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