* added support for original spi transfers functions that require poling for completion.

* changed parameters count to be uint32_t instead of size_t. Dma transfer setup functions accept count as uint32_t. This provides more transparency on max byte size to user calling function.

Author: BriscoeTech

libraries/SPI/SPI.cpp

@@ -261,7 +261,6 @@ void SPIClass::transfer(void* txbuf, void* rxbuf, size_t count)
     }
 }
 
-
 // Pointer to SPIClass object, one per DMA channel.
 static SPIClass *spiPtr[DMAC_CH_NUM] = { 0 }; // Legit inits list to NULL
 
@@ -279,8 +278,12 @@ void SPIClass::dmaCallback_read(Adafruit_ZeroDMA *dma)
 	// read and write dmas are both done
 	if(spiPtr[channel]->dma_read_done && spiPtr[channel]->dma_write_done)
 	{
-		// call the callback function the user specified
-		spiPtr[channel]->userDmaCallback();
+		// is a user specified callback to call on completion
+		if(spiPtr[channel]->userDmaCallback != NULL)
+		{
+			// call the callback function the user specified
+			spiPtr[channel]->userDmaCallback();
+		}
 	}
 }
 
@@ -298,15 +301,41 @@ void SPIClass::dmaCallback_write(Adafruit_ZeroDMA *dma)
 	// read and write dmas are both done
 	if(spiPtr[channel]->dma_read_done && spiPtr[channel]->dma_write_done)
 	{
-		// call the callback function the user specified
-		spiPtr[channel]->userDmaCallback();
+		// is a user specified callback to call on completion
+		if(spiPtr[channel]->userDmaCallback != NULL)
+		{
+			// call the callback function the user specified
+			spiPtr[channel]->userDmaCallback();
+		}
+	}
+}
+
+// dma transfer function for spi with pole for completion
+void SPIClass::transfer(const void* txbuf, void* rxbuf, uint32_t count, bool block)
+{
+	// start the dma transfer, but do not specify a user callback function, will pole for completion instead
+	transfer(txbuf, rxbuf, count, NULL);
+
+	// if this function should automatically wait for completion, otherwise user must do manually
+	if(block)
+	{
+		waitForTransfer();
 	}
 }
 
+// Waits for a prior in-background DMA transfer to complete.
+void SPIClass::waitForTransfer(void)
+{
+    while( !dma_read_done || !dma_write_done )
+    {
+    	// do nothing, wait for transfer completion
+    }
+}
+
 // dma transfer function for spi
 // this function does not block, and dma will transfer in the background
 // the callback parameter should be passed in by the user, it is called when the dma is done
-void SPIClass::transfer(void* txbuf, void* rxbuf, size_t count, void (*functionToCallWhenComplete)(void) )
+void SPIClass::transfer(void* txbuf, void* rxbuf, uint32_t count, void (*functionToCallWhenComplete)(void) )
 {
 	// save this function to call when the dma is done
 	userDmaCallback = functionToCallWhenComplete;

libraries/SPI/SPI.h

@@ -118,7 +118,9 @@ class SPIClass {
   uint16_t transfer16(uint16_t data);
   void transfer(void *buf, size_t count);
   void transfer(void* txbuf, void* rxbuf, size_t count); //non dma
-  void transfer(void* txbuf, void* rxbuf, size_t count, void (*functionToCallWhenComplete)(void) ); //dma
+  void transfer(const void* txbuf, void* rxbuf, uint32_t count, bool block = true); //dma pole for completion
+  void waitForTransfer(void); //dma pole for completion
+  void transfer(void* txbuf, void* rxbuf, uint32_t count, void (*functionToCallWhenComplete)(void) ); //dma asynchronous
 
   // Transaction Functions
   void usingInterrupt(int interruptNumber);
@@ -175,9 +177,11 @@ class SPIClass {
   DmacDescriptor  *writeDescriptor = NULL;
   volatile bool    dma_write_done 	 = false;
   volatile bool    dma_read_done  	 = false;
+  size_t 		   dma_bytes_remaining;
   static void      dmaCallback_read(Adafruit_ZeroDMA *dma);
   static void      dmaCallback_write(Adafruit_ZeroDMA *dma);
-  void (*userDmaCallback)(void) = NULL; //function pointer to users dma callback function						 
+  void (*userDmaCallback)(void) = NULL; //function pointer to users dma callback function
+
 };
 
 #if SPI_INTERFACES_COUNT > 0

libraries/SPI/examples/zerodma_spi1/zerodma_spi1.ino

@@ -104,8 +104,9 @@ void loop()
 	// send the command byte
 	//SPI.transfer(255);
 
-	#if(1)
-		// dma transfer
+	#define DMA_TEST 3 //select the type of dma to test
+	#if(DMA_TEST == 1)
+		// asyncronous dma transfer
 		// reset the transaction flag
 		dmaDone = false;
 
@@ -120,9 +121,25 @@ void loop()
 		// wait here until transfer is completed
 		while(!dmaDone); // this is updated by our callback function
 
-	#else
+	#elif(DMA_TEST == 2)
+		// dma transfer pole for completion
+		// calls the dma transfer, this call will block
+		SPI.transfer(send_memory, receive_memory, DATA_LENGTH, true); //dma
+
+	#elif(DMA_TEST == 3)
+		// dma transfer pole for completion
+		// calls the dma transfer, this call will not block
+		SPI.transfer(send_memory, receive_memory, DATA_LENGTH, false); //dma
+
+		// can do other things here...
+
+		// wait here until transfer is completed
+		SPI.waitForTransfer();
+
+	#elif(DMA_TEST == 4)
 		//non dma transfer
 		SPI.transfer(send_memory, receive_memory, DATA_LENGTH);
+
 	#endif
 
 	// disable Slave Select