111 files changed, 11941 insertions, 0 deletions

diff --git a/fw/fe310/eos/LICENSE b/fw/fe310/eos/LICENSE
new file mode 100644
index 0000000..d159169
--- /dev/null
+++ b/fw/fe310/eos/LICENSE
@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/fw/fe310/eos/Makefile b/fw/fe310/eos/Makefile
new file mode 100644
index 0000000..abdcbac
--- /dev/null
+++ b/fw/fe310/eos/Makefile
@@ -0,0 +1,19 @@
+include ../common.mk
+
+CRYPTO_DIR = ../../../crypto
+
+CFLAGS += -I. -I../bsp/include -I../bsp/drivers -I$(CRYPTO_DIR)
+
+obj = trap_entry.o eos.o msgq.o event.o interrupt.o timer.o power.o i2s.o i2c.o uart.o spi.o spi_dev.o sdcard.o sdc_crypto.o cam.o net.o wifi.o cell.o sock.o unicode.o
+
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $<
+
+%.o: %.S
+	$(CC) $(CFLAGS) -c $<
+
+all: $(obj)
+
+clean:
+	rm -f *.o
diff --git a/fw/fe310/eos/app/Makefile b/fw/fe310/eos/app/Makefile
new file mode 100644
index 0000000..e0eee28
--- /dev/null
+++ b/fw/fe310/eos/app/Makefile
@@ -0,0 +1,17 @@
+include ../../common.mk
+
+CFLAGS += -I..
+
+obj = app_root.o app_status.o
+
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $<
+
+%.o: %.S
+	$(CC) $(CFLAGS) -c $<
+
+all: $(obj)
+
+clean:
+	rm -f *.o
diff --git a/fw/fe310/eos/app/app_root.c b/fw/fe310/eos/app/app_root.c
new file mode 100644
index 0000000..1b46ea8
--- /dev/null
+++ b/fw/fe310/eos/app/app_root.c
@@ -0,0 +1,88 @@
+#include <stdlib.h>
+
+#include "net.h"
+
+#include "eve/eve.h"
+#include "eve/eve_kbd.h"
+#include "eve/eve_font.h"
+
+#include "eve/screen/window.h"
+#include "eve/screen/page.h"
+#include "eve/screen/form.h"
+
+#include "eve/widget/widgets.h"
+
+#include "app_status.h"
+#include "app_root.h"
+
+#define KBD_X           0
+#define KBD_Y           575
+#define KBD_W           480
+#define KBD_H           225
+
+static EVEKbd kbd;
+static EVEFont font;
+static EVEWindowRoot win_root;
+static EVEWindowKbd win_kbd;
+static EVEWindow win_status;
+static EVEWindow win_main;
+static EVEView view_status;
+static EVEViewStack view_stack;
+
+EVEWindowRoot *app_root(void) {
+    return &win_root;
+}
+
+void app_root_refresh(void) {
+    eve_spi_start();
+    eve_window_root_draw(app_root());
+    eve_spi_stop();
+}
+
+void app_root_init(eve_view_constructor_t home_page) {
+    EVERect g;
+
+    eve_spi_start();
+
+    eve_brightness(0x40);
+
+    eve_font_init(&font, APP_FONT_HANDLE);
+
+    g.x = 0;
+    g.y = 0;
+    g.w = APP_SCREEN_W;
+    g.h = APP_SCREEN_H;
+    eve_window_init_root(&win_root, &g, "root", &font);
+
+    g.x = KBD_X;
+    g.y = KBD_Y;
+    g.w = KBD_W;
+    g.h = KBD_H;
+    eve_kbd_init(&kbd, &g, win_root.mem_next, &win_root.mem_next);
+    eve_window_init_kbd(&win_kbd, &g, &win_root, "kbd", &kbd);
+
+    g.x = 0;
+    g.y = 0;
+    g.w = APP_SCREEN_W;
+    g.h = APP_STATUS_H;
+    eve_window_init(&win_status, &g, (EVEWindow *)&win_root, "status");
+    eve_view_init(&view_status, &win_status, app_status_draw, app_status_touch, NULL, NULL);
+
+    g.x = 0;
+    g.y = APP_STATUS_H;
+    g.w = APP_SCREEN_W;
+    g.h = APP_SCREEN_H - APP_STATUS_H;
+    eve_window_init(&win_main, &g, (EVEWindow *)&win_root, "main");
+
+    eve_view_stack_init(&view_stack);
+    eve_view_create(&win_main, &view_stack, home_page);
+
+    eve_window_append(&win_status);
+    eve_window_append(&win_main);
+
+    eve_window_root_draw(&win_root);
+
+    eve_spi_stop();
+
+    eos_net_acquire_for_evt(EOS_EVT_UI | EVE_ETYPE_INTR, 1);
+}
diff --git a/fw/fe310/eos/app/app_root.h b/fw/fe310/eos/app/app_root.h
new file mode 100644
index 0000000..7a44565
--- /dev/null
+++ b/fw/fe310/eos/app/app_root.h
@@ -0,0 +1,12 @@
+#include <stdint.h>
+
+#define APP_SCREEN_W        480
+#define APP_SCREEN_H        800
+#define APP_STATUS_H        60
+
+#define APP_FONT_HANDLE     31
+
+EVEWindowRoot *app_root(void);
+void app_root_refresh(void);
+
+void app_root_init(eve_view_constructor_t home_page);
diff --git a/fw/fe310/eos/app/app_status.c b/fw/fe310/eos/app/app_status.c
new file mode 100644
index 0000000..4ab0a97
--- /dev/null
+++ b/fw/fe310/eos/app/app_status.c
@@ -0,0 +1,17 @@
+#include <stdlib.h>
+
+#include "eve/eve.h"
+#include "eve/eve_kbd.h"
+#include "eve/eve_font.h"
+
+#include "eve/screen/window.h"
+
+#include "app_status.h"
+
+uint8_t app_status_draw(EVEView *view, uint8_t tag0) {
+    return eve_view_clear(view, tag0, 0);
+}
+
+int app_status_touch(EVEView *view, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    return 0;
+}
diff --git a/fw/fe310/eos/app/app_status.h b/fw/fe310/eos/app/app_status.h
new file mode 100644
index 0000000..9b2ac66
--- /dev/null
+++ b/fw/fe310/eos/app/app_status.h
@@ -0,0 +1,4 @@
+#include <stdint.h>
+
+int app_status_touch(EVEView *view, EVETouch *touch, uint16_t evt, uint8_t tag0);
+uint8_t app_status_draw(EVEView *view, uint8_t tag0);
diff --git a/fw/fe310/eos/board.h b/fw/fe310/eos/board.h
new file mode 100644
index 0000000..752808a
--- /dev/null
+++ b/fw/fe310/eos/board.h
@@ -0,0 +1,42 @@
+#define SPI_DIV_NET             16
+#define SPI_DIV_EVE             16
+#define SPI_DIV_SDC             1024
+#define SPI_DIV_CAM             24
+
+#define SPI_CSID_NET            3
+#define SPI_CSID_EVE            2
+#define SPI_CSID_SDC            SPI_CSID_NONE
+#define SPI_CSID_CAM            SPI_CSID_NONE
+
+#define SPI_CSPIN_NET           SPI_CSPIN_NONE
+#define SPI_CSPIN_EVE           SPI_CSPIN_NONE
+#define SPI_CSPIN_SDC           2
+#define SPI_CSPIN_CAM           23
+
+#define SPI_IOF_MASK_CS         (((uint32_t)1 << IOF_SPI1_SS2) | ((uint32_t)1 << IOF_SPI1_SS3))
+
+#define NET_PIN_RTS             20
+#define NET_PIN_CTS             22
+
+#define I2S_PIN_CK              1       /* PWM 0.1 */
+#define I2S_PIN_CK_SW           21      /* PWM 1.2 */
+#define I2S_PIN_CK_SR           18
+#define I2S_PIN_WS_MIC          19      /* PWM 1.1 */
+#define I2S_PIN_WS_SPK          11      /* PWM 2.1 */
+#define I2S_PIN_SD_IN           13
+#define I2S_PIN_SD_OUT          12
+
+#define I2S_IRQ_WS_ID           (INT_PWM2_BASE + 0)
+#define I2S_IRQ_SD_ID           (INT_PWM2_BASE + 3)
+
+#define I2S_CTRL_ADDR_CK        PWM0_CTRL_ADDR
+#define I2S_CTRL_ADDR_WS_MIC    PWM1_CTRL_ADDR
+#define I2S_CTRL_ADDR_WS_SPK    PWM2_CTRL_ADDR
+
+#define I2S_IDLE_CYCLES         8
+
+#define EVE_GPIO_DIR            0x0f
+
+#define EVE_GPIO_CAM            0
+#define EVE_GPIO_EXT            1
+#define EVE_GPIO_MOTOR          3
diff --git a/fw/fe310/eos/cam.c b/fw/fe310/eos/cam.c
new file mode 100644
index 0000000..43293af
--- /dev/null
+++ b/fw/fe310/eos/cam.c
@@ -0,0 +1,138 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "eos.h"
+#include "spi.h"
+#include "cam.h"
+
+const int _eos_cam_resolution[][2] = {
+    {0,    0   },
+    // C/SIF Resolutions
+    {88,   72  },    /* QQCIF     */
+    {176,  144 },    /* QCIF      */
+    {352,  288 },    /* CIF       */
+    {88,   60  },    /* QQSIF     */
+    {176,  120 },    /* QSIF      */
+    {352,  240 },    /* SIF       */
+    // VGA Resolutions
+    {40,   30  },    /* QQQQVGA   */
+    {80,   60  },    /* QQQVGA    */
+    {160,  120 },    /* QQVGA     */
+    {320,  240 },    /* QVGA      */
+    {640,  480 },    /* VGA       */
+    {60,   40  },    /* HQQQVGA   */
+    {120,  80  },    /* HQQVGA    */
+    {240,  160 },    /* HQVGA     */
+    // FFT Resolutions
+    {64,   32  },    /* 64x32     */
+    {64,   64  },    /* 64x64     */
+    {128,  64  },    /* 128x64    */
+    {128,  128 },    /* 128x128   */
+    {320,  320 },    /* 128x128   */
+    // Other
+    {128,  160 },    /* LCD       */
+    {128,  160 },    /* QQVGA2    */
+    {720,  480 },    /* WVGA      */
+    {752,  480 },    /* WVGA2     */
+    {800,  600 },    /* SVGA      */
+    {1024, 768 },    /* XGA       */
+    {1280, 1024},    /* SXGA      */
+    {1600, 1200},    /* UXGA      */
+    {1280, 720 },    /* HD        */
+    {1920, 1080},    /* FHD       */
+    {2560, 1440},    /* QHD       */
+    {2048, 1536},    /* QXGA      */
+    {2560, 1600},    /* WQXGA     */
+    {2592, 1944},    /* WQXGA2    */
+};
+
+#define CAM_REG_CAPTURE_CTRL        0x01
+#define CAM_REG_FIFO_CTRL           0x04
+
+#define CAM_REG_GPIO_DIR            0x05
+#define CAM_REG_GPIO_WR             0x06
+#define CAM_REG_GPIO_RD             0x45
+
+#define CAM_REG_STATUS              0x41
+
+#define CAM_REG_VER                 0x40
+
+#define CAM_REG_READ_BURST          0x3c
+#define CAM_REG_READ_BYTE           0x3d
+
+#define CAM_REG_FIFO_SIZE1          0x42
+#define CAM_REG_FIFO_SIZE2          0x43
+#define CAM_REG_FIFO_SIZE3          0x44
+
+#define CAM_VAL_FIFO_CTRL_CLEAR     0x01
+#define CAM_VAL_FIFO_CTRL_START     0x02
+#define CAM_VAL_FIFO_CTRL_RSTWR     0x10
+#define CAM_VAL_FIFO_CTRL_RSTRD     0x20
+
+#define CAM_VAL_STATUS_VSYNC        0x01
+#define CAM_VAL_STATUS_SHUTTER      0x02
+#define CAM_VAL_STATUS_CPTDONE      0x08
+
+#define CAM_VAL_GPIO_RST            0x01
+#define CAM_VAL_GPIO_PWRDN          0x02
+#define CAM_VAL_GPIO_PWREN          0x04
+
+static uint8_t reg_read(uint8_t addr) {
+    uint8_t ret;
+
+    eos_spi_cs_set();
+    eos_spi_xchg8(addr, 0);
+    ret = eos_spi_xchg8(0, 0);
+    eos_spi_cs_clear();
+
+    return ret;
+}
+
+static void reg_write(uint8_t addr, uint8_t val) {
+    eos_spi_cs_set();
+    eos_spi_xchg8(addr | 0x80, 0);
+    eos_spi_xchg8(val, 0);
+    eos_spi_cs_clear();
+}
+
+void eos_cam_capture(void) {
+    reg_write(CAM_REG_FIFO_CTRL, CAM_VAL_FIFO_CTRL_START);
+}
+
+int eos_cam_capture_done(void) {
+    return !!(reg_read(CAM_REG_STATUS) & CAM_VAL_STATUS_CPTDONE);
+}
+
+void eos_cam_capture_wait(void) {
+    int done = 0;
+    
+    while (!done) {
+        done = eos_cam_capture_done();
+    }
+}
+
+uint32_t eos_cam_fbuf_size(void) {
+    uint32_t ret;
+    
+	ret = reg_read(CAM_REG_FIFO_SIZE1);
+    ret |= reg_read(CAM_REG_FIFO_SIZE2) << 8;
+    ret |= (reg_read(CAM_REG_FIFO_SIZE3) & 0x7f) << 16;
+    return ret;
+}
+
+void eos_cam_fbuf_read(uint8_t *buffer, uint16_t sz, int first) {
+    int i;
+    
+    eos_spi_cs_set();
+    eos_spi_xchg8(CAM_REG_READ_BURST, 0);
+    if (first) eos_spi_xchg8(0, 0);
+
+    for (i=0; i<sz; i++) {
+        buffer[i] = eos_spi_xchg8(0, 0);
+    }
+    eos_spi_cs_clear();
+}
+
+void eos_cam_fbuf_done(void) {
+    reg_write(CAM_REG_FIFO_CTRL, CAM_VAL_FIFO_CTRL_CLEAR);
+}
diff --git a/fw/fe310/eos/cam.h b/fw/fe310/eos/cam.h
new file mode 100644
index 0000000..f61757b
--- /dev/null
+++ b/fw/fe310/eos/cam.h
@@ -0,0 +1,88 @@
+#include <stdint.h>
+
+typedef enum {
+    PIXFORMAT_INVALID = 0,
+    PIXFORMAT_BINARY,    // 1BPP/BINARY
+    PIXFORMAT_GRAYSCALE, // 1BPP/GRAYSCALE
+    PIXFORMAT_RGB565,    // 2BPP/RGB565
+    PIXFORMAT_YUV422,    // 2BPP/YUV422
+    PIXFORMAT_BAYER,     // 1BPP/RAW
+    PIXFORMAT_JPEG,      // JPEG/COMPRESSED
+} pixformat_t;
+
+typedef enum {
+    FRAMESIZE_INVALID = 0,
+    // C/SIF Resolutions
+    FRAMESIZE_QQCIF,    // 88x72
+    FRAMESIZE_QCIF,     // 176x144
+    FRAMESIZE_CIF,      // 352x288
+    FRAMESIZE_QQSIF,    // 88x60
+    FRAMESIZE_QSIF,     // 176x120
+    FRAMESIZE_SIF,      // 352x240
+    // VGA Resolutions
+    FRAMESIZE_QQQQVGA,  // 40x30
+    FRAMESIZE_QQQVGA,   // 80x60
+    FRAMESIZE_QQVGA,    // 160x120
+    FRAMESIZE_QVGA,     // 320x240
+    FRAMESIZE_VGA,      // 640x480
+    FRAMESIZE_HQQQVGA,  // 60x40
+    FRAMESIZE_HQQVGA,   // 120x80
+    FRAMESIZE_HQVGA,    // 240x160
+    // FFT Resolutions
+    FRAMESIZE_64X32,    // 64x32
+    FRAMESIZE_64X64,    // 64x64
+    FRAMESIZE_128X64,   // 128x64
+    FRAMESIZE_128X128,  // 128x128
+    FRAMESIZE_320X320,  // 320x320
+    // Other
+    FRAMESIZE_LCD,      // 128x160
+    FRAMESIZE_QQVGA2,   // 128x160
+    FRAMESIZE_WVGA,     // 720x480
+    FRAMESIZE_WVGA2,    // 752x480
+    FRAMESIZE_SVGA,     // 800x600
+    FRAMESIZE_XGA,      // 1024x768
+    FRAMESIZE_SXGA,     // 1280x1024
+    FRAMESIZE_UXGA,     // 1600x1200
+    FRAMESIZE_HD,       // 1280x720
+    FRAMESIZE_FHD,      // 1920x1080
+    FRAMESIZE_QHD,      // 2560x1440
+    FRAMESIZE_QXGA,     // 2048x1536
+    FRAMESIZE_WQXGA,    // 2560x1600
+    FRAMESIZE_WQXGA2,   // 2592x1944
+} framesize_t;
+
+typedef enum {
+    GAINCEILING_2X,
+    GAINCEILING_4X,
+    GAINCEILING_8X,
+    GAINCEILING_16X,
+    GAINCEILING_32X,
+    GAINCEILING_64X,
+    GAINCEILING_128X,
+} gainceiling_t;
+
+typedef enum {
+    SDE_NORMAL,
+    SDE_NEGATIVE,
+} sde_t;
+
+extern const int _eos_cam_resolution[][2];
+
+#define IM_LOG2_2(x)    (((x) &                0x2ULL) ? ( 2                        ) :             1) // NO ({ ... }) !
+#define IM_LOG2_4(x)    (((x) &                0xCULL) ? ( 2 +  IM_LOG2_2((x) >>  2)) :  IM_LOG2_2(x)) // NO ({ ... }) !
+#define IM_LOG2_8(x)    (((x) &               0xF0ULL) ? ( 4 +  IM_LOG2_4((x) >>  4)) :  IM_LOG2_4(x)) // NO ({ ... }) !
+#define IM_LOG2_16(x)   (((x) &             0xFF00ULL) ? ( 8 +  IM_LOG2_8((x) >>  8)) :  IM_LOG2_8(x)) // NO ({ ... }) !
+#define IM_LOG2_32(x)   (((x) &         0xFFFF0000ULL) ? (16 + IM_LOG2_16((x) >> 16)) : IM_LOG2_16(x)) // NO ({ ... }) !
+#define IM_LOG2(x)      (((x) & 0xFFFFFFFF00000000ULL) ? (32 + IM_LOG2_32((x) >> 32)) : IM_LOG2_32(x)) // NO ({ ... }) !
+
+#define IM_MAX(a,b)     ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _a > _b ? _a : _b; })
+#define IM_MIN(a,b)     ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _a < _b ? _a : _b; })
+#define IM_DIV(a,b)     ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _b ? (_a / _b) : 0; })
+#define IM_MOD(a,b)     ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _b ? (_a % _b) : 0; })
+
+void eos_cam_capture(void);
+int eos_cam_capture_done(void);
+void eos_cam_capture_wait(void);
+uint32_t eos_cam_fbuf_size(void);
+void eos_cam_fbuf_read(uint8_t *buffer, uint16_t sz, int first);
+void eos_cam_fbuf_done(void);
diff --git a/fw/fe310/eos/cell.c b/fw/fe310/eos/cell.c
new file mode 100644
index 0000000..2886041
--- /dev/null
+++ b/fw/fe310/eos/cell.c
@@ -0,0 +1,51 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "eos.h"
+#include "event.h"
+#include "net.h"
+
+#include "cell.h"
+
+static eos_evt_handler_t evt_handler[EOS_CELL_MAX_MTYPE];
+
+static void cell_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char mtype;
+    unsigned char idx;
+
+    if ((buffer == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, buffer, len);
+        return;
+    }
+
+    mtype = buffer[0];
+    idx = (mtype & EOS_CELL_MTYPE_MASK) >> 4;
+    if ((idx < EOS_CELL_MAX_MTYPE) && evt_handler[idx]) {
+        evt_handler[idx](mtype & ~EOS_CELL_MTYPE_MASK, buffer, len);
+    } else {
+        eos_net_bad_handler(type, buffer, len);
+    }
+}
+
+void eos_cell_init(void) {
+    int i;
+
+    for (i=0; i<EOS_CELL_MAX_MTYPE; i++) {
+        evt_handler[i] = NULL;
+    }
+    eos_net_set_handler(EOS_NET_MTYPE_CELL, cell_handle_msg);
+}
+
+void eos_cell_set_handler(unsigned char mtype, eos_evt_handler_t handler) {
+    unsigned char idx = (mtype & EOS_CELL_MTYPE_MASK) >> 4;
+
+    if (idx < EOS_CELL_MAX_MTYPE) evt_handler[idx] = handler;
+}
+
+eos_evt_handler_t eos_cell_get_handler(unsigned char mtype) {
+    unsigned char idx = (mtype & EOS_CELL_MTYPE_MASK) >> 4;
+
+    if (idx < EOS_CELL_MAX_MTYPE) return evt_handler[idx];
+    return NULL;
+}
diff --git a/fw/fe310/eos/cell.h b/fw/fe310/eos/cell.h
new file mode 100644
index 0000000..0fc2052
--- /dev/null
+++ b/fw/fe310/eos/cell.h
@@ -0,0 +1,51 @@
+#include <stdint.h>
+#include "event.h"
+
+#define EOS_CELL_MTYPE_DEV              0x10
+#define EOS_CELL_MTYPE_VOICE            0x20
+#define EOS_CELL_MTYPE_SMS              0x30
+#define EOS_CELL_MTYPE_CBS              0x40
+#define EOS_CELL_MTYPE_USSD             0x50
+#define EOS_CELL_MTYPE_PDP              0x60
+
+#define EOS_CELL_MTYPE_MASK             0xf0
+#define EOS_CELL_MAX_MTYPE              8
+
+/* EOS_CELL_MTYPE_DEV subtypes */
+#define EOS_CELL_MTYPE_READY            1
+#define EOS_CELL_MTYPE_UART_DATA        2
+#define EOS_CELL_MTYPE_UART_TAKE        3
+#define EOS_CELL_MTYPE_UART_GIVE        4
+#define EOS_CELL_MTYPE_RESET            5
+
+#define EOS_CELL_MTYPE_VOICE_PCM        1
+#define EOS_CELL_MTYPE_VOICE_DIAL       2
+#define EOS_CELL_MTYPE_VOICE_RING       3
+#define EOS_CELL_MTYPE_VOICE_ANSWER     4
+#define EOS_CELL_MTYPE_VOICE_HANGUP     5
+#define EOS_CELL_MTYPE_VOICE_BEGIN      6
+#define EOS_CELL_MTYPE_VOICE_END        7
+#define EOS_CELL_MTYPE_VOICE_MISS       8
+#define EOS_CELL_MTYPE_VOICE_BUSY       9
+#define EOS_CELL_MTYPE_VOICE_ERR        10
+
+#define EOS_CELL_MTYPE_SMS_LIST         1
+#define EOS_CELL_MTYPE_SMS_SEND         2
+#define EOS_CELL_MTYPE_SMS_MSG_NEW      3
+#define EOS_CELL_MTYPE_SMS_MSG_ITEM     4
+
+#define EOS_CELL_MTYPE_USSD_REQUEST     1
+#define EOS_CELL_MTYPE_USSD_REPLY       2
+#define EOS_CELL_MTYPE_USSD_CANCEL      3
+
+#define EOS_CELL_MTYPE_PDP_CONFIG       1
+#define EOS_CELL_MTYPE_PDP_CONNECT      2
+#define EOS_CELL_MTYPE_PDP_DISCONNECT   3
+
+#define EOS_CELL_SMS_ADDRTYPE_INTL      1
+#define EOS_CELL_SMS_ADDRTYPE_ALPHA     2
+#define EOS_CELL_SMS_ADDRTYPE_OTHER     3
+
+void eos_cell_init(void);
+void eos_cell_set_handler(unsigned char mtype, eos_evt_handler_t handler);
+eos_evt_handler_t eos_cell_get_handler(unsigned char mtype);
\ No newline at end of file
diff --git a/fw/fe310/eos/eos.c b/fw/fe310/eos/eos.c
new file mode 100644
index 0000000..e2ad3d1
--- /dev/null
+++ b/fw/fe310/eos/eos.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+
+#include "event.h"
+#include "interrupt.h"
+#include "timer.h"
+#include "power.h"
+#include "i2s.h"
+#include "uart.h"
+#include "spi.h"
+#include "spi_dev.h"
+#include "sdcard.h"
+#include "net.h"
+#include "wifi.h"
+#include "cell.h"
+#include "sock.h"
+#include "i2c/bq25895.h"
+#include "eve/eve.h"
+
+#include "board.h"
+
+#include "eos.h"
+
+void eos_init(void) {
+    uint8_t wakeup_cause = eos_power_wakeup_cause();
+    uint32_t touch_matrix[6] = {0xfa46,0xfffffcf6,0x422fe,0xffffff38,0x10002,0xf3cb0};
+    int touch_calibrate = 0;
+
+    printf("WAKE:%d\n", wakeup_cause);
+
+    eos_evtq_init();
+    eos_intr_init();
+    eos_timer_init();
+    eos_i2s_init();
+    eos_uart_init();
+    eos_spi_init();
+    eos_spi_dev_init();
+    eos_sdc_init();
+    eos_net_init();
+    eos_power_init();
+    eos_wifi_init();
+    eos_cell_init();
+    eos_sock_init();
+    eos_bq25895_init();
+
+    eos_net_start(wakeup_cause);
+
+    eve_init(wakeup_cause == EOS_PWR_WAKE_RST, touch_calibrate, touch_matrix, EVE_GPIO_DIR);
+    if (touch_calibrate) {
+        printf("TOUCH MATRIX:\n");
+        printf("uint32_t touch_matrix[6] = {0x%x,0x%x,0x%x,0x%x,0x%x,0x%x}\n", touch_matrix[0], touch_matrix[1], touch_matrix[2], touch_matrix[3], touch_matrix[4], touch_matrix[5]);
+    }
+}
diff --git a/fw/fe310/eos/eos.h b/fw/fe310/eos/eos.h
new file mode 100644
index 0000000..2a295f1
--- /dev/null
+++ b/fw/fe310/eos/eos.h
@@ -0,0 +1,12 @@
+#define EOS_OK                  0
+#define EOS_ERR                 -1
+#define EOS_ERR_TIMEOUT         -2
+#define EOS_ERR_BUSY            -3
+
+#define EOS_ERR_FULL            -10
+#define EOS_ERR_EMPTY           -11
+#define EOS_ERR_NOTFOUND        -12
+
+#define EOS_ERR_NET             -20
+
+void eos_init(void);
diff --git a/fw/fe310/eos/eve/Makefile b/fw/fe310/eos/eve/Makefile
new file mode 100644
index 0000000..e55ef7a
--- /dev/null
+++ b/fw/fe310/eos/eve/Makefile
@@ -0,0 +1,17 @@
+include ../../common.mk
+
+CFLAGS += -I.. -I../../bsp/include
+
+obj = eve.o eve_platform.o eve_touch.o eve_phy.o eve_vtrack.o eve_font.o eve_kbd.o eve_text.o clipb.o
+
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $<
+
+%.o: %.S
+	$(CC) $(CFLAGS) -c $<
+
+all: $(obj)
+
+clean:
+	rm -f *.o
diff --git a/fw/fe310/eos/eve/clipb.c b/fw/fe310/eos/eve/clipb.c
new file mode 100644
index 0000000..974b631
--- /dev/null
+++ b/fw/fe310/eos/eve/clipb.c
@@ -0,0 +1,19 @@
+#include <string.h>
+
+#include "eve.h"
+#include "clipb.h"
+
+static uint8_t clipb[EVE_CLIPB_SIZE_BUF];
+
+int eve_clipb_push(uint8_t *str, uint16_t len) {
+    if (len >= EVE_CLIPB_SIZE_BUF) return EVE_ERR;
+
+    memcpy(clipb, str, len);
+    clipb[len] = '\0';
+
+    return EVE_OK;
+}
+
+uint8_t *eve_clipb_get(void) {
+    return clipb;
+}
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/clipb.h b/fw/fe310/eos/eve/clipb.h
new file mode 100644
index 0000000..2d6fae6
--- /dev/null
+++ b/fw/fe310/eos/eve/clipb.h
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+#define EVE_CLIPB_SIZE_BUF  256
+
+int eve_clipb_push(uint8_t *str, uint16_t len);
+uint8_t *eve_clipb_get(void);
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/eve.c b/fw/fe310/eos/eve/eve.c
new file mode 100644
index 0000000..d625fec
--- /dev/null
+++ b/fw/fe310/eos/eve/eve.c
@@ -0,0 +1,476 @@
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include "eve.h"
+
+#define EVE_MEM_WRITE           0x800000
+#define EVE_SPI_FLAGS(b)        ( (b) ? (EVE_SPI_FLAG_TX | EVE_SPI_FLAG_BSWAP) : EVE_SPI_FLAG_BSWAP )
+
+static char cmd_burst;
+static uint16_t cmd_offset;
+
+static char dl_burst;
+static uint32_t dl_addr;
+
+static uint8_t brigtness;
+static uint8_t power_state;
+
+void eve_command(uint8_t command, uint8_t parameter) {
+    eve_spi_cs_set();
+    eve_spi_xchg24(((uint32_t)command << 16) | ((uint32_t)parameter << 8), 0);
+    eve_spi_cs_clear();
+}
+
+uint8_t eve_read8(uint32_t addr) {
+    uint8_t r;
+    eve_spi_cs_set();
+    eve_spi_xchg32(addr << 8, 0);
+    r = eve_spi_xchg8(0, EVE_SPI_FLAG_BSWAP);
+    eve_spi_cs_clear();
+
+    return r;
+}
+
+uint16_t eve_read16(uint32_t addr) {
+    uint16_t r;
+    eve_spi_cs_set();
+    eve_spi_xchg32(addr << 8, 0);
+    r = eve_spi_xchg16(0, EVE_SPI_FLAG_BSWAP);
+    eve_spi_cs_clear();
+
+    return r;
+}
+
+uint32_t eve_read32(uint32_t addr) {
+    uint32_t r;
+    eve_spi_cs_set();
+    eve_spi_xchg32(addr << 8, 0);
+    r = eve_spi_xchg32(0, EVE_SPI_FLAG_BSWAP);
+    eve_spi_cs_clear();
+
+    return r;
+}
+
+void eve_write8(uint32_t addr, uint8_t data) {
+    eve_spi_cs_set();
+    eve_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    eve_spi_xchg8(data, EVE_SPI_FLAG_BSWAP);
+    eve_spi_cs_clear();
+}
+
+void eve_write16(uint32_t addr, uint16_t data) {
+    eve_spi_cs_set();
+    eve_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    eve_spi_xchg16(data, EVE_SPI_FLAG_BSWAP);
+    eve_spi_cs_clear();
+}
+
+void eve_write32(uint32_t addr, uint32_t data) {
+    eve_spi_cs_set();
+    eve_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    eve_spi_xchg32(data, EVE_SPI_FLAG_BSWAP);
+    eve_spi_cs_clear();
+}
+
+void eve_readb(uint32_t addr, uint8_t *buf, size_t size) {
+    int i;
+
+    eve_spi_cs_set();
+    eve_spi_xchg32(addr << 8, 0);
+    for (i=0; i<size; i++) {
+        buf[i] = eve_spi_xchg8(0, 0);
+    }
+    eve_spi_cs_clear();
+}
+
+void eve_writeb(uint32_t addr, uint8_t *buf, size_t size) {
+    int i;
+
+    eve_spi_cs_set();
+    eve_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    for (i=0; i<size; i++) {
+        eve_spi_xchg8(buf[i], 0);
+    }
+    eve_spi_cs_clear();
+}
+
+static void dl_inc(uint32_t i) {
+    dl_addr += i;
+}
+
+void eve_dl_start(uint32_t addr, char burst) {
+    dl_addr = addr;
+    dl_burst = burst;
+    if (burst) {
+        eve_spi_lock();
+        eve_spi_cs_set();
+        eve_spi_xchg24(addr | EVE_MEM_WRITE, EVE_SPI_FLAG_TX);
+    }
+}
+
+void eve_dl_write(uint32_t dl) {
+    if (dl_burst) {
+        eve_spi_xchg32(dl, EVE_SPI_FLAGS(dl_burst));
+    } else {
+        eve_write32(dl_addr, dl);
+    }
+    dl_inc(4);
+}
+
+void eve_dl_end(void) {
+    if (dl_burst) {
+        eve_spi_flush();
+        eve_spi_cs_clear();
+        eve_spi_unlock();
+        dl_burst = 0;
+    }
+}
+
+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) {
+    if (!cmd_burst) {
+        uint32_t addr = EVE_RAM_CMD + cmd_offset;
+        eve_spi_cs_set();
+        eve_spi_xchg24(addr | EVE_MEM_WRITE, 0);
+    }
+    eve_spi_xchg32(command, flags);
+    cmd_inc(4);
+}
+
+static void cmd_end(void) {
+    if (!cmd_burst) eve_spi_cs_clear();
+}
+
+static void cmd_string(const char *str, uint8_t flags) {
+    int i = 0;
+
+    while (str[i] != 0) {
+        eve_spi_xchg8(str[i], flags);
+        i++;
+    }
+    eve_spi_xchg8(0, flags);
+    i++;
+    cmd_inc(i);
+}
+
+static void cmd_buffer(const char *buf, int size, uint8_t flags) {
+    int i = 0;
+
+    for (i=0; i<size; i++) {
+        eve_spi_xchg8(buf[i], flags);
+    }
+    cmd_inc(size);
+}
+
+static void cmd_padding(uint8_t flags) {
+    int i = cmd_offset & 3;  /* equivalent to cmd_offset % 4 */
+
+    if (i) {
+        i = 4 - i;  /* 3, 2 or 1 */
+        cmd_inc(i);
+
+        while (i > 0) {
+            eve_spi_xchg8(0, flags);
+            i--;
+        }
+    }
+}
+
+void eve_cmd(uint32_t cmd, const char *fmt, ...) {
+    uint8_t flags = EVE_SPI_FLAGS(cmd_burst);
+    va_list argv;
+    uint16_t *p;
+    int i = 0;
+    int cont = 0;
+
+    va_start(argv, fmt);
+    cmd_begin(cmd, flags);
+    while (fmt[i]) {
+        switch (fmt[i]) {
+            case 'b':
+                eve_spi_xchg8(va_arg(argv, int), flags);
+                cmd_inc(1);
+                break;
+            case 'h':
+                eve_spi_xchg16(va_arg(argv, int), flags);
+                cmd_inc(2);
+                break;
+            case 'w':
+                eve_spi_xchg32(va_arg(argv, int), flags);
+                cmd_inc(4);
+                break;
+            case '&':
+                p = va_arg(argv, uint16_t *);
+                *p = cmd_offset;
+                eve_spi_xchg32(0, 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;
+            case '+':
+                cont = 1;
+                break;
+        }
+        if (cont) break;
+        i++;
+    }
+    va_end(argv);
+    if (!cont) eve_cmd_end();
+}
+
+void eve_cmd_write(uint8_t *buffer, size_t size) {
+    cmd_buffer(buffer, size, EVE_SPI_FLAGS(cmd_burst));
+}
+
+void eve_cmd_end(void) {
+    cmd_padding(EVE_SPI_FLAGS(cmd_burst));
+    cmd_end();
+}
+
+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, EVE_SPI_FLAGS(cmd_burst));
+    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 EVE_ERR;
+    }
+    return EVE_OK;
+}
+
+void eve_cmd_burst_start(void) {
+    uint32_t addr = EVE_RAM_CMD + cmd_offset;
+    eve_spi_lock();
+    eve_spi_cs_set();
+    eve_spi_xchg24(addr | EVE_MEM_WRITE, EVE_SPI_FLAG_TX);
+    cmd_burst = 1;
+}
+
+void eve_cmd_burst_end(void) {
+    eve_spi_flush();
+    eve_spi_cs_clear();
+    eve_spi_unlock();
+    cmd_burst = 0;
+}
+
+int eve_gpio_get(int gpio) {
+    uint16_t reg = eve_read16(REG_GPIOX);
+    return !!(reg & (1 << gpio));
+}
+
+void eve_gpio_set(int gpio, int val) {
+    uint16_t reg = eve_read16(REG_GPIOX);
+    uint16_t reg_val = (1 << gpio);
+    if (val) {
+        reg |= reg_val;
+    } else {
+        reg &= ~reg_val;
+    }
+    eve_write16(REG_GPIOX, reg);
+}
+
+uint8_t eve_gpio_get_dir(void) {
+    uint16_t reg = eve_read16(REG_GPIOX_DIR);
+    return reg & 0x000f;
+}
+
+void eve_gpio_set_dir(uint8_t dir) {
+    uint16_t reg = eve_read16(REG_GPIOX_DIR);
+    reg &= 0xfff0;
+    reg |= dir & 0x0f;
+    eve_write16(REG_GPIOX_DIR, reg);
+}
+
+void eve_active(void) {
+    eve_command(EVE_ACTIVE, 0);
+    if (power_state == EVE_PSTATE_SLEEP) eve_time_sleep(40);
+
+    eve_write8(REG_PWM_DUTY, brigtness);
+    if (power_state != EVE_PSTATE_SLEEP) return;
+
+    eve_write8(REG_TOUCH_MODE, EVE_TMODE_CONTINUOUS);
+    eve_write8(REG_CTOUCH_EXTENDED, 0x00);
+
+    power_state = EVE_PSTATE_ACTIVE;
+}
+
+void eve_standby(void) {
+    if (power_state != EVE_PSTATE_ACTIVE) return;
+
+    brigtness = eve_read8(REG_PWM_DUTY);
+    eve_command(EVE_STANDBY, 0);
+
+    power_state = EVE_PSTATE_STANDBY;
+}
+
+void eve_sleep(void) {
+    if (power_state != EVE_PSTATE_ACTIVE) return;
+
+    brigtness = eve_read8(REG_PWM_DUTY);
+    eve_write8(REG_PWM_DUTY, 0x0);
+
+    eve_write8(REG_CTOUCH_EXTENDED, 0x01);
+    eve_write8(REG_TOUCH_MODE, EVE_TMODE_OFF);
+
+    eve_time_sleep(500);
+    eve_command(EVE_SLEEP, 0);
+
+    power_state = EVE_PSTATE_SLEEP;
+}
+
+void eve_brightness(uint8_t b) {
+    eve_write8(REG_PWM_DUTY, b);
+}
+
+static int _init(int touch_calibrate, uint32_t *touch_matrix, uint8_t gpio_dir) {
+    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 */
+        eve_time_sleep(1);
+        chipid = eve_read8(REG_ID);
+        timeout++;
+        if (timeout > 400) return EVE_ERR;
+    }
+
+    eve_write8(REG_PWM_DUTY, 0);
+    eve_write16(REG_GPIOX_DIR, 0x8000 | (gpio_dir & 0x0f));
+    eve_write16(REG_GPIOX, 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 */
+
+    /* disable Audio */
+    eve_write16(REG_SOUND, 0x0000);         /* set synthesizer to silence */
+    eve_write8(REG_VOL_SOUND, 0x00);        /* turn synthesizer volume off */
+    eve_write8(REG_VOL_PB, 0x00);           /* turn recorded audio volume off */
+
+    /* write a basic display-list to get things started */
+    eve_dl_start(EVE_RAM_DL, 0);
+    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_write16(REG_GPIOX, 0x8000);         /* enable the DISP signal to the LCD panel, it is set to output in REG_GPIOX_DIR by default */
+    eve_write8(REG_PCLK, EVE_PCLK);         /* now start clocking data to the LCD panel */
+
+    /* configure Touch */
+    eve_write16(REG_TOUCH_CONFIG, 0xb81);                   /* enable touch low power mode: 0xb81 - default: 0x381 */
+    eve_write8(REG_TOUCH_MODE, EVE_TMODE_CONTINUOUS);       /* enable touch */
+    eve_write16(REG_TOUCH_RZTHRESH, EVE_TOUCH_RZTHRESH);    /* eliminate any false touches */
+
+    if (touch_calibrate) {
+        eve_write8(REG_PWM_DUTY, 0x40);
+        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);
+        eve_write8(REG_PWM_DUTY, 0);
+
+        touch_matrix[0] = eve_read32(REG_TOUCH_TRANSFORM_A);
+        touch_matrix[1] = eve_read32(REG_TOUCH_TRANSFORM_B);
+        touch_matrix[2] = eve_read32(REG_TOUCH_TRANSFORM_C);
+        touch_matrix[3] = eve_read32(REG_TOUCH_TRANSFORM_D);
+        touch_matrix[4] = eve_read32(REG_TOUCH_TRANSFORM_E);
+        touch_matrix[5] = eve_read32(REG_TOUCH_TRANSFORM_F);
+    } else {
+        eve_write32(REG_TOUCH_TRANSFORM_A, touch_matrix[0]);
+        eve_write32(REG_TOUCH_TRANSFORM_B, touch_matrix[1]);
+        eve_write32(REG_TOUCH_TRANSFORM_C, touch_matrix[2]);
+        eve_write32(REG_TOUCH_TRANSFORM_D, touch_matrix[3]);
+        eve_write32(REG_TOUCH_TRANSFORM_E, touch_matrix[4]);
+        eve_write32(REG_TOUCH_TRANSFORM_F, touch_matrix[5]);
+    }
+
+    eve_write8(REG_CTOUCH_EXTENDED, 0x00);
+
+    eve_cmd(CMD_SETROTATE, "w", 2);
+    eve_cmd_exec(1);
+
+    return EVE_OK;
+}
+
+int eve_init(int pwr_on, int touch_calibrate, uint32_t *touch_matrix, uint8_t gpio_dir) {
+    eve_spi_start();
+
+    pwr_on = 1; // override this for now
+
+    if (pwr_on) {
+        int rv = _init(touch_calibrate, touch_matrix, gpio_dir);
+        if (rv) return rv;
+    } else {
+        power_state = EVE_PSTATE_SLEEP;
+        eve_active();
+    }
+
+    eve_touch_init();
+    eve_platform_init();
+
+    eve_spi_stop();
+
+    return EVE_OK;
+}
diff --git a/fw/fe310/eos/eve/eve.h b/fw/fe310/eos/eve/eve.h
new file mode 100644
index 0000000..2f26edf
--- /dev/null
+++ b/fw/fe310/eos/eve/eve.h
@@ -0,0 +1,70 @@
+#include <stdint.h>
+
+#include "eve_def.h"
+#include "eve_touch.h"
+#include "eve_phy.h"
+#include "eve_vtrack.h"
+#include "eve_platform.h"
+
+#define EVE_OK              0
+#define EVE_ERR             -1
+
+#define EVE_ERR_FULL        -10
+#define EVE_ERR_EMPTY       -11
+
+#define EVE_ERR_NOMEM       -100
+
+#define EVE_PSTATE_ACTIVE   0
+#define EVE_PSTATE_STANDBY  1
+#define EVE_PSTATE_SLEEP    3
+
+#define COLOR_RGBC(c)       ((4UL<<24)|((c)&16777215UL))
+#define CLEAR_COLOR_RGBC(c) ((2UL<<24)|((c)&16777215UL))
+
+typedef struct EVERect {
+    int16_t x;
+    int16_t y;
+    uint16_t w;
+    uint16_t h;
+} EVERect;
+
+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_readb(uint32_t addr, uint8_t *buf, size_t size);
+void eve_writeb(uint32_t addr, uint8_t *buf, size_t size);
+
+void eve_dl_start(uint32_t addr, char burst);
+void eve_dl_write(uint32_t dl);
+void eve_dl_end(void);
+void eve_dl_swap(void);
+uint32_t eve_dl_get_addr(void);
+
+void eve_cmd(uint32_t cmd, const char *fmt, ...);
+void eve_cmd_write(uint8_t *buffer, size_t size);
+void eve_cmd_end(void);
+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_gpio_get(int gpio);
+void eve_gpio_set(int gpio, int val);
+uint8_t eve_gpio_get_dir(void);
+void eve_gpio_set_dir(uint8_t dir);
+
+void eve_active(void);
+void eve_standby(void);
+void eve_sleep(void);
+void eve_wake(void);
+void eve_brightness(uint8_t b);
+
+int eve_init(int pwr_on, int touch_calibrate, uint32_t *touch_matrix, uint8_t gpio_dir);
diff --git a/fw/fe310/eos/eve/eve_config.h b/fw/fe310/eos/eve/eve_config.h
new file mode 100755
index 0000000..882ea89
--- /dev/null
+++ b/fw/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            (1L)                            /* 60MHz / REG_PCLK = PCLK frequency - 30 MHz */
+#define EVE_CSPREAD         (0L)                            /* 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/fw/fe310/eos/eve/eve_def.h b/fw/fe310/eos/eve/eve_def.h
new file mode 100755
index 0000000..25e4927
--- /dev/null
+++ b/fw/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/fw/fe310/eos/eve/eve_font.c b/fw/fe310/eos/eve/eve_font.c
new file mode 100644
index 0000000..e1e3aee
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_font.c
@@ -0,0 +1,59 @@
+#include <stdlib.h>
+
+#include "eve.h"
+#include "eve_font.h"
+
+void eve_font_init(EVEFont *font, uint8_t font_id) {
+    uint32_t p;
+
+    p = eve_read32(EVE_ROM_FONT_ADDR);
+    p += (148 * (font_id - 16));
+    font->id = font_id;
+    font->w = eve_read32(p + 136);
+    font->h = eve_read32(p + 140);
+    eve_readb(p, font->w_ch, 128);
+}
+
+uint8_t eve_font_ch_w(EVEFont *font, utf32_t ch) {
+    if (ch < 128) return font->w_ch[ch];
+    return 0;
+}
+
+uint16_t eve_font_str_w(EVEFont *font, utf8_t *str) {
+    uint16_t r = 0;
+    utf32_t ch;
+    uint8_t ch_w;
+    uint8_t ch_l;
+
+    if (str == NULL) return 0;
+
+    while (*str) {
+        ch_l = utf8_dec(str, &ch);
+        ch_w = eve_font_ch_w(font, ch);
+        r += ch_w;
+        str += ch_l;
+    }
+
+    return r;
+}
+
+uint16_t eve_font_buf_w(EVEFont *font, utf8_t *buf, uint16_t buf_len) {
+    int i = 0;
+    uint16_t r = 0;
+    utf32_t ch;
+    uint8_t ch_w;
+    uint8_t ch_l;
+
+    while (i < buf_len) {
+        ch_l = utf8_dec(buf + i, &ch);
+        ch_w = eve_font_ch_w(font, ch);
+        r += ch_w;
+        i += ch_l;
+    }
+
+    return r;
+}
+
+uint8_t eve_font_h(EVEFont *font) {
+    return font->h;
+}
diff --git a/fw/fe310/eos/eve/eve_font.h b/fw/fe310/eos/eve/eve_font.h
new file mode 100644
index 0000000..87ef41f
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_font.h
@@ -0,0 +1,16 @@
+#include <stdint.h>
+
+#include "unicode.h"
+
+typedef struct EVEFont {
+    uint8_t id;
+    uint8_t w;
+    uint8_t h;
+    uint8_t w_ch[128];
+} EVEFont;
+
+void eve_font_init(EVEFont *font, uint8_t font_id);
+uint8_t eve_font_ch_w(EVEFont *font, utf32_t ch);
+uint16_t eve_font_str_w(EVEFont *font, utf8_t *str);
+uint16_t eve_font_buf_w(EVEFont *font, utf8_t *buf, uint16_t buf_len);
+uint8_t eve_font_h(EVEFont *font);
diff --git a/fw/fe310/eos/eve/eve_kbd.c b/fw/fe310/eos/eve/eve_kbd.c
new file mode 100644
index 0000000..c8c1362
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_kbd.c
@@ -0,0 +1,162 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+
+#define KEY_SPACERX     3
+#define KEY_SPACERY     5
+#define KEY_FONT        29
+#define MOD_FONT        21
+
+#define KEY_BS          0x08
+#define KEY_RET         0x0a
+
+#define FLAG_SHIFT      0x01
+#define FLAG_CTRL       0x02
+#define FLAG_FN         0x04
+
+#define TAG_SHIFT       0x11
+#define TAG_CTRL        0x12
+#define TAG_FN          0x13
+
+void eve_kbd_init(EVEKbd *kbd, EVERect *g, uint32_t mem_addr, uint32_t *mem_next) {
+    uint16_t mem_size;
+
+    kbd->g = *g;
+    kbd->mem_addr = mem_addr;
+    kbd->key_modifier = 0;
+    kbd->key_modifier_sticky = 0;
+    kbd->key_modifier_lock = 0;
+    kbd->key_count = 0;
+    kbd->key_down = 0;
+    kbd->putc = NULL;
+    kbd->param = NULL;
+
+    kbd->key_down = 0xff;
+    eve_write16(REG_CMD_DL, 0);
+    eve_kbd_draw(kbd);
+    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->key_down = 0;
+    kbd->mem_size = mem_size;
+
+    *mem_next = kbd->mem_addr + kbd->mem_size;
+}
+
+void eve_kbd_close(EVEKbd *kbd) {
+    kbd->key_modifier = 0;
+    kbd->key_modifier_sticky = 0;
+    kbd->key_modifier_lock = 0;
+    kbd->key_count = 0;
+    kbd->key_down = 0;
+    kbd->putc = NULL;
+    kbd->param = NULL;
+}
+
+void eve_kbd_set_handler(EVEKbd *kbd, eve_kbd_input_handler_t putc, void *param) {
+    kbd->putc = putc;
+    kbd->param = param;
+}
+
+int eve_kbd_touch(EVEKbd *kbd, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    int ret;
+
+    evt = eve_touch_evt(touch, evt, tag0, 1, 126);
+    if (touch && evt) {
+        int8_t touch_idx = eve_touch_get_idx(touch);
+
+        if (evt & EVE_TOUCH_ETYPE_TAG) {
+            uint8_t _tag = touch->tag;
+
+            if (_tag >= TAG_SHIFT && _tag <= TAG_FN) {
+                if (touch_idx == 0) {
+                    uint8_t f = (1 << (_tag - TAG_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(kbd->param, c);
+                }
+            }
+        }
+        if (evt & EVE_TOUCH_ETYPE_TAG_UP) {
+            uint8_t _tag = touch->tag_up;
+
+            if (_tag >= TAG_SHIFT && _tag <= TAG_FN) {
+                if (touch_idx == 0) {
+                    uint8_t f = (1 << (_tag - TAG_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;
+                }
+            }
+        }
+        ret = 1;
+    } else {
+        ret = 0;
+    }
+
+    return ret;
+}
+
+uint8_t eve_kbd_draw(EVEKbd *kbd) {
+    if (kbd->key_down || kbd->key_modifier) {
+        int x = kbd->g.x;
+        int y = kbd->g.y;
+        int w = kbd->g.w;
+        int row_h = kbd->g.h / 5;
+        int key_w = (w - 9 * KEY_SPACERX) / 10 + 1;
+        int mod_w = key_w + key_w / 2;
+        int key_h = row_h - KEY_SPACERY;
+
+        eve_cmd_dl(SAVE_CONTEXT());
+        eve_cmd(CMD_KEYS, "hhhhhhs", x, y + row_h * 0, w, key_h, KEY_FONT, kbd->key_down, kbd->key_modifier & (FLAG_FN | FLAG_SHIFT) ? "!@#$%^&*()" : (kbd->key_modifier & FLAG_CTRL ? " @[\\]^_?  " : "1234567890"));
+        eve_cmd(CMD_KEYS, "hhhhhhs", x, y + row_h * 1, w, key_h, KEY_FONT, kbd->key_down, kbd->key_modifier & FLAG_FN ? "-_=+[]{}\\|" : kbd->key_modifier & (FLAG_SHIFT | FLAG_CTRL) ? "QWERTYUIOP" : "qwertyuiop");
+        eve_cmd(CMD_KEYS, "hhhhhhs", x + key_w / 2, y + row_h * 2, w - key_w, key_h, KEY_FONT, kbd->key_down, kbd->key_modifier & FLAG_FN ? "`~   ;:'\"" : kbd->key_modifier & (FLAG_SHIFT | FLAG_CTRL) ? "ASDFGHJKL" : "asdfghjkl");
+        eve_cmd(CMD_KEYS, "hhhhhhs", x + mod_w + KEY_SPACERX, y + row_h * 3, w - 2 * (mod_w + KEY_SPACERX), key_h, KEY_FONT, kbd->key_down, kbd->key_modifier & FLAG_FN ? " ,.<>/?" : kbd->key_modifier & (FLAG_SHIFT | FLAG_CTRL) ? "ZXCVBNM" : "zxcvbnm");
+        eve_cmd_dl(TAG(TAG_SHIFT));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", x, y + row_h * 3, mod_w, key_h, MOD_FONT, kbd->key_modifier & FLAG_SHIFT ? EVE_OPT_FLAT : 0, "shift");
+        eve_cmd_dl(TAG(KEY_BS));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", x + w - mod_w, y + row_h * 3, mod_w, key_h, MOD_FONT, kbd->key_down == KEY_BS ? EVE_OPT_FLAT : 0, "del");
+        eve_cmd_dl(TAG(TAG_FN));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", x, y + row_h * 4, mod_w, key_h, MOD_FONT, kbd->key_modifier & FLAG_FN ? EVE_OPT_FLAT : 0, "fn");
+        eve_cmd_dl(TAG(TAG_CTRL));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", x + mod_w + KEY_SPACERX, y + row_h * 4, mod_w, key_h, MOD_FONT, kbd->key_modifier & FLAG_CTRL ? EVE_OPT_FLAT : 0, "ctrl");
+        eve_cmd_dl(TAG(' '));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", x + 2 * (mod_w + KEY_SPACERX), y + row_h * 4, w - 3 * (mod_w + KEY_SPACERX), key_h, MOD_FONT, kbd->key_down == ' ' ? EVE_OPT_FLAT : 0, "");
+        eve_cmd_dl(TAG(KEY_RET));
+        eve_cmd(CMD_BUTTON, "hhhhhhs", x + w - mod_w, y + row_h * 4, mod_w, key_h, MOD_FONT, 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 0x80;
+}
diff --git a/fw/fe310/eos/eve/eve_kbd.h b/fw/fe310/eos/eve/eve_kbd.h
new file mode 100644
index 0000000..b4f9874
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_kbd.h
@@ -0,0 +1,23 @@
+#include <stdint.h>
+
+typedef void (*eve_kbd_input_handler_t) (void *, int);
+
+typedef struct EVEKbd {
+    EVERect g;
+    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;
+    char active;
+    eve_kbd_input_handler_t putc;
+    void *param;
+} EVEKbd;
+
+void eve_kbd_init(EVEKbd *kbd, EVERect *g, uint32_t mem_addr, uint32_t *mem_next);
+void eve_kbd_close(EVEKbd *kbd);
+void eve_kbd_set_handler(EVEKbd *kbd, eve_kbd_input_handler_t putc, void *param);
+int eve_kbd_touch(EVEKbd *kbd, EVETouch *touch, uint16_t evt, uint8_t tag0);
+uint8_t eve_kbd_draw(EVEKbd *kbd);
diff --git a/fw/fe310/eos/eve/eve_phy.c b/fw/fe310/eos/eve/eve_phy.c
new file mode 100644
index 0000000..1e255fe
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_phy.c
@@ -0,0 +1,77 @@
+#include <stdlib.h>
+#include <math.h>
+
+#include "eve_platform.h"
+#include "eve_phy.h"
+
+/* Constant accelerator */
+void eve_phy_acc_init(EVEPhyAcc *param, int a) {
+    param->a = a;
+}
+
+void eve_phy_acc_start(EVEPhyAcc *param, int x0, int y0, int v0x, int v0y) {
+    double v0 = sqrt(v0x * v0x + v0y * v0y);
+
+    param->x0 = x0;
+    param->y0 = y0;
+    param->v0x = v0x;
+    param->v0y = v0y;
+    param->k = 2 * v0 / param->a * EVE_RTC_FREQ;
+}
+
+int eve_phy_acc_tick(EVEPhyAcc *param, int dt, int *x, int *y) {
+    int k = param->k;
+    int x0 = param->x0;
+    int y0 = param->y0;
+    int v0x = param->v0x;
+    int v0y = param->v0y;
+    int more = 1;
+
+    if ((k < 0) && (dt >= -k / 2)) {
+        dt = -k / 2;
+        more = 0;
+    }
+    if (x) *x = x0 + (v0x * dt + v0x * dt / k * dt) / (int)(EVE_RTC_FREQ);
+    if (y) *y = y0 + (v0y * dt + v0y * dt / k * dt) / (int)(EVE_RTC_FREQ);
+
+    return more;
+}
+
+/* Linear harmonic oscillator */
+void eve_phy_lho_init(EVEPhyLHO *param, int x, int y, uint32_t T, double d, uint32_t t_max) {
+    double f0 = 2 * M_PI / (T * EVE_RTC_FREQ / 1000);
+
+    if (d < 0) d = 0;
+    if (d > 1) d = 1;
+    param->x = x;
+    param->y = y;
+    param->f = f0 * sqrt(1 - d * d);
+    param->a = -d * f0;
+    param->t_max = t_max * EVE_RTC_FREQ / 1000;
+}
+
+int eve_phy_lho_start(EVEPhyLHO *param, int x0, int y0) {
+    param->x0 = x0;
+    param->y0 = y0;
+}
+
+int eve_phy_lho_tick(EVEPhyLHO *param, int dt, int *x, int *y) {
+    int ax = param->x0 - param->x;
+    int ay = param->y0 - param->y;
+    int more = 1;
+
+    if (param->t_max && (dt >= param->t_max)) {
+        dt = param->t_max;
+        more = 0;
+    }
+    if (param->a) {
+        double e = exp(param->a * dt);
+        ax = ax * e;
+        ay = ay * e;
+        if ((ax == 0) && (ay == 0)) more = 0;
+    }
+    if (x) *x = param->x + ax * cos(param->f * dt);
+    if (y) *y = param->y + ay * cos(param->f * dt);
+
+    return more;
+}
diff --git a/fw/fe310/eos/eve/eve_phy.h b/fw/fe310/eos/eve/eve_phy.h
new file mode 100644
index 0000000..1be5fd0
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_phy.h
@@ -0,0 +1,28 @@
+#include <stdint.h>
+
+typedef struct EVEPhyAcc {
+    int a;
+    int k;
+    int x0;
+    int y0;
+    int v0x;
+    int v0y;
+} EVEPhyAcc;
+
+void eve_phy_acc_init(EVEPhyAcc *param, int a);
+void eve_phy_acc_start(EVEPhyAcc *param, int x0, int y0, int v0x, int v0y);
+int eve_phy_acc_tick(EVEPhyAcc *param, int dt, int *x, int *y);
+
+typedef struct EVEPhyLHO {
+    int x;
+    int y;
+    double f;
+    double a;
+    uint32_t t_max;
+    int x0;
+    int y0;
+} EVEPhyLHO;
+
+void eve_phy_lho_init(EVEPhyLHO *param, int x, int y, uint32_t T, double d, uint32_t t_max);
+int eve_phy_lho_start(EVEPhyLHO *param, int x0, int y0);
+int eve_phy_lho_tick(EVEPhyLHO *param, int dt, int *x, int *y);
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/eve_platform.c b/fw/fe310/eos/eve/eve_platform.c
new file mode 100644
index 0000000..6bc87bb
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_platform.c
@@ -0,0 +1,80 @@
+#include <stdlib.h>
+
+#include "platform.h"
+
+#include "eos.h"
+#include "interrupt.h"
+#include "event.h"
+
+#include "eve.h"
+#include "eve_platform.h"
+
+
+static void handle_time(unsigned char type) {
+    eve_handle_time();
+}
+
+static void handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    eve_handle_touch();
+
+    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;
+}
+
+void eve_time_sleep(uint32_t ms) {
+    eos_time_sleep(ms);
+}
+
+void eve_timer_set(uint32_t ms) {
+    eos_timer_set(ms, EOS_TIMER_ETYPE_UI);
+}
+
+void eve_timer_clear(void) {
+    eos_timer_clear(EOS_TIMER_ETYPE_UI);
+}
+
+uint64_t eve_time_get_tick(void) {
+    return eos_time_get_tick();
+}
+
+void eve_platform_init(void) {
+    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);
+
+    eos_spi_set_div(EOS_SPI_DEV_EVE, 4);
+}
+
+void eve_spi_start(void) {
+    eos_spi_select(EOS_SPI_DEV_EVE);
+}
+
+void eve_spi_stop(void) {
+    eos_spi_deselect();
+}
+
+#include <stdio.h>
+
+void *eve_malloc(size_t size) {
+    void *p = malloc(size);
+    printf("MALLOC:%p %d\n", p, size);
+    return p;
+}
+
+void eve_free(void *p) {
+    printf("FREE:%p\n", p);
+    free(p);
+}
diff --git a/fw/fe310/eos/eve/eve_platform.h b/fw/fe310/eos/eve/eve_platform.h
new file mode 100644
index 0000000..7975fbc
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_platform.h
@@ -0,0 +1,39 @@
+#include <stdint.h>
+
+#include "spi.h"
+#include "spi_dev.h"
+#include "timer.h"
+
+#define EVE_ETYPE_INTR      1
+#define EVE_PIN_INTR        0
+
+#define EVE_RTC_FREQ        EOS_TIMER_RTC_FREQ
+
+#define EVE_SPI_FLAG_BSWAP  EOS_SPI_FLAG_BSWAP
+#define EVE_SPI_FLAG_TX     EOS_SPI_FLAG_TX
+
+void *eve_malloc(size_t);
+void eve_free(void *);
+
+//#define eve_malloc          malloc
+//#define eve_free            free
+
+void eve_spi_start(void);
+void eve_spi_stop(void);
+
+#define eve_spi_cs_set      eos_spi_cs_set
+#define eve_spi_cs_clear    eos_spi_cs_clear
+#define eve_spi_flush       eos_spi_flush
+#define eve_spi_xchg8       eos_spi_xchg8
+#define eve_spi_xchg16      eos_spi_xchg16
+#define eve_spi_xchg24      eos_spi_xchg24
+#define eve_spi_xchg32      eos_spi_xchg32
+#define eve_spi_lock        eos_spi_lock
+#define eve_spi_unlock      eos_spi_unlock
+
+void eve_time_sleep(uint32_t ms);
+void eve_timer_set(uint32_t ms);
+void eve_timer_clear(void);
+uint64_t eve_time_get_tick(void);
+
+void eve_platform_init(void);
diff --git a/fw/fe310/eos/eve/eve_text.c b/fw/fe310/eos/eve/eve_text.c
new file mode 100644
index 0000000..b52678d
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_text.c
@@ -0,0 +1,209 @@
+#include <stdlib.h>
+#include <string.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);
+    eve_text_update(box);
+    box->dirty = 1;
+}
+
+void eve_text_init(EVEText *box, EVERect *g, uint16_t w, uint16_t h, uint16_t line_size, uint32_t mem_addr, uint32_t *mem_next) {
+    double scale_x, scale_y;
+
+    if (g->w == 0) {
+        g->w = w * 8;
+    }
+    if (g->h == 0) {
+        g->h = h * 16;
+    }
+
+    scale_x = (double)g->w / (w * 8);
+    scale_y = (double)g->h / (h * 16);
+    box->g = *g;
+    box->w = w;
+    box->h = h;
+    box->tag = EVE_NOTAG;
+    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 = 14;
+    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_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;
+}
+
+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, 1);
+    eve_dl_write(BEGIN(EVE_BITMAPS));
+    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->g.x, box->g.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->g.x, box->g.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_end();
+}
+
+void eve_text_scroll0(EVEText *box) {
+    if (box->line_top >= 0) {
+        box->line_top = -1;
+        box->line_top0 = -1;
+        eve_text_update(box);
+    }
+}
+
+int eve_text_touch(EVEText *box, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    evt = eve_touch_evt(touch, evt, tag0, box->tag, 1);
+    if (touch && 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, (touch->y0 - touch->y) / box->ch_h, box->line_size);
+            if (LINE_IDX_LTE(line, box->line0, box->line_size, box->h)) {
+                box->line_top = line;
+                eve_text_update(box);
+            }
+        }
+        if (evt & EVE_TOUCH_ETYPE_TRACK_STOP) {
+            box->line_top0 = box->line_top;
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+uint8_t eve_text_draw(EVEText *box, uint8_t tag) {
+    eve_cmd_dl(SAVE_CONTEXT());
+    box->tag = tag;
+    if (tag != EVE_NOTAG) {
+        eve_cmd_dl(TAG(tag));
+        eve_touch_set_opt(tag, EVE_TOUCH_OPT_TRACK | EVE_TOUCH_OPT_TRACK_EXT_Y);
+        tag++;
+    }
+    eve_cmd(CMD_APPEND, "ww", box->mem_addr + box->w * 2 * box->line_size, box->dl_size * 4);
+    eve_cmd_dl(RESTORE_CONTEXT());
+
+    return tag;
+}
+
+void 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;
+    }
+}
+
+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);
+}
+
+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_puts(EVEText *box, char *s) {
+    while (*s) {
+        eve_text_putc(box, *s);
+        s++;
+    }
+}
diff --git a/fw/fe310/eos/eve/eve_text.h b/fw/fe310/eos/eve/eve_text.h
new file mode 100644
index 0000000..3b282c9
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_text.h
@@ -0,0 +1,32 @@
+#include <stdint.h>
+
+typedef struct EVEText {
+    EVERect g;
+    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, EVERect *g, uint16_t w, uint16_t h, uint16_t line_size, uint32_t mem_addr, uint32_t *mem_next);
+void eve_text_update(EVEText *box);
+void eve_text_scroll0(EVEText *box);
+
+int eve_text_touch(EVEText *box, EVETouch *touch, uint16_t evt, uint8_t tag0);
+uint8_t eve_text_draw(EVEText *box, uint8_t tag);
+
+void eve_text_putc(EVEText *box, int c);
+void eve_text_backspace(EVEText *box);
+void eve_text_newline(EVEText *box);
+void eve_text_puts(EVEText *box, char *s);
diff --git a/fw/fe310/eos/eve/eve_touch.c b/fw/fe310/eos/eve/eve_touch.c
new file mode 100644
index 0000000..e75cf4e
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_touch.c
@@ -0,0 +1,419 @@
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "eve.h"
+
+static int touch_intr_mask = EVE_INT_TAG | EVE_INT_TOUCH;
+static int touch_multi;
+static uint8_t touch_tag0;
+
+static EVETouch touch_obj[EVE_MAX_TOUCH];
+static EVETouchTimer touch_timer;
+
+static eve_touch_handler_t touch_handler;
+static void *touch_handler_param;
+static uint8_t touch_tag_opt[256];
+
+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_handle_touch(void) {
+    int i;
+    char touch_ex = 0;
+    char int_ccomplete = 0;
+    uint8_t flags;
+
+    eve_spi_start();
+
+    flags = eve_read8(REG_INT_FLAGS) & touch_intr_mask;
+    if (!touch_multi && (flags & EVE_INT_TOUCH)) touch_multi = 1;
+    for (i=0; i<EVE_MAX_TOUCH; i++) {
+        uint8_t touch_tag;
+        uint32_t touch_xy;
+        uint64_t now = 0;
+        uint16_t touch_evt = 0;
+        EVETouch *touch = &touch_obj[i];
+
+        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 != EVE_NOTOUCH) {
+            int16_t touch_x = touch_xy >> 16;
+            int16_t touch_y = touch_xy & 0xffff;
+            now = eve_time_get_tick();
+            if (touch->eevt & EVE_TOUCH_EETYPE_NOTOUCH) {
+                uint16_t _evt = 0;
+                uint16_t _eevt = 0;
+                uint16_t _ttevt = eve_touch_timer_get_evt(touch);
+
+                if (_ttevt) {
+                    touch->eevt &= ~EVE_TOUCH_EETYPE_NOTOUCH;
+
+                    if (_ttevt & EVE_TOUCH_ETYPE_TAP2) {
+                        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_TOUCH_THRESHOLD_X) || (dy > EVE_TOUCH_THRESHOLD_Y)) {
+                            touch_evt |= EVE_TOUCH_ETYPE_TAP1;
+                        } else {
+                            _evt |= EVE_TOUCH_ETYPE_TAP2;
+                            _eevt |= EVE_TOUCH_EETYPE_TAP2;
+                        }
+                    }
+                    if (_ttevt & EVE_TOUCH_ETYPE_TRACK) {
+                        EVEVTrack *vtrack = eve_vtrack_get();
+
+                        _eevt |= EVE_TOUCH_EETYPE_TRACK_ABORT;
+                        touch_evt |= (EVE_TOUCH_ETYPE_TRACK_STOP | EVE_TOUCH_ETYPE_TRACK_ABORT);
+                        if (vtrack->stop) vtrack->stop(touch, vtrack->param);
+                    }
+                    if (_ttevt & EVE_TOUCH_ETYPE_TIMER) {
+                        _eevt |= EVE_TOUCH_EETYPE_TIMER_ABORT;
+                        touch_evt |= EVE_TOUCH_ETYPE_TIMER_ABORT;
+                    }
+
+                    eve_touch_timer_clear(touch);
+                    if (touch_handler && touch_evt) {
+                        touch_handler(touch_timer.touch, touch_evt, touch_timer.tag0, touch_handler_param);
+                    }
+                }
+                touch_evt = EVE_TOUCH_ETYPE_POINT | _evt;
+                touch->eevt = _eevt;
+                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)(EVE_RTC_FREQ) / dt;
+                int vy = ((int)touch_y - touch->y) * (int)(EVE_RTC_FREQ) / dt;
+                touch->vx = touch->vx ? (vx + touch->vx * EVE_TOUCH_TRAVG) / (EVE_TOUCH_TRAVG + 1) : vx;
+                touch->vy = touch->vy ? (vy + touch->vy * EVE_TOUCH_TRAVG) / (EVE_TOUCH_TRAVG + 1) : vy;
+                touch->t = now;
+            }
+            touch->x = touch_x;
+            touch->y = touch_y;
+            if (touch_multi || (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->eevt & EVE_TOUCH_EETYPE_NOTOUCH)) {
+                uint16_t _ttevt = eve_touch_timer_get_evt(touch);
+
+                touch_evt = EVE_TOUCH_ETYPE_POINT_UP;
+                touch->eevt |= EVE_TOUCH_EETYPE_NOTOUCH;
+                if (_ttevt & EVE_TOUCH_ETYPE_LPRESS) {
+                    eve_touch_timer_set_evt(touch, _ttevt & ~EVE_TOUCH_ETYPE_LPRESS);
+                }
+                if (touch->tracker.tag && touch->tracker.track) {
+                    uint8_t opt = touch_tag_opt[touch->tracker.tag];
+                    char track_ext = ((opt & EVE_TOUCH_OPT_TRACK_EXT_X) && (touch->eevt & EVE_TOUCH_EETYPE_TRACK_X)) ||
+                                     ((opt & EVE_TOUCH_OPT_TRACK_EXT_Y) && (touch->eevt & EVE_TOUCH_EETYPE_TRACK_Y));
+                    if (!eve_touch_timer_get_evt(NULL) && track_ext) {
+                        EVEVTrack *vtrack = eve_vtrack_get();
+
+                        eve_touch_timer_set(touch, EVE_TOUCH_ETYPE_TRACK, touch_tag0, EVE_TOUCH_TIMEOUT_TRACK);
+                        if (vtrack->start) vtrack->start(touch, vtrack->param);
+                    } else {
+                        touch_evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
+                    }
+                }
+            }
+        }
+        if (touch_tag != touch->tag) {
+            if (touch_tag) {
+                if (!touch_tag0) touch_tag0 = touch_tag;
+                if (!touch->tag0) {
+                    touch->tag0 = touch_tag;
+                    if (touch_tag_opt[touch_tag] & (EVE_TOUCH_OPT_TRACK | EVE_TOUCH_OPT_TRACK_REG)) {
+                        touch->tracker.tag = touch_tag;
+                    }
+                    if (touch->tracker.tag && !(touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_XY)) {
+                        touch_evt |= EVE_TOUCH_ETYPE_TRACK_START;
+                        touch->tracker.track = 1;
+                        touch->t = now;
+                    }
+                    if (!eve_touch_timer_get_evt(NULL) && (touch_tag_opt[touch_tag] & (EVE_TOUCH_OPT_LPRESS | EVE_TOUCH_OPT_TAP2))) {
+                        uint16_t _evt = 0;
+
+                        if (touch_tag_opt[touch_tag] & EVE_TOUCH_OPT_LPRESS) _evt |= EVE_TOUCH_ETYPE_LPRESS;
+                        if (touch_tag_opt[touch_tag] & EVE_TOUCH_OPT_TAP2) _evt |= EVE_TOUCH_ETYPE_TAP2;
+                        eve_touch_timer_set(touch, _evt, touch_tag0, EVE_TOUCH_TIMEOUT_TAP);
+                    }
+                }
+            }
+            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 != EVE_NOTOUCH) {
+            uint16_t _ttevt = eve_touch_timer_get_evt(touch);
+            int _track = touch->tracker.tag && !touch->tracker.track;
+            int _timer = _ttevt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP2);
+            if (_track || _timer) {
+                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_TOUCH_THRESHOLD_X) && !(touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_X)) {
+                        touch->tracker.tag = 0;
+                    }
+                    if ((dy > EVE_TOUCH_THRESHOLD_Y) && !(touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_Y)) {
+                        touch->tracker.tag = 0;
+                    }
+                    if (touch->tracker.tag && ((dx > EVE_TOUCH_THRESHOLD_X) || (dy > EVE_TOUCH_THRESHOLD_Y))) {
+                        if (dx > EVE_TOUCH_THRESHOLD_X) {
+                            touch->eevt |= touch->x > touch->x0 ? EVE_TOUCH_EETYPE_TRACK_RIGHT : EVE_TOUCH_EETYPE_TRACK_LEFT;
+                        }
+                        if (dy > EVE_TOUCH_THRESHOLD_Y) {
+                            touch->eevt |= touch->y > touch->y0 ? EVE_TOUCH_EETYPE_TRACK_DOWN : EVE_TOUCH_EETYPE_TRACK_UP;
+                        }
+                        touch_evt |= EVE_TOUCH_ETYPE_TRACK_START;
+                        touch->tracker.track = 1;
+                        touch->t = now;
+                    }
+                }
+                if (_timer && ((dx > EVE_TOUCH_THRESHOLD_X) || (dy > EVE_TOUCH_THRESHOLD_Y))) {
+                    eve_touch_timer_set_evt(touch, _ttevt & ~(EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP2));
+                    _timer = 0;
+                }
+            }
+            if (touch->tracker.tag && touch->tracker.track) {
+                if (touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK) touch_evt |= EVE_TOUCH_ETYPE_TRACK;
+                if (touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_REG) touch_evt |= EVE_TOUCH_ETYPE_TRACK_REG;
+            }
+            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 || _timer) int_ccomplete = 1;
+        }
+        if (touch_handler && touch_evt) {
+            touch_handler(touch, touch_evt, touch_tag0, touch_handler_param);
+        }
+        if (!touch_multi) break;
+    }
+
+    if (!touch_ex) {
+        touch_tag0 = 0;
+        touch_multi = 0;
+    }
+
+    if (touch_multi) int_ccomplete = 1;
+
+    if (int_ccomplete && !(touch_intr_mask & EVE_INT_CONVCOMPLETE)) {
+        touch_intr_mask |= EVE_INT_CONVCOMPLETE;
+        eve_write8(REG_INT_MASK, touch_intr_mask);
+    }
+    if (!int_ccomplete && (touch_intr_mask & EVE_INT_CONVCOMPLETE)) {
+        touch_intr_mask &= ~EVE_INT_CONVCOMPLETE;
+        eve_write8(REG_INT_MASK, touch_intr_mask);
+    }
+
+    eve_spi_stop();
+}
+
+void eve_handle_time(void) {
+    EVETouch *touch = touch_timer.touch;
+
+    if (touch_timer.evt) {
+        int more = 0;
+        uint16_t touch_evt = 0;
+
+        eve_spi_start();
+
+        if (touch_timer.evt & EVE_TOUCH_ETYPE_LPRESS) {
+            touch_evt |= EVE_TOUCH_ETYPE_LPRESS;
+            if (touch) touch->eevt |= EVE_TOUCH_EETYPE_LPRESS;
+        }
+        if (touch_timer.evt & EVE_TOUCH_ETYPE_TAP2) {
+            touch_evt |= EVE_TOUCH_ETYPE_TAP1;
+        }
+        if (touch_timer.evt & EVE_TOUCH_ETYPE_TRACK) {
+            EVEVTrack *vtrack = eve_vtrack_get();
+
+            if (vtrack->tick) {
+                touch_evt |= EVE_TOUCH_ETYPE_TRACK;
+                more = vtrack->tick(touch, vtrack->param);
+            }
+            if (!more) {
+                touch_evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
+                if (vtrack->stop) vtrack->stop(touch, vtrack->param);
+            }
+        }
+        if (touch_timer.evt & EVE_TOUCH_ETYPE_TIMER) {
+            touch_evt |= EVE_TOUCH_ETYPE_TIMER;
+            more = 1;
+        }
+
+        if (more) {
+            eve_timer_set(touch_timer.to);
+        } else {
+            touch_timer.evt = 0;
+        }
+
+        if (touch_handler && touch_evt) {
+            touch_handler(touch, touch_evt, touch_timer.tag0, touch_handler_param);
+        }
+
+        eve_spi_stop();
+    }
+}
+
+void eve_touch_init(void) {
+    int i;
+
+    eve_vtrack_init();
+
+    for (i=0; i<EVE_MAX_TOUCH; i++) {
+        EVETouch *touch = &touch_obj[i];
+        touch->eevt |= EVE_TOUCH_EETYPE_NOTOUCH;
+    }
+
+    eve_write8(REG_INT_MASK, touch_intr_mask);
+    eve_write8(REG_INT_EN, 0x01);
+    while(eve_read8(REG_INT_FLAGS));
+}
+
+void eve_touch_set_handler(eve_touch_handler_t handler, void *param) {
+    touch_handler = handler;
+    touch_handler_param = param;
+}
+
+EVETouch *eve_touch_get(int i) {
+    return &touch_obj[i];
+}
+
+int8_t eve_touch_get_idx(EVETouch *touch) {
+    if (touch == NULL) return -1;
+    return touch - touch_obj;
+}
+
+uint16_t eve_touch_evt(EVETouch *touch, uint16_t evt, uint8_t tag0, uint8_t tag_min, uint8_t tag_n) {
+    int tag_max;
+    uint8_t _tag;
+    uint16_t _evt;
+
+    if (tag_min == EVE_NOTAG) return 0;
+
+    tag_max = tag_min + tag_n;
+    if ((tag0 < tag_min) || (tag0 >= tag_max)) return 0;
+
+    _evt = evt & (EVE_TOUCH_ETYPE_TIMER_MASK | EVE_TOUCH_ETYPE_USR_MASK);
+    if (touch == NULL) return _evt;
+
+    _evt |= evt & EVE_TOUCH_ETYPE_POINT_MASK;
+    if (evt & EVE_TOUCH_ETYPE_TAG) {
+        _tag = touch->tag;
+        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= EVE_TOUCH_ETYPE_TAG;
+    }
+    if (evt & EVE_TOUCH_ETYPE_TAG_UP) {
+        _tag = touch->tag_up;
+        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= EVE_TOUCH_ETYPE_TAG_UP;
+    }
+    if (evt & EVE_TOUCH_ETYPE_TRACK_MASK) {
+        _tag = touch->tracker.tag;
+        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= evt & EVE_TOUCH_ETYPE_TRACK_MASK;
+    }
+    if (evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP1 | EVE_TOUCH_ETYPE_TAP2)) {
+        _tag = touch->tag0;
+        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP1 | EVE_TOUCH_ETYPE_TAP2);
+    }
+
+    return _evt;
+}
+
+void eve_touch_set_opt(uint8_t tag, uint8_t opt) {
+    touch_tag_opt[tag] = opt;
+}
+
+uint8_t eve_touch_get_opt(uint8_t tag) {
+    return touch_tag_opt[tag];
+}
+
+void eve_touch_clear_opt(void) {
+    memset(touch_tag_opt, 0, sizeof(touch_tag_opt));
+}
+
+void eve_touch_timer_set(EVETouch *touch, uint16_t evt, uint8_t tag0, uint32_t to) {
+    touch_timer.touch = touch;
+    touch_timer.evt = evt;
+    touch_timer.tag0 = tag0;
+    touch_timer.to = to;
+    eve_timer_set(to);
+}
+
+void eve_touch_timer_clear(EVETouch *touch) {
+    eve_touch_timer_set_evt(touch, 0);
+}
+
+uint16_t eve_touch_timer_get_evt(EVETouch *touch) {
+    uint16_t ret = 0;
+
+    if ((touch == NULL) || (touch_timer.touch == touch)) {
+        ret = touch_timer.evt;
+    } else if (touch_timer.touch == NULL) {
+        ret = touch_timer.evt & EVE_TOUCH_ETYPE_TIMER;
+    }
+    return ret;
+}
+
+void eve_touch_timer_set_evt(EVETouch *touch, uint16_t evt) {
+    if (touch == touch_timer.touch) {
+        touch_timer.evt = evt;
+    } else if (touch_timer.touch == NULL) {
+        touch_timer.evt = evt & EVE_TOUCH_ETYPE_TIMER;
+    }
+    if (!touch_timer.evt) eve_timer_clear();
+}
+
+void eve_touch_timer_start(uint8_t tag0, uint32_t to) {
+    eve_touch_timer_set(NULL, EVE_TOUCH_ETYPE_TIMER, tag0, to);
+}
+
+void eve_touch_timer_stop(void) {
+    eve_touch_timer_clear(NULL);
+}
+
+EVETouchTimer *eve_touch_timer_get(void) {
+    return &touch_timer;
+}
diff --git a/fw/fe310/eos/eve/eve_touch.h b/fw/fe310/eos/eve/eve_touch.h
new file mode 100644
index 0000000..1bb77ba
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_touch.h
@@ -0,0 +1,121 @@
+#include <stdint.h>
+
+#define EVE_TOUCH_TIMEOUT_TAP           1000
+#define EVE_TOUCH_TIMEOUT_TRACK         20
+
+#define EVE_TOUCH_THRESHOLD_X           5
+#define EVE_TOUCH_THRESHOLD_Y           5
+#define EVE_TOUCH_TRAVG                 3
+
+#define EVE_NOTAG                       0
+#define EVE_NOTOUCH                     0x80008000
+#define EVE_MAX_TOUCH                   5
+
+/* events */
+#define EVE_TOUCH_ETYPE_TAG             0x0001
+#define EVE_TOUCH_ETYPE_TAG_UP          0x0002
+#define EVE_TOUCH_ETYPE_POINT           0x0004
+#define EVE_TOUCH_ETYPE_POINT_UP        0x0008
+#define EVE_TOUCH_ETYPE_TRACK           0x0010
+#define EVE_TOUCH_ETYPE_TRACK_START     0x0020
+#define EVE_TOUCH_ETYPE_TRACK_STOP      0x0040
+#define EVE_TOUCH_ETYPE_TRACK_ABORT     0x0080
+#define EVE_TOUCH_ETYPE_TIMER           0x0100
+#define EVE_TOUCH_ETYPE_TIMER_ABORT     0x0200
+#define EVE_TOUCH_ETYPE_TRACK_REG       0x0400
+#define EVE_TOUCH_ETYPE_LPRESS          0x0800
+#define EVE_TOUCH_ETYPE_TAP1            0x1000
+#define EVE_TOUCH_ETYPE_TAP2            0x2000
+#define EVE_TOUCH_ETYPE_USR             0x4000
+#define EVE_TOUCH_ETYPE_USR1            0x8000
+
+#define EVE_TOUCH_ETYPE_TRACK_MASK      (EVE_TOUCH_ETYPE_TRACK  | EVE_TOUCH_ETYPE_TRACK_START | EVE_TOUCH_ETYPE_TRACK_STOP | EVE_TOUCH_ETYPE_TRACK_ABORT | EVE_TOUCH_ETYPE_TRACK_REG)
+#define EVE_TOUCH_ETYPE_TIMER_MASK      (EVE_TOUCH_ETYPE_TIMER  | EVE_TOUCH_ETYPE_TIMER_ABORT)
+#define EVE_TOUCH_ETYPE_POINT_MASK      (EVE_TOUCH_ETYPE_POINT  | EVE_TOUCH_ETYPE_POINT_UP)
+#define EVE_TOUCH_ETYPE_USR_MASK        (EVE_TOUCH_ETYPE_USR    | EVE_TOUCH_ETYPE_USR1)
+
+/* extended events */
+#define EVE_TOUCH_EETYPE_NOTOUCH        0x0001
+#define EVE_TOUCH_EETYPE_LPRESS         0x0002
+#define EVE_TOUCH_EETYPE_TAP2           0x0004
+
+#define EVE_TOUCH_EETYPE_TRACK_LEFT     0x0010
+#define EVE_TOUCH_EETYPE_TRACK_RIGHT    0x0020
+#define EVE_TOUCH_EETYPE_TRACK_UP       0x0040
+#define EVE_TOUCH_EETYPE_TRACK_DOWN     0x0080
+
+#define EVE_TOUCH_EETYPE_TRACK_ABORT    0x0100
+#define EVE_TOUCH_EETYPE_TIMER_ABORT    0x0200
+
+#define EVE_TOUCH_EETYPE_USR            0x1000
+#define EVE_TOUCH_EETYPE_USR1           0x2000
+#define EVE_TOUCH_EETYPE_USR2           0x4000
+#define EVE_TOUCH_EETYPE_USR3           0x8000
+
+#define EVE_TOUCH_EETYPE_TRACK_X        (EVE_TOUCH_EETYPE_TRACK_LEFT    | EVE_TOUCH_EETYPE_TRACK_RIGHT)
+#define EVE_TOUCH_EETYPE_TRACK_Y        (EVE_TOUCH_EETYPE_TRACK_UP      | EVE_TOUCH_EETYPE_TRACK_DOWN)
+#define EVE_TOUCH_EETYPE_TRACK_XY       (EVE_TOUCH_EETYPE_TRACK_X       | EVE_TOUCH_EETYPE_TRACK_Y)
+#define EVE_TOUCH_EETYPE_ABORT          (EVE_TOUCH_EETYPE_TRACK_ABORT   | EVE_TOUCH_EETYPE_TIMER_ABORT)
+
+/* tag options */
+#define EVE_TOUCH_OPT_TRACK             0x01
+#define EVE_TOUCH_OPT_TRACK_REG         0x02
+#define EVE_TOUCH_OPT_TRACK_X           0x04
+#define EVE_TOUCH_OPT_TRACK_Y           0x08
+#define EVE_TOUCH_OPT_TRACK_EXT_X       0x10
+#define EVE_TOUCH_OPT_TRACK_EXT_Y       0x20
+#define EVE_TOUCH_OPT_LPRESS            0x40
+#define EVE_TOUCH_OPT_TAP2              0x80
+
+#define EVE_TOUCH_OPT_TRACK_XY          (EVE_TOUCH_OPT_TRACK_X      | EVE_TOUCH_OPT_TRACK_Y)
+#define EVE_TOUCH_OPT_TRACK_EXT_XY      (EVE_TOUCH_OPT_TRACK_EXT_X  | EVE_TOUCH_OPT_TRACK_EXT_Y)
+
+typedef struct EVETouch {
+    int x;
+    int y;
+    int vx;
+    int vy;
+    int x0;
+    int y0;
+    uint64_t t;
+    uint16_t eevt;
+    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 {
+    EVETouch *touch;
+    uint32_t to;
+    uint16_t evt;
+    uint8_t tag0;
+} EVETouchTimer;
+
+typedef void (*eve_touch_handler_t) (EVETouch *, uint16_t, uint8_t, void *);
+
+void eve_handle_touch(void);
+void eve_handle_time(void);
+
+void eve_touch_init(void);
+void eve_touch_set_handler(eve_touch_handler_t handler, void *handler_param);
+EVETouch *eve_touch_get(int i);
+int8_t eve_touch_get_idx(EVETouch *touch);
+uint16_t eve_touch_evt(EVETouch *touch, uint16_t evt, uint8_t tag0, uint8_t tag_min, uint8_t tag_n);
+
+void eve_touch_set_opt(uint8_t tag, uint8_t opt);
+uint8_t eve_touch_get_opt(uint8_t tag);
+void eve_touch_clear_opt(void);
+
+void eve_touch_timer_set(EVETouch *touch, uint16_t evt, uint8_t tag0, uint32_t to);
+void eve_touch_timer_clear(EVETouch *touch);
+uint16_t eve_touch_timer_get_evt(EVETouch *touch);
+void eve_touch_timer_set_evt(EVETouch *touch, uint16_t evt);
+void eve_touch_timer_start(uint8_t tag0, uint32_t to);
+void eve_touch_timer_stop(void);
+
+EVETouchTimer *eve_touch_timer_get(void);
diff --git a/fw/fe310/eos/eve/eve_vtrack.c b/fw/fe310/eos/eve/eve_vtrack.c
new file mode 100644
index 0000000..b9f28af
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_vtrack.c
@@ -0,0 +1,65 @@
+#include <stdlib.h>
+#include <math.h>
+
+#include "eve.h"
+
+static EVEVTrack vtrack;
+static EVEPhyAcc vtrack_acc;
+
+void eve_vtrack_init(void) {
+    eve_phy_acc_init(&vtrack_acc, -EVE_VTRACK_ACC_A);
+    eve_vtrack_reset();
+}
+
+EVEVTrack *eve_vtrack_get(void) {
+    return &vtrack;
+}
+
+void eve_vtrack_set(eve_vtrack_start_t start, eve_vtrack_tick_t tick, eve_vtrack_stop_t stop, void *param) {
+    vtrack.start = start;
+    vtrack.tick = tick;
+    vtrack.stop = stop;
+    vtrack.param = param;
+}
+
+void eve_vtrack_reset(void) {
+    eve_vtrack_set(eve_vtrack_acc_start, eve_vtrack_acc_tick, NULL, &vtrack_acc);
+}
+
+void eve_vtrack_start(EVETouch *touch, uint8_t tag0, uint32_t to) {
+    eve_touch_timer_set(touch, EVE_TOUCH_ETYPE_TRACK, tag0, to);
+    if (vtrack.start) vtrack.start(touch, vtrack.param);
+}
+
+void eve_vtrack_stop(EVETouch *touch) {
+    eve_touch_timer_clear(touch);
+    eve_vtrack_reset();
+}
+
+void eve_vtrack_acc_start(EVETouch *touch, void *p) {
+    EVEPhyAcc *param = (EVEPhyAcc *)p;
+    eve_phy_acc_start(param, touch->x, touch->y, touch->vx, touch->vy);
+}
+
+int eve_vtrack_acc_tick(EVETouch *touch, void *p) {
+    EVEPhyAcc *param = (EVEPhyAcc *)p;
+
+    return eve_phy_acc_tick(param, eve_time_get_tick() - touch->t, &touch->x, &touch->y);
+}
+
+void eve_vtrack_lho_start(EVETouch *touch, void *p) {
+    EVEPhyLHO *param = (EVEPhyLHO *)p;
+
+    eve_phy_lho_start(param, touch->x, touch->y);
+}
+
+int eve_vtrack_lho_tick(EVETouch *touch, void *p) {
+    EVEPhyLHO *param = (EVEPhyLHO *)p;
+
+    return eve_phy_lho_tick(param, eve_time_get_tick() - touch->t, &touch->x, &touch->y);
+}
+
+void eve_vtrack_lho_stop(EVETouch *touch, void *p) {
+    eve_vtrack_reset();
+}
+
diff --git a/fw/fe310/eos/eve/eve_vtrack.h b/fw/fe310/eos/eve/eve_vtrack.h
new file mode 100644
index 0000000..b75f673
--- /dev/null
+++ b/fw/fe310/eos/eve/eve_vtrack.h
@@ -0,0 +1,28 @@
+#include <stdint.h>
+
+#define EVE_VTRACK_ACC_A        1000
+
+typedef void (*eve_vtrack_start_t) (EVETouch *, void *);
+typedef int  (*eve_vtrack_tick_t)  (EVETouch *, void *);
+typedef void (*eve_vtrack_stop_t)  (EVETouch *, void *);
+
+typedef struct EVEVTrack {
+    eve_vtrack_start_t start;
+    eve_vtrack_tick_t  tick;
+    eve_vtrack_stop_t  stop;
+    void *param;
+} EVEVTrack;
+
+void eve_vtrack_init(void);
+EVEVTrack *eve_vtrack_get(void);
+void eve_vtrack_set(eve_vtrack_start_t start, eve_vtrack_tick_t tick, eve_vtrack_stop_t stop, void *param);
+void eve_vtrack_reset(void);
+void eve_vtrack_start(EVETouch *touch, uint8_t tag0, uint32_t to);
+void eve_vtrack_stop(EVETouch *touch);
+
+void eve_vtrack_acc_start(EVETouch *touch, void *p);
+int eve_vtrack_acc_tick(EVETouch *touch, void *p);
+
+void eve_vtrack_lho_start(EVETouch *touch, void *p);
+int eve_vtrack_lho_tick(EVETouch *touch, void *p);
+void eve_vtrack_lho_stop(EVETouch *touch, void *p);
diff --git a/fw/fe310/eos/eve/screen/Makefile b/fw/fe310/eos/eve/screen/Makefile
new file mode 100644
index 0000000..cc4a81d
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/Makefile
@@ -0,0 +1,17 @@
+include ../../../common.mk
+
+CFLAGS += -I.. -I../..
+
+obj = window.o view.o page.o form.o
+
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $<
+
+%.o: %.S
+	$(CC) $(CFLAGS) -c $<
+
+all: $(obj)
+
+clean:
+	rm -f *.o
diff --git a/fw/fe310/eos/eve/screen/form.c b/fw/fe310/eos/eve/screen/form.c
new file mode 100644
index 0000000..8555158
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/form.c
@@ -0,0 +1,165 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "window.h"
+#include "page.h"
+#include "form.h"
+
+#include "widget/widgets.h"
+
+#define MIN(X, Y)               (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y)               (((X) > (Y)) ? (X) : (Y))
+
+static void form_update_g(EVEForm *form, EVEWidget *_widget) {
+    EVEPage *page = &form->p;
+    EVEWidget *widget = page->widget;
+    int i;
+    uint16_t w = 0;
+    uint16_t h = 0;
+    uint16_t l_h = 0;
+
+    for (i=0; i<page->widget_size; i++) {
+        if (widget->label) {
+            h += l_h;
+            w = widget->label->g.w;
+            l_h = widget->label->g.h;
+            widget->label->g.x = 0;
+            widget->label->g.y = h;
+        }
+        if (w + widget->g.w > form->p.v.window->g.w) {
+            h += l_h;
+            w = 0;
+            l_h = 0;
+        }
+        widget->g.x = w;
+        widget->g.y = h;
+
+        w += widget->g.w;
+        l_h = MAX(l_h, widget->g.h);
+
+        widget = eve_widget_next(widget);
+    }
+    page->g.w = page->v.window->g.w;
+    page->g.h = h + l_h;
+}
+
+static void widgets_destroy(EVEWidget *widget, uint16_t widget_size) {
+    int i;
+
+    for (i=0; i<widget_size; i++) {
+        if (widget->label) eve_free(widget->label);
+        eve_widget_destroy(widget);
+        widget = eve_widget_next(widget);
+    }
+}
+
+EVEForm *eve_form_create(EVEWindow *window, EVEViewStack *stack, EVEWidgetSpec spec[], uint16_t spec_size, eve_form_uievt_t uievt, eve_form_action_t action, eve_form_destructor_t destructor) {
+    EVEWidget *widgets;
+    EVEWidget *widget;
+    EVELabel *label;
+    EVEForm *form;
+    int w_size = 0;
+    int i, r;
+
+    for (i=0; i<spec_size; i++) {
+        w_size += eve_widget_size(spec[i].widget.type);
+    }
+    form = eve_malloc(sizeof(EVEForm));
+    if (form == NULL) {
+        return NULL;
+    }
+    if (uievt == NULL) uievt = eve_form_uievt;
+    if (destructor == NULL) destructor = eve_form_destroy;
+    eve_form_init(form, window, stack, NULL, 0, uievt, action, destructor);
+
+    widgets = eve_malloc(w_size);
+    if (widgets == NULL) {
+        eve_free(form);
+        return NULL;
+    }
+
+    widget = widgets;
+    for (i=0; i<spec_size; i++) {
+        r = eve_widget_create(widget, spec[i].widget.type, &spec[i].widget.g, (EVEPage *)form, &spec[i].widget.spec);
+        if (r) {
+            widgets_destroy(widgets, i);
+            eve_free(widgets);
+            eve_free(form);
+            return NULL;
+        }
+        if (spec[i].label.title) {
+            EVEFont *font = spec[i].label.font ? spec[i].label.font : eve_window_font(window);
+            label = eve_malloc(sizeof(EVELabel));
+            if (label == NULL) {
+                eve_widget_destroy(widget);
+                widgets_destroy(widgets, i);
+                eve_free(widgets);
+                eve_free(form);
+                return NULL;
+            }
+            eve_label_init(label, &spec[i].label.g, font, spec[i].label.title);
+            eve_widget_set_label(widget, label);
+            if (label->g.w == 0) label->g.w = eve_font_str_w(font, label->title);
+        }
+        if (widget->label && (widget->label->g.w == 0)) eve_font_str_w(label->font, label->title) + EVE_FORM_LABEL_MARGIN;
+        if (widget->g.w == 0) widget->g.w = window->g.w - (widget->label ? widget->label->g.w : 0);
+        widget = eve_widget_next(widget);
+    }
+    eve_form_update(form, widgets, spec_size);
+
+    return form;
+}
+
+void eve_form_init(EVEForm *form, EVEWindow *window, EVEViewStack *stack, EVEWidget *widget, uint16_t widget_size, eve_form_uievt_t uievt, eve_form_action_t action, eve_form_destructor_t destructor) {
+    memset(form, 0, sizeof(EVEForm));
+    eve_page_init(&form->p, window, stack, NULL, 0, EVE_PAGE_OPT_SCROLL_Y | EVE_PAGE_OPT_SCROLL_BACK | EVE_PAGE_OPT_TRACK_EXT_Y, eve_page_draw, eve_page_touch, (eve_view_uievt_t)uievt, (eve_page_destructor_t)destructor);
+    form->action = action;
+    eve_form_update(form, widget, widget_size);
+}
+
+void eve_form_update(EVEForm *form, EVEWidget *widget, uint16_t widget_size) {
+    eve_page_update((EVEPage *)form, widget, widget_size);
+    form_update_g(form, NULL);
+}
+
+void eve_form_destroy(EVEForm *form) {
+    widgets_destroy(form->p.widget, form->p.widget_size);
+    eve_free(form->p.widget);
+    eve_free(form);
+}
+
+int eve_form_uievt(EVEForm *form, uint16_t evt, void *param) {
+    switch (evt) {
+        case EVE_UIEVT_WIDGET_UPDATE_G:
+            form_update_g(form, (EVEWidget *)param);
+            break;
+
+        case EVE_UIEVT_PAGE_SCROLL_START:
+            break;
+
+        case EVE_UIEVT_PAGE_SCROLL_STOP:
+            break;
+
+        case EVE_UIEVT_PAGE_TRACK_START:
+            break;
+
+        case EVE_UIEVT_PAGE_TRACK_STOP: {
+            EVEUIEvtTouch *touch_p = (EVEUIEvtTouch *)param;
+            if (touch_p->evt & EVE_TOUCH_ETYPE_TRACK_STOP) {
+                if (touch_p->touch->eevt & EVE_TOUCH_EETYPE_TRACK_RIGHT) {
+                    eve_page_close((EVEPage *)form);
+                    return 1;
+                }
+                if (touch_p->touch->eevt & EVE_TOUCH_EETYPE_TRACK_LEFT) {
+                    if (form->action) form->action(form);
+                }
+            }
+            break;
+        }
+    }
+    return 0;
+}
diff --git a/fw/fe310/eos/eve/screen/form.h b/fw/fe310/eos/eve/screen/form.h
new file mode 100644
index 0000000..272b6ed
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/form.h
@@ -0,0 +1,23 @@
+#include <stdint.h>
+
+#define EVE_FORM_LABEL_MARGIN   10
+
+struct EVEWidget;
+struct EVEWidgetSpec;
+struct EVEForm;
+
+typedef int (*eve_form_uievt_t) (struct EVEForm *, uint16_t, void *);
+typedef void (*eve_form_action_t) (struct EVEForm *);
+typedef void (*eve_form_destructor_t) (struct EVEForm *);
+
+typedef struct EVEForm {
+    EVEPage p;
+    eve_form_action_t action;
+} EVEForm;
+
+EVEForm *eve_form_create(EVEWindow *window, EVEViewStack *stack, struct EVEWidgetSpec *spec, uint16_t spec_size, eve_form_uievt_t uievt, eve_form_action_t action, eve_form_destructor_t destructor);
+void eve_form_init(EVEForm *form, EVEWindow *window, EVEViewStack *stack, struct EVEWidget *widget, uint16_t widget_size, eve_form_uievt_t uievt, eve_form_action_t action, eve_form_destructor_t destructor);
+void eve_form_update(EVEForm *form, struct EVEWidget *widget, uint16_t widget_size);
+void eve_form_destroy(EVEForm *form);
+
+int eve_form_uievt(EVEForm *form, uint16_t evt, void *param);
diff --git a/fw/fe310/eos/eve/screen/page.c b/fw/fe310/eos/eve/screen/page.c
new file mode 100644
index 0000000..65dd534
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/page.c
@@ -0,0 +1,349 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "window.h"
+#include "page.h"
+
+#include "widget/label.h"
+#include "widget/widget.h"
+
+#define PAGE_TMODE_NONE     0
+#define PAGE_TMODE_TRACK    1
+#define PAGE_TMODE_SCROLL   2
+
+void eve_page_init(EVEPage *page, EVEWindow *window, EVEViewStack *stack, EVEWidget *widget, uint16_t widget_size, uint8_t opt, eve_view_draw_t draw, eve_view_touch_t touch, eve_view_uievt_t uievt, eve_page_destructor_t destructor) {
+    memset(page, 0, sizeof(EVEPage));
+    eve_view_init(&page->v, window, draw, touch, uievt, NULL);
+    page->stack = stack;
+    page->opt = opt;
+    page->destructor = destructor;
+    eve_page_update(page, widget, widget_size);
+}
+
+void eve_page_update(EVEPage *page, EVEWidget *widget, uint16_t widget_size) {
+    page->widget = widget;
+    page->widget_size = widget_size;
+}
+
+void eve_page_open(EVEPage *parent, eve_view_constructor_t constructor) {
+    EVEWindow *window = parent->v.window;
+    EVEViewStack *stack = parent->stack;
+    eve_page_destructor_t destructor = parent->destructor;
+
+    if (destructor) destructor(parent);
+    eve_view_create(window, stack, constructor);
+}
+
+void eve_page_close(EVEPage *page) {
+    EVEWindow *window = page->v.window;
+    EVEViewStack *stack = page->stack;
+    eve_page_destructor_t destructor = page->destructor;
+
+    if (stack->level <= 1) return;
+
+    if (page->lho_t0) {
+        page->lho_t0 = 0;
+        eve_touch_timer_stop();
+    }
+    if (eve_window_scroll(window->root, NULL) == window) {
+        eve_window_scroll_stop(window);
+    }
+
+    if (destructor) destructor(page);
+    eve_window_kbd_detach(window);
+    eve_view_destroy(window, stack);
+}
+
+/* Screen to page coordinates */
+int16_t eve_page_x(EVEPage *page, int16_t x) {
+    return x + page->g.x - page->v.window->g.x;
+}
+
+int16_t eve_page_y(EVEPage *page, int16_t y) {
+    return y + page->g.y - page->v.window->g.y;
+}
+
+/* Page to window coordinates */
+int16_t eve_page_win_x(EVEPage *page, int16_t x) {
+    return x - page->g.x;
+}
+
+int16_t eve_page_win_y(EVEPage *page, int16_t y) {
+    return y - page->g.y;
+}
+
+/* Page to screen coordinates */
+int16_t eve_page_scr_x(EVEPage *page, int16_t x) {
+    return eve_page_win_x(page, x) + page->v.window->g.x;
+}
+
+int16_t eve_page_scr_y(EVEPage *page, int16_t y) {
+    return eve_page_win_y(page, y) + page->v.window->g.y;
+}
+
+int eve_page_rect_visible(EVEPage *page, EVERect *g) {
+    uint16_t w = page->v.window->g.w;
+    uint16_t h = page->v.window->g.h;
+
+    if (((g->x + g->w) >= page->g.x) && ((g->y + g->h) >= page->g.y) && (g->x <= (page->g.x + w)) && (g->y <= (page->g.y + h))) return 1;
+    return 0;
+}
+
+void eve_page_focus(EVEPage *page, EVERect *rect) {
+    if (rect) {
+        EVERect g;
+
+        eve_window_visible_g(page->v.window, &g);
+        g.x -= page->v.window->g.x;
+        g.y -= page->v.window->g.y;
+
+        if (rect->x < page->g.x + g.x) {
+            page->g.x = rect->x - g.x;
+        }
+        if (rect->y < page->g.y + g.y) {
+            page->g.y = rect->y - g.y;
+        }
+        if ((rect->x + rect->w) > (page->g.x + g.x + g.w)) {
+            page->g.x = (rect->x + rect->w) - (g.x + g.w);
+        }
+        if ((rect->y + rect->h) > (page->g.y + g.y + g.h)) {
+            page->g.y = (rect->y + rect->h) - (g.y + g.h);
+        }
+    }
+}
+
+void eve_page_focus_widget(EVEPage *page, EVEWidget *widget, EVERect *rect) {
+    if (page->widget_f != widget) {
+        EVEWindow *window = page->v.window;
+        EVEWidget *widget_f = page->widget_f;
+
+        if (widget_f && widget_f->putc) {
+            widget_f->putc(widget_f, EVE_PAGE_KBDCH_CLOSE);
+            if (!(widget && widget->putc)) eve_window_kbd_detach(window);
+        }
+        if (widget && widget->putc) {
+            EVEKbd *kbd = eve_window_kbd(window);
+
+            if (kbd) eve_kbd_set_handler(kbd, widget->putc, widget);
+            if (!(widget_f && widget_f->putc)) eve_window_kbd_attach(window);
+        }
+        page->widget_f = widget;
+    }
+    if (rect) eve_page_focus(page, rect);
+}
+
+EVEWidget *eve_page_focus_widget_get(EVEPage *page) {
+    return page->widget_f;
+}
+
+EVEWidget *eve_page_widget(EVEPage *page, uint16_t idx) {
+    EVEWidget *w = page->widget;
+    int i;
+
+    if (idx >= page->widget_size) return NULL;
+
+    for (i=0; i<idx; i++) {
+        w = eve_widget_next(w);
+    }
+    return w;
+}
+
+static int page_touch(EVEPage *page, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    EVEView *view = &page->v;
+    EVEWindow *window = view->window;
+    int scroll, scroll_x, scroll_y;
+    int ret = 0;
+
+    scroll_x = page->opt & (EVE_PAGE_OPT_SCROLL_X | EVE_PAGE_OPT_SCROLL_XY);
+    if (scroll_x && touch) scroll_x = touch->eevt & ((page->opt & EVE_PAGE_OPT_SCROLL_XY) ? EVE_TOUCH_EETYPE_TRACK_XY : EVE_TOUCH_EETYPE_TRACK_X);
+
+    scroll_y = page->opt & (EVE_PAGE_OPT_SCROLL_Y | EVE_PAGE_OPT_SCROLL_XY);
+    if (scroll_y && touch) scroll_y = touch->eevt & ((page->opt & EVE_PAGE_OPT_SCROLL_XY) ? EVE_TOUCH_EETYPE_TRACK_XY : EVE_TOUCH_EETYPE_TRACK_Y);
+
+    scroll = scroll_x || scroll_y;
+
+    if ((evt & EVE_TOUCH_ETYPE_POINT_UP) && !(touch->eevt & (EVE_TOUCH_EETYPE_TRACK_XY | EVE_TOUCH_EETYPE_ABORT))) {
+        int _ret = 0;
+
+        if (page->widget_f) eve_page_focus_widget(page, NULL, NULL);
+        _ret = eve_view_uievt_pusht(view, EVE_UIEVT_PAGE_TOUCH, touch, evt, tag0);
+        if (_ret) return _ret;
+        ret = 1;
+    }
+
+    /* Scroll start */
+    if ((evt & EVE_TOUCH_ETYPE_TRACK_START) && !(touch->eevt & EVE_TOUCH_EETYPE_ABORT)) {
+        int _ret = 0;
+
+        if (scroll) {
+            page->track_mode = PAGE_TMODE_SCROLL;
+            eve_window_scroll_start(window, touch->tracker.tag);
+            _ret = eve_view_uievt_pusht(view, EVE_UIEVT_PAGE_SCROLL_START, touch, evt, tag0);
+        } else {
+            page->track_mode = PAGE_TMODE_TRACK;
+            _ret = eve_view_uievt_pusht(view, EVE_UIEVT_PAGE_TRACK_START, touch, evt, tag0);
+        }
+        if (_ret) return _ret;
+        ret = 1;
+    }
+
+    /* Scroll stop */
+    if (((evt & EVE_TOUCH_ETYPE_TRACK_STOP) && !(evt & EVE_TOUCH_ETYPE_TRACK_ABORT)) ||
+        ((evt & EVE_TOUCH_ETYPE_POINT_UP) && (touch->eevt & EVE_TOUCH_EETYPE_ABORT) && !(touch->eevt & EVE_TOUCH_EETYPE_TRACK_XY))) {
+        if ((page->track_mode == PAGE_TMODE_SCROLL) && (page->opt & EVE_PAGE_OPT_SCROLL_BACK)) {
+            int wmax_x, wmax_y;
+            int lho_x, lho_y;
+            EVERect vg;
+
+            eve_window_visible_g(page->v.window, &vg);
+            wmax_x = page->g.w > vg.w ? page->g.w - vg.w : 0;
+            wmax_y = page->g.h > vg.h ? page->g.h - vg.h : 0;
+            lho_x = page->g.x < 0 ? 0 : wmax_x;
+            lho_y = page->g.y < 0 ? 0 : wmax_y;
+            if ((page->g.x < 0) || (page->g.x > wmax_x) ||
+                (page->g.y < 0) || (page->g.y > wmax_y)) {
+                EVEPhyLHO *lho = &page->lho;
+                uint8_t _tag;
+
+                eve_window_scroll(window->root, &_tag);
+
+                eve_phy_lho_init(lho, lho_x, lho_y, 1000, 0.5, 0);
+                eve_phy_lho_start(lho, page->g.x, page->g.y);
+                page->lho_t0 = eve_time_get_tick();
+                eve_touch_timer_start(_tag, 20);
+            }
+        }
+
+        if (!page->lho_t0) {
+            int _ret = 0;
+
+            if (page->track_mode == PAGE_TMODE_SCROLL) {
+                page->track_mode = PAGE_TMODE_NONE;
+                eve_window_scroll_stop(window);
+                _ret = eve_view_uievt_pusht(view, EVE_UIEVT_PAGE_SCROLL_STOP, touch, evt, tag0);
+            } else if (!(touch->eevt & EVE_TOUCH_EETYPE_ABORT)) {
+                page->track_mode = PAGE_TMODE_NONE;
+                _ret = eve_view_uievt_pusht(view, EVE_UIEVT_PAGE_TRACK_STOP, touch, evt, tag0);
+            }
+            if (_ret) return _ret;
+            ret = 1;
+        }
+    }
+
+    if (page->track_mode == PAGE_TMODE_SCROLL) {
+        if (evt & EVE_TOUCH_ETYPE_TRACK_START) {
+            if (scroll_x) {
+                page->x0 = page->g.x;
+            }
+            if (scroll_y) {
+                page->y0 = page->g.y;
+            }
+        }
+        if (evt & EVE_TOUCH_ETYPE_TRACK) {
+            if (scroll_x) {
+                page->g.x = page->x0 + touch->x0 - touch->x;
+            }
+            if (scroll_y) {
+                page->g.y = page->y0 + touch->y0 - touch->y;
+            }
+            ret = 1;
+        }
+        if ((evt & EVE_TOUCH_ETYPE_TIMER) && (page->opt & EVE_PAGE_OPT_SCROLL_BACK)) {
+            EVEPhyLHO *lho = &page->lho;
+            int x, y, more;
+
+            more = eve_phy_lho_tick(lho, eve_time_get_tick() - page->lho_t0, scroll_x ? &x : NULL, scroll_y ? &y : NULL);
+            if (scroll_x) page->g.x = x;
+            if (scroll_y) page->g.y = y;
+            if (!more) {
+                int _ret = 0;
+
+                page->lho_t0 = 0;
+                eve_touch_timer_stop();
+                page->track_mode = PAGE_TMODE_NONE;
+                eve_window_scroll_stop(window);
+                _ret = eve_view_uievt_pusht(view, EVE_UIEVT_PAGE_SCROLL_STOP, touch, evt, tag0);
+                if (_ret) return _ret;
+            }
+            ret = 1;
+        }
+        if (evt & EVE_TOUCH_EETYPE_TIMER_ABORT) {
+            page->lho_t0 = 0;
+        }
+    }
+
+    return ret;
+}
+
+uint8_t eve_page_draw(EVEView *view, uint8_t tag0) {
+    EVEPage *page = (EVEPage *)view;
+    EVEWidget *widget = page->widget;
+    int i;
+    uint8_t tagN = tag0;
+    uint8_t tag_opt;
+
+    tag_opt = EVE_TOUCH_OPT_TRACK | EVE_TOUCH_OPT_TRACK_XY;
+    if (page->opt & EVE_PAGE_OPT_TRACK_EXT_X) tag_opt |= EVE_TOUCH_OPT_TRACK_EXT_X;
+    if (page->opt & EVE_PAGE_OPT_TRACK_EXT_Y) tag_opt |= EVE_TOUCH_OPT_TRACK_EXT_Y;
+
+    tag0 = eve_view_clear(view, tag0, tag_opt);
+    tagN = tag0;
+    eve_cmd_dl(SAVE_CONTEXT());
+    eve_cmd_dl(VERTEX_FORMAT(0));
+    eve_cmd_dl(VERTEX_TRANSLATE_X(eve_page_scr_x(page, 0) * 16));
+    eve_cmd_dl(VERTEX_TRANSLATE_Y(eve_page_scr_y(page, 0) * 16));
+    for (i=0; i<page->widget_size; i++) {
+        if (widget->label && eve_page_rect_visible(page, &widget->label->g)) {
+            eve_cmd_dl(TAG_MASK(0));
+            eve_label_draw(widget->label);
+            eve_cmd_dl(TAG_MASK(1));
+        }
+        if (eve_page_rect_visible(page, &widget->g)) {
+            tagN = widget->draw(widget, tagN);
+        }
+        widget = eve_widget_next(widget);
+    }
+    eve_cmd_dl(RESTORE_CONTEXT());
+
+    for (i=tag0; i<tagN; i++) {
+        if (i != EVE_NOTAG) eve_touch_set_opt(i, eve_touch_get_opt(i) | tag_opt);
+    }
+
+    return tagN;
+}
+
+int eve_page_touch(EVEView *view, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    EVEPage *page = (EVEPage *)view;
+    EVEWidget *widget = page->widget;
+    int8_t touch_idx = eve_touch_get_idx(touch);
+    uint16_t _evt;
+    int i, ret;
+
+    if (touch_idx > 0) return 0;
+
+    _evt = eve_touch_evt(touch, evt, tag0, page->v.tag, 1);
+    if (_evt) {
+        ret = page_touch(page, touch, _evt, tag0);
+        if (ret) return 1;
+    }
+    for (i=0; i<page->widget_size; i++) {
+        if (eve_page_rect_visible(page, &widget->g)) {
+            _evt = eve_touch_evt(touch, evt, tag0, widget->tag0, widget->tagN - widget->tag0);
+            if (_evt) {
+                if (page->track_mode == PAGE_TMODE_NONE) {
+                    ret = widget->touch(widget, touch, _evt);
+                    if (ret) return 1;
+                }
+                ret = page_touch(page, touch, _evt, tag0);
+                if (ret) return 1;
+            }
+        }
+        widget = eve_widget_next(widget);
+    }
+
+    return 0;
+}
diff --git a/fw/fe310/eos/eve/screen/page.h b/fw/fe310/eos/eve/screen/page.h
new file mode 100644
index 0000000..26c33c5
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/page.h
@@ -0,0 +1,56 @@
+#include <stdint.h>
+
+#define EVE_PAGE_KBDCH_CLOSE        0x1a
+
+#define EVE_PAGE_OPT_SCROLL_X       0x01
+#define EVE_PAGE_OPT_SCROLL_Y       0x02
+#define EVE_PAGE_OPT_SCROLL_BACK    0x04
+#define EVE_PAGE_OPT_SCROLL_XY      0x08
+#define EVE_PAGE_OPT_TRACK_EXT_X    0x10
+#define EVE_PAGE_OPT_TRACK_EXT_Y    0x20
+#define EVE_PAGE_OPT_TRACK_EXT_XY  (EVE_PAGE_OPT_TRACK_EXT_X | EVE_PAGE_OPT_TRACK_EXT_Y)
+
+struct EVEWidget;
+struct EVEPage;
+
+typedef void (*eve_page_destructor_t) (struct EVEPage *);
+
+typedef struct EVEPage {
+    EVEView v;
+    EVERect g;
+    int16_t x0;
+    int16_t y0;
+    EVEViewStack *stack;
+    eve_page_destructor_t destructor;
+    struct EVEWidget *widget;
+    uint16_t widget_size;
+    struct EVEWidget *widget_f;
+    EVEPhyLHO lho;
+    uint64_t lho_t0;
+    uint8_t track_mode;
+    uint8_t opt;
+} EVEPage;
+
+void eve_page_init(EVEPage *page, EVEWindow *window, EVEViewStack *stack, struct EVEWidget *widget, uint16_t widget_size, uint8_t opt,eve_view_draw_t draw, eve_view_touch_t touch, eve_view_uievt_t uievt, eve_page_destructor_t destructor);
+void eve_page_update(EVEPage *page, struct EVEWidget *widget, uint16_t widget_size);
+void eve_page_open(EVEPage *parent, eve_view_constructor_t constructor);
+void eve_page_close(EVEPage *page);
+
+/* Screen to page coordinates */
+int16_t eve_page_x(EVEPage *page, int16_t x);
+int16_t eve_page_y(EVEPage *page, int16_t y);
+/* Page to window coordinates */
+int16_t eve_page_win_x(EVEPage *page, int16_t x);
+int16_t eve_page_win_y(EVEPage *page, int16_t y);
+/* Page to screen coordinates */
+int16_t eve_page_scr_x(EVEPage *page, int16_t x);
+int16_t eve_page_scr_y(EVEPage *page, int16_t y);
+int eve_page_rect_visible(EVEPage *page, EVERect *g);
+
+void eve_page_focus(EVEPage *page, EVERect *rect);
+void eve_page_focus_widget(EVEPage *page, struct EVEWidget *widget, EVERect *rect);
+struct EVEWidget *eve_page_focus_widget_get(EVEPage *page);
+struct EVEWidget *eve_page_widget(EVEPage *page, uint16_t idx);
+
+uint8_t eve_page_draw(EVEView *view, uint8_t tag0);
+int eve_page_touch(EVEView *view, EVETouch *touch, uint16_t evt, uint8_t tag0);
diff --git a/fw/fe310/eos/eve/screen/uievt.h b/fw/fe310/eos/eve/screen/uievt.h
new file mode 100644
index 0000000..98f0d95
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/uievt.h
@@ -0,0 +1,14 @@
+#define EVE_UIEVT_WIN_UPDATE_G          1
+#define EVE_UIEVT_PAGE_UPDATE_G         2
+#define EVE_UIEVT_PAGE_TOUCH            3
+#define EVE_UIEVT_PAGE_SCROLL_START     4
+#define EVE_UIEVT_PAGE_SCROLL_STOP      5
+#define EVE_UIEVT_PAGE_TRACK_START      6
+#define EVE_UIEVT_PAGE_TRACK_STOP       7
+#define EVE_UIEVT_WIDGET_UPDATE_G       8
+
+typedef struct EVEUIEvtTouch {
+    EVETouch *touch;
+    uint16_t evt;
+    uint8_t tag0;
+} EVEUIEvtTouch;
diff --git a/fw/fe310/eos/eve/screen/view.c b/fw/fe310/eos/eve/screen/view.c
new file mode 100644
index 0000000..ac9aef4
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/view.c
@@ -0,0 +1,94 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "window.h"
+
+void eve_view_init(EVEView *view, EVEWindow *window, eve_view_draw_t draw, eve_view_touch_t touch, eve_view_uievt_t uievt, void *param) {
+    view->draw = draw;
+    view->touch = touch;
+    view->uievt = uievt;
+    view->param = param;
+    view->window = window;
+    view->color_bg = 0x000000;
+    view->color_fg = 0xffffff;
+    window->view = view;
+}
+
+void eve_view_set_color_bg(EVEView *view, uint8_t r, uint8_t g, uint8_t b) {
+    view->color_bg = (r << 16) | (g << 8) | b;
+}
+
+void eve_view_set_color_fg(EVEView *view, uint8_t r, uint8_t g, uint8_t b) {
+    view->color_fg = (r << 16) | (g << 8) | b;
+}
+
+uint8_t eve_view_clear(EVEView *view, uint8_t tag0, uint8_t tag_opt) {
+    EVEWindow *win_scroll = NULL;
+    EVEWindow *window = view->window;
+    uint8_t _tag;
+
+    win_scroll = eve_window_scroll(window->root, &_tag);
+    eve_cmd_dl(CLEAR_COLOR_RGBC(view->color_bg));
+    eve_cmd_dl(COLOR_RGBC(view->color_fg));
+    if (win_scroll == window) {
+        view->tag = _tag;
+        eve_touch_set_opt(view->tag, tag_opt);
+        eve_cmd_dl(TAG(view->tag));
+        eve_cmd_dl(CLEAR_TAG(view->tag));
+    } else if (win_scroll) {
+        view->tag = EVE_NOTAG;
+        eve_cmd_dl(TAG(view->tag));
+        eve_cmd_dl(CLEAR_TAG(view->tag));
+    } else {
+        view->tag = tag0;
+        if (tag0 != EVE_NOTAG) {
+            eve_touch_set_opt(tag0, tag_opt);
+            eve_cmd_dl(CLEAR_TAG(tag0));
+            tag0++;
+        }
+    }
+    eve_cmd_dl(CLEAR(1,1,1));
+    return tag0;
+}
+
+void eve_view_stack_init(EVEViewStack *stack) {
+    memset(stack, 0, sizeof(EVEViewStack));
+}
+
+void eve_view_create(EVEWindow *window, EVEViewStack *stack, eve_view_constructor_t constructor) {
+    if (stack->level < EVE_VIEW_SIZE_STACK - 1) {
+        stack->constructor[stack->level] = constructor;
+        stack->level++;
+        constructor(window, stack);
+    }
+}
+
+void eve_view_destroy(EVEWindow *window, EVEViewStack *stack) {
+    if (stack->level > 1) {
+        eve_view_constructor_t constructor;
+
+        stack->level--;
+        constructor = stack->constructor[stack->level - 1];
+        constructor(window, stack);
+    }
+}
+
+void eve_view_uievt_push(EVEView *view, uint16_t evt, void *param) {
+    if (view->uievt) view->uievt(view, evt, param);
+}
+
+int eve_view_uievt_pusht(EVEView *view, uint16_t evt, EVETouch *touch, uint16_t t_evt, uint8_t tag0) {
+    if (view->uievt) {
+        EVEUIEvtTouch param;
+
+        param.touch = touch;
+        param.evt = t_evt;
+        param.tag0 = tag0;
+        view->uievt(view, evt, &param);
+    }
+    return 0;
+}
diff --git a/fw/fe310/eos/eve/screen/view.h b/fw/fe310/eos/eve/screen/view.h
new file mode 100644
index 0000000..65999d7
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/view.h
@@ -0,0 +1,42 @@
+#include <stdint.h>
+
+#include "uievt.h"
+
+#define EVE_VIEW_SIZE_STACK             16
+
+struct EVEView;
+struct EVEViewStack;
+struct EVEWindow;
+
+typedef uint8_t (*eve_view_draw_t) (struct EVEView *, uint8_t);
+typedef int (*eve_view_touch_t) (struct EVEView *, EVETouch *, uint16_t, uint8_t);
+typedef int (*eve_view_uievt_t) (struct EVEView *, uint16_t, void *);
+typedef void (*eve_view_constructor_t) (struct EVEWindow *window, struct EVEViewStack *);
+
+typedef struct EVEView {
+    eve_view_draw_t draw;
+    eve_view_touch_t touch;
+    eve_view_uievt_t uievt;
+    struct EVEWindow *window;
+    void *param;
+    uint32_t color_bg;
+    uint32_t color_fg;
+    uint8_t tag;
+} EVEView;
+
+typedef struct EVEViewStack {
+    eve_view_constructor_t constructor[EVE_VIEW_SIZE_STACK];
+    uint8_t level;
+} EVEViewStack;
+
+void eve_view_init(EVEView *view, struct EVEWindow *window, eve_view_draw_t draw, eve_view_touch_t touch, eve_view_uievt_t uievt, void *param);
+void eve_view_set_color_bg(EVEView *view, uint8_t r, uint8_t g, uint8_t b);
+void eve_view_set_color_fg(EVEView *view, uint8_t r, uint8_t g, uint8_t b);
+uint8_t eve_view_clear(EVEView *view, uint8_t tag0, uint8_t tag_opt);
+
+void eve_view_stack_init(EVEViewStack *stack);
+void eve_view_create(struct EVEWindow *window, EVEViewStack *stack, eve_view_constructor_t constructor);
+void eve_view_destroy(struct EVEWindow *window, EVEViewStack *stack);
+
+void eve_view_uievt_push(EVEView *view, uint16_t evt, void *param);
+int eve_view_uievt_pusht(EVEView *view, uint16_t evt, EVETouch *touch, uint16_t t_evt, uint8_t tag0);
diff --git a/fw/fe310/eos/eve/screen/window.c b/fw/fe310/eos/eve/screen/window.c
new file mode 100644
index 0000000..c259b19
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/window.c
@@ -0,0 +1,300 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "window.h"
+
+#define MIN(X, Y)           (((X) < (Y)) ? (X) : (Y))
+
+void eve_window_init(EVEWindow *window, EVERect *g, EVEWindow *parent, char *name) {
+    memset(window, 0, sizeof(EVEWindow));
+
+    if (g) window->g = *g;
+    window->root = parent ? parent->root : NULL;
+    window->parent = parent;
+    window->name = name;
+}
+
+void eve_window_init_root(EVEWindowRoot *root, EVERect *g, char *name, EVEFont *font) {
+    EVEWindow *_window = &root->w;
+
+    eve_window_init(_window, g, NULL, name);
+    _window->root = root;
+    root->mem_next = EVE_RAM_G;
+    root->font = font;
+    root->win_kbd = NULL;
+    root->tag0 = EVE_NOTAG;
+    eve_touch_set_handler(eve_window_root_touch, root);
+}
+
+static uint8_t kbd_draw(EVEView *view, uint8_t tag0) {
+    EVEKbd *kbd = view->param;
+
+    tag0 = eve_view_clear(view, tag0, 0);
+
+    eve_kbd_draw(kbd);
+    return tag0;
+}
+
+static int kbd_touch(EVEView *view, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    EVEKbd *kbd = view->param;
+
+    return eve_kbd_touch(kbd, touch, evt, tag0);
+}
+
+void eve_window_init_kbd(EVEWindowKbd *win_kbd, EVERect *g, EVEWindowRoot *root, char *name, EVEKbd *kbd) {
+    EVEWindow *_window = &win_kbd->w;
+
+    eve_window_init(_window, g, NULL, name);
+    _window->root = root;
+    win_kbd->kbd = kbd;
+    root->win_kbd = win_kbd;
+    eve_view_init(&win_kbd->v, _window, kbd_draw, kbd_touch, NULL, kbd);
+}
+
+void eve_window_set_parent(EVEWindow *window, EVEWindow *parent) {
+    window->parent = parent;
+    window->root = parent->root;
+}
+
+int eve_window_visible(EVEWindow *window) {
+    if (window->g.x >= window->root->w.g.w) return 0;
+    if (window->g.y >= window->root->w.g.h) return 0;
+    if ((window->g.x + window->g.w) <= 0) return 0;
+    if ((window->g.y + window->g.h) <= 0) return 0;
+    return 1;
+}
+
+static void window_visible_g(EVEWindow *w, EVERect *g) {
+    while (w) {
+        if (eve_window_visible(w)) {
+            if (w->g.x > g->x) g->w = MIN(g->w, w->g.x - g->x);
+            if (w->g.y > g->y) g->h = MIN(g->h, w->g.y - g->y);
+            if (w->g.x + w->g.w < g->x + g->w) {
+                uint16_t x0 = g->w - MIN(g->w, (g->x + g->w) - (w->g.x + w->g.w));
+                g->x += x0;
+                g->w -= x0;
+            }
+            if (w->g.y + w->g.h < g->y + g->h) {
+                uint16_t y0 = g->h - MIN(g->h, (g->y + g->h) - (w->g.y + w->g.h));
+                g->y += y0;
+                g->h -= y0;
+            }
+        }
+        if (w->child_head) window_visible_g(w->child_head, g);
+        w = w->next;
+    }
+}
+
+void eve_window_visible_g(EVEWindow *window, EVERect *g) {
+    *g = window->g;
+    if (window->child_head) window_visible_g(window->child_head, g);
+    window_visible_g(window->next, g);
+}
+
+void eve_window_append(EVEWindow *window) {
+    EVEWindow *parent = window->parent;
+
+    window->prev = parent->child_tail;
+    window->next = NULL;
+    if (parent->child_tail) {
+        parent->child_tail->next = window;
+    } else {
+        parent->child_head = window;
+    }
+    parent->child_tail = window;
+}
+
+void eve_window_insert_above(EVEWindow *window, EVEWindow *win_prev) {
+    EVEWindow *parent = window->parent;
+
+    window->prev = win_prev;
+    window->next = win_prev->next;
+
+    if (window->next) {
+        window->next->prev = window;
+    } else {
+        parent->child_tail = window;
+    }
+    win_prev->next = window;
+}
+
+void eve_window_insert_below(EVEWindow *window, EVEWindow *win_next) {
+    EVEWindow *parent = window->parent;
+
+    window->prev = win_next->prev;
+    window->next = win_next;
+
+    win_next->prev = window;
+    if (window->prev) {
+        window->prev->next = window;
+    } else {
+        parent->child_head = window;
+    }
+}
+
+void eve_window_remove(EVEWindow *window) {
+    EVEWindow *parent = window->parent;
+
+    if (window->prev) {
+        window->prev->next = window->next;
+    } else {
+        parent->child_head = window->next;
+    }
+    if (window->next) {
+        window->next->prev = window->prev;
+    } else {
+        parent->child_tail = window->prev;
+    }
+    window->parent = NULL;
+    window->prev = NULL;
+    window->next = NULL;
+}
+
+EVEWindow *eve_window_search(EVEWindow *window, char *name) {
+    while (window) {
+        if (window->name && (strcmp(name, window->name) == 0)) return window;
+        if (window->child_head) {
+            EVEWindow *ret = eve_window_search(window->child_head, name);
+            if (ret) return ret;
+        }
+        window = window->next;
+    }
+
+    return NULL;
+}
+
+uint8_t eve_window_draw(EVEWindow *window, uint8_t tag0) {
+    while (window) {
+        if (eve_window_visible(window) && window->view) {
+            int16_t s_x = window->g.x;
+            int16_t s_y = window->g.y;
+            uint16_t s_w = window->g.w;
+            uint16_t s_h = window->g.h;
+
+            if (s_x < 0) {
+                s_w += s_x;
+                s_x = 0;
+            }
+            if (s_y < 0) {
+                s_h += s_y;
+                s_y = 0;
+            }
+            if (s_x + s_w > window->root->w.g.w) s_w = window->root->w.g.w - s_x;
+            if (s_y + s_h > window->root->w.g.h) s_h = window->root->w.g.h - s_y;
+            eve_cmd_dl(SCISSOR_XY(s_x, s_y));
+            eve_cmd_dl(SCISSOR_SIZE(s_w, s_h));
+            tag0 = window->view->draw(window->view, tag0);
+        }
+        if (window->child_head) tag0 = eve_window_draw(window->child_head, tag0);
+        window = window->next;
+    }
+
+    return tag0;
+}
+
+int eve_window_touch(EVEWindow *window, EVETouch *touch, uint16_t evt, uint8_t tag0) {
+    int ret = 0;
+
+    while (window) {
+        if (window->child_tail) {
+            ret = eve_window_touch(window->child_tail, touch, evt, tag0);
+            if (ret) return 1;
+        }
+        if (eve_window_visible(window) && window->view) {
+            ret = window->view->touch(window->view, touch, evt, tag0);
+            if (ret) return 1;
+        }
+        window = window->prev;
+    }
+
+    return 0;
+}
+
+void eve_window_root_draw(EVEWindowRoot *root) {
+    uint8_t tag0 = 0x80;
+    int rv;
+
+    eve_cmd_burst_start();
+    eve_cmd_dl(CMD_DLSTART);
+
+    if (root->tag0 != EVE_NOTAG) tag0 = EVE_NOTAG;
+    eve_window_draw(&root->w, tag0);
+
+    eve_cmd_dl(DISPLAY());
+    eve_cmd_dl(CMD_SWAP);
+    eve_cmd_burst_end();
+    rv = eve_cmd_exec(1);
+    if (rv) printf("EVE EXEC ERR\n");
+}
+
+void eve_window_root_touch(EVETouch *touch, uint16_t evt, uint8_t tag0, void *win) {
+    EVEWindowRoot *root = (EVEWindowRoot *)win;
+    int ret;
+
+    if (root->tag0 != EVE_NOTAG) tag0 = root->tag0;
+    ret = eve_window_touch(&root->w, touch, evt, tag0);
+    if (ret) {
+        eve_touch_clear_opt();
+        eve_window_root_draw(root);
+    }
+}
+
+EVEKbd *eve_window_kbd(EVEWindow *window) {
+    EVEWindowRoot *root = window->root;
+    EVEWindowKbd *win_kbd = root->win_kbd;
+
+    if (win_kbd) return win_kbd->kbd;
+    return NULL;
+}
+
+void eve_window_kbd_attach(EVEWindow *window) {
+    EVEWindowRoot *root = window->root;
+    EVEWindowKbd *win_kbd = root->win_kbd;
+    EVEKbd *kbd = win_kbd ? win_kbd->kbd : NULL;
+
+    if (kbd) {
+        eve_window_set_parent(&win_kbd->w, window);
+        eve_window_append(&win_kbd->w);
+    }
+}
+
+void eve_window_kbd_detach(EVEWindow *window) {
+    EVEWindowRoot *root = window->root;
+    EVEWindowKbd *win_kbd = root->win_kbd;
+    EVEKbd *kbd = win_kbd ? win_kbd->kbd : NULL;
+
+    if (kbd && win_kbd->w.parent) {
+        eve_window_remove(&win_kbd->w);
+        eve_kbd_close(kbd);
+    }
+}
+
+EVEFont *eve_window_font(EVEWindow *window) {
+    EVEWindowRoot *root = window->root;
+
+    return root->font;
+}
+
+EVEWindow *eve_window_scroll(EVEWindowRoot *root, uint8_t *tag) {
+    if (tag) *tag = root->tag0;
+    return root->win_scroll;
+}
+
+void eve_window_scroll_start(EVEWindow *window, uint8_t tag) {
+    EVEWindowRoot *root = window->root;
+
+    root->win_scroll = window;
+    root->tag0 = tag;
+}
+
+void eve_window_scroll_stop(EVEWindow *window) {
+    EVEWindowRoot *root = window->root;
+
+    root->win_scroll = NULL;
+    root->tag0 = EVE_NOTAG;
+}
diff --git a/fw/fe310/eos/eve/screen/window.h b/fw/fe310/eos/eve/screen/window.h
new file mode 100644
index 0000000..27465c4
--- /dev/null
+++ b/fw/fe310/eos/eve/screen/window.h
@@ -0,0 +1,60 @@
+#include <stdint.h>
+
+#include "view.h"
+
+struct EVEWindowRoot;
+
+typedef struct EVEWindow {
+    EVERect g;
+    char *name;
+    EVEView *view;
+    struct EVEWindowRoot *root;
+    struct EVEWindow *parent;
+    struct EVEWindow *next;
+    struct EVEWindow *prev;
+    struct EVEWindow *child_head;
+    struct EVEWindow *child_tail;
+} EVEWindow;
+
+typedef struct EVEWindowKbd {
+    EVEWindow w;
+    EVEView v;
+    EVEKbd *kbd;
+} EVEWindowKbd;
+
+typedef struct EVEWindowRoot {
+    EVEWindow w;
+    uint32_t mem_next;
+    EVEFont *font;
+    EVEWindowKbd *win_kbd;
+    EVEWindow *win_scroll;
+    uint8_t tag0;
+} EVEWindowRoot;
+
+void eve_window_init(EVEWindow *window, EVERect *g, EVEWindow *parent, char *name);
+void eve_window_init_root(EVEWindowRoot *root, EVERect *g, char *name, EVEFont *font);
+void eve_window_init_kbd(EVEWindowKbd *win_kbd, EVERect *g, EVEWindowRoot *root, char *name, EVEKbd *kbd);
+void eve_window_set_parent(EVEWindow *window, EVEWindow *parent);
+
+int eve_window_visible(EVEWindow *window);
+void eve_window_visible_g(EVEWindow *window, EVERect *g);
+
+void eve_window_append(EVEWindow *window);
+void eve_window_insert_above(EVEWindow *window, EVEWindow *win_prev);
+void eve_window_insert_below(EVEWindow *window, EVEWindow *win_next);
+void eve_window_remove(EVEWindow *window);
+EVEWindow *eve_window_search(EVEWindow *window, char *name);
+
+uint8_t eve_window_draw(EVEWindow *window, uint8_t tag0);
+int eve_window_touch(EVEWindow *window, EVETouch *touch, uint16_t evt, uint8_t tag0);
+void eve_window_root_draw(EVEWindowRoot *root);
+void eve_window_root_touch(EVETouch *touch, uint16_t evt, uint8_t tag0, void *win);
+
+EVEKbd *eve_window_kbd(EVEWindow *window);
+void eve_window_kbd_attach(EVEWindow *window);
+void eve_window_kbd_detach(EVEWindow *window);
+EVEFont *eve_window_font(EVEWindow *window);
+
+EVEWindow *eve_window_scroll(EVEWindowRoot *root, uint8_t *tag);
+void eve_window_scroll_start(EVEWindow *window, uint8_t tag);
+void eve_window_scroll_stop(EVEWindow *window);
diff --git a/fw/fe310/eos/eve/widget/Makefile b/fw/fe310/eos/eve/widget/Makefile
new file mode 100644
index 0000000..95af16d
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/Makefile
@@ -0,0 +1,17 @@
+include ../../../common.mk
+
+CFLAGS += -I.. -I../..
+
+obj = label.o widget.o freew.o spacerw.o pagew.o strw.o textw.o selectw.o
+
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $<
+
+%.o: %.S
+	$(CC) $(CFLAGS) -c $<
+
+all: $(obj)
+
+clean:
+	rm -f *.o
diff --git a/fw/fe310/eos/eve/widget/freew.c b/fw/fe310/eos/eve/widget/freew.c
new file mode 100644
index 0000000..86c2686
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/freew.c
@@ -0,0 +1,54 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+#include "widget.h"
+#include "freew.h"
+
+int eve_freew_create(EVEFreeWidget *widget, EVERect *g, EVEPage *page, EVEFreeSpec *spec) {
+    eve_freew_init(widget, g, page, spec->draw, spec->touch, spec->putc);
+
+    return EVE_OK;
+}
+
+void eve_freew_init(EVEFreeWidget *widget, EVERect *g, EVEPage *page, eve_freew_draw_t draw, eve_freew_touch_t touch, eve_kbd_input_handler_t putc) {
+    EVEWidget *_widget = &widget->w;
+
+    memset(widget, 0, sizeof(EVEFreeWidget));
+    eve_widget_init(_widget, EVE_WIDGET_TYPE_FREE, g, page, eve_freew_draw, eve_freew_touch, putc);
+    widget->_draw = draw;
+    widget->_touch = touch;
+    widget->w.putc = putc;
+}
+
+void eve_freew_tag(EVEFreeWidget *widget) {
+    EVEWidget *_widget = &widget->w;
+
+    if (_widget->tagN != EVE_NOTAG) {
+        eve_cmd_dl(TAG(_widget->tagN));
+        _widget->tagN++;
+    }
+}
+
+uint8_t eve_freew_draw(EVEWidget *_widget, uint8_t tag0) {
+    EVEFreeWidget *widget = (EVEFreeWidget *)_widget;
+
+    _widget->tag0 = tag0;
+    _widget->tagN = tag0;
+    widget->_draw(widget);
+
+    return _widget->tagN;
+}
+
+int eve_freew_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt) {
+    EVEFreeWidget *widget = (EVEFreeWidget *)_widget;
+
+    return widget->_touch(widget, touch, evt);
+}
diff --git a/fw/fe310/eos/eve/widget/freew.h b/fw/fe310/eos/eve/widget/freew.h
new file mode 100644
index 0000000..7eda8c1
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/freew.h
@@ -0,0 +1,25 @@
+#include <stdint.h>
+
+struct EVEFreeWidget;
+
+typedef void (*eve_freew_draw_t) (struct EVEFreeWidget *);
+typedef int (*eve_freew_touch_t) (struct EVEFreeWidget *, EVETouch *, uint16_t);
+
+typedef struct EVEFreeWidget {
+    EVEWidget w;
+    eve_freew_draw_t _draw;
+    eve_freew_touch_t _touch;
+} EVEFreeWidget;
+
+typedef struct EVEFreeSpec {
+    eve_freew_draw_t draw;
+    eve_freew_touch_t touch;
+    eve_kbd_input_handler_t putc;
+} EVEFreeSpec;
+
+int eve_freew_create(EVEFreeWidget *widget, EVERect *g, EVEPage *page, EVEFreeSpec *spec);
+void eve_freew_init(EVEFreeWidget *widget, EVERect *g, EVEPage *page, eve_freew_draw_t draw, eve_freew_touch_t touch, eve_kbd_input_handler_t putc);
+
+void eve_freew_tag(EVEFreeWidget *widget);
+uint8_t eve_freew_draw(EVEWidget *_widget, uint8_t tag0);
+int eve_freew_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt);
diff --git a/fw/fe310/eos/eve/widget/label.c b/fw/fe310/eos/eve/widget/label.c
new file mode 100644
index 0000000..f2d2e8e
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/label.c
@@ -0,0 +1,23 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+
+void eve_label_init(EVELabel *label, EVERect *g, EVEFont *font, char *title) {
+    memset(label, 0, sizeof(EVELabel));
+    if (g) label->g = *g;
+    label->font = font;
+    label->title = title;
+    if (label->g.h == 0) label->g.h = eve_font_h(font);
+}
+
+void eve_label_draw(EVELabel *label) {
+    eve_cmd(CMD_TEXT, "hhhhs", label->g.x, label->g.y, label->font->id, 0, label->title);
+}
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/widget/label.h b/fw/fe310/eos/eve/widget/label.h
new file mode 100644
index 0000000..659c057
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/label.h
@@ -0,0 +1,10 @@
+#include <stdint.h>
+
+typedef struct EVELabel {
+    EVERect g;
+    EVEFont *font;
+    char *title;
+} EVELabel;
+
+void eve_label_init(EVELabel *label, EVERect *g, EVEFont *font, char *title);
+void eve_label_draw(EVELabel *label);
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/widget/pagew.c b/fw/fe310/eos/eve/widget/pagew.c
new file mode 100644
index 0000000..bd7819f
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/pagew.c
@@ -0,0 +1,59 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+#include "widget.h"
+#include "pagew.h"
+
+int eve_pagew_create(EVEPageWidget *widget, EVERect *g, EVEPage *page, EVEPageSpec *spec) {
+    EVEFont *font = spec->font ? spec->font : eve_window_font(page->v.window);
+
+    eve_pagew_init(widget, g, page, font, spec->title, spec->constructor);
+
+    return EVE_OK;
+}
+
+void eve_pagew_init(EVEPageWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, char *title, eve_view_constructor_t constructor) {
+    EVEWidget *_widget = &widget->w;
+
+    memset(widget, 0, sizeof(EVEPageWidget));
+    eve_widget_init(_widget, EVE_WIDGET_TYPE_PAGE, g, page, eve_pagew_draw, eve_pagew_touch, NULL);
+    widget->font = font;
+    widget->title = title;
+    widget->constructor = constructor;
+    if (_widget->g.h == 0) _widget->g.h = eve_font_h(widget->font);
+}
+
+uint8_t eve_pagew_draw(EVEWidget *_widget, uint8_t tag0) {
+    EVEPageWidget *widget = (EVEPageWidget *)_widget;
+
+    _widget->tag0 = tag0;
+    if (tag0 != EVE_NOTAG) {
+        eve_cmd_dl(TAG(tag0));
+        tag0++;
+    }
+    _widget->tagN = tag0;
+
+    eve_cmd(CMD_TEXT, "hhhhs", _widget->g.x, _widget->g.y, widget->font->id, 0, widget->title);
+
+    return _widget->tagN;
+}
+
+int eve_pagew_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt) {
+    EVEPage *parent = _widget->page;
+    EVEPageWidget *widget = (EVEPageWidget *)_widget;
+
+    if (evt & EVE_TOUCH_ETYPE_TAG_UP) {
+        eve_page_open(parent, widget->constructor);
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/fw/fe310/eos/eve/widget/pagew.h b/fw/fe310/eos/eve/widget/pagew.h
new file mode 100644
index 0000000..76ac0d2
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/pagew.h
@@ -0,0 +1,20 @@
+#include <stdint.h>
+
+typedef struct EVEPageWidget {
+    EVEWidget w;
+    EVEFont *font;
+    char *title;
+    eve_view_constructor_t constructor;
+} EVEPageWidget;
+
+typedef struct EVEPageSpec {
+    EVEFont *font;
+    char *title;
+    eve_view_constructor_t constructor;
+} EVEPageSpec;
+
+int eve_pagew_create(EVEPageWidget *widget, EVERect *g, EVEPage *page, EVEPageSpec *spec);
+void eve_pagew_init(EVEPageWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, char *title, eve_view_constructor_t constructor);
+
+uint8_t eve_pagew_draw(EVEWidget *_widget, uint8_t tag0);
+int eve_pagew_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt);
diff --git a/fw/fe310/eos/eve/widget/selectw.c b/fw/fe310/eos/eve/widget/selectw.c
new file mode 100644
index 0000000..46ed3d1
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/selectw.c
@@ -0,0 +1,248 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+#include "widget.h"
+#include "selectw.h"
+
+#define SELECTW_NOSELECT        0xffffffff
+
+#define DIVC(x,y)               ((x) / (y) + ((x) % (y) != 0))
+
+static int selectw_verify(utf8_t *option, uint16_t option_size) {
+    int o_len;
+    uint16_t o_curr;
+    int rv;
+
+    o_curr = 0;
+    while (o_curr < option_size) {
+        rv = utf8_verify(option + o_curr, option_size - o_curr, &o_len);
+        if (rv) return EVE_ERR;
+        if (o_len == 0) return EVE_OK;
+        o_curr += o_len + 1;
+    }
+
+    return EVE_OK;
+}
+
+static int selectw_count(EVESelectWidget *widget) {
+    int o_len;
+    int o_curr;
+    int i;
+
+    o_curr = 0;
+    i = 0;
+    do {
+        o_len = strnlen(widget->option + o_curr, widget->option_size - o_curr);
+        if (o_len == widget->option_size - o_curr) return i;
+        if (o_len) {
+            o_curr += o_len + 1;
+            i++;
+        }
+    } while (o_len);
+
+    return i;
+}
+
+static void selectw_update_sz(EVESelectWidget *widget, int uievt) {
+    EVEWidget *_widget = &widget->w;
+    EVEPage *page = _widget->page;
+
+    _widget->g.h = widget->option_count * widget->font->h;
+    if (uievt) eve_view_uievt_push(&page->v, EVE_UIEVT_WIDGET_UPDATE_G, _widget);
+}
+
+int eve_selectw_create(EVESelectWidget *widget, EVERect *g, EVEPage *page, EVESelectSpec *spec) {
+    EVEFont *font = spec->font ? spec->font : eve_window_font(page->v.window);
+    utf8_t *option;
+
+    option = eve_malloc(spec->option_size);
+    if (option == NULL) {
+        return EVE_ERR_NOMEM;
+    }
+    memset(option, 0, spec->option_size);
+
+    eve_selectw_init(widget, g, page, font, option, spec->option_size, spec->multi);
+
+    return EVE_OK;
+}
+
+void eve_selectw_init(EVESelectWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, utf8_t *option, uint16_t option_size, uint8_t multi) {
+    EVEWidget *_widget = &widget->w;
+    int rv;
+
+    memset(widget, 0, sizeof(EVESelectWidget));
+    eve_widget_init(_widget, EVE_WIDGET_TYPE_SELECT, g, page, eve_selectw_draw, eve_selectw_touch, NULL);
+    widget->font = font;
+    rv = selectw_verify(option, option_size);
+    if (rv == EVE_OK) {
+        widget->option = option;
+        widget->option_size = option_size;
+        widget->option_count = selectw_count(widget);
+        selectw_update_sz(widget, 0);
+    }
+    widget->multi = multi;
+    widget->select = widget->multi ? 0 : SELECTW_NOSELECT;
+}
+
+void eve_selectw_destroy(EVESelectWidget *widget) {
+    eve_free(widget->option);
+}
+
+uint8_t eve_selectw_draw(EVEWidget *_widget, uint8_t tag0) {
+    EVEPage *page = _widget->page;
+    EVESelectWidget *widget = (EVESelectWidget *)_widget;
+    int o_len;
+    int o_curr;
+    int i, s;
+    int16_t x1, x2, y1, y2;
+    uint16_t new_h;
+
+    int line0, lineN;
+
+    line0 = -((int)eve_page_win_y(page, _widget->g.y)) / widget->font->h;
+    lineN = DIVC((-((int)eve_page_win_y(page, _widget->g.y)) + page->v.window->g.h), widget->font->h);
+    if (line0 < 0) line0 = 0;
+    if (lineN < 0) lineN = 0;
+    if (line0 > widget->option_count) line0 = widget->option_count;
+    if (lineN > widget->option_count) lineN = widget->option_count;
+
+    _widget->tag0 = tag0;
+    _widget->tagN = tag0;
+    widget->line0 = line0;
+
+    o_curr = 0;
+    i = 0;
+    do {
+        o_len = strnlen(widget->option + o_curr, widget->option_size - o_curr);
+        if (!o_len || (o_len == widget->option_size - o_curr)) break;
+        if ((i >= line0) && (i < lineN)) {
+            if (_widget->tagN != EVE_NOTAG) {
+                eve_cmd_dl(TAG(_widget->tagN));
+                _widget->tagN++;
+            }
+            s = widget->multi ? widget->select & (0x1 << i) : widget->select == i;
+            x1 = _widget->g.x;
+            x2 = x1 + _widget->g.w;
+            y1 = _widget->g.y + i * widget->font->h;
+            y2 = y1 + widget->font->h;
+            eve_cmd_dl(BEGIN(EVE_RECTS));
+            if (!s) eve_cmd_dl(COLOR_MASK(0 ,0 ,0 ,0));
+            eve_cmd_dl(VERTEX2F(x1, y1));
+            eve_cmd_dl(VERTEX2F(x2, y2));
+            if (!s) {
+                eve_cmd_dl(COLOR_MASK(1 ,1 ,1 ,1));
+                eve_cmd_dl(BEGIN(EVE_LINES));
+                eve_cmd_dl(VERTEX2F(x1, y2));
+                eve_cmd_dl(VERTEX2F(x2, y2));
+            }
+            eve_cmd_dl(END());
+            if (s) eve_cmd_dl(COLOR_RGBC(page->v.color_bg));
+            eve_cmd(CMD_TEXT, "hhhhs", x1, y1, widget->font->id, 0, widget->option + o_curr);
+            if (s) eve_cmd_dl(COLOR_RGBC(page->v.color_fg));
+        }
+
+        o_curr += o_len + 1;
+        i++;
+    } while (o_len);
+
+    return _widget->tagN;
+}
+
+int eve_selectw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt) {
+    EVESelectWidget *widget = (EVESelectWidget *)_widget;
+
+    if (evt & EVE_TOUCH_ETYPE_TAG_UP) {
+        int i = touch->tag0 - _widget->tag0 + widget->line0;
+        if (widget->multi) {
+            uint32_t f = (0x1 << i);
+
+            if (widget->select & f) {
+                widget->select &= ~f;
+            } else {
+                widget->select |= f;
+            }
+        } else {
+            if (widget->select == i) {
+                widget->select = SELECTW_NOSELECT;
+            } else {
+                widget->select = i;
+            }
+        }
+        return 1;
+    }
+    return 0;
+}
+
+utf8_t *eve_selectw_option_get(EVESelectWidget *widget, int idx) {
+    int o_len;
+    int o_curr;
+    int i;
+
+    o_curr = 0;
+    i = 0;
+    do {
+        o_len = strnlen(widget->option + o_curr, widget->option_size - o_curr);
+        if (o_len == widget->option_size - o_curr) return NULL;
+        if (o_len && (i == idx)) return widget->option + o_curr;
+        o_curr += o_len + 1;
+        i++;
+    } while (o_len);
+
+    return NULL;
+}
+
+utf8_t *eve_selectw_option_get_select(EVESelectWidget *widget) {
+    return eve_selectw_option_get(widget, widget->select);
+}
+
+int eve_selectw_option_add(EVESelectWidget *widget, utf8_t *option) {
+    int o_len;
+    int o_curr;
+    int rv, i;
+
+    rv = utf8_verify(option, strlen(option) + 1, NULL);
+    if (rv) return EVE_ERR;
+
+    o_curr = 0;
+    i = 0;
+    do {
+        o_len = strnlen(widget->option + o_curr, widget->option_size - o_curr);
+        if (o_len == widget->option_size - o_curr) return EVE_ERR_FULL;
+        if (o_len) {
+            o_curr += o_len + 1;
+            i++;
+        }
+    } while (o_len);
+
+    if (o_curr + strlen(option) + 1 > widget->option_size) return EVE_ERR_FULL;
+    strcpy(widget->option + o_curr, option);
+
+    widget->option_count = i + 1;
+    selectw_update_sz(widget, 1);
+
+    return EVE_OK;
+}
+
+int eve_selectw_option_set(EVESelectWidget *widget, utf8_t *option, uint16_t option_size) {
+    int rv, i;
+
+    rv = selectw_verify(option, option_size);
+    if (rv) return rv;
+    if (option_size > widget->option_size) return EVE_ERR_FULL;
+
+    memcpy(widget->option, option, option_size);
+    memset(widget->option + option_size, 0, widget->option_size - option_size);
+
+    widget->option_count = selectw_count(widget);
+    selectw_update_sz(widget, 1);
+
+    return EVE_OK;
+}
diff --git a/fw/fe310/eos/eve/widget/selectw.h b/fw/fe310/eos/eve/widget/selectw.h
new file mode 100644
index 0000000..939e362
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/selectw.h
@@ -0,0 +1,30 @@
+#include <stdint.h>
+
+typedef struct EVESelectWidget {
+    EVEWidget w;
+    EVEFont *font;
+    utf8_t *option;
+    uint16_t option_size;
+    uint16_t option_count;
+    uint32_t select;
+    uint16_t line0;
+    uint8_t multi;
+} EVESelectWidget;
+
+typedef struct EVESelectSpec {
+    EVEFont *font;
+    uint16_t option_size;
+    uint8_t multi;
+} EVESelectSpec;
+
+int eve_selectw_create(EVESelectWidget *widget, EVERect *g, EVEPage *page, EVESelectSpec *spec);
+void eve_selectw_init(EVESelectWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, utf8_t *option, uint16_t option_size, uint8_t multi);
+void eve_selectw_destroy(EVESelectWidget *widget);
+
+uint8_t eve_selectw_draw(EVEWidget *_widget, uint8_t tag0);
+int eve_selectw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt);
+
+utf8_t *eve_selectw_option_get(EVESelectWidget *widget, int idx);
+utf8_t *eve_selectw_option_get_select(EVESelectWidget *widget);
+int eve_selectw_option_add(EVESelectWidget *widget, utf8_t *option);
+int eve_selectw_option_set(EVESelectWidget *widget, utf8_t *option, uint16_t option_size);
diff --git a/fw/fe310/eos/eve/widget/spacerw.c b/fw/fe310/eos/eve/widget/spacerw.c
new file mode 100644
index 0000000..d9f9104
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/spacerw.c
@@ -0,0 +1,36 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+#include "widget.h"
+#include "spacerw.h"
+
+int eve_spacerw_create(EVESpacerWidget *widget, EVERect *g, EVEPage *page, EVESpacerSpec *spec) {
+    eve_spacerw_init(widget, g, page);
+
+    return EVE_OK;
+}
+
+void eve_spacerw_init(EVESpacerWidget *widget, EVERect *g, EVEPage *page) {
+    EVEWidget *_widget = &widget->w;
+
+    memset(widget, 0, sizeof(EVESpacerWidget));
+    eve_widget_init(_widget, EVE_WIDGET_TYPE_SPACER, g, page, eve_spacerw_draw, eve_spacerw_touch, NULL);
+}
+
+uint8_t eve_spacerw_draw(EVEWidget *_widget, uint8_t tag0) {
+    _widget->tag0 = tag0;
+    _widget->tagN = tag0;
+    return _widget->tagN;
+}
+
+int eve_spacerw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt) {
+    return 0;
+}
diff --git a/fw/fe310/eos/eve/widget/spacerw.h b/fw/fe310/eos/eve/widget/spacerw.h
new file mode 100644
index 0000000..9dafa8b
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/spacerw.h
@@ -0,0 +1,14 @@
+#include <stdint.h>
+
+typedef struct EVESpacerWidget {
+    EVEWidget w;
+} EVESpacerWidget;
+
+typedef struct EVESpacerSpec {
+} EVESpacerSpec;
+
+int eve_spacerw_create(EVESpacerWidget *widget, EVERect *g, EVEPage *page, EVESpacerSpec *spec);
+void eve_spacerw_init(EVESpacerWidget *widget, EVERect *g, EVEPage *page);
+
+uint8_t eve_spacerw_draw(EVEWidget *_widget, uint8_t tag0);
+int eve_spacerw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt);
diff --git a/fw/fe310/eos/eve/widget/strw.c b/fw/fe310/eos/eve/widget/strw.c
new file mode 100644
index 0000000..e78cf46
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/strw.c
@@ -0,0 +1,446 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "clipb.h"
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+#include "widget.h"
+#include "strw.h"
+
+#define STRW_TOUCH_OPT          EVE_TOUCH_OPT_TRACK | EVE_TOUCH_OPT_TRACK_X | EVE_TOUCH_OPT_TRACK_EXT_X | EVE_TOUCH_OPT_LPRESS
+
+#define STRW_TMODE_NONE         0
+#define STRW_TMODE_CRSR         1
+#define STRW_TMODE_TXT          2
+
+#define CH_BS                   0x08
+#define CH_DEL                  0x7f
+
+#define CH_CTRLX                0x18
+#define CH_CTRLC                0x03
+#define CH_CTRLV                0x16
+
+#define CHAR_VALID_INPUT(c)     ((c >= 0x20) && (c < 0x7f))
+
+int eve_strw_create(EVEStrWidget *widget, EVERect *g, EVEPage *page, EVEStrSpec *spec) {
+    EVEFont *font = spec->font ? spec->font : eve_window_font(page->v.window);
+    utf8_t *str;
+    uint16_t *line;
+
+    str = eve_malloc(spec->str_size);
+    if (str == NULL) return EVE_ERR_NOMEM;
+    str[0] = '\0';
+
+    eve_strw_init(widget, g, page, font, str, spec->str_size);
+
+    return EVE_OK;
+}
+
+void eve_strw_init(EVEStrWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, utf8_t *str, uint16_t str_size) {
+    EVEWidget *_widget = &widget->w;
+    int rv, str_len;
+
+    memset(widget, 0, sizeof(EVEStrWidget));
+    eve_widget_init(_widget, EVE_WIDGET_TYPE_STR, g, page, eve_strw_draw, eve_strw_touch, eve_strw_putc);
+    widget->font = font;
+    rv = utf8_verify(str, str_size, &str_len);
+    if (rv != UTF_OK) {
+        if (str_len >= str_size) str_len = 0;
+        str[str_len] = '\0';
+    }
+    widget->str = str;
+    widget->str_size = str_size;
+    widget->str_len = str_len;
+    widget->str_g.w = eve_font_str_w(widget->font, str);
+    if (_widget->g.h == 0) _widget->g.h = eve_font_h(widget->font);
+}
+
+int eve_strw_update(EVEStrWidget *widget) {
+    int rv, str_len;
+
+    rv = utf8_verify(widget->str, widget->str_size, &str_len);
+    if (rv != UTF_OK) {
+        if (str_len >= widget->str_size) str_len = 0;
+        widget->str[str_len] = '\0';
+    }
+    widget->str_len = str_len;
+    return (rv == UTF_OK) ? EVE_OK : EVE_ERR;
+}
+
+void eve_strw_destroy(EVEStrWidget *widget) {
+    eve_free(widget->str);
+}
+
+static void set_focus(EVEStrWidget *widget) {
+    EVEWidget *_widget = &widget->w;
+    EVERect focus;
+
+    focus.x = _widget->g.x;
+    focus.y = _widget->g.y;
+    focus.w = _widget->g.w;
+    focus.h = 2 * widget->font->h;
+    eve_widget_focus(_widget, &focus);
+}
+
+static EVEStrCursor *cursor_prox(EVEStrWidget *widget, EVEStrCursor *cursor, EVETouch *touch, short *dx) {
+    EVEWidget *_widget = &widget->w;
+    EVEPage *page = _widget->page;
+    int x = eve_page_x(page, touch->x0) - _widget->g.x + widget->str_g.x;
+    int _dx;
+
+    *dx = cursor->x - x;
+    _dx = *dx < 0 ? -(*dx) : *dx;
+
+    if (_dx <= widget->font->w) return cursor;
+    return NULL;
+}
+
+static void draw_string(EVEStrWidget *widget, uint16_t ch, uint16_t len, uint16_t x1, uint16_t x2, char s) {
+    int16_t x;
+    EVEWidget *_widget = &widget->w;
+    EVEPage *page = _widget->page;
+
+    x = _widget->g.x - widget->str_g.x;
+    if (x1 != x2) {
+        eve_cmd_dl(BEGIN(EVE_RECTS));
+        if (!s) eve_cmd_dl(COLOR_MASK(0 ,0 ,0 ,0));
+        eve_cmd_dl(VERTEX2F(x + x1, _widget->g.y));
+        eve_cmd_dl(VERTEX2F(x + x2, _widget->g.y + widget->font->h));
+        if (!s) {
+            eve_cmd_dl(COLOR_MASK(1 ,1 ,1 ,1));
+            eve_cmd_dl(BEGIN(EVE_LINES));
+            eve_cmd_dl(VERTEX2F(x + x1, _widget->g.y + widget->font->h));
+            eve_cmd_dl(VERTEX2F(x + x2, _widget->g.y + widget->font->h));
+        }
+        eve_cmd_dl(END());
+        if (len) {
+            if (s) eve_cmd_dl(COLOR_RGBC(page->v.color_bg));
+            eve_cmd(CMD_TEXT, "hhhhpb", x + x1, _widget->g.y, widget->font->id, 0, widget->str + ch, len, 0);
+            if (s) eve_cmd_dl(COLOR_RGBC(page->v.color_fg));
+        }
+    }
+}
+
+static void draw_cursor(EVEStrWidget *widget, EVEStrCursor *cursor) {
+    uint16_t x, y;
+    EVEWidget *_widget = &widget->w;
+
+    x = _widget->g.x - widget->str_g.x + cursor->x;
+    y = _widget->g.y;
+    eve_cmd_dl(BEGIN(EVE_LINES));
+    eve_cmd_dl(VERTEX2F(x, y));
+    eve_cmd_dl(VERTEX2F(x, y + widget->font->h));
+    eve_cmd_dl(END());
+}
+
+uint8_t eve_strw_draw(EVEWidget *_widget, uint8_t tag0) {
+    EVEStrWidget *widget = (EVEStrWidget *)_widget;
+    char cut = widget->str_g.x || (widget->str_g.w > _widget->g.w);
+
+    _widget->tag0 = tag0;
+    if (tag0 != EVE_NOTAG) {
+        eve_cmd_dl(TAG(tag0));
+        eve_touch_set_opt(tag0, STRW_TOUCH_OPT);
+        tag0++;
+    }
+    _widget->tagN = tag0;
+
+    if (cut) {
+        EVEPage *page = _widget->page;
+        EVEWindow *window = page->v.window;
+        int16_t x = eve_page_scr_x(page, _widget->g.x);
+        int16_t y = eve_page_scr_y(page, _widget->g.y);
+        uint16_t w = _widget->g.w;
+        uint16_t h = _widget->g.h;
+        int16_t win_x1 = window->g.x;
+        int16_t win_y1 = window->g.y;
+        int16_t win_x2 = win_x1 + window->g.w;
+        int16_t win_y2 = win_y1 + window->g.h;
+
+        if (win_x1 < 0) win_x1 = 0;
+        if (win_y1 < 0) win_y1 = 0;
+        if (win_x2 > window->root->w.g.w) win_x2 = window->root->w.g.w;
+        if (win_y2 > window->root->w.g.h) win_y2 = window->root->w.g.h;
+        if (x < win_x1) {
+            w += x - win_x1;
+            x = win_x1;
+        }
+        if (y < win_y1) {
+            h += y - win_y1;
+            y = win_y1;
+        }
+        if (x + w > win_x2) w = win_x2 - x;
+        if (y + h > win_y2) h = win_y2 - y;
+
+        eve_cmd_dl(SAVE_CONTEXT());
+        eve_cmd_dl(SCISSOR_XY(x, y));
+        eve_cmd_dl(SCISSOR_SIZE(w, h));
+    }
+
+    if (widget->cursor2.on) {
+        EVEStrCursor *c1, *c2;
+        int l1, l2, l3;
+
+        if (widget->cursor1.ch <= widget->cursor2.ch) {
+            c1 = &widget->cursor1;
+            c2 = &widget->cursor2;
+        } else {
+            c1 = &widget->cursor2;
+            c2 = &widget->cursor1;
+        }
+
+        l1 = c1->ch;
+        l2 = c2->ch - c1->ch;
+        l3 = widget->str_len - c2->ch;
+        draw_string(widget, 0, l1, 0, c1->x, 0);
+        draw_string(widget, c1->ch, l2, c1->x, c2->x, 1);
+        draw_string(widget, c2->ch, l3, c2->x, widget->str_g.x + _widget->g.w, 0);
+    } else {
+        if (widget->cursor1.on) draw_cursor(widget, &widget->cursor1);
+        draw_string(widget, 0, widget->str_len, 0, widget->str_g.x + _widget->g.w, 0);
+    }
+
+    if (cut) {
+        eve_cmd_dl(RESTORE_CONTEXT());
+    }
+
+    return _widget->tagN;
+}
+
+int eve_strw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt) {
+    EVEPage *page = _widget->page;
+    EVEStrWidget *widget = (EVEStrWidget *)_widget;
+    EVEStrCursor *t_cursor = NULL;
+    short dx;
+    int ret = 0;
+
+    if (evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TRACK_START)) {
+        if (widget->cursor2.on) {
+            t_cursor = cursor_prox(widget, &widget->cursor2, touch, &dx);
+        }
+        if ((t_cursor == NULL) && widget->cursor1.on) {
+            t_cursor = cursor_prox(widget, &widget->cursor1, touch, &dx);
+        }
+        if (evt & EVE_TOUCH_ETYPE_TRACK_START) {
+            if (t_cursor) {
+                widget->track.mode = STRW_TMODE_CRSR;
+                widget->track.cursor = t_cursor;
+                widget->track.dx = dx;
+            } else if (touch->eevt & EVE_TOUCH_EETYPE_TRACK_X) {
+                widget->track.mode = STRW_TMODE_TXT;
+            }
+        }
+    }
+
+    if (widget->track.mode) {
+        int x, w1;
+
+        if (evt & EVE_TOUCH_ETYPE_TRACK) {
+            switch (widget->track.mode) {
+                case STRW_TMODE_TXT:
+                    if (evt & EVE_TOUCH_ETYPE_TRACK_START) {
+                        widget->str_g.x0 = widget->str_g.x;
+                    }
+                    x = widget->str_g.x0 + touch->x0 - touch->x;
+                    w1 = _widget->g.w - widget->font->w;
+                    if (x > widget->str_g.w - w1) x = widget->str_g.w - w1;
+                    if (x < 0) x = 0;
+                    widget->str_g.x = x;
+                    break;
+
+                case STRW_TMODE_CRSR:
+                    eve_strw_cursor_set(widget, widget->track.cursor, eve_page_x(page, touch->x) + widget->track.dx);
+                    break;
+            }
+        }
+        ret = 1;
+    } else {
+        if (evt & EVE_TOUCH_ETYPE_LPRESS) {
+            if (widget->cursor2.on) {
+                // copy
+            } else if (widget->cursor1.on) {
+                if (t_cursor) {
+                    // paste
+                } else {
+                    eve_strw_cursor_set(widget, &widget->cursor2, eve_page_x(page, touch->x));
+                }
+            } else {
+                // select
+            }
+            ret = 1;
+        }
+        if ((evt & EVE_TOUCH_ETYPE_POINT_UP) && !(touch->eevt & (EVE_TOUCH_EETYPE_TRACK_XY | EVE_TOUCH_EETYPE_ABORT | EVE_TOUCH_EETYPE_LPRESS))) {
+            eve_strw_cursor_set(widget, &widget->cursor1, eve_page_x(page, touch->x0));
+            if (widget->cursor2.on) eve_strw_cursor_clear(widget, &widget->cursor2);
+            set_focus(widget);
+            ret = 1;
+        }
+    }
+
+    if (evt & EVE_TOUCH_ETYPE_TRACK_STOP) {
+        widget->track.mode = STRW_TMODE_NONE;
+        widget->track.cursor = NULL;
+        widget->track.dx = 0;
+    }
+
+    return ret;
+}
+
+void eve_strw_putc(void *w, int c) {
+    EVEStrWidget *widget = (EVEStrWidget *)w;
+    EVEWidget *_widget = &widget->w;
+    EVEStrCursor *cursor1 = &widget->cursor1;
+    EVEStrCursor *cursor2 = &widget->cursor2;
+    utf8_t *str;
+    utf8_t *clipb = NULL;
+    int w0 = widget->font->w;
+    int w1 = _widget->g.w - widget->font->w;
+    int ins_c = 0, del_c = 0;
+    int ins_w = 0, del_w = 0;
+
+
+    if (c == EVE_PAGE_KBDCH_CLOSE) {
+        if (cursor1->on) eve_strw_cursor_clear(widget, cursor1);
+        if (cursor2->on) eve_strw_cursor_clear(widget, cursor2);
+        return;
+    }
+
+    if (!cursor1->on) return;
+
+    if (!cursor2->on && ((c == CH_BS) || (c == CH_DEL))) {
+        utf32_t uc;
+
+        str = widget->str + cursor1->ch;
+        switch (c) {
+            case CH_BS:
+                if (cursor1->ch > 0) {
+                    del_c = -utf8_seek(str, -1, &uc);
+                    del_w = eve_font_ch_w(widget->font, uc);
+                    memmove(str - del_c, str, widget->str_len - cursor1->ch + 1);
+                    widget->str_len -= del_c;
+                    widget->str_g.w -= del_w;
+                    cursor1->ch -= del_c;
+                    cursor1->x -= del_w;
+                }
+                break;
+
+            case CH_DEL:
+                if (cursor1->ch < widget->str_len) {
+                    del_c = utf8_dec(str, &uc);
+                    del_w = eve_font_ch_w(widget->font, uc);
+                    memmove(str, str + del_c, widget->str_len - cursor1->ch - del_c + 1);
+                    widget->str_len -= del_c;
+                    widget->str_g.w -= del_w;
+                }
+                break;
+        }
+        if (widget->str_g.w - widget->str_g.x < w1) {
+            widget->str_g.x -= del_w;
+            if (widget->str_g.x < 0) widget->str_g.x = 0;
+        }
+    } else {
+        EVEStrCursor *c1 = cursor1;
+        EVEStrCursor *c2 = cursor1;
+        utf8_t utf8_buf[4];
+
+        if (cursor2->on) {
+            if (cursor1->ch <= cursor2->ch) {
+                c2 = cursor2;
+            } else {
+                c1 = cursor2;
+            }
+            del_c = c2->ch - c1->ch;
+            del_w = eve_font_buf_w(widget->font, str, del_c);
+            if ((c == CH_CTRLX) || (c == CH_CTRLC)) {
+                eve_clipb_push(str, del_c);
+                if (c == CH_CTRLC) return;
+            }
+        }
+
+        str = widget->str + c1->ch;
+        if (CHAR_VALID_INPUT(c)) {
+            ins_c = utf8_enc(c, utf8_buf);
+            ins_w = eve_font_ch_w(widget->font, c);
+        } else if (c == CH_CTRLV) {
+            int rv, clipb_len = 0;
+
+            clipb = eve_clipb_get();
+            if (clipb) {
+                rv = utf8_verify(clipb, EVE_CLIPB_SIZE_BUF, &clipb_len);
+                if (rv != UTF_OK) {
+                    clipb = NULL;
+                    clipb_len = 0;
+                }
+            }
+            ins_c = clipb_len;
+            ins_w = eve_font_str_w(widget->font, clipb);
+        }
+        if (widget->str_len + ins_c >= widget->str_size + del_c) {
+            ins_c = 0;
+            ins_w = 0;
+        }
+        if (ins_c != del_c) memmove(str + ins_c, str + del_c, widget->str_len - c2->ch + 1);
+        if (ins_c) {
+            if (c == CH_CTRLV) {
+                memcpy(str, clipb, ins_c);
+            } else if (ins_c > 1) {
+                memcpy(str, utf8_buf, ins_c);
+            } else {
+                *str = utf8_buf[0];
+            }
+            c1->ch += ins_c;
+            c1->x += ins_w;
+        }
+        widget->str_len += ins_c - del_c;
+        widget->str_g.w += ins_w - del_w;
+        if (c1 == cursor2) widget->cursor1 = widget->cursor2;
+        if (cursor2->on) eve_strw_cursor_clear(widget, cursor2);
+    }
+
+    if (cursor1->x - widget->str_g.x < w0) widget->str_g.x = cursor1->x > w0 ? cursor1->x - w0 : 0;
+    if (cursor1->x - widget->str_g.x > w1) widget->str_g.x = cursor1->x - w1;
+}
+
+void eve_strw_cursor_set(EVEStrWidget *widget, EVEStrCursor *cursor, int16_t x) {
+    int i;
+    int16_t _x, _d;
+    utf32_t ch;
+    uint8_t ch_w;
+    uint8_t ch_l;
+    EVEWidget *_widget = &widget->w;
+
+    x = x - _widget->g.x + widget->str_g.x;
+
+    _x = 0;
+    _d = x;
+    i = 0;
+    while (i < widget->str_len) {
+        ch_l = utf8_dec(widget->str + i, &ch);
+        ch_w = eve_font_ch_w(widget->font, ch);
+        _x += ch_w;
+        i += ch_l;
+        if (_x >= x) {
+            if (_x - x > _d) {
+                _x -= ch_w;
+                i -= ch_l;
+            }
+            break;
+        } else {
+            _d = x - _x;
+        }
+    }
+    cursor->x = _x;
+    cursor->ch = i;
+    cursor->on = 1;
+}
+
+void eve_strw_cursor_clear(EVEStrWidget *widget, EVEStrCursor *cursor) {
+    cursor->on = 0;
+}
diff --git a/fw/fe310/eos/eve/widget/strw.h b/fw/fe310/eos/eve/widget/strw.h
new file mode 100644
index 0000000..44e5e2d
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/strw.h
@@ -0,0 +1,43 @@
+#include <stdint.h>
+
+typedef struct EVEStrCursor {
+    char on;
+    uint16_t x;
+    uint16_t ch;
+} EVEStrCursor;
+
+typedef struct EVEStrWidget {
+    EVEWidget w;
+    EVEFont *font;
+    utf8_t *str;
+    uint16_t str_size;
+    uint16_t str_len;
+    struct {
+        int16_t x;
+        int16_t x0;
+        uint16_t w;
+    } str_g;
+    EVEStrCursor cursor1;
+    EVEStrCursor cursor2;
+    struct {
+        EVEStrCursor *cursor;
+        short dx;
+        char mode;
+    } track;
+} EVEStrWidget;
+
+typedef struct EVEStrSpec {
+    EVEFont *font;
+    uint16_t str_size;
+} EVEStrSpec;
+
+int eve_strw_create(EVEStrWidget *widget, EVERect *g, EVEPage *page, EVEStrSpec *spec);
+void eve_strw_init(EVEStrWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, utf8_t *str, uint16_t str_size);
+void eve_strw_destroy(EVEStrWidget *widget);
+int eve_strw_update(EVEStrWidget *widget);
+
+uint8_t eve_strw_draw(EVEWidget *_widget, uint8_t tag0);
+int eve_strw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt);
+void eve_strw_putc(void *_page, int c);
+void eve_strw_cursor_set(EVEStrWidget *widget, EVEStrCursor *cursor, int16_t x);
+void eve_strw_cursor_clear(EVEStrWidget *widget, EVEStrCursor *cursor);
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/widget/textw.c b/fw/fe310/eos/eve/widget/textw.c
new file mode 100644
index 0000000..e994c0e
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/textw.c
@@ -0,0 +1,545 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "clipb.h"
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "label.h"
+#include "widget.h"
+#include "textw.h"
+
+#define TEXTW_TOUCH_OPT         EVE_TOUCH_OPT_TRACK | EVE_TOUCH_OPT_TRACK_XY | EVE_TOUCH_OPT_TRACK_EXT_XY | EVE_TOUCH_OPT_LPRESS
+
+#define CH_BS                   0x08
+#define CH_DEL                  0x7f
+
+#define CH_CTRLX                0x18
+#define CH_CTRLC                0x03
+#define CH_CTRLV                0x16
+
+#define LINE_LEN(w,l)           ((l) ? (w->line[l] ? w->line[l] - w->line[(l) - 1] - 1 : 0) : w->line[l])
+#define LINE_START(w,l)         ((l) ? w->line[(l) - 1] + 1 : 0)
+#define LINE_END(w,l)           (w->line[l])
+#define LINE_EMPTY              0xffff
+
+#define CHAR_VALID_INPUT(c)     (((c >= 0x20) && (c < 0x7f)) || (c == '\n'))
+
+#define DIVC(x,y)               ((x) / (y) + ((x) % (y) != 0))
+
+int eve_textw_create(EVETextWidget *widget, EVERect *g, EVEPage *page, EVETextSpec *spec) {
+    EVEFont *font = spec->font ? spec->font : eve_window_font(page->v.window);
+    utf8_t *text;
+    uint16_t *line;
+
+    text = eve_malloc(spec->text_size);
+    if (text == NULL) {
+        return EVE_ERR_NOMEM;
+    }
+    text[0] = '\0';
+    line = eve_malloc(sizeof(uint16_t) * spec->line_size);
+    if (line == NULL) {
+        free(text);
+        return EVE_ERR_NOMEM;
+    }
+
+    eve_textw_init(widget, g, page, font, text, spec->text_size, line, spec->line_size);
+
+    return EVE_OK;
+}
+
+void eve_textw_init(EVETextWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, utf8_t *text, uint16_t text_size, uint16_t *line, uint16_t line_size) {
+    EVEWidget *_widget = &widget->w;
+    int rv, text_len;
+
+    memset(widget, 0, sizeof(EVETextWidget));
+    eve_widget_init(_widget, EVE_WIDGET_TYPE_TEXT, g, page, eve_textw_draw, eve_textw_touch, eve_textw_putc);
+    widget->font = font;
+    rv = utf8_verify(text, text_size, &text_len);
+    if (rv != UTF_OK) {
+        if (text_len >= text_size) text_len = 0;
+        text[text_len] = '\0';
+    }
+    widget->text = text;
+    widget->text_size = text_size;
+    widget->text_len = text_len;
+    widget->line = line;
+    widget->line_size = line_size;
+    memset(widget->line, 0xff, line_size * sizeof(uint16_t));
+    eve_textw_text_update(widget, 0, 0);
+}
+
+void eve_textw_destroy(EVETextWidget *widget) {
+    eve_free(widget->line);
+    eve_free(widget->text);
+}
+
+static void set_focus(EVETextWidget *widget, EVETextCursor *cursor) {
+    EVEWidget *_widget = &widget->w;
+    EVERect focus;
+
+    focus.x = _widget->g.x;
+    focus.y = _widget->g.y + cursor->line * widget->font->h;
+    focus.w = _widget->g.w;
+    focus.h = 2 * widget->font->h;
+    eve_widget_focus(_widget, &focus);
+}
+
+static EVETextCursor *cursor_prox(EVETextWidget *widget, EVETextCursor *cursor, EVETouch *touch, short *dx, short *dl) {
+    EVEWidget *_widget = &widget->w;
+    EVEPage *page = _widget->page;
+    int x = eve_page_x(page, touch->x0) - _widget->g.x;
+    int l = (int)touch->tag0 - _widget->tag0 + widget->line0;
+    int _dx, _dl;
+
+    *dx = cursor->x - x;
+    *dl = cursor->line - l;
+
+    _dx = *dx < 0 ? -(*dx) : *dx;
+    _dl = *dl < 0 ? -(*dl) : *dl;
+
+    if ((_dx <= widget->font->h) && (_dl <= 1)) return cursor;
+    return NULL;
+}
+
+static void draw_line(EVETextWidget *widget, uint16_t l, uint16_t ch, uint16_t len, uint16_t x1, uint16_t x2, char s) {
+    EVEWidget *_widget = &widget->w;
+    EVEPage *page = _widget->page;
+
+    if (x1 != x2) {
+        eve_cmd_dl(BEGIN(EVE_RECTS));
+        if (!s) eve_cmd_dl(COLOR_MASK(0 ,0 ,0 ,0));
+        eve_cmd_dl(VERTEX2F(_widget->g.x + x1, _widget->g.y + l * widget->font->h));
+        eve_cmd_dl(VERTEX2F(_widget->g.x + x2, _widget->g.y + (l + 1) * widget->font->h));
+        if (!s) {
+            eve_cmd_dl(COLOR_MASK(1 ,1 ,1 ,1));
+            eve_cmd_dl(BEGIN(EVE_LINES));
+            eve_cmd_dl(VERTEX2F(_widget->g.x + x1, _widget->g.y + (l + 1) * widget->font->h));
+            eve_cmd_dl(VERTEX2F(_widget->g.x + x2, _widget->g.y + (l + 1) * widget->font->h));
+        }
+        eve_cmd_dl(END());
+        if (len) {
+            if (s) eve_cmd_dl(COLOR_RGBC(page->v.color_bg));
+            eve_cmd(CMD_TEXT, "hhhhpb", _widget->g.x + x1, _widget->g.y + l * widget->font->h, widget->font->id, 0, widget->text + ch, len, 0);
+            if (s) eve_cmd_dl(COLOR_RGBC(page->v.color_fg));
+        }
+    }
+}
+
+static void draw_cursor(EVETextWidget *widget, EVETextCursor *cursor) {
+    uint16_t x, y;
+    EVEWidget *_widget = &widget->w;
+
+    x = _widget->g.x + cursor->x;
+    y = _widget->g.y + cursor->line * widget->font->h;
+    eve_cmd_dl(BEGIN(EVE_LINES));
+    eve_cmd_dl(VERTEX2F(x, y));
+    eve_cmd_dl(VERTEX2F(x, y + widget->font->h));
+    eve_cmd_dl(END());
+}
+
+uint8_t eve_textw_draw(EVEWidget *_widget, uint8_t tag0) {
+    EVEPage *page = _widget->page;
+    EVETextWidget *widget = (EVETextWidget *)_widget;
+    int line0, lineN;
+    int _line0, _lineN;
+    char lineNvisible;
+
+    _line0 = line0 = -((int)eve_page_win_y(page, _widget->g.y)) / widget->font->h;
+    _lineN = lineN = DIVC((-((int)eve_page_win_y(page, _widget->g.y)) + page->v.window->g.h), widget->font->h);
+    if (line0 < 0) line0 = 0;
+    if (lineN < 0) lineN = 0;
+    if (line0 > widget->line_len) line0 = widget->line_len;
+    if (lineN > widget->line_len) lineN = widget->line_len;
+    lineNvisible = (lineN >= _line0) && (lineN < _lineN);
+
+    if (lineNvisible || (line0 < lineN)) {
+        int i;
+        char s = 0;
+        EVETextCursor *c1, *c2;
+
+        widget->line0 = line0;
+        _widget->tag0 = tag0;
+        _widget->tagN = tag0;
+
+        if (widget->cursor2.on) {
+            if (widget->cursor1.ch <= widget->cursor2.ch) {
+                c1 = &widget->cursor1;
+                c2 = &widget->cursor2;
+            } else {
+                c1 = &widget->cursor2;
+                c2 = &widget->cursor1;
+            }
+        } else {
+            c1 = NULL;
+            c2 = NULL;
+        }
+
+        for (i=line0; i<lineN; i++) {
+            if (_widget->tagN != EVE_NOTAG) {
+                eve_cmd_dl(TAG(_widget->tagN));
+                eve_touch_set_opt(_widget->tagN, TEXTW_TOUCH_OPT);
+                _widget->tagN++;
+            }
+            if (!s && c1 && (c1->line == i)) {
+                int l1, l2, l3;
+
+                l1 = c1->ch - LINE_START(widget, i);
+                if (c2->line == i) {
+                    l2 = c2->ch - c1->ch;
+                    l3 = LINE_START(widget, i) + LINE_LEN(widget, i) - c2->ch;
+                } else {
+                    l2 = LINE_START(widget, i) + LINE_LEN(widget, i) - c1->ch;
+                    l3 = 0;
+                    s = 1;
+                }
+                draw_line(widget, i, LINE_START(widget, i), l1, 0, c1->x, 0);
+                draw_line(widget, i, c1->ch, l2, c1->x, s ? _widget->g.w : c2->x, 1);
+                if (!s) {
+                    draw_line(widget, i, c2->ch, l3, c2->x, _widget->g.w, 0);
+                    c1 = NULL;
+                    c2 = NULL;
+                }
+            } else if (s && (c2->line == i)) {
+                int l1 = c2->ch - LINE_START(widget, i);
+                int l2 = LINE_START(widget, i) + LINE_LEN(widget, i) - c2->ch;
+
+                draw_line(widget, i, LINE_START(widget, i), l1, 0, c2->x, 1);
+                draw_line(widget, i, c2->ch, l2, c2->x, _widget->g.w, 0);
+                c1 = NULL;
+                c2 = NULL;
+                s = 0;
+            } else {
+                if (widget->cursor1.on && (widget->cursor1.line == i)) draw_cursor(widget, &widget->cursor1);
+                draw_line(widget, i, LINE_START(widget, i), LINE_LEN(widget, i), 0, _widget->g.w, s);
+            }
+        }
+        if (lineNvisible) {
+            if (_widget->tagN != EVE_NOTAG) {
+                eve_cmd_dl(TAG(_widget->tagN));
+                eve_touch_set_opt(_widget->tagN, TEXTW_TOUCH_OPT);
+                _widget->tagN++;
+            }
+            draw_line(widget, lineN, 0, 0, 0, _widget->g.w, 0);
+        }
+    } else {
+        widget->line0 = 0;
+        _widget->tag0 = EVE_NOTAG;
+        _widget->tagN = EVE_NOTAG;
+    }
+
+    return _widget->tagN;
+}
+
+int eve_textw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt) {
+    EVEPage *page = _widget->page;
+    EVETextWidget *widget = (EVETextWidget *)_widget;
+    EVETextCursor *t_cursor = NULL;
+    short dx, dl;
+    int ret = 0;
+
+    if (evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TRACK_START)) {
+        if (widget->cursor2.on) {
+            t_cursor = cursor_prox(widget, &widget->cursor2, touch, &dx, &dl);
+        }
+        if ((t_cursor == NULL) && widget->cursor1.on) {
+            t_cursor = cursor_prox(widget, &widget->cursor1, touch, &dx, &dl);
+        }
+        if (t_cursor && (evt & EVE_TOUCH_ETYPE_TRACK_START)) {
+            widget->track.cursor = t_cursor;
+            widget->track.dx = dx;
+            widget->track.dl = dl;
+        }
+    }
+
+    if (widget->track.cursor) {
+        if (evt & EVE_TOUCH_ETYPE_TRACK) eve_textw_cursor_set(widget, widget->track.cursor, touch->tag + widget->track.dl, eve_page_x(page, touch->x) + widget->track.dx);
+        ret = 1;
+    } else {
+        if (evt & EVE_TOUCH_ETYPE_LPRESS) {
+            if (widget->cursor2.on) {
+                // copy
+            } else if (widget->cursor1.on) {
+                if (t_cursor && (dl == 0)) {
+                    // paste
+                } else {
+                    eve_textw_cursor_set(widget, &widget->cursor2, touch->tag, eve_page_x(page, touch->x));
+                }
+            } else {
+                // select
+            }
+            ret = 1;
+        }
+        if ((evt & EVE_TOUCH_ETYPE_POINT_UP) && !(touch->eevt & (EVE_TOUCH_EETYPE_TRACK_XY | EVE_TOUCH_EETYPE_ABORT | EVE_TOUCH_EETYPE_LPRESS))) {
+            eve_textw_cursor_set(widget, &widget->cursor1, touch->tag_up, eve_page_x(page, touch->x0));
+            if (widget->cursor2.on) eve_textw_cursor_clear(widget, &widget->cursor2);
+            set_focus(widget, &widget->cursor1);
+            ret = 1;
+        }
+    }
+
+    if (evt & EVE_TOUCH_ETYPE_TRACK_STOP) {
+        widget->track.cursor = NULL;
+        widget->track.dx = 0;
+        widget->track.dl = 0;
+    }
+
+    return ret;
+}
+
+void eve_textw_putc(void *w, int c) {
+    EVETextWidget *widget = (EVETextWidget *)w;
+    EVEWidget *_widget = &widget->w;
+    EVETextCursor *cursor1 = &widget->cursor1;
+    EVETextCursor *cursor2 = &widget->cursor2;
+    utf8_t *text;
+    utf8_t *clipb = NULL;
+    int i, r;
+    int ins_c = 0, del_c = 0;
+    int ch_w = 0;
+
+    if (c == EVE_PAGE_KBDCH_CLOSE) {
+        if (cursor1->on) eve_textw_cursor_clear(widget, cursor1);
+        if (cursor2->on) eve_textw_cursor_clear(widget, cursor2);
+        return;
+    }
+
+    if (!cursor1->on) return;
+
+    if (!cursor2->on && ((c == CH_BS) || (c == CH_DEL))) {
+        utf32_t uc;
+
+        text = widget->text + cursor1->ch;
+        switch (c) {
+            case CH_BS:
+                if (cursor1->ch > 0) {
+                    del_c = -utf8_seek(text, -1, &uc);
+                    ch_w = eve_font_ch_w(widget->font, uc);
+                    memmove(text - del_c, text, widget->text_len - cursor1->ch + 1);
+                    cursor1->ch -= del_c;
+                }
+                break;
+
+            case CH_DEL:
+                if (cursor1->ch < widget->text_len) {
+                    del_c = utf8_dec(text, &uc);
+                    ch_w = eve_font_ch_w(widget->font, uc);
+                    memmove(text, text + del_c, widget->text_len - cursor1->ch - del_c + 1);
+                }
+                break;
+        }
+    } else {
+        EVETextCursor *c1 = cursor1;
+        EVETextCursor *c2 = cursor1;
+        utf8_t utf8_buf[4];
+
+        if (cursor2->on) {
+            if (cursor1->ch <= cursor2->ch) {
+                c2 = cursor2;
+            } else {
+                c1 = cursor2;
+            }
+            del_c = c2->ch - c1->ch;
+            if ((c == CH_CTRLX) || (c == CH_CTRLC)) {
+                eve_clipb_push(text, del_c);
+                if (c == CH_CTRLC) return;
+            }
+        }
+
+        text = widget->text + c1->ch;
+        if (CHAR_VALID_INPUT(c)) {
+            ins_c = utf8_enc(c, utf8_buf);
+            ch_w = eve_font_ch_w(widget->font, c);
+        } else if (c == CH_CTRLV) {
+            int rv, clipb_len = 0;
+
+            clipb = eve_clipb_get();
+            if (clipb) {
+                rv = utf8_verify(clipb, EVE_CLIPB_SIZE_BUF, &clipb_len);
+                if (rv != UTF_OK) {
+                    clipb = NULL;
+                    clipb_len = 0;
+                }
+            }
+            ins_c = clipb_len;
+            ch_w = eve_font_str_w(widget->font, clipb);
+        }
+        if (widget->text_len + ins_c >= widget->text_size + del_c) {
+            ins_c = 0;
+            ch_w = 0;
+        }
+        if (ins_c != del_c) memmove(text + ins_c, text + del_c, widget->text_len - c2->ch + 1);
+        if (ins_c) {
+            if (c == CH_CTRLV) {
+                memcpy(text, clipb, ins_c);
+            } else if (ins_c > 1) {
+                memcpy(text, utf8_buf, ins_c);
+            } else {
+                *text = utf8_buf[0];
+            }
+            c1->ch += ins_c;
+        }
+        if (c1 == cursor2) widget->cursor1 = widget->cursor2;
+        if (cursor2->on) eve_textw_cursor_clear(widget, cursor2);
+    }
+
+    if ((ins_c == 0) && (del_c == 0)) return;
+
+    widget->text_len += ins_c - del_c;
+    for (i=cursor1->line; i<widget->line_len; i++) {
+        widget->line[i] += ins_c - del_c;
+    }
+
+    r = cursor1->line;
+    if (cursor1->line) r = eve_textw_text_update(widget, cursor1->line - 1, 1);
+    if ((cursor1->line == 0) || (r == cursor1->line - 1)) r = eve_textw_text_update(widget, cursor1->line, 1);
+
+    if (cursor1->line && (cursor1->ch < LINE_START(widget, cursor1->line))) {
+        cursor1->line--;
+        eve_textw_cursor_update(widget, cursor1);
+        set_focus(widget, cursor1);
+    } else if (cursor1->ch > LINE_END(widget, cursor1->line)) {
+        while (cursor1->ch > LINE_END(widget, cursor1->line)) cursor1->line++;
+        eve_textw_cursor_update(widget, cursor1);
+        set_focus(widget, cursor1);
+    } else {
+        cursor1->x += ch_w;
+    }
+}
+
+uint16_t eve_textw_text_update(EVETextWidget *widget, uint16_t line, int uievt) {
+    int i;
+    utf32_t ch;
+    uint8_t ch_w;
+    uint8_t ch_l;
+    uint16_t word_w, line_w, line_b;
+    uint16_t new_h;
+    EVEWidget *_widget = &widget->w;
+    EVEPage *page = _widget->page;
+
+    word_w = 0;
+    line_w = 0;
+    line_b = LINE_EMPTY;
+
+    i = LINE_START(widget, line);
+    while (i < widget->text_size) {
+        ch_l = utf8_dec(widget->text + i, &ch);
+        if (!CHAR_VALID_INPUT(ch) && ch) {
+            ch = 0;
+            widget->text[i] = '\0';
+            widget->text_len = i;
+            widget->line[line] = LINE_EMPTY;
+        }
+
+        ch_w = eve_font_ch_w(widget->font, ch);
+        if (ch <= 0x20) {
+            if ((ch == '\n') || (ch == '\0')) {
+                if (widget->line[line] == i) return line;
+                widget->line[line] = i;
+                line++;
+                if ((ch == '\0') || (line == widget->line_size)) break;
+                word_w = 0;
+                line_w = 0;
+                line_b = LINE_EMPTY;
+            } else if (ch == ' ') {
+                word_w = 0;
+                line_w += ch_w;
+                line_b = i;
+            }
+        } else {
+            word_w += ch_w;
+            line_w += ch_w;
+        }
+        if ((line_w > _widget->g.w) && (line_b != LINE_EMPTY)) {
+            if (widget->line[line] == line_b) return line;
+            widget->line[line] = line_b;
+            line++;
+            if (line == widget->line_size) {
+                i = line_b;
+                break;
+            }
+            line_w = word_w;
+            line_b = LINE_EMPTY;
+        }
+        i += ch_l;
+    }
+
+    for (i=line; i<widget->line_size; i++) {
+        widget->line[i] = LINE_EMPTY;
+    }
+
+    if (uievt && (widget->line_len != line)) {
+        eve_view_uievt_push(&page->v, EVE_UIEVT_WIDGET_UPDATE_G, _widget);
+    }
+    widget->line_len = line;
+    _widget->g.h = (widget->line_len + 1) * widget->font->h;
+
+    return line;
+}
+
+void eve_textw_cursor_update(EVETextWidget *widget, EVETextCursor *cursor) {
+    int i = LINE_START(widget, cursor->line);
+    uint16_t x = 0;
+    utf32_t ch;
+    uint8_t ch_l;
+    EVEWidget *_widget = &widget->w;
+
+    while ((i < cursor->ch) && (i < LINE_END(widget, cursor->line))) {
+        ch_l = utf8_dec(widget->text + i, &ch);
+        x += eve_font_ch_w(widget->font, ch);
+        i += ch_l;
+    }
+    cursor->x = x;
+}
+
+void eve_textw_cursor_set(EVETextWidget *widget, EVETextCursor *cursor, uint8_t tag, int16_t x) {
+    int i;
+    int16_t _x, _d;
+    uint16_t c_line = LINE_EMPTY;
+    utf32_t ch;
+    uint8_t ch_w;
+    uint8_t ch_l;
+    EVEWidget *_widget = &widget->w;
+
+    if ((tag >= _widget->tag0) && ((_widget->tagN == EVE_NOTAG) || (tag < _widget->tagN))) c_line = tag - _widget->tag0 + widget->line0;
+    if (c_line < widget->line_len) {
+        cursor->line = c_line;
+    } else if (c_line == widget->line_len) {
+        cursor->line = c_line - 1;
+    } else if (!cursor->on) {
+        return;
+    }
+
+    x -= _widget->g.x;
+
+    _x = 0;
+    _d = x;
+    i = LINE_START(widget, cursor->line);
+    while (i < LINE_END(widget, cursor->line)) {
+        ch_l = utf8_dec(widget->text + i, &ch);
+        ch_w = eve_font_ch_w(widget->font, ch);
+        _x += ch_w;
+        i += ch_l;
+        if (_x >= x) {
+            if (_x - x > _d) {
+                _x -= ch_w;
+                i -= ch_l;
+            }
+            break;
+        } else {
+            _d = x - _x;
+        }
+    }
+    cursor->x = _x;
+    cursor->ch = i;
+    cursor->on = 1;
+}
+
+void eve_textw_cursor_clear(EVETextWidget *widget, EVETextCursor *cursor) {
+    cursor->on = 0;
+}
diff --git a/fw/fe310/eos/eve/widget/textw.h b/fw/fe310/eos/eve/widget/textw.h
new file mode 100644
index 0000000..570bba8
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/textw.h
@@ -0,0 +1,46 @@
+#include <stdint.h>
+
+typedef struct EVETextCursor {
+    char on;
+    uint16_t x;
+    uint16_t line;
+    uint16_t ch;
+} EVETextCursor;
+
+typedef struct EVETextWidget {
+    EVEWidget w;
+    EVEFont *font;
+    utf8_t *text;
+    uint16_t text_size;
+    uint16_t text_len;
+    uint16_t *line;
+    uint16_t line_size;
+    uint16_t line_len;
+    EVETextCursor cursor1;
+    EVETextCursor cursor2;
+    uint16_t line0;
+    struct {
+        EVETextCursor *cursor;
+        short dx;
+        short dl;
+    } track;
+} EVETextWidget;
+
+typedef struct EVETextSpec {
+    EVEFont *font;
+    uint16_t text_size;
+    uint16_t line_size;
+} EVETextSpec;
+
+int eve_textw_create(EVETextWidget *widget, EVERect *g, EVEPage *page, EVETextSpec *spec);
+void eve_textw_init(EVETextWidget *widget, EVERect *g, EVEPage *page, EVEFont *font, utf8_t *text, uint16_t text_size, uint16_t *line, uint16_t line_size);
+void eve_textw_destroy(EVETextWidget *widget);
+
+uint8_t eve_textw_draw(EVEWidget *_widget, uint8_t tag0);
+int eve_textw_touch(EVEWidget *_widget, EVETouch *touch, uint16_t evt);
+void eve_textw_putc(void *_w, int c);
+
+uint16_t eve_textw_text_update(EVETextWidget *widget, uint16_t line, int uievt);
+void eve_textw_cursor_update(EVETextWidget *widget, EVETextCursor *cursor);
+void eve_textw_cursor_set(EVETextWidget *widget, EVETextCursor *cursor, uint8_t tag, int16_t x);
+void eve_textw_cursor_clear(EVETextWidget *widget, EVETextCursor *cursor);
diff --git a/fw/fe310/eos/eve/widget/widget.c b/fw/fe310/eos/eve/widget/widget.c
new file mode 100644
index 0000000..96d2ddf
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/widget.c
@@ -0,0 +1,77 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "eve.h"
+#include "eve_kbd.h"
+#include "eve_font.h"
+
+#include "screen/window.h"
+#include "screen/page.h"
+
+#include "widgets.h"
+
+static const size_t _widget_size[] = {
+    0,
+    sizeof(EVEFreeWidget),
+    sizeof(EVESpacerWidget),
+    sizeof(EVEPageWidget),
+    sizeof(EVEStrWidget),
+    sizeof(EVETextWidget),
+    sizeof(EVESelectWidget),
+};
+
+static const eve_widget_create_t _widget_create[] = {
+    NULL,
+    (eve_widget_create_t)eve_freew_create,
+    (eve_widget_create_t)eve_spacerw_create,
+    (eve_widget_create_t)eve_pagew_create,
+    (eve_widget_create_t)eve_strw_create,
+    (eve_widget_create_t)eve_textw_create,
+    (eve_widget_create_t)eve_selectw_create,
+};
+
+static const eve_widget_destroy_t _widget_destroy[] = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (eve_widget_destroy_t)eve_strw_destroy,
+    (eve_widget_destroy_t)eve_textw_destroy,
+    (eve_widget_destroy_t)eve_selectw_destroy,
+};
+
+void eve_widget_init(EVEWidget *widget, uint8_t type, EVERect *g, EVEPage *page, eve_widget_draw_t draw, eve_widget_touch_t touch, eve_kbd_input_handler_t putc) {
+    if (g) widget->g = *g;
+    widget->page = page;
+    widget->draw = draw;
+    widget->touch = touch;
+    widget->putc = putc;
+    widget->type = type;
+}
+
+size_t eve_widget_size(uint8_t type) {
+    return _widget_size[type];
+}
+
+void eve_widget_set_label(EVEWidget *widget, EVELabel *label) {
+    widget->label = label;
+}
+
+EVEWidget *eve_widget_next(EVEWidget *widget) {
+    char *_w = (char *)widget;
+    return (EVEWidget *)(_w + _widget_size[widget->type]);
+}
+
+int eve_widget_create(EVEWidget *widget, uint8_t type, EVERect *g, EVEPage *page, EVEWidgetSpecT *spec) {
+    return _widget_create[type](widget, g, page, spec);
+}
+
+void eve_widget_destroy(EVEWidget *widget) {
+    if (_widget_destroy[widget->type]) _widget_destroy[widget->type](widget);
+}
+
+void eve_widget_focus(EVEWidget *widget, EVERect *rect) {
+    EVEPage *page = widget->page;
+
+    eve_page_focus_widget(page, widget, rect);
+}
diff --git a/fw/fe310/eos/eve/widget/widget.h b/fw/fe310/eos/eve/widget/widget.h
new file mode 100644
index 0000000..f081b4c
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/widget.h
@@ -0,0 +1,31 @@
+#include <stdint.h>
+
+#define EVE_WIDGET_TYPE_FREE    1
+#define EVE_WIDGET_TYPE_SPACER  2
+#define EVE_WIDGET_TYPE_PAGE    3
+#define EVE_WIDGET_TYPE_STR     4
+#define EVE_WIDGET_TYPE_TEXT    5
+#define EVE_WIDGET_TYPE_SELECT  6
+
+struct EVEWidget;
+
+typedef uint8_t (*eve_widget_draw_t) (struct EVEWidget *, uint8_t);
+typedef int (*eve_widget_touch_t) (struct EVEWidget *, EVETouch *, uint16_t);
+
+typedef struct EVEWidget {
+    EVERect g;
+    EVEPage *page;
+    eve_widget_draw_t draw;
+    eve_widget_touch_t touch;
+    eve_kbd_input_handler_t putc;
+    EVELabel *label;
+    uint8_t type;
+    uint8_t tag0;
+    uint8_t tagN;
+} EVEWidget;
+
+void eve_widget_init(EVEWidget *widget, uint8_t type, EVERect *g, EVEPage *page, eve_widget_draw_t draw, eve_widget_touch_t touch, eve_kbd_input_handler_t putc);
+size_t eve_widget_size(uint8_t type);
+void eve_widget_set_label(EVEWidget *widget, EVELabel *label);
+EVEWidget *eve_widget_next(EVEWidget *widget);
+void eve_widget_focus(EVEWidget *widget, EVERect *rect);
\ No newline at end of file
diff --git a/fw/fe310/eos/eve/widget/widgets.h b/fw/fe310/eos/eve/widget/widgets.h
new file mode 100644
index 0000000..2f8d3ca
--- /dev/null
+++ b/fw/fe310/eos/eve/widget/widgets.h
@@ -0,0 +1,39 @@
+#include "label.h"
+#include "widget.h"
+
+#include "freew.h"
+#include "spacerw.h"
+#include "pagew.h"
+#include "strw.h"
+#include "textw.h"
+#include "selectw.h"
+
+typedef union EVEWidgetSpecT {
+    EVEFreeSpec free;
+    EVESpacerSpec spacer;
+    EVEPageSpec page;
+    EVEStrSpec str;
+    EVETextSpec text;
+    EVESelectSpec select;
+} EVEWidgetSpecT;
+
+typedef struct EVELabelSpec {
+    EVERect g;
+    EVEFont *font;
+    char *title;
+} APPLabelSpec;
+
+typedef struct EVEWidgetSpec {
+    APPLabelSpec label;
+    struct {
+        EVERect g;
+        EVEWidgetSpecT spec;
+        uint8_t type;
+    } widget;
+} EVEWidgetSpec;
+
+typedef int (*eve_widget_create_t) (EVEWidget *, EVERect *, EVEPage *, EVEWidgetSpecT *);
+typedef void (*eve_widget_destroy_t) (EVEWidget *);
+
+int eve_widget_create(EVEWidget *widget, uint8_t type, EVERect *g, EVEPage *page, EVEWidgetSpecT *spec);
+void eve_widget_destroy(EVEWidget *widget);
diff --git a/fw/fe310/eos/event.c b/fw/fe310/eos/event.c
new file mode 100644
index 0000000..e0a185f
--- /dev/null
+++ b/fw/fe310/eos/event.c
@@ -0,0 +1,155 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "msgq.h"
+#include "event.h"
+
+EOSMsgQ _eos_event_q;
+static EOSMsgItem event_q_array[EOS_EVT_SIZE_Q];
+
+static eos_evt_handler_t evt_handler[EOS_EVT_MAX_EVT + 1];
+
+static void evtq_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char idx = (type & EOS_EVT_MASK) >> 4;
+
+    if (idx && (idx <= EOS_EVT_MAX_EVT)) {
+        evt_handler[idx](type, buffer, len);
+    } else {
+        eos_evtq_bad_handler(type, buffer, len);
+    }
+}
+
+void eos_evtq_init(void) {
+    int i;
+
+    evt_handler[0] = evtq_handler;
+    for (i=0; i<EOS_EVT_MAX_EVT; i++) {
+        evt_handler[i + 1] = eos_evtq_bad_handler;
+    }
+    eos_msgq_init(&_eos_event_q, event_q_array, EOS_EVT_SIZE_Q);
+}
+
+int eos_evtq_push(unsigned char type, unsigned char *buffer, uint16_t len) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    int ret = eos_msgq_push(&_eos_event_q, type, buffer, len);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+int eos_evtq_push_isr(unsigned char type, unsigned char *buffer, uint16_t len) {
+    return eos_msgq_push(&_eos_event_q, type, buffer, len);
+}
+
+void eos_evtq_pop(unsigned char *type, unsigned char **buffer, uint16_t *len) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    eos_msgq_pop(&_eos_event_q, type, buffer, len);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_evtq_pop_isr(unsigned char *type, unsigned char **buffer, uint16_t *len) {
+    eos_msgq_pop(&_eos_event_q, type, buffer, len);
+}
+
+int eos_evtq_get(unsigned char type, unsigned char **buffer, uint16_t *len) {
+    int rv = 0;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    rv = eos_msgq_find(&_eos_event_q, type, NULL, 0, buffer, len);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+int eos_evtq_find(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
+    int rv = 0;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    rv = eos_msgq_find(&_eos_event_q, type, selector, sel_len, buffer, len);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_evtq_wait(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
+    int rv = 0;
+
+    while(!rv) {
+        clear_csr(mstatus, MSTATUS_MIE);
+        rv = eos_msgq_find(&_eos_event_q, type, selector, sel_len, buffer, len);
+        if (!rv) {
+            unsigned char _type;
+            unsigned char *_buffer;
+            uint16_t _len;
+
+            eos_msgq_pop(&_eos_event_q, &_type, &_buffer, &_len);
+            if (_type) {
+                set_csr(mstatus, MSTATUS_MIE);
+                evt_handler[0](_type, _buffer, _len);
+            } else {
+                asm volatile ("wfi");
+                set_csr(mstatus, MSTATUS_MIE);
+            }
+        } else {
+            set_csr(mstatus, MSTATUS_MIE);
+        }
+    }
+}
+
+void eos_evtq_flush(void) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    eos_evtq_flush_isr();
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_evtq_flush_isr(void) {
+    unsigned char type;
+    unsigned char *buffer;
+    uint16_t len;
+
+    do {
+        eos_msgq_pop(&_eos_event_q, &type, &buffer, &len);
+        if (type) {
+            set_csr(mstatus, MSTATUS_MIE);
+            evt_handler[0](type, buffer, len);
+            clear_csr(mstatus, MSTATUS_MIE);
+        }
+    } while (type);
+}
+
+void eos_evtq_loop(void) {
+    unsigned char type;
+    unsigned char *buffer;
+    uint16_t len;
+    int foo = 1;
+
+    while(foo) {
+        clear_csr(mstatus, MSTATUS_MIE);
+        eos_msgq_pop(&_eos_event_q, &type, &buffer, &len);
+        if (type) {
+            set_csr(mstatus, MSTATUS_MIE);
+            evt_handler[0](type, buffer, len);
+        } else {
+            asm volatile ("wfi");
+            set_csr(mstatus, MSTATUS_MIE);
+        }
+    }
+}
+
+void eos_evtq_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
+    printf("evt bad handler:0x%x\n", type);
+}
+
+void eos_evtq_set_handler(unsigned char type, eos_evt_handler_t handler) {
+    unsigned char idx = (type & EOS_EVT_MASK) >> 4;
+
+    if (handler == NULL) handler = eos_evtq_bad_handler;
+    if (idx <= EOS_EVT_MAX_EVT) evt_handler[idx] = handler;
+}
+
+eos_evt_handler_t eos_evtq_get_handler(unsigned char type) {
+    unsigned char idx = (type & EOS_EVT_MASK) >> 4;
+
+    if (idx <= EOS_EVT_MAX_EVT) return evt_handler[idx];
+    return NULL;
+}
diff --git a/fw/fe310/eos/event.h b/fw/fe310/eos/event.h
new file mode 100644
index 0000000..c9edd03
--- /dev/null
+++ b/fw/fe310/eos/event.h
@@ -0,0 +1,21 @@
+#include <stdint.h>
+
+#include "evt_def.h"
+
+typedef void (*eos_evt_handler_t) (unsigned char, unsigned char *, uint16_t);
+
+void eos_evtq_init(void);
+int eos_evtq_push(unsigned char type, unsigned char *buffer, uint16_t len);
+int eos_evtq_push_isr(unsigned char type, unsigned char *buffer, uint16_t len);
+void eos_evtq_pop(unsigned char *type, unsigned char **buffer, uint16_t *len);
+void eos_evtq_pop_isr(unsigned char *type, unsigned char **buffer, uint16_t *len);
+int eos_evtq_get(unsigned char type, unsigned char **buffer, uint16_t *len);
+int eos_evtq_find(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len);
+void eos_evtq_wait(unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len);
+void eos_evtq_flush(void);
+void eos_evtq_flush_isr(void);
+void eos_evtq_loop(void);
+
+void eos_evtq_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len);
+void eos_evtq_set_handler(unsigned char type, eos_evt_handler_t handler);
+eos_evt_handler_t eos_evtq_get_handler(unsigned char type);
diff --git a/fw/fe310/eos/evt_def.h b/fw/fe310/eos/evt_def.h
new file mode 100644
index 0000000..16c4255
--- /dev/null
+++ b/fw/fe310/eos/evt_def.h
@@ -0,0 +1,12 @@
+#define EOS_EVT_TIMER               0x10
+#define EOS_EVT_I2S                 0x20
+#define EOS_EVT_NET                 0x30
+#define EOS_EVT_SPI                 0x40
+#define EOS_EVT_UART                0x50
+#define EOS_EVT_UI                  0x60
+#define EOS_EVT_USER                0x80
+
+#define EOS_EVT_MAX_EVT             8
+#define EOS_EVT_MASK                0xF0
+
+#define EOS_EVT_SIZE_Q              4
diff --git a/fw/fe310/eos/i2c.c b/fw/fe310/eos/i2c.c
new file mode 100644
index 0000000..122a1b2
--- /dev/null
+++ b/fw/fe310/eos/i2c.c
@@ -0,0 +1,99 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+#include "prci_driver.h"
+
+#include "eos.h"
+#include "i2c.h"
+
+void eos_i2c_start(uint32_t baud_rate) {
+    eos_i2c_set_baud_rate(baud_rate);
+    GPIO_REG(GPIO_IOF_SEL)      &= ~IOF0_I2C0_MASK;
+    GPIO_REG(GPIO_IOF_EN)       |=  IOF0_I2C0_MASK;
+}
+
+void eos_i2c_stop(void) {
+    GPIO_REG(GPIO_IOF_EN)       &=  ~IOF0_I2C0_MASK;
+}
+
+void eos_i2c_set_baud_rate(uint32_t baud_rate) {
+    unsigned long clock_rate = PRCI_get_cpu_freq();
+    uint16_t prescaler = (clock_rate / (baud_rate * 5)) - 1;
+
+    I2C0_REGB(I2C_CONTROL) &= ~I2C_CONTROL_EN;
+    I2C0_REGB(I2C_PRESCALE_LOW) = prescaler & 0xFF;
+    I2C0_REGB(I2C_PRESCALE_HIGH) = (prescaler >> 8) & 0xFF;
+    I2C0_REGB(I2C_CONTROL) |= I2C_CONTROL_EN;
+}
+
+
+static int i2c_read(uint8_t cmd) {
+    I2C0_REGB(I2C_COMMAND) = I2C_CMD_READ | cmd;
+    while (I2C0_REGB(I2C_STATUS) & I2C_STATUS_TIP);
+
+    return I2C0_REGB(I2C_RECEIVE);
+}
+
+static int i2c_write(uint8_t cmd, uint8_t b) {
+    I2C0_REGB(I2C_TRANSMIT) = b;
+    I2C0_REGB(I2C_COMMAND) = I2C_CMD_WRITE | cmd;
+    while (I2C0_REGB(I2C_STATUS) & I2C_STATUS_TIP);
+
+    if (I2C0_REGB(I2C_STATUS) & I2C_STATUS_RXACK) return EOS_ERR;
+    return EOS_OK;
+}
+
+static int i2c_addr(uint8_t addr, uint8_t rw_flag) {
+    return i2c_write(I2C_CMD_START, ((addr & 0x7F) << 1) | (rw_flag & 0x1));
+}
+
+int eos_i2c_read(uint8_t addr, uint8_t reg, uint8_t *buffer, uint16_t len) {
+    int rv;
+    int i;
+
+    rv = i2c_addr(addr, I2C_WRITE);
+    if (rv) return rv;
+
+    rv = i2c_write(0, reg);
+    if (rv) return rv;
+
+    rv = i2c_addr(addr, I2C_READ);
+    if (rv) return rv;
+
+    for (i=0; i<len; i++) {
+        rv = i2c_read(i == (len - 1) ? (I2C_CMD_ACK | I2C_CMD_STOP) : 0);  /* Set NACK to end read, and generate STOP condition */
+        if (rv < 0) return rv;
+
+        buffer[i] = (uint8_t)rv;
+    }
+
+    return EOS_OK;
+}
+
+int eos_i2c_write(uint8_t addr, uint8_t reg, uint8_t *buffer, uint16_t len) {
+    int rv;
+    int i;
+
+    rv = i2c_addr(addr, I2C_WRITE);
+    if (rv) return rv;
+
+    rv = i2c_write(0, reg);
+    if (rv) return rv;
+
+    for (i=0; i<len; i++) {
+        rv = i2c_write(i == (len - 1) ? I2C_CMD_STOP : 0, buffer[i]);
+        if (rv) return rv;
+    }
+
+    return EOS_OK;
+}
+
+int eos_i2c_read8(uint8_t addr, uint8_t reg, uint8_t *data) {
+    return eos_i2c_read(addr, reg, data, 1);
+}
+
+int eos_i2c_write8(uint8_t addr, uint8_t reg, uint8_t data) {
+    return eos_i2c_write(addr, reg, &data, 1);
+}
diff --git a/fw/fe310/eos/i2c.h b/fw/fe310/eos/i2c.h
new file mode 100644
index 0000000..9692ea0
--- /dev/null
+++ b/fw/fe310/eos/i2c.h
@@ -0,0 +1,9 @@
+#include <stdint.h>
+
+void eos_i2c_start(uint32_t baud_rate);
+void eos_i2c_stop(void);
+void eos_i2c_set_baud_rate(uint32_t baud_rate);
+int eos_i2c_read(uint8_t addr, uint8_t reg, uint8_t *buffer, uint16_t len);
+int eos_i2c_write(uint8_t addr, uint8_t reg, uint8_t *buffer, uint16_t len);
+int eos_i2c_read8(uint8_t addr, uint8_t reg, uint8_t *data);
+int eos_i2c_write8(uint8_t addr, uint8_t reg, uint8_t data);
diff --git a/fw/fe310/eos/i2c/Makefile b/fw/fe310/eos/i2c/Makefile
new file mode 100644
index 0000000..a210898
--- /dev/null
+++ b/fw/fe310/eos/i2c/Makefile
@@ -0,0 +1,17 @@
+include ../../common.mk
+
+CFLAGS += -I..
+
+obj = bq25895.o ov2640.o
+
+
+%.o: %.c %.h
+	$(CC) $(CFLAGS) -c $<
+
+%.o: %.S
+	$(CC) $(CFLAGS) -c $<
+
+all: $(obj)
+
+clean:
+	rm -f *.o
diff --git a/fw/fe310/eos/i2c/bq25895.c b/fw/fe310/eos/i2c/bq25895.c
new file mode 100644
index 0000000..934b5e7
--- /dev/null
+++ b/fw/fe310/eos/i2c/bq25895.c
@@ -0,0 +1,27 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "eos.h"
+#include "i2c.h"
+#include "i2c/bq25895.h"
+
+void eos_bq25895_init(void) {
+    uint8_t data = 0;
+    int i, ret = EOS_OK;
+
+    eos_i2c_start(100000);
+    ret = eos_i2c_write8(BQ25895_ADDR, 0x07, 0x8d);   // disable watchdog
+    if (ret) printf("I2C ERROR 0x07\n");
+    ret = eos_i2c_write8(BQ25895_ADDR, 0x00, 0x28);   // 2.1A input current
+    if (ret) printf("I2C ERROR 0x00\n");
+    ret = eos_i2c_write8(BQ25895_ADDR, 0x03, 0x1e);   // sysmin 3.7, disable otg
+    if (ret) printf("I2C ERROR 0x03\n");
+
+    printf("BQ25895:\n");
+    for (i=0; i<0x15; i++) {
+        ret = eos_i2c_read8(BQ25895_ADDR, i, &data);
+        if (!ret) printf("REG%02x: %02x\n", i, data);
+    }
+    eos_i2c_stop();
+}
diff --git a/fw/fe310/eos/i2c/bq25895.h b/fw/fe310/eos/i2c/bq25895.h
new file mode 100644
index 0000000..f61a46f
--- /dev/null
+++ b/fw/fe310/eos/i2c/bq25895.h
@@ -0,0 +1,5 @@
+#include <stdint.h>
+
+#define BQ25895_ADDR        0x6A
+
+void eos_bq25895_init(void);
diff --git a/fw/fe310/eos/i2c/drv2605.h b/fw/fe310/eos/i2c/drv2605.h
new file mode 100644
index 0000000..fe90a9b
--- /dev/null
+++ b/fw/fe310/eos/i2c/drv2605.h
@@ -0,0 +1,3 @@
+#include <stdint.h>
+
+#define DRV2605_ADDR        0x5A
diff --git a/fw/fe310/eos/i2c/lsm9ds1.h b/fw/fe310/eos/i2c/lsm9ds1.h
new file mode 100644
index 0000000..92220e7
--- /dev/null
+++ b/fw/fe310/eos/i2c/lsm9ds1.h
@@ -0,0 +1,4 @@
+#include <stdint.h>
+
+#define LSM9DS1_ADDR_AG     0x1E
+#define LSM9DS1_ADDR_M      0x6B
diff --git a/fw/fe310/eos/i2c/ov2640.c b/fw/fe310/eos/i2c/ov2640.c
new file mode 100644
index 0000000..1a29463
--- /dev/null
+++ b/fw/fe310/eos/i2c/ov2640.c
@@ -0,0 +1,861 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <math.h>
+
+#include "eos.h"
+#include "timer.h"
+#include "cam.h"
+
+#include "i2c.h"
+#include "ov2640_regs.h"
+#include "ov2640.h"
+
+#define XCLK_FREQ       24000000
+//#define XCLK_FREQ       12000000
+
+#define CIF_WIDTH       (400)
+#define CIF_HEIGHT      (296)
+
+#define SVGA_WIDTH      (800)
+#define SVGA_HEIGHT     (600)
+
+#define UXGA_WIDTH      (1600)
+#define UXGA_HEIGHT     (1200)
+
+static const uint8_t default_regs[][2] = {
+
+// From Linux Driver.
+
+    {BANK_SEL,      BANK_SEL_DSP},
+    {0x2c,          0xff},
+    {0x2e,          0xdf},
+    {BANK_SEL,      BANK_SEL_SENSOR},
+    {0x3c,          0x32},
+//  {CLKRC,         CLKRC_DOUBLE | 0x02},
+    {CLKRC,         0x01},
+    {COM2,          COM2_OUT_DRIVE_3x},
+    {REG04,         REG04_SET(REG04_HFLIP_IMG | REG04_VFLIP_IMG | REG04_VREF_EN | REG04_HREF_EN)},
+    {COM8,          COM8_SET(COM8_BNDF_EN | COM8_AGC_EN | COM8_AEC_EN)},
+    {COM9,          COM9_AGC_SET(COM9_AGC_GAIN_8x)},
+    {0x2c,          0x0c},
+    {0x33,          0x78},
+    {0x3a,          0x33},
+    {0x3b,          0xfb},
+    {0x3e,          0x00},
+    {0x43,          0x11},
+    {0x16,          0x10},
+    {0x39,          0x02},
+    {0x35,          0x88},
+    {0x22,          0x0a},
+    {0x37,          0x40},
+    {0x23,          0x00},
+    {ARCOM2,        0xa0},
+    {0x06,          0x02},
+    {0x06,          0x88},
+    {0x07,          0xc0},
+    {0x0d,          0xb7},
+    {0x0e,          0x01},
+    {0x4c,          0x00},
+    {0x4a,          0x81},
+    {0x21,          0x99},
+    {AEW,           0x40},
+    {AEB,           0x38},
+    {VV,            VV_AGC_TH_SET(0x08, 0x02)},
+    {0x5c,          0x00},
+    {0x63,          0x00},
+    {FLL,           0x22},
+    {COM3,          COM3_BAND_SET(COM3_BAND_AUTO)},
+    {REG5D,         0x55},
+    {REG5E,         0x7d},
+    {REG5F,         0x7d},
+    {REG60,         0x55},
+    {HISTO_LOW,     0x70},
+    {HISTO_HIGH,    0x80},
+    {0x7c,          0x05},
+    {0x20,          0x80},
+    {0x28,          0x30},
+    {0x6c,          0x00},
+    {0x6d,          0x80},
+    {0x6e,          0x00},
+    {0x70,          0x02},
+    {0x71,          0x94},
+    {0x73,          0xc1},
+    {0x3d,          0x34},
+    {COM7,          COM7_RES_UXGA | COM7_ZOOM_EN},
+    {0x5a,          0x57},
+    {COM25,         0x00},
+    {BD50,          0xbb},
+    {BD60,          0x9c},
+    {BANK_SEL,      BANK_SEL_DSP},
+    {0xe5,          0x7f},
+    {MC_BIST,       MC_BIST_RESET | MC_BIST_BOOT_ROM_SEL},
+    {0x41,          0x24},
+    {RESET,         RESET_JPEG | RESET_DVP},
+    {0x76,          0xff},
+    {0x33,          0xa0},
+    {0x42,          0x20},
+    {0x43,          0x18},
+    {0x4c,          0x00},
+    {CTRL3,         CTRL3_BPC_EN | CTRL3_WPC_EN | 0x10},
+    {0x88,          0x3f},
+    {0xd7,          0x03},
+    {0xd9,          0x10},
+    {R_DVP_SP,      R_DVP_SP_AUTO_MODE | 0x2},
+    {0xc8,          0x08},
+    {0xc9,          0x80},
+    {BPADDR,        0x00},
+    {BPDATA,        0x00},
+    {BPADDR,        0x03},
+    {BPDATA,        0x48},
+    {BPDATA,        0x48},
+    {BPADDR,        0x08},
+    {BPDATA,        0x20},
+    {BPDATA,        0x10},
+    {BPDATA,        0x0e},
+    {0x90,          0x00},
+    {0x91,          0x0e},
+    {0x91,          0x1a},
+    {0x91,          0x31},
+    {0x91,          0x5a},
+    {0x91,          0x69},
+    {0x91,          0x75},
+    {0x91,          0x7e},
+    {0x91,          0x88},
+    {0x91,          0x8f},
+    {0x91,          0x96},
+    {0x91,          0xa3},
+    {0x91,          0xaf},
+    {0x91,          0xc4},
+    {0x91,          0xd7},
+    {0x91,          0xe8},
+    {0x91,          0x20},
+    {0x92,          0x00},
+    {0x93,          0x06},
+    {0x93,          0xe3},
+    {0x93,          0x03},
+    {0x93,          0x03},
+    {0x93,          0x00},
+    {0x93,          0x02},
+    {0x93,          0x00},
+    {0x93,          0x00},
+    {0x93,          0x00},
+    {0x93,          0x00},
+    {0x93,          0x00},
+    {0x93,          0x00},
+    {0x93,          0x00},
+    {0x96,          0x00},
+    {0x97,          0x08},
+    {0x97,          0x19},
+    {0x97,          0x02},
+    {0x97,          0x0c},
+    {0x97,          0x24},
+    {0x97,          0x30},
+    {0x97,          0x28},
+    {0x97,          0x26},
+    {0x97,          0x02},
+    {0x97,          0x98},
+    {0x97,          0x80},
+    {0x97,          0x00},
+    {0x97,          0x00},
+    {0xa4,          0x00},
+    {0xa8,          0x00},
+    {0xc5,          0x11},
+    {0xc6,          0x51},
+    {0xbf,          0x80},
+    {0xc7,          0x10},  /* simple AWB */
+    {0xb6,          0x66},
+    {0xb8,          0xA5},
+    {0xb7,          0x64},
+    {0xb9,          0x7C},
+    {0xb3,          0xaf},
+    {0xb4,          0x97},
+    {0xb5,          0xFF},
+    {0xb0,          0xC5},
+    {0xb1,          0x94},
+    {0xb2,          0x0f},
+    {0xc4,          0x5c},
+    {0xa6,          0x00},
+    {0xa7,          0x20},
+    {0xa7,          0xd8},
+    {0xa7,          0x1b},
+    {0xa7,          0x31},
+    {0xa7,          0x00},
+    {0xa7,          0x18},
+    {0xa7,          0x20},
+    {0xa7,          0xd8},
+    {0xa7,          0x19},
+    {0xa7,          0x31},
+    {0xa7,          0x00},
+    {0xa7,          0x18},
+    {0xa7,          0x20},
+    {0xa7,          0xd8},
+    {0xa7,          0x19},
+    {0xa7,          0x31},
+    {0xa7,          0x00},
+    {0xa7,          0x18},
+    {0x7f,          0x00},
+    {0xe5,          0x1f},
+    {0xe1,          0x77},
+    {0xdd,          0x7f},
+    {CTRL0,         CTRL0_YUV422 | CTRL0_YUV_EN | CTRL0_RGB_EN},
+
+// OpenMV Custom.
+
+    {BANK_SEL,      BANK_SEL_SENSOR},
+    {0x0f,          0x4b},
+    {COM1,          0x8f},
+
+// End.
+
+    {0xff,          0xff},
+};
+
+// Looks really bad.
+//static const uint8_t cif_regs[][2] = {
+//    {BANK_SEL,  BANK_SEL_SENSOR},
+//    {COM7,      COM7_RES_CIF},
+//    {COM1,      0x06 | 0x80},
+//    {HSTART,    0x11},
+//    {HSTOP,     0x43},
+//    {VSTART,    0x01}, // 0x01 fixes issue with garbage pixels in the image...
+//    {VSTOP,     0x97},
+//    {REG32,     0x09},
+//    {BANK_SEL,  BANK_SEL_DSP},
+//    {RESET,     RESET_DVP},
+//    {SIZEL,     SIZEL_HSIZE8_11_SET(CIF_WIDTH) | SIZEL_HSIZE8_SET(CIF_WIDTH) | SIZEL_VSIZE8_SET(CIF_HEIGHT)},
+//    {HSIZE8,    HSIZE8_SET(CIF_WIDTH)},
+//    {VSIZE8,    VSIZE8_SET(CIF_HEIGHT)},
+//    {CTRL2,     CTRL2_DCW_EN | CTRL2_SDE_EN | CTRL2_UV_AVG_EN | CTRL2_CMX_EN | CTRL2_UV_ADJ_EN},
+//    {0,         0},
+//};
+
+static const uint8_t svga_regs[][2] = {
+    {BANK_SEL,  BANK_SEL_SENSOR},
+    {COM7,      COM7_RES_SVGA},
+    {COM1,      0x0A | 0x80},
+    {HSTART,    0x11},
+    {HSTOP,     0x43},
+    {VSTART,    0x01}, // 0x01 fixes issue with garbage pixels in the image...
+    {VSTOP,     0x97},
+    {REG32,     0x09},
+    {BANK_SEL,  BANK_SEL_DSP},
+    {RESET,     RESET_DVP},
+    {SIZEL,     SIZEL_HSIZE8_11_SET(SVGA_WIDTH) | SIZEL_HSIZE8_SET(SVGA_WIDTH) | SIZEL_VSIZE8_SET(SVGA_HEIGHT)},
+    {HSIZE8,    HSIZE8_SET(SVGA_WIDTH)},
+    {VSIZE8,    VSIZE8_SET(SVGA_HEIGHT)},
+    {CTRL2,     CTRL2_DCW_EN | CTRL2_SDE_EN | CTRL2_UV_AVG_EN | CTRL2_CMX_EN | CTRL2_UV_ADJ_EN},
+    {0xff,      0xff},
+};
+
+static const uint8_t uxga_regs[][2] = {
+    {BANK_SEL,  BANK_SEL_SENSOR},
+    {COM7,      COM7_RES_UXGA},
+    {COM1,      0x0F | 0x80},
+    {HSTART,    0x11},
+    {HSTOP,     0x75},
+    {VSTART,    0x01},
+    {VSTOP,     0x97},
+    {REG32,     0x36},
+    {BANK_SEL,  BANK_SEL_DSP},
+    {RESET,     RESET_DVP},
+    {SIZEL,     SIZEL_HSIZE8_11_SET(UXGA_WIDTH) | SIZEL_HSIZE8_SET(UXGA_WIDTH) | SIZEL_VSIZE8_SET(UXGA_HEIGHT)},
+    {HSIZE8,    HSIZE8_SET(UXGA_WIDTH)},
+    {VSIZE8,    VSIZE8_SET(UXGA_HEIGHT)},
+    {CTRL2,     CTRL2_DCW_EN | CTRL2_SDE_EN | CTRL2_UV_AVG_EN | CTRL2_CMX_EN | CTRL2_UV_ADJ_EN},
+    {0xff,      0xff},
+};
+
+static const uint8_t yuv422_regs[][2] = {
+    {BANK_SEL,      BANK_SEL_DSP},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {IMAGE_MODE,    IMAGE_MODE_YUV422},
+    {0xd7,          0x03},
+    {0x33,          0xa0},
+    {0xe5,          0x1f},
+    {0xe1,          0x67},
+    {RESET,         0x00},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {0xff,          0xff},
+};
+
+static const uint8_t rgb565_regs[][2] = {
+    {BANK_SEL,      BANK_SEL_DSP},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {IMAGE_MODE,    IMAGE_MODE_RGB565},
+    {0xd7,          0x03},
+    {RESET,         0x00},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {0xff,          0xff},
+};
+
+static const uint8_t bayer_regs[][2] = {
+    {BANK_SEL,      BANK_SEL_DSP},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {IMAGE_MODE,    IMAGE_MODE_RAW10},
+    {0xd7,          0x03},
+    {RESET,         0x00},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {0xff,          0xff},
+};
+
+static const uint8_t jpeg_regs[][2] = {
+    {BANK_SEL,      BANK_SEL_DSP},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {IMAGE_MODE,    IMAGE_MODE_JPEG_EN},
+    {0xd7,          0x03},
+    {RESET,         0x00},
+    {R_BYPASS,      R_BYPASS_DSP_EN},
+    {0xff,          0xff},
+};
+
+#define NUM_BRIGHTNESS_LEVELS (5)
+static const uint8_t brightness_regs[NUM_BRIGHTNESS_LEVELS + 1][5] = {
+    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA},
+    {0x00, 0x04, 0x09, 0x00, 0x00}, /* -2 */
+    {0x00, 0x04, 0x09, 0x10, 0x00}, /* -1 */
+    {0x00, 0x04, 0x09, 0x20, 0x00}, /*  0 */
+    {0x00, 0x04, 0x09, 0x30, 0x00}, /* +1 */
+    {0x00, 0x04, 0x09, 0x40, 0x00}, /* +2 */
+};
+
+#define NUM_CONTRAST_LEVELS (5)
+static const uint8_t contrast_regs[NUM_CONTRAST_LEVELS + 1][7] = {
+    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA, BPDATA, BPDATA},
+    {0x00, 0x04, 0x07, 0x20, 0x18, 0x34, 0x06}, /* -2 */
+    {0x00, 0x04, 0x07, 0x20, 0x1c, 0x2a, 0x06}, /* -1 */
+    {0x00, 0x04, 0x07, 0x20, 0x20, 0x20, 0x06}, /*  0 */
+    {0x00, 0x04, 0x07, 0x20, 0x24, 0x16, 0x06}, /* +1 */
+    {0x00, 0x04, 0x07, 0x20, 0x28, 0x0c, 0x06}, /* +2 */
+};
+
+#define NUM_SATURATION_LEVELS (5)
+static const uint8_t saturation_regs[NUM_SATURATION_LEVELS + 1][5] = {
+    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA},
+    {0x00, 0x02, 0x03, 0x28, 0x28}, /* -2 */
+    {0x00, 0x02, 0x03, 0x38, 0x38}, /* -1 */
+    {0x00, 0x02, 0x03, 0x48, 0x48}, /*  0 */
+    {0x00, 0x02, 0x03, 0x58, 0x58}, /* +1 */
+    {0x00, 0x02, 0x03, 0x68, 0x68}, /* +2 */
+};
+
+static int reg_read(int8_t reg, uint8_t *data) {
+    return eos_i2c_read8(OV2640_ADDR, reg, data);
+}
+
+static int reg_write(uint8_t reg, uint8_t data) {
+    return eos_i2c_write8(OV2640_ADDR, reg, data);
+}
+
+static int regarr_write(const uint8_t (*regs)[2]) {
+    int i, rv;
+
+    i = 0;
+    rv = EOS_OK;
+
+    while ((regs[i][0] != 0xff) || (regs[i][1] != 0xff)) {
+        if (!rv) rv = reg_write(regs[i][0], regs[i][1]);
+        i++;
+    }
+
+    return rv;
+}
+
+int eos_ov2640_init(void) {
+    int rv;
+
+    // Reset all registers
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_write(COM7, COM7_SRST);
+    if (rv) return rv;
+
+    // Delay 5 ms
+    eos_time_sleep(5);
+
+    // Write default regsiters
+    rv = regarr_write(default_regs);
+    if (rv) return rv;
+
+    // Delay 300 ms
+    eos_time_sleep(300);
+
+    return EOS_OK;
+}
+
+int eos_ov2640_sleep(int enable) {
+    uint8_t reg;
+    int rv;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(COM2, &reg);
+    if (rv) return rv;
+
+    if (enable) {
+        reg |= COM2_STDBY;
+    } else {
+        reg &= ~COM2_STDBY;
+    }
+
+    // Write back register
+    return reg_write(COM2, reg);
+}
+
+int eos_ov2640_set_pixfmt(pixformat_t fmt) {
+    const uint8_t (*regs)[2];
+
+    switch (fmt) {
+        case PIXFORMAT_RGB565:
+            regs = rgb565_regs;
+            break;
+        case PIXFORMAT_YUV422:
+        case PIXFORMAT_GRAYSCALE:
+            regs = yuv422_regs;
+            break;
+        case PIXFORMAT_BAYER:
+            regs = bayer_regs;
+            break;
+        case PIXFORMAT_JPEG:
+            regs = jpeg_regs;
+            break;
+        default:
+            return EOS_ERR;
+    }
+
+    return regarr_write(regs);
+}
+
+int eos_ov2640_set_framesize(framesize_t framesize) {
+    const uint8_t (*regs)[2];
+    uint16_t sensor_w = 0;
+    uint16_t sensor_h = 0;
+    uint16_t w = _eos_cam_resolution[framesize][0];
+    uint16_t h = _eos_cam_resolution[framesize][1];
+    int rv;
+
+    if ((w % 4) || (h % 4) || (w > UXGA_WIDTH) || (h > UXGA_HEIGHT)) { // w/h must be divisble by 4
+        return EOS_ERR;
+    }
+
+    // Looks really bad.
+    /* if ((w <= CIF_WIDTH) && (h <= CIF_HEIGHT)) {
+        regs = cif_regs;
+        sensor_w = CIF_WIDTH;
+        sensor_h = CIF_HEIGHT;
+    } else */ if ((w <= SVGA_WIDTH) && (h <= SVGA_HEIGHT)) {
+        regs = svga_regs;
+        sensor_w = SVGA_WIDTH;
+        sensor_h = SVGA_HEIGHT;
+    } else {
+        regs = uxga_regs;
+        sensor_w = UXGA_WIDTH;
+        sensor_h = UXGA_HEIGHT;
+    }
+
+    // Write setup regsiters
+    rv = regarr_write(regs);
+    if (rv) return rv;
+
+    uint64_t tmp_div = IM_MIN(sensor_w / w, sensor_h / h);
+    uint16_t log_div = IM_MIN(IM_LOG2(tmp_div) - 1, 3);
+    uint16_t div = 1 << log_div;
+    uint16_t w_mul = w * div;
+    uint16_t h_mul = h * div;
+    uint16_t x_off = (sensor_w - w_mul) / 2;
+    uint16_t y_off = (sensor_h - h_mul) / 2;
+
+    rv = EOS_OK;
+    if (!rv) rv = reg_write(CTRLI, CTRLI_LP_DP | CTRLI_V_DIV_SET(log_div) | CTRLI_H_DIV_SET(log_div));
+    if (!rv) rv = reg_write(HSIZE, HSIZE_SET(w_mul));
+    if (!rv) rv = reg_write(VSIZE, VSIZE_SET(h_mul));
+    if (!rv) rv = reg_write(XOFFL, XOFFL_SET(x_off));
+    if (!rv) rv = reg_write(YOFFL, YOFFL_SET(y_off));
+    if (!rv) rv = reg_write(VHYX, VHYX_HSIZE_SET(w_mul) | VHYX_VSIZE_SET(h_mul) | VHYX_XOFF_SET(x_off) | VHYX_YOFF_SET(y_off));
+    if (!rv) rv = reg_write(TEST, TEST_HSIZE_SET(w_mul));
+    if (!rv) rv = reg_write(ZMOW, ZMOW_OUTW_SET(w));
+    if (!rv) rv = reg_write(ZMOH, ZMOH_OUTH_SET(h));
+    if (!rv) rv = reg_write(ZMHH, ZMHH_OUTW_SET(w) | ZMHH_OUTH_SET(h));
+    if (!rv) rv = reg_write(R_DVP_SP, div);
+    if (!rv) rv = reg_write(RESET, 0x00);
+
+    return rv;
+}
+
+int eos_ov2640_set_contrast(int level) {
+    int rv = EOS_OK;
+
+    level += (NUM_CONTRAST_LEVELS / 2) + 1;
+    if (level <= 0 || level > NUM_CONTRAST_LEVELS) {
+        return EOS_ERR;
+    }
+
+    /* Switch to DSP register bank */
+    rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+
+    /* Write contrast registers */
+    for (int i=0; i<sizeof(contrast_regs[0])/sizeof(contrast_regs[0][0]); i++) {
+        if (!rv) rv = reg_write(contrast_regs[0][i], contrast_regs[level][i]);
+    }
+
+    return rv;
+}
+
+int eos_ov2640_set_brightness(int level) {
+    int rv = EOS_OK;
+
+    level += (NUM_BRIGHTNESS_LEVELS / 2) + 1;
+    if (level <= 0 || level > NUM_BRIGHTNESS_LEVELS) {
+        return EOS_ERR;
+    }
+
+    /* Switch to DSP register bank */
+    rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+
+    /* Write brightness registers */
+    for (int i=0; i<sizeof(brightness_regs[0])/sizeof(brightness_regs[0][0]); i++) {
+        if (!rv) rv = reg_write(brightness_regs[0][i], brightness_regs[level][i]);
+    }
+
+    return rv;
+}
+
+int eos_ov2640_set_saturation(int level) {
+    int rv = EOS_OK;
+
+    level += (NUM_SATURATION_LEVELS / 2) + 1;
+    if (level <= 0 || level > NUM_SATURATION_LEVELS) {
+        return EOS_ERR;
+    }
+
+    /* Switch to DSP register bank */
+    rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+
+    /* Write saturation registers */
+    for (int i=0; i<sizeof(saturation_regs[0])/sizeof(saturation_regs[0][0]); i++) {
+        if (!rv) rv = reg_write(saturation_regs[0][i], saturation_regs[level][i]);
+    }
+
+    return rv;
+}
+
+int eos_ov2640_set_gainceiling(gainceiling_t gainceiling) {
+    int rv = EOS_OK;
+
+    /* Switch to SENSOR register bank */
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+
+    /* Write gain ceiling register */
+    if (!rv) rv = reg_write(COM9, COM9_AGC_SET(gainceiling));
+
+    return rv;
+}
+
+int eos_ov2640_set_quality(int qs) {
+    int rv = EOS_OK;
+
+    /* Switch to DSP register bank */
+    rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+
+    /* Write QS register */
+    if (!rv) rv = reg_write(QS, qs);
+
+    return rv;
+}
+
+int eos_ov2640_set_colorbar(int enable) {
+    int rv = EOS_OK;
+    uint8_t reg;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(COM7, &reg);
+    if (rv) return rv;
+
+    if (enable) {
+        reg |= COM7_COLOR_BAR;
+    } else {
+        reg &= ~COM7_COLOR_BAR;
+    }
+
+    return reg_write(COM7, reg);
+}
+
+int eos_ov2640_set_auto_gain(int enable, float gain_db, float gain_db_ceiling) {
+    int rv = EOS_OK;
+    uint8_t reg;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(COM8, &reg);
+    if (rv) return rv;
+
+    rv = reg_write(COM8, (reg & (~COM8_AGC_EN)) | (enable ? COM8_AGC_EN : 0));
+    if (rv) return rv;
+
+    rv = EOS_OK;
+    if (enable && (!isnanf(gain_db_ceiling)) && (!isinff(gain_db_ceiling))) {
+        float gain_ceiling = IM_MAX(IM_MIN(expf((gain_db_ceiling / 20.0) * logf(10.0)), 128.0), 2.0);
+
+        if (!rv) rv = reg_read(COM9, &reg);
+        if (!rv) rv = reg_write(COM9, (reg & 0x1F) | (((int)ceilf(log2f(gain_ceiling)) - 1) << 5));
+    }
+
+    if (!enable && (!isnanf(gain_db)) && (!isinff(gain_db))) {
+        float gain = IM_MAX(IM_MIN(expf((gain_db / 20.0) * logf(10.0)), 32.0), 1.0);
+
+        int gain_temp = roundf(log2f(IM_MAX(gain / 2.0, 1.0)));
+        int gain_hi = 0xF >> (4 - gain_temp);
+        int gain_lo = IM_MIN(roundf(((gain / (1 << gain_temp)) - 1.0) * 16.0), 15);
+
+        if (!rv) rv = reg_write(GAIN, (gain_hi << 4) | (gain_lo << 0));
+    }
+
+    return rv;
+}
+
+int eos_ov2640_get_gain_db(float *gain_db) {
+    int rv = EOS_OK;
+    uint8_t reg, gain;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(COM8, &reg);
+    if (rv) return rv;
+
+    // DISABLED
+    // if (reg & COM8_AGC_EN) {
+    //     rv = reg_write(COM8, reg & (~COM8_AGC_EN));
+    //     if (rv) return rv;
+    // }
+    // DISABLED
+
+    rv = reg_read(GAIN, &gain);
+    if (rv) return rv;
+
+    // DISABLED
+    // if (reg & COM8_AGC_EN) {
+    //     rv = reg_write(COM8, reg | COM8_AGC_EN);
+    //     if (rv) return rv;
+    // }
+    // DISABLED
+
+    int hi_gain = 1 << (((gain >> 7) & 1) + ((gain >> 6) & 1) + ((gain >> 5) & 1) + ((gain >> 4) & 1));
+    float lo_gain = 1.0 + (((gain >> 0) & 0xF) / 16.0);
+    *gain_db = 20.0 * (logf(hi_gain * lo_gain) / logf(10.0));
+
+    return EOS_OK;
+}
+
+int eos_ov2640_set_auto_exposure(int enable, int exposure_us) {
+    int rv = EOS_OK;
+    uint8_t reg;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(COM8, &reg);
+    if (rv) return rv;
+
+    rv = reg_write(COM8, COM8_SET_AEC(reg, (enable != 0)));
+    if (rv) return rv;
+
+    if (!enable && (exposure_us >= 0)) {
+        rv = reg_read(COM7, &reg);
+        if (rv) return rv;
+
+        int t_line = 0;
+
+        if (COM7_GET_RES(reg) == COM7_RES_UXGA) t_line = 1600 + 322;
+        if (COM7_GET_RES(reg) == COM7_RES_SVGA) t_line = 800 + 390;
+        if (COM7_GET_RES(reg) == COM7_RES_CIF) t_line = 400 + 195;
+
+        rv = reg_read(CLKRC, &reg);
+        if (rv) return rv;
+
+        int pll_mult = ((reg & CLKRC_DOUBLE) ? 2 : 1) * 3;
+        int clk_rc = (reg & CLKRC_DIVIDER_MASK) + 2;
+
+        rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+        if (rv) return rv;
+
+        rv = reg_read(IMAGE_MODE, &reg);
+        if (rv) return rv;
+
+        int t_pclk = 0;
+
+        if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_YUV422) t_pclk = 2;
+        if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_RAW10) t_pclk = 1;
+        if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_RGB565) t_pclk = 2;
+
+        int exposure = IM_MAX(IM_MIN(((exposure_us*(((XCLK_FREQ/clk_rc)*pll_mult)/1000000))/t_pclk)/t_line,0xFFFF),0x0000);
+
+        if (!rv) rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+
+        if (!rv) rv = reg_read(REG04, &reg);
+        if (!rv) rv = reg_write(REG04, (reg & 0xFC) | ((exposure >> 0) & 0x3));
+
+        if (!rv) rv = reg_read(AEC, &reg);
+        if (!rv) rv = reg_write(AEC, (reg & 0x00) | ((exposure >> 2) & 0xFF));
+
+        if (!rv) rv = reg_read(REG45, &reg);
+        if (!rv) rv = reg_write(REG45, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
+    }
+
+    return rv;
+}
+
+int eos_ov2640_get_exposure_us(int *exposure_us) {
+    int rv = EOS_OK;
+    uint8_t reg, aec_10, aec_92, aec_1510;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(COM8, &reg);
+    if (rv) return rv;
+
+    // DISABLED
+    // if (reg & COM8_AEC_EN) {
+    //     rv = reg_write(COM8, reg & (~COM8_AEC_EN));
+    //     if (rv) return rv;
+    // }
+    // DISABLED
+
+    rv = reg_read(REG04, &aec_10);
+    if (rv) return rv;
+
+    rv = reg_read(AEC, &aec_92);
+    if (rv) return rv;
+
+    rv = reg_read(REG45, &aec_1510);
+    if (rv) return rv;
+
+    // DISABLED
+    // if (reg & COM8_AEC_EN) {
+    //     rv = reg_write(COM8, reg | COM8_AEC_EN);
+    //     if (rv) return rv;
+    // }
+    // DISABLED
+
+    rv = reg_read(COM7, &reg);
+    if (rv) return rv;
+
+    int t_line = 0;
+
+    if (COM7_GET_RES(reg) == COM7_RES_UXGA) t_line = 1600 + 322;
+    if (COM7_GET_RES(reg) == COM7_RES_SVGA) t_line = 800 + 390;
+    if (COM7_GET_RES(reg) == COM7_RES_CIF) t_line = 400 + 195;
+
+    rv = reg_read(CLKRC, &reg);
+    if (rv) return rv;
+
+    int pll_mult = ((reg & CLKRC_DOUBLE) ? 2 : 1) * 3;
+    int clk_rc = (reg & CLKRC_DIVIDER_MASK) + 2;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+    if (rv) return rv;
+
+    rv = reg_read(IMAGE_MODE, &reg);
+    if (rv) return rv;
+
+    int t_pclk = 0;
+
+    if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_YUV422) t_pclk = 2;
+    if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_RAW10) t_pclk = 1;
+    if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_RGB565) t_pclk = 2;
+
+    uint16_t exposure = ((aec_1510 & 0x3F) << 10) + ((aec_92 & 0xFF) << 2) + ((aec_10 & 0x3) << 0);
+    *exposure_us = (exposure*t_line*t_pclk)/(((XCLK_FREQ/clk_rc)*pll_mult)/1000000);
+
+    return EOS_OK;
+}
+
+int eos_ov2640_set_auto_whitebal(int enable, float r_gain_db, float g_gain_db, float b_gain_db) {
+    int rv = EOS_OK;
+    uint8_t reg;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+    if (rv) return rv;
+
+    rv = reg_read(CTRL1, &reg);
+    if (rv) return rv;
+
+    rv = reg_write(CTRL1, (reg & (~CTRL1_AWB)) | (enable ? CTRL1_AWB : 0));
+    if (rv) return rv;
+
+    if (!enable && (!isnanf(r_gain_db)) && (!isnanf(g_gain_db)) && (!isnanf(b_gain_db))
+                && (!isinff(r_gain_db)) && (!isinff(g_gain_db)) && (!isinff(b_gain_db))) {
+    }
+
+    return rv;
+}
+
+int eos_ov2640_set_hmirror(int enable) {
+    int rv = EOS_OK;
+    uint8_t reg;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(REG04, &reg);
+    if (rv) return rv;
+
+    if (!enable) { // Already mirrored.
+        reg |= REG04_HFLIP_IMG;
+    } else {
+        reg &= ~REG04_HFLIP_IMG;
+    }
+
+    return reg_write(REG04, reg);
+}
+
+int eos_ov2640_set_vflip(int enable) {
+    int rv = EOS_OK;
+    uint8_t reg;
+
+    rv = reg_write(BANK_SEL, BANK_SEL_SENSOR);
+    if (rv) return rv;
+
+    rv = reg_read(REG04, &reg);
+    if (rv) return rv;
+
+    if (!enable) { // Already flipped.
+        reg |= REG04_VFLIP_IMG | REG04_VREF_EN;
+    } else {
+        reg &= ~(REG04_VFLIP_IMG | REG04_VREF_EN);
+    }
+
+    return reg_write(REG04, reg);
+}
+
+int eos_ov2640_set_effect(sde_t sde) {
+    int rv = EOS_OK;
+
+    switch (sde) {
+        case SDE_NEGATIVE:
+            if (!rv) rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+            if (!rv) rv = reg_write(BPADDR, 0x00);
+            if (!rv) rv = reg_write(BPDATA, 0x40);
+            if (!rv) rv = reg_write(BPADDR, 0x05);
+            if (!rv) rv = reg_write(BPDATA, 0x80);
+            if (!rv) rv = reg_write(BPDATA, 0x80);
+            break;
+        case SDE_NORMAL:
+            if (!rv) rv = reg_write(BANK_SEL, BANK_SEL_DSP);
+            if (!rv) rv = reg_write(BPADDR, 0x00);
+            if (!rv) rv = reg_write(BPDATA, 0x00);
+            if (!rv) rv = reg_write(BPADDR, 0x05);
+            if (!rv) rv = reg_write(BPDATA, 0x80);
+            if (!rv) rv = reg_write(BPDATA, 0x80);
+            break;
+        default:
+            return EOS_ERR;
+    }
+
+    return rv;
+}
diff --git a/fw/fe310/eos/i2c/ov2640.h b/fw/fe310/eos/i2c/ov2640.h
new file mode 100644
index 0000000..3d08c2a
--- /dev/null
+++ b/fw/fe310/eos/i2c/ov2640.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+
+#define OV2640_ADDR     0x30
+
+int eos_ov2640_init(void);
+int eos_ov2640_sleep(int enable);
+int eos_ov2640_set_pixfmt(pixformat_t fmt);
+int eos_ov2640_set_framesize(framesize_t framesize);
diff --git a/fw/fe310/eos/i2c/ov2640_regs.h b/fw/fe310/eos/i2c/ov2640_regs.h
new file mode 100644
index 0000000..deb7521
--- /dev/null
+++ b/fw/fe310/eos/i2c/ov2640_regs.h
@@ -0,0 +1,245 @@
+/*
+ * This file is part of the OpenMV project.
+ *
+ * Copyright (c) 2013-2021 Ibrahim Abdelkader <iabdalkader@openmv.io>
+ * Copyright (c) 2013-2021 Kwabena W. Agyeman <kwagyeman@openmv.io>
+ *
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * OV2640 register definitions.
+ */
+#ifndef __REG_REGS_H__
+#define __REG_REGS_H__
+
+/* DSP register bank FF=0x00*/
+
+#define QS                      0x44
+#define HSIZE                   0x51
+#define VSIZE                   0x52
+#define XOFFL                   0x53
+#define YOFFL                   0x54
+#define VHYX                    0x55
+#define DPRP                    0x56
+#define TEST                    0x57
+#define ZMOW                    0x5A
+#define ZMOH                    0x5B
+#define ZMHH                    0x5C
+#define BPADDR                  0x7C
+#define BPDATA                  0x7D
+#define SIZEL                   0x8C
+#define HSIZE8                  0xC0
+#define VSIZE8                  0xC1
+#define CTRL1                   0xC3
+#define MS_SP                   0xF0
+#define SS_ID                   0xF7
+#define SS_CTRL                 0xF7
+#define MC_AL                   0xFA
+#define MC_AH                   0xFB
+#define MC_D                    0xFC
+#define P_CMD                   0xFD
+#define P_STATUS                0xFE
+
+#define CTRLI                   0x50
+#define CTRLI_LP_DP             0x80
+#define CTRLI_ROUND             0x40
+
+#define CTRL0                   0xC2
+#define CTRL0_AEC_EN            0x80
+#define CTRL0_AEC_SEL           0x40
+#define CTRL0_STAT_SEL          0x20
+#define CTRL0_VFIRST            0x10
+#define CTRL0_YUV422            0x08
+#define CTRL0_YUV_EN            0x04
+#define CTRL0_RGB_EN            0x02
+#define CTRL0_RAW_EN            0x01
+
+#define CTRL2                   0x86
+#define CTRL2_DCW_EN            0x20
+#define CTRL2_SDE_EN            0x10
+#define CTRL2_UV_ADJ_EN         0x08
+#define CTRL2_UV_AVG_EN         0x04
+#define CTRL2_CMX_EN            0x01
+
+#define CTRL3                   0x87
+#define CTRL3_BPC_EN            0x80
+#define CTRL3_WPC_EN            0x40
+#define R_DVP_SP                0xD3
+#define R_DVP_SP_AUTO_MODE      0x80
+
+#define R_BYPASS                0x05
+#define R_BYPASS_DSP_EN         0x00
+#define R_BYPASS_DSP_BYPAS      0x01
+
+#define IMAGE_MODE              0xDA
+#define IMAGE_MODE_Y8_DVP_EN    0x40
+#define IMAGE_MODE_JPEG_EN      0x10
+#define IMAGE_MODE_YUV422       0x00
+#define IMAGE_MODE_RAW10        0x04
+#define IMAGE_MODE_RGB565       0x09
+#define IMAGE_MODE_HREF_VSYNC   0x02
+#define IMAGE_MODE_LBYTE_FIRST  0x01
+#define IMAGE_MODE_GET_FMT(x)   ((x)&0xC)
+
+#define RESET                   0xE0
+#define RESET_MICROC            0x40
+#define RESET_SCCB              0x20
+#define RESET_JPEG              0x10
+#define RESET_DVP               0x04
+#define RESET_IPU               0x02
+#define RESET_CIF               0x01
+
+#define MC_BIST                 0xF9
+#define MC_BIST_RESET           0x80
+#define MC_BIST_BOOT_ROM_SEL    0x40
+#define MC_BIST_12KB_SEL        0x20
+#define MC_BIST_12KB_MASK       0x30
+#define MC_BIST_512KB_SEL       0x08
+#define MC_BIST_512KB_MASK      0x0C
+#define MC_BIST_BUSY_BIT_R      0x02
+#define MC_BIST_MC_RES_ONE_SH_W 0x02
+#define MC_BIST_LAUNCH          0x01
+
+#define BANK_SEL                0xFF
+#define BANK_SEL_DSP            0x00
+#define BANK_SEL_SENSOR         0x01
+
+/* Sensor register bank FF=0x01*/
+
+#define GAIN                0x00
+#define COM1                0x03
+#define REG_PID             0x0A
+#define REG_VER             0x0B
+#define COM4                0x0D
+#define AEC                 0x10
+
+#define CLKRC               0x11
+#define CLKRC_DOUBLE        0x80
+#define CLKRC_DIVIDER_MASK  0x3F
+
+#define COM10               0x15
+#define HSTART              0x17
+#define HSTOP               0x18
+#define VSTART              0x19
+#define VSTOP               0x1A
+#define MIDH                0x1C
+#define MIDL                0x1D
+#define AEW                 0x24
+#define AEB                 0x25
+#define REG2A               0x2A
+#define FRARL               0x2B
+#define ADDVSL              0x2D
+#define ADDVSH              0x2E
+#define YAVG                0x2F
+#define HSDY                0x30
+#define HEDY                0x31
+#define ARCOM2              0x34
+#define REG45               0x45
+#define FLL                 0x46
+#define FLH                 0x47
+#define COM19               0x48
+#define ZOOMS               0x49
+#define COM22               0x4B
+#define COM25               0x4E
+#define BD50                0x4F
+#define BD60                0x50
+#define REG5D               0x5D
+#define REG5E               0x5E
+#define REG5F               0x5F
+#define REG60               0x60
+#define HISTO_LOW           0x61
+#define HISTO_HIGH          0x62
+
+#define REG04               0x04
+#define REG04_DEFAULT       0x28
+#define REG04_HFLIP_IMG     0x80
+#define REG04_VFLIP_IMG     0x40
+#define REG04_VREF_EN       0x10
+#define REG04_HREF_EN       0x08
+#define REG04_SET(x)        (REG04_DEFAULT|x)
+
+#define REG08               0x08
+#define COM2                0x09
+#define COM2_STDBY          0x10
+#define COM2_OUT_DRIVE_1x   0x00
+#define COM2_OUT_DRIVE_2x   0x01
+#define COM2_OUT_DRIVE_3x   0x02
+#define COM2_OUT_DRIVE_4x   0x03
+
+#define COM3                0x0C
+#define COM3_DEFAULT        0x38
+#define COM3_BAND_50Hz      0x04
+#define COM3_BAND_60Hz      0x00
+#define COM3_BAND_AUTO      0x02
+#define COM3_BAND_SET(x)    (COM3_DEFAULT|x)
+
+#define COM7                0x12
+#define COM7_SRST           0x80
+#define COM7_RES_UXGA       0x00 /* UXGA */
+#define COM7_RES_SVGA       0x40 /* SVGA */
+#define COM7_RES_CIF        0x20 /* CIF  */
+#define COM7_ZOOM_EN        0x04 /* Enable Zoom */
+#define COM7_COLOR_BAR      0x02 /* Enable Color Bar Test */
+#define COM7_GET_RES(x)     ((x)&0x70)
+
+#define COM8                0x13
+#define COM8_DEFAULT        0xC0
+#define COM8_BNDF_EN        0x20 /* Enable Banding filter */
+#define COM8_AGC_EN         0x04 /* AGC Auto/Manual control selection */
+#define COM8_AEC_EN         0x01 /* Auto/Manual Exposure control */
+#define COM8_SET(x)         (COM8_DEFAULT|x)
+#define COM8_SET_AEC(r,x)   (((r)&0xFE)|((x)&1))
+
+#define COM9                0x14 /* AGC gain ceiling */
+#define COM9_DEFAULT        0x08
+#define COM9_AGC_GAIN_2x    0x00 /* AGC:    2x */
+#define COM9_AGC_GAIN_4x    0x01 /* AGC:    4x */
+#define COM9_AGC_GAIN_8x    0x02 /* AGC:    8x */
+#define COM9_AGC_GAIN_16x   0x03 /* AGC:   16x */
+#define COM9_AGC_GAIN_32x   0x04 /* AGC:   32x */
+#define COM9_AGC_GAIN_64x   0x05 /* AGC:   64x */
+#define COM9_AGC_GAIN_128x  0x06 /* AGC:  128x */
+#define COM9_AGC_SET(x)     (COM9_DEFAULT|(x<<5))
+
+#define CTRL1_AWB           0x08 /* Enable AWB */
+
+#define VV                  0x26
+#define VV_AGC_TH_SET(h,l)  ((h<<4)|(l&0x0F))
+
+#define REG32               0x32
+#define REG32_UXGA          0x36
+#define REG32_SVGA          0x09
+#define REG32_CIF           0x00
+
+#define VAL_SET(x, mask, rshift, lshift) ((((x) >> rshift) & mask) << lshift)
+
+#define CTRLI_V_DIV_SET(x)      VAL_SET(x, 0x3, 0, 3)
+#define CTRLI_H_DIV_SET(x)      VAL_SET(x, 0x3, 0, 0)
+
+#define SIZEL_HSIZE8_11_SET(x)  VAL_SET(x, 0x1, 11, 6)
+#define SIZEL_HSIZE8_SET(x)     VAL_SET(x, 0x7, 0, 3)
+#define SIZEL_VSIZE8_SET(x)     VAL_SET(x, 0x7, 0, 0)
+
+#define HSIZE8_SET(x)           VAL_SET(x, 0xFF, 3, 0)
+#define VSIZE8_SET(x)           VAL_SET(x, 0xFF, 3, 0)
+
+#define HSIZE_SET(x)            VAL_SET(x, 0xFF, 2, 0)
+#define VSIZE_SET(x)            VAL_SET(x, 0xFF, 2, 0)
+
+#define XOFFL_SET(x)            VAL_SET(x, 0xFF, 0, 0)
+#define YOFFL_SET(x)            VAL_SET(x, 0xFF, 0, 0)
+
+#define VHYX_VSIZE_SET(x)       VAL_SET(x, 0x1, (8+2), 7)
+#define VHYX_HSIZE_SET(x)       VAL_SET(x, 0x1, (8+2), 3)
+#define VHYX_YOFF_SET(x)        VAL_SET(x, 0x3, 8, 4)
+#define VHYX_XOFF_SET(x)        VAL_SET(x, 0x3, 8, 0)
+
+#define TEST_HSIZE_SET(x)       VAL_SET(x, 0x1, (9+2), 7)
+
+#define ZMOW_OUTW_SET(x)        VAL_SET(x, 0xFF, 2, 0)
+#define ZMOH_OUTH_SET(x)        VAL_SET(x, 0xFF, 2, 0)
+
+#define ZMHH_ZSPEED_SET(x)      VAL_SET(x, 0x0F, 0, 4)
+#define ZMHH_OUTH_SET(x)        VAL_SET(x, 0x1, (8+2), 2)
+#define ZMHH_OUTW_SET(x)        VAL_SET(x, 0x3, (8+2), 0)
+
+#endif //__REG_REGS_H__
diff --git a/fw/fe310/eos/i2s.c b/fw/fe310/eos/i2s.c
new file mode 100644
index 0000000..b4fd277
--- /dev/null
+++ b/fw/fe310/eos/i2s.c
@@ -0,0 +1,408 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+#include "prci_driver.h"
+
+#include "eos.h"
+#include "interrupt.h"
+#include "event.h"
+
+#include "board.h"
+
+#include "i2s.h"
+#include "i2s_priv.h"
+
+#define I2S_REG_CK(o)       _REG32(I2S_CTRL_ADDR_CK, o)
+#define I2S_REG_WS_MIC(o)   _REG32(I2S_CTRL_ADDR_WS_MIC, o)
+#define I2S_REG_WS_SPK(o)   _REG32(I2S_CTRL_ADDR_WS_SPK, o)
+
+#define MIN(X, Y)           (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y)           (((X) > (Y)) ? (X) : (Y))
+
+#define EOS_ABUF_IDX_MASK(IDX, SIZE)  ((IDX) & ((SIZE) - 1))
+
+EOSABuf _eos_i2s_mic_buf;
+EOSABuf _eos_i2s_spk_buf;
+uint32_t _eos_i2s_fmt = 0;
+uint32_t _eos_i2s_mic_wm = 0;
+uint32_t _eos_i2s_spk_wm = 0;
+uint32_t _eos_i2s_mic_evt_enable = 0;
+uint32_t _eos_i2s_spk_evt_enable = 0;
+
+static eos_i2s_handler_t i2s_spk_handler = NULL;
+static eos_i2s_handler_t i2s_mic_handler = NULL;
+static uint32_t i2s_clk_period;
+static uint8_t i2s_mic_volume = 0;      /* 0 - 8 */
+static uint8_t i2s_spk_volume = 16;     /* 0 - 16 */
+
+static void _abuf_init(EOSABuf *buf, uint8_t *array, uint16_t size) {
+    buf->idx_r = 0;
+    buf->idx_w = 0;
+    buf->size = size;
+    buf->array = array;
+}
+
+static int _abuf_push8(EOSABuf *buf, uint8_t sample) {
+    if ((uint16_t)(buf->idx_w - buf->idx_r) == buf->size) return EOS_ERR_FULL;
+
+    buf->array[EOS_ABUF_IDX_MASK(buf->idx_w, buf->size)] = sample;
+    buf->idx_w++;
+    return EOS_OK;
+}
+
+static int _abuf_push16(EOSABuf *buf, uint16_t sample) {
+    if ((uint16_t)(buf->idx_w - buf->idx_r) == buf->size) return EOS_ERR_FULL;
+
+    buf->array[EOS_ABUF_IDX_MASK(buf->idx_w, buf->size)] = sample >> 8;
+    buf->array[EOS_ABUF_IDX_MASK(buf->idx_w + 1, buf->size)] = sample & 0xFF;
+    buf->idx_w += 2;
+    return EOS_OK;
+}
+
+static int _abuf_pop8(EOSABuf *buf, uint8_t *sample) {
+    if (buf->idx_r == buf->idx_w) {
+        return EOS_ERR_EMPTY;
+    } else {
+        *sample = buf->array[EOS_ABUF_IDX_MASK(buf->idx_r, buf->size)];
+        buf->idx_r++;
+        return EOS_OK;
+    }
+}
+
+static int _abuf_pop16(EOSABuf *buf, uint16_t *sample) {
+    if (buf->idx_r == buf->idx_w) {
+        return EOS_ERR_EMPTY;
+    } else {
+        *sample = buf->array[EOS_ABUF_IDX_MASK(buf->idx_r, buf->size)] << 8;
+        *sample |= buf->array[EOS_ABUF_IDX_MASK(buf->idx_r + 1, buf->size)];
+        buf->idx_r += 2;
+        return EOS_OK;
+    }
+}
+
+
+static void _abuf_flush(EOSABuf *buf) {
+    buf->idx_r = 0;
+    buf->idx_w = 0;
+}
+
+static uint16_t _abuf_len(EOSABuf *buf) {
+    return buf->idx_w - buf->idx_r;
+}
+
+static void i2s_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    switch(type & ~EOS_EVT_MASK) {
+        case EOS_I2S_ETYPE_MIC:
+            if (i2s_mic_handler) i2s_mic_handler(type);
+            clear_csr(mstatus, MSTATUS_MIE);
+            _eos_i2s_mic_evt_enable = 1;
+            set_csr(mstatus, MSTATUS_MIE);
+            break;
+        case EOS_I2S_ETYPE_SPK:
+            if (i2s_spk_handler) i2s_spk_handler(type);
+            clear_csr(mstatus, MSTATUS_MIE);
+            _eos_i2s_spk_evt_enable = 1;
+            set_csr(mstatus, MSTATUS_MIE);
+            break;
+        default:
+            eos_evtq_bad_handler(type, buffer, len);
+            break;
+    }
+}
+
+static void _mic_vol_set(uint8_t vol) {
+    I2S_REG_WS_MIC(PWM_CMP2) = i2s_clk_period * (vol + 1);
+    I2S_REG_WS_MIC(PWM_CMP3) = I2S_REG_WS_MIC(PWM_CMP2) + i2s_clk_period * 16;
+}
+
+static void _spk_vol_set(uint8_t vol) {
+    int spk_cmp = vol + i2s_mic_volume - 16;
+
+    if (spk_cmp <= 0) {
+        I2S_REG_WS_SPK(PWM_CMP1) = i2s_clk_period * (32 + spk_cmp);
+        I2S_REG_WS_SPK(PWM_CMP2) = i2s_clk_period * (64 + spk_cmp);
+        I2S_REG_WS_SPK(PWM_CMP3) = i2s_clk_period * 33;
+        GPIO_REG(GPIO_OUTPUT_XOR) &= ~(1 << I2S_PIN_WS_SPK);
+    } else {
+        I2S_REG_WS_SPK(PWM_CMP1) = i2s_clk_period * spk_cmp;
+        I2S_REG_WS_SPK(PWM_CMP2) = i2s_clk_period * (32 + spk_cmp);
+        I2S_REG_WS_SPK(PWM_CMP3) = i2s_clk_period * (33 + spk_cmp);
+        GPIO_REG(GPIO_OUTPUT_XOR) |= (1 << I2S_PIN_WS_SPK);
+    }
+}
+
+extern void _eos_i2s_start_pwm(void);
+
+void eos_i2s_init(void) {
+    eos_evtq_set_handler(EOS_EVT_I2S, i2s_handle_evt);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_CK);
+    GPIO_REG(GPIO_OUTPUT_EN)    |=  (1 << I2S_PIN_CK);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_CK);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_CK);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_OUTPUT_EN)    |=  (1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_CK_SW);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_WS_MIC);
+    GPIO_REG(GPIO_OUTPUT_EN)    |=  (1 << I2S_PIN_WS_MIC);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_WS_MIC);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_WS_MIC);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_WS_SPK);
+    GPIO_REG(GPIO_OUTPUT_EN)    |=  (1 << I2S_PIN_WS_SPK);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_WS_SPK);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_WS_SPK);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_CK_SR);
+    GPIO_REG(GPIO_OUTPUT_EN)    |=  (1 << I2S_PIN_CK_SR);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_CK_SR);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_CK_SR);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_SD_IN);
+    GPIO_REG(GPIO_OUTPUT_EN)    &= ~(1 << I2S_PIN_SD_IN);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_SD_IN);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_SD_IN);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_SD_OUT);
+    GPIO_REG(GPIO_OUTPUT_EN)    &= ~(1 << I2S_PIN_SD_OUT);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << I2S_PIN_SD_OUT);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << I2S_PIN_SD_OUT);
+
+    GPIO_REG(GPIO_OUTPUT_VAL)   |=  (1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_OUTPUT_VAL)   &= ~((1 << I2S_PIN_CK) | (1 << I2S_PIN_CK_SR) | (1 << I2S_PIN_WS_MIC) | (1 << I2S_PIN_WS_SPK));
+}
+
+void eos_i2s_start(uint32_t sample_rate, unsigned char fmt) {
+    i2s_clk_period = ((PRCI_get_cpu_freq() / (sample_rate * 64)) & ~I2S_PWM_SCALE_CK_MASK) + 1;
+
+    I2S_REG_CK(PWM_CMP0)        = i2s_clk_period >> I2S_PWM_SCALE_CK;
+    I2S_REG_CK(PWM_CMP1)        = I2S_REG_CK(PWM_CMP0) / 2;
+    I2S_REG_CK(PWM_CMP2)        = 0;
+    I2S_REG_CK(PWM_CMP3)        = 0;
+
+    I2S_REG_WS_MIC(PWM_CMP0)    = i2s_clk_period * 64 - 1;
+    I2S_REG_WS_MIC(PWM_CMP1)    = i2s_clk_period * 32;
+    _mic_vol_set(i2s_mic_volume);
+
+    I2S_REG_WS_SPK(PWM_CMP0)    = i2s_clk_period * 64 - 1;
+    _spk_vol_set(i2s_spk_volume);
+
+    I2S_REG_CK(PWM_COUNT)       = 0;
+    I2S_REG_WS_MIC(PWM_COUNT)   = 0;
+    I2S_REG_WS_SPK(PWM_COUNT)   = i2s_clk_period / 2;
+
+    _eos_i2s_fmt = fmt;
+    _eos_i2s_mic_evt_enable = 1;
+    _eos_i2s_spk_evt_enable = 1;
+
+    eos_intr_set_priority(I2S_IRQ_WS_ID, IRQ_PRIORITY_I2S_WS);
+    eos_intr_set_priority(I2S_IRQ_SD_ID, 0);
+    eos_intr_enable(I2S_IRQ_WS_ID);
+    eos_intr_enable(I2S_IRQ_SD_ID);
+
+    _eos_i2s_start_pwm();
+    /*
+    I2S_REG_CK(PWM_CFG)         = PWM_CFG_ENALWAYS | PWM_CFG_ZEROCMP | I2S_PWM_SCALE_CK;
+    I2S_REG_WS_MIC(PWM_CFG)     = PWM_CFG_ENALWAYS | PWM_CFG_ZEROCMP | PWM_CFG_CMP2GANG;
+    I2S_REG_WS_SPK(PWM_CFG)     = PWM_CFG_ENALWAYS | PWM_CFG_ZEROCMP | PWM_CFG_CMP1GANG;
+    */
+
+    GPIO_REG(GPIO_INPUT_EN)     |=  (1 << I2S_PIN_SD_IN);
+    GPIO_REG(GPIO_OUTPUT_VAL)   |=  (1 << I2S_PIN_CK_SR);
+
+    GPIO_REG(GPIO_IOF_SEL)      |=  (1 << I2S_PIN_CK);
+    GPIO_REG(GPIO_IOF_EN)       |=  (1 << I2S_PIN_CK);
+
+    GPIO_REG(GPIO_IOF_SEL)      |=  (1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_IOF_EN)       |=  (1 << I2S_PIN_CK_SW);
+
+    GPIO_REG(GPIO_IOF_SEL)      |=  (1 << I2S_PIN_WS_MIC);
+    GPIO_REG(GPIO_IOF_EN)       |=  (1 << I2S_PIN_WS_MIC);
+
+    GPIO_REG(GPIO_IOF_SEL)      |=  (1 << I2S_PIN_WS_SPK);
+    GPIO_REG(GPIO_IOF_EN)       |=  (1 << I2S_PIN_WS_SPK);
+}
+
+void eos_i2s_stop(void) {
+    I2S_REG_CK(PWM_CFG)         = 0;
+    I2S_REG_WS_MIC(PWM_CFG)     = 0;
+    I2S_REG_WS_SPK(PWM_CFG)     = 0;
+    I2S_REG_CK(PWM_COUNT)       = 0;
+    I2S_REG_WS_MIC(PWM_COUNT)   = 0;
+    I2S_REG_WS_SPK(PWM_COUNT)   = 0;
+
+    _eos_i2s_mic_evt_enable = 0;
+    _eos_i2s_spk_evt_enable = 0;
+    eos_intr_set_priority(I2S_IRQ_WS_ID, 0);
+    eos_intr_set_priority(I2S_IRQ_SD_ID, 0);
+    eos_intr_disable(I2S_IRQ_WS_ID);
+    eos_intr_disable(I2S_IRQ_SD_ID);
+
+    GPIO_REG(GPIO_IOF_EN)       &= ~(1 << I2S_PIN_CK);
+    GPIO_REG(GPIO_IOF_SEL)      &= ~(1 << I2S_PIN_CK);
+
+    GPIO_REG(GPIO_IOF_EN)       &= ~(1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_IOF_SEL)      &= ~(1 << I2S_PIN_CK_SW);
+
+    GPIO_REG(GPIO_IOF_EN)       &= ~(1 << I2S_PIN_WS_MIC);
+    GPIO_REG(GPIO_IOF_SEL)      &= ~(1 << I2S_PIN_WS_MIC);
+
+    GPIO_REG(GPIO_IOF_EN)       &= ~(1 << I2S_PIN_WS_SPK);
+    GPIO_REG(GPIO_IOF_SEL)      &= ~(1 << I2S_PIN_WS_SPK);
+
+    GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << I2S_PIN_SD_IN);
+
+    GPIO_REG(GPIO_OUTPUT_VAL)   |=  (1 << I2S_PIN_CK_SW);
+    GPIO_REG(GPIO_OUTPUT_VAL)   &= ~((1 << I2S_PIN_CK) | (1 << I2S_PIN_CK_SR) | (1 << I2S_PIN_WS_MIC) | (1 << I2S_PIN_WS_SPK));
+}
+
+void eos_i2s_mic_init(uint8_t *mic_arr, uint16_t mic_arr_size) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    _abuf_init(&_eos_i2s_mic_buf, mic_arr, mic_arr_size);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_i2s_mic_set_handler(eos_i2s_handler_t wm_handler) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    i2s_mic_handler = wm_handler;
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_i2s_mic_set_wm(uint16_t wm) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    _eos_i2s_mic_wm = wm;
+    set_csr(mstatus, MSTATUS_MIE);
+
+}
+
+uint16_t eos_i2s_mic_len(void) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    uint16_t ret = _abuf_len(&_eos_i2s_mic_buf);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+uint16_t eos_i2s_mic_read(uint8_t *sample, uint16_t ssize) {
+    uint16_t i;
+    uint16_t _ssize = 0;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    _ssize = MIN(ssize, _abuf_len(&_eos_i2s_mic_buf));
+    set_csr(mstatus, MSTATUS_MIE);
+
+    for (i=0; i<_ssize; i++) {
+        sample[i] = _eos_i2s_mic_buf.array[EOS_ABUF_IDX_MASK(_eos_i2s_mic_buf.idx_r + i, _eos_i2s_mic_buf.size)];
+    }
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    _eos_i2s_mic_buf.idx_r += _ssize;
+    set_csr(mstatus, MSTATUS_MIE);
+
+    return _ssize;
+}
+
+int eos_i2s_mic_pop8(uint8_t *sample) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    int ret = _abuf_pop8(&_eos_i2s_mic_buf, sample);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+int eos_i2s_mic_pop16(uint16_t *sample) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    int ret = _abuf_pop16(&_eos_i2s_mic_buf, sample);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+int eos_i2s_mic_vol_get(void) {
+    return i2s_mic_volume;
+}
+
+void eos_i2s_mic_vol_set(int vol) {
+    if ((vol < 0) || (vol > 8)) return;
+
+    i2s_mic_volume = vol;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    _mic_vol_set(vol);
+    _spk_vol_set(i2s_spk_volume);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_i2s_spk_init(uint8_t *spk_arr, uint16_t spk_arr_size) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    _abuf_init(&_eos_i2s_spk_buf, spk_arr, spk_arr_size);
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_i2s_spk_set_handler(eos_i2s_handler_t wm_handler) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    i2s_spk_handler = wm_handler;
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_i2s_spk_set_wm(uint16_t wm) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    _eos_i2s_spk_wm = wm;
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+uint16_t eos_i2s_spk_len(void) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    uint16_t ret = _abuf_len(&_eos_i2s_spk_buf);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+uint16_t eos_i2s_spk_write(uint8_t *sample, uint16_t ssize) {
+    uint16_t i;
+    uint16_t _ssize = 0;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    _ssize = MIN(ssize, _eos_i2s_spk_buf.size - _abuf_len(&_eos_i2s_spk_buf));
+    set_csr(mstatus, MSTATUS_MIE);
+
+    for (i=0; i<_ssize; i++) {
+        _eos_i2s_spk_buf.array[EOS_ABUF_IDX_MASK(_eos_i2s_spk_buf.idx_w + i, _eos_i2s_spk_buf.size)] = sample[i];
+    }
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    _eos_i2s_spk_buf.idx_w += _ssize;
+    set_csr(mstatus, MSTATUS_MIE);
+
+    return _ssize;
+}
+
+int eos_i2s_spk_push8(uint8_t sample) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    int ret = _abuf_push8(&_eos_i2s_spk_buf, sample);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+int eos_i2s_spk_push16(uint16_t sample) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    int ret = _abuf_push16(&_eos_i2s_spk_buf, sample);
+    set_csr(mstatus, MSTATUS_MIE);
+    return ret;
+}
+
+int eos_i2s_spk_vol_get(void) {
+    return i2s_spk_volume;
+}
+
+void eos_i2s_spk_vol_set(int vol) {
+    if ((vol < 0) || (vol > 16)) return;
+
+    i2s_spk_volume = vol;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    _spk_vol_set(vol);
+    set_csr(mstatus, MSTATUS_MIE);
+}
diff --git a/fw/fe310/eos/i2s.h b/fw/fe310/eos/i2s.h
new file mode 100644
index 0000000..47dc3e2
--- /dev/null
+++ b/fw/fe310/eos/i2s.h
@@ -0,0 +1,34 @@
+#include <stdint.h>
+
+#include "i2s_def.h"
+
+typedef struct EOSABuf {
+    uint16_t idx_r;
+    uint16_t idx_w;
+    uint16_t size;
+    uint8_t *array;
+} EOSABuf;
+
+typedef void (*eos_i2s_handler_t) (unsigned char);
+
+void eos_i2s_init(void);
+void eos_i2s_start(uint32_t sample_rate, unsigned char fmt);
+void eos_i2s_stop(void);
+void eos_i2s_mic_init(uint8_t *mic_arr, uint16_t mic_arr_size);
+void eos_i2s_mic_set_handler(eos_i2s_handler_t wm_handler);
+void eos_i2s_mic_set_wm(uint16_t wm);
+uint16_t eos_i2s_mic_len(void);
+uint16_t eos_i2s_mic_read(uint8_t *sample, uint16_t ssize);
+int eos_i2s_mic_pop8(uint8_t *sample);
+int eos_i2s_mic_pop16(uint16_t *sample);
+int eos_i2s_mic_vol_get(void);
+void eos_i2s_mic_vol_set(int vol);
+void eos_i2s_spk_init(uint8_t *mic_arr, uint16_t mic_arr_size);
+void eos_i2s_spk_set_handler(eos_i2s_handler_t wm_handler);
+void eos_i2s_spk_set_wm(uint16_t wm);
+uint16_t eos_i2s_spk_len(void);
+uint16_t eos_i2s_spk_write(uint8_t *sample, uint16_t ssize);
+int eos_i2s_spk_push8(uint8_t sample);
+int eos_i2s_spk_push16(uint16_t sample);
+int eos_i2s_spk_vol_get(void);
+void eos_i2s_spk_vol_set(int vol);
diff --git a/fw/fe310/eos/i2s_def.h b/fw/fe310/eos/i2s_def.h
new file mode 100644
index 0000000..1af70bb
--- /dev/null
+++ b/fw/fe310/eos/i2s_def.h
@@ -0,0 +1,5 @@
+#define EOS_I2S_FMT_ALAW        0
+#define EOS_I2S_FMT_PCM16       1
+
+#define EOS_I2S_ETYPE_MIC       1
+#define EOS_I2S_ETYPE_SPK       2
diff --git a/fw/fe310/eos/i2s_priv.h b/fw/fe310/eos/i2s_priv.h
new file mode 100644
index 0000000..25237c3
--- /dev/null
+++ b/fw/fe310/eos/i2s_priv.h
@@ -0,0 +1,8 @@
+#define I2S_PWM_SCALE_CK        2
+#define I2S_PWM_SCALE_CK_MASK   0x0003
+
+/* asm */
+#define I2S_ABUF_OFF_IDXR       0
+#define I2S_ABUF_OFF_IDXW       2
+#define I2S_ABUF_OFF_SIZE       4
+#define I2S_ABUF_OFF_ARRAY      8
diff --git a/fw/fe310/eos/interrupt.c b/fw/fe310/eos/interrupt.c
new file mode 100644
index 0000000..820d1fa
--- /dev/null
+++ b/fw/fe310/eos/interrupt.c
@@ -0,0 +1,72 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include "encoding.h"
+#include "platform.h"
+#include "plic_driver.h"
+
+#include "interrupt.h"
+
+// Global Instance data for the PLIC
+// for use by the PLIC Driver.
+static plic_instance_t plic;
+
+static eos_intr_handler_t ext_interrupt_handler[PLIC_NUM_INTERRUPTS];
+
+uintptr_t eos_intr_handle(uintptr_t int_num) {
+    if ((int_num >=1) && (int_num <= PLIC_NUM_INTERRUPTS) && (ext_interrupt_handler[int_num-1])) {
+        ext_interrupt_handler[int_num-1]();
+    } else {
+        printf("error:%d\n", int_num);
+        exit(int_num);
+    }
+    return int_num;
+}
+
+void eos_intr_init(void) {
+    for (int i = 0; i < PLIC_NUM_INTERRUPTS; i++){
+        ext_interrupt_handler[i] = NULL;
+    }
+
+    /**************************************************************************
+    * Set up the PLIC
+    **************************************************************************/
+    PLIC_init(&plic,
+ 	    PLIC_CTRL_ADDR,
+ 	    PLIC_NUM_INTERRUPTS,
+ 	    PLIC_NUM_PRIORITIES);
+
+    // Enable Global (PLIC) interrupts.
+    set_csr(mie, MIP_MEIP);
+
+    // Enable all interrupts
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_intr_set(uint8_t int_num, uint8_t priority, eos_intr_handler_t handler) {
+    ext_interrupt_handler[int_num-1] = handler;
+    PLIC_set_priority(&plic, int_num, priority);
+    PLIC_enable_interrupt(&plic, int_num);
+}
+
+void eos_intr_set_handler(uint8_t int_num, eos_intr_handler_t handler) {
+    ext_interrupt_handler[int_num-1] = handler;
+}
+
+void eos_intr_set_priority(uint8_t int_num, uint8_t priority) {
+    PLIC_set_priority(&plic, int_num, priority);
+}
+
+void eos_intr_enable(uint8_t int_num) {
+    PLIC_enable_interrupt(&plic, int_num);
+}
+
+void eos_intr_disable(uint8_t int_num) {
+    PLIC_disable_interrupt(&plic, int_num);
+}
+
+void eos_intr_mask(uint8_t priority) {
+    PLIC_set_threshold(&plic, priority);
+}
diff --git a/fw/fe310/eos/interrupt.h b/fw/fe310/eos/interrupt.h
new file mode 100644
index 0000000..feaf277
--- /dev/null
+++ b/fw/fe310/eos/interrupt.h
@@ -0,0 +1,13 @@
+#include <stdint.h>
+
+#include "irq_def.h"
+
+typedef void (*eos_intr_handler_t) (void);
+
+void eos_intr_init(void);
+void eos_intr_set(uint8_t int_num, uint8_t priority, eos_intr_handler_t handler);
+void eos_intr_set_handler(uint8_t int_num, eos_intr_handler_t handler);
+void eos_intr_set_priority(uint8_t int_num, uint8_t priority);
+void eos_intr_enable(uint8_t int_num);
+void eos_intr_disable(uint8_t int_num);
+void eos_intr_mask(uint8_t priority);
\ No newline at end of file
diff --git a/fw/fe310/eos/irq_def.h b/fw/fe310/eos/irq_def.h
new file mode 100644
index 0000000..5d9fb1e
--- /dev/null
+++ b/fw/fe310/eos/irq_def.h
@@ -0,0 +1,11 @@
+#define IRQ_PRIORITY_I2S_SD     7
+#define IRQ_PRIORITY_I2S_WS     6
+
+#define IRQ_PRIORITY_SPI_XCHG   5
+
+#define IRQ_PRIORITY_NET_CTS    4
+#define IRQ_PRIORITY_NET_RTS    4
+
+#define IRQ_PRIORITY_UART       1
+
+#define IRQ_PRIORITY_UI         5
diff --git a/fw/fe310/eos/msgq.c b/fw/fe310/eos/msgq.c
new file mode 100644
index 0000000..a483a58
--- /dev/null
+++ b/fw/fe310/eos/msgq.c
@@ -0,0 +1,122 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "eos.h"
+#include "msgq.h"
+
+#define IDX_MASK(IDX, SIZE)     ((IDX) & ((SIZE) - 1))
+#define IDX_HALF                ((uint8_t)1 << (sizeof(uint8_t) * 8 - 1))
+#define IDX_LT(a,b)             ((uint8_t)((uint8_t)(a) - (uint8_t)(b)) > IDX_HALF)
+#define IDX_LTE(a,b)            ((uint8_t)((uint8_t)(b) - (uint8_t)(a)) < IDX_HALF)
+
+void eos_msgq_init(EOSMsgQ *msgq, EOSMsgItem *array, uint8_t size) {
+    msgq->idx_r = 0;
+    msgq->idx_w = 0;
+    msgq->size = size;
+    msgq->array = array;
+}
+
+int eos_msgq_push(EOSMsgQ *msgq, unsigned char type, unsigned char *buffer, uint16_t len) {
+    if ((uint8_t)(msgq->idx_w - msgq->idx_r) == msgq->size) return EOS_ERR_FULL;
+
+    uint8_t idx = IDX_MASK(msgq->idx_w, msgq->size);
+    msgq->array[idx].type = type;
+    msgq->array[idx].buffer = buffer;
+    msgq->array[idx].len = len;
+    msgq->idx_w++;
+    return EOS_OK;
+}
+
+void eos_msgq_pop(EOSMsgQ *msgq, unsigned char *type, unsigned char **buffer, uint16_t *len) {
+    if (msgq->idx_r == msgq->idx_w) {
+        *type = 0;
+        *buffer = NULL;
+        *len = 0;
+    } else {
+        uint8_t idx = IDX_MASK(msgq->idx_r, msgq->size);
+        *type = msgq->array[idx].type;
+        *buffer = msgq->array[idx].buffer;
+        *len = msgq->array[idx].len;
+        msgq->idx_r++;
+    }
+}
+
+int eos_msgq_find(EOSMsgQ *msgq, unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len) {
+    uint8_t i, j, idx;
+    unsigned char *_buffer;
+    uint16_t _len;
+
+    if (msgq->idx_r == msgq->idx_w) {
+        if (buffer && len) {
+            *buffer = NULL;
+            *len = 0;
+        }
+        return 0;
+    }
+
+    idx = IDX_MASK(msgq->idx_r, msgq->size);
+    if (type == msgq->array[idx].type) {
+        _buffer = msgq->array[idx].buffer;
+        _len = msgq->array[idx].len;
+        if ((selector == NULL) || (sel_len == 0) || ((sel_len <= _len) && (memcmp(selector, _buffer, sel_len) == 0))) {
+            msgq->idx_r++;
+            if (buffer && len) {
+                *buffer = _buffer;
+                *len = _len;
+            }
+            return 1;
+        }
+    }
+    for (i = msgq->idx_r + 1; IDX_LT(i, msgq->idx_w); i++) {
+        idx = IDX_MASK(i, msgq->size);
+        if (type== msgq->array[idx].type) {
+            _buffer = msgq->array[idx].buffer;
+            _len = msgq->array[idx].len;
+            if ((selector == NULL) || (sel_len == 0) || ((sel_len <= _len) && (memcmp(selector, _buffer, sel_len) == 0))) {
+                for (j = i + 1; IDX_LT(j, msgq->idx_w); j++) {
+                    msgq->array[IDX_MASK(j - 1, msgq->size)] = msgq->array[IDX_MASK(j, msgq->size)];
+                }
+                msgq->idx_w--;
+                if (buffer && len) {
+                    *buffer = _buffer;
+                    *len = _len;
+                }
+                return 1;
+            }
+        }
+    }
+    if (buffer && len) {
+        *buffer = NULL;
+        *len = 0;
+    }
+    return 0;
+}
+
+uint8_t eos_msgq_len(EOSMsgQ *msgq) {
+    return (uint8_t)(msgq->idx_w - msgq->idx_r);
+}
+
+void eos_bufq_init(EOSBufQ *bufq, unsigned char **array, uint8_t size) {
+    bufq->idx_r = 0;
+    bufq->idx_w = 0;
+    bufq->size = size;
+    bufq->array = array;
+}
+
+int eos_bufq_push(EOSBufQ *bufq, unsigned char *buffer) {
+    if ((uint8_t)(bufq->idx_w - bufq->idx_r) == bufq->size) return EOS_ERR_FULL;
+
+    bufq->array[IDX_MASK(bufq->idx_w++, bufq->size)] = buffer;
+    return EOS_OK;
+}
+
+unsigned char *eos_bufq_pop(EOSBufQ *bufq) {
+    if (bufq->idx_r == bufq->idx_w) return NULL;
+
+    return bufq->array[IDX_MASK(bufq->idx_r++, bufq->size)];
+}
+
+uint8_t eos_bufq_len(EOSBufQ *bufq) {
+    return (uint8_t)(bufq->idx_w - bufq->idx_r);
+}
diff --git a/fw/fe310/eos/msgq.h b/fw/fe310/eos/msgq.h
new file mode 100644
index 0000000..7e3b5e5
--- /dev/null
+++ b/fw/fe310/eos/msgq.h
@@ -0,0 +1,32 @@
+#include <stdint.h>
+
+typedef struct EOSMsgItem {
+    unsigned char type;
+    unsigned char *buffer;
+    uint16_t len;
+} EOSMsgItem;
+
+typedef struct EOSMsgQ {
+    uint8_t idx_r;
+    uint8_t idx_w;
+    uint8_t size;
+    EOSMsgItem *array;
+} EOSMsgQ;
+
+void eos_msgq_init(EOSMsgQ *msgq, EOSMsgItem *array, uint8_t size);
+int eos_msgq_push(EOSMsgQ *msgq, unsigned char type, unsigned char *buffer, uint16_t len);
+void eos_msgq_pop(EOSMsgQ *msgq, unsigned char *type, unsigned char **buffer, uint16_t *len);
+int eos_msgq_find(EOSMsgQ *msgq, unsigned char type, unsigned char *selector, uint16_t sel_len, unsigned char **buffer, uint16_t *len);
+uint8_t eos_msgq_len(EOSMsgQ *msgq);
+
+typedef struct EOSBufQ {
+    uint8_t idx_r;
+    uint8_t idx_w;
+    uint8_t size;
+    unsigned char **array;
+} EOSBufQ;
+
+void eos_bufq_init(EOSBufQ *bufq, unsigned char **array, uint8_t size);
+int eos_bufq_push(EOSBufQ *bufq, unsigned char *buffer);
+unsigned char *eos_bufq_pop(EOSBufQ *bufq);
+uint8_t eos_bufq_len(EOSBufQ *bufq);
diff --git a/fw/fe310/eos/msgq_priv.h b/fw/fe310/eos/msgq_priv.h
new file mode 100644
index 0000000..2ad5fc5
--- /dev/null
+++ b/fw/fe310/eos/msgq_priv.h
@@ -0,0 +1,10 @@
+/* asm */
+#define MSGQ_OFF_IDXR       0
+#define MSGQ_OFF_IDXW       1
+#define MSGQ_OFF_SIZE       2
+#define MSGQ_OFF_ARRAY      4
+
+#define MSGQ_ITEM_OFF_TYPE  0
+#define MSGQ_ITEM_OFF_BUF   4
+#define MSGQ_ITEM_OFF_SIZE  8
+#define MSGQ_ITEM_SIZE      12
diff --git a/fw/fe310/eos/net.c b/fw/fe310/eos/net.c
new file mode 100644
index 0000000..d42686d
--- /dev/null
+++ b/fw/fe310/eos/net.c
@@ -0,0 +1,568 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "eos.h"
+#include "msgq.h"
+#include "interrupt.h"
+#include "event.h"
+#include "timer.h"
+#include "power.h"
+
+#include "board.h"
+
+#include "spi.h"
+#include "spi_priv.h"
+#include "spi_dev.h"
+
+#include "net.h"
+
+#define NET_SIZE_HDR            3
+#define NET_STATE_FLAG_RUN      0x01
+#define NET_STATE_FLAG_INIT     0x02
+#define NET_STATE_FLAG_XCHG     0x04
+#define NET_STATE_FLAG_ONEW     0x10
+#define NET_STATE_FLAG_REPW     0x20
+#define NET_STATE_FLAG_RTS      0x40
+#define NET_STATE_FLAG_CTS      0x80
+
+#define MIN(X, Y)               (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y)               (((X) > (Y)) ? (X) : (Y))
+
+static EOSBufQ net_buf_q;
+static unsigned char *net_bufq_array[EOS_NET_SIZE_BUFQ];
+static unsigned char net_bufq_buffer[EOS_NET_SIZE_BUFQ][EOS_NET_SIZE_BUF];
+
+static EOSMsgQ net_send_q;
+static EOSMsgItem net_sndq_array[EOS_NET_SIZE_BUFQ];
+
+static volatile uint8_t net_state_flags = 0;
+static unsigned char net_state_type = 0;
+static uint32_t net_state_len_tx = 0;
+static uint32_t net_state_len_rx = 0;
+unsigned char *net_state_buf = NULL;
+
+static uint8_t net_state_next_cnt = 0;
+static unsigned char *net_state_next_buf = NULL;
+
+static eos_evt_handler_t net_handler[EOS_NET_MAX_MTYPE];
+static uint16_t net_wrapper_acq[EOS_EVT_MAX_EVT];
+static uint16_t net_flags_acq[EOS_EVT_MAX_EVT];
+
+static int net_xchg_sleep(void) {
+    int i;
+    int rv = EOS_OK;
+    volatile uint32_t x = 0;
+    net_state_flags &= ~NET_STATE_FLAG_CTS;
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
+
+    SPI1_REG(SPI_REG_TXFIFO) = 0xFF;
+    while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+    if (x & 0xFF) rv = EOS_ERR_BUSY;
+
+    for (i=0; i<7; i++) {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = 0;
+        while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+    }
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
+
+    return rv;
+}
+
+static void net_xchg_wake(void) {
+    int i;
+    volatile uint32_t x = 0;
+    net_state_flags &= ~NET_STATE_FLAG_CTS;
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
+
+    for (i=0; i<8; i++) {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = 0;
+        while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+    }
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
+}
+
+static void net_xchg_reset(void) {
+    volatile uint32_t x = 0;
+    net_state_flags &= ~NET_STATE_FLAG_CTS;
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
+
+    SPI1_REG(SPI_REG_TXFIFO) = 0;
+    while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
+}
+
+static void net_xchg_start(unsigned char type, unsigned char *buffer, uint16_t len) {
+    net_state_flags &= ~NET_STATE_FLAG_CTS;
+    net_state_flags |= (NET_STATE_FLAG_INIT | NET_STATE_FLAG_XCHG);
+
+    if (net_state_next_cnt && (net_state_next_buf == NULL)) type |= EOS_NET_MTYPE_FLAG_ONEW;
+    if (type & EOS_NET_MTYPE_FLAG_ONEW) net_state_flags |= NET_STATE_FLAG_ONEW;
+    if (type & EOS_NET_MTYPE_FLAG_REPW) net_state_flags |= NET_STATE_FLAG_REPW;
+
+    net_state_type = type;
+    net_state_len_tx = len;
+    net_state_len_rx = 0;
+    net_state_buf = buffer;
+
+    SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
+    SPI1_REG(SPI_REG_TXFIFO) = type;
+    SPI1_REG(SPI_REG_TXFIFO) = (len >> 8) & 0xFF;
+    SPI1_REG(SPI_REG_TXFIFO) = (len & 0xFF);
+    SPI1_REG(SPI_REG_RXCTRL) = SPI_RXWM(2);
+    SPI1_REG(SPI_REG_IE) = SPI_IP_RXWM;
+}
+
+static int net_xchg_next(unsigned char *_buffer) {
+    unsigned char type;
+    unsigned char *buffer = NULL;
+    uint16_t len;
+    int ret = _buffer ? 1 : 0;
+
+    eos_msgq_pop(&net_send_q, &type, &buffer, &len);
+    if (type) {
+        net_xchg_start(type, buffer, len);
+    } else if (net_state_flags & NET_STATE_FLAG_RTS) {
+        if (_buffer) {
+            buffer = _buffer;
+            ret = 0;
+        } else {
+            buffer = eos_bufq_pop(&net_buf_q);
+        }
+        if (buffer) net_xchg_start(0, buffer, 0);
+    }
+
+    return ret;
+}
+
+static void net_handle_xchg(void) {
+    volatile uint32_t r1, r2, r3;
+    uint32_t len;
+
+    if (net_state_flags & NET_STATE_FLAG_INIT) {
+        net_state_flags &= ~NET_STATE_FLAG_INIT;
+
+        r1 = SPI1_REG(SPI_REG_RXFIFO);
+        r2 = SPI1_REG(SPI_REG_RXFIFO);
+        r3 = SPI1_REG(SPI_REG_RXFIFO);
+
+        if (net_state_flags & (NET_STATE_FLAG_ONEW | NET_STATE_FLAG_REPW)) {
+            r1 = 0;
+            r2 = 0;
+            r3 = 0;
+        }
+
+        net_state_type    = (r1 & 0xFF);
+        net_state_len_rx  = (r2 & 0xFF) << 8;
+        net_state_len_rx |= (r3 & 0xFF);
+        len = MAX(net_state_len_tx, net_state_len_rx);
+
+        if (len > EOS_NET_MTU) {
+            net_state_flags &= ~NET_STATE_FLAG_XCHG;
+            SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
+            SPI1_REG(SPI_REG_IE) = 0x0;
+            return;
+        }
+
+        // esp32 dma workaraund
+        if (len < 8 - NET_SIZE_HDR) {
+            len = 8 - NET_SIZE_HDR;
+        } else if ((len + NET_SIZE_HDR) % 4 != 0) {
+            len = ((len + NET_SIZE_HDR)/4 + 1) * 4 - NET_SIZE_HDR;
+        }
+
+        _eos_spi_xchg_init(net_state_buf, len, 0);
+        SPI1_REG(SPI_REG_TXCTRL) = SPI_TXWM(SPI_SIZE_WM);
+        SPI1_REG(SPI_REG_IE) = SPI_IP_TXWM;
+        return;
+    }
+
+    eos_spi_handle_xchg();
+    if (SPI1_REG(SPI_REG_CSMODE) == SPI_CSMODE_AUTO) {  // exchange done
+        if (net_state_flags & NET_STATE_FLAG_REPW) {
+            net_state_flags &= ~NET_STATE_FLAG_REPW;
+        } else {
+            if (net_state_type) {
+                int r = eos_evtq_push_isr(EOS_EVT_NET | net_state_type, net_state_buf, net_state_len_rx);
+                if (r) eos_bufq_push(&net_buf_q, net_state_buf);
+            } else if (((net_state_flags & NET_STATE_FLAG_ONEW) || net_state_next_cnt) && (net_state_next_buf == NULL)) {
+                net_state_next_buf = net_state_buf;
+                net_state_flags &= ~NET_STATE_FLAG_ONEW;
+            } else {
+                eos_bufq_push(&net_buf_q, net_state_buf);
+            }
+        }
+        net_state_flags &= ~NET_STATE_FLAG_XCHG;
+    }
+}
+
+static void net_handle_cts(void) {
+    GPIO_REG(GPIO_RISE_IP) = (1 << NET_PIN_CTS);
+    net_state_flags |= NET_STATE_FLAG_CTS;
+
+    if (net_state_flags & NET_STATE_FLAG_RUN) {
+        net_xchg_next(NULL);
+    }
+}
+
+static void net_handle_rts(void) {
+    uint32_t rts_offset = (1 << NET_PIN_RTS);
+    if (GPIO_REG(GPIO_RISE_IP) & rts_offset) {
+        GPIO_REG(GPIO_RISE_IP) = rts_offset;
+        net_state_flags |= NET_STATE_FLAG_RTS;
+        if ((net_state_flags & NET_STATE_FLAG_RUN) && (net_state_flags & NET_STATE_FLAG_CTS)) {
+            net_xchg_reset();
+        }
+    } else if (GPIO_REG(GPIO_FALL_IP) & rts_offset) {
+        GPIO_REG(GPIO_FALL_IP) = rts_offset;
+        net_state_flags &= ~NET_STATE_FLAG_RTS;
+    }
+}
+
+static void net_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char idx = (type & ~EOS_EVT_MASK) - 1;
+
+    if (idx < EOS_NET_MAX_MTYPE) {
+        net_handler[idx](type, buffer, len);
+    } else {
+        eos_net_bad_handler(type, buffer, len);
+    }
+}
+
+static int net_acquire(unsigned char reserved) {
+    int ret = 0;
+
+    if (reserved) {
+        while (!ret) {
+            clear_csr(mstatus, MSTATUS_MIE);
+            if (net_state_next_buf) {
+                ret = 1;
+                net_state_next_cnt--;
+            } else {
+                asm volatile ("wfi");
+            }
+            set_csr(mstatus, MSTATUS_MIE);
+        }
+    } else {
+        clear_csr(mstatus, MSTATUS_MIE);
+        if (net_state_next_buf == NULL) net_state_next_buf = eos_bufq_pop(&net_buf_q);
+        ret = (net_state_next_buf != NULL);
+        if (!ret) net_state_next_cnt++;
+        set_csr(mstatus, MSTATUS_MIE);
+    }
+    return ret;
+}
+
+static void evt_handler_wrapper(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char idx, uint16_t flag) {
+    int ok;
+
+    ok = net_acquire(net_wrapper_acq[idx] & flag);
+    if (ok) {
+        eos_evtq_get_handler(type)(type, buffer, len);
+        eos_net_release();
+        net_wrapper_acq[idx] &= ~flag;
+    } else {
+        net_wrapper_acq[idx] |= flag;
+        eos_evtq_push(type, buffer, len);
+    }
+}
+
+static void evt_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char idx = (type & EOS_EVT_MASK) >> 4;
+
+    if (idx && (idx <= EOS_EVT_MAX_EVT)) {
+        uint16_t flag = (uint16_t)1 << (type & ~EOS_EVT_MASK);
+
+        idx--;
+        if (flag & net_flags_acq[idx]) {
+            evt_handler_wrapper(type, buffer, len, idx, flag);
+        } else {
+            eos_evtq_get_handler(type)(type, buffer, len);
+        }
+    } else {
+        eos_evtq_bad_handler(type, buffer, len);
+    }
+}
+
+static void net_pause(void) {
+    net_state_flags &= ~NET_STATE_FLAG_RUN;
+}
+
+static void net_resume(void) {
+    net_state_flags |= NET_STATE_FLAG_RUN;
+    if (net_state_flags & NET_STATE_FLAG_CTS) {
+        net_xchg_next(NULL);
+    }
+}
+
+void eos_net_init(void) {
+    int i;
+
+    eos_msgq_init(&net_send_q, net_sndq_array, EOS_NET_SIZE_BUFQ);
+    eos_bufq_init(&net_buf_q, net_bufq_array, EOS_NET_SIZE_BUFQ);
+    for (i=0; i<EOS_NET_SIZE_BUFQ; i++) {
+        eos_bufq_push(&net_buf_q, net_bufq_buffer[i]);
+    }
+
+    for (i=0; i<EOS_NET_MAX_MTYPE; i++) {
+        net_handler[i] = eos_net_bad_handler;
+    }
+    eos_evtq_set_handler(0, evt_handler);
+    eos_evtq_set_handler(EOS_EVT_NET, net_handle_evt);
+
+    GPIO_REG(GPIO_INPUT_EN)     |=  (1 << NET_PIN_CTS);
+    GPIO_REG(GPIO_OUTPUT_EN)    &= ~(1 << NET_PIN_CTS);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << NET_PIN_CTS);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << NET_PIN_CTS);
+
+    GPIO_REG(GPIO_RISE_IE)      |=  (1 << NET_PIN_CTS);
+    eos_intr_set(INT_GPIO_BASE + NET_PIN_CTS, IRQ_PRIORITY_NET_CTS, net_handle_cts);
+
+    GPIO_REG(GPIO_INPUT_EN)     |=  (1 << NET_PIN_RTS);
+    GPIO_REG(GPIO_OUTPUT_EN)    &= ~(1 << NET_PIN_RTS);
+    GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << NET_PIN_RTS);
+    GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << NET_PIN_RTS);
+
+    GPIO_REG(GPIO_RISE_IE)      |=  (1 << NET_PIN_RTS);
+    GPIO_REG(GPIO_FALL_IE)      |=  (1 << NET_PIN_RTS);
+    eos_intr_set(INT_GPIO_BASE + NET_PIN_RTS, IRQ_PRIORITY_NET_RTS, net_handle_rts);
+
+    /* set initial state */
+    clear_csr(mstatus, MSTATUS_MIE);
+    if (GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_CTS)) net_state_flags |= NET_STATE_FLAG_CTS;
+    if (GPIO_REG(GPIO_INPUT_VAL) & (1 << NET_PIN_RTS)) net_state_flags |= NET_STATE_FLAG_RTS;
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_net_start(uint8_t wakeup_cause) {
+    eos_intr_set_handler(INT_SPI1_BASE, net_handle_xchg);
+    SPI1_REG(SPI_REG_SCKDIV) = eos_spi_div(EOS_SPI_DEV_NET);
+    SPI1_REG(SPI_REG_CSID) = eos_spi_csid(EOS_SPI_DEV_NET);
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    if (wakeup_cause) {
+        if (wakeup_cause != EOS_PWR_WAKE_BTN) {
+            net_xchg_wake();
+        }
+        if (!(net_state_flags & NET_STATE_FLAG_CTS)) {
+            while (!(GPIO_REG(GPIO_RISE_IP) & (1 << NET_PIN_CTS))) {
+                asm volatile ("wfi");
+            }
+            GPIO_REG(GPIO_RISE_IP) = (1 << NET_PIN_CTS);
+        }
+        net_xchg_reset();
+    }
+    net_resume();
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+void eos_net_stop(void) {
+    uint8_t done = 0;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    if (net_state_flags & NET_STATE_FLAG_RUN) {
+        net_state_flags &= ~NET_STATE_FLAG_RUN;
+        done = !(net_state_flags & NET_STATE_FLAG_XCHG);
+    } else {
+        done = 1;
+    }
+    set_csr(mstatus, MSTATUS_MIE);
+
+    while (!done) {
+        clear_csr(mstatus, MSTATUS_MIE);
+        done = !(net_state_flags & NET_STATE_FLAG_XCHG);
+        if (!done) asm volatile ("wfi");
+        set_csr(mstatus, MSTATUS_MIE);
+    }
+}
+
+int eos_net_sleep(uint32_t timeout) {
+    volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+    uint64_t then_ms = timeout + *mtime * 1000 / EOS_TIMER_RTC_FREQ;
+    uint8_t done = 0;
+    int rv = EOS_OK;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    if (!(net_state_flags & NET_STATE_FLAG_RUN)) rv = EOS_ERR;
+    set_csr(mstatus, MSTATUS_MIE);
+
+    if (rv) return rv;
+
+    do {
+        if (*mtime * 1000 / EOS_TIMER_RTC_FREQ > then_ms) return EOS_ERR_TIMEOUT;
+        clear_csr(mstatus, MSTATUS_MIE);
+        eos_evtq_flush_isr();
+        done = (eos_msgq_len(&net_send_q) == 0);
+        done = done && (!(net_state_flags & NET_STATE_FLAG_RTS) && (net_state_flags & NET_STATE_FLAG_CTS));
+        if (done) done = (net_xchg_sleep() == EOS_OK);
+        if (!done) {
+            asm volatile ("wfi");
+            set_csr(mstatus, MSTATUS_MIE);
+        }
+    } while (!done);
+
+    while (!(GPIO_REG(GPIO_RISE_IP) & (1 << NET_PIN_CTS))) {
+        if (*mtime * 1000 / EOS_TIMER_RTC_FREQ > then_ms) {
+            rv = EOS_ERR_TIMEOUT;
+            break;
+        }
+        asm volatile ("wfi");
+    }
+
+    if (!rv) {
+        GPIO_REG(GPIO_RISE_IP) = (1 << NET_PIN_CTS);
+        net_state_flags &= ~NET_STATE_FLAG_RUN;
+    }
+
+    set_csr(mstatus, MSTATUS_MIE);
+
+    return rv;
+}
+
+void eos_net_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len) {
+    eos_evtq_bad_handler(type, buffer, len);
+    if (buffer) eos_net_free(buffer, 0);
+}
+
+void eos_net_set_handler(unsigned char mtype, eos_evt_handler_t handler) {
+    if (handler == NULL) handler = eos_net_bad_handler;
+    if (mtype && (mtype <= EOS_NET_MAX_MTYPE)) net_handler[mtype - 1] = handler;
+}
+
+void eos_net_acquire_for_evt(unsigned char type, char acq) {
+    unsigned char idx = (type & EOS_EVT_MASK) >> 4;
+    uint16_t flag = type & ~EOS_EVT_MASK ? (uint16_t)1 << (type & ~EOS_EVT_MASK) : 0xFFFF;
+
+    if (idx && (idx <= EOS_EVT_MAX_EVT)) {
+        idx--;
+        net_flags_acq[idx] &= ~flag;
+        if (acq) net_flags_acq[idx] |= flag;
+    }
+}
+
+void eos_net_acquire(void) {
+    unsigned char acq = net_acquire(0);
+    if (!acq) net_acquire(1);
+}
+
+void eos_net_release(void) {
+    clear_csr(mstatus, MSTATUS_MIE);
+    if (!net_state_next_cnt && net_state_next_buf) {
+        eos_bufq_push(&net_buf_q, net_state_next_buf);
+        net_state_next_buf = NULL;
+    }
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+unsigned char *eos_net_alloc(void) {
+    unsigned char *ret = NULL;
+
+    while (!ret) {
+        clear_csr(mstatus, MSTATUS_MIE);
+        if (net_state_next_buf) {
+            ret = net_state_next_buf;
+            net_state_next_buf = NULL;
+        } else {
+            asm volatile ("wfi");
+        }
+        set_csr(mstatus, MSTATUS_MIE);
+    }
+
+    return ret;
+}
+
+void eos_net_free(unsigned char *buffer, unsigned char more) {
+    uint8_t do_release = 1;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    if ((more || net_state_next_cnt) && (net_state_next_buf == NULL)) {
+        net_state_next_buf = buffer;
+    } else {
+        if ((net_state_flags & NET_STATE_FLAG_RUN) && (net_state_flags & NET_STATE_FLAG_CTS)) {
+            do_release = net_xchg_next(buffer);
+        }
+        if (do_release) {
+            eos_bufq_push(&net_buf_q, buffer);
+        }
+    }
+    set_csr(mstatus, MSTATUS_MIE);
+}
+
+static int net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len) {
+    int rv = EOS_OK;
+    int _sync = 0;
+    unsigned char _type = *type;
+    uint16_t _len = *len;
+    uint8_t spi_dev = EOS_SPI_DEV_NET;
+
+    clear_csr(mstatus, MSTATUS_MIE);
+    if ((_type & EOS_NET_MTYPE_FLAG_REPW) || ((_type & EOS_NET_MTYPE_FLAG_ONEW) && !(net_state_flags & NET_STATE_FLAG_RUN))) _sync = 1;
+
+    if (!(net_state_flags & NET_STATE_FLAG_RUN) && _sync) {
+        int _rv;
+
+        set_csr(mstatus, MSTATUS_MIE);
+        spi_dev = eos_spi_dev();
+        _rv = eos_spi_deselect();
+        if (_rv) return _rv;
+        clear_csr(mstatus, MSTATUS_MIE);
+    }
+
+    if (_sync) {
+        net_pause();
+        while (!(net_state_flags & NET_STATE_FLAG_CTS)) {
+            asm volatile ("wfi");
+            set_csr(mstatus, MSTATUS_MIE);
+            clear_csr(mstatus, MSTATUS_MIE);
+        }
+        net_xchg_start(_type, buffer, _len);
+        if (_type & EOS_NET_MTYPE_FLAG_REPW) {
+            while (!(net_state_flags & NET_STATE_FLAG_CTS)) {
+                asm volatile ("wfi");
+                set_csr(mstatus, MSTATUS_MIE);
+                clear_csr(mstatus, MSTATUS_MIE);
+            }
+            net_xchg_start(0, buffer, 0);
+            while (net_state_flags & NET_STATE_FLAG_XCHG) {
+                asm volatile ("wfi");
+                set_csr(mstatus, MSTATUS_MIE);
+                clear_csr(mstatus, MSTATUS_MIE);
+            }
+            *type = net_state_type;
+            *len = net_state_len_rx;
+        }
+        net_resume();
+    } else {
+        if ((net_state_flags & NET_STATE_FLAG_RUN) && (net_state_flags & NET_STATE_FLAG_CTS)) {
+            net_xchg_start(_type, buffer, _len);
+        } else {
+            rv = eos_msgq_push(&net_send_q, _type, buffer, _len);
+            if (rv) eos_bufq_push(&net_buf_q, buffer);
+        }
+    }
+
+    set_csr(mstatus, MSTATUS_MIE);
+    if (spi_dev != EOS_SPI_DEV_NET) eos_spi_select(spi_dev);
+
+    return rv;
+}
+
+int eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char more) {
+    if (more) type |= EOS_NET_MTYPE_FLAG_ONEW;
+    return net_xchg(&type, buffer, &len);
+}
+
+int eos_net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len) {
+    *type |= EOS_NET_MTYPE_FLAG_REPW;
+    return net_xchg(type, buffer, len);
+}
diff --git a/fw/fe310/eos/net.h b/fw/fe310/eos/net.h
new file mode 100644
index 0000000..574d179
--- /dev/null
+++ b/fw/fe310/eos/net.h
@@ -0,0 +1,39 @@
+#include <stdint.h>
+#include "event.h"
+
+/* common */
+#define EOS_NET_MTU                 1500
+#define EOS_NET_SIZE_BUF            (EOS_NET_MTU + 4)
+
+#define EOS_NET_MTYPE_SOCK          1
+#define EOS_NET_MTYPE_POWER         4
+
+#define EOS_NET_MTYPE_WIFI          5
+#define EOS_NET_MTYPE_CELL          6
+#define EOS_NET_MTYPE_SIP           7
+#define EOS_NET_MTYPE_APP           8
+
+#define EOS_NET_MAX_MTYPE           8
+
+#define EOS_NET_MTYPE_FLAG_ONEW     0x40
+#define EOS_NET_MTYPE_FLAG_REPW     0x80
+#define EOS_NET_MTYPE_FLAG_MASK     0xc0
+
+/* fe310 specific */
+#define EOS_NET_SIZE_BUFQ           2
+
+void eos_net_init(void);
+void eos_net_start(uint8_t wakeup_cause);
+void eos_net_stop(void);
+int eos_net_sleep(uint32_t timeout);
+
+void eos_net_bad_handler(unsigned char type, unsigned char *buffer, uint16_t len);
+void eos_net_set_handler(unsigned char type, eos_evt_handler_t handler);
+void eos_net_acquire_for_evt(unsigned char type, char acq);
+
+void eos_net_acquire(void);
+void eos_net_release(void);
+unsigned char *eos_net_alloc(void);
+void eos_net_free(unsigned char *buffer, unsigned char more);
+int eos_net_send(unsigned char type, unsigned char *buffer, uint16_t len, unsigned char more);
+int eos_net_xchg(unsigned char *type, unsigned char *buffer, uint16_t *len);
diff --git a/fw/fe310/eos/power.c b/fw/fe310/eos/power.c
new file mode 100644
index 0000000..5f44a94
--- /dev/null
+++ b/fw/fe310/eos/power.c
@@ -0,0 +1,119 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "eos.h"
+#include "event.h"
+#include "timer.h"
+#include "spi.h"
+#include "spi_dev.h"
+#include "net.h"
+#include "eve/eve.h"
+
+#include "power.h"
+
+#define PWR_RTC_SCALE   15
+#define PWR_RTC_SFREQ   (EOS_TIMER_RTC_FREQ >> PWR_RTC_SCALE)
+
+static eos_evt_handler_t evt_handler[EOS_PWR_MAX_MTYPE];
+static unsigned char power_btn_down;
+
+static void power_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char mtype;
+
+    if ((buffer == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, buffer, len);
+        return;
+    }
+
+    mtype = buffer[0];
+    if ((mtype < EOS_PWR_MAX_MTYPE) && evt_handler[mtype]) {
+        evt_handler[mtype](mtype, buffer, len);
+    } else {
+        eos_net_bad_handler(type, buffer, len);
+    }
+}
+
+static void power_handle_btn(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char level = buffer[1];
+
+    eos_net_free(buffer, 0);
+    if (!level) {
+        power_btn_down = 1;
+        return;
+    }
+    if (!power_btn_down) return;
+
+    eos_power_sleep();
+}
+
+void eos_power_init(void) {
+    int i;
+
+    for (i=0; i<EOS_PWR_MAX_MTYPE; i++) {
+        evt_handler[i] = NULL;
+    }
+    eos_net_set_handler(EOS_NET_MTYPE_POWER, power_handle_msg);
+    eos_power_set_handler(EOS_PWR_MTYPE_BUTTON, power_handle_btn);
+
+    AON_REG(AON_PMUKEY) = 0x51F15E;
+    AON_REG(AON_PMUIE) = 0x5;
+
+    AON_REG(AON_RTCCMP) = 0xFFFFFFFF;
+    AON_REG(AON_RTCCFG) = PWR_RTC_SCALE;
+    AON_REG(AON_RTCHI) = 0;
+    AON_REG(AON_RTCLO) = 0;
+}
+
+uint8_t eos_power_wakeup_cause(void) {
+    return AON_REG(AON_PMUCAUSE) & 0xff;
+}
+
+uint8_t eos_power_reset_cause(void) {
+    return (AON_REG(AON_PMUCAUSE) >> 8) & 0xff;
+}
+
+void eos_power_sleep(void) {
+    eos_spi_select(EOS_SPI_DEV_EVE);
+    eve_sleep();
+    eos_spi_deselect();
+    eos_net_sleep(1000);
+
+    AON_REG(AON_PMUKEY) = 0x51F15E;
+    AON_REG(AON_PMUSLEEP) = 1;
+}
+
+void eos_power_wake_at(uint32_t msec) {
+    uint32_t pmuie;
+
+    AON_REG(AON_RTCCFG) |= AON_RTCCFG_ENALWAYS;
+    AON_REG(AON_RTCCMP) = msec * PWR_RTC_SFREQ / 1000;
+
+    pmuie = AON_REG(AON_PMUIE) | 0x2;
+    AON_REG(AON_PMUKEY) = 0x51F15E;
+    AON_REG(AON_PMUIE) = pmuie;
+}
+
+void eos_power_wake_disable(void) {
+    uint32_t pmuie;
+
+    AON_REG(AON_RTCCMP) = 0xFFFFFFFF;
+    AON_REG(AON_RTCCFG) &= ~AON_RTCCFG_ENALWAYS;
+    AON_REG(AON_RTCHI) = 0;
+    AON_REG(AON_RTCLO) = 0;
+
+    pmuie = AON_REG(AON_PMUIE) & ~0x2;
+    AON_REG(AON_PMUKEY) = 0x51F15E;
+    AON_REG(AON_PMUIE) = pmuie;
+}
+
+void eos_power_set_handler(unsigned char mtype, eos_evt_handler_t handler) {
+    if (mtype < EOS_PWR_MAX_MTYPE) evt_handler[mtype] = handler;
+}
+
+eos_evt_handler_t eos_power_get_handler(unsigned char mtype) {
+    if (mtype < EOS_PWR_MAX_MTYPE) return evt_handler[mtype];
+    return NULL;
+}
diff --git a/fw/fe310/eos/power.h b/fw/fe310/eos/power.h
new file mode 100644
index 0000000..3eee817
--- /dev/null
+++ b/fw/fe310/eos/power.h
@@ -0,0 +1,23 @@
+#include <stdint.h>
+#include "event.h"
+
+#define EOS_PWR_MTYPE_BUTTON    1
+
+#define EOS_PWR_MAX_MTYPE       2
+
+#define EOS_PWR_WAKE_RST        0
+#define EOS_PWR_WAKE_RTC        1
+#define EOS_PWR_WAKE_BTN        2
+
+#define EOS_PWR_RST_PWRON       0
+#define EOS_PWR_RST_EXT         1
+#define EOS_PWR_RST_WDOG        2
+
+void eos_power_init(void);
+uint8_t eos_power_wakeup_cause(void);
+uint8_t eos_power_reset_cause(void);
+void eos_power_sleep(void);
+void eos_power_wake_at(uint32_t msec);
+void eos_power_wake_disable(void);
+void eos_power_set_handler(unsigned char mtype, eos_evt_handler_t handler);
+eos_evt_handler_t eos_power_get_handler(unsigned char mtype);
\ No newline at end of file
diff --git a/fw/fe310/eos/sdc_crypto.c b/fw/fe310/eos/sdc_crypto.c
new file mode 100644
index 0000000..c094468
--- /dev/null
+++ b/fw/fe310/eos/sdc_crypto.c
@@ -0,0 +1,51 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "sha/sha1.h"
+#include "sdc_crypto.h"
+
+#define SDC_CRYPTO_KEY_SIZE     16
+#define SDC_CRYPTO_BLK_SIZE     16
+#define SDC_CRYPTO_HASH_SIZE    20
+
+EOSSDCCrypto *sdc_crypto;
+
+void eos_sdcc_init(EOSSDCCrypto *crypto, uint8_t *key, void *ctx, eve_sdcc_init_t init, eve_sdcc_crypt_t enc, eve_sdcc_crypt_t dec, void *ctx_essiv, eve_sdcc_init_t init_essiv, eve_sdcc_essiv_t enc_essiv) {
+    char key_essiv[SDC_CRYPTO_HASH_SIZE];
+
+    sdc_crypto = crypto;
+
+    memset(key_essiv, 0, SDC_CRYPTO_HASH_SIZE);
+    init(ctx, key);
+    sdc_crypto->ctx = ctx;
+    sdc_crypto->enc = enc;
+    sdc_crypto->dec = dec;
+
+    SHA1(key_essiv, key, SDC_CRYPTO_KEY_SIZE);
+    init_essiv(ctx_essiv, key_essiv);
+    sdc_crypto->ctx_essiv = ctx_essiv;
+    sdc_crypto->enc_essiv = enc_essiv;
+}
+
+void eos_sdcc_encrypt(uint32_t sect, uint8_t *buffer) {
+    uint8_t iv[SDC_CRYPTO_BLK_SIZE];
+
+    if (sdc_crypto == NULL) return;
+
+    memset(iv, 0, SDC_CRYPTO_BLK_SIZE);
+    memcpy(iv, &sect, sizeof(sect));
+    sdc_crypto->enc_essiv(sdc_crypto->ctx_essiv, iv);
+    sdc_crypto->enc(sdc_crypto->ctx, iv, buffer, 512);
+}
+
+void eos_sdcc_decrypt(uint32_t sect, uint8_t *buffer) {
+    uint8_t iv[SDC_CRYPTO_BLK_SIZE];
+
+    if (sdc_crypto == NULL) return;
+
+    memset(iv, 0, SDC_CRYPTO_BLK_SIZE);
+    memcpy(iv, &sect, sizeof(sect));
+    sdc_crypto->enc_essiv(sdc_crypto->ctx_essiv, iv);
+    sdc_crypto->dec(sdc_crypto->ctx, iv, buffer, 512);
+}
\ No newline at end of file
diff --git a/fw/fe310/eos/sdc_crypto.h b/fw/fe310/eos/sdc_crypto.h
new file mode 100644
index 0000000..015bf8a
--- /dev/null
+++ b/fw/fe310/eos/sdc_crypto.h
@@ -0,0 +1,18 @@
+#include <stddef.h>
+#include <stdint.h>
+
+typedef void (*eve_sdcc_init_t) (void *, uint8_t *);
+typedef void (*eve_sdcc_crypt_t) (void *, uint8_t *, uint8_t *, size_t);
+typedef void (*eve_sdcc_essiv_t) (void *, uint8_t *);
+
+typedef struct EOSSDCCrypto {
+    void *ctx;
+    eve_sdcc_crypt_t enc;
+    eve_sdcc_crypt_t dec;
+    void *ctx_essiv;
+    eve_sdcc_essiv_t enc_essiv;
+} EOSSDCCrypto;
+
+void eos_sdcc_init(EOSSDCCrypto *crypto, uint8_t *key, void *ctx, eve_sdcc_init_t init, eve_sdcc_crypt_t enc, eve_sdcc_crypt_t dec, void *ctx_essiv, eve_sdcc_init_t init_essiv, eve_sdcc_essiv_t enc_essiv);
+void eos_sdcc_encrypt(uint32_t sect, uint8_t *buffer);
+void eos_sdcc_decrypt(uint32_t sect, uint8_t *buffer);
\ No newline at end of file
diff --git a/fw/fe310/eos/sdcard.c b/fw/fe310/eos/sdcard.c
new file mode 100644
index 0000000..970ab17
--- /dev/null
+++ b/fw/fe310/eos/sdcard.c
@@ -0,0 +1,541 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "eos.h"
+#include "timer.h"
+
+#include "spi.h"
+#include "spi_dev.h"
+
+#include "sdc_crypto.h"
+#include "sdcard.h"
+
+#define SDC_TIMEOUT_CMD         500
+#define SDC_TIMEOUT_READ        200
+#define SDC_TIMEOUT_WRITE       500
+
+#define SDC_POLY_CRC7           0x09
+#define SDC_POLY_CRC16          0x1021
+
+#define SDC_CMD_FLAG_CRC        0x01
+#define SDC_CMD_FLAG_NOCS       0x02
+#define SDC_CMD_FLAG_NOWAIT     0x04
+#define SDC_CMD_FLAG_RSTUFF     0x08
+
+#define SDC_TOKEN_START_BLK     0xfe
+#define SDC_TOKEN_START_BLKM    0xfc
+#define SDC_TOKEN_STOP_TRAN     0xfd
+
+#define SDC_DRESP_MASK          0x1f
+#define SDC_DRESP_ACCEPT        0x05
+#define SDC_DRESP_ERR_CRC       0x0b
+#define SDC_DRESP_ERR_WRITE     0x0d
+
+#define SDC_R1_READY            0x00
+
+#define SDC_R1_IDLE_STATE       0x01
+#define SDC_R1_ERASE_RESET      0x02
+#define SDC_R1_ILLEGAL_CMD      0x04
+#define SDC_R1_ERR_CMD_CRC      0x08
+#define SDC_R1_ERR_ERASE_SEQ    0x10
+#define SDC_R1_ERR_ADDR         0x20
+#define SDC_R1_ERR_PARAM        0x40
+
+#define SDC_NCR                 10
+
+#define SDC_ERR(rv)             ((rv < 0) ? rv : EOS_ERR)
+
+/* CMD */
+#define GO_IDLE_STATE           0
+#define SEND_OP_COND            1
+#define SEND_IF_COND            8
+#define SEND_CSD                9
+#define STOP_TRANSMISSION       12
+#define SET_BLOCKLEN            16
+#define READ_SINGLE_BLOCK       17
+#define READ_MULTIPLE_BLOCK     18
+#define WRITE_BLOCK             24
+#define WRITE_MULTIPLE_BLOCK    25
+#define ERASE_WR_BLK_START      32
+#define ERASE_WR_BLK_END        33
+#define ERASE                   38
+#define APP_CMD                 55
+#define READ_OCR                58
+
+/* ACMD */
+#define SD_STATUS               13
+#define SET_WR_BLK_ERASE_COUNT  23
+#define SD_APP_OP_COND          41
+
+static uint8_t sdc_type = 0;
+
+static uint8_t sdc_crc7(uint8_t crc, uint8_t b) {
+    int i;
+
+    for (i=8; i--; b<<=1) {
+        crc <<= 1;
+        if ((b ^ crc) & 0x80) crc ^= SDC_POLY_CRC7;
+    }
+    return crc & 0x7f;
+}
+
+static uint16_t sdc_crc16(uint16_t crc, uint8_t b) {
+    int i;
+
+    crc = crc ^ ((uint16_t)b << 8);
+    for (i=8; i--;) {
+        if (crc & 0x8000) {
+            crc = (crc << 1) ^ SDC_POLY_CRC16;
+        } else {
+            crc <<= 1;
+        }
+    }
+    return crc;
+}
+
+static uint32_t sdc_nto(uint64_t start, uint32_t timeout) {
+    uint32_t d = eos_time_since(start);
+    return (d > timeout) ? 0 : timeout - d;
+}
+
+static uint8_t sdc_xchg8(uint8_t data) {
+    return eos_spi_xchg8(data, 0);
+}
+
+static uint16_t sdc_xchg16(uint16_t data) {
+    return eos_spi_xchg16(data, 0);
+}
+
+static uint32_t sdc_xchg32(uint32_t data) {
+    return eos_spi_xchg32(data, 0);
+}
+
+static void sdc_buf_send(unsigned char *buffer, uint16_t len) {
+    int i;
+
+    for (i=0; i<len; i++) {
+        sdc_xchg8(buffer[i]);
+    }
+}
+
+static void sdc_buf_recv(unsigned char *buffer, uint16_t len) {
+    int i;
+
+    for (i=0; i<len; i++) {
+        buffer[i] = sdc_xchg8(0xff);
+    }
+}
+
+static void sdc_select(void) {
+    eos_spi_cs_set();
+    eos_spi_xchg8(0xff, 0);
+}
+
+static void sdc_deselect(void) {
+    eos_spi_cs_clear();
+    eos_spi_xchg8(0xff, 0);
+}
+
+static int sdc_xchg_cmd(uint8_t cmd, uint32_t arg, uint8_t flags) {
+    int i;
+    uint8_t ret;
+    uint8_t crc = 0x7f;
+
+    cmd |= 0x40;
+    if (flags & SDC_CMD_FLAG_CRC) {
+        crc = sdc_crc7(0, cmd);
+        crc = sdc_crc7(crc, arg >> 24);
+        crc = sdc_crc7(crc, arg >> 16);
+        crc = sdc_crc7(crc, arg >> 8);
+        crc = sdc_crc7(crc, arg);
+    }
+    crc = (crc << 1) | 0x01;
+    sdc_xchg8(cmd);
+    sdc_xchg32(arg);
+    sdc_xchg8(crc);
+    if (flags & SDC_CMD_FLAG_RSTUFF) sdc_xchg8(0xff);
+
+    i = SDC_NCR;
+    do {
+        ret = sdc_xchg8(0xff);
+    } while ((ret & 0x80) && --i);
+    if (ret & 0x80) return EOS_ERR_BUSY;
+
+    return ret;
+}
+
+static int sdc_ready(uint32_t timeout) {
+    uint8_t d = 0;
+    uint64_t start;
+
+    if (timeout == 0) return EOS_ERR_BUSY;
+    start = eos_time_get_tick();
+    do {
+        if (eos_time_since(start) > timeout) break;
+        d = sdc_xchg8(0xff);
+    } while (d != 0xff);
+    if (d != 0xff) return EOS_ERR_BUSY;
+
+    return EOS_OK;
+}
+
+static int sdc_block_read(uint8_t *buffer, uint16_t len, uint32_t timeout) {
+    uint8_t token = 0xff;
+    uint64_t start;
+
+    if (timeout == 0) return EOS_ERR_BUSY;
+    start = eos_time_get_tick();
+    do {
+        if (eos_time_since(start) > timeout) break;
+        token = sdc_xchg8(0xff);
+    } while (token == 0xff);
+    if (token == 0xff) return EOS_ERR_BUSY;
+    if (token != SDC_TOKEN_START_BLK) return EOS_ERR;
+
+    sdc_buf_recv(buffer, len);
+    sdc_xchg16(0xffff); /* dummy CRC */
+
+    return EOS_OK;
+}
+
+static int sdc_block_write(uint8_t token, uint8_t *buffer, uint16_t len, uint32_t timeout) {
+    uint8_t d;
+    int rv;
+
+    rv = sdc_ready(timeout);
+    if (rv) return rv;
+
+    sdc_xchg8(token);
+    if (buffer && len) {
+        sdc_buf_send(buffer, len);
+        sdc_xchg16(0xffff); /* dummy CRC */
+
+        d = sdc_xchg8(0xff); /* Response */
+        if ((d & SDC_DRESP_MASK) != SDC_DRESP_ACCEPT) return EOS_ERR;
+    }
+
+    return EOS_OK;
+}
+
+static int sdc_cmd(uint8_t cmd, uint32_t arg, uint8_t flags, uint32_t timeout) {
+    int do_cs = !(flags & SDC_CMD_FLAG_NOCS);
+    int do_wait = !(flags & SDC_CMD_FLAG_NOWAIT);
+    int rv = EOS_OK;
+
+    if (do_cs) sdc_select();
+    if (do_wait) rv = sdc_ready(timeout);
+    if (rv) {
+        if (do_cs) sdc_deselect();
+        return rv;
+    }
+    rv = sdc_xchg_cmd(cmd, arg, flags);
+    if (do_cs) sdc_deselect();
+    return rv;
+}
+
+static int sdc_acmd(uint8_t cmd, uint32_t arg, uint8_t flags, uint32_t timeout) {
+    int rv;
+    uint64_t start;
+
+    start = eos_time_get_tick();
+    rv = sdc_cmd(APP_CMD, 0, flags, timeout);
+    if (rv & ~SDC_R1_IDLE_STATE) return rv;
+
+    if (flags & SDC_CMD_FLAG_NOCS) {
+        sdc_deselect();
+        sdc_select();
+    }
+    return sdc_cmd(cmd, arg, flags, sdc_nto(start, timeout));
+}
+
+static int sdc_init(uint32_t timeout) {
+    int rv, i;
+    uint8_t _type;
+    uint8_t ocr[4];
+    uint64_t start;
+    start = eos_time_get_tick();
+
+    eos_time_sleep(100);
+    for (i=10; i--;) sdc_xchg8(0xff);     /* 80 dummy cycles */
+
+    rv = sdc_cmd(GO_IDLE_STATE, 0, SDC_CMD_FLAG_CRC, SDC_TIMEOUT_CMD);
+    if (rv != SDC_R1_IDLE_STATE) return SDC_ERR(rv);
+
+    sdc_select();
+    rv = sdc_cmd(SEND_IF_COND, 0x1aa, SDC_CMD_FLAG_CRC | SDC_CMD_FLAG_NOCS, sdc_nto(start, timeout));
+    switch (rv) {
+        case SDC_R1_IDLE_STATE:
+            for (i=0; i<4; i++) {   /* R7 response */
+                ocr[i] = sdc_xchg8(0xff);
+            }
+            sdc_deselect();
+            if (ocr[2] == 0x01 && ocr[3] == 0xaa) {     /* Check voltage range: 2.7-3.6V */
+                do {
+                    rv = sdc_acmd(SD_APP_OP_COND, 0x40000000, 0, sdc_nto(start, timeout));
+                } while (rv == SDC_R1_IDLE_STATE);
+                if (rv != SDC_R1_READY) return SDC_ERR(rv);
+
+                sdc_select();
+                rv = sdc_cmd(READ_OCR, 0, SDC_CMD_FLAG_NOCS, sdc_nto(start, timeout));
+                if (rv == SDC_R1_READY) {
+                    for (i=0; i<4; i++) {   /* R7 response */
+                        ocr[i] = sdc_xchg8(0xff);
+                    }
+                    sdc_deselect();
+                } else {
+                    sdc_deselect();
+                    return SDC_ERR(rv);
+                }
+
+                _type = EOS_SDC_TYPE_SDC2;
+                if (ocr[0] & 0xc0) _type |= EOS_SDC_CAP_BLK;
+            }
+            break;
+
+        case SDC_R1_IDLE_STATE | SDC_R1_ILLEGAL_CMD:
+            sdc_deselect();
+            rv = sdc_acmd(SD_APP_OP_COND, 0, 0, sdc_nto(start, timeout));
+            switch (rv) {
+                case SDC_R1_IDLE_STATE:
+                    do  {
+                        rv = sdc_acmd(SD_APP_OP_COND, 0, 0, sdc_nto(start, timeout));
+                    } while (rv == SDC_R1_IDLE_STATE);
+                    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+                case SDC_R1_READY:
+                    _type = EOS_SDC_TYPE_SDC1;
+                    break;
+
+                default:
+                    do {
+                        rv = sdc_cmd(SEND_OP_COND, 0, 0, sdc_nto(start, timeout));
+                    } while (rv == SDC_R1_IDLE_STATE);
+                    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+                    _type = EOS_SDC_TYPE_MMC;
+                    break;
+
+            }
+            break;
+
+        default:
+            sdc_deselect();
+            return SDC_ERR(rv);
+    }
+
+    if (!(_type & EOS_SDC_CAP_BLK)) {
+        rv = sdc_cmd(SET_BLOCKLEN, 512, 0, sdc_nto(start, timeout));
+        if (rv != SDC_R1_READY) return SDC_ERR(rv);
+    }
+
+    if (_type & EOS_SDC_TYPE_SDC) {
+        uint8_t csd[16];
+
+        sdc_select();
+        rv = sdc_cmd(SEND_CSD, 0, SDC_CMD_FLAG_NOCS, sdc_nto(start, timeout));
+        if (rv == SDC_R1_READY) {
+            rv = sdc_block_read(csd, 16, sdc_nto(start, timeout));
+        } else {
+            rv = SDC_ERR(rv);
+        }
+        sdc_deselect();
+        if (rv) return rv;
+
+        for (i=0; i<16; i++) {
+            printf("%.2x ", csd[i]);
+        }
+        printf("\n");
+        if (csd[10] & 0x40) _type |= EOS_SDC_CAP_ERASE_EN;
+    }
+
+    eos_spi_set_div(EOS_SPI_DEV_SDC, 5);
+    sdc_type = _type;
+    return EOS_OK;
+}
+
+void eos_sdc_init(void) {
+    int rv;
+
+    eos_spi_select(EOS_SPI_DEV_SDC);
+    rv = sdc_init(5000);
+    if (rv) {
+        printf("SDC ERROR\n");
+    } else {
+        printf("SDC OK:%x\n", sdc_type);
+    }
+    eos_spi_deselect();
+}
+
+uint8_t eos_sdc_type(void) {
+    return sdc_type & EOS_SDC_TYPE_MASK;
+}
+
+uint8_t eos_sdc_cap(void) {
+    return sdc_type & EOS_SDC_CAP_MASK;
+}
+
+int eos_sdc_get_sect_count(uint32_t timeout, uint32_t *sectors) {
+    int rv;
+    uint8_t csd[16];
+    uint64_t start = eos_time_get_tick();
+
+    sdc_select();
+    rv = sdc_cmd(SEND_CSD, 0, SDC_CMD_FLAG_NOCS, timeout);
+    if (rv == SDC_R1_READY) {
+        rv = sdc_block_read(csd, 16, sdc_nto(start, timeout));
+    } else {
+        rv = SDC_ERR(rv);
+    }
+    sdc_deselect();
+    if (rv) return rv;
+
+    if ((csd[0] >> 6) == 1) {   /* SDCv2 */
+        *sectors = (csd[9] + (csd[8] << 8) + ((csd[7] & 0x3f) << 16) + 1) << 10;
+    } else {                    /* SDCv1 or MMC*/
+        uint8_t n = (csd[5] & 0x0f) + (csd[10] >> 7) + ((csd[9] & 0x03) << 1) + 2;
+        *sectors = (csd[8] >> 6) + (csd[7] << 2) + ((csd[6] & 0x03) << 10) + 1;
+        *sectors = *sectors << (n - 9);
+    }
+
+    return EOS_OK;
+}
+
+int eos_sdc_get_blk_size(uint32_t timeout, uint32_t *size) {
+    int rv;
+    uint8_t rbl[64];    /* SD Status or CSD register */
+    uint64_t start = eos_time_get_tick();
+
+    sdc_select();
+    if (sdc_type & EOS_SDC_TYPE_SDC2) {
+        rv = sdc_acmd(SD_STATUS, 0, SDC_CMD_FLAG_NOCS, timeout);
+        sdc_xchg8(0xff);    /* R2 response */
+    } else {
+        rv = sdc_cmd(SEND_CSD, 0, SDC_CMD_FLAG_NOCS, timeout);
+    }
+    if (rv == SDC_R1_READY) {
+        rv = sdc_block_read(rbl, (sdc_type & EOS_SDC_TYPE_SDC2) ? 64 : 16, sdc_nto(start, timeout));
+    } else {
+        rv = SDC_ERR(rv);
+    }
+    sdc_deselect();
+    if (rv) return rv;
+
+    if (sdc_type & EOS_SDC_TYPE_SDC2) {
+        *size = 16UL << (rbl[10] >> 4);
+    } else if (sdc_type & EOS_SDC_TYPE_SDC1) {
+        *size = (((rbl[10] & 0x3f) << 1) + (rbl[11] >> 7) + 1) << ((rbl[13] >> 6) - 1);
+    } else {
+        *size = (((rbl[10] & 0x7c) >> 2) + 1) * (((rbl[11] & 0x03) << 3) + (rbl[11] >> 5) + 1);
+    }
+
+    return EOS_OK;
+}
+
+int eos_sdc_sync(uint32_t timeout) {
+    int rv;
+
+    sdc_select();
+    rv = sdc_ready(timeout);
+    sdc_deselect();
+
+    return rv;
+}
+
+int eos_sdc_erase(uint32_t blk_start, uint32_t blk_end, uint32_t timeout) {
+    int rv;
+    uint64_t start;
+
+    if (!(sdc_type & EOS_SDC_TYPE_SDC)) return EOS_ERR;
+    if (!(sdc_type & EOS_SDC_CAP_ERASE_EN)) return EOS_ERR;
+    if (!(sdc_type & EOS_SDC_CAP_BLK)) {
+        blk_start *= 512;
+        blk_end *= 512;
+    }
+
+    start = eos_time_get_tick();
+    rv = sdc_cmd(ERASE_WR_BLK_START, blk_start, 0, timeout);
+    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+
+    rv = sdc_cmd(ERASE_WR_BLK_END, blk_end, 0, sdc_nto(start, timeout));
+    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+
+    rv = sdc_cmd(ERASE, 0, 0, sdc_nto(start, timeout));
+    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+
+    return eos_sdc_sync(sdc_nto(start, timeout));
+}
+
+int eos_sdc_sect_read(uint32_t sect, unsigned int count, uint8_t *buffer) {
+    int rv;
+    uint64_t start;
+    uint8_t cmd = ((count == 1) ? READ_SINGLE_BLOCK : READ_MULTIPLE_BLOCK);
+
+    if (!(sdc_type & EOS_SDC_CAP_BLK)) sect *= 512;
+    start = eos_time_get_tick();
+
+    sdc_select();
+    rv = sdc_cmd(cmd, sect, SDC_CMD_FLAG_NOCS, SDC_TIMEOUT_CMD);
+    if (rv == SDC_R1_READY) {
+        int _rv = SDC_R1_READY;
+
+        while (count) {
+            rv = sdc_block_read(buffer, 512, SDC_TIMEOUT_READ);
+            if (rv) break;
+            eos_sdcc_decrypt(sect, buffer);
+            buffer += 512;
+            count--;
+        }
+        if (cmd == READ_MULTIPLE_BLOCK) _rv = sdc_cmd(STOP_TRANSMISSION, 0, SDC_CMD_FLAG_NOCS | SDC_CMD_FLAG_NOWAIT | SDC_CMD_FLAG_RSTUFF, 0);
+        if (!rv && (_rv != SDC_R1_READY)) rv = SDC_ERR(_rv);
+    } else {
+        rv = SDC_ERR(rv);
+    }
+    sdc_deselect();
+
+    return rv;
+}
+
+int eos_sdc_sect_write(uint32_t sect, unsigned int count, uint8_t *buffer) {
+    int rv;
+    uint64_t start;
+
+    if (!(sdc_type & EOS_SDC_CAP_BLK)) sect *= 512;
+    start = eos_time_get_tick();
+
+    if (count == 1) {
+        sdc_select();
+        rv = sdc_cmd(WRITE_BLOCK, sect, SDC_CMD_FLAG_NOCS, SDC_TIMEOUT_CMD);
+        if (rv == SDC_R1_READY) {
+            eos_sdcc_encrypt(sect, buffer);
+            rv = sdc_block_write(SDC_TOKEN_START_BLK, buffer, 512, SDC_TIMEOUT_WRITE);
+        } else {
+            rv = SDC_ERR(rv);
+        }
+        sdc_deselect();
+    } else {
+        if (sdc_type & EOS_SDC_TYPE_SDC) {
+            rv = sdc_acmd(SET_WR_BLK_ERASE_COUNT, count, 0, SDC_TIMEOUT_CMD);
+            if (rv != SDC_R1_READY) return SDC_ERR(rv);
+        }
+
+        sdc_select();
+        rv = sdc_cmd(WRITE_MULTIPLE_BLOCK, sect, SDC_CMD_FLAG_NOCS, SDC_TIMEOUT_CMD);
+        if (rv == SDC_R1_READY) {
+            int _rv;
+
+            while (count) {
+                eos_sdcc_encrypt(sect, buffer);
+                rv = sdc_block_write(SDC_TOKEN_START_BLKM, buffer, 512, SDC_TIMEOUT_WRITE);
+                if (rv) break;
+                buffer += 512;
+                count--;
+            }
+            _rv = sdc_block_write(SDC_TOKEN_STOP_TRAN, NULL, 0, SDC_TIMEOUT_WRITE);
+            if (!rv && (_rv != SDC_R1_READY)) rv = SDC_ERR(_rv);
+        } else {
+            rv = SDC_ERR(rv);
+        }
+        sdc_deselect();
+    }
+
+    return rv;
+}
diff --git a/fw/fe310/eos/sdcard.h b/fw/fe310/eos/sdcard.h
new file mode 100644
index 0000000..0234f65
--- /dev/null
+++ b/fw/fe310/eos/sdcard.h
@@ -0,0 +1,22 @@
+#include <stdint.h>
+
+#define EOS_SDC_TYPE_MMC            0x01
+
+#define EOS_SDC_TYPE_SDC1           0x04
+#define EOS_SDC_TYPE_SDC2           0x08
+#define EOS_SDC_TYPE_SDC            0x0c
+#define EOS_SDC_TYPE_MASK           0x0f
+
+#define EOS_SDC_CAP_BLK             0x10
+#define EOS_SDC_CAP_ERASE_EN        0x20
+#define EOS_SDC_CAP_MASK            0xf0
+
+void eos_sdc_init(void);
+uint8_t eos_sdc_type(void);
+uint8_t eos_sdc_cap(void);
+int eos_sdc_get_sect_count(uint32_t timeout, uint32_t *sectors);
+int eos_sdc_get_blk_size(uint32_t timeout, uint32_t *size);
+int eos_sdc_sync(uint32_t timeout);
+int eos_sdc_erase(uint32_t blk_start, uint32_t blk_end, uint32_t timeout);
+int eos_sdc_sect_read(uint32_t sect, unsigned int count, uint8_t *buffer);
+int eos_sdc_sect_write(uint32_t sect, unsigned int count, uint8_t *buffer);
diff --git a/fw/fe310/eos/sock.c b/fw/fe310/eos/sock.c
new file mode 100644
index 0000000..a2e30e3
--- /dev/null
+++ b/fw/fe310/eos/sock.c
@@ -0,0 +1,103 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "eos.h"
+#include "event.h"
+#include "net.h"
+
+#include "sock.h"
+
+static eos_evt_handler_t evt_handler[EOS_SOCK_MAX_SOCK];
+
+static void sock_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char sock;
+
+    if ((buffer == NULL) || (len < 2)) {
+        eos_net_bad_handler(type, buffer, len);
+        return;
+    }
+
+    sock = buffer[1];
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK) || (evt_handler[sock - 1] == NULL)) {
+        eos_net_bad_handler(type, buffer, len);
+        return;
+    }
+
+    switch(buffer[0]) {
+        case EOS_SOCK_MTYPE_PKT:
+            evt_handler[sock - 1](type, buffer, len);
+            break;
+        default:
+            eos_net_bad_handler(type, buffer, len);
+            break;
+    }
+}
+
+void eos_sock_init(void) {
+    int i;
+
+    for (i=0; i<EOS_SOCK_MAX_SOCK; i++) {
+        evt_handler[i] = NULL;
+    }
+    eos_net_set_handler(EOS_NET_MTYPE_SOCK, sock_handle_msg);
+}
+
+void eos_sock_set_handler(unsigned char sock, eos_evt_handler_t handler) {
+    if (sock && (sock <= EOS_SOCK_MAX_SOCK)) evt_handler[sock - 1] = handler;
+}
+
+eos_evt_handler_t eos_sock_get_handler(unsigned char sock) {
+    if (sock && (sock <= EOS_SOCK_MAX_SOCK)) return evt_handler[sock - 1];
+    return NULL;
+}
+
+int eos_sock_open_udp(eos_evt_handler_t handler) {
+    unsigned char type = EOS_SOCK_MTYPE_OPEN_DGRAM;
+    unsigned char *buffer = eos_net_alloc();
+    uint16_t buf_size;
+    int rv, sock;
+
+    buffer[0] = type;
+    rv = eos_net_send(EOS_NET_MTYPE_SOCK, buffer, 1, 0);
+    if (rv) return rv;
+
+    eos_evtq_wait(EOS_NET_MTYPE_SOCK, &type, 1, &buffer, &buf_size);
+    if (buf_size < 2) {
+        eos_net_free(buffer, 0);
+        return EOS_ERR_NET;
+    }
+
+    sock = buffer[1];
+    eos_net_free(buffer, 1);
+
+    if (sock == 0) return EOS_ERR_NET;
+
+    eos_sock_set_handler(sock, handler);
+    return sock;
+}
+
+void eos_sock_close(unsigned char sock) {
+    unsigned char *buffer = eos_net_alloc();
+    buffer[0] = EOS_SOCK_MTYPE_CLOSE;
+    buffer[1] = sock;
+    eos_net_send(EOS_NET_MTYPE_SOCK, buffer, 2, 1);
+    eos_sock_set_handler(sock, NULL);
+}
+
+int eos_sock_sendto(unsigned char sock, unsigned char *buffer, uint16_t size, unsigned char more, EOSNetAddr *addr) {
+    unsigned char type = EOS_NET_MTYPE_SOCK;
+
+    buffer[0] = EOS_SOCK_MTYPE_PKT;
+    buffer[1] = sock;
+    memcpy(buffer+2, addr->host, sizeof(addr->host));
+    memcpy(buffer+2+sizeof(addr->host), &addr->port, sizeof(addr->port));
+    return eos_net_send(type, buffer, size, more);
+}
+
+void eos_sock_getfrom(unsigned char *buffer, EOSNetAddr *addr) {
+    memcpy(addr->host, buffer+2, sizeof(addr->host));
+    memcpy(&addr->port, buffer+2+sizeof(addr->host), sizeof(addr->port));
+}
+
+
diff --git a/fw/fe310/eos/sock.h b/fw/fe310/eos/sock.h
new file mode 100644
index 0000000..7461473
--- /dev/null
+++ b/fw/fe310/eos/sock.h
@@ -0,0 +1,26 @@
+#include <stdint.h>
+#include "event.h"
+
+#define EOS_SOCK_MTYPE_PKT          0
+#define EOS_SOCK_MTYPE_OPEN_DGRAM   1
+#define EOS_SOCK_MTYPE_CLOSE        127
+
+#define EOS_SOCK_MAX_SOCK           2
+
+#define EOS_SOCK_SIZE_UDP_HDR       8
+
+#define EOS_IPv4_ADDR_SIZE          4
+
+typedef struct EOSNetAddr {
+    unsigned char host[EOS_IPv4_ADDR_SIZE];
+    uint16_t port;
+} EOSNetAddr;
+
+void eos_sock_init(void);
+void eos_sock_set_handler(unsigned char sock, eos_evt_handler_t handler);
+eos_evt_handler_t eos_sock_get_handler(unsigned char sock);
+
+int eos_sock_open_udp(eos_evt_handler_t handler);
+void eos_sock_close(unsigned char sock);
+int eos_sock_sendto(unsigned char sock, unsigned char *buffer, uint16_t size, unsigned char more, EOSNetAddr *addr);
+void eos_sock_getfrom(unsigned char *buffer, EOSNetAddr *addr);
diff --git a/fw/fe310/eos/spi.c b/fw/fe310/eos/spi.c
new file mode 100644
index 0000000..c5e953e
--- /dev/null
+++ b/fw/fe310/eos/spi.c
@@ -0,0 +1,338 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "eos.h"
+#include "msgq.h"
+#include "interrupt.h"
+#include "event.h"
+
+#include "board.h"
+
+#include "spi.h"
+#include "spi_priv.h"
+
+#define SPI_MODE0               0x00
+#define SPI_MODE1               0x01
+#define SPI_MODE2               0x02
+#define SPI_MODE3               0x03
+
+#define SPI_FLAG_XCHG           0x10
+
+#define SPI_IOF_MASK            (((uint32_t)1 << IOF_SPI1_SCK) | ((uint32_t)1 << IOF_SPI1_MOSI) | ((uint32_t)1 << IOF_SPI1_MISO)) | SPI_IOF_MASK_CS
+
+#define MIN(X, Y)               (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y)               (((X) > (Y)) ? (X) : (Y))
+
+static uint8_t spi_cspin;
+static volatile uint8_t spi_state_flags;
+static unsigned char spi_evt;
+static unsigned char spi_in_xchg;
+
+static uint32_t spi_state_len = 0;
+static uint32_t spi_state_idx_tx = 0;
+static uint32_t spi_state_idx_rx = 0;
+static unsigned char *spi_state_buf = NULL;
+
+static eos_evt_handler_t evt_handler[EOS_SPI_MAX_EVT];
+
+static void spi_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char idx = (type & ~EOS_EVT_MASK) - 1;
+    if (idx < EOS_SPI_MAX_EVT) {
+        evt_handler[idx](type, buffer, len);
+    } else {
+        eos_evtq_bad_handler(type, buffer, len);
+    }
+}
+
+void eos_spi_init(void) {
+    int i;
+
+    for (i=0; i<EOS_SPI_MAX_EVT; i++) {
+        evt_handler[i] = eos_evtq_bad_handler;
+    }
+    eos_evtq_set_handler(EOS_EVT_SPI, spi_handle_evt);
+    eos_intr_set(INT_SPI1_BASE, IRQ_PRIORITY_SPI_XCHG, NULL);
+
+    SPI1_REG(SPI_REG_SCKMODE) = SPI_MODE0;
+    SPI1_REG(SPI_REG_FMT) = SPI_FMT_PROTO(SPI_PROTO_S) |
+      SPI_FMT_ENDIAN(SPI_ENDIAN_MSB) |
+      SPI_FMT_DIR(SPI_DIR_RX) |
+      SPI_FMT_LEN(8);
+
+    GPIO_REG(GPIO_IOF_SEL) &= ~SPI_IOF_MASK;
+    GPIO_REG(GPIO_IOF_EN) |= SPI_IOF_MASK;
+
+    // There is no way here to change the CS polarity.
+    // SPI1_REG(SPI_REG_CSDEF) = 0xFFFF;
+}
+
+void eos_spi_start(uint16_t div, uint8_t csid, uint8_t cspin, unsigned char evt) {
+    spi_state_flags = 0;
+    spi_evt = evt;
+    SPI1_REG(SPI_REG_SCKDIV) = div;
+    SPI1_REG(SPI_REG_CSID) = csid;
+    if (csid != SPI_CSID_NONE) {
+        SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
+    } else {
+        spi_cspin = cspin;
+        SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_OFF;
+    }
+    eos_intr_set_handler(INT_SPI1_BASE, eos_spi_handle_xchg);
+}
+
+void eos_spi_stop(void) {
+    eos_spi_flush();
+    spi_evt = 0;
+}
+
+void eos_spi_set_handler(unsigned char evt, eos_evt_handler_t handler) {
+    if (handler == NULL) handler = eos_evtq_bad_handler;
+    if (evt && (evt <= EOS_SPI_MAX_EVT)) evt_handler[evt - 1] = handler;
+}
+
+void _eos_spi_xchg_init(unsigned char *buffer, uint16_t len, uint8_t flags) {
+    spi_state_flags &= 0xF0;
+    spi_state_flags |= (SPI_FLAG_XCHG | flags);
+    spi_state_buf = buffer;
+    spi_state_len = len;
+    spi_state_idx_tx = 0;
+    spi_state_idx_rx = 0;
+}
+
+static void spi_xchg_finish(void) {
+    uint8_t done = 0;
+
+    while (!done) {
+        clear_csr(mstatus, MSTATUS_MIE);
+        done = !(spi_state_flags & SPI_FLAG_XCHG);
+        if (!done) asm volatile ("wfi");
+        set_csr(mstatus, MSTATUS_MIE);
+    }
+    spi_in_xchg = 0;
+}
+
+void eos_spi_xchg(unsigned char *buffer, uint16_t len, uint8_t flags) {
+    if (spi_in_xchg) spi_xchg_finish();
+
+    spi_in_xchg = 1;
+    _eos_spi_xchg_init(buffer, len, flags);
+
+    eos_spi_cs_set();
+    SPI1_REG(SPI_REG_TXCTRL) = SPI_TXWM(SPI_SIZE_WM);
+    SPI1_REG(SPI_REG_IE) = SPI_IP_TXWM;
+}
+
+void eos_spi_handle_xchg(void) {
+    int i;
+    uint16_t sz_chunk = MIN(spi_state_len - spi_state_idx_tx, SPI_SIZE_CHUNK);
+
+    for (i=0; i<sz_chunk; i++) {
+        volatile uint32_t x = SPI1_REG(SPI_REG_TXFIFO);
+        if (x & SPI_TXFIFO_FULL) break;
+        SPI1_REG(SPI_REG_TXFIFO) = spi_state_buf[spi_state_idx_tx+i];
+    }
+    spi_state_idx_tx += i;
+
+    for (i=0; i<spi_state_idx_tx - spi_state_idx_rx; i++) {
+        volatile uint32_t x = SPI1_REG(SPI_REG_RXFIFO);
+        if (x & SPI_RXFIFO_EMPTY) break;
+        spi_state_buf[spi_state_idx_rx+i] = x & 0xFF;
+    }
+    spi_state_idx_rx += i;
+
+    if (spi_state_idx_tx == spi_state_len) {
+        if ((spi_state_idx_rx == spi_state_len) || (spi_state_flags & EOS_SPI_FLAG_TX)) {
+            spi_state_flags &= ~SPI_FLAG_XCHG;
+            if (!(spi_state_flags & EOS_SPI_FLAG_MORE)) eos_spi_cs_clear();
+            SPI1_REG(SPI_REG_IE) = 0x0;
+            if (spi_evt) eos_evtq_push_isr(EOS_EVT_SPI | spi_evt, spi_state_buf, spi_state_len);
+        } else {
+            SPI1_REG(SPI_REG_RXCTRL) = SPI_RXWM(MIN(spi_state_len - spi_state_idx_rx - 1, SPI_SIZE_WM - 1));
+            SPI1_REG(SPI_REG_IE) = SPI_IP_RXWM;
+        }
+    }
+}
+
+void eos_spi_cs_set(void) {
+	/* cs low */
+    if (SPI1_REG(SPI_REG_CSMODE) == SPI_CSMODE_OFF) {
+        GPIO_REG(GPIO_OUTPUT_VAL) &= ~(1 << spi_cspin);
+    } else {
+        SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_HOLD;
+    }
+}
+
+void eos_spi_cs_clear(void) {
+	/* cs high */
+    if (SPI1_REG(SPI_REG_CSMODE) == SPI_CSMODE_OFF) {
+        GPIO_REG(GPIO_OUTPUT_VAL) |= (1 << spi_cspin);
+    } else {
+        SPI1_REG(SPI_REG_CSMODE) = SPI_CSMODE_AUTO;
+    }
+}
+
+uint8_t eos_spi_xchg8(uint8_t data, uint8_t flags) {
+    volatile uint32_t x = 0;
+    uint8_t rx = !(flags & EOS_SPI_FLAG_TX);
+
+    spi_state_flags &= 0xF0;
+    spi_state_flags |= flags;
+
+    while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+    SPI1_REG(SPI_REG_TXFIFO) = data;
+
+    if (rx) {
+        while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+    }
+
+    return x & 0xFF;
+}
+
+uint16_t eos_spi_xchg16(uint16_t data, uint8_t flags) {
+    volatile uint32_t x = 0;
+    uint8_t rx = !(flags & EOS_SPI_FLAG_TX);
+    uint16_t r = 0;
+
+    spi_state_flags &= 0xF0;
+    spi_state_flags |= flags;
+
+    if (flags & EOS_SPI_FLAG_BSWAP) {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x00FF);
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0xFF00) >> 8;
+    } else {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0xFF00) >> 8;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x00FF);
+    }
+
+    if (rx) {
+        if (flags & EOS_SPI_FLAG_BSWAP) {
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF);
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 8;
+        } else {
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 8;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF);
+        }
+    }
+
+    return r;
+}
+
+uint32_t eos_spi_xchg24(uint32_t data, uint8_t flags) {
+    volatile uint32_t x = 0;
+    uint8_t rx = !(flags & EOS_SPI_FLAG_TX);
+    uint32_t r = 0;
+
+    spi_state_flags &= 0xF0;
+    spi_state_flags |= flags;
+
+    if (flags & EOS_SPI_FLAG_BSWAP) {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x000000FF);
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x0000FF00) >> 8;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x00FF0000) >> 16;
+    } else {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x00FF0000) >> 16;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x0000FF00) >> 8;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x000000FF);
+    }
+
+    if (rx) {
+        if (flags & EOS_SPI_FLAG_BSWAP) {
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF);
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 8;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 16;
+        } else {
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 16;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 8;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF);
+        }
+    }
+
+    return r;
+}
+
+uint32_t eos_spi_xchg32(uint32_t data, uint8_t flags) {
+    volatile uint32_t x = 0;
+    uint8_t rx = !(flags & EOS_SPI_FLAG_TX);
+    uint32_t r = 0;
+
+    spi_state_flags &= 0xF0;
+    spi_state_flags |= flags;
+
+    if (flags & EOS_SPI_FLAG_BSWAP) {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x000000FF);
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x0000FF00) >> 8;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x00FF0000) >> 16;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0xFF000000) >> 24;
+    } else {
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0xFF000000) >> 24;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x00FF0000) >> 16;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x0000FF00) >> 8;
+        while (SPI1_REG(SPI_REG_TXFIFO) & SPI_TXFIFO_FULL);
+        SPI1_REG(SPI_REG_TXFIFO) = (data & 0x000000FF);
+    }
+
+    if (rx) {
+        if (flags & EOS_SPI_FLAG_BSWAP) {
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF);
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 8;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 16;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 24;
+        } else {
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 24;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 16;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF) << 8;
+            while ((x = SPI1_REG(SPI_REG_RXFIFO)) & SPI_RXFIFO_EMPTY);
+            r |= (x & 0xFF);
+        }
+    }
+
+    return r;
+}
+
+void eos_spi_flush(void) {
+    volatile uint32_t x = 0;
+
+    if (spi_in_xchg) spi_xchg_finish();
+
+    SPI1_REG(SPI_REG_TXCTRL) = SPI_TXWM(1);
+    while (!x) {
+        if (SPI1_REG(SPI_REG_IP) & SPI_IP_TXWM) x = SPI1_REG(SPI_REG_RXFIFO) & SPI_RXFIFO_EMPTY;
+    }
+}
diff --git a/fw/fe310/eos/spi.h b/fw/fe310/eos/spi.h
new file mode 100644
index 0000000..06db0d0
--- /dev/null
+++ b/fw/fe310/eos/spi.h
@@ -0,0 +1,28 @@
+#include <stdint.h>
+#include "event.h"
+
+#define EOS_SPI_FLAG_TX         0x01
+#define EOS_SPI_FLAG_MORE       0x02
+#define EOS_SPI_FLAG_BSWAP      0x04
+
+#define EOS_SPI_EVT_SDC         1
+#define EOS_SPI_EVT_CAM         2
+
+#define EOS_SPI_MAX_EVT         2
+
+void eos_spi_init(void);
+void eos_spi_start(uint16_t div, uint8_t csid, uint8_t cspin, unsigned char evt);
+void eos_spi_stop(void);
+void eos_spi_set_handler(unsigned char evt, eos_evt_handler_t handler);
+
+void _eos_spi_xchg_init(unsigned char *buffer, uint16_t len, uint8_t flags);
+void eos_spi_xchg(unsigned char *buffer, uint16_t len, uint8_t flags);
+void eos_spi_handle_xchg(void);
+
+void eos_spi_cs_set(void);
+void eos_spi_cs_clear(void);
+uint8_t eos_spi_xchg8(uint8_t data, uint8_t flags);
+uint16_t eos_spi_xchg16(uint16_t data, uint8_t flags);
+uint32_t eos_spi_xchg24(uint32_t data, uint8_t flags);
+uint32_t eos_spi_xchg32(uint32_t data, uint8_t flags);
+void eos_spi_flush(void);
diff --git a/fw/fe310/eos/spi_cfg.h b/fw/fe310/eos/spi_cfg.h
new file mode 100644
index 0000000..43b0763
--- /dev/null
+++ b/fw/fe310/eos/spi_cfg.h
@@ -0,0 +1,35 @@
+#include <stdint.h>
+
+typedef struct {
+    uint16_t div;
+    uint8_t csid;
+    uint8_t cspin;
+    unsigned char evt;
+} SPIConfig;
+
+static const SPIConfig spi_cfg[] = {
+    {   // DEV_NET
+        .div = SPI_DIV_NET,
+        .csid = SPI_CSID_NET,
+        .cspin = SPI_CSPIN_NET,
+        .evt = 0,   // Not SPI event
+    },
+    {   // DEV_EVE
+        .div = SPI_DIV_EVE,
+        .csid = SPI_CSID_EVE,
+        .cspin = SPI_CSPIN_EVE,
+        .evt = 0,
+    },
+    {   // DEV_SDC
+        .div = SPI_DIV_SDC,
+        .csid = SPI_CSID_SDC,
+        .cspin = SPI_CSPIN_SDC,
+        .evt = EOS_SPI_EVT_SDC,
+    },
+    {   // DEV_CAM
+        .div = SPI_DIV_CAM,
+        .csid = SPI_CSID_CAM,
+        .cspin = SPI_CSPIN_CAM,
+        .evt = EOS_SPI_EVT_CAM,
+    },
+};
diff --git a/fw/fe310/eos/spi_dev.c b/fw/fe310/eos/spi_dev.c
new file mode 100644
index 0000000..0448f76
--- /dev/null
+++ b/fw/fe310/eos/spi_dev.c
@@ -0,0 +1,93 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "eos.h"
+#include "msgq.h"
+#include "interrupt.h"
+#include "event.h"
+
+#include "board.h"
+
+#include "net.h"
+#include "spi.h"
+#include "spi_priv.h"
+#include "spi_cfg.h"
+#include "spi_dev.h"
+
+static uint8_t spi_dev;
+static uint8_t spi_lock;
+static uint16_t spi_div[EOS_SPI_MAX_DEV];
+
+void eos_spi_dev_init(void) {
+    int i;
+
+    for (i=0; i<EOS_SPI_MAX_DEV; i++) {
+        spi_div[i] = spi_cfg[i].div;
+        if (spi_cfg[i].csid == SPI_CSID_NONE) {
+            GPIO_REG(GPIO_INPUT_EN)     &= ~(1 << spi_cfg[i].cspin);
+            GPIO_REG(GPIO_OUTPUT_EN)    |=  (1 << spi_cfg[i].cspin);
+            GPIO_REG(GPIO_PULLUP_EN)    &= ~(1 << spi_cfg[i].cspin);
+            GPIO_REG(GPIO_OUTPUT_XOR)   &= ~(1 << spi_cfg[i].cspin);
+            GPIO_REG(GPIO_OUTPUT_VAL)   |=  (1 << spi_cfg[i].cspin);
+        }
+    }
+}
+
+int eos_spi_select(unsigned char dev) {
+    if (dev == EOS_SPI_DEV_NET) return EOS_ERR;
+    if (spi_lock) return EOS_ERR_BUSY;
+
+    if (spi_dev == EOS_SPI_DEV_NET) {
+        eos_net_stop();
+    } else {
+        eos_spi_stop();
+    }
+
+    spi_dev = dev;
+    eos_spi_start(spi_div[dev], spi_cfg[dev].csid, spi_cfg[dev].cspin, spi_cfg[dev].evt);
+
+    return EOS_OK;
+}
+
+int eos_spi_deselect(void) {
+    if (spi_dev == EOS_SPI_DEV_NET) return EOS_ERR;
+    if (spi_lock) return EOS_ERR_BUSY;
+
+    eos_spi_stop();
+
+    spi_dev = EOS_SPI_DEV_NET;
+    eos_net_start(0);
+
+    return EOS_OK;
+}
+
+uint8_t eos_spi_dev(void) {
+    return spi_dev;
+}
+
+uint16_t eos_spi_div(unsigned char dev) {
+    return spi_div[dev];
+}
+
+uint8_t eos_spi_csid(unsigned char dev) {
+    return spi_cfg[dev].csid;
+}
+
+uint8_t eos_spi_cspin(unsigned char dev) {
+    return spi_cfg[dev].cspin;
+}
+
+void eos_spi_lock(void) {
+    spi_lock = 1;
+}
+
+void eos_spi_unlock(void) {
+    spi_lock = 0;
+}
+
+void eos_spi_set_div(unsigned char dev, uint16_t div) {
+    spi_div[dev] = div;
+}
diff --git a/fw/fe310/eos/spi_dev.h b/fw/fe310/eos/spi_dev.h
new file mode 100644
index 0000000..ff0e2a6
--- /dev/null
+++ b/fw/fe310/eos/spi_dev.h
@@ -0,0 +1,21 @@
+#include <stdint.h>
+
+#define EOS_SPI_DEV_NET         0
+#define EOS_SPI_DEV_EVE         1
+#define EOS_SPI_DEV_SDC         2
+#define EOS_SPI_DEV_CAM         3
+
+#define EOS_SPI_MAX_DEV         4
+
+void eos_spi_dev_init(void);
+int eos_spi_select(unsigned char dev);
+int eos_spi_deselect(void);
+
+uint8_t eos_spi_dev(void);
+uint16_t eos_spi_div(unsigned char dev);
+uint8_t eos_spi_csid(unsigned char dev);
+uint8_t eos_spi_cspin(unsigned char dev);
+
+void eos_spi_lock(void);
+void eos_spi_unlock(void);
+void eos_spi_set_div(unsigned char dev, uint16_t div);
diff --git a/fw/fe310/eos/spi_priv.h b/fw/fe310/eos/spi_priv.h
new file mode 100644
index 0000000..72c2dae
--- /dev/null
+++ b/fw/fe310/eos/spi_priv.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+
+#define SPI_CSID_NONE           1
+#define SPI_CSPIN_NONE          0xff
+
+/* DO NOT TOUCH THEESE */
+#define SPI_SIZE_CHUNK          4
+#define SPI_SIZE_WM             2
diff --git a/fw/fe310/eos/timer.c b/fw/fe310/eos/timer.c
new file mode 100644
index 0000000..d8cf107
--- /dev/null
+++ b/fw/fe310/eos/timer.c
@@ -0,0 +1,135 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "msgq.h"
+#include "event.h"
+#include "timer.h"
+
+#define MIN(X, Y)               (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y)               (((X) > (Y)) ? (X) : (Y))
+
+static eos_timer_handler_t timer_handler[EOS_TIMER_MAX_ETYPE + 1];
+static uint64_t timer_next[EOS_TIMER_MAX_ETYPE + 1];
+
+static void timer_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char idx = (type & ~EOS_EVT_MASK);
+
+    if (idx && (idx <= EOS_TIMER_MAX_ETYPE) && timer_handler[idx]) {
+        timer_handler[idx](type);
+    } else {
+        eos_evtq_bad_handler(type, buffer, len);
+    }
+}
+
+void _eos_timer_handle(void) {
+    int i;
+    volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+    uint64_t *mtimecmp = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+    uint64_t now = *mtime;
+    uint64_t next = 0;
+
+    for (i = 0; i <= EOS_TIMER_MAX_ETYPE; i++) {
+        if (timer_next[i] && (timer_next[i] <= now)) {
+            timer_next[i] = 0;
+            if (i == 0) {
+                timer_handler[0](0);
+            } else {
+                eos_evtq_push_isr(EOS_EVT_TIMER | i, NULL, 0);
+            }
+        }
+        next = next && timer_next[i] ? MIN(next, timer_next[i]) : (next ? next : timer_next[i]);
+    }
+    *mtimecmp = next;
+    if (*mtimecmp == 0) clear_csr(mie, MIP_MTIP);
+}
+
+void eos_timer_init(void) {
+    int i;
+    uint64_t *mtimecmp = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+
+    clear_csr(mie, MIP_MTIP);
+    *mtimecmp = 0;
+    for (i=0; i<=EOS_TIMER_MAX_ETYPE; i++) {
+        timer_next[i] = 0;
+        timer_handler[i] = NULL;
+    }
+    eos_evtq_set_handler(EOS_EVT_TIMER, timer_handle_evt);
+}
+
+void eos_timer_set_handler(unsigned char evt, eos_timer_handler_t handler) {
+    uint64_t *mtimecmp = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+
+    if (!evt && (*mtimecmp != 0)) clear_csr(mie, MIP_MTIP);
+    timer_handler[evt] = handler;
+    if (!evt && (*mtimecmp != 0)) set_csr(mie, MIP_MTIP);
+}
+
+uint32_t eos_timer_get(unsigned char evt) {
+    volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+    uint64_t *mtimecmp = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+    uint64_t now;
+    uint32_t ret;
+
+    if (*mtimecmp != 0) clear_csr(mie, MIP_MTIP);
+    now = *mtime;
+    if (timer_next[evt]) {
+        ret = (timer_next[evt] > now) ? (timer_next[evt] - now) * 1000 / EOS_TIMER_RTC_FREQ : 0;
+    } else {
+        ret = EOS_TIMER_NONE;
+    }
+    if (*mtimecmp != 0) set_csr(mie, MIP_MTIP);
+
+    return ret;
+}
+
+void eos_timer_set(uint32_t msec, unsigned char evt) {
+    int i;
+    volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+    uint64_t *mtimecmp = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+    uint64_t tick = *mtime + msec * (uint64_t)EOS_TIMER_RTC_FREQ / 1000;
+    uint64_t next = 0;
+
+    if (*mtimecmp != 0) clear_csr(mie, MIP_MTIP);
+    timer_next[evt] = tick;
+    for (i = 0; i <= EOS_TIMER_MAX_ETYPE; i++) {
+        next = next && timer_next[i] ? MIN(next, timer_next[i]) : (next ? next : timer_next[i]);
+    }
+    *mtimecmp = next;
+    if (*mtimecmp != 0) set_csr(mie, MIP_MTIP);
+}
+
+void eos_timer_clear(unsigned char evt) {
+    int i;
+    uint64_t *mtimecmp = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+    uint64_t next = 0;
+
+    if (*mtimecmp != 0) clear_csr(mie, MIP_MTIP);
+    if (timer_next[evt]) {
+        timer_next[evt] = 0;
+        for (i = 0; i <= EOS_TIMER_MAX_ETYPE; i++) {
+            next = next && timer_next[i] ? MIN(next, timer_next[i]) : (next ? next : timer_next[i]);
+        }
+        *mtimecmp = next;
+    }
+    if (*mtimecmp != 0) set_csr(mie, MIP_MTIP);
+}
+
+
+void eos_time_sleep(uint32_t msec) {
+    volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+    uint64_t now_ms = *mtime * 1000 / EOS_TIMER_RTC_FREQ;
+
+    while (*mtime * 1000 / EOS_TIMER_RTC_FREQ < now_ms + msec);
+}
+
+uint64_t eos_time_get_tick(void) {
+    volatile uint64_t *mtime = (uint64_t *) (CLINT_CTRL_ADDR + CLINT_MTIME);
+    return *mtime;
+}
+
+uint32_t eos_time_since(uint32_t start) {
+    return (eos_time_get_tick() - start) * 1000 / EOS_TIMER_RTC_FREQ;
+ }
diff --git a/fw/fe310/eos/timer.h b/fw/fe310/eos/timer.h
new file mode 100644
index 0000000..99ffa7a
--- /dev/null
+++ b/fw/fe310/eos/timer.h
@@ -0,0 +1,23 @@
+#include <stdint.h>
+
+#define EOS_TIMER_ETYPE_UI      1
+#define EOS_TIMER_ETYPE_ECP     2
+#define EOS_TIMER_ETYPE_USER    4
+
+#define EOS_TIMER_MAX_ETYPE     4
+
+#define EOS_TIMER_NONE          0xffffffff
+#define EOS_TIMER_RTC_FREQ      32768
+
+typedef void (*eos_timer_handler_t) (unsigned char);
+
+void eos_timer_init(void);
+void eos_timer_set_handler(unsigned char evt, eos_timer_handler_t handler);
+
+uint32_t eos_timer_get(unsigned char evt);
+void eos_timer_set(uint32_t msec, unsigned char evt);
+void eos_timer_clear(unsigned char evt);
+
+void eos_time_sleep(uint32_t msec);
+uint64_t eos_time_get_tick(void);
+uint32_t eos_time_since(uint32_t start);
diff --git a/fw/fe310/eos/trap_entry.S b/fw/fe310/eos/trap_entry.S
new file mode 100644
index 0000000..d54243f
--- /dev/null
+++ b/fw/fe310/eos/trap_entry.S
@@ -0,0 +1,517 @@
+#include "encoding.h"
+#include "sifive/bits.h"
+
+#define MCAUSE_INT        0x80000000
+#define MCAUSE_EXT        (MCAUSE_INT | IRQ_M_EXT)
+#define MCAUSE_TIMER      (MCAUSE_INT | IRQ_M_TIMER)
+
+#define PLIC_PRIORITY     0x0C000000
+#define PLIC_THRESHOLD    0x0C200000
+#define PLIC_CLAIM        0x0C200004
+
+#define PWM0_CTRL_ADDR    0x10015000
+#define PWM1_CTRL_ADDR    0x10025000
+#define PWM2_CTRL_ADDR    0x10035000
+#include "sifive/devices/pwm.h"
+
+#define GPIO_CTRL_ADDR    0x10012000
+#include "sifive/devices/gpio.h"
+
+#define SPI0_CTRL_ADDR    0x10014000
+#define SPI1_CTRL_ADDR    0x10024000
+#include "sifive/devices/spi.h"
+
+#define INT_PWM0_BASE     40
+#define INT_PWM1_BASE     44
+#define INT_PWM2_BASE     48
+
+#include "board.h"
+#include "irq_def.h"
+#include "evt_def.h"
+#include "i2s_def.h"
+#include "i2s_priv.h"
+#include "msgq_priv.h"
+
+  .section      .data.entry
+  .align 4
+
+.global eos_trap_entry
+eos_trap_entry:
+  addi sp, sp, -8*REGBYTES
+  STORE x8, 0*REGBYTES(sp)
+  STORE x9, 1*REGBYTES(sp)
+  STORE x18, 2*REGBYTES(sp)
+  STORE x19, 3*REGBYTES(sp)
+  STORE x20, 4*REGBYTES(sp)
+  STORE x21, 5*REGBYTES(sp)
+  STORE x22, 6*REGBYTES(sp)
+  STORE x23, 7*REGBYTES(sp)
+
+  csrr x8, mcause
+  li x18, MCAUSE_EXT
+  bne x8, x18, handle_intr
+  li x18, PLIC_CLAIM
+  lw x9, 0(x18)
+  li x18, I2S_IRQ_WS_ID
+  beq x9, x18, i2s_handle_ws
+  li x18, I2S_IRQ_SD_ID
+  beq x9, x18, i2s_handle_sd
+  j handle_intr
+
+evtq_push:
+  la x9, _eos_event_q
+  lbu x18, MSGQ_OFF_IDXR(x9)
+  lbu x19, MSGQ_OFF_IDXW(x9)
+  lbu x20, MSGQ_OFF_SIZE(x9)
+
+  sub x18, x19, x18
+  andi x18, x18, 0xff
+  beq x18, x20, 0f
+
+  addi x20, x20, -1
+  and x20, x20, x19
+  li x18, MSGQ_ITEM_SIZE
+  mul x20, x20, x18
+  lw x21, MSGQ_OFF_ARRAY(x9)
+  add x21, x21, x20
+
+  addi x19, x19, 1
+  sb x19, MSGQ_OFF_IDXW(x9)
+  jalr x0, x22
+
+0:
+  mv x20, x0
+  jalr x0, x21
+
+i2s_handle_sd:
+  # exit if too early
+  li x18, I2S_CTRL_ADDR_WS_SPK
+  lw x8, PWM_COUNT(x18)
+  lw x9, PWM_CMP3(x18)
+  bltu x8, x9, i2s_handle_sd_exit
+
+  # disable sd irq
+  li x18, PLIC_PRIORITY
+  sw x0, 4*I2S_IRQ_SD_ID(x18)
+
+  la x9, _eos_i2s_fmt
+  lw x23, 0(x9)
+
+i2s_abuf_pop:
+  # pop from spk buf -> x8
+  mv x8, x0
+  la x9, _eos_i2s_spk_buf
+  lhu x18, I2S_ABUF_OFF_IDXR(x9)
+  lhu x19, I2S_ABUF_OFF_IDXW(x9)
+  lhu x20, I2S_ABUF_OFF_SIZE(x9)
+
+  beq x18, x19, i2s_handle_sd_xchg
+
+  addi x20, x20, -1
+  and x20, x20, x18
+  lw x21, I2S_ABUF_OFF_ARRAY(x9)
+  add x21, x21, x20
+  bnez x23, 0f
+  lbu x8, 0(x21)
+  addi x18, x18, 1
+  j 1f
+0:
+  lb x8, 0(x21)
+  lbu x20, 1(x21)
+  slli x8, x8, 8
+  or x8, x8, x20
+  addi x18, x18, 2
+1:
+  sh x18, I2S_ABUF_OFF_IDXR(x9)
+
+  li x21, 0xffff
+  sub x18, x19, x18
+  and x18, x18, x21
+
+  # check for push to event queue
+  la x9, _eos_i2s_spk_wm
+  lw x20, 0(x9)
+  beqz x20, i2s_decode
+  bgtu x18, x20, i2s_decode
+
+  la x9, _eos_i2s_spk_evt_enable
+  lw x18, 0(x9)
+  beqz x18, i2s_decode
+  sw x0, 0(x9)
+
+  # push to event queue
+  jal x22, evtq_push
+  beqz x21, i2s_decode
+  li x18, (EOS_EVT_I2S | EOS_I2S_ETYPE_SPK)
+  sb x18, MSGQ_ITEM_OFF_TYPE(x21)
+
+i2s_decode:
+  bnez x23, i2s_handle_sd_xchg
+  # aLaw decode -> x8
+  xori x8, x8, 0x55
+  andi x9, x8, 0x80
+  beqz x9, 0f
+  li x9, 1
+  slli x9, x9, 7
+  not x9, x9
+  and x8, x8, x9
+  li x9, -1
+0:
+  andi x18, x8, 0xf0
+  srli x18, x18, 4
+  addi x18, x18, 4
+
+  li x19, 4
+  beq x18, x19, 1f
+
+  andi x8, x8, 0x0f
+  addi x19, x18, -4
+  sll x8, x8, x19
+
+  li x19, 1
+  sll x19, x19, x18
+  or x8, x8, x19
+
+  li x19, 1
+  addi x18, x18, -5
+  sll x19, x19, x18
+  or x8, x8, x19
+  j 2f
+1:
+  slli x8, x8, 1
+  ori x8, x8, 1
+2:
+  beqz x9, i2s_handle_sd_xchg
+  mul x8, x8, x9
+
+i2s_handle_sd_xchg:
+  # read/write shift reg: x8 -> sr -> x8
+  li x18, GPIO_CTRL_ADDR
+  li x19, (0x1 << I2S_PIN_SD_IN)
+  li x20, (0x1 << I2S_PIN_SD_OUT)
+  li x21, (0x1 << I2S_PIN_CK_SR)
+  lw x22, GPIO_OUTPUT_VAL(x18)
+
+  lw x9, GPIO_OUTPUT_EN(x18)
+  or x9, x9, x20
+  sw x9, GPIO_OUTPUT_EN(x18)
+
+  not x20, x20
+  xor x22, x22, x21
+
+  li x23, 16
+0:
+  # write bit
+  li x9, 1
+  slli x9, x9, 15
+  and x9, x8, x9
+  slli x8, x8, 1
+#if I2S_PIN_SD_OUT > 15
+  slli x9, x9, (I2S_PIN_SD_OUT - 15)
+#else
+  srli x9, x9, (15 - I2S_PIN_SD_OUT)
+#endif
+  and x22, x22, x20
+  or x22, x22, x9
+
+  # read bit
+  lw x9, GPIO_INPUT_VAL(x18)
+  and x9, x9, x19
+  srli x9, x9, I2S_PIN_SD_IN
+  or x8, x8, x9
+
+  # 74HC595 ck low (I2S_PIN_CK_SR high)
+  xor x22, x22, x21
+  sw x22, GPIO_OUTPUT_VAL(x18)
+
+  # idle
+  li x9, I2S_IDLE_CYCLES
+1:
+  addi x9, x9, -1
+  bnez x9, 1b
+
+  # 74HC595 ck high (I2S_PIN_CK_SR low)
+  xor x22, x22, x21
+  sw x22, GPIO_OUTPUT_VAL(x18)
+
+  # idle
+  li x9, I2S_IDLE_CYCLES
+1:
+  addi x9, x9, -1
+  bnez x9, 1b
+
+  addi x23, x23, -1
+  beqz x23, 2f
+  j 0b
+
+2:
+  # 74HC595 ck low (I2S_PIN_CK_SR high)
+  xor x22, x22, x21
+  sw x22, GPIO_OUTPUT_VAL(x18)
+
+  lw x9, GPIO_OUTPUT_EN(x18)
+  and x9, x9, x20
+  sw x9, GPIO_OUTPUT_EN(x18)
+
+  slli x8, x8, 16
+  srai x8, x8, 16
+
+  la x9, _eos_i2s_fmt
+  lw x23, 0(x9)
+
+i2s_encode:
+  bnez x23, i2s_abuf_push
+  # aLaw encode -> x8
+  li x18, 0x800
+  li x19, 7
+  bgez x8, 0f
+  neg x8, x8
+  lui x9, 0x80000
+  or x8, x8, x9
+0:
+  and x9, x8, x18
+  beq x9, x18, 1f
+  beqz x19, 1f
+  srli x18, x18, 1
+  addi x19, x19, -1
+  j 0b
+1:
+  mv x9, x19
+  bnez x9, 2f
+  addi x9, x9, 1
+2:
+  sra x8, x8, x9
+  li x9, 0x8000000f
+  and x8, x8, x9
+  slli x19, x19, 4
+  or x8, x8, x19
+  bgez x8, 3f
+  ori x8, x8, 0x80
+3:
+  xori x8, x8, 0x55
+  andi x8, x8, 0xff
+
+i2s_abuf_push:
+  # push to mic buf
+  la x9, _eos_i2s_mic_buf
+  lhu x18, I2S_ABUF_OFF_IDXR(x9)
+  lhu x19, I2S_ABUF_OFF_IDXW(x9)
+  lhu x20, I2S_ABUF_OFF_SIZE(x9)
+  li x21, 0xffff
+
+  sub x18, x19, x18
+  and x18, x18, x21
+  beq x18, x20, i2s_handle_sd_exit
+
+  addi x20, x20, -1
+  and x20, x20, x19
+  lw x21, I2S_ABUF_OFF_ARRAY(x9)
+  add x21, x21, x20
+  bnez x23, 0f
+  sb x8, 0(x21)
+  addi x19, x19, 1
+  addi x18, x18, 1
+  j 1f
+0:
+  sb x8, 1(x21)
+  srli x8, x8, 8
+  sb x8, 0(x21)
+  addi x19, x19, 2
+  addi x18, x18, 2
+1:
+  sh x19, I2S_ABUF_OFF_IDXW(x9)
+
+  # check for push to event queue
+  la x9, _eos_i2s_mic_wm
+  lw x20, 0(x9)
+  beqz x20, i2s_handle_sd_exit
+  bltu x18, x20, i2s_handle_sd_exit
+
+  la x9, _eos_i2s_mic_evt_enable
+  lw x18, 0(x9)
+  beqz x18, i2s_handle_sd_exit
+  sw x0, 0(x9)
+
+  # push to event queue
+  jal x22, evtq_push
+  beqz x21, i2s_handle_sd_exit
+  li x18, (EOS_EVT_I2S | EOS_I2S_ETYPE_MIC)
+  sb x18, MSGQ_ITEM_OFF_TYPE(x21)
+
+i2s_handle_sd_exit:
+  # complete
+  li x18, I2S_IRQ_SD_ID
+  li x19, PLIC_CLAIM
+  sw x18, 0(x19)
+
+  # exit
+  j trap_exit_data
+
+i2s_handle_ws:
+  # enable sd irq
+  li x18, PLIC_PRIORITY
+  li x19, IRQ_PRIORITY_I2S_SD
+  sw x19, 4*I2S_IRQ_SD_ID(x18)
+
+  # complete
+  li x18, I2S_IRQ_WS_ID
+  li x19, PLIC_CLAIM
+  sw x18, 0(x19)
+
+  # exit
+  j trap_exit_data
+
+.global _eos_i2s_start_pwm
+_eos_i2s_start_pwm:
+  addi sp, sp, -8*REGBYTES
+  STORE x8, 0*REGBYTES(sp)
+  STORE x9, 1*REGBYTES(sp)
+  STORE x18, 2*REGBYTES(sp)
+  STORE x19, 3*REGBYTES(sp)
+  STORE x20, 4*REGBYTES(sp)
+  STORE x21, 5*REGBYTES(sp)
+  STORE x22, 6*REGBYTES(sp)
+  STORE x23, 7*REGBYTES(sp)
+
+  li x18, I2S_CTRL_ADDR_CK
+  li x19, I2S_CTRL_ADDR_WS_MIC
+  li x20, I2S_CTRL_ADDR_WS_SPK
+  li x21, PWM_CFG_ENALWAYS | PWM_CFG_ZEROCMP | I2S_PWM_SCALE_CK
+  li x22, PWM_CFG_ENALWAYS | PWM_CFG_ZEROCMP | PWM_CFG_CMP2GANG
+  li x23, PWM_CFG_ENALWAYS | PWM_CFG_ZEROCMP | PWM_CFG_CMP1GANG
+  sw x21, PWM_CFG(x18)
+  sw x22, PWM_CFG(x19)
+  sw x23, PWM_CFG(x20)
+
+  LOAD x8, 0*REGBYTES(sp)
+  LOAD x9, 1*REGBYTES(sp)
+  LOAD x18, 2*REGBYTES(sp)
+  LOAD x19, 3*REGBYTES(sp)
+  LOAD x20, 4*REGBYTES(sp)
+  LOAD x21, 5*REGBYTES(sp)
+  LOAD x22, 6*REGBYTES(sp)
+  LOAD x23, 7*REGBYTES(sp)
+  addi sp, sp, 8*REGBYTES
+
+  ret
+
+.global _eos_flash_set
+_eos_flash_set:
+  li a3, SPI0_CTRL_ADDR
+  sw x0, SPI_REG_FCTRL(a3)
+  sw a0, SPI_REG_SCKDIV(a3)
+  sw a1, SPI_REG_FFMT(a3)
+  li a0, 1
+  sw a0, SPI_REG_FCTRL(a3)
+  ret
+
+trap_exit_data:
+  # Remain in M-mode after mret
+  li x18, MSTATUS_MPP
+  csrs mstatus, x18
+
+  LOAD x8, 0*REGBYTES(sp)
+  LOAD x9, 1*REGBYTES(sp)
+  LOAD x18, 2*REGBYTES(sp)
+  LOAD x19, 3*REGBYTES(sp)
+  LOAD x20, 4*REGBYTES(sp)
+  LOAD x21, 5*REGBYTES(sp)
+  LOAD x22, 6*REGBYTES(sp)
+  LOAD x23, 7*REGBYTES(sp)
+  addi sp, sp, 8*REGBYTES
+
+  mret
+
+handle_intr:
+  lui x18,       %hi(trap_entry_text)
+  addi x18, x18, %lo(trap_entry_text)
+  jalr x0, x18
+
+  .section      .text.entry
+  .align 2
+
+trap_entry_text:
+  addi sp, sp, -24*REGBYTES
+
+  STORE x1, 0*REGBYTES(sp)
+  STORE x2, 1*REGBYTES(sp)
+  STORE x3, 2*REGBYTES(sp)
+  STORE x4, 3*REGBYTES(sp)
+  STORE x5, 4*REGBYTES(sp)
+  STORE x6, 5*REGBYTES(sp)
+  STORE x7, 6*REGBYTES(sp)
+  STORE x10, 7*REGBYTES(sp)
+  STORE x11, 8*REGBYTES(sp)
+  STORE x12, 9*REGBYTES(sp)
+  STORE x13, 10*REGBYTES(sp)
+  STORE x14, 11*REGBYTES(sp)
+  STORE x15, 12*REGBYTES(sp)
+  STORE x16, 13*REGBYTES(sp)
+  STORE x17, 14*REGBYTES(sp)
+  STORE x24, 15*REGBYTES(sp)
+  STORE x25, 16*REGBYTES(sp)
+  STORE x26, 17*REGBYTES(sp)
+  STORE x27, 18*REGBYTES(sp)
+  STORE x28, 19*REGBYTES(sp)
+  STORE x29, 20*REGBYTES(sp)
+  STORE x30, 21*REGBYTES(sp)
+  STORE x31, 22*REGBYTES(sp)
+
+  li x18, MCAUSE_TIMER
+  beq x8, x18, handle_timer
+  li x18, MCAUSE_EXT
+  beq x8, x18, handle_ext
+  mv a0, x8
+  call _exit
+
+handle_timer:
+  call _eos_timer_handle
+  j trap_exit_text
+
+handle_ext:
+  mv a0, x9
+  call eos_intr_handle
+  li x18, PLIC_CLAIM
+  sw a0, 0(x18)
+  j trap_exit_text
+
+trap_exit_text:
+  # Remain in M-mode after mret
+  li t0, MSTATUS_MPP
+  csrs mstatus, t0
+
+  LOAD x1, 0*REGBYTES(sp)
+  LOAD x2, 1*REGBYTES(sp)
+  LOAD x3, 2*REGBYTES(sp)
+  LOAD x4, 3*REGBYTES(sp)
+  LOAD x5, 4*REGBYTES(sp)
+  LOAD x6, 5*REGBYTES(sp)
+  LOAD x7, 6*REGBYTES(sp)
+  LOAD x10, 7*REGBYTES(sp)
+  LOAD x11, 8*REGBYTES(sp)
+  LOAD x12, 9*REGBYTES(sp)
+  LOAD x13, 10*REGBYTES(sp)
+  LOAD x14, 11*REGBYTES(sp)
+  LOAD x15, 12*REGBYTES(sp)
+  LOAD x16, 13*REGBYTES(sp)
+  LOAD x17, 14*REGBYTES(sp)
+  LOAD x24, 15*REGBYTES(sp)
+  LOAD x25, 16*REGBYTES(sp)
+  LOAD x26, 17*REGBYTES(sp)
+  LOAD x27, 18*REGBYTES(sp)
+  LOAD x28, 19*REGBYTES(sp)
+  LOAD x29, 20*REGBYTES(sp)
+  LOAD x30, 21*REGBYTES(sp)
+  LOAD x31, 22*REGBYTES(sp)
+
+  LOAD x8, 24*REGBYTES(sp)
+  LOAD x9, 25*REGBYTES(sp)
+  LOAD x18, 26*REGBYTES(sp)
+  LOAD x19, 27*REGBYTES(sp)
+  LOAD x20, 28*REGBYTES(sp)
+  LOAD x21, 29*REGBYTES(sp)
+  LOAD x22, 30*REGBYTES(sp)
+  LOAD x23, 31*REGBYTES(sp)
+
+  addi sp, sp, 32*REGBYTES
+  mret
diff --git a/fw/fe310/eos/uart.c b/fw/fe310/eos/uart.c
new file mode 100644
index 0000000..c10b6d5
--- /dev/null
+++ b/fw/fe310/eos/uart.c
@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "encoding.h"
+#include "platform.h"
+
+#include "eos.h"
+#include "interrupt.h"
+#include "event.h"
+
+#include "uart.h"
+
+static eos_uart_handler_t uart_handler[EOS_UART_MAX_ETYPE];
+
+static void uart_handle_evt(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char idx = (type & ~EOS_EVT_MASK) - 1;
+
+    if ((idx < EOS_UART_MAX_ETYPE) && uart_handler[idx]) {
+        uart_handler[idx](type);
+    } else {
+        eos_evtq_bad_handler(type, buffer, len);
+    }
+}
+
+static void uart_handle_intr(void) {
+    if (UART0_REG(UART_REG_IP) & UART_IP_TXWM) {
+        UART0_REG(UART_REG_IE) &= ~UART_IP_TXWM;
+        eos_evtq_push_isr(EOS_EVT_UART | EOS_UART_ETYPE_TX, NULL, 0);
+    }
+    if (UART0_REG(UART_REG_IP) & UART_IP_RXWM) {
+        UART0_REG(UART_REG_IE) &= ~UART_IP_RXWM;
+        eos_evtq_push_isr(EOS_EVT_UART | EOS_UART_ETYPE_RX, NULL, 0);
+    }
+}
+
+void eos_uart_init(void) {
+    int i;
+
+    for (i=0; i<EOS_UART_MAX_ETYPE; i++) {
+        uart_handler[i] = NULL;
+    }
+    eos_evtq_set_handler(EOS_EVT_UART, uart_handle_evt);
+    eos_intr_set(INT_UART0_BASE, IRQ_PRIORITY_UART, uart_handle_intr);
+}
+
+void eos_uart_set_handler(unsigned char type, eos_uart_handler_t handler) {
+    if (type && (type <= EOS_UART_MAX_ETYPE)) uart_handler[type - 1] = handler;
+}
+
+void eos_uart_txwm_set(uint8_t wm) {
+    UART0_REG(UART_REG_TXCTRL)  &= ~UART_TXWM(0xFFFF);
+    UART0_REG(UART_REG_TXCTRL)  |=  UART_TXWM(wm);
+    UART0_REG(UART_REG_IE)      |=  UART_IP_TXWM;
+}
+
+void eos_uart_txwm_clear(void) {
+    UART0_REG(UART_REG_IE)      &= ~UART_IP_TXWM;
+}
+
+void eos_uart_rxwm_set(uint8_t wm) {
+    UART0_REG(UART_REG_RXCTRL)  &= ~UART_RXWM(0xFFFF);
+    UART0_REG(UART_REG_RXCTRL)  |=  UART_RXWM(wm);
+    UART0_REG(UART_REG_IE)      |=  UART_IP_RXWM;
+}
+
+void eos_uart_rxwm_clear(void) {
+    UART0_REG(UART_REG_IE)      &= ~UART_IP_RXWM;
+}
+
+int eos_uart_putc(int c, char b) {
+    if (b) {
+        while (UART0_REG(UART_REG_TXFIFO) & 0x80000000);
+        UART0_REG(UART_REG_TXFIFO) = c & 0xff;
+    } else {
+        if (UART0_REG(UART_REG_TXFIFO) & 0x80000000) return EOS_ERR_FULL;
+        UART0_REG(UART_REG_TXFIFO) = c & 0xff;
+    }
+    return EOS_OK;
+}
+
+int eos_uart_getc(char b) {
+    volatile uint32_t r;
+
+    if (b) {
+        while ((r = UART0_REG(UART_REG_RXFIFO)) & 0x80000000);
+    } else {
+        r = UART0_REG(UART_REG_RXFIFO);
+        if (r & 0x80000000) return EOS_ERR_EMPTY;
+    }
+    return r & 0xff;
+}
\ No newline at end of file
diff --git a/fw/fe310/eos/uart.h b/fw/fe310/eos/uart.h
new file mode 100644
index 0000000..da5faab
--- /dev/null
+++ b/fw/fe310/eos/uart.h
@@ -0,0 +1,18 @@
+#include <stdint.h>
+
+#define EOS_UART_ETYPE_TX       1
+#define EOS_UART_ETYPE_RX       2
+
+#define EOS_UART_MAX_ETYPE      2
+
+typedef void (*eos_uart_handler_t) (unsigned char);
+
+void eos_uart_init(void);
+void eos_uart_set_handler(unsigned char type, eos_uart_handler_t handler);
+
+void eos_uart_txwm_set(uint8_t wm);
+void eos_uart_txwm_clear(void);
+void eos_uart_rxwm_set(uint8_t wm);
+void eos_uart_rxwm_clear(void);
+int eos_uart_putc(int c, char b);
+int eos_uart_getc(char b);
\ No newline at end of file
diff --git a/fw/fe310/eos/unicode.c b/fw/fe310/eos/unicode.c
new file mode 100644
index 0000000..29100c7
--- /dev/null
+++ b/fw/fe310/eos/unicode.c
@@ -0,0 +1,195 @@
+#include "unicode.h"
+
+int utf8_enc(utf32_t ch, utf8_t *str) {
+    if (ch <= 0x7f) {
+        str[0] = ch;
+        return 1;
+    } else if (ch <= 0x7ff) {
+        str[0] = 0xc0 | (ch >> 6);
+        str[1] = 0x80 | (ch & 0x3f);
+        return 2;
+    } else if (ch <= 0xffff) {
+        if ((ch >= 0xd800) && (ch <= 0xdfff)) return UTF_ERR;
+        str[0] = 0xe0 | (ch >> 12);
+        str[1] = 0x80 | ((ch >> 6) & 0x3f);
+        str[2] = 0x80 | (ch & 0x3f);
+        return 3;
+    } else if (ch <= 0x10ffff) {
+        str[0] = 0xf0 | (ch >> 18);
+        str[1] = 0x80 | ((ch >> 12) & 0x3f);
+        str[2] = 0x80 | ((ch >> 6) & 0x3f);
+        str[3] = 0x80 | (ch & 0x3f);
+        return 4;
+    } else {
+        return UTF_ERR;
+    }
+}
+
+int utf8_dec(utf8_t *str, utf32_t *ch) {
+    if ((str[0] & 0x80) == 0x00) {
+        *ch = str[0];
+        return 1;
+    } else if ((str[0] & 0xe0) == 0xc0) {
+        if ((str[1] & 0xc0) != 0x80) return UTF_ERR;
+        *ch  = (utf32_t)(str[0] & 0x1f) << 6;
+        *ch |= (utf32_t)(str[1] & 0x3f);
+        if (*ch < 0x80) return UTF_ERR;
+        return 2;
+    } else if ((str[0] & 0xf0) == 0xe0) {
+        if (((str[1] & 0xc0) != 0x80) || ((str[2] & 0xc0) != 0x80)) return UTF_ERR;
+        *ch  = (utf32_t)(str[0] & 0x0f) << 12;
+        *ch |= (utf32_t)(str[1] & 0x3f) << 6;
+        *ch |= (utf32_t)(str[2] & 0x3f);
+        if ((*ch >= 0xd800) && (*ch <= 0xdfff)) return UTF_ERR;
+        if (*ch < 0x800) return UTF_ERR;
+        return 3;
+    } else if ((str[0] & 0xf8) == 0xf0) {
+        if (((str[1] & 0xc0) != 0x80) || ((str[2] & 0xc0) != 0x80) || ((str[3] & 0xc0) != 0x80)) return UTF_ERR;
+        *ch  = (utf32_t)(str[0] & 0x07) << 18;
+        *ch |= (utf32_t)(str[1] & 0x0f) << 12;
+        *ch |= (utf32_t)(str[2] & 0x3f) << 6;
+        *ch |= (utf32_t)(str[3] & 0x3f);
+        if (*ch < 0x010000) return UTF_ERR;
+        if (*ch > 0x10ffff) return UTF_ERR;
+        return 4;
+    } else {
+        return UTF_ERR;
+    }
+}
+
+int utf8_len(utf8_t *str) {
+    if ((*str & 0xf8) == 0xf0) return 4;
+    if ((*str & 0xf0) == 0xe0) return 3;
+    if ((*str & 0xe0) == 0xc0) return 2;
+    if ((*str & 0x80) == 0x00) return 1;
+
+    return UTF_ERR;
+}
+
+int utf8_seek(utf8_t *str, int off, utf32_t *ch) {
+    int i;
+    int len = 0;
+
+    if (off < 0) {
+        off = -off;
+        for (i=0; i<off; i++) {
+            len--;
+            while ((str[len] & 0xc0) == 0x80) len--;
+        }
+    } else {
+        for (i=0; i<off; i++) {
+            if ((str[len] & 0x80) == 0x00) {
+                len += 1;
+            } else if ((str[0] & 0xe0) == 0xc0) {
+                len += 2;
+            } else if ((str[0] & 0xf0) == 0xe0) {
+                len += 3;
+            } else if ((str[0] & 0xf8) == 0xf0) {
+                len += 4;
+            }
+        }
+    }
+    utf8_dec(str + len, ch);
+    return len;
+}
+
+int utf8_verify(utf8_t *str, int str_size, int *str_len) {
+    utf32_t ch;
+    uint8_t ch_l;
+    int len = 0;
+
+    while (len < str_size) {
+        if (str_size - len < 4) {
+            int _len = utf8_len(str + len);
+            if ((_len == UTF_ERR) || ((str_size - len) < _len)) break;
+        }
+        ch_l = utf8_dec(str + len, &ch);
+        if (ch_l > 0) {
+            if (ch == 0) {
+                if (str_len) *str_len = len;
+                return UTF_OK;
+            }
+            len += ch_l;
+        } else {
+            break;
+        }
+    }
+
+    if (str_len) *str_len = len;
+    return UTF_ERR;
+}
+
+int utf16_enc(utf32_t ch, uint8_t *str) {
+    if (ch <= 0xffff) {
+        if ((ch >= 0xd800) && (ch <= 0xdfff)) return UTF_ERR;
+        str[0] = ch >> 8;
+        str[1] = ch & 0xff;
+        return 2;
+    } else if (ch <= 0x10ffff) {
+        uint16_t hi;
+        uint16_t lo;
+
+        ch -= 0x10000;
+        hi = (ch >> 10) + 0xd800;
+        lo = (ch & 0x3ff) + 0xdc00;
+        str[0] = hi >> 8;
+        str[1] = hi & 0xff;
+        str[2] = lo >> 8;
+        str[3] = lo & 0xff;
+        return 4;
+    } else {
+        return UTF_ERR;
+    }
+}
+
+int utf16_dec(uint8_t *str, utf32_t *ch) {
+    *ch = (str[0] << 8) | str[1];
+    if ((*ch >= 0xd800) && (*ch <= 0xdfff)) {
+        uint16_t hi = *ch;
+        uint16_t lo;
+
+        if (hi > 0xdbff) return UTF_ERR;
+        lo = (str[2] << 8) | str[3];
+        if ((lo < 0xdc00) || (lo > 0xdfff)) return UTF_ERR;
+        *ch = (((hi - 0xd800) << 10) | (lo - 0xdc00)) + 0x10000;
+        return 4;
+    } else {
+        return 2;
+    }
+}
+
+int utf16_len(uint8_t *str) {
+    uint16_t ch = (str[0] << 8) | str[1];
+
+    if ((ch >= 0xdc00) && (ch <= 0xdfff)) return UTF_ERR;
+    if ((ch >= 0xd800) && (ch <= 0xdfff)) return 4;
+    return 2;
+}
+
+int utf16_seek(uint8_t *str, int off, utf32_t *ch) {
+    int i;
+    int len = 0;
+    uint16_t cu;
+
+    if (off < 0) {
+        off = -off;
+        for (i=0; i<off; i++) {
+            len -= 2;
+            cu = (str[len] << 8) | str[len + 1];
+            if ((cu >= 0xdc00) && (cu <= 0xdfff)) {
+                len -= 2;
+            }
+        }
+    } else {
+        for (i=0; i<off; i++) {
+            cu = (str[len] << 8) | str[len + 1];
+            if ((cu >= 0xd800) && (cu <= 0xdbff)) {
+                len += 4;
+            } else {
+                len += 2;
+            }
+        }
+    }
+    utf16_dec(str + len, ch);
+    return len;
+}
diff --git a/fw/fe310/eos/unicode.h b/fw/fe310/eos/unicode.h
new file mode 100644
index 0000000..12fa99c
--- /dev/null
+++ b/fw/fe310/eos/unicode.h
@@ -0,0 +1,19 @@
+#include <stdint.h>
+
+#define UTF_OK      0
+#define UTF_ERR     -1
+
+typedef uint8_t utf8_t;
+typedef uint16_t utf16_t;
+typedef uint32_t utf32_t;
+
+int utf8_enc(utf32_t ch, utf8_t *str);
+int utf8_dec(utf8_t *str, utf32_t *ch);
+int utf8_len(utf8_t *str);
+int utf8_seek(utf8_t *str, int off, utf32_t *ch);
+int utf8_verify(utf8_t *str, int str_size, int *str_len);
+
+int utf16_enc(utf32_t ch, uint8_t *str);
+int utf16_dec(uint8_t *str, utf32_t *ch);
+int utf16_len(uint8_t *str);
+int utf16_seek(uint8_t *str, int off, utf32_t *ch);
diff --git a/fw/fe310/eos/wifi.c b/fw/fe310/eos/wifi.c
new file mode 100644
index 0000000..ca29a95
--- /dev/null
+++ b/fw/fe310/eos/wifi.c
@@ -0,0 +1,45 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "eos.h"
+#include "event.h"
+#include "net.h"
+
+#include "wifi.h"
+
+static eos_evt_handler_t evt_handler[EOS_WIFI_MAX_MTYPE];
+
+static void wifi_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+    unsigned char mtype;
+
+    if ((buffer == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, buffer, len);
+        return;
+    }
+
+    mtype = buffer[0];
+    if ((mtype < EOS_WIFI_MAX_MTYPE) && evt_handler[mtype]) {
+        evt_handler[mtype](mtype, buffer, len);
+    } else {
+        eos_net_bad_handler(type, buffer, len);
+    }
+}
+
+void eos_wifi_init(void) {
+    int i;
+
+    for (i=0; i<EOS_WIFI_MAX_MTYPE; i++) {
+        evt_handler[i] = NULL;
+    }
+    eos_net_set_handler(EOS_NET_MTYPE_WIFI, wifi_handle_msg);
+}
+
+void eos_wifi_set_handler(unsigned char mtype, eos_evt_handler_t handler) {
+    if (mtype < EOS_WIFI_MAX_MTYPE) evt_handler[mtype] = handler;
+}
+
+eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype) {
+    if (mtype < EOS_WIFI_MAX_MTYPE) return evt_handler[mtype];
+    return NULL;
+}
diff --git a/fw/fe310/eos/wifi.h b/fw/fe310/eos/wifi.h
new file mode 100644
index 0000000..bb629ed
--- /dev/null
+++ b/fw/fe310/eos/wifi.h
@@ -0,0 +1,13 @@
+#include <stdint.h>
+#include "event.h"
+
+#define EOS_WIFI_MTYPE_SCAN         1
+#define EOS_WIFI_MTYPE_CONFIG       2
+#define EOS_WIFI_MTYPE_CONNECT      3
+#define EOS_WIFI_MTYPE_DISCONNECT   4
+
+#define EOS_WIFI_MAX_MTYPE          5
+
+void eos_wifi_init(void);
+void eos_wifi_set_handler(unsigned char mtype, eos_evt_handler_t handler);
+eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype);