spi_flash_at45d.c

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2011 by egnite GmbH
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <cfg/memory.h>
#include <sys/nutdebug.h>

#include <dev/spi_node_at45d.h>

#include <stdlib.h>
#include <string.h>


#ifndef FLASH_BUFFERS_AT45D
#define FLASH_BUFFERS_AT45D  2
#endif

#ifdef AT45D_CRC_PAGE
#define AT45D_CRC_SIZE  2
#else
#define AT45D_CRC_SIZE  0
#endif

#define FLASH_BUFFER_DIRTY      0x0001

typedef struct _AT45D_FLASH {
    sf_unit_t dxb_page[FLASH_BUFFERS_AT45D];

    uint_fast8_t flags[FLASH_BUFFERS_AT45D];

    int dxb_locks[FLASH_BUFFERS_AT45D];

    HANDLE dxb_lque;

    uint_fast8_t dxb_pshft;

    uint8_t *dxb_pbuf[FLASH_BUFFERS_AT45D];
} AT45D_FLASH;

#ifdef AT45D_CRC_PAGE

/*
 * http://www.nongnu.org/avr-libc/user-manual/group__util__crc.html
 */
static uint16_t crc_ccitt_update(uint16_t crc, uint8_t data)
{
    data ^= (uint8_t) (crc);
    data ^= data << 4;

    return ((((uint16_t) data << 8) | (crc >> 8)) ^ (uint8_t) (data >> 4) ^ ((uint16_t) data << 3));
}

static int CalculateChecksum(AT45D_FLASH * at, int_fast8_t b, uint16_t * crc16, int xlen)
{
    int rc;
    NUTSPIBUS *bus;

    /* Sanity checks. */
    NUTASSERT(at != NULL);
    NUTASSERT(crc16 != NULL);

    *crc16 = 0xffff;
    if (xlen) {
        int i;
        uint8_t c;
        uint_fast8_t ne = 0;

        for (i = 0; i < xlen; i++) {
            c = at->dxb_pbuf[i];
            if (ne || c != 0xff) {
                ne = 1;
                *crc16 = crc_ccitt_update(*crc16, c);
            }
        }
        if (*crc16 == 0) {
            *crc16 = 0xffff;
        }
    }
}

#endif                          /* AT45D_CRC_PAGE */

static int At45dFlashSaveUnit(NUTSERIALFLASH * sfi, int_fast8_t b)
{
    int rc;
    AT45D_FLASH *at;

    at = (AT45D_FLASH *) sfi->sf_info;

#ifdef AT45D_CRC_PAGE
    /* Store a 16 bit CRC at the end of the page, if configured. */
    {
        uint16_t crc16;

        CalculateChecksum(at, b, &crc16, sfi->sf_unit_size);
        memcpy(at->dxb_pbuf[b] + sfi->sf_unit_size, &crc16, sizeof(crc16));
    }
#endif

    rc = At45dNodeLock(sfi->sf_node);
    if (rc == 0) {
        rc = At45dNodeTransfer(sfi->sf_node, DFCMD_BUF2_WRITE, 0, 4, at->dxb_pbuf[b], NULL, sfi->sf_unit_size + AT45D_CRC_SIZE);
        if (rc == 0) {
            uint32_t pga;

            pga = at->dxb_page[b];
            pga <<= at->dxb_pshft;
            rc = At45dNodeCommand(sfi->sf_node, DFCMD_BUF2_FLASH_NE, pga, 4);
            if (rc == 0) {
                rc = At45dNodeWaitReady(sfi->sf_node, AT45_WRITE_POLLS, 0);
            }
            At45dNodeUnlock(sfi->sf_node);
            if (rc == 0) {
                at->flags[b] &= ~FLASH_BUFFER_DIRTY;
            }
        }
    }
    return rc;
}

static void At45dFlashRelease(NUTSERIALFLASH * sfi, int b)
{
    AT45D_FLASH *at = (AT45D_FLASH *) sfi->sf_info;

    at->dxb_locks[b]--;
    NutEventPost(&at->dxb_lque);
}

