new eve dir

8 files changed, 2111 insertions, 0 deletions

diff --git a/code/fe310/eos/eve/eve.c b/code/fe310/eos/eve/eve.c
new file mode 100644
index 0000000..8de0362
--- /dev/null
+++ b/code/fe310/eos/eve/eve.c
@@ -0,0 +1,733 @@
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "eos.h"
+#include "interrupt.h"
+#include "event.h"
+#include "timer.h"
+#include "spi.h"
+#include "eve.h"
+#include "irq_def.h"
+
+
+#define EVE_PIN_INTR            0
+#define EVE_MAX_TOUCH           5
+#define EVE_TAG_SCREEN          0xff
+
+#define EVE_THRESHOLD_X         5
+#define EVE_THRESHOLD_Y         5
+#define EVE_TIMEOUT_TAP         1000
+#define EVE_TIMEOUT_TRACK       20
+#define EVE_TRAVG               3
+#define EVE_FRICTION            500
+
+#define EVE_NOTOUCH             0x80000000
+#define EVE_MEM_WRITE           0x800000
+
+static char _cmd_burst;
+static uint16_t _cmd_offset;
+static uint32_t _dl_addr;
+
+static int _intr_mask = EVE_INT_TAG | EVE_INT_TOUCH;
+static int _multitouch;
+static uint8_t _tag0;
+
+static EVETouch _touch[EVE_MAX_TOUCH];
+static EVETouchTimer _touch_timer;
+
+static eve_touch_handler_t _touch_handler;
+static void *_touch_handler_param;
+
+static uint8_t _tag_opt[255];
+
+static const uint32_t _reg_touch[] = {
+    REG_CTOUCH_TOUCH0_XY,
+    REG_CTOUCH_TOUCH1_XY,
+    REG_CTOUCH_TOUCH2_XY,
+    REG_CTOUCH_TOUCH3_XY
+};
+
+static const uint32_t _reg_tag[] = {
+    REG_TOUCH_TAG,
+    REG_TOUCH_TAG1,
+    REG_TOUCH_TAG2,
+    REG_TOUCH_TAG3,
+    REG_TOUCH_TAG4
+};
+
+static const uint32_t _reg_track[] = {
+    REG_TRACKER,
+    REG_TRACKER_1,
+    REG_TRACKER_2,
+    REG_TRACKER_3,
+    REG_TRACKER_4
+};
+
+void eve_command(uint8_t command, uint8_t parameter) {
+    eos_spi_cs_set();
+    eos_spi_xchg24(((uint32_t)command << 16) | ((uint32_t)parameter << 8), 0);
+    eos_spi_cs_clear();
+}
+
+uint8_t eve_read8(uint32_t addr) {
+    uint8_t r;
+    eos_spi_cs_set();
+    eos_spi_xchg32(addr << 8, 0);
+    r = eos_spi_xchg8(0, EOS_SPI_FLAG_BSWAP);
+    eos_spi_cs_clear();
+
+    return r;
+}
+
+uint16_t eve_read16(uint32_t addr) {
+    uint16_t r;
+    eos_spi_cs_set();
+    eos_spi_xchg32(addr << 8, 0);
+    r = eos_spi_xchg16(0, EOS_SPI_FLAG_BSWAP);
+    eos_spi_cs_clear();
+
+    return r;
+}
+
+uint32_t eve_read32(uint32_t addr) {
+    uint32_t r;
+    eos_spi_cs_set();
+    eos_spi_xchg32(addr << 8, 0);
+    r = eos_spi_xchg32(0, EOS_SPI_FLAG_BSWAP);
+    eos_spi_cs_clear();
+
+    return r;
+}
+
+void eve_write8(uint32_t addr, uint8_t data) {
+    eos_spi_cs_set();
+    eos_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    eos_spi_xchg8(data, EOS_SPI_FLAG_BSWAP);
+    eos_spi_cs_clear();
+}
+
+void eve_write16(uint32_t addr, uint16_t data) {
+    eos_spi_cs_set();
+    eos_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    eos_spi_xchg16(data, EOS_SPI_FLAG_BSWAP);
+    eos_spi_cs_clear();
+}
+
+void eve_write32(uint32_t addr, uint32_t data) {
+    eos_spi_cs_set();
+    eos_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    eos_spi_xchg32(data, EOS_SPI_FLAG_BSWAP);
+    eos_spi_cs_clear();
+}
+
+void eve_active(void) {
+    eve_command(EVE_ACTIVE, 0);
+}
+
+void eve_brightness(uint8_t b) {
+	eve_write8(REG_PWM_DUTY, b);
+}
+
+static void _dl_inc(uint32_t i) {
+	_dl_addr += i;
+}
+
+void eve_dl_start(uint32_t addr) {
+    _dl_addr = addr;
+}
+
+void eve_dl_write(uint32_t dl) {
+    eve_write32(_dl_addr, dl);
+    _dl_inc(4);
+}
+
+void eve_dl_swap(void) {
+    eve_write8(REG_DLSWAP, EVE_DLSWAP_FRAME);
+}
+
+uint32_t eve_dl_get_addr(void) {
+    return _dl_addr;
+}
+
+static void _cmd_inc(uint16_t i) {
+	_cmd_offset += i;
+	_cmd_offset &= 0x0fff;
+}
+
+static void _cmd_begin(uint32_t command) {
+    uint8_t flags = 0;
+
+    if (_cmd_burst) {
+        flags = EOS_SPI_FLAG_TX;
+    } else {
+    	uint32_t addr = EVE_RAM_CMD + _cmd_offset;
+        eos_spi_cs_set();
+        eos_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    }
+    eos_spi_xchg32(command, EOS_SPI_FLAG_BSWAP | flags);
+    _cmd_inc(4);
+}
+
+static void _cmd_end(void) {
+    if (!_cmd_burst) eos_spi_cs_clear();
+}
+
+static void _cmd_string(const char *s, uint8_t flags) {
+    int i = 0, p = 0;
+
+    while (s[i] != 0) {
+        eos_spi_xchg8(s[i], EOS_SPI_FLAG_BSWAP | flags);
+        i++;
+    }
+    eos_spi_xchg8(0, EOS_SPI_FLAG_BSWAP | flags);
+    i++;
+    _cmd_inc(i);
+}
+
+static void _cmd_buffer(const char *b, int size, uint8_t flags) {
+    int i = 0, p = 0;
+
+    for (i=0; i<size; i++) {
+        eos_spi_xchg8(b[i], EOS_SPI_FLAG_BSWAP | flags);
+    }
+    _cmd_inc(size);
+}
+
+void eve_cmd(uint32_t cmd, const char *fmt, ...) {
+    uint8_t flags = _cmd_burst ? EOS_SPI_FLAG_TX : 0;
+    va_list argv;
+    uint16_t *p;
+    int i = 0;
+
+    va_start(argv, fmt);
+    _cmd_begin(cmd);
+    while (fmt[i]) {
+        switch (fmt[i]) {
+            case 'b':
+                eos_spi_xchg8(va_arg(argv, int), EOS_SPI_FLAG_BSWAP | flags);
+                _cmd_inc(1);
+                break;
+            case 'h':
+                eos_spi_xchg16(va_arg(argv, int), EOS_SPI_FLAG_BSWAP | flags);
+                _cmd_inc(2);
+                break;
+            case 'w':
+                eos_spi_xchg32(va_arg(argv, int), EOS_SPI_FLAG_BSWAP | flags);
+                _cmd_inc(4);
+                break;
+            case '&':
+                p = va_arg(argv, uint16_t *);
+                *p = _cmd_offset;
+                eos_spi_xchg32(0, EOS_SPI_FLAG_BSWAP | flags);
+                _cmd_inc(4);
+                break;
+            case 's':
+                _cmd_string(va_arg(argv, const char *), flags);
+                break;
+            case 'p':
+                _cmd_buffer(va_arg(argv, const char *), va_arg(argv, int), flags);
+                break;
+        }
+        i++;
+    }
+    /* padding */
+	i = _cmd_offset & 3;  /* equivalent to _cmd_offset % 4 */
+    if (i) {
+    	i = 4 - i;  /* 3, 2 or 1 */
+        _cmd_inc(i);
+
+    	while (i > 0) {
+            eos_spi_xchg8(0, EOS_SPI_FLAG_BSWAP | flags);
+    		i--;
+    	}
+    }
+    _cmd_end();
+	va_end(argv);
+}
+
+uint32_t eve_cmd_result(uint16_t offset) {
+    return eve_read32(EVE_RAM_CMD + offset);
+}
+
+void eve_cmd_dl(uint32_t dl) {
+    _cmd_begin(dl);
+    _cmd_end();
+}
+
+int eve_cmd_done(void) {
+	uint16_t r = eve_read16(REG_CMD_READ);
+    if (r == 0xfff) {
+		_cmd_offset = 0;
+		eve_write8(REG_CPURESET, 1);
+		eve_write16(REG_CMD_READ, 0);
+		eve_write16(REG_CMD_WRITE, 0);
+		eve_write16(REG_CMD_DL, 0);
+		eve_write8(REG_CPURESET, 0);
+        return -1;
+    }
+    return (r == _cmd_offset);
+}
+
+int eve_cmd_exec(int w) {
+    eve_write16(REG_CMD_WRITE, _cmd_offset);
+    if (w) {
+        int r;
+        do {
+            r = eve_cmd_done();
+        } while (!r);
+        if (r < 0) return EOS_ERR;
+    }
+    return EOS_OK;
+}
+
+void eve_cmd_burst_start(void) {
+	uint32_t addr = EVE_RAM_CMD + _cmd_offset;
+    eos_spi_cs_set();
+    eos_spi_xchg24(addr | EVE_MEM_WRITE, EOS_SPI_FLAG_TX);
+    _cmd_burst = 1;
+}
+
+void eve_cmd_burst_end(void) {
+    eos_spi_flush();
+    eos_spi_cs_clear();
+    _cmd_burst = 0;
+}
+
+static void _touch_timer_clear(void) {
+    _touch_timer.tag = 0;
+    _touch_timer.fc = 0;
+}
+
+static void handle_touch(uint8_t flags) {
+    int i;
+    char touch_ex = 0;
+    char int_ccomplete = 0;
+    uint8_t tag0 = _tag0;
+    uint8_t touch_last = 0;
+
+    if (!_multitouch && (flags & EVE_INT_TOUCH)) _multitouch = 1;
+    for (i=0; i<EVE_MAX_TOUCH; i++) {
+        uint8_t touch_tag;
+        uint32_t touch_xy;
+        volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+        volatile uint64_t now = 0;
+        EVETouch *touch = &_touch[i];
+
+        touch->evt &= ~EVE_TOUCH_EVT_MASK;
+        touch_xy = i < 4 ? eve_read32(_reg_touch[i]) : (((uint32_t)eve_read16(REG_CTOUCH_TOUCH4_X) << 16) | eve_read16(REG_CTOUCH_TOUCH4_Y));
+
+        if (touch_xy != 0x80008000) {
+            int16_t touch_x = touch_xy >> 16;
+            int16_t touch_y = touch_xy & 0xffff;
+            now = *mtime;
+            if (touch->x == EVE_NOTOUCH) {
+                if (!_tag0 && _touch_timer.tag) {
+                    if (_touch_timer.evt & EVE_TOUCH_ETYPE_TAP1) {
+                        int dx = touch_x - touch->x0;
+                        int dy = touch_y - touch->y0;
+                        dx = dx < 0 ? -dx : dx;
+                        dy = dy < 0 ? -dy : dy;
+                        if ((dx > EVE_THRESHOLD_X) || (dy > EVE_THRESHOLD_Y)) {
+                            touch->evt |= EVE_TOUCH_ETYPE_TAP1;
+                        } else {
+                            touch->evt |= EVE_TOUCH_ETYPE_TAP2;
+                        }
+                    }
+                    if (_touch_timer.evt & EVE_TOUCH_ETYPE_TRACK) {
+                        touch->evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
+                    }
+                    if (_touch_handler && (touch->evt & EVE_TOUCH_EVT_MASK)) {
+                        _touch_handler(_touch_handler_param, _touch_timer.tag, i);
+                    }
+                    eos_timer_clear(EOS_TIMER_ETYPE_UI);
+                    _touch_timer_clear();
+                }
+                touch->evt = EVE_TOUCH_ETYPE_POINT;
+                touch->tag0 = 0;
+                touch->tag = 0;
+                touch->tag_up = 0;
+                touch->tracker.tag = 0;
+                touch->tracker.track = 0;
+                touch->tracker.val = 0;
+                touch->t = 0;
+                touch->vx = 0;
+                touch->vy = 0;
+                touch->x0 = touch_x;
+                touch->y0 = touch_y;
+            } else if (touch->t) {
+                int dt = now - touch->t;
+                int vx = ((int)touch_x - touch->x) * (int)(RTC_FREQ) / dt;
+                int vy = ((int)touch_y - touch->y) * (int)(RTC_FREQ) / dt;
+                touch->vx = touch->vx ? (vx + touch->vx * EVE_TRAVG) / (EVE_TRAVG + 1) : vx;
+                touch->vy = touch->vy ? (vy + touch->vy * EVE_TRAVG) / (EVE_TRAVG + 1) : vy;
+                touch->t = now;
+            }
+            touch->x = touch_x;
+            touch->y = touch_y;
+            if (_multitouch || (flags & EVE_INT_TAG)) {
+                touch_tag = eve_read8(_reg_tag[i]);
+            } else {
+                touch_tag = touch->tag;
+            }
+            touch_ex = 1;
+        } else {
+            touch_tag = 0;
+            if (touch->x != EVE_NOTOUCH) {
+                touch->evt |= EVE_TOUCH_ETYPE_POINT_UP;
+                if (_touch_timer.tag && (i == 0)) {
+                    _touch_timer.evt &= ~EVE_TOUCH_ETYPE_LPRESS;
+                    if (!_touch_timer.evt) {
+                        eos_timer_clear(EOS_TIMER_ETYPE_UI);
+                        _touch_timer_clear();
+                    }
+                }
+                if (touch->tracker.tag && touch->tracker.track) {
+                    if (!_touch_timer.tag && (_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_INERT)) {
+                        _touch_timer.x0 = touch->x;
+                        _touch_timer.y0 = touch->y;
+                        _touch_timer.tag = touch->tracker.tag;
+                        _touch_timer.idx = i;
+                        _touch_timer.evt = EVE_TOUCH_ETYPE_TRACK;
+                        eos_timer_set(EVE_TIMEOUT_TRACK, EOS_TIMER_ETYPE_UI, 0);
+                    } else {
+                        touch->evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
+                    }
+                }
+                touch->x = EVE_NOTOUCH;
+                touch->y = EVE_NOTOUCH;
+            }
+        }
+        if (touch_tag != touch->tag) {
+            if (touch_tag) {
+                if (!touch->tag0) {
+                    touch->tag0 = touch_tag;
+                    if (_tag_opt[touch_tag] & EVE_TOUCH_OPT_TRACK_MASK) {
+                        touch->tracker.tag = touch_tag;
+                    } else if (_tag_opt[EVE_TAG_SCREEN] & EVE_TOUCH_OPT_TRACK_MASK) {
+                        touch->tracker.tag = EVE_TAG_SCREEN;
+                    }
+                    if (touch->tracker.tag && !(_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_XY)) {
+                        touch->tracker.track = 1;
+                        touch->evt |= EVE_TOUCH_ETYPE_TRACK_START;
+                        if (!touch->t && (_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_INERT)) touch->t = now;
+                    }
+                    if (!_tag0 && ((_tag_opt[touch_tag] | _tag_opt[EVE_TAG_SCREEN]) & EVE_TOUCH_OPT_TIMER_MASK)) {
+                        _touch_timer.tag = _tag_opt[touch_tag] & EVE_TOUCH_OPT_TIMER_MASK ? touch_tag : EVE_TAG_SCREEN;
+                        _touch_timer.idx = 0;
+                        _touch_timer.evt = 0;
+                        if (_tag_opt[_touch_timer.tag] & EVE_TOUCH_OPT_LPRESS) _touch_timer.evt |= EVE_TOUCH_ETYPE_LPRESS;
+                        if (_tag_opt[_touch_timer.tag] & EVE_TOUCH_OPT_DTAP) _touch_timer.evt |= EVE_TOUCH_ETYPE_TAP1;
+                        eos_timer_set(EVE_TIMEOUT_TAP, EOS_TIMER_ETYPE_UI, 0);
+                    }
+                }
+                if (!_tag0) _tag0 = tag0 = touch_tag;
+            }
+            touch->tag_up = touch->tag;
+            if (touch->tag_up) touch->evt |= EVE_TOUCH_ETYPE_TAG_UP;
+            touch->tag = touch_tag;
+            if (touch->tag) touch->evt |= EVE_TOUCH_ETYPE_TAG;
+        }
+        if (touch_xy != 0x80008000) {
+            char _track = touch->tracker.tag && !touch->tracker.track;
+            if (_track || _touch_timer.tag) {
+                int dx = touch->x - touch->x0;
+                int dy = touch->y - touch->y0;
+                dx = dx < 0 ? -dx : dx;
+                dy = dy < 0 ? -dy : dy;
+                if (_track) {
+                    if ((dx > EVE_THRESHOLD_X) && !(_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_X)) {
+                        touch->tracker.tag = 0;
+                    }
+                    if ((dy > EVE_THRESHOLD_Y) && !(_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_Y)) {
+                        touch->tracker.tag = 0;
+                    }
+                    if (touch->tracker.tag && ((dx > EVE_THRESHOLD_X) || (dy > EVE_THRESHOLD_Y))) {
+                        if (dx > EVE_THRESHOLD_X) {
+                            touch->evt |= touch->x > touch->x0 ? EVE_TOUCH_ETYPE_TRACK_RIGHT : EVE_TOUCH_ETYPE_TRACK_LEFT;
+                        }
+                        if (dy > EVE_THRESHOLD_Y) {
+                            touch->evt |= touch->y > touch->y0 ? EVE_TOUCH_ETYPE_TRACK_DOWN : EVE_TOUCH_ETYPE_TRACK_UP;
+                        }
+                        touch->tracker.track = 1;
+                        touch->evt |= EVE_TOUCH_ETYPE_TRACK_START;
+                        if (!touch->t && (_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_INERT)) touch->t = now;
+                    }
+                }
+                if (_touch_timer.tag && ((dx > EVE_THRESHOLD_X) || (dy > EVE_THRESHOLD_Y))) {
+                    eos_timer_clear(EOS_TIMER_ETYPE_UI);
+                    _touch_timer_clear();
+                }
+            }
+            if (touch->tracker.tag && touch->tracker.track) {
+                touch->evt |= _tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_MASK;
+            }
+            if (touch->evt & EVE_TOUCH_ETYPE_TRACK_REG) {
+                uint32_t touch_track = eve_read32(_reg_track[i]);
+                if (touch->tracker.tag == (touch_track & 0xff)) {
+                    touch->tracker.val = touch_track >> 16;
+                } else {
+                    touch->evt &= ~EVE_TOUCH_ETYPE_TRACK_REG;
+                }
+            }
+            if (touch->tracker.tag || _touch_timer.tag) int_ccomplete = 1;
+        }
+        if (touch->evt & EVE_TOUCH_EVT_MASK) touch_last = i + 1;
+        if (!_multitouch) break;
+        if (_touch_timer.tag) {
+            eos_timer_clear(EOS_TIMER_ETYPE_UI);
+            _touch_timer_clear();
+        }
+    }
+
+    if (!touch_ex) {
+        _tag0 = 0;
+        _multitouch = 0;
+    }
+
+    if (_multitouch) int_ccomplete = 1;
+
+    if (int_ccomplete && !(_intr_mask & EVE_INT_CONVCOMPLETE)) {
+        _intr_mask |= EVE_INT_CONVCOMPLETE;
+        eve_write8(REG_INT_MASK, _intr_mask);
+    }
+    if (!int_ccomplete && (_intr_mask & EVE_INT_CONVCOMPLETE)) {
+        _intr_mask &= ~EVE_INT_CONVCOMPLETE;
+        eve_write8(REG_INT_MASK, _intr_mask);
+    }
+
+    for (i=0; i<touch_last; i++) {
+        EVETouch *touch = &_touch[i];
+        if (_touch_handler && (touch->evt & EVE_TOUCH_EVT_MASK)) {
+            _touch_handler(_touch_handler_param, tag0, i);
+        }
+    }
+}
+
+static void handle_time(unsigned char type) {
+    if (_touch_handler && _touch_timer.tag) {
+        EVETouch *touch = &_touch[_touch_timer.idx];
+
+        if ((_touch_timer.evt & EVE_TOUCH_ETYPE_TAP1) && (touch->x != EVE_NOTOUCH)) _touch_timer.evt &= ~EVE_TOUCH_ETYPE_TAP1;
+
+        if (_touch_timer.evt) {
+            char more = 0;
+            int _x = touch->x;
+            int _y = touch->y;
+
+            touch->evt &= ~EVE_TOUCH_EVT_MASK;
+            touch->evt |= _touch_timer.evt;
+            if (touch->evt & EVE_TOUCH_ETYPE_TRACK) {
+                volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+                int dt = *mtime - touch->t;
+
+                if (_touch_timer.fc == 0) {
+                    double d = sqrt(touch->vx * touch->vx + touch->vy * touch->vy);
+                    _touch_timer.fc = (double)(RTC_FREQ) * d / EVE_FRICTION;
+                }
+
+                if (dt < _touch_timer.fc / 2) {
+                    more = 1;
+                } else {
+                    touch->evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
+                    dt = _touch_timer.fc / 2;
+                }
+                touch->x = _touch_timer.x0 + (touch->vx * dt - touch->vx * dt / _touch_timer.fc * dt ) / (int)(RTC_FREQ);
+                touch->y = _touch_timer.y0 + (touch->vy * dt - touch->vy * dt / _touch_timer.fc * dt ) / (int)(RTC_FREQ);
+
+                if (more) eos_timer_set(EVE_TIMEOUT_TRACK, EOS_TIMER_ETYPE_UI, 0);
+            }
+
+
+            eos_spi_dev_start(EOS_DEV_DISP);
+            _touch_handler(_touch_handler_param, _touch_timer.tag, _touch_timer.idx);
+            eos_spi_dev_stop();
+
+            if (!more) _touch_timer_clear();
+            touch->x = _x;
+            touch->y = _y;
+        }
+    }
+}
+
+static void handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    uint8_t flags;
+
+    eos_spi_dev_start(EOS_DEV_DISP);
+    flags = eve_read8(REG_INT_FLAGS) & _intr_mask;
+    handle_touch(flags);
+    eos_spi_dev_stop();
+
+    GPIO_REG(GPIO_LOW_IP) = (1 << EVE_PIN_INTR);
+    GPIO_REG(GPIO_LOW_IE) |= (1 << EVE_PIN_INTR);
+}
+
+static void handle_intr(void) {
+    GPIO_REG(GPIO_LOW_IE) &= ~(1 << EVE_PIN_INTR);
+    eos_evtq_push_isr(EOS_EVT_UI | EVE_ETYPE_INTR, NULL, 0);
+    return;
+}
+
+int eve_init(uint32_t *touch_transform) {
+    int i;
+	uint8_t chipid = 0;
+	uint16_t timeout = 0;
+
+    eve_command(EVE_RST_PULSE, 0);
+    eve_command(EVE_CLKEXT, 0);
+    eve_command(EVE_ACTIVE, 0);         /* start EVE */
+
+    while(chipid != 0x7C) {             /* if chipid is not 0x7c, continue to read it until it is, EVE needs a moment for it's power on self-test and configuration */
+		eos_timer_sleep(1);
+		chipid = eve_read8(REG_ID);
+		timeout++;
+		if (timeout > 400) return EOS_ERR;
+	}
+
+    eve_write8(REG_PWM_DUTY, 0);
+
+    /* Initialize Display */
+	eve_write16(REG_HCYCLE,  EVE_HCYCLE);   /* total number of clocks per line, incl front/back porch */
+	eve_write16(REG_HOFFSET, EVE_HOFFSET);  /* start of active line */
+	eve_write16(REG_HSYNC0,  EVE_HSYNC0);   /* start of horizontal sync pulse */
+	eve_write16(REG_HSYNC1,  EVE_HSYNC1);   /* end of horizontal sync pulse */
+	eve_write16(REG_VCYCLE,  EVE_VCYCLE);   /* total number of lines per screen, including pre/post */
+	eve_write16(REG_VOFFSET, EVE_VOFFSET);  /* start of active screen */
+	eve_write16(REG_VSYNC0,  EVE_VSYNC0);   /* start of vertical sync pulse */
+	eve_write16(REG_VSYNC1,  EVE_VSYNC1);   /* end of vertical sync pulse */
+	eve_write8(REG_SWIZZLE,  EVE_SWIZZLE);  /* FT8xx output to LCD - pin order */
+	eve_write8(REG_PCLK_POL, EVE_PCLKPOL);  /* LCD data is clocked in on this PCLK edge */
+	eve_write8(REG_CSPREAD,	 EVE_CSPREAD);  /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
+	eve_write16(REG_HSIZE,   EVE_HSIZE);    /* active display width */
+	eve_write16(REG_VSIZE,   EVE_VSIZE);    /* active display height */
+
+	/* do not set PCLK yet - wait for just after the first display list */
+
+	/* configure Touch */
+	eve_write8(REG_TOUCH_MODE, EVE_TMODE_CONTINUOUS);       /* enable touch */
+	eve_write16(REG_TOUCH_RZTHRESH, EVE_TOUCH_RZTHRESH);    /* eliminate any false touches */
+
+	/* disable Audio for now */
+	eve_write8(REG_VOL_PB, 0x00);       /* turn recorded audio volume down */
+	eve_write8(REG_VOL_SOUND, 0x00);    /* turn synthesizer volume off */
+	eve_write16(REG_SOUND, 0x6000);     /* set synthesizer to mute */
+
+	/* write a basic display-list to get things started */
+    eve_dl_start(EVE_RAM_DL);
+    eve_dl_write(CLEAR_COLOR_RGB(0,0,0));
+	eve_dl_write(CLEAR(1,1,1));
+    eve_dl_write(DISPLAY());
+    eve_dl_swap();
+
+	/* nothing is being displayed yet... the pixel clock is still 0x00 */
+	eve_write8(REG_GPIO, 0x80);         /* enable the DISP signal to the LCD panel, it is set to output in REG_GPIO_DIR by default */
+	eve_write8(REG_PCLK, EVE_PCLK);     /* now start clocking data to the LCD panel */
+
+    eve_write8(REG_INT_EN, 0x01);
+    eve_write8(REG_INT_MASK, _intr_mask);
+    while(eve_read8(REG_INT_FLAGS));
+
+    if (touch_transform) {
+        eve_write32(REG_TOUCH_TRANSFORM_A, touch_transform[0]);
+        eve_write32(REG_TOUCH_TRANSFORM_B, touch_transform[1]);
+        eve_write32(REG_TOUCH_TRANSFORM_C, touch_transform[2]);
+        eve_write32(REG_TOUCH_TRANSFORM_D, touch_transform[3]);
+        eve_write32(REG_TOUCH_TRANSFORM_E, touch_transform[4]);
+        eve_write32(REG_TOUCH_TRANSFORM_F, touch_transform[5]);
+    } else {
+        uint32_t touch_transform[6];
+        eve_cmd_dl(CMD_DLSTART);
+        eve_cmd_dl(CLEAR_COLOR_RGB(0,0,0));
+        eve_cmd_dl(CLEAR(1,1,1));
+        eve_cmd(CMD_TEXT, "hhhhs", EVE_HSIZE/2, EVE_VSIZE/2, 27, EVE_OPT_CENTER, "Please tap on the dot.");
+        eve_cmd(CMD_CALIBRATE, "w", 0);
+        eve_cmd_dl(DISPLAY());
+        eve_cmd_dl(CMD_SWAP);
+        eve_cmd_exec(1);
+
+        touch_transform[0] = eve_read32(REG_TOUCH_TRANSFORM_A);
+        touch_transform[1] = eve_read32(REG_TOUCH_TRANSFORM_B);
+        touch_transform[2] = eve_read32(REG_TOUCH_TRANSFORM_C);
+        touch_transform[3] = eve_read32(REG_TOUCH_TRANSFORM_D);
+        touch_transform[4] = eve_read32(REG_TOUCH_TRANSFORM_E);
+        touch_transform[5] = eve_read32(REG_TOUCH_TRANSFORM_F);
+
+        printf("TOUCH TRANSFORM:{0x%x,0x%x,0x%x,0x%x,0x%x,0x%x}\n", touch_transform[0], touch_transform[1], touch_transform[2], touch_transform[3], touch_transform[4], touch_transform[5]);
+    }
+
+    eve_write32(REG_CTOUCH_EXTENDED, 0x00);
+    eve_cmd(CMD_SETROTATE, "w", 2);
+    eve_cmd_exec(1);
+
+    eos_timer_sleep(500);
+    eve_command(EVE_STANDBY, 0);
+
+    for (i=0; i<EVE_MAX_TOUCH; i++) {
+        EVETouch *touch = &_touch[i];
+        touch->x = EVE_NOTOUCH;
+        touch->y = EVE_NOTOUCH;
+    }
+    eos_evtq_set_handler(EOS_EVT_UI, handle_evt);
+    eos_timer_set_handler(EOS_TIMER_ETYPE_UI, handle_time);
+
+    GPIO_REG(GPIO_INPUT_EN)     |=  (1 << EVE_PIN_INTR);
+    GPIO_REG(GPIO_OUTPUT_EN)    &= ~(1 << EVE_PIN_INTR);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << EVE_PIN_INTR);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << EVE_PIN_INTR);
+
+    GPIO_REG(GPIO_LOW_IE)       |=  (1 << EVE_PIN_INTR);
+    eos_intr_set(INT_GPIO_BASE + EVE_PIN_INTR, IRQ_PRIORITY_UI, handle_intr);
+
+    return EOS_OK;
+}
+
+void eve_touch_set_handler(eve_touch_handler_t handler, void *param) {
+    _touch_handler = handler;
+    _touch_handler_param = param;
+}
+
+EVETouch *eve_touch_evt(uint8_t tag0, int touch_idx, uint8_t tag_min, uint8_t tag_max, uint16_t *evt) {
+    uint8_t _tag;
+    uint16_t _evt;
+    EVETouch *ret = NULL;
+
+    *evt = 0;
+    if ((touch_idx < 0) || (touch_idx > 4)) return ret;
+    if ((tag0 < tag_min) || (tag0 > tag_max)) return ret;
+
+    ret = &_touch[touch_idx];
+    _evt = ret->evt;
+
+    *evt |= _evt & EVE_TOUCH_ETYPE_POINT_MASK;
+    if (_evt & EVE_TOUCH_ETYPE_TAG) {
+        _tag = ret->tag;
+        if ((_tag >= tag_min) && (_tag <= tag_max)) *evt |= EVE_TOUCH_ETYPE_TAG;
+    }
+    if (_evt & EVE_TOUCH_ETYPE_TAG_UP) {
+        _tag = ret->tag_up;
+        if ((_tag >= tag_min) && (_tag <= tag_max)) *evt |= EVE_TOUCH_ETYPE_TAG_UP;
+    }
+    if (_evt & EVE_TOUCH_ETYPE_TRACK_MASK) {
+        _tag = ret->tracker.tag;
+        if ((_tag >= tag_min) && (_tag <= tag_max)) *evt |= _evt & (EVE_TOUCH_ETYPE_TRACK_MASK | EVE_TOUCH_ETYPE_TRACK_XY);
+    }
+    if (_evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP1 | EVE_TOUCH_ETYPE_TAP2)) {
+        _tag = _touch_timer.tag;
+        if ((_tag >= tag_min) && (_tag <= tag_max)) *evt |= _evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP1 | EVE_TOUCH_ETYPE_TAP2);
+    }
+
+    return ret;
+}
+
+void eve_touch_set_opt(uint8_t tag, uint8_t opt) {
+    _tag_opt[tag] = opt;
+}
+
+EVETouchTimer *eve_touch_get_timer(void) {
+    return &_touch_timer;
+}
+
diff --git a/code/fe310/eos/eve/eve.h b/code/fe310/eos/eve/eve.h
new file mode 100644
index 0000000..8445ea1
--- /dev/null
+++ b/code/fe310/eos/eve/eve.h
@@ -0,0 +1,111 @@
+#include <stdint.h>
+
+#include "eve_def.h"
+
+#define EVE_ETYPE_INTR                  1
+
+/* events */
+#define EVE_TOUCH_ETYPE_TRACK           0x0001
+#define EVE_TOUCH_ETYPE_TRACK_REG       0x0002
+#define EVE_TOUCH_ETYPE_TRACK_START     0x0004
+#define EVE_TOUCH_ETYPE_TRACK_STOP      0x0008
+#define EVE_TOUCH_ETYPE_TAG             0x0010
+#define EVE_TOUCH_ETYPE_TAG_UP          0x0020
+#define EVE_TOUCH_ETYPE_POINT           0x0040
+#define EVE_TOUCH_ETYPE_POINT_UP        0x0080
+#define EVE_TOUCH_ETYPE_LPRESS          0x0100
+#define EVE_TOUCH_ETYPE_TAP1            0x0200
+#define EVE_TOUCH_ETYPE_TAP2            0x0400
+
+#define EVE_TOUCH_EVT_MASK              0x0fff
+
+#define EVE_TOUCH_ETYPE_TAG_MASK        (EVE_TOUCH_ETYPE_TAG        | EVE_TOUCH_ETYPE_TAG_UP)
+#define EVE_TOUCH_ETYPE_TAP_MASK        (EVE_TOUCH_ETYPE_TAP1       | EVE_TOUCH_ETYPE_TAP2)
+#define EVE_TOUCH_ETYPE_TRACK_MASK      (EVE_TOUCH_ETYPE_TRACK      | EVE_TOUCH_ETYPE_TRACK_REG | EVE_TOUCH_ETYPE_TRACK_START | EVE_TOUCH_ETYPE_TRACK_STOP)
+#define EVE_TOUCH_ETYPE_POINT_MASK      (EVE_TOUCH_ETYPE_POINT      | EVE_TOUCH_ETYPE_POINT_UP)
+
+/* extended events */
+#define EVE_TOUCH_ETYPE_TRACK_LEFT      0x1000
+#define EVE_TOUCH_ETYPE_TRACK_RIGHT     0x2000
+#define EVE_TOUCH_ETYPE_TRACK_UP        0x4000
+#define EVE_TOUCH_ETYPE_TRACK_DOWN      0x8000
+
+#define EVE_TOUCH_ETYPE_TRACK_X         (EVE_TOUCH_ETYPE_TRACK_LEFT | EVE_TOUCH_ETYPE_TRACK_RIGHT)
+#define EVE_TOUCH_ETYPE_TRACK_Y         (EVE_TOUCH_ETYPE_TRACK_UP   | EVE_TOUCH_ETYPE_TRACK_DOWN)
+#define EVE_TOUCH_ETYPE_TRACK_XY        (EVE_TOUCH_ETYPE_TRACK_X    | EVE_TOUCH_ETYPE_TRACK_Y)
+
+/* tag options */
+#define EVE_TOUCH_OPT_TRACK             EVE_TOUCH_ETYPE_TRACK
+#define EVE_TOUCH_OPT_TRACK_REG         EVE_TOUCH_ETYPE_TRACK_REG
+#define EVE_TOUCH_OPT_TRACK_X           0x04
+#define EVE_TOUCH_OPT_TRACK_Y           0x08
+#define EVE_TOUCH_OPT_INERT             0x10
+#define EVE_TOUCH_OPT_LPRESS            0x40
+#define EVE_TOUCH_OPT_DTAP              0x80
+
+#define EVE_TOUCH_OPT_TRACK_XY          (EVE_TOUCH_OPT_TRACK_X      | EVE_TOUCH_OPT_TRACK_Y)
+#define EVE_TOUCH_OPT_TRACK_MASK        (EVE_TOUCH_OPT_TRACK        | EVE_TOUCH_OPT_TRACK_REG)
+#define EVE_TOUCH_OPT_TIMER_MASK        (EVE_TOUCH_OPT_LPRESS       | EVE_TOUCH_OPT_DTAP)
+
+typedef struct EVETouch {
+    int x;
+    int y;
+    int vx;
+    int vy;
+    int x0;
+    int y0;
+    uint64_t t;
+    uint16_t evt;
+    uint8_t tag0;
+    uint8_t tag;
+    uint8_t tag_up;
+    struct {
+        uint8_t tag;
+        uint8_t track;
+        uint16_t val;
+    } tracker;
+} EVETouch;
+
+typedef struct EVETouchTimer {
+    uint8_t tag;
+    uint8_t idx;
+    uint16_t evt;
+    int x0;
+    int y0;
+    int fc;
+} EVETouchTimer;
+
+typedef void (*eve_touch_handler_t) (void *, uint8_t, int);
+
+void eve_command(uint8_t command, uint8_t parameter);
+
+uint8_t eve_read8(uint32_t addr);
+uint16_t eve_read16(uint32_t addr);
+uint32_t eve_read32(uint32_t addr);
+void eve_write8(uint32_t addr, uint8_t data);
+void eve_write16(uint32_t addr, uint16_t data);
+void eve_write32(uint32_t addr, uint32_t data);
+
+void eve_active(void);
+void eve_brightness(uint8_t b);
+
+void eve_dl_start(uint32_t addr);
+void eve_dl_write(uint32_t dl);
+void eve_dl_swap(void);
+uint32_t eve_dl_get_addr(void);
+
+void eve_cmd(uint32_t cmd, const char *fmt, ...);
+uint32_t eve_cmd_result(uint16_t offset);
+void eve_cmd_dl(uint32_t dl);
+int eve_cmd_done(void);
+int eve_cmd_exec(int w);
+void eve_cmd_burst_start(void);
+void eve_cmd_burst_end(void);
+
+int eve_init(uint32_t *touch_transform);
+
+void eve_touch_set_handler(eve_touch_handler_t handler, void *handler_param);
+EVETouch *eve_touch_evt(uint8_t tag0, int touch_idx, uint8_t tag_min, uint8_t tag_max, uint16_t *evt);
+void eve_touch_set_opt(uint8_t tag, uint8_t opt);
+
+EVETouchTimer *eve_touch_get_timer(void);
\ No newline at end of file
diff --git a/code/fe310/eos/eve/eve_config.h b/code/fe310/eos/eve/eve_config.h
new file mode 100755
index 0000000..a7d3c42
--- /dev/null
+++ b/code/fe310/eos/eve/eve_config.h
@@ -0,0 +1,39 @@
+#ifndef EVE_CONFIG_H_

