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"
40 static int tuner
= -1;
41 module_param(tuner
, int, 0444);
42 MODULE_PARM_DESC(tuner
, "tuner type");
44 static int transfer_mode
= 1;
45 module_param(transfer_mode
, int, 0444);
46 MODULE_PARM_DESC(transfer_mode
, "transfer mode (1-ISO or 0-BULK)");
48 static unsigned int disable_ir
;
49 module_param(disable_ir
, int, 0444);
50 MODULE_PARM_DESC(disable_ir
, "disable infrared remote support");
52 /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
53 static unsigned long cx231xx_devused
;
56 * Reset sequences for analog/digital modes
59 static struct cx231xx_reg_seq RDE250_XCV_TUNER
[] = {
69 struct cx231xx_board cx231xx_boards
[] = {
70 [CX231XX_BOARD_UNKNOWN
] = {
71 .name
= "Unknown CX231xx video grabber",
72 .tuner_type
= TUNER_ABSENT
,
74 .type
= CX231XX_VMUX_TELEVISION
,
75 .vmux
= CX231XX_VIN_3_1
,
76 .amux
= CX231XX_AMUX_VIDEO
,
79 .type
= CX231XX_VMUX_COMPOSITE1
,
80 .vmux
= CX231XX_VIN_2_1
,
81 .amux
= CX231XX_AMUX_LINE_IN
,
84 .type
= CX231XX_VMUX_SVIDEO
,
85 .vmux
= CX231XX_VIN_1_1
|
86 (CX231XX_VIN_1_2
<< 8) |
88 .amux
= CX231XX_AMUX_LINE_IN
,
93 [CX231XX_BOARD_CNXT_CARRAERA
] = {
94 .name
= "Conexant Hybrid TV - CARRAERA",
95 .tuner_type
= TUNER_XC5000
,
97 .tuner_gpio
= RDE250_XCV_TUNER
,
98 .tuner_sif_gpio
= 0x05,
99 .tuner_scl_gpio
= 0x1a,
100 .tuner_sda_gpio
= 0x1b,
101 .decoder
= CX231XX_AVDECODER
,
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
= 1,
107 .demod_i2c_master
= 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 .demod_xfer_mode
= 0,
142 .ctl_pin_status_mask
= 0xFFFFFFC4,
143 .agc_analog_digital_select_gpio
= 0x0c,
144 .gpio_pin_status_mask
= 0x4001000,
145 .tuner_i2c_master
= 1,
146 .demod_i2c_master
= 2,
149 .norm
= V4L2_STD_NTSC
,
152 .type
= CX231XX_VMUX_TELEVISION
,
153 .vmux
= CX231XX_VIN_3_1
,
154 .amux
= CX231XX_AMUX_VIDEO
,
157 .type
= CX231XX_VMUX_COMPOSITE1
,
158 .vmux
= CX231XX_VIN_2_1
,
159 .amux
= CX231XX_AMUX_LINE_IN
,
162 .type
= CX231XX_VMUX_SVIDEO
,
163 .vmux
= CX231XX_VIN_1_1
|
164 (CX231XX_VIN_1_2
<< 8) |
166 .amux
= CX231XX_AMUX_LINE_IN
,
171 [CX231XX_BOARD_CNXT_RDE_253S
] = {
172 .name
= "Conexant Hybrid TV - RDE253S",
173 .tuner_type
= TUNER_NXP_TDA18271
,
175 .tuner_gpio
= RDE250_XCV_TUNER
,
176 .tuner_sif_gpio
= 0x05,
177 .tuner_scl_gpio
= 0x1a,
178 .tuner_sda_gpio
= 0x1b,
179 .decoder
= CX231XX_AVDECODER
,
180 .demod_xfer_mode
= 0,
181 .ctl_pin_status_mask
= 0xFFFFFFC4,
182 .agc_analog_digital_select_gpio
= 0x1c,
183 .gpio_pin_status_mask
= 0x4001000,
184 .tuner_i2c_master
= 1,
185 .demod_i2c_master
= 2,
188 .norm
= V4L2_STD_PAL
,
191 .type
= CX231XX_VMUX_TELEVISION
,
192 .vmux
= CX231XX_VIN_3_1
,
193 .amux
= CX231XX_AMUX_VIDEO
,
196 .type
= CX231XX_VMUX_COMPOSITE1
,
197 .vmux
= CX231XX_VIN_2_1
,
198 .amux
= CX231XX_AMUX_LINE_IN
,
201 .type
= CX231XX_VMUX_SVIDEO
,
202 .vmux
= CX231XX_VIN_1_1
|
203 (CX231XX_VIN_1_2
<< 8) |
205 .amux
= CX231XX_AMUX_LINE_IN
,
211 [CX231XX_BOARD_CNXT_RDU_253S
] = {
212 .name
= "Conexant Hybrid TV - RDU253S",
213 .tuner_type
= TUNER_NXP_TDA18271
,
215 .tuner_gpio
= RDE250_XCV_TUNER
,
216 .tuner_sif_gpio
= 0x05,
217 .tuner_scl_gpio
= 0x1a,
218 .tuner_sda_gpio
= 0x1b,
219 .decoder
= CX231XX_AVDECODER
,
220 .demod_xfer_mode
= 0,
221 .ctl_pin_status_mask
= 0xFFFFFFC4,
222 .agc_analog_digital_select_gpio
= 0x1c,
223 .gpio_pin_status_mask
= 0x4001000,
224 .tuner_i2c_master
= 1,
225 .demod_i2c_master
= 2,
228 .norm
= V4L2_STD_PAL
,
231 .type
= CX231XX_VMUX_TELEVISION
,
232 .vmux
= CX231XX_VIN_3_1
,
233 .amux
= CX231XX_AMUX_VIDEO
,
236 .type
= CX231XX_VMUX_COMPOSITE1
,
237 .vmux
= CX231XX_VIN_2_1
,
238 .amux
= CX231XX_AMUX_LINE_IN
,
241 .type
= CX231XX_VMUX_SVIDEO
,
242 .vmux
= CX231XX_VIN_1_1
|
243 (CX231XX_VIN_1_2
<< 8) |
245 .amux
= CX231XX_AMUX_LINE_IN
,
250 [CX231XX_BOARD_CNXT_VIDEO_GRABBER
] = {
251 .name
= "Conexant VIDEO GRABBER",
252 .tuner_type
= TUNER_NXP_TDA18271
,
254 .tuner_gpio
= RDE250_XCV_TUNER
,
255 .tuner_sif_gpio
= 0x05,
256 .tuner_scl_gpio
= 0x1a,
257 .tuner_sda_gpio
= 0x1b,
258 .decoder
= CX231XX_AVDECODER
,
259 .demod_xfer_mode
= 0,
260 .ctl_pin_status_mask
= 0xFFFFFFC4,
261 .agc_analog_digital_select_gpio
= 0x1c,
262 .gpio_pin_status_mask
= 0x4001000,
263 .tuner_i2c_master
= 1,
264 .demod_i2c_master
= 2,
267 .norm
= V4L2_STD_PAL
,
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
,
282 .type
= CX231XX_VMUX_TELEVISION
,
283 .vmux
= CX231XX_VIN_3_1
,
284 .amux
= CX231XX_AMUX_VIDEO
,
289 [CX231XX_BOARD_CNXT_RDE_250
] = {
290 .name
= "Conexant Hybrid TV - rde 250",
291 .tuner_type
= TUNER_XC5000
,
293 .tuner_gpio
= RDE250_XCV_TUNER
,
294 .tuner_sif_gpio
= 0x05,
295 .tuner_scl_gpio
= 0x1a,
296 .tuner_sda_gpio
= 0x1b,
297 .decoder
= CX231XX_AVDECODER
,
298 .demod_xfer_mode
= 0,
299 .ctl_pin_status_mask
= 0xFFFFFFC4,
300 .agc_analog_digital_select_gpio
= 0x0c,
301 .gpio_pin_status_mask
= 0x4001000,
302 .tuner_i2c_master
= 1,
303 .demod_i2c_master
= 2,
306 .norm
= V4L2_STD_PAL
,
309 .type
= CX231XX_VMUX_TELEVISION
,
310 .vmux
= CX231XX_VIN_2_1
,
311 .amux
= CX231XX_AMUX_VIDEO
,
316 [CX231XX_BOARD_CNXT_RDU_250
] = {
317 .name
= "Conexant Hybrid TV - RDU 250",
318 .tuner_type
= TUNER_XC5000
,
320 .tuner_gpio
= RDE250_XCV_TUNER
,
321 .tuner_sif_gpio
= 0x05,
322 .tuner_scl_gpio
= 0x1a,
323 .tuner_sda_gpio
= 0x1b,
324 .decoder
= CX231XX_AVDECODER
,
325 .demod_xfer_mode
= 0,
326 .ctl_pin_status_mask
= 0xFFFFFFC4,
327 .agc_analog_digital_select_gpio
= 0x0c,
328 .gpio_pin_status_mask
= 0x4001000,
329 .tuner_i2c_master
= 1,
330 .demod_i2c_master
= 2,
333 .norm
= V4L2_STD_NTSC
,
336 .type
= CX231XX_VMUX_TELEVISION
,
337 .vmux
= CX231XX_VIN_2_1
,
338 .amux
= CX231XX_AMUX_VIDEO
,
349 const unsigned int cx231xx_bcount
= ARRAY_SIZE(cx231xx_boards
);
351 /* table of devices that work with this driver */
352 struct usb_device_id cx231xx_id_table
[] = {
353 {USB_DEVICE(0x0572, 0x5A3C),
354 .driver_info
= CX231XX_BOARD_UNKNOWN
},
355 {USB_DEVICE(0x0572, 0x58A2),
356 .driver_info
= CX231XX_BOARD_CNXT_CARRAERA
},
357 {USB_DEVICE(0x0572, 0x58A1),
358 .driver_info
= CX231XX_BOARD_CNXT_SHELBY
},
359 {USB_DEVICE(0x0572, 0x58A4),
360 .driver_info
= CX231XX_BOARD_CNXT_RDE_253S
},
361 {USB_DEVICE(0x0572, 0x58A5),
362 .driver_info
= CX231XX_BOARD_CNXT_RDU_253S
},
363 {USB_DEVICE(0x0572, 0x58A6),
364 .driver_info
= CX231XX_BOARD_CNXT_VIDEO_GRABBER
},
365 {USB_DEVICE(0x0572, 0x589E),
366 .driver_info
= CX231XX_BOARD_CNXT_RDE_250
},
367 {USB_DEVICE(0x0572, 0x58A0),
368 .driver_info
= CX231XX_BOARD_CNXT_RDU_250
},
369 {USB_DEVICE_VER(USB_VID_PIXELVIEW
, USB_PID_PIXELVIEW_SBTVD
, 0x4000,0x4fff),
370 .driver_info
= CX231XX_BOARD_UNKNOWN
},
374 MODULE_DEVICE_TABLE(usb
, cx231xx_id_table
);
376 /* cx231xx_tuner_callback
377 * will be used to reset XC5000 tuner using GPIO pin
380 int cx231xx_tuner_callback(void *ptr
, int component
, int command
, int arg
)
383 struct cx231xx
*dev
= ptr
;
385 if (dev
->tuner_type
== TUNER_XC5000
) {
386 if (command
== XC5000_TUNER_RESET
) {
388 ("Tuner CB: RESET: cmd %d : tuner type %d \n",
389 command
, dev
->tuner_type
);
390 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
393 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
396 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
403 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback
);
405 void cx231xx_reset_out(struct cx231xx
*dev
)
407 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
409 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 0);
411 cx231xx_set_gpio_value(dev
, CX23417_RESET
, 1);
413 void cx231xx_enable_OSC(struct cx231xx
*dev
)
415 cx231xx_set_gpio_value(dev
, CX23417_OSC_EN
, 1);
417 void cx231xx_sleep_s5h1432(struct cx231xx
*dev
)
419 cx231xx_set_gpio_value(dev
, SLEEP_S5H1432
, 0);
422 static inline void cx231xx_set_model(struct cx231xx
*dev
)
424 memcpy(&dev
->board
, &cx231xx_boards
[dev
->model
], sizeof(dev
->board
));
427 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
428 * this won't work for boards with generic PCI IDs
430 void cx231xx_pre_card_setup(struct cx231xx
*dev
)
433 cx231xx_set_model(dev
);
435 cx231xx_info("Identified as %s (card=%d)\n",
436 dev
->board
.name
, dev
->model
);
438 /* set the direction for GPIO pins */
439 if (dev
->board
.tuner_gpio
) {
440 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_gpio
->bit
, 1);
441 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
, 1);
442 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_sif_gpio
, 1);
444 /* request some modules if any required */
447 /* set the mode to Analog mode initially */
448 cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
451 /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
455 static void cx231xx_config_tuner(struct cx231xx
*dev
)
457 struct tuner_setup tun_setup
;
458 struct v4l2_frequency f
;
460 if (dev
->tuner_type
== TUNER_ABSENT
)
463 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
464 tun_setup
.type
= dev
->tuner_type
;
465 tun_setup
.addr
= dev
->tuner_addr
;
466 tun_setup
.tuner_callback
= cx231xx_tuner_callback
;
468 tuner_call(dev
, tuner
, s_type_addr
, &tun_setup
);
471 if (tun_setup
.type
== TUNER_XC5000
) {
472 static struct xc2028_ctrl ctrl
= {
473 .fname
= XC5000_DEFAULT_FIRMWARE
,
477 struct v4l2_priv_tun_config cfg
= {
478 .tuner
= dev
->tuner_type
,
481 tuner_call(dev
, tuner
, s_config
, &cfg
);
484 /* configure tuner */
486 f
.type
= V4L2_TUNER_ANALOG_TV
;
487 f
.frequency
= 9076; /* just a magic number */
488 dev
->ctl_freq
= f
.frequency
;
489 call_all(dev
, tuner
, s_frequency
, &f
);
493 /* ----------------------------------------------------------------------- */
494 void cx231xx_register_i2c_ir(struct cx231xx
*dev
)
499 /* REVISIT: instantiate IR device */
501 /* detect & configure */
502 switch (dev
->model
) {
504 case CX231XX_BOARD_CNXT_CARRAERA
:
506 case CX231XX_BOARD_CNXT_RDE_250
:
508 case CX231XX_BOARD_CNXT_SHELBY
:
510 case CX231XX_BOARD_CNXT_RDU_250
:
512 case CX231XX_BOARD_CNXT_RDE_253S
:
514 case CX231XX_BOARD_CNXT_RDU_253S
:
516 case CX231XX_BOARD_CNXT_VIDEO_GRABBER
:
523 void cx231xx_card_setup(struct cx231xx
*dev
)
526 cx231xx_set_model(dev
);
528 dev
->tuner_type
= cx231xx_boards
[dev
->model
].tuner_type
;
529 if (cx231xx_boards
[dev
->model
].tuner_addr
)
530 dev
->tuner_addr
= cx231xx_boards
[dev
->model
].tuner_addr
;
532 /* request some modules */
533 if (dev
->board
.decoder
== CX231XX_AVDECODER
) {
534 dev
->sd_cx25840
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
535 &dev
->i2c_bus
[0].i2c_adap
,
536 "cx25840", "cx25840", 0x88 >> 1, NULL
);
537 if (dev
->sd_cx25840
== NULL
)
538 cx231xx_info("cx25840 subdev registration failure\n");
539 cx25840_call(dev
, core
, load_fw
);
543 switch (dev
->model
) {
544 case CX231XX_BOARD_CNXT_CARRAERA
:
545 case CX231XX_BOARD_CNXT_RDE_250
:
546 case CX231XX_BOARD_CNXT_SHELBY
:
547 case CX231XX_BOARD_CNXT_RDU_250
:
548 if (dev
->board
.tuner_type
!= TUNER_ABSENT
) {
549 dev
->sd_tuner
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
550 &dev
->i2c_bus
[1].i2c_adap
,
551 "tuner", "tuner", 0xc2 >> 1, NULL
);
552 if (dev
->sd_tuner
== NULL
)
554 "tuner subdev registration failure\n");
556 cx231xx_config_tuner(dev
);
559 case CX231XX_BOARD_CNXT_RDE_253S
:
560 case CX231XX_BOARD_CNXT_RDU_253S
:
561 case CX231XX_BOARD_CNXT_VIDEO_GRABBER
:
562 if (dev
->board
.tuner_type
!= TUNER_ABSENT
) {
563 dev
->sd_tuner
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
564 &dev
->i2c_bus
[1].i2c_adap
,
565 "tuner", "tuner", 0xc0 >> 1, NULL
);
566 if (dev
->sd_tuner
== NULL
)
568 "tuner subdev registration failure\n");
570 cx231xx_config_tuner(dev
);
577 cx231xx_config_tuner(dev
);
580 /* TBD IR will be added later */
581 cx231xx_ir_init(dev
);
587 * inits registers with sane defaults
589 int cx231xx_config(struct cx231xx
*dev
)
591 /* TBD need to add cx231xx specific code */
592 dev
->mute
= 1; /* maybe not the right place... */
599 * cx231xx_config_i2c()
600 * configure i2c attached devices
602 void cx231xx_config_i2c(struct cx231xx
*dev
)
604 /* u32 input = INPUT(dev->video_input)->vmux; */
606 call_all(dev
, video
, s_stream
, 1);
610 * cx231xx_realease_resources()
611 * unregisters the v4l2,i2c and usb devices
612 * called when the device gets disconected or at module unload
614 void cx231xx_release_resources(struct cx231xx
*dev
)
617 #if 0 /* TBD IR related */
619 cx231xx_ir_fini(dev
);
622 cx231xx_release_analog_resources(dev
);
624 cx231xx_remove_from_devlist(dev
);
626 cx231xx_dev_uninit(dev
);
628 usb_put_dev(dev
->udev
);
630 /* Mark device as unused */
631 cx231xx_devused
&= ~(1 << dev
->devno
);
636 * allocates and inits the device structs, registers i2c bus and v4l device
638 static int cx231xx_init_dev(struct cx231xx
**devhandle
, struct usb_device
*udev
,
641 struct cx231xx
*dev
= *devhandle
;
642 int retval
= -ENOMEM
;
644 unsigned int maxh
, maxw
;
647 mutex_init(&dev
->lock
);
648 mutex_init(&dev
->ctrl_urb_lock
);
649 mutex_init(&dev
->gpio_i2c_lock
);
650 mutex_init(&dev
->i2c_lock
);
652 spin_lock_init(&dev
->video_mode
.slock
);
653 spin_lock_init(&dev
->vbi_mode
.slock
);
654 spin_lock_init(&dev
->sliced_cc_mode
.slock
);
656 init_waitqueue_head(&dev
->open
);
657 init_waitqueue_head(&dev
->wait_frame
);
658 init_waitqueue_head(&dev
->wait_stream
);
660 dev
->cx231xx_read_ctrl_reg
= cx231xx_read_ctrl_reg
;
661 dev
->cx231xx_write_ctrl_reg
= cx231xx_write_ctrl_reg
;
662 dev
->cx231xx_send_usb_command
= cx231xx_send_usb_command
;
663 dev
->cx231xx_gpio_i2c_read
= cx231xx_gpio_i2c_read
;
664 dev
->cx231xx_gpio_i2c_write
= cx231xx_gpio_i2c_write
;
666 /* Query cx231xx to find what pcb config it is related to */
667 initialize_cx231xx(dev
);
669 /*To workaround error number=-71 on EP0 for VideoGrabber,
671 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
672 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
673 cx231xx_set_alt_setting(dev
, INDEX_VANC
, 1);
675 /* Cx231xx pre card setup */
676 cx231xx_pre_card_setup(dev
);
678 errCode
= cx231xx_config(dev
);
680 cx231xx_errdev("error configuring device\n");
684 /* set default norm */
685 dev
->norm
= dev
->board
.norm
;
687 /* register i2c bus */
688 errCode
= cx231xx_dev_init(dev
);
690 cx231xx_dev_uninit(dev
);
691 cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
696 /* Do board specific init */
697 cx231xx_card_setup(dev
);
699 /* configure the device */
700 cx231xx_config_i2c(dev
);
702 maxw
= norm_maxw(dev
);
703 maxh
= norm_maxh(dev
);
705 /* set default image size */
711 dev
->video_input
= 0;
713 errCode
= cx231xx_config(dev
);
715 cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
720 /* init video dma queues */
721 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.active
);
722 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.queued
);
724 /* init vbi dma queues */
725 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.active
);
726 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.queued
);
728 /* Reset other chips required if they are tied up with GPIO pins */
729 cx231xx_add_into_devlist(dev
);
731 printk(KERN_INFO
"attach 417 %d\n", dev
->model
);
732 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
733 if (cx231xx_417_register(dev
) < 0) {
735 "%s() Failed to register 417 on VID_B\n",
740 retval
= cx231xx_register_analog_devices(dev
);
742 cx231xx_release_resources(dev
);
743 goto fail_reg_devices
;
746 cx231xx_init_extension(dev
);
751 mutex_unlock(&dev
->lock
);
755 #if defined(CONFIG_MODULES) && defined(MODULE)
756 static void request_module_async(struct work_struct
*work
)
758 struct cx231xx
*dev
= container_of(work
,
759 struct cx231xx
, request_module_wk
);
761 if (dev
->has_alsa_audio
)
762 request_module("cx231xx-alsa");
764 if (dev
->board
.has_dvb
)
765 request_module("cx231xx-dvb");
769 static void request_modules(struct cx231xx
*dev
)
771 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
772 schedule_work(&dev
->request_module_wk
);
775 #define request_modules(dev)
776 #endif /* CONFIG_MODULES */
779 * cx231xx_usb_probe()
780 * checks for supported devices
782 static int cx231xx_usb_probe(struct usb_interface
*interface
,
783 const struct usb_device_id
*id
)
785 struct usb_device
*udev
;
786 struct usb_interface
*uif
;
787 struct cx231xx
*dev
= NULL
;
788 int retval
= -ENODEV
;
790 int i
, isoc_pipe
= 0;
792 char descr
[255] = "";
793 struct usb_interface
*lif
= NULL
;
794 int skip_interface
= 0;
795 struct usb_interface_assoc_descriptor
*assoc_desc
;
797 udev
= usb_get_dev(interface_to_usbdev(interface
));
798 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
802 * Interface number 0 - IR interface
804 /* Check to see next free device and mark as used */
805 nr
= find_first_zero_bit(&cx231xx_devused
, CX231XX_MAXBOARDS
);
806 cx231xx_devused
|= 1 << nr
;
808 if (nr
>= CX231XX_MAXBOARDS
) {
809 cx231xx_err(DRIVER_NAME
810 ": Supports only %i cx231xx boards.\n", CX231XX_MAXBOARDS
);
811 cx231xx_devused
&= ~(1 << nr
);
815 /* allocate memory for our device state and initialize it */
816 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
818 cx231xx_err(DRIVER_NAME
": out of memory!\n");
819 cx231xx_devused
&= ~(1 << nr
);
823 snprintf(dev
->name
, 29, "cx231xx #%d", nr
);
825 dev
->model
= id
->driver_info
;
826 dev
->video_mode
.alt
= -1;
827 dev
->interface_count
++;
829 /* reset gpio dir and value */
832 dev
->xc_fw_load_done
= 0;
833 dev
->has_alsa_audio
= 1;
834 dev
->power_mode
= -1;
835 atomic_set(&dev
->devlist_count
, 0);
837 /* 0 - vbi ; 1 -sliced cc mode */
838 dev
->vbi_or_sliced_cc_mode
= 0;
840 /* get maximum no.of IAD interfaces */
841 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
842 dev
->max_iad_interface_count
= assoc_desc
->bInterfaceCount
;
844 /* init CIR module TBD */
846 /* store the current interface */
849 /*mode_tv: digital=1 or analog=0*/
852 dev
->USE_ISO
= transfer_mode
;
854 switch (udev
->speed
) {
858 case USB_SPEED_UNKNOWN
:
869 if (udev
->manufacturer
)
870 strlcpy(descr
, udev
->manufacturer
, sizeof(descr
));
874 strlcat(descr
, " ", sizeof(descr
));
875 strlcat(descr
, udev
->product
, sizeof(descr
));
878 strlcat(descr
, " ", sizeof(descr
));
880 cx231xx_info("New device %s@ %s Mbps "
881 "(%04x:%04x) with %d interfaces\n",
884 le16_to_cpu(udev
->descriptor
.idVendor
),
885 le16_to_cpu(udev
->descriptor
.idProduct
),
886 dev
->max_iad_interface_count
);
888 /* Get dev structure first */
889 dev
= usb_get_intfdata(udev
->actconfig
->interface
[0]);
891 cx231xx_err(DRIVER_NAME
": out of first interface!\n");
895 /* store the interface 0 back */
896 lif
= udev
->actconfig
->interface
[0];
898 /* increment interface count */
899 dev
->interface_count
++;
901 /* get device number */
905 * set skip interface, for all interfaces but
906 * interface 1 and the last one
908 if ((ifnum
!= 1) && ((ifnum
)
909 != dev
->max_iad_interface_count
))
913 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
914 if (assoc_desc
->bFirstInterface
!= ifnum
) {
915 cx231xx_err(DRIVER_NAME
": Not found "
916 "matching IAD interface\n");
925 cx231xx_info("registering interface %d\n", ifnum
);
927 /* save our data pointer in this interface device */
928 usb_set_intfdata(lif
, dev
);
930 if ((ifnum
) != dev
->max_iad_interface_count
)
934 * AV device initialization - only done at the last interface
937 /* Create v4l2 device */
938 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
940 cx231xx_errdev("v4l2_device_register failed\n");
941 cx231xx_devused
&= ~(1 << nr
);
946 /* allocate device struct */
947 retval
= cx231xx_init_dev(&dev
, udev
, nr
);
949 cx231xx_devused
&= ~(1 << dev
->devno
);
950 v4l2_device_unregister(&dev
->v4l2_dev
);
953 usb_set_intfdata(lif
, NULL
);
958 /* compute alternate max packet sizes for video */
959 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
960 hs_config_info
[0].interface_info
.video_index
+ 1];
962 dev
->video_mode
.end_point_addr
= le16_to_cpu(uif
->altsetting
[0].
963 endpoint
[isoc_pipe
].desc
.bEndpointAddress
);
965 dev
->video_mode
.num_alt
= uif
->num_altsetting
;
966 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
967 dev
->video_mode
.end_point_addr
,
968 dev
->video_mode
.num_alt
);
969 dev
->video_mode
.alt_max_pkt_size
=
970 kmalloc(32 * dev
->video_mode
.num_alt
, GFP_KERNEL
);
972 if (dev
->video_mode
.alt_max_pkt_size
== NULL
) {
973 cx231xx_errdev("out of memory!\n");
974 cx231xx_devused
&= ~(1 << nr
);
975 v4l2_device_unregister(&dev
->v4l2_dev
);
981 for (i
= 0; i
< dev
->video_mode
.num_alt
; i
++) {
982 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
983 desc
.wMaxPacketSize
);
984 dev
->video_mode
.alt_max_pkt_size
[i
] =
985 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
986 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
987 dev
->video_mode
.alt_max_pkt_size
[i
]);
990 /* compute alternate max packet sizes for vbi */
991 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
992 hs_config_info
[0].interface_info
.
995 dev
->vbi_mode
.end_point_addr
=
996 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
999 dev
->vbi_mode
.num_alt
= uif
->num_altsetting
;
1000 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1001 dev
->vbi_mode
.end_point_addr
,
1002 dev
->vbi_mode
.num_alt
);
1003 dev
->vbi_mode
.alt_max_pkt_size
=
1004 kmalloc(32 * dev
->vbi_mode
.num_alt
, GFP_KERNEL
);
1006 if (dev
->vbi_mode
.alt_max_pkt_size
== NULL
) {
1007 cx231xx_errdev("out of memory!\n");
1008 cx231xx_devused
&= ~(1 << nr
);
1009 v4l2_device_unregister(&dev
->v4l2_dev
);
1015 for (i
= 0; i
< dev
->vbi_mode
.num_alt
; i
++) {
1017 le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1018 desc
.wMaxPacketSize
);
1019 dev
->vbi_mode
.alt_max_pkt_size
[i
] =
1020 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1021 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1022 dev
->vbi_mode
.alt_max_pkt_size
[i
]);
1025 /* compute alternate max packet sizes for sliced CC */
1026 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
1027 hs_config_info
[0].interface_info
.
1030 dev
->sliced_cc_mode
.end_point_addr
=
1031 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
1034 dev
->sliced_cc_mode
.num_alt
= uif
->num_altsetting
;
1035 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1036 dev
->sliced_cc_mode
.end_point_addr
,
1037 dev
->sliced_cc_mode
.num_alt
);
1038 dev
->sliced_cc_mode
.alt_max_pkt_size
=
1039 kmalloc(32 * dev
->sliced_cc_mode
.num_alt
, GFP_KERNEL
);
1041 if (dev
->sliced_cc_mode
.alt_max_pkt_size
== NULL
) {
1042 cx231xx_errdev("out of memory!\n");
1043 cx231xx_devused
&= ~(1 << nr
);
1044 v4l2_device_unregister(&dev
->v4l2_dev
);
1050 for (i
= 0; i
< dev
->sliced_cc_mode
.num_alt
; i
++) {
1051 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
1052 desc
.wMaxPacketSize
);
1053 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
] =
1054 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1055 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1056 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
]);
1059 if (dev
->current_pcb_config
.ts1_source
!= 0xff) {
1060 /* compute alternate max packet sizes for TS1 */
1061 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
1066 dev
->ts1_mode
.end_point_addr
=
1067 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].
1068 desc
.bEndpointAddress
);
1070 dev
->ts1_mode
.num_alt
= uif
->num_altsetting
;
1071 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1072 dev
->ts1_mode
.end_point_addr
,
1073 dev
->ts1_mode
.num_alt
);
1074 dev
->ts1_mode
.alt_max_pkt_size
=
1075 kmalloc(32 * dev
->ts1_mode
.num_alt
, GFP_KERNEL
);
1077 if (dev
->ts1_mode
.alt_max_pkt_size
== NULL
) {
1078 cx231xx_errdev("out of memory!\n");
1079 cx231xx_devused
&= ~(1 << nr
);
1080 v4l2_device_unregister(&dev
->v4l2_dev
);
1086 for (i
= 0; i
< dev
->ts1_mode
.num_alt
; i
++) {
1087 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].
1088 endpoint
[isoc_pipe
].desc
.
1090 dev
->ts1_mode
.alt_max_pkt_size
[i
] =
1091 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1092 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
1093 dev
->ts1_mode
.alt_max_pkt_size
[i
]);
1097 if (dev
->model
== CX231XX_BOARD_CNXT_VIDEO_GRABBER
) {
1098 cx231xx_enable_OSC(dev
);
1099 cx231xx_reset_out(dev
);
1100 cx231xx_set_alt_setting(dev
, INDEX_VIDEO
, 3);
1103 if (dev
->model
== CX231XX_BOARD_CNXT_RDE_253S
)
1104 cx231xx_sleep_s5h1432(dev
);
1106 /* load other modules required */
1107 request_modules(dev
);
1113 * cx231xx_usb_disconnect()
1114 * called when the device gets diconencted
1115 * video device will be unregistered on v4l2_close in case it is still open
1117 static void cx231xx_usb_disconnect(struct usb_interface
*interface
)
1119 struct cx231xx
*dev
;
1121 dev
= usb_get_intfdata(interface
);
1122 usb_set_intfdata(interface
, NULL
);
1130 /* delete v4l2 device */
1131 v4l2_device_unregister(&dev
->v4l2_dev
);
1133 /* wait until all current v4l2 io is finished then deallocate
1135 mutex_lock(&dev
->lock
);
1137 wake_up_interruptible_all(&dev
->open
);
1141 ("device %s is open! Deregistration and memory "
1142 "deallocation are deferred on close.\n",
1143 video_device_node_name(dev
->vdev
));
1145 dev
->state
|= DEV_MISCONFIGURED
;
1147 cx231xx_uninit_isoc(dev
);
1149 cx231xx_uninit_bulk(dev
);
1150 dev
->state
|= DEV_DISCONNECTED
;
1151 wake_up_interruptible(&dev
->wait_frame
);
1152 wake_up_interruptible(&dev
->wait_stream
);
1154 dev
->state
|= DEV_DISCONNECTED
;
1155 cx231xx_release_resources(dev
);
1158 cx231xx_close_extension(dev
);
1160 mutex_unlock(&dev
->lock
);
1163 kfree(dev
->video_mode
.alt_max_pkt_size
);
1164 kfree(dev
->vbi_mode
.alt_max_pkt_size
);
1165 kfree(dev
->sliced_cc_mode
.alt_max_pkt_size
);
1166 kfree(dev
->ts1_mode
.alt_max_pkt_size
);
1172 static struct usb_driver cx231xx_usb_driver
= {
1174 .probe
= cx231xx_usb_probe
,
1175 .disconnect
= cx231xx_usb_disconnect
,
1176 .id_table
= cx231xx_id_table
,
1179 static int __init
cx231xx_module_init(void)
1183 printk(KERN_INFO DRIVER_NAME
" v4l2 driver loaded.\n");
1185 /* register this driver with the USB subsystem */
1186 result
= usb_register(&cx231xx_usb_driver
);
1188 cx231xx_err(DRIVER_NAME
1189 " usb_register failed. Error number %d.\n", result
);
1194 static void __exit
cx231xx_module_exit(void)
1196 /* deregister this driver with the USB subsystem */
1197 usb_deregister(&cx231xx_usb_driver
);
1200 module_init(cx231xx_module_init
);
1201 module_exit(cx231xx_module_exit
);