Changes in uspace/lib/drv/generic/remote_usbhc.c [6edd494:93f8da1] in mainline

File:

• uspace/lib/drv/generic/remote_usbhc.c (modified) (15 diffs)

uspace/lib/drv/generic/remote_usbhc.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2010-2011 Vojtech Horky
  * All rights reserved.
  *
@@ -52 +52 @@
 static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_control_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
@@ -81 +83 @@
         remote_usbhc_control_read_setup,
         remote_usbhc_control_read_data,
-        remote_usbhc_control_read_status
+        remote_usbhc_control_read_status,
+
+        remote_usbhc_control_write,
+        remote_usbhc_control_read
 };
 
@@ -95 +100 @@
         ipc_callid_t caller;
         void *buffer;
+        void *setup_packet;
         size_t size;
 } async_transaction_t;
 
+static void async_transaction_destroy(async_transaction_t *trans)
+{
+        if (trans == NULL) {
+                return;
+        }
+
+        if (trans->setup_packet != NULL) {
+                free(trans->setup_packet);
+        }
+        if (trans->buffer != NULL) {
+                free(trans->buffer);
+        }
+
+        free(trans);
+}
+
+static async_transaction_t *async_transaction_create(ipc_callid_t caller)
+{
+        async_transaction_t *trans = malloc(sizeof(async_transaction_t));
+        if (trans == NULL) {
+                return NULL;
+        }
+
+        trans->caller = caller;
+        trans->buffer = NULL;
+        trans->setup_packet = NULL;
+        trans->size = 0;
+
+        return trans;
+}
+
 void remote_usbhc_get_address(device_t *device, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
@@ -130 +167 @@
         if (trans->buffer == NULL) {
                 ipc_answer_0(callid, EINVAL);
-                free(trans);
+                async_transaction_destroy(trans);
                 return;
         }
@@ -138 +175 @@
         if (!async_data_read_receive(&cid, &accepted_size)) {
                 ipc_answer_0(callid, EINVAL);
+                async_transaction_destroy(trans);
                 return;
         }
@@ -148 +186 @@
         ipc_answer_1(callid, EOK, accepted_size);
 
-        free(trans->buffer);
-        free(trans);
+        async_transaction_destroy(trans);
 }
 
@@ -242 +279 @@
         async_transaction_t *trans = (async_transaction_t *)arg;
 
-        // FIXME - answer according to outcome
-        ipc_answer_0(trans->caller, EOK);
-
-        free(trans);
+        ipc_answer_0(trans->caller, outcome);
+
+        async_transaction_destroy(trans);
 }
 
@@ -253 +289 @@
         async_transaction_t *trans = (async_transaction_t *)arg;
 
-        // FIXME - answer according to outcome
-        ipc_answer_1(trans->caller, EOK, (sysarg_t)trans);
+        if (outcome != USB_OUTCOME_OK) {
+                ipc_answer_0(trans->caller, outcome);
+                async_transaction_destroy(trans);
+                return;
+        }
 
         trans->size = actual_size;
+        ipc_answer_1(trans->caller, USB_OUTCOME_OK, (sysarg_t)trans);
 }
 
@@ -294 +334 @@
         }
 
-        async_transaction_t *trans = malloc(sizeof(async_transaction_t));
-        trans->caller = callid;
-        trans->buffer = buffer;
-        trans->size = len;
-
-        int rc = transfer_func(device, target, buffer, len,
-            callback_out, trans);
-
-        if (rc != EOK) {
-                ipc_answer_0(callid, rc);
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
                 if (buffer != NULL) {
                         free(buffer);
                 }
-                free(trans);
+                ipc_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        trans->buffer = buffer;
+        trans->size = len;
+
+        int rc = transfer_func(device, target, buffer, len,
+            callback_out, trans);
+
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+                async_transaction_destroy(trans);
         }
 }
@@ -333 +377 @@
         };
 
-        async_transaction_t *trans = malloc(sizeof(async_transaction_t));
-        trans->caller = callid;
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                ipc_answer_0(callid, ENOMEM);
+                return;
+        }
         trans->buffer = malloc(len);
         trans->size = len;
@@ -343 +390 @@
         if (rc != EOK) {
                 ipc_answer_0(callid, rc);
-                free(trans->buffer);
-                free(trans);
+                async_transaction_destroy(trans);
         }
 }
@@ -388 +434 @@
         };
 
-        async_transaction_t *trans = malloc(sizeof(async_transaction_t));
-        trans->caller = callid;
-        trans->buffer = NULL;
-        trans->size = 0;
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                ipc_answer_0(callid, ENOMEM);
+                return;
+        }
 
         int rc;
@@ -410 +457 @@
         if (rc != EOK) {
                 ipc_answer_0(callid, rc);
-                free(trans);
-        }
-        return;
+                async_transaction_destroy(trans);
+        }
 }
 
@@ -496 +542 @@
 }
 
+void remote_usbhc_control_write(device_t *device, void *iface,
+ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        if (!usb_iface->control_write) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        usb_target_t target = {
+                .address = DEV_IPC_GET_ARG1(*call),
+                .endpoint = DEV_IPC_GET_ARG2(*call)
+        };
+
+        int rc;
+
+        void *setup_packet = NULL;
+        void *data_buffer = NULL;
+        size_t setup_packet_len = 0;
+        size_t data_buffer_len = 0;
+
+        rc = async_data_write_accept(&setup_packet, false,
+            1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len);
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+                return;
+        }
+        rc = async_data_write_accept(&data_buffer, false,
+            1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len);
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+                free(setup_packet);
+                return;
+        }
+
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                ipc_answer_0(callid, ENOMEM);
+                free(setup_packet);
+                free(data_buffer);
+                return;
+        }
+        trans->setup_packet = setup_packet;
+        trans->buffer = data_buffer;
+        trans->size = data_buffer_len;
+
+        rc = usb_iface->control_write(device, target,
+            setup_packet, setup_packet_len,
+            data_buffer, data_buffer_len,
+            callback_out, trans);
+
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+                async_transaction_destroy(trans);
+        }
+}
+
+
+void remote_usbhc_control_read(device_t *device, void *iface,
+ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        assert(usb_iface != NULL);
+
+        if (!usb_iface->control_read) {
+                ipc_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t data_len = DEV_IPC_GET_ARG3(*call);
+        usb_target_t target = {
+                .address = DEV_IPC_GET_ARG1(*call),
+                .endpoint = DEV_IPC_GET_ARG2(*call)
+        };
+
+        int rc;
+
+        void *setup_packet = NULL;
+        size_t setup_packet_len = 0;
+
+        rc = async_data_write_accept(&setup_packet, false,
+            1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len);
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+                return;
+        }
+
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                ipc_answer_0(callid, ENOMEM);
+                free(setup_packet);
+                return;
+        }
+        trans->setup_packet = setup_packet;
+        trans->size = data_len;
+        trans->buffer = malloc(data_len);
+        if (trans->buffer == NULL) {
+                ipc_answer_0(callid, ENOMEM);
+                async_transaction_destroy(trans);
+                return;
+        }
+
+        rc = usb_iface->control_read(device, target,
+            setup_packet, setup_packet_len,
+            trans->buffer, trans->size,
+            callback_in, trans);
+
+        if (rc != EOK) {
+                ipc_answer_0(callid, rc);
+                async_transaction_destroy(trans);
+        }
+}
+