projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
media/video: explicitly flush request_module work
[deliverable/linux.git] / drivers / media / video / cx231xx / cx231xx-cards.c
CommitLineData
e0d3bafd 1/*
b9255176
SD		 2 cx231xx-cards.c - driver for Conexant Cx23100/101/102
3 USB video capture devices
e0d3bafd
SD		 4
5 Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
b9255176 6 Based on em28xx driver
e0d3bafd
SD		 7
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.
12
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.
17
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.
21 */
22
23#include <linux/init.h>
24#include <linux/module.h>
5a0e3ad6 25#include <linux/slab.h>
e0d3bafd
SD		 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>
33
34#include <media/cx25840.h>
3bfb317f 35#include "dvb-usb-ids.h"
e0d3bafd
SD		 36#include "xc5000.h"
37
38#include "cx231xx.h"
39
40static int tuner = -1;
41module_param(tuner, int, 0444);
42MODULE_PARM_DESC(tuner, "tuner type");
43
64fbf444
PB		 44static int transfer_mode = 1;
45module_param(transfer_mode, int, 0444);
46MODULE_PARM_DESC(transfer_mode, "transfer mode (1-ISO or 0-BULK)");
47
e0d3bafd
SD		 48static unsigned int disable_ir;
49module_param(disable_ir, int, 0444);
50MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
51
52/* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
53static unsigned long cx231xx_devused;
54
55/*
56 * Reset sequences for analog/digital modes
57 */
58
59static struct cx231xx_reg_seq RDE250_XCV_TUNER[] = {
84b5dbf3
MCC		 60 {0x03, 0x01, 10},
61 {0x03, 0x00, 30},
62 {0x03, 0x01, 10},
63 {-1, -1, -1},
e0d3bafd
SD		 64};
65
e0d3bafd
SD		 66/*
67 * Board definitions
68 */
69struct cx231xx_board cx231xx_boards[] = {
e0d3bafd 70 [CX231XX_BOARD_UNKNOWN] = {
6e4f574b
SD		 71 .name = "Unknown CX231xx video grabber",
72 .tuner_type = TUNER_ABSENT,
73 .input = {{
74 .type = CX231XX_VMUX_TELEVISION,
75 .vmux = CX231XX_VIN_3_1,
76 .amux = CX231XX_AMUX_VIDEO,
7ee0a288 77 .gpio = NULL,
6e4f574b
SD		 78 }, {
79 .type = CX231XX_VMUX_COMPOSITE1,
80 .vmux = CX231XX_VIN_2_1,
81 .amux = CX231XX_AMUX_LINE_IN,
7ee0a288 82 .gpio = NULL,
6e4f574b
SD		 83 }, {
84 .type = CX231XX_VMUX_SVIDEO,
85 .vmux = CX231XX_VIN_1_1 |
86 (CX231XX_VIN_1_2 << 8) |
87 CX25840_SVIDEO_ON,
88 .amux = CX231XX_AMUX_LINE_IN,
7ee0a288 89 .gpio = NULL,
6e4f574b
SD		 90 }
91 },
92 },
64fbf444
PB		 93 [CX231XX_BOARD_CNXT_CARRAERA] = {
94 .name = "Conexant Hybrid TV - CARRAERA",
6e4f574b
SD		 95 .tuner_type = TUNER_XC5000,
96 .tuner_addr = 0x61,
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,
88806218 102 .output_mode = OUT_MODE_VIP11,
6e4f574b
SD		 103 .demod_xfer_mode = 0,
104 .ctl_pin_status_mask = 0xFFFFFFC4,
105 .agc_analog_digital_select_gpio = 0x0c,
106 .gpio_pin_status_mask = 0x4001000,
107 .tuner_i2c_master = 1,
108 .demod_i2c_master = 2,
109 .has_dvb = 1,
110 .demod_addr = 0x02,
111 .norm = V4L2_STD_PAL,
112
113 .input = {{
114 .type = CX231XX_VMUX_TELEVISION,
115 .vmux = CX231XX_VIN_3_1,
116 .amux = CX231XX_AMUX_VIDEO,
7ee0a288 117 .gpio = NULL,
6e4f574b
SD		 118 }, {
119 .type = CX231XX_VMUX_COMPOSITE1,
120 .vmux = CX231XX_VIN_2_1,
121 .amux = CX231XX_AMUX_LINE_IN,
7ee0a288 122 .gpio = NULL,
6e4f574b
SD		 123 }, {
124 .type = CX231XX_VMUX_SVIDEO,
125 .vmux = CX231XX_VIN_1_1 |
126 (CX231XX_VIN_1_2 << 8) |
127 CX25840_SVIDEO_ON,
128 .amux = CX231XX_AMUX_LINE_IN,
7ee0a288 129 .gpio = NULL,
6e4f574b
SD		 130 }
131 },
132 },
64fbf444
PB		 133 [CX231XX_BOARD_CNXT_SHELBY] = {
134 .name = "Conexant Hybrid TV - SHELBY",
6e4f574b
SD		 135 .tuner_type = TUNER_XC5000,
136 .tuner_addr = 0x61,
137 .tuner_gpio = RDE250_XCV_TUNER,
138 .tuner_sif_gpio = 0x05,
139 .tuner_scl_gpio = 0x1a,
140 .tuner_sda_gpio = 0x1b,
141 .decoder = CX231XX_AVDECODER,
88806218 142 .output_mode = OUT_MODE_VIP11,
6e4f574b
SD		 143 .demod_xfer_mode = 0,
144 .ctl_pin_status_mask = 0xFFFFFFC4,
145 .agc_analog_digital_select_gpio = 0x0c,
146 .gpio_pin_status_mask = 0x4001000,
147 .tuner_i2c_master = 1,
148 .demod_i2c_master = 2,
149 .has_dvb = 1,
150 .demod_addr = 0x32,
151 .norm = V4L2_STD_NTSC,
152
153 .input = {{
154 .type = CX231XX_VMUX_TELEVISION,
155 .vmux = CX231XX_VIN_3_1,
156 .amux = CX231XX_AMUX_VIDEO,
7ee0a288 157 .gpio = NULL,
6e4f574b
SD		 158 }, {
159 .type = CX231XX_VMUX_COMPOSITE1,
160 .vmux = CX231XX_VIN_2_1,
161 .amux = CX231XX_AMUX_LINE_IN,
7ee0a288 162 .gpio = NULL,
6e4f574b
SD		 163 }, {
164 .type = CX231XX_VMUX_SVIDEO,
165 .vmux = CX231XX_VIN_1_1 |
166 (CX231XX_VIN_1_2 << 8) |
167 CX25840_SVIDEO_ON,
168 .amux = CX231XX_AMUX_LINE_IN,
7ee0a288 169 .gpio = NULL,
6e4f574b
SD		 170 }
171 },
172 },
64fbf444
PB		 173 [CX231XX_BOARD_CNXT_RDE_253S] = {
174 .name = "Conexant Hybrid TV - RDE253S",
175 .tuner_type = TUNER_NXP_TDA18271,
176 .tuner_addr = 0x60,
177 .tuner_gpio = RDE250_XCV_TUNER,
178 .tuner_sif_gpio = 0x05,
179 .tuner_scl_gpio = 0x1a,
180 .tuner_sda_gpio = 0x1b,
181 .decoder = CX231XX_AVDECODER,
88806218 182 .output_mode = OUT_MODE_VIP11,
64fbf444
PB		 183 .demod_xfer_mode = 0,
184 .ctl_pin_status_mask = 0xFFFFFFC4,
185 .agc_analog_digital_select_gpio = 0x1c,
186 .gpio_pin_status_mask = 0x4001000,
187 .tuner_i2c_master = 1,
188 .demod_i2c_master = 2,
189 .has_dvb = 1,
190 .demod_addr = 0x02,
191 .norm = V4L2_STD_PAL,
192
193 .input = {{
194 .type = CX231XX_VMUX_TELEVISION,
195 .vmux = CX231XX_VIN_3_1,
196 .amux = CX231XX_AMUX_VIDEO,
197 .gpio = NULL,
198 }, {
199 .type = CX231XX_VMUX_COMPOSITE1,
200 .vmux = CX231XX_VIN_2_1,
201 .amux = CX231XX_AMUX_LINE_IN,
202 .gpio = NULL,
203 }, {
204 .type = CX231XX_VMUX_SVIDEO,
205 .vmux = CX231XX_VIN_1_1 |
206 (CX231XX_VIN_1_2 << 8) |
207 CX25840_SVIDEO_ON,
208 .amux = CX231XX_AMUX_LINE_IN,
209 .gpio = NULL,
210 }
211 },
212 },
213
214 [CX231XX_BOARD_CNXT_RDU_253S] = {
215 .name = "Conexant Hybrid TV - RDU253S",
216 .tuner_type = TUNER_NXP_TDA18271,
217 .tuner_addr = 0x60,
218 .tuner_gpio = RDE250_XCV_TUNER,
219 .tuner_sif_gpio = 0x05,
220 .tuner_scl_gpio = 0x1a,
221 .tuner_sda_gpio = 0x1b,
222 .decoder = CX231XX_AVDECODER,
88806218 223 .output_mode = OUT_MODE_VIP11,
64fbf444
PB		 224 .demod_xfer_mode = 0,
225 .ctl_pin_status_mask = 0xFFFFFFC4,
226 .agc_analog_digital_select_gpio = 0x1c,
227 .gpio_pin_status_mask = 0x4001000,
228 .tuner_i2c_master = 1,
229 .demod_i2c_master = 2,
230 .has_dvb = 1,
231 .demod_addr = 0x02,
232 .norm = V4L2_STD_PAL,
233
234 .input = {{
235 .type = CX231XX_VMUX_TELEVISION,
236 .vmux = CX231XX_VIN_3_1,
237 .amux = CX231XX_AMUX_VIDEO,
238 .gpio = NULL,
239 }, {
240 .type = CX231XX_VMUX_COMPOSITE1,
241 .vmux = CX231XX_VIN_2_1,
242 .amux = CX231XX_AMUX_LINE_IN,
243 .gpio = NULL,
244 }, {
245 .type = CX231XX_VMUX_SVIDEO,
246 .vmux = CX231XX_VIN_1_1 |
247 (CX231XX_VIN_1_2 << 8) |
248 CX25840_SVIDEO_ON,
249 .amux = CX231XX_AMUX_LINE_IN,
250 .gpio = NULL,
251 }
252 },
253 },
254 [CX231XX_BOARD_CNXT_VIDEO_GRABBER] = {
255 .name = "Conexant VIDEO GRABBER",
9f51259f 256 .tuner_type = TUNER_ABSENT,
64fbf444 257 .decoder = CX231XX_AVDECODER,
88806218 258 .output_mode = OUT_MODE_VIP11,
64fbf444
PB		 259 .ctl_pin_status_mask = 0xFFFFFFC4,
260 .agc_analog_digital_select_gpio = 0x1c,
261 .gpio_pin_status_mask = 0x4001000,
64fbf444
PB		 262 .norm = V4L2_STD_PAL,
263
264 .input = {{
265 .type = CX231XX_VMUX_COMPOSITE1,
266 .vmux = CX231XX_VIN_2_1,
267 .amux = CX231XX_AMUX_LINE_IN,
268 .gpio = NULL,
269 }, {
270 .type = CX231XX_VMUX_SVIDEO,
271 .vmux = CX231XX_VIN_1_1 |
272 (CX231XX_VIN_1_2 << 8) |
273 CX25840_SVIDEO_ON,
274 .amux = CX231XX_AMUX_LINE_IN,
275 .gpio = NULL,
64fbf444
PB		 276 }
277 },
278 },
279 [CX231XX_BOARD_CNXT_RDE_250] = {
280 .name = "Conexant Hybrid TV - rde 250",
281 .tuner_type = TUNER_XC5000,
282 .tuner_addr = 0x61,
283 .tuner_gpio = RDE250_XCV_TUNER,
284 .tuner_sif_gpio = 0x05,
285 .tuner_scl_gpio = 0x1a,
286 .tuner_sda_gpio = 0x1b,
287 .decoder = CX231XX_AVDECODER,
88806218 288 .output_mode = OUT_MODE_VIP11,
64fbf444
PB		 289 .demod_xfer_mode = 0,
290 .ctl_pin_status_mask = 0xFFFFFFC4,
291 .agc_analog_digital_select_gpio = 0x0c,
292 .gpio_pin_status_mask = 0x4001000,
293 .tuner_i2c_master = 1,
294 .demod_i2c_master = 2,
295 .has_dvb = 1,
296 .demod_addr = 0x02,
297 .norm = V4L2_STD_PAL,
298
299 .input = {{
300 .type = CX231XX_VMUX_TELEVISION,
301 .vmux = CX231XX_VIN_2_1,
302 .amux = CX231XX_AMUX_VIDEO,
303 .gpio = NULL,
304 }
305 },
306 },
307 [CX231XX_BOARD_CNXT_RDU_250] = {
308 .name = "Conexant Hybrid TV - RDU 250",
309 .tuner_type = TUNER_XC5000,
310 .tuner_addr = 0x61,
311 .tuner_gpio = RDE250_XCV_TUNER,
312 .tuner_sif_gpio = 0x05,
313 .tuner_scl_gpio = 0x1a,
314 .tuner_sda_gpio = 0x1b,
315 .decoder = CX231XX_AVDECODER,
88806218 316 .output_mode = OUT_MODE_VIP11,
64fbf444
PB		 317 .demod_xfer_mode = 0,
318 .ctl_pin_status_mask = 0xFFFFFFC4,
319 .agc_analog_digital_select_gpio = 0x0c,
320 .gpio_pin_status_mask = 0x4001000,
321 .tuner_i2c_master = 1,
322 .demod_i2c_master = 2,
323 .has_dvb = 1,
324 .demod_addr = 0x32,
325 .norm = V4L2_STD_NTSC,
326
327 .input = {{
328 .type = CX231XX_VMUX_TELEVISION,
329 .vmux = CX231XX_VIN_2_1,
330 .amux = CX231XX_AMUX_VIDEO,
331 .gpio = NULL,
332 }
333 },
334 },
1a50fdde
MK		 335 [CX231XX_BOARD_HAUPPAUGE_EXETER] = {
336 .name = "Hauppauge EXETER",
337 .tuner_type = TUNER_NXP_TDA18271,
338 .tuner_addr = 0x60,
339 .tuner_gpio = RDE250_XCV_TUNER,
340 .tuner_sif_gpio = 0x05,
341 .tuner_scl_gpio = 0x1a,
342 .tuner_sda_gpio = 0x1b,
343 .decoder = CX231XX_AVDECODER,
88806218 344 .output_mode = OUT_MODE_VIP11,
1a50fdde
MK		 345 .demod_xfer_mode = 0,
346 .ctl_pin_status_mask = 0xFFFFFFC4,
347 .agc_analog_digital_select_gpio = 0x0c,
348 .gpio_pin_status_mask = 0x4001000,
349 .tuner_i2c_master = 1,
350 .demod_i2c_master = 2,
351 .has_dvb = 1,
352 .demod_addr = 0x0e,
353 .norm = V4L2_STD_NTSC,
354
355 .input = {{
356 .type = CX231XX_VMUX_TELEVISION,
357 .vmux = CX231XX_VIN_3_1,
358 .amux = CX231XX_AMUX_VIDEO,
359 .gpio = 0,
360 }, {
361 .type = CX231XX_VMUX_COMPOSITE1,
362 .vmux = CX231XX_VIN_2_1,
363 .amux = CX231XX_AMUX_LINE_IN,
364 .gpio = 0,
365 }, {
366 .type = CX231XX_VMUX_SVIDEO,
367 .vmux = CX231XX_VIN_1_1 |
368 (CX231XX_VIN_1_2 << 8) |
369 CX25840_SVIDEO_ON,
370 .amux = CX231XX_AMUX_LINE_IN,
371 .gpio = 0,
372 } },
373 },
4270c3ca
DH		 374 [CX231XX_BOARD_HAUPPAUGE_USBLIVE2] = {
375 .name = "Hauppauge USB Live 2",
376 .tuner_type = TUNER_ABSENT,
377 .decoder = CX231XX_AVDECODER,
88806218 378 .output_mode = OUT_MODE_VIP11,
4270c3ca
DH		 379 .demod_xfer_mode = 0,
380 .ctl_pin_status_mask = 0xFFFFFFC4,
381 .agc_analog_digital_select_gpio = 0x0c,
382 .gpio_pin_status_mask = 0x4001000,
383 .norm = V4L2_STD_NTSC,
384 .input = {{
385 .type = CX231XX_VMUX_COMPOSITE1,
386 .vmux = CX231XX_VIN_2_1,
387 .amux = CX231XX_AMUX_LINE_IN,
388 .gpio = 0,
389 }, {
390 .type = CX231XX_VMUX_SVIDEO,
391 .vmux = CX231XX_VIN_1_1 |
392 (CX231XX_VIN_1_2 << 8) |
393 CX25840_SVIDEO_ON,
394 .amux = CX231XX_AMUX_LINE_IN,
395 .gpio = 0,
396 } },
397 },
e0d3bafd
SD		 398};
399const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
400
401/* table of devices that work with this driver */
84b5dbf3 402struct usb_device_id cx231xx_id_table[] = {
ed559edf 403 {USB_DEVICE(0x0572, 0x5A3C),
84b5dbf3 404 .driver_info = CX231XX_BOARD_UNKNOWN},
1a50fdde
MK		 405 {USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x4000,0x4fff),
406 .driver_info = CX231XX_BOARD_UNKNOWN},
84b5dbf3 407 {USB_DEVICE(0x0572, 0x58A2),
64fbf444 408 .driver_info = CX231XX_BOARD_CNXT_CARRAERA},
ed559edf 409 {USB_DEVICE(0x0572, 0x58A1),
64fbf444
PB		 410 .driver_info = CX231XX_BOARD_CNXT_SHELBY},
411 {USB_DEVICE(0x0572, 0x58A4),
412 .driver_info = CX231XX_BOARD_CNXT_RDE_253S},
413 {USB_DEVICE(0x0572, 0x58A5),
414 .driver_info = CX231XX_BOARD_CNXT_RDU_253S},
415 {USB_DEVICE(0x0572, 0x58A6),
416 .driver_info = CX231XX_BOARD_CNXT_VIDEO_GRABBER},
417 {USB_DEVICE(0x0572, 0x589E),
418 .driver_info = CX231XX_BOARD_CNXT_RDE_250},
419 {USB_DEVICE(0x0572, 0x58A0),
84b5dbf3 420 .driver_info = CX231XX_BOARD_CNXT_RDU_250},
1a50fdde
MK		 421 {USB_DEVICE(0x2040, 0xb120),
422 .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
d78148fb
DH		 423 {USB_DEVICE(0x2040, 0xb140),
424 .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
4270c3ca
DH		 425 {USB_DEVICE(0x2040, 0xc200),
426 .driver_info = CX231XX_BOARD_HAUPPAUGE_USBLIVE2},
84b5dbf3 427 {},
e0d3bafd 428};
84b5dbf3 429
e0d3bafd
SD		 430MODULE_DEVICE_TABLE(usb, cx231xx_id_table);
431
432/* cx231xx_tuner_callback
433 * will be used to reset XC5000 tuner using GPIO pin
434 */
435
436int cx231xx_tuner_callback(void *ptr, int component, int command, int arg)
437{
438 int rc = 0;
439 struct cx231xx *dev = ptr;
440
84b5dbf3
MCC		 441 if (dev->tuner_type == TUNER_XC5000) {
442 if (command == XC5000_TUNER_RESET) {
443 cx231xx_info
b9255176
SD		 444 ("Tuner CB: RESET: cmd %d : tuner type %d \n",
445 command, dev->tuner_type);
84b5dbf3
MCC		 446 cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
447 1);
448 msleep(10);
449 cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
450 0);
451 msleep(330);
452 cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
453 1);
454 msleep(10);
455 }
456 }
e0d3bafd
SD		 457 return rc;
458}
459EXPORT_SYMBOL_GPL(cx231xx_tuner_callback);
460
64fbf444
PB		 461void cx231xx_reset_out(struct cx231xx *dev)
462{
463 cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
464 msleep(200);
465 cx231xx_set_gpio_value(dev, CX23417_RESET, 0);
466 msleep(200);
467 cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
468}
469void cx231xx_enable_OSC(struct cx231xx *dev)
470{
471 cx231xx_set_gpio_value(dev, CX23417_OSC_EN, 1);
472}
473void cx231xx_sleep_s5h1432(struct cx231xx *dev)
474{
475 cx231xx_set_gpio_value(dev, SLEEP_S5H1432, 0);
476}
477
b9255176 478static inline void cx231xx_set_model(struct cx231xx *dev)
e0d3bafd
SD		 479{
480 memcpy(&dev->board, &cx231xx_boards[dev->model], sizeof(dev->board));
481}
482
483/* Since cx231xx_pre_card_setup() requires a proper dev->model,
484 * this won't work for boards with generic PCI IDs
485 */
486void cx231xx_pre_card_setup(struct cx231xx *dev)
487{
488
489 cx231xx_set_model(dev);
490
491 cx231xx_info("Identified as %s (card=%d)\n",
84b5dbf3 492 dev->board.name, dev->model);
e0d3bafd 493
6e4f574b 494 /* set the direction for GPIO pins */
c10469c6
MCC		 495 if (dev->board.tuner_gpio) {
496 cx231xx_set_gpio_direction(dev, dev->board.tuner_gpio->bit, 1);
497 cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit, 1);
78bb6df6
MCC		 498 }
499 if (dev->board.tuner_sif_gpio >= 0)
c10469c6 500 cx231xx_set_gpio_direction(dev, dev->board.tuner_sif_gpio, 1);
e0d3bafd 501
78bb6df6 502 /* request some modules if any required */
e0d3bafd 503
84b5dbf3 504 /* set the mode to Analog mode initially */
e0d3bafd
SD		 505 cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
506
507 /* Unlock device */
508 /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
509
510}
511
e0d3bafd
SD		 512static void cx231xx_config_tuner(struct cx231xx *dev)
513{
84b5dbf3
MCC		 514 struct tuner_setup tun_setup;
515 struct v4l2_frequency f;
e0d3bafd
SD		 516
517 if (dev->tuner_type == TUNER_ABSENT)
518 return;
519
520 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
521 tun_setup.type = dev->tuner_type;
522 tun_setup.addr = dev->tuner_addr;
523 tun_setup.tuner_callback = cx231xx_tuner_callback;
524
b1196126
SD		 525 tuner_call(dev, tuner, s_type_addr, &tun_setup);
526
e0d3bafd 527#if 0
84b5dbf3 528 if (tun_setup.type == TUNER_XC5000) {
e0d3bafd
SD		 529 static struct xc2028_ctrl ctrl = {
530 .fname = XC5000_DEFAULT_FIRMWARE,
531 .max_len = 64,
84b5dbf3 532 .demod = 0;
e0d3bafd
SD		 533 };
534 struct v4l2_priv_tun_config cfg = {
535 .tuner = dev->tuner_type,
536 .priv = &ctrl,
537 };
b1196126 538 tuner_call(dev, tuner, s_config, &cfg);
e0d3bafd
SD		 539 }
540#endif
e0d3bafd
SD		 541 /* configure tuner */
542 f.tuner = 0;
543 f.type = V4L2_TUNER_ANALOG_TV;
84b5dbf3 544 f.frequency = 9076; /* just a magic number */
e0d3bafd 545 dev->ctl_freq = f.frequency;
b1196126 546 call_all(dev, tuner, s_frequency, &f);
e0d3bafd 547
b1196126 548}
e0d3bafd 549
e0d3bafd
SD		 550void cx231xx_card_setup(struct cx231xx *dev)
551{
b1196126 552
e0d3bafd
SD		 553 cx231xx_set_model(dev);
554
555 dev->tuner_type = cx231xx_boards[dev->model].tuner_type;
556 if (cx231xx_boards[dev->model].tuner_addr)
557 dev->tuner_addr = cx231xx_boards[dev->model].tuner_addr;
558
e0d3bafd 559 /* request some modules */
84b5dbf3 560 if (dev->board.decoder == CX231XX_AVDECODER) {
e6574f2f
HV		 561 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
562 &dev->i2c_bus[0].i2c_adap,
1532a070 563 NULL, "cx25840", 0x88 >> 1, NULL);
b1196126
SD		 564 if (dev->sd_cx25840 == NULL)
565 cx231xx_info("cx25840 subdev registration failure\n");
cc26b076 566 cx25840_call(dev, core, load_fw);
b1196126 567
84b5dbf3 568 }
b1196126 569
e3e0aaaa
DH		 570 /* Initialize the tuner */
571 if (dev->board.tuner_type != TUNER_ABSENT) {
572 dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1a4aa920 573 &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
1532a070 574 NULL, "tuner",
e3e0aaaa
DH		 575 dev->tuner_addr, NULL);
576 if (dev->sd_tuner == NULL)
577 cx231xx_info("tuner subdev registration failure\n");
578 else
64fbf444 579 cx231xx_config_tuner(dev);
84b5dbf3 580 }
e0d3bafd
SD		 581}
582
e0d3bafd
SD		 583/*
584 * cx231xx_config()
585 * inits registers with sane defaults
586 */
587int cx231xx_config(struct cx231xx *dev)
588{
84b5dbf3 589 /* TBD need to add cx231xx specific code */
e0d3bafd
SD		 590 dev->mute = 1; /* maybe not the right place... */
591 dev->volume = 0x1f;
592
593 return 0;
594}
595
596/*
597 * cx231xx_config_i2c()
598 * configure i2c attached devices
599 */
600void cx231xx_config_i2c(struct cx231xx *dev)
601{
5325b427 602 /* u32 input = INPUT(dev->video_input)->vmux; */
e0d3bafd 603
b1196126 604 call_all(dev, video, s_stream, 1);
e0d3bafd
SD		 605}
606
607/*
608 * cx231xx_realease_resources()
609 * unregisters the v4l2,i2c and usb devices
610 * called when the device gets disconected or at module unload
611*/
612void cx231xx_release_resources(struct cx231xx *dev)
613{
e0d3bafd
SD		 614 cx231xx_release_analog_resources(dev);
615
84b5dbf3 616 cx231xx_remove_from_devlist(dev);
e0d3bafd 617
84b5dbf3 618 cx231xx_dev_uninit(dev);
e0d3bafd
SD		 619
620 usb_put_dev(dev->udev);
621
622 /* Mark device as unused */
84b5dbf3 623 cx231xx_devused &= ~(1 << dev->devno);
e0d3bafd
SD		 624}
625
e0d3bafd
SD		 626/*
627 * cx231xx_init_dev()
628 * allocates and inits the device structs, registers i2c bus and v4l device
629 */
630static int cx231xx_init_dev(struct cx231xx **devhandle, struct usb_device *udev,
84b5dbf3 631 int minor)
e0d3bafd
SD		 632{
633 struct cx231xx *dev = *devhandle;
634 int retval = -ENOMEM;
635 int errCode;
636 unsigned int maxh, maxw;
637
638 dev->udev = udev;
639 mutex_init(&dev->lock);
640 mutex_init(&dev->ctrl_urb_lock);
84b5dbf3 641 mutex_init(&dev->gpio_i2c_lock);
64fbf444 642 mutex_init(&dev->i2c_lock);
e0d3bafd 643
84b5dbf3
MCC		 644 spin_lock_init(&dev->video_mode.slock);
645 spin_lock_init(&dev->vbi_mode.slock);
646 spin_lock_init(&dev->sliced_cc_mode.slock);
e0d3bafd
SD		 647
648 init_waitqueue_head(&dev->open);
649 init_waitqueue_head(&dev->wait_frame);
650 init_waitqueue_head(&dev->wait_stream);
651
84b5dbf3
MCC		 652 dev->cx231xx_read_ctrl_reg = cx231xx_read_ctrl_reg;
653 dev->cx231xx_write_ctrl_reg = cx231xx_write_ctrl_reg;
654 dev->cx231xx_send_usb_command = cx231xx_send_usb_command;
655 dev->cx231xx_gpio_i2c_read = cx231xx_gpio_i2c_read;
656 dev->cx231xx_gpio_i2c_write = cx231xx_gpio_i2c_write;
e0d3bafd 657
84b5dbf3
MCC		 658 /* Query cx231xx to find what pcb config it is related to */
659 initialize_cx231xx(dev);
e0d3bafd 660
64fbf444
PB		 661 /*To workaround error number=-71 on EP0 for VideoGrabber,
662 need set alt here.*/
4270c3ca
DH		 663 if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER ||
664 dev->model == CX231XX_BOARD_HAUPPAUGE_USBLIVE2) {
64fbf444
PB		 665 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
666 cx231xx_set_alt_setting(dev, INDEX_VANC, 1);
667 }
84b5dbf3 668 /* Cx231xx pre card setup */
e0d3bafd
SD		 669 cx231xx_pre_card_setup(dev);
670
671 errCode = cx231xx_config(dev);
672 if (errCode) {
673 cx231xx_errdev("error configuring device\n");
674 return -ENOMEM;
675 }
676
84b5dbf3 677 /* set default norm */
e0d3bafd
SD		 678 dev->norm = dev->board.norm;
679
680 /* register i2c bus */
681 errCode = cx231xx_dev_init(dev);
682 if (errCode < 0) {
64fbf444 683 cx231xx_dev_uninit(dev);
e0d3bafd 684 cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
84b5dbf3 685 __func__, errCode);
e0d3bafd
SD		 686 return errCode;
687 }
688
689 /* Do board specific init */
690 cx231xx_card_setup(dev);
691
692 /* configure the device */
693 cx231xx_config_i2c(dev);
694
695 maxw = norm_maxw(dev);
696 maxh = norm_maxh(dev);
697
698 /* set default image size */
699 dev->width = maxw;
700 dev->height = maxh;
701 dev->interlaced = 0;
e0d3bafd
SD		 702 dev->video_input = 0;
703
704 errCode = cx231xx_config(dev);
705 if (errCode < 0) {
706 cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
84b5dbf3 707 __func__, errCode);
e0d3bafd
SD		 708 return errCode;
709 }
710
711 /* init video dma queues */
712 INIT_LIST_HEAD(&dev->video_mode.vidq.active);
713 INIT_LIST_HEAD(&dev->video_mode.vidq.queued);
714
84b5dbf3 715 /* init vbi dma queues */
e0d3bafd
SD		 716 INIT_LIST_HEAD(&dev->vbi_mode.vidq.active);
717 INIT_LIST_HEAD(&dev->vbi_mode.vidq.queued);
718
719 /* Reset other chips required if they are tied up with GPIO pins */
84b5dbf3 720 cx231xx_add_into_devlist(dev);
e0d3bafd 721
64fbf444 722 if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER) {
2b43db32 723 printk(KERN_INFO "attach 417 %d\n", dev->model);
64fbf444
PB		 724 if (cx231xx_417_register(dev) < 0) {
725 printk(KERN_ERR
726 "%s() Failed to register 417 on VID_B\n",
727 __func__);
728 }
729 }
730
e0d3bafd
SD		 731 retval = cx231xx_register_analog_devices(dev);
732 if (retval < 0) {
733 cx231xx_release_resources(dev);
734 goto fail_reg_devices;
735 }
736
737 cx231xx_init_extension(dev);
738
739 return 0;
740
b9255176 741fail_reg_devices:
e0d3bafd
SD		 742 mutex_unlock(&dev->lock);
743 return retval;
744}
745
746#if defined(CONFIG_MODULES) && defined(MODULE)
747static void request_module_async(struct work_struct *work)
748{
749 struct cx231xx *dev = container_of(work,
84b5dbf3 750 struct cx231xx, request_module_wk);
e0d3bafd
SD		 751
752 if (dev->has_alsa_audio)
753 request_module("cx231xx-alsa");
754
755 if (dev->board.has_dvb)
756 request_module("cx231xx-dvb");
757
758}
759
760static void request_modules(struct cx231xx *dev)
761{
762 INIT_WORK(&dev->request_module_wk, request_module_async);
763 schedule_work(&dev->request_module_wk);
764}
707bcf32
TH		 765
766static void flush_request_modules(struct cx231xx *dev)
767{
768 flush_work_sync(&dev->request_module_wk);
769}
e0d3bafd
SD		 770#else
771#define request_modules(dev)
707bcf32 772#define flush_request_modules(dev)
e0d3bafd
SD		 773#endif /* CONFIG_MODULES */
774
e0d3bafd
SD		 775/*
776 * cx231xx_usb_probe()
777 * checks for supported devices
778 */
779static int cx231xx_usb_probe(struct usb_interface *interface,
84b5dbf3 780 const struct usb_device_id *id)
e0d3bafd
SD		 781{
782 struct usb_device *udev;
783 struct usb_interface *uif;
784 struct cx231xx *dev = NULL;
785 int retval = -ENODEV;
d73abcff 786 int nr = 0, ifnum;
e0d3bafd
SD		 787 int i, isoc_pipe = 0;
788 char *speed;
789 char descr[255] = "";
84b5dbf3 790 struct usb_interface *lif = NULL;
84b5dbf3 791 struct usb_interface_assoc_descriptor *assoc_desc;
e0d3bafd
SD		 792
793 udev = usb_get_dev(interface_to_usbdev(interface));
794 ifnum = interface->altsetting[0].desc.bInterfaceNumber;
795
10e4ebb6 796 if (ifnum == 1) {
90960744
MCC		 797 /*
798 * Interface number 0 - IR interface
799 */
84b5dbf3
MCC		 800 /* Check to see next free device and mark as used */
801 nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
802 cx231xx_devused |= 1 << nr;
803
804 if (nr >= CX231XX_MAXBOARDS) {
64fbf444
PB		 805 cx231xx_err(DRIVER_NAME
806 ": Supports only %i cx231xx boards.\n", CX231XX_MAXBOARDS);
84b5dbf3
MCC		 807 cx231xx_devused &= ~(1 << nr);
808 return -ENOMEM;
809 }
810
811 /* allocate memory for our device state and initialize it */
812 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
813 if (dev == NULL) {
814 cx231xx_err(DRIVER_NAME ": out of memory!\n");
815 cx231xx_devused &= ~(1 << nr);
816 return -ENOMEM;
817 }
818
819 snprintf(dev->name, 29, "cx231xx #%d", nr);
820 dev->devno = nr;
821 dev->model = id->driver_info;
822 dev->video_mode.alt = -1;
823 dev->interface_count++;
824
825 /* reset gpio dir and value */
826 dev->gpio_dir = 0;
827 dev->gpio_val = 0;
828 dev->xc_fw_load_done = 0;
e0d3bafd 829 dev->has_alsa_audio = 1;
84b5dbf3 830 dev->power_mode = -1;
64fbf444 831 atomic_set(&dev->devlist_count, 0);
84b5dbf3 832
b9255176
SD		 833 /* 0 - vbi ; 1 -sliced cc mode */
834 dev->vbi_or_sliced_cc_mode = 0;
84b5dbf3
MCC		 835
836 /* get maximum no.of IAD interfaces */
837 assoc_desc = udev->actconfig->intf_assoc[0];
838 dev->max_iad_interface_count = assoc_desc->bInterfaceCount;
84b5dbf3
MCC		 839
840 /* init CIR module TBD */
841
842 /* store the current interface */
843 lif = interface;
844
64fbf444
PB		 845 /*mode_tv: digital=1 or analog=0*/
846 dev->mode_tv = 0;
847
848 dev->USE_ISO = transfer_mode;
849
90960744
MCC		 850 switch (udev->speed) {
851 case USB_SPEED_LOW:
852 speed = "1.5";
853 break;
854 case USB_SPEED_UNKNOWN:
855 case USB_SPEED_FULL:
856 speed = "12";
857 break;
858 case USB_SPEED_HIGH:
859 speed = "480";
860 break;
861 default:
862 speed = "unknown";
84b5dbf3
MCC		 863 }
864
90960744
MCC		 865 if (udev->manufacturer)
866 strlcpy(descr, udev->manufacturer, sizeof(descr));
84b5dbf3 867
90960744
MCC		 868 if (udev->product) {
869 if (*descr)
870 strlcat(descr, " ", sizeof(descr));
871 strlcat(descr, udev->product, sizeof(descr));
84b5dbf3 872 }
90960744
MCC		 873 if (*descr)
874 strlcat(descr, " ", sizeof(descr));
84b5dbf3 875
90960744
MCC		 876 cx231xx_info("New device %s@ %s Mbps "
877 "(%04x:%04x) with %d interfaces\n",
878 descr,
879 speed,
880 le16_to_cpu(udev->descriptor.idVendor),
881 le16_to_cpu(udev->descriptor.idProduct),
882 dev->max_iad_interface_count);
84b5dbf3
MCC		 883
884 /* store the interface 0 back */
885 lif = udev->actconfig->interface[0];
886
887 /* increment interface count */
888 dev->interface_count++;
889
890 /* get device number */
891 nr = dev->devno;
892
10e4ebb6
MCC		 893 assoc_desc = udev->actconfig->intf_assoc[0];
894 if (assoc_desc->bFirstInterface != ifnum) {
895 cx231xx_err(DRIVER_NAME ": Not found "
896 "matching IAD interface\n");
897 return -ENODEV;
84b5dbf3 898 }
10e4ebb6 899 } else {
90960744 900 return -ENODEV;
10e4ebb6 901 }
e0d3bafd 902
90960744 903 cx231xx_info("registering interface %d\n", ifnum);
e0d3bafd 904
90960744
MCC		 905 /* save our data pointer in this interface device */
906 usb_set_intfdata(lif, dev);
e0d3bafd 907
90960744
MCC		 908 /*
909 * AV device initialization - only done at the last interface
910 */
b1196126 911
90960744 912 /* Create v4l2 device */
7231748a 913 retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
90960744
MCC		 914 if (retval) {
915 cx231xx_errdev("v4l2_device_register failed\n");
916 cx231xx_devused &= ~(1 << nr);
917 kfree(dev);
64fbf444 918 dev = NULL;
90960744
MCC		 919 return -EIO;
920 }
90960744
MCC		 921 /* allocate device struct */
922 retval = cx231xx_init_dev(&dev, udev, nr);
923 if (retval) {
924 cx231xx_devused &= ~(1 << dev->devno);
925 v4l2_device_unregister(&dev->v4l2_dev);
926 kfree(dev);
64fbf444
PB		 927 dev = NULL;
928 usb_set_intfdata(lif, NULL);
929
90960744
MCC		 930 return retval;
931 }
84b5dbf3 932
90960744
MCC		 933 /* compute alternate max packet sizes for video */
934 uif = udev->actconfig->interface[dev->current_pcb_config.
935 hs_config_info[0].interface_info.video_index + 1];
936
937 dev->video_mode.end_point_addr = le16_to_cpu(uif->altsetting[0].
938 endpoint[isoc_pipe].desc.bEndpointAddress);
939
940 dev->video_mode.num_alt = uif->num_altsetting;
941 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
942 dev->video_mode.end_point_addr,
943 dev->video_mode.num_alt);
944 dev->video_mode.alt_max_pkt_size =
945 kmalloc(32 * dev->video_mode.num_alt, GFP_KERNEL);
946
947 if (dev->video_mode.alt_max_pkt_size == NULL) {
948 cx231xx_errdev("out of memory!\n");
949 cx231xx_devused &= ~(1 << nr);
950 v4l2_device_unregister(&dev->v4l2_dev);
951 kfree(dev);
64fbf444 952 dev = NULL;
90960744
MCC		 953 return -ENOMEM;
954 }
84b5dbf3 955
90960744
MCC		 956 for (i = 0; i < dev->video_mode.num_alt; i++) {
957 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
958 desc.wMaxPacketSize);
959 dev->video_mode.alt_max_pkt_size[i] =
960 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
961 cx231xx_info("Alternate setting %i, max size= %i\n", i,
962 dev->video_mode.alt_max_pkt_size[i]);
963 }
84b5dbf3 964
90960744
MCC		 965 /* compute alternate max packet sizes for vbi */
966 uif = udev->actconfig->interface[dev->current_pcb_config.
967 hs_config_info[0].interface_info.
968 vanc_index + 1];
969
970 dev->vbi_mode.end_point_addr =
971 le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
972 bEndpointAddress);
973
974 dev->vbi_mode.num_alt = uif->num_altsetting;
975 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
976 dev->vbi_mode.end_point_addr,
977 dev->vbi_mode.num_alt);
978 dev->vbi_mode.alt_max_pkt_size =
979 kmalloc(32 * dev->vbi_mode.num_alt, GFP_KERNEL);
980
981 if (dev->vbi_mode.alt_max_pkt_size == NULL) {
982 cx231xx_errdev("out of memory!\n");
983 cx231xx_devused &= ~(1 << nr);
984 v4l2_device_unregister(&dev->v4l2_dev);
985 kfree(dev);
64fbf444 986 dev = NULL;
90960744
MCC		 987 return -ENOMEM;
988 }
84b5dbf3 989
90960744
MCC		 990 for (i = 0; i < dev->vbi_mode.num_alt; i++) {
991 u16 tmp =
992 le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
993 desc.wMaxPacketSize);
994 dev->vbi_mode.alt_max_pkt_size[i] =
995 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
996 cx231xx_info("Alternate setting %i, max size= %i\n", i,
997 dev->vbi_mode.alt_max_pkt_size[i]);
998 }
84b5dbf3 999
90960744
MCC		 1000 /* compute alternate max packet sizes for sliced CC */
1001 uif = udev->actconfig->interface[dev->current_pcb_config.
1002 hs_config_info[0].interface_info.
1003 hanc_index + 1];
1004
1005 dev->sliced_cc_mode.end_point_addr =
1006 le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
1007 bEndpointAddress);
1008
1009 dev->sliced_cc_mode.num_alt = uif->num_altsetting;
1010 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1011 dev->sliced_cc_mode.end_point_addr,
1012 dev->sliced_cc_mode.num_alt);
1013 dev->sliced_cc_mode.alt_max_pkt_size =
1014 kmalloc(32 * dev->sliced_cc_mode.num_alt, GFP_KERNEL);
1015
1016 if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
1017 cx231xx_errdev("out of memory!\n");
1018 cx231xx_devused &= ~(1 << nr);
1019 v4l2_device_unregister(&dev->v4l2_dev);
1020 kfree(dev);
64fbf444 1021 dev = NULL;
90960744
MCC		 1022 return -ENOMEM;
1023 }
84b5dbf3 1024
90960744
MCC		 1025 for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
1026 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
1027 desc.wMaxPacketSize);
1028 dev->sliced_cc_mode.alt_max_pkt_size[i] =
1029 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1030 cx231xx_info("Alternate setting %i, max size= %i\n", i,
1031 dev->sliced_cc_mode.alt_max_pkt_size[i]);
1032 }
84b5dbf3 1033
90960744
MCC		 1034 if (dev->current_pcb_config.ts1_source != 0xff) {
1035 /* compute alternate max packet sizes for TS1 */
1036 uif = udev->actconfig->interface[dev->current_pcb_config.
1037 hs_config_info[0].
1038 interface_info.
1039 ts1_index + 1];
84b5dbf3 1040
90960744
MCC		 1041 dev->ts1_mode.end_point_addr =
1042 le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].
1043 desc.bEndpointAddress);
84b5dbf3 1044
90960744
MCC		 1045 dev->ts1_mode.num_alt = uif->num_altsetting;
1046 cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
1047 dev->ts1_mode.end_point_addr,
1048 dev->ts1_mode.num_alt);
1049 dev->ts1_mode.alt_max_pkt_size =
1050 kmalloc(32 * dev->ts1_mode.num_alt, GFP_KERNEL);
84b5dbf3 1051
90960744 1052 if (dev->ts1_mode.alt_max_pkt_size == NULL) {
84b5dbf3
MCC		 1053 cx231xx_errdev("out of memory!\n");
1054 cx231xx_devused &= ~(1 << nr);
b1196126 1055 v4l2_device_unregister(&dev->v4l2_dev);
84b5dbf3 1056 kfree(dev);
64fbf444 1057 dev = NULL;
84b5dbf3
MCC		 1058 return -ENOMEM;
1059 }
1060
90960744
MCC		 1061 for (i = 0; i < dev->ts1_mode.num_alt; i++) {
1062 u16 tmp = le16_to_cpu(uif->altsetting[i].
84b5dbf3
MCC		 1063 endpoint[isoc_pipe].desc.
1064 wMaxPacketSize);
90960744
MCC		 1065 dev->ts1_mode.alt_max_pkt_size[i] =
1066 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1067 cx231xx_info("Alternate setting %i, max size= %i\n", i,
84b5dbf3 1068 dev->ts1_mode.alt_max_pkt_size[i]);
84b5dbf3 1069 }
84b5dbf3 1070 }
e0d3bafd 1071
64fbf444
PB		 1072 if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER) {
1073 cx231xx_enable_OSC(dev);
1074 cx231xx_reset_out(dev);
1075 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
1076 }
1077
1078 if (dev->model == CX231XX_BOARD_CNXT_RDE_253S)
1079 cx231xx_sleep_s5h1432(dev);
1080
84b5dbf3 1081 /* load other modules required */
90960744 1082 request_modules(dev);
e0d3bafd
SD		 1083
1084 return 0;
1085}
1086
1087/*
1088 * cx231xx_usb_disconnect()
1089 * called when the device gets diconencted
1090 * video device will be unregistered on v4l2_close in case it is still open
1091 */
1092static void cx231xx_usb_disconnect(struct usb_interface *interface)
1093{
1094 struct cx231xx *dev;
1095
84b5dbf3 1096 dev = usb_get_intfdata(interface);
e0d3bafd
SD		 1097 usb_set_intfdata(interface, NULL);
1098
1099 if (!dev)
1100 return;
1101
90960744
MCC		 1102 if (!dev->udev)
1103 return;
1104
707bcf32
TH		 1105 flush_request_modules(dev);
1106
b1196126
SD		 1107 /* delete v4l2 device */
1108 v4l2_device_unregister(&dev->v4l2_dev);
1109
e0d3bafd
SD		 1110 /* wait until all current v4l2 io is finished then deallocate
1111 resources */
1112 mutex_lock(&dev->lock);
1113
1114 wake_up_interruptible_all(&dev->open);
1115
1116 if (dev->users) {
1117 cx231xx_warn
38c7c036
LP		 1118 ("device %s is open! Deregistration and memory "
1119 "deallocation are deferred on close.\n",
1120 video_device_node_name(dev->vdev));
e0d3bafd
SD		 1121
1122 dev->state |= DEV_MISCONFIGURED;
64fbf444
PB		 1123 if (dev->USE_ISO)
1124 cx231xx_uninit_isoc(dev);
1125 else
1126 cx231xx_uninit_bulk(dev);
e0d3bafd
SD		 1127 dev->state |= DEV_DISCONNECTED;
1128 wake_up_interruptible(&dev->wait_frame);
1129 wake_up_interruptible(&dev->wait_stream);
1130 } else {
1131 dev->state |= DEV_DISCONNECTED;
1132 cx231xx_release_resources(dev);
1133 }
1134
84b5dbf3 1135 cx231xx_close_extension(dev);
e0d3bafd
SD		 1136
1137 mutex_unlock(&dev->lock);
1138
1139 if (!dev->users) {
1140 kfree(dev->video_mode.alt_max_pkt_size);
84b5dbf3
MCC		 1141 kfree(dev->vbi_mode.alt_max_pkt_size);
1142 kfree(dev->sliced_cc_mode.alt_max_pkt_size);
1143 kfree(dev->ts1_mode.alt_max_pkt_size);
e0d3bafd 1144 kfree(dev);
64fbf444 1145 dev = NULL;
e0d3bafd
SD		 1146 }
1147}
1148
1149static struct usb_driver cx231xx_usb_driver = {
1150 .name = "cx231xx",
1151 .probe = cx231xx_usb_probe,
1152 .disconnect = cx231xx_usb_disconnect,
1153 .id_table = cx231xx_id_table,
1154};
1155
1156static int __init cx231xx_module_init(void)
1157{
1158 int result;
1159
818fdf34 1160 printk(KERN_INFO DRIVER_NAME " v4l2 driver loaded.\n");
e0d3bafd
SD		 1161
1162 /* register this driver with the USB subsystem */
1163 result = usb_register(&cx231xx_usb_driver);
1164 if (result)
1165 cx231xx_err(DRIVER_NAME
84b5dbf3 1166 " usb_register failed. Error number %d.\n", result);
e0d3bafd
SD		 1167
1168 return result;
1169}
1170
1171static void __exit cx231xx_module_exit(void)
1172{
1173 /* deregister this driver with the USB subsystem */
1174 usb_deregister(&cx231xx_usb_driver);
1175}
1176
1177module_init(cx231xx_module_init);
1178module_exit(cx231xx_module_exit);
Linux kernel - Deliverables
This page took 0.215079 seconds and 5 git commands to generate.