spi_at45dib.c

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2010 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/at45d.h>
#ifndef DFCMD_BUF1_LOAD_PAGE
#define DFCMD_BUF1_LOAD_PAGE    0x53
#endif
#ifndef DFCMD_BUF2_LOAD_PAGE
#define DFCMD_BUF2_LOAD_PAGE    0x55
#endif
#include <stdlib.h>

#include <dev/spi_at45dib.h>


#define AT45DIB_FDIRTY      0x0001

typedef struct _AT45DIB {
    sf_unit_t dib_page[2];

    uint_fast8_t flags[2];

    int dib_locks[2];

    HANDLE dib_lque;

    uint_fast8_t dib_pshft;
} AT45DIB;

static int At45dibTransmitCmd(NUTSPINODE * node, uint8_t op, uint32_t parm, uint_fast8_t oplen)
{
    uint8_t cmd[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

    NUTASSERT(oplen <= sizeof(cmd));

    cmd[0] = op;
    if (parm) {
        cmd[1] = (uint8_t) (parm >> 16);
        cmd[2] = (uint8_t) (parm >> 8);
        cmd[3] = (uint8_t) parm;
    }
    return (*((NUTSPIBUS *) node->node_bus)->bus_transfer) (node, cmd, NULL, oplen);
}

static int At45dibTransfer(NUTSPINODE * node, uint8_t op, uint32_t parm, uint_fast8_t oplen, 
                           CONST void *txbuf, void *rxbuf, int xlen)
{
    int rc;
    NUTSPIBUS *bus;

    /* Sanity checks. */
    NUTASSERT(node != NULL);
    bus = (NUTSPIBUS *) node->node_bus;
    NUTASSERT(bus != NULL);
    NUTASSERT(bus->bus_alloc != NULL);
    NUTASSERT(bus->bus_transfer != NULL);
    NUTASSERT(bus->bus_release != NULL);

    rc = (*bus->bus_alloc) (node, 0);
    if (rc == 0) {
        rc = At45dibTransmitCmd(node, op, parm, oplen);
        if (rc == 0 && xlen) {
            rc = (*bus->bus_transfer) (node, txbuf, rxbuf, xlen);
        }
        (*bus->bus_release) (node);
    }
    return rc;
}

static int At45dibCommand(NUTSPINODE * node, uint8_t op, uint32_t parm, uint_fast8_t oplen)
{
    return At45dibTransfer(node, op, parm, oplen, NULL, NULL, 0);
}

static int At45dibCompare(NUTSPINODE * node, uint8_t op, uint32_t parm, uint_fast8_t oplen, CONST void *buf, int xlen)
{
    int rc;
    NUTSPIBUS *bus;

    /* Sanity checks. */
    NUTASSERT(node != NULL);
    bus = (NUTSPIBUS *) node->node_bus;
    NUTASSERT(bus != NULL);
    NUTASSERT(bus->bus_alloc != NULL);
    NUTASSERT(bus->bus_transfer != NULL);
    NUTASSERT(bus->bus_release != NULL);

    rc = (*bus->bus_alloc) (node, 0);
    if (rc == 0) {
        rc = At45dibTransmitCmd(node, op, parm, oplen);
        if (rc == 0 && xlen) {
            int i;
            uint8_t c;
            uint8_t *cp = (uint8_t *) buf;

            for (i = 0; i < xlen; i++) {
                rc = (*bus->bus_transfer) (node, NULL, &c, 1);
                if (rc) {
                    break;
                }
                if (c != cp[i]) {
                    rc = (int) c - (int) cp[i];
                    break;
                }
            }
        }
        (*bus->bus_release) (node);
    }
    return rc;
}

static int At45dibUsed(NUTSPINODE * node, uint8_t op, uint32_t parm, uint_fast8_t oplen, int xlen)
{
    int rc;
    NUTSPIBUS *bus;

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

    bus = (NUTSPIBUS *) node->node_bus;
    NUTASSERT(bus != NULL);
    NUTASSERT(bus->bus_alloc != NULL);
    NUTASSERT(bus->bus_transfer != NULL);
    NUTASSERT(bus->bus_release != NULL);

    rc = (*bus->bus_alloc) (node, 0);
    if (rc == 0) {
        rc = At45dibTransmitCmd(node, op, parm, oplen);
        if (rc == 0 && xlen) {
            int i;
            int n = -1;
            uint8_t c;

            for (i = 0; i < xlen; i++) {
                rc = (*bus->bus_transfer) (node, NULL, &c, 1);
                if (rc) {
                    break;
                }
                if (c != 0xff) {
                    n = i;
                }
            }
            if (rc == 0) {
                rc = n + 1;
            }
        }
        (*bus->bus_release) (node);
    }
    return rc;
}


#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 At45dibChecksum(NUTSPINODE * node, uint8_t op, uint32_t parm, uint_fast8_t oplen, uint16_t * crc16, int xlen)
{
    int rc;
    NUTSPIBUS *bus;

    /* Sanity checks. */
    NUTASSERT(node != NULL);
    bus = (NUTSPIBUS *) node->node_bus;
    NUTASSERT(bus != NULL);
    NUTASSERT(bus->bus_alloc != NULL);
    NUTASSERT(bus->bus_transfer != NULL);
    NUTASSERT(bus->bus_release != NULL);

    *crc16 = 0xffff;
    rc = (*bus->bus_alloc) (node, 0);
    if (rc == 0) {
        rc = At45dibTransmitCmd(node, op, parm, oplen);
        if (rc == 0 && xlen) {
            int i;
            uint8_t c;
            uint_fast8_t ne = 0;

            for (i = 0; i < xlen; i++) {
                rc = (*bus->bus_transfer) (node, NULL, &c, 1);
                if (rc) {
                    break;
                }
                if (ne || c != 0xff) {
                    ne = 1;
                    *crc16 = crc_ccitt_update(*crc16, c);
                }
            }
            if (*crc16 == 0) {
                *crc16 = 0xffff;
            }
        }
        (*bus->bus_release) (node);
    }
    return rc;
}

#endif /* AT45D_CRC_PAGE */


static uint8_t At45dibStatus(NUTSPINODE * node)
{
    int rc;
    uint8_t cmd[2] = { DFCMD_READ_STATUS, 0xFF };
    NUTSPIBUS *bus;

    /* Sanity checks. */
    NUTASSERT(node != NULL);
    NUTASSERT(node->node_bus != NULL);

    bus = (NUTSPIBUS *) node->node_bus;
    NUTASSERT(bus->bus_alloc != NULL);
    NUTASSERT(bus->bus_transfer != NULL);
    NUTASSERT(bus->bus_wait != NULL);
    NUTASSERT(bus->bus_release != NULL);

    rc = (*bus->bus_alloc) (node, 0);
    if (rc == 0) {
        rc = (*bus->bus_transfer) (node, cmd, cmd, 2);
        if (rc == 0) {
            (*bus->bus_wait) (node, NUT_WAIT_INFINITE);
            rc = cmd[1];
        }
        (*bus->bus_release) (node);
    }
    return (uint8_t) rc;
}

static int At45dibWaitReady(NUTSPINODE * node, uint32_t tmo)
{
    uint8_t sr;

    while (((sr = At45dibStatus(node)) & 0x80) == 0) {
        if (tmo-- == 0) {
            return -1;
        }
    }
    return 0;
}

static int At45dibFlash(NUTSERIALFLASH * sfi, int_fast8_t b)
{
    int rc;
    AT45DIB *at;
    uint32_t pga;

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

        if (At45dibChecksum(sfi->sf_node, b ? DFCMD_BUF2_READ : DFCMD_BUF1_READ, 0, 5, &crc16, sfi->sf_unit_size)) {
            return -1;
        }
        if (At45dibTransfer
            (sfi->sf_node, b ? DFCMD_BUF2_WRITE : DFCMD_BUF1_WRITE, sfi->sf_unit_size, 4, &crc16, NULL, sizeof(crc16))) {
            return -1;
        }
    }
#endif

    at = (AT45DIB *) sfi->sf_info;
    pga = at->dib_page[b];
    pga <<= at->dib_pshft;
    rc = At45dibCommand(sfi->sf_node, b ? DFCMD_BUF2_FLASH_NE : DFCMD_BUF1_FLASH_NE, pga, 4);
    if (rc == 0) {
        rc = At45dibWaitReady(sfi->sf_node, AT45_WRITE_POLLS);
        at->flags[b] &= ~AT45DIB_FDIRTY;
    }
    return rc;
}

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

    at->dib_locks[b]--;
    NutEventPost(&at->dib_lque);
}

