File:  [DragonFly] / src / sys / dev / usbmisc / umass / umass.c
Revision 1.9: download - view: text, annotated - select for diffs
Mon Mar 15 01:10:45 2004 UTC (10 years, 4 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
The cam_sim structure was being deallocated unconditionally by device
driver detach routines.  The problem with this is that part of the CAM
bus structure may still be active (for example, with pending timeout()'s),
and even though the bus, target, and device is freed, since the sim IS
freed any accesses through the sim will hit 0xdeadc0de.  This case most often
occurs with USB UMASS devices.

The CAM_XPT and CAM_SIM layer has been revamped.  CAM_DEV_UNCONFIGURED is now
accounted for in the device->refcount, and the cam_sim structure is now
ref-counted as well.  Additionally, the cam_simq* code which handles the
device queues has been revamped to refcount as well, so shared device queues
(raid and multi-channel devices) are not free()'d before all references have
gone away.

scsi_low free'd its cam_sim twice.  Fixed.

USB was improperly using M_NOWAIT.  All M_NOWAIT instances have been renamed
to M_INTWAIT.

    1: /*-
    2:  * Copyright (c) 1999 MAEKAWA Masahide <bishop@rr.iij4u.or.jp>,
    3:  *		      Nick Hibma <n_hibma@freebsd.org>
    4:  * All rights reserved.
    5:  *
    6:  * Redistribution and use in source and binary forms, with or without
    7:  * modification, are permitted provided that the following conditions
    8:  * are met:
    9:  * 1. Redistributions of source code must retain the above copyright
   10:  *    notice, this list of conditions and the following disclaimer.
   11:  * 2. Redistributions in binary form must reproduce the above copyright
   12:  *    notice, this list of conditions and the following disclaimer in the
   13:  *    documentation and/or other materials provided with the distribution.
   14:  *
   15:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25:  * SUCH DAMAGE.
   26:  *
   27:  * $NetBSD: umass.c,v 1.28 2000/04/02 23:46:53 augustss Exp $
   28:  * $FreeBSD: src/sys/dev/usb/umass.c,v 1.96 2003/12/19 12:19:11 sanpei Exp $
   29:  * $DragonFly: src/sys/dev/usbmisc/umass/umass.c,v 1.9 2004/03/15 01:10:45 dillon Exp $
   30:  */
   31: 
   32: /*
   33:  * Universal Serial Bus Mass Storage Class specs:
   34:  * http://www.usb.org/developers/data/devclass/usbmassover_11.pdf
   35:  * http://www.usb.org/developers/data/devclass/usbmassbulk_10.pdf
   36:  * http://www.usb.org/developers/data/devclass/usbmass-cbi10.pdf
   37:  * http://www.usb.org/developers/data/devclass/usbmass-ufi10.pdf
   38:  */
   39: 
   40: /*
   41:  * Ported to NetBSD by Lennart Augustsson <augustss@netbsd.org>.
   42:  * Parts of the code written my Jason R. Thorpe <thorpej@shagadelic.org>.
   43:  */
   44: 
   45: /*
   46:  * The driver handles 3 Wire Protocols
   47:  * - Command/Bulk/Interrupt (CBI)
   48:  * - Command/Bulk/Interrupt with Command Completion Interrupt (CBI with CCI)
   49:  * - Mass Storage Bulk-Only (BBB)
   50:  *   (BBB refers Bulk/Bulk/Bulk for Command/Data/Status phases)
   51:  *
   52:  * Over these wire protocols it handles the following command protocols
   53:  * - SCSI
   54:  * - UFI (floppy command set)
   55:  * - 8070i (ATAPI)
   56:  *
   57:  * UFI and 8070i (ATAPI) are transformed versions of the SCSI command set. The
   58:  * sc->transform method is used to convert the commands into the appropriate
   59:  * format (if at all necessary). For example, UFI requires all commands to be
   60:  * 12 bytes in length amongst other things.
   61:  *
   62:  * The source code below is marked and can be split into a number of pieces
   63:  * (in this order):
   64:  *
   65:  * - probe/attach/detach
   66:  * - generic transfer routines
   67:  * - BBB
   68:  * - CBI
   69:  * - CBI_I (in addition to functions from CBI)
   70:  * - CAM (Common Access Method)
   71:  * - SCSI
   72:  * - UFI
   73:  * - 8070i (ATAPI)
   74:  *
   75:  * The protocols are implemented using a state machine, for the transfers as
   76:  * well as for the resets. The state machine is contained in umass_*_state.
   77:  * The state machine is started through either umass_*_transfer or
   78:  * umass_*_reset.
   79:  *
   80:  * The reason for doing this is a) CAM performs a lot better this way and b) it
   81:  * avoids using tsleep from interrupt context (for example after a failed
   82:  * transfer).
   83:  */
   84: 
   85: /*
   86:  * The SCSI related part of this driver has been derived from the
   87:  * dev/ppbus/vpo.c driver, by Nicolas Souchu (nsouch@freebsd.org).
   88:  *
   89:  * The CAM layer uses so called actions which are messages sent to the host
   90:  * adapter for completion. The actions come in through umass_cam_action. The
   91:  * appropriate block of routines is called depending on the transport protocol
   92:  * in use. When the transfer has finished, these routines call
   93:  * umass_cam_cb again to complete the CAM command.
   94:  */
   95: 
   96: /*
   97:  * XXX Currently CBI with CCI is not supported because it bombs the system
   98:  *     when the device is detached (low frequency interrupts are detached
   99:  *     too late.
  100:  */
  101: #undef CBI_I
  102: 
  103: #include <sys/param.h>
  104: #include <sys/systm.h>
  105: #include <sys/kernel.h>
  106: #include <sys/module.h>
  107: #include <sys/bus.h>
  108: #include <sys/sysctl.h>
  109: 
  110: #include <bus/usb/usb.h>
  111: #include <bus/usb/usbdi.h>
  112: #include <bus/usb/usbdi_util.h>
  113: #include <bus/usb/usbdevs.h>
  114: 
  115: #include <bus/cam/cam.h>
  116: #include <bus/cam/cam_ccb.h>
  117: #include <bus/cam/cam_sim.h>
  118: #include <bus/cam/cam_xpt_sim.h>
  119: #include <bus/cam/scsi/scsi_all.h>
  120: #include <bus/cam/scsi/scsi_da.h>
  121: 
  122: #include <bus/cam/cam_periph.h>
  123: 
  124: #ifdef USB_DEBUG
  125: #define DIF(m, x)	if (umassdebug & (m)) do { x ; } while (0)
  126: #define	DPRINTF(m, x)	if (umassdebug & (m)) logprintf x
  127: #define UDMASS_GEN	0x00010000	/* general */
  128: #define UDMASS_SCSI	0x00020000	/* scsi */
  129: #define UDMASS_UFI	0x00040000	/* ufi command set */
  130: #define UDMASS_ATAPI	0x00080000	/* 8070i command set */
  131: #define UDMASS_CMD	(UDMASS_SCSI|UDMASS_UFI|UDMASS_ATAPI)
  132: #define UDMASS_USB	0x00100000	/* USB general */
  133: #define UDMASS_BBB	0x00200000	/* Bulk-Only transfers */
  134: #define UDMASS_CBI	0x00400000	/* CBI transfers */
  135: #define UDMASS_WIRE	(UDMASS_BBB|UDMASS_CBI)
  136: #define UDMASS_ALL	0xffff0000	/* all of the above */
  137: int umassdebug = 0;
  138: SYSCTL_NODE(_hw_usb, OID_AUTO, umass, CTLFLAG_RW, 0, "USB umass");
  139: SYSCTL_INT(_hw_usb_umass, OID_AUTO, debug, CTLFLAG_RW,
  140: 	   &umassdebug, 0, "umass debug level");
  141: #else
  142: #define DIF(m, x)	/* nop */
  143: #define	DPRINTF(m, x)	/* nop */
  144: #endif
  145: 
  146: 
  147: /* Generic definitions */
  148: 
  149: /* Direction for umass_*_transfer */
  150: #define DIR_NONE	0
  151: #define DIR_IN		1
  152: #define DIR_OUT		2
  153: 
  154: /* device name */
  155: #define DEVNAME		"umass"
  156: #define DEVNAME_SIM	"umass-sim"
  157: 
  158: #define UMASS_MAX_TRANSFER_SIZE		65536
  159: #define UMASS_DEFAULT_TRANSFER_SPEED	1000
  160: #define UMASS_FLOPPY_TRANSFER_SPEED	20
  161: 
  162: #define UMASS_TIMEOUT			5000 /* msecs */
  163: 
  164: /* CAM specific definitions */
  165: 
  166: #define UMASS_SCSIID_MAX	1	/* maximum number of drives expected */
  167: #define UMASS_SCSIID_HOST	UMASS_SCSIID_MAX
  168: 
  169: #define MS_TO_TICKS(ms) ((ms) * hz / 1000)
  170: 
  171: 
  172: /* Bulk-Only features */
  173: 
  174: #define UR_BBB_RESET		0xff		/* Bulk-Only reset */
  175: #define UR_BBB_GET_MAX_LUN	0xfe		/* Get maximum lun */
  176: 
  177: /* Command Block Wrapper */
  178: typedef struct {
  179: 	uDWord		dCBWSignature;
  180: #	define CBWSIGNATURE	0x43425355
  181: 	uDWord		dCBWTag;
  182: 	uDWord		dCBWDataTransferLength;
  183: 	uByte		bCBWFlags;
  184: #	define CBWFLAGS_OUT	0x00
  185: #	define CBWFLAGS_IN	0x80
  186: 	uByte		bCBWLUN;
  187: 	uByte		bCDBLength;
  188: #	define CBWCDBLENGTH	16
  189: 	uByte		CBWCDB[CBWCDBLENGTH];
  190: } umass_bbb_cbw_t;
  191: #define	UMASS_BBB_CBW_SIZE	31
  192: 
  193: /* Command Status Wrapper */
  194: typedef struct {
  195: 	uDWord		dCSWSignature;
  196: #	define CSWSIGNATURE	0x53425355
  197: #	define CSWSIGNATURE_OLYMPUS_C1	0x55425355
  198: 	uDWord		dCSWTag;
  199: 	uDWord		dCSWDataResidue;
  200: 	uByte		bCSWStatus;
  201: #	define CSWSTATUS_GOOD	0x0
  202: #	define CSWSTATUS_FAILED	0x1
  203: #	define CSWSTATUS_PHASE	0x2
  204: } umass_bbb_csw_t;
  205: #define	UMASS_BBB_CSW_SIZE	13
  206: 
  207: /* CBI features */
  208: 
  209: #define UR_CBI_ADSC	0x00
  210: 
  211: typedef unsigned char umass_cbi_cbl_t[16];	/* Command block */
  212: 
  213: typedef union {
  214: 	struct {
  215: 		unsigned char	type;
  216: 		#define IDB_TYPE_CCI		0x00
  217: 		unsigned char	value;
  218: 		#define IDB_VALUE_PASS		0x00
  219: 		#define IDB_VALUE_FAIL		0x01
  220: 		#define IDB_VALUE_PHASE		0x02
  221: 		#define IDB_VALUE_PERSISTENT	0x03
  222: 		#define IDB_VALUE_STATUS_MASK	0x03
  223: 	} common;
  224: 
  225: 	struct {
  226: 		unsigned char	asc;
  227: 		unsigned char	ascq;
  228: 	} ufi;
  229: } umass_cbi_sbl_t;
  230: 
  231: 
  232: 
  233: struct umass_softc;		/* see below */
  234: 
  235: typedef void (*transfer_cb_f)	(struct umass_softc *sc, void *priv,
  236: 				int residue, int status);
  237: #define STATUS_CMD_OK		0	/* everything ok */
  238: #define STATUS_CMD_UNKNOWN	1	/* will have to fetch sense */
  239: #define STATUS_CMD_FAILED	2	/* transfer was ok, command failed */
  240: #define STATUS_WIRE_FAILED	3	/* couldn't even get command across */
  241: 
  242: typedef void (*wire_reset_f)	(struct umass_softc *sc, int status);
  243: typedef void (*wire_transfer_f)	(struct umass_softc *sc, int lun,
  244: 				void *cmd, int cmdlen, void *data, int datalen,
  245: 				int dir, transfer_cb_f cb, void *priv);
  246: typedef void (*wire_state_f)	(usbd_xfer_handle xfer,
  247: 				usbd_private_handle priv, usbd_status err);
  248: 
  249: typedef int (*command_transform_f)	(struct umass_softc *sc,
  250: 				unsigned char *cmd, int cmdlen,
  251: 				unsigned char **rcmd, int *rcmdlen);
  252: 
  253: 
  254: struct umass_devdescr_t {
  255: 	u_int32_t	vid;
  256: #	define VID_WILDCARD	0xffffffff
  257: #	define VID_EOT		0xfffffffe
  258: 	u_int32_t	pid;
  259: #	define PID_WILDCARD	0xffffffff
  260: #	define PID_EOT		0xfffffffe
  261: 	u_int32_t	rid;
  262: #	define RID_WILDCARD	0xffffffff
  263: #	define RID_EOT		0xfffffffe
  264: 
  265: 	/* wire and command protocol */
  266: 	u_int16_t	proto;
  267: #	define UMASS_PROTO_BBB		0x0001	/* USB wire protocol */
  268: #	define UMASS_PROTO_CBI		0x0002
  269: #	define UMASS_PROTO_CBI_I	0x0004
  270: #	define UMASS_PROTO_WIRE		0x00ff	/* USB wire protocol mask */
  271: #	define UMASS_PROTO_SCSI		0x0100	/* command protocol */
  272: #	define UMASS_PROTO_ATAPI	0x0200
  273: #	define UMASS_PROTO_UFI		0x0400
  274: #	define UMASS_PROTO_RBC		0x0800
  275: #	define UMASS_PROTO_COMMAND	0xff00	/* command protocol mask */
  276: 
  277: 	/* Device specific quirks */
  278: 	u_int16_t	quirks;
  279: #	define NO_QUIRKS		0x0000
  280: 	/* The drive does not support Test Unit Ready. Convert to Start Unit
  281: 	 */
  282: #	define NO_TEST_UNIT_READY	0x0001
  283: 	/* The drive does not reset the Unit Attention state after REQUEST
  284: 	 * SENSE has been sent. The INQUIRY command does not reset the UA
  285: 	 * either, and so CAM runs in circles trying to retrieve the initial
  286: 	 * INQUIRY data.
  287: 	 */
  288: #	define RS_NO_CLEAR_UA		0x0002
  289: 	/* The drive does not support START STOP.  */
  290: #	define NO_START_STOP		0x0004
  291: 	/* Don't ask for full inquiry data (255b).  */
  292: #	define FORCE_SHORT_INQUIRY	0x0008
  293: 	/* Needs to be initialised the Shuttle way */
  294: #	define SHUTTLE_INIT		0x0010
  295: 	/* Drive needs to be switched to alternate iface 1 */
  296: #	define ALT_IFACE_1		0x0020
  297: 	/* Drive does not do 1Mb/s, but just floppy speeds (20kb/s) */
  298: #	define FLOPPY_SPEED		0x0040
  299: 	/* The device can't count and gets the residue of transfers wrong */
  300: #	define IGNORE_RESIDUE		0x0080
  301: 	/* No GetMaxLun call */
  302: #	define NO_GETMAXLUN		0x0100
  303: 	/* The device uses a weird CSWSIGNATURE. */
  304: #	define WRONG_CSWSIG		0x0200
  305: 	/* Device cannot handle INQUIRY so fake a generic response */
  306: #	define NO_INQUIRY		0x0400
  307: 	/* Device cannot handle INQUIRY EVPD, return CHECK CONDITION */
  308: #	define NO_INQUIRY_EVPD		0x0800
  309: };
  310: 
  311: Static struct umass_devdescr_t umass_devdescrs[] = {
  312: 	{ USB_VENDOR_ASAHIOPTICAL, PID_WILDCARD, RID_WILDCARD,
  313: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  314: 	  RS_NO_CLEAR_UA
  315: 	},
  316: 	{ USB_VENDOR_FUJIPHOTO, USB_PRODUCT_FUJIPHOTO_MASS0100, RID_WILDCARD,
  317: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  318: 	  RS_NO_CLEAR_UA
  319: 	},
  320: 	{ USB_VENDOR_GENESYS,  USB_PRODUCT_GENESYS_GL641USB2IDE, RID_WILDCARD,
  321: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  322: 	  FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE
  323: 	},
  324: 	{ USB_VENDOR_GENESYS,  USB_PRODUCT_GENESYS_GL641USB, RID_WILDCARD,
  325: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  326: 	  FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE
  327: 	},
  328: 	{ USB_VENDOR_HITACHI, USB_PRODUCT_HITACHI_DVDCAM_USB, RID_WILDCARD,
  329: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  330: 	  NO_INQUIRY
  331: 	},
  332: 	{ USB_VENDOR_HP, USB_PRODUCT_HP_CDW8200, RID_WILDCARD,
  333: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  334: 	  NO_TEST_UNIT_READY | NO_START_STOP
  335: 	},
  336: 	{ USB_VENDOR_INSYSTEM, USB_PRODUCT_INSYSTEM_USBCABLE, RID_WILDCARD,
  337: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI,
  338: 	  NO_TEST_UNIT_READY | NO_START_STOP | ALT_IFACE_1
  339: 	},
  340: 	{ USB_VENDOR_IOMEGA, USB_PRODUCT_IOMEGA_ZIP100, RID_WILDCARD,
  341: 	  /* XXX This is not correct as there are Zip drives that use ATAPI.
  342: 	   */
  343: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  344: 	  NO_TEST_UNIT_READY
  345: 	},
  346: 	{ USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_LDR_H443U2, RID_WILDCARD,
  347: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  348: 	  NO_QUIRKS
  349: 	},
  350: 	{ USB_VENDOR_MELCO,  USB_PRODUCT_MELCO_DUBPXXG, RID_WILDCARD,
  351: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  352: 	  FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE
  353: 	},
  354: 	{ USB_VENDOR_MICROTECH, USB_PRODUCT_MICROTECH_DPCM, RID_WILDCARD,
  355: 	  UMASS_PROTO_SCSI | UMASS_PROTO_CBI,
  356: 	  NO_TEST_UNIT_READY | NO_START_STOP
  357: 	},
  358: 	{ USB_VENDOR_MSYSTEMS, USB_PRODUCT_MSYSTEMS_DISKONKEY, RID_WILDCARD,
  359: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  360: 	  IGNORE_RESIDUE | NO_GETMAXLUN | RS_NO_CLEAR_UA
  361: 	},
  362: 	{ USB_VENDOR_MSYSTEMS, USB_PRODUCT_MSYSTEMS_DISKONKEY2, RID_WILDCARD,
  363: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_BBB,
  364: 	  NO_QUIRKS
  365: 	},
  366: 	{ USB_VENDOR_OLYMPUS, USB_PRODUCT_OLYMPUS_C1, RID_WILDCARD,
  367: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  368: 	  WRONG_CSWSIG
  369: 	},
  370: 	{ USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXLCB20AN, RID_WILDCARD,
  371: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  372: 	  NO_QUIRKS
  373: 	},
  374: 	{ USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXLCB35AN, RID_WILDCARD,
  375: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  376: 	  NO_QUIRKS
  377: 	},
  378: 	{ USB_VENDOR_PNY, USB_PRODUCT_PNY_ATTACHE, RID_WILDCARD,
  379: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  380: 	  IGNORE_RESIDUE
  381: 	},
  382: 	{ USB_VENDOR_SCANLOGIC, USB_PRODUCT_SCANLOGIC_SL11R, RID_WILDCARD,
  383: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  384: 	  NO_QUIRKS
  385: 	},
  386: 	{ USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_EUSB, RID_WILDCARD,
  387: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  388: 	  NO_TEST_UNIT_READY | NO_START_STOP | SHUTTLE_INIT
  389: 	},
  390: 	{ USB_VENDOR_SIGMATEL, USB_PRODUCT_SIGMATEL_I_BEAD100, RID_WILDCARD,
  391: 	  UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
  392: 	  SHUTTLE_INIT
  393: 	},
  394: 	{ USB_VENDOR_SONY, USB_PRODUCT_SONY_DSC, RID_WILDCARD,
  395: 	  UMASS_PROTO_RBC | UMASS_PROTO_CBI,
  396: 	  NO_QUIRKS
  397: 	},
  398: 	{ USB_VENDOR_SONY, USB_PRODUCT_SONY_MSC, RID_WILDCARD,
  399: 	  UMASS_PROTO_RBC | UMASS_PROTO_CBI,
  400: 	  NO_QUIRKS
  401: 	},
  402: 	{ USB_VENDOR_TREK, USB_PRODUCT_TREK_THUMBDRIVE_8MB, RID_WILDCARD,
  403:           UMASS_PROTO_ATAPI | UMASS_PROTO_BBB,
  404: 	  IGNORE_RESIDUE
  405: 	},
  406: 	{ USB_VENDOR_YANO,  USB_PRODUCT_YANO_U640MO, RID_WILDCARD,
  407: 	  UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
  408: 	  FORCE_SHORT_INQUIRY
  409: 	},
  410: 	{ VID_EOT, PID_EOT, RID_EOT, 0, 0 }
  411: };
  412: 
  413: 
  414: /* the per device structure */
  415: struct umass_softc {
  416: 	USBBASEDEVICE		sc_dev;		/* base device */
  417: 	usbd_device_handle	sc_udev;	/* USB device */
  418: 
  419: 	struct cam_sim		*umass_sim;	/* SCSI Interface Module */
  420: 
  421: 	unsigned char		flags;		/* various device flags */
  422: #	define UMASS_FLAGS_GONE		0x01	/* devices is no more */
  423: 
  424: 	u_int16_t		proto;		/* wire and cmd protocol */
  425: 	u_int16_t		quirks;		/* they got it almost right */
  426: 
  427: 	usbd_interface_handle	iface;		/* Mass Storage interface */
  428: 	int			ifaceno;	/* MS iface number */
  429: 
  430: 	u_int8_t		bulkin;		/* bulk-in Endpoint Address */
  431: 	u_int8_t		bulkout;	/* bulk-out Endpoint Address */
  432: 	u_int8_t		intrin;		/* intr-in Endp. (CBI) */
  433: 	usbd_pipe_handle	bulkin_pipe;
  434: 	usbd_pipe_handle	bulkout_pipe;
  435: 	usbd_pipe_handle	intrin_pipe;
  436: 
  437: 	/* Reset the device in a wire protocol specific way */
  438: 	wire_reset_f		reset;
  439: 
  440: 	/* The start of a wire transfer. It prepares the whole transfer (cmd,
  441: 	 * data, and status stage) and initiates it. It is up to the state
  442: 	 * machine (below) to handle the various stages and errors in these
  443: 	 */
  444: 	wire_transfer_f		transfer;
  445: 
  446: 	/* The state machine, handling the various states during a transfer */
  447: 	wire_state_f		state;
  448: 
  449: 	/* The command transform function is used to conver the SCSI commands
  450: 	 * into their derivatives, like UFI, ATAPI, and friends.
  451: 	 */
  452: 	command_transform_f	transform;	/* command transform */
  453: 
  454: 	/* Bulk specific variables for transfers in progress */
  455: 	umass_bbb_cbw_t		cbw;	/* command block wrapper */
  456: 	umass_bbb_csw_t		csw;	/* command status wrapper*/
  457: 	/* CBI specific variables for transfers in progress */
  458: 	umass_cbi_cbl_t		cbl;	/* command block */
  459: 	umass_cbi_sbl_t		sbl;	/* status block */
  460: 
  461: 	/* generic variables for transfers in progress */
  462: 	/* ctrl transfer requests */
  463: 	usb_device_request_t	request;
  464: 
  465: 	/* xfer handles
  466: 	 * Most of our operations are initiated from interrupt context, so
  467: 	 * we need to avoid using the one that is in use. We want to avoid
  468: 	 * allocating them in the interrupt context as well.
  469: 	 */
  470: 	/* indices into array below */
  471: #	define XFER_BBB_CBW		0	/* Bulk-Only */
  472: #	define XFER_BBB_DATA		1
  473: #	define XFER_BBB_DCLEAR		2
  474: #	define XFER_BBB_CSW1		3
  475: #	define XFER_BBB_CSW2		4
  476: #	define XFER_BBB_SCLEAR		5
  477: #	define XFER_BBB_RESET1		6
  478: #	define XFER_BBB_RESET2		7
  479: #	define XFER_BBB_RESET3		8
  480: 
  481: #	define XFER_CBI_CB		0	/* CBI */
  482: #	define XFER_CBI_DATA		1
  483: #	define XFER_CBI_STATUS		2
  484: #	define XFER_CBI_DCLEAR		3
  485: #	define XFER_CBI_SCLEAR		4
  486: #	define XFER_CBI_RESET1		5
  487: #	define XFER_CBI_RESET2		6
  488: #	define XFER_CBI_RESET3		7
  489: 
  490: #	define XFER_NR			9	/* maximum number */
  491: 
  492: 	usbd_xfer_handle	transfer_xfer[XFER_NR];	/* for ctrl xfers */
  493: 
  494: 	int			transfer_dir;		/* data direction */
  495: 	void			*transfer_data;		/* data buffer */
  496: 	int			transfer_datalen;	/* (maximum) length */
  497: 	int			transfer_actlen;	/* actual length */
  498: 	transfer_cb_f		transfer_cb;		/* callback */
  499: 	void			*transfer_priv;		/* for callback */
  500: 	int			transfer_status;
  501: 
  502: 	int			transfer_state;
  503: #	define TSTATE_ATTACH			0	/* in attach */
  504: #	define TSTATE_IDLE			1
  505: #	define TSTATE_BBB_COMMAND		2	/* CBW transfer */
  506: #	define TSTATE_BBB_DATA			3	/* Data transfer */
  507: #	define TSTATE_BBB_DCLEAR		4	/* clear endpt stall */
  508: #	define TSTATE_BBB_STATUS1		5	/* clear endpt stall */
  509: #	define TSTATE_BBB_SCLEAR		6	/* clear endpt stall */
  510: #	define TSTATE_BBB_STATUS2		7	/* CSW transfer */
  511: #	define TSTATE_BBB_RESET1		8	/* reset command */
  512: #	define TSTATE_BBB_RESET2		9	/* in clear stall */
  513: #	define TSTATE_BBB_RESET3		10	/* out clear stall */
  514: #	define TSTATE_CBI_COMMAND		11	/* command transfer */
  515: #	define TSTATE_CBI_DATA			12	/* data transfer */
  516: #	define TSTATE_CBI_STATUS		13	/* status transfer */
  517: #	define TSTATE_CBI_DCLEAR		14	/* clear ep stall */
  518: #	define TSTATE_CBI_SCLEAR		15	/* clear ep stall */
  519: #	define TSTATE_CBI_RESET1		16	/* reset command */
  520: #	define TSTATE_CBI_RESET2		17	/* in clear stall */
  521: #	define TSTATE_CBI_RESET3		18	/* out clear stall */
  522: #	define TSTATE_STATES			19	/* # of states above */
  523: 
  524: 
  525: 	/* SCSI/CAM specific variables */
  526: 	unsigned char 		cam_scsi_command[CAM_MAX_CDBLEN];
  527: 	unsigned char 		cam_scsi_command2[CAM_MAX_CDBLEN];
  528: 	struct scsi_sense	cam_scsi_sense;
  529: 	struct scsi_sense	cam_scsi_test_unit_ready;
  530: 
  531: 	int			maxlun;			/* maximum LUN number */
  532: 	struct callout_handle	rescan_timeout;
  533: };
  534: 
  535: #ifdef USB_DEBUG
  536: char *states[TSTATE_STATES+1] = {
  537: 	/* should be kept in sync with the list at transfer_state */
  538: 	"Attach",
  539: 	"Idle",
  540: 	"BBB CBW",
  541: 	"BBB Data",
  542: 	"BBB Data bulk-in/-out clear stall",
  543: 	"BBB CSW, 1st attempt",
  544: 	"BBB CSW bulk-in clear stall",
  545: 	"BBB CSW, 2nd attempt",
  546: 	"BBB Reset",
  547: 	"BBB bulk-in clear stall",
  548: 	"BBB bulk-out clear stall",
  549: 	"CBI Command",
  550: 	"CBI Data",
  551: 	"CBI Status",
  552: 	"CBI Data bulk-in/-out clear stall",
  553: 	"CBI Status intr-in clear stall",
  554: 	"CBI Reset",
  555: 	"CBI bulk-in clear stall",
  556: 	"CBI bulk-out clear stall",
  557: 	NULL
  558: };
  559: #endif
  560: 
  561: /* If device cannot return valid inquiry data, fake it */
  562: Static uint8_t fake_inq_data[SHORT_INQUIRY_LENGTH] = {
  563: 	0, /*removable*/ 0x80, SCSI_REV_2, SCSI_REV_2,
  564: 	/*additional_length*/ 31, 0, 0, 0
  565: };
  566: 
  567: /* USB device probe/attach/detach functions */
  568: USB_DECLARE_DRIVER(umass);
  569: Static int umass_match_proto	(struct umass_softc *sc,
  570: 				usbd_interface_handle iface,
  571: 				usbd_device_handle udev);
  572: 
  573: /* quirk functions */
  574: Static void umass_init_shuttle	(struct umass_softc *sc);
  575: 
  576: /* generic transfer functions */
  577: Static usbd_status umass_setup_transfer	(struct umass_softc *sc,
  578: 				usbd_pipe_handle pipe,
  579: 				void *buffer, int buflen, int flags,
  580: 				usbd_xfer_handle xfer);
  581: Static usbd_status umass_setup_ctrl_transfer	(struct umass_softc *sc,
  582: 				usbd_device_handle udev,
  583: 				usb_device_request_t *req,
  584: 				void *buffer, int buflen, int flags,
  585: 				usbd_xfer_handle xfer);
  586: Static void umass_clear_endpoint_stall	(struct umass_softc *sc,
  587: 				u_int8_t endpt, usbd_pipe_handle pipe,
  588: 				int state, usbd_xfer_handle xfer);
  589: Static void umass_reset		(struct umass_softc *sc,
  590: 				transfer_cb_f cb, void *priv);
  591: 
  592: /* Bulk-Only related functions */
  593: Static void umass_bbb_reset	(struct umass_softc *sc, int status);
  594: Static void umass_bbb_transfer	(struct umass_softc *sc, int lun,
  595: 				void *cmd, int cmdlen,
  596: 		    		void *data, int datalen, int dir,
  597: 				transfer_cb_f cb, void *priv);
  598: Static void umass_bbb_state	(usbd_xfer_handle xfer,
  599: 				usbd_private_handle priv,
  600: 				usbd_status err);
  601: Static int umass_bbb_get_max_lun
  602: 				(struct umass_softc *sc);
  603: 
  604: /* CBI related functions */
  605: Static int umass_cbi_adsc	(struct umass_softc *sc,
  606: 				char *buffer, int buflen,
  607: 				usbd_xfer_handle xfer);
  608: Static void umass_cbi_reset	(struct umass_softc *sc, int status);
  609: Static void umass_cbi_transfer	(struct umass_softc *sc, int lun,
  610: 				void *cmd, int cmdlen,
  611: 		    		void *data, int datalen, int dir,
  612: 				transfer_cb_f cb, void *priv);
  613: Static void umass_cbi_state	(usbd_xfer_handle xfer,
  614: 				usbd_private_handle priv, usbd_status err);
  615: 
  616: /* CAM related functions */
  617: Static void umass_cam_action	(struct cam_sim *sim, union ccb *ccb);
  618: Static void umass_cam_poll	(struct cam_sim *sim);
  619: 
  620: Static void umass_cam_cb	(struct umass_softc *sc, void *priv,
  621: 				int residue, int status);
  622: Static void umass_cam_sense_cb	(struct umass_softc *sc, void *priv,
  623: 				int residue, int status);
  624: Static void umass_cam_quirk_cb	(struct umass_softc *sc, void *priv,
  625: 				int residue, int status);
  626: 
  627: Static void umass_cam_rescan_callback
  628: 				(struct cam_periph *periph,union ccb *ccb);
  629: Static void umass_cam_rescan	(void *addr);
  630: 
  631: Static int umass_cam_attach_sim	(struct umass_softc *sc);
  632: Static int umass_cam_attach	(struct umass_softc *sc);
  633: Static int umass_cam_detach_sim	(struct umass_softc *sc);
  634: 
  635: 
  636: /* SCSI specific functions */
  637: Static int umass_scsi_transform	(struct umass_softc *sc,
  638: 				unsigned char *cmd, int cmdlen,
  639: 		     		unsigned char **rcmd, int *rcmdlen);
  640: 
  641: /* UFI specific functions */
  642: #define UFI_COMMAND_LENGTH	12	/* UFI commands are always 12 bytes */
  643: Static int umass_ufi_transform	(struct umass_softc *sc,
  644: 				unsigned char *cmd, int cmdlen,
  645: 		    		unsigned char **rcmd, int *rcmdlen);
  646: 
  647: /* ATAPI (8070i) specific functions */
  648: #define ATAPI_COMMAND_LENGTH	12	/* ATAPI commands are always 12 bytes */
  649: Static int umass_atapi_transform	(struct umass_softc *sc,
  650: 				unsigned char *cmd, int cmdlen,
  651: 		     		unsigned char **rcmd, int *rcmdlen);
  652: 
  653: /* RBC specific functions */
  654: Static int umass_rbc_transform	(struct umass_softc *sc,
  655: 				unsigned char *cmd, int cmdlen,
  656: 		     		unsigned char **rcmd, int *rcmdlen);
  657: 
  658: #ifdef USB_DEBUG
  659: /* General debugging functions */
  660: Static void umass_bbb_dump_cbw	(struct umass_softc *sc, umass_bbb_cbw_t *cbw);
  661: Static void umass_bbb_dump_csw	(struct umass_softc *sc, umass_bbb_csw_t *csw);
  662: Static void umass_cbi_dump_cmd	(struct umass_softc *sc, void *cmd, int cmdlen);
  663: Static void umass_dump_buffer	(struct umass_softc *sc, u_int8_t *buffer,
  664: 				int buflen, int printlen);
  665: #endif
  666: 
  667: #if defined(__FreeBSD__) || defined(__DragonFly__)
  668: MODULE_DEPEND(umass, cam, 1,1,1);
  669: #endif
  670: 
  671: /*
  672:  * USB device probe/attach/detach
  673:  */
  674: 
  675: /*
  676:  * Match the device we are seeing with the devices supported. Fill in the
  677:  * description in the softc accordingly. This function is called from both
  678:  * probe and attach.
  679:  */
  680: 
  681: Static int
  682: umass_match_proto(struct umass_softc *sc, usbd_interface_handle iface,
  683: 		  usbd_device_handle udev)
  684: {
  685: 	usb_device_descriptor_t *dd;
  686: 	usb_interface_descriptor_t *id;
  687: 	int i;
  688: 	int found = 0;
  689: 
  690: 	sc->sc_udev = udev;
  691: 	sc->proto = 0;
  692: 	sc->quirks = 0;
  693: 
  694: 	dd = usbd_get_device_descriptor(udev);
  695: 
  696: 	/* An entry specifically for Y-E Data devices as they don't fit in the
  697: 	 * device description table.
  698: 	 */
  699: 	if (UGETW(dd->idVendor) == USB_VENDOR_YEDATA
  700: 	    && UGETW(dd->idProduct) == USB_PRODUCT_YEDATA_FLASHBUSTERU) {
  701: 
  702: 		/* Revisions < 1.28 do not handle the inerrupt endpoint
  703: 		 * very well.
  704: 		 */
  705: 		if (UGETW(dd->bcdDevice) < 0x128) {
  706: 			sc->proto = UMASS_PROTO_UFI | UMASS_PROTO_CBI;
  707: 		} else {
  708: 			sc->proto = UMASS_PROTO_UFI | UMASS_PROTO_CBI_I;
  709: 		}
  710: 
  711: 		/*
  712: 		 * Revisions < 1.28 do not have the TEST UNIT READY command
  713: 		 * Revisions == 1.28 have a broken TEST UNIT READY
  714: 		 */
  715: 		if (UGETW(dd->bcdDevice) <= 0x128)
  716: 			sc->quirks |= NO_TEST_UNIT_READY;
  717: 
  718: 		sc->quirks |= RS_NO_CLEAR_UA | FLOPPY_SPEED;
  719: 		return(UMATCH_VENDOR_PRODUCT);
  720: 	}
  721: 
  722: 	/* Check the list of supported devices for a match. While looking,
  723: 	 * check for wildcarded and fully matched. First match wins.
  724: 	 */
  725: 	for (i = 0; umass_devdescrs[i].vid != VID_EOT && !found; i++) {
  726: 		if (umass_devdescrs[i].vid == VID_WILDCARD &&
  727: 		    umass_devdescrs[i].pid == PID_WILDCARD &&
  728: 		    umass_devdescrs[i].rid == RID_WILDCARD) {
  729: 			printf("umass: ignoring invalid wildcard quirk\n");
  730: 			continue;
  731: 		}
  732: 		if ((umass_devdescrs[i].vid == UGETW(dd->idVendor) ||
  733: 		     umass_devdescrs[i].vid == VID_WILDCARD)
  734: 		 && (umass_devdescrs[i].pid == UGETW(dd->idProduct) ||
  735: 		     umass_devdescrs[i].pid == PID_WILDCARD)) {
  736: 			if (umass_devdescrs[i].rid == RID_WILDCARD) {
  737: 				sc->proto = umass_devdescrs[i].proto;
  738: 				sc->quirks = umass_devdescrs[i].quirks;
  739: 				return (UMATCH_VENDOR_PRODUCT);
  740: 			} else if (umass_devdescrs[i].rid ==
  741: 			    UGETW(dd->bcdDevice)) {
  742: 				sc->proto = umass_devdescrs[i].proto;
  743: 				sc->quirks = umass_devdescrs[i].quirks;
  744: 				return (UMATCH_VENDOR_PRODUCT_REV);
  745: 			} /* else RID does not match */
  746: 		}
  747: 	}
  748: 
  749: 	/* Check for a standards compliant device */
  750: 
  751: 	id = usbd_get_interface_descriptor(iface);
  752: 	if (id == NULL || id->bInterfaceClass != UICLASS_MASS)
  753: 		return(UMATCH_NONE);
  754: 	
  755: 	switch (id->bInterfaceSubClass) {
  756: 	case UISUBCLASS_SCSI:
  757: 		sc->proto |= UMASS_PROTO_SCSI;
  758: 		break;
  759: 	case UISUBCLASS_UFI:
  760: 		sc->proto |= UMASS_PROTO_UFI;
  761: 		break;
  762: 	case UISUBCLASS_RBC:
  763: 		sc->proto |= UMASS_PROTO_RBC;
  764: 		break;
  765: 	case UISUBCLASS_SFF8020I:
  766: 	case UISUBCLASS_SFF8070I:
  767: 		sc->proto |= UMASS_PROTO_ATAPI;
  768: 		break;
  769: 	default:
  770: 		DPRINTF(UDMASS_GEN, ("%s: Unsupported command protocol %d\n",
  771: 			USBDEVNAME(sc->sc_dev), id->bInterfaceSubClass));
  772: 		return(UMATCH_NONE);
  773: 	}
  774: 
  775: 	switch (id->bInterfaceProtocol) {
  776: 	case UIPROTO_MASS_CBI:
  777: 		sc->proto |= UMASS_PROTO_CBI;
  778: 		break;
  779: 	case UIPROTO_MASS_CBI_I:
  780: 		sc->proto |= UMASS_PROTO_CBI_I;
  781: 		break;
  782: 	case UIPROTO_MASS_BBB_OLD:
  783: 	case UIPROTO_MASS_BBB:
  784: 		sc->proto |= UMASS_PROTO_BBB;
  785: 		break;
  786: 	default:
  787: 		DPRINTF(UDMASS_GEN, ("%s: Unsupported wire protocol %d\n",
  788: 			USBDEVNAME(sc->sc_dev), id->bInterfaceProtocol));
  789: 		return(UMATCH_NONE);
  790: 	}
  791: 
  792: 	return(UMATCH_DEVCLASS_DEVSUBCLASS_DEVPROTO);
  793: }
  794: 
  795: USB_MATCH(umass)
  796: {
  797: 	USB_MATCH_START(umass, uaa);
  798: 	struct umass_softc *sc = device_get_softc(self);
  799: 
  800: 	USB_MATCH_SETUP;
  801: 
  802: 	if (uaa->iface == NULL)
  803: 		return(UMATCH_NONE);
  804: 
  805: 	return(umass_match_proto(sc, uaa->iface, uaa->device));
  806: }
  807: 
  808: USB_ATTACH(umass)
  809: {
  810: 	USB_ATTACH_START(umass, sc, uaa);
  811: 	usb_interface_descriptor_t *id;
  812: 	usb_endpoint_descriptor_t *ed;
  813: 	char devinfo[1024];
  814: 	int i;
  815: 	int err;
  816: 
  817: 	/*
  818: 	 * the softc struct is bzero-ed in device_set_driver. We can safely
  819: 	 * call umass_detach without specifically initialising the struct.
  820: 	 */
  821: 
  822: 	usbd_devinfo(uaa->device, 0, devinfo);
  823: 	USB_ATTACH_SETUP;
  824: 
  825: 	sc->iface = uaa->iface;
  826: 	sc->ifaceno = uaa->ifaceno;
  827: 
  828: 	/* initialise the proto and drive values in the umass_softc (again) */
  829: 	(void) umass_match_proto(sc, sc->iface, uaa->device);
  830: 
  831: 	id = usbd_get_interface_descriptor(sc->iface);
  832: 	printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo);
  833: #ifdef USB_DEBUG
  834: 	printf("%s: ", USBDEVNAME(sc->sc_dev));
  835: 	switch (sc->proto&UMASS_PROTO_COMMAND) {
  836: 	case UMASS_PROTO_SCSI:
  837: 		printf("SCSI");
  838: 		break;
  839: 	case UMASS_PROTO_ATAPI:
  840: 		printf("8070i (ATAPI)");
  841: 		break;
  842: 	case UMASS_PROTO_UFI:
  843: 		printf("UFI");
  844: 		break;
  845: 	case UMASS_PROTO_RBC:
  846: 		printf("RBC");
  847: 		break;
  848: 	default:
  849: 		printf("(unknown 0x%02x)", sc->proto&UMASS_PROTO_COMMAND);
  850: 		break;
  851: 	}
  852: 	printf(" over ");
  853: 	switch (sc->proto&UMASS_PROTO_WIRE) {
  854: 	case UMASS_PROTO_BBB:
  855: 		printf("Bulk-Only");
  856: 		break;
  857: 	case UMASS_PROTO_CBI:			/* uses Comand/Bulk pipes */
  858: 		printf("CBI");
  859: 		break;
  860: 	case UMASS_PROTO_CBI_I:		/* uses Comand/Bulk/Interrupt pipes */
  861: 		printf("CBI with CCI");
  862: #ifndef CBI_I
  863: 		printf(" (using CBI)");
  864: #endif
  865: 		break;
  866: 	default:
  867: 		printf("(unknown 0x%02x)", sc->proto&UMASS_PROTO_WIRE);
  868: 	}
  869: 	printf("; quirks = 0x%04x\n", sc->quirks);
  870: #endif
  871: 
  872: #ifndef CBI_I
  873: 	if (sc->proto & UMASS_PROTO_CBI_I) {
  874: 		/* See beginning of file for comment on the use of CBI with CCI */
  875: 		sc->proto = (sc->proto & ~UMASS_PROTO_CBI_I) | UMASS_PROTO_CBI;
  876: 	}
  877: #endif
  878: 
  879: 	if (sc->quirks & ALT_IFACE_1) {
  880: 		err = usbd_set_interface(0, 1);
  881: 		if (err) {
  882: 			DPRINTF(UDMASS_USB, ("%s: could not switch to "
  883: 				"Alt Interface %d\n",
  884: 				USBDEVNAME(sc->sc_dev), 1));
  885: 			umass_detach(self);
  886: 			USB_ATTACH_ERROR_RETURN;
  887: 		}
  888: 	}
  889: 
  890: 	/*
  891: 	 * In addition to the Control endpoint the following endpoints
  892: 	 * are required:
  893: 	 * a) bulk-in endpoint.
  894: 	 * b) bulk-out endpoint.
  895: 	 * and for Control/Bulk/Interrupt with CCI (CBI_I)
  896: 	 * c) intr-in
  897: 	 *
  898: 	 * The endpoint addresses are not fixed, so we have to read them
  899: 	 * from the device descriptors of the current interface.
  900: 	 */
  901: 	for (i = 0 ; i < id->bNumEndpoints ; i++) {
  902: 		ed = usbd_interface2endpoint_descriptor(sc->iface, i);
  903: 		if (!ed) {
  904: 			printf("%s: could not read endpoint descriptor\n",
  905: 			       USBDEVNAME(sc->sc_dev));
  906: 			USB_ATTACH_ERROR_RETURN;
  907: 		}
  908: 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
  909: 		    && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
  910: 			sc->bulkin = ed->bEndpointAddress;
  911: 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
  912: 		    && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
  913: 			sc->bulkout = ed->bEndpointAddress;
  914: 		} else if (sc->proto & UMASS_PROTO_CBI_I
  915: 		    && UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
  916: 		    && (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
  917: 			sc->intrin = ed->bEndpointAddress;
  918: #ifdef USB_DEBUG
  919: 			if (UGETW(ed->wMaxPacketSize) > 2) {
  920: 				DPRINTF(UDMASS_CBI, ("%s: intr size is %d\n",
  921: 					USBDEVNAME(sc->sc_dev),
  922: 					UGETW(ed->wMaxPacketSize)));
  923: 			}
  924: #endif
  925: 		}
  926: 	}
  927: 
  928: 	/* check whether we found all the endpoints we need */
  929: 	if (!sc->bulkin || !sc->bulkout
  930: 	    || (sc->proto & UMASS_PROTO_CBI_I && !sc->intrin) ) {
  931: 	    	DPRINTF(UDMASS_USB, ("%s: endpoint not found %d/%d/%d\n",
  932: 			USBDEVNAME(sc->sc_dev),
  933: 			sc->bulkin, sc->bulkout, sc->intrin));
  934: 		umass_detach(self);
  935: 		USB_ATTACH_ERROR_RETURN;
  936: 	}
  937: 
  938: 	/* Open the bulk-in and -out pipe */
  939: 	err = usbd_open_pipe(sc->iface, sc->bulkout,
  940: 				USBD_EXCLUSIVE_USE, &sc->bulkout_pipe);
  941: 	if (err) {
  942: 		DPRINTF(UDMASS_USB, ("%s: cannot open %d-out pipe (bulk)\n",
  943: 			USBDEVNAME(sc->sc_dev), sc->bulkout));
  944: 		umass_detach(self);
  945: 		USB_ATTACH_ERROR_RETURN;
  946: 	}
  947: 	err = usbd_open_pipe(sc->iface, sc->bulkin,
  948: 				USBD_EXCLUSIVE_USE, &sc->bulkin_pipe);
  949: 	if (err) {
  950: 		DPRINTF(UDMASS_USB, ("%s: could not open %d-in pipe (bulk)\n",
  951: 			USBDEVNAME(sc->sc_dev), sc->bulkin));
  952: 		umass_detach(self);
  953: 		USB_ATTACH_ERROR_RETURN;
  954: 	}
  955: 	/* Open the intr-in pipe if the protocol is CBI with CCI.
  956: 	 * Note: early versions of the Zip drive do have an interrupt pipe, but
  957: 	 * this pipe is unused
  958: 	 *
  959: 	 * We do not open the interrupt pipe as an interrupt pipe, but as a
  960: 	 * normal bulk endpoint. We send an IN transfer down the wire at the
  961: 	 * appropriate time, because we know exactly when to expect data on
  962: 	 * that endpoint. This saves bandwidth, but more important, makes the
  963: 	 * code for handling the data on that endpoint simpler. No data
  964: 	 * arriving concurently.
  965: 	 */
  966: 	if (sc->proto & UMASS_PROTO_CBI_I) {
  967: 		err = usbd_open_pipe(sc->iface, sc->intrin,
  968: 				USBD_EXCLUSIVE_USE, &sc->intrin_pipe);
  969: 		if (err) {
  970: 			DPRINTF(UDMASS_USB, ("%s: couldn't open %d-in (intr)\n",
  971: 				USBDEVNAME(sc->sc_dev), sc->intrin));
  972: 			umass_detach(self);
  973: 			USB_ATTACH_ERROR_RETURN;
  974: 		}
  975: 	}
  976: 
  977: 	/* initialisation of generic part */
  978: 	sc->transfer_state = TSTATE_ATTACH;
  979: 
  980: 	/* request a sufficient number of xfer handles */
  981: 	for (i = 0; i < XFER_NR; i++) {
  982: 		sc->transfer_xfer[i] = usbd_alloc_xfer(uaa->device);
  983: 		if (!sc->transfer_xfer[i]) {
  984: 			DPRINTF(UDMASS_USB, ("%s: Out of memory\n",
  985: 				USBDEVNAME(sc->sc_dev)));
  986: 			umass_detach(self);
  987: 			USB_ATTACH_ERROR_RETURN;
  988: 		}
  989: 	}
  990: 
  991: 	/* Initialise the wire protocol specific methods */
  992: 	if (sc->proto & UMASS_PROTO_BBB) {
  993: 		sc->reset = umass_bbb_reset;
  994: 		sc->transfer = umass_bbb_transfer;
  995: 		sc->state = umass_bbb_state;
  996: 	} else if (sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I)) {
  997: 		sc->reset = umass_cbi_reset;
  998: 		sc->transfer = umass_cbi_transfer;
  999: 		sc->state = umass_cbi_state;
 1000: #ifdef USB_DEBUG
 1001: 	} else {
 1002: 		panic("%s:%d: Unknown proto 0x%02x",
 1003: 		      __FILE__, __LINE__, sc->proto);
 1004: #endif
 1005: 	}
 1006: 
 1007: 	if (sc->proto & UMASS_PROTO_SCSI)
 1008: 		sc->transform = umass_scsi_transform;
 1009: 	else if (sc->proto & UMASS_PROTO_UFI)
 1010: 		sc->transform = umass_ufi_transform;
 1011: 	else if (sc->proto & UMASS_PROTO_ATAPI)
 1012: 		sc->transform = umass_atapi_transform;
 1013: 	else if (sc->proto & UMASS_PROTO_RBC)
 1014: 		sc->transform = umass_rbc_transform;
 1015: #ifdef USB_DEBUG
 1016: 	else
 1017: 		panic("No transformation defined for command proto 0x%02x",
 1018: 		      sc->proto & UMASS_PROTO_COMMAND);
 1019: #endif
 1020: 
 1021: 	/* From here onwards the device can be used. */
 1022: 
 1023: 	if (sc->quirks & SHUTTLE_INIT)
 1024: 		umass_init_shuttle(sc);
 1025: 
 1026: 	/* Get the maximum LUN supported by the device.
 1027: 	 */
 1028: 	if ((sc->proto & UMASS_PROTO_WIRE) == UMASS_PROTO_BBB)
 1029: 		sc->maxlun = umass_bbb_get_max_lun(sc);
 1030: 	else
 1031: 		sc->maxlun = 0;
 1032: 
 1033: 	if ((sc->proto & UMASS_PROTO_SCSI) ||
 1034: 	    (sc->proto & UMASS_PROTO_ATAPI) ||
 1035: 	    (sc->proto & UMASS_PROTO_UFI) ||
 1036: 	    (sc->proto & UMASS_PROTO_RBC)) {
 1037: 		/* Prepare the SCSI command block */
 1038: 		sc->cam_scsi_sense.opcode = REQUEST_SENSE;
 1039: 		sc->cam_scsi_test_unit_ready.opcode = TEST_UNIT_READY;
 1040: 
 1041: 		/* register the SIM */
 1042: 		err = umass_cam_attach_sim(sc);
 1043: 		if (err) {
 1044: 			umass_detach(self);
 1045: 			USB_ATTACH_ERROR_RETURN;
 1046: 		}
 1047: 		/* scan the new sim */
 1048: 		err = umass_cam_attach(sc);
 1049: 		if (err) {
 1050: 			umass_cam_detach_sim(sc);
 1051: 			umass_detach(self);
 1052: 			USB_ATTACH_ERROR_RETURN;
 1053: 		}
 1054: 	} else {
 1055: 		panic("%s:%d: Unknown proto 0x%02x",
 1056: 		      __FILE__, __LINE__, sc->proto);
 1057: 	}
 1058: 
 1059: 	sc->transfer_state = TSTATE_IDLE;
 1060: 	DPRINTF(UDMASS_GEN, ("%s: Attach finished\n", USBDEVNAME(sc->sc_dev)));
 1061: 
 1062: 	USB_ATTACH_SUCCESS_RETURN;
 1063: }
 1064: 
 1065: USB_DETACH(umass)
 1066: {
 1067: 	USB_DETACH_START(umass, sc);
 1068: 	int err = 0;
 1069: 	int i;
 1070: 
 1071: 	DPRINTF(UDMASS_USB, ("%s: detached\n", USBDEVNAME(sc->sc_dev)));
 1072: 
 1073: 	sc->flags |= UMASS_FLAGS_GONE;
 1074: 
 1075: 	if ((sc->proto & UMASS_PROTO_SCSI) ||
 1076: 	    (sc->proto & UMASS_PROTO_ATAPI) ||
 1077: 	    (sc->proto & UMASS_PROTO_UFI) ||
 1078: 	    (sc->proto & UMASS_PROTO_RBC))
 1079: 		/* detach the SCSI host controller (SIM) */
 1080: 		err = umass_cam_detach_sim(sc);
 1081: 
 1082: 	for (i = 0; i < XFER_NR; i++)
 1083: 		if (sc->transfer_xfer[i])
 1084: 			usbd_free_xfer(sc->transfer_xfer[i]);
 1085: 
 1086: 	/* remove all the pipes */
 1087: 	if (sc->bulkout_pipe)
 1088: 		usbd_close_pipe(sc->bulkout_pipe);
 1089: 	if (sc->bulkin_pipe)
 1090: 		usbd_close_pipe(sc->bulkin_pipe);
 1091: 	if (sc->intrin_pipe)
 1092: 		usbd_close_pipe(sc->intrin_pipe);
 1093: 
 1094: 	return(err);
 1095: }
 1096: 
 1097: Static void
 1098: umass_init_shuttle(struct umass_softc *sc)
 1099: {
 1100: 	usb_device_request_t req;
 1101: 	u_char status[2];
 1102: 
 1103: 	/* The Linux driver does this, but no one can tell us what the
 1104: 	 * command does.
 1105: 	 */
 1106: 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 1107: 	req.bRequest = 1;	/* XXX unknown command */
 1108: 	USETW(req.wValue, 0);
 1109: 	USETW(req.wIndex, sc->ifaceno);
 1110: 	USETW(req.wLength, sizeof status);
 1111: 	(void) usbd_do_request(sc->sc_udev, &req, &status);
 1112: 
 1113: 	DPRINTF(UDMASS_GEN, ("%s: Shuttle init returned 0x%02x%02x\n",
 1114: 		USBDEVNAME(sc->sc_dev), status[0], status[1]));
 1115: }
 1116: 
 1117:  /*
 1118:  * Generic functions to handle transfers
 1119:  */
 1120: 
 1121: Static usbd_status
 1122: umass_setup_transfer(struct umass_softc *sc, usbd_pipe_handle pipe,
 1123: 			void *buffer, int buflen, int flags,
 1124: 			usbd_xfer_handle xfer)
 1125: {
 1126: 	usbd_status err;
 1127: 
 1128: 	/* Initialiase a USB transfer and then schedule it */
 1129: 
 1130: 	(void) usbd_setup_xfer(xfer, pipe, (void *) sc, buffer, buflen, flags,
 1131: 			UMASS_TIMEOUT, sc->state);
 1132: 
 1133: 	err = usbd_transfer(xfer);
 1134: 	if (err && err != USBD_IN_PROGRESS) {
 1135: 		DPRINTF(UDMASS_BBB, ("%s: failed to setup transfer, %s\n",
 1136: 			USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
 1137: 		return(err);
 1138: 	}
 1139: 
 1140: 	return (USBD_NORMAL_COMPLETION);
 1141: }
 1142: 
 1143: 
 1144: Static usbd_status
 1145: umass_setup_ctrl_transfer(struct umass_softc *sc, usbd_device_handle udev,
 1146: 	 usb_device_request_t *req,
 1147: 	 void *buffer, int buflen, int flags,
 1148: 	 usbd_xfer_handle xfer)
 1149: {
 1150: 	usbd_status err;
 1151: 
 1152: 	/* Initialiase a USB control transfer and then schedule it */
 1153: 
 1154: 	(void) usbd_setup_default_xfer(xfer, udev, (void *) sc,
 1155: 			UMASS_TIMEOUT, req, buffer, buflen, flags, sc->state);
 1156: 
 1157: 	err = usbd_transfer(xfer);
 1158: 	if (err && err != USBD_IN_PROGRESS) {
 1159: 		DPRINTF(UDMASS_BBB, ("%s: failed to setup ctrl transfer, %s\n",
 1160: 			 USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
 1161: 
 1162: 		/* do not reset, as this would make us loop */
 1163: 		return(err);
 1164: 	}
 1165: 
 1166: 	return (USBD_NORMAL_COMPLETION);
 1167: }
 1168: 
 1169: Static void
 1170: umass_clear_endpoint_stall(struct umass_softc *sc,
 1171: 				u_int8_t endpt, usbd_pipe_handle pipe,
 1172: 				int state, usbd_xfer_handle xfer)
 1173: {
 1174: 	usbd_device_handle udev;
 1175: 
 1176: 	DPRINTF(UDMASS_BBB, ("%s: Clear endpoint 0x%02x stall\n",
 1177: 		USBDEVNAME(sc->sc_dev), endpt));
 1178: 
 1179: 	usbd_interface2device_handle(sc->iface, &udev);
 1180: 
 1181: 	sc->transfer_state = state;
 1182: 
 1183: 	usbd_clear_endpoint_toggle(pipe);
 1184: 
 1185: 	sc->request.bmRequestType = UT_WRITE_ENDPOINT;
 1186: 	sc->request.bRequest = UR_CLEAR_FEATURE;
 1187: 	USETW(sc->request.wValue, UF_ENDPOINT_HALT);
 1188: 	USETW(sc->request.wIndex, endpt);
 1189: 	USETW(sc->request.wLength, 0);
 1190: 	umass_setup_ctrl_transfer(sc, udev, &sc->request, NULL, 0, 0, xfer);
 1191: }
 1192: 
 1193: Static void
 1194: umass_reset(struct umass_softc *sc, transfer_cb_f cb, void *priv)
 1195: {
 1196: 	sc->transfer_cb = cb;
 1197: 	sc->transfer_priv = priv;
 1198: 
 1199: 	/* The reset is a forced reset, so no error (yet) */
 1200: 	sc->reset(sc, STATUS_CMD_OK);
 1201: }
 1202: 
 1203: /*
 1204:  * Bulk protocol specific functions
 1205:  */
 1206: 
 1207: Static void
 1208: umass_bbb_reset(struct umass_softc *sc, int status)
 1209: {
 1210: 	usbd_device_handle udev;
 1211: 
 1212: 	KASSERT(sc->proto & UMASS_PROTO_BBB,
 1213: 		("%s: umass_bbb_reset: wrong sc->proto 0x%02x\n",
 1214: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1215: 
 1216: 	/*
 1217: 	 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
 1218: 	 *
 1219: 	 * For Reset Recovery the host shall issue in the following order:
 1220: 	 * a) a Bulk-Only Mass Storage Reset
 1221: 	 * b) a Clear Feature HALT to the Bulk-In endpoint
 1222: 	 * c) a Clear Feature HALT to the Bulk-Out endpoint
 1223: 	 *
 1224: 	 * This is done in 3 steps, states:
 1225: 	 * TSTATE_BBB_RESET1
 1226: 	 * TSTATE_BBB_RESET2
 1227: 	 * TSTATE_BBB_RESET3
 1228: 	 *
 1229: 	 * If the reset doesn't succeed, the device should be port reset.
 1230: 	 */
 1231: 
 1232: 	DPRINTF(UDMASS_BBB, ("%s: Bulk Reset\n",
 1233: 		USBDEVNAME(sc->sc_dev)));
 1234: 
 1235: 	sc->transfer_state = TSTATE_BBB_RESET1;
 1236: 	sc->transfer_status = status;
 1237: 
 1238: 	usbd_interface2device_handle(sc->iface, &udev);
 1239: 
 1240: 	/* reset is a class specific interface write */
 1241: 	sc->request.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 1242: 	sc->request.bRequest = UR_BBB_RESET;
 1243: 	USETW(sc->request.wValue, 0);
 1244: 	USETW(sc->request.wIndex, sc->ifaceno);
 1245: 	USETW(sc->request.wLength, 0);
 1246: 	umass_setup_ctrl_transfer(sc, udev, &sc->request, NULL, 0, 0,
 1247: 				  sc->transfer_xfer[XFER_BBB_RESET1]);
 1248: }
 1249: 
 1250: Static void
 1251: umass_bbb_transfer(struct umass_softc *sc, int lun, void *cmd, int cmdlen,
 1252: 		    void *data, int datalen, int dir,
 1253: 		    transfer_cb_f cb, void *priv)
 1254: {
 1255: 	KASSERT(sc->proto & UMASS_PROTO_BBB,
 1256: 		("%s: umass_bbb_transfer: wrong sc->proto 0x%02x\n",
 1257: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1258: 
 1259: 	/*
 1260: 	 * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly
 1261: 	 * a data phase of datalen bytes from/to the device and finally a
 1262: 	 * csw read phase.
 1263: 	 * If the data direction was inbound a maximum of datalen bytes
 1264: 	 * is stored in the buffer pointed to by data.
 1265: 	 *
 1266: 	 * umass_bbb_transfer initialises the transfer and lets the state
 1267: 	 * machine in umass_bbb_state handle the completion. It uses the
 1268: 	 * following states:
 1269: 	 * TSTATE_BBB_COMMAND
 1270: 	 *   -> TSTATE_BBB_DATA
 1271: 	 *   -> TSTATE_BBB_STATUS
 1272: 	 *   -> TSTATE_BBB_STATUS2
 1273: 	 *   -> TSTATE_BBB_IDLE
 1274: 	 *
 1275: 	 * An error in any of those states will invoke
 1276: 	 * umass_bbb_reset.
 1277: 	 */
 1278: 
 1279: 	/* check the given arguments */
 1280: 	KASSERT(datalen == 0 || data != NULL,
 1281: 		("%s: datalen > 0, but no buffer",USBDEVNAME(sc->sc_dev)));
 1282: 	KASSERT(cmdlen <= CBWCDBLENGTH,
 1283: 		("%s: cmdlen exceeds CDB length in CBW (%d > %d)",
 1284: 			USBDEVNAME(sc->sc_dev), cmdlen, CBWCDBLENGTH));
 1285: 	KASSERT(dir == DIR_NONE || datalen > 0,
 1286: 		("%s: datalen == 0 while direction is not NONE\n",
 1287: 			USBDEVNAME(sc->sc_dev)));
 1288: 	KASSERT(datalen == 0 || dir != DIR_NONE,
 1289: 		("%s: direction is NONE while datalen is not zero\n",
 1290: 			USBDEVNAME(sc->sc_dev)));
 1291: 	KASSERT(sizeof(umass_bbb_cbw_t) == UMASS_BBB_CBW_SIZE,
 1292: 		("%s: CBW struct does not have the right size (%ld vs. %d)\n",
 1293: 			USBDEVNAME(sc->sc_dev),
 1294: 			(long)sizeof(umass_bbb_cbw_t), UMASS_BBB_CBW_SIZE));
 1295: 	KASSERT(sizeof(umass_bbb_csw_t) == UMASS_BBB_CSW_SIZE,
 1296: 		("%s: CSW struct does not have the right size (%ld vs. %d)\n",
 1297: 			USBDEVNAME(sc->sc_dev),
 1298: 			(long)sizeof(umass_bbb_csw_t), UMASS_BBB_CSW_SIZE));
 1299: 
 1300: 	/*
 1301: 	 * Determine the direction of the data transfer and the length.
 1302: 	 *
 1303: 	 * dCBWDataTransferLength (datalen) :
 1304: 	 *   This field indicates the number of bytes of data that the host
 1305: 	 *   intends to transfer on the IN or OUT Bulk endpoint(as indicated by
 1306: 	 *   the Direction bit) during the execution of this command. If this
 1307: 	 *   field is set to 0, the device will expect that no data will be
 1308: 	 *   transferred IN or OUT during this command, regardless of the value
 1309: 	 *   of the Direction bit defined in dCBWFlags.
 1310: 	 *
 1311: 	 * dCBWFlags (dir) :
 1312: 	 *   The bits of the Flags field are defined as follows:
 1313: 	 *     Bits 0-6  reserved
 1314: 	 *     Bit  7    Direction - this bit shall be ignored if the
 1315: 	 *                           dCBWDataTransferLength field is zero.
 1316: 	 *               0 = data Out from host to device
 1317: 	 *               1 = data In from device to host
 1318: 	 */
 1319: 
 1320: 	/* Fill in the Command Block Wrapper
 1321: 	 * We fill in all the fields, so there is no need to bzero it first.
 1322: 	 */
 1323: 	USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE);
 1324: 	/* We don't care about the initial value, as long as the values are unique */
 1325: 	USETDW(sc->cbw.dCBWTag, UGETDW(sc->cbw.dCBWTag) + 1);
 1326: 	USETDW(sc->cbw.dCBWDataTransferLength, datalen);
 1327: 	/* DIR_NONE is treated as DIR_OUT (0x00) */
 1328: 	sc->cbw.bCBWFlags = (dir == DIR_IN? CBWFLAGS_IN:CBWFLAGS_OUT);
 1329: 	sc->cbw.bCBWLUN = lun;
 1330: 	sc->cbw.bCDBLength = cmdlen;
 1331: 	bcopy(cmd, sc->cbw.CBWCDB, cmdlen);
 1332: 
 1333: 	DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw));
 1334: 
 1335: 	/* store the details for the data transfer phase */
 1336: 	sc->transfer_dir = dir;
 1337: 	sc->transfer_data = data;
 1338: 	sc->transfer_datalen = datalen;
 1339: 	sc->transfer_actlen = 0;
 1340: 	sc->transfer_cb = cb;
 1341: 	sc->transfer_priv = priv;
 1342: 	sc->transfer_status = STATUS_CMD_OK;
 1343: 
 1344: 	/* move from idle to the command state */
 1345: 	sc->transfer_state = TSTATE_BBB_COMMAND;
 1346: 
 1347: 	/* Send the CBW from host to device via bulk-out endpoint. */
 1348: 	if (umass_setup_transfer(sc, sc->bulkout_pipe,
 1349: 			&sc->cbw, UMASS_BBB_CBW_SIZE, 0,
 1350: 			sc->transfer_xfer[XFER_BBB_CBW])) {
 1351: 		umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1352: 	}
 1353: }
 1354: 
 1355: 
 1356: Static void
 1357: umass_bbb_state(usbd_xfer_handle xfer, usbd_private_handle priv,
 1358: 		usbd_status err)
 1359: {
 1360: 	struct umass_softc *sc = (struct umass_softc *) priv;
 1361: 	usbd_xfer_handle next_xfer;
 1362: 
 1363: 	KASSERT(sc->proto & UMASS_PROTO_BBB,
 1364: 		("%s: umass_bbb_state: wrong sc->proto 0x%02x\n",
 1365: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1366: 
 1367: 	/*
 1368: 	 * State handling for BBB transfers.
 1369: 	 *
 1370: 	 * The subroutine is rather long. It steps through the states given in
 1371: 	 * Annex A of the Bulk-Only specification.
 1372: 	 * Each state first does the error handling of the previous transfer
 1373: 	 * and then prepares the next transfer.
 1374: 	 * Each transfer is done asynchroneously so after the request/transfer
 1375: 	 * has been submitted you will find a 'return;'.
 1376: 	 */
 1377: 
 1378: 	DPRINTF(UDMASS_BBB, ("%s: Handling BBB state %d (%s), xfer=%p, %s\n",
 1379: 		USBDEVNAME(sc->sc_dev), sc->transfer_state,
 1380: 		states[sc->transfer_state], xfer, usbd_errstr(err)));
 1381: 
 1382: 	switch (sc->transfer_state) {
 1383: 
 1384: 	/***** Bulk Transfer *****/
 1385: 	case TSTATE_BBB_COMMAND:
 1386: 		/* Command transport phase, error handling */
 1387: 		if (err) {
 1388: 			DPRINTF(UDMASS_BBB, ("%s: failed to send CBW\n",
 1389: 				USBDEVNAME(sc->sc_dev)));
 1390: 			/* If the device detects that the CBW is invalid, then
 1391: 			 * the device may STALL both bulk endpoints and require
 1392: 			 * a Bulk-Reset
 1393: 			 */
 1394: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1395: 			return;
 1396: 		}
 1397: 
 1398: 		/* Data transport phase, setup transfer */
 1399: 		sc->transfer_state = TSTATE_BBB_DATA;
 1400: 		if (sc->transfer_dir == DIR_IN) {
 1401: 			if (umass_setup_transfer(sc, sc->bulkin_pipe,
 1402: 					sc->transfer_data, sc->transfer_datalen,
 1403: 					USBD_SHORT_XFER_OK,
 1404: 					sc->transfer_xfer[XFER_BBB_DATA]))
 1405: 				umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1406: 
 1407: 			return;
 1408: 		} else if (sc->transfer_dir == DIR_OUT) {
 1409: 			if (umass_setup_transfer(sc, sc->bulkout_pipe,
 1410: 					sc->transfer_data, sc->transfer_datalen,
 1411: 					0,	/* fixed length transfer */
 1412: 					sc->transfer_xfer[XFER_BBB_DATA]))
 1413: 				umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1414: 
 1415: 			return;
 1416: 		} else {
 1417: 			DPRINTF(UDMASS_BBB, ("%s: no data phase\n",
 1418: 				USBDEVNAME(sc->sc_dev)));
 1419: 		}
 1420: 
 1421: 		/* FALLTHROUGH if no data phase, err == 0 */
 1422: 	case TSTATE_BBB_DATA:
 1423: 		/* Command transport phase, error handling (ignored if no data
 1424: 		 * phase (fallthrough from previous state)) */
 1425: 		if (sc->transfer_dir != DIR_NONE) {
 1426: 			/* retrieve the length of the transfer that was done */
 1427: 			usbd_get_xfer_status(xfer, NULL, NULL,
 1428: 						&sc->transfer_actlen, NULL);
 1429: 
 1430: 			if (err) {
 1431: 				DPRINTF(UDMASS_BBB, ("%s: Data-%s %db failed, "
 1432: 					"%s\n", USBDEVNAME(sc->sc_dev),
 1433: 					(sc->transfer_dir == DIR_IN?"in":"out"),
 1434: 					sc->transfer_datalen,usbd_errstr(err)));
 1435: 
 1436: 				if (err == USBD_STALLED) {
 1437: 					umass_clear_endpoint_stall(sc,
 1438: 					  (sc->transfer_dir == DIR_IN?
 1439: 					    sc->bulkin:sc->bulkout),
 1440: 					  (sc->transfer_dir == DIR_IN?
 1441: 					    sc->bulkin_pipe:sc->bulkout_pipe),
 1442: 					  TSTATE_BBB_DCLEAR,
 1443: 					  sc->transfer_xfer[XFER_BBB_DCLEAR]);
 1444: 					return;
 1445: 				} else {
 1446: 					/* Unless the error is a pipe stall the
 1447: 					 * error is fatal.
 1448: 					 */
 1449: 					umass_bbb_reset(sc,STATUS_WIRE_FAILED);
 1450: 					return;
 1451: 				}
 1452: 			}
 1453: 		}
 1454: 
 1455: 		DIF(UDMASS_BBB, if (sc->transfer_dir == DIR_IN)
 1456: 					umass_dump_buffer(sc, sc->transfer_data,
 1457: 						sc->transfer_datalen, 48));
 1458: 
 1459: 
 1460: 
 1461: 		/* FALLTHROUGH, err == 0 (no data phase or successfull) */
 1462: 	case TSTATE_BBB_DCLEAR:	/* stall clear after data phase */
 1463: 	case TSTATE_BBB_SCLEAR:	/* stall clear after status phase */
 1464: 		/* Reading of CSW after bulk stall condition in data phase
 1465: 		 * (TSTATE_BBB_DATA2) or bulk-in stall condition after
 1466: 		 * reading CSW (TSTATE_BBB_SCLEAR).
 1467: 		 * In the case of no data phase or successfull data phase,
 1468: 		 * err == 0 and the following if block is passed.
 1469: 		 */
 1470: 		if (err) {	/* should not occur */
 1471: 			/* try the transfer below, even if clear stall failed */
 1472: 			DPRINTF(UDMASS_BBB, ("%s: bulk-%s stall clear failed"
 1473: 				", %s\n", USBDEVNAME(sc->sc_dev),
 1474: 				(sc->transfer_dir == DIR_IN? "in":"out"),
 1475: 				usbd_errstr(err)));
 1476: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1477: 			return;
 1478: 		}
 1479: 
 1480: 		/* Status transport phase, setup transfer */
 1481: 		if (sc->transfer_state == TSTATE_BBB_COMMAND ||
 1482: 		    sc->transfer_state == TSTATE_BBB_DATA ||
 1483: 		    sc->transfer_state == TSTATE_BBB_DCLEAR) {
 1484: 		    	/* After no data phase, successfull data phase and
 1485: 			 * after clearing bulk-in/-out stall condition
 1486: 			 */
 1487: 			sc->transfer_state = TSTATE_BBB_STATUS1;
 1488: 			next_xfer = sc->transfer_xfer[XFER_BBB_CSW1];
 1489: 		} else {
 1490: 			/* After first attempt of fetching CSW */
 1491: 			sc->transfer_state = TSTATE_BBB_STATUS2;
 1492: 			next_xfer = sc->transfer_xfer[XFER_BBB_CSW2];
 1493: 		}
 1494: 
 1495: 		/* Read the Command Status Wrapper via bulk-in endpoint. */
 1496: 		if (umass_setup_transfer(sc, sc->bulkin_pipe,
 1497: 				&sc->csw, UMASS_BBB_CSW_SIZE, 0,
 1498: 				next_xfer)) {
 1499: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1500: 			return;
 1501: 		}
 1502: 
 1503: 		return;
 1504: 	case TSTATE_BBB_STATUS1:	/* first attempt */
 1505: 	case TSTATE_BBB_STATUS2:	/* second attempt */
 1506: 		/* Status transfer, error handling */
 1507: 		{
 1508: 		int Residue;
 1509: 		if (err) {
 1510: 			DPRINTF(UDMASS_BBB, ("%s: Failed to read CSW, %s%s\n",
 1511: 				USBDEVNAME(sc->sc_dev), usbd_errstr(err),
 1512: 				(sc->transfer_state == TSTATE_BBB_STATUS1?
 1513: 					", retrying":"")));
 1514: 
 1515: 			/* If this was the first attempt at fetching the CSW
 1516: 			 * retry it, otherwise fail.
 1517: 			 */
 1518: 			if (sc->transfer_state == TSTATE_BBB_STATUS1) {
 1519: 				umass_clear_endpoint_stall(sc,
 1520: 					    sc->bulkin, sc->bulkin_pipe,
 1521: 					    TSTATE_BBB_SCLEAR,
 1522: 					    sc->transfer_xfer[XFER_BBB_SCLEAR]);
 1523: 				return;
 1524: 			} else {
 1525: 				umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1526: 				return;
 1527: 			}
 1528: 		}
 1529: 
 1530: 		DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw));
 1531: 
 1532: 		/* Translate weird command-status signatures. */
 1533: 		if ((sc->quirks & WRONG_CSWSIG) &&
 1534: 		    UGETDW(sc->csw.dCSWSignature) == CSWSIGNATURE_OLYMPUS_C1)
 1535: 			USETDW(sc->csw.dCSWSignature, CSWSIGNATURE);
 1536: 
 1537: 		Residue = UGETDW(sc->csw.dCSWDataResidue);
 1538: 		if (Residue == 0 &&
 1539: 		    sc->transfer_datalen - sc->transfer_actlen != 0)
 1540: 			Residue = sc->transfer_datalen - sc->transfer_actlen;
 1541: 
 1542: 		/* Check CSW and handle any error */
 1543: 		if (UGETDW(sc->csw.dCSWSignature) != CSWSIGNATURE) {
 1544: 			/* Invalid CSW: Wrong signature or wrong tag might
 1545: 			 * indicate that the device is confused -> reset it.
 1546: 			 */
 1547: 			printf("%s: Invalid CSW: sig 0x%08x should be 0x%08x\n",
 1548: 				USBDEVNAME(sc->sc_dev),
 1549: 				UGETDW(sc->csw.dCSWSignature),
 1550: 				CSWSIGNATURE);
 1551: 
 1552: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1553: 			return;
 1554: 		} else if (UGETDW(sc->csw.dCSWTag)
 1555: 				!= UGETDW(sc->cbw.dCBWTag)) {
 1556: 			printf("%s: Invalid CSW: tag %d should be %d\n",
 1557: 				USBDEVNAME(sc->sc_dev),
 1558: 				UGETDW(sc->csw.dCSWTag),
 1559: 				UGETDW(sc->cbw.dCBWTag));
 1560: 
 1561: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1562: 			return;
 1563: 
 1564: 		/* CSW is valid here */
 1565: 		} else if (sc->csw.bCSWStatus > CSWSTATUS_PHASE) {
 1566: 			printf("%s: Invalid CSW: status %d > %d\n",
 1567: 				USBDEVNAME(sc->sc_dev),
 1568: 				sc->csw.bCSWStatus,
 1569: 				CSWSTATUS_PHASE);
 1570: 
 1571: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1572: 			return;
 1573: 		} else if (sc->csw.bCSWStatus == CSWSTATUS_PHASE) {
 1574: 			printf("%s: Phase Error, residue = %d\n",
 1575: 				USBDEVNAME(sc->sc_dev), Residue);
 1576: 
 1577: 			umass_bbb_reset(sc, STATUS_WIRE_FAILED);
 1578: 			return;
 1579: 
 1580: 		} else if (sc->transfer_actlen > sc->transfer_datalen) {
 1581: 			/* Buffer overrun! Don't let this go by unnoticed */
 1582: 			panic("%s: transferred %db instead of %db",
 1583: 				USBDEVNAME(sc->sc_dev),
 1584: 				sc->transfer_actlen, sc->transfer_datalen);
 1585: 
 1586: 		} else if (sc->csw.bCSWStatus == CSWSTATUS_FAILED) {
 1587: 			DPRINTF(UDMASS_BBB, ("%s: Command Failed, res = %d\n",
 1588: 				USBDEVNAME(sc->sc_dev), Residue));
 1589: 
 1590: 			/* SCSI command failed but transfer was succesful */
 1591: 			sc->transfer_state = TSTATE_IDLE;
 1592: 			sc->transfer_cb(sc, sc->transfer_priv, Residue,
 1593: 					STATUS_CMD_FAILED);
 1594: 			return;
 1595: 
 1596: 		} else {	/* success */
 1597: 			sc->transfer_state = TSTATE_IDLE;
 1598: 			sc->transfer_cb(sc, sc->transfer_priv, Residue,
 1599: 					STATUS_CMD_OK);
 1600: 
 1601: 			return;
 1602: 		}
 1603: 		}
 1604: 
 1605: 	/***** Bulk Reset *****/
 1606: 	case TSTATE_BBB_RESET1:
 1607: 		if (err)
 1608: 			printf("%s: BBB reset failed, %s\n",
 1609: 				USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 1610: 
 1611: 		umass_clear_endpoint_stall(sc,
 1612: 			sc->bulkin, sc->bulkin_pipe, TSTATE_BBB_RESET2,
 1613: 			sc->transfer_xfer[XFER_BBB_RESET2]);
 1614: 
 1615: 		return;
 1616: 	case TSTATE_BBB_RESET2:
 1617: 		if (err)	/* should not occur */
 1618: 			printf("%s: BBB bulk-in clear stall failed, %s\n",
 1619: 			       USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 1620: 			/* no error recovery, otherwise we end up in a loop */
 1621: 
 1622: 		umass_clear_endpoint_stall(sc,
 1623: 			sc->bulkout, sc->bulkout_pipe, TSTATE_BBB_RESET3,
 1624: 			sc->transfer_xfer[XFER_BBB_RESET3]);
 1625: 
 1626: 		return;
 1627: 	case TSTATE_BBB_RESET3:
 1628: 		if (err)	/* should not occur */
 1629: 			printf("%s: BBB bulk-out clear stall failed, %s\n",
 1630: 			       USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 1631: 			/* no error recovery, otherwise we end up in a loop */
 1632: 
 1633: 		sc->transfer_state = TSTATE_IDLE;
 1634: 		if (sc->transfer_priv) {
 1635: 			sc->transfer_cb(sc, sc->transfer_priv,
 1636: 					sc->transfer_datalen,
 1637: 					sc->transfer_status);
 1638: 		}
 1639: 
 1640: 		return;
 1641: 
 1642: 	/***** Default *****/
 1643: 	default:
 1644: 		panic("%s: Unknown state %d",
 1645: 		      USBDEVNAME(sc->sc_dev), sc->transfer_state);
 1646: 	}
 1647: }
 1648: 
 1649: Static int
 1650: umass_bbb_get_max_lun(struct umass_softc *sc)
 1651: {
 1652: 	usbd_device_handle udev;
 1653: 	usb_device_request_t req;
 1654: 	usbd_status err;
 1655: 	usb_interface_descriptor_t *id;
 1656: 	int maxlun = 0;
 1657: 	u_int8_t buf = 0;
 1658: 
 1659: 	usbd_interface2device_handle(sc->iface, &udev);
 1660: 	id = usbd_get_interface_descriptor(sc->iface);
 1661: 
 1662: 	/* The Get Max Lun command is a class-specific request. */
 1663: 	req.bmRequestType = UT_READ_CLASS_INTERFACE;
 1664: 	req.bRequest = UR_BBB_GET_MAX_LUN;
 1665: 	USETW(req.wValue, 0);
 1666: 	USETW(req.wIndex, id->bInterfaceNumber);
 1667: 	USETW(req.wLength, 1);
 1668: 
 1669: 	err = usbd_do_request(udev, &req, &buf);
 1670: 	switch (err) {
 1671: 	case USBD_NORMAL_COMPLETION:
 1672: 		maxlun = buf;
 1673: 		DPRINTF(UDMASS_BBB, ("%s: Max Lun is %d\n",
 1674: 		    USBDEVNAME(sc->sc_dev), maxlun));
 1675: 		break;
 1676: 	case USBD_STALLED:
 1677: 	case USBD_SHORT_XFER:
 1678: 	default:
 1679: 		/* Device doesn't support Get Max Lun request. */
 1680: 		printf("%s: Get Max Lun not supported (%s)\n",
 1681: 		    USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 1682: 		/* XXX Should we port_reset the device? */
 1683: 		break;
 1684: 	}
 1685: 
 1686: 	return(maxlun);
 1687: }
 1688: 
 1689: /*
 1690:  * Command/Bulk/Interrupt (CBI) specific functions
 1691:  */
 1692: 
 1693: Static int
 1694: umass_cbi_adsc(struct umass_softc *sc, char *buffer, int buflen,
 1695: 	       usbd_xfer_handle xfer)
 1696: {
 1697: 	usbd_device_handle udev;
 1698: 
 1699: 	KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
 1700: 		("%s: umass_cbi_adsc: wrong sc->proto 0x%02x\n",
 1701: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1702: 
 1703: 	usbd_interface2device_handle(sc->iface, &udev);
 1704: 
 1705: 	sc->request.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 1706: 	sc->request.bRequest = UR_CBI_ADSC;
 1707: 	USETW(sc->request.wValue, 0);
 1708: 	USETW(sc->request.wIndex, sc->ifaceno);
 1709: 	USETW(sc->request.wLength, buflen);
 1710: 	return umass_setup_ctrl_transfer(sc, udev, &sc->request, buffer,
 1711: 					 buflen, 0, xfer);
 1712: }
 1713: 
 1714: 
 1715: Static void
 1716: umass_cbi_reset(struct umass_softc *sc, int status)
 1717: {
 1718: 	int i;
 1719: #	define SEND_DIAGNOSTIC_CMDLEN	12
 1720: 
 1721: 	KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
 1722: 		("%s: umass_cbi_reset: wrong sc->proto 0x%02x\n",
 1723: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1724: 
 1725: 	/*
 1726: 	 * Command Block Reset Protocol
 1727: 	 *
 1728: 	 * First send a reset request to the device. Then clear
 1729: 	 * any possibly stalled bulk endpoints.
 1730: 
 1731: 	 * This is done in 3 steps, states:
 1732: 	 * TSTATE_CBI_RESET1
 1733: 	 * TSTATE_CBI_RESET2
 1734: 	 * TSTATE_CBI_RESET3
 1735: 	 *
 1736: 	 * If the reset doesn't succeed, the device should be port reset.
 1737: 	 */
 1738: 
 1739: 	DPRINTF(UDMASS_CBI, ("%s: CBI Reset\n",
 1740: 		USBDEVNAME(sc->sc_dev)));
 1741: 
 1742: 	KASSERT(sizeof(sc->cbl) >= SEND_DIAGNOSTIC_CMDLEN,
 1743: 		("%s: CBL struct is too small (%ld < %d)\n",
 1744: 			USBDEVNAME(sc->sc_dev),
 1745: 			(long)sizeof(sc->cbl), SEND_DIAGNOSTIC_CMDLEN));
 1746: 
 1747: 	sc->transfer_state = TSTATE_CBI_RESET1;
 1748: 	sc->transfer_status = status;
 1749: 
 1750: 	/* The 0x1d code is the SEND DIAGNOSTIC command. To distingiush between
 1751: 	 * the two the last 10 bytes of the cbl is filled with 0xff (section
 1752: 	 * 2.2 of the CBI spec).
 1753: 	 */
 1754: 	sc->cbl[0] = 0x1d;	/* Command Block Reset */
 1755: 	sc->cbl[1] = 0x04;
 1756: 	for (i = 2; i < SEND_DIAGNOSTIC_CMDLEN; i++)
 1757: 		sc->cbl[i] = 0xff;
 1758: 
 1759: 	umass_cbi_adsc(sc, sc->cbl, SEND_DIAGNOSTIC_CMDLEN,
 1760: 		       sc->transfer_xfer[XFER_CBI_RESET1]);
 1761: 	/* XXX if the command fails we should reset the port on the bub */
 1762: }
 1763: 
 1764: Static void
 1765: umass_cbi_transfer(struct umass_softc *sc, int lun,
 1766: 		void *cmd, int cmdlen, void *data, int datalen, int dir,
 1767: 		transfer_cb_f cb, void *priv)
 1768: {
 1769: 	KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
 1770: 		("%s: umass_cbi_transfer: wrong sc->proto 0x%02x\n",
 1771: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1772: 
 1773: 	/*
 1774: 	 * Do a CBI transfer with cmdlen bytes from cmd, possibly
 1775: 	 * a data phase of datalen bytes from/to the device and finally a
 1776: 	 * csw read phase.
 1777: 	 * If the data direction was inbound a maximum of datalen bytes
 1778: 	 * is stored in the buffer pointed to by data.
 1779: 	 *
 1780: 	 * umass_cbi_transfer initialises the transfer and lets the state
 1781: 	 * machine in umass_cbi_state handle the completion. It uses the
 1782: 	 * following states:
 1783: 	 * TSTATE_CBI_COMMAND
 1784: 	 *   -> XXX fill in
 1785: 	 *
 1786: 	 * An error in any of those states will invoke
 1787: 	 * umass_cbi_reset.
 1788: 	 */
 1789: 
 1790: 	/* check the given arguments */
 1791: 	KASSERT(datalen == 0 || data != NULL,
 1792: 		("%s: datalen > 0, but no buffer",USBDEVNAME(sc->sc_dev)));
 1793: 	KASSERT(datalen == 0 || dir != DIR_NONE,
 1794: 		("%s: direction is NONE while datalen is not zero\n",
 1795: 			USBDEVNAME(sc->sc_dev)));
 1796: 
 1797: 	/* store the details for the data transfer phase */
 1798: 	sc->transfer_dir = dir;
 1799: 	sc->transfer_data = data;
 1800: 	sc->transfer_datalen = datalen;
 1801: 	sc->transfer_actlen = 0;
 1802: 	sc->transfer_cb = cb;
 1803: 	sc->transfer_priv = priv;
 1804: 	sc->transfer_status = STATUS_CMD_OK;
 1805: 
 1806: 	/* move from idle to the command state */
 1807: 	sc->transfer_state = TSTATE_CBI_COMMAND;
 1808: 
 1809: 	DIF(UDMASS_CBI, umass_cbi_dump_cmd(sc, cmd, cmdlen));
 1810: 
 1811: 	/* Send the Command Block from host to device via control endpoint. */
 1812: 	if (umass_cbi_adsc(sc, cmd, cmdlen, sc->transfer_xfer[XFER_CBI_CB]))
 1813: 		umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1814: }
 1815: 
 1816: Static void
 1817: umass_cbi_state(usbd_xfer_handle xfer, usbd_private_handle priv,
 1818: 		usbd_status err)
 1819: {
 1820: 	struct umass_softc *sc = (struct umass_softc *) priv;
 1821: 
 1822: 	KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
 1823: 		("%s: umass_cbi_state: wrong sc->proto 0x%02x\n",
 1824: 			USBDEVNAME(sc->sc_dev), sc->proto));
 1825: 
 1826: 	/*
 1827: 	 * State handling for CBI transfers.
 1828: 	 */
 1829: 
 1830: 	DPRINTF(UDMASS_CBI, ("%s: Handling CBI state %d (%s), xfer=%p, %s\n",
 1831: 		USBDEVNAME(sc->sc_dev), sc->transfer_state,
 1832: 		states[sc->transfer_state], xfer, usbd_errstr(err)));
 1833: 
 1834: 	switch (sc->transfer_state) {
 1835: 
 1836: 	/***** CBI Transfer *****/
 1837: 	case TSTATE_CBI_COMMAND:
 1838: 		if (err == USBD_STALLED) {
 1839: 			DPRINTF(UDMASS_CBI, ("%s: Command Transport failed\n",
 1840: 				USBDEVNAME(sc->sc_dev)));
 1841: 			/* Status transport by control pipe (section 2.3.2.1).
 1842: 			 * The command contained in the command block failed.
 1843: 			 *
 1844: 			 * The control pipe has already been unstalled by the
 1845: 			 * USB stack.
 1846: 			 * Section 2.4.3.1.1 states that the bulk in endpoints
 1847: 			 * should not be stalled at this point.
 1848: 			 */
 1849: 
 1850: 			sc->transfer_state = TSTATE_IDLE;
 1851: 			sc->transfer_cb(sc, sc->transfer_priv,
 1852: 					sc->transfer_datalen,
 1853: 					STATUS_CMD_FAILED);
 1854: 
 1855: 			return;
 1856: 		} else if (err) {
 1857: 			DPRINTF(UDMASS_CBI, ("%s: failed to send ADSC\n",
 1858: 				USBDEVNAME(sc->sc_dev)));
 1859: 			umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1860: 
 1861: 			return;
 1862: 		}
 1863: 
 1864: 		sc->transfer_state = TSTATE_CBI_DATA;
 1865: 		if (sc->transfer_dir == DIR_IN) {
 1866: 			if (umass_setup_transfer(sc, sc->bulkin_pipe,
 1867: 					sc->transfer_data, sc->transfer_datalen,
 1868: 					USBD_SHORT_XFER_OK,
 1869: 					sc->transfer_xfer[XFER_CBI_DATA]))
 1870: 				umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1871: 
 1872: 		} else if (sc->transfer_dir == DIR_OUT) {
 1873: 			if (umass_setup_transfer(sc, sc->bulkout_pipe,
 1874: 					sc->transfer_data, sc->transfer_datalen,
 1875: 					0,	/* fixed length transfer */
 1876: 					sc->transfer_xfer[XFER_CBI_DATA]))
 1877: 				umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1878: 
 1879: 		} else if (sc->proto & UMASS_PROTO_CBI_I) {
 1880: 			DPRINTF(UDMASS_CBI, ("%s: no data phase\n",
 1881: 				USBDEVNAME(sc->sc_dev)));
 1882: 			sc->transfer_state = TSTATE_CBI_STATUS;
 1883: 			if (umass_setup_transfer(sc, sc->intrin_pipe,
 1884: 					&sc->sbl, sizeof(sc->sbl),
 1885: 					0,	/* fixed length transfer */
 1886: 					sc->transfer_xfer[XFER_CBI_STATUS])){
 1887: 				umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1888: 			}
 1889: 		} else {
 1890: 			DPRINTF(UDMASS_CBI, ("%s: no data phase\n",
 1891: 				USBDEVNAME(sc->sc_dev)));
 1892: 			/* No command completion interrupt. Request
 1893: 			 * sense data.
 1894: 			 */
 1895: 			sc->transfer_state = TSTATE_IDLE;
 1896: 			sc->transfer_cb(sc, sc->transfer_priv,
 1897: 			       0, STATUS_CMD_UNKNOWN);
 1898: 		}
 1899: 
 1900: 		return;
 1901: 
 1902: 	case TSTATE_CBI_DATA:
 1903: 		/* retrieve the length of the transfer that was done */
 1904: 		usbd_get_xfer_status(xfer,NULL,NULL,&sc->transfer_actlen,NULL);
 1905: 
 1906: 		if (err) {
 1907: 			DPRINTF(UDMASS_CBI, ("%s: Data-%s %db failed, "
 1908: 				"%s\n", USBDEVNAME(sc->sc_dev),
 1909: 				(sc->transfer_dir == DIR_IN?"in":"out"),
 1910: 				sc->transfer_datalen,usbd_errstr(err)));
 1911: 
 1912: 			if (err == USBD_STALLED) {
 1913: 				umass_clear_endpoint_stall(sc,
 1914: 					sc->bulkin, sc->bulkin_pipe,
 1915: 					TSTATE_CBI_DCLEAR,
 1916: 					sc->transfer_xfer[XFER_CBI_DCLEAR]);
 1917: 			} else {
 1918: 				umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1919: 			}
 1920: 			return;
 1921: 		}
 1922: 
 1923: 		DIF(UDMASS_CBI, if (sc->transfer_dir == DIR_IN)
 1924: 					umass_dump_buffer(sc, sc->transfer_data,
 1925: 						sc->transfer_actlen, 48));
 1926: 
 1927: 		if (sc->proto & UMASS_PROTO_CBI_I) {
 1928: 			sc->transfer_state = TSTATE_CBI_STATUS;
 1929: 			if (umass_setup_transfer(sc, sc->intrin_pipe,
 1930: 				    &sc->sbl, sizeof(sc->sbl),
 1931: 				    0,	/* fixed length transfer */
 1932: 				    sc->transfer_xfer[XFER_CBI_STATUS])){
 1933: 				umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1934: 			}
 1935: 		} else {
 1936: 			/* No command completion interrupt. Request
 1937: 			 * sense to get status of command.
 1938: 			 */
 1939: 			sc->transfer_state = TSTATE_IDLE;
 1940: 			sc->transfer_cb(sc, sc->transfer_priv,
 1941: 				sc->transfer_datalen - sc->transfer_actlen,
 1942: 				STATUS_CMD_UNKNOWN);
 1943: 		}
 1944: 		return;
 1945: 
 1946: 	case TSTATE_CBI_STATUS:
 1947: 		if (err) {
 1948: 			DPRINTF(UDMASS_CBI, ("%s: Status Transport failed\n",
 1949: 				USBDEVNAME(sc->sc_dev)));
 1950: 			/* Status transport by interrupt pipe (section 2.3.2.2).
 1951: 			 */
 1952: 
 1953: 			if (err == USBD_STALLED) {
 1954: 				umass_clear_endpoint_stall(sc,
 1955: 					sc->intrin, sc->intrin_pipe,
 1956: 					TSTATE_CBI_SCLEAR,
 1957: 					sc->transfer_xfer[XFER_CBI_SCLEAR]);
 1958: 			} else {
 1959: 				umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 1960: 			}
 1961: 			return;
 1962: 		}
 1963: 
 1964: 		/* Dissect the information in the buffer */
 1965: 
 1966: 		if (sc->proto & UMASS_PROTO_UFI) {
 1967: 			int status;
 1968: 
 1969: 			/* Section 3.4.3.1.3 specifies that the UFI command
 1970: 			 * protocol returns an ASC and ASCQ in the interrupt
 1971: 			 * data block.
 1972: 			 */
 1973: 
 1974: 			DPRINTF(UDMASS_CBI, ("%s: UFI CCI, ASC = 0x%02x, "
 1975: 				"ASCQ = 0x%02x\n",
 1976: 				USBDEVNAME(sc->sc_dev),
 1977: 				sc->sbl.ufi.asc, sc->sbl.ufi.ascq));
 1978: 
 1979: 			if (sc->sbl.ufi.asc == 0 && sc->sbl.ufi.ascq == 0)
 1980: 				status = STATUS_CMD_OK;
 1981: 			else
 1982: 				status = STATUS_CMD_FAILED;
 1983: 
 1984: 			sc->transfer_state = TSTATE_IDLE;
 1985: 			sc->transfer_cb(sc, sc->transfer_priv,
 1986: 				sc->transfer_datalen - sc->transfer_actlen,
 1987: 				status);
 1988: 		} else {
 1989: 			/* Command Interrupt Data Block */
 1990: 			DPRINTF(UDMASS_CBI, ("%s: type=0x%02x, value=0x%02x\n",
 1991: 				USBDEVNAME(sc->sc_dev),
 1992: 				sc->sbl.common.type, sc->sbl.common.value));
 1993: 
 1994: 			if (sc->sbl.common.type == IDB_TYPE_CCI) {
 1995: 				int err;
 1996: 
 1997: 				if ((sc->sbl.common.value&IDB_VALUE_STATUS_MASK)
 1998: 							== IDB_VALUE_PASS) {
 1999: 					err = STATUS_CMD_OK;
 2000: 				} else if ((sc->sbl.common.value & IDB_VALUE_STATUS_MASK)
 2001: 							== IDB_VALUE_FAIL ||
 2002: 					   (sc->sbl.common.value & IDB_VALUE_STATUS_MASK)
 2003: 						== IDB_VALUE_PERSISTENT) {
 2004: 					err = STATUS_CMD_FAILED;
 2005: 				} else {
 2006: 					err = STATUS_WIRE_FAILED;
 2007: 				}
 2008: 
 2009: 				sc->transfer_state = TSTATE_IDLE;
 2010: 				sc->transfer_cb(sc, sc->transfer_priv,
 2011: 				       sc->transfer_datalen-sc->transfer_actlen,
 2012: 				       err);
 2013: 			}
 2014: 		}
 2015: 		return;
 2016: 
 2017: 	case TSTATE_CBI_DCLEAR:
 2018: 		if (err) {	/* should not occur */
 2019: 			printf("%s: CBI bulk-in/out stall clear failed, %s\n",
 2020: 			       USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 2021: 			umass_cbi_reset(sc, STATUS_WIRE_FAILED);
 2022: 		}
 2023: 
 2024: 		sc->transfer_state = TSTATE_IDLE;
 2025: 		sc->transfer_cb(sc, sc->transfer_priv,
 2026: 				sc->transfer_datalen,
 2027: 				STATUS_CMD_FAILED);
 2028: 		return;
 2029: 
 2030: 	case TSTATE_CBI_SCLEAR:
 2031: 		if (err)	/* should not occur */
 2032: 			printf("%s: CBI intr-in stall clear failed, %s\n",
 2033: 			       USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 2034: 
 2035: 		/* Something really bad is going on. Reset the device */
 2036: 		umass_cbi_reset(sc, STATUS_CMD_FAILED);
 2037: 		return;
 2038: 
 2039: 	/***** CBI Reset *****/
 2040: 	case TSTATE_CBI_RESET1:
 2041: 		if (err)
 2042: 			printf("%s: CBI reset failed, %s\n",
 2043: 				USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 2044: 
 2045: 		umass_clear_endpoint_stall(sc,
 2046: 			sc->bulkin, sc->bulkin_pipe, TSTATE_CBI_RESET2,
 2047: 			sc->transfer_xfer[XFER_CBI_RESET2]);
 2048: 
 2049: 		return;
 2050: 	case TSTATE_CBI_RESET2:
 2051: 		if (err)	/* should not occur */
 2052: 			printf("%s: CBI bulk-in stall clear failed, %s\n",
 2053: 			       USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 2054: 			/* no error recovery, otherwise we end up in a loop */
 2055: 
 2056: 		umass_clear_endpoint_stall(sc,
 2057: 			sc->bulkout, sc->bulkout_pipe, TSTATE_CBI_RESET3,
 2058: 			sc->transfer_xfer[XFER_CBI_RESET3]);
 2059: 
 2060: 		return;
 2061: 	case TSTATE_CBI_RESET3:
 2062: 		if (err)	/* should not occur */
 2063: 			printf("%s: CBI bulk-out stall clear failed, %s\n",
 2064: 			       USBDEVNAME(sc->sc_dev), usbd_errstr(err));
 2065: 			/* no error recovery, otherwise we end up in a loop */
 2066: 
 2067: 		sc->transfer_state = TSTATE_IDLE;
 2068: 		if (sc->transfer_priv) {
 2069: 			sc->transfer_cb(sc, sc->transfer_priv,
 2070: 					sc->transfer_datalen,
 2071: 					sc->transfer_status);
 2072: 		}
 2073: 
 2074: 		return;
 2075: 
 2076: 
 2077: 	/***** Default *****/
 2078: 	default:
 2079: 		panic("%s: Unknown state %d",
 2080: 		      USBDEVNAME(sc->sc_dev), sc->transfer_state);
 2081: 	}
 2082: }
 2083: 
 2084: 
 2085: 
 2086: 
 2087: /*
 2088:  * CAM specific functions (used by SCSI, UFI, 8070i (ATAPI))
 2089:  */
 2090: 
 2091: Static int
 2092: umass_cam_attach_sim(struct umass_softc *sc)
 2093: {
 2094: 	struct cam_devq	*devq;		/* Per device Queue */
 2095: 
 2096: 	/* A HBA is attached to the CAM layer.
 2097: 	 *
 2098: 	 * The CAM layer will then after a while start probing for
 2099: 	 * devices on the bus. The number of SIMs is limited to one.
 2100: 	 */
 2101: 
 2102: 	devq = cam_simq_alloc(1 /*maximum openings*/);
 2103: 	if (devq == NULL)
 2104: 		return(ENOMEM);
 2105: 
 2106: 	sc->umass_sim = cam_sim_alloc(umass_cam_action, umass_cam_poll,
 2107: 				DEVNAME_SIM,
 2108: 				sc /*priv*/,
 2109: 				USBDEVUNIT(sc->sc_dev) /*unit number*/,
 2110: 				1 /*maximum device openings*/,
 2111: 				0 /*maximum tagged device openings*/,
 2112: 				devq);
 2113: 	cam_simq_release(devq);
 2114: 	if (sc->umass_sim == NULL)
 2115: 		return(ENOMEM);
 2116: 
 2117: 	/*
 2118: 	 * If we could not register the bus we must immediately free the
 2119: 	 * sim so we do not attempt to deregister a bus later on that we
 2120: 	 * had not registered.
 2121: 	 */
 2122: 	if (xpt_bus_register(sc->umass_sim, USBDEVUNIT(sc->sc_dev)) !=
 2123: 	    CAM_SUCCESS) {
 2124: 		cam_sim_free(sc->umass_sim);
 2125: 		sc->umass_sim = NULL;
 2126: 		return(ENOMEM);
 2127: 	}
 2128: 
 2129: 	return(0);
 2130: }
 2131: 
 2132: Static void
 2133: umass_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb)
 2134: {
 2135: #ifdef USB_DEBUG
 2136: 	if (ccb->ccb_h.status != CAM_REQ_CMP) {
 2137: 		DPRINTF(UDMASS_SCSI, ("%s:%d Rescan failed, 0x%04x\n",
 2138: 			periph->periph_name, periph->unit_number,
 2139: 			ccb->ccb_h.status));
 2140: 	} else {
 2141: 		DPRINTF(UDMASS_SCSI, ("%s%d: Rescan succeeded\n",
 2142: 			periph->periph_name, periph->unit_number));
 2143: 	}
 2144: #endif
 2145: 
 2146: 	xpt_free_path(ccb->ccb_h.path);
 2147: 	free(ccb, M_USBDEV);
 2148: }
 2149: 
 2150: Static void
 2151: umass_cam_rescan(void *addr)
 2152: {
 2153: 	struct umass_softc *sc = (struct umass_softc *) addr;
 2154: 	struct cam_path *path;
 2155: 	union ccb *ccb;
 2156: 
 2157: 	sc->rescan_timeout.callout = NULL;
 2158: 	ccb = malloc(sizeof(union ccb), M_USBDEV, M_WAITOK|M_ZERO);
 2159: 
 2160: 	DPRINTF(UDMASS_SCSI, ("scbus%d: scanning for %s:%d:%d:%d\n",
 2161: 		cam_sim_path(sc->umass_sim),
 2162: 		USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2163: 		USBDEVUNIT(sc->sc_dev), CAM_LUN_WILDCARD));
 2164: 
 2165: 	if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->umass_sim),
 2166: 			    CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)
 2167: 	    != CAM_REQ_CMP)
 2168: 		return;
 2169: 
 2170: 	xpt_setup_ccb(&ccb->ccb_h, path, 5/*priority (low)*/);
 2171: 	ccb->ccb_h.func_code = XPT_SCAN_BUS;
 2172: 	ccb->ccb_h.cbfcnp = umass_cam_rescan_callback;
 2173: 	ccb->crcn.flags = CAM_FLAG_NONE;
 2174: 	xpt_action(ccb);
 2175: 
 2176: 	/* The scan is in progress now. */
 2177: }
 2178: 
 2179: Static int
 2180: umass_cam_attach(struct umass_softc *sc)
 2181: {
 2182: #ifndef USB_DEBUG
 2183: 	if (bootverbose)
 2184: #endif
 2185: 		printf("%s:%d:%d:%d: Attached to scbus%d\n",
 2186: 			USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2187: 			USBDEVUNIT(sc->sc_dev), CAM_LUN_WILDCARD,
 2188: 			cam_sim_path(sc->umass_sim));
 2189: 
 2190: 	if (!cold) {
 2191: 		/* 
 2192: 		 * Notify CAM of the new device after 1 second delay. Any
 2193: 		 * failure is benign, as the user can still do it by hand
 2194: 		 * (camcontrol rescan <busno>). Only do this if we are not
 2195: 		 * booting, because CAM does a scan after booting has
 2196: 		 * completed, when interrupts have been enabled.
 2197: 		 */
 2198: 		sc->rescan_timeout =
 2199: 			timeout(umass_cam_rescan, sc, MS_TO_TICKS(200));
 2200: 	}
 2201: 
 2202: 	return(0);	/* always succesfull */
 2203: }
 2204: 
 2205: /* umass_cam_detach
 2206:  *	detach from the CAM layer
 2207:  */
 2208: 
 2209: Static int
 2210: umass_cam_detach_sim(struct umass_softc *sc)
 2211: {
 2212: 	if (sc->rescan_timeout.callout) {
 2213: 		untimeout(umass_cam_rescan, sc, sc->rescan_timeout);
 2214: 		sc->rescan_timeout.callout = NULL;
 2215: 	}
 2216: 	if (sc->umass_sim) {
 2217: 		if (xpt_bus_deregister(cam_sim_path(sc->umass_sim)))
 2218: 			cam_sim_free(sc->umass_sim);
 2219: 		else
 2220: 			return(EBUSY);
 2221: 
 2222: 		sc->umass_sim = NULL;
 2223: 	}
 2224: 
 2225: 	return(0);
 2226: }
 2227: 
 2228: /* umass_cam_action
 2229:  * 	CAM requests for action come through here
 2230:  */
 2231: 
 2232: Static void
 2233: umass_cam_action(struct cam_sim *sim, union ccb *ccb)
 2234: {
 2235: 	struct umass_softc *sc = (struct umass_softc *)sim->softc;
 2236: 
 2237: 	/* The softc is still there, but marked as going away. umass_cam_detach
 2238: 	 * has not yet notified CAM of the lost device however.
 2239: 	 */
 2240: 	if (sc && (sc->flags & UMASS_FLAGS_GONE)) {
 2241: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: "
 2242: 			"Invalid target (gone)\n",
 2243: 			USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2244: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 2245: 			ccb->ccb_h.func_code));
 2246: 		ccb->ccb_h.status = CAM_TID_INVALID;
 2247: 		xpt_done(ccb);
 2248: 		return;
 2249: 	}
 2250: 
 2251: 	/* Verify, depending on the operation to perform, that we either got a
 2252: 	 * valid sc, because an existing target was referenced, or otherwise
 2253: 	 * the SIM is addressed.
 2254: 	 *
 2255: 	 * This avoids bombing out at a printf and does give the CAM layer some
 2256: 	 * sensible feedback on errors.
 2257: 	 */
 2258: 	switch (ccb->ccb_h.func_code) {
 2259: 	case XPT_SCSI_IO:
 2260: 	case XPT_RESET_DEV:
 2261: 	case XPT_GET_TRAN_SETTINGS:
 2262: 	case XPT_SET_TRAN_SETTINGS:
 2263: 	case XPT_CALC_GEOMETRY:
 2264: 		/* the opcodes requiring a target. These should never occur. */
 2265: 		if (sc == NULL) {
 2266: 			printf("%s:%d:%d:%d:func_code 0x%04x: "
 2267: 				"Invalid target (target needed)\n",
 2268: 				DEVNAME_SIM, cam_sim_path(sc->umass_sim),
 2269: 				ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 2270: 				ccb->ccb_h.func_code);
 2271: 
 2272: 			ccb->ccb_h.status = CAM_TID_INVALID;
 2273: 			xpt_done(ccb);
 2274: 			return;
 2275: 		}
 2276: 		break;
 2277: 	case XPT_PATH_INQ:
 2278: 	case XPT_NOOP:
 2279: 		/* The opcodes sometimes aimed at a target (sc is valid),
 2280: 		 * sometimes aimed at the SIM (sc is invalid and target is
 2281: 		 * CAM_TARGET_WILDCARD)
 2282: 		 */
 2283: 		if (sc == NULL && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) {
 2284: 			DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: "
 2285: 				"Invalid target (no wildcard)\n",
 2286: 				DEVNAME_SIM, cam_sim_path(sc->umass_sim),
 2287: 				ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 2288: 				ccb->ccb_h.func_code));
 2289: 
 2290: 			ccb->ccb_h.status = CAM_TID_INVALID;
 2291: 			xpt_done(ccb);
 2292: 			return;
 2293: 		}
 2294: 		break;
 2295: 	default:
 2296: 		/* XXX Hm, we should check the input parameters */
 2297: 		break;
 2298: 	}
 2299: 
 2300: 	/* Perform the requested action */
 2301: 	switch (ccb->ccb_h.func_code) {
 2302: 	case XPT_SCSI_IO:
 2303: 	{
 2304: 		struct ccb_scsiio *csio = &ccb->csio;	/* deref union */
 2305: 		int dir;
 2306: 		unsigned char *cmd;
 2307: 		int cmdlen;
 2308: 		unsigned char *rcmd;
 2309: 		int rcmdlen;
 2310: 
 2311: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SCSI_IO: "
 2312: 			"cmd: 0x%02x, flags: 0x%02x, "
 2313: 			"%db cmd/%db data/%db sense\n",
 2314: 			USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2315: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 2316: 			csio->cdb_io.cdb_bytes[0],
 2317: 			ccb->ccb_h.flags & CAM_DIR_MASK,
 2318: 			csio->cdb_len, csio->dxfer_len,
 2319: 			csio->sense_len));
 2320: 
 2321: 		/* clear the end of the buffer to make sure we don't send out
 2322: 		 * garbage.
 2323: 		 */
 2324: 		DIF(UDMASS_SCSI, if ((ccb->ccb_h.flags & CAM_DIR_MASK)
 2325: 				     == CAM_DIR_OUT)
 2326: 					umass_dump_buffer(sc, csio->data_ptr,
 2327: 						csio->dxfer_len, 48));
 2328: 
 2329: 		if (sc->transfer_state != TSTATE_IDLE) {
 2330: 			DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SCSI_IO: "
 2331: 				"I/O in progress, deferring (state %d, %s)\n",
 2332: 				USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2333: 				ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 2334: 				sc->transfer_state,states[sc->transfer_state]));
 2335: 			ccb->ccb_h.status = CAM_SCSI_BUSY;
 2336: 			xpt_done(ccb);
 2337: 			return;
 2338: 		}
 2339: 
 2340: 		switch(ccb->ccb_h.flags&CAM_DIR_MASK) {
 2341: 		case CAM_DIR_IN:
 2342: 			dir = DIR_IN;
 2343: 			break;
 2344: 		case CAM_DIR_OUT:
 2345: 			dir = DIR_OUT;
 2346: 			break;
 2347: 		default:
 2348: 			dir = DIR_NONE;
 2349: 		}
 2350: 
 2351: 		ccb->ccb_h.status = CAM_REQ_INPROG | CAM_SIM_QUEUED;
 2352: 
 2353: 
 2354: 		if (csio->ccb_h.flags & CAM_CDB_POINTER) {
 2355: 			cmd = (unsigned char *) csio->cdb_io.cdb_ptr;
 2356: 		} else {
 2357: 			cmd = (unsigned char *) &csio->cdb_io.cdb_bytes;
 2358: 		}
 2359: 		cmdlen = csio->cdb_len;
 2360: 		rcmd = (unsigned char *) &sc->cam_scsi_command;
 2361: 		rcmdlen = sizeof(sc->cam_scsi_command);
 2362: 
 2363: 		/* sc->transform will convert the command to the command
 2364: 		 * (format) needed by the specific command set and return
 2365: 		 * the converted command in a buffer pointed to be rcmd.
 2366: 		 * We pass in a buffer, but if the command does not
 2367: 		 * have to be transformed it returns a ptr to the original
 2368: 		 * buffer (see umass_scsi_transform).
 2369: 		 */
 2370: 
 2371: 		if (sc->transform(sc, cmd, cmdlen, &rcmd, &rcmdlen)) {
 2372: 			/*
 2373: 			 * Handle EVPD inquiry for broken devices first
 2374: 			 * NO_INQUIRY also implies NO_INQUIRY_EVPD
 2375: 			 */
 2376: 			if ((sc->quirks & (NO_INQUIRY_EVPD | NO_INQUIRY)) &&
 2377: 			    rcmd[0] == INQUIRY && (rcmd[1] & SI_EVPD)) {
 2378: 				struct scsi_sense_data *sense;
 2379: 
 2380: 				sense = &ccb->csio.sense_data;
 2381: 				bzero(sense, sizeof(*sense));
 2382: 				sense->error_code = SSD_CURRENT_ERROR;
 2383: 				sense->flags = SSD_KEY_ILLEGAL_REQUEST;
 2384: 				sense->add_sense_code = 0x24;
 2385: 				sense->extra_len = 10;
 2386:  				ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
 2387: 				ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR |
 2388: 				    CAM_AUTOSNS_VALID;
 2389: 				xpt_done(ccb);
 2390: 				return;
 2391: 			}
 2392: 			/* Return fake inquiry data for broken devices */
 2393: 			if ((sc->quirks & NO_INQUIRY) && rcmd[0] == INQUIRY) {
 2394: 				struct ccb_scsiio *csio = &ccb->csio;
 2395: 
 2396: 				memcpy(csio->data_ptr, &fake_inq_data,
 2397: 				    sizeof(fake_inq_data));
 2398: 				csio->scsi_status = SCSI_STATUS_OK;
 2399: 				ccb->ccb_h.status = CAM_REQ_CMP;
 2400: 				xpt_done(ccb);
 2401: 				return;
 2402: 			}
 2403: 			if ((sc->quirks & FORCE_SHORT_INQUIRY) &&
 2404: 			    rcmd[0] == INQUIRY) {
 2405: 				csio->dxfer_len = SHORT_INQUIRY_LENGTH;
 2406: 			}
 2407: 			sc->transfer(sc, ccb->ccb_h.target_lun, rcmd, rcmdlen,
 2408: 				     csio->data_ptr,
 2409: 				     csio->dxfer_len, dir,
 2410: 				     umass_cam_cb, (void *) ccb);
 2411: 		} else {
 2412: 			ccb->ccb_h.status = CAM_REQ_INVALID;
 2413: 			xpt_done(ccb);
 2414: 		}
 2415: 
 2416: 		break;
 2417: 	}
 2418: 	case XPT_PATH_INQ:
 2419: 	{
 2420: 		struct ccb_pathinq *cpi = &ccb->cpi;
 2421: 
 2422: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_PATH_INQ:.\n",
 2423: 			(sc == NULL? DEVNAME_SIM:USBDEVNAME(sc->sc_dev)),
 2424: 			cam_sim_path(sc->umass_sim),
 2425: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
 2426: 
 2427: 		/* host specific information */
 2428: 		cpi->version_num = 1;
 2429: 		cpi->hba_inquiry = 0;
 2430: 		cpi->target_sprt = 0;
 2431: 		cpi->hba_misc = PIM_NO_6_BYTE;
 2432: 		cpi->hba_eng_cnt = 0;
 2433: 		cpi->max_target = UMASS_SCSIID_MAX;	/* one target */
 2434: 		cpi->initiator_id = UMASS_SCSIID_HOST;
 2435: 		strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
 2436: 		strncpy(cpi->hba_vid, "USB SCSI", HBA_IDLEN);
 2437: 		strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
 2438: 		cpi->unit_number = cam_sim_unit(sim);
 2439: 		cpi->bus_id = USBDEVUNIT(sc->sc_dev);
 2440: 
 2441: 		if (sc == NULL) {
 2442: 			cpi->base_transfer_speed = 0;
 2443: 			cpi->max_lun = 0;
 2444: 		} else {
 2445: 			if (sc->quirks & FLOPPY_SPEED) {
 2446: 			    cpi->base_transfer_speed = UMASS_FLOPPY_TRANSFER_SPEED;
 2447: 			} else {
 2448: 			    cpi->base_transfer_speed = UMASS_DEFAULT_TRANSFER_SPEED;
 2449: 			}
 2450: 			cpi->max_lun = sc->maxlun;
 2451: 		}
 2452: 
 2453: 		cpi->ccb_h.status = CAM_REQ_CMP;
 2454: 		xpt_done(ccb);
 2455: 		break;
 2456: 	}
 2457: 	case XPT_RESET_DEV:
 2458: 	{
 2459: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_RESET_DEV:.\n",
 2460: 			USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2461: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
 2462: 
 2463: 		ccb->ccb_h.status = CAM_REQ_INPROG;
 2464: 		umass_reset(sc, umass_cam_cb, (void *) ccb);
 2465: 		break;
 2466: 	}
 2467: 	case XPT_GET_TRAN_SETTINGS:
 2468: 	{
 2469: 		struct ccb_trans_settings *cts = &ccb->cts;
 2470: 
 2471: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_GET_TRAN_SETTINGS:.\n",
 2472: 			USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2473: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
 2474: 
 2475: 		cts->valid = 0;
 2476: 		cts->flags = 0;		/* no disconnection, tagging */
 2477: 
 2478: 		ccb->ccb_h.status = CAM_REQ_CMP;
 2479: 		xpt_done(ccb);
 2480: 		break;
 2481: 	}
 2482: 	case XPT_SET_TRAN_SETTINGS:
 2483: 	{
 2484: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SET_TRAN_SETTINGS:.\n",
 2485: 			USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
 2486: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
 2487: 
 2488: 		ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 2489: 		xpt_done(ccb);
 2490: 		break;
 2491: 	}
 2492: 	case XPT_CALC_GEOMETRY:
 2493: 	{
 2494: 		cam_calc_geometry(&ccb->ccg, /*extended*/1);
 2495: 		xpt_done(ccb);
 2496: 		break;
 2497: 	}
 2498: 	case XPT_NOOP:
 2499: 	{
 2500: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_NOOP:.\n",
 2501: 			(sc == NULL? DEVNAME_SIM:USBDEVNAME(sc->sc_dev)),
 2502: 			cam_sim_path(sc->umass_sim),
 2503: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
 2504: 
 2505: 		ccb->ccb_h.status = CAM_REQ_CMP;
 2506: 		xpt_done(ccb);
 2507: 		break;
 2508: 	}
 2509: 	default:
 2510: 		DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: "
 2511: 			"Not implemented\n",
 2512: 			(sc == NULL? DEVNAME_SIM:USBDEVNAME(sc->sc_dev)),
 2513: 			cam_sim_path(sc->umass_sim),
 2514: 			ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
 2515: 			ccb->ccb_h.func_code));
 2516: 
 2517: 		ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 2518: 		xpt_done(ccb);
 2519: 		break;
 2520: 	}
 2521: }
 2522: 
 2523: /* umass_cam_poll
 2524:  *	all requests are handled through umass_cam_action, requests
 2525:  *	are never pending. So, nothing to do here.
 2526:  */
 2527: Static void
 2528: umass_cam_poll(struct cam_sim *sim)
 2529: {
 2530: #ifdef USB_DEBUG
 2531: 	struct umass_softc *sc = (struct umass_softc *) sim->softc;
 2532: 
 2533: 	DPRINTF(UDMASS_SCSI, ("%s: CAM poll\n",
 2534: 		USBDEVNAME(sc->sc_dev)));
 2535: #endif
 2536: 
 2537: 	/* nop */
 2538: }
 2539: 
 2540: 
 2541: /* umass_cam_cb
 2542:  *	finalise a completed CAM command
 2543:  */
 2544: 
 2545: Static void
 2546: umass_cam_cb(struct umass_softc *sc, void *priv, int residue, int status)
 2547: {
 2548: 	union ccb *ccb = (union ccb *) priv;
 2549: 	struct ccb_scsiio *csio = &ccb->csio;		/* deref union */
 2550: 
 2551: 	csio->resid = residue;
 2552: 
 2553: 	switch (status) {
 2554: 	case STATUS_CMD_OK:
 2555: 		ccb->ccb_h.status = CAM_REQ_CMP;
 2556: 		xpt_done(ccb);
 2557: 		break;
 2558: 
 2559: 	case STATUS_CMD_UNKNOWN:
 2560: 	case STATUS_CMD_FAILED:
 2561: 		switch (ccb->ccb_h.func_code) {
 2562: 		case XPT_SCSI_IO:
 2563: 		{
 2564: 			unsigned char *rcmd;
 2565: 			int rcmdlen;
 2566: 
 2567: 			/* fetch sense data */
 2568: 			/* the rest of the command was filled in at attach */
 2569: 			sc->cam_scsi_sense.length = csio->sense_len;
 2570: 
 2571: 			DPRINTF(UDMASS_SCSI,("%s: Fetching %db sense data\n",
 2572: 				USBDEVNAME(sc->sc_dev), csio->sense_len));
 2573: 
 2574: 			rcmd = (unsigned char *) &sc->cam_scsi_command;
 2575: 			rcmdlen = sizeof(sc->cam_scsi_command);
 2576: 
 2577: 			if (sc->transform(sc,
 2578: 				    (unsigned char *) &sc->cam_scsi_sense,
 2579: 				    sizeof(sc->cam_scsi_sense),
 2580: 				    &rcmd, &rcmdlen)) {
 2581: 				if ((sc->quirks & FORCE_SHORT_INQUIRY) && (rcmd[0] == INQUIRY)) {
 2582: 					csio->sense_len = SHORT_INQUIRY_LENGTH;
 2583: 				}
 2584: 				sc->transfer(sc, ccb->ccb_h.target_lun,
 2585: 					     rcmd, rcmdlen,
 2586: 					     &csio->sense_data,
 2587: 					     csio->sense_len, DIR_IN,
 2588: 					     umass_cam_sense_cb, (void *) ccb);
 2589: 			} else {
 2590: 				panic("transform(REQUEST_SENSE) failed");
 2591: 			}
 2592: 			break;
 2593: 		}
 2594: 		case XPT_RESET_DEV: /* Reset failed */
 2595: 			ccb->ccb_h.status = CAM_REQ_CMP_ERR;
 2596: 			xpt_done(ccb);
 2597: 			break;
 2598: 		default:
 2599: 			panic("umass_cam_cb called for func_code %d",
 2600: 			      ccb->ccb_h.func_code);
 2601: 		}
 2602: 		break;
 2603: 
 2604: 	case STATUS_WIRE_FAILED:
 2605: 		/* the wire protocol failed and will have recovered
 2606: 		 * (hopefully).  We return an error to CAM and let CAM retry
 2607: 		 * the command if necessary.
 2608: 		 */
 2609: 		ccb->ccb_h.status = CAM_REQ_CMP_ERR;
 2610: 		xpt_done(ccb);
 2611: 		break;
 2612: 	default:
 2613: 		panic("%s: Unknown status %d in umass_cam_cb",
 2614: 			USBDEVNAME(sc->sc_dev), status);
 2615: 	}
 2616: }
 2617: 
 2618: /* Finalise a completed autosense operation
 2619:  */
 2620: Static void
 2621: umass_cam_sense_cb(struct umass_softc *sc, void *priv, int residue, int status)
 2622: {
 2623: 	union ccb *ccb = (union ccb *) priv;
 2624: 	struct ccb_scsiio *csio = &ccb->csio;		/* deref union */
 2625: 	unsigned char *rcmd;
 2626: 	int rcmdlen;
 2627: 
 2628: 	switch (status) {
 2629: 	case STATUS_CMD_OK:
 2630: 	case STATUS_CMD_UNKNOWN:
 2631: 	case STATUS_CMD_FAILED:
 2632: 		/* Getting sense data always succeeds (apart from wire
 2633: 		 * failures).
 2634: 		 */
 2635: 		if ((sc->quirks & RS_NO_CLEAR_UA)
 2636: 		    && csio->cdb_io.cdb_bytes[0] == INQUIRY
 2637: 		    && (csio->sense_data.flags & SSD_KEY)
 2638: 		    				== SSD_KEY_UNIT_ATTENTION) {
 2639: 			/* Ignore unit attention errors in the case where
 2640: 			 * the Unit Attention state is not cleared on
 2641: 			 * REQUEST SENSE. They will appear again at the next
 2642: 			 * command.
 2643: 			 */
 2644: 			ccb->ccb_h.status = CAM_REQ_CMP;
 2645: 		} else if ((csio->sense_data.flags & SSD_KEY)
 2646: 						== SSD_KEY_NO_SENSE) {
 2647: 			/* No problem after all (in the case of CBI without
 2648: 			 * CCI)
 2649: 			 */
 2650: 			ccb->ccb_h.status = CAM_REQ_CMP;
 2651: 		} else if ((sc->quirks & RS_NO_CLEAR_UA) &&
 2652: 			   (csio->cdb_io.cdb_bytes[0] == READ_CAPACITY) &&
 2653: 			   ((csio->sense_data.flags & SSD_KEY)
 2654: 			    == SSD_KEY_UNIT_ATTENTION)) {
 2655: 			/*
 2656: 			 * Some devices do not clear the unit attention error
 2657: 			 * on request sense. We insert a test unit ready
 2658: 			 * command to make sure we clear the unit attention
 2659: 			 * condition, then allow the retry to proceed as
 2660: 			 * usual.
 2661: 			 */
 2662: 
 2663: 			ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
 2664: 					    | CAM_AUTOSNS_VALID;
 2665: 			csio->scsi_status = SCSI_STATUS_CHECK_COND;
 2666: 
 2667: #if 0
 2668: 			DELAY(300000);
 2669: #endif
 2670: 
 2671: 			DPRINTF(UDMASS_SCSI,("%s: Doing a sneaky"
 2672: 					     "TEST_UNIT_READY\n",
 2673: 				USBDEVNAME(sc->sc_dev)));
 2674: 
 2675: 			/* the rest of the command was filled in at attach */
 2676: 
 2677: 			rcmd = (unsigned char *) &sc->cam_scsi_command2;
 2678: 			rcmdlen = sizeof(sc->cam_scsi_command2);
 2679: 
 2680: 			if (sc->transform(sc,
 2681: 					(unsigned char *)
 2682: 					&sc->cam_scsi_test_unit_ready,
 2683: 					sizeof(sc->cam_scsi_test_unit_ready),
 2684: 					&rcmd, &rcmdlen)) {
 2685: 				sc->transfer(sc, ccb->ccb_h.target_lun,
 2686: 					     rcmd, rcmdlen,
 2687: 					     NULL, 0, DIR_NONE,
 2688: 					     umass_cam_quirk_cb, (void *) ccb);
 2689: 			} else {
 2690: 				panic("transform(TEST_UNIT_READY) failed");
 2691: 			}
 2692: 			break;
 2693: 		} else {
 2694: 			ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
 2695: 					    | CAM_AUTOSNS_VALID;
 2696: 			csio->scsi_status = SCSI_STATUS_CHECK_COND;
 2697: 		}
 2698: 		xpt_done(ccb);
 2699: 		break;
 2700: 
 2701: 	default:
 2702: 		DPRINTF(UDMASS_SCSI, ("%s: Autosense failed, status %d\n",
 2703: 			USBDEVNAME(sc->sc_dev), status));
 2704: 		ccb->ccb_h.status = CAM_AUTOSENSE_FAIL;
 2705: 		xpt_done(ccb);
 2706: 	}
 2707: }
 2708: 
 2709: /*
 2710:  * This completion code just handles the fact that we sent a test-unit-ready
 2711:  * after having previously failed a READ CAPACITY with CHECK_COND.  Even
 2712:  * though this command succeeded, we have to tell CAM to retry.
 2713:  */
 2714: Static void
 2715: umass_cam_quirk_cb(struct umass_softc *sc, void *priv, int residue, int status)
 2716: {
 2717: 	union ccb *ccb = (union ccb *) priv;
 2718: 
 2719: 	DPRINTF(UDMASS_SCSI, ("%s: Test unit ready returned status %d\n",
 2720: 	USBDEVNAME(sc->sc_dev), status));
 2721: #if 0
 2722: 	ccb->ccb_h.status = CAM_REQ_CMP;
 2723: #endif
 2724: 	ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
 2725: 			    | CAM_AUTOSNS_VALID;
 2726: 	ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
 2727: 	xpt_done(ccb);
 2728: }
 2729: 
 2730: Static int
 2731: umass_driver_load(module_t mod, int what, void *arg)
 2732: {
 2733: 	switch (what) {
 2734: 	case MOD_UNLOAD:
 2735: 	case MOD_LOAD:
 2736: 	default:
 2737: 		return(usbd_driver_load(mod, what, arg));
 2738: 	}
 2739: }
 2740: 
 2741: /*
 2742:  * SCSI specific functions
 2743:  */
 2744: 
 2745: Static int
 2746: umass_scsi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
 2747: 		     unsigned char **rcmd, int *rcmdlen)
 2748: {
 2749: 	switch (cmd[0]) {
 2750: 	case TEST_UNIT_READY:
 2751: 		if (sc->quirks & NO_TEST_UNIT_READY) {
 2752: 			KASSERT(*rcmdlen >= sizeof(struct scsi_start_stop_unit),
 2753: 				("rcmdlen = %d < %ld, buffer too small",
 2754: 				 *rcmdlen,
 2755: 				 (long)sizeof(struct scsi_start_stop_unit)));
 2756: 			DPRINTF(UDMASS_SCSI, ("%s: Converted TEST_UNIT_READY "
 2757: 				"to START_UNIT\n", USBDEVNAME(sc->sc_dev)));
 2758: 			memset(*rcmd, 0, *rcmdlen);
 2759: 			(*rcmd)[0] = START_STOP_UNIT;
 2760: 			(*rcmd)[4] = SSS_START;
 2761: 			return 1;
 2762: 		}
 2763: 		/* fallthrough */
 2764: 	case INQUIRY:
 2765: 		/* some drives wedge when asked for full inquiry information. */
 2766: 		if (sc->quirks & FORCE_SHORT_INQUIRY) {
 2767: 			memcpy(*rcmd, cmd, cmdlen);
 2768: 			*rcmdlen = cmdlen;
 2769: 			(*rcmd)[4] = SHORT_INQUIRY_LENGTH;
 2770: 			return 1;
 2771: 		}
 2772: 		/* fallthrough */
 2773: 	default:
 2774: 		*rcmd = cmd;		/* We don't need to copy it */
 2775: 		*rcmdlen = cmdlen;
 2776: 	}
 2777: 
 2778: 	return 1;
 2779: }
 2780: /* RBC specific functions */
 2781: Static int
 2782: umass_rbc_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
 2783: 		     unsigned char **rcmd, int *rcmdlen)
 2784: {
 2785: 	switch (cmd[0]) {
 2786: 	/* these commands are defined in RBC: */
 2787: 	case READ_10:
 2788: 	case READ_CAPACITY:
 2789: 	case START_STOP_UNIT:
 2790: 	case SYNCHRONIZE_CACHE:
 2791: 	case WRITE_10:
 2792: 	case 0x2f: /* VERIFY_10 is absent from scsi_all.h??? */
 2793: 	case INQUIRY:
 2794: 	case MODE_SELECT_10:
 2795: 	case MODE_SENSE_10:
 2796: 	case TEST_UNIT_READY:
 2797: 	case WRITE_BUFFER:
 2798: 	 /* The following commands are not listed in my copy of the RBC specs.
 2799: 	  * CAM however seems to want those, and at least the Sony DSC device
 2800: 	  * appears to support those as well */
 2801: 	case REQUEST_SENSE:
 2802: 	case PREVENT_ALLOW:
 2803: 		*rcmd = cmd;		/* We don't need to copy it */
 2804: 		*rcmdlen = cmdlen;
 2805: 		return 1;
 2806: 	/* All other commands are not legal in RBC */
 2807: 	default:
 2808: 		printf("%s: Unsupported RBC command 0x%02x",
 2809: 			USBDEVNAME(sc->sc_dev), cmd[0]);
 2810: 		printf("\n");
 2811: 		return 0;	/* failure */
 2812: 	}
 2813: }
 2814: 
 2815: /*
 2816:  * UFI specific functions
 2817:  */
 2818: Static int
 2819: umass_ufi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
 2820: 		    unsigned char **rcmd, int *rcmdlen)
 2821: {
 2822: 	/* A UFI command is always 12 bytes in length */
 2823: 	KASSERT(*rcmdlen >= UFI_COMMAND_LENGTH,
 2824: 		("rcmdlen = %d < %d, buffer too small",
 2825: 		 *rcmdlen, UFI_COMMAND_LENGTH));
 2826: 
 2827: 	*rcmdlen = UFI_COMMAND_LENGTH;
 2828: 	memset(*rcmd, 0, UFI_COMMAND_LENGTH);
 2829: 
 2830: 	switch (cmd[0]) {
 2831: 	/* Commands of which the format has been verified. They should work.
 2832: 	 * Copy the command into the (zeroed out) destination buffer.
 2833: 	 */
 2834: 	case TEST_UNIT_READY:
 2835: 		if (sc->quirks &  NO_TEST_UNIT_READY) {
 2836: 			/* Some devices do not support this command.
 2837: 			 * Start Stop Unit should give the same results
 2838: 			 */
 2839: 			DPRINTF(UDMASS_UFI, ("%s: Converted TEST_UNIT_READY "
 2840: 				"to START_UNIT\n", USBDEVNAME(sc->sc_dev)));
 2841: 			(*rcmd)[0] = START_STOP_UNIT;
 2842: 			(*rcmd)[4] = SSS_START;
 2843: 		} else {
 2844: 			memcpy(*rcmd, cmd, cmdlen);
 2845: 		}
 2846: 		return 1;
 2847: 
 2848: 	case REZERO_UNIT:
 2849: 	case REQUEST_SENSE:
 2850: 	case INQUIRY:
 2851: 	case START_STOP_UNIT:
 2852: 	case SEND_DIAGNOSTIC:
 2853: 	case PREVENT_ALLOW:
 2854: 	case READ_CAPACITY:
 2855: 	case READ_10:
 2856: 	case WRITE_10:
 2857: 	case POSITION_TO_ELEMENT:	/* SEEK_10 */
 2858: 	case MODE_SELECT_10:
 2859: 	case MODE_SENSE_10:
 2860: 	case READ_12:
 2861: 	case WRITE_12:
 2862: 		memcpy(*rcmd, cmd, cmdlen);
 2863: 		return 1;
 2864: 
 2865: 	/* Other UFI commands: FORMAT_UNIT, READ_FORMAT_CAPACITY,
 2866: 	 * VERIFY, WRITE_AND_VERIFY.
 2867: 	 * These should be checked whether they somehow can be made to fit.
 2868: 	 */
 2869: 
 2870: 	default:
 2871: 		printf("%s: Unsupported UFI command 0x%02x\n",
 2872: 			USBDEVNAME(sc->sc_dev), cmd[0]);
 2873: 		return 0;	/* failure */
 2874: 	}
 2875: }
 2876: 
 2877: /*
 2878:  * 8070i (ATAPI) specific functions
 2879:  */
 2880: Static int
 2881: umass_atapi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
 2882: 		      unsigned char **rcmd, int *rcmdlen)
 2883: {
 2884: 	/* An ATAPI command is always 12 bytes in length. */
 2885: 	KASSERT(*rcmdlen >= ATAPI_COMMAND_LENGTH,
 2886: 		("rcmdlen = %d < %d, buffer too small",
 2887: 		 *rcmdlen, ATAPI_COMMAND_LENGTH));
 2888: 
 2889: 	*rcmdlen = ATAPI_COMMAND_LENGTH;
 2890: 	memset(*rcmd, 0, ATAPI_COMMAND_LENGTH);
 2891: 
 2892: 	switch (cmd[0]) {
 2893: 	/* Commands of which the format has been verified. They should work.
 2894: 	 * Copy the command into the (zeroed out) destination buffer.
 2895: 	 */
 2896: 	case INQUIRY:
 2897: 		memcpy(*rcmd, cmd, cmdlen);
 2898: 		/* some drives wedge when asked for full inquiry information. */
 2899: 		if (sc->quirks & FORCE_SHORT_INQUIRY)
 2900: 			(*rcmd)[4] = SHORT_INQUIRY_LENGTH;
 2901: 		return 1;
 2902: 
 2903: 	case TEST_UNIT_READY:
 2904: 		if (sc->quirks & NO_TEST_UNIT_READY) {
 2905: 			KASSERT(*rcmdlen >= sizeof(struct scsi_start_stop_unit),
 2906: 				("rcmdlen = %d < %ld, buffer too small",
 2907: 				 *rcmdlen,
 2908: 				 (long)sizeof(struct scsi_start_stop_unit)));
 2909: 			DPRINTF(UDMASS_SCSI, ("%s: Converted TEST_UNIT_READY "
 2910: 				"to START_UNIT\n", USBDEVNAME(sc->sc_dev)));
 2911: 			memset(*rcmd, 0, *rcmdlen);
 2912: 			(*rcmd)[0] = START_STOP_UNIT;
 2913: 			(*rcmd)[4] = SSS_START;
 2914: 			return 1;
 2915: 		}
 2916: 		/* fallthrough */
 2917: 	case REZERO_UNIT:
 2918: 	case REQUEST_SENSE:
 2919: 	case START_STOP_UNIT:
 2920: 	case SEND_DIAGNOSTIC:
 2921: 	case PREVENT_ALLOW:
 2922: 	case READ_CAPACITY:
 2923: 	case READ_10:
 2924: 	case WRITE_10:
 2925: 	case POSITION_TO_ELEMENT:	/* SEEK_10 */
 2926: 	case SYNCHRONIZE_CACHE:
 2927: 	case MODE_SELECT_10:
 2928: 	case MODE_SENSE_10:
 2929: 		memcpy(*rcmd, cmd, cmdlen);
 2930: 		return 1;
 2931: 
 2932: 	case READ_12:
 2933: 	case WRITE_12:
 2934: 	default:
 2935: 		printf("%s: Unsupported ATAPI command 0x%02x\n",
 2936: 			USBDEVNAME(sc->sc_dev), cmd[0]);
 2937: 		return 0;	/* failure */
 2938: 	}
 2939: }
 2940: 
 2941: 
 2942: /* (even the comment is missing) */
 2943: 
 2944: DRIVER_MODULE(umass, uhub, umass_driver, umass_devclass, umass_driver_load, 0);
 2945: 
 2946: 
 2947: 
 2948: #ifdef USB_DEBUG
 2949: Static void
 2950: umass_bbb_dump_cbw(struct umass_softc *sc, umass_bbb_cbw_t *cbw)
 2951: {
 2952: 	int clen = cbw->bCDBLength;
 2953: 	int dlen = UGETDW(cbw->dCBWDataTransferLength);
 2954: 	u_int8_t *c = cbw->CBWCDB;
 2955: 	int tag = UGETDW(cbw->dCBWTag);
 2956: 	int flags = cbw->bCBWFlags;
 2957: 
 2958: 	DPRINTF(UDMASS_BBB, ("%s: CBW %d: cmd = %db "
 2959: 		"(0x%02x%02x%02x%02x%02x%02x%s), "
 2960: 		"data = %db, dir = %s\n",
 2961: 		USBDEVNAME(sc->sc_dev), tag, clen,
 2962: 		c[0], c[1], c[2], c[3], c[4], c[5], (clen > 6? "...":""),
 2963: 		dlen, (flags == CBWFLAGS_IN? "in":
 2964: 		       (flags == CBWFLAGS_OUT? "out":"<invalid>"))));
 2965: }
 2966: 
 2967: Static void
 2968: umass_bbb_dump_csw(struct umass_softc *sc, umass_bbb_csw_t *csw)
 2969: {
 2970: 	int sig = UGETDW(csw->dCSWSignature);
 2971: 	int tag = UGETW(csw->dCSWTag);
 2972: 	int res = UGETDW(csw->dCSWDataResidue);
 2973: 	int status = csw->bCSWStatus;
 2974: 
 2975: 	DPRINTF(UDMASS_BBB, ("%s: CSW %d: sig = 0x%08x (%s), tag = %d, "
 2976: 		"res = %d, status = 0x%02x (%s)\n", USBDEVNAME(sc->sc_dev),
 2977: 		tag, sig, (sig == CSWSIGNATURE?  "valid":"invalid"),
 2978: 		tag, res,
 2979: 		status, (status == CSWSTATUS_GOOD? "good":
 2980: 			 (status == CSWSTATUS_FAILED? "failed":
 2981: 			  (status == CSWSTATUS_PHASE? "phase":"<invalid>")))));
 2982: }
 2983: 
 2984: Static void
 2985: umass_cbi_dump_cmd(struct umass_softc *sc, void *cmd, int cmdlen)
 2986: {
 2987: 	u_int8_t *c = cmd;
 2988: 	int dir = sc->transfer_dir;
 2989: 
 2990: 	DPRINTF(UDMASS_BBB, ("%s: cmd = %db "
 2991: 		"(0x%02x%02x%02x%02x%02x%02x%s), "
 2992: 		"data = %db, dir = %s\n",
 2993: 		USBDEVNAME(sc->sc_dev), cmdlen,
 2994: 		c[0], c[1], c[2], c[3], c[4], c[5], (cmdlen > 6? "...":""),
 2995: 		sc->transfer_datalen,
 2996: 		(dir == DIR_IN? "in":
 2997: 		 (dir == DIR_OUT? "out":
 2998: 		  (dir == DIR_NONE? "no data phase": "<invalid>")))));
 2999: }
 3000: 
 3001: Static void
 3002: umass_dump_buffer(struct umass_softc *sc, u_int8_t *buffer, int buflen,
 3003: 		  int printlen)
 3004: {
 3005: 	int i, j;
 3006: 	char s1[40];
 3007: 	char s2[40];
 3008: 	char s3[5];
 3009: 
 3010: 	s1[0] = '\0';
 3011: 	s3[0] = '\0';
 3012: 
 3013: 	sprintf(s2, " buffer=%p, buflen=%d", buffer, buflen);
 3014: 	for (i = 0; i < buflen && i < printlen; i++) {
 3015: 		j = i % 16;
 3016: 		if (j == 0 && i != 0) {
 3017: 			DPRINTF(UDMASS_GEN, ("%s: 0x %s%s\n",
 3018: 				USBDEVNAME(sc->sc_dev), s1, s2));
 3019: 			s2[0] = '\0';
 3020: 		}
 3021: 		sprintf(&s1[j*2], "%02x", buffer[i] & 0xff);
 3022: 	}
 3023: 	if (buflen > printlen)
 3024: 		sprintf(s3, " ...");
 3025: 	DPRINTF(UDMASS_GEN, ("%s: 0x %s%s%s\n",
 3026: 		USBDEVNAME(sc->sc_dev), s1, s2, s3));
 3027: }
 3028: #endif