Merge branches 'acpi-misc', 'acpi-video' and 'acpi-prm'
[linux-2.6-microblaze.git] / drivers / media / usb / go7007 / go7007-usb.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2005-2006 Micronas USA Inc.
4  */
5
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/wait.h>
11 #include <linux/list.h>
12 #include <linux/slab.h>
13 #include <linux/time.h>
14 #include <linux/mm.h>
15 #include <linux/usb.h>
16 #include <linux/i2c.h>
17 #include <asm/byteorder.h>
18 #include <media/i2c/saa7115.h>
19 #include <media/tuner.h>
20 #include <media/i2c/uda1342.h>
21
22 #include "go7007-priv.h"
23
24 static unsigned int assume_endura;
25 module_param(assume_endura, int, 0644);
26 MODULE_PARM_DESC(assume_endura,
27                         "when probing fails, hardware is a Pelco Endura");
28
29 /* #define GO7007_I2C_DEBUG */ /* for debugging the EZ-USB I2C adapter */
30
31 #define HPI_STATUS_ADDR 0xFFF4
32 #define INT_PARAM_ADDR  0xFFF6
33 #define INT_INDEX_ADDR  0xFFF8
34
35 /*
36  * Pipes on EZ-USB interface:
37  *      0 snd - Control
38  *      0 rcv - Control
39  *      2 snd - Download firmware (control)
40  *      4 rcv - Read Interrupt (interrupt)
41  *      6 rcv - Read Video (bulk)
42  *      8 rcv - Read Audio (bulk)
43  */
44
45 #define GO7007_USB_EZUSB                (1<<0)
46 #define GO7007_USB_EZUSB_I2C            (1<<1)
47
48 struct go7007_usb_board {
49         unsigned int flags;
50         struct go7007_board_info main_info;
51 };
52
53 struct go7007_usb {
54         const struct go7007_usb_board *board;
55         struct mutex i2c_lock;
56         struct usb_device *usbdev;
57         struct urb *video_urbs[8];
58         struct urb *audio_urbs[8];
59         struct urb *intr_urb;
60 };
61
62 /*********************** Product specification data ***********************/
63
64 static const struct go7007_usb_board board_matrix_ii = {
65         .flags          = GO7007_USB_EZUSB,
66         .main_info      = {
67                 .flags           = GO7007_BOARD_HAS_AUDIO |
68                                         GO7007_BOARD_USE_ONBOARD_I2C,
69                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
70                                         GO7007_AUDIO_WORD_16,
71                 .audio_rate      = 48000,
72                 .audio_bclk_div  = 8,
73                 .audio_main_div  = 2,
74                 .hpi_buffer_cap  = 7,
75                 .sensor_flags    = GO7007_SENSOR_656 |
76                                         GO7007_SENSOR_VALID_ENABLE |
77                                         GO7007_SENSOR_TV |
78                                         GO7007_SENSOR_SAA7115 |
79                                         GO7007_SENSOR_VBI |
80                                         GO7007_SENSOR_SCALING,
81                 .num_i2c_devs    = 1,
82                 .i2c_devs        = {
83                         {
84                                 .type   = "saa7115",
85                                 .addr   = 0x20,
86                                 .is_video = 1,
87                         },
88                 },
89                 .num_inputs      = 2,
90                 .inputs          = {
91                         {
92                                 .video_input    = 0,
93                                 .name           = "Composite",
94                         },
95                         {
96                                 .video_input    = 9,
97                                 .name           = "S-Video",
98                         },
99                 },
100                 .video_config   = SAA7115_IDQ_IS_DEFAULT,
101         },
102 };
103
104 static const struct go7007_usb_board board_matrix_reload = {
105         .flags          = GO7007_USB_EZUSB,
106         .main_info      = {
107                 .flags           = GO7007_BOARD_HAS_AUDIO |
108                                         GO7007_BOARD_USE_ONBOARD_I2C,
109                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
110                                         GO7007_AUDIO_I2S_MASTER |
111                                         GO7007_AUDIO_WORD_16,
112                 .audio_rate      = 48000,
113                 .audio_bclk_div  = 8,
114                 .audio_main_div  = 2,
115                 .hpi_buffer_cap  = 7,
116                 .sensor_flags    = GO7007_SENSOR_656 |
117                                         GO7007_SENSOR_TV,
118                 .num_i2c_devs    = 1,
119                 .i2c_devs        = {
120                         {
121                                 .type   = "saa7113",
122                                 .addr   = 0x25,
123                                 .is_video = 1,
124                         },
125                 },
126                 .num_inputs      = 2,
127                 .inputs          = {
128                         {
129                                 .video_input    = 0,
130                                 .name           = "Composite",
131                         },
132                         {
133                                 .video_input    = 9,
134                                 .name           = "S-Video",
135                         },
136                 },
137                 .video_config   = SAA7115_IDQ_IS_DEFAULT,
138         },
139 };
140
141 static const struct go7007_usb_board board_star_trek = {
142         .flags          = GO7007_USB_EZUSB | GO7007_USB_EZUSB_I2C,
143         .main_info      = {
144                 .flags           = GO7007_BOARD_HAS_AUDIO, /* |
145                                         GO7007_BOARD_HAS_TUNER, */
146                 .sensor_flags    = GO7007_SENSOR_656 |
147                                         GO7007_SENSOR_VALID_ENABLE |
148                                         GO7007_SENSOR_TV |
149                                         GO7007_SENSOR_SAA7115 |
150                                         GO7007_SENSOR_VBI |
151                                         GO7007_SENSOR_SCALING,
152                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
153                                         GO7007_AUDIO_WORD_16,
154                 .audio_bclk_div  = 8,
155                 .audio_main_div  = 2,
156                 .hpi_buffer_cap  = 7,
157                 .num_i2c_devs    = 1,
158                 .i2c_devs        = {
159                         {
160                                 .type   = "saa7115",
161                                 .addr   = 0x20,
162                                 .is_video = 1,
163                         },
164                 },
165                 .num_inputs      = 2,
166                 .inputs          = {
167                 /*      {
168                  *              .video_input    = 3,
169                  *              .audio_index    = AUDIO_TUNER,
170                  *              .name           = "Tuner",
171                  *      },
172                  */
173                         {
174                                 .video_input    = 1,
175                         /*      .audio_index    = AUDIO_EXTERN, */
176                                 .name           = "Composite",
177                         },
178                         {
179                                 .video_input    = 8,
180                         /*      .audio_index    = AUDIO_EXTERN, */
181                                 .name           = "S-Video",
182                         },
183                 },
184                 .video_config   = SAA7115_IDQ_IS_DEFAULT,
185         },
186 };
187
188 static const struct go7007_usb_board board_px_tv402u = {
189         .flags          = GO7007_USB_EZUSB | GO7007_USB_EZUSB_I2C,
190         .main_info      = {
191                 .flags           = GO7007_BOARD_HAS_AUDIO |
192                                         GO7007_BOARD_HAS_TUNER,
193                 .sensor_flags    = GO7007_SENSOR_656 |
194                                         GO7007_SENSOR_VALID_ENABLE |
195                                         GO7007_SENSOR_TV |
196                                         GO7007_SENSOR_SAA7115 |
197                                         GO7007_SENSOR_VBI |
198                                         GO7007_SENSOR_SCALING,
199                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
200                                         GO7007_AUDIO_WORD_16,
201                 .audio_bclk_div  = 8,
202                 .audio_main_div  = 2,
203                 .hpi_buffer_cap  = 7,
204                 .num_i2c_devs    = 5,
205                 .i2c_devs        = {
206                         {
207                                 .type   = "saa7115",
208                                 .addr   = 0x20,
209                                 .is_video = 1,
210                         },
211                         {
212                                 .type   = "uda1342",
213                                 .addr   = 0x1a,
214                                 .is_audio = 1,
215                         },
216                         {
217                                 .type   = "tuner",
218                                 .addr   = 0x60,
219                         },
220                         {
221                                 .type   = "tuner",
222                                 .addr   = 0x43,
223                         },
224                         {
225                                 .type   = "sony-btf-mpx",
226                                 .addr   = 0x44,
227                         },
228                 },
229                 .num_inputs      = 3,
230                 .inputs          = {
231                         {
232                                 .video_input    = 3,
233                                 .audio_index    = 0,
234                                 .name           = "Tuner",
235                         },
236                         {
237                                 .video_input    = 1,
238                                 .audio_index    = 1,
239                                 .name           = "Composite",
240                         },
241                         {
242                                 .video_input    = 8,
243                                 .audio_index    = 1,
244                                 .name           = "S-Video",
245                         },
246                 },
247                 .video_config   = SAA7115_IDQ_IS_DEFAULT,
248                 .num_aud_inputs  = 2,
249                 .aud_inputs      = {
250                         {
251                                 .audio_input    = UDA1342_IN2,
252                                 .name           = "Tuner",
253                         },
254                         {
255                                 .audio_input    = UDA1342_IN1,
256                                 .name           = "Line In",
257                         },
258                 },
259         },
260 };
261
262 static const struct go7007_usb_board board_xmen = {
263         .flags          = 0,
264         .main_info      = {
265                 .flags            = GO7007_BOARD_USE_ONBOARD_I2C,
266                 .hpi_buffer_cap   = 0,
267                 .sensor_flags     = GO7007_SENSOR_VREF_POLAR,
268                 .sensor_width     = 320,
269                 .sensor_height    = 240,
270                 .sensor_framerate = 30030,
271                 .audio_flags      = GO7007_AUDIO_ONE_CHANNEL |
272                                         GO7007_AUDIO_I2S_MODE_3 |
273                                         GO7007_AUDIO_WORD_14 |
274                                         GO7007_AUDIO_I2S_MASTER |
275                                         GO7007_AUDIO_BCLK_POLAR |
276                                         GO7007_AUDIO_OKI_MODE,
277                 .audio_rate       = 8000,
278                 .audio_bclk_div   = 48,
279                 .audio_main_div   = 1,
280                 .num_i2c_devs     = 1,
281                 .i2c_devs         = {
282                         {
283                                 .type   = "ov7640",
284                                 .addr   = 0x21,
285                         },
286                 },
287                 .num_inputs       = 1,
288                 .inputs           = {
289                         {
290                                 .name           = "Camera",
291                         },
292                 },
293         },
294 };
295
296 static const struct go7007_usb_board board_matrix_revolution = {
297         .flags          = GO7007_USB_EZUSB,
298         .main_info      = {
299                 .flags           = GO7007_BOARD_HAS_AUDIO |
300                                         GO7007_BOARD_USE_ONBOARD_I2C,
301                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
302                                         GO7007_AUDIO_I2S_MASTER |
303                                         GO7007_AUDIO_WORD_16,
304                 .audio_rate      = 48000,
305                 .audio_bclk_div  = 8,
306                 .audio_main_div  = 2,
307                 .hpi_buffer_cap  = 7,
308                 .sensor_flags    = GO7007_SENSOR_656 |
309                                         GO7007_SENSOR_TV |
310                                         GO7007_SENSOR_VBI,
311                 .num_i2c_devs    = 1,
312                 .i2c_devs        = {
313                         {
314                                 .type   = "tw9903",
315                                 .is_video = 1,
316                                 .addr   = 0x44,
317                         },
318                 },
319                 .num_inputs      = 2,
320                 .inputs          = {
321                         {
322                                 .video_input    = 2,
323                                 .name           = "Composite",
324                         },
325                         {
326                                 .video_input    = 8,
327                                 .name           = "S-Video",
328                         },
329                 },
330         },
331 };
332
333 #if 0
334 static const struct go7007_usb_board board_lifeview_lr192 = {
335         .flags          = GO7007_USB_EZUSB,
336         .main_info      = {
337                 .flags           = GO7007_BOARD_HAS_AUDIO |
338                                         GO7007_BOARD_USE_ONBOARD_I2C,
339                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
340                                         GO7007_AUDIO_WORD_16,
341                 .audio_rate      = 48000,
342                 .audio_bclk_div  = 8,
343                 .audio_main_div  = 2,
344                 .hpi_buffer_cap  = 7,
345                 .sensor_flags    = GO7007_SENSOR_656 |
346                                         GO7007_SENSOR_VALID_ENABLE |
347                                         GO7007_SENSOR_TV |
348                                         GO7007_SENSOR_VBI |
349                                         GO7007_SENSOR_SCALING,
350                 .num_i2c_devs    = 0,
351                 .num_inputs      = 1,
352                 .inputs          = {
353                         {
354                                 .video_input    = 0,
355                                 .name           = "Composite",
356                         },
357                 },
358         },
359 };
360 #endif
361
362 static const struct go7007_usb_board board_endura = {
363         .flags          = 0,
364         .main_info      = {
365                 .flags           = 0,
366                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
367                                         GO7007_AUDIO_I2S_MASTER |
368                                         GO7007_AUDIO_WORD_16,
369                 .audio_rate      = 8000,
370                 .audio_bclk_div  = 48,
371                 .audio_main_div  = 8,
372                 .hpi_buffer_cap  = 0,
373                 .sensor_flags    = GO7007_SENSOR_656 |
374                                         GO7007_SENSOR_TV,
375                 .sensor_h_offset = 8,
376                 .num_i2c_devs    = 0,
377                 .num_inputs      = 1,
378                 .inputs          = {
379                         {
380                                 .name           = "Camera",
381                         },
382                 },
383         },
384 };
385
386 static const struct go7007_usb_board board_adlink_mpg24 = {
387         .flags          = 0,
388         .main_info      = {
389                 .flags           = GO7007_BOARD_USE_ONBOARD_I2C,
390                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
391                                         GO7007_AUDIO_I2S_MASTER |
392                                         GO7007_AUDIO_WORD_16,
393                 .audio_rate      = 48000,
394                 .audio_bclk_div  = 8,
395                 .audio_main_div  = 2,
396                 .hpi_buffer_cap  = 0,
397                 .sensor_flags    = GO7007_SENSOR_656 |
398                                         GO7007_SENSOR_TV |
399                                         GO7007_SENSOR_VBI,
400                 .num_i2c_devs    = 1,
401                 .i2c_devs        = {
402                         {
403                                 .type   = "tw2804",
404                                 .addr   = 0x00, /* yes, really */
405                                 .flags  = I2C_CLIENT_TEN,
406                                 .is_video = 1,
407                         },
408                 },
409                 .num_inputs      = 1,
410                 .inputs          = {
411                         {
412                                 .name           = "Composite",
413                         },
414                 },
415         },
416 };
417
418 static const struct go7007_usb_board board_sensoray_2250 = {
419         .flags          = GO7007_USB_EZUSB | GO7007_USB_EZUSB_I2C,
420         .main_info      = {
421                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
422                                         GO7007_AUDIO_I2S_MASTER |
423                                         GO7007_AUDIO_WORD_16,
424                 .flags           = GO7007_BOARD_HAS_AUDIO,
425                 .audio_rate      = 48000,
426                 .audio_bclk_div  = 8,
427                 .audio_main_div  = 2,
428                 .hpi_buffer_cap  = 7,
429                 .sensor_flags    = GO7007_SENSOR_656 |
430                                         GO7007_SENSOR_TV,
431                 .num_i2c_devs    = 1,
432                 .i2c_devs        = {
433                         {
434                                 .type   = "s2250",
435                                 .addr   = 0x43,
436                                 .is_video = 1,
437                                 .is_audio = 1,
438                         },
439                 },
440                 .num_inputs      = 2,
441                 .inputs          = {
442                         {
443                                 .video_input    = 0,
444                                 .name           = "Composite",
445                         },
446                         {
447                                 .video_input    = 1,
448                                 .name           = "S-Video",
449                         },
450                 },
451                 .num_aud_inputs  = 3,
452                 .aud_inputs      = {
453                         {
454                                 .audio_input    = 0,
455                                 .name           = "Line In",
456                         },
457                         {
458                                 .audio_input    = 1,
459                                 .name           = "Mic",
460                         },
461                         {
462                                 .audio_input    = 2,
463                                 .name           = "Mic Boost",
464                         },
465                 },
466         },
467 };
468
469 static const struct go7007_usb_board board_ads_usbav_709 = {
470         .flags          = GO7007_USB_EZUSB,
471         .main_info      = {
472                 .flags           = GO7007_BOARD_HAS_AUDIO |
473                                         GO7007_BOARD_USE_ONBOARD_I2C,
474                 .audio_flags     = GO7007_AUDIO_I2S_MODE_1 |
475                                         GO7007_AUDIO_I2S_MASTER |
476                                         GO7007_AUDIO_WORD_16,
477                 .audio_rate      = 48000,
478                 .audio_bclk_div  = 8,
479                 .audio_main_div  = 2,
480                 .hpi_buffer_cap  = 7,
481                 .sensor_flags    = GO7007_SENSOR_656 |
482                                         GO7007_SENSOR_TV |
483                                         GO7007_SENSOR_VBI,
484                 .num_i2c_devs    = 1,
485                 .i2c_devs        = {
486                         {
487                                 .type   = "tw9906",
488                                 .is_video = 1,
489                                 .addr   = 0x44,
490                         },
491                 },
492                 .num_inputs      = 2,
493                 .inputs          = {
494                         {
495                                 .video_input    = 0,
496                                 .name           = "Composite",
497                         },
498                         {
499                                 .video_input    = 10,
500                                 .name           = "S-Video",
501                         },
502                 },
503         },
504 };
505
506 static const struct usb_device_id go7007_usb_id_table[] = {
507         {
508                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
509                                         USB_DEVICE_ID_MATCH_INT_INFO,
510                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
511                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
512                 .bcdDevice_lo   = 0x200,   /* Revision number of XMen */
513                 .bcdDevice_hi   = 0x200,
514                 .bInterfaceClass        = 255,
515                 .bInterfaceSubClass     = 0,
516                 .bInterfaceProtocol     = 255,
517                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_XMEN,
518         },
519         {
520                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
521                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
522                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
523                 .bcdDevice_lo   = 0x202,   /* Revision number of Matrix II */
524                 .bcdDevice_hi   = 0x202,
525                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_MATRIX_II,
526         },
527         {
528                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
529                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
530                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
531                 .bcdDevice_lo   = 0x204,   /* Revision number of Matrix */
532                 .bcdDevice_hi   = 0x204,   /*     Reloaded */
533                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_MATRIX_RELOAD,
534         },
535         {
536                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
537                                         USB_DEVICE_ID_MATCH_INT_INFO,
538                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
539                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
540                 .bcdDevice_lo   = 0x205,   /* Revision number of XMen-II */
541                 .bcdDevice_hi   = 0x205,
542                 .bInterfaceClass        = 255,
543                 .bInterfaceSubClass     = 0,
544                 .bInterfaceProtocol     = 255,
545                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_XMEN_II,
546         },
547         {
548                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
549                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
550                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
551                 .bcdDevice_lo   = 0x208,   /* Revision number of Star Trek */
552                 .bcdDevice_hi   = 0x208,
553                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_STAR_TREK,
554         },
555         {
556                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION |
557                                         USB_DEVICE_ID_MATCH_INT_INFO,
558                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
559                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
560                 .bcdDevice_lo   = 0x209,   /* Revision number of XMen-III */
561                 .bcdDevice_hi   = 0x209,
562                 .bInterfaceClass        = 255,
563                 .bInterfaceSubClass     = 0,
564                 .bInterfaceProtocol     = 255,
565                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_XMEN_III,
566         },
567         {
568                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
569                 .idVendor       = 0x0eb1,  /* Vendor ID of WIS Technologies */
570                 .idProduct      = 0x7007,  /* Product ID of GO7007SB chip */
571                 .bcdDevice_lo   = 0x210,   /* Revision number of Matrix */
572                 .bcdDevice_hi   = 0x210,   /*     Revolution */
573                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_MATRIX_REV,
574         },
575         {
576                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
577                 .idVendor       = 0x093b,  /* Vendor ID of Plextor */
578                 .idProduct      = 0xa102,  /* Product ID of M402U */
579                 .bcdDevice_lo   = 0x1,     /* revision number of Blueberry */
580                 .bcdDevice_hi   = 0x1,
581                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_PX_M402U,
582         },
583         {
584                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
585                 .idVendor       = 0x093b,  /* Vendor ID of Plextor */
586                 .idProduct      = 0xa104,  /* Product ID of TV402U */
587                 .bcdDevice_lo   = 0x1,
588                 .bcdDevice_hi   = 0x1,
589                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_PX_TV402U,
590         },
591         {
592                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
593                 .idVendor       = 0x10fd,  /* Vendor ID of Anubis Electronics */
594                 .idProduct      = 0xde00,  /* Product ID of Lifeview LR192 */
595                 .bcdDevice_lo   = 0x1,
596                 .bcdDevice_hi   = 0x1,
597                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_LIFEVIEW_LR192,
598         },
599         {
600                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
601                 .idVendor       = 0x1943,  /* Vendor ID Sensoray */
602                 .idProduct      = 0x2250,  /* Product ID of 2250/2251 */
603                 .bcdDevice_lo   = 0x1,
604                 .bcdDevice_hi   = 0x1,
605                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_SENSORAY_2250,
606         },
607         {
608                 .match_flags    = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION,
609                 .idVendor       = 0x06e1,  /* Vendor ID of ADS Technologies */
610                 .idProduct      = 0x0709,  /* Product ID of DVD Xpress DX2 */
611                 .bcdDevice_lo   = 0x204,
612                 .bcdDevice_hi   = 0x204,
613                 .driver_info    = (kernel_ulong_t)GO7007_BOARDID_ADS_USBAV_709,
614         },
615         { }                                     /* Terminating entry */
616 };
617
618 MODULE_DEVICE_TABLE(usb, go7007_usb_id_table);
619
620 /********************* Driver for EZ-USB HPI interface *********************/
621
622 static int go7007_usb_vendor_request(struct go7007 *go, int request,
623                 int value, int index, void *transfer_buffer, int length, int in)
624 {
625         struct go7007_usb *usb = go->hpi_context;
626         int timeout = 5000;
627
628         if (in) {
629                 return usb_control_msg(usb->usbdev,
630                                 usb_rcvctrlpipe(usb->usbdev, 0), request,
631                                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
632                                 value, index, transfer_buffer, length, timeout);
633         } else {
634                 return usb_control_msg(usb->usbdev,
635                                 usb_sndctrlpipe(usb->usbdev, 0), request,
636                                 USB_TYPE_VENDOR | USB_RECIP_DEVICE,
637                                 value, index, transfer_buffer, length, timeout);
638         }
639 }
640
641 static int go7007_usb_interface_reset(struct go7007 *go)
642 {
643         struct go7007_usb *usb = go->hpi_context;
644         u16 intr_val, intr_data;
645
646         if (go->status == STATUS_SHUTDOWN)
647                 return -1;
648         /* Reset encoder */
649         if (go7007_write_interrupt(go, 0x0001, 0x0001) < 0)
650                 return -1;
651         msleep(100);
652
653         if (usb->board->flags & GO7007_USB_EZUSB) {
654                 /* Reset buffer in EZ-USB */
655                 pr_debug("resetting EZ-USB buffers\n");
656                 if (go7007_usb_vendor_request(go, 0x10, 0, 0, NULL, 0, 0) < 0 ||
657                     go7007_usb_vendor_request(go, 0x10, 0, 0, NULL, 0, 0) < 0)
658                         return -1;
659
660                 /* Reset encoder again */
661                 if (go7007_write_interrupt(go, 0x0001, 0x0001) < 0)
662                         return -1;
663                 msleep(100);
664         }
665
666         /* Wait for an interrupt to indicate successful hardware reset */
667         if (go7007_read_interrupt(go, &intr_val, &intr_data) < 0 ||
668                         (intr_val & ~0x1) != 0x55aa) {
669                 dev_err(go->dev, "unable to reset the USB interface\n");
670                 return -1;
671         }
672         return 0;
673 }
674
675 static int go7007_usb_ezusb_write_interrupt(struct go7007 *go,
676                                                 int addr, int data)
677 {
678         struct go7007_usb *usb = go->hpi_context;
679         int i, r;
680         u16 status_reg = 0;
681         int timeout = 500;
682
683         pr_debug("WriteInterrupt: %04x %04x\n", addr, data);
684
685         for (i = 0; i < 100; ++i) {
686                 r = usb_control_msg(usb->usbdev,
687                                 usb_rcvctrlpipe(usb->usbdev, 0), 0x14,
688                                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
689                                 0, HPI_STATUS_ADDR, go->usb_buf,
690                                 sizeof(status_reg), timeout);
691                 if (r < 0)
692                         break;
693                 status_reg = le16_to_cpu(*((__le16 *)go->usb_buf));
694                 if (!(status_reg & 0x0010))
695                         break;
696                 msleep(10);
697         }
698         if (r < 0)
699                 goto write_int_error;
700         if (i == 100) {
701                 dev_err(go->dev, "device is hung, status reg = 0x%04x\n", status_reg);
702                 return -1;
703         }
704         r = usb_control_msg(usb->usbdev, usb_sndctrlpipe(usb->usbdev, 0), 0x12,
705                         USB_TYPE_VENDOR | USB_RECIP_DEVICE, data,
706                         INT_PARAM_ADDR, NULL, 0, timeout);
707         if (r < 0)
708                 goto write_int_error;
709         r = usb_control_msg(usb->usbdev, usb_sndctrlpipe(usb->usbdev, 0),
710                         0x12, USB_TYPE_VENDOR | USB_RECIP_DEVICE, addr,
711                         INT_INDEX_ADDR, NULL, 0, timeout);
712         if (r < 0)
713                 goto write_int_error;
714         return 0;
715
716 write_int_error:
717         dev_err(go->dev, "error in WriteInterrupt: %d\n", r);
718         return r;
719 }
720
721 static int go7007_usb_onboard_write_interrupt(struct go7007 *go,
722                                                 int addr, int data)
723 {
724         struct go7007_usb *usb = go->hpi_context;
725         int r;
726         int timeout = 500;
727
728         pr_debug("WriteInterrupt: %04x %04x\n", addr, data);
729
730         go->usb_buf[0] = data & 0xff;
731         go->usb_buf[1] = data >> 8;
732         go->usb_buf[2] = addr & 0xff;
733         go->usb_buf[3] = addr >> 8;
734         go->usb_buf[4] = go->usb_buf[5] = go->usb_buf[6] = go->usb_buf[7] = 0;
735         r = usb_control_msg(usb->usbdev, usb_sndctrlpipe(usb->usbdev, 2), 0x00,
736                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT, 0x55aa,
737                         0xf0f0, go->usb_buf, 8, timeout);
738         if (r < 0) {
739                 dev_err(go->dev, "error in WriteInterrupt: %d\n", r);
740                 return r;
741         }
742         return 0;
743 }
744
745 static void go7007_usb_readinterrupt_complete(struct urb *urb)
746 {
747         struct go7007 *go = (struct go7007 *)urb->context;
748         __le16 *regs = (__le16 *)urb->transfer_buffer;
749         int status = urb->status;
750
751         if (status) {
752                 if (status != -ESHUTDOWN &&
753                                 go->status != STATUS_SHUTDOWN) {
754                         dev_err(go->dev, "error in read interrupt: %d\n", urb->status);
755                 } else {
756                         wake_up(&go->interrupt_waitq);
757                         return;
758                 }
759         } else if (urb->actual_length != urb->transfer_buffer_length) {
760                 dev_err(go->dev, "short read in interrupt pipe!\n");
761         } else {
762                 go->interrupt_available = 1;
763                 go->interrupt_data = __le16_to_cpu(regs[0]);
764                 go->interrupt_value = __le16_to_cpu(regs[1]);
765                 pr_debug("ReadInterrupt: %04x %04x\n",
766                                 go->interrupt_value, go->interrupt_data);
767         }
768
769         wake_up(&go->interrupt_waitq);
770 }
771
772 static int go7007_usb_read_interrupt(struct go7007 *go)
773 {
774         struct go7007_usb *usb = go->hpi_context;
775         int r;
776
777         r = usb_submit_urb(usb->intr_urb, GFP_KERNEL);
778         if (r < 0) {
779                 dev_err(go->dev, "unable to submit interrupt urb: %d\n", r);
780                 return r;
781         }
782         return 0;
783 }
784
785 static void go7007_usb_read_video_pipe_complete(struct urb *urb)
786 {
787         struct go7007 *go = (struct go7007 *)urb->context;
788         int r, status = urb->status;
789
790         if (!vb2_is_streaming(&go->vidq)) {
791                 wake_up_interruptible(&go->frame_waitq);
792                 return;
793         }
794         if (status) {
795                 dev_err(go->dev, "error in video pipe: %d\n", status);
796                 return;
797         }
798         if (urb->actual_length != urb->transfer_buffer_length) {
799                 dev_err(go->dev, "short read in video pipe!\n");
800                 return;
801         }
802         go7007_parse_video_stream(go, urb->transfer_buffer, urb->actual_length);
803         r = usb_submit_urb(urb, GFP_ATOMIC);
804         if (r < 0)
805                 dev_err(go->dev, "error in video pipe: %d\n", r);
806 }
807
808 static void go7007_usb_read_audio_pipe_complete(struct urb *urb)
809 {
810         struct go7007 *go = (struct go7007 *)urb->context;
811         int r, status = urb->status;
812
813         if (!vb2_is_streaming(&go->vidq))
814                 return;
815         if (status) {
816                 dev_err(go->dev, "error in audio pipe: %d\n",
817                         status);
818                 return;
819         }
820         if (urb->actual_length != urb->transfer_buffer_length) {
821                 dev_err(go->dev, "short read in audio pipe!\n");
822                 return;
823         }
824         if (go->audio_deliver != NULL)
825                 go->audio_deliver(go, urb->transfer_buffer, urb->actual_length);
826         r = usb_submit_urb(urb, GFP_ATOMIC);
827         if (r < 0)
828                 dev_err(go->dev, "error in audio pipe: %d\n", r);
829 }
830
831 static int go7007_usb_stream_start(struct go7007 *go)
832 {
833         struct go7007_usb *usb = go->hpi_context;
834         int i, r;
835
836         for (i = 0; i < 8; ++i) {
837                 r = usb_submit_urb(usb->video_urbs[i], GFP_KERNEL);
838                 if (r < 0) {
839                         dev_err(go->dev, "error submitting video urb %d: %d\n", i, r);
840                         goto video_submit_failed;
841                 }
842         }
843         if (!go->audio_enabled)
844                 return 0;
845
846         for (i = 0; i < 8; ++i) {
847                 r = usb_submit_urb(usb->audio_urbs[i], GFP_KERNEL);
848                 if (r < 0) {
849                         dev_err(go->dev, "error submitting audio urb %d: %d\n", i, r);
850                         goto audio_submit_failed;
851                 }
852         }
853         return 0;
854
855 audio_submit_failed:
856         for (i = 0; i < 7; ++i)
857                 usb_kill_urb(usb->audio_urbs[i]);
858 video_submit_failed:
859         for (i = 0; i < 8; ++i)
860                 usb_kill_urb(usb->video_urbs[i]);
861         return -1;
862 }
863
864 static int go7007_usb_stream_stop(struct go7007 *go)
865 {
866         struct go7007_usb *usb = go->hpi_context;
867         int i;
868
869         if (go->status == STATUS_SHUTDOWN)
870                 return 0;
871         for (i = 0; i < 8; ++i)
872                 usb_kill_urb(usb->video_urbs[i]);
873         if (go->audio_enabled)
874                 for (i = 0; i < 8; ++i)
875                         usb_kill_urb(usb->audio_urbs[i]);
876         return 0;
877 }
878
879 static int go7007_usb_send_firmware(struct go7007 *go, u8 *data, int len)
880 {
881         struct go7007_usb *usb = go->hpi_context;
882         int transferred, pipe;
883         int timeout = 500;
884
885         pr_debug("DownloadBuffer sending %d bytes\n", len);
886
887         if (usb->board->flags & GO7007_USB_EZUSB)
888                 pipe = usb_sndbulkpipe(usb->usbdev, 2);
889         else
890                 pipe = usb_sndbulkpipe(usb->usbdev, 3);
891
892         return usb_bulk_msg(usb->usbdev, pipe, data, len,
893                                         &transferred, timeout);
894 }
895
896 static void go7007_usb_release(struct go7007 *go)
897 {
898         struct go7007_usb *usb = go->hpi_context;
899         struct urb *vurb, *aurb;
900         int i;
901
902         if (usb->intr_urb) {
903                 usb_kill_urb(usb->intr_urb);
904                 kfree(usb->intr_urb->transfer_buffer);
905                 usb_free_urb(usb->intr_urb);
906         }
907
908         /* Free USB-related structs */
909         for (i = 0; i < 8; ++i) {
910                 vurb = usb->video_urbs[i];
911                 if (vurb) {
912                         usb_kill_urb(vurb);
913                         kfree(vurb->transfer_buffer);
914                         usb_free_urb(vurb);
915                 }
916                 aurb = usb->audio_urbs[i];
917                 if (aurb) {
918                         usb_kill_urb(aurb);
919                         kfree(aurb->transfer_buffer);
920                         usb_free_urb(aurb);
921                 }
922         }
923
924         kfree(go->hpi_context);
925 }
926
927 static const struct go7007_hpi_ops go7007_usb_ezusb_hpi_ops = {
928         .interface_reset        = go7007_usb_interface_reset,
929         .write_interrupt        = go7007_usb_ezusb_write_interrupt,
930         .read_interrupt         = go7007_usb_read_interrupt,
931         .stream_start           = go7007_usb_stream_start,
932         .stream_stop            = go7007_usb_stream_stop,
933         .send_firmware          = go7007_usb_send_firmware,
934         .release                = go7007_usb_release,
935 };
936
937 static const struct go7007_hpi_ops go7007_usb_onboard_hpi_ops = {
938         .interface_reset        = go7007_usb_interface_reset,
939         .write_interrupt        = go7007_usb_onboard_write_interrupt,
940         .read_interrupt         = go7007_usb_read_interrupt,
941         .stream_start           = go7007_usb_stream_start,
942         .stream_stop            = go7007_usb_stream_stop,
943         .send_firmware          = go7007_usb_send_firmware,
944         .release                = go7007_usb_release,
945 };
946
947 /********************* Driver for EZ-USB I2C adapter *********************/
948
949 static int go7007_usb_i2c_master_xfer(struct i2c_adapter *adapter,
950                                         struct i2c_msg msgs[], int num)
951 {
952         struct go7007 *go = i2c_get_adapdata(adapter);
953         struct go7007_usb *usb = go->hpi_context;
954         u8 *buf = go->usb_buf;
955         int buf_len, i;
956         int ret = -EIO;
957
958         if (go->status == STATUS_SHUTDOWN)
959                 return -ENODEV;
960
961         mutex_lock(&usb->i2c_lock);
962
963         for (i = 0; i < num; ++i) {
964                 /* The hardware command is "write some bytes then read some
965                  * bytes", so we try to coalesce a write followed by a read
966                  * into a single USB transaction */
967                 if (i + 1 < num && msgs[i].addr == msgs[i + 1].addr &&
968                                 !(msgs[i].flags & I2C_M_RD) &&
969                                 (msgs[i + 1].flags & I2C_M_RD)) {
970 #ifdef GO7007_I2C_DEBUG
971                         pr_debug("i2c write/read %d/%d bytes on %02x\n",
972                                 msgs[i].len, msgs[i + 1].len, msgs[i].addr);
973 #endif
974                         buf[0] = 0x01;
975                         buf[1] = msgs[i].len + 1;
976                         buf[2] = msgs[i].addr << 1;
977                         memcpy(&buf[3], msgs[i].buf, msgs[i].len);
978                         buf_len = msgs[i].len + 3;
979                         buf[buf_len++] = msgs[++i].len;
980                 } else if (msgs[i].flags & I2C_M_RD) {
981 #ifdef GO7007_I2C_DEBUG
982                         pr_debug("i2c read %d bytes on %02x\n",
983                                         msgs[i].len, msgs[i].addr);
984 #endif
985                         buf[0] = 0x01;
986                         buf[1] = 1;
987                         buf[2] = msgs[i].addr << 1;
988                         buf[3] = msgs[i].len;
989                         buf_len = 4;
990                 } else {
991 #ifdef GO7007_I2C_DEBUG
992                         pr_debug("i2c write %d bytes on %02x\n",
993                                         msgs[i].len, msgs[i].addr);
994 #endif
995                         buf[0] = 0x00;
996                         buf[1] = msgs[i].len + 1;
997                         buf[2] = msgs[i].addr << 1;
998                         memcpy(&buf[3], msgs[i].buf, msgs[i].len);
999                         buf_len = msgs[i].len + 3;
1000                         buf[buf_len++] = 0;
1001                 }
1002                 if (go7007_usb_vendor_request(go, 0x24, 0, 0,
1003                                                 buf, buf_len, 0) < 0)
1004                         goto i2c_done;
1005                 if (msgs[i].flags & I2C_M_RD) {
1006                         memset(buf, 0, msgs[i].len + 1);
1007                         if (go7007_usb_vendor_request(go, 0x25, 0, 0, buf,
1008                                                 msgs[i].len + 1, 1) < 0)
1009                                 goto i2c_done;
1010                         memcpy(msgs[i].buf, buf + 1, msgs[i].len);
1011                 }
1012         }
1013         ret = num;
1014
1015 i2c_done:
1016         mutex_unlock(&usb->i2c_lock);
1017         return ret;
1018 }
1019
1020 static u32 go7007_usb_functionality(struct i2c_adapter *adapter)
1021 {
1022         /* No errors are reported by the hardware, so we don't bother
1023          * supporting quick writes to avoid confusing probing */
1024         return (I2C_FUNC_SMBUS_EMUL) & ~I2C_FUNC_SMBUS_QUICK;
1025 }
1026
1027 static const struct i2c_algorithm go7007_usb_algo = {
1028         .master_xfer    = go7007_usb_i2c_master_xfer,
1029         .functionality  = go7007_usb_functionality,
1030 };
1031
1032 static struct i2c_adapter go7007_usb_adap_templ = {
1033         .owner                  = THIS_MODULE,
1034         .name                   = "WIS GO7007SB EZ-USB",
1035         .algo                   = &go7007_usb_algo,
1036 };
1037
1038 /********************* USB add/remove functions *********************/
1039
1040 static int go7007_usb_probe(struct usb_interface *intf,
1041                 const struct usb_device_id *id)
1042 {
1043         struct go7007 *go;
1044         struct go7007_usb *usb;
1045         const struct go7007_usb_board *board;
1046         struct usb_device *usbdev = interface_to_usbdev(intf);
1047         struct usb_host_endpoint *ep;
1048         unsigned num_i2c_devs;
1049         char *name;
1050         int video_pipe, i, v_urb_len;
1051
1052         pr_debug("probing new GO7007 USB board\n");
1053
1054         switch (id->driver_info) {
1055         case GO7007_BOARDID_MATRIX_II:
1056                 name = "WIS Matrix II or compatible";
1057                 board = &board_matrix_ii;
1058                 break;
1059         case GO7007_BOARDID_MATRIX_RELOAD:
1060                 name = "WIS Matrix Reloaded or compatible";
1061                 board = &board_matrix_reload;
1062                 break;
1063         case GO7007_BOARDID_MATRIX_REV:
1064                 name = "WIS Matrix Revolution or compatible";
1065                 board = &board_matrix_revolution;
1066                 break;
1067         case GO7007_BOARDID_STAR_TREK:
1068                 name = "WIS Star Trek or compatible";
1069                 board = &board_star_trek;
1070                 break;
1071         case GO7007_BOARDID_XMEN:
1072                 name = "WIS XMen or compatible";
1073                 board = &board_xmen;
1074                 break;
1075         case GO7007_BOARDID_XMEN_II:
1076                 name = "WIS XMen II or compatible";
1077                 board = &board_xmen;
1078                 break;
1079         case GO7007_BOARDID_XMEN_III:
1080                 name = "WIS XMen III or compatible";
1081                 board = &board_xmen;
1082                 break;
1083         case GO7007_BOARDID_PX_M402U:
1084                 name = "Plextor PX-M402U";
1085                 board = &board_matrix_ii;
1086                 break;
1087         case GO7007_BOARDID_PX_TV402U:
1088                 name = "Plextor PX-TV402U (unknown tuner)";
1089                 board = &board_px_tv402u;
1090                 break;
1091         case GO7007_BOARDID_LIFEVIEW_LR192:
1092                 dev_err(&intf->dev, "The Lifeview TV Walker Ultra is not supported. Sorry!\n");
1093                 return -ENODEV;
1094 #if 0
1095                 name = "Lifeview TV Walker Ultra";
1096                 board = &board_lifeview_lr192;
1097 #endif
1098                 break;
1099         case GO7007_BOARDID_SENSORAY_2250:
1100                 dev_info(&intf->dev, "Sensoray 2250 found\n");
1101                 name = "Sensoray 2250/2251";
1102                 board = &board_sensoray_2250;
1103                 break;
1104         case GO7007_BOARDID_ADS_USBAV_709:
1105                 name = "ADS Tech DVD Xpress DX2";
1106                 board = &board_ads_usbav_709;
1107                 break;
1108         default:
1109                 dev_err(&intf->dev, "unknown board ID %d!\n",
1110                                 (unsigned int)id->driver_info);
1111                 return -ENODEV;
1112         }
1113
1114         go = go7007_alloc(&board->main_info, &intf->dev);
1115         if (go == NULL)
1116                 return -ENOMEM;
1117
1118         usb = kzalloc(sizeof(struct go7007_usb), GFP_KERNEL);
1119         if (usb == NULL) {
1120                 kfree(go);
1121                 return -ENOMEM;
1122         }
1123
1124         usb->board = board;
1125         usb->usbdev = usbdev;
1126         usb_make_path(usbdev, go->bus_info, sizeof(go->bus_info));
1127         go->board_id = id->driver_info;
1128         strscpy(go->name, name, sizeof(go->name));
1129         if (board->flags & GO7007_USB_EZUSB)
1130                 go->hpi_ops = &go7007_usb_ezusb_hpi_ops;
1131         else
1132                 go->hpi_ops = &go7007_usb_onboard_hpi_ops;
1133         go->hpi_context = usb;
1134
1135         ep = usb->usbdev->ep_in[4];
1136         if (!ep)
1137                 return -ENODEV;
1138
1139         /* Allocate the URB and buffer for receiving incoming interrupts */
1140         usb->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
1141         if (usb->intr_urb == NULL)
1142                 goto allocfail;
1143         usb->intr_urb->transfer_buffer = kmalloc_array(2, sizeof(u16),
1144                                                        GFP_KERNEL);
1145         if (usb->intr_urb->transfer_buffer == NULL)
1146                 goto allocfail;
1147
1148         if (usb_endpoint_type(&ep->desc) == USB_ENDPOINT_XFER_BULK)
1149                 usb_fill_bulk_urb(usb->intr_urb, usb->usbdev,
1150                         usb_rcvbulkpipe(usb->usbdev, 4),
1151                         usb->intr_urb->transfer_buffer, 2*sizeof(u16),
1152                         go7007_usb_readinterrupt_complete, go);
1153         else
1154                 usb_fill_int_urb(usb->intr_urb, usb->usbdev,
1155                         usb_rcvintpipe(usb->usbdev, 4),
1156                         usb->intr_urb->transfer_buffer, 2*sizeof(u16),
1157                         go7007_usb_readinterrupt_complete, go, 8);
1158         usb_set_intfdata(intf, &go->v4l2_dev);
1159
1160         /* Boot the GO7007 */
1161         if (go7007_boot_encoder(go, go->board_info->flags &
1162                                         GO7007_BOARD_USE_ONBOARD_I2C) < 0)
1163                 goto allocfail;
1164
1165         /* Register the EZ-USB I2C adapter, if we're using it */
1166         if (board->flags & GO7007_USB_EZUSB_I2C) {
1167                 memcpy(&go->i2c_adapter, &go7007_usb_adap_templ,
1168                                 sizeof(go7007_usb_adap_templ));
1169                 mutex_init(&usb->i2c_lock);
1170                 go->i2c_adapter.dev.parent = go->dev;
1171                 i2c_set_adapdata(&go->i2c_adapter, go);
1172                 if (i2c_add_adapter(&go->i2c_adapter) < 0) {
1173                         dev_err(go->dev, "error: i2c_add_adapter failed\n");
1174                         goto allocfail;
1175                 }
1176                 go->i2c_adapter_online = 1;
1177         }
1178
1179         /* Pelco and Adlink reused the XMen and XMen-III vendor and product
1180          * IDs for their own incompatible designs.  We can detect XMen boards
1181          * by probing the sensor, but there is no way to probe the sensors on
1182          * the Pelco and Adlink designs so we default to the Adlink.  If it
1183          * is actually a Pelco, the user must set the assume_endura module
1184          * parameter. */
1185         if ((go->board_id == GO7007_BOARDID_XMEN ||
1186                                 go->board_id == GO7007_BOARDID_XMEN_III) &&
1187                         go->i2c_adapter_online) {
1188                 union i2c_smbus_data data;
1189
1190                 /* Check to see if register 0x0A is 0x76 */
1191                 i2c_smbus_xfer(&go->i2c_adapter, 0x21, I2C_CLIENT_SCCB,
1192                         I2C_SMBUS_READ, 0x0A, I2C_SMBUS_BYTE_DATA, &data);
1193                 if (data.byte != 0x76) {
1194                         if (assume_endura) {
1195                                 go->board_id = GO7007_BOARDID_ENDURA;
1196                                 usb->board = board = &board_endura;
1197                                 go->board_info = &board->main_info;
1198                                 strscpy(go->name, "Pelco Endura",
1199                                         sizeof(go->name));
1200                         } else {
1201                                 u16 channel;
1202
1203                                 /* read channel number from GPIO[1:0] */
1204                                 go7007_read_addr(go, 0x3c81, &channel);
1205                                 channel &= 0x3;
1206                                 go->board_id = GO7007_BOARDID_ADLINK_MPG24;
1207                                 usb->board = board = &board_adlink_mpg24;
1208                                 go->board_info = &board->main_info;
1209                                 go->channel_number = channel;
1210                                 snprintf(go->name, sizeof(go->name),
1211                                         "Adlink PCI-MPG24, channel #%d",
1212                                         channel);
1213                         }
1214                         go7007_update_board(go);
1215                 }
1216         }
1217
1218         num_i2c_devs = go->board_info->num_i2c_devs;
1219
1220         /* Probe the tuner model on the TV402U */
1221         if (go->board_id == GO7007_BOARDID_PX_TV402U) {
1222                 /* Board strapping indicates tuner model */
1223                 if (go7007_usb_vendor_request(go, 0x41, 0, 0, go->usb_buf, 3,
1224                                         1) < 0) {
1225                         dev_err(go->dev, "GPIO read failed!\n");
1226                         goto allocfail;
1227                 }
1228                 switch (go->usb_buf[0] >> 6) {
1229                 case 1:
1230                         go->tuner_type = TUNER_SONY_BTF_PG472Z;
1231                         go->std = V4L2_STD_PAL;
1232                         strscpy(go->name, "Plextor PX-TV402U-EU",
1233                                 sizeof(go->name));
1234                         break;
1235                 case 2:
1236                         go->tuner_type = TUNER_SONY_BTF_PK467Z;
1237                         go->std = V4L2_STD_NTSC_M_JP;
1238                         num_i2c_devs -= 2;
1239                         strscpy(go->name, "Plextor PX-TV402U-JP",
1240                                 sizeof(go->name));
1241                         break;
1242                 case 3:
1243                         go->tuner_type = TUNER_SONY_BTF_PB463Z;
1244                         num_i2c_devs -= 2;
1245                         strscpy(go->name, "Plextor PX-TV402U-NA",
1246                                 sizeof(go->name));
1247                         break;
1248                 default:
1249                         pr_debug("unable to detect tuner type!\n");
1250                         break;
1251                 }
1252                 /* Configure tuner mode selection inputs connected
1253                  * to the EZ-USB GPIO output pins */
1254                 if (go7007_usb_vendor_request(go, 0x40, 0x7f02, 0,
1255                                         NULL, 0, 0) < 0) {
1256                         dev_err(go->dev, "GPIO write failed!\n");
1257                         goto allocfail;
1258                 }
1259         }
1260
1261         /* Print a nasty message if the user attempts to use a USB2.0 device in
1262          * a USB1.1 port.  There will be silent corruption of the stream. */
1263         if ((board->flags & GO7007_USB_EZUSB) &&
1264                         usbdev->speed != USB_SPEED_HIGH)
1265                 dev_err(go->dev, "*** WARNING ***  This device must be connected to a USB 2.0 port! Attempting to capture video through a USB 1.1 port will result in stream corruption, even at low bitrates!\n");
1266
1267         /* Allocate the URBs and buffers for receiving the video stream */
1268         if (board->flags & GO7007_USB_EZUSB) {
1269                 if (!usb->usbdev->ep_in[6])
1270                         goto allocfail;
1271                 v_urb_len = 1024;
1272                 video_pipe = usb_rcvbulkpipe(usb->usbdev, 6);
1273         } else {
1274                 if (!usb->usbdev->ep_in[1])
1275                         goto allocfail;
1276                 v_urb_len = 512;
1277                 video_pipe = usb_rcvbulkpipe(usb->usbdev, 1);
1278         }
1279         for (i = 0; i < 8; ++i) {
1280                 usb->video_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
1281                 if (usb->video_urbs[i] == NULL)
1282                         goto allocfail;
1283                 usb->video_urbs[i]->transfer_buffer =
1284                                                 kmalloc(v_urb_len, GFP_KERNEL);
1285                 if (usb->video_urbs[i]->transfer_buffer == NULL)
1286                         goto allocfail;
1287                 usb_fill_bulk_urb(usb->video_urbs[i], usb->usbdev, video_pipe,
1288                                 usb->video_urbs[i]->transfer_buffer, v_urb_len,
1289                                 go7007_usb_read_video_pipe_complete, go);
1290         }
1291
1292         /* Allocate the URBs and buffers for receiving the audio stream */
1293         if ((board->flags & GO7007_USB_EZUSB) &&
1294             (board->main_info.flags & GO7007_BOARD_HAS_AUDIO)) {
1295                 if (!usb->usbdev->ep_in[8])
1296                         goto allocfail;
1297                 for (i = 0; i < 8; ++i) {
1298                         usb->audio_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
1299                         if (usb->audio_urbs[i] == NULL)
1300                                 goto allocfail;
1301                         usb->audio_urbs[i]->transfer_buffer = kmalloc(4096,
1302                                                                 GFP_KERNEL);
1303                         if (usb->audio_urbs[i]->transfer_buffer == NULL)
1304                                 goto allocfail;
1305                         usb_fill_bulk_urb(usb->audio_urbs[i], usb->usbdev,
1306                                 usb_rcvbulkpipe(usb->usbdev, 8),
1307                                 usb->audio_urbs[i]->transfer_buffer, 4096,
1308                                 go7007_usb_read_audio_pipe_complete, go);
1309                 }
1310         }
1311
1312         /* Do any final GO7007 initialization, then register the
1313          * V4L2 and ALSA interfaces */
1314         if (go7007_register_encoder(go, num_i2c_devs) < 0)
1315                 goto allocfail;
1316
1317         go->status = STATUS_ONLINE;
1318         return 0;
1319
1320 allocfail:
1321         go7007_usb_release(go);
1322         kfree(go);
1323         return -ENOMEM;
1324 }
1325
1326 static void go7007_usb_disconnect(struct usb_interface *intf)
1327 {
1328         struct go7007 *go = to_go7007(usb_get_intfdata(intf));
1329
1330         mutex_lock(&go->queue_lock);
1331         mutex_lock(&go->serialize_lock);
1332
1333         if (go->audio_enabled)
1334                 go7007_snd_remove(go);
1335
1336         go->status = STATUS_SHUTDOWN;
1337         v4l2_device_disconnect(&go->v4l2_dev);
1338         video_unregister_device(&go->vdev);
1339         mutex_unlock(&go->serialize_lock);
1340         mutex_unlock(&go->queue_lock);
1341
1342         v4l2_device_put(&go->v4l2_dev);
1343 }
1344
1345 static struct usb_driver go7007_usb_driver = {
1346         .name           = "go7007",
1347         .probe          = go7007_usb_probe,
1348         .disconnect     = go7007_usb_disconnect,
1349         .id_table       = go7007_usb_id_table,
1350 };
1351
1352 module_usb_driver(go7007_usb_driver);
1353 MODULE_LICENSE("GPL v2");