diff --git a/src/86box.c b/src/86box.c
index f8d632e11..1cd0ffec8 100644
--- a/src/86box.c
+++ b/src/86box.c
@@ -189,6 +189,7 @@ int      voodoo_enabled                         = 0;              /* (C) video o
 int      lba_enhancer_enabled                   = 0;              /* (C) enable Vision Systems LBA Enhancer */
 int      ibm8514_standalone_enabled             = 0;              /* (C) video option */
 int      xga_standalone_enabled                 = 0;              /* (C) video option */
+int      da2_standalone_enabled                 = 0;              /* (C) video option */
 uint32_t mem_size                               = 0;              /* (C) memory size (Installed on
                                                                          system board)*/
 uint32_t isa_mem_size                           = 0;              /* (C) memory size (ISA Memory Cards) */
@@ -1093,13 +1094,24 @@ pc_init_modules(void)
 void
 pc_send_ca(uint16_t sc)
 {
-    keyboard_input(1, 0x1D); /* Ctrl key pressed */
-    keyboard_input(1, 0x38); /* Alt key pressed */
-    keyboard_input(1, sc);
-    usleep(50000);
-    keyboard_input(0, sc);
-    keyboard_input(0, 0x38); /* Alt key released */
-    keyboard_input(0, 0x1D); /* Ctrl key released */
+    if (keyboard_mode == 0x8A) {
+        /* Use R-Alt because PS/55 DOS assigns L-Alt Kanji */
+        keyboard_input(1, 0x1D);  /*  Ctrl key pressed */
+        keyboard_input(1, 0x138); /* R-Alt key pressed */
+        keyboard_input(1, sc);
+        usleep(50000);
+        keyboard_input(0, sc);
+        keyboard_input(0, 0x138); /* R-Alt key released */
+        keyboard_input(0, 0x1D);  /*  Ctrl key released */
+    } else {
+        keyboard_input(1, 0x1D); /* Ctrl key pressed */
+        keyboard_input(1, 0x38); /* Alt key pressed */
+        keyboard_input(1, sc);
+        usleep(50000);
+        keyboard_input(0, sc);
+        keyboard_input(0, 0x38); /* Alt key released */
+        keyboard_input(0, 0x1D); /* Ctrl key released */
+    }
 }
 
 /* Send the machine a Control-Alt-DEL sequence. */
diff --git a/src/config.c b/src/config.c
index c52ec48ad..6c34c4790 100644
--- a/src/config.c
+++ b/src/config.c
@@ -454,6 +454,7 @@ load_video(void)
     ibm8514_active                   = ibm8514_standalone_enabled;
     xga_standalone_enabled           = !!ini_section_get_int(cat, "xga", 0);
     xga_active                       = xga_standalone_enabled;
+    da2_standalone_enabled           = !!ini_section_get_int(cat, "da2", 0);
     show_second_monitors             = !!ini_section_get_int(cat, "show_second_monitors", 1);
     video_fullscreen_scale_maximized = !!ini_section_get_int(cat, "video_fullscreen_scale_maximized", 0);
 
@@ -2139,6 +2140,11 @@ save_video(void)
     else
         ini_section_set_int(cat, "xga", xga_standalone_enabled);
 
+    if (da2_standalone_enabled == 0)
+        ini_section_delete_var(cat, "da2");
+    else
+        ini_section_set_int(cat, "da2", da2_standalone_enabled);
+
     // TODO
     for (uint8_t i = 1; i < GFXCARD_MAX; i ++) {
         if (gfxcard[i] == 0)
diff --git a/src/device/keyboard.c b/src/device/keyboard.c
index a352d8df9..2b851f36c 100644
--- a/src/device/keyboard.c
+++ b/src/device/keyboard.c
@@ -18,10 +18,13 @@
  *          Copyright 2015-2019 Miran Grca.
  *          Copyright 2017-2019 Fred N. van Kempen.
  */
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
+#include <stdlib.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include <86box/86box.h>
 #include <86box/machine.h>
 #include <86box/keyboard.h>
@@ -41,6 +44,24 @@ uint16_t key_prefix_2_2 = 0x000;     /* Invalid */
 uint16_t key_uncapture_1 = 0x058;    /* F12 */
 uint16_t key_uncapture_2 = 0x000;    /* Invalid */
 
+#ifdef ENABLE_KBC_AT_LOG
+int kbc_at_do_log = ENABLE_KBC_AT_LOG;
+
+static void
+kbc_at_log(const char* fmt, ...)
+{
+    va_list ap;
+
+    if (kbc_at_do_log) {
+        va_start(ap, fmt);
+        pclog_ex(fmt, ap);
+        va_end(ap);
+    }
+}
+#else
+#    define kbc_at_log(fmt, ...)
+#endif
+
 void (*keyboard_send)(uint16_t val);
 
 static int recv_key[512] = { 0 }; /* keyboard input buffer */
@@ -56,6 +77,67 @@ static uint8_t num_lock    = 0;
 static uint8_t scroll_lock = 0;
 static uint8_t shift       = 0;
 
+static int key5576mode = 0;
+
+typedef struct {
+    const uint16_t sc;
+    const uint8_t mk[4];
+    const uint8_t brk[4];
+} scconvtbl;
+
+/* Is this a left-over of something planned earlier? */
+#ifdef USE_SCCONV55_82
+static scconvtbl scconv55_82[18 + 1] =
+{
+    // clang-format off
+      {.sc = 0x02 , .mk = {    0x5f,   0 }, .brk = { 0xf0, 0x5f,   0 } }, /* '1' -> 'Clear/ /SysRq' */
+      {.sc = 0x03 , .mk = {    0x48,   0 }, .brk = { 0xf0, 0x48,   0 } }, /* '2' -> '終了 (Exit)' */
+      {.sc = 0x04 , .mk = {    0x38,   0 }, .brk = { 0xf0, 0x38,   0 } }, /* '3' -> 'メッセージ (Message)/ /応答 (Respond)' */
+      {.sc = 0x05 , .mk = {    0x30,   0 }, .brk = { 0xf0, 0x30,   0 } }, /* '4' -> 'サイズ変換 (Change Size)/ /横倍角 (2x Width)' */
+      {.sc = 0x06 , .mk = {    0x20,   0 }, .brk = { 0xf0, 0x20,   0 } }, /* '5' -> '単語登録 (Register Word)/ /再交換 (Re-change)' */
+      {.sc = 0x07 , .mk = {    0x28,   0 }, .brk = { 0xf0, 0x28,   0 } }, /* '6' -> '漢字 (Kanji)/ /番号 (Number)' */
+      {.sc = 0x08 , .mk = {    0x60,   0 }, .brk = { 0xf0, 0x60,   0 } }, /* '7' -> '取消 (Cancel)' */
+      {.sc = 0x09 , .mk = {    0x40,   0 }, .brk = { 0xf0, 0x40,   0 } }, /* '8' -> 'コピー (Copy)/ /移動 (Move)' */
+      {.sc = 0x3d , .mk = {    0x1f,   0 }, .brk = { 0xf0, 0x1f,   0 } }, /* 'F3' -> 'Cr Bnk/領域呼出 (Call Range)/All Cr/登録 (Register)' */
+      {.sc = 0x3e , .mk = {    0x27,   0 }, .brk = { 0xf0, 0x27,   0 } }, /* 'F4' -> '割込み (Interrupt)' */
+      {.sc = 0x3f , .mk = {    0x2f,   0 }, .brk = { 0xf0, 0x2f,   0 } }, /* 'F5' -> 'UF1' */
+      {.sc = 0x40 , .mk = {    0x5e,   0 }, .brk = { 0xf0, 0x5e,   0 } }, /* 'F6' -> 'UF2' */
+      {.sc = 0x41 , .mk = {    0x08,   0 }, .brk = { 0xf0, 0x08,   0 } }, /* 'F7' -> 'UF3' */
+      {.sc = 0x42 , .mk = {    0x10,   0 }, .brk = { 0xf0, 0x10,   0 } }, /* 'F8' -> 'UF4' */
+      {.sc = 0x43 , .mk = {    0x50,   0 }, .brk = { 0xf0, 0x50,   0 } }, /* 'F9' -> 'EOF/Erase/ErInp' */
+      {.sc = 0x44 , .mk = {    0x18,   0 }, .brk = { 0xf0, 0x18,   0 } }, /* 'F10' -> 'Attn/ /CrSel' */
+      {.sc = 0x57 , .mk = {    0x17,   0 }, .brk = { 0xf0, 0x17,   0 } }, /* 'F11' -> 'PA1/ /DvCncl' */
+      {.sc = 0x58 , .mk = {    0x37,   0 }, .brk = { 0xf0, 0x37,   0 } }, /* 'F12' -> 'PA2/ /PA3' */
+      {.sc = 0 , .mk = { 0 }, .brk = { 0 } } /* end */
+    // clang-format on
+};
+#endif
+
+static scconvtbl scconv55_8a[18 + 1] =
+{
+    // clang-format off
+      {.sc = 0x02 , .mk = {    0x48 }, .brk = {       0 } }, /* '1' -> 'Clear/ /SysRq' */
+      {.sc = 0x03 , .mk = {    0x49 }, .brk = {       0 } }, /* '2' -> '終了 (Exit)' */
+      {.sc = 0x04 , .mk = {    0x46 }, .brk = {       0 } }, /* '3' -> 'メッセージ (Message)/ /応答 (Respond)' */
+      {.sc = 0x05 , .mk = {    0x44 }, .brk = {       0 } }, /* '4' -> 'サイズ変換 (Change Size)/ /横倍角 (2x Width)' */
+      {.sc = 0x06 , .mk = {    0x42 }, .brk = {       0 } }, /* '5' -> '単語登録 (Register Word)/ /再交換 (Re-change)' */
+      {.sc = 0x07 , .mk = {    0x43 }, .brk = {       0 } }, /* '6' -> '漢字 (Kanji)/ /番号 (Number)' */
+      {.sc = 0x08 , .mk = {    0x40 }, .brk = {       0 } }, /* '7' -> '取消 (Cancel)' */
+      {.sc = 0x09 , .mk = {    0x51 }, .brk = {       0 } }, /* '8' -> 'コピー (Copy)/ /移動 (Move)' */
+      {.sc = 0x3d , .mk = {    0x76 }, .brk = {       0 } }, /* 'F3' -> 'Cr Bnk/領域呼出 (Call Range)/All Cr/登録 (Register)' */
+      {.sc = 0x3e , .mk = {    0x77 }, .brk = {       0 } }, /* 'F4' -> '割込み (Interrupt)' */
+      {.sc = 0x3f , .mk = {    0x78 }, .brk = {       0 } }, /* 'F5' -> 'UF1' */
+      {.sc = 0x40 , .mk = {    0x79 }, .brk = {       0 } }, /* 'F6' -> 'UF2' */
+      {.sc = 0x41 , .mk = {    0x7a }, .brk = {       0 } }, /* 'F7' -> 'UF3' */
+      {.sc = 0x42 , .mk = {    0x7b }, .brk = {       0 } }, /* 'F8' -> 'UF4' */
+      {.sc = 0x43 , .mk = {    0x7c }, .brk = {       0 } }, /* 'F9' -> 'EOF/Erase/ErInp' */
+      {.sc = 0x44 , .mk = {    0x7d }, .brk = {       0 } }, /* 'F10' -> 'Attn/ /CrSel' */
+      {.sc = 0x57 , .mk = {    0x7e }, .brk = {       0 } }, /* 'F11' -> 'PA1/ /DvCncl' */
+      {.sc = 0x58 , .mk = {    0x7f }, .brk = {       0 } }, /* 'F12' -> 'PA2/ /PA3' */
+      {.sc = 0 , .mk = { 0 }, .brk = { 0 } } /* end */
+    // clang-format on
+};
+
 void
 keyboard_init(void)
 {
@@ -111,6 +193,36 @@ key_process(uint16_t scan, int down)
 
     oldkey[scan] = down;
 
+    kbc_at_log("Key %04X,%d in process\n", scan, down);
+
+    c = 0;
+    /* According to Japanese DOS K3.3 manual (N:SC18-2194-1),
+      IBM 5576-002, -003 keyboards have the one-time key conversion mode
+      that emulates 18 out of 131 keys on IBM 5576-001 keyboard.
+      It is triggered by pressing L-Shift (⇧) + L-Ctrl + R-Alt (前面キー)
+      when the scancode set is 82h or 8ah.
+    */
+    if (key5576mode) {
+        int i = 0;
+        if (!down) {
+            /* Do and exit the 5576-001 emulation when a key is pressed other than trigger keys. */
+            if (scan != 0x1d && scan != 0x2a && scan != 0x138)
+            {
+                key5576mode = 0;
+                kbc_at_log("5576-001 key emulation disabled.\n");
+            }
+        }
+        while (scconv55_8a[i].sc != 0)
+        {
+            if (scconv55_8a[i].sc == scan) {
+                while (scconv55_8a[i].mk[c] != 0)
+                    keyboard_send(scconv55_8a[i].mk[c++]);
+                return;
+            }
+            i++;
+        }
+    }
+
     if (down && (codes[scan].mk[0] == 0))
         return;
 
@@ -137,6 +249,13 @@ key_process(uint16_t scan, int down)
         if (fake_shift_needed(scan))
             keyboard_send(0x101);
     }
+
+    /* Enter the 5576-001 emulation mode. */
+    if (keyboard_mode == 0x8a && down && ((keyboard_get_shift() & 0x43) == 0x43))
+    {
+        key5576mode = 1;
+        kbc_at_log("5576-001 key emulation enabled.\n");
+    }
 }
 
 /* Handle a keystroke event from the UI layer. */
@@ -232,7 +351,7 @@ keyboard_input(int down, uint16_t scan)
         }
     }
 
-    /* pclog("Received scan code: %03X (%s)\n", scan & 0x1ff, down ? "down" : "up"); */
+    /* kbc_at_log("Received scan code: %03X (%s)\n", scan & 0x1ff, down ? "down" : "up"); */
     recv_key_ui[scan & 0x1ff] = down;
 
     if (mouse_capture || !kbd_req_capture || video_fullscreen) {
diff --git a/src/device/keyboard_at.c b/src/device/keyboard_at.c
index c3cc29b78..5c66029ad 100644
--- a/src/device/keyboard_at.c
+++ b/src/device/keyboard_at.c
@@ -53,10 +53,10 @@ const uint8_t id_bytes[16][4] = { { 0x00, 0x00, 0x00, 0x00 },    /* AT 84-key */
                                   { 0x00, 0x00, 0x00, 0x00 },
                                   { 0x00, 0x00, 0x00, 0x00 },
                                   { 0x00, 0x00, 0x00, 0x00 },
-                                  { 0x00, 0x00, 0x00, 0x00 },
+                                  { 0x00, 0x00, 0x00, 0x00 },    /* FLAG_PS2 = 0x08 */
                                   { 0xab, 0x83, 0x00, 0x00 },    /* PS/2 101-key */
                                   { 0xab, 0x83, 0x00, 0x00 },    /* PS/2 102-key */
-                                  { 0xab, 0x90, 0x00, 0x00 },    /* PS/2 106-key JIS */
+                                  { 0xab, 0x90, 0x00, 0x00 },    /* PS/55 106-key JIS (IBM-J 5576-002) */
                                   /* Japanese keyboard ID - TODO: Find the actual Korean one. */
                                   { 0xab, 0x90, 0x00, 0x00 },    /* PS/2 Korean */
                                   { 0x00, 0x00, 0x00, 0x00 },
@@ -1630,6 +1630,550 @@ static const scancode scancode_set3[512] = {
   // clang-format on
 };
 
+/*  IBM Japan 5576-001, 002 and 003 keyboards have three extra scancode sets; 81h, 82h, 8ah.
+    To implement them, we need take the following into consideration.
+        * Add a UI to switch the type of keyboards and keyboard IDs.
+        * Add modified scancode set 1 and 2 (in these modes, language input keys are used as an alternative key).
+        * Japanese keyboards traditionally use a bit-paired layout. Its key mapping doesn't match with foreign keyboards.
+
+    5576 keyboards kept 101-key compatible scancode sets because PS/55 had to support western (PS/2) versions of operating systems.
+    The default scancode set is 2.
+    In Japanese DOS, the keyboard driver confirms its keyboard ID, and sends a command to switch the scancode set to 8Ah.
+    Japanese OS/2 and Windows use the scancode set 82h.
+
+    The OADG standard (1991-) and modern Japanese keyboards use the same keyboard ID and scancode set number as PS/2 keyboards use.
+    Three extra scancode sets are no longer available. Instead, language input keys are available in scancode set 1 and 2.
+    However, their physical key layout is a bit-paired layout.
+    Users have to choose the correct keyboard layout on setup, and the driver needs to remap keys.
+
+    Currently, scancode set 81h and 82h are not implemented yet. Also, the key layout is designed to match with the Japanese keyboard.
+
+     [Japanese DOS and keyboard scancode set comparison]
+    |                           | K3.3 | J4.0 | J5.0 | J4.0/V | J5.0/V | OS/2 J1.3 | DOS 5(US)|
+    |---------------------------|:----:|:----:|:----:|:------:|:------:|:---------:|:--------:|
+    | IBM 101-key               |  n/a |  n/a |  n/a |  n/a   |    2   |    n/a    |     2    |
+    | IBM-J 5576-00x (obsolete) |  8Ah |  8Ah |  8Ah |   82h  |   82h  |     82h   |     2    |
+    | OADG (modern Japanese)    |  n/a |  n/a |  n/a |    2   |    2   |      2    |     2    | */
+
+/* Scancode set 8Ah : IBM 5556 keyboard compatible scancode set used by J-DOS */
+static scancode scancode_set8a[512] =
+{
+    // clang-format off                     
+      {.mk = {       0 }, .brk = {       0 } }, /* 000 */
+      {.mk = { 0x3d, 0 }, .brk = {       0 } }, /* 001 */
+      {.mk = { 0x24, 0 }, .brk = {       0 } }, /* 002 */
+      {.mk = { 0x25, 0 }, .brk = {       0 } }, /* 003 */
+      {.mk = { 0x26, 0 }, .brk = {       0 } }, /* 004 */
+      {.mk = { 0x27, 0 }, .brk = {       0 } }, /* 005 */
+      {.mk = { 0x28, 0 }, .brk = {       0 } }, /* 006 */
+      {.mk = { 0x29, 0 }, .brk = {       0 } }, /* 007 */
+      {.mk = { 0x2a, 0 }, .brk = {       0 } }, /* 008 */
+      {.mk = { 0x2b, 0 }, .brk = {       0 } }, /* 009 */
+      {.mk = { 0x2c, 0 }, .brk = {       0 } }, /* 00a */
+      {.mk = { 0x2d, 0 }, .brk = {       0 } }, /* 00b */
+      {.mk = { 0x2e, 0 }, .brk = {       0 } }, /* 00c */
+      {.mk = { 0x2f, 0 }, .brk = {       0 } }, /* 00d */
+      {.mk = { 0x3e, 0 }, .brk = {       0 } }, /* 00e */
+      {.mk = { 0x3c, 0 }, .brk = {       0 } }, /* 00f */
+      {.mk = { 0x18, 0 }, .brk = {       0 } }, /* 010 */
+      {.mk = { 0x19, 0 }, .brk = {       0 } }, /* 011 */
+      {.mk = { 0x1a, 0 }, .brk = {       0 } }, /* 012 */
+      {.mk = { 0x1b, 0 }, .brk = {       0 } }, /* 013 */
+      {.mk = { 0x1c, 0 }, .brk = {       0 } }, /* 014 */
+      {.mk = { 0x1d, 0 }, .brk = {       0 } }, /* 015 */
+      {.mk = { 0x1e, 0 }, .brk = {       0 } }, /* 016 */
+      {.mk = { 0x1f, 0 }, .brk = {       0 } }, /* 017 */
+      {.mk = { 0x20, 0 }, .brk = {       0 } }, /* 018 */
+      {.mk = { 0x21, 0 }, .brk = {       0 } }, /* 019 */
+      {.mk = { 0x22, 0 }, .brk = {       0 } }, /* 01a */
+      {.mk = { 0x23, 0 }, .brk = {       0 } }, /* 01b */
+      {.mk = { 0x3b, 0 }, .brk = {       0 } }, /* 01c */
+      {.mk = { 0x41, 0 }, .brk = { 0xc1, 0 } }, /* 01d LCTRL */
+      {.mk = { 0x0c, 0 }, .brk = {       0 } }, /* 01e */
+      {.mk = { 0x0d, 0 }, .brk = {       0 } }, /* 01f */
+      {.mk = { 0x0e, 0 }, .brk = {       0 } }, /* 020 */
+      {.mk = { 0x0f, 0 }, .brk = {       0 } }, /* 021 */
+      {.mk = { 0x10, 0 }, .brk = {       0 } }, /* 022 */
+      {.mk = { 0x11, 0 }, .brk = {       0 } }, /* 023 */
+      {.mk = { 0x12, 0 }, .brk = {       0 } }, /* 024 */
+      {.mk = { 0x13, 0 }, .brk = {       0 } }, /* 025 */
+      {.mk = { 0x14, 0 }, .brk = {       0 } }, /* 026 */
+      {.mk = { 0x15, 0 }, .brk = {       0 } }, /* 027 */
+      {.mk = { 0x16, 0 }, .brk = {       0 } }, /* 028* */
+      {.mk = { 0x45, 0 }, .brk = {       0 } }, /* 029 Hankaku, Zenkaku */
+      {.mk = { 0x38, 0 }, .brk = { 0xb8, 0 } }, /* 02a LSHIFT */
+      {.mk = { 0x17, 0 }, .brk = {       0 } }, /* 02b Mu */
+      {.mk = { 0x01, 0 }, .brk = {       0 } }, /* 02c */
+      {.mk = { 0x02, 0 }, .brk = {       0 } }, /* 02d */
+      {.mk = { 0x03, 0 }, .brk = {       0 } }, /* 02e */
+      {.mk = { 0x04, 0 }, .brk = {       0 } }, /* 02f */
+      {.mk = { 0x05, 0 }, .brk = {       0 } }, /* 030 */
+      {.mk = { 0x06, 0 }, .brk = {       0 } }, /* 031 */
+      {.mk = { 0x07, 0 }, .brk = {       0 } }, /* 032 */
+      {.mk = { 0x08, 0 }, .brk = {       0 } }, /* 033 */
+      {.mk = { 0x09, 0 }, .brk = {       0 } }, /* 034 */
+      {.mk = { 0x0a, 0 }, .brk = {       0 } }, /* 035 */
+      {.mk = { 0x39, 0 }, .brk = { 0xb9, 0 } }, /* 036 RSHIFT */
+      {.mk = { 0x64, 0 }, .brk = {       0 } }, /* 037 * (asterisk) */
+      {.mk = { 0x3A, 0 }, .brk = { 0xba, 0 } }, /* 038 LALT = Kanji */
+      {.mk = { 0x34, 0 }, .brk = {       0 } }, /* 039 */
+      {.mk = { 0x32, 0 }, .brk = { 0xb2, 0 } }, /* 03a CAPSLOCK */
+      {.mk = { 0x68, 0 }, .brk = {       0 } }, /* 03b F1 */
+      {.mk = { 0x69, 0 }, .brk = {       0 } }, /* 03c */
+      {.mk = { 0x6a, 0 }, .brk = {       0 } }, /* 03d */
+      {.mk = { 0x6b, 0 }, .brk = {       0 } }, /* 03e */
+      {.mk = { 0x6c, 0 }, .brk = {       0 } }, /* 03f */
+      {.mk = { 0x6d, 0 }, .brk = {       0 } }, /* 040 */
+      {.mk = { 0x6e, 0 }, .brk = {       0 } }, /* 041 */
+      {.mk = { 0x6f, 0 }, .brk = {       0 } }, /* 042 */
+      {.mk = { 0x70, 0 }, .brk = {       0 } }, /* 043 */
+      {.mk = { 0x71, 0 }, .brk = {       0 } }, /* 044 F10 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 045 NUMLOCKCLEAR -> Shift + SCRLOCK :TODO */
+      {.mk = { 0x75, 0 }, .brk = {       0 } }, /* 046 SCROLLLOCK */
+      {.mk = { 0x5d, 0 }, .brk = {       0 } }, /* 047 KP7 */
+      {.mk = { 0x5e, 0 }, .brk = {       0 } }, /* 048 */
+      {.mk = { 0x5f, 0 }, .brk = {       0 } }, /* 049 */
+      {.mk = { 0x67, 0 }, .brk = {       0 } }, /* 04a KP_MINUS */
+      {.mk = { 0x5a, 0 }, .brk = {       0 } }, /* 04b */
+      {.mk = { 0x5b, 0 }, .brk = {       0 } }, /* 04c */
+      {.mk = { 0x5c, 0 }, .brk = {       0 } }, /* 04d */
+      {.mk = { 0x63, 0 }, .brk = {       0 } }, /* 04e */
+      {.mk = { 0x57, 0 }, .brk = {       0 } }, /* 04f */
+      {.mk = { 0x58, 0 }, .brk = {       0 } }, /* 050 */
+      {.mk = { 0x59, 0 }, .brk = {       0 } }, /* 051 */
+      {.mk = { 0x55, 0 }, .brk = {       0 } }, /* 052 KP0 */
+      {.mk = { 0x56, 0 }, .brk = {       0 } }, /* 053 KP_PERIOD */
+      {.mk = {       0 }, .brk = {       0 } }, /* 054 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 055 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 056 */
+      {.mk = { 0x72, 0 }, .brk = {       0 } }, /* 057 F11 */
+      {.mk = { 0x73, 0 }, .brk = {       0 } }, /* 058 F12 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 059 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 05a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 05b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 05c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 05d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 05e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 05f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 060 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 061 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 062 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 063 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 064 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 065 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 066 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 067 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 068 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 069 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 06a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 06b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 06c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 06d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 06e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 06f */
+      {.mk = { 0x36, 0 }, .brk = { 0xb6, 0 } }, /* 070 Kana */
+      {.mk = {       0 }, .brk = {       0 } }, /* 071 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 072 */
+      {.mk = { 0x0b, 0 }, .brk = {       0 } }, /* 073 Ro, Underline */
+      {.mk = {       0 }, .brk = {       0 } }, /* 074 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 075 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 076 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 077 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 078 */
+      {.mk = { 0x35, 0 }, .brk = {       0 } }, /* 079 Henkan */
+      {.mk = {       0 }, .brk = {       0 } }, /* 07a */
+      {.mk = { 0x33, 0 }, .brk = {       0 } }, /* 07b Muhenkan */
+      {.mk = {       0 }, .brk = {       0 } }, /* 07c */
+      {.mk = { 0x30, 0 }, .brk = {       0 } }, /* 07d Yen, Vertical line */
+      {.mk = {       0 }, .brk = {       0 } }, /* 07e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 07f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 080 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 081 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 082 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 083 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 084 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 085 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 086 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 087 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 088 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 089 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 08a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 08b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 08c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 08d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 08e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 08f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 090 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 091 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 092 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 093 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 094 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 095 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 096 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 097 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 098 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 099 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 09a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 09b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 09c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 09d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 09e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 09f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0a9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0aa */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ab */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ac */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ad */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ae */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0af */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0b9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ba */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0bb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0bc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0bd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0be */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0bf */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0c9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ca */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0cb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0cc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0cd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ce */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0cf */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0d9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0da */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0db */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0dc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0dd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0de */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0df */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0e9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ea */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0eb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ec */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ed */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ee */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ef */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0f9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0fa */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0fb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0fc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0fd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0fe */
+      {.mk = {       0 }, .brk = {       0 } }, /* 0ff */
+      {.mk = { 0x47, 0 }, .brk = {       0 } }, /* 100 Pause */
+      {.mk = {       0 }, .brk = {       0 } }, /* 101 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 102 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 103 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 104 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 105 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 106 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 107 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 108 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 109 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 10a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 10b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 10c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 10d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 10e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 10f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 110 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 112 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 113 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 113 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 114 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 115 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 116 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 117 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 118 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 119 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 11a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 11b */
+      {.mk = { 0x60, 0 }, .brk = {       0 } }, /* 11c KP_Enter */
+      {.mk = { 0x37, 0 }, .brk = { 0xb7, 0 } }, /* 11d R-Ctrl */
+      {.mk = {       0 }, .brk = {       0 } }, /* 11e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 11f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 120 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 121 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 122 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 123 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 124 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 125 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 126 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 127 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 128 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 129 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 12a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 12b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 12c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 12d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 12e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 12f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 130 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 131 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 132 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 133 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 134 */
+      {.mk = { 0x65, 0 }, .brk = {       0 } }, /* 135 KP_DIVIDE */
+      {.mk = {       0 }, .brk = {       0 } }, /* 136 */
+      {.mk = { 0x74, 0 }, .brk = {       0 } }, /* 137 PRINTSCREEN */
+      {.mk = { 0x31, 0 }, .brk = { 0xb1, 0 } }, /* 138* R-Alt */
+      {.mk = {       0 }, .brk = {       0 } }, /* 139 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 13a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 13b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 13c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 13d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 13e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 13f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 140 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 141 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 142 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 143 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 144 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 145 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 146 */
+      {.mk = { 0x4c, 0 }, .brk = {       0 } }, /* 147 Home */
+      {.mk = { 0x4e, 0 }, .brk = {       0 } }, /* 148 Up */
+      {.mk = { 0x52, 0 }, .brk = {       0 } }, /* 149 PageUp */
+      {.mk = {       0 }, .brk = {       0 } }, /* 14a */
+      {.mk = { 0x4b, 0 }, .brk = {       0 } }, /* 14b Left */
+      {.mk = {       0 }, .brk = {       0 } }, /* 14c */
+      {.mk = { 0x4d, 0 }, .brk = {       0 } }, /* 14d Right */
+      {.mk = {       0 }, .brk = {       0 } }, /* 14e */
+      {.mk = { 0x53, 0 }, .brk = {       0 } }, /* 14f End */
+      {.mk = { 0x4a, 0 }, .brk = {       0 } }, /* 150 Down */
+      {.mk = { 0x54, 0 }, .brk = {       0 } }, /* 151 PageDown */
+      {.mk = { 0x4f, 0 }, .brk = {       0 } }, /* 152 Ins */
+      {.mk = { 0x50, 0 }, .brk = {       0 } }, /* 153 Del */
+      {.mk = {       0 }, .brk = {       0 } }, /* 154 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 155 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 156 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 157 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 158 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 159 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 15a */
+      {.mk = { 0x33, 0 }, .brk = {       0 } }, /* 15b LGUI->Muhenkan (in emulator only) */
+      {.mk = { 0x35, 0 }, .brk = {       0 } }, /* 15c RGUI->Henkan (in emulator only) */
+      {.mk = { 0x36, 0 }, .brk = { 0xb6, 0 } }, /* 15d APPLICATION->Kana (in emulator only) */
+      {.mk = {       0 }, .brk = {       0 } }, /* 15e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 15f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 160 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 161 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 162 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 163 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 164 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 165 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 166 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 167 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 168 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 169 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 16a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 16b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 16c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 16d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 16e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 16f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 170 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 171 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 172 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 173 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 174 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 175 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 176 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 177 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 178 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 179 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 17a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 17b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 17c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 17d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 17e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 17f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 180 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 181 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 182 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 183 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 184 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 185 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 186 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 187 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 188 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 189 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 18a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 18b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 18c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 18d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 18e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 18f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 190 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 191 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 192 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 193 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 194 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 195 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 196 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 197 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 198 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 199 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 19a */
+      {.mk = {       0 }, .brk = {       0 } }, /* 19b */
+      {.mk = {       0 }, .brk = {       0 } }, /* 19c */
+      {.mk = {       0 }, .brk = {       0 } }, /* 19d */
+      {.mk = {       0 }, .brk = {       0 } }, /* 19e */
+      {.mk = {       0 }, .brk = {       0 } }, /* 19f */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1a9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1aa */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ab */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ac */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ad */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ae */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1af */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1b9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ba */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1bb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1bc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1bd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1be */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1bf */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1c9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ca */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1cb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1cv */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1cd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ce */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1cf */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1d9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1da */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1db */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1dc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1dd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1de */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1df */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1e9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ea */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1eb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ec */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ed */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ee */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1ef */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f0 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f1 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f2 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f3 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f4 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f5 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f6 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f7 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f8 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1f9 */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1fa */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1fb */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1fc */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1fd */
+      {.mk = {       0 }, .brk = {       0 } }, /* 1fe */
+      {.mk = {       0 }, .brk = {       0 } }  /* 1ff */
+    // clang-format on
+};
+
 #ifdef ENABLE_KEYBOARD_AT_LOG
 int keyboard_at_do_log = ENABLE_KEYBOARD_AT_LOG;
 
@@ -1664,6 +2208,10 @@ keyboard_at_set_scancode_set(void)
         case 0x03:
             keyboard_set_table(scancode_set3);
             break;
+
+        case 0x8a:
+            keyboard_set_table(scancode_set8a);
+            break;
     }
 }
 
