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