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