Changes in / [31860b7:8cd1aa5e] in mainline

Location:

uspace

Files:

• drv/root/root.c (modified) (1 diff)
• drv/uhci/main.c (modified) (1 diff)
• drv/uhci/uhci.ma (modified) (1 diff)
• drv/vhc/connhost.c (modified) (4 diffs)
• drv/vhc/hc.c (modified) (1 diff)
• drv/vhc/hc.h (modified) (1 diff)
• drv/vhc/hcd.c (modified) (2 diffs)
• lib/usb/Makefile (modified) (1 diff)
• lib/usb/include/usb/hcdhubd.h (modified) (1 diff)
• lib/usb/src/hcdhubd.c (modified) (6 diffs)
• lib/usb/src/localdrv.c (added)

uspace/drv/root/root.c

@@ -72 +72 @@
 static int add_platform_child(device_t *parent)
 {
-        return EOK;
         printf(NAME ": adding new child for platform device.\n");
         

uspace/drv/uhci/main.c

@@ -77 +77 @@
         /*
          * We need to announce the presence of our root hub.
+         * Commented out until the problem which causes the whole task to
+         * block is solved.
          */
-        usb_hcd_add_root_hub(device);
+        //usb_hcd_add_root_hub(device);
 
         return EOK;

uspace/drv/uhci/uhci.ma

@@ -1 @@
-0 pci/ven=8086&dev=7020
+10 pci/ven=8086&dev=7020
 10 usb&hc=uhci
 10 usb&hc=uhci&hub

uspace/drv/vhc/connhost.c

@@ -41 +41 @@
 #include "hc.h"
 
+typedef struct {
+        usb_direction_t direction;
+        usb_hcd_transfer_callback_out_t out_callback;
+        usb_hcd_transfer_callback_in_t in_callback;
+        usb_hc_device_t *hc;
+        void *arg;
+} transfer_info_t;
+
+static void universal_callback(void *buffer, size_t size,
+    usb_transaction_outcome_t outcome, void *arg)
+{
+        transfer_info_t *transfer = (transfer_info_t *) arg;
+
+        switch (transfer->direction) {
+                case USB_DIRECTION_IN:
+                        transfer->in_callback(transfer->hc,
+                            size, outcome,
+                            transfer->arg);
+                        break;
+                case USB_DIRECTION_OUT:
+                        transfer->out_callback(transfer->hc,
+                            outcome,
+                            transfer->arg);
+                        break;
+                default:
+                        assert(false && "unreachable");
+                        break;
+        }
+
+        free(transfer);
+}
+
+static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
+    usb_direction_t direction, void *arg)
+{
+        transfer_info_t *transfer = malloc(sizeof(transfer_info_t));
+
+        transfer->direction = direction;
+        transfer->in_callback = NULL;
+        transfer->out_callback = NULL;
+        transfer->arg = arg;
+        transfer->hc = hc;
+
+        return transfer;
+}
+
 static int enqueue_transfer_out(usb_hc_device_t *hc,
     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
@@ -50 +96 @@
             usb_str_transfer_type(endpoint->transfer_type),
             size);
-        return ENOTSUP;
+
+        transfer_info_t *transfer
+            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
+        transfer->out_callback = callback;
+
+        usb_target_t target = {
+                .address = dev->address,
+                .endpoint = endpoint->endpoint
+        };
+
+        hc_add_transaction_to_device(false, target, buffer, size,
+            universal_callback, transfer);
+
+        return EOK;
 }
 
@@ -62 +121 @@
             usb_str_transfer_type(endpoint->transfer_type),
             size);
-        return ENOTSUP;
+
+        transfer_info_t *transfer
+            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
+        transfer->out_callback = callback;
+
+        usb_target_t target = {
+                .address = dev->address,
+                .endpoint = endpoint->endpoint
+        };
+
+        hc_add_transaction_to_device(true, target, buffer, size,
+            universal_callback, transfer);
+
+        return EOK;
 }
 
@@ -74 +146 @@
             usb_str_transfer_type(endpoint->transfer_type),
             size);
