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