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