usb: usbnet: ecm: Use transfer API

Replace low-level usb_read/usb_write with transfer functions.

Signed-off-by: Loic Poulain <[email protected]>

Author: Loic Poulain

subsys/usb/class/netusb/function_ecm.c

@@ -28,11 +28,7 @@
 #define USB_CDC_ECM_REQ_TYPE		0x21
 #define USB_CDC_SET_ETH_PKT_FILTER	0x43
 
-/* Pointer to pkt assembling at the moment */
-static struct net_pkt *in_pkt;
-
-/* In a case of low memory skip data to the end of the packet */
-static bool skip;
+static u8_t tx_buf[NETUSB_MTU], rx_buf[NETUSB_MTU];
 
 static int ecm_class_handler(struct usb_setup_packet *setup, s32_t *len,
 			     u8_t **data)
@@ -61,17 +57,16 @@ static void ecm_int_in(u8_t ep, enum usb_dc_ep_cb_status_code ep_status)
 	SYS_LOG_DBG("EP 0x%x status %d", ep, ep_status);
 }
 
-/* Returns true if the given packet is long enough to hold the whole payload */
-static bool ecm_have_payload(struct net_pkt *pkt)
+/* Retrieve expected pkt size from ethernet/ip header */
+static size_t ecm_eth_size(void *ecm_pkt, size_t len)
 {
-	struct net_eth_hdr *hdr = NET_ETH_HDR(pkt);
-	int len = net_pkt_get_len(pkt);
-	u8_t *ip_data = pkt->frags->data + sizeof(struct net_eth_hdr);
+	struct net_eth_hdr *hdr = (void *)ecm_pkt;
+	u8_t *ip_data = (u8_t *)ecm_pkt + sizeof(struct net_eth_hdr);
 	u16_t ip_len;
 
 	if (len < NET_IPV6H_LEN + sizeof(struct net_eth_hdr)) {
-		/* Too short to tell */
-		return false;
+		/* Too short */
+		return 0;
 	}
 
 	switch (ntohs(hdr->type)) {
@@ -84,201 +79,101 @@ static bool ecm_have_payload(struct net_pkt *pkt)
 		break;
 	default:
 		SYS_LOG_DBG("Unknown hdr type 0x%04x", hdr->type);
-		return false;
+		return 0;
 	}
 
-	return sizeof(struct net_eth_hdr) + ip_len <= len;
+	return sizeof(struct net_eth_hdr) + ip_len;
 }
 
