1/*
  2 * USB Attached SCSI
  3 * Note that this is not the same as the USB Mass Storage driver
  4 *
 
  5 * Copyright Matthew Wilcox for Intel Corp, 2010
  6 * Copyright Sarah Sharp for Intel Corp, 2010
  7 *
  8 * Distributed under the terms of the GNU GPL, version two.
  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/hcd.h>
 17#include <linux/usb/storage.h>
 18#include <linux/usb/uas.h>
 19
 20#include <scsi/scsi.h>
 
 21#include <scsi/scsi_dbg.h>
 22#include <scsi/scsi_cmnd.h>
 23#include <scsi/scsi_device.h>
 24#include <scsi/scsi_host.h>
 25#include <scsi/scsi_tcq.h>
 26
 
 
 27/*
 28 * The r00-r01c specs define this version of the SENSE IU data structure.
 29 * It's still in use by several different firmware releases.
 30 */
 31struct sense_iu_old {
 32	__u8 iu_id;
 33	__u8 rsvd1;
 34	__be16 tag;
 35	__be16 len;
 36	__u8 status;
 37	__u8 service_response;
 38	__u8 sense[SCSI_SENSE_BUFFERSIZE];
 39};
 40
 41struct uas_dev_info {
 42	struct usb_interface *intf;
 43	struct usb_device *udev;
 44	int qdepth;
 
 
 
 
 45	unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
 46	unsigned use_streams:1;
 47	unsigned uas_sense_old:1;
 
 
 48	struct scsi_cmnd *cmnd;
 49	struct urb *status_urb; /* used only if stream support is available */
 
 
 
 50};
 51
 52enum {
 53	ALLOC_STATUS_URB	= (1 << 0),
 54	SUBMIT_STATUS_URB	= (1 << 1),
 55	ALLOC_DATA_IN_URB	= (1 << 2),
 56	SUBMIT_DATA_IN_URB	= (1 << 3),
 57	ALLOC_DATA_OUT_URB	= (1 << 4),
 58	SUBMIT_DATA_OUT_URB	= (1 << 5),
 59	ALLOC_CMD_URB		= (1 << 6),
 60	SUBMIT_CMD_URB		= (1 << 7),
 
 
 
 
 
 
 
 61};
 62
 63/* Overrides scsi_pointer */
 64struct uas_cmd_info {
 65	unsigned int state;
 66	unsigned int stream;
 67	struct urb *cmd_urb;
 68	/* status_urb is used only if stream support isn't available */
 69	struct urb *status_urb;
 70	struct urb *data_in_urb;
 71	struct urb *data_out_urb;
 72	struct list_head list;
 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, gfp_t gfp);
 78static void uas_do_work(struct work_struct *work);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 79
 80static DECLARE_WORK(uas_work, uas_do_work);
 81static DEFINE_SPINLOCK(uas_work_lock);
 82static LIST_HEAD(uas_work_list);
 
 
 
 
 
 83
 84static void uas_do_work(struct work_struct *work)
 85{
 
 
 86	struct uas_cmd_info *cmdinfo;
 87	struct uas_cmd_info *temp;
 88	struct list_head list;
 89	int err;
 90
 91	spin_lock_irq(&uas_work_lock);
 92	list_replace_init(&uas_work_list, &list);
 93	spin_unlock_irq(&uas_work_lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 94
 95	list_for_each_entry_safe(cmdinfo, temp, &list, list) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 96		struct scsi_pointer *scp = (void *)cmdinfo;
 97		struct scsi_cmnd *cmnd = container_of(scp,
 98							struct scsi_cmnd, SCp);
 99		err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO);
100		if (err) {
101			list_del(&cmdinfo->list);
102			spin_lock_irq(&uas_work_lock);
103			list_add_tail(&cmdinfo->list, &uas_work_list);
104			spin_unlock_irq(&uas_work_lock);
105			schedule_work(&uas_work);
106		}
107	}
 
 
108}
109
110static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
111{
112	struct sense_iu *sense_iu = urb->transfer_buffer;
113	struct scsi_device *sdev = cmnd->device;
114
115	if (urb->actual_length > 16) {
116		unsigned len = be16_to_cpup(&sense_iu->len);
117		if (len + 16 != urb->actual_length) {
118			int newlen = min(len + 16, urb->actual_length) - 16;
119			if (newlen < 0)
120				newlen = 0;
121			sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
122				"disagrees with IU sense data length %d, "
123				"using %d bytes of sense data\n", __func__,
124					urb->actual_length, len, newlen);
125			len = newlen;
126		}
127		memcpy(cmnd->sense_buffer, sense_iu->sense, len);
128	}
129
130	cmnd->result = sense_iu->status;
131	cmnd->scsi_done(cmnd);
132}
133
134static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
135{
136	struct sense_iu_old *sense_iu = urb->transfer_buffer;
137	struct scsi_device *sdev = cmnd->device;
138
139	if (urb->actual_length > 8) {
140		unsigned len = be16_to_cpup(&sense_iu->len) - 2;
141		if (len + 8 != urb->actual_length) {
142			int newlen = min(len + 8, urb->actual_length) - 8;
143			if (newlen < 0)
144				newlen = 0;
145			sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
146				"disagrees with IU sense data length %d, "
147				"using %d bytes of sense data\n", __func__,
148					urb->actual_length, len, newlen);
149			len = newlen;
150		}
151		memcpy(cmnd->sense_buffer, sense_iu->sense, len);
152	}
153
154	cmnd->result = sense_iu->status;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
155	cmnd->scsi_done(cmnd);
 