+#define EVE_CONFIG_H_

+

+/* my display */

+

+#define EVE_TH      1200L

+#define EVE_THD     800L

+#define EVE_THF     210L

+#define EVE_THP     20L

+#define EVE_THB     46L

+

+#define EVE_TV      650L

+#define EVE_TVD     480L

+#define EVE_TVF     22L

+#define EVE_TVP     12L

+#define EVE_TVB     23L

+

+

+#define EVE_HSIZE	(EVE_THD)                       /* Thd Length of visible part of line (in PCLKs) - display width */

+#define EVE_HSYNC0	(EVE_THF)                       /* Thf Horizontal Front Porch */

+#define EVE_HSYNC1	(EVE_THF + EVE_THP)             /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */

+#define EVE_HOFFSET	(EVE_THF + EVE_THP + EVE_THB)   /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */

+#define EVE_HCYCLE 	(EVE_TH)                        /* Th Total length of line (visible and non-visible) (in PCLKs) */

+

+#define EVE_VSIZE	(EVE_TVD)                       /* Tvd Number of visible lines (in lines) - display height */

+#define EVE_VSYNC0	(EVE_TVF)                       /* Tvf Vertical Front Porch */

+#define EVE_VSYNC1	(EVE_TVF + EVE_TVP)             /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */

+#define EVE_VOFFSET	(EVE_TVF + EVE_TVP + EVE_TVB)	/* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */

+#define EVE_VCYCLE	(EVE_TV)                        /* Tv Total number of lines (visible and non-visible) (in lines) */

+

+#define EVE_PCLKPOL	(1L)                            /* PCLK polarity (0 = rising edge, 1 = falling edge) */

+#define EVE_SWIZZLE	(0L)                            /* Defines the arrangement of the RGB pins of the FT800 */

+#define EVE_PCLK	(2L)                            /* 60MHz / REG_PCLK = PCLK frequency - 30 MHz */

+#define EVE_CSPREAD	(1L)                            /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */

+#define EVE_TOUCH_RZTHRESH (1200L)                  /* touch-sensitivity */

+#define EVE_HAS_CRYSTAL

+#define FT81X_ENABLE

+

+#endif /* EVE_CONFIG_H */

diff --git a/code/fe310/eos/eve/eve_def.h b/code/fe310/eos/eve/eve_def.h
new file mode 100755
index 0000000..25e4927
--- /dev/null
+++ b/code/fe310/eos/eve/eve_def.h
@@ -0,0 +1,872 @@
+/*

+@file    EVE.h

+@brief   Contains FT80x/FT81x/BT81x API definitions

+@version 4.0

+@date    2019-11-17

+@author  Rudolph Riedel

+

+@section LICENSE

+

+MIT License

+

+Copyright (c) 2016-2019 Rudolph Riedel

+

+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),

+to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,

+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

+

+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+

+@section History

+

+2.1

+- changes to this header

+

+2.2

+- commented out "#define DISPLAY() ((0UL<<24))" as it collides with a define in the Arduino IDE - the whole section of "macros" needs a rework...

+

+3.0

+- renamed from FT800.h to FT8.h

+- changed FT_ prefixes to FT8_

+- switched to standard-C compliant comment-style

+- changed FT81x register definitions from decimal to hex

+- verified all FT81x register definitions

+- moved FT81x registers marked as "reserved" to an #if 0 block

+

+3.1

+- moved several undocumented commands to an #if 0 block

+

+3.2

+- moved CMD_CRC to the block of undocumented commands as well

+

+3.3

+- changed macros BITMAP_LAYOUT_H and BITMAP_SIZE_H as submitted to github by "jventerprises"

+	These macros provide the extended bits for bitmaps bigger than 511 pixels, FTDIs original implementation that I used and never touched takes the arguments

+	as already processed and not the original values.

+	Note the one example in "FT81x Series Programmers Guide" Version 1.1 for displaying a 800x480 sized bitmap:

+	dl(BITMAP_SIZE_H(1, 0));

+	dl(BITMAP_SIZE(NEAREST, BORDER, BORDER, 288, 480));

+	Now you can use it like this:

+	EVE_cmd_dl(BITMAP_SIZE_H(800, 480));

+	EVE_cmd_dl(BITMAP_SIZE(NEAREST, BORDER, BORDER, 800, 480));

+

+4.0

+- renamed from FT8.h to EVE.h

+- renamed EVE_81X_ENABLE to FT81X_ENABLE

+- changed FT8_ prefixes to EVE_

+- rearranged things a bit with FT80x specific includes moved to the end and a "#if defined (BT81X_ENABLE)" block on top of the chip-specific includes

+- started to add specific BT81x defines

+- minor maintenance

+- changed OPT_FLASH to EVE_OPT_FLASH and OPT_FORMAT to EVE_OPT_FORMAT for consistency

+- added EVE_OPT_FILL which has been left out of the documentation for the BT81x so far

+- added a few BT81x specific macros

+- added a few FT81x/BT81x specific host commands

+- removed the preceding underscore from the include guard define to avoid potential undefined behavior

+- removed a bunch of defines for FT80x that I never implemented for FT81x

+

+*/

