uas.c 31 KB
Newer Older
Matthew Wilcox's avatar
Matthew Wilcox committed
1 2 3 4
/*
 * USB Attached SCSI
 * Note that this is not the same as the USB Mass Storage driver
 *
5
 * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2016
Matthew Wilcox's avatar
Matthew Wilcox committed
6 7 8 9 10 11 12 13 14
 * Copyright Matthew Wilcox for Intel Corp, 2010
 * Copyright Sarah Sharp for Intel Corp, 2010
 *
 * Distributed under the terms of the GNU GPL, version two.
 */

#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/types.h>
15
#include <linux/module.h>
Matthew Wilcox's avatar
Matthew Wilcox committed
16
#include <linux/usb.h>
17
#include <linux/usb_usual.h>
18
#include <linux/usb/hcd.h>
Matthew Wilcox's avatar
Matthew Wilcox committed
19
#include <linux/usb/storage.h>
20
#include <linux/usb/uas.h>
Matthew Wilcox's avatar
Matthew Wilcox committed
21 22

#include <scsi/scsi.h>
23
#include <scsi/scsi_eh.h>
Matthew Wilcox's avatar
Matthew Wilcox committed
24 25 26 27 28 29
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>

30
#include "uas-detect.h"
31
#include "scsiglue.h"
32

33
#define MAX_CMNDS 256
Matthew Wilcox's avatar
Matthew Wilcox committed
34 35 36 37

struct uas_dev_info {
	struct usb_interface *intf;
	struct usb_device *udev;
38
	struct usb_anchor cmd_urbs;
39 40
	struct usb_anchor sense_urbs;
	struct usb_anchor data_urbs;
41
	unsigned long flags;
42
	int qdepth, resetting;
Matthew Wilcox's avatar
Matthew Wilcox committed
43 44
	unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
	unsigned use_streams:1;
Hans de Goede's avatar
Hans de Goede committed
45
	unsigned shutdown:1;
46
	struct scsi_cmnd *cmnd[MAX_CMNDS];
Gerd Hoffmann's avatar
Gerd Hoffmann committed
47
	spinlock_t lock;
48
	struct work_struct work;
Matthew Wilcox's avatar
Matthew Wilcox committed
49 50 51
};

enum {
52
	SUBMIT_STATUS_URB	= (1 << 1),
Matthew Wilcox's avatar
Matthew Wilcox committed
53 54 55 56 57 58
	ALLOC_DATA_IN_URB	= (1 << 2),
	SUBMIT_DATA_IN_URB	= (1 << 3),
	ALLOC_DATA_OUT_URB	= (1 << 4),
	SUBMIT_DATA_OUT_URB	= (1 << 5),
	ALLOC_CMD_URB		= (1 << 6),
	SUBMIT_CMD_URB		= (1 << 7),
59 60 61
	COMMAND_INFLIGHT        = (1 << 8),
	DATA_IN_URB_INFLIGHT    = (1 << 9),
	DATA_OUT_URB_INFLIGHT   = (1 << 10),
62 63
	COMMAND_ABORTED         = (1 << 11),
	IS_IN_WORK_LIST         = (1 << 12),
Matthew Wilcox's avatar
Matthew Wilcox committed
64 65 66 67 68
};

/* Overrides scsi_pointer */
struct uas_cmd_info {
	unsigned int state;
69
	unsigned int uas_tag;
Matthew Wilcox's avatar
Matthew Wilcox committed
70 71 72 73 74 75 76 77
	struct urb *cmd_urb;
	struct urb *data_in_urb;
	struct urb *data_out_urb;
};

/* I hate forward declarations, but I actually have a loop */
static int uas_submit_urbs(struct scsi_cmnd *cmnd,
				struct uas_dev_info *devinfo, gfp_t gfp);
78
static void uas_do_work(struct work_struct *work);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
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 82
static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
				int status);
83

Matthew Wilcox's avatar
Matthew Wilcox committed
84 85
static void uas_do_work(struct work_struct *work)
{
86 87
	struct uas_dev_info *devinfo =
		container_of(work, struct uas_dev_info, work);
Matthew Wilcox's avatar
Matthew Wilcox committed
88
	struct uas_cmd_info *cmdinfo;
Hans de Goede's avatar
Hans de Goede committed
89
	struct scsi_cmnd *cmnd;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
90
	unsigned long flags;
Hans de Goede's avatar
Hans de Goede committed
91
	int i, err;
Matthew Wilcox's avatar
Matthew Wilcox committed
92

93
	spin_lock_irqsave(&devinfo->lock, flags);
94 95 96 97

	if (devinfo->resetting)
		goto out;

Hans de Goede's avatar
Hans de Goede committed
98 99 100 101 102 103
	for (i = 0; i < devinfo->qdepth; i++) {
		if (!devinfo->cmnd[i])
			continue;

		cmnd = devinfo->cmnd[i];
		cmdinfo = (void *)&cmnd->SCp;
104 105 106 107

		if (!(cmdinfo->state & IS_IN_WORK_LIST))
			continue;

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);
Matthew Wilcox's avatar
Matthew Wilcox committed
113
	}
114
out:
Gerd Hoffmann's avatar
Gerd Hoffmann committed
115 116 117
	spin_unlock_irqrestore(&devinfo->lock, flags);
}

118 119 120 121 122 123
static void uas_add_work(struct uas_cmd_info *cmdinfo)
{
	struct scsi_pointer *scp = (void *)cmdinfo;
	struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, SCp);
	struct uas_dev_info *devinfo = cmnd->device->hostdata;

124
	lockdep_assert_held(&devinfo->lock);
125 126 127 128
	cmdinfo->state |= IS_IN_WORK_LIST;
	schedule_work(&devinfo->work);
}

129
static void uas_zap_pending(struct uas_dev_info *devinfo, int result)
Gerd Hoffmann's avatar
Gerd Hoffmann committed
130 131
{
	struct uas_cmd_info *cmdinfo;
Hans de Goede's avatar
Hans de Goede committed
132
	struct scsi_cmnd *cmnd;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
133
	unsigned long flags;
Hans de Goede's avatar
Hans de Goede committed
134
	int i, err;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
135 136

	spin_lock_irqsave(&devinfo->lock, flags);
Hans de Goede's avatar
Hans de Goede committed
137 138 139 140 141 142
	for (i = 0; i < devinfo->qdepth; i++) {
		if (!devinfo->cmnd[i])
			continue;

		cmnd = devinfo->cmnd[i];
		cmdinfo = (void *)&cmnd->SCp;
143
		uas_log_cmd_state(cmnd, __func__, 0);
144 145
		/* Sense urbs were killed, clear COMMAND_INFLIGHT manually */
		cmdinfo->state &= ~COMMAND_INFLIGHT;
146
		cmnd->result = result << 16;
147 148
		err = uas_try_complete(cmnd, __func__);
		WARN_ON(err != 0);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
149 150 151 152
	}
	spin_unlock_irqrestore(&devinfo->lock, flags);
}