@@ -1922,19 +2470,22 @@ keyboard_at_write(void *priv)
                 break;
 
             case 0xf0: /* Get/set scancode set */
-                kbc_at_dev_queue_add(dev, (val > 3) ? 0xfe : 0xfa, 0);
                 switch (val) {
                     case 0x00:
+                        kbc_at_dev_queue_add(dev, 0xfa, 0); /* ACK */
                         keyboard_at_log("%s: Get scan code set [%02X]\n", dev->name, keyboard_mode);
                         kbc_at_dev_queue_add(dev, keyboard_mode, 0);
                         break;
                     case 0x01 ... 0x03:
+                    case 0x8a:
+                        kbc_at_dev_queue_add(dev, 0xfa, 0); /* ACK */
                         keyboard_mode = val;
                         keyboard_at_log("%s: Set scan code set [%02X]\n", dev->name, keyboard_mode);
                         keyboard_at_set_scancode_set();
                         break;
                     default:
                         /* Fatal so any instance of anything attempting to set scan code > 3 can be reported to us. */
+                        kbc_at_dev_queue_add(dev, 0xfe, 0); /* Resend */
                         fatal("%s: Scan code set [%02X] invalid, resend\n", dev->name, val);
                         dev->flags |= FLAG_CTRLDAT;
                         dev->state = DEV_STATE_MAIN_WANT_IN;
diff --git a/src/disk/hdc.c b/src/disk/hdc.c
index 908cbce07..f09a9a430 100644
--- a/src/disk/hdc.c
+++ b/src/disk/hdc.c
@@ -77,6 +77,7 @@ static const struct {
     { &xtide_acculogic_device      },
     { &xtide_device                },
     { &esdi_ps2_device             },
+    { &esdi_integrated_device      },
     { &ide_pci_device              },
     { &ide_pci_2ch_device          },
     { &ide_vlb_device              },
diff --git a/src/disk/hdc_esdi_mca.c b/src/disk/hdc_esdi_mca.c
index b7ab5ff9f..8f1def137 100644
--- a/src/disk/hdc_esdi_mca.c
+++ b/src/disk/hdc_esdi_mca.c
@@ -150,6 +150,11 @@ typedef struct esdi_t {
     uint8_t pos_regs[8];
 } esdi_t;
 
+enum {
+    ESDI_IS_ADAPTER,
+    ESDI_IS_INTEGRATED
+};
+
 #define STATUS_DMA_ENA             (1 << 7)
 #define STATUS_IRQ_PENDING         (1 << 6)
 #define STATUS_CMD_IN_PROGRESS     (1 << 5)
@@ -694,32 +699,48 @@ esdi_callback(void *priv)
             break;
 
         case CMD_GET_DEV_CONFIG:
-            ESDI_DRIVE_ONLY();
-
-            if (!drive->present) {
-                device_not_present(dev);
-                return;
+            if (dev->cmd_dev == ATTN_HOST_ADAPTER)
+            {
+                if ((dev->status & STATUS_IRQ) || dev->irq_in_progress)
+                    fatal("IRQ in progress %02x %i\n", dev->status, dev->irq_in_progress);
+                /* INT 13, AX=1C0B - ESDI FIXED DISK - GET ADAPTER CONFIGURATION */
+                /* The PS/55 will test sector buffer after this request is done. */
+                dev->status_len = 6;
+                dev->status_data[0] = CMD_GET_DEV_CONFIG | STATUS_LEN(6) | STATUS_DEVICE_HOST_ADAPTER;
+                dev->status_data[1] = 0;
+                dev->status_data[2] = 0;
+                /* bit 15-12: chip revision = 0011b, bit 11-8: sector buffer size = n * 256 bytes (n must be < 6) */
+                dev->status_data[3] = 0x3200;
+                dev->status_data[4] = 0;
+                dev->status_data[5] = 0;
             }
+            else
+            {
+                ESDI_DRIVE_ONLY();
+                if (!drive->present) {
+                    device_not_present(dev);
+                    return;
+                }
 
-            if ((dev->status & STATUS_IRQ) || dev->irq_in_progress)
-                fatal("IRQ in progress %02x %i\n", dev->status, dev->irq_in_progress);
-
-            dev->status_len     = 6;
-            dev->status_data[0] = CMD_GET_DEV_CONFIG | STATUS_LEN(6) | STATUS_DEVICE_HOST_ADAPTER;
-            dev->status_data[1] = 0x10; /*Zero defect*/
-            dev->status_data[2] = drive->sectors & 0xffff;
-            dev->status_data[3] = drive->sectors >> 16;
-            dev->status_data[4] = drive->tracks;
-            dev->status_data[5] = drive->hpc | (drive->spt << 16);
+                if ((dev->status & STATUS_IRQ) || dev->irq_in_progress)
+                    fatal("IRQ in progress %02x %i\n", dev->status, dev->irq_in_progress);
 
+                dev->status_len = 6;
+                dev->status_data[0] = CMD_GET_DEV_CONFIG | STATUS_LEN(6) | STATUS_DEVICE_HOST_ADAPTER;
+                dev->status_data[1] = 0x10; /*Zero defect*/
+                dev->status_data[2] = drive->sectors & 0xffff;
+                dev->status_data[3] = drive->sectors >> 16;
+                dev->status_data[4] = drive->tracks;
+                dev->status_data[5] = drive->hpc | (drive->spt << 16);
+            }
             esdi_mca_log("CMD_GET_DEV_CONFIG %i  %04x %04x %04x %04x %04x %04x\n",
-                         drive->sectors,
-                         dev->status_data[0], dev->status_data[1],
-                         dev->status_data[2], dev->status_data[3],
-                         dev->status_data[4], dev->status_data[5]);
+                drive->sectors,
+                dev->status_data[0], dev->status_data[1],
+                dev->status_data[2], dev->status_data[3],
+                dev->status_data[4], dev->status_data[5]);
 
-            dev->status          = STATUS_IRQ | STATUS_STATUS_OUT_FULL;
-            dev->irq_status      = dev->cmd_dev | IRQ_CMD_COMPLETE_SUCCESS;
+            dev->status = STATUS_IRQ | STATUS_STATUS_OUT_FULL;
+            dev->irq_status = dev->cmd_dev | IRQ_CMD_COMPLETE_SUCCESS;
             dev->irq_in_progress = 1;
             set_irq(dev);
             ui_sb_update_icon(SB_HDD | HDD_BUS_ESDI, 0);
@@ -733,7 +754,7 @@ esdi_callback(void *priv)
 
             dev->status_len     = 5;
             dev->status_data[0] = CMD_GET_POS_INFO | STATUS_LEN(5) | STATUS_DEVICE_HOST_ADAPTER;
-            dev->status_data[1] = 0xffdd; /*MCA ID*/
+            dev->status_data[1] = dev->pos_regs[1] | (dev->pos_regs[0] << 8); /*MCA ID*/
             dev->status_data[2] = dev->pos_regs[3] | (dev->pos_regs[2] << 8);
             dev->status_data[3] = 0xff;
             dev->status_data[4] = 0xff;
@@ -1233,6 +1254,62 @@ esdi_mca_write(int port, uint8_t val, void *priv)
     }
 }
 
+static void
+esdi_integrated_mca_write(int port, uint8_t val, void* priv)
+{
+    esdi_t* dev = (esdi_t*)priv;
+
+    esdi_mca_log("ESDI: mcawr(%04x, %02x)  pos[2]=%02x pos[3]=%02x\n",
+        port, val, dev->pos_regs[2], dev->pos_regs[3]);
+
+    if (port < 0x102)
+        return;
+
+    /* Save the new value. */
+    dev->pos_regs[port & 7] = val;
+
+    io_removehandler(ESDI_IOADDR_PRI, 8,
+        esdi_read, esdi_readw, NULL,
+        esdi_write, esdi_writew, NULL, dev);
+
+    switch (dev->pos_regs[2] & 0x3c) {
+    case 0x14:
+        dev->dma = 5;
+        break;
+    case 0x18:
+        dev->dma = 6;
+        break;
+    case 0x1c:
+        dev->dma = 7;
+        break;
+    case 0x00:
+        dev->dma = 0;
+        break;
+    case 0x04:
+        dev->dma = 1;
+        break;
+    case 0x0c:
+        dev->dma = 3;
+        break;
+    case 0x10:
+        dev->dma = 4;
+        break;
+
+    default:
+        break;
+    }
+
+    if (dev->pos_regs[2] & 1) {
+        io_sethandler(ESDI_IOADDR_PRI, 8,
+            esdi_read, esdi_readw, NULL,
+            esdi_write, esdi_writew, NULL, dev);
+
+        /* Say hello. */
+        esdi_mca_log("ESDI: I/O=3510, IRQ=14, DMA=%d\n",
+            dev->dma);
+    }
+}
+
 static uint8_t
 esdi_mca_feedb(void *priv)
 {
@@ -1241,6 +1318,16 @@ esdi_mca_feedb(void *priv)
     return (dev->pos_regs[2] & 1);
 }
 
+static void esdi_reset(void* priv)
+{
+    esdi_t* dev = (esdi_t*)priv;
+    if (!dev->in_reset) {
+        dev->in_reset = 1;
+        esdi_mca_set_callback(dev, ESDI_TIME * 50);
+        dev->status = STATUS_BUSY;
+    }
+}
+
 static void *
 esdi_init(UNUSED(const device_t *info))
 {
@@ -1256,10 +1343,12 @@ esdi_init(UNUSED(const device_t *info))
     /* Mark as unconfigured. */
     dev->irq_status = 0xff;
 
-    rom_init_interleaved(&dev->bios_rom,
-                         BIOS_FILE_H, BIOS_FILE_L,
-                         0xc8000, 0x4000, 0x3fff, 0, MEM_MAPPING_EXTERNAL);
-    mem_mapping_disable(&dev->bios_rom.mapping);
+    if (info->local == ESDI_IS_ADAPTER) {
+        rom_init_interleaved(&dev->bios_rom,
+            BIOS_FILE_H, BIOS_FILE_L,
+            0xc8000, 0x4000, 0x3fff, 0, MEM_MAPPING_EXTERNAL);
+        mem_mapping_disable(&dev->bios_rom.mapping);
+    }
 
     dev->drives[0].present = dev->drives[1].present = 0;
 
@@ -1292,12 +1381,25 @@ esdi_init(UNUSED(const device_t *info))
             break;
     }
 
-    /* Set the MCA ID for this controller, 0xFFDD. */
-    dev->pos_regs[0] = 0xff;
-    dev->pos_regs[1] = 0xdd;
+    /* Set the MCA ID for this controller. */
+    if (info->local == ESDI_IS_ADAPTER) {
+        dev->pos_regs[0] = 0xff;
+        dev->pos_regs[1] = 0xdd;
+    } else if (info->local == ESDI_IS_INTEGRATED) {
+        dev->pos_regs[0] = 0x9f;
+        dev->pos_regs[1] = 0xdf;
+    }
 
     /* Enable the device. */
-    mca_add(esdi_mca_read, esdi_mca_write, esdi_mca_feedb, NULL, dev);
+    if (info->local == ESDI_IS_INTEGRATED) {
+        /* The slot number of this controller is fixed by the planar. IBM PS/55 5551-T assigns it #5. */
+        int slotno = device_get_config_int("in_esdi_slot");
+        if (slotno)
+            mca_add_to_slot(esdi_mca_read, esdi_integrated_mca_write, esdi_mca_feedb, esdi_reset, dev, slotno - 1);
+        else
+            mca_add(esdi_mca_read, esdi_integrated_mca_write, esdi_mca_feedb, esdi_reset, dev);
+    } else
+        mca_add(esdi_mca_read, esdi_mca_write, esdi_mca_feedb, NULL, dev);
 
     /* Mark for a reset. */
     dev->in_reset = 1;
@@ -1337,7 +1439,7 @@ const device_t esdi_ps2_device = {
     .name          = "IBM PS/2 ESDI Fixed Disk Adapter (MCA)",
     .internal_name = "esdi_mca",
     .flags         = DEVICE_MCA,
-    .local         = 0,
+    .local         = ESDI_IS_ADAPTER,
     .init          = esdi_init,
     .close         = esdi_close,
     .reset         = NULL,
@@ -1346,3 +1448,52 @@ const device_t esdi_ps2_device = {
     .force_redraw  = NULL,
     .config        = NULL
 };
+
+static device_config_t
+    esdi_integrated_config[] = {
+          {
+           .name        = "in_esdi_slot",
+           .description = "Slot #",
+           .type        = CONFIG_SELECTION,
+           .selection   = {
+                { .description = "Auto", .value = 0 },
+                { .description = "1", .value = 1 },
+                { .description = "2", .value = 2 },
+                { .description = "3", .value = 3 },
+                { .description = "4", .value = 4 },
+                { .description = "5", .value = 5 },
+                { .description = "6", .value = 6 },
+                { .description = "7", .value = 7 },
+                { .description = "8", .value = 8 }
+            },
+           .default_int = 0
+        },
+          { .type = -1 }
+};
+
+/*
+Device for an IBM DBA (Direct Bus Attachment) hard disk.
+The Disk BIOS is included in the System ROM.
+Some models have an exclusive channel slot for the DBA hard disk.
+Following IBM machines are supported:
+  * PS/2 model 55SX
+  * PS/2 model 65SX
+  * PS/2 model 70 type 3 (Slot #4)
+  * PS/2 model 70 type 4 (Slot #4)
+  * PS/55 model 5550-T (Slot #5)
+  * PS/55 model 5550-V (Slot #5)
+*/
+const device_t
+esdi_integrated_device = {
+    .name = "IBM Integrated Fixed Disk and Controller (MCA)",
+    .internal_name = "esdi_integrated_mca",
+    .flags = DEVICE_MCA,
+    .local = ESDI_IS_INTEGRATED,
+    .init = esdi_init,
+    .close = esdi_close,
+    .reset = esdi_reset,
+    .available = NULL,
+    .speed_changed = NULL,
+    .force_redraw = NULL,
+    .config = esdi_integrated_config
+};
diff --git a/src/floppy/fdc.c b/src/floppy/fdc.c
index 300d775c5..5de1a8ef4 100644
--- a/src/floppy/fdc.c
+++ b/src/floppy/fdc.c
@@ -740,6 +740,18 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
                 drive = real_drive(fdc, fdc->dor & 3);
                 fdc_update_rwc(fdc, drive, (val & 0x30) >> 4);
             }
+            /* Bit 2: FIFO test mode (PS/55 5550-S,T only. Undocumented) 
+               The Power-on Self Test of PS/55 writes and verifies 8 bytes of FIFO buffer through I/O 3F5h.
+               If it fails, then floppy drives will be treated as DD drives. */
+            if (fdc->flags & FDC_FLAG_PS2_MCA) {
+                if (val & 0x04) {
+                    fdc->tfifo      = 8;
+                    fdc->fifointest = 1;
+                } else {
+                    fdc->tfifo      = 1;
+                    fdc->fifointest = 0;
+                }
+            }
             return;
         case 4: /* DSR */
             if (!(fdc->flags & FDC_FLAG_NO_DSR_RESET)) {
@@ -753,6 +765,14 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
             fdc->dsr = val;
             return;
         case 5: /*Command register*/
+            if (fdc->fifointest) {
+                /* Write FIFO buffer in the test mode (PS/55) */
+                fdc_log("FIFO buffer position = %X\n", ((fifo_t *) fdc->fifo_p)->end);
+                fifo_write(val, fdc->fifo_p);
+                if (fifo_get_full(fdc->fifo_p))
+                    fdc->stat &= ~0x80;
+                break;
+            }
             if ((fdc->stat & 0xf0) == 0xb0) {
                 if ((fdc->flags & FDC_FLAG_PCJR) || !fdc->fifo) {
                     fdc->dat = val;
@@ -1335,6 +1355,7 @@ fdc_read(uint16_t addr, void *priv)
                     ret = 0x10;
                 else
                     ret = 0x00;
+                /* PS/55 POST throws an error and halt if ret = 1 or 2, somehow. */
             } else if (!fdc->enh_mode)
                 ret = 0x20;
             else
@@ -1344,6 +1365,11 @@ fdc_read(uint16_t addr, void *priv)
             ret = fdc->stat;
             break;
         case 5: /*Data*/
+            if (fdc->fifointest) {
+                /* Read FIFO buffer in the test mode (PS/55) */
+                ret = fifo_read(fdc->fifo_p);
+                break;
+            }
             if ((fdc->stat & 0xf0) == 0xf0) {
                 fdc->stat &= ~0x80;
                 if ((fdc->flags & FDC_FLAG_PCJR) || !fdc->fifo) {
@@ -2249,6 +2275,7 @@ fdc_reset(void *priv)
 
     fdc->fifo  = 0;
     fdc->tfifo = 1;
+    fdc->fifointest = 0;
 
     if (fdc->flags & FDC_FLAG_PCJR) {
         fdc->dma        = 0;
diff --git a/src/floppy/fdd.c b/src/floppy/fdd.c
index f0a32df75..d3d513b9f 100644
--- a/src/floppy/fdd.c
+++ b/src/floppy/fdd.c
@@ -294,7 +294,7 @@ fdd_type_invert_densel(int type)
     int ret;
 
     if (drive_types[type].flags & FLAG_PS2)
-        ret = (!!strstr(machine_getname(), "PS/1")) || (!!strstr(machine_getname(), "PS/2"));
+        ret = (!!strstr(machine_getname(), "PS/1")) || (!!strstr(machine_getname(), "PS/2")) || (!!strstr(machine_getname(), "PS/55"));
     else
         ret = drive_types[type].flags & FLAG_INVERT_DENSEL;
 
diff --git a/src/include/86box/86box.h b/src/include/86box/86box.h
index 6f6caf743..e4e5ecae1 100644
--- a/src/include/86box/86box.h
+++ b/src/include/86box/86box.h
@@ -138,6 +138,7 @@ extern int      sound_is_float;             /* (C) sound uses FP values */
 extern int      voodoo_enabled;             /* (C) video option */
 extern int      ibm8514_standalone_enabled; /* (C) video option */
 extern int      xga_standalone_enabled;     /* (C) video option */
+extern int      da2_standalone_enabled;     /* (C) video option */
 extern uint32_t mem_size;                   /* (C) memory size (Installed on system board) */
 extern uint32_t isa_mem_size;               /* (C) memory size (ISA Memory Cards) */
 extern int      cpu;                        /* (C) cpu type */
diff --git a/src/include/86box/fdc.h b/src/include/86box/fdc.h
index 9e8006650..2d17380d0 100644
--- a/src/include/86box/fdc.h
+++ b/src/include/86box/fdc.h
@@ -103,7 +103,6 @@ typedef struct fdc_t {
     uint8_t densel_force;
     uint8_t fifo;
     uint8_t tfifo;
-    uint8_t fifobufpos;
 
     uint8_t drv2en;
     uint8_t gap;
@@ -148,6 +147,7 @@ typedef struct fdc_t {
     int drvrate[4];
 
     void *fifo_p;
+    int fifointest;
 
     sector_id_t read_track_sector;
     sector_id_t format_sector_id;
diff --git a/src/include/86box/hdc.h b/src/include/86box/hdc.h
index e798f2464..7f91fd61b 100644
--- a/src/include/86box/hdc.h
+++ b/src/include/86box/hdc.h
@@ -48,6 +48,7 @@ extern const device_t st506_xt_toshiba_t1200_device;      /* st506_xt_toshiba_t1
 
 extern const device_t esdi_at_wd1007vse1_device; /* esdi_at */
 extern const device_t esdi_ps2_device;           /* esdi_mca */
+extern const device_t esdi_integrated_device;           /* esdi_mca */
 
 extern const device_t ide_isa_device;         /* isa_ide */
 extern const device_t ide_isa_sec_device;     /* isa_ide sec*/
diff --git a/src/include/86box/machine.h b/src/include/86box/machine.h
index 8676fa5f1..78f4902eb 100644
--- a/src/include/86box/machine.h
+++ b/src/include/86box/machine.h
@@ -903,6 +903,8 @@ extern int machine_ps2_model_70_type3_init(const machine_t *);
 extern int machine_ps2_model_80_init(const machine_t *);
 extern int machine_ps2_model_80_axx_init(const machine_t *);
 extern int machine_ps2_model_70_type4_init(const machine_t *);
+extern int machine_ps55_model_50t_init(const machine_t*);
+extern int machine_ps55_model_50v_init(const machine_t*);
 
 /* m_tandy.c */
 extern int tandy1k_eeprom_read(void);
diff --git a/src/include/86box/mca.h b/src/include/86box/mca.h
index e048a6131..2d31fe33d 100644
--- a/src/include/86box/mca.h
+++ b/src/include/86box/mca.h
@@ -3,6 +3,7 @@
 
 extern void    mca_init(int nr_cards);
 extern void    mca_add(uint8_t (*read)(int addr, void *priv), void (*write)(int addr, uint8_t val, void *priv), uint8_t (*feedb)(void *priv), void (*reset)(void *priv), void *priv);
+extern void    mca_add_to_slot(uint8_t(*read)(int addr, void* priv), void (*write)(int addr, uint8_t val, void* priv), uint8_t(*feedb)(void* priv), void (*reset)(void* priv), void* priv, int c);
 extern void    mca_set_index(int index);
 extern uint8_t mca_read(uint16_t port);
 extern uint8_t mca_read_index(uint16_t port, int index);
diff --git a/src/include/86box/network.h b/src/include/86box/network.h
index 2140d62dd..ef9f291ad 100644
--- a/src/include/86box/network.h
+++ b/src/include/86box/network.h
@@ -57,7 +57,7 @@
 /* Queue size must be a power of 2 */
 #define NET_QUEUE_LEN      16
 #define NET_QUEUE_LEN_MASK (NET_QUEUE_LEN - 1)
-#define NET_QUEUE_COUNT 3
+#define NET_QUEUE_COUNT    4
 #define NET_CARD_MAX       4
 #define NET_HOST_INTF_MAX  64
 
@@ -84,9 +84,10 @@ enum {
 };
 
 enum {
-    NET_QUEUE_RX      = 0,
-    NET_QUEUE_TX_VM   = 1,
-    NET_QUEUE_TX_HOST = 2
+    NET_QUEUE_RX       = 0,
+    NET_QUEUE_TX_VM    = 1,
+    NET_QUEUE_TX_HOST  = 2,
+    NET_QUEUE_RX_ON_TX = 3
 };
 
 typedef struct netcard_conf_t {
@@ -199,7 +200,10 @@ extern const device_t *network_card_getdevice(int);
 extern int network_tx_pop(netcard_t *card, netpkt_t *out_pkt);
 extern int network_tx_popv(netcard_t *card, netpkt_t *pkt_vec, int vec_size);
 extern int network_rx_put(netcard_t *card, uint8_t *bufp, int len);
+extern int network_rx_on_tx_popv(netcard_t *card, netpkt_t *pkt_vec, int vec_size);
+extern int network_rx_on_tx_put(netcard_t *card, uint8_t *bufp, int len);
 extern int network_rx_put_pkt(netcard_t *card, netpkt_t *pkt);
+extern int network_rx_on_tx_put_pkt(netcard_t *card, netpkt_t *pkt);
 
 #ifdef EMU_DEVICE_H
 /* 3Com Etherlink */
diff --git a/src/include/86box/vid_ps55da2.h b/src/include/86box/vid_ps55da2.h
new file mode 100644
index 000000000..f029b5751
--- /dev/null
+++ b/src/include/86box/vid_ps55da2.h
@@ -0,0 +1,24 @@
+/*
+ * 86Box    A hypervisor and IBM PC system emulator that specializes in
+ *          running old operating systems and software designed for IBM
+ *          PC systems and compatibles from 1981 through fairly recent
+ *          system designs based on the PCI bus.
+ *
+ *          This file is part of the 86Box distribution.
+ *
+ *          IBM PS/55 Display Adapter II emulation.
+ *
+ *
+ *
+ * Authors: Akamaki.
+ *
+ *          Copyright 2024 Akamaki.
+ */
+
+#ifndef VIDEO_DA2_DEVICE_H
+#define VIDEO_DA2_DEVICE_H
+
+#ifdef EMU_DEVICE_H
+extern const device_t ps55da2_device;
+#endif
+#endif /*VIDEO_DA2_DEVICE_H*/
diff --git a/src/include/86box/vid_svga.h b/src/include/86box/vid_svga.h
index 3be4ee9e5..afff6e211 100644
--- a/src/include/86box/vid_svga.h
+++ b/src/include/86box/vid_svga.h
@@ -229,6 +229,11 @@ typedef struct svga_t {
     int   override;
     void *priv;
 
+    int vga_enabled;
+    /* The PS/55 POST BIOS has a special monitor detection for its internal VGA
+       when the monitor is connected to the Display Adapter. */
+    int cable_connected;
+
     uint8_t  crtc[256];
     uint8_t  gdcreg[256];
     uint8_t  attrregs[32];
diff --git a/src/include/86box/vid_vga.h b/src/include/86box/vid_vga.h
index 0ffbeb4cd..26b5a7f71 100644
--- a/src/include/86box/vid_vga.h
+++ b/src/include/86box/vid_vga.h
@@ -31,4 +31,8 @@ typedef struct vga_t {
 extern void vga_out(uint16_t addr, uint8_t val, void *priv);
 extern uint8_t vga_in(uint16_t addr, void *priv);
 
+void vga_disable(void* p);
+void vga_enable(void* p);
+int vga_isenabled(void* p);
+
 #endif /*VIDEO_VGA_H*/
diff --git a/src/include/86box/video.h b/src/include/86box/video.h
index 9ee710592..7ad29838c 100644
--- a/src/include/86box/video.h
+++ b/src/include/86box/video.h
@@ -313,6 +313,9 @@ extern const device_t mach32_mca_device;
 extern const device_t mach32_pci_device;
 extern const device_t mach32_onboard_pci_device;
 
+/* IBM Display Adapter (PS/55) */
+extern void da2_device_add(void);
+
 /* ATi Mach64 */
 extern const device_t mach64gx_isa_device;
 extern const device_t mach64gx_vlb_device;
diff --git a/src/machine/m_ps2_mca.c b/src/machine/m_ps2_mca.c
index 35f3ed125..1a2f4d6c6 100644
--- a/src/machine/m_ps2_mca.c
+++ b/src/machine/m_ps2_mca.c
@@ -67,6 +67,8 @@
 #include <86box/port_92.h>
 #include <86box/serial.h>
 #include <86box/video.h>
+#include <86box/vid_svga.h>
+#include <86box/vid_vga.h>
 #include <86box/machine.h>
 #include <86box/plat_unused.h>
 
@@ -103,6 +105,9 @@ static struct ps2_t {
     int pending_cache_miss;
 
     serial_t *uart;
+
+    vga_t* mb_vga;
+    int has_e0000_hole;
 } ps2;
 
 /*The model 70 type 3/4 BIOS performs cache testing. Since 86Box doesn't have any
@@ -140,7 +145,8 @@ static struct ps2_t {
 
 static uint8_t ps2_cache[65536];
 static int     ps2_cache_valid[65536 / 8];
-
+static void mem_encoding_update(void);
+// #define ENABLE_PS2_MCA_LOG 1
 #ifdef ENABLE_PS2_MCA_LOG
 int ps2_mca_do_log = ENABLE_PS2_MCA_LOG;
 
@@ -358,6 +364,114 @@ model_80_read(uint16_t port)
     return 0xff;
 }
 
+static uint8_t
+ps55_model_50t_read(uint16_t port)
+{
+    ps2_mca_log(" Read SysBrd %04X xx %04X:%04X\n", port, cs >> 4, cpu_state.pc);
+    switch (port) {
+        case 0x100:
+            return ps2.planar_id & 0xff;
+        case 0x101:
+            return ps2.planar_id >> 8;
+        case 0x102:
+            return ps2.option[0];
+        case 0x103:
+            uint8_t val = 0xff;
+            /*
+            I/O 103h - Bit 7-4: Memory Card ID (Connector 1 or 3)
+                       Bit 3-0: Memory Card ID (Connector 2)
+
+            Memory Card ID: 7h = 2 MB Memory Card 2 or 3 Installed
+                            5h = 4 MB Memory Card 2 Installed
+            */
+            switch (mem_size / 1024) {
+                case 2:
+                    if (ps2.option[1] & 0x04)
+                        val = 0xff;
+                    else
+                        val = 0x7f;
+                    break;
+                case 4:
+                    if (ps2.option[1] & 0x04)
+                        val = 0xff;
+                    else
+                        val = 0x77;
+                    break;
+                case 6:
+                    if (ps2.option[1] & 0x04)
+                        val = 0x7f;
+                    else
+                        val = 0x77;
+                    break;
+                case 8:
+                default:
+                    if (ps2.option[1] & 0x04)
+                        val = 0x5f;
+                    else
+                        val = 0x77;
+                    break;
+            }
+            ps2_mca_log(" Read MCA %04X %02X %04X:%04X mem_size = %d, ps2option1 = %2X\n", port, val, cs >> 4, cpu_state.pc, mem_size, ps2.option[1]);
+            return val;
+        case 0x104:
+            return ps2.option[2];
+        case 0x105:
+            return ps2.option[3];
+        case 0x106:
+            return ps2.subaddr_lo;
+        case 0x107:
+            return ps2.subaddr_hi;
+    }
+    return 0xff;
+}
+
+static uint8_t
+ps55_model_50v_read(uint16_t port)
+{
+    switch (port) {
+        case 0x100:
+            return ps2.planar_id & 0xff;
+        case 0x101:
+            return ps2.planar_id >> 8;
+        case 0x102:
+            return ps2.option[0];
+        case 0x103:
+            uint8_t val = 0xff;
+            /*
+            I/O 103h - Bit 7-4: Reserved
+                       Bit 3-0: Memory Card ID (Connector 3 or 1)
+
+            Memory Card ID: 8h = 4 MB Memory Card IV Installed
+                            Fh = No Card Installed
+            */
+            switch (mem_size / 1024) {
+                case 4:
+                    if (ps2.option[1] & 0x04)
+                        val = 0xff;
+                    else
+                        val = 0xf8;
+                    break;
+                case 8:
+                default:
+                    if (ps2.option[1] & 0x04)
+                        val = 0xf8;
+                    else
+                        val = 0xf8;
+                    break;
+            }
+            return val;
+        case 0x104:
+            /* Reading cache ID (bit 3-2) always returns zero */
+            return ps2.option[2] & 0xf3;
+        case 0x105:
+            return ps2.option[3];
+        case 0x106:
+            return ps2.subaddr_lo;
+        case 0x107:
+            return ps2.subaddr_hi;
+    }
+    return 0xff;
+}
 static void
 model_50_write(uint16_t port, uint8_t val)
 {
@@ -655,6 +769,62 @@ model_80_write(uint16_t port, uint8_t val)
     }
 }
 
+static void
+ps55_model_50tv_write(uint16_t port, uint8_t val)
+{
+    ps2_mca_log(" Write SysBrd %04X %02X %04X:%04X\n", port, val, cs >> 4, cpu_state.pc);
+    switch (port) {
+        case 0x102:
+            lpt1_remove();
+            serial_remove(ps2.uart);
+            if (val & 0x04) {
+                if (val & 0x08)
+                    serial_setup(ps2.uart, COM1_ADDR, COM1_IRQ);
+                else
+                    serial_setup(ps2.uart, COM2_ADDR, COM2_IRQ);
+            }
+            if (val & 0x10) {
+                switch ((val >> 5) & 3) {
+                    case 0:
+                        lpt1_setup(LPT_MDA_ADDR);
+                        break;
+                    case 1:
+                        lpt1_setup(LPT1_ADDR);
+                        break;
+                    case 2:
+                        lpt1_setup(LPT2_ADDR);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            ps2.option[0] = val;
+            break;
+        case 0x103:
+            ps2.option[1] = val;
+            break;
+        case 0x104:
+            if ((ps2.option[2] ^ val) & 1) {
+                /* Disable/Enable E0000 - E0FFF (Make 2 KB hole for Display Adapter) */
+                ps2.option[2] = val;
+                mem_encoding_update();
+            }
+            ps2.option[2] = val;
+            break;
+        case 0x105:
+            ps2.option[3] = val;
+            break;
+        case 0x106:
+            ps2.subaddr_lo = val;
+            break;
+        case 0x107:
+            ps2.subaddr_hi = val;
+            break;
+        default:
+            break;
+    }
+}
+
 uint8_t
 ps2_mca_read(uint16_t port, UNUSED(void *priv))
 {
@@ -772,8 +942,15 @@ ps2_mca_write(uint16_t port, uint8_t val, UNUSED(void *priv))
             ps2.setup = val;
             break;
         case 0x96:
-            if ((val & 0x80) && !(ps2.adapter_setup & 0x80))
+            if ((val & 0x80) && !(ps2.adapter_setup & 0x80)) {
                 mca_reset();
+                if (ps2.has_e0000_hole) {
+                    /* Reset memstate for E0000 - E0FFFh hole (for PS/55 5550-V)
+                       5550-T does this in POST, but 5550-V doesn't. */
+                    ps2.option[2] &= 0xFE;
+                    mem_encoding_update();
+                }
+            }
             ps2.adapter_setup = val;
             mca_set_index(val & 7);
             break;
@@ -793,7 +970,16 @@ ps2_mca_write(uint16_t port, uint8_t val, UNUSED(void *priv))
             if (!(ps2.setup & PS2_SETUP_IO))
                 ps2.planar_write(port, val);
             else if (!(ps2.setup & PS2_SETUP_VGA))
+            {
+                if (ps2.mb_vga)
+                {
+                    if (vga_isenabled(ps2.mb_vga))
+                        vga_disable(ps2.mb_vga);
+                    if (val & 1)
+                        vga_enable(ps2.mb_vga);
+                }
                 ps2.pos_vga = val;
+            }
             else if (ps2.adapter_setup & PS2_ADAPTER_SETUP)
                 mca_write(port, val);
             break;
@@ -1117,6 +1303,11 @@ mem_encoding_update(void)
         ps2_mca_log("PS/2 Model 80-111: Split memory block disabled\n");
     }
 
+    if (ps2.has_e0000_hole && (ps2.option[2] & 1)) {
+        /* Set memstate for E0000 - E0FFFh hole (PS/55 only) */
+        mem_set_mem_state(0xe0000, 0x1000, MEM_READ_EXTERNAL | MEM_WRITE_EXTERNAL);
+    }
+
     flushmmucache_nopc();
 }
 
@@ -1311,7 +1502,7 @@ ps2_mca_board_model_70_type34_init(int is_type4, int slots)
     }
 
     if (gfxcard[0] == VID_INTERNAL)
-        device_add(&ps1vga_mca_device);
+        ps2.mb_vga = device_add(&ps1vga_mca_device);
 }
 
 static void
@@ -1385,7 +1576,7 @@ ps2_mca_board_model_80_type2_init(void)
     }
 
     if (gfxcard[0] == VID_INTERNAL)
-        device_add(&ps1vga_mca_device);
+        ps2.mb_vga = device_add(&ps1vga_mca_device);
 
     ps2.split_size = 0;
 }
@@ -1409,6 +1600,8 @@ machine_ps2_common_init(const machine_t *model)
     nmi_mask = 0x80;
 
     ps2.uart = device_add_inst(&ns16550_device, 1);
+
+    ps2.has_e0000_hole = 0;
 }
 
 int
@@ -1576,3 +1769,160 @@ machine_ps2_model_70_type4_init(const machine_t *model)
 
     return ret;
 }
+
+static void
+ps55_mca_board_model_50t_init(void)
+{
+    ps2_mca_board_common_init();
+
+    ps2.split_addr = mem_size * 1024;
+    /* The slot 5 is reserved for the Integrated Fixed Disk II (an internal ESDI hard drive). */
+    mca_init(5);
+    device_add(&keyboard_ps2_mca_1_device);
+
+    ps2.planar_read = ps55_model_50t_read;
+    ps2.planar_write = ps55_model_50tv_write;
+
+    device_add(&ps2_nvr_device);
+
+    io_sethandler(0x00e0, 0x0002, mem_encoding_read, NULL, NULL, mem_encoding_write, NULL, NULL, NULL);
+
+    ps2.mem_regs[1] = 2;
+    ps2.option[2] &= 0xfe; /* Bit 0: Disable E0000-E0FFFh (4 KB) */
+    ps2.has_e0000_hole = 1;
+
+    mem_mapping_add(&ps2.split_mapping,
+        (mem_size + 256) * 1024,
+        256 * 1024,
+        ps2_read_split_ram,
+        ps2_read_split_ramw,
+        ps2_read_split_raml,
+        ps2_write_split_ram,
+        ps2_write_split_ramw,
+        ps2_write_split_raml,
+        &ram[0xa0000],
+        MEM_MAPPING_INTERNAL,
+        NULL);
+    mem_mapping_disable(&ps2.split_mapping);
+
+    if (mem_size > 8192) {
+        /* Only 8 MB supported on planar, create a memory expansion card for the rest */
+            ps2_mca_mem_fffc_init(8);
+    }
+
+    if (gfxcard[0] == VID_INTERNAL)
+        ps2.mb_vga = (vga_t *)device_add(&ps1vga_mca_device);
+}
+
+static void
+ps55_mca_board_model_50v_init(void)
+{
+    ps2_mca_board_common_init();
+
+    ps2.split_addr = mem_size * 1024;
+    /* The slot 5 is reserved for the Integrated Fixed Disk II (an internal ESDI hard drive). */
+    mca_init(5);
+    device_add(&keyboard_ps2_mca_1_device);
+
+    ps2.planar_read = ps55_model_50v_read;
+    ps2.planar_write = ps55_model_50tv_write;
+
+    device_add(&ps2_nvr_device);
+
+    io_sethandler(0x00e0, 0x0003, mem_encoding_read_cached, NULL, NULL, mem_encoding_write_cached, NULL, NULL, NULL);
+
+    ps2.mem_regs[1] = 2;
+    ps2.option[2] &= 0xf2; /*   Bit 3-2: -Cache IDs, Bit 1: Reserved
+                                Bit 0: Disable E0000-E0FFFh (4 KB) */
+    ps2.has_e0000_hole = 1;
+
+    mem_mapping_add(&ps2.split_mapping,
+        (mem_size + 256) * 1024,
+        256 * 1024,
+        ps2_read_split_ram,
+        ps2_read_split_ramw,
+        ps2_read_split_raml,
+        ps2_write_split_ram,
+        ps2_write_split_ramw,
+        ps2_write_split_raml,
+        &ram[0xa0000],
+        MEM_MAPPING_INTERNAL,
+        NULL);
+    mem_mapping_disable(&ps2.split_mapping);
+
+    mem_mapping_add(&ps2.cache_mapping,
+                    0,
+                    64 * 1024,
+                    ps2_read_cache_ram,
+                    ps2_read_cache_ramw,
+                    ps2_read_cache_raml,
+                    ps2_write_cache_ram,
+                    NULL,
+                    NULL,
+                    ps2_cache,
+                    MEM_MAPPING_INTERNAL,
+                    NULL);
+    mem_mapping_disable(&ps2.cache_mapping);
+
+    if (mem_size > 8192) {
+        /* Only 8 MB supported on planar, create a memory expansion card for the rest */
+            ps2_mca_mem_fffc_init(8);
+    }
+
+    if (gfxcard[0] == VID_INTERNAL)
+        ps2.mb_vga = (vga_t *)device_add(&ps1vga_mca_device);
+}
+
+int
+machine_ps55_model_50t_init(const machine_t* model)
+{
+    int ret;
+
+    ret = bios_load_linear("roms/machines/ibmps55_m50t/38F6933.BIN",
+        0x000e0000, 131072, 0);
+
+    if (bios_only || !ret)
+        return ret;
+
+    machine_ps2_common_init(model);
+
+    /*
+    * Planar ID
+    * FFFAh - PS/55 model 5551-S0x, T0x (stage 1?)
+    * FFEEh - PS/55 model 5551-S1x, T1x (stage 2?)
+    * Verification in BIOS P/N 38F6933: FBxx -> 4 slots (error), xxEE -> 5 slots (ok), others -> 8 (error)
+    * 
+    * The only difference between S and T models is the CPU speed (16 MHz vs 20 MHz).
+    * The POST measures the speed, and sets a flag in the BIOS Data Area to indicate the sub model.
+    * The VM in 86Box runs faster than the real, so the POST always determines it as the T model.
+    */
+    ps2.planar_id = 0xffee;
+    ps55_mca_board_model_50t_init();
+
+    return ret;
+}
+
+int
+machine_ps55_model_50v_init(const machine_t* model)
+{
+    int ret;
+
+    ret = bios_load_interleaved("roms/machines/ibmps55_m50v/56F7416.BIN",
+                                "roms/machines/ibmps55_m50v/56F7417.BIN",
+                                0x000e0000, 131072, 0);
+
+    if (bios_only || !ret)
+        return ret;
+
+    machine_ps2_common_init(model);
+
+    /*
+    * Planar ID
+    * F1FFh - PS/55 model 5551-V0x, V1x
+    * Verification in BIOS P/N 56F7416,56F7417: FBxx -> 5 slots (ok), F1xx -> 5 slots (ok), others -> 8 (error)
+    */
+    ps2.planar_id = 0xf1ff;
+    ps55_mca_board_model_50v_init();
+
+    return ret;
+}
diff --git a/src/machine/machine_table.c b/src/machine/machine_table.c
index b9cc8461b..3706126a3 100644
--- a/src/machine/machine_table.c
+++ b/src/machine/machine_table.c
@@ -324,7 +324,7 @@ const machine_t machines[] = {
             .max_multi = 0
         },
         .bus_flags = MACHINE_PCJR,
-        .flags = MACHINE_VIDEO_FIXED,
+        .flags = MACHINE_VIDEO_FIXED | MACHINE_CARTRIDGE,
         .ram = {
             .min = 64,
             .max = 640,
@@ -5638,6 +5638,86 @@ const machine_t machines[] = {
         .snd_device = NULL,
         .net_device = NULL
     },
+    /* Has IBM PS/55 5551-Sxx, Txx stage 2 firmware. */
+    {
+        .name = "[MCA] IBM PS/55 model 5550-T",
+        .internal_name = "ibmps55_m50t",
+        .type = MACHINE_TYPE_386DX,
+        .chipset = MACHINE_CHIPSET_PROPRIETARY,
+        .init = machine_ps55_model_50t_init,
+        .p1_handler = NULL,
+        .gpio_handler = NULL,
+        .available_flag = MACHINE_AVAILABLE,
+        .gpio_acpi_handler = NULL,
+        .cpu = {
+            .package = CPU_PKG_386DX | CPU_PKG_486BL,
+            .block = CPU_BLOCK_NONE,
+            .min_bus = 0,
+            .max_bus = 0,
+            .min_voltage = 0,
+            .max_voltage = 0,
+            .min_multi = 0,
+            .max_multi = 0
+        },
+        .bus_flags = MACHINE_PS2_MCA,
+        .flags = MACHINE_VIDEO | MACHINE_APM,
+        .ram = {
+            .min = 2048,
+            .max = 16384,
+            .step = 2048
+        },
+        .nvrmask = 63,
+        .kbc_device = NULL,
+        .kbc_p1 = 0xff,
+        .gpio = 0xffffffff,
+        .gpio_acpi = 0xffffffff,
+        .device = NULL,
+        .fdc_device = NULL,
+        .sio_device = NULL,
+        .vid_device = NULL,
+        .snd_device = NULL,
+        .net_device = NULL
+    },
+    /* Has IBM PS/55 5551-V0x, V1x firmware. */
+    {
+        .name = "[MCA] IBM PS/55 model 5550-V",
+        .internal_name = "ibmps55_m50v",
+        .type = MACHINE_TYPE_386DX,
+        .chipset = MACHINE_CHIPSET_PROPRIETARY,
+        .init = machine_ps55_model_50v_init,
+        .p1_handler = NULL,
+        .gpio_handler = NULL,
+        .available_flag = MACHINE_AVAILABLE,
+        .gpio_acpi_handler = NULL,
+        .cpu = {
+            .package = CPU_PKG_386DX | CPU_PKG_486BL,
+            .block = CPU_BLOCK_NONE,
+            .min_bus = 0,
+            .max_bus = 0,
+            .min_voltage = 0,
+            .max_voltage = 0,
+            .min_multi = 0,
+            .max_multi = 0
+        },
+        .bus_flags = MACHINE_PS2_MCA,
+        .flags = MACHINE_VIDEO | MACHINE_APM,
+        .ram = {
+            .min = 4096,
+            .max = 16384,
+            .step = 4096
+        },
+        .nvrmask = 63,
+        .kbc_device = NULL,
+        .kbc_p1 = 0xff,
+        .gpio = 0xffffffff,
+        .gpio_acpi = 0xffffffff,
+        .device = NULL,
+        .fdc_device = NULL,
+        .sio_device = NULL,
+        .vid_device = NULL,
+        .snd_device = NULL,
+        .net_device = NULL
+    },
 
     /* 386DX/486 machines */
     /* Has AMIKey F KBC firmware. */
diff --git a/src/mca.c b/src/mca.c
index 871060bb4..a14fea6fa 100644
--- a/src/mca.c
+++ b/src/mca.c
@@ -101,3 +101,19 @@ mca_add(uint8_t (*read)(int addr, void *priv), void (*write)(int addr, uint8_t v
         }
     }
 }
+
+void
+mca_add_to_slot(uint8_t (*read)(int addr, void* priv), void (*write)(int addr, uint8_t val, void* priv), uint8_t(*feedb)(void* priv), void (*reset)(void* priv), void* priv, int c)
+{
+    if (mca_card_read[c] || mca_card_write[c])
+    {
+        //pclog("cannot add the device to slot %d\n", num);
+        return;
+    }
+    mca_card_read[c] = read;
+    mca_card_write[c] = write;
+    mca_card_feedb[c] = feedb;
+    mca_card_reset[c] = reset;
+    mca_priv[c] = priv;
+    return;
+}
diff --git a/src/network/net_slirp.c b/src/network/net_slirp.c
index 11f1a74b2..203428b83 100644
--- a/src/network/net_slirp.c
+++ b/src/network/net_slirp.c
@@ -60,16 +60,19 @@ enum {
 };
 
 typedef struct net_slirp_t {
-    Slirp     *slirp;
-    uint8_t    mac_addr[6];
-    netcard_t *card; /* netcard attached to us */
-    thread_t  *poll_tid;
-    net_evt_t  tx_event;
-    net_evt_t  stop_event;
-    netpkt_t   pkt;
-    netpkt_t   pkt_tx_v[SLIRP_PKT_BATCH];
+    Slirp *        slirp;
+    uint8_t        mac_addr[6];
+    netcard_t *    card; /* netcard attached to us */
+    thread_t *     poll_tid;
+    net_evt_t      rx_event;
+    net_evt_t      tx_event;
+    net_evt_t      stop_event;
+    netpkt_t       pkt;
+    netpkt_t       pkt_tx_v[SLIRP_PKT_BATCH];
+    int            during_tx;
+    int            recv_on_tx;
 #ifdef _WIN32
-    HANDLE     sock_event;
+    HANDLE         sock_event;
 #else
     uint32_t       pfd_len;
     uint32_t       pfd_size;
@@ -184,7 +187,11 @@ net_slirp_send_packet(const void *qp, size_t pkt_len, void *opaque)
 
     memcpy(slirp->pkt.data, (uint8_t *) qp, pkt_len);
     slirp->pkt.len = pkt_len;
-    network_rx_put_pkt(slirp->card, &slirp->pkt);
+    if (slirp->during_tx) {
+        network_rx_on_tx_put_pkt(slirp->card, &slirp->pkt);
+        slirp->recv_on_tx = 1;
+    } else
+        network_rx_put_pkt(slirp->card, &slirp->pkt);
 
     return pkt_len;
 }
@@ -324,6 +331,21 @@ net_slirp_in_available(void *priv)
     net_event_set(&slirp->tx_event);
 }
 
+static void
+net_slirp_rx_deferred_packets(net_slirp_t *slirp)
+{
+    int packets = 0;
+
+    if (slirp->recv_on_tx) {
+        do {
+            packets = network_rx_on_tx_popv(slirp->card, slirp->pkt_tx_v, SLIRP_PKT_BATCH);
+            for (int i = 0; i < packets; i++)
+                 network_rx_put_pkt(slirp->card, &(slirp->pkt_tx_v[i]));
+        } while (packets > 0);
+        slirp->recv_on_tx = 0;
+    }
+}
+
 #ifdef _WIN32
 static void
 net_slirp_thread(void *priv)
@@ -352,10 +374,13 @@ net_slirp_thread(void *priv)
 
             case NET_EVENT_TX:
                 {
+                    slirp->during_tx = 1;
                     int packets = network_tx_popv(slirp->card, slirp->pkt_tx_v, SLIRP_PKT_BATCH);
-                    for (int i = 0; i < packets; i++) {
+                    for (int i = 0; i < packets; i++)
                         net_slirp_in(slirp, slirp->pkt_tx_v[i].data, slirp->pkt_tx_v[i].len);
-                    }
+                    slirp->during_tx = 0;
+
+                    net_slirp_rx_deferred_packets(slirp);
                 }
                 break;
 
@@ -398,10 +423,13 @@ net_slirp_thread(void *priv)
         if (slirp->pfd[NET_EVENT_TX].revents & POLLIN) {
             net_event_clear(&slirp->tx_event);
 
+            slirp->during_tx = 1;
             int packets = network_tx_popv(slirp->card, slirp->pkt_tx_v, SLIRP_PKT_BATCH);
-            for (int i = 0; i < packets; i++) {
+            for (int i = 0; i < packets; i++)
                 net_slirp_in(slirp, slirp->pkt_tx_v[i].data, slirp->pkt_tx_v[i].len);
-            }
+            slirp->during_tx = 0;
+
+            net_slirp_rx_deferred_packets(slirp);
         }
     }
 
