strix/arduino/libraries/Arduino_SpiNINA/src/spi_drv.cpp

/*
  This file is part of the Arduino_SpiNINA library.

  Copyright (C) Arduino s.r.l. and/or its affiliated companies

  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

#include "Arduino.h"
#include <SPI.h>
#include "spi_drv.h"
#include "pins_arduino.h"

#ifdef ARDUINO_SAMD_MKRVIDOR4000
// STRIX: the STRIX FPGA image passes the NINA module's pins through to SAMD21 pins, so the
// module is driven directly (SPI on D8-D10) instead of through Arduino's FPGA peripherals.
// GPIO0 is bidirectional through the FPGA; the firmware switches its direction around begin().
#define NINA_GPIO0 6
#define SPIWIFI_SS 5
#define SPIWIFI_ACK 4
#define SPIWIFI_RESET 7
#endif

// #define _DEBUG_
#include "utility/debug.h"

static uint8_t SLAVESELECT = 10;  // ss
static uint8_t SLAVEREADY = 7;    // handshake pin
static uint8_t SLAVERESET = 5;    // reset pin

static bool inverted_reset = false;

#define DELAY_TRANSFER()

#ifndef SPIWIFI
#define SPIWIFI SPI
#endif

#ifndef NINA_GPIOIRQ
#define NINA_GPIOIRQ NINA_GPIO0
#endif

bool SpiDrv::initialized = false;

void SpiDrv::begin(bool force) {
  if (initialized && !force) {
    return;
  }


#ifdef SPIWIFI_SS
  SLAVESELECT = SPIWIFI_SS;
#endif

#ifdef SPIWIFI_ACK
  SLAVEREADY = SPIWIFI_ACK;
#endif

#ifdef SPIWIFI_RESET
  SLAVERESET = (uint8_t)SPIWIFI_RESET;
#endif

#ifdef ARDUINO_SAMD_MKRVIDOR4000
  inverted_reset = false;
#else
  if (SLAVERESET > PINS_COUNT) {
    inverted_reset = true;
    SLAVERESET = ~SLAVERESET;
  }
#endif

  pinMode(SLAVESELECT, OUTPUT);
  pinMode(SLAVEREADY, INPUT);
  pinMode(SLAVERESET, OUTPUT);
  pinMode(NINA_GPIO0, OUTPUT);

  digitalWrite(NINA_GPIO0, HIGH);
  digitalWrite(SLAVESELECT, HIGH);
  digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
  delay(10);
  digitalWrite(SLAVERESET, inverted_reset ? LOW : HIGH);
  delay(750);

  digitalWrite(NINA_GPIO0, LOW);
  pinMode(NINA_GPIOIRQ, INPUT);

  SPIWIFI.begin();

#ifdef _DEBUG_
  INIT_TRIGGER()
#endif

  initialized = true;
}

void SpiDrv::end() {
  digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);

  pinMode(SLAVESELECT, INPUT);

  SPIWIFI.end();

  initialized = false;
}

void SpiDrv::spiSlaveSelect() {
  SPIWIFI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  digitalWrite(SLAVESELECT, LOW);

  // wait for up to 5 ms for the NINA to indicate it is not ready for transfer
  // the timeout is only needed for the case when the shield or module is not present
  for (unsigned long start = millis(); (digitalRead(SLAVEREADY) != HIGH) && (millis() - start) < 5;);
}


void SpiDrv::spiSlaveDeselect() {
  digitalWrite(SLAVESELECT, HIGH);
  SPIWIFI.endTransaction();
}


char SpiDrv::spiTransfer(volatile char data) {
  char result = SPIWIFI.transfer(data);
  DELAY_TRANSFER();

  return result;  // return the received byte
}

int SpiDrv::waitSpiChar(unsigned char waitChar) {
  int timeout = TIMEOUT_CHAR;
  unsigned char _readChar = 0;
  do {
    _readChar = readChar();  //get data byte
    if (_readChar == ERR_CMD) {
      WARN("Err cmd received\n");
      return -1;
    }
  } while ((timeout-- > 0) && (_readChar != waitChar));
  return (_readChar == waitChar);
}

int SpiDrv::readAndCheckChar(char checkChar, char* readChar) {
  getParam((uint8_t*)readChar);

  return (*readChar == checkChar);
}

char SpiDrv::readChar() {
  uint8_t readChar = 0;
  getParam(&readChar);
  return readChar;
}

#define WAIT_START_CMD(x) waitSpiChar(START_CMD)

#define IF_CHECK_START_CMD(x) \
  if (!WAIT_START_CMD(_data)) { \
    TOGGLE_TRIGGER() \
    WARN("Error waiting START_CMD"); \
    return 0; \
  } else

#define CHECK_DATA(check, x) \
  if (!readAndCheckChar(check, &x)) { \
    TOGGLE_TRIGGER() \
    WARN("Reply error"); \
    INFO2(check, (uint8_t)x); \
    return 0; \
  } else

#define waitSlaveReady() (digitalRead(SLAVEREADY) == LOW)
#define waitSlaveSign() (digitalRead(SLAVEREADY) == HIGH)
#define waitSlaveSignalH() \
  while (digitalRead(SLAVEREADY) != HIGH) {}
#define waitSlaveSignalL() \
  while (digitalRead(SLAVEREADY) != LOW) {}

void SpiDrv::waitForSlaveSign() {
  while (!waitSlaveSign());
}

void SpiDrv::waitForSlaveReady(bool const feed_watchdog) {
  unsigned long const start = millis();
  while (!waitSlaveReady()) {
    if (feed_watchdog) {
      if ((millis() - start) < 10000) {
        //TODO: Feed watchdog in a proper way
        //WiFi.feedWatchdog();
      }
    }
  }
}

void SpiDrv::getParam(uint8_t* param) {
  // Get Params data
  *param = spiTransfer(DUMMY_DATA);
  DELAY_TRANSFER();
}

int SpiDrv::waitResponseCmd(uint8_t cmd, uint8_t numParam, uint8_t* param, uint8_t* param_len) {
  char _data = 0;
  int ii = 0;

  IF_CHECK_START_CMD(_data) {
    CHECK_DATA(cmd | REPLY_FLAG, _data){};

    CHECK_DATA(numParam, _data) {
      readParamLen8(param_len);
      for (ii = 0; ii < (*param_len); ++ii) {
        // Get Params data
        //param[ii] = spiTransfer(DUMMY_DATA);
        getParam(&param[ii]);
      }
    }

    readAndCheckChar(END_CMD, &_data);
  }

  return 1;
}

int SpiDrv::waitResponseData16(uint8_t cmd, uint8_t* param, uint16_t* param_len) {
  char _data = 0;
  uint16_t ii = 0;

  IF_CHECK_START_CMD(_data) {
    CHECK_DATA(cmd | REPLY_FLAG, _data){};

    uint8_t numParam = readChar();
    if (numParam != 0) {
      readParamLen16(param_len);
      for (ii = 0; ii < (*param_len); ++ii) {
        // Get Params data
        param[ii] = spiTransfer(DUMMY_DATA);
      }
    }

    readAndCheckChar(END_CMD, &_data);
  }

  return 1;
}

int SpiDrv::waitResponseData8(uint8_t cmd, uint8_t* param, uint8_t* param_len) {
  char _data = 0;
  int ii = 0;

  IF_CHECK_START_CMD(_data) {
    CHECK_DATA(cmd | REPLY_FLAG, _data){};

    uint8_t numParam = readChar();
    if (numParam != 0) {
      readParamLen8(param_len);
      for (ii = 0; ii < (*param_len); ++ii) {
        // Get Params data
        param[ii] = spiTransfer(DUMMY_DATA);
      }
    }

    readAndCheckChar(END_CMD, &_data);
  }

  return 1;
}

int SpiDrv::waitResponseParams(uint8_t cmd, uint8_t numParam, tParam* params) {
  char _data = 0;
  int i = 0, ii = 0;


  IF_CHECK_START_CMD(_data) {
    CHECK_DATA(cmd | REPLY_FLAG, _data){};

    uint8_t _numParam = readChar();
    if (_numParam != 0) {
      for (i = 0; i < _numParam; ++i) {
        params[i].paramLen = readParamLen8();
        for (ii = 0; ii < params[i].paramLen; ++ii) {
          // Get Params data
          params[i].param[ii] = spiTransfer(DUMMY_DATA);
        }
      }
    } else {
      WARN("Error numParam == 0");
      return 0;
    }

    if (numParam != _numParam) {
      WARN("Mismatch numParam");
      return 0;
    }

    readAndCheckChar(END_CMD, &_data);
  }
  return 1;
}

#define SPI_RESPONSE_MAX_LENGTH 32
#define SPI_MAX_RESPONSE_NUMBER 10

int SpiDrv::waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams) {
  char _data = 0;
  int i = 0, ii = 0;

  char* index[SPI_RESPONSE_MAX_LENGTH];

  for (i = 0; i < SPI_MAX_RESPONSE_NUMBER; i++)
    index[i] = (char*)params + SPI_RESPONSE_MAX_LENGTH * i;

  IF_CHECK_START_CMD(_data) {
    CHECK_DATA(cmd | REPLY_FLAG, _data){};

    uint8_t numParam = readChar();

    if (numParam > maxNumParams) {
      numParam = maxNumParams;
    }
    *numParamRead = numParam;
    if (numParam != 0) {
      for (i = 0; i < numParam; ++i) {
        uint8_t paramLen = readParamLen8();
        for (ii = 0; ii < paramLen; ++ii) {
          //ssid[ii] = spiTransfer(DUMMY_DATA);
          // Get Params data
          index[i][ii] = (uint8_t)spiTransfer(DUMMY_DATA);
        }
        index[i][ii] = 0;
      }
    } else {
      WARN("Error numParams == 0");
      readAndCheckChar(END_CMD, &_data);
      return 0;
    }
    readAndCheckChar(END_CMD, &_data);
  }
  return 1;
}

void SpiDrv::sendParamNoLen(const uint8_t* param, size_t param_len, uint8_t lastParam) {
  size_t i = 0;
  // Send SPI paramLen
  sendParamLen8(0);

  // Send SPI param data
  for (i = 0; i < param_len; ++i) {
    spiTransfer(param[i]);
  }

  // if lastParam==1 Send SPI END CMD
  if (lastParam == 1)
    spiTransfer(END_CMD);
}

void SpiDrv::sendParam(const uint8_t* param, uint8_t param_len, uint8_t lastParam) {
  int i = 0;
  // Send SPI paramLen
  sendParamLen8(param_len);

  // Send SPI param data
  for (i = 0; i < param_len; ++i) {
    spiTransfer(param[i]);
  }

  // if lastParam==1 Send SPI END CMD
  if (lastParam == 1)
    spiTransfer(END_CMD);
}

void SpiDrv::sendParamLen8(uint8_t param_len) {
  // Send SPI paramLen
  spiTransfer(param_len);
}

void SpiDrv::sendParamLen16(uint16_t param_len) {
  // Send SPI paramLen
  spiTransfer((uint8_t)((param_len & 0xff00) >> 8));
  spiTransfer((uint8_t)(param_len & 0xff));
}

uint8_t SpiDrv::readParamLen8(uint8_t* param_len) {
  uint8_t _param_len = spiTransfer(DUMMY_DATA);
  if (param_len != NULL) {
    *param_len = _param_len;
  }
  return _param_len;
}

uint16_t SpiDrv::readParamLen16(uint16_t* param_len) {
  uint16_t _param_len = spiTransfer(DUMMY_DATA) << 8 | (spiTransfer(DUMMY_DATA) & 0xff);
  if (param_len != NULL) {
    *param_len = _param_len;
  }
  return _param_len;
}


void SpiDrv::sendBuffer(const uint8_t* param, uint16_t param_len, uint8_t lastParam) {
  uint16_t i = 0;

  // Send SPI paramLen
  sendParamLen16(param_len);

  // Send SPI param data
  for (i = 0; i < param_len; ++i) {
    spiTransfer(param[i]);
  }

  // if lastParam==1 Send SPI END CMD
  if (lastParam == 1)
    spiTransfer(END_CMD);
}


void SpiDrv::sendParam(uint16_t param, uint8_t lastParam) {
  // Send SPI paramLen
  sendParamLen8(2);

  spiTransfer((uint8_t)((param & 0xff00) >> 8));
  spiTransfer((uint8_t)(param & 0xff));

  // if lastParam==1 Send SPI END CMD
  if (lastParam == 1)
    spiTransfer(END_CMD);
}

/* Cmd Struct Message */
/* _________________________________________________________________________________  */
/*| START CMD | C/R  | CMD  |[TOT LEN]| N.PARAM | PARAM LEN | PARAM  | .. | END CMD | */
/*|___________|______|______|_________|_________|___________|________|____|_________| */
/*|   8 bit   | 1bit | 7bit |  8bit   |  8bit   |   8bit    | nbytes | .. |   8bit  | */
/*|___________|______|______|_________|_________|___________|________|____|_________| */

void SpiDrv::sendCmd(uint8_t cmd, uint8_t numParam) {
  // Send SPI START CMD
  spiTransfer(START_CMD);

  // Send SPI C + cmd
  spiTransfer(cmd & ~(REPLY_FLAG));

  // Send SPI totLen
  //spiTransfer(totLen);

  // Send SPI numParam
  spiTransfer(numParam);

  // If numParam == 0 send END CMD
  if (numParam == 0)
    spiTransfer(END_CMD);
}

int SpiDrv::available() {
  return (digitalRead(NINA_GPIOIRQ) != LOW);
}

SpiDrv spiDrv;