flash_avr.c

Go to the documentation of this file.

#include "flash_avr.h"

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

// Define log settings for cfg/log.h
#define LOG_LEVEL    CONFIG_FLASH_AVR_LOG_LEVEL
#define LOG_FORMAT   CONFIG_FLASH_AVR_LOG_FORMAT
#include <cfg/log.h>

#include <drv/wdt.h>

#include <kern/kfile.h>

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

#include <string.h>


typedef uint16_t avr_page_addr_t;




static void flash_avr_flush(FlashAvr *fd)
{
    if (fd->page_dirty)
    {

        LOG_INFO("Flushing page %d\n", fd->curr_page);

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

        LOG_INFO("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)fd->page_buf[page_addr + 1] << 8) | fd->page_buf[page_addr];

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

        wdt_reset();

        LOG_INFO("Erasing page, addr %u...", fd->curr_page * SPM_PAGESIZE);

        /* Page erase */
        ATOMIC(boot_page_erase(fd->curr_page * SPM_PAGESIZE));

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

        LOG_INFO("Done.\n");
        LOG_INFO("Writing page, addr %u...", fd->curr_page * SPM_PAGESIZE);

        /* Store buffer in flash page. */
        ATOMIC(boot_page_write(fd->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());

        fd->page_dirty = false;
        LOG_INFO("Done.\n");
    }
}


static int flash_avr_kfileFlush(struct KFile *_fd)
{
    FlashAvr *fd = FLASHAVR_CAST(_fd);
    flash_avr_flush(fd);
    return 0;
}


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

static size_t flash_avr_write(struct KFile *_fd, const void *_buf, size_t size)
{
    FlashAvr *fd = FLASHAVR_CAST(_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->fd.seek_pos + (kfile_off_t)size <= (kfile_off_t)fd->fd.size);
    size = MIN((kfile_off_t)size, fd->fd.size - fd->fd.seek_pos);

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

        flash_avr_loadPage(fd, page);

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

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

static void flash_avr_open(struct FlashAvr *fd)
{
    fd->curr_page = 0;
    memcpy_P(fd->page_buf, (const char *)(fd->curr_page * SPM_PAGESIZE), SPM_PAGESIZE);

    fd->fd.seek_pos = 0;
    fd->fd.size = (uint16_t)(FLASHEND - CONFIG_FLASH_AVR_BOOTSIZE + 1);
    fd->page_dirty = false;

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

static int flash_avr_close(struct KFile *_fd)
{
    FlashAvr *fd = FLASHAVR_CAST(_fd);
    flash_avr_flush(fd);
    LOG_INFO("Flash file closed\n");
    return 0;
}

static struct KFile *flash_avr_reopen(struct KFile *fd)
{
    FlashAvr *_fd = FLASHAVR_CAST(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)
{
    FlashAvr *fd = FLASHAVR_CAST(_fd);
    ASSERT(fd->fd.seek_pos + (kfile_off_t)size <= (kfile_off_t)fd->fd.size);
    size = MIN((kfile_off_t)size, fd->fd.size - fd->fd.seek_pos);

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

    /*
     * 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->fd.seek_pos;

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

void flash_avr_init(struct FlashAvr *fd)
{
    memset(fd, 0, sizeof(*fd));
    DB(fd->fd._type = KFT_FLASHAVR);

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

    flash_avr_open(fd);
}