From: aaron Date: Fri, 31 Mar 2000 22:11:37 +0000 (+0000) Subject: Add support for USB Mass Storage devices; e.g., USB Zip Drives. UNTESTED. X-Git-Url: http://artulab.com/gitweb/?a=commitdiff_plain;h=5ad2ce0f0e44112f14802bd9390d951fa932d300;p=openbsd Add support for USB Mass Storage devices; e.g., USB Zip Drives. UNTESTED. From NetBSD. --- diff --git a/sys/arch/i386/conf/GENERIC b/sys/arch/i386/conf/GENERIC index 23aea71090a..dc1386b9078 100644 --- a/sys/arch/i386/conf/GENERIC +++ b/sys/arch/i386/conf/GENERIC @@ -1,4 +1,4 @@ -# $OpenBSD: GENERIC,v 1.166 2000/03/28 19:37:45 aaron Exp $ +# $OpenBSD: GENERIC,v 1.167 2000/03/31 22:11:37 aaron Exp $ # $NetBSD: GENERIC,v 1.48 1996/05/20 18:17:23 mrg Exp $ # # GENERIC -- everything that's currently supported @@ -79,9 +79,13 @@ pcmcia* at pcic? controller ? socket ? # USB Generic HID devices #uhid* at uhub? port ? configuration ? interface ? -# USB Printer +# USB Printers #ulpt* at uhub? port ? configuration ? interface ? +# USB Mass Storage devices +#umass* at uhub? port ? configuration ? interface ? +#scsibus* at umass? + # USB Audio #uaudio* at uhub? port ? configuration ? diff --git a/sys/dev/usb/files.usb b/sys/dev/usb/files.usb index f6f0443b3c8..7f67bd41c70 100644 --- a/sys/dev/usb/files.usb +++ b/sys/dev/usb/files.usb @@ -1,4 +1,4 @@ -# $OpenBSD: files.usb,v 1.7 2000/03/28 19:37:46 aaron Exp $ +# $OpenBSD: files.usb,v 1.8 2000/03/31 22:11:37 aaron Exp $ # $NetBSD: files.usb,v 1.16 2000/02/14 20:29:54 augustss Exp $ # # Config file and device description for machine-independent USB code. @@ -43,6 +43,11 @@ device ulpt attach ulpt at uhub file dev/usb/ulpt.c ulpt needs-flag +# Mass storage +device umass: scsi +attach umass at uhub +file dev/usb/umass.c umass + # Ethernet adapters # ADMtek AN986 Pegasus device aue: ether, ifnet, mii, ifmedia diff --git a/sys/dev/usb/umass.c b/sys/dev/usb/umass.c new file mode 100644 index 00000000000..51aeefd3aee --- /dev/null +++ b/sys/dev/usb/umass.c @@ -0,0 +1,964 @@ +/* $OpenBSD: umass.c,v 1.1 2000/03/31 22:11:37 aaron Exp $ */ +/* $NetBSD: umass.c,v 1.27 2000/03/29 18:30:46 augustss Exp $ */ + +/*- + * Copyright (c) 1999 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Jason R. Thorpe. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/*- + * Copyright (c) 1999 MAEKAWA Masahide , + * Nick Hibma + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * FreeBSD: src/sys/dev/usb/umass.c,v 1.8 1999/06/20 15:46:13 n_hibma Exp + */ + +/* + * Universal Serial Bus Mass Storage Class Control/Interrupt/Bulk (CBI) + * Specification: + * + * http://www.usb.org/developers/data/usbmass-cbi10.pdf + * + * Universal Serial Bus Mass Storage Bulk Only 1.0rc4 Specification: + * + * http://www.usb.org/developers/data/usbmassbulk_10rc4.pdf + * + * Relevant parts of the old spec (Bulk-only 0.9) have been quoted + * in the source. + */ + +/* To do: + * x The umass_usb_transfer routine uses synchroneous transfers. This + * should be changed to async and state handling. + * + * x Should handle more than just Iomega USB Zip drives. There are + * a fair number of USB->SCSI dongles out there. + * + * x Need to implement SCSI command timeout/abort handling. + * + * x Add support for other than Bulk. + * + * x Add support for other than SCSI. + */ + +/* Authors: (with short acronyms for comments) + * NWH - Nick Hibma + * JRT - Jason R. Thorpe + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#if defined(__OpenBSD__) +#include +#include +#else +#include +#include +#include +#endif + +#if defined(USB_DEBUG) && !defined(UMASS_DEBUG) +#define UMASS_DEBUG 1 +#endif + +#ifdef UMASS_DEBUG +#define DPRINTF(m, x) if (umassdebug & (m)) logprintf x +#define UDMASS_SCSI 0x00020000 +#define UDMASS_USB 0x00040000 +#define UDMASS_BULK 0x00080000 +#define UDMASS_ALL 0xffff0000 +int umassdebug = /* UDMASS_SCSI|UDMASS_BULK|UDMASS_USB */ 0; +#else +#define DPRINTF(m, x) +#endif + +typedef struct umass_softc { + USBBASEDEVICE sc_dev; /* base device */ + usbd_device_handle sc_udev; + usbd_interface_handle sc_iface; /* the interface we use */ + + u_int8_t sc_subclass; /* our USB subclass */ + u_int8_t sc_protocol; /* our USB protocol */ + + u_int8_t sc_bulkout; /* bulk-out Endpoint Address */ + usbd_pipe_handle sc_bulkout_pipe; + u_int8_t sc_bulkin; /* bulk-in Endpoint Address */ + usbd_pipe_handle sc_bulkin_pipe; + + struct scsipi_link sc_link; /* prototype for devs */ + struct scsipi_adapter sc_adapter; + + device_ptr_t sc_child; /* child device, for detach */ + + int sc_refcnt; + char sc_dying; +} umass_softc_t; + +#define USBD_COMMAND_FAILED USBD_INVAL /* redefine some errors for */ + +#define UMASS_SCSIID_HOST 0x00 +#define UMASS_SCSIID_DEVICE 0x01 + +#define DIR_OUT 0 +#define DIR_IN 1 +#define DIR_NONE 2 + +/* Bulk-Only specific request */ +#define UR_RESET 0xff +#define UR_GET_MAX_LUN 0xfe + +/* Bulk-Only Mass Storage features */ +/* Command Block Wrapper */ +typedef struct { + uDWord dCBWSignature; +#define CBWSIGNATURE 0x43425355 + uDWord dCBWTag; + uDWord dCBWDataTransferLength; + uByte bCBWFlags; +#define CBWFLAGS_OUT 0x00 +#define CBWFLAGS_IN 0x80 + uByte bCBWLUN; + uByte bCDBLength; + uByte CBWCDB[16]; +} usb_bulk_cbw_t; +#define USB_BULK_CBW_SIZE 31 + +/* Command Status Wrapper */ +typedef struct { + uDWord dCSWSignature; +#define CSWSIGNATURE 0x53425355 + uDWord dCSWTag; + uDWord dCSWDataResidue; + uByte bCSWStatus; +#define CSWSTATUS_GOOD 0x0 +#define CSWSTATUS_FAILED 0x1 +#define CSWSTATUS_PHASE 0x2 +} usb_bulk_csw_t; +#define USB_BULK_CSW_SIZE 13 + + +USB_DECLARE_DRIVER(umass); + +/* USB related functions */ +usbd_status umass_usb_transfer __P((umass_softc_t *, + usbd_pipe_handle pipe, + void *buf, int buflen, + int flags, int *xfer_size)); + +/* Bulk-Only related functions */ +usbd_status umass_bulk_reset __P((umass_softc_t *sc)); +usbd_status umass_bulk_get_max_lun __P((umass_softc_t *sc, u_int8_t *maxlun)); +usbd_status umass_bulk_transfer __P((umass_softc_t *sc, int lun, + void *cmd, int cmdlen, + void *data, int datalen, + int dir, int *residue)); + +/* SCSIPI related functions */ +struct scsipi_device umass_dev = { + NULL, /* Use default error handler */ + NULL, /* have a queue, served by this */ + NULL, /* have no async handler */ + NULL, /* Use default `done' routine */ +}; + +void umass_scsipi_minphys __P((struct buf *)); +int umass_scsipi_scsi_cmd __P((struct scsipi_xfer *)); + + + +USB_MATCH(umass) +{ + USB_MATCH_START(umass, uaa); + usb_interface_descriptor_t *id; + + if (uaa->iface == NULL) + return(UMATCH_NONE); + + id = usbd_get_interface_descriptor(uaa->iface); + if (id != NULL + && id->bInterfaceClass == UICLASS_MASS + && id->bInterfaceSubClass == UISUBCLASS_SCSI + && id->bInterfaceProtocol == UIPROTO_MASS_BBB_P) + return(UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); + + return(UMATCH_NONE); +} + +USB_ATTACH(umass) +{ + USB_ATTACH_START(umass, sc, uaa); + usb_interface_descriptor_t *id; + usb_endpoint_descriptor_t *ed; + char devinfo[1024]; + usbd_status err; + int i; + u_int8_t maxlun; + const char *subclass, *protocol; + + sc->sc_udev = uaa->device; + sc->sc_iface = uaa->iface; + sc->sc_bulkout_pipe = NULL; + sc->sc_bulkin_pipe = NULL; + + usbd_devinfo(uaa->device, 0, devinfo); + USB_ATTACH_SETUP; + + id = usbd_get_interface_descriptor(sc->sc_iface); + + sc->sc_subclass = id->bInterfaceSubClass; + sc->sc_protocol = id->bInterfaceProtocol; + + switch (sc->sc_subclass) { +#if 0 + case UISUBCLASS_RBC: subclass = "RBC"; break; + case UISUBCLASS_SFF8020I: subclass = "8020i"; break; + case UISUBCLASS_QIC157: subclass = "QIC157"; break; + case UISUBCLASS_UFI: subclass = "UFI"; break; + case UISUBCLASS_SFF8070I: subclass = "8070i"; break; +#endif + case UISUBCLASS_SCSI: subclass = "SCSI"; break; + default: + panic("umass_attach: impossible subclass"); + } + + switch (sc->sc_protocol) { +#if 0 + case UIPROTO_MASS_CBI_I: protocol = "CBI with CCI"; break; + case UIPROTO_MASS_CBI: protocol = "CBI"; break; +#endif + case UIPROTO_MASS_BBB: /* XXX Is this really right? */ + case UIPROTO_MASS_BBB_P: protocol = "Bulk-Only"; break; + default: + panic("umass_attach: impossible protocol"); + } + + printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo); + printf("%s: %s over %s (iclass %d/%d/%d)\n", USBDEVNAME(sc->sc_dev), + subclass, protocol, id->bInterfaceClass, id->bInterfaceSubClass, + id->bInterfaceProtocol); + + /* + * A Bulk-Only Mass Storage device supports the following endpoints, + * in addition to the Endpoint 0 for Control transfer that is required + * of all USB devices: + * (a) bulk-in endpoint. + * (b) bulk-out endpoint. + * + * The endpoint addresses are not fixed, so we have to read them + * from the device descriptors of the current interface. + */ + for (i = 0 ; i < id->bNumEndpoints ; i++) { + ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i); + if (ed == NULL) { + printf("%s: could not read endpoint descriptor\n", + USBDEVNAME(sc->sc_dev)); + USB_ATTACH_ERROR_RETURN; + } + if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN + && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { + sc->sc_bulkin = ed->bEndpointAddress; + } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT + && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { + sc->sc_bulkout = ed->bEndpointAddress; + } + } + + /* + * Get the maximum LUN supported by the device. + */ + err = umass_bulk_get_max_lun(sc, &maxlun); + if (err) { + printf("%s: unable to get Max Lun: %s\n", + USBDEVNAME(sc->sc_dev), usbd_errstr(err)); + USB_ATTACH_ERROR_RETURN; + } + + /* Open the bulk-in and -out pipe */ + err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout, + USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe); + if (err) { + DPRINTF(UDMASS_USB,("cannot open bulk out pipe (address %d)\n", + sc->sc_bulkout)); + USB_ATTACH_ERROR_RETURN; + } + err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin, + USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe); + if (err) { + DPRINTF(UDMASS_USB,("cannot open bulk in pipe (address %d)\n", + sc->sc_bulkin)); + usbd_close_pipe(sc->sc_bulkout_pipe); + USB_ATTACH_ERROR_RETURN; + } + + /* attach the device to the SCSIPI layer */ + sc->sc_adapter.scsipi_cmd = umass_scsipi_scsi_cmd; + sc->sc_adapter.scsipi_minphys = umass_scsipi_minphys; + + sc->sc_link.adapter_softc = sc; + sc->sc_link.adapter = &sc->sc_adapter; + sc->sc_link.device = &umass_dev; + sc->sc_link.openings = 1; +#if defined(__OpenBSD__) + sc->sc_link.adapter_target = UMASS_SCSIID_HOST; +#else + sc->sc_link.scsipi_scsi.adapter_target = UMASS_SCSIID_HOST; + sc->sc_link.scsipi_scsi.channel = SCSI_CHANNEL_ONLY_ONE; + sc->sc_link.scsipi_scsi.max_target = UMASS_SCSIID_DEVICE; /* XXX */ + sc->sc_link.scsipi_scsi.max_lun = maxlun; + sc->sc_link.type = BUS_SCSI; +#endif + + sc->sc_child = config_found(&sc->sc_dev, &sc->sc_link, scsiprint); + if (sc->sc_child == NULL) { + usbd_close_pipe(sc->sc_bulkout_pipe); + usbd_close_pipe(sc->sc_bulkin_pipe); + /* XXX Not really an error. */ + USB_ATTACH_ERROR_RETURN; + } + + usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, + USBDEV(sc->sc_dev)); + + USB_ATTACH_SUCCESS_RETURN; +} + +int +umass_activate(self, act) + struct device *self; + enum devact act; +{ + struct umass_softc *sc = (struct umass_softc *) self; + int s, rv = 0; + + DPRINTF(UDMASS_USB, ("%s: umass_activate: %d\n", + USBDEVNAME(sc->sc_dev), act)); + + s = splhigh(); + switch (act) { + case DVACT_ACTIVATE: + rv = EOPNOTSUPP; + break; + + case DVACT_DEACTIVATE: + if (sc->sc_child == NULL || sc->sc_dying) + break; + rv = config_deactivate(sc->sc_child); + DPRINTF(UDMASS_USB, ("%s: umass_activate: child " + "returned %d\n", USBDEVNAME(sc->sc_dev), rv)); + if (rv == 0) + sc->sc_dying = 1; + break; + } + splx(s); + return (rv); +} + +USB_DETACH(umass) +{ + USB_DETACH_START(umass, sc); + int s, rv = 0; + + DPRINTF(UDMASS_USB, ("%s: umass_detach: flags 0x%x\n", + USBDEVNAME(sc->sc_dev), flags)); + + if (sc->sc_child != NULL) + rv = config_detach(sc->sc_child, flags); + + if (rv != 0) + return (rv); + + /* Abort the pipes to wake up any waiting processes. */ + if (sc->sc_bulkin_pipe != NULL) + usbd_abort_pipe(sc->sc_bulkin_pipe); + if (sc->sc_bulkout_pipe != NULL) + usbd_abort_pipe(sc->sc_bulkout_pipe); + + s = splusb(); + if (--sc->sc_refcnt >= 0) { + /* Wait for processes to go away. */ + usb_detach_wait(USBDEV(sc->sc_dev)); + } + splx(s); + + if (sc->sc_bulkin_pipe != NULL) { + usbd_close_pipe(sc->sc_bulkin_pipe); + sc->sc_bulkin_pipe = NULL; + } + if (sc->sc_bulkout_pipe != NULL) { + usbd_close_pipe(sc->sc_bulkout_pipe); + sc->sc_bulkout_pipe = NULL; + } + + usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, + USBDEV(sc->sc_dev)); + + return (rv); +} + +/* Performs a request over a pipe. + * + * flags: Can be set to USBD_SHORT_XFER_OK + * xfer_size: if not null returns the nr. of bytes transferred + * + * If the returned error is USBD_STALLED the pipe stall has + * been cleared again. + */ + +usbd_status +umass_usb_transfer(umass_softc_t *sc, usbd_pipe_handle pipe, + void *buf, int buflen, int flags, int *xfer_size) +{ + usbd_xfer_handle xfer; + usbd_private_handle priv; + void *buffer; + int size; + usbd_status err; + + /* A transfer is done synchronously. We create and schedule the + * transfer and then wait for it to complete + */ + + xfer = usbd_alloc_xfer(usbd_pipe2device_handle(pipe)); + if (xfer == NULL) { + DPRINTF(UDMASS_USB, ("%s: not enough memory\n", + USBDEVNAME(sc->sc_dev))); + return USBD_NOMEM; + } + + usbd_setup_xfer(xfer, pipe, 0, buf, buflen,flags, 3000/*ms*/, NULL); + err = usbd_sync_transfer(xfer); + if (err) { + DPRINTF(UDMASS_USB, ("%s: transfer failed: %s\n", + USBDEVNAME(sc->sc_dev), usbd_errstr(err))); + usbd_free_xfer(xfer); + return(err); + } + + usbd_get_xfer_status(xfer, &priv, &buffer, &size, &err); + + if (xfer_size != NULL) + *xfer_size = size; + + usbd_free_xfer(xfer); + return(USBD_NORMAL_COMPLETION); +} + +usbd_status +umass_bulk_get_max_lun(umass_softc_t *sc, u_int8_t *maxlun) +{ + usbd_device_handle dev; + usb_device_request_t req; + usbd_status err; + usb_interface_descriptor_t *id; + + *maxlun = 0; /* Default to 0. */ + + DPRINTF(UDMASS_BULK, ("%s: Get Max Lun\n", USBDEVNAME(sc->sc_dev))); + + usbd_interface2device_handle(sc->sc_iface, &dev); + id = usbd_get_interface_descriptor(sc->sc_iface); + + /* The Get Max Lun command is a class-specific request. */ + req.bmRequestType = UT_READ_CLASS_INTERFACE; + req.bRequest = UR_GET_MAX_LUN; + USETW(req.wValue, 0); + USETW(req.wIndex, id->bInterfaceNumber); + USETW(req.wLength, 1); + + err = usbd_do_request(dev, &req, maxlun); + switch (err) { + case USBD_NORMAL_COMPLETION: + DPRINTF(UDMASS_BULK, ("%s: Max Lun %d\n", + USBDEVNAME(sc->sc_dev), *maxlun)); + break; + + case USBD_STALLED: + /* + * Device doesn't support Get Max Lun request. + */ + err = USBD_NORMAL_COMPLETION; + DPRINTF(UDMASS_BULK, ("%s: Get Max Lun not supported\n", + USBDEVNAME(sc->sc_dev))); + break; + + case USBD_SHORT_XFER: + /* + * XXX This must mean Get Max Lun is not supported, too! + */ + err = USBD_NORMAL_COMPLETION; + DPRINTF(UDMASS_BULK, ("%s: Get Max Lun SHORT_XFER\n", + USBDEVNAME(sc->sc_dev))); + break; + + default: + printf("%s: Get Max Lun failed: %s\n", + USBDEVNAME(sc->sc_dev), usbd_errstr(err)); + /* XXX Should we port_reset the device? */ + break; + } + + return (err); +} + +usbd_status +umass_bulk_reset(umass_softc_t *sc) +{ + usbd_device_handle dev; + usb_device_request_t req; + usbd_status err; + usb_interface_descriptor_t *id; + + /* + * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class) + * + * For Reset Recovery the host shall issue in the following order: + * a) a Bulk-Only Mass Storage Reset + * b) a Clear Feature HALT to the Bulk-In endpoint + * c) a Clear Feature HALT to the Bulk-Out endpoint + */ + + DPRINTF(UDMASS_BULK, ("%s: Reset\n", + USBDEVNAME(sc->sc_dev))); + + usbd_interface2device_handle(sc->sc_iface, &dev); + id = usbd_get_interface_descriptor(sc->sc_iface); + + /* the reset command is a class specific interface request */ + req.bmRequestType = UT_WRITE_CLASS_INTERFACE; + req.bRequest = UR_RESET; + USETW(req.wValue, 0); + USETW(req.wIndex, id->bInterfaceNumber); + USETW(req.wLength, 0); + + err = usbd_do_request(dev, &req, 0); + if (err) { + printf("%s: Reset failed, %s\n", + USBDEVNAME(sc->sc_dev), usbd_errstr(err)); + /* XXX we should port_reset the device */ + return(err); + } + + usbd_clear_endpoint_stall(sc->sc_bulkout_pipe); + usbd_clear_endpoint_stall(sc->sc_bulkin_pipe); + +#if 0 + /* + * XXX we should convert this into a more friendly delay. + * Perhaps a tsleep (or is this routine run from int context?) + */ + + DELAY(2500000 /*us*/); +#else + usbd_delay_ms(dev, 2500); +#endif + + return(USBD_NORMAL_COMPLETION); +} + +/* + * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly + * a data phase of datalen bytes from/to data and finally a csw read + * phase. + * + * If the data direction was inbound a maximum of datalen bytes + * is stored in the buffer pointed to by data. + * The status returned is USBD_NORMAL_COMPLETION, + * USBD_IOERROR, USBD_COMMAND_FAILED. + * In the last case *residue is set to the residue from the CSW, + * otherwise to 0. + * + * For the functionality of this subroutine see the Mass Storage + * Spec., the graphs on page 14 and page 19 and beyong (v0.9 of + * the spec). + */ + +usbd_status +umass_bulk_transfer(umass_softc_t *sc, int lun, void *cmd, int cmdlen, + void *data, int datalen, int dir, int *residue) +{ + static int dCBWtag = 42; /* tag to be used in transfers, + * incremented at each transfer */ + usb_bulk_cbw_t cbw; /* command block wrapper struct */ + usb_bulk_csw_t csw; /* command status wrapper struct */ + u_int32_t n = 0; /* number of bytes transported */ + usbd_status err; + +#ifdef UMASS_DEBUG + u_int8_t *c = cmd; + + /* check the given arguments */ + if (data == NULL && datalen > 0) { /* no buffer for transfer */ + DPRINTF(UDMASS_BULK, ("%s: no buffer, but datalen > 0 !\n", + USBDEVNAME(sc->sc_dev))); + return USBD_IOERROR; + } + + DPRINTF(UDMASS_BULK, ("%s: cmd: %d bytes (0x%02x%02x%02x%02x%02x%02x%s)" + ", data: %d bytes, dir: %s\n", + USBDEVNAME(sc->sc_dev), + cmdlen, c[0], c[1], c[2], c[3], c[4], c[5], + (cmdlen > 6? "...":""), + datalen, (dir == DIR_IN? "in":"out"))); +#endif + + if (dir == DIR_NONE || datalen == 0) { /* make sure they correspond */ + datalen = 0; + dir = DIR_NONE; + } + + if (residue != NULL) + *residue = 0; /* reset residue */ + + /* + * Determine the direction of transferring data and data length. + * + * dCBWDataTransferLength (datalen) : + * This field indicates the number of bytes of data that the host + * intends to transfer on the IN or OUT Bulk endpoint(as indicated by + * the Direction bit) during the execution of this command. If this + * field is set to 0, the device will expect that no data will be + * transferred IN or OUT during this command, regardless of the value + * of the Direction bit defined in dCBWFlags. + * + * dCBWFlags (dir) : + * The bits of the Flags field are defined as follows: + * Bits 0-6 reserved + * Bit 7 Direction - this bit shall be ignored if the + * dCBWDataTransferLength field is zero. + * 0 = data Out from host to device + * 1 = data In from device to host + */ + + + /* + * Command transport phase + */ + + /* Fill in the Command Block Wrapper */ + USETDW(cbw.dCBWSignature, CBWSIGNATURE); + USETDW(cbw.dCBWTag, dCBWtag++); + USETDW(cbw.dCBWDataTransferLength, datalen); + /* we do not check for DIR_NONE below (see text on dCBWFlags above) */ + cbw.bCBWFlags = (dir == DIR_IN? CBWFLAGS_IN:CBWFLAGS_OUT); + cbw.bCBWLUN = lun; + cbw.bCDBLength = cmdlen; + bcopy(cmd, cbw.CBWCDB, cmdlen); + + /* Send the CBW from host to device via bulk-out endpoint. */ + err = umass_usb_transfer(sc, sc->sc_bulkout_pipe, + &cbw, USB_BULK_CBW_SIZE, 0, NULL); + if (err) { + DPRINTF(UDMASS_BULK, ("%s: failed to send CBW\n", + USBDEVNAME(sc->sc_dev))); + /* If the device detects that the CBW is invalid, then the + * device may STALL both bulk endpoints and require a + * Bulk-Only MS Reset + */ + if (!sc->sc_dying) + umass_bulk_reset(sc); + return(USBD_IOERROR); + } + + + /* + * Data transport phase (only if there is data to be sent/received) + */ + + if (dir == DIR_IN) { + /* we allow short transfers for bulk-in pipes */ + err = umass_usb_transfer(sc, sc->sc_bulkin_pipe, + data, datalen, + USBD_SHORT_XFER_OK, &n); + if (err) + DPRINTF(UDMASS_BULK, ("%s: failed to receive data, " + "(%d bytes, n = %d), %s\n", + USBDEVNAME(sc->sc_dev), + datalen, n, usbd_errstr(err))); + } else if (dir == DIR_OUT) { + err = umass_usb_transfer(sc, sc->sc_bulkout_pipe, + data, datalen, 0, &n); + if (err) + DPRINTF(UDMASS_BULK, ("%s: failed to send data, " + "(%d bytes, n = %d), %s\n", + USBDEVNAME(sc->sc_dev), + datalen, n, usbd_errstr(err))); + } + if (err && err != USBD_STALLED) + return(USBD_IOERROR); + + + /* + * Status transport phase + */ + + /* Read the Command Status Wrapper via bulk-in endpoint. */ + err = umass_usb_transfer(sc, sc->sc_bulkin_pipe, + &csw, USB_BULK_CSW_SIZE, 0, NULL); + /* Try again if the bulk-in pipe was stalled */ + if (err == USBD_STALLED) { + err = usbd_clear_endpoint_stall(sc->sc_bulkin_pipe); + if (!err) { + err = umass_usb_transfer(sc, sc->sc_bulkin_pipe, + &csw, USB_BULK_CSW_SIZE, 0, NULL); + } + } + if (err && err != USBD_STALLED) + return(USBD_IOERROR); + + /* + * Check the CSW for status and validity, and check for fatal errors + */ + + /* Invalid CSW: Wrong signature or wrong tag might indicate + * that the device is confused -> reset it. + * Other fatal errors: STALL on read of CSW and Phase error + * or unknown status. + */ + if (err == USBD_STALLED + || UGETDW(csw.dCSWSignature) != CSWSIGNATURE + || UGETDW(csw.dCSWTag) != UGETDW(cbw.dCBWTag) + || csw.bCSWStatus == CSWSTATUS_PHASE + || csw.bCSWStatus > CSWSTATUS_PHASE) { + if (err) { + printf("%s: failed to read CSW, %s\n", + USBDEVNAME(sc->sc_dev), usbd_errstr(err)); + } else if (csw.bCSWStatus == CSWSTATUS_PHASE) { + printf("%s: Phase Error, residue = %d, n = %d\n", + USBDEVNAME(sc->sc_dev), + UGETDW(csw.dCSWDataResidue), n); + } else if (csw.bCSWStatus > CSWSTATUS_PHASE) { + printf("%s: Unknown status %d in CSW\n", + USBDEVNAME(sc->sc_dev), csw.bCSWStatus); + } else { + printf("%s: invalid CSW, sig = 0x%08x, tag = %d (!= %d)\n", + USBDEVNAME(sc->sc_dev), + UGETDW(csw.dCSWSignature), + UGETDW(csw.dCSWTag), UGETDW(cbw.dCBWTag)); + } + umass_bulk_reset(sc); + return(USBD_IOERROR); + } + + if (csw.bCSWStatus == CSWSTATUS_FAILED) { + DPRINTF(UDMASS_BULK, ("%s: Command Failed, " + "residue = %d, n = %d\n", + USBDEVNAME(sc->sc_dev), + UGETDW(csw.dCSWDataResidue), n)); + if (residue != NULL) + *residue = UGETDW(csw.dCSWDataResidue); + return(USBD_COMMAND_FAILED); + } + + /* + * XXX a residue not equal to 0 might indicate that something + * is wrong. Does CAM high level drivers check this for us? + */ + + return(USBD_NORMAL_COMPLETION); +} + + +/* + * SCSIPI specific functions + */ + +int +umass_scsipi_scsi_cmd(xs) + struct scsipi_xfer *xs; +{ + struct scsipi_link *sc_link = xs->sc_link; + struct umass_softc *sc = sc_link->adapter_softc; + int residue, dir; + usbd_status err; + struct scsipi_sense sense_cmd; + + DPRINTF(UDMASS_SCSI, ("%s: umass_scsi_cmd %d:%d\n", + USBDEVNAME(sc->sc_dev), + sc_link->scsipi_scsi.target, sc_link->scsipi_scsi.lun)); + + if (sc->sc_dying) { + xs->xs_status |= XS_STS_DONE; + xs->error = XS_DRIVER_STUFFUP; + scsipi_done(xs); + if (xs->xs_control & XS_CTL_POLL) + return (COMPLETE); + else + return (SUCCESSFULLY_QUEUED); + } + +#ifdef UMASS_DEBUG + if (sc_link->scsipi_scsi.target != UMASS_SCSIID_DEVICE) { + DPRINTF(UDMASS_SCSI, ("%s: Wrong SCSI ID %d\n", + USBDEVNAME(sc->sc_dev), + sc_link->scsipi_scsi.target)); + xs->error = XS_DRIVER_STUFFUP; + return (COMPLETE); + } +#endif + + dir = DIR_NONE; + if (xs->datalen) { + switch (xs->xs_control & (XS_CTL_DATA_IN|XS_CTL_DATA_OUT)) { + case XS_CTL_DATA_IN: + dir = DIR_IN; + break; + case XS_CTL_DATA_OUT: + dir = DIR_OUT; + break; + } + } + + /* Make sure we don't lose our softc. */ + sc->sc_refcnt++; + +#if defined(__OpenBSD__) + err = umass_bulk_transfer(sc, sc_link->lun, + xs->cmd, xs->cmdlen, xs->data, xs->datalen, dir, &residue); +#else + err = umass_bulk_transfer(sc, sc_link->scsipi_scsi.lun, + xs->cmd, xs->cmdlen, xs->data, xs->datalen, dir, &residue); +#endif + + /* + * FAILED commands are supposed to be SCSI failed commands + * and are therefore considered to be successfull CDW/CSW + * transfers. PHASE errors are more serious and should return + * an error to the SCSIPI system. + * + * XXX This is however more based on empirical evidence than on + * hard proof from the Bulk-Only spec. + */ + if (err == USBD_NORMAL_COMPLETION) { + xs->error = XS_NOERROR; + } else if (sc->sc_dying) { + /* We are being detached, no use talking to the device. */ + xs->error = XS_DRIVER_STUFFUP; + } else { + DPRINTF(UDMASS_USB|UDMASS_SCSI, ("%s: bulk transfer completed " + "with error %s\n", USBDEVNAME(sc->sc_dev), + usbd_errstr(err))); + + /* + * Probably have a CHECK CONDITION here. Issue a + * REQUEST SENSE. + */ + memset(&sense_cmd, 0, sizeof(sense_cmd)); + sense_cmd.opcode = REQUEST_SENSE; +#if defined(__OpenBSD__) + sense_cmd.byte2 = sc_link->lun << + SCSI_CMD_LUN_SHIFT; +#else + sense_cmd.byte2 = sc_link->scsipi_scsi.lun << + SCSI_CMD_LUN_SHIFT; +#endif + sense_cmd.length = sizeof(xs->sense); + +#if defined(__OpenBSD__) + if ((err = umass_bulk_transfer(sc, sc_link->lun, +#else + if ((err = umass_bulk_transfer(sc, sc_link->scsipi_scsi.lun, +#endif + (struct scsipi_generic *)&sense_cmd, sizeof(sense_cmd), + &xs->sense, sizeof(xs->sense), DIR_IN, NULL)) != + USBD_NORMAL_COMPLETION) { + DPRINTF(UDMASS_SCSI, ("%s: REQUEST SENSE failed: %s\n", + USBDEVNAME(sc->sc_dev), usbd_errstr(err))); + xs->error = XS_DRIVER_STUFFUP; /* XXX */ + } else + xs->error = XS_SENSE; + } + xs->resid = residue; + + DPRINTF(UDMASS_SCSI, ("%s: umass_scsi_cmd: error = %d, resid = 0x%x\n", + USBDEVNAME(sc->sc_dev), xs->error, xs->resid)); + + xs->xs_status |= XS_STS_DONE; + scsipi_done(xs); + + /* We are done with the softc for now. */ + if (--sc->sc_refcnt < 0) + usb_detach_wakeup(USBDEV(sc->sc_dev)); + + /* + * XXXJRT We must return successfully queued if we're an + * XXXJRT `asynchronous' command, otherwise `xs' will be + * XXXJRT freed twice: once in scsipi_done(), and once in + * XXXJRT scsi_scsipi_cmd(). + */ + if ((xs->xs_control & XS_CTL_POLL) == 0) + return (SUCCESSFULLY_QUEUED); + + return (COMPLETE); +} + +void +umass_scsipi_minphys(bp) + struct buf *bp; +{ + + /* No limit here. */ + minphys(bp); +} diff --git a/sys/dev/usb/usb_port.h b/sys/dev/usb/usb_port.h index 645d9e22eb9..20448e5b180 100644 --- a/sys/dev/usb/usb_port.h +++ b/sys/dev/usb/usb_port.h @@ -1,4 +1,4 @@ -/* $OpenBSD: usb_port.h,v 1.9 2000/03/30 16:19:33 aaron Exp $ */ +/* $OpenBSD: usb_port.h,v 1.10 2000/03/31 22:11:37 aaron Exp $ */ /* $NetBSD: usb_port.h,v 1.28 2000/03/30 08:53:31 augustss Exp $ */ /* $FreeBSD: src/sys/dev/usb/usb_port.h,v 1.21 1999/11/17 22:33:47 n_hibma Exp $ */ @@ -187,6 +187,21 @@ __CONCAT(dname,_detach)(self, flags) \ #define Static +#define XS_STS_DONE ITSDONE +#define XS_CTL_POLL SCSI_POLL +#define XS_CTL_DATA_IN SCSI_DATA_IN +#define XS_CTL_DATA_OUT SCSI_DATA_OUT +#define scsipi_adapter scsi_adapter +#define scsipi_cmd scsi_cmd +#define scsipi_device scsi_device +#define scsipi_done scsi_done +#define scsipi_link scsi_link +#define scsipi_minphys scsi_minphys +#define scsipi_sense scsi_sense +#define scsipi_xfer scsi_xfer +#define xs_control flags +#define xs_status status + #define memcpy(d, s, l) bcopy((s),(d),(l)) #define memset(d, v, l) bzero((d),(l)) #define bswap32(x) swap32(x)