/*
 * PI-AR035-F1-1 / CVE2 EP03 board control core.
 * ACM:* compatible UART command plane, LED/KEY, QSPI Flash, I2C EEPROM,
 * TF card probe and a 500 ms watchdog.
 */
#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 LED_REG      (*(volatile unsigned int  *)0x40000000u)
#define KEY_REG      (*(volatile unsigned int  *)0x40010000u)
#define GPIO_OUT     (*(volatile unsigned int  *)0x40020000u)
#define GPIO_IN      (*(volatile unsigned int  *)0x40020004u)
#define DBG_REG      (*(volatile unsigned int  *)0x40030000u)

#define WDT_ARM      (*(volatile unsigned int  *)0x30000000u)
#define WDT_KICK     (*(volatile unsigned int  *)0x30000004u)
#define WDT_CAUSE    (*(volatile unsigned int  *)0x30000008u)
#define WDT_STATUS   (*(volatile unsigned int  *)0x3000000Cu)

#define G_FLASH_CS   (1u << 0)
#define G_FLASH_SCLK (1u << 1)
#define G_FLASH_MOSI (1u << 2)
#define G_FLASH_WP   (1u << 3)
#define G_FLASH_HOLD (1u << 4)
#define G_SD_CS      (1u << 5)
#define G_SD_SCLK    (1u << 6)
#define G_SD_MOSI    (1u << 7)
#define G_I2C_SCL_L  (1u << 8)
#define G_I2C_SDA_L  (1u << 9)

#define IN_FLASH_MISO (1u << 0)
#define IN_SD_MISO    (1u << 1)
#define IN_I2C_SCL    (1u << 2)
#define IN_I2C_SDA    (1u << 3)

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

static unsigned int gpio_shadow = 0x0039u; /* CS high, WP/HOLD high, I2C released */
static unsigned int led_shadow;
static unsigned int eeprom_data;
static unsigned int eeprom_ok;
static unsigned int flash_id;

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) {
        unsigned int n = (v >> i) & 0xfu;
        putc(n < 10u ? (char)('0' + n) : (char)('a' + n - 10u));
    }
}

static int match(const char *line, const char *text)
{
    while (*text) {
        if (*line++ != *text++)
            return 0;
    }
    return *line == '\0';
}

static const char *prefix(const char *line, const char *head)
{
    while (*head) {
        if (*line++ != *head++)
            return 0;
    }
    return line;
}

static void gpio_write(void)
{
    GPIO_OUT = gpio_shadow;
}

static void gpio_set(unsigned int bits)
{
    gpio_shadow |= bits;
    gpio_write();
}

static void gpio_clear(unsigned int bits)
{
    gpio_shadow &= ~bits;
    gpio_write();
}

static void led_write(unsigned int v)
{
    led_shadow = v & 0xffu;
    LED_REG = led_shadow;
}

static unsigned int led_read(void)
{
    return LED_REG & 0xffu;
}

/* ---------------- QSPI Flash: JEDEC ID 0x9F ---------------- */
static unsigned char flash_xfer(unsigned char out)
{
    unsigned char in = 0u;
    int i;
    for (i = 0; i < 8; ++i) {
        if (out & 0x80u)
            gpio_set(G_FLASH_MOSI);
        else
            gpio_clear(G_FLASH_MOSI);
        delay(8u);
        gpio_set(G_FLASH_SCLK);
        delay(8u);
        in = (unsigned char)((in << 1) | ((GPIO_IN & IN_FLASH_MISO) ? 1u : 0u));
        gpio_clear(G_FLASH_SCLK);
        delay(8u);
        out = (unsigned char)(out << 1);
    }
    return in;
}

