flash_avr.c

Go to the documentation of this file.

#include "flash_avr.h"

#include <avr/io.h>
#include <avr/boot.h>
#include <avr/pgmspace.h>

#include <cfg/macros.h> // MIN()
#include <cfg/compiler.h>
#include <cfg/debug.h>
#include <cpu/irq.h>

#include <drv/wdt.h>

#include <kern/kfile.h>

#include <string.h>

typedef uint16_t avr_page_addr_t;
typedef uint16_t avr_page_t;

static uint8_t page_buf[SPM_PAGESIZE];

bool page_modified;

static avr_page_t curr_page = 0;

/*
 * Private avr flush funtion.
 *
 * Write current buffered page in flash memory (if modified).
 * This function erase flash memory page before writing.
 *
 * This function is only use internaly in this module.
 */
static void flash_avr_flush(void)
{
    if (page_modified)
    {
        kprintf("Flushing page %d\n", curr_page);

        // Wait while the SPM instruction is busy.
        boot_spm_busy_wait();

        kprintf("Filling temparary page buffer...");

        // Fill the temporary buffer of the AVR
        for (avr_page_addr_t page_addr = 0; page_addr < SPM_PAGESIZE; page_addr += 2)
        {
            uint16_t word = ((uint16_t)page_buf[page_addr + 1] << 8) | page_buf[page_addr];

            ATOMIC(boot_page_fill(page_addr, word));
        }
        kprintf("Done.\n");

        wdt_reset();

        kprintf("Erasing page, addr %u...", curr_page * SPM_PAGESIZE);

        /* Page erase */
        ATOMIC(boot_page_erase(curr_page * SPM_PAGESIZE));

        /* Wait until the memory is erased. */
        boot_spm_busy_wait();

        kprintf("Done.\n");
        kprintf("Writing page, addr %u...", curr_page * SPM_PAGESIZE);

        /* Store buffer in flash page. */
        ATOMIC(boot_page_write(curr_page * SPM_PAGESIZE));
        boot_spm_busy_wait();  // Wait while the SPM instruction is busy.

        /*
        * Reenable RWW-section again. We need this if we want to jump back
        * to the application after bootloading.
        */
        ATOMIC(boot_rww_enable());

        page_modified = false;
        kprintf("Done.\n");
    }
}


static int flash_avr_kfileFlush(struct KFile * fd)
{
    KFILE_ASSERT_GENERIC(fd);
    (void)fd;
    flash_avr_flush();
    return 0;
}


static void flash_avr_loadPage(avr_page_t page)
{
    if (page != curr_page)
    {
        flash_avr_flush();
        // Load page
        memcpy_P(page_buf, (const char *)(page * SPM_PAGESIZE), SPM_PAGESIZE);
        curr_page = page;
        kprintf("Loaded page %d\n", curr_page);
    }
}

static size_t flash_avr_write(struct KFile *fd, const void *_buf, size_t size)
{
    KFILE_ASSERT_GENERIC(fd);
    const uint8_t *buf =(const uint8_t *)_buf;

    avr_page_t page;
    avr_page_addr_t page_addr;
    size_t total_write = 0;

    ASSERT(fd->seek_pos + size <= fd->size);
    size = MIN((uint32_t)size, fd->size - fd->seek_pos);

    kprintf("Writing at pos[%u]\n", fd->seek_pos);
    while (size)
    {
        page = fd->seek_pos / SPM_PAGESIZE;
        page_addr = fd->seek_pos % SPM_PAGESIZE;

        flash_avr_loadPage(page);

        size_t wr_len = MIN(size, SPM_PAGESIZE - page_addr);
        memcpy(page_buf + page_addr, buf, wr_len);
        page_modified = true;

        buf += wr_len;
        fd->seek_pos += wr_len;
        size -= wr_len;
        total_write += wr_len;
    }
    kprintf("written %u bytes\n", total_write);
    return total_write;
}

static void flash_avr_open(struct KFile *fd)
{
    KFILE_ASSERT_GENERIC(fd);
    curr_page = 0;
    memcpy_P(page_buf, (const char *)(curr_page * SPM_PAGESIZE), SPM_PAGESIZE);

    fd->seek_pos = 0;
    fd->size = (uint16_t)(FLASHEND - CONFIG_BOOT_SIZE + 1);
    page_modified = false;

    kprintf("Flash file opened\n");
}

static int flash_avr_close(UNUSED_ARG(struct KFile *,fd))
{
    KFILE_ASSERT_GENERIC(fd);
    flash_avr_flush();
    kprintf("Flash file closed\n");
    return 0;
}

static struct KFile *flash_avr_reopen(struct KFile *fd)
{
    KFILE_ASSERT_GENERIC(fd);
    flash_avr_close(fd);
    flash_avr_open(fd);
    return fd;
}


static size_t flash_avr_read(struct KFile *fd, void *buf, size_t size)
{
    KFILE_ASSERT_GENERIC(fd);
    ASSERT(fd->seek_pos + size <= fd->size);
    size = MIN((uint32_t)size, fd->size - fd->seek_pos);

    kprintf("Reading at pos[%u]\n", fd->seek_pos);
    // Flush current buffered page (if modified).
    flash_avr_flush();

    /*
     * AVR pointers are 16 bits wide, this hack is needed to avoid
     * compiler warning, cause fd->seek_pos is a 32bit offset.
     */
    const uint8_t *pgm_addr = (const uint8_t *)0;
    pgm_addr += fd->seek_pos;

    memcpy_P(buf, pgm_addr, size);
    fd->seek_pos += size;
    kprintf("Read %u bytes\n", size);
    return size;
}

void flash_avr_init(struct KFile *fd)
{
    memset(fd, 0, sizeof(*fd));
    DB(fd->_type = KFT_GENERIC);

    // Set up flash programming functions.
    fd->reopen = flash_avr_reopen;
    fd->close = flash_avr_close;
    fd->read = flash_avr_read;
    fd->write = flash_avr_write;
    fd->seek = kfile_genericSeek;
    fd->flush = flash_avr_kfileFlush;

    flash_avr_open(fd);
}