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