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(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(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(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, 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(tv, 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, 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, sizeof(eedata));
344 		break;
345 	}
346 
347 ret:
348 	kfree(c);
349 }
350 
351 static void cx18_process_eeprom(struct cx18 *cx)
352 {
353 	struct tveeprom tv;
354 
355 	cx18_read_eeprom(cx, &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(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(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(cx->in_workq_name, sizeof(cx->in_workq_name), "%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(&cx->cxhdl, 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(&cx->vbi.sliced_mpeg_buf.list);
761 	INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
762 	INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
763 	list_add(&cx->vbi.sliced_mpeg_buf.list,
764 		 &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 - 1; 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 - 1; 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(pci_dev)) {
804 		CX18_ERR("Can't enable device %d!\n", cx->instance);
805 		return -EIO;
806 	}
807 	if (dma_set_mask(&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(pci_dev, PCI_COMMAND, &cmd);
819 	cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
820 	pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
821 
822 	cx->card_rev = pci_dev->revision;
823 	pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &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(pci_dev, PCI_LATENCY_TIMER, 64);
829 		pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &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, device) == 0)
870 				cx->hw_flags |= device;
871 			break;
872 		default:
873 			if (cx18_i2c_register(cx, 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, 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(&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(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(&pci_dev->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(cx);
914 		return retval;
915 	}
916 	snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "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(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, 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, 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(cx->pci_dev->irq, cx18_irq_handler,
1019 			     IRQF_SHARED, cx->v4l2_dev.name, (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(&cx->cxhdl, !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, 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(cx->in_work_queue);
1126 err:
1127 	CX18_ERR("Error %d on initialization\n", retval);
1128 
1129 	v4l2_device_unregister(&cx->v4l2_dev);
1130 	kfree(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, &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, &cx->i_flags);
1160 		return -ENXIO;
1161 	}
1162 	set_bit(CX18_F_I_LOADED_FW, &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, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1177 	cx18_vapi(cx, CX18_APU_RESETAI, 0);
1178 	cx18_vapi(cx, CX18_APU_STOP, 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, &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, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1204 	cx18_vapi(cx, CX18_APU_RESETAI, 0);
1205 	cx18_vapi(cx, CX18_APU_STOP, 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, 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, std);
1230 	cx18_s_frequency(NULL, &fh, &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(&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(&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(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(&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(cx->in_work_queue);
1277 
1278 	cx18_streams_cleanup(cx, 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(cx->pci_dev);
1289 
1290 	if (cx->vbi.sliced_mpeg_data[0])
1291 		for (i = 0; i < CX18_VBI_FRAMES; i++)
1292 			kfree(cx->vbi.sliced_mpeg_data[i]);
1293 
1294 	v4l2_ctrl_handler_free(&cx->av_state.hdl);
1295 
1296 	CX18_INFO("Removed %s\n", cx->card_name);
1297 
1298 	v4l2_device_unregister(v4l2_dev);
1299 	kfree(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(&cx18_pci_driver);
1339 }
1340 
1341 module_init(module_start);
1342 module_exit(module_cleanup);
1343 MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE);
1344