Changeset 237df2f in mainline

Timestamp:

2013-01-04T16:49:53Z (12 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

0e97b4b5

Parents:

daf199f

Message:

libusbhost: Add host side device initialization.

Add new roothub initialization functions (the old one is going away).
change usb device names created by host controller to be less awkward.

Location:

uspace/lib

Files:

• usb/include/usb/request.h (modified) (1 diff)
• usbhost/include/usb/host/ddf_helpers.h (modified) (1 diff)
• usbhost/include/usb/host/hcd.h (modified) (2 diffs)
• usbhost/src/ddf_helpers.c (modified) (4 diffs)
• usbhost/src/hcd.c (modified) (1 diff)

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

@@ -79 +79 @@
         uint8_t request_type;
 #define SETUP_REQUEST_TYPE_DEVICE_TO_HOST (1 << 7)
+#define SETUP_REQUEST_TYPE_HOST_TO_DEVICE (0 << 7)
 #define SETUP_REQUEST_TYPE_GET_TYPE(rt) ((rt >> 5) & 0x3)
 #define SETUP_REQUEST_TYPE_GET_RECIPIENT(rec) (rec & 0x1f)

uspace/lib/usbhost/include/usb/host/ddf_helpers.h

@@ -45 +45 @@
 int hcd_ddf_setup_device(ddf_dev_t *device, ddf_fun_t **hc_fun,
     usb_speed_t max_speed, size_t bw, bw_count_func_t bw_count);
+int hcd_ddf_setup_root_hub(ddf_dev_t *dev, usb_speed_t speed);
 int hcd_ddf_setup_hub(ddf_dev_t *dev, usb_address_t *address);
+int hcd_ddf_new_device(ddf_dev_t *device);
 
 hcd_t *dev_to_hcd(ddf_dev_t *dev);

uspace/lib/usbhost/include/usb/host/hcd.h

@@ -88 +88 @@
 int hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed);
 
-static inline int hcd_release_default_address(hcd_t *hcd, usb_address_t address)
+static inline int hcd_release_default_address(hcd_t *hcd)
 {
         return hcd_release_address(hcd, USB_ADDRESS_DEFAULT);
@@ -103 +103 @@
     usbhc_iface_transfer_out_callback_t out, void *arg, const char* name);
 
+ssize_t hcd_send_batch_sync(hcd_t *hcd, usb_target_t target,
+    usb_direction_t dir, void *data, size_t size, uint64_t setup_data,
+    const char* name);
+
 #endif
 /**

uspace/lib/usbhost/src/ddf_helpers.c

@@ -35 +35 @@
 
 #include <usb_iface.h>
+#include <usb/classes/classes.h>
 #include <usb/debug.h>
+#include <usb/descriptor.h>
+#include <usb/request.h>
 #include <errno.h>
 #include <str_error.h>
 
 #include "ddf_helpers.h"
+
+#define CTRL_PIPE_MIN_PACKET_SIZE 8
 
 extern usbhc_iface_t hcd_iface;
@@ -119 +124 @@
 };
 
+#define GET_DEVICE_DESC(size) \
+{ \
+        .request_type = SETUP_REQUEST_TYPE_DEVICE_TO_HOST \
+            | (USB_REQUEST_TYPE_STANDARD << 5) \
+            | USB_REQUEST_RECIPIENT_DEVICE, \
+        .request = USB_DEVREQ_GET_DESCRIPTOR, \
+        .value = uint16_host2usb(USB_DESCTYPE_DEVICE << 8), \
+        .index = uint16_host2usb(0), \
+        .length = uint16_host2usb(size), \
+};
+
+#define SET_ADDRESS(address) \
+{ \
+        .request_type = SETUP_REQUEST_TYPE_HOST_TO_DEVICE \
+            | (USB_REQUEST_TYPE_STANDARD << 5) \
+            | USB_REQUEST_RECIPIENT_DEVICE, \
+        .request = USB_DEVREQ_SET_ADDRESS, \
+        .value = uint16_host2usb(address), \
+        .index = uint16_host2usb(0), \
+        .length = uint16_host2usb(0), \
+};
+
+static const usb_device_request_setup_packet_t set_address = {
+        .request_type = SETUP_REQUEST_TYPE_DEVICE_TO_HOST
+            | (USB_REQUEST_TYPE_STANDARD << 5)
+            | USB_REQUEST_RECIPIENT_DEVICE,
+        .request = USB_DEVREQ_GET_DESCRIPTOR,
+        .value = uint16_host2usb(USB_DESCTYPE_DEVICE << 8),
+        .index = uint16_host2usb(0),
+        .length = uint16_host2usb(CTRL_PIPE_MIN_PACKET_SIZE),
+};
+
 int hcd_ddf_add_usb_device(ddf_dev_t *parent,
     usb_address_t address, usb_speed_t speed, const char *name,
@@ -127 +164 @@
         devman_handle_t hc_handle = ddf_fun_get_handle(hc_dev->hc_fun);
 
-        char default_name[8]; /* usbxyzs */
+        char default_name[10] = { 0 }; /* usbxyz-ss */
         if (!name) {
                 snprintf(default_name, sizeof(default_name) - 1,
-                    "usb%u%c", address, usb_str_speed(speed)[0]);
+                    "usb%u-%cs", address, usb_str_speed(speed)[0]);
                 name = default_name;
         }