static int probe_flash(void)
{
    unsigned int id;
    int i;
    gpio_set(G_FLASH_CS | G_FLASH_WP | G_FLASH_HOLD);
    gpio_clear(G_FLASH_SCLK | G_FLASH_MOSI);
    delay(20u);
    /* STARTUPE2 takes over CCLK here; send 8 dummy clocks with CS# high
       to leave continuous-read state left by the boot ROM. */
    for (i = 0; i < 8; ++i)
        flash_xfer(0xFFu);

    /* Leave QPI if a previous design enabled it: FFh is "Disable QPI" in
       QPI mode and a harmless no-op in standard SPI. Then issue the
       software reset pair 66h/99h. */
    gpio_clear(G_FLASH_CS);
    delay(20u);
    flash_xfer(0xFFu);
    gpio_set(G_FLASH_CS);
    delay(200u);

    gpio_clear(G_FLASH_CS);
    delay(20u);
    flash_xfer(0x66u);
    gpio_set(G_FLASH_CS);
    delay(200u);

    gpio_clear(G_FLASH_CS);
    delay(20u);
    flash_xfer(0x99u);
    gpio_set(G_FLASH_CS);
    delay(50000u);

    gpio_clear(G_FLASH_CS);
    delay(20u);
    flash_xfer(0x9Fu);
    id  = (unsigned int)flash_xfer(0x00u) << 16;
    id |= (unsigned int)flash_xfer(0x00u) << 8;
    id |= (unsigned int)flash_xfer(0x00u);
    gpio_set(G_FLASH_CS);
    delay(20u);
    flash_id = id;
    return (id == 0x00C84018u) ? 1 : 0;
}

/* ---------------- I2C EEPROM: read byte at 0x00 ---------------- */
static void i2c_scl_high(void) { gpio_clear(G_I2C_SCL_L); delay(40u); }
static void i2c_scl_low(void)  { gpio_set(G_I2C_SCL_L);   delay(40u); }
static void i2c_sda_high(void) { gpio_clear(G_I2C_SDA_L); delay(40u); }
static void i2c_sda_low(void)  { gpio_set(G_I2C_SDA_L);   delay(40u); }

static void i2c_start(void)
{
    i2c_sda_high();
    i2c_scl_high();
    i2c_sda_low();
    i2c_scl_low();
}

static void i2c_stop(void)
{
    i2c_sda_low();
    i2c_scl_high();
    i2c_sda_high();
}

static int i2c_write_bit(unsigned int bit)
{
    if (bit)
        i2c_sda_high();
    else
        i2c_sda_low();
    i2c_scl_high();
    i2c_scl_low();
    return 0;
}

static int i2c_write_byte(unsigned int v)
{
    int i, ack;
    for (i = 7; i >= 0; --i)
        i2c_write_bit((v >> i) & 1u);
    i2c_sda_high();
    i2c_scl_high();
    ack = (GPIO_IN & IN_I2C_SDA) ? 1 : 0;
    i2c_scl_low();
    return ack;
}

static unsigned int i2c_read_byte(void)
{
    unsigned int v = 0u;
    int i;
    i2c_sda_high();
    for (i = 0; i < 8; ++i) {
        i2c_scl_high();
        v = (v << 1) | ((GPIO_IN & IN_I2C_SDA) ? 1u : 0u);
        i2c_scl_low();
    }
    /* master NACK */
    i2c_sda_high();
    i2c_scl_high();
    i2c_scl_low();
    return v & 0xffu;
}

static int probe_eeprom(void)
{
    int ack1, ack2, ack3;
    unsigned int v;
    gpio_clear(G_I2C_SCL_L | G_I2C_SDA_L);
    delay(100u);
    i2c_start();
    ack1 = i2c_write_byte(0xA0u);
    ack2 = i2c_write_byte(0x00u);
    i2c_start();
    ack3 = i2c_write_byte(0xA1u);
    v = i2c_read_byte();
    i2c_stop();
    delay(100u);
    eeprom_data = v;
    eeprom_ok = (ack1 == 0 && ack2 == 0 && ack3 == 0) ? 1u : 0u;
    return (int)eeprom_ok;
}

