projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-2.6
[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 ret;
309 int timeout = msecs_to_jiffies(msecs);
310
311 do {
312 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
313 timeout = schedule_timeout(timeout);
314 if (intr && (ret = signal_pending(current)))
315 return ret;
316 } while (timeout);
317 return 0;
318 }
319
320 /* Release ioremapped memory */
321 static void ivtv_iounmap(struct ivtv *itv)
322 {
323 if (itv == NULL)
324 return;
325
326 /* Release registers memory */
327 if (itv->reg_mem != NULL) {
328 IVTV_DEBUG_INFO("releasing reg_mem\n");
329 iounmap(itv->reg_mem);
330 itv->reg_mem = NULL;
331 }
332 /* Release io memory */
333 if (itv->has_cx23415 && itv->dec_mem != NULL) {
334 IVTV_DEBUG_INFO("releasing dec_mem\n");
335 iounmap(itv->dec_mem);
336 }
337 itv->dec_mem = NULL;
338
339 /* Release io memory */
340 if (itv->enc_mem != NULL) {
341 IVTV_DEBUG_INFO("releasing enc_mem\n");
342 iounmap(itv->enc_mem);
343 itv->enc_mem = NULL;
344 }
345 }
346
347 /* Hauppauge card? get values from tveeprom */
348 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
349 {
350 u8 eedata[256];
351
352 itv->i2c_client.addr = 0xA0 >> 1;
353 tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
354 tveeprom_hauppauge_analog(&itv->i2c_client, tv, eedata);
355 }
356
357 static void ivtv_process_eeprom(struct ivtv *itv)
358 {
359 struct tveeprom tv;
360 int pci_slot = PCI_SLOT(itv->pdev->devfn);
361
362 ivtv_read_eeprom(itv, &tv);
363
364 /* Many thanks to Steven Toth from Hauppauge for providing the
365 model numbers */
366 switch (tv.model) {
367 /* In a few cases the PCI subsystem IDs do not correctly
368 identify the card. A better method is to check the
369 model number from the eeprom instead. */
370 case 30012 ... 30039: /* Low profile PVR250 */
371 case 32000 ... 32999:
372 case 48000 ... 48099: /* 48??? range are PVR250s with a cx23415 */
373 case 48400 ... 48599:
374 itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
375 break;
376 case 48100 ... 48399:
377 case 48600 ... 48999:
378 itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
379 break;
380 case 23000 ... 23999: /* PVR500 */
381 case 25000 ... 25999: /* Low profile PVR150 */
382 case 26000 ... 26999: /* Regular PVR150 */
383 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
384 break;
385 case 0:
386 IVTV_ERR("Invalid EEPROM\n");
387 return;
388 default:
389 IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
390 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
391 break;
392 }
393
394 switch (tv.model) {
395 /* Old style PVR350 (with an saa7114) uses this input for
396 the tuner. */
397 case 48254:
398 itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
399 break;
400 default:
401 break;
402 }
403
404 itv->v4l2_cap = itv->card->v4l2_capabilities;
405 itv->card_name = itv->card->name;
406 itv->card_i2c = itv->card->i2c;
407
408 /* If this is a PVR500 then it should be possible to detect whether it is the
409 first or second unit by looking at the subsystem device ID: is bit 4 is
410 set, then it is the second unit (according to info from Hauppauge).
411
412 However, while this works for most cards, I have seen a few PVR500 cards
413 where both units have the same subsystem ID.
414
415 So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
416 PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
417 it is the second unit. It is possible that it is a different slot when ivtv is
418 used in Xen, in that case I ignore this card here. The worst that can happen
419 is that the card presents itself with a non-working radio device.
420
421 This detection is needed since the eeprom reports incorrectly that a radio is
422 present on the second unit. */
423 if (tv.model / 1000 == 23) {
424 static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
425 .radio = { 0x60, I2C_CLIENT_END },
426 .demod = { 0x43, I2C_CLIENT_END },
427 .tv = { 0x61, I2C_CLIENT_END },
428 };
429
430 itv->card_name = "WinTV PVR 500";
431 itv->card_i2c = &ivtv_i2c_radio;
432 if (pci_slot == 8 || pci_slot == 9) {
433 int is_first = (pci_slot & 1) == 0;
434
435 itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
436 "WinTV PVR 500 (unit #2)";
437 if (!is_first) {
438 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
439 tv.has_radio = 0;
440 }
441 }
442 }
443 IVTV_INFO("Autodetected %s\n", itv->card_name);
444
445 switch (tv.tuner_hauppauge_model) {
446 case 85:
447 case 99:
448 case 112:
449 itv->pvr150_workaround = 1;
450 break;
451 default:
452 break;
453 }
454 if (tv.tuner_type == TUNER_ABSENT)
455 IVTV_ERR("tveeprom cannot autodetect tuner!");
456
457 if (itv->options.tuner == -1)
458 itv->options.tuner = tv.tuner_type;
459 if (itv->options.radio == -1)
460 itv->options.radio = (tv.has_radio != 0);
461 /* only enable newi2c if an IR blaster is present */
462 if (itv->options.newi2c == -1 && tv.has_ir) {
463 itv->options.newi2c = (tv.has_ir & 4) ? 1 : 0;
464 if (itv->options.newi2c) {
465 IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
466 exit_ivtv_i2c(itv);
467 init_ivtv_i2c(itv);
468 }
469 }
470
471 if (itv->std != 0)
472 /* user specified tuner standard */
473 return;
474
475 /* autodetect tuner standard */
476 if (tv.tuner_formats & V4L2_STD_PAL) {
477 IVTV_DEBUG_INFO("PAL tuner detected\n");
478 itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
479 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
480 IVTV_DEBUG_INFO("NTSC tuner detected\n");
481 itv->std |= V4L2_STD_NTSC_M;
482 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
483 IVTV_DEBUG_INFO("SECAM tuner detected\n");
484 itv->std |= V4L2_STD_SECAM_L;
485 } else {
486 IVTV_INFO("No tuner detected, default to NTSC-M\n");
487 itv->std |= V4L2_STD_NTSC_M;
488 }
489 }
490
491 static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
492 {
493 switch (pal[0]) {
494 case '6':
495 tunertype = 0;
496 return V4L2_STD_PAL_60;
497 case 'b':
498 case 'B':
499 case 'g':
500 case 'G':
501 case 'h':
502 case 'H':
503 tunertype = 0;
504 return V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
505 case 'n':
506 case 'N':
507 tunertype = 1;
508 if (pal[1] == 'c' || pal[1] == 'C')
509 return V4L2_STD_PAL_Nc;
510 return V4L2_STD_PAL_N;
511 case 'i':
512 case 'I':
513 tunertype = 0;
514 return V4L2_STD_PAL_I;
515 case 'd':
516 case 'D':
517 case 'k':
518 case 'K':
519 tunertype = 0;
520 return V4L2_STD_PAL_DK;
521 case 'M':
522 case 'm':
523 tunertype = 1;
524 return V4L2_STD_PAL_M;
525 case '-':
526 break;
527 default:
528 IVTV_WARN("pal= argument not recognised\n");
529 return 0;
530 }
531
532 switch (secam[0]) {
533 case 'b':
534 case 'B':
535 case 'g':
536 case 'G':
537 case 'h':
538 case 'H':
539 tunertype = 0;
540 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
541 case 'd':
542 case 'D':
543 case 'k':
544 case 'K':
545 tunertype = 0;
546 return V4L2_STD_SECAM_DK;
547 case 'l':
548 case 'L':
549 tunertype = 0;
550 if (secam[1] == 'C' || secam[1] == 'c')
551 return V4L2_STD_SECAM_LC;
552 return V4L2_STD_SECAM_L;
553 case '-':
554 break;
555 default:
556 IVTV_WARN("secam= argument not recognised\n");
557 return 0;
558 }
559
560 switch (ntsc[0]) {
561 case 'm':
562 case 'M':
563 tunertype = 1;
564 return V4L2_STD_NTSC_M;
565 case 'j':
566 case 'J':
567 tunertype = 1;
568 return V4L2_STD_NTSC_M_JP;
569 case 'k':
570 case 'K':
571 tunertype = 1;
572 return V4L2_STD_NTSC_M_KR;
573 case '-':
574 break;
575 default:
576 IVTV_WARN("ntsc= argument not recognised\n");
577 return 0;
578 }
579
580 /* no match found */
581 return 0;
582 }
583
584 static void ivtv_process_options(struct ivtv *itv)
585 {
586 const char *chipname;
587 int i, j;
588
589 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
590 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
591 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
592 itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
593 itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
594 itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
595 itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
596 itv->options.cardtype = cardtype[itv->instance];
597 itv->options.tuner = tuner[itv->instance];
598 itv->options.radio = radio[itv->instance];
599 itv->options.newi2c = newi2c;
600 if (tunertype < -1 || tunertype > 1) {
601 IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
602 tunertype = -1;
603 }
604 itv->std = ivtv_parse_std(itv);
605 if (itv->std == 0 && tunertype >= 0)
606 itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
607 itv->has_cx23415 = (itv->pdev->device == PCI_DEVICE_ID_IVTV15);
608 chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
609 if (itv->options.cardtype == -1) {
610 IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
611 return;
612 }
613 if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
614 IVTV_INFO("User specified %s card (detected %s based chip)\n",
615 itv->card->name, chipname);
616 } else if (itv->options.cardtype != 0) {
617 IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
618 }
619 if (itv->card == NULL) {
620 if (itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
621 itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
622 itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
623 itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
624 IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
625 chipname);
626 }
627 }
628 if (itv->card == NULL) {
629 for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
630 if (itv->card->pci_list == NULL)
631 continue;
632 for (j = 0; itv->card->pci_list[j].device; j++) {
633 if (itv->pdev->device !=
634 itv->card->pci_list[j].device)
635 continue;
636 if (itv->pdev->subsystem_vendor !=
637 itv->card->pci_list[j].subsystem_vendor)
638 continue;
639 if (itv->pdev->subsystem_device !=
640 itv->card->pci_list[j].subsystem_device)
641 continue;
642 IVTV_INFO("Autodetected %s card (%s based)\n",
643 itv->card->name, chipname);
644 goto done;
645 }
646 }
647 }
648 done:
649
650 if (itv->card == NULL) {
651 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
652 IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
653 itv->pdev->vendor, itv->pdev->device);
654 IVTV_ERR(" subsystem vendor/device: [%04x:%04x]\n",
655 itv->pdev->subsystem_vendor, itv->pdev->subsystem_device);
656 IVTV_ERR(" %s based\n", chipname);
657 IVTV_ERR("Defaulting to %s card\n", itv->card->name);
658 IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
659 IVTV_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
660 IVTV_ERR("Prefix your subject line with [UNKNOWN IVTV CARD].\n");
661 }
662 itv->v4l2_cap = itv->card->v4l2_capabilities;
663 itv->card_name = itv->card->name;
664 itv->card_i2c = itv->card->i2c;
665 }
666
667 /* Precondition: the ivtv structure has been memset to 0. Only
668 the dev and num fields have been filled in.
669 No assumptions on the card type may be made here (see ivtv_init_struct2
670 for that).
671 */
672 static int __devinit ivtv_init_struct1(struct ivtv *itv)
673 {
674 itv->base_addr = pci_resource_start(itv->pdev, 0);
675 itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
676 itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
677
678 mutex_init(&itv->serialize_lock);
679 mutex_init(&itv->i2c_bus_lock);
680 mutex_init(&itv->udma.lock);
681
682 spin_lock_init(&itv->lock);
683 spin_lock_init(&itv->dma_reg_lock);
684
685 itv->irq_work_queues = create_singlethread_workqueue(itv->v4l2_dev.name);
686 if (itv->irq_work_queues == NULL) {
687 IVTV_ERR("Could not create ivtv workqueue\n");
688 return -1;
689 }
690
691 INIT_WORK(&itv->irq_work_queue, ivtv_irq_work_handler);
692
693 /* start counting open_id at 1 */
694 itv->open_id = 1;
695
696 /* Initial settings */
697 cx2341x_fill_defaults(&itv->params);
698 itv->params.port = CX2341X_PORT_MEMORY;
699 itv->params.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
700 init_waitqueue_head(&itv->eos_waitq);
701 init_waitqueue_head(&itv->event_waitq);
702 init_waitqueue_head(&itv->vsync_waitq);
703 init_waitqueue_head(&itv->dma_waitq);
704 init_timer(&itv->dma_timer);
705 itv->dma_timer.function = ivtv_unfinished_dma;
706 itv->dma_timer.data = (unsigned long)itv;
707
708 itv->cur_dma_stream = -1;
709 itv->cur_pio_stream = -1;
710 itv->audio_stereo_mode = AUDIO_STEREO;
711 itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
712
713 /* Ctrls */
714 itv->speed = 1000;
715
716 /* VBI */
717 itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
718 itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
719
720 /* Init the sg table for osd/yuv output */
721 sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
722
723 /* OSD */
724 itv->osd_global_alpha_state = 1;
725 itv->osd_global_alpha = 255;
726
727 /* YUV */
728 atomic_set(&itv->yuv_info.next_dma_frame, -1);
729 itv->yuv_info.lace_mode = ivtv_yuv_mode;
730 itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
731 itv->yuv_info.max_frames_buffered = 3;
732 itv->yuv_info.track_osd = 1;
733 return 0;
734 }
735
736 /* Second initialization part. Here the card type has been
737 autodetected. */
738 static void __devinit ivtv_init_struct2(struct ivtv *itv)
739 {
740 int i;
741
742 for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
743 if (itv->card->video_inputs[i].video_type == 0)
744 break;
745 itv->nof_inputs = i;
746 for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
747 if (itv->card->audio_inputs[i].audio_type == 0)
748 break;
749 itv->nof_audio_inputs = i;
750
751 if (itv->card->hw_all & IVTV_HW_CX25840) {
752 itv->vbi.sliced_size = 288; /* multiple of 16, real size = 284 */
753 } else {
754 itv->vbi.sliced_size = 64; /* multiple of 16, real size = 52 */
755 }
756
757 /* Find tuner input */
758 for (i = 0; i < itv->nof_inputs; i++) {
759 if (itv->card->video_inputs[i].video_type ==
760 IVTV_CARD_INPUT_VID_TUNER)
761 break;
762 }
763 if (i == itv->nof_inputs)
764 i = 0;
765 itv->active_input = i;
766 itv->audio_input = itv->card->video_inputs[i].audio_index;
767 }
768
769 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
770 const struct pci_device_id *pci_id)
771 {
772 u16 cmd;
773 u8 card_rev;
774 unsigned char pci_latency;
775
776 IVTV_DEBUG_INFO("Enabling pci device\n");
777
778 if (pci_enable_device(pdev)) {
779 IVTV_ERR("Can't enable device!\n");
780 return -EIO;
781 }
782 if (pci_set_dma_mask(pdev, 0xffffffff)) {
783 IVTV_ERR("No suitable DMA available.\n");
784 return -EIO;
785 }
786 if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
787 IVTV_ERR("Cannot request encoder memory region.\n");
788 return -EIO;
789 }
790
791 if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
792 IVTV_REG_SIZE, "ivtv registers")) {
793 IVTV_ERR("Cannot request register memory region.\n");
794 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
795 return -EIO;
796 }
797
798 if (itv->has_cx23415 &&
799 !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
800 IVTV_DECODER_SIZE, "ivtv decoder")) {
801 IVTV_ERR("Cannot request decoder memory region.\n");
802 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
803 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
804 return -EIO;
805 }
806
807 /* Check for bus mastering */
808 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
809 if (!(cmd & PCI_COMMAND_MASTER)) {
810 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
811 pci_set_master(pdev);
812 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
813 if (!(cmd & PCI_COMMAND_MASTER)) {
814 IVTV_ERR("Bus Mastering is not enabled\n");
815 return -ENXIO;
816 }
817 }
818 IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
819
820 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &card_rev);
821 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
822
823 if (pci_latency < 64 && ivtv_pci_latency) {
824 IVTV_INFO("Unreasonably low latency timer, "
825 "setting to 64 (was %d)\n", pci_latency);
826 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
827 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
828 }
829 /* This config space value relates to DMA latencies. The
830 default value 0x8080 is too low however and will lead
831 to DMA errors. 0xffff is the max value which solves
832 these problems. */
833 pci_write_config_dword(pdev, 0x40, 0xffff);
834
835 IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
836 "irq: %d, latency: %d, memory: 0x%lx\n",
837 pdev->device, card_rev, pdev->bus->number,
838 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
839 pdev->irq, pci_latency, (unsigned long)itv->base_addr);
840
841 return 0;
842 }
843
844 static void ivtv_load_and_init_modules(struct ivtv *itv)
845 {
846 u32 hw = itv->card->hw_all;
847 unsigned i;
848
849 /* check which i2c devices are actually found */
850 for (i = 0; i < 32; i++) {
851 u32 device = 1 << i;
852
853 if (!(device & hw))
854 continue;
855 if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
856 /* GPIO and TVEEPROM do not use i2c probing */
857 itv->hw_flags |= device;
858 continue;
859 }
860 if (ivtv_i2c_register(itv, i) == 0)
861 itv->hw_flags |= device;
862 }
863
864 if (itv->card->hw_all & IVTV_HW_CX25840)
865 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_CX25840);
866 else if (itv->card->hw_all & IVTV_HW_SAA717X)
867 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA717X);
868 else if (itv->card->hw_all & IVTV_HW_SAA7114)
869 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7114);
870 else
871 itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7115);
872 itv->sd_audio = ivtv_find_hw(itv, itv->card->hw_audio_ctrl);
873 itv->sd_muxer = ivtv_find_hw(itv, itv->card->hw_muxer);
874
875 hw = itv->hw_flags;
876
877 if (itv->card->type == IVTV_CARD_CX23416GYC) {
878 /* Several variations of this card exist, detect which card
879 type should be used. */
880 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
881 itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
882 else if ((hw & IVTV_HW_UPD64031A) == 0)
883 itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
884 }
885 else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
886 itv->card->type == IVTV_CARD_GV_MVPRX2E) {
887 /* The crystal frequency of GVMVPRX is 24.576MHz */
888 v4l2_subdev_call(itv->sd_video, video, s_crystal_freq,
889 SAA7115_FREQ_24_576_MHZ, SAA7115_FREQ_FL_UCGC);
890 }
891
892 if (hw & IVTV_HW_CX25840) {
893 itv->vbi.raw_decoder_line_size = 1444;
894 itv->vbi.raw_decoder_sav_odd_field = 0x20;
895 itv->vbi.raw_decoder_sav_even_field = 0x60;
896 itv->vbi.sliced_decoder_line_size = 272;
897 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
898 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
899 }
900
901 if (hw & IVTV_HW_SAA711X) {
902 struct v4l2_dbg_chip_ident v;
903
904 /* determine the exact saa711x model */
905 itv->hw_flags &= ~IVTV_HW_SAA711X;
906
907 v.match.type = V4L2_CHIP_MATCH_I2C_DRIVER;
908 strlcpy(v.match.name, "saa7115", sizeof(v.match.name));
909 ivtv_call_hw(itv, IVTV_HW_SAA711X, core, g_chip_ident, &v);
910 if (v.ident == V4L2_IDENT_SAA7114) {
911 itv->hw_flags |= IVTV_HW_SAA7114;
912 /* VBI is not yet supported by the saa7114 driver. */
913 itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
914 } else {
915 itv->hw_flags |= IVTV_HW_SAA7115;
916 }
917 itv->vbi.raw_decoder_line_size = 1443;
918 itv->vbi.raw_decoder_sav_odd_field = 0x25;
919 itv->vbi.raw_decoder_sav_even_field = 0x62;
920 itv->vbi.sliced_decoder_line_size = 51;
921 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
922 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
923 }
924
925 if (hw & IVTV_HW_SAA717X) {
926 itv->vbi.raw_decoder_line_size = 1443;
927 itv->vbi.raw_decoder_sav_odd_field = 0x25;
928 itv->vbi.raw_decoder_sav_even_field = 0x62;
929 itv->vbi.sliced_decoder_line_size = 51;
930 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
931 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
932 }
933 }
934
935 static int __devinit ivtv_probe(struct pci_dev *pdev,
936 const struct pci_device_id *pci_id)
937 {
938 int retval = 0;
939 int vbi_buf_size;
940 struct ivtv *itv;
941
942 itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
943 if (itv == NULL)
944 return -ENOMEM;
945 itv->pdev = pdev;
946 itv->instance = atomic_inc_return(&ivtv_instance) - 1;
947
948 retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
949 if (retval) {
950 kfree(itv);
951 return retval;
952 }
953 /* "ivtv + PCI ID" is a bit of a mouthful, so use
954 "ivtv + instance" instead. */
955 snprintf(itv->v4l2_dev.name, sizeof(itv->v4l2_dev.name),
956 "ivtv%d", itv->instance);
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.066431 seconds and 6 git commands to generate.