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 = 0x00,	/* According with PV cxPolaris.inf file */
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 };
845 const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
846 
847 /* table of devices that work with this driver */
848 struct usb_device_id cx231xx_id_table[] = {
849 	{USB_DEVICE(0x1D19, 0x6109),
850 	.driver_info = CX231XX_BOARD_PV_XCAPTURE_USB},
851 	{USB_DEVICE(0x0572, 0x5A3C),
852 	 .driver_info = CX231XX_BOARD_UNKNOWN},
853 	{USB_DEVICE(0x0572, 0x58A2),
854 	 .driver_info = CX231XX_BOARD_CNXT_CARRAERA},
855 	{USB_DEVICE(0x0572, 0x58A1),
856 	 .driver_info = CX231XX_BOARD_CNXT_SHELBY},
857 	{USB_DEVICE(0x0572, 0x58A4),
858 	 .driver_info = CX231XX_BOARD_CNXT_RDE_253S},
859 	{USB_DEVICE(0x0572, 0x58A5),
860 	 .driver_info = CX231XX_BOARD_CNXT_RDU_253S},
861 	{USB_DEVICE(0x0572, 0x58A6),
862 	 .driver_info = CX231XX_BOARD_CNXT_VIDEO_GRABBER},
863 	{USB_DEVICE(0x0572, 0x589E),
864 	 .driver_info = CX231XX_BOARD_CNXT_RDE_250},
865 	{USB_DEVICE(0x0572, 0x58A0),
866 	 .driver_info = CX231XX_BOARD_CNXT_RDU_250},
867 	{USB_DEVICE(0x2040, 0xb110),
868 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL},
869 	{USB_DEVICE(0x2040, 0xb111),
870 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC},
871 	{USB_DEVICE(0x2040, 0xb120),
872 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
873 	{USB_DEVICE(0x2040, 0xb123),
874 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_955Q},
875 	{USB_DEVICE(0x2040, 0xb130),
876 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
877 	{USB_DEVICE(0x2040, 0xb131),
878 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
879 	/* Hauppauge WinTV-HVR-900-H */
880 	{USB_DEVICE(0x2040, 0xb138),
881 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
882 	/* Hauppauge WinTV-HVR-901-H */
883 	{USB_DEVICE(0x2040, 0xb139),
884 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
885 	{USB_DEVICE(0x2040, 0xb140),
886 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
887 	{USB_DEVICE(0x2040, 0xc200),
888 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_USBLIVE2},
889 	/* PCTV QuatroStick 521e */
890 	{USB_DEVICE(0x2013, 0x0259),
891 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx},
892 	/* PCTV QuatroStick 522e */
893 	{USB_DEVICE(0x2013, 0x025e),
894 	 .driver_info = CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx},
895 	{USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x4000, 0x4001),
896 	 .driver_info = CX231XX_BOARD_PV_PLAYTV_USB_HYBRID},
897 	{USB_DEVICE(USB_VID_PIXELVIEW, 0x5014),
898 	 .driver_info = CX231XX_BOARD_PV_XCAPTURE_USB},
899 	{USB_DEVICE(0x1b80, 0xe424),
900 	 .driver_info = CX231XX_BOARD_KWORLD_UB430_USB_HYBRID},
901 	{USB_DEVICE(0x1b80, 0xe421),
902 	 .driver_info = CX231XX_BOARD_KWORLD_UB445_USB_HYBRID},
903 	{USB_DEVICE(0x1f4d, 0x0237),
904 	 .driver_info = CX231XX_BOARD_ICONBIT_U100},
905 	{USB_DEVICE(0x0fd9, 0x0037),
906 	 .driver_info = CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2},
907 	{USB_DEVICE(0x1f4d, 0x0102),
908 	 .driver_info = CX231XX_BOARD_OTG102},
909 	{USB_DEVICE(USB_VID_TERRATEC, 0x00a6),
910 	 .driver_info = CX231XX_BOARD_TERRATEC_GRABBY},
911 	{},
912 };
913 
914 MODULE_DEVICE_TABLE(usb, cx231xx_id_table);
915 
916 /* cx231xx_tuner_callback
917  * will be used to reset XC5000 tuner using GPIO pin
918  */
919 
920 int cx231xx_tuner_callback(void *ptr, int component, int command, int arg)
921 {
922 	int rc = 0;
923 	struct cx231xx *dev = ptr;
924 
925 	if (dev->tuner_type == TUNER_XC5000) {
926 		if (command == XC5000_TUNER_RESET) {
927 			dev_dbg(dev->dev,
928 				"Tuner CB: RESET: cmd %d : tuner type %d\n",
929 				command, dev->tuner_type);
930 			cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
931 					       1);
932 			msleep(10);
933 			cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
934 					       0);
935 			msleep(330);
936 			cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
937 					       1);
938 			msleep(10);
939 		}
940 	} else if (dev->tuner_type == TUNER_NXP_TDA18271) {
941 		switch (command) {
942 		case TDA18271_CALLBACK_CMD_AGC_ENABLE:
943 			if (dev->model == CX231XX_BOARD_PV_PLAYTV_USB_HYBRID)
944 				rc = cx231xx_set_agc_analog_digital_mux_select(dev, arg);
945 			break;
946 		default:
947 			rc = -EINVAL;
948 			break;
949 		}
950 	}
951 	return rc;
952 }
953 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback);
954 
955 static void cx231xx_reset_out(struct cx231xx *dev)
956 {
957 	cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
958 	msleep(200);
959 	cx231xx_set_gpio_value(dev, CX23417_RESET, 0);
960 	msleep(200);
961 	cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
962 }
963 
964 static void cx231xx_enable_OSC(struct cx231xx *dev)
965 {
966 	cx231xx_set_gpio_value(dev, CX23417_OSC_EN, 1);
967 }
968 
969 static void cx231xx_sleep_s5h1432(struct cx231xx *dev)
970 {
971 	cx231xx_set_gpio_value(dev, SLEEP_S5H1432, 0);
972 }
973 
974 static inline void cx231xx_set_model(struct cx231xx *dev)
975 {
976 	dev->board = cx231xx_boards[dev->model];
977 }
978 
979 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
980  * this won't work for boards with generic PCI IDs
981  */
982 void cx231xx_pre_card_setup(struct cx231xx *dev)
983 {
984 	dev_info(dev->dev, "Identified as %s (card=%d)\n",
985 		dev->board.name, dev->model);
986 
987 	/* set the direction for GPIO pins */
988 	if (dev->board.tuner_gpio) {
989 		cx231xx_set_gpio_direction(dev, dev->board.tuner_gpio->bit, 1);
990 		cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit, 1);
991 	}
992 	if (dev->board.tuner_sif_gpio >= 0)
993 		cx231xx_set_gpio_direction(dev, dev->board.tuner_sif_gpio, 1);
994 
995 	/* request some modules if any required */
996 
997 	/* set the mode to Analog mode initially */
998 	cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
999 
1000 	/* Unlock device */
1001 	/* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
1002 
1003 }
1004 
1005 static void cx231xx_config_tuner(struct cx231xx *dev)
1006 {
1007 	struct tuner_setup tun_setup;
1008 	struct v4l2_frequency f;
1009 
1010 	if (dev->tuner_type == TUNER_ABSENT)
1011 		return;
1012 
1013 	tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
1014 	tun_setup.type = dev->tuner_type;
1015 	tun_setup.addr = dev->tuner_addr;
1016 	tun_setup.tuner_callback = cx231xx_tuner_callback;
1017 
1018 	tuner_call(dev, tuner, s_type_addr, &tun_setup);
1019 
1020 #if 0
1021 	if (tun_setup.type == TUNER_XC5000) {
1022 		static struct xc2028_ctrl ctrl = {
1023 			.fname = XC5000_DEFAULT_FIRMWARE,
1024 			.max_len = 64,
1025 			.demod = 0;
1026 		};
1027 		struct v4l2_priv_tun_config cfg = {
1028 			.tuner = dev->tuner_type,
1029 			.priv = &ctrl,
1030 		};
1031 		tuner_call(dev, tuner, s_config, &cfg);
1032 	}
1033 #endif
1034 	/* configure tuner */
1035 	f.tuner = 0;
1036 	f.type = V4L2_TUNER_ANALOG_TV;
1037 	f.frequency = 9076;	/* just a magic number */
1038 	dev->ctl_freq = f.frequency;
1039 	call_all(dev, tuner, s_frequency, &f);
1040 
1041 }
1042 
1043 static int read_eeprom(struct cx231xx *dev, struct i2c_client *client,
1044 		       u8 *eedata, int len)
1045 {
1046 	int ret = 0;
1047 	u8 start_offset = 0;
1048 	int len_todo = len;
1049 	u8 *eedata_cur = eedata;
1050 	int i;
1051 	struct i2c_msg msg_write = { .addr = client->addr, .flags = 0,
1052 		.buf = &start_offset, .len = 1 };
1053 	struct i2c_msg msg_read = { .addr = client->addr, .flags = I2C_M_RD };
1054 
1055 	/* start reading at offset 0 */
1056 	ret = i2c_transfer(client->adapter, &msg_write, 1);
1057 	if (ret < 0) {
1058 		dev_err(dev->dev, "Can't read eeprom\n");
1059 		return ret;
1060 	}
1061 
1062 	while (len_todo > 0) {
1063 		msg_read.len = (len_todo > 64) ? 64 : len_todo;
1064 		msg_read.buf = eedata_cur;
1065 
1066 		ret = i2c_transfer(client->adapter, &msg_read, 1);
1067 		if (ret < 0) {
1068 			dev_err(dev->dev, "Can't read eeprom\n");
1069 			return ret;
1070 		}
1071 		eedata_cur += msg_read.len;
1072 		len_todo -= msg_read.len;
1073 	}
1074 
1075 	for (i = 0; i + 15 < len; i += 16)
1076 		dev_dbg(dev->dev, "i2c eeprom %02x: %*ph\n",
1077 			i, 16, &eedata[i]);
1078 
1079 	return 0;
1080 }
1081 
1082 void cx231xx_card_setup(struct cx231xx *dev)
1083 {
1084 
1085 	cx231xx_set_model(dev);
1086 
1087 	dev->tuner_type = cx231xx_boards[dev->model].tuner_type;
1088 	if (cx231xx_boards[dev->model].tuner_addr)
1089 		dev->tuner_addr = cx231xx_boards[dev->model].tuner_addr;
1090 
1091 	/* request some modules */
1092 	if (dev->board.decoder == CX231XX_AVDECODER) {
1093 		dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1094 					cx231xx_get_i2c_adap(dev, I2C_0),
1095 					"cx25840", 0x88 >> 1, NULL);
1096 		if (dev->sd_cx25840 == NULL)
1097 			dev_err(dev->dev,
1098 				"cx25840 subdev registration failure\n");
1099 		cx25840_call(dev, core, load_fw);
1100 
1101 	}
1102 
1103 	/* Initialize the tuner */
1104 	if (dev->board.tuner_type != TUNER_ABSENT) {
1105 		struct i2c_adapter *tuner_i2c = cx231xx_get_i2c_adap(dev,
1106 						dev->board.tuner_i2c_master);
1107 		dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1108 						    tuner_i2c,
1109 						    "tuner",
1110 						    dev->tuner_addr, NULL);
1111 		if (dev->sd_tuner == NULL)
1112 			dev_err(dev->dev,
1113 				"tuner subdev registration failure\n");
1114 		else
1115 			cx231xx_config_tuner(dev);
1116 	}
1117 
1118 	switch (dev->model) {
1119 	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
1120 	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1121 	case CX231XX_BOARD_HAUPPAUGE_955Q:
1122 		{
1123 			struct eeprom {
1124 				struct tveeprom tvee;
1125 				u8 eeprom[256];
1126 				struct i2c_client client;
1127 			};
1128 			struct eeprom *e = kzalloc(sizeof(*e), GFP_KERNEL);
1129 
1130 			if (e == NULL) {
1131 				dev_err(dev->dev,
1132 					"failed to allocate memory to read eeprom\n");
1133 				break;
1134 			}
1135 			e->client.adapter = cx231xx_get_i2c_adap(dev, I2C_1_MUX_1);
1136 			e->client.addr = 0xa0 >> 1;
1137 
1138 			read_eeprom(dev, &e->client, e->eeprom, sizeof(e->eeprom));
1139 			tveeprom_hauppauge_analog(&e->client,
1140 						&e->tvee, e->eeprom + 0xc0);
1141 			kfree(e);
1142 			break;
1143 		}
1144 	}
1145 
1146 }
1147 
1148 /*
1149  * cx231xx_config()
1150  * inits registers with sane defaults
1151  */
1152 int cx231xx_config(struct cx231xx *dev)
1153 {
1154 	/* TBD need to add cx231xx specific code */
1155 
1156 	return 0;
1157 }
1158 
1159 /*
1160  * cx231xx_config_i2c()
1161  * configure i2c attached devices
1162  */
1163 void cx231xx_config_i2c(struct cx231xx *dev)
1164 {
1165 	/* u32 input = INPUT(dev->video_input)->vmux; */
1166 
1167 	call_all(dev, video, s_stream, 1);
1168 }
1169 
1170 static void cx231xx_unregister_media_device(struct cx231xx *dev)
1171 {
1172 #ifdef CONFIG_MEDIA_CONTROLLER
1173 	if (dev->media_dev) {
1174 		media_device_unregister(dev->media_dev);
1175 		media_device_cleanup(dev->media_dev);
1176 		kfree(dev->media_dev);
1177 		dev->media_dev = NULL;
1178 	}
1179 #endif
1180 }
1181 
1182 /*
1183  * cx231xx_realease_resources()
1184  * unregisters the v4l2,i2c and usb devices
1185  * called when the device gets disconected or at module unload
1186 */
1187 void cx231xx_release_resources(struct cx231xx *dev)
1188 {
1189 	cx231xx_release_analog_resources(dev);
1190 
1191 	cx231xx_remove_from_devlist(dev);
1192 
1193 	cx231xx_ir_exit(dev);
1194 
1195 	/* Release I2C buses */
1196 	cx231xx_dev_uninit(dev);
1197 
1198 	/* delete v4l2 device */
1199 	v4l2_device_unregister(&dev->v4l2_dev);
1200 
1201 	cx231xx_unregister_media_device(dev);
1202 
1203 	usb_put_dev(dev->udev);
1204 
1205 	/* Mark device as unused */
1206 	clear_bit(dev->devno, &cx231xx_devused);
1207 }
1208 
1209 static int cx231xx_media_device_init(struct cx231xx *dev,
1210 				      struct usb_device *udev)
1211 {
1212 #ifdef CONFIG_MEDIA_CONTROLLER
1213 	struct media_device *mdev;
1214 
1215 	mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
1216 	if (!mdev)
1217 		return -ENOMEM;
1218 
1219 	media_device_usb_init(mdev, udev, dev->board.name);
1220 
1221 	dev->media_dev = mdev;
1222 #endif
1223 	return 0;
1224 }
1225 
1226 /*
1227  * cx231xx_init_dev()
1228  * allocates and inits the device structs, registers i2c bus and v4l device
1229  */
1230 static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
1231 			    int minor)
1232 {
1233 	int retval = -ENOMEM;
1234 	unsigned int maxh, maxw;
1235 
1236 	dev->udev = udev;
1237 	mutex_init(&dev->lock);
1238 	mutex_init(&dev->ctrl_urb_lock);
1239 	mutex_init(&dev->gpio_i2c_lock);
1240 	mutex_init(&dev->i2c_lock);
1241 
1242 	spin_lock_init(&dev->video_mode.slock);
1243 	spin_lock_init(&dev->vbi_mode.slock);
1244 	spin_lock_init(&dev->sliced_cc_mode.slock);
1245 
1246 	init_waitqueue_head(&dev->open);
1247 	init_waitqueue_head(&dev->wait_frame);
1248 	init_waitqueue_head(&dev->wait_stream);
1249 
1250 	dev->cx231xx_read_ctrl_reg = cx231xx_read_ctrl_reg;
1251 	dev->cx231xx_write_ctrl_reg = cx231xx_write_ctrl_reg;
1252 	dev->cx231xx_send_usb_command = cx231xx_send_usb_command;
1253 	dev->cx231xx_gpio_i2c_read = cx231xx_gpio_i2c_read;
1254 	dev->cx231xx_gpio_i2c_write = cx231xx_gpio_i2c_write;
1255 
1256 	/* Query cx231xx to find what pcb config it is related to */
1257 	retval = initialize_cx231xx(dev);
1258 	if (retval < 0) {
1259 		dev_err(dev->dev, "Failed to read PCB config\n");
1260 		return retval;
1261 	}
1262 
1263 	/*To workaround error number=-71 on EP0 for VideoGrabber,
1264 		 need set alt here.*/
1265 	if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER ||
1266 	    dev->model == CX231XX_BOARD_HAUPPAUGE_USBLIVE2) {
1267 		cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
1268 		cx231xx_set_alt_setting(dev, INDEX_VANC, 1);
1269 	}
1270 	/* Cx231xx pre card setup */
1271 	cx231xx_pre_card_setup(dev);
1272 
1273 	retval = cx231xx_config(dev);
1274 	if (retval) {
1275 		dev_err(dev->dev, "error configuring device\n");
1276 		return -ENOMEM;
1277 	}
1278 
1279 	/* set default norm */
1280 	dev->norm = dev->board.norm;
1281 
1282 	/* register i2c bus */
1283 	retval = cx231xx_dev_init(dev);
1284 	if (retval) {
1285 		dev_err(dev->dev,
1286 			"%s: cx231xx_i2c_register - errCode [%d]!\n",
1287 			__func__, retval);
1288 		goto err_dev_init;
1289 	}
1290 
1291 	/* Do board specific init */
1292 	cx231xx_card_setup(dev);
1293 
1294 	/* configure the device */
1295 	cx231xx_config_i2c(dev);
1296 
1297 	maxw = norm_maxw(dev);
1298 	maxh = norm_maxh(dev);
1299 
1300 	/* set default image size */
1301 	dev->width = maxw;
1302 	dev->height = maxh;
1303 	dev->interlaced = 0;
1304 	dev->video_input = 0;
1305 
1306 	retval = cx231xx_config(dev);
1307 	if (retval) {
1308 		dev_err(dev->dev, "%s: cx231xx_config - errCode [%d]!\n",
1309 			__func__, retval);
1310 		goto err_dev_init;
1311 	}
1312 
1313 	/* init video dma queues */
1314 	INIT_LIST_HEAD(&dev->video_mode.vidq.active);
1315 	INIT_LIST_HEAD(&dev->video_mode.vidq.queued);
1316 
1317 	/* init vbi dma queues */
1318 	INIT_LIST_HEAD(&dev->vbi_mode.vidq.active);
1319 	INIT_LIST_HEAD(&dev->vbi_mode.vidq.queued);
1320 
1321 	/* Reset other chips required if they are tied up with GPIO pins */
1322 	cx231xx_add_into_devlist(dev);
1323 
1324 	if (dev->board.has_417) {
1325 		dev_info(dev->dev, "attach 417 %d\n", dev->model);
1326 		if (cx231xx_417_register(dev) < 0) {
1327 			dev_err(dev->dev,
1328 				"%s() Failed to register 417 on VID_B\n",
1329 				__func__);
1330 		}
1331 	}
1332 
1333 	retval = cx231xx_register_analog_devices(dev);
1334 	if (retval)
1335 		goto err_analog;
1336 
1337 	cx231xx_ir_init(dev);
1338 
1339 	cx231xx_init_extension(dev);
1340 
1341 	return 0;
1342 err_analog:
1343 	cx231xx_unregister_media_device(dev);
1344 	cx231xx_release_analog_resources(dev);
1345 	cx231xx_remove_from_devlist(dev);
1346 err_dev_init:
1347 	cx231xx_dev_uninit(dev);
1348 	return retval;
1349 }
1350 
1351 #if defined(CONFIG_MODULES) && defined(MODULE)
1352 static void request_module_async(struct work_struct *work)
1353 {
1354 	struct cx231xx *dev = container_of(work,
1355 					   struct cx231xx, request_module_wk);
1356 
1357 	if (dev->has_alsa_audio)
1358 		request_module("cx231xx-alsa");
1359 
1360 	if (dev->board.has_dvb)
1361 		request_module("cx231xx-dvb");
1362 
1363 }
1364 
1365 static void request_modules(struct cx231xx *dev)
1366 {
1367 	INIT_WORK(&dev->request_module_wk, request_module_async);
1368 	schedule_work(&dev->request_module_wk);
1369 }
1370 
1371 static void flush_request_modules(struct cx231xx *dev)
1372 {
1373 	flush_work(&dev->request_module_wk);
1374 }
1375 #else
1376 #define request_modules(dev)
1377 #define flush_request_modules(dev)
1378 #endif /* CONFIG_MODULES */
1379 
1380 static int cx231xx_init_v4l2(struct cx231xx *dev,
1381 			     struct usb_device *udev,
1382 			     struct usb_interface *interface,
1383 			     int isoc_pipe)
1384 {
1385 	struct usb_interface *uif;
1386 	int i, idx;
1387 
1388 	/* Video Init */
1389 
1390 	/* compute alternate max packet sizes for video */
1391 	idx = dev->current_pcb_config.hs_config_info[0].interface_info.video_index + 1;
1392 	if (idx >= dev->max_iad_interface_count) {
1393 		dev_err(dev->dev,
1394 			"Video PCB interface #%d doesn't exist\n", idx);
1395 		return -ENODEV;
1396 	}
1397 
1398 	uif = udev->actconfig->interface[idx];
1399 
1400 	dev->video_mode.end_point_addr = uif->altsetting[0].endpoint[isoc_pipe].desc.bEndpointAddress;
1401 	dev->video_mode.num_alt = uif->num_altsetting;
1402 
1403 	dev_info(dev->dev,
1404 		 "video EndPoint Addr 0x%x, Alternate settings: %i\n",
1405 		 dev->video_mode.end_point_addr,
1406 		 dev->video_mode.num_alt);
1407 
1408 	dev->video_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->video_mode.num_alt, GFP_KERNEL);
1409 	if (dev->video_mode.alt_max_pkt_size == NULL)
1410 		return -ENOMEM;
1411 
1412 	for (i = 0; i < dev->video_mode.num_alt; i++) {
1413 		u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.wMaxPacketSize);
1414 		dev->video_mode.alt_max_pkt_size[i] = (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1415 		dev_dbg(dev->dev,
1416 			"Alternate setting %i, max size= %i\n", i,
1417 			dev->video_mode.alt_max_pkt_size[i]);
1418 	}
1419 
1420 	/* VBI Init */
1421 
1422 	idx = dev->current_pcb_config.hs_config_info[0].interface_info.vanc_index + 1;
1423 	if (idx >= dev->max_iad_interface_count) {
1424 		dev_err(dev->dev,
1425 			"VBI PCB interface #%d doesn't exist\n", idx);
1426 		return -ENODEV;
1427 	}
1428 	uif = udev->actconfig->interface[idx];
1429 
1430 	dev->vbi_mode.end_point_addr =
1431 	    uif->altsetting[0].endpoint[isoc_pipe].desc.
1432 			bEndpointAddress;
1433 
1434 	dev->vbi_mode.num_alt = uif->num_altsetting;
1435 	dev_info(dev->dev,
1436 		 "VBI EndPoint Addr 0x%x, Alternate settings: %i\n",
1437 		 dev->vbi_mode.end_point_addr,
1438 		 dev->vbi_mode.num_alt);
1439 
1440 	/* compute alternate max packet sizes for vbi */
1441 	dev->vbi_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->vbi_mode.num_alt, GFP_KERNEL);
1442 	if (dev->vbi_mode.alt_max_pkt_size == NULL)
1443 		return -ENOMEM;
1444 
1445 	for (i = 0; i < dev->vbi_mode.num_alt; i++) {
1446 		u16 tmp =
1447 		    le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
1448 				desc.wMaxPacketSize);
1449 		dev->vbi_mode.alt_max_pkt_size[i] =
1450 		    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1451 		dev_dbg(dev->dev,
1452 			"Alternate setting %i, max size= %i\n", i,
1453 			dev->vbi_mode.alt_max_pkt_size[i]);
1454 	}
1455 
1456 	/* Sliced CC VBI init */
1457 
1458 	/* compute alternate max packet sizes for sliced CC */
1459 	idx = dev->current_pcb_config.hs_config_info[0].interface_info.hanc_index + 1;
1460 	if (idx >= dev->max_iad_interface_count) {
1461 		dev_err(dev->dev,
1462 			"Sliced CC PCB interface #%d doesn't exist\n", idx);
1463 		return -ENODEV;
1464 	}
1465 	uif = udev->actconfig->interface[idx];
1466 
1467 	dev->sliced_cc_mode.end_point_addr =
1468 	    uif->altsetting[0].endpoint[isoc_pipe].desc.
1469 			bEndpointAddress;
1470 
1471 	dev->sliced_cc_mode.num_alt = uif->num_altsetting;
1472 	dev_info(dev->dev,
1473 		 "sliced CC EndPoint Addr 0x%x, Alternate settings: %i\n",
1474 		 dev->sliced_cc_mode.end_point_addr,
1475 		 dev->sliced_cc_mode.num_alt);
1476 	dev->sliced_cc_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->sliced_cc_mode.num_alt, GFP_KERNEL);
1477 	if (dev->sliced_cc_mode.alt_max_pkt_size == NULL)
1478 		return -ENOMEM;
1479 
1480 	for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
1481 		u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
1482 				desc.wMaxPacketSize);
1483 		dev->sliced_cc_mode.alt_max_pkt_size[i] =
1484 		    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1485 		dev_dbg(dev->dev,
1486 			"Alternate setting %i, max size= %i\n", i,
1487 			dev->sliced_cc_mode.alt_max_pkt_size[i]);
1488 	}
1489 
1490 	return 0;
1491 }
1492 
1493 /*
1494  * cx231xx_usb_probe()
1495  * checks for supported devices
1496  */
1497 static int cx231xx_usb_probe(struct usb_interface *interface,
1498 			     const struct usb_device_id *id)
1499 {
1500 	struct usb_device *udev;
1501 	struct device *d = &interface->dev;
1502 	struct usb_interface *uif;
1503 	struct cx231xx *dev = NULL;
1504 	int retval = -ENODEV;
1505 	int nr = 0, ifnum;
1506 	int i, isoc_pipe = 0;
1507 	char *speed;
1508 	u8 idx;
1509 	struct usb_interface_assoc_descriptor *assoc_desc;
1510 
1511 	ifnum = interface->altsetting[0].desc.bInterfaceNumber;
1512 
1513 	/*
1514 	 * Interface number 0 - IR interface (handled by mceusb driver)
1515 	 * Interface number 1 - AV interface (handled by this driver)
1516 	 */
1517 	if (ifnum != 1)
1518 		return -ENODEV;
1519 
1520 	/* Check to see next free device and mark as used */
1521 	do {
1522 		nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
1523 		if (nr >= CX231XX_MAXBOARDS) {
1524 			/* No free device slots */
1525 			dev_err(d,
1526 				"Supports only %i devices.\n",
1527 				CX231XX_MAXBOARDS);
1528 			return -ENOMEM;
1529 		}
1530 	} while (test_and_set_bit(nr, &cx231xx_devused));
1531 
1532 	udev = usb_get_dev(interface_to_usbdev(interface));
1533 
1534 	/* allocate memory for our device state and initialize it */
1535 	dev = devm_kzalloc(&udev->dev, sizeof(*dev), GFP_KERNEL);
1536 	if (dev == NULL) {
1537 		retval = -ENOMEM;
1538 		goto err_if;
1539 	}
1540 
1541 	snprintf(dev->name, 29, "cx231xx #%d", nr);
1542 	dev->devno = nr;
1543 	dev->model = id->driver_info;
1544 	dev->video_mode.alt = -1;
1545 	dev->dev = d;
1546 
1547 	cx231xx_set_model(dev);
1548 
1549 	dev->interface_count++;
1550 	/* reset gpio dir and value */
1551 	dev->gpio_dir = 0;
1552 	dev->gpio_val = 0;
1553 	dev->xc_fw_load_done = 0;
1554 	dev->has_alsa_audio = 1;
1555 	dev->power_mode = -1;
1556 	atomic_set(&dev->devlist_count, 0);
1557 
1558 	/* 0 - vbi ; 1 -sliced cc mode */
1559 	dev->vbi_or_sliced_cc_mode = 0;
1560 
1561 	/* get maximum no.of IAD interfaces */
1562 	dev->max_iad_interface_count = udev->config->desc.bNumInterfaces;
1563 
1564 	/* init CIR module TBD */
1565 
1566 	/*mode_tv: digital=1 or analog=0*/
1567 	dev->mode_tv = 0;
1568 
1569 	dev->USE_ISO = transfer_mode;
1570 
1571 	switch (udev->speed) {
1572 	case USB_SPEED_LOW:
1573 		speed = "1.5";
1574 		break;
1575 	case USB_SPEED_UNKNOWN:
1576 	case USB_SPEED_FULL:
1577 		speed = "12";
1578 		break;
1579 	case USB_SPEED_HIGH:
1580 		speed = "480";
1581 		break;
1582 	default:
1583 		speed = "unknown";
1584 	}
1585 
1586 	dev_info(d,
1587 		 "New device %s %s @ %s Mbps (%04x:%04x) with %d interfaces\n",
1588 		 udev->manufacturer ? udev->manufacturer : "",
1589 		 udev->product ? udev->product : "",
1590 		 speed,
1591 		 le16_to_cpu(udev->descriptor.idVendor),
1592 		 le16_to_cpu(udev->descriptor.idProduct),
1593 		 dev->max_iad_interface_count);
1594 
1595 	/* increment interface count */
1596 	dev->interface_count++;
1597 
1598 	/* get device number */
1599 	nr = dev->devno;
1600 
1601 	assoc_desc = udev->actconfig->intf_assoc[0];
1602 	if (assoc_desc->bFirstInterface != ifnum) {
1603 		dev_err(d, "Not found matching IAD interface\n");
1604 		retval = -ENODEV;
1605 		goto err_if;
1606 	}
1607 
1608 	dev_dbg(d, "registering interface %d\n", ifnum);
1609 
1610 	/* save our data pointer in this interface device */
1611 	usb_set_intfdata(interface, dev);
1612 
1613 	/* Initialize the media controller */
1614 	retval = cx231xx_media_device_init(dev, udev);
1615 	if (retval) {
1616 		dev_err(d, "cx231xx_media_device_init failed\n");
1617 		goto err_media_init;
1618 	}
1619 
1620 	/* Create v4l2 device */
1621 #ifdef CONFIG_MEDIA_CONTROLLER
1622 	dev->v4l2_dev.mdev = dev->media_dev;
1623 #endif
1624 	retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
1625 	if (retval) {
1626 		dev_err(d, "v4l2_device_register failed\n");
1627 		goto err_v4l2;
1628 	}
1629 
1630 	/* allocate device struct */
1631 	retval = cx231xx_init_dev(dev, udev, nr);
1632 	if (retval)
1633 		goto err_init;
1634 
1635 	retval = cx231xx_init_v4l2(dev, udev, interface, isoc_pipe);
1636 	if (retval)
1637 		goto err_init;
1638 
1639 	if (dev->current_pcb_config.ts1_source != 0xff) {
1640 		/* compute alternate max packet sizes for TS1 */
1641 		idx = dev->current_pcb_config.hs_config_info[0].interface_info.ts1_index + 1;
1642 		if (idx >= dev->max_iad_interface_count) {
1643 			dev_err(d, "TS1 PCB interface #%d doesn't exist\n",
1644 				idx);
1645 			retval = -ENODEV;
1646 			goto err_video_alt;
1647 		}
1648 		uif = udev->actconfig->interface[idx];
1649 
1650 		dev->ts1_mode.end_point_addr =
1651 		    uif->altsetting[0].endpoint[isoc_pipe].
1652 				desc.bEndpointAddress;
1653 
1654 		dev->ts1_mode.num_alt = uif->num_altsetting;
1655 		dev_info(d,
1656 			 "TS EndPoint Addr 0x%x, Alternate settings: %i\n",
1657 			 dev->ts1_mode.end_point_addr,
1658 			 dev->ts1_mode.num_alt);
1659 
1660 		dev->ts1_mode.alt_max_pkt_size = devm_kmalloc_array(&udev->dev, 32, dev->ts1_mode.num_alt, GFP_KERNEL);
1661 		if (dev->ts1_mode.alt_max_pkt_size == NULL) {
1662 			retval = -ENOMEM;
1663 			goto err_video_alt;
1664 		}
1665 
1666 		for (i = 0; i < dev->ts1_mode.num_alt; i++) {
1667 			u16 tmp = le16_to_cpu(uif->altsetting[i].
1668 						endpoint[isoc_pipe].desc.
1669 						wMaxPacketSize);
1670 			dev->ts1_mode.alt_max_pkt_size[i] =
1671 			    (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1672 			dev_dbg(d, "Alternate setting %i, max size= %i\n",
1673 				i, dev->ts1_mode.alt_max_pkt_size[i]);
1674 		}
1675 	}
1676 
1677 	if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER) {
1678 		cx231xx_enable_OSC(dev);
1679 		cx231xx_reset_out(dev);
1680 		cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
1681 	}
1682 
1683 	if (dev->model == CX231XX_BOARD_CNXT_RDE_253S)
1684 		cx231xx_sleep_s5h1432(dev);
1685 
1686 	/* load other modules required */
1687 	request_modules(dev);
1688 
1689 #ifdef CONFIG_MEDIA_CONTROLLER
1690 	/* Init entities at the Media Controller */
1691 	cx231xx_v4l2_create_entities(dev);
1692 
1693 	retval = v4l2_mc_create_media_graph(dev->media_dev);
1694 	if (!retval)
1695 		retval = media_device_register(dev->media_dev);
1696 #endif
1697 	if (retval < 0)
1698 		cx231xx_release_resources(dev);
1699 	return retval;
1700 
1701 err_video_alt:
1702 	/* cx231xx_uninit_dev: */
1703 	cx231xx_close_extension(dev);
1704 	cx231xx_ir_exit(dev);
1705 	cx231xx_release_analog_resources(dev);
1706 	cx231xx_417_unregister(dev);
1707 	cx231xx_remove_from_devlist(dev);
1708 	cx231xx_dev_uninit(dev);
1709 err_init:
1710 	v4l2_device_unregister(&dev->v4l2_dev);
1711 err_v4l2:
1712 	cx231xx_unregister_media_device(dev);
1713 err_media_init:
1714 	usb_set_intfdata(interface, NULL);
1715 err_if:
1716 	usb_put_dev(udev);
1717 	clear_bit(nr, &cx231xx_devused);
1718 	return retval;
1719 }
1720 
1721 /*
1722  * cx231xx_usb_disconnect()
1723  * called when the device gets diconencted
1724  * video device will be unregistered on v4l2_close in case it is still open
1725  */
1726 static void cx231xx_usb_disconnect(struct usb_interface *interface)
1727 {
1728 	struct cx231xx *dev;
1729 
1730 	dev = usb_get_intfdata(interface);
1731 	usb_set_intfdata(interface, NULL);
1732 
1733 	if (!dev)
1734 		return;
1735 
1736 	if (!dev->udev)
1737 		return;
1738 
1739 	dev->state |= DEV_DISCONNECTED;
1740 
1741 	flush_request_modules(dev);
1742 
1743 	/* wait until all current v4l2 io is finished then deallocate
1744 	   resources */
1745 	mutex_lock(&dev->lock);
1746 
1747 	wake_up_interruptible_all(&dev->open);
1748 
1749 	if (dev->users) {
1750 		dev_warn(dev->dev,
1751 			 "device %s is open! Deregistration and memory deallocation are deferred on close.\n",
1752 			 video_device_node_name(&dev->vdev));
1753 
1754 		/* Even having users, it is safe to remove the RC i2c driver */
1755 		cx231xx_ir_exit(dev);
1756 
1757 		if (dev->USE_ISO)
1758 			cx231xx_uninit_isoc(dev);
1759 		else
1760 			cx231xx_uninit_bulk(dev);
1761 		wake_up_interruptible(&dev->wait_frame);
1762 		wake_up_interruptible(&dev->wait_stream);
1763 	} else {
1764 	}
1765 
1766 	cx231xx_close_extension(dev);
1767 
1768 	mutex_unlock(&dev->lock);
1769 
1770 	if (!dev->users)
1771 		cx231xx_release_resources(dev);
1772 }
1773 
1774 static struct usb_driver cx231xx_usb_driver = {
1775 	.name = "cx231xx",
1776 	.probe = cx231xx_usb_probe,
1777 	.disconnect = cx231xx_usb_disconnect,
1778 	.id_table = cx231xx_id_table,
1779 };
1780 
1781 module_usb_driver(cx231xx_usb_driver);
1782