156}
157
158static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
159							unsigned direction)
160{
161	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
162	int err;
163
164	cmdinfo->state = direction;
165	err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
166	if (err) {
167		spin_lock(&uas_work_lock);
168		list_add_tail(&cmdinfo->list, &uas_work_list);
169		spin_unlock(&uas_work_lock);
170		schedule_work(&uas_work);
171	}
172}
173
174static void uas_stat_cmplt(struct urb *urb)
175{
176	struct iu *iu = urb->transfer_buffer;
177	struct Scsi_Host *shost = urb->context;
178	struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
179	struct scsi_cmnd *cmnd;
 
 
180	u16 tag;
181	int ret;
182
183	if (urb->status) {
184		dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status);
185		if (devinfo->use_streams)
186			usb_free_urb(urb);
 
 
 
 
 
 
 
 
 
 
187		return;
188	}
189
 
190	tag = be16_to_cpup(&iu->tag) - 1;
191	if (tag == 0)
192		cmnd = devinfo->cmnd;
193	else
194		cmnd = scsi_host_find_tag(shost, tag - 1);
 
195	if (!cmnd) {
196		if (devinfo->use_streams) {
197			usb_free_urb(urb);
198			return;
199		}
200		ret = usb_submit_urb(urb, GFP_ATOMIC);
201		if (ret)
202			dev_err(&urb->dev->dev, "failed submit status urb\n");
 
 
203		return;
204	}
205
 
206	switch (iu->iu_id) {
207	case IU_ID_STATUS:
208		if (devinfo->cmnd == cmnd)
209			devinfo->cmnd = NULL;
210
211		if (urb->actual_length < 16)
212			devinfo->uas_sense_old = 1;
213		if (devinfo->uas_sense_old)
214			uas_sense_old(urb, cmnd);
215		else
216			uas_sense(urb, cmnd);
 
 
 
 
 
 
217		break;
218	case IU_ID_READ_READY:
 
 
 
 
 
219		uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
220		break;
221	case IU_ID_WRITE_READY:
 
 
 
 
 
222		uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
223		break;
224	default:
225		scmd_printk(KERN_ERR, cmnd,
226			"Bogus IU (%d) received on status pipe\n", iu->iu_id);
227	}
 
 
 
