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