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