-        return ENOTSUP;
+
+        transfer_info_t *transfer
+            = create_transfer_info(hc, USB_DIRECTION_IN, arg);
+        transfer->in_callback = callback;
+
+        usb_target_t target = {
+                .address = dev->address,
+                .endpoint = endpoint->endpoint
+        };
+
+        hc_add_transaction_from_device(target, buffer, size,
+            universal_callback, transfer);
+
+        return EOK;
 }
 

uspace/drv/vhc/hc.c

@@ -131 +131 @@
                 
                 process_transaction_with_outcome(transaction, outcome);
-                
+
                 free(transaction);
         }

uspace/drv/vhc/hc.h

@@ -79 +79 @@
     hc_transaction_done_callback_t callback, void * arg);
 
-int hc_fillin_transaction_from_device(usb_target_t target,
-    void * buffer, size_t len);
 
 #endif

uspace/drv/vhc/hcd.c

@@ -69 +69 @@
 
         /*
-         * Announce that we have some root hub present.
+         * Initialize our hub and announce its presence.
          */
+        hub_init();
         usb_hcd_add_root_hub(dev);
 
@@ -83 +84 @@
 };
 
+/** Fibril wrapper for HC transaction manager.
+ *
+ * @param arg Not used.
+ * @return Nothing, return argument is unreachable.
+ */
+static int hc_manager_fibril(void *arg)
+{
+        hc_manager();
+        return EOK;
+}
+
 int main(int argc, char * argv[])
 {       
         printf("%s: virtual USB host controller driver.\n", NAME);
 
-        debug_level = 5;
+        debug_level = 10;
+
+        fid_t fid = fibril_create(hc_manager_fibril, NULL);
+        if (fid == 0) {
+                printf("%s: failed to start HC manager fibril\n", NAME);
+                return ENOMEM;
+        }
+        fibril_add_ready(fid);
+
+        /*
+         * Temporary workaround. Wait a little bit to be the last driver
+         * in devman output.
+         */
+        sleep(4);
 
         return usb_hcd_main(&vhc_driver);

uspace/lib/usb/Makefile

@@ -34 +34 @@
 SOURCES = \
         src/hcdhubd.c \
+        src/localdrv.c \
         src/usb.c \
         src/usbdrv.c

uspace/lib/usb/include/usb/hcdhubd.h

@@ -159 +159 @@
     void *, size_t, size_t *, usb_handle_t *);
 
+int usb_hc_async_control_write_setup(usb_hc_device_t *, usb_target_t,
+    void *, size_t, usb_handle_t *);
+int usb_hc_async_control_write_data(usb_hc_device_t *, usb_target_t,
+    void *, size_t, usb_handle_t *);
+int usb_hc_async_control_write_status(usb_hc_device_t *, usb_target_t,
+    usb_handle_t *);
+
+int usb_hc_async_control_read_setup(usb_hc_device_t *, usb_target_t,
+    void *, size_t, usb_handle_t *);
+int usb_hc_async_control_read_data(usb_hc_device_t *, usb_target_t,
+    void *, size_t, size_t *, usb_handle_t *);
+int usb_hc_async_control_read_status(usb_hc_device_t *, usb_target_t,
+    usb_handle_t *);
+
 int usb_hc_async_wait_for(usb_handle_t);
 

uspace/lib/usb/src/hcdhubd.c

@@ -34 +34 @@
  */
 #include <usb/hcdhubd.h>
+#include <usb/devreq.h>
 #include <usbhc_iface.h>
 #include <driver.h>
@@ -55 +56 @@
         .interfaces[USBHC_DEV_IFACE] = &usb_interface
 };
+
+static void set_hub_address(usb_hc_device_t *hc, usb_address_t address);
 
 /** Callback when new device is detected and must be handled by this driver.
@@ -98 +101 @@
                 return EOK;
         } else {
-                printf("%s: hub added, hurrah!\n", hc_driver->name);
+                usb_hc_device_t *hc = list_get_instance(hc_list.next, usb_hc_device_t, link);
+                set_hub_address(hc, 5);
+
                 /*
                  * We are some (probably deeply nested) hub.
@@ -104 +109 @@
                  * connected devices.
                  */
+
                 return ENOTSUP;
         }
