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.
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/delay.h>
27 #include <linux/i2c.h>
28 #include <linux/usb.h>
29 #include <media/tuner.h>
30 #include <media/tveeprom.h>
31 #include <media/v4l2-common.h>
32 #include <media/v4l2-chip-ident.h>
34 #include <media/cx25840.h>
35 #include "dvb-usb-ids.h"
41 static int tuner
= -1;
42 module_param(tuner
, int, 0444);
43 MODULE_PARM_DESC(tuner
, "tuner type");
45 static int transfer_mode
= 1;
46 module_param(transfer_mode
, int, 0444);
47 MODULE_PARM_DESC(transfer_mode
, "transfer mode (1-ISO or 0-BULK)");
49 static unsigned int disable_ir
;
50 module_param(disable_ir
, int, 0444);
51 MODULE_PARM_DESC(disable_ir
, "disable infrared remote support");
53 /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
54 static unsigned long cx231xx_devused
;
57 * Reset sequences for analog/digital modes
60 static struct cx231xx_reg_seq RDE250_XCV_TUNER
[] = {
70 struct cx231xx_board cx231xx_boards
[] = {
71 [CX231XX_BOARD_UNKNOWN
] = {
72 .name
= "Unknown CX231xx video grabber",
73 .tuner_type
= TUNER_ABSENT
,
75 .type
= CX231XX_VMUX_TELEVISION
,
76 .vmux
= CX231XX_VIN_3_1
,
77 .amux
= CX231XX_AMUX_VIDEO
,
80 .type
= CX231XX_VMUX_COMPOSITE1
,
81 .vmux
= CX231XX_VIN_2_1
,
82 .amux
= CX231XX_AMUX_LINE_IN
,
85 .type
= CX231XX_VMUX_SVIDEO
,
86 .vmux
= CX231XX_VIN_1_1
|
87 (CX231XX_VIN_1_2
<< 8) |
89 .amux
= CX231XX_AMUX_LINE_IN
,
94 [CX231XX_BOARD_CNXT_CARRAERA
] = {
95 .name
= "Conexant Hybrid TV - CARRAERA",
96 .tuner_type
= TUNER_XC5000
,
98 .tuner_gpio
= RDE250_XCV_TUNER
,
99 .tuner_sif_gpio
= 0x05,
100 .tuner_scl_gpio
= 0x1a,
101 .tuner_sda_gpio
= 0x1b,
102 .decoder
= CX231XX_AVDECODER
,
103 .output_mode
= OUT_MODE_VIP11
,
104 .demod_xfer_mode
= 0,
105 .ctl_pin_status_mask
= 0xFFFFFFC4,
106 .agc_analog_digital_select_gpio
= 0x0c,
107 .gpio_pin_status_mask
= 0x4001000,
108 .tuner_i2c_master
= 1,
109 .demod_i2c_master
= 2,
112 .norm
= V4L2_STD_PAL
,
115 .type
= CX231XX_VMUX_TELEVISION
,
116 .vmux
= CX231XX_VIN_3_1
,
117 .amux
= CX231XX_AMUX_VIDEO
,
120 .type
= CX231XX_VMUX_COMPOSITE1
,
121 .vmux
= CX231XX_VIN_2_1
,
122 .amux
= CX231XX_AMUX_LINE_IN
,
125 .type
= CX231XX_VMUX_SVIDEO
,
126 .vmux
= CX231XX_VIN_1_1
|
127 (CX231XX_VIN_1_2
<< 8) |
129 .amux
= CX231XX_AMUX_LINE_IN
,
134 [CX231XX_BOARD_CNXT_SHELBY
] = {
135 .name
= "Conexant Hybrid TV - SHELBY",
136 .tuner_type
= TUNER_XC5000
,
138 .tuner_gpio
= RDE250_XCV_TUNER
,
139 .tuner_sif_gpio
= 0x05,
140 .tuner_scl_gpio
= 0x1a,
141 .tuner_sda_gpio
= 0x1b,
142 .decoder
= CX231XX_AVDECODER
,
143 .output_mode
= OUT_MODE_VIP11
,
144 .demod_xfer_mode
= 0,
145 .ctl_pin_status_mask
= 0xFFFFFFC4,
146 .agc_analog_digital_select_gpio
= 0x0c,
147 .gpio_pin_status_mask
= 0x4001000,
148 .tuner_i2c_master
= 1,
149 .demod_i2c_master
= 2,
152 .norm
= V4L2_STD_NTSC
,
155 .type
= CX231XX_VMUX_TELEVISION
,
156 .vmux
= CX231XX_VIN_3_1
,
157 .amux
= CX231XX_AMUX_VIDEO
,
160 .type
= CX231XX_VMUX_COMPOSITE1
,
161 .vmux
= CX231XX_VIN_2_1
,
162 .amux
= CX231XX_AMUX_LINE_IN
,
165 .type
= CX231XX_VMUX_SVIDEO
,
166 .vmux
= CX231XX_VIN_1_1
|
167 (CX231XX_VIN_1_2
<< 8) |
169 .amux
= CX231XX_AMUX_LINE_IN
,
174 [CX231XX_BOARD_CNXT_RDE_253S
] = {
175 .name
= "Conexant Hybrid TV - RDE253S",
176 .tuner_type
= TUNER_NXP_TDA18271
,
178 .tuner_gpio
= RDE250_XCV_TUNER
,
179 .tuner_sif_gpio
= 0x05,
180 .tuner_scl_gpio
= 0x1a,
181 .tuner_sda_gpio
= 0x1b,
182 .decoder
= CX231XX_AVDECODER
,
183 .output_mode
= OUT_MODE_VIP11
,
184 .demod_xfer_mode
= 0,
185 .ctl_pin_status_mask
= 0xFFFFFFC4,
186 .agc_analog_digital_select_gpio
= 0x1c,
187 .gpio_pin_status_mask
= 0x4001000,
188 .tuner_i2c_master
= 1,
189 .demod_i2c_master
= 2,
192 .norm
= V4L2_STD_PAL
,
195 .type
= CX231XX_VMUX_TELEVISION
,
196 .vmux
= CX231XX_VIN_3_1
,
197 .amux
= CX231XX_AMUX_VIDEO
,
200 .type
= CX231XX_VMUX_COMPOSITE1
,
201 .vmux
= CX231XX_VIN_2_1
,
202 .amux
= CX231XX_AMUX_LINE_IN
,
205 .type
= CX231XX_VMUX_SVIDEO
,
206 .vmux
= CX231XX_VIN_1_1
|
207 (CX231XX_VIN_1_2
<< 8) |
209 .amux
= CX231XX_AMUX_LINE_IN
,
215 [CX231XX_BOARD_CNXT_RDU_253S
] = {
216 .name
= "Conexant Hybrid TV - RDU253S",
217 .tuner_type
= TUNER_NXP_TDA18271
,
219 .tuner_gpio
= RDE250_XCV_TUNER
,
220 .tuner_sif_gpio
= 0x05,
221 .tuner_scl_gpio
= 0x1a,
222 .tuner_sda_gpio
= 0x1b,
223 .decoder
= CX231XX_AVDECODER
,
224 .output_mode
= OUT_MODE_VIP11
,
225 .demod_xfer_mode
= 0,
226 .ctl_pin_status_mask
= 0xFFFFFFC4,
227 .agc_analog_digital_select_gpio
= 0x1c,
228 .gpio_pin_status_mask
= 0x4001000,
229 .tuner_i2c_master
= 1,
230 .demod_i2c_master
= 2,
233 .norm
= V4L2_STD_PAL
,
236 .type
= CX231XX_VMUX_TELEVISION
,
237 .vmux
= CX231XX_VIN_3_1
,
238 .amux
= CX231XX_AMUX_VIDEO
,
241 .type
= CX231XX_VMUX_COMPOSITE1
,
242 .vmux
= CX231XX_VIN_2_1
,
243 .amux
= CX231XX_AMUX_LINE_IN
,
246 .type
= CX231XX_VMUX_SVIDEO
,
247 .vmux
= CX231XX_VIN_1_1
|
248 (CX231XX_VIN_1_2
<< 8) |
250 .amux
= CX231XX_AMUX_LINE_IN
,
255 [CX231XX_BOARD_CNXT_VIDEO_GRABBER
] = {
256 .name
= "Conexant VIDEO GRABBER",
257 .tuner_type
= TUNER_ABSENT
,
258 .decoder
= CX231XX_AVDECODER
,
259 .output_mode
= OUT_MODE_VIP11
,
260 .ctl_pin_status_mask
= 0xFFFFFFC4,
261 .agc_analog_digital_select_gpio
= 0x1c,
262 .gpio_pin_status_mask
= 0x4001000,
263 .norm
= V4L2_STD_PAL
,
269 .type
= CX231XX_VMUX_COMPOSITE1
,
270 .vmux
= CX231XX_VIN_2_1
,
271 .amux
= CX231XX_AMUX_LINE_IN
,
274 .type
= CX231XX_VMUX_SVIDEO
,
275 .vmux
= CX231XX_VIN_1_1
|
276 (CX231XX_VIN_1_2
<< 8) |
278 .amux
= CX231XX_AMUX_LINE_IN
,
283 [CX231XX_BOARD_CNXT_RDE_250
] = {
284 .name
= "Conexant Hybrid TV - rde 250",
285 .tuner_type
= TUNER_XC5000
,
287 .tuner_gpio
= RDE250_XCV_TUNER
,
288 .tuner_sif_gpio
= 0x05,
289 .tuner_scl_gpio
= 0x1a,
290 .tuner_sda_gpio
= 0x1b,
291 .decoder
= CX231XX_AVDECODER
,
292 .output_mode
= OUT_MODE_VIP11
,
293 .demod_xfer_mode
= 0,
294 .ctl_pin_status_mask
= 0xFFFFFFC4,
295 .agc_analog_digital_select_gpio
= 0x0c,
296 .gpio_pin_status_mask
= 0x4001000,
297 .tuner_i2c_master
= 1,
298 .demod_i2c_master
= 2,
301 .norm
= V4L2_STD_PAL
,
304 .type
= CX231XX_VMUX_TELEVISION
,
305 .vmux
= CX231XX_VIN_2_1
,
306 .amux
= CX231XX_AMUX_VIDEO
,
311 [CX231XX_BOARD_CNXT_RDU_250
] = {
312 .name
= "Conexant Hybrid TV - RDU 250",
313 .tuner_type
= TUNER_XC5000
,
315 .tuner_gpio
= RDE250_XCV_TUNER
,
316 .tuner_sif_gpio
= 0x05,
317 .tuner_scl_gpio
= 0x1a,
318 .tuner_sda_gpio
= 0x1b,
319 .decoder
= CX231XX_AVDECODER
,
320 .output_mode
= OUT_MODE_VIP11
,
321 .demod_xfer_mode
= 0,
322 .ctl_pin_status_mask
= 0xFFFFFFC4,
323 .agc_analog_digital_select_gpio
= 0x0c,
324 .gpio_pin_status_mask
= 0x4001000,
325 .tuner_i2c_master
= 1,
326 .demod_i2c_master
= 2,
329 .norm
= V4L2_STD_NTSC
,
332 .type
= CX231XX_VMUX_TELEVISION
,
333 .vmux
= CX231XX_VIN_2_1
,
334 .amux
= CX231XX_AMUX_VIDEO
,
339 [CX231XX_BOARD_HAUPPAUGE_EXETER
] = {
340 .name
= "Hauppauge EXETER",
341 .tuner_type
= TUNER_NXP_TDA18271
,
343 .tuner_gpio
= RDE250_XCV_TUNER
,
344 .tuner_sif_gpio
= 0x05,
345 .tuner_scl_gpio
= 0x1a,
346 .tuner_sda_gpio
= 0x1b,
347 .decoder
= CX231XX_AVDECODER
,
348 .output_mode
= OUT_MODE_VIP11
,
349 .demod_xfer_mode
= 0,
350 .ctl_pin_status_mask
= 0xFFFFFFC4,
351 .agc_analog_digital_select_gpio
= 0x0c,
352 .gpio_pin_status_mask
= 0x4001000,
353 .tuner_i2c_master
= 1,
354 .demod_i2c_master
= 2,
357 .norm
= V4L2_STD_NTSC
,
360 .type
= CX231XX_VMUX_TELEVISION
,
361 .vmux
= CX231XX_VIN_3_1
,
362 .amux
= CX231XX_AMUX_VIDEO
,
365 .type
= CX231XX_VMUX_COMPOSITE1
,
366 .vmux
= CX231XX_VIN_2_1
,
367 .amux
= CX231XX_AMUX_LINE_IN
,
370 .type
= CX231XX_VMUX_SVIDEO
,
371 .vmux
= CX231XX_VIN_1_1
|
372 (CX231XX_VIN_1_2
<< 8) |
374 .amux
= CX231XX_AMUX_LINE_IN
,
378 [CX231XX_BOARD_HAUPPAUGE_USBLIVE2
] = {
379 .name
= "Hauppauge USB Live 2",
380 .tuner_type
= TUNER_ABSENT
,
381 .decoder
= CX231XX_AVDECODER
,
382 .output_mode
= OUT_MODE_VIP11
,
383 .demod_xfer_mode
= 0,
384 .ctl_pin_status_mask
= 0xFFFFFFC4,
385 .agc_analog_digital_select_gpio
= 0x0c,
386 .gpio_pin_status_mask
= 0x4001000,
387 .norm
= V4L2_STD_NTSC
,
390 .dont_use_port_3
= 1,
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
= 2,
419 .demod_i2c_master
= 1,
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_PV_PLAYTV_USB_HYBRID
] = {
444 .name
= "Pixelview PlayTV 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
= 0x00, /* 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
= 2,
457 .demod_i2c_master
= 1,
459 .rc_map_name
= RC_MAP_PIXELVIEW_002T
,
462 .norm
= V4L2_STD_PAL_M
,
464 .type
= CX231XX_VMUX_TELEVISION
,
465 .vmux
= CX231XX_VIN_3_1
,
466 .amux
= CX231XX_AMUX_VIDEO
,
469 .type
= CX231XX_VMUX_COMPOSITE1
,
470 .vmux
= CX231XX_VIN_2_1
,
471 .amux
= CX231XX_AMUX_LINE_IN
,
474 .type
= CX231XX_VMUX_SVIDEO
,
475 .vmux
= CX231XX_VIN_1_1
|
476 (CX231XX_VIN_1_2
<< 8) |
478 .amux
= CX231XX_AMUX_LINE_IN
,
482 [CX231XX_BOARD_PV_XCAPTURE_USB
] = {
483 .name
= "Pixelview Xcapture USB",
484 .tuner_type
= TUNER_ABSENT
,
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
= 0x0c,
490 .gpio_pin_status_mask
= 0x4001000,
491 .norm
= V4L2_STD_NTSC
,
494 .dont_use_port_3
= 1,
497 .type
= CX231XX_VMUX_COMPOSITE1
,
498 .vmux
= CX231XX_VIN_2_1
,
499 .amux
= CX231XX_AMUX_LINE_IN
,
502 .type
= CX231XX_VMUX_SVIDEO
,
503 .vmux
= CX231XX_VIN_1_1
|
504 (CX231XX_VIN_1_2
<< 8) |
506 .amux
= CX231XX_AMUX_LINE_IN
,
512 [CX231XX_BOARD_ICONBIT_U100
] = {
513 .name
= "Iconbit Analog Stick U100 FM",
514 .tuner_type
= TUNER_ABSENT
,
515 .decoder
= CX231XX_AVDECODER
,
516 .output_mode
= OUT_MODE_VIP11
,
517 .demod_xfer_mode
= 0,
518 .ctl_pin_status_mask
= 0xFFFFFFC4,
519 .agc_analog_digital_select_gpio
= 0x1C,
520 .gpio_pin_status_mask
= 0x4001000,
523 .type
= CX231XX_VMUX_COMPOSITE1
,
524 .vmux
= CX231XX_VIN_2_1
,
525 .amux
= CX231XX_AMUX_LINE_IN
,
528 .type
= CX231XX_VMUX_SVIDEO
,
529 .vmux
= CX231XX_VIN_1_1
|
530 (CX231XX_VIN_1_2
<< 8) |
532 .amux
= CX231XX_AMUX_LINE_IN
,
536 [CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL
] = {
537 .name
= "Hauppauge WinTV USB2 FM (PAL)",
538 .tuner_type
= TUNER_NXP_TDA18271
,
540 .tuner_gpio
= RDE250_XCV_TUNER
,
541 .tuner_sif_gpio
= 0x05,
542 .tuner_scl_gpio
= 0x1a,
543 .tuner_sda_gpio
= 0x1b,
544 .decoder
= CX231XX_AVDECODER
,
545 .output_mode
= OUT_MODE_VIP11
,
546 .ctl_pin_status_mask
= 0xFFFFFFC4,
547 .agc_analog_digital_select_gpio
= 0x0c,
548 .gpio_pin_status_mask
= 0x4001000,
549 .tuner_i2c_master
= 1,
550 .norm
= V4L2_STD_PAL
,
553 .type
= CX231XX_VMUX_TELEVISION
,
554 .vmux
= CX231XX_VIN_3_1
,
555 .amux
= CX231XX_AMUX_VIDEO
,
558 .type
= CX231XX_VMUX_COMPOSITE1
,
559 .vmux
= CX231XX_VIN_2_1
,
560 .amux
= CX231XX_AMUX_LINE_IN
,
563 .type
= CX231XX_VMUX_SVIDEO
,
564 .vmux
= CX231XX_VIN_1_1
|
565 (CX231XX_VIN_1_2
<< 8) |
567 .amux
= CX231XX_AMUX_LINE_IN
,
571 [CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC
] = {
572 .name
= "Hauppauge WinTV USB2 FM (NTSC)",
573 .tuner_type
= TUNER_NXP_TDA18271
,
575 .tuner_gpio
= RDE250_XCV_TUNER
,
576 .tuner_sif_gpio
= 0x05,
577 .tuner_scl_gpio
= 0x1a,
578 .tuner_sda_gpio
= 0x1b,
579 .decoder
= CX231XX_AVDECODER
,
580 .output_mode
= OUT_MODE_VIP11
,
581 .ctl_pin_status_mask
= 0xFFFFFFC4,
582 .agc_analog_digital_select_gpio
= 0x0c,
583 .gpio_pin_status_mask
= 0x4001000,
584 .tuner_i2c_master
= 1,
585 .norm
= V4L2_STD_NTSC
,
588 .type
= CX231XX_VMUX_TELEVISION
,
589 .vmux
= CX231XX_VIN_3_1
,
590 .amux
= CX231XX_AMUX_VIDEO
,
593 .type
= CX231XX_VMUX_COMPOSITE1
,
594 .vmux
= CX231XX_VIN_2_1
,
595 .amux
= CX231XX_AMUX_LINE_IN
,
598 .type
= CX231XX_VMUX_SVIDEO
,
599 .vmux
= CX231XX_VIN_1_1
|
600 (CX231XX_VIN_1_2
<< 8) |
602 .amux
= CX231XX_AMUX_LINE_IN
,
607 const unsigned int cx231xx_bcount
= ARRAY_SIZE(cx231xx_boards
);
609 /* table of devices that work with this driver */
610 struct usb_device_id cx231xx_id_table
[] = {
611 {USB_DEVICE(0x0572, 0x5A3C),
612 .driver_info
= CX231XX_BOARD_UNKNOWN
},
613 {USB_DEVICE(0x0572, 0x58A2),
614 .driver_info
= CX231XX_BOARD_CNXT_CARRAERA
},
615 {USB_DEVICE(0x0572, 0x58A1),
616 .driver_info
= CX231XX_BOARD_CNXT_SHELBY
},
617 {USB_DEVICE(0x0572, 0x58A4),
618 .driver_info
= CX231XX_BOARD_CNXT_RDE_253S
},
619 {USB_DEVICE(0x0572, 0x58A5),
620 .driver_info
= CX231XX_BOARD_CNXT_RDU_253S
},
621 {USB_DEVICE(0x0572, 0x58A6),
622 .driver_info
= CX231XX_BOARD_CNXT_VIDEO_GRABBER
},
623 {USB_DEVICE(0x0572, 0x589E),
624 .driver_info
= CX231XX_BOARD_CNXT_RDE_250
},
625 {USB_DEVICE(0x0572, 0x58A0),
626 .driver_info
= CX231XX_BOARD_CNXT_RDU_250
},
627 {USB_DEVICE(0x2040, 0xb110),
628 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL
},
629 {USB_DEVICE(0x2040, 0xb111),
630 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC
},
631 {USB_DEVICE(0x2040, 0xb120),
632 .driver_info
= CX231XX_BOARD_HAUPPAUGE_EXETER
},
633 {USB_DEVICE(0x2040, 0xb140),
634 .driver_info
= CX231XX_BOARD_HAUPPAUGE_EXETER
},
635 {USB_DEVICE(0x2040, 0xc200),
636 .driver_info
= CX231XX_BOARD_HAUPPAUGE_USBLIVE2
},
637 {USB_DEVICE_VER(USB_VID_PIXELVIEW
, USB_PID_PIXELVIEW_SBTVD
, 0x4000, 0x4001),
638 .driver_info
= CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
},
639 {USB_DEVICE(USB_VID_PIXELVIEW
, 0x5014),
640 .driver_info
= CX231XX_BOARD_PV_XCAPTURE_USB
},
641 {USB_DEVICE(0x1b80, 0xe424),
642 .driver_info
= CX231XX_BOARD_KWORLD_UB430_USB_HYBRID
},
643 {USB_DEVICE(0x1f4d, 0x0237),
644 .driver_info
= CX231XX_BOARD_ICONBIT_U100
},
648 MODULE_DEVICE_TABLE(usb
, cx231xx_id_table
);
650 /* cx231xx_tuner_callback
651 * will be used to reset XC5000 tuner using GPIO pin
654 int cx231xx_tuner_callback(void *ptr
, int component
, int command
, int arg
)
657 struct cx231xx
*dev
= ptr
;
659 if (dev
->tuner_type
== TUNER_XC5000
) {
660 if (command
== XC5000_TUNER_RESET
) {
662 ("Tuner CB: RESET: cmd %d : tuner type %d \n",
663 command
, dev
->tuner_type
);
664 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
667 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
670 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
674 } else if (dev
->tuner_type
== TUNER_NXP_TDA18271
) {
676 case TDA18271_CALLBACK_CMD_AGC_ENABLE
:
677 if (dev
->model
== CX231XX_BOARD_PV_PLAYTV_USB_HYBRID
)
678 rc
= cx231xx_set_agc_analog_digital_mux_select(dev
, arg
);
687 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback
);
689 void cx231xx_reset_out(struct cx231xx
*dev
)
691 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
693 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 0);
695 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
697 void cx231xx_enable_OSC(struct cx231xx
*dev
)
699 cx231xx_set_gpio_value(dev
, CX23417_OSC_EN
, 1);
701 void cx231xx_sleep_s5h1432(struct cx231xx
*dev
)
703 cx231xx_set_gpio_value(dev
, SLEEP_S5H1432
, 0);
706 static inline void cx231xx_set_model(struct cx231xx
*dev
)
708 memcpy(&dev
->board
, &cx231xx_boards
[dev
->model
], sizeof(dev
->board
));
711 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
712 * this won't work for boards with generic PCI IDs
714 void cx231xx_pre_card_setup(struct cx231xx
*dev
)
717 cx231xx_set_model(dev
);
719 cx231xx_info("Identified as %s (card=%d)\n",
720 dev
->board
.name
, dev
->model
);
722 /* set the direction for GPIO pins */
723 if (dev
->board
.tuner_gpio
) {
724 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_gpio
->bit
, 1);
725 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
, 1);
727 if (dev
->board
.tuner_sif_gpio
>= 0)
728 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_sif_gpio
, 1);
730 /* request some modules if any required */
732 /* set the mode to Analog mode initially */
733 cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
736 /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
740 static void cx231xx_config_tuner(struct cx231xx
*dev
)
742 struct tuner_setup tun_setup
;
743 struct v4l2_frequency f
;
745 if (dev
->tuner_type
== TUNER_ABSENT
)
748 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
749 tun_setup
.type
= dev
->tuner_type
;
750 tun_setup
.addr
= dev
->tuner_addr
;
751 tun_setup
.tuner_callback
= cx231xx_tuner_callback
;
753 tuner_call(dev
, tuner
, s_type_addr
, &tun_setup
);
756 if (tun_setup
.type
== TUNER_XC5000
) {
757 static struct xc2028_ctrl ctrl
= {
758 .fname
= XC5000_DEFAULT_FIRMWARE
,
762 struct v4l2_priv_tun_config cfg
= {
763 .tuner
= dev
->tuner_type
,
766 tuner_call(dev
, tuner
, s_config
, &cfg
);
769 /* configure tuner */
771 f
.type
= V4L2_TUNER_ANALOG_TV
;
772 f
.frequency
= 9076; /* just a magic number */
773 dev
->ctl_freq
= f
.frequency
;
774 call_all(dev
, tuner
, s_frequency
, &f
);
778 void cx231xx_card_setup(struct cx231xx
*dev
)
781 cx231xx_set_model(dev
);
783 dev
->tuner_type
= cx231xx_boards
[dev
->model
].tuner_type
;
784 if (cx231xx_boards
[dev
->model
].tuner_addr
)
785 dev
->tuner_addr
= cx231xx_boards
[dev
->model
].tuner_addr
;
787 /* request some modules */
788 if (dev
->board
.decoder
== CX231XX_AVDECODER
) {
789 dev
->sd_cx25840
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
790 &dev
->i2c_bus
[0].i2c_adap
,
791 "cx25840", 0x88 >> 1, NULL
);
792 if (dev
->sd_cx25840
== NULL
)
793 cx231xx_info("cx25840 subdev registration failure\n");
794 cx25840_call(dev
, core
, load_fw
);
798 /* Initialize the tuner */
799 if (dev
->board
.tuner_type
!= TUNER_ABSENT
) {
800 dev
->sd_tuner
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
801 &dev
->i2c_bus
[dev
->board
.tuner_i2c_master
].i2c_adap
,
803 dev
->tuner_addr
, NULL
);
804 if (dev
->sd_tuner
== NULL
)
805 cx231xx_info("tuner subdev registration failure\n");
807 cx231xx_config_tuner(dev
);
813 * inits registers with sane defaults
815 int cx231xx_config(struct cx231xx
*dev
)
817 /* TBD need to add cx231xx specific code */
818 dev
->mute
= 1; /* maybe not the right place... */
825 * cx231xx_config_i2c()
826 * configure i2c attached devices
828 void cx231xx_config_i2c(struct cx231xx
*dev
)
830 /* u32 input = INPUT(dev->video_input)->vmux; */
832 call_all(dev
, video
, s_stream
, 1);
836 * cx231xx_realease_resources()
837 * unregisters the v4l2,i2c and usb devices
838 * called when the device gets disconected or at module unload
840 void cx231xx_release_resources(struct cx231xx
*dev
)
842 cx231xx_release_analog_resources(dev
);
844 cx231xx_remove_from_devlist(dev
);
846 /* Release I2C buses */
847 cx231xx_dev_uninit(dev
);
849 cx231xx_ir_exit(dev
);
851 usb_put_dev(dev
->udev
);
853 /* Mark device as unused */
854 cx231xx_devused
&= ~(1 << dev
->devno
);
859 * allocates and inits the device structs, registers i2c bus and v4l device
861 static int cx231xx_init_dev(struct cx231xx
**devhandle
, struct usb_device
*udev
,
864 struct cx231xx
*dev
= *devhandle
;
865 int retval
= -ENOMEM
;
867 unsigned int maxh
, maxw
;
870 mutex_init(&dev
->lock
);
871 mutex_init(&dev
->ctrl_urb_lock
);
872 mutex_init(&dev
->gpio_i2c_lock
);
873 mutex_init(&dev
->i2c_lock
);
875 spin_lock_init(&dev
->video_mode
.slock
);
876 spin_lock_init(&dev
->vbi_mode
.slock
);
877 spin_lock_init(&dev
->sliced_cc_mode
.slock
);
879 init_waitqueue_head(&dev
->open
);
880 init_waitqueue_head(&dev
->wait_frame
);
881 init_waitqueue_head(&dev
->wait_stream
);
883 dev
->cx231xx_read_ctrl_reg
= cx231xx_read_ctrl_reg
;
884 dev
->cx231xx_write_ctrl_reg
= cx231xx_write_ctrl_reg
;
885 dev
->cx231xx_send_usb_command
= cx231xx_send_usb_command
;
886 dev
->cx231xx_gpio_i2c_read
= cx231xx_gpio_i2c_read
;
887 dev
->cx231xx_gpio_i2c_write
= cx231xx_gpio_i2c_write
;
889 /* Query cx231xx to find what pcb config it is related to */
890 initialize_cx231xx(dev
);
892 /*To workaround error number=-71 on EP0 for VideoGrabber,
894 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
||
895 dev
->model
== CX231XX_BOARD_HAUPPAUGE_USBLIVE2
) {
896 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
897 cx231xx_set_alt_setting(dev
, INDEX_VANC
, 1);
899 /* Cx231xx pre card setup */
900 cx231xx_pre_card_setup(dev
);
902 errCode
= cx231xx_config(dev
);
904 cx231xx_errdev("error configuring device\n");
908 /* set default norm */
909 dev
->norm
= dev
->board
.norm
;
911 /* register i2c bus */
912 errCode
= cx231xx_dev_init(dev
);
914 cx231xx_dev_uninit(dev
);
915 cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
920 /* Do board specific init */
921 cx231xx_card_setup(dev
);
923 /* configure the device */
924 cx231xx_config_i2c(dev
);
926 maxw
= norm_maxw(dev
);
927 maxh
= norm_maxh(dev
);
929 /* set default image size */
933 dev
->video_input
= 0;
935 errCode
= cx231xx_config(dev
);
937 cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
942 /* init video dma queues */
943 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.active
);
944 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.queued
);
946 /* init vbi dma queues */
947 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.active
);
948 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.queued
);
950 /* Reset other chips required if they are tied up with GPIO pins */
951 cx231xx_add_into_devlist(dev
);
953 if (dev
->board
.has_417
) {
954 printk(KERN_INFO
"attach 417 %d\n", dev
->model
);
955 if (cx231xx_417_register(dev
) < 0) {
957 "%s() Failed to register 417 on VID_B\n",
962 retval
= cx231xx_register_analog_devices(dev
);
964 cx231xx_release_resources(dev
);
968 cx231xx_ir_init(dev
);
970 cx231xx_init_extension(dev
);
975 #if defined(CONFIG_MODULES) && defined(MODULE)
976 static void request_module_async(struct work_struct
*work
)
978 struct cx231xx
*dev
= container_of(work
,
979 struct cx231xx
, request_module_wk
);
981 if (dev
->has_alsa_audio
)
982 request_module("cx231xx-alsa");
984 if (dev
->board
.has_dvb
)
985 request_module("cx231xx-dvb");
989 static void request_modules(struct cx231xx
*dev
)
991 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
992 schedule_work(&dev
->request_module_wk
);
995 static void flush_request_modules(struct cx231xx
*dev
)
997 flush_work_sync(&dev
->request_module_wk
);
1000 #define request_modules(dev)
1001 #define flush_request_modules(dev)
1002 #endif /* CONFIG_MODULES */
1005 * cx231xx_usb_probe()
1006 * checks for supported devices
1008 static int cx231xx_usb_probe(struct usb_interface
*interface
,
1009 const struct usb_device_id
*id
)
1011 struct usb_device
*udev
;
1012 struct usb_interface
*uif
;
1013 struct cx231xx
*dev
= NULL
;
1014 int retval
= -ENODEV
;
1016 int i
, isoc_pipe
= 0;
1018 char descr
[255] = "";
1019 struct usb_interface
*lif
= NULL
;
1020 struct usb_interface_assoc_descriptor
*assoc_desc
;
1022 udev
= usb_get_dev(interface_to_usbdev(interface
));
1023 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
1026 * Interface number 0 - IR interface (handled by mceusb driver)
1027 * Interface number 1 - AV interface (handled by this driver)
1032 /* Check to see next free device and mark as used */
1033 nr
= find_first_zero_bit(&cx231xx_devused
, CX231XX_MAXBOARDS
);
1034 cx231xx_devused
|= 1 << nr
;
1036 if (nr
>= CX231XX_MAXBOARDS
) {
1037 cx231xx_err(DRIVER_NAME
1038 ": Supports only %i cx231xx boards.\n", CX231XX_MAXBOARDS
);
1039 cx231xx_devused
&= ~(1 << nr
);
1043 /* allocate memory for our device state and initialize it */
1044 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1046 cx231xx_err(DRIVER_NAME
": out of memory!\n");
1047 cx231xx_devused
&= ~(1 << nr
);
1051 snprintf(dev
->name
, 29, "cx231xx #%d", nr
);
1053 dev
->model
= id
->driver_info
;
1054 dev
->video_mode
.alt
= -1;
1056 dev
->interface_count
++;
1057 /* reset gpio dir and value */
1060 dev
->xc_fw_load_done
= 0;
1061 dev
->has_alsa_audio
= 1;
1062 dev
->power_mode
= -1;
1063 atomic_set(&dev
->devlist_count
, 0);
1065 /* 0 - vbi ; 1 -sliced cc mode */
1066 dev
->vbi_or_sliced_cc_mode
= 0;
1068 /* get maximum no.of IAD interfaces */
1069 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
1070 dev
->max_iad_interface_count
= assoc_desc
->bInterfaceCount
;
1072 /* init CIR module TBD */
1074 /* store the current interface */
1077 /*mode_tv: digital=1 or analog=0*/
1080 dev
->USE_ISO
= transfer_mode
;
1082 switch (udev
->speed
) {
1086 case USB_SPEED_UNKNOWN
:
1087 case USB_SPEED_FULL
:
1090 case USB_SPEED_HIGH
:
1097 if (udev
->manufacturer
)
1098 strlcpy(descr
, udev
->manufacturer
, sizeof(descr
));
1100 if (udev
->product
) {
1102 strlcat(descr
, " ", sizeof(descr
));
1103 strlcat(descr
, udev
->product
, sizeof(descr
));
1106 strlcat(descr
, " ", sizeof(descr
));
1108 cx231xx_info("New device %s@ %s Mbps "
1109 "(%04x:%04x) with %d interfaces\n",
1112 le16_to_cpu(udev
->descriptor
.idVendor
),
1113 le16_to_cpu(udev
->descriptor
.idProduct
),
1114 dev
->max_iad_interface_count
);
1116 /* store the interface 0 back */
1117 lif
= udev
->actconfig
->interface
[0];
1119 /* increment interface count */
1120 dev
->interface_count
++;
1122 /* get device number */
1125 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
1126 if (assoc_desc
->bFirstInterface
!= ifnum
) {
1127 cx231xx_err(DRIVER_NAME
": Not found "
1128 "matching IAD interface\n");
1129 cx231xx_devused
&= ~(1 << nr
);
1135 cx231xx_info("registering interface %d\n", ifnum
);
1137 /* save our data pointer in this interface device */
1138 usb_set_intfdata(lif
, dev
);
1141 * AV device initialization - only done at the last interface
1144 /* Create v4l2 device */
1145 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
1147 cx231xx_errdev("v4l2_device_register failed\n");
1148 cx231xx_devused
&= ~(1 << nr
);
1153 /* allocate device struct */
1154 retval
= cx231xx_init_dev(&dev
, udev
, nr
);
1156 cx231xx_devused
&= ~(1 << dev
->devno
);
1157 v4l2_device_unregister(&dev
->v4l2_dev
);
1160 usb_set_intfdata(lif
, NULL
);
1165 /* compute alternate max packet sizes for video */
1166 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
1167 hs_config_info
[0].interface_info
.video_index
+ 1];
1169 dev
->video_mode
.end_point_addr
= le16_to_cpu(uif
->altsetting
[0].
1170 endpoint
[isoc_pipe
].desc
.bEndpointAddress
);
1172 dev
->video_mode
.num_alt
= uif
->num_altsetting
;
1173 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1174 dev
->video_mode
.end_point_addr
,
1175 dev
->video_mode
.num_alt
);
1176 dev
->video_mode
.alt_max_pkt_size
=
1177 kmalloc(32 * dev
->video_mode
.num_alt
, GFP_KERNEL
);
1179 if (dev
->video_mode
.alt_max_pkt_size
== NULL
) {
1180 cx231xx_errdev("out of memory!\n");
1181 cx231xx_devused
&= ~(1 << nr
);
1182 v4l2_device_unregister(&dev
->v4l2_dev
);
1188 for (i
= 0; i
< dev
->video_mode
.num_alt
; i
++) {
1189 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1190 desc
.wMaxPacketSize
);
1191 dev
->video_mode
.alt_max_pkt_size
[i
] =
1192 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1193 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1194 dev
->video_mode
.alt_max_pkt_size
[i
]);
1197 /* compute alternate max packet sizes for vbi */
1198 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
1199 hs_config_info
[0].interface_info
.
1202 dev
->vbi_mode
.end_point_addr
=
1203 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1206 dev
->vbi_mode
.num_alt
= uif
->num_altsetting
;
1207 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1208 dev
->vbi_mode
.end_point_addr
,
1209 dev
->vbi_mode
.num_alt
);
1210 dev
->vbi_mode
.alt_max_pkt_size
=
1211 kmalloc(32 * dev
->vbi_mode
.num_alt
, GFP_KERNEL
);
1213 if (dev
->vbi_mode
.alt_max_pkt_size
== NULL
) {
1214 cx231xx_errdev("out of memory!\n");
1215 cx231xx_devused
&= ~(1 << nr
);
1216 v4l2_device_unregister(&dev
->v4l2_dev
);
1222 for (i
= 0; i
< dev
->vbi_mode
.num_alt
; i
++) {
1224 le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1225 desc
.wMaxPacketSize
);
1226 dev
->vbi_mode
.alt_max_pkt_size
[i
] =
1227 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1228 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1229 dev
->vbi_mode
.alt_max_pkt_size
[i
]);
1232 /* compute alternate max packet sizes for sliced CC */
1233 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
1234 hs_config_info
[0].interface_info
.
1237 dev
->sliced_cc_mode
.end_point_addr
=
1238 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1241 dev
->sliced_cc_mode
.num_alt
= uif
->num_altsetting
;
1242 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1243 dev
->sliced_cc_mode
.end_point_addr
,
1244 dev
->sliced_cc_mode
.num_alt
);
1245 dev
->sliced_cc_mode
.alt_max_pkt_size
=
1246 kmalloc(32 * dev
->sliced_cc_mode
.num_alt
, GFP_KERNEL
);
1248 if (dev
->sliced_cc_mode
.alt_max_pkt_size
== NULL
) {
1249 cx231xx_errdev("out of memory!\n");
1250 cx231xx_devused
&= ~(1 << nr
);
1251 v4l2_device_unregister(&dev
->v4l2_dev
);
1257 for (i
= 0; i
< dev
->sliced_cc_mode
.num_alt
; i
++) {
1258 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1259 desc
.wMaxPacketSize
);
1260 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
] =
1261 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1262 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1263 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
]);
1266 if (dev
->current_pcb_config
.ts1_source
!= 0xff) {
1267 /* compute alternate max packet sizes for TS1 */
1268 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
1273 dev
->ts1_mode
.end_point_addr
=
1274 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].
1275 desc
.bEndpointAddress
);
1277 dev
->ts1_mode
.num_alt
= uif
->num_altsetting
;
1278 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1279 dev
->ts1_mode
.end_point_addr
,
1280 dev
->ts1_mode
.num_alt
);
1281 dev
->ts1_mode
.alt_max_pkt_size
=
1282 kmalloc(32 * dev
->ts1_mode
.num_alt
, GFP_KERNEL
);
1284 if (dev
->ts1_mode
.alt_max_pkt_size
== NULL
) {
1285 cx231xx_errdev("out of memory!\n");
1286 cx231xx_devused
&= ~(1 << nr
);
1287 v4l2_device_unregister(&dev
->v4l2_dev
);
1293 for (i
= 0; i
< dev
->ts1_mode
.num_alt
; i
++) {
1294 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].
1295 endpoint
[isoc_pipe
].desc
.
1297 dev
->ts1_mode
.alt_max_pkt_size
[i
] =
1298 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1299 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1300 dev
->ts1_mode
.alt_max_pkt_size
[i
]);
1304 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
1305 cx231xx_enable_OSC(dev
);
1306 cx231xx_reset_out(dev
);
1307 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
1310 if (dev
->model
== CX231XX_BOARD_CNXT_RDE_253S
)
1311 cx231xx_sleep_s5h1432(dev
);
1313 /* load other modules required */
1314 request_modules(dev
);
1320 * cx231xx_usb_disconnect()
1321 * called when the device gets diconencted
1322 * video device will be unregistered on v4l2_close in case it is still open
1324 static void cx231xx_usb_disconnect(struct usb_interface
*interface
)
1326 struct cx231xx
*dev
;
1328 dev
= usb_get_intfdata(interface
);
1329 usb_set_intfdata(interface
, NULL
);
1337 flush_request_modules(dev
);
1339 /* delete v4l2 device */
1340 v4l2_device_unregister(&dev
->v4l2_dev
);
1342 /* wait until all current v4l2 io is finished then deallocate
1344 mutex_lock(&dev
->lock
);
1346 wake_up_interruptible_all(&dev
->open
);
1350 ("device %s is open! Deregistration and memory "
1351 "deallocation are deferred on close.\n",
1352 video_device_node_name(dev
->vdev
));
1354 dev
->state
|= DEV_MISCONFIGURED
;
1356 cx231xx_uninit_isoc(dev
);
1358 cx231xx_uninit_bulk(dev
);
1359 dev
->state
|= DEV_DISCONNECTED
;
1360 wake_up_interruptible(&dev
->wait_frame
);
1361 wake_up_interruptible(&dev
->wait_stream
);
1363 dev
->state
|= DEV_DISCONNECTED
;
1364 cx231xx_release_resources(dev
);
1367 cx231xx_close_extension(dev
);
1369 mutex_unlock(&dev
->lock
);
1372 kfree(dev
->video_mode
.alt_max_pkt_size
);
1373 kfree(dev
->vbi_mode
.alt_max_pkt_size
);
1374 kfree(dev
->sliced_cc_mode
.alt_max_pkt_size
);
1375 kfree(dev
->ts1_mode
.alt_max_pkt_size
);
1381 static struct usb_driver cx231xx_usb_driver
= {
1383 .probe
= cx231xx_usb_probe
,
1384 .disconnect
= cx231xx_usb_disconnect
,
1385 .id_table
= cx231xx_id_table
,
1388 static int __init
cx231xx_module_init(void)
1392 printk(KERN_INFO DRIVER_NAME
" v4l2 driver loaded.\n");
1394 /* register this driver with the USB subsystem */
1395 result
= usb_register(&cx231xx_usb_driver
);
1397 cx231xx_err(DRIVER_NAME
1398 " usb_register failed. Error number %d.\n", result
);
1403 static void __exit
cx231xx_module_exit(void)
1405 /* deregister this driver with the USB subsystem */
1406 usb_deregister(&cx231xx_usb_driver
);
1409 module_init(cx231xx_module_init
);
1410 module_exit(cx231xx_module_exit
);