static int_fast8_t At45dibAllocate(NUTSERIALFLASH * sfi, sf_unit_t pgn)
{
    int_fast8_t b;
    AT45DIB *at;

    at = (AT45DIB *) sfi->sf_info;
    for (;;) {
        /* 
        ** Check, if the page is already loaded.
        */
        for (b = 0; b < 2; b++) {
            if (at->dib_page[b] == pgn) {
                at->dib_locks[b]++;
                at->flags[b] |= AT45DIB_FDIRTY;
                return b;
            }
        }

        /*
        ** Search for a clean unlocked buffer and load the page.
        */
        for (b = 0; b < 2; b++) {
            if (at->dib_locks[b] == 0 && (at->flags[b] & AT45DIB_FDIRTY) == 0) {
                int rc;
                uint32_t pga = pgn;

                pga <<= at->dib_pshft;
                at->dib_locks[b]++;
                if (b) {
                    rc = At45dibCommand(sfi->sf_node, DFCMD_BUF2_LOAD_PAGE, pga, 4);
                } else {
                    rc = At45dibCommand(sfi->sf_node, DFCMD_BUF1_LOAD_PAGE, pga, 4);
                }
                if (rc == 0) {
                    rc = At45dibWaitReady(sfi->sf_node, AT45_WRITE_POLLS);
                }
                if (rc == 0) {
                    at->dib_page[b] = pgn;
                    at->flags[b] |= AT45DIB_FDIRTY;

                    return b;
                }
                At45dibRelease(sfi, b);

                return -1;
            }
        }

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

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

static int SpiAt45dibInit(NUTSERIALFLASH * sfi)
{
    int_fast8_t b;
    uint8_t sr;
    int_fast8_t i;

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

    sr = At45dibStatus(sfi->sf_node);
    sr &= AT45D_STATUS_DENSITY | AT45D_STATUS_PAGE_SIZE;
    for (i = at45d_known_types; --i >= 0;) {
        if (sr == at45d_info[i].at45d_srval) {
            /* Known DataFlash type. */
            AT45DIB *at = calloc(1, sizeof(AT45DIB));
            if (at == NULL) {
                return -1;
            }
            at->dib_pshft = at45d_info[i].at45d_pshft;
            for (b = 0; b < 2; b++) {
                at->dib_page[b] = SERIALFLASH_MAX_UNITS;
            }
            sfi->sf_info = (void *) at;
            sfi->sf_units = (sf_unit_t) at45d_info[i].at45d_pages;
            sfi->sf_unit_size = at45d_info[i].at45d_psize;
#ifdef AT45D_CRC_PAGE
            sfi->sf_unit_size -= 2;
#endif
            return 0;
        }
    }
    /* Unknown DataFlash type. */
    return -1;
}

static void SpiAt45dibExit(NUTSERIALFLASH * sfi)
{
    NUTASSERT(sfi != NULL);
    NUTASSERT(sfi->sf_info != NULL);

    free(sfi->sf_info);
}

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

#ifdef AT45D_CRC_PAGE
    AT45DIB *at;
    int_fast8_t b;
    uint16_t crc16;

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

    at = (AT45DIB *) sfi->sf_info;
    while (cnt--) {
        /* If this page is buffered, then read from the buffer. */
        for (b = 0; b < 2 && at->dib_page[b] != pgn + cnt; b++);
        if (b < 2) {
            At45dibChecksum(sfi->sf_node, b ? DFCMD_BUF2_READ : DFCMD_BUF1_READ, 0, 5, &crc16, sfi->sf_unit_size + 2);
        }
        /* If not buffered, then directly read from the flash. */
        else {
            uint32_t pga = pgn + cnt;
            pga <<= at->dib_pshft;
            At45dibChecksum(sfi->sf_node, DFCMD_READ_PAGE, pga, 8, &crc16, sfi->sf_unit_size + 2);
        }
        if (crc16 != 0xFFFF) {
            rc = -1;
            break;
        }
    }
#endif
    return rc;
}

static int SpiAt45dibRead(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;
        AT45DIB *at = (AT45DIB *) sfi->sf_info;

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

        /* If this page is buffered, then read from the buffer. */
        for (b = 0; b < 2 && at->dib_page[b] != pgn; b++);
        if (b < 2) {
            rc = At45dibTransfer(sfi->sf_node, b ? DFCMD_BUF2_READ : DFCMD_BUF1_READ, off, 5, NULL, data, len);
        }
        /* If not buffered, then directly read from the flash. */
        else {
            uint32_t pga = pgn;

            pga <<= at->dib_pshft;
            pga |= off;
            rc = At45dibTransfer(sfi->sf_node, DFCMD_READ_PAGE, pga, 8, NULL, data, len);
        }
    }
    return rc;
}

