Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
zoran_card.c
Go to the documentation of this file.
1 /*
2  * Zoran zr36057/zr36067 PCI controller driver, for the
3  * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
4  * Media Labs LML33/LML33R10.
5  *
6  * This part handles card-specific data and detection
7  *
8  * Copyright (C) 2000 Serguei Miridonov <[email protected]>
9  *
10  * Currently maintained by:
11  * Ronald Bultje <[email protected]>
12  * Laurent Pinchart <[email protected]>
13  * Mailinglist <[email protected]>
14  *
15  * This program is free software; you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation; either version 2 of the License, or
18  * (at your option) any later version.
19  *
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, write to the Free Software
27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28  */
29 
30 #include <linux/delay.h>
31 
32 #include <linux/types.h>
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/vmalloc.h>
37 #include <linux/slab.h>
38 
39 #include <linux/proc_fs.h>
40 #include <linux/i2c.h>
41 #include <linux/i2c-algo-bit.h>
42 #include <linux/videodev2.h>
43 #include <linux/spinlock.h>
44 #include <linux/sem.h>
45 #include <linux/kmod.h>
46 #include <linux/wait.h>
47 
48 #include <linux/pci.h>
49 #include <linux/interrupt.h>
50 #include <linux/mutex.h>
51 #include <linux/io.h>
52 #include <media/v4l2-common.h>
53 #include <media/bt819.h>
54 
55 #include "videocodec.h"
56 #include "zoran.h"
57 #include "zoran_card.h"
58 #include "zoran_device.h"
59 #include "zoran_procfs.h"
60 
61 extern const struct zoran_format zoran_formats[];
62 
63 static int card[BUZ_MAX] = { [0 ... (BUZ_MAX-1)] = -1 };
64 module_param_array(card, int, NULL, 0444);
65 MODULE_PARM_DESC(card, "Card type");
66 
67 /*
68  The video mem address of the video card.
69  The driver has a little database for some videocards
70  to determine it from there. If your video card is not in there
71  you have either to give it to the driver as a parameter
72  or set in in a VIDIOCSFBUF ioctl
73  */
74 
75 static unsigned long vidmem; /* default = 0 - Video memory base address */
76 module_param(vidmem, ulong, 0444);
77 MODULE_PARM_DESC(vidmem, "Default video memory base address");
78 
79 /*
80  Default input and video norm at startup of the driver.
81 */
82 
83 static unsigned int default_input; /* default 0 = Composite, 1 = S-Video */
84 module_param(default_input, uint, 0444);
85 MODULE_PARM_DESC(default_input,
86  "Default input (0=Composite, 1=S-Video, 2=Internal)");
87 
88 static int default_mux = 1; /* 6 Eyes input selection */
89 module_param(default_mux, int, 0644);
90 MODULE_PARM_DESC(default_mux,
91  "Default 6 Eyes mux setting (Input selection)");
92 
93 static int default_norm; /* default 0 = PAL, 1 = NTSC 2 = SECAM */
94 module_param(default_norm, int, 0444);
95 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
96 
97 /* /dev/videoN, -1 for autodetect */
98 static int video_nr[BUZ_MAX] = { [0 ... (BUZ_MAX-1)] = -1 };
99 module_param_array(video_nr, int, NULL, 0444);
100 MODULE_PARM_DESC(video_nr, "Video device number (-1=Auto)");
101 
102 int v4l_nbufs = 4;
103 int v4l_bufsize = 864; /* Everybody should be able to work with this setting */
104 module_param(v4l_nbufs, int, 0644);
105 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
106 module_param(v4l_bufsize, int, 0644);
107 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
108 
109 int jpg_nbufs = 32;
110 int jpg_bufsize = 512; /* max size for 100% quality full-PAL frame */
111 module_param(jpg_nbufs, int, 0644);
112 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
113 module_param(jpg_bufsize, int, 0644);
114 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
115 
116 int pass_through = 0; /* 1=Pass through TV signal when device is not used */
117  /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
118 module_param(pass_through, int, 0644);
119 MODULE_PARM_DESC(pass_through,
120  "Pass TV signal through to TV-out when idling");
121 
122 int zr36067_debug = 1;
123 module_param_named(debug, zr36067_debug, int, 0644);
124 MODULE_PARM_DESC(debug, "Debug level (0-5)");
125 
126 #define ZORAN_VERSION "0.10.1"
127 
128 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
129 MODULE_AUTHOR("Serguei Miridonov");
130 MODULE_LICENSE("GPL");
131 MODULE_VERSION(ZORAN_VERSION);
132 
133 #define ZR_DEVICE(subven, subdev, data) { \
134  .vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \
135  .subvendor = (subven), .subdevice = (subdev), .driver_data = (data) }
136 
137 static struct pci_device_id zr36067_pci_tbl[] = {
138  ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC10PLUS, DC10plus),
139  ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC30PLUS, DC30plus),
140  ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH, PCI_DEVICE_ID_LML_33R10, LML33R10),
141  ZR_DEVICE(PCI_VENDOR_ID_IOMEGA, PCI_DEVICE_ID_IOMEGA_BUZ, BUZ),
142  ZR_DEVICE(PCI_ANY_ID, PCI_ANY_ID, NUM_CARDS),
143  {0}
144 };
145 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
146 
147 static unsigned int zoran_num; /* number of cards found */
148 
149 /* videocodec bus functions ZR36060 */
150 static u32
151 zr36060_read (struct videocodec *codec,
152  u16 reg)
153 {
154  struct zoran *zr = (struct zoran *) codec->master_data->data;
155  __u32 data;
156 
157  if (post_office_wait(zr)
158  || post_office_write(zr, 0, 1, reg >> 8)
159  || post_office_write(zr, 0, 2, reg & 0xff)) {
160  return -1;
161  }
162 
163  data = post_office_read(zr, 0, 3) & 0xff;
164  return data;
165 }
166 
167 static void
168 zr36060_write (struct videocodec *codec,
169  u16 reg,
170  u32 val)
171 {
172  struct zoran *zr = (struct zoran *) codec->master_data->data;
173 
174  if (post_office_wait(zr)
175  || post_office_write(zr, 0, 1, reg >> 8)
176  || post_office_write(zr, 0, 2, reg & 0xff)) {
177  return;
178  }
179 
180  post_office_write(zr, 0, 3, val & 0xff);
181 }
182 
183 /* videocodec bus functions ZR36050 */
184 static u32
185 zr36050_read (struct videocodec *codec,
186  u16 reg)
187 {
188  struct zoran *zr = (struct zoran *) codec->master_data->data;
189  __u32 data;
190 
191  if (post_office_wait(zr)
192  || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
193  return -1;
194  }
195 
196  data = post_office_read(zr, 0, reg & 0x03) & 0xff; // reg. LOWBYTES + read
197  return data;
198 }
199 
200 static void
201 zr36050_write (struct videocodec *codec,
202  u16 reg,
203  u32 val)
204 {
205  struct zoran *zr = (struct zoran *) codec->master_data->data;
206 
207  if (post_office_wait(zr)
208  || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
209  return;
210  }
211 
212  post_office_write(zr, 0, reg & 0x03, val & 0xff); // reg. LOWBYTES + wr. data
213 }
214 
215 /* videocodec bus functions ZR36016 */
216 static u32
217 zr36016_read (struct videocodec *codec,
218  u16 reg)
219 {
220  struct zoran *zr = (struct zoran *) codec->master_data->data;
221  __u32 data;
222 
223  if (post_office_wait(zr)) {
224  return -1;
225  }
226 
227  data = post_office_read(zr, 2, reg & 0x03) & 0xff; // read
228  return data;
229 }
230 
231 /* hack for in zoran_device.c */
232 void
233 zr36016_write (struct videocodec *codec,
234  u16 reg,
235  u32 val)
236 {
237  struct zoran *zr = (struct zoran *) codec->master_data->data;
238 
239  if (post_office_wait(zr)) {
240  return;
241  }
242 
243  post_office_write(zr, 2, reg & 0x03, val & 0x0ff); // wr. data
244 }
245 
246 /*
247  * Board specific information
248  */
249 
250 static void
251 dc10_init (struct zoran *zr)
252 {
253  dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
254 
255  /* Pixel clock selection */
256  GPIO(zr, 4, 0);
257  GPIO(zr, 5, 1);
258  /* Enable the video bus sync signals */
259  GPIO(zr, 7, 0);
260 }
261 
262 static void
263 dc10plus_init (struct zoran *zr)
264 {
265  dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
266 }
267 
268 static void
269 buz_init (struct zoran *zr)
270 {
271  dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
272 
273  /* some stuff from Iomega */
274  pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
275  pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
276  pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
277 }
278 
279 static void
280 lml33_init (struct zoran *zr)
281 {
282  dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
283 
284  GPIO(zr, 2, 1); // Set Composite input/output
285 }
286 
287 static void
288 avs6eyes_init (struct zoran *zr)
289 {
290  // AverMedia 6-Eyes original driver by Christer Weinigel
291 
292  // Lifted straight from Christer's old driver and
293  // modified slightly by Martin Samuelsson.
294 
295  int mux = default_mux; /* 1 = BT866, 7 = VID1 */
296 
297  GPIO(zr, 4, 1); /* Bt866 SLEEP on */
298  udelay(2);
299 
300  GPIO(zr, 0, 1); /* ZR36060 /RESET on */
301  GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
302  GPIO(zr, 2, mux & 1); /* MUX S0 */
303  GPIO(zr, 3, 0); /* /FRAME on */
304  GPIO(zr, 4, 0); /* Bt866 SLEEP off */
305  GPIO(zr, 5, mux & 2); /* MUX S1 */
306  GPIO(zr, 6, 0); /* ? */
307  GPIO(zr, 7, mux & 4); /* MUX S2 */
308 
309 }
310 
311 static char *
312 codecid_to_modulename (u16 codecid)
313 {
314  char *name = NULL;
315 
316  switch (codecid) {
317  case CODEC_TYPE_ZR36060:
318  name = "zr36060";
319  break;
320  case CODEC_TYPE_ZR36050:
321  name = "zr36050";
322  break;
323  case CODEC_TYPE_ZR36016:
324  name = "zr36016";
325  break;
326  }
327 
328  return name;
329 }
330 
331 // struct tvnorm {
332 // u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
333 // };
334 
335 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
336 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
337 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
338 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
339 
340 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
341 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
342 
343 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
344 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
345 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
346 
347 /* FIXME: I cannot swap U and V in saa7114, so i do one
348  * pixel left shift in zoran (75 -> 74)
349  * (Maxim Yevtyushkin <[email protected]>) */
350 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
351 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
352 
353 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
354  * copy Maxim's left shift hack for the 6 Eyes.
355  *
356  * Christer's driver used the unshifted norms, though...
357  * /Sam */
358 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
359 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
360 
361 static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END };
362 static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END };
363 static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END };
364 static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END };
365 static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END };
366 static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END };
367 static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END };
368 static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END };
369 static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END };
370 static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END };
371 
372 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
373  {
374  .type = DC10_old,
375  .name = "DC10(old)",
376  .i2c_decoder = "vpx3220a",
377  .addrs_decoder = vpx3220_addrs,
378  .video_codec = CODEC_TYPE_ZR36050,
379  .video_vfe = CODEC_TYPE_ZR36016,
380 
381  .inputs = 3,
382  .input = {
383  { 1, "Composite" },
384  { 2, "S-Video" },
385  { 0, "Internal/comp" }
386  },
387  .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
388  .tvn = {
389  &f50sqpixel_dc10,
390  &f60sqpixel_dc10,
391  &f50sqpixel_dc10
392  },
393  .jpeg_int = 0,
394  .vsync_int = ZR36057_ISR_GIRQ1,
395  .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
396  .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
397  .gpcs = { -1, 0 },
398  .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
399  .gws_not_connected = 0,
400  .input_mux = 0,
401  .init = &dc10_init,
402  }, {
403  .type = DC10_new,
404  .name = "DC10(new)",
405  .i2c_decoder = "saa7110",
406  .addrs_decoder = saa7110_addrs,
407  .i2c_encoder = "adv7175",
408  .addrs_encoder = adv717x_addrs,
409  .video_codec = CODEC_TYPE_ZR36060,
410 
411  .inputs = 3,
412  .input = {
413  { 0, "Composite" },
414  { 7, "S-Video" },
415  { 5, "Internal/comp" }
416  },
417  .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
418  .tvn = {
419  &f50sqpixel,
420  &f60sqpixel,
421  &f50sqpixel},
422  .jpeg_int = ZR36057_ISR_GIRQ0,
423  .vsync_int = ZR36057_ISR_GIRQ1,
424  .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
425  .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
426  .gpcs = { -1, 1},
427  .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
428  .gws_not_connected = 0,
429  .input_mux = 0,
430  .init = &dc10plus_init,
431  }, {
432  .type = DC10plus,
433  .name = "DC10plus",
434  .i2c_decoder = "saa7110",
435  .addrs_decoder = saa7110_addrs,
436  .i2c_encoder = "adv7175",
437  .addrs_encoder = adv717x_addrs,
438  .video_codec = CODEC_TYPE_ZR36060,
439 
440  .inputs = 3,
441  .input = {
442  { 0, "Composite" },
443  { 7, "S-Video" },
444  { 5, "Internal/comp" }
445  },
446  .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
447  .tvn = {
448  &f50sqpixel,
449  &f60sqpixel,
450  &f50sqpixel
451  },
452  .jpeg_int = ZR36057_ISR_GIRQ0,
453  .vsync_int = ZR36057_ISR_GIRQ1,
454  .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
455  .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
456  .gpcs = { -1, 1 },
457  .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
458  .gws_not_connected = 0,
459  .input_mux = 0,
460  .init = &dc10plus_init,
461  }, {
462  .type = DC30,
463  .name = "DC30",
464  .i2c_decoder = "vpx3220a",
465  .addrs_decoder = vpx3220_addrs,
466  .i2c_encoder = "adv7175",
467  .addrs_encoder = adv717x_addrs,
468  .video_codec = CODEC_TYPE_ZR36050,
469  .video_vfe = CODEC_TYPE_ZR36016,
470 
471  .inputs = 3,
472  .input = {
473  { 1, "Composite" },
474  { 2, "S-Video" },
475  { 0, "Internal/comp" }
476  },
477  .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
478  .tvn = {
479  &f50sqpixel_dc10,
480  &f60sqpixel_dc10,
481  &f50sqpixel_dc10
482  },
483  .jpeg_int = 0,
484  .vsync_int = ZR36057_ISR_GIRQ1,
485  .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
486  .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
487  .gpcs = { -1, 0 },
488  .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
489  .gws_not_connected = 0,
490  .input_mux = 0,
491  .init = &dc10_init,
492  }, {
493  .type = DC30plus,
494  .name = "DC30plus",
495  .i2c_decoder = "vpx3220a",
496  .addrs_decoder = vpx3220_addrs,
497  .i2c_encoder = "adv7175",
498  .addrs_encoder = adv717x_addrs,
499  .video_codec = CODEC_TYPE_ZR36050,
500  .video_vfe = CODEC_TYPE_ZR36016,
501 
502  .inputs = 3,
503  .input = {
504  { 1, "Composite" },
505  { 2, "S-Video" },
506  { 0, "Internal/comp" }
507  },
508  .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
509  .tvn = {
510  &f50sqpixel_dc10,
511  &f60sqpixel_dc10,
512  &f50sqpixel_dc10
513  },
514  .jpeg_int = 0,
515  .vsync_int = ZR36057_ISR_GIRQ1,
516  .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
517  .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
518  .gpcs = { -1, 0 },
519  .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
520  .gws_not_connected = 0,
521  .input_mux = 0,
522  .init = &dc10_init,
523  }, {
524  .type = LML33,
525  .name = "LML33",
526  .i2c_decoder = "bt819a",
527  .addrs_decoder = bt819_addrs,
528  .i2c_encoder = "bt856",
529  .addrs_encoder = bt856_addrs,
530  .video_codec = CODEC_TYPE_ZR36060,
531 
532  .inputs = 2,
533  .input = {
534  { 0, "Composite" },
535  { 7, "S-Video" }
536  },
537  .norms = V4L2_STD_NTSC|V4L2_STD_PAL,
538  .tvn = {
539  &f50ccir601_lml33,
540  &f60ccir601_lml33,
541  NULL
542  },
543  .jpeg_int = ZR36057_ISR_GIRQ1,
544  .vsync_int = ZR36057_ISR_GIRQ0,
545  .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
546  .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
547  .gpcs = { 3, 1 },
548  .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
549  .gws_not_connected = 1,
550  .input_mux = 0,
551  .init = &lml33_init,
552  }, {
553  .type = LML33R10,
554  .name = "LML33R10",
555  .i2c_decoder = "saa7114",
556  .addrs_decoder = saa7114_addrs,
557  .i2c_encoder = "adv7170",
558  .addrs_encoder = adv717x_addrs,
559  .video_codec = CODEC_TYPE_ZR36060,
560 
561  .inputs = 2,
562  .input = {
563  { 0, "Composite" },
564  { 7, "S-Video" }
565  },
566  .norms = V4L2_STD_NTSC|V4L2_STD_PAL,
567  .tvn = {
568  &f50ccir601_lm33r10,
569  &f60ccir601_lm33r10,
570  NULL
571  },
572  .jpeg_int = ZR36057_ISR_GIRQ1,
573  .vsync_int = ZR36057_ISR_GIRQ0,
574  .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
575  .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
576  .gpcs = { 3, 1 },
577  .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
578  .gws_not_connected = 1,
579  .input_mux = 0,
580  .init = &lml33_init,
581  }, {
582  .type = BUZ,
583  .name = "Buz",
584  .i2c_decoder = "saa7111",
585  .addrs_decoder = saa7111_addrs,
586  .i2c_encoder = "saa7185",
587  .addrs_encoder = saa7185_addrs,
588  .video_codec = CODEC_TYPE_ZR36060,
589 
590  .inputs = 2,
591  .input = {
592  { 3, "Composite" },
593  { 7, "S-Video" }
594  },
595  .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
596  .tvn = {
597  &f50ccir601,
598  &f60ccir601,
599  &f50ccir601
600  },
601  .jpeg_int = ZR36057_ISR_GIRQ1,
602  .vsync_int = ZR36057_ISR_GIRQ0,
603  .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
604  .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
605  .gpcs = { 3, 1 },
606  .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
607  .gws_not_connected = 1,
608  .input_mux = 0,
609  .init = &buz_init,
610  }, {
611  .type = AVS6EYES,
612  .name = "6-Eyes",
613  /* AverMedia chose not to brand the 6-Eyes. Thus it
614  can't be autodetected, and requires card=x. */
615  .i2c_decoder = "ks0127",
616  .addrs_decoder = ks0127_addrs,
617  .i2c_encoder = "bt866",
618  .addrs_encoder = bt866_addrs,
619  .video_codec = CODEC_TYPE_ZR36060,
620 
621  .inputs = 10,
622  .input = {
623  { 0, "Composite 1" },
624  { 1, "Composite 2" },
625  { 2, "Composite 3" },
626  { 4, "Composite 4" },
627  { 5, "Composite 5" },
628  { 6, "Composite 6" },
629  { 8, "S-Video 1" },
630  { 9, "S-Video 2" },
631  {10, "S-Video 3" },
632  {15, "YCbCr" }
633  },
634  .norms = V4L2_STD_NTSC|V4L2_STD_PAL,
635  .tvn = {
636  &f50ccir601_avs6eyes,
637  &f60ccir601_avs6eyes,
638  NULL
639  },
640  .jpeg_int = ZR36057_ISR_GIRQ1,
641  .vsync_int = ZR36057_ISR_GIRQ0,
642  .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
643  .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
644  .gpcs = { 3, 1 }, // Validity unknown /Sam
645  .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam
646  .gws_not_connected = 1,
647  .input_mux = 1,
648  .init = &avs6eyes_init,
649  }
650 
651 };
652 
653 /*
654  * I2C functions
655  */
656 /* software I2C functions */
657 static int
658 zoran_i2c_getsda (void *data)
659 {
660  struct zoran *zr = (struct zoran *) data;
661 
662  return (btread(ZR36057_I2CBR) >> 1) & 1;
663 }
664 
665 static int
666 zoran_i2c_getscl (void *data)
667 {
668  struct zoran *zr = (struct zoran *) data;
669 
670  return btread(ZR36057_I2CBR) & 1;
671 }
672 
673 static void
674 zoran_i2c_setsda (void *data,
675  int state)
676 {
677  struct zoran *zr = (struct zoran *) data;
678 
679  if (state)
680  zr->i2cbr |= 2;
681  else
682  zr->i2cbr &= ~2;
683  btwrite(zr->i2cbr, ZR36057_I2CBR);
684 }
685 
686 static void
687 zoran_i2c_setscl (void *data,
688  int state)
689 {
690  struct zoran *zr = (struct zoran *) data;
691 
692  if (state)
693  zr->i2cbr |= 1;
694  else
695  zr->i2cbr &= ~1;
696  btwrite(zr->i2cbr, ZR36057_I2CBR);
697 }
698 
699 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
700  .setsda = zoran_i2c_setsda,
701  .setscl = zoran_i2c_setscl,
702  .getsda = zoran_i2c_getsda,
703  .getscl = zoran_i2c_getscl,
704  .udelay = 10,
705  .timeout = 100,
706 };
707 
708 static int
709 zoran_register_i2c (struct zoran *zr)
710 {
711  memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
712  sizeof(struct i2c_algo_bit_data));
713  zr->i2c_algo.data = zr;
714  strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
715  sizeof(zr->i2c_adapter.name));
716  i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
717  zr->i2c_adapter.algo_data = &zr->i2c_algo;
718  zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
719  return i2c_bit_add_bus(&zr->i2c_adapter);
720 }
721 
722 static void
723 zoran_unregister_i2c (struct zoran *zr)
724 {
725  i2c_del_adapter(&zr->i2c_adapter);
726 }
727 
728 /* Check a zoran_params struct for correctness, insert default params */
729 
730 int
731 zoran_check_jpg_settings (struct zoran *zr,
732  struct zoran_jpg_settings *settings,
733  int try)
734 {
735  int err = 0, err0 = 0;
736 
737  dprintk(4,
738  KERN_DEBUG
739  "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
740  ZR_DEVNAME(zr), __func__, settings->decimation, settings->HorDcm,
741  settings->VerDcm, settings->TmpDcm);
742  dprintk(4,
743  KERN_DEBUG
744  "%s: %s - x: %d, y: %d, w: %d, y: %d\n",
745  ZR_DEVNAME(zr), __func__, settings->img_x, settings->img_y,
746  settings->img_width, settings->img_height);
747  /* Check decimation, set default values for decimation = 1, 2, 4 */
748  switch (settings->decimation) {
749  case 1:
750 
751  settings->HorDcm = 1;
752  settings->VerDcm = 1;
753  settings->TmpDcm = 1;
754  settings->field_per_buff = 2;
755  settings->img_x = 0;
756  settings->img_y = 0;
757  settings->img_width = BUZ_MAX_WIDTH;
758  settings->img_height = BUZ_MAX_HEIGHT / 2;
759  break;
760  case 2:
761 
762  settings->HorDcm = 2;
763  settings->VerDcm = 1;
764  settings->TmpDcm = 2;
765  settings->field_per_buff = 1;
766  settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
767  settings->img_y = 0;
768  settings->img_width =
769  (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
770  settings->img_height = BUZ_MAX_HEIGHT / 2;
771  break;
772  case 4:
773 
774  if (zr->card.type == DC10_new) {
775  dprintk(1,
776  KERN_DEBUG
777  "%s: %s - HDec by 4 is not supported on the DC10\n",
778  ZR_DEVNAME(zr), __func__);
779  err0++;
780  break;
781  }
782 
783  settings->HorDcm = 4;
784  settings->VerDcm = 2;
785  settings->TmpDcm = 2;
786  settings->field_per_buff = 1;
787  settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
788  settings->img_y = 0;
789  settings->img_width =
790  (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
791  settings->img_height = BUZ_MAX_HEIGHT / 2;
792  break;
793  case 0:
794 
795  /* We have to check the data the user has set */
796 
797  if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
798  (zr->card.type == DC10_new || settings->HorDcm != 4)) {
799  settings->HorDcm = clamp(settings->HorDcm, 1, 2);
800  err0++;
801  }
802  if (settings->VerDcm != 1 && settings->VerDcm != 2) {
803  settings->VerDcm = clamp(settings->VerDcm, 1, 2);
804  err0++;
805  }
806  if (settings->TmpDcm != 1 && settings->TmpDcm != 2) {
807  settings->TmpDcm = clamp(settings->TmpDcm, 1, 2);
808  err0++;
809  }
810  if (settings->field_per_buff != 1 &&
811  settings->field_per_buff != 2) {
812  settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
813  err0++;
814  }
815  if (settings->img_x < 0) {
816  settings->img_x = 0;
817  err0++;
818  }
819  if (settings->img_y < 0) {
820  settings->img_y = 0;
821  err0++;
822  }
823  if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
824  settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
825  err0++;
826  }
827  if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
828  settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
829  err0++;
830  }
831  if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
832  settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
833  err0++;
834  }
835  if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
836  settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
837  err0++;
838  }
839  if (settings->img_width % (16 * settings->HorDcm) != 0) {
840  settings->img_width -= settings->img_width % (16 * settings->HorDcm);
841  if (settings->img_width == 0)
842  settings->img_width = 16 * settings->HorDcm;
843  err0++;
844  }
845  if (settings->img_height % (8 * settings->VerDcm) != 0) {
846  settings->img_height -= settings->img_height % (8 * settings->VerDcm);
847  if (settings->img_height == 0)
848  settings->img_height = 8 * settings->VerDcm;
849  err0++;
850  }
851 
852  if (!try && err0) {
853  dprintk(1,
854  KERN_ERR
855  "%s: %s - error in params for decimation = 0\n",
856  ZR_DEVNAME(zr), __func__);
857  err++;
858  }
859  break;
860  default:
861  dprintk(1,
862  KERN_ERR
863  "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n",
864  ZR_DEVNAME(zr), __func__, settings->decimation);
865  err++;
866  break;
867  }
868 
869  if (settings->jpg_comp.quality > 100)
870  settings->jpg_comp.quality = 100;
871  if (settings->jpg_comp.quality < 5)
872  settings->jpg_comp.quality = 5;
873  if (settings->jpg_comp.APPn < 0)
874  settings->jpg_comp.APPn = 0;
875  if (settings->jpg_comp.APPn > 15)
876  settings->jpg_comp.APPn = 15;
877  if (settings->jpg_comp.APP_len < 0)
878  settings->jpg_comp.APP_len = 0;
879  if (settings->jpg_comp.APP_len > 60)
880  settings->jpg_comp.APP_len = 60;
881  if (settings->jpg_comp.COM_len < 0)
882  settings->jpg_comp.COM_len = 0;
883  if (settings->jpg_comp.COM_len > 60)
884  settings->jpg_comp.COM_len = 60;
885  if (err)
886  return -EINVAL;
887  return 0;
888 }
889 
890 void
891 zoran_open_init_params (struct zoran *zr)
892 {
893  int i;
894 
895  /* User must explicitly set a window */
896  zr->overlay_settings.is_set = 0;
897  zr->overlay_mask = NULL;
898  zr->overlay_active = ZORAN_FREE;
899 
900  zr->v4l_memgrab_active = 0;
901  zr->v4l_overlay_active = 0;
902  zr->v4l_grab_frame = NO_GRAB_ACTIVE;
903  zr->v4l_grab_seq = 0;
904  zr->v4l_settings.width = 192;
905  zr->v4l_settings.height = 144;
906  zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */
907  zr->v4l_settings.bytesperline =
908  zr->v4l_settings.width *
909  ((zr->v4l_settings.format->depth + 7) / 8);
910 
911  /* DMA ring stuff for V4L */
912  zr->v4l_pend_tail = 0;
913  zr->v4l_pend_head = 0;
914  zr->v4l_sync_tail = 0;
915  zr->v4l_buffers.active = ZORAN_FREE;
916  for (i = 0; i < VIDEO_MAX_FRAME; i++) {
917  zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
918  }
919  zr->v4l_buffers.allocated = 0;
920 
921  for (i = 0; i < BUZ_MAX_FRAME; i++) {
922  zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
923  }
924  zr->jpg_buffers.active = ZORAN_FREE;
925  zr->jpg_buffers.allocated = 0;
926  /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
927  zr->jpg_settings.decimation = 1;
928  zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
929  if (zr->card.type != BUZ)
930  zr->jpg_settings.odd_even = 1;
931  else
932  zr->jpg_settings.odd_even = 0;
933  zr->jpg_settings.jpg_comp.APPn = 0;
934  zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
935  memset(zr->jpg_settings.jpg_comp.APP_data, 0,
936  sizeof(zr->jpg_settings.jpg_comp.APP_data));
937  zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
938  memset(zr->jpg_settings.jpg_comp.COM_data, 0,
939  sizeof(zr->jpg_settings.jpg_comp.COM_data));
940  zr->jpg_settings.jpg_comp.jpeg_markers =
941  V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT;
942  i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
943  if (i)
944  dprintk(1, KERN_ERR "%s: %s internal error\n",
945  ZR_DEVNAME(zr), __func__);
946 
947  clear_interrupt_counters(zr);
948  zr->testing = 0;
949 }
950 
951 static void __devinit
952 test_interrupts (struct zoran *zr)
953 {
954  DEFINE_WAIT(wait);
955  int timeout, icr;
956 
957  clear_interrupt_counters(zr);
958 
959  zr->testing = 1;
960  icr = btread(ZR36057_ICR);
961  btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
962  prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
963  timeout = schedule_timeout(HZ);
964  finish_wait(&zr->test_q, &wait);
965  btwrite(0, ZR36057_ICR);
966  btwrite(0x78000000, ZR36057_ISR);
967  zr->testing = 0;
968  dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
969  if (timeout) {
970  dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
971  }
972  if (zr36067_debug > 1)
973  print_interrupts(zr);
974  btwrite(icr, ZR36057_ICR);
975 }
976 
977 static int __devinit
978 zr36057_init (struct zoran *zr)
979 {
980  int j, err;
981 
982  dprintk(1,
983  KERN_INFO
984  "%s: %s - initializing card[%d], zr=%p\n",
985  ZR_DEVNAME(zr), __func__, zr->id, zr);
986 
987  /* default setup of all parameters which will persist between opens */
988  zr->user = 0;
989 
990  init_waitqueue_head(&zr->v4l_capq);
991  init_waitqueue_head(&zr->jpg_capq);
992  init_waitqueue_head(&zr->test_q);
993  zr->jpg_buffers.allocated = 0;
994  zr->v4l_buffers.allocated = 0;
995 
996  zr->vbuf_base = (void *) vidmem;
997  zr->vbuf_width = 0;
998  zr->vbuf_height = 0;
999  zr->vbuf_depth = 0;
1000  zr->vbuf_bytesperline = 0;
1001 
1002  /* Avoid nonsense settings from user for default input/norm */
1003  if (default_norm < 0 || default_norm > 2)
1004  default_norm = 0;
1005  if (default_norm == 0) {
1006  zr->norm = V4L2_STD_PAL;
1007  zr->timing = zr->card.tvn[0];
1008  } else if (default_norm == 1) {
1009  zr->norm = V4L2_STD_NTSC;
1010  zr->timing = zr->card.tvn[1];
1011  } else {
1012  zr->norm = V4L2_STD_SECAM;
1013  zr->timing = zr->card.tvn[2];
1014  }
1015  if (zr->timing == NULL) {
1016  dprintk(1,
1017  KERN_WARNING
1018  "%s: %s - default TV standard not supported by hardware. PAL will be used.\n",
1019  ZR_DEVNAME(zr), __func__);
1020  zr->norm = V4L2_STD_PAL;
1021  zr->timing = zr->card.tvn[0];
1022  }
1023 
1024  if (default_input > zr->card.inputs-1) {
1025  dprintk(1,
1026  KERN_WARNING
1027  "%s: default_input value %d out of range (0-%d)\n",
1028  ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1029  default_input = 0;
1030  }
1031  zr->input = default_input;
1032 
1033  /* default setup (will be repeated at every open) */
1034  zoran_open_init_params(zr);
1035 
1036  /* allocate memory *before* doing anything to the hardware
1037  * in case allocation fails */
1038  zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1039  zr->video_dev = video_device_alloc();
1040  if (!zr->stat_com || !zr->video_dev) {
1041  dprintk(1,
1042  KERN_ERR
1043  "%s: %s - kmalloc (STAT_COM) failed\n",
1044  ZR_DEVNAME(zr), __func__);
1045  err = -ENOMEM;
1046  goto exit_free;
1047  }
1048  for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1049  zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1050  }
1051 
1052  /*
1053  * Now add the template and register the device unit.
1054  */
1055  memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1056  zr->video_dev->parent = &zr->pci_dev->dev;
1057  strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1058  /* It's not a mem2mem device, but you can both capture and output from
1059  one and the same device. This should really be split up into two
1060  device nodes, but that's a job for another day. */
1061  zr->video_dev->vfl_dir = VFL_DIR_M2M;
1062  err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1063  if (err < 0)
1064  goto exit_free;
1065  video_set_drvdata(zr->video_dev, zr);
1066 
1067  zoran_init_hardware(zr);
1068  if (zr36067_debug > 2)
1069  detect_guest_activity(zr);
1070  test_interrupts(zr);
1071  if (!pass_through) {
1072  decoder_call(zr, video, s_stream, 0);
1073  encoder_call(zr, video, s_routing, 2, 0, 0);
1074  }
1075 
1076  zr->zoran_proc = NULL;
1077  zr->initialized = 1;
1078  return 0;
1079 
1080 exit_free:
1081  kfree(zr->stat_com);
1082  kfree(zr->video_dev);
1083  return err;
1084 }
1085 
1086 static void __devexit zoran_remove(struct pci_dev *pdev)
1087 {
1088  struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1089  struct zoran *zr = to_zoran(v4l2_dev);
1090 
1091  if (!zr->initialized)
1092  goto exit_free;
1093 
1094  /* unregister videocodec bus */
1095  if (zr->codec) {
1096  struct videocodec_master *master = zr->codec->master_data;
1097 
1098  videocodec_detach(zr->codec);
1099  kfree(master);
1100  }
1101  if (zr->vfe) {
1102  struct videocodec_master *master = zr->vfe->master_data;
1103 
1104  videocodec_detach(zr->vfe);
1105  kfree(master);
1106  }
1107 
1108  /* unregister i2c bus */
1109  zoran_unregister_i2c(zr);
1110  /* disable PCI bus-mastering */
1111  zoran_set_pci_master(zr, 0);
1112  /* put chip into reset */
1113  btwrite(0, ZR36057_SPGPPCR);
1114  free_irq(zr->pci_dev->irq, zr);
1115  /* unmap and free memory */
1116  kfree(zr->stat_com);
1117  zoran_proc_cleanup(zr);
1118  iounmap(zr->zr36057_mem);
1119  pci_disable_device(zr->pci_dev);
1120  video_unregister_device(zr->video_dev);
1121 exit_free:
1122  v4l2_device_unregister(&zr->v4l2_dev);
1123  kfree(zr);
1124 }
1125 
1126 void
1127 zoran_vdev_release (struct video_device *vdev)
1128 {
1129  kfree(vdev);
1130 }
1131 
1132 static struct videocodec_master * __devinit
1133 zoran_setup_videocodec (struct zoran *zr,
1134  int type)
1135 {
1136  struct videocodec_master *m = NULL;
1137 
1138  m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1139  if (!m) {
1140  dprintk(1, KERN_ERR "%s: %s - no memory\n",
1141  ZR_DEVNAME(zr), __func__);
1142  return m;
1143  }
1144 
1145  /* magic and type are unused for master struct. Makes sense only at
1146  codec structs.
1147  In the past, .type were initialized to the old V4L1 .hardware
1148  value, as VID_HARDWARE_ZR36067
1149  */
1150  m->magic = 0L;
1151  m->type = 0;
1152 
1153  m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1154  strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1155  m->data = zr;
1156 
1157  switch (type)
1158  {
1159  case CODEC_TYPE_ZR36060:
1160  m->readreg = zr36060_read;
1161  m->writereg = zr36060_write;
1162  m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1163  break;
1164  case CODEC_TYPE_ZR36050:
1165  m->readreg = zr36050_read;
1166  m->writereg = zr36050_write;
1167  m->flags |= CODEC_FLAG_JPEG;
1168  break;
1169  case CODEC_TYPE_ZR36016:
1170  m->readreg = zr36016_read;
1171  m->writereg = zr36016_write;
1172  m->flags |= CODEC_FLAG_VFE;
1173  break;
1174  }
1175 
1176  return m;
1177 }
1178 
1179 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1180 {
1181  struct zoran *zr = to_zoran(sd->v4l2_dev);
1182 
1183  /* Bt819 needs to reset its FIFO buffer using #FRST pin and
1184  LML33 card uses GPIO(7) for that. */
1185  if (cmd == BT819_FIFO_RESET_LOW)
1186  GPIO(zr, 7, 0);
1187  else if (cmd == BT819_FIFO_RESET_HIGH)
1188  GPIO(zr, 7, 1);
1189 }
1190 
1191 /*
1192  * Scan for a Buz card (actually for the PCI controller ZR36057),
1193  * request the irq and map the io memory
1194  */
1195 static int __devinit zoran_probe(struct pci_dev *pdev,
1196  const struct pci_device_id *ent)
1197 {
1198  unsigned char latency, need_latency;
1199  struct zoran *zr;
1200  int result;
1201  struct videocodec_master *master_vfe = NULL;
1202  struct videocodec_master *master_codec = NULL;
1203  int card_num;
1204  char *codec_name, *vfe_name;
1205  unsigned int nr;
1206 
1207 
1208  nr = zoran_num++;
1209  if (nr >= BUZ_MAX) {
1210  dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n",
1211  ZORAN_NAME, BUZ_MAX);
1212  return -ENOENT;
1213  }
1214 
1215  zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1216  if (!zr) {
1217  dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n",
1218  ZORAN_NAME, __func__);
1219  return -ENOMEM;
1220  }
1221  zr->v4l2_dev.notify = zoran_subdev_notify;
1222  if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1223  goto zr_free_mem;
1224  zr->pci_dev = pdev;
1225  zr->id = nr;
1226  snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1227  spin_lock_init(&zr->spinlock);
1228  mutex_init(&zr->resource_lock);
1229  mutex_init(&zr->other_lock);
1230  if (pci_enable_device(pdev))
1231  goto zr_unreg;
1232  zr->revision = zr->pci_dev->revision;
1233 
1234  dprintk(1,
1235  KERN_INFO
1236  "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1237  ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision,
1238  zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1239  if (zr->revision >= 2) {
1240  dprintk(1,
1241  KERN_INFO
1242  "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1243  ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor,
1244  zr->pci_dev->subsystem_device);
1245  }
1246 
1247  /* Use auto-detected card type? */
1248  if (card[nr] == -1) {
1249  if (zr->revision < 2) {
1250  dprintk(1,
1251  KERN_ERR
1252  "%s: No card type specified, please use the card=X module parameter\n",
1253  ZR_DEVNAME(zr));
1254  dprintk(1,
1255  KERN_ERR
1256  "%s: It is not possible to auto-detect ZR36057 based cards\n",
1257  ZR_DEVNAME(zr));
1258  goto zr_unreg;
1259  }
1260 
1261  card_num = ent->driver_data;
1262  if (card_num >= NUM_CARDS) {
1263  dprintk(1,
1264  KERN_ERR
1265  "%s: Unknown card, try specifying card=X module parameter\n",
1266  ZR_DEVNAME(zr));
1267  goto zr_unreg;
1268  }
1269  dprintk(3,
1270  KERN_DEBUG
1271  "%s: %s() - card %s detected\n",
1272  ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name);
1273  } else {
1274  card_num = card[nr];
1275  if (card_num >= NUM_CARDS || card_num < 0) {
1276  dprintk(1,
1277  KERN_ERR
1278  "%s: User specified card type %d out of range (0 .. %d)\n",
1279  ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
1280  goto zr_unreg;
1281  }
1282  }
1283 
1284  /* even though we make this a non pointer and thus
1285  * theoretically allow for making changes to this struct
1286  * on a per-individual card basis at runtime, this is
1287  * strongly discouraged. This structure is intended to
1288  * keep general card information, no settings or anything */
1289  zr->card = zoran_cards[card_num];
1290  snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1291  "%s[%u]", zr->card.name, zr->id);
1292 
1293  zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0);
1294  if (!zr->zr36057_mem) {
1295  dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n",
1296  ZR_DEVNAME(zr), __func__);
1297  goto zr_unreg;
1298  }
1299 
1300  result = request_irq(zr->pci_dev->irq, zoran_irq,
1301  IRQF_SHARED | IRQF_DISABLED, ZR_DEVNAME(zr), zr);
1302  if (result < 0) {
1303  if (result == -EINVAL) {
1304  dprintk(1,
1305  KERN_ERR
1306  "%s: %s - bad irq number or handler\n",
1307  ZR_DEVNAME(zr), __func__);
1308  } else if (result == -EBUSY) {
1309  dprintk(1,
1310  KERN_ERR
1311  "%s: %s - IRQ %d busy, change your PnP config in BIOS\n",
1312  ZR_DEVNAME(zr), __func__, zr->pci_dev->irq);
1313  } else {
1314  dprintk(1,
1315  KERN_ERR
1316  "%s: %s - can't assign irq, error code %d\n",
1317  ZR_DEVNAME(zr), __func__, result);
1318  }
1319  goto zr_unmap;
1320  }
1321 
1322  /* set PCI latency timer */
1323  pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1324  &latency);
1325  need_latency = zr->revision > 1 ? 32 : 48;
1326  if (latency != need_latency) {
1327  dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n",
1328  ZR_DEVNAME(zr), latency, need_latency);
1329  pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1330  need_latency);
1331  }
1332 
1333  zr36057_restart(zr);
1334  /* i2c */
1335  dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1336  ZR_DEVNAME(zr));
1337 
1338  if (zoran_register_i2c(zr) < 0) {
1339  dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n",
1340  ZR_DEVNAME(zr), __func__);
1341  goto zr_free_irq;
1342  }
1343 
1344  zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1345  &zr->i2c_adapter, zr->card.i2c_decoder,
1346  0, zr->card.addrs_decoder);
1347 
1348  if (zr->card.i2c_encoder)
1349  zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1350  &zr->i2c_adapter, zr->card.i2c_encoder,
1351  0, zr->card.addrs_encoder);
1352 
1353  dprintk(2,
1354  KERN_INFO "%s: Initializing videocodec bus...\n",
1355  ZR_DEVNAME(zr));
1356 
1357  if (zr->card.video_codec) {
1358  codec_name = codecid_to_modulename(zr->card.video_codec);
1359  if (codec_name) {
1360  result = request_module(codec_name);
1361  if (result) {
1362  dprintk(1,
1363  KERN_ERR
1364  "%s: failed to load modules %s: %d\n",
1365  ZR_DEVNAME(zr), codec_name, result);
1366  }
1367  }
1368  }
1369  if (zr->card.video_vfe) {
1370  vfe_name = codecid_to_modulename(zr->card.video_vfe);
1371  if (vfe_name) {
1372  result = request_module(vfe_name);
1373  if (result < 0) {
1374  dprintk(1,
1375  KERN_ERR
1376  "%s: failed to load modules %s: %d\n",
1377  ZR_DEVNAME(zr), vfe_name, result);
1378  }
1379  }
1380  }
1381 
1382  /* reset JPEG codec */
1383  jpeg_codec_sleep(zr, 1);
1384  jpeg_codec_reset(zr);
1385  /* video bus enabled */
1386  /* display codec revision */
1387  if (zr->card.video_codec != 0) {
1388  master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1389  if (!master_codec)
1390  goto zr_unreg_i2c;
1391  zr->codec = videocodec_attach(master_codec);
1392  if (!zr->codec) {
1393  dprintk(1, KERN_ERR "%s: %s - no codec found\n",
1394  ZR_DEVNAME(zr), __func__);
1395  goto zr_free_codec;
1396  }
1397  if (zr->codec->type != zr->card.video_codec) {
1398  dprintk(1, KERN_ERR "%s: %s - wrong codec\n",
1399  ZR_DEVNAME(zr), __func__);
1400  goto zr_detach_codec;
1401  }
1402  }
1403  if (zr->card.video_vfe != 0) {
1404  master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1405  if (!master_vfe)
1406  goto zr_detach_codec;
1407  zr->vfe = videocodec_attach(master_vfe);
1408  if (!zr->vfe) {
1409  dprintk(1, KERN_ERR "%s: %s - no VFE found\n",
1410  ZR_DEVNAME(zr), __func__);
1411  goto zr_free_vfe;
1412  }
1413  if (zr->vfe->type != zr->card.video_vfe) {
1414  dprintk(1, KERN_ERR "%s: %s = wrong VFE\n",
1415  ZR_DEVNAME(zr), __func__);
1416  goto zr_detach_vfe;
1417  }
1418  }
1419 
1420  /* take care of Natoma chipset and a revision 1 zr36057 */
1421  if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1422  zr->jpg_buffers.need_contiguous = 1;
1423  dprintk(1, KERN_INFO
1424  "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1425  ZR_DEVNAME(zr));
1426  }
1427 
1428  if (zr36057_init(zr) < 0)
1429  goto zr_detach_vfe;
1430 
1431  zoran_proc_init(zr);
1432 
1433  return 0;
1434 
1435 zr_detach_vfe:
1436  videocodec_detach(zr->vfe);
1437 zr_free_vfe:
1438  kfree(master_vfe);
1439 zr_detach_codec:
1440  videocodec_detach(zr->codec);
1441 zr_free_codec:
1442  kfree(master_codec);
1443 zr_unreg_i2c:
1444  zoran_unregister_i2c(zr);
1445 zr_free_irq:
1446  btwrite(0, ZR36057_SPGPPCR);
1447  free_irq(zr->pci_dev->irq, zr);
1448 zr_unmap:
1449  iounmap(zr->zr36057_mem);
1450 zr_unreg:
1451  v4l2_device_unregister(&zr->v4l2_dev);
1452 zr_free_mem:
1453  kfree(zr);
1454 
1455  return -ENODEV;
1456 }
1457 
1458 static struct pci_driver zoran_driver = {
1459  .name = "zr36067",
1460  .id_table = zr36067_pci_tbl,
1461  .probe = zoran_probe,
1462  .remove = __devexit_p(zoran_remove),
1463 };
1464 
1465 static int __init zoran_init(void)
1466 {
1467  int res;
1468 
1469  printk(KERN_INFO "Zoran MJPEG board driver version %s\n",
1470  ZORAN_VERSION);
1471 
1472  /* check the parameters we have been given, adjust if necessary */
1473  if (v4l_nbufs < 2)
1474  v4l_nbufs = 2;
1475  if (v4l_nbufs > VIDEO_MAX_FRAME)
1476  v4l_nbufs = VIDEO_MAX_FRAME;
1477  /* The user specfies the in KB, we want them in byte
1478  * (and page aligned) */
1479  v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1480  if (v4l_bufsize < 32768)
1481  v4l_bufsize = 32768;
1482  /* 2 MB is arbitrary but sufficient for the maximum possible images */
1483  if (v4l_bufsize > 2048 * 1024)
1484  v4l_bufsize = 2048 * 1024;
1485  if (jpg_nbufs < 4)
1486  jpg_nbufs = 4;
1487  if (jpg_nbufs > BUZ_MAX_FRAME)
1488  jpg_nbufs = BUZ_MAX_FRAME;
1489  jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1490  if (jpg_bufsize < 8192)
1491  jpg_bufsize = 8192;
1492  if (jpg_bufsize > (512 * 1024))
1493  jpg_bufsize = 512 * 1024;
1494  /* Use parameter for vidmem or try to find a video card */
1495  if (vidmem) {
1496  dprintk(1,
1497  KERN_INFO
1498  "%s: Using supplied video memory base address @ 0x%lx\n",
1499  ZORAN_NAME, vidmem);
1500  }
1501 
1502  /* some mainboards might not do PCI-PCI data transfer well */
1503  if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1504  dprintk(1,
1505  KERN_WARNING
1506  "%s: chipset does not support reliable PCI-PCI DMA\n",
1507  ZORAN_NAME);
1508  }
1509 
1510  res = pci_register_driver(&zoran_driver);
1511  if (res) {
1512  dprintk(1,
1513  KERN_ERR
1514  "%s: Unable to register ZR36057 driver\n",
1515  ZORAN_NAME);
1516  return res;
1517  }
1518 
1519  return 0;
1520 }
1521 
1522 static void __exit zoran_exit(void)
1523 {
1524  pci_unregister_driver(&zoran_driver);
1525 }
1526 
1527 module_init(zoran_init);
1528 module_exit(zoran_exit);
Generated on Thu Jan 10 2013 13:49:03 for Linux Kernel by   doxygen 1.8.2