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