Changeset 55054db0 in mainline

Timestamp:

2011-05-13T13:44:19Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

852803a

Parents:

3e4f2e0 (diff), c372e03 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge development/ changes

Location:

uspace

Files:

• drv/ehci-hcd/pci.c (modified) (4 diffs)
• drv/uhci-rhd/port.c (modified) (5 diffs)
• drv/usbmast/Makefile (modified) (1 diff)
• drv/usbmast/inquiry.c (added)
• drv/usbmast/main.c (modified) (2 diffs)
• drv/usbmast/mast.c (modified) (4 diffs)
• drv/usbmast/mast.h (modified) (1 diff)
• lib/usbdev/include/usb/request.h (modified) (1 diff)
• lib/usbdev/src/request.c (modified) (1 diff)

uspace/drv/ehci-hcd/pci.c

@@ -54 +54 @@
 
 #define CMD_OFFSET 0x0
-#define CONFIGFLAG_OFFSET 0x40
+#define STS_OFFSET 0x4
+#define CFG_OFFSET 0x40
 
 #define USBCMD_RUN 1
@@ -264 +265 @@
          * It would prevent pre-OS code from interfering. */
         ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-           IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGCTLSTS_OFFSET, 0);
+           IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGCTLSTS_OFFSET,
+           0xe0000000);
         CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) zero USBLEGCTLSTS.\n", ret);
-        usb_log_debug("Zeroed USBLEGCTLSTS register.\n");
 
         /* Read again Legacy Support and Control register */
@@ -291 +292 @@
         volatile uint32_t *usbcmd =
             (uint32_t*)((uint8_t*)registers + operation_offset + CMD_OFFSET);
+        volatile uint32_t *usbsts =
+            (uint32_t*)((uint8_t*)registers + operation_offset + STS_OFFSET);
         volatile uint32_t *usbconfigured =
-            (uint32_t*)((uint8_t*)registers + operation_offset
-            + CONFIGFLAG_OFFSET);
+            (uint32_t*)((uint8_t*)registers + operation_offset + CFG_OFFSET);
         usb_log_debug("USBCMD value: %x.\n", *usbcmd);
         if (*usbcmd & USBCMD_RUN) {
                 *usbcmd = 0;
+                while (!(*usbsts & (1 << 12))); /*wait until hc is halted */
                 *usbconfigured = 0;
                 usb_log_info("EHCI turned off.\n");
@@ -302 +305 @@
                 usb_log_info("EHCI was not running.\n");
         }
+        usb_log_debug("Registers: %x(0x00080000):%x(0x00001000):%x(0x0).\n",
+            *usbcmd, *usbsts, *usbconfigured);
 
         async_hangup(parent_phone);

uspace/drv/uhci-rhd/port.c

@@ -32 +32 @@
  * @brief UHCI root hub port routines
  */
-#include <libarch/ddi.h> /* pio_read and pio_write */
+#include <libarch/ddi.h>  /* pio_read and pio_write */
+#include <fibril_synch.h> /* async_usleep */
 #include <errno.h>
 #include <str_error.h>
-#include <fibril_synch.h>
 
 #include <usb/usb.h>    /* usb_address_t */
-#include <usb/hub.h>
+#include <usb/hub.h>    /* usb_hc_new_device_wrapper */
 #include <usb/debug.h>
 
@@ -212 +212 @@
 
         /*
-         * The host then waits for at least 100 ms to allow completion of
-         * an insertion process and for power at the device to become stable.
-         */
-        async_usleep(100000);
-
-        /*
-         * Resets from root ports should be nominally 50ms
+         * Resets from root ports should be nominally 50ms (USB spec 7.1.7.3)
          */
         {
@@ -229 +223 @@
                 port_status &= ~STATUS_IN_RESET;
                 uhci_port_write_status(port, port_status);
-                usb_log_debug("%s: Reset Signal stop.\n", port->id_string);
-        }
-
-        /* the reset recovery time 10ms */
-        async_usleep(10000);
-
+                while (uhci_port_read_status(port) & STATUS_IN_RESET);
+                // TODO: find a better way to waste time (it should be less than
+                // 10ms, if we reschedule it takes too much time (random
+                // interrupts can be solved by multiple attempts).
+                usb_log_debug2("%s: Reset Signal stop.\n", port->id_string);
+        }
         /* Enable the port. */
         uhci_port_set_enabled(port, true);