228
229	if (devinfo->use_streams) {
230		usb_free_urb(urb);
231		return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
232	}
233
234	ret = usb_submit_urb(urb, GFP_ATOMIC);
235	if (ret)
236		dev_err(&urb->dev->dev, "failed submit status urb\n");
237}
238
239static void uas_data_cmplt(struct urb *urb)
240{
241	struct scsi_data_buffer *sdb = urb->context;
242	sdb->resid = sdb->length - urb->actual_length;
 
 
 
 
243	usb_free_urb(urb);
244}
245
246static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
247				unsigned int pipe, u16 stream_id,
248				struct scsi_data_buffer *sdb,
249				enum dma_data_direction dir)
250{
251	struct usb_device *udev = devinfo->udev;
252	struct urb *urb = usb_alloc_urb(0, gfp);
 
 
253
254	if (!urb)
255		goto out;
256	usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt,
257									sdb);
258	if (devinfo->use_streams)
259		urb->stream_id = stream_id;
260	urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
261	urb->sg = sdb->table.sgl;
262 out:
263	return urb;
264}
265
266static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
267		struct Scsi_Host *shost, u16 stream_id)
268{
269	struct usb_device *udev = devinfo->udev;
270	struct urb *urb = usb_alloc_urb(0, gfp);
271	struct sense_iu *iu;
272
273	if (!urb)
274		goto out;
275
276	iu = kzalloc(sizeof(*iu), gfp);
277	if (!iu)
278		goto free;
279
280	usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
281						uas_stat_cmplt, shost);
282	urb->stream_id = stream_id;
283	urb->transfer_flags |= URB_FREE_BUFFER;
284 out:
285	return urb;
286 free:
287	usb_free_urb(urb);
288	return NULL;
289}
290
291static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
292					struct scsi_cmnd *cmnd, u16 stream_id)
293{
294	struct usb_device *udev = devinfo->udev;
295	struct scsi_device *sdev = cmnd->device;
296	struct urb *urb = usb_alloc_urb(0, gfp);
297	struct command_iu *iu;
298	int len;
299
300	if (!urb)
301		goto out;
302
303	len = cmnd->cmd_len - 16;
304	if (len < 0)
305		len = 0;
306	len = ALIGN(len, 4);
307	iu = kzalloc(sizeof(*iu) + len, gfp);
308	if (!iu)
309		goto free;
310
311	iu->iu_id = IU_ID_COMMAND;
312	if (blk_rq_tagged(cmnd->request))
313		iu->tag = cpu_to_be16(cmnd->request->tag + 2);
314	else
315		iu->tag = cpu_to_be16(1);
316	iu->prio_attr = UAS_SIMPLE_TAG;
317	iu->len = len;
318	int_to_scsilun(sdev->lun, &iu->lun);
319	memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
320
321	usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
322							usb_free_urb, NULL);
323	urb->transfer_flags |= URB_FREE_BUFFER;
324 out:
325	return urb;
326 free:
327	usb_free_urb(urb);
328	return NULL;
329}
330
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
331/*
332 * Why should I request the Status IU before sending the Command IU?  Spec
333 * says to, but also says the device may receive them in any order.  Seems
334 * daft to me.
335 */
336
337static int uas_submit_urbs(struct scsi_cmnd *cmnd,
338					struct uas_dev_info *devinfo, gfp_t gfp)
339{
340	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
 
 
 
341
342	if (cmdinfo->state & ALLOC_STATUS_URB) {
343		cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp,
344				cmnd->device->host, cmdinfo->stream);
345		if (!cmdinfo->status_urb)
346			return SCSI_MLQUEUE_DEVICE_BUSY;
347		cmdinfo->state &= ~ALLOC_STATUS_URB;
 
 
 
 
 
 
 
348	}
 
 
 
 
 
 
 
 
 
349
 
350	if (cmdinfo->state & SUBMIT_STATUS_URB) {
351		if (usb_submit_urb(cmdinfo->status_urb, gfp)) {
352			scmd_printk(KERN_INFO, cmnd,
353					"sense urb submission failure\n");
354			return SCSI_MLQUEUE_DEVICE_BUSY;
355		}
356		cmdinfo->state &= ~SUBMIT_STATUS_URB;
357	}
358
359	if (cmdinfo->state & ALLOC_DATA_IN_URB) {
360		cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
361					devinfo->data_in_pipe, cmdinfo->stream,
362					scsi_in(cmnd), DMA_FROM_DEVICE);
363		if (!cmdinfo->data_in_urb)
364			return SCSI_MLQUEUE_DEVICE_BUSY;
365		cmdinfo->state &= ~ALLOC_DATA_IN_URB;
366	}
367
368	if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
369		if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
 
 
 
 
370			scmd_printk(KERN_INFO, cmnd,
371					"data in urb submission failure\n");
 
372			return SCSI_MLQUEUE_DEVICE_BUSY;
373		}
374		cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
 
375	}
376
377	if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
378		cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
379					devinfo->data_out_pipe, cmdinfo->stream,
380					scsi_out(cmnd), DMA_TO_DEVICE);
381		if (!cmdinfo->data_out_urb)
382			return SCSI_MLQUEUE_DEVICE_BUSY;
383		cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
384	}
385
386	if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
387		if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
 
 
 
 
388			scmd_printk(KERN_INFO, cmnd,
389					"data out urb submission failure\n");
 
390			return SCSI_MLQUEUE_DEVICE_BUSY;
391		}
392		cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
 
393	}
394
395	if (cmdinfo->state & ALLOC_CMD_URB) {
396		cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
397							cmdinfo->stream);
398		if (!cmdinfo->cmd_urb)
399			return SCSI_MLQUEUE_DEVICE_BUSY;
400		cmdinfo->state &= ~ALLOC_CMD_URB;
401	}
402
403	if (cmdinfo->state & SUBMIT_CMD_URB) {
404		if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
 
 
 
 
405			scmd_printk(KERN_INFO, cmnd,
406					"cmd urb submission failure\n");
407			return SCSI_MLQUEUE_DEVICE_BUSY;
408		}
 
409		cmdinfo->state &= ~SUBMIT_CMD_URB;
 
410	}
411
412	return 0;
413}
414
415static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
416					void (*done)(struct scsi_cmnd *))
417{
418	struct scsi_device *sdev = cmnd->device;
419	struct uas_dev_info *devinfo = sdev->hostdata;
420	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
 
421	int err;
422
423	BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
424
425	if (devinfo->cmnd)
 
 
 
 
 
 
 
 
 
 
426		return SCSI_MLQUEUE_DEVICE_BUSY;
 
 
 
427
428	if (blk_rq_tagged(cmnd->request)) {
429		cmdinfo->stream = cmnd->request->tag + 2;
430	} else {
431		devinfo->cmnd = cmnd;
432		cmdinfo->stream = 1;
433	}
434
435	cmnd->scsi_done = done;
436
437	cmdinfo->state = ALLOC_STATUS_URB | SUBMIT_STATUS_URB |
438			ALLOC_CMD_URB | SUBMIT_CMD_URB;
439
440	switch (cmnd->sc_data_direction) {
441	case DMA_FROM_DEVICE:
442		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
443		break;
444	case DMA_BIDIRECTIONAL:
445		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
446	case DMA_TO_DEVICE:
447		cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
448	case DMA_NONE:
449		break;
450	}
451
452	if (!devinfo->use_streams) {
453		cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB |
454				ALLOC_STATUS_URB | SUBMIT_STATUS_URB);
455		cmdinfo->stream = 0;
456	}
457
458	err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
459	if (err) {
460		/* If we did nothing, give up now */
461		if (cmdinfo->state & SUBMIT_STATUS_URB) {
462			usb_free_urb(cmdinfo->status_urb);
463			return SCSI_MLQUEUE_DEVICE_BUSY;
464		}
465		spin_lock(&uas_work_lock);
466		list_add_tail(&cmdinfo->list, &uas_work_list);
467		spin_unlock(&uas_work_lock);
468		schedule_work(&uas_work);
469	}
470
 
 
471	return 0;
472}
473
474static DEF_SCSI_QCMD(uas_queuecommand)
475
476static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
 
477{
478	struct scsi_device *sdev = cmnd->device;
479	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
480							cmnd->request->tag);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
481
482/* XXX: Send ABORT TASK Task Management command */
483	return FAILED;
484}
485
486static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
487{
488	struct scsi_device *sdev = cmnd->device;
489	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
490							cmnd->request->tag);
 
 
 