static int_fast8_t At45dFlashLoadUnit(NUTSERIALFLASH * sfi, sf_unit_t pgn, int_fast8_t lock)
{
    static int_fast8_t bnxt = 0;
    int_fast8_t b;
    AT45D_FLASH *at;

    at = (AT45D_FLASH *) sfi->sf_info;
    for (;;) {
        /*
         * Check, if the page is already loaded.
         */
        for (b = 0; b < FLASH_BUFFERS_AT45D; b++) {
            if (at->dxb_page[b] == pgn) {
                if (lock) {
                    at->dxb_locks[b]++;
                    at->flags[b] |= FLASH_BUFFER_DIRTY;
                }
                return b;
            }
        }

        /*
         * Search for a clean unlocked buffer and load the page.
         */
        b = bnxt;
        do {
            if (at->dxb_locks[b] == 0 && (at->flags[b] & FLASH_BUFFER_DIRTY) == 0) {
                break;
            }
            if (++b >= FLASH_BUFFERS_AT45D) {
                b = 0;
            }
            if (b == bnxt) {
                b = -1;
            }
        } while (b >= 0);
        if (b >= 0) {
            int rc;
            uint32_t pga = pgn;

            if (At45dNodeLock(sfi->sf_node) == 0) {
                pga <<= at->dxb_pshft;
                if (lock) {
                    at->dxb_locks[b]++;
                }
                rc = At45dNodeTransfer(sfi->sf_node, DFCMD_READ_PAGE, pga, 8, NULL, at->dxb_pbuf[b],
                                       sfi->sf_unit_size + AT45D_CRC_SIZE);
                At45dNodeUnlock(sfi->sf_node);
                if (rc == 0) {
                    at->dxb_page[b] = pgn;
                    if (lock) {
                        at->flags[b] |= FLASH_BUFFER_DIRTY;
                    }
                    if (++bnxt >= FLASH_BUFFERS_AT45D) {
                        bnxt = 0;
                    }
                    return b;
                }
                if (lock) {
                    At45dFlashRelease(sfi, b);
                }
            }
            return -1;
        }

        /*
         * No clean buffer. If not locked, save one of them.
         */
        for (b = 0; b < FLASH_BUFFERS_AT45D; b++) {
            if (at->dxb_locks[b] == 0 && (at->flags[b] & FLASH_BUFFER_DIRTY) == FLASH_BUFFER_DIRTY) {
                if (At45dFlashSaveUnit(sfi, b)) {
                    return -1;
                }
                break;
            }
        }

        /*
         * All buffers are locked. Wait for an unlock event.
         */
        if (b >= FLASH_BUFFERS_AT45D) {
            NutEventWait(&at->dxb_lque, 0);
        }
    }
}

static int SpiAt45dFlashInit(NUTSERIALFLASH * sfi)
{
    int_fast8_t b;
    AT45D_INFO *df;
    AT45D_FLASH *at;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_node != NULL);

    df = At45dNodeProbe(sfi->sf_node);
    if (df == NULL) {
        /* Unknown DataFlash type. */
        return -1;
    }
    /* Known DataFlash type. */
    at = calloc(1, sizeof(AT45D_FLASH));
    if (at == NULL) {
        return -1;
    }
    at->dxb_pshft = df->at45d_pshft;
    for (b = 0; b < FLASH_BUFFERS_AT45D; b++) {
        at->dxb_page[b] = SERIALFLASH_MAX_UNITS;
        at->dxb_pbuf[b] = malloc(df->at45d_psize);
    }
    sfi->sf_info = (void *) at;
    sfi->sf_units = (sf_unit_t) df->at45d_pages;
    sfi->sf_unit_size = df->at45d_psize - AT45D_CRC_SIZE;

    return 0;
}

static void SpiAt45dFlashExit(NUTSERIALFLASH * sfi)
{
    int_fast8_t b;
    AT45D_FLASH *at;

    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_info != NULL);

    at = (AT45D_FLASH *) sfi->sf_info;
    for (b = 0; b < FLASH_BUFFERS_AT45D; b++) {
        free(at->dxb_pbuf[b]);
    }
    free(sfi->sf_info);
}

static int SpiAt45dFlashCheck(NUTSERIALFLASH * sfi, sf_unit_t pgn, int cnt)
{
    int rc = 0;

#ifdef AT45D_CRC_PAGE
    AT45D_FLASH *at;
    int_fast8_t b;
    uint16_t crc16 = 0;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_info != NULL);
    NUTASSERT(pgn + cnt <= sfi->sf_units);
    NUTASSERT(cnt >= 0);

    at = (AT45D_FLASH *) sfi->sf_info;
    while (cnt--) {
        b = At45dFlashLoadUnit(sfi, pgn + cnt, 0);
        if (b >= 0) {
            CalculateChecksum(at, b, &crc16, sfi->sf_unit_size + AT45D_CRC_SIZE);
        }
        if (crc16 != 0xFFFF) {
            rc = -1;
            break;
        }
    }