@@ -169 +206 @@
         list_append(&info->link, &hc_dev->devices);
         return EOK;
+}
+
+
+#define ADD_MATCHID_OR_RETURN(list, sc, str, ...) \
+do { \
+        match_id_t *mid = malloc(sizeof(match_id_t)); \
+        if (!mid) { \
+                clean_match_ids(list); \
+                return ENOMEM; \
+        } \
+        char *id = NULL; \
+        int ret = asprintf(&id, str, ##__VA_ARGS__); \
+        if (ret < 0) { \
+                clean_match_ids(list); \
+                free(mid); \
+                return ENOMEM; \
+        } \
+        mid->score = sc; \
+        mid->id = id; \
+        add_match_id(list, mid); \
+} while (0)
+                
+
+/* This is a copy of lib/usbdev/src/recognise.c */
+static int create_match_ids(match_id_list_t *l,
+    usb_standard_device_descriptor_t *d)
+{
+        assert(l);
+        assert(d);
+        
+        if (d->vendor_id != 0) {
+                /* First, with release number. */
+                ADD_MATCHID_OR_RETURN(l, 100,
+                    "usb&vendor=%#04x&product=%#04x&release=%x.%x",
+                    d->vendor_id, d->product_id, (d->device_version >> 8),
+                    (d->device_version & 0xff));
+        
+                /* Next, without release number. */     
+                ADD_MATCHID_OR_RETURN(l, 90, "usb&vendor=%#04x&product=%#04x",
+                    d->vendor_id, d->product_id);
+        }
+
+        /* Class match id */
+        ADD_MATCHID_OR_RETURN(l, 50, "usb&class=%s",
+            usb_str_class(d->device_class));
+
+        /* As a last resort, try fallback driver. */
+        ADD_MATCHID_OR_RETURN(l, 10, "usb&fallback");
+
+        return EOK;
+
+}
+
+int hcd_ddf_new_device(ddf_dev_t *device)
+{
+        assert(device);
+
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+        
+        usb_speed_t speed = USB_SPEED_MAX;
+
+        /* This checks whether the default address is reserved and gets speed */
+        int ret = usb_device_manager_get_info_by_address(&hcd->dev_manager,
+                USB_ADDRESS_DEFAULT, NULL, &speed);
+        if (ret != EOK) {
+                return ret;
+        }
+
+        static const usb_target_t default_target = {{
+                .address = USB_ADDRESS_DEFAULT,
+                .endpoint = 0,
+        }};
+
+        const usb_address_t address = hcd_request_address(hcd, speed);
+        if (address < 0)
+                return address;
+
+        const usb_target_t target = {{
+                .address = address,
+                .endpoint = 0,
+        }};
+
+        /* Add default pipe on default address */
+        ret = hcd_add_ep(hcd, 
+            default_target, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            CTRL_PIPE_MIN_PACKET_SIZE, CTRL_PIPE_MIN_PACKET_SIZE);
+
+        if (ret != EOK) {
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+
+        /* Get max packet size for default pipe */
+        usb_standard_device_descriptor_t desc = { 0 };
+        static const usb_device_request_setup_packet_t get_device_desc_8 =
+            GET_DEVICE_DESC(CTRL_PIPE_MIN_PACKET_SIZE);
+
+        // TODO CALLBACKS
+        ssize_t got = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_IN,
+            &desc, CTRL_PIPE_MIN_PACKET_SIZE, *(uint64_t *)&get_device_desc_8,
+            "read first 8 bytes of dev descriptor");
+
+        if (got != CTRL_PIPE_MIN_PACKET_SIZE) {
+                hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return got < 0 ? got : EOVERFLOW;
+        }
+
+        /* Register EP on the new address */
+        ret = hcd_add_ep(hcd, target, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            desc.max_packet_size, desc.max_packet_size);
+        if (ret != EOK) {
+                hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+
+        /* Set new address */
+        const usb_device_request_setup_packet_t set_address =
+            SET_ADDRESS(target.address);
+
+        // TODO CALLBACKS
+        got = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_OUT,
+            NULL, 0, *(uint64_t *)&set_address, "set address");
+
+        hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+
+        if (got != 0) {
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return got;
+        }
+        
+        /* Get std device descriptor */
+        static const usb_device_request_setup_packet_t get_device_desc =
+            GET_DEVICE_DESC(sizeof(desc));
+
+        // TODO CALLBACKS
+        got = hcd_send_batch_sync(hcd, target, USB_DIRECTION_IN,
+            &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
+            "read device descriptor");
+        if (ret != EOK) {
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return got < 0 ? got : EOVERFLOW;
+        }
+        
+        /* Create match ids from the device descriptor */
+        match_id_list_t mids;
+        init_match_ids(&mids);
+
+        ret = create_match_ids(&mids, &desc);
+        if (ret != EOK) {
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return ret;
+        }
+        
+                
+
+        /* Register device */   
+        ret = hcd_ddf_add_usb_device(device, address, speed, NULL, &mids);
+        clean_match_ids(&mids);
+        if (ret != EOK) {
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return ret;
+        }
+
+        return ret;
+}
+
+/** Announce root hub to the DDF
+ *
+ * @param[in] device Host controller ddf device
+ * @param[in] speed roothub communication speed
+ * @return Error code
+ */
+int hcd_ddf_setup_root_hub(ddf_dev_t *device, usb_speed_t speed)
+{
+        assert(device);
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+
+        hcd_reserve_default_address(hcd, speed);
+        int ret = hcd_ddf_new_device(device);
+        hcd_release_default_address(hcd);
+        return ret;
 }
 

uspace/lib/usbhost/src/hcd.c

@@ -253 +253 @@
 }
 
