/*
 * PI-AR035-F1-1 / XC7A35T CVE2 EP04 peripheral bus matrix.
 *
 * This firmware is both the power-on self test and the ACM:* UART command
 * plane. It drives hardware SPI (QSPI Flash + TF card), hardware I2C
 * (board EEPROM), four PWM channels with CH0 edge capture, GPIO, the
 * bus monitor and the aggregated interrupt controller.
 *
 * No oscilloscope or signal generator is required: PWM is measured by the
 * FPGA capture logic itself, and the page states that this is functional
 * evidence rather than waveform-level evidence.
 */
#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 WDT_STATUS     (*(volatile unsigned int  *)0x3000000Cu)

#define GPIO_OUT       (*(volatile unsigned int  *)0x40000000u)
#define GPIO_IN        (*(volatile unsigned int  *)0x40000004u)
#define GPIO_DIR       (*(volatile unsigned int  *)0x40000008u)
#define GPIO_SET       (*(volatile unsigned int  *)0x4000000Cu)
#define GPIO_CLR       (*(volatile unsigned int  *)0x40000010u)
#define GPIO_TOG       (*(volatile unsigned int  *)0x40000014u)

#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 I2C_CTRL       (*(volatile unsigned int  *)0x40020000u)
#define I2C_TX         (*(volatile unsigned int  *)0x40020004u)
#define I2C_RX         (*(volatile unsigned int  *)0x40020008u)
#define I2C_STATUS     (*(volatile unsigned int  *)0x4002000Cu)

#define PWM_CH0_PERIOD (*(volatile unsigned int  *)0x40030000u)
#define PWM_CH0_DUTY   (*(volatile unsigned int  *)0x40030004u)
#define PWM_CH0_CTRL   (*(volatile unsigned int  *)0x40030008u)
#define PWM_CH1_PERIOD (*(volatile unsigned int  *)0x40030010u)
#define PWM_CH1_DUTY   (*(volatile unsigned int  *)0x40030014u)
#define PWM_CH1_CTRL   (*(volatile unsigned int  *)0x40030018u)
#define PWM_CH2_PERIOD (*(volatile unsigned int  *)0x40030020u)
#define PWM_CH2_DUTY   (*(volatile unsigned int  *)0x40030024u)
#define PWM_CH2_CTRL   (*(volatile unsigned int  *)0x40030028u)
#define PWM_CH3_PERIOD (*(volatile unsigned int  *)0x40030030u)
#define PWM_CH3_DUTY   (*(volatile unsigned int  *)0x40030034u)
#define PWM_CH3_CTRL   (*(volatile unsigned int  *)0x40030038u)
#define PWM_CAP_PERIOD (*(volatile unsigned int  *)0x40030040u)
#define PWM_CAP_HIGH   (*(volatile unsigned int  *)0x40030044u)
#define PWM_CAP_STATUS (*(volatile unsigned int  *)0x40030048u)

#define BUS_TXN        (*(volatile unsigned int  *)0x40040000u)
#define BUS_RD         (*(volatile unsigned int  *)0x40040004u)
#define BUS_WR         (*(volatile unsigned int  *)0x40040008u)
#define BUS_WAIT       (*(volatile unsigned int  *)0x4004000Cu)
#define BUS_ERR        (*(volatile unsigned int  *)0x40040010u)
#define BUS_IRQ_STATUS (*(volatile unsigned int  *)0x40040014u)
#define BUS_IRQ_ENABLE (*(volatile unsigned int  *)0x40040018u)
#define BUS_IRQ_CLEAR  (*(volatile unsigned int  *)0x4004001Cu)
#define BUS_LAST_ADDR  (*(volatile unsigned int  *)0x40040020u)

#define DBG_REG        (*(volatile unsigned int  *)0x40050000u)
#define DBG_VERSION    (*(volatile unsigned int  *)0x40050004u)
#define DBG_SCL_EDGES  (*(volatile unsigned int  *)0x40050008u)
#define DBG_SDA_EDGES  (*(volatile unsigned int  *)0x4005000Cu)
#define DBG_SCL_PERIOD (*(volatile unsigned int  *)0x40050010u)

