flash_at25.c

Go to the documentation of this file.

#include "flash_at25.h"
#include "main.h"
#include <string.h>
 
// Commands
#define CMD_READ_ID          0x9F
#define CMD_READ_DATA        0x03
#define CMD_FAST_READ        0x0B  // Fast read command for optimized reads
#define CMD_PAGE_PROG        0x02
#define CMD_WRITE_ENABLE     0x06
#define CMD_WRITE_DISABLE    0x04
#define CMD_READ_STATUS      0x05
#define CMD_PAGE_ERASE       0x81
 
// Status Register Bits
#define SR_WIP               0x01  // Write In Progress
#define SR_WEL               0x02  // Write Enable Latch
 
// Timeouts for wait operations (in iterations)
#define FLASH_TIMEOUT        10000
 
 
 
// internal buffer for erasing of page before write
static uint8_t _buffer256[256] = {};
 
static void flash_Select(const flash_at25CS_t *s)
{
    HAL_GPIO_WritePin(s->CSPort, s->CSPin, GPIO_PIN_RESET);
}
 
static void flash_Unselect(const flash_at25CS_t *s)
{
    HAL_GPIO_WritePin(s->CSPort, s->CSPin, GPIO_PIN_SET);
}
 
/**
 * @brief Helper function to wait for flash ready with timeout protection
 * Optimized for frequent operations with proper timeout and CS handling
 * @param s Pointer to flash configuration structure
 * @retval HAL_OK if ready, HAL_TIMEOUT if timeout, HAL_ERROR on communication error
 */
static HAL_StatusTypeDef flashNew_WaitReadyWithTimeout(const flash_at25CS_t *s)
{
    HAL_StatusTypeDef ret;
    uint32_t timeout = FLASH_TIMEOUT;
    uint8_t status;
 
    do
    {
        uint8_t cmd = CMD_READ_STATUS;
 
        flash_Select(s);
        if ((ret = HAL_SPI_Transmit(s->Spi, &cmd, 1, HAL_MAX_DELAY)) != HAL_OK)
            break;
        if ((ret = HAL_SPI_Receive(s->Spi, &status, 1, HAL_MAX_DELAY)) != HAL_OK)
            break;
        flash_Unselect(s);
    } while ((status & SR_WIP) && timeout--);   // repeat, until write is progress, Check WIP (Write In Progress) bit
    flash_Unselect(s);
    return ret;
}
 
/**
 * @brief Helper function to enable write with verification
 * Ensures write enable latch is properly set
 * @param s Pointer to flash configuration structure
 * @retval HAL_OK if write enabled, HAL_ERROR otherwise
 */
static HAL_StatusTypeDef flashNew_WriteEnableVerified(const flash_at25CS_t *s)
{
    HAL_StatusTypeDef ret = HAL_ERROR;
    uint8_t cmd = CMD_WRITE_ENABLE;
    uint8_t status;
 
    do
    {
        // Send write enable command
        flash_Select(s);
        if ((ret = HAL_SPI_Transmit(s->Spi, &cmd, 1, HAL_MAX_DELAY)) != HAL_OK)
            break;
        flash_Unselect(s);
 
        // Verify WEL bit is set in status register
        flash_Select(s);
        cmd = CMD_READ_STATUS;
        if ((ret = HAL_SPI_Transmit(s->Spi, &cmd, 1, HAL_MAX_DELAY)) != HAL_OK)
            break;
        if ((ret = HAL_SPI_Receive(s->Spi, &status, 1, HAL_MAX_DELAY)) != HAL_OK)
            break;
        flash_Unselect(s);
    } while (ret == HAL_OK && !(status & SR_WEL));
    flash_Unselect(s);
    return ret;
}
 
//////// public /////////////
HAL_StatusTypeDef flash_at25_Init(flash_at25CS_t *s)
{
    uint8_t cmd = CMD_READ_ID;
    uint8_t id[3];
    HAL_StatusTypeDef ret;
    uint8_t waitForWakeup = 0;
    uint32_t timeout = 2000; // Max safety timeout
    uint32_t start_tick = HAL_GetTick();
 
    // Read device ID with proper verification
    s->Is = 0;
    s->Size = 0;
    Power3v3_On();
 
    do
    {
        waitForWakeup = 0;
        flash_Select(s);
        do
        {
            ret = HAL_SPI_Transmit(s->Spi, &cmd, 1, 100);
            if (ret != HAL_OK)
                break;
            ret = HAL_SPI_Receive(s->Spi, id, 3, 100);
            if (ret != HAL_OK)
                break;
 
            // Verify manufacturer ID (0x1F for Atmel/Microchip)
            if (id[0] != AT25_MANUFACTURER_ID)
            {
                ret = HAL_ERROR;
                waitForWakeup = 1;  // the chip is ready, but looks like not woke up yet
                break;
            }
            // Verify device family and density for AT25EU0041A
            // id[1] = device family, id[2] = density code
            // For AT25EU0041A: family should be 0x84 and density 0x10 (4Mbit)
            s->Is = 1;
            s->Size = AT25_MEMSIZE; // 4Mbit = 512KB = 524288 bytes
        } while (0);
        flash_Unselect(s);
    } while (waitForWakeup && HAL_GetTick() - start_tick < timeout);
 
    Power3v3_Off();
    return ret;
}
 