Matthew Wilcox's avatar
Matthew Wilcox committed
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
{
	struct sense_iu *sense_iu = urb->transfer_buffer;
	struct scsi_device *sdev = cmnd->device;

	if (urb->actual_length > 16) {
		unsigned len = be16_to_cpup(&sense_iu->len);
		if (len + 16 != urb->actual_length) {
			int newlen = min(len + 16, urb->actual_length) - 16;
			if (newlen < 0)
				newlen = 0;
			sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
				"disagrees with IU sense data length %d, "
				"using %d bytes of sense data\n", __func__,
					urb->actual_length, len, newlen);
			len = newlen;
		}
		memcpy(cmnd->sense_buffer, sense_iu->sense, len);
	}

	cmnd->result = sense_iu->status;
}

176 177
static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
			      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 184
		    "%s %d uas-tag %d inflight:%s%s%s%s%s%s%s%s%s%s%s%s ",
		    prefix, status, cmdinfo->uas_tag,
185 186 187 188 189 190 191 192 193 194
		    (ci->state & SUBMIT_STATUS_URB)     ? " s-st"  : "",
		    (ci->state & ALLOC_DATA_IN_URB)     ? " a-in"  : "",
		    (ci->state & SUBMIT_DATA_IN_URB)    ? " s-in"  : "",
		    (ci->state & ALLOC_DATA_OUT_URB)    ? " a-out" : "",
		    (ci->state & SUBMIT_DATA_OUT_URB)   ? " s-out" : "",
		    (ci->state & ALLOC_CMD_URB)         ? " a-cmd" : "",
		    (ci->state & SUBMIT_CMD_URB)        ? " s-cmd" : "",
		    (ci->state & COMMAND_INFLIGHT)      ? " CMD"   : "",
		    (ci->state & DATA_IN_URB_INFLIGHT)  ? " IN"    : "",
		    (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT"   : "",
195
		    (ci->state & COMMAND_ABORTED)       ? " abort" : "",
196
		    (ci->state & IS_IN_WORK_LIST)       ? " work"  : "");
Hans de Goede's avatar
Hans de Goede committed
197
	scsi_print_command(cmnd);
198 199
}

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
static void uas_free_unsubmitted_urbs(struct scsi_cmnd *cmnd)
{
	struct uas_cmd_info *cmdinfo;

	if (!cmnd)
		return;

	cmdinfo = (void *)&cmnd->SCp;

	if (cmdinfo->state & SUBMIT_CMD_URB)
		usb_free_urb(cmdinfo->cmd_urb);

	/* data urbs may have never gotten their submit flag set */
	if (!(cmdinfo->state & DATA_IN_URB_INFLIGHT))
		usb_free_urb(cmdinfo->data_in_urb);
	if (!(cmdinfo->state & DATA_OUT_URB_INFLIGHT))
		usb_free_urb(cmdinfo->data_out_urb);
217 218 219 220 221
}

