Changeset b00849e in mainline for uspace/drv

Timestamp:

2011-02-02T00:57:32Z (15 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

1537ba6, 3597dab

Parents:

2cea1045 (diff), 2f4438f5 (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:

Merged pipe API

The pipe API shall eventually replace USB device drivers API explicitly
using phones. This API uses extra abstraction level by introducing
device connection (the wire) and endpoint pipe.

The USB HID driver uses the new API, hub driver does not.

Location:

uspace/drv

Files:

• usbhid/descdump.h (modified) (1 diff)
• usbhid/descparser.h (modified) (1 diff)
• usbhid/hid.h (added)
• usbhid/main.c (modified) (9 diffs)
• vhc/connhost.c (modified) (6 diffs)

uspace/drv/usbhid/descdump.h

@@ -37 +37 @@
 #define USBHID_DESCDUMP_H_
 
-#include <usb/classes/hid.h>
+#include "hid.h"
 
 void dump_standard_configuration_descriptor(

uspace/drv/usbhid/descparser.h

@@ -37 +37 @@
 #define USBHID_DESCPARSER_H_
 
-#include <usb/classes/hid.h>
+#include "hid.h"
 
 int usbkbd_parse_descriptors(const uint8_t *data, size_t size,

uspace/drv/usbhid/main.c

@@ -43 +43 @@
 #include <io/console.h>
 #include <errno.h>
+#include <str_error.h>
 #include <fibril.h>
 #include <usb/classes/hid.h>
 #include <usb/classes/hidparser.h>
-#include <usb/devreq.h>
+#include <usb/request.h>
 #include <usb/descriptor.h>
 #include <io/console.h>
+#include "hid.h"
 #include "descparser.h"
 #include "descdump.h"
@@ -278 +280 @@
                 
                 // get the descriptor from the device
-                int rc = usb_drv_req_get_descriptor(kbd_dev->device->parent_phone,
-                    kbd_dev->address, USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT, 
-                    0, i, kbd_dev->conf->interfaces[i].report_desc, length, 
+                int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
+                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
+                    i, 0,
+                    kbd_dev->conf->interfaces[i].report_desc, length,
                     &actual_size);
 
@@ -301 +304 @@
         usb_standard_configuration_descriptor_t config_desc;
         
-        int rc = usb_drv_req_get_bare_configuration_descriptor(
-            kbd_dev->device->parent_phone, kbd_dev->address, 0, &config_desc);
+        int rc;
+        rc = usb_request_get_bare_configuration_descriptor(&kbd_dev->ctrl_pipe,
+            0, &config_desc);
         
         if (rc != EOK) {
@@ -316 +320 @@
         size_t transferred = 0;
         // get full configuration descriptor
-        rc = usb_drv_req_get_full_configuration_descriptor(
-            kbd_dev->device->parent_phone, kbd_dev->address, 0, descriptors,
+        rc = usb_request_get_full_configuration_descriptor(&kbd_dev->ctrl_pipe,
+            0, descriptors,
             config_desc.total_length, &transferred);
         
@@ -364 +368 @@
 static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev)
 {
+        int rc;
+
         usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)calloc(1, 
             sizeof(usb_hid_dev_kbd_t));
@@ -374 +380 @@
         kbd_dev->device = dev;
 
-        // get phone to my HC and save it as my parent's phone
-        // TODO: maybe not a good idea if DDF will use parent_phone
-        int rc = kbd_dev->device->parent_phone = usb_drv_hc_connect_auto(dev, 0);
-        if (rc < 0) {
-                printf("Problem setting phone to HC.\n");
-                free(kbd_dev);
-                return NULL;
-        }
-
-        rc = kbd_dev->address = usb_drv_get_my_address(dev->parent_phone, dev);
-        if (rc < 0) {
-                printf("Problem getting address of the device.\n");
-                free(kbd_dev);
-                return NULL;
-        }
-
-        // doesn't matter now that we have no address
-//      if (kbd_dev->address < 0) {
-//              fprintf(stderr, NAME ": No device address!\n");
-//              free(kbd_dev);
-//              return NULL;
-//      }
-
-        // default endpoint
-        kbd_dev->poll_endpoint = GUESSED_POLL_ENDPOINT;
-        
+        /*
+         * Initialize the backing connection to the host controller.
+         */
+        rc = usb_device_connection_initialize_from_device(&kbd_dev->wire, dev);
+        if (rc != EOK) {
+                printf("Problem initializing connection to device: %s.\n",
+                    str_error(rc));
+                goto error_leave;
+        }
+
+        /*
+         * Initialize device pipes.
+         */
+        rc = usb_endpoint_pipe_initialize_default_control(&kbd_dev->ctrl_pipe,
+            &kbd_dev->wire);
+        if (rc != EOK) {
+                printf("Failed to initialize default control pipe: %s.\n",
+                    str_error(rc));
+                goto error_leave;
+        }
+
+        rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,
+            GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);
+        if (rc != EOK) {
+                printf("Failed to initialize interrupt in pipe: %s.\n",
+                    str_error(rc));
+                goto error_leave;
+        }
+
         /*
          * will need all descriptors:
-         * 1) choose one configuration from configuration descriptors 
+         * 1) choose one configuration from configuration descriptors
          *    (set it to the device)
          * 2) set endpoints from endpoint descriptors
@@ -408 +417 @@
 
         // TODO: get descriptors, parse descriptors and save endpoints
+        usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
         usbkbd_process_descriptors(kbd_dev);
+        usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
 
         return kbd_dev;
+
+error_leave:
+        free(kbd_dev);
+        return NULL;
 }
 
@@ -435 +450 @@
 static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev)
 {
-        int rc;
-        usb_handle_t handle;
+        int rc, sess_rc;
         uint8_t buffer[BUFFER_SIZE];
         size_t actual_size;
-        //usb_endpoint_t poll_endpoint = 1;
-
-//      usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone,
-//          dev);
-//      if (my_address < 0) {
-//              return;
-//      }
-
-        usb_target_t poll_target = {
-                .address = kbd_dev->address,
-                .endpoint = kbd_dev->poll_endpoint
-        };
 
         printf("Polling keyboard...\n");
@@ -456 +458 @@
         while (true) {
                 async_usleep(1000 * 1000 * 2);
-                rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone,
-                    poll_target, buffer, BUFFER_SIZE, &actual_size, &handle);
+
+                sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
+                if (sess_rc != EOK) {
+                        printf("Failed to start a session: %s.\n",
+                            str_error(sess_rc));
+                        continue;
+                }
+
+                rc = usb_endpoint_pipe_read(&kbd_dev->poll_pipe, buffer,
+                    BUFFER_SIZE, &actual_size);
+                sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->poll_pipe);
 
                 if (rc != EOK) {
-                        printf("Error in usb_drv_async_interrupt_in(): %d\n", rc);
+                        printf("Error polling the keyboard: %s.\n",
+                            str_error(rc));
                         continue;
                 }
 
-                rc = usb_drv_async_wait_for(handle);
-                if (rc != EOK) {
-                        printf("Error in usb_drv_async_wait_for(): %d\n", rc);
+                if (sess_rc != EOK) {
+                        printf("Error closing session: %s.\n",
+                            str_error(sess_rc));
                         continue;
                 }

uspace/drv/vhc/connhost.c

@@ -42 +42 @@
 #include "hc.h"
 
+
 typedef struct {
         usb_direction_t direction;
@@ -47 +48 @@
         usbhc_iface_transfer_in_callback_t in_callback;
         device_t *dev;
+        size_t reported_size;
         void *arg;
 } transfer_info_t;
 
+typedef struct {
+        usb_direction_t direction;
+        usb_target_t target;
+        usbhc_iface_transfer_out_callback_t out_callback;
+        usbhc_iface_transfer_in_callback_t in_callback;
+        device_t *dev;
+        void *arg;
+        void *data_buffer;
+        size_t data_buffer_size;
+} control_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;
+
+        if (transfer->reported_size != (size_t) -1) {
+                size = transfer->reported_size;
+        }
 
         switch (transfer->direction) {
@@ -84 +101 @@
         transfer->arg = arg;
         transfer->dev = dev;
+        transfer->reported_size = (size_t) -1;
+
+        return transfer;
+}
+
+static void control_abort_prematurely(control_transfer_info_t *transfer,
+    size_t size, usb_transaction_outcome_t outcome)
+{
+        switch (transfer->direction) {
+                case USB_DIRECTION_IN:
+                        transfer->in_callback(transfer->dev,
+                            outcome, size,
+                            transfer->arg);
+                        break;
+                case USB_DIRECTION_OUT:
+                        transfer->out_callback(transfer->dev,
+                            outcome,
+                            transfer->arg);
+                        break;
+                default:
+                        assert(false && "unreachable");
+                        break;
+        }
+}
+
+static void control_callback_two(void *buffer, size_t size,
+    usb_transaction_outcome_t outcome, void *arg)
+{
+        control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
+
+        if (outcome != USB_OUTCOME_OK) {
+                control_abort_prematurely(ctrl_transfer, outcome, size);
+                free(ctrl_transfer);
+                return;
+        }
+
+        transfer_info_t *transfer  = create_transfer_info(ctrl_transfer->dev,
+            ctrl_transfer->direction, ctrl_transfer->arg);
+        transfer->out_callback = ctrl_transfer->out_callback;
+        transfer->in_callback = ctrl_transfer->in_callback;
+        transfer->reported_size = size;
+
+        switch (ctrl_transfer->direction) {
+                case USB_DIRECTION_IN:
+                        hc_add_transaction_to_device(false, ctrl_transfer->target,
+                            USB_TRANSFER_CONTROL,
+                            NULL, 0,
+                            universal_callback, transfer);
+                        break;
+                case USB_DIRECTION_OUT:
+                        hc_add_transaction_from_device(ctrl_transfer->target,
+                            USB_TRANSFER_CONTROL,
+                            NULL, 0,
+                            universal_callback, transfer);
+                        break;
+                default:
+                        assert(false && "unreachable");
+                        break;
+        }
+
+        free(ctrl_transfer);
+}
+
+static void control_callback_one(void *buffer, size_t size,
+    usb_transaction_outcome_t outcome, void *arg)
+{
+        control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
+
+        if (outcome != USB_OUTCOME_OK) {
+                control_abort_prematurely(transfer, outcome, size);
+                free(transfer);
+                return;
+        }
+
+        switch (transfer->direction) {
+                case USB_DIRECTION_IN:
+                        hc_add_transaction_from_device(transfer->target,
+                            USB_TRANSFER_CONTROL,
+                            transfer->data_buffer, transfer->data_buffer_size,
+                            control_callback_two, transfer);
+                        break;
+                case USB_DIRECTION_OUT:
+                        hc_add_transaction_to_device(false, transfer->target,
+                            USB_TRANSFER_CONTROL,
+                            transfer->data_buffer, transfer->data_buffer_size,
+                            control_callback_two, transfer);
+                        break;
+                default:
+                        assert(false && "unreachable");
+                        break;
+        }
+}
+
+static control_transfer_info_t *create_control_transfer_info(device_t *dev,
+    usb_direction_t direction, usb_target_t target,
+    void *data_buffer, size_t data_buffer_size,
+    void *arg)
+{
+        control_transfer_info_t *transfer
+            = malloc(sizeof(control_transfer_info_t));
+
+        transfer->direction = direction;
+        transfer->target = target;
+        transfer->in_callback = NULL;
+        transfer->out_callback = NULL;
+        transfer->arg = arg;
+        transfer->dev = dev;
+        transfer->data_buffer = data_buffer;
+        transfer->data_buffer_size = data_buffer_size;
 
         return transfer;
@@ -193 +319 @@
 }
 
+static int control_write(device_t *dev, usb_target_t target,
+    void *setup_packet, size_t setup_packet_size,
+    void *data, size_t data_size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        control_transfer_info_t *transfer
+            = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,
+            data, data_size, arg);
+        transfer->out_callback = callback;
+
+        hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
+            setup_packet, setup_packet_size,
+            control_callback_one, transfer);
+
+        return EOK;
+}
+
 static int control_read_setup(device_t *dev, usb_target_t target,
     void *data, size_t size,
@@ -217 +360 @@
             NULL, 0,
             callback, arg);
+}
+
+static int control_read(device_t *dev, usb_target_t target,
+    void *setup_packet, size_t setup_packet_size,
+    void *data, size_t data_size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        control_transfer_info_t *transfer
+            = create_control_transfer_info(dev, USB_DIRECTION_IN, target,
+            data, data_size, arg);
+        transfer->in_callback = callback;
+
+        hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
+            setup_packet, setup_packet_size,
+            control_callback_one, transfer);
+
+        return EOK;
 }
 
@@ -290 +450 @@
         .control_write_status = control_write_status,
 
+        .control_write = control_write,
+
         .control_read_setup = control_read_setup,
         .control_read_data = control_read_data,
-        .control_read_status = control_read_status
+        .control_read_status = control_read_status,
+
+        .control_read = control_read
 };