int8_t flash_at25_Is(flash_at25CS_t *s, int8_t tryInit)
{
    if (!s->Is && tryInit)
        flash_at25_Init(s);
    return s->Is;
}
 
HAL_StatusTypeDef flash_at25_Read(const flash_at25CS_t *s, uint32_t addr, void *buffer, uint16_t size)
{
    HAL_StatusTypeDef ret = HAL_ERROR;
 
    // Validate inputs
    if (s->Is > 0 && buffer != NULL && size > 0 && addr + size <= s->Size)
    {
        uint8_t cmd[5];
 
        // Use fast read command for better performance
        // Fast read requires: CMD + 3 address bytes + 1 dummy byte + data
        cmd[0] = CMD_FAST_READ;
        cmd[1] = (addr >> 16) & 0xFF;
        cmd[2] = (addr >> 8) & 0xFF;
        cmd[3] = addr & 0xFF;
        cmd[4] = 0xFF; // Dummy byte required for fast read
 
        Power3v3_On();
        do
        {
            // Wait for any pending operations to complete
            if ((ret = flashNew_WaitReadyWithTimeout(s)) != HAL_OK)
                break;
            flash_Select(s);    // because flashNew_WaitReadyWithTimeout
            if ((ret = HAL_SPI_Transmit(s->Spi, cmd, 5, HAL_MAX_DELAY)) != HAL_OK)
                break;
            ret = HAL_SPI_Receive(s->Spi, buffer, size, HAL_MAX_DELAY);
            if (ret != HAL_OK)
                break;
        } while (0);
        flash_Unselect(s);
        Power3v3_Off();
    }
    return ret;
}
 
/**
 * @brief write data to 256 bounder with erase of page
 */
static HAL_StatusTypeDef flash_WritePage(const flash_at25CS_t *s, uint32_t addr, const uint8_t *data, uint16_t size)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (s->Is > 0)
    {
        if (size > sizeof(_buffer256))
        {
            writeLog("flash_WritePage incorrect length:%d", (int)size);
            Error_Handler();
        }
        do
        {
            uint32_t pageAddr = addr >> 8;  // /256
            uint8_t cmd[4];
 
            pageAddr <<= 8; // 256 the erase Page to 256 bounde`r
            if ((status = flash_at25_Read(s, pageAddr, _buffer256, sizeof(_buffer256))) != HAL_OK)  // backup Page
                break;
            cmd[0] = CMD_PAGE_ERASE; // Page Erase Command
            cmd[1] = (pageAddr >> 16) & 0xFF;   // page 256
            cmd[2] = (pageAddr >> 8) & 0xFF;
            cmd[3] = pageAddr & 0xFF;
            if ((status = flashNew_WriteEnableVerified(s)) != HAL_OK)
                break;
            flash_Select(s);
            if ((status = HAL_SPI_Transmit(s->Spi, cmd, 4, HAL_MAX_DELAY)) != HAL_OK)
                break;
            flash_Unselect(s);
 
            cmd[0] = CMD_PAGE_PROG; // write on same position
            memcpy(_buffer256 + (addr - pageAddr), data, size); // copy new data only
            // Wait for flash to be ready
            if ((status = flashNew_WaitReadyWithTimeout(s)) != HAL_OK)
                break;
            // Enable write operations with verification
            if ((status = flashNew_WriteEnableVerified(s)) != HAL_OK)
                break;
            flash_Select(s);
            if ((status = HAL_SPI_Transmit(s->Spi, cmd, 4, HAL_MAX_DELAY)) != HAL_OK)
                break;
            if ((status = HAL_SPI_Transmit(s->Spi, _buffer256, sizeof(_buffer256), HAL_MAX_DELAY)) != HAL_OK)   // whole buffer
                break;
            flash_Unselect(s);
            // Final wait to ensure last write completes
            status = flashNew_WaitReadyWithTimeout(s);
        }while(0);
        flash_Unselect(s);
    }
    return status;
}
 
HAL_StatusTypeDef flash_at25_Write(const flash_at25CS_t *s, uint32_t addr, const void *data, uint16_t size)
{
    HAL_StatusTypeDef ret = HAL_ERROR;
    uint32_t pAddr = addr;
    uint32_t bytesLeft = size;
    const uint8_t *pBuffer = data;
 
    Power3v3_On();
    while (bytesLeft > 0)
    {
        // Calculate how many bytes can be written in the current page
        uint32_t pageOffset = pAddr % 256;
        uint32_t maxWrite = 256 - pageOffset;
        uint32_t currentWriteLen = (bytesLeft < maxWrite) ? bytesLeft : maxWrite;
 
        ret = flash_WritePage(s, pAddr, pBuffer, currentWriteLen);
        if (ret != HAL_OK)
            break;
 
        pAddr += currentWriteLen;
        pBuffer += currentWriteLen;
        bytesLeft -= currentWriteLen;
    }
    Power3v3_Off();
 
    // memory check
#ifdef xxxDEBUG
    uint8_t sectorBuffer[512] = {};
    ret = flash_at25_Read(s, addr, sectorBuffer, size);
    if (ret != HAL_OK)
    {
        writeLog("flashNew_Write: read check failed:%d", (int) ret);
        Error_Handler();
    }
    if (memcmp(sectorBuffer, data, size) != 0)
    {
        writeLog("flashNew_Write: compare failed!");
        Error_Handler();
    }
#endif
    return ret;
}