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