Changes in uspace/drv/bus/usb/xhci/transfers.c [3038d51:e454d9c] in mainline

File:

• uspace/drv/bus/usb/xhci/transfers.c (modified) (6 diffs)

uspace/drv/bus/usb/xhci/transfers.c

@@ -126 +126 @@
 }
 
-static int calculate_trb_count(xhci_transfer_t *transfer)
-{
-        const size_t size = transfer->batch.buffer_size;
-        return (size + PAGE_SIZE - 1 )/ PAGE_SIZE;
-}
-
-static void trb_set_buffer(xhci_transfer_t *transfer, xhci_trb_t *trb,
-        size_t i, size_t total, size_t *remaining)
-{
-        const uintptr_t ptr = dma_buffer_phys(&transfer->hc_buffer,
-                transfer->hc_buffer.virt + i * PAGE_SIZE);
-
-        trb->parameter = host2xhci(64, ptr);
-        TRB_CTRL_SET_TD_SIZE(*trb, max(31, total - i - 1));
-        if (*remaining > PAGE_SIZE) {
-                TRB_CTRL_SET_XFER_LEN(*trb, PAGE_SIZE);
-                *remaining -= PAGE_SIZE;
-        }
-        else {
-                TRB_CTRL_SET_XFER_LEN(*trb, *remaining);
-                *remaining = 0;
-        }
-}
-
 static int schedule_control(xhci_hc_t* hc, xhci_transfer_t* transfer)
 {
@@ -157 +133 @@
         usb_device_request_setup_packet_t* setup = &batch->setup.packet;
 
-        size_t buffer_count = 0;
-        if (setup->length > 0) {
-                buffer_count = calculate_trb_count(transfer);
-        }
-
-        xhci_trb_t trbs[buffer_count + 2];
-
-        xhci_trb_t *trb_setup = trbs;
+        xhci_trb_t trbs[3];
+        int trbs_used = 0;
+
+        xhci_trb_t *trb_setup = trbs + trbs_used++;
         xhci_trb_clean(trb_setup);
 
@@ -183 +155 @@
 
         /* Data stage */
+        xhci_trb_t *trb_data = NULL;
         if (setup->length > 0) {
+                trb_data = trbs + trbs_used++;
+                xhci_trb_clean(trb_data);
+
+                trb_data->parameter = host2xhci(64, transfer->hc_buffer.phys);
+
+                // data size (sent for OUT, or buffer size)
+                TRB_CTRL_SET_XFER_LEN(*trb_data, batch->buffer_size);
+                // FIXME: TD size 4.11.2.4
+                TRB_CTRL_SET_TD_SIZE(*trb_data, 1);
+
+                // Some more fields here, no idea what they mean
+                TRB_CTRL_SET_TRB_TYPE(*trb_data, XHCI_TRB_TYPE_DATA_STAGE);
+
                 int stage_dir = REQUEST_TYPE_IS_DEVICE_TO_HOST(setup->request_type)
                                         ? STAGE_IN : STAGE_OUT;
-                size_t remaining = transfer->batch.buffer_size;
-
-                for (size_t i = 0; i < buffer_count; ++i) {
-                        xhci_trb_clean(&trbs[i + 1]);
-                        trb_set_buffer(transfer, &trbs[i + 1], i, buffer_count, &remaining);
-
-                        TRB_CTRL_SET_DIR(trbs[i + 1], stage_dir);
-                        TRB_CTRL_SET_TRB_TYPE(trbs[i + 1], XHCI_TRB_TYPE_DATA_STAGE);
-
-                        if (i == buffer_count - 1) break;
-
-                        /* Set the chain bit as this is not the last TRB */
-                        TRB_CTRL_SET_CHAIN(trbs[i], 1);
-                }
+                TRB_CTRL_SET_DIR(*trb_data, stage_dir);
         }
 
         /* Status stage */
-        xhci_trb_t *trb_status = trbs + buffer_count + 1;
+        xhci_trb_t *trb_status = trbs + trbs_used++;
         xhci_trb_clean(trb_status);
 
@@ -219 +192 @@
 
         return xhci_trb_ring_enqueue_multiple(get_ring(transfer), trbs,
-            buffer_count + 2, &transfer->interrupt_trb_phys);
+            trbs_used, &transfer->interrupt_trb_phys);
 }
 
 static int schedule_bulk(xhci_hc_t* hc, xhci_transfer_t *transfer)
 {
+        xhci_trb_t trb;
+        xhci_trb_clean(&trb);
+        trb.parameter = host2xhci(64, transfer->hc_buffer.phys);
+
+        // data size (sent for OUT, or buffer size)
+        TRB_CTRL_SET_XFER_LEN(trb, transfer->batch.buffer_size);
+
         /* The stream-enabled endpoints need to chain ED trb */
         xhci_endpoint_t *ep = xhci_endpoint_get(transfer->batch.ep);
         if (!ep->primary_stream_data_size) {
-                const size_t buffer_count = calculate_trb_count(transfer);
-                xhci_trb_t trbs[buffer_count];
-                size_t remaining = transfer->batch.buffer_size;
-
-                for (size_t i = 0; i < buffer_count; ++i) {
-                        xhci_trb_clean(&trbs[i]);
-                        trb_set_buffer(transfer, &trbs[i], i, buffer_count, &remaining);
-                        TRB_CTRL_SET_TRB_TYPE(trbs[i], XHCI_TRB_TYPE_NORMAL);
-
-                        if (i == buffer_count - 1) break;
-
-                        /* Set the chain bit as this is not the last TRB */
-                        TRB_CTRL_SET_CHAIN(trbs[i], 1);
-                }
-                /* Set the interrupt bit for last TRB */
-                TRB_CTRL_SET_IOC(trbs[buffer_count - 1], 1);
+                // FIXME: TD size 4.11.2.4
+                TRB_CTRL_SET_TD_SIZE(trb, 1);
+
+                // we want an interrupt after this td is done
+                TRB_CTRL_SET_IOC(trb, 1);
+                TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL);
 
                 xhci_trb_ring_t* ring = get_ring(transfer);
-                return xhci_trb_ring_enqueue_multiple(ring, &trbs[0], buffer_count,
-                        &transfer->interrupt_trb_phys);
+                return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
         }
         else {
+                TRB_CTRL_SET_TD_SIZE(trb, 2);
+                TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL);
+                TRB_CTRL_SET_CHAIN(trb, 1);
+                TRB_CTRL_SET_ENT(trb, 1);
+
                 xhci_trb_ring_t* ring = get_ring(transfer);
                 if (!ring) {
@@ -254 +228 @@
                 }
 
