starting to replace memcpy with DMA

rp2040/usb_dc_rp2040.c

@@ -1,6 +1,6 @@
 #include "usbd_core.h"
 #include "usb_rp2040_reg.h"
-
+#include "lwip.h"
 #ifndef USBD_IRQHandler
 #define USBD_IRQHandler isr_irq5
 #endif
@@ -156,7 +156,16 @@ static void usb_start_transfer(struct usb_dc_ep_state *ep, uint8_t *buf, uint16_
     if (USB_EP_DIR_IS_IN(ep->ep_addr)) {
         /*!< Need to copy the data from the user buffer to the usb memory */
         if (buf != NULL) {
-            memcpy((void *)ep->dpram_data_buf, (void *)buf, len);
+			dma_channel_configure(
+					dma_usb_cpy,            // Channel to be configured
+					&usb_cpy,              // The configuration we just created
+					(void *)ep->dpram_data_buf,// The initial write address
+					buf,             // The initial read address
+					(len/4)+1,             // Number of transfers; in this case each is 1 byte.
+					true             // Start immediately.
+				);
+			//dma_channel_wait_for_finish_blocking(dma_usb_cpy);
+            //memcpy((void *)ep->dpram_data_buf, (void *)buf, len);
         }
         /*!< Mark as full */
         val |= USB_BUF_CTRL_FULL;

src/lwip.h

@@ -25,9 +25,20 @@ void printline(int cdc,char string[],int len);
 void dma_handler();
 extern int chan;
 extern int chan_2;
+extern int dma_memset_0;
+extern int dma_align_cpy_head;
+extern int dma_align_cpy;
+extern int dma_align_cpy_tail;
+extern int dma_usb_cpy;
 
 extern dma_channel_config c;
 extern dma_channel_config c_2;
+extern dma_channel_config memset_0;
+extern dma_channel_config align_cpy_head;
+extern dma_channel_config align_cpy;
+extern dma_channel_config align_cpy_tail;
+extern dma_channel_config usb_cpy;
+
 
 extern char connect_ssid[190], connect_ssid_decode[95], connect_password[190], connect_password_decode[95], retry_ms[6], enc_type[1], wifi_configuration[450], 	wifi_configuration_last[450];
 extern int wifi_congfig_len;

src/main.c

@@ -23,6 +23,16 @@ int chan = 0;
 dma_channel_config c;
 int chan_2 = 0;
 dma_channel_config c_2;
+int dma_memset_0 = 0;
+dma_channel_config memset_0;
+int dma_align_cpy_head = 0;
+dma_channel_config align_cpy_head;
+int dma_align_cpy = 0;
+dma_channel_config align_cpy;
+int dma_align_cpy_tail = 0;
+dma_channel_config align_cpy_tail;
+int dma_usb_cpy = 0;
+dma_channel_config usb_cpy;
 
 void printline(int cdc,char string[],int len){
 	char buf[2048];
@@ -165,13 +175,43 @@ int main(void)
 	channel_config_set_read_increment(&c, true);
 	channel_config_set_write_increment(&c, true);
 
-	chan_2 = dma_claim_unused_channel(false);
+	chan_2 = dma_claim_unused_channel(true);
 	dma_channel_set_irq0_enabled(chan_2, true);
 
 	c_2 = dma_channel_get_default_config(chan_2);
 	channel_config_set_transfer_data_size(&c_2, DMA_SIZE_16);
 	channel_config_set_read_increment(&c_2, true);
 	channel_config_set_write_increment(&c_2, true);
+
+	dma_memset_0 = dma_claim_unused_channel(true);
+	memset_0 =  dma_channel_get_default_config(dma_memset_0);
+	channel_config_set_transfer_data_size(&memset_0, DMA_SIZE_16);
+	channel_config_set_read_increment(&memset_0, false);
+	channel_config_set_write_increment(&memset_0, true);
+
+	dma_align_cpy_head = dma_claim_unused_channel(true);
+	align_cpy_head =  dma_channel_get_default_config(dma_align_cpy_head);
+	channel_config_set_transfer_data_size(&align_cpy_head, DMA_SIZE_8);
+	channel_config_set_read_increment(&align_cpy_head, true);
+	channel_config_set_write_increment(&align_cpy_head, true);
+
+	dma_align_cpy = dma_claim_unused_channel(true);
+	align_cpy =  dma_channel_get_default_config(dma_align_cpy);
+	channel_config_set_transfer_data_size(&align_cpy, DMA_SIZE_32);
+	channel_config_set_read_increment(&align_cpy, true);
+	channel_config_set_write_increment(&align_cpy, true);
+
+	dma_align_cpy_tail = dma_claim_unused_channel(true);
+	align_cpy_tail =  dma_channel_get_default_config(dma_align_cpy_tail);
+	channel_config_set_transfer_data_size(&align_cpy_tail, DMA_SIZE_8);
+	channel_config_set_read_increment(&align_cpy_tail, true);
+	channel_config_set_write_increment(&align_cpy_tail, true);
+
+	dma_usb_cpy = dma_claim_unused_channel(true);
+	usb_cpy =  dma_channel_get_default_config(dma_usb_cpy);
+	channel_config_set_transfer_data_size(&usb_cpy, DMA_SIZE_32);
+	channel_config_set_read_increment(&usb_cpy, true);
+	channel_config_set_write_increment(&usb_cpy, true);
 
 	while (1) {
 		if (!link_up) {

src/usbd_rndis.c

@@ -504,7 +504,16 @@ int usbd_rndis_eth_tx(struct pbuf *p)
     struct pbuf *q;
     uint8_t *buffer;
     rndis_data_packet_t *hdr;
-
+	hdr = (rndis_data_packet_t *)g_rndis_tx_buffer;
+	uint16_t zerobuf[] = {0};
+	dma_channel_configure(
+					dma_memset_0,            // Channel to be configured
+					&memset_0,              // The configuration we just created
+					hdr,// The initial write address
+					zerobuf,             // The initial read address
+					(sizeof(rndis_data_packet_t)/2)+1,             // Number of transfers; in this case each is 1 byte.
+					true             // Start immediately.
+				);
     if (g_usbd_rndis.link_status == NDIS_MEDIA_STATE_DISCONNECTED) {
         return -USB_ERR_NOTCONN;
     }
@@ -523,9 +532,9 @@ int usbd_rndis_eth_tx(struct pbuf *p)
         buffer += q->len;
     }
 
-    hdr = (rndis_data_packet_t *)g_rndis_tx_buffer;
-
-    memset(hdr, 0, sizeof(rndis_data_packet_t));
+
+	dma_channel_wait_for_finish_blocking(dma_memset_0);
+    //memset(hdr, 0, sizeof(rndis_data_packet_t));
     hdr->MessageType = REMOTE_NDIS_PACKET_MSG;
     hdr->MessageLength = sizeof(rndis_data_packet_t) + p->tot_len;
     hdr->DataOffset = sizeof(rndis_data_packet_t) - sizeof(rndis_generic_msg_t);

usb_config.h

@@ -196,7 +196,15 @@ static inline void *usb_memcpy(void *dest, const void *src, size_t n)
         if (n < leading_bytes) {
             leading_bytes = n;
         }
-        memcpy(d, s, leading_bytes);
+        //memcpy(d, s, leading_bytes);
+		dma_channel_configure(
+					dma_align_cpy_head,            // Channel to be configured
+					&align_cpy_head,              // The configuration we just created
+					d,// The initial write address
+					s,             // The initial read address
+					leading_bytes,             // Number of transfers; in this case each is 1 byte.
+					true             // Start immediately.
+				);
         d += leading_bytes;
         s += leading_bytes;
         n -= leading_bytes;
@@ -206,9 +214,19 @@ static inline void *usb_memcpy(void *dest, const void *src, size_t n)
     uint32_t *dw = (uint32_t *)d;
     const uint32_t *sw = (const uint32_t *)s;
     size_t word_count = n / 4;
-    for (size_t i = 0; i < word_count; ++i) {
+    /*
+	for (size_t i = 0; i < word_count; ++i) {
         dw[i] = sw[i];
-    }
+    }*/
+	dma_channel_configure(
+					dma_align_cpy,            // Channel to be configured
+					&align_cpy,              // The configuration we just created
+					dw,// The initial write address
+					sw,             // The initial read address
+					word_count,             // Number of transfers; in this case each is 1 byte.
+					true             // Start immediately.
+				);
+
 
     // Update pointers and remaining byte count
     d = (char *)(dw + word_count);
@@ -217,8 +235,17 @@ static inline void *usb_memcpy(void *dest, const void *src, size_t n)
 
     // Copy remaining bytes
     if (n > 0) {
-        memcpy(d, s, n);
+        //memcpy(d, s, n);
+		dma_channel_configure(
+					dma_align_cpy_tail,            // Channel to be configured
+					&align_cpy_tail,              // The configuration we just created
+					d,// The initial write address
+					s,             // The initial read address
+					n,             // Number of transfers; in this case each is 1 byte.
+					true             // Start immediately.
+				);
     }
+	//dma_channel_wait_for_finish_blocking(dma_align_cpy);
 
     return dest;
 }