/*
 * EP09 SPI Flash bootloader for PI-AR035-F1-1 / XC7A35T / CVE2.
 *
 * Flash map (GD25Q128, 16 MiB):
 *   0x000000..0xBFFFFF  FPGA bitstream / factory area (untouched)
 *   0xC00000..0xC7FFFF  slot A (512 KiB)
 *   0xC80000..0xCFFFFF  slot B (512 KiB)
 *   0xD00000 / 0xD01000 metadata sectors (alternating, 4 KiB erase)
 *
 * RAM map (64 KiB):
 *   0x0000..0x3FFF bootloader, stack top 0x4000
 *   0x4000..0xFFFF application, max 48 KiB
 *
 * UART loader frame (little endian):
 *   'P', slot(1), force(1), len(4), crc32(4), version(4), payload[len]
 */
#include <stdint.h>

#define UART_TX      (*(volatile unsigned char *)0x10000000u)
#define UART_STATUS  (*(volatile unsigned int  *)0x10000004u)
#define UART_RX      (*(volatile unsigned char *)0x10000008u)
#define WDT_ARM      (*(volatile unsigned int  *)0x30000000u)
#define WDT_KICK     (*(volatile unsigned int  *)0x30000004u)
#define WDT_CAUSE    (*(volatile unsigned int  *)0x30000008u)

#define SPI_CTRL     (*(volatile unsigned int  *)0x40010000u)
#define SPI_TX       (*(volatile unsigned int  *)0x40010004u)
#define SPI_RX       (*(volatile unsigned int  *)0x40010008u)
#define SPI_STATUS   (*(volatile unsigned int  *)0x4001000Cu)

#define APP_BASE     0x00004000u
#define APP_MAX      0x0000C000u
#define SLOT_A       0x00C00000u
#define SLOT_B       0x00C80000u
#define META_A       0x00D00000u
#define META_B       0x00D01000u

volatile unsigned int g_trap_count;
volatile unsigned int g_trap_cause;
volatile unsigned int g_trap_epc;

typedef struct {
    uint32_t magic;
    uint32_t seq;
    uint32_t slot;
    uint32_t len;
    uint32_t crc;
    uint32_t version;
    uint32_t attempts;
    uint32_t rec_crc;
} record_t;

static unsigned int spi_div = 4u;      /* 6.25 MHz */
static unsigned int spi_cs_flash_n = 1u;
static unsigned int spi_cs_sd_n = 1u;

static void delay(unsigned int n)
{
    volatile unsigned int i;
    for (i = 0u; i < n; ++i)
        __asm__ volatile ("nop");
}

static void putc(char c)
{
    while (UART_STATUS & 1u)
        ;
    UART_TX = (unsigned char)c;
}

static void puts(const char *s) { while (*s) putc(*s++); }

static void puthex(unsigned int v)
{
    int i;
    for (i = 28; i >= 0; i -= 4)
        putc("0123456789abcdef"[(v >> i) & 0xfu]);
}

static void putdec(unsigned int v)
{
    char b[10];
    int n = 0;
    if (!v) { putc('0'); return; }
    while (v && n < 10) { b[n++] = (char)('0' + v % 10u); v /= 10u; }
    while (n) putc(b[--n]);
}

static unsigned char uart_getc(void)
{
    while (!(UART_STATUS & 2u))
        ;
    return (unsigned char)(UART_RX & 0xffu);
}

static uint32_t crc32(const unsigned char *p, uint32_t n)
{
    uint32_t c = 0xffffffffu;
    uint32_t i, k;
    for (i = 0u; i < n; ++i) {
        c ^= p[i];
        for (k = 0u; k < 8u; ++k)
            c = (c >> 1) ^ (0xedb88320u & (0u - (c & 1u)));
    }
    return c ^ 0xffffffffu;
}

static void spi_apply(unsigned int start)
{
    SPI_CTRL = (spi_div << 8) | (spi_cs_flash_n << 1) |
               (spi_cs_sd_n << 2) | (start ? 1u : 0u);
}

static void spi_cs(unsigned int flash_n, unsigned int sd_n)
{
    spi_cs_flash_n = flash_n;
    spi_cs_sd_n = sd_n;
    spi_apply(0u);
}

static unsigned char spi_xfer(unsigned char out)
{
    unsigned int guard = 0u;
    SPI_TX = (unsigned int)out;
    spi_apply(1u);
    while ((SPI_STATUS & 1u) && guard++ < 100000u) ;
    guard = 0u;
    while (!(SPI_STATUS & 2u) && guard++ < 100000u) ;
    return (unsigned char)(SPI_RX & 0xffu);
}

static uint32_t flash_id(void)
{
    uint32_t id = 0u;
    int i;
    spi_cs(0u, 1u);
    spi_xfer(0x9fu);
    for (i = 0; i < 3; ++i) id = (id << 8) | spi_xfer(0xffu);
    spi_cs(1u, 1u);
    return id;
}