-                const size_t buffer_count = calculate_trb_count(transfer);
-                xhci_trb_t trbs[buffer_count + 1];
-                size_t remaining = transfer->batch.buffer_size;
-
-                for (size_t i = 0; i < buffer_count; ++i) {
-                        xhci_trb_clean(&trbs[i]);
-                        trb_set_buffer(transfer, &trbs[i], i, buffer_count + 1, &remaining);
-                        TRB_CTRL_SET_TRB_TYPE(trbs[i], XHCI_TRB_TYPE_NORMAL);
-                        TRB_CTRL_SET_CHAIN(trbs[i], 1);
+                int err = xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
+
+                if (err) {
+                        return err;
                 }
-                TRB_CTRL_SET_ENT(trbs[buffer_count - 1], 1);
-
-                xhci_trb_clean(&trbs[buffer_count]);
-                trbs[buffer_count].parameter = host2xhci(64, (uintptr_t) transfer);
-                TRB_CTRL_SET_TRB_TYPE(trbs[buffer_count], XHCI_TRB_TYPE_EVENT_DATA);
-                TRB_CTRL_SET_IOC(trbs[buffer_count], 1);
-
-                return xhci_trb_ring_enqueue_multiple(ring, &trbs[0], buffer_count + 1,
-                        &transfer->interrupt_trb_phys);
+
+                xhci_trb_clean(&trb);
+                trb.parameter = host2xhci(64, (uintptr_t) transfer);
+                TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_EVENT_DATA);
+                TRB_CTRL_SET_IOC(trb, 1);
+
+                return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
         }
 }
@@ -278 +245 @@
 static int schedule_interrupt(xhci_hc_t* hc, xhci_transfer_t* transfer)
 {
-        const size_t buffer_count = calculate_trb_count(transfer);
-        xhci_trb_t trbs[buffer_count];
-        size_t remaining = transfer->batch.buffer_size;
-
-        for (size_t i = 0; i < buffer_count; ++i) {
-                xhci_trb_clean(&trbs[i]);
-                trb_set_buffer(transfer, &trbs[i], i, buffer_count, &remaining);
-                TRB_CTRL_SET_TRB_TYPE(trbs[i], XHCI_TRB_TYPE_NORMAL);
-
-                if (i == buffer_count - 1) break;
-
-                /* Set the chain bit as this is not the last TRB */
-                TRB_CTRL_SET_CHAIN(trbs[i], 1);
-        }
-        /* Set the interrupt bit for last TRB */
-        TRB_CTRL_SET_IOC(trbs[buffer_count - 1], 1);
+        xhci_trb_t trb;
+        xhci_trb_clean(&trb);
+        trb.parameter = host2xhci(64, transfer->hc_buffer.phys);
+
+        // data size (sent for OUT, or buffer size)
+        TRB_CTRL_SET_XFER_LEN(trb, transfer->batch.buffer_size);
+        // FIXME: TD size 4.11.2.4
+        TRB_CTRL_SET_TD_SIZE(trb, 1);
+
+        // we want an interrupt after this td is done
+        TRB_CTRL_SET_IOC(trb, 1);
+
+        TRB_CTRL_SET_TRB_TYPE(trb, XHCI_TRB_TYPE_NORMAL);
 
         xhci_trb_ring_t* ring = get_ring(transfer);
-        return xhci_trb_ring_enqueue_multiple(ring, &trbs[0], buffer_count,
-                &transfer->interrupt_trb_phys);
+
+        return xhci_trb_ring_enqueue(ring, &trb, &transfer->interrupt_trb_phys);
 }