Rework SPI to include async operation; reshuffle DMA assignments

Author: GrumpyOldPizza

libraries/SPI/keywords.txt

@@ -14,12 +14,17 @@ SPI	KEYWORD1
 
 begin			KEYWORD2
 end			KEYWORD2
+usingInterrupt		KEYWORD2
+notUsingInterrupt	KEYWORD2
+beginTransaction	KEYWORD2
+endTransaction		KEYWORD2
 transfer		KEYWORD2
 transfer16		KEYWORD2
-transfer32		KEYWORD2
 setBitOrder		KEYWORD2
 setDataMode		KEYWORD2
 setClockDivider		KEYWORD2
+cancel			KEYWORD2
+done			KEYWORD2
 
 
 #######################################

libraries/SPI/src/SPI.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2018 Thomas Roell.  All rights reserved.
+ * Copyright (c) 2016-2020 Thomas Roell.  All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
@@ -53,9 +53,8 @@ SPIClass::SPIClass(struct _stm32l0_spi_t *spi, const struct _stm32l0_spi_params_
     _clock = 4000000;
     _option = STM32L0_SPI_OPTION_MODE_0 | STM32L0_SPI_OPTION_MSB_FIRST;
 
-    _transferRoutine = SPIClass::_transferSelect;
+    _transfer8Routine = SPIClass::_transfer8Select;
     _transfer16Routine = SPIClass::_transfer16Select;
-    _transfer32Routine = SPIClass::_transfer32Select;
 
     _spi_class[spi->instance] = this;
 }
@@ -70,9 +69,8 @@ void SPIClass::end()
     if (_active) {
 	stm32l0_spi_release(_spi);
 
-	_transferRoutine = SPIClass::_transferSelect;
+	_transfer8Routine = SPIClass::_transfer8Select;
 	_transfer16Routine = SPIClass::_transfer16Select;
-	_transfer32Routine = SPIClass::_transfer32Select;
 
 	_active = false;
     }
@@ -108,18 +106,16 @@ void SPIClass::beginTransaction(SPISettings settings)
 
     _active = true;
 
-    _transferRoutine = stm32l0_spi_data;
+    _transfer8Routine = stm32l0_spi_data8;
     _transfer16Routine = stm32l0_spi_data16;
-    _transfer32Routine = stm32l0_spi_data32;
 }
 
 void SPIClass::endTransaction(void)
 {
     stm32l0_spi_release(_spi);
 
-    _transferRoutine = SPIClass::_transferSelect;
+    _transfer8Routine = SPIClass::_transfer8Select;
     _transfer16Routine = SPIClass::_transfer16Select;
-    _transfer32Routine = SPIClass::_transfer32Select;
 
     _active = false;
 }
@@ -129,9 +125,8 @@ void SPIClass::setBitOrder(BitOrder bitOrder)
     if (_active) {
 	stm32l0_spi_release(_spi);
 
-	_transferRoutine = SPIClass::_transferSelect;
+	_transfer8Routine = SPIClass::_transfer8Select;
 	_transfer16Routine = SPIClass::_transfer16Select;
-	_transfer32Routine = SPIClass::_transfer32Select;
 
 	_active = false;
     }
@@ -144,9 +139,8 @@ void SPIClass::setDataMode(uint8_t dataMode)
     if (_active) {
 	stm32l0_spi_release(_spi);
 
-	_transferRoutine = SPIClass::_transferSelect;
+	_transfer8Routine = SPIClass::_transfer8Select;
 	_transfer16Routine = SPIClass::_transfer16Select;
-	_transfer32Routine = SPIClass::_transfer32Select;
 
 	_active = false;
     }
@@ -159,9 +153,8 @@ void SPIClass::setClockDivider(uint8_t divider)
     if (_active) {
 	stm32l0_spi_release(_spi);
 
-	_transferRoutine = SPIClass::_transferSelect;
+	_transfer8Routine = SPIClass::_transfer8Select;
 	_transfer16Routine = SPIClass::_transfer16Select;
-	_transfer32Routine = SPIClass::_transfer32Select;
 
 	_active = false;
     }
