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