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/delay.h>
26 #include <linux/i2c.h>
27 #include <linux/usb.h>
28 #include <media/tuner.h>
29 #include <media/tveeprom.h>
30 #include <media/v4l2-common.h>
31 #include <media/v4l2-chip-ident.h>
33 #include <media/cx25840.h>
38 static int tuner
= -1;
39 module_param(tuner
, int, 0444);
40 MODULE_PARM_DESC(tuner
, "tuner type");
42 static unsigned int disable_ir
;
43 module_param(disable_ir
, int, 0444);
44 MODULE_PARM_DESC(disable_ir
, "disable infrared remote support");
46 /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
47 static unsigned long cx231xx_devused
;
50 * Reset sequences for analog/digital modes
53 static struct cx231xx_reg_seq RDE250_XCV_TUNER
[] = {
63 struct cx231xx_board cx231xx_boards
[] = {
64 [CX231XX_BOARD_UNKNOWN
] = {
65 .name
= "Unknown CX231xx video grabber",
66 .tuner_type
= TUNER_ABSENT
,
68 .type
= CX231XX_VMUX_TELEVISION
,
69 .vmux
= CX231XX_VIN_3_1
,
70 .amux
= CX231XX_AMUX_VIDEO
,
73 .type
= CX231XX_VMUX_COMPOSITE1
,
74 .vmux
= CX231XX_VIN_2_1
,
75 .amux
= CX231XX_AMUX_LINE_IN
,
78 .type
= CX231XX_VMUX_SVIDEO
,
79 .vmux
= CX231XX_VIN_1_1
|
80 (CX231XX_VIN_1_2
<< 8) |
82 .amux
= CX231XX_AMUX_LINE_IN
,
87 [CX231XX_BOARD_CNXT_RDE_250
] = {
88 .name
= "Conexant Hybrid TV - RDE250",
89 .tuner_type
= TUNER_XC5000
,
91 .tuner_gpio
= RDE250_XCV_TUNER
,
92 .tuner_sif_gpio
= 0x05,
93 .tuner_scl_gpio
= 0x1a,
94 .tuner_sda_gpio
= 0x1b,
95 .decoder
= CX231XX_AVDECODER
,
97 .ctl_pin_status_mask
= 0xFFFFFFC4,
98 .agc_analog_digital_select_gpio
= 0x0c,
99 .gpio_pin_status_mask
= 0x4001000,
100 .tuner_i2c_master
= 1,
101 .demod_i2c_master
= 2,
104 .norm
= V4L2_STD_PAL
,
107 .type
= CX231XX_VMUX_TELEVISION
,
108 .vmux
= CX231XX_VIN_3_1
,
109 .amux
= CX231XX_AMUX_VIDEO
,
112 .type
= CX231XX_VMUX_COMPOSITE1
,
113 .vmux
= CX231XX_VIN_2_1
,
114 .amux
= CX231XX_AMUX_LINE_IN
,
117 .type
= CX231XX_VMUX_SVIDEO
,
118 .vmux
= CX231XX_VIN_1_1
|
119 (CX231XX_VIN_1_2
<< 8) |
121 .amux
= CX231XX_AMUX_LINE_IN
,
127 [CX231XX_BOARD_CNXT_RDU_250
] = {
128 .name
= "Conexant Hybrid TV - RDU250",
129 .tuner_type
= TUNER_XC5000
,
131 .tuner_gpio
= RDE250_XCV_TUNER
,
132 .tuner_sif_gpio
= 0x05,
133 .tuner_scl_gpio
= 0x1a,
134 .tuner_sda_gpio
= 0x1b,
135 .decoder
= CX231XX_AVDECODER
,
136 .demod_xfer_mode
= 0,
137 .ctl_pin_status_mask
= 0xFFFFFFC4,
138 .agc_analog_digital_select_gpio
= 0x0c,
139 .gpio_pin_status_mask
= 0x4001000,
140 .tuner_i2c_master
= 1,
141 .demod_i2c_master
= 2,
144 .norm
= V4L2_STD_NTSC
,
147 .type
= CX231XX_VMUX_TELEVISION
,
148 .vmux
= CX231XX_VIN_3_1
,
149 .amux
= CX231XX_AMUX_VIDEO
,
152 .type
= CX231XX_VMUX_COMPOSITE1
,
153 .vmux
= CX231XX_VIN_2_1
,
154 .amux
= CX231XX_AMUX_LINE_IN
,
157 .type
= CX231XX_VMUX_SVIDEO
,
158 .vmux
= CX231XX_VIN_1_1
|
159 (CX231XX_VIN_1_2
<< 8) |
161 .amux
= CX231XX_AMUX_LINE_IN
,
167 const unsigned int cx231xx_bcount
= ARRAY_SIZE(cx231xx_boards
);
169 /* table of devices that work with this driver */
170 struct usb_device_id cx231xx_id_table
[] = {
171 {USB_DEVICE(0x0572, 0x5A3C),
172 .driver_info
= CX231XX_BOARD_UNKNOWN
},
173 {USB_DEVICE(0x0572, 0x58A2),
174 .driver_info
= CX231XX_BOARD_CNXT_RDE_250
},
175 {USB_DEVICE(0x0572, 0x58A1),
176 .driver_info
= CX231XX_BOARD_CNXT_RDU_250
},
180 MODULE_DEVICE_TABLE(usb
, cx231xx_id_table
);
182 /* cx231xx_tuner_callback
183 * will be used to reset XC5000 tuner using GPIO pin
186 int cx231xx_tuner_callback(void *ptr
, int component
, int command
, int arg
)
189 struct cx231xx
*dev
= ptr
;
191 if (dev
->tuner_type
== TUNER_XC5000
) {
192 if (command
== XC5000_TUNER_RESET
) {
194 ("Tuner CB: RESET: cmd %d : tuner type %d \n",
195 command
, dev
->tuner_type
);
196 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
199 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
202 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
,
209 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback
);
211 static inline void cx231xx_set_model(struct cx231xx
*dev
)
213 memcpy(&dev
->board
, &cx231xx_boards
[dev
->model
], sizeof(dev
->board
));
216 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
217 * this won't work for boards with generic PCI IDs
219 void cx231xx_pre_card_setup(struct cx231xx
*dev
)
222 cx231xx_set_model(dev
);
224 cx231xx_info("Identified as %s (card=%d)\n",
225 dev
->board
.name
, dev
->model
);
227 /* set the direction for GPIO pins */
228 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_gpio
->bit
, 1);
229 cx231xx_set_gpio_value(dev
, dev
->board
.tuner_gpio
->bit
, 1);
230 cx231xx_set_gpio_direction(dev
, dev
->board
.tuner_sif_gpio
, 1);
232 /* request some modules if any required */
234 /* reset the Tuner */
235 cx231xx_gpio_set(dev
, dev
->board
.tuner_gpio
);
237 /* set the mode to Analog mode initially */
238 cx231xx_set_mode(dev
, CX231XX_ANALOG_MODE
);
241 /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
245 static void cx231xx_config_tuner(struct cx231xx
*dev
)
247 struct tuner_setup tun_setup
;
248 struct v4l2_frequency f
;
250 if (dev
->tuner_type
== TUNER_ABSENT
)
253 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
254 tun_setup
.type
= dev
->tuner_type
;
255 tun_setup
.addr
= dev
->tuner_addr
;
256 tun_setup
.tuner_callback
= cx231xx_tuner_callback
;
258 tuner_call(dev
, tuner
, s_type_addr
, &tun_setup
);
261 if (tun_setup
.type
== TUNER_XC5000
) {
262 static struct xc2028_ctrl ctrl
= {
263 .fname
= XC5000_DEFAULT_FIRMWARE
,
267 struct v4l2_priv_tun_config cfg
= {
268 .tuner
= dev
->tuner_type
,
271 tuner_call(dev
, tuner
, s_config
, &cfg
);
274 /* configure tuner */
276 f
.type
= V4L2_TUNER_ANALOG_TV
;
277 f
.frequency
= 9076; /* just a magic number */
278 dev
->ctl_freq
= f
.frequency
;
279 call_all(dev
, tuner
, s_frequency
, &f
);
283 /* ----------------------------------------------------------------------- */
284 void cx231xx_register_i2c_ir(struct cx231xx
*dev
)
289 /* REVISIT: instantiate IR device */
292 void cx231xx_set_ir(struct cx231xx
*dev
, struct IR_i2c
*ir
)
294 /* detect & configure */
295 switch (dev
->model
) {
297 case CX231XX_BOARD_CNXT_RDE_250
:
299 case CX231XX_BOARD_CNXT_RDU_250
:
306 void cx231xx_card_setup(struct cx231xx
*dev
)
309 cx231xx_set_model(dev
);
311 dev
->tuner_type
= cx231xx_boards
[dev
->model
].tuner_type
;
312 if (cx231xx_boards
[dev
->model
].tuner_addr
)
313 dev
->tuner_addr
= cx231xx_boards
[dev
->model
].tuner_addr
;
315 /* request some modules */
316 if (dev
->board
.decoder
== CX231XX_AVDECODER
) {
317 dev
->sd_cx25840
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
318 &dev
->i2c_bus
[0].i2c_adap
,
319 "cx25840", "cx25840", 0x88 >> 1);
320 if (dev
->sd_cx25840
== NULL
)
321 cx231xx_info("cx25840 subdev registration failure\n");
322 cx25840_call(dev
, core
, load_fw
);
326 if (dev
->board
.tuner_type
!= TUNER_ABSENT
) {
327 dev
->sd_tuner
= v4l2_i2c_new_subdev(&dev
->v4l2_dev
,
328 &dev
->i2c_bus
[1].i2c_adap
,
329 "tuner", "tuner", 0xc2 >> 1);
330 if (dev
->sd_tuner
== NULL
)
331 cx231xx_info("tuner subdev registration failure\n");
333 cx231xx_config_tuner(dev
);
336 cx231xx_config_tuner(dev
);
339 /* TBD IR will be added later */
340 cx231xx_ir_init(dev
);
346 * inits registers with sane defaults
348 int cx231xx_config(struct cx231xx
*dev
)
350 /* TBD need to add cx231xx specific code */
351 dev
->mute
= 1; /* maybe not the right place... */
358 * cx231xx_config_i2c()
359 * configure i2c attached devices
361 void cx231xx_config_i2c(struct cx231xx
*dev
)
363 /* u32 input = INPUT(dev->video_input)->vmux; */
365 call_all(dev
, video
, s_stream
, 1);
369 * cx231xx_realease_resources()
370 * unregisters the v4l2,i2c and usb devices
371 * called when the device gets disconected or at module unload
373 void cx231xx_release_resources(struct cx231xx
*dev
)
376 #if 0 /* TBD IR related */
378 cx231xx_ir_fini(dev
);
381 cx231xx_release_analog_resources(dev
);
383 cx231xx_remove_from_devlist(dev
);
385 cx231xx_dev_uninit(dev
);
387 usb_put_dev(dev
->udev
);
389 /* Mark device as unused */
390 cx231xx_devused
&= ~(1 << dev
->devno
);
395 * allocates and inits the device structs, registers i2c bus and v4l device
397 static int cx231xx_init_dev(struct cx231xx
**devhandle
, struct usb_device
*udev
,
400 struct cx231xx
*dev
= *devhandle
;
401 int retval
= -ENOMEM
;
403 unsigned int maxh
, maxw
;
406 mutex_init(&dev
->lock
);
407 mutex_init(&dev
->ctrl_urb_lock
);
408 mutex_init(&dev
->gpio_i2c_lock
);
410 spin_lock_init(&dev
->video_mode
.slock
);
411 spin_lock_init(&dev
->vbi_mode
.slock
);
412 spin_lock_init(&dev
->sliced_cc_mode
.slock
);
414 init_waitqueue_head(&dev
->open
);
415 init_waitqueue_head(&dev
->wait_frame
);
416 init_waitqueue_head(&dev
->wait_stream
);
418 dev
->cx231xx_read_ctrl_reg
= cx231xx_read_ctrl_reg
;
419 dev
->cx231xx_write_ctrl_reg
= cx231xx_write_ctrl_reg
;
420 dev
->cx231xx_send_usb_command
= cx231xx_send_usb_command
;
421 dev
->cx231xx_gpio_i2c_read
= cx231xx_gpio_i2c_read
;
422 dev
->cx231xx_gpio_i2c_write
= cx231xx_gpio_i2c_write
;
424 /* Query cx231xx to find what pcb config it is related to */
425 initialize_cx231xx(dev
);
427 /* Cx231xx pre card setup */
428 cx231xx_pre_card_setup(dev
);
430 errCode
= cx231xx_config(dev
);
432 cx231xx_errdev("error configuring device\n");
436 /* set default norm */
437 dev
->norm
= dev
->board
.norm
;
439 /* register i2c bus */
440 errCode
= cx231xx_dev_init(dev
);
442 cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
447 /* Do board specific init */
448 cx231xx_card_setup(dev
);
450 /* configure the device */
451 cx231xx_config_i2c(dev
);
453 maxw
= norm_maxw(dev
);
454 maxh
= norm_maxh(dev
);
456 /* set default image size */
462 dev
->video_input
= 0;
464 errCode
= cx231xx_config(dev
);
466 cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
471 /* init video dma queues */
472 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.active
);
473 INIT_LIST_HEAD(&dev
->video_mode
.vidq
.queued
);
475 /* init vbi dma queues */
476 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.active
);
477 INIT_LIST_HEAD(&dev
->vbi_mode
.vidq
.queued
);
479 /* Reset other chips required if they are tied up with GPIO pins */
481 cx231xx_add_into_devlist(dev
);
483 retval
= cx231xx_register_analog_devices(dev
);
485 cx231xx_release_resources(dev
);
486 goto fail_reg_devices
;
489 cx231xx_init_extension(dev
);
494 mutex_unlock(&dev
->lock
);
498 #if defined(CONFIG_MODULES) && defined(MODULE)
499 static void request_module_async(struct work_struct
*work
)
501 struct cx231xx
*dev
= container_of(work
,
502 struct cx231xx
, request_module_wk
);
504 if (dev
->has_alsa_audio
)
505 request_module("cx231xx-alsa");
507 if (dev
->board
.has_dvb
)
508 request_module("cx231xx-dvb");
512 static void request_modules(struct cx231xx
*dev
)
514 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
515 schedule_work(&dev
->request_module_wk
);
518 #define request_modules(dev)
519 #endif /* CONFIG_MODULES */
522 * cx231xx_usb_probe()
523 * checks for supported devices
525 static int cx231xx_usb_probe(struct usb_interface
*interface
,
526 const struct usb_device_id
*id
)
528 struct usb_device
*udev
;
529 struct usb_interface
*uif
;
530 struct cx231xx
*dev
= NULL
;
531 int retval
= -ENODEV
;
533 int i
, isoc_pipe
= 0;
535 char descr
[255] = "";
536 struct usb_interface
*lif
= NULL
;
537 int skip_interface
= 0;
538 struct usb_interface_assoc_descriptor
*assoc_desc
;
540 udev
= usb_get_dev(interface_to_usbdev(interface
));
541 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
545 * Interface number 0 - IR interface
547 /* Check to see next free device and mark as used */
548 nr
= find_first_zero_bit(&cx231xx_devused
, CX231XX_MAXBOARDS
);
549 cx231xx_devused
|= 1 << nr
;
551 if (nr
>= CX231XX_MAXBOARDS
) {
552 cx231xx_err(DRIVER_NAME
": Supports only %i cx231xx boards.\n",
554 cx231xx_devused
&= ~(1 << nr
);
558 /* allocate memory for our device state and initialize it */
559 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
561 cx231xx_err(DRIVER_NAME
": out of memory!\n");
562 cx231xx_devused
&= ~(1 << nr
);
566 snprintf(dev
->name
, 29, "cx231xx #%d", nr
);
568 dev
->model
= id
->driver_info
;
569 dev
->video_mode
.alt
= -1;
570 dev
->interface_count
++;
572 /* reset gpio dir and value */
575 dev
->xc_fw_load_done
= 0;
576 dev
->has_alsa_audio
= 1;
577 dev
->power_mode
= -1;
579 /* 0 - vbi ; 1 -sliced cc mode */
580 dev
->vbi_or_sliced_cc_mode
= 0;
582 /* get maximum no.of IAD interfaces */
583 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
584 dev
->max_iad_interface_count
= assoc_desc
->bInterfaceCount
;
586 /* init CIR module TBD */
588 /* store the current interface */
591 switch (udev
->speed
) {
595 case USB_SPEED_UNKNOWN
:
606 if (udev
->manufacturer
)
607 strlcpy(descr
, udev
->manufacturer
, sizeof(descr
));
611 strlcat(descr
, " ", sizeof(descr
));
612 strlcat(descr
, udev
->product
, sizeof(descr
));
615 strlcat(descr
, " ", sizeof(descr
));
617 cx231xx_info("New device %s@ %s Mbps "
618 "(%04x:%04x) with %d interfaces\n",
621 le16_to_cpu(udev
->descriptor
.idVendor
),
622 le16_to_cpu(udev
->descriptor
.idProduct
),
623 dev
->max_iad_interface_count
);
625 /* Get dev structure first */
626 dev
= usb_get_intfdata(udev
->actconfig
->interface
[0]);
628 cx231xx_err(DRIVER_NAME
": out of first interface!\n");
632 /* store the interface 0 back */
633 lif
= udev
->actconfig
->interface
[0];
635 /* increment interface count */
636 dev
->interface_count
++;
638 /* get device number */
642 * set skip interface, for all interfaces but
643 * interface 1 and the last one
645 if ((ifnum
!= 1) && ((dev
->interface_count
- 1)
646 != dev
->max_iad_interface_count
))
650 assoc_desc
= udev
->actconfig
->intf_assoc
[0];
651 if (assoc_desc
->bFirstInterface
!= ifnum
) {
652 cx231xx_err(DRIVER_NAME
": Not found "
653 "matching IAD interface\n");
662 cx231xx_info("registering interface %d\n", ifnum
);
664 /* save our data pointer in this interface device */
665 usb_set_intfdata(lif
, dev
);
667 if ((dev
->interface_count
- 1) != dev
->max_iad_interface_count
)
671 * AV device initialization - only done at the last interface
674 /* Create v4l2 device */
675 retval
= v4l2_device_register(&interface
->dev
, &dev
->v4l2_dev
);
677 cx231xx_errdev("v4l2_device_register failed\n");
678 cx231xx_devused
&= ~(1 << nr
);
683 /* allocate device struct */
684 retval
= cx231xx_init_dev(&dev
, udev
, nr
);
686 cx231xx_devused
&= ~(1 << dev
->devno
);
687 v4l2_device_unregister(&dev
->v4l2_dev
);
692 /* compute alternate max packet sizes for video */
693 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
694 hs_config_info
[0].interface_info
.video_index
+ 1];
696 dev
->video_mode
.end_point_addr
= le16_to_cpu(uif
->altsetting
[0].
697 endpoint
[isoc_pipe
].desc
.bEndpointAddress
);
699 dev
->video_mode
.num_alt
= uif
->num_altsetting
;
700 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
701 dev
->video_mode
.end_point_addr
,
702 dev
->video_mode
.num_alt
);
703 dev
->video_mode
.alt_max_pkt_size
=
704 kmalloc(32 * dev
->video_mode
.num_alt
, GFP_KERNEL
);
706 if (dev
->video_mode
.alt_max_pkt_size
== NULL
) {
707 cx231xx_errdev("out of memory!\n");
708 cx231xx_devused
&= ~(1 << nr
);
709 v4l2_device_unregister(&dev
->v4l2_dev
);
714 for (i
= 0; i
< dev
->video_mode
.num_alt
; i
++) {
715 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
716 desc
.wMaxPacketSize
);
717 dev
->video_mode
.alt_max_pkt_size
[i
] =
718 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
719 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
720 dev
->video_mode
.alt_max_pkt_size
[i
]);
723 /* compute alternate max packet sizes for vbi */
724 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
725 hs_config_info
[0].interface_info
.
728 dev
->vbi_mode
.end_point_addr
=
729 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
732 dev
->vbi_mode
.num_alt
= uif
->num_altsetting
;
733 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
734 dev
->vbi_mode
.end_point_addr
,
735 dev
->vbi_mode
.num_alt
);
736 dev
->vbi_mode
.alt_max_pkt_size
=
737 kmalloc(32 * dev
->vbi_mode
.num_alt
, GFP_KERNEL
);
739 if (dev
->vbi_mode
.alt_max_pkt_size
== NULL
) {
740 cx231xx_errdev("out of memory!\n");
741 cx231xx_devused
&= ~(1 << nr
);
742 v4l2_device_unregister(&dev
->v4l2_dev
);
747 for (i
= 0; i
< dev
->vbi_mode
.num_alt
; i
++) {
749 le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
750 desc
.wMaxPacketSize
);
751 dev
->vbi_mode
.alt_max_pkt_size
[i
] =
752 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
753 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
754 dev
->vbi_mode
.alt_max_pkt_size
[i
]);
757 /* compute alternate max packet sizes for sliced CC */
758 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
759 hs_config_info
[0].interface_info
.
762 dev
->sliced_cc_mode
.end_point_addr
=
763 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].desc
.
766 dev
->sliced_cc_mode
.num_alt
= uif
->num_altsetting
;
767 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
768 dev
->sliced_cc_mode
.end_point_addr
,
769 dev
->sliced_cc_mode
.num_alt
);
770 dev
->sliced_cc_mode
.alt_max_pkt_size
=
771 kmalloc(32 * dev
->sliced_cc_mode
.num_alt
, GFP_KERNEL
);
773 if (dev
->sliced_cc_mode
.alt_max_pkt_size
== NULL
) {
774 cx231xx_errdev("out of memory!\n");
775 cx231xx_devused
&= ~(1 << nr
);
776 v4l2_device_unregister(&dev
->v4l2_dev
);
781 for (i
= 0; i
< dev
->sliced_cc_mode
.num_alt
; i
++) {
782 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[isoc_pipe
].
783 desc
.wMaxPacketSize
);
784 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
] =
785 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
786 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
787 dev
->sliced_cc_mode
.alt_max_pkt_size
[i
]);
790 if (dev
->current_pcb_config
.ts1_source
!= 0xff) {
791 /* compute alternate max packet sizes for TS1 */
792 uif
= udev
->actconfig
->interface
[dev
->current_pcb_config
.
797 dev
->ts1_mode
.end_point_addr
=
798 le16_to_cpu(uif
->altsetting
[0].endpoint
[isoc_pipe
].
799 desc
.bEndpointAddress
);
801 dev
->ts1_mode
.num_alt
= uif
->num_altsetting
;
802 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
803 dev
->ts1_mode
.end_point_addr
,
804 dev
->ts1_mode
.num_alt
);
805 dev
->ts1_mode
.alt_max_pkt_size
=
806 kmalloc(32 * dev
->ts1_mode
.num_alt
, GFP_KERNEL
);
808 if (dev
->ts1_mode
.alt_max_pkt_size
== NULL
) {
809 cx231xx_errdev("out of memory!\n");
810 cx231xx_devused
&= ~(1 << nr
);
811 v4l2_device_unregister(&dev
->v4l2_dev
);
816 for (i
= 0; i
< dev
->ts1_mode
.num_alt
; i
++) {
817 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].
818 endpoint
[isoc_pipe
].desc
.
820 dev
->ts1_mode
.alt_max_pkt_size
[i
] =
821 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
822 cx231xx_info("Alternate setting %i, max size= %i\n", i
,
823 dev
->ts1_mode
.alt_max_pkt_size
[i
]);
827 /* load other modules required */
828 request_modules(dev
);
834 * cx231xx_usb_disconnect()
835 * called when the device gets diconencted
836 * video device will be unregistered on v4l2_close in case it is still open
838 static void cx231xx_usb_disconnect(struct usb_interface
*interface
)
842 dev
= usb_get_intfdata(interface
);
843 usb_set_intfdata(interface
, NULL
);
851 /* delete v4l2 device */
852 v4l2_device_unregister(&dev
->v4l2_dev
);
854 /* wait until all current v4l2 io is finished then deallocate
856 mutex_lock(&dev
->lock
);
858 wake_up_interruptible_all(&dev
->open
);
862 ("device /dev/video%d is open! Deregistration and memory "
863 "deallocation are deferred on close.\n", dev
->vdev
->num
);
865 dev
->state
|= DEV_MISCONFIGURED
;
866 cx231xx_uninit_isoc(dev
);
867 dev
->state
|= DEV_DISCONNECTED
;
868 wake_up_interruptible(&dev
->wait_frame
);
869 wake_up_interruptible(&dev
->wait_stream
);
871 dev
->state
|= DEV_DISCONNECTED
;
872 cx231xx_release_resources(dev
);
875 cx231xx_close_extension(dev
);
877 mutex_unlock(&dev
->lock
);
880 kfree(dev
->video_mode
.alt_max_pkt_size
);
881 kfree(dev
->vbi_mode
.alt_max_pkt_size
);
882 kfree(dev
->sliced_cc_mode
.alt_max_pkt_size
);
883 kfree(dev
->ts1_mode
.alt_max_pkt_size
);
888 static struct usb_driver cx231xx_usb_driver
= {
890 .probe
= cx231xx_usb_probe
,
891 .disconnect
= cx231xx_usb_disconnect
,
892 .id_table
= cx231xx_id_table
,
895 static int __init
cx231xx_module_init(void)
899 printk(KERN_INFO DRIVER_NAME
" v4l2 driver loaded.\n");
901 /* register this driver with the USB subsystem */
902 result
= usb_register(&cx231xx_usb_driver
);
904 cx231xx_err(DRIVER_NAME
905 " usb_register failed. Error number %d.\n", result
);
910 static void __exit
cx231xx_module_exit(void)
912 /* deregister this driver with the USB subsystem */
913 usb_deregister(&cx231xx_usb_driver
);
916 module_init(cx231xx_module_init
);
917 module_exit(cx231xx_module_exit
);