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