static int SpiAt45dibCompare(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;
        AT45DIB *at = (AT45DIB *) sfi->sf_info;

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

        /* If this page is buffered, then read from the buffer. */
        for (b = 0; b < 2 && at->dib_page[b] != pgn; b++);
        if (b < 2) {
            rc = At45dibCompare(sfi->sf_node, b ? DFCMD_BUF2_READ : DFCMD_BUF1_READ, off, 5, data, len);
        }
        /* If not buffered, then directly read from the flash. */
        else {
            uint32_t pga = pgn;

            pga <<= at->dib_pshft;
            pga |= off;
            rc = At45dibCompare(sfi->sf_node, DFCMD_READ_PAGE, pga, 8, data, len);
        }
    }
    return rc;
}

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

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

    at = (AT45DIB *) sfi->sf_info;

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

    /* If this page is buffered, then read from the buffer. */
    for (b = 0; b < 2 && at->dib_page[b] != pgn; b++);
    if (b < 2) {
        rc = At45dibUsed(sfi->sf_node, b ? DFCMD_BUF2_READ : DFCMD_BUF1_READ, skip, 5, len);
    }
    /* If not buffered, then directly read from the flash. */
    else {
        uint32_t pga = pgn;

        pga <<= at->dib_pshft;
        pga |= skip;
        rc = At45dibUsed(sfi->sf_node, DFCMD_READ_PAGE, pga, 8, len);
    }
    return rc;
}

