1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * USB Attached SCSI
   4 * Note that this is not the same as the USB Mass Storage driver
   5 *
   6 * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2016
   7 * Copyright Matthew Wilcox for Intel Corp, 2010
   8 * Copyright Sarah Sharp for Intel Corp, 2010
   9 */
  10
  11#include <linux/blkdev.h>
  12#include <linux/slab.h>
  13#include <linux/types.h>
  14#include <linux/module.h>
  15#include <linux/usb.h>
  16#include <linux/usb_usual.h>
  17#include <linux/usb/hcd.h>
  18#include <linux/usb/storage.h>
  19#include <linux/usb/uas.h>
  20
  21#include <scsi/scsi.h>
  22#include <scsi/scsi_eh.h>
  23#include <scsi/scsi_dbg.h>
  24#include <scsi/scsi_cmnd.h>
  25#include <scsi/scsi_device.h>
  26#include <scsi/scsi_host.h>
  27#include <scsi/scsi_tcq.h>
  28
  29#include "uas-detect.h"
  30#include "scsiglue.h"
  31
  32#define MAX_CMNDS 256
  33
  34struct uas_dev_info {
  35	struct usb_interface *intf;
  36	struct usb_device *udev;
  37	struct usb_anchor cmd_urbs;
  38	struct usb_anchor sense_urbs;
  39	struct usb_anchor data_urbs;
  40	u64 flags;
  41	int qdepth, resetting;
  42	unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
  43	unsigned use_streams:1;
  44	unsigned shutdown:1;
  45	struct scsi_cmnd *cmnd[MAX_CMNDS];
  46	spinlock_t lock;
  47	struct work_struct work;
  48	struct work_struct scan_work;      /* for async scanning */
  49};
  50
  51enum {
  52	SUBMIT_STATUS_URB	= BIT(1),
  53	ALLOC_DATA_IN_URB	= BIT(2),
  54	SUBMIT_DATA_IN_URB	= BIT(3),
  55	ALLOC_DATA_OUT_URB	= BIT(4),
  56	SUBMIT_DATA_OUT_URB	= BIT(5),
  57	ALLOC_CMD_URB		= BIT(6),
  58	SUBMIT_CMD_URB		= BIT(7),
  59	COMMAND_INFLIGHT        = BIT(8),
  60	DATA_IN_URB_INFLIGHT    = BIT(9),
  61	DATA_OUT_URB_INFLIGHT   = BIT(10),
  62	COMMAND_ABORTED         = BIT(11),
  63	IS_IN_WORK_LIST         = BIT(12),
  64};
  65
  66/* Overrides scsi_pointer */
  67struct uas_cmd_info {
  68	unsigned int state;
  69	unsigned int uas_tag;
  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 */
  76static int uas_submit_urbs(struct scsi_cmnd *cmnd,
  77				struct uas_dev_info *devinfo);
  78static void uas_do_work(struct work_struct *work);
  79static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller);
  80static void uas_free_streams(struct uas_dev_info *devinfo);
  81static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
  82				int status);
  83
  84/*
  85 * This driver needs its own workqueue, as we need to control memory allocation.
  86 *
  87 * In the course of error handling and power management uas_wait_for_pending_cmnds()
  88 * needs to flush pending work items. In these contexts we cannot allocate memory
  89 * by doing block IO as we would deadlock. For the same reason we cannot wait
  90 * for anything allocating memory not heeding these constraints.
  91 *
  92 * So we have to control all work items that can be on the workqueue we flush.
  93 * Hence we cannot share a queue and need our own.
  94 */
  95static struct workqueue_struct *workqueue;
  96
  97static void uas_do_work(struct work_struct *work)
  98{
  99	struct uas_dev_info *devinfo =
 100		container_of(work, struct uas_dev_info, work);
 101	struct uas_cmd_info *cmdinfo;
 102	struct scsi_cmnd *cmnd;
 103	unsigned long flags;
 104	int i, err;
 105
 106	spin_lock_irqsave(&devinfo->lock, flags);
 107
 108	if (devinfo->resetting)
 109		goto out;
 110
 111	for (i = 0; i < devinfo->qdepth; i++) {
 112		if (!devinfo->cmnd[i])
 113			continue;
 114
 115		cmnd = devinfo->cmnd[i];
 116		cmdinfo = scsi_cmd_priv(cmnd);
 117
 118		if (!(cmdinfo->state & IS_IN_WORK_LIST))
 119			continue;
 120
 121		err = uas_submit_urbs(cmnd, cmnd->device->hostdata);
 122		if (!err)
 123			cmdinfo->state &= ~IS_IN_WORK_LIST;
 124		else
 125			queue_work(workqueue, &devinfo->work);
 126	}
 127out:
 128	spin_unlock_irqrestore(&devinfo->lock, flags);
 129}
 130
 131static void uas_scan_work(struct work_struct *work)
 132{
 133	struct uas_dev_info *devinfo =
 134		container_of(work, struct uas_dev_info, scan_work);
 135	struct Scsi_Host *shost = usb_get_intfdata(devinfo->intf);
 136
 137	dev_dbg(&devinfo->intf->dev, "starting scan\n");
 138	scsi_scan_host(shost);
 139	dev_dbg(&devinfo->intf->dev, "scan complete\n");
 140}
 141
 142static void uas_add_work(struct scsi_cmnd *cmnd)
 143{
 144	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 145	struct uas_dev_info *devinfo = cmnd->device->hostdata;
 146
 147	lockdep_assert_held(&devinfo->lock);
 148	cmdinfo->state |= IS_IN_WORK_LIST;
 149	queue_work(workqueue, &devinfo->work);
 150}
 151
 152static void uas_zap_pending(struct uas_dev_info *devinfo, int result)
 153{
 154	struct uas_cmd_info *cmdinfo;
 155	struct scsi_cmnd *cmnd;
 156	unsigned long flags;
 157	int i, err;
 158
 159	spin_lock_irqsave(&devinfo->lock, flags);
 160	for (i = 0; i < devinfo->qdepth; i++) {
 161		if (!devinfo->cmnd[i])
 162			continue;
 163
 164		cmnd = devinfo->cmnd[i];
 165		cmdinfo = scsi_cmd_priv(cmnd);
 166		uas_log_cmd_state(cmnd, __func__, 0);
 167		/* Sense urbs were killed, clear COMMAND_INFLIGHT manually */
 168		cmdinfo->state &= ~COMMAND_INFLIGHT;
 169		cmnd->result = result << 16;
 170		err = uas_try_complete(cmnd, __func__);
 171		WARN_ON(err != 0);
 172	}
 173	spin_unlock_irqrestore(&devinfo->lock, flags);
 174}
 175
 176static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
 177{
 178	struct sense_iu *sense_iu = urb->transfer_buffer;
 179	struct scsi_device *sdev = cmnd->device;
 180
 181	if (urb->actual_length > 16) {
 182		unsigned len = be16_to_cpup(&sense_iu->len);
 183		if (len + 16 != urb->actual_length) {
 184			int newlen = min(len + 16, urb->actual_length) - 16;
 185			if (newlen < 0)
 186				newlen = 0;
 187			sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
 188				"disagrees with IU sense data length %d, "
 189				"using %d bytes of sense data\n", __func__,
 190					urb->actual_length, len, newlen);
 191			len = newlen;
 192		}
 193		memcpy(cmnd->sense_buffer, sense_iu->sense, len);
 194	}
 195
 196	cmnd->result = sense_iu->status;
 197}
 198
 199static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
 200			      int status)
 201{
 202	struct uas_cmd_info *ci = scsi_cmd_priv(cmnd);
 203
 204	if (status == -ENODEV) /* too late */
 205		return;
 206
 207	scmd_printk(KERN_INFO, cmnd,
 208		    "%s %d uas-tag %d inflight:%s%s%s%s%s%s%s%s%s%s%s%s ",
 209		    prefix, status, ci->uas_tag,
 210		    (ci->state & SUBMIT_STATUS_URB)     ? " s-st"  : "",
 211		    (ci->state & ALLOC_DATA_IN_URB)     ? " a-in"  : "",
 212		    (ci->state & SUBMIT_DATA_IN_URB)    ? " s-in"  : "",
 213		    (ci->state & ALLOC_DATA_OUT_URB)    ? " a-out" : "",
 214		    (ci->state & SUBMIT_DATA_OUT_URB)   ? " s-out" : "",
 215		    (ci->state & ALLOC_CMD_URB)         ? " a-cmd" : "",
 216		    (ci->state & SUBMIT_CMD_URB)        ? " s-cmd" : "",
 217		    (ci->state & COMMAND_INFLIGHT)      ? " CMD"   : "",
 218		    (ci->state & DATA_IN_URB_INFLIGHT)  ? " IN"    : "",
 219		    (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT"   : "",
 220		    (ci->state & COMMAND_ABORTED)       ? " abort" : "",
 221		    (ci->state & IS_IN_WORK_LIST)       ? " work"  : "");
 222	scsi_print_command(cmnd);
 223}
 224
 225static void uas_free_unsubmitted_urbs(struct scsi_cmnd *cmnd)
 226{
 227	struct uas_cmd_info *cmdinfo;
 228
 229	if (!cmnd)
 230		return;
 231
 232	cmdinfo = scsi_cmd_priv(cmnd);
 233
 234	if (cmdinfo->state & SUBMIT_CMD_URB)
 235		usb_free_urb(cmdinfo->cmd_urb);
 236
 237	/* data urbs may have never gotten their submit flag set */
 238	if (!(cmdinfo->state & DATA_IN_URB_INFLIGHT))
 239		usb_free_urb(cmdinfo->data_in_urb);
 240	if (!(cmdinfo->state & DATA_OUT_URB_INFLIGHT))
 241		usb_free_urb(cmdinfo->data_out_urb);
 242}
 243
 244static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
 245{
 246	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 247	struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
 248
 249	lockdep_assert_held(&devinfo->lock);
 250	if (cmdinfo->state & (COMMAND_INFLIGHT |
 251			      DATA_IN_URB_INFLIGHT |
 252			      DATA_OUT_URB_INFLIGHT |
 253			      COMMAND_ABORTED))
 254		return -EBUSY;
 255	devinfo->cmnd[cmdinfo->uas_tag - 1] = NULL;
 256	uas_free_unsubmitted_urbs(cmnd);
 257	scsi_done(cmnd);
 258	return 0;
 259}
 260
 261static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
 262			  unsigned direction)
 263{
 264	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 265	int err;
 266
 267	cmdinfo->state |= direction | SUBMIT_STATUS_URB;
 268	err = uas_submit_urbs(cmnd, cmnd->device->hostdata);
 269	if (err) {
 270		uas_add_work(cmnd);
 271	}
 272}
 273
 274static bool uas_evaluate_response_iu(struct response_iu *riu, struct scsi_cmnd *cmnd)
 275{
 276	u8 response_code = riu->response_code;
 277
 278	switch (response_code) {
 279	case RC_INCORRECT_LUN:
 280		set_host_byte(cmnd, DID_BAD_TARGET);
 281		break;
 282	case RC_TMF_SUCCEEDED:
 283		set_host_byte(cmnd, DID_OK);
 284		break;
 285	case RC_TMF_NOT_SUPPORTED:
 286		set_host_byte(cmnd, DID_BAD_TARGET);
 287		break;
 288	default:
 289		uas_log_cmd_state(cmnd, "response iu", response_code);
 290		set_host_byte(cmnd, DID_ERROR);
 291		break;
 292	}
 293
 294	return response_code == RC_TMF_SUCCEEDED;
 295}
 296
 297static void uas_stat_cmplt(struct urb *urb)
 298{
 299	struct iu *iu = urb->transfer_buffer;
 300	struct Scsi_Host *shost = urb->context;
 301	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
 302	struct urb *data_in_urb = NULL;
 303	struct urb *data_out_urb = NULL;
 304	struct scsi_cmnd *cmnd;
 305	struct uas_cmd_info *cmdinfo;
 306	unsigned long flags;
 307	unsigned int idx;
 308	int status = urb->status;
 309	bool success;
 310
 311	spin_lock_irqsave(&devinfo->lock, flags);
 312
 313	if (devinfo->resetting)
 314		goto out;
 315
 316	if (status) {
 317		if (status != -ENOENT && status != -ECONNRESET && status != -ESHUTDOWN)
 318			dev_err(&urb->dev->dev, "stat urb: status %d\n", status);
 319		goto out;
 320	}
 321
 322	idx = be16_to_cpup(&iu->tag) - 1;
 323	if (idx >= MAX_CMNDS || !devinfo->cmnd[idx]) {
 324		dev_err(&urb->dev->dev,
 325			"stat urb: no pending cmd for uas-tag %d\n", idx + 1);
 326		goto out;
 327	}
 328
 329	cmnd = devinfo->cmnd[idx];
 330	cmdinfo = scsi_cmd_priv(cmnd);
 331
 332	if (!(cmdinfo->state & COMMAND_INFLIGHT)) {
 333		uas_log_cmd_state(cmnd, "unexpected status cmplt", 0);
 334		goto out;
 335	}
 336
 337	switch (iu->iu_id) {
 338	case IU_ID_STATUS:
 339		uas_sense(urb, cmnd);
 340		if (cmnd->result != 0) {
 341			/* cancel data transfers on error */
 342			data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
 343			data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
 344		}
 345		cmdinfo->state &= ~COMMAND_INFLIGHT;
 346		uas_try_complete(cmnd, __func__);
 347		break;
 348	case IU_ID_READ_READY:
 349		if (!cmdinfo->data_in_urb ||
 350				(cmdinfo->state & DATA_IN_URB_INFLIGHT)) {
 351			uas_log_cmd_state(cmnd, "unexpected read rdy", 0);
 352			break;
 353		}
 354		uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
 355		break;
 356	case IU_ID_WRITE_READY:
 357		if (!cmdinfo->data_out_urb ||
 358				(cmdinfo->state & DATA_OUT_URB_INFLIGHT)) {
 359			uas_log_cmd_state(cmnd, "unexpected write rdy", 0);
 360			break;
 361		}
 362		uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
 363		break;
 364	case IU_ID_RESPONSE:
 365		cmdinfo->state &= ~COMMAND_INFLIGHT;
 366		success = uas_evaluate_response_iu((struct response_iu *)iu, cmnd);
 367		if (!success) {
 368			/* Error, cancel data transfers */
 369			data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
 370			data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
 371		}
 372		uas_try_complete(cmnd, __func__);
 373		break;
 374	default:
 375		uas_log_cmd_state(cmnd, "bogus IU", iu->iu_id);
 376	}
 377out:
 378	usb_free_urb(urb);
 379	spin_unlock_irqrestore(&devinfo->lock, flags);
 380
 381	/* Unlinking of data urbs must be done without holding the lock */
 382	if (data_in_urb) {
 383		usb_unlink_urb(data_in_urb);
 384		usb_put_urb(data_in_urb);
 385	}
 386	if (data_out_urb) {
 387		usb_unlink_urb(data_out_urb);
 388		usb_put_urb(data_out_urb);
 389	}
 390}
 391
 392static void uas_data_cmplt(struct urb *urb)
 393{
 394	struct scsi_cmnd *cmnd = urb->context;
 395	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 396	struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
 397	struct scsi_data_buffer *sdb = &cmnd->sdb;
 398	unsigned long flags;
 399	int status = urb->status;
 400
 401	spin_lock_irqsave(&devinfo->lock, flags);
 402
 403	if (cmdinfo->data_in_urb == urb) {
 404		cmdinfo->state &= ~DATA_IN_URB_INFLIGHT;
 405		cmdinfo->data_in_urb = NULL;
 406	} else if (cmdinfo->data_out_urb == urb) {
 407		cmdinfo->state &= ~DATA_OUT_URB_INFLIGHT;
 408		cmdinfo->data_out_urb = NULL;
 409	}
 410
 411	if (devinfo->resetting)
 412		goto out;
 413
 414	/* Data urbs should not complete before the cmd urb is submitted */
 415	if (cmdinfo->state & SUBMIT_CMD_URB) {
 416		uas_log_cmd_state(cmnd, "unexpected data cmplt", 0);
 417		goto out;
 418	}
 419
 420	if (status) {
 421		if (status != -ENOENT && status != -ECONNRESET && status != -ESHUTDOWN)
 422			uas_log_cmd_state(cmnd, "data cmplt err", status);
 423		/* error: no data transfered */
 424		scsi_set_resid(cmnd, sdb->length);
 425	} else {
 426		scsi_set_resid(cmnd, sdb->length - urb->actual_length);
 427	}
 428	uas_try_complete(cmnd, __func__);
 429out:
 430	usb_free_urb(urb);
 431	spin_unlock_irqrestore(&devinfo->lock, flags);
 432}
 433
 434static void uas_cmd_cmplt(struct urb *urb)
 435{
 436	if (urb->status)
 437		dev_err(&urb->dev->dev, "cmd cmplt err %d\n", urb->status);
 438
 439	usb_free_urb(urb);
 440}
 441
 442static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
 443				      struct scsi_cmnd *cmnd,
 444				      enum dma_data_direction dir)
 445{
 446	struct usb_device *udev = devinfo->udev;
 447	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 448	struct urb *urb = usb_alloc_urb(0, gfp);
 449	struct scsi_data_buffer *sdb = &cmnd->sdb;
 450	unsigned int pipe = (dir == DMA_FROM_DEVICE)
 451		? devinfo->data_in_pipe : devinfo->data_out_pipe;
 452
 453	if (!urb)
 454		goto out;
 455	usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length,
 456			  uas_data_cmplt, cmnd);
 457	if (devinfo->use_streams)
 458		urb->stream_id = cmdinfo->uas_tag;
 459	urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
 460	urb->sg = sdb->table.sgl;
 461 out:
 462	return urb;
 463}
 464
 465static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
 466				       struct scsi_cmnd *cmnd)
 467{
 468	struct usb_device *udev = devinfo->udev;
 469	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 470	struct urb *urb = usb_alloc_urb(0, gfp);
 471	struct sense_iu *iu;
 472
 473	if (!urb)
 474		goto out;
 475
 476	iu = kzalloc(sizeof(*iu), gfp);
 477	if (!iu)
 478		goto free;
 479
 480	usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
 481			  uas_stat_cmplt, cmnd->device->host);
 482	if (devinfo->use_streams)
 483		urb->stream_id = cmdinfo->uas_tag;
 484	urb->transfer_flags |= URB_FREE_BUFFER;
 485 out:
 486	return urb;
 487 free:
 488	usb_free_urb(urb);
 489	return NULL;
 490}
 491
 492static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
 493					struct scsi_cmnd *cmnd)
 494{
 495	struct usb_device *udev = devinfo->udev;
 496	struct scsi_device *sdev = cmnd->device;
 497	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 498	struct urb *urb = usb_alloc_urb(0, gfp);
 499	struct command_iu *iu;
 500	int len;
 501
 502	if (!urb)
 503		goto out;
 504
 505	len = cmnd->cmd_len - 16;
 506	if (len < 0)
 507		len = 0;
 508	len = ALIGN(len, 4);
 509	iu = kzalloc(sizeof(*iu) + len, gfp);
 510	if (!iu)
 511		goto free;
 512
 513	iu->iu_id = IU_ID_COMMAND;
 514	iu->tag = cpu_to_be16(cmdinfo->uas_tag);
 515	iu->prio_attr = UAS_SIMPLE_TAG;
 516	iu->len = len;
 517	int_to_scsilun(sdev->lun, &iu->lun);
 518	memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
 519
 520	usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
 521							uas_cmd_cmplt, NULL);
 522	urb->transfer_flags |= URB_FREE_BUFFER;
 523 out:
 524	return urb;
 525 free:
 526	usb_free_urb(urb);
 527	return NULL;
 528}
 529
 530/*
 531 * Why should I request the Status IU before sending the Command IU?  Spec
 532 * says to, but also says the device may receive them in any order.  Seems
 533 * daft to me.
 534 */
 535
 536static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd, gfp_t gfp)
 537{
 538	struct uas_dev_info *devinfo = cmnd->device->hostdata;
 539	struct urb *urb;
 540	int err;
 541
 542	urb = uas_alloc_sense_urb(devinfo, gfp, cmnd);
 543	if (!urb)
 544		return NULL;
 545	usb_anchor_urb(urb, &devinfo->sense_urbs);
 546	err = usb_submit_urb(urb, gfp);
 547	if (err) {
 548		usb_unanchor_urb(urb);
 549		uas_log_cmd_state(cmnd, "sense submit err", err);
 550		usb_free_urb(urb);
 551		return NULL;
 552	}
 553	return urb;
 554}
 555
 556static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 557			   struct uas_dev_info *devinfo)
 558{
 559	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 560	struct urb *urb;
 561	int err;
 562
 563	lockdep_assert_held(&devinfo->lock);
 564	if (cmdinfo->state & SUBMIT_STATUS_URB) {
 565		urb = uas_submit_sense_urb(cmnd, GFP_ATOMIC);
 566		if (!urb)
 567			return SCSI_MLQUEUE_DEVICE_BUSY;
 568		cmdinfo->state &= ~SUBMIT_STATUS_URB;
 569	}
 570
 571	if (cmdinfo->state & ALLOC_DATA_IN_URB) {
 572		cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, GFP_ATOMIC,
 573							cmnd, DMA_FROM_DEVICE);
 574		if (!cmdinfo->data_in_urb)
 575			return SCSI_MLQUEUE_DEVICE_BUSY;
 576		cmdinfo->state &= ~ALLOC_DATA_IN_URB;
 577	}
 578
 579	if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
 580		usb_anchor_urb(cmdinfo->data_in_urb, &devinfo->data_urbs);
 581		err = usb_submit_urb(cmdinfo->data_in_urb, GFP_ATOMIC);
 582		if (err) {
 583			usb_unanchor_urb(cmdinfo->data_in_urb);
 584			uas_log_cmd_state(cmnd, "data in submit err", err);
 585			return SCSI_MLQUEUE_DEVICE_BUSY;
 586		}
 587		cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
 588		cmdinfo->state |= DATA_IN_URB_INFLIGHT;
 589	}
 590
 591	if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
 592		cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, GFP_ATOMIC,
 593							cmnd, DMA_TO_DEVICE);
 594		if (!cmdinfo->data_out_urb)
 595			return SCSI_MLQUEUE_DEVICE_BUSY;
 596		cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
 597	}
 598
 599	if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
 600		usb_anchor_urb(cmdinfo->data_out_urb, &devinfo->data_urbs);
 601		err = usb_submit_urb(cmdinfo->data_out_urb, GFP_ATOMIC);
 602		if (err) {
 603			usb_unanchor_urb(cmdinfo->data_out_urb);
 604			uas_log_cmd_state(cmnd, "data out submit err", err);
 605			return SCSI_MLQUEUE_DEVICE_BUSY;
 606		}
 607		cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
 608		cmdinfo->state |= DATA_OUT_URB_INFLIGHT;
 609	}
 610
 611	if (cmdinfo->state & ALLOC_CMD_URB) {
 612		cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, GFP_ATOMIC, cmnd);
 613		if (!cmdinfo->cmd_urb)
 614			return SCSI_MLQUEUE_DEVICE_BUSY;
 615		cmdinfo->state &= ~ALLOC_CMD_URB;
 616	}
 617
 618	if (cmdinfo->state & SUBMIT_CMD_URB) {
 619		usb_anchor_urb(cmdinfo->cmd_urb, &devinfo->cmd_urbs);
 620		err = usb_submit_urb(cmdinfo->cmd_urb, GFP_ATOMIC);
 621		if (err) {
 622			usb_unanchor_urb(cmdinfo->cmd_urb);
 623			uas_log_cmd_state(cmnd, "cmd submit err", err);
 624			return SCSI_MLQUEUE_DEVICE_BUSY;
 625		}
 626		cmdinfo->cmd_urb = NULL;
 627		cmdinfo->state &= ~SUBMIT_CMD_URB;
 628		cmdinfo->state |= COMMAND_INFLIGHT;
 629	}
 630
 631	return 0;
 632}
 633
 634static int uas_queuecommand_lck(struct scsi_cmnd *cmnd)
 635{
 636	struct scsi_device *sdev = cmnd->device;
 637	struct uas_dev_info *devinfo = sdev->hostdata;
 638	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 639	unsigned long flags;
 640	int idx, err;
 641
 642	/* Re-check scsi_block_requests now that we've the host-lock */
 643	if (cmnd->device->host->host_self_blocked)
 644		return SCSI_MLQUEUE_DEVICE_BUSY;
 645
 646	if ((devinfo->flags & US_FL_NO_ATA_1X) &&
 647			(cmnd->cmnd[0] == ATA_12 || cmnd->cmnd[0] == ATA_16)) {
 648		memcpy(cmnd->sense_buffer, usb_stor_sense_invalidCDB,
 649		       sizeof(usb_stor_sense_invalidCDB));
 650		cmnd->result = SAM_STAT_CHECK_CONDITION;
 651		scsi_done(cmnd);
 652		return 0;
 653	}
 654
 655	spin_lock_irqsave(&devinfo->lock, flags);
 656
 657	if (devinfo->resetting) {
 658		set_host_byte(cmnd, DID_ERROR);
 659		scsi_done(cmnd);
 660		goto zombie;
 661	}
 662
 663	/* Find a free uas-tag */
 664	for (idx = 0; idx < devinfo->qdepth; idx++) {
 665		if (!devinfo->cmnd[idx])
 666			break;
 667	}
 668	if (idx == devinfo->qdepth) {
 669		spin_unlock_irqrestore(&devinfo->lock, flags);
 670		return SCSI_MLQUEUE_DEVICE_BUSY;
 671	}
 672
 673	memset(cmdinfo, 0, sizeof(*cmdinfo));
 674	cmdinfo->uas_tag = idx + 1; /* uas-tag == usb-stream-id, so 1 based */
 675	cmdinfo->state = SUBMIT_STATUS_URB | ALLOC_CMD_URB | SUBMIT_CMD_URB;
 676
 677	switch (cmnd->sc_data_direction) {
 678	case DMA_FROM_DEVICE:
 679		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
 680		break;
 681	case DMA_BIDIRECTIONAL:
 682		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
 683		fallthrough;
 684	case DMA_TO_DEVICE:
 685		cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
 686		break;
 687	case DMA_NONE:
 688		break;
 689	}
 690
 691	if (!devinfo->use_streams)
 692		cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
 693
 694	err = uas_submit_urbs(cmnd, devinfo);
 695	/*
 696	 * in case of fatal errors the SCSI layer is peculiar
 697	 * a command that has finished is a success for the purpose
 698	 * of queueing, no matter how fatal the error
 699	 */
 700	if (err == -ENODEV) {
 701		set_host_byte(cmnd, DID_ERROR);
 702		scsi_done(cmnd);
 703		goto zombie;
 704	}
 705	if (err) {
 706		/* If we did nothing, give up now */
 707		if (cmdinfo->state & SUBMIT_STATUS_URB) {
 708			spin_unlock_irqrestore(&devinfo->lock, flags);
 709			return SCSI_MLQUEUE_DEVICE_BUSY;
 710		}
 711		uas_add_work(cmnd);
 712	}
 713
 714	devinfo->cmnd[idx] = cmnd;
 715zombie:
 716	spin_unlock_irqrestore(&devinfo->lock, flags);
 717	return 0;
 718}
 719
 720static DEF_SCSI_QCMD(uas_queuecommand)
 721
 722/*
 723 * For now we do not support actually sending an abort to the device, so
 724 * this eh always fails. Still we must define it to make sure that we've
 725 * dropped all references to the cmnd in question once this function exits.
 726 */
 727static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
 728{
 729	struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
 730	struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
 731	struct urb *data_in_urb = NULL;
 732	struct urb *data_out_urb = NULL;
 733	unsigned long flags;
 734
 735	spin_lock_irqsave(&devinfo->lock, flags);
 736
 737	uas_log_cmd_state(cmnd, __func__, 0);
 738
 739	/* Ensure that try_complete does not call scsi_done */
 740	cmdinfo->state |= COMMAND_ABORTED;
 741
 742	/* Drop all refs to this cmnd, kill data urbs to break their ref */
 743	devinfo->cmnd[cmdinfo->uas_tag - 1] = NULL;
 744	if (cmdinfo->state & DATA_IN_URB_INFLIGHT)
 745		data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
 746	if (cmdinfo->state & DATA_OUT_URB_INFLIGHT)
 747		data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
 748
 749	uas_free_unsubmitted_urbs(cmnd);
 750
 751	spin_unlock_irqrestore(&devinfo->lock, flags);
 752
 753	if (data_in_urb) {
 754		usb_kill_urb(data_in_urb);
 755		usb_put_urb(data_in_urb);
 756	}
 757	if (data_out_urb) {
 758		usb_kill_urb(data_out_urb);
 759		usb_put_urb(data_out_urb);
 760	}
 761
 762	return FAILED;
 763}
 764
 765static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
 766{
 767	struct scsi_device *sdev = cmnd->device;
 768	struct uas_dev_info *devinfo = sdev->hostdata;
 769	struct usb_device *udev = devinfo->udev;
 770	unsigned long flags;
 771	int err;
 772
 773	err = usb_lock_device_for_reset(udev, devinfo->intf);
 774	if (err) {
 775		shost_printk(KERN_ERR, sdev->host,
 776			     "%s FAILED to get lock err %d\n", __func__, err);
 777		return FAILED;
 778	}
 779
 780	shost_printk(KERN_INFO, sdev->host, "%s start\n", __func__);
 781
 782	spin_lock_irqsave(&devinfo->lock, flags);
 783	devinfo->resetting = 1;
 784	spin_unlock_irqrestore(&devinfo->lock, flags);
 785
 786	usb_kill_anchored_urbs(&devinfo->cmd_urbs);
 787	usb_kill_anchored_urbs(&devinfo->sense_urbs);
 788	usb_kill_anchored_urbs(&devinfo->data_urbs);
 789	uas_zap_pending(devinfo, DID_RESET);
 790
 791	err = usb_reset_device(udev);
 792
 793	spin_lock_irqsave(&devinfo->lock, flags);
 794	devinfo->resetting = 0;
 795	spin_unlock_irqrestore(&devinfo->lock, flags);
 796
 797	usb_unlock_device(udev);
 798
 799	if (err) {
 800		shost_printk(KERN_INFO, sdev->host, "%s FAILED err %d\n",
 801			     __func__, err);
 802		return FAILED;
 803	}
 804
 805	shost_printk(KERN_INFO, sdev->host, "%s success\n", __func__);
 806	return SUCCESS;
 807}
 808
 809static int uas_target_alloc(struct scsi_target *starget)
 810{
 811	struct uas_dev_info *devinfo = (struct uas_dev_info *)
 812			dev_to_shost(starget->dev.parent)->hostdata;
 813
 814	if (devinfo->flags & US_FL_NO_REPORT_LUNS)
 815		starget->no_report_luns = 1;
 816
 817	return 0;
 818}
 819
 820static int uas_slave_alloc(struct scsi_device *sdev)
 821{
 822	struct uas_dev_info *devinfo =
 823		(struct uas_dev_info *)sdev->host->hostdata;
 824
 825	sdev->hostdata = devinfo;
 826
 827	/*
 828	 * The protocol has no requirements on alignment in the strict sense.
 829	 * Controllers may or may not have alignment restrictions.
 830	 * As this is not exported, we use an extremely conservative guess.
 831	 */
 832	blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
 833
 834	if (devinfo->flags & US_FL_MAX_SECTORS_64)
 835		blk_queue_max_hw_sectors(sdev->request_queue, 64);
 836	else if (devinfo->flags & US_FL_MAX_SECTORS_240)
 837		blk_queue_max_hw_sectors(sdev->request_queue, 240);
 838
 839	return 0;
 840}
 841
 842static int uas_slave_configure(struct scsi_device *sdev)
 843{
 844	struct uas_dev_info *devinfo = sdev->hostdata;
 845
 846	if (devinfo->flags & US_FL_NO_REPORT_OPCODES)
 847		sdev->no_report_opcodes = 1;
 848
 849	/* A few buggy USB-ATA bridges don't understand FUA */
 850	if (devinfo->flags & US_FL_BROKEN_FUA)
 851		sdev->broken_fua = 1;
 852
 853	/* UAS also needs to support FL_ALWAYS_SYNC */
 854	if (devinfo->flags & US_FL_ALWAYS_SYNC) {
 855		sdev->skip_ms_page_3f = 1;
 856		sdev->skip_ms_page_8 = 1;
 857		sdev->wce_default_on = 1;
 858	}
 859
 860	/* Some disks cannot handle READ_CAPACITY_16 */
 861	if (devinfo->flags & US_FL_NO_READ_CAPACITY_16)
 862		sdev->no_read_capacity_16 = 1;
 863
 864	/* Some disks cannot handle WRITE_SAME */
 865	if (devinfo->flags & US_FL_NO_SAME)
 866		sdev->no_write_same = 1;
 867	/*
 868	 * Some disks return the total number of blocks in response
 869	 * to READ CAPACITY rather than the highest block number.
 870	 * If this device makes that mistake, tell the sd driver.
 871	 */
 872	if (devinfo->flags & US_FL_FIX_CAPACITY)
 873		sdev->fix_capacity = 1;
 874
 875	/*
 876	 * in some cases we have to guess
 877	 */
 878	if (devinfo->flags & US_FL_CAPACITY_HEURISTICS)
 879		sdev->guess_capacity = 1;
 880
 881	/*
 882	 * Some devices report generic values until the media has been
 883	 * accessed. Force a READ(10) prior to querying device
 884	 * characteristics.
 885	 */
 886	sdev->read_before_ms = 1;
 887
 888	/*
 889	 * Some devices don't like MODE SENSE with page=0x3f,
 890	 * which is the command used for checking if a device
 891	 * is write-protected.  Now that we tell the sd driver
 892	 * to do a 192-byte transfer with this command the
 893	 * majority of devices work fine, but a few still can't
 894	 * handle it.  The sd driver will simply assume those
 895	 * devices are write-enabled.
 896	 */
 897	if (devinfo->flags & US_FL_NO_WP_DETECT)
 898		sdev->skip_ms_page_3f = 1;
 899
 900	scsi_change_queue_depth(sdev, devinfo->qdepth - 2);
 901	return 0;
 902}
 903
 904static const struct scsi_host_template uas_host_template = {
 905	.module = THIS_MODULE,
 906	.name = "uas",
 907	.queuecommand = uas_queuecommand,
 908	.target_alloc = uas_target_alloc,
 909	.slave_alloc = uas_slave_alloc,
 910	.slave_configure = uas_slave_configure,
 911	.eh_abort_handler = uas_eh_abort_handler,
 912	.eh_device_reset_handler = uas_eh_device_reset_handler,
 913	.this_id = -1,
 914	.skip_settle_delay = 1,
 915	.dma_boundary = PAGE_SIZE - 1,
 916	.cmd_size = sizeof(struct uas_cmd_info),
 917};
 918
 919#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
 920		    vendorName, productName, useProtocol, useTransport, \
 921		    initFunction, flags) \
 922{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
 923	.driver_info = (flags) }
 924
 925static struct usb_device_id uas_usb_ids[] = {
 926#	include "unusual_uas.h"
 927	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
 928	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
 929	{ }
 930};
 931MODULE_DEVICE_TABLE(usb, uas_usb_ids);
 932
 933#undef UNUSUAL_DEV
 934
 935static int uas_switch_interface(struct usb_device *udev,
 936				struct usb_interface *intf)
 937{
 938	struct usb_host_interface *alt;
 939
 940	alt = uas_find_uas_alt_setting(intf);
 941	if (!alt)
 942		return -ENODEV;
 943
 944	return usb_set_interface(udev, alt->desc.bInterfaceNumber,
 945			alt->desc.bAlternateSetting);
 946}
 947
 948static int uas_configure_endpoints(struct uas_dev_info *devinfo)
 949{
 950	struct usb_host_endpoint *eps[4] = { };
 951	struct usb_device *udev = devinfo->udev;
 952	int r;
 953
 954	r = uas_find_endpoints(devinfo->intf->cur_altsetting, eps);
 955	if (r)
 956		return r;
 957
 958	devinfo->cmd_pipe = usb_sndbulkpipe(udev,
 959					    usb_endpoint_num(&eps[0]->desc));
 960	devinfo->status_pipe = usb_rcvbulkpipe(udev,
 961					    usb_endpoint_num(&eps[1]->desc));
 962	devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
 963					    usb_endpoint_num(&eps[2]->desc));
 964	devinfo->data_out_pipe = usb_sndbulkpipe(udev,
 965					    usb_endpoint_num(&eps[3]->desc));
 966
 967	if (udev->speed < USB_SPEED_SUPER) {
 968		devinfo->qdepth = 32;
 969		devinfo->use_streams = 0;
 970	} else {
 971		devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1,
 972						    3, MAX_CMNDS, GFP_NOIO);
 973		if (devinfo->qdepth < 0)
 974			return devinfo->qdepth;
 975		devinfo->use_streams = 1;
 976	}
 977
 978	return 0;
 979}
 980
 981static void uas_free_streams(struct uas_dev_info *devinfo)
 982{
 983	struct usb_device *udev = devinfo->udev;
 984	struct usb_host_endpoint *eps[3];
 985
 986	eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
 987	eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
 988	eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
 989	usb_free_streams(devinfo->intf, eps, 3, GFP_NOIO);
 990}
 991
 992static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
 993{
 994	int result = -ENOMEM;
 995	struct Scsi_Host *shost = NULL;
 996	struct uas_dev_info *devinfo;
 997	struct usb_device *udev = interface_to_usbdev(intf);
 998	u64 dev_flags;
 999
1000	if (!uas_use_uas_driver(intf, id, &dev_flags))
1001		return -ENODEV;
1002
1003	if (uas_switch_interface(udev, intf))
1004		return -ENODEV;
1005
1006	shost = scsi_host_alloc(&uas_host_template,
1007				sizeof(struct uas_dev_info));
1008	if (!shost)
1009		goto set_alt0;
1010
1011	shost->max_cmd_len = 16 + 252;
1012	shost->max_id = 1;
1013	shost->max_lun = 256;
1014	shost->max_channel = 0;
1015	shost->sg_tablesize = udev->bus->sg_tablesize;
1016
1017	devinfo = (struct uas_dev_info *)shost->hostdata;
1018	devinfo->intf = intf;
1019	devinfo->udev = udev;
1020	devinfo->resetting = 0;
1021	devinfo->shutdown = 0;
1022	devinfo->flags = dev_flags;
1023	init_usb_anchor(&devinfo->cmd_urbs);
1024	init_usb_anchor(&devinfo->sense_urbs);
1025	init_usb_anchor(&devinfo->data_urbs);
1026	spin_lock_init(&devinfo->lock);
1027	INIT_WORK(&devinfo->work, uas_do_work);
1028	INIT_WORK(&devinfo->scan_work, uas_scan_work);
1029
1030	result = uas_configure_endpoints(devinfo);
1031	if (result)
1032		goto set_alt0;
1033
1034	/*
1035	 * 1 tag is reserved for untagged commands +
1036	 * 1 tag to avoid off by one errors in some bridge firmwares
1037	 */
1038	shost->can_queue = devinfo->qdepth - 2;
1039
1040	usb_set_intfdata(intf, shost);
1041	result = scsi_add_host(shost, &intf->dev);
1042	if (result)
1043		goto free_streams;
1044
1045	/* Submit the delayed_work for SCSI-device scanning */
1046	schedule_work(&devinfo->scan_work);
1047
1048	return result;
1049
1050free_streams:
1051	uas_free_streams(devinfo);
1052	usb_set_intfdata(intf, NULL);
1053set_alt0:
1054	usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1055	if (shost)
1056		scsi_host_put(shost);
1057	return result;
1058}
1059
1060static int uas_cmnd_list_empty(struct uas_dev_info *devinfo)
1061{
1062	unsigned long flags;
1063	int i, r = 1;
1064
1065	spin_lock_irqsave(&devinfo->lock, flags);
1066
1067	for (i = 0; i < devinfo->qdepth; i++) {
1068		if (devinfo->cmnd[i]) {
1069			r = 0; /* Not empty */
1070			break;
1071		}
1072	}
1073
1074	spin_unlock_irqrestore(&devinfo->lock, flags);
1075
1076	return r;
1077}
1078
1079/*
1080 * Wait for any pending cmnds to complete, on usb-2 sense_urbs may temporarily
1081 * get empty while there still is more work to do due to sense-urbs completing
1082 * with a READ/WRITE_READY iu code, so keep waiting until the list gets empty.
1083 */
1084static int uas_wait_for_pending_cmnds(struct uas_dev_info *devinfo)
1085{
1086	unsigned long start_time;
1087	int r;
1088
1089	start_time = jiffies;
1090	do {
1091		flush_work(&devinfo->work);
1092
1093		r = usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000);
1094		if (r == 0)
1095			return -ETIME;
1096
1097		r = usb_wait_anchor_empty_timeout(&devinfo->data_urbs, 500);
1098		if (r == 0)
1099			return -ETIME;
1100
1101		if (time_after(jiffies, start_time + 5 * HZ))
1102			return -ETIME;
1103	} while (!uas_cmnd_list_empty(devinfo));
1104
1105	return 0;
1106}
1107
1108static int uas_pre_reset(struct usb_interface *intf)
1109{
1110	struct Scsi_Host *shost = usb_get_intfdata(intf);
1111	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1112	unsigned long flags;
1113
1114	if (devinfo->shutdown)
1115		return 0;
1116
1117	/* Block new requests */
1118	spin_lock_irqsave(shost->host_lock, flags);
1119	scsi_block_requests(shost);
1120	spin_unlock_irqrestore(shost->host_lock, flags);
1121
1122	if (uas_wait_for_pending_cmnds(devinfo) != 0) {
1123		shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1124		scsi_unblock_requests(shost);
1125		return 1;
1126	}
1127
1128	uas_free_streams(devinfo);
1129
1130	return 0;
1131}
1132
1133static int uas_post_reset(struct usb_interface *intf)
1134{
1135	struct Scsi_Host *shost = usb_get_intfdata(intf);
1136	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1137	unsigned long flags;
1138	int err;
1139
1140	if (devinfo->shutdown)
1141		return 0;
1142
1143	err = uas_configure_endpoints(devinfo);
1144	if (err && err != -ENODEV)
1145		shost_printk(KERN_ERR, shost,
1146			     "%s: alloc streams error %d after reset",
1147			     __func__, err);
1148
1149	/* we must unblock the host in every case lest we deadlock */
1150	spin_lock_irqsave(shost->host_lock, flags);
1151	scsi_report_bus_reset(shost, 0);
1152	spin_unlock_irqrestore(shost->host_lock, flags);
1153
1154	scsi_unblock_requests(shost);
1155
1156	return err ? 1 : 0;
1157}
1158
1159static int uas_suspend(struct usb_interface *intf, pm_message_t message)
1160{
1161	struct Scsi_Host *shost = usb_get_intfdata(intf);
1162	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1163
1164	if (uas_wait_for_pending_cmnds(devinfo) != 0) {
1165		shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1166		return -ETIME;
1167	}
1168
1169	return 0;
1170}
1171
1172static int uas_resume(struct usb_interface *intf)
1173{
1174	return 0;
1175}
1176
1177static int uas_reset_resume(struct usb_interface *intf)
1178{
1179	struct Scsi_Host *shost = usb_get_intfdata(intf);
1180	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1181	unsigned long flags;
1182	int err;
1183
1184	err = uas_configure_endpoints(devinfo);
1185	if (err) {
1186		shost_printk(KERN_ERR, shost,
1187			     "%s: alloc streams error %d after reset",
1188			     __func__, err);
1189		return -EIO;
1190	}
1191
1192	spin_lock_irqsave(shost->host_lock, flags);
1193	scsi_report_bus_reset(shost, 0);
1194	spin_unlock_irqrestore(shost->host_lock, flags);
1195
1196	return 0;
1197}
1198
1199static void uas_disconnect(struct usb_interface *intf)
1200{
1201	struct Scsi_Host *shost = usb_get_intfdata(intf);
1202	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1203	unsigned long flags;
1204
1205	spin_lock_irqsave(&devinfo->lock, flags);
1206	devinfo->resetting = 1;
1207	spin_unlock_irqrestore(&devinfo->lock, flags);
1208
1209	cancel_work_sync(&devinfo->work);
1210	usb_kill_anchored_urbs(&devinfo->cmd_urbs);
1211	usb_kill_anchored_urbs(&devinfo->sense_urbs);
1212	usb_kill_anchored_urbs(&devinfo->data_urbs);
1213	uas_zap_pending(devinfo, DID_NO_CONNECT);
1214
1215	/*
1216	 * Prevent SCSI scanning (if it hasn't started yet)
1217	 * or wait for the SCSI-scanning routine to stop.
1218	 */
1219	cancel_work_sync(&devinfo->scan_work);
1220
1221	scsi_remove_host(shost);
1222	uas_free_streams(devinfo);
1223	scsi_host_put(shost);
1224}
1225
1226/*
1227 * Put the device back in usb-storage mode on shutdown, as some BIOS-es
1228 * hang on reboot when the device is still in uas mode. Note the reset is
1229 * necessary as some devices won't revert to usb-storage mode without it.
1230 */
1231static void uas_shutdown(struct device *dev)
1232{
1233	struct usb_interface *intf = to_usb_interface(dev);
1234	struct usb_device *udev = interface_to_usbdev(intf);
1235	struct Scsi_Host *shost = usb_get_intfdata(intf);
1236	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1237
1238	if (system_state != SYSTEM_RESTART)
1239		return;
1240
1241	devinfo->shutdown = 1;
1242	uas_free_streams(devinfo);
1243	usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1244	usb_reset_device(udev);
1245}
1246
1247static struct usb_driver uas_driver = {
1248	.name = "uas",
1249	.probe = uas_probe,
1250	.disconnect = uas_disconnect,
1251	.pre_reset = uas_pre_reset,
1252	.post_reset = uas_post_reset,
1253	.suspend = uas_suspend,
1254	.resume = uas_resume,
1255	.reset_resume = uas_reset_resume,
1256	.driver.shutdown = uas_shutdown,
1257	.id_table = uas_usb_ids,
1258};
1259
1260static int __init uas_init(void)
1261{
1262	int rv;
1263
1264	workqueue = alloc_workqueue("uas", WQ_MEM_RECLAIM, 0);
1265	if (!workqueue)
1266		return -ENOMEM;
1267
1268	rv = usb_register(&uas_driver);
1269	if (rv) {
1270		destroy_workqueue(workqueue);
1271		return -ENOMEM;
1272	}
1273
1274	return 0;
1275}
1276
1277static void __exit uas_exit(void)
1278{
1279	usb_deregister(&uas_driver);
1280	destroy_workqueue(workqueue);
1281}
1282
1283module_init(uas_init);
1284module_exit(uas_exit);
1285
1286MODULE_LICENSE("GPL");
1287MODULE_IMPORT_NS(USB_STORAGE);
1288MODULE_AUTHOR(
1289	"Hans de Goede <hdegoede@redhat.com>, Matthew Wilcox and Sarah Sharp");