* commented out non dma function for now. Its function signature conflicts with dma transfer with optional boolean for blocking. I dont know of a instance where the non dma is a requirement or better, so it is commented out for now.

* initialized variables so to avoid constructor error message in sloeber
* changed void pointer math to have a explicit type cast to uint8_t, void pointer math was generating compiler error and we know we are doing byte math.
* added explicit typecast of null function pointer, this prevents ambiguity on what function signature we are calling and prevents compiler warnings in sloeber

Author: BriscoeTech

libraries/SPI/SPI.cpp

@@ -235,6 +235,7 @@ void SPIClass::transfer(void *buf, size_t count)
   }
 }
 
+/*
 // Non-DMA transfer function.
 // this was removed from the dma function and made its own
 void SPIClass::transfer(void* txbuf, void* rxbuf, size_t count)
@@ -260,6 +261,7 @@ 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
@@ -309,8 +311,9 @@ void SPIClass::checkDmaComplete(uint8_t channel)
 			// initiate another transfer for the next section of bytes
 			// update buffer pointers offsets
 			// use the same user callback as last time if any
-			void* txbuf = spiPtr[channel]->txbuf_last + DMA_MAX_TRANSFER_SIZE;
-			void* rxbuf = spiPtr[channel]->rxbuf_last + DMA_MAX_TRANSFER_SIZE;
+			// (uint8_t*) typecast needed as c does not like pointer math of void*, but we know we are doing byte math
+			void* txbuf = (uint8_t*)spiPtr[channel]->txbuf_last + DMA_MAX_TRANSFER_SIZE;
+			void* rxbuf = (uint8_t*)spiPtr[channel]->rxbuf_last + DMA_MAX_TRANSFER_SIZE;
 			spiPtr[channel]->transfer(txbuf, rxbuf, spiPtr[channel]->dma_bytes_remaining, spiPtr[channel]->userDmaCallback );
 		}
 		// the transfer is completed, no bytes remaining
@@ -331,10 +334,10 @@ void SPIClass::checkDmaComplete(uint8_t channel)
 }
 
 // dma transfer function for spi with poll for completion
-void SPIClass::transfer(const void* txbuf, void* rxbuf, uint32_t count, bool block)
+void SPIClass::transfer(void* txbuf, void* rxbuf, uint32_t count, bool block)
 {
 	// start the dma transfer, but do not specify a user callback function, will poll for completion instead
-	transfer(txbuf, rxbuf, count, NULL);
+	transfer(txbuf, rxbuf, count, (void (*)(void))NULL );
 
 	// if this function should automatically wait for completion, otherwise user must do manually
 	if(block)

libraries/SPI/SPI.h

@@ -117,8 +117,8 @@ class SPIClass {
   byte transfer(uint8_t data);
   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(const void* txbuf, void* rxbuf, uint32_t count, bool block = true); //dma poll for completion
+  //void transfer(void* txbuf, void* rxbuf, size_t count); //non dma
+  void transfer(void* txbuf, void* rxbuf, uint32_t count, bool block); //dma poll for completion
   void waitForTransfer(void); //dma poll for completion
   void transfer(void* txbuf, void* rxbuf, uint32_t count, void (*functionToCallWhenComplete)(void) ); //dma asynchronous
 
@@ -180,12 +180,12 @@ class SPIClass {
   DmacDescriptor  *readDescriptor  = NULL;
   DmacDescriptor  *writeDescriptor = NULL;
 
-  volatile bool    dma_write_done 	 = false;		// true when read dma callback completes
-  volatile bool    dma_read_done  	 = false;		// true when write dma callback completes
-  uint32_t 		   dma_bytes_remaining;				// number of bytes remaining for future dma transactions
-  volatile bool    dma_complete  	 = false;		// all transactions completed and no bytes remaining
-  void* 		   txbuf_last;						// pointer to buffer last used
-  void* 		   rxbuf_last;						// pointer to buffer last used
+  volatile bool    dma_write_done 	 	= false;		// true when read dma callback completes
+  volatile bool    dma_read_done  	 	= false;		// true when write dma callback completes
+  uint32_t 		   dma_bytes_remaining 	= 0;			// number of bytes remaining for future dma transactions
+  volatile bool    dma_complete  	 	= false;		// all transactions completed and no bytes remaining
+  void* 		   txbuf_last			= NULL;			// pointer to buffer last used
+  void* 		   rxbuf_last			= NULL;			// pointer to buffer last used
 
   static void      dmaCallback_read(Adafruit_ZeroDMA *dma);
   static void      dmaCallback_write(Adafruit_ZeroDMA *dma);

libraries/SPI/examples/zerodma_spi1/zerodma_spi1.ino

@@ -104,14 +104,14 @@ void loop()
 	// send the command byte
 	//SPI.transfer(255);
 
-	#define DMA_TEST 3 //select the type of dma to test
+	#define DMA_TEST 1 //select the type of dma to test
 	#if(DMA_TEST == 1)
 		// asyncronous dma transfer
 		// reset the transaction flag
 		dmaDone = false;
 
 		// calls the dma transfer, this call does not block
-		// will call the callback frunction when the dma is completed
+		// will call the callback function when the dma is completed
 		SPI.transfer(send_memory, receive_memory, DATA_LENGTH, callback_dmaDone); //dma
 
 		// can do other things here...