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-routing.h"
56 #include "ivtv-controls.h"
57 #include "ivtv-gpio.h"
59 #include <media/tveeprom.h>
60 #include <media/saa7115.h>
61 #include <media/v4l2-chip-ident.h>
62 #include "tuner-xc2028.h"
64 /* If you have already X v4l cards, then set this to X. This way
65 the device numbers stay matched. Example: you have a WinTV card
66 without radio and a PVR-350 with. Normally this would give a
67 video1 device together with a radio0 device for the PVR. By
68 setting this to 1 you ensure that radio0 is now also radio1. */
71 /* add your revision and whatnot here */
72 static 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},
80 MODULE_DEVICE_TABLE(pci
,ivtv_pci_tbl
);
82 /* ivtv instance counter */
83 static atomic_t ivtv_instance
= ATOMIC_INIT(0);
85 /* Parameter declarations */
86 static int cardtype
[IVTV_MAX_CARDS
];
87 static 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 };
91 static 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 };
95 static 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 };
100 static unsigned int cardtype_c
= 1;
101 static unsigned int tuner_c
= 1;
102 static unsigned int radio_c
= 1;
103 static unsigned int i2c_clock_period_c
= 1;
104 static char pal
[] = "---";
105 static char secam
[] = "--";
106 static char ntsc
[] = "-";
110 /* DMA Buffers, Default size in MB allocated */
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 /* Exception: size in kB for this stream (MB is overkill) */
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 /* Exception: size in kB for this stream (MB is way overkill) */
119 #define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
121 static int enc_mpg_buffers
= IVTV_DEFAULT_ENC_MPG_BUFFERS
;
122 static int enc_yuv_buffers
= IVTV_DEFAULT_ENC_YUV_BUFFERS
;
123 static int enc_vbi_buffers
= IVTV_DEFAULT_ENC_VBI_BUFFERS
;
124 static int enc_pcm_buffers
= IVTV_DEFAULT_ENC_PCM_BUFFERS
;
125 static int dec_mpg_buffers
= IVTV_DEFAULT_DEC_MPG_BUFFERS
;
126 static int dec_yuv_buffers
= IVTV_DEFAULT_DEC_YUV_BUFFERS
;
127 static int dec_vbi_buffers
= IVTV_DEFAULT_DEC_VBI_BUFFERS
;
129 static int ivtv_yuv_mode
;
130 static int ivtv_yuv_threshold
= -1;
131 static int ivtv_pci_latency
= 1;
134 #ifdef CONFIG_VIDEO_ADV_DEBUG
138 static int tunertype
= -1;
139 static int newi2c
= -1;
141 module_param_array(tuner
, int, &tuner_c
, 0644);
142 module_param_array(radio
, bool, &radio_c
, 0644);
143 module_param_array(cardtype
, int, &cardtype_c
, 0644);
144 module_param_string(pal
, pal
, sizeof(pal
), 0644);
145 module_param_string(secam
, secam
, sizeof(secam
), 0644);
146 module_param_string(ntsc
, ntsc
, sizeof(ntsc
), 0644);
147 module_param_named(debug
,ivtv_debug
, int, 0644);
148 #ifdef CONFIG_VIDEO_ADV_DEBUG
149 module_param_named(fw_debug
, ivtv_fw_debug
, int, 0644);
151 module_param(ivtv_pci_latency
, int, 0644);
152 module_param(ivtv_yuv_mode
, int, 0644);
153 module_param(ivtv_yuv_threshold
, int, 0644);
154 module_param(ivtv_first_minor
, int, 0644);
156 module_param(enc_mpg_buffers
, int, 0644);
157 module_param(enc_yuv_buffers
, int, 0644);
158 module_param(enc_vbi_buffers
, int, 0644);
159 module_param(enc_pcm_buffers
, int, 0644);
160 module_param(dec_mpg_buffers
, int, 0644);
161 module_param(dec_yuv_buffers
, int, 0644);
162 module_param(dec_vbi_buffers
, int, 0644);
164 module_param(tunertype
, int, 0644);
165 module_param(newi2c
, int, 0644);
166 module_param_array(i2c_clock_period
, int, &i2c_clock_period_c
, 0644);
168 MODULE_PARM_DESC(tuner
, "Tuner type selection,\n"
169 "\t\t\tsee tuner.h for values");
170 MODULE_PARM_DESC(radio
,
171 "Enable or disable the radio. Use only if autodetection\n"
172 "\t\t\tfails. 0 = disable, 1 = enable");
173 MODULE_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");
206 MODULE_PARM_DESC(pal
, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
207 MODULE_PARM_DESC(secam
, "Set SECAM standard: BGH, DK, L, LC");
208 MODULE_PARM_DESC(ntsc
, "Set NTSC standard: M, J (Japan), K (South Korea)");
209 MODULE_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");
214 MODULE_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
228 MODULE_PARM_DESC(fw_debug
,
229 "Enable code for debugging firmware problems. Default: 0\n");
231 MODULE_PARM_DESC(ivtv_pci_latency
,
232 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
233 "\t\t\tDefault: Yes");
234 MODULE_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)");
238 MODULE_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");
241 MODULE_PARM_DESC(enc_mpg_buffers
,
242 "Encoder MPG Buffers (in MB)\n"
243 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS
));
244 MODULE_PARM_DESC(enc_yuv_buffers
,
245 "Encoder YUV Buffers (in MB)\n"
246 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS
));
247 MODULE_PARM_DESC(enc_vbi_buffers
,
248 "Encoder VBI Buffers (in MB)\n"
249 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS
));
250 MODULE_PARM_DESC(enc_pcm_buffers
,
251 "Encoder PCM buffers (in kB)\n"
252 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS
));
253 MODULE_PARM_DESC(dec_mpg_buffers
,
254 "Decoder MPG buffers (in MB)\n"
255 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS
));
256 MODULE_PARM_DESC(dec_yuv_buffers
,
257 "Decoder YUV buffers (in MB)\n"
258 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS
));
259 MODULE_PARM_DESC(dec_vbi_buffers
,
260 "Decoder VBI buffers (in kB)\n"
261 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS
));
262 MODULE_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");
266 MODULE_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
));
271 MODULE_PARM_DESC(ivtv_first_minor
, "Set device node number assigned to first card");
273 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
274 MODULE_DESCRIPTION("CX23415/CX23416 driver");
275 MODULE_SUPPORTED_DEVICE
276 ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
277 "\t\t\tYuan MPG series and similar)");
278 MODULE_LICENSE("GPL");
280 MODULE_VERSION(IVTV_VERSION
);
282 void ivtv_clear_irq_mask(struct ivtv
*itv
, u32 mask
)
284 itv
->irqmask
&= ~mask
;
285 write_reg_sync(itv
->irqmask
, IVTV_REG_IRQMASK
);
288 void ivtv_set_irq_mask(struct ivtv
*itv
, u32 mask
)
290 itv
->irqmask
|= mask
;
291 write_reg_sync(itv
->irqmask
, IVTV_REG_IRQMASK
);
294 int ivtv_set_output_mode(struct ivtv
*itv
, int mode
)
298 spin_lock(&itv
->lock
);
299 old_mode
= itv
->output_mode
;
301 itv
->output_mode
= old_mode
= mode
;
302 spin_unlock(&itv
->lock
);
306 struct ivtv_stream
*ivtv_get_output_stream(struct ivtv
*itv
)
308 switch (itv
->output_mode
) {
310 return &itv
->streams
[IVTV_DEC_STREAM_TYPE_MPG
];
312 return &itv
->streams
[IVTV_DEC_STREAM_TYPE_YUV
];
318 int ivtv_waitq(wait_queue_head_t
*waitq
)
322 prepare_to_wait(waitq
, &wait
, TASK_INTERRUPTIBLE
);
324 finish_wait(waitq
, &wait
);
325 return signal_pending(current
) ? -EINTR
: 0;
328 /* Generic utility functions */
329 int ivtv_msleep_timeout(unsigned int msecs
, int intr
)
331 int timeout
= msecs_to_jiffies(msecs
);
334 set_current_state(intr
? TASK_INTERRUPTIBLE
: TASK_UNINTERRUPTIBLE
);
335 timeout
= schedule_timeout(timeout
);
337 int ret
= signal_pending(current
);
346 /* Release ioremapped memory */
347 static void ivtv_iounmap(struct ivtv
*itv
)
352 /* Release registers memory */
353 if (itv
->reg_mem
!= NULL
) {
354 IVTV_DEBUG_INFO("releasing reg_mem\n");
355 iounmap(itv
->reg_mem
);
358 /* Release io memory */
359 if (itv
->has_cx23415
&& itv
->dec_mem
!= NULL
) {
360 IVTV_DEBUG_INFO("releasing dec_mem\n");
361 iounmap(itv
->dec_mem
);
365 /* Release io memory */
366 if (itv
->enc_mem
!= NULL
) {
367 IVTV_DEBUG_INFO("releasing enc_mem\n");
368 iounmap(itv
->enc_mem
);
373 /* Hauppauge card? get values from tveeprom */
374 void ivtv_read_eeprom(struct ivtv
*itv
, struct tveeprom
*tv
)
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
);
383 static void ivtv_process_eeprom(struct ivtv
*itv
)
386 int pci_slot
= PCI_SLOT(itv
->pdev
->devfn
);
388 ivtv_read_eeprom(itv
, &tv
);
390 /* Many thanks to Steven Toth from Hauppauge for providing the
393 /* In a few cases the PCI subsystem IDs do not correctly
394 identify the card. A better method is to check the
395 model number from the eeprom instead. */
396 case 30012 ... 30039: /* Low profile PVR250 */
397 case 32000 ... 32999:
398 case 48000 ... 48099: /* 48??? range are PVR250s with a cx23415 */
399 case 48400 ... 48599:
400 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_250
);
402 case 48100 ... 48399:
403 case 48600 ... 48999:
404 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_350
);
406 case 23000 ... 23999: /* PVR500 */
407 case 25000 ... 25999: /* Low profile PVR150 */
408 case 26000 ... 26999: /* Regular PVR150 */
409 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_150
);
412 IVTV_ERR("Invalid EEPROM\n");
415 IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv
.model
);
416 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_150
);
421 /* Old style PVR350 (with an saa7114) uses this input for
424 itv
->card
= ivtv_get_card(IVTV_CARD_PVR_350_V1
);
430 itv
->v4l2_cap
= itv
->card
->v4l2_capabilities
;
431 itv
->card_name
= itv
->card
->name
;
432 itv
->card_i2c
= itv
->card
->i2c
;
434 /* If this is a PVR500 then it should be possible to detect whether it is the
435 first or second unit by looking at the subsystem device ID: is bit 4 is
436 set, then it is the second unit (according to info from Hauppauge).
438 However, while this works for most cards, I have seen a few PVR500 cards
439 where both units have the same subsystem ID.
441 So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
442 PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
443 it is the second unit. It is possible that it is a different slot when ivtv is
444 used in Xen, in that case I ignore this card here. The worst that can happen
445 is that the card presents itself with a non-working radio device.
447 This detection is needed since the eeprom reports incorrectly that a radio is
448 present on the second unit. */
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
},
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;
461 itv
->card_name
= is_first
? "WinTV PVR 500 (unit #1)" :
462 "WinTV PVR 500 (unit #2)";
464 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
469 IVTV_INFO("Autodetected %s\n", itv
->card_name
);
471 switch (tv
.tuner_hauppauge_model
) {
475 itv
->pvr150_workaround
= 1;
480 if (tv
.tuner_type
== TUNER_ABSENT
)
481 IVTV_ERR("tveeprom cannot autodetect tuner!\n");
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 /* only enable newi2c if an IR blaster is present */
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");
498 /* user specified tuner standard */
501 /* autodetect tuner standard */
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
;
512 IVTV_INFO("No tuner detected, default to NTSC-M\n");
513 itv
->std
|= V4L2_STD_NTSC_M
;
517 static v4l2_std_id
ivtv_parse_std(struct ivtv
*itv
)
522 return V4L2_STD_PAL_60
;
530 return V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
534 if (pal
[1] == 'c' || pal
[1] == 'C')
535 return V4L2_STD_PAL_Nc
;
536 return V4L2_STD_PAL_N
;
540 return V4L2_STD_PAL_I
;
546 return V4L2_STD_PAL_DK
;
550 return V4L2_STD_PAL_M
;
554 IVTV_WARN("pal= argument not recognised\n");
566 return V4L2_STD_SECAM_B
| V4L2_STD_SECAM_G
| V4L2_STD_SECAM_H
;
572 return V4L2_STD_SECAM_DK
;
576 if (secam
[1] == 'C' || secam
[1] == 'c')
577 return V4L2_STD_SECAM_LC
;
578 return V4L2_STD_SECAM_L
;
582 IVTV_WARN("secam= argument not recognised\n");
590 return V4L2_STD_NTSC_M
;
594 return V4L2_STD_NTSC_M_JP
;
598 return V4L2_STD_NTSC_M_KR
;
602 IVTV_WARN("ntsc= argument not recognised\n");
610 static void ivtv_process_options(struct ivtv
*itv
)
612 const char *chipname
;
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
];
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;
634 itv
->options
.newi2c
= newi2c
;
635 if (tunertype
< -1 || tunertype
> 1) {
636 IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
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
);
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");
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",
663 if (itv
->card
== NULL
) {
664 for (i
= 0; (itv
->card
= ivtv_get_card(i
)); i
++) {
665 if (itv
->card
->pci_list
== NULL
)
667 for (j
= 0; itv
->card
->pci_list
[j
].device
; j
++) {
668 if (itv
->pdev
->device
!=
669 itv
->card
->pci_list
[j
].device
)
671 if (itv
->pdev
->subsystem_vendor
!=
672 itv
->card
->pci_list
[j
].subsystem_vendor
)
674 if (itv
->pdev
->subsystem_device
!=
675 itv
->card
->pci_list
[j
].subsystem_device
)
677 IVTV_INFO("Autodetected %s card (%s based)\n",
678 itv
->card
->name
, chipname
);
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");
697 itv
->v4l2_cap
= itv
->card
->v4l2_capabilities
;
698 itv
->card_name
= itv
->card
->name
;
699 itv
->card_i2c
= itv
->card
->i2c
;
702 /* Precondition: the ivtv structure has been memset to 0. Only
703 the dev and num fields have been filled in.
704 No assumptions on the card type may be made here (see ivtv_init_struct2
707 static int __devinit
ivtv_init_struct1(struct ivtv
*itv
)
709 struct sched_param param
= { .sched_priority
= 99 };
711 itv
->base_addr
= pci_resource_start(itv
->pdev
, 0);
712 itv
->enc_mbox
.max_mbox
= 2; /* the encoder has 3 mailboxes (0-2) */
713 itv
->dec_mbox
.max_mbox
= 1; /* the decoder has 2 mailboxes (0-1) */
715 mutex_init(&itv
->serialize_lock
);
716 mutex_init(&itv
->i2c_bus_lock
);
717 mutex_init(&itv
->udma
.lock
);
719 spin_lock_init(&itv
->lock
);
720 spin_lock_init(&itv
->dma_reg_lock
);
722 init_kthread_worker(&itv
->irq_worker
);
723 itv
->irq_worker_task
= kthread_run(kthread_worker_fn
, &itv
->irq_worker
,
725 if (IS_ERR(itv
->irq_worker_task
)) {
726 IVTV_ERR("Could not create ivtv task\n");
729 /* must use the FIFO scheduler as it is realtime sensitive */
730 sched_setscheduler(itv
->irq_worker_task
, SCHED_FIFO
, ¶m
);
732 init_kthread_work(&itv
->irq_work
, ivtv_irq_work_handler
);
734 /* start counting open_id at 1 */
737 /* Initial settings */
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
;
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
;
757 itv
->vbi
.in
.type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
758 itv
->vbi
.sliced_in
= &itv
->vbi
.in
.fmt
.sliced
;
760 /* Init the sg table for osd/yuv output */
761 sg_init_table(itv
->udma
.SGlist
, IVTV_DMA_SG_OSD_ENT
);
764 itv
->osd_global_alpha_state
= 1;
765 itv
->osd_global_alpha
= 255;
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;
776 /* Second initialization part. Here the card type has been
778 static void __devinit
ivtv_init_struct2(struct ivtv
*itv
)
782 for (i
= 0; i
< IVTV_CARD_MAX_VIDEO_INPUTS
; i
++)
783 if (itv
->card
->video_inputs
[i
].video_type
== 0)
786 for (i
= 0; i
< IVTV_CARD_MAX_AUDIO_INPUTS
; i
++)
787 if (itv
->card
->audio_inputs
[i
].audio_type
== 0)
789 itv
->nof_audio_inputs
= i
;
791 if (itv
->card
->hw_all
& IVTV_HW_CX25840
) {
792 itv
->vbi
.sliced_size
= 288; /* multiple of 16, real size = 284 */
794 itv
->vbi
.sliced_size
= 64; /* multiple of 16, real size = 52 */
797 /* Find tuner input */
798 for (i
= 0; i
< itv
->nof_inputs
; i
++) {
799 if (itv
->card
->video_inputs
[i
].video_type
==
800 IVTV_CARD_INPUT_VID_TUNER
)
803 if (i
== itv
->nof_inputs
)
805 itv
->active_input
= i
;
806 itv
->audio_input
= itv
->card
->video_inputs
[i
].audio_index
;
809 static int ivtv_setup_pci(struct ivtv
*itv
, struct pci_dev
*pdev
,
810 const struct pci_device_id
*pci_id
)
813 unsigned char pci_latency
;
815 IVTV_DEBUG_INFO("Enabling pci device\n");
817 if (pci_enable_device(pdev
)) {
818 IVTV_ERR("Can't enable device!\n");
821 if (pci_set_dma_mask(pdev
, 0xffffffff)) {
822 IVTV_ERR("No suitable DMA available.\n");
825 if (!request_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
, "ivtv encoder")) {
826 IVTV_ERR("Cannot request encoder memory region.\n");
830 if (!request_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
,
831 IVTV_REG_SIZE
, "ivtv registers")) {
832 IVTV_ERR("Cannot request register memory region.\n");
833 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
837 if (itv
->has_cx23415
&&
838 !request_mem_region(itv
->base_addr
+ IVTV_DECODER_OFFSET
,
839 IVTV_DECODER_SIZE
, "ivtv decoder")) {
840 IVTV_ERR("Cannot request decoder memory region.\n");
841 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
842 release_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
846 /* Check for bus mastering */
847 pci_read_config_word(pdev
, PCI_COMMAND
, &cmd
);
848 if (!(cmd
& PCI_COMMAND_MASTER
)) {
849 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
850 pci_set_master(pdev
);
851 pci_read_config_word(pdev
, PCI_COMMAND
, &cmd
);
852 if (!(cmd
& PCI_COMMAND_MASTER
)) {
853 IVTV_ERR("Bus Mastering is not enabled\n");
857 IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
859 pci_read_config_byte(pdev
, PCI_LATENCY_TIMER
, &pci_latency
);
861 if (pci_latency
< 64 && ivtv_pci_latency
) {
862 IVTV_INFO("Unreasonably low latency timer, "
863 "setting to 64 (was %d)\n", pci_latency
);
864 pci_write_config_byte(pdev
, PCI_LATENCY_TIMER
, 64);
865 pci_read_config_byte(pdev
, PCI_LATENCY_TIMER
, &pci_latency
);
867 /* This config space value relates to DMA latencies. The
868 default value 0x8080 is too low however and will lead
869 to DMA errors. 0xffff is the max value which solves
871 pci_write_config_dword(pdev
, 0x40, 0xffff);
873 IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
874 "irq: %d, latency: %d, memory: 0x%lx\n",
875 pdev
->device
, pdev
->revision
, pdev
->bus
->number
,
876 PCI_SLOT(pdev
->devfn
), PCI_FUNC(pdev
->devfn
),
877 pdev
->irq
, pci_latency
, (unsigned long)itv
->base_addr
);
882 static void ivtv_load_and_init_modules(struct ivtv
*itv
)
884 u32 hw
= itv
->card
->hw_all
;
887 /* check which i2c devices are actually found */
888 for (i
= 0; i
< 32; i
++) {
893 if (device
== IVTV_HW_GPIO
|| device
== IVTV_HW_TVEEPROM
) {
894 /* GPIO and TVEEPROM do not use i2c probing */
895 itv
->hw_flags
|= device
;
898 if (ivtv_i2c_register(itv
, i
) == 0)
899 itv
->hw_flags
|= device
;
902 /* probe for legacy IR controllers that aren't in card definitions */
903 if ((itv
->hw_flags
& IVTV_HW_IR_ANY
) == 0)
904 ivtv_i2c_new_ir_legacy(itv
);
906 if (itv
->card
->hw_all
& IVTV_HW_CX25840
)
907 itv
->sd_video
= ivtv_find_hw(itv
, IVTV_HW_CX25840
);
908 else if (itv
->card
->hw_all
& IVTV_HW_SAA717X
)
909 itv
->sd_video
= ivtv_find_hw(itv
, IVTV_HW_SAA717X
);
910 else if (itv
->card
->hw_all
& IVTV_HW_SAA7114
)
911 itv
->sd_video
= ivtv_find_hw(itv
, IVTV_HW_SAA7114
);
913 itv
->sd_video
= ivtv_find_hw(itv
, IVTV_HW_SAA7115
);
914 itv
->sd_audio
= ivtv_find_hw(itv
, itv
->card
->hw_audio_ctrl
);
915 itv
->sd_muxer
= ivtv_find_hw(itv
, itv
->card
->hw_muxer
);
919 if (itv
->card
->type
== IVTV_CARD_CX23416GYC
) {
920 /* Several variations of this card exist, detect which card
921 type should be used. */
922 if ((hw
& (IVTV_HW_UPD64031A
| IVTV_HW_UPD6408X
)) == 0)
923 itv
->card
= ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS
);
924 else if ((hw
& IVTV_HW_UPD64031A
) == 0)
925 itv
->card
= ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR
);
927 else if (itv
->card
->type
== IVTV_CARD_GV_MVPRX
||
928 itv
->card
->type
== IVTV_CARD_GV_MVPRX2E
) {
929 /* The crystal frequency of GVMVPRX is 24.576MHz */
930 v4l2_subdev_call(itv
->sd_video
, video
, s_crystal_freq
,
931 SAA7115_FREQ_24_576_MHZ
, SAA7115_FREQ_FL_UCGC
);
934 if (hw
& IVTV_HW_CX25840
) {
935 itv
->vbi
.raw_decoder_line_size
= 1444;
936 itv
->vbi
.raw_decoder_sav_odd_field
= 0x20;
937 itv
->vbi
.raw_decoder_sav_even_field
= 0x60;
938 itv
->vbi
.sliced_decoder_line_size
= 272;
939 itv
->vbi
.sliced_decoder_sav_odd_field
= 0xB0;
940 itv
->vbi
.sliced_decoder_sav_even_field
= 0xF0;
943 if (hw
& IVTV_HW_SAA711X
) {
944 struct v4l2_dbg_chip_ident v
;
946 /* determine the exact saa711x model */
947 itv
->hw_flags
&= ~IVTV_HW_SAA711X
;
949 v
.match
.type
= V4L2_CHIP_MATCH_I2C_DRIVER
;
950 strlcpy(v
.match
.name
, "saa7115", sizeof(v
.match
.name
));
951 ivtv_call_hw(itv
, IVTV_HW_SAA711X
, core
, g_chip_ident
, &v
);
952 if (v
.ident
== V4L2_IDENT_SAA7114
) {
953 itv
->hw_flags
|= IVTV_HW_SAA7114
;
954 /* VBI is not yet supported by the saa7114 driver. */
955 itv
->v4l2_cap
&= ~(V4L2_CAP_SLICED_VBI_CAPTURE
|V4L2_CAP_VBI_CAPTURE
);
957 itv
->hw_flags
|= IVTV_HW_SAA7115
;
959 itv
->vbi
.raw_decoder_line_size
= 1443;
960 itv
->vbi
.raw_decoder_sav_odd_field
= 0x25;
961 itv
->vbi
.raw_decoder_sav_even_field
= 0x62;
962 itv
->vbi
.sliced_decoder_line_size
= 51;
963 itv
->vbi
.sliced_decoder_sav_odd_field
= 0xAB;
964 itv
->vbi
.sliced_decoder_sav_even_field
= 0xEC;
967 if (hw
& IVTV_HW_SAA717X
) {
968 itv
->vbi
.raw_decoder_line_size
= 1443;
969 itv
->vbi
.raw_decoder_sav_odd_field
= 0x25;
970 itv
->vbi
.raw_decoder_sav_even_field
= 0x62;
971 itv
->vbi
.sliced_decoder_line_size
= 51;
972 itv
->vbi
.sliced_decoder_sav_odd_field
= 0xAB;
973 itv
->vbi
.sliced_decoder_sav_even_field
= 0xEC;
977 static int __devinit
ivtv_probe(struct pci_dev
*pdev
,
978 const struct pci_device_id
*pci_id
)
984 itv
= kzalloc(sizeof(struct ivtv
), GFP_ATOMIC
);
988 itv
->instance
= v4l2_device_set_name(&itv
->v4l2_dev
, "ivtv",
991 retval
= v4l2_device_register(&pdev
->dev
, &itv
->v4l2_dev
);
996 IVTV_INFO("Initializing card %d\n", itv
->instance
);
998 ivtv_process_options(itv
);
999 if (itv
->options
.cardtype
== -1) {
1003 if (ivtv_init_struct1(itv
)) {
1007 retval
= cx2341x_handler_init(&itv
->cxhdl
, 50);
1010 itv
->v4l2_dev
.ctrl_handler
= &itv
->cxhdl
.hdl
;
1011 itv
->cxhdl
.ops
= &ivtv_cxhdl_ops
;
1012 itv
->cxhdl
.priv
= itv
;
1013 itv
->cxhdl
.func
= ivtv_api_func
;
1015 IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv
->base_addr
);
1017 /* PCI Device Setup */
1018 retval
= ivtv_setup_pci(itv
, pdev
, pci_id
);
1021 if (retval
== -ENXIO
)
1025 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1026 itv
->base_addr
+ IVTV_ENCODER_OFFSET
, IVTV_ENCODER_SIZE
);
1027 itv
->enc_mem
= ioremap_nocache(itv
->base_addr
+ IVTV_ENCODER_OFFSET
,
1029 if (!itv
->enc_mem
) {
1030 IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1031 "encoder memory\n");
1032 IVTV_ERR("Each capture card with a CX23415/6 needs 8 MB of "
1033 "vmalloc address space for this window\n");
1034 IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1035 IVTV_ERR("Use the vmalloc= kernel command line option to set "
1036 "VmallocTotal to a larger value\n");
1041 if (itv
->has_cx23415
) {
1042 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1043 itv
->base_addr
+ IVTV_DECODER_OFFSET
, IVTV_DECODER_SIZE
);
1044 itv
->dec_mem
= ioremap_nocache(itv
->base_addr
+ IVTV_DECODER_OFFSET
,
1046 if (!itv
->dec_mem
) {
1047 IVTV_ERR("ioremap failed. Can't get a window into "
1048 "CX23415 decoder memory\n");
1049 IVTV_ERR("Each capture card with a CX23415 needs 8 MB "
1050 "of vmalloc address space for this window\n");
1051 IVTV_ERR("Check the output of 'grep Vmalloc "
1052 "/proc/meminfo'\n");
1053 IVTV_ERR("Use the vmalloc= kernel command line option "
1054 "to set VmallocTotal to a larger value\n");
1060 itv
->dec_mem
= itv
->enc_mem
;
1063 /* map registers memory */
1064 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1065 itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1067 ioremap_nocache(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1068 if (!itv
->reg_mem
) {
1069 IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1070 "register space\n");
1071 IVTV_ERR("Each capture card with a CX23415/6 needs 64 kB of "
1072 "vmalloc address space for this window\n");
1073 IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1074 IVTV_ERR("Use the vmalloc= kernel command line option to set "
1075 "VmallocTotal to a larger value\n");
1080 retval
= ivtv_gpio_init(itv
);
1085 IVTV_DEBUG_INFO("activating i2c...\n");
1086 if (init_ivtv_i2c(itv
)) {
1087 IVTV_ERR("Could not initialize i2c\n");
1091 if (itv
->card
->hw_all
& IVTV_HW_TVEEPROM
) {
1092 /* Based on the model number the cardtype may be changed.
1093 The PCI IDs are not always reliable. */
1094 ivtv_process_eeprom(itv
);
1096 if (itv
->card
->comment
)
1097 IVTV_INFO("%s", itv
->card
->comment
);
1098 if (itv
->card
->v4l2_capabilities
== 0) {
1099 /* card was detected but is not supported */
1104 if (itv
->std
== 0) {
1105 itv
->std
= V4L2_STD_NTSC_M
;
1108 if (itv
->options
.tuner
== -1) {
1111 for (i
= 0; i
< IVTV_CARD_MAX_TUNERS
; i
++) {
1112 if ((itv
->std
& itv
->card
->tuners
[i
].std
) == 0)
1114 itv
->options
.tuner
= itv
->card
->tuners
[i
].tuner
;
1118 /* if no tuner was found, then pick the first tuner in the card list */
1119 if (itv
->options
.tuner
== -1 && itv
->card
->tuners
[0].std
) {
1120 itv
->std
= itv
->card
->tuners
[0].std
;
1121 if (itv
->std
& V4L2_STD_PAL
)
1122 itv
->std
= V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
1123 else if (itv
->std
& V4L2_STD_NTSC
)
1124 itv
->std
= V4L2_STD_NTSC_M
;
1125 else if (itv
->std
& V4L2_STD_SECAM
)
1126 itv
->std
= V4L2_STD_SECAM_L
;
1127 itv
->options
.tuner
= itv
->card
->tuners
[0].tuner
;
1129 if (itv
->options
.radio
== -1)
1130 itv
->options
.radio
= (itv
->card
->radio_input
.audio_type
!= 0);
1132 /* The card is now fully identified, continue with card-specific
1134 ivtv_init_struct2(itv
);
1136 ivtv_load_and_init_modules(itv
);
1138 if (itv
->std
& V4L2_STD_525_60
) {
1140 itv
->is_out_60hz
= 1;
1143 itv
->is_out_50hz
= 1;
1146 itv
->yuv_info
.osd_full_w
= 720;
1147 itv
->yuv_info
.osd_full_h
= itv
->is_out_50hz
? 576 : 480;
1148 itv
->yuv_info
.v4l2_src_w
= itv
->yuv_info
.osd_full_w
;
1149 itv
->yuv_info
.v4l2_src_h
= itv
->yuv_info
.osd_full_h
;
1151 cx2341x_handler_set_50hz(&itv
->cxhdl
, itv
->is_50hz
);
1153 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_MPG
] = 0x08000;
1154 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_PCM
] = 0x01200;
1155 itv
->stream_buf_size
[IVTV_DEC_STREAM_TYPE_MPG
] = 0x10000;
1156 itv
->stream_buf_size
[IVTV_DEC_STREAM_TYPE_YUV
] = 0x10000;
1157 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_YUV
] = 0x08000;
1159 /* Setup VBI Raw Size. Should be big enough to hold PAL.
1160 It is possible to switch between PAL and NTSC, so we need to
1161 take the largest size here. */
1162 /* 1456 is multiple of 16, real size = 1444 */
1163 itv
->vbi
.raw_size
= 1456;
1164 /* We use a buffer size of 1/2 of the total size needed for a
1165 frame. This is actually very useful, since we now receive
1166 a field at a time and that makes 'compressing' the raw data
1167 down to size by stripping off the SAV codes a lot easier.
1168 Note: having two different buffer sizes prevents standard
1169 switching on the fly. We need to find a better solution... */
1170 vbi_buf_size
= itv
->vbi
.raw_size
* (itv
->is_60hz
? 24 : 36) / 2;
1171 itv
->stream_buf_size
[IVTV_ENC_STREAM_TYPE_VBI
] = vbi_buf_size
;
1172 itv
->stream_buf_size
[IVTV_DEC_STREAM_TYPE_VBI
] = sizeof(struct v4l2_sliced_vbi_data
) * 36;
1174 if (itv
->options
.radio
> 0)
1175 itv
->v4l2_cap
|= V4L2_CAP_RADIO
;
1177 if (itv
->options
.tuner
> -1) {
1178 struct tuner_setup setup
;
1180 setup
.addr
= ADDR_UNSET
;
1181 setup
.type
= itv
->options
.tuner
;
1182 setup
.mode_mask
= T_ANALOG_TV
; /* matches TV tuners */
1183 setup
.tuner_callback
= (setup
.type
== TUNER_XC2028
) ?
1184 ivtv_reset_tuner_gpio
: NULL
;
1185 ivtv_call_all(itv
, tuner
, s_type_addr
, &setup
);
1186 if (setup
.type
== TUNER_XC2028
) {
1187 static struct xc2028_ctrl ctrl
= {
1188 .fname
= XC2028_DEFAULT_FIRMWARE
,
1191 struct v4l2_priv_tun_config cfg
= {
1192 .tuner
= itv
->options
.tuner
,
1195 ivtv_call_all(itv
, tuner
, s_config
, &cfg
);
1199 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1201 itv
->tuner_std
= itv
->std
;
1203 if (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
) {
1204 ivtv_call_all(itv
, video
, s_std_output
, itv
->std
);
1205 /* Turn off the output signal. The mpeg decoder is not yet
1206 active so without this you would get a green image until the
1207 mpeg decoder becomes active. */
1208 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, video
, s_stream
, 0);
1211 /* clear interrupt mask, effectively disabling interrupts */
1212 ivtv_set_irq_mask(itv
, 0xffffffff);
1215 retval
= request_irq(itv
->pdev
->irq
, ivtv_irq_handler
,
1216 IRQF_SHARED
| IRQF_DISABLED
, itv
->v4l2_dev
.name
, (void *)itv
);
1218 IVTV_ERR("Failed to register irq %d\n", retval
);
1222 retval
= ivtv_streams_setup(itv
);
1224 IVTV_ERR("Error %d setting up streams\n", retval
);
1227 retval
= ivtv_streams_register(itv
);
1229 IVTV_ERR("Error %d registering devices\n", retval
);
1232 IVTV_INFO("Initialized card: %s\n", itv
->card_name
);
1236 ivtv_streams_cleanup(itv
, 1);
1238 free_irq(itv
->pdev
->irq
, (void *)itv
);
1244 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
1245 release_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1246 if (itv
->has_cx23415
)
1247 release_mem_region(itv
->base_addr
+ IVTV_DECODER_OFFSET
, IVTV_DECODER_SIZE
);
1249 kthread_stop(itv
->irq_worker_task
);
1253 IVTV_ERR("Error %d on initialization\n", retval
);
1255 v4l2_device_unregister(&itv
->v4l2_dev
);
1260 int ivtv_init_on_first_open(struct ivtv
*itv
)
1262 struct v4l2_frequency vf
;
1263 /* Needed to call ioctls later */
1264 struct ivtv_open_id fh
;
1265 int fw_retry_count
= 3;
1270 if (test_bit(IVTV_F_I_FAILED
, &itv
->i_flags
))
1273 if (test_and_set_bit(IVTV_F_I_INITED
, &itv
->i_flags
))
1276 while (--fw_retry_count
> 0) {
1278 if (ivtv_firmware_init(itv
) == 0)
1280 if (fw_retry_count
> 1)
1281 IVTV_WARN("Retry loading firmware\n");
1284 if (fw_retry_count
== 0) {
1285 set_bit(IVTV_F_I_FAILED
, &itv
->i_flags
);
1289 /* Try and get firmware versions */
1290 IVTV_DEBUG_INFO("Getting firmware version..\n");
1291 ivtv_firmware_versions(itv
);
1293 if (itv
->card
->hw_all
& IVTV_HW_CX25840
)
1294 v4l2_subdev_call(itv
->sd_video
, core
, load_fw
);
1297 vf
.type
= V4L2_TUNER_ANALOG_TV
;
1298 vf
.frequency
= 6400; /* the tuner 'baseline' frequency */
1300 /* Set initial frequency. For PAL/SECAM broadcasts no
1301 'default' channel exists AFAIK. */
1302 if (itv
->std
== V4L2_STD_NTSC_M_JP
) {
1303 vf
.frequency
= 1460; /* ch. 1 91250*16/1000 */
1305 else if (itv
->std
& V4L2_STD_NTSC_M
) {
1306 vf
.frequency
= 1076; /* ch. 4 67250*16/1000 */
1309 video_input
= itv
->active_input
;
1310 itv
->active_input
++; /* Force update of input */
1311 ivtv_s_input(NULL
, &fh
, video_input
);
1313 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1315 itv
->std
++; /* Force full standard initialization */
1316 itv
->std_out
= itv
->std
;
1317 ivtv_s_frequency(NULL
, &fh
, &vf
);
1319 if (itv
->card
->v4l2_capabilities
& V4L2_CAP_VIDEO_OUTPUT
) {
1320 /* Turn on the TV-out: ivtv_init_mpeg_decoder() initializes
1321 the mpeg decoder so now the saa7127 receives a proper
1323 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, video
, s_stream
, 1);
1324 ivtv_init_mpeg_decoder(itv
);
1327 /* On a cx23416 this seems to be able to enable DMA to the chip? */
1328 if (!itv
->has_cx23415
)
1329 write_reg_sync(0x03, IVTV_REG_DMACONTROL
);
1331 ivtv_s_std_enc(itv
, &itv
->tuner_std
);
1333 /* Default interrupts enabled. For the PVR350 this includes the
1334 decoder VSYNC interrupt, which is always on. It is not only used
1335 during decoding but also by the OSD.
1336 Some old PVR250 cards had a cx23415, so testing for that is too
1337 general. Instead test if the card has video output capability. */
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 ivtv_s_std_dec(itv
, &itv
->tuner_std
);
1343 ivtv_clear_irq_mask(itv
, IVTV_IRQ_MASK_INIT
);
1346 /* Setup initial controls */
1347 cx2341x_handler_setup(&itv
->cxhdl
);
1351 static void ivtv_remove(struct pci_dev
*pdev
)
1353 struct v4l2_device
*v4l2_dev
= dev_get_drvdata(&pdev
->dev
);
1354 struct ivtv
*itv
= to_ivtv(v4l2_dev
);
1357 IVTV_DEBUG_INFO("Removing card\n");
1359 if (test_bit(IVTV_F_I_INITED
, &itv
->i_flags
)) {
1360 /* Stop all captures */
1361 IVTV_DEBUG_INFO("Stopping all streams\n");
1362 if (atomic_read(&itv
->capturing
) > 0)
1363 ivtv_stop_all_captures(itv
);
1365 /* Stop all decoding */
1366 IVTV_DEBUG_INFO("Stopping decoding\n");
1368 /* Turn off the TV-out */
1369 if (itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
)
1370 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, video
, s_stream
, 0);
1371 if (atomic_read(&itv
->decoding
) > 0) {
1374 if (test_bit(IVTV_F_I_DEC_YUV
, &itv
->i_flags
))
1375 type
= IVTV_DEC_STREAM_TYPE_YUV
;
1377 type
= IVTV_DEC_STREAM_TYPE_MPG
;
1378 ivtv_stop_v4l2_decode_stream(&itv
->streams
[type
],
1379 VIDEO_CMD_STOP_TO_BLACK
| VIDEO_CMD_STOP_IMMEDIATELY
, 0);
1381 ivtv_halt_firmware(itv
);
1385 ivtv_set_irq_mask(itv
, 0xffffffff);
1386 del_timer_sync(&itv
->dma_timer
);
1388 /* Kill irq worker */
1389 flush_kthread_worker(&itv
->irq_worker
);
1390 kthread_stop(itv
->irq_worker_task
);
1392 ivtv_streams_cleanup(itv
, 1);
1393 ivtv_udma_free(itv
);
1397 free_irq(itv
->pdev
->irq
, (void *)itv
);
1400 release_mem_region(itv
->base_addr
, IVTV_ENCODER_SIZE
);
1401 release_mem_region(itv
->base_addr
+ IVTV_REG_OFFSET
, IVTV_REG_SIZE
);
1402 if (itv
->has_cx23415
)
1403 release_mem_region(itv
->base_addr
+ IVTV_DECODER_OFFSET
, IVTV_DECODER_SIZE
);
1405 pci_disable_device(itv
->pdev
);
1406 for (i
= 0; i
< IVTV_VBI_FRAMES
; i
++)
1407 kfree(itv
->vbi
.sliced_mpeg_data
[i
]);
1409 printk(KERN_INFO
"ivtv: Removed %s\n", itv
->card_name
);
1411 v4l2_device_unregister(&itv
->v4l2_dev
);
1415 /* define a pci_driver for card detection */
1416 static struct pci_driver ivtv_pci_driver
= {
1418 .id_table
= ivtv_pci_tbl
,
1419 .probe
= ivtv_probe
,
1420 .remove
= ivtv_remove
,
1423 static int __init
module_start(void)
1425 printk(KERN_INFO
"ivtv: Start initialization, version %s\n", IVTV_VERSION
);
1427 /* Validate parameters */
1428 if (ivtv_first_minor
< 0 || ivtv_first_minor
>= IVTV_MAX_CARDS
) {
1429 printk(KERN_ERR
"ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1430 IVTV_MAX_CARDS
- 1);
1434 if (ivtv_debug
< 0 || ivtv_debug
> 2047) {
1436 printk(KERN_INFO
"ivtv: Debug value must be >= 0 and <= 2047\n");
1439 if (pci_register_driver(&ivtv_pci_driver
)) {
1440 printk(KERN_ERR
"ivtv: Error detecting PCI card\n");
1443 printk(KERN_INFO
"ivtv: End initialization\n");
1447 static void __exit
module_cleanup(void)
1449 pci_unregister_driver(&ivtv_pci_driver
);
1452 /* Note: These symbols are exported because they are used by the ivtvfb
1453 framebuffer module and an infrared module for the IR-blaster. */
1454 EXPORT_SYMBOL(ivtv_set_irq_mask
);
1455 EXPORT_SYMBOL(ivtv_api
);
1456 EXPORT_SYMBOL(ivtv_vapi
);
1457 EXPORT_SYMBOL(ivtv_vapi_result
);
1458 EXPORT_SYMBOL(ivtv_clear_irq_mask
);
1459 EXPORT_SYMBOL(ivtv_debug
);
1460 #ifdef CONFIG_VIDEO_ADV_DEBUG
1461 EXPORT_SYMBOL(ivtv_fw_debug
);
1463 EXPORT_SYMBOL(ivtv_reset_ir_gpio
);
1464 EXPORT_SYMBOL(ivtv_udma_setup
);
1465 EXPORT_SYMBOL(ivtv_udma_unmap
);
1466 EXPORT_SYMBOL(ivtv_udma_alloc
);
1467 EXPORT_SYMBOL(ivtv_udma_prepare
);
1468 EXPORT_SYMBOL(ivtv_init_on_first_open
);
1469 EXPORT_SYMBOL(ivtv_firmware_check
);
1471 module_init(module_start
);
1472 module_exit(module_cleanup
);