static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
{
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
222
	struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
223

224
	lockdep_assert_held(&devinfo->lock);
225 226
	if (cmdinfo->state & (COMMAND_INFLIGHT |
			      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;
Matthew Wilcox's avatar
Matthew Wilcox committed
234 235 236
}

static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
237
			  unsigned direction)
Matthew Wilcox's avatar
Matthew Wilcox committed
238 239 240 241
{
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
	int err;

242
	cmdinfo->state |= direction | SUBMIT_STATUS_URB;
Matthew Wilcox's avatar
Matthew Wilcox committed
243 244
	err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
	if (err) {
245
		uas_add_work(cmdinfo);
Matthew Wilcox's avatar
Matthew Wilcox committed
246 247 248 249 250 251
	}
}

static void uas_stat_cmplt(struct urb *urb)
{
	struct iu *iu = urb->transfer_buffer;
252
	struct Scsi_Host *shost = urb->context;
Hans de Goede's avatar
Hans de Goede committed
253
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
254 255
	struct urb *data_in_urb = NULL;
	struct urb *data_out_urb = NULL;
Matthew Wilcox's avatar
Matthew Wilcox committed
256
	struct scsi_cmnd *cmnd;
257
	struct uas_cmd_info *cmdinfo;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
258
	unsigned long flags;
259
	unsigned int idx;
260
	int status = urb->status;
Matthew Wilcox's avatar
Matthew Wilcox committed
261

262 263 264 265
	spin_lock_irqsave(&devinfo->lock, flags);

	if (devinfo->resetting)
		goto out;
Matthew Wilcox's avatar
Matthew Wilcox committed
266

267 268 269
	if (status) {
		if (status != -ENOENT && status != -ECONNRESET && status != -ESHUTDOWN)
			dev_err(&urb->dev->dev, "stat urb: status %d\n", status);
270
		goto out;
Matthew Wilcox's avatar
Matthew Wilcox committed
271 272
	}

273 274 275
	idx = be16_to_cpup(&iu->tag) - 1;
	if (idx >= MAX_CMNDS || !devinfo->cmnd[idx]) {
		dev_err(&urb->dev->dev,
276
			"stat urb: no pending cmd for uas-tag %d\n", idx + 1);
277
		goto out;
278 279
	}

280
	cmnd = devinfo->cmnd[idx];
Gerd Hoffmann's avatar
Gerd Hoffmann committed
281
	cmdinfo = (void *)&cmnd->SCp;
282 283

	if (!(cmdinfo->state & COMMAND_INFLIGHT)) {
284
		uas_log_cmd_state(cmnd, "unexpected status cmplt", 0);
285
		goto out;
286
	}
Matthew Wilcox's avatar
Matthew Wilcox committed
287 288 289

	switch (iu->iu_id) {
	case IU_ID_STATUS:
290
		uas_sense(urb, cmnd);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
291 292
		if (cmnd->result != 0) {
			/* cancel data transfers on error */
293 294
			data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
			data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
295
		}
296 297
		cmdinfo->state &= ~COMMAND_INFLIGHT;
		uas_try_complete(cmnd, __func__);
Matthew Wilcox's avatar
Matthew Wilcox committed
298 299
		break;
	case IU_ID_READ_READY:
300 301
		if (!cmdinfo->data_in_urb ||
				(cmdinfo->state & DATA_IN_URB_INFLIGHT)) {
302
			uas_log_cmd_state(cmnd, "unexpected read rdy", 0);
303 304
			break;
		}
Matthew Wilcox's avatar
Matthew Wilcox committed
305 306 307
		uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
		break;
	case IU_ID_WRITE_READY:
308 309
		if (!cmdinfo->data_out_urb ||
				(cmdinfo->state & DATA_OUT_URB_INFLIGHT)) {
310
			uas_log_cmd_state(cmnd, "unexpected write rdy", 0);
311 312
			break;
		}
Matthew Wilcox's avatar
Matthew Wilcox committed
313 314
		uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
		break;
315 316 317 318 319 320 321 322 323 324
	case IU_ID_RESPONSE:
		uas_log_cmd_state(cmnd, "unexpected response iu",
				  ((struct response_iu *)iu)->response_code);
		/* Error, cancel data transfers */
		data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
		data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
		cmdinfo->state &= ~COMMAND_INFLIGHT;
		cmnd->result = DID_ERROR << 16;
		uas_try_complete(cmnd, __func__);
		break;
Matthew Wilcox's avatar
Matthew Wilcox committed
325
	default:
326
		uas_log_cmd_state(cmnd, "bogus IU", iu->iu_id);
Matthew Wilcox's avatar
Matthew Wilcox committed
327
	}
328
out:
Gerd Hoffmann's avatar
Gerd Hoffmann committed
329
	usb_free_urb(urb);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
330
	spin_unlock_irqrestore(&devinfo->lock, flags);
331 332 333 334 335 336 337 338 339 340

	/* Unlinking of data urbs must be done without holding the lock */
	if (data_in_urb) {
		usb_unlink_urb(data_in_urb);
		usb_put_urb(data_in_urb);
	}
	if (data_out_urb) {
		usb_unlink_urb(data_out_urb);
		usb_put_urb(data_out_urb);
	}
Matthew Wilcox's avatar
Matthew Wilcox committed
341 342
}

343
static void uas_data_cmplt(struct urb *urb)
Matthew Wilcox's avatar
Matthew Wilcox committed
344
{
345 346
	struct scsi_cmnd *cmnd = urb->context;
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
347
	struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
348
	struct scsi_data_buffer *sdb = NULL;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
349
	unsigned long flags;
350
	int status = urb->status;
351

Gerd Hoffmann's avatar
Gerd Hoffmann committed
352
	spin_lock_irqsave(&devinfo->lock, flags);
353

354 355 356
	if (cmdinfo->data_in_urb == urb) {
		sdb = scsi_in(cmnd);
		cmdinfo->state &= ~DATA_IN_URB_INFLIGHT;
357
		cmdinfo->data_in_urb = NULL;
358 359 360
	} else if (cmdinfo->data_out_urb == urb) {
		sdb = scsi_out(cmnd);
		cmdinfo->state &= ~DATA_OUT_URB_INFLIGHT;
361
		cmdinfo->data_out_urb = NULL;
362
	}
363 364
	if (sdb == NULL) {
		WARN_ON_ONCE(1);
365 366 367 368 369 370
		goto out;
	}

	if (devinfo->resetting)
		goto out;

371 372
	/* Data urbs should not complete before the cmd urb is submitted */
	if (cmdinfo->state & SUBMIT_CMD_URB) {
373
		uas_log_cmd_state(cmnd, "unexpected data cmplt", 0);
374 375 376
		goto out;
	}

377 378 379
	if (status) {
		if (status != -ENOENT && status != -ECONNRESET && status != -ESHUTDOWN)
			uas_log_cmd_state(cmnd, "data cmplt err", status);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
380 381 382 383 384
		/* error: no data transfered */
		sdb->resid = sdb->length;
	} else {
		sdb->resid = sdb->length - urb->actual_length;
	}
385
	uas_try_complete(cmnd, __func__);
386
out:
387
	usb_free_urb(urb);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
388
	spin_unlock_irqrestore(&devinfo->lock, flags);
Matthew Wilcox's avatar
Matthew Wilcox committed
389 390
}

Hans de Goede's avatar
Hans de Goede committed
391 392
static void uas_cmd_cmplt(struct urb *urb)
{
393 394
	if (urb->status)
		dev_err(&urb->dev->dev, "cmd cmplt err %d\n", urb->status);
Hans de Goede's avatar
Hans de Goede committed
395 396 397 398

	usb_free_urb(urb);
}

Matthew Wilcox's avatar
Matthew Wilcox committed
399
static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
400 401
				      struct scsi_cmnd *cmnd,
				      enum dma_data_direction dir)
Matthew Wilcox's avatar
Matthew Wilcox committed
402 403
{
	struct usb_device *udev = devinfo->udev;
404
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
Matthew Wilcox's avatar
Matthew Wilcox committed
405
	struct urb *urb = usb_alloc_urb(0, gfp);
406 407
	struct scsi_data_buffer *sdb = (dir == DMA_FROM_DEVICE)
		? scsi_in(cmnd) : scsi_out(cmnd);
408 409
	unsigned int pipe = (dir == DMA_FROM_DEVICE)
		? devinfo->data_in_pipe : devinfo->data_out_pipe;
Matthew Wilcox's avatar
Matthew Wilcox committed
410 411 412

	if (!urb)
		goto out;
413 414
	usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length,
			  uas_data_cmplt, cmnd);
415 416
	if (devinfo->use_streams)
		urb->stream_id = cmdinfo->uas_tag;
Matthew Wilcox's avatar
Matthew Wilcox committed
417 418 419 420 421 422 423
	urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
	urb->sg = sdb->table.sgl;
 out:
	return urb;
}

static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
424
				       struct scsi_cmnd *cmnd)
