2 ivtv driver initialization and card probing
3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2004 Chris Kennedy <c@groovy.org>
5 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 /* Main Driver file for the ivtv project:
23 * Driver for the Conexant CX23415/CX23416 chip.
24 * Author: Kevin Thayer (nufan_wfk at yahoo.com)
26 * http://www.ivtvdriver.org
29 * MPG600/MPG160 support by T.Adachi <tadachi@tadachi-net.com>
30 * and Takeru KOMORIYA<komoriya@paken.org>
32 * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
33 * using information provided by Jiun-Kuei Jung @ AVerMedia.
35 * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <alpha292@bremen.or.jp>
36 * using information from T.Adachi,Takeru KOMORIYA and others :-)
38 * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
39 * version by T.Adachi. Special thanks Mr.Suzuki
42 #include "ivtv-driver.h"
43 #include "ivtv-version.h"
44 #include "ivtv-fileops.h"
46 #include "ivtv-firmware.h"
47 #include "ivtv-queue.h"
48 #include "ivtv-udma.h"
50 #include "ivtv-mailbox.h"
51 #include "ivtv-streams.h"
52 #include "ivtv-ioctl.h"
53 #include "ivtv-cards.h"
55 #include "ivtv-audio.h"
56 #include "ivtv-gpio.h"
59 #include <media/tveeprom.h>
60 #include <media/saa7115.h>
61 #include <media/v4l2-chip-ident.h>
63 /* var to keep track of the number of array elements in use */
64 int ivtv_cards_active
= 0;
66 /* If you have already X v4l cards, then set this to X. This way
67 the device numbers stay matched. Example: you have a WinTV card
68 without radio and a PVR-350 with. Normally this would give a
69 video1 device together with a radio0 device for the PVR. By
70 setting this to 1 you ensure that radio0 is now also radio1. */
71 int ivtv_first_minor
= 0;
73 /* Master variable for all ivtv info */
74 struct ivtv
*ivtv_cards
[IVTV_MAX_CARDS
];
76 /* Protects ivtv_cards_active */
77 DEFINE_SPINLOCK(ivtv_cards_lock
);
79 /* add your revision and whatnot here */
80 static struct pci_device_id ivtv_pci_tbl
[] __devinitdata
= {
81 {PCI_VENDOR_ID_ICOMP
, PCI_DEVICE_ID_IVTV15
,
82 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
83 {PCI_VENDOR_ID_ICOMP
, PCI_DEVICE_ID_IVTV16
,
84 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
88 MODULE_DEVICE_TABLE(pci
,ivtv_pci_tbl
);
90 const u32 yuv_offset
[4] = {
91 IVTV_YUV_BUFFER_OFFSET
,
92 IVTV_YUV_BUFFER_OFFSET_1
,
93 IVTV_YUV_BUFFER_OFFSET_2
,
94 IVTV_YUV_BUFFER_OFFSET_3
97 /* Parameter declarations */
98 static int cardtype
[IVTV_MAX_CARDS
];
99 static int tuner
[IVTV_MAX_CARDS
] = { -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 -1, -1, -1, -1, -1, -1, -1, -1 };
103 static int radio
[IVTV_MAX_CARDS
] = { -1, -1, -1, -1, -1, -1, -1, -1,
104 -1, -1, -1, -1, -1, -1, -1, -1,
105 -1, -1, -1, -1, -1, -1, -1, -1,
106 -1, -1, -1, -1, -1, -1, -1, -1 };
108 static int cardtype_c
= 1;
109 static int tuner_c
= 1;
110 static int radio_c
= 1;
111 static char pal
[] = "--";
112 static char secam
[] = "--";
113 static char ntsc
[] = "-";
116 static int enc_mpg_buffers
= IVTV_DEFAULT_ENC_MPG_BUFFERS
;
117 static int enc_yuv_buffers
= IVTV_DEFAULT_ENC_YUV_BUFFERS
;
118 static int enc_vbi_buffers
= IVTV_DEFAULT_ENC_VBI_BUFFERS
;
119 static int enc_pcm_buffers
= IVTV_DEFAULT_ENC_PCM_BUFFERS
;
120 static int dec_mpg_buffers
= IVTV_DEFAULT_DEC_MPG_BUFFERS
;
121 static int dec_yuv_buffers
= IVTV_DEFAULT_DEC_YUV_BUFFERS
;
122 static int dec_vbi_buffers
= IVTV_DEFAULT_DEC_VBI_BUFFERS
;
124 static int ivtv_yuv_mode
= 0;
125 static int ivtv_yuv_threshold
=-1;
126 static int ivtv_pci_latency
= 1;
130 static int newi2c
= -1;
132 module_param_array(tuner
, int, &tuner_c
, 0644);
133 module_param_array(radio
, bool, &radio_c
, 0644);
134 module_param_array(cardtype
, int, &cardtype_c
, 0644);
135 module_param_string(pal
, pal
, sizeof(pal
), 0644);
136 module_param_string(secam
, secam
, sizeof(secam
), 0644);
137 module_param_string(ntsc
, ntsc
, sizeof(ntsc
), 0644);
138 module_param_named(debug
,ivtv_debug
, int, 0644);
139 module_param(ivtv_pci_latency
, int, 0644);
140 module_param(ivtv_yuv_mode
, int, 0644);
141 module_param(ivtv_yuv_threshold
, int, 0644);
142 module_param(ivtv_first_minor
, int, 0644);
144 module_param(enc_mpg_buffers
, int, 0644);
145 module_param(enc_yuv_buffers
, int, 0644);
146 module_param(enc_vbi_buffers
, int, 0644);
147 module_param(enc_pcm_buffers
, int, 0644);
148 module_param(dec_mpg_buffers
, int, 0644);
149 module_param(dec_yuv_buffers
, int, 0644);
150 module_param(dec_vbi_buffers
, int, 0644);
152 module_param(newi2c
, int, 0644);
154 MODULE_PARM_DESC(tuner
, "Tuner type selection,\n"
155 "\t\t\tsee tuner.h for values");
156 MODULE_PARM_DESC(radio
,
157 "Enable or disable the radio. Use only if autodetection\n"
158 "\t\t\tfails. 0 = disable, 1 = enable");
159 MODULE_PARM_DESC(cardtype
,
160 "Only use this option if your card is not detected properly.\n"
161 "\t\tSpecify card type:\n"
162 "\t\t\t 1 = WinTV PVR 250\n"
163 "\t\t\t 2 = WinTV PVR 350\n"
164 "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
165 "\t\t\t 4 = AVerMedia M179\n"
166 "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
167 "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
168 "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
169 "\t\t\t 8 = Adaptec AVC-2410\n"
170 "\t\t\t 9 = Adaptec AVC-2010\n"
171 "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
172 "\t\t\t11 = AOpen VA2000MAX-STN6\n"
173 "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
174 "\t\t\t13 = I/O Data GV-MVP/RX\n"
175 "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
176 "\t\t\t15 = GOTVIEW PCI DVD\n"
177 "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
178 "\t\t\t17 = Yuan MPC622\n"
179 "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
180 "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
181 "\t\t\t20 = Club3D ZAP-TV1x01\n"
182 "\t\t\t21 = AverTV MCE 116 Plus\n"
183 "\t\t\t 0 = Autodetect (default)\n"
184 "\t\t\t-1 = Ignore this card\n\t\t");
185 MODULE_PARM_DESC(pal
, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
186 MODULE_PARM_DESC(secam
, "Set SECAM standard: B, G, H, D, K, L, LC");
187 MODULE_PARM_DESC(ntsc
, "Set NTSC standard: M, J, K");
188 MODULE_PARM_DESC(debug
,
189 "Debug level (bitmask). Default: 0\n"
190 "\t\t\t 1/0x0001: warning\n"
191 "\t\t\t 2/0x0002: info\n"
192 "\t\t\t 4/0x0004: mailbox\n"
193 "\t\t\t 8/0x0008: ioctl\n"
194 "\t\t\t 16/0x0010: file\n"
195 "\t\t\t 32/0x0020: dma\n"
196 "\t\t\t 64/0x0040: irq\n"
197 "\t\t\t 128/0x0080: decoder\n"
198 "\t\t\t 256/0x0100: yuv\n"
199 "\t\t\t 512/0x0200: i2c\n"
200 "\t\t\t1024/0x0400: high volume\n");
201 MODULE_PARM_DESC(ivtv_pci_latency
,
202 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
203 "\t\t\tDefault: Yes");
204 MODULE_PARM_DESC(ivtv_yuv_mode
,
205 "Specify the yuv playback mode:\n"
206 "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
207 "\t\t\tDefault: 0 (interlaced)");
208 MODULE_PARM_DESC(ivtv_yuv_threshold
,
209 "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
210 "\t\t\tDefault: 480");;
211 MODULE_PARM_DESC(enc_mpg_buffers
,
212 "Encoder MPG Buffers (in MB)\n"
213 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS
));
214 MODULE_PARM_DESC(enc_yuv_buffers
,
215 "Encoder YUV Buffers (in MB)\n"
216 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS
));
217 MODULE_PARM_DESC(enc_vbi_buffers
,
218 "Encoder VBI Buffers (in MB)\n"
219 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS
));
220 MODULE_PARM_DESC(enc_pcm_buffers
,
221 "Encoder PCM buffers (in kB)\n"
222 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS
));
223 MODULE_PARM_DESC(dec_mpg_buffers
,
224 "Decoder MPG buffers (in MB)\n"
225 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS
));
226 MODULE_PARM_DESC(dec_yuv_buffers
,
227 "Decoder YUV buffers (in MB)\n"
228 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS
));
229 MODULE_PARM_DESC(dec_vbi_buffers
,
230 "Decoder VBI buffers (in kB)\n"
231 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS
));
232 MODULE_PARM_DESC(newi2c
,
233 "Use new I2C implementation\n"
234 "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
235 "\t\t\tDefault is autodetect");
237 MODULE_PARM_DESC(ivtv_first_minor
, "Set minor assigned to first card");
239 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
240 MODULE_DESCRIPTION("CX23415/CX23416 driver");
241 MODULE_SUPPORTED_DEVICE
242 ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
243 "\t\t\tYuan MPG series and similar)");
244 MODULE_LICENSE("GPL");
246 MODULE_VERSION(IVTV_VERSION
);
248 void ivtv_clear_irq_mask(struct ivtv
*itv
, u32 mask
)
250 itv
->irqmask
&= ~mask
;
251 write_reg_sync(itv
->irqmask
, IVTV_REG_IRQMASK
);
254 void ivtv_set_irq_mask(struct ivtv
*itv
, u32 mask
)
256 itv
->irqmask
|= mask
;
257 write_reg_sync(itv
->irqmask
, IVTV_REG_IRQMASK
);
260 int ivtv_set_output_mode(struct ivtv
*itv
, int mode
)
264 spin_lock(&itv
->lock
);
265 old_mode
= itv
->output_mode
;
267 itv
->output_mode
= old_mode
= mode
;
268 spin_unlock(&itv
->lock
);
272 struct ivtv_stream
*ivtv_get_output_stream(struct ivtv
*itv
)
274 switch (itv
->output_mode
) {
276 return &itv
->streams
[IVTV_DEC_STREAM_TYPE_MPG
];
278 return &itv
->streams
[IVTV_DEC_STREAM_TYPE_YUV
];
284 int ivtv_waitq(wait_queue_head_t
*waitq
)
288 prepare_to_wait(waitq
, &wait
, TASK_INTERRUPTIBLE
);
290 finish_wait(waitq
, &wait
);
291 return signal_pending(current
) ? -EINTR
: 0;
294 /* Generic utility functions */
295 int ivtv_msleep_timeout(unsigned int msecs
, int intr
)
298 int timeout
= msecs_to_jiffies(msecs
);
301 set_current_state(intr
? TASK_INTERRUPTIBLE
: TASK_UNINTERRUPTIBLE
);
302 timeout
= schedule_timeout(timeout
);
303 if (intr
&& (ret
= signal_pending(current
)))
309 /* Release ioremapped memory */
310 static void ivtv_iounmap(struct ivtv
*itv
)
315 /* Release registers memory */
316 if (itv
->reg_mem
!= NULL
) {
317 IVTV_DEBUG_INFO("releasing reg_mem\n");
318 iounmap(itv
->reg_mem
);
321 /* Release io memory */
322 if (itv
->has_cx23415
&& itv
->dec_mem
!= NULL
) {
323 IVTV_DEBUG_INFO("releasing dec_mem\n");
324 iounmap(itv
->dec_mem
);
328 /* Release io memory */
329 if (itv
->enc_mem
!= NULL
) {
330 IVTV_DEBUG_INFO("releasing enc_mem\n");
331 iounmap(itv
->enc_mem
);
336 /* Hauppauge card? get values from tveeprom */
337 void ivtv_read_eeprom(struct ivtv
*itv
, struct tveeprom
*tv
)
341 itv
->i2c_client
.addr
= 0xA0 >> 1;
342 tveeprom_read(&itv
->i2c_client
, eedata
, sizeof(eedata
));
343 tveeprom_hauppauge_analog(&itv
->i2c_client
, tv
, eedata
);
346 static void ivtv_process_eeprom(struct ivtv
*itv
)
349 int pci_slot
= PCI_SLOT(itv
->dev
->devfn
);
351 ivtv_read_eeprom(itv
, &tv
);
353 /* Many thanks to Steven Toth from Hauppauge for providing the
356 /* In a few cases the PCI subsystem IDs do not correctly
357 identify the card. A better method is to check the
358 model number from the eeprom instead. */
359 case 30012 ... 30039: /* Low profile PVR250 */
360 case 32000 ... 32999:
361 case 48000 ... 48099: /* 48??? range are PVR250s with a cx23415 */
362 case 48400 ... 48599:
363 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_250
);
365 case 48100 ... 48399:
366 case 48600 ... 48999:
367 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_350
);
369 case 23000 ... 23999: /* PVR500 */
370 case 25000 ... 25999: /* Low profile PVR150 */
371 case 26000 ... 26999: /* Regular PVR150 */
372 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_150
);
375 IVTV_ERR("Invalid EEPROM\n");
378 IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv
.model
);
379 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_150
);
384 /* Old style PVR350 (with an saa7114) uses this input for
387 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_350_V1
);
393 itv
->v4l2_cap
= itv
->card
->v4l2_capabilities
;
394 itv
->card_name
= itv
->card
->name
;
396 /* If this is a PVR500 then it should be possible to detect whether it is the
397 first or second unit by looking at the subsystem device ID: is bit 4 is
398 set, then it is the second unit (according to info from Hauppauge).
400 However, while this works for most cards, I have seen a few PVR500 cards
401 where both units have the same subsystem ID.
403 So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
404 PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
405 it is the second unit. It is possible that it is a different slot when ivtv is
406 used in Xen, in that case I ignore this card here. The worst that can happen
407 is that the card presents itself with a non-working radio device.
409 This detection is needed since the eeprom reports incorrectly that a radio is
410 present on the second unit. */
411 if (tv
.model
/ 1000 == 23) {
412 itv
->card_name
= "WinTV PVR 500";
413 if (pci_slot
== 8 || pci_slot
== 9) {
414 int is_first
= (pci_slot
& 1) == 0;
416 itv
->card_name
= is_first
? "WinTV PVR 500 (unit #1)" :
417 "WinTV PVR 500 (unit #2)";
419 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
424 IVTV_INFO("Autodetected %s\n", itv
->card_name
);
426 switch (tv
.tuner_hauppauge_model
) {
430 itv
->pvr150_workaround
= 1;
435 if (tv
.tuner_type
== TUNER_ABSENT
)
436 IVTV_ERR("tveeprom cannot autodetect tuner!");
438 if (itv
->options
.tuner
== -1)
439 itv
->options
.tuner
= tv
.tuner_type
;
440 if (itv
->options
.radio
== -1)
441 itv
->options
.radio
= (tv
.has_radio
!= 0);
442 /* only enable newi2c if an IR blaster is present */
443 /* FIXME: for 2.6.20 the test against 2 should be removed */
444 if (itv
->options
.newi2c
== -1 && tv
.has_ir
!= -1 && tv
.has_ir
!= 2) {
445 itv
->options
.newi2c
= (tv
.has_ir
& 2) ? 1 : 0;
446 if (itv
->options
.newi2c
) {
447 IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
454 /* user specified tuner standard */
457 /* autodetect tuner standard */
458 if (tv
.tuner_formats
& V4L2_STD_PAL
) {
459 IVTV_DEBUG_INFO("PAL tuner detected\n");
460 itv
->std
|= V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
461 } else if (tv
.tuner_formats
& V4L2_STD_NTSC
) {
462 IVTV_DEBUG_INFO("NTSC tuner detected\n");
463 itv
->std
|= V4L2_STD_NTSC_M
;
464 } else if (tv
.tuner_formats
& V4L2_STD_SECAM
) {
465 IVTV_DEBUG_INFO("SECAM tuner detected\n");
466 itv
->std
|= V4L2_STD_SECAM_L
;
468 IVTV_INFO("No tuner detected, default to NTSC-M\n");
469 itv
->std
|= V4L2_STD_NTSC_M
;
473 static v4l2_std_id
ivtv_parse_std(struct ivtv
*itv
)
477 return V4L2_STD_PAL_60
;
482 return V4L2_STD_PAL_BG
;
485 return V4L2_STD_PAL_H
;
488 if (pal
[1] == 'c' || pal
[1] == 'C')
489 return V4L2_STD_PAL_Nc
;
490 return V4L2_STD_PAL_N
;
493 return V4L2_STD_PAL_I
;
498 return V4L2_STD_PAL_DK
;
501 return V4L2_STD_PAL_M
;
505 IVTV_WARN("pal= argument not recognised\n");
516 return V4L2_STD_SECAM_B
| V4L2_STD_SECAM_G
| V4L2_STD_SECAM_H
;
521 return V4L2_STD_SECAM_DK
;
524 if (secam
[1] == 'C' || secam
[1] == 'c')
525 return V4L2_STD_SECAM_LC
;
526 return V4L2_STD_SECAM_L
;
530 IVTV_WARN("secam= argument not recognised\n");
537 return V4L2_STD_NTSC_M
;
540 return V4L2_STD_NTSC_M_JP
;
543 return V4L2_STD_NTSC_M_KR
;
547 IVTV_WARN("ntsc= argument not recognised\n");
555 static void ivtv_process_options(struct ivtv
*itv
)
557 const char *chipname
;
560 itv
->options
.kilobytes
[IVTV_ENC_STREAM_TYPE_MPG
] = enc_mpg_buffers
* 1024;
561 itv
->options
.kilobytes
[IVTV_ENC_STREAM_TYPE_YUV
] = enc_yuv_buffers
* 1024;
562 itv
->options
.kilobytes
[IVTV_ENC_STREAM_TYPE_VBI
] = enc_vbi_buffers
* 1024;
563 itv
->options
.kilobytes
[IVTV_ENC_STREAM_TYPE_PCM
] = enc_pcm_buffers
;
564 itv
->options
.kilobytes
[IVTV_DEC_STREAM_TYPE_MPG
] = dec_mpg_buffers
* 1024;
565 itv
->options
.kilobytes
[IVTV_DEC_STREAM_TYPE_YUV
] = dec_yuv_buffers
* 1024;
566 itv
->options
.kilobytes
[IVTV_DEC_STREAM_TYPE_VBI
] = dec_vbi_buffers
;
567 itv
->options
.cardtype
= cardtype
[itv
->num
];
568 itv
->options
.tuner
= tuner
[itv
->num
];
569 itv
->options
.radio
= radio
[itv
->num
];
570 itv
->options
.newi2c
= newi2c
;
572 itv
->std
= ivtv_parse_std(itv
);
573 itv
->has_cx23415
= (itv
->dev
->device
== PCI_DEVICE_ID_IVTV15
);
574 chipname
= itv
->has_cx23415
? "cx23415" : "cx23416";
575 if (itv
->options
.cardtype
== -1) {
576 IVTV_INFO("Ignore card (detected %s based chip)\n", chipname
);
579 if ((itv
->card
= ivtv_get_card(itv
->options
.cardtype
- 1))) {
580 IVTV_INFO("User specified %s card (detected %s based chip)\n",
581 itv
->card
->name
, chipname
);
582 } else if (itv
->options
.cardtype
!= 0) {
583 IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
585 if (itv
->card
== NULL
) {
586 if (itv
->dev
->subsystem_vendor
== IVTV_PCI_ID_HAUPPAUGE
||
587 itv
->dev
->subsystem_vendor
== IVTV_PCI_ID_HAUPPAUGE_ALT1
||
588 itv
->dev
->subsystem_vendor
== IVTV_PCI_ID_HAUPPAUGE_ALT2
) {
589 itv
->card
= ivtv_get_card(itv
->has_cx23415
? IVTV_CARD_PVR_350
: IVTV_CARD_PVR_150
);
590 IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
594 if (itv
->card
== NULL
) {
595 for (i
= 0; (itv
->card
= ivtv_get_card(i
)); i
++) {
596 if (itv
->card
->pci_list
== NULL
)
598 for (j
= 0; itv
->card
->pci_list
[j
].device
; j
++) {
599 if (itv
->dev
->device
!=
600 itv
->card
->pci_list
[j
].device
)
602 if (itv
->dev
->subsystem_vendor
!=
603 itv
->card
->pci_list
[j
].subsystem_vendor
)
605 if (itv
->dev
->subsystem_device
!=
606 itv
->card
->pci_list
[j
].subsystem_device
)
608 IVTV_INFO("Autodetected %s card (%s based)\n",
609 itv
->card
->name
, chipname
);
616 if (itv
->card
== NULL
) {
617 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_150
);
618 IVTV_ERR("Unknown card: vendor/device: %04x/%04x\n",
619 itv
->dev
->vendor
, itv
->dev
->device
);
620 IVTV_ERR(" subsystem vendor/device: %04x/%04x\n",
621 itv
->dev
->subsystem_vendor
, itv
->dev
->subsystem_device
);
622 IVTV_ERR(" %s based\n", chipname
);
623 IVTV_ERR("Defaulting to %s card\n", itv
->card
->name
);
624 IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
625 IVTV_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
626 IVTV_ERR("Prefix your subject line with [UNKNOWN CARD].\n");
628 itv
->v4l2_cap
= itv
->card
->v4l2_capabilities
;
629 itv
->card_name
= itv
->card
->name
;
632 /* Precondition: the ivtv structure has been memset to 0. Only
633 the dev and num fields have been filled in.
634 No assumptions on the card type may be made here (see ivtv_init_struct2
637 static int __devinit
ivtv_init_struct1(struct ivtv
*itv
)
639 itv
->base_addr
= pci_resource_start(itv
->dev
, 0);
640 itv
->enc_mbox
.max_mbox
= 2; /* the encoder has 3 mailboxes (0-2) */
641 itv
->dec_mbox
.max_mbox
= 1; /* the decoder has 2 mailboxes (0-1) */
643 mutex_init(&itv
->serialize_lock
);
644 mutex_init(&itv
->i2c_bus_lock
);
645 mutex_init(&itv
->udma
.lock
);
647 spin_lock_init(&itv
->lock
);
648 spin_lock_init(&itv
->dma_reg_lock
);
650 itv
->irq_work_queues
= create_workqueue(itv
->name
);
651 if (itv
->irq_work_queues
== NULL
) {
652 IVTV_ERR("Could not create ivtv workqueue\n");
656 INIT_WORK(&itv
->irq_work_queue
, ivtv_irq_work_handler
);
658 /* start counting open_id at 1 */
661 /* Initial settings */
662 cx2341x_fill_defaults(&itv
->params
);
663 itv
->params
.port
= CX2341X_PORT_MEMORY
;
664 itv
->params
.capabilities
= CX2341X_CAP_HAS_SLICED_VBI
;
665 init_waitqueue_head(&itv
->cap_w
);
666 init_waitqueue_head(&itv
->event_waitq
);
667 init_waitqueue_head(&itv
->vsync_waitq
);
668 init_waitqueue_head(&itv
->dma_waitq
);
669 init_timer(&itv
->dma_timer
);
670 itv
->dma_timer
.function
= ivtv_unfinished_dma
;
671 itv
->dma_timer
.data
= (unsigned long)itv
;
673 itv
->cur_dma_stream
= -1;
674 itv
->cur_pio_stream
= -1;
675 itv
->audio_stereo_mode
= AUDIO_STEREO
;
676 itv
->audio_bilingual_mode
= AUDIO_MONO_LEFT
;
682 itv
->vbi
.in
.type
= V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
;
683 itv
->vbi
.sliced_in
= &itv
->vbi
.in
.fmt
.sliced
;
686 itv
->osd_global_alpha_state
= 1;
687 itv
->osd_global_alpha
= 255;
690 atomic_set(&itv
->yuv_info
.next_dma_frame
, -1);
691 itv
->yuv_info
.lace_mode
= ivtv_yuv_mode
;
692 itv
->yuv_info
.lace_threshold
= ivtv_yuv_threshold
;
696 /* Second initialization part. Here the card type has been
698 static void __devinit
ivtv_init_struct2(struct ivtv
*itv
)
702 for (i
= 0; i
< IVTV_CARD_MAX_VIDEO_INPUTS
; i
++)
703 if (itv
->card
->video_inputs
[i
].video_type
== 0)
706 for (i
= 0; i
< IVTV_CARD_MAX_AUDIO_INPUTS
; i
++)
707 if (itv
->card
->audio_inputs
[i
].audio_type
== 0)
709 itv
->nof_audio_inputs
= i
;
711 /* 0x00EF = saa7114(239) 0x00F0 = saa7115(240) 0x0106 = micro */
712 if (itv
->card
->hw_all
& (IVTV_HW_SAA7115
| IVTV_HW_SAA717X
))
713 itv
->digitizer
= 0xF1;
714 else if (itv
->card
->hw_all
& IVTV_HW_SAA7114
)
715 itv
->digitizer
= 0xEF;
717 itv
->digitizer
= 0x140;
719 if (itv
->card
->hw_all
& IVTV_HW_CX25840
) {
720 itv
->vbi
.sliced_size
= 288; /* multiple of 16, real size = 284 */
722 itv
->vbi
.sliced_size
= 64; /* multiple of 16, real size = 52 */
725 /* Find tuner input */
726 for (i
= 0; i
< itv
->nof_inputs
; i
++) {
727 if (itv
->card
->video_inputs
[i
].video_type
==
728 IVTV_CARD_INPUT_VID_TUNER
)
731 if (i
== itv
->nof_inputs
)
733 itv
->active_input
= i
;
734 itv
->audio_input
= itv
->card
->video_inputs
[i
].audio_index
;
735 if (itv
->card
->hw_all
& IVTV_HW_CX25840
)
736 itv
->video_dec_func
= ivtv_cx25840
;
737 else if (itv
->card
->hw_all
& IVTV_HW_SAA717X
)
738 itv
->video_dec_func
= ivtv_saa717x
;
740 itv
->video_dec_func
= ivtv_saa7115
;
743 static int ivtv_setup_pci(struct ivtv
*itv
, struct pci_dev
*dev
,
744 const struct pci_device_id
*pci_id
)
747 unsigned char pci_latency
;
749 IVTV_DEBUG_INFO("Enabling pci device\n");
751 if (pci_enable_device(dev
)) {
752 IVTV_ERR("Can't enable device %d!\n", itv
->num
);
755 if (pci_set_dma_mask(dev
, 0xffffffff)) {
756 IVTV_ERR("No suitable DMA available on card %d.\n", itv
->num
);
759 if (!request_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
, "ivtv encoder")) {
760 IVTV_ERR("Cannot request encoder memory region on card %d.\n", itv
->num
);
764 if (!request_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
,
765 IVTV_REG_SIZE
, "ivtv registers")) {
766 IVTV_ERR("Cannot request register memory region on card %d.\n", itv
->num
);
767 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
771 if (itv
->has_cx23415
&&
772 !request_mem_region(itv
->base_addr
+ IVTV_DECODER_OFFSET
,
773 IVTV_DECODER_SIZE
, "ivtv decoder")) {
774 IVTV_ERR("Cannot request decoder memory region on card %d.\n", itv
->num
);
775 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
776 release_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
780 /* Check for bus mastering */
781 pci_read_config_word(dev
, PCI_COMMAND
, &cmd
);
782 if (!(cmd
& PCI_COMMAND_MASTER
)) {
783 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
785 pci_read_config_word(dev
, PCI_COMMAND
, &cmd
);
786 if (!(cmd
& PCI_COMMAND_MASTER
)) {
787 IVTV_ERR("Bus Mastering is not enabled\n");
791 IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
793 pci_read_config_byte(dev
, PCI_CLASS_REVISION
, &itv
->card_rev
);
794 pci_read_config_byte(dev
, PCI_LATENCY_TIMER
, &pci_latency
);
796 if (pci_latency
< 64 && ivtv_pci_latency
) {
797 IVTV_INFO("Unreasonably low latency timer, "
798 "setting to 64 (was %d)\n", pci_latency
);
799 pci_write_config_byte(dev
, PCI_LATENCY_TIMER
, 64);
800 pci_read_config_byte(dev
, PCI_LATENCY_TIMER
, &pci_latency
);
802 /* This config space value relates to DMA latencies. The
803 default value 0x8080 is too low however and will lead
804 to DMA errors. 0xffff is the max value which solves
806 pci_write_config_dword(dev
, 0x40, 0xffff);
808 IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
809 "irq: %d, latency: %d, memory: 0x%lx\n",
810 itv
->dev
->device
, itv
->card_rev
, dev
->bus
->number
,
811 PCI_SLOT(dev
->devfn
), PCI_FUNC(dev
->devfn
),
812 itv
->dev
->irq
, pci_latency
, (unsigned long)itv
->base_addr
);
817 static void ivtv_request_module(struct ivtv
*itv
, const char *name
)
819 if (request_module(name
) != 0) {
820 IVTV_ERR("Failed to load module %s\n", name
);
822 IVTV_DEBUG_INFO("Loaded module %s\n", name
);
826 static void ivtv_load_and_init_modules(struct ivtv
*itv
)
828 u32 hw
= itv
->card
->hw_all
;
832 #ifndef CONFIG_VIDEO_TUNER
833 if (hw
& IVTV_HW_TUNER
) {
834 if (itv
->options
.tuner
== TUNER_XCEIVE_XC3028
) {
835 IVTV_INFO("Xceive tuner not yet supported, only composite and S-Video inputs will be available\n");
839 ivtv_request_module(itv
, "tuner");
843 #ifndef CONFIG_VIDEO_CX25840
844 if (hw
& IVTV_HW_CX25840
)
845 ivtv_request_module(itv
, "cx25840");
847 #ifndef CONFIG_VIDEO_SAA711X
848 if (hw
& IVTV_HW_SAA711X
)
849 ivtv_request_module(itv
, "saa7115");
851 #ifndef CONFIG_VIDEO_SAA7127
852 if (hw
& IVTV_HW_SAA7127
)
853 ivtv_request_module(itv
, "saa7127");
855 if (hw
& IVTV_HW_SAA717X
)
856 ivtv_request_module(itv
, "saa717x");
857 #ifndef CONFIG_VIDEO_UPD64031A
858 if (hw
& IVTV_HW_UPD64031A
)
859 ivtv_request_module(itv
, "upd64031a");
861 #ifndef CONFIG_VIDEO_UPD64083
862 if (hw
& IVTV_HW_UPD6408X
)
863 ivtv_request_module(itv
, "upd64083");
865 #ifndef CONFIG_VIDEO_MSP3400
866 if (hw
& IVTV_HW_MSP34XX
)
867 ivtv_request_module(itv
, "msp3400");
869 #ifndef CONFIG_VIDEO_VP27SMPX
870 if (hw
& IVTV_HW_VP27SMPX
)
871 ivtv_request_module(itv
, "vp27smpx");
873 if (hw
& IVTV_HW_TVAUDIO
)
874 ivtv_request_module(itv
, "tvaudio");
875 #ifndef CONFIG_VIDEO_WM8775
876 if (hw
& IVTV_HW_WM8775
)
877 ivtv_request_module(itv
, "wm8775");
879 #ifndef CONFIG_VIDEO_WM8739
880 if (hw
& IVTV_HW_WM8739
)
881 ivtv_request_module(itv
, "wm8739");
883 #ifndef CONFIG_VIDEO_CS53L32A
884 if (hw
& IVTV_HW_CS53L32A
)
885 ivtv_request_module(itv
, "cs53l32a");
888 /* check which i2c devices are actually found */
889 for (i
= 0; i
< 32; i
++) {
894 if (device
== IVTV_HW_GPIO
) {
895 /* GPIO is always available */
896 itv
->hw_flags
|= IVTV_HW_GPIO
;
899 if (ivtv_i2c_hw_addr(itv
, device
) > 0)
900 itv
->hw_flags
|= device
;
905 if (itv
->card
->type
== IVTV_CARD_CX23416GYC
) {
906 /* Several variations of this card exist, detect which card
907 type should be used. */
908 if ((hw
& (IVTV_HW_UPD64031A
| IVTV_HW_UPD6408X
)) == 0)
909 itv
->card
= ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS
);
910 else if ((hw
& IVTV_HW_UPD64031A
) == 0)
911 itv
->card
= ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR
);
913 else if (itv
->card
->type
== IVTV_CARD_GV_MVPRX
||
914 itv
->card
->type
== IVTV_CARD_GV_MVPRX2E
) {
915 struct v4l2_crystal_freq crystal_freq
;
917 /* The crystal frequency of GVMVPRX is 24.576MHz */
918 crystal_freq
.freq
= SAA7115_FREQ_24_576_MHZ
;
919 crystal_freq
.flags
= SAA7115_FREQ_FL_UCGC
;
920 itv
->video_dec_func(itv
, VIDIOC_INT_S_CRYSTAL_FREQ
, &crystal_freq
);
923 if (hw
& IVTV_HW_CX25840
) {
924 itv
->vbi
.raw_decoder_line_size
= 1444;
925 itv
->vbi
.raw_decoder_sav_odd_field
= 0x20;
926 itv
->vbi
.raw_decoder_sav_even_field
= 0x60;
927 itv
->vbi
.sliced_decoder_line_size
= 272;
928 itv
->vbi
.sliced_decoder_sav_odd_field
= 0xB0;
929 itv
->vbi
.sliced_decoder_sav_even_field
= 0xF0;
932 if (hw
& IVTV_HW_SAA711X
) {
933 struct v4l2_chip_ident v
= { V4L2_CHIP_MATCH_I2C_DRIVER
, I2C_DRIVERID_SAA711X
};
935 /* determine the exact saa711x model */
936 itv
->hw_flags
&= ~IVTV_HW_SAA711X
;
938 ivtv_saa7115(itv
, VIDIOC_G_CHIP_IDENT
, &v
);
939 if (v
.ident
== V4L2_IDENT_SAA7114
) {
940 itv
->hw_flags
|= IVTV_HW_SAA7114
;
941 /* VBI is not yet supported by the saa7114 driver. */
942 itv
->v4l2_cap
&= ~(V4L2_CAP_SLICED_VBI_CAPTURE
|V4L2_CAP_VBI_CAPTURE
);
945 itv
->hw_flags
|= IVTV_HW_SAA7115
;
947 itv
->vbi
.raw_decoder_line_size
= 1443;
948 itv
->vbi
.raw_decoder_sav_odd_field
= 0x25;
949 itv
->vbi
.raw_decoder_sav_even_field
= 0x62;
950 itv
->vbi
.sliced_decoder_line_size
= 51;
951 itv
->vbi
.sliced_decoder_sav_odd_field
= 0xAB;
952 itv
->vbi
.sliced_decoder_sav_even_field
= 0xEC;
955 if (hw
& IVTV_HW_SAA717X
) {
956 itv
->vbi
.raw_decoder_line_size
= 1443;
957 itv
->vbi
.raw_decoder_sav_odd_field
= 0x25;
958 itv
->vbi
.raw_decoder_sav_even_field
= 0x62;
959 itv
->vbi
.sliced_decoder_line_size
= 51;
960 itv
->vbi
.sliced_decoder_sav_odd_field
= 0xAB;
961 itv
->vbi
.sliced_decoder_sav_even_field
= 0xEC;
965 static int __devinit
ivtv_probe(struct pci_dev
*dev
,
966 const struct pci_device_id
*pci_id
)
973 spin_lock(&ivtv_cards_lock
);
975 /* Make sure we've got a place for this card */
976 if (ivtv_cards_active
== IVTV_MAX_CARDS
) {
977 printk(KERN_ERR
"ivtv: Maximum number of cards detected (%d)\n",
979 spin_unlock(&ivtv_cards_lock
);
983 itv
= kzalloc(sizeof(struct ivtv
), GFP_ATOMIC
);
985 spin_unlock(&ivtv_cards_lock
);
988 ivtv_cards
[ivtv_cards_active
] = itv
;
990 itv
->num
= ivtv_cards_active
++;
991 snprintf(itv
->name
, sizeof(itv
->name
) - 1, "ivtv%d", itv
->num
);
992 IVTV_INFO("Initializing card #%d\n", itv
->num
);
994 spin_unlock(&ivtv_cards_lock
);
996 ivtv_process_options(itv
);
997 if (itv
->options
.cardtype
== -1) {
1001 if (ivtv_init_struct1(itv
)) {
1006 IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv
->base_addr
);
1008 /* PCI Device Setup */
1009 if ((retval
= ivtv_setup_pci(itv
, dev
, pci_id
)) != 0) {
1011 goto free_workqueue
;
1012 else if (retval
== -ENXIO
)
1015 /* save itv in the pci struct for later use */
1016 pci_set_drvdata(dev
, itv
);
1019 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1020 itv
->base_addr
+ IVTV_ENCODER_OFFSET
, IVTV_ENCODER_SIZE
);
1021 itv
->enc_mem
= ioremap_nocache(itv
->base_addr
+ IVTV_ENCODER_OFFSET
,
1023 if (!itv
->enc_mem
) {
1024 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1025 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1030 if (itv
->has_cx23415
) {
1031 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1032 itv
->base_addr
+ IVTV_DECODER_OFFSET
, IVTV_DECODER_SIZE
);
1033 itv
->dec_mem
= ioremap_nocache(itv
->base_addr
+ IVTV_DECODER_OFFSET
,
1035 if (!itv
->dec_mem
) {
1036 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1037 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1043 itv
->dec_mem
= itv
->enc_mem
;
1046 /* map registers memory */
1047 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1048 itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1050 ioremap_nocache(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1051 if (!itv
->reg_mem
) {
1052 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1053 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1058 /* Check yuv output filter table */
1059 if (itv
->has_cx23415
) ivtv_yuv_filter_check(itv
);
1061 ivtv_gpio_init(itv
);
1064 IVTV_DEBUG_INFO("activating i2c...\n");
1065 if (init_ivtv_i2c(itv
)) {
1066 IVTV_ERR("Could not initialize i2c\n");
1070 IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active
);
1072 if (itv
->card
->hw_all
& IVTV_HW_TVEEPROM
) {
1073 #ifdef CONFIG_VIDEO_TVEEPROM_MODULE
1074 ivtv_request_module(itv
, "tveeprom");
1076 /* Based on the model number the cardtype may be changed.
1077 The PCI IDs are not always reliable. */
1078 ivtv_process_eeprom(itv
);
1081 if (itv
->std
== 0) {
1082 itv
->std
= V4L2_STD_NTSC_M
;
1085 if (itv
->options
.tuner
== -1) {
1088 for (i
= 0; i
< IVTV_CARD_MAX_TUNERS
; i
++) {
1089 if ((itv
->std
& itv
->card
->tuners
[i
].std
) == 0)
1091 itv
->options
.tuner
= itv
->card
->tuners
[i
].tuner
;
1095 /* if no tuner was found, then pick the first tuner in the card list */
1096 if (itv
->options
.tuner
== -1 && itv
->card
->tuners
[0].std
) {
1097 itv
->std
= itv
->card
->tuners
[0].std
;
1098 itv
->options
.tuner
= itv
->card
->tuners
[0].tuner
;
1100 if (itv
->options
.radio
== -1)
1101 itv
->options
.radio
= (itv
->card
->radio_input
.audio_type
!= 0);
1103 /* The card is now fully identified, continue with card-specific
1105 ivtv_init_struct2(itv
);
1107 ivtv_load_and_init_modules(itv
);
1109 if (itv
->std
& V4L2_STD_525_60
) {
1111 itv
->is_out_60hz
= 1;
1114 itv
->is_out_50hz
= 1;
1116 itv
->params
.video_gop_size
= itv
->is_60hz
? 15 : 12;
1118 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_MPG
] = 0x08000;
1119 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_PCM
] = 0x01200;
1120 itv
->stream_buf_size
[IVTV_DEC_STREAM_TYPE_MPG
] = 0x10000;
1122 /* 0x15180 == 720 * 480 / 4, 0x19500 == 720 * 576 / 4 */
1123 yuv_buf_size
= itv
->is_60hz
? 0x15180 : 0x19500;
1124 itv
->stream_buf_size
[IVTV_DEC_STREAM_TYPE_YUV
] = yuv_buf_size
/ 2;
1125 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_YUV
] = yuv_buf_size
/ 8;
1127 /* Setup VBI Raw Size. Should be big enough to hold PAL.
1128 It is possible to switch between PAL and NTSC, so we need to
1129 take the largest size here. */
1130 /* 1456 is multiple of 16, real size = 1444 */
1131 itv
->vbi
.raw_size
= 1456;
1132 /* We use a buffer size of 1/2 of the total size needed for a
1133 frame. This is actually very useful, since we now receive
1134 a field at a time and that makes 'compressing' the raw data
1135 down to size by stripping off the SAV codes a lot easier.
1136 Note: having two different buffer sizes prevents standard
1137 switching on the fly. We need to find a better solution... */
1138 vbi_buf_size
= itv
->vbi
.raw_size
* (itv
->is_60hz
? 24 : 36) / 2;
1139 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_VBI
] = vbi_buf_size
;
1140 itv
->stream_buf_size
[IVTV_DEC_STREAM_TYPE_VBI
] = sizeof(struct v4l2_sliced_vbi_data
) * 36;
1142 if (itv
->options
.radio
> 0)
1143 itv
->v4l2_cap
|= V4L2_CAP_RADIO
;
1145 if (itv
->options
.tuner
> -1 && itv
->tunerid
== 0) {
1146 struct tuner_setup setup
;
1148 setup
.addr
= ADDR_UNSET
;
1149 setup
.type
= itv
->options
.tuner
;
1150 setup
.mode_mask
= T_ANALOG_TV
; /* matches TV tuners */
1151 ivtv_call_i2c_clients(itv
, TUNER_SET_TYPE_ADDR
, &setup
);
1154 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1156 itv
->tuner_std
= itv
->std
;
1158 if (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
) {
1159 ivtv_call_i2c_clients(itv
, VIDIOC_INT_S_STD_OUTPUT
, &itv
->std
);
1162 retval
= ivtv_streams_setup(itv
);
1164 IVTV_ERR("Error %d setting up streams\n", retval
);
1168 IVTV_DEBUG_IRQ("Masking interrupts\n");
1169 /* clear interrupt mask, effectively disabling interrupts */
1170 ivtv_set_irq_mask(itv
, 0xffffffff);
1173 retval
= request_irq(itv
->dev
->irq
, ivtv_irq_handler
,
1174 IRQF_SHARED
| IRQF_DISABLED
, itv
->name
, (void *)itv
);
1176 IVTV_ERR("Failed to register irq %d\n", retval
);
1179 IVTV_INFO("Initialized card #%d: %s\n", itv
->num
, itv
->card_name
);
1183 free_irq(itv
->dev
->irq
, (void *)itv
);
1185 ivtv_streams_cleanup(itv
);
1191 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
1192 release_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1193 if (itv
->has_cx23415
)
1194 release_mem_region(itv
->base_addr
+ IVTV_DECODER_OFFSET
, IVTV_DECODER_SIZE
);
1196 destroy_workqueue(itv
->irq_work_queues
);
1200 IVTV_ERR("Error %d on initialization\n", retval
);
1202 spin_lock(&ivtv_cards_lock
);
1203 kfree(ivtv_cards
[ivtv_cards_active
]);
1204 ivtv_cards
[ivtv_cards_active
] = NULL
;
1205 spin_unlock(&ivtv_cards_lock
);
1209 int ivtv_init_on_first_open(struct ivtv
*itv
)
1211 struct v4l2_frequency vf
;
1212 int fw_retry_count
= 3;
1215 if (test_bit(IVTV_F_I_FAILED
, &itv
->i_flags
))
1218 if (test_and_set_bit(IVTV_F_I_INITED
, &itv
->i_flags
))
1221 while (--fw_retry_count
> 0) {
1223 if (ivtv_firmware_init(itv
) == 0)
1225 if (fw_retry_count
> 1)
1226 IVTV_WARN("Retry loading firmware\n");
1229 if (fw_retry_count
== 0) {
1230 set_bit(IVTV_F_I_FAILED
, &itv
->i_flags
);
1234 /* Try and get firmware versions */
1235 IVTV_DEBUG_INFO("Getting firmware version..\n");
1236 ivtv_firmware_versions(itv
);
1238 if (itv
->card
->hw_all
& IVTV_HW_CX25840
) {
1239 struct v4l2_control ctrl
;
1241 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1242 ctrl
.id
= V4L2_CID_PRIVATE_BASE
;
1243 ctrl
.value
= itv
->pvr150_workaround
;
1244 itv
->video_dec_func(itv
, VIDIOC_S_CTRL
, &ctrl
);
1248 vf
.type
= V4L2_TUNER_ANALOG_TV
;
1249 vf
.frequency
= 6400; /* the tuner 'baseline' frequency */
1251 /* Set initial frequency. For PAL/SECAM broadcasts no
1252 'default' channel exists AFAIK. */
1253 if (itv
->std
== V4L2_STD_NTSC_M_JP
) {
1254 vf
.frequency
= 1460; /* ch. 1 91250*16/1000 */
1256 else if (itv
->std
& V4L2_STD_NTSC_M
) {
1257 vf
.frequency
= 1076; /* ch. 4 67250*16/1000 */
1260 video_input
= itv
->active_input
;
1261 itv
->active_input
++; /* Force update of input */
1262 ivtv_v4l2_ioctls(itv
, NULL
, VIDIOC_S_INPUT
, &video_input
);
1264 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1266 itv
->std
++; /* Force full standard initialization */
1267 itv
->std_out
= itv
->std
;
1268 ivtv_v4l2_ioctls(itv
, NULL
, VIDIOC_S_FREQUENCY
, &vf
);
1270 if (itv
->card
->v4l2_capabilities
& V4L2_CAP_VIDEO_OUTPUT
) {
1271 ivtv_init_mpeg_decoder(itv
);
1273 ivtv_v4l2_ioctls(itv
, NULL
, VIDIOC_S_STD
, &itv
->tuner_std
);
1275 /* On a cx23416 this seems to be able to enable DMA to the chip? */
1276 if (!itv
->has_cx23415
)
1277 write_reg_sync(0x03, IVTV_REG_DMACONTROL
);
1279 /* Default interrupts enabled. For the PVR350 this includes the
1280 decoder VSYNC interrupt, which is always on. It is not only used
1281 during decoding but also by the OSD.
1282 Some old PVR250 cards had a cx23415, so testing for that is too
1283 general. Instead test if the card has video output capability. */
1284 if (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
) {
1285 ivtv_clear_irq_mask(itv
, IVTV_IRQ_MASK_INIT
| IVTV_IRQ_DEC_VSYNC
);
1286 ivtv_set_osd_alpha(itv
);
1289 ivtv_clear_irq_mask(itv
, IVTV_IRQ_MASK_INIT
);
1293 static void ivtv_remove(struct pci_dev
*pci_dev
)
1295 struct ivtv
*itv
= pci_get_drvdata(pci_dev
);
1297 IVTV_DEBUG_INFO("Removing Card #%d\n", itv
->num
);
1299 if (test_bit(IVTV_F_I_INITED
, &itv
->i_flags
)) {
1300 /* Stop all captures */
1301 IVTV_DEBUG_INFO("Stopping all streams\n");
1302 if (atomic_read(&itv
->capturing
) > 0)
1303 ivtv_stop_all_captures(itv
);
1305 /* Stop all decoding */
1306 IVTV_DEBUG_INFO("Stopping decoding\n");
1307 if (atomic_read(&itv
->decoding
) > 0) {
1310 if (test_bit(IVTV_F_I_DEC_YUV
, &itv
->i_flags
))
1311 type
= IVTV_DEC_STREAM_TYPE_YUV
;
1313 type
= IVTV_DEC_STREAM_TYPE_MPG
;
1314 ivtv_stop_v4l2_decode_stream(&itv
->streams
[type
],
1315 VIDEO_CMD_STOP_TO_BLACK
| VIDEO_CMD_STOP_IMMEDIATELY
, 0);
1317 ivtv_halt_firmware(itv
);
1321 ivtv_set_irq_mask(itv
, 0xffffffff);
1322 del_timer_sync(&itv
->dma_timer
);
1324 /* Stop all Work Queues */
1325 flush_workqueue(itv
->irq_work_queues
);
1326 destroy_workqueue(itv
->irq_work_queues
);
1328 ivtv_streams_cleanup(itv
);
1329 ivtv_udma_free(itv
);
1333 free_irq(itv
->dev
->irq
, (void *)itv
);
1336 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
1337 release_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1338 if (itv
->has_cx23415
)
1339 release_mem_region(itv
->base_addr
+ IVTV_DECODER_OFFSET
, IVTV_DECODER_SIZE
);
1341 pci_disable_device(itv
->dev
);
1343 IVTV_INFO("Removed %s, card #%d\n", itv
->card_name
, itv
->num
);
1346 /* define a pci_driver for card detection */
1347 static struct pci_driver ivtv_pci_driver
= {
1349 .id_table
= ivtv_pci_tbl
,
1350 .probe
= ivtv_probe
,
1351 .remove
= ivtv_remove
,
1354 static int module_start(void)
1356 printk(KERN_INFO
"ivtv: Start initialization, version %s\n", IVTV_VERSION
);
1358 memset(ivtv_cards
, 0, sizeof(ivtv_cards
));
1360 /* Validate parameters */
1361 if (ivtv_first_minor
< 0 || ivtv_first_minor
>= IVTV_MAX_CARDS
) {
1362 printk(KERN_ERR
"ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1363 IVTV_MAX_CARDS
- 1);
1367 if (ivtv_debug
< 0 || ivtv_debug
> 2047) {
1369 printk(KERN_INFO
"ivtv: Debug value must be >= 0 and <= 2047\n");
1372 if (pci_register_driver(&ivtv_pci_driver
)) {
1373 printk(KERN_ERR
"ivtv: Error detecting PCI card\n");
1376 printk(KERN_INFO
"ivtv: End initialization\n");
1380 static void module_cleanup(void)
1384 pci_unregister_driver(&ivtv_pci_driver
);
1386 spin_lock(&ivtv_cards_lock
);
1387 for (i
= 0; i
< ivtv_cards_active
; i
++) {
1388 if (ivtv_cards
[i
] == NULL
)
1390 for (j
= 0; j
< IVTV_VBI_FRAMES
; j
++) {
1391 kfree(ivtv_cards
[i
]->vbi
.sliced_mpeg_data
[j
]);
1393 kfree(ivtv_cards
[i
]);
1395 spin_unlock(&ivtv_cards_lock
);
1398 /* Note: These symbols are exported because they are used by the ivtv-fb
1399 framebuffer module and an infrared module for the IR-blaster. */
1400 EXPORT_SYMBOL(ivtv_set_irq_mask
);
1401 EXPORT_SYMBOL(ivtv_cards_active
);
1402 EXPORT_SYMBOL(ivtv_cards
);
1403 EXPORT_SYMBOL(ivtv_cards_lock
);
1404 EXPORT_SYMBOL(ivtv_api
);
1405 EXPORT_SYMBOL(ivtv_vapi
);
1406 EXPORT_SYMBOL(ivtv_vapi_result
);
1407 EXPORT_SYMBOL(ivtv_clear_irq_mask
);
1408 EXPORT_SYMBOL(ivtv_debug
);
1409 EXPORT_SYMBOL(ivtv_reset_ir_gpio
);
1410 EXPORT_SYMBOL(ivtv_udma_setup
);
1411 EXPORT_SYMBOL(ivtv_udma_unmap
);
1412 EXPORT_SYMBOL(ivtv_udma_alloc
);
1413 EXPORT_SYMBOL(ivtv_udma_prepare
);
1414 EXPORT_SYMBOL(ivtv_init_on_first_open
);
1416 module_init(module_start
);
1417 module_exit(module_cleanup
);