@@ -477,6 +505,7 @@ net_slirp_init(const netcard_t *card, const uint8_t *mac_addr, UNUSED(void *priv
         slirp->pkt_tx_v[i].data = calloc(1, NET_MAX_FRAME);
     }
     slirp->pkt.data = calloc(1, NET_MAX_FRAME);
+    net_event_init(&slirp->rx_event);
     net_event_init(&slirp->tx_event);
     net_event_init(&slirp->stop_event);
 #ifdef _WIN32
@@ -531,8 +560,9 @@ net_slirp_close(void *priv)
     slirp_log("SLiRP: waiting for thread to end...\n");
     thread_wait(slirp->poll_tid);
 
-    net_event_close(&slirp->tx_event);
     net_event_close(&slirp->stop_event);
+    net_event_close(&slirp->tx_event);
+    net_event_close(&slirp->rx_event);
     slirp_cleanup(slirp->slirp);
     for (int i = 0; i < SLIRP_PKT_BATCH; i++) {
         free(slirp->pkt_tx_v[i].data);
diff --git a/src/network/network.c b/src/network/network.c
index 66990e51d..047642085 100644
--- a/src/network/network.c
+++ b/src/network/network.c
@@ -643,6 +643,43 @@ network_rx_put(netcard_t *card, uint8_t *bufp, int len)
     return ret;
 }
 
+int
+network_rx_on_tx_popv(netcard_t *card, netpkt_t *pkt_vec, int vec_size)
+{
+    int pkt_count = 0;
+
+    netqueue_t *queue = &card->queues[NET_QUEUE_RX_ON_TX];
+    for (int i = 0; i < vec_size; i++) {
+        if (!network_queue_get_swap(queue, pkt_vec))
+            break;
+        network_dump_packet(pkt_vec);
+        pkt_count++;
+        pkt_vec++;
+    }
+
+    return pkt_count;
+}
+
+int
+network_rx_on_tx_put(netcard_t *card, uint8_t *bufp, int len)
+{
+    int ret = 0;
+
+    ret = network_queue_put(&card->queues[NET_QUEUE_RX_ON_TX], bufp, len);
+
+    return ret;
+}
+
+int
+network_rx_on_tx_put_pkt(netcard_t *card, netpkt_t *pkt)
+{
+    int ret = 0;
+
+    ret = network_queue_put_swap(&card->queues[NET_QUEUE_RX_ON_TX], pkt);
+
+    return ret;
+}
+
 int
 network_rx_put_pkt(netcard_t *card, netpkt_t *pkt)
 {
diff --git a/src/qt/qt_settingsdisplay.cpp b/src/qt/qt_settingsdisplay.cpp
index 50489ea61..75f8d376b 100644
--- a/src/qt/qt_settingsdisplay.cpp
+++ b/src/qt/qt_settingsdisplay.cpp
@@ -26,6 +26,7 @@ extern "C" {
 #include <86box/video.h>
 #include <86box/vid_8514a_device.h>
 #include <86box/vid_xga_device.h>
+#include <86box/vid_ps55da2.h>
 }
 
 #include "qt_deviceconfig.hpp"
@@ -58,6 +59,7 @@ SettingsDisplay::save()
     voodoo_enabled             = ui->checkBoxVoodoo->isChecked() ? 1 : 0;
     ibm8514_standalone_enabled = ui->checkBox8514->isChecked() ? 1 : 0;
     xga_standalone_enabled     = ui->checkBoxXga->isChecked() ? 1 : 0;
+    da2_standalone_enabled = ui->checkBoxDa2->isChecked() ? 1 : 0;
 }
 
 void
@@ -149,6 +151,12 @@ SettingsDisplay::on_pushButtonConfigureXga_clicked()
     }
 }
 
+void
+SettingsDisplay::on_pushButtonConfigureDa2_clicked()
+{
+    DeviceConfig::ConfigureDevice(&ps55da2_device, 0, qobject_cast<Settings *>(Settings::settings));
+}
+
 void
 SettingsDisplay::on_comboBoxVideo_currentIndexChanged(int index)
 {
@@ -174,6 +182,7 @@ SettingsDisplay::on_comboBoxVideo_currentIndexChanged(int index)
 
     bool machineSupports8514 = ((machineHasIsa16 || machineHasMca) && !videoCardHas8514);
     bool machineSupportsXga  = (((machineHasIsa16 && device_available(&xga_isa_device)) || (machineHasMca && device_available(&xga_device))) && !videoCardHasXga);
+    bool machineSupportsDa2 = machineHasMca && device_available(&ps55da2_device);
 
     ui->checkBox8514->setEnabled(machineSupports8514);
     ui->checkBox8514->setChecked(ibm8514_standalone_enabled && machineSupports8514);
@@ -183,7 +192,11 @@ SettingsDisplay::on_comboBoxVideo_currentIndexChanged(int index)
     ui->checkBoxXga->setEnabled(machineSupportsXga);
     ui->checkBoxXga->setChecked(xga_standalone_enabled && machineSupportsXga);
 
+    ui->checkBoxDa2->setEnabled(machineSupportsDa2);
+    ui->checkBoxDa2->setChecked(da2_standalone_enabled && machineSupportsDa2);
+
     ui->pushButtonConfigureXga->setEnabled(ui->checkBoxXga->isEnabled() && ui->checkBoxXga->isChecked());
+    ui->pushButtonConfigureDa2->setEnabled(ui->checkBoxDa2->isEnabled() && ui->checkBoxDa2->isChecked());
 
     int c = 2;
 
@@ -264,6 +277,12 @@ SettingsDisplay::on_checkBoxXga_stateChanged(int state)
     ui->pushButtonConfigureXga->setEnabled(state == Qt::Checked);
 }
 