Matthew Wilcox's avatar
Matthew Wilcox committed
425 426
{
	struct usb_device *udev = devinfo->udev;
427
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
Matthew Wilcox's avatar
Matthew Wilcox committed
428 429 430 431 432 433
	struct urb *urb = usb_alloc_urb(0, gfp);
	struct sense_iu *iu;

	if (!urb)
		goto out;

434
	iu = kzalloc(sizeof(*iu), gfp);
Matthew Wilcox's avatar
Matthew Wilcox committed
435 436 437 438
	if (!iu)
		goto free;

	usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
439
			  uas_stat_cmplt, cmnd->device->host);
440 441
	if (devinfo->use_streams)
		urb->stream_id = cmdinfo->uas_tag;
Matthew Wilcox's avatar
Matthew Wilcox committed
442 443 444 445 446 447 448 449 450
	urb->transfer_flags |= URB_FREE_BUFFER;
 out:
	return urb;
 free:
	usb_free_urb(urb);
	return NULL;
}

static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
451
					struct scsi_cmnd *cmnd)
Matthew Wilcox's avatar
Matthew Wilcox committed
452 453 454
{
	struct usb_device *udev = devinfo->udev;
	struct scsi_device *sdev = cmnd->device;
455
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
Matthew Wilcox's avatar
Matthew Wilcox committed
456 457 458 459 460 461 462 463 464 465 466
	struct urb *urb = usb_alloc_urb(0, gfp);
	struct command_iu *iu;
	int len;

	if (!urb)
		goto out;

	len = cmnd->cmd_len - 16;
	if (len < 0)
		len = 0;
	len = ALIGN(len, 4);
467
	iu = kzalloc(sizeof(*iu) + len, gfp);
Matthew Wilcox's avatar
Matthew Wilcox committed
468 469 470 471
	if (!iu)
		goto free;

	iu->iu_id = IU_ID_COMMAND;
472
	iu->tag = cpu_to_be16(cmdinfo->uas_tag);
473
	iu->prio_attr = UAS_SIMPLE_TAG;
Matthew Wilcox's avatar
Matthew Wilcox committed
474 475 476 477 478
	iu->len = len;
	int_to_scsilun(sdev->lun, &iu->lun);
	memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);

	usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
479
							uas_cmd_cmplt, NULL);
Matthew Wilcox's avatar
Matthew Wilcox committed
480 481 482 483 484 485 486 487 488 489 490 491 492 493
	urb->transfer_flags |= URB_FREE_BUFFER;
 out:
	return urb;
 free:
	usb_free_urb(urb);
	return NULL;
}

/*
 * Why should I request the Status IU before sending the Command IU?  Spec
 * says to, but also says the device may receive them in any order.  Seems
 * daft to me.
 */

494
static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd, gfp_t gfp)
Matthew Wilcox's avatar
Matthew Wilcox committed
495
{
496
	struct uas_dev_info *devinfo = cmnd->device->hostdata;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
497
	struct urb *urb;
Hans de Goede's avatar
Hans de Goede committed
498
	int err;
Matthew Wilcox's avatar
Matthew Wilcox committed
499

500
	urb = uas_alloc_sense_urb(devinfo, gfp, cmnd);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
501
	if (!urb)
502
		return NULL;
503
	usb_anchor_urb(urb, &devinfo->sense_urbs);
Hans de Goede's avatar
Hans de Goede committed
504 505
	err = usb_submit_urb(urb, gfp);
	if (err) {
506
		usb_unanchor_urb(urb);
507
		uas_log_cmd_state(cmnd, "sense submit err", err);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
508
		usb_free_urb(urb);
509
		return NULL;
Matthew Wilcox's avatar
Matthew Wilcox committed
510
	}
511
	return urb;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
512 513 514 515 516 517
}

static int uas_submit_urbs(struct scsi_cmnd *cmnd,
			   struct uas_dev_info *devinfo, gfp_t gfp)
{
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
518
	struct urb *urb;
Hans de Goede's avatar
Hans de Goede committed
519
	int err;
Matthew Wilcox's avatar
Matthew Wilcox committed
520

521
	lockdep_assert_held(&devinfo->lock);
522
	if (cmdinfo->state & SUBMIT_STATUS_URB) {
523
		urb = uas_submit_sense_urb(cmnd, gfp);
524 525
		if (!urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
526
		cmdinfo->state &= ~SUBMIT_STATUS_URB;
Matthew Wilcox's avatar
Matthew Wilcox committed
527 528 529 530
	}

	if (cmdinfo->state & ALLOC_DATA_IN_URB) {
		cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
531
							cmnd, DMA_FROM_DEVICE);
Matthew Wilcox's avatar
Matthew Wilcox committed
532 533 534 535 536 537
		if (!cmdinfo->data_in_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_DATA_IN_URB;
	}

	if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
538
		usb_anchor_urb(cmdinfo->data_in_urb, &devinfo->data_urbs);
Hans de Goede's avatar
Hans de Goede committed
539 540
		err = usb_submit_urb(cmdinfo->data_in_urb, gfp);
		if (err) {
541
			usb_unanchor_urb(cmdinfo->data_in_urb);
542
			uas_log_cmd_state(cmnd, "data in submit err", err);
Matthew Wilcox's avatar
Matthew Wilcox committed
543 544 545
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
546
		cmdinfo->state |= DATA_IN_URB_INFLIGHT;
Matthew Wilcox's avatar
Matthew Wilcox committed
547 548 549 550
	}

	if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
		cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
551
							cmnd, DMA_TO_DEVICE);
Matthew Wilcox's avatar
Matthew Wilcox committed
552 553 554 555 556 557
		if (!cmdinfo->data_out_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
	}

	if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
558
		usb_anchor_urb(cmdinfo->data_out_urb, &devinfo->data_urbs);
Hans de Goede's avatar
Hans de Goede committed
559 560
		err = usb_submit_urb(cmdinfo->data_out_urb, gfp);
		if (err) {
561
			usb_unanchor_urb(cmdinfo->data_out_urb);
562
			uas_log_cmd_state(cmnd, "data out submit err", err);
Matthew Wilcox's avatar
Matthew Wilcox committed
563 564 565
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
566
		cmdinfo->state |= DATA_OUT_URB_INFLIGHT;
Matthew Wilcox's avatar
Matthew Wilcox committed
567 568 569
	}

	if (cmdinfo->state & ALLOC_CMD_URB) {
570
		cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd);
Matthew Wilcox's avatar
Matthew Wilcox committed
571 572 573 574 575 576
		if (!cmdinfo->cmd_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_CMD_URB;
	}