#define IRQ_SPI        (1u << 0)
#define IRQ_I2C        (1u << 1)
#define IRQ_PWM        (1u << 2)
#define IRQ_KEY        (1u << 3)
#define IRQ_BUS        (1u << 4)

volatile unsigned int g_trap_count;
volatile unsigned int g_trap_cause;
volatile unsigned int g_trap_epc;
volatile unsigned int g_irq_count;
volatile unsigned int g_last_irq;

static unsigned int led_shadow;
static unsigned int eeprom_data;
static unsigned int eeprom_ok;
static unsigned int flash_id;
static unsigned int sd_r1;
static unsigned int spi_div = 124u;
static unsigned int spi_cs_flash_n = 1u;
static unsigned int spi_cs_sd_n = 1u;
static unsigned int i2c_div = 240u;
static unsigned int pwm_period_cap;
static unsigned int pwm_high_cap;
static unsigned int pwm_freq;
static unsigned int pwm_duty_permille;

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 buf[12];
    int i = 0;
    if (v == 0u) {
        putc('0');
        return;
    }
    while (v && i < 10) {
        buf[i++] = (char)('0' + (v % 10u));
        v /= 10u;
    }
    while (i > 0)
        putc(buf[--i]);
}

static int starts(const char *s, const char *p)
{
    while (*p) {
        if (*s++ != *p++)
            return 0;
    }
    return 1;
}

static int streq(const char *a, const char *b)
{
    while (*a && *b) {
        if (*a++ != *b++)
            return 0;
    }
    return (*a == *b);
}

static int contains(const char *s, const char *p)
{
    while (*s) {
        const char *x = s;
        const char *y = p;
        while (*x && *y && *x == *y) {
            ++x;
            ++y;
        }
        if (!*y)
            return 1;
        ++s;
    }
    return 0;
}

/* ------------------------------------------------------------------ */
/* SPI: one clock/MOSI generator, two chip selects, MISO mux.          */
/* ------------------------------------------------------------------ */
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)
{
    SPI_TX = (unsigned int)out;
    spi_apply(1u);
    delay(8u);
    while (SPI_STATUS & 1u)
        ;
    while (!(SPI_STATUS & 2u))
        ;
    return (unsigned char)(SPI_RX & 0xffu);
}

static int probe_flash(void)
{
    unsigned int id = 0u;
    int i;

    spi_div = 4u; /* 6.25 MHz */
    spi_cs(1u, 1u);
    delay(20000u);

    /* 8 dummy clocks while CS is high, then exit QPI and soft reset. */
    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);

    spi_cs(0u, 1u);
    delay(1000u);
    spi_xfer(0xabu);
    spi_cs(1u, 1u);
    delay(5000u);

    spi_cs(0u, 1u);
    delay(1000u);
    spi_xfer(0x9fu);
    for (i = 0; i < 3; ++i)
        id = (id << 8) | (unsigned int)spi_xfer(0xffu);
    spi_cs(1u, 1u);
    delay(1000u);

    flash_id = id;
    return (id == 0x00c84018u);
}

static int probe_sd(void)
{
    unsigned char r = 0xffu;
    int i;

    spi_div = 124u; /* about 200 kHz for CMD0 */
    spi_cs(1u, 1u);
    delay(50000u);
    for (i = 0; i < 10; ++i)
        spi_xfer(0xffu);

    spi_cs(1u, 0u);
    spi_xfer(0x40u);
    spi_xfer(0x00u);
    spi_xfer(0x00u);
    spi_xfer(0x00u);
    spi_xfer(0x00u);
    spi_xfer(0x95u);
    for (i = 0; i < 8; ++i) {
        r = spi_xfer(0xffu);
        if (r != 0xffu)
            break;
    }
    spi_cs(1u, 1u);
    spi_xfer(0xffu);

    sd_r1 = (unsigned int)r;
    if (r == 0x01u)
        return 1;
    if (r == 0xffu)
        return 0; /* no card / no response */
    return -1;
}