static int SpiAt45dibWrite(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;

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

        /* Load the page. */
        b = At45dibAllocate(sfi, pgn);
        if (b < 0) {
            return -1;
        }
        /* Transfer the data and release the page. */
        rc = At45dibTransfer(sfi->sf_node, b ? DFCMD_BUF2_WRITE : DFCMD_BUF1_WRITE, off, 4, data, NULL, len);
        At45dibRelease(sfi, b);
    }
    return rc;
}

static int SpiAt45dibCopy(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 = At45dibAllocate(sfi, spg);
    } else {
        AT45DIB *at = (AT45DIB *) sfi->sf_info;

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

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

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

    at = (AT45DIB *) sfi->sf_info;
    for (b = 0; b < 2 && at->dib_page[b] != pgn; b++);
    if (b < 2 && (at->flags[b] & AT45DIB_FDIRTY) == AT45DIB_FDIRTY) {
        rc = At45dibFlash(sfi, b);
    }
    return rc;
}

static int SpiAt45dibErase(NUTSERIALFLASH * sfi, sf_unit_t pgn, int cnt)
{
    int_fast8_t b;
    AT45DIB *at;

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

    at = (AT45DIB *) sfi->sf_info;
    /* Invalidate any buffered page. */
    for (b = 0; b < 2; b++) {
        if (at->dib_page[b] >= pgn && at->dib_page[b] < pgn + cnt) {
            at->dib_page[b] = SERIALFLASH_MAX_UNITS;
            at->flags[b] &= ~AT45DIB_FDIRTY;
        }
    }
    while (cnt--) {
        uint32_t pga = pgn + cnt;

        pga <<= at->dib_pshft;
        if (At45dibCommand(sfi->sf_node, DFCMD_PAGE_ERASE, pga, 4)) {
            return -1;
        }
        if (At45dibWaitReady(sfi->sf_node, AT45_WRITE_POLLS)) {
            return -1;
        }
    }
    return 0;
}