	if (cmdinfo->state & SUBMIT_CMD_URB) {
577
		usb_anchor_urb(cmdinfo->cmd_urb, &devinfo->cmd_urbs);
Hans de Goede's avatar
Hans de Goede committed
578 579
		err = usb_submit_urb(cmdinfo->cmd_urb, gfp);
		if (err) {
580
			usb_unanchor_urb(cmdinfo->cmd_urb);
581
			uas_log_cmd_state(cmnd, "cmd submit err", err);
Matthew Wilcox's avatar
Matthew Wilcox committed
582 583
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
584
		cmdinfo->cmd_urb = NULL;
Matthew Wilcox's avatar
Matthew Wilcox committed
585
		cmdinfo->state &= ~SUBMIT_CMD_URB;
586
		cmdinfo->state |= COMMAND_INFLIGHT;
Matthew Wilcox's avatar
Matthew Wilcox committed
587 588 589 590 591
	}

	return 0;
}

Jeff Garzik's avatar
Jeff Garzik committed
592
static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
Matthew Wilcox's avatar
Matthew Wilcox committed
593 594 595 596 597
					void (*done)(struct scsi_cmnd *))
{
	struct scsi_device *sdev = cmnd->device;
	struct uas_dev_info *devinfo = sdev->hostdata;
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
598
	unsigned long flags;
599
	int idx, err;
Matthew Wilcox's avatar
Matthew Wilcox committed
600 601 602

	BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));

603 604 605 606
	/* Re-check scsi_block_requests now that we've the host-lock */
	if (cmnd->device->host->host_self_blocked)
		return SCSI_MLQUEUE_DEVICE_BUSY;

607 608 609 610 611 612 613 614 615
	if ((devinfo->flags & US_FL_NO_ATA_1X) &&
			(cmnd->cmnd[0] == ATA_12 || cmnd->cmnd[0] == ATA_16)) {
		memcpy(cmnd->sense_buffer, usb_stor_sense_invalidCDB,
		       sizeof(usb_stor_sense_invalidCDB));
		cmnd->result = SAM_STAT_CHECK_CONDITION;
		cmnd->scsi_done(cmnd);
		return 0;
	}

616 617
	spin_lock_irqsave(&devinfo->lock, flags);

618 619 620
	if (devinfo->resetting) {
		cmnd->result = DID_ERROR << 16;
		cmnd->scsi_done(cmnd);
621
		spin_unlock_irqrestore(&devinfo->lock, flags);
622 623 624
		return 0;
	}

625 626 627 628 629 630
	/* Find a free uas-tag */
	for (idx = 0; idx < devinfo->qdepth; idx++) {
		if (!devinfo->cmnd[idx])
			break;
	}
	if (idx == devinfo->qdepth) {
Gerd Hoffmann's avatar
Gerd Hoffmann committed
631
		spin_unlock_irqrestore(&devinfo->lock, flags);
Matthew Wilcox's avatar
Matthew Wilcox committed
632
		return SCSI_MLQUEUE_DEVICE_BUSY;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
633
	}
Matthew Wilcox's avatar
Matthew Wilcox committed
634 635 636

	cmnd->scsi_done = done;

637
	memset(cmdinfo, 0, sizeof(*cmdinfo));
638
	cmdinfo->uas_tag = idx + 1; /* uas-tag == usb-stream-id, so 1 based */
639
	cmdinfo->state = SUBMIT_STATUS_URB | ALLOC_CMD_URB | SUBMIT_CMD_URB;
Matthew Wilcox's avatar
Matthew Wilcox committed
640 641 642 643 644 645 646 647 648 649 650 651 652

	switch (cmnd->sc_data_direction) {
	case DMA_FROM_DEVICE:
		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
		break;
	case DMA_BIDIRECTIONAL:
		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
	case DMA_TO_DEVICE:
		cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
	case DMA_NONE:
		break;
	}

653
	if (!devinfo->use_streams)
654
		cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
Matthew Wilcox's avatar
Matthew Wilcox committed
655 656 657 658

	err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
	if (err) {
		/* If we did nothing, give up now */
659
		if (cmdinfo->state & SUBMIT_STATUS_URB) {
Gerd Hoffmann's avatar
Gerd Hoffmann committed
660
			spin_unlock_irqrestore(&devinfo->lock, flags);
Matthew Wilcox's avatar
Matthew Wilcox committed
661 662
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
663
		uas_add_work(cmdinfo);
Matthew Wilcox's avatar
Matthew Wilcox committed
664 665
	}

666
	devinfo->cmnd[idx] = cmnd;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
667
	spin_unlock_irqrestore(&devinfo->lock, flags);
Matthew Wilcox's avatar
Matthew Wilcox committed
668 669 670
	return 0;
}

Jeff Garzik's avatar
Jeff Garzik committed
671 672
static DEF_SCSI_QCMD(uas_queuecommand)

673 674 675 676 677 678
/*
 * For now we do not support actually sending an abort to the device, so
 * this eh always fails. Still we must define it to make sure that we've
 * dropped all references to the cmnd in question once this function exits.
 */
static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
Matthew Wilcox's avatar
Matthew Wilcox committed
679
{
680 681 682 683
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
	struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
	struct urb *data_in_urb = NULL;
	struct urb *data_out_urb = NULL;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
684
	unsigned long flags;
Matthew Wilcox's avatar
Matthew Wilcox committed
685

Gerd Hoffmann's avatar
Gerd Hoffmann committed
686
	spin_lock_irqsave(&devinfo->lock, flags);
687

688
	uas_log_cmd_state(cmnd, __func__, 0);
689

690 691
	/* Ensure that try_complete does not call scsi_done */
	cmdinfo->state |= COMMAND_ABORTED;
692

693
	/* Drop all refs to this cmnd, kill data urbs to break their ref */
694
	devinfo->cmnd[cmdinfo->uas_tag - 1] = NULL;
695 696 697 698
	if (cmdinfo->state & DATA_IN_URB_INFLIGHT)
		data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
	if (cmdinfo->state & DATA_OUT_URB_INFLIGHT)
		data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
699

700
	uas_free_unsubmitted_urbs(cmnd);
701 702 703

	spin_unlock_irqrestore(&devinfo->lock, flags);

704 705 706
	if (data_in_urb) {
		usb_kill_urb(data_in_urb);
		usb_put_urb(data_in_urb);
707
	}
708 709 710
	if (data_out_urb) {
		usb_kill_urb(data_out_urb);
		usb_put_urb(data_out_urb);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
711
	}
Matthew Wilcox's avatar
Matthew Wilcox committed
712

713
	return FAILED;
Matthew Wilcox's avatar
Matthew Wilcox committed
714 715 716 717 718 719 720
}