/* ------------------------------------------------------------------ */
/* I2C: byte-level hardware master, open drain.                        */
/* ------------------------------------------------------------------ */
static int i2c_wait_done(void)
{
    unsigned int t = 200000u;

    delay(8u);
    while (!(I2C_STATUS & 1u) && t)
        --t;
    if (!t)
        return -2;

    t = 200000u;
    while ((I2C_STATUS & 1u) && t)
        --t;
    if (!t)
        return -2;

    t = 200000u;
    while (!(I2C_STATUS & 4u) && t)
        --t;
    if (!t)
        return -2;
    return 0;
}

static int i2c_wait_ack(void)
{
    int r = i2c_wait_done();
    if (r)
        return r;
    return (I2C_STATUS & 2u) ? -1 : 0;
}

static int i2c_start_write(unsigned char b)
{
    I2C_TX = (unsigned int)b;
    I2C_CTRL = (i2c_div << 8) | 0x02u;
    return i2c_wait_ack();
}

static int i2c_write_byte(unsigned char b)
{
    I2C_TX = (unsigned int)b;
    I2C_CTRL = (i2c_div << 8) | 0x10u;
    return i2c_wait_ack();
}

static int i2c_read_byte(unsigned char *v)
{
    int r;
    I2C_CTRL = (i2c_div << 8) | 0x04u;
    r = i2c_wait_done();
    *v = (unsigned char)(I2C_RX & 0xffu);
    return r;
}

static void i2c_stop(void)
{
    I2C_CTRL = (i2c_div << 8) | 0x08u;
    (void)i2c_wait_done();
}

static int probe_eeprom(void)
{
    unsigned char v = 0u;
    int a1, a2, a3;

    i2c_stop();
    delay(100u);
    a1 = i2c_start_write(0xa0u);
    if (a1) {
        puts("EEPROM STAGE=1\r\n");
        i2c_stop();
        eeprom_ok = 0u;
        return 0;
    }
    a2 = i2c_write_byte(0x00u);
    if (a2) {
        puts("EEPROM STAGE=2\r\n");
        i2c_stop();
        eeprom_ok = 0u;
        return 0;
    }
    a3 = i2c_start_write(0xa1u);
    if (a3) {
        puts("EEPROM STAGE=3\r\n");
        i2c_stop();
        eeprom_ok = 0u;
        return 0;
    }
    (void)i2c_read_byte(&v);
    i2c_stop();

    eeprom_data = (unsigned int)v;
    eeprom_ok = 1u;
    return 1;
}

/* ------------------------------------------------------------------ */
/* PWM: functional self-test through CH0 capture, no scope needed.     */
/* ------------------------------------------------------------------ */
static void pwm_disable_all(void)
{
    PWM_CH0_CTRL = 0u;
    PWM_CH1_CTRL = 0u;
    PWM_CH2_CTRL = 0u;
    PWM_CH3_CTRL = 0u;
}

static int pwm_measure(int verbose)
{
    pwm_period_cap = 0u;
    pwm_high_cap = 0u;

    PWM_CH0_PERIOD = 50000u;
    PWM_CH0_DUTY = 25000u;
    PWM_CH0_CTRL = 1u;
    delay(1000000u);

    pwm_period_cap = PWM_CAP_PERIOD & 0xffffffffu;
    pwm_high_cap = PWM_CAP_HIGH & 0xffffffffu;

    if (pwm_period_cap == 0u) {
        puts("PWM CAP PERIOD=00000000 HIGH=");
        puthex(pwm_high_cap);
        puts("\r\n");
        return 0;
    }

    pwm_freq = 50000000u / pwm_period_cap;
    pwm_duty_permille = (pwm_high_cap * 1000u) / pwm_period_cap;

    if (verbose) {
        puts("PWM PERIOD=");
        puthex(pwm_period_cap);
        puts(" HIGH=");
        puthex(pwm_high_cap);
        puts(" FREQ=");
        putdec(pwm_freq);
        puts(" DUTY=");
        putdec(pwm_duty_permille);
        puts("/1000\r\n");
    }

    return (pwm_period_cap >= 49000u && pwm_period_cap <= 51000u &&
            pwm_high_cap >= 24500u && pwm_high_cap <= 25500u);
}