-/* Host to device data out */
-static void ecm_bulk_out(u8_t ep, enum usb_dc_ep_cb_status_code ep_status)
+static int ecm_send(struct net_pkt *pkt)
 {
-	struct net_pkt *pkt;
-	struct net_buf *buf;
-	u8_t buffer[CONFIG_CDC_ECM_BULK_EP_MPS];
-	u32_t len;
-
-	usb_read(ep, NULL, 0, &len);
-#if VERBOSE_DEBUG
-	SYS_LOG_DBG("EP 0x%x status %d len %u", ep, ep_status, len);
-#endif
-
-	if (unlikely(len > CONFIG_CDC_ECM_BULK_EP_MPS || !len)) {
-		SYS_LOG_ERR("Incorrect length: %u", len);
-		return;
-	}
+	struct net_buf *frag;
+	int b_idx = 0, ret;
 
-	/*
-	 * Quark SE USB controller is always storing data
-	 * in the FIFOs per 32-bit words. Now handled in the
-	 * usb_read().
-	 */
-	usb_read(ep, buffer, len, NULL);
+	net_hexdump_frags("<", pkt);
 
-	if (skip) {
-		SYS_LOG_WRN("Skipping %u bytes", len);
+	if (!pkt->frags) {
+		return -ENODATA;
+	}
 
-		if (len < sizeof(buffer)) {
-			SYS_LOG_WRN("End skipping fragments");
-			skip = false;
+	/* copy header */
+	memcpy(&tx_buf[b_idx], net_pkt_ll(pkt), net_pkt_ll_reserve(pkt));
+	b_idx += net_pkt_ll_reserve(pkt);
 
-			return;
-		}
-
-		return;
+	/* copy payload */
+	for (frag = pkt->frags; frag; frag = frag->frags) {
+		memcpy(&tx_buf[b_idx], frag->data, frag->len);
+		b_idx += frag->len;
 	}
 
-	/* Start new packet */
-	if (!in_pkt) {
-		pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
-		if (!pkt) {
-			SYS_LOG_ERR("Not enough memory for pkt buffer");
-			skip = true;
-			return;
-		}
+	/* transfer data to host */
+	ret = usb_transfer_sync(CONFIG_CDC_ECM_IN_EP_ADDR, tx_buf, b_idx,
+				USB_TRANS_WRITE);
+	if (ret != b_idx) {
+		SYS_LOG_ERR("Transfer failure");
+		return -EINVAL;
+	}
 
-		buf = net_pkt_get_frag(pkt, K_NO_WAIT);
-		if (!buf) {
-			net_pkt_unref(pkt);
-			SYS_LOG_ERR("Not enough memory for network buffers");
-			return;
-		}
+	return 0;
+}
 
-		net_pkt_frag_insert(pkt, buf);
+static void ecm_read_cb(u8_t ep, int size, void *priv)
+{
+	struct net_pkt *pkt;
+	struct net_buf *frag;
 
-		in_pkt = pkt;
+	if (size <= 0) {
+		goto done;
 	}
 
-	/* The ECM spec says that the end of a packet is marked by
-	 * a short frame.  If the packet is a multiple of the endpoint
-	 * size then the host should send a zero length packet.
-	 * Linux, however, sends a one byte packet instead.  Handle by
-	 * checking the IP header length and dropping the extra byte.
+	/* Linux considers by default that network usb device controllers are
+	 * not able to handle Zero Lenght Packet (ZLP) and then generates
+	 * a short packet containing a null byte. Handle by checking the IP
+	 * header length and dropping the extra byte.
 	 */
-	if (len == 1 && ecm_have_payload(in_pkt)) {
-		len = 0;
+	if (rx_buf[size - 1] == 0) { /* last byte is null */
+		if (ecm_eth_size(rx_buf, size) == (size - 1)) {
+			/* last byte has been appended as delimiter, drop it */
+			size--;
+		}
 	}
 
-	if (!net_pkt_append_all(in_pkt, len, buffer, K_FOREVER)) {
-		SYS_LOG_ERR("Error appending data to pkt: %p", in_pkt);
-
-		net_pkt_unref(in_pkt);
-		in_pkt = NULL;
-		return;
+	pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
+	if (!pkt) {
+		SYS_LOG_ERR("no memory for network packet\n");
+		goto done;
 	}
 
-	if (len < sizeof(buffer)) {
-		SYS_LOG_DBG("ECM network packet received, len %u",
-			    net_pkt_get_len(in_pkt));
+	frag = net_pkt_get_frag(pkt, K_FOREVER);
+	if (!frag) {
+		SYS_LOG_ERR("no memory for network packet\n");
+		net_pkt_unref(pkt);
+		goto done;
+	}
 
-		net_hexdump_frags(">", in_pkt);
+	net_pkt_frag_insert(pkt, frag);
 
-		netusb_recv(in_pkt);
-		in_pkt = NULL;
+	if (!net_pkt_append_all(pkt, size, rx_buf, K_FOREVER)) {
+		SYS_LOG_ERR("no memory for network packet\n");
+		net_pkt_unref(pkt);
+		goto done;
 	}
-}
 
-static void ecm_bulk_in(u8_t ep, enum usb_dc_ep_cb_status_code ep_status)
-{
-#if VERBOSE_DEBUG
-	SYS_LOG_DBG("EP 0x%x status %d", ep, ep_status);
-#endif
-}
+	netusb_recv(pkt);
 
-/*
- * The idea here is to use one buffer of size endpoint MPS (64 bytes)
- * for sending pkt without linearlizing first since we would need Ethernet
- * packet frame as a buffer up to 1518 bytes and it would require two
- * iterations.
- */
-static int append_bytes(u8_t *out_buf, u16_t buf_len, u8_t *data,
-			u16_t len, u16_t remaining)
-{
-	int ret;
-
-	do {
-		u16_t count = min(len, remaining);
-#if VERBOSE_DEBUG
-		SYS_LOG_DBG("len %u remaining %u count %u", len, remaining,
-			    count);
-#endif
-
-		memcpy(out_buf + (buf_len - remaining), data, count);
-
-		data += count;
-		remaining -= count;
-		len -= count;
-
-		/* Buffer filled */
-		if (remaining == 0) {
-#if VERBOSE_DEBUG
-			net_hexdump("fragment", out_buf, buf_len);
-#endif
-
-			ret = try_write(CONFIG_CDC_ECM_IN_EP_ADDR, out_buf,
-					buf_len);
-			if (ret) {
-				SYS_LOG_ERR("Error sending data");
-				return ret;
-			}
-
-			/* Consumed full buffer */
-			if (len == 0) {
-				return buf_len;
-			}
-
-			remaining = buf_len;
-		}
-	} while (len);
-#if VERBOSE_DEBUG
-	net_hexdump("fragment", out_buf, buf_len - remaining);
-#endif
-	return remaining;
+done:
+	usb_transfer(CONFIG_CDC_ECM_OUT_EP_ADDR, rx_buf, sizeof(rx_buf),
+		     USB_TRANS_READ, ecm_read_cb, NULL);
 }
 
-static int ecm_send(struct net_pkt *pkt)
+static int ecm_connect(bool connected)
 {
-	u8_t send_buf[CONFIG_CDC_ECM_BULK_EP_MPS];
-	int remaining = sizeof(send_buf);
-	struct net_buf *frag;
-
-	net_hexdump_frags("<", pkt);
-
-	if (!pkt->frags) {
-		return -ENODATA;
-	}
-
-	remaining = append_bytes(send_buf, sizeof(send_buf),
-				 net_pkt_ll(pkt),
-				 net_pkt_ll_reserve(pkt) +
-				 pkt->frags->len,
-				 remaining);
-	if (remaining < 0) {
-		return remaining;
-	}
-
-	for (frag = pkt->frags->frags; frag; frag = frag->frags) {
-#if VERBOSE_DEBUG
-		SYS_LOG_DBG("Fragment %p len %u, remaining %u",
-			    frag, frag->len, remaining);
-#endif
-		remaining = append_bytes(send_buf, sizeof(send_buf),
-					 frag->data, frag->len,
-					 remaining);
-		if (remaining < 0) {
-			return remaining;
-		}
-	}
-
-	if (remaining > 0 && remaining < sizeof(send_buf)) {
-		return try_write(CONFIG_CDC_ECM_IN_EP_ADDR, send_buf,
-				 sizeof(send_buf) - remaining);
+	if (connected) {
+		ecm_read_cb(CONFIG_CDC_ECM_OUT_EP_ADDR, 0, NULL);
 	} else {
-		u8_t zero[] = { 0x00 };
-
-		SYS_LOG_DBG("Send Zero packet to mark frame end");
-
-		return try_write(CONFIG_CDC_ECM_IN_EP_ADDR, zero, sizeof(zero));
+		/* Cancel any transfer */
+		usb_cancel_transfer(CONFIG_CDC_ECM_OUT_EP_ADDR);
+		usb_cancel_transfer(CONFIG_CDC_ECM_IN_EP_ADDR);
 	}
 
 	return 0;
@@ -291,18 +186,20 @@ static struct usb_ep_cfg_data ecm_ep_data[] = {
 		.ep_addr = CONFIG_CDC_ECM_INT_EP_ADDR
 	},
 	{
-		.ep_cb = ecm_bulk_out,
+		/* high-level transfer mgmt */
+		.ep_cb = usb_transfer_ep_callback,
 		.ep_addr = CONFIG_CDC_ECM_OUT_EP_ADDR
 	},
 	{
-		.ep_cb = ecm_bulk_in,
+		/* high-level transfer mgmt */
+		.ep_cb = usb_transfer_ep_callback,
 		.ep_addr = CONFIG_CDC_ECM_IN_EP_ADDR
 	},
 };
 
 struct netusb_function ecm_function = {
 	.init = NULL,
-	.connect_media = NULL,
+	.connect_media = ecm_connect,
 	.class_handler = ecm_class_handler,
 	.send_pkt = ecm_send,
 	.num_ep = ARRAY_SIZE(ecm_ep_data),