+
+        /* Reset recovery period,
+         * devices do not have to respond during this period
+         */
+        async_usleep(10000);
         return EOK;
 }
@@ -255 +254 @@
         usb_log_debug("%s: Detected new device.\n", port->id_string);
 
+        int ret, count = 0;
         usb_address_t dev_addr;
-        int ret = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
-            speed, uhci_port_reset_enable, port->number, port,
-            &dev_addr, &port->attached_device, NULL, NULL, NULL);
+        do {
+                ret = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
+                    speed, uhci_port_reset_enable, port->number, port,
+                    &dev_addr, &port->attached_device, NULL, NULL, NULL);
+        } while (ret != EOK && ++count < 4);
 
         if (ret != EOK) {
@@ -313 +315 @@
         /* Wait for port to become enabled */
         do {
-                async_usleep(1000);
                 port_status = uhci_port_read_status(port);
         } while ((port_status & STATUS_CONNECTED) &&

uspace/drv/usbmast/Makefile

@@ -41 +41 @@
 
 SOURCES = \
+        inquiry.c \
         main.c \
         mast.c

uspace/drv/usbmast/main.c

@@ -75 +75 @@
 };
 
-#define BITS_GET_MASK(type, bitcount) (((type)(1 << (bitcount)))-1)
-#define BITS_GET_MID_MASK(type, bitcount, offset) \
-        ((type)( BITS_GET_MASK(type, (bitcount) + (offset)) - BITS_GET_MASK(type, bitcount) ))
-#define BITS_GET(type, number, bitcount, offset) \
-        ((type)( (number) & (BITS_GET_MID_MASK(type, bitcount, offset)) ) >> (offset))
-
-#define INQUIRY_RESPONSE_LENGTH 35
-
-static void try_inquiry(usb_device_t *dev)
-{
-        scsi_cmd_inquiry_t inquiry = {
-                .op_code = 0x12,
-                .lun_evpd = 0,
-                .page_code = 0,
-                .alloc_length = INQUIRY_RESPONSE_LENGTH,
-                .ctrl = 0
-        };
-        size_t response_len;
-        uint8_t response[INQUIRY_RESPONSE_LENGTH];
-
-        int rc;
-
-        rc = usb_massstor_data_in(GET_BULK_IN(dev), GET_BULK_OUT(dev),
-            0xDEADBEEF, 0, (uint8_t *) &inquiry, sizeof(inquiry),
-            response, INQUIRY_RESPONSE_LENGTH, &response_len);
-
-        if (rc != EOK) {
-                usb_log_error("Failed to probe device %s using %s: %s.\n",
-                   dev->ddf_dev->name, "SCSI:INQUIRY", str_error(rc));
-                return;
-        }
-
-        if (response_len < 8) {
-                usb_log_error("The SCSI response is too short.\n");
-                return;
-        }
-
-        /*
-         * This is an ugly part of the code. We will parse the returned
-         * data by hand and try to get as many useful data as possible.
-         */
-        int device_type = BITS_GET(uint8_t, response[0], 5, 0);
-        int removable = BITS_GET(uint8_t, response[1], 1, 7);
-
-        usb_log_info("SCSI information for device `%s':\n", dev->ddf_dev->name);
-        usb_log_info("  - peripheral device type: %d\n", device_type);
-        usb_log_info("  - removable: %s\n", removable ? "yes" : "no");
-
-        if (response_len < 32) {
-                return;
-        }
-
-        char dev_vendor[9];
-        str_ncpy(dev_vendor, 9, (const char *) &response[8], 8);
-        usb_log_info("  - vendor: '%s'\n", dev_vendor);
-
-        char dev_product[9];
-        str_ncpy(dev_product, 9, (const char *) &response[16], 8);
-        usb_log_info("  - product: '%s'\n", dev_vendor);
-}
-
 /** Callback when new device is attached and recognized as a mass storage.
  *
@@ -168 +107 @@
             (size_t) dev->pipes[BULK_OUT_EP].descriptor->max_packet_size);
 
-        try_inquiry(dev);
+        size_t lun_count = usb_masstor_get_lun_count(dev);
+
+        usb_massstor_inquiry_result_t inquiry;
+        rc = usb_massstor_inquiry(dev, BULK_IN_EP, BULK_OUT_EP, &inquiry);
+        if (rc != EOK) {
+                usb_log_warning("Failed to inquiry device `%s': %s.\n",
+                    dev->ddf_dev->name, str_error(rc));
+                return EOK;
+        }
+
+        usb_log_info("Mass storage `%s': " \
+            "`%s' by `%s' is %s (%s), %zu LUN(s).\n",
+            dev->ddf_dev->name,
+            inquiry.product_and_revision, inquiry.vendor_id,
+            usb_str_masstor_scsi_peripheral_device_type(inquiry.peripheral_device_type),
+            inquiry.removable ? "removable" : "non-removable",
+            lun_count);
 
         return EOK;

uspace/drv/usbmast/mast.c

@@ -40 +40 @@
 #include <str_error.h>
 #include <usb/debug.h>
+#include <usb/request.h>
 
 bool usb_mast_verbose = true;
@@ -63 +64 @@
  * @return Error code.
  */
-int usb_massstor_data_in(usb_pipe_t *bulk_in_pipe, usb_pipe_t *bulk_out_pipe,
+int usb_massstor_data_in(usb_device_t *dev,
+    size_t bulk_in_pipe_index, size_t bulk_out_pipe_index,
     uint32_t tag, uint8_t lun, void *cmd, size_t cmd_size,
     void *in_buffer, size_t in_buffer_size, size_t *received_size)
@@ -69 +71 @@
         int rc;
         size_t act_size;
+        usb_pipe_t *bulk_in_pipe = dev->pipes[bulk_in_pipe_index].pipe;
+        usb_pipe_t *bulk_out_pipe = dev->pipes[bulk_out_pipe_index].pipe;
 
         /* Prepare CBW - command block wrapper */
@@ -135 +139 @@
 }
 
+/** Perform bulk-only mass storage reset.
+ *
+ * @param dev Device to be reseted.
+ * @return Error code.
+ */
+int usb_massstor_reset(usb_device_t *dev)
+{
+        return usb_control_request_set(&dev->ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+            0xFF, 0, dev->interface_no, NULL, 0);
+}
+
+/** Perform complete reset recovery of bulk-only mass storage.
+ *
+ * Notice that no error is reported because if this fails, the error
+ * would reappear on next transaction somehow.
+ *
+ * @param dev Device to be reseted.
+ * @param bulk_in_idx Index of bulk in pipe.
+ * @param bulk_out_idx Index of bulk out pipe.
+ */
+void usb_massstor_reset_recovery(usb_device_t *dev,
+    size_t bulk_in_idx, size_t bulk_out_idx)
+{
+        /* We would ignore errors here because if this fails
+         * we are doomed anyway and any following transaction would fail.
+         */
+        usb_massstor_reset(dev);
+        usb_pipe_clear_halt(&dev->ctrl_pipe, dev->pipes[bulk_in_idx].pipe);
+        usb_pipe_clear_halt(&dev->ctrl_pipe, dev->pipes[bulk_out_idx].pipe);
+}
+
+/** Get max LUN of a mass storage device.
+ *
+ * @see usb_masstor_get_lun_count
+ *
+ * @warning Error from this command does not necessarily indicate malfunction
+ * of the device. Device does not need to support this request.
+ * You shall rather use usb_masstor_get_lun_count.
+ *
+ * @param dev Mass storage device.
+ * @return Error code of maximum LUN (index, not count).
+ */
+int usb_massstor_get_max_lun(usb_device_t *dev)
+{
+        uint8_t max_lun;
+        size_t data_recv_len;
+        int rc = usb_control_request_get(&dev->ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+            0xFE, 0, dev->interface_no, &max_lun, 1, &data_recv_len);
+        if (rc != EOK) {
+                return rc;
+        }
+        if (data_recv_len != 1) {
+                return EEMPTY;
+        }
+        return (int) max_lun;
+}
+
+/** Get number of LUNs supported by mass storage device.
+ *
+ * @warning This function hides any error during the request
+ * (typically that shall not be a problem).
+ *
+ * @param dev Mass storage device.
+ * @return Number of LUNs.
+ */
+size_t usb_masstor_get_lun_count(usb_device_t *dev)
+{
+        int max_lun = usb_massstor_get_max_lun(dev);
+        if (max_lun < 0) {
+                max_lun = 1;
+        } else {
+                max_lun++;
+        }
+
+        return (size_t) max_lun;
+}
+
 /**
  * @}

uspace/drv/usbmast/mast.h

@@ -40 +40 @@
 #include <usb/usb.h>
 #include <usb/pipes.h>
+#include <usb/devdrv.h>
 
-int usb_massstor_data_in(usb_pipe_t *, usb_pipe_t *, uint32_t, uint8_t,
-    void *, size_t, void *, size_t, size_t *);
+/** Result of SCSI INQUIRY command.
+ * This is already parsed structure, not the original buffer returned by
+ * the device.
+ */
+typedef struct {
+        /** SCSI peripheral device type. */
+        int peripheral_device_type;
+        /** Whether the device is removable. */
+        bool removable;
+        /** Vendor ID string. */
+        char vendor_id[9];
+        /** Product ID and product revision string. */
+        char product_and_revision[12];
+} usb_massstor_inquiry_result_t;
+
+int usb_massstor_data_in(usb_device_t *dev, size_t, size_t,
+    uint32_t, uint8_t, void *, size_t, void *, size_t, size_t *);
+int usb_massstor_reset(usb_device_t *);
+void usb_massstor_reset_recovery(usb_device_t *, size_t, size_t);
+int usb_massstor_get_max_lun(usb_device_t *);
+size_t usb_masstor_get_lun_count(usb_device_t *);
+int usb_massstor_inquiry(usb_device_t *, size_t, size_t,
+    usb_massstor_inquiry_result_t *);
+const char *usb_str_masstor_scsi_peripheral_device_type(int);
 
 #endif

uspace/lib/usbdev/include/usb/request.h

@@ -142 +142 @@
 
 int usb_request_clear_endpoint_halt(usb_pipe_t *, uint16_t);
+int usb_pipe_clear_halt(usb_pipe_t *, usb_pipe_t *);
+int usb_request_get_endpoint_status(usb_pipe_t *, usb_pipe_t *, uint16_t *);
 
 #endif

uspace/lib/usbdev/src/request.c

@@ -885 +885 @@
 }
 