/* ------------------------------------------------------------------ */
/* Bus error + IRQ tests.                                             */
/* ------------------------------------------------------------------ */
static volatile unsigned int sink;

static int bus_error_test(void)
{
    g_trap_count = 0u;
    g_trap_cause = 0u;
    sink = *(volatile unsigned int *)0x50000000u;
    if (g_trap_count != 1u || g_trap_cause != 5u)
        return 0;

    g_trap_count = 0u;
    g_trap_cause = 0u;
    *(volatile unsigned int *)0x50000000u = 0x12345678u;
    if (g_trap_count != 1u || g_trap_cause != 7u)
        return 0;

    return 1;
}

static int irq_test(void)
{
    unsigned int t;

    pwm_disable_all();
    PWM_CH0_PERIOD = 50000u;
    PWM_CH0_DUTY = 25000u;
    PWM_CH0_CTRL = 1u;

    g_irq_count = 0u;
    g_last_irq = 0u;
    BUS_IRQ_CLEAR = 0x1fu;
    BUS_IRQ_ENABLE = IRQ_PWM;

    __asm__ volatile ("csrs mie, %0" : : "r" (0x800u));
    __asm__ volatile ("csrs mstatus, %0" : : "r" (0x8u));

    for (t = 0u; t < 2000000u && g_irq_count == 0u; ++t)
        ;

    __asm__ volatile ("csrc mstatus, %0" : : "r" (0x8u));
    __asm__ volatile ("csrc mie, %0" : : "r" (0x800u));
    BUS_IRQ_ENABLE = 0u;
    BUS_IRQ_CLEAR = 0x1fu;
    pwm_disable_all();

    return (g_irq_count != 0u);
}

/* ------------------------------------------------------------------ */
/* GPIO / LED / KEY.                                                  */
/* ------------------------------------------------------------------ */
static void led_write(unsigned int v)
{
    led_shadow = v & 0xffu;
    GPIO_OUT = 0x0300u | led_shadow;
}

static int gpio_test(void)
{
    GPIO_DIR = 0xffffu;
    GPIO_OUT = 0x0355u;
    if ((GPIO_OUT & 0xffffu) != 0x0355u)
        return 0;
    GPIO_OUT = 0x0300u;
    return 1;
}

static int led_test(void)
{
    int i;
    pwm_disable_all();
    for (i = 0; i < 8; ++i) {
        led_write(1u << i);
        delay(120000u);
    }
    led_write(0xffu);
    delay(120000u);
    led_write(0x00u);
    return 1;
}

static void key_report(void)
{
    unsigned int k = GPIO_IN & 3u;
    puts("KEY1=");
    putdec((k >> 0) & 1u);
    puts(" KEY2=");
    putdec((k >> 1) & 1u);
    puts("\r\n");
}

/* ------------------------------------------------------------------ */
/* Command plane.                                                     */
/* ------------------------------------------------------------------ */
static void result(const char *name, int value)
{
    puts("ACS:Auto=");
    puts(name);
    puts(",result=");
    if (value > 0)
        puts("ok");
    else if (value == 0)
        puts("wait");
    else
        puts("err");
    puts("\r\n");
}

static void auto_all(void)
{
    result("GPIO", gpio_test() ? 1 : -1);
    result("FLASH", probe_flash() ? 1 : -1);
    result("EEPROM", probe_eeprom() ? 1 : -1);
    result("SD", probe_sd());
    result("PWM", pwm_measure(0) ? 1 : -1);
    result("BUSERR", bus_error_test() ? 1 : -1);
    result("IRQ", irq_test() ? 1 : -1);
    result("DDR3", 0);
    result("ETH1", 0);
    result("MIPI", 0);
    result("ADC", 0);
    result("HDMI_IN", 0);
}

