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