idac: improved compatibility with newer versions

Reviewed-on: Dniel97/segatools#17

board/io3.c

@@ -79,6 +79,11 @@ static HRESULT io3_cmd_read_analogs(
         struct const_iobuf *req_buf,
         struct iobuf *resp_buf);
 
+static HRESULT io3_cmd_read_rotarys(
+        struct io3 *io3,
+        struct const_iobuf *req_buf,
+        struct iobuf *resp_buf);
+
 static HRESULT io3_cmd_write_gpio(
         struct io3 *io3,
         struct const_iobuf *req_buf,
@@ -116,6 +121,13 @@ static uint8_t io3_features[] = {
 
     0x03, 8, 10, 0,
 
+    /* Feature : 0x04 : Rotary inputs
+       Param1  :    4 : Number of rotary channels
+       Param2  :    0 : N/A
+       Param3  :    0 : N/A */
+
+    0x04, 4, 0, 0,
+
     /* Feature : 0x12 : GPIO outputs
        Param1  :    3 : Number of ports (8 bits per port)
        Param2  :    0 : N/A
@@ -218,6 +230,9 @@ static HRESULT io3_cmd(
 
     case JVS_CMD_READ_ANALOGS:
         return io3_cmd_read_analogs(io3, req, resp);
+    
+    case JVS_CMD_READ_ROTARYS:
+        return io3_cmd_read_rotarys(io3, req, resp);
 
     case JVS_CMD_WRITE_GPIO:
         return io3_cmd_write_gpio(io3, req, resp);
@@ -536,6 +551,60 @@ static HRESULT io3_cmd_read_analogs(
 
 }
 
+static HRESULT io3_cmd_read_rotarys(
+        struct io3 *io3,
+        struct const_iobuf *req_buf,
+        struct iobuf *resp_buf)
+{
+    struct jvs_req_read_rotarys req;
+    uint16_t rotarys[4];
+    uint8_t i;
+    HRESULT hr;
+
+    /* Read req */
+
+    hr = iobuf_read(req_buf, &req, sizeof(req));
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+
+    if (req.nrotarys > _countof(rotarys)) {
+        dprintf("JVS I/O: Invalid analog count %i\n", req.nrotarys);
+
+        return E_FAIL;
+    }
+
+    //dprintf("JVS I/O: Read rotarys, nrotarys=%i\n", req.nrotarys);
+
+    /* Write report byte */
+
+    hr = iobuf_write_8(resp_buf, 0x01);
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+
+    /* Write analogs */
+
+    memset(rotarys, 0, sizeof(rotarys));
+
+    if (io3->ops->read_rotarys != NULL) {
+        io3->ops->read_rotarys(io3->ops_ctx, rotarys, req.nrotarys);
+    }
+
+    for (i = 0 ; i < req.nrotarys ; i++) {
+        hr = iobuf_write_be16(resp_buf, rotarys[i]);
+
+        if (FAILED(hr)) {
+            return hr;
+        }
+    }
+
+    return hr;
+
+}
+
 static HRESULT io3_cmd_write_gpio(
         struct io3 *io3,
         struct const_iobuf *req_buf,

board/io3.h

@@ -18,6 +18,7 @@ struct io3_ops {
     void (*write_gpio)(void *ctx, uint32_t state);
     void (*read_switches)(void *ctx, struct io3_switch_state *out);
     void (*read_analogs)(void *ctx, uint16_t *analogs, uint8_t nanalogs);
+    void (*read_rotarys)(void *ctx, uint16_t *rotaries, uint8_t nrotaries);
     void (*read_coin_counter)(void *ctx, uint8_t slot_no, uint16_t *out);
 };
 

board/io4.c

@@ -48,7 +48,7 @@ static_assert(sizeof(struct io4_report_in) == 0x40, "IO4 IN report size");
 struct io4_report_out {
     uint8_t report_id;
     uint8_t cmd;
-    uint8_t payload[62];
+    uint8_t payload[IO4_REPORT_OUT_PAYLOAD_LEN];
 };
 
 static_assert(sizeof(struct io4_report_out) == 0x40, "IO4 OUT report size");
@@ -223,7 +223,11 @@ static HRESULT io4_handle_write(struct irp *irp)
         return S_OK;
 
     case IO4_CMD_SET_GENERAL_OUTPUT:
-        dprintf("USB I/O: GPIO Out\n");
+        // dprintf("USB I/O: GPIO Out\n");
+
+        if (io4_ops->write_gpio != NULL) {
+            return io4_ops->write_gpio(out.payload, IO4_REPORT_OUT_PAYLOAD_LEN);
+        }
 
         return S_OK;
 

board/io4.h

@@ -4,6 +4,8 @@
 
 #include <stdint.h>
 
+#define IO4_REPORT_OUT_PAYLOAD_LEN 62
+
 enum {
     /* System buttons in button[0] */
 
@@ -24,6 +26,7 @@ struct io4_state {
 
 struct io4_ops {
     HRESULT (*poll)(void *ctx, struct io4_state *state);
+    HRESULT (*write_gpio)(uint8_t* payload, size_t len);
 };
 
 HRESULT io4_hook_init(

board/led15070-cmd.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "board/led15070-frame.h"
+
+/* Command IDs */
+
+enum {
+    LED_15070_CMD_RESET                     = 0x10,
+    LED_15070_CMD_SET_INPUT                 = 0x28, // No known use case
+    LED_15070_CMD_SET_NORMAL_12BIT          = 0x30, // TODO
+    LED_15070_CMD_SET_NORMAL_8BIT           = 0x31,
+    LED_15070_CMD_SET_MULTI_FLASH_8BIT      = 0x32,
+    LED_15070_CMD_SET_MULTI_FADE_8BIT       = 0x33,
+    LED_15070_CMD_SET_PALETTE_7_NORMAL_LED  = 0x34, // No known use case
+    LED_15070_CMD_SET_PALETTE_6_FLASH_LED   = 0x35, // No known use case
+    LED_15070_CMD_SET_15DC_OUT              = 0x36, // No known use case
+    LED_15070_CMD_SET_15GS_OUT              = 0x37, // No known use case
+    LED_15070_CMD_SET_PSC_MAX               = 0x38, // No known use case
+    LED_15070_CMD_SET_FET_OUTPUT            = 0x39,
+    LED_15070_CMD_SET_GS_PALETTE            = 0x3A,
+    LED_15070_CMD_DC_UPDATE                 = 0x3B,
+    LED_15070_CMD_GS_UPDATE                 = 0x3C,
+    LED_15070_CMD_ROTATE                    = 0x3E, // No known use case, wtf is this?
+    LED_15070_CMD_SET_DC_DATA               = 0x3F,
+    LED_15070_CMD_EEPROM_WRITE              = 0x7B,
+    LED_15070_CMD_EEPROM_READ               = 0x7C,
+    LED_15070_CMD_ACK_ON                    = 0x7D,
+    LED_15070_CMD_ACK_OFF                   = 0x7E,
+    LED_15070_CMD_BOARD_INFO                = 0xF0,
+    LED_15070_CMD_BOARD_STATUS              = 0xF1,
+    LED_15070_CMD_FW_SUM                    = 0xF2,
+    LED_15070_CMD_PROTOCOL_VER              = 0xF3,
+    LED_15070_CMD_TO_BOOT_MODE              = 0xFD,
+    LED_15070_CMD_FW_UPDATE                 = 0xFE,
+};
+
+/* Response codes */
+
+enum {
+    LED_15070_STATUS_OK                     = 0x01,
+    LED_15070_STATUS_SUM_ERR                = 0x02,
+    LED_15070_STATUS_PARITY_ERR             = 0x03,
+    LED_15070_STATUS_FRAMING_ERR            = 0x04,
+    LED_15070_STATUS_OVERRUN_ERR            = 0x05,
+    LED_15070_STATUS_BUFFER_OVERFLOW        = 0x06,
+};
+
+enum {
+    LED_15070_REPORT_OK                     = 0x01,
+    LED_15070_REPORT_WAIT                   = 0x02,
+    LED_15070_REPORT_ERR1                   = 0x03,
+    LED_15070_REPORT_ERR2                   = 0x04,
+};
+
+/* Request data structures */
+
+struct led15070_req_any {
+    struct led15070_hdr hdr;
+    uint8_t cmd;
+    uint8_t payload[256];
+};
+
+/* Response data structures */
+
+struct led15070_resp_any {
+    struct led15070_hdr hdr;
+    uint8_t status;
+    uint8_t cmd;
+    uint8_t report;
+    uint8_t data[32];
+};
+
+struct led15070_resp_board_info {
+    struct led15070_hdr hdr;
+    uint8_t status;
+    uint8_t cmd;
+    uint8_t report;
+    char board_num[8];
+    uint8_t endcode; // Always 0xFF
+    uint8_t fw_ver;
+};

board/led15070-frame.c

@@ -0,0 +1,194 @@
+#include <windows.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "board/led15070-frame.h"
+
+#include "hook/iobuf.h"
+
+static void led15070_frame_sync(struct iobuf *src);
+static HRESULT led15070_frame_accept(const struct iobuf *dest);
+static HRESULT led15070_frame_encode_byte(struct iobuf *dest, uint8_t byte);
+
+/* Frame structure:
+
+   [0] Sync byte (0xE0)
+   [1] Destination address
+   [2] Source Address
+   [3] Length of data/payload
+   [4] Data/payload
+        For requests (host to board):
+            [0] Command
+            ... Payload
+        For responses (board to host):
+            [0] Status
+            [1] Command
+            [2] Report
+            ... Payload
+   [n] Checksum: Sum of all prior bytes (excluding sync byte)
+
+   Byte stuffing:
+
+   0xD0 is an escape byte. Un-escape the subsequent byte by adding 1. */
+
+static void led15070_frame_sync(struct iobuf *src)
+{
+    size_t i;
+
+    for (i = 0 ; i < src->pos && src->bytes[i] != 0xE0 ; i++);
+
+    src->pos -= i;
+    memmove(&src->bytes[0], &src->bytes[i], i);
+}
+
+static HRESULT led15070_frame_accept(const struct iobuf *dest)
+{
+    uint8_t checksum;
+    size_t i;
+
+    if (dest->pos < 3 || dest->pos != dest->bytes[3] + 5) {
+        return S_FALSE;
+    }
+
+    checksum = 0;
+
+    for (i = 1 ; i < dest->pos - 1 ; i++) {
+        checksum += dest->bytes[i];
+    }
+    
+    //dprintf("LED checksum %02x, expected %02x\n", checksum, dest->bytes[dest->pos - 1]);
+    
+    if (checksum != dest->bytes[dest->pos - 1]) {
+        return HRESULT_FROM_WIN32(ERROR_CRC);
+    }
+
+    return S_OK;
+}
+
+HRESULT led15070_frame_decode(struct iobuf *dest, struct iobuf *src)
+{
+    uint8_t byte;
+    bool escape;
+    size_t i;
+    HRESULT hr;
+
+    assert(dest != NULL);
+    assert(dest->bytes != NULL || dest->nbytes == 0);
+    assert(dest->pos <= dest->nbytes);
+    assert(src != NULL);
+    assert(src->bytes != NULL || src->nbytes == 0);
+    assert(src->pos <= src->nbytes);
+
+    led15070_frame_sync(src);
+
+    dest->pos = 0;
+    escape = false;
+
+    for (i = 0, hr = S_FALSE ; i < src->pos && hr == S_FALSE ; i++) {
+        /* Step the FSM to unstuff another byte */
+
+        byte = src->bytes[i];
+
+        if (dest->pos >= dest->nbytes) {
+            hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+        } else if (i == 0) {
+            dest->bytes[dest->pos++] = byte;
+        } else if (byte == 0xE0) {
+            hr = E_FAIL;
+        } else if (byte == 0xD0) {
+            if (escape) {
+                hr = E_FAIL;
+            }
+
+            escape = true;
+        } else if (escape) {
+            dest->bytes[dest->pos++] = byte + 1;
+            escape = false;
+        } else {
+            dest->bytes[dest->pos++] = byte;
+        }
+
+        /* Try to accept the packet we've built up so far */
+
+        if (SUCCEEDED(hr)) {
+            hr = led15070_frame_accept(dest);
+        }
+    }
+
+    /* Handle FSM terminal state */
+
+    if (hr != S_FALSE) {
+        /* Frame was either accepted or rejected, remove it from src */
+        memmove(&src->bytes[0], &src->bytes[i], src->pos - i);
+        src->pos -= i;
+    }
+
+    return hr;
+}
+
+HRESULT led15070_frame_encode(
+        struct iobuf *dest,
+        const void *ptr,
+        size_t nbytes)
+{
+    const uint8_t *src;
+    uint8_t checksum;
+    uint8_t byte;
+    size_t i;
+    HRESULT hr;
+
+    assert(dest != NULL);
+    assert(dest->bytes != NULL || dest->nbytes == 0);
+    assert(dest->pos <= dest->nbytes);
+    assert(ptr != NULL);
+
+    src = ptr;
+
+    assert(nbytes >= 3 && src[0] == 0xE0 && src[3] + 4 == nbytes);
+
+    if (dest->pos >= dest->nbytes) {
+        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+    }
+
+    dest->bytes[dest->pos++] = 0xE0;
+    checksum = 0;
+    // dprintf("%02x ", 0xe0);
+
+    for (i = 1 ; i < nbytes ; i++) {
+        byte = src[i];
+        checksum += byte;
+        // dprintf("%02x ", byte);
+
+        hr = led15070_frame_encode_byte(dest, byte);
+
+        if (FAILED(hr)) {
+            return hr;
+        }
+    }
+    // dprintf("%02x \n", checksum);
+
+    return led15070_frame_encode_byte(dest, checksum);
+}
+
+static HRESULT led15070_frame_encode_byte(struct iobuf *dest, uint8_t byte)
+{
+    if (byte == 0xE0 || byte == 0xD0) {
+        if (dest->pos + 2 > dest->nbytes) {
+            return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+        }
+
+        dest->bytes[dest->pos++] = 0xD0;
+        dest->bytes[dest->pos++] = byte - 1;
+    } else {
+        if (dest->pos + 1 > dest->nbytes) {
+            return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+        }
+
+        dest->bytes[dest->pos++] = byte;
+    }
+
+    return S_OK;
+}

board/led15070-frame.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <windows.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hook/iobuf.h"
+
+enum {
+    LED_15070_FRAME_SYNC = 0xE0,
+};
+
+struct led15070_hdr {
+    uint8_t sync;
+    uint8_t dest_adr;
+    uint8_t src_adr;
+    uint8_t nbytes;
+};
+
+HRESULT led15070_frame_decode(struct iobuf *dest, struct iobuf *src);
+
+HRESULT led15070_frame_encode(
+        struct iobuf *dest,
+        const void *ptr,
+        size_t nbytes);

board/led15070.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <windows.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct led15070_config {
+    bool enable;
+    unsigned int port_no;
+    char board_number[8];
+    uint8_t fw_ver;
+    uint16_t fw_sum;
+    wchar_t eeprom_path[MAX_PATH];
+};
+
+typedef HRESULT (*io_led_init_t)(void);
+typedef void (*io_led_set_fet_output_t)(const uint8_t *rgb);
+typedef void (*io_led_dc_update_t)(const uint8_t *rgb);
+typedef void (*io_led_gs_update_t)(const uint8_t *rgb);
+
+HRESULT led15070_hook_init(
+        const struct led15070_config *cfg,
+        io_led_init_t _led_init,
+        io_led_set_fet_output_t _led_set_fet_output,
+        io_led_dc_update_t _led_dc_update,
+        io_led_gs_update_t _led_gs_update,
+        unsigned int first_port,
+        unsigned int num_boards);

board/meson.build

@@ -25,6 +25,11 @@ board_lib = static_library(
         'led15093-frame.h',
         'led15093.c',
         'led15093.h',
+        'led15070-cmd.h',
+        'led15070-frame.c',
+        'led15070-frame.h',
+        'led15070.c',
+        'led15070.h',
         'sg-cmd.c',
         'sg-cmd.h',
         'sg-frame.c',

carolhook/dllmain.c

@@ -1,3 +1,31 @@
+/*
+    "Wonderland Wars" (carol*) hook
+
+    Devices:
+
+    JVS:    837-14572 "Type 3" I/O Board
+
+    [Satellite]
+
+    USB:    "WinTouch" Controller Board
+                ^ (DIPSW2 ON, Version 5.xx.xx or above)
+    COM1:   3M Touch Systems 78-0011-2353-4 Touch Controller Board
+                ^ (DIPSW2 OFF)
+    COM10:  TN32MSEC003S "Gen 1" Aime Reader
+            OR
+            837-15286 "Gen 2" Aime Reader
+                ^ (Version 1.6x.xx or above)
+    COM11:  837-15070-02 LED Controller Board
+    COM12:  837-15312 Pen Controller I/O Board
+
+    [Terminal]
+
+    COM10:  837-15286 "Gen 2" Aime Reader
+
+    *: SEGA's abbreviation for Lewis Carroll, author of Alice's Adventures in
+    Wonderland.
+*/
+
 #include <windows.h>
 
 #include <stdlib.h>

chunihook/dllmain.c

@@ -1,3 +1,15 @@
+/*
+    "CHUNITHM" (chuni) hook
+
+    Devices
+
+    JVS:    837-14572 "Type 3" I/O Board
+    COM1:   837-15330 Ground Slider
+    COM10:  837-15093-06 LED Controller Board
+    COM11:  837-15093-06 LED Controller Board
+    COM12:  TN32MSEC003S "Gen 1" Aime Reader
+*/
+
 #include <windows.h>
 
 #include <stdlib.h>

chuniio/chuniio.h

@@ -163,9 +163,17 @@ HRESULT chuni_io_led_init(void);
    Chunithm uses two chains/boards with WS2811 protocol (each logical led corresponds to 3 physical leds). 
    board 0 is on the left side and board 1 on the right side of the cab
 
-   left side has 5*10 rgb values for the billboard, followed by 3 rgb values for the air tower
+   Board 0 has 53 LEDs:
-   right side has 6*10 rgb values for the billboard, followed by 3 rgb values for the air tower
+     [0]-[49]: snakes through left half of billboard (first column starts at top)
+     [50]-[52]: left side partition LEDs
    
+   Board 1 has 63 LEDs:
+     [0]-[59]: right half of billboard (first column starts at bottom)
+     [60]-[62]: right side partition LEDs
+   
+   Board 2 is the slider and has 31 LEDs:
+     [0]-[31]: slider LEDs right to left BRG, alternating between keys and dividers 
+
    Each rgb value is comprised of 3 bytes in R,G,B order
 
    NOTE: billboard strips have alternating direction (bottom to top, top to bottom, ...)

chuniio/config.c

@@ -57,11 +57,11 @@ void chuni_io_config_load(
                 filename);
     }
 
-    cfg->led_output_pipe = GetPrivateProfileIntW(L"led", L"cabLedOutputPipe", 1, filename);
+    cfg->cab_led_output_pipe = GetPrivateProfileIntW(L"led", L"cabLedOutputPipe", 1, filename);
-    cfg->led_output_serial = GetPrivateProfileIntW(L"led", L"cabLedOutputSerial", 0, filename);
+    cfg->cab_led_output_serial = GetPrivateProfileIntW(L"led", L"cabLedOutputSerial", 0, filename);
     
-    cfg->slider_led_output_pipe = GetPrivateProfileIntW(L"led", L"controllerLedOutputPipe", 1, filename);
+    cfg->controller_led_output_pipe = GetPrivateProfileIntW(L"led", L"controllerLedOutputPipe", 1, filename);
-    cfg->slider_led_output_serial = GetPrivateProfileIntW(L"led", L"controllerLedOutputSerial", 0, filename);
+    cfg->controller_led_output_serial = GetPrivateProfileIntW(L"led", L"controllerLedOutputSerial", 0, filename);
 
     cfg->led_serial_baud = GetPrivateProfileIntW(L"led", L"serialBaud", 921600, filename);
 
@@ -70,7 +70,7 @@ void chuni_io_config_load(
             L"serialPort",
             L"COM5",
             port_input,
-            6,
+            _countof(port_input),
             filename);
 
     // Sanitize the output path. If it's a serial COM port, it needs to be prefixed

chuniio/config.h

@@ -12,16 +12,15 @@ struct chuni_io_config {
     uint8_t vk_cell[32];
 
     // Which ways to output LED information are enabled
-    bool led_output_pipe;
+    bool cab_led_output_pipe;
-    bool led_output_serial;
+    bool cab_led_output_serial;
     
-    bool slider_led_output_pipe;
+    bool controller_led_output_pipe;
-    bool slider_led_output_serial;
+    bool controller_led_output_serial;
 
     // The name of a COM port to output LED data on, in serial mode
     wchar_t led_serial_port[12];
     int32_t led_serial_baud;
-
 };
 
 void chuni_io_config_load(

chuniio/ledoutput.c

@@ -48,15 +48,15 @@ HRESULT led_output_init(struct chuni_io_config* const cfg)
             led_escaped_buf[i].data_len = chuni_led_board_data_lens[i];
         }
         
-        any_outputs_enabled = config->led_output_pipe || config->slider_led_output_pipe
+        any_outputs_enabled = config->cab_led_output_pipe || config->controller_led_output_pipe
-            || config->led_output_serial || config->slider_led_output_serial;
+            || config->cab_led_output_serial || config->controller_led_output_serial;
         
-        if (config->led_output_pipe || config->slider_led_output_pipe)
+        if (config->cab_led_output_pipe || config->controller_led_output_pipe)
         {
             led_pipe_init();  // don't really care about errors here tbh
         }
         
-        if (config->led_output_serial || config->slider_led_output_serial)
+        if (config->cab_led_output_serial || config->controller_led_output_serial)
         {
             led_serial_init(config->led_serial_port, config->led_serial_baud);
         }
@@ -106,13 +106,13 @@ void led_output_update(uint8_t board, const byte* rgb)
     
     if (board < 2)
     {
-        // billboard
+        // billboard (cab)
-        if (config->led_output_pipe)
+        if (config->cab_led_output_pipe)
         {
             led_pipe_update(escaped_data);
         }
         
-        if (config->led_output_serial)
+        if (config->cab_led_output_serial)
         {
             led_serial_update(escaped_data);
         }
@@ -120,12 +120,12 @@ void led_output_update(uint8_t board, const byte* rgb)
     else
     {
         // slider
-        if (config->slider_led_output_pipe)
+        if (config->controller_led_output_pipe)
         {
             led_pipe_update(escaped_data);
         }
         
-        if (config->slider_led_output_serial)
+        if (config->controller_led_output_serial)
         {
             led_serial_update(escaped_data);
         }

chuniio/pipeimpl.h

@@ -4,6 +4,7 @@
     Credits:
     somewhatlurker, skogaby
 */
+
 #pragma once
 
 #include <windows.h>

chusanhook/chuni-dll.c

@@ -170,7 +170,7 @@ HRESULT chuni_dll_init(const struct chuni_dll_config *cfg, HINSTANCE self)
                         "\"%s\". Please contact your IO DLL's developer for "
                         "further assistance.\n",
                         sym->sym);
-                dprintf("imported %d symbols\n",bind_count);
+                dprintf("imported %d symbols\n", bind_count);
                 goto end;
             }
         } else {

chusanhook/dllmain.c

@@ -1,3 +1,27 @@
+/*
+    "CHUNITHM NEW" (chusan) hook
+
+    Devices
+
+    USB:    837-15257-02 "Type 4" I/O Board
+    COM1:   837-15330 Ground Slider
+
+    [CVT mode (DIPSW2 ON)]
+
+    COM2:   837-15093-06 LED Controller Board
+    COM3:   837-15093-06 LED Controller Board
+    COM4:   837-15286 "Gen 2" Aime Reader
+
+    [SP mode (DIPSW2 OFF)]
+
+    USB:    837-15067-02 USB Serial I/F Board
+            connected to
+            837-15093-06 LED Controller Board (COM20)
+            837-15093-06 LED Controller Board (COM21)
+    COM2:   200-6275 VFD GP1232A02A FUTABA Board
+    COM4:   837-15396 "Gen 3" Aime Reader
+*/
+
 #include <windows.h>
 
 #include <stddef.h>

cmhook/dllmain.c

@@ -1,3 +1,16 @@
+/*
+    "Card Maker" (cm) hook
+
+    Devices
+
+    USB:    837-15257-01 "Type 4" I/O Board
+    USB:    838-20006 "WinTouch" Controller Board
+    USB:    630-00009 Sinfonia CHC-C310 Printer
+    COM1:   837-15396 "Gen 3" Aime Reader
+    COM2:   200-6275 VFD GP1232A02A FUTABA Board
+    COM3:   220-5872 AS-6DB Coin Selector
+*/
+
 #include <windows.h>
 
 #include <stdlib.h>
@@ -55,6 +68,12 @@ static DWORD CALLBACK cm_pre_startup(void)
         goto fail;
     }
 
+    hr = cm_dll_init(&cm_hook_cfg.dll, cm_hook_mod);
+
+    if (FAILED(hr)) {
+        goto fail;
+    }
+
     hr = sg_reader_hook_init(&cm_hook_cfg.aime, 1, 1, cm_hook_mod);
 
     if (FAILED(hr)) {
@@ -67,12 +86,6 @@ static DWORD CALLBACK cm_pre_startup(void)
         goto fail;
     }
 
-    hr = cm_dll_init(&cm_hook_cfg.dll, cm_hook_mod);
-
-    if (FAILED(hr)) {
-        goto fail;
-    }
-
     hr = cm_io4_hook_init(&cm_hook_cfg.io4);
 
     if (FAILED(hr)) {

cxbhook/led.c

@@ -5,7 +5,7 @@
 #include "cxbhook/led.h"
 #include "cxbhook/cxb-dll.h"
 
-#include "hooklib/procaddr.h"
+#include "hook/procaddr.h"
 
 #include "hook/table.h"
 
@@ -56,7 +56,7 @@ HRESULT led_hook_init(struct led_config *cfg)
     }
     
     dprintf("LED: Hook enabled.\n");
-    return proc_addr_table_push("CommLamp.dll", lamp_syms, _countof(lamp_syms));
+    return proc_addr_table_push(NULL, "CommLamp.dll", lamp_syms, _countof(lamp_syms));
 }
 
 static int my_cCommLamp_Open(char *port)

cxbhook/revio.c

@@ -6,7 +6,7 @@
 #include "cxbhook/revio.h"
 #include "cxbhook/cxb-dll.h"
 
-#include "hooklib/procaddr.h"
+#include "hook/procaddr.h"
 
 #include "hook/table.h"
 
@@ -89,7 +89,7 @@ HRESULT revio_hook_init(struct revio_config *cfg)
     }
 
     dprintf("Revio: Hook enabled.\n");
-    return proc_addr_table_push("CommIo.dll", revio_syms, _countof(revio_syms));
+    return proc_addr_table_push(NULL, "CommIo.dll", revio_syms, _countof(revio_syms));
 }
 
 static int my_cCommIo_Open(char *port)

dist/chuni/segatools.ini

@@ -63,20 +63,6 @@ framed=1
 ; Select the monitor to run the game on. (Fullscreen only, 0 =primary screen)
 monitor=0
 
-; -----------------------------------------------------------------------------
-; Custom IO settings
-; -----------------------------------------------------------------------------
-
-[aimeio]
-; To use a custom card reader IO DLL enter its path here.
-; Leave empty if you want to use Segatools built-in keyboard input.
-path=
-
-[chuniio]
-; To use a custom Chunithm IO DLL enter its path here.
-; Leave empty if you want to use Segatools built-in keyboard input.
-path=
-
 ; -----------------------------------------------------------------------------
 ; LED settings
 ; -----------------------------------------------------------------------------
@@ -122,6 +108,20 @@ controllerLedOutputSerial=0
 ;   [0]-[31]: slider LEDs right to left BRG, alternating between keys and dividers
 
 
+; -----------------------------------------------------------------------------
+; Custom IO settings
+; -----------------------------------------------------------------------------
+
+[aimeio]
+; To use a custom card reader IO DLL enter its path here.
+; Leave empty if you want to use Segatools built-in keyboard input.
+path=
+
+[chuniio]
+; To use a custom Chunithm IO DLL enter its path here.
+; Leave empty if you want to use Segatools built-in keyboard input.
+path=
+
 ; -----------------------------------------------------------------------------
 ; Input settings
 ; -----------------------------------------------------------------------------

dist/chusan/segatools.ini

@@ -43,6 +43,7 @@ default=127.0.0.1
 ; Chunithm is extremely picky about its LAN environment, so leaving this
 ; setting enabled is strongly recommended.
 enable=1
+
 ; The final octet of the local host's IP address on the virtualized subnet (so,
 ; if the keychip subnet is `192.168.32.0` and this value is set to `11`, then the
 ; local host's virtualized LAN IP is `192.168.32.11`).
@@ -88,25 +89,6 @@ framed=0
 ; Select the monitor to run the game on. (Fullscreen only, 0 =primary screen)
 monitor=0
 
-; -----------------------------------------------------------------------------
-; Custom IO settings
-; -----------------------------------------------------------------------------
-
-[aimeio]
-; To use a custom card reader IO DLL (x64) enter its path here.
-; Leave empty if you want to use Segatools built-in keyboard input.
-path=
-
-[chuniio]
-; Uncomment this if you have custom chuniio implementation comprised of a single 32bit DLL.
-; (will use chu2to3 engine internally)
-;path=
-
-; Uncomment both of these if you have custom chuniio implementation comprised of two DLLs.
-; x86 chuniio to path32, x64 to path64. Both are necessary.
-;path32=
-;path64=
-
 ; -----------------------------------------------------------------------------
 ; LED settings
 ; -----------------------------------------------------------------------------
@@ -152,6 +134,25 @@ controllerLedOutputSerial=0
 ;   [0]-[31]: slider LEDs right to left BRG, alternating between keys and dividers
 
 
+; -----------------------------------------------------------------------------
+; Custom IO settings
+; -----------------------------------------------------------------------------
+
+[aimeio]
+; To use a custom card reader IO DLL (x64) enter its path here.
+; Leave empty if you want to use Segatools built-in keyboard input.
+path=
+
+[chuniio]
+; Uncomment this if you have custom chuniio implementation comprised of a single 32bit DLL.
+; (will use chu2to3 engine internally)
+;path=
+
+; Uncomment both of these if you have custom chuniio implementation comprised of two DLLs.
+; x86 chuniio to path32, x64 to path64. Both are necessary.
+;path32=
+;path64=
+
 ; -----------------------------------------------------------------------------
 ; Input settings
 ; -----------------------------------------------------------------------------

dist/fgo/segatools.ini

@@ -128,7 +128,6 @@ path=
 ; world. An improved solution will be provided later.
 
 [io4]
-; Input API selection for JVS input emulator.
 ; Test button virtual-key code. Default is the F1 key.
 test=0x70
 ; Service button virtual-key code. Default is the F2 key.

dist/idac/segatools.ini

@@ -75,6 +75,25 @@ dipsw3=0
 dipsw4=0
 dipsw5=0
 
+; -----------------------------------------------------------------------------
+; LED settings
+; -----------------------------------------------------------------------------
+
+[led15070]
+; Enable emulation of the 837-15070-02 controlled lights, which handle the
+; cabinet and seat LEDs.
+enable=1
+
+; -----------------------------------------------------------------------------
+; Misc. hooks settings
+; -----------------------------------------------------------------------------
+
+[indrun]
+; Hooks to patch GameProject-Win64-Shipping.exe and IndRun.dll. This is needed
+; to boot version 1.60.00 and up. The hooks are not needed for version 1.50.00
+; and below. 
+enable=1
+
 ; -----------------------------------------------------------------------------
 ; Custom IO settings
 ; -----------------------------------------------------------------------------

dist/mai2/segatools.ini

@@ -69,6 +69,18 @@ freeplay=0
 ; this to 1 on exactly one machine and set this to 0 on all others.
 dipsw1=1
 
+; -----------------------------------------------------------------------------
+; Misc. hook settings
+; -----------------------------------------------------------------------------
+
+[unity]
+; Enable Unity hook. This will allow you to run custom .NET code before the game
+enable=1
+
+; Path to a .NET DLL that should run before the game. Useful for loading
+; modding frameworks such as BepInEx.
+targetAssembly=
+
 ; -----------------------------------------------------------------------------
 ; Custom IO settings
 ; -----------------------------------------------------------------------------
@@ -83,15 +95,6 @@ path=
 ; Leave empty if you want to use Segatools built-in keyboard input.
 path=
 
-; -----------------------------------------------------------------------------
-; Misc. hook settings
-; -----------------------------------------------------------------------------
-
-[unity]
-; Path to a .NET DLL that should run before the game. Useful for loading
-; modding frameworks such as BepInEx.
-targetAssembly=
-
 ; -----------------------------------------------------------------------------
 ; Input settings
 ; -----------------------------------------------------------------------------

dist/mu3/segatools.ini

@@ -73,10 +73,61 @@ dipsw1=1
 enable=1
 
 [unity]
+; Enable Unity hook. This will allow you to run custom .NET code before the game
+enable=1
+
 ; Path to a .NET DLL that should run before the game. Useful for loading
 ; modding frameworks such as BepInEx.
 targetAssembly=
 
+; -----------------------------------------------------------------------------
+; LED settings
+; -----------------------------------------------------------------------------
+
+[led15093]
+; Enable emulation of the 15093-06 controlled lights, which handle the air tower 
+; RGBs and the rear LED panel (billboard) on the cabinet.
+enable=1
+
+[led]
+; Output billboard LED strip data to a named pipe called "\\.\pipe\ongeki_led"
+cabLedOutputPipe=1
+; Output billboard LED strip data to serial
+cabLedOutputSerial=0
+
+; Output slider LED data to the named pipe
+controllerLedOutputPipe=1
+; Output slider LED data to the serial port
+controllerLedOutputSerial=0
+
+; Serial port to send data to if using serial output. Default is COM5.
+;serialPort=COM5
+; Baud rate for serial data
+;serialBaud=921600
+
+; Data output a sequence of bytes, with JVS-like framing.
+; Each "packet" starts with 0xE0 as a sync. To avoid E0 appearing elsewhere,
+; 0xD0 is used as an escape character -- if you receive D0 in the output, ignore
+; it and use the next sent byte plus one instead.
+;
+; After the sync is one byte for the board number that was updated, followed by
+; the red, green and blue values for each LED.
+;
+; Board 0 has 61 LEDs:
+;   [0]-[1]: left side button
+;   [2]-[8]: left pillar lower LEDs
+;   [9]-[17]: left pillar center LEDs
+;   [18]-[24]: left pillar upper LEDs
+;   [25]-[35]: billboard LEDs
+;   [36]-[42]: right pillar upper LEDs
+;   [43]-[51]: right pillar center LEDs
+;   [52]-[58]: right pillar lower LEDs
+;   [59]-[60]: right side button
+;
+; Board 1 has 6 LEDs:
+;   [0]-[5]: 3 left and 3 right controller buttons
+;
+
 ; -----------------------------------------------------------------------------
 ; Custom IO settings
 ; -----------------------------------------------------------------------------

divahook/dllmain.c

@@ -1,3 +1,14 @@
+/*
+    "Hatsune Miku Project DIVA Arcade " (diva) hook
+
+    Devices
+
+      JVS:  837-14572 "Type 3" I/O Board
+     COM1:  3M Touch Systems 78-0011-2353-4 Touch Controller Board
+    COM10:  TN32MSEC003S "Gen 1" Aime Reader
+    COM11:  837-15275 Touch Slider
+*/
+
 #include <windows.h>
 
 #include <stdlib.h>

fgohook/dllmain.c

@@ -1,3 +1,20 @@
+/*
+    "Fate Grand/Order Arcade" (fgo) hook
+
+    Devices
+
+    USB:    837-15257 "Type 4" I/O Board
+    USB:    838-15405 "WinTouch" Controller Board
+    USB:    630-00008 Sinfonia CHC-C330 Printer
+    USB:    837-14509-02 USB-SER I/F BD Mini-B FTDI Board
+            connected to
+            837-15093-06 LED Controller Board
+    COM1:   200-6275 VFD GP1232A02A FUTABA Board
+    COM2:   837-15345 RFID Deck Reader Noard
+    COM3:   837-15396 "Gen 3" Aime Reader
+    COM4:   837-15347 RFID Reader/Writer Board (inside the printer)
+*/
+
 #include <windows.h>
 
 #include <stdlib.h>

fgohook/fgo-dll.c

@@ -28,7 +28,7 @@ const struct dll_bind_sym fgo_dll_syms[] = {
         .sym = "fgo_io_led_init",
         .off = offsetof(struct fgo_dll, led_init),
     }, {
-        .sym = "fgo_io_led_set_leds",
+        .sym = "fgo_io_led_set_colors",
         .off = offsetof(struct fgo_dll, led_set_leds),
     }
 };