#endif
    return rc;
}

static int SpiAt45dFlashRead(NUTSERIALFLASH * sfi, sf_unit_t pgn, int off, void *data, int len)
{
    int rc = 0;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_info != NULL);
    NUTASSERT(pgn < sfi->sf_units);
    NUTASSERT(off >= -(int) sfi->sf_unit_size && off <= (int) sfi->sf_unit_size);
    NUTASSERT(data != NULL);
    NUTASSERT(len >= 0 && len <= sfi->sf_unit_size);

    if (len) {
        int_fast8_t b;
        AT45D_FLASH *at = (AT45D_FLASH *) sfi->sf_info;

        /* Normalize the offset. */
        if (off < 0) {
            off += sfi->sf_unit_size;
        }
        NUTASSERT(off + len <= (int) sfi->sf_unit_size);

        b = At45dFlashLoadUnit(sfi, pgn, 0);
        if (b < 0) {
            rc = -1;
        } else {
            memcpy(data, at->dxb_pbuf[b] + off, len);
        }
    }
    return rc;
}

static int SpiAt45dFlashCompare(NUTSERIALFLASH * sfi, sf_unit_t pgn, int off, CONST void *data, int len)
{
    int rc = 0;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_info != NULL);
    NUTASSERT(pgn < sfi->sf_units);
    NUTASSERT(off >= -(int) sfi->sf_unit_size && off <= (int) sfi->sf_unit_size);
    NUTASSERT(data != NULL);
    NUTASSERT(len >= 0 && len <= sfi->sf_unit_size);

    if (len) {
        int_fast8_t b;
        AT45D_FLASH *at = (AT45D_FLASH *) sfi->sf_info;

        /* Normalize the offset. */
        if (off < 0) {
            off += sfi->sf_unit_size;
        }
        NUTASSERT(off + len <= (int) sfi->sf_unit_size);

        b = At45dFlashLoadUnit(sfi, pgn, 0);
        if (b < 0 || memcmp(at->dxb_pbuf[b] + off, data, len)) {
            rc = -1;
        }
    }
    return rc;
}

static int SpiAt45dFlashUsed(NUTSERIALFLASH * sfi, sf_unit_t pgn, int skip)
{
    int rc;
    int len;
    AT45D_FLASH *at;
    int_fast8_t b;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(pgn < sfi->sf_units);
    NUTASSERT(skip <= (int) sfi->sf_unit_size);

    at = (AT45D_FLASH *) sfi->sf_info;

    /* Determine length and offset. */
    len = (int) sfi->sf_unit_size;
    if (skip < 0) {
        len += skip;
        skip = 0;
    } else {
        len -= skip;
    }

    b = At45dFlashLoadUnit(sfi, pgn, 0);
    if (b < 0) {
        rc = -1;
    } else {
        rc = 0;
        if (len) {
            uint8_t *cp = at->dxb_pbuf[b] + skip;
            int i;

            for (i = 0; i < len; i++) {
                if (*cp++ != 0xff) {
                    rc = i + 1;
                }
            }
        }
    }
    return rc;
}

static int SpiAt45dFlashWrite(NUTSERIALFLASH * sfi, sf_unit_t pgn, int off, CONST void *data, int len)
{
    int rc = 0;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(pgn < sfi->sf_units);
    NUTASSERT(off >= -(int) sfi->sf_unit_size && off <= (int) sfi->sf_unit_size);
    NUTASSERT(len == 0 || data != NULL);
    NUTASSERT(len >= 0 && len <= sfi->sf_unit_size);

    if (len) {
        int_fast8_t b;
        AT45D_FLASH *at = (AT45D_FLASH *) sfi->sf_info;

        /* Normalize the offset. */
        if (off < 0) {
            off += sfi->sf_unit_size;
        }
        NUTASSERT(off + len <= (int) sfi->sf_unit_size);

        /* Load the page. */
        b = At45dFlashLoadUnit(sfi, pgn, 1);
        if (b < 0) {
            return -1;
        }
        /* Transfer the data and release the page. */
        memcpy(at->dxb_pbuf[b] + off, data, len);
        At45dFlashRelease(sfi, b);
    }
    return rc;
}