+/** Clear halt bit of an endpoint pipe (after pipe stall).
+ *
+ * @param ctrl_pipe Control pipe.
+ * @param target_pipe Which pipe is halted and shall be cleared.
+ * @return Error code.
+ */
+int usb_pipe_clear_halt(usb_pipe_t *ctrl_pipe, usb_pipe_t *target_pipe)
+{
+        if ((ctrl_pipe == NULL) || (target_pipe == NULL)) {
+                return EINVAL;
+        }
+        return usb_request_clear_endpoint_halt(ctrl_pipe,
+            target_pipe->endpoint_no);
+}
+
+/** Get endpoint status.
+ *
+ * @param[in] ctrl_pipe Control pipe.
+ * @param[in] pipe Of which pipe the status shall be received.
+ * @param[out] status Where to store pipe status (in native endianness).
+ * @return Error code.
+ */
+int usb_request_get_endpoint_status(usb_pipe_t *ctrl_pipe, usb_pipe_t *pipe,
+    uint16_t *status)
+{
+        uint16_t status_tmp;
+        uint16_t pipe_index = (uint16_t) pipe->endpoint_no;
+        int rc = usb_request_get_status(ctrl_pipe,
+            USB_REQUEST_RECIPIENT_ENDPOINT, uint16_host2usb(pipe_index),
+            &status_tmp);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        if (status != NULL) {
+                *status = uint16_usb2host(status_tmp);
+        }
+
+        return EOK;
+}
+
 /**
  * @}