static void auto_one(const char *name)
{
    if (streq(name, "GPIO"))
        result("GPIO", gpio_test() ? 1 : -1);
    else if (streq(name, "FLASH"))
        result("FLASH", probe_flash() ? 1 : -1);
    else if (streq(name, "EEPROM"))
        result("EEPROM", probe_eeprom() ? 1 : -1);
    else if (streq(name, "SD"))
        result("SD", probe_sd());
    else if (streq(name, "PWM"))
        result("PWM", pwm_measure(1) ? 1 : -1);
    else if (streq(name, "BUSERR"))
        result("BUSERR", bus_error_test() ? 1 : -1);
    else if (streq(name, "IRQ"))
        result("IRQ", irq_test() ? 1 : -1);
    else if (streq(name, "DDR3") || streq(name, "ETH1") ||
             streq(name, "MIPI") || streq(name, "ADC") ||
             streq(name, "HDMI_IN"))
        result(name, 0);
    else
        puts("ERR:unknown auto target\r\n");
}

static void bus_report(void)
{
    puts("BUS TXN=");
    puthex(BUS_TXN);
    puts(" RD=");
    puthex(BUS_RD);
    puts(" WR=");
    puthex(BUS_WR);
    puts(" WAIT=");
    puthex(BUS_WAIT);
    puts(" ERR=");
    puthex(BUS_ERR);
    puts(" LAST=");
    puthex(BUS_LAST_ADDR);
    puts("\r\n");
    puts("IRQ STATUS=");
    puthex(BUS_IRQ_STATUS);
    puts(" ENABLE=");
    puthex(BUS_IRQ_ENABLE);
    puts(" COUNT=");
    putdec(g_irq_count);
    puts("\r\n");
}

static void command(char *line)
{
    if (starts(line, "ACM:Support")) {
        puts("ACM:Support=Auto,Test,Start,Stop,Status,Version,GpioOut,GpioIn,Adc,FlashId,Eeprom,Irq\r\n");
    } else if (starts(line, "ACM:Auto=")) {
        auto_one(line + 9);
    } else if (streq(line, "ACM:Auto")) {
        auto_all();
    } else if (starts(line, "ACM:Test=")) {
        const char *t = line + 9;
        if (streq(t, "LED")) {
            (void)led_test();
            puts("LED TEST=PASS\r\n");
        } else if (streq(t, "GPIO")) {
            puts(gpio_test() ? "GPIO TEST=PASS\r\n" : "GPIO TEST=FAIL\r\n");
        } else if (streq(t, "KEY")) {
            key_report();
        } else if (streq(t, "FLASH") || streq(t, "Flash")) {
            int ok = probe_flash();
            puts(ok ? "FLASH ID=" : "FLASH ID=");
            puthex(flash_id);
            puts(ok ? " OK\r\n" : " ERR\r\n");
        } else if (streq(t, "EEPROM")) {
            int ok = probe_eeprom();
            puts("EEPROM DATA=");
            puthex(eeprom_data);
            puts(ok ? " ACK\r\n" : " ERR\r\n");
        } else if (streq(t, "SD")) {
            int ok = probe_sd();
            puts("SD R1=");
            puthex(sd_r1);
            puts(ok > 0 ? " OK\r\n" : (ok == 0 ? " WAIT\r\n" : " ERR\r\n"));
        } else if (streq(t, "PWM")) {
            puts(pwm_measure(1) ? "PWM TEST=PASS\r\n" : "PWM TEST=FAIL\r\n");
        } else if (streq(t, "BUSERR")) {
            puts(bus_error_test() ? "BUSERR TEST=PASS\r\n" : "BUSERR TEST=FAIL\r\n");
        } else if (streq(t, "IRQ")) {
            puts(irq_test() ? "IRQ TEST=PASS\r\n" : "IRQ TEST=FAIL\r\n");
        } else if (streq(t, "WDT")) {
            puts("WDT ARM=500ms\r\n");
            WDT_ARM = 1u;
            while (1)
                WDT_KICK = 1u;
        } else {
            puts("ERR:unknown test\r\n");
        }
    } else if (starts(line, "ACM:GpioOut=")) {
        const char *arg = line + 12;
        unsigned int idx;
        if (arg[0] < '1' || arg[0] > '8') {
            puts("ERR:gpio index\r\n");
            return;
        }
        idx = (unsigned int)(arg[0] - '1');
        if (contains(arg, "on"))
            led_write(led_shadow | (1u << idx));
        else if (contains(arg, "off"))
            led_write(led_shadow & ~(1u << idx));
        else {
            puts("ERR:use on/off\r\n");
            return;
        }
        puts("LED");
        putdec(idx + 1u);
        puts(contains(arg, "on") ? "=ON\r\n" : "=OFF\r\n");
    } else if (starts(line, "ACM:GpioIn")) {
        key_report();
    } else if (starts(line, "ACM:Adc")) {
        puts("ADC=");
        puthex(0u);
        puts(" WAIT\r\n");
    } else if (starts(line, "ACM:FlashId")) {
        (void)probe_flash();
        puts("FLASH ID=");
        puthex(flash_id);
        puts("\r\n");
    } else if (starts(line, "ACM:Eeprom")) {
        (void)probe_eeprom();
        puts("EEPROM DATA=");
        puthex(eeprom_data);
        puts("\r\n");
    } else if (starts(line, "ACM:Irq")) {
        bus_report();
    } else if (starts(line, "ACM:Status")) {
        puts("CFG=");
        puthex(DBG_REG);
        puts(" FLASH=");
        puthex(flash_id);
        puts(" EEPROM=");
        puthex(eeprom_data);
        puts(" SD=");
        puthex(sd_r1);
        puts("\r\n");
    } else if (starts(line, "ACM:Version")) {
        puts("EP04-CVE2 VERSION=");
        puthex(DBG_VERSION);
        puts("\r\n");
    } else if (starts(line, "ACM:Start=Bus")) {
        puts("BUS START\r\n");
        bus_report();
    } else if (starts(line, "ACM:Stop")) {
        puts("ACK:STOP\r\n");
    } else if (starts(line, "ACM:")) {
        puts("ERR:unknown command\r\n");
    }
}

