projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'x86/urgent' into x86/setup
[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!");
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 = atomic_inc_return(&ivtv_instance) - 1;
950
951 retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
952 if (retval) {
953 kfree(itv);
954 return retval;
955 }
956 /* "ivtv + PCI ID" is a bit of a mouthful, so use
957 "ivtv + instance" instead. */
958 snprintf(itv->v4l2_dev.name, sizeof(itv->v4l2_dev.name),
959 "ivtv%d", itv->instance);
960 IVTV_INFO("Initializing card %d\n", itv->instance);
961
962 ivtv_process_options(itv);
963 if (itv->options.cardtype == -1) {
964 retval = -ENODEV;
965 goto err;
966 }
967 if (ivtv_init_struct1(itv)) {
968 retval = -ENOMEM;
969 goto err;
970 }
971
972 IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
973
974 /* PCI Device Setup */
975 retval = ivtv_setup_pci(itv, pdev, pci_id);
976 if (retval == -EIO)
977 goto free_workqueue;
978 if (retval == -ENXIO)
979 goto free_mem;
980
981 /* map io memory */
982 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
983 itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
984 itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
985 IVTV_ENCODER_SIZE);
986 if (!itv->enc_mem) {
987 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
988 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
989 retval = -ENOMEM;
990 goto free_mem;
991 }
992
993 if (itv->has_cx23415) {
994 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
995 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
996 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
997 IVTV_DECODER_SIZE);
998 if (!itv->dec_mem) {
999 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1000 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1001 retval = -ENOMEM;
1002 goto free_mem;
1003 }
1004 }
1005 else {
1006 itv->dec_mem = itv->enc_mem;
1007 }
1008
1009 /* map registers memory */
1010 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1011 itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1012 itv->reg_mem =
1013 ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1014 if (!itv->reg_mem) {
1015 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1016 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1017 retval = -ENOMEM;
1018 goto free_io;
1019 }
1020
1021 retval = ivtv_gpio_init(itv);
1022 if (retval)
1023 goto free_io;
1024
1025 /* active i2c */
1026 IVTV_DEBUG_INFO("activating i2c...\n");
1027 if (init_ivtv_i2c(itv)) {
1028 IVTV_ERR("Could not initialize i2c\n");
1029 goto free_io;
1030 }
1031
1032 if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1033 /* Based on the model number the cardtype may be changed.
1034 The PCI IDs are not always reliable. */
1035 ivtv_process_eeprom(itv);
1036 }
1037 if (itv->card->comment)
1038 IVTV_INFO("%s", itv->card->comment);
1039 if (itv->card->v4l2_capabilities == 0) {
1040 /* card was detected but is not supported */
1041 retval = -ENODEV;
1042 goto free_i2c;
1043 }
1044
1045 if (itv->std == 0) {
1046 itv->std = V4L2_STD_NTSC_M;
1047 }
1048
1049 if (itv->options.tuner == -1) {
1050 int i;
1051
1052 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1053 if ((itv->std & itv->card->tuners[i].std) == 0)
1054 continue;
1055 itv->options.tuner = itv->card->tuners[i].tuner;
1056 break;
1057 }
1058 }
1059 /* if no tuner was found, then pick the first tuner in the card list */
1060 if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1061 itv->std = itv->card->tuners[0].std;
1062 if (itv->std & V4L2_STD_PAL)
1063 itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1064 else if (itv->std & V4L2_STD_NTSC)
1065 itv->std = V4L2_STD_NTSC_M;
1066 else if (itv->std & V4L2_STD_SECAM)
1067 itv->std = V4L2_STD_SECAM_L;
1068 itv->options.tuner = itv->card->tuners[0].tuner;
1069 }
1070 if (itv->options.radio == -1)
1071 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1072
1073 /* The card is now fully identified, continue with card-specific
1074 initialization. */
1075 ivtv_init_struct2(itv);
1076
1077 ivtv_load_and_init_modules(itv);
1078
1079 if (itv->std & V4L2_STD_525_60) {
1080 itv->is_60hz = 1;
1081 itv->is_out_60hz = 1;
1082 } else {
1083 itv->is_50hz = 1;
1084 itv->is_out_50hz = 1;
1085 }
1086
1087 itv->yuv_info.osd_full_w = 720;
1088 itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1089 itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1090 itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1091
1092 itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1093
1094 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1095 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1096 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1097 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1098 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1099
1100 /* Setup VBI Raw Size. Should be big enough to hold PAL.
1101 It is possible to switch between PAL and NTSC, so we need to
1102 take the largest size here. */
1103 /* 1456 is multiple of 16, real size = 1444 */
1104 itv->vbi.raw_size = 1456;
1105 /* We use a buffer size of 1/2 of the total size needed for a
1106 frame. This is actually very useful, since we now receive
1107 a field at a time and that makes 'compressing' the raw data
1108 down to size by stripping off the SAV codes a lot easier.
1109 Note: having two different buffer sizes prevents standard
1110 switching on the fly. We need to find a better solution... */
1111 vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1112 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1113 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1114
1115 if (itv->options.radio > 0)
1116 itv->v4l2_cap |= V4L2_CAP_RADIO;
1117
1118 if (itv->options.tuner > -1) {
1119 struct tuner_setup setup;
1120
1121 setup.addr = ADDR_UNSET;
1122 setup.type = itv->options.tuner;
1123 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1124 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1125 ivtv_reset_tuner_gpio : NULL;
1126 ivtv_call_all(itv, tuner, s_type_addr, &setup);
1127 if (setup.type == TUNER_XC2028) {
1128 static struct xc2028_ctrl ctrl = {
1129 .fname = XC2028_DEFAULT_FIRMWARE,
1130 .max_len = 64,
1131 };
1132 struct v4l2_priv_tun_config cfg = {
1133 .tuner = itv->options.tuner,
1134 .priv = &ctrl,
1135 };
1136 ivtv_call_all(itv, tuner, s_config, &cfg);
1137 }
1138 }
1139
1140 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1141 are not. */
1142 itv->tuner_std = itv->std;
1143
1144 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1145 ivtv_call_all(itv, video, s_std_output, itv->std);
1146 /* Turn off the output signal. The mpeg decoder is not yet
1147 active so without this you would get a green image until the
1148 mpeg decoder becomes active. */
1149 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1150 }
1151
1152 /* clear interrupt mask, effectively disabling interrupts */
1153 ivtv_set_irq_mask(itv, 0xffffffff);
1154
1155 /* Register IRQ */
1156 retval = request_irq(itv->pdev->irq, ivtv_irq_handler,
1157 IRQF_SHARED | IRQF_DISABLED, itv->v4l2_dev.name, (void *)itv);
1158 if (retval) {
1159 IVTV_ERR("Failed to register irq %d\n", retval);
1160 goto free_i2c;
1161 }
1162
1163 retval = ivtv_streams_setup(itv);
1164 if (retval) {
1165 IVTV_ERR("Error %d setting up streams\n", retval);
1166 goto free_irq;
1167 }
1168 retval = ivtv_streams_register(itv);
1169 if (retval) {
1170 IVTV_ERR("Error %d registering devices\n", retval);
1171 goto free_streams;
1172 }
1173 IVTV_INFO("Initialized card: %s\n", itv->card_name);
1174 return 0;
1175
1176 free_streams:
1177 ivtv_streams_cleanup(itv, 1);
1178 free_irq:
1179 free_irq(itv->pdev->irq, (void *)itv);
1180 free_i2c:
1181 exit_ivtv_i2c(itv);
1182 free_io:
1183 ivtv_iounmap(itv);
1184 free_mem:
1185 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1186 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1187 if (itv->has_cx23415)
1188 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1189 free_workqueue:
1190 destroy_workqueue(itv->irq_work_queues);
1191 err:
1192 if (retval == 0)
1193 retval = -ENODEV;
1194 IVTV_ERR("Error %d on initialization\n", retval);
1195
1196 v4l2_device_unregister(&itv->v4l2_dev);
1197 kfree(itv);
1198 return retval;
1199 }
1200
1201 int ivtv_init_on_first_open(struct ivtv *itv)
1202 {
1203 struct v4l2_frequency vf;
1204 /* Needed to call ioctls later */
1205 struct ivtv_open_id fh;
1206 int fw_retry_count = 3;
1207 int video_input;
1208
1209 fh.itv = itv;
1210
1211 if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1212 return -ENXIO;
1213
1214 if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1215 return 0;
1216
1217 while (--fw_retry_count > 0) {
1218 /* load firmware */
1219 if (ivtv_firmware_init(itv) == 0)
1220 break;
1221 if (fw_retry_count > 1)
1222 IVTV_WARN("Retry loading firmware\n");
1223 }
1224
1225 if (fw_retry_count == 0) {
1226 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1227 return -ENXIO;
1228 }
1229
1230 /* Try and get firmware versions */
1231 IVTV_DEBUG_INFO("Getting firmware version..\n");
1232 ivtv_firmware_versions(itv);
1233
1234 if (itv->card->hw_all & IVTV_HW_CX25840) {
1235 struct v4l2_control ctrl;
1236
1237 v4l2_subdev_call(itv->sd_video, core, load_fw);
1238 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1239 ctrl.id = V4L2_CID_PRIVATE_BASE;
1240 ctrl.value = itv->pvr150_workaround;
1241 v4l2_subdev_call(itv->sd_video, core, s_ctrl, &ctrl);
1242 }
1243
1244 vf.tuner = 0;
1245 vf.type = V4L2_TUNER_ANALOG_TV;
1246 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1247
1248 /* Set initial frequency. For PAL/SECAM broadcasts no
1249 'default' channel exists AFAIK. */
1250 if (itv->std == V4L2_STD_NTSC_M_JP) {
1251 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1252 }
1253 else if (itv->std & V4L2_STD_NTSC_M) {
1254 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1255 }
1256
1257 video_input = itv->active_input;
1258 itv->active_input++; /* Force update of input */
1259 ivtv_s_input(NULL, &fh, video_input);
1260
1261 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1262 in one place. */
1263 itv->std++; /* Force full standard initialization */
1264 itv->std_out = itv->std;
1265 ivtv_s_frequency(NULL, &fh, &vf);
1266
1267 if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1268 /* Turn on the TV-out: ivtv_init_mpeg_decoder() initializes
1269 the mpeg decoder so now the saa7127 receives a proper
1270 signal. */
1271 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
1272 ivtv_init_mpeg_decoder(itv);
1273 }
1274 ivtv_s_std(NULL, &fh, &itv->tuner_std);
1275
1276 /* On a cx23416 this seems to be able to enable DMA to the chip? */
1277 if (!itv->has_cx23415)
1278 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1279
1280 /* Default interrupts enabled. For the PVR350 this includes the
1281 decoder VSYNC interrupt, which is always on. It is not only used
1282 during decoding but also by the OSD.
1283 Some old PVR250 cards had a cx23415, so testing for that is too
1284 general. Instead test if the card has video output capability. */
1285 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1286 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1287 ivtv_set_osd_alpha(itv);
1288 }
1289 else
1290 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1291 return 0;
1292 }
1293
1294 static void ivtv_remove(struct pci_dev *pdev)
1295 {
1296 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1297 struct ivtv *itv = to_ivtv(v4l2_dev);
1298 int i;
1299
1300 IVTV_DEBUG_INFO("Removing card\n");
1301
1302 if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1303 /* Stop all captures */
1304 IVTV_DEBUG_INFO("Stopping all streams\n");
1305 if (atomic_read(&itv->capturing) > 0)
1306 ivtv_stop_all_captures(itv);
1307
1308 /* Stop all decoding */
1309 IVTV_DEBUG_INFO("Stopping decoding\n");
1310
1311 /* Turn off the TV-out */
1312 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1313 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1314 if (atomic_read(&itv->decoding) > 0) {
1315 int type;
1316
1317 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1318 type = IVTV_DEC_STREAM_TYPE_YUV;
1319 else
1320 type = IVTV_DEC_STREAM_TYPE_MPG;
1321 ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1322 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1323 }
1324 ivtv_halt_firmware(itv);
1325 }
1326
1327 /* Interrupts */
1328 ivtv_set_irq_mask(itv, 0xffffffff);
1329 del_timer_sync(&itv->dma_timer);
1330
1331 /* Stop all Work Queues */
1332 flush_workqueue(itv->irq_work_queues);
1333 destroy_workqueue(itv->irq_work_queues);
1334
1335 ivtv_streams_cleanup(itv, 1);
1336 ivtv_udma_free(itv);
1337
1338 exit_ivtv_i2c(itv);
1339
1340 free_irq(itv->pdev->irq, (void *)itv);
1341 ivtv_iounmap(itv);
1342
1343 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1344 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1345 if (itv->has_cx23415)
1346 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1347
1348 pci_disable_device(itv->pdev);
1349 for (i = 0; i < IVTV_VBI_FRAMES; i++)
1350 kfree(itv->vbi.sliced_mpeg_data[i]);
1351
1352 printk(KERN_INFO "ivtv: Removed %s\n", itv->card_name);
1353
1354 v4l2_device_unregister(&itv->v4l2_dev);
1355 kfree(itv);
1356 }
1357
1358 /* define a pci_driver for card detection */
1359 static struct pci_driver ivtv_pci_driver = {
1360 .name = "ivtv",
1361 .id_table = ivtv_pci_tbl,
1362 .probe = ivtv_probe,
1363 .remove = ivtv_remove,
1364 };
1365
1366 static int module_start(void)
1367 {
1368 printk(KERN_INFO "ivtv: Start initialization, version %s\n", IVTV_VERSION);
1369
1370 /* Validate parameters */
1371 if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1372 printk(KERN_ERR "ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1373 IVTV_MAX_CARDS - 1);
1374 return -1;
1375 }
1376
1377 if (ivtv_debug < 0 || ivtv_debug > 2047) {
1378 ivtv_debug = 0;
1379 printk(KERN_INFO "ivtv: Debug value must be >= 0 and <= 2047\n");
1380 }
1381
1382 if (pci_register_driver(&ivtv_pci_driver)) {
1383 printk(KERN_ERR "ivtv: Error detecting PCI card\n");
1384 return -ENODEV;
1385 }
1386 printk(KERN_INFO "ivtv: End initialization\n");
1387 return 0;
1388 }
1389
1390 static void module_cleanup(void)
1391 {
1392 pci_unregister_driver(&ivtv_pci_driver);
1393 }
1394
1395 /* Note: These symbols are exported because they are used by the ivtvfb
1396 framebuffer module and an infrared module for the IR-blaster. */
1397 EXPORT_SYMBOL(ivtv_set_irq_mask);
1398 EXPORT_SYMBOL(ivtv_api);
1399 EXPORT_SYMBOL(ivtv_vapi);
1400 EXPORT_SYMBOL(ivtv_vapi_result);
1401 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1402 EXPORT_SYMBOL(ivtv_debug);
1403 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1404 EXPORT_SYMBOL(ivtv_udma_setup);
1405 EXPORT_SYMBOL(ivtv_udma_unmap);
1406 EXPORT_SYMBOL(ivtv_udma_alloc);
1407 EXPORT_SYMBOL(ivtv_udma_prepare);
1408 EXPORT_SYMBOL(ivtv_init_on_first_open);
1409
1410 module_init(module_start);
1411 module_exit(module_cleanup);
Linux kernel - Deliverables
This page took 0.073295 seconds and 6 git commands to generate.