+

+#include "eve_config.h"

+

+#ifndef EVE_H_

+#define EVE_H_

+

+

+#define DL_CLEAR		0x26000000UL /* requires OR'd arguments */

+#define DL_CLEAR_RGB	0x02000000UL /* requires OR'd arguments */

+#define DL_COLOR_RGB	0x04000000UL /* requires OR'd arguments */

+#define DL_POINT_SIZE	0x0D000000UL /* requires OR'd arguments */

+#define DL_END			0x21000000UL

+#define DL_BEGIN		0x1F000000UL /* requires OR'd arguments */

+#define DL_DISPLAY		0x00000000UL

+

+#define CLR_COL              0x4

+#define CLR_STN              0x2

+#define CLR_TAG              0x1

+

+

+/* Host commands */

+#define EVE_ACTIVE	0x00  /* place FT8xx in active state */

+#define EVE_STANDBY	0x41  /* place FT8xx in Standby (clk running) */

+#define EVE_SLEEP	0x42  /* place FT8xx in Sleep (clk off) */

+#define EVE_PWRDOWN	0x50  /* place FT8xx in Power Down (core off) */

+#define EVE_CLKEXT	0x44  /* select external clock source */

+#define EVE_CLKINT	0x48  /* select internal clock source */

+#define EVE_CORERST	0x68  /* reset core - all registers default and processors reset */

+#define EVE_CLK48M	0x62  /* select 48MHz PLL output */

+#define EVE_CLK36M	0x61  /* select 36MHz PLL output */

+

+

+/* defines used for graphics commands */

+#define EVE_NEVER                0UL

+#define EVE_LESS                 1UL

+#define EVE_LEQUAL               2UL

+#define EVE_GREATER              3UL

+#define EVE_GEQUAL               4UL

+#define EVE_EQUAL                5UL

+#define EVE_NOTEQUAL             6UL

+#define EVE_ALWAYS               7UL

+

+

+/* Bitmap formats */

+#define EVE_ARGB1555             0UL

+#define EVE_L1                   1UL

+#define EVE_L4                   2UL

+#define EVE_L8                   3UL

+#define EVE_RGB332               4UL

+#define EVE_ARGB2                5UL

+#define EVE_ARGB4                6UL

+#define EVE_RGB565               7UL

+#define EVE_PALETTED             8UL

+#define EVE_TEXT8X8              9UL

+#define EVE_TEXTVGA              10UL

+#define EVE_BARGRAPH             11UL

+

+

+/* Bitmap filter types */

+#define EVE_NEAREST              0UL

+#define EVE_BILINEAR             1UL

+

+

+/* Bitmap wrap types */

+#define EVE_BORDER               0UL

+#define EVE_REPEAT               1UL

+

+

+/* Stencil defines */

+#define EVE_KEEP                 1UL

+#define EVE_REPLACE              2UL

+#define EVE_INCR                 3UL

+#define EVE_DECR                 4UL

+#define EVE_INVERT               5UL

+

+

+/* Graphics display list swap defines */

+#define EVE_DLSWAP_DONE          0UL

+#define EVE_DLSWAP_LINE          1UL

+#define EVE_DLSWAP_FRAME         2UL

+

+

+/* Interrupt bits */

+#define EVE_INT_SWAP             0x01

+#define EVE_INT_TOUCH            0x02

+#define EVE_INT_TAG              0x04

+#define EVE_INT_SOUND            0x08

+#define EVE_INT_PLAYBACK         0x10

+#define EVE_INT_CMDEMPTY         0x20

+#define EVE_INT_CMDFLAG          0x40

+#define EVE_INT_CONVCOMPLETE     0x80

+

+

+/* Touch mode */

+#define EVE_TMODE_OFF        	0

+#define EVE_TMODE_ONESHOT    	1

+#define EVE_TMODE_FRAME      	2

+#define EVE_TMODE_CONTINUOUS 	3

+

+

+/* Alpha blending */

+#define EVE_ZERO                 0UL

+#define EVE_ONE                  1UL

+#define EVE_SRC_ALPHA            2UL

+#define EVE_DST_ALPHA            3UL

+#define EVE_ONE_MINUS_SRC_ALPHA  4UL

+#define EVE_ONE_MINUS_DST_ALPHA  5UL

+

+

+/* Graphics primitives */

+#define EVE_BITMAPS              1UL

+#define EVE_POINTS               2UL

+#define EVE_LINES                3UL

+#define EVE_LINE_STRIP           4UL

+#define EVE_EDGE_STRIP_R         5UL

+#define EVE_EDGE_STRIP_L         6UL

+#define EVE_EDGE_STRIP_A         7UL

+#define EVE_EDGE_STRIP_B         8UL

+#define EVE_RECTS                9UL

+

+

+/* Widget command */

+#define EVE_OPT_MONO             1

+#define EVE_OPT_NODL             2

+#define EVE_OPT_FLAT             256

+#define EVE_OPT_CENTERX          512

+#define EVE_OPT_CENTERY          1024

+#define EVE_OPT_CENTER           (EVE_OPT_CENTERX | EVE_OPT_CENTERY)

+#define EVE_OPT_NOBACK           4096

+#define EVE_OPT_NOTICKS          8192

+#define EVE_OPT_NOHM             16384

+#define EVE_OPT_NOPOINTER        16384

+#define EVE_OPT_NOSECS           32768

+#define EVE_OPT_NOHANDS          49152

+#define EVE_OPT_RIGHTX           2048

+#define EVE_OPT_SIGNED           256

+

+

+/* Defines related to inbuilt font */

+#define EVE_NUMCHAR_PERFONT 		(128L)  /* number of font characters per bitmap handle */

+#define EVE_FONT_TABLE_SIZE 		(148L)  /* size of the font table - utilized for loopup by the graphics engine */

+#define EVE_FONT_TABLE_POINTER	(0xFFFFCUL) /* pointer to the inbuilt font tables starting from bitmap handle 16 */

+

+

+/* Audio sample type defines */

+#define EVE_LINEAR_SAMPLES       0UL	/* 8bit signed samples */

+#define EVE_ULAW_SAMPLES         1UL	/* 8bit ulaw samples */

+#define EVE_ADPCM_SAMPLES        2UL	/* 4bit ima adpcm samples */

+

+

+/* Synthesized sound */

+#define EVE_SILENCE              0x00

+#define EVE_SQUAREWAVE           0x01

+#define EVE_SINEWAVE             0x02

+#define EVE_SAWTOOTH             0x03

+#define EVE_TRIANGLE             0x04

+#define EVE_BEEPING              0x05

+#define EVE_ALARM                0x06

+#define EVE_WARBLE               0x07

+#define EVE_CAROUSEL             0x08

+#define EVE_PIPS(n)              (0x0F + (n))

+#define EVE_HARP                 0x40

+#define EVE_XYLOPHONE            0x41

+#define EVE_TUBA                 0x42

+#define EVE_GLOCKENSPIEL         0x43

+#define EVE_ORGAN                0x44

+#define EVE_TRUMPET              0x45

+#define EVE_PIANO                0x46

+#define EVE_CHIMES               0x47

+#define EVE_MUSICBOX             0x48

+#define EVE_BELL                 0x49

+#define EVE_CLICK                0x50

+#define EVE_SWITCH               0x51

+#define EVE_COWBELL              0x52

+#define EVE_NOTCH                0x53

+#define EVE_HIHAT                0x54

+#define EVE_KICKDRUM             0x55

+#define EVE_POP                  0x56

+#define EVE_CLACK                0x57

+#define EVE_CHACK                0x58

+#define EVE_MUTE                 0x60

+#define EVE_UNMUTE               0x61

+

+

+/* Synthesized sound frequencies, midi note */

+#define EVE_MIDI_A0   21

+#define EVE_MIDI_A_0  22

+#define EVE_MIDI_B0   23

+#define EVE_MIDI_C1   24

+#define EVE_MIDI_C_1  25

+#define EVE_MIDI_D1   26

+#define EVE_MIDI_D_1  27

+#define EVE_MIDI_E1   28

+#define EVE_MIDI_F1   29

+#define EVE_MIDI_F_1  30

+#define EVE_MIDI_G1   31

+#define EVE_MIDI_G_1  32

+#define EVE_MIDI_A1   33

+#define EVE_MIDI_A_1  34

+#define EVE_MIDI_B1   35

+#define EVE_MIDI_C2   36

+#define EVE_MIDI_C_2  37

+#define EVE_MIDI_D2   38

+#define EVE_MIDI_D_2  39

+#define EVE_MIDI_E2   40

+#define EVE_MIDI_F2   41

+#define EVE_MIDI_F_2  42

+#define EVE_MIDI_G2   43

+#define EVE_MIDI_G_2  44

+#define EVE_MIDI_A2   45

+#define EVE_MIDI_A_2  46

+#define EVE_MIDI_B2   47

+#define EVE_MIDI_C3   48

+#define EVE_MIDI_C_3  49

+#define EVE_MIDI_D3   50

+#define EVE_MIDI_D_3  51

+#define EVE_MIDI_E3   52

+#define EVE_MIDI_F3   53

+#define EVE_MIDI_F_3  54

+#define EVE_MIDI_G3   55

+#define EVE_MIDI_G_3  56

+#define EVE_MIDI_A3   57

