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