fgohook/fgohook.def

@@ -18,7 +18,7 @@ EXPORTS
     fgo_io_init
     fgo_io_poll
     fgo_io_led_init
-    fgo_io_led_set_leds
+    fgo_io_led_set_colors
     fwdlusb_open
     fwdlusb_close
     fwdlusb_listupPrinter

fgoio/fgoio.c

@@ -145,7 +145,7 @@ HRESULT fgo_io_led_init(void)
     return S_OK;
 }
 
-void fgo_io_led_set_leds(uint8_t board, uint8_t *rgb)
+void fgo_io_led_set_colors(uint8_t board, uint8_t *rgb)
 {
     return;
-}
+}

fgoio/fgoio.h

@@ -83,4 +83,4 @@ HRESULT fgo_io_led_init(void);
    
    Exact layout is TBD. */
 
-void fgo_io_led_set_leds(uint8_t board, uint8_t *rgb);
+void fgo_io_led_set_colors(uint8_t board, uint8_t *rgb);

hooklib/dns.c

@@ -194,6 +194,37 @@ static void dns_hook_init(void)
             _countof(dns_hook_syms_winhttp));
 }
 
+// This function match domain and subdomains like *.naominet.jp.
+bool match_domain(const wchar_t* target, const wchar_t* pattern) {
+    if (_wcsicmp(pattern, target) == 0) {
+        return true;
+    }
+
+    int pattern_ptr_index = 0;
+    int target_ptr_index = 0;
+
+    while (pattern[pattern_ptr_index] != '\0' && target[target_ptr_index] != '\0') {
+        if (pattern[pattern_ptr_index] == '*') {
+            pattern_ptr_index++; // Check next character for wildcard match.
+
+            while (pattern[pattern_ptr_index] != target[target_ptr_index]) {
+                target_ptr_index++;
+
+                if (target[target_ptr_index] == '\0') return false;
+            }
+        }
+        else if (pattern[pattern_ptr_index] != target[target_ptr_index]) {
+            return false;
+        }
+        else {
+            pattern_ptr_index++;
+            target_ptr_index++;
+        }
+    }
+
+    return pattern[pattern_ptr_index] == '\0' && target[target_ptr_index] == '\0';
+}
+
 HRESULT dns_hook_push(const wchar_t *from_src, const wchar_t *to_src)
 {
     HRESULT hr;
@@ -297,7 +328,7 @@ static DNS_STATUS WINAPI hook_DnsQuery_A(
     for (i = 0 ; i < dns_hook_nentries ; i++) {
         pos = &dns_hook_entries[i];
 
-        if (_wcsicmp(wstr, pos->from) == 0) {
+        if (match_domain(wstr, pos->from)) {
             if(pos->to == NULL) {
                 LeaveCriticalSection(&dns_hook_lock);
                 hr = HRESULT_FROM_WIN32(DNS_ERROR_RCODE_NAME_ERROR);
@@ -361,7 +392,7 @@ static DNS_STATUS WINAPI hook_DnsQuery_W(
     for (i = 0 ; i < dns_hook_nentries ; i++) {
         pos = &dns_hook_entries[i];
 
-        if (_wcsicmp(pszName, pos->from) == 0) {
+        if (match_domain(pszName, pos->from)) {
             if(pos->to == NULL) {
                 LeaveCriticalSection(&dns_hook_lock);
                 return HRESULT_FROM_WIN32(DNS_ERROR_RCODE_NAME_ERROR);
@@ -405,7 +436,7 @@ static DNS_STATUS WINAPI hook_DnsQueryEx(
     for (i = 0 ; i < dns_hook_nentries ; i++) {
         pos = &dns_hook_entries[i];
 
-        if (_wcsicmp(pRequest->QueryName, pos->from) == 0) {
+        if (match_domain(pRequest->QueryName, pos->from)) {
             if(pos->to == NULL) {
                 LeaveCriticalSection(&dns_hook_lock);
                 return HRESULT_FROM_WIN32(DNS_ERROR_RCODE_NAME_ERROR);
@@ -472,7 +503,7 @@ static int WSAAPI hook_getaddrinfo(
     for (i = 0 ; i < dns_hook_nentries ; i++) {
         pos = &dns_hook_entries[i];
 
-        if (_wcsicmp(wstr, pos->from) == 0) {
+        if (match_domain(wstr, pos->from)) {
             if(pos->to == NULL) {
                 LeaveCriticalSection(&dns_hook_lock);
                 result = EAI_NONAME;
@@ -526,7 +557,7 @@ static HINTERNET WINAPI hook_WinHttpConnect(
     for (i = 0 ; i < dns_hook_nentries ; i++) {
         pos = &dns_hook_entries[i];
 
-        if (_wcsicmp(pwszServerName, pos->from) == 0) {
+        if (match_domain(pwszServerName, pos->from)) {
             if(pos->to == NULL) {
                 LeaveCriticalSection(&dns_hook_lock);
                 return NULL;
@@ -558,7 +589,7 @@ static bool WINAPI hook_WinHttpCrackUrl(
     for (i = 0 ; i < dns_hook_nentries ; i++) {
         pos = &dns_hook_entries[i];
 
-        if (_wcsicmp(pwszUrl, pos->from) == 0) {
+        if (match_domain(pwszUrl, pos->from)) {
             wchar_t* toAddr = pos->to;
             wchar_t titleBuffer[255];
             

hooklib/meson.build

@@ -23,8 +23,6 @@ hooklib_lib = static_library(
         'fdshark.h',
         'path.c',
         'path.h',
-        'procaddr.c',
-        'procaddr.h',
         'reg.c',
         'reg.h',
         'setupapi.c',

hooklib/procaddr.c

@@ -1,125 +0,0 @@
-#include <windows.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <libgen.h>
-
-#include "hooklib/procaddr.h"
-
-#include "hook/table.h"
-
-#include "util/dprintf.h"
-
-static struct proc_addr_table *proc_addr_hook_list;
-static size_t proc_addr_hook_count;
-static CRITICAL_SECTION proc_addr_hook_lock;
-static bool proc_addr_hook_initted;
-
-static FARPROC WINAPI my_GetProcAddress(HMODULE hModule, const char *name);
-static FARPROC (WINAPI *next_GetProcAddress)(HMODULE hModule, const char *name);
-static void proc_addr_hook_init(void);
-
-static const struct hook_symbol win32_hooks[] = {
-    {
-        .name = "GetProcAddress",
-        .patch = my_GetProcAddress,
-        .link = (void **) &next_GetProcAddress
-    }
-};
-
-HRESULT proc_addr_table_push(
-    const char *target,
-    struct hook_symbol *syms,
-    size_t nsyms
-)
-{
-    HRESULT hr;
-    struct proc_addr_table *new_item;
-    struct proc_addr_table *new_mem;
-
-    proc_addr_hook_init();
-
-    EnterCriticalSection(&proc_addr_hook_lock);
-
-    new_mem = realloc(
-            proc_addr_hook_list,
-            (proc_addr_hook_count + 1) * sizeof(struct proc_addr_table));
-    
-    if (new_mem == NULL) {
-        hr = E_OUTOFMEMORY;
-        
-        LeaveCriticalSection(&proc_addr_hook_lock);
-        return hr;
-    }
-
-    new_item = &new_mem[proc_addr_hook_count];
-    new_item->name = target;    
-    new_item->nsyms = nsyms;
-    new_item->syms = syms;
-
-    proc_addr_hook_list = new_mem;
-    proc_addr_hook_count++;
-    hr = S_OK;
-
-    LeaveCriticalSection(&proc_addr_hook_lock);
-
-    return hr;
-}
-
-static void proc_addr_hook_init(void)
-{
-    if (proc_addr_hook_initted) {
-        return;
-    }
-
-    dprintf("ProcAddr: Hook init\n");
-    proc_addr_hook_initted = true;
-
-    InitializeCriticalSection(&proc_addr_hook_lock);
-
-    hook_table_apply(
-            NULL,
-            "kernel32.dll",
-            win32_hooks,
-            _countof(win32_hooks));
-}
-
-FARPROC WINAPI my_GetProcAddress(HMODULE hModule, const char *name)
-{
-    uintptr_t ordinal = (uintptr_t) name;
-    char mod_path[PATH_MAX];
-    char *mod_name;
-    const struct hook_symbol *sym;
-    FARPROC result = next_GetProcAddress(hModule, name);
-    
-    GetModuleFileNameA(hModule, mod_path, PATH_MAX);
-    mod_name = basename(mod_path);
-
-    for (int i = 0; i < proc_addr_hook_count; i++) {
-
-        if (strcmp(proc_addr_hook_list[i].name, mod_name) == 0) {
-            
-            for (int j = 0; j < proc_addr_hook_list[i].nsyms; j++) {
-                sym = &proc_addr_hook_list[i].syms[j];
-                
-                if (ordinal > 0xFFFF) {
-
-                    if (strcmp(sym->name, name) == 0) {
-
-                        dprintf("ProcAddr: Hooking %s from %s\n", name, mod_name);
-                        result = (FARPROC) sym->patch;
-                    }
-                }
-
-                else {
-                    if (sym->ordinal == ordinal) {
-
-                        dprintf("ProcAddr: Hooking Ord %p from %s\n", (void *)ordinal, mod_name);
-                        result = (FARPROC) sym->patch;
-                    }
-                }
-            }
-        }
-    }
-
-    return result;
-}

hooklib/procaddr.h

@@ -1,18 +0,0 @@
-#pragma once
-#include <windows.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "hook/table.h"
-
-struct proc_addr_table {
-    const char *name;
-    size_t nsyms;    
-    struct hook_symbol *syms;
-};
-
-HRESULT proc_addr_table_push(
-    const char *target,
-    struct hook_symbol *syms,
-    size_t nsyms
-);

hooklib/reg.c

@@ -7,6 +7,7 @@
 #include "hook/table.h"
 
 #include "hooklib/reg.h"
+#include "hook/procaddr.h"
 
 #include "util/dprintf.h"
 #include "util/str.h"
@@ -99,6 +100,29 @@ static LSTATUS WINAPI hook_RegGetValueW(
     uint32_t *numData
 );
 
+static LSTATUS WINAPI hook_RegQueryInfoKeyW(
+    HKEY      hKey,
+    LPWSTR    lpClass,
+    LPDWORD   lpcchClass,
+    LPDWORD   lpReserved,
+    LPDWORD   lpcSubKeys,
+    LPDWORD   lpcbMaxSubKeyLen,
+    LPDWORD   lpcbMaxClassLen,
+    LPDWORD   lpcValues,
+    LPDWORD   lpcbMaxValueNameLen,
+    LPDWORD   lpcbMaxValueLen,
+    LPDWORD   lpcbSecurityDescriptor,
+    PFILETIME lpftLastWriteTime);
+
+static LSTATUS WINAPI hook_RegEnumValueW(
+    HKEY    hkey,
+    DWORD   dwIndex,
+    LPWSTR   lpValueName,
+    LPDWORD lpcchValueName,
+    LPDWORD lpReserved,
+    LPDWORD lpType,
+    LPBYTE  lpData,
+    LPDWORD lpcbData);
 /* Link pointers */
 
 static LSTATUS (WINAPI *next_RegOpenKeyExW)(
@@ -155,6 +179,30 @@ static LSTATUS (WINAPI *next_RegGetValueW)(
     uint32_t *numData
 );
 
+static LSTATUS (WINAPI *next_RegQueryInfoKeyW)(
+    HKEY      hKey,
+    LPWSTR    lpClass,
+    LPDWORD   lpcchClass,
+    LPDWORD   lpReserved,
+    LPDWORD   lpcSubKeys,
+    LPDWORD   lpcbMaxSubKeyLen,
+    LPDWORD   lpcbMaxClassLen,
+    LPDWORD   lpcValues,
+    LPDWORD   lpcbMaxValueNameLen,
+    LPDWORD   lpcbMaxValueLen,
+    LPDWORD   lpcbSecurityDescriptor,
+    PFILETIME lpftLastWriteTime);
+
+static LSTATUS (WINAPI *next_RegEnumValueW)(
+    HKEY    hkey,
+    DWORD   dwIndex,
+    LPWSTR   lpValueName,
+    LPDWORD lpcchValueName,
+    LPDWORD lpReserved,
+    LPDWORD lpType,
+    LPBYTE  lpData,
+    LPDWORD lpcbData);
+
 static const struct hook_symbol reg_hook_syms[] = {
     {
         .name   = "RegOpenKeyExW",
@@ -184,6 +232,14 @@ static const struct hook_symbol reg_hook_syms[] = {
         .name   = "RegGetValueW",
         .patch  = hook_RegGetValueW,
         .link   = (void **) &next_RegGetValueW,
+    }, {
+        .name   = "RegQueryInfoKeyW",
+        .patch  = hook_RegQueryInfoKeyW,
+        .link   = (void **) &next_RegQueryInfoKeyW,
+    }, {
+        .name   = "RegEnumValueW",
+        .patch  = hook_RegEnumValueW,
+        .link   = (void **) &next_RegEnumValueW,
     }
 };
 
@@ -254,11 +310,24 @@ static void reg_hook_init(void)
     InitializeCriticalSection(&reg_hook_lock);
     dprintf("Reg hook init\n");
 
+    reg_hook_insert_hooks(NULL);
+
+    proc_addr_table_push(
+        NULL,
+        "ADVAPI32.dll",
+        (struct hook_symbol *) reg_hook_syms,
+        _countof(reg_hook_syms));
+
+}
+
+void reg_hook_insert_hooks(HMODULE target)
+{
     hook_table_apply(
-            NULL,
+            target,
             "advapi32.dll",
             reg_hook_syms,
             _countof(reg_hook_syms));
+    
 }
 
 static LRESULT reg_hook_propagate_hr(HRESULT hr)
@@ -331,6 +400,7 @@ static LSTATUS reg_hook_open_locked(
         /* Assume reg keys are referenced from a root key and not from some
            intermediary key */
         key = &reg_hook_keys[i];
+        //dprintf("Reg: %ls vs %ls\n", name, key->name);
 
         if (key->root == parent && wstr_ieq(key->name, name)) {
             break;
@@ -821,6 +891,99 @@ static LSTATUS WINAPI hook_RegGetValueW(
     return err;
 }
 
+static LSTATUS WINAPI hook_RegQueryInfoKeyW(
+    HKEY      hKey,
+    LPWSTR    lpClass,
+    LPDWORD   lpcchClass,
+    LPDWORD   lpReserved,
+    LPDWORD   lpcSubKeys,
+    LPDWORD   lpcbMaxSubKeyLen,
+    LPDWORD   lpcbMaxClassLen,
+    LPDWORD   lpcValues,
+    LPDWORD   lpcbMaxValueNameLen,
+    LPDWORD   lpcbMaxValueLen,
+    LPDWORD   lpcbSecurityDescriptor,
+    PFILETIME lpftLastWriteTime)
+{
+    struct reg_hook_key *key;
+    LSTATUS err;
+
+    EnterCriticalSection(&reg_hook_lock);
+
+    key = reg_hook_match_key_locked(hKey);
+
+    /* Check if this is a virtualized registry key */
+
+    if (key == NULL) {
+        LeaveCriticalSection(&reg_hook_lock);
+
+        return next_RegQueryInfoKeyW(
+            hKey,
+            lpClass,
+            lpcchClass,
+            lpReserved,
+            lpcSubKeys,
+            lpcbMaxSubKeyLen,
+            lpcbMaxClassLen,
+            lpcValues,
+            lpcbMaxValueNameLen,
+            lpcbMaxValueLen,
+            lpcbSecurityDescriptor,
+            lpftLastWriteTime);
+    }
+
+    // This is the only one I've seen even be changed, so it's all I'm doing
+    // until I see otherwise.
+    *lpcValues = key->nvals;
+    LeaveCriticalSection(&reg_hook_lock);
+    return ERROR_SUCCESS;
+}
+
+static LSTATUS WINAPI hook_RegEnumValueW(
+    HKEY    hkey,
+    DWORD   dwIndex,
+    LPWSTR   lpValueName,
+    LPDWORD lpcchValueName,
+    LPDWORD lpReserved,
+    LPDWORD lpType,
+    LPBYTE  lpData,
+    LPDWORD lpcbData)
+{
+    struct reg_hook_key *key;
+    HRESULT hr;
+    LSTATUS err;
+
+    EnterCriticalSection(&reg_hook_lock);
+
+    key = reg_hook_match_key_locked(hkey);
+
+    /* Check if this is a virtualized registry key */
+
+    if (key == NULL) {
+        LeaveCriticalSection(&reg_hook_lock);
+
+        return next_RegEnumValueW(
+            hkey,
+            dwIndex,
+            lpValueName,
+            lpcchValueName,
+            lpReserved,
+            lpType,
+            lpData,
+            lpcbData);
+    }
+
+    if (dwIndex >= key->nvals) {
+        LeaveCriticalSection(&reg_hook_lock);
+        return ERROR_NO_MORE_ITEMS; // Pretty sure this is what it actually returns here?
+    }
+
+    wcscpy_s(lpValueName, *lpcchValueName, key->vals[dwIndex].name);
+    *lpcchValueName = wcslen(key->vals[dwIndex].name);
+    LeaveCriticalSection(&reg_hook_lock);
+    return ERROR_SUCCESS;
+}
+
 HRESULT reg_hook_read_bin(
         void *bytes,
         uint32_t *nbytes,

hooklib/reg.h

@@ -12,6 +12,8 @@ struct reg_hook_val {
     uint32_t type;
 };
 
+void reg_hook_insert_hooks(HMODULE target);
+
 HRESULT reg_hook_push_key(
         HKEY root,
         const wchar_t *name,

hooklib/touch.c

@@ -119,10 +119,19 @@ void touch_screen_hook_init(const struct touch_screen_config *cfg, HINSTANCE sel
     defaultCursor = LoadCursorA(NULL, IDC_CROSS);
 
     memcpy(&touch_config, cfg, sizeof(*cfg));
-    hook_table_apply(NULL, "user32.dll", touch_hooks, _countof(touch_hooks));
+    touch_hook_insert_hooks(NULL);
     dprintf("TOUCH: hook enabled.\n");
 }
 
+void touch_hook_insert_hooks(HMODULE target)
+{
+    hook_table_apply(
+            target,
+            "user32.dll",
+            touch_hooks,
+            _countof(touch_hooks));
+}
+
 static HCURSOR WINAPI hook_SetCursor(HCURSOR cursor) {
     if (cursor == 0 && touch_config.cursor)
         return next_SetCursor(defaultCursor);

hooklib/touch.h

@@ -14,3 +14,4 @@ struct touch_screen_config {
     blah blah you know the drill by now. */
 
 void touch_screen_hook_init(const struct touch_screen_config *cfg, HINSTANCE self);
+void touch_hook_insert_hooks(HMODULE target);

idachook/config.c

@@ -13,6 +13,43 @@
 #include "platform/config.h"
 #include "platform/platform.h"
 
+
+void led15070_config_load(struct led15070_config *cfg, const wchar_t *filename)
+{
+    assert(cfg != NULL);
+    assert(filename != NULL);
+
+    wchar_t tmpstr[16];
+
+    cfg->enable = GetPrivateProfileIntW(L"led15070", L"enable", 1, filename);
+    cfg->port_no = GetPrivateProfileIntW(L"led15070", L"portNo", 0, filename);
+    cfg->fw_ver = GetPrivateProfileIntW(L"led15070", L"fwVer", 0x90, filename);
+    /* TODO: Unknown, no firmware file available */
+    cfg->fw_sum = GetPrivateProfileIntW(L"led15070", L"fwSum", 0x0000, filename);
+
+    GetPrivateProfileStringW(
+            L"led15070",
+            L"boardNumber",
+            L"15070-02",
+            tmpstr,
+            _countof(tmpstr),
+            filename);
+
+    size_t n = wcstombs(cfg->board_number, tmpstr, sizeof(cfg->board_number));
+    for (int i = n; i < sizeof(cfg->board_number); i++)
+    {
+        cfg->board_number[i] = ' ';
+    }
+
+    GetPrivateProfileStringW(
+            L"led15070",
+            L"eepromPath",
+            L"DEVICE",
+            cfg->eeprom_path,
+            _countof(cfg->eeprom_path),
+            filename);
+}
+
 void idac_dll_config_load(
         struct idac_dll_config *cfg,
         const wchar_t *filename)
@@ -29,6 +66,16 @@ void idac_dll_config_load(
             filename);
 }
 
+void indrun_config_load(
+        struct indrun_config *cfg,
+        const wchar_t *filename)
+{
+    assert(cfg != NULL);
+    assert(filename != NULL);
+
+    cfg->enable = GetPrivateProfileIntW(L"indrun", L"enable", 1, filename);
+}
+
 void idac_hook_config_load(
         struct idac_hook_config *cfg,
         const wchar_t *filename)
@@ -42,6 +89,8 @@ void idac_hook_config_load(
     zinput_config_load(&cfg->zinput, filename);
     dvd_config_load(&cfg->dvd, filename);
     io4_config_load(&cfg->io4, filename);
+    led15070_config_load(&cfg->led15070, filename);
+    indrun_config_load(&cfg->indrun, filename);
 }
 
 void zinput_config_load(struct zinput_config *cfg, const wchar_t *filename)

idachook/config.h

@@ -4,11 +4,13 @@
 #include <stddef.h>
 
 #include "board/config.h"
+#include "board/led15070.h"
 
 #include "hooklib/dvd.h"
 
 #include "idachook/idac-dll.h"
 #include "idachook/zinput.h"
+#include "idachook/indrun.h"
 
 #include "platform/platform.h"
 
@@ -19,6 +21,8 @@ struct idac_hook_config {
     struct io4_config io4;
     struct idac_dll_config dll;
     struct zinput_config zinput;
+    struct led15070_config led15070;
+    struct indrun_config indrun;
 };
 
 void idac_dll_config_load(
@@ -29,4 +33,10 @@ void idac_hook_config_load(
         struct idac_hook_config *cfg,
         const wchar_t *filename);
 
-void zinput_config_load(struct zinput_config *cfg, const wchar_t *filename);
+void zinput_config_load(
+        struct zinput_config *cfg,
+        const wchar_t *filename);
+
+void indrun_config_load(
+        struct indrun_config *cfg,
+        const wchar_t *filename);

idachook/dllmain.c

@@ -1,3 +1,16 @@
+/*
+    "Initial D THE ARCADE" (idac) hook
+
+    Devices
+
+     USB:   837-15257 "Type 4" I/O Board
+    COM1:   838-15069 MOTOR DRIVE BD RS232/422 Board
+    COM2:   837-15070-02 IC BD LED Controller Board
+    COM3:   837-15286 "Gen 2" Aime Reader (DIPSW2 OFF)
+            OR
+            837-15396 "Gen 3" Aime Reader (DIPSW2 ON)
+*/
+
 #include <windows.h>
 #include <shlwapi.h>
 
@@ -53,13 +66,13 @@ static DWORD CALLBACK idac_pre_startup(void)
         goto fail;
     }
 
-    hr = sg_reader_hook_init(&idac_hook_cfg.aime, 3, 3, idac_hook_mod);
+    hr = idac_dll_init(&idac_hook_cfg.dll, idac_hook_mod);
 
     if (FAILED(hr)) {
         goto fail;
     }
 
-    hr = idac_dll_init(&idac_hook_cfg.dll, idac_hook_mod);
+    hr = sg_reader_hook_init(&idac_hook_cfg.aime, 3, 3, idac_hook_mod);
 
     if (FAILED(hr)) {
         goto fail;
@@ -71,6 +84,20 @@ static DWORD CALLBACK idac_pre_startup(void)
         goto fail;
     }
 
+    hr = led15070_hook_init(&idac_hook_cfg.led15070, idac_dll.led_init, 
+        idac_dll.led_set_fet_output, NULL, idac_dll.led_gs_update, 2, 1);
+
+    if (FAILED(hr)) {
+        goto fail;
+    }
+
+    /* Initialize native plugin DLL hooks
+
+       There seems to be an issue with other DLL hooks if `LoadLibraryW` is
+       hooked earlier in the initialization. */
+
+    indrun_hook_init(&idac_hook_cfg.indrun);
+
     /* Initialize debug helpers */
 
     spike_hook_init(L".\\segatools.ini");

idachook/idac-dll.c

@@ -24,6 +24,18 @@ const struct dll_bind_sym idac_dll_syms[] = {
     }, {
         .sym = "idac_io_get_analogs",
         .off = offsetof(struct idac_dll, get_analogs),
+    }, {
+        .sym = "idac_io_led_init",
+        .off = offsetof(struct idac_dll, led_init),
+    }, {
+        .sym = "idac_io_led_set_fet_output",
+        .off = offsetof(struct idac_dll, led_set_fet_output),
+    }, {
+        .sym = "idac_io_led_gs_update",
+        .off = offsetof(struct idac_dll, led_gs_update),
+    }, {
+        .sym = "idac_io_led_set_leds",
+        .off = offsetof(struct idac_dll, led_set_leds),
     }
 };
 

idachook/idac-dll.h

@@ -11,6 +11,10 @@ struct idac_dll {
     void (*get_gamebtns)(uint8_t *gamebtn);
     void (*get_shifter)(uint8_t *gear);
     void (*get_analogs)(struct idac_io_analog_state *out);
+    HRESULT (*led_init)(void);
+    void (*led_set_fet_output)(const uint8_t *rgb);
+    void (*led_gs_update)(const uint8_t *rgb);
+    void (*led_set_leds)(const uint8_t *rgb);
 };
 
 struct idac_dll_config {

idachook/idachook.def

@@ -17,3 +17,7 @@ EXPORTS
     idac_io_get_gamebtns
     idac_io_get_shifter
     idac_io_get_analogs
+    idac_io_led_init
+    idac_io_led_set_fet_output
+    idac_io_led_gs_update
+    idac_io_led_set_leds

idachook/indrun.c

@@ -0,0 +1,260 @@
+#include <assert.h>
+#include <stdbool.h>
+
+#include "hook/table.h"
+
+#include "hooklib/dll.h"
+
+#include "util/dprintf.h"
+
+#include "indrun.h"
+
+static const wchar_t *target_modules[] = {
+    L"IndRun.dll",
+};
+
+static const size_t target_modules_len = _countof(target_modules);
+
+static void dll_hook_insert_hooks(HMODULE target);
+static void app_hook_insert_hooks(HMODULE target);
+
+static HMODULE WINAPI hook_LoadLibraryW(const wchar_t *name);
+static HMODULE (WINAPI *next_LoadLibraryW)(const wchar_t *name);
+
+static int WINAPI hook_GetSystemMetrics(int nIndex);
+static int (WINAPI *next_GetSystemMetrics)(int nIndex);
+
+static BOOL WINAPI hook_GetComputerNameW(LPWSTR  lpBuffer, LPDWORD nSize);
+static DWORD WINAPI hook_GetCurrentDirectoryW( DWORD  nBufferLength, LPWSTR lpBuffer);
+static BOOL WINAPI hook_GetVersionExW(LPOSVERSIONINFOW lpVersionInformation);
+static int (WINAPI *next_GetVersionExW)(LPOSVERSIONINFOW lpVersionInformation);
+static BOOL WINAPI hook_VerifyVersionInfoW(LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
+static BOOL (WINAPI *next_VerifyVersionInfoW)(LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
+static BOOL WINAPI hook_K32EnumProcesses(DWORD *lpidProcess, DWORD cb, LPDWORD lpcbNeeded);
+static BOOL (WINAPI *next_K32EnumProcesses)(DWORD *lpidProcess, DWORD cb, LPDWORD lpcbNeeded);
+
+static BOOL WINAPI hook_GetUserNameW(LPWSTR  lpBuffer, LPDWORD pcbBuffer);
+
+static const struct hook_symbol idac_app_user32_syms[] = {
+    {
+        .name = "GetSystemMetrics",
+        .patch = hook_GetSystemMetrics,
+        .link = (void **) &next_GetSystemMetrics,
+    }
+};
+
+static const struct hook_symbol idac_app_kernel32_syms[] = {
+    {
+        .name = "GetComputerNameW",
+        .patch = hook_GetComputerNameW,
+    },
+    {
+        .name = "GetCurrentDirectoryW",
+        .patch = hook_GetCurrentDirectoryW,
+    },
+    {
+        .name = "GetVersionExW",
+        .patch = hook_GetVersionExW,
+        .link = (void **) &next_GetVersionExW,
+    },
+    {
+        .name = "VerifyVersionInfoW",
+        .patch = hook_VerifyVersionInfoW,
+        .link = (void **) &next_VerifyVersionInfoW,
+    },
+    {
+        .name = "K32EnumProcesses",
+        .patch = hook_K32EnumProcesses,
+        .link = (void **) &next_K32EnumProcesses,
+    }
+};
+
+static const struct hook_symbol idac_app_advapi32_syms[] = {
+    {
+        .name = "GetUserNameW",
+        .patch = hook_GetUserNameW,
+    }
+};
+
+static const struct hook_symbol indrun_kernel32_syms[] = {
+    {
+        .name = "LoadLibraryW",
+        .patch = hook_LoadLibraryW,
+        .link = (void **) &next_LoadLibraryW,
+    }
+};
+
+void indrun_hook_init(struct indrun_config *cfg)
+{
+    assert(cfg != NULL);
+
+    if (!cfg->enable) {
+       return;
+    }
+
+    dprintf("IDAC: Hooks enabled.\n");
+
+    // GameProject-Win64-Shipping.exe hooks
+    app_hook_insert_hooks(NULL);
+
+    // IndRun.dll hooks
+    dll_hook_insert_hooks(NULL);
+}
+
+static void dll_hook_insert_hooks(HMODULE target) {
+    hook_table_apply(
+        target,
+        "kernel32.dll",
+        indrun_kernel32_syms,
+        _countof(indrun_kernel32_syms));
+}
+
+void app_hook_insert_hooks(HMODULE target) {
+    hook_table_apply(
+        target,
+        "user32.dll",
+        idac_app_user32_syms,
+        _countof(idac_app_user32_syms));
+
+    hook_table_apply(
+        target,
+        "kernel32.dll",
+        idac_app_kernel32_syms,
+        _countof(idac_app_kernel32_syms));
+    
+    hook_table_apply(
+        target,
+        "advapi32.dll",
+        idac_app_advapi32_syms,
+        _countof(idac_app_advapi32_syms));
+}
+
+static HMODULE WINAPI hook_LoadLibraryW(const wchar_t *name)
+{
+    const wchar_t *name_end;
+    const wchar_t *target_module;
+    bool already_loaded;
+    HMODULE result;
+    size_t name_len;
+    size_t target_module_len;
+
+    if (name == NULL) {
+        SetLastError(ERROR_INVALID_PARAMETER);
+
+        return NULL;
+    }
+
+    // Check if the module is already loaded
+    already_loaded = GetModuleHandleW(name) != NULL;
+
+    // Must call the next handler so the DLL reference count is incremented
+    result = next_LoadLibraryW(name);
+
+    if (!already_loaded && result != NULL) {
+        name_len = wcslen(name);
+
+        for (size_t i = 0; i < target_modules_len; i++) {
+            target_module = target_modules[i];
+            target_module_len = wcslen(target_module);
+
+            // Check if the newly loaded library is at least the length of
+            // the name of the target module
+            if (name_len < target_module_len) {
+                continue;
+            }
+
+            name_end = &name[name_len - target_module_len];
+
+            // Check if the name of the newly loaded library is one of the
+            // modules the path hooks should be injected into
+            if (_wcsicmp(name_end, target_module) != 0) {
+                continue;
+            }
+
+            dprintf("IDAC: Hooked %S\n", target_module);
+
+            dll_hook_insert_hooks(result);
+            app_hook_insert_hooks(result);
+        }
+    }
+
+    return result;
+}
+
+static int WINAPI hook_GetSystemMetrics(int nIndex) {
+    int ret = next_GetSystemMetrics(nIndex);
+
+    // Disable mouse buttons detection
+    if (nIndex == SM_CMOUSEBUTTONS) {
+        dprintf("IDAC: GetSystemMetrics(%d) -> 0\n", nIndex);
+        return 0;
+    }
+
+    return ret;
+}
+
+static BOOL WINAPI hook_GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) {
+    dprintf("IDAC: GetComputerNameW -> ACAE01A99999999\n");
+
+    // Fake the computer name as ACAE01A999999999
+    wcscpy(lpBuffer, L"ACAE01A999999999");
+	*nSize = _countof(L"ACAE01A99999999");
+
+    return TRUE;
+}
+
+static DWORD WINAPI hook_GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
+    dprintf("IDAC: GetCurrentDirectoryW -> X:\\\n");
+
+    // Fake the current diretory as X:
+    wcscpy(lpBuffer, L"X");
+    return 1;
+}
+
+static BOOL WINAPI hook_GetVersionExW(LPOSVERSIONINFOW lpVersionInformation) {
+    int result = next_GetVersionExW(lpVersionInformation);
+
+    // Fake the version as Windows 10 1809
+    if (result) {
+        dprintf("IDAC: GetVersionExW -> Windows 10 1809\n");
+        lpVersionInformation->dwMajorVersion = 10;
+        lpVersionInformation->dwMinorVersion = 0;
+        lpVersionInformation->dwBuildNumber = 17763;
+        return TRUE;
+    }
+
+    return result;
+}
+
+static BOOL WINAPI hook_GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer) {
+    dprintf("IDAC: GetUserNameW -> AppUser\n");
+
+    // Fake the user name as AppUser
+    wcscpy(lpBuffer, L"AppUser");
+    *pcbBuffer = _countof(L"AppUser");
+
+    return TRUE;
+}
+
+static BOOL WINAPI hook_VerifyVersionInfoW(LPOSVERSIONINFOEXW lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask) {
+    BOOL result = next_VerifyVersionInfoW(lpVersionInformation, dwTypeMask, dwlConditionMask);
+
+    // Fake the version as Windows 10 1809
+    if (lpVersionInformation->dwBuildNumber == 17763) {
+        dprintf("IDAC: VerifyVersionInfoW -> Windows 10 1809\n");
+        return TRUE;
+    }
+
+    return result;
+}
+
+static BOOL WINAPI hook_K32EnumProcesses(DWORD *lpidProcess, DWORD cb, LPDWORD lpcbNeeded) {
+    BOOL result = next_K32EnumProcesses(lpidProcess, cb, lpcbNeeded);
+
+    // Rteurn an empy process list
+    dprintf("IDAC: K32EnumProcesses -> NULL\n");
+    lpidProcess = NULL;
+    *lpcbNeeded = 0;
+
+    return TRUE;
+}

idachook/indrun.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <windows.h>
+
+struct indrun_config {
+    bool enable;
+};
+
+void indrun_hook_init(struct indrun_config *cfg);

idachook/io4.c

@@ -11,10 +11,12 @@
 #include "util/dprintf.h"
 
 static HRESULT idac_io4_poll(void *ctx, struct io4_state *state);
+static HRESULT idac_io4_write_gpio(uint8_t* payload, size_t len);
 static uint16_t coins;
 
 static const struct io4_ops idac_io4_ops = {
     .poll = idac_io4_poll,
+    .write_gpio = idac_io4_write_gpio
 };
 
 static const uint16_t idac_gear_signals[] = {
@@ -128,3 +130,34 @@ static HRESULT idac_io4_poll(void *ctx, struct io4_state *state)
 
     return S_OK;
 }
+
+static HRESULT idac_io4_write_gpio(uint8_t* payload, size_t len) 
+{
+    // Just fast fail if there aren't enough bytes in the payload
+    if (len < 3) 
+        return S_OK;
+    
+    // This command is used for lights in IDAC, but it only contains button lights,
+    // and only in the first 3 bytes of the payload; everything else is padding to
+    // make the payload 62 bytes. The rest of the cabinet lights and the side button
+    // lights are handled separately, by the 15070 lights controller.
+    uint32_t lights_data = (uint32_t) ((uint8_t)(payload[0]) << 24 |
+        (uint8_t)(payload[1]) << 16 |
+        (uint8_t)(payload[2]) << 8);
+
+    // Since Sega uses an odd ordering for the first part of the bitfield,
+    // let's normalize the data and just send over bytes for the receiver
+    // to interpret as ON/OFF values.
+    uint8_t rgb_out[6] = {
+        lights_data & IDAC_IO_LED_START ? 0xFF : 0x00,
+        lights_data & IDAC_IO_LED_VIEW_CHANGE ? 0xFF : 0x00,
+        lights_data & IDAC_IO_LED_UP ? 0xFF : 0x00,
+        lights_data & IDAC_IO_LED_DOWN ? 0xFF : 0x00,
+        lights_data & IDAC_IO_LED_RIGHT ? 0xFF : 0x00,
+        lights_data & IDAC_IO_LED_LEFT ? 0xFF : 0x00,
+    };
+
+    idac_dll.led_set_leds(rgb_out);
+
+    return S_OK;
+}

idachook/meson.build

@@ -28,5 +28,7 @@ shared_library(
         'io4.h',
         'zinput.c',
         'zinput.h',
+        'indrun.c',
+        'indrun.h',
     ],
 )

idacio/dllmain.c

@@ -19,7 +19,7 @@ static bool idac_io_coin;
 
 uint16_t idac_io_get_api_version(void)
 {
-    return 0x0100;
+    return 0x0101;
 }
 
 HRESULT idac_io_init(void)
@@ -118,3 +118,44 @@ void idac_io_get_analogs(struct idac_io_analog_state *out)
     out->accel = tmp.accel;
     out->brake = tmp.brake;
 }
+
+HRESULT idac_io_led_init(void)
+{
+    return S_OK;
+}
+
+void idac_io_led_set_fet_output(const uint8_t *rgb)
+{
+#if 0
+    dprintf("IDAC LED: LEFT SEAT LED: %02X\n", rgb[0]);
+    dprintf("IDAC LED: RIGHT SEAT LED: %02X\n", rgb[1]);
+#endif
+
+    return;
+}
+
+void idac_io_led_gs_update(const uint8_t *rgb)
+{
+#if 0
+    for (int i = 0; i < 9; i++) {
+        dprintf("IDAC LED: LED %d: %02X %02X %02X Speed: %02X\n",
+                i, rgb[i * 4], rgb[i * 4 + 1], rgb[i * 4 + 2], rgb[i * 4 + 3]);
+    }
+#endif
+
+    return;
+}
+
+void idac_io_led_set_leds(const uint8_t *rgb)
+{
+#if 0
+    dprintf("IDAC LED: START: %02X\n", rgb[0]);
+    dprintf("IDAC LED: VIEW CHANGE: %02X\n", rgb[1]);
+    dprintf("IDAC LED: UP: %02X\n", rgb[2]);
+    dprintf("IDAC LED: DOWN: %02X\n", rgb[3]);
+    dprintf("IDAC LED: RIGHT: %02X\n", rgb[4]);
+    dprintf("IDAC LED: LEFT: %02X\n", rgb[5]);
+#endif
+
+    return;
+}

idacio/idacio.def

@@ -6,3 +6,7 @@ EXPORTS
     idac_io_get_gamebtns
     idac_io_get_shifter
     idac_io_get_analogs
+    idac_io_led_init
+    idac_io_led_set_fet_output
+    idac_io_led_gs_update
+    idac_io_led_set_leds

idacio/idacio.h

@@ -19,6 +19,17 @@ enum {
     IDAC_IO_GAMEBTN_VIEW_CHANGE = 0x20,
 };
 
+enum {
+    /* These are the bitmasks to use when checking which
+       lights are triggered on incoming IO4 GPIO writes. */
+    IDAC_IO_LED_START = 1 << 31,
+    IDAC_IO_LED_VIEW_CHANGE = 1 << 30,
+    IDAC_IO_LED_UP = 1 << 25,
+    IDAC_IO_LED_DOWN = 1 << 24,
+    IDAC_IO_LED_LEFT = 1 << 23,
+    IDAC_IO_LED_RIGHT = 1 << 22,
+};
+
 struct idac_io_analog_state {
     /* Current steering wheel position, where zero is the centered position.
 
@@ -92,4 +103,60 @@ void idac_io_get_analogs(struct idac_io_analog_state *out);
 
    Minimum API version: 0x0100 */
 
-void idac_io_get_shifter(uint8_t *gear);
+void idac_io_get_shifter(uint8_t *gear);
+
+/* Initialize LED emulation. This function will be called before any
+   other idac_io_led_*() function calls.
+
+   All subsequent calls may originate from arbitrary threads and some may
+   overlap with each other. Ensuring synchronization inside your IO DLL is
+   your responsibility. 
+   
+   Minimum API version: 0x0101 */
+
+HRESULT idac_io_led_init(void);
+
+/* Update the FET outputs. rgb is a pointer to an array up to 3 bytes.
+
+   The following bits are used to control the FET outputs:
+   [0]: LEFT SEAT LED
+   [1]: RIGHT SEAT LED
+
+   The LED is truned on when the byte is 255 and turned off when the byte is 0.
+
+   Minimum API version: 0x0101 */
+
+void idac_io_led_set_fet_output(const uint8_t *rgb);
+
+/* Update the RGB LEDs. rgb is a pointer to an array up to 32 * 4 = 128 bytes. 
+
+   The LEDs are laid out as follows:
+   [0]: LEFT UP LED
+   [1-2]: LEFT CENTER LED
+   [3]: LEFT DOWN LED
+   [5]: RIGHT UP LED
+   [6-7]: RIGHT CENTER LED
+   [8]: RIGHT DOWN LED
+
+   Each rgb value is comprised for 4 bytes in the order of R, G, B, Speed.
+   Speed is a value from 0 to 255, where 0 is the fastest speed and 255 is the slowest.
+
+   Minimum API version: 0x0101 */
+
+void idac_io_led_gs_update(const uint8_t *rgb);
+
+/* Update the cabinet button LEDs. rgb is a pointer to an array up to 6 bytes.
+
+   The LEDs are laid out as follows:
+   [0]: START LED
+   [1]: VIEW CHANGE LED
+   [2]: UP LED
+   [3]: DOWN LED
+   [4]: RIGHT LED
+   [5]: LEFT LED
+
+   The LED is turned on when the byte is 255 and turned off when the byte is 0.
+
+   Minimum API version: 0x0101 */
+
+void idac_io_led_set_leds(const uint8_t *rgb);

idzhook/dllmain.c

@@ -1,3 +1,14 @@
+/*
+    "Initial D ARCADE STAGE Zero" (idz) hook
+
+    Devices
+
+      JVS:  837-15257 "Type 4" I/O Board
+     COM1:  838-15069 MOTOR DRIVE BD RS232/422 Board
+    COM10:  837-15286 "Gen 2" Aime Reader
+    COM11:  837-15070-02 IC BD LED Controller Board
+*/
+
 #include <windows.h>
 #include <shlwapi.h>
 

jvs/jvs-cmd.h

@@ -9,6 +9,7 @@ enum {
     JVS_CMD_READ_SWITCHES = 0x20,
     JVS_CMD_READ_COIN = 0x21,
     JVS_CMD_READ_ANALOGS = 0x22,
+    JVS_CMD_READ_ROTARYS = 0x23,
     JVS_CMD_WRITE_GPIO = 0x32,
     JVS_CMD_RESET = 0xF0,
     JVS_CMD_ASSIGN_ADDR = 0xF1,
@@ -32,6 +33,11 @@ struct jvs_req_read_analogs {
     uint8_t nanalogs;
 };
 
+struct jvs_req_read_rotarys {
+    uint8_t cmd;
+    uint8_t nrotarys;
+};
+
 struct jvs_req_reset {
     uint8_t cmd;
     uint8_t unknown;

mai2hook/dllmain.c

@@ -1,3 +1,22 @@
+/*
+    "maimai DX" (mai2) hook
+
+    Devices
+
+    USB:    837-15257-01 "Type 4" I/O Board
+    USB:    2 * 601-13216 USB "QR Code" Camera (SDEZ2, SDEZ3)
+    USB:    601-13249 USB "Player" Camera (SDEZ1)
+    USB:    837-15067-02 IC BD USB to Serial 232
+            connected to
+            837-15070-04 LED Board Controller (COM21)
+            837-15070-04 LED Board Controller (COM23)
+
+    COM1:   837-15396 "Gen 3" Aime Reader
+    COM2:   200-6275 VFD GP1232A02A FUTABA Board
+    COM3:   509-6483 Touch Panel Controller
+    COM4:   509-6483 Touch Panel Controller
+*/
+
 #include <windows.h>
 
 #include "board/io4.h"
@@ -5,6 +24,8 @@
 #include "board/vfd.h"
 
 #include "hook/process.h"
+#include "hook/table.h"
+#include "hook/iohook.h"
 
 #include "hooklib/serial.h"
 #include "hooklib/spike.h"

mercuryhook/dllmain.c

@@ -1,3 +1,16 @@
+/*
+    "WACCA" (mercury) hook
+
+    Devices
+
+    USB:    837-15257-01 "Type 4" I/O Board
+    USB:    14-1497-R "Elisabeth" LED Board Controller
+    COM1:   837-15396 "Gen 3" Aime Reader
+    COM2:   200-6275 VFD GP1232A02A FUTABA Board
+    COM3:   PSS-7135-L02-01 "Left Side" Touch Board
+    COM4:   PSS-7135-L02-01 "Right Sdde" Touch Board
+*/
+
 #include <windows.h>
 
 #include "board/io4.h"

meson.build

@@ -14,6 +14,7 @@ add_project_arguments(
     '-D_WIN32_WINNT=_WIN32_WINNT_WIN7',
     '-DMINGW_HAS_SECURE_API=1',
     '-Wno-unused',
+    # '-ggdb',  # Add debug information
     language: 'c',
 )
 
@@ -23,7 +24,6 @@ if cc.get_id() != 'msvc'
     add_project_arguments(
         '-ffunction-sections',
         '-fdata-sections',
-        '-flto',  # Enable Link-Time Optimization
         language: 'c',
     )
 
@@ -32,8 +32,9 @@ if cc.get_id() != 'msvc'
         '-Wl,--exclude-all-symbols',
         '-Wl,--gc-sections',
         '-static-libgcc',
-        '-flto',  # Enable Link-Time Optimization
+        # '-ggdb',  # Add debug information
-        '-Wl,-s',  # Strip debug symbols
+        '-lcrypt32', # Bcrypt needed for prashook
+        # '-Wl,-s',  # Strip debug symbols
         language: 'c',
     )
 endif

mu3hook/config.c

@@ -28,6 +28,66 @@ void mu3_dll_config_load(
             filename);
 }
 
+void led15093_config_load(struct led15093_config *cfg, const wchar_t *filename)
+{
+    assert(cfg != NULL);
+    assert(filename != NULL);
+
+    wchar_t tmpstr[16];
+
+    memset(cfg->board_number, ' ', sizeof(cfg->board_number));
+    memset(cfg->chip_number, ' ', sizeof(cfg->chip_number));
+    memset(cfg->boot_chip_number, ' ', sizeof(cfg->boot_chip_number));
+
+    cfg->enable = GetPrivateProfileIntW(L"led15093", L"enable", 1, filename);
+    cfg->port_no = GetPrivateProfileIntW(L"led15093", L"portNo", 0, filename);
+    cfg->high_baudrate = GetPrivateProfileIntW(L"led15093", L"highBaud", 0, filename);
+    cfg->fw_ver = GetPrivateProfileIntW(L"led15093", L"fwVer", 0xA0, filename);
+    cfg->fw_sum = GetPrivateProfileIntW(L"led15093", L"fwSum", 0xAA53, filename);
+
+    GetPrivateProfileStringW(
+            L"led15093",
+            L"boardNumber",
+            L"15093-06",
+            tmpstr,
+            _countof(tmpstr),
+            filename);
+
+    size_t n = wcstombs(cfg->board_number, tmpstr, sizeof(cfg->board_number));
+    for (int i = n; i < sizeof(cfg->board_number); i++)
+    {
+        cfg->board_number[i] = ' ';
+    }
+
+    GetPrivateProfileStringW(
+            L"led15093",
+            L"chipNumber",
+            L"6710A",
+            tmpstr,
+            _countof(tmpstr),
+            filename);
+
+    n = wcstombs(cfg->chip_number, tmpstr, sizeof(cfg->chip_number));
+    for (int i = n; i < sizeof(cfg->chip_number); i++)
+    {
+        cfg->chip_number[i] = ' ';
+    }
+
+    GetPrivateProfileStringW(
+            L"led15093",
+            L"bootChipNumber",
+            L"6709 ",
+            tmpstr,
+            _countof(tmpstr),
+            filename);
+
+    n = wcstombs(cfg->boot_chip_number, tmpstr, sizeof(cfg->boot_chip_number));
+    for (int i = n; i < sizeof(cfg->boot_chip_number); i++)
+    {
+        cfg->boot_chip_number[i] = ' ';
+    }
+}
+
 void mu3_hook_config_load(
         struct mu3_hook_config *cfg,
         const wchar_t *filename)
@@ -40,6 +100,7 @@ void mu3_hook_config_load(
     dvd_config_load(&cfg->dvd, filename);
     io4_config_load(&cfg->io4, filename);
     gfx_config_load(&cfg->gfx, filename);
+    led15093_config_load(&cfg->led15093, filename);
     vfd_config_load(&cfg->vfd, filename);
     mu3_dll_config_load(&cfg->dll, filename);
     unity_config_load(&cfg->unity, filename);

mu3hook/config.h

@@ -3,7 +3,7 @@
 #include <stddef.h>
 
 #include "board/config.h"
-// #include "board/led15093.h"
+#include "board/led15093.h"
 
 #include "gfxhook/gfx.h"
 
@@ -21,7 +21,7 @@ struct mu3_hook_config {
     struct dvd_config dvd;
     struct io4_config io4;
     struct gfx_config gfx;
-    // struct led15093_config led15093;
+    struct led15093_config led15093;
     struct vfd_config vfd;
     struct mu3_dll_config dll;
     struct unity_config unity;

mu3hook/dllmain.c

@@ -1,3 +1,15 @@
+/*
+    "O.N.G.E.K.I." (mu3) hook
+
+    Devices
+
+    USB:    837-15257-01 "Type 4" I/O Board
+    USB:    3 * 601-13216 USB "QR Code" Camera (SDDT1-SDDT3)
+    COM1:   837-15396 "Gen 3" Aime Reader
+    COM2:   200-6275 VFD GP1232A02A FUTABA Board
+    COM3:   837-15093-06 LED Controller Board
+*/
+
 #include <windows.h>
 
 #include <stdlib.h>
@@ -62,14 +74,18 @@ static DWORD CALLBACK mu3_pre_startup(void)
         goto fail;
     }
 
-    /*
+    hr = mu3_dll_init(&mu3_hook_cfg.dll, mu3_hook_mod);
-    // Does not work, Unity moment
+
-    hr = led15093_hook_init(&mu3_hook_cfg.led15093, 3, 1, 1, 2);
+    if (FAILED(hr)) {
+        goto fail;
+    }
+
+    hr = led15093_hook_init(&mu3_hook_cfg.led15093, 
+        mu3_dll.led_init, mu3_dll.led_set_leds, 3, 1, 1, 2);
 
     if (FAILED(hr)) {
         return hr;
     }
-    */
 
     hr = sg_reader_hook_init(&mu3_hook_cfg.aime, 1, 1, mu3_hook_mod);
 
@@ -83,12 +99,6 @@ static DWORD CALLBACK mu3_pre_startup(void)
         goto fail;
     }
 
-    hr = mu3_dll_init(&mu3_hook_cfg.dll, mu3_hook_mod);
-
-    if (FAILED(hr)) {
-        goto fail;
-    }
-
     hr = mu3_io4_hook_init(&mu3_hook_cfg.io4);
 
     if (FAILED(hr)) {

mu3hook/io4.c

@@ -11,10 +11,13 @@
 #include "util/dprintf.h"
 
 static HRESULT mu3_io4_poll(void *ctx, struct io4_state *state);
+static HRESULT mu3_io4_write_gpio(uint8_t* payload, size_t len);
+
 static uint16_t coins;
 
 static const struct io4_ops mu3_io4_ops = {
     .poll = mu3_io4_poll,
+    .write_gpio = mu3_io4_write_gpio,
 };
 
 HRESULT mu3_io4_hook_init(const struct io4_config *cfg)
@@ -124,3 +127,46 @@ static HRESULT mu3_io4_poll(void *ctx, struct io4_state *state)
 
     return S_OK;
 }
+
+static HRESULT mu3_io4_write_gpio(uint8_t* payload, size_t len) 
+{
+    // Just fast fail if there aren't enough bytes in the payload
+    if (len < 3) 
+        return S_OK;
+
+    // This command is used for lights in Ongeki, but it only contains button lights,
+    // and only in the first 3 bytes of the payload; everything else is padding to
+    // make the payload 62 bytes. The rest of the cabinet lights and the side button
+    // lights are handled separately, by the 15093 lights controller.
+    uint32_t lights_data = (uint32_t) ((uint8_t)(payload[0]) << 24 |
+        (uint8_t)(payload[1]) << 16 |
+        (uint8_t)(payload[2]) << 8);
+
+    // Since Sega uses an odd ordering for the first part of the bitfield,
+    // let's normalize the data and just send over bytes for the receiver
+    // to interpret as RGB values.
+    uint8_t rgb_out[6 * 3] = {
+        lights_data & MU3_IO_LED_L1_R ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L1_G ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L1_B ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L2_R ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L2_G ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L2_B ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L3_R ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L3_G ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_L3_B ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R1_R ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R1_G ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R1_B ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R2_R ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R2_G ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R2_B ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R3_R ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R3_G ? 0xFF : 0x00,
+        lights_data & MU3_IO_LED_R3_B ? 0xFF : 0x00,
+    };
+
+    mu3_dll.led_set_leds(1, rgb_out);
+
+    return S_OK;
+}

mu3hook/mu3-dll.c

@@ -24,9 +24,28 @@ const struct dll_bind_sym mu3_dll_syms[] = {
     }, {
         .sym = "mu3_io_get_lever",
         .off = offsetof(struct mu3_dll, get_lever),
+    }, {
+        .sym = "mu3_io_led_init",
+        .off = offsetof(struct mu3_dll, led_init),
+    }, {
+        .sym = "mu3_io_led_set_colors",
+        .off = offsetof(struct mu3_dll, led_set_leds),
     }
 };
 
+/* Helper function to determine upon dll_bind failure whether the required functions were found
+   NOTE: relies on symbols order declared above */
+static HRESULT has_enough_symbols(uint16_t version, uint8_t count)
+{
+    if ( version <= 0x0100 && count == 5 )
+        return S_OK;
+
+    if ( version >= 0x0101 && count == 7 )
+        return S_OK;
+
+    return E_FAIL;
+}
+
 struct mu3_dll mu3_dll;
 
 // Copypasta DLL binding and diagnostic message boilerplate.
@@ -86,16 +105,25 @@ HRESULT mu3_dll_init(const struct mu3_dll_config *cfg, HINSTANCE self)
     }
 
     sym = mu3_dll_syms;
+    const struct dll_bind_sym *init_sym = &sym[0];
+
     hr = dll_bind(&mu3_dll, src, &sym, _countof(mu3_dll_syms));
 
     if (FAILED(hr)) {
         if (src != self) {
-            dprintf("Ongeki IO: Custom IO DLL does not provide function "
+            // Might still be ok depending on external dll API version
-                    "\"%s\". Please contact your IO DLL's developer for "
+            int bind_count = sym - init_sym;
-                    "further assistance.\n",
+            if (has_enough_symbols(mu3_dll.api_version, bind_count) == S_OK)
-                    sym->sym);
+            {
+                hr = S_OK;
+            } else {
+                dprintf("Ongeki IO: Custom IO DLL does not provide function "
+                        "\"%s\". Please contact your IO DLL's developer for "
+                        "further assistance.\n",
+                        sym->sym);
 
-            goto end;
+                goto end;
+            }
         } else {
             dprintf("Internal error: could not reflect \"%s\"\n", sym->sym);
         }

mu3hook/mu3-dll.h

@@ -11,6 +11,8 @@ struct mu3_dll {
     void (*get_opbtns)(uint8_t *opbtn);
     void (*get_gamebtns)(uint8_t *left, uint8_t *right);
     void (*get_lever)(int16_t *pos);
+    HRESULT (*led_init)(void);
+    void (*led_set_leds)(uint8_t board, uint8_t *rgb);
 };
 
 struct mu3_dll_config {

mu3hook/mu3hook.def

@@ -23,3 +23,5 @@ EXPORTS
     mu3_io_get_opbtns
     mu3_io_init
     mu3_io_poll
+    mu3_io_led_init
+    mu3_io_led_set_colors

mu3io/config.c

@@ -14,6 +14,8 @@ void mu3_io_config_load(
     assert(cfg != NULL);
     assert(filename != NULL);
 
+    wchar_t output_path_input[6];
+
     cfg->vk_test = GetPrivateProfileIntW(L"io4", L"test", VK_F1, filename);
     cfg->vk_service = GetPrivateProfileIntW(L"io4", L"service", VK_F2, filename);
     cfg->vk_coin = GetPrivateProfileIntW(L"io4", L"coin", VK_F3, filename);
@@ -30,4 +32,25 @@ void mu3_io_config_load(
     cfg->vk_right_3 = GetPrivateProfileIntW(L"io4", L"right3", 'L', filename);
     cfg->vk_left_menu = GetPrivateProfileIntW(L"io4", L"leftMenu", 'U', filename);
     cfg->vk_right_menu = GetPrivateProfileIntW(L"io4", L"rightMenu", 'O', filename);
+
+    cfg->cab_led_output_pipe = GetPrivateProfileIntW(L"led", L"cabLedOutputPipe", 1, filename);
+    cfg->cab_led_output_serial = GetPrivateProfileIntW(L"led", L"cabLedOutputSerial", 0, filename);
+    
+    cfg->controller_led_output_pipe = GetPrivateProfileIntW(L"led", L"controllerLedOutputPipe", 1, filename);
+    cfg->controller_led_output_serial = GetPrivateProfileIntW(L"led", L"controllerLedOutputSerial", 0, filename);
+
+    cfg->led_serial_baud = GetPrivateProfileIntW(L"led", L"serialBaud", 921600, filename);
+
+    GetPrivateProfileStringW(
+            L"led",
+            L"serialPort",
+            L"COM5",
+            output_path_input,
+            _countof(output_path_input),
+            filename);
+
+    // Sanitize the output path. If it's a serial COM port, it needs to be prefixed
+    // with `\\.\`.
+    wcsncpy(cfg->led_serial_port, L"\\\\.\\", 4);
+    wcsncat_s(cfg->led_serial_port, MAX_PATH, output_path_input, MAX_PATH);
 }

mu3io/config.h

@@ -22,6 +22,17 @@ struct mu3_io_config {
     uint8_t vk_right_3;
     uint8_t vk_left_menu;
     uint8_t vk_right_menu;
+
+    // Which ways to output LED information are enabled
+    bool cab_led_output_pipe;
+    bool cab_led_output_serial;
+    
+    bool controller_led_output_pipe;
+    bool controller_led_output_serial;
+
+    // The name of a COM port to output LED data on, in serial mode
+    wchar_t led_serial_port[12];
+    int32_t led_serial_baud;
 };
 
 void mu3_io_config_load(

mu3io/leddata.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <windows.h>
+
+#include <stdint.h>
+
+#define LED_PACKET_FRAMING 0xE0
+#define LED_PACKET_ESCAPE 0xD0
+#define LED_NUM_MAX 66
+#define LED_BOARDS_TOTAL 2
+#define LED_OUTPUT_HEADER_SIZE 2
+#define LED_OUTPUT_DATA_SIZE_MAX LED_NUM_MAX * 3 * 2  // max if every byte's escaped
+#define LED_OUTPUT_TOTAL_SIZE_MAX LED_OUTPUT_HEADER_SIZE + LED_OUTPUT_DATA_SIZE_MAX
+
+// This struct is used to send data related to the button and cab LEDs
+struct _ongeki_led_data_buf_t {
+    byte framing; // Sync byte
+    uint8_t board; // LED output the data is for (0: cab, 1: control deck)
+    byte data[LED_OUTPUT_DATA_SIZE_MAX]; // Buffer for LEDs
+    byte data_len; // How many bytes to output from the buffer
+};
+
+static byte ongeki_led_board_data_lens[LED_BOARDS_TOTAL] = {9*3, 6*3};

mu3io/ledoutput.c

@@ -0,0 +1,130 @@
+#include <windows.h>
+
+#include <process.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "mu3io/config.h"
+#include "mu3io/leddata.h"
+#include "mu3io/ledoutput.h"
+#include "mu3io/pipeimpl.h"
+#include "mu3io/serialimpl.h"
+
+static struct _ongeki_led_data_buf_t mu3_led_unescaped_buf[LED_BOARDS_TOTAL];
+static struct _ongeki_led_data_buf_t mu3_led_escaped_buf[LED_BOARDS_TOTAL];
+
+static bool mu3_led_output_is_init = false;
+static struct mu3_io_config* mu3_io_config;
+static bool mu3_led_any_outputs_enabled;
+
+HANDLE mu3_led_init_mutex;
+
+HRESULT mu3_led_output_init(struct mu3_io_config* const cfg)
+{
+    DWORD dwWaitResult = WaitForSingleObject(mu3_led_init_mutex, INFINITE);
+    if (dwWaitResult == WAIT_FAILED)
+    {
+        return HRESULT_FROM_WIN32(GetLastError());
+    }
+    else if (dwWaitResult != WAIT_OBJECT_0)
+    {
+        return E_FAIL;
+    }
+    
+    if (!mu3_led_output_is_init)
+    {
+        mu3_io_config = cfg;
+        
+        // Setup the framing bytes for the packets
+        for (int i = 0; i < LED_BOARDS_TOTAL; i++) {
+            mu3_led_unescaped_buf[i].framing = LED_PACKET_FRAMING;
+            mu3_led_unescaped_buf[i].board = i;
+            mu3_led_unescaped_buf[i].data_len = ongeki_led_board_data_lens[i];
+            
+            mu3_led_escaped_buf[i].framing = LED_PACKET_FRAMING;
+            mu3_led_escaped_buf[i].board = i;
+            mu3_led_escaped_buf[i].data_len = ongeki_led_board_data_lens[i];
+        }
+        
+        mu3_led_any_outputs_enabled = mu3_io_config->cab_led_output_pipe || mu3_io_config->controller_led_output_pipe
+            || mu3_io_config->cab_led_output_serial || mu3_io_config->controller_led_output_serial;
+        
+        if (mu3_io_config->cab_led_output_pipe || mu3_io_config->controller_led_output_pipe)
+        {
+            mu3_led_pipe_init();  // don't really care about errors here tbh
+        }
+        
+        if (mu3_io_config->cab_led_output_serial || mu3_io_config->controller_led_output_serial)
+        {
+            mu3_led_serial_init(mu3_io_config->led_serial_port, mu3_io_config->led_serial_baud);
+        }
+    }
+    
+    mu3_led_output_is_init = true;
+    
+    ReleaseMutex(mu3_led_init_mutex);
+    return S_OK;
+}
+
+struct _ongeki_led_data_buf_t* escape_led_data(struct _ongeki_led_data_buf_t* unescaped)
+{
+    struct _ongeki_led_data_buf_t* out_struct = &mu3_led_escaped_buf[unescaped->board];
+    
+    byte* in_buf = unescaped->data;
+    byte* out_buf = out_struct->data;
+    int i = 0;
+    int o = 0;
+    
+    while (i < unescaped->data_len)
+    {
+        byte b = in_buf[i++];
+        if (b == LED_PACKET_FRAMING || b == LED_PACKET_ESCAPE)
+        {
+            out_buf[o++] = LED_PACKET_ESCAPE;
+            b--;
+        }
+        out_buf[o++] = b;
+    }
+    
+    out_struct->data_len = o;
+    
+    return out_struct;
+}
+
+void mu3_led_output_update(int board, const byte* rgb)
+{
+    if (board < 0 || board > 1 || !mu3_led_any_outputs_enabled)
+    {
+        return;
+    }
+    
+    memcpy(mu3_led_unescaped_buf[board].data, rgb, mu3_led_unescaped_buf[board].data_len);
+    struct _ongeki_led_data_buf_t* escaped_data = escape_led_data(&mu3_led_unescaped_buf[board]);
+    
+    if (board == 0)
+    {
+        // cab
+        if (mu3_io_config->cab_led_output_pipe)
+        {
+            mu3_led_pipe_update(escaped_data);
+        }
+        
+        if (mu3_io_config->cab_led_output_serial)
+        {
+            mu3_led_serial_update(escaped_data);
+        }
+    }
+    else
+    {
+        // slider
+        if (mu3_io_config->controller_led_output_pipe)
+        {
+            mu3_led_pipe_update(escaped_data);
+        }
+        
+        if (mu3_io_config->controller_led_output_serial)
+        {
+            mu3_led_serial_update(escaped_data);
+        }
+    }
+}

mu3io/ledoutput.h

@@ -0,0 +1,20 @@
+/*
+    LED output functions
+    
+    Credits:
+    somewhatlurker, skogaby
+*/
+
+#pragma once
+
+#include <windows.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "mu3io/config.h"
+
+extern HANDLE mu3_led_init_mutex;
+
+HRESULT mu3_led_output_init(struct mu3_io_config* const cfg);
+void mu3_led_output_update(int board, const byte* rgb);

mu3io/meson.build

@@ -8,9 +8,16 @@ mu3io_lib = static_library(
         xinput_lib,
     ],
     sources : [
-        'mu3io.c',
-        'mu3io.h',
         'config.c',
         'config.h',
+        'leddata.h',
+        'ledoutput.c',
+        'ledoutput.h',
+        'mu3io.c',
+        'mu3io.h',
+        'pipeimpl.c',
+        'pipeimpl.h',
+        'serialimpl.c',
+        'serialimpl.h'
     ],
 )

mu3io/mu3io.c

@@ -6,6 +6,8 @@
 
 #include "mu3io/mu3io.h"
 #include "mu3io/config.h"
+#include "mu3io/ledoutput.h"
+
 #include "util/dprintf.h"
 
 static uint8_t mu3_opbtn;
@@ -21,7 +23,7 @@ const double MOUSE_SENSITIVITY = 0.5;
 
 uint16_t mu3_io_get_api_version(void)
 {
-    return 0x0100;
+    return 0x0101;
 }
 
 HRESULT mu3_io_init(void)
@@ -32,7 +34,17 @@ HRESULT mu3_io_init(void)
     dprintf("XInput: Mouse lever emulation : %i\n", mu3_io_cfg.use_mouse);
     dprintf("XInput: ---  End  configuration ---\n");
 
-    return S_OK;
+    mu3_led_init_mutex = CreateMutex(
+        NULL,              // default security attributes
+        FALSE,             // initially not owned
+        NULL);             // unnamed mutex
+    
+    if (mu3_led_init_mutex == NULL)
+    {
+        return E_FAIL;
+    }
+
+    return mu3_led_output_init(&mu3_io_cfg);
 }
 
 HRESULT mu3_io_poll(void)
@@ -195,3 +207,13 @@ void mu3_io_get_lever(int16_t *pos)
         *pos = mu3_lever_xpos;
     }
 }
+
+HRESULT mu3_io_led_init(void)
+{
+    return S_OK;
+}
+
+void mu3_io_led_set_colors(uint8_t board, uint8_t *rgb)
+{
+    mu3_led_output_update(board, rgb);
+}

mu3io/mu3io.h

@@ -1,5 +1,15 @@
 #pragma once
 
+/*
+   MU3 CUSTOM IO API
+
+   Changelog:
+
+   - 0x0100: Initial API version (assumed if chuni_io_get_api_version is not
+     exported)
+   - 0x0101: Added mu3_io_led_init and mu3_io_set_leds
+*/
+
 #include <windows.h>
 
 #include <stdint.h>
@@ -18,6 +28,29 @@ enum {
     MU3_IO_GAMEBTN_MENU = 0x10,
 };
 
+enum {
+    /* These are the bitmasks to use when checking which
+       lights are triggered on incoming IO4 GPIO writes. */
+    MU3_IO_LED_L1_R = 1 << 31,
+    MU3_IO_LED_L1_G = 1 << 28,
+    MU3_IO_LED_L1_B = 1 << 30,
+    MU3_IO_LED_L2_R = 1 << 27,
+    MU3_IO_LED_L2_G = 1 << 29,
+    MU3_IO_LED_L2_B = 1 << 26,
+    MU3_IO_LED_L3_R = 1 << 25,
+    MU3_IO_LED_L3_G = 1 << 24,
+    MU3_IO_LED_L3_B = 1 << 23,
+    MU3_IO_LED_R1_R = 1 << 22,
+    MU3_IO_LED_R1_G = 1 << 21,
+    MU3_IO_LED_R1_B = 1 << 20,
+    MU3_IO_LED_R2_R = 1 << 19,
+    MU3_IO_LED_R2_G = 1 << 18,
+    MU3_IO_LED_R2_B = 1 << 17,
+    MU3_IO_LED_R3_R = 1 << 16,
+    MU3_IO_LED_R3_G = 1 << 15,
+    MU3_IO_LED_R3_B = 1 << 14,
+};
+
 /* Get the version of the Ongeki IO API that this DLL supports. This
    function should return a positive 16-bit integer, where the high byte is
    the major version and the low byte is the minor version (as defined by the
@@ -83,3 +116,43 @@ void mu3_io_get_gamebtns(uint8_t *left, uint8_t *right);
    Minimum API version: 0x0100 */
 
 void mu3_io_get_lever(int16_t *pos);
+
+/* Initialize LED emulation. This function will be called before any
+   other mu3_io_led_*() function calls.
+
+   All subsequent calls may originate from arbitrary threads and some may
+   overlap with each other. Ensuring synchronization inside your IO DLL is
+   your responsibility. 
+   
+   Minimum API version: 0x0101 */
+
+HRESULT mu3_io_led_init(void);
+
+/* Update the RGB LEDs. rgb is a pointer to an array of up to 61 * 3 = 183 bytes.
+
+   ONGEKI uses one board with WS2811 protocol (each logical led corresponds to 3 
+   physical leds). Board 0 is used for all cab lights and both WAD button lights.
+
+   Board 0 has 61 LEDs:
+      [0]-[1]: left side button
+      [2]-[8]: left pillar lower LEDs
+      [9]-[17]: left pillar center LEDs
+      [18]-[24]: left pillar upper LEDs
+      [25]-[35]: billboard LEDs
+      [36]-[42]: right pillar upper LEDs
+      [43]-[51]: right pillar center LEDs
+      [52]-[58]: right pillar lower LEDs
+      [59]-[60]: right side button
+
+   Board 1 has 6 LEDs:
+      [0]-[5]: 3 left and 3 right controller buttons
+
+   Each rgb value is comprised of 3 bytes in R,G,B order. The tricky part is
+   that the board 0 is called from mu3 and the board 1 is called from amdaemon.
+   So the library must be able to handle both calls, using shared memory f.e.
+   This is up to the developer to decide how to handle this, recommended way is
+   to use the amdaemon process as the main one and the mu3 process as a sub one.
+
+   Minimum API version: 0x0101 */
+
+void mu3_io_led_set_colors(uint8_t board, uint8_t *rgb);

mu3io/pipeimpl.c

@@ -0,0 +1,160 @@
+#include <windows.h>
+
+#include <process.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "mu3io/leddata.h"
+#include "mu3io/pipeimpl.h"
+
+static bool mu3_pipe_update[LED_BOARDS_TOTAL];
+
+// incoming data is copied into these to ensure it isn't written during output
+static struct _ongeki_led_data_buf_t mu3_pipe_write_buf[LED_BOARDS_TOTAL];
+static HANDLE mu3_pipe_write_mutex;
+
+static HRESULT mu3_pipe_create(LPHANDLE hPipe, LPCWSTR lpszPipename, DWORD dwBufSize)
+{
+    *hPipe = INVALID_HANDLE_VALUE;
+    
+    *hPipe = CreateNamedPipeW( 
+        lpszPipename,                   // pipe name
+        PIPE_ACCESS_OUTBOUND,           // read/write access
+        PIPE_TYPE_BYTE |                // byte type pipe
+        PIPE_WAIT,                      // blocking mode
+        PIPE_UNLIMITED_INSTANCES,       // max. instances 
+        dwBufSize,                      // output buffer size
+        0,                              // input buffer size
+        0,                              // client time-out
+        NULL);                          // default security attribute
+    
+    if (*hPipe == INVALID_HANDLE_VALUE)
+    {
+        return E_FAIL;
+    }
+    
+    return S_OK;
+}
+
+static HRESULT mu3_pipe_write(HANDLE hPipe, LPCVOID lpBuffer, DWORD dwSize)
+{
+    DWORD cbWritten = 0;
+    
+    bool fSuccess = WriteFile( 
+        hPipe,
+        lpBuffer,
+        dwSize,
+        &cbWritten,
+        NULL);
+    
+    if (!fSuccess || cbWritten != dwSize) 
+    {
+        DWORD last_err = GetLastError();
+        return (last_err == ERROR_BROKEN_PIPE) ? E_ABORT : E_FAIL;
+    }
+
+    return S_OK;
+}
+
+static unsigned int __stdcall mu3_io_led_pipe_thread_proc(void *ctx)
+{
+    HANDLE hPipe;
+    LPCWSTR lpszPipename = L"\\\\.\\pipe\\ongeki_led";
+    
+    while (true)
+    {
+        hPipe = INVALID_HANDLE_VALUE;
+        
+        if (mu3_pipe_create(&hPipe, lpszPipename, LED_OUTPUT_TOTAL_SIZE_MAX) != S_OK)
+        {
+            continue;
+        }
+        
+        // wait for a connection to the pipe
+        bool fConnected = ConnectNamedPipe(hPipe, NULL) ?
+            true : (GetLastError() == ERROR_PIPE_CONNECTED);
+        
+        while (fConnected)
+        {
+            if (WaitForSingleObject(mu3_pipe_write_mutex, INFINITE) != WAIT_OBJECT_0)
+            {
+                continue;
+            }
+            
+            for (int i = 0; i < LED_BOARDS_TOTAL; i++) {
+                if (mu3_pipe_update[i])
+                {
+                    HRESULT result = mu3_pipe_write(
+                        hPipe,
+                        &mu3_pipe_write_buf[i],
+                        LED_OUTPUT_HEADER_SIZE + mu3_pipe_write_buf[i].data_len);
+
+                    if (result != S_OK)
+                    {
+                        //if (result == E_ABORT) 
+                        //{
+                            fConnected = false;
+                        //}
+                        break;
+                    }
+                    
+                    mu3_pipe_update[i] = false;
+                }
+            }
+            
+            ReleaseMutex(mu3_pipe_write_mutex);
+        }
+        
+        FlushFileBuffers(hPipe); 
+        DisconnectNamedPipe(hPipe);
+        CloseHandle(hPipe);
+    }
+    
+    return 0;
+}
+
+HRESULT mu3_led_pipe_init()
+{
+    mu3_pipe_write_mutex = CreateMutex(
+        NULL,              // default security attributes
+        FALSE,             // initially not owned
+        NULL);             // unnamed mutex
+    
+    if (mu3_pipe_write_mutex == NULL)
+    {
+        return E_FAIL;
+    }
+    
+    // clear out update bools
+    for (int i = 0; i < LED_BOARDS_TOTAL; i++) {
+        mu3_pipe_update[i] = false;
+    }
+    
+    _beginthreadex(
+            NULL,
+            0,
+            mu3_io_led_pipe_thread_proc,
+            0,
+            0,
+            NULL);
+    
+    return S_OK;
+}
+
+void mu3_led_pipe_update(struct _ongeki_led_data_buf_t* data)
+{
+    if (data->board > 1)
+    {
+        return;
+    }
+    
+    if (WaitForSingleObject(mu3_pipe_write_mutex, INFINITE) != WAIT_OBJECT_0)
+    {
+        return;
+    }
+    
+    memcpy(&mu3_pipe_write_buf[data->board], data, sizeof(struct _ongeki_led_data_buf_t));
+    mu3_pipe_update[data->board] = true;
+    
+    ReleaseMutex(mu3_pipe_write_mutex);
+}

mu3io/pipeimpl.h

@@ -0,0 +1,15 @@
+/*
+    Pipe implementation for chuniio
+    
+    Credits:
+    somewhatlurker, skogaby
+*/
+
+#pragma once
+
+#include <windows.h>
+
+#include "mu3io/leddata.h"
+
+HRESULT mu3_led_pipe_init();
+void mu3_led_pipe_update(struct _ongeki_led_data_buf_t* data);

mu3io/serialimpl.c

@@ -0,0 +1,88 @@
+#include <windows.h>
+
+#include <process.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "mu3io/leddata.h"
+#include "mu3io/serialimpl.h"
+
+#include "util/dprintf.h"
+
+static HANDLE mu3_serial_port;
+
+HRESULT mu3_led_serial_init(wchar_t led_com[12], DWORD baud)
+{
+    // Setup the serial communications
+    BOOL status;
+
+    mu3_serial_port = CreateFileW(led_com,
+            GENERIC_READ | GENERIC_WRITE,
+            0,
+            NULL,
+            OPEN_EXISTING,
+            0,
+            NULL);
+    
+    if (mu3_serial_port == INVALID_HANDLE_VALUE)
+    {
+        dprintf("Ongeki Serial LEDs: Failed to open COM port (attempted on %S)\n", led_com);
+        return E_FAIL;
+    }
+            
+    DCB dcb_serial_params = { 0 };
+    dcb_serial_params.DCBlength = sizeof(dcb_serial_params);
+    status = GetCommState(mu3_serial_port, &dcb_serial_params);
+    
+    dcb_serial_params.BaudRate = baud;
+    dcb_serial_params.ByteSize = 8;
+    dcb_serial_params.StopBits = ONESTOPBIT;
+    dcb_serial_params.Parity   = NOPARITY; 
+    SetCommState(mu3_serial_port, &dcb_serial_params);
+    
+    COMMTIMEOUTS timeouts = { 0 };
+    timeouts.ReadIntervalTimeout         = 50;
+    timeouts.ReadTotalTimeoutConstant    = 50; 
+    timeouts.ReadTotalTimeoutMultiplier  = 10;
+    timeouts.WriteTotalTimeoutConstant   = 50;
+    timeouts.WriteTotalTimeoutMultiplier = 10;
+    
+    SetCommTimeouts(mu3_serial_port, &timeouts);
+
+    if (!status)
+    {
+        return E_FAIL;
+    }
+
+    return S_OK;
+}
+
+void mu3_led_serial_update(struct _ongeki_led_data_buf_t* data)
+{
+    if (data->board > 1)
+    {
+        return;
+    }
+
+    if (mu3_serial_port != INVALID_HANDLE_VALUE) 
+    {
+        DWORD bytes_written = 0;
+
+        BOOL status = WriteFile(
+            mu3_serial_port, 
+            data, 
+            LED_OUTPUT_HEADER_SIZE + data->data_len, 
+            &bytes_written, 
+            NULL);
+
+        if (!status) 
+        {
+            DWORD last_err = GetLastError();
+            dprintf("Ongeki Serial LEDs: Serial port write failed -- %d\n", (int) last_err); 
+        }
+    } 
+    else 
+    {
+        dprintf("Ongeki Serial LEDs: Invalid serial port handle\n"); 
+    }
+}

mu3io/serialimpl.h

@@ -0,0 +1,15 @@
+/*
+    Serial LED implementation for chuniio
+    
+    Credits:
+    somewhatlurker, skogaby
+*/
+
+#pragma once
+
+#include <windows.h>
+
+#include "mu3io/leddata.h"
+
+HRESULT mu3_led_serial_init(wchar_t led_com[12], DWORD baud);
+void mu3_led_serial_update(struct _ongeki_led_data_buf_t* data);

platform/dns.c

@@ -105,6 +105,21 @@ HRESULT dns_platform_hook_init(const struct dns_config *cfg)
 
     hr = dns_hook_push(L"shop.tfps.thincacloud.com", cfg->startup);
 
+    if (FAILED(hr)) {
+        return hr;
+    }
+    
+    // CHN
+    // PowerOn
+    hr = dns_hook_push(L"at.sys-all.cn", cfg->startup);
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+    
+    // WeChat AimeDB Server
+    hr = dns_hook_push(L"ai.sys-all.cn", cfg->aimedb);
+
     if (FAILED(hr)) {
         return hr;
     }
@@ -126,7 +141,13 @@ HRESULT dns_platform_hook_init(const struct dns_config *cfg)
 
     // Disable api/polling to the original servers
 
-    hr = dns_hook_push(L"amlog.sys-all.net", NULL);
+    hr = dns_hook_push(L"*.amlog.sys-all.net", NULL);
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+
+    hr = dns_hook_push(L"*.d-amlog.sys-all.net", NULL);
 
     if (FAILED(hr)) {
         return hr;

platform/platform.c

@@ -76,7 +76,7 @@ HRESULT platform_hook_init(
         return hr;
     }
 
-    hr = vfs_hook_init(&cfg->vfs);
+    hr = vfs_hook_init(&cfg->vfs, game_id);
 
     if (FAILED(hr)) {
         return hr;

platform/vfs.c

@@ -9,6 +9,9 @@
 #include "hooklib/path.h"
 #include "hooklib/reg.h"
 
+#include "hook/procaddr.h"
+#include "hook/table.h"
+
 #include "platform/vfs.h"
 
 #include "util/dprintf.h"
@@ -31,6 +34,26 @@ static HRESULT vfs_path_hook_option(
 static HRESULT vfs_reg_read_amfs(void *bytes, uint32_t *nbytes);
 static HRESULT vfs_reg_read_appdata(void *bytes, uint32_t *nbytes);
 
+static wchar_t* hook_System_getAppRootPath();
+static wchar_t* (*next_System_getAppRootPath)();
+
+static wchar_t* hook_AppImage_getOptionMountRootPath();
+static wchar_t* (*next_AppImage_getOptionMountRootPath)();
+
+static const struct hook_symbol amdaemon_syms[] = {
+    {
+        .name = "System_getAppRootPath",
+        .patch = hook_System_getAppRootPath,
+        .link = (void **) &next_System_getAppRootPath,
+    },
+    {
+        .name = "AppImage_getOptionMountRootPath",
+        .patch = hook_AppImage_getOptionMountRootPath,
+        .link = (void **) &next_AppImage_getOptionMountRootPath,
+    },
+};
+
+static wchar_t game[5] = {0};
 static wchar_t vfs_nthome_real[MAX_PATH];
 static const wchar_t vfs_nthome[] = L"C:\\Documents and Settings\\AppUser";
 static const size_t vfs_nthome_len = _countof(vfs_nthome) - 1;
@@ -55,7 +78,7 @@ static const struct reg_hook_val vfs_reg_vals[] = {
 
 static struct vfs_config vfs_config;
 
-HRESULT vfs_hook_init(const struct vfs_config *config)
+HRESULT vfs_hook_init(const struct vfs_config *config, const char* game_id)
 {
     wchar_t temp[MAX_PATH];
     size_t nthome_len;
@@ -68,6 +91,8 @@ HRESULT vfs_hook_init(const struct vfs_config *config)
         return S_FALSE;
     }
 
+    mbstowcs(game, game_id, 4);
+
     if (config->amfs[0] == L'\0') {
         dprintf("Vfs: FATAL: AMFS path not specified in INI file\n");
 
@@ -175,6 +200,13 @@ HRESULT vfs_hook_init(const struct vfs_config *config)
         return hr;
     }
 
+    proc_addr_table_push(
+        NULL,
+        "amdaemon_api.dll",
+        amdaemon_syms,
+        _countof(amdaemon_syms)
+    );
+
     return S_OK;
 }
 
@@ -287,8 +319,6 @@ static HRESULT vfs_path_hook(const wchar_t *src, wchar_t *dest, size_t *count)
     }
 
     switch (src[0]) {
-    // case L'D': // later AMDaemon versions default to D: for AMFS if it can't find it
-    // case L'd':
     case L'e':
     case L'E':
         redir = vfs_config.amfs;
@@ -479,3 +509,21 @@ static HRESULT vfs_reg_read_appdata(void *bytes, uint32_t *nbytes)
 {
     return reg_hook_read_wstr(bytes, nbytes, L"Y:\\");
 }
+
+static wchar_t* hook_System_getAppRootPath()
+{
+    wchar_t *path = malloc(sizeof(wchar_t) * MAX_PATH);
+    wcscpy_s(path, MAX_PATH, vfs_config.appdata);
+    wcscat_s(path, MAX_PATH, game);
+    wcscat_s(path, MAX_PATH, L"\\");
+    
+    return path;
+}
+
+static wchar_t* hook_AppImage_getOptionMountRootPath()
+{
+    wchar_t *path = malloc(sizeof(wchar_t) * MAX_PATH);
+    wcscpy_s(path, MAX_PATH, vfs_config.option);
+
+    return path;
+}

platform/vfs.h

@@ -12,4 +12,4 @@ struct vfs_config {
     wchar_t option[MAX_PATH];
 };
 
-HRESULT vfs_hook_init(const struct vfs_config *config);
+HRESULT vfs_hook_init(const struct vfs_config *config, const char* game_id);

subprojects/capnhook.wrap

@@ -1,4 +1,4 @@
 [wrap-git]
 directory = capnhook
-url = https://github.com/decafcode/capnhook
+url = https://github.com/Hay1tsme/capnhook
-revision = 69f7e3b48c2e0ff5be1d7a83cdcc2597a458357b
+revision = 09306229f1fd09bae0e617865a26778d3537ff93

swdchook/dllmain.c

@@ -1,3 +1,18 @@
+/*
+    "SEGA World Drivers Championship" (swdc) hook
+
+    Devices
+
+    USB:    837-15257 "Type 4" I/O Board
+    USB:    838-15415 Indicator BD Main Board (COM21)
+            WITH
+            838-15416 Indicator BD LED Board
+    COM1:   838-15069 MOTOR DRIVE BD RS232/422 board
+    COM2:   837-15396 "Gen 3" Aime reader
+    COM3:   837-15070-04 IC BD LED controller board
+    COM4:   200-6275 VFD GP1232A02A FUTABA board
+*/
+
 #include <windows.h>
 #include <shlwapi.h>
 

unityhook/doorstop.c

@@ -8,7 +8,7 @@
 #include <pathcch.h>
 #include <psapi.h>
 
-#include "hooklib/procaddr.h"
+#include "hook/procaddr.h"
 #include "util/dprintf.h"
 
 #include "doorstop.h"
@@ -37,7 +37,7 @@ void doorstop_mono_hook_init(const struct unity_config *cfg, HINSTANCE module) {
 
     memcpy(&unity_config, cfg, sizeof(*cfg));
     load_mono_functions(module);
-    proc_addr_table_push(module_name, unity_mono_syms, _countof(unity_mono_syms));
+    proc_addr_table_push(NULL, module_name, unity_mono_syms, _countof(unity_mono_syms));
 
     doorstop_hook_initted = true;
 }
@@ -118,9 +118,19 @@ void doorstop_invoke(void* domain) {
         return;
     }
 
-    void *desc = mono_method_desc_new("*:Main", FALSE);
+    // BepInEx 5.4.23 has upgrade its doorstop version,
+    // which forces entrypoint to Doorstop.Entrypoint:Start
+
+    void *desc = mono_method_desc_new("Doorstop.Entrypoint:Start", TRUE);
     void *method = mono_method_desc_search_in_image(desc, image);
 
+    if (!method) {
+        // Fallback to old entrypoint definition.
+
+        desc = mono_method_desc_new("*:Main", FALSE);
+        method = mono_method_desc_search_in_image(desc, image);
+    }
+
     if (!method) {
         dprintf("Unity: Assembly does not have a valid entrypoint.\n");
         free(dll_path);

unityhook/hook.c

@@ -2,7 +2,16 @@
 #include <stdbool.h>
 
 #include "hook/table.h"
+#include "hook/procaddr.h"
+#include "hook/iohook.h"
+
+#include "hooklib/dll.h"
 #include "hooklib/path.h"
+#include "hooklib/printer.h"
+#include "hooklib/reg.h"
+#include "hooklib/touch.h"
+#include "hooklib/serial.h"
+
 #include "util/dprintf.h"
 
 #include "doorstop.h"
@@ -15,22 +24,37 @@ static const wchar_t *target_modules[] = {
     L"mono.dll",
     L"mono-2.0-bdwgc.dll",
     L"cri_ware_unity.dll",
+    L"amdaemon_api.dll",
+    L"SerialPortAPI.dll",
+    L"C300usb.dll",
+    L"C300FWDLusb.dll",
+    L"apmled.dll",
+    L"HKBSys_api.dll",
+    L"amptw.dll"
 };
+
 static const size_t target_modules_len = _countof(target_modules);
 
 static void dll_hook_insert_hooks(HMODULE target);
 
-static HMODULE WINAPI my_LoadLibraryW(const wchar_t *name);
+static HMODULE WINAPI hook_LoadLibraryW(const wchar_t *name);
 static HMODULE (WINAPI *next_LoadLibraryW)(const wchar_t *name);
+static HMODULE WINAPI hook_LoadLibraryExW(const wchar_t *name, HANDLE  hFile, DWORD   dwFlags);
+static HMODULE (WINAPI *next_LoadLibraryExW)(const wchar_t *name, HANDLE  hFile, DWORD   dwFlags);
 
 static const struct hook_symbol unity_kernel32_syms[] = {
     {
         .name = "LoadLibraryW",
-        .patch = my_LoadLibraryW,
+        .patch = hook_LoadLibraryW,
         .link = (void **) &next_LoadLibraryW,
-    },
+    }, {
+        .name  = "LoadLibraryExW",
+        .patch = hook_LoadLibraryExW,
+        .link  = (void **) &next_LoadLibraryExW,
+    }
 };
 
+
 void unity_hook_init(const struct unity_config *cfg, HINSTANCE self) {
     assert(cfg != NULL);
 
@@ -57,7 +81,14 @@ static void dll_hook_insert_hooks(HMODULE target) {
         _countof(unity_kernel32_syms));
 }
 
-static HMODULE WINAPI my_LoadLibraryW(const wchar_t *name) {
+static HMODULE WINAPI hook_LoadLibraryExW(const wchar_t *name, HANDLE  hFile, DWORD   dwFlags)
+{
+    // dprintf("Unity: LoadLibraryExW %ls\n", name);
+    return hook_LoadLibraryW(name);
+}
+
+static HMODULE WINAPI hook_LoadLibraryW(const wchar_t *name)
+{
     const wchar_t *name_end;
     const wchar_t *target_module;
     bool already_loaded;
@@ -107,6 +138,12 @@ static HMODULE WINAPI my_LoadLibraryW(const wchar_t *name) {
 
             dll_hook_insert_hooks(result);
             path_hook_insert_hooks(result);
+
+            // printer_hook_insert_hooks(result);
+            reg_hook_insert_hooks(result);
+            proc_addr_insert_hooks(result);
+            serial_hook_apply_hooks(result);
+            iohook_apply_hooks(result);
         }
     }