static int SpiAt45dFlashCopy(NUTSERIALFLASH * sfi, sf_unit_t spg, sf_unit_t dpg)
{
    int_fast8_t b;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_info != NULL);
    NUTASSERT(spg < sfi->sf_units);
    NUTASSERT(dpg < sfi->sf_units);

    /* If source and destination page numbers are equal, just load it. */
    if (spg == dpg) {
        b = At45dFlashLoadUnit(sfi, spg, 1);
    } else {
        AT45D_FLASH *at = (AT45D_FLASH *) sfi->sf_info;

        /* Invalidate any buffered destination. */
        for (b = 0; b < FLASH_BUFFERS_AT45D; b++) {
            if (at->dxb_page[b] == dpg) {
                /* But do not touch locked pages. */
                if (at->dxb_locks[b]) {
                    return -1;
                }
                at->dxb_page[b] = SERIALFLASH_MAX_UNITS;
            }
        }
        /* Try to load the source page and make it the destination page. */
        b = At45dFlashLoadUnit(sfi, spg, 1);
        if (b >= 0) {
            at->dxb_page[b] = dpg;
        }
    }
    if (b >= 0) {
        At45dFlashRelease(sfi, b);
        return 0;
    }
    return -1;
}

static int SpiAt45dFlashCommit(NUTSERIALFLASH * sfi, sf_unit_t pgn)
{
    int rc = 0;
    int_fast8_t b;
    AT45D_FLASH *at;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(pgn < sfi->sf_units);

    at = (AT45D_FLASH *) sfi->sf_info;
    for (b = 0; b < FLASH_BUFFERS_AT45D && at->dxb_page[b] != pgn; b++);
    if (b < FLASH_BUFFERS_AT45D && (at->flags[b] & FLASH_BUFFER_DIRTY) == FLASH_BUFFER_DIRTY) {
        rc = At45dFlashSaveUnit(sfi, b);
    }
    return rc;
}

static int SpiAt45dFlashErase(NUTSERIALFLASH * sfi, sf_unit_t pgn, int cnt)
{
    int rc = 0;
    int_fast8_t b;
    AT45D_FLASH *at;

    /* Sanity checks. */
    NUTASSERT(sfi != NULL);
    NUTASSERT(pgn + cnt <= sfi->sf_units);
    NUTASSERT(cnt >= 0);

    at = (AT45D_FLASH *) sfi->sf_info;
    /* Invalidate any buffered page. */
    for (b = 0; b < FLASH_BUFFERS_AT45D; b++) {
        if (at->dxb_page[b] >= pgn && at->dxb_page[b] < pgn + cnt) {
            at->dxb_page[b] = SERIALFLASH_MAX_UNITS;
            at->flags[b] &= ~FLASH_BUFFER_DIRTY;
        }
    }
    while (rc == 0 && cnt--) {
        uint32_t pga = pgn + cnt;
        pga <<= at->dxb_pshft;

        rc = At45dNodeLock(sfi->sf_node);
        if (rc == 0) {
            rc = At45dNodeCommand(sfi->sf_node, DFCMD_PAGE_ERASE, pga, 4);
            if (rc == 0) {
                At45dNodeWaitReady(sfi->sf_node, AT45_WRITE_POLLS, 0);
            }
            At45dNodeUnlock(sfi->sf_node);
        }
    }
    return rc;
}

#ifndef FLASH_MOUNT_OFFSET_AT45D0
#ifdef MOUNT_OFFSET_AT45D0
#define FLASH_MOUNT_OFFSET_AT45D0       MOUNT_OFFSET_AT45D0
#else
#define FLASH_MOUNT_OFFSET_AT45D0       0
#endif
#endif

#ifndef FLASH_MOUNT_TOP_RESERVE_AT45D0
#ifdef MOUNT_TOP_RESERVE_AT45D0
#define FLASH_MOUNT_TOP_RESERVE_AT45D0  MOUNT_TOP_RESERVE_AT45D0
#else
#define FLASH_MOUNT_TOP_RESERVE_AT45D0  1
#endif
#endif

NUTSERIALFLASH flashAt45d0 = {
    &nodeAt45d0,                
    NULL,                       
    0,                          
    0,                          
    FLASH_MOUNT_OFFSET_AT45D0,  
    FLASH_MOUNT_TOP_RESERVE_AT45D0,     
    SpiAt45dFlashInit,          
    SpiAt45dFlashExit,          
    SpiAt45dFlashCheck,         
    SpiAt45dFlashRead,          
    SpiAt45dFlashCompare,       
    SpiAt45dFlashUsed,          
    SpiAt45dFlashWrite,         
    SpiAt45dFlashCopy,          
    SpiAt45dFlashCommit,        
    SpiAt45dFlashErase          
};

