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