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