+typedef struct {
+        volatile unsigned done;
+        int ret;        
+        size_t size;
+} sync_data_t;
+
+static void transfer_in_cb(int ret, size_t size, void* data)
+{
+        sync_data_t *d = data;
+        assert(d);
+        d->ret = ret;
+        d->done = 1;
+        d->size = size;
+}
+
+static void transfer_out_cb(int ret, void* data)
+{
+        sync_data_t *d = data;
+        assert(data);
+        d->ret = ret;
+        d->done = 1;
+}
+
+/** this is really ugly version of sync usb communication */
+ssize_t hcd_send_batch_sync(
+    hcd_t *hcd, usb_target_t target, usb_direction_t dir,
+    void *data, size_t size, uint64_t setup_data, const char* name)
+{
+        assert(hcd);
+        sync_data_t sd = { .done = 0, .ret = EINPROGRESS, .size = size };
+
+        int ret = hcd_send_batch(hcd, target, dir, data, size, setup_data,
+            dir == USB_DIRECTION_IN ? transfer_in_cb : NULL,
+            dir == USB_DIRECTION_OUT ? transfer_out_cb : NULL, &sd, name);
+        if (ret != EOK)
+                return ret;
+        do {
+                async_usleep(1000);
+        } while (!sd.done);
+        if (sd.ret == EOK)
+                return sd.size;
+        return sd.ret;
+}
+
+
 /**
  * @}