491
492/* XXX: Send LOGICAL UNIT RESET Task Management command */
493	return FAILED;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
494}
495
496static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd)
497{
498	struct scsi_device *sdev = cmnd->device;
499	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
500							cmnd->request->tag);
501
502/* XXX: Can we reset just the one USB interface?
503 * Would calling usb_set_interface() have the right effect?
504 */
505	return FAILED;
506}
507
508static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
509{
510	struct scsi_device *sdev = cmnd->device;
511	struct uas_dev_info *devinfo = sdev->hostdata;
512	struct usb_device *udev = devinfo->udev;
 
513
514	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
515							cmnd->request->tag);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
516
517	if (usb_reset_device(udev))
518		return SUCCESS;
519
520	return FAILED;
 
 
 
 
 
 
521}
522
523static int uas_slave_alloc(struct scsi_device *sdev)
524{
525	sdev->hostdata = (void *)sdev->host->hostdata[0];
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
526	return 0;
527}
528
529static int uas_slave_configure(struct scsi_device *sdev)
530{
531	struct uas_dev_info *devinfo = sdev->hostdata;
532	scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
533	scsi_activate_tcq(sdev, devinfo->qdepth - 2);
534	return 0;
535}
536
537static struct scsi_host_template uas_host_template = {
538	.module = THIS_MODULE,
539	.name = "uas",
540	.queuecommand = uas_queuecommand,
541	.slave_alloc = uas_slave_alloc,
542	.slave_configure = uas_slave_configure,
543	.eh_abort_handler = uas_eh_abort_handler,
544	.eh_device_reset_handler = uas_eh_device_reset_handler,
545	.eh_target_reset_handler = uas_eh_target_reset_handler,
546	.eh_bus_reset_handler = uas_eh_bus_reset_handler,
547	.can_queue = 65536,	/* Is there a limit on the _host_ ? */
548	.this_id = -1,
549	.sg_tablesize = SG_NONE,
550	.cmd_per_lun = 1,	/* until we override it */
551	.skip_settle_delay = 1,
552	.ordered_tag = 1,
553};
554
 
 
 
 
 
 
555static struct usb_device_id uas_usb_ids[] = {
 
556	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
557	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
558	/* 0xaa is a prototype device I happen to have access to */
559	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
560	{ }
561};
562MODULE_DEVICE_TABLE(usb, uas_usb_ids);
563
564static int uas_is_interface(struct usb_host_interface *intf)
565{
566	return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE &&
567		intf->desc.bInterfaceSubClass == USB_SC_SCSI &&
568		intf->desc.bInterfaceProtocol == USB_PR_UAS);
569}
570
571static int uas_isnt_supported(struct usb_device *udev)
572{
573	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
574
575	dev_warn(&udev->dev, "The driver for the USB controller %s does not "
576			"support scatter-gather which is\n",
577			hcd->driver->description);
578	dev_warn(&udev->dev, "required by the UAS driver. Please try an"
579			"alternative USB controller if you wish to use UAS.\n");
580	return -ENODEV;
581}
582
583static int uas_switch_interface(struct usb_device *udev,
584						struct usb_interface *intf)
585{
586	int i;
587	int sg_supported = udev->bus->sg_tablesize != 0;
588
589	for (i = 0; i < intf->num_altsetting; i++) {
590		struct usb_host_interface *alt = &intf->altsetting[i];
591
592		if (uas_is_interface(alt)) {
593			if (!sg_supported)
594				return uas_isnt_supported(udev);
595			return usb_set_interface(udev,
596						alt->desc.bInterfaceNumber,
597						alt->desc.bAlternateSetting);
598		}
599	}
600
601	return -ENODEV;
 
602}
603
604static void uas_configure_endpoints(struct uas_dev_info *devinfo)
605{
606	struct usb_host_endpoint *eps[4] = { };
607	struct usb_interface *intf = devinfo->intf;
608	struct usb_device *udev = devinfo->udev;
609	struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
610	unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;
611
612	devinfo->uas_sense_old = 0;
613	devinfo->cmnd = NULL;
614
615	for (i = 0; i < n_endpoints; i++) {
616		unsigned char *extra = endpoint[i].extra;
617		int len = endpoint[i].extralen;
618		while (len > 1) {
619			if (extra[1] == USB_DT_PIPE_USAGE) {
620				unsigned pipe_id = extra[2];
621				if (pipe_id > 0 && pipe_id < 5)
622					eps[pipe_id - 1] = &endpoint[i];
623				break;
624			}
625			len -= extra[0];
626			extra += extra[0];
627		}
628	}
629
630	/*
631	 * Assume that if we didn't find a control pipe descriptor, we're
632	 * using a device with old firmware that happens to be set up like
633	 * this.
634	 */
635	if (!eps[0]) {
636		devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
637		devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
638		devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
639		devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
640
641		eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
642		eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
643		eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
644	} else {
645		devinfo->cmd_pipe = usb_sndbulkpipe(udev,
646						eps[0]->desc.bEndpointAddress);
647		devinfo->status_pipe = usb_rcvbulkpipe(udev,
648						eps[1]->desc.bEndpointAddress);
649		devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
650						eps[2]->desc.bEndpointAddress);
651		devinfo->data_out_pipe = usb_sndbulkpipe(udev,
652						eps[3]->desc.bEndpointAddress);
653	}
654
655	devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
656								GFP_KERNEL);
657	if (devinfo->qdepth < 0) {
658		devinfo->qdepth = 256;
659		devinfo->use_streams = 0;
660	} else {
 
 
 
 
661		devinfo->use_streams = 1;
662	}
663}
664
665static int uas_alloc_status_urb(struct uas_dev_info *devinfo,
666		struct Scsi_Host *shost)
667{
668	if (devinfo->use_streams) {
669		devinfo->status_urb = NULL;
670		return 0;
671	}
672
673	devinfo->status_urb = uas_alloc_sense_urb(devinfo, GFP_KERNEL,
674			shost, 0);
675	if (!devinfo->status_urb)
676		goto err_s_urb;
677
678	if (usb_submit_urb(devinfo->status_urb, GFP_KERNEL))
679		goto err_submit_urb;
680
681	return 0;
682err_submit_urb:
683	usb_free_urb(devinfo->status_urb);
684err_s_urb:
685	return -ENOMEM;
686}
687
688static void uas_free_streams(struct uas_dev_info *devinfo)
689{
690	struct usb_device *udev = devinfo->udev;
691	struct usb_host_endpoint *eps[3];
692
693	eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
694	eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
695	eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
696	usb_free_streams(devinfo->intf, eps, 3, GFP_KERNEL);
697}
698
699/*
700 * XXX: What I'd like to do here is register a SCSI host for each USB host in
701 * the system.  Follow usb-storage's design of registering a SCSI host for
702 * each USB device for the moment.  Can implement this by walking up the
703 * USB hierarchy until we find a USB host.
704 */
705static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
706{
707	int result;
708	struct Scsi_Host *shost;
709	struct uas_dev_info *devinfo;
710	struct usb_device *udev = interface_to_usbdev(intf);
711
712	if (uas_switch_interface(udev, intf))
713		return -ENODEV;
714
715	devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
716	if (!devinfo)
717		return -ENOMEM;
718
719	result = -ENOMEM;
720	shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
721	if (!shost)
722		goto free;
723
724	shost->max_cmd_len = 16 + 252;
725	shost->max_id = 1;
 
 
726	shost->sg_tablesize = udev->bus->sg_tablesize;
727
 
728	devinfo->intf = intf;
729	devinfo->udev = udev;
730	uas_configure_endpoints(devinfo);
 
 
 
 
 
 
 
 
 
731
732	result = scsi_init_shared_tag_map(shost, devinfo->qdepth - 2);
733	if (result)
734		goto free;
735
736	result = scsi_add_host(shost, &intf->dev);
737	if (result)
738		goto deconfig_eps;
739
740	shost->hostdata[0] = (unsigned long)devinfo;
741
742	result = uas_alloc_status_urb(devinfo, shost);
743	if (result)
744		goto err_alloc_status;
745
746	scsi_scan_host(shost);
747	usb_set_intfdata(intf, shost);
748	return result;
749
750err_alloc_status:
751	scsi_remove_host(shost);
752	shost = NULL;
753deconfig_eps:
754	uas_free_streams(devinfo);
755 free:
756	kfree(devinfo);
 
757	if (shost)
758		scsi_host_put(shost);
759	return result;
760}
761
762static int uas_pre_reset(struct usb_interface *intf)
763{
764/* XXX: Need to return 1 if it's not our device in error handling */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
765	return 0;
766}
767
768static int uas_post_reset(struct usb_interface *intf)
769{
770/* XXX: Need to return 1 if it's not our device in error handling */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
771	return 0;
772}
773
774static void uas_disconnect(struct usb_interface *intf)
775{
776	struct Scsi_Host *shost = usb_get_intfdata(intf);
777	struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
778
 
 
 
 
 
 
 
779	scsi_remove_host(shost);
780	usb_kill_urb(devinfo->status_urb);
781	usb_free_urb(devinfo->status_urb);
782	uas_free_streams(devinfo);
783	kfree(devinfo);
784}
785
786/*
787 * XXX: Should this plug into libusual so we can auto-upgrade devices from
788 * Bulk-Only to UAS?
 
789 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
790static struct usb_driver uas_driver = {
791	.name = "uas",
792	.probe = uas_probe,
793	.disconnect = uas_disconnect,
794	.pre_reset = uas_pre_reset,
795	.post_reset = uas_post_reset,
 
 
 
 
796	.id_table = uas_usb_ids,
797};
798
799module_usb_driver(uas_driver);
800
801MODULE_LICENSE("GPL");
802MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");