+void
+SettingsDisplay::on_checkBoxDa2_stateChanged(int state)
+{
+    ui->pushButtonConfigureDa2->setEnabled(state == Qt::Checked);
+}
+
 void
 SettingsDisplay::on_comboBoxVideoSecondary_currentIndexChanged(int index)
 {
diff --git a/src/qt/qt_settingsdisplay.hpp b/src/qt/qt_settingsdisplay.hpp
index 3c28c52e0..854fce658 100644
--- a/src/qt/qt_settingsdisplay.hpp
+++ b/src/qt/qt_settingsdisplay.hpp
@@ -31,10 +31,12 @@ private slots:
     void on_checkBoxVoodoo_stateChanged(int state);
     void on_checkBox8514_stateChanged(int state);
     void on_checkBoxXga_stateChanged(int state);
+    void on_checkBoxDa2_stateChanged(int state);
     void on_comboBoxVideo_currentIndexChanged(int index);
     void on_pushButtonConfigureVoodoo_clicked();
     void on_pushButtonConfigure8514_clicked();
     void on_pushButtonConfigureXga_clicked();
+    void on_pushButtonConfigureDa2_clicked();
     void on_pushButtonConfigure_clicked();
 
 private:
diff --git a/src/qt/qt_settingsdisplay.ui b/src/qt/qt_settingsdisplay.ui
index f6bbeeae0..a8799204c 100644
--- a/src/qt/qt_settingsdisplay.ui
+++ b/src/qt/qt_settingsdisplay.ui
@@ -120,6 +120,20 @@
      </property>
     </widget>
    </item>
+   <item row="7" column="0">
+    <widget class="QCheckBox" name="checkBoxDa2">
+     <property name="text">
+      <string>IBM PS/55 Display Adapter Graphics</string>
+     </property>
+    </widget>
+   </item>
+   <item row="7" column="2">
+    <widget class="QPushButton" name="pushButtonConfigureDa2">
+     <property name="text">
+      <string>Configure</string>
+     </property>
+    </widget>
+   </item>
    <item row="3" column="2">
     <widget class="QPushButton" name="pushButtonConfigureSecondary">
      <property name="text">
@@ -140,7 +154,7 @@
      </property>
     </widget>
    </item>
-   <item row="7" column="0" colspan="3">
+   <item row="8" column="0" colspan="3">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
diff --git a/src/video/CMakeLists.txt b/src/video/CMakeLists.txt
index 41566bf3e..fdd94f6c6 100644
--- a/src/video/CMakeLists.txt
+++ b/src/video/CMakeLists.txt
@@ -77,6 +77,7 @@ add_library(vid OBJECT
     vid_att2xc498_ramdac.c
     vid_xga.c
     vid_bochs_vbe.c
+    vid_ps55da2.c
     nv/nv_rivatimer.c
 )
 
diff --git a/src/video/vid_ps55da2.c b/src/video/vid_ps55da2.c
new file mode 100644
index 000000000..aaf5d4803
--- /dev/null
+++ b/src/video/vid_ps55da2.c
@@ -0,0 +1,3260 @@
+/*
+ * 86Box    A hypervisor and IBM PC system emulator that specializes in
+ *          running old operating systems and software designed for IBM
+ *          PC systems and compatibles from 1981 through fairly recent
+ *          system designs based on the PCI bus.
+ *
+ *          This file is part of the 86Box distribution.
+ *
+ *          IBM PS/55 Display Adapter II (and its successors) emulation.
+ * 
+ *   Notes: There are some known issues that should be corrected.
+ *            - Incorrect foreground text color appears on an active window in OS/2 J1.3. 
+ *            - BitBlt's text drawing function does not work correctly.
+ *            - The screen resolution and blanking interval time maybe not correct.
+ * 
+ *          The code should be tested with following cases.
+ *            - Execute MODE 0, 1, 3 and 4 commands in DOS K3.3 to test various video modes.
+ *            - Run SAMPLE program with the BASIC interpreter in DOS K3.3.
+ *            - Run DOS J4.0 install program to test video mode 03.
+ *            - Run Win 3.1 (IBM-J OEM) and OS/2 J1.3 with 16 and 256 color driver to test BilBlt operations.
+ *
+ * Authors: Akamaki.
+ *
+ *          Copyright 2024-2025 Akamaki.
+ */
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <stdatomic.h>
+#define HAVE_STDARG_H
+#include <86box/86box.h>
+#include <86box/device.h>
+#include <86box/io.h>
+#include <86box/machine.h>
+#include <86box/mem.h>
+#include <86box/timer.h>
+#include <86box/mca.h>
+#include <86box/rom.h>
+#include <86box/plat.h>
+#include <86box/thread.h>
+#include <86box/video.h>
+#include <86box/vid_ps55da2.h>
+#include <86box/vid_svga.h>
+#include <86box/vid_svga_render.h>
+#include "cpu.h"
+
+#define DA2_FONTROM_PATH_JPAN    "roms/video/da2/94X1320.BIN"
+#define DA2_FONTROM_PATH_HANT    "roms/video/da2/23F2698.BIN"
+#define DA2_FONTROM_SIZE         1536 * 1024
+#define DA2_FONTROM_BASESBCS     0x98000
+#define DA2_GAIJIRAM_SBCS        0x34000
+#define DA2_GAIJIRAM_SBEX        0x3c000
+#define DA2_INVALIDACCESS8       0xff
+#define DA2_MASK_MMIO            0x1ffff
+#define DA2_MASK_GRAM            0x1ffff
+#define DA2_MASK_CRAM            0xfff
+#define DA2_MASK_GAIJIRAM        0x3ffff
+#define DA2_PIXELCLOCK           58000000.0
+#define DA2_BLT_MEMSIZE          0x100
+#define DA2_BLT_REGSIZE          0x40
+#define DA2_DEBUG_BLTLOG_SIZE    (DA2_BLT_REGSIZE + 1)
+#define DA2_DEBUG_BLTLOG_MAX     256 * 1024
+#define DA2_DEBUG_BLT_NEVERUSED  0xfefefefe
+#define DA2_DEBUG_BLT_USEDRESET  0xfefefe
+#define DA2_DCONFIG_CHARSET_JPAN 0 /* for Code page 932 Japanese */
+// #define DA2_DCONFIG_CHARSET_HANG 1 /* for Code page 934 Hangul */
+// #define DA2_DCONFIG_CHARSET_HANS 2 /* for Code page 936 Simplified Chinese */
+/* These ROMs are currently not found.
+   At least, IBM-J released a Korean and PRC version of PS/55 for each market. */
+#define DA2_DCONFIG_CHARSET_HANT  3 /* for Code page 938 Traditional Chinese */
+#define DA2_DCONFIG_MONTYPE_COLOR 0x0A
+#define DA2_DCONFIG_MONTYPE_8515  0x0B
+#define DA2_DCONFIG_MONTYPE_MONO  0x09
+
+#define DA2_BLT_CIDLE             0
+#define DA2_BLT_CFILLRECT         1
+#define DA2_BLT_CFILLTILE         2
+#define DA2_BLT_CCOPYF            3
+#define DA2_BLT_CCOPYR            4
+#define DA2_BLT_CPUTCHAR          5
+#define DA2_BLT_CDONE             6
+#define DA2_BLT_CLOAD             7
+/* POS ID = 0xeffe : Display Adapter II, III, V  */
+#define DA2_POSID_H 0xef
+#define DA2_POSID_L 0xfe
+/*
+     [Identification]
+    POS ID	SYS ID
+    EFFFh	*		Display Adapter (PS/55 Model 5571-S0A) [Toledo]
+    E013h	*		Layout Display Terminal (PS/55-5571 RPQ model) [LDT]
+    EFFEh	*		Display Adapter II (I/O 3E0:0A = xx0x xxxx) [Atlas]
+    |-		FFF2h	Display Adapter B2 (I/O 3E0:0A = xx1x xxxx) (PS/55 Model 5530Z-SX)
+    |-		FDFEh	Display Adapter B2 (I/O 3E0:0A = xx1x xxxx) (PS/55 Model 5550-V2)
+    |-		*		Display Adapter III,V (I/O 3E0:0A = xx1x xxxx)
+    ECECh	FF4Fh	Display Adapter B1 (PS/55 Model 5531Z-SX) [Atlas-KENT]
+    |-		*		Display Adapter IV
+    ECCEh	*		Display Adapter IV
+    901Fh	*		Display Adapter A2
+    901Dh	*		Display Adapter A1 [Atlas II]
+    901Eh	*		Plasma Display Adapter
+    EFD8h	*		Display Adapter/J [Atlas-SP2]
+
+     [Japanese DOS and Display Adapter compatibility]
+    | POS ID     | Adapter Name                | K3.31 | J4.04 | J4.08 | OS2 J1.3 | Win3 |
+    |------------|-----------------------------|:-----:|:-----:|:-----:|:--------:|:----:|
+    | EFFFh      | Display Adapter             | X     |       |       |          |      |
+    | FFEDh      | ? [Atlas EVT]               | X     |       |       |          |      |
+    | FFFDh      | ? [LDT EVT]                 | X     |       |       |          |      |
+    | EFFEh      | Display Adapter II,III,V,B2 | X     | X     | X     | X        | X    |
+    | E013h      | ? [LDT]                     | X     | X     | X     | X        |      |
+    | ECCEh      | Display Adapter IV          |       | X     | X     | X        |      |
+    | ECECh      | Display Adapter IV,B1       |       | X     | X     | X        | X    |
+    | 9000-901Fh | Display Adapter A1,A2       |       | X     | X     |          | X    |
+    | EFD8h      | Display Adapter /J          |       |       | X     | X        | X    |
+*/
+/* IO 3E0/3E1:0Ah Hardware Configuration Value L (imported from OS/2 DDK) */
+#define OldLSI 0x20 /* 1 = DA-2, 0 = DA-3 */
+// #define  Mon_ID3   0x10
+#define FontCard  0x08 /* ? */
+#define Page_One  0x06 /*  80000h 110b */
+#define Page_Two  0x05 /* 100000h 101b */
+#define Page_Four 0x03 /* 200000h 011b */
+/* Page Number Mask : Memory Size? = (110b and 111b): vram size is 512k (256 color mode unsupported). */
+
+/* IO 3E0/3E1:0Bh Hardware Configuration Value H (imported from OS/2 DDK) */
+#define AddPage 0x08 /* ? */
+// #define  Mon_ID2   0x04
+// #define  Mon_ID1   0x02
+// #define  Mon_ID0   0x01
+
+/* Monitor ID (imported from OS/2 DDK 1.2)
+#define  StarbuckC     0x0A  // 1 010b IBM 8514, 9518 color 1040x768
+#define  StarbuckM     0x09  // 1 001b IBM 8507, 8604 grayscale
+#define  Lark_B        0x02  // 0 010b IBM 9517       color 1040x768 but 4bpp
+#define  Dallas        0x0B  // 1 011b IBM 8515, 9515 color 1040x740 another palette
+*/
+
+/* DA2 Registers (imported from OS/2 DDK) */
+#define AC_REG                  0x3EE
+#define AC_DMAE                 0x80
+#define AC_FONT_SEL             0x40
+#define FONT_BANK               0x3EF
+#define LS_INDEX                0x3E0
+#define LS_DATA                 0x3E1
+#define LS_RESET                0x00
+#define LS_MODE                 0x02
+#define LS_STATUS               0x03 /* added */
+#define LS_MMIO                 0x08 /* added */
+#define LS_CONFIG1              0x0a
+#define LS_CONFIG2              0x0b /* added */
+#define LF_INDEX                0x3e2
+#define LF_DATA                 0x3e3
+#define LF_MMIO_SEL             0x08 /* added */
+#define LF_MMIO_ADDR            0x0A /* added */
+#define LF_MMIO_MODE            0x0B /* added */
+#define LC_INDEX                0x3E4
+#define LC_DATA                 0x3E5
+#define LC_HORIZONTAL_TOTAL     0x00
+#define LC_H_DISPLAY_ENABLE_END 0x01
+#define LC_START_H_BLANKING     0x02
+#define LC_END_H_BLANKING       0x03
+#define LC_START_HSYNC_PULSE    0x04
+#define LC_END_HSYNC_PULSE      0x05
+#define LC_VERTICAL_TOTALJ      0x06
+#define LC_CRTC_OVERFLOW        0x07
+#define LC_PRESET_ROW_SCANJ     0x08
+#define LC_MAXIMUM_SCAN_LINE    0x09
+#define LC_CURSOR_ROW_START     0x0A
+#define LC_CURSOR_ROW_END       0x0B
+#define LC_START_ADDRESS_HIGH   0x0C
+#define LC_START_ADDRESS_LOW    0x0D
+#define LC_CURSOR_LOC_HIGH      0x0E
+#define LC_ROW_CURSOR_LOC       0x0E
+#define LC_CURSOR_LOC_LOWJ      0x0F
+#define LC_COLUMN_CURSOR_LOC    0x0F
+#define LC_VERTICAL_SYNC_START  0x10
+#define LC_LIGHT_PEN_HIGH       0x10
+#define LC_VERTICAL_SYNC_END    0x11
+#define LC_LIGHT_PEN_LOW        0x11
+#define LC_V_DISPLAY_ENABLE_END 0x12
+#define LC_OFFSET               0x13
+#define LC_UNDERLINE_LOCATION   0x14
+#define LC_START_VERTICAL_BLANK 0x15
+#define LC_END_VERTICAL_BLANK   0x16
+#define LC_LC_MODE_CONTROL      0x17
+#define LC_LINE_COMPAREJ        0x18
+#define LC_START_H_DISPLAY_ENAB 0x19
+#define LC_START_V_DISPLAY_ENAB 0x1A
+#define LC_VIEWPORT_COMMAND     0x1B
+#define LC_VIEWPORT_SELECT      0x1C
+#define LC_VIEWPORT_PRIORITY    0x1D
+#define LC_COMMAND              0x1E
+#define LC_COMPATIBILITY        0x1F
+#define LC_VIEWPORT_NUMBER      0x1F
+#define LV_PORT                 0x3E8
+#define LV_PALETTE_0            0x00
+#define LV_MODE_CONTROL         0x10
+#define LV_OVERSCAN_COLOR       0x11
+#define LV_COLOR_PLANE_ENAB     0x12
+#define LV_PANNING              0x13
+#define LV_VIEWPORT1_BG         0x14
+#define LV_VIEWPORT2_BG         0x15
+#define LV_VIEWPORT3_BG         0x16
+#define LV_BLINK_COLOR          0x17
+#define LV_BLINK_CODE           0x18
+#define LV_GR_CURSOR_ROTATION   0x19
+#define LV_GR_CURSOR_COLOR      0x1A
+#define LV_GR_CURSOR_CONTROL    0x1B
+#define LV_COMMAND              0x1C
+#define LV_VP_BORDER_LINE       0x1D
+#define LV_SYNC_POLARITY        0x1F
+#define LV_CURSOR_CODE_0        0x20
+#define LV_GRID_COLOR_0         0x34
+#define LV_GRID_COLOR_1         0x35
+#define LV_GRID_COLOR_2         0x36
+#define LV_GRID_COLOR_3         0x37
+#define LV_ATTRIBUTE_CNTL       0x38
+#define LV_CURSOR_COLOR         0x3A
+#define LV_CURSOR_CONTROL       0x3B
+#define LV_RAS_STATUS_VIDEO     0x3C
+#define LV_PAS_STATUS_CNTRL     0x3D
+#define LV_IDENTIFICATION       0x3E
+#define LV_OUTPUT               0x3E
+#define LV_COMPATIBILITY        0x3F
+#define LG_INDEX                0x3EA
+#define LG_DATA                 0x3EB
+#define LG_SET_RESETJ           0x00
+#define LG_ENABLE_SRJ           0x01
+#define LG_COLOR_COMPAREJ       0x02
+#define LG_DATA_ROTATION        0x03
+#define LG_READ_MAP_SELECT      0x04
+#define LG_MODE                 0x05
+#define LG_COMPLEMENT           0x06
+#define LG_COLOR_DONT_CARE      0x07
+#define LG_BIT_MASK_LOW         0x08
+#define LG_BIT_MASK_HIGH        0x09
+#define LG_MAP_MASKJ            0x0A
+#define LG_COMMAND              0x0B
+#define LG_SET_RESET_2          0x10
+
+#ifndef RELEASE_BUILD
+// #define ENABLE_DA2_LOG 1
+#endif
+
+#ifdef ENABLE_DA2_LOG
+#    define ENABLE_DA2_DEBUGBLT 1
+// #    define ENABLE_DA2_DEBUGFULLSCREEN 1
+int da2_do_log = ENABLE_DA2_LOG;
+
+static void
+da2_log(const char *fmt, ...)
+{
+    va_list ap;
+
+    if (da2_do_log) {
+        va_start(ap, fmt);
+        pclog_ex(fmt, ap);
+        va_end(ap);
+    }
+}
+#else
+#    define da2_log(fmt, ...)
+#endif
+
+typedef struct da2_t {
+    // mem_mapping_t vmapping;
+    mem_mapping_t cmapping;
+
+    // uint8_t crtcreg;
+    uint8_t  ioctl[16];
+    uint8_t  fctl[32];
+    uint16_t crtc[128];
+    uint8_t  gdcreg[64];
+    uint8_t  reg3ee[16];
+    int      gdcaddr;
+    uint8_t  attrc[0x40];
+    int      attraddr, attrff;
+    int      attr_palette_enable;
+    // uint8_t seqregs[64];
+    int outflipflop;
+    int inflipflop;
+    int iolatch;
+
+    int ioctladdr;
+    int fctladdr;
+    int crtcaddr;
+
+    uint32_t decode_mask;
+    uint32_t vram_max;
+    uint32_t vram_mask;
+
+    uint32_t gdcla[8];
+    uint32_t gdcinput[8];
+    uint32_t gdcsrc[8];
+    uint32_t debug_vramold[8];
+
+    uint8_t dac_mask, dac_status;
+    int     dac_read, dac_write, dac_pos;
+    int     dac_r, dac_g;
+
+    uint8_t cgastat;
+
+    uint8_t plane_mask;
+
+    int fb_only;
+
+    int      fast;
+    uint8_t  colourcompare, colournocare;
+    int      readmode, writemode, readplane;
+    uint8_t  writemask;
+    uint32_t charseta, charsetb;
+
+    uint8_t  egapal[16];
+    uint32_t pallook[512];
+    PALETTE  vgapal;
+
+    int      vtotal, dispend, vsyncstart, split, vblankstart;
+    int      hdisp, hdisp_old, htotal, hdisp_time, rowoffset;
+    int      lowres, interlace;
+    int      rowcount;
+    double   clock;
+    uint32_t ma_latch, ca_adj;
+
+    uint64_t   dispontime, dispofftime;
+    pc_timer_t timer;
+    uint64_t   da2const;
+
+    int dispon;
+    int hdisp_on;
+
+    uint32_t ma, maback, ca;
+    int      vc;
+    int      sc;
+    int      linepos, vslines, linecountff, oddeven;
+    int      con, cursoron, blink, blinkconf;
+    int      scrollcache;
+    int      char_width;
+
+    int firstline, lastline;
+    int firstline_draw, lastline_draw;
+    int displine;
+
+    /* Attribute Buffer E0000-E0FFFh (4 KB) */
+    uint8_t *cram;
+    /* (cram size - 1) >> 3 = 0xFFF */
+    // uint32_t cram_display_mask;
+    /* APA Buffer A0000-BFFFFh (128 KB) */
+    uint8_t *vram;
+    /* addr >> 12 = xx000h */
+    uint8_t *changedvram;
+    /* (vram size - 1) >> 3 = 0x1FFFF */
+    uint32_t vram_display_mask;
+
+    // uint32_t write_bank, read_bank;
+
+    int fullchange;
+
+    void (*render)(struct da2_t *da2);
+
+    /*If set then another device is driving the monitor output and the SVGA
+      card should not attempt to display anything */
+    int override;
+
+    /* end VGA compatible regs*/
+    struct
+    {
+        int           enable;
+        mem_mapping_t mapping;
+        uint8_t       ram[256 * 1024];
+        uint8_t      *font;
+        int           charset;
+    } mmio;
+
+    struct {
+        int        bitshift_destr;
+        int        raster_op;
+        uint8_t    payload[DA2_BLT_MEMSIZE];
+        int32_t    reg[DA2_BLT_REGSIZE]; // must be signed int
+#ifdef ENABLE_DA2_DEBUGBLT
+        int32_t   *debug_reg;            // for debug
+        int        debug_reg_ip;         // for debug
+#endif
+        int        payload_addr;
+        pc_timer_t timer;
+        int64_t    timerspeed;
+        int        exec;
+        int        indata;
+        int32_t    destaddr;
+        int32_t    srcaddr;
+        int32_t    size_x, tile_w;
+        int32_t    size_y;
+        int16_t    destpitch;
+        int16_t    srcpitch;
+        int32_t    fcolor;
+        int32_t    maskl, maskr;
+        int        x, y;
+    } bitblt;
+
+#ifdef ENABLE_DA2_DEBUGBLT
+    FILE    *mmdbg_fp;
+    FILE    *mmrdbg_fp;
+    uint32_t mmdbg_vidaddr;
+    uint32_t mmrdbg_vidaddr;
+#endif
+
+    uint8_t pos_regs[8];
+    svga_t *mb_vga;
+    uint8_t monitorid;
+
+    int old_pos2;
+} da2_t;
+
+void        da2_recalctimings(da2_t *da2);
+static void da2_mmio_gc_writeW(uint32_t addr, uint16_t val, void *p);
+void        da2_bitblt_exec(void *p);
+void        da2_updatevidselector(da2_t *da2);
+void        da2_reset_ioctl(da2_t *da2);
+static void da2_reset(void *priv);
+
+typedef union {
+    uint32_t d;
+    uint8_t  b[4];
+} DA2_VidSeq32;
+
+typedef struct {
+    uint32_t p8[8];
+} pixel32;
+
+/* safety read for internal functions */
+uint32_t
+DA2_readvram_s(uint32_t addr, da2_t *da2)
+{
+    if (addr & ~da2->vram_mask)
+        return -1;
+    return da2->vram[addr];
+}
+
+void
+DA2_WritePlaneDataWithBitmask(uint32_t destaddr, const uint16_t mask, pixel32 *srcpx, da2_t *da2)
+{
+    uint32_t writepx[8];
+    destaddr &= 0xfffffffe; /* align to word address to work bit shift correctly */
+    // da2_log("DA2_WPDWB addr %x mask %x rop %x shift %d\n", destaddr, mask, da2->bitblt.raster_op, da2->bitblt.bitshift_destr);
+    da2->changedvram[(da2->vram_display_mask & destaddr) >> 12]       = changeframecount;
+    da2->changedvram[(da2->vram_display_mask & (destaddr + 1)) >> 12] = changeframecount;
+    destaddr <<= 3;
+    /* read destination data with big endian order */
+    for (int i = 0; i < 8; i++)
+        writepx[i] = DA2_readvram_s((destaddr + 24) | i, da2)
+            | (DA2_readvram_s((destaddr + 16) | i, da2) << 8)
+            | (DA2_readvram_s((destaddr + 8) | i, da2) << 16)
+            | (DA2_readvram_s((destaddr + 0) | i, da2) << 24);
+
+    DA2_VidSeq32 mask32in;
+    mask32in.d = (uint32_t) mask;
+    DA2_VidSeq32 mask32;
+    mask32.d    = 0;
+    mask32.b[3] = mask32in.b[0];
+    mask32.b[2] = mask32in.b[1];
+    mask32.d &= 0xffff0000;
+    for (int i = 0; i < 8; i++) {
+        if (da2->bitblt.bitshift_destr > 0)
+            srcpx->p8[i] <<= 16 - da2->bitblt.bitshift_destr;
+        switch (da2->bitblt.raster_op) {
+            case 0x00: /* None */
+                writepx[i] &= ~mask32.d;
+                writepx[i] |= srcpx->p8[i] & mask32.d;
+                break;
+            case 0x01: /* AND */
+                writepx[i] &= srcpx->p8[i] | ~mask32.d;
+                break;
+            case 0x02: /* OR */
+                writepx[i] |= srcpx->p8[i] & mask32.d;
+                break;
+            case 0x03: /* XOR */
+                writepx[i] ^= srcpx->p8[i] & mask32.d;
+                break;
+        }
+    }
+    for (int i = 0; i < 8; i++) {
+        da2->vram[(da2->vram_mask & destaddr) | i]       = (writepx[i] >> 24) & 0xff;
+        da2->vram[(da2->vram_mask & (destaddr + 8)) | i] = (writepx[i] >> 16) & 0xff;
+    }
+}
+
+void
+DA2_DrawColorWithBitmask(uint32_t destaddr, uint8_t color, uint16_t mask, da2_t *da2)
+{
+    pixel32 srcpx;
+    /* fill data with input color */
+    for (int i = 0; i < 8; i++)
+        srcpx.p8[i] = (color & (1 << i)) ? 0xffffffff : 0; /* read in word */
+
+    DA2_WritePlaneDataWithBitmask(destaddr, mask, &srcpx, da2);
+}
+/*
+Param   Desc
+01      Color
+03      Bit Shift
+04      Select plane?
+05      Dir(10 or 11) + Command?(40 or 48)
+08      Mask Left
+09      Mask Right
+0A      Plane Mask?
+0B      ROP?(8h or 200h + 0-3h)
+0D
+20      Exec (1)
+21      ?
+22      ?
+23      Tile W
+28      Tile H
+29      Dest Addr
+2A      Src Addr
+2B      Tile Addr
+33      Size W
+35      Size H
+*/
+void
+DA2_CopyPlaneDataWithBitmask(uint32_t srcaddr, uint32_t destaddr, uint16_t mask, da2_t *da2)
+{
+    pixel32 srcpx;
+    srcaddr &= 0xfffffffe;
+    srcaddr <<= 3;
+    for (int i = 0; i < 8; i++)
+        srcpx.p8[i] = DA2_readvram_s((srcaddr + 24) | i, da2)
+            | (DA2_readvram_s((srcaddr + 16) | i, da2) << 8)
+            | (DA2_readvram_s((srcaddr + 8) | i, da2) << 16)
+            | (DA2_readvram_s((srcaddr + 0) | i, da2) << 24);
+
+    DA2_WritePlaneDataWithBitmask(destaddr, mask, &srcpx, da2);
+}
+void
+DA2_PutcharWithBitmask(uint32_t srcaddr, uint32_t destaddr, uint16_t mask, da2_t *da2)
+{
+    pixel32 srcpx;
+    if (srcaddr >= DA2_FONTROM_SIZE) {
+        da2_log("DA2 Putchar Addr Error %x\n", srcaddr);
+        return;
+    }
+    for (int i = 0; i < 8; i++)
+        srcpx.p8[i] = ((uint32_t) da2->mmio.font[srcaddr] << 24)
+            | ((uint32_t) da2->mmio.font[srcaddr + 1] << 16)
+            | ((uint32_t) da2->mmio.font[srcaddr + 2] << 8)
+            | ((uint32_t) da2->mmio.font[srcaddr + 3] << 0);
+
+    DA2_WritePlaneDataWithBitmask(destaddr, mask, &srcpx, da2);
+}
+#ifdef ENABLE_DA2_DEBUGBLT
+uint8_t
+pixel1tohex(uint32_t addr, int index, da2_t *da2)
+{
+    uint8_t pixeldata = 0;
+    for (int j = 0; j < 8; j++) {
+        if (da2->vram[(da2->vram_mask & (addr << 3)) | j] & (1 << (7 - index)))
+            pixeldata++;
+    }
+    return pixeldata;
+}
+void
+print_pixelbyte(uint32_t addr, da2_t *da2)
+{
+    for (int i = 0; i < 8; i++) {
+        pclog("%X", pixel1tohex(addr, i, da2));
+    }
+}
+void
+print_bytetobin(uint8_t b)
+{
+    for (int i = 0; i < 8; i++) {
+        if (b & 0x80)
+            pclog("1");
+        else
+            pclog("0");
+        b <<= 1;
+    }
+}
+// Convert internal char code to Shift JIS code
+inline int
+isKanji1(uint8_t chr)
+{
+    return (chr >= 0x81 && chr <= 0x9f) || (chr >= 0xe0 && chr <= 0xfc);
+}
+inline int
+isKanji2(uint8_t chr)
+{
+    return (chr >= 0x40 && chr <= 0x7e) || (chr >= 0x80 && chr <= 0xfc);
+}
+uint16_t
+IBMJtoSJIS(uint16_t knj)
+{
+    if (knj < 0x100)
+        return 0xffff;
+    knj -= 0x100;
+    if (knj <= 0x1f7d)
+        ; /* do nothing */
+    else if (knj >= 0xb700 && knj <= 0xb75f) {
+        knj -= 0x90ec;
+    } else if (knj >= 0xb3f0 && knj <= 0xb67f) {
+        knj -= 0x906c;
+    } else if (knj >= 0x8000 && knj <= 0x8183) {
+        knj -= 0x5524;
+    } else
+        return 0xffff;
+    uint32_t knj1 = knj / 0xBC;
+    uint32_t knj2 = knj - (knj1 * 0xBC);
+    knj1 += 0x81;
+    if (knj1 > 0x9F)
+        knj1 += 0x40;
+    knj2 += 0x40;
+    if (knj2 > 0x7E)
+        knj2++;
+    // if (!isKanji1(knj1)) return 0xffff;
+    // if (!isKanji2(knj2)) return 0xffff;
+    knj = knj1 << 8;
+    knj |= knj2;
+    return knj;
+}
+#endif
+void
+da2_bitblt_load(da2_t *da2)
+{
+    uint32_t value32;
+    uint64_t value64;
+    da2_log("bltload: loading params\n");
+    // da2_log("BitBlt memory:\n");
+    // if (da2->bitblt.payload[0] != 0)
+    //     for (int j = 0; j < DA2_BLT_MEMSIZE / 8; j++)
+    //     {
+    //         int i = j * 8;
+    //         da2_log("%02x %02x %02x %02x %02x %02x %02x %02x \n", da2->bitblt.payload[i], da2->bitblt.payload[i + 1], da2->bitblt.payload[i + 2], da2->bitblt.payload[i + 3],
+    //             da2->bitblt.payload[i + 4], da2->bitblt.payload[i + 5], da2->bitblt.payload[i + 6], da2->bitblt.payload[i + 7]);
+    //     }
+    int i = 0;
+    while (i < DA2_BLT_MEMSIZE) {
+        if (da2->bitblt.reg[0x20] & 0x1)
+            break;
+        switch (da2->bitblt.payload[i]) {
+            case 0x88:
+            case 0x89:
+            case 0x95:
+                value32 = da2->bitblt.payload[i + 3];
+                value32 <<= 8;
+                value32 |= da2->bitblt.payload[i + 2];
+                da2_log("[%02x] %02x: %04x (%d)\n", da2->bitblt.payload[i], da2->bitblt.payload[i + 1], value32, value32);
+                da2->bitblt.reg[da2->bitblt.payload[i + 1]] = value32;
+                i += 3;
+                break;
+            case 0x91:
+                value32 = da2->bitblt.payload[i + 5];
+                value32 <<= 8;
+                value32 |= da2->bitblt.payload[i + 4];
+                value32 <<= 8;
+                value32 |= da2->bitblt.payload[i + 3];
+                value32 <<= 8;
+                value32 |= da2->bitblt.payload[i + 2];
+                da2_log("[%02x] %02x: %08x (%d)\n", da2->bitblt.payload[i], da2->bitblt.payload[i + 1], value32, value32);
+                da2->bitblt.reg[da2->bitblt.payload[i + 1]] = value32;
+                i += 5;
+                break;
+            case 0x99:
+                value64 = da2->bitblt.payload[i + 7];
+                value64 <<= 8;
+                value64 = da2->bitblt.payload[i + 6];
+                value64 <<= 8;
+                value64 = da2->bitblt.payload[i + 5];
+                value64 <<= 8;
+                value64 |= da2->bitblt.payload[i + 4];
+                value64 <<= 8;
+                value64 |= da2->bitblt.payload[i + 3];
+                value64 <<= 8;
+                value64 |= da2->bitblt.payload[i + 2];
+                da2_log("[%02x] %02x: %02x %02x %02x %02x %02x %02x\n", da2->bitblt.payload[i], da2->bitblt.payload[i + 1], da2->bitblt.payload[i + 2], da2->bitblt.payload[i + 3],
+                        da2->bitblt.payload[i + 4], da2->bitblt.payload[i + 5], da2->bitblt.payload[i + 6], da2->bitblt.payload[i + 7]);
+                da2->bitblt.reg[da2->bitblt.payload[i + 1]] = value64;
+                i += 7;
+                break;
+            case 0x00:
+                break;
+            default:
+                da2_log("bltload: Unknown PreOP!\n");
+                break;
+        }
+        i++;
+    }
+    da2->bitblt.exec = DA2_BLT_CIDLE;
+    // /* clear payload memory */
+    // memset(da2->bitblt.payload, 0x00, DA2_BLT_MEMSIZE);
+    // da2->bitblt.payload_addr = 0;
+    /* [89] 20: 0001 (1) then execute payload */
+    if (da2->bitblt.reg[0x20] & 0x1) {
+        /* clear payload memory */
+        memset(da2->bitblt.payload, 0x00, DA2_BLT_MEMSIZE);
+        da2->bitblt.payload_addr = 0;
+#ifdef ENABLE_DA2_DEBUGBLT
+        for (i = 0; i < DA2_DEBUG_BLTLOG_SIZE; i++) {
+            // if(da2->bitblt.reg[i] != 0xfefe && da2->bitblt.reg[i] != DA2_DEBUG_BLT_NEVERUSED) da2_log("%02x: %04x (%d)\n",i, da2->bitblt.reg[i], da2->bitblt.reg[i]);
+        }
+        for (i = 0; i < DA2_DEBUG_BLTLOG_SIZE; i++) {
+            da2->bitblt.debug_reg[DA2_DEBUG_BLTLOG_SIZE * da2->bitblt.debug_reg_ip + i] = da2->bitblt.reg[i];
+        }
+        da2->bitblt.debug_reg[DA2_DEBUG_BLTLOG_SIZE * (da2->bitblt.debug_reg_ip + 1) - 1] = 0;
+        da2->bitblt.debug_reg_ip++;
+        if (da2->bitblt.debug_reg_ip >= DA2_DEBUG_BLTLOG_MAX)
+            da2->bitblt.debug_reg_ip = 0;
+#endif
+        da2->bitblt.bitshift_destr = ((da2->bitblt.reg[0x3] >> 4) & 0x0f); /* set bit shift */
+        da2->bitblt.raster_op      = da2->bitblt.reg[0x0b] & 0x03;         /* 01 AND, 03 XOR */
+        da2_log("bltload_exec: %x, rop: %x CS:PC=%4x:%4x\n", da2->bitblt.reg[0x5], da2->bitblt.reg[0x0b], CS, cpu_state.pc);
+        // for (int i = 0; i <= 0xb; i++)
+        // {
+        //     da2_log("%02x ", da2->gdcreg[i]);
+        //     da2->gdcreg[i] = da2->bitblt.reg[i] & 0xff;
+        // }
+        // da2_log("\n");
+
+        da2->bitblt.destaddr  = da2->bitblt.reg[0x29];
+        da2->bitblt.size_x    = da2->bitblt.reg[0x33];
+        da2->bitblt.size_y    = da2->bitblt.reg[0x35];
+        da2->bitblt.destpitch = da2->bitblt.reg[0x21];
+        da2->bitblt.srcpitch  = da2->bitblt.reg[0x22];
+        if (da2->bitblt.reg[0x2F] == 0x90) /* destaddr -= 2, length += 1; */
+        {
+            da2->bitblt.destaddr -= 2;
+            da2->bitblt.size_x += 1;
+            da2->bitblt.destpitch -= 2;
+            da2->bitblt.srcpitch -= 2;
+        }
+        da2->bitblt.fcolor = da2->bitblt.reg[0x0];
+        da2->bitblt.maskl  = da2->bitblt.reg[0x8];
+        da2->bitblt.maskr  = da2->bitblt.reg[0x9];
+        da2->bitblt.x      = 0;
+        da2->bitblt.y      = 0;
+        da2->bitblt.exec   = DA2_BLT_CDONE;
+        timer_set_delay_u64(&da2->bitblt.timer, da2->bitblt.timerspeed);
+
+        if (da2->bitblt.reg[0x2f] < 0x80) /* MS Paint 3.1 will cause hang up in 256 color mode */
+        {
+            da2_log("bitblt not executed 2f:%x\n", da2->bitblt.reg[0x2f]);
+            da2->bitblt.exec = DA2_BLT_CDONE;
+        } else if (da2->bitblt.reg[0x10] == 0xbc04) { /* Put char used by OS/2 (i'm not sure what the condition is) */
+            da2->bitblt.exec = DA2_BLT_CPUTCHAR;
+            /* Todo: addressing */
+            // if (da2->bitblt.reg[0x2F] == 0x90) /* destaddr -= 2, length += 1; */
+            //{
+            //     da2->bitblt.destaddr += 2;
+            //     da2->bitblt.size_x -= 1;
+            //     da2->bitblt.destpitch += 2;
+            //     da2->bitblt.srcpitch += 2;
+            // }
+            da2->bitblt.srcaddr = da2->bitblt.reg[0x12] * 72 + 2;
+            da2->bitblt.destaddr += 2;
+            da2->bitblt.srcpitch  = 0;
+            da2->bitblt.raster_op = da2->bitblt.reg[0x05] & 0x03; /* XOR */
+            da2->bitblt.bitshift_destr += 1;
+#ifdef ENABLE_DA2_DEBUGBLT
+            uint32_t sjis_h = IBMJtoSJIS(da2->bitblt.reg[0x12]) >> 8;
+            uint32_t sjis_l = IBMJtoSJIS(da2->bitblt.reg[0x12]) & 0xff;
+            da2_log("put char src=%x, dest=%x, x=%d, y=%d, w=%d, h=%d, c=%c%c\n",
+                    da2->bitblt.srcaddr, da2->bitblt.destaddr,
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y, sjis_h, sjis_l);
+#endif
+        } else if (da2->bitblt.reg[0x10] == 0x0004 || da2->bitblt.reg[0x10] == 0x0E04) {
+            da2->bitblt.exec    = DA2_BLT_CPUTCHAR;
+            da2->bitblt.srcaddr = da2->bitblt.reg[0x12] * 64 + 2 + DA2_FONTROM_BASESBCS;
+            da2->bitblt.destaddr += 2;
+            da2->bitblt.srcpitch  = 0;
+            da2->bitblt.raster_op = da2->bitblt.reg[0x05] & 0x03; /* XOR */
+            da2->bitblt.bitshift_destr += 1;
+#ifdef ENABLE_DA2_DEBUGBLT
+            uint32_t sjis_h = IBMJtoSJIS(da2->bitblt.reg[0x12]) >> 8;
+            uint32_t sjis_l = IBMJtoSJIS(da2->bitblt.reg[0x12]) & 0xff;
+            da2_log("put char src=%x, dest=%x, x=%d, y=%d, w=%d, h=%d, c=%c%c\n",
+                    da2->bitblt.srcaddr, da2->bitblt.destaddr,
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y, sjis_h, sjis_l);
+#endif
+        }
+        /* Fill a rectangle(or draw a line) */
+        else if ((da2->bitblt.reg[0x5] & 0xfff0) == 0x40 && da2->bitblt.reg[0x3D] == 0) {
+            da2_log("fillrect x=%d, y=%d, w=%d, h=%d, c=%d, 2f=%x, rowcount=%x\n",
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y, da2->bitblt.reg[0x0], da2->bitblt.reg[0x2F], da2->rowoffset * 2);
+            da2->bitblt.exec = DA2_BLT_CFILLRECT;
+            da2->bitblt.destaddr += 2;
+        }
+        /* Tiling a rectangle ??(transfer tile data multiple times) os/2 only */
+        else if ((da2->bitblt.reg[0x5] & 0xfff0) == 0x0040 && da2->bitblt.reg[0x3D] == 0x40) {
+            da2->bitblt.exec = DA2_BLT_CFILLTILE;
+            da2->bitblt.destaddr += 2;
+            da2->bitblt.srcaddr = da2->bitblt.reg[0x2B];
+            da2->bitblt.tile_w  = da2->bitblt.reg[0x28];
+            da2_log("copy tile src=%x, dest=%x, x1=%d, y1=%d, x2=%d, y2=%d, w=%d, h=%d\n",
+                    da2->bitblt.srcaddr, da2->bitblt.destaddr,
+                    da2->bitblt.reg[0x2B] % (da2->rowoffset * 2), da2->bitblt.reg[0x2B] / (da2->rowoffset * 2),
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y);
+        }
+        /* Tiling a rectangle (transfer tile data multiple times) */
+        else if ((da2->bitblt.reg[0x5] & 0xfff0) == 0x1040 && da2->bitblt.reg[0x3D] == 0x40) {
+            da2->bitblt.exec = DA2_BLT_CFILLTILE;
+            da2->bitblt.destaddr += 2;
+            da2->bitblt.srcaddr = da2->bitblt.reg[0x2B];
+            da2->bitblt.tile_w  = da2->bitblt.reg[0x28];
+            da2_log("copy tile src=%x, dest=%x, x1=%d, y1=%d, x2=%d, y2=%d, w=%d, h=%d\n",
+                    da2->bitblt.srcaddr, da2->bitblt.destaddr,
+                    da2->bitblt.reg[0x2B] % (da2->rowoffset * 2), da2->bitblt.reg[0x2B] / (da2->rowoffset * 2),
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y);
+        }
+        /* Block transfer (range copy) */
+        else if ((da2->bitblt.reg[0x5] & 0xfff0) == 0x1040 && da2->bitblt.reg[0x3D] == 0x00) {
+            da2->bitblt.exec    = DA2_BLT_CCOPYF;
+            da2->bitblt.srcaddr = da2->bitblt.reg[0x2A];
+            da2->bitblt.destaddr += 2;
+            da2_log("copy block src=%x, dest=%x, x1=%d, y1=%d, x2=%d, y2=%d, w=%d, h=%d\n",
+                    da2->bitblt.srcaddr, da2->bitblt.destaddr,
+                    da2->bitblt.reg[0x2A] % (da2->rowoffset * 2), da2->bitblt.reg[0x2A] / (da2->rowoffset * 2),
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y);
+        }
+        /* Block copy but reversed direction */
+        else if ((da2->bitblt.reg[0x5] & 0xfff0) == 0x1140 && da2->bitblt.reg[0x3D] == 0x00) {
+            da2->bitblt.exec    = DA2_BLT_CCOPYR;
+            da2->bitblt.srcaddr = da2->bitblt.reg[0x2A];
+            da2->bitblt.destaddr -= 2;
+            da2->bitblt.srcaddr -= 2;
+            da2_log("copy blockR src=%x, dest=%x, x1=%d, y1=%d, x2=%d, y2=%d, w=%d, h=%d\n",
+                    da2->bitblt.srcaddr, da2->bitblt.destaddr,
+                    da2->bitblt.reg[0x2A] % (da2->rowoffset * 2), da2->bitblt.reg[0x2A] / (da2->rowoffset * 2),
+                    da2->bitblt.reg[0x29] % (da2->rowoffset * 2), da2->bitblt.reg[0x29] / (da2->rowoffset * 2),
+                    da2->bitblt.size_x, da2->bitblt.size_y);
+            // da2_log("            mask8=%x, mask9=%x\n", da2->bitblt.reg[0x8], da2->bitblt.reg[0x9]);
+        }
+    }
+}
+void
+da2_bitblt_exec(void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    // timer_set_delay_u64(&da2->bitblt.timer, da2->bitblt.timerspeed);
+    da2_log("bitblt_exec: %d\n", da2->bitblt.exec);
+    // da2_log("blt %x %x %x %x\n", da2->bitblt.destaddr, da2->bitblt.x, da2->bitblt.y);
+    switch (da2->bitblt.exec) {
+        case DA2_BLT_CIDLE:
+            // timer_disable(&da2->bitblt.timer);
+            break;
+        case DA2_BLT_CLOAD:
+            da2->bitblt.indata = 0;
+            da2_bitblt_load(da2);
+            break;
+        case DA2_BLT_CFILLRECT:
+            // da2_log("%x %x %x\n", da2->bitblt.destaddr, da2->bitblt.x, da2->bitblt.y);
+            if (da2->bitblt.x >= da2->bitblt.size_x - 1) {
+                DA2_DrawColorWithBitmask(da2->bitblt.destaddr, da2->bitblt.fcolor, da2->bitblt.maskr, da2);
+                if (da2->bitblt.y >= da2->bitblt.size_y - 1) {
+                    da2->bitblt.exec = DA2_BLT_CDONE;
+                }
+                da2->bitblt.x = 0;
+                da2->bitblt.y++;
+                da2->bitblt.destaddr += da2->bitblt.destpitch + 2;
+            } else if (da2->bitblt.x == 0) {
+                DA2_DrawColorWithBitmask(da2->bitblt.destaddr, da2->bitblt.fcolor, da2->bitblt.maskl, da2);
+                da2->bitblt.x++;
+            } else {
+                DA2_DrawColorWithBitmask(da2->bitblt.destaddr, da2->bitblt.fcolor, 0xffff, da2);
+                da2->bitblt.x++;
+            }
+            da2->bitblt.destaddr += 2;
+            break;
+        case DA2_BLT_CFILLTILE:
+            int32_t tileaddr = da2->bitblt.srcaddr + (da2->bitblt.y % da2->bitblt.tile_w) * 2;
+            if (da2->bitblt.x >= da2->bitblt.size_x - 1) {
+                DA2_CopyPlaneDataWithBitmask(tileaddr, da2->bitblt.destaddr, da2->bitblt.maskr, da2);
+                if (da2->bitblt.y >= da2->bitblt.size_y - 1) {
+                    da2->bitblt.exec = DA2_BLT_CDONE;
+                }
+                da2->bitblt.x = 0;
+                da2->bitblt.y++;
+                da2->bitblt.destaddr += da2->bitblt.destpitch + 2;
+            } else if (da2->bitblt.x == 0) {
+                DA2_CopyPlaneDataWithBitmask(tileaddr, da2->bitblt.destaddr, da2->bitblt.maskl, da2);
+                da2->bitblt.x++;
+            } else {
+                DA2_CopyPlaneDataWithBitmask(tileaddr, da2->bitblt.destaddr, 0xffff, da2);
+                da2->bitblt.x++;
+            }
+            da2->bitblt.destaddr += 2;
+            break;
+        case DA2_BLT_CCOPYF:
+            if (da2->bitblt.x >= da2->bitblt.size_x - 1) {
+                DA2_CopyPlaneDataWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, da2->bitblt.maskr, da2);
+                if (da2->bitblt.y >= da2->bitblt.size_y - 1) {
+                    da2->bitblt.exec = DA2_BLT_CDONE;
+                }
+                da2->bitblt.x = 0;
+                da2->bitblt.y++;
+                da2->bitblt.destaddr += da2->bitblt.destpitch + 2;
+                da2->bitblt.srcaddr += da2->bitblt.srcpitch + 2;
+            } else if (da2->bitblt.x == 0) {
+                DA2_CopyPlaneDataWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, da2->bitblt.maskl, da2);
+                da2->bitblt.x++;
+            } else {
+                DA2_CopyPlaneDataWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, 0xffff, da2);
+                da2->bitblt.x++;
+            }
+            da2->bitblt.destaddr += 2;
+            da2->bitblt.srcaddr += 2;
+            break;
+        case DA2_BLT_CCOPYR:
+            if (da2->bitblt.x >= da2->bitblt.size_x - 1) {
+                DA2_CopyPlaneDataWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, da2->bitblt.maskr, da2);
+                if (da2->bitblt.y >= da2->bitblt.size_y - 1) {
+                    da2->bitblt.exec = DA2_BLT_CDONE;
+                }
+                da2->bitblt.x = 0;
+                da2->bitblt.y++;
+                da2->bitblt.destaddr -= da2->bitblt.destpitch;
+                da2->bitblt.srcaddr -= da2->bitblt.srcpitch;
+                da2->bitblt.destaddr -= 2;
+                da2->bitblt.srcaddr -= 2;
+            } else if (da2->bitblt.x == 0) {
+                DA2_CopyPlaneDataWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, da2->bitblt.maskl, da2);
+                da2->bitblt.x++;
+            } else {
+                DA2_CopyPlaneDataWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, 0xffff, da2);
+                da2->bitblt.x++;
+            }
+            da2->bitblt.destaddr -= 2;
+            da2->bitblt.srcaddr -= 2;
+            break;
+        case DA2_BLT_CPUTCHAR: /* used in OS/2 J1.3 wo ROM patch. TODO: still not work */
+            // da2->bitblt.y += 2;
+            da2->bitblt.destaddr = da2->bitblt.reg[0x29] + da2->bitblt.x * 2 + da2->bitblt.y * 130 + 0 + 260;
+            // pclog("scr %x dest %x :", da2->bitblt.srcaddr, da2->bitblt.destaddr);
+            // da2->bitblt.srcaddr += 2;
+            if (da2->bitblt.reg[0x12] < 0x100)
+                da2->bitblt.srcaddr = DA2_FONTROM_BASESBCS + da2->bitblt.reg[0x12] * 64 + (da2->bitblt.x * 2) + (da2->bitblt.y * 2) - 2;
+            else
+                da2->bitblt.srcaddr = da2->bitblt.reg[0x12] * 72 + (da2->bitblt.x * 2) + (da2->bitblt.y * 3) - 2;
+            // print_bytetobin(da2->mmio.font[da2->bitblt.srcaddr + 2]);
+            // print_bytetobin(da2->mmio.font[da2->bitblt.srcaddr + 3]);
+            // pclog("\n");
+            if (da2->bitblt.x >= da2->bitblt.size_x - 1) {
+                // if (1) {
+                DA2_PutcharWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, da2->bitblt.maskr, da2);
+                if (da2->bitblt.y >= da2->bitblt.size_y - 3) {
+                    da2->bitblt.exec = DA2_BLT_CDONE;
+                }
+                da2->bitblt.x = 0;
+                da2->bitblt.y++;
+                da2->bitblt.destaddr += 130;
+                // da2->bitblt.destaddr += da2->bitblt.destpitch + 2;
+                // da2->bitblt.srcaddr += -1;
+            } else if (da2->bitblt.x == 0) {
+                DA2_PutcharWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, da2->bitblt.maskl, da2);
+                da2->bitblt.x++;
+                // da2->bitblt.x++;
+            } else {
+                DA2_PutcharWithBitmask(da2->bitblt.srcaddr, da2->bitblt.destaddr, 0xffff, da2);
+                da2->bitblt.x++;
+                // da2->bitblt.x++;
+            }
+            // da2->bitblt.destaddr = da2->bitblt.reg[0x29] + da2->bitblt.x + da2->bitblt.y * 130 + 2;
+            ////da2->bitblt.srcaddr += 2;
+            // da2->bitblt.srcaddr = da2->bitblt.reg[0x12] * 72 + (da2->bitblt.x * 2 ) + (da2->bitblt.y * 3) + 2;
+            break;
+        case DA2_BLT_CDONE:
+            /* initialize regs for debug dump */
+            for (int i = 0; i < DA2_BLT_REGSIZE; i++) {
+                if (da2->bitblt.reg[i] != DA2_DEBUG_BLT_NEVERUSED)
+                    da2->bitblt.reg[i] = DA2_DEBUG_BLT_USEDRESET;
+            }
+            if (da2->bitblt.indata)
+                da2->bitblt.exec = DA2_BLT_CLOAD;
+            else
+                da2->bitblt.exec = DA2_BLT_CIDLE;
+            break;
+    }
+}
+void
+da2_bitblt_dopayload(void *priv)
+{
+    da2_t *da2 = (da2_t *) priv;
+    timer_set_delay_u64(&da2->bitblt.timer, da2->bitblt.timerspeed);
+    // if (da2->bitblt.indata) /* for OS/2 J1.3 */
+    // {
+    //     if (da2->bitblt.exec == DA2_BLT_CIDLE) {
+    //         da2->bitblt.exec = DA2_BLT_CLOAD;
+    //         /* do all queues (ignore async executing) for OS/2 J1.3 commannd prompt that doesn't wait for idle */
+    //         da2_log("da2 Do bitblt\n");
+    //         while (da2->bitblt.exec != DA2_BLT_CIDLE) {
+    //             da2_bitblt_exec(da2);
+    //         }
+    //         da2_log("da2 End bitblt %x\n", da2->bitblt.exec);
+    //     }
+    // }
+    if (da2->bitblt.exec != DA2_BLT_CIDLE)
+        da2_bitblt_exec(da2);
+    else if (da2->bitblt.indata) /* for OS/2 J1.3 */
+    {
+        if (da2->bitblt.exec == DA2_BLT_CIDLE) {
+            da2->bitblt.exec = DA2_BLT_CLOAD;
+            da2_bitblt_exec(da2);
+        }
+    }
+}
+
+void
+da2_out(uint16_t addr, uint16_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    int    oldval;
+    /*
+    3E0 3E1     Sequencer Registers (undoc)
+    3E2 3E3     Font Registers (undoc)
+    3E4 3E5     CRT Control Registers (undoc)
+    3E8 3E9     Attribute Controller Registers (undoc)
+    3EA 3EB 3EC Graphics Contoller Registers
+    */
+    switch (addr) {
+        case 0x3c6: /* PEL Mask */
+            da2->dac_mask = val;
+            break;
+        case 0x3C7: /* Read Address */
+            da2->dac_read = val;
+            da2->dac_pos  = 0;
+            break;
+        case 0x3C8: /* Write Address */
+            da2->dac_write = val;
+            da2->dac_read  = val - 1;
+            da2->dac_pos   = 0;
+            break;
+        case 0x3C9: /* Data */
+            // da2_log("DA2 Out addr %03X idx %d:%d val %02X %04X:%04X esdi %04X:%04X\n", addr, da2->dac_write, da2->dac_pos, val, cs >> 4, cpu_state.pc, ES, DI);
+            da2->dac_status = 0;
+            da2->fullchange = changeframecount;
+            switch (da2->dac_pos) {
+                case 0:
+                    da2->dac_r = val;
+                    da2->dac_pos++;
+                    break;
+                case 1:
+                    da2->dac_g = val;
+                    da2->dac_pos++;
+                    break;
+                case 2:
+                    da2->vgapal[da2->dac_write].r = da2->dac_r;
+                    da2->vgapal[da2->dac_write].g = da2->dac_g;
+                    da2->vgapal[da2->dac_write].b = val;
+                    // if (da2->ramdac_type == RAMDAC_8BIT)
+                    //     da2->pallook[da2->dac_write] = makecol32(da2->vgapal[da2->dac_write].r, da2->vgapal[da2->dac_write].g, da2->vgapal[da2->dac_write].b);
+                    // else
+                    da2->pallook[da2->dac_write] = makecol32((da2->vgapal[da2->dac_write].r & 0x3f) * 4, (da2->vgapal[da2->dac_write].g & 0x3f) * 4, (da2->vgapal[da2->dac_write].b & 0x3f) * 4);
+                    da2->dac_pos                 = 0;
+                    da2->dac_write               = (da2->dac_write + 1) & 255;
+                    break;
+            }
+            break;
+        case LS_INDEX:
+            da2->ioctladdr = val;
+            break;
+        case LS_DATA:
+            // da2_log("DA2 Out addr %03X idx %02X val %02X %04X:%04X\n", addr, da2->ioctladdr, val, cs >> 4, cpu_state.pc);
+            if (da2->ioctladdr > 0xf)
+                return;
+            if (da2->ioctl[da2->ioctladdr & 15] != val)
+                da2_log("ioctl changed %x: %x -> %x  %04X:%04X\n", da2->ioctladdr & 15, da2->ioctl[da2->ioctladdr & 15], val, cs >> 4, cpu_state.pc);
+            oldval                     = da2->ioctl[da2->ioctladdr];
+            da2->ioctl[da2->ioctladdr] = val;
+            if (oldval != val) {
+                if (da2->ioctladdr == LS_RESET && val & 0x01) /* Reset register */
+                    da2_reset_ioctl(da2);
+                else if (da2->ioctladdr == LS_MODE && ((oldval ^ val) & 0x03)) /* Mode register */
+                {
+                    da2->fullchange = changeframecount;
+                    da2_recalctimings(da2);
+                    da2_updatevidselector(da2);
+                } else if (da2->ioctladdr == LS_MMIO && (!(val & 0x01))) /* MMIO register */
+                {
+                    // da2->bitblt.indata = 1;
+                }
+            }
+            break;
+        case LF_INDEX:
+            da2->fctladdr = val;
+            break;
+        case LF_DATA:
+            // da2_log("DA2 Out addr %03X idx %02X val %02X %04X:%04X\n", addr, da2->fctladdr, val, cs >> 4, cpu_state.pc);
+            if (da2->fctladdr > 0x1f)
+                return;
+            if (da2->fctl[da2->fctladdr & 0x1f] != val)
+                da2_log("fctl changed %x: %x -> %x  %04X:%04X\n", da2->fctladdr & 0x1f, da2->fctl[da2->fctladdr & 0x1f], val, cs >> 4, cpu_state.pc);
+            oldval                   = da2->fctl[da2->fctladdr];
+            da2->fctl[da2->fctladdr] = val;
+            if (da2->fctladdr == 0 && oldval != val) {
+                da2->fullchange = changeframecount;
+                da2_recalctimings(da2);
+            }
+            break;
+        case LC_INDEX:
+            da2->crtcaddr = val;
+            break;
+        case LC_DATA:
+            if (da2->crtcaddr > 0x1f)
+                return;
+            // if (!(da2->crtcaddr == LC_CURSOR_LOC_HIGH || da2->crtcaddr == LC_CURSOR_LOC_LOWJ))
+            //     da2_log("DA2 Out addr %03X idx %02X val %02X %04X:%04X\n", addr, da2->crtcaddr, val, cs >> 4, cpu_state.pc);
+            if (!(da2->crtc[da2->crtcaddr] ^ val))
+                return;
+            switch (da2->crtcaddr) {
+                case LC_CRTC_OVERFLOW:
+                    // return;
+                    break;
+                case LC_MAXIMUM_SCAN_LINE:
+                    if (!(da2->ioctl[LS_MODE] & 0x01))
+                        val = 0;
+                    break;
+                case LC_START_ADDRESS_HIGH:
+                    // if (da2->crtc[0x1c] & 0x40) return;
+                    break;
+                case LC_VERTICAL_TOTALJ:      /* Vertical Total */
+                case LC_VERTICAL_SYNC_START:  /* Vertical Retrace Start Register */
+                case LC_V_DISPLAY_ENABLE_END: /* Vertical Display End Register */
+                case LC_START_VERTICAL_BLANK: /* Start Vertical Blank Register */
+#ifdef ENABLE_DA2_DEBUGFULLSCREEN
+                    val = 0x400; /* for debugging bitblt in Win 3.x */
+#endif
+                    break;
+                case LC_VIEWPORT_SELECT: /* ViewPort Select? */
+                    // return;
+                    break;
+                case LC_VIEWPORT_NUMBER: /* Compatibility? */
+                    break;
+            }
+            da2->crtc[da2->crtcaddr] = val;
+            switch (da2->crtcaddr) {
+                case LC_H_DISPLAY_ENABLE_END:
+                case LC_VERTICAL_TOTALJ:
+                case LC_MAXIMUM_SCAN_LINE:
+                case LC_START_ADDRESS_HIGH:
+                case LC_START_ADDRESS_LOW:
+                case LC_VERTICAL_SYNC_START:
+                case LC_V_DISPLAY_ENABLE_END:
+                case LC_START_VERTICAL_BLANK:
+                case LC_END_VERTICAL_BLANK:
+                case LC_VIEWPORT_PRIORITY:
+                    da2->fullchange = changeframecount;
+                    da2_recalctimings(da2);
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case LV_PORT:
+            // da2_log("DA2 Out addr %03X val %02X ff %d %04X:%04X\n", addr, val, da2->attrff,cs >> 4, cpu_state.pc);
+            if (!da2->attrff) {
+                // da2->attraddr = val & 31;
+                da2->attraddr = val & 0x3f;
+                if ((val & 0x20) != (da2->attr_palette_enable & 0x20)) {
+                    da2->fullchange          = 3;
+                    da2->attr_palette_enable = val & 0x20;
+                    da2_recalctimings(da2);
+                }
+                // da2_log("set attraddr: %X\n", da2->attraddr);
+            } else {
+                if ((da2->attraddr == LV_PANNING) && (da2->attrc[LV_PANNING] != val))
+                    da2->fullchange = changeframecount;
+                if (da2->attrc[da2->attraddr & 0x3f] != val)
+                    da2_log("attr changed %x: %x -> %x\n", da2->attraddr & 0x3f, da2->attrc[da2->attraddr & 0x3f], val);
+                da2->attrc[da2->attraddr & 0x3f] = val;
+                // da2_log("set attrc %x: %x\n", da2->attraddr & 31, val);
+                if (da2->attraddr < 16)
+                    da2->fullchange = changeframecount;
+                if (da2->attraddr == LV_MODE_CONTROL || da2->attraddr < 0x10) {
+                    for (int c = 0; c < 16; c++) {
+                        // if (da2->attrc[LV_MODE_CONTROL] & 0x80) da2->egapal[c] = (da2->attrc[c] & 0xf) | ((da2->attrc[0x14] & 0xf) << 4);
+                        // else                             da2->egapal[c] = (da2->attrc[c] & 0x3f) | ((da2->attrc[0x14] & 0xc) << 4);
+                        if (da2->attrc[LV_MODE_CONTROL] & 0x80)
+                            da2->egapal[c] = da2->attrc[c] & 0xf;
+                        else
+                            da2->egapal[c] = da2->attrc[c] & 0x3f;
+                    }
+                }
+                switch (da2->attraddr) {
+                    case LV_COLOR_PLANE_ENAB:
+                        if ((val & 0xff) != da2->plane_mask)
+                            da2->fullchange = changeframecount;
+                        da2->plane_mask = val & 0xff;
+                        break;
+                    case LV_CURSOR_CONTROL:
+                        switch (val & 0x18) {
+                            case 0x08: /* fast blink */
+                                da2->blinkconf = 0x10;
+                                break;
+                            case 0x18: /* slow blink */
+                                da2->blinkconf = 0x20;
+                                break;
+                            default: /* no blink */
+                                da2->blinkconf = 0xff;
+                                break;
+                        }
+                        break;
+                    case LV_MODE_CONTROL:
+                    case LV_ATTRIBUTE_CNTL:
+                    case LV_COMPATIBILITY:
+                        da2_recalctimings(da2);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            da2->attrff ^= 1;
+            break;
+        case 0x3E9:
+            /* VZ Editor's CURSOR.COM writes data via this port */
+            da2->attrc[da2->attraddr & 0x3f] = val;
+            break;
+        case LG_INDEX:
+            da2->gdcaddr = val;
+            break;
+        case LG_DATA:
+            // if(da2->gdcaddr != 8 && da2->gdcaddr != 9) da2_log("DA2 Out addr %03X idx %02X val %02X\n", addr, da2->gdcaddr, val);
+            // if(da2->gdcaddr != 8 && da2->gdcaddr != 9) da2_log("DA2 GCOut idx %X val %02X %04X:%04X esdi %04X:%04X\n", da2->gdcaddr, val, cs >> 4, cpu_state.pc, ES, DI);
+            switch (da2->gdcaddr & 0x1f) {
+                case LG_READ_MAP_SELECT:
+                    da2->readplane = val & 0x7;
+                    break;
+                case LG_MODE:
+                    da2->writemode = val & 3;
+                    break;
+                case LG_MAP_MASKJ:
+                    da2->writemask = val & 0xff;
+                    break;
+                case LG_COMMAND:
+                    break;
+                case LG_SET_RESET_2:
+                    da2_log("!!!DA2 GC Out addr %03X idx 10 val %02X\n", addr, val);
+                    return;
+            }
+            da2->gdcreg[da2->gdcaddr & 0x0f] = val & 0xff;
+            break;
+        // case 0x3ed: /* used by Windows 3.1 display driver */
+        //     da2->gdcreg[5] = val & 0xff;
+        //     break;
+        default:
+            da2_log("DA2? Out addr %03X val %02X\n", addr, val);
+            break;
+    }
+}
+
+uint16_t
+da2_in(uint16_t addr, void *p)
+{
+    da2_t   *da2  = (da2_t *) p;
+    uint16_t temp = 0xff;
+
+    switch (addr) {
+        case 0x3c3:
+            temp = 0;
+            break;
+        case 0x3c6:
+            temp = da2->dac_mask;
+            break;
+        case 0x3c7:
+            temp = da2->dac_status;
+            break;
+        case 0x3c8:
+            temp = da2->dac_write;
+            break;
+        case 0x3c9:
+            da2->dac_status = 3;
+            switch (da2->dac_pos) {
+                case 0:
+                    da2->dac_pos++;
+                    temp = da2->vgapal[da2->dac_read].r & 0x3f;
+                    break;
+                case 1:
+                    da2->dac_pos++;
+                    temp = da2->vgapal[da2->dac_read].g & 0x3f;
+                    break;
+                case 2:
+                    da2->dac_pos  = 0;
+                    da2->dac_read = (da2->dac_read + 1) & 255;
+                    temp          = da2->vgapal[(da2->dac_read - 1) & 255].b & 0x3f;
+                    break;
+            }
+            break;
+        case LS_INDEX:
+            temp = da2->ioctladdr;
+            break;
+        case LS_DATA:
+            // da2->ioctl[3] = 0x80; /* 3E1h:3 bit 7 color monitor, bit 3 busy(GC) bit 0 busy (IO?) */
+            if (da2->ioctladdr > 0xf)
+                return DA2_INVALIDACCESS8;
+            temp = da2->ioctl[da2->ioctladdr];
+            if (da2->ioctladdr == LS_STATUS) {             /* Status register */
+                if (da2->attrc[LV_COMPATIBILITY] & 0x08) { /* for detecting monitor type and cable wiring */
+                    if (da2->monitorid == DA2_DCONFIG_MONTYPE_MONO) {
+                        /* grayscale monitor */
+                        if ((da2->vgapal[0].r >= 10) || (da2->vgapal[0].g >= 40) || (da2->vgapal[0].b >= 10))
+                            temp &= 0x7F; /* Inactive when the RGB output voltage is high (or the cable is not connected to a color monitor). */
+                        else
+                            temp |= 0x80; /* Active when the RGB output voltage is low and the cable is connected to a color monitor.
+                                             If the cable or the monitor is wrong, it becomes inactive. */
+                    } else {
+                        /* color monitor */
+                        if ((da2->vgapal[0].r + da2->vgapal[0].g + da2->vgapal[0].b) >= 80)
+                            temp &= 0x7F;
+                        else
+                            temp |= 0x80;
+                    }
+                } else {
+                    temp |= 0x80;
+                }
+                temp &= 0xf6;           /* clear busy bit */
+                // if (da2->bitblt.indata) /* for OS/2 J1.3 */
+                //     da2_bitblt_dopayload(da2);
+                if (da2->bitblt.exec != DA2_BLT_CIDLE) {
+                    // da2_log("exec:%x\n", da2->bitblt.exec);
+                    temp |= 0x01; /* wait (bit 3 + bit 0) ? need verify */
+                    // if (!da2->bitblt.timer.enabled)
+                    //{
+                    //     da2_log("bitblt timer restarted!! %04X:%04X\n", cs >> 4, cpu_state.pc);
+                    //     timer_advance_u64(&da2->bitblt.timer, da2->bitblt.timerspeed);
+                    // }
+                }
+                if (da2->bitblt.indata)
+                    temp |= 0x08;
+                da2_log("DA2 In %04X(%02X) %04X %04X:%04X\n", addr, da2->ioctladdr,temp, cs >> 4, cpu_state.pc);
+            }
+            // da2_log("DA2 In %04X(%02X) %04X %04X:%04X\n", addr, da2->ioctladdr,temp, cs >> 4, cpu_state.pc);
+            break;
+        case LF_INDEX:
+            temp = da2->fctladdr;
+            break;
+        case LF_DATA:
+            if (da2->fctladdr > 0x1f)
+                return DA2_INVALIDACCESS8;
+            temp = da2->fctl[da2->fctladdr];
+            break;
+        case LC_INDEX:
+            temp = da2->crtcaddr;
+            break;
+        case LC_DATA:
+            if (da2->crtcaddr > 0x1f)
+                return DA2_INVALIDACCESS8;
+            temp = da2->crtc[da2->crtcaddr];
+            break;
+        case LV_PORT:
+            temp = da2->attraddr | da2->attr_palette_enable;
+            break;
+        case 0x3E9:
+            if (da2->attraddr == LV_RAS_STATUS_VIDEO) /* this maybe equivalent to 3ba / 3da ISR1 */
+            {
+                if (da2->cgastat & 0x01)
+                    da2->cgastat &= ~0x30;
+                else
+                    da2->cgastat ^= 0x30; /* toggle */
+                temp = da2->cgastat;
+            } else
+                temp = da2->attrc[da2->attraddr];
+            // da2_log("DA2 In %04X(%02X) %04X %04X:%04X\n", addr, da2->attraddr, temp, cs >> 4, cpu_state.pc);
+            da2->attrff = 0; /* reset flipflop (VGA does not reset flipflop) */
+            break;
+        case LG_INDEX:
+            temp = da2->gdcaddr;
+            break;
+        case LG_DATA:
+            temp = da2->gdcreg[da2->gdcaddr & 0x1f];
+            // da2_log("DA2 In %04X(%02X) %04X %04X:%04X\n", addr, da2->gdcaddr, temp, cs >> 4, cpu_state.pc);
+            break;
+    }
+    // da2_log("DA2 In %04X %04X %04X:%04X\n", addr, temp, cs >> 4, cpu_state.pc);
+    return temp;
+}
+/*
+ * Write I/O
+ * out b(idx), out b(data), out b(data)
+ * out b(idx), out w(data)
+ * out b(idx), out w(data), out b(data)
+ *             out w(idx)
+ * Read I/O
+ * out b(idx), in b(data)
+ * out b(idx), in b, in b(data)
+ * out b(idx), in w(data)
+ */
+void
+da2_outb(uint16_t addr, uint8_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    // da2_log("DA2 Outb addr %03X val %02X %04X:%04X es:di=%x:%x ds:si=%x:%x\n", addr, val, cs >> 4, cpu_state.pc, ES, DI, DS, SI);
+    da2->inflipflop = 0;
+    switch (addr) {
+        case LS_DATA:
+        case LF_DATA:
+        case LC_DATA:
+        case LG_DATA:
+            if (da2->outflipflop) {
+                /* out b(idx), out b(data), out b(data) */
+                da2->iolatch |= (uint16_t) val << 8;
+                da2->outflipflop = 0;
+            } else { //
+                da2->iolatch     = val;
+                da2->outflipflop = 1;
+            }
+            break;
+        case LS_INDEX:
+        case LF_INDEX:
+        case LC_INDEX:
+        case LG_INDEX:
+        default:
+            da2->iolatch     = val;
+            da2->outflipflop = 0;
+            break;
+    }
+    da2_out(addr, da2->iolatch, da2);
+}
+void
+da2_outw(uint16_t addr, uint16_t val, void *p)
+{
+    da2_log("DA2 Outw addr %03X val %04X %04X:%04X\n", addr, val, cs >> 4, cpu_state.pc);
+    da2_t *da2      = (da2_t *) p;
+    da2->inflipflop = 0;
+    switch (addr) {
+        case LS_INDEX:
+        case LF_INDEX:
+        case LC_INDEX:
+        case LG_INDEX:
+            da2_out(addr, val & 0xff, da2);
+            da2->iolatch = val >> 8;
+            da2_out(addr + 1, da2->iolatch, da2);
+            da2->outflipflop = 1;
+            break;
+        case LV_PORT:
+            da2->attrff = 0;
+            da2_out(addr, val & 0xff, da2);
+            da2_out(addr, val >> 8, da2);
+            da2->outflipflop = 0;
+            break;
+        case 0x3EC:
+            // da2_log("DA2 Outw addr %03X val %04X %04X:%04X\n", addr, val, cs >> 4, cpu_state.pc);
+            da2_out(LG_DATA, val >> 8, da2);
+            break;
+        case 0x3ED:
+            da2->gdcaddr = LG_MODE;
+            da2_out(LG_DATA, val, da2);
+            break;
+        case LS_DATA:
+        case LF_DATA:
+        case LC_DATA:
+        case LG_DATA:
+        default:
+            da2_out(addr, val, da2);
+            da2->outflipflop = 0;
+            break;
+        case AC_REG:
+            /* no register is revealed */
+            da2_log("DA2 Outw addr %03X val %04X %04X:%04X\n", addr, val, cs >> 4, cpu_state.pc);
+            da2->reg3ee[val & 0x0f] = val >> 8;
+            break;
+    }
+}
+uint8_t
+da2_inb(uint16_t addr, void *p)
+{
+    uint8_t temp;
+    da2_t  *da2      = (da2_t *) p;
+    da2->outflipflop = 0;
+    switch (addr) {
+        case LC_DATA:
+            if (da2->inflipflop) {
+                /* out b(idx), in b(low data), in b(high data) */
+                temp            = da2->iolatch >> 8;
+                da2->inflipflop = 0;
+            } else { //
+                da2->iolatch    = da2_in(addr, da2);
+                temp            = da2->iolatch & 0xff;
+                da2->inflipflop = 1;
+            }
+            break;
+        case LS_INDEX:
+        case LF_INDEX:
+        case LC_INDEX:
+        case LG_INDEX:
+        case LS_DATA:
+        case LF_DATA:
+        case LG_DATA:
+        default:
+            temp            = da2_in(addr, da2) & 0xff;
+            da2->inflipflop = 0;
+            break;
+    }
+    // da2_log("DA2 Inb %04X %02X %04X:%04X\n", addr, temp, cs >> 4, cpu_state.pc);
+    return temp;
+}
+uint16_t
+da2_inw(uint16_t addr, void *p)
+{
+    // uint16_t temp;
+    da2_t *da2       = (da2_t *) p;
+    da2->inflipflop  = 0;
+    da2->outflipflop = 0;
+    return da2_in(addr, da2);
+}
+/* IO 03DAh : Input Status Register 2 for DOSSHELL used by DOS J4.0 */
+uint8_t
+da2_in_ISR(uint16_t addr, void *p)
+{
+    da2_t  *da2  = (da2_t *) p;
+    uint8_t temp = 0;
+    if (addr == 0x3da) {
+        if (da2->cgastat & 0x01)
+            da2->cgastat &= ~0x30;
+        else
+            da2->cgastat ^= 0x30;
+        temp = da2->cgastat;
+    }
+    // da2_log("DA2D In %04X %04X %04X:%04X\n", addr, temp, cs >> 4, cpu_state.pc);
+    return temp;
+}
+
+void
+da2_out_ISR(uint16_t addr, uint8_t val, void *p)
+{
+    // da2_t* da2 = (da2_t*)p;
+    da2_log("DA2D Out %04X %04X %04X:%04X\n", addr, val, cs >> 4, cpu_state.pc);
+}
+
+/*
+The IBM 5550 character mode addresses video memory between E0000h and E0FFFh.
+ [Character drawing]
+ SBCS:
+   1 2   ...       13
+ 1  |   H.Grid
+    |----------------
+ 2  |    Space
+ 3 V|
+   .|
+   G|  Font Pattern
+   r| (12x24 pixels)
+   i|
+   d|
+26  |________________
+27       Space
+     ----------------
+28     Underscore    ]
+     ---------------- >Cursor Position
+29                   ]
+
+ DBCS:
+   1 2   ...    13 1 2  ...  12 13
+ 1  |   H.Grid    |   H.Grid   |
+   -|--------------------------|-
+ 2  |    Space    |    Space   |
+   -|--------------------------|-
+ 3 V|             |            |S
+   .|             |            |p
+   G|        Font Pattern      |a
+   r|       (24x24 pixels)     |c
+   i|             |            |e
+   d|             |            |
+26  |_____________|____________|
+27  |    Space    |    Space
+   ------------------------------
+28  |  Underscore |  Underscore  ]
+   ------------------------------ >Cursor Position
+29  |             |              ]
+
+ [Attributes]
+ Video mode 08h:
+  7      6      5      4      3      2      1      0
+  Blink |Under |HGrid |VGrid |Bright|Revers|FntSet|DBCS/SBCS|
+
+ Video mode 0Eh:
+  -Blue |-Green|HGrid |VGrid |-Red  |Revers|FntSet|DBCS/SBCS|
+
+ Bit 1 switches the font bank to the Extended SBCS. DOS K3.x loads APL characters from $SYSEX24.FNT into it.
+ DOS Bunsho Program transfers 1/2 and 1/4 fonts fron the font ROM to the Extended SBCS.
+ This bit is not used for DBCS, but some apps set it as that column is right half of DBCS.
+
+[Font ROM Map (DA2, Japanese)]
+The Font ROM can be accessed via 128 KB memory window located at A0000-BFFFFh.
+
+ Bank 0
+ 4800-  *
+ Bank 1, 2, 3
+   *  -  *
+ Bank 4
+   *  -0DB6Fh ( 4800-8DB6Fh) : JIS X 0208 DBCS (24 x 24) (IBMJ code: 100-1F7Dh)
+ 10000-16D1Fh (90000-96D1Fh) : IBM Extended Characters (IBMJ code: 2ADC-2C5Fh)
+ 18000-1BFCFh (98000-9BFCFh) : JIS X 0201 SBCS (13 x 30)
+ 1C000-1FFFFh (9C000-9FFFFh) : Codepage 437 characters (13 x 30)
+ Bank 5
+ 00000-0C68Fh (A0000-AC68Fh) : Gaiji used by DOS Bunsho
+ 10000-13FFFh (B0000-B3FFFh) : Extended SBCS (13 x 30)
+ 14000-1477Fh (B4000-B477Fh) : Half-width box drawing characters used by DOS Bunsho
+ 16000-17FFFh (B6000-B7FFFh) : Codepage 850 characters (13 x 30)
+ 18000-1A3FFh (B8000-BA3FFh) : CAD control icons and box drawing characters (32 x 32)
+
+ Some models have the signature 80h, 01h placed at Bank 0:1AFFEh. It disables Bitblt text drawing in OS/2 J1.3.
+
+[Font ROM Map (DA3, Traditional Chinese)]
+ Bank 0 - 11 : Valid Font ROM data
+ Bank 12 : Alias of bank 11 (At least, DOS T5.0 uses this on purpose to obtain the SBCS font.)
+ Bank 13 : Filled by 0xFFh
+
+[Gaiji RAM Map (DA2)]
+ Bank 0 00000-1FFFFh placed between A0000h-BFFFFh
+ 00000-1F7FFh(A0000-BF7FFh): Gaiji Non-resident (Kuten 103-114 ku,IBM: 2674-2ADBh) 1008 chs 128 bytes
+ 1F800-1FFFFh(BF800-BFFFFh): Gaiji Resident (SJIS: F040-F04Fh, IBM: 2384-2393h) 16 chs
+
+ Bank 1 20000-3FFFFh placed between A0000h-BFFFFh
+ 20000-33FFFh(A0000-B3FFFh): Gaiji Resident (SJIS: F050-F39Ch, IBM: 2394-2613h) 640 chs
+ 34000-37FFFh(B4000-B7FFFh): Basic SBCS(00-FFh, ATTR bit 1 = off)
+ 38000-3AFFFh(B8000-BAFFFh): Gaiji Resident (SJIS: F39D-F3FCh, IBM: 2614-2673h) 96 chs
+ 3C000-3FFFFh(BC000-BFFFFh): Extended SBCS(00-FFh, ATTR bit 1 = on)
+
+[IBMJ code to Gaiji address conv tbl from DOS K3.3]
+ A     B     C
+ 2ADC, 2C5F, +5524  --> 8000
+ 2614, 2673, +90EC  --> B700
+ 2384, 2613, +906C  --> B3F0
+ 0682, 1F7D, +0000
+
+ 8000 - 8183h 184h(388 characters) IBM Extended Characters
+ B3F0 - B75Fh 370h(880 characters) User-defined Characters
+*/
+
+/* Get character line pattern from jfont rom or gaiji volatile memory */
+uint32_t
+getfont_ps55dbcs(int32_t code, int32_t line, void *p)
+{
+    da2_t   *da2   = (da2_t *) p;
+    uint32_t font  = 0;
+    int32_t  fline = line - 2; /* Start line of drawing character (line >= 1 AND line < 24 + 1 ) */
+    if (code >= 0x8000 && code <= 0x8183)
+        code -= 0x6000; /* shift for IBM extended characters (I don't know how the real card works.) */
+    if (code < DA2_FONTROM_SIZE / 72 && fline >= 0 && fline < 24) {
+        font = da2->mmio.font[code * 72 + fline * 3];             /* 1111 1111 */
+        font <<= 8;                                               /* 1111 1111 0000 0000 */
+        font |= da2->mmio.font[code * 72 + fline * 3 + 1] & 0xf0; /* 1111 1111 2222 0000 */
+        font >>= 1;                                               /* 0111 1111 1222 2000 */
+        font <<= 4;                                               /* 0111 1111 1222 2000 0000 */
+        font |= da2->mmio.font[code * 72 + fline * 3 + 1] & 0x0f; /* 0111 1111 1222 2000 2222 */
+        font <<= 8;                                               /* 0111 1111 1222 2000 2222 0000 0000 */
+        font |= da2->mmio.font[code * 72 + fline * 3 + 2];        /* 0111 1111 1222 2000 2222 3333 3333 */
+        font <<= 4;                                               /* 0111 1111 1222 2000 2222 3333 3333 0000 */
+        /* font >>= 1;//put blank at column 1 (and 26) */
+    } else if (code >= 0xb000 && code <= 0xb75f) {
+        /* convert code->address in gaiji memory */
+        code -= 0xb000;
+        code *= 0x80;
+        // code += 0xf800;
+        font = da2->mmio.ram[code + line * 4];
+        font <<= 8;
+        font |= da2->mmio.ram[code + line * 4 + 1];
+        font <<= 8;
+        font |= da2->mmio.ram[code + line * 4 + 2];
+        font <<= 8;
+        font |= da2->mmio.ram[code + line * 4 + 3];
+    } else if (code > DA2_FONTROM_SIZE)
+        font = 0xffffffff;
+    else
+        font = 0;
+    return font;
+}
+
+/* Reverse the bit order of attribute code IRGB to BGRI(used in Mode 3 and Cursor Color) */
+uint8_t
+IRGBtoBGRI(uint8_t attr)
+{
+    attr = ((attr & 0x01) << 7) | ((attr & 0x02) << 5) | ((attr & 0x04) << 3) | ((attr & 0x08) << 1);
+    return attr >>= 4;
+}
+/* Get the foreground color from the attribute byte */
+uint8_t
+getPS55ForeColor(uint8_t attr, da2_t *da2)
+{
+    uint8_t foreground = ~attr & 0x08; /* 0000 1000 */
+    foreground <<= 2;                  /* 0010 0000 */
+    foreground |= ~attr & 0xc0;        /*  1110 0000 */
+    foreground >>= 4;                  /* 0000 1110 */
+    if (da2->attrc[LV_PAS_STATUS_CNTRL] & 0x40)
+        foreground |= 0x01; /* bright color palette */
+    return foreground;
+}
+
+void
+da2_render_blank(da2_t *da2)
+{
+    int x, xx;
+
+    if (da2->firstline_draw == 2000)
+        da2->firstline_draw = da2->displine;
+    da2->lastline_draw = da2->displine;
+
+    for (x = 0; x < da2->hdisp; x++) {
+        for (xx = 0; xx < 13; xx++)
+            ((uint32_t *) buffer32->line[da2->displine])[(x * 13) + xx + 32] = 0;
+    }
+}
+/* Display Adapter Mode 8, E Drawing */
+static void
+da2_render_text(da2_t *da2)
+{
+    if (da2->firstline_draw == 2000)
+        da2->firstline_draw = da2->displine;
+    da2->lastline_draw = da2->displine;
+
+    if (da2->fullchange) {
+        int       offset = (8 - da2->scrollcache) + 24;
+        uint32_t *p      = &((uint32_t *) buffer32->line[da2->displine])[offset];
+        int       x;
+        int       drawcursor;
+        uint8_t   chr, attr;
+        int       fg, bg;
+        uint32_t  chr_dbcs;
+        int       chr_wide = 0;
+        // da2_log("\nda2ma: %x, da2sc: %x\n", da2->ma, da2->sc);
+        for (x = 0; x < da2->hdisp; x += 13) {
+            chr  = da2->cram[(da2->ma) & da2->vram_display_mask];
+            attr = da2->cram[((da2->ma) + 1) & da2->vram_display_mask];
+            // if(chr!=0x20) da2_log("chr: %x, attr: %x    ", chr, attr);
+            if (da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) /* IO 3E8h, Index 1Dh */
+            {                                           /* --Parse attribute byte in color mode-- */
+                bg = 0;                                 /* bg color is always black (the only way to change background color is programming PAL) */
+                fg = getPS55ForeColor(attr, da2);
+                if (attr & 0x04) { /* reverse 0000 0100 */
+                    bg = fg;
+                    fg = 0;
+                }
+            } else { /* --Parse attribute byte in monochrome mode-- */
+                if (attr & 0x08)
+                    fg = 3; /* Highlight 0000 1000 */
+                else
+                    fg = 2;
+                bg = 0;              /* Background is always color #0 (default is black) */
+                if (!(~attr & 0xCC)) /* Invisible 11xx 11xx -> 00xx 00xx  */
+                {
+                    fg = bg;
+                    attr &= 0x33; /* disable blinkking, underscore, highlight and reverse */
+                }
+                if (attr & 0x04) { /* reverse 0000 0100 */
+                    bg = fg;
+                    fg = 0;
+                }
+                /* Blinking 1000 0000 */
+                fg = ((da2->blink & 0x20) || (!(attr & 0x80))) ? fg : bg;
+                // if(chr!=0x20) da2_log("chr: %x, %x, %x, %x, %x    ", chr, attr, fg, da2->egapal[fg], da2->pallook[da2->egapal[fg]]);
+            }
+            /* Draw character */
+            for (uint32_t n = 0; n < 13; n++)
+                p[n] = da2->pallook[da2->egapal[bg]]; /* draw blank */
+            /*  SBCS or DBCS left half */
+            if (chr_wide == 0) {
+                if (attr & 0x01)
+                    chr_wide = 1;
+                // chr_wide = 0;
+                /* Stay drawing If the char code is DBCS and not at last column. */
+                if (chr_wide) {
+                    /* Get high DBCS code from the next video address */
+                    chr_dbcs = da2->cram[((da2->ma) + 2) & da2->vram_display_mask];
+                    chr_dbcs <<= 8;
+                    chr_dbcs |= chr;
+                    /* Get the font pattern */
+                    uint32_t font = getfont_ps55dbcs(chr_dbcs, da2->sc, da2);
+                    /* Draw 13 dots */
+                    for (uint32_t n = 0; n < 13; n++) {
+                        p[n] = da2->pallook[da2->egapal[(font & 0x80000000) ? fg : bg]];
+                        font <<= 1;
+                    }
+                } else {
+                    /* the char code is SBCS (ANK) */
+                    uint32_t fontbase;
+                    if (attr & 0x02) /* second map of SBCS font */
+                        fontbase = DA2_GAIJIRAM_SBEX;
+                    else
+                        fontbase = DA2_GAIJIRAM_SBCS;
+                    uint16_t font = da2->mmio.ram[fontbase + chr * 0x40 + da2->sc * 2]; /* w13xh29 font */
+                    font <<= 8;
+                    font |= da2->mmio.ram[fontbase + chr * 0x40 + da2->sc * 2 + 1]; /* w13xh29 font */
+                    // if(chr!=0x20) da2_log("ma: %x, sc: %x, chr: %x, font: %x    ", da2->ma, da2->sc, chr, font);
+                    /* Draw 13 dots */
+                    for (uint32_t n = 0; n < 13; n++) {
+                        p[n] = da2->pallook[da2->egapal[(font & 0x8000) ? fg : bg]];
+                        font <<= 1;
+                    }
+                }
+            }
+            /* right half of DBCS */
+            else {
+                uint32_t font = getfont_ps55dbcs(chr_dbcs, da2->sc, da2);
+                /* Draw 13 dots */
+                for (uint32_t n = 0; n < 13; n++) {
+                    p[n] = da2->pallook[da2->egapal[(font & 0x8000) ? fg : bg]];
+                    font <<= 1;
+                }
+                chr_wide = 0;
+            }
+            /* Line 28 (Underscore) Note: Draw this first to display blink + vertical + underline correctly. */
+            if (da2->sc == 27 && attr & 0x40 && ~da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) { /* Underscore only in monochrome mode */
+                for (uint32_t n = 0; n < 13; n++)
+                    p[n] = da2->pallook[da2->egapal[fg]]; /* under line (white) */
+            }
+            /* Column 1 (Vertical Line) */
+            if (attr & 0x10) {
+                p[0] = da2->pallook[da2->egapal[(da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) ? IRGBtoBGRI(da2->attrc[LV_GRID_COLOR_0]) : 2]]; /* vertical line (white) */
+            }
+            if (da2->sc == 0 && attr & 0x20 && ~da2->attrc[LV_PAS_STATUS_CNTRL]) { /* HGrid */
+                for (uint32_t n = 0; n < 13; n++)
+                    p[n] = da2->pallook[da2->egapal[(da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) ? IRGBtoBGRI(da2->attrc[LV_GRID_COLOR_0]) : 2]]; /* horizontal line (white) */
+            }
+            /* Drawing text cursor */
+            drawcursor = ((da2->ma == da2->ca) && da2->con && da2->cursoron);
+            if (drawcursor && da2->sc >= da2->crtc[LC_CURSOR_ROW_START] && da2->sc <= da2->crtc[LC_CURSOR_ROW_END]) {
+                int cursorwidth = (da2->crtc[LC_COMPATIBILITY] & 0x20 ? 26 : 13);
+                int cursorcolor = (da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) ? IRGBtoBGRI(da2->attrc[LV_CURSOR_COLOR]) : 2; /* Choose color 2 if mode 8 */
+                fg              = (da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) ? getPS55ForeColor(attr, da2) : ((attr & 0x08) ? 3 : 2);
+                bg              = 0;
+                if (attr & 0x04) { /* Color 0 if reverse */
+                    bg = fg;
+                    fg = 0;
+                }
+                for (uint32_t n = 0; n < cursorwidth; n++)
+                    if (p[n] == da2->pallook[da2->egapal[cursorcolor]] || da2->egapal[bg] == da2->egapal[cursorcolor])
+                        p[n] = (p[n] == da2->pallook[da2->egapal[bg]]) ? da2->pallook[da2->egapal[fg]] : da2->pallook[da2->egapal[bg]];
+                    else
+                        p[n] = (p[n] == da2->pallook[da2->egapal[bg]]) ? da2->pallook[da2->egapal[cursorcolor]] : p[n];
+            }
+            da2->ma += 2;
+            p += 13;
+        }
+        da2->ma &= da2->vram_display_mask;
+        // da2->writelines++;
+    }
+}
+
+/* Display Adapter Mode 3 Drawing */
+static void
+da2_render_textm3(da2_t *da2)
+{
+    if (da2->firstline_draw == 2000)
+        da2->firstline_draw = da2->displine;
+    da2->lastline_draw = da2->displine;
+
+    if (da2->fullchange) {
+        int       offset = (8 - da2->scrollcache) + 24;
+        uint32_t *p      = &((uint32_t *) buffer32->line[da2->displine])[offset];
+        int       x;
+        int       drawcursor;
+        uint8_t   chr, attr, extattr;
+        int       fg, bg;
+        uint32_t  chr_dbcs;
+        int       chr_wide = 0;
+        // da2_log("\nda2ma: %x, da2sc: %x\n", da2->ma, da2->sc);
+        for (x = 0; x < da2->hdisp; x += 13) {
+            chr     = da2->vram[(0x18000 + (da2->ma)) & da2->vram_mask];
+            attr    = da2->vram[((0x18000 + (da2->ma)) + 1) & da2->vram_mask];
+            extattr = da2->vram[((0x10000 + (da2->ma)) + 1) & da2->vram_mask];
+            // if(chr!=0x20) da2_log("addr: %x, chr: %x, attr: %x    ", (0x18000 + da2->ma << 1) & da2->vram_mask, chr, attr);
+            bg = attr >> 4;
+            // if (da2->blink) bg &= ~0x8;
+            // fg = (da2->blink || (!(attr & 0x80))) ? (attr & 0xf) : bg;
+            fg = attr & 0xf;
+            fg = IRGBtoBGRI(fg);
+            bg = IRGBtoBGRI(bg);
+            /* Draw character */
+            for (uint32_t n = 0; n < 13; n++)
+                p[n] = da2->pallook[da2->egapal[bg]]; /* draw blank */
+            /* BCS or DBCS left half */
+            if (chr_wide == 0) {
+                if (extattr & 0x01)
+                    chr_wide = 1;
+                /* Stay drawing if the char code is DBCS and not at last column. */
+                if (chr_wide) {
+                    /* Get high DBCS code from the next video address */
+                    chr_dbcs = da2->vram[(0x18000 + (da2->ma) + 2) & da2->vram_mask];
+                    chr_dbcs <<= 8;
+                    chr_dbcs |= chr;
+                    /* Get the font pattern */
+                    uint32_t font = getfont_ps55dbcs(chr_dbcs, da2->sc, da2);
+                    /* Draw 13 dots */
+                    for (uint32_t n = 0; n < 13; n++) {
+                        p[n] = da2->pallook[da2->egapal[(font & 0x80000000) ? fg : bg]];
+                        font <<= 1;
+                    }
+                } else {
+                    /* the char code is SBCS (ANK) */
+                    uint32_t fontbase;
+                    fontbase      = DA2_GAIJIRAM_SBCS;
+                    uint16_t font = da2->mmio.ram[fontbase + chr * 0x40 + da2->sc * 2]; /* w13xh29 font */
+                    font <<= 8;
+                    font |= da2->mmio.ram[fontbase + chr * 0x40 + da2->sc * 2 + 1]; /* w13xh29 font */
+                    // if(chr!=0x20) da2_log("ma: %x, sc: %x, chr: %x, font: %x    ", da2->ma, da2->sc, chr, font);
+                    for (uint32_t n = 0; n < 13; n++) {
+                        p[n] = da2->pallook[da2->egapal[(font & 0x8000) ? fg : bg]];
+                        font <<= 1;
+                    }
+                }
+            }
+            /* right half of DBCS */
+            else {
+                uint32_t font = getfont_ps55dbcs(chr_dbcs, da2->sc, da2);
+                /* Draw 13 dots */
+                for (uint32_t n = 0; n < 13; n++) {
+                    p[n] = da2->pallook[da2->egapal[(font & 0x8000) ? fg : bg]];
+                    font <<= 1;
+                }
+                chr_wide = 0;
+            }
+            drawcursor = ((da2->ma == da2->ca) && da2->con && da2->cursoron);
+            if (drawcursor && da2->sc >= da2->crtc[LC_CURSOR_ROW_START] && da2->sc <= da2->crtc[LC_CURSOR_ROW_END]) {
+                // int cursorwidth = (da2->crtc[0x1f] & 0x20 ? 26 : 13);
+                // int cursorcolor = (da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) ? IRGBtoBGRI(da2->attrc[0x1a]) : 2;/* Choose color 2 if mode 8 */
+                // fg = (da2->attrc[LV_PAS_STATUS_CNTRL] & 0x80) ? getPS55ForeColor(attr, da2) : (attr & 0x08) ? 3 : 2;
+                // bg = 0;
+                // if (attr & 0x04) {/* Color 0 if reverse */
+                //     bg = fg;
+                //     fg = 0;
+                // }
+                for (uint32_t n = 0; n < 13; n++)
+                    p[n] = da2->pallook[da2->egapal[fg]];
+            }
+            da2->ma += 2;
+            p += 13;
+        }
+        da2->ma &= da2->vram_display_mask;
+        // da2->writelines++;
+    }
+}
+
+void
+da2_render_color_4bpp(da2_t *da2)
+{
+    int changed_offset = da2->ma >> 12;
+    // da2_log("ma %x cf %x\n", da2->ma, changed_offset);
+    da2->plane_mask &= 0x0f; /*safety */
+
+    if (da2->changedvram[changed_offset] || da2->changedvram[changed_offset + 1] || da2->fullchange) {
+        int       x;
+        int       offset = (8 - da2->scrollcache) + 24;
+        uint32_t *p      = &((uint32_t *) buffer32->line[da2->displine])[offset];
+
+        if (da2->firstline_draw == 2000)
+            da2->firstline_draw = da2->displine;
+        da2->lastline_draw = da2->displine;
+        // da2_log("d %X\n", da2->ma);
+
+        for (x = 0; x <= da2->hdisp; x += 8) /* hdisp = 1024 */
+        {
+            uint8_t edat[8];
+            uint8_t dat;
+
+            /* get 8 pixels from vram */
+            da2->ma &= da2->vram_display_mask;
+            *(uint32_t *) (&edat[0]) = *(uint32_t *) (&da2->vram[da2->ma << 3]);
+            da2->ma += 1;
+
+            dat  = ((edat[0] >> 7) & (1 << 0)) | ((edat[1] >> 6) & (1 << 1)) | ((edat[2] >> 5) & (1 << 2)) | ((edat[3] >> 4) & (1 << 3));
+            p[0] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 6) & (1 << 0)) | ((edat[1] >> 5) & (1 << 1)) | ((edat[2] >> 4) & (1 << 2)) | ((edat[3] >> 3) & (1 << 3));
+            p[1] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 5) & (1 << 0)) | ((edat[1] >> 4) & (1 << 1)) | ((edat[2] >> 3) & (1 << 2)) | ((edat[3] >> 2) & (1 << 3));
+            p[2] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 4) & (1 << 0)) | ((edat[1] >> 3) & (1 << 1)) | ((edat[2] >> 2) & (1 << 2)) | ((edat[3] >> 1) & (1 << 3));
+            p[3] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 3) & (1 << 0)) | ((edat[1] >> 2) & (1 << 1)) | ((edat[2] >> 1) & (1 << 2)) | ((edat[3] >> 0) & (1 << 3));
+            p[4] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 2) & (1 << 0)) | ((edat[1] >> 1) & (1 << 1)) | ((edat[2] >> 0) & (1 << 2)) | ((edat[3] << 1) & (1 << 3));
+            p[5] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 1) & (1 << 0)) | ((edat[1] >> 0) & (1 << 1)) | ((edat[2] << 1) & (1 << 2)) | ((edat[3] << 2) & (1 << 3));
+            p[6] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            dat  = ((edat[0] >> 0) & (1 << 0)) | ((edat[1] << 1) & (1 << 1)) | ((edat[2] << 2) & (1 << 2)) | ((edat[3] << 3) & (1 << 3));
+            p[7] = da2->pallook[da2->egapal[dat & da2->plane_mask]];
+            p += 8;
+        }
+        // da2->writelines++;
+    }
+}
+
+void
+da2_render_color_8bpp(da2_t *da2)
+{
+    int changed_offset = da2->ma >> 12;
+    // da2_log("ma %x cf %x\n", da2->ma, changed_offset);
+
+    if (da2->changedvram[changed_offset] || da2->changedvram[changed_offset + 1] || da2->fullchange) {
+        int       x;
+        int       offset = (8 - da2->scrollcache) + 24;
+        uint32_t *p      = &((uint32_t *) buffer32->line[da2->displine])[offset];
+
+        if (da2->firstline_draw == 2000)
+            da2->firstline_draw = da2->displine;
+        da2->lastline_draw = da2->displine;
+        // da2_log("d %X\n", da2->ma);
+
+        for (x = 0; x <= da2->hdisp; x += 8) /* hdisp = 1024 */
+        {
+            uint8_t edat[8];
+            uint8_t dat;
+
+            /* get 8 pixels from vram */
+            da2->ma &= da2->vram_display_mask;
+            *(uint32_t *) (&edat[0]) = *(uint32_t *) (&da2->vram[da2->ma << 3]);
+            *(uint32_t *) (&edat[4]) = *(uint32_t *) (&da2->vram[(da2->ma << 3) + 4]);
+            da2->ma += 1;
+
+            dat  = ((edat[0] >> 7) & (1 << 0)) | ((edat[1] >> 6) & (1 << 1)) | ((edat[2] >> 5) & (1 << 2)) | ((edat[3] >> 4) & (1 << 3)) | ((edat[4] >> 3) & (1 << 4)) | ((edat[5] >> 2) & (1 << 5)) | ((edat[6] >> 1) & (1 << 6)) | ((edat[7] >> 0) & (1 << 7));
+            p[0] = da2->pallook[dat];
+            dat  = ((edat[0] >> 6) & (1 << 0)) | ((edat[1] >> 5) & (1 << 1)) | ((edat[2] >> 4) & (1 << 2)) | ((edat[3] >> 3) & (1 << 3)) | ((edat[4] >> 2) & (1 << 4)) | ((edat[5] >> 1) & (1 << 5)) | ((edat[6] >> 0) & (1 << 6)) | ((edat[7] << 1) & (1 << 7));
+            p[1] = da2->pallook[dat];
+            dat  = ((edat[0] >> 5) & (1 << 0)) | ((edat[1] >> 4) & (1 << 1)) | ((edat[2] >> 3) & (1 << 2)) | ((edat[3] >> 2) & (1 << 3)) | ((edat[4] >> 1) & (1 << 4)) | ((edat[5] >> 0) & (1 << 5)) | ((edat[6] << 1) & (1 << 6)) | ((edat[7] << 2) & (1 << 7));
+            p[2] = da2->pallook[dat];
+            dat  = ((edat[0] >> 4) & (1 << 0)) | ((edat[1] >> 3) & (1 << 1)) | ((edat[2] >> 2) & (1 << 2)) | ((edat[3] >> 1) & (1 << 3)) | ((edat[4] >> 0) & (1 << 4)) | ((edat[5] << 1) & (1 << 5)) | ((edat[6] << 2) & (1 << 6)) | ((edat[7] << 3) & (1 << 7));
+            p[3] = da2->pallook[dat];
+            dat  = ((edat[0] >> 3) & (1 << 0)) | ((edat[1] >> 2) & (1 << 1)) | ((edat[2] >> 1) & (1 << 2)) | ((edat[3] >> 0) & (1 << 3)) | ((edat[4] << 1) & (1 << 4)) | ((edat[5] << 2) & (1 << 5)) | ((edat[6] << 3) & (1 << 6)) | ((edat[7] << 4) & (1 << 7));
+            p[4] = da2->pallook[dat];
+            dat  = ((edat[0] >> 2) & (1 << 0)) | ((edat[1] >> 1) & (1 << 1)) | ((edat[2] >> 0) & (1 << 2)) | ((edat[3] << 1) & (1 << 3)) | ((edat[4] << 2) & (1 << 4)) | ((edat[5] << 3) & (1 << 5)) | ((edat[6] << 4) & (1 << 6)) | ((edat[7] << 5) & (1 << 7));
+            p[5] = da2->pallook[dat];
+            dat  = ((edat[0] >> 1) & (1 << 0)) | ((edat[1] >> 0) & (1 << 1)) | ((edat[2] << 1) & (1 << 2)) | ((edat[3] << 2) & (1 << 3)) | ((edat[4] << 3) & (1 << 4)) | ((edat[5] << 4) & (1 << 5)) | ((edat[6] << 5) & (1 << 6)) | ((edat[7] << 6) & (1 << 7));
+            p[6] = da2->pallook[dat];
+            dat  = ((edat[0] >> 0) & (1 << 0)) | ((edat[1] << 1) & (1 << 1)) | ((edat[2] << 2) & (1 << 2)) | ((edat[3] << 3) & (1 << 3)) | ((edat[4] << 4) & (1 << 4)) | ((edat[5] << 5) & (1 << 5)) | ((edat[6] << 6) & (1 << 6)) | ((edat[7] << 7) & (1 << 7));
+            p[7] = da2->pallook[dat];
+            p += 8;
+        }
+        // da2->writelines++;
+    }
+}
+
+void
+da2_updatevidselector(da2_t *da2)
+{
+    da2_log("DA2 selector: %d\n", da2->ioctl[LS_MODE]);
+    if (da2->ioctl[LS_MODE] & 0x02) {
+        /* VGA passthrough mode */
+        da2->override = 1;
+        svga_set_override(da2->mb_vga, 0);
+    } else {
+        svga_set_override(da2->mb_vga, 1);
+        da2->override = 0;
+    }
+}
+
+void
+da2_recalctimings(da2_t *da2)
+{
+    double crtcconst;
+    double _dispontime, _dispofftime, disptime;
+
+    da2->vtotal      = da2->crtc[LC_VERTICAL_TOTALJ] & 0xfff;
+    da2->dispend     = da2->crtc[LC_V_DISPLAY_ENABLE_END] & 0xfff;
+    da2->vsyncstart  = da2->crtc[LC_VERTICAL_SYNC_START] & 0xfff;
+    da2->split       = da2->crtc[LC_LINE_COMPAREJ] & 0xfff;
+    da2->split       = 0xfff;
+    da2->vblankstart = da2->crtc[LC_START_VERTICAL_BLANK] & 0xfff;
+    da2->hdisp       = da2->crtc[LC_H_DISPLAY_ENABLE_END];
+
+    if (da2->crtc[LC_START_H_DISPLAY_ENAB] & 1) {
+        da2->hdisp--;
+        da2->dispend -= 29;
+    } else {
+        // da2->vtotal += 2;
+        da2->dispend--;
+        // da2->vsyncstart++;
+        // da2->split++;
+        // da2->vblankstart++;
+        // da2->hdisp--;
+    }
+
+    da2->htotal = da2->crtc[LC_HORIZONTAL_TOTAL];
+    da2->htotal += 1;
+
+    da2->rowoffset = da2->crtc[LC_OFFSET]; /* number of bytes in a scanline */
+
+    da2->clock = da2->da2const;
+
+    // da2->lowres = da2->attrc[LV_MODE_CONTROL] & 0x40;
+
+    // da2->interlace = 0;
+
+    // da2->ma_latch = ((da2->crtc[0xc] & 0x3ff) << 8) | da2->crtc[0xd];//w + b
+    da2->ca_adj = 0;
+
+    da2->rowcount = da2->crtc[LC_MAXIMUM_SCAN_LINE];
+
+    da2->hdisp_time = da2->hdisp;
+    da2->render     = da2_render_blank;
+    /* determine display mode */
+    // if (da2->attr_palette_enable && (da2->attrc[0x1f] & 0x08))
+    if (da2->attrc[LV_COMPATIBILITY] & 0x08) {
+        /* 16 color graphics mode */
+        if (!(da2->ioctl[LS_MODE] & 0x01)) {
+            da2->hdisp *= 16;
+            da2->char_width = 13;
+            da2->hdisp_old  = da2->hdisp;
+            if (da2->crtc[LC_VIEWPORT_PRIORITY] & 0x80) {
+                da2_log("Set videomode to PS/55 8 bpp graphics.\n");
+                da2->render            = da2_render_color_8bpp;
+                da2->vram_display_mask = DA2_MASK_GRAM;
+            } else { /* PS/55 8-color */
+                da2_log("Set videomode to PS/55 4 bpp graphics.\n");
+                da2->vram_display_mask = DA2_MASK_GRAM;
+                da2->render            = da2_render_color_4bpp;
+            }
+        } else {
+            /* text mode */
+            if (da2->attrc[LV_ATTRIBUTE_CNTL] & 1) {
+                da2_log("Set videomode to PS/55 Mode 03 text.\n");
+                da2->render            = da2_render_textm3;
+                da2->vram_display_mask = DA2_MASK_CRAM;
+            }
+            /* PS/55 text(color/mono) */
+            else {
+                da2_log("Set videomode to PS/55 Mode 8/E text.\n");
+                da2->render            = da2_render_text;
+                da2->vram_display_mask = DA2_MASK_CRAM;
+            }
+            da2->hdisp *= 13;
+            da2->hdisp_old  = da2->hdisp;
+            da2->char_width = 13;
+        }
+    } else {
+        da2_log("Set videomode to blank.\n");
+    }
+    // if (!da2->scrblank && da2->attr_palette_enable)
+    //{
+    // da2->render = da2_draw_text;
+    //}
+
+    // da2_log("da2_render %08X : %08X %08X %08X %08X %08X  %i %i %02X %i %i\n", da2_render, da2_render_text_40, da2_render_text_80, da2_render_8bpp_lowres, da2_render_8bpp_highres, da2_render_blank, scrblank,gdcreg[6]&1,gdcreg[5]&0x60,bpp,seqregs[1]&8);
+
+    // if (da2->recalctimings_ex)
+    //     da2->recalctimings_ex(da2);
+
+    if (da2->vblankstart < da2->dispend)
+        da2->dispend = da2->vblankstart;
+
+    crtcconst = da2->clock * da2->char_width;
+
+    disptime    = da2->htotal;
+    _dispontime = da2->hdisp_time;
+
+    da2_log("Disptime %f dispontime %f hdisp %i\n", disptime, _dispontime, da2->hdisp);
+    // if (da2->seqregs[1] & 8) { disptime *= 2; _dispontime *= 2; }
+    _dispofftime = disptime - _dispontime;
+    _dispontime *= crtcconst;
+    _dispofftime *= crtcconst;
+
+    da2->dispontime  = (uint64_t) _dispontime;
+    da2->dispofftime = (uint64_t) _dispofftime;
+    if (da2->dispontime < TIMER_USEC)
+        da2->dispontime = TIMER_USEC;
+    if (da2->dispofftime < TIMER_USEC)
+        da2->dispofftime = TIMER_USEC;
+    da2_log("da2 horiz total %i display end %i vidclock %f\n", da2->crtc[0], da2->crtc[1], da2->clock);
+    // da2_log("da2 vert total %i display end %i max row %i vsync %i\n",da2->vtotal,da2->dispend,(da2->crtc[9]&31)+1,da2->vsyncstart);
+    // da2_log("total %f on %i cycles off %i cycles frame %i sec %i\n",disptime*crtcconst,da2->dispontime,da2->dispofftime,(da2->dispontime+da2->dispofftime)*da2->vtotal,(da2->dispontime+da2->dispofftime)*da2->vtotal*70);
+
+    // da2_log("da2->render %08X\n", da2->render);
+}
+
+static void
+da2_mapping_update(da2_t *da2)
+{
+    /* Has the CardEnable bit been changed? */
+    if (!((da2->pos_regs[2] ^ da2->old_pos2) & 1))
+        return;
+    da2->old_pos2 = da2->pos_regs[2];
+    // da2_recalc_mapping(da2);
+    if (da2->pos_regs[2] & 0x01) {
+        da2_log("DA2 enable registers\n");
+        for (int i = 0; i < 8; i++)
+            da2_log("DA2 POS[%d]: %x\n", i, da2->pos_regs[i]);
+        io_sethandler(0x03c0, 0x000a, da2_inb, da2_inw, NULL, da2_outb, da2_outw, NULL, da2);
+        io_sethandler(0x03e0, 0x0010, da2_inb, da2_inw, NULL, da2_outb, da2_outw, NULL, da2);
+        io_sethandler(0x03d0, 0x000b, da2_in_ISR, NULL, NULL, da2_out_ISR, NULL, NULL, da2);
+        mem_mapping_enable(&da2->cmapping);
+        mem_mapping_enable(&da2->mmio.mapping);
+        timer_enable(&da2->timer);
+        timer_enable(&da2->bitblt.timer);
+    } else {
+        da2_log("DA2 disable registers\n");
+        timer_disable(&da2->bitblt.timer);
+        timer_disable(&da2->timer);
+        mem_mapping_disable(&da2->cmapping);
+        mem_mapping_disable(&da2->mmio.mapping);
+        io_removehandler(0x03c0, 0x000a, da2_inb, da2_inw, NULL, da2_outb, da2_outw, NULL, da2);
+        io_removehandler(0x03e0, 0x0010, da2_inb, da2_inw, NULL, da2_outb, da2_outw, NULL, da2);
+        io_removehandler(0x03d0, 0x000b, da2_in_ISR, NULL, NULL, da2_out_ISR, NULL, NULL, da2);
+    }
+}
+
+uint8_t
+da2_mca_read(int port, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    return da2->pos_regs[port & 7];
+}
+
+void
+da2_mca_write(int port, uint8_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+
+    da2_log("da2_mca_write: port=%04x val=%02x\n", port, val);
+
+    if (port < 0x102)
+        return;
+    da2->pos_regs[port & 7] = val;
+
+    da2_mapping_update(da2);
+}
+
+static uint8_t
+da2_mca_feedb(void *priv)
+{
+    const da2_t *da2 = (da2_t *) priv;
+
+    return da2->pos_regs[2] & 0x01;
+}
+
+static void
+da2_mca_reset(void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    da2_log("da2_mca_reset called.\n");
+    da2_reset(da2);
+    da2_mca_write(0x102, 0, da2);
+}
+
+static void
+da2_gdcropB(uint32_t addr,uint8_t bitmask, da2_t *da2)
+{
+    for (int i = 0; i < 8; i++) {
+        if (da2->writemask & (1 << i)) {
+            // da2_log("da2_gdcropB o%x a%x d%x p%d m%x\n", da2->gdcreg[LG_COMMAND] & 0x03, addr, da2->gdcinput[i], i, bitmask);
+            switch (da2->gdcreg[LG_COMMAND] & 0x03) {
+                case 0: /*Set*/
+                    // da2->vram[addr | i] = (da2->gdcinput[i] & bitmask) | (da2->gdcsrc[i] & ~bitmask);
+                    // da2->vram[addr | i] = (da2->gdcinput[i] & bitmask) | (da2->vram[addr | i] & ~bitmask);
+                    da2->vram[addr | i] = (da2->gdcinput[i] & bitmask) | (da2->vram[addr | i] & ~bitmask);
+                    break;
+                case 1: /*AND*/
+                    // da2->vram[addr | i] = (da2->gdcinput[i] | ~bitmask) & da2->gdcsrc[i];
+                    da2->vram[addr | i] = ((da2->gdcinput[i] & da2->gdcsrc[i]) & bitmask) | (da2->vram[addr | i] & ~bitmask);
+                    break;
+                case 2: /*OR*/
+                    // da2->vram[addr | i] = (da2->gdcinput[i] & bitmask) | da2->gdcsrc[i];
+                    da2->vram[addr | i] = ((da2->gdcinput[i] | da2->gdcsrc[i]) & bitmask) | (da2->vram[addr | i] & ~bitmask);
+                    break;
+                case 3: /*XOR*/
+                    // da2->vram[addr | i] = (da2->gdcinput[i] & bitmask) ^ da2->gdcsrc[i];
+                    da2->vram[addr | i] = ((da2->gdcinput[i] ^ da2->gdcsrc[i]) & bitmask) | (da2->vram[addr | i] & ~bitmask);
+                    break;
+            }
+        }
+    }
+}
+static void
+da2_gdcropW(uint32_t addr, uint16_t bitmask, da2_t *da2)
+{
+    uint8_t bitmask_l = bitmask & 0xff;
+    uint8_t bitmask_h = bitmask >> 8;
+    for (int i = 0; i < 8; i++) {
+        if (da2->writemask & (1 << i)) {
+            // da2_log("da2_gdcropW m%x a%x d%x i%d ml%x mh%x\n", da2->gdcreg[LG_COMMAND] & 0x03, addr, da2->gdcinput[i], i, da2->gdcreg[LG_BIT_MASK_LOW], da2->gdcreg[LG_BIT_MASK_HIGH]);
+            switch (da2->gdcreg[LG_COMMAND] & 0x03) {
+                case 0: /*Set*/
+                    // da2->vram[addr | i]       = (da2->gdcinput[i] & bitmask_l) | (da2->gdcsrc[i] & ~bitmask_l);
+                    // da2->vram[(addr + 8) | i] = ((da2->gdcinput[i] >> 8) & bitmask_h) | ((da2->gdcsrc[i] >> 8) & ~bitmask_h);
+                    da2->vram[addr | i]       = (da2->gdcinput[i] & bitmask_l) | (da2->vram[addr | i] & ~bitmask_l);
+                    da2->vram[(addr + 8) | i] = ((da2->gdcinput[i] >> 8) & bitmask_h)
+                        | (da2->vram[(addr + 8) | i] & ~bitmask_h);
+                    break;
+                case 1: /*AND*/
+                    // da2->vram[addr | i]       = (da2->gdcinput[i] | ~bitmask_l) & da2->gdcsrc[i];
+                    // da2->vram[(addr + 8) | i] = ((da2->gdcinput[i] >> 8) | ~bitmask_h) & (da2->gdcsrc[i] >> 8);
+                    da2->vram[addr | i]       = ((da2->gdcinput[i] & da2->gdcsrc[i]) & bitmask_l) | (da2->vram[addr | i] & ~bitmask_l);
+                    da2->vram[(addr + 8) | i] = (((da2->gdcinput[i] >> 8) & (da2->gdcsrc[i] >> 8)) & bitmask_h)
+                        | (da2->vram[(addr + 8) | i] & ~bitmask_h);
+                    break;
+                case 2: /*OR*/
+                    // da2->vram[addr | i]       = (da2->gdcinput[i] & bitmask_l) | da2->gdcsrc[i];
+                    // da2->vram[(addr + 8) | i] = ((da2->gdcinput[i] >> 8) & bitmask_h) | (da2->gdcsrc[i] >> 8);
+                    da2->vram[addr | i]       = ((da2->gdcinput[i] | da2->gdcsrc[i]) & bitmask_l) | (da2->vram[addr | i] & ~bitmask_l);
+                    da2->vram[(addr + 8) | i] = (((da2->gdcinput[i] >> 8) | (da2->gdcsrc[i] >> 8)) & bitmask_h)
+                        | (da2->vram[(addr + 8) | i] & ~bitmask_h);
+                    break;
+                case 3: /*XOR*/
+                    // da2->vram[addr | i]       = (da2->gdcinput[i] & bitmask_l) ^ da2->gdcsrc[i];
+                    // da2->vram[(addr + 8) | i] = ((da2->gdcinput[i] >> 8) & bitmask_h) ^ (da2->gdcsrc[i] >> 8);
+                    da2->vram[addr | i]       = ((da2->gdcinput[i] ^ da2->gdcsrc[i]) & bitmask_l) | (da2->vram[addr | i] & ~bitmask_l);
+                    da2->vram[(addr + 8) | i] = (((da2->gdcinput[i] >> 8) ^ (da2->gdcsrc[i] >> 8)) & bitmask_h)
+                        | (da2->vram[(addr + 8) | i] & ~bitmask_h);
+                    break;
+            }
+        }
+    }
+}
+
+static uint8_t
+da2_mmio_read(uint32_t addr, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    addr &= DA2_MASK_MMIO;
+
+    if (da2->ioctl[LS_MMIO] & 0x10) {
+        if (da2->fctl[LF_MMIO_SEL] == 0x80)
+            /* linear access */
+            addr |= ((uint32_t) da2->fctl[LF_MMIO_ADDR] << 17);
+        else {
+            /* 64k bank switch access */
+            uint32_t index = da2->fctl[LF_MMIO_MODE] & 0x0f;
+            index <<= 8;
+            index |= da2->fctl[LF_MMIO_ADDR];
+            addr += index * 0x40;
+        }
+        // da2_log("PS55_MemHnd: Read from mem %x, bank %x, addr %x\n", da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr);
+        switch (da2->fctl[LF_MMIO_MODE] & 0xf0) {
+            case 0xb0:                     /* Gaiji RAM */
+                addr &= DA2_MASK_GAIJIRAM; /* safety access */
+                // da2_log("PS55_MemHnd_G: Read from mem %x, bank %x, chr %x (%x), val %x\n", da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr / 128, addr, da2->mmio.font[addr]);
+                return da2->mmio.ram[addr];
+                break;
+            case 0x10: /* Font ROM */
+                if (da2->mmio.charset == DA2_DCONFIG_CHARSET_HANT) {
+                    if (addr >= 0x1a0000)
+                        return DA2_INVALIDACCESS8;
+                    if (addr >= 0x180000)
+                        addr -= 0x40000; /* The bank 12 (180000h-19ffffh) is beyond the available ROM address range,
+                                              but the Chinese font sub card actually has this alias, and is used by DOS T5.0. */
+                }
+                if (addr >= DA2_FONTROM_SIZE)
+                    return DA2_INVALIDACCESS8;
+                // da2_log("PS55_MemHnd: Read from mem %x, bank %x, chr %x (%x), val %x\n", da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr / 72, addr, da2->mmio.font[addr]);
+                return da2->mmio.font[addr];
+                break;
+            default:
+                return DA2_INVALIDACCESS8; /* invalid memory access */
+                break;
+        }
+    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 8 or 256 color mode */
+        cycles -= video_timing_read_b;
+        for (int i = 0; i < 8; i++)
+            da2->gdcla[i] = da2->vram[(addr << 3) | i]; /* read in byte */
+        // da2_log("da2_Rb: %05x=%02x\n", addr, da2->gdcla[da2->readplane]);
+        if (da2->gdcreg[LG_MODE] & 0x08) { /* compare data across planes if the read mode bit (3EB 05, bit 3) is 1 */
+            uint8_t ret = 0;
+            for (int i = 0; i < 8; i++) {
+                if (~da2->gdcreg[LG_COLOR_DONT_CARE] & (1 << i)) /* color don't care register */
+                    ret |= da2->gdcla[i] ^ ((da2->gdcreg[LG_COLOR_COMPAREJ] & (1 << i)) ? 0xff : 0);
+            }
+            return ~ret;
+        } else
+            return da2->gdcla[da2->readplane];
+    } else { /* text mode 3 */
+
+        cycles -= video_timing_read_b;
+        return da2->vram[addr];
+    }
+}
+static uint16_t
+da2_mmio_readw(uint32_t addr, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    //da2_log("da2_readW: %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr);
+    if (da2->ioctl[LS_MMIO] & 0x10) {
+        return (uint16_t) da2_mmio_read(addr, da2) | (uint16_t) (da2_mmio_read(addr + 1, da2) << 8);
+    } else if (!(da2->ioctl[LS_MODE] & 1)) /* 8 color or 256 color mode */
+    {
+        cycles -= video_timing_read_w;
+        addr &= DA2_MASK_MMIO;
+        for (int i = 0; i < 8; i++)
+            da2->gdcla[i] = (uint16_t) (da2->vram[(addr << 3) | i]) | ((uint16_t) (da2->vram[((addr << 3) + 8) | i]) << 8); /* read vram into latch */
+
+#ifdef ENABLE_DA2_DEBUGBLT
+        ////debug
+        // if (((int)addr - (int)da2->mmrdbg_vidaddr) > 2 || (((int)da2->mmrdbg_vidaddr - (int)addr) > 2) || da2->mmrdbg_vidaddr == addr)
+        //{
+        //     fprintf(da2->mmrdbg_fp, "\nR %x ", addr);
+        //     for (int i = 0; i <= 0xb; i++)
+        //         fprintf(da2->mmrdbg_fp, "%02x ", da2->gdcreg[i]);
+        // }
+        // for (int i = 0; i < 16; i++)
+        //{
+        //     int pixeldata = 0;
+        //     if (da2->gdcla[da2->readplane] & (1 << (15 - i))) pixeldata = 1;
+        //     fprintf(da2->mmrdbg_fp, "%X", pixeldata);
+        // }
+        // da2->mmrdbg_vidaddr = addr;
+#endif
+
+        if (da2->gdcreg[LG_MODE] & 0x08) { /* compare data across planes if the read mode bit (3EB 05, bit 3) is 1 */
+            uint16_t ret = 0;
+
+            for (int i = 0; i < 8; i++) {
+                if (~da2->gdcreg[LG_COLOR_DONT_CARE] & (1 << i)) /* color don't care register */
+                    ret |= da2->gdcla[i] ^ ((da2->gdcreg[LG_COLOR_COMPAREJ] & (1 << i)) ? 0xffff : 0);
+            }
+            return ~ret;
+        } else {
+            // da2_log("da2_Rw: %05x=%04x\n", addr, da2->gdcla[da2->readplane]);
+            return da2->gdcla[da2->readplane];
+        }
+    } else {
+        return (uint16_t) da2_mmio_read(addr, da2) | (uint16_t) (da2_mmio_read(addr + 1, da2) << 8);
+    }
+}
+
+static void
+da2_mmio_write(uint32_t addr, uint8_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    // da2_log("da2_mmio_write %x %x\n", addr, val);
+    if ((addr & ~DA2_MASK_MMIO) != 0xA0000)
+        return;
+    addr &= DA2_MASK_MMIO;
+
+    if (da2->ioctl[LS_MMIO] & 0x10) {
+        // if(da2->ioctl[LS_MMIO] == 0x1f) da2_log("mw mem %x, addr %x, val %x, ESDI %x:%x DSSI %x:%x\n", da2->fctl[LF_MMIO_MODE], addr, val, ES, DI, DS, SI);
+        /* Gaiji RAM */
+        if (da2->fctl[LF_MMIO_SEL] == 0x80)
+            addr |= ((uint32_t) da2->fctl[LF_MMIO_ADDR] << 17); /* xxxy yyyy yyyy yyyy yyyy */
+        else {
+            uint32_t index = da2->fctl[LF_MMIO_MODE] & 0x0f;
+            index <<= 8;
+            index |= da2->fctl[LF_MMIO_ADDR];
+            addr += index * 0x40;
+        }
+        switch (da2->fctl[LF_MMIO_MODE]) {
+            case 0xb0:                     /* Gaiji RAM 1011 0000 */
+                addr &= DA2_MASK_GAIJIRAM; /* safety access */
+                da2->mmio.ram[addr] = val;
+                break;
+            case 0x10: /* Font ROM  0001 0000 */
+                /* Read-Only */
+                break;
+            case 0x00:
+                // da2_log("da2_mmio_write %x %x %04X:%04X\n", addr, val, CS, cpu_state.pc);
+                // addr &= 0x7f;/* OS/2 write addr 1cf80-1cfc3, val xx */
+                // if (addr >= DA2_BLT_MEMSIZE)
+                //{
+                //     da2_log("da2_mmio_write failed mem %x, addr %x, val %x\n", da2->fctl[LF_MMIO_MODE], addr, val);
+                //     return;
+                // }
+                da2->bitblt.indata = 1;
+                if (da2->bitblt.payload_addr >= DA2_BLT_MEMSIZE)
+                    da2_log("da2_mmio_write payload overflow! mem %x, addr %x, val %x\n", da2->fctl[LF_MMIO_MODE], addr, val);
+                da2->bitblt.payload[da2->bitblt.payload_addr] = val;
+                da2->bitblt.payload_addr++;
+                break;
+            default:
+                da2_log("da2_mmio_write failed mem %x, addr %x, val %x\n", da2->fctl[LF_MMIO_MODE], addr, val);
+                break;
+        }
+    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 8 color or 256 color mode */
+        uint8_t bitmask;
+        /* align bitmask to even address */
+        if (addr & 1) bitmask = da2->gdcreg[LG_BIT_MASK_HIGH];
+        else  bitmask = da2->gdcreg[LG_BIT_MASK_LOW];
+#ifdef ENABLE_DA2_DEBUGBLT
+        da2_log("da2_wB %x %02x\n", addr, val);
+        // if (!(da2->gdcreg[LG_COMMAND] & 0x08))
+        //{
+        if (((int) addr - (int) da2->mmdbg_vidaddr) > 2 || (((int) da2->mmdbg_vidaddr - (int) addr) > 2) || da2->mmdbg_vidaddr == addr) {
+            fprintf(da2->mmdbg_fp, "\nB %x %02x ", addr, val);
+            for (int i = 0; i <= 0xb; i++)
+                fprintf(da2->mmdbg_fp, "%02x ", da2->gdcreg[i]);
+        }
+        for (int i = 0; i < 8; i++) {
+            int pixeldata = 0;
+            if (val & (1 << (7 - i)))
+                pixeldata = (da2->writemask & 0xf);
+            fprintf(da2->mmdbg_fp, "%X", pixeldata);
+        }
+        da2->mmdbg_vidaddr = addr;
+        //}
+#endif
+
+        cycles -= video_timing_write_b;
+
+        da2->changedvram[addr >> 12] = changeframecount;
+        addr <<= 3;
+
+        for (int i = 0; i < 8; i++)
+            da2->gdcsrc[i] = da2->gdcla[i]; /* use latch */
+
+        // da2_log("da2_Wb m%02x r%02x %05x:%02x %x:%x\n", da2->gdcreg[0x5], da2->gdcreg[LG_COMMAND], addr >> 3, val, cs >> 4, cpu_state.pc);
+        // da2_log("da2_Wb m%02x r%02x %05x:%02x=%02x%02x%02x%02x->", da2->gdcreg[0x5], da2->gdcreg[LG_COMMAND], addr >> 3, val, da2->vram[addr + 0], da2->vram[addr + 1], da2->vram[addr + 2], da2->vram[addr + 3]);
+
+        if (!(da2->gdcreg[LG_COMMAND] & 0x08)) {
+            for (int i = 0; i < 8; i++)
+                if (da2->gdcreg[LG_ENABLE_SRJ] & (1 << i))
+                    da2->gdcinput[i] = (da2->gdcreg[LG_SET_RESETJ] & (1 << i)) ? 0xff : 0;
+                else if (da2->gdcreg[LG_SET_RESETJ] & (1 << i))
+                    da2->gdcinput[i] = ~val;
+                else
+                    da2->gdcinput[i] = val;
+            da2_gdcropB(addr, bitmask, da2);
+            return;
+        }
+
+        switch (da2->writemode) {
+            case 2: /* equiv to vga write mode 1 */
+                for (int i = 0; i < 8; i++)
+                    if (da2->writemask & (1 << i))
+                        da2->vram[addr | i] = da2->gdcsrc[i];
+                break;
+            case 0:/* equiv to vga write mode 0 */
+                if (da2->gdcreg[LG_DATA_ROTATION] & 7)
+                    val = svga_rotate[da2->gdcreg[LG_DATA_ROTATION] & 7][val];
+                if (bitmask == 0xff && !(da2->gdcreg[LG_COMMAND] & 0x03) && (!da2->gdcreg[LG_ENABLE_SRJ])) {
+                    for (int i = 0; i < 8; i++)
+                        if (da2->writemask & (1 << i))
+                            da2->vram[addr | i] = val;
+                } else {
+                    for (int i = 0; i < 8; i++)
+                        if (da2->gdcreg[LG_ENABLE_SRJ] & (1 << i))
+                            da2->gdcinput[i] = (da2->gdcreg[LG_SET_RESETJ] & (1 << i)) ? 0xff : 0;
+                        else
+                            da2->gdcinput[i] = val;
+
+                    for (int i = 0; i < 8; i++)
+                        da2->debug_vramold[i] = da2->vram[addr | i]; /* use latch */
+                    da2_gdcropB(addr, bitmask, da2);
+                    // for (int i = 0; i < 8; i++)
+                    //     da2_log("\tsrc %02x in %02x bitm %02x mod %x rop %x: %02x -> %02x\n", da2->gdcsrc[i], da2->gdcinput[i], bitmask, da2->gdcreg[5],da2->gdcreg[LG_COMMAND], da2->debug_vramold[i],  da2->vram[addr | i]);//use latch
+                    ////da2_log("- %02X %02X %02X %02X   %08X\n",vram[addr],vram[addr|0x1],vram[addr|0x2],vram[addr|0x3],addr);
+                }
+                break;
+            case 1:/* equiv to vga write mode 2 */
+                if (!(da2->gdcreg[LG_COMMAND] & 0x03) && (!da2->gdcreg[LG_ENABLE_SRJ])) {
+                    for (int i = 0; i < 8; i++)
+                        if (da2->writemask & (1 << i))
+                            da2->vram[addr | i] = (((val & (1 << i)) ? 0xff : 0) & bitmask) | (da2->gdcsrc[i] & ~bitmask);
+                    //fprintf(da2->mmdbg_fp, "m1-1");
+                } else {
+                    for (int i = 0; i < 8; i++)
+                        da2->gdcinput[i] = ((val & (1 << i)) ? 0xff : 0);
+                    da2_gdcropB(addr, bitmask, da2);
+                    //fprintf(da2->mmdbg_fp, "m1-2");
+                }
+                break;
+            case 3:/* equiv to vga write mode 3 */
+                if (da2->gdcreg[LG_DATA_ROTATION] & 7)
+                    val = svga_rotate[da2->gdcreg[LG_DATA_ROTATION] & 7][val];
+                bitmask &= val;
+
+                for (int i = 0; i < 8; i++)
+                    da2->gdcinput[i] = (da2->gdcreg[LG_SET_RESETJ] & (1 << i)) ? 0xff : 0;
+                da2_gdcropB(addr, bitmask, da2);
+                break;
+        }
+        // da2_log("%02x%02x%02x%02x\n", da2->vram[addr + 0], da2->vram[addr + 1], da2->vram[addr + 2], da2->vram[addr + 3]);
+    } else { /*  mode 3h text */
+        cycles -= video_timing_write_b;
+        da2->vram[addr] = val;
+        da2->fullchange = 2;
+    }
+}
+uint16_t
+rightRotate(uint16_t data, uint8_t count)
+{
+    return (data >> count) | (data << (sizeof(data) * 8 - count));
+}
+static void
+da2_mmio_gc_writeW(uint32_t addr, uint16_t val, void *p)
+{
+    da2_t   *da2     = (da2_t *) p;
+    uint16_t bitmask = da2->gdcreg[LG_BIT_MASK_HIGH];
+    bitmask <<= 8;
+    bitmask |= (uint16_t) da2->gdcreg[LG_BIT_MASK_LOW];
+#ifdef ENABLE_DA2_DEBUGBLT
+    // if (!(da2->gdcreg[LG_COMMAND] & 0x08))
+    //{
+    if (((int) addr - (int) da2->mmdbg_vidaddr) > 2 || (((int) da2->mmdbg_vidaddr - (int) addr) > 2) || da2->mmdbg_vidaddr == addr) {
+        fprintf(da2->mmdbg_fp, "\nW %x ", addr);
+        for (int i = 0; i <= 0xb; i++)
+            fprintf(da2->mmdbg_fp, "%02x ", da2->gdcreg[i]);
+    }
+    for (int i = 0; i < 16; i++) {
+        int pixeldata = 0;
+        if (val & (1 << (15 - i)))
+            pixeldata = (da2->writemask & 0xf);
+        fprintf(da2->mmdbg_fp, "%X", pixeldata);
+    }
+    da2->mmdbg_vidaddr = addr;
+    //}
+#endif
+    cycles -= video_timing_write_w;
+    // cycles_lost += video_timing_write_w;
+
+    // da2_log("da2_gcW m%d a%x d%x\n", da2->writemode, addr, val);
+    // da2_log("da2_gcW %05X %02X %04X:%04X esdi %04X:%04X dssi %04X:%04X\n", addr, val, cs >> 4, cpu_state.pc, ES, DI, DS, SI);
+
+    da2->changedvram[addr >> 12]       = changeframecount;
+    da2->changedvram[(addr + 1) >> 12] = changeframecount;
+    addr <<= 3;
+
+    for (int i = 0; i < 8; i++)
+        da2->gdcsrc[i] = da2->gdcla[i]; /* use latch */
+
+    if (!(da2->gdcreg[LG_COMMAND] & 0x08)) {
+        for (int i = 0; i < 8; i++)
+            if (da2->gdcreg[LG_ENABLE_SRJ] & (1 << i))
+                da2->gdcinput[i] = (da2->gdcreg[LG_SET_RESETJ] & (1 << i)) ? 0xffff : 0;
+            else if (da2->gdcreg[LG_SET_RESETJ] & (1 << i))
+                da2->gdcinput[i] = ~val;
+            else
+                da2->gdcinput[i] = val;
+        da2_gdcropW(addr, bitmask, da2);
+        return;
+    }
+    // da2_log("da2_Ww m%02x r%02x %05x:%04x=%02x%02x%02x%02x,%02x%02x%02x%02x->", da2->gdcreg[0x5], da2->gdcreg[LG_COMMAND], addr >> 3, val, da2->vram[addr + 0], da2->vram[addr + 1], da2->vram[addr + 2], da2->vram[addr + 3]
+    //     , da2->vram[addr + 8], da2->vram[addr + 9], da2->vram[addr + 10], da2->vram[addr + 11]);
+    switch (da2->writemode) {
+        case 2:
+            for (int i = 0; i < 8; i++)
+                if (da2->writemask & (1 << i)) {
+                    da2->vram[addr | i]       = da2->gdcsrc[i] & 0xff;
+                    da2->vram[(addr + 8) | i] = da2->gdcsrc[i] >> 8;
+                }
+            break;
+        case 0:
+            if (da2->gdcreg[LG_DATA_ROTATION] & 15)
+                val = rightRotate(val, da2->gdcreg[LG_DATA_ROTATION] & 15); // val = svga_rotate[da2->gdcreg[LG_DATA_ROTATION] & 7][val]; TODO this wont work
+            if (bitmask == 0xffff && !(da2->gdcreg[LG_COMMAND] & 0x03) && (!da2->gdcreg[LG_ENABLE_SRJ])) {
+                for (int i = 0; i < 8; i++)
+                    if (da2->writemask & (1 << i)) {
+                        da2->vram[addr | i]       = val & 0xff;
+                        da2->vram[(addr + 8) | i] = val >> 8;
+                    }
+            } else {
+                for (int i = 0; i < 8; i++)
+                    if (da2->gdcreg[LG_ENABLE_SRJ] & (1 << i))
+                        da2->gdcinput[i] = (da2->gdcreg[LG_SET_RESETJ] & (1 << i)) ? 0xffff : 0;
+                    else
+                        da2->gdcinput[i] = val;
+                da2_gdcropW(addr, bitmask, da2);
+                // da2_log("- %02X %02X %02X %02X   %08X\n",vram[addr],vram[addr|0x1],vram[addr|0x2],vram[addr|0x3],addr);
+            }
+            break;
+        case 1:
+            if (!(da2->gdcreg[LG_COMMAND] & 0x03) && (!da2->gdcreg[LG_ENABLE_SRJ])) {
+                for (int i = 0; i < 8; i++)
+                    if (da2->writemask & (1 << i)) {
+                        uint16_t wdata            = (((val & (1 << i)) ? 0xffff : 0) & bitmask) | (da2->gdcsrc[i] & ~bitmask);
+                        da2->vram[addr | i]       = wdata & 0xff;
+                        da2->vram[(addr + 8) | i] = wdata >> 8;
+                    }
+            } else {
+                for (int i = 0; i < 8; i++)
+                    da2->gdcinput[i] = ((val & (1 << i)) ? 0xffff : 0);
+                da2_gdcropW(addr, bitmask, da2);
+            }
+            break;
+        case 3:
+            if (da2->gdcreg[LG_DATA_ROTATION] & 15)
+                val = rightRotate(val, da2->gdcreg[LG_DATA_ROTATION] & 15); // val = svga_rotate[da2->gdcreg[LG_DATA_ROTATION] & 7][val];; TODO this wont work
+            bitmask &= val;
+
+            for (int i = 0; i < 8; i++)
+                da2->gdcinput[i] = (da2->gdcreg[LG_SET_RESETJ] & (1 << i)) ? 0xffff : 0;
+            da2_gdcropW(addr, bitmask, da2);
+            break;
+    }
+    // da2_log("%02x%02x%02x%02x,%02x%02x%02x%02x\n", da2->vram[addr + 0], da2->vram[addr + 1], da2->vram[addr + 2], da2->vram[addr + 3]
+    //     , da2->vram[addr + 8], da2->vram[addr + 9], da2->vram[addr + 10], da2->vram[addr + 11]);
+}
+static void
+da2_mmio_writew(uint32_t addr, uint16_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    // if ((addr & ~0x1ffff) != 0xA0000) return;
+    if (da2->ioctl[LS_MMIO] & 0x10) {
+        // da2_log("da2_mmio_writeW %x %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr, val);
+        da2_mmio_write(addr, val & 0xff, da2);
+        da2_mmio_write(addr + 1, val >> 8, da2);
+    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 8 color or 256 color mode */
+        addr &= DA2_MASK_MMIO;
+        // return;
+        // da2_log("da2_mmio_writeGW %x %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr, val);
+        da2_mmio_gc_writeW(addr, val, da2);
+    } else { /* mode 3h text */
+        // if (addr & 0xff00 == 0) da2_log("da2_mmio_write %x %x %04X:%04X\n", addr, val, CS, cpu_state.pc);
+        // da2_log("da2_mmio_writeGW %x %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr, val);
+        da2_mmio_write(addr, val & 0xff, da2);
+        da2_mmio_write(addr + 1, val >> 8, da2);
+    }
+}
+
+static void
+da2_code_write(uint32_t addr, uint8_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    // if ((addr & ~0xfff) != 0xE0000) return;
+    addr &= DA2_MASK_CRAM;
+    da2->cram[addr] = val;
+    da2->fullchange = 2;
+}
+static void
+da2_code_writeb(uint32_t addr, uint8_t val, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    // da2_log("DA2_code_writeb: Write to %x, val %x\n", addr, val);
+    cycles -= video_timing_write_b;
+    da2_code_write(addr, val, da2);
+}
+static void
+da2_code_writew(uint32_t addr, uint16_t val, void *p)
+{
+    // da2_log("DA2_code_writew: Write to %x, val %x\n", addr, val);
+    da2_t *da2 = (da2_t *) p;
+    cycles -= video_timing_write_w;
+    da2_code_write(addr, val & 0xff, da2);
+    da2_code_write(addr + 1, val >> 8, da2);
+}
+
+static uint8_t
+da2_code_read(uint32_t addr, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    if ((addr & ~DA2_MASK_CRAM) != 0xE0000)
+        return DA2_INVALIDACCESS8;
+    addr &= DA2_MASK_CRAM;
+    return da2->cram[addr];
+}
+static uint8_t
+da2_code_readb(uint32_t addr, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    cycles -= video_timing_read_b;
+    return da2_code_read(addr, da2);
+}
+static uint16_t
+da2_code_readw(uint32_t addr, void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+    cycles -= video_timing_read_w;
+    return da2_code_read(addr, da2) | (da2_code_read(addr + 1, da2) << 8);
+}
+
+void
+da2_doblit(int y1, int y2, int wx, int wy, da2_t *da2)
+{
+    if (wx != xsize || wy != ysize) {
+        xsize = wx;
+        ysize = wy;
+        set_screen_size(xsize, ysize);
+
+        if (video_force_resize_get())
+            video_force_resize_set(0);
+    }
+    video_blit_memtoscreen(32, 0, xsize, ysize);
+    frames++;
+
+    video_res_x = wx;
+    video_res_y = wy;
+    video_bpp   = 8;
+}
+
+void
+da2_poll(void *priv)
+{
+    da2_t *da2 = (da2_t *) priv;
+    int    x;
+
+    if (!da2->linepos) {
+        timer_advance_u64(&da2->timer, da2->dispofftime);
+        // if (output) printf("Display off %f\n",vidtime);
+        da2->cgastat |= 1;
+        da2->linepos = 1;
+
+        if (da2->dispon) {
+            da2->hdisp_on = 1;
+
+            da2->ma &= da2->vram_display_mask;
+            if (da2->firstline == 2000) {
+                da2->firstline = da2->displine;
+                video_wait_for_buffer();
+            }
+
+            if (!da2->override)
+                da2->render(da2);
+
+            if (da2->lastline < da2->displine)
+                da2->lastline = da2->displine;
+        }
+
+        // da2_log("%03i %06X %06X\n", da2->displine, da2->ma,da2->vram_display_mask);
+        da2->displine++;
+        // if (da2->interlace)
+        //     da2->displine++;
+        if ((da2->cgastat & 8) && ((da2->displine & 0xf) == (da2->crtc[LC_VERTICAL_SYNC_END] & 0xf)) && da2->vslines) {
+            // da2_log("Vsync off at line %i\n",displine);
+            da2->cgastat &= ~8;
+        }
+        da2->vslines++;
+        if (da2->displine > 1200)
+            da2->displine = 0;
+        // da2_log("Col is %08X %08X %08X   %i %i  %08X\n",((uint32_t *)buffer32->line[displine])[320],((uint32_t *)buffer32->line[displine])[321],((uint32_t *)buffer32->line[displine])[322],
+        // displine, vc, ma);
+    } else {
+        // da2_log("VC %i ma %05X\n", da2->vc, da2->ma);
+        timer_advance_u64(&da2->timer, da2->dispontime);
+
+        // if (output) printf("Display on %f\n",vidtime);
+        if (da2->dispon)
+            da2->cgastat &= ~1;
+        da2->hdisp_on = 0;
+
+        da2->linepos = 0;
+        if (da2->sc == (da2->crtc[LC_CURSOR_ROW_END] & 31))
+            da2->con = 0;
+        if (da2->dispon) {
+            if (da2->sc == da2->rowcount) {
+                da2->linecountff = 0;
+                da2->sc          = 0;
+
+                da2->maback += (da2->rowoffset << 1); /*   color = 0x50(80), mono = 0x40(64) */
+                if (da2->interlace)
+                    da2->maback += (da2->rowoffset << 1);
+                da2->maback &= da2->vram_display_mask;
+                da2->ma = da2->maback;
+            } else {
+                da2->sc++;
+                da2->sc &= 31;
+                da2->ma = da2->maback;
+            }
+        }
+
+        da2->vc++;
+        da2->vc &= 2047;
+
+        if (da2->vc == da2->dispend) {
+            da2->dispon = 0;
+            // if (da2->crtc[10] & 0x20) da2->cursoron = 0;
+            // else da2->cursoron = da2->blink & 16;
+            if (da2->ioctl[LS_MODE] & 1) {                /* in text mode */
+                if (da2->attrc[LV_CURSOR_CONTROL] & 0x01) /* cursor blinking */
+                {
+                    da2->cursoron = (da2->blink | 1) & da2->blinkconf;
+                } else {
+                    da2->cursoron = 0;
+                }
+                if (!(da2->blink & (0x10 - 1))) /* force redrawing for cursor and blink attribute */
+                    da2->fullchange = 2;
+            }
+            da2->blink++;
+
+            for (x = 0; x < ((da2->vram_mask + 1) >> 12); x++) {
+                if (da2->changedvram[x])
+                    da2->changedvram[x]--;
+            }
+            // memset(changedvram,0,2048);  del
+            if (da2->fullchange) {
+                da2->fullchange--;
+            }
+        }
+        if (da2->vc == da2->vsyncstart) {
+            int wx, wy;
+            // da2_log("VC vsync  %i %i\n", da2->firstline_draw, da2->lastline_draw);
+            da2->dispon = 0;
+            da2->cgastat |= 8;
+            x = da2->hdisp;
+
+            // if (da2->interlace && !da2->oddeven) da2->lastline++;
+            // if (da2->interlace && da2->oddeven) da2->firstline--;
+
+            wx = x;
+            wy = da2->lastline - da2->firstline;
+
+            da2_doblit(da2->firstline_draw, da2->lastline_draw + 1, wx, wy, da2);
+
+            da2->firstline = 2000;
+            da2->lastline  = 0;
+
+            da2->firstline_draw = 2000;
+            da2->lastline_draw  = 0;
+
+            da2->oddeven ^= 1;
+
+            changeframecount = da2->interlace ? 3 : 2;
+            da2->vslines     = 0;
+
+            // if (da2->interlace && da2->oddeven) da2->ma = da2->maback = da2->ma_latch + (da2->rowoffset << 1) + ((da2->crtc[5] & 0x60) >> 5);
+            // else                                  da2->ma = da2->maback = da2->ma_latch + ((da2->crtc[5] & 0x60) >> 5);
+            // da2->ca = ((da2->crtc[0xe] << 8) | da2->crtc[0xf]) + ((da2->crtc[0xb] & 0x60) >> 5) + da2->ca_adj;
+            /*            if (da2->interlace && da2->oddeven) da2->ma = da2->maback = da2->ma_latch;
+                        else*/
+            da2->ma
+                = da2->maback = da2->ma_latch;
+            da2->ca           = ((da2->crtc[LC_CURSOR_LOC_HIGH] << 8) | da2->crtc[LC_CURSOR_LOC_LOWJ]) + da2->ca_adj;
+
+            da2->ma <<= 1;
+            da2->maback <<= 1;
+            da2->ca <<= 1;
+
+            // da2_log("Addr %08X vson %03X vsoff %01X  %02X %02X %02X %i %i\n",ma,da2_vsyncstart,crtc[0x11]&0xF,crtc[0xD],crtc[0xC],crtc[0x33], da2_interlace, oddeven);
+        }
+        if (da2->vc == da2->vtotal) {
+            // da2_log("VC vtotal\n");
+            // printf("Frame over at line %i %i  %i %i\n",displine,vc,da2_vsyncstart,da2_dispend);
+            da2->vc          = 0;
+            da2->sc          = da2->crtc[LC_PRESET_ROW_SCANJ] & 0x1f;
+            da2->dispon      = 1;
+            da2->displine    = (da2->interlace && da2->oddeven) ? 1 : 0;
+            da2->scrollcache = da2->attrc[LV_PANNING] & 7;
+        }
+        if (da2->sc == (da2->crtc[LC_CURSOR_ROW_START] & 31))
+            da2->con = 1;
+    }
+    // printf("2 %i\n",da2_vsyncstart);
+    // da2_log("da2_poll %i %i %i %i %i  %i %i\n", ins, da2->dispofftime, da2->dispontime, da2->vidtime, cyc_total, da2->linepos, da2->vc);
+    // da2_log("r");
+}
+
+static void
+da2_loadfont(char *fname, void *p)
+{
+    da2_t  *da2 = (da2_t *) p;
+    uint8_t buf;
+    // uint32_t code = 0;
+    uint64_t fsize;
+    if (!fname)
+        return;
+    if (*fname == '\0')
+        return;
+    FILE *mfile = rom_fopen(fname, "rb");
+    if (!mfile) {
+        // da2_log("MSG: Can't open binary ROM font file: %s\n", fname);
+        return;
+    }
+    fseek(mfile, 0, SEEK_END);
+    fsize = ftell(mfile); /* get filesize */
+    fseek(mfile, 0, SEEK_SET);
+    if (fsize > DA2_FONTROM_SIZE) {
+        fsize = DA2_FONTROM_SIZE; /* truncate read data */
+        // da2_log("MSG: The binary ROM font is truncated: %s\n", fname);
+        // fclose(mfile);
+        // return 1;
+    }
+    uint32_t j = 0;
+    while (ftell(mfile) < fsize) {
+        fread(&buf, sizeof(uint8_t), 1, mfile);
+        da2->mmio.font[j] = buf;
+        j++;
+    }
+    fclose(mfile);
+    return;
+}
+
+/* 12-bit DAC color palette for IBMJ Display Adapter with color monitor */
+static uint8_t ps55_palette_color[64][3] = {
+    { 0x00, 0x00, 0x00 },    { 0x00, 0x00, 0x2A },    { 0x00, 0x2A, 0x00 },    { 0x00, 0x2A, 0x2A },
+    { 0x2A, 0x00, 0x00 },    { 0x2A, 0x00, 0x2A },    { 0x2A, 0x2A, 0x00 },    { 0x2A, 0x2A, 0x2A },
+    { 0x00, 0x00, 0x15 },    { 0x00, 0x00, 0x3F },    { 0x00, 0x2A, 0x15 },    { 0x00, 0x2A, 0x3F },
+    { 0x2A, 0x00, 0x15 },    { 0x2A, 0x00, 0x3F },    { 0x2A, 0x2A, 0x15 },    { 0x2A, 0x2A, 0x3F },
+    { 0x00, 0x15, 0x00 },    { 0x00, 0x15, 0x2A },    { 0x00, 0x3F, 0x00 },    { 0x00, 0x3F, 0x2A },
+    { 0x2A, 0x15, 0x00 },    { 0x2A, 0x15, 0x2A },    { 0x2A, 0x3F, 0x00 },    { 0x2A, 0x3F, 0x2A },
+    { 0x00, 0x15, 0x15 },    { 0x00, 0x15, 0x3F },    { 0x00, 0x3F, 0x15 },    { 0x00, 0x3F, 0x3F },
+    { 0x2A, 0x15, 0x15 },    { 0x2A, 0x15, 0x3F },    { 0x2A, 0x3F, 0x15 },    { 0x2A, 0x3F, 0x3F },
+    { 0x15, 0x00, 0x00 },    { 0x15, 0x00, 0x2A },    { 0x15, 0x2A, 0x00 },    { 0x15, 0x2A, 0x2A },
+    { 0x3F, 0x00, 0x00 },    { 0x3F, 0x00, 0x2A },    { 0x3F, 0x2A, 0x00 },    { 0x3F, 0x2A, 0x2A },
+    { 0x15, 0x00, 0x15 },    { 0x15, 0x00, 0x3F },    { 0x15, 0x2A, 0x15 },    { 0x15, 0x2A, 0x3F },
+    { 0x3F, 0x00, 0x15 },    { 0x3F, 0x00, 0x3F },    { 0x3F, 0x2A, 0x15 },    { 0x3F, 0x2A, 0x3F },
+    { 0x15, 0x15, 0x00 },    { 0x15, 0x15, 0x2A },    { 0x15, 0x3F, 0x00 },    { 0x15, 0x3F, 0x2A },
+    { 0x3F, 0x15, 0x00 },    { 0x3F, 0x15, 0x2A },    { 0x3F, 0x3F, 0x00 },    { 0x3F, 0x3F, 0x2A },
+    { 0x15, 0x15, 0x15 },    { 0x15, 0x15, 0x3F },    { 0x15, 0x3F, 0x15 },    { 0x15, 0x3F, 0x3F },
+    { 0x3F, 0x15, 0x15 },    { 0x3F, 0x15, 0x3F },    { 0x3F, 0x3F, 0x15 },    { 0x3F, 0x3F, 0x3F }
+};
+
+void
+da2_reset_ioctl(da2_t *da2)
+{
+    da2->ioctl[LS_RESET] = 0x00;     /* Bit 0: Reset sequencer */
+    da2_outw(LS_INDEX, 0x0302, da2); /* Index 02, Bit 1: VGA passthrough, Bit 0: Character Mode */
+    da2_outw(LS_INDEX, 0x0008, da2); /* Index 08, Bit 0: Enable MMIO */
+}
+
+static void
+da2_reset(void *priv)
+{
+    da2_t *da2 = (da2_t *) priv;
+
+    /* Initialize drawing */
+    da2->bitblt.exec = DA2_BLT_CIDLE;
+    da2->render      = da2_render_blank;
+    da2_reset_ioctl(da2);
+
+    da2->pos_regs[0]       = DA2_POSID_L;                    /* Adapter Identification Byte (Low byte) */
+    da2->pos_regs[1]       = DA2_POSID_H;                    /* Adapter Identification Byte (High byte) */
+    da2->pos_regs[2]       = 0x40;                           /* Bit 7-5: 010=Mono, 100=Color, Bit 0 : Card Enable (they are changed by system software) */
+    da2->ioctl[LS_CONFIG1] = OldLSI | Page_Two;              /* Configuration 1 : DA-II, 1024 KB */
+    da2->ioctl[LS_CONFIG1] |= ((da2->monitorid & 0x8) << 1); /* Configuration 1 : Monitor ID 3 */
+    da2->ioctl[LS_CONFIG2]         = (da2->monitorid & 0x7); /* Configuration 2: Monitor ID 0-2 */
+    da2->fctl[0]                   = 0x2b;                   /* 3E3h:0 */
+    da2->fctl[LF_MMIO_MODE]        = 0xb0;                   /* 3E3h:0bh */
+    da2->attrc[LV_CURSOR_COLOR]    = 0x0f;                   /* cursor color */
+    da2->crtc[LC_HORIZONTAL_TOTAL] = 63;                     /* Horizontal Total */
+    da2->crtc[LC_VERTICAL_TOTALJ]  = 255;                    /* Vertical Total (These two must be set before the timer starts.) */
+    da2->ma_latch                  = 0;
+    da2->interlace                 = 0;
+    da2->attrc[LV_CURSOR_CONTROL]  = 0x13; /* cursor options */
+    da2->attr_palette_enable       = 0;    /* disable attribute generator */
+
+    /* Set default color palette (Windows 3.1 display driver won't reset palette) */
+    for (int i = 0; i < 256; i++) {
+        da2->vgapal[i].r = ps55_palette_color[i & 0x3F][0];
+        da2->vgapal[i].g = ps55_palette_color[i & 0x3F][1];
+        da2->vgapal[i].b = ps55_palette_color[i & 0x3F][2];
+        da2->pallook[i]  = makecol32((da2->vgapal[i].r & 0x3f) * 4, (da2->vgapal[i].g & 0x3f) * 4, (da2->vgapal[i].b & 0x3f) * 4);
+    }
+    da2_log("da2_reset done.\n");
+}
+
+static void *
+da2_init(UNUSED(const device_t *info))
+{
+    if (svga_get_pri() == NULL)
+        return NULL;
+    svga_t *mb_vga          = svga_get_pri();
+    mb_vga->cable_connected = 0;
+
+    da2_t *da2  = malloc(sizeof(da2_t));
+    da2->mb_vga = mb_vga;
+
+    da2->dispontime        = 1000ull << 32;
+    da2->dispofftime       = 1000ull << 32;
+    int memsize            = 1024 * 1024;
+    da2->vram              = malloc(memsize);
+    da2->vram_mask         = memsize - 1;
+    da2->cram              = malloc(0x1000);
+    da2->vram_display_mask = DA2_MASK_CRAM;
+    da2->changedvram       = malloc(/*(memsize >> 12) << 1*/ 0x1000000 >> 12); /* XX000h */
+    da2->monitorid         = device_get_config_int("montype");                 /* Configuration for Monitor ID (aaaa) -> (xxax xxxx, xxxx xaaa) */
+
+    da2->mmio.charset = device_get_config_int("charset");
+    da2->mmio.font    = malloc(DA2_FONTROM_SIZE);
+    switch (da2->mmio.charset) {
+        case DA2_DCONFIG_CHARSET_HANT:
+            da2_loadfont(DA2_FONTROM_PATH_HANT, da2);
+            break;
+        case DA2_DCONFIG_CHARSET_JPAN:
+            da2_loadfont(DA2_FONTROM_PATH_JPAN, da2);
+            /* Add magic code for OS/2 J1.3. This disables BitBlt's text drawing function. */
+            da2->mmio.font[0x1AFFE] = 0x80;
+            da2->mmio.font[0x1AFFF] = 0x01;
+            break;
+    }
+
+    mca_add(da2_mca_read, da2_mca_write, da2_mca_feedb, da2_mca_reset, da2);
+    da2->da2const = (uint64_t) ((cpuclock / DA2_PIXELCLOCK) * (float) (1ull << 32));
+    memset(da2->bitblt.payload, 0x00, DA2_BLT_MEMSIZE);
+    memset(da2->bitblt.reg, 0xfe, DA2_BLT_REGSIZE * sizeof(uint32_t)); /* clear memory */
+#ifdef ENABLE_DA2_DEBUGBLT
+    da2->bitblt.debug_reg    = malloc(DA2_DEBUG_BLTLOG_MAX * DA2_DEBUG_BLTLOG_SIZE);
+    da2->mmdbg_fp            = fopen("da2_mmiowdat.txt", "w");
+    da2->mmrdbg_fp           = fopen("da2_mmiordat.txt", "w");
+    da2->bitblt.debug_reg_ip = 0;
+#endif
+    da2->bitblt.payload_addr = 0;
+    da2_reset(da2);
+
+    mem_mapping_add(&da2->mmio.mapping, 0xA0000, 0x20000, da2_mmio_read, da2_mmio_readw, NULL, da2_mmio_write, da2_mmio_writew, NULL, NULL, MEM_MAPPING_EXTERNAL, da2);
+    // da2_log("DA2mmio new mapping: %X, base: %x, size: %x\n", &da2->mmio.mapping, da2->mmio.mapping.base, da2->mmio.mapping.size);
+
+    mem_mapping_disable(&da2->mmio.mapping);
+
+    mem_mapping_add(&da2->cmapping, 0xE0000, 0x1000, da2_code_readb, da2_code_readw, NULL, da2_code_writeb, da2_code_writew, NULL, NULL, MEM_MAPPING_EXTERNAL, da2);
+
+    mem_mapping_disable(&da2->cmapping);
+
+    timer_add(&da2->timer, da2_poll, da2, 0);
+    da2->bitblt.timerspeed = 1 * TIMER_USEC;
+    timer_add(&da2->bitblt.timer, da2_bitblt_dopayload, da2, 0);
+
+    return da2;
+}
+static int
+da2_available(void)
+{
+    return (rom_present(DA2_FONTROM_PATH_HANT) || rom_present(DA2_FONTROM_PATH_JPAN));
+}
+
+void
+da2_close(void *p)
+{
+    da2_t *da2 = (da2_t *) p;
+
+    /* dump mem for debug */
+#ifdef ENABLE_DA2_LOG
+    FILE *f;
+    f = fopen("da2_cram.dmp", "wb");
+    if (f != NULL) {
+        fwrite(da2->cram, 0x1000, 1, f);
+        fclose(f);
+    }
+    f = fopen("da2_vram.dmp", "wb");
+    if (f != NULL) {
+        fwrite(da2->vram, 1024 * 1024, 1, f);
+        fclose(f);
+    }
+    f = fopen("da2_gram.dmp", "wb");
+    if (f != NULL) {
+        fwrite(da2->mmio.ram, 256 * 1024, 1, f);
+        fclose(f);
+    }
+    f = fopen("da2_attrpal.dmp", "wb");
+    if (f != NULL) {
+        fwrite(da2->attrc, 32, 1, f);
+        fclose(f);
+    }
+    f = fopen("da2_dacrgb.dmp", "wb");
+    if (f != NULL) {
+        fwrite(da2->vgapal, 3 * 256, 1, f);
+        fclose(f);
+    }
+    f = fopen("da2_daregs.txt", "w");
+    if (f != NULL) {
+        for (int i = 0; i < 0x10; i++)
+            fprintf(f, "3e1(ioctl) %02X: %4X\n", i, da2->ioctl[i]);
+        for (int i = 0; i < 0x20; i++)
+            fprintf(f, "3e3(fctl)  %02X: %4X\n", i, da2->fctl[i]);
+        for (int i = 0; i < 0x20; i++)
+            fprintf(f, "3e5(crtc)  %02X: %4X\n", i, da2->crtc[i]);
+        for (int i = 0; i < 0x40; i++)
+            fprintf(f, "3e8(attr)  %02X: %4X\n", i, da2->attrc[i]);
+        for (int i = 0; i < 0x10; i++)
+            fprintf(f, "3eb(gcr)   %02X: %4X\n", i, da2->gdcreg[i]);
+        for (int i = 0; i < 0x10; i++)
+            fprintf(f, "3ee(?)     %02X: %4X\n", i, da2->reg3ee[i]);
+        fclose(f);
+    }
+#endif
+#ifdef ENABLE_DA2_DEBUGBLT
+    f = fopen("da2_bltdump.csv", "w");
+    if (f != NULL && da2->bitblt.debug_reg_ip > 0) {
+        /* print header */
+        for (int y = 0; y < DA2_DEBUG_BLTLOG_SIZE; y++) {
+            if (da2->bitblt.debug_reg[(da2->bitblt.debug_reg_ip - 1) * DA2_DEBUG_BLTLOG_SIZE + y] != DA2_DEBUG_BLT_NEVERUSED)
+                fprintf(f, "\"%02X\"\t", y);
+        }
+        fprintf(f, "\n");
+        /* print data */
+        for (int x = 0; x < da2->bitblt.debug_reg_ip; x++) {
+            for (int y = 0; y < DA2_DEBUG_BLTLOG_SIZE; y++) {
+                if (da2->bitblt.debug_reg[x * DA2_DEBUG_BLTLOG_SIZE + y] == DA2_DEBUG_BLT_NEVERUSED)
+                    ;
+                else if (da2->bitblt.debug_reg[x * DA2_DEBUG_BLTLOG_SIZE + y] == DA2_DEBUG_BLT_USEDRESET)
+                    fprintf(f, "\"\"\t");
+                else
+                    fprintf(f, "\"%X\"\t", da2->bitblt.debug_reg[x * DA2_DEBUG_BLTLOG_SIZE + y]);
+            }
+            fprintf(f, "\n");
+        }
+        fclose(f);
+    }
+    if (da2->mmdbg_fp != NULL)
+        fclose(da2->mmdbg_fp);
+    if (da2->mmrdbg_fp != NULL)
+        fclose(da2->mmrdbg_fp);
+    free(da2->bitblt.debug_reg);
+#endif
+    free(da2->cram);
+    free(da2->vram);
+    free(da2->changedvram);
+    free(da2->mmio.font);
+    free(da2);
+}
+
+void
+da2_speed_changed(void *p)
+{
+    da2_t *da2    = (da2_t *) p;
+    da2->da2const = (uint64_t) ((cpuclock / DA2_PIXELCLOCK) * (float) (1ull << 32));
+    da2_recalctimings(da2);
+}
+
+void
+da2_force_redraw(void *p)
+{
+    da2_t *da2      = (da2_t *) p;
+    da2->fullchange = changeframecount;
+}
+
+static const device_config_t da2_configuration[] = {
+    // clang-format off
+    {
+        .name = "charset",
+        .description = "Charset",
+        .type = CONFIG_SELECTION,
+        .default_int = DA2_DCONFIG_CHARSET_JPAN,
+        .selection = {
+            {
+                .description = "932 (Japanese)",
+                .value = DA2_DCONFIG_CHARSET_JPAN
+            },
+            {
+                .description = "938 (Traditional Chinese)",
+                .value = DA2_DCONFIG_CHARSET_HANT
+            },
+            { .description = "" }
+        }
+    },
+    {
+        .name = "montype",
+        .description = "Monitor type",
+        .type = CONFIG_SELECTION,
+        .default_int = DA2_DCONFIG_MONTYPE_COLOR,
+        .selection = {
+            {
+                .description = "Color",
+                .value = DA2_DCONFIG_MONTYPE_COLOR
+            },
+            {
+                .description = "IBM 8515",
+                .value = DA2_DCONFIG_MONTYPE_8515
+            },
+            {
+                .description = "Grayscale",
+                .value = DA2_DCONFIG_MONTYPE_MONO
+            },
+            { .description = "" }
+        }
+    },
+    { .name = "", .description = "", .type = CONFIG_END }
+    // clang-format on
+};
+
+const device_t ps55da2_device = {
+    .name          = "IBM Display Adapter II (MCA)",
+    .internal_name = "ps55da2",
+    .flags         = DEVICE_MCA,
+    .local         = 0,
+    .init          = da2_init,
+    .close         = da2_close,
+    .reset         = da2_reset,
+    .available     = da2_available,
+    .speed_changed = da2_speed_changed,
+    .force_redraw  = da2_force_redraw,
+    .config        = da2_configuration
+};
+
+void
+da2_device_add(void)
+{
+    if (!da2_standalone_enabled)
+        return;
+
+    if (machine_has_bus(machine, MACHINE_BUS_MCA))
+        device_add(&ps55da2_device);
+    else
+        return;
+}
diff --git a/src/video/vid_svga.c b/src/video/vid_svga.c
index 7c674e00a..caa20e196 100644
--- a/src/video/vid_svga.c
+++ b/src/video/vid_svga.c
@@ -502,10 +502,25 @@ svga_in(uint16_t addr, void *priv)
             ret = svga->attrregs[svga->attraddr];
             break;
         case 0x3c2:
