1 /*
2 * cx18 driver initialization and card probing
3 *
4 * Derived from ivtv-driver.c
5 *
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
7 * Copyright (C) 2008 Andy Walls <awalls@md.metrocast.net>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22 * 02111-1307 USA
23 */
24
25 #include "cx18-driver.h"
26 #include "cx18-io.h"
27 #include "cx18-version.h"
28 #include "cx18-cards.h"
29 #include "cx18-i2c.h"
30 #include "cx18-irq.h"
31 #include "cx18-gpio.h"
32 #include "cx18-firmware.h"
33 #include "cx18-queue.h"
34 #include "cx18-streams.h"
35 #include "cx18-av-core.h"
36 #include "cx18-scb.h"
37 #include "cx18-mailbox.h"
38 #include "cx18-ioctl.h"
39 #include "cx18-controls.h"
40 #include "tuner-xc2028.h"
41
42 #include <media/tveeprom.h>
43
44 /* If you have already X v4l cards, then set this to X. This way
45 the device numbers stay matched. Example: you have a WinTV card
46 without radio and a Compro H900 with. Normally this would give a
47 video1 device together with a radio0 device for the Compro. By
48 setting this to 1 you ensure that radio0 is now also radio1. */
49 int cx18_first_minor;
50
51 /* Callback for registering extensions */
52 int (*cx18_ext_init)(struct cx18 *);
53 EXPORT_SYMBOL(cx18_ext_init);
54
55 /* add your revision and whatnot here */
56 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
57 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
58 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
59 {0,}
60 };
61
62 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
63
64 static atomic_t cx18_instance = ATOMIC_INIT(0);
65
66 /* Parameter declarations */
67 static int cardtype[CX18_MAX_CARDS];
68 static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
69 -1, -1, -1, -1, -1, -1, -1, -1,
70 -1, -1, -1, -1, -1, -1, -1, -1,
71 -1, -1, -1, -1, -1, -1, -1, -1 };
72 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1,
74 -1, -1, -1, -1, -1, -1, -1, -1,
75 -1, -1, -1, -1, -1, -1, -1, -1 };
76 static unsigned cardtype_c = 1;
77 static unsigned tuner_c = 1;
78 static unsigned radio_c = 1;
79 static char pal[] = "--";
80 static char secam[] = "--";
81 static char ntsc[] = "-";
82
83 /* Buffers */
84 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
85 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
86 static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
87 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
88 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
89 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
90
91 static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
92 static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
93 static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
94 static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
95 static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
96
97 static int enc_ts_bufs = -1;
98 static int enc_mpg_bufs = -1;
99 static int enc_idx_bufs = CX18_MAX_FW_MDLS_PER_STREAM;
100 static int enc_yuv_bufs = -1;
101 static int enc_vbi_bufs = -1;
102 static int enc_pcm_bufs = -1;
103
104
105 static int cx18_pci_latency = 1;
106
107 static int mmio_ndelay;
108 static int retry_mmio = 1;
109
110 int cx18_debug;
111
112 module_param_array(tuner, int, &tuner_c, 0644);
113 module_param_array(radio, bool, &radio_c, 0644);
114 module_param_array(cardtype, int, &cardtype_c, 0644);
115 module_param_string(pal, pal, sizeof(pal), 0644);
116 module_param_string(secam, secam, sizeof(secam), 0644);
117 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
118 module_param_named(debug, cx18_debug, int, 0644);
119 module_param(mmio_ndelay, int, 0644);
120 module_param(retry_mmio, int, 0644);
121 module_param(cx18_pci_latency, int, 0644);
122 module_param(cx18_first_minor, int, 0644);
123
124 module_param(enc_ts_buffers, int, 0644);
125 module_param(enc_mpg_buffers, int, 0644);
126 module_param(enc_idx_buffers, int, 0644);
127 module_param(enc_yuv_buffers, int, 0644);
128 module_param(enc_vbi_buffers, int, 0644);
129 module_param(enc_pcm_buffers, int, 0644);
130
131 module_param(enc_ts_bufsize, int, 0644);
132 module_param(enc_mpg_bufsize, int, 0644);
133 module_param(enc_idx_bufsize, int, 0644);
134 module_param(enc_yuv_bufsize, int, 0644);
135 module_param(enc_pcm_bufsize, int, 0644);
136
137 module_param(enc_ts_bufs, int, 0644);
138 module_param(enc_mpg_bufs, int, 0644);
139 module_param(enc_idx_bufs, int, 0644);
140 module_param(enc_yuv_bufs, int, 0644);
141 module_param(enc_vbi_bufs, int, 0644);
142 module_param(enc_pcm_bufs, int, 0644);
143
144 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
145 "\t\t\tsee tuner.h for values");
146 MODULE_PARM_DESC(radio,
147 "Enable or disable the radio. Use only if autodetection\n"
148 "\t\t\tfails. 0 = disable, 1 = enable");
149 MODULE_PARM_DESC(cardtype,
150 "Only use this option if your card is not detected properly.\n"
151 "\t\tSpecify card type:\n"
152 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
153 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
154 "\t\t\t 3 = Compro VideoMate H900\n"
155 "\t\t\t 4 = Yuan MPC718\n"
156 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
157 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
158 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
159 "\t\t\t 8 = Leadtek WinFast DVR3100 H\n"
160 "\t\t\t 9 = GoTView PCI DVD3 Hybrid\n"
161 "\t\t\t 10 = Hauppauge HVR 1600 (S5H1411)\n"
162 "\t\t\t 0 = Autodetect (default)\n"
163 "\t\t\t-1 = Ignore this card\n\t\t");
164 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
165 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
166 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
167 MODULE_PARM_DESC(debug,
168 "Debug level (bitmask). Default: 0\n"
169 "\t\t\t 1/0x0001: warning\n"
170 "\t\t\t 2/0x0002: info\n"
171 "\t\t\t 4/0x0004: mailbox\n"
172 "\t\t\t 8/0x0008: dma\n"
173 "\t\t\t 16/0x0010: ioctl\n"
174 "\t\t\t 32/0x0020: file\n"
175 "\t\t\t 64/0x0040: i2c\n"
176 "\t\t\t128/0x0080: irq\n"
177 "\t\t\t256/0x0100: high volume\n");
178 MODULE_PARM_DESC(cx18_pci_latency,
179 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
180 "\t\t\tDefault: Yes");
181 MODULE_PARM_DESC(retry_mmio,
182 "(Deprecated) MMIO writes are now always checked and retried\n"
183 "\t\t\tEffectively: 1 [Yes]");
184 MODULE_PARM_DESC(mmio_ndelay,
185 "(Deprecated) MMIO accesses are now never purposely delayed\n"
186 "\t\t\tEffectively: 0 ns");
187 MODULE_PARM_DESC(enc_ts_buffers,
188 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
189 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
190 MODULE_PARM_DESC(enc_ts_bufsize,
191 "Size of an encoder TS buffer (kB)\n"
192 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
193 MODULE_PARM_DESC(enc_ts_bufs,
194 "Number of encoder TS buffers\n"
195 "\t\t\tDefault is computed from other enc_ts_* parameters");
196 MODULE_PARM_DESC(enc_mpg_buffers,
197 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
198 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
199 MODULE_PARM_DESC(enc_mpg_bufsize,
200 "Size of an encoder MPG buffer (kB)\n"
201 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
202 MODULE_PARM_DESC(enc_mpg_bufs,
203 "Number of encoder MPG buffers\n"
204 "\t\t\tDefault is computed from other enc_mpg_* parameters");
205 MODULE_PARM_DESC(enc_idx_buffers,
206 "(Deprecated) Encoder IDX buffer memory (MB)\n"
207 "\t\t\tIgnored, except 0 disables IDX buffer allocations\n"
208 "\t\t\tDefault: 1 [Enabled]");
209 MODULE_PARM_DESC(enc_idx_bufsize,
210 "Size of an encoder IDX buffer (kB)\n"
211 "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n"
212 "\t\t\t(multiples of size required for 64 index entries)\n"
213 "\t\t\tDefault: 2");
214 MODULE_PARM_DESC(enc_idx_bufs,
215 "Number of encoder IDX buffers\n"
216 "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM));
217 MODULE_PARM_DESC(enc_yuv_buffers,
218 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
219 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
220 MODULE_PARM_DESC(enc_yuv_bufsize,
221 "Size of an encoder YUV buffer (kB)\n"
222 "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n"
223 "\t\t\t(multiples of size required for 32 screen lines)\n"
224 "\t\t\tDefault: 102");
225 MODULE_PARM_DESC(enc_yuv_bufs,
226 "Number of encoder YUV buffers\n"
227 "\t\t\tDefault is computed from other enc_yuv_* parameters");
228 MODULE_PARM_DESC(enc_vbi_buffers,
229 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
230 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
231 MODULE_PARM_DESC(enc_vbi_bufs,
232 "Number of encoder VBI buffers\n"
233 "\t\t\tDefault is computed from enc_vbi_buffers");
234 MODULE_PARM_DESC(enc_pcm_buffers,
235 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
236 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
237 MODULE_PARM_DESC(enc_pcm_bufsize,
238 "Size of an encoder PCM buffer (kB)\n"
239 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
240 MODULE_PARM_DESC(enc_pcm_bufs,
241 "Number of encoder PCM buffers\n"
242 "\t\t\tDefault is computed from other enc_pcm_* parameters");
243
244 MODULE_PARM_DESC(cx18_first_minor,
245 "Set device node number assigned to first card");
246
247 MODULE_AUTHOR("Hans Verkuil");
248 MODULE_DESCRIPTION("CX23418 driver");
249 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
250 MODULE_LICENSE("GPL");
251
252 MODULE_VERSION(CX18_VERSION);
253
254 #if defined(CONFIG_MODULES) && defined(MODULE)
request_module_async(struct work_struct * work)255 static void request_module_async(struct work_struct *work)
256 {
257 struct cx18 *dev = container_of(work, struct cx18, request_module_wk);
258
259 /* Make sure cx18-alsa module is loaded */
260 request_module("cx18-alsa");
261
262 /* Initialize cx18-alsa for this instance of the cx18 device */
263 if (cx18_ext_init != NULL)
264 cx18_ext_init(dev);
265 }
266
request_modules(struct cx18 * dev)267 static void request_modules(struct cx18 *dev)
268 {
269 INIT_WORK(&dev->request_module_wk, request_module_async);
270 schedule_work(&dev->request_module_wk);
271 }
272
flush_request_modules(struct cx18 * dev)273 static void flush_request_modules(struct cx18 *dev)
274 {
275 flush_work_sync(&dev->request_module_wk);
276 }
277 #else
278 #define request_modules(dev)
279 #define flush_request_modules(dev)
280 #endif /* CONFIG_MODULES */
281
282 /* Generic utility functions */
cx18_msleep_timeout(unsigned int msecs,int intr)283 int cx18_msleep_timeout(unsigned int msecs, int intr)
284 {
285 long int timeout = msecs_to_jiffies(msecs);
286 int sig;
287
288 do {
289 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
290 timeout = schedule_timeout(timeout);
291 sig = intr ? signal_pending(current) : 0;
292 } while (!sig && timeout);
293 return sig;
294 }
295
296 /* Release ioremapped memory */
cx18_iounmap(struct cx18 * cx)297 static void cx18_iounmap(struct cx18 *cx)
298 {
299 if (cx == NULL)
300 return;
301
302 /* Release io memory */
303 if (cx->enc_mem != NULL) {
304 CX18_DEBUG_INFO("releasing enc_mem\n");
305 iounmap(cx->enc_mem);
306 cx->enc_mem = NULL;
307 }
308 }
309
cx18_eeprom_dump(struct cx18 * cx,unsigned char * eedata,int len)310 static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len)
311 {
312 int i;
313
314 CX18_INFO("eeprom dump:\n");
315 for (i = 0; i < len; i++) {
316 if (0 == (i % 16))
317 CX18_INFO("eeprom %02x:", i);
318 printk(KERN_CONT " %02x", eedata[i]);
319 if (15 == (i % 16))
320 printk(KERN_CONT "\n");
321 }
322 }
323
324 /* Hauppauge card? get values from tveeprom */
cx18_read_eeprom(struct cx18 * cx,struct tveeprom * tv)325 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
326 {
327 struct i2c_client c;
328 u8 eedata[256];
329
330 memset(&c, 0, sizeof(c));
331 strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
332 c.adapter = &cx->i2c_adap[0];
333 c.addr = 0xA0 >> 1;
334
335 memset(tv, 0, sizeof(*tv));
336 if (tveeprom_read(&c, eedata, sizeof(eedata)))
337 return;
338
339 switch (cx->card->type) {
340 case CX18_CARD_HVR_1600_ESMT:
341 case CX18_CARD_HVR_1600_SAMSUNG:
342 case CX18_CARD_HVR_1600_S5H1411:
343 tveeprom_hauppauge_analog(&c, tv, eedata);
344 break;
345 case CX18_CARD_YUAN_MPC718:
346 case CX18_CARD_GOTVIEW_PCI_DVD3:
347 tv->model = 0x718;
348 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
349 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
350 eedata[2], eedata[1], eedata[4], eedata[3]);
351 break;
352 default:
353 tv->model = 0xffffffff;
354 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
355 break;
356 }
357 }
358
cx18_process_eeprom(struct cx18 * cx)359 static void cx18_process_eeprom(struct cx18 *cx)
360 {
361 struct tveeprom tv;
362
363 cx18_read_eeprom(cx, &tv);
364
365 /* Many thanks to Steven Toth from Hauppauge for providing the
366 model numbers */
367 /* Note: the Samsung memory models cannot be reliably determined
368 from the model number. Use the cardtype module option if you
369 have one of these preproduction models. */
370 switch (tv.model) {
371 case 74301: /* Retail models */
372 case 74321:
373 case 74351: /* OEM models */
374 case 74361:
375 /* Digital side is s5h1411/tda18271 */
376 cx->card = cx18_get_card(CX18_CARD_HVR_1600_S5H1411);
377 break;
378 case 74021: /* Retail models */
379 case 74031:
380 case 74041:
381 case 74141:
382 case 74541: /* OEM models */
383 case 74551:
384 case 74591:
385 case 74651:
386 case 74691:
387 case 74751:
388 case 74891:
389 /* Digital side is s5h1409/mxl5005s */
390 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
391 break;
392 case 0x718:
393 return;
394 case 0xffffffff:
395 CX18_INFO("Unknown EEPROM encoding\n");
396 return;
397 case 0:
398 CX18_ERR("Invalid EEPROM\n");
399 return;
400 default:
401 CX18_ERR("Unknown model %d, defaulting to original HVR-1600 "
402 "(cardtype=1)\n", tv.model);
403 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
404 break;
405 }
406
407 cx->v4l2_cap = cx->card->v4l2_capabilities;
408 cx->card_name = cx->card->name;
409 cx->card_i2c = cx->card->i2c;
410
411 CX18_INFO("Autodetected %s\n", cx->card_name);
412
413 if (tv.tuner_type == TUNER_ABSENT)
414 CX18_ERR("tveeprom cannot autodetect tuner!\n");
415
416 if (cx->options.tuner == -1)
417 cx->options.tuner = tv.tuner_type;
418 if (cx->options.radio == -1)
419 cx->options.radio = (tv.has_radio != 0);
420
421 if (cx->std != 0)
422 /* user specified tuner standard */
423 return;
424
425 /* autodetect tuner standard */
426 if (tv.tuner_formats & V4L2_STD_PAL) {
427 CX18_DEBUG_INFO("PAL tuner detected\n");
428 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
429 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
430 CX18_DEBUG_INFO("NTSC tuner detected\n");
431 cx->std |= V4L2_STD_NTSC_M;
432 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
433 CX18_DEBUG_INFO("SECAM tuner detected\n");
434 cx->std |= V4L2_STD_SECAM_L;
435 } else {
436 CX18_INFO("No tuner detected, default to NTSC-M\n");
437 cx->std |= V4L2_STD_NTSC_M;
438 }
439 }
440
cx18_parse_std(struct cx18 * cx)441 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
442 {
443 switch (pal[0]) {
444 case '6':
445 return V4L2_STD_PAL_60;
446 case 'b':
447 case 'B':
448 case 'g':
449 case 'G':
450 return V4L2_STD_PAL_BG;
451 case 'h':
452 case 'H':
453 return V4L2_STD_PAL_H;
454 case 'n':
455 case 'N':
456 if (pal[1] == 'c' || pal[1] == 'C')
457 return V4L2_STD_PAL_Nc;
458 return V4L2_STD_PAL_N;
459 case 'i':
460 case 'I':
461 return V4L2_STD_PAL_I;
462 case 'd':
463 case 'D':
464 case 'k':
465 case 'K':
466 return V4L2_STD_PAL_DK;
467 case 'M':
468 case 'm':
469 return V4L2_STD_PAL_M;
470 case '-':
471 break;
472 default:
473 CX18_WARN("pal= argument not recognised\n");
474 return 0;
475 }
476
477 switch (secam[0]) {
478 case 'b':
479 case 'B':
480 case 'g':
481 case 'G':
482 case 'h':
483 case 'H':
484 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
485 case 'd':
486 case 'D':
487 case 'k':
488 case 'K':
489 return V4L2_STD_SECAM_DK;
490 case 'l':
491 case 'L':
492 if (secam[1] == 'C' || secam[1] == 'c')
493 return V4L2_STD_SECAM_LC;
494 return V4L2_STD_SECAM_L;
495 case '-':
496 break;
497 default:
498 CX18_WARN("secam= argument not recognised\n");
499 return 0;
500 }
501
502 switch (ntsc[0]) {
503 case 'm':
504 case 'M':
505 return V4L2_STD_NTSC_M;
506 case 'j':
507 case 'J':
508 return V4L2_STD_NTSC_M_JP;
509 case 'k':
510 case 'K':
511 return V4L2_STD_NTSC_M_KR;
512 case '-':
513 break;
514 default:
515 CX18_WARN("ntsc= argument not recognised\n");
516 return 0;
517 }
518
519 /* no match found */
520 return 0;
521 }
522
cx18_process_options(struct cx18 * cx)523 static void cx18_process_options(struct cx18 *cx)
524 {
525 int i, j;
526
527 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
528 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
529 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
530 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
531 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
532 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
533 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
534
535 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
536 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
537 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
538 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
539 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
540 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
541 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
542
543 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
544 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
545 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
546 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
547 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
548 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
549 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
550
551 /* Ensure stream_buffers & stream_buf_size are valid */
552 for (i = 0; i < CX18_MAX_STREAMS; i++) {
553 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */
554 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */
555 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */
556 cx->options.megabytes[i] = 0;
557 cx->stream_buffers[i] = 0;
558 cx->stream_buf_size[i] = 0;
559 continue;
560 }
561 /*
562 * YUV is a special case where the stream_buf_size needs to be
563 * an integral multiple of 33.75 kB (storage for 32 screens
564 * lines to maintain alignment in case of lost buffers).
565 *
566 * IDX is a special case where the stream_buf_size should be
567 * an integral multiple of 1.5 kB (storage for 64 index entries
568 * to maintain alignment in case of lost buffers).
569 *
570 */
571 if (i == CX18_ENC_STREAM_TYPE_YUV) {
572 cx->stream_buf_size[i] *= 1024;
573 cx->stream_buf_size[i] -=
574 (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE);
575
576 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
577 cx->stream_buf_size[i] =
578 CX18_UNIT_ENC_YUV_BUFSIZE;
579 } else if (i == CX18_ENC_STREAM_TYPE_IDX) {
580 cx->stream_buf_size[i] *= 1024;
581 cx->stream_buf_size[i] -=
582 (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE);
583
584 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)
585 cx->stream_buf_size[i] =
586 CX18_UNIT_ENC_IDX_BUFSIZE;
587 }
588 /*
589 * YUV and IDX are special cases where the stream_buf_size is
590 * now in bytes.
591 * VBI is a special case where the stream_buf_size is fixed
592 * and already in bytes
593 */
594 if (i == CX18_ENC_STREAM_TYPE_VBI ||
595 i == CX18_ENC_STREAM_TYPE_YUV ||
596 i == CX18_ENC_STREAM_TYPE_IDX) {
597 if (cx->stream_buffers[i] < 0) {
598 cx->stream_buffers[i] =
599 cx->options.megabytes[i] * 1024 * 1024
600 / cx->stream_buf_size[i];
601 } else {
602 /* N.B. This might round down to 0 */
603 cx->options.megabytes[i] =
604 cx->stream_buffers[i]
605 * cx->stream_buf_size[i]/(1024 * 1024);
606 }
607 } else {
608 /* All other streams have stream_buf_size in kB here */
609 if (cx->stream_buffers[i] < 0) {
610 cx->stream_buffers[i] =
611 cx->options.megabytes[i] * 1024
612 / cx->stream_buf_size[i];
613 } else {
614 /* N.B. This might round down to 0 */
615 cx->options.megabytes[i] =
616 cx->stream_buffers[i]
617 * cx->stream_buf_size[i] / 1024;
618 }
619 /* convert from kB to bytes */
620 cx->stream_buf_size[i] *= 1024;
621 }
622 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
623 "%d bytes\n", i, cx->options.megabytes[i],
624 cx->stream_buffers[i], cx->stream_buf_size[i]);
625 }
626
627 cx->options.cardtype = cardtype[cx->instance];
628 cx->options.tuner = tuner[cx->instance];
629 cx->options.radio = radio[cx->instance];
630
631 cx->std = cx18_parse_std(cx);
632 if (cx->options.cardtype == -1) {
633 CX18_INFO("Ignore card\n");
634 return;
635 }
636 cx->card = cx18_get_card(cx->options.cardtype - 1);
637 if (cx->card)
638 CX18_INFO("User specified %s card\n", cx->card->name);
639 else if (cx->options.cardtype != 0)
640 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
641 if (cx->card == NULL) {
642 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
643 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
644 CX18_INFO("Autodetected Hauppauge card\n");
645 }
646 }
647 if (cx->card == NULL) {
648 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
649 if (cx->card->pci_list == NULL)
650 continue;
651 for (j = 0; cx->card->pci_list[j].device; j++) {
652 if (cx->pci_dev->device !=
653 cx->card->pci_list[j].device)
654 continue;
655 if (cx->pci_dev->subsystem_vendor !=
656 cx->card->pci_list[j].subsystem_vendor)
657 continue;
658 if (cx->pci_dev->subsystem_device !=
659 cx->card->pci_list[j].subsystem_device)
660 continue;
661 CX18_INFO("Autodetected %s card\n", cx->card->name);
662 goto done;
663 }
664 }
665 }
666 done:
667
668 if (cx->card == NULL) {
669 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
670 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
671 cx->pci_dev->vendor, cx->pci_dev->device);
672 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
673 cx->pci_dev->subsystem_vendor,
674 cx->pci_dev->subsystem_device);
675 CX18_ERR("Defaulting to %s card\n", cx->card->name);
676 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
677 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
678 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
679 }
680 cx->v4l2_cap = cx->card->v4l2_capabilities;
681 cx->card_name = cx->card->name;
682 cx->card_i2c = cx->card->i2c;
683 }
684
cx18_create_in_workq(struct cx18 * cx)685 static int __devinit cx18_create_in_workq(struct cx18 *cx)
686 {
687 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
688 cx->v4l2_dev.name);
689 cx->in_work_queue = alloc_ordered_workqueue(cx->in_workq_name, 0);
690 if (cx->in_work_queue == NULL) {
691 CX18_ERR("Unable to create incoming mailbox handler thread\n");
692 return -ENOMEM;
693 }
694 return 0;
695 }
696
cx18_init_in_work_orders(struct cx18 * cx)697 static void __devinit cx18_init_in_work_orders(struct cx18 *cx)
698 {
699 int i;
700 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
701 cx->in_work_order[i].cx = cx;
702 cx->in_work_order[i].str = cx->epu_debug_str;
703 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
704 }
705 }
706
707 /* Precondition: the cx18 structure has been memset to 0. Only
708 the dev and instance fields have been filled in.
709 No assumptions on the card type may be made here (see cx18_init_struct2
710 for that).
711 */
cx18_init_struct1(struct cx18 * cx)712 static int __devinit cx18_init_struct1(struct cx18 *cx)
713 {
714 int ret;
715
716 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
717
718 mutex_init(&cx->serialize_lock);
719 mutex_init(&cx->gpio_lock);
720 mutex_init(&cx->epu2apu_mb_lock);
721 mutex_init(&cx->epu2cpu_mb_lock);
722
723 ret = cx18_create_in_workq(cx);
724 if (ret)
725 return ret;
726
727 cx18_init_in_work_orders(cx);
728
729 /* start counting open_id at 1 */
730 cx->open_id = 1;
731
732 /* Initial settings */
733 cx->cxhdl.port = CX2341X_PORT_MEMORY;
734 cx->cxhdl.capabilities = CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
735 cx->cxhdl.ops = &cx18_cxhdl_ops;
736 cx->cxhdl.func = cx18_api_func;
737 cx->cxhdl.priv = &cx->streams[CX18_ENC_STREAM_TYPE_MPG];
738 ret = cx2341x_handler_init(&cx->cxhdl, 50);
739 if (ret)
740 return ret;
741 cx->v4l2_dev.ctrl_handler = &cx->cxhdl.hdl;
742
743 cx->temporal_strength = cx->cxhdl.video_temporal_filter->cur.val;
744 cx->spatial_strength = cx->cxhdl.video_spatial_filter->cur.val;
745 cx->filter_mode = cx->cxhdl.video_spatial_filter_mode->cur.val |
746 (cx->cxhdl.video_temporal_filter_mode->cur.val << 1) |
747 (cx->cxhdl.video_median_filter_type->cur.val << 2);
748
749 init_waitqueue_head(&cx->cap_w);
750 init_waitqueue_head(&cx->mb_apu_waitq);
751 init_waitqueue_head(&cx->mb_cpu_waitq);
752 init_waitqueue_head(&cx->dma_waitq);
753
754 /* VBI */
755 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
756 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
757
758 /* IVTV style VBI insertion into MPEG streams */
759 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list);
760 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
761 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
762 list_add(&cx->vbi.sliced_mpeg_buf.list,
763 &cx->vbi.sliced_mpeg_mdl.buf_list);
764 return 0;
765 }
766
767 /* Second initialization part. Here the card type has been
768 autodetected. */
cx18_init_struct2(struct cx18 * cx)769 static void __devinit cx18_init_struct2(struct cx18 *cx)
770 {
771 int i;
772
773 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
774 if (cx->card->video_inputs[i].video_type == 0)
775 break;
776 cx->nof_inputs = i;
777 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
778 if (cx->card->audio_inputs[i].audio_type == 0)
779 break;
780 cx->nof_audio_inputs = i;
781
782 /* Find tuner input */
783 for (i = 0; i < cx->nof_inputs; i++) {
784 if (cx->card->video_inputs[i].video_type ==
785 CX18_CARD_INPUT_VID_TUNER)
786 break;
787 }
788 if (i == cx->nof_inputs)
789 i = 0;
790 cx->active_input = i;
791 cx->audio_input = cx->card->video_inputs[i].audio_index;
792 }
793
cx18_setup_pci(struct cx18 * cx,struct pci_dev * pci_dev,const struct pci_device_id * pci_id)794 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
795 const struct pci_device_id *pci_id)
796 {
797 u16 cmd;
798 unsigned char pci_latency;
799
800 CX18_DEBUG_INFO("Enabling pci device\n");
801
802 if (pci_enable_device(pci_dev)) {
803 CX18_ERR("Can't enable device %d!\n", cx->instance);
804 return -EIO;
805 }
806 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
807 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
808 return -EIO;
809 }
810 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
811 CX18_ERR("Cannot request encoder memory region, card %d\n",
812 cx->instance);
813 return -EIO;
814 }
815
816 /* Enable bus mastering and memory mapped IO for the CX23418 */
817 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
818 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
819 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
820
821 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
822 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
823
824 if (pci_latency < 64 && cx18_pci_latency) {
825 CX18_INFO("Unreasonably low latency timer, "
826 "setting to 64 (was %d)\n", pci_latency);
827 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
828 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
829 }
830
831 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
832 "irq: %d, latency: %d, memory: 0x%lx\n",
833 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
834 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
835 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
836
837 return 0;
838 }
839
cx18_init_subdevs(struct cx18 * cx)840 static void cx18_init_subdevs(struct cx18 *cx)
841 {
842 u32 hw = cx->card->hw_all;
843 u32 device;
844 int i;
845
846 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
847
848 if (!(device & hw))
849 continue;
850
851 switch (device) {
852 case CX18_HW_DVB:
853 case CX18_HW_TVEEPROM:
854 /* These subordinate devices do not use probing */
855 cx->hw_flags |= device;
856 break;
857 case CX18_HW_418_AV:
858 /* The A/V decoder gets probed earlier to set PLLs */
859 /* Just note that the card uses it (i.e. has analog) */
860 cx->hw_flags |= device;
861 break;
862 case CX18_HW_GPIO_RESET_CTRL:
863 /*
864 * The Reset Controller gets probed and added to
865 * hw_flags earlier for i2c adapter/bus initialization
866 */
867 break;
868 case CX18_HW_GPIO_MUX:
869 if (cx18_gpio_register(cx, device) == 0)
870 cx->hw_flags |= device;
871 break;
872 default:
873 if (cx18_i2c_register(cx, i) == 0)
874 cx->hw_flags |= device;
875 break;
876 }
877 }
878
879 if (cx->hw_flags & CX18_HW_418_AV)
880 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
881
882 if (cx->card->hw_muxer != 0)
883 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
884 }
885
cx18_probe(struct pci_dev * pci_dev,const struct pci_device_id * pci_id)886 static int __devinit cx18_probe(struct pci_dev *pci_dev,
887 const struct pci_device_id *pci_id)
888 {
889 int retval = 0;
890 int i;
891 u32 devtype;
892 struct cx18 *cx;
893
894 /* FIXME - module parameter arrays constrain max instances */
895 i = atomic_inc_return(&cx18_instance) - 1;
896 if (i >= CX18_MAX_CARDS) {
897 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
898 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
899 return -ENOMEM;
900 }
901
902 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
903 if (cx == NULL) {
904 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
905 i);
906 return -ENOMEM;
907 }
908 cx->pci_dev = pci_dev;
909 cx->instance = i;
910
911 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
912 if (retval) {
913 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
914 "\n", cx->instance);
915 kfree(cx);
916 return retval;
917 }
918 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
919 cx->instance);
920 CX18_INFO("Initializing card %d\n", cx->instance);
921
922 cx18_process_options(cx);
923 if (cx->options.cardtype == -1) {
924 retval = -ENODEV;
925 goto err;
926 }
927
928 retval = cx18_init_struct1(cx);
929 if (retval)
930 goto err;
931
932 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
933
934 /* PCI Device Setup */
935 retval = cx18_setup_pci(cx, pci_dev, pci_id);
936 if (retval != 0)
937 goto free_workqueues;
938
939 /* map io memory */
940 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
941 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
942 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
943 CX18_MEM_SIZE);
944 if (!cx->enc_mem) {
945 CX18_ERR("ioremap failed. Can't get a window into CX23418 "
946 "memory and register space\n");
947 CX18_ERR("Each capture card with a CX23418 needs 64 MB of "
948 "vmalloc address space for the window\n");
949 CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
950 CX18_ERR("Use the vmalloc= kernel command line option to set "
951 "VmallocTotal to a larger value\n");
952 retval = -ENOMEM;
953 goto free_mem;
954 }
955 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
956 devtype = cx18_read_reg(cx, 0xC72028);
957 switch (devtype & 0xff000000) {
958 case 0xff000000:
959 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
960 break;
961 case 0x01000000:
962 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
963 break;
964 default:
965 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
966 break;
967 }
968
969 cx18_init_power(cx, 1);
970 cx18_init_memory(cx);
971
972 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
973 cx18_init_scb(cx);
974
975 cx18_gpio_init(cx);
976
977 /* Initialize integrated A/V decoder early to set PLLs, just in case */
978 retval = cx18_av_probe(cx);
979 if (retval) {
980 CX18_ERR("Could not register A/V decoder subdevice\n");
981 goto free_map;
982 }
983
984 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
985 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
986 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
987 CX18_WARN("Could not register GPIO reset controller"
988 "subdevice; proceeding anyway.\n");
989 else
990 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
991 }
992
993 /* active i2c */
994 CX18_DEBUG_INFO("activating i2c...\n");
995 retval = init_cx18_i2c(cx);
996 if (retval) {
997 CX18_ERR("Could not initialize i2c\n");
998 goto free_map;
999 }
1000
1001 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
1002 /* Based on the model number the cardtype may be changed.
1003 The PCI IDs are not always reliable. */
1004 cx18_process_eeprom(cx);
1005 }
1006 if (cx->card->comment)
1007 CX18_INFO("%s", cx->card->comment);
1008 if (cx->card->v4l2_capabilities == 0) {
1009 retval = -ENODEV;
1010 goto free_i2c;
1011 }
1012 cx18_init_memory(cx);
1013 cx18_init_scb(cx);
1014
1015 /* Register IRQ */
1016 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
1017 IRQF_SHARED | IRQF_DISABLED,
1018 cx->v4l2_dev.name, (void *)cx);
1019 if (retval) {
1020 CX18_ERR("Failed to register irq %d\n", retval);
1021 goto free_i2c;
1022 }
1023
1024 if (cx->std == 0)
1025 cx->std = V4L2_STD_NTSC_M;
1026
1027 if (cx->options.tuner == -1) {
1028 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
1029 if ((cx->std & cx->card->tuners[i].std) == 0)
1030 continue;
1031 cx->options.tuner = cx->card->tuners[i].tuner;
1032 break;
1033 }
1034 }
1035 /* if no tuner was found, then pick the first tuner in the card list */
1036 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
1037 cx->std = cx->card->tuners[0].std;
1038 if (cx->std & V4L2_STD_PAL)
1039 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1040 else if (cx->std & V4L2_STD_NTSC)
1041 cx->std = V4L2_STD_NTSC_M;
1042 else if (cx->std & V4L2_STD_SECAM)
1043 cx->std = V4L2_STD_SECAM_L;
1044 cx->options.tuner = cx->card->tuners[0].tuner;
1045 }
1046 if (cx->options.radio == -1)
1047 cx->options.radio = (cx->card->radio_input.audio_type != 0);
1048
1049 /* The card is now fully identified, continue with card-specific
1050 initialization. */
1051 cx18_init_struct2(cx);
1052
1053 cx18_init_subdevs(cx);
1054
1055 if (cx->std & V4L2_STD_525_60)
1056 cx->is_60hz = 1;
1057 else
1058 cx->is_50hz = 1;
1059
1060 cx2341x_handler_set_50hz(&cx->cxhdl, !cx->is_60hz);
1061
1062 if (cx->options.radio > 0)
1063 cx->v4l2_cap |= V4L2_CAP_RADIO;
1064
1065 if (cx->options.tuner > -1) {
1066 struct tuner_setup setup;
1067
1068 setup.addr = ADDR_UNSET;
1069 setup.type = cx->options.tuner;
1070 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1071 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1072 cx18_reset_tuner_gpio : NULL;
1073 cx18_call_all(cx, tuner, s_type_addr, &setup);
1074 if (setup.type == TUNER_XC2028) {
1075 static struct xc2028_ctrl ctrl = {
1076 .fname = XC2028_DEFAULT_FIRMWARE,
1077 .max_len = 64,
1078 };
1079 struct v4l2_priv_tun_config cfg = {
1080 .tuner = cx->options.tuner,
1081 .priv = &ctrl,
1082 };
1083 cx18_call_all(cx, tuner, s_config, &cfg);
1084 }
1085 }
1086
1087 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1088 are not. */
1089 cx->tuner_std = cx->std;
1090
1091 retval = cx18_streams_setup(cx);
1092 if (retval) {
1093 CX18_ERR("Error %d setting up streams\n", retval);
1094 goto free_irq;
1095 }
1096 retval = cx18_streams_register(cx);
1097 if (retval) {
1098 CX18_ERR("Error %d registering devices\n", retval);
1099 goto free_streams;
1100 }
1101
1102 CX18_INFO("Initialized card: %s\n", cx->card_name);
1103
1104 /* Load cx18 submodules (cx18-alsa) */
1105 request_modules(cx);
1106 return 0;
1107
1108 free_streams:
1109 cx18_streams_cleanup(cx, 1);
1110 free_irq:
1111 free_irq(cx->pci_dev->irq, (void *)cx);
1112 free_i2c:
1113 exit_cx18_i2c(cx);
1114 free_map:
1115 cx18_iounmap(cx);
1116 free_mem:
1117 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1118 free_workqueues:
1119 destroy_workqueue(cx->in_work_queue);
1120 err:
1121 if (retval == 0)
1122 retval = -ENODEV;
1123 CX18_ERR("Error %d on initialization\n", retval);
1124
1125 v4l2_device_unregister(&cx->v4l2_dev);
1126 kfree(cx);
1127 return retval;
1128 }
1129
cx18_init_on_first_open(struct cx18 * cx)1130 int cx18_init_on_first_open(struct cx18 *cx)
1131 {
1132 int video_input;
1133 int fw_retry_count = 3;
1134 struct v4l2_frequency vf;
1135 struct cx18_open_id fh;
1136
1137 fh.cx = cx;
1138
1139 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1140 return -ENXIO;
1141
1142 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1143 return 0;
1144
1145 while (--fw_retry_count > 0) {
1146 /* load firmware */
1147 if (cx18_firmware_init(cx) == 0)
1148 break;
1149 if (fw_retry_count > 1)
1150 CX18_WARN("Retry loading firmware\n");
1151 }
1152
1153 if (fw_retry_count == 0) {
1154 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1155 return -ENXIO;
1156 }
1157 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1158
1159 /*
1160 * Init the firmware twice to work around a silicon bug
1161 * with the digital TS.
1162 *
1163 * The second firmware load requires us to normalize the APU state,
1164 * or the audio for the first analog capture will be badly incorrect.
1165 *
1166 * I can't seem to call APU_RESETAI and have it succeed without the
1167 * APU capturing audio, so we start and stop it here to do the reset
1168 */
1169
1170 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1171 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1172 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1173 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1174
1175 fw_retry_count = 3;
1176 while (--fw_retry_count > 0) {
1177 /* load firmware */
1178 if (cx18_firmware_init(cx) == 0)
1179 break;
1180 if (fw_retry_count > 1)
1181 CX18_WARN("Retry loading firmware\n");
1182 }
1183
1184 if (fw_retry_count == 0) {
1185 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1186 return -ENXIO;
1187 }
1188
1189 /*
1190 * The second firmware load requires us to normalize the APU state,
1191 * or the audio for the first analog capture will be badly incorrect.
1192 *
1193 * I can't seem to call APU_RESETAI and have it succeed without the
1194 * APU capturing audio, so we start and stop it here to do the reset
1195 */
1196
1197 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1198 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1199 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1200 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1201
1202 /* Init the A/V decoder, if it hasn't been already */
1203 v4l2_subdev_call(cx->sd_av, core, load_fw);
1204
1205 vf.tuner = 0;
1206 vf.type = V4L2_TUNER_ANALOG_TV;
1207 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1208
1209 /* Set initial frequency. For PAL/SECAM broadcasts no
1210 'default' channel exists AFAIK. */
1211 if (cx->std == V4L2_STD_NTSC_M_JP)
1212 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1213 else if (cx->std & V4L2_STD_NTSC_M)
1214 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1215
1216 video_input = cx->active_input;
1217 cx->active_input++; /* Force update of input */
1218 cx18_s_input(NULL, &fh, video_input);
1219
1220 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1221 in one place. */
1222 cx->std++; /* Force full standard initialization */
1223 cx18_s_std(NULL, &fh, &cx->tuner_std);
1224 cx18_s_frequency(NULL, &fh, &vf);
1225 return 0;
1226 }
1227
cx18_cancel_in_work_orders(struct cx18 * cx)1228 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1229 {
1230 int i;
1231 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1232 cancel_work_sync(&cx->in_work_order[i].work);
1233 }
1234
cx18_cancel_out_work_orders(struct cx18 * cx)1235 static void cx18_cancel_out_work_orders(struct cx18 *cx)
1236 {
1237 int i;
1238 for (i = 0; i < CX18_MAX_STREAMS; i++)
1239 if (&cx->streams[i].video_dev != NULL)
1240 cancel_work_sync(&cx->streams[i].out_work_order);
1241 }
1242
cx18_remove(struct pci_dev * pci_dev)1243 static void cx18_remove(struct pci_dev *pci_dev)
1244 {
1245 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1246 struct cx18 *cx = to_cx18(v4l2_dev);
1247 int i;
1248
1249 CX18_DEBUG_INFO("Removing Card\n");
1250
1251 flush_request_modules(cx);
1252
1253 /* Stop all captures */
1254 CX18_DEBUG_INFO("Stopping all streams\n");
1255 if (atomic_read(&cx->tot_capturing) > 0)
1256 cx18_stop_all_captures(cx);
1257
1258 /* Stop interrupts that cause incoming work to be queued */
1259 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1260
1261 /* Incoming work can cause outgoing work, so clean up incoming first */
1262 cx18_cancel_in_work_orders(cx);
1263 cx18_cancel_out_work_orders(cx);
1264
1265 /* Stop ack interrupts that may have been needed for work to finish */
1266 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1267
1268 cx18_halt_firmware(cx);
1269
1270 destroy_workqueue(cx->in_work_queue);
1271
1272 cx18_streams_cleanup(cx, 1);
1273
1274 exit_cx18_i2c(cx);
1275
1276 free_irq(cx->pci_dev->irq, (void *)cx);
1277
1278 cx18_iounmap(cx);
1279
1280 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1281
1282 pci_disable_device(cx->pci_dev);
1283
1284 if (cx->vbi.sliced_mpeg_data[0] != NULL)
1285 for (i = 0; i < CX18_VBI_FRAMES; i++)
1286 kfree(cx->vbi.sliced_mpeg_data[i]);
1287
1288 v4l2_ctrl_handler_free(&cx->av_state.hdl);
1289
1290 CX18_INFO("Removed %s\n", cx->card_name);
1291
1292 v4l2_device_unregister(v4l2_dev);
1293 kfree(cx);
1294 }
1295
1296
1297 /* define a pci_driver for card detection */
1298 static struct pci_driver cx18_pci_driver = {
1299 .name = "cx18",
1300 .id_table = cx18_pci_tbl,
1301 .probe = cx18_probe,
1302 .remove = cx18_remove,
1303 };
1304
module_start(void)1305 static int __init module_start(void)
1306 {
1307 printk(KERN_INFO "cx18: Start initialization, version %s\n",
1308 CX18_VERSION);
1309
1310 /* Validate parameters */
1311 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1312 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1313 CX18_MAX_CARDS - 1);
1314 return -1;
1315 }
1316
1317 if (cx18_debug < 0 || cx18_debug > 511) {
1318 cx18_debug = 0;
1319 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1320 }
1321
1322 if (pci_register_driver(&cx18_pci_driver)) {
1323 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1324 return -ENODEV;
1325 }
1326 printk(KERN_INFO "cx18: End initialization\n");
1327 return 0;
1328 }
1329
module_cleanup(void)1330 static void __exit module_cleanup(void)
1331 {
1332 pci_unregister_driver(&cx18_pci_driver);
1333 }
1334
1335 module_init(module_start);
1336 module_exit(module_cleanup);
1337