Changeset 998773d in mainline for uspace/drv/bus/usb/xhci/trb_ring.c

Timestamp:

2018-01-22T14:27:24Z (7 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

effbef3

Parents:

db51a6a6

git-author:

Ondřej Hlavatý <aearsis@…> (2018-01-22 14:11:42)

git-committer:

Ondřej Hlavatý <aearsis@…> (2018-01-22 14:27:24)

Message:

xhci trb_ring: make initial ring size variable

File:

• uspace/drv/bus/usb/xhci/trb_ring.c (modified) (7 diffs)

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

@@ -37 +37 @@
 #include "trb_ring.h"
 
-#define SEGMENT_HEADER_SIZE (sizeof(link_t) + sizeof(uintptr_t))
-
-/**
- * Number of TRBs in a segment (with our header).
- */
-#define SEGMENT_TRB_COUNT ((PAGE_SIZE - SEGMENT_HEADER_SIZE) / sizeof(xhci_trb_t))
+/**
+ * A structure representing a segment of a TRB ring.
+ */
+
+#define SEGMENT_FOOTER_SIZE (sizeof(link_t) + sizeof(uintptr_t))
+
+#define SEGMENT_TRB_COUNT ((PAGE_SIZE - SEGMENT_FOOTER_SIZE) / sizeof(xhci_trb_t))
+#define SEGMENT_TRB_USEFUL_COUNT (SEGMENT_TRB_COUNT - 1)
 
 struct trb_segment {
@@ -51 +53 @@
 } __attribute__((aligned(PAGE_SIZE)));
 
+static_assert(sizeof(trb_segment_t) == PAGE_SIZE);
+
 
 /**
@@ -66 +70 @@
 {
         return segment_begin(segment) + SEGMENT_TRB_COUNT;
+}
+
+/**
+ * Return a first segment of a list of segments.
+ */
+static inline trb_segment_t *get_first_segment(list_t *segments)
+{
+        return list_get_instance(list_first(segments), trb_segment_t, segments_link);
+
 }
 
@@ -97 +110 @@
 /**
  * Initializes the ring with one segment.
- */
-int xhci_trb_ring_init(xhci_trb_ring_t *ring)
-{
-        struct trb_segment *segment;
+ *
+ * @param[in] initial_size A number of free slots on the ring, 0 leaves the
+ * choice on a reasonable default (one page-sized segment).
+ */
+int xhci_trb_ring_init(xhci_trb_ring_t *ring, size_t initial_size)
+{
         int err;
+        if (initial_size == 0)
+                initial_size = SEGMENT_TRB_USEFUL_COUNT;
 
         list_initialize(&ring->segments);
-
-        if ((err = trb_segment_alloc(&segment)) != EOK)
-                return err;
-
-        list_append(&segment->segments_link, &ring->segments);
-        ring->segment_count = 1;
-
+        size_t segment_count = (initial_size + SEGMENT_TRB_USEFUL_COUNT - 1)
+                / SEGMENT_TRB_USEFUL_COUNT;
+
+        for (size_t i = 0; i < segment_count; ++i) {
+                struct trb_segment *segment;
+                if ((err = trb_segment_alloc(&segment)) != EOK)
+                        return err;
+
+                list_append(&segment->segments_link, &ring->segments);
+                ring->segment_count = i + 1;
+        }
+
+        trb_segment_t * const segment = get_first_segment(&ring->segments);
         xhci_trb_t *last = segment_end(segment) - 1;
         xhci_trb_link_fill(last, segment->phys);
@@ -284 +307 @@
 /**
  * Initializes an event ring.
- */
-int xhci_event_ring_init(xhci_event_ring_t *ring)
-{
-        struct trb_segment *segment;
+ *
+ * @param[in] initial_size A number of free slots on the ring, 0 leaves the
+ * choice on a reasonable default (one page-sized segment).
+ */
+int xhci_event_ring_init(xhci_event_ring_t *ring, size_t initial_size)
+{
         int err;
+        if (initial_size == 0)
+                initial_size = SEGMENT_TRB_COUNT;
 
         list_initialize(&ring->segments);
 
-        if ((err = trb_segment_alloc(&segment)) != EOK)
-                return err;
-
-        list_append(&segment->segments_link, &ring->segments);
-        ring->segment_count = 1;
-
+        size_t segment_count = (initial_size + SEGMENT_TRB_COUNT - 1) / SEGMENT_TRB_COUNT;
+        size_t erst_size = segment_count * sizeof(xhci_erst_entry_t);
+
+        if (dma_buffer_alloc(&ring->erst, erst_size)) {
+                xhci_event_ring_fini(ring);
+                return ENOMEM;
+        }
+
+        xhci_erst_entry_t *erst = ring->erst.virt;
+        memset(erst, 0, erst_size);
+
+        for (size_t i = 0; i < segment_count; i++) {
+                trb_segment_t *segment;
+                if ((err = trb_segment_alloc(&segment)) != EOK) {
+                        xhci_event_ring_fini(ring);
+                        return err;
+                }
+
+                list_append(&segment->segments_link, &ring->segments);
+                ring->segment_count = i + 1;
+                xhci_fill_erst_entry(&erst[i], segment->phys, SEGMENT_TRB_COUNT);
+        }
+
+        trb_segment_t * const segment = get_first_segment(&ring->segments);
         ring->dequeue_segment = segment;
         ring->dequeue_trb = segment_begin(segment);
         ring->dequeue_ptr = segment->phys;
-
-        if (dma_buffer_alloc(&ring->erst, PAGE_SIZE)) {
-                xhci_event_ring_fini(ring);
-                return ENOMEM;
-        }
-        xhci_erst_entry_t *erst = ring->erst.virt;
-
-        memset(erst, 0, PAGE_SIZE);
-        xhci_fill_erst_entry(&erst[0], segment->phys, SEGMENT_TRB_COUNT);
-
         ring->ccs = 1;
 
@@ -316 +351 @@
 
         usb_log_debug("Initialized event ring.");
-
         return EOK;
 }
@@ -324 +358 @@
         list_foreach_safe(ring->segments, cur, next) {
                 trb_segment_t *segment = list_get_instance(cur, trb_segment_t, segments_link);
-                dmamem_unmap_anonymous(segment);
+                trb_segment_free(segment);
         }