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/drv-intf/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_1_MUX_1
,
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
= 0x1c,
490 .tuner_sif_gpio
= -1,
491 .tuner_scl_gpio
= -1,
492 .tuner_sda_gpio
= -1,
493 .gpio_pin_status_mask
= 0x4001000,
494 .tuner_i2c_master
= I2C_2
,
495 .demod_i2c_master
= I2C_1_MUX_3
,
496 .ir_i2c_master
= I2C_2
,
497 .rc_map_name
= RC_MAP_PIXELVIEW_002T
,
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_1_MUX_3
,
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_1_MUX_3
,
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
,
779 [CX231XX_BOARD_HAUPPAUGE_955Q
] = {
780 .name
= "Hauppauge WinTV-HVR-955Q (111401)",
781 .tuner_type
= TUNER_ABSENT
,
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
,
797 .norm
= V4L2_STD_NTSC
,
800 .type
= CX231XX_VMUX_TELEVISION
,
801 .vmux
= CX231XX_VIN_3_1
,
802 .amux
= CX231XX_AMUX_VIDEO
,
805 .type
= CX231XX_VMUX_COMPOSITE1
,
806 .vmux
= CX231XX_VIN_2_1
,
807 .amux
= CX231XX_AMUX_LINE_IN
,
810 .type
= CX231XX_VMUX_SVIDEO
,
811 .vmux
= CX231XX_VIN_1_1
|
812 (CX231XX_VIN_1_2
<< 8) |
814 .amux
= CX231XX_AMUX_LINE_IN
,
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
,
831 .type
= CX231XX_VMUX_COMPOSITE1
,
832 .vmux
= CX231XX_VIN_2_1
,
833 .amux
= CX231XX_AMUX_LINE_IN
,
836 .type
= CX231XX_VMUX_SVIDEO
,
837 .vmux
= CX231XX_VIN_1_1
|
838 (CX231XX_VIN_1_2
<< 8) |
840 .amux
= CX231XX_AMUX_LINE_IN
,
844 [CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD
] = {
845 .name
= "Evromedia USB Full Hybrid Full HD",
846 .tuner_type
= TUNER_ABSENT
,
847 .demod_addr
= 0x64, /* 0xc8 >> 1 */
848 .demod_i2c_master
= I2C_1_MUX_3
,
850 .ir_i2c_master
= I2C_0
,
851 .norm
= V4L2_STD_PAL
,
852 .output_mode
= OUT_MODE_VIP11
,
853 .tuner_addr
= 0x60, /* 0xc0 >> 1 */
854 .tuner_i2c_master
= I2C_2
,
856 .type
= CX231XX_VMUX_TELEVISION
,
858 .amux
= CX231XX_AMUX_VIDEO
,
860 .type
= CX231XX_VMUX_COMPOSITE1
,
861 .vmux
= CX231XX_VIN_2_1
,
862 .amux
= CX231XX_AMUX_LINE_IN
,
864 .type
= CX231XX_VMUX_SVIDEO
,
865 .vmux
= CX231XX_VIN_1_1
|
866 (CX231XX_VIN_1_2
<< 8) |
868 .amux
= CX231XX_AMUX_LINE_IN
,
872 const unsigned int cx231xx_bcount
= ARRAY_SIZE(cx231xx_boards
);
874 /* table of devices that work with this driver */
875 struct usb_device_id cx231xx_id_table
[] = {
876 {USB_DEVICE(0x1D19, 0x6109),
877 .driver_info
= CX231XX_BOARD_PV_XCAPTURE_USB
},
878 {USB_DEVICE(0x0572, 0x5A3C),
879 .driver_info
= CX231XX_BOARD_UNKNOWN
},
880 {USB_DEVICE(0x0572, 0x58A2),
881 .driver_info
= CX231XX_BOARD_CNXT_CARRAERA
},
882 {USB_DEVICE(0x0572, 0x58A1),
883 .driver_info
= CX231XX_BOARD_CNXT_SHELBY
},
884 {USB_DEVICE(0x0572, 0x58A4),
885 .driver_info
= CX231XX_BOARD_CNXT_RDE_253S
},
886 {USB_DEVICE(0x0572, 0x58A5),
887 .driver_info
= CX231XX_BOARD_CNXT_RDU_253S
},
888 {USB_DEVICE(0x0572, 0x58A6),
889 .driver_info
= CX231XX_BOARD_CNXT_VIDEO_GRABBER
},
890 {USB_DEVICE(0x0572, 0x589E),
891 .driver_info
= CX231XX_BOARD_CNXT_RDE_250
},
892 {USB_DEVICE(0x0572, 0x58A0),
893 .driver_info
= CX231XX_BOARD_CNXT_RDU_250
},
894 {USB_DEVICE(0x2040, 0xb110),
895 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL
},
896 {USB_DEVICE(0x2040, 0xb111),
897 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC
},
898 {USB_DEVICE(0x2040, 0xb120),
899 .driver_info
= CX231XX_BOARD_HAUPPAUGE_EXETER
},
900 {USB_DEVICE(0x2040, 0xb123),
901 .driver_info
= CX231XX_BOARD_HAUPPAUGE_955Q
},
902 {USB_DEVICE(0x2040, 0xb130),
903 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
},
904 {USB_DEVICE(0x2040, 0xb131),
905 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
},
906 /* Hauppauge WinTV-HVR-900-H */
907 {USB_DEVICE(0x2040, 0xb138),
908 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
},
909 /* Hauppauge WinTV-HVR-901-H */
910 {USB_DEVICE(0x2040, 0xb139),
911 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
},
912 {USB_DEVICE(0x2040, 0xb140),
913 .driver_info
= CX231XX_BOARD_HAUPPAUGE_EXETER
},
914 {USB_DEVICE(0x2040, 0xc200),
915 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USBLIVE2
},
916 /* PCTV QuatroStick 521e */
917 {USB_DEVICE(0x2013, 0x0259),
918 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
},
919 /* PCTV QuatroStick 522e */
920 {USB_DEVICE(0x2013, 0x025e),
921 .driver_info
= CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
},
922 {USB_DEVICE_VER(USB_VID_PIXELVIEW
, USB_PID_PIXELVIEW_SBTVD
, 0x4000, 0x4001),
923 .driver_info
= CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
},
924 {USB_DEVICE(USB_VID_PIXELVIEW
, 0x5014),
925 .driver_info
= CX231XX_BOARD_PV_XCAPTURE_USB
},
926 {USB_DEVICE(0x1b80, 0xe424),
927 .driver_info
= CX231XX_BOARD_KWORLD_UB430_USB_HYBRID
},
928 {USB_DEVICE(0x1b80, 0xe421),
929 .driver_info
= CX231XX_BOARD_KWORLD_UB445_USB_HYBRID
},
930 {USB_DEVICE(0x1f4d, 0x0237),
931 .driver_info
= CX231XX_BOARD_ICONBIT_U100
},
932 {USB_DEVICE(0x0fd9, 0x0037),
933 .driver_info
= CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2
},
934 {USB_DEVICE(0x1f4d, 0x0102),
935 .driver_info
= CX231XX_BOARD_OTG102
},
936 {USB_DEVICE(USB_VID_TERRATEC
, 0x00a6),
937 .driver_info
= CX231XX_BOARD_TERRATEC_GRABBY
},
938 {USB_DEVICE(0x1b80, 0xd3b2),
939 .driver_info
= CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD
},
943 MODULE_DEVICE_TABLE(usb
, cx231xx_id_table
);
945 /* cx231xx_tuner_callback
946 * will be used to reset XC5000 tuner using GPIO pin
949 int cx231xx_tuner_callback(void *ptr
, int component
, int command
, int arg
)
952 struct cx231xx
*dev
= ptr
;
954 if (dev
->tuner_type
== TUNER_XC5000
) {
955 if (command
== XC5000_TUNER_RESET
) {
957 "Tuner CB: RESET: cmd %d : tuner type %d\n",
958 command
, dev
->tuner_type
);
959 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
962 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
965 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
969 } else if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
971 case TDA18271_CALLBACK_CMD_AGC_ENABLE
:
972 if (dev
->model
== CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
)
973 rc
= cx231xx_set_agc_analog_digital_mux_select(dev
, arg
);
982 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback
);
984 static void cx231xx_reset_out(struct cx231xx
*dev
)
986 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
988 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 0);
990 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
993 static void cx231xx_enable_OSC(struct cx231xx
*dev
)
995 cx231xx_set_gpio_value(dev
, CX23417_OSC_EN
, 1);
998 static void cx231xx_sleep_s5h1432(struct cx231xx
*dev
)
1000 cx231xx_set_gpio_value(dev
, SLEEP_S5H1432
, 0);
1003 static inline void cx231xx_set_model(struct cx231xx
*dev
)
1005 dev
->board
= cx231xx_boards
[dev
->model
];
1008 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
1009 * this won't work for boards with generic PCI IDs
1011 void cx231xx_pre_card_setup(struct cx231xx
*dev
)
1013 dev_info(dev
->dev
, "Identified as %s (card=%d)\n",
1014 dev
->board
.name
, dev
->model
);
1016 /* set the direction for GPIO pins */
1017 if (dev
->board
.tuner_gpio
) {
1018 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_gpio
->bit
, 1);
1019 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
, 1);
1021 if (dev
->board
.tuner_sif_gpio
>= 0)
1022 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_sif_gpio
, 1);
1024 /* request some modules if any required */
1026 /* set the mode to Analog mode initially */
1027 cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
1030 /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
1034 static void cx231xx_config_tuner(struct cx231xx
*dev
)
1036 struct tuner_setup tun_setup
;
1037 struct v4l2_frequency f
;
1039 if (dev
->tuner_type
== TUNER_ABSENT
)
1042 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
1043 tun_setup
.type
= dev
->tuner_type
;
1044 tun_setup
.addr
= dev
->tuner_addr
;
1045 tun_setup
.tuner_callback
= cx231xx_tuner_callback
;
1047 tuner_call(dev
, tuner
, s_type_addr
, &tun_setup
);
1050 if (tun_setup
.type
== TUNER_XC5000
) {
1051 static struct xc2028_ctrl ctrl
= {
1052 .fname
= XC5000_DEFAULT_FIRMWARE
,
1056 struct v4l2_priv_tun_config cfg
= {
1057 .tuner
= dev
->tuner_type
,
1060 tuner_call(dev
, tuner
, s_config
, &cfg
);
1063 /* configure tuner */
1065 f
.type
= V4L2_TUNER_ANALOG_TV
;
1066 f
.frequency
= 9076; /* just a magic number */
1067 dev
->ctl_freq
= f
.frequency
;
1068 call_all(dev
, tuner
, s_frequency
, &f
);
1072 static int read_eeprom(struct cx231xx
*dev
, struct i2c_client
*client
,
1073 u8
*eedata
, int len
)
1076 u8 start_offset
= 0;
1078 u8
*eedata_cur
= eedata
;
1080 struct i2c_msg msg_write
= { .addr
= client
->addr
, .flags
= 0,
1081 .buf
= &start_offset
, .len
= 1 };
1082 struct i2c_msg msg_read
= { .addr
= client
->addr
, .flags
= I2C_M_RD
};
1084 /* start reading at offset 0 */
1085 ret
= i2c_transfer(client
->adapter
, &msg_write
, 1);
1087 dev_err(dev
->dev
, "Can't read eeprom\n");
1091 while (len_todo
> 0) {
1092 msg_read
.len
= (len_todo
> 64) ? 64 : len_todo
;
1093 msg_read
.buf
= eedata_cur
;
1095 ret
= i2c_transfer(client
->adapter
, &msg_read
, 1);
1097 dev_err(dev
->dev
, "Can't read eeprom\n");
1100 eedata_cur
+= msg_read
.len
;
1101 len_todo
-= msg_read
.len
;
1104 for (i
= 0; i
+ 15 < len
; i
+= 16)
1105 dev_dbg(dev
->dev
, "i2c eeprom %02x: %*ph\n",
1111 void cx231xx_card_setup(struct cx231xx
*dev
)
1114 cx231xx_set_model(dev
);
1116 dev
->tuner_type
= cx231xx_boards
[dev
->model
].tuner_type
;
1117 if (cx231xx_boards
[dev
->model
].tuner_addr
)
1118 dev
->tuner_addr
= cx231xx_boards
[dev
->model
].tuner_addr
;
1120 /* request some modules */
1121 if (dev
->board
.decoder
== CX231XX_AVDECODER
) {
1122 dev
->sd_cx25840
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
1123 cx231xx_get_i2c_adap(dev
, I2C_0
),
1124 "cx25840", 0x88 >> 1, NULL
);
1125 if (dev
->sd_cx25840
== NULL
)
1127 "cx25840 subdev registration failure\n");
1128 cx25840_call(dev
, core
, load_fw
);
1132 /* Initialize the tuner */
1133 if (dev
->board
.tuner_type
!= TUNER_ABSENT
) {
1134 struct i2c_adapter
*tuner_i2c
= cx231xx_get_i2c_adap(dev
,
1135 dev
->board
.tuner_i2c_master
);
1136 dev
->sd_tuner
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
1139 dev
->tuner_addr
, NULL
);
1140 if (dev
->sd_tuner
== NULL
)
1142 "tuner subdev registration failure\n");
1144 cx231xx_config_tuner(dev
);
1147 switch (dev
->model
) {
1148 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx
:
1149 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx
:
1150 case CX231XX_BOARD_HAUPPAUGE_955Q
:
1153 struct tveeprom tvee
;
1155 struct i2c_client client
;
1157 struct eeprom
*e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
1161 "failed to allocate memory to read eeprom\n");
1164 e
->client
.adapter
= cx231xx_get_i2c_adap(dev
, I2C_1_MUX_1
);
1165 e
->client
.addr
= 0xa0 >> 1;
1167 read_eeprom(dev
, &e
->client
, e
->eeprom
, sizeof(e
->eeprom
));
1168 tveeprom_hauppauge_analog(&e
->client
,
1169 &e
->tvee
, e
->eeprom
+ 0xc0);
1179 * inits registers with sane defaults
1181 int cx231xx_config(struct cx231xx
*dev
)
1183 /* TBD need to add cx231xx specific code */
1189 * cx231xx_config_i2c()
1190 * configure i2c attached devices
1192 void cx231xx_config_i2c(struct cx231xx
*dev
)
1194 /* u32 input = INPUT(dev->video_input)->vmux; */
1196 call_all(dev
, video
, s_stream
, 1);
1199 static void cx231xx_unregister_media_device(struct cx231xx
*dev
)
1201 #ifdef CONFIG_MEDIA_CONTROLLER
1202 if (dev
->media_dev
) {
1203 media_device_unregister(dev
->media_dev
);
1204 media_device_cleanup(dev
->media_dev
);
1205 kfree(dev
->media_dev
);
1206 dev
->media_dev
= NULL
;
1212 * cx231xx_realease_resources()
1213 * unregisters the v4l2,i2c and usb devices
1214 * called when the device gets disconected or at module unload
1216 void cx231xx_release_resources(struct cx231xx
*dev
)
1218 cx231xx_ir_exit(dev
);
1220 cx231xx_release_analog_resources(dev
);
1222 cx231xx_remove_from_devlist(dev
);
1224 /* Release I2C buses */
1225 cx231xx_dev_uninit(dev
);
1227 /* delete v4l2 device */
1228 v4l2_device_unregister(&dev
->v4l2_dev
);
1230 cx231xx_unregister_media_device(dev
);
1232 usb_put_dev(dev
->udev
);
1234 /* Mark device as unused */
1235 clear_bit(dev
->devno
, &cx231xx_devused
);
1238 static int cx231xx_media_device_init(struct cx231xx
*dev
,
1239 struct usb_device
*udev
)
1241 #ifdef CONFIG_MEDIA_CONTROLLER
1242 struct media_device
*mdev
;
1244 mdev
= kzalloc(sizeof(*mdev
), GFP_KERNEL
);
1248 media_device_usb_init(mdev
, udev
, dev
->board
.name
);
1250 dev
->media_dev
= mdev
;
1256 * cx231xx_init_dev()
1257 * allocates and inits the device structs, registers i2c bus and v4l device
1259 static int cx231xx_init_dev(struct cx231xx
*dev
, struct usb_device
*udev
,
1262 int retval
= -ENOMEM
;
1263 unsigned int maxh
, maxw
;
1266 mutex_init(&dev
->lock
);
1267 mutex_init(&dev
->ctrl_urb_lock
);
1268 mutex_init(&dev
->gpio_i2c_lock
);
1269 mutex_init(&dev
->i2c_lock
);
1271 spin_lock_init(&dev
->video_mode
.slock
);
1272 spin_lock_init(&dev
->vbi_mode
.slock
);
1273 spin_lock_init(&dev
->sliced_cc_mode
.slock
);
1275 init_waitqueue_head(&dev
->open
);
1276 init_waitqueue_head(&dev
->wait_frame
);
1277 init_waitqueue_head(&dev
->wait_stream
);
1279 dev
->cx231xx_read_ctrl_reg
= cx231xx_read_ctrl_reg
;
1280 dev
->cx231xx_write_ctrl_reg
= cx231xx_write_ctrl_reg
;
1281 dev
->cx231xx_send_usb_command
= cx231xx_send_usb_command
;
1282 dev
->cx231xx_gpio_i2c_read
= cx231xx_gpio_i2c_read
;
1283 dev
->cx231xx_gpio_i2c_write
= cx231xx_gpio_i2c_write
;
1285 /* Query cx231xx to find what pcb config it is related to */
1286 retval
= initialize_cx231xx(dev
);
1288 dev_err(dev
->dev
, "Failed to read PCB config\n");
1292 /*To workaround error number=-71 on EP0 for VideoGrabber,
1293 need set alt here.*/
1294 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
||
1295 dev
->model
== CX231XX_BOARD_HAUPPAUGE_USBLIVE2
) {
1296 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
1297 cx231xx_set_alt_setting(dev
, INDEX_VANC
, 1);
1299 /* Cx231xx pre card setup */
1300 cx231xx_pre_card_setup(dev
);
1302 retval
= cx231xx_config(dev
);
1304 dev_err(dev
->dev
, "error configuring device\n");
1308 /* set default norm */
1309 dev
->norm
= dev
->board
.norm
;
1311 /* register i2c bus */
1312 retval
= cx231xx_dev_init(dev
);
1315 "%s: cx231xx_i2c_register - errCode [%d]!\n",
1320 /* Do board specific init */
1321 cx231xx_card_setup(dev
);
1323 /* configure the device */
1324 cx231xx_config_i2c(dev
);
1326 maxw
= norm_maxw(dev
);
1327 maxh
= norm_maxh(dev
);
1329 /* set default image size */
1332 dev
->interlaced
= 0;
1333 dev
->video_input
= 0;
1335 retval
= cx231xx_config(dev
);
1337 dev_err(dev
->dev
, "%s: cx231xx_config - errCode [%d]!\n",
1342 /* init video dma queues */
1343 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.active
);
1344 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.queued
);
1346 /* init vbi dma queues */
1347 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.active
);
1348 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.queued
);
1350 /* Reset other chips required if they are tied up with GPIO pins */
1351 cx231xx_add_into_devlist(dev
);
1353 if (dev
->board
.has_417
) {
1354 dev_info(dev
->dev
, "attach 417 %d\n", dev
->model
);
1355 if (cx231xx_417_register(dev
) < 0) {
1357 "%s() Failed to register 417 on VID_B\n",
1362 retval
= cx231xx_register_analog_devices(dev
);
1366 cx231xx_ir_init(dev
);
1368 cx231xx_init_extension(dev
);
1372 cx231xx_unregister_media_device(dev
);
1373 cx231xx_release_analog_resources(dev
);
1374 cx231xx_remove_from_devlist(dev
);
1376 cx231xx_dev_uninit(dev
);
1380 #if defined(CONFIG_MODULES) && defined(MODULE)
1381 static void request_module_async(struct work_struct
*work
)
1383 struct cx231xx
*dev
= container_of(work
,
1384 struct cx231xx
, request_module_wk
);
1386 if (dev
->has_alsa_audio
)
1387 request_module("cx231xx-alsa");
1389 if (dev
->board
.has_dvb
)
1390 request_module("cx231xx-dvb");
1394 static void request_modules(struct cx231xx
*dev
)
1396 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
1397 schedule_work(&dev
->request_module_wk
);
1400 static void flush_request_modules(struct cx231xx
*dev
)
1402 flush_work(&dev
->request_module_wk
);
1405 #define request_modules(dev)
1406 #define flush_request_modules(dev)
1407 #endif /* CONFIG_MODULES */
1409 static int cx231xx_init_v4l2(struct cx231xx
*dev
,
1410 struct usb_device
*udev
,
1411 struct usb_interface
*interface
,
1414 struct usb_interface
*uif
;
1419 /* compute alternate max packet sizes for video */
1420 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.video_index
+ 1;
1421 if (idx
>= dev
->max_iad_interface_count
) {
1423 "Video PCB interface #%d doesn't exist\n", idx
);
1427 uif
= udev
->actconfig
->interface
[idx
];
1429 dev
->video_mode
.end_point_addr
= uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.bEndpointAddress
;
1430 dev
->video_mode
.num_alt
= uif
->num_altsetting
;
1433 "video EndPoint Addr 0x%x, Alternate settings: %i\n",
1434 dev
->video_mode
.end_point_addr
,
1435 dev
->video_mode
.num_alt
);
1437 dev
->video_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->video_mode
.num_alt
, GFP_KERNEL
);
1438 if (dev
->video_mode
.alt_max_pkt_size
== NULL
)
1441 for (i
= 0; i
< dev
->video_mode
.num_alt
; i
++) {
1442 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].desc
.wMaxPacketSize
);
1443 dev
->video_mode
.alt_max_pkt_size
[i
] = (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1445 "Alternate setting %i, max size= %i\n", i
,
1446 dev
->video_mode
.alt_max_pkt_size
[i
]);
1451 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.vanc_index
+ 1;
1452 if (idx
>= dev
->max_iad_interface_count
) {
1454 "VBI PCB interface #%d doesn't exist\n", idx
);
1457 uif
= udev
->actconfig
->interface
[idx
];
1459 dev
->vbi_mode
.end_point_addr
=
1460 uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1463 dev
->vbi_mode
.num_alt
= uif
->num_altsetting
;
1465 "VBI EndPoint Addr 0x%x, Alternate settings: %i\n",
1466 dev
->vbi_mode
.end_point_addr
,
1467 dev
->vbi_mode
.num_alt
);
1469 /* compute alternate max packet sizes for vbi */
1470 dev
->vbi_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->vbi_mode
.num_alt
, GFP_KERNEL
);
1471 if (dev
->vbi_mode
.alt_max_pkt_size
== NULL
)
1474 for (i
= 0; i
< dev
->vbi_mode
.num_alt
; i
++) {
1476 le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1477 desc
.wMaxPacketSize
);
1478 dev
->vbi_mode
.alt_max_pkt_size
[i
] =
1479 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1481 "Alternate setting %i, max size= %i\n", i
,
1482 dev
->vbi_mode
.alt_max_pkt_size
[i
]);
1485 /* Sliced CC VBI init */
1487 /* compute alternate max packet sizes for sliced CC */
1488 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.hanc_index
+ 1;
1489 if (idx
>= dev
->max_iad_interface_count
) {
1491 "Sliced CC PCB interface #%d doesn't exist\n", idx
);
1494 uif
= udev
->actconfig
->interface
[idx
];
1496 dev
->sliced_cc_mode
.end_point_addr
=
1497 uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1500 dev
->sliced_cc_mode
.num_alt
= uif
->num_altsetting
;
1502 "sliced CC EndPoint Addr 0x%x, Alternate settings: %i\n",
1503 dev
->sliced_cc_mode
.end_point_addr
,
1504 dev
->sliced_cc_mode
.num_alt
);
1505 dev
->sliced_cc_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->sliced_cc_mode
.num_alt
, GFP_KERNEL
);
1506 if (dev
->sliced_cc_mode
.alt_max_pkt_size
== NULL
)
1509 for (i
= 0; i
< dev
->sliced_cc_mode
.num_alt
; i
++) {
1510 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1511 desc
.wMaxPacketSize
);
1512 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
] =
1513 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1515 "Alternate setting %i, max size= %i\n", i
,
1516 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
]);
1523 * cx231xx_usb_probe()
1524 * checks for supported devices
1526 static int cx231xx_usb_probe(struct usb_interface
*interface
,
1527 const struct usb_device_id
*id
)
1529 struct usb_device
*udev
;
1530 struct device
*d
= &interface
->dev
;
1531 struct usb_interface
*uif
;
1532 struct cx231xx
*dev
= NULL
;
1533 int retval
= -ENODEV
;
1535 int i
, isoc_pipe
= 0;
1538 struct usb_interface_assoc_descriptor
*assoc_desc
;
1540 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
1543 * Interface number 0 - IR interface (handled by mceusb driver)
1544 * Interface number 1 - AV interface (handled by this driver)
1549 /* Check to see next free device and mark as used */
1551 nr
= find_first_zero_bit(&cx231xx_devused
, CX231XX_MAXBOARDS
);
1552 if (nr
>= CX231XX_MAXBOARDS
) {
1553 /* No free device slots */
1555 "Supports only %i devices.\n",
1559 } while (test_and_set_bit(nr
, &cx231xx_devused
));
1561 udev
= usb_get_dev(interface_to_usbdev(interface
));
1563 /* allocate memory for our device state and initialize it */
1564 dev
= devm_kzalloc(&udev
->dev
, sizeof(*dev
), GFP_KERNEL
);
1570 snprintf(dev
->name
, 29, "cx231xx #%d", nr
);
1572 dev
->model
= id
->driver_info
;
1573 dev
->video_mode
.alt
= -1;
1576 cx231xx_set_model(dev
);
1578 dev
->interface_count
++;
1579 /* reset gpio dir and value */
1582 dev
->xc_fw_load_done
= 0;
1583 dev
->has_alsa_audio
= 1;
1584 dev
->power_mode
= -1;
1585 atomic_set(&dev
->devlist_count
, 0);
1587 /* 0 - vbi ; 1 -sliced cc mode */
1588 dev
->vbi_or_sliced_cc_mode
= 0;
1590 /* get maximum no.of IAD interfaces */
1591 dev
->max_iad_interface_count
= udev
->config
->desc
.bNumInterfaces
;
1593 /* init CIR module TBD */
1595 /*mode_tv: digital=1 or analog=0*/
1598 dev
->USE_ISO
= transfer_mode
;
1600 switch (udev
->speed
) {
1604 case USB_SPEED_UNKNOWN
:
1605 case USB_SPEED_FULL
:
1608 case USB_SPEED_HIGH
:
1616 "New device %s %s @ %s Mbps (%04x:%04x) with %d interfaces\n",
1617 udev
->manufacturer
? udev
->manufacturer
: "",
1618 udev
->product
? udev
->product
: "",
1620 le16_to_cpu(udev
->descriptor
.idVendor
),
1621 le16_to_cpu(udev
->descriptor
.idProduct
),
1622 dev
->max_iad_interface_count
);
1624 /* increment interface count */
1625 dev
->interface_count
++;
1627 /* get device number */
1630 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
1631 if (assoc_desc
->bFirstInterface
!= ifnum
) {
1632 dev_err(d
, "Not found matching IAD interface\n");
1637 dev_dbg(d
, "registering interface %d\n", ifnum
);
1639 /* save our data pointer in this interface device */
1640 usb_set_intfdata(interface
, dev
);
1642 /* Initialize the media controller */
1643 retval
= cx231xx_media_device_init(dev
, udev
);
1645 dev_err(d
, "cx231xx_media_device_init failed\n");
1646 goto err_media_init
;
1649 /* Create v4l2 device */
1650 #ifdef CONFIG_MEDIA_CONTROLLER
1651 dev
->v4l2_dev
.mdev
= dev
->media_dev
;
1653 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
1655 dev_err(d
, "v4l2_device_register failed\n");
1659 /* allocate device struct */
1660 retval
= cx231xx_init_dev(dev
, udev
, nr
);
1664 retval
= cx231xx_init_v4l2(dev
, udev
, interface
, isoc_pipe
);
1668 if (dev
->current_pcb_config
.ts1_source
!= 0xff) {
1669 /* compute alternate max packet sizes for TS1 */
1670 idx
= dev
->current_pcb_config
.hs_config_info
[0].interface_info
.ts1_index
+ 1;
1671 if (idx
>= dev
->max_iad_interface_count
) {
1672 dev_err(d
, "TS1 PCB interface #%d doesn't exist\n",
1677 uif
= udev
->actconfig
->interface
[idx
];
1679 dev
->ts1_mode
.end_point_addr
=
1680 uif
->altsetting
[0].endpoint
[isoc_pipe
].
1681 desc
.bEndpointAddress
;
1683 dev
->ts1_mode
.num_alt
= uif
->num_altsetting
;
1685 "TS EndPoint Addr 0x%x, Alternate settings: %i\n",
1686 dev
->ts1_mode
.end_point_addr
,
1687 dev
->ts1_mode
.num_alt
);
1689 dev
->ts1_mode
.alt_max_pkt_size
= devm_kmalloc_array(&udev
->dev
, 32, dev
->ts1_mode
.num_alt
, GFP_KERNEL
);
1690 if (dev
->ts1_mode
.alt_max_pkt_size
== NULL
) {
1695 for (i
= 0; i
< dev
->ts1_mode
.num_alt
; i
++) {
1696 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].
1697 endpoint
[isoc_pipe
].desc
.
1699 dev
->ts1_mode
.alt_max_pkt_size
[i
] =
1700 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1701 dev_dbg(d
, "Alternate setting %i, max size= %i\n",
1702 i
, dev
->ts1_mode
.alt_max_pkt_size
[i
]);
1706 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
1707 cx231xx_enable_OSC(dev
);
1708 cx231xx_reset_out(dev
);
1709 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
1712 if (dev
->model
== CX231XX_BOARD_CNXT_RDE_253S
)
1713 cx231xx_sleep_s5h1432(dev
);
1715 /* load other modules required */
1716 request_modules(dev
);
1718 #ifdef CONFIG_MEDIA_CONTROLLER
1719 /* Init entities at the Media Controller */
1720 cx231xx_v4l2_create_entities(dev
);
1722 retval
= v4l2_mc_create_media_graph(dev
->media_dev
);
1724 retval
= media_device_register(dev
->media_dev
);
1727 cx231xx_release_resources(dev
);
1731 /* cx231xx_uninit_dev: */
1732 cx231xx_close_extension(dev
);
1733 cx231xx_ir_exit(dev
);
1734 cx231xx_release_analog_resources(dev
);
1735 cx231xx_417_unregister(dev
);
1736 cx231xx_remove_from_devlist(dev
);
1737 cx231xx_dev_uninit(dev
);
1739 v4l2_device_unregister(&dev
->v4l2_dev
);
1741 cx231xx_unregister_media_device(dev
);
1743 usb_set_intfdata(interface
, NULL
);
1746 clear_bit(nr
, &cx231xx_devused
);
1751 * cx231xx_usb_disconnect()
1752 * called when the device gets diconencted
1753 * video device will be unregistered on v4l2_close in case it is still open
1755 static void cx231xx_usb_disconnect(struct usb_interface
*interface
)
1757 struct cx231xx
*dev
;
1759 dev
= usb_get_intfdata(interface
);
1760 usb_set_intfdata(interface
, NULL
);
1768 dev
->state
|= DEV_DISCONNECTED
;
1770 flush_request_modules(dev
);
1772 /* wait until all current v4l2 io is finished then deallocate
1774 mutex_lock(&dev
->lock
);
1776 wake_up_interruptible_all(&dev
->open
);
1780 "device %s is open! Deregistration and memory deallocation are deferred on close.\n",
1781 video_device_node_name(&dev
->vdev
));
1783 /* Even having users, it is safe to remove the RC i2c driver */
1784 cx231xx_ir_exit(dev
);
1787 cx231xx_uninit_isoc(dev
);
1789 cx231xx_uninit_bulk(dev
);
1790 wake_up_interruptible(&dev
->wait_frame
);
1791 wake_up_interruptible(&dev
->wait_stream
);
1795 cx231xx_close_extension(dev
);
1797 mutex_unlock(&dev
->lock
);
1800 cx231xx_release_resources(dev
);
1803 static struct usb_driver cx231xx_usb_driver
= {
1805 .probe
= cx231xx_usb_probe
,
1806 .disconnect
= cx231xx_usb_disconnect
,
1807 .id_table
= cx231xx_id_table
,
1810 module_usb_driver(cx231xx_usb_driver
);