/* ---------------- TF card: SPI CMD0 ---------------- */
static unsigned char sd_xfer(unsigned char out)
{
    unsigned char in = 0u;
    int i;
    for (i = 0; i < 8; ++i) {
        if (out & 0x80u)
            gpio_set(G_SD_MOSI);
        else
            gpio_clear(G_SD_MOSI);
        delay(8u);
        gpio_set(G_SD_SCLK);
        delay(8u);
        in = (unsigned char)((in << 1) | ((GPIO_IN & IN_SD_MISO) ? 1u : 0u));
        gpio_clear(G_SD_SCLK);
        delay(8u);
        out = (unsigned char)(out << 1);
    }
    return in;
}

static int probe_sd(void)
{
    unsigned char r = 0xFFu;
    int i;
    gpio_set(G_SD_CS | G_SD_MOSI);
    gpio_clear(G_SD_SCLK);
    for (i = 0; i < 10; ++i)
        sd_xfer(0xFFu);
    gpio_clear(G_SD_CS);
    sd_xfer(0x40u); /* CMD0 */
    sd_xfer(0x00u);
    sd_xfer(0x00u);
    sd_xfer(0x00u);
    sd_xfer(0x00u);
    sd_xfer(0x95u);
    for (i = 0; i < 8; ++i) {
        r = sd_xfer(0xFFu);
        if (r != 0xFFu)
            break;
    }
    gpio_set(G_SD_CS);
    sd_xfer(0xFFu);
    if (r == 0x01u)
        return 1;
    if (r == 0xFFu)
        return 0; /* no response: wait, not a hard error */
    return -1;
}

/* ---------------- ACM response helpers ---------------- */
static void result(const char *name, int state)
{
    puts("ACS:Auto=");
    puts(name);
    if (state == 1)
        puts(",result=ok\r\n");
    else if (state == 0)
        puts(",result=wait\r\n");
    else
        puts(",result=err\r\n");
}

static void auto_one(const char *name)
{
    if (match(name, "FLASH"))
        result("FLASH", probe_flash() ? 1 : -1);
    else if (match(name, "EEPROM"))
        result("EEPROM", probe_eeprom() ? 1 : -1);
    else if (match(name, "SD"))
        result("SD", probe_sd());
    else if (match(name, "DDR3") || match(name, "ETH1") ||
             match(name, "MIPI") || match(name, "ADC") ||
             match(name, "HDMI_IN"))
        result(name, 0);
}

static void auto_all(void)
{
    result("DDR3", 0);
    result("FLASH", probe_flash() ? 1 : -1);
    result("EEPROM", probe_eeprom() ? 1 : -1);
    result("SD", probe_sd());
    result("ETH1", 0);
    result("MIPI", 0);
    result("ADC", 0);
    result("HDMI_IN", 0);
}

static void send_support(void)
{
    puts("ACS:Support,Auto=DDR3,Auto=FLASH,Auto=EEPROM,Auto=SD,Auto=ETH1,"
         "Auto=MIPI,Auto=ADC,Auto=HDMI_IN,GpioIn=KEY1,GpioIn=KEY2,"
         "GpioOut=LED1,GpioOut=LED2,GpioOut=LED3,GpioOut=LED4,"
         "GpioOut=LED5,GpioOut=LED6,GpioOut=LED7,GpioOut=LED8,"
         "Test=LED,Test=WDT\r\n");
}

static void keys_report(void)
{
    unsigned int k = KEY_REG;
    int i;
    for (i = 0; i < 2; ++i) {
        puts("ACS:GpioIn=KEY");
        putc((char)('1' + i));
        puts((k & (1u << i)) ? ",status=on" : ",status=off");
        puts((k & (1u << (i + 2))) ? ",seen=1\r\n" : ",seen=0\r\n");
    }
}