-            if ((svga->vgapal[0].r + svga->vgapal[0].g + svga->vgapal[0].b) >= 0x4e)
-                ret = 0;
-            else
-                ret = 0x10;
+            if (svga->cable_connected) {
+                if ((svga->vgapal[0].r + svga->vgapal[0].g + svga->vgapal[0].b) >= 0x4e)
+                    ret = 0;
+                else
+                    ret = 0x10;
+            /* Monitor is not connected to the planar VGA if the PS/55 Display Adapter is installed. */
+            } else {
+                /*
+                   The IBM PS/55 Display Adapter has own Monitor Type Detection bit in the different I/O port (I/O 3E0h, 3E1h).
+                   When the monitor cable is connected to the Display Adapter, the port 3C2h returns the value as 'no cable connection'.
+                   The POST of PS/55 has an extra code. If the monitor is not detected on the planar VGA,
+                   it reads the POS data in NVRAM set by the reference diskette, and writes the BIOS Data Area (Mem 487h, 489h).
+                   MONCHK.EXE in the reference diskette uses both I/O ports to determine the monitor type, updates the NVRAM and BDA.
+                */
+                if (svga->vgapal[0].r >= 10 || svga->vgapal[0].g >= 10 || svga->vgapal[0].b >= 10)
+                    ret = 0;
+                else
+                    ret = 0x10;
+            }
             break;
         case 0x3c3:
             ret = 0x01;
