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