@@ -171,21 +164,6 @@ void SPIClass::setClockDivider(uint8_t divider)
     }
 }
 
-void SPIClass::setHalfDuplex(bool enable)
-{
-    if (_active) {
-	stm32l0_spi_release(_spi);
-    
-	_transferRoutine = SPIClass::_transferSelect;
-	_transfer16Routine = SPIClass::_transfer16Select;
-	_transfer32Routine = SPIClass::_transfer32Select;
-    
-	_active = false;
-    }
-
-    _option = (_option & ~STM32L0_SPI_OPTION_HALFDUPLEX) | (enable ? STM32L0_SPI_OPTION_HALFDUPLEX : 0);
-}
-
 void SPIClass::attachInterrupt()
 {
   // Should be enableInterrupt()
@@ -196,19 +174,18 @@ void SPIClass::detachInterrupt()
   // Should be disableInterrupt()
 }
 
-uint8_t SPIClass::_transferSelect(struct _stm32l0_spi_t *spi, uint8_t data)
+uint8_t SPIClass::_transfer8Select(struct _stm32l0_spi_t *spi, uint8_t data)
 {
     SPIClass *spi_class = _spi_class[spi->instance];
 
     stm32l0_spi_acquire(spi, spi_class->_clock, spi_class->_option);
 
     spi_class->_active = true;
 
-    spi_class->_transferRoutine = stm32l0_spi_data;
+    spi_class->_transfer8Routine = stm32l0_spi_data8;
     spi_class->_transfer16Routine = stm32l0_spi_data16;
-    spi_class->_transfer32Routine = stm32l0_spi_data32;
 
-    return (*spi_class->_transferRoutine)(spi, data);
+    return (*spi_class->_transfer8Routine)(spi, data);
 }
 
 uint16_t SPIClass::_transfer16Select(struct _stm32l0_spi_t *spi, uint16_t data)
@@ -219,56 +196,85 @@ uint16_t SPIClass::_transfer16Select(struct _stm32l0_spi_t *spi, uint16_t data)
 
     spi_class->_active = true;
 
-    spi_class->_transferRoutine = stm32l0_spi_data;
+    spi_class->_transfer8Routine = stm32l0_spi_data8;
     spi_class->_transfer16Routine = stm32l0_spi_data16;
-    spi_class->_transfer32Routine = stm32l0_spi_data32;
 
     return (*spi_class->_transfer16Routine)(spi, data);
 }
 
-uint32_t SPIClass::_transfer32Select(struct _stm32l0_spi_t *spi, uint32_t data)
+void SPIClass::transfer(const void *txBuffer, void *rxBuffer, size_t count) 
 {
-    SPIClass *spi_class = _spi_class[spi->instance];
-
-    stm32l0_spi_acquire(spi, spi_class->_clock, spi_class->_option);
+    if (!_active)
+    {
+	stm32l0_spi_acquire(_spi, _clock, _option);
+	
+	_active = true;
+	
+	_transfer8Routine = stm32l0_spi_data8;
+	_transfer16Routine = stm32l0_spi_data16;
+    }
 
-    spi_class->_active = true;
+    stm32l0_spi_data(_spi, (const uint8_t*)txBuffer, (uint8_t*)rxBuffer, count);
+}
 
-    spi_class->_transferRoutine = stm32l0_spi_data;
-    spi_class->_transfer16Routine = stm32l0_spi_data16;
-    spi_class->_transfer32Routine = stm32l0_spi_data32;
-  
-    return (*spi_class->_transfer32Routine)(spi, data);
+bool SPIClass::transfer(const void *txBuffer, void *rxBuffer, size_t count, void(*callback)(void))
+{
+    return transfer(txBuffer, rxBuffer, count, Callback(callback));
 }
 
