Add capabilities to redefine QSPI pins

Signed-off-by: Frederic Pillon <frederic.pillon@st.com>

Author: fpistm

README.md

@@ -1,32 +1,69 @@
 # MX25R6435F
-Arduino library to support the Quad-SPI NOR Flash memory MX25R6435F
+Arduino library to support the Quad-SPI NOR Flash memory MX25R6435F using the Quad SPI flash memories interface. Since library version 2.0.0 and [STM32 core](https://github.com/stm32duino/Arduino_Core_STM32) version 2.0.0 the OctoSPI Flash memories interface can also be used.
 
 ## API
 
 The library provides the following API:
 
-* begin()
-* end()
-* write()
-* read()
-* mapped()
-* erase()
-* eraseChip()
-* eraseSector()
-* suspendErase()
-* resumeErase()
-* sleep()
-* wakeup()
-* status()
-* info()
-* length()
+* `begin()`
+* `end()`
+* `write()`
+* `read()`
+* `mapped()`
+* `erase()`
+* `eraseChip()`
+* `eraseSector()`
+* `suspendErase()`
+* `resumeErase()`
+* `sleep()`
+* `wakeup()`
+* `status()`
+* `info()`
+* `length()`
+
+Since library version 2.0.0, xSPI pins can be defined at sketch level, using:
+
+* To redefine the default one before call of `begin()`:
+
+  * `setDx(uint32_t data0, uint32_t data1, uint32_t data2, uint32_t data3)`
+  * `setDx(PinName data0, PinName data1, PinName data2, PinName data3)`
+  * `setSSEL(uint32_t ssel)`
+  * `setSSEL(PinName ssel)`
+  * `setSCLK(uint32_t sclk)`
+  * `setSCLK(PinName sclk)`
+
+  *Code snippet:*
+```C++
+  MX25R6435F.setDx(PE12, PE13, PE14, PE15); // using pin number
+  MX25R6435F.setSCLK(PE10);
+  MX25R6435F.setSSEL(PE_11); // using PinName
+  MX25R6435F.begin();
+```
+
+* or using the `begin()` method:
+
+  * `MX25R6435FClass(uint8_t data0, uint8_t data1, uint8_t data2, uint8_t data3, uint8_t clk, uint8_t ssel)`
+
+  *Code snippet:*
+```C++
+  MX25R6435F.begin(PE12, PE13, PE14, PE15, PE10, PE11);
+```
+
+* or by redefining the default pins definition (using [build_opt.h](https://github.com/stm32duino/wiki/wiki/Customize-build-options-using-build_opt.h) or [hal_conf_extra.h](https://github.com/stm32duino/wiki/wiki/HAL-configuration#customize-hal-or-variant-definition)):
+
+  * `MX25R6435F_D0`
+  * `MX25R6435F_D1`
+  * `MX25R6435F_D2`
+  * `MX25R6435F_D3`
+  * `MX25R6435F_SCLK`
+  * `MX25R6435F_SSEL`
 
 ## Examples
 
-3 sketches provide basic examples to show how to use the library API.  
-demo.ino uses basic read/write functions.  
-eraseChip.ino erases all data present in the memory.  
-memoryMappedMode.ino shows how to use the mapped mode.  
+3 sketches provide basic examples to show how to use the library API:
+* `demo.ino` uses basic read/write functions.
+* `eraseChip.ino` erases all data present in the memory.
+* `memoryMappedMode.ino` shows how to use the mapped mode.
 
 ## Documentation
 

keywords.txt

@@ -26,6 +26,9 @@ wakeup	KEYWORD2
 status	KEYWORD2
 info	KEYWORD2
 length	KEYWORD2
+setDx KEYWORD2
+setSCLK KEYWORD2
+setSSEL KEYWORD2
 
 #######################################
 # Constants (LITERAL1)

src/MX25R6435F.cpp

@@ -42,18 +42,24 @@ MX25R6435FClass MX25R6435F;
 
 MX25R6435FClass::MX25R6435FClass(): initDone(0)
 {
-
 }
 
-void MX25R6435FClass::begin(void)
+void MX25R6435FClass::begin(uint8_t data0, uint8_t data1, uint8_t data2, uint8_t data3, uint8_t sclk, uint8_t ssel)
 {
-  if(BSP_QSPI_Init() == MEMORY_OK)
+  _qspi.pin_d0 = digitalPinToPinName(data0);
+  _qspi.pin_d1 = digitalPinToPinName(data1);
+  _qspi.pin_d2 = digitalPinToPinName(data2);
+  _qspi.pin_d3 = digitalPinToPinName(data3);
+  _qspi.pin_sclk = digitalPinToPinName(sclk);
+  _qspi.pin_ssel = digitalPinToPinName(ssel);
+
+  if (BSP_QSPI_Init(&_qspi) == MEMORY_OK) {
     initDone = 1;
 }
 
 void MX25R6435FClass::end(void)
 {
-  BSP_QSPI_DeInit();
+  BSP_QSPI_DeInit(&_qspi);
   initDone = 0;
 }
 
@@ -67,7 +73,7 @@ uint32_t MX25R6435FClass::write(uint8_t *pData, uint32_t addr, uint32_t size)
   if((pData == NULL) || (initDone == 0))
     return 0;
 
-  if(BSP_QSPI_Write(pData, addr, size) != MEMORY_OK)
+  if(BSP_QSPI_Write(&_qspi, pData, addr, size) != MEMORY_OK)
     return 0;
 
   return size;
@@ -85,12 +91,12 @@ uint8_t MX25R6435FClass::read(uint32_t addr)
 void MX25R6435FClass::read(uint8_t *pData, uint32_t addr, uint32_t size)
 {
   if((pData != NULL) && (initDone == 1))
-    BSP_QSPI_Read(pData, addr, size);
+    BSP_QSPI_Read(&_qspi, pData, addr, size);
 }
 
 uint8_t *MX25R6435FClass::mapped(void)
 {
-  if(BSP_QSPI_EnableMemoryMappedMode() != MEMORY_OK)
+  if(BSP_QSPI_EnableMemoryMappedMode(&_qspi) != MEMORY_OK)
     return NULL;
 
   return (uint8_t *)MEMORY_MAPPED_ADDRESS;
@@ -101,60 +107,60 @@ uint8_t MX25R6435FClass::erase(uint32_t addr)
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_Erase_Block(addr);
+  return BSP_QSPI_Erase_Block(&_qspi, addr);
 }
 
 uint8_t MX25R6435FClass::eraseChip(void)
 {
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_Erase_Chip();
+  return BSP_QSPI_Erase_Chip(&_qspi);
 }
 
 uint8_t MX25R6435FClass::eraseSector(uint32_t sector)
 {
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_Erase_Sector(sector);
+  return BSP_QSPI_Erase_Sector(&_qspi, sector);
 }
 
 uint8_t MX25R6435FClass::suspendErase(void)
 {
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_SuspendErase();
+  return BSP_QSPI_SuspendErase(&_qspi);
 }
 
 uint8_t MX25R6435FClass::resumeErase(void)
 {
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_ResumeErase();
+  return BSP_QSPI_ResumeErase(&_qspi);
 }
 
 uint8_t MX25R6435FClass::sleep(void)
 {
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_EnterDeepPowerDown();
+  return BSP_QSPI_EnterDeepPowerDown(&_qspi);
 }
 
 uint8_t MX25R6435FClass::wakeup(void)
 {
   if(initDone == 0)
     return MEMORY_ERROR;
 
-  return BSP_QSPI_LeaveDeepPowerDown();
+  return BSP_QSPI_LeaveDeepPowerDown(&_qspi);
 }
 
 uint8_t MX25R6435FClass::status(void)
 {
-  return BSP_QSPI_GetStatus();
+  return BSP_QSPI_GetStatus(&_qspi);
 }
 
 uint32_t MX25R6435FClass::info(memory_info_t info)

src/MX25R6435F.h

@@ -39,8 +39,28 @@
 #ifndef _MX25R6435F_H_
 #define _MX25R6435F_H_
 
+#include "Arduino.h"
 #include "mx25r6435f_driver.h"
 
+#ifndef MX25R6435F_D0
+#define MX25R6435F_D0           NC
+#endif
+#ifndef MX25R6435F_D1
+#define MX25R6435F_D1           NC
+#endif
+#ifndef MX25R6435F_D2
+#define MX25R6435F_D2           NC
+#endif
+#ifndef MX25R6435F_D3
+#define MX25R6435F_D3           NC
+#endif
+#ifndef MX25R6435F_SCLK
+#define MX25R6435F_SCLK         NC
+#endif
+#ifndef MX25R6435F_SSEL
+#define MX25R6435F_SSEL         NC
+#endif
+
 /* Memory configuration paremeters */
 typedef enum {
   MEMORY_SIZE,
@@ -65,8 +85,41 @@ class MX25R6435FClass
   public:
     MX25R6435FClass();
 
+    // setDx/SCLK/SSEL have to be called before begin()
+    void setDx(uint32_t data0, uint32_t data1, uint32_t data2, uint32_t data3)
+    {
+      _qspi.pin_d0 = digitalPinToPinName(data0);
+      _qspi.pin_d1 = digitalPinToPinName(data1);
+      _qspi.pin_d2 = digitalPinToPinName(data2);
+      _qspi.pin_d3 = digitalPinToPinName(data3);
+    };
+    void setSCLK(uint32_t sclk)
+    {
+      _qspi.pin_sclk = digitalPinToPinName(sclk);
+    };
+    void setSSEL(uint32_t ssel)
+    {
+      _qspi.pin_ssel = digitalPinToPinName(ssel);
+    };
+
+    void setDx(PinName data0, PinName data1, PinName data2, PinName data3)
+    {
+      _qspi.pin_d0 = (data0);
+      _qspi.pin_d1 = (data1);
+      _qspi.pin_d2 = (data2);
+      _qspi.pin_d3 = (data3);
+    };
+    void setSCLK(PinName sclk)
+    {
+      _qspi.pin_sclk = (sclk);
+    };
+    void setSSEL(PinName ssel)
+    {
+      _qspi.pin_ssel = (ssel);
+    };
+
     /* Initializes the memory interface. */
-    void begin(void);
+    void begin(uint8_t data0 = MX25R6435F_D0, uint8_t data1 = MX25R6435F_D1, uint8_t data2 = MX25R6435F_D2, uint8_t data3 = MX25R6435F_D3, uint8_t sclk = MX25R6435F_SCLK, uint8_t ssel = MX25R6435F_SSEL);
 
     /* De-Initializes the memory interface. */
     void end(void);
@@ -174,6 +227,7 @@ class MX25R6435FClass
 
   private:
     uint8_t initDone;
+    QSPI_t _qspi;
 };
 
 extern MX25R6435FClass MX25R6435F;