+#define EVE_MIDI_A_3  58

+#define EVE_MIDI_B3   59

+#define EVE_MIDI_C4   60

+#define EVE_MIDI_C_4  61

+#define EVE_MIDI_D4   62

+#define EVE_MIDI_D_4  63

+#define EVE_MIDI_E4   64

+#define EVE_MIDI_F4   65

+#define EVE_MIDI_F_4  66

+#define EVE_MIDI_G4   67

+#define EVE_MIDI_G_4  68

+#define EVE_MIDI_A4   69

+#define EVE_MIDI_A_4  70

+#define EVE_MIDI_B4   71

+#define EVE_MIDI_C5   72

+#define EVE_MIDI_C_5  73

+#define EVE_MIDI_D5   74

+#define EVE_MIDI_D_5  75

+#define EVE_MIDI_E5   76

+#define EVE_MIDI_F5   77

+#define EVE_MIDI_F_5  78

+#define EVE_MIDI_G5   79

+#define EVE_MIDI_G_5  80

+#define EVE_MIDI_A5   81

+#define EVE_MIDI_A_5  82

+#define EVE_MIDI_B5   83

+#define EVE_MIDI_C6   84

+#define EVE_MIDI_C_6  85

+#define EVE_MIDI_D6   86

+#define EVE_MIDI_D_6  87

+#define EVE_MIDI_E6   88

+#define EVE_MIDI_F6   89

+#define EVE_MIDI_F_6  90

+#define EVE_MIDI_G6   91

+#define EVE_MIDI_G_6  92

+#define EVE_MIDI_A6   93

+#define EVE_MIDI_A_6  94

+#define EVE_MIDI_B6   95

+#define EVE_MIDI_C7   96

+#define EVE_MIDI_C_7  97

+#define EVE_MIDI_D7   98

+#define EVE_MIDI_D_7  99

+#define EVE_MIDI_E7   100

+#define EVE_MIDI_F7   101

+#define EVE_MIDI_F_7  102

+#define EVE_MIDI_G7   103

+#define EVE_MIDI_G_7  104

+#define EVE_MIDI_A7   105

+#define EVE_MIDI_A_7  106

+#define EVE_MIDI_B7   107

+#define EVE_MIDI_C8   108

+

+

+/* GPIO bits */

+#define EVE_GPIO0	0

+#define EVE_GPIO1	1	/* default gpio pin for audio shutdown, 1 - enable, 0 - disable */

+#define EVE_GPIO7	7	/* default gpio pin for display enable, 1 - enable, 0 - disable */

+

+

+/* Display rotation */

+#define EVE_DISPLAY_0		0	/* 0 degrees rotation */

+#define EVE_DISPLAY_180		1	/* 180 degrees rotation */

+

+

+/* commands common to EVE/EVE2/EVE3 */

+#define CMD_APPEND				0xFFFFFF1E

+#define CMD_BGCOLOR				0xFFFFFF09

+#define CMD_BUTTON				0xFFFFFF0D

+#define CMD_CALIBRATE			0xFFFFFF15

+#define CMD_CLOCK				0xFFFFFF14

+#define CMD_COLDSTART			0xFFFFFF32

+#define CMD_DIAL				0xFFFFFF2D

+#define CMD_DLSTART				0xFFFFFF00

+#define CMD_FGCOLOR				0xFFFFFF0A

+#define CMD_GAUGE				0xFFFFFF13

+#define CMD_GETMATRIX			0xFFFFFF33

+#define CMD_GETPROPS			0xFFFFFF25

+#define CMD_GETPTR				0xFFFFFF23

+#define CMD_GRADCOLOR			0xFFFFFF34

+#define CMD_GRADIENT			0xFFFFFF0B

+#define CMD_INFLATE				0xFFFFFF22

+#define CMD_INTERRUPT			0xFFFFFF02

+#define CMD_KEYS				0xFFFFFF0E

+#define CMD_LOADIDENTITY		0xFFFFFF26

+#define CMD_LOADIMAGE			0xFFFFFF24

+#define CMD_LOGO				0xFFFFFF31

+#define CMD_MEMCPY				0xFFFFFF1D

+#define CMD_MEMCRC				0xFFFFFF18

+#define CMD_MEMSET				0xFFFFFF1B

+#define CMD_MEMWRITE			0xFFFFFF1A

+#define CMD_MEMZERO				0xFFFFFF1C

+#define CMD_NUMBER				0xFFFFFF2E

+#define CMD_PROGRESS			0xFFFFFF0F

+#define CMD_REGREAD				0xFFFFFF19

+#define CMD_ROTATE				0xFFFFFF29

+#define CMD_SCALE				0xFFFFFF28

+#define CMD_SCREENSAVER			0xFFFFFF2F

+#define CMD_SCROLLBAR			0xFFFFFF11

+#define CMD_SETFONT				0xFFFFFF2B

+#define CMD_SETMATRIX			0xFFFFFF2A

+#define CMD_SKETCH				0xFFFFFF30

+#define CMD_SLIDER				0xFFFFFF10

+#define CMD_SNAPSHOT			0xFFFFFF1F

+#define CMD_SPINNER				0xFFFFFF16

+#define CMD_STOP				0xFFFFFF17

+#define CMD_SWAP				0xFFFFFF01

+#define CMD_TEXT				0xFFFFFF0C

+#define CMD_TOGGLE				0xFFFFFF12

+#define CMD_TRACK				0xFFFFFF2C

+#define CMD_TRANSLATE			0xFFFFFF27

+

+

+/* the following are undocumented commands that therefore should not be used */

+#if 0

+#define CMD_CRC					0xFFFFFF03

+#define CMD_HAMMERAUX			0xFFFFFF04

+#define CMD_MARCH				0xFFFFFF05

+#define CMD_IDCT				0xFFFFFF06

+#define CMD_EXECUTE				0xFFFFFF07

+#define CMD_GETPOINT			0xFFFFFF08

+#define CMD_TOUCH_TRANSFORM		0xFFFFFF20

+#endif

+

+

+/* FT8xx graphics engine specific macros useful for static display list generation */

+#define ALPHA_FUNC(func,ref) ((9UL<<24)|(((func)&7UL)<<8)|(((ref)&255UL)<<0))

+#define BEGIN(prim) ((31UL<<24)|(((prim)&15UL)<<0))

+#define BITMAP_HANDLE(handle) ((5UL<<24)|(((handle)&31UL)<<0))

+#define BITMAP_LAYOUT(format,linestride,height) ((7UL<<24)|(((format)&31UL)<<19)|(((linestride)&1023UL)<<9)|(((height)&511UL)<<0))

+#define BITMAP_SIZE(filter,wrapx,wrapy,width,height) ((8UL<<24)|(((filter)&1UL)<<20)|(((wrapx)&1UL)<<19)|(((wrapy)&1UL)<<18)|(((width)&511UL)<<9)|(((height)&511UL)<<0))

+#define BITMAP_TRANSFORM_A(a) ((21UL<<24)|(((a)&131071UL)<<0))

+#define BITMAP_TRANSFORM_B(b) ((22UL<<24)|(((b)&131071UL)<<0))

+#define BITMAP_TRANSFORM_C(c) ((23UL<<24)|(((c)&16777215UL)<<0))

+#define BITMAP_TRANSFORM_D(d) ((24UL<<24)|(((d)&131071UL)<<0))

+#define BITMAP_TRANSFORM_E(e) ((25UL<<24)|(((e)&131071UL)<<0))

+#define BITMAP_TRANSFORM_F(f) ((26UL<<24)|(((f)&16777215UL)<<0))

+#define BLEND_FUNC(src,dst) ((11UL<<24)|(((src)&7UL)<<3)|(((dst)&7UL)<<0))

+#define CALL(dest) ((29UL<<24)|(((dest)&65535UL)<<0))

+#define CELL(cell) ((6UL<<24)|(((cell)&127UL)<<0))

+#define CLEAR(c,s,t) ((38UL<<24)|(((c)&1UL)<<2)|(((s)&1UL)<<1)|(((t)&1UL)<<0))

+#define CLEAR_COLOR_A(alpha) ((15UL<<24)|(((alpha)&255UL)<<0))

+#define CLEAR_COLOR_RGB(red,green,blue) ((2UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0))

+#define CLEAR_STENCIL(s) ((17UL<<24)|(((s)&255UL)<<0))

+#define CLEAR_TAG(s) ((18UL<<24)|(((s)&255UL)<<0))

+#define COLOR_A(alpha) ((16UL<<24)|(((alpha)&255UL)<<0))

+#define COLOR_MASK(r,g,b,a) ((32UL<<24)|(((r)&1UL)<<3)|(((g)&1UL)<<2)|(((b)&1UL)<<1)|(((a)&1UL)<<0))

+#define COLOR_RGB(red,green,blue) ((4UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0))

+#define DISPLAY() ((0UL<<24))

+#define END() ((33UL<<24))

+#define JUMP(dest) ((30UL<<24)|(((dest)&65535UL)<<0))

+#define LINE_WIDTH(width) ((14UL<<24)|(((width)&4095UL)<<0))

+#define MACRO(m) ((37UL<<24)|(((m)&1UL)<<0))

+#define POINT_SIZE(size) ((13UL<<24)|(((size)&8191UL)<<0))

+#define RESTORE_CONTEXT() ((35UL<<24))

+#define RETURN() ((36UL<<24))

+#define SAVE_CONTEXT() ((34UL<<24))

+#define STENCIL_FUNC(func,ref,mask) ((10UL<<24)|(((func)&7UL)<<16)|(((ref)&255UL)<<8)|(((mask)&255UL)<<0))

+#define STENCIL_MASK(mask) ((19UL<<24)|(((mask)&255UL)<<0))

+#define STENCIL_OP(sfail,spass) ((12UL<<24)|(((sfail)&7UL)<<3)|(((spass)&7UL)<<0))

+#define TAG(s) ((3UL<<24)|(((s)&255UL)<<0))

+#define TAG_MASK(mask) ((20UL<<24)|(((mask)&1UL)<<0))

+#define VERTEX2F(x,y) ((1UL<<30)|(((x)&32767UL)<<15)|(((y)&32767UL)<<0))

+#define VERTEX2II(x,y,handle,cell) ((2UL<<30)|(((x)&511UL)<<21)|(((y)&511UL)<<12)|(((handle)&31UL)<<7)|(((cell)&127UL)<<0))

+

+

+/* ----------------- BT81x exclusive definitions -----------------*/

+#if defined (BT81X_ENABLE)

+

+#define EVE_GLFORMAT 31UL	/* used with BITMAP_LAYOUT to indicate bitmap-format is specified by BITMAP_EXT_FORMAT */

+

+#define DL_BITMAP_EXT_FORMAT	0x2E000000 /* requires OR'd arguments */

+

+/* extended Bitmap formats */

+#define EVE_COMPRESSED_RGBA_ASTC_4x4_KHR   37808UL

+#define EVE_COMPRESSED_RGBA_ASTC_5x4_KHR   37809UL

+#define EVE_COMPRESSED_RGBA_ASTC_5x5_KHR   37810UL

+#define EVE_COMPRESSED_RGBA_ASTC_6x5_KHR   37811UL

+#define EVE_COMPRESSED_RGBA_ASTC_6x6_KHR   37812UL

+#define EVE_COMPRESSED_RGBA_ASTC_8x5_KHR   37813UL

+#define EVE_COMPRESSED_RGBA_ASTC_8x6_KHR   37814UL

+#define EVE_COMPRESSED_RGBA_ASTC_8x8_KHR   37815UL

+#define EVE_COMPRESSED_RGBA_ASTC_10x5_KHR  37816UL

+#define EVE_COMPRESSED_RGBA_ASTC_10x6_KHR  37817UL

+#define EVE_COMPRESSED_RGBA_ASTC_10x8_KHR  37818UL

+#define EVE_COMPRESSED_RGBA_ASTC_10x10_KHR 37819UL

+#define EVE_COMPRESSED_RGBA_ASTC_12x10_KHR 37820UL

+#define EVE_COMPRESSED_RGBA_ASTC_12x12_KHR 37821UL

+

+

+#define EVE_RAM_ERR_REPORT      0x309800UL /* max 128 bytes null terminated string */

+#define EVE_RAM_FLASH           0x800000UL

+#define EVE_RAM_FLASH_POSTBLOB  0x801000UL

+

+#define EVE_OPT_FLASH  64UL

+#define EVE_OPT_FORMAT 4096UL

+#define EVE_OPT_FILL   8192UL

+

+

+/* additional commands for BT81x */

+#define CMD_BITMAP_TRANSFORM 0xFFFFFF21

+#define CMD_SYNC             0xFFFFFF42		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_SYNC) */

+#define CMD_FLASHERASE       0xFFFFFF44		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHERASE) */

+#define CMD_FLASHWRITE       0xFFFFFF45

+#define CMD_FLASHREAD        0xFFFFFF46

+#define CMD_FLASHUPDATE      0xFFFFFF47

+#define CMD_FLASHDETACH      0xFFFFFF48		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHDETACH) */

+#define CMD_FLASHATTACH      0xFFFFFF49		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHATTACH) */

+#define CMD_FLASHFAST        0xFFFFFF4A

+#define CMD_FLASHSPIDESEL    0xFFFFFF4B		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHSPIDESEL) */

+#define CMD_FLASHSPITX       0xFFFFFF4C

