V4L/DVB (10957a): cx231xx: Fix compilation breakage
[linux-2.6.git] / drivers / media / video / cx231xx / cx231xx-cards.c
1 /*
2    cx231xx-cards.c - driver for Conexant Cx23100/101/102 USB video capture devices
3
4    Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
5         Based on em28xx driver
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/delay.h>
25 #include <linux/i2c.h>
26 #include <linux/usb.h>
27 #include <media/tuner.h>
28 #include <media/tveeprom.h>
29 #include <media/v4l2-common.h>
30 #include <media/v4l2-chip-ident.h>
31
32 #include <media/cx25840.h>
33 #include "xc5000.h"
34
35 #include "cx231xx.h"
36
37 static int tuner = -1;
38 module_param(tuner, int, 0444);
39 MODULE_PARM_DESC(tuner, "tuner type");
40
41 static unsigned int disable_ir;
42 module_param(disable_ir, int, 0444);
43 MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
44
45 /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
46 static unsigned long cx231xx_devused;
47
48 /*
49  *  Reset sequences for analog/digital modes
50  */
51
52 static struct cx231xx_reg_seq RDE250_XCV_TUNER[] = {
53         {0x03, 0x01, 10},
54         {0x03, 0x00, 30},
55         {0x03, 0x01, 10},
56         {-1, -1, -1},
57 };
58
59 /*
60  *  Board definitions
61  */
62 struct cx231xx_board cx231xx_boards[] = {
63
64         [CX231XX_BOARD_UNKNOWN] = {
65                                    .name = "Unknown CX231xx video grabber",
66                                    .tuner_type = TUNER_ABSENT,
67                                    .input = {{
68                                               .type = CX231XX_VMUX_TELEVISION,
69                                               .vmux = CX231XX_VIN_3_1,
70                                               .amux = CX231XX_AMUX_VIDEO,
71                                               .gpio = 0,
72                                               }, {
73                                                   .type =
74                                                   CX231XX_VMUX_COMPOSITE1,
75                                                   .vmux = CX231XX_VIN_2_1,
76                                                   .amux = CX231XX_AMUX_LINE_IN,
77                                                   .gpio = 0,
78                                                   }, {
79                                                       .type =
80                                                       CX231XX_VMUX_SVIDEO,
81                                                       .vmux =
82                                                       CX231XX_VIN_1_1 |
83                                                       (CX231XX_VIN_1_2 << 8) |
84                                                       CX25840_SVIDEO_ON,
85                                                       .amux =
86                                                       CX231XX_AMUX_LINE_IN,
87                                                       .gpio = 0,
88                                                       }},
89                                    },
90
91         [CX231XX_BOARD_CNXT_RDE_250] = {
92                                         .name = "Conexant Hybrid TV - RDE250",
93                                         .valid = CX231XX_BOARD_VALIDATED,
94                                         .tuner_type = TUNER_XC5000,
95                                         .tuner_addr = 0x61,
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                                         .demod_xfer_mode = 0,
102                                         .ctl_pin_status_mask = 0xFFFFFFC4,
103                                         .agc_analog_digital_select_gpio = 0x0c,
104                                         .gpio_pin_status_mask = 0x4001000,
105                                         .tuner_i2c_master = 1,
106                                         .demod_i2c_master = 2,
107                                         .has_dvb = 1,
108                                         .demod_addr = 0x02,
109                                         .norm = V4L2_STD_PAL,
110
111                                         .input = {{
112                                                    .type =
113                                                    CX231XX_VMUX_TELEVISION,
114                                                    .vmux = CX231XX_VIN_3_1,
115                                                    .amux = CX231XX_AMUX_VIDEO,
116                                                    .gpio = 0,
117                                                    }, {
118                                                        .type =
119                                                        CX231XX_VMUX_COMPOSITE1,
120                                                        .vmux = CX231XX_VIN_2_1,
121                                                        .amux =
122                                                        CX231XX_AMUX_LINE_IN,
123                                                        .gpio = 0,
124                                                        }, {
125                                                            .type =
126                                                            CX231XX_VMUX_SVIDEO,
127                                                            .vmux =
128                                                            CX231XX_VIN_1_1 |
129                                                            (CX231XX_VIN_1_2 <<
130                                                             8) |
131                                                            CX25840_SVIDEO_ON,
132                                                            .amux =
133                                                            CX231XX_AMUX_LINE_IN,
134                                                            .gpio = 0,
135                                                            }},
136                                         },
137
138         [CX231XX_BOARD_CNXT_RDU_250] = {
139                                         .name = "Conexant Hybrid TV - RDU250",
140                                         .valid = CX231XX_BOARD_VALIDATED,
141                                         .tuner_type = TUNER_XC5000,
142                                         .tuner_addr = 0x61,
143                                         .tuner_gpio = RDE250_XCV_TUNER,
144                                         .tuner_sif_gpio = 0x05,
145                                         .tuner_scl_gpio = 0x1a,
146                                         .tuner_sda_gpio = 0x1b,
147                                         .decoder = CX231XX_AVDECODER,
148                                         .demod_xfer_mode = 0,
149                                         .ctl_pin_status_mask = 0xFFFFFFC4,
150                                         .agc_analog_digital_select_gpio = 0x0c,
151                                         .gpio_pin_status_mask = 0x4001000,
152                                         .tuner_i2c_master = 1,
153                                         .demod_i2c_master = 2,
154                                         .has_dvb = 1,
155                                         .demod_addr = 0x32,
156                                         .norm = V4L2_STD_NTSC,
157
158                                         .input = {{
159                                                    .type =
160                                                    CX231XX_VMUX_TELEVISION,
161                                                    .vmux = CX231XX_VIN_3_1,
162                                                    .amux = CX231XX_AMUX_VIDEO,
163                                                    .gpio = 0,
164                                                    }, {
165                                                        .type =
166                                                        CX231XX_VMUX_COMPOSITE1,
167                                                        .vmux = CX231XX_VIN_2_1,
168                                                        .amux =
169                                                        CX231XX_AMUX_LINE_IN,
170                                                        .gpio = 0,
171                                                        }, {
172                                                            .type =
173                                                            CX231XX_VMUX_SVIDEO,
174                                                            .vmux =
175                                                            CX231XX_VIN_1_1 |
176                                                            (CX231XX_VIN_1_2 <<
177                                                             8) |
178                                                            CX25840_SVIDEO_ON,
179                                                            .amux =
180                                                            CX231XX_AMUX_LINE_IN,
181                                                            .gpio = 0,
182                                                            }},
183                                         },
184 };
185 const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
186
187 /* table of devices that work with this driver */
188 struct usb_device_id cx231xx_id_table[] = {
189         {USB_DEVICE(0x0572, 0x58A0),
190          .driver_info = CX231XX_BOARD_UNKNOWN},
191         {USB_DEVICE(0x0572, 0x58A2),
192          .driver_info = CX231XX_BOARD_CNXT_RDE_250},
193         {USB_DEVICE(0x0572, 0x5A3C),
194          .driver_info = CX231XX_BOARD_CNXT_RDU_250},
195         {},
196 };
197
198 MODULE_DEVICE_TABLE(usb, cx231xx_id_table);
199
200 /* cx231xx_tuner_callback
201  * will be used to reset XC5000 tuner using GPIO pin
202  */
203
204 int cx231xx_tuner_callback(void *ptr, int component, int command, int arg)
205 {
206         int rc = 0;
207         struct cx231xx *dev = ptr;
208
209         if (dev->tuner_type == TUNER_XC5000) {
210                 if (command == XC5000_TUNER_RESET) {
211                         cx231xx_info
212                             ("Tuner Call back : RESET : command %d : tuner type %d \n",
213                              command, dev->tuner_type);
214
215                         cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
216                                                1);
217                         msleep(10);
218                         cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
219                                                0);
220                         msleep(330);
221                         cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
222                                                1);
223                         msleep(10);
224                 }
225         }
226         return rc;
227 }
228
229 EXPORT_SYMBOL_GPL(cx231xx_tuner_callback);
230
231 static void inline cx231xx_set_model(struct cx231xx *dev)
232 {
233         memcpy(&dev->board, &cx231xx_boards[dev->model], sizeof(dev->board));
234 }
235
236 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
237  * this won't work for boards with generic PCI IDs
238  */
239 void cx231xx_pre_card_setup(struct cx231xx *dev)
240 {
241
242         cx231xx_set_model(dev);
243
244         cx231xx_info("Identified as %s (card=%d)\n",
245                      dev->board.name, dev->model);
246
247         /* Do card specific if any */
248         switch (dev->model) {
249         case CX231XX_BOARD_CNXT_RDE_250:
250                 /* do card specific GPIO settings if required */
251                 cx231xx_info("Precard: Board is Conexnat RDE 250\n");
252                 /* set the direction for GPIO pins */
253                 cx231xx_set_gpio_direction(dev, dev->board.tuner_gpio->bit, 1);
254                 cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit, 1);
255                 cx231xx_set_gpio_direction(dev, dev->board.tuner_sif_gpio, 1);
256                 break;
257         case CX231XX_BOARD_CNXT_RDU_250:
258                 /* do card specific GPIO settings if required */
259                 cx231xx_info("Precard: Board is Conexnat RDU 250\n");
260                 /* set the direction for GPIO pins */
261                 cx231xx_set_gpio_direction(dev, dev->board.tuner_gpio->bit, 1);
262                 cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit, 1);
263                 cx231xx_set_gpio_direction(dev, dev->board.tuner_sif_gpio, 1);
264                 break;
265         }
266
267         /* request some modules if any required */
268
269         /* reset the Tuner */
270         cx231xx_gpio_set(dev, dev->board.tuner_gpio);
271
272         /* set the mode to Analog mode initially */
273         cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
274
275         /* Unlock device */
276         /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
277
278 }
279
280 #if 0
281
282 static void cx231xx_config_tuner(struct cx231xx *dev)
283 {
284         struct tuner_setup tun_setup;
285         struct v4l2_frequency f;
286
287         if (dev->tuner_type == TUNER_ABSENT)
288                 return;
289
290         tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
291         tun_setup.type = dev->tuner_type;
292         tun_setup.addr = dev->tuner_addr;
293         tun_setup.tuner_callback = cx231xx_tuner_callback;
294
295         cx231xx_i2c_call_clients(&dev->i2c_bus[1], TUNER_SET_TYPE_ADDR,
296                                  &tun_setup);
297 #if 0
298         if (tun_setup.type == TUNER_XC5000) {
299                 static struct xc2028_ctrl ctrl = {
300                         .fname = XC5000_DEFAULT_FIRMWARE,
301                         .max_len = 64,
302                         .demod = 0;
303                 };
304                 struct v4l2_priv_tun_config cfg = {
305                         .tuner = dev->tuner_type,
306                         .priv = &ctrl,
307                 };
308                 cx231xx_i2c_call_clients(&dev->i2c_bus[1], TUNER_SET_CONFIG,
309                                          &cfg);
310         }
311 #endif
312
313         /* configure tuner */
314         f.tuner = 0;
315         f.type = V4L2_TUNER_ANALOG_TV;
316         f.frequency = 9076;     /* just a magic number */
317         dev->ctl_freq = f.frequency;
318         cx231xx_i2c_call_clients(&dev->i2c_bus[1], VIDIOC_S_FREQUENCY, &f);
319 }
320
321 #endif
322
323 /* ----------------------------------------------------------------------- */
324 void cx231xx_set_ir(struct cx231xx *dev, struct IR_i2c *ir)
325 {
326         if (disable_ir) {
327                 ir->get_key = NULL;
328                 return;
329         }
330
331         /* detect & configure */
332         switch (dev->model) {
333
334         case CX231XX_BOARD_CNXT_RDE_250:
335                 break;
336         case CX231XX_BOARD_CNXT_RDU_250:
337                 break;
338         default:
339                 break;
340         }
341 }
342
343 void cx231xx_card_setup(struct cx231xx *dev)
344 {
345         cx231xx_set_model(dev);
346
347         dev->tuner_type = cx231xx_boards[dev->model].tuner_type;
348         if (cx231xx_boards[dev->model].tuner_addr)
349                 dev->tuner_addr = cx231xx_boards[dev->model].tuner_addr;
350
351         cx231xx_info(": tuner type %d, tuner address %d \n",
352                      dev->tuner_type, dev->tuner_addr);
353
354         /* Do card specific if any */
355         switch (dev->model) {
356         case CX231XX_BOARD_CNXT_RDE_250:
357                 /* do card specific GPIO settings if required */
358                 cx231xx_info("Board is Conexnat RDE 250\n");
359                 break;
360         case CX231XX_BOARD_CNXT_RDU_250:
361                 /* do card specific GPIO settings if required */
362                 cx231xx_info("Board is Conexnat RDU 250\n");
363                 break;
364         }
365
366         if (dev->board.valid == CX231XX_BOARD_NOT_VALIDATED) {
367                 cx231xx_errdev("\n\n");
368                 cx231xx_errdev("The support for this board weren't "
369                                "valid yet.\n");
370                 cx231xx_errdev("Please send a report of having this working\n");
371                 cx231xx_errdev("not to V4L mailing list (and/or to other "
372                                "addresses)\n\n");
373         }
374
375         /* request some modules */
376         if (dev->board.decoder == CX231XX_AVDECODER) {
377                 cx231xx_info(": Requesting cx25840 module\n");
378                 request_module("cx25840");
379         }
380 #if 0
381         if (dev->board.tuner_type != TUNER_ABSENT) {
382                 cx231xx_info(": Requesting Tuner module\n");
383                 request_module("tuner");
384         }
385
386         cx231xx_config_tuner(dev);
387
388         /* TBD  IR will be added later */
389         cx231xx_ir_init(dev);
390 #endif
391 }
392
393 /*
394  * cx231xx_config()
395  * inits registers with sane defaults
396  */
397 int cx231xx_config(struct cx231xx *dev)
398 {
399         /* TBD need to add cx231xx specific code */
400         dev->mute = 1;          /* maybe not the right place... */
401         dev->volume = 0x1f;
402
403         return 0;
404 }
405
406 /*
407  * cx231xx_config_i2c()
408  * configure i2c attached devices
409  */
410 void cx231xx_config_i2c(struct cx231xx *dev)
411 {
412         struct v4l2_routing route;
413
414         route.input = INPUT(dev->video_input)->vmux;
415         route.output = 0;
416
417         cx231xx_i2c_call_clients(&dev->i2c_bus[0], VIDIOC_STREAMON, NULL);
418 }
419
420 /*
421  * cx231xx_realease_resources()
422  * unregisters the v4l2,i2c and usb devices
423  * called when the device gets disconected or at module unload
424 */
425 void cx231xx_release_resources(struct cx231xx *dev)
426 {
427
428 #if 0           /* TBD IR related  */
429         if (dev->ir)
430                 cx231xx_ir_fini(dev);
431 #endif
432
433         cx231xx_release_analog_resources(dev);
434
435         cx231xx_remove_from_devlist(dev);
436
437         cx231xx_dev_uninit(dev);
438
439         usb_put_dev(dev->udev);
440
441         /* Mark device as unused */
442         cx231xx_devused &= ~(1 << dev->devno);
443 }
444
445 /*
446  * cx231xx_init_dev()
447  * allocates and inits the device structs, registers i2c bus and v4l device
448  */
449 static int cx231xx_init_dev(struct cx231xx **devhandle, struct usb_device *udev,
450                             int minor)
451 {
452         struct cx231xx *dev = *devhandle;
453         int retval = -ENOMEM;
454         int errCode;
455         unsigned int maxh, maxw;
456
457         dev->udev = udev;
458         mutex_init(&dev->lock);
459         mutex_init(&dev->ctrl_urb_lock);
460         mutex_init(&dev->gpio_i2c_lock);
461
462         spin_lock_init(&dev->video_mode.slock);
463         spin_lock_init(&dev->vbi_mode.slock);
464         spin_lock_init(&dev->sliced_cc_mode.slock);
465
466         init_waitqueue_head(&dev->open);
467         init_waitqueue_head(&dev->wait_frame);
468         init_waitqueue_head(&dev->wait_stream);
469
470         dev->cx231xx_read_ctrl_reg = cx231xx_read_ctrl_reg;
471         dev->cx231xx_write_ctrl_reg = cx231xx_write_ctrl_reg;
472         dev->cx231xx_send_usb_command = cx231xx_send_usb_command;
473         dev->cx231xx_gpio_i2c_read = cx231xx_gpio_i2c_read;
474         dev->cx231xx_gpio_i2c_write = cx231xx_gpio_i2c_write;
475
476         /* Query cx231xx to find what pcb config it is related to */
477         initialize_cx231xx(dev);
478
479         /* Cx231xx pre card setup */
480         cx231xx_pre_card_setup(dev);
481
482         errCode = cx231xx_config(dev);
483         if (errCode) {
484                 cx231xx_errdev("error configuring device\n");
485                 return -ENOMEM;
486         }
487
488         /* set default norm */
489         dev->norm = dev->board.norm;
490
491         /* register i2c bus */
492         errCode = cx231xx_dev_init(dev);
493         if (errCode < 0) {
494                 cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
495                                __func__, errCode);
496                 return errCode;
497         }
498
499         /* Do board specific init */
500         cx231xx_card_setup(dev);
501
502         /* configure the device */
503         cx231xx_config_i2c(dev);
504
505         maxw = norm_maxw(dev);
506         maxh = norm_maxh(dev);
507
508         /* set default image size */
509         dev->width = maxw;
510         dev->height = maxh;
511         dev->interlaced = 0;
512         dev->hscale = 0;
513         dev->vscale = 0;
514         dev->video_input = 0;
515
516         errCode = cx231xx_config(dev);
517         if (errCode < 0) {
518                 cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
519                                __func__, errCode);
520                 return errCode;
521         }
522
523         /* init video dma queues */
524         INIT_LIST_HEAD(&dev->video_mode.vidq.active);
525         INIT_LIST_HEAD(&dev->video_mode.vidq.queued);
526
527         /* init vbi dma queues */
528         INIT_LIST_HEAD(&dev->vbi_mode.vidq.active);
529         INIT_LIST_HEAD(&dev->vbi_mode.vidq.queued);
530
531         /* Reset other chips required if they are tied up with GPIO pins */
532
533         cx231xx_add_into_devlist(dev);
534
535         retval = cx231xx_register_analog_devices(dev);
536         if (retval < 0) {
537                 cx231xx_release_resources(dev);
538                 goto fail_reg_devices;
539         }
540
541         cx231xx_init_extension(dev);
542
543         return 0;
544
545       fail_reg_devices:
546         mutex_unlock(&dev->lock);
547         return retval;
548 }
549
550 #if defined(CONFIG_MODULES) && defined(MODULE)
551 static void request_module_async(struct work_struct *work)
552 {
553         struct cx231xx *dev = container_of(work,
554                                            struct cx231xx, request_module_wk);
555
556         if (dev->has_alsa_audio)
557                 request_module("cx231xx-alsa");
558
559         if (dev->board.has_dvb)
560                 request_module("cx231xx-dvb");
561
562 }
563
564 static void request_modules(struct cx231xx *dev)
565 {
566         INIT_WORK(&dev->request_module_wk, request_module_async);
567         schedule_work(&dev->request_module_wk);
568 }
569 #else
570 #define request_modules(dev)
571 #endif /* CONFIG_MODULES */
572
573 /*
574  * cx231xx_usb_probe()
575  * checks for supported devices
576  */
577 static int cx231xx_usb_probe(struct usb_interface *interface,
578                              const struct usb_device_id *id)
579 {
580         struct usb_device *udev;
581         struct usb_interface *uif;
582         struct cx231xx *dev = NULL;
583         int retval = -ENODEV;
584         int nr, ifnum;
585         int i, isoc_pipe = 0;
586         char *speed;
587         char descr[255] = "";
588         struct usb_interface *lif = NULL;
589         int skip_interface = 0;
590         struct usb_interface_assoc_descriptor *assoc_desc;
591
592         udev = usb_get_dev(interface_to_usbdev(interface));
593         ifnum = interface->altsetting[0].desc.bInterfaceNumber;
594
595         cx231xx_info(": Interface Number %d\n", ifnum);
596
597         /* Interface number 0 - IR interface */
598         if (ifnum == 0) {
599                 /* Check to see next free device and mark as used */
600                 nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
601                 cx231xx_devused |= 1 << nr;
602
603                 if (nr >= CX231XX_MAXBOARDS) {
604                         cx231xx_info(": Supports only %i cx231xx boards.\n",
605                                      CX231XX_MAXBOARDS);
606                         cx231xx_devused &= ~(1 << nr);
607                         return -ENOMEM;
608                 }
609
610                 /* allocate memory for our device state and initialize it */
611                 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
612                 if (dev == NULL) {
613                         cx231xx_err(DRIVER_NAME ": out of memory!\n");
614                         cx231xx_devused &= ~(1 << nr);
615                         return -ENOMEM;
616                 }
617
618                 snprintf(dev->name, 29, "cx231xx #%d", nr);
619                 dev->devno = nr;
620                 dev->model = id->driver_info;
621                 dev->video_mode.alt = -1;
622                 dev->interface_count++;
623
624                 /* reset gpio dir and value */
625                 dev->gpio_dir = 0;
626                 dev->gpio_val = 0;
627                 dev->xc_fw_load_done = 0;
628                 dev->has_alsa_audio = 1;
629                 dev->power_mode = -1;
630
631                 dev->vbi_or_sliced_cc_mode = 0; /* 0 - vbi ; 1 -sliced cc mode */
632
633                 /* get maximum no.of IAD interfaces */
634                 assoc_desc = udev->actconfig->intf_assoc[0];
635                 dev->max_iad_interface_count = assoc_desc->bInterfaceCount;
636                 cx231xx_info(": Found IAD interface count %d\n",
637                              dev->max_iad_interface_count);
638
639                 /* init CIR module TBD */
640
641                 /* store the current interface */
642                 lif = interface;
643
644         } else if (ifnum == 1) {
645
646                 /* Get dev structure first */
647                 dev = usb_get_intfdata(udev->actconfig->interface[0]);
648                 if (dev == NULL) {
649                         cx231xx_err(DRIVER_NAME ": out of first interface!\n");
650                         return -ENODEV;
651                 }
652
653                 /* store the interface 0 back */
654                 lif = udev->actconfig->interface[0];
655
656                 /* increment interface count */
657                 dev->interface_count++;
658
659                 /* get device number */
660                 nr = dev->devno;
661
662                 assoc_desc = udev->actconfig->intf_assoc[0];
663                 if (assoc_desc->bFirstInterface == ifnum) {
664                         cx231xx_info
665                             (": Found IAD interface match: AV Descriptor Start!! \n");
666                 } else {
667                         cx231xx_err(DRIVER_NAME
668                                     " Not found matching interface\n");
669                         return -ENODEV;
670                 }
671
672         } else if (ifnum >= 2) {
673                 /* Get dev structure first */
674                 dev = usb_get_intfdata(udev->actconfig->interface[0]);
675                 if (dev == NULL) {
676                         cx231xx_err(DRIVER_NAME ": out of first interface!\n");
677                         return -ENODEV;
678                 }
679
680                 /* store the interface 0 back */
681                 lif = udev->actconfig->interface[0];
682
683                 /* increment interface count */
684                 dev->interface_count++;
685
686                 /* get device number */
687                 nr = dev->devno;
688
689                 /* set skip interface */
690                 if ((dev->interface_count - 1) != dev->max_iad_interface_count)
691                         skip_interface = 1;     /* set skipping */
692                 else {
693                         cx231xx_info
694                             (": Found IAD interface number match with AV Device number!! \n");
695                 }
696         }
697
698         switch (udev->speed) {
699         case USB_SPEED_LOW:
700                 speed = "1.5";
701                 break;
702         case USB_SPEED_UNKNOWN:
703         case USB_SPEED_FULL:
704                 speed = "12";
705                 break;
706         case USB_SPEED_HIGH:
707                 speed = "480";
708                 break;
709         default:
710                 speed = "unknown";
711         }
712
713         if (udev->manufacturer)
714                 strlcpy(descr, udev->manufacturer, sizeof(descr));
715
716         if (udev->product) {
717                 if (*descr)
718                         strlcat(descr, " ", sizeof(descr));
719                 strlcat(descr, udev->product, sizeof(descr));
720         }
721         if (*descr)
722                 strlcat(descr, " ", sizeof(descr));
723
724         cx231xx_info("New device %s@ %s Mbps "
725                      "(%04x:%04x, interface %d, class %d)\n",
726                      descr,
727                      speed,
728                      le16_to_cpu(udev->descriptor.idVendor),
729                      le16_to_cpu(udev->descriptor.idProduct),
730                      ifnum, interface->altsetting->desc.bInterfaceNumber);
731
732         /* AV device initialization */
733         if ((dev->interface_count - 1) == dev->max_iad_interface_count) {
734                 cx231xx_info(" Calling init_dev\n");
735                 /* allocate device struct */
736                 retval = cx231xx_init_dev(&dev, udev, nr);
737                 if (retval) {
738                         cx231xx_devused &= ~(1 << dev->devno);
739                         kfree(dev);
740
741                         return retval;
742                 }
743
744                 /* compute alternate max packet sizes for video */
745                 uif =
746                     udev->actconfig->interface[dev->current_pcb_config.
747                                                hs_config_info[0].interface_info.
748                                                video_index + 1];
749
750                 dev->video_mode.end_point_addr =
751                     le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
752                                 bEndpointAddress);
753
754                 dev->video_mode.num_alt = uif->num_altsetting;
755                 cx231xx_info(": EndPoint Addr 0x%x, Alternate settings: %i\n",
756                              dev->video_mode.end_point_addr,
757                              dev->video_mode.num_alt);
758                 dev->video_mode.alt_max_pkt_size =
759                     kmalloc(32 * dev->video_mode.num_alt, GFP_KERNEL);
760
761                 if (dev->video_mode.alt_max_pkt_size == NULL) {
762                         cx231xx_errdev("out of memory!\n");
763                         cx231xx_devused &= ~(1 << nr);
764                         kfree(dev);
765                         return -ENOMEM;
766                 }
767
768                 for (i = 0; i < dev->video_mode.num_alt; i++) {
769                         u16 tmp =
770                             le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
771                                         desc.wMaxPacketSize);
772                         dev->video_mode.alt_max_pkt_size[i] =
773                             (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
774                         cx231xx_info("Alternate setting %i, max size= %i\n", i,
775                                      dev->video_mode.alt_max_pkt_size[i]);
776                 }
777
778                 /* compute alternate max packet sizes for vbi */
779                 uif =
780                     udev->actconfig->interface[dev->current_pcb_config.
781                                                hs_config_info[0].interface_info.
782                                                vanc_index + 1];
783
784                 dev->vbi_mode.end_point_addr =
785                     le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
786                                 bEndpointAddress);
787
788                 dev->vbi_mode.num_alt = uif->num_altsetting;
789                 cx231xx_info(": EndPoint Addr 0x%x, Alternate settings: %i\n",
790                              dev->vbi_mode.end_point_addr,
791                              dev->vbi_mode.num_alt);
792                 dev->vbi_mode.alt_max_pkt_size =
793                     kmalloc(32 * dev->vbi_mode.num_alt, GFP_KERNEL);
794
795                 if (dev->vbi_mode.alt_max_pkt_size == NULL) {
796                         cx231xx_errdev("out of memory!\n");
797                         cx231xx_devused &= ~(1 << nr);
798                         kfree(dev);
799                         return -ENOMEM;
800                 }
801
802                 for (i = 0; i < dev->vbi_mode.num_alt; i++) {
803                         u16 tmp =
804                             le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
805                                         desc.wMaxPacketSize);
806                         dev->vbi_mode.alt_max_pkt_size[i] =
807                             (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
808                         cx231xx_info("Alternate setting %i, max size= %i\n", i,
809                                      dev->vbi_mode.alt_max_pkt_size[i]);
810                 }
811
812                 /* compute alternate max packet sizes for sliced CC */
813                 uif =
814                     udev->actconfig->interface[dev->current_pcb_config.
815                                                hs_config_info[0].interface_info.
816                                                hanc_index + 1];
817
818                 dev->sliced_cc_mode.end_point_addr =
819                     le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
820                                 bEndpointAddress);
821
822                 dev->sliced_cc_mode.num_alt = uif->num_altsetting;
823                 cx231xx_info(": EndPoint Addr 0x%x, Alternate settings: %i\n",
824                              dev->sliced_cc_mode.end_point_addr,
825                              dev->sliced_cc_mode.num_alt);
826                 dev->sliced_cc_mode.alt_max_pkt_size =
827                     kmalloc(32 * dev->sliced_cc_mode.num_alt, GFP_KERNEL);
828
829                 if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
830                         cx231xx_errdev("out of memory!\n");
831                         cx231xx_devused &= ~(1 << nr);
832                         kfree(dev);
833                         return -ENOMEM;
834                 }
835
836                 for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
837                         u16 tmp =
838                             le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
839                                         desc.wMaxPacketSize);
840                         dev->sliced_cc_mode.alt_max_pkt_size[i] =
841                             (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
842                         cx231xx_info("Alternate setting %i, max size= %i\n", i,
843                                      dev->sliced_cc_mode.alt_max_pkt_size[i]);
844                 }
845
846                 if (dev->current_pcb_config.ts1_source != 0xff) {
847
848                         /* compute alternate max packet sizes for TS1 */
849                         uif =
850                             udev->actconfig->interface[dev->current_pcb_config.
851                                                        hs_config_info[0].
852                                                        interface_info.
853                                                        ts1_index + 1];
854
855                         dev->ts1_mode.end_point_addr =
856                             le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].
857                                         desc.bEndpointAddress);
858
859                         dev->ts1_mode.num_alt = uif->num_altsetting;
860                         cx231xx_info
861                             (": EndPoint Addr 0x%x, Alternate settings: %i\n",
862                              dev->ts1_mode.end_point_addr,
863                              dev->ts1_mode.num_alt);
864                         dev->ts1_mode.alt_max_pkt_size =
865                             kmalloc(32 * dev->ts1_mode.num_alt, GFP_KERNEL);
866
867                         if (dev->ts1_mode.alt_max_pkt_size == NULL) {
868                                 cx231xx_errdev("out of memory!\n");
869                                 cx231xx_devused &= ~(1 << nr);
870                                 kfree(dev);
871                                 return -ENOMEM;
872                         }
873
874                         for (i = 0; i < dev->ts1_mode.num_alt; i++) {
875                                 u16 tmp =
876                                     le16_to_cpu(uif->altsetting[i].
877                                                 endpoint[isoc_pipe].desc.
878                                                 wMaxPacketSize);
879                                 dev->ts1_mode.alt_max_pkt_size[i] =
880                                     (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) +
881                                                       1);
882                                 cx231xx_info
883                                     ("Alternate setting %i, max size= %i\n", i,
884                                      dev->ts1_mode.alt_max_pkt_size[i]);
885                         }
886                 }
887
888         }
889
890         /* save our data pointer in this interface device */
891         usb_set_intfdata(lif, dev);
892
893         /* load other modules required */
894         if ((dev->interface_count - 1) == dev->max_iad_interface_count) {
895                 cx231xx_info("Calling request modules\n");
896                 request_modules(dev);
897         }
898
899         if (skip_interface) {
900                 cx231xx_info("Skipping the interface\n");
901                 return -ENODEV;
902         }
903
904         return 0;
905 }
906
907 /*
908  * cx231xx_usb_disconnect()
909  * called when the device gets diconencted
910  * video device will be unregistered on v4l2_close in case it is still open
911  */
912 static void cx231xx_usb_disconnect(struct usb_interface *interface)
913 {
914         struct cx231xx *dev;
915
916         dev = usb_get_intfdata(interface);
917         usb_set_intfdata(interface, NULL);
918
919         if (!dev)
920                 return;
921
922         /* wait until all current v4l2 io is finished then deallocate
923            resources */
924         mutex_lock(&dev->lock);
925
926         wake_up_interruptible_all(&dev->open);
927
928         if (dev->users) {
929                 cx231xx_warn
930                     ("device /dev/video%d is open! Deregistration and memory "
931                      "deallocation are deferred on close.\n", dev->vdev->num);
932
933                 dev->state |= DEV_MISCONFIGURED;
934                 cx231xx_uninit_isoc(dev);
935                 dev->state |= DEV_DISCONNECTED;
936                 wake_up_interruptible(&dev->wait_frame);
937                 wake_up_interruptible(&dev->wait_stream);
938         } else {
939                 dev->state |= DEV_DISCONNECTED;
940                 cx231xx_release_resources(dev);
941         }
942
943         cx231xx_close_extension(dev);
944
945         mutex_unlock(&dev->lock);
946
947         if (!dev->users) {
948                 kfree(dev->video_mode.alt_max_pkt_size);
949                 kfree(dev->vbi_mode.alt_max_pkt_size);
950                 kfree(dev->sliced_cc_mode.alt_max_pkt_size);
951                 kfree(dev->ts1_mode.alt_max_pkt_size);
952                 kfree(dev);
953         }
954 }
955
956 static struct usb_driver cx231xx_usb_driver = {
957         .name = "cx231xx",
958         .probe = cx231xx_usb_probe,
959         .disconnect = cx231xx_usb_disconnect,
960         .id_table = cx231xx_id_table,
961 };
962
963 static int __init cx231xx_module_init(void)
964 {
965         int result;
966
967         printk(KERN_INFO DRIVER_NAME " v4l2 driver loaded.\n");
968
969         /* register this driver with the USB subsystem */
970         result = usb_register(&cx231xx_usb_driver);
971         if (result)
972                 cx231xx_err(DRIVER_NAME
973                             " usb_register failed. Error number %d.\n", result);
974
975         return result;
976 }
977
978 static void __exit cx231xx_module_exit(void)
979 {
980         /* deregister this driver with the USB subsystem */
981         usb_deregister(&cx231xx_usb_driver);
982 }
983
984 module_init(cx231xx_module_init);
985 module_exit(cx231xx_module_exit);