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