+#define CMD_FLASHSPIRX       0xFFFFFF4D

+#define CMD_FLASHSOURCE      0xFFFFFF4E

+#define CMD_CLEARCACHE       0xFFFFFF4F		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_CLEARCACHE) */

+#define CMD_INFLATE2         0xFFFFFF50

+#define CMD_ROTATEAROUND     0xFFFFFF51

+#define CMD_RESETFONTS       0xFFFFFF52		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_RESETFONTS) */

+#define CMD_ANIMSTART        0xFFFFFF53

+#define CMD_ANIMSTOP         0xFFFFFF54

+#define CMD_ANIMXY           0xFFFFFF55

+#define CMD_ANIMDRAW         0xFFFFFF56

+#define CMD_GRADIENTA        0xFFFFFF57

+#define CMD_FILLWIDTH        0xFFFFFF58

+#define CMD_APPENDF          0xFFFFFF59

+#define CMD_ANIMFRAME        0xFFFFFF5A

+#define CMD_VIDEOSTARTF      0xFFFFFF5F		/* does not need a dedicated function, just use EVE_cmd_dl(CMD_VIDEOSTARTF) */

+

+#if 0

+/* some undocumented commands for BT81x */

+#define CMD_NOP              0xFFFFFF5B

+#define CMD_SHA1             0xFFFFFF5C

+#define CMD_HMAC             0xFFFFFF5D

+#define CMD_LAST_            0xFFFFFF5E

+

+#endif

+

+

+/* additional registers for BT81x */

+#define REG_ADAPTIVE_FRAMERATE 0x30257cUL

+#define REG_PLAYBACK_PAUSE     0x3025ecUL

+#define REG_FLASH_STATUS       0x3025f0UL

+#define REG_FLASH_SIZE         0x309024UL

+#define REG_PLAY_CONTROL       0x30914eUL

+#define REG_COPRO_PATCH_DTR    0x309162UL

+

+

+/* BT81x graphics engine specific macros */

+#define BITMAP_EXT_FORMAT(format) ((46UL<<24)|(((format)&65535UL)<<0))

+#define BITMAP_SWIZZLE(r,g,b,a) ((47UL<<24)|(((r)&7UL)<<9)|(((g)&7UL)<<6)|(((b)&7UL)<<3)|(((a)&7UL)<<0))

+#define BITMAP_SOURCE2(flash_or_ram, addr) ((1UL<<24)|((flash_or_ram) << 23)|(((addr)&8388607UL)<<0))

+#define INT_FRR() ((48UL<<24))

+

+#undef BITMAP_TRANSFORM_A

+#undef BITMAP_TRANSFORM_B

+#undef BITMAP_TRANSFORM_D

+#undef BITMAP_TRANSFORM_E

+

+#define BITMAP_TRANSFORM_A_EXT(p,v) ((21UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))

+#define BITMAP_TRANSFORM_B_EXT(p,v) ((22UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))

+#define BITMAP_TRANSFORM_D_EXT(p,v) ((24UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))

+#define BITMAP_TRANSFORM_E_EXT(p,v) ((25UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))

+

+#define BITMAP_TRANSFORM_A(a) BITMAP_TRANSFORM_A_EXT(0,a)

+#define BITMAP_TRANSFORM_B(b) BITMAP_TRANSFORM_B_EXT(0,b)

+#define BITMAP_TRANSFORM_D(d) BITMAP_TRANSFORM_D_EXT(0,d)

+#define BITMAP_TRANSFORM_E(e) BITMAP_TRANSFORM_E_EXT(0,e)

+

+#endif

+

+/* ----------------- FT81x / BT81x exclusive definitions -----------------*/

+#if defined (FT81X_ENABLE)

+

+

+/* Host commands */

+#define EVE_CLKSEL			0x61 /* configure system clock */

+#define EVE_RST_PULSE		0x68 /* reset core - all registers default and processors reset */

+#define EVE_PINDRIVE		0x70 /* setup drive strength for various pins */

+#define EVE_PIN_PD_STATE	0x71 /* setup how pins behave during power down */

+

+

+/* Memory definitions */

+#define EVE_RAM_G			0x000000UL

+#define EVE_ROM_CHIPID		0x0C0000UL

+#define EVE_ROM_FONT		0x1E0000UL

+#define EVE_ROM_FONT_ADDR	0x2FFFFCUL

+#define EVE_RAM_DL			0x300000UL

+#define EVE_RAM_REG			0x302000UL

+#define EVE_RAM_CMD			0x308000UL

+

+

+/* Memory buffer sizes */

+#define EVE_RAM_G_SIZE		1024*1024L

+#define EVE_CMDFIFO_SIZE	4*1024L

+#define EVE_RAM_DL_SIZE		8*1024L

+

+

+/* various additional defines for FT81x */

+#define EVE_ADC_DIFFERENTIAL     1UL

+#define EVE_ADC_SINGLE_ENDED     0UL

+

+#define EVE_INT_G8               18UL

+#define EVE_INT_L8C              12UL

+#define EVE_INT_VGA              13UL

+

+#define EVE_OPT_MEDIAFIFO        16UL

+#define EVE_OPT_FULLSCREEN       8UL

+#define EVE_OPT_NOTEAR           4UL

+#define EVE_OPT_SOUND            32UL

+

+#define EVE_PALETTED565          14UL

+#define EVE_PALETTED4444         15UL

+#define EVE_PALETTED8            16UL

+#define EVE_L2                   17UL

+

+

+/* additional commands for FT81x */

+#define CMD_MEDIAFIFO			0xFFFFFF39

+#define CMD_PLAYVIDEO			0xFFFFFF3A

+#define CMD_ROMFONT				0xFFFFFF3F

+#define CMD_SETBASE				0xFFFFFF38

+#define CMD_SETBITMAP			0xFFFFFF43

+#define CMD_SETFONT2			0xFFFFFF3B

+#define CMD_SETROTATE			0xFFFFFF36

+#define CMD_SETSCRATCH			0xFFFFFF3C

+#define CMD_SNAPSHOT2			0xFFFFFF37

+#define CMD_VIDEOFRAME			0xFFFFFF41

+#define CMD_VIDEOSTART			0xFFFFFF40

+

+

+/* the following are undocumented commands that therefore should not be used */

+#if 0

+#define CMD_CSKETCH				0xFFFFFF35

+#define CMD_INT_RAMSHARED		0xFFFFFF3D

+#define CMD_INT_SWLOADIMAGE		0xFFFFFF3E

+#endif

+

+

+/* Register definitions */

+#define REG_ANA_COMP         0x302184UL /* only listed in datasheet */

+#define REG_BIST_EN          0x302174UL /* only listed in datasheet */

+#define REG_CLOCK            0x302008UL

+#define REG_CMDB_SPACE       0x302574UL

+#define REG_CMDB_WRITE       0x302578UL

+#define REG_CMD_DL           0x302100UL

+#define REG_CMD_READ         0x3020f8UL

+#define REG_CMD_WRITE        0x3020fcUL

+#define REG_CPURESET         0x302020UL

+#define REG_CSPREAD          0x302068UL

+#define REG_CTOUCH_EXTENDED  0x302108UL

+#define REG_CTOUCH_TOUCH0_XY 0x302124UL /* only listed in datasheet */

+#define REG_CTOUCH_TOUCH4_X  0x30216cUL

+#define REG_CTOUCH_TOUCH4_Y  0x302120UL

+#define REG_CTOUCH_TOUCH1_XY 0x30211cUL

+#define REG_CTOUCH_TOUCH2_XY 0x30218cUL

+#define REG_CTOUCH_TOUCH3_XY 0x302190UL

+#define REG_TOUCH_CONFIG     0x302168UL

+#define REG_DATESTAMP        0x302564UL /* only listed in datasheet */

+#define REG_DITHER           0x302060UL

+#define REG_DLSWAP           0x302054UL

+#define REG_FRAMES           0x302004UL

+#define REG_FREQUENCY        0x30200cUL

+#define REG_GPIO             0x302094UL

+#define REG_GPIOX            0x30209cUL

+#define REG_GPIOX_DIR        0x302098UL

+#define REG_GPIO_DIR         0x302090UL

+#define REG_HCYCLE           0x30202cUL

+#define REG_HOFFSET          0x302030UL

+#define REG_HSIZE            0x302034UL

+#define REG_HSYNC0           0x302038UL

+#define REG_HSYNC1           0x30203cUL

+#define REG_ID               0x302000UL

+#define REG_INT_EN           0x3020acUL

+#define REG_INT_FLAGS        0x3020a8UL

+#define REG_INT_MASK         0x3020b0UL

+#define REG_MACRO_0          0x3020d8UL

+#define REG_MACRO_1          0x3020dcUL

+#define REG_MEDIAFIFO_READ   0x309014UL /* only listed in programmers guide */

+#define REG_MEDIAFIFO_WRITE  0x309018UL /* only listed in programmers guide */

+#define REG_OUTBITS          0x30205cUL

+#define REG_PCLK             0x302070UL

+#define REG_PCLK_POL         0x30206cUL

+#define REG_PLAY             0x30208cUL

+#define REG_PLAYBACK_FORMAT  0x3020c4UL

+#define REG_PLAYBACK_FREQ    0x3020c0UL

+#define REG_PLAYBACK_LENGTH  0x3020b8UL

+#define REG_PLAYBACK_LOOP    0x3020c8UL

+#define REG_PLAYBACK_PLAY    0x3020ccUL

+#define REG_PLAYBACK_READPTR 0x3020bcUL

+#define REG_PLAYBACK_START   0x3020b4UL

+#define REG_PWM_DUTY         0x3020d4UL

+#define REG_PWM_HZ           0x3020d0UL

+#define REG_RENDERMODE       0x302010UL /* only listed in datasheet */

+#define REG_ROTATE           0x302058UL

+#define REG_SNAPFORMAT       0x30201cUL /* only listed in datasheet */

+#define REG_SNAPSHOT         0x302018UL /* only listed in datasheet */

+#define REG_SNAPY            0x302014UL /* only listed in datasheet */

+#define REG_SOUND            0x302088UL

+#define REG_SPI_WIDTH        0x302188UL /* listed with false offset in programmers guide V1.1 */

+#define REG_SWIZZLE          0x302064UL

+#define REG_TAG              0x30207cUL

+#define REG_TAG_X            0x302074UL

+#define REG_TAG_Y            0x302078UL

+#define REG_TAP_CRC          0x302024UL /* only listed in datasheet */

+#define REG_TAP_MASK         0x302028UL /* only listed in datasheet */

+#define REG_TOUCH_ADC_MODE   0x302108UL

+#define REG_TOUCH_CHARGE     0x30210cUL

+#define REG_TOUCH_DIRECT_XY  0x30218cUL

+#define REG_TOUCH_DIRECT_Z1Z2 0x302190UL

+#define REG_TOUCH_MODE       0x302104UL

+#define REG_TOUCH_OVERSAMPLE 0x302114UL

+#define REG_TOUCH_RAW_XY     0x30211cUL

+#define REG_TOUCH_RZ         0x302120UL

+#define REG_TOUCH_RZTHRESH   0x302118UL

+#define REG_TOUCH_SCREEN_XY  0x302124UL

+#define REG_TOUCH_SETTLE     0x302110UL

+#define REG_TOUCH_TAG        0x30212cUL

+#define REG_TOUCH_TAG1       0x302134UL /* only listed in datasheet */

+#define REG_TOUCH_TAG1_XY    0x302130UL /* only listed in datasheet */

+#define REG_TOUCH_TAG2       0x30213cUL /* only listed in datasheet */

+#define REG_TOUCH_TAG2_XY    0x302138UL /* only listed in datasheet */

+#define REG_TOUCH_TAG3       0x302144UL /* only listed in datasheet */

+#define REG_TOUCH_TAG3_XY    0x302140UL /* only listed in datasheet */

+#define REG_TOUCH_TAG4       0x30214cUL /* only listed in datasheet */

+#define REG_TOUCH_TAG4_XY    0x302148UL /* only listed in datasheet */

+#define REG_TOUCH_TAG_XY     0x302128UL

+#define REG_TOUCH_TRANSFORM_A 0x302150UL

+#define REG_TOUCH_TRANSFORM_B 0x302154UL

+#define REG_TOUCH_TRANSFORM_C 0x302158UL

+#define REG_TOUCH_TRANSFORM_D 0x30215cUL

+#define REG_TOUCH_TRANSFORM_E 0x302160UL

+#define REG_TOUCH_TRANSFORM_F 0x302164UL

+#define REG_TRACKER          0x309000UL /* only listed in programmers guide */

+#define REG_TRACKER_1        0x309004UL /* only listed in programmers guide */

+#define REG_TRACKER_2        0x309008UL /* only listed in programmers guide */

+#define REG_TRACKER_3        0x30900cUL /* only listed in programmers guide */

+#define REG_TRACKER_4        0x309010UL /* only listed in programmers guide */

+#define REG_TRIM             0x302180UL

+#define REG_VCYCLE           0x302040UL

+#define REG_VOFFSET          0x302044UL

+#define REG_VOL_PB           0x302080UL

+#define REG_VOL_SOUND        0x302084UL

+#define REG_VSIZE            0x302048UL

+#define REG_VSYNC0           0x30204cUL

+#define REG_VSYNC1           0x302050UL

+

+#if 0

