1 /* 2 * USB Attached SCSI 3 * Note that this is not the same as the USB Mass Storage driver 4 * 5 * Copyright Matthew Wilcox for Intel Corp, 2010 6 * Copyright Sarah Sharp for Intel Corp, 2010 7 * 8 * Distributed under the terms of the GNU GPL, version two. 9 */ 10 11 #include <linux/blkdev.h> 12 #include <linux/slab.h> 13 #include <linux/types.h> 14 #include <linux/usb.h> 15 #include <linux/usb/storage.h> 16 17 #include <scsi/scsi.h> 18 #include <scsi/scsi_dbg.h> 19 #include <scsi/scsi_cmnd.h> 20 #include <scsi/scsi_device.h> 21 #include <scsi/scsi_host.h> 22 #include <scsi/scsi_tcq.h> 23 24 /* Common header for all IUs */ 25 struct iu { 26 __u8 iu_id; 27 __u8 rsvd1; 28 __be16 tag; 29 }; 30 31 enum { 32 IU_ID_COMMAND = 0x01, 33 IU_ID_STATUS = 0x03, 34 IU_ID_RESPONSE = 0x04, 35 IU_ID_TASK_MGMT = 0x05, 36 IU_ID_READ_READY = 0x06, 37 IU_ID_WRITE_READY = 0x07, 38 }; 39 40 struct command_iu { 41 __u8 iu_id; 42 __u8 rsvd1; 43 __be16 tag; 44 __u8 prio_attr; 45 __u8 rsvd5; 46 __u8 len; 47 __u8 rsvd7; 48 struct scsi_lun lun; 49 __u8 cdb[16]; /* XXX: Overflow-checking tools may misunderstand */ 50 }; 51 52 /* 53 * Also used for the Read Ready and Write Ready IUs since they have the 54 * same first four bytes 55 */ 56 struct sense_iu { 57 __u8 iu_id; 58 __u8 rsvd1; 59 __be16 tag; 60 __be16 status_qual; 61 __u8 status; 62 __u8 rsvd7[7]; 63 __be16 len; 64 __u8 sense[SCSI_SENSE_BUFFERSIZE]; 65 }; 66 67 /* 68 * The r00-r01c specs define this version of the SENSE IU data structure. 69 * It's still in use by several different firmware releases. 70 */ 71 struct sense_iu_old { 72 __u8 iu_id; 73 __u8 rsvd1; 74 __be16 tag; 75 __be16 len; 76 __u8 status; 77 __u8 service_response; 78 __u8 sense[SCSI_SENSE_BUFFERSIZE]; 79 }; 80 81 enum { 82 CMD_PIPE_ID = 1, 83 STATUS_PIPE_ID = 2, 84 DATA_IN_PIPE_ID = 3, 85 DATA_OUT_PIPE_ID = 4, 86 87 UAS_SIMPLE_TAG = 0, 88 UAS_HEAD_TAG = 1, 89 UAS_ORDERED_TAG = 2, 90 UAS_ACA = 4, 91 }; 92 93 struct uas_dev_info { 94 struct usb_interface *intf; 95 struct usb_device *udev; 96 int qdepth; 97 unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe; 98 unsigned use_streams:1; 99 unsigned uas_sense_old:1; 100 }; 101 102 enum { 103 ALLOC_STATUS_URB = (1 << 0), 104 SUBMIT_STATUS_URB = (1 << 1), 105 ALLOC_DATA_IN_URB = (1 << 2), 106 SUBMIT_DATA_IN_URB = (1 << 3), 107 ALLOC_DATA_OUT_URB = (1 << 4), 108 SUBMIT_DATA_OUT_URB = (1 << 5), 109 ALLOC_CMD_URB = (1 << 6), 110 SUBMIT_CMD_URB = (1 << 7), 111 }; 112 113 /* Overrides scsi_pointer */ 114 struct uas_cmd_info { 115 unsigned int state; 116 unsigned int stream; 117 struct urb *cmd_urb; 118 struct urb *status_urb; 119 struct urb *data_in_urb; 120 struct urb *data_out_urb; 121 struct list_head list; 122 }; 123 124 /* I hate forward declarations, but I actually have a loop */ 125 static int uas_submit_urbs(struct scsi_cmnd *cmnd, 126 struct uas_dev_info *devinfo, gfp_t gfp); 127 128 static DEFINE_SPINLOCK(uas_work_lock); 129 static LIST_HEAD(uas_work_list); 130 131 static void uas_do_work(struct work_struct *work) 132 { 133 struct uas_cmd_info *cmdinfo; 134 struct list_head list; 135 136 spin_lock_irq(&uas_work_lock); 137 list_replace_init(&uas_work_list, &list); 138 spin_unlock_irq(&uas_work_lock); 139 140 list_for_each_entry(cmdinfo, &list, list) { 141 struct scsi_pointer *scp = (void *)cmdinfo; 142 struct scsi_cmnd *cmnd = container_of(scp, 143 struct scsi_cmnd, SCp); 144 uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO); 145 } 146 } 147 148 static DECLARE_WORK(uas_work, uas_do_work); 149 150 static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd) 151 { 152 struct sense_iu *sense_iu = urb->transfer_buffer; 153 struct scsi_device *sdev = cmnd->device; 154 155 if (urb->actual_length > 16) { 156 unsigned len = be16_to_cpup(&sense_iu->len); 157 if (len + 16 != urb->actual_length) { 158 int newlen = min(len + 16, urb->actual_length) - 16; 159 if (newlen < 0) 160 newlen = 0; 161 sdev_printk(KERN_INFO, sdev, "%s: urb length %d " 162 "disagrees with IU sense data length %d, " 163 "using %d bytes of sense data\n", __func__, 164 urb->actual_length, len, newlen); 165 len = newlen; 166 } 167 memcpy(cmnd->sense_buffer, sense_iu->sense, len); 168 } 169 170 cmnd->result = sense_iu->status; 171 if (sdev->current_cmnd) 172 sdev->current_cmnd = NULL; 173 cmnd->scsi_done(cmnd); 174 usb_free_urb(urb); 175 } 176 177 static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd) 178 { 179 struct sense_iu_old *sense_iu = urb->transfer_buffer; 180 struct scsi_device *sdev = cmnd->device; 181 182 if (urb->actual_length > 8) { 183 unsigned len = be16_to_cpup(&sense_iu->len) - 2; 184 if (len + 8 != urb->actual_length) { 185 int newlen = min(len + 8, urb->actual_length) - 8; 186 if (newlen < 0) 187 newlen = 0; 188 sdev_printk(KERN_INFO, sdev, "%s: urb length %d " 189 "disagrees with IU sense data length %d, " 190 "using %d bytes of sense data\n", __func__, 191 urb->actual_length, len, newlen); 192 len = newlen; 193 } 194 memcpy(cmnd->sense_buffer, sense_iu->sense, len); 195 } 196 197 cmnd->result = sense_iu->status; 198 if (sdev->current_cmnd) 199 sdev->current_cmnd = NULL; 200 cmnd->scsi_done(cmnd); 201 usb_free_urb(urb); 202 } 203 204 static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd, 205 unsigned direction) 206 { 207 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 208 int err; 209 210 cmdinfo->state = direction | SUBMIT_STATUS_URB; 211 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC); 212 if (err) { 213 spin_lock(&uas_work_lock); 214 list_add_tail(&cmdinfo->list, &uas_work_list); 215 spin_unlock(&uas_work_lock); 216 schedule_work(&uas_work); 217 } 218 } 219 220 static void uas_stat_cmplt(struct urb *urb) 221 { 222 struct iu *iu = urb->transfer_buffer; 223 struct scsi_device *sdev = urb->context; 224 struct uas_dev_info *devinfo = sdev->hostdata; 225 struct scsi_cmnd *cmnd; 226 u16 tag; 227 228 if (urb->status) { 229 dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status); 230 usb_free_urb(urb); 231 return; 232 } 233 234 tag = be16_to_cpup(&iu->tag) - 1; 235 if (sdev->current_cmnd) 236 cmnd = sdev->current_cmnd; 237 else 238 cmnd = scsi_find_tag(sdev, tag); 239 if (!cmnd) 240 return; 241 242 switch (iu->iu_id) { 243 case IU_ID_STATUS: 244 if (urb->actual_length < 16) 245 devinfo->uas_sense_old = 1; 246 if (devinfo->uas_sense_old) 247 uas_sense_old(urb, cmnd); 248 else 249 uas_sense(urb, cmnd); 250 break; 251 case IU_ID_READ_READY: 252 uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB); 253 break; 254 case IU_ID_WRITE_READY: 255 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB); 256 break; 257 default: 258 scmd_printk(KERN_ERR, cmnd, 259 "Bogus IU (%d) received on status pipe\n", iu->iu_id); 260 } 261 } 262 263 static void uas_data_cmplt(struct urb *urb) 264 { 265 struct scsi_data_buffer *sdb = urb->context; 266 sdb->resid = sdb->length - urb->actual_length; 267 usb_free_urb(urb); 268 } 269 270 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp, 271 unsigned int pipe, u16 stream_id, 272 struct scsi_data_buffer *sdb, 273 enum dma_data_direction dir) 274 { 275 struct usb_device *udev = devinfo->udev; 276 struct urb *urb = usb_alloc_urb(0, gfp); 277 278 if (!urb) 279 goto out; 280 usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt, 281 sdb); 282 if (devinfo->use_streams) 283 urb->stream_id = stream_id; 284 urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0; 285 urb->sg = sdb->table.sgl; 286 out: 287 return urb; 288 } 289 290 static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp, 291 struct scsi_cmnd *cmnd, u16 stream_id) 292 { 293 struct usb_device *udev = devinfo->udev; 294 struct urb *urb = usb_alloc_urb(0, gfp); 295 struct sense_iu *iu; 296 297 if (!urb) 298 goto out; 299 300 iu = kzalloc(sizeof(*iu), gfp); 301 if (!iu) 302 goto free; 303 304 usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu), 305 uas_stat_cmplt, cmnd->device); 306 urb->stream_id = stream_id; 307 urb->transfer_flags |= URB_FREE_BUFFER; 308 out: 309 return urb; 310 free: 311 usb_free_urb(urb); 312 return NULL; 313 } 314 315 static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp, 316 struct scsi_cmnd *cmnd, u16 stream_id) 317 { 318 struct usb_device *udev = devinfo->udev; 319 struct scsi_device *sdev = cmnd->device; 320 struct urb *urb = usb_alloc_urb(0, gfp); 321 struct command_iu *iu; 322 int len; 323 324 if (!urb) 325 goto out; 326 327 len = cmnd->cmd_len - 16; 328 if (len < 0) 329 len = 0; 330 len = ALIGN(len, 4); 331 iu = kzalloc(sizeof(*iu) + len, gfp); 332 if (!iu) 333 goto free; 334 335 iu->iu_id = IU_ID_COMMAND; 336 iu->tag = cpu_to_be16(stream_id); 337 iu->prio_attr = UAS_SIMPLE_TAG; 338 iu->len = len; 339 int_to_scsilun(sdev->lun, &iu->lun); 340 memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len); 341 342 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len, 343 usb_free_urb, NULL); 344 urb->transfer_flags |= URB_FREE_BUFFER; 345 out: 346 return urb; 347 free: 348 usb_free_urb(urb); 349 return NULL; 350 } 351 352 /* 353 * Why should I request the Status IU before sending the Command IU? Spec 354 * says to, but also says the device may receive them in any order. Seems 355 * daft to me. 356 */ 357 358 static int uas_submit_urbs(struct scsi_cmnd *cmnd, 359 struct uas_dev_info *devinfo, gfp_t gfp) 360 { 361 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 362 363 if (cmdinfo->state & ALLOC_STATUS_URB) { 364 cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd, 365 cmdinfo->stream); 366 if (!cmdinfo->status_urb) 367 return SCSI_MLQUEUE_DEVICE_BUSY; 368 cmdinfo->state &= ~ALLOC_STATUS_URB; 369 } 370 371 if (cmdinfo->state & SUBMIT_STATUS_URB) { 372 if (usb_submit_urb(cmdinfo->status_urb, gfp)) { 373 scmd_printk(KERN_INFO, cmnd, 374 "sense urb submission failure\n"); 375 return SCSI_MLQUEUE_DEVICE_BUSY; 376 } 377 cmdinfo->state &= ~SUBMIT_STATUS_URB; 378 } 379 380 if (cmdinfo->state & ALLOC_DATA_IN_URB) { 381 cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp, 382 devinfo->data_in_pipe, cmdinfo->stream, 383 scsi_in(cmnd), DMA_FROM_DEVICE); 384 if (!cmdinfo->data_in_urb) 385 return SCSI_MLQUEUE_DEVICE_BUSY; 386 cmdinfo->state &= ~ALLOC_DATA_IN_URB; 387 } 388 389 if (cmdinfo->state & SUBMIT_DATA_IN_URB) { 390 if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) { 391 scmd_printk(KERN_INFO, cmnd, 392 "data in urb submission failure\n"); 393 return SCSI_MLQUEUE_DEVICE_BUSY; 394 } 395 cmdinfo->state &= ~SUBMIT_DATA_IN_URB; 396 } 397 398 if (cmdinfo->state & ALLOC_DATA_OUT_URB) { 399 cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp, 400 devinfo->data_out_pipe, cmdinfo->stream, 401 scsi_out(cmnd), DMA_TO_DEVICE); 402 if (!cmdinfo->data_out_urb) 403 return SCSI_MLQUEUE_DEVICE_BUSY; 404 cmdinfo->state &= ~ALLOC_DATA_OUT_URB; 405 } 406 407 if (cmdinfo->state & SUBMIT_DATA_OUT_URB) { 408 if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) { 409 scmd_printk(KERN_INFO, cmnd, 410 "data out urb submission failure\n"); 411 return SCSI_MLQUEUE_DEVICE_BUSY; 412 } 413 cmdinfo->state &= ~SUBMIT_DATA_OUT_URB; 414 } 415 416 if (cmdinfo->state & ALLOC_CMD_URB) { 417 cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd, 418 cmdinfo->stream); 419 if (!cmdinfo->cmd_urb) 420 return SCSI_MLQUEUE_DEVICE_BUSY; 421 cmdinfo->state &= ~ALLOC_CMD_URB; 422 } 423 424 if (cmdinfo->state & SUBMIT_CMD_URB) { 425 if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) { 426 scmd_printk(KERN_INFO, cmnd, 427 "cmd urb submission failure\n"); 428 return SCSI_MLQUEUE_DEVICE_BUSY; 429 } 430 cmdinfo->state &= ~SUBMIT_CMD_URB; 431 } 432 433 return 0; 434 } 435 436 static int uas_queuecommand_lck(struct scsi_cmnd *cmnd, 437 void (*done)(struct scsi_cmnd *)) 438 { 439 struct scsi_device *sdev = cmnd->device; 440 struct uas_dev_info *devinfo = sdev->hostdata; 441 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 442 int err; 443 444 BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer)); 445 446 if (!cmdinfo->status_urb && sdev->current_cmnd) 447 return SCSI_MLQUEUE_DEVICE_BUSY; 448 449 if (blk_rq_tagged(cmnd->request)) { 450 cmdinfo->stream = cmnd->request->tag + 1; 451 } else { 452 sdev->current_cmnd = cmnd; 453 cmdinfo->stream = 1; 454 } 455 456 cmnd->scsi_done = done; 457 458 cmdinfo->state = ALLOC_STATUS_URB | SUBMIT_STATUS_URB | 459 ALLOC_CMD_URB | SUBMIT_CMD_URB; 460 461 switch (cmnd->sc_data_direction) { 462 case DMA_FROM_DEVICE: 463 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB; 464 break; 465 case DMA_BIDIRECTIONAL: 466 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB; 467 case DMA_TO_DEVICE: 468 cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB; 469 case DMA_NONE: 470 break; 471 } 472 473 if (!devinfo->use_streams) { 474 cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB); 475 cmdinfo->stream = 0; 476 } 477 478 err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC); 479 if (err) { 480 /* If we did nothing, give up now */ 481 if (cmdinfo->state & SUBMIT_STATUS_URB) { 482 usb_free_urb(cmdinfo->status_urb); 483 return SCSI_MLQUEUE_DEVICE_BUSY; 484 } 485 spin_lock(&uas_work_lock); 486 list_add_tail(&cmdinfo->list, &uas_work_list); 487 spin_unlock(&uas_work_lock); 488 schedule_work(&uas_work); 489 } 490 491 return 0; 492 } 493 494 static DEF_SCSI_QCMD(uas_queuecommand) 495 496 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd) 497 { 498 struct scsi_device *sdev = cmnd->device; 499 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__, 500 cmnd->request->tag); 501 502 /* XXX: Send ABORT TASK Task Management command */ 503 return FAILED; 504 } 505 506 static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd) 507 { 508 struct scsi_device *sdev = cmnd->device; 509 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__, 510 cmnd->request->tag); 511 512 /* XXX: Send LOGICAL UNIT RESET Task Management command */ 513 return FAILED; 514 } 515 516 static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd) 517 { 518 struct scsi_device *sdev = cmnd->device; 519 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__, 520 cmnd->request->tag); 521 522 /* XXX: Can we reset just the one USB interface? 523 * Would calling usb_set_interface() have the right effect? 524 */ 525 return FAILED; 526 } 527 528 static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd) 529 { 530 struct scsi_device *sdev = cmnd->device; 531 struct uas_dev_info *devinfo = sdev->hostdata; 532 struct usb_device *udev = devinfo->udev; 533 534 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__, 535 cmnd->request->tag); 536 537 if (usb_reset_device(udev)) 538 return SUCCESS; 539 540 return FAILED; 541 } 542 543 static int uas_slave_alloc(struct scsi_device *sdev) 544 { 545 sdev->hostdata = (void *)sdev->host->hostdata[0]; 546 return 0; 547 } 548 549 static int uas_slave_configure(struct scsi_device *sdev) 550 { 551 struct uas_dev_info *devinfo = sdev->hostdata; 552 scsi_set_tag_type(sdev, MSG_ORDERED_TAG); 553 scsi_activate_tcq(sdev, devinfo->qdepth - 1); 554 return 0; 555 } 556 557 static struct scsi_host_template uas_host_template = { 558 .module = THIS_MODULE, 559 .name = "uas", 560 .queuecommand = uas_queuecommand, 561 .slave_alloc = uas_slave_alloc, 562 .slave_configure = uas_slave_configure, 563 .eh_abort_handler = uas_eh_abort_handler, 564 .eh_device_reset_handler = uas_eh_device_reset_handler, 565 .eh_target_reset_handler = uas_eh_target_reset_handler, 566 .eh_bus_reset_handler = uas_eh_bus_reset_handler, 567 .can_queue = 65536, /* Is there a limit on the _host_ ? */ 568 .this_id = -1, 569 .sg_tablesize = SG_NONE, 570 .cmd_per_lun = 1, /* until we override it */ 571 .skip_settle_delay = 1, 572 .ordered_tag = 1, 573 }; 574 575 static struct usb_device_id uas_usb_ids[] = { 576 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) }, 577 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) }, 578 /* 0xaa is a prototype device I happen to have access to */ 579 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) }, 580 { } 581 }; 582 MODULE_DEVICE_TABLE(usb, uas_usb_ids); 583 584 static int uas_is_interface(struct usb_host_interface *intf) 585 { 586 return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE && 587 intf->desc.bInterfaceSubClass == USB_SC_SCSI && 588 intf->desc.bInterfaceProtocol == USB_PR_UAS); 589 } 590 591 static int uas_switch_interface(struct usb_device *udev, 592 struct usb_interface *intf) 593 { 594 int i; 595 596 if (uas_is_interface(intf->cur_altsetting)) 597 return 0; 598 599 for (i = 0; i < intf->num_altsetting; i++) { 600 struct usb_host_interface *alt = &intf->altsetting[i]; 601 if (alt == intf->cur_altsetting) 602 continue; 603 if (uas_is_interface(alt)) 604 return usb_set_interface(udev, 605 alt->desc.bInterfaceNumber, 606 alt->desc.bAlternateSetting); 607 } 608 609 return -ENODEV; 610 } 611 612 static void uas_configure_endpoints(struct uas_dev_info *devinfo) 613 { 614 struct usb_host_endpoint *eps[4] = { }; 615 struct usb_interface *intf = devinfo->intf; 616 struct usb_device *udev = devinfo->udev; 617 struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint; 618 unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints; 619 620 devinfo->uas_sense_old = 0; 621 622 for (i = 0; i < n_endpoints; i++) { 623 unsigned char *extra = endpoint[i].extra; 624 int len = endpoint[i].extralen; 625 while (len > 1) { 626 if (extra[1] == USB_DT_PIPE_USAGE) { 627 unsigned pipe_id = extra[2]; 628 if (pipe_id > 0 && pipe_id < 5) 629 eps[pipe_id - 1] = &endpoint[i]; 630 break; 631 } 632 len -= extra[0]; 633 extra += extra[0]; 634 } 635 } 636 637 /* 638 * Assume that if we didn't find a control pipe descriptor, we're 639 * using a device with old firmware that happens to be set up like 640 * this. 641 */ 642 if (!eps[0]) { 643 devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1); 644 devinfo->status_pipe = usb_rcvbulkpipe(udev, 1); 645 devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2); 646 devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2); 647 648 eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe); 649 eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe); 650 eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe); 651 } else { 652 devinfo->cmd_pipe = usb_sndbulkpipe(udev, 653 eps[0]->desc.bEndpointAddress); 654 devinfo->status_pipe = usb_rcvbulkpipe(udev, 655 eps[1]->desc.bEndpointAddress); 656 devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 657 eps[2]->desc.bEndpointAddress); 658 devinfo->data_out_pipe = usb_sndbulkpipe(udev, 659 eps[3]->desc.bEndpointAddress); 660 } 661 662 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256, 663 GFP_KERNEL); 664 if (devinfo->qdepth < 0) { 665 devinfo->qdepth = 256; 666 devinfo->use_streams = 0; 667 } else { 668 devinfo->use_streams = 1; 669 } 670 } 671 672 /* 673 * XXX: What I'd like to do here is register a SCSI host for each USB host in 674 * the system. Follow usb-storage's design of registering a SCSI host for 675 * each USB device for the moment. Can implement this by walking up the 676 * USB hierarchy until we find a USB host. 677 */ 678 static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id) 679 { 680 int result; 681 struct Scsi_Host *shost; 682 struct uas_dev_info *devinfo; 683 struct usb_device *udev = interface_to_usbdev(intf); 684 685 if (uas_switch_interface(udev, intf)) 686 return -ENODEV; 687 688 devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL); 689 if (!devinfo) 690 return -ENOMEM; 691 692 result = -ENOMEM; 693 shost = scsi_host_alloc(&uas_host_template, sizeof(void *)); 694 if (!shost) 695 goto free; 696 697 shost->max_cmd_len = 16 + 252; 698 shost->max_id = 1; 699 shost->sg_tablesize = udev->bus->sg_tablesize; 700 701 result = scsi_add_host(shost, &intf->dev); 702 if (result) 703 goto free; 704 shost->hostdata[0] = (unsigned long)devinfo; 705 706 devinfo->intf = intf; 707 devinfo->udev = udev; 708 uas_configure_endpoints(devinfo); 709 710 scsi_scan_host(shost); 711 usb_set_intfdata(intf, shost); 712 return result; 713 free: 714 kfree(devinfo); 715 if (shost) 716 scsi_host_put(shost); 717 return result; 718 } 719 720 static int uas_pre_reset(struct usb_interface *intf) 721 { 722 /* XXX: Need to return 1 if it's not our device in error handling */ 723 return 0; 724 } 725 726 static int uas_post_reset(struct usb_interface *intf) 727 { 728 /* XXX: Need to return 1 if it's not our device in error handling */ 729 return 0; 730 } 731 732 static void uas_disconnect(struct usb_interface *intf) 733 { 734 struct usb_device *udev = interface_to_usbdev(intf); 735 struct usb_host_endpoint *eps[3]; 736 struct Scsi_Host *shost = usb_get_intfdata(intf); 737 struct uas_dev_info *devinfo = (void *)shost->hostdata[0]; 738 739 scsi_remove_host(shost); 740 741 eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe); 742 eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe); 743 eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe); 744 usb_free_streams(intf, eps, 3, GFP_KERNEL); 745 746 kfree(devinfo); 747 } 748 749 /* 750 * XXX: Should this plug into libusual so we can auto-upgrade devices from 751 * Bulk-Only to UAS? 752 */ 753 static struct usb_driver uas_driver = { 754 .name = "uas", 755 .probe = uas_probe, 756 .disconnect = uas_disconnect, 757 .pre_reset = uas_pre_reset, 758 .post_reset = uas_post_reset, 759 .id_table = uas_usb_ids, 760 }; 761 762 static int uas_init(void) 763 { 764 return usb_register(&uas_driver); 765 } 766 767 static void uas_exit(void) 768 { 769 usb_deregister(&uas_driver); 770 } 771 772 module_init(uas_init); 773 module_exit(uas_exit); 774 775 MODULE_LICENSE("GPL"); 776 MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp"); 777