Changeset b00849e in mainline for uspace/drv/vhc/connhost.c

Timestamp:

2011-02-02T00:57:32Z (13 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.

File:

• uspace/drv/vhc/connhost.c (modified) (6 diffs)

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
 };