+#define REG_BUSYBITS         0x3020e8UL /* only listed as "reserved" in datasheet */

+#define REG_CRC              0x302178UL /* only listed as "reserved" in datasheet */

+#define REG_SPI_EARLY_TX     0x30217cUL /* only listed as "reserved" in datasheet */

+#define REG_ROMSUB_SEL       0x3020f0UL /* only listed as "reserved" in datasheet */

+#define REG_TOUCH_FAULT      0x302170UL /* only listed as "reserved" in datasheet */

+#endif

+

+

+/* FT81x graphics engine specific macros useful for static display list generation */

+

+/* beware, these are different to FTDIs implementation as these take the original values as parameters and not only the upper bits */

+#define BITMAP_LAYOUT_H(linestride,height) ((40UL<<24)|((((linestride&0xC00)>>10)&3UL)<<2)|((((height&0x600)>>9)&3UL)<<0))

+#define BITMAP_SIZE_H(width,height) ((41UL<<24)|((((width&0x600)>>9)&3UL)<<2)|((((height&0x600)>>9)&3UL)<<0))

+

+#define BITMAP_SOURCE(addr) ((1UL<<24)|(((addr)&4194303UL)<<0))

+#define NOP() ((45UL<<24))

+#define PALETTE_SOURCE(addr) ((42UL<<24)|(((addr)&4194303UL)<<0))

+#define SCISSOR_SIZE(width,height) ((28UL<<24)|(((width)&4095UL)<<12)|(((height)&4095UL)<<0))

+#define SCISSOR_XY(x,y) ((27UL<<24)|(((x)&2047UL)<<11)|(((y)&2047UL)<<0))

+#define VERTEX_FORMAT(frac) ((39UL<<24)|(((frac)&7UL)<<0))

+#define VERTEX_TRANSLATE_X(x) ((43UL<<24)|(((x)&131071UL)<<0))

+#define VERTEX_TRANSLATE_Y(y) ((44UL<<24)|(((y)&131071UL)<<0))

+

+

+

+/* ----------------- FT80x exclusive definitions -----------------*/

+#else

+

+/* Memory definitions */

+#define EVE_RAM_G			0x000000UL

+#define EVE_ROM_CHIPID		0x0C0000UL

+#define EVE_ROM_FONT		0x0BB23CUL

+#define EVE_ROM_FONT_ADDR	0x0FFFFCUL

+#define EVE_RAM_DL			0x100000UL

+#define EVE_RAM_PAL			0x102000UL

+#define EVE_RAM_CMD			0x108000UL

+#define EVE_RAM_SCREENSHOT	0x1C2000UL

+

+

+/* Memory buffer sizes */

+#define EVE_RAM_G_SIZE		256*1024L

+#define EVE_CMDFIFO_SIZE	4*1024L

+#define EVE_RAM_DL_SIZE		8*1024L

+#define EVE_RAM_PAL_SIZE	1*1024L

+

+

+/* Register definitions */

+#define REG_ID					0x102400UL

+#define REG_FRAMES				0x102404UL

+#define REG_CLOCK				0x102408UL

+#define REG_FREQUENCY			0x10240CUL

+#define REG_SCREENSHOT_EN		0x102410UL

+#define REG_SCREENSHOT_Y		0x102414UL

+#define REG_SCREENSHOT_START	0x102418UL

+#define REG_CPURESET 			0x10241CUL

+#define REG_TAP_CRC 			0x102420UL

+#define REG_TAP_MASK 			0x102424UL

+#define REG_HCYCLE 				0x102428UL

+#define REG_HOFFSET 			0x10242CUL

+#define REG_HSIZE 				0x102430UL

+#define REG_HSYNC0 				0x102434UL

+#define REG_HSYNC1 				0x102438UL

+#define REG_VCYCLE 				0x10243CUL

+#define REG_VOFFSET 			0x102440UL

+#define REG_VSIZE 				0x102444UL

+#define REG_VSYNC0 				0x102448UL

+#define REG_VSYNC1 				0x10244CUL

+#define REG_DLSWAP 				0x102450UL

+#define REG_ROTATE 				0x102454UL

+#define REG_OUTBITS 			0x102458UL

+#define REG_DITHER 				0x10245CUL

+#define REG_SWIZZLE 			0x102460UL

+#define REG_CSPREAD 			0x102464UL

+#define REG_PCLK_POL 			0x102468UL

+#define REG_PCLK 				0x10246CUL

+#define REG_TAG_X 				0x102470UL

+#define REG_TAG_Y 				0x102474UL

+#define REG_TAG 				0x102478UL

+#define REG_VOL_PB 				0x10247CUL

+#define REG_VOL_SOUND 			0x102480UL

+#define REG_SOUND 				0x102484UL

+#define REG_PLAY 				0x102488UL

+#define REG_GPIO_DIR 			0x10248CUL

+#define REG_GPIO 				0x102490UL

+#define REG_INT_FLAGS       	0x102498UL

+#define REG_INT_EN          	0x10249CUL

+#define REG_INT_MASK        	0x1024A0UL

+#define REG_PLAYBACK_START  	0x1024A4UL

+#define REG_PLAYBACK_LENGTH  	0x1024A8UL

+#define REG_PLAYBACK_READPTR 	0x1024ACUL

+#define REG_PLAYBACK_FREQ    	0x1024B0UL

+#define REG_PLAYBACK_FORMAT  	0x1024B4UL

+#define REG_PLAYBACK_LOOP    	0x1024B8UL

+#define REG_PLAYBACK_PLAY   	0x1024BCUL

+#define REG_PWM_HZ          	0x1024C0UL

+#define REG_PWM_DUTY        	0x1024C4UL

+#define REG_MACRO_0         	0x1024C8UL

+#define REG_MACRO_1         	0x1024CCUL

+#define REG_SCREENSHOT_BUSY		0x1024D8UL

+#define REG_CMD_READ         	0x1024E4UL

+#define REG_CMD_WRITE        	0x1024E8UL

+#define REG_CMD_DL           	0x1024ECUL

+#define REG_TOUCH_MODE       	0x1024F0UL

+#define REG_TOUCH_ADC_MODE   	0x1024F4UL

+#define REG_TOUCH_CHARGE     	0x1024F8UL

+#define REG_TOUCH_SETTLE     	0x1024FCUL

+#define REG_TOUCH_OVERSAMPLE 	0x102500UL

+#define REG_TOUCH_RZTHRESH   	0x102504UL

+#define REG_TOUCH_RAW_XY     	0x102508UL

+#define REG_TOUCH_RZ         	0x10250CUL

+#define REG_TOUCH_SCREEN_XY  	0x102510UL

+#define REG_TOUCH_TAG_XY     	0x102514UL

+#define REG_TOUCH_TAG        	0x102518UL

+#define REG_TOUCH_TRANSFORM_A	0x10251CUL

+#define REG_TOUCH_TRANSFORM_B	0x102520UL

+#define REG_TOUCH_TRANSFORM_C	0x102524UL

+#define REG_TOUCH_TRANSFORM_D	0x102528UL

+#define REG_TOUCH_TRANSFORM_E	0x10252CUL

+#define REG_TOUCH_TRANSFORM_F	0x102530UL

+#define REG_SCREENSHOT_READ		0x102554UL

+#define REG_TRIM				0x10256CUL

+#define REG_TOUCH_DIRECT_XY 	0x102574UL

+#define REG_TOUCH_DIRECT_Z1Z2	0x102578UL

+#define REG_TRACKER				0x109000UL

+

+/* FT80x graphics engine specific macros useful for static display list generation */

+#define BITMAP_SOURCE(addr) ((1UL<<24)|(((addr)&1048575UL)<<0))

+#define SCISSOR_SIZE(width,height) ((28UL<<24)|(((width)&1023UL)<<10)|(((height)&1023UL)<<0))

+#define SCISSOR_XY(x,y) ((27UL<<24)|(((x)&511UL)<<9)|(((y)&511UL)<<0))

+

+#endif

+

+#endif /* EVE_H_ */