static void flash_reset(void)
{
    int i;
    spi_cs(1u, 1u);
    delay(20000u);
    for (i = 0; i < 8; ++i) spi_xfer(0xffu);
    spi_cs(0u, 1u); delay(1000u); spi_xfer(0x66u); spi_cs(1u, 1u); delay(5000u);
    spi_cs(0u, 1u); delay(1000u); spi_xfer(0x99u); spi_cs(1u, 1u); delay(5000u);
}

static int flash_wait(void)
{
    unsigned int guard = 0u;
    unsigned char st;
    do {
        spi_cs(0u, 1u);
        spi_xfer(0x05u);
        st = spi_xfer(0xffu);
        spi_cs(1u, 1u);
        if (guard++ > 2000000u) return 0;
    } while (st & 1u);
    return 1;
}

static void flash_read(uint32_t addr, unsigned char *buf, uint32_t len)
{
    uint32_t i;
    spi_cs(0u, 1u);
    spi_xfer(0x03u);
    spi_xfer((unsigned char)(addr >> 16));
    spi_xfer((unsigned char)(addr >> 8));
    spi_xfer((unsigned char)addr);
    for (i = 0u; i < len; ++i) buf[i] = spi_xfer(0xffu);
    spi_cs(1u, 1u);
}

static int flash_erase4k(uint32_t addr)
{
    spi_cs(1u, 1u);
    spi_cs(0u, 1u); spi_xfer(0x06u); spi_cs(1u, 1u);
    spi_cs(0u, 1u);
    spi_xfer(0x20u);
    spi_xfer((unsigned char)(addr >> 16));
    spi_xfer((unsigned char)(addr >> 8));
    spi_xfer((unsigned char)addr);
    spi_cs(1u, 1u);
    return flash_wait();
}

static int flash_page(uint32_t addr, const unsigned char *buf, uint32_t len)
{
    uint32_t i;
    spi_cs(1u, 1u);
    spi_cs(0u, 1u); spi_xfer(0x06u); spi_cs(1u, 1u);
    spi_cs(0u, 1u);
    spi_xfer(0x02u);
    spi_xfer((unsigned char)(addr >> 16));
    spi_xfer((unsigned char)(addr >> 8));
    spi_xfer((unsigned char)addr);
    for (i = 0u; i < len; ++i) spi_xfer(buf[i]);
    spi_cs(1u, 1u);
    return flash_wait();
}

static int write_region(uint32_t addr, const unsigned char *buf, uint32_t len)
{
    uint32_t off;
    for (off = 0u; off < len; off += 4096u) {
        if (!flash_erase4k(addr + off)) return 0;
    }
    for (off = 0u; off < len; off += 256u) {
        uint32_t n = (len - off > 256u) ? 256u : (len - off);
        if (!flash_page(addr + off, buf + off, n)) return 0;
    }
    return 1;
}

static uint32_t rec_crc(const record_t *r)
{
    return crc32((const unsigned char *)r, 28u);
}

static int rec_valid(const record_t *r)
{
    return r->magic == 0x45503952u && r->slot <= 1u &&
           r->len <= APP_MAX && r->rec_crc == rec_crc(r);
}

static int read_record(uint32_t addr, record_t *r)
{
    flash_read(addr, (unsigned char *)r, sizeof(*r));
    return rec_valid(r);
}

static int write_record(uint32_t addr, record_t *r)
{
    r->magic = 0x45503952u;
    r->rec_crc = rec_crc(r);
    return write_region(addr, (const unsigned char *)r, sizeof(*r));
}

static uint32_t slot_base(uint32_t slot) { return slot ? SLOT_B : SLOT_A; }
static uint32_t meta_base(uint32_t seq) { return (seq & 1u) ? META_B : META_A; }

static void reboot(void)
{
    puts("REBOOT\r\n");
    WDT_ARM = 1u;
    while (1) ;
}

static int load_and_jump(uint32_t slot, const record_t *r)
{
    unsigned char *dst = (unsigned char *)APP_BASE;
    uint32_t got;
    puts("LOAD SLOT="); putc(slot ? 'B' : 'A');
    puts(" LEN="); putdec(r->len);
    puts(" VER="); puthex(r->version);
    flash_read(slot_base(slot), dst, r->len);
    got = crc32(dst, r->len);
    puts(" CRC="); puthex(got);
    if (got != r->crc) {
        puts(" LOAD_FAIL\r\n");
        return 0;
    }
    puts(" LOAD_PASS\r\n");
    __asm__ volatile ("fence.i");
    {
        register uint32_t a0 __asm__("a0") = r->version;
        __asm__ volatile ("mv sp, %0\n jr %1" : : "r"(0x00010000u), "r"(APP_BASE), "r"(a0));
    }
    return 0;
}

