drivers: uhc_virtual: allow multiple transfers scheduled within a frame

With the current implementation, NACK claims all resources and prevents
scheduling multiple transfers within a frame. Place a number of
available transfers in a list at the beginning of a frame, and process
the transfers in a limited number of slots.

Signed-off-by: Johann Fischer <[email protected]>

Author: jfischer-no

drivers/usb/uhc/uhc_virtual.c

@@ -24,23 +24,35 @@
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(uhc_vrt, CONFIG_UHC_DRIVER_LOG_LEVEL);
 
+#define FRAME_MAX_TRANSFERS 16
+
 struct uhc_vrt_config {
 };
 
+struct uhc_vrt_slot {
+	sys_dnode_t node;
+	struct uhc_transfer *xfer;
+};
+
+struct uhc_vrt_frame {
+	struct uhc_vrt_slot slots[FRAME_MAX_TRANSFERS];
+	sys_dnode_t *ptr;
+	sys_dlist_t list;
+	uint8_t count;
+};
+
 struct uhc_vrt_data {
 	const struct device *dev;
 	struct uvb_node *host_node;
 	struct k_work work;
 	struct k_fifo fifo;
 	struct uhc_transfer *last_xfer;
+	struct uhc_vrt_frame frame;
 	struct k_timer sof_timer;
-	bool busy;
 	uint8_t req;
 };
 
 enum uhc_vrt_event_type {
-	/* Trigger next transfer */
-	UHC_VRT_EVT_XFER,
 	/* SoF generator event */
 	UHC_VRT_EVT_SOF,
 	/* Request reply received */
@@ -94,7 +106,6 @@ static int vrt_xfer_control(const struct device *dev,
 		}
 
 		priv->req = UVB_REQUEST_SETUP;
-		priv->busy = true;
 
 		return uvb_advert_pkt(priv->host_node, uvb_pkt);
 	}
@@ -118,7 +129,6 @@ static int vrt_xfer_control(const struct device *dev,
 		}
 
 		priv->req = UVB_REQUEST_DATA;
-		priv->busy = true;
 
 		return uvb_advert_pkt(priv->host_node, uvb_pkt);
 	}
@@ -142,7 +152,6 @@ static int vrt_xfer_control(const struct device *dev,
 		}
 
 		priv->req = UVB_REQUEST_DATA;
-		priv->busy = true;
 
 		return uvb_advert_pkt(priv->host_node, uvb_pkt);
 	}
@@ -177,25 +186,87 @@ static int vrt_xfer_bulk(const struct device *dev,
 	return uvb_advert_pkt(priv->host_node, uvb_pkt);
 }
 
