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 #include <linux/dma-mapping.h>
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[] = {
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, int, &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(&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(tv, 0, sizeof(*tv));
331
332 c = kzalloc(sizeof(*c), GFP_KERNEL);
333 if (!c)
334 return;
335
336 strlcpy(c->name, "cx18 tveeprom tmp", sizeof(c->name));
337 c->adapter = &cx->i2c_adap[0];
338 c->addr = 0xa0 >> 1;
339
340 if (tveeprom_read(c, eedata, sizeof(eedata)))
341 goto ret;
342
343 switch (cx->card->type) {
344 case CX18_CARD_HVR_1600_ESMT:
345 case CX18_CARD_HVR_1600_SAMSUNG:
346 case CX18_CARD_HVR_1600_S5H1411:
347 tveeprom_hauppauge_analog(c, tv, eedata);
348 break;
349 case CX18_CARD_YUAN_MPC718:
350 case CX18_CARD_GOTVIEW_PCI_DVD3:
351 tv->model = 0x718;
352 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
353 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
354 eedata[2], eedata[1], eedata[4], eedata[3]);
355 break;
356 default:
357 tv->model = 0xffffffff;
358 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
359 break;
360 }
361
362 ret:
363 kfree(c);
364 }
365
cx18_process_eeprom(struct cx18 * cx)366 static void cx18_process_eeprom(struct cx18 *cx)
367 {
368 struct tveeprom tv;
369
370 cx18_read_eeprom(cx, &tv);
371
372 /* Many thanks to Steven Toth from Hauppauge for providing the
373 model numbers */
374 /* Note: the Samsung memory models cannot be reliably determined
375 from the model number. Use the cardtype module option if you
376 have one of these preproduction models. */
377 switch (tv.model) {
378 case 74301: /* Retail models */
379 case 74321:
380 case 74351: /* OEM models */
381 case 74361:
382 /* Digital side is s5h1411/tda18271 */
383 cx->card = cx18_get_card(CX18_CARD_HVR_1600_S5H1411);
384 break;
385 case 74021: /* Retail models */
386 case 74031:
387 case 74041:
388 case 74141:
389 case 74541: /* OEM models */
390 case 74551:
391 case 74591:
392 case 74651:
393 case 74691:
394 case 74751:
395 case 74891:
396 /* Digital side is s5h1409/mxl5005s */
397 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
398 break;
399 case 0x718:
400 return;
401 case 0xffffffff:
402 CX18_INFO("Unknown EEPROM encoding\n");
403 return;
404 case 0:
405 CX18_ERR("Invalid EEPROM\n");
406 return;
407 default:
408 CX18_ERR("Unknown model %d, defaulting to original HVR-1600 "
409 "(cardtype=1)\n", tv.model);
410 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
411 break;
412 }
413
414 cx->v4l2_cap = cx->card->v4l2_capabilities;
415 cx->card_name = cx->card->name;
416 cx->card_i2c = cx->card->i2c;
417
418 CX18_INFO("Autodetected %s\n", cx->card_name);
419
420 if (tv.tuner_type == TUNER_ABSENT)
421 CX18_ERR("tveeprom cannot autodetect tuner!\n");
422
423 if (cx->options.tuner == -1)
424 cx->options.tuner = tv.tuner_type;
425 if (cx->options.radio == -1)
426 cx->options.radio = (tv.has_radio != 0);
427
428 if (cx->std != 0)
429 /* user specified tuner standard */
430 return;
431
432 /* autodetect tuner standard */
433 #define TVEEPROM_TUNER_FORMAT_ALL (V4L2_STD_B | V4L2_STD_GH | \
434 V4L2_STD_MN | \
435 V4L2_STD_PAL_I | \
436 V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC | \
437 V4L2_STD_DK)
438 if ((tv.tuner_formats & TVEEPROM_TUNER_FORMAT_ALL)
439 == TVEEPROM_TUNER_FORMAT_ALL) {
440 CX18_DEBUG_INFO("Worldwide tuner detected\n");
441 cx->std = V4L2_STD_ALL;
442 } else if (tv.tuner_formats & V4L2_STD_PAL) {
443 CX18_DEBUG_INFO("PAL tuner detected\n");
444 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
445 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
446 CX18_DEBUG_INFO("NTSC tuner detected\n");
447 cx->std |= V4L2_STD_NTSC_M;
448 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
449 CX18_DEBUG_INFO("SECAM tuner detected\n");
450 cx->std |= V4L2_STD_SECAM_L;
451 } else {
452 CX18_INFO("No tuner detected, default to NTSC-M\n");
453 cx->std |= V4L2_STD_NTSC_M;
454 }
455 }
456
cx18_parse_std(struct cx18 * cx)457 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
458 {
459 switch (pal[0]) {
460 case '6':
461 return V4L2_STD_PAL_60;
462 case 'b':
463 case 'B':
464 case 'g':
465 case 'G':
466 return V4L2_STD_PAL_BG;
467 case 'h':
468 case 'H':
469 return V4L2_STD_PAL_H;
470 case 'n':
471 case 'N':
472 if (pal[1] == 'c' || pal[1] == 'C')
473 return V4L2_STD_PAL_Nc;
474 return V4L2_STD_PAL_N;
475 case 'i':
476 case 'I':
477 return V4L2_STD_PAL_I;
478 case 'd':
479 case 'D':
480 case 'k':
481 case 'K':
482 return V4L2_STD_PAL_DK;
483 case 'M':
484 case 'm':
485 return V4L2_STD_PAL_M;
486 case '-':
487 break;
488 default:
489 CX18_WARN("pal= argument not recognised\n");
490 return 0;
491 }
492
493 switch (secam[0]) {
494 case 'b':
495 case 'B':
496 case 'g':
497 case 'G':
498 case 'h':
499 case 'H':
500 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
501 case 'd':
502 case 'D':
503 case 'k':
504 case 'K':
505 return V4L2_STD_SECAM_DK;
506 case 'l':
507 case 'L':
508 if (secam[1] == 'C' || secam[1] == 'c')
509 return V4L2_STD_SECAM_LC;
510 return V4L2_STD_SECAM_L;
511 case '-':
512 break;
513 default:
514 CX18_WARN("secam= argument not recognised\n");
515 return 0;
516 }
517
518 switch (ntsc[0]) {
519 case 'm':
520 case 'M':
521 return V4L2_STD_NTSC_M;
522 case 'j':
523 case 'J':
524 return V4L2_STD_NTSC_M_JP;
525 case 'k':
526 case 'K':
527 return V4L2_STD_NTSC_M_KR;
528 case '-':
529 break;
530 default:
531 CX18_WARN("ntsc= argument not recognised\n");
532 return 0;
533 }
534
535 /* no match found */
536 return 0;
537 }
538
cx18_process_options(struct cx18 * cx)539 static void cx18_process_options(struct cx18 *cx)
540 {
541 int i, j;
542
543 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
544 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
545 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
546 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
547 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
548 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
549 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
550
551 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
552 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
553 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
554 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
555 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
556 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
557 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
558
559 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
560 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
561 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
562 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
563 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
564 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
565 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
566
567 /* Ensure stream_buffers & stream_buf_size are valid */
568 for (i = 0; i < CX18_MAX_STREAMS; i++) {
569 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */
570 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */
571 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */
572 cx->options.megabytes[i] = 0;
573 cx->stream_buffers[i] = 0;
574 cx->stream_buf_size[i] = 0;
575 continue;
576 }
577 /*
578 * YUV is a special case where the stream_buf_size needs to be
579 * an integral multiple of 33.75 kB (storage for 32 screens
580 * lines to maintain alignment in case of lost buffers).
581 *
582 * IDX is a special case where the stream_buf_size should be
583 * an integral multiple of 1.5 kB (storage for 64 index entries
584 * to maintain alignment in case of lost buffers).
585 *
586 */
587 if (i == CX18_ENC_STREAM_TYPE_YUV) {
588 cx->stream_buf_size[i] *= 1024;
589 cx->stream_buf_size[i] -=
590 (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE);
591
592 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
593 cx->stream_buf_size[i] =
594 CX18_UNIT_ENC_YUV_BUFSIZE;
595 } else if (i == CX18_ENC_STREAM_TYPE_IDX) {
596 cx->stream_buf_size[i] *= 1024;
597 cx->stream_buf_size[i] -=
598 (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE);
599
600 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)
601 cx->stream_buf_size[i] =
602 CX18_UNIT_ENC_IDX_BUFSIZE;
603 }
604 /*
605 * YUV and IDX are special cases where the stream_buf_size is
606 * now in bytes.
607 * VBI is a special case where the stream_buf_size is fixed
608 * and already in bytes
609 */
610 if (i == CX18_ENC_STREAM_TYPE_VBI ||
611 i == CX18_ENC_STREAM_TYPE_YUV ||
612 i == CX18_ENC_STREAM_TYPE_IDX) {
613 if (cx->stream_buffers[i] < 0) {
614 cx->stream_buffers[i] =
615 cx->options.megabytes[i] * 1024 * 1024
616 / cx->stream_buf_size[i];
617 } else {
618 /* N.B. This might round down to 0 */
619 cx->options.megabytes[i] =
620 cx->stream_buffers[i]
621 * cx->stream_buf_size[i]/(1024 * 1024);
622 }
623 } else {
624 /* All other streams have stream_buf_size in kB here */
625 if (cx->stream_buffers[i] < 0) {
626 cx->stream_buffers[i] =
627 cx->options.megabytes[i] * 1024
628 / cx->stream_buf_size[i];
629 } else {
630 /* N.B. This might round down to 0 */
631 cx->options.megabytes[i] =
632 cx->stream_buffers[i]
633 * cx->stream_buf_size[i] / 1024;
634 }
635 /* convert from kB to bytes */
636 cx->stream_buf_size[i] *= 1024;
637 }
638 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
639 "%d bytes\n", i, cx->options.megabytes[i],
640 cx->stream_buffers[i], cx->stream_buf_size[i]);
641 }
642
643 cx->options.cardtype = cardtype[cx->instance];
644 cx->options.tuner = tuner[cx->instance];
645 cx->options.radio = radio[cx->instance];
646
647 cx->std = cx18_parse_std(cx);
648 if (cx->options.cardtype == -1) {
649 CX18_INFO("Ignore card\n");
650 return;
651 }
652 cx->card = cx18_get_card(cx->options.cardtype - 1);
653 if (cx->card)
654 CX18_INFO("User specified %s card\n", cx->card->name);
655 else if (cx->options.cardtype != 0)
656 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
657 if (cx->card == NULL) {
658 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
659 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
660 CX18_INFO("Autodetected Hauppauge card\n");
661 }
662 }
663 if (cx->card == NULL) {
664 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
665 if (cx->card->pci_list == NULL)
666 continue;
667 for (j = 0; cx->card->pci_list[j].device; j++) {
668 if (cx->pci_dev->device !=
669 cx->card->pci_list[j].device)
670 continue;
671 if (cx->pci_dev->subsystem_vendor !=
672 cx->card->pci_list[j].subsystem_vendor)
673 continue;
674 if (cx->pci_dev->subsystem_device !=
675 cx->card->pci_list[j].subsystem_device)
676 continue;
677 CX18_INFO("Autodetected %s card\n", cx->card->name);
678 goto done;
679 }
680 }
681 }
682 done:
683
684 if (cx->card == NULL) {
685 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
686 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
687 cx->pci_dev->vendor, cx->pci_dev->device);
688 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
689 cx->pci_dev->subsystem_vendor,
690 cx->pci_dev->subsystem_device);
691 CX18_ERR("Defaulting to %s card\n", cx->card->name);
692 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
693 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
694 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
695 }
696 cx->v4l2_cap = cx->card->v4l2_capabilities;
697 cx->card_name = cx->card->name;
698 cx->card_i2c = cx->card->i2c;
699 }
700
cx18_create_in_workq(struct cx18 * cx)701 static int cx18_create_in_workq(struct cx18 *cx)
702 {
703 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
704 cx->v4l2_dev.name);
705 cx->in_work_queue = alloc_ordered_workqueue("%s", 0, cx->in_workq_name);
706 if (cx->in_work_queue == NULL) {
707 CX18_ERR("Unable to create incoming mailbox handler thread\n");
708 return -ENOMEM;
709 }
710 return 0;
711 }
712
cx18_init_in_work_orders(struct cx18 * cx)713 static void cx18_init_in_work_orders(struct cx18 *cx)
714 {
715 int i;
716 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
717 cx->in_work_order[i].cx = cx;
718 cx->in_work_order[i].str = cx->epu_debug_str;
719 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
720 }
721 }
722
723 /* Precondition: the cx18 structure has been memset to 0. Only
724 the dev and instance fields have been filled in.
725 No assumptions on the card type may be made here (see cx18_init_struct2
726 for that).
727 */
cx18_init_struct1(struct cx18 * cx)728 static int cx18_init_struct1(struct cx18 *cx)
729 {
730 int ret;
731
732 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
733
734 mutex_init(&cx->serialize_lock);
735 mutex_init(&cx->gpio_lock);
736 mutex_init(&cx->epu2apu_mb_lock);
737 mutex_init(&cx->epu2cpu_mb_lock);
738
739 ret = cx18_create_in_workq(cx);
740 if (ret)
741 return ret;
742
743 cx18_init_in_work_orders(cx);
744
745 /* start counting open_id at 1 */
746 cx->open_id = 1;
747
748 /* Initial settings */
749 cx->cxhdl.port = CX2341X_PORT_MEMORY;
750 cx->cxhdl.capabilities = CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
751 cx->cxhdl.ops = &cx18_cxhdl_ops;
752 cx->cxhdl.func = cx18_api_func;
753 cx->cxhdl.priv = &cx->streams[CX18_ENC_STREAM_TYPE_MPG];
754 ret = cx2341x_handler_init(&cx->cxhdl, 50);
755 if (ret)
756 return ret;
757 cx->v4l2_dev.ctrl_handler = &cx->cxhdl.hdl;
758
759 cx->temporal_strength = cx->cxhdl.video_temporal_filter->cur.val;
760 cx->spatial_strength = cx->cxhdl.video_spatial_filter->cur.val;
761 cx->filter_mode = cx->cxhdl.video_spatial_filter_mode->cur.val |
762 (cx->cxhdl.video_temporal_filter_mode->cur.val << 1) |
763 (cx->cxhdl.video_median_filter_type->cur.val << 2);
764
765 init_waitqueue_head(&cx->cap_w);
766 init_waitqueue_head(&cx->mb_apu_waitq);
767 init_waitqueue_head(&cx->mb_cpu_waitq);
768 init_waitqueue_head(&cx->dma_waitq);
769
770 /* VBI */
771 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
772 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
773
774 /* IVTV style VBI insertion into MPEG streams */
775 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list);
776 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
777 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
778 list_add(&cx->vbi.sliced_mpeg_buf.list,
779 &cx->vbi.sliced_mpeg_mdl.buf_list);
780 return 0;
781 }
782
783 /* Second initialization part. Here the card type has been
784 autodetected. */
cx18_init_struct2(struct cx18 * cx)785 static void cx18_init_struct2(struct cx18 *cx)
786 {
787 int i;
788
789 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
790 if (cx->card->video_inputs[i].video_type == 0)
791 break;
792 cx->nof_inputs = i;
793 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
794 if (cx->card->audio_inputs[i].audio_type == 0)
795 break;
796 cx->nof_audio_inputs = i;
797
798 /* Find tuner input */
799 for (i = 0; i < cx->nof_inputs; i++) {
800 if (cx->card->video_inputs[i].video_type ==
801 CX18_CARD_INPUT_VID_TUNER)
802 break;
803 }
804 if (i == cx->nof_inputs)
805 i = 0;
806 cx->active_input = i;
807 cx->audio_input = cx->card->video_inputs[i].audio_index;
808 }
809
cx18_setup_pci(struct cx18 * cx,struct pci_dev * pci_dev,const struct pci_device_id * pci_id)810 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
811 const struct pci_device_id *pci_id)
812 {
813 u16 cmd;
814 unsigned char pci_latency;
815
816 CX18_DEBUG_INFO("Enabling pci device\n");
817
818 if (pci_enable_device(pci_dev)) {
819 CX18_ERR("Can't enable device %d!\n", cx->instance);
820 return -EIO;
821 }
822 if (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32))) {
823 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
824 return -EIO;
825 }
826 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
827 CX18_ERR("Cannot request encoder memory region, card %d\n",
828 cx->instance);
829 return -EIO;
830 }
831
832 /* Enable bus mastering and memory mapped IO for the CX23418 */
833 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
834 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
835 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
836
837 cx->card_rev = pci_dev->revision;
838 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
839
840 if (pci_latency < 64 && cx18_pci_latency) {
841 CX18_INFO("Unreasonably low latency timer, "
842 "setting to 64 (was %d)\n", pci_latency);
843 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
844 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
845 }
846
847 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
848 "irq: %d, latency: %d, memory: 0x%llx\n",
849 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
850 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
851 cx->pci_dev->irq, pci_latency, (u64)cx->base_addr);
852
853 return 0;
854 }
855
cx18_init_subdevs(struct cx18 * cx)856 static void cx18_init_subdevs(struct cx18 *cx)
857 {
858 u32 hw = cx->card->hw_all;
859 u32 device;
860 int i;
861
862 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
863
864 if (!(device & hw))
865 continue;
866
867 switch (device) {
868 case CX18_HW_DVB:
869 case CX18_HW_TVEEPROM:
870 /* These subordinate devices do not use probing */
871 cx->hw_flags |= device;
872 break;
873 case CX18_HW_418_AV:
874 /* The A/V decoder gets probed earlier to set PLLs */
875 /* Just note that the card uses it (i.e. has analog) */
876 cx->hw_flags |= device;
877 break;
878 case CX18_HW_GPIO_RESET_CTRL:
879 /*
880 * The Reset Controller gets probed and added to
881 * hw_flags earlier for i2c adapter/bus initialization
882 */
883 break;
884 case CX18_HW_GPIO_MUX:
885 if (cx18_gpio_register(cx, device) == 0)
886 cx->hw_flags |= device;
887 break;
888 default:
889 if (cx18_i2c_register(cx, i) == 0)
890 cx->hw_flags |= device;
891 break;
892 }
893 }
894
895 if (cx->hw_flags & CX18_HW_418_AV)
896 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
897
898 if (cx->card->hw_muxer != 0)
899 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
900 }
901
cx18_probe(struct pci_dev * pci_dev,const struct pci_device_id * pci_id)902 static int cx18_probe(struct pci_dev *pci_dev,
903 const struct pci_device_id *pci_id)
904 {
905 int retval = 0;
906 int i;
907 u32 devtype;
908 struct cx18 *cx;
909
910 /* FIXME - module parameter arrays constrain max instances */
911 i = atomic_inc_return(&cx18_instance) - 1;
912 if (i >= CX18_MAX_CARDS) {
913 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
914 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
915 return -ENOMEM;
916 }
917
918 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
919 if (cx == NULL) {
920 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
921 i);
922 return -ENOMEM;
923 }
924 cx->pci_dev = pci_dev;
925 cx->instance = i;
926
927 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
928 if (retval) {
929 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
930 "\n", cx->instance);
931 kfree(cx);
932 return retval;
933 }
934 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
935 cx->instance);
936 CX18_INFO("Initializing card %d\n", cx->instance);
937
938 cx18_process_options(cx);
939 if (cx->options.cardtype == -1) {
940 retval = -ENODEV;
941 goto err;
942 }
943
944 retval = cx18_init_struct1(cx);
945 if (retval)
946 goto err;
947
948 CX18_DEBUG_INFO("base addr: 0x%llx\n", (u64)cx->base_addr);
949
950 /* PCI Device Setup */
951 retval = cx18_setup_pci(cx, pci_dev, pci_id);
952 if (retval != 0)
953 goto free_workqueues;
954
955 /* map io memory */
956 CX18_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
957 (u64)cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
958 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
959 CX18_MEM_SIZE);
960 if (!cx->enc_mem) {
961 CX18_ERR("ioremap failed. Can't get a window into CX23418 "
962 "memory and register space\n");
963 CX18_ERR("Each capture card with a CX23418 needs 64 MB of "
964 "vmalloc address space for the window\n");
965 CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
966 CX18_ERR("Use the vmalloc= kernel command line option to set "
967 "VmallocTotal to a larger value\n");
968 retval = -ENOMEM;
969 goto free_mem;
970 }
971 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
972 devtype = cx18_read_reg(cx, 0xC72028);
973 switch (devtype & 0xff000000) {
974 case 0xff000000:
975 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
976 break;
977 case 0x01000000:
978 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
979 break;
980 default:
981 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
982 break;
983 }
984
985 cx18_init_power(cx, 1);
986 cx18_init_memory(cx);
987
988 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
989 cx18_init_scb(cx);
990
991 cx18_gpio_init(cx);
992
993 /* Initialize integrated A/V decoder early to set PLLs, just in case */
994 retval = cx18_av_probe(cx);
995 if (retval) {
996 CX18_ERR("Could not register A/V decoder subdevice\n");
997 goto free_map;
998 }
999
1000 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
1001 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
1002 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
1003 CX18_WARN("Could not register GPIO reset controller"
1004 "subdevice; proceeding anyway.\n");
1005 else
1006 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
1007 }
1008
1009 /* active i2c */
1010 CX18_DEBUG_INFO("activating i2c...\n");
1011 retval = init_cx18_i2c(cx);
1012 if (retval) {
1013 CX18_ERR("Could not initialize i2c\n");
1014 goto free_map;
1015 }
1016
1017 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
1018 /* Based on the model number the cardtype may be changed.
1019 The PCI IDs are not always reliable. */
1020 const struct cx18_card *orig_card = cx->card;
1021 cx18_process_eeprom(cx);
1022
1023 if (cx->card != orig_card) {
1024 /* Changed the cardtype; re-reset the I2C chips */
1025 cx18_gpio_init(cx);
1026 cx18_call_hw(cx, CX18_HW_GPIO_RESET_CTRL,
1027 core, reset, (u32) CX18_GPIO_RESET_I2C);
1028 }
1029 }
1030 if (cx->card->comment)
1031 CX18_INFO("%s", cx->card->comment);
1032 if (cx->card->v4l2_capabilities == 0) {
1033 retval = -ENODEV;
1034 goto free_i2c;
1035 }
1036 cx18_init_memory(cx);
1037 cx18_init_scb(cx);
1038
1039 /* Register IRQ */
1040 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
1041 IRQF_SHARED, cx->v4l2_dev.name, (void *)cx);
1042 if (retval) {
1043 CX18_ERR("Failed to register irq %d\n", retval);
1044 goto free_i2c;
1045 }
1046
1047 if (cx->std == 0)
1048 cx->std = V4L2_STD_NTSC_M;
1049
1050 if (cx->options.tuner == -1) {
1051 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
1052 if ((cx->std & cx->card->tuners[i].std) == 0)
1053 continue;
1054 cx->options.tuner = cx->card->tuners[i].tuner;
1055 break;
1056 }
1057 }
1058 /* if no tuner was found, then pick the first tuner in the card list */
1059 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
1060 cx->std = cx->card->tuners[0].std;
1061 if (cx->std & V4L2_STD_PAL)
1062 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1063 else if (cx->std & V4L2_STD_NTSC)
1064 cx->std = V4L2_STD_NTSC_M;
1065 else if (cx->std & V4L2_STD_SECAM)
1066 cx->std = V4L2_STD_SECAM_L;
1067 cx->options.tuner = cx->card->tuners[0].tuner;
1068 }
1069 if (cx->options.radio == -1)
1070 cx->options.radio = (cx->card->radio_input.audio_type != 0);
1071
1072 /* The card is now fully identified, continue with card-specific
1073 initialization. */
1074 cx18_init_struct2(cx);
1075
1076 cx18_init_subdevs(cx);
1077
1078 if (cx->std & V4L2_STD_525_60)
1079 cx->is_60hz = 1;
1080 else
1081 cx->is_50hz = 1;
1082
1083 cx2341x_handler_set_50hz(&cx->cxhdl, !cx->is_60hz);
1084
1085 if (cx->options.radio > 0)
1086 cx->v4l2_cap |= V4L2_CAP_RADIO;
1087
1088 if (cx->options.tuner > -1) {
1089 struct tuner_setup setup;
1090
1091 setup.addr = ADDR_UNSET;
1092 setup.type = cx->options.tuner;
1093 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1094 setup.config = NULL;
1095 if (cx->options.radio > 0)
1096 setup.mode_mask |= T_RADIO;
1097 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1098 cx18_reset_tuner_gpio : NULL;
1099 cx18_call_all(cx, tuner, s_type_addr, &setup);
1100 if (setup.type == TUNER_XC2028) {
1101 static struct xc2028_ctrl ctrl = {
1102 .fname = XC2028_DEFAULT_FIRMWARE,
1103 .max_len = 64,
1104 };
1105 struct v4l2_priv_tun_config cfg = {
1106 .tuner = cx->options.tuner,
1107 .priv = &ctrl,
1108 };
1109 cx18_call_all(cx, tuner, s_config, &cfg);
1110 }
1111 }
1112
1113 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1114 are not. */
1115 cx->tuner_std = cx->std;
1116 if (cx->std == V4L2_STD_ALL)
1117 cx->std = V4L2_STD_NTSC_M;
1118
1119 retval = cx18_streams_setup(cx);
1120 if (retval) {
1121 CX18_ERR("Error %d setting up streams\n", retval);
1122 goto free_irq;
1123 }
1124 retval = cx18_streams_register(cx);
1125 if (retval) {
1126 CX18_ERR("Error %d registering devices\n", retval);
1127 goto free_streams;
1128 }
1129
1130 CX18_INFO("Initialized card: %s\n", cx->card_name);
1131
1132 /* Load cx18 submodules (cx18-alsa) */
1133 request_modules(cx);
1134 return 0;
1135
1136 free_streams:
1137 cx18_streams_cleanup(cx, 1);
1138 free_irq:
1139 free_irq(cx->pci_dev->irq, (void *)cx);
1140 free_i2c:
1141 exit_cx18_i2c(cx);
1142 free_map:
1143 cx18_iounmap(cx);
1144 free_mem:
1145 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1146 free_workqueues:
1147 destroy_workqueue(cx->in_work_queue);
1148 err:
1149 if (retval == 0)
1150 retval = -ENODEV;
1151 CX18_ERR("Error %d on initialization\n", retval);
1152
1153 v4l2_device_unregister(&cx->v4l2_dev);
1154 kfree(cx);
1155 return retval;
1156 }
1157
cx18_init_on_first_open(struct cx18 * cx)1158 int cx18_init_on_first_open(struct cx18 *cx)
1159 {
1160 int video_input;
1161 int fw_retry_count = 3;
1162 struct v4l2_frequency vf;
1163 struct cx18_open_id fh;
1164 v4l2_std_id std;
1165
1166 fh.cx = cx;
1167
1168 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1169 return -ENXIO;
1170
1171 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1172 return 0;
1173
1174 while (--fw_retry_count > 0) {
1175 /* load firmware */
1176 if (cx18_firmware_init(cx) == 0)
1177 break;
1178 if (fw_retry_count > 1)
1179 CX18_WARN("Retry loading firmware\n");
1180 }
1181
1182 if (fw_retry_count == 0) {
1183 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1184 return -ENXIO;
1185 }
1186 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1187
1188 /*
1189 * Init the firmware twice to work around a silicon bug
1190 * with the digital TS.
1191 *
1192 * The second firmware load requires us to normalize the APU state,
1193 * or the audio for the first analog capture will be badly incorrect.
1194 *
1195 * I can't seem to call APU_RESETAI and have it succeed without the
1196 * APU capturing audio, so we start and stop it here to do the reset
1197 */
1198
1199 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1200 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1201 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1202 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1203
1204 fw_retry_count = 3;
1205 while (--fw_retry_count > 0) {
1206 /* load firmware */
1207 if (cx18_firmware_init(cx) == 0)
1208 break;
1209 if (fw_retry_count > 1)
1210 CX18_WARN("Retry loading firmware\n");
1211 }
1212
1213 if (fw_retry_count == 0) {
1214 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1215 return -ENXIO;
1216 }
1217
1218 /*
1219 * The second firmware load requires us to normalize the APU state,
1220 * or the audio for the first analog capture will be badly incorrect.
1221 *
1222 * I can't seem to call APU_RESETAI and have it succeed without the
1223 * APU capturing audio, so we start and stop it here to do the reset
1224 */
1225
1226 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1227 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1228 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1229 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1230
1231 /* Init the A/V decoder, if it hasn't been already */
1232 v4l2_subdev_call(cx->sd_av, core, load_fw);
1233
1234 vf.tuner = 0;
1235 vf.type = V4L2_TUNER_ANALOG_TV;
1236 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1237
1238 /* Set initial frequency. For PAL/SECAM broadcasts no
1239 'default' channel exists AFAIK. */
1240 if (cx->std == V4L2_STD_NTSC_M_JP)
1241 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1242 else if (cx->std & V4L2_STD_NTSC_M)
1243 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1244
1245 video_input = cx->active_input;
1246 cx->active_input++; /* Force update of input */
1247 cx18_s_input(NULL, &fh, video_input);
1248
1249 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1250 in one place. */
1251 cx->std++; /* Force full standard initialization */
1252 std = (cx->tuner_std == V4L2_STD_ALL) ? V4L2_STD_NTSC_M : cx->tuner_std;
1253 cx18_s_std(NULL, &fh, std);
1254 cx18_s_frequency(NULL, &fh, &vf);
1255 return 0;
1256 }
1257
cx18_cancel_in_work_orders(struct cx18 * cx)1258 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1259 {
1260 int i;
1261 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1262 cancel_work_sync(&cx->in_work_order[i].work);
1263 }
1264
cx18_cancel_out_work_orders(struct cx18 * cx)1265 static void cx18_cancel_out_work_orders(struct cx18 *cx)
1266 {
1267 int i;
1268 for (i = 0; i < CX18_MAX_STREAMS; i++)
1269 if (&cx->streams[i].video_dev != NULL)
1270 cancel_work_sync(&cx->streams[i].out_work_order);
1271 }
1272
cx18_remove(struct pci_dev * pci_dev)1273 static void cx18_remove(struct pci_dev *pci_dev)
1274 {
1275 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1276 struct cx18 *cx = to_cx18(v4l2_dev);
1277 int i;
1278
1279 CX18_DEBUG_INFO("Removing Card\n");
1280
1281 flush_request_modules(cx);
1282
1283 /* Stop all captures */
1284 CX18_DEBUG_INFO("Stopping all streams\n");
1285 if (atomic_read(&cx->tot_capturing) > 0)
1286 cx18_stop_all_captures(cx);
1287
1288 /* Stop interrupts that cause incoming work to be queued */
1289 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1290
1291 /* Incoming work can cause outgoing work, so clean up incoming first */
1292 cx18_cancel_in_work_orders(cx);
1293 cx18_cancel_out_work_orders(cx);
1294
1295 /* Stop ack interrupts that may have been needed for work to finish */
1296 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1297
1298 cx18_halt_firmware(cx);
1299
1300 destroy_workqueue(cx->in_work_queue);
1301
1302 cx18_streams_cleanup(cx, 1);
1303
1304 exit_cx18_i2c(cx);
1305
1306 free_irq(cx->pci_dev->irq, (void *)cx);
1307
1308 cx18_iounmap(cx);
1309
1310 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1311
1312 pci_disable_device(cx->pci_dev);
1313
1314 if (cx->vbi.sliced_mpeg_data[0] != NULL)
1315 for (i = 0; i < CX18_VBI_FRAMES; i++)
1316 kfree(cx->vbi.sliced_mpeg_data[i]);
1317
1318 v4l2_ctrl_handler_free(&cx->av_state.hdl);
1319
1320 CX18_INFO("Removed %s\n", cx->card_name);
1321
1322 v4l2_device_unregister(v4l2_dev);
1323 kfree(cx);
1324 }
1325
1326
1327 /* define a pci_driver for card detection */
1328 static struct pci_driver cx18_pci_driver = {
1329 .name = "cx18",
1330 .id_table = cx18_pci_tbl,
1331 .probe = cx18_probe,
1332 .remove = cx18_remove,
1333 };
1334
module_start(void)1335 static int __init module_start(void)
1336 {
1337 printk(KERN_INFO "cx18: Start initialization, version %s\n",
1338 CX18_VERSION);
1339
1340 /* Validate parameters */
1341 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1342 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1343 CX18_MAX_CARDS - 1);
1344 return -1;
1345 }
1346
1347 if (cx18_debug < 0 || cx18_debug > 511) {
1348 cx18_debug = 0;
1349 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1350 }
1351
1352 if (pci_register_driver(&cx18_pci_driver)) {
1353 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1354 return -ENODEV;
1355 }
1356 printk(KERN_INFO "cx18: End initialization\n");
1357 return 0;
1358 }
1359
module_cleanup(void)1360 static void __exit module_cleanup(void)
1361 {
1362 pci_unregister_driver(&cx18_pci_driver);
1363 }
1364
1365 module_init(module_start);
1366 module_exit(module_cleanup);
1367 MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE);
1368