Changeset 243cb86 in mainline for uspace/lib/usb/src

Timestamp:

2010-12-12T10:50:19Z (15 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

8365533

Parents:

101ef25c (diff), ebb98c5 (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 from development + several changes to hid driver.

Changes to hid driver:

• copied some code to usbkbd_get_descriptors() function
• base structure for hid descriptor and report parser (files uspace/lib/usb/include/usb/classes/hidparser.h

and uspace/lib/usb/src/hidparser.c)

Location:

uspace/lib/usb/src

Files:

• addrkeep.c (added)
• debug.c (added)
• drvpsync.c (added)
• hcdhubd.c (modified) (7 diffs)
• hcdhubd_private.h (modified) (1 diff)
• hcdrv.c (modified) (3 diffs)
• hidparser.c (added)
• localdrv.c (modified) (1 diff)
• remotedrv.c (modified) (1 diff)
• usbdrv.c (modified) (3 diffs)
• usbdrvreq.c (added)

uspace/lib/usb/src/hcdhubd.c

@@ -51 +51 @@
  */
 static int add_device(device_t *dev) {
-        bool is_hc = str_cmp(dev->name, USB_HUB_DEVICE_NAME) != 0;
-        printf("%s: add_device(name=\"%s\")\n", hc_driver->name, dev->name);
-
-        if (is_hc) {
-                /*
-                 * We are the HC itself.
-                 */
-                return usb_add_hc_device(dev);
-        } else {
-                /*
-                 * We are some (maybe deeply nested) hub.
-                 * Thus, assign our own operations and explore already
-                 * connected devices.
-                 */
-                return usb_add_hub_device(dev);
-        }
+        return ENOTSUP;
 }
 
@@ -105 +90 @@
  * @return Error code.
  */
-int usb_hcd_add_root_hub(usb_hc_device_t *dev)
+int usb_hcd_add_root_hub(device_t *dev)
 {
         char *id;
-        int rc = asprintf(&id, "usb&hc=%s&hub", hc_driver->name);
+        int rc = asprintf(&id, "usb&hub");
         if (rc <= 0) {
                 return rc;
         }
 
-        rc = usb_hc_add_child_device(dev->generic, USB_HUB_DEVICE_NAME, id, true);
+        rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true);
         if (rc != EOK) {
                 free(id);
@@ -129 +114 @@
 
 /** Adds a child device fibril worker. */
-static int fibril_add_child_device(void *arg)
-{
+static int fibril_add_child_device(void *arg) {
         struct child_device_info *child_info
-            = (struct child_device_info *) arg;
+                        = (struct child_device_info *) arg;
         int rc;
 
@@ -156 +140 @@
 
         printf("%s: adding child device `%s' with match \"%s\"\n",
-            hc_driver->name, child->name, match_id->id);
+                        hc_driver->name, child->name, match_id->id);
         rc = child_device_register(child, child_info->parent);
         printf("%s: child device `%s' registration: %s\n",
-            hc_driver->name, child->name, str_error(rc));
+                        hc_driver->name, child->name, str_error(rc));
 
         if (rc != EOK) {
@@ -197 +181 @@
  */
 int usb_hc_add_child_device(device_t *parent, const char *name,
-    const char *match_id, bool create_fibril)
-{
+                const char *match_id, bool create_fibril) {
         printf("%s: about to add child device `%s' (%s)\n", hc_driver->name,
-            name, match_id);
+                        name, match_id);
 
         /*
@@ -209 +192 @@
 
         struct child_device_info *child_info
-            = malloc(sizeof(struct child_device_info));
+                        = malloc(sizeof (struct child_device_info));
 
         child_info->parent = parent;
@@ -233 +216 @@
  * @return USB device address or error code.
  */
-usb_address_t usb_get_address_by_handle(devman_handle_t handle)
-{
+usb_address_t usb_get_address_by_handle(devman_handle_t handle) {
         /* TODO: search list of attached devices. */
         return ENOENT;
 }
 
+usb_address_t usb_use_free_address(usb_hc_device_t * this_hcd) {
+        //is there free address?
+        link_t * addresses = &this_hcd->addresses;
+        if (list_empty(addresses)) return -1;
+        link_t * link_addr = addresses;
+        bool found = false;
+        usb_address_list_t * range = NULL;
+        while (!found) {
+                link_addr = link_addr->next;
+                if (link_addr == addresses) return -2;
+                range = list_get_instance(link_addr,
+                                usb_address_list_t, link);
+                if (range->upper_bound - range->lower_bound > 0) {
+                        found = true;
+                }
+        }
+        //now we have interval
+        int result = range->lower_bound;
+        ++(range->lower_bound);
+        if (range->upper_bound - range->lower_bound == 0) {
+                list_remove(&range->link);
+                free(range);
+        }
+        return result;
+}
+
+void usb_free_used_address(usb_hc_device_t * this_hcd, usb_address_t addr) {
+        //check range
+        if (addr < usb_lowest_address || addr > usb_highest_address)
+                return;
+        link_t * addresses = &this_hcd->addresses;
+        link_t * link_addr = addresses;
+        //find 'good' interval
+        usb_address_list_t * found_range = NULL;
+        bool found = false;
+        while (!found) {
+                link_addr = link_addr->next;
+                if (link_addr == addresses) {
+                        found = true;
+                } else {
+                        usb_address_list_t * range = list_get_instance(link_addr,
+                                        usb_address_list_t, link);
+                        if (    (range->lower_bound - 1 == addr) ||
+                                        (range->upper_bound == addr)) {
+                                found = true;
+                                found_range = range;
+                        }
+                        if (range->lower_bound - 1 > addr) {
+                                found = true;
+                        }
+
+                }
+        }
+        if (found_range == NULL) {
+                //no suitable range found
+                usb_address_list_t * result_range =
+                                (usb_address_list_t*) malloc(sizeof (usb_address_list_t));
+                result_range->lower_bound = addr;
+                result_range->upper_bound = addr + 1;
+                list_insert_before(&result_range->link, link_addr);
+        } else {
+                //we have good range
+                if (found_range->lower_bound - 1 == addr) {
+                        --found_range->lower_bound;
+                } else {
+                        //only one possible case
+                        ++found_range->upper_bound;
+                        if (found_range->link.next != addresses) {
+                                usb_address_list_t * next_range =
+                                                list_get_instance( &found_range->link.next,
+                                                usb_address_list_t, link);
+                                //check neighbour range
+                                if (next_range->lower_bound == addr + 1) {
+                                        //join ranges
+                                        found_range->upper_bound = next_range->upper_bound;
+                                        list_remove(&next_range->link);
+                                        free(next_range);
+                                }
+                        }
+                }
+        }
+
+}
+
 /**
  * @}

uspace/lib/usb/src/hcdhubd_private.h

@@ -46 +46 @@
 usb_address_t usb_get_address_by_handle(devman_handle_t);
 int usb_add_hc_device(device_t *);
-int usb_add_hub_device(device_t *);
+
+/** lowest allowed usb address */
+extern int usb_lowest_address;
+
+/** highest allowed usb address */
+extern int usb_highest_address;
+
+/**
+ * @brief initialize address list of given hcd
+ *
+ * This function should be used only for hcd initialization.
+ * It creates interval list of free addresses, thus it is initialized as
+ * list with one interval with whole address space. Using an address shrinks
+ * the interval, freeing an address extends an interval or creates a
+ * new one. 
+ *
+ * @param hcd
+ * @return
+ */
+void  usb_create_address_list(usb_hc_device_t * hcd);
+
+
+
+
+
 
 #endif

uspace/lib/usb/src/hcdrv.c

@@ -47 +47 @@
 LIST_INITIALIZE(hc_list);
 
+/* Fake driver to have the name item initialized. */
+static usb_hc_driver_t hc_driver_fake = {
+        .name = "HCD",
+};
+
 /** Our HC driver. */
-usb_hc_driver_t *hc_driver = NULL;
+usb_hc_driver_t *hc_driver = &hc_driver_fake;
+
+int usb_lowest_address = 1;
+
+int usb_highest_address = 255;
 
 static device_ops_t usb_device_ops = {
         .interfaces[USBHC_DEV_IFACE] = &usbhc_interface
 };
+
+
+void usb_create_address_list(usb_hc_device_t * hcd){
+        list_initialize(&hcd->addresses);
+        usb_address_list_t * range =
+                        (usb_address_list_t*)malloc(sizeof(usb_address_list_t));
+        range->lower_bound = usb_lowest_address;
+        range->upper_bound = usb_highest_address + 1;
+        list_append(&range->link, &hcd->addresses);
+}
 
 static usb_hc_device_t *usb_hc_device_create(device_t *dev) {
@@ -59 +78 @@
         list_initialize(&hc_dev->link);
         list_initialize(&hc_dev->hubs);
+        usb_create_address_list(hc_dev);
         list_initialize(&hc_dev->attached_devices);
         hc_dev->transfer_ops = NULL;
@@ -71 +91 @@
 int usb_add_hc_device(device_t *dev)
 {
+        return ENOTSUP;
         usb_hc_device_t *hc_dev = usb_hc_device_create(dev);
 

uspace/lib/usb/src/localdrv.c

@@ -39 +39 @@
 #include <errno.h>
 
+/** Find host controller when handled by current task.
+ *
+ * @param dev Device asking for connection.
+ * @return Device structure corresponding to parent host controller.
+ * @retval NULL Corresponding host controller not found.
+ */
+device_t *usb_hc_connect(device_t *dev)
+{
+        /*
+         * FIXME: this will not work when some hub on the path is
+         * not driven by the same task.
+         */
+        device_t *parent = dev;
+        while (parent->parent != NULL) {
+                parent = parent->parent;
+        }
+        
+        if (dev == parent) {
+                printf("FIXME in %s:%d encountered!\n", __FILE__, __LINE__);
+                parent = NULL;
+        }
+
+        return parent;
+}
+
 /** Information about pending transaction on HC. */
 typedef struct {

uspace/lib/usb/src/remotedrv.c

@@ -300 +300 @@
  */
 static void remote_in_callback(usb_hc_device_t *hc,
-    usb_transaction_outcome_t outcome, size_t actual_size, void *arg)
+    size_t actual_size, usb_transaction_outcome_t outcome, void *arg)
 {
         transfer_info_t *transfer = (transfer_info_t *) arg;

uspace/lib/usb/src/usbdrv.c

@@ -55 +55 @@
 /** Connect to host controller the device is physically attached to.
  *
- * @param handle Device handle.
+ * @param dev Device asking for connection.
  * @param flags Connection flags (blocking connection).
  * @return Phone to corresponding HC or error code.
@@ -71 +71 @@
         devman_handle_t handle;
 
-        rc = devman_device_get_handle("/vhc", &handle, 0);
+        rc = devman_device_get_handle("/virt/usbhc", &handle, 0);
         if (rc != EOK) {
                 return rc;
@@ -98 +98 @@
 
         return (usb_address_t) address;
+}
+
+/** Tell HC to reserve default address.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Error code.
+ */
+int usb_drv_reserve_default_address(int phone)
+{
+        return async_req_0_0(phone, IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
+}
+
+/** Tell HC to release default address.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Error code.
+ */
+int usb_drv_release_default_address(int phone)
+{
+        return async_req_0_0(phone, IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
+}
+
+/** Ask HC for free address assignment.
+ *
+ * @param phone Open phone to host controller driver.
+ * @return Assigned USB address or negative error code.
+ */
+usb_address_t usb_drv_request_address(int phone)
+{
+        ipcarg_t address;
+        int rc = async_req_0_1(phone, IPC_M_USBHC_REQUEST_ADDRESS, &address);
+        if (rc != EOK) {
+                return rc;
+        } else {
+                return (usb_address_t) address;
+        }
+}
+
+/** Inform HC about binding address with devman handle.
+ *
+ * @param phone Open phone to host controller driver.
+ * @param address Address to be binded.
+ * @param handle Devman handle of the device.
+ * @return Error code.
+ */
+int usb_drv_bind_address(int phone, usb_address_t address,
+    devman_handle_t handle)
+{
+        int rc = async_req_2_0(phone, IPC_M_USBHC_BIND_ADDRESS,
+            address, handle);
+
+        return rc;
+}
+
+/** Inform HC about address release.
+ *
+ * @param phone Open phone to host controller driver.
+ * @param address Address to be released.
+ * @return Error code.
+ */
+int usb_drv_release_address(int phone, usb_address_t address)
+{
+        return async_req_1_0(phone, IPC_M_USBHC_RELEASE_ADDRESS, address);
 }