@@ -1526,6 +1541,8 @@ svga_init(const device_t *info, svga_t *svga, void *priv, int memsize,
     svga->dac_hwcursor.cur_xsize = svga->dac_hwcursor.cur_ysize = 32;
 
     svga->translate_address         = NULL;
+    
+    svga->cable_connected = 1;
     svga->ksc5601_english_font_type = 0;
 
     /* TODO: Move DEVICE_MCA to 16-bit once the device flags have been appropriately corrected. */
diff --git a/src/video/vid_table.c b/src/video/vid_table.c
index 9ff092161..ff3073c73 100644
--- a/src/video/vid_table.c
+++ b/src/video/vid_table.c
@@ -369,6 +369,8 @@ video_post_reset(void)
     if (xga_standalone_enabled)
         xga_device_add();
 
+    if (da2_standalone_enabled)
+        da2_device_add();
     /* Reset the graphics card (or do nothing if it was already done
        by the machine's init function). */
     video_reset(gfxcard[0]);
diff --git a/src/video/vid_vga.c b/src/video/vid_vga.c
index ad66192ac..97889e007 100644
--- a/src/video/vid_vga.c
+++ b/src/video/vid_vga.c
@@ -104,6 +104,37 @@ vga_in(uint16_t addr, void *priv)
     return temp;
 }
 