static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
{
	struct scsi_device *sdev = cmnd->device;
	struct uas_dev_info *devinfo = sdev->hostdata;
	struct usb_device *udev = devinfo->udev;
721
	unsigned long flags;
722
	int err;
Matthew Wilcox's avatar
Matthew Wilcox committed
723

Hans de Goede's avatar
Hans de Goede committed
724 725 726 727 728 729 730
	err = usb_lock_device_for_reset(udev, devinfo->intf);
	if (err) {
		shost_printk(KERN_ERR, sdev->host,
			     "%s FAILED to get lock err %d\n", __func__, err);
		return FAILED;
	}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
731
	shost_printk(KERN_INFO, sdev->host, "%s start\n", __func__);
732 733

	spin_lock_irqsave(&devinfo->lock, flags);
734
	devinfo->resetting = 1;
735 736
	spin_unlock_irqrestore(&devinfo->lock, flags);

737
	usb_kill_anchored_urbs(&devinfo->cmd_urbs);
738 739
	usb_kill_anchored_urbs(&devinfo->sense_urbs);
	usb_kill_anchored_urbs(&devinfo->data_urbs);
740 741
	uas_zap_pending(devinfo, DID_RESET);

742
	err = usb_reset_device(udev);
743 744

	spin_lock_irqsave(&devinfo->lock, flags);
745
	devinfo->resetting = 0;
746
	spin_unlock_irqrestore(&devinfo->lock, flags);
Matthew Wilcox's avatar
Matthew Wilcox committed
747

Hans de Goede's avatar
Hans de Goede committed
748 749
	usb_unlock_device(udev);

750
	if (err) {
751 752
		shost_printk(KERN_INFO, sdev->host, "%s FAILED err %d\n",
			     __func__, err);
753 754
		return FAILED;
	}
Matthew Wilcox's avatar
Matthew Wilcox committed
755

756 757
	shost_printk(KERN_INFO, sdev->host, "%s success\n", __func__);
	return SUCCESS;
Matthew Wilcox's avatar
Matthew Wilcox committed
758 759
}

760 761 762 763 764 765 766 767 768 769 770
static int uas_target_alloc(struct scsi_target *starget)
{
	struct uas_dev_info *devinfo = (struct uas_dev_info *)
			dev_to_shost(starget->dev.parent)->hostdata;

	if (devinfo->flags & US_FL_NO_REPORT_LUNS)
		starget->no_report_luns = 1;

	return 0;
}

Matthew Wilcox's avatar
Matthew Wilcox committed
771 772
static int uas_slave_alloc(struct scsi_device *sdev)
{
773 774 775 776
	struct uas_dev_info *devinfo =
		(struct uas_dev_info *)sdev->host->hostdata;

	sdev->hostdata = devinfo;
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794

	/* USB has unusual DMA-alignment requirements: Although the
	 * starting address of each scatter-gather element doesn't matter,
	 * the length of each element except the last must be divisible
	 * by the Bulk maxpacket value.  There's currently no way to
	 * express this by block-layer constraints, so we'll cop out
	 * and simply require addresses to be aligned at 512-byte
	 * boundaries.  This is okay since most block I/O involves
	 * hardware sectors that are multiples of 512 bytes in length,
	 * and since host controllers up through USB 2.0 have maxpacket
	 * values no larger than 512.
	 *
	 * But it doesn't suffice for Wireless USB, where Bulk maxpacket
	 * values can be as large as 2048.  To make that work properly
	 * will require changes to the block layer.
	 */
	blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));

795 796 797 798 799
	if (devinfo->flags & US_FL_MAX_SECTORS_64)
		blk_queue_max_hw_sectors(sdev->request_queue, 64);
	else if (devinfo->flags & US_FL_MAX_SECTORS_240)
		blk_queue_max_hw_sectors(sdev->request_queue, 240);

Matthew Wilcox's avatar
Matthew Wilcox committed
800 801 802 803 804 805
	return 0;
}

static int uas_slave_configure(struct scsi_device *sdev)
{
	struct uas_dev_info *devinfo = sdev->hostdata;
806 807 808 809

	if (devinfo->flags & US_FL_NO_REPORT_OPCODES)
		sdev->no_report_opcodes = 1;

810 811 812 813
	/* A few buggy USB-ATA bridges don't understand FUA */
	if (devinfo->flags & US_FL_BROKEN_FUA)
		sdev->broken_fua = 1;

814
	scsi_change_queue_depth(sdev, devinfo->qdepth - 2);
Matthew Wilcox's avatar
Matthew Wilcox committed
815 816 817 818 819 820 821
	return 0;
}

static struct scsi_host_template uas_host_template = {
	.module = THIS_MODULE,
	.name = "uas",
	.queuecommand = uas_queuecommand,
822
	.target_alloc = uas_target_alloc,
Matthew Wilcox's avatar
Matthew Wilcox committed
823 824 825 826
	.slave_alloc = uas_slave_alloc,
	.slave_configure = uas_slave_configure,
	.eh_abort_handler = uas_eh_abort_handler,
	.eh_bus_reset_handler = uas_eh_bus_reset_handler,
827
	.can_queue = MAX_CMNDS,
Matthew Wilcox's avatar
Matthew Wilcox committed
828 829 830 831 832
	.this_id = -1,
	.sg_tablesize = SG_NONE,
	.skip_settle_delay = 1,
};

833 834 835 836 837 838
#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
		    vendorName, productName, useProtocol, useTransport, \
		    initFunction, flags) \
{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
	.driver_info = (flags) }

Matthew Wilcox's avatar
Matthew Wilcox committed
839
static struct usb_device_id uas_usb_ids[] = {
840
#	include "unusual_uas.h"
Matthew Wilcox's avatar
Matthew Wilcox committed
841 842 843 844 845 846
	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
	{ }
};
MODULE_DEVICE_TABLE(usb, uas_usb_ids);

847 848
#undef UNUSUAL_DEV

849 850 851
static int uas_switch_interface(struct usb_device *udev,
				struct usb_interface *intf)
{
852
	struct usb_host_interface *alt;
853 854

