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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42#include "ivtv-driver.h"
43#include "ivtv-version.h"
44#include "ivtv-fileops.h"
45#include "ivtv-i2c.h"
46#include "ivtv-firmware.h"
47#include "ivtv-queue.h"
48#include "ivtv-udma.h"
49#include "ivtv-irq.h"
50#include "ivtv-mailbox.h"
51#include "ivtv-streams.h"
52#include "ivtv-ioctl.h"
53#include "ivtv-cards.h"
54#include "ivtv-vbi.h"
55#include "ivtv-routing.h"
56#include "ivtv-controls.h"
57#include "ivtv-gpio.h"
58#include <linux/dma-mapping.h>
59#include <media/tveeprom.h>
60#include <media/saa7115.h>
61#include "tuner-xc2028.h"
62
63
64
65
66
67
68int ivtv_first_minor;
69
70
71int (*ivtv_ext_init)(struct ivtv *);
72EXPORT_SYMBOL(ivtv_ext_init);
73
74
75static struct pci_device_id ivtv_pci_tbl[] = {
76 {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
77 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
78 {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
79 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
80 {0,}
81};
82
83MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
84
85
86static atomic_t ivtv_instance = ATOMIC_INIT(0);
87
88
89static int cardtype[IVTV_MAX_CARDS];
90static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
91 -1, -1, -1, -1, -1, -1, -1, -1,
92 -1, -1, -1, -1, -1, -1, -1, -1,
93 -1, -1, -1, -1, -1, -1, -1, -1 };
94static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
95 -1, -1, -1, -1, -1, -1, -1, -1,
96 -1, -1, -1, -1, -1, -1, -1, -1,
97 -1, -1, -1, -1, -1, -1, -1, -1 };
98static int i2c_clock_period[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
99 -1, -1, -1, -1, -1, -1, -1, -1,
100 -1, -1, -1, -1, -1, -1, -1, -1,
101 -1, -1, -1, -1, -1, -1, -1, -1 };
102
103static unsigned int cardtype_c = 1;
104static unsigned int tuner_c = 1;
105static int radio_c = 1;
106static unsigned int i2c_clock_period_c = 1;
107static char pal[] = "---";
108static char secam[] = "--";
109static char ntsc[] = "-";
110
111
112
113
114#define IVTV_DEFAULT_ENC_MPG_BUFFERS 4
115#define IVTV_DEFAULT_ENC_YUV_BUFFERS 2
116#define IVTV_DEFAULT_ENC_VBI_BUFFERS 1
117
118#define IVTV_DEFAULT_ENC_PCM_BUFFERS 320
119#define IVTV_DEFAULT_DEC_MPG_BUFFERS 1
120#define IVTV_DEFAULT_DEC_YUV_BUFFERS 1
121
122#define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
123
124static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
125static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
126static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
127static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
128static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
129static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
130static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
131
132static int ivtv_yuv_mode;
133static int ivtv_yuv_threshold = -1;
134static int ivtv_pci_latency = 1;
135
136int ivtv_debug;
137#ifdef CONFIG_VIDEO_ADV_DEBUG
138int ivtv_fw_debug;
139#endif
140
141static int tunertype = -1;
142static int newi2c = -1;
143
144module_param_array(tuner, int, &tuner_c, 0644);
145module_param_array(radio, int, &radio_c, 0644);
146module_param_array(cardtype, int, &cardtype_c, 0644);
147module_param_string(pal, pal, sizeof(pal), 0644);
148module_param_string(secam, secam, sizeof(secam), 0644);
149module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
150module_param_named(debug,ivtv_debug, int, 0644);
151#ifdef CONFIG_VIDEO_ADV_DEBUG
152module_param_named(fw_debug, ivtv_fw_debug, int, 0644);
153#endif
154module_param(ivtv_pci_latency, int, 0644);
155module_param(ivtv_yuv_mode, int, 0644);
156module_param(ivtv_yuv_threshold, int, 0644);
157module_param(ivtv_first_minor, int, 0644);
158
159module_param(enc_mpg_buffers, int, 0644);
160module_param(enc_yuv_buffers, int, 0644);
161module_param(enc_vbi_buffers, int, 0644);
162module_param(enc_pcm_buffers, int, 0644);
163module_param(dec_mpg_buffers, int, 0644);
164module_param(dec_yuv_buffers, int, 0644);
165module_param(dec_vbi_buffers, int, 0644);
166
167module_param(tunertype, int, 0644);
168module_param(newi2c, int, 0644);
169module_param_array(i2c_clock_period, int, &i2c_clock_period_c, 0644);
170
171MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
172 "\t\t\tsee tuner.h for values");
173MODULE_PARM_DESC(radio,
174 "Enable or disable the radio. Use only if autodetection\n"
175 "\t\t\tfails. 0 = disable, 1 = enable");
176MODULE_PARM_DESC(cardtype,
177 "Only use this option if your card is not detected properly.\n"
178 "\t\tSpecify card type:\n"
179 "\t\t\t 1 = WinTV PVR 250\n"
180 "\t\t\t 2 = WinTV PVR 350\n"
181 "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
182 "\t\t\t 4 = AVerMedia M179\n"
183 "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
184 "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
185 "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
186 "\t\t\t 8 = Adaptec AVC-2410\n"
187 "\t\t\t 9 = Adaptec AVC-2010\n"
188 "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
189 "\t\t\t11 = AOpen VA2000MAX-STN6\n"
190 "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
191 "\t\t\t13 = I/O Data GV-MVP/RX\n"
192 "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
193 "\t\t\t15 = GOTVIEW PCI DVD\n"
194 "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
195 "\t\t\t17 = Yuan MPC622\n"
196 "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
197 "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
198 "\t\t\t20 = Club3D ZAP-TV1x01\n"
199 "\t\t\t21 = AverTV MCE 116 Plus\n"
200 "\t\t\t22 = ASUS Falcon2\n"
201 "\t\t\t23 = AverMedia PVR-150 Plus\n"
202 "\t\t\t24 = AverMedia EZMaker PCI Deluxe\n"
203 "\t\t\t25 = AverMedia M104 (not yet working)\n"
204 "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
205 "\t\t\t27 = AVerMedia UltraTV 1500 MCE\n"
206 "\t\t\t28 = Sony VAIO Giga Pocket (ENX Kikyou)\n"
207 "\t\t\t 0 = Autodetect (default)\n"
208 "\t\t\t-1 = Ignore this card\n\t\t");
209MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
210MODULE_PARM_DESC(secam, "Set SECAM standard: BGH, DK, L, LC");
211MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J (Japan), K (South Korea)");
212MODULE_PARM_DESC(tunertype,
213 "Specify tuner type:\n"
214 "\t\t\t 0 = tuner for PAL-B/G/H/D/K/I, SECAM-B/G/H/D/K/L/Lc\n"
215 "\t\t\t 1 = tuner for NTSC-M/J/K, PAL-M/N/Nc\n"
216 "\t\t\t-1 = Autodetect (default)\n");
217MODULE_PARM_DESC(debug,
218 "Debug level (bitmask). Default: 0\n"
219 "\t\t\t 1/0x0001: warning\n"
220 "\t\t\t 2/0x0002: info\n"
221 "\t\t\t 4/0x0004: mailbox\n"
222 "\t\t\t 8/0x0008: ioctl\n"
223 "\t\t\t 16/0x0010: file\n"
224 "\t\t\t 32/0x0020: dma\n"
225 "\t\t\t 64/0x0040: irq\n"
226 "\t\t\t 128/0x0080: decoder\n"
227 "\t\t\t 256/0x0100: yuv\n"
228 "\t\t\t 512/0x0200: i2c\n"
229 "\t\t\t1024/0x0400: high volume\n");
230#ifdef CONFIG_VIDEO_ADV_DEBUG
231MODULE_PARM_DESC(fw_debug,
232 "Enable code for debugging firmware problems. Default: 0\n");
233#endif
234MODULE_PARM_DESC(ivtv_pci_latency,
235 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
236 "\t\t\tDefault: Yes");
237MODULE_PARM_DESC(ivtv_yuv_mode,
238 "Specify the yuv playback mode:\n"
239 "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
240 "\t\t\tDefault: 0 (interlaced)");
241MODULE_PARM_DESC(ivtv_yuv_threshold,
242 "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
243 "\t\t\tDefault: 480");
244MODULE_PARM_DESC(enc_mpg_buffers,
245 "Encoder MPG Buffers (in MB)\n"
246 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
247MODULE_PARM_DESC(enc_yuv_buffers,
248 "Encoder YUV Buffers (in MB)\n"
249 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
250MODULE_PARM_DESC(enc_vbi_buffers,
251 "Encoder VBI Buffers (in MB)\n"
252 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
253MODULE_PARM_DESC(enc_pcm_buffers,
254 "Encoder PCM buffers (in kB)\n"
255 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
256MODULE_PARM_DESC(dec_mpg_buffers,
257 "Decoder MPG buffers (in MB)\n"
258 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
259MODULE_PARM_DESC(dec_yuv_buffers,
260 "Decoder YUV buffers (in MB)\n"
261 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
262MODULE_PARM_DESC(dec_vbi_buffers,
263 "Decoder VBI buffers (in kB)\n"
264 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
265MODULE_PARM_DESC(newi2c,
266 "Use new I2C implementation\n"
267 "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
268 "\t\t\tDefault is autodetect");
269MODULE_PARM_DESC(i2c_clock_period,
270 "Period of SCL for the I2C bus controlled by the CX23415/6\n"
271 "\t\t\tMin: 10 usec (100 kHz), Max: 4500 usec (222 Hz)\n"
272 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_I2C_CLOCK_PERIOD));
273
274MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first card");
275
276MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
277MODULE_DESCRIPTION("CX23415/CX23416 driver");
278MODULE_SUPPORTED_DEVICE
279 ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
280 "\t\t\tYuan MPG series and similar)");
281MODULE_LICENSE("GPL");
282
283MODULE_VERSION(IVTV_VERSION);
284
285#if defined(CONFIG_MODULES) && defined(MODULE)
286static void request_module_async(struct work_struct *work)
287{
288 struct ivtv *dev = container_of(work, struct ivtv, request_module_wk);
289
290
291 request_module("ivtv-alsa");
292
293
294 if (ivtv_ext_init != NULL)
295 ivtv_ext_init(dev);
296}
297
298static void request_modules(struct ivtv *dev)
299{
300 INIT_WORK(&dev->request_module_wk, request_module_async);
301 schedule_work(&dev->request_module_wk);
302}
303
304static void flush_request_modules(struct ivtv *dev)
305{
306 flush_work(&dev->request_module_wk);
307}
308#else
309#define request_modules(dev)
310#define flush_request_modules(dev)
311#endif
312
313void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
314{
315 itv->irqmask &= ~mask;
316 write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
317}
318
319void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
320{
321 itv->irqmask |= mask;
322 write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
323}
324
325int ivtv_set_output_mode(struct ivtv *itv, int mode)
326{
327 int old_mode;
328
329 spin_lock(&itv->lock);
330 old_mode = itv->output_mode;
331 if (old_mode == 0)
332 itv->output_mode = old_mode = mode;
333 spin_unlock(&itv->lock);
334 return old_mode;
335}
336
337struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
338{
339 switch (itv->output_mode) {
340 case OUT_MPG:
341 return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
342 case OUT_YUV:
343 return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
344 default:
345 return NULL;
346 }
347}
348
349int ivtv_waitq(wait_queue_head_t *waitq)
350{
351 DEFINE_WAIT(wait);
352
353 prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
354 schedule();
355 finish_wait(waitq, &wait);
356 return signal_pending(current) ? -EINTR : 0;
357}
358
359
360int ivtv_msleep_timeout(unsigned int msecs, int intr)
361{
362 int timeout = msecs_to_jiffies(msecs);
363
364 do {
365 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
366 timeout = schedule_timeout(timeout);
367 if (intr) {
368 int ret = signal_pending(current);
369
370 if (ret)
371 return ret;
372 }
373 } while (timeout);
374 return 0;
375}
376
377
378static void ivtv_iounmap(struct ivtv *itv)
379{
380 if (itv == NULL)
381 return;
382
383
384 if (itv->reg_mem != NULL) {
385 IVTV_DEBUG_INFO("releasing reg_mem\n");
386 iounmap(itv->reg_mem);
387 itv->reg_mem = NULL;
388 }
389
390 if (itv->has_cx23415 && itv->dec_mem != NULL) {
391 IVTV_DEBUG_INFO("releasing dec_mem\n");
392 iounmap(itv->dec_mem);
393 }
394 itv->dec_mem = NULL;
395
396
397 if (itv->enc_mem != NULL) {
398 IVTV_DEBUG_INFO("releasing enc_mem\n");
399 iounmap(itv->enc_mem);
400 itv->enc_mem = NULL;
401 }
402}
403
404
405void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
406{
407 u8 eedata[256];
408
409 itv->i2c_client.addr = 0xA0 >> 1;
410 tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
411 tveeprom_hauppauge_analog(&itv->i2c_client, tv, eedata);
412}
413
414static void ivtv_process_eeprom(struct ivtv *itv)
415{
416 struct tveeprom tv;
417 int pci_slot = PCI_SLOT(itv->pdev->devfn);
418
419 ivtv_read_eeprom(itv, &tv);
420
421
422
423 switch (tv.model) {
424
425
426
427 case 30012 ... 30039:
428 case 32000 ... 32999:
429 case 48000 ... 48099:
430 case 48400 ... 48599:
431 itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
432 break;
433 case 48100 ... 48399:
434 case 48600 ... 48999:
435 itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
436 break;
437 case 23000 ... 23999:
438 case 25000 ... 25999:
439 case 26000 ... 26999:
440 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
441 break;
442 case 0:
443 IVTV_ERR("Invalid EEPROM\n");
444 return;
445 default:
446 IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
447 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
448 break;
449 }
450
451 switch (tv.model) {
452
453
454 case 48254:
455 itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
456 break;
457 default:
458 break;
459 }
460
461 itv->v4l2_cap = itv->card->v4l2_capabilities;
462 itv->card_name = itv->card->name;
463 itv->card_i2c = itv->card->i2c;
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480 if (tv.model / 1000 == 23) {
481 static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
482 .radio = { 0x60, I2C_CLIENT_END },
483 .demod = { 0x43, I2C_CLIENT_END },
484 .tv = { 0x61, I2C_CLIENT_END },
485 };
486
487 itv->card_name = "WinTV PVR 500";
488 itv->card_i2c = &ivtv_i2c_radio;
489 if (pci_slot == 8 || pci_slot == 9) {
490 int is_first = (pci_slot & 1) == 0;
491
492 itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
493 "WinTV PVR 500 (unit #2)";
494 if (!is_first) {
495 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
496 tv.has_radio = 0;
497 }
498 }
499 }
500 IVTV_INFO("Autodetected %s\n", itv->card_name);
501
502 switch (tv.tuner_hauppauge_model) {
503 case 85:
504 case 99:
505 case 112:
506 itv->pvr150_workaround = 1;
507 break;
508 default:
509 break;
510 }
511 if (tv.tuner_type == TUNER_ABSENT)
512 IVTV_ERR("tveeprom cannot autodetect tuner!\n");
513
514 if (itv->options.tuner == -1)
515 itv->options.tuner = tv.tuner_type;
516 if (itv->options.radio == -1)
517 itv->options.radio = (tv.has_radio != 0);
518
519 if (itv->options.newi2c == -1 && tv.has_ir) {
520 itv->options.newi2c = (tv.has_ir & 4) ? 1 : 0;
521 if (itv->options.newi2c) {
522 IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
523 exit_ivtv_i2c(itv);
524 init_ivtv_i2c(itv);
525 }
526 }
527
528 if (itv->std != 0)
529
530 return;
531
532
533 if (tv.tuner_formats & V4L2_STD_PAL) {
534 IVTV_DEBUG_INFO("PAL tuner detected\n");
535 itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
536 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
537 IVTV_DEBUG_INFO("NTSC tuner detected\n");
538 itv->std |= V4L2_STD_NTSC_M;
539 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
540 IVTV_DEBUG_INFO("SECAM tuner detected\n");
541 itv->std |= V4L2_STD_SECAM_L;
542 } else {
543 IVTV_INFO("No tuner detected, default to NTSC-M\n");
544 itv->std |= V4L2_STD_NTSC_M;
545 }
546}
547
548static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
549{
550 switch (pal[0]) {
551 case '6':
552 tunertype = 0;
553 return V4L2_STD_PAL_60;
554 case 'b':
555 case 'B':
556 case 'g':
557 case 'G':
558 case 'h':
559 case 'H':
560 tunertype = 0;
561 return V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
562 case 'n':
563 case 'N':
564 tunertype = 1;
565 if (pal[1] == 'c' || pal[1] == 'C')
566 return V4L2_STD_PAL_Nc;
567 return V4L2_STD_PAL_N;
568 case 'i':
569 case 'I':
570 tunertype = 0;
571 return V4L2_STD_PAL_I;
572 case 'd':
573 case 'D':
574 case 'k':
575 case 'K':
576 tunertype = 0;
577 return V4L2_STD_PAL_DK;
578 case 'M':
579 case 'm':
580 tunertype = 1;
581 return V4L2_STD_PAL_M;
582 case '-':
583 break;
584 default:
585 IVTV_WARN("pal= argument not recognised\n");
586 return 0;
587 }
588
589 switch (secam[0]) {
590 case 'b':
591 case 'B':
592 case 'g':
593 case 'G':
594 case 'h':
595 case 'H':
596 tunertype = 0;
597 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
598 case 'd':
599 case 'D':
600 case 'k':
601 case 'K':
602 tunertype = 0;
603 return V4L2_STD_SECAM_DK;
604 case 'l':
605 case 'L':
606 tunertype = 0;
607 if (secam[1] == 'C' || secam[1] == 'c')
608 return V4L2_STD_SECAM_LC;
609 return V4L2_STD_SECAM_L;
610 case '-':
611 break;
612 default:
613 IVTV_WARN("secam= argument not recognised\n");
614 return 0;
615 }
616
617 switch (ntsc[0]) {
618 case 'm':
619 case 'M':
620 tunertype = 1;
621 return V4L2_STD_NTSC_M;
622 case 'j':
623 case 'J':
624 tunertype = 1;
625 return V4L2_STD_NTSC_M_JP;
626 case 'k':
627 case 'K':
628 tunertype = 1;
629 return V4L2_STD_NTSC_M_KR;
630 case '-':
631 break;
632 default:
633 IVTV_WARN("ntsc= argument not recognised\n");
634 return 0;
635 }
636
637
638 return 0;
639}
640
641static void ivtv_process_options(struct ivtv *itv)
642{
643 const char *chipname;
644 int i, j;
645
646 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
647 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
648 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
649 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
650 itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
651 itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
652 itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
653 itv->options.cardtype = cardtype[itv->instance];
654 itv->options.tuner = tuner[itv->instance];
655 itv->options.radio = radio[itv->instance];
656
657 itv->options.i2c_clock_period = i2c_clock_period[itv->instance];
658 if (itv->options.i2c_clock_period == -1)
659 itv->options.i2c_clock_period = IVTV_DEFAULT_I2C_CLOCK_PERIOD;
660 else if (itv->options.i2c_clock_period < 10)
661 itv->options.i2c_clock_period = 10;
662 else if (itv->options.i2c_clock_period > 4500)
663 itv->options.i2c_clock_period = 4500;
664
665 itv->options.newi2c = newi2c;
666 if (tunertype < -1 || tunertype > 1) {
667 IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
668 tunertype = -1;
669 }
670 itv->std = ivtv_parse_std(itv);
671 if (itv->std == 0 && tunertype >= 0)
672 itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
673 itv->has_cx23415 = (itv->pdev->device == PCI_DEVICE_ID_IVTV15);
674 chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
675 if (itv->options.cardtype == -1) {
676 IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
677 return;
678 }
679 if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
680 IVTV_INFO("User specified %s card (detected %s based chip)\n",
681 itv->card->name, chipname);
682 } else if (itv->options.cardtype != 0) {
683 IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
684 }
685 if (itv->card == NULL) {
686 if (itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
687 itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
688 itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
689 itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
690 IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
691 chipname);
692 }
693 }
694 if (itv->card == NULL) {
695 for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
696 if (itv->card->pci_list == NULL)
697 continue;
698 for (j = 0; itv->card->pci_list[j].device; j++) {
699 if (itv->pdev->device !=
700 itv->card->pci_list[j].device)
701 continue;
702 if (itv->pdev->subsystem_vendor !=
703 itv->card->pci_list[j].subsystem_vendor)
704 continue;
705 if (itv->pdev->subsystem_device !=
706 itv->card->pci_list[j].subsystem_device)
707 continue;
708 IVTV_INFO("Autodetected %s card (%s based)\n",
709 itv->card->name, chipname);
710 goto done;
711 }
712 }
713 }
714done:
715
716 if (itv->card == NULL) {
717 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
718 IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
719 itv->pdev->vendor, itv->pdev->device);
720 IVTV_ERR(" subsystem vendor/device: [%04x:%04x]\n",
721 itv->pdev->subsystem_vendor, itv->pdev->subsystem_device);
722 IVTV_ERR(" %s based\n", chipname);
723 IVTV_ERR("Defaulting to %s card\n", itv->card->name);
724 IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
725 IVTV_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
726 IVTV_ERR("Prefix your subject line with [UNKNOWN IVTV CARD].\n");
727 }
728 itv->v4l2_cap = itv->card->v4l2_capabilities;
729 itv->card_name = itv->card->name;
730 itv->card_i2c = itv->card->i2c;
731}
732
733
734
735
736
737
738static int ivtv_init_struct1(struct ivtv *itv)
739{
740 struct sched_param param = { .sched_priority = 99 };
741
742 itv->base_addr = pci_resource_start(itv->pdev, 0);
743 itv->enc_mbox.max_mbox = 2;
744 itv->dec_mbox.max_mbox = 1;
745
746 mutex_init(&itv->serialize_lock);
747 mutex_init(&itv->i2c_bus_lock);
748 mutex_init(&itv->udma.lock);
749
750 spin_lock_init(&itv->lock);
751 spin_lock_init(&itv->dma_reg_lock);
752
753 init_kthread_worker(&itv->irq_worker);
754 itv->irq_worker_task = kthread_run(kthread_worker_fn, &itv->irq_worker,
755 "%s", itv->v4l2_dev.name);
756 if (IS_ERR(itv->irq_worker_task)) {
757 IVTV_ERR("Could not create ivtv task\n");
758 return -1;
759 }
760
761 sched_setscheduler(itv->irq_worker_task, SCHED_FIFO, ¶m);
762
763 init_kthread_work(&itv->irq_work, ivtv_irq_work_handler);
764
765
766 itv->cxhdl.port = CX2341X_PORT_MEMORY;
767 itv->cxhdl.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
768 init_waitqueue_head(&itv->eos_waitq);
769 init_waitqueue_head(&itv->event_waitq);
770 init_waitqueue_head(&itv->vsync_waitq);
771 init_waitqueue_head(&itv->dma_waitq);
772 init_timer(&itv->dma_timer);
773 itv->dma_timer.function = ivtv_unfinished_dma;
774 itv->dma_timer.data = (unsigned long)itv;
775
776 itv->cur_dma_stream = -1;
777 itv->cur_pio_stream = -1;
778
779
780 itv->speed = 1000;
781
782
783 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
784 itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
785
786
787 sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
788
789
790 itv->osd_global_alpha_state = 1;
791 itv->osd_global_alpha = 255;
792
793
794 atomic_set(&itv->yuv_info.next_dma_frame, -1);
795 itv->yuv_info.lace_mode = ivtv_yuv_mode;
796 itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
797 itv->yuv_info.max_frames_buffered = 3;
798 itv->yuv_info.track_osd = 1;
799 return 0;
800}
801
802
803
804static void ivtv_init_struct2(struct ivtv *itv)
805{
806 int i;
807
808 for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
809 if (itv->card->video_inputs[i].video_type == 0)
810 break;
811 itv->nof_inputs = i;
812 for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
813 if (itv->card->audio_inputs[i].audio_type == 0)
814 break;
815 itv->nof_audio_inputs = i;
816
817 if (itv->card->hw_all & IVTV_HW_CX25840) {
818 itv->vbi.sliced_size = 288;
819 } else {
820 itv->vbi.sliced_size = 64;
821 }
822
823
824 for (i = 0; i < itv->nof_inputs; i++) {
825 if (itv->card->video_inputs[i].video_type ==
826 IVTV_CARD_INPUT_VID_TUNER)
827 break;
828 }
829 if (i == itv->nof_inputs)
830 i = 0;
831 itv->active_input = i;
832 itv->audio_input = itv->card->video_inputs[i].audio_index;
833}
834
835static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
836 const struct pci_device_id *pci_id)
837{
838 u16 cmd;
839 unsigned char pci_latency;
840
841 IVTV_DEBUG_INFO("Enabling pci device\n");
842
843 if (pci_enable_device(pdev)) {
844 IVTV_ERR("Can't enable device!\n");
845 return -EIO;
846 }
847 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
848 IVTV_ERR("No suitable DMA available.\n");
849 return -EIO;
850 }
851 if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
852 IVTV_ERR("Cannot request encoder memory region.\n");
853 return -EIO;
854 }
855
856 if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
857 IVTV_REG_SIZE, "ivtv registers")) {
858 IVTV_ERR("Cannot request register memory region.\n");
859 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
860 return -EIO;
861 }
862
863 if (itv->has_cx23415 &&
864 !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
865 IVTV_DECODER_SIZE, "ivtv decoder")) {
866 IVTV_ERR("Cannot request decoder memory region.\n");
867 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
868 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
869 return -EIO;
870 }
871
872
873 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
874 if (!(cmd & PCI_COMMAND_MASTER)) {
875 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
876 pci_set_master(pdev);
877 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
878 if (!(cmd & PCI_COMMAND_MASTER)) {
879 IVTV_ERR("Bus Mastering is not enabled\n");
880 return -ENXIO;
881 }
882 }
883 IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
884
885 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
886
887 if (pci_latency < 64 && ivtv_pci_latency) {
888 IVTV_INFO("Unreasonably low latency timer, "
889 "setting to 64 (was %d)\n", pci_latency);
890 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
891 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
892 }
893
894
895
896
897 pci_write_config_dword(pdev, 0x40, 0xffff);
898
899 IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
900 "irq: %d, latency: %d, memory: 0x%llx\n",
901 pdev->device, pdev->revision, pdev->bus->number,
902 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
903 pdev->irq, pci_latency, (u64)itv->base_addr);
904
905 return 0;
906}
907
908static void ivtv_load_and_init_modules(struct ivtv *itv)
909{
910 u32 hw = itv->card->hw_all;
911 unsigned i;
912
913
914 for (i = 0; i < 32; i++) {
915 u32 device = 1 << i;
916
917 if (!(device & hw))
918 continue;
919 if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
920
921 itv->hw_flags |= device;
922 continue;
923 }
924 if (ivtv_i2c_register(itv, i) == 0)
925 itv->hw_flags |= device;
926 }
927
928
929 if ((itv->hw_flags & IVTV_HW_IR_ANY) == 0)
930 ivtv_i2c_new_ir_legacy(itv);
931
932 if (itv->card->hw_all & IVTV_HW_CX25840)
933 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_CX25840);
934 else if (itv->card->hw_all & IVTV_HW_SAA717X)
935 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA717X);
936 else if (itv->card->hw_all & IVTV_HW_SAA7114)
937 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7114);
938 else
939 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7115);
940 itv->sd_audio = ivtv_find_hw(itv, itv->card->hw_audio_ctrl);
941 itv->sd_muxer = ivtv_find_hw(itv, itv->card->hw_muxer);
942
943 hw = itv->hw_flags;
944
945 if (itv->card->type == IVTV_CARD_CX23416GYC) {
946
947
948 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
949 itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
950 else if ((hw & IVTV_HW_UPD64031A) == 0)
951 itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
952 }
953 else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
954 itv->card->type == IVTV_CARD_GV_MVPRX2E) {
955
956 v4l2_subdev_call(itv->sd_video, video, s_crystal_freq,
957 SAA7115_FREQ_24_576_MHZ, SAA7115_FREQ_FL_UCGC);
958 }
959
960 if (hw & IVTV_HW_CX25840) {
961 itv->vbi.raw_decoder_line_size = 1444;
962 itv->vbi.raw_decoder_sav_odd_field = 0x20;
963 itv->vbi.raw_decoder_sav_even_field = 0x60;
964 itv->vbi.sliced_decoder_line_size = 272;
965 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
966 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
967 }
968
969 if (hw & IVTV_HW_SAA711X) {
970
971 itv->hw_flags &= ~IVTV_HW_SAA711X;
972
973 if (strstr(itv->sd_video->name, "saa7114")) {
974 itv->hw_flags |= IVTV_HW_SAA7114;
975
976 itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
977 } else {
978 itv->hw_flags |= IVTV_HW_SAA7115;
979 }
980 itv->vbi.raw_decoder_line_size = 1443;
981 itv->vbi.raw_decoder_sav_odd_field = 0x25;
982 itv->vbi.raw_decoder_sav_even_field = 0x62;
983 itv->vbi.sliced_decoder_line_size = 51;
984 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
985 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
986 }
987
988 if (hw & IVTV_HW_SAA717X) {
989 itv->vbi.raw_decoder_line_size = 1443;
990 itv->vbi.raw_decoder_sav_odd_field = 0x25;
991 itv->vbi.raw_decoder_sav_even_field = 0x62;
992 itv->vbi.sliced_decoder_line_size = 51;
993 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
994 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
995 }
996}
997
998static int ivtv_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
999{
1000 int retval = 0;
1001 int vbi_buf_size;
1002 struct ivtv *itv;
1003
1004 itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
1005 if (itv == NULL)
1006 return -ENOMEM;
1007 itv->pdev = pdev;
1008 itv->instance = v4l2_device_set_name(&itv->v4l2_dev, "ivtv",
1009 &ivtv_instance);
1010
1011 retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
1012 if (retval) {
1013 kfree(itv);
1014 return retval;
1015 }
1016 IVTV_INFO("Initializing card %d\n", itv->instance);
1017
1018 ivtv_process_options(itv);
1019 if (itv->options.cardtype == -1) {
1020 retval = -ENODEV;
1021 goto err;
1022 }
1023 if (ivtv_init_struct1(itv)) {
1024 retval = -ENOMEM;
1025 goto err;
1026 }
1027 retval = cx2341x_handler_init(&itv->cxhdl, 50);
1028 if (retval)
1029 goto err;
1030 itv->v4l2_dev.ctrl_handler = &itv->cxhdl.hdl;
1031 itv->cxhdl.ops = &ivtv_cxhdl_ops;
1032 itv->cxhdl.priv = itv;
1033 itv->cxhdl.func = ivtv_api_func;
1034
1035 IVTV_DEBUG_INFO("base addr: 0x%llx\n", (u64)itv->base_addr);
1036
1037
1038 retval = ivtv_setup_pci(itv, pdev, pci_id);
1039 if (retval == -EIO)
1040 goto free_worker;
1041 if (retval == -ENXIO)
1042 goto free_mem;
1043
1044
1045 IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1046 (u64)itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1047 itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1048 IVTV_ENCODER_SIZE);
1049 if (!itv->enc_mem) {
1050 IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1051 "encoder memory\n");
1052 IVTV_ERR("Each capture card with a CX23415/6 needs 8 MB of "
1053 "vmalloc address space for this window\n");
1054 IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1055 IVTV_ERR("Use the vmalloc= kernel command line option to set "
1056 "VmallocTotal to a larger value\n");
1057 retval = -ENOMEM;
1058 goto free_mem;
1059 }
1060
1061 if (itv->has_cx23415) {
1062 IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1063 (u64)itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1064 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1065 IVTV_DECODER_SIZE);
1066 if (!itv->dec_mem) {
1067 IVTV_ERR("ioremap failed. Can't get a window into "
1068 "CX23415 decoder memory\n");
1069 IVTV_ERR("Each capture card with a CX23415 needs 8 MB "
1070 "of vmalloc address space for this window\n");
1071 IVTV_ERR("Check the output of 'grep Vmalloc "
1072 "/proc/meminfo'\n");
1073 IVTV_ERR("Use the vmalloc= kernel command line option "
1074 "to set VmallocTotal to a larger value\n");
1075 retval = -ENOMEM;
1076 goto free_mem;
1077 }
1078 }
1079 else {
1080 itv->dec_mem = itv->enc_mem;
1081 }
1082
1083
1084 IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1085 (u64)itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1086 itv->reg_mem =
1087 ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1088 if (!itv->reg_mem) {
1089 IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1090 "register space\n");
1091 IVTV_ERR("Each capture card with a CX23415/6 needs 64 kB of "
1092 "vmalloc address space for this window\n");
1093 IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1094 IVTV_ERR("Use the vmalloc= kernel command line option to set "
1095 "VmallocTotal to a larger value\n");
1096 retval = -ENOMEM;
1097 goto free_io;
1098 }
1099
1100 retval = ivtv_gpio_init(itv);
1101 if (retval)
1102 goto free_io;
1103
1104
1105 IVTV_DEBUG_INFO("activating i2c...\n");
1106 if (init_ivtv_i2c(itv)) {
1107 IVTV_ERR("Could not initialize i2c\n");
1108 goto free_io;
1109 }
1110
1111 if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1112
1113
1114 ivtv_process_eeprom(itv);
1115 }
1116 if (itv->card->comment)
1117 IVTV_INFO("%s", itv->card->comment);
1118 if (itv->card->v4l2_capabilities == 0) {
1119
1120 retval = -ENODEV;
1121 goto free_i2c;
1122 }
1123
1124 if (itv->std == 0) {
1125 itv->std = V4L2_STD_NTSC_M;
1126 }
1127
1128 if (itv->options.tuner == -1) {
1129 int i;
1130
1131 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1132 if ((itv->std & itv->card->tuners[i].std) == 0)
1133 continue;
1134 itv->options.tuner = itv->card->tuners[i].tuner;
1135 break;
1136 }
1137 }
1138
1139 if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1140 itv->std = itv->card->tuners[0].std;
1141 if (itv->std & V4L2_STD_PAL)
1142 itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1143 else if (itv->std & V4L2_STD_NTSC)
1144 itv->std = V4L2_STD_NTSC_M;
1145 else if (itv->std & V4L2_STD_SECAM)
1146 itv->std = V4L2_STD_SECAM_L;
1147 itv->options.tuner = itv->card->tuners[0].tuner;
1148 }
1149 if (itv->options.radio == -1)
1150 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1151
1152
1153
1154 ivtv_init_struct2(itv);
1155
1156 ivtv_load_and_init_modules(itv);
1157
1158 if (itv->std & V4L2_STD_525_60) {
1159 itv->is_60hz = 1;
1160 itv->is_out_60hz = 1;
1161 } else {
1162 itv->is_50hz = 1;
1163 itv->is_out_50hz = 1;
1164 }
1165
1166 itv->yuv_info.osd_full_w = 720;
1167 itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1168 itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1169 itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1170
1171 cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1172
1173 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1174 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1175 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1176 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1177 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1178
1179
1180
1181
1182
1183 itv->vbi.raw_size = 1456;
1184
1185
1186
1187
1188
1189
1190 vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1191 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1192 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1193
1194 if (itv->options.radio > 0)
1195 itv->v4l2_cap |= V4L2_CAP_RADIO;
1196
1197 if (itv->options.tuner > -1) {
1198 struct tuner_setup setup;
1199
1200 setup.addr = ADDR_UNSET;
1201 setup.type = itv->options.tuner;
1202 setup.mode_mask = T_ANALOG_TV;
1203 if (itv->options.radio > 0)
1204 setup.mode_mask |= T_RADIO;
1205 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1206 ivtv_reset_tuner_gpio : NULL;
1207 ivtv_call_all(itv, tuner, s_type_addr, &setup);
1208 if (setup.type == TUNER_XC2028) {
1209 static struct xc2028_ctrl ctrl = {
1210 .fname = XC2028_DEFAULT_FIRMWARE,
1211 .max_len = 64,
1212 };
1213 struct v4l2_priv_tun_config cfg = {
1214 .tuner = itv->options.tuner,
1215 .priv = &ctrl,
1216 };
1217 ivtv_call_all(itv, tuner, s_config, &cfg);
1218 }
1219 }
1220
1221
1222
1223 itv->tuner_std = itv->std;
1224
1225 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1226 struct v4l2_ctrl_handler *hdl = itv->v4l2_dev.ctrl_handler;
1227
1228 itv->ctrl_pts = v4l2_ctrl_new_std(hdl, &ivtv_hdl_out_ops,
1229 V4L2_CID_MPEG_VIDEO_DEC_PTS, 0, 0, 0, 0);
1230 itv->ctrl_frame = v4l2_ctrl_new_std(hdl, &ivtv_hdl_out_ops,
1231 V4L2_CID_MPEG_VIDEO_DEC_FRAME, 0, 0, 0, 0);
1232
1233
1234 itv->ctrl_audio_playback =
1235 v4l2_ctrl_new_std_menu(hdl, &ivtv_hdl_out_ops,
1236 V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK,
1237 V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO,
1238 1 << V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO,
1239 V4L2_MPEG_AUDIO_DEC_PLAYBACK_STEREO);
1240 itv->ctrl_audio_multilingual_playback =
1241 v4l2_ctrl_new_std_menu(hdl, &ivtv_hdl_out_ops,
1242 V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK,
1243 V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO,
1244 1 << V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO,
1245 V4L2_MPEG_AUDIO_DEC_PLAYBACK_LEFT);
1246 if (hdl->error) {
1247 retval = hdl->error;
1248 goto free_i2c;
1249 }
1250 v4l2_ctrl_cluster(2, &itv->ctrl_pts);
1251 v4l2_ctrl_cluster(2, &itv->ctrl_audio_playback);
1252 ivtv_call_all(itv, video, s_std_output, itv->std);
1253
1254
1255
1256 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1257 }
1258
1259
1260 ivtv_set_irq_mask(itv, 0xffffffff);
1261
1262
1263 retval = request_irq(itv->pdev->irq, ivtv_irq_handler,
1264 IRQF_SHARED, itv->v4l2_dev.name, (void *)itv);
1265 if (retval) {
1266 IVTV_ERR("Failed to register irq %d\n", retval);
1267 goto free_i2c;
1268 }
1269
1270 retval = ivtv_streams_setup(itv);
1271 if (retval) {
1272 IVTV_ERR("Error %d setting up streams\n", retval);
1273 goto free_irq;
1274 }
1275 retval = ivtv_streams_register(itv);
1276 if (retval) {
1277 IVTV_ERR("Error %d registering devices\n", retval);
1278 goto free_streams;
1279 }
1280 IVTV_INFO("Initialized card: %s\n", itv->card_name);
1281
1282
1283 request_modules(itv);
1284 return 0;
1285
1286free_streams:
1287 ivtv_streams_cleanup(itv, 1);
1288free_irq:
1289 free_irq(itv->pdev->irq, (void *)itv);
1290free_i2c:
1291 v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1292 exit_ivtv_i2c(itv);
1293free_io:
1294 ivtv_iounmap(itv);
1295free_mem:
1296 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1297 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1298 if (itv->has_cx23415)
1299 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1300free_worker:
1301 kthread_stop(itv->irq_worker_task);
1302err:
1303 if (retval == 0)
1304 retval = -ENODEV;
1305 IVTV_ERR("Error %d on initialization\n", retval);
1306
1307 v4l2_device_unregister(&itv->v4l2_dev);
1308 kfree(itv);
1309 return retval;
1310}
1311
1312int ivtv_init_on_first_open(struct ivtv *itv)
1313{
1314 struct v4l2_frequency vf;
1315
1316 struct ivtv_open_id fh;
1317 int fw_retry_count = 3;
1318 int video_input;
1319
1320 fh.itv = itv;
1321 fh.type = IVTV_ENC_STREAM_TYPE_MPG;
1322
1323 if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1324 return -ENXIO;
1325
1326 if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1327 return 0;
1328
1329 while (--fw_retry_count > 0) {
1330
1331 if (ivtv_firmware_init(itv) == 0)
1332 break;
1333 if (fw_retry_count > 1)
1334 IVTV_WARN("Retry loading firmware\n");
1335 }
1336
1337 if (fw_retry_count == 0) {
1338 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1339 return -ENXIO;
1340 }
1341
1342
1343 IVTV_DEBUG_INFO("Getting firmware version..\n");
1344 ivtv_firmware_versions(itv);
1345
1346 if (itv->card->hw_all & IVTV_HW_CX25840)
1347 v4l2_subdev_call(itv->sd_video, core, load_fw);
1348
1349 vf.tuner = 0;
1350 vf.type = V4L2_TUNER_ANALOG_TV;
1351 vf.frequency = 6400;
1352
1353
1354
1355 if (itv->std == V4L2_STD_NTSC_M_JP) {
1356 vf.frequency = 1460;
1357 }
1358 else if (itv->std & V4L2_STD_NTSC_M) {
1359 vf.frequency = 1076;
1360 }
1361
1362 video_input = itv->active_input;
1363 itv->active_input++;
1364 ivtv_s_input(NULL, &fh, video_input);
1365
1366
1367
1368 itv->std++;
1369 itv->std_out = itv->std;
1370 ivtv_s_frequency(NULL, &fh, &vf);
1371
1372 if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1373
1374
1375
1376 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
1377 ivtv_init_mpeg_decoder(itv);
1378 }
1379
1380
1381 if (!itv->has_cx23415)
1382 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1383
1384 ivtv_s_std_enc(itv, itv->tuner_std);
1385
1386
1387
1388
1389
1390
1391 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1392 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1393 ivtv_set_osd_alpha(itv);
1394 ivtv_s_std_dec(itv, itv->tuner_std);
1395 } else {
1396 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1397 }
1398
1399
1400 cx2341x_handler_setup(&itv->cxhdl);
1401 return 0;
1402}
1403
1404static void ivtv_remove(struct pci_dev *pdev)
1405{
1406 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1407 struct ivtv *itv = to_ivtv(v4l2_dev);
1408 int i;
1409
1410 IVTV_DEBUG_INFO("Removing card\n");
1411
1412 flush_request_modules(itv);
1413
1414 if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1415
1416 IVTV_DEBUG_INFO("Stopping all streams\n");
1417 if (atomic_read(&itv->capturing) > 0)
1418 ivtv_stop_all_captures(itv);
1419
1420
1421 IVTV_DEBUG_INFO("Stopping decoding\n");
1422
1423
1424 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1425 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1426 if (atomic_read(&itv->decoding) > 0) {
1427 int type;
1428
1429 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1430 type = IVTV_DEC_STREAM_TYPE_YUV;
1431 else
1432 type = IVTV_DEC_STREAM_TYPE_MPG;
1433 ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1434 V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY, 0);
1435 }
1436 ivtv_halt_firmware(itv);
1437 }
1438
1439
1440 ivtv_set_irq_mask(itv, 0xffffffff);
1441 del_timer_sync(&itv->dma_timer);
1442
1443
1444 flush_kthread_worker(&itv->irq_worker);
1445 kthread_stop(itv->irq_worker_task);
1446
1447 ivtv_streams_cleanup(itv, 1);
1448 ivtv_udma_free(itv);
1449
1450 v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1451
1452 exit_ivtv_i2c(itv);
1453
1454 free_irq(itv->pdev->irq, (void *)itv);
1455 ivtv_iounmap(itv);
1456
1457 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1458 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1459 if (itv->has_cx23415)
1460 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1461
1462 pci_disable_device(itv->pdev);
1463 for (i = 0; i < IVTV_VBI_FRAMES; i++)
1464 kfree(itv->vbi.sliced_mpeg_data[i]);
1465
1466 printk(KERN_INFO "ivtv: Removed %s\n", itv->card_name);
1467
1468 v4l2_device_unregister(&itv->v4l2_dev);
1469 kfree(itv);
1470}
1471
1472
1473static struct pci_driver ivtv_pci_driver = {
1474 .name = "ivtv",
1475 .id_table = ivtv_pci_tbl,
1476 .probe = ivtv_probe,
1477 .remove = ivtv_remove,
1478};
1479
1480static int __init module_start(void)
1481{
1482 printk(KERN_INFO "ivtv: Start initialization, version %s\n", IVTV_VERSION);
1483
1484
1485 if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1486 printk(KERN_ERR "ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1487 IVTV_MAX_CARDS - 1);
1488 return -1;
1489 }
1490
1491 if (ivtv_debug < 0 || ivtv_debug > 2047) {
1492 ivtv_debug = 0;
1493 printk(KERN_INFO "ivtv: Debug value must be >= 0 and <= 2047\n");
1494 }
1495
1496 if (pci_register_driver(&ivtv_pci_driver)) {
1497 printk(KERN_ERR "ivtv: Error detecting PCI card\n");
1498 return -ENODEV;
1499 }
1500 printk(KERN_INFO "ivtv: End initialization\n");
1501 return 0;
1502}
1503
1504static void __exit module_cleanup(void)
1505{
1506 pci_unregister_driver(&ivtv_pci_driver);
1507}
1508
1509
1510
1511EXPORT_SYMBOL(ivtv_set_irq_mask);
1512EXPORT_SYMBOL(ivtv_api);
1513EXPORT_SYMBOL(ivtv_vapi);
1514EXPORT_SYMBOL(ivtv_vapi_result);
1515EXPORT_SYMBOL(ivtv_clear_irq_mask);
1516EXPORT_SYMBOL(ivtv_debug);
1517#ifdef CONFIG_VIDEO_ADV_DEBUG
1518EXPORT_SYMBOL(ivtv_fw_debug);
1519#endif
1520EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1521EXPORT_SYMBOL(ivtv_udma_setup);
1522EXPORT_SYMBOL(ivtv_udma_unmap);
1523EXPORT_SYMBOL(ivtv_udma_alloc);
1524EXPORT_SYMBOL(ivtv_udma_prepare);
1525EXPORT_SYMBOL(ivtv_init_on_first_open);
1526EXPORT_SYMBOL(ivtv_firmware_check);
1527
1528module_init(module_start);
1529module_exit(module_cleanup);
1530
