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