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