-static int vrt_schedule_xfer(const struct device *dev)
+static inline uint8_t get_xfer_ep_idx(const uint8_t ep)
 {
-	struct uhc_vrt_data *priv = uhc_get_private(dev);
+	/* We do not need to differentiate the direction for the control
+	 * transfers because they are handled as a whole.
+	 */
+	if (USB_EP_DIR_IS_OUT(ep) || USB_EP_GET_IDX(ep) == 0) {
+		return USB_EP_GET_IDX(ep & BIT_MASK(4));
+	}
+
+	return USB_EP_GET_IDX(ep & BIT_MASK(4)) + 16U;
+}
+
+static void vrt_assemble_frame(const struct device *dev)
+{
+	struct uhc_vrt_data *const priv = uhc_get_private(dev);
+	struct uhc_vrt_frame *const frame = &priv->frame;
+	struct uhc_data *const data = dev->data;
+	struct uhc_transfer *tmp;
+	unsigned int n = 0;
+	unsigned int key;
+	uint32_t bm = 0;
+
+	sys_dlist_init(&frame->list);
+	frame->ptr = NULL;
+	frame->count = 0;
+	key = irq_lock();
+
+	/* TODO: add periodic transfers up to 90% */
+	SYS_DLIST_FOR_EACH_CONTAINER(&data->ctrl_xfers, tmp, node) {
+		uint8_t idx = get_xfer_ep_idx(tmp->ep);
+
+		/* There could be multiple transfers queued for the same
+		 * endpoint, for now we only allow one to be scheduled per frame.
+		 */
+		if (bm & BIT(idx)) {
+			continue;
+		}
+
+		bm |= BIT(idx);
+		frame->slots[n].xfer = tmp;
+		sys_dlist_append(&frame->list, &frame->slots[n].node);
+		n++;
+
+		if (n >= FRAME_MAX_TRANSFERS) {
+			/* No more free slots */
+			break;
+		}
+	}
+
+	irq_unlock(key);
+}
+
+static int vrt_schedule_frame(const struct device *dev)
+{
+	struct uhc_vrt_data *const priv = uhc_get_private(dev);
+	struct uhc_vrt_frame *const frame = &priv->frame;
+	struct uhc_vrt_slot *slot;
 
 	if (priv->last_xfer == NULL) {
-		priv->last_xfer = uhc_xfer_get_next(dev);
-		if (priv->last_xfer == NULL) {
-			LOG_DBG("Nothing to transfer");
+		if (frame->count >= FRAME_MAX_TRANSFERS) {
+			LOG_DBG("Frame finished");
 			return 0;
 		}
 
-		LOG_DBG("Next transfer is %p", priv->last_xfer);
+		frame->ptr = sys_dlist_get(&frame->list);
+		slot = SYS_DLIST_CONTAINER(frame->ptr, slot, node);
+		if (slot == NULL) {
+			LOG_DBG("No more transfers for the frame");
+			return 0;
+		}
+
+		priv->last_xfer = slot->xfer;
+		frame->count++;
+		LOG_DBG("Next transfer is %p (count %u)",
+			(void *)priv->last_xfer, frame->count);
 	}
 
 	if (USB_EP_GET_IDX(priv->last_xfer->ep) == 0) {
 		return vrt_xfer_control(dev, priv->last_xfer);
 	}
 
-	/* TODO: Isochronous transfers */
 	return vrt_xfer_bulk(dev, priv->last_xfer);
 }
 
@@ -276,6 +347,7 @@ static int vrt_handle_reply(const struct device *dev,
 			    struct uvb_packet *const pkt)
 {
 	struct uhc_vrt_data *priv = uhc_get_private(dev);
+	struct uhc_vrt_frame *const frame = &priv->frame;
 	struct uhc_transfer *const xfer = priv->last_xfer;
 	int ret = 0;
 
@@ -285,11 +357,12 @@ static int vrt_handle_reply(const struct device *dev,
 		goto handle_reply_err;
 	}
 
-	priv->busy = false;
-
 	switch (pkt->reply) {
 	case UVB_REPLY_NACK:
-		/* Restart last transaction */
+		/* Move the transfer back to the list. */
+		sys_dlist_append(&frame->list, frame->ptr);
+		priv->last_xfer = NULL;
+		LOG_DBG("NACK 0x%02x count %u", xfer->ep, frame->count);
 		break;
 	case UVB_REPLY_STALL:
 		vrt_xfer_drop_active(dev, -EPIPE);
@@ -315,7 +388,6 @@ static void vrt_xfer_cleanup_cancelled(const struct device *dev)
 	struct uhc_transfer *tmp;
 
 	if (priv->last_xfer != NULL && priv->last_xfer->err == -ECONNRESET) {
-		priv->busy = false;
 		vrt_xfer_drop_active(dev, -ECONNRESET);
 	}
 
@@ -337,6 +409,11 @@ static void xfer_work_handler(struct k_work *work)
 		int err;
 
 		switch (ev->type) {
+		case UHC_VRT_EVT_SOF:
+			vrt_xfer_cleanup_cancelled(dev);
+			vrt_assemble_frame(dev);
+			schedule = true;
+			break;
 		case UHC_VRT_EVT_REPLY:
 			err = vrt_handle_reply(dev, ev->pkt);
 			if (unlikely(err)) {
@@ -345,23 +422,16 @@ static void xfer_work_handler(struct k_work *work)
 
 			schedule = true;
 			break;
-		case UHC_VRT_EVT_XFER:
-			LOG_DBG("Transfer triggered for %p", dev);
-			schedule = true;
-			break;
-		case UHC_VRT_EVT_SOF:
-			break;
 		default:
 			break;
 		}
 
-		vrt_xfer_cleanup_cancelled(dev);
-
-		if (schedule && !priv->busy) {
-			err = vrt_schedule_xfer(dev);
+		if (schedule) {
+			err = vrt_schedule_frame(dev);
 			if (unlikely(err)) {
 				uhc_submit_event(dev, UHC_EVT_ERROR, err);
 			}
+
 		}
 
 		k_mem_slab_free(&uhc_vrt_slab, (void *)ev);
@@ -461,7 +531,6 @@ static int uhc_vrt_enqueue(const struct device *dev,
 			   struct uhc_transfer *const xfer)
 {
 	uhc_xfer_append(dev, xfer);
-	vrt_event_submit(dev, UHC_VRT_EVT_XFER, NULL);
 
 	return 0;
 }
@@ -482,7 +551,6 @@ static int uhc_vrt_dequeue(const struct device *dev,
 	}
 
 	irq_unlock(key);
-	vrt_event_submit(dev, UHC_VRT_EVT_XFER, NULL);
 
 	return 0;
 }