diff --git a/code/fe310/eos/eve/eve_kbd.c b/code/fe310/eos/eve/eve_kbd.c
new file mode 100644
index 0000000..f42b376
--- /dev/null
+++ b/code/fe310/eos/eve/eve_kbd.c
@@ -0,0 +1,124 @@
+#include "eve.h"
+#include "eve_kbd.h"
+
+#define FLAG_SHIFT  0x01
+#define FLAG_CTRL   0x02
+#define FLAG_FN     0x04
+
+#define KEY_SHIFT   0x11
+#define KEY_CTRL    0x12
+#define KEY_FN      0x13
+
+#define KEY_DEL     0x08
+#define KEY_RET     0x0a
+
+#define KEYS_Y      575
+#define KEYS_FSIZE  29
+#define KEYS_HEIGHT 40
+#define KEYS_RSIZE  45
+
+void eve_kbd_init(EVEKbd *kbd, eve_kbd_input_handler_t putc, uint32_t mem_addr, uint32_t *mem_next) {
+    uint16_t mem_size;
+
+    eve_write16(REG_CMD_DL, 0);
+    eve_kbd_draw(kbd, 1);
+    eve_cmd_exec(1);
+    mem_size = eve_read16(REG_CMD_DL);
+    eve_cmd(CMD_MEMCPY, "www", mem_addr, EVE_RAM_DL, mem_size);
+    eve_cmd_exec(1);
+
+    kbd->mem_addr = mem_addr;
+    kbd->mem_size = mem_size;
+    kbd->key_modifier = 0;
+    kbd->key_count = 0;
+    kbd->key_down = 0;
+    kbd->putc = putc;
+    *mem_next = kbd->mem_addr + kbd->mem_size;
+}
+
+int eve_kbd_touch(EVEKbd *kbd, uint8_t tag0, int touch_idx, void *w) {
+    uint16_t evt;
+    EVETouch *t = eve_touch_evt(tag0, touch_idx, 1, 0x7e, &evt);
+
+    if (t && evt) {
+        if (evt & EVE_TOUCH_ETYPE_TAG) {
+            uint8_t _tag = t->tag;
+
+            if (_tag >= KEY_SHIFT && _tag <= KEY_FN) {
+                if (touch_idx == 0) {
+                    uint8_t f = (1 << (_tag - KEY_SHIFT));
+
+                    kbd->key_modifier = f;
+                    kbd->key_modifier_sticky &= f;
+                    kbd->key_modifier_lock &= f;
+                    if (kbd->key_modifier_lock & f) {
+                        kbd->key_modifier_lock &= ~f;
+                    } else if (kbd->key_modifier_sticky & f) {
+                        kbd->key_modifier_sticky &= ~f;
+                        kbd->key_modifier_lock |= f;
+                    } else {
+                        kbd->key_modifier_sticky |= f;
+                    }
+                }
+            } else {
+                kbd->key_count++;
+                kbd->key_down = _tag;
+                if (kbd->putc) {
+                    int c = _tag;
+
+                    if ((kbd->key_modifier & FLAG_CTRL) && (_tag >= '?') && (_tag <= '_')) c = (_tag - '@') & 0x7f;
+                    kbd->putc(w, c);
+                }
+            }
+        }
+        if (evt & EVE_TOUCH_ETYPE_TAG_UP) {
+            uint8_t _tag = t->tag_up;
+
+            if (_tag >= KEY_SHIFT && _tag <= KEY_FN) {
+                if (touch_idx == 0) {
+                    uint8_t f = (1 << (_tag - KEY_SHIFT));
+
+                    if (!((kbd->key_modifier_lock | kbd->key_modifier_sticky) & f)) {
+                        kbd->key_modifier &= ~f;
+                    }
+                }
+            } else {
+                if (kbd->key_count) kbd->key_count--;
+                if (!kbd->key_count) kbd->key_down = 0;
+                if (kbd->key_modifier_sticky) {
+                    if (touch_idx == 0) kbd->key_modifier &= ~kbd->key_modifier_sticky;
+                    kbd->key_modifier_sticky = 0;
+                }
+            }
+        }
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+uint8_t eve_kbd_draw(EVEKbd *kbd, char active) {
+    if (active) {
+        eve_cmd_dl(SAVE_CONTEXT());
+        eve_cmd(CMD_KEYS, "hhhhhhs", 0, KEYS_Y + KEYS_RSIZE * 0, 480, KEYS_HEIGHT, KEYS_FSIZE, kbd->key_down, kbd->key_modifier & (FLAG_FN | FLAG_SHIFT) ? "!@#$%^&*()" : (kbd->key_modifier & FLAG_CTRL ? " @[\\]^_?  " : "1234567890"));
+        eve_cmd(CMD_KEYS, "hhhhhhs", 0, KEYS_Y + KEYS_RSIZE * 1, 480, KEYS_HEIGHT, KEYS_FSIZE, kbd->key_down, kbd->key_modifier & FLAG_FN ? "-_=+[]{}\\|" : kbd->key_modifier & (FLAG_SHIFT | FLAG_CTRL) ? "QWERTYUIOP" : "qwertyuiop");
+        eve_cmd(CMD_KEYS, "hhhhhhs", 24, KEYS_Y + KEYS_RSIZE * 2, 432, KEYS_HEIGHT, KEYS_FSIZE, kbd->key_down, kbd->key_modifier & FLAG_FN ? "`~   ;:'\"" : kbd->key_modifier & (FLAG_SHIFT | FLAG_CTRL) ? "ASDFGHJKL" : "asdfghjkl");
+        eve_cmd(CMD_KEYS, "hhhhhhs", 72, KEYS_Y + KEYS_RSIZE * 3, 335, KEYS_HEIGHT, KEYS_FSIZE, kbd->key_down, kbd->key_modifier & FLAG_FN ? " ,.<>/?" : kbd->key_modifier & (FLAG_SHIFT | FLAG_CTRL) ? "ZXCVBNM" : "zxcvbnm");
+        eve_cmd_dl(TAG(KEY_SHIFT));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", 0, KEYS_Y + KEYS_RSIZE * 3, 69, KEYS_HEIGHT, 21, kbd->key_modifier & FLAG_SHIFT ? EVE_OPT_FLAT : 0, "shift");
+        eve_cmd_dl(TAG(KEY_DEL));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", 410, KEYS_Y + KEYS_RSIZE * 3, 70, KEYS_HEIGHT, 21, kbd->key_down == KEY_DEL ? EVE_OPT_FLAT : 0, "del");
+        eve_cmd_dl(TAG(KEY_FN));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", 0, KEYS_Y + KEYS_RSIZE * 4, 69, KEYS_HEIGHT, 21, kbd->key_modifier & FLAG_FN ? EVE_OPT_FLAT : 0, "fn");
+        eve_cmd_dl(TAG(KEY_CTRL));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", 72, KEYS_Y + KEYS_RSIZE * 4, 69, KEYS_HEIGHT, 21, kbd->key_modifier & FLAG_CTRL ? EVE_OPT_FLAT : 0, "ctrl");
+        eve_cmd_dl(TAG(' '));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", 144, KEYS_Y + KEYS_RSIZE * 4, 263, KEYS_HEIGHT, 21, kbd->key_down == ' ' ? EVE_OPT_FLAT : 0, "");
+        eve_cmd_dl(TAG(KEY_RET));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", 410, KEYS_Y + KEYS_RSIZE * 4, 69, KEYS_HEIGHT, 21, kbd->key_down == KEY_RET ? EVE_OPT_FLAT : 0, "ret");
+        eve_cmd_dl(RESTORE_CONTEXT());
+    } else {
+        eve_cmd(CMD_APPEND, "ww", kbd->mem_addr, kbd->mem_size);
+    }
+    return 0x7e;
+}
diff --git a/code/fe310/eos/eve/eve_kbd.h b/code/fe310/eos/eve/eve_kbd.h
new file mode 100644
index 0000000..c65f7d3
--- /dev/null
+++ b/code/fe310/eos/eve/eve_kbd.h
@@ -0,0 +1,18 @@
+#include <stdint.h>
+
+typedef void (*eve_kbd_input_handler_t) (void *, int);
+
+typedef struct EVEKbd {
+    uint32_t mem_addr;
+    uint16_t mem_size;
+    uint8_t key_count;
+    uint8_t key_down;
+    uint8_t key_modifier;
+    uint8_t key_modifier_sticky;
+    uint8_t key_modifier_lock;
+    eve_kbd_input_handler_t putc;
+} EVEKbd;
+
+void eve_kbd_init(EVEKbd *kbd, eve_kbd_input_handler_t putc_f, uint32_t mem_addr, uint32_t *mem_next);
+int eve_kbd_touch(EVEKbd *kbd, uint8_t tag0, int touch_idx, void *w);
+uint8_t eve_kbd_draw(EVEKbd *kbd, char active);
\ No newline at end of file
diff --git a/code/fe310/eos/eve/eve_text.c b/code/fe310/eos/eve/eve_text.c
new file mode 100644
index 0000000..9470530
--- /dev/null
+++ b/code/fe310/eos/eve/eve_text.c
@@ -0,0 +1,185 @@
+#include "eos.h"
+#include "eve.h"
+#include "eve_text.h"
+
+#define TEXT_ATTR   0x0A
+#define TEXT_CRSR   0x02DB
+
+#define LINE_IDX_ADD(l1,l2,s)       (((((l1) + (l2)) % (s)) + (s)) % (s))
+#define LINE_IDX_SUB(l1,l2,s)       (((((l1) - (l2)) % (s)) + (s)) % (s))
+
+#define LINE_IDX_LTE(l1,l2,s,h)     (LINE_IDX_SUB(l2,l1,s) <= (s) - (h))
+#define LINE_IDX_DIFF(l1,l2,s)      ((l1) > (l2) ? (l1) - (l2) : (s) + (l1) - (l2))
+
+static void scroll1(EVEText *box) {
+    box->line0 = (box->line0 + 1) % box->line_size;
+    eve_cmd(CMD_MEMSET, "www", box->mem_addr + box->ch_idx, 0x0, box->w * 2);
+    eve_cmd_exec(1);
+    box->dirty = 1;
+}
+
+void eve_text_init(EVEText *box, uint16_t x, uint16_t y, uint16_t w, uint16_t h, double scale_x, double scale_y, uint8_t tag, uint16_t line_size, uint32_t mem_addr, uint32_t *mem_next) {
+    box->x = x;
+    box->y = y;
+    box->w = w;
+    box->h = h;
+    box->tag = tag;
+    box->transform_a = 256/scale_x;
+    box->transform_e = 256/scale_y;
+    box->ch_w = scale_x * 8;
+    box->ch_h = scale_y * 16;
+    box->dl_size = 17;
+    box->mem_addr = mem_addr;
+    box->line_size = line_size;
+    box->line0 = 0;
+    box->line_top = -1;
+    box->line_top0 = -1;
+    box->ch_idx = 0;
+    if (box->transform_a != 256) {
+        box->dl_size += 1;
+    }
+    if (box->transform_e != 256) {
+        box->dl_size += 1;
+    }
+
+    eve_touch_set_opt(tag, EVE_TOUCH_OPT_TRACK);
+
+    eve_cmd(CMD_MEMSET, "www", mem_addr, 0x0, box->w * 2 * box->line_size);
+    eve_cmd_exec(1);
+
+    eve_text_update(box);
+    *mem_next = box->mem_addr + box->w * 2 * box->line_size + box->dl_size * 4;
+}
+
+int eve_text_touch(EVEText *box, uint8_t tag0, int touch_idx) {
+    uint16_t evt;
+    EVETouch *t = eve_touch_evt(tag0, touch_idx, box->tag, box->tag, &evt);
+
+    if (t && evt) {
+        if ((evt & EVE_TOUCH_ETYPE_TRACK_START) && (box->line_top < 0)) {
+            box->line_top = box->line0;
+            box->line_top0 = box->line0;
+        }
+        if ((evt & EVE_TOUCH_ETYPE_TRACK) && (box->line_top0 >=0)) {
+            int line = LINE_IDX_ADD(box->line_top0, (t->y0 - t->y) / box->ch_h, box->line_size);
+            if (LINE_IDX_LTE(line, box->line0, box->line_size, box->h)) {
+                box->line_top = line;
+                box->dirty = 1;
+            }
+        }
+        if (evt & EVE_TOUCH_ETYPE_TRACK_STOP) {
+            box->line_top0 = box->line_top;
+        }
+        return 1;
+    } else if (box->line_top >= 0) {
+        box->line_top = -1;
+        box->line_top0 = -1;
+        box->dirty = 1;
+    }
+    return 0;
+}
+
+uint8_t eve_text_draw(EVEText *box) {
+    if (box->dirty) {
+        eve_text_update(box);
+        box->dirty = 0;
+    }
+    eve_cmd(CMD_APPEND, "ww", box->mem_addr + box->w * 2 * box->line_size, box->dl_size * 4);
+    return box->tag;
+}
+
+int eve_text_putc(EVEText *box, int c) {
+    int line_c, line_n;
+
+    switch (c) {
+        case '\b':
+            eve_text_backspace(box);
+            break;
+        case '\r':
+        case '\n':
+            eve_text_newline(box);
+            break;
+        default:
+            line_c = box->ch_idx / 2 / box->w;
+
+            eve_write16(box->mem_addr + box->ch_idx, 0x0200 | (c & 0xff));
+            box->ch_idx = (box->ch_idx + 2) % (box->line_size * box->w * 2);
+            eve_write16(box->mem_addr + box->ch_idx, TEXT_CRSR);
+
+            line_n = box->ch_idx / 2 / box->w;
+            if ((line_c != line_n) && (LINE_IDX_DIFF(line_n, box->line0, box->line_size) == box->h)) scroll1(box);
+            break;
+    }
+    return EOS_OK;
+}
+
+void eve_text_update(EVEText *box) {
+    int text_h1;
+    int text_h2;
+    int line_top;
+
+    line_top = box->line_top >= 0 ? box->line_top : box->line0;
+
+    if (line_top + box->h > box->line_size) {
+        text_h1 = box->line_size - line_top;
+        text_h2 = box->h - text_h1;
+    } else {
+        text_h1 = box->h;
+        text_h2 = 0;
+    }
+    eve_dl_start(box->mem_addr + box->w * 2 * box->line_size);
+
+    eve_dl_write(SAVE_CONTEXT());
+    eve_dl_write(BEGIN(EVE_BITMAPS));
+    eve_dl_write(TAG(box->tag));
+    eve_dl_write(VERTEX_FORMAT(0));
+    eve_dl_write(BITMAP_HANDLE(15));
+    if (box->transform_a != 256) {
+        eve_dl_write(BITMAP_TRANSFORM_A(box->transform_a));
+    }
+    if (box->transform_e != 256) {
+        eve_dl_write(BITMAP_TRANSFORM_E(box->transform_e));
+    }
+    eve_dl_write(BITMAP_SOURCE(box->mem_addr + line_top * box->w * 2));
+    eve_dl_write(BITMAP_LAYOUT(EVE_TEXTVGA, box->w * 2, text_h1));
+    eve_dl_write(BITMAP_SIZE(EVE_NEAREST, EVE_BORDER, EVE_BORDER, box->w * box->ch_w, text_h1 * box->ch_h));
+    eve_dl_write(BITMAP_SIZE_H(box->w * box->ch_w, text_h1 * box->ch_h));
+    eve_dl_write(VERTEX2F(box->x, box->y));
+
+    if (text_h2) {
+        eve_dl_write(BITMAP_SOURCE(box->mem_addr));
+        eve_dl_write(BITMAP_LAYOUT(EVE_TEXTVGA, box->w * 2, text_h2));
+        eve_dl_write(BITMAP_SIZE(EVE_NEAREST, EVE_BORDER, EVE_BORDER, box->w * box->ch_w, text_h2 * box->ch_h));
+        eve_dl_write(BITMAP_SIZE_H(box->w * box->ch_w, text_h2 * box->ch_h));
+        eve_dl_write(VERTEX2F(box->x, box->y + text_h1 * box->ch_h));
+    } else {
+        eve_dl_write(NOP());
+        eve_dl_write(NOP());
+        eve_dl_write(NOP());
+        eve_dl_write(NOP());
+        eve_dl_write(NOP());
+    }
+
+    eve_dl_write(END());
+    eve_dl_write(RESTORE_CONTEXT());
+}
+
+void eve_text_newline(EVEText *box) {
+    int line = (box->ch_idx / 2 / box->w + 1) % box->line_size;
+
+    eve_write16(box->mem_addr + box->ch_idx, 0);
+    box->ch_idx = line * box->w * 2;
+    if (LINE_IDX_DIFF(line, box->line0, box->line_size) == box->h) scroll1(box);
+    eve_write16(box->mem_addr + box->ch_idx, TEXT_CRSR);
+}
+
+void eve_text_backspace(EVEText *box) {
+    uint16_t c;
+
+    eve_write16(box->mem_addr + box->ch_idx, 0);
+    box->ch_idx = (box->ch_idx - 2) % (box->line_size * box->w * 2);
+    if (eve_read16(box->mem_addr + box->ch_idx) == 0) {
+        box->ch_idx = (box->ch_idx + 2) % (box->line_size * box->w * 2);
+    }
+    eve_write16(box->mem_addr + box->ch_idx, TEXT_CRSR);
+}
\ No newline at end of file
diff --git a/code/fe310/eos/eve/eve_text.h b/code/fe310/eos/eve/eve_text.h
new file mode 100644
index 0000000..814a0cd
--- /dev/null
+++ b/code/fe310/eos/eve/eve_text.h
@@ -0,0 +1,29 @@
+#include <stdint.h>
+
+typedef struct EVEText {
+    uint16_t x;
+    uint16_t y;
+    uint16_t w;
+    uint16_t h;
+    uint32_t mem_addr;
+    uint16_t line_size;
+    uint16_t line0;
+    int line_top;
+    int line_top0;
+    uint16_t ch_idx;
+    uint16_t transform_a;
+    uint16_t transform_e;
+    uint8_t tag;
+    uint8_t ch_h;
+    uint8_t ch_w;
+    uint8_t dl_size;
+    char dirty;
+} EVEText;
+
+void eve_text_init(EVEText *box, uint16_t x, uint16_t y, uint16_t w, uint16_t h, double scale_x, double scale_y, uint8_t tag, uint16_t line_size, uint32_t mem_addr, uint32_t *mem_next);
+int eve_text_touch(EVEText *box, uint8_t tag0, int touch_idx);
+uint8_t eve_text_draw(EVEText *box);
+int eve_text_putc(EVEText *box, int c);
+void eve_text_update(EVEText *box);
+void eve_text_newline(EVEText *box);
+void eve_text_backspace(EVEText *box);