static void led_test(void)
{
    int i;
    for (i = 0; i < 8; ++i) {
        led_write(1u << i);
        delay(120000u);
    }
    led_write(0xFFu);
    delay(120000u);
    led_write(0x00u);
    delay(120000u);
    gpio_set(G_FLASH_CS | G_SD_CS | G_FLASH_WP | G_FLASH_HOLD);
    puts("LED TEST=PASS\r\n");
}

static void command(const char *line)
{
    const char *arg;
    if (match(line, "ACM:Support")) {
        send_support();
    } else if (match(line, "ACM:Auto")) {
        auto_all();
    } else if ((arg = prefix(line, "ACM:Auto=")) != 0) {
        auto_one(arg);
    } else if (match(line, "ACM:Start=Storage")) {
        puts("ACS:Start=Storage\r\n");
        result("FLASH", probe_flash() ? 1 : -1);
        result("EEPROM", probe_eeprom() ? 1 : -1);
        result("SD", probe_sd());
    } else if (match(line, "ACM:GpioIn")) {
        keys_report();
    } else if ((arg = prefix(line, "ACM:GpioOut=LED")) != 0 &&
               *arg >= '1' && *arg <= '8') {
        unsigned int bit = 1u << (*arg++ - '1');
        if (match(arg, ",set=on"))
            led_write(led_shadow | bit);
        else if (match(arg, ",set=off"))
            led_write(led_shadow & ~bit);
        else
            return;
        puts("ACS:GpioOut=ok\r\n");
    } else if (match(line, "ACM:Test=LED")) {
        led_test();
    } else if (match(line, "ACM:Test=WDT") || match(line, "ACM:Watchdog")) {
        puts("ACS:Test=WDT,armed\r\n");
        WDT_ARM = 1u;
        for (;;)
            ;
    } else if (match(line, "ACM:Version")) {
        puts("ACS:Version=EP03-CVE2-BOARD-CONTROL\r\n");
    } else {
        puts("ACS:Error=unknown-command\r\n");
    }
}

int main(void)
{
    char line[68];
    unsigned int len = 0u;
    unsigned int discard = 0u;
    unsigned int cause;
    int f, e, s;

    delay(300000u); /* let STARTUPE2 release CCLK after configuration */

    cause = WDT_CAUSE & 1u;
    puts("\r\nALINX AR035 CVE2 Board Control EP03\r\n");
    puts(cause ? "BOOT CAUSE=WDT\r\n" : "BOOT CAUSE=POR/EXT\r\n");

    f = probe_flash();
    puts("CFG=");
    puthex(DBG_REG);
    puts("\r\n");
    e = probe_eeprom();
    s = probe_sd();

    puts("FLASH ID=");
    puthex(flash_id);
    puts(f ? " OK\r\n" : " ERR\r\n");
    puts("EEPROM DATA=");
    puthex(eeprom_data);
    puts(e ? " ACK\r\n" : " NACK\r\n");
    puts("SD R1=");
    puthex((unsigned int)(s == 1 ? 0x01u : (s == 0 ? 0xFFu : 0xEEu)));
    puts(s == 1 ? " OK\r\n" : " WAIT/ERR\r\n");

    led_test();

    puts("KEY1=");
    putc((KEY_REG & 1u) ? '1' : '0');
    puts(" KEY2=");
    putc((KEY_REG & 2u) ? '1' : '0');
    puts("\r\nREADY\r\n");

    for (;;) {
        if ((UART_STATUS & 2u) == 0u)
            continue;
        {
            char c = (char)(UART_RX & 0xffu);
            if (c == '\r' || c == '\n') {
                if (!discard && len != 0u) {
                    line[len] = '\0';
                    command(line);
                }
                len = 0u;
                discard = 0u;
            } else if (c < ' ' || c > '~' || len >= sizeof(line) - 1u) {
                discard = 1u;
            } else if (!discard) {
                line[len++] = c;
            }
        }
    }
}
