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