flashc.c

Go to the documentation of this file.

#include <sys/atom.h>
#include <dev/nvmem.h>

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

#include <arch/avr32.h>
#include <arch/avr32/flashc.h>

#include <avr32/io.h>



#ifndef FLASH_CONF_SECTOR
#define FLASH_CONF_SECTOR  0x0003FF00
#endif


#ifndef FLASH_CONF_SIZE
#define FLASH_CONF_SIZE         AVR32_FLASHC_PAGE_SIZE
#endif

#ifndef FLASH_WRITE_WAIT
#define FLASH_WRITE_WAIT        60000
#endif

#ifndef FLASH_ERASE_WAIT
#define FLASH_ERASE_WAIT        60000
#endif

#ifndef FLASH_CHIP_ERASE_WAIT
#define FLASH_CHIP_ERASE_WAIT   600000
#endif


typedef uint32_t flashdat_t;
typedef unsigned long flashadr_t;
typedef volatile flashdat_t *flashptr_t;

static int flashc_is_ready(void)
{
    return ((AVR32_FLASHC.fsr & AVR32_FLASHC_FSR_FRDY_MASK) != 0);
}

int Avr32FlashcCmd(unsigned int cmd, uint32_t tmo)
{
    int rc = 0;

    /* Make sure that the previous command has finished. */
    while (!flashc_is_ready()) {
        if (tmo && --tmo < 1) {
            return -1;
        }
    }

    /* IRQ handlers are located in flash. Disable them. */
    NutEnterCritical();

    /* Write command. */
    outr(AVR32_FLASHC.fcmd, AVR32_FLASHC_FCMD_KEY_KEY | cmd);

    /* Wait for ready flag set. */
    while (!flashc_is_ready()) {
        if (tmo && --tmo < 1) {
            rc = -1;
            break;
        }
    }

    /* Flash command finished. Re-enable IRQ handlers. */
    NutExitCritical();

    /* Check result. */
    if (AVR32_FLASHC.fsr & (AVR32_FLASHC_FSR_LOCKE_MASK | AVR32_FLASHC_FSR_PROGE_MASK)) {
        rc = -1;
    }
    return rc;
}

int Avr32FlashcSectorRead(unsigned int off, void *data, unsigned int len)
{
    memcpy(data, (void *) (uptr_t) (AVR32_FLASH_ADDRESS + off), len);

    return 0;
}

int Avr32FlashcSectorWrite(unsigned int off, CONST void *data, unsigned int len)
{
    flashptr_t dp = (flashptr_t) (uptr_t) (AVR32_FLASH_ADDRESS + off);
    int rc;
    unsigned int i;

    if (data) {
        flashptr_t sp = (flashptr_t) data;

        /* Copy data to the flash write buffer. */
        for (i = 0; i < len; i += sizeof(flashdat_t)) {
            *dp++ = *sp++;
        }
    } else {
        /* All bits set to emulate sector erasing. */
        for (i = 0; i < len; i += sizeof(flashdat_t)) {
            *dp++ = (flashdat_t) (-1);
        }
    }

    /* Erase target flash page. */
    Avr32FlashcSectorErase(off);
    /* Execute page write command. */
    rc = Avr32FlashcCmd((off & AVR32_FLASHC_FCMD_PAGEN_MASK) | AVR32_FLASHC_FCMD_CMD_WP, FLASH_WRITE_WAIT);

    return rc;
}

int Avr32FlashcSectorErase(unsigned int off)
{
    return Avr32FlashcCmd((off & AVR32_FLASHC_FCMD_PAGEN_MASK) | AVR32_FLASHC_FCMD_CMD_EP, FLASH_ERASE_WAIT);
}

int Avr32FlashcRegionLock(unsigned int off)
{
    return Avr32FlashcCmd((off & AVR32_FLASHC_FCMD_PAGEN_MASK) | AVR32_FLASHC_FCMD_CMD_LP, FLASH_WRITE_WAIT);
}

int Avr32FlashcRegionUnlock(unsigned int off)
{
    return Avr32FlashcCmd((off & AVR32_FLASHC_FCMD_PAGEN_MASK) | AVR32_FLASHC_FCMD_CMD_UP, FLASH_WRITE_WAIT);
}

int Avr32FlashcParamRead(unsigned int pos, void *data, unsigned int len)
{
    return Avr32FlashcSectorRead(FLASH_CONF_SECTOR + pos, data, len);
}

int Avr32FlashcParamWrite(unsigned int pos, CONST void *data, unsigned int len)
{
    int rc = -1;
    uint8_t *buff;

    /* Load the complete configuration area. */
    if ((buff = malloc(FLASH_CONF_SIZE)) != NULL) {

        rc = Avr32FlashcSectorRead(FLASH_CONF_SECTOR, buff, FLASH_CONF_SIZE);
        /* Compare old with new contents. */
        if (memcmp(buff + pos, data, len)) {
            /* New contents differs. Copy it into the sector buffer. */
            memcpy(buff + pos, data, len);
            /* Write back new data. Maintain region lock. */
            if (Avr32FlashcRegionUnlock(FLASH_CONF_SECTOR) == 0) {
                rc = Avr32FlashcSectorWrite(FLASH_CONF_SECTOR, buff, FLASH_CONF_SIZE);
                Avr32FlashcRegionLock(FLASH_CONF_SECTOR);
            }
        }
        free(buff);
    }
    return rc;
}