1 /*
2    cx231xx-cards.c - driver for Conexant Cx23100/101/102
3 				USB video capture devices
4 
5    Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
6 				Based on em28xx driver
7 
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12 
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17 
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22 
23 #include "cx231xx.h"
24 #include <linux/init.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/delay.h>
28 #include <linux/i2c.h>
29 #include <media/tuner.h>
30 #include <media/tveeprom.h>
31 #include <media/v4l2-common.h>
32 
33 #include <media/drv-intf/cx25840.h>
34 #include "dvb-usb-ids.h"
35 #include "xc5000.h"
36 #include "tda18271.h"
37 
38 
39 static int tuner = -1;
40 module_param(tuner, int, 0444);
41 MODULE_PARM_DESC(tuner, "tuner type");
42 
43 static int transfer_mode = 1;
44 module_param(transfer_mode, int, 0444);
45 MODULE_PARM_DESC(transfer_mode, "transfer mode (1-ISO or 0-BULK)");
46 
47 static unsigned int disable_ir;
48 module_param(disable_ir, int, 0444);
49 MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
50 
51 /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
52 static unsigned long cx231xx_devused;
53 
54 /*
55  *  Reset sequences for analog/digital modes
56  */
57 
58 static struct cx231xx_reg_seq RDE250_XCV_TUNER[] = {
59 	{0x03, 0x01, 10},
60 	{0x03, 0x00, 30},
61 	{0x03, 0x01, 10},
62 	{-1, -1, -1},
63 };
64 
65 /*
66  *  Board definitions
67  */
68 struct cx231xx_board cx231xx_boards[] = {
69 	[CX231XX_BOARD_UNKNOWN] = {
70 		.name = "Unknown CX231xx video grabber",
71 		.tuner_type = TUNER_ABSENT,
72 		.input = {{
73 				.type = CX231XX_VMUX_TELEVISION,
74 				.vmux = CX231XX_VIN_3_1,
75 				.amux = CX231XX_AMUX_VIDEO,
76 				.gpio = NULL,
77 			}, {
78 				.type = CX231XX_VMUX_COMPOSITE1,
79 				.vmux = CX231XX_VIN_2_1,
80 				.amux = CX231XX_AMUX_LINE_IN,
81 				.gpio = NULL,
82 			}, {
83 				.type = CX231XX_VMUX_SVIDEO,
84 				.vmux = CX231XX_VIN_1_1 |
85 					(CX231XX_VIN_1_2 << 8) |
86 					CX25840_SVIDEO_ON,
87 				.amux = CX231XX_AMUX_LINE_IN,
88 				.gpio = NULL,
89 			}
90 		},
91 	},
92 	[CX231XX_BOARD_CNXT_CARRAERA] = {
93 		.name = "Conexant Hybrid TV - CARRAERA",
94 		.tuner_type = TUNER_XC5000,
95 		.tuner_addr = 0x61,
96 		.tuner_gpio = RDE250_XCV_TUNER,
97 		.tuner_sif_gpio = 0x05,
98 		.tuner_scl_gpio = 0x1a,
99 		.tuner_sda_gpio = 0x1b,
100 		.decoder = CX231XX_AVDECODER,
101 		.output_mode = OUT_MODE_VIP11,
102 		.demod_xfer_mode = 0,
103 		.ctl_pin_status_mask = 0xFFFFFFC4,
104 		.agc_analog_digital_select_gpio = 0x0c,
105 		.gpio_pin_status_mask = 0x4001000,
106 		.tuner_i2c_master = I2C_1_MUX_3,
107 		.demod_i2c_master = I2C_2,
108 		.has_dvb = 1,
109 		.demod_addr = 0x02,
110 		.norm = V4L2_STD_PAL,
111 
112 		.input = {{
113 				.type = CX231XX_VMUX_TELEVISION,
114 				.vmux = CX231XX_VIN_3_1,
115 				.amux = CX231XX_AMUX_VIDEO,
116 				.gpio = NULL,
117 			}, {
118 				.type = CX231XX_VMUX_COMPOSITE1,
119 				.vmux = CX231XX_VIN_2_1,
120 				.amux = CX231XX_AMUX_LINE_IN,
121 				.gpio = NULL,
122 			}, {
123 				.type = CX231XX_VMUX_SVIDEO,
124 				.vmux = CX231XX_VIN_1_1 |
125 					(CX231XX_VIN_1_2 << 8) |
126 					CX25840_SVIDEO_ON,
127 				.amux = CX231XX_AMUX_LINE_IN,
128 				.gpio = NULL,
129 			}
130 		},
131 	},
132 	[CX231XX_BOARD_CNXT_SHELBY] = {
133 		.name = "Conexant Hybrid TV - SHELBY",
134 		.tuner_type = TUNER_XC5000,
135 		.tuner_addr = 0x61,
136 		.tuner_gpio = RDE250_XCV_TUNER,
137 		.tuner_sif_gpio = 0x05,
138 		.tuner_scl_gpio = 0x1a,
139 		.tuner_sda_gpio = 0x1b,
140 		.decoder = CX231XX_AVDECODER,
141 		.output_mode = OUT_MODE_VIP11,
142 		.demod_xfer_mode = 0,
143 		.ctl_pin_status_mask = 0xFFFFFFC4,
144 		.agc_analog_digital_select_gpio = 0x0c,
145 		.gpio_pin_status_mask = 0x4001000,
146 		.tuner_i2c_master = I2C_1_MUX_3,
147 		.demod_i2c_master = I2C_2,
148 		.has_dvb = 1,
149 		.demod_addr = 0x32,
150 		.norm = V4L2_STD_NTSC,
151 
152 		.input = {{
153 				.type = CX231XX_VMUX_TELEVISION,
154 				.vmux = CX231XX_VIN_3_1,
155 				.amux = CX231XX_AMUX_VIDEO,
156 				.gpio = NULL,
157 			}, {
158 				.type = CX231XX_VMUX_COMPOSITE1,
159 				.vmux = CX231XX_VIN_2_1,
160 				.amux = CX231XX_AMUX_LINE_IN,
161 				.gpio = NULL,
162 			}, {
163 				.type = CX231XX_VMUX_SVIDEO,
164 				.vmux = CX231XX_VIN_1_1 |
165 					(CX231XX_VIN_1_2 << 8) |
166 					CX25840_SVIDEO_ON,
167 				.amux = CX231XX_AMUX_LINE_IN,
168 				.gpio = NULL,
169 			}
170 		},
171 	},
172 	[CX231XX_BOARD_CNXT_RDE_253S] = {
173 		.name = "Conexant Hybrid TV - RDE253S",
174 		.tuner_type = TUNER_NXP_TDA18271,
175 		.tuner_addr = 0x60,
176 		.tuner_gpio = RDE250_XCV_TUNER,
177 		.tuner_sif_gpio = 0x05,
178 		.tuner_scl_gpio = 0x1a,
179 		.tuner_sda_gpio = 0x1b,
180 		.decoder = CX231XX_AVDECODER,
181 		.output_mode = OUT_MODE_VIP11,
182 		.demod_xfer_mode = 0,
183 		.ctl_pin_status_mask = 0xFFFFFFC4,
184 		.agc_analog_digital_select_gpio = 0x1c,
185 		.gpio_pin_status_mask = 0x4001000,
186 		.tuner_i2c_master = I2C_1_MUX_3,
187 		.demod_i2c_master = I2C_2,
188 		.has_dvb = 1,
189 		.demod_addr = 0x02,
190 		.norm = V4L2_STD_PAL,
191 
192 		.input = {{
193 				.type = CX231XX_VMUX_TELEVISION,
194 				.vmux = CX231XX_VIN_3_1,
195 				.amux = CX231XX_AMUX_VIDEO,
196 				.gpio = NULL,
197 			}, {
198 				.type = CX231XX_VMUX_COMPOSITE1,
199 				.vmux = CX231XX_VIN_2_1,
200 				.amux = CX231XX_AMUX_LINE_IN,
201 				.gpio = NULL,
202 			}, {
203 				.type = CX231XX_VMUX_SVIDEO,
204 				.vmux = CX231XX_VIN_1_1 |
205 					(CX231XX_VIN_1_2 << 8) |
206 					CX25840_SVIDEO_ON,
207 				.amux = CX231XX_AMUX_LINE_IN,
208 				.gpio = NULL,
209 			}
210 		},
211 	},
212 
213 	[CX231XX_BOARD_CNXT_RDU_253S] = {
214 		.name = "Conexant Hybrid TV - RDU253S",
215 		.tuner_type = TUNER_NXP_TDA18271,
216 		.tuner_addr = 0x60,
217 		.tuner_gpio = RDE250_XCV_TUNER,
218 		.tuner_sif_gpio = 0x05,
219 		.tuner_scl_gpio = 0x1a,
220 		.tuner_sda_gpio = 0x1b,
221 		.decoder = CX231XX_AVDECODER,
222 		.output_mode = OUT_MODE_VIP11,
223 		.demod_xfer_mode = 0,
224 		.ctl_pin_status_mask = 0xFFFFFFC4,
225 		.agc_analog_digital_select_gpio = 0x1c,
226 		.gpio_pin_status_mask = 0x4001000,
227 		.tuner_i2c_master = I2C_1_MUX_3,
228 		.demod_i2c_master = I2C_2,
229 		.has_dvb = 1,
230 		.demod_addr = 0x02,
231 		.norm = V4L2_STD_PAL,
232 
233 		.input = {{
234 				.type = CX231XX_VMUX_TELEVISION,
235 				.vmux = CX231XX_VIN_3_1,
236 				.amux = CX231XX_AMUX_VIDEO,
237 				.gpio = NULL,
238 			}, {
239 				.type = CX231XX_VMUX_COMPOSITE1,
240 				.vmux = CX231XX_VIN_2_1,
241 				.amux = CX231XX_AMUX_LINE_IN,
242 				.gpio = NULL,
243 			}, {
244 				.type = CX231XX_VMUX_SVIDEO,
245 				.vmux = CX231XX_VIN_1_1 |
246 					(CX231XX_VIN_1_2 << 8) |
247 					CX25840_SVIDEO_ON,
248 				.amux = CX231XX_AMUX_LINE_IN,
249 				.gpio = NULL,
250 			}
251 		},
252 	},
253 	[CX231XX_BOARD_CNXT_VIDEO_GRABBER] = {
254 		.name = "Conexant VIDEO GRABBER",
255 		.tuner_type = TUNER_ABSENT,
256 		.decoder = CX231XX_AVDECODER,
257 		.output_mode = OUT_MODE_VIP11,
258 		.ctl_pin_status_mask = 0xFFFFFFC4,
259 		.agc_analog_digital_select_gpio = 0x1c,
260 		.gpio_pin_status_mask = 0x4001000,
261 		.norm = V4L2_STD_PAL,
262 		.no_alt_vanc = 1,
263 		.external_av = 1,
264 		/* Actually, it has a 417, but it isn't working correctly.
265 		 * So set to 0 for now until someone can manage to get this
266 		 * to work reliably. */
267 		.has_417 = 0,
268 
269 		.input = {{
270 				.type = CX231XX_VMUX_COMPOSITE1,
271 				.vmux = CX231XX_VIN_2_1,
272 				.amux = CX231XX_AMUX_LINE_IN,
273 				.gpio = NULL,
274 			}, {
275 				.type = CX231XX_VMUX_SVIDEO,
276 				.vmux = CX231XX_VIN_1_1 |
277 					(CX231XX_VIN_1_2 << 8) |
278 					CX25840_SVIDEO_ON,
279 				.amux = CX231XX_AMUX_LINE_IN,
280 				.gpio = NULL,
281 			}
282 		},
283 	},
284 	[CX231XX_BOARD_CNXT_RDE_250] = {
285 		.name = "Conexant Hybrid TV - rde 250",
286 		.tuner_type = TUNER_XC5000,
287 		.tuner_addr = 0x61,
288 		.tuner_gpio = RDE250_XCV_TUNER,
289 		.tuner_sif_gpio = 0x05,
290 		.tuner_scl_gpio = 0x1a,
291 		.tuner_sda_gpio = 0x1b,
292 		.decoder = CX231XX_AVDECODER,
293 		.output_mode = OUT_MODE_VIP11,
294 		.demod_xfer_mode = 0,
295 		.ctl_pin_status_mask = 0xFFFFFFC4,
296 		.agc_analog_digital_select_gpio = 0x0c,
297 		.gpio_pin_status_mask = 0x4001000,
298 		.tuner_i2c_master = I2C_1_MUX_3,
299 		.demod_i2c_master = I2C_2,
300 		.has_dvb = 1,
301 		.demod_addr = 0x02,
302 		.norm = V4L2_STD_PAL,
303 
304 		.input = {{
305 				.type = CX231XX_VMUX_TELEVISION,
306 				.vmux = CX231XX_VIN_2_1,
307 				.amux = CX231XX_AMUX_VIDEO,
308 				.gpio = NULL,
309 			}
310 		},
311 	},
312 	[CX231XX_BOARD_CNXT_RDU_250] = {
313 		.name = "Conexant Hybrid TV - RDU 250",
314 		.tuner_type = TUNER_XC5000,
315 		.tuner_addr = 0x61,
316 		.tuner_gpio = RDE250_XCV_TUNER,
317 		.tuner_sif_gpio = 0x05,
318 		.tuner_scl_gpio = 0x1a,
319 		.tuner_sda_gpio = 0x1b,
320 		.decoder = CX231XX_AVDECODER,
321 		.output_mode = OUT_MODE_VIP11,
322 		.demod_xfer_mode = 0,
323 		.ctl_pin_status_mask = 0xFFFFFFC4,
324 		.agc_analog_digital_select_gpio = 0x0c,
325 		.gpio_pin_status_mask = 0x4001000,
326 		.tuner_i2c_master = I2C_1_MUX_3,
327 		.demod_i2c_master = I2C_2,
328 		.has_dvb = 1,
329 		.demod_addr = 0x32,
330 		.norm = V4L2_STD_NTSC,
331 
332 		.input = {{
333 				.type = CX231XX_VMUX_TELEVISION,
334 				.vmux = CX231XX_VIN_2_1,
335 				.amux = CX231XX_AMUX_VIDEO,
336 				.gpio = NULL,
337 			}
338 		},
339 	},
340 	[CX231XX_BOARD_HAUPPAUGE_EXETER] = {
341 		.name = "Hauppauge EXETER",
342 		.tuner_type = TUNER_NXP_TDA18271,
343 		.tuner_addr = 0x60,
344 		.tuner_gpio = RDE250_XCV_TUNER,
345 		.tuner_sif_gpio = 0x05,
346 		.tuner_scl_gpio = 0x1a,
347 		.tuner_sda_gpio = 0x1b,
348 		.decoder = CX231XX_AVDECODER,
349 		.output_mode = OUT_MODE_VIP11,
350 		.demod_xfer_mode = 0,
351 		.ctl_pin_status_mask = 0xFFFFFFC4,
352 		.agc_analog_digital_select_gpio = 0x0c,
353 		.gpio_pin_status_mask = 0x4001000,
354 		.tuner_i2c_master = I2C_1_MUX_1,
355 		.demod_i2c_master = I2C_1_MUX_1,
356 		.has_dvb = 1,
357 		.demod_addr = 0x0e,
358 		.norm = V4L2_STD_NTSC,
359 
360 		.input = {{
361 			.type = CX231XX_VMUX_TELEVISION,
362 			.vmux = CX231XX_VIN_3_1,
363 			.amux = CX231XX_AMUX_VIDEO,
364 			.gpio = NULL,
365 		}, {
366 			.type = CX231XX_VMUX_COMPOSITE1,
367 			.vmux = CX231XX_VIN_2_1,
368 			.amux = CX231XX_AMUX_LINE_IN,
369 			.gpio = NULL,
370 		}, {
371 			.type = CX231XX_VMUX_SVIDEO,
372 			.vmux = CX231XX_VIN_1_1 |
373 				(CX231XX_VIN_1_2 << 8) |
374 				CX25840_SVIDEO_ON,
375 			.amux = CX231XX_AMUX_LINE_IN,
376 			.gpio = NULL,
377 		} },
378 	},
379 	[CX231XX_BOARD_HAUPPAUGE_USBLIVE2] = {
380 		.name = "Hauppauge USB Live 2",
381 		.tuner_type = TUNER_ABSENT,
382 		.decoder = CX231XX_AVDECODER,
383 		.output_mode = OUT_MODE_VIP11,
384 		.demod_xfer_mode = 0,
385 		.ctl_pin_status_mask = 0xFFFFFFC4,
386 		.agc_analog_digital_select_gpio = 0x0c,
387 		.gpio_pin_status_mask = 0x4001000,
388 		.norm = V4L2_STD_NTSC,
389 		.no_alt_vanc = 1,
390 		.external_av = 1,
391 		.input = {{
392 			.type = CX231XX_VMUX_COMPOSITE1,
393 			.vmux = CX231XX_VIN_2_1,
394 			.amux = CX231XX_AMUX_LINE_IN,
395 			.gpio = NULL,
396 		}, {
397 			.type = CX231XX_VMUX_SVIDEO,
398 			.vmux = CX231XX_VIN_1_1 |
399 				(CX231XX_VIN_1_2 << 8) |
400 				CX25840_SVIDEO_ON,
401 			.amux = CX231XX_AMUX_LINE_IN,
402 			.gpio = NULL,
403 		} },
404 	},
405 	[CX231XX_BOARD_KWORLD_UB430_USB_HYBRID] = {
406 		.name = "Kworld UB430 USB Hybrid",
407 		.tuner_type = TUNER_NXP_TDA18271,
408 		.tuner_addr = 0x60,
409 		.decoder = CX231XX_AVDECODER,
410 		.output_mode = OUT_MODE_VIP11,
411 		.demod_xfer_mode = 0,
412 		.ctl_pin_status_mask = 0xFFFFFFC4,
413 		.agc_analog_digital_select_gpio = 0x11,	/* According with PV cxPolaris.inf file */
414 		.tuner_sif_gpio = -1,
415 		.tuner_scl_gpio = -1,
416 		.tuner_sda_gpio = -1,
417 		.gpio_pin_status_mask = 0x4001000,
418 		.tuner_i2c_master = I2C_2,
419 		.demod_i2c_master = I2C_1_MUX_3,
420 		.ir_i2c_master = I2C_2,
421 		.has_dvb = 1,
422 		.demod_addr = 0x10,
423 		.norm = V4L2_STD_PAL_M,
424 		.input = {{
425 			.type = CX231XX_VMUX_TELEVISION,
426 			.vmux = CX231XX_VIN_3_1,
427 			.amux = CX231XX_AMUX_VIDEO,
428 			.gpio = NULL,
429 		}, {
430 			.type = CX231XX_VMUX_COMPOSITE1,
431 			.vmux = CX231XX_VIN_2_1,
432 			.amux = CX231XX_AMUX_LINE_IN,
433 			.gpio = NULL,
434 		}, {
435 			.type = CX231XX_VMUX_SVIDEO,
436 			.vmux = CX231XX_VIN_1_1 |
437 				(CX231XX_VIN_1_2 << 8) |
438 				CX25840_SVIDEO_ON,
439 			.amux = CX231XX_AMUX_LINE_IN,
440 			.gpio = NULL,
441 		} },
442 	},
443 	[CX231XX_BOARD_KWORLD_UB445_USB_HYBRID] = {
444 		.name = "Kworld UB445 USB Hybrid",
445 		.tuner_type = TUNER_NXP_TDA18271,
446 		.tuner_addr = 0x60,
447 		.decoder = CX231XX_AVDECODER,
448 		.output_mode = OUT_MODE_VIP11,
449 		.demod_xfer_mode = 0,
450 		.ctl_pin_status_mask = 0xFFFFFFC4,
451 		.agc_analog_digital_select_gpio = 0x11,	/* According with PV cxPolaris.inf file */
452 		.tuner_sif_gpio = -1,
453 		.tuner_scl_gpio = -1,
454 		.tuner_sda_gpio = -1,
455 		.gpio_pin_status_mask = 0x4001000,
456 		.tuner_i2c_master = I2C_2,
457 		.demod_i2c_master = I2C_1_MUX_3,
458 		.ir_i2c_master = I2C_2,
459 		.has_dvb = 1,
460 		.demod_addr = 0x10,
461 		.norm = V4L2_STD_NTSC_M,
462 		.input = {{
463 			.type = CX231XX_VMUX_TELEVISION,
464 			.vmux = CX231XX_VIN_3_1,
465 			.amux = CX231XX_AMUX_VIDEO,
466 			.gpio = NULL,
467 		}, {
468 			.type = CX231XX_VMUX_COMPOSITE1,
469 			.vmux = CX231XX_VIN_2_1,
470 			.amux = CX231XX_AMUX_LINE_IN,
471 			.gpio = NULL,
472 		}, {
473 			.type = CX231XX_VMUX_SVIDEO,
474 			.vmux = CX231XX_VIN_1_1 |
475 				(CX231XX_VIN_1_2 << 8) |
476 				CX25840_SVIDEO_ON,
477 			.amux = CX231XX_AMUX_LINE_IN,
478 			.gpio = NULL,
479 		} },
480 	},
481 	[CX231XX_BOARD_PV_PLAYTV_USB_HYBRID] = {
482 		.name = "Pixelview PlayTV USB Hybrid",
483 		.tuner_type = TUNER_NXP_TDA18271,
484 		.tuner_addr = 0x60,
485 		.decoder = CX231XX_AVDECODER,
486 		.output_mode = OUT_MODE_VIP11,
487 		.demod_xfer_mode = 0,
488 		.ctl_pin_status_mask = 0xFFFFFFC4,
489 		.agc_analog_digital_select_gpio = 0x1c,
490 		.tuner_sif_gpio = -1,
491 		.tuner_scl_gpio = -1,
492 		.tuner_sda_gpio = -1,
493 		.gpio_pin_status_mask = 0x4001000,
494 		.tuner_i2c_master = I2C_2,
495 		.demod_i2c_master = I2C_1_MUX_3,
496 		.ir_i2c_master = I2C_2,
497 		.rc_map_name = RC_MAP_PIXELVIEW_002T,
498 		.has_dvb = 1,
499 		.demod_addr = 0x10,
500 		.norm = V4L2_STD_PAL_M,
501 		.input = {{
502 			.type = CX231XX_VMUX_TELEVISION,
503 			.vmux = CX231XX_VIN_3_1,
504 			.amux = CX231XX_AMUX_VIDEO,
505 			.gpio = NULL,
506 		}, {
507 			.type = CX231XX_VMUX_COMPOSITE1,
508 			.vmux = CX231XX_VIN_2_1,
509 			.amux = CX231XX_AMUX_LINE_IN,
510 			.gpio = NULL,
511 		}, {
512 			.type = CX231XX_VMUX_SVIDEO,
513 			.vmux = CX231XX_VIN_1_1 |
514 				(CX231XX_VIN_1_2 << 8) |
515 				CX25840_SVIDEO_ON,
516 			.amux = CX231XX_AMUX_LINE_IN,
517 			.gpio = NULL,
518 		} },
519 	},
520 	[CX231XX_BOARD_PV_XCAPTURE_USB] = {
521 		.name = "Pixelview Xcapture USB",
522 		.tuner_type = TUNER_ABSENT,
523 		.decoder = CX231XX_AVDECODER,
524 		.output_mode = OUT_MODE_VIP11,
525 		.demod_xfer_mode = 0,
526 		.ctl_pin_status_mask = 0xFFFFFFC4,
527 		.agc_analog_digital_select_gpio = 0x0c,
528 		.gpio_pin_status_mask = 0x4001000,
529 		.norm = V4L2_STD_NTSC,
530 		.no_alt_vanc = 1,
531 		.external_av = 1,
532 
533 		.input = {{
534 				.type = CX231XX_VMUX_COMPOSITE1,
535 				.vmux = CX231XX_VIN_2_1,
536 				.amux = CX231XX_AMUX_LINE_IN,
537 				.gpio = NULL,
538 			}, {
539 				.type = CX231XX_VMUX_SVIDEO,
540 				.vmux = CX231XX_VIN_1_1 |
541 					(CX231XX_VIN_1_2 << 8) |
542 					CX25840_SVIDEO_ON,
543 				.amux = CX231XX_AMUX_LINE_IN,
544 				.gpio = NULL,
545 			}
546 		},
547 	},
548 
549 	[CX231XX_BOARD_ICONBIT_U100] = {
550 		.name = "Iconbit Analog Stick U100 FM",
551 		.tuner_type = TUNER_ABSENT,
552 		.decoder = CX231XX_AVDECODER,
553 		.output_mode = OUT_MODE_VIP11,
554 		.demod_xfer_mode = 0,
555 		.ctl_pin_status_mask = 0xFFFFFFC4,
556 		.agc_analog_digital_select_gpio = 0x1C,
557 		.gpio_pin_status_mask = 0x4001000,
558 
559 		.input = {{
560 			.type = CX231XX_VMUX_COMPOSITE1,
561 			.vmux = CX231XX_VIN_2_1,
562 			.amux = CX231XX_AMUX_LINE_IN,
563 			.gpio = NULL,
564 		}, {
565 			.type = CX231XX_VMUX_SVIDEO,
566 			.vmux = CX231XX_VIN_1_1 |
567 				(CX231XX_VIN_1_2 << 8) |
568 				CX25840_SVIDEO_ON,
569 			.amux = CX231XX_AMUX_LINE_IN,
570 			.gpio = NULL,
571 		} },
572 	},
573 	[CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL] = {
574 		.name = "Hauppauge WinTV USB2 FM (PAL)",
575 		.tuner_type = TUNER_NXP_TDA18271,
576 		.tuner_addr = 0x60,
577 		.tuner_gpio = RDE250_XCV_TUNER,
578 		.tuner_sif_gpio = 0x05,
579 		.tuner_scl_gpio = 0x1a,
580 		.tuner_sda_gpio = 0x1b,
581 		.decoder = CX231XX_AVDECODER,
582 		.output_mode = OUT_MODE_VIP11,
583 		.ctl_pin_status_mask = 0xFFFFFFC4,
584 		.agc_analog_digital_select_gpio = 0x0c,
585 		.gpio_pin_status_mask = 0x4001000,
586 		.tuner_i2c_master = I2C_1_MUX_3,
587 		.norm = V4L2_STD_PAL,
588 
589 		.input = {{
590 			.type = CX231XX_VMUX_TELEVISION,
591 			.vmux = CX231XX_VIN_3_1,
592 			.amux = CX231XX_AMUX_VIDEO,
593 			.gpio = NULL,
594 		}, {
595 			.type = CX231XX_VMUX_COMPOSITE1,
596 			.vmux = CX231XX_VIN_2_1,
597 			.amux = CX231XX_AMUX_LINE_IN,
598 			.gpio = NULL,
599 		}, {
600 			.type = CX231XX_VMUX_SVIDEO,
601 			.vmux = CX231XX_VIN_1_1 |
602 				(CX231XX_VIN_1_2 << 8) |
603 				CX25840_SVIDEO_ON,
604 			.amux = CX231XX_AMUX_LINE_IN,
605 			.gpio = NULL,
606 		} },
607 	},
608 	[CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC] = {
609 		.name = "Hauppauge WinTV USB2 FM (NTSC)",
610 		.tuner_type = TUNER_NXP_TDA18271,
611 		.tuner_addr = 0x60,
612 		.tuner_gpio = RDE250_XCV_TUNER,
613 		.tuner_sif_gpio = 0x05,
614 		.tuner_scl_gpio = 0x1a,
615 		.tuner_sda_gpio = 0x1b,
616 		.decoder = CX231XX_AVDECODER,
617 		.output_mode = OUT_MODE_VIP11,
618 		.ctl_pin_status_mask = 0xFFFFFFC4,
619 		.agc_analog_digital_select_gpio = 0x0c,
620 		.gpio_pin_status_mask = 0x4001000,
621 		.tuner_i2c_master = I2C_1_MUX_3,
622 		.norm = V4L2_STD_NTSC,
623 
624 		.input = {{
625 			.type = CX231XX_VMUX_TELEVISION,
626 			.vmux = CX231XX_VIN_3_1,
627 			.amux = CX231XX_AMUX_VIDEO,
628 			.gpio = NULL,
629 		}, {
630 			.type = CX231XX_VMUX_COMPOSITE1,
631 			.vmux = CX231XX_VIN_2_1,
632 			.amux = CX231XX_AMUX_LINE_IN,
633 			.gpio = NULL,
634 		}, {
635 			.type = CX231XX_VMUX_SVIDEO,
636 			.vmux = CX231XX_VIN_1_1 |
637 				(CX231XX_VIN_1_2 << 8) |
638 				CX25840_SVIDEO_ON,
639 			.amux = CX231XX_AMUX_LINE_IN,
640 			.gpio = NULL,
641 		} },
642 	},
643 	[CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2] = {
644 		.name = "Elgato Video Capture V2",
645 		.tuner_type = TUNER_ABSENT,
646 		.decoder = CX231XX_AVDECODER,
647 		.output_mode = OUT_MODE_VIP11,
648 		.demod_xfer_mode = 0,
649 		.ctl_pin_status_mask = 0xFFFFFFC4,
650 		.agc_analog_digital_select_gpio = 0x0c,
651 		.gpio_pin_status_mask = 0x4001000,
652 		.norm = V4L2_STD_NTSC,
653 		.no_alt_vanc = 1,
654 		.external_av = 1,
655 		.input = {{
656 			.type = CX231XX_VMUX_COMPOSITE1,
657 			.vmux = CX231XX_VIN_2_1,
658 			.amux = CX231XX_AMUX_LINE_IN,
659 			.gpio = NULL,
660 		}, {
661 			.type = CX231XX_VMUX_SVIDEO,
662 			.vmux = CX231XX_VIN_1_1 |
663 				(CX231XX_VIN_1_2 << 8) |
664 				CX25840_SVIDEO_ON,
665 			.amux = CX231XX_AMUX_LINE_IN,
666 			.gpio = NULL,
667 		} },
668 	},
669 	[CX231XX_BOARD_OTG102] = {
670 		.name = "Geniatech OTG102",
671 		.tuner_type = TUNER_ABSENT,
672 		.decoder = CX231XX_AVDECODER,
673 		.output_mode = OUT_MODE_VIP11,
674 		.ctl_pin_status_mask = 0xFFFFFFC4,
675 		.agc_analog_digital_select_gpio = 0x0c,
676 			/* According with PV CxPlrCAP.inf file */
677 		.gpio_pin_status_mask = 0x4001000,
678 		.norm = V4L2_STD_NTSC,
679 		.no_alt_vanc = 1,
680 		.external_av = 1,
681 		/*.has_417 = 1, */
682 		/* This board is believed to have a hardware encoding chip
683 		 * supporting mpeg1/2/4, but as the 417 is apparently not
684 		 * working for the reference board it is not here either. */
685 
686 		.input = {{
687 				.type = CX231XX_VMUX_COMPOSITE1,
688 				.vmux = CX231XX_VIN_2_1,
689 				.amux = CX231XX_AMUX_LINE_IN,
690 				.gpio = NULL,
691 			}, {
692 				.type = CX231XX_VMUX_SVIDEO,
693 				.vmux = CX231XX_VIN_1_1 |
694 					(CX231XX_VIN_1_2 << 8) |
695 					CX25840_SVIDEO_ON,
696 				.amux = CX231XX_AMUX_LINE_IN,
697 				.gpio = NULL,
698 			}
699 		},
700 	},
701 	[CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx] = {
702 		.name = "Hauppauge WinTV 930C-HD (1113xx) / HVR-900H (111xxx) / PCTV QuatroStick 521e",
703 		.tuner_type = TUNER_NXP_TDA18271,
704 		.tuner_addr = 0x60,
705 		.tuner_gpio = RDE250_XCV_TUNER,
706 		.tuner_sif_gpio = 0x05,
707 		.tuner_scl_gpio = 0x1a,
708 		.tuner_sda_gpio = 0x1b,
709 		.decoder = CX231XX_AVDECODER,
710 		.output_mode = OUT_MODE_VIP11,
711 		.demod_xfer_mode = 0,
712 		.ctl_pin_status_mask = 0xFFFFFFC4,
713 		.agc_analog_digital_select_gpio = 0x0c,
714 		.gpio_pin_status_mask = 0x4001000,
715 		.tuner_i2c_master = I2C_1_MUX_3,
716 		.demod_i2c_master = I2C_1_MUX_3,
717 		.has_dvb = 1,
718 		.demod_addr = 0x0e,
719 		.norm = V4L2_STD_PAL,
720 
721 		.input = {{
722 			.type = CX231XX_VMUX_TELEVISION,
723 			.vmux = CX231XX_VIN_3_1,
724 			.amux = CX231XX_AMUX_VIDEO,
725 			.gpio = NULL,
726 		}, {
727 			.type = CX231XX_VMUX_COMPOSITE1,
728 			.vmux = CX231XX_VIN_2_1,
729 			.amux = CX231XX_AMUX_LINE_IN,
730 			.gpio = NULL,
731 		}, {
732 			.type = CX231XX_VMUX_SVIDEO,
733 			.vmux = CX231XX_VIN_1_1 |
734 				(CX231XX_VIN_1_2 << 8) |
735 				CX25840_SVIDEO_ON,
736 			.amux = CX231XX_AMUX_LINE_IN,
737 			.gpio = NULL,
738 		} },
739 	},
740 	[CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx] = {
741 		.name = "Hauppauge WinTV 930C-HD (1114xx) / HVR-901H (1114xx) / PCTV QuatroStick 522e",
742 		.tuner_type = TUNER_ABSENT,
743 		.tuner_addr = 0x60,
744 		.tuner_gpio = RDE250_XCV_TUNER,
745 		.tuner_sif_gpio = 0x05,
746 		.tuner_scl_gpio = 0x1a,
747 		.tuner_sda_gpio = 0x1b,
748 		.decoder = CX231XX_AVDECODER,
749 		.output_mode = OUT_MODE_VIP11,
750 		.demod_xfer_mode = 0,
751 		.ctl_pin_status_mask = 0xFFFFFFC4,
752 		.agc_analog_digital_select_gpio = 0x0c,
753 		.gpio_pin_status_mask = 0x4001000,
754 		.tuner_i2c_master = I2C_1_MUX_3,
755 		.demod_i2c_master = I2C_1_MUX_3,
756 		.has_dvb = 1,
757 		.demod_addr = 0x0e,
758 		.norm = V4L2_STD_PAL,
759 
760 		.input = {{
761 			.type = CX231XX_VMUX_TELEVISION,
762 			.vmux = CX231XX_VIN_3_1,
763 			.amux = CX231XX_AMUX_VIDEO,
764 			.gpio = NULL,
765 		}, {
766 			.type = CX231XX_VMUX_COMPOSITE1,
767 			.vmux = CX231XX_VIN_2_1,
768 			.amux = CX231XX_AMUX_LINE_IN,
769 			.gpio = NULL,
770 		}, {
771 			.type = CX231XX_VMUX_SVIDEO,
772 			.vmux = CX231XX_VIN_1_1 |
773 				(CX231XX_VIN_1_2 << 8) |
774 				CX25840_SVIDEO_ON,
775 			.amux = CX231XX_AMUX_LINE_IN,
776 			.gpio = NULL,
777 		} },
778 	},
779 	[CX231XX_BOARD_HAUPPAUGE_955Q] = {
780 		.name = "Hauppauge WinTV-HVR-955Q (111401)",
781 		.tuner_type = TUNER_ABSENT,
782 		.tuner_addr = 0x60,
783 		.tuner_gpio = RDE250_XCV_TUNER,
784 		.tuner_sif_gpio = 0x05,
785 		.tuner_scl_gpio = 0x1a,
786 		.tuner_sda_gpio = 0x1b,
787 		.decoder = CX231XX_AVDECODER,
788 		.output_mode = OUT_MODE_VIP11,
789 		.demod_xfer_mode = 0,
790 		.ctl_pin_status_mask = 0xFFFFFFC4,
791 		.agc_analog_digital_select_gpio = 0x0c,
792 		.gpio_pin_status_mask = 0x4001000,
793 		.tuner_i2c_master = I2C_1_MUX_3,
794 		.demod_i2c_master = I2C_1_MUX_3,
795 		.has_dvb = 1,
796 		.demod_addr = 0x0e,
797 		.norm = V4L2_STD_NTSC,
798 
799 		.input = {{
800 			.type = CX231XX_VMUX_TELEVISION,
801 			.vmux = CX231XX_VIN_3_1,
802 			.amux = CX231XX_AMUX_VIDEO,
803 			.gpio = NULL,
804 		}, {
805 			.type = CX231XX_VMUX_COMPOSITE1,
806 			.vmux = CX231XX_VIN_2_1,
807 			.amux = CX231XX_AMUX_LINE_IN,
808 			.gpio = NULL,
809 		}, {
810 			.type = CX231XX_VMUX_SVIDEO,
811 			.vmux = CX231XX_VIN_1_1 |
812 				(CX231XX_VIN_1_2 << 8) |
813 				CX25840_SVIDEO_ON,
814 			.amux = CX231XX_AMUX_LINE_IN,
815 			.gpio = NULL,
816 		} },
817 	},
818 	[CX231XX_BOARD_TERRATEC_GRABBY] = {
819 		.name = "Terratec Grabby",
820 		.tuner_type = TUNER_ABSENT,
821 		.decoder = CX231XX_AVDECODER,
822 		.output_mode = OUT_MODE_VIP11,
823 		.demod_xfer_mode = 0,
824 		.ctl_pin_status_mask = 0xFFFFFFC4,
825 		.agc_analog_digital_select_gpio = 0x0c,
826 		.gpio_pin_status_mask = 0x4001000,
827 		.norm = V4L2_STD_PAL,
828 		.no_alt_vanc = 1,
829 		.external_av = 1,
830 		.input = {{
831 			.type = CX231XX_VMUX_COMPOSITE1,
832 			.vmux = CX231XX_VIN_2_1,
833 			.amux = CX231XX_AMUX_LINE_IN,
834 			.gpio = NULL,
835 		}, {
836 			.type = CX231XX_VMUX_SVIDEO,
837 			.vmux = CX231XX_VIN_1_1 |
838 				(CX231XX_VIN_1_2 << 8) |
839 				CX25840_SVIDEO_ON,
840 			.amux = CX231XX_AMUX_LINE_IN,
841 			.gpio = NULL,
842 		} },
843 	},
844 	[CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD] = {
845 		.name = "Evromedia USB Full Hybrid Full HD",
846 		.tuner_type = TUNER_ABSENT,
847 		.demod_addr = 0x64, /* 0xc8 >> 1 */
848 		.demod_i2c_master = I2C_1_MUX_3,
849 		.has_dvb = 1,
850 		.decoder = CX231XX_AVDECODER,
851 		.norm = V4L2_STD_PAL,
852 		.output_mode = OUT_MODE_VIP11,
853 		.tuner_addr = 0x60, /* 0xc0 >> 1 */
854 		.tuner_i2c_master = I2C_2,
855 		.input = {{
856 			.type = CX231XX_VMUX_TELEVISION,
857 			.vmux = 0,
858 			.amux = CX231XX_AMUX_VIDEO,
859 		}, {
860 			.type = CX231XX_VMUX_COMPOSITE1,
861 			.vmux = CX231XX_VIN_2_1,
862 			.amux = CX231XX_AMUX_LINE_IN,
863 		}, {
864 			.type = CX231XX_VMUX_SVIDEO,
865 			.vmux = CX231XX_VIN_1_1 |
866 				(CX231XX_VIN_1_2 << 8) |
867 				CX25840_SVIDEO_ON,
868 			.amux = CX231XX_AMUX_LINE_IN,
869 		} },
870 	},
871 	[CX231XX_BOARD_ASTROMETA_T2HYBRID] = {
872 		.name = "Astrometa T2hybrid",
873 		.tuner_type = TUNER_ABSENT,
874 		.has_dvb = 1,
875 		.decoder = CX231XX_AVDECODER,
876 		.output_mode = OUT_MODE_VIP11,
877 		.agc_analog_digital_select_gpio = 0x01,
878 		.ctl_pin_status_mask = 0xffffffc4,
879 		.demod_addr = 0x18, /* 0x30 >> 1 */
880 		.demod_i2c_master = I2C_1_MUX_1,
881 		.gpio_pin_status_mask = 0xa,
882 		.norm = V4L2_STD_NTSC,
883 		.tuner_addr = 0x3a, /* 0x74 >> 1 */
884 		.tuner_i2c_master = I2C_1_MUX_3,
885 		.tuner_scl_gpio = 0x1a,
886 		.tuner_sda_gpio = 0x1b,
887 		.tuner_sif_gpio = 0x05,
888 		.input = {{
889 				.type = CX231XX_VMUX_TELEVISION,
890 				.vmux = CX231XX_VIN_1_1,
891 				.amux = CX231XX_AMUX_VIDEO,
892 			}, {
893 				.type = CX231XX_VMUX_COMPOSITE1,
894 				.vmux = CX231XX_VIN_2_1,
895 				.amux = CX231XX_AMUX_LINE_IN,
896 			},
897 		},
898 	},
899 };
900 const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
901 
902 /* table of devices that work with this driver */
903 struct usb_device_id cx231xx_id_table[] = {
904 	{USB_DEVICE(0x1D19, 0x6109),
905 	.driver_info = CX231XX_BOARD_PV_XCAPTURE_USB},
906 	{USB_DEVICE(0x0572, 0x5A3C),
907 	 .driver_info = CX231XX_BOARD_UNKNOWN},
908 	{USB_DEVICE(0x0572, 0x58A2),
909 	 .driver_info = CX231XX_BOARD_CNXT_CARRAERA},
910 	{USB_DEVICE(0x0572, 0x58A1),
911 	 .driver_info = CX231XX_BOARD_CNXT_SHELBY},
912 	{USB_DEVICE(0x0572, 0x58A4),
913 	 .driver_info = CX231XX_BOARD_CNXT_RDE_253S},
914 	{USB_DEVICE(0x0572, 0x58A5),
915 	 .driver_info = CX231XX_BOARD_CNXT_RDU_253S},
916 	{USB_DEVICE(0x0572, 0x58A6),
917 	 .driver_info = CX231XX_BOARD_CNXT_VIDEO_GRABBER},
918 	{USB_DEVICE(0x0572, 0x589E),
919 	 .driver_info = CX231XX_BOARD_CNXT_RDE_250},
920 	{USB_DEVICE(0x0572, 0x58A0),
921 	 .driver_info = CX231XX_BOARD_CNXT_RDU_250},
922 	{USB_DEVICE(0x2040, 0xb110),
923 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL},
924 	{USB_DEVICE(0x2040, 0xb111),
925 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC},
926 	{USB_DEVICE(0x2040, 0xb120),
927 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
928 	{USB_DEVICE(0x2040, 0xb123),
929 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_955Q},
930 	{USB_DEVICE(0x2040, 0xb130),
931 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
932 	{USB_DEVICE(0x2040, 0xb131),
933 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
934 	/* Hauppauge WinTV-HVR-900-H */
935 	{USB_DEVICE(0x2040, 0xb138),
936 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
937 	/* Hauppauge WinTV-HVR-901-H */
938 	{USB_DEVICE(0x2040, 0xb139),
939 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
940 	{USB_DEVICE(0x2040, 0xb140),
941 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
942 	{USB_DEVICE(0x2040, 0xc200),
943 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_USBLIVE2},
944 	/* PCTV QuatroStick 521e */
945 	{USB_DEVICE(0x2013, 0x0259),
946 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
947 	/* PCTV QuatroStick 522e */
948 	{USB_DEVICE(0x2013, 0x025e),
949 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
950 	{USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x4000, 0x4001),
951 	 .driver_info = CX231XX_BOARD_PV_PLAYTV_USB_HYBRID},
952 	{USB_DEVICE(USB_VID_PIXELVIEW, 0x5014),
953 	 .driver_info = CX231XX_BOARD_PV_XCAPTURE_USB},
954 	{USB_DEVICE(0x1b80, 0xe424),
955 	 .driver_info = CX231XX_BOARD_KWORLD_UB430_USB_HYBRID},
956 	{USB_DEVICE(0x1b80, 0xe421),
957 	 .driver_info = CX231XX_BOARD_KWORLD_UB445_USB_HYBRID},
958 	{USB_DEVICE(0x1f4d, 0x0237),
959 	 .driver_info = CX231XX_BOARD_ICONBIT_U100},
960 	{USB_DEVICE(0x0fd9, 0x0037),
961 	 .driver_info = CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2},
962 	{USB_DEVICE(0x1f4d, 0x0102),
963 	 .driver_info = CX231XX_BOARD_OTG102},
964 	{USB_DEVICE(USB_VID_TERRATEC, 0x00a6),
965 	 .driver_info = CX231XX_BOARD_TERRATEC_GRABBY},
966 	{USB_DEVICE(0x1b80, 0xd3b2),
967 	.driver_info = CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD},
968 	{USB_DEVICE(0x15f4, 0x0135),
969 	.driver_info = CX231XX_BOARD_ASTROMETA_T2HYBRID},
970 	{},
971 };
972 
973 MODULE_DEVICE_TABLE(usb, cx231xx_id_table);
974 
975 /* cx231xx_tuner_callback
976  * will be used to reset XC5000 tuner using GPIO pin
977  */
978 
979 int cx231xx_tuner_callback(void *ptr, int component, int command, int arg)
980 {
981 	int rc = 0;
982 	struct cx231xx *dev = ptr;
983 
984 	if (dev->tuner_type == TUNER_XC5000) {
985 		if (command == XC5000_TUNER_RESET) {
986 			dev_dbg(dev->dev,
987 				"Tuner CB: RESET: cmd %d : tuner type %d\n",
988 				command, dev->tuner_type);
989 			cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
990 					       1);
991 			msleep(10);
992 			cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
993 					       0);
994 			msleep(330);
995 			cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
996 					       1);
997 			msleep(10);
998 		}
999 	} else if (dev->tuner_type == TUNER_NXP_TDA18271) {
1000 		switch (command) {
1001 		case TDA18271_CALLBACK_CMD_AGC_ENABLE:
1002 			if (dev->model == CX231XX_BOARD_PV_PLAYTV_USB_HYBRID)
1003 				rc = cx231xx_set_agc_analog_digital_mux_select(dev, arg);
1004 			break;
1005 		default:
1006 			rc = -EINVAL;
1007 			break;
1008 		}
1009 	}
1010 	return rc;
1011 }
1012 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback);
1013 
1014 static void cx231xx_reset_out(struct cx231xx *dev)
1015 {
1016 	cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
1017 	msleep(200);
1018 	cx231xx_set_gpio_value(dev, CX23417_RESET, 0);
1019 	msleep(200);
1020 	cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
1021 }
1022 
1023 static void cx231xx_enable_OSC(struct cx231xx *dev)
1024 {
1025 	cx231xx_set_gpio_value(dev, CX23417_OSC_EN, 1);
1026 }
1027 
1028 static void cx231xx_sleep_s5h1432(struct cx231xx *dev)
1029 {
1030 	cx231xx_set_gpio_value(dev, SLEEP_S5H1432, 0);
1031 }
1032 
1033 static inline void cx231xx_set_model(struct cx231xx *dev)
1034 {
1035 	dev->board = cx231xx_boards[dev->model];
1036 }
1037 
1038 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
1039  * this won't work for boards with generic PCI IDs
1040  */
1041 void cx231xx_pre_card_setup(struct cx231xx *dev)
1042 {
1043 	dev_info(dev->dev, "Identified as %s (card=%d)\n",
1044 		dev->board.name, dev->model);
1045 
1046 	if (CX231XX_BOARD_ASTROMETA_T2HYBRID == dev->model) {
1047 		/* turn on demodulator chip */
1048 		cx231xx_set_gpio_value(dev, 0x03, 0x01);
1049 	}
1050 
1051 	/* set the direction for GPIO pins */
1052 	if (dev->board.tuner_gpio) {
1053 		cx231xx_set_gpio_direction(dev, dev->board.tuner_gpio->bit, 1);
1054 		cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit, 1);
1055 	}
1056 	if (dev->board.tuner_sif_gpio >= 0)
1057 		cx231xx_set_gpio_direction(dev, dev->board.tuner_sif_gpio, 1);
1058 
1059 	/* request some modules if any required */
1060 
1061 	/* set the mode to Analog mode initially */
1062 	cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
1063 
1064 	/* Unlock device */
1065 	/* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
1066 
1067 }
1068 
1069 static void cx231xx_config_tuner(struct cx231xx *dev)
1070 {
1071 	struct tuner_setup tun_setup;
1072 	struct v4l2_frequency f;
1073 
1074 	if (dev->tuner_type == TUNER_ABSENT)
1075 		return;
1076 
1077 	tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
1078 	tun_setup.type = dev->tuner_type;
1079 	tun_setup.addr = dev->tuner_addr;
1080 	tun_setup.tuner_callback = cx231xx_tuner_callback;
1081 
1082 	tuner_call(dev, tuner, s_type_addr, &tun_setup);
1083 
1084 #if 0
1085 	if (tun_setup.type == TUNER_XC5000) {
1086 		static struct xc2028_ctrl ctrl = {
1087 			.fname = XC5000_DEFAULT_FIRMWARE,
1088 			.max_len = 64,
1089 			.demod = 0;
1090 		};
1091 		struct v4l2_priv_tun_config cfg = {
1092 			.tuner = dev->tuner_type,
1093 			.priv = &ctrl,
1094 		};
1095 		tuner_call(dev, tuner, s_config, &cfg);
1096 	}
1097 #endif
1098 	/* configure tuner */
1099 	f.tuner = 0;
1100 	f.type = V4L2_TUNER_ANALOG_TV;
1101 	f.frequency = 9076;	/* just a magic number */
1102 	dev->ctl_freq = f.frequency;
1103 	call_all(dev, tuner, s_frequency, &f);
1104 
1105 }
1106 
1107 static int read_eeprom(struct cx231xx *dev, struct i2c_client *client,
1108 		       u8 *eedata, int len)
1109 {
1110 	int ret = 0;
1111 	u8 start_offset = 0;
1112 	int len_todo = len;
1113 	u8 *eedata_cur = eedata;
1114 	int i;
1115 	struct i2c_msg msg_write = { .addr = client->addr, .flags = 0,
1116 		.buf = &start_offset, .len = 1 };
1117 	struct i2c_msg msg_read = { .addr = client->addr, .flags = I2C_M_RD };
1118 
1119 	/* start reading at offset 0 */
1120 	ret = i2c_transfer(client->adapter, &msg_write, 1);
1121 	if (ret < 0) {
1122 		dev_err(dev->dev, "Can't read eeprom\n");
1123 		return ret;
1124 	}
1125 
1126 	while (len_todo > 0) {
1127 		msg_read.len = (len_todo > 64) ? 64 : len_todo;
1128 		msg_read.buf = eedata_cur;
1129 
1130 		ret = i2c_transfer(client->adapter, &msg_read, 1);
1131 		if (ret < 0) {
1132 			dev_err(dev->dev, "Can't read eeprom\n");
1133 			return ret;
1134 		}
1135 		eedata_cur += msg_read.len;
1136 		len_todo -= msg_read.len;
1137 	}
1138 
1139 	for (i = 0; i + 15 < len; i += 16)
1140 		dev_dbg(dev->dev, "i2c eeprom %02x: %*ph\n",
1141 			i, 16, &eedata[i]);
1142 
1143 	return 0;
1144 }
1145 
1146 void cx231xx_card_setup(struct cx231xx *dev)
1147 {
1148 
1149 	cx231xx_set_model(dev);
1150 
1151 	dev->tuner_type = cx231xx_boards[dev->model].tuner_type;
1152 	if (cx231xx_boards[dev->model].tuner_addr)
1153 		dev->tuner_addr = cx231xx_boards[dev->model].tuner_addr;
1154 
1155 	/* request some modules */
1156 	if (dev->board.decoder == CX231XX_AVDECODER) {
1157 		dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1158 					cx231xx_get_i2c_adap(dev, I2C_0),
1159 					"cx25840", 0x88 >> 1, NULL);
1160 		if (dev->sd_cx25840 == NULL)
1161 			dev_err(dev->dev,
1162 				"cx25840 subdev registration failure\n");
1163 		cx25840_call(dev, core, load_fw);
1164 
1165 	}
1166 
1167 	/* Initialize the tuner */
1168 	if (dev->board.tuner_type != TUNER_ABSENT) {
1169 		struct i2c_adapter *tuner_i2c = cx231xx_get_i2c_adap(dev,
1170 						dev->board.tuner_i2c_master);
1171 		dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1172 						    tuner_i2c,
1173 						    "tuner",
1174 						    dev->tuner_addr, NULL);
1175 		if (dev->sd_tuner == NULL)
1176 			dev_err(dev->dev,
1177 				"tuner subdev registration failure\n");
1178 		else
1179 			cx231xx_config_tuner(dev);
1180 	}
1181 
1182 	switch (dev->model) {
1183 	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
1184 	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1185 	case CX231XX_BOARD_HAUPPAUGE_955Q:
1186 		{
1187 			struct eeprom {
1188 				struct tveeprom tvee;
1189 				u8 eeprom[256];
1190 				struct i2c_client client;
1191 			};
1192 			struct eeprom *e = kzalloc(sizeof(*e), GFP_KERNEL);
1193 
1194 			if (e == NULL) {
1195 				dev_err(dev->dev,
1196 					"failed to allocate memory to read eeprom\n");
1197 				break;
1198 			}
1199 			e->client.adapter = cx231xx_get_i2c_adap(dev, I2C_1_MUX_1);
1200 			e->client.addr = 0xa0 >> 1;
1201 
1202 			read_eeprom(dev, &e->client, e->eeprom, sizeof(e->eeprom));
1203 			tveeprom_hauppauge_analog(&e->tvee, e->eeprom + 0xc0);
1204 			kfree(e);
1205 			break;
1206 		}
1207 	}
1208 
1209 }
1210 
1211 /*
1212  * cx231xx_config()
1213  * inits registers with sane defaults
1214  */
1215 int cx231xx_config(struct cx231xx *dev)
1216 {
1217 	/* TBD need to add cx231xx specific code */
1218 
1219 	return 0;
1220 }
1221 
1222 /*
1223  * cx231xx_config_i2c()
1224  * configure i2c attached devices
1225  */
1226 void cx231xx_config_i2c(struct cx231xx *dev)
1227 {
1228 	/* u32 input = INPUT(dev->video_input)->vmux; */
1229 
1230 	call_all(dev, video, s_stream, 1);
1231 }
1232 
1233 static void cx231xx_unregister_media_device(struct cx231xx *dev)
1234 {
1235 #ifdef CONFIG_MEDIA_CONTROLLER
1236 	if (dev->media_dev) {
1237 		media_device_unregister(dev->media_dev);
1238 		media_device_cleanup(dev->media_dev);
1239 		kfree(dev->media_dev);
1240 		dev->media_dev = NULL;
1241 	}
1242 #endif
1243 }
1244 
1245 /*
1246  * cx231xx_realease_resources()
1247  * unregisters the v4l2,i2c and usb devices
1248  * called when the device gets disconected or at module unload
1249 */
1250 void cx231xx_release_resources(struct cx231xx *dev)
1251 {
1252 	cx231xx_ir_exit(dev);
1253 
1254 	cx231xx_release_analog_resources(dev);
1255 
1256 	cx231xx_remove_from_devlist(dev);
1257 
1258 	/* Release I2C buses */
1259 	cx231xx_dev_uninit(dev);
1260 
1261 	/* delete v4l2 device */
1262 	v4l2_device_unregister(&dev->v4l2_dev);
1263 
1264 	cx231xx_unregister_media_device(dev);
1265 
1266 	usb_put_dev(dev->udev);
1267 
1268 	/* Mark device as unused */
1269 	clear_bit(dev->devno, &cx231xx_devused);
1270 }
1271 
1272 static int cx231xx_media_device_init(struct cx231xx *dev,
1273 				      struct usb_device *udev)
1274 {
1275 #ifdef CONFIG_MEDIA_CONTROLLER
1276 	struct media_device *mdev;
1277 
1278 	mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
1279 	if (!mdev)
1280 		return -ENOMEM;
1281 
1282 	media_device_usb_init(mdev, udev, dev->board.name);
1283 
1284 	dev->media_dev = mdev;
1285 #endif
1286 	return 0;
1287 }
1288 
1289 /*
1290  * cx231xx_init_dev()
1291  * allocates and inits the device structs, registers i2c bus and v4l device
1292  */
1293 static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
1294 			    int minor)
1295 {
1296 	int retval = -ENOMEM;
1297 	unsigned int maxh, maxw;
1298 
1299 	dev->udev = udev;
1300 	mutex_init(&dev->lock);
1301 	mutex_init(&dev->ctrl_urb_lock);
1302 	mutex_init(&dev->gpio_i2c_lock);
1303 	mutex_init(&dev->i2c_lock);
1304 
1305 	spin_lock_init(&dev->video_mode.slock);
1306 	spin_lock_init(&dev->vbi_mode.slock);
1307 	spin_lock_init(&dev->sliced_cc_mode.slock);
1308 
1309 	init_waitqueue_head(&dev->open);
1310 	init_waitqueue_head(&dev->wait_frame);
1311 	init_waitqueue_head(&dev->wait_stream);
1312 
1313 	dev->cx231xx_read_ctrl_reg = cx231xx_read_ctrl_reg;
1314 	dev->cx231xx_write_ctrl_reg = cx231xx_write_ctrl_reg;
1315 	dev->cx231xx_send_usb_command = cx231xx_send_usb_command;
1316 	dev->cx231xx_gpio_i2c_read = cx231xx_gpio_i2c_read;
1317 	dev->cx231xx_gpio_i2c_write = cx231xx_gpio_i2c_write;
1318 
1319 	/* Query cx231xx to find what pcb config it is related to */
1320 	retval = initialize_cx231xx(dev);
1321 	if (retval < 0) {
1322 		dev_err(dev->dev, "Failed to read PCB config\n");
1323 		return retval;
1324 	}
1325 
1326 	/*To workaround error number=-71 on EP0 for VideoGrabber,
1327 		 need set alt here.*/
1328 	if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER ||
1329 	    dev->model == CX231XX_BOARD_HAUPPAUGE_USBLIVE2) {
1330 		cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
1331 		cx231xx_set_alt_setting(dev, INDEX_VANC, 1);
1332 	}
1333 	/* Cx231xx pre card setup */
1334 	cx231xx_pre_card_setup(dev);
1335 
1336 	retval = cx231xx_config(dev);
1337 	if (retval) {
1338 		dev_err(dev->dev, "error configuring device\n");
1339 		return -ENOMEM;
1340 	}
1341 
1342 	/* set default norm */
1343 	dev->norm = dev->board.norm;
1344 
1345 	/* register i2c bus */
1346 	retval = cx231xx_dev_init(dev);
1347 	if (retval) {
1348 		dev_err(dev->dev,
1349 			"%s: cx231xx_i2c_register - errCode [%d]!\n",
1350 			__func__, retval);
1351 		goto err_dev_init;
1352 	}
1353 
1354 	/* Do board specific init */
1355 	cx231xx_card_setup(dev);
1356 
1357 	/* configure the device */
1358 	cx231xx_config_i2c(dev);
1359 
1360 	maxw = norm_maxw(dev);
1361 	maxh = norm_maxh(dev);
1362 
1363 	/* set default image size */
1364 	dev->width = maxw;
1365 	dev->height = maxh;
1366 	dev->interlaced = 0;
1367 	dev->video_input = 0;
1368 
1369 	retval = cx231xx_config(dev);
1370 	if (retval) {
1371 		dev_err(dev->dev, "%s: cx231xx_config - errCode [%d]!\n",
1372 			__func__, retval);
1373 		goto err_dev_init;
1374 	}
1375 
1376 	/* init video dma queues */
1377 	INIT_LIST_HEAD(&dev->video_mode.vidq.active);
1378 	INIT_LIST_HEAD(&dev->video_mode.vidq.queued);
1379 
1380 	/* init vbi dma queues */
1381 	INIT_LIST_HEAD(&dev->vbi_mode.vidq.active);
1382 	INIT_LIST_HEAD(&dev->vbi_mode.vidq.queued);
1383 
1384 	/* Reset other chips required if they are tied up with GPIO pins */
1385 	cx231xx_add_into_devlist(dev);
1386 
1387 	if (dev->board.has_417) {
1388 		dev_info(dev->dev, "attach 417 %d\n", dev->model);
1389 		if (cx231xx_417_register(dev) < 0) {
1390 			dev_err(dev->dev,
1391 				"%s() Failed to register 417 on VID_B\n",
1392 				__func__);
1393 		}
1394 	}
1395 
1396 	retval = cx231xx_register_analog_devices(dev);
1397 	if (retval)
1398 		goto err_analog;
1399 
1400 	cx231xx_ir_init(dev);
1401 
1402 	cx231xx_init_extension(dev);
1403 
1404 	return 0;
1405 err_analog:
1406 	cx231xx_unregister_media_device(dev);
1407 	cx231xx_release_analog_resources(dev);
1408 	cx231xx_remove_from_devlist(dev);
1409 err_dev_init:
1410 	cx231xx_dev_uninit(dev);
1411 	return retval;
1412 }
1413 
1414 #if defined(CONFIG_MODULES) && defined(MODULE)
1415 static void request_module_async(struct work_struct *work)
1416 {
1417 	struct cx231xx *dev = container_of(work,
1418 					   struct cx231xx, request_module_wk);
1419 
1420 	if (dev->has_alsa_audio)
1421 		request_module("cx231xx-alsa");
1422 
1423 	if (dev->board.has_dvb)
1424 		request_module("cx231xx-dvb");
1425 
1426 }
1427 
1428 static void request_modules(struct cx231xx *dev)
1429 {
1430 	INIT_WORK(&dev->request_module_wk, request_module_async);
1431 	schedule_work(&dev->request_module_wk);
1432 }
1433 
1434 static void flush_request_modules(struct cx231xx *dev)
1435 {
1436 	flush_work(&dev->request_module_wk);
1437 }
1438 #else
1439 #define request_modules(dev)
1440 #define flush_request_modules(dev)
1441 #endif /* CONFIG_MODULES */
1442 
1443 static int cx231xx_init_v4l2(struct cx231xx *dev,
1444 			     struct usb_device *udev,
1445 			     struct usb_interface *interface,
1446 			     int isoc_pipe)
1447 {
1448 	struct usb_interface *uif;
1449 	int i, idx;
1450 
1451 	/* Video Init */
1452 
1453 	/* compute alternate max packet sizes for video */
1454 	idx = dev->current_pcb_config.hs_config_info[0].interface_info.video_index + 1;
1455 	if (idx >= dev->max_iad_interface_count) {
1456 		dev_err(dev->dev,
1457 			"Video PCB interface #%d doesn't exist\n", idx);
1458 		return -ENODEV;
1459 	}
1460 
1461 	uif = udev->actconfig->interface[idx];
1462 
1463 	if (uif->altsetting[0].desc.bNumEndpoints < isoc_pipe + 1)
1464 		return -ENODEV;
1465 
1466 	dev->video_mode.end_point_addr = uif->altsetting[0].endpoint[isoc_pipe].desc.bEndpointAddress;
1467 	dev->video_mode.num_alt = uif->num_altsetting;
1468 
1469 	dev_info(dev->dev,
1470 		 "video EndPoint Addr 0x%x, Alternate settings: %i\n",
1471 		 dev->video_mode.end_point_addr,
1472 		 dev->video_mode.num_alt);
1473 
1474 	dev->video_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->video_mode.num_alt, GFP_KERNEL);
1475 	if (dev->video_mode.alt_max_pkt_size == NULL)
1476 		return -ENOMEM;
1477 
1478 	for (i = 0; i < dev->video_mode.num_alt; i++) {
1479 		u16 tmp;
1480 
1481 		if (uif->altsetting[i].desc.bNumEndpoints < isoc_pipe + 1)
1482 			return -ENODEV;
1483 
1484 		tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.wMaxPacketSize);
1485 		dev->video_mode.alt_max_pkt_size[i] = (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1486 		dev_dbg(dev->dev,
1487 			"Alternate setting %i, max size= %i\n", i,
1488 			dev->video_mode.alt_max_pkt_size[i]);
1489 	}
1490 
1491 	/* VBI Init */
1492 
1493 	idx = dev->current_pcb_config.hs_config_info[0].interface_info.vanc_index + 1;
1494 	if (idx >= dev->max_iad_interface_count) {
1495 		dev_err(dev->dev,
1496 			"VBI PCB interface #%d doesn't exist\n", idx);
1497 		return -ENODEV;
1498 	}
1499 	uif = udev->actconfig->interface[idx];
1500 
1501 	if (uif->altsetting[0].desc.bNumEndpoints < isoc_pipe + 1)
1502 		return -ENODEV;
1503 
1504 	dev->vbi_mode.end_point_addr =
1505 	    uif->altsetting[0].endpoint[isoc_pipe].desc.
1506 			bEndpointAddress;
1507 
1508 	dev->vbi_mode.num_alt = uif->num_altsetting;
1509 	dev_info(dev->dev,
1510 		 "VBI EndPoint Addr 0x%x, Alternate settings: %i\n",
1511 		 dev->vbi_mode.end_point_addr,
1512 		 dev->vbi_mode.num_alt);
1513 
1514 	/* compute alternate max packet sizes for vbi */
1515 	dev->vbi_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->vbi_mode.num_alt, GFP_KERNEL);
1516 	if (dev->vbi_mode.alt_max_pkt_size == NULL)
1517 		return -ENOMEM;
1518 
1519 	for (i = 0; i < dev->vbi_mode.num_alt; i++) {
1520 		u16 tmp;
1521 
1522 		if (uif->altsetting[i].desc.bNumEndpoints < isoc_pipe + 1)
1523 			return -ENODEV;
1524 
1525 		tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
1526 				desc.wMaxPacketSize);
1527 		dev->vbi_mode.alt_max_pkt_size[i] =
1528 		    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1529 		dev_dbg(dev->dev,
1530 			"Alternate setting %i, max size= %i\n", i,
1531 			dev->vbi_mode.alt_max_pkt_size[i]);
1532 	}
1533 
1534 	/* Sliced CC VBI init */
1535 
1536 	/* compute alternate max packet sizes for sliced CC */
1537 	idx = dev->current_pcb_config.hs_config_info[0].interface_info.hanc_index + 1;
1538 	if (idx >= dev->max_iad_interface_count) {
1539 		dev_err(dev->dev,
1540 			"Sliced CC PCB interface #%d doesn't exist\n", idx);
1541 		return -ENODEV;
1542 	}
1543 	uif = udev->actconfig->interface[idx];
1544 
1545 	if (uif->altsetting[0].desc.bNumEndpoints < isoc_pipe + 1)
1546 		return -ENODEV;
1547 
1548 	dev->sliced_cc_mode.end_point_addr =
1549 	    uif->altsetting[0].endpoint[isoc_pipe].desc.
1550 			bEndpointAddress;
1551 
1552 	dev->sliced_cc_mode.num_alt = uif->num_altsetting;
1553 	dev_info(dev->dev,
1554 		 "sliced CC EndPoint Addr 0x%x, Alternate settings: %i\n",
1555 		 dev->sliced_cc_mode.end_point_addr,
1556 		 dev->sliced_cc_mode.num_alt);
1557 	dev->sliced_cc_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->sliced_cc_mode.num_alt, GFP_KERNEL);
1558 	if (dev->sliced_cc_mode.alt_max_pkt_size == NULL)
1559 		return -ENOMEM;
1560 
1561 	for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
1562 		u16 tmp;
1563 
1564 		if (uif->altsetting[i].desc.bNumEndpoints < isoc_pipe + 1)
1565 			return -ENODEV;
1566 
1567 		tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
1568 				desc.wMaxPacketSize);
1569 		dev->sliced_cc_mode.alt_max_pkt_size[i] =
1570 		    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1571 		dev_dbg(dev->dev,
1572 			"Alternate setting %i, max size= %i\n", i,
1573 			dev->sliced_cc_mode.alt_max_pkt_size[i]);
1574 	}
1575 
1576 	return 0;
1577 }
1578 
1579 /*
1580  * cx231xx_usb_probe()
1581  * checks for supported devices
1582  */
1583 static int cx231xx_usb_probe(struct usb_interface *interface,
1584 			     const struct usb_device_id *id)
1585 {
1586 	struct usb_device *udev;
1587 	struct device *d = &interface->dev;
1588 	struct usb_interface *uif;
1589 	struct cx231xx *dev = NULL;
1590 	int retval = -ENODEV;
1591 	int nr = 0, ifnum;
1592 	int i, isoc_pipe = 0;
1593 	char *speed;
1594 	u8 idx;
1595 	struct usb_interface_assoc_descriptor *assoc_desc;
1596 
1597 	ifnum = interface->altsetting[0].desc.bInterfaceNumber;
1598 
1599 	/*
1600 	 * Interface number 0 - IR interface (handled by mceusb driver)
1601 	 * Interface number 1 - AV interface (handled by this driver)
1602 	 */
1603 	if (ifnum != 1)
1604 		return -ENODEV;
1605 
1606 	/* Check to see next free device and mark as used */
1607 	do {
1608 		nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
1609 		if (nr >= CX231XX_MAXBOARDS) {
1610 			/* No free device slots */
1611 			dev_err(d,
1612 				"Supports only %i devices.\n",
1613 				CX231XX_MAXBOARDS);
1614 			return -ENOMEM;
1615 		}
1616 	} while (test_and_set_bit(nr, &cx231xx_devused));
1617 
1618 	udev = usb_get_dev(interface_to_usbdev(interface));
1619 
1620 	/* allocate memory for our device state and initialize it */
1621 	dev = devm_kzalloc(&udev->dev, sizeof(*dev), GFP_KERNEL);
1622 	if (dev == NULL) {
1623 		retval = -ENOMEM;
1624 		goto err_if;
1625 	}
1626 
1627 	snprintf(dev->name, 29, "cx231xx #%d", nr);
1628 	dev->devno = nr;
1629 	dev->model = id->driver_info;
1630 	dev->video_mode.alt = -1;
1631 	dev->dev = d;
1632 
1633 	cx231xx_set_model(dev);
1634 
1635 	dev->interface_count++;
1636 	/* reset gpio dir and value */
1637 	dev->gpio_dir = 0;
1638 	dev->gpio_val = 0;
1639 	dev->xc_fw_load_done = 0;
1640 	dev->has_alsa_audio = 1;
1641 	dev->power_mode = -1;
1642 	atomic_set(&dev->devlist_count, 0);
1643 
1644 	/* 0 - vbi ; 1 -sliced cc mode */
1645 	dev->vbi_or_sliced_cc_mode = 0;
1646 
1647 	/* get maximum no.of IAD interfaces */
1648 	dev->max_iad_interface_count = udev->config->desc.bNumInterfaces;
1649 
1650 	/* init CIR module TBD */
1651 
1652 	/*mode_tv: digital=1 or analog=0*/
1653 	dev->mode_tv = 0;
1654 
1655 	dev->USE_ISO = transfer_mode;
1656 
1657 	switch (udev->speed) {
1658 	case USB_SPEED_LOW:
1659 		speed = "1.5";
1660 		break;
1661 	case USB_SPEED_UNKNOWN:
1662 	case USB_SPEED_FULL:
1663 		speed = "12";
1664 		break;
1665 	case USB_SPEED_HIGH:
1666 		speed = "480";
1667 		break;
1668 	default:
1669 		speed = "unknown";
1670 	}
1671 
1672 	dev_info(d,
1673 		 "New device %s %s @ %s Mbps (%04x:%04x) with %d interfaces\n",
1674 		 udev->manufacturer ? udev->manufacturer : "",
1675 		 udev->product ? udev->product : "",
1676 		 speed,
1677 		 le16_to_cpu(udev->descriptor.idVendor),
1678 		 le16_to_cpu(udev->descriptor.idProduct),
1679 		 dev->max_iad_interface_count);
1680 
1681 	/* increment interface count */
1682 	dev->interface_count++;
1683 
1684 	/* get device number */
1685 	nr = dev->devno;
1686 
1687 	assoc_desc = udev->actconfig->intf_assoc[0];
1688 	if (!assoc_desc || assoc_desc->bFirstInterface != ifnum) {
1689 		dev_err(d, "Not found matching IAD interface\n");
1690 		retval = -ENODEV;
1691 		goto err_if;
1692 	}
1693 
1694 	dev_dbg(d, "registering interface %d\n", ifnum);
1695 
1696 	/* save our data pointer in this interface device */
1697 	usb_set_intfdata(interface, dev);
1698 
1699 	/* Initialize the media controller */
1700 	retval = cx231xx_media_device_init(dev, udev);
1701 	if (retval) {
1702 		dev_err(d, "cx231xx_media_device_init failed\n");
1703 		goto err_media_init;
1704 	}
1705 
1706 	/* Create v4l2 device */
1707 #ifdef CONFIG_MEDIA_CONTROLLER
1708 	dev->v4l2_dev.mdev = dev->media_dev;
1709 #endif
1710 	retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
1711 	if (retval) {
1712 		dev_err(d, "v4l2_device_register failed\n");
1713 		goto err_v4l2;
1714 	}
1715 
1716 	/* allocate device struct */
1717 	retval = cx231xx_init_dev(dev, udev, nr);
1718 	if (retval)
1719 		goto err_init;
1720 
1721 	retval = cx231xx_init_v4l2(dev, udev, interface, isoc_pipe);
1722 	if (retval)
1723 		goto err_init;
1724 
1725 	if (dev->current_pcb_config.ts1_source != 0xff) {
1726 		/* compute alternate max packet sizes for TS1 */
1727 		idx = dev->current_pcb_config.hs_config_info[0].interface_info.ts1_index + 1;
1728 		if (idx >= dev->max_iad_interface_count) {
1729 			dev_err(d, "TS1 PCB interface #%d doesn't exist\n",
1730 				idx);
1731 			retval = -ENODEV;
1732 			goto err_video_alt;
1733 		}
1734 		uif = udev->actconfig->interface[idx];
1735 
1736 		if (uif->altsetting[0].desc.bNumEndpoints < isoc_pipe + 1) {
1737 			retval = -ENODEV;
1738 			goto err_video_alt;
1739 		}
1740 
1741 		dev->ts1_mode.end_point_addr =
1742 		    uif->altsetting[0].endpoint[isoc_pipe].
1743 				desc.bEndpointAddress;
1744 
1745 		dev->ts1_mode.num_alt = uif->num_altsetting;
1746 		dev_info(d,
1747 			 "TS EndPoint Addr 0x%x, Alternate settings: %i\n",
1748 			 dev->ts1_mode.end_point_addr,
1749 			 dev->ts1_mode.num_alt);
1750 
1751 		dev->ts1_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->ts1_mode.num_alt, GFP_KERNEL);
1752 		if (dev->ts1_mode.alt_max_pkt_size == NULL) {
1753 			retval = -ENOMEM;
1754 			goto err_video_alt;
1755 		}
1756 
1757 		for (i = 0; i < dev->ts1_mode.num_alt; i++) {
1758 			u16 tmp;
1759 
1760 			if (uif->altsetting[i].desc.bNumEndpoints < isoc_pipe + 1) {
1761 				retval = -ENODEV;
1762 				goto err_video_alt;
1763 			}
1764 
1765 			tmp = le16_to_cpu(uif->altsetting[i].
1766 						endpoint[isoc_pipe].desc.
1767 						wMaxPacketSize);
1768 			dev->ts1_mode.alt_max_pkt_size[i] =
1769 			    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1770 			dev_dbg(d, "Alternate setting %i, max size= %i\n",
1771 				i, dev->ts1_mode.alt_max_pkt_size[i]);
1772 		}
1773 	}
1774 
1775 	if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER) {
1776 		cx231xx_enable_OSC(dev);
1777 		cx231xx_reset_out(dev);
1778 		cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
1779 	}
1780 
1781 	if (dev->model == CX231XX_BOARD_CNXT_RDE_253S)
1782 		cx231xx_sleep_s5h1432(dev);
1783 
1784 	/* load other modules required */
1785 	request_modules(dev);
1786 
1787 #ifdef CONFIG_MEDIA_CONTROLLER
1788 	/* Init entities at the Media Controller */
1789 	cx231xx_v4l2_create_entities(dev);
1790 
1791 	retval = v4l2_mc_create_media_graph(dev->media_dev);
1792 	if (!retval)
1793 		retval = media_device_register(dev->media_dev);
1794 #endif
1795 	if (retval < 0)
1796 		cx231xx_release_resources(dev);
1797 	return retval;
1798 
1799 err_video_alt:
1800 	/* cx231xx_uninit_dev: */
1801 	cx231xx_close_extension(dev);
1802 	cx231xx_ir_exit(dev);
1803 	cx231xx_release_analog_resources(dev);
1804 	cx231xx_417_unregister(dev);
1805 	cx231xx_remove_from_devlist(dev);
1806 	cx231xx_dev_uninit(dev);
1807 err_init:
1808 	v4l2_device_unregister(&dev->v4l2_dev);
1809 err_v4l2:
1810 	cx231xx_unregister_media_device(dev);
1811 err_media_init:
1812 	usb_set_intfdata(interface, NULL);
1813 err_if:
1814 	usb_put_dev(udev);
1815 	clear_bit(nr, &cx231xx_devused);
1816 	return retval;
1817 }
1818 
1819 /*
1820  * cx231xx_usb_disconnect()
1821  * called when the device gets diconencted
1822  * video device will be unregistered on v4l2_close in case it is still open
1823  */
1824 static void cx231xx_usb_disconnect(struct usb_interface *interface)
1825 {
1826 	struct cx231xx *dev;
1827 
1828 	dev = usb_get_intfdata(interface);
1829 	usb_set_intfdata(interface, NULL);
1830 
1831 	if (!dev)
1832 		return;
1833 
1834 	if (!dev->udev)
1835 		return;
1836 
1837 	dev->state |= DEV_DISCONNECTED;
1838 
1839 	flush_request_modules(dev);
1840 
1841 	/* wait until all current v4l2 io is finished then deallocate
1842 	   resources */
1843 	mutex_lock(&dev->lock);
1844 
1845 	wake_up_interruptible_all(&dev->open);
1846 
1847 	if (dev->users) {
1848 		dev_warn(dev->dev,
1849 			 "device %s is open! Deregistration and memory deallocation are deferred on close.\n",
1850 			 video_device_node_name(&dev->vdev));
1851 
1852 		/* Even having users, it is safe to remove the RC i2c driver */
1853 		cx231xx_ir_exit(dev);
1854 
1855 		if (dev->USE_ISO)
1856 			cx231xx_uninit_isoc(dev);
1857 		else
1858 			cx231xx_uninit_bulk(dev);
1859 		wake_up_interruptible(&dev->wait_frame);
1860 		wake_up_interruptible(&dev->wait_stream);
1861 	} else {
1862 	}
1863 
1864 	cx231xx_close_extension(dev);
1865 
1866 	mutex_unlock(&dev->lock);
1867 
1868 	if (!dev->users)
1869 		cx231xx_release_resources(dev);
1870 }
1871 
1872 static struct usb_driver cx231xx_usb_driver = {
1873 	.name = "cx231xx",
1874 	.probe = cx231xx_usb_probe,
1875 	.disconnect = cx231xx_usb_disconnect,
1876 	.id_table = cx231xx_id_table,
1877 };
1878 
1879 module_usb_driver(cx231xx_usb_driver);
1880