+}
+
+/** Sample usage of usb_hc_async functions.
+ * This function sets hub address using standard SET_ADDRESS request.
+ *
+ * @warning This function shall be removed once you are familiar with
+ * the usb_hc_ API.
+ *
+ * @param hc Host controller the hub belongs to.
+ * @param address New hub address.
+ */
+static void set_hub_address(usb_hc_device_t *hc, usb_address_t address)
+{
+        printf("%s: setting hub address to %d\n", hc->generic->name, address);
+        usb_target_t target = {0, 0};
+        usb_handle_t handle;
+        int rc;
+
+        usb_device_request_setup_packet_t setup_packet = {
+                .request_type = 0,
+                .request = USB_DEVREQ_SET_ADDRESS,
+                .index = 0,
+                .length = 0,
+        };
+        setup_packet.value = address;
+
+        rc = usb_hc_async_control_write_setup(hc, target,
+            &setup_packet, sizeof(setup_packet), &handle);
+        if (rc != EOK) {
+                return;
+        }
+
+        rc = usb_hc_async_wait_for(handle);
+        if (rc != EOK) {
+                return;
+        }
+
+        rc = usb_hc_async_control_write_status(hc, target, &handle);
+        if (rc != EOK) {
+                return;
+        }
+
+        rc = usb_hc_async_wait_for(handle);
+        if (rc != EOK) {
+                return;
+        }
+
+        printf("%s: hub address changed\n", hc->generic->name);
 }
 
@@ -212 +266 @@
 
         /*
-         * For testing/debugging purposes only.
-         * Try to send some data to default USB address.
-         */
-        usb_target_t target = {0, 0};
-        usb_handle_t handle = 0;
-        char *data = (char *) "Hello, World!";
-
-
-        (void)usb_hc_async_interrupt_out(dev, target, data, str_length(data), &handle);
-        (void)usb_hc_async_wait_for(handle);
-
-        /*
          * Announce presence of child device.
          */
@@ -272 +314 @@
 }
 
-/** Issue interrupt OUT transfer to HC driven by current task.
- *
- * @param hc Host controller to handle the transfer.
- * @param target Target device address.
- * @param buffer Data buffer.
- * @param size Buffer size.
- * @param handle Transfer handle.
- * @return Error code.
- */
-int usb_hc_async_interrupt_out(usb_hc_device_t *hc, usb_target_t target,
-    void *buffer, size_t size,
-    usb_handle_t *handle)
-{
-        if ((hc->transfer_ops == NULL)
-            || (hc->transfer_ops->transfer_out == NULL)) {
-                return ENOTSUP;
-        }
-
-        /*
-         * For debugging purposes only.
-         * We need to find appropriate device in list of managed device
-         * and pass it to the transfer callback function.
-         */
-        usb_hcd_attached_device_info_t dev = {
-                .address = target.address,
-                .endpoint_count = 0,
-                .endpoints = NULL,
-        };
-        usb_hc_endpoint_info_t endpoint = {
-                .endpoint = target.endpoint,
-                .transfer_type = USB_TRANSFER_INTERRUPT,
-                .direction = USB_DIRECTION_OUT,
-                .data_toggle = 0
-        };
-
-        hc->transfer_ops->transfer_out(hc, &dev, &endpoint, buffer, size, NULL, NULL);
-
-        *handle = (usb_handle_t)NULL;
-
-        return EOK;
-}
-
-
-/** Issue interrupt IN transfer to HC driven by current task.
- *
- * @warning The @p buffer and @p actual_size parameters shall not be
- * touched until this transfer is waited for by usb_hc_async_wait_for().
- *
- * @param hc Host controller to handle the transfer.
- * @param target Target device address.
- * @param buffer Data buffer.
- * @param size Buffer size.
- * @param actual_size Size of actually transferred data.
- * @param handle Transfer handle.
- * @return Error code.
- */
-int usb_hc_async_interrupt_in(usb_hc_device_t *hc, usb_target_t target,
-    void *buffer, size_t size, size_t *actual_size,
-    usb_handle_t *handle)
-{
-        /*
-         * TODO: verify that given endpoint is of interrupt type and
-         * call hc->transfer_ops->transfer_in()
-         */
-        return ENOTSUP;
-}
-
-/** Wait for transfer to complete.
- *
- * @param handle Transfer handle.
- * @return Error code.
- */
-int usb_hc_async_wait_for(usb_handle_t handle)
-{
-        return ENOTSUP;
-}
-
 /**
  * @}