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