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