	alt = uas_find_uas_alt_setting(intf);
855 856
	if (!alt)
		return -ENODEV;
857

858 859
	return usb_set_interface(udev, alt->desc.bInterfaceNumber,
			alt->desc.bAlternateSetting);
860 861
}

862
static int uas_configure_endpoints(struct uas_dev_info *devinfo)
863 864 865 866 867 868
{
	struct usb_host_endpoint *eps[4] = { };
	struct usb_device *udev = devinfo->udev;
	int r;

	r = uas_find_endpoints(devinfo->intf->cur_altsetting, eps);
869 870 871 872 873 874 875 876 877 878 879
	if (r)
		return r;

	devinfo->cmd_pipe = usb_sndbulkpipe(udev,
					    usb_endpoint_num(&eps[0]->desc));
	devinfo->status_pipe = usb_rcvbulkpipe(udev,
					    usb_endpoint_num(&eps[1]->desc));
	devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
					    usb_endpoint_num(&eps[2]->desc));
	devinfo->data_out_pipe = usb_sndbulkpipe(udev,
					    usb_endpoint_num(&eps[3]->desc));
Matthew Wilcox's avatar
Matthew Wilcox committed
880

881
	if (udev->speed < USB_SPEED_SUPER) {
882
		devinfo->qdepth = 32;
Matthew Wilcox's avatar
Matthew Wilcox committed
883 884
		devinfo->use_streams = 0;
	} else {
885
		devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1,
886
						    3, MAX_CMNDS, GFP_NOIO);
887 888
		if (devinfo->qdepth < 0)
			return devinfo->qdepth;
Matthew Wilcox's avatar
Matthew Wilcox committed
889 890
		devinfo->use_streams = 1;
	}
891 892

	return 0;
Matthew Wilcox's avatar
Matthew Wilcox committed
893 894
}

895 896 897 898 899 900 901 902
static void uas_free_streams(struct uas_dev_info *devinfo)
{
	struct usb_device *udev = devinfo->udev;
	struct usb_host_endpoint *eps[3];

	eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
	eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
	eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
903
	usb_free_streams(devinfo->intf, eps, 3, GFP_NOIO);
904 905
}

Matthew Wilcox's avatar
Matthew Wilcox committed
906 907
static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
908 909
	int result = -ENOMEM;
	struct Scsi_Host *shost = NULL;
Matthew Wilcox's avatar
Matthew Wilcox committed
910 911
	struct uas_dev_info *devinfo;
	struct usb_device *udev = interface_to_usbdev(intf);
912
	unsigned long dev_flags;
Matthew Wilcox's avatar
Matthew Wilcox committed
913

914
	if (!uas_use_uas_driver(intf, id, &dev_flags))
915 916
		return -ENODEV;

917 918
	if (uas_switch_interface(udev, intf))
		return -ENODEV;
Matthew Wilcox's avatar
Matthew Wilcox committed
919

Hans de Goede's avatar
Hans de Goede committed
920 921
	shost = scsi_host_alloc(&uas_host_template,
				sizeof(struct uas_dev_info));
Matthew Wilcox's avatar
Matthew Wilcox committed
922
	if (!shost)
923
		goto set_alt0;
Matthew Wilcox's avatar
Matthew Wilcox committed
924 925 926

	shost->max_cmd_len = 16 + 252;
	shost->max_id = 1;
927 928
	shost->max_lun = 256;
	shost->max_channel = 0;
Matthew Wilcox's avatar
Matthew Wilcox committed
929 930
	shost->sg_tablesize = udev->bus->sg_tablesize;

Hans de Goede's avatar
Hans de Goede committed
931
	devinfo = (struct uas_dev_info *)shost->hostdata;
Matthew Wilcox's avatar
Matthew Wilcox committed
932 933
	devinfo->intf = intf;
	devinfo->udev = udev;
934
	devinfo->resetting = 0;
Hans de Goede's avatar
Hans de Goede committed
935
	devinfo->shutdown = 0;
936
	devinfo->flags = dev_flags;
937
	init_usb_anchor(&devinfo->cmd_urbs);
938 939
	init_usb_anchor(&devinfo->sense_urbs);
	init_usb_anchor(&devinfo->data_urbs);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
940
	spin_lock_init(&devinfo->lock);
941
	INIT_WORK(&devinfo->work, uas_do_work);
942 943 944 945

	result = uas_configure_endpoints(devinfo);
	if (result)
		goto set_alt0;
Matthew Wilcox's avatar
Matthew Wilcox committed
946

947 948 949 950 951 952
	/*
	 * 1 tag is reserved for untagged commands +
	 * 1 tag to avoid off by one errors in some bridge firmwares
	 */
	shost->can_queue = devinfo->qdepth - 2;

953
	usb_set_intfdata(intf, shost);
954 955
	result = scsi_add_host(shost, &intf->dev);
	if (result)
956
		goto free_streams;
957

Matthew Wilcox's avatar
Matthew Wilcox committed
958 959
	scsi_scan_host(shost);
	return result;
960

961
free_streams:
962
	uas_free_streams(devinfo);
963
	usb_set_intfdata(intf, NULL);
964 965
set_alt0:
	usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
Matthew Wilcox's avatar
Matthew Wilcox committed
966 967 968 969 970
	if (shost)
		scsi_host_put(shost);
	return result;
}

971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
static int uas_cmnd_list_empty(struct uas_dev_info *devinfo)
{
	unsigned long flags;
	int i, r = 1;

	spin_lock_irqsave(&devinfo->lock, flags);

	for (i = 0; i < devinfo->qdepth; i++) {
		if (devinfo->cmnd[i]) {
			r = 0; /* Not empty */
			break;
		}
	}

	spin_unlock_irqrestore(&devinfo->lock, flags);

	return r;
}

/*
 * Wait for any pending cmnds to complete, on usb-2 sense_urbs may temporarily
 * get empty while there still is more work to do due to sense-urbs completing
 * with a READ/WRITE_READY iu code, so keep waiting until the list gets empty.
 */
static int uas_wait_for_pending_cmnds(struct uas_dev_info *devinfo)
{
	unsigned long start_time;
	int r;

	start_time = jiffies;
	do {
		flush_work(&devinfo->work);

		r = usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000);
		if (r == 0)
			return -ETIME;

		r = usb_wait_anchor_empty_timeout(&devinfo->data_urbs, 500);
		if (r == 0)
			return -ETIME;

		if (time_after(jiffies, start_time + 5 * HZ))
			return -ETIME;
	} while (!uas_cmnd_list_empty(devinfo));

	return 0;
}

