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