?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (6093): ivtv: reorganized and cleanup ivtv struct
[firewire-audio.git] / drivers / media / video / ivtv / ivtv-driver.c
blob855697c1c9681bcca51c73fc080c502e1ecda539
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->eos_waitq);
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 if (itv->card->hw_all & IVTV_HW_CX25840) {
717 itv->vbi.sliced_size = 288; /* multiple of 16, real size = 284 */
718 } else {
719 itv->vbi.sliced_size = 64; /* multiple of 16, real size = 52 */
720 }
721
722 /* Find tuner input */
723 for (i = 0; i < itv->nof_inputs; i++) {
724 if (itv->card->video_inputs[i].video_type ==
725 IVTV_CARD_INPUT_VID_TUNER)
726 break;
727 }
728 if (i == itv->nof_inputs)
729 i = 0;
730 itv->active_input = i;
731 itv->audio_input = itv->card->video_inputs[i].audio_index;
732 if (itv->card->hw_all & IVTV_HW_CX25840)
733 itv->video_dec_func = ivtv_cx25840;
734 else if (itv->card->hw_all & IVTV_HW_SAA717X)
735 itv->video_dec_func = ivtv_saa717x;
736 else
737 itv->video_dec_func = ivtv_saa7115;
738 }
739
740 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
741 const struct pci_device_id *pci_id)
742 {
743 u16 cmd;
744 u8 card_rev;
745 unsigned char pci_latency;
746
747 IVTV_DEBUG_INFO("Enabling pci device\n");
748
749 if (pci_enable_device(dev)) {
750 IVTV_ERR("Can't enable device %d!\n", itv->num);
751 return -EIO;
752 }
753 if (pci_set_dma_mask(dev, 0xffffffff)) {
754 IVTV_ERR("No suitable DMA available on card %d.\n", itv->num);
755 return -EIO;
756 }
757 if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
758 IVTV_ERR("Cannot request encoder memory region on card %d.\n", itv->num);
759 return -EIO;
760 }
761
762 if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
763 IVTV_REG_SIZE, "ivtv registers")) {
764 IVTV_ERR("Cannot request register memory region on card %d.\n", itv->num);
765 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
766 return -EIO;
767 }
768
769 if (itv->has_cx23415 &&
770 !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
771 IVTV_DECODER_SIZE, "ivtv decoder")) {
772 IVTV_ERR("Cannot request decoder memory region on card %d.\n", itv->num);
773 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
774 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
775 return -EIO;
776 }
777
778 /* Check for bus mastering */
779 pci_read_config_word(dev, PCI_COMMAND, &cmd);
780 if (!(cmd & PCI_COMMAND_MASTER)) {
781 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
782 pci_set_master(dev);
783 pci_read_config_word(dev, PCI_COMMAND, &cmd);
784 if (!(cmd & PCI_COMMAND_MASTER)) {
785 IVTV_ERR("Bus Mastering is not enabled\n");
786 return -ENXIO;
787 }
788 }
789 IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
790
791 pci_read_config_byte(dev, PCI_CLASS_REVISION, &card_rev);
792 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
793
794 if (pci_latency < 64 && ivtv_pci_latency) {
795 IVTV_INFO("Unreasonably low latency timer, "
796 "setting to 64 (was %d)\n", pci_latency);
797 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
798 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
799 }
800 /* This config space value relates to DMA latencies. The
801 default value 0x8080 is too low however and will lead
802 to DMA errors. 0xffff is the max value which solves
803 these problems. */
804 pci_write_config_dword(dev, 0x40, 0xffff);
805
806 IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
807 "irq: %d, latency: %d, memory: 0x%lx\n",
808 itv->dev->device, card_rev, dev->bus->number,
809 PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
810 itv->dev->irq, pci_latency, (unsigned long)itv->base_addr);
811
812 return 0;
813 }
814
815 static void ivtv_request_module(struct ivtv *itv, const char *name)
816 {
817 if (request_module(name) != 0) {
818 IVTV_ERR("Failed to load module %s\n", name);
819 } else {
820 IVTV_DEBUG_INFO("Loaded module %s\n", name);
821 }
822 }
823
824 static void ivtv_load_and_init_modules(struct ivtv *itv)
825 {
826 u32 hw = itv->card->hw_all;
827 int i;
828
829 /* load modules */
830 #ifndef CONFIG_VIDEO_TUNER
831 if (hw & IVTV_HW_TUNER) {
832 if (itv->options.tuner == TUNER_XCEIVE_XC3028) {
833 IVTV_INFO("Xceive tuner not yet supported, only composite and S-Video inputs will be available\n");
834 itv->tunerid = 1;
835 }
836 else {
837 ivtv_request_module(itv, "tuner");
838 }
839 }
840 #endif
841 #ifndef CONFIG_VIDEO_CX25840
842 if (hw & IVTV_HW_CX25840)
843 ivtv_request_module(itv, "cx25840");
844 #endif
845 #ifndef CONFIG_VIDEO_SAA711X
846 if (hw & IVTV_HW_SAA711X)
847 ivtv_request_module(itv, "saa7115");
848 #endif
849 #ifndef CONFIG_VIDEO_SAA7127
850 if (hw & IVTV_HW_SAA7127)
851 ivtv_request_module(itv, "saa7127");
852 #endif
853 if (hw & IVTV_HW_SAA717X)
854 ivtv_request_module(itv, "saa717x");
855 #ifndef CONFIG_VIDEO_UPD64031A
856 if (hw & IVTV_HW_UPD64031A)
857 ivtv_request_module(itv, "upd64031a");
858 #endif
859 #ifndef CONFIG_VIDEO_UPD64083
860 if (hw & IVTV_HW_UPD6408X)
861 ivtv_request_module(itv, "upd64083");
862 #endif
863 #ifndef CONFIG_VIDEO_MSP3400
864 if (hw & IVTV_HW_MSP34XX)
865 ivtv_request_module(itv, "msp3400");
866 #endif
867 #ifndef CONFIG_VIDEO_VP27SMPX
868 if (hw & IVTV_HW_VP27SMPX)
869 ivtv_request_module(itv, "vp27smpx");
870 #endif
871 if (hw & IVTV_HW_TVAUDIO)
872 ivtv_request_module(itv, "tvaudio");
873 #ifndef CONFIG_VIDEO_WM8775
874 if (hw & IVTV_HW_WM8775)
875 ivtv_request_module(itv, "wm8775");
876 #endif
877 #ifndef CONFIG_VIDEO_WM8739
878 if (hw & IVTV_HW_WM8739)
879 ivtv_request_module(itv, "wm8739");
880 #endif
881 #ifndef CONFIG_VIDEO_CS53L32A
882 if (hw & IVTV_HW_CS53L32A)
883 ivtv_request_module(itv, "cs53l32a");
884 #endif
885
886 /* check which i2c devices are actually found */
887 for (i = 0; i < 32; i++) {
888 u32 device = 1 << i;
889
890 if (!(device & hw))
891 continue;
892 if (device == IVTV_HW_GPIO) {
893 /* GPIO is always available */
894 itv->hw_flags |= IVTV_HW_GPIO;
895 continue;
896 }
897 if (ivtv_i2c_hw_addr(itv, device) > 0)
898 itv->hw_flags |= device;
899 }
900
901 hw = itv->hw_flags;
902
903 if (itv->card->type == IVTV_CARD_CX23416GYC) {
904 /* Several variations of this card exist, detect which card
905 type should be used. */
906 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
907 itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
908 else if ((hw & IVTV_HW_UPD64031A) == 0)
909 itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
910 }
911 else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
912 itv->card->type == IVTV_CARD_GV_MVPRX2E) {
913 struct v4l2_crystal_freq crystal_freq;
914
915 /* The crystal frequency of GVMVPRX is 24.576MHz */
916 crystal_freq.freq = SAA7115_FREQ_24_576_MHZ;
917 crystal_freq.flags = SAA7115_FREQ_FL_UCGC;
918 itv->video_dec_func(itv, VIDIOC_INT_S_CRYSTAL_FREQ, &crystal_freq);
919 }
920
921 if (hw & IVTV_HW_CX25840) {
922 itv->vbi.raw_decoder_line_size = 1444;
923 itv->vbi.raw_decoder_sav_odd_field = 0x20;
924 itv->vbi.raw_decoder_sav_even_field = 0x60;
925 itv->vbi.sliced_decoder_line_size = 272;
926 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
927 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
928 }
929
930 if (hw & IVTV_HW_SAA711X) {
931 struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
932
933 /* determine the exact saa711x model */
934 itv->hw_flags &= ~IVTV_HW_SAA711X;
935
936 ivtv_saa7115(itv, VIDIOC_G_CHIP_IDENT, &v);
937 if (v.ident == V4L2_IDENT_SAA7114) {
938 itv->hw_flags |= IVTV_HW_SAA7114;
939 /* VBI is not yet supported by the saa7114 driver. */
940 itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
941 }
942 else {
943 itv->hw_flags |= IVTV_HW_SAA7115;
944 }
945 itv->vbi.raw_decoder_line_size = 1443;
946 itv->vbi.raw_decoder_sav_odd_field = 0x25;
947 itv->vbi.raw_decoder_sav_even_field = 0x62;
948 itv->vbi.sliced_decoder_line_size = 51;
949 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
950 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
951 }
952
953 if (hw & IVTV_HW_SAA717X) {
954 itv->vbi.raw_decoder_line_size = 1443;
955 itv->vbi.raw_decoder_sav_odd_field = 0x25;
956 itv->vbi.raw_decoder_sav_even_field = 0x62;
957 itv->vbi.sliced_decoder_line_size = 51;
958 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
959 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
960 }
961 }
962
963 static int __devinit ivtv_probe(struct pci_dev *dev,
964 const struct pci_device_id *pci_id)
965 {
966 int retval = 0;
967 int yuv_buf_size;
968 int vbi_buf_size;
969 struct ivtv *itv;
970
971 spin_lock(&ivtv_cards_lock);
972
973 /* Make sure we've got a place for this card */
974 if (ivtv_cards_active == IVTV_MAX_CARDS) {
975 printk(KERN_ERR "ivtv: Maximum number of cards detected (%d)\n",
976 ivtv_cards_active);
977 spin_unlock(&ivtv_cards_lock);
978 return -ENOMEM;
979 }
980
981 itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
982 if (itv == 0) {
983 spin_unlock(&ivtv_cards_lock);
984 return -ENOMEM;
985 }
986 ivtv_cards[ivtv_cards_active] = itv;
987 itv->dev = dev;
988 itv->num = ivtv_cards_active++;
989 snprintf(itv->name, sizeof(itv->name) - 1, "ivtv%d", itv->num);
990 IVTV_INFO("Initializing card #%d\n", itv->num);
991
992 spin_unlock(&ivtv_cards_lock);
993
994 ivtv_process_options(itv);
995 if (itv->options.cardtype == -1) {
996 retval = -ENODEV;
997 goto err;
998 }
999 if (ivtv_init_struct1(itv)) {
1000 retval = -ENOMEM;
1001 goto err;
1002 }
1003
1004 IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
1005
1006 /* PCI Device Setup */
1007 if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
1008 if (retval == -EIO)
1009 goto free_workqueue;
1010 else if (retval == -ENXIO)
1011 goto free_mem;
1012 }
1013 /* save itv in the pci struct for later use */
1014 pci_set_drvdata(dev, itv);
1015
1016 /* map io memory */
1017 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1018 itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1019 itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1020 IVTV_ENCODER_SIZE);
1021 if (!itv->enc_mem) {
1022 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1023 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1024 retval = -ENOMEM;
1025 goto free_mem;
1026 }
1027
1028 if (itv->has_cx23415) {
1029 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1030 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1031 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1032 IVTV_DECODER_SIZE);
1033 if (!itv->dec_mem) {
1034 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1035 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1036 retval = -ENOMEM;
1037 goto free_mem;
1038 }
1039 }
1040 else {
1041 itv->dec_mem = itv->enc_mem;
1042 }
1043
1044 /* map registers memory */
1045 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1046 itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1047 itv->reg_mem =
1048 ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1049 if (!itv->reg_mem) {
1050 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1051 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1052 retval = -ENOMEM;
1053 goto free_io;
1054 }
1055
1056 /* Check yuv output filter table */
1057 if (itv->has_cx23415) ivtv_yuv_filter_check(itv);
1058
1059 ivtv_gpio_init(itv);
1060
1061 /* active i2c */
1062 IVTV_DEBUG_INFO("activating i2c...\n");
1063 if (init_ivtv_i2c(itv)) {
1064 IVTV_ERR("Could not initialize i2c\n");
1065 goto free_irq;
1066 }
1067
1068 IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1069
1070 if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1071 #ifdef CONFIG_VIDEO_TVEEPROM_MODULE
1072 ivtv_request_module(itv, "tveeprom");
1073 #endif
1074 /* Based on the model number the cardtype may be changed.
1075 The PCI IDs are not always reliable. */
1076 ivtv_process_eeprom(itv);
1077 }
1078
1079 if (itv->std == 0) {
1080 itv->std = V4L2_STD_NTSC_M;
1081 }
1082
1083 if (itv->options.tuner == -1) {
1084 int i;
1085
1086 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1087 if ((itv->std & itv->card->tuners[i].std) == 0)
1088 continue;
1089 itv->options.tuner = itv->card->tuners[i].tuner;
1090 break;
1091 }
1092 }
1093 /* if no tuner was found, then pick the first tuner in the card list */
1094 if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1095 itv->std = itv->card->tuners[0].std;
1096 itv->options.tuner = itv->card->tuners[0].tuner;
1097 }
1098 if (itv->options.radio == -1)
1099 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1100
1101 /* The card is now fully identified, continue with card-specific
1102 initialization. */
1103 ivtv_init_struct2(itv);
1104
1105 ivtv_load_and_init_modules(itv);
1106
1107 if (itv->std & V4L2_STD_525_60) {
1108 itv->is_60hz = 1;
1109 itv->is_out_60hz = 1;
1110 } else {
1111 itv->is_50hz = 1;
1112 itv->is_out_50hz = 1;
1113 }
1114 itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1115
1116 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1117 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1118 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1119
1120 /* 0x15180 == 720 * 480 / 4, 0x19500 == 720 * 576 / 4 */
1121 yuv_buf_size = itv->is_60hz ? 0x15180 : 0x19500;
1122 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = yuv_buf_size / 2;
1123 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = yuv_buf_size / 8;
1124
1125 /* Setup VBI Raw Size. Should be big enough to hold PAL.
1126 It is possible to switch between PAL and NTSC, so we need to
1127 take the largest size here. */
1128 /* 1456 is multiple of 16, real size = 1444 */
1129 itv->vbi.raw_size = 1456;
1130 /* We use a buffer size of 1/2 of the total size needed for a
1131 frame. This is actually very useful, since we now receive
1132 a field at a time and that makes 'compressing' the raw data
1133 down to size by stripping off the SAV codes a lot easier.
1134 Note: having two different buffer sizes prevents standard
1135 switching on the fly. We need to find a better solution... */
1136 vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1137 itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1138 itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1139
1140 if (itv->options.radio > 0)
1141 itv->v4l2_cap |= V4L2_CAP_RADIO;
1142
1143 if (itv->options.tuner > -1 && itv->tunerid == 0) {
1144 struct tuner_setup setup;
1145
1146 setup.addr = ADDR_UNSET;
1147 setup.type = itv->options.tuner;
1148 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1149 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1150 }
1151
1152 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1153 are not. */
1154 itv->tuner_std = itv->std;
1155
1156 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1157 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std);
1158 }
1159
1160 retval = ivtv_streams_setup(itv);
1161 if (retval) {
1162 IVTV_ERR("Error %d setting up streams\n", retval);
1163 goto free_i2c;
1164 }
1165
1166 IVTV_DEBUG_IRQ("Masking interrupts\n");
1167 /* clear interrupt mask, effectively disabling interrupts */
1168 ivtv_set_irq_mask(itv, 0xffffffff);
1169
1170 /* Register IRQ */
1171 retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1172 IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1173 if (retval) {
1174 IVTV_ERR("Failed to register irq %d\n", retval);
1175 goto free_streams;
1176 }
1177 IVTV_INFO("Initialized card #%d: %s\n", itv->num, itv->card_name);
1178 return 0;
1179
1180 free_irq:
1181 free_irq(itv->dev->irq, (void *)itv);
1182 free_streams:
1183 ivtv_streams_cleanup(itv);
1184 free_i2c:
1185 exit_ivtv_i2c(itv);
1186 free_io:
1187 ivtv_iounmap(itv);
1188 free_mem:
1189 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1190 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1191 if (itv->has_cx23415)
1192 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1193 free_workqueue:
1194 destroy_workqueue(itv->irq_work_queues);
1195 err:
1196 if (retval == 0)
1197 retval = -ENODEV;
1198 IVTV_ERR("Error %d on initialization\n", retval);
1199
1200 spin_lock(&ivtv_cards_lock);
1201 kfree(ivtv_cards[ivtv_cards_active]);
1202 ivtv_cards[ivtv_cards_active] = NULL;
1203 spin_unlock(&ivtv_cards_lock);
1204 return retval;
1205 }
1206
1207 int ivtv_init_on_first_open(struct ivtv *itv)
1208 {
1209 struct v4l2_frequency vf;
1210 int fw_retry_count = 3;
1211 int video_input;
1212
1213 if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1214 return -ENXIO;
1215
1216 if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1217 return 0;
1218
1219 while (--fw_retry_count > 0) {
1220 /* load firmware */
1221 if (ivtv_firmware_init(itv) == 0)
1222 break;
1223 if (fw_retry_count > 1)
1224 IVTV_WARN("Retry loading firmware\n");
1225 }
1226
1227 if (fw_retry_count == 0) {
1228 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1229 return -ENXIO;
1230 }
1231
1232 /* Try and get firmware versions */
1233 IVTV_DEBUG_INFO("Getting firmware version..\n");
1234 ivtv_firmware_versions(itv);
1235
1236 if (itv->card->hw_all & IVTV_HW_CX25840) {
1237 struct v4l2_control ctrl;
1238
1239 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1240 ctrl.id = V4L2_CID_PRIVATE_BASE;
1241 ctrl.value = itv->pvr150_workaround;
1242 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
1243 }
1244
1245 vf.tuner = 0;
1246 vf.type = V4L2_TUNER_ANALOG_TV;
1247 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1248
1249 /* Set initial frequency. For PAL/SECAM broadcasts no
1250 'default' channel exists AFAIK. */
1251 if (itv->std == V4L2_STD_NTSC_M_JP) {
1252 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1253 }
1254 else if (itv->std & V4L2_STD_NTSC_M) {
1255 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1256 }
1257
1258 video_input = itv->active_input;
1259 itv->active_input++; /* Force update of input */
1260 ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_INPUT, &video_input);
1261
1262 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1263 in one place. */
1264 itv->std++; /* Force full standard initialization */
1265 itv->std_out = itv->std;
1266 ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_FREQUENCY, &vf);
1267
1268 if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1269 ivtv_init_mpeg_decoder(itv);
1270 }
1271 ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_STD, &itv->tuner_std);
1272
1273 /* On a cx23416 this seems to be able to enable DMA to the chip? */
1274 if (!itv->has_cx23415)
1275 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1276
1277 /* Default interrupts enabled. For the PVR350 this includes the
1278 decoder VSYNC interrupt, which is always on. It is not only used
1279 during decoding but also by the OSD.
1280 Some old PVR250 cards had a cx23415, so testing for that is too
1281 general. Instead test if the card has video output capability. */
1282 if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1283 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1284 ivtv_set_osd_alpha(itv);
1285 }
1286 else
1287 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1288 return 0;
1289 }
1290
1291 static void ivtv_remove(struct pci_dev *pci_dev)
1292 {
1293 struct ivtv *itv = pci_get_drvdata(pci_dev);
1294
1295 IVTV_DEBUG_INFO("Removing Card #%d\n", itv->num);
1296
1297 if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1298 /* Stop all captures */
1299 IVTV_DEBUG_INFO("Stopping all streams\n");
1300 if (atomic_read(&itv->capturing) > 0)
1301 ivtv_stop_all_captures(itv);
1302
1303 /* Stop all decoding */
1304 IVTV_DEBUG_INFO("Stopping decoding\n");
1305 if (atomic_read(&itv->decoding) > 0) {
1306 int type;
1307
1308 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1309 type = IVTV_DEC_STREAM_TYPE_YUV;
1310 else
1311 type = IVTV_DEC_STREAM_TYPE_MPG;
1312 ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1313 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1314 }
1315 ivtv_halt_firmware(itv);
1316 }
1317
1318 /* Interrupts */
1319 ivtv_set_irq_mask(itv, 0xffffffff);
1320 del_timer_sync(&itv->dma_timer);
1321
1322 /* Stop all Work Queues */
1323 flush_workqueue(itv->irq_work_queues);
1324 destroy_workqueue(itv->irq_work_queues);
1325
1326 ivtv_streams_cleanup(itv);
1327 ivtv_udma_free(itv);
1328
1329 exit_ivtv_i2c(itv);
1330
1331 free_irq(itv->dev->irq, (void *)itv);
1332 ivtv_iounmap(itv);
1333
1334 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1335 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1336 if (itv->has_cx23415)
1337 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1338
1339 pci_disable_device(itv->dev);
1340
1341 IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1342 }
1343
1344 /* define a pci_driver for card detection */
1345 static struct pci_driver ivtv_pci_driver = {
1346 .name = "ivtv",
1347 .id_table = ivtv_pci_tbl,
1348 .probe = ivtv_probe,
1349 .remove = ivtv_remove,
1350 };
1351
1352 static int module_start(void)
1353 {
1354 printk(KERN_INFO "ivtv: Start initialization, version %s\n", IVTV_VERSION);
1355
1356 memset(ivtv_cards, 0, sizeof(ivtv_cards));
1357
1358 /* Validate parameters */
1359 if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1360 printk(KERN_ERR "ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1361 IVTV_MAX_CARDS - 1);
1362 return -1;
1363 }
1364
1365 if (ivtv_debug < 0 || ivtv_debug > 2047) {
1366 ivtv_debug = 0;
1367 printk(KERN_INFO "ivtv: Debug value must be >= 0 and <= 2047\n");
1368 }
1369
1370 if (pci_register_driver(&ivtv_pci_driver)) {
1371 printk(KERN_ERR "ivtv: Error detecting PCI card\n");
1372 return -ENODEV;
1373 }
1374 printk(KERN_INFO "ivtv: End initialization\n");
1375 return 0;
1376 }
1377
1378 static void module_cleanup(void)
1379 {
1380 int i, j;
1381
1382 pci_unregister_driver(&ivtv_pci_driver);
1383
1384 spin_lock(&ivtv_cards_lock);
1385 for (i = 0; i < ivtv_cards_active; i++) {
1386 if (ivtv_cards[i] == NULL)
1387 continue;
1388 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1389 kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1390 }
1391 kfree(ivtv_cards[i]);
1392 }
1393 spin_unlock(&ivtv_cards_lock);
1394 }
1395
1396 /* Note: These symbols are exported because they are used by the ivtv-fb
1397 framebuffer module and an infrared module for the IR-blaster. */
1398 EXPORT_SYMBOL(ivtv_set_irq_mask);
1399 EXPORT_SYMBOL(ivtv_cards_active);
1400 EXPORT_SYMBOL(ivtv_cards);
1401 EXPORT_SYMBOL(ivtv_cards_lock);
1402 EXPORT_SYMBOL(ivtv_api);
1403 EXPORT_SYMBOL(ivtv_vapi);
1404 EXPORT_SYMBOL(ivtv_vapi_result);
1405 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1406 EXPORT_SYMBOL(ivtv_debug);
1407 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1408 EXPORT_SYMBOL(ivtv_udma_setup);
1409 EXPORT_SYMBOL(ivtv_udma_unmap);
1410 EXPORT_SYMBOL(ivtv_udma_alloc);
1411 EXPORT_SYMBOL(ivtv_udma_prepare);
1412 EXPORT_SYMBOL(ivtv_init_on_first_open);
1413
1414 module_init(module_start);
1415 module_exit(module_cleanup);
AMDTP streaming driver for the Linux FireWire stack (Juju)