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