drivers/staging/media/go7007/go7007-usb.c

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