#include <stdint.h>

#define UART_TX      (*(volatile unsigned char *)0x10000000u)
#define UART_STATUS  (*(volatile unsigned int  *)0x10000004u)
#define CLINT        ((volatile unsigned int  *)0x20000000u)

volatile unsigned int g_exc_count;
volatile unsigned int g_sw_count;
volatile unsigned int g_timer_count;
volatile unsigned int g_ext_count;
volatile unsigned int g_last_mcause;
volatile unsigned int g_last_mepc;
volatile unsigned int g_fail;

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 void set_mtvec(void)
{
    unsigned int v = 0x100u;
    __asm__ volatile ("csrw mtvec, %0" :: "r"(v));
}

static void irq_enable(unsigned int mask)
{
    __asm__ volatile ("csrs mstatus, %0" :: "r"(8u));
    __asm__ volatile ("csrs mie, %0" :: "r"(mask));
}

static void irq_disable(unsigned int mask)
{
    __asm__ volatile ("csrc mie, %0" :: "r"(mask));
}

static void fail(unsigned int code)
{
    if (g_fail == 0u)
        g_fail = code;
}

static void check_exc(unsigned int cause, const char *name)
{
    puts("CASE ");
    puts(name);
    puts(" mcause=");
    puthex(g_last_mcause);
    puts(" mepc=");
    puthex(g_last_mepc);
    if (g_exc_count == 1u && g_last_mcause == cause) {
        puts(" PASS\n");
    } else {
        puts(" FAIL\n");
        fail(0xE001u);
    }
}

static void check_irq(unsigned int cause, volatile unsigned int *count,
                      const char *name)
{
    puts("CASE ");
    puts(name);
    puts(" count=");
    puthex(*count);
    puts(" mcause=");
    puthex(g_last_mcause);
    if (*count > 0u && g_last_mcause == cause) {
        puts(" PASS\n");
    } else {
        puts(" FAIL\n");
        fail(0xE002u);
    }
}

static void check_csr(void)
{
    unsigned int v;

    __asm__ volatile ("csrw mscratch, %0" :: "r"(0x5a5a1234u));
    __asm__ volatile ("csrr %0, mscratch" : "=r"(v));
    puts("CASE csr mscratch=");
    puthex(v);
    if (v == 0x5a5a1234u) {
        puts(" PASS\n");
    } else {
        puts(" FAIL\n");
        fail(0xE005u);
    }

    __asm__ volatile ("csrw mie, %0" :: "r"(0x888u));
    __asm__ volatile ("csrr %0, mie" : "=r"(v));
    puts("CASE csr mie=");
    puthex(v);
    if ((v & 0x888u) == 0x888u) {
        puts(" PASS\n");
    } else {
        puts(" FAIL\n");
        fail(0xE005u);
    }
    __asm__ volatile ("csrw mie, zero");

    __asm__ volatile ("csrs mstatus, %0" :: "r"(8u));
    __asm__ volatile ("csrr %0, mstatus" : "=r"(v));
    puts("CASE csr mstatus.MIE=");
    puthex((v >> 3) & 1u);
    if (((v >> 3) & 1u) == 1u) {
        puts(" PASS\n");
    } else {
        puts(" FAIL\n");
        fail(0xE005u);
    }
    __asm__ volatile ("csrc mstatus, %0" :: "r"(8u));

    __asm__ volatile ("csrr %0, mtvec" : "=r"(v));
    puts("CASE csr mtvec=");
    puthex(v);
    if ((v & 0xfffffffcu) == 0x100u) {
        puts(" PASS\n");
    } else {
        puts(" FAIL\n");
        fail(0xE005u);
    }
}

int main(void)
{
    set_mtvec();
    check_csr();

    puts("EP02 CVE2 TRAP/IRQ TEST\n");
    puts("mtvec=00000100\n");
    g_fail = 0u;

    g_exc_count = 0u;
    g_last_mcause = 0u;
    g_last_mepc = 0u;
    __asm__ volatile ("ecall");
    check_exc(11u, "ecall");

    g_exc_count = 0u;
    g_last_mcause = 0u;
    g_last_mepc = 0u;
    __asm__ volatile (".4byte 0x00100073");  /* 32-bit EBREAK */
    check_exc(3u, "ebreak");

    g_exc_count = 0u;
    g_last_mcause = 0u;
    g_last_mepc = 0u;
    __asm__ volatile (".4byte 0x00000000");
    check_exc(2u, "illegal");

    g_timer_count = 0u;
    g_last_mcause = 0u;
    CLINT[3] = 0u;
    CLINT[2] = CLINT[0] + 50000u;
    irq_enable(0x80u);
    for (volatile unsigned int i = 0u; i < 2000000u && g_timer_count == 0u; i++)
        ;
    irq_disable(0x80u);
    check_irq(0x80000007u, &g_timer_count, "timer");

    g_sw_count = 0u;
    g_last_mcause = 0u;
    CLINT[4] = 1u;
    irq_enable(0x8u);
    for (volatile unsigned int i = 0u; i < 1000000u && g_sw_count == 0u; i++)
        ;
    irq_disable(0x8u);
    check_irq(0x80000003u, &g_sw_count, "software");

    g_ext_count = 0u;
    g_last_mcause = 0u;
    CLINT[5] = 1u;
    irq_enable(0x800u);
    for (volatile unsigned int i = 0u; i < 1000000u && g_ext_count == 0u; i++)
        ;
    irq_disable(0x800u);
    check_irq(0x8000000bu, &g_ext_count, "external");

    puts("counts exc=");
    puthex(g_exc_count);
    puts(" timer=");
    puthex(g_timer_count);
    puts(" sw=");
    puthex(g_sw_count);
    puts(" ext=");
    puthex(g_ext_count);
    putc('\n');

    if (g_fail == 0u) {
        puts("RESULT: PASS\n");
    } else {
        puts("RESULT: FAIL code=");
        puthex(g_fail);
        putc('\n');
    }

    for (;;)
        __asm__ volatile ("nop");
}
