]>
Commit | Line | Data |
---|---|---|
1c1e45d1 HV |
1 | /* |
2 | * cx18 driver initialization and card probing | |
3 | * | |
4 | * Derived from ivtv-driver.c | |
5 | * | |
6 | * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
21 | * 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include "cx18-driver.h" | |
25 | #include "cx18-version.h" | |
26 | #include "cx18-cards.h" | |
27 | #include "cx18-i2c.h" | |
28 | #include "cx18-irq.h" | |
29 | #include "cx18-gpio.h" | |
30 | #include "cx18-firmware.h" | |
31 | #include "cx18-streams.h" | |
32 | #include "cx18-av-core.h" | |
33 | #include "cx18-scb.h" | |
34 | #include "cx18-mailbox.h" | |
35 | #include "cx18-ioctl.h" | |
36 | #include "tuner-xc2028.h" | |
37 | ||
38 | #include <media/tveeprom.h> | |
39 | ||
40 | ||
41 | /* var to keep track of the number of array elements in use */ | |
42 | int cx18_cards_active; | |
43 | ||
44 | /* If you have already X v4l cards, then set this to X. This way | |
45 | the device numbers stay matched. Example: you have a WinTV card | |
46 | without radio and a Compro H900 with. Normally this would give a | |
47 | video1 device together with a radio0 device for the Compro. By | |
48 | setting this to 1 you ensure that radio0 is now also radio1. */ | |
49 | int cx18_first_minor; | |
50 | ||
51 | /* Master variable for all cx18 info */ | |
52 | struct cx18 *cx18_cards[CX18_MAX_CARDS]; | |
53 | ||
54 | /* Protects cx18_cards_active */ | |
55 | DEFINE_SPINLOCK(cx18_cards_lock); | |
56 | ||
57 | /* add your revision and whatnot here */ | |
58 | static struct pci_device_id cx18_pci_tbl[] __devinitdata = { | |
59 | {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418, | |
60 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | |
61 | {0,} | |
62 | }; | |
63 | ||
64 | MODULE_DEVICE_TABLE(pci, cx18_pci_tbl); | |
65 | ||
66 | /* Parameter declarations */ | |
67 | static int cardtype[CX18_MAX_CARDS]; | |
68 | static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, | |
69 | -1, -1, -1, -1, -1, -1, -1, -1, | |
70 | -1, -1, -1, -1, -1, -1, -1, -1, | |
71 | -1, -1, -1, -1, -1, -1, -1, -1 }; | |
72 | static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, | |
73 | -1, -1, -1, -1, -1, -1, -1, -1, | |
74 | -1, -1, -1, -1, -1, -1, -1, -1, | |
75 | -1, -1, -1, -1, -1, -1, -1, -1 }; | |
76 | ||
77 | static int cardtype_c = 1; | |
78 | static int tuner_c = 1; | |
79 | static int radio_c = 1; | |
80 | static char pal[] = "--"; | |
81 | static char secam[] = "--"; | |
82 | static char ntsc[] = "-"; | |
83 | ||
84 | /* Buffers */ | |
85 | static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS; | |
86 | static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS; | |
87 | static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS; | |
88 | static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS; | |
89 | static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS; | |
90 | ||
91 | static int cx18_pci_latency = 1; | |
92 | ||
93 | int cx18_debug; | |
94 | ||
95 | module_param_array(tuner, int, &tuner_c, 0644); | |
96 | module_param_array(radio, bool, &radio_c, 0644); | |
97 | module_param_array(cardtype, int, &cardtype_c, 0644); | |
98 | module_param_string(pal, pal, sizeof(pal), 0644); | |
99 | module_param_string(secam, secam, sizeof(secam), 0644); | |
100 | module_param_string(ntsc, ntsc, sizeof(ntsc), 0644); | |
101 | module_param_named(debug, cx18_debug, int, 0644); | |
102 | module_param(cx18_pci_latency, int, 0644); | |
103 | module_param(cx18_first_minor, int, 0644); | |
104 | ||
105 | module_param(enc_mpg_buffers, int, 0644); | |
106 | module_param(enc_ts_buffers, int, 0644); | |
107 | module_param(enc_yuv_buffers, int, 0644); | |
108 | module_param(enc_vbi_buffers, int, 0644); | |
109 | module_param(enc_pcm_buffers, int, 0644); | |
110 | ||
111 | MODULE_PARM_DESC(tuner, "Tuner type selection,\n" | |
112 | "\t\t\tsee tuner.h for values"); | |
113 | MODULE_PARM_DESC(radio, | |
114 | "Enable or disable the radio. Use only if autodetection\n" | |
115 | "\t\t\tfails. 0 = disable, 1 = enable"); | |
116 | MODULE_PARM_DESC(cardtype, | |
117 | "Only use this option if your card is not detected properly.\n" | |
118 | "\t\tSpecify card type:\n" | |
119 | "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n" | |
120 | "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n" | |
121 | "\t\t\t 3 = Compro VideoMate H900\n" | |
122 | "\t\t\t 4 = Yuan MPC718\n" | |
03c28085 | 123 | "\t\t\t 5 = Conexant Raptor PAL/SECAM\n" |
1c1e45d1 HV |
124 | "\t\t\t 0 = Autodetect (default)\n" |
125 | "\t\t\t-1 = Ignore this card\n\t\t"); | |
126 | MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60"); | |
127 | MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC"); | |
128 | MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K"); | |
129 | MODULE_PARM_DESC(debug, | |
130 | "Debug level (bitmask). Default: 0\n" | |
131 | "\t\t\t 1/0x0001: warning\n" | |
132 | "\t\t\t 2/0x0002: info\n" | |
133 | "\t\t\t 4/0x0004: mailbox\n" | |
134 | "\t\t\t 8/0x0008: dma\n" | |
135 | "\t\t\t 16/0x0010: ioctl\n" | |
136 | "\t\t\t 32/0x0020: file\n" | |
137 | "\t\t\t 64/0x0040: i2c\n" | |
138 | "\t\t\t128/0x0080: irq\n" | |
139 | "\t\t\t256/0x0100: high volume\n"); | |
140 | MODULE_PARM_DESC(cx18_pci_latency, | |
141 | "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n" | |
142 | "\t\t\tDefault: Yes"); | |
143 | MODULE_PARM_DESC(enc_mpg_buffers, | |
144 | "Encoder MPG Buffers (in MB)\n" | |
145 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS)); | |
146 | MODULE_PARM_DESC(enc_ts_buffers, | |
147 | "Encoder TS Buffers (in MB)\n" | |
148 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS)); | |
149 | MODULE_PARM_DESC(enc_yuv_buffers, | |
150 | "Encoder YUV Buffers (in MB)\n" | |
151 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS)); | |
152 | MODULE_PARM_DESC(enc_vbi_buffers, | |
153 | "Encoder VBI Buffers (in MB)\n" | |
154 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS)); | |
155 | MODULE_PARM_DESC(enc_pcm_buffers, | |
156 | "Encoder PCM buffers (in MB)\n" | |
157 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS)); | |
158 | ||
159 | MODULE_PARM_DESC(cx18_first_minor, "Set minor assigned to first card"); | |
160 | ||
161 | MODULE_AUTHOR("Hans Verkuil"); | |
162 | MODULE_DESCRIPTION("CX23418 driver"); | |
163 | MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder"); | |
164 | MODULE_LICENSE("GPL"); | |
165 | ||
166 | MODULE_VERSION(CX18_VERSION); | |
167 | ||
1c1e45d1 HV |
168 | /* Generic utility functions */ |
169 | int cx18_msleep_timeout(unsigned int msecs, int intr) | |
170 | { | |
171 | int timeout = msecs_to_jiffies(msecs); | |
172 | int sig; | |
173 | ||
174 | do { | |
175 | set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE); | |
176 | timeout = schedule_timeout(timeout); | |
177 | sig = intr ? signal_pending(current) : 0; | |
178 | } while (!sig && timeout); | |
179 | return sig; | |
180 | } | |
181 | ||
182 | /* Release ioremapped memory */ | |
183 | static void cx18_iounmap(struct cx18 *cx) | |
184 | { | |
185 | if (cx == NULL) | |
186 | return; | |
187 | ||
188 | /* Release io memory */ | |
189 | if (cx->enc_mem != NULL) { | |
190 | CX18_DEBUG_INFO("releasing enc_mem\n"); | |
191 | iounmap(cx->enc_mem); | |
192 | cx->enc_mem = NULL; | |
193 | } | |
194 | } | |
195 | ||
196 | /* Hauppauge card? get values from tveeprom */ | |
197 | void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv) | |
198 | { | |
199 | u8 eedata[256]; | |
200 | ||
201 | cx->i2c_client[0].addr = 0xA0 >> 1; | |
202 | tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata)); | |
203 | tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata); | |
204 | } | |
205 | ||
206 | static void cx18_process_eeprom(struct cx18 *cx) | |
207 | { | |
208 | struct tveeprom tv; | |
209 | ||
210 | cx18_read_eeprom(cx, &tv); | |
211 | ||
212 | /* Many thanks to Steven Toth from Hauppauge for providing the | |
213 | model numbers */ | |
1d081601 HV |
214 | /* Note: the Samsung memory models cannot be reliably determined |
215 | from the model number. Use the cardtype module option if you | |
216 | have one of these preproduction models. */ | |
1c1e45d1 | 217 | switch (tv.model) { |
1d081601 | 218 | case 74000 ... 74999: |
1c1e45d1 HV |
219 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); |
220 | break; | |
1c1e45d1 HV |
221 | case 0: |
222 | CX18_ERR("Invalid EEPROM\n"); | |
223 | return; | |
224 | default: | |
225 | CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model); | |
226 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); | |
227 | break; | |
228 | } | |
229 | ||
230 | cx->v4l2_cap = cx->card->v4l2_capabilities; | |
231 | cx->card_name = cx->card->name; | |
232 | cx->card_i2c = cx->card->i2c; | |
233 | ||
234 | CX18_INFO("Autodetected %s\n", cx->card_name); | |
235 | ||
236 | if (tv.tuner_type == TUNER_ABSENT) | |
237 | CX18_ERR("tveeprom cannot autodetect tuner!"); | |
238 | ||
239 | if (cx->options.tuner == -1) | |
240 | cx->options.tuner = tv.tuner_type; | |
241 | if (cx->options.radio == -1) | |
242 | cx->options.radio = (tv.has_radio != 0); | |
243 | ||
244 | if (cx->std != 0) | |
245 | /* user specified tuner standard */ | |
246 | return; | |
247 | ||
248 | /* autodetect tuner standard */ | |
249 | if (tv.tuner_formats & V4L2_STD_PAL) { | |
250 | CX18_DEBUG_INFO("PAL tuner detected\n"); | |
251 | cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H; | |
252 | } else if (tv.tuner_formats & V4L2_STD_NTSC) { | |
253 | CX18_DEBUG_INFO("NTSC tuner detected\n"); | |
254 | cx->std |= V4L2_STD_NTSC_M; | |
255 | } else if (tv.tuner_formats & V4L2_STD_SECAM) { | |
256 | CX18_DEBUG_INFO("SECAM tuner detected\n"); | |
257 | cx->std |= V4L2_STD_SECAM_L; | |
258 | } else { | |
259 | CX18_INFO("No tuner detected, default to NTSC-M\n"); | |
260 | cx->std |= V4L2_STD_NTSC_M; | |
261 | } | |
262 | } | |
263 | ||
264 | static v4l2_std_id cx18_parse_std(struct cx18 *cx) | |
265 | { | |
266 | switch (pal[0]) { | |
267 | case '6': | |
268 | return V4L2_STD_PAL_60; | |
269 | case 'b': | |
270 | case 'B': | |
271 | case 'g': | |
272 | case 'G': | |
273 | return V4L2_STD_PAL_BG; | |
274 | case 'h': | |
275 | case 'H': | |
276 | return V4L2_STD_PAL_H; | |
277 | case 'n': | |
278 | case 'N': | |
279 | if (pal[1] == 'c' || pal[1] == 'C') | |
280 | return V4L2_STD_PAL_Nc; | |
281 | return V4L2_STD_PAL_N; | |
282 | case 'i': | |
283 | case 'I': | |
284 | return V4L2_STD_PAL_I; | |
285 | case 'd': | |
286 | case 'D': | |
287 | case 'k': | |
288 | case 'K': | |
289 | return V4L2_STD_PAL_DK; | |
290 | case 'M': | |
291 | case 'm': | |
292 | return V4L2_STD_PAL_M; | |
293 | case '-': | |
294 | break; | |
295 | default: | |
296 | CX18_WARN("pal= argument not recognised\n"); | |
297 | return 0; | |
298 | } | |
299 | ||
300 | switch (secam[0]) { | |
301 | case 'b': | |
302 | case 'B': | |
303 | case 'g': | |
304 | case 'G': | |
305 | case 'h': | |
306 | case 'H': | |
307 | return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H; | |
308 | case 'd': | |
309 | case 'D': | |
310 | case 'k': | |
311 | case 'K': | |
312 | return V4L2_STD_SECAM_DK; | |
313 | case 'l': | |
314 | case 'L': | |
315 | if (secam[1] == 'C' || secam[1] == 'c') | |
316 | return V4L2_STD_SECAM_LC; | |
317 | return V4L2_STD_SECAM_L; | |
318 | case '-': | |
319 | break; | |
320 | default: | |
321 | CX18_WARN("secam= argument not recognised\n"); | |
322 | return 0; | |
323 | } | |
324 | ||
325 | switch (ntsc[0]) { | |
326 | case 'm': | |
327 | case 'M': | |
328 | return V4L2_STD_NTSC_M; | |
329 | case 'j': | |
330 | case 'J': | |
331 | return V4L2_STD_NTSC_M_JP; | |
332 | case 'k': | |
333 | case 'K': | |
334 | return V4L2_STD_NTSC_M_KR; | |
335 | case '-': | |
336 | break; | |
337 | default: | |
338 | CX18_WARN("ntsc= argument not recognised\n"); | |
339 | return 0; | |
340 | } | |
341 | ||
342 | /* no match found */ | |
343 | return 0; | |
344 | } | |
345 | ||
346 | static void cx18_process_options(struct cx18 *cx) | |
347 | { | |
348 | int i, j; | |
349 | ||
350 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers; | |
351 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers; | |
352 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers; | |
353 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers; | |
354 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers; | |
355 | cx->options.cardtype = cardtype[cx->num]; | |
356 | cx->options.tuner = tuner[cx->num]; | |
357 | cx->options.radio = radio[cx->num]; | |
358 | ||
359 | cx->std = cx18_parse_std(cx); | |
360 | if (cx->options.cardtype == -1) { | |
361 | CX18_INFO("Ignore card\n"); | |
362 | return; | |
363 | } | |
364 | cx->card = cx18_get_card(cx->options.cardtype - 1); | |
365 | if (cx->card) | |
366 | CX18_INFO("User specified %s card\n", cx->card->name); | |
367 | else if (cx->options.cardtype != 0) | |
368 | CX18_ERR("Unknown user specified type, trying to autodetect card\n"); | |
369 | if (cx->card == NULL) { | |
370 | if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) { | |
371 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); | |
372 | CX18_INFO("Autodetected Hauppauge card\n"); | |
373 | } | |
374 | } | |
375 | if (cx->card == NULL) { | |
376 | for (i = 0; (cx->card = cx18_get_card(i)); i++) { | |
377 | if (cx->card->pci_list == NULL) | |
378 | continue; | |
379 | for (j = 0; cx->card->pci_list[j].device; j++) { | |
380 | if (cx->dev->device != | |
381 | cx->card->pci_list[j].device) | |
382 | continue; | |
383 | if (cx->dev->subsystem_vendor != | |
384 | cx->card->pci_list[j].subsystem_vendor) | |
385 | continue; | |
386 | if (cx->dev->subsystem_device != | |
387 | cx->card->pci_list[j].subsystem_device) | |
388 | continue; | |
389 | CX18_INFO("Autodetected %s card\n", cx->card->name); | |
390 | goto done; | |
391 | } | |
392 | } | |
393 | } | |
394 | done: | |
395 | ||
396 | if (cx->card == NULL) { | |
397 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); | |
398 | CX18_ERR("Unknown card: vendor/device: %04x/%04x\n", | |
399 | cx->dev->vendor, cx->dev->device); | |
400 | CX18_ERR(" subsystem vendor/device: %04x/%04x\n", | |
401 | cx->dev->subsystem_vendor, cx->dev->subsystem_device); | |
402 | CX18_ERR("Defaulting to %s card\n", cx->card->name); | |
403 | CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n"); | |
404 | CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n"); | |
405 | CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n"); | |
406 | } | |
407 | cx->v4l2_cap = cx->card->v4l2_capabilities; | |
408 | cx->card_name = cx->card->name; | |
409 | cx->card_i2c = cx->card->i2c; | |
410 | } | |
411 | ||
412 | /* Precondition: the cx18 structure has been memset to 0. Only | |
413 | the dev and num fields have been filled in. | |
414 | No assumptions on the card type may be made here (see cx18_init_struct2 | |
415 | for that). | |
416 | */ | |
417 | static int __devinit cx18_init_struct1(struct cx18 *cx) | |
418 | { | |
419 | cx->base_addr = pci_resource_start(cx->dev, 0); | |
420 | ||
421 | mutex_init(&cx->serialize_lock); | |
422 | mutex_init(&cx->i2c_bus_lock[0]); | |
423 | mutex_init(&cx->i2c_bus_lock[1]); | |
8abdd00d | 424 | mutex_init(&cx->gpio_lock); |
1c1e45d1 HV |
425 | |
426 | spin_lock_init(&cx->lock); | |
427 | spin_lock_init(&cx->dma_reg_lock); | |
428 | ||
429 | /* start counting open_id at 1 */ | |
430 | cx->open_id = 1; | |
431 | ||
432 | /* Initial settings */ | |
433 | cx2341x_fill_defaults(&cx->params); | |
434 | cx->temporal_strength = cx->params.video_temporal_filter; | |
435 | cx->spatial_strength = cx->params.video_spatial_filter; | |
436 | cx->filter_mode = cx->params.video_spatial_filter_mode | | |
437 | (cx->params.video_temporal_filter_mode << 1) | | |
438 | (cx->params.video_median_filter_type << 2); | |
439 | cx->params.port = CX2341X_PORT_MEMORY; | |
e8b934de | 440 | cx->params.capabilities = CX2341X_CAP_HAS_TS; |
1c1e45d1 HV |
441 | init_waitqueue_head(&cx->cap_w); |
442 | init_waitqueue_head(&cx->mb_apu_waitq); | |
443 | init_waitqueue_head(&cx->mb_cpu_waitq); | |
444 | init_waitqueue_head(&cx->mb_epu_waitq); | |
445 | init_waitqueue_head(&cx->mb_hpu_waitq); | |
446 | init_waitqueue_head(&cx->dma_waitq); | |
447 | ||
448 | /* VBI */ | |
449 | cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; | |
450 | cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced; | |
451 | cx->vbi.raw_size = 1456; | |
452 | cx->vbi.raw_decoder_line_size = 1456; | |
453 | cx->vbi.raw_decoder_sav_odd_field = 0x20; | |
454 | cx->vbi.raw_decoder_sav_even_field = 0x60; | |
455 | cx->vbi.sliced_decoder_line_size = 272; | |
456 | cx->vbi.sliced_decoder_sav_odd_field = 0xB0; | |
457 | cx->vbi.sliced_decoder_sav_even_field = 0xF0; | |
458 | return 0; | |
459 | } | |
460 | ||
461 | /* Second initialization part. Here the card type has been | |
462 | autodetected. */ | |
463 | static void __devinit cx18_init_struct2(struct cx18 *cx) | |
464 | { | |
465 | int i; | |
466 | ||
467 | for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++) | |
468 | if (cx->card->video_inputs[i].video_type == 0) | |
469 | break; | |
470 | cx->nof_inputs = i; | |
471 | for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++) | |
472 | if (cx->card->audio_inputs[i].audio_type == 0) | |
473 | break; | |
474 | cx->nof_audio_inputs = i; | |
475 | ||
476 | /* Find tuner input */ | |
477 | for (i = 0; i < cx->nof_inputs; i++) { | |
478 | if (cx->card->video_inputs[i].video_type == | |
479 | CX18_CARD_INPUT_VID_TUNER) | |
480 | break; | |
481 | } | |
482 | if (i == cx->nof_inputs) | |
483 | i = 0; | |
484 | cx->active_input = i; | |
485 | cx->audio_input = cx->card->video_inputs[i].audio_index; | |
486 | cx->av_state.vid_input = CX18_AV_COMPOSITE7; | |
487 | cx->av_state.aud_input = CX18_AV_AUDIO8; | |
488 | cx->av_state.audclk_freq = 48000; | |
489 | cx->av_state.audmode = V4L2_TUNER_MODE_LANG1; | |
490 | cx->av_state.vbi_line_offset = 8; | |
491 | } | |
492 | ||
493 | static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev, | |
494 | const struct pci_device_id *pci_id) | |
495 | { | |
496 | u16 cmd; | |
497 | unsigned char pci_latency; | |
498 | ||
499 | CX18_DEBUG_INFO("Enabling pci device\n"); | |
500 | ||
501 | if (pci_enable_device(dev)) { | |
502 | CX18_ERR("Can't enable device %d!\n", cx->num); | |
503 | return -EIO; | |
504 | } | |
505 | if (pci_set_dma_mask(dev, 0xffffffff)) { | |
506 | CX18_ERR("No suitable DMA available on card %d.\n", cx->num); | |
507 | return -EIO; | |
508 | } | |
509 | if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) { | |
510 | CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num); | |
511 | return -EIO; | |
512 | } | |
513 | ||
514 | /* Check for bus mastering */ | |
515 | pci_read_config_word(dev, PCI_COMMAND, &cmd); | |
516 | cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; | |
517 | pci_write_config_word(dev, PCI_COMMAND, cmd); | |
518 | ||
519 | pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev); | |
520 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency); | |
521 | ||
522 | if (pci_latency < 64 && cx18_pci_latency) { | |
523 | CX18_INFO("Unreasonably low latency timer, " | |
524 | "setting to 64 (was %d)\n", pci_latency); | |
525 | pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64); | |
526 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency); | |
527 | } | |
528 | /* This config space value relates to DMA latencies. The | |
529 | default value 0x8080 is too low however and will lead | |
530 | to DMA errors. 0xffff is the max value which solves | |
531 | these problems. */ | |
532 | pci_write_config_dword(dev, 0x40, 0xffff); | |
533 | ||
534 | CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, " | |
535 | "irq: %d, latency: %d, memory: 0x%lx\n", | |
536 | cx->dev->device, cx->card_rev, dev->bus->number, | |
537 | PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), | |
538 | cx->dev->irq, pci_latency, (unsigned long)cx->base_addr); | |
539 | ||
540 | return 0; | |
541 | } | |
542 | ||
6a4a7935 | 543 | #ifdef MODULE |
1c1e45d1 HV |
544 | static u32 cx18_request_module(struct cx18 *cx, u32 hw, |
545 | const char *name, u32 id) | |
546 | { | |
547 | if ((hw & id) == 0) | |
548 | return hw; | |
549 | if (request_module(name) != 0) { | |
550 | CX18_ERR("Failed to load module %s\n", name); | |
551 | return hw & ~id; | |
552 | } | |
553 | CX18_DEBUG_INFO("Loaded module %s\n", name); | |
554 | return hw; | |
555 | } | |
6a4a7935 | 556 | #endif |
1c1e45d1 HV |
557 | |
558 | static void cx18_load_and_init_modules(struct cx18 *cx) | |
559 | { | |
560 | u32 hw = cx->card->hw_all; | |
561 | int i; | |
562 | ||
6a4a7935 | 563 | #ifdef MODULE |
1c1e45d1 | 564 | /* load modules */ |
ff138171 | 565 | #ifndef CONFIG_MEDIA_TUNER |
1c1e45d1 HV |
566 | hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER); |
567 | #endif | |
568 | #ifndef CONFIG_VIDEO_CS5345 | |
569 | hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345); | |
6a4a7935 | 570 | #endif |
1c1e45d1 HV |
571 | #endif |
572 | ||
573 | /* check which i2c devices are actually found */ | |
574 | for (i = 0; i < 32; i++) { | |
575 | u32 device = 1 << i; | |
576 | ||
577 | if (!(device & hw)) | |
578 | continue; | |
579 | if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM || | |
580 | device == CX18_HW_CX23418 || device == CX18_HW_DVB) { | |
581 | /* These 'devices' do not use i2c probing */ | |
582 | cx->hw_flags |= device; | |
583 | continue; | |
584 | } | |
585 | cx18_i2c_register(cx, i); | |
586 | if (cx18_i2c_hw_addr(cx, device) > 0) | |
587 | cx->hw_flags |= device; | |
588 | } | |
589 | ||
590 | hw = cx->hw_flags; | |
591 | } | |
592 | ||
593 | static int __devinit cx18_probe(struct pci_dev *dev, | |
594 | const struct pci_device_id *pci_id) | |
595 | { | |
596 | int retval = 0; | |
597 | int vbi_buf_size; | |
598 | u32 devtype; | |
599 | struct cx18 *cx; | |
600 | ||
601 | spin_lock(&cx18_cards_lock); | |
602 | ||
603 | /* Make sure we've got a place for this card */ | |
604 | if (cx18_cards_active == CX18_MAX_CARDS) { | |
605 | printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n", | |
606 | cx18_cards_active); | |
607 | spin_unlock(&cx18_cards_lock); | |
608 | return -ENOMEM; | |
609 | } | |
610 | ||
611 | cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC); | |
cb6969e8 | 612 | if (!cx) { |
1c1e45d1 HV |
613 | spin_unlock(&cx18_cards_lock); |
614 | return -ENOMEM; | |
615 | } | |
616 | cx18_cards[cx18_cards_active] = cx; | |
617 | cx->dev = dev; | |
618 | cx->num = cx18_cards_active++; | |
b4ac3c8d | 619 | snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num); |
1c1e45d1 HV |
620 | CX18_INFO("Initializing card #%d\n", cx->num); |
621 | ||
622 | spin_unlock(&cx18_cards_lock); | |
623 | ||
624 | cx18_process_options(cx); | |
625 | if (cx->options.cardtype == -1) { | |
626 | retval = -ENODEV; | |
627 | goto err; | |
628 | } | |
629 | if (cx18_init_struct1(cx)) { | |
630 | retval = -ENOMEM; | |
631 | goto err; | |
632 | } | |
633 | ||
634 | CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr); | |
635 | ||
636 | /* PCI Device Setup */ | |
637 | retval = cx18_setup_pci(cx, dev, pci_id); | |
638 | if (retval != 0) { | |
639 | if (retval == -EIO) | |
640 | goto free_workqueue; | |
641 | else if (retval == -ENXIO) | |
642 | goto free_mem; | |
643 | } | |
644 | /* save cx in the pci struct for later use */ | |
645 | pci_set_drvdata(dev, cx); | |
646 | ||
647 | /* map io memory */ | |
648 | CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n", | |
649 | cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE); | |
650 | cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET, | |
651 | CX18_MEM_SIZE); | |
652 | if (!cx->enc_mem) { | |
653 | CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n"); | |
654 | CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n"); | |
655 | retval = -ENOMEM; | |
656 | goto free_mem; | |
657 | } | |
658 | cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET; | |
659 | devtype = read_reg(0xC72028); | |
660 | switch (devtype & 0xff000000) { | |
661 | case 0xff000000: | |
662 | CX18_INFO("cx23418 revision %08x (A)\n", devtype); | |
663 | break; | |
664 | case 0x01000000: | |
665 | CX18_INFO("cx23418 revision %08x (B)\n", devtype); | |
666 | break; | |
667 | default: | |
668 | CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype); | |
669 | break; | |
670 | } | |
671 | ||
672 | cx18_init_power(cx, 1); | |
673 | cx18_init_memory(cx); | |
674 | ||
990c81c8 | 675 | cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET); |
1c1e45d1 HV |
676 | cx18_init_scb(cx); |
677 | ||
678 | cx18_gpio_init(cx); | |
679 | ||
680 | /* active i2c */ | |
681 | CX18_DEBUG_INFO("activating i2c...\n"); | |
682 | if (init_cx18_i2c(cx)) { | |
683 | CX18_ERR("Could not initialize i2c\n"); | |
684 | goto free_map; | |
685 | } | |
686 | ||
687 | CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active); | |
688 | ||
689 | if (cx->card->hw_all & CX18_HW_TVEEPROM) { | |
690 | /* Based on the model number the cardtype may be changed. | |
691 | The PCI IDs are not always reliable. */ | |
692 | cx18_process_eeprom(cx); | |
693 | } | |
694 | if (cx->card->comment) | |
695 | CX18_INFO("%s", cx->card->comment); | |
696 | if (cx->card->v4l2_capabilities == 0) { | |
697 | retval = -ENODEV; | |
698 | goto free_i2c; | |
699 | } | |
700 | cx18_init_memory(cx); | |
701 | ||
702 | /* Register IRQ */ | |
703 | retval = request_irq(cx->dev->irq, cx18_irq_handler, | |
704 | IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx); | |
705 | if (retval) { | |
706 | CX18_ERR("Failed to register irq %d\n", retval); | |
707 | goto free_i2c; | |
708 | } | |
709 | ||
710 | if (cx->std == 0) | |
711 | cx->std = V4L2_STD_NTSC_M; | |
712 | ||
713 | if (cx->options.tuner == -1) { | |
714 | int i; | |
715 | ||
716 | for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) { | |
717 | if ((cx->std & cx->card->tuners[i].std) == 0) | |
718 | continue; | |
719 | cx->options.tuner = cx->card->tuners[i].tuner; | |
720 | break; | |
721 | } | |
722 | } | |
723 | /* if no tuner was found, then pick the first tuner in the card list */ | |
724 | if (cx->options.tuner == -1 && cx->card->tuners[0].std) { | |
725 | cx->std = cx->card->tuners[0].std; | |
c3cb4d95 HV |
726 | if (cx->std & V4L2_STD_PAL) |
727 | cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H; | |
728 | else if (cx->std & V4L2_STD_NTSC) | |
729 | cx->std = V4L2_STD_NTSC_M; | |
730 | else if (cx->std & V4L2_STD_SECAM) | |
731 | cx->std = V4L2_STD_SECAM_L; | |
1c1e45d1 HV |
732 | cx->options.tuner = cx->card->tuners[0].tuner; |
733 | } | |
734 | if (cx->options.radio == -1) | |
735 | cx->options.radio = (cx->card->radio_input.audio_type != 0); | |
736 | ||
737 | /* The card is now fully identified, continue with card-specific | |
738 | initialization. */ | |
739 | cx18_init_struct2(cx); | |
740 | ||
741 | cx18_load_and_init_modules(cx); | |
742 | ||
743 | if (cx->std & V4L2_STD_525_60) { | |
744 | cx->is_60hz = 1; | |
745 | cx->is_out_60hz = 1; | |
746 | } else { | |
747 | cx->is_50hz = 1; | |
748 | cx->is_out_50hz = 1; | |
749 | } | |
750 | cx->params.video_gop_size = cx->is_60hz ? 15 : 12; | |
751 | ||
752 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000; | |
753 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000; | |
754 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200; | |
755 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000; | |
756 | vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2; | |
757 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size; | |
758 | ||
759 | if (cx->options.radio > 0) | |
760 | cx->v4l2_cap |= V4L2_CAP_RADIO; | |
761 | ||
1c1e45d1 HV |
762 | if (cx->options.tuner > -1) { |
763 | struct tuner_setup setup; | |
764 | ||
765 | setup.addr = ADDR_UNSET; | |
766 | setup.type = cx->options.tuner; | |
767 | setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */ | |
768 | setup.tuner_callback = (setup.type == TUNER_XC2028) ? | |
769 | cx18_reset_tuner_gpio : NULL; | |
770 | cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup); | |
771 | if (setup.type == TUNER_XC2028) { | |
772 | static struct xc2028_ctrl ctrl = { | |
773 | .fname = XC2028_DEFAULT_FIRMWARE, | |
774 | .max_len = 64, | |
775 | }; | |
776 | struct v4l2_priv_tun_config cfg = { | |
777 | .tuner = cx->options.tuner, | |
778 | .priv = &ctrl, | |
779 | }; | |
780 | cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg); | |
781 | } | |
782 | } | |
783 | ||
784 | /* The tuner is fixed to the standard. The other inputs (e.g. S-Video) | |
785 | are not. */ | |
786 | cx->tuner_std = cx->std; | |
787 | ||
5e7fdc5e HV |
788 | retval = cx18_streams_setup(cx); |
789 | if (retval) { | |
790 | CX18_ERR("Error %d setting up streams\n", retval); | |
791 | goto free_irq; | |
792 | } | |
793 | retval = cx18_streams_register(cx); | |
794 | if (retval) { | |
795 | CX18_ERR("Error %d registering devices\n", retval); | |
796 | goto free_streams; | |
797 | } | |
1c1e45d1 HV |
798 | |
799 | CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name); | |
800 | ||
801 | return 0; | |
802 | ||
803 | free_streams: | |
3f98387e | 804 | cx18_streams_cleanup(cx, 1); |
1c1e45d1 HV |
805 | free_irq: |
806 | free_irq(cx->dev->irq, (void *)cx); | |
807 | free_i2c: | |
808 | exit_cx18_i2c(cx); | |
809 | free_map: | |
810 | cx18_iounmap(cx); | |
811 | free_mem: | |
812 | release_mem_region(cx->base_addr, CX18_MEM_SIZE); | |
813 | free_workqueue: | |
814 | err: | |
815 | if (retval == 0) | |
816 | retval = -ENODEV; | |
817 | CX18_ERR("Error %d on initialization\n", retval); | |
818 | ||
819 | kfree(cx18_cards[cx18_cards_active]); | |
820 | cx18_cards[cx18_cards_active] = NULL; | |
821 | return retval; | |
822 | } | |
823 | ||
824 | int cx18_init_on_first_open(struct cx18 *cx) | |
825 | { | |
826 | int video_input; | |
827 | int fw_retry_count = 3; | |
828 | struct v4l2_frequency vf; | |
3b6fe58f AW |
829 | struct cx18_open_id fh; |
830 | ||
831 | fh.cx = cx; | |
1c1e45d1 HV |
832 | |
833 | if (test_bit(CX18_F_I_FAILED, &cx->i_flags)) | |
834 | return -ENXIO; | |
835 | ||
836 | if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags)) | |
837 | return 0; | |
838 | ||
839 | while (--fw_retry_count > 0) { | |
840 | /* load firmware */ | |
841 | if (cx18_firmware_init(cx) == 0) | |
842 | break; | |
843 | if (fw_retry_count > 1) | |
844 | CX18_WARN("Retry loading firmware\n"); | |
845 | } | |
846 | ||
847 | if (fw_retry_count == 0) { | |
848 | set_bit(CX18_F_I_FAILED, &cx->i_flags); | |
849 | return -ENXIO; | |
850 | } | |
851 | set_bit(CX18_F_I_LOADED_FW, &cx->i_flags); | |
852 | ||
853 | /* Init the firmware twice to work around a silicon bug | |
854 | * transport related. */ | |
855 | ||
856 | fw_retry_count = 3; | |
857 | while (--fw_retry_count > 0) { | |
858 | /* load firmware */ | |
859 | if (cx18_firmware_init(cx) == 0) | |
860 | break; | |
861 | if (fw_retry_count > 1) | |
862 | CX18_WARN("Retry loading firmware\n"); | |
863 | } | |
864 | ||
865 | if (fw_retry_count == 0) { | |
866 | set_bit(CX18_F_I_FAILED, &cx->i_flags); | |
867 | return -ENXIO; | |
868 | } | |
869 | ||
870 | vf.tuner = 0; | |
871 | vf.type = V4L2_TUNER_ANALOG_TV; | |
872 | vf.frequency = 6400; /* the tuner 'baseline' frequency */ | |
873 | ||
874 | /* Set initial frequency. For PAL/SECAM broadcasts no | |
875 | 'default' channel exists AFAIK. */ | |
876 | if (cx->std == V4L2_STD_NTSC_M_JP) | |
877 | vf.frequency = 1460; /* ch. 1 91250*16/1000 */ | |
878 | else if (cx->std & V4L2_STD_NTSC_M) | |
879 | vf.frequency = 1076; /* ch. 4 67250*16/1000 */ | |
880 | ||
881 | video_input = cx->active_input; | |
882 | cx->active_input++; /* Force update of input */ | |
3b6fe58f | 883 | cx18_s_input(NULL, &fh, video_input); |
1c1e45d1 HV |
884 | |
885 | /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code | |
886 | in one place. */ | |
887 | cx->std++; /* Force full standard initialization */ | |
3b6fe58f AW |
888 | cx18_s_std(NULL, &fh, &cx->tuner_std); |
889 | cx18_s_frequency(NULL, &fh, &vf); | |
1c1e45d1 HV |
890 | return 0; |
891 | } | |
892 | ||
893 | static void cx18_remove(struct pci_dev *pci_dev) | |
894 | { | |
895 | struct cx18 *cx = pci_get_drvdata(pci_dev); | |
896 | ||
897 | CX18_DEBUG_INFO("Removing Card #%d\n", cx->num); | |
898 | ||
899 | /* Stop all captures */ | |
900 | CX18_DEBUG_INFO("Stopping all streams\n"); | |
31554ae5 | 901 | if (atomic_read(&cx->tot_capturing) > 0) |
1c1e45d1 HV |
902 | cx18_stop_all_captures(cx); |
903 | ||
904 | /* Interrupts */ | |
905 | sw1_irq_disable(IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU); | |
906 | sw2_irq_disable(IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK); | |
907 | ||
908 | cx18_halt_firmware(cx); | |
909 | ||
3f98387e | 910 | cx18_streams_cleanup(cx, 1); |
1c1e45d1 HV |
911 | |
912 | exit_cx18_i2c(cx); | |
913 | ||
914 | free_irq(cx->dev->irq, (void *)cx); | |
915 | ||
cba627a5 | 916 | cx18_iounmap(cx); |
1c1e45d1 HV |
917 | |
918 | release_mem_region(cx->base_addr, CX18_MEM_SIZE); | |
919 | ||
920 | pci_disable_device(cx->dev); | |
921 | ||
922 | CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num); | |
923 | } | |
924 | ||
925 | /* define a pci_driver for card detection */ | |
926 | static struct pci_driver cx18_pci_driver = { | |
927 | .name = "cx18", | |
928 | .id_table = cx18_pci_tbl, | |
929 | .probe = cx18_probe, | |
930 | .remove = cx18_remove, | |
931 | }; | |
932 | ||
933 | static int module_start(void) | |
934 | { | |
935 | printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION); | |
936 | ||
937 | memset(cx18_cards, 0, sizeof(cx18_cards)); | |
938 | ||
939 | /* Validate parameters */ | |
940 | if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) { | |
941 | printk(KERN_ERR "cx18: Exiting, ivtv_first_minor must be between 0 and %d\n", | |
942 | CX18_MAX_CARDS - 1); | |
943 | return -1; | |
944 | } | |
945 | ||
946 | if (cx18_debug < 0 || cx18_debug > 511) { | |
947 | cx18_debug = 0; | |
948 | printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n"); | |
949 | } | |
950 | ||
951 | if (pci_register_driver(&cx18_pci_driver)) { | |
952 | printk(KERN_ERR "cx18: Error detecting PCI card\n"); | |
953 | return -ENODEV; | |
954 | } | |
955 | printk(KERN_INFO "cx18: End initialization\n"); | |
956 | return 0; | |
957 | } | |
958 | ||
959 | static void module_cleanup(void) | |
960 | { | |
961 | int i; | |
962 | ||
963 | pci_unregister_driver(&cx18_pci_driver); | |
964 | ||
965 | for (i = 0; i < cx18_cards_active; i++) { | |
966 | if (cx18_cards[i] == NULL) | |
967 | continue; | |
968 | kfree(cx18_cards[i]); | |
969 | } | |
970 | } | |
971 | ||
972 | module_init(module_start); | |
973 | module_exit(module_cleanup); |