#ifndef FLASH_MOUNT_OFFSET_AT45D1
#ifdef MOUNT_OFFSET_AT45D1
#define FLASH_MOUNT_OFFSET_AT45D1       MOUNT_OFFSET_AT45D1
#else
#define FLASH_MOUNT_OFFSET_AT45D1       0
#endif
#endif

#ifndef FLASH_MOUNT_TOP_RESERVE_AT45D1
#ifdef MOUNT_TOP_RESERVE_AT45D1
#define FLASH_MOUNT_TOP_RESERVE_AT45D1  MOUNT_TOP_RESERVE_AT45D1
#else
#define FLASH_MOUNT_TOP_RESERVE_AT45D1  1
#endif
#endif

NUTSERIALFLASH flashAt45d1 = {
    &nodeAt45d1,                
    NULL,                       
    0,                          
    0,                          
    FLASH_MOUNT_OFFSET_AT45D1,  
    FLASH_MOUNT_TOP_RESERVE_AT45D1,     
    SpiAt45dFlashInit,          
    SpiAt45dFlashExit,          
    SpiAt45dFlashCheck,         
    SpiAt45dFlashRead,          
    SpiAt45dFlashCompare,       
    SpiAt45dFlashUsed,          
    SpiAt45dFlashWrite,         
    SpiAt45dFlashCopy,          
    SpiAt45dFlashCommit,        
    SpiAt45dFlashErase          
};

#ifndef FLASH_MOUNT_OFFSET_AT45D2
#ifdef MOUNT_OFFSET_AT45D2
#define FLASH_MOUNT_OFFSET_AT45D2       MOUNT_OFFSET_AT45D2
#else
#define FLASH_MOUNT_OFFSET_AT45D2       0
#endif
#endif

#ifndef FLASH_MOUNT_TOP_RESERVE_AT45D2
#ifdef MOUNT_TOP_RESERVE_AT45D2
#define FLASH_MOUNT_TOP_RESERVE_AT45D2  MOUNT_TOP_RESERVE_AT45D2
#else
#define FLASH_MOUNT_TOP_RESERVE_AT45D2  1
#endif
#endif

NUTSERIALFLASH flashAt45d2 = {
    &nodeAt45d2,                
    NULL,                       
    0,                          
    0,                          
    FLASH_MOUNT_OFFSET_AT45D2,  
    FLASH_MOUNT_TOP_RESERVE_AT45D2,     
    SpiAt45dFlashInit,          
    SpiAt45dFlashExit,          
    SpiAt45dFlashCheck,         
    SpiAt45dFlashRead,          
    SpiAt45dFlashCompare,       
    SpiAt45dFlashUsed,          
    SpiAt45dFlashWrite,         
    SpiAt45dFlashCopy,          
    SpiAt45dFlashCommit,        
    SpiAt45dFlashErase          
};

#ifndef FLASH_MOUNT_OFFSET_AT45D3
#ifdef MOUNT_OFFSET_AT45D3
#define FLASH_MOUNT_OFFSET_AT45D3       MOUNT_OFFSET_AT45D3
#else
#define FLASH_MOUNT_OFFSET_AT45D3       0
#endif
#endif

#ifndef FLASH_MOUNT_TOP_RESERVE_AT45D3
#ifdef MOUNT_TOP_RESERVE_AT45D3
#define FLASH_MOUNT_TOP_RESERVE_AT45D3  MOUNT_TOP_RESERVE_AT45D3
#else
#define FLASH_MOUNT_TOP_RESERVE_AT45D3  1
#endif
#endif

NUTSERIALFLASH flashAt45d3 = {
    &nodeAt45d3,                
    NULL,                       
    0,                          
    0,                          
    FLASH_MOUNT_OFFSET_AT45D3,  
    FLASH_MOUNT_TOP_RESERVE_AT45D3,     
    SpiAt45dFlashInit,          
    SpiAt45dFlashExit,          
    SpiAt45dFlashCheck,         
    SpiAt45dFlashRead,          
    SpiAt45dFlashCompare,       
    SpiAt45dFlashUsed,          
    SpiAt45dFlashWrite,         
    SpiAt45dFlashCopy,          
    SpiAt45dFlashCommit,        
    SpiAt45dFlashErase          
};