1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * cx18 driver initialization and card probing |
4 | * |
5 | * Derived from ivtv-driver.c |
6 | * |
7 | * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl> |
8 | * Copyright (C) 2008 Andy Walls <awalls@md.metrocast.net> |
9 | */ |
10 | |
11 | #include "cx18-driver.h" |
12 | #include "cx18-io.h" |
13 | #include "cx18-version.h" |
14 | #include "cx18-cards.h" |
15 | #include "cx18-i2c.h" |
16 | #include "cx18-irq.h" |
17 | #include "cx18-gpio.h" |
18 | #include "cx18-firmware.h" |
19 | #include "cx18-queue.h" |
20 | #include "cx18-streams.h" |
21 | #include "cx18-av-core.h" |
22 | #include "cx18-scb.h" |
23 | #include "cx18-mailbox.h" |
24 | #include "cx18-ioctl.h" |
25 | #include "cx18-controls.h" |
26 | #include "xc2028.h" |
27 | #include <linux/dma-mapping.h> |
28 | #include <media/tveeprom.h> |
29 | |
30 | /* If you have already X v4l cards, then set this to X. This way |
31 | the device numbers stay matched. Example: you have a WinTV card |
32 | without radio and a Compro H900 with. Normally this would give a |
33 | video1 device together with a radio0 device for the Compro. By |
34 | setting this to 1 you ensure that radio0 is now also radio1. */ |
35 | int cx18_first_minor; |
36 | |
37 | /* Callback for registering extensions */ |
38 | int (*cx18_ext_init)(struct cx18 *); |
39 | EXPORT_SYMBOL(cx18_ext_init); |
40 | |
41 | /* add your revision and whatnot here */ |
42 | static const struct pci_device_id cx18_pci_tbl[] = { |
43 | {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418, |
44 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, |
45 | {0,} |
46 | }; |
47 | |
48 | MODULE_DEVICE_TABLE(pci, cx18_pci_tbl); |
49 | |
50 | static atomic_t cx18_instance = ATOMIC_INIT(0); |
51 | |
52 | /* Parameter declarations */ |
53 | static int cardtype[CX18_MAX_CARDS]; |
54 | static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, |
55 | -1, -1, -1, -1, -1, -1, -1, -1, |
56 | -1, -1, -1, -1, -1, -1, -1, -1, |
57 | -1, -1, -1, -1, -1, -1, -1, -1 }; |
58 | static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1, |
59 | -1, -1, -1, -1, -1, -1, -1, -1, |
60 | -1, -1, -1, -1, -1, -1, -1, -1, |
61 | -1, -1, -1, -1, -1, -1, -1, -1 }; |
62 | static unsigned cardtype_c = 1; |
63 | static unsigned tuner_c = 1; |
64 | static unsigned radio_c = 1; |
65 | static char pal[] = "--" ; |
66 | static char secam[] = "--" ; |
67 | static char ntsc[] = "-" ; |
68 | |
69 | /* Buffers */ |
70 | static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS; |
71 | static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS; |
72 | static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS; |
73 | static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS; |
74 | static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS; |
75 | static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS; |
76 | |
77 | static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE; |
78 | static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE; |
79 | static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE; |
80 | static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE; |
81 | static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE; |
82 | |
83 | static int enc_ts_bufs = -1; |
84 | static int enc_mpg_bufs = -1; |
85 | static int enc_idx_bufs = CX18_MAX_FW_MDLS_PER_STREAM; |
86 | static int enc_yuv_bufs = -1; |
87 | static int enc_vbi_bufs = -1; |
88 | static int enc_pcm_bufs = -1; |
89 | |
90 | |
91 | static int cx18_pci_latency = 1; |
92 | |
93 | static int mmio_ndelay; |
94 | static int retry_mmio = 1; |
95 | |
96 | int cx18_debug; |
97 | |
98 | module_param_array(tuner, int, &tuner_c, 0644); |
99 | module_param_array(radio, int, &radio_c, 0644); |
100 | module_param_array(cardtype, int, &cardtype_c, 0644); |
101 | module_param_string(pal, pal, sizeof(pal), 0644); |
102 | module_param_string(secam, secam, sizeof(secam), 0644); |
103 | module_param_string(ntsc, ntsc, sizeof(ntsc), 0644); |
104 | module_param_named(debug, cx18_debug, int, 0644); |
105 | module_param(mmio_ndelay, int, 0644); |
106 | module_param(retry_mmio, int, 0644); |
107 | module_param(cx18_pci_latency, int, 0644); |
108 | module_param(cx18_first_minor, int, 0644); |
109 | |
110 | module_param(enc_ts_buffers, int, 0644); |
111 | module_param(enc_mpg_buffers, int, 0644); |
112 | module_param(enc_idx_buffers, int, 0644); |
113 | module_param(enc_yuv_buffers, int, 0644); |
114 | module_param(enc_vbi_buffers, int, 0644); |
115 | module_param(enc_pcm_buffers, int, 0644); |
116 | |
117 | module_param(enc_ts_bufsize, int, 0644); |
118 | module_param(enc_mpg_bufsize, int, 0644); |
119 | module_param(enc_idx_bufsize, int, 0644); |
120 | module_param(enc_yuv_bufsize, int, 0644); |
121 | module_param(enc_pcm_bufsize, int, 0644); |
122 | |
123 | module_param(enc_ts_bufs, int, 0644); |
124 | module_param(enc_mpg_bufs, int, 0644); |
125 | module_param(enc_idx_bufs, int, 0644); |
126 | module_param(enc_yuv_bufs, int, 0644); |
127 | module_param(enc_vbi_bufs, int, 0644); |
128 | module_param(enc_pcm_bufs, int, 0644); |
129 | |
130 | MODULE_PARM_DESC(tuner, "Tuner type selection,\n" |
131 | "\t\t\tsee tuner.h for values" ); |
132 | MODULE_PARM_DESC(radio, |
133 | "Enable or disable the radio. Use only if autodetection\n" |
134 | "\t\t\tfails. 0 = disable, 1 = enable" ); |
135 | MODULE_PARM_DESC(cardtype, |
136 | "Only use this option if your card is not detected properly.\n" |
137 | "\t\tSpecify card type:\n" |
138 | "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n" |
139 | "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n" |
140 | "\t\t\t 3 = Compro VideoMate H900\n" |
141 | "\t\t\t 4 = Yuan MPC718\n" |
142 | "\t\t\t 5 = Conexant Raptor PAL/SECAM\n" |
143 | "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n" |
144 | "\t\t\t 7 = Leadtek WinFast PVR2100\n" |
145 | "\t\t\t 8 = Leadtek WinFast DVR3100 H\n" |
146 | "\t\t\t 9 = GoTView PCI DVD3 Hybrid\n" |
147 | "\t\t\t 10 = Hauppauge HVR 1600 (S5H1411)\n" |
148 | "\t\t\t 0 = Autodetect (default)\n" |
149 | "\t\t\t-1 = Ignore this card\n\t\t" ); |
150 | MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60" ); |
151 | MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC" ); |
152 | MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K" ); |
153 | MODULE_PARM_DESC(debug, |
154 | "Debug level (bitmask). Default: 0\n" |
155 | "\t\t\t 1/0x0001: warning\n" |
156 | "\t\t\t 2/0x0002: info\n" |
157 | "\t\t\t 4/0x0004: mailbox\n" |
158 | "\t\t\t 8/0x0008: dma\n" |
159 | "\t\t\t 16/0x0010: ioctl\n" |
160 | "\t\t\t 32/0x0020: file\n" |
161 | "\t\t\t 64/0x0040: i2c\n" |
162 | "\t\t\t128/0x0080: irq\n" |
163 | "\t\t\t256/0x0100: high volume\n" ); |
164 | MODULE_PARM_DESC(cx18_pci_latency, |
165 | "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n" |
166 | "\t\t\tDefault: Yes" ); |
167 | MODULE_PARM_DESC(retry_mmio, |
168 | "(Deprecated) MMIO writes are now always checked and retried\n" |
169 | "\t\t\tEffectively: 1 [Yes]" ); |
170 | MODULE_PARM_DESC(mmio_ndelay, |
171 | "(Deprecated) MMIO accesses are now never purposely delayed\n" |
172 | "\t\t\tEffectively: 0 ns" ); |
173 | MODULE_PARM_DESC(enc_ts_buffers, |
174 | "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n" |
175 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS)); |
176 | MODULE_PARM_DESC(enc_ts_bufsize, |
177 | "Size of an encoder TS buffer (kB)\n" |
178 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE)); |
179 | MODULE_PARM_DESC(enc_ts_bufs, |
180 | "Number of encoder TS buffers\n" |
181 | "\t\t\tDefault is computed from other enc_ts_* parameters" ); |
182 | MODULE_PARM_DESC(enc_mpg_buffers, |
183 | "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n" |
184 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS)); |
185 | MODULE_PARM_DESC(enc_mpg_bufsize, |
186 | "Size of an encoder MPG buffer (kB)\n" |
187 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE)); |
188 | MODULE_PARM_DESC(enc_mpg_bufs, |
189 | "Number of encoder MPG buffers\n" |
190 | "\t\t\tDefault is computed from other enc_mpg_* parameters" ); |
191 | MODULE_PARM_DESC(enc_idx_buffers, |
192 | "(Deprecated) Encoder IDX buffer memory (MB)\n" |
193 | "\t\t\tIgnored, except 0 disables IDX buffer allocations\n" |
194 | "\t\t\tDefault: 1 [Enabled]" ); |
195 | MODULE_PARM_DESC(enc_idx_bufsize, |
196 | "Size of an encoder IDX buffer (kB)\n" |
197 | "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n" |
198 | "\t\t\t(multiples of size required for 64 index entries)\n" |
199 | "\t\t\tDefault: 2" ); |
200 | MODULE_PARM_DESC(enc_idx_bufs, |
201 | "Number of encoder IDX buffers\n" |
202 | "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM)); |
203 | MODULE_PARM_DESC(enc_yuv_buffers, |
204 | "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n" |
205 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS)); |
206 | MODULE_PARM_DESC(enc_yuv_bufsize, |
207 | "Size of an encoder YUV buffer (kB)\n" |
208 | "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n" |
209 | "\t\t\t(multiples of size required for 32 screen lines)\n" |
210 | "\t\t\tDefault: 102" ); |
211 | MODULE_PARM_DESC(enc_yuv_bufs, |
212 | "Number of encoder YUV buffers\n" |
213 | "\t\t\tDefault is computed from other enc_yuv_* parameters" ); |
214 | MODULE_PARM_DESC(enc_vbi_buffers, |
215 | "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n" |
216 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS)); |
217 | MODULE_PARM_DESC(enc_vbi_bufs, |
218 | "Number of encoder VBI buffers\n" |
219 | "\t\t\tDefault is computed from enc_vbi_buffers" ); |
220 | MODULE_PARM_DESC(enc_pcm_buffers, |
221 | "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n" |
222 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS)); |
223 | MODULE_PARM_DESC(enc_pcm_bufsize, |
224 | "Size of an encoder PCM buffer (kB)\n" |
225 | "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE)); |
226 | MODULE_PARM_DESC(enc_pcm_bufs, |
227 | "Number of encoder PCM buffers\n" |
228 | "\t\t\tDefault is computed from other enc_pcm_* parameters" ); |
229 | |
230 | MODULE_PARM_DESC(cx18_first_minor, |
231 | "Set device node number assigned to first card" ); |
232 | |
233 | MODULE_AUTHOR("Hans Verkuil" ); |
234 | MODULE_DESCRIPTION("CX23418 driver" ); |
235 | MODULE_LICENSE("GPL" ); |
236 | |
237 | MODULE_VERSION(CX18_VERSION); |
238 | |
239 | #if defined(CONFIG_MODULES) && defined(MODULE) |
240 | static void request_module_async(struct work_struct *work) |
241 | { |
242 | struct cx18 *dev = container_of(work, struct cx18, request_module_wk); |
243 | |
244 | /* Make sure cx18-alsa module is loaded */ |
245 | request_module("cx18-alsa" ); |
246 | |
247 | /* Initialize cx18-alsa for this instance of the cx18 device */ |
248 | if (cx18_ext_init) |
249 | cx18_ext_init(dev); |
250 | } |
251 | |
252 | static void request_modules(struct cx18 *dev) |
253 | { |
254 | INIT_WORK(&dev->request_module_wk, request_module_async); |
255 | schedule_work(&dev->request_module_wk); |
256 | } |
257 | |
258 | static void flush_request_modules(struct cx18 *dev) |
259 | { |
260 | flush_work(&dev->request_module_wk); |
261 | } |
262 | #else |
263 | #define request_modules(dev) |
264 | #define flush_request_modules(dev) |
265 | #endif /* CONFIG_MODULES */ |
266 | |
267 | /* Generic utility functions */ |
268 | int cx18_msleep_timeout(unsigned int msecs, int intr) |
269 | { |
270 | long int timeout = msecs_to_jiffies(m: msecs); |
271 | int sig; |
272 | |
273 | do { |
274 | set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE); |
275 | timeout = schedule_timeout(timeout); |
276 | sig = intr ? signal_pending(current) : 0; |
277 | } while (!sig && timeout); |
278 | return sig; |
279 | } |
280 | |
281 | /* Release ioremapped memory */ |
282 | static void cx18_iounmap(struct cx18 *cx) |
283 | { |
284 | if (!cx) |
285 | return; |
286 | |
287 | /* Release io memory */ |
288 | if (cx->enc_mem) { |
289 | CX18_DEBUG_INFO("releasing enc_mem\n" ); |
290 | iounmap(addr: cx->enc_mem); |
291 | cx->enc_mem = NULL; |
292 | } |
293 | } |
294 | |
295 | static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len) |
296 | { |
297 | int i; |
298 | |
299 | CX18_INFO("eeprom dump:\n" ); |
300 | for (i = 0; i < len; i++) { |
301 | if (0 == (i % 16)) |
302 | CX18_INFO("eeprom %02x:" , i); |
303 | printk(KERN_CONT " %02x" , eedata[i]); |
304 | if (15 == (i % 16)) |
305 | printk(KERN_CONT "\n" ); |
306 | } |
307 | } |
308 | |
309 | /* Hauppauge card? get values from tveeprom */ |
310 | void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv) |
311 | { |
312 | struct i2c_client *c; |
313 | u8 eedata[256]; |
314 | |
315 | memset(tv, 0, sizeof(*tv)); |
316 | |
317 | c = kzalloc(size: sizeof(*c), GFP_KERNEL); |
318 | if (!c) |
319 | return; |
320 | |
321 | strscpy(c->name, "cx18 tveeprom tmp" , sizeof(c->name)); |
322 | c->adapter = &cx->i2c_adap[0]; |
323 | c->addr = 0xa0 >> 1; |
324 | |
325 | if (tveeprom_read(c, eedata, len: sizeof(eedata))) |
326 | goto ret; |
327 | |
328 | switch (cx->card->type) { |
329 | case CX18_CARD_HVR_1600_ESMT: |
330 | case CX18_CARD_HVR_1600_SAMSUNG: |
331 | case CX18_CARD_HVR_1600_S5H1411: |
332 | tveeprom_hauppauge_analog(tvee: tv, eeprom_data: eedata); |
333 | break; |
334 | case CX18_CARD_YUAN_MPC718: |
335 | case CX18_CARD_GOTVIEW_PCI_DVD3: |
336 | tv->model = 0x718; |
337 | cx18_eeprom_dump(cx, eedata, len: sizeof(eedata)); |
338 | CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n" , |
339 | eedata[2], eedata[1], eedata[4], eedata[3]); |
340 | break; |
341 | default: |
342 | tv->model = 0xffffffff; |
343 | cx18_eeprom_dump(cx, eedata, len: sizeof(eedata)); |
344 | break; |
345 | } |
346 | |
347 | ret: |
348 | kfree(objp: c); |
349 | } |
350 | |
351 | static void cx18_process_eeprom(struct cx18 *cx) |
352 | { |
353 | struct tveeprom tv; |
354 | |
355 | cx18_read_eeprom(cx, tv: &tv); |
356 | |
357 | /* Many thanks to Steven Toth from Hauppauge for providing the |
358 | model numbers */ |
359 | /* Note: the Samsung memory models cannot be reliably determined |
360 | from the model number. Use the cardtype module option if you |
361 | have one of these preproduction models. */ |
362 | switch (tv.model) { |
363 | case 74301: /* Retail models */ |
364 | case 74321: |
365 | case 74351: /* OEM models */ |
366 | case 74361: |
367 | /* Digital side is s5h1411/tda18271 */ |
368 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_S5H1411); |
369 | break; |
370 | case 74021: /* Retail models */ |
371 | case 74031: |
372 | case 74041: |
373 | case 74141: |
374 | case 74541: /* OEM models */ |
375 | case 74551: |
376 | case 74591: |
377 | case 74651: |
378 | case 74691: |
379 | case 74751: |
380 | case 74891: |
381 | /* Digital side is s5h1409/mxl5005s */ |
382 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); |
383 | break; |
384 | case 0x718: |
385 | return; |
386 | case 0xffffffff: |
387 | CX18_INFO("Unknown EEPROM encoding\n" ); |
388 | return; |
389 | case 0: |
390 | CX18_ERR("Invalid EEPROM\n" ); |
391 | return; |
392 | default: |
393 | CX18_ERR("Unknown model %d, defaulting to original HVR-1600 (cardtype=1)\n" , |
394 | tv.model); |
395 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); |
396 | break; |
397 | } |
398 | |
399 | cx->v4l2_cap = cx->card->v4l2_capabilities; |
400 | cx->card_name = cx->card->name; |
401 | cx->card_i2c = cx->card->i2c; |
402 | |
403 | CX18_INFO("Autodetected %s\n" , cx->card_name); |
404 | |
405 | if (tv.tuner_type == TUNER_ABSENT) |
406 | CX18_ERR("tveeprom cannot autodetect tuner!\n" ); |
407 | |
408 | if (cx->options.tuner == -1) |
409 | cx->options.tuner = tv.tuner_type; |
410 | if (cx->options.radio == -1) |
411 | cx->options.radio = (tv.has_radio != 0); |
412 | |
413 | if (cx->std != 0) |
414 | /* user specified tuner standard */ |
415 | return; |
416 | |
417 | /* autodetect tuner standard */ |
418 | #define TVEEPROM_TUNER_FORMAT_ALL (V4L2_STD_B | V4L2_STD_GH | \ |
419 | V4L2_STD_MN | \ |
420 | V4L2_STD_PAL_I | \ |
421 | V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC | \ |
422 | V4L2_STD_DK) |
423 | if ((tv.tuner_formats & TVEEPROM_TUNER_FORMAT_ALL) |
424 | == TVEEPROM_TUNER_FORMAT_ALL) { |
425 | CX18_DEBUG_INFO("Worldwide tuner detected\n" ); |
426 | cx->std = V4L2_STD_ALL; |
427 | } else if (tv.tuner_formats & V4L2_STD_PAL) { |
428 | CX18_DEBUG_INFO("PAL tuner detected\n" ); |
429 | cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H; |
430 | } else if (tv.tuner_formats & V4L2_STD_NTSC) { |
431 | CX18_DEBUG_INFO("NTSC tuner detected\n" ); |
432 | cx->std |= V4L2_STD_NTSC_M; |
433 | } else if (tv.tuner_formats & V4L2_STD_SECAM) { |
434 | CX18_DEBUG_INFO("SECAM tuner detected\n" ); |
435 | cx->std |= V4L2_STD_SECAM_L; |
436 | } else { |
437 | CX18_INFO("No tuner detected, default to NTSC-M\n" ); |
438 | cx->std |= V4L2_STD_NTSC_M; |
439 | } |
440 | } |
441 | |
442 | static v4l2_std_id cx18_parse_std(struct cx18 *cx) |
443 | { |
444 | switch (pal[0]) { |
445 | case '6': |
446 | return V4L2_STD_PAL_60; |
447 | case 'b': |
448 | case 'B': |
449 | case 'g': |
450 | case 'G': |
451 | return V4L2_STD_PAL_BG; |
452 | case 'h': |
453 | case 'H': |
454 | return V4L2_STD_PAL_H; |
455 | case 'n': |
456 | case 'N': |
457 | if (pal[1] == 'c' || pal[1] == 'C') |
458 | return V4L2_STD_PAL_Nc; |
459 | return V4L2_STD_PAL_N; |
460 | case 'i': |
461 | case 'I': |
462 | return V4L2_STD_PAL_I; |
463 | case 'd': |
464 | case 'D': |
465 | case 'k': |
466 | case 'K': |
467 | return V4L2_STD_PAL_DK; |
468 | case 'M': |
469 | case 'm': |
470 | return V4L2_STD_PAL_M; |
471 | case '-': |
472 | break; |
473 | default: |
474 | CX18_WARN("pal= argument not recognised\n" ); |
475 | return 0; |
476 | } |
477 | |
478 | switch (secam[0]) { |
479 | case 'b': |
480 | case 'B': |
481 | case 'g': |
482 | case 'G': |
483 | case 'h': |
484 | case 'H': |
485 | return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H; |
486 | case 'd': |
487 | case 'D': |
488 | case 'k': |
489 | case 'K': |
490 | return V4L2_STD_SECAM_DK; |
491 | case 'l': |
492 | case 'L': |
493 | if (secam[1] == 'C' || secam[1] == 'c') |
494 | return V4L2_STD_SECAM_LC; |
495 | return V4L2_STD_SECAM_L; |
496 | case '-': |
497 | break; |
498 | default: |
499 | CX18_WARN("secam= argument not recognised\n" ); |
500 | return 0; |
501 | } |
502 | |
503 | switch (ntsc[0]) { |
504 | case 'm': |
505 | case 'M': |
506 | return V4L2_STD_NTSC_M; |
507 | case 'j': |
508 | case 'J': |
509 | return V4L2_STD_NTSC_M_JP; |
510 | case 'k': |
511 | case 'K': |
512 | return V4L2_STD_NTSC_M_KR; |
513 | case '-': |
514 | break; |
515 | default: |
516 | CX18_WARN("ntsc= argument not recognised\n" ); |
517 | return 0; |
518 | } |
519 | |
520 | /* no match found */ |
521 | return 0; |
522 | } |
523 | |
524 | static void cx18_process_options(struct cx18 *cx) |
525 | { |
526 | int i, j; |
527 | |
528 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers; |
529 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers; |
530 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers; |
531 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers; |
532 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers; |
533 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers; |
534 | cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */ |
535 | |
536 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs; |
537 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs; |
538 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs; |
539 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs; |
540 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs; |
541 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs; |
542 | cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */ |
543 | |
544 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize; |
545 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize; |
546 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize; |
547 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize; |
548 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = VBI_ACTIVE_SAMPLES * 36; |
549 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize; |
550 | cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */ |
551 | |
552 | /* Ensure stream_buffers & stream_buf_size are valid */ |
553 | for (i = 0; i < CX18_MAX_STREAMS; i++) { |
554 | if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */ |
555 | cx->options.megabytes[i] <= 0 || /* User said 0 MB total */ |
556 | cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */ |
557 | cx->options.megabytes[i] = 0; |
558 | cx->stream_buffers[i] = 0; |
559 | cx->stream_buf_size[i] = 0; |
560 | continue; |
561 | } |
562 | /* |
563 | * YUV is a special case where the stream_buf_size needs to be |
564 | * an integral multiple of 33.75 kB (storage for 32 screens |
565 | * lines to maintain alignment in case of lost buffers). |
566 | * |
567 | * IDX is a special case where the stream_buf_size should be |
568 | * an integral multiple of 1.5 kB (storage for 64 index entries |
569 | * to maintain alignment in case of lost buffers). |
570 | * |
571 | */ |
572 | if (i == CX18_ENC_STREAM_TYPE_YUV) { |
573 | cx->stream_buf_size[i] *= 1024; |
574 | cx->stream_buf_size[i] -= |
575 | (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE); |
576 | |
577 | if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE) |
578 | cx->stream_buf_size[i] = |
579 | CX18_UNIT_ENC_YUV_BUFSIZE; |
580 | } else if (i == CX18_ENC_STREAM_TYPE_IDX) { |
581 | cx->stream_buf_size[i] *= 1024; |
582 | cx->stream_buf_size[i] -= |
583 | (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE); |
584 | |
585 | if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE) |
586 | cx->stream_buf_size[i] = |
587 | CX18_UNIT_ENC_IDX_BUFSIZE; |
588 | } |
589 | /* |
590 | * YUV and IDX are special cases where the stream_buf_size is |
591 | * now in bytes. |
592 | * VBI is a special case where the stream_buf_size is fixed |
593 | * and already in bytes |
594 | */ |
595 | if (i == CX18_ENC_STREAM_TYPE_VBI || |
596 | i == CX18_ENC_STREAM_TYPE_YUV || |
597 | i == CX18_ENC_STREAM_TYPE_IDX) { |
598 | if (cx->stream_buffers[i] < 0) { |
599 | cx->stream_buffers[i] = |
600 | cx->options.megabytes[i] * 1024 * 1024 |
601 | / cx->stream_buf_size[i]; |
602 | } else { |
603 | /* N.B. This might round down to 0 */ |
604 | cx->options.megabytes[i] = |
605 | cx->stream_buffers[i] |
606 | * cx->stream_buf_size[i]/(1024 * 1024); |
607 | } |
608 | } else { |
609 | /* All other streams have stream_buf_size in kB here */ |
610 | if (cx->stream_buffers[i] < 0) { |
611 | cx->stream_buffers[i] = |
612 | cx->options.megabytes[i] * 1024 |
613 | / cx->stream_buf_size[i]; |
614 | } else { |
615 | /* N.B. This might round down to 0 */ |
616 | cx->options.megabytes[i] = |
617 | cx->stream_buffers[i] |
618 | * cx->stream_buf_size[i] / 1024; |
619 | } |
620 | /* convert from kB to bytes */ |
621 | cx->stream_buf_size[i] *= 1024; |
622 | } |
623 | CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, %d bytes\n" , |
624 | i, cx->options.megabytes[i], |
625 | cx->stream_buffers[i], cx->stream_buf_size[i]); |
626 | } |
627 | |
628 | cx->options.cardtype = cardtype[cx->instance]; |
629 | cx->options.tuner = tuner[cx->instance]; |
630 | cx->options.radio = radio[cx->instance]; |
631 | |
632 | cx->std = cx18_parse_std(cx); |
633 | if (cx->options.cardtype == -1) { |
634 | CX18_INFO("Ignore card\n" ); |
635 | return; |
636 | } |
637 | cx->card = cx18_get_card(index: cx->options.cardtype - 1); |
638 | if (cx->card) |
639 | CX18_INFO("User specified %s card\n" , cx->card->name); |
640 | else if (cx->options.cardtype != 0) |
641 | CX18_ERR("Unknown user specified type, trying to autodetect card\n" ); |
642 | if (!cx->card) { |
643 | if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) { |
644 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); |
645 | CX18_INFO("Autodetected Hauppauge card\n" ); |
646 | } |
647 | } |
648 | if (!cx->card) { |
649 | for (i = 0; (cx->card = cx18_get_card(index: i)); i++) { |
650 | if (!cx->card->pci_list) |
651 | continue; |
652 | for (j = 0; cx->card->pci_list[j].device; j++) { |
653 | if (cx->pci_dev->device != |
654 | cx->card->pci_list[j].device) |
655 | continue; |
656 | if (cx->pci_dev->subsystem_vendor != |
657 | cx->card->pci_list[j].subsystem_vendor) |
658 | continue; |
659 | if (cx->pci_dev->subsystem_device != |
660 | cx->card->pci_list[j].subsystem_device) |
661 | continue; |
662 | CX18_INFO("Autodetected %s card\n" , cx->card->name); |
663 | goto done; |
664 | } |
665 | } |
666 | } |
667 | done: |
668 | |
669 | if (!cx->card) { |
670 | cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT); |
671 | CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n" , |
672 | cx->pci_dev->vendor, cx->pci_dev->device); |
673 | CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n" , |
674 | cx->pci_dev->subsystem_vendor, |
675 | cx->pci_dev->subsystem_device); |
676 | CX18_ERR("Defaulting to %s card\n" , cx->card->name); |
677 | CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n" ); |
678 | CX18_ERR("card you have to the linux-media mailinglist (www.linuxtv.org)\n" ); |
679 | CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n" ); |
680 | } |
681 | cx->v4l2_cap = cx->card->v4l2_capabilities; |
682 | cx->card_name = cx->card->name; |
683 | cx->card_i2c = cx->card->i2c; |
684 | } |
685 | |
686 | static int cx18_create_in_workq(struct cx18 *cx) |
687 | { |
688 | snprintf(buf: cx->in_workq_name, size: sizeof(cx->in_workq_name), fmt: "%s-in" , |
689 | cx->v4l2_dev.name); |
690 | cx->in_work_queue = alloc_ordered_workqueue("%s" , 0, cx->in_workq_name); |
691 | if (!cx->in_work_queue) { |
692 | CX18_ERR("Unable to create incoming mailbox handler thread\n" ); |
693 | return -ENOMEM; |
694 | } |
695 | return 0; |
696 | } |
697 | |
698 | static void cx18_init_in_work_orders(struct cx18 *cx) |
699 | { |
700 | int i; |
701 | for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) { |
702 | cx->in_work_order[i].cx = cx; |
703 | cx->in_work_order[i].str = cx->epu_debug_str; |
704 | INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler); |
705 | } |
706 | } |
707 | |
708 | /* Precondition: the cx18 structure has been memset to 0. Only |
709 | the dev and instance fields have been filled in. |
710 | No assumptions on the card type may be made here (see cx18_init_struct2 |
711 | for that). |
712 | */ |
713 | static int cx18_init_struct1(struct cx18 *cx) |
714 | { |
715 | int ret; |
716 | |
717 | cx->base_addr = pci_resource_start(cx->pci_dev, 0); |
718 | |
719 | mutex_init(&cx->serialize_lock); |
720 | mutex_init(&cx->gpio_lock); |
721 | mutex_init(&cx->epu2apu_mb_lock); |
722 | mutex_init(&cx->epu2cpu_mb_lock); |
723 | |
724 | ret = cx18_create_in_workq(cx); |
725 | if (ret) |
726 | return ret; |
727 | |
728 | cx18_init_in_work_orders(cx); |
729 | |
730 | /* start counting open_id at 1 */ |
731 | cx->open_id = 1; |
732 | |
733 | /* Initial settings */ |
734 | cx->cxhdl.port = CX2341X_PORT_MEMORY; |
735 | cx->cxhdl.capabilities = CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI; |
736 | cx->cxhdl.ops = &cx18_cxhdl_ops; |
737 | cx->cxhdl.func = cx18_api_func; |
738 | cx->cxhdl.priv = &cx->streams[CX18_ENC_STREAM_TYPE_MPG]; |
739 | ret = cx2341x_handler_init(cxhdl: &cx->cxhdl, nr_of_controls_hint: 50); |
740 | if (ret) |
741 | return ret; |
742 | cx->v4l2_dev.ctrl_handler = &cx->cxhdl.hdl; |
743 | |
744 | cx->temporal_strength = cx->cxhdl.video_temporal_filter->cur.val; |
745 | cx->spatial_strength = cx->cxhdl.video_spatial_filter->cur.val; |
746 | cx->filter_mode = cx->cxhdl.video_spatial_filter_mode->cur.val | |
747 | (cx->cxhdl.video_temporal_filter_mode->cur.val << 1) | |
748 | (cx->cxhdl.video_median_filter_type->cur.val << 2); |
749 | |
750 | init_waitqueue_head(&cx->cap_w); |
751 | init_waitqueue_head(&cx->mb_apu_waitq); |
752 | init_waitqueue_head(&cx->mb_cpu_waitq); |
753 | init_waitqueue_head(&cx->dma_waitq); |
754 | |
755 | /* VBI */ |
756 | cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE; |
757 | cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced; |
758 | |
759 | /* IVTV style VBI insertion into MPEG streams */ |
760 | INIT_LIST_HEAD(list: &cx->vbi.sliced_mpeg_buf.list); |
761 | INIT_LIST_HEAD(list: &cx->vbi.sliced_mpeg_mdl.list); |
762 | INIT_LIST_HEAD(list: &cx->vbi.sliced_mpeg_mdl.buf_list); |
763 | list_add(new: &cx->vbi.sliced_mpeg_buf.list, |
764 | head: &cx->vbi.sliced_mpeg_mdl.buf_list); |
765 | return 0; |
766 | } |
767 | |
768 | /* Second initialization part. Here the card type has been |
769 | autodetected. */ |
770 | static void cx18_init_struct2(struct cx18 *cx) |
771 | { |
772 | int i; |
773 | |
774 | for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++) |
775 | if (cx->card->video_inputs[i].video_type == 0) |
776 | break; |
777 | cx->nof_inputs = i; |
778 | for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++) |
779 | if (cx->card->audio_inputs[i].audio_type == 0) |
780 | break; |
781 | cx->nof_audio_inputs = i; |
782 | |
783 | /* Find tuner input */ |
784 | for (i = 0; i < cx->nof_inputs; i++) { |
785 | if (cx->card->video_inputs[i].video_type == |
786 | CX18_CARD_INPUT_VID_TUNER) |
787 | break; |
788 | } |
789 | if (i == cx->nof_inputs) |
790 | i = 0; |
791 | cx->active_input = i; |
792 | cx->audio_input = cx->card->video_inputs[i].audio_index; |
793 | } |
794 | |
795 | static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev, |
796 | const struct pci_device_id *pci_id) |
797 | { |
798 | u16 cmd; |
799 | unsigned char pci_latency; |
800 | |
801 | CX18_DEBUG_INFO("Enabling pci device\n" ); |
802 | |
803 | if (pci_enable_device(dev: pci_dev)) { |
804 | CX18_ERR("Can't enable device %d!\n" , cx->instance); |
805 | return -EIO; |
806 | } |
807 | if (dma_set_mask(dev: &pci_dev->dev, DMA_BIT_MASK(32))) { |
808 | CX18_ERR("No suitable DMA available, card %d\n" , cx->instance); |
809 | return -EIO; |
810 | } |
811 | if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder" )) { |
812 | CX18_ERR("Cannot request encoder memory region, card %d\n" , |
813 | cx->instance); |
814 | return -EIO; |
815 | } |
816 | |
817 | /* Enable bus mastering and memory mapped IO for the CX23418 */ |
818 | pci_read_config_word(dev: pci_dev, PCI_COMMAND, val: &cmd); |
819 | cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; |
820 | pci_write_config_word(dev: pci_dev, PCI_COMMAND, val: cmd); |
821 | |
822 | cx->card_rev = pci_dev->revision; |
823 | pci_read_config_byte(dev: pci_dev, PCI_LATENCY_TIMER, val: &pci_latency); |
824 | |
825 | if (pci_latency < 64 && cx18_pci_latency) { |
826 | CX18_INFO("Unreasonably low latency timer, setting to 64 (was %d)\n" , |
827 | pci_latency); |
828 | pci_write_config_byte(dev: pci_dev, PCI_LATENCY_TIMER, val: 64); |
829 | pci_read_config_byte(dev: pci_dev, PCI_LATENCY_TIMER, val: &pci_latency); |
830 | } |
831 | |
832 | CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, irq: %d, latency: %d, memory: 0x%llx\n" , |
833 | cx->pci_dev->device, cx->card_rev, pci_dev->bus->number, |
834 | PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn), |
835 | cx->pci_dev->irq, pci_latency, (u64)cx->base_addr); |
836 | |
837 | return 0; |
838 | } |
839 | |
840 | static void cx18_init_subdevs(struct cx18 *cx) |
841 | { |
842 | u32 hw = cx->card->hw_all; |
843 | u32 device; |
844 | int i; |
845 | |
846 | for (i = 0, device = 1; i < 32; i++, device <<= 1) { |
847 | |
848 | if (!(device & hw)) |
849 | continue; |
850 | |
851 | switch (device) { |
852 | case CX18_HW_DVB: |
853 | case CX18_HW_TVEEPROM: |
854 | /* These subordinate devices do not use probing */ |
855 | cx->hw_flags |= device; |
856 | break; |
857 | case CX18_HW_418_AV: |
858 | /* The A/V decoder gets probed earlier to set PLLs */ |
859 | /* Just note that the card uses it (i.e. has analog) */ |
860 | cx->hw_flags |= device; |
861 | break; |
862 | case CX18_HW_GPIO_RESET_CTRL: |
863 | /* |
864 | * The Reset Controller gets probed and added to |
865 | * hw_flags earlier for i2c adapter/bus initialization |
866 | */ |
867 | break; |
868 | case CX18_HW_GPIO_MUX: |
869 | if (cx18_gpio_register(cx, hw: device) == 0) |
870 | cx->hw_flags |= device; |
871 | break; |
872 | default: |
873 | if (cx18_i2c_register(cx, idx: i) == 0) |
874 | cx->hw_flags |= device; |
875 | break; |
876 | } |
877 | } |
878 | |
879 | if (cx->hw_flags & CX18_HW_418_AV) |
880 | cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV); |
881 | |
882 | if (cx->card->hw_muxer != 0) |
883 | cx->sd_extmux = cx18_find_hw(cx, hw: cx->card->hw_muxer); |
884 | } |
885 | |
886 | static int cx18_probe(struct pci_dev *pci_dev, |
887 | const struct pci_device_id *pci_id) |
888 | { |
889 | int retval = 0; |
890 | int i; |
891 | u32 devtype; |
892 | struct cx18 *cx; |
893 | |
894 | /* FIXME - module parameter arrays constrain max instances */ |
895 | i = atomic_inc_return(v: &cx18_instance) - 1; |
896 | if (i >= CX18_MAX_CARDS) { |
897 | printk(KERN_ERR "cx18: cannot manage card %d, driver has a limit of 0 - %d\n" , |
898 | i, CX18_MAX_CARDS - 1); |
899 | return -ENOMEM; |
900 | } |
901 | |
902 | cx = kzalloc(size: sizeof(*cx), GFP_KERNEL); |
903 | if (!cx) |
904 | return -ENOMEM; |
905 | |
906 | cx->pci_dev = pci_dev; |
907 | cx->instance = i; |
908 | |
909 | retval = v4l2_device_register(dev: &pci_dev->dev, v4l2_dev: &cx->v4l2_dev); |
910 | if (retval) { |
911 | printk(KERN_ERR "cx18: v4l2_device_register of card %d failed\n" , |
912 | cx->instance); |
913 | kfree(objp: cx); |
914 | return retval; |
915 | } |
916 | snprintf(buf: cx->v4l2_dev.name, size: sizeof(cx->v4l2_dev.name), fmt: "cx18-%d" , |
917 | cx->instance); |
918 | CX18_INFO("Initializing card %d\n" , cx->instance); |
919 | |
920 | cx18_process_options(cx); |
921 | if (cx->options.cardtype == -1) { |
922 | retval = -ENODEV; |
923 | goto err; |
924 | } |
925 | |
926 | retval = cx18_init_struct1(cx); |
927 | if (retval) |
928 | goto err; |
929 | |
930 | CX18_DEBUG_INFO("base addr: 0x%llx\n" , (u64)cx->base_addr); |
931 | |
932 | /* PCI Device Setup */ |
933 | retval = cx18_setup_pci(cx, pci_dev, pci_id); |
934 | if (retval != 0) |
935 | goto free_workqueues; |
936 | |
937 | /* map io memory */ |
938 | CX18_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n" , |
939 | (u64)cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE); |
940 | cx->enc_mem = ioremap(offset: cx->base_addr + CX18_MEM_OFFSET, |
941 | CX18_MEM_SIZE); |
942 | if (!cx->enc_mem) { |
943 | CX18_ERR("ioremap failed. Can't get a window into CX23418 memory and register space\n" ); |
944 | CX18_ERR("Each capture card with a CX23418 needs 64 MB of vmalloc address space for the window\n" ); |
945 | CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n" ); |
946 | CX18_ERR("Use the vmalloc= kernel command line option to set VmallocTotal to a larger value\n" ); |
947 | retval = -ENOMEM; |
948 | goto free_mem; |
949 | } |
950 | cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET; |
951 | devtype = cx18_read_reg(cx, reg: 0xC72028); |
952 | switch (devtype & 0xff000000) { |
953 | case 0xff000000: |
954 | CX18_INFO("cx23418 revision %08x (A)\n" , devtype); |
955 | break; |
956 | case 0x01000000: |
957 | CX18_INFO("cx23418 revision %08x (B)\n" , devtype); |
958 | break; |
959 | default: |
960 | CX18_INFO("cx23418 revision %08x (Unknown)\n" , devtype); |
961 | break; |
962 | } |
963 | |
964 | cx18_init_power(cx, lowpwr: 1); |
965 | cx18_init_memory(cx); |
966 | |
967 | cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET); |
968 | cx18_init_scb(cx); |
969 | |
970 | cx18_gpio_init(cx); |
971 | |
972 | /* Initialize integrated A/V decoder early to set PLLs, just in case */ |
973 | retval = cx18_av_probe(cx); |
974 | if (retval) { |
975 | CX18_ERR("Could not register A/V decoder subdevice\n" ); |
976 | goto free_map; |
977 | } |
978 | |
979 | /* Initialize GPIO Reset Controller to do chip resets during i2c init */ |
980 | if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) { |
981 | if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0) |
982 | CX18_WARN("Could not register GPIO reset controllersubdevice; proceeding anyway.\n" ); |
983 | else |
984 | cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL; |
985 | } |
986 | |
987 | /* active i2c */ |
988 | CX18_DEBUG_INFO("activating i2c...\n" ); |
989 | retval = init_cx18_i2c(cx); |
990 | if (retval) { |
991 | CX18_ERR("Could not initialize i2c\n" ); |
992 | goto free_map; |
993 | } |
994 | |
995 | if (cx->card->hw_all & CX18_HW_TVEEPROM) { |
996 | /* Based on the model number the cardtype may be changed. |
997 | The PCI IDs are not always reliable. */ |
998 | const struct cx18_card *orig_card = cx->card; |
999 | cx18_process_eeprom(cx); |
1000 | |
1001 | if (cx->card != orig_card) { |
1002 | /* Changed the cardtype; re-reset the I2C chips */ |
1003 | cx18_gpio_init(cx); |
1004 | cx18_call_hw(cx, CX18_HW_GPIO_RESET_CTRL, |
1005 | core, reset, (u32) CX18_GPIO_RESET_I2C); |
1006 | } |
1007 | } |
1008 | if (cx->card->comment) |
1009 | CX18_INFO("%s" , cx->card->comment); |
1010 | if (cx->card->v4l2_capabilities == 0) { |
1011 | retval = -ENODEV; |
1012 | goto free_i2c; |
1013 | } |
1014 | cx18_init_memory(cx); |
1015 | cx18_init_scb(cx); |
1016 | |
1017 | /* Register IRQ */ |
1018 | retval = request_irq(irq: cx->pci_dev->irq, handler: cx18_irq_handler, |
1019 | IRQF_SHARED, name: cx->v4l2_dev.name, dev: (void *)cx); |
1020 | if (retval) { |
1021 | CX18_ERR("Failed to register irq %d\n" , retval); |
1022 | goto free_i2c; |
1023 | } |
1024 | |
1025 | if (cx->std == 0) |
1026 | cx->std = V4L2_STD_NTSC_M; |
1027 | |
1028 | if (cx->options.tuner == -1) { |
1029 | for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) { |
1030 | if ((cx->std & cx->card->tuners[i].std) == 0) |
1031 | continue; |
1032 | cx->options.tuner = cx->card->tuners[i].tuner; |
1033 | break; |
1034 | } |
1035 | } |
1036 | /* if no tuner was found, then pick the first tuner in the card list */ |
1037 | if (cx->options.tuner == -1 && cx->card->tuners[0].std) { |
1038 | cx->std = cx->card->tuners[0].std; |
1039 | if (cx->std & V4L2_STD_PAL) |
1040 | cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H; |
1041 | else if (cx->std & V4L2_STD_NTSC) |
1042 | cx->std = V4L2_STD_NTSC_M; |
1043 | else if (cx->std & V4L2_STD_SECAM) |
1044 | cx->std = V4L2_STD_SECAM_L; |
1045 | cx->options.tuner = cx->card->tuners[0].tuner; |
1046 | } |
1047 | if (cx->options.radio == -1) |
1048 | cx->options.radio = (cx->card->radio_input.audio_type != 0); |
1049 | |
1050 | /* The card is now fully identified, continue with card-specific |
1051 | initialization. */ |
1052 | cx18_init_struct2(cx); |
1053 | |
1054 | cx18_init_subdevs(cx); |
1055 | |
1056 | if (cx->std & V4L2_STD_525_60) |
1057 | cx->is_60hz = 1; |
1058 | else |
1059 | cx->is_50hz = 1; |
1060 | |
1061 | cx2341x_handler_set_50hz(cxhdl: &cx->cxhdl, is_50hz: !cx->is_60hz); |
1062 | |
1063 | if (cx->options.radio > 0) |
1064 | cx->v4l2_cap |= V4L2_CAP_RADIO; |
1065 | |
1066 | if (cx->options.tuner > -1) { |
1067 | struct tuner_setup setup; |
1068 | |
1069 | setup.addr = ADDR_UNSET; |
1070 | setup.type = cx->options.tuner; |
1071 | setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */ |
1072 | setup.config = NULL; |
1073 | if (cx->options.radio > 0) |
1074 | setup.mode_mask |= T_RADIO; |
1075 | setup.tuner_callback = (setup.type == TUNER_XC2028) ? |
1076 | cx18_reset_tuner_gpio : NULL; |
1077 | cx18_call_all(cx, tuner, s_type_addr, &setup); |
1078 | if (setup.type == TUNER_XC2028) { |
1079 | static struct xc2028_ctrl ctrl = { |
1080 | .fname = XC2028_DEFAULT_FIRMWARE, |
1081 | .max_len = 64, |
1082 | }; |
1083 | struct v4l2_priv_tun_config cfg = { |
1084 | .tuner = cx->options.tuner, |
1085 | .priv = &ctrl, |
1086 | }; |
1087 | cx18_call_all(cx, tuner, s_config, &cfg); |
1088 | } |
1089 | } |
1090 | |
1091 | /* The tuner is fixed to the standard. The other inputs (e.g. S-Video) |
1092 | are not. */ |
1093 | cx->tuner_std = cx->std; |
1094 | if (cx->std == V4L2_STD_ALL) |
1095 | cx->std = V4L2_STD_NTSC_M; |
1096 | |
1097 | retval = cx18_streams_setup(cx); |
1098 | if (retval) { |
1099 | CX18_ERR("Error %d setting up streams\n" , retval); |
1100 | goto free_irq; |
1101 | } |
1102 | retval = cx18_streams_register(cx); |
1103 | if (retval) { |
1104 | CX18_ERR("Error %d registering devices\n" , retval); |
1105 | goto free_streams; |
1106 | } |
1107 | |
1108 | CX18_INFO("Initialized card: %s\n" , cx->card_name); |
1109 | |
1110 | /* Load cx18 submodules (cx18-alsa) */ |
1111 | request_modules(cx); |
1112 | return 0; |
1113 | |
1114 | free_streams: |
1115 | cx18_streams_cleanup(cx, unregister: 1); |
1116 | free_irq: |
1117 | free_irq(cx->pci_dev->irq, (void *)cx); |
1118 | free_i2c: |
1119 | exit_cx18_i2c(cx); |
1120 | free_map: |
1121 | cx18_iounmap(cx); |
1122 | free_mem: |
1123 | release_mem_region(cx->base_addr, CX18_MEM_SIZE); |
1124 | free_workqueues: |
1125 | destroy_workqueue(wq: cx->in_work_queue); |
1126 | err: |
1127 | CX18_ERR("Error %d on initialization\n" , retval); |
1128 | |
1129 | v4l2_device_unregister(v4l2_dev: &cx->v4l2_dev); |
1130 | kfree(objp: cx); |
1131 | return retval; |
1132 | } |
1133 | |
1134 | int cx18_init_on_first_open(struct cx18 *cx) |
1135 | { |
1136 | int video_input; |
1137 | int fw_retry_count = 3; |
1138 | struct v4l2_frequency vf; |
1139 | struct cx18_open_id fh; |
1140 | v4l2_std_id std; |
1141 | |
1142 | fh.cx = cx; |
1143 | |
1144 | if (test_bit(CX18_F_I_FAILED, &cx->i_flags)) |
1145 | return -ENXIO; |
1146 | |
1147 | if (test_and_set_bit(CX18_F_I_INITED, addr: &cx->i_flags)) |
1148 | return 0; |
1149 | |
1150 | while (--fw_retry_count > 0) { |
1151 | /* load firmware */ |
1152 | if (cx18_firmware_init(cx) == 0) |
1153 | break; |
1154 | if (fw_retry_count > 1) |
1155 | CX18_WARN("Retry loading firmware\n" ); |
1156 | } |
1157 | |
1158 | if (fw_retry_count == 0) { |
1159 | set_bit(CX18_F_I_FAILED, addr: &cx->i_flags); |
1160 | return -ENXIO; |
1161 | } |
1162 | set_bit(CX18_F_I_LOADED_FW, addr: &cx->i_flags); |
1163 | |
1164 | /* |
1165 | * Init the firmware twice to work around a silicon bug |
1166 | * with the digital TS. |
1167 | * |
1168 | * The second firmware load requires us to normalize the APU state, |
1169 | * or the audio for the first analog capture will be badly incorrect. |
1170 | * |
1171 | * I can't seem to call APU_RESETAI and have it succeed without the |
1172 | * APU capturing audio, so we start and stop it here to do the reset |
1173 | */ |
1174 | |
1175 | /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */ |
1176 | cx18_vapi(cx, CX18_APU_START, args: 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0); |
1177 | cx18_vapi(cx, CX18_APU_RESETAI, args: 0); |
1178 | cx18_vapi(cx, CX18_APU_STOP, args: 1, CX18_APU_ENCODING_METHOD_MPEG); |
1179 | |
1180 | fw_retry_count = 3; |
1181 | while (--fw_retry_count > 0) { |
1182 | /* load firmware */ |
1183 | if (cx18_firmware_init(cx) == 0) |
1184 | break; |
1185 | if (fw_retry_count > 1) |
1186 | CX18_WARN("Retry loading firmware\n" ); |
1187 | } |
1188 | |
1189 | if (fw_retry_count == 0) { |
1190 | set_bit(CX18_F_I_FAILED, addr: &cx->i_flags); |
1191 | return -ENXIO; |
1192 | } |
1193 | |
1194 | /* |
1195 | * The second firmware load requires us to normalize the APU state, |
1196 | * or the audio for the first analog capture will be badly incorrect. |
1197 | * |
1198 | * I can't seem to call APU_RESETAI and have it succeed without the |
1199 | * APU capturing audio, so we start and stop it here to do the reset |
1200 | */ |
1201 | |
1202 | /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */ |
1203 | cx18_vapi(cx, CX18_APU_START, args: 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0); |
1204 | cx18_vapi(cx, CX18_APU_RESETAI, args: 0); |
1205 | cx18_vapi(cx, CX18_APU_STOP, args: 1, CX18_APU_ENCODING_METHOD_MPEG); |
1206 | |
1207 | /* Init the A/V decoder, if it hasn't been already */ |
1208 | v4l2_subdev_call(cx->sd_av, core, load_fw); |
1209 | |
1210 | vf.tuner = 0; |
1211 | vf.type = V4L2_TUNER_ANALOG_TV; |
1212 | vf.frequency = 6400; /* the tuner 'baseline' frequency */ |
1213 | |
1214 | /* Set initial frequency. For PAL/SECAM broadcasts no |
1215 | 'default' channel exists AFAIK. */ |
1216 | if (cx->std == V4L2_STD_NTSC_M_JP) |
1217 | vf.frequency = 1460; /* ch. 1 91250*16/1000 */ |
1218 | else if (cx->std & V4L2_STD_NTSC_M) |
1219 | vf.frequency = 1076; /* ch. 4 67250*16/1000 */ |
1220 | |
1221 | video_input = cx->active_input; |
1222 | cx->active_input++; /* Force update of input */ |
1223 | cx18_s_input(NULL, fh: &fh, inp: video_input); |
1224 | |
1225 | /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code |
1226 | in one place. */ |
1227 | cx->std++; /* Force full standard initialization */ |
1228 | std = (cx->tuner_std == V4L2_STD_ALL) ? V4L2_STD_NTSC_M : cx->tuner_std; |
1229 | cx18_s_std(NULL, fh: &fh, std); |
1230 | cx18_s_frequency(NULL, fh: &fh, vf: &vf); |
1231 | return 0; |
1232 | } |
1233 | |
1234 | static void cx18_cancel_in_work_orders(struct cx18 *cx) |
1235 | { |
1236 | int i; |
1237 | for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) |
1238 | cancel_work_sync(work: &cx->in_work_order[i].work); |
1239 | } |
1240 | |
1241 | static void cx18_cancel_out_work_orders(struct cx18 *cx) |
1242 | { |
1243 | int i; |
1244 | for (i = 0; i < CX18_MAX_STREAMS; i++) |
1245 | if (cx->streams[i].video_dev.v4l2_dev) |
1246 | cancel_work_sync(work: &cx->streams[i].out_work_order); |
1247 | } |
1248 | |
1249 | static void cx18_remove(struct pci_dev *pci_dev) |
1250 | { |
1251 | struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev: pci_dev); |
1252 | struct cx18 *cx = to_cx18(v4l2_dev); |
1253 | int i; |
1254 | |
1255 | CX18_DEBUG_INFO("Removing Card\n" ); |
1256 | |
1257 | flush_request_modules(cx); |
1258 | |
1259 | /* Stop all captures */ |
1260 | CX18_DEBUG_INFO("Stopping all streams\n" ); |
1261 | if (atomic_read(v: &cx->tot_capturing) > 0) |
1262 | cx18_stop_all_captures(cx); |
1263 | |
1264 | /* Stop interrupts that cause incoming work to be queued */ |
1265 | cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU); |
1266 | |
1267 | /* Incoming work can cause outgoing work, so clean up incoming first */ |
1268 | cx18_cancel_in_work_orders(cx); |
1269 | cx18_cancel_out_work_orders(cx); |
1270 | |
1271 | /* Stop ack interrupts that may have been needed for work to finish */ |
1272 | cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK); |
1273 | |
1274 | cx18_halt_firmware(cx); |
1275 | |
1276 | destroy_workqueue(wq: cx->in_work_queue); |
1277 | |
1278 | cx18_streams_cleanup(cx, unregister: 1); |
1279 | |
1280 | exit_cx18_i2c(cx); |
1281 | |
1282 | free_irq(cx->pci_dev->irq, (void *)cx); |
1283 | |
1284 | cx18_iounmap(cx); |
1285 | |
1286 | release_mem_region(cx->base_addr, CX18_MEM_SIZE); |
1287 | |
1288 | pci_disable_device(dev: cx->pci_dev); |
1289 | |
1290 | if (cx->vbi.sliced_mpeg_data[0]) |
1291 | for (i = 0; i < CX18_VBI_FRAMES; i++) |
1292 | kfree(objp: cx->vbi.sliced_mpeg_data[i]); |
1293 | |
1294 | v4l2_ctrl_handler_free(hdl: &cx->av_state.hdl); |
1295 | |
1296 | CX18_INFO("Removed %s\n" , cx->card_name); |
1297 | |
1298 | v4l2_device_unregister(v4l2_dev); |
1299 | kfree(objp: cx); |
1300 | } |
1301 | |
1302 | |
1303 | /* define a pci_driver for card detection */ |
1304 | static struct pci_driver cx18_pci_driver = { |
1305 | .name = "cx18" , |
1306 | .id_table = cx18_pci_tbl, |
1307 | .probe = cx18_probe, |
1308 | .remove = cx18_remove, |
1309 | }; |
1310 | |
1311 | static int __init module_start(void) |
1312 | { |
1313 | printk(KERN_INFO "cx18: Start initialization, version %s\n" , |
1314 | CX18_VERSION); |
1315 | |
1316 | /* Validate parameters */ |
1317 | if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) { |
1318 | printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n" , |
1319 | CX18_MAX_CARDS - 1); |
1320 | return -1; |
1321 | } |
1322 | |
1323 | if (cx18_debug < 0 || cx18_debug > 511) { |
1324 | cx18_debug = 0; |
1325 | printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n" ); |
1326 | } |
1327 | |
1328 | if (pci_register_driver(&cx18_pci_driver)) { |
1329 | printk(KERN_ERR "cx18: Error detecting PCI card\n" ); |
1330 | return -ENODEV; |
1331 | } |
1332 | printk(KERN_INFO "cx18: End initialization\n" ); |
1333 | return 0; |
1334 | } |
1335 | |
1336 | static void __exit module_cleanup(void) |
1337 | { |
1338 | pci_unregister_driver(dev: &cx18_pci_driver); |
1339 | } |
1340 | |
1341 | module_init(module_start); |
1342 | module_exit(module_cleanup); |
1343 | MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE); |
1344 | |