-void SPIClass::transfer(const void *txBuffer, void *rxBuffer, size_t count) 
+bool SPIClass::transfer(const void *txBuffer, void *rxBuffer, size_t count, Callback callback)
 {
+    if (!stm32l0_spi_done(_spi))
+    {
+	return false;
+    }
+
     if (!_active)
     {
 	stm32l0_spi_acquire(_spi, _clock, _option);
 
 	_active = true;
 
-	_transferRoutine = stm32l0_spi_data;
+	_transfer8Routine = stm32l0_spi_data8;
 	_transfer16Routine = stm32l0_spi_data16;
-	_transfer32Routine = stm32l0_spi_data32;
     }
 
-    if (txBuffer)
-    {
-	if (rxBuffer)
-	{
-	    stm32l0_spi_transfer(_spi, (const uint8_t*)txBuffer, (uint8_t*)rxBuffer, count);
-	}
-	else
-	{
-	    stm32l0_spi_transmit(_spi, (const uint8_t*)txBuffer, count);
+    _callback = callback;
+
+    if (txBuffer) {
+	if (rxBuffer) {
+	    if (!stm32l0_spi_transfer(_spi, static_cast<const uint8_t*>(txBuffer), static_cast<uint8_t*>(rxBuffer), count, (stm32l0_spi_done_callback_t)SPIClass::_doneCallback, (void*)this)) {
+		return false;
+	    }
+	} else {
+	    if (!stm32l0_spi_transmit(_spi, static_cast<const uint8_t*>(txBuffer), count, (stm32l0_spi_done_callback_t)SPIClass::_doneCallback, (void*)this)) {
+		return false;
+	    }
 	}
     }
     else
     {
-	stm32l0_spi_receive(_spi, (uint8_t*)rxBuffer, count);
+	if (!stm32l0_spi_receive(_spi, static_cast<uint8_t*>(rxBuffer), count, (stm32l0_spi_done_callback_t)SPIClass::_doneCallback, (void*)this)) {	
+	    return false;
+	}
     }
+
+    return true;
+}
+
+size_t SPIClass::cancel(void)
+{
+    return stm32l0_spi_cancel(_spi);
+}
+
+bool SPIClass::done(void)
+{
+    return stm32l0_spi_done(_spi);
+}
+
+void SPIClass::_doneCallback(class SPIClass *self)
+{
+    self->_callback.queue();;
 }
 
 #if SPI_INTERFACES_COUNT > 0

libraries/SPI/src/SPI.h

@@ -42,8 +42,8 @@
 class SPISettings {
 public:
   SPISettings() : _clock(4000000), _option(0) { }
-  SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, bool halfduplex = false) :
-    _clock(clock), _option((dataMode & (SPI_CR1_CPHA | SPI_CR1_CPOL)) | ((bitOrder != MSBFIRST) ? SPI_CR1_LSBFIRST : 0) | (halfduplex ? 0x80000000 : 0x00000000)) { }
+  SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) :
+  _clock(clock), _option((dataMode & (SPI_CR1_CPHA | SPI_CR1_CPOL)) | ((bitOrder != MSBFIRST) ? SPI_CR1_LSBFIRST : 0)) { }
 
 private:
   uint32_t _clock;
@@ -54,61 +54,61 @@ class SPISettings {
 
 class SPIClass {
 public:
-  SPIClass(struct _stm32l0_spi_t *spi, const struct _stm32l0_spi_params_t *params);
+    SPIClass(struct _stm32l0_spi_t *spi, const struct _stm32l0_spi_params_t *params);
 
-  inline uint8_t transfer(uint8_t data) { return _transfer(data); }
-  inline uint16_t transfer16(uint16_t data) { return _transfer16(data); }
-  inline void transfer(void *buffer, size_t count) { return transfer(buffer, buffer, count); }
+    inline uint8_t transfer(uint8_t data) { return _transfer8(data); }
+    inline uint16_t transfer16(uint16_t data) { return _transfer16(data); }
+    inline void transfer(void *buffer, size_t count) { return transfer(buffer, buffer, count); }
 
-  // Transaction Functions
-  void usingInterrupt(uint32_t pin);
-  void notUsingInterrupt(uint32_t pin);
-  void beginTransaction(SPISettings settings);
-  void endTransaction(void);
+    // Transaction Functions
+    void usingInterrupt(uint32_t pin);
+    void notUsingInterrupt(uint32_t pin);
+    void beginTransaction(SPISettings settings);
+    void endTransaction(void);
 
-  // SPI Configuration methods
-  void attachInterrupt();
-  void detachInterrupt();
+    // SPI Configuration methods
+    void attachInterrupt();
+    void detachInterrupt();
 
-  void begin();
-  void end();
+    void begin();
+    void end();
 
-  void setBitOrder(BitOrder bitOrder);
-  void setDataMode(uint8_t dataMode);
-  void setClockDivider(uint8_t divider);
-  void setHalfDuplex(bool enable);
-
-  // STM32L0 EXTENSION: transfer of a 32 bit chunk
-  inline uint32_t transfer32(uint32_t data) { return _transfer32(data); }
-
-  // STM32L0 EXTENSION: transfer with separate read/write buffer
-  void transfer(const void *txBuffer, void *rxBuffer, size_t count);
+    void setBitOrder(BitOrder bitOrder);
+    void setDataMode(uint8_t dataMode);
+    void setClockDivider(uint8_t divider);
 
+    // STM32L0 EXTENSION: transfer with separate read/write buffer
+    void transfer(const void *txBuffer, void *rxBuffer, size_t count);
+    
+    // STM32L0 EXTENSTION: asynchronous transfer with separate read/write buffer
+    bool transfer(const void *txBuffer, void *rxBuffer, size_t count, void(*callback)(void));
+    bool transfer(const void *txBuffer, void *rxBuffer, size_t count, Callback callback);
+    size_t cancel(void);
+    bool done(void);
+  
 private:
     struct _stm32l0_spi_t *_spi;
     bool _active;
     uint32_t _clock;
     uint32_t _option;
 
-    uint8_t (*_transferRoutine)(struct _stm32l0_spi_t*, uint8_t);
-    uint16_t (*_transfer16Routine)(struct _stm32l0_spi_t*, uint16_t);
-    uint32_t (*_transfer32Routine)(struct _stm32l0_spi_t*, uint32_t);
+    Callback _callback;
 
-    uint8_t _transfer(uint8_t data)  __attribute__((__always_inline__)) {
-	return (*_transferRoutine)(_spi, data);
+    uint8_t (*_transfer8Routine)(struct _stm32l0_spi_t*, uint8_t);
+    uint16_t (*_transfer16Routine)(struct _stm32l0_spi_t*, uint16_t);
+    
+    uint8_t _transfer8(uint8_t data)  __attribute__((__always_inline__)) {
+	return (*_transfer8Routine)(_spi, data);
     }
 
     uint16_t _transfer16(uint16_t data) __attribute__((__always_inline__)) {
 	return (*_transfer16Routine)(_spi, data);
     }
 
-    uint32_t _transfer32(uint32_t data) __attribute__((__always_inline__)) {
-	return (*_transfer32Routine)(_spi, data);
-    }
-    
-    static uint8_t _transferSelect(struct _stm32l0_spi_t *spi, uint8_t data);
+    static uint8_t _transfer8Select(struct _stm32l0_spi_t *spi, uint8_t data);
     static uint16_t _transfer16Select(struct _stm32l0_spi_t *spi, uint16_t data);
-    static uint32_t _transfer32Select(struct _stm32l0_spi_t *spi, uint32_t data);
+
+    static void _doneCallback(class SPIClass *self);
 };
 
 #if SPI_INTERFACES_COUNT > 0

libraries/Wire/src/Wire.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Thomas Roell.  All rights reserved.
+ * Copyright (c) 2016-2020 Thomas Roell.  All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
@@ -607,10 +607,10 @@ bool TwoWireTransaction::submit(class TwoWire &wire, uint8_t address, const uint
     _callback = callback;
 
     if (!stm32l0_i2c_submit(wire._i2c, &_transaction)) {
-        return 1;
+	return false;
     }
 
-    return 0;
+    return true;
 }
 
 bool TwoWireTransaction::done()