+void vga_disable(void* p)
+{
+    vga_t* vga = (vga_t*)p;
+    svga_t* svga = &vga->svga;
+
+    io_removehandler(0x03a0, 0x0040, vga_in, NULL, NULL, vga_out, NULL, NULL, vga);
+    mem_mapping_disable(&svga->mapping);
+    svga->vga_enabled = 0;
+}
+
+void vga_enable(void* p)
+{
+    vga_t* vga = (vga_t*)p;
+    svga_t* svga = &vga->svga;
+
+    io_sethandler(0x03c0, 0x0020, vga_in, NULL, NULL, vga_out, NULL, NULL, vga);
+    if (!(svga->miscout & 1))
+        io_sethandler(0x03a0, 0x0020, vga_in, NULL, NULL, vga_out, NULL, NULL, vga);
+
+    mem_mapping_enable(&svga->mapping);
+    svga->vga_enabled = 1;
+}
+
+int vga_isenabled(void* p)
+{
+    vga_t* vga = (vga_t*)p;
+    svga_t* svga = &vga->svga;
+
+    return svga->vga_enabled;
+}
+
 static void *
 vga_init(const device_t *info)
 {
@@ -150,6 +181,7 @@ ps1vga_init(const device_t *info)
 
     vga->svga.bpp     = 8;
     vga->svga.miscout = 1;
+    vga->svga.vga_enabled = 1;
 
     return vga;
 }