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