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