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