Changeset c21e6a5 in mainline for uspace/drv/bus/usb/uhci

Timestamp:

2018-02-05T00:54:08Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

af16ebe

Parents:

65c059f

git-author:

Ondřej Hlavatý <aearsis@…> (2018-02-05 00:27:40)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-02-05 00:54:08)

Message:

usbhost: prepare buffers for transfers in library

Location:

uspace/drv/bus/usb/uhci

Files:

• uhci_batch.c (modified) (3 diffs)
• uhci_batch.h (modified) (3 diffs)
• uhci_rh.c (modified) (1 diff)

uspace/drv/bus/usb/uhci/uhci_batch.c

@@ -61 +61 @@
 {
         assert(uhci_batch);
-        free32(uhci_batch->device_buffer);
+        dma_buffer_free(&uhci_batch->uhci_dma_buffer);
         free(uhci_batch);
 }
@@ -110 +110 @@
 
         const size_t total_size = (sizeof(td_t) * uhci_batch->td_count)
-            + sizeof(qh_t) + setup_size + usb_batch->buffer_size;
-        uhci_batch->device_buffer = malloc32(total_size);
-        if (!uhci_batch->device_buffer) {
+            + sizeof(qh_t) + setup_size;
+
+        if (dma_buffer_alloc(&uhci_batch->uhci_dma_buffer, total_size)) {
                 usb_log_error("Failed to allocate UHCI buffer.");
                 return ENOMEM;
         }
-        memset(uhci_batch->device_buffer, 0, total_size);
-
-        uhci_batch->tds = uhci_batch->device_buffer;
-        uhci_batch->qh =
-            (uhci_batch->device_buffer + (sizeof(td_t) * uhci_batch->td_count));
+        memset(uhci_batch->uhci_dma_buffer.virt, 0, total_size);
+
+        uhci_batch->tds = uhci_batch->uhci_dma_buffer.virt;
+        uhci_batch->qh = (qh_t *) &uhci_batch->tds[uhci_batch->td_count];
 
         qh_init(uhci_batch->qh);
         qh_set_element_td(uhci_batch->qh, &uhci_batch->tds[0]);
 
-        void *dest =
-            uhci_batch->device_buffer + (sizeof(td_t) * uhci_batch->td_count)
-            + sizeof(qh_t);
+        void *setup_buffer = uhci_transfer_batch_setup_buffer(uhci_batch);
+        assert(setup_buffer == (void *) (uhci_batch->qh + 1));
         /* Copy SETUP packet data to the device buffer */
-        memcpy(dest, usb_batch->setup.buffer, setup_size);
-        dest += setup_size;
-        /* Copy generic data unless they are provided by the device */
-        if (usb_batch->dir != USB_DIRECTION_IN) {
-                memcpy(dest, usb_batch->buffer, usb_batch->buffer_size);
-        }
+        memcpy(setup_buffer, usb_batch->setup.buffer, setup_size);
+
         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT
             " memory structures ready.", usb_batch,
@@ -196 +190 @@
         }
 
-        if (batch->dir == USB_DIRECTION_IN) {
-                assert(batch->transferred_size <= batch->buffer_size);
-                memcpy(batch->buffer,
-                    uhci_transfer_batch_data_buffer(uhci_batch),
-                    batch->transferred_size);
-        }
+        assert(batch->transferred_size <= batch->buffer_size);
 
         return true;

uspace/drv/bus/usb/uhci/uhci_batch.h

@@ -61 +61 @@
         /** Number of TDs used by the transfer */
         size_t td_count;
-        /** Data buffer, must be accessible by the UHCI hw */
-        void *device_buffer;
+        /* Setup data */
+        char *setup_buffer;
+        /** Backing TDs + setup_buffer */
+        dma_buffer_t uhci_dma_buffer;
         /** List element */
         link_t link;
@@ -80 +82 @@
 {
         assert(uhci_batch);
-        assert(uhci_batch->device_buffer);
-        return uhci_batch->device_buffer + sizeof(qh_t) +
+        return uhci_batch->uhci_dma_buffer.virt + sizeof(qh_t) +
             uhci_batch->td_count * sizeof(td_t);
 }
@@ -93 +94 @@
 {
         assert(uhci_batch);
-        return uhci_transfer_batch_setup_buffer(uhci_batch) +
-            (uhci_batch->base.ep->transfer_type == USB_TRANSFER_CONTROL ? USB_SETUP_PACKET_SIZE : 0);
+        return uhci_batch->base.dma_buffer.virt;
 }
 

uspace/drv/bus/usb/uhci/uhci_rh.c

@@ -107 +107 @@
                 batch->error = virthub_base_request(&instance->base, batch->target,
                     batch->dir, (void*) batch->setup.buffer,
-                    batch->buffer, batch->buffer_size, &batch->transferred_size);
+                    batch->dma_buffer.virt, batch->buffer_size, &batch->transferred_size);
                 if (batch->error == ENAK)
                         async_usleep(instance->base.endpoint_descriptor.poll_interval * 1000);