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