int main(void)
{
    unsigned int cause;
    int f, e, s, g, p, be, irq;

    delay(300000u);

    GPIO_DIR = 0xffffu;
    GPIO_OUT = 0x0300u;
    pwm_disable_all();
    spi_cs(1u, 1u);

    cause = WDT_CAUSE & 1u;

    puts("\r\nALINX AR035 CVE2 Peripheral Bus EP04\r\n");
    puts("BOOT CAUSE=");
    puts(cause ? "WDT\r\n" : "POR/EXT\r\n");

    g = gpio_test();
    puts("GPIO TEST=");
    puts(g ? "PASS\r\n" : "FAIL\r\n");

    f = probe_flash();
    puts("FLASH ID=");
    puthex(flash_id);
    puts(f ? " OK\r\n" : " ERR\r\n");

    e = probe_eeprom();
    puts("EEPROM DATA=");
    puthex(eeprom_data);
    puts(e ? " ACK\r\n" : " ERR\r\n");

    s = probe_sd();
    puts("SD R1=");
    puthex(sd_r1);
    puts(s > 0 ? " OK\r\n" : (s == 0 ? " WAIT\r\n" : " ERR\r\n"));

    p = pwm_measure(1);
    puts(p ? "PWM TEST=PASS\r\n" : "PWM TEST=FAIL\r\n");

    be = bus_error_test();
    puts(be ? "BUSERR TEST=PASS\r\n" : "BUSERR TEST=FAIL\r\n");

    puts("IRQ TEST START\r\n");
    irq = irq_test();
    puts("IRQ COUNT=");
    puthex(g_irq_count);
    puts("\r\n");
    puts(irq ? "IRQ TEST=PASS\r\n" : "IRQ TEST=FAIL\r\n");

    key_report();
    bus_report();

    puts("READY\r\n");

    while (1) {
        char line[64];
        int n = 0;
        char c;

        while (1) {
            if (!(UART_STATUS & 2u))
                continue;
            c = (char)(UART_RX & 0xffu);
            if (c == '\r' || c == '\n') {
                if (n > 0)
                    break;
            } else if (n < 63) {
                line[n++] = c;
            }
        }
        line[n] = '\0';
        command(line);
    }
}
