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