#ifndef SPI_RATE_AT45D0
#define SPI_RATE_AT45D0  33000000
#endif

#ifndef SPI_MODE_AT45D0

#ifdef SPI_CSHIGH_AT45D0
#define SPI_MODE_AT45D0 (SPI_MODE_3 | SPI_MODE_CSHIGH)
#else
#define SPI_MODE_AT45D0 SPI_MODE_3
#endif

#elif defined(SPI_CSHIGH_AT45D0)

/* This is a tricky problem. Originally we didn't provide mode settings
** in the Configurator, but used mode 3 only. After experiencing problems
** with mode switching on the EIR, we need to set mode 0 for that board,
** which spoils our chip select polarity setting. */
#if SPI_MODE_AT45D0 == SPI_MODE_0
#undef SPI_MODE_AT45D0
#define SPI_MODE_AT45D0 (SPI_MODE_0 | SPI_MODE_CSHIGH)
#elif SPI_MODE_AT45D0 == SPI_MODE_3
#undef SPI_MODE_AT45D0
#define SPI_MODE_AT45D0 (SPI_MODE_3 | SPI_MODE_CSHIGH)
#endif

#endif /* SPI_MODE_AT45D0 */

static NUTSPINODE spiNode0 = {
    NULL,                       
    NULL,                       
    SPI_RATE_AT45D0,            
    SPI_MODE_AT45D0,            
    8,                          
    0                           
};

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

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

NUTSERIALFLASH flashAt45dib0 = {
    &spiNode0,                  
    NULL,                       
    0,                          
    0,                          
    MOUNT_OFFSET_AT45DIB0,      
    MOUNT_TOP_RESERVE_AT45DIB0, 
    SpiAt45dibInit,             
    SpiAt45dibExit,             
    SpiAt45dibCheck,            
    SpiAt45dibRead,             
    SpiAt45dibCompare,          
    SpiAt45dibUsed,             
    SpiAt45dibWrite,            
    SpiAt45dibCopy,             
    SpiAt45dibCommit,           
    SpiAt45dibErase             
};

#ifndef SPI_RATE_AT45D1
#define SPI_RATE_AT45D1  33000000
#endif

#ifndef SPI_MODE_AT45D1

#ifdef SPI_CSHIGH_AT45D1
#define SPI_MODE_AT45D1 (SPI_MODE_3 | SPI_MODE_CSHIGH)
#else
#define SPI_MODE_AT45D1 SPI_MODE_3
#endif

#elif defined(SPI_CSHIGH_AT45D1)

/* Same problem problem as above. */
#if SPI_MODE_AT45D1 == SPI_MODE_0
#undef SPI_MODE_AT45D1
#define SPI_MODE_AT45D1 (SPI_MODE_0 | SPI_MODE_CSHIGH)
#elif SPI_MODE_AT45D1 == SPI_MODE_3
#undef SPI_MODE_AT45D1
#define SPI_MODE_AT45D1 (SPI_MODE_3 | SPI_MODE_CSHIGH)
#endif

#endif /* SPI_MODE_AT45D0 */

static NUTSPINODE spiNode1 = {
    NULL,                       
    NULL,                       
    SPI_RATE_AT45D1,            
    SPI_MODE_AT45D1,            
    8,                          
    1                           
};

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

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

NUTSERIALFLASH flashAt45dib1 = {
    &spiNode1,                  
    NULL,                       
    0,                          
    0,                          
    MOUNT_OFFSET_AT45DIB1,      
    MOUNT_TOP_RESERVE_AT45DIB1, 
    SpiAt45dibInit,             
    SpiAt45dibExit,             
    SpiAt45dibCheck,            
    SpiAt45dibRead,             
    SpiAt45dibCompare,          
    SpiAt45dibUsed,             
    SpiAt45dibWrite,            
    SpiAt45dibCopy,             
    SpiAt45dibCommit,           
    SpiAt45dibErase             
};