Changeset 1537ba6 in mainline for uspace/drv

Timestamp:

2011-02-02T10:19:13Z (15 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

93f8da1

Parents:

0b31409 (diff), b00849e (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/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
 };