Matthew Wilcox's avatar
Matthew Wilcox committed
1019 1020
static int uas_pre_reset(struct usb_interface *intf)
{
1021
	struct Scsi_Host *shost = usb_get_intfdata(intf);
Hans de Goede's avatar
Hans de Goede committed
1022
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1023 1024
	unsigned long flags;

Hans de Goede's avatar
Hans de Goede committed
1025 1026 1027
	if (devinfo->shutdown)
		return 0;

1028 1029 1030 1031 1032
	/* Block new requests */
	spin_lock_irqsave(shost->host_lock, flags);
	scsi_block_requests(shost);
	spin_unlock_irqrestore(shost->host_lock, flags);

1033
	if (uas_wait_for_pending_cmnds(devinfo) != 0) {
1034
		shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1035
		scsi_unblock_requests(shost);
1036 1037 1038 1039 1040
		return 1;
	}

	uas_free_streams(devinfo);

Matthew Wilcox's avatar
Matthew Wilcox committed
1041 1042 1043 1044 1045
	return 0;
}

static int uas_post_reset(struct usb_interface *intf)
{
1046
	struct Scsi_Host *shost = usb_get_intfdata(intf);
Hans de Goede's avatar
Hans de Goede committed
1047
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1048
	unsigned long flags;
1049
	int err;
1050

Hans de Goede's avatar
Hans de Goede committed
1051 1052 1053
	if (devinfo->shutdown)
		return 0;

1054
	err = uas_configure_endpoints(devinfo);
1055
	if (err && err != -ENODEV)
1056
		shost_printk(KERN_ERR, shost,
1057 1058
			     "%s: alloc streams error %d after reset",
			     __func__, err);
1059

1060
	/* we must unblock the host in every case lest we deadlock */
1061 1062 1063 1064 1065 1066
	spin_lock_irqsave(shost->host_lock, flags);
	scsi_report_bus_reset(shost, 0);
	spin_unlock_irqrestore(shost->host_lock, flags);

	scsi_unblock_requests(shost);

1067
	return err ? 1 : 0;
Matthew Wilcox's avatar
Matthew Wilcox committed
1068 1069
}

1070 1071 1072
static int uas_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct Scsi_Host *shost = usb_get_intfdata(intf);
Hans de Goede's avatar
Hans de Goede committed
1073
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1074

1075
	if (uas_wait_for_pending_cmnds(devinfo) != 0) {
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
		shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
		return -ETIME;
	}

	return 0;
}

static int uas_resume(struct usb_interface *intf)
{
	return 0;
}

static int uas_reset_resume(struct usb_interface *intf)
{
	struct Scsi_Host *shost = usb_get_intfdata(intf);
Hans de Goede's avatar
Hans de Goede committed
1091
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1092
	unsigned long flags;
1093
	int err;
1094

1095 1096
	err = uas_configure_endpoints(devinfo);
	if (err) {
1097
		shost_printk(KERN_ERR, shost,
1098 1099
			     "%s: alloc streams error %d after reset",
			     __func__, err);
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
		return -EIO;
	}

	spin_lock_irqsave(shost->host_lock, flags);
	scsi_report_bus_reset(shost, 0);
	spin_unlock_irqrestore(shost->host_lock, flags);

	return 0;
}

Matthew Wilcox's avatar
Matthew Wilcox committed
1110 1111 1112
static void uas_disconnect(struct usb_interface *intf)
{
	struct Scsi_Host *shost = usb_get_intfdata(intf);
Hans de Goede's avatar
Hans de Goede committed
1113
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1114
	unsigned long flags;
Matthew Wilcox's avatar
Matthew Wilcox committed
1115

1116
	spin_lock_irqsave(&devinfo->lock, flags);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
1117
	devinfo->resetting = 1;
1118 1119
	spin_unlock_irqrestore(&devinfo->lock, flags);

1120
	cancel_work_sync(&devinfo->work);
1121
	usb_kill_anchored_urbs(&devinfo->cmd_urbs);
1122 1123
	usb_kill_anchored_urbs(&devinfo->sense_urbs);
	usb_kill_anchored_urbs(&devinfo->data_urbs);
1124 1125
	uas_zap_pending(devinfo, DID_NO_CONNECT);

Gerd Hoffmann's avatar
Gerd Hoffmann committed
1126
	scsi_remove_host(shost);
1127
	uas_free_streams(devinfo);
Hans de Goede's avatar
Hans de Goede committed
1128
	scsi_host_put(shost);
Matthew Wilcox's avatar
Matthew Wilcox committed
1129 1130
}

Hans de Goede's avatar
Hans de Goede committed
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
/*
 * Put the device back in usb-storage mode on shutdown, as some BIOS-es
 * hang on reboot when the device is still in uas mode. Note the reset is
 * necessary as some devices won't revert to usb-storage mode without it.
 */
static void uas_shutdown(struct device *dev)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *udev = interface_to_usbdev(intf);
	struct Scsi_Host *shost = usb_get_intfdata(intf);
Hans de Goede's avatar
Hans de Goede committed
1141
	struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
Hans de Goede's avatar
Hans de Goede committed
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151

	if (system_state != SYSTEM_RESTART)
		return;

	devinfo->shutdown = 1;
	uas_free_streams(devinfo);
	usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
	usb_reset_device(udev);
}

Matthew Wilcox's avatar
Matthew Wilcox committed
1152 1153 1154 1155 1156 1157
static struct usb_driver uas_driver = {
	.name = "uas",
	.probe = uas_probe,
	.disconnect = uas_disconnect,
	.pre_reset = uas_pre_reset,
	.post_reset = uas_post_reset,
1158 1159 1160
	.suspend = uas_suspend,
	.resume = uas_resume,
	.reset_resume = uas_reset_resume,
Hans de Goede's avatar
Hans de Goede committed
1161
	.drvwrap.driver.shutdown = uas_shutdown,
Matthew Wilcox's avatar
Matthew Wilcox committed
1162 1163 1164
	.id_table = uas_usb_ids,
};

1165
module_usb_driver(uas_driver);
Matthew Wilcox's avatar
Matthew Wilcox committed
1166 1167

MODULE_LICENSE("GPL");
1168 1169
MODULE_AUTHOR(
	"Hans de Goede <hdegoede@redhat.com>, Matthew Wilcox and Sarah Sharp");