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