2 cx231xx-cards.c - driver for Conexant Cx23100/101/102
3 USB video capture devices
5 Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
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.
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.
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.
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>
33 #include <media/cx25840.h>
34 #include "dvb-usb-ids.h"
39 static int tuner
= -1;
40 module_param(tuner
, int, 0444);
41 MODULE_PARM_DESC(tuner
, "tuner type");
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)");
47 static unsigned int disable_ir
;
48 module_param(disable_ir
, int, 0444);
49 MODULE_PARM_DESC(disable_ir
, "disable infrared remote support");
51 /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
52 static unsigned long cx231xx_devused
;
55 * Reset sequences for analog/digital modes
58 static struct cx231xx_reg_seq RDE250_XCV_TUNER
[] = {
68 struct cx231xx_board cx231xx_boards
[] = {
69 [CX231XX_BOARD_UNKNOWN
] = {
70 .name
= "Unknown CX231xx video grabber",
71 .tuner_type
= TUNER_ABSENT
,
73 .type
= CX231XX_VMUX_TELEVISION
,
74 .vmux
= CX231XX_VIN_3_1
,
75 .amux
= CX231XX_AMUX_VIDEO
,
78 .type
= CX231XX_VMUX_COMPOSITE1
,
79 .vmux
= CX231XX_VIN_2_1
,
80 .amux
= CX231XX_AMUX_LINE_IN
,
83 .type
= CX231XX_VMUX_SVIDEO
,
84 .vmux
= CX231XX_VIN_1_1
|
85 (CX231XX_VIN_1_2
<< 8) |
87 .amux
= CX231XX_AMUX_LINE_IN
,
92 [CX231XX_BOARD_CNXT_CARRAERA
] = {
93 .name
= "Conexant Hybrid TV - CARRAERA",
94 .tuner_type
= TUNER_XC5000
,
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
,
110 .norm
= V4L2_STD_PAL
,
113 .type
= CX231XX_VMUX_TELEVISION
,
114 .vmux
= CX231XX_VIN_3_1
,
115 .amux
= CX231XX_AMUX_VIDEO
,
118 .type
= CX231XX_VMUX_COMPOSITE1
,
119 .vmux
= CX231XX_VIN_2_1
,
120 .amux
= CX231XX_AMUX_LINE_IN
,
123 .type
= CX231XX_VMUX_SVIDEO
,
124 .vmux
= CX231XX_VIN_1_1
|
125 (CX231XX_VIN_1_2
<< 8) |
127 .amux
= CX231XX_AMUX_LINE_IN
,
132 [CX231XX_BOARD_CNXT_SHELBY
] = {
133 .name
= "Conexant Hybrid TV - SHELBY",
134 .tuner_type
= TUNER_XC5000
,
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
,
150 .norm
= V4L2_STD_NTSC
,
153 .type
= CX231XX_VMUX_TELEVISION
,
154 .vmux
= CX231XX_VIN_3_1
,
155 .amux
= CX231XX_AMUX_VIDEO
,
158 .type
= CX231XX_VMUX_COMPOSITE1
,
159 .vmux
= CX231XX_VIN_2_1
,
160 .amux
= CX231XX_AMUX_LINE_IN
,
163 .type
= CX231XX_VMUX_SVIDEO
,
164 .vmux
= CX231XX_VIN_1_1
|
165 (CX231XX_VIN_1_2
<< 8) |
167 .amux
= CX231XX_AMUX_LINE_IN
,
172 [CX231XX_BOARD_CNXT_RDE_253S
] = {
173 .name
= "Conexant Hybrid TV - RDE253S",
174 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
190 .norm
= V4L2_STD_PAL
,
193 .type
= CX231XX_VMUX_TELEVISION
,
194 .vmux
= CX231XX_VIN_3_1
,
195 .amux
= CX231XX_AMUX_VIDEO
,
198 .type
= CX231XX_VMUX_COMPOSITE1
,
199 .vmux
= CX231XX_VIN_2_1
,
200 .amux
= CX231XX_AMUX_LINE_IN
,
203 .type
= CX231XX_VMUX_SVIDEO
,
204 .vmux
= CX231XX_VIN_1_1
|
205 (CX231XX_VIN_1_2
<< 8) |
207 .amux
= CX231XX_AMUX_LINE_IN
,
213 [CX231XX_BOARD_CNXT_RDU_253S
] = {
214 .name
= "Conexant Hybrid TV - RDU253S",
215 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
231 .norm
= V4L2_STD_PAL
,
234 .type
= CX231XX_VMUX_TELEVISION
,
235 .vmux
= CX231XX_VIN_3_1
,
236 .amux
= CX231XX_AMUX_VIDEO
,
239 .type
= CX231XX_VMUX_COMPOSITE1
,
240 .vmux
= CX231XX_VIN_2_1
,
241 .amux
= CX231XX_AMUX_LINE_IN
,
244 .type
= CX231XX_VMUX_SVIDEO
,
245 .vmux
= CX231XX_VIN_1_1
|
246 (CX231XX_VIN_1_2
<< 8) |
248 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
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. */
270 .type
= CX231XX_VMUX_COMPOSITE1
,
271 .vmux
= CX231XX_VIN_2_1
,
272 .amux
= CX231XX_AMUX_LINE_IN
,
275 .type
= CX231XX_VMUX_SVIDEO
,
276 .vmux
= CX231XX_VIN_1_1
|
277 (CX231XX_VIN_1_2
<< 8) |
279 .amux
= CX231XX_AMUX_LINE_IN
,
284 [CX231XX_BOARD_CNXT_RDE_250
] = {
285 .name
= "Conexant Hybrid TV - rde 250",
286 .tuner_type
= TUNER_XC5000
,
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
,
302 .norm
= V4L2_STD_PAL
,
305 .type
= CX231XX_VMUX_TELEVISION
,
306 .vmux
= CX231XX_VIN_2_1
,
307 .amux
= CX231XX_AMUX_VIDEO
,
312 [CX231XX_BOARD_CNXT_RDU_250
] = {
313 .name
= "Conexant Hybrid TV - RDU 250",
314 .tuner_type
= TUNER_XC5000
,
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
,
330 .norm
= V4L2_STD_NTSC
,
333 .type
= CX231XX_VMUX_TELEVISION
,
334 .vmux
= CX231XX_VIN_2_1
,
335 .amux
= CX231XX_AMUX_VIDEO
,
340 [CX231XX_BOARD_HAUPPAUGE_EXETER
] = {
341 .name
= "Hauppauge EXETER",
342 .tuner_type
= TUNER_NXP_TDA18271
,
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_2
,
358 .norm
= V4L2_STD_NTSC
,
361 .type
= CX231XX_VMUX_TELEVISION
,
362 .vmux
= CX231XX_VIN_3_1
,
363 .amux
= CX231XX_AMUX_VIDEO
,
366 .type
= CX231XX_VMUX_COMPOSITE1
,
367 .vmux
= CX231XX_VIN_2_1
,
368 .amux
= CX231XX_AMUX_LINE_IN
,
371 .type
= CX231XX_VMUX_SVIDEO
,
372 .vmux
= CX231XX_VIN_1_1
|
373 (CX231XX_VIN_1_2
<< 8) |
375 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
392 .type
= CX231XX_VMUX_COMPOSITE1
,
393 .vmux
= CX231XX_VIN_2_1
,
394 .amux
= CX231XX_AMUX_LINE_IN
,
397 .type
= CX231XX_VMUX_SVIDEO
,
398 .vmux
= CX231XX_VIN_1_1
|
399 (CX231XX_VIN_1_2
<< 8) |
401 .amux
= CX231XX_AMUX_LINE_IN
,
405 [CX231XX_BOARD_KWORLD_UB430_USB_HYBRID
] = {
406 .name
= "Kworld UB430 USB Hybrid",
407 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
423 .norm
= V4L2_STD_PAL_M
,
425 .type
= CX231XX_VMUX_TELEVISION
,
426 .vmux
= CX231XX_VIN_3_1
,
427 .amux
= CX231XX_AMUX_VIDEO
,
430 .type
= CX231XX_VMUX_COMPOSITE1
,
431 .vmux
= CX231XX_VIN_2_1
,
432 .amux
= CX231XX_AMUX_LINE_IN
,
435 .type
= CX231XX_VMUX_SVIDEO
,
436 .vmux
= CX231XX_VIN_1_1
|
437 (CX231XX_VIN_1_2
<< 8) |
439 .amux
= CX231XX_AMUX_LINE_IN
,
443 [CX231XX_BOARD_KWORLD_UB445_USB_HYBRID
] = {
444 .name
= "Kworld UB445 USB Hybrid",
445 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
461 .norm
= V4L2_STD_NTSC_M
,
463 .type
= CX231XX_VMUX_TELEVISION
,
464 .vmux
= CX231XX_VIN_3_1
,
465 .amux
= CX231XX_AMUX_VIDEO
,
468 .type
= CX231XX_VMUX_COMPOSITE1
,
469 .vmux
= CX231XX_VIN_2_1
,
470 .amux
= CX231XX_AMUX_LINE_IN
,
473 .type
= CX231XX_VMUX_SVIDEO
,
474 .vmux
= CX231XX_VIN_1_1
|
475 (CX231XX_VIN_1_2
<< 8) |
477 .amux
= CX231XX_AMUX_LINE_IN
,
481 [CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
] = {
482 .name
= "Pixelview PlayTV USB Hybrid",
483 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
500 .norm
= V4L2_STD_PAL_M
,
502 .type
= CX231XX_VMUX_TELEVISION
,
503 .vmux
= CX231XX_VIN_3_1
,
504 .amux
= CX231XX_AMUX_VIDEO
,
507 .type
= CX231XX_VMUX_COMPOSITE1
,
508 .vmux
= CX231XX_VIN_2_1
,
509 .amux
= CX231XX_AMUX_LINE_IN
,
512 .type
= CX231XX_VMUX_SVIDEO
,
513 .vmux
= CX231XX_VIN_1_1
|
514 (CX231XX_VIN_1_2
<< 8) |
516 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
534 .type
= CX231XX_VMUX_COMPOSITE1
,
535 .vmux
= CX231XX_VIN_2_1
,
536 .amux
= CX231XX_AMUX_LINE_IN
,
539 .type
= CX231XX_VMUX_SVIDEO
,
540 .vmux
= CX231XX_VIN_1_1
|
541 (CX231XX_VIN_1_2
<< 8) |
543 .amux
= CX231XX_AMUX_LINE_IN
,
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,
560 .type
= CX231XX_VMUX_COMPOSITE1
,
561 .vmux
= CX231XX_VIN_2_1
,
562 .amux
= CX231XX_AMUX_LINE_IN
,
565 .type
= CX231XX_VMUX_SVIDEO
,
566 .vmux
= CX231XX_VIN_1_1
|
567 (CX231XX_VIN_1_2
<< 8) |
569 .amux
= CX231XX_AMUX_LINE_IN
,
573 [CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL
] = {
574 .name
= "Hauppauge WinTV USB2 FM (PAL)",
575 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
590 .type
= CX231XX_VMUX_TELEVISION
,
591 .vmux
= CX231XX_VIN_3_1
,
592 .amux
= CX231XX_AMUX_VIDEO
,
595 .type
= CX231XX_VMUX_COMPOSITE1
,
596 .vmux
= CX231XX_VIN_2_1
,
597 .amux
= CX231XX_AMUX_LINE_IN
,
600 .type
= CX231XX_VMUX_SVIDEO
,
601 .vmux
= CX231XX_VIN_1_1
|
602 (CX231XX_VIN_1_2
<< 8) |
604 .amux
= CX231XX_AMUX_LINE_IN
,
608 [CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC
] = {
609 .name
= "Hauppauge WinTV USB2 FM (NTSC)",
610 .tuner_type
= TUNER_NXP_TDA18271
,
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
,
625 .type
= CX231XX_VMUX_TELEVISION
,
626 .vmux
= CX231XX_VIN_3_1
,
627 .amux
= CX231XX_AMUX_VIDEO
,
630 .type
= CX231XX_VMUX_COMPOSITE1
,
631 .vmux
= CX231XX_VIN_2_1
,
632 .amux
= CX231XX_AMUX_LINE_IN
,
635 .type
= CX231XX_VMUX_SVIDEO
,
636 .vmux
= CX231XX_VIN_1_1
|
637 (CX231XX_VIN_1_2
<< 8) |
639 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
656 .type
= CX231XX_VMUX_COMPOSITE1
,
657 .vmux
= CX231XX_VIN_2_1
,
658 .amux
= CX231XX_AMUX_LINE_IN
,
661 .type
= CX231XX_VMUX_SVIDEO
,
662 .vmux
= CX231XX_VIN_1_1
|
663 (CX231XX_VIN_1_2
<< 8) |
665 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
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. */
687 .type
= CX231XX_VMUX_COMPOSITE1
,
688 .vmux
= CX231XX_VIN_2_1
,
689 .amux
= CX231XX_AMUX_LINE_IN
,
692 .type
= CX231XX_VMUX_SVIDEO
,
693 .vmux
= CX231XX_VIN_1_1
|
694 (CX231XX_VIN_1_2
<< 8) |
696 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
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_2
,
719 .norm
= V4L2_STD_PAL
,
722 .type
= CX231XX_VMUX_TELEVISION
,
723 .vmux
= CX231XX_VIN_3_1
,
724 .amux
= CX231XX_AMUX_VIDEO
,
727 .type
= CX231XX_VMUX_COMPOSITE1
,
728 .vmux
= CX231XX_VIN_2_1
,
729 .amux
= CX231XX_AMUX_LINE_IN
,
732 .type
= CX231XX_VMUX_SVIDEO
,
733 .vmux
= CX231XX_VIN_1_1
|
734 (CX231XX_VIN_1_2
<< 8) |
736 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
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_2
,
758 .norm
= V4L2_STD_PAL
,
761 .type
= CX231XX_VMUX_TELEVISION
,
762 .vmux
= CX231XX_VIN_3_1
,
763 .amux
= CX231XX_AMUX_VIDEO
,
766 .type
= CX231XX_VMUX_COMPOSITE1
,
767 .vmux
= CX231XX_VIN_2_1
,
768 .amux
= CX231XX_AMUX_LINE_IN
,
771 .type
= CX231XX_VMUX_SVIDEO
,
772 .vmux
= CX231XX_VIN_1_1
|
773 (CX231XX_VIN_1_2
<< 8) |
775 .amux
= CX231XX_AMUX_LINE_IN
,
780 const unsigned int cx231xx_bcount
= ARRAY_SIZE(cx231xx_boards
);
782 /* table of devices that work with this driver */
783 struct usb_device_id cx231xx_id_table
[] = {
784 {USB_DEVICE(0x1D19, 0x6109),
785 .driver_info
= CX231XX_BOARD_PV_XCAPTURE_USB
},
786 {USB_DEVICE(0x0572, 0x5A3C),
787 .driver_info
= CX231XX_BOARD_UNKNOWN
},
788 {USB_DEVICE(0x0572, 0x58A2),
789 .driver_info
= CX231XX_BOARD_CNXT_CARRAERA
},
790 {USB_DEVICE(0x0572, 0x58A1),
791 .driver_info
= CX231XX_BOARD_CNXT_SHELBY
},
792 {USB_DEVICE(0x0572, 0x58A4),
793 .driver_info
= CX231XX_BOARD_CNXT_RDE_253S
},
794 {USB_DEVICE(0x0572, 0x58A5),
795 .driver_info
= CX231XX_BOARD_CNXT_RDU_253S
},
796 {USB_DEVICE(0x0572, 0x58A6),
797 .driver_info
= CX231XX_BOARD_CNXT_VIDEO_GRABBER
},
798 {USB_DEVICE(0x0572, 0x589E),
799 .driver_info
= CX231XX_BOARD_CNXT_RDE_250
},
800 {USB_DEVICE(0x0572, 0x58A0),
801 .driver_info
= CX231XX_BOARD_CNXT_RDU_250
},
802 {USB_DEVICE(0x2040, 0xb110),
803 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL
},
804 {USB_DEVICE(0x2040, 0xb111),
805 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC
},
806 {USB_DEVICE(0x2040, 0xb120),
807 .driver_info
= CX231XX_BOARD_HAUPPAUGE_EXETER
},
808 {USB_DEVICE(0x2040, 0xb130),
809 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
},
810 {USB_DEVICE(0x2040, 0xb131),
811 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
},
812 /* Hauppauge WinTV-HVR-900-H */
813 {USB_DEVICE(0x2040, 0xb138),
814 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
},
815 /* Hauppauge WinTV-HVR-901-H */
816 {USB_DEVICE(0x2040, 0xb139),
817 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
},
818 {USB_DEVICE(0x2040, 0xb140),
819 .driver_info
= CX231XX_BOARD_HAUPPAUGE_EXETER
},
820 {USB_DEVICE(0x2040, 0xc200),
821 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USBLIVE2
},
822 /* PCTV QuatroStick 521e */
823 {USB_DEVICE(0x2013, 0x0259),
824 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
},
825 /* PCTV QuatroStick 522e */
826 {USB_DEVICE(0x2013, 0x025e),
827 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
},
828 {USB_DEVICE_VER(USB_VID_PIXELVIEW
, USB_PID_PIXELVIEW_SBTVD
, 0x4000, 0x4001),
829 .driver_info
= CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
},
830 {USB_DEVICE(USB_VID_PIXELVIEW
, 0x5014),
831 .driver_info
= CX231XX_BOARD_PV_XCAPTURE_USB
},
832 {USB_DEVICE(0x1b80, 0xe424),
833 .driver_info
= CX231XX_BOARD_KWORLD_UB430_USB_HYBRID
},
834 {USB_DEVICE(0x1b80, 0xe421),
835 .driver_info
= CX231XX_BOARD_KWORLD_UB445_USB_HYBRID
},
836 {USB_DEVICE(0x1f4d, 0x0237),
837 .driver_info
= CX231XX_BOARD_ICONBIT_U100
},
838 {USB_DEVICE(0x0fd9, 0x0037),
839 .driver_info
= CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2
},
840 {USB_DEVICE(0x1f4d, 0x0102),
841 .driver_info
= CX231XX_BOARD_OTG102
},
845 MODULE_DEVICE_TABLE(usb
, cx231xx_id_table
);
847 /* cx231xx_tuner_callback
848 * will be used to reset XC5000 tuner using GPIO pin
851 int cx231xx_tuner_callback(void *ptr
, int component
, int command
, int arg
)
854 struct cx231xx
*dev
= ptr
;
856 if (dev
->tuner_type
== TUNER_XC5000
) {
857 if (command
== XC5000_TUNER_RESET
) {
859 "Tuner CB: RESET: cmd %d : tuner type %d\n",
860 command
, dev
->tuner_type
);
861 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
864 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
867 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
871 } else if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
873 case TDA18271_CALLBACK_CMD_AGC_ENABLE
:
874 if (dev
->model
== CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
)
875 rc
= cx231xx_set_agc_analog_digital_mux_select(dev
, arg
);
884 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback
);
886 static void cx231xx_reset_out(struct cx231xx
*dev
)
888 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
890 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 0);
892 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
895 static void cx231xx_enable_OSC(struct cx231xx
*dev
)
897 cx231xx_set_gpio_value(dev
, CX23417_OSC_EN
, 1);
900 static void cx231xx_sleep_s5h1432(struct cx231xx
*dev
)
902 cx231xx_set_gpio_value(dev
, SLEEP_S5H1432
, 0);
905 static inline void cx231xx_set_model(struct cx231xx
*dev
)
907 dev
->board
= cx231xx_boards
[dev
->model
];
910 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
911 * this won't work for boards with generic PCI IDs
913 void cx231xx_pre_card_setup(struct cx231xx
*dev
)
916 cx231xx_set_model(dev
);
918 dev_info(dev
->dev
, "Identified as %s (card=%d)\n",
919 dev
->board
.name
, dev
->model
);
921 /* set the direction for GPIO pins */
922 if (dev
->board
.tuner_gpio
) {
923 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_gpio
->bit
, 1);
924 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
, 1);
926 if (dev
->board
.tuner_sif_gpio
>= 0)
927 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_sif_gpio
, 1);
929 /* request some modules if any required */
931 /* set the mode to Analog mode initially */
932 cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
935 /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
939 static void cx231xx_config_tuner(struct cx231xx
*dev
)
941 struct tuner_setup tun_setup
;
942 struct v4l2_frequency f
;
944 if (dev
->tuner_type
== TUNER_ABSENT
)
947 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
948 tun_setup
.type
= dev
->tuner_type
;
949 tun_setup
.addr
= dev
->tuner_addr
;
950 tun_setup
.tuner_callback
= cx231xx_tuner_callback
;
952 tuner_call(dev
, tuner
, s_type_addr
, &tun_setup
);
955 if (tun_setup
.type
== TUNER_XC5000
) {
956 static struct xc2028_ctrl ctrl
= {
957 .fname
= XC5000_DEFAULT_FIRMWARE
,
961 struct v4l2_priv_tun_config cfg
= {
962 .tuner
= dev
->tuner_type
,
965 tuner_call(dev
, tuner
, s_config
, &cfg
);
968 /* configure tuner */
970 f
.type
= V4L2_TUNER_ANALOG_TV
;
971 f
.frequency
= 9076; /* just a magic number */
972 dev
->ctl_freq
= f
.frequency
;
973 call_all(dev
, tuner
, s_frequency
, &f
);
977 static int read_eeprom(struct cx231xx
*dev
, struct i2c_client
*client
,
983 u8
*eedata_cur
= eedata
;
985 struct i2c_msg msg_write
= { .addr
= client
->addr
, .flags
= 0,
986 .buf
= &start_offset
, .len
= 1 };
987 struct i2c_msg msg_read
= { .addr
= client
->addr
, .flags
= I2C_M_RD
};
989 /* start reading at offset 0 */
990 ret
= i2c_transfer(client
->adapter
, &msg_write
, 1);
992 dev_err(dev
->dev
, "Can't read eeprom\n");
996 while (len_todo
> 0) {
997 msg_read
.len
= (len_todo
> 64) ? 64 : len_todo
;
998 msg_read
.buf
= eedata_cur
;
1000 ret
= i2c_transfer(client
->adapter
, &msg_read
, 1);
1002 dev_err(dev
->dev
, "Can't read eeprom\n");
1005 eedata_cur
+= msg_read
.len
;
1006 len_todo
-= msg_read
.len
;
1009 for (i
= 0; i
+ 15 < len
; i
+= 16)
1010 dev_dbg(dev
->dev
, "i2c eeprom %02x: %*ph\n",
1016 void cx231xx_card_setup(struct cx231xx
*dev
)
1019 cx231xx_set_model(dev
);
1021 dev
->tuner_type
= cx231xx_boards
[dev
->model
].tuner_type
;
1022 if (cx231xx_boards
[dev
->model
].tuner_addr
)
1023 dev
->tuner_addr
= cx231xx_boards
[dev
->model
].tuner_addr
;
1025 /* request some modules */
1026 if (dev
->board
.decoder
== CX231XX_AVDECODER
) {
1027 dev
->sd_cx25840
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
1028 cx231xx_get_i2c_adap(dev
, I2C_0
),
1029 "cx25840", 0x88 >> 1, NULL
);
1030 if (dev
->sd_cx25840
== NULL
)
1032 "cx25840 subdev registration failure\n");
1033 cx25840_call(dev
, core
, load_fw
);
1037 /* Initialize the tuner */
1038 if (dev
->board
.tuner_type
!= TUNER_ABSENT
) {
1039 struct i2c_adapter
*tuner_i2c
= cx231xx_get_i2c_adap(dev
,
1040 dev
->board
.tuner_i2c_master
);
1041 dev
->sd_tuner
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
1044 dev
->tuner_addr
, NULL
);
1045 if (dev
->sd_tuner
== NULL
)
1047 "tuner subdev registration failure\n");
1049 cx231xx_config_tuner(dev
);
1052 switch (dev
->model
) {
1053 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
:
1054 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
:
1056 struct tveeprom tvee
;
1057 static u8 eeprom
[256];
1058 struct i2c_client client
;
1060 memset(&client
, 0, sizeof(client
));
1061 client
.adapter
= cx231xx_get_i2c_adap(dev
, I2C_1_MUX_1
);
1062 client
.addr
= 0xa0 >> 1;
1064 read_eeprom(dev
, &client
, eeprom
, sizeof(eeprom
));
1065 tveeprom_hauppauge_analog(&client
,
1066 &tvee
, eeprom
+ 0xc0);
1075 * inits registers with sane defaults
1077 int cx231xx_config(struct cx231xx
*dev
)
1079 /* TBD need to add cx231xx specific code */
1085 * cx231xx_config_i2c()
1086 * configure i2c attached devices
1088 void cx231xx_config_i2c(struct cx231xx
*dev
)
1090 /* u32 input = INPUT(dev->video_input)->vmux; */
1092 call_all(dev
, video
, s_stream
, 1);
1096 * cx231xx_realease_resources()
1097 * unregisters the v4l2,i2c and usb devices
1098 * called when the device gets disconected or at module unload
1100 void cx231xx_release_resources(struct cx231xx
*dev
)
1102 cx231xx_release_analog_resources(dev
);
1104 cx231xx_remove_from_devlist(dev
);
1106 cx231xx_ir_exit(dev
);
1108 /* Release I2C buses */
1109 cx231xx_dev_uninit(dev
);
1111 /* delete v4l2 device */
1112 v4l2_device_unregister(&dev
->v4l2_dev
);
1114 usb_put_dev(dev
->udev
);
1116 /* Mark device as unused */
1117 clear_bit(dev
->devno
, &cx231xx_devused
);
1121 * cx231xx_init_dev()
1122 * allocates and inits the device structs, registers i2c bus and v4l device
1124 static int cx231xx_init_dev(struct cx231xx
*dev
, struct usb_device
*udev
,
1127 int retval
= -ENOMEM
;
1128 unsigned int maxh
, maxw
;
1131 mutex_init(&dev
->lock
);
1132 mutex_init(&dev
->ctrl_urb_lock
);
1133 mutex_init(&dev
->gpio_i2c_lock
);
1134 mutex_init(&dev
->i2c_lock
);
1136 spin_lock_init(&dev
->video_mode
.slock
);
1137 spin_lock_init(&dev
->vbi_mode
.slock
);
1138 spin_lock_init(&dev
->sliced_cc_mode
.slock
);
1140 init_waitqueue_head(&dev
->open
);
1141 init_waitqueue_head(&dev
->wait_frame
);
1142 init_waitqueue_head(&dev
->wait_stream
);
1144 dev
->cx231xx_read_ctrl_reg
= cx231xx_read_ctrl_reg
;
1145 dev
->cx231xx_write_ctrl_reg
= cx231xx_write_ctrl_reg
;
1146 dev
->cx231xx_send_usb_command
= cx231xx_send_usb_command
;
1147 dev
->cx231xx_gpio_i2c_read
= cx231xx_gpio_i2c_read
;
1148 dev
->cx231xx_gpio_i2c_write
= cx231xx_gpio_i2c_write
;
1150 /* Query cx231xx to find what pcb config it is related to */
1151 retval
= initialize_cx231xx(dev
);
1153 dev_err(dev
->dev
, "Failed to read PCB config\n");
1157 /*To workaround error number=-71 on EP0 for VideoGrabber,
1158 need set alt here.*/
1159 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
||
1160 dev
->model
== CX231XX_BOARD_HAUPPAUGE_USBLIVE2
) {
1161 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
1162 cx231xx_set_alt_setting(dev
, INDEX_VANC
, 1);
1164 /* Cx231xx pre card setup */
1165 cx231xx_pre_card_setup(dev
);
1167 retval
= cx231xx_config(dev
);
1169 dev_err(dev
->dev
, "error configuring device\n");
1173 /* set default norm */
1174 dev
->norm
= dev
->board
.norm
;
1176 /* register i2c bus */
1177 retval
= cx231xx_dev_init(dev
);
1180 "%s: cx231xx_i2c_register - errCode [%d]!\n",
1185 /* Do board specific init */
1186 cx231xx_card_setup(dev
);
1188 /* configure the device */
1189 cx231xx_config_i2c(dev
);
1191 maxw
= norm_maxw(dev
);
1192 maxh
= norm_maxh(dev
);
1194 /* set default image size */
1197 dev
->interlaced
= 0;
1198 dev
->video_input
= 0;
1200 retval
= cx231xx_config(dev
);
1202 dev_err(dev
->dev
, "%s: cx231xx_config - errCode [%d]!\n",
1207 /* init video dma queues */
1208 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.active
);
1209 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.queued
);
1211 /* init vbi dma queues */
1212 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.active
);
1213 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.queued
);
1215 /* Reset other chips required if they are tied up with GPIO pins */
1216 cx231xx_add_into_devlist(dev
);
1218 if (dev
->board
.has_417
) {
1219 dev_info(dev
->dev
, "attach 417 %d\n", dev
->model
);
1220 if (cx231xx_417_register(dev
) < 0) {
1222 "%s() Failed to register 417 on VID_B\n",
1227 retval
= cx231xx_register_analog_devices(dev
);
1229 cx231xx_release_analog_resources(dev
);
1233 cx231xx_ir_init(dev
);
1235 cx231xx_init_extension(dev
);
1239 cx231xx_remove_from_devlist(dev
);
1241 cx231xx_dev_uninit(dev
);
1245 #if defined(CONFIG_MODULES) && defined(MODULE)
1246 static void request_module_async(struct work_struct
*work
)
1248 struct cx231xx
*dev
= container_of(work
,
1249 struct cx231xx
, request_module_wk
);
1251 if (dev
->has_alsa_audio
)
1252 request_module("cx231xx-alsa");
1254 if (dev
->board
.has_dvb
)
1255 request_module("cx231xx-dvb");
1259 static void request_modules(struct cx231xx
*dev
)
1261 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
1262 schedule_work(&dev
->request_module_wk
);
1265 static void flush_request_modules(struct cx231xx
*dev
)
1267 flush_work(&dev
->request_module_wk
);
1270 #define request_modules(dev)
1271 #define flush_request_modules(dev)
1272 #endif /* CONFIG_MODULES */
1274 static int cx231xx_init_v4l2(struct cx231xx
*dev
,
1275 struct usb_device
*udev
,
1276 struct usb_interface
*interface
,
1279 struct usb_interface
*uif
;
1284 /* compute alternate max packet sizes for video */
1285 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.video_index
+ 1;
1286 if (idx
>= dev
->max_iad_interface_count
) {
1288 "Video PCB interface #%d doesn't exist\n", idx
);
1292 uif
= udev
->actconfig
->interface
[idx
];
1294 dev
->video_mode
.end_point_addr
= uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.bEndpointAddress
;
1295 dev
->video_mode
.num_alt
= uif
->num_altsetting
;
1298 "video EndPoint Addr 0x%x, Alternate settings: %i\n",
1299 dev
->video_mode
.end_point_addr
,
1300 dev
->video_mode
.num_alt
);
1302 dev
->video_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->video_mode
.num_alt
, GFP_KERNEL
);
1303 if (dev
->video_mode
.alt_max_pkt_size
== NULL
)
1306 for (i
= 0; i
< dev
->video_mode
.num_alt
; i
++) {
1307 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].desc
.wMaxPacketSize
);
1308 dev
->video_mode
.alt_max_pkt_size
[i
] = (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1310 "Alternate setting %i, max size= %i\n", i
,
1311 dev
->video_mode
.alt_max_pkt_size
[i
]);
1316 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.vanc_index
+ 1;
1317 if (idx
>= dev
->max_iad_interface_count
) {
1319 "VBI PCB interface #%d doesn't exist\n", idx
);
1322 uif
= udev
->actconfig
->interface
[idx
];
1324 dev
->vbi_mode
.end_point_addr
=
1325 uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1328 dev
->vbi_mode
.num_alt
= uif
->num_altsetting
;
1330 "VBI EndPoint Addr 0x%x, Alternate settings: %i\n",
1331 dev
->vbi_mode
.end_point_addr
,
1332 dev
->vbi_mode
.num_alt
);
1334 /* compute alternate max packet sizes for vbi */
1335 dev
->vbi_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->vbi_mode
.num_alt
, GFP_KERNEL
);
1336 if (dev
->vbi_mode
.alt_max_pkt_size
== NULL
)
1339 for (i
= 0; i
< dev
->vbi_mode
.num_alt
; i
++) {
1341 le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1342 desc
.wMaxPacketSize
);
1343 dev
->vbi_mode
.alt_max_pkt_size
[i
] =
1344 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1346 "Alternate setting %i, max size= %i\n", i
,
1347 dev
->vbi_mode
.alt_max_pkt_size
[i
]);
1350 /* Sliced CC VBI init */
1352 /* compute alternate max packet sizes for sliced CC */
1353 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.hanc_index
+ 1;
1354 if (idx
>= dev
->max_iad_interface_count
) {
1356 "Sliced CC PCB interface #%d doesn't exist\n", idx
);
1359 uif
= udev
->actconfig
->interface
[idx
];
1361 dev
->sliced_cc_mode
.end_point_addr
=
1362 uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1365 dev
->sliced_cc_mode
.num_alt
= uif
->num_altsetting
;
1367 "sliced CC EndPoint Addr 0x%x, Alternate settings: %i\n",
1368 dev
->sliced_cc_mode
.end_point_addr
,
1369 dev
->sliced_cc_mode
.num_alt
);
1370 dev
->sliced_cc_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->sliced_cc_mode
.num_alt
, GFP_KERNEL
);
1371 if (dev
->sliced_cc_mode
.alt_max_pkt_size
== NULL
)
1374 for (i
= 0; i
< dev
->sliced_cc_mode
.num_alt
; i
++) {
1375 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1376 desc
.wMaxPacketSize
);
1377 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
] =
1378 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1380 "Alternate setting %i, max size= %i\n", i
,
1381 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
]);
1388 * cx231xx_usb_probe()
1389 * checks for supported devices
1391 static int cx231xx_usb_probe(struct usb_interface
*interface
,
1392 const struct usb_device_id
*id
)
1394 struct usb_device
*udev
;
1395 struct device
*d
= &interface
->dev
;
1396 struct usb_interface
*uif
;
1397 struct cx231xx
*dev
= NULL
;
1398 int retval
= -ENODEV
;
1400 int i
, isoc_pipe
= 0;
1403 struct usb_interface_assoc_descriptor
*assoc_desc
;
1405 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
1406 udev
= usb_get_dev(interface_to_usbdev(interface
));
1409 * Interface number 0 - IR interface (handled by mceusb driver)
1410 * Interface number 1 - AV interface (handled by this driver)
1415 /* Check to see next free device and mark as used */
1417 nr
= find_first_zero_bit(&cx231xx_devused
, CX231XX_MAXBOARDS
);
1418 if (nr
>= CX231XX_MAXBOARDS
) {
1419 /* No free device slots */
1421 "Supports only %i devices.\n",
1425 } while (test_and_set_bit(nr
, &cx231xx_devused
));
1427 /* allocate memory for our device state and initialize it */
1428 dev
= devm_kzalloc(&udev
->dev
, sizeof(*dev
), GFP_KERNEL
);
1430 clear_bit(nr
, &cx231xx_devused
);
1434 snprintf(dev
->name
, 29, "cx231xx #%d", nr
);
1436 dev
->model
= id
->driver_info
;
1437 dev
->video_mode
.alt
= -1;
1440 dev
->interface_count
++;
1441 /* reset gpio dir and value */
1444 dev
->xc_fw_load_done
= 0;
1445 dev
->has_alsa_audio
= 1;
1446 dev
->power_mode
= -1;
1447 atomic_set(&dev
->devlist_count
, 0);
1449 /* 0 - vbi ; 1 -sliced cc mode */
1450 dev
->vbi_or_sliced_cc_mode
= 0;
1452 /* get maximum no.of IAD interfaces */
1453 dev
->max_iad_interface_count
= udev
->config
->desc
.bNumInterfaces
;
1455 /* init CIR module TBD */
1457 /*mode_tv: digital=1 or analog=0*/
1460 dev
->USE_ISO
= transfer_mode
;
1462 switch (udev
->speed
) {
1466 case USB_SPEED_UNKNOWN
:
1467 case USB_SPEED_FULL
:
1470 case USB_SPEED_HIGH
:
1478 "New device %s %s @ %s Mbps (%04x:%04x) with %d interfaces\n",
1479 udev
->manufacturer
? udev
->manufacturer
: "",
1480 udev
->product
? udev
->product
: "",
1482 le16_to_cpu(udev
->descriptor
.idVendor
),
1483 le16_to_cpu(udev
->descriptor
.idProduct
),
1484 dev
->max_iad_interface_count
);
1486 /* increment interface count */
1487 dev
->interface_count
++;
1489 /* get device number */
1492 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
1493 if (assoc_desc
->bFirstInterface
!= ifnum
) {
1494 dev_err(d
, "Not found matching IAD interface\n");
1499 dev_dbg(d
, "registering interface %d\n", ifnum
);
1501 /* save our data pointer in this interface device */
1502 usb_set_intfdata(interface
, dev
);
1504 /* Create v4l2 device */
1505 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
1507 dev_err(d
, "v4l2_device_register failed\n");
1511 /* allocate device struct */
1512 retval
= cx231xx_init_dev(dev
, udev
, nr
);
1516 retval
= cx231xx_init_v4l2(dev
, udev
, interface
, isoc_pipe
);
1520 if (dev
->current_pcb_config
.ts1_source
!= 0xff) {
1521 /* compute alternate max packet sizes for TS1 */
1522 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.ts1_index
+ 1;
1523 if (idx
>= dev
->max_iad_interface_count
) {
1524 dev_err(d
, "TS1 PCB interface #%d doesn't exist\n",
1529 uif
= udev
->actconfig
->interface
[idx
];
1531 dev
->ts1_mode
.end_point_addr
=
1532 uif
->altsetting
[0].endpoint
[isoc_pipe
].
1533 desc
.bEndpointAddress
;
1535 dev
->ts1_mode
.num_alt
= uif
->num_altsetting
;
1537 "TS EndPoint Addr 0x%x, Alternate settings: %i\n",
1538 dev
->ts1_mode
.end_point_addr
,
1539 dev
->ts1_mode
.num_alt
);
1541 dev
->ts1_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->ts1_mode
.num_alt
, GFP_KERNEL
);
1542 if (dev
->ts1_mode
.alt_max_pkt_size
== NULL
) {
1547 for (i
= 0; i
< dev
->ts1_mode
.num_alt
; i
++) {
1548 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].
1549 endpoint
[isoc_pipe
].desc
.
1551 dev
->ts1_mode
.alt_max_pkt_size
[i
] =
1552 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1553 dev_dbg(d
, "Alternate setting %i, max size= %i\n",
1554 i
, dev
->ts1_mode
.alt_max_pkt_size
[i
]);
1558 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
1559 cx231xx_enable_OSC(dev
);
1560 cx231xx_reset_out(dev
);
1561 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
1564 if (dev
->model
== CX231XX_BOARD_CNXT_RDE_253S
)
1565 cx231xx_sleep_s5h1432(dev
);
1567 /* load other modules required */
1568 request_modules(dev
);
1572 /* cx231xx_uninit_dev: */
1573 cx231xx_close_extension(dev
);
1574 cx231xx_ir_exit(dev
);
1575 cx231xx_release_analog_resources(dev
);
1576 cx231xx_417_unregister(dev
);
1577 cx231xx_remove_from_devlist(dev
);
1578 cx231xx_dev_uninit(dev
);
1580 v4l2_device_unregister(&dev
->v4l2_dev
);
1582 usb_set_intfdata(interface
, NULL
);
1585 clear_bit(dev
->devno
, &cx231xx_devused
);
1590 * cx231xx_usb_disconnect()
1591 * called when the device gets diconencted
1592 * video device will be unregistered on v4l2_close in case it is still open
1594 static void cx231xx_usb_disconnect(struct usb_interface
*interface
)
1596 struct cx231xx
*dev
;
1598 dev
= usb_get_intfdata(interface
);
1599 usb_set_intfdata(interface
, NULL
);
1607 dev
->state
|= DEV_DISCONNECTED
;
1609 flush_request_modules(dev
);
1611 /* wait until all current v4l2 io is finished then deallocate
1613 mutex_lock(&dev
->lock
);
1615 wake_up_interruptible_all(&dev
->open
);
1619 "device %s is open! Deregistration and memory deallocation are deferred on close.\n",
1620 video_device_node_name(dev
->vdev
));
1622 /* Even having users, it is safe to remove the RC i2c driver */
1623 cx231xx_ir_exit(dev
);
1626 cx231xx_uninit_isoc(dev
);
1628 cx231xx_uninit_bulk(dev
);
1629 wake_up_interruptible(&dev
->wait_frame
);
1630 wake_up_interruptible(&dev
->wait_stream
);
1634 cx231xx_close_extension(dev
);
1636 mutex_unlock(&dev
->lock
);
1639 cx231xx_release_resources(dev
);
1642 static struct usb_driver cx231xx_usb_driver
= {
1644 .probe
= cx231xx_usb_probe
,
1645 .disconnect
= cx231xx_usb_disconnect
,
1646 .id_table
= cx231xx_id_table
,
1649 module_usb_driver(cx231xx_usb_driver
);