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