1 /* 2 * USB Attached SCSI 3 * Note that this is not the same as the USB Mass Storage driver 4 * 5 * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 6 * Copyright Matthew Wilcox for Intel Corp, 2010 7 * Copyright Sarah Sharp for Intel Corp, 2010 8 * 9 * Distributed under the terms of the GNU GPL, version two. 10 */ 11 12 #include <linux/blkdev.h> 13 #include <linux/slab.h> 14 #include <linux/types.h> 15 #include <linux/module.h> 16 #include <linux/usb.h> 17 #include <linux/usb_usual.h> 18 #include <linux/usb/hcd.h> 19 #include <linux/usb/storage.h> 20 #include <linux/usb/uas.h> 21 22 #include <scsi/scsi.h> 23 #include <scsi/scsi_eh.h> 24 #include <scsi/scsi_dbg.h> 25 #include <scsi/scsi_cmnd.h> 26 #include <scsi/scsi_device.h> 27 #include <scsi/scsi_host.h> 28 #include <scsi/scsi_tcq.h> 29 30 #include "uas-detect.h" 31 32 /* 33 * The r00-r01c specs define this version of the SENSE IU data structure. 34 * It's still in use by several different firmware releases. 35 */ 36 struct sense_iu_old { 37 __u8 iu_id; 38 __u8 rsvd1; 39 __be16 tag; 40 __be16 len; 41 __u8 status; 42 __u8 service_response; 43 __u8 sense[SCSI_SENSE_BUFFERSIZE]; 44 }; 45 46 struct uas_dev_info { 47 struct usb_interface *intf; 48 struct usb_device *udev; 49 struct usb_anchor cmd_urbs; 50 struct usb_anchor sense_urbs; 51 struct usb_anchor data_urbs; 52 int qdepth, resetting; 53 struct response_iu response; 54 unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe; 55 unsigned use_streams:1; 56 unsigned uas_sense_old:1; 57 unsigned running_task:1; 58 unsigned shutdown:1; 59 struct scsi_cmnd *cmnd; 60 spinlock_t lock; 61 struct work_struct work; 62 struct list_head inflight_list; 63 struct list_head dead_list; 64 }; 65 66 enum { 67 SUBMIT_STATUS_URB = (1 << 1), 68 ALLOC_DATA_IN_URB = (1 << 2), 69 SUBMIT_DATA_IN_URB = (1 << 3), 70 ALLOC_DATA_OUT_URB = (1 << 4), 71 SUBMIT_DATA_OUT_URB = (1 << 5), 72 ALLOC_CMD_URB = (1 << 6), 73 SUBMIT_CMD_URB = (1 << 7), 74 COMMAND_INFLIGHT = (1 << 8), 75 DATA_IN_URB_INFLIGHT = (1 << 9), 76 DATA_OUT_URB_INFLIGHT = (1 << 10), 77 COMMAND_COMPLETED = (1 << 11), 78 COMMAND_ABORTED = (1 << 12), 79 UNLINK_DATA_URBS = (1 << 13), 80 IS_IN_WORK_LIST = (1 << 14), 81 }; 82 83 /* Overrides scsi_pointer */ 84 struct uas_cmd_info { 85 unsigned int state; 86 unsigned int stream; 87 struct urb *cmd_urb; 88 struct urb *data_in_urb; 89 struct urb *data_out_urb; 90 struct list_head list; 91 }; 92 93 /* I hate forward declarations, but I actually have a loop */ 94 static int uas_submit_urbs(struct scsi_cmnd *cmnd, 95 struct uas_dev_info *devinfo, gfp_t gfp); 96 static void uas_do_work(struct work_struct *work); 97 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller); 98 static void uas_free_streams(struct uas_dev_info *devinfo); 99 static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller); 100 101 /* Must be called with devinfo->lock held, will temporary unlock the lock */ 102 static void uas_unlink_data_urbs(struct uas_dev_info *devinfo, 103 struct uas_cmd_info *cmdinfo, 104 unsigned long *lock_flags) 105 { 106 /* 107 * The UNLINK_DATA_URBS flag makes sure uas_try_complete 108 * (called by urb completion) doesn't release cmdinfo 109 * underneath us. 110 */ 111 cmdinfo->state |= UNLINK_DATA_URBS; 112 spin_unlock_irqrestore(&devinfo->lock, *lock_flags); 113 114 if (cmdinfo->data_in_urb) 115 usb_unlink_urb(cmdinfo->data_in_urb); 116 if (cmdinfo->data_out_urb) 117 usb_unlink_urb(cmdinfo->data_out_urb); 118 119 spin_lock_irqsave(&devinfo->lock, *lock_flags); 120 cmdinfo->state &= ~UNLINK_DATA_URBS; 121 } 122 123 static void uas_do_work(struct work_struct *work) 124 { 125 struct uas_dev_info *devinfo = 126 container_of(work, struct uas_dev_info, work); 127 struct uas_cmd_info *cmdinfo; 128 unsigned long flags; 129 int err; 130 131 spin_lock_irqsave(&devinfo->lock, flags); 132 list_for_each_entry(cmdinfo, &devinfo->inflight_list, list) { 133 struct scsi_pointer *scp = (void *)cmdinfo; 134 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, 135 SCp); 136 137 if (!(cmdinfo->state & IS_IN_WORK_LIST)) 138 continue; 139 140 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC); 141 if (!err) 142 cmdinfo->state &= ~IS_IN_WORK_LIST; 143 else 144 schedule_work(&devinfo->work); 145 } 146 spin_unlock_irqrestore(&devinfo->lock, flags); 147 } 148 149 static void uas_mark_cmd_dead(struct uas_dev_info *devinfo, 150 struct uas_cmd_info *cmdinfo, 151 int result, const char *caller) 152 { 153 struct scsi_pointer *scp = (void *)cmdinfo; 154 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, SCp); 155 156 uas_log_cmd_state(cmnd, caller); 157 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock)); 158 WARN_ON_ONCE(cmdinfo->state & COMMAND_ABORTED); 159 cmdinfo->state |= COMMAND_ABORTED; 160 cmdinfo->state &= ~IS_IN_WORK_LIST; 161 cmnd->result = result << 16; 162 list_move_tail(&cmdinfo->list, &devinfo->dead_list); 163 } 164 165 static void uas_abort_inflight(struct uas_dev_info *devinfo, int result, 166 const char *caller) 167 { 168 struct uas_cmd_info *cmdinfo; 169 struct uas_cmd_info *temp; 170 unsigned long flags; 171 172 spin_lock_irqsave(&devinfo->lock, flags); 173 list_for_each_entry_safe(cmdinfo, temp, &devinfo->inflight_list, list) 174 uas_mark_cmd_dead(devinfo, cmdinfo, result, caller); 175 spin_unlock_irqrestore(&devinfo->lock, flags); 176 } 177 178 static void uas_add_work(struct uas_cmd_info *cmdinfo) 179 { 180 struct scsi_pointer *scp = (void *)cmdinfo; 181 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, SCp); 182 struct uas_dev_info *devinfo = cmnd->device->hostdata; 183 184 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock)); 185 cmdinfo->state |= IS_IN_WORK_LIST; 186 schedule_work(&devinfo->work); 187 } 188 189 static void uas_zap_dead(struct uas_dev_info *devinfo) 190 { 191 struct uas_cmd_info *cmdinfo; 192 struct uas_cmd_info *temp; 193 unsigned long flags; 194 195 spin_lock_irqsave(&devinfo->lock, flags); 196 list_for_each_entry_safe(cmdinfo, temp, &devinfo->dead_list, list) { 197 struct scsi_pointer *scp = (void *)cmdinfo; 198 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, 199 SCp); 200 uas_log_cmd_state(cmnd, __func__); 201 WARN_ON_ONCE(!(cmdinfo->state & COMMAND_ABORTED)); 202 /* all urbs are killed, clear inflight bits */ 203 cmdinfo->state &= ~(COMMAND_INFLIGHT | 204 DATA_IN_URB_INFLIGHT | 205 DATA_OUT_URB_INFLIGHT); 206 uas_try_complete(cmnd, __func__); 207 } 208 devinfo->running_task = 0; 209 spin_unlock_irqrestore(&devinfo->lock, flags); 210 } 211 212 static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd) 213 { 214 struct sense_iu *sense_iu = urb->transfer_buffer; 215 struct scsi_device *sdev = cmnd->device; 216 217 if (urb->actual_length > 16) { 218 unsigned len = be16_to_cpup(&sense_iu->len); 219 if (len + 16 != urb->actual_length) { 220 int newlen = min(len + 16, urb->actual_length) - 16; 221 if (newlen < 0) 222 newlen = 0; 223 sdev_printk(KERN_INFO, sdev, "%s: urb length %d " 224 "disagrees with IU sense data length %d, " 225 "using %d bytes of sense data\n", __func__, 226 urb->actual_length, len, newlen); 227 len = newlen; 228 } 229 memcpy(cmnd->sense_buffer, sense_iu->sense, len); 230 } 231 232 cmnd->result = sense_iu->status; 233 } 234 235 static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd) 236 { 237 struct sense_iu_old *sense_iu = urb->transfer_buffer; 238 struct scsi_device *sdev = cmnd->device; 239 240 if (urb->actual_length > 8) { 241 unsigned len = be16_to_cpup(&sense_iu->len) - 2; 242 if (len + 8 != urb->actual_length) { 243 int newlen = min(len + 8, urb->actual_length) - 8; 244 if (newlen < 0) 245 newlen = 0; 246 sdev_printk(KERN_INFO, sdev, "%s: urb length %d " 247 "disagrees with IU sense data length %d, " 248 "using %d bytes of sense data\n", __func__, 249 urb->actual_length, len, newlen); 250 len = newlen; 251 } 252 memcpy(cmnd->sense_buffer, sense_iu->sense, len); 253 } 254 255 cmnd->result = sense_iu->status; 256 } 257 258 static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller) 259 { 260 struct uas_cmd_info *ci = (void *)&cmnd->SCp; 261 262 scmd_printk(KERN_INFO, cmnd, "%s %p tag %d, inflight:" 263 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", 264 caller, cmnd, cmnd->request->tag, 265 (ci->state & SUBMIT_STATUS_URB) ? " s-st" : "", 266 (ci->state & ALLOC_DATA_IN_URB) ? " a-in" : "", 267 (ci->state & SUBMIT_DATA_IN_URB) ? " s-in" : "", 268 (ci->state & ALLOC_DATA_OUT_URB) ? " a-out" : "", 269 (ci->state & SUBMIT_DATA_OUT_URB) ? " s-out" : "", 270 (ci->state & ALLOC_CMD_URB) ? " a-cmd" : "", 271 (ci->state & SUBMIT_CMD_URB) ? " s-cmd" : "", 272 (ci->state & COMMAND_INFLIGHT) ? " CMD" : "", 273 (ci->state & DATA_IN_URB_INFLIGHT) ? " IN" : "", 274 (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT" : "", 275 (ci->state & COMMAND_COMPLETED) ? " done" : "", 276 (ci->state & COMMAND_ABORTED) ? " abort" : "", 277 (ci->state & UNLINK_DATA_URBS) ? " unlink": "", 278 (ci->state & IS_IN_WORK_LIST) ? " work" : ""); 279 } 280 281 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller) 282 { 283 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 284 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata; 285 286 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock)); 287 if (cmdinfo->state & (COMMAND_INFLIGHT | 288 DATA_IN_URB_INFLIGHT | 289 DATA_OUT_URB_INFLIGHT | 290 UNLINK_DATA_URBS)) 291 return -EBUSY; 292 WARN_ON_ONCE(cmdinfo->state & COMMAND_COMPLETED); 293 cmdinfo->state |= COMMAND_COMPLETED; 294 usb_free_urb(cmdinfo->data_in_urb); 295 usb_free_urb(cmdinfo->data_out_urb); 296 if (cmdinfo->state & COMMAND_ABORTED) 297 scmd_printk(KERN_INFO, cmnd, "abort completed\n"); 298 list_del(&cmdinfo->list); 299 cmnd->scsi_done(cmnd); 300 return 0; 301 } 302 303 static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd, 304 unsigned direction) 305 { 306 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 307 int err; 308 309 cmdinfo->state |= direction | SUBMIT_STATUS_URB; 310 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC); 311 if (err) { 312 uas_add_work(cmdinfo); 313 } 314 } 315 316 static void uas_stat_cmplt(struct urb *urb) 317 { 318 struct iu *iu = urb->transfer_buffer; 319 struct Scsi_Host *shost = urb->context; 320 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 321 struct scsi_cmnd *cmnd; 322 struct uas_cmd_info *cmdinfo; 323 unsigned long flags; 324 u16 tag; 325 326 if (urb->status) { 327 if (urb->status == -ENOENT) { 328 dev_err(&urb->dev->dev, "stat urb: killed, stream %d\n", 329 urb->stream_id); 330 } else { 331 dev_err(&urb->dev->dev, "stat urb: status %d\n", 332 urb->status); 333 } 334 usb_free_urb(urb); 335 return; 336 } 337 338 if (devinfo->resetting) { 339 usb_free_urb(urb); 340 return; 341 } 342 343 spin_lock_irqsave(&devinfo->lock, flags); 344 tag = be16_to_cpup(&iu->tag) - 1; 345 if (tag == 0) 346 cmnd = devinfo->cmnd; 347 else 348 cmnd = scsi_host_find_tag(shost, tag - 1); 349 350 if (!cmnd) { 351 if (iu->iu_id == IU_ID_RESPONSE) { 352 if (!devinfo->running_task) 353 dev_warn(&urb->dev->dev, 354 "stat urb: recv unexpected response iu\n"); 355 /* store results for uas_eh_task_mgmt() */ 356 memcpy(&devinfo->response, iu, sizeof(devinfo->response)); 357 } 358 usb_free_urb(urb); 359 spin_unlock_irqrestore(&devinfo->lock, flags); 360 return; 361 } 362 363 cmdinfo = (void *)&cmnd->SCp; 364 switch (iu->iu_id) { 365 case IU_ID_STATUS: 366 if (devinfo->cmnd == cmnd) 367 devinfo->cmnd = NULL; 368 369 if (urb->actual_length < 16) 370 devinfo->uas_sense_old = 1; 371 if (devinfo->uas_sense_old) 372 uas_sense_old(urb, cmnd); 373 else 374 uas_sense(urb, cmnd); 375 if (cmnd->result != 0) { 376 /* cancel data transfers on error */ 377 uas_unlink_data_urbs(devinfo, cmdinfo, &flags); 378 } 379 cmdinfo->state &= ~COMMAND_INFLIGHT; 380 uas_try_complete(cmnd, __func__); 381 break; 382 case IU_ID_READ_READY: 383 if (!cmdinfo->data_in_urb || 384 (cmdinfo->state & DATA_IN_URB_INFLIGHT)) { 385 scmd_printk(KERN_ERR, cmnd, "unexpected read rdy\n"); 386 break; 387 } 388 uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB); 389 break; 390 case IU_ID_WRITE_READY: 391 if (!cmdinfo->data_out_urb || 392 (cmdinfo->state & DATA_OUT_URB_INFLIGHT)) { 393 scmd_printk(KERN_ERR, cmnd, "unexpected write rdy\n"); 394 break; 395 } 396 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB); 397 break; 398 default: 399 scmd_printk(KERN_ERR, cmnd, 400 "Bogus IU (%d) received on status pipe\n", iu->iu_id); 401 } 402 usb_free_urb(urb); 403 spin_unlock_irqrestore(&devinfo->lock, flags); 404 } 405 406 static void uas_data_cmplt(struct urb *urb) 407 { 408 struct scsi_cmnd *cmnd = urb->context; 409 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 410 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata; 411 struct scsi_data_buffer *sdb = NULL; 412 unsigned long flags; 413 414 spin_lock_irqsave(&devinfo->lock, flags); 415 if (cmdinfo->data_in_urb == urb) { 416 sdb = scsi_in(cmnd); 417 cmdinfo->state &= ~DATA_IN_URB_INFLIGHT; 418 } else if (cmdinfo->data_out_urb == urb) { 419 sdb = scsi_out(cmnd); 420 cmdinfo->state &= ~DATA_OUT_URB_INFLIGHT; 421 } 422 if (sdb == NULL) { 423 WARN_ON_ONCE(1); 424 } else if (urb->status) { 425 if (urb->status != -ECONNRESET) { 426 uas_log_cmd_state(cmnd, __func__); 427 scmd_printk(KERN_ERR, cmnd, 428 "data cmplt err %d stream %d\n", 429 urb->status, urb->stream_id); 430 } 431 /* error: no data transfered */ 432 sdb->resid = sdb->length; 433 } else { 434 sdb->resid = sdb->length - urb->actual_length; 435 } 436 uas_try_complete(cmnd, __func__); 437 spin_unlock_irqrestore(&devinfo->lock, flags); 438 } 439 440 static void uas_cmd_cmplt(struct urb *urb) 441 { 442 struct scsi_cmnd *cmnd = urb->context; 443 444 if (urb->status) { 445 uas_log_cmd_state(cmnd, __func__); 446 scmd_printk(KERN_ERR, cmnd, "cmd cmplt err %d\n", urb->status); 447 } 448 usb_free_urb(urb); 449 } 450 451 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp, 452 unsigned int pipe, u16 stream_id, 453 struct scsi_cmnd *cmnd, 454 enum dma_data_direction dir) 455 { 456 struct usb_device *udev = devinfo->udev; 457 struct urb *urb = usb_alloc_urb(0, gfp); 458 struct scsi_data_buffer *sdb = (dir == DMA_FROM_DEVICE) 459 ? scsi_in(cmnd) : scsi_out(cmnd); 460 461 if (!urb) 462 goto out; 463 usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, 464 uas_data_cmplt, cmnd); 465 urb->stream_id = stream_id; 466 urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0; 467 urb->sg = sdb->table.sgl; 468 out: 469 return urb; 470 } 471 472 static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp, 473 struct Scsi_Host *shost, u16 stream_id) 474 { 475 struct usb_device *udev = devinfo->udev; 476 struct urb *urb = usb_alloc_urb(0, gfp); 477 struct sense_iu *iu; 478 479 if (!urb) 480 goto out; 481 482 iu = kzalloc(sizeof(*iu), gfp); 483 if (!iu) 484 goto free; 485 486 usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu), 487 uas_stat_cmplt, shost); 488 urb->stream_id = stream_id; 489 urb->transfer_flags |= URB_FREE_BUFFER; 490 out: 491 return urb; 492 free: 493 usb_free_urb(urb); 494 return NULL; 495 } 496 497 static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp, 498 struct scsi_cmnd *cmnd) 499 { 500 struct usb_device *udev = devinfo->udev; 501 struct scsi_device *sdev = cmnd->device; 502 struct urb *urb = usb_alloc_urb(0, gfp); 503 struct command_iu *iu; 504 int len; 505 506 if (!urb) 507 goto out; 508 509 len = cmnd->cmd_len - 16; 510 if (len < 0) 511 len = 0; 512 len = ALIGN(len, 4); 513 iu = kzalloc(sizeof(*iu) + len, gfp); 514 if (!iu) 515 goto free; 516 517 iu->iu_id = IU_ID_COMMAND; 518 if (blk_rq_tagged(cmnd->request)) 519 iu->tag = cpu_to_be16(cmnd->request->tag + 2); 520 else 521 iu->tag = cpu_to_be16(1); 522 iu->prio_attr = UAS_SIMPLE_TAG; 523 iu->len = len; 524 int_to_scsilun(sdev->lun, &iu->lun); 525 memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len); 526 527 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len, 528 uas_cmd_cmplt, cmnd); 529 urb->transfer_flags |= URB_FREE_BUFFER; 530 out: 531 return urb; 532 free: 533 usb_free_urb(urb); 534 return NULL; 535 } 536 537 static int uas_submit_task_urb(struct scsi_cmnd *cmnd, gfp_t gfp, 538 u8 function, u16 stream_id) 539 { 540 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata; 541 struct usb_device *udev = devinfo->udev; 542 struct urb *urb = usb_alloc_urb(0, gfp); 543 struct task_mgmt_iu *iu; 544 int err = -ENOMEM; 545 546 if (!urb) 547 goto err; 548 549 iu = kzalloc(sizeof(*iu), gfp); 550 if (!iu) 551 goto err; 552 553 iu->iu_id = IU_ID_TASK_MGMT; 554 iu->tag = cpu_to_be16(stream_id); 555 int_to_scsilun(cmnd->device->lun, &iu->lun); 556 557 iu->function = function; 558 switch (function) { 559 case TMF_ABORT_TASK: 560 if (blk_rq_tagged(cmnd->request)) 561 iu->task_tag = cpu_to_be16(cmnd->request->tag + 2); 562 else 563 iu->task_tag = cpu_to_be16(1); 564 break; 565 } 566 567 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu), 568 uas_cmd_cmplt, cmnd); 569 urb->transfer_flags |= URB_FREE_BUFFER; 570 571 usb_anchor_urb(urb, &devinfo->cmd_urbs); 572 err = usb_submit_urb(urb, gfp); 573 if (err) { 574 usb_unanchor_urb(urb); 575 uas_log_cmd_state(cmnd, __func__); 576 scmd_printk(KERN_ERR, cmnd, "task submission err %d\n", err); 577 goto err; 578 } 579 580 return 0; 581 582 err: 583 usb_free_urb(urb); 584 return err; 585 } 586 587 /* 588 * Why should I request the Status IU before sending the Command IU? Spec 589 * says to, but also says the device may receive them in any order. Seems 590 * daft to me. 591 */ 592 593 static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd, 594 gfp_t gfp, unsigned int stream) 595 { 596 struct Scsi_Host *shost = cmnd->device->host; 597 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 598 struct urb *urb; 599 int err; 600 601 urb = uas_alloc_sense_urb(devinfo, gfp, shost, stream); 602 if (!urb) 603 return NULL; 604 usb_anchor_urb(urb, &devinfo->sense_urbs); 605 err = usb_submit_urb(urb, gfp); 606 if (err) { 607 usb_unanchor_urb(urb); 608 uas_log_cmd_state(cmnd, __func__); 609 shost_printk(KERN_INFO, shost, 610 "sense urb submission error %d stream %d\n", 611 err, stream); 612 usb_free_urb(urb); 613 return NULL; 614 } 615 return urb; 616 } 617 618 static int uas_submit_urbs(struct scsi_cmnd *cmnd, 619 struct uas_dev_info *devinfo, gfp_t gfp) 620 { 621 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 622 struct urb *urb; 623 int err; 624 625 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock)); 626 if (cmdinfo->state & SUBMIT_STATUS_URB) { 627 urb = uas_submit_sense_urb(cmnd, gfp, cmdinfo->stream); 628 if (!urb) 629 return SCSI_MLQUEUE_DEVICE_BUSY; 630 cmdinfo->state &= ~SUBMIT_STATUS_URB; 631 } 632 633 if (cmdinfo->state & ALLOC_DATA_IN_URB) { 634 cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp, 635 devinfo->data_in_pipe, cmdinfo->stream, 636 cmnd, DMA_FROM_DEVICE); 637 if (!cmdinfo->data_in_urb) 638 return SCSI_MLQUEUE_DEVICE_BUSY; 639 cmdinfo->state &= ~ALLOC_DATA_IN_URB; 640 } 641 642 if (cmdinfo->state & SUBMIT_DATA_IN_URB) { 643 usb_anchor_urb(cmdinfo->data_in_urb, &devinfo->data_urbs); 644 err = usb_submit_urb(cmdinfo->data_in_urb, gfp); 645 if (err) { 646 usb_unanchor_urb(cmdinfo->data_in_urb); 647 uas_log_cmd_state(cmnd, __func__); 648 scmd_printk(KERN_INFO, cmnd, 649 "data in urb submission error %d stream %d\n", 650 err, cmdinfo->data_in_urb->stream_id); 651 return SCSI_MLQUEUE_DEVICE_BUSY; 652 } 653 cmdinfo->state &= ~SUBMIT_DATA_IN_URB; 654 cmdinfo->state |= DATA_IN_URB_INFLIGHT; 655 } 656 657 if (cmdinfo->state & ALLOC_DATA_OUT_URB) { 658 cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp, 659 devinfo->data_out_pipe, cmdinfo->stream, 660 cmnd, DMA_TO_DEVICE); 661 if (!cmdinfo->data_out_urb) 662 return SCSI_MLQUEUE_DEVICE_BUSY; 663 cmdinfo->state &= ~ALLOC_DATA_OUT_URB; 664 } 665 666 if (cmdinfo->state & SUBMIT_DATA_OUT_URB) { 667 usb_anchor_urb(cmdinfo->data_out_urb, &devinfo->data_urbs); 668 err = usb_submit_urb(cmdinfo->data_out_urb, gfp); 669 if (err) { 670 usb_unanchor_urb(cmdinfo->data_out_urb); 671 uas_log_cmd_state(cmnd, __func__); 672 scmd_printk(KERN_INFO, cmnd, 673 "data out urb submission error %d stream %d\n", 674 err, cmdinfo->data_out_urb->stream_id); 675 return SCSI_MLQUEUE_DEVICE_BUSY; 676 } 677 cmdinfo->state &= ~SUBMIT_DATA_OUT_URB; 678 cmdinfo->state |= DATA_OUT_URB_INFLIGHT; 679 } 680 681 if (cmdinfo->state & ALLOC_CMD_URB) { 682 cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd); 683 if (!cmdinfo->cmd_urb) 684 return SCSI_MLQUEUE_DEVICE_BUSY; 685 cmdinfo->state &= ~ALLOC_CMD_URB; 686 } 687 688 if (cmdinfo->state & SUBMIT_CMD_URB) { 689 usb_anchor_urb(cmdinfo->cmd_urb, &devinfo->cmd_urbs); 690 err = usb_submit_urb(cmdinfo->cmd_urb, gfp); 691 if (err) { 692 usb_unanchor_urb(cmdinfo->cmd_urb); 693 uas_log_cmd_state(cmnd, __func__); 694 scmd_printk(KERN_INFO, cmnd, 695 "cmd urb submission error %d\n", err); 696 return SCSI_MLQUEUE_DEVICE_BUSY; 697 } 698 cmdinfo->cmd_urb = NULL; 699 cmdinfo->state &= ~SUBMIT_CMD_URB; 700 cmdinfo->state |= COMMAND_INFLIGHT; 701 } 702 703 return 0; 704 } 705 706 static int uas_queuecommand_lck(struct scsi_cmnd *cmnd, 707 void (*done)(struct scsi_cmnd *)) 708 { 709 struct scsi_device *sdev = cmnd->device; 710 struct uas_dev_info *devinfo = sdev->hostdata; 711 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 712 unsigned long flags; 713 int err; 714 715 BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer)); 716 717 spin_lock_irqsave(&devinfo->lock, flags); 718 719 if (devinfo->resetting) { 720 cmnd->result = DID_ERROR << 16; 721 cmnd->scsi_done(cmnd); 722 spin_unlock_irqrestore(&devinfo->lock, flags); 723 return 0; 724 } 725 726 if (devinfo->cmnd) { 727 spin_unlock_irqrestore(&devinfo->lock, flags); 728 return SCSI_MLQUEUE_DEVICE_BUSY; 729 } 730 731 memset(cmdinfo, 0, sizeof(*cmdinfo)); 732 733 if (blk_rq_tagged(cmnd->request)) { 734 cmdinfo->stream = cmnd->request->tag + 2; 735 } else { 736 devinfo->cmnd = cmnd; 737 cmdinfo->stream = 1; 738 } 739 740 cmnd->scsi_done = done; 741 742 cmdinfo->state = SUBMIT_STATUS_URB | 743 ALLOC_CMD_URB | SUBMIT_CMD_URB; 744 745 switch (cmnd->sc_data_direction) { 746 case DMA_FROM_DEVICE: 747 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB; 748 break; 749 case DMA_BIDIRECTIONAL: 750 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB; 751 case DMA_TO_DEVICE: 752 cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB; 753 case DMA_NONE: 754 break; 755 } 756 757 if (!devinfo->use_streams) { 758 cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB); 759 cmdinfo->stream = 0; 760 } 761 762 err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC); 763 if (err) { 764 /* If we did nothing, give up now */ 765 if (cmdinfo->state & SUBMIT_STATUS_URB) { 766 spin_unlock_irqrestore(&devinfo->lock, flags); 767 return SCSI_MLQUEUE_DEVICE_BUSY; 768 } 769 uas_add_work(cmdinfo); 770 } 771 772 list_add_tail(&cmdinfo->list, &devinfo->inflight_list); 773 spin_unlock_irqrestore(&devinfo->lock, flags); 774 return 0; 775 } 776 777 static DEF_SCSI_QCMD(uas_queuecommand) 778 779 static int uas_eh_task_mgmt(struct scsi_cmnd *cmnd, 780 const char *fname, u8 function) 781 { 782 struct Scsi_Host *shost = cmnd->device->host; 783 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 784 u16 tag = devinfo->qdepth; 785 unsigned long flags; 786 struct urb *sense_urb; 787 int result = SUCCESS; 788 789 spin_lock_irqsave(&devinfo->lock, flags); 790 791 if (devinfo->resetting) { 792 spin_unlock_irqrestore(&devinfo->lock, flags); 793 return FAILED; 794 } 795 796 if (devinfo->running_task) { 797 shost_printk(KERN_INFO, shost, 798 "%s: %s: error already running a task\n", 799 __func__, fname); 800 spin_unlock_irqrestore(&devinfo->lock, flags); 801 return FAILED; 802 } 803 804 devinfo->running_task = 1; 805 memset(&devinfo->response, 0, sizeof(devinfo->response)); 806 sense_urb = uas_submit_sense_urb(cmnd, GFP_ATOMIC, 807 devinfo->use_streams ? tag : 0); 808 if (!sense_urb) { 809 shost_printk(KERN_INFO, shost, 810 "%s: %s: submit sense urb failed\n", 811 __func__, fname); 812 devinfo->running_task = 0; 813 spin_unlock_irqrestore(&devinfo->lock, flags); 814 return FAILED; 815 } 816 if (uas_submit_task_urb(cmnd, GFP_ATOMIC, function, tag)) { 817 shost_printk(KERN_INFO, shost, 818 "%s: %s: submit task mgmt urb failed\n", 819 __func__, fname); 820 devinfo->running_task = 0; 821 spin_unlock_irqrestore(&devinfo->lock, flags); 822 usb_kill_urb(sense_urb); 823 return FAILED; 824 } 825 spin_unlock_irqrestore(&devinfo->lock, flags); 826 827 if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 3000) == 0) { 828 /* 829 * Note we deliberately do not clear running_task here. If we 830 * allow new tasks to be submitted, there is no way to figure 831 * out if a received response_iu is for the failed task or for 832 * the new one. A bus-reset will eventually clear running_task. 833 */ 834 shost_printk(KERN_INFO, shost, 835 "%s: %s timed out\n", __func__, fname); 836 return FAILED; 837 } 838 839 spin_lock_irqsave(&devinfo->lock, flags); 840 devinfo->running_task = 0; 841 if (be16_to_cpu(devinfo->response.tag) != tag) { 842 shost_printk(KERN_INFO, shost, 843 "%s: %s failed (wrong tag %d/%d)\n", __func__, 844 fname, be16_to_cpu(devinfo->response.tag), tag); 845 result = FAILED; 846 } else if (devinfo->response.response_code != RC_TMF_COMPLETE) { 847 shost_printk(KERN_INFO, shost, 848 "%s: %s failed (rc 0x%x)\n", __func__, 849 fname, devinfo->response.response_code); 850 result = FAILED; 851 } 852 spin_unlock_irqrestore(&devinfo->lock, flags); 853 854 return result; 855 } 856 857 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd) 858 { 859 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp; 860 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata; 861 unsigned long flags; 862 int ret; 863 864 spin_lock_irqsave(&devinfo->lock, flags); 865 866 if (devinfo->resetting) { 867 spin_unlock_irqrestore(&devinfo->lock, flags); 868 return FAILED; 869 } 870 871 uas_mark_cmd_dead(devinfo, cmdinfo, DID_ABORT, __func__); 872 if (cmdinfo->state & COMMAND_INFLIGHT) { 873 spin_unlock_irqrestore(&devinfo->lock, flags); 874 ret = uas_eh_task_mgmt(cmnd, "ABORT TASK", TMF_ABORT_TASK); 875 } else { 876 uas_unlink_data_urbs(devinfo, cmdinfo, &flags); 877 uas_try_complete(cmnd, __func__); 878 spin_unlock_irqrestore(&devinfo->lock, flags); 879 ret = SUCCESS; 880 } 881 return ret; 882 } 883 884 static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd) 885 { 886 sdev_printk(KERN_INFO, cmnd->device, "%s\n", __func__); 887 return uas_eh_task_mgmt(cmnd, "LOGICAL UNIT RESET", 888 TMF_LOGICAL_UNIT_RESET); 889 } 890 891 static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd) 892 { 893 struct scsi_device *sdev = cmnd->device; 894 struct uas_dev_info *devinfo = sdev->hostdata; 895 struct usb_device *udev = devinfo->udev; 896 int err; 897 898 err = usb_lock_device_for_reset(udev, devinfo->intf); 899 if (err) { 900 shost_printk(KERN_ERR, sdev->host, 901 "%s FAILED to get lock err %d\n", __func__, err); 902 return FAILED; 903 } 904 905 shost_printk(KERN_INFO, sdev->host, "%s start\n", __func__); 906 devinfo->resetting = 1; 907 uas_abort_inflight(devinfo, DID_RESET, __func__); 908 usb_kill_anchored_urbs(&devinfo->cmd_urbs); 909 usb_kill_anchored_urbs(&devinfo->sense_urbs); 910 usb_kill_anchored_urbs(&devinfo->data_urbs); 911 uas_zap_dead(devinfo); 912 err = usb_reset_device(udev); 913 devinfo->resetting = 0; 914 915 usb_unlock_device(udev); 916 917 if (err) { 918 shost_printk(KERN_INFO, sdev->host, "%s FAILED\n", __func__); 919 return FAILED; 920 } 921 922 shost_printk(KERN_INFO, sdev->host, "%s success\n", __func__); 923 return SUCCESS; 924 } 925 926 static int uas_slave_alloc(struct scsi_device *sdev) 927 { 928 sdev->hostdata = (void *)sdev->host->hostdata; 929 930 /* USB has unusual DMA-alignment requirements: Although the 931 * starting address of each scatter-gather element doesn't matter, 932 * the length of each element except the last must be divisible 933 * by the Bulk maxpacket value. There's currently no way to 934 * express this by block-layer constraints, so we'll cop out 935 * and simply require addresses to be aligned at 512-byte 936 * boundaries. This is okay since most block I/O involves 937 * hardware sectors that are multiples of 512 bytes in length, 938 * and since host controllers up through USB 2.0 have maxpacket 939 * values no larger than 512. 940 * 941 * But it doesn't suffice for Wireless USB, where Bulk maxpacket 942 * values can be as large as 2048. To make that work properly 943 * will require changes to the block layer. 944 */ 945 blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1)); 946 947 return 0; 948 } 949 950 static int uas_slave_configure(struct scsi_device *sdev) 951 { 952 struct uas_dev_info *devinfo = sdev->hostdata; 953 scsi_set_tag_type(sdev, MSG_ORDERED_TAG); 954 scsi_activate_tcq(sdev, devinfo->qdepth - 2); 955 return 0; 956 } 957 958 static struct scsi_host_template uas_host_template = { 959 .module = THIS_MODULE, 960 .name = "uas", 961 .queuecommand = uas_queuecommand, 962 .slave_alloc = uas_slave_alloc, 963 .slave_configure = uas_slave_configure, 964 .eh_abort_handler = uas_eh_abort_handler, 965 .eh_device_reset_handler = uas_eh_device_reset_handler, 966 .eh_bus_reset_handler = uas_eh_bus_reset_handler, 967 .can_queue = 65536, /* Is there a limit on the _host_ ? */ 968 .this_id = -1, 969 .sg_tablesize = SG_NONE, 970 .cmd_per_lun = 1, /* until we override it */ 971 .skip_settle_delay = 1, 972 .ordered_tag = 1, 973 }; 974 975 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 976 vendorName, productName, useProtocol, useTransport, \ 977 initFunction, flags) \ 978 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 979 .driver_info = (flags) } 980 981 static struct usb_device_id uas_usb_ids[] = { 982 # include "unusual_uas.h" 983 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) }, 984 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) }, 985 /* 0xaa is a prototype device I happen to have access to */ 986 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) }, 987 { } 988 }; 989 MODULE_DEVICE_TABLE(usb, uas_usb_ids); 990 991 #undef UNUSUAL_DEV 992 993 static int uas_switch_interface(struct usb_device *udev, 994 struct usb_interface *intf) 995 { 996 int alt; 997 998 alt = uas_find_uas_alt_setting(intf); 999 if (alt < 0) 1000 return alt; 1001 1002 return usb_set_interface(udev, 1003 intf->altsetting[0].desc.bInterfaceNumber, alt); 1004 } 1005 1006 static int uas_configure_endpoints(struct uas_dev_info *devinfo) 1007 { 1008 struct usb_host_endpoint *eps[4] = { }; 1009 struct usb_device *udev = devinfo->udev; 1010 int r; 1011 1012 devinfo->uas_sense_old = 0; 1013 devinfo->cmnd = NULL; 1014 1015 r = uas_find_endpoints(devinfo->intf->cur_altsetting, eps); 1016 if (r) 1017 return r; 1018 1019 devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1020 usb_endpoint_num(&eps[0]->desc)); 1021 devinfo->status_pipe = usb_rcvbulkpipe(udev, 1022 usb_endpoint_num(&eps[1]->desc)); 1023 devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 1024 usb_endpoint_num(&eps[2]->desc)); 1025 devinfo->data_out_pipe = usb_sndbulkpipe(udev, 1026 usb_endpoint_num(&eps[3]->desc)); 1027 1028 if (udev->speed != USB_SPEED_SUPER) { 1029 devinfo->qdepth = 256; 1030 devinfo->use_streams = 0; 1031 } else { 1032 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 1033 3, 256, GFP_NOIO); 1034 if (devinfo->qdepth < 0) 1035 return devinfo->qdepth; 1036 devinfo->use_streams = 1; 1037 } 1038 1039 return 0; 1040 } 1041 1042 static void uas_free_streams(struct uas_dev_info *devinfo) 1043 { 1044 struct usb_device *udev = devinfo->udev; 1045 struct usb_host_endpoint *eps[3]; 1046 1047 eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe); 1048 eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe); 1049 eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe); 1050 usb_free_streams(devinfo->intf, eps, 3, GFP_NOIO); 1051 } 1052 1053 static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id) 1054 { 1055 int result = -ENOMEM; 1056 struct Scsi_Host *shost = NULL; 1057 struct uas_dev_info *devinfo; 1058 struct usb_device *udev = interface_to_usbdev(intf); 1059 1060 if (!uas_use_uas_driver(intf, id)) 1061 return -ENODEV; 1062 1063 if (uas_switch_interface(udev, intf)) 1064 return -ENODEV; 1065 1066 shost = scsi_host_alloc(&uas_host_template, 1067 sizeof(struct uas_dev_info)); 1068 if (!shost) 1069 goto set_alt0; 1070 1071 shost->max_cmd_len = 16 + 252; 1072 shost->max_id = 1; 1073 shost->max_lun = 256; 1074 shost->max_channel = 0; 1075 shost->sg_tablesize = udev->bus->sg_tablesize; 1076 1077 devinfo = (struct uas_dev_info *)shost->hostdata; 1078 devinfo->intf = intf; 1079 devinfo->udev = udev; 1080 devinfo->resetting = 0; 1081 devinfo->running_task = 0; 1082 devinfo->shutdown = 0; 1083 init_usb_anchor(&devinfo->cmd_urbs); 1084 init_usb_anchor(&devinfo->sense_urbs); 1085 init_usb_anchor(&devinfo->data_urbs); 1086 spin_lock_init(&devinfo->lock); 1087 INIT_WORK(&devinfo->work, uas_do_work); 1088 INIT_LIST_HEAD(&devinfo->inflight_list); 1089 INIT_LIST_HEAD(&devinfo->dead_list); 1090 1091 result = uas_configure_endpoints(devinfo); 1092 if (result) 1093 goto set_alt0; 1094 1095 result = scsi_init_shared_tag_map(shost, devinfo->qdepth - 2); 1096 if (result) 1097 goto free_streams; 1098 1099 usb_set_intfdata(intf, shost); 1100 result = scsi_add_host(shost, &intf->dev); 1101 if (result) 1102 goto free_streams; 1103 1104 scsi_scan_host(shost); 1105 return result; 1106 1107 free_streams: 1108 uas_free_streams(devinfo); 1109 usb_set_intfdata(intf, NULL); 1110 set_alt0: 1111 usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0); 1112 if (shost) 1113 scsi_host_put(shost); 1114 return result; 1115 } 1116 1117 static int uas_pre_reset(struct usb_interface *intf) 1118 { 1119 struct Scsi_Host *shost = usb_get_intfdata(intf); 1120 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 1121 unsigned long flags; 1122 1123 if (devinfo->shutdown) 1124 return 0; 1125 1126 /* Block new requests */ 1127 spin_lock_irqsave(shost->host_lock, flags); 1128 scsi_block_requests(shost); 1129 spin_unlock_irqrestore(shost->host_lock, flags); 1130 1131 /* Wait for any pending requests to complete */ 1132 flush_work(&devinfo->work); 1133 if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) { 1134 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__); 1135 return 1; 1136 } 1137 1138 uas_free_streams(devinfo); 1139 1140 return 0; 1141 } 1142 1143 static int uas_post_reset(struct usb_interface *intf) 1144 { 1145 struct Scsi_Host *shost = usb_get_intfdata(intf); 1146 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 1147 unsigned long flags; 1148 1149 if (devinfo->shutdown) 1150 return 0; 1151 1152 if (uas_configure_endpoints(devinfo) != 0) { 1153 shost_printk(KERN_ERR, shost, 1154 "%s: alloc streams error after reset", __func__); 1155 return 1; 1156 } 1157 1158 spin_lock_irqsave(shost->host_lock, flags); 1159 scsi_report_bus_reset(shost, 0); 1160 spin_unlock_irqrestore(shost->host_lock, flags); 1161 1162 scsi_unblock_requests(shost); 1163 1164 return 0; 1165 } 1166 1167 static int uas_suspend(struct usb_interface *intf, pm_message_t message) 1168 { 1169 struct Scsi_Host *shost = usb_get_intfdata(intf); 1170 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 1171 1172 /* Wait for any pending requests to complete */ 1173 flush_work(&devinfo->work); 1174 if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) { 1175 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__); 1176 return -ETIME; 1177 } 1178 1179 return 0; 1180 } 1181 1182 static int uas_resume(struct usb_interface *intf) 1183 { 1184 return 0; 1185 } 1186 1187 static int uas_reset_resume(struct usb_interface *intf) 1188 { 1189 struct Scsi_Host *shost = usb_get_intfdata(intf); 1190 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 1191 unsigned long flags; 1192 1193 if (uas_configure_endpoints(devinfo) != 0) { 1194 shost_printk(KERN_ERR, shost, 1195 "%s: alloc streams error after reset", __func__); 1196 return -EIO; 1197 } 1198 1199 spin_lock_irqsave(shost->host_lock, flags); 1200 scsi_report_bus_reset(shost, 0); 1201 spin_unlock_irqrestore(shost->host_lock, flags); 1202 1203 return 0; 1204 } 1205 1206 static void uas_disconnect(struct usb_interface *intf) 1207 { 1208 struct Scsi_Host *shost = usb_get_intfdata(intf); 1209 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 1210 1211 devinfo->resetting = 1; 1212 cancel_work_sync(&devinfo->work); 1213 uas_abort_inflight(devinfo, DID_NO_CONNECT, __func__); 1214 usb_kill_anchored_urbs(&devinfo->cmd_urbs); 1215 usb_kill_anchored_urbs(&devinfo->sense_urbs); 1216 usb_kill_anchored_urbs(&devinfo->data_urbs); 1217 uas_zap_dead(devinfo); 1218 scsi_remove_host(shost); 1219 uas_free_streams(devinfo); 1220 scsi_host_put(shost); 1221 } 1222 1223 /* 1224 * Put the device back in usb-storage mode on shutdown, as some BIOS-es 1225 * hang on reboot when the device is still in uas mode. Note the reset is 1226 * necessary as some devices won't revert to usb-storage mode without it. 1227 */ 1228 static void uas_shutdown(struct device *dev) 1229 { 1230 struct usb_interface *intf = to_usb_interface(dev); 1231 struct usb_device *udev = interface_to_usbdev(intf); 1232 struct Scsi_Host *shost = usb_get_intfdata(intf); 1233 struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata; 1234 1235 if (system_state != SYSTEM_RESTART) 1236 return; 1237 1238 devinfo->shutdown = 1; 1239 uas_free_streams(devinfo); 1240 usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0); 1241 usb_reset_device(udev); 1242 } 1243 1244 static struct usb_driver uas_driver = { 1245 .name = "uas", 1246 .probe = uas_probe, 1247 .disconnect = uas_disconnect, 1248 .pre_reset = uas_pre_reset, 1249 .post_reset = uas_post_reset, 1250 .suspend = uas_suspend, 1251 .resume = uas_resume, 1252 .reset_resume = uas_reset_resume, 1253 .drvwrap.driver.shutdown = uas_shutdown, 1254 .id_table = uas_usb_ids, 1255 }; 1256 1257 module_usb_driver(uas_driver); 1258 1259 MODULE_LICENSE("GPL"); 1260 MODULE_AUTHOR( 1261 "Hans de Goede <hdegoede@redhat.com>, Matthew Wilcox and Sarah Sharp"); 1262