projects / deliverable / linux.git / blob
? search:


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