static int boot(void)
{
    record_t a, b, best, other;
    int va, vb, have = 0, have_other = 0;
    va = read_record(META_A, &a);
    vb = read_record(META_B, &b);
    if (va && (!vb || a.seq >= b.seq)) { best = a; other = b; have = 1; have_other = vb; }
    if (vb && (!va || b.seq >  a.seq)) { best = b; other = a; have = 1; have_other = va; }
    if (!have) { puts("NO_VALID_META\r\n"); return 0; }

    if (load_and_jump(best.slot, &best)) return 1;

    if (have_other && other.slot != best.slot) {
        puts("FALLBACK\r\n");
        if (!load_and_jump(other.slot, &other)) return 1;
    }
    puts("NO_BOOTABLE_IMAGE\r\n");
    return 0;
}

static void loader(void)
{
    unsigned char hdr[15];
    uint32_t force;
    record_t r;
    unsigned char *buf = (unsigned char *)APP_BASE;
    uint32_t i, got;

    puts("LOADER READY\r\n");
    /* Drop any bytes left in the RX FIFO before waiting for a real frame. */
    while (UART_STATUS & 2u)
        (void)UART_RX;

    for (;;) {
    hdr[0] = uart_getc();                 /* 'P' */
    for (i = 1u; i < sizeof(hdr); ++i) hdr[i] = uart_getc();
    if (hdr[0] != 'P') { puts("BAD_FRAME\r\n"); continue; }
    r.slot = hdr[1];
    force  = hdr[2];
    r.len  = (uint32_t)hdr[3] | ((uint32_t)hdr[4] << 8) |
             ((uint32_t)hdr[5] << 16) | ((uint32_t)hdr[6] << 24);
    r.crc  = (uint32_t)hdr[7] | ((uint32_t)hdr[8] << 8) |
             ((uint32_t)hdr[9] << 16) | ((uint32_t)hdr[10] << 24);
    r.version = (uint32_t)hdr[11] | ((uint32_t)hdr[12] << 8) |
                ((uint32_t)hdr[13] << 16) | ((uint32_t)hdr[14] << 24);
    if (r.slot > 1u || r.len > APP_MAX) { puts("BAD_FRAME\r\n"); continue; }

    puts("RECV SLOT="); putc(r.slot ? 'B' : 'A');
    puts(" LEN="); putdec(r.len); puts("...\r\n");
    for (i = 0u; i < r.len; ++i) buf[i] = uart_getc();
    got = crc32(buf, r.len);
    puts("RX_CRC="); puthex(got); puts(" EXPECT="); puthex(r.crc); puts("\r\n");
    if (got != r.crc && !force) {
        puts("CRC_MISMATCH_ABORT\r\n");
        continue;
    }

    if (!write_region(slot_base(r.slot), buf, r.len)) {
        puts("PROGRAM_FAIL\r\n");
        continue;
    }
    puts("PROGRAM_PASS\r\n");

    /* Re-read both records to keep the sequence monotonic. */
    record_t ma, mb;
    int va = read_record(META_A, &ma);
    int vb = read_record(META_B, &mb);
    uint32_t seq = 1u;
    if (va) seq = ma.seq + 1u;
    if (vb && mb.seq + 1u > seq) seq = mb.seq + 1u;
    r.seq = seq;
    r.attempts = 0u;
    if (!write_record(meta_base(seq), &r)) { puts("META_FAIL\r\n"); continue; }
    puts("META_PASS SEQ="); putdec(seq);
    puts(" ACTIVE="); putc(r.slot ? 'B' : 'A'); puts("\r\n");
    /* Switch without a chip reset: re-check the image and jump to it. */
    if (!load_and_jump(r.slot, &r)) {
        puts("SWITCH_FAIL\r\n");
        /* Bad metadata is expected in the forced-failure test: let boot()
         * select the older good slot and jump there without a chip reset. */
        if (!boot())
            puts("NO_BOOTABLE_IMAGE\r\n");
        continue;
    }
    }
}

int main(void)
{
    record_t r;
    int i;
    puts("\r\nEP09 FLASH BOOTLOADER\r\n");
    flash_reset();
    r.magic = flash_id();
    puts("FLASH ID="); puthex(r.magic); puts(r.magic == 0x00c84018u ? " OK\r\n" : " BAD\r\n");

    /* 1 s window to enter loader after reset; a blank board enters it too. */
    puts("PRESS L FOR LOADER (3s)...\r\n");
    for (i = 0; i < 1500000; ++i) {
        delay(100u);
        if ((UART_STATUS & 2u) && (UART_RX & 0xffu) == 'L') {
            loader();
        }
    }
    boot();
    loader();
    return 0;
}
