MB85RS64V.cpp

/*
 * MB85RS64V.cpp
 *
 * STM32 HAL driver for the Fujitsu (RAMXEED) MB85RS64V SPI FRAM.
 * See MB85RS64V.hpp for the class documentation.
 *
 *  Created on: Oct 3, 2026
 *      Author: johng
 */
 
#include "MB85RS64V.hpp"
 
MB85RS64V::MB85RS64V(SPI_HandleTypeDef *hspi, GPIO_TypeDef *csPort, uint16_t csPin, uint32_t timeoutMs,
        uint8_t maxAttempts)
    : _spi(hspi), _csPort(csPort), _csPin(csPin), _timeoutMs(timeoutMs),
      _maxAttempts(maxAttempts == 0 ? 1 : maxAttempts) {
}
 
void MB85RS64V::csLow() {
    HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_RESET);
}
 
void MB85RS64V::csHigh() {
    HAL_GPIO_WritePin(_csPort, _csPin, GPIO_PIN_SET);
}
 
bool MB85RS64V::spiConfigOk() const {
    const SPI_InitTypeDef &i = _spi->Init;
    const bool mode0 = (i.CLKPolarity == SPI_POLARITY_LOW)  && (i.CLKPhase == SPI_PHASE_1EDGE);
    const bool mode3 = (i.CLKPolarity == SPI_POLARITY_HIGH) && (i.CLKPhase == SPI_PHASE_2EDGE);
    return i.Mode == SPI_MODE_MASTER && i.Direction == SPI_DIRECTION_2LINES
            && i.DataSize == SPI_DATASIZE_8BIT && i.FirstBit == SPI_FIRSTBIT_MSB
            && i.NSS == SPI_NSS_SOFT && (mode0 || mode3);
}
 
bool MB85RS64V::isTransient(HAL_StatusTypeDef status) const {
    if (status == HAL_BUSY || status == HAL_TIMEOUT) {
        return true;
    }
    if (status != HAL_ERROR) {
        return false;
    }
    // HAL_ERROR is also returned for a bad parameter or state, which a retry cannot fix; only the
    // SPI error codes that describe a problem during the transfer itself count as transient.
    uint32_t transfer = 0;
#ifdef HAL_SPI_ERROR_MODF
    transfer |= HAL_SPI_ERROR_MODF;
#endif
#ifdef HAL_SPI_ERROR_CRC
    transfer |= HAL_SPI_ERROR_CRC;
#endif
#ifdef HAL_SPI_ERROR_OVR
    transfer |= HAL_SPI_ERROR_OVR;
#endif
#ifdef HAL_SPI_ERROR_FRE
    transfer |= HAL_SPI_ERROR_FRE;
#endif
#ifdef HAL_SPI_ERROR_DMA
    transfer |= HAL_SPI_ERROR_DMA;
#endif
#ifdef HAL_SPI_ERROR_FLAG
    transfer |= HAL_SPI_ERROR_FLAG;
#endif
    return (HAL_SPI_GetError(_spi) & transfer) != 0;
}
 
bool MB85RS64V::transmit(const uint8_t *data, uint16_t length) {
    // HAL takes a non-const pointer for historical reasons but does not modify a transmit buffer.
    _lastStatus = HAL_SPI_Transmit(_spi, const_cast<uint8_t *>(data), length, _timeoutMs);
    _lastRetryable = (_lastStatus != HAL_OK) && isTransient(_lastStatus);
    return _lastStatus == HAL_OK;
}
 
bool MB85RS64V::receive(uint8_t *data, uint16_t length) {
    _lastStatus = HAL_SPI_Receive(_spi, data, length, _timeoutMs);
    _lastRetryable = (_lastStatus != HAL_OK) && isTransient(_lastStatus);
    return _lastStatus == HAL_OK;
}
 
bool MB85RS64V::sendCommand(uint8_t opcode) {
    return run([&]() {
        csLow();
        const bool ok = transmit(&opcode, 1);
        csHigh();
        return ok;
    });
}
 
bool MB85RS64V::begin() {
    csHigh();
    if (!spiConfigOk()) {
        return false;
    }
    uint8_t id[ID_LENGTH];
    if (!readId(id)) {
        return false;
    }
    if (id[0] != 0x04 || id[1] != 0x7F || id[2] != 0x03 || id[3] != 0x02) {
        return false;
    }
    return writeDisable();
}
 
bool MB85RS64V::readId(uint8_t *id) {
    if (id == nullptr) {
        return false;
    }
    const uint8_t op = OP_RDID;
    return run([&]() {
        csLow();
        const bool ok = transmit(&op, 1) && receive(id, ID_LENGTH);
        csHigh();
        return ok;
    });
}
 
bool MB85RS64V::read(uint16_t address, uint8_t *buffer, size_t length) {
    if (buffer == nullptr || length == 0 || address >= SIZE_BYTES || length > static_cast<size_t>(SIZE_BYTES - address)) {
        return false;
    }
    const uint8_t header[3] = { OP_READ, static_cast<uint8_t>(address >> 8), static_cast<uint8_t>(address & 0xFF) };
    return run([&]() {
        csLow();
        const bool ok = transmit(header, sizeof(header)) && receive(buffer, static_cast<uint16_t>(length));
        csHigh();
        return ok;
    });
}
 
bool MB85RS64V::write(uint16_t address, const uint8_t *data, size_t length) {
    if (data == nullptr || length == 0 || address >= SIZE_BYTES || length > static_cast<size_t>(SIZE_BYTES - address)) {
        return false;
    }
    const uint8_t header[3] = { OP_WRITE, static_cast<uint8_t>(address >> 8), static_cast<uint8_t>(address & 0xFF) };
    // Write enable and write are retried together: the enable latch clears after a write ends
    return run([&]() {
        uint8_t wren = OP_WREN;
        csLow();
        bool ok = transmit(&wren, 1);
        csHigh();
        if (!ok) {
            return false;
        }
        csLow();
        ok = transmit(header, sizeof(header)) && transmit(data, static_cast<uint16_t>(length));
        csHigh();
        return ok;
    });
}
 
bool MB85RS64V::writeEnable() {
    return sendCommand(OP_WREN);
}
 
bool MB85RS64V::writeDisable() {
    return sendCommand(OP_WRDI);
}
 
bool MB85RS64V::readStatus(uint8_t *status) {
    if (status == nullptr) {
        return false;
    }
    const uint8_t op = OP_RDSR;
    return run([&]() {
        csLow();
        const bool ok = transmit(&op, 1) && receive(status, 1);
        csHigh();
        return ok;
    });
}
 
bool MB85RS64V::writeStatus(uint8_t status) {
    const uint8_t frame[2] = { OP_WRSR, status };
    return run([&]() {
        uint8_t wren = OP_WREN;
        csLow();
        bool ok = transmit(&wren, 1);
        csHigh();
        if (!ok) {
            return false;
        }
        csLow();
        ok = transmit(frame, sizeof(frame));
        csHigh();
        return ok;
    });
}
 
bool MB85RS64V::setBlockProtect(BlockProtect area) {
    uint8_t status;
    if (!readStatus(&status)) {
        return false;
    }
    status = static_cast<uint8_t>((status & ~(STATUS_BP1 | STATUS_BP0)) | static_cast<uint8_t>(area));
    return writeStatus(status);
}