Merge pull request 'Throw fatal when vfs option configured but invalid' (#47) from Bottersnike/segatools:feat/vfs-validation into develop

Reviewed-on: Dniel97/segatools#47

Package.mk

@@ -203,6 +203,43 @@ $(BUILD_DIR_ZIP)/cm.zip:
 	$(V)strip $(BUILD_DIR_ZIP)/cm/*.{exe,dll}
 	$(V)cd $(BUILD_DIR_ZIP)/cm ; zip -r ../cm.zip *
 
+$(BUILD_DIR_ZIP)/tokyo.zip:
+	$(V)echo ... $@
+	$(V)mkdir -p $(BUILD_DIR_ZIP)/tokyo
+	$(V)mkdir -p $(BUILD_DIR_ZIP)/tokyo/DEVICE
+	$(V)cp $(BUILD_DIR_64)/subprojects/capnhook/inject/inject.exe \
+		$(BUILD_DIR_64)/tokyohook/tokyohook.dll \
+		$(DIST_DIR)/tokyo/config_hook.json \
+		$(DIST_DIR)/tokyo/segatools.ini \
+		$(DIST_DIR)/tokyo/start.bat \
+    	$(BUILD_DIR_ZIP)/tokyo
+	$(V)cp pki/billing.pub \
+		pki/ca.crt \
+    	$(BUILD_DIR_ZIP)/tokyo/DEVICE
+	$(V)strip $(BUILD_DIR_ZIP)/tokyo/*.{exe,dll}
+	$(V)cd $(BUILD_DIR_ZIP)/tokyo ; zip -r ../tokyo.zip *
+
+$(BUILD_DIR_ZIP)/kemono.zip:
+	$(V)echo ... $@
+	$(V)mkdir -p $(BUILD_DIR_ZIP)/kemono
+	$(V)mkdir -p $(BUILD_DIR_ZIP)/kemono/DEVICE
+	$(V)cp $(DIST_DIR)/kemono/segatools.ini \
+		$(DIST_DIR)/kemono/start.bat \
+		$(BUILD_DIR_ZIP)/kemono
+	$(V)cp $(BUILD_DIR_32)/kemonohook/kemonohook.dll \
+		$(BUILD_DIR_ZIP)/kemono/kemonohook_x86.dll
+	$(V)cp $(BUILD_DIR_64)/kemonohook/kemonohook.dll \
+		$(BUILD_DIR_ZIP)/kemono/kemonohook_x64.dll
+	$(V)cp $(BUILD_DIR_32)/subprojects/capnhook/inject/inject.exe \
+		$(BUILD_DIR_ZIP)/kemono/inject_x86.exe
+	$(V)cp $(BUILD_DIR_64)/subprojects/capnhook/inject/inject.exe \
+		$(BUILD_DIR_ZIP)/kemono/inject_x64.exe
+	$(V)cp pki/billing.pub \
+		pki/ca.crt \
+		$(BUILD_DIR_ZIP)/kemono/DEVICE
+	for x in exe dll; do strip $(BUILD_DIR_ZIP)/kemono/*.$$x; done
+	$(V)cd $(BUILD_DIR_ZIP)/kemono ; zip -r ../kemono.zip *
+
 $(BUILD_DIR_ZIP)/doc.zip: \
 		$(DOC_DIR)/config \
 		$(DOC_DIR)/chunihook.md \
@@ -225,7 +262,9 @@ $(BUILD_DIR_ZIP)/segatools.zip: \
 		$(BUILD_DIR_ZIP)/mu3.zip \
 		$(BUILD_DIR_ZIP)/mai2.zip \
 		$(BUILD_DIR_ZIP)/cm.zip \
+		$(BUILD_DIR_ZIP)/tokyo.zip \
 		$(BUILD_DIR_ZIP)/fgo.zip \
+		$(BUILD_DIR_ZIP)/kemono.zip \
 		CHANGELOG.md \
 		README.md \
 

README.md

@@ -1,33 +1,37 @@
 # Segatools
 
-Version: `2024-03-13`
+Version: `2024-09-30`
 
 Loaders and hardware emulators for SEGA games that run on the Nu and ALLS platforms.
 
 ## List of supported games
 
+* Card Maker
+  * starting from Card Maker
 * CHUNITHM
   * up to [CHUNITHM PARADISE LOST](doc/chunihook.md)
   * starting from CHUNITHM NEW!!
 * crossbeats REV.
   * up to crossbeats REV. SUNRISE
+* Fate/Grand Order
+  * Fate/Grand Order Arcade
+* Hatsune Miku: Project DIVA Arcade
+  * up to Future Tone
 * Initial D
   * [Initial D Arcade Stage Zero](doc/idzhook.md)
   * Initial D THE ARCADE
-* Hatsune Miku: Project DIVA Arcade
-  * up to Future Tone
-* SEGA World Drivers Championship
-  * SEGA World Drivers Championship 2019
-* Fate/Grand Order
-  * Fate/Grand Order Arcade
-* O.N.G.E.K.I.
-  * starting from O.N.G.E.K.I.
 * maimai DX
   * starting from maimai DX
-* Card Maker
-  * starting from Card Maker
+* Mario & Sonic
+  * Mario & Sonic at the Tokyo 2020 Olympics Arcade
+* O.N.G.E.K.I.
+  * starting from O.N.G.E.K.I.
+* SEGA World Drivers Championship
+  * SEGA World Drivers Championship 2019
 * WACCA
   * starting from WACCA
+* Kemono Friends
+  * Kemono Friends 3: Planet Tours
 
 ## End-users
 

board/config.c

@@ -90,4 +90,14 @@ void vfd_config_load(struct vfd_config *cfg, const wchar_t *filename)
     assert(filename != NULL);
 
     cfg->enable = GetPrivateProfileIntW(L"vfd", L"enable", 1, filename);
+    cfg->port = GetPrivateProfileIntW(L"vfd", L"portNo", 0, filename);
+    cfg->utf_conversion = GetPrivateProfileIntW(L"vfd", L"utfConversion", 0, filename);
+}
+
+void ffb_config_load(struct ffb_config *cfg, const wchar_t *filename)
+{
+    assert(cfg != NULL);
+    assert(filename != NULL);
+
+    cfg->enable = GetPrivateProfileIntW(L"ffb", L"enable", 1, filename);
 }

board/config.h

@@ -6,7 +6,9 @@
 #include "board/io4.h"
 #include "board/sg-reader.h"
 #include "board/vfd.h"
+#include "board/ffb.h"
 
 void aime_config_load(struct aime_config *cfg, const wchar_t *filename);
 void io4_config_load(struct io4_config *cfg, const wchar_t *filename);
 void vfd_config_load(struct vfd_config *cfg, const wchar_t *filename);
+void ffb_config_load(struct ffb_config *cfg, const wchar_t *filename);

board/ffb.c

@@ -0,0 +1,235 @@
+/*
+    Force Feedback Board (FFB)
+
+    This board is used by many SEGA games to provide force feedback to the player.
+    It is driven by the game software over a serial connection and is used by many
+    games such as SEGA World Drivers Championship, Initial D Arcade, ...
+
+    Part number in schematics is "838-15069 MOTOR DRIVE BD RS232/422 Board".
+
+    Some observations:
+    The maximal strength for any effect is 127, except Damper which maxes out at 40.
+    The period for rumble effects is in the range 0-40.
+*/
+
+#include "board/ffb.h"
+
+#include <assert.h>
+#include <stdint.h>
+#include <windows.h>
+
+#include "hook/iohook.h"
+#include "hooklib/uart.h"
+#include "util/dprintf.h"
+#include "util/dump.h"
+
+
+// request format:
+// 0x?? - sync + command
+// 0x?? - direction/additional command
+// 0x?? - strength
+// 0x?? - checksum (sum of everything except the sync byte)
+
+enum {
+    FFB_CMD_TOGGLE = 0x80,
+    FFB_CMD_CONSTANT_FORCE = 0x84,
+    FFB_CMD_RUMBLE = 0x85,
+    FFB_CMD_DAMPER = 0x86,
+};
+
+struct ffb_hdr {
+    uint8_t cmd;
+};
+
+union ffb_req_any {
+    struct ffb_hdr hdr;
+    uint8_t bytes[3];
+};
+
+static HRESULT ffb_handle_irp(struct irp *irp);
+
+static HRESULT ffb_req_dispatch(const union ffb_req_any *req);
+static HRESULT ffb_req_toggle(const uint8_t *bytes);
+static HRESULT ffb_req_constant_force(const uint8_t *bytes);
+static HRESULT ffb_req_rumble(const uint8_t *bytes);
+static HRESULT ffb_req_damper(const uint8_t *bytes);
+
+static const struct ffb_ops *ffb_ops;
+static struct uart ffb_uart;
+
+static bool ffb_started;
+static HRESULT ffb_start_hr;
+static uint8_t ffb_written[4];
+static uint8_t ffb_readable[4];
+
+/* Static variables to store maximum strength values */
+static uint8_t max_constant_force = 0;
+static uint8_t max_rumble = 0;
+static uint8_t max_period = 0;
+static uint8_t max_damper = 0;
+
+HRESULT ffb_hook_init(
+        const struct ffb_config *cfg,
+        const struct ffb_ops *ops,
+        unsigned int port_no)
+{
+    assert(cfg != NULL);
+    assert(ops != NULL);
+
+    if (!cfg->enable) {
+        return S_FALSE;
+    }
+
+    ffb_ops = ops;
+
+    uart_init(&ffb_uart, port_no);
+    ffb_uart.written.bytes = ffb_written;
+    ffb_uart.written.nbytes = sizeof(ffb_written);
+    ffb_uart.readable.bytes = ffb_readable;
+    ffb_uart.readable.nbytes = sizeof(ffb_readable);
+
+    dprintf("FFB: hook enabled.\n");
+
+    return iohook_push_handler(ffb_handle_irp);
+}
+
+static HRESULT ffb_handle_irp(struct irp *irp)
+{
+    HRESULT hr;
+
+    assert(irp != NULL);
+
+    if (!uart_match_irp(&ffb_uart, irp)) {
+        return iohook_invoke_next(irp);
+    }
+
+    hr = uart_handle_irp(&ffb_uart, irp);
+
+    if (FAILED(hr) || irp->op != IRP_OP_WRITE) {
+        return hr;
+    }
+
+    assert(&ffb_uart.written != NULL);
+    assert(ffb_uart.written.bytes != NULL || ffb_uart.written.nbytes == 0);
+    assert(ffb_uart.written.pos <= ffb_uart.written.nbytes);
+
+    // dprintf("FFB TX:\n");
+
+    hr = ffb_req_dispatch((const union ffb_req_any *) ffb_uart.written.bytes);
+
+    if (FAILED(hr)) {
+        dprintf("FFB: Processing error: %x\n", (int)hr);
+    }
+
+    // dump_iobuf(&ffb_uart.written);
+    ffb_uart.written.pos = 0;
+
+    return hr;
+}
+
+static HRESULT ffb_req_dispatch(const union ffb_req_any *req)
+{
+    switch (req->hdr.cmd) {
+    case FFB_CMD_TOGGLE:
+        return ffb_req_toggle(req->bytes);
+    case FFB_CMD_CONSTANT_FORCE:
+        return ffb_req_constant_force(req->bytes);
+    case FFB_CMD_RUMBLE:
+        return ffb_req_rumble(req->bytes);
+    case FFB_CMD_DAMPER:
+        return ffb_req_damper(req->bytes);
+
+    /* There are some test mode specfic commands which doesn't seem to be used in
+       game at all. The same is true for the initialization phase. */
+
+    default:
+        dprintf("FFB: Unhandled command %02x\n", req->hdr.cmd);
+
+        return S_OK;
+    }
+}
+
+static HRESULT ffb_req_toggle(const uint8_t *bytes)
+{
+    uint8_t activate = bytes[2];
+
+    if (activate == 0x01) {
+        dprintf("FFB: Activated\n");
+    } else {
+        dprintf("FFB: Deactivated\n");
+    }
+
+    if (ffb_ops->toggle != NULL) {
+        ffb_ops->toggle(activate == 0x01);
+    }
+
+    return S_OK;
+}
+
+static HRESULT ffb_req_constant_force(const uint8_t *bytes)
+{
+    // dprintf("FFB: Constant force\n");
+
+    uint8_t direction = bytes[1];
+    uint8_t force = bytes[2];
+
+    if (direction == 0x0) {
+        // Right
+        force = 128 - force;
+    }
+
+    // Update max strength if the current force is greater
+    if (force > max_constant_force) {
+        max_constant_force = force;
+    }
+
+    // dprintf("FFB: Constant Force Strength: %d (Max: %d)\n", force, max_constant_force);
+    if (ffb_ops->constant_force != NULL) {
+        ffb_ops->constant_force(direction, force);
+    }
+
+    return S_OK;
+}
+
+static HRESULT ffb_req_rumble(const uint8_t *bytes)
+{
+    // dprintf("FFB: Rumble\n");
+
+    uint8_t force = bytes[1];
+    uint8_t period = bytes[2];
+
+    // Update max strength if the current force is greater
+    if (force > max_rumble) {
+        max_rumble = force;
+    }
+
+    if (period > max_period) {
+        max_period = period;
+    }
+
+    // dprintf("FFB: Rumble Period: %d (Max %d), Strength: %d (Max: %d)\n", period, max_period, force, max_rumble);
+    if (ffb_ops->rumble != NULL) {
+        ffb_ops->rumble(force, period);
+    }
+
+    return S_OK;
+}
+
+static HRESULT ffb_req_damper(const uint8_t *bytes)
+{
+    // dprintf("FFB: Damper\n");
+
+    uint8_t force = bytes[2];
+
+    // Update max strength if the current force is greater
+    if (force > max_damper) {
+        max_damper = force;
+    }
+
+    // dprintf("FFB: Damper Strength: %d (Max: %d)\n", force, max_damper);
+    if (ffb_ops->damper != NULL) {
+        ffb_ops->damper(force);
+    }
+
+    return S_OK;
+}

board/ffb.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <windows.h>
+#include <stdbool.h>
+
+struct ffb_config {
+    bool enable;
+};
+
+struct ffb_ops {
+    void (*toggle)(bool active);
+    void (*constant_force)(uint8_t direction, uint8_t force);
+    void (*rumble)(uint8_t force, uint8_t period);
+    void (*damper)(uint8_t force);
+};
+
+HRESULT ffb_hook_init(
+        const struct ffb_config *cfg,
+        const struct ffb_ops *ops,
+        unsigned int port_no);

board/led15093-cmd.h

@@ -199,7 +199,7 @@ struct led15093_resp_board_info {
     char chip_num[5];
     uint8_t endcode; // Always 0xFF
     uint8_t fw_ver;
-    uint8_t rx_buf;
+    uint16_t rx_buf;
 };
 
 struct led15093_resp_protocol_ver {

board/meson.build

@@ -47,5 +47,10 @@ board_lib = static_library(
         'slider-frame.h',
         'vfd.c',
         'vfd.h',
+        'vfd-cmd.h',
+        'vfd-frame.c',
+        'vfd-frame.h',
+        'ffb.c',
+        'ffb.h'
     ],
 )

board/sg-nfc-cmd.h

@@ -5,19 +5,21 @@
 #pragma pack(push, 1)
 
 enum {
-    SG_NFC_CMD_GET_FW_VERSION       = 0x30,
-    SG_NFC_CMD_GET_HW_VERSION       = 0x32,
-    SG_NFC_CMD_RADIO_ON             = 0x40,
-    SG_NFC_CMD_RADIO_OFF            = 0x41,
-    SG_NFC_CMD_POLL                 = 0x42,
-    SG_NFC_CMD_MIFARE_SELECT_TAG    = 0x43,
-    SG_NFC_CMD_MIFARE_SET_KEY_BANA  = 0x50,
-    SG_NFC_CMD_MIFARE_READ_BLOCK    = 0x52,
-    SG_NFC_CMD_MIFARE_SET_KEY_AIME  = 0x54,
-    SG_NFC_CMD_MIFARE_AUTHENTICATE  = 0x55, /* guess based on time sent */
-    SG_NFC_CMD_SEND_HEX_DATA        = 0x61,
-    SG_NFC_CMD_RESET                = 0x62,
-    SG_NFC_CMD_FELICA_ENCAP         = 0x71,
+    SG_NFC_CMD_GET_FW_VERSION        = 0x30,
+    SG_NFC_CMD_GET_HW_VERSION        = 0x32,
+    SG_NFC_CMD_RADIO_ON              = 0x40,
+    SG_NFC_CMD_RADIO_OFF             = 0x41,
+    SG_NFC_CMD_POLL                  = 0x42,
+    SG_NFC_CMD_MIFARE_SELECT_TAG     = 0x43,
+    SG_NFC_CMD_MIFARE_SET_KEY_AIME   = 0x50,
+    SG_NFC_CMD_MIFARE_AUTHENTICATE_A = 0x51,
+    SG_NFC_CMD_MIFARE_READ_BLOCK     = 0x52,
+    SG_NFC_CMD_MIFARE_SET_KEY_BANA   = 0x54,
+    SG_NFC_CMD_MIFARE_AUTHENTICATE_B = 0x55,
+    SG_NFC_CMD_TO_UPDATE_MODE        = 0x60,
+    SG_NFC_CMD_SEND_HEX_DATA         = 0x61,
+    SG_NFC_CMD_RESET                 = 0x62,
+    SG_NFC_CMD_FELICA_ENCAP          = 0x71,
 };
 
 struct sg_nfc_res_get_fw_version {
@@ -32,7 +34,7 @@ struct sg_nfc_res_get_hw_version {
 
 struct sg_nfc_req_mifare_set_key {
     struct sg_req_header req;
-    uint8_t key_a[6];
+    uint8_t key[6];
 };
 
 struct sg_nfc_req_mifare_50 {

board/sg-nfc.c

@@ -60,6 +60,11 @@ static HRESULT sg_nfc_cmd_felica_encap(
         const struct sg_nfc_req_felica_encap *req,
         struct sg_nfc_res_felica_encap *res);
 
+static HRESULT sg_nfc_cmd_send_hex_data(
+        struct sg_nfc *nfc,
+        const struct sg_req_header *req,
+        struct sg_res_header *res);
+
 static HRESULT sg_nfc_cmd_dummy(
         struct sg_nfc *nfc,
         const struct sg_req_header *req,
@@ -184,13 +189,17 @@ static HRESULT sg_nfc_dispatch(
                 &req->felica_encap,
                 &res->felica_encap);
 
-    case SG_NFC_CMD_MIFARE_AUTHENTICATE:
+    case SG_NFC_CMD_MIFARE_AUTHENTICATE_A:
+    case SG_NFC_CMD_MIFARE_AUTHENTICATE_B:
+    case SG_NFC_CMD_SEND_HEX_DATA:
+        return sg_nfc_cmd_send_hex_data(nfc, &req->simple, &res->simple);
+
     case SG_NFC_CMD_MIFARE_SELECT_TAG:
     case SG_NFC_CMD_MIFARE_SET_KEY_AIME:
     case SG_NFC_CMD_MIFARE_SET_KEY_BANA:
     case SG_NFC_CMD_RADIO_ON:
     case SG_NFC_CMD_RADIO_OFF:
-    case SG_NFC_CMD_SEND_HEX_DATA: // TODO: implement?
+    case SG_NFC_CMD_TO_UPDATE_MODE:
         return sg_nfc_cmd_dummy(nfc, &req->simple, &res->simple);
 
     default:
@@ -442,6 +451,22 @@ static HRESULT sg_nfc_cmd_felica_encap(
     return S_OK;
 }
 
+static HRESULT sg_nfc_cmd_send_hex_data(
+        struct sg_nfc *nfc,
+        const struct sg_req_header *req,
+        struct sg_res_header *res)
+{
+    sg_res_init(res, req, 0);
+
+    /* Firmware checksum length? */
+    if (req->payload_len == 0x2b) {
+         /* The firmware is identical flag? */
+        res->status = 0x20;
+    }
+
+    return S_OK;
+}
+
 static HRESULT sg_nfc_cmd_dummy(
         struct sg_nfc *nfc,
         const struct sg_req_header *req,

board/vfd-cmd.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include "board/vfd-frame.h"
+
+enum {
+    VFD_CMD_GET_VERSION = 0x5B,
+    VFD_CMD_RESET = 0x0B,
+    VFD_CMD_CLEAR_SCREEN = 0x0C,
+    VFD_CMD_SET_BRIGHTNESS = 0x20,
+    VFD_CMD_SET_SCREEN_ON = 0x21,
+    VFD_CMD_SET_H_SCROLL = 0x22,
+    VFD_CMD_DRAW_IMAGE = 0x2E,
+    VFD_CMD_SET_CURSOR = 0x30,
+    VFD_CMD_SET_ENCODING = 0x32,
+    VFD_CMD_SET_TEXT_WND = 0x40,
+    VFD_CMD_SET_TEXT_SPEED = 0x41,
+    VFD_CMD_WRITE_TEXT = 0x50,
+    VFD_CMD_ENABLE_SCROLL = 0x51,
+    VFD_CMD_DISABLE_SCROLL = 0x52,
+    VFD_CMD_ROTATE = 0x5D,
+    VFD_CMD_CREATE_CHAR = 0xA3,
+    VFD_CMD_CREATE_CHAR2 = 0xA4,
+};
+
+enum {
+    VFD_ENC_GB2312    = 0,
+    VFD_ENC_BIG5      = 1,
+    VFD_ENC_SHIFT_JIS = 2,
+    VFD_ENC_KSC5601   = 3,
+    VFD_ENC_MAX = 3,
+};
+
+struct vfd_req_hdr {
+    uint8_t sync;
+    uint8_t cmd;
+};
+
+struct vfd_req_any {
+    struct vfd_req_hdr hdr;
+    uint8_t payload[2054];
+};
+
+struct vfd_req_board_info {
+    struct vfd_req_hdr hdr;
+    uint8_t unk1;
+};
+
+struct vfd_resp_board_info { // \x0201.20\x03
+    uint8_t unk1;
+    char version[5];
+    uint8_t unk2;
+};
+
+struct vfd_req_reset {
+    struct vfd_req_hdr hdr;
+};
+
+struct vfd_req_cls {
+    struct vfd_req_hdr hdr;
+};
+
+struct vfd_req_brightness {
+    struct vfd_req_hdr hdr;
+    uint8_t brightness;
+};
+
+struct vfd_req_power {
+    struct vfd_req_hdr hdr;
+    uint8_t power_state;
+};
+
+struct vfd_req_hscroll {
+    struct vfd_req_hdr hdr;
+    uint8_t x_pos;
+};
+
+struct vfd_req_draw {
+    struct vfd_req_hdr hdr;
+    uint16_t x0;
+    uint8_t y0;
+    uint16_t x1;
+    uint8_t y1;
+    uint8_t image[2048];
+};
+
+struct vfd_req_cursor {
+    struct vfd_req_hdr hdr;
+    uint16_t x;
+    uint8_t y;
+};
+
+struct vfd_req_encoding {
+    struct vfd_req_hdr hdr;
+    uint8_t encoding;
+};
+
+struct vfd_req_wnd {
+    struct vfd_req_hdr hdr;
+    uint16_t x0;
+    uint8_t y0;
+    uint16_t x1;
+    uint8_t y1;
+};
+
+struct vfd_req_speed {
+    struct vfd_req_hdr hdr;
+    uint8_t encoding;
+};
+
+struct vfd_req_scroll {
+    struct vfd_req_hdr hdr;
+};
+
+struct vfd_req_rotate {
+    struct vfd_req_hdr hdr;
+    uint8_t unk1;
+};
+
+struct vfd_req_create_char {
+    struct vfd_req_hdr hdr;
+    uint8_t type;
+    uint8_t pixels[32];
+};

board/vfd-frame.c

@@ -0,0 +1,88 @@
+#include <windows.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define SUPER_VERBOSE 1
+
+#include "board/vfd-frame.h"
+
+#include "hook/iobuf.h"
+
+#include "util/dprintf.h"
+
+static HRESULT vfd_frame_encode_byte(struct iobuf *dest, uint8_t byte);
+
+/* Frame structure:
+
+    REQUEST:
+   [0] Sync byte (0x1A or 0x1B)
+   [1] Packet ID
+   [2...n-1] Data/payload
+
+   --- OR ---
+
+   if no sync byte is given, plain static text in the currently configured encoding is expected.
+
+   RESPONSE:
+   This thing never responds, unless it's VFD_CMD_GET_VERSION
+   */
+
+bool vfd_frame_sync(struct const_iobuf *src) {
+    return src->bytes[src->pos] == VFD_SYNC_BYTE || src->bytes[src->pos] == VFD_SYNC_BYTE2;
+}
+
+HRESULT vfd_frame_encode(
+        struct iobuf *dest,
+        const void *ptr,
+        size_t nbytes) {
+    const uint8_t *src;
+    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;
+
+    if (dest->pos >= dest->nbytes) {
+        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+    }
+
+#if SUPER_VERBOSE
+    dprintf("VFD: RX Buffer:\n");
+#endif
+
+    for (i = 1; i < nbytes; i++) {
+        byte = src[i];
+#if SUPER_VERBOSE
+        dprintf("%02x ", byte);
+#endif
+
+        hr = vfd_frame_encode_byte(dest, byte);
+
+        if (FAILED(hr)) {
+            return hr;
+        }
+    }
+#if SUPER_VERBOSE
+    dprintf("\n");
+#endif
+
+    return hr;
+}
+
+static HRESULT vfd_frame_encode_byte(struct iobuf *dest, uint8_t byte) {
+    if (dest->pos + 1 > dest->nbytes) {
+        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+    }
+
+    dest->bytes[dest->pos++] = byte;
+
+    return S_OK;
+}

board/vfd-frame.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <windows.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hook/iobuf.h"
+
+enum {
+    VFD_SYNC_BYTE = 0x1B,
+    VFD_SYNC_BYTE2 = 0x1A,
+};
+
+bool vfd_frame_sync(struct const_iobuf *src);
+
+HRESULT vfd_frame_encode(
+        struct iobuf *dest,
+        const void *ptr,
+        size_t nbytes);

board/vfd.c

@@ -2,17 +2,16 @@
    directly by amdaemon, and it has something to do with displaying the status
    of electronic payments.
 
-   Part number in schematics is "VFD GP1232A02A FUTABA".
-
-   Little else about this board is known. Black-holing the RS232 comms that it
-   receives seems to be sufficient for the time being. */
+   Part number in schematics is "VFD GP1232A02A FUTABA". */
 
 #include <windows.h>
 
 #include <assert.h>
 #include <stdint.h>
 
+#include "board/config.h"
 #include "board/vfd.h"
+#include "board/vfd-cmd.h"
 
 #include "hook/iohook.h"
 
@@ -21,33 +20,101 @@
 #include "util/dprintf.h"
 #include "util/dump.h"
 
+#define SUPER_VERBOSE 0
+
 static HRESULT vfd_handle_irp(struct irp *irp);
 
 static struct uart vfd_uart;
-static uint8_t vfd_written[512];
-static uint8_t vfd_readable[512];
-UINT codepage;
+static uint8_t vfd_written[4096];
+static uint8_t vfd_readable[4096];
 
-HRESULT vfd_hook_init(const struct vfd_config *cfg, unsigned int port_no)
+static int encoding = VFD_ENC_SHIFT_JIS;
+
+HRESULT vfd_handle_get_version(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_reset(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_clear_screen(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_brightness(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_screen_on(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_h_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_draw_image(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_cursor(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_encoding(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_text_wnd(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_set_text_speed(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_write_text(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_enable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_disable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_rotate(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_create_char(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+HRESULT vfd_handle_create_char2(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
+
+static bool utf_enabled;
+
+HRESULT vfd_hook_init(struct vfd_config *cfg, int default_port)
 {
-    assert(cfg != NULL);
-
-    if (!cfg->enable) {
+    if (!cfg->enable){
         return S_FALSE;
     }
 
-    uart_init(&vfd_uart, port_no);
+    utf_enabled = cfg->utf_conversion;
+
+    int port = cfg->port;
+    if (port == 0){
+        port = default_port;
+    }
+
+    dprintf("VFD: enabling (port=%d)\n", port);
+    uart_init(&vfd_uart, port);
     vfd_uart.written.bytes = vfd_written;
     vfd_uart.written.nbytes = sizeof(vfd_written);
     vfd_uart.readable.bytes = vfd_readable;
     vfd_uart.readable.nbytes = sizeof(vfd_readable);
 
-    codepage = GetACP();
-    dprintf("VFD: hook enabled.\n");
-
     return iohook_push_handler(vfd_handle_irp);
 }
 
+
+const char* get_encoding_name(int b){
+    switch (b){
+        case 0: return "gb2312";
+        case 1: return "big5";
+        case 2: return "shift-jis";
+        case 3: return "ks_c_5601-1987";
+        default: return "unknown";
+    }
+}
+
+void print_vfd_text(const char* str, int len){
+
+    if (utf_enabled){
+
+        wchar_t encoded[1024];
+        memset(encoded, 0, 1024 * sizeof(wchar_t));
+
+        int codepage = 0;
+        if (encoding == VFD_ENC_GB2312){
+            codepage = 936;
+        } else if (encoding == VFD_ENC_BIG5){
+            codepage = 950;
+        } else if (encoding == VFD_ENC_SHIFT_JIS){
+            codepage = 932;
+        } else if (encoding == VFD_ENC_KSC5601) {
+            codepage = 949;
+        }
+
+        if (!MultiByteToWideChar(codepage, MB_USEGLYPHCHARS, str, len, encoded, 1024)){
+            dprintf("VFD: Text conversion failed: %ld", GetLastError());
+            return;
+        }
+
+        dprintf("VFD: Text: %ls\n", encoded);
+    } else {
+
+        dprintf("VFD: Text: %s\n", str);
+
+    }
+}
+
 static HRESULT vfd_handle_irp(struct irp *irp)
 {
     HRESULT hr;
@@ -58,67 +125,274 @@ static HRESULT vfd_handle_irp(struct irp *irp)
         return iohook_invoke_next(irp);
     }
 
+    if (irp->op == IRP_OP_OPEN){
+        dprintf("VFD: Open\n");
+    } else if (irp->op == IRP_OP_CLOSE){
+        dprintf("VFD: Close\n");
+    }
+
     hr = uart_handle_irp(&vfd_uart, irp);
 
     if (FAILED(hr) || irp->op != IRP_OP_WRITE) {
         return hr;
     }
 
-    uint8_t cmd = 0;
-    uint8_t str_1[512];
-    uint8_t str_2[512];
-    uint8_t str_1_len = 0;
-    uint8_t str_2_len = 0;
-    for (size_t i = 0; i < vfd_uart.written.pos; i++) {
-        if (vfd_uart.written.bytes[i] == 0x1B) {
-            i++;
-            cmd = vfd_uart.written.bytes[i];
-            if (cmd == 0x30) {
-                i += 3;
-            }
-            else if (cmd == 0x50) {
-                i++;
-            }
-            continue;
-        }
-        if (cmd == 0x30) {
-            str_1[str_1_len++] = vfd_uart.written.bytes[i];
-        }
-        else if (cmd == 0x50) {
-            str_2[str_2_len++] = vfd_uart.written.bytes[i];
-        }
-    }
+#if SUPER_VERBOSE
+    dprintf("VFD TX:\n");
+    dump_iobuf(&vfd_uart.written);
+#endif
 
-    if (str_1_len) {
-        str_1[str_1_len++] = '\0';
-        if (codepage != 932) {
-            WCHAR buffer[512];
-            MultiByteToWideChar(932, 0, (LPCSTR)str_1, str_1_len, buffer, str_1_len);
-            char str_recode[str_1_len * 3];
-            WideCharToMultiByte(codepage, 0, buffer, str_1_len, str_recode, str_1_len * 3, NULL, NULL);
-            dprintf("VFD: %s\n", str_recode);
-        }
-        else {
-            dprintf("VFD: %s\n", str_1);
-        }
-    }
+    struct const_iobuf reader;
+    iobuf_flip(&reader, &vfd_uart.written);
 
-    if (str_2_len) {
-        str_2[str_2_len++] = '\0';
-        if (codepage != 932) {
-            WCHAR buffer[512];
-            MultiByteToWideChar(932, 0, (LPCSTR)str_2, str_2_len, buffer, str_2_len);
-            char str_recode[str_2_len * 3];
-            WideCharToMultiByte(codepage, 0, buffer, str_2_len, str_recode, str_2_len * 3, NULL, NULL);
-            dprintf("VFD: %s\n", str_recode);
+    struct iobuf* writer = &vfd_uart.readable;
+    for (; reader.pos < reader.nbytes ; ){
+
+        if (vfd_frame_sync(&reader)) {
+
+            reader.pos++; // get the sync byte out of the way
+
+            uint8_t cmd;
+            iobuf_read_8(&reader, &cmd);
+
+            if (cmd == VFD_CMD_GET_VERSION) {
+                hr = vfd_handle_get_version(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_RESET) {
+                hr = vfd_handle_reset(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_CLEAR_SCREEN) {
+                hr = vfd_handle_clear_screen(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_BRIGHTNESS) {
+                hr = vfd_handle_set_brightness(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_SCREEN_ON) {
+                hr = vfd_handle_set_screen_on(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_H_SCROLL) {
+                hr = vfd_handle_set_h_scroll(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_DRAW_IMAGE) {
+                hr = vfd_handle_draw_image(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_CURSOR) {
+                hr = vfd_handle_set_cursor(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_ENCODING) {
+                hr = vfd_handle_set_encoding(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_TEXT_WND) {
+                hr = vfd_handle_set_text_wnd(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_SET_TEXT_SPEED) {
+                hr = vfd_handle_set_text_speed(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_WRITE_TEXT) {
+                hr = vfd_handle_write_text(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_ENABLE_SCROLL) {
+                hr = vfd_handle_enable_scroll(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_DISABLE_SCROLL) {
+                hr = vfd_handle_disable_scroll(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_ROTATE) {
+                hr = vfd_handle_rotate(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_CREATE_CHAR) {
+                hr = vfd_handle_create_char(&reader, writer, &vfd_uart);
+            } else if (cmd == VFD_CMD_CREATE_CHAR2) {
+                hr = vfd_handle_create_char2(&reader, writer, &vfd_uart);
+            } else {
+                dprintf("VFD: Unknown command 0x%x\n", cmd);
+                dump_const_iobuf(&reader);
+                hr = S_FALSE;
+            }
         } else {
-            dprintf("VFD: %s\n", str_2);
+
+            // if no sync byte is sent, we are just getting plain text...
+
+            if (reader.pos < reader.nbytes){
+                int len = 0;
+
+                // read chars until we hit a new sync byte or the data ends
+                while (reader.pos + len + 1 < reader.nbytes && reader.bytes[reader.pos + len] != VFD_SYNC_BYTE && reader.bytes[reader.pos + len] != VFD_SYNC_BYTE2){
+                    len++;
+                }
+
+                char* str = malloc(len);
+                memset(str, 0, len);
+                iobuf_read(&reader, str, len);
+                print_vfd_text(str, len);
+                free(str);
+
+                reader.pos += len;
+            }
+
         }
+
+        if (!SUCCEEDED(hr)){
+            return hr;
+        }
+
     }
 
-    // dprintf("VFD TX:\n");
-    // dump_iobuf(&vfd_uart.written);
     vfd_uart.written.pos = 0;
 
     return hr;
 }
+
+HRESULT vfd_handle_get_version(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    dprintf("VFD: Get Version\n");
+
+    struct vfd_resp_board_info resp;
+
+    memset(&resp, 0, sizeof(resp));
+    resp.unk1 = 2;
+    strcpy(resp.version, "01.20");
+    resp.unk2 = 1;
+
+    return vfd_frame_encode(writer, &resp, sizeof(resp));
+}
+HRESULT vfd_handle_reset(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    dprintf("VFD: Reset\n");
+
+    encoding = VFD_ENC_SHIFT_JIS;
+
+    return S_FALSE;
+}
+HRESULT vfd_handle_clear_screen(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    dprintf("VFD: Clear Screen\n");
+
+    return S_FALSE;
+}
+HRESULT vfd_handle_set_brightness(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b;
+    iobuf_read_8(reader, &b);
+
+    if (b > 4){
+        dprintf("VFD: Brightness, invalid argument\n");
+        return E_FAIL;
+    }
+
+    dprintf("VFD: Brightness, %d\n", b);
+
+    return S_FALSE;
+}
+HRESULT vfd_handle_set_screen_on(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b;
+    iobuf_read_8(reader, &b);
+
+    if (b > 1){
+        dprintf("VFD: Screen Power, invalid argument\n");
+        return E_FAIL;
+    }
+
+    dprintf("VFD: Screen Power, %d\n", b);
+    return S_FALSE;
+}
+HRESULT vfd_handle_set_h_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t x;
+    iobuf_read_8(reader, &x);
+
+    dprintf("VFD: Horizontal Scroll, X=%d\n", x);
+    return S_FALSE;
+}
+HRESULT vfd_handle_draw_image(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    int w, h;
+    uint16_t x0, x1;
+    uint8_t y0, y1;
+    uint8_t image[2048];
+
+    iobuf_read_be16(reader, &x0);
+    iobuf_read_8(reader, &y0);
+    iobuf_read_be16(reader, &x1);
+    iobuf_read_8(reader, &y1);
+    w = x1 - x0;
+    h = y1 - y0;
+    iobuf_read(reader, image, w*h);
+
+    dprintf("VFD: Draw image, %dx%d\n", w, h);
+    return S_FALSE;
+}
+
+HRESULT vfd_handle_set_cursor(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint16_t x;
+    uint8_t y;
+
+    iobuf_read_be16(reader, &x);
+    iobuf_read_8(reader, &y);
+
+    dprintf("VFD: Set Cursor, x=%d,y=%d\n", x, y);
+
+    return S_FALSE;
+}
+
+HRESULT vfd_handle_set_encoding(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b;
+    iobuf_read_8(reader, &b);
+
+    dprintf("VFD: Set Encoding, %d (%s)\n", b, get_encoding_name(b));
+
+    if (b < 0 || b > VFD_ENC_MAX){
+        dprintf("Invalid encoding specified\n");
+        return E_FAIL;
+    }
+
+    encoding = b;
+
+    return S_FALSE;
+}
+HRESULT vfd_handle_set_text_wnd(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint16_t x0, x1;
+    uint8_t y0, y1;
+
+    iobuf_read_be16(reader, &x0);
+    iobuf_read_8(reader, &y0);
+    iobuf_read_be16(reader, &x1);
+    iobuf_read_8(reader, &y1);
+
+    dprintf("VFD: Set Text Window, p0:%d,%d, p1:%d,%d\n", x0, y0, x1, y1);
+    return S_FALSE;
+}
+HRESULT vfd_handle_set_text_speed(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b;
+    iobuf_read_8(reader, &b);
+
+    dprintf("VFD: Set Text Speed, %d\n", b);
+    return S_FALSE;
+}
+HRESULT vfd_handle_write_text(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t len;
+    iobuf_read_8(reader, &len);
+
+    char* str = malloc(len);
+    iobuf_read(reader, str, len);
+
+    print_vfd_text(str, len);
+    free(str);
+
+    return S_FALSE;
+}
+HRESULT vfd_handle_enable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    dprintf("VFD: Enable Scrolling\n");
+    return S_FALSE;
+}
+HRESULT vfd_handle_disable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    dprintf("VFD: Disable Scrolling\n");
+    return S_FALSE;
+}
+HRESULT vfd_handle_rotate(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b;
+    iobuf_read_8(reader, &b);
+
+    dprintf("VFD: Rotate, %d\n", b);
+    return S_FALSE;
+}
+HRESULT vfd_handle_create_char(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b;
+    iobuf_read_8(reader, &b);
+    char buf[32];
+
+    iobuf_read(reader, buf, 32);
+
+    dprintf("VFD: Create character, %d\n", b);
+    return S_FALSE;
+}
+HRESULT vfd_handle_create_char2(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
+    uint8_t b, b2;
+    iobuf_read_8(reader, &b);
+    iobuf_read_8(reader, &b2);
+    char buf[16];
+
+    iobuf_read(reader, buf, 16);
+
+    dprintf("VFD: Create character, %d, %d\n", b, b2);
+    return S_FALSE;
+}

board/vfd.h

@@ -4,7 +4,10 @@
 
 struct vfd_config {
     bool enable;
+    int port;
+    bool utf_conversion;
 };
 
 
-HRESULT vfd_hook_init(const struct vfd_config *cfg, unsigned int port_no);
+HRESULT vfd_hook_init(struct vfd_config *cfg, int default_port);
+

chuniio/chuniio.h

@@ -139,9 +139,10 @@ void chuni_io_slider_start(chuni_io_slider_callback_t callback);
 void chuni_io_slider_stop(void);
 
 /* Update the RGB lighting on the slider. A pointer to an array of 32 * 3 = 96
-   bytes is supplied. The illuminated areas on the touch slider are some
-   combination of rectangular regions and dividing lines between these regions
-   but the exact mapping of this lighting control buffer is still TBD.
+  bytes is supplied, organized in BRG format.
+   The first set of bytes is the right-most slider key, and from there the bytes
+   alternate between the dividers and the keys until the left-most key. 
+   There are 31 illuminated sections in total.
 
    Minimum API version: 0x0100 */
 

chuniio/config.c

@@ -63,6 +63,8 @@ void chuni_io_config_load(
     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->controller_led_output_openithm = GetPrivateProfileIntW(L"led", L"controllerLedOutputOpeNITHM", 0, filename);
+
     cfg->led_serial_baud = GetPrivateProfileIntW(L"led", L"serialBaud", 921600, filename);
 
     GetPrivateProfileStringW(

chuniio/config.h

@@ -18,6 +18,8 @@ struct chuni_io_config {
     bool controller_led_output_pipe;
     bool controller_led_output_serial;
 
+    bool controller_led_output_openithm;
+
     // 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;

chuniio/ledoutput.c

@@ -127,7 +127,11 @@ void led_output_update(uint8_t board, const byte* rgb)
         
         if (config->controller_led_output_serial)
         {
-            led_serial_update(escaped_data);
+            if (config->controller_led_output_openithm){
+                led_serial_update_openithm(rgb);
+            } else {
+                led_serial_update(escaped_data);
+            }
         }
     }
 }

chuniio/meson.build

@@ -4,6 +4,7 @@ chuniio_lib = static_library(
     include_directories : inc,
     implicit_include_directories : false,
     c_pch : '../precompiled.h',
+
     sources : [
         'chu2to3.c',
         'chu2to3.h',

chuniio/serialimpl.c

@@ -97,3 +97,27 @@ void led_serial_update(struct _chuni_led_data_buf_t* data)
     
     ReleaseMutex(serial_write_mutex);
 }
+
+void led_serial_update_openithm(const byte* rgb)
+{
+    if (serial_port != INVALID_HANDLE_VALUE)
+    {
+        char led_buffer[100];
+        DWORD bytes_to_write;               // No of bytes to write into the port
+        DWORD bytes_written = 0;            // No of bytes written to the port
+        bytes_to_write = sizeof(led_buffer);
+        BOOL status;
+        
+        led_buffer[0] = 0xAA;
+        led_buffer[1] = 0xAA;
+        memcpy(led_buffer+2, rgb, sizeof(uint8_t) * 96);
+        led_buffer[98] = 0xDD;
+        led_buffer[99] = 0xDD;
+        
+        status = WriteFile(serial_port,     // Handle to the Serial port
+                           led_buffer,      // Data to be written to the port
+                           bytes_to_write,  // No of bytes to write
+                           &bytes_written,  // Bytes written
+                           NULL);
+    }
+}

chuniio/serialimpl.h

@@ -13,3 +13,4 @@
 
 HRESULT led_serial_init(wchar_t led_com[12], DWORD baud);
 void led_serial_update(struct _chuni_led_data_buf_t* data);
+void led_serial_update_openithm(const byte* rgb);

chusanhook/dllmain.c

@@ -123,7 +123,7 @@ static DWORD CALLBACK chusan_pre_startup(void)
         goto fail;
     }
 
-    bool *dipsw = &chusan_hook_cfg.platform.dipsw.dipsw[0];
+    bool *dipsw = &chusan_hook_cfg.platform.system.dipsw[0];
     bool is_cvt = dipsw[2];
 
     for (int i = 0; i < 3; i++) {

cmhook/cmhook.def

@@ -15,3 +15,59 @@ EXPORTS
     cm_io_get_opbtns
     cm_io_init
     cm_io_poll
+    CFW_init
+    CFW_term
+    CFW_open
+    CFW_close
+    CFW_listupPrinter
+    CFW_listupPrinterSN
+    CFW_selectPrinter
+    CFW_selectPrinterSN
+    CFW_getPrinterInfo
+    CFW_status
+    CFW_statusAll
+    CFW_resetPrinter
+    CFW_updateFirmware
+    CFW_getFirmwareInfo
+    CHCUSB_init
+    CHCUSB_term
+    CHCUSB_MakeThread
+    CHCUSB_open
+    CHCUSB_close
+    CHCUSB_ReleaseThread
+    CHCUSB_listupPrinter
+    CHCUSB_listupPrinterSN
+    CHCUSB_selectPrinter
+    CHCUSB_selectPrinterSN
+    CHCUSB_getPrinterInfo
+    CHCUSB_imageformat
+    CHCUSB_setmtf
+    CHCUSB_makeGamma
+    CHCUSB_setIcctableProfile
+    CHCUSB_setIcctable
+    CHCUSB_copies
+    CHCUSB_status
+    CHCUSB_statusAll
+    CHCUSB_startpage
+    CHCUSB_endpage
+    CHCUSB_write
+    CHCUSB_writeLaminate
+    CHCUSB_writeHolo
+    CHCUSB_setPrinterInfo
+    CHCUSB_setPrinterToneCurve
+    CHCUSB_getGamma
+    CHCUSB_getMtf
+    CHCUSB_cancelCopies
+    CHCUSB_getPrinterToneCurve
+    CHCUSB_blinkLED
+    CHCUSB_resetPrinter
+    CHCUSB_AttachThreadCount
+    CHCUSB_getPrintIDStatus
+    CHCUSB_setPrintStandby
+    CHCUSB_testCardFeed
+    CHCUSB_exitCard
+    CHCUSB_getCardRfidTID
+    CHCUSB_commCardRfidReader
+    CHCUSB_updateCardRfidReader
+    CHCUSB_getErrorLog
+    CHCUSB_getErrorStatus

cmhook/config.c

@@ -39,6 +39,7 @@ void cm_hook_config_load(
     io4_config_load(&cfg->io4, filename);
     vfd_config_load(&cfg->vfd, filename);
     touch_screen_config_load(&cfg->touch, filename);
+    printer_config_load(&cfg->printer, filename);
     cm_dll_config_load(&cfg->dll, filename);
     unity_config_load(&cfg->unity, filename);
 }

cmhook/config.h

@@ -6,6 +6,7 @@
 
 #include "hooklib/dvd.h"
 #include "hooklib/touch.h"
+#include "hooklib/printer.h"
 
 #include "cmhook/cm-dll.h"
 
@@ -21,6 +22,7 @@ struct cm_hook_config {
     struct vfd_config vfd;
     struct cm_dll_config dll;
     struct touch_screen_config touch;
+    struct printer_config printer;
     struct unity_config unity;
 };
 

cmhook/dllmain.c

@@ -56,6 +56,10 @@ static DWORD CALLBACK cm_pre_startup(void)
     touch_screen_hook_init(&cm_hook_cfg.touch, cm_hook_mod);
     serial_hook_init();
 
+    /* Hook external DLL APIs */
+
+    printer_hook_init(&cm_hook_cfg.printer, 0, cm_hook_mod);
+
     /* Initialize emulation hooks */
 
     hr = platform_hook_init(
@@ -97,7 +101,7 @@ static DWORD CALLBACK cm_pre_startup(void)
        There seems to be an issue with other DLL hooks if `LoadLibraryW` is
        hooked earlier in the `cmhook` initialization. */
 
-    unity_hook_init(&cm_hook_cfg.unity, cm_hook_mod);
+    unity_hook_init(&cm_hook_cfg.unity, cm_hook_mod, NULL);
 
     /* Initialize debug helpers */
 

cmio/cmio.h

@@ -36,9 +36,9 @@ HRESULT cm_io_init(void);
 HRESULT cm_io_poll(void);
 
 /* Get the state of the cabinet's operator buttons as of the last poll. See
-   cm_IO_OPBTN enum above: this contains bit mask definitions for button
+   CM_IO_OPBTN enum above: this contains bit mask definitions for button
    states returned in *opbtn. All buttons are active-high.
 
    Minimum API version: 0x0100 */
 
-void cm_io_get_opbtns(uint8_t *opbtn);
+void cm_io_get_opbtns(uint8_t *opbtn);

dist/carol/segatools.ini

@@ -64,6 +64,8 @@ subnet=192.168.126.0
 ; -----------------------------------------------------------------------------
 
 [gfx]
+; Enables the graphics hook.
+enable=1
 ; Force the game to run windowed.
 windowed=1
 ; Add a frame to the game window if running windowed.

dist/chuni/segatools.ini

@@ -56,6 +56,8 @@ subnet=192.168.139.0
 ; -----------------------------------------------------------------------------
 
 [gfx]
+; Enables the graphics hook.
+enable=1
 ; Force the game to run windowed.
 windowed=1
 ; Add a frame to the game window if running windowed.
@@ -82,10 +84,12 @@ cabLedOutputSerial=0
 controllerLedOutputPipe=1
 ; Output slider LED data to the serial port
 controllerLedOutputSerial=0
+; Use the OpeNITHM protocol for serial LED output
+controllerLedOutputOpeNITHM=0
 
 ; Serial port to send data to if using serial output. Default is COM5.
 ;serialPort=COM5
-; Baud rate for serial data
+; Baud rate for serial data (set to 115200 if using OpeNITHM)
 ;serialBaud=921600
 
 ; Data output a sequence of bytes, with JVS-like framing.

dist/chusan/segatools.ini

@@ -25,7 +25,7 @@ aimePath=DEVICE\aime.txt
 ;highBaud=1
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -59,8 +59,8 @@ addrSuffix=11
 ; that subnet must start with 192.168.
 subnet=192.168.139.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to
@@ -82,6 +82,8 @@ dipsw3=1
 ; -----------------------------------------------------------------------------
 
 [gfx]
+; Enables the graphics hook.
+enable=1
 ; Force the game to run windowed.
 windowed=1
 ; Add a frame to the game window if running windowed.
@@ -108,10 +110,12 @@ cabLedOutputSerial=0
 controllerLedOutputPipe=1
 ; Output slider LED data to the serial port
 controllerLedOutputSerial=0
+; Use the OpeNITHM protocol for serial LED output
+controllerLedOutputOpeNITHM=0
 
 ; Serial port to send data to if using serial output. Default is COM5.
 ;serialPort=COM5
-; Baud rate for serial data
+; Baud rate for serial data (set to 115200 if using OpeNITHM)
 ;serialBaud=921600
 
 ; Data output a sequence of bytes, with JVS-like framing.
@@ -202,7 +206,3 @@ ir=0x20
 ; ... etc ...
 ;cell31=0x53
 ;cell32=0x53
-
-; Enable slider LED serial output. This follows OpeNITHM Serial LED Protocol.
-; eg. COM5
-;ledport=

dist/cm/segatools.ini

@@ -23,7 +23,7 @@ enable=1
 aimePath=DEVICE\aime.txt
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -50,10 +50,10 @@ enable=1
 ; The /24 LAN subnet that the emulated keychip will tell the game to expect.
 ; If you disable netenv then you must set this to your LAN's IP subnet, and
 ; that subnet must start with 192.168.
-subnet=192.168.100.0
+subnet=192.168.165.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; LAN Install: If multiple machines are present on the same LAN then set 
@@ -73,6 +73,14 @@ enable=0
 ; modding frameworks such as BepInEx.
 targetAssembly=
 
+[printer]
+; Sinfonia CHC-C330 printer emulation setting.
+enable=1
+; Change the printer serial number here.
+serial_no="5A-A123"
+; Insert the path to the image output directory here.
+printerOutPath="DEVICE\print"
+
 ; -----------------------------------------------------------------------------
 ; Custom IO settings
 ; -----------------------------------------------------------------------------

dist/cxb/segatools.ini

@@ -75,6 +75,8 @@ path=../DEVICE/sram.bin
 ; -----------------------------------------------------------------------------
 
 [gfx]
+; Enables the graphics hook.
+enable=1
 ; Force the game to run windowed.
 windowed=1
 ; Add a frame to the game window if running windowed.

dist/diva/segatools.ini

@@ -5,7 +5,7 @@
 [vfs]
 ; Insert the path to the game AMFS directory here (contains ICF1 and ICF2)
 amfs=
-; Insert the path to the game Option directory here (contains Axxx directories)
+; Insert the path to the game Option (mdata) directory here (contains Mxxx directories)
 option=
 ; Create an empty directory somewhere and insert the path here.
 ; This directory may be shared between multiple SEGA games.
@@ -36,6 +36,10 @@ 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`).
+addrSuffix=11
 
 ; -----------------------------------------------------------------------------
 ; Board settings
@@ -54,6 +58,18 @@ dipsw1=1
 ; that subnet must start with 192.168.
 subnet=192.168.78.0
 
+; -----------------------------------------------------------------------------
+; Misc. hooks settings
+; -----------------------------------------------------------------------------
+
+[gfx]
+; Enables the graphics hook.
+enable=1
+; Force the game to run windowed.
+windowed=1
+; Add a frame to the game window if running windowed.
+framed=0
+
 ; -----------------------------------------------------------------------------
 ; Custom IO settings
 ; -----------------------------------------------------------------------------

dist/fgo/segatools.ini

@@ -23,7 +23,7 @@ enable=1
 aimePath=DEVICE\aime.txt
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -72,8 +72,8 @@ addrSuffix=11
 ; that subnet must start with 192.168.
 subnet=192.168.167.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to
@@ -85,6 +85,14 @@ freeplay=0
 ; Misc. hook settings
 ; -----------------------------------------------------------------------------
 
+[gfx]
+; Enables the graphics hook.
+enable=1
+; Force the game to run windowed.
+windowed=0
+; Add a frame to the game window if running windowed.
+framed=0
+
 [touch]
 ; WinTouch emulation setting.
 enable=1

dist/idac/segatools.ini

@@ -54,8 +54,8 @@ subnet=192.168.158.0
 ; 1: JPN: Japan, 4: EXP: Export (for Asian markets)
 region=4
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to
@@ -75,6 +75,11 @@ dipsw3=0
 dipsw4=0
 dipsw5=0
 
+[ffb]
+; Enable force feedback (838-15069) board emulation. This is required for
+; both DirectInput and XInput steering wheel effects.
+enable=1
+
 ; -----------------------------------------------------------------------------
 ; LED settings
 ; -----------------------------------------------------------------------------
@@ -231,6 +236,20 @@ reverseAccelAxis=0
 reverseBrakeAxis=0
 
 ; Force feedback settings.
-; Strength of the force feedback spring effect in percent. Possible values
-; are 0-100.
-centerSpringStrength=30
+; Only works when FFB board emulation is enabled!
+;
+; It is recommended to change the strength inside the Game Test Mode!
+;
+; These settings are only used when using DirectInput for the wheel.
+; The values are in the range 0%-100%, where 0 disables the effect and
+; 100 is the maximum.
+
+; Constant force strength, used for centering spring effect.
+constantForceStrength=100
+; Damper strength, used for steering wheel damper effect.
+damperStrength=100
+
+; Rumble strength, used for road surface effects.
+rumbleStrength=100
+; Rumble duration factor from ms to µs, used to scale the duration of the rumble effect.
+rumbleDuration=1000

dist/idz/segatools.ini

@@ -69,6 +69,20 @@ region=4
 ; exactly one machine and set this to 0 on all others.
 dipsw1=1
 
+[ffb]
+; Enable force feedback (838-15069) board emulation. This is required for
+; both DirectInput and XInput steering wheel effects.
+enable=1
+
+; -----------------------------------------------------------------------------
+; LED settings
+; -----------------------------------------------------------------------------
+
+[led15070]
+; Enable emulation of the 837-15070-02 controlled lights, which handle the
+; cabinet and seat LEDs.
+enable=1
+
 ; -----------------------------------------------------------------------------
 ; Misc. hooks settings
 ; -----------------------------------------------------------------------------
@@ -212,6 +226,20 @@ reverseAccelAxis=0
 reverseBrakeAxis=0
 
 ; Force feedback settings.
-; Strength of the force feedback spring effect in percent. Possible values
-; are 0-100.
-centerSpringStrength=30
+; Only works when FFB board emulation is enabled!
+;
+; It is recommended to change the strength inside the Game Test Mode!
+;
+; These settings are only used when using DirectInput for the wheel.
+; The values are in the range 0%-100%, where 0 disables the effect and
+; 100 is the maximum.
+
+; Constant force strength, used for centering spring effect.
+constantForceStrength=100
+; Damper strength, used for steering wheel damper effect.
+damperStrength=100
+
+; Rumble strength, used for road surface effects.
+rumbleStrength=100
+; Rumble duration factor from ms to µs, used to scale the duration of the rumble effect.
+rumbleDuration=1000

dist/idz/start.bat

@@ -2,10 +2,11 @@
 
 pushd %~dp0
 
-inject -k idzhook.dll InitialD0_DX11_Nu.exe
+start /min "AM Daemon" inject -d -k idzhook.dll amdaemon.exe -c configDHCP_Final_Common.json configDHCP_Final_JP.json configDHCP_Final_JP_ST1.json configDHCP_Final_JP_ST2.json configDHCP_Final_EX.json configDHCP_Final_EX_ST1.json configDHCP_Final_EX_ST2.json
+
 rem Set dipsw1=0 and uncomment the ServerBox for in store battle?
 rem inject -k idzhook.dll ServerBoxD8_Nu_x64.exe
-inject -d -k idzhook.dll amdaemon.exe -c configDHCP_Final_Common.json configDHCP_Final_JP.json configDHCP_Final_JP_ST1.json configDHCP_Final_JP_ST2.json configDHCP_Final_EX.json configDHCP_Final_EX_ST1.json configDHCP_Final_EX_ST2.json
+inject -d -k idzhook.dll InitialD0_DX11_Nu.exe
 
 taskkill /im ServerBoxD8_Nu_x64.exe > nul 2>&1
 

dist/kemono/segatools.ini

@@ -0,0 +1,150 @@
+; -----------------------------------------------------------------------------
+; Path settings
+; -----------------------------------------------------------------------------
+
+[vfs]
+; Insert the path to the game AMFS directory here (contains ICF1 and ICF2)
+amfs=
+; Insert the path to the game Option directory here (contains Axxx directories)
+option=
+; Create an empty directory somewhere and insert the path here.
+; This directory may be shared between multiple SEGA games.
+; NOTE: This has nothing to do with Windows %APPDATA%.
+appdata=
+
+; -----------------------------------------------------------------------------
+; Device settings
+; -----------------------------------------------------------------------------
+
+[aime]
+; Enable Aime card reader assembly emulation. Disable to use a real SEGA Aime
+; reader.
+enable=1
+aimePath=DEVICE\aime.txt
+
+[vfd]
+; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; GP1232A02A FUTABA assembly.
+enable=1
+
+; -----------------------------------------------------------------------------
+; Network settings
+; -----------------------------------------------------------------------------
+
+[dns]
+; Insert the hostname or IP address of the server you wish to use here.
+; Note that 127.0.0.1, localhost etc are specifically rejected.
+default=127.0.0.1
+
+[netenv]
+; Simulate an ideal LAN environment. This may interfere with head-to-head play.
+; SEGA games are somewhat picky about its LAN environment, so leaving this
+; setting enabled is 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`).
+addrSuffix=11
+
+; -----------------------------------------------------------------------------
+; Board settings
+; -----------------------------------------------------------------------------
+
+[keychip]
+; The /24 LAN subnet that the emulated keychip will tell the game to expect.
+; If you disable netenv then you must set this to your LAN's IP subnet, and
+; that subnet must start with 192.168.
+subnet=192.168.179.0
+
+[gpio]
+; Emulated Nu DIP switch for Distribution Server setting.
+;
+; If multiple machines are present on the same LAN then set this to 1 on
+; exactly one machine and set this to 0 on all others.
+dipsw1=1
+
+; Chassis Test button virtual-key code. Default is the 4 key.
+test=0x34
+; Chassis Service button virtual-key code. Default is the 5 key.
+service=0x35
+
+; -----------------------------------------------------------------------------
+; 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.
+;
+; NOTE: For Kemono Friends, BepInEx (or similar) should be installed to the main folder, not the "UnityApp" folder.
+targetAssembly=
+
+[printer]
+; Sinfonia CHC-C300 printer emulation setting.
+enable=1
+; Change the printer serial number here.
+serial_no="5A-A123"
+; Insert the path to the image output directory here.
+printerOutPath="DEVICE\print"
+; The length in milliseconds the printer should be busy printing.
+; Set to 0 to instantly finish printing.
+waitTime=20000
+
+; -----------------------------------------------------------------------------
+; LED settings
+; -----------------------------------------------------------------------------
+
+[led15093]
+; 837-15093-06 LED board emulation setting.
+enable=1
+
+; -----------------------------------------------------------------------------
+; 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=
+
+[kemonoio]
+; To use a custom Kemono IO DLL enter its path here.
+; Leave empty if you want to use Segatools built-in keyboard input.
+path=
+
+; -----------------------------------------------------------------------------
+; Input settings
+; -----------------------------------------------------------------------------
+
+; Keyboard bindings are specified as hexadecimal (prefixed with 0x) or decimal
+; (not prefixed with 0x) virtual-key codes, a list of which can be found here:
+;
+; https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
+;
+; This is, admittedly, not the most user-friendly configuration method in the
+; world. An improved solution will be provided later.
+
+[io3]
+; Test button virtual-key code. Default is the 1 key.
+test=0x31
+; Service button virtual-key code. Default is the 2 key.
+service=0x32
+; Keyboard button to increment coin counter. Default is the 3 key.
+coin=0x33
+
+; Analog lever (which is actually just four buttons, and not real analog input, default: Arrow keys)
+left=0x25
+right=0x27
+up=0x26
+down=0x28
+
+; Controller face buttons (default A, S, D)
+red=0x41
+green=0x53
+blue=0x44
+
+; Menu confirmation key (default RETURN)
+start=0x0D

dist/kemono/start.bat

@@ -0,0 +1,12 @@
+@echo off
+
+pushd %~dp0
+
+start "AM Daemon" /min inject_x64 -d -k kemonohook_x64.dll amdaemon.exe -c config.json
+inject_x86 -d -k kemonohook_x86.dll UnityApp\Parade -screen-fullscreen 0 -popupwindow -screen-width 720 -screen-height 1280 -silent-crashes
+
+taskkill /f /im amdaemon.exe > nul 2>&1
+
+echo.
+echo Game processes have terminated
+pause

dist/mai2/segatools.ini

@@ -23,7 +23,7 @@ enable=1
 aimePath=DEVICE\aime.txt
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -56,8 +56,8 @@ addrSuffix=11
 ; that subnet must start with 192.168.
 subnet=192.168.172.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to

dist/mercury/segatools.ini

@@ -23,7 +23,7 @@ enable=1
 aimePath=DEVICE\aime.txt
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -56,8 +56,8 @@ addrSuffix=11
 ; that subnet must start with 192.168.
 subnet=192.168.174.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to
@@ -74,6 +74,7 @@ dipsw1=1
 ; -----------------------------------------------------------------------------
 
 [gfx]
+; Enables the graphics hook.
 enable=1
 
 ; Hooks related to the touch boards

dist/mu3/segatools.ini

@@ -23,7 +23,7 @@ enable=1
 aimePath=DEVICE\aime.txt
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -52,8 +52,8 @@ enable=1
 ; that subnet must start with 192.168.
 subnet=192.168.162.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to
@@ -70,6 +70,7 @@ dipsw1=1
 ; -----------------------------------------------------------------------------
 
 [gfx]
+; Enables the graphics hook.
 enable=1
 
 [unity]
@@ -190,7 +191,7 @@ leftSide=0x01   ; Mouse Left
 rightSide=0x02  ; Mouse Right
 
 right1=0x4A ; J
-right1=0x4B ; K
+right2=0x4B ; K
 right3=0x4C ; L
 
 leftMenu=0x55   ; U

dist/swdc/segatools.ini

@@ -23,7 +23,7 @@ enable=1
 aimePath=DEVICE\aime.txt
 
 [vfd]
-; Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+; Enable VFD emulation. Disable to use a real VFD
 ; GP1232A02A FUTABA assembly.
 enable=1
 
@@ -56,8 +56,8 @@ addrSuffix=11
 ; in order to find the MAIN cabinet.
 subnet=192.168.160.0
 
-[gpio]
-; ALLS DIP switches.
+[system]
+; Enable ALLS system settings.
 enable=1
 
 ; Enable freeplay mode. This will disable the coin slot and set the game to
@@ -65,6 +65,11 @@ enable=1
 ; allow you to start a game in freeplay mode.
 freeplay=0
 
+[ffb]
+; Enable force feedback (838-15069) board emulation. This is required for
+; both DirectInput and XInput steering wheel effects.
+enable=1
+
 ; -----------------------------------------------------------------------------
 ; Custom IO settings
 ; -----------------------------------------------------------------------------
@@ -181,6 +186,20 @@ reverseAccelAxis=0
 reverseBrakeAxis=0
 
 ; Force feedback settings.
-; Strength of the force feedback spring effect in percent. Possible values
-; are 0-100.
-centerSpringStrength=30
+; Only works when FFB board emulation is enabled!
+;
+; It is recommended to change the strength inside the Game Test Mode!
+;
+; These settings are only used when using DirectInput for the wheel.
+; The values are in the range 0%-100%, where 0 disables the effect and
+; 100 is the maximum.
+
+; Constant force strength, used for centering spring effect.
+constantForceStrength=100
+; Damper strength, used for steering wheel damper effect.
+damperStrength=100
+
+; Rumble strength, used for road surface effects.
+rumbleStrength=100
+; Rumble duration factor from ms to µs, used to scale the duration of the rumble effect.
+rumbleDuration=1000

dist/tokyo/config_hook.json

@@ -0,0 +1,9 @@
+{
+	"network" :
+	{
+		"property" :
+		{
+			"dhcp" : true
+        }
+	}
+}

dist/tokyo/segatools.ini

@@ -0,0 +1,199 @@
+; -----------------------------------------------------------------------------
+; Path settings
+; -----------------------------------------------------------------------------
+
+[vfs]
+; Insert the path to the game AMFS directory here (contains ICF1 and ICF2)
+amfs=
+; Insert the path to the game Option directory here (contains OPxx directories)
+option=
+; Create an empty directory somewhere and insert the path here.
+; This directory may be shared between multiple SEGA games.
+; NOTE: This has nothing to do with Windows %APPDATA%.
+appdata=
+
+; -----------------------------------------------------------------------------
+; Network settings
+; -----------------------------------------------------------------------------
+
+[dns]
+; Insert the hostname or IP address of the server you wish to use here.
+; Note that 127.0.0.1, localhost etc are specifically rejected.
+default=127.0.0.1
+
+[netenv]
+; Simulate an ideal LAN environment. This may interfere with head-to-head play.
+; SEGA games are somewhat picky about their LAN environment, so leaving this
+; setting enabled is 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.149.0` and this value is set to `205`, then the
+; local host's virtualized LAN IP is `192.168.149.205`).
+addrSuffix=205
+
+; -----------------------------------------------------------------------------
+; Board settings
+; -----------------------------------------------------------------------------
+
+[keychip]
+; The /24 LAN subnet that the emulated keychip will tell the game to expect.
+; If you disable netenv then you must set this to your LAN's IP subnet, and
+; that subnet must start with 192.168.
+subnet=192.168.149.0
+
+; Override the keychip's region code.
+; 1: JAPAN (ALL.Net, Japanese language, Option support enabled)
+; 4: EXPORT (Local networking only, English language, No option support)
+; 8: CHINA
+;
+; NOTE: Changing this setting causes a factory reset. The language can be
+; changed in the game settings, so it's possible to run the JAPAN region
+; with English language.
+region=1
+
+[system]
+; Enable ALLS system settings.
+enable=1
+
+; Enable freeplay mode. This will disable the coin slot and set the game to
+; freeplay. Keep in mind that some game modes (e.g. Freedom/Time Modes) will not
+; allow you to start a game in freeplay mode.
+freeplay=0
+
+; For Mario & Sonic at the Tokyo 2020 Olympics Arcade, DipSw 1/2/3 must be set
+; as the following:
+; Cabinet ID 1 (Server): 1 0 0
+; Cabinet ID 2 (Client): 0 1 0
+; Cabinet ID 3 (Client): 0 0 1
+; Cabinet ID 4 (Client): 0 1 1
+dipsw1=1
+dipsw2=0
+dipsw3=0
+
+; -----------------------------------------------------------------------------
+; LED settings
+; -----------------------------------------------------------------------------
+
+[led15093]
+; Enable emulation of the 15093-04 controlled lights, which handle the cabinet
+; LEDs.
+enable=1
+
+; -----------------------------------------------------------------------------
+; Misc. hook settings
+; -----------------------------------------------------------------------------
+
+[zinput]
+; Disables the built-in DirectInput support, which is used to support a
+; controller out of the box.
+enable=1
+
+; -----------------------------------------------------------------------------
+; Custom IO settings
+; -----------------------------------------------------------------------------
+
+[tokyoio]
+; To use a custom Mario & Sonic at the Tokyo 2020 Olympics Arcade IO DLL enter 
+; its path here. Leave empty if you want to use Segatools built-in keyboard/
+; gamepad input.
+path=
+
+; -----------------------------------------------------------------------------
+; Input settings
+; -----------------------------------------------------------------------------
+
+; Keyboard bindings are specified as hexadecimal (prefixed with 0x) or decimal
+; (not prefixed with 0x) virtual-key codes, a list of which can be found here:
+;
+; https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
+;
+; This is, admittedly, not the most user-friendly configuration method in the
+; world. An improved solution will be provided later.
+
+[io4]
+; Test button virtual-key code. Default is the F1 key.
+test=0x70
+; Service button virtual-key code. Default is the F2 key.
+service=0x71
+; Keyboard button to increment coin counter. Default is the F3 key.
+coin=0x72
+
+; Input API selection for IO4 input emulator.
+; Set "xinput" to use a gamepad and "keyboard" to use a keyboard.
+mode=xinput
+
+; Mario & Sonic at the Tokyo 2020 Olympics Arcade Control Panel
+;
+; |--|------------------ Main-Assy ------------------|--|
+; |  |                     YELLOW                    |  |
+; |  |                      ---                      |  |
+; |  |                    (  O  )                    |  |
+; |--|    BLUE              ---               RED    |--|
+; |  |    ---           PUSH CENTER           ---    |  |
+; |  |  (  O  )      /---------------\      (  O  )  |  |
+; |  |    ---      /                   \      ---    |  |
+; |  | PUSH LEFT /                       \ PUSH RIGHT|  |
+; |--|---------/        Floor Assy         \---------|--|
+; |  |    |JUMP SENSE                 JUMP SENSE|    |  |
+; |  |    |1|---------------|-|-------------->|1|    |  |
+; |  |    | |  Foot Panel   | |   Foot Panel  | |    |  |
+; |  |    |2|<- - - - - - - |-| - - - - - - - |2|    |  |
+; |  |    | |               | |               | |    |  |
+; |  |    |3| -FOOT SENSE - |-| - FOOT SENSE->|3|    |  |
+; |  |    | |      L        | |       R       | |    |  |
+; |  |    |4|<- - - - - - - |-| - - - - - - - |4|    |  |
+; |  |    | |               | |               | |    |  |
+; |  |    |5| - - - - - - - |-| - - - - - - ->|5|    |  |
+; |  |    | |               | |               | |    |  |
+; |  |    |6|<--------------|-|---------------|6|    |  |
+; |  |    |                                     |    |  |
+; |  |    |                                     |    |  |
+; |--|----|-------------------------------------|----|--|
+;
+
+; XInput bindings
+;
+; X                    Push Left Blue
+; Y                    Push Center Yellow
+; B                    Push Right Red
+; D-Pad Left           Push Left Blue
+; D-Pad Right          Push Right Red  
+; Left Trigger         Foot Sense L/Jump Sense
+; Right Trigger        Foot Sense R/Jump Sense
+
+[keyboard]
+; Keyboard bindings
+
+; Keyoard: Push button settings
+
+; PUSH LEFT (BLUE) button virtual-key code. Default is the A key.
+leftBlue=0x41
+; PUSH CENTER (YELLOW) button virtual-key code. Default is the S key.
+centerYellow=0x53
+; PUSH RIGHT (RED) button virtual-key code. Default is the D key.
+rightRed=0x44
+
+; Keyboard: Sensor settings
+; FOOT SENSE L (LEFT) button virtual-key code. Default is the Left Arrow key.
+footLeft=0x25
+; FOOT SENSE R (RIGHT) button virtual-key code. Default is the Right Arrow key.
+footRight=0x27
+
+; Keyboard: Jump sensor settings
+; All jump sensors will also trigger the FOOT SENSE L and FOOT SENSE R buttons.
+; JUMP SENSOR 1 button virtual-key code. Default is the Z key.
+jump1=0x5A
+; JUMP SENSOR 2 button virtual-key code. Default is the X key.
+jump2=0x58
+; JUMP SENSOR 3 button virtual-key code. Default is the C key.
+jump3=0x43
+; JUMP SENSOR 4 button virtual-key code. Default is the B key.
+jump4=0x42
+; JUMP SENSOR 5 button virtual-key code. Default is the N key.
+jump5=0x4E
+; JUMP SENSOR 6 button virtual-key code. Default is the M key.
+jump6=0x4D
+
+; Virtual-key code for all jump sensors. Default is the Space key.
+jumpAll=0x20

dist/tokyo/start.bat

@@ -0,0 +1,57 @@
+@echo off
+pushd %~dp0
+
+set DAEMON_WAIT_SECONDS=5
+
+set AMDAEMON_CFG=config_common.json ^
+config_ch.json ^
+config_ex.json ^
+config_jp.json ^
+config_st1_ch.json ^
+config_st1_ex.json ^
+config_st1_jp.json ^
+config_st2_ch.json ^
+config_st2_ex.json ^
+config_st2_jp.json ^
+config_st3_ch.json ^
+config_st3_ex.json ^
+config_st3_jp.json ^
+config_st4_ch.json ^
+config_st4_ex.json ^
+config_st4_jp.json ^
+config_laninstall_server_ch.json ^
+config_laninstall_client1_ch.json ^
+config_laninstall_client2_ch.json ^
+config_laninstall_client3_ch.json ^
+config_laninstall_server_ex.json ^
+config_laninstall_client1_ex.json ^
+config_laninstall_client2_ex.json ^
+config_laninstall_client3_ex.json ^
+config_laninstall_server_jp.json ^
+config_laninstall_client1_jp.json ^
+config_laninstall_client2_jp.json ^
+config_laninstall_client3_jp.json ^
+config_hook.json
+
+start /min "AM Daemon" inject -d -k tokyohook.dll amdaemon.exe -c %AMDAEMON_CFG%
+timeout %DAEMON_WAIT_SECONDS% > nul 2>&1
+
+REM ---------------------------------------------------------------------------
+REM Set configuration
+REM ---------------------------------------------------------------------------
+
+REM Configuration values to be passed to the game executable.
+REM All known values:
+REM -forceapi:11
+REM -forcehal
+REM -forcevsync:0/1
+REM -fullscreen
+REM -windowed
+REM Note: -windowed is recommended as the game looks sharper in windowed mode.
+inject -d -k tokyohook.dll app.exe -windowed
+
+taskkill /f /im amdaemon.exe > nul 2>&1
+
+echo.
+echo Game processes have terminated
+pause

divahook/config.c

@@ -8,6 +8,9 @@
 #include "board/config.h"
 #include "board/sg-reader.h"
 
+#include "hooklib/config.h"
+#include "hooklib/dvd.h"
+
 #include "divahook/config.h"
 
 #include "platform/config.h"
@@ -47,6 +50,8 @@ void diva_hook_config_load(
     platform_config_load(&cfg->platform, filename);
     amex_config_load(&cfg->amex, filename);
     aime_config_load(&cfg->aime, filename);
+    dvd_config_load(&cfg->dvd, filename);
+    gfx_config_load(&cfg->gfx, filename);
     diva_dll_config_load(&cfg->dll, filename);
     slider_config_load(&cfg->slider, filename);
 }

divahook/config.h

@@ -6,15 +6,25 @@
 
 #include "board/sg-reader.h"
 
+#include "hooklib/dvd.h"
+#include "hooklib/touch.h"
+
+#include "gfxhook/config.h"
+
+#include "platform/config.h"
+
+#include "divahook/3mpxsc.h"
 #include "divahook/diva-dll.h"
 #include "divahook/slider.h"
 
-#include "platform/platform.h"
-
 struct diva_hook_config {
     struct platform_config platform;
     struct amex_config amex;
     struct aime_config aime;
+    struct dvd_config dvd;
+    struct gfx_config gfx;
+    struct touch3mpxsc_config touch3mpxsc;
+    struct touch_screen_config touch;
     struct diva_dll_config dll;
     struct slider_config slider;
 };

divahook/dllmain.c

@@ -22,6 +22,9 @@
 #include "divahook/jvs.h"
 #include "divahook/slider.h"
 
+#include "gfxhook/gfx.h"
+#include "gfxhook/gl.h"
+
 #include "hook/process.h"
 
 #include "hooklib/serial.h"
@@ -38,15 +41,30 @@ static struct diva_hook_config diva_hook_cfg;
 static DWORD CALLBACK diva_pre_startup(void)
 {
     HRESULT hr;
+    HMODULE dbghelp;
 
     dprintf("--- Begin diva_pre_startup ---\n");
 
+    /* Pin dbghelp so the path hooks apply to it. */
+
+    dbghelp = LoadLibraryW(L"dbghelp.dll");
+
+    if (dbghelp != NULL) {
+        dprintf("Pinned debug helper library, hMod=%p\n", dbghelp);
+    }
+    else {
+        dprintf("Failed to load debug helper library!\n");
+    }
+
     /* Config load */
 
     diva_hook_config_load(&diva_hook_cfg, L".\\segatools.ini");
 
     /* Hook Win32 APIs */
 
+    dvd_hook_init(&diva_hook_cfg.dvd, diva_hook_mod);
+    gfx_hook_init(&diva_hook_cfg.gfx);
+    gfx_gl_hook_init(&diva_hook_cfg.gfx, diva_hook_mod);
     serial_hook_init();
 
     /* Initialize emulation hooks */

divahook/jvs.c

@@ -63,33 +63,33 @@ static void diva_jvs_read_switches(void *ctx, struct io3_switch_state *out)
 
     diva_dll.jvs_poll(&opbtn, &gamebtn);
 
-    if (gamebtn & 0x01) {
+    if (gamebtn & DIVA_IO_GAMEBTN_CIRCLE) {
         out->p1 |= 1 << 6;
     }
 
-    if (gamebtn & 0x02) {
+    if (gamebtn & DIVA_IO_GAMEBTN_CROSS) {
         out->p1 |= 1 << 7;
     }
 
-    if (gamebtn & 0x04) {
+    if (gamebtn & DIVA_IO_GAMEBTN_SQUARE) {
         out->p1 |= 1 << 8;
     }
 
-    if (gamebtn & 0x08) {
+    if (gamebtn & DIVA_IO_GAMEBTN_TRIANGLE) {
         out->p1 |= 1 << 9;
     }
 
-    if (gamebtn & 0x10) {
+    if (gamebtn & DIVA_IO_GAMEBTN_START) {
         out->p1 |= 1 << 15;
     }
 
-    if (opbtn & 0x01) {
+    if (opbtn & DIVA_IO_OPBTN_TEST) {
         out->system = 0x80;
     } else {
         out->system = 0;
     }
 
-    if (opbtn & 0x02) {
+    if (opbtn & DIVA_IO_OPBTN_SERVICE) {
         out->p1 |= 1 << 14;
     }
 }

divahook/meson.build

@@ -14,6 +14,7 @@ shared_library(
         amex_lib,
         board_lib,
         divaio_lib,
+        gfxhook_lib,
         hooklib_lib,
         jvs_lib,
         platform_lib,

divaio/divaio.c

@@ -37,11 +37,11 @@ void diva_io_jvs_poll(uint8_t *opbtn_out, uint8_t *gamebtn_out)
     opbtn = 0;
 
     if (GetAsyncKeyState(diva_io_cfg.vk_test) & 0x8000) {
-        opbtn |= 1;
+        opbtn |= DIVA_IO_OPBTN_TEST;
     }
 
     if (GetAsyncKeyState(diva_io_cfg.vk_service) & 0x8000) {
-        opbtn |= 2;
+        opbtn |= DIVA_IO_OPBTN_SERVICE;
     }
 
     for (i = 0 ; i < _countof(diva_io_cfg.vk_buttons) ; i++) {

divaio/divaio.h

@@ -5,6 +5,19 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+enum {
+    DIVA_IO_OPBTN_TEST = 0x01,
+    DIVA_IO_OPBTN_SERVICE = 0x02
+};
+
+enum {
+    DIVA_IO_GAMEBTN_CIRCLE = 0x01,
+    DIVA_IO_GAMEBTN_CROSS = 0x02,
+    DIVA_IO_GAMEBTN_SQUARE = 0x04,
+    DIVA_IO_GAMEBTN_TRIANGLE = 0x08,
+    DIVA_IO_GAMEBTN_START = 0x10,
+};
+
 /* Get the version of the Project Diva 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

doc/config/common.md

@@ -92,9 +92,21 @@ Controls emulation of the VFD GP1232A02A FUTABA assembly.
 
 Default: `1`
 
-Enable VFD emulation (currently just stubbed). Disable to use a real VFD
+Enable VFD emulation. Disable to use a real VFD
 GP1232A02A FUTABA assembly (COM port number varies by game).
 
+### `portNo`
+
+Default: (game specific)
+
+Sets the COM port to use for the VFD.
+
+### `utfConversion`
+
+Default: `0`
+
+Converts the strings from the VFD from their respective encoding to UTF, so console output will display as it should on non-Japanese locales.
+
 ## `[amvideo]`
 
 Controls the `amvideo.dll` stub built into Segatools. This is a DLL that is

fgohook/config.c

@@ -122,5 +122,6 @@ void fgo_hook_config_load(
     fgo_deck_config_load(&cfg->deck, filename);
     ftdi_config_load(&cfg->ftdi, filename);
     led15093_config_load(&cfg->led15093, filename);
+    gfx_config_load(&cfg->gfx, filename);
     fgo_dll_config_load(&cfg->dll, filename);
 }

fgohook/config.h

@@ -9,6 +9,8 @@
 #include "hooklib/touch.h"
 #include "hooklib/printer.h"
 
+#include "gfxhook/config.h"
+
 #include "fgohook/deck.h"
 #include "fgohook/ftdi.h"
 #include "fgohook/fgo-dll.h"
@@ -26,6 +28,7 @@ struct fgo_hook_config {
     struct deck_config deck;
     struct ftdi_config ftdi;
     struct led15093_config led15093;
+    struct gfx_config gfx;
     struct fgo_dll_config dll;
 };
 

fgohook/dllmain.c

@@ -26,6 +26,7 @@
 
 #include "hook/process.h"
 
+#include "hooklib/dll.h"
 #include "hooklib/dvd.h"
 #include "hooklib/touch.h"
 #include "hooklib/printer.h"
@@ -33,6 +34,8 @@
 #include "hooklib/serial.h"
 #include "hooklib/spike.h"
 
+#include "gfxhook/gfx.h"
+
 #include "fgohook/config.h"
 #include "fgohook/io4.h"
 #include "fgohook/fgo-dll.h"
@@ -49,9 +52,21 @@ static struct fgo_hook_config fgo_hook_cfg;
 static DWORD CALLBACK fgo_pre_startup(void)
 {
     HRESULT hr;
+    HMODULE dbghelp;
 
     dprintf("--- Begin fgo_pre_startup ---\n");
 
+    /* Pin dbghelp so the path hooks apply to it. */
+
+    dbghelp = LoadLibraryW(L"dbghelp.dll");
+
+    if (dbghelp != NULL) {
+        dprintf("Pinned debug helper library, hMod=%p\n", dbghelp);
+    }
+    else {
+        dprintf("Failed to load debug helper library!\n");
+    }
+
     /* Load config */
 
     fgo_hook_config_load(&fgo_hook_cfg, L".\\segatools.ini");
@@ -59,12 +74,15 @@ static DWORD CALLBACK fgo_pre_startup(void)
     /* Hook Win32 APIs */
 
     dvd_hook_init(&fgo_hook_cfg.dvd, fgo_hook_mod);
+    gfx_hook_init(&fgo_hook_cfg.gfx);
     touch_screen_hook_init(&fgo_hook_cfg.touch, fgo_hook_mod);
     serial_hook_init();
 
     /* Hook external DLL APIs */
 
     printer_hook_init(&fgo_hook_cfg.printer, 4, fgo_hook_mod);
+    dll_hook_push(fgo_hook_mod, L"C330Ausb.dll");
+    dll_hook_push(fgo_hook_mod, L"C330AFWDLusb.dll");
 
     /* Initialize emulation hooks */
 

fgohook/fgohook.def

@@ -44,7 +44,7 @@ EXPORTS
     chcusb_selectPrinter
     chcusb_selectPrinterSN
     chcusb_getPrinterInfo
-    chcusb_imageformat
+    chcusb_imageformat=chcusb_imageformat_330
     chcusb_setmtf
     chcusb_makeGamma
     chcusb_setIcctable

fgohook/meson.build

@@ -13,6 +13,7 @@ shared_library(
     link_with : [
         aimeio_lib,
         board_lib,
+        gfxhook_lib,
         hooklib_lib,
         fgoio_lib,
         platform_lib,

fgoio/fgoio.h

@@ -52,16 +52,12 @@ HRESULT fgo_io_poll(void);
 void fgo_io_get_opbtns(uint8_t *opbtn);
 
 /* Get the state of the cabinet's gameplay buttons as of the last poll. See
-   FGO_IO_GAMEBTN enum above for bit mask definitions. Inputs are split into
-   a left hand side set of inputs and a right hand side set of inputs: the bit
-   mappings are the same in both cases.
-
-   All buttons are active-high, even though some buttons' electrical signals
-   on a real cabinet are active-low.
+   FGO_IO_GAMEBTN enum above: this contains bit mask definitions for button
+   states returned in *gamebtn. All buttons are active-high.
 
    Minimum API version: 0x0100 */
 
-void fgo_io_get_gamebtns(uint8_t *btn);
+void fgo_io_get_gamebtns(uint8_t *gamebtn);
 
 /* Get the position of the cabinet stick as of the last poll. The center
    position should be equal to or close to 32767.

gfxhook/d3d9.c

@@ -224,9 +224,19 @@ static HRESULT STDMETHODCALLTYPE my_IDirect3D9_CreateDevice(
         gfx_util_frame_window(hwnd);
     }
 
-    dprintf("Gfx: Using adapter %d\n", gfx_config.monitor);
+    UINT max_adapter = IDirect3D9_GetAdapterCount(real);
+    adapter = gfx_config.monitor;
+    if (adapter >= max_adapter) {
+        dprintf(
+            "Gfx: Requested adapter %d but maximum is %d. Using primary monitor\n",
+            gfx_config.monitor, max_adapter - 1
+        );
+        adapter = D3DADAPTER_DEFAULT;
+    } else {
+        dprintf("Gfx: Using adapter %d\n", gfx_config.monitor);
+    }
 
-    return IDirect3D9_CreateDevice(real, gfx_config.monitor, type, hwnd, flags, pp, pdev);
+    return IDirect3D9_CreateDevice(real, adapter, type, hwnd, flags, pp, pdev);
 }
 
 static HRESULT STDMETHODCALLTYPE my_IDirect3D9Ex_CreateDevice(

gfxhook/gfx.c

@@ -9,18 +9,53 @@
 
 #include "util/dprintf.h"
 
-typedef BOOL (WINAPI *ShowWindow_t)(HWND hWnd, int nCmdShow);
+/* Hook functions */
 
 static BOOL WINAPI hook_ShowWindow(HWND hWnd, int nCmdShow);
+static BOOL WINAPI hook_CreateWindowExA(
+    DWORD dwExStyle,
+    LPCSTR lpClassName,
+    LPCSTR lpWindowName,
+    DWORD dwStyle,
+    int X,
+    int Y,
+    int nWidth,
+    int nHeight,
+    HWND hWndParent,
+    HMENU hMenu,
+    HINSTANCE hInstance,
+    LPVOID lpParam
+);
+
+/* Link pointers */
+
+static BOOL (WINAPI *next_ShowWindow)(HWND hWnd, int nCmdShow);
+static BOOL (WINAPI *next_CreateWindowExA)(
+    DWORD dwExStyle,
+    LPCSTR lpClassName,
+    LPCSTR lpWindowName,
+    DWORD dwStyle,
+    int X,
+    int Y,
+    int nWidth,
+    int nHeight,
+    HWND hWndParent,
+    HMENU hMenu,
+    HINSTANCE hInstance,
+    LPVOID lpParam
+);
 
 static struct gfx_config gfx_config;
-static ShowWindow_t next_ShowWindow;
 
 static const struct hook_symbol gfx_hooks[] = {
     {
         .name = "ShowWindow",
         .patch = hook_ShowWindow,
         .link = (void **) &next_ShowWindow,
+    }, {
+        .name = "CreateWindowExA",
+        .patch = hook_CreateWindowExA,
+        .link = (void **) &next_CreateWindowExA,
     },
 };
 
@@ -46,3 +81,45 @@ static BOOL WINAPI hook_ShowWindow(HWND hWnd, int nCmdShow)
 
     return next_ShowWindow(hWnd, nCmdShow);
 }
+
+static BOOL WINAPI hook_CreateWindowExA(
+    DWORD dwExStyle,
+    LPCSTR lpClassName,
+    LPCSTR lpWindowName,
+    DWORD dwStyle,
+    int X,
+    int Y,
+    int nWidth,
+    int nHeight,
+    HWND hWndParent,
+    HMENU hMenu,
+    HINSTANCE hInstance,
+    LPVOID lpParam
+)
+{
+    dprintf("Gfx: CreateWindowExA hook hit\n");
+
+    // Set to WS_OVERLAPPEDWINDOW to enable a window with a border and windowed style
+    if (gfx_config.windowed) {
+        dwStyle = WS_OVERLAPPEDWINDOW;
+
+        if (!gfx_config.framed) {
+            dwStyle = WS_POPUP;
+        }
+    }
+
+    return next_CreateWindowExA(
+        dwExStyle,
+        lpClassName,
+        lpWindowName,
+        dwStyle,
+        X,
+        Y,
+        nWidth,
+        nHeight,
+        hWndParent,
+        hMenu,
+        hInstance,
+        lpParam
+    );
+}

gfxhook/gl.c

@@ -0,0 +1,77 @@
+#include <windows.h>
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "gfxhook/gfx.h"
+#include "gfxhook/gl.h"
+
+#include "hook/table.h"
+
+#include "hooklib/dll.h"
+
+#include "util/dprintf.h"
+
+/* Hook functions */
+
+static void WINAPI hook_glutFullScreen(void);
+static void WINAPI hook_glutInitDisplayMode(unsigned int mode);
+
+/* Link pointers */
+
+static void (WINAPI *next_glutFullScreen)(void);
+static void (WINAPI *next_glutInitDisplayMode)(unsigned int mode);
+
+static struct gfx_config gfx_config;
+
+static const struct hook_symbol glut_hooks[] = {
+    {
+        .name = "glutFullScreen",
+        .patch = hook_glutFullScreen,
+        .link = (void **) &next_glutFullScreen,
+    }, {
+        .name = "glutInitDisplayMode",
+        .patch = hook_glutInitDisplayMode,
+        .link = (void **) &next_glutInitDisplayMode,
+    },
+};
+
+void gfx_gl_hook_init(const struct gfx_config *cfg, HINSTANCE self)
+{
+    assert(cfg != NULL);
+
+    if (!cfg->enable) {
+        return;
+    }
+
+    memcpy(&gfx_config, cfg, sizeof(*cfg));
+    hook_table_apply(NULL, "glut32.dll", glut_hooks, _countof(glut_hooks));
+
+    if (self != NULL) {
+        dll_hook_push(self, L"glut32.dll");
+    }
+}
+
+static void WINAPI hook_glutFullScreen(void)
+{
+    dprintf("Gfx: glutFullScreen hook hit\n");
+
+    if (gfx_config.windowed) {
+        return;
+    }
+
+    return next_glutFullScreen();
+}
+
+static void WINAPI hook_glutInitDisplayMode(unsigned int mode)
+{
+    dprintf("Gfx: glutInitDisplayMode hook hit\n");
+
+    // GLUT adds a frame when going windowed
+    if (gfx_config.windowed && !gfx_config.framed) {
+        // GLUT_BORDERLESS
+        mode |= 0x0800;
+    }
+
+    return next_glutInitDisplayMode(mode);
+}

gfxhook/gl.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void gfx_gl_hook_init(const struct gfx_config *cfg, HINSTANCE self);

gfxhook/meson.build

@@ -22,6 +22,8 @@ gfxhook_lib = static_library(
         'dxgi.h',
         'gfx.c',
         'gfx.h',
+        'gl.c',
+        'gl.h',
         'util.c',
         'util.h',
     ],

hooklib/config.c

@@ -80,4 +80,6 @@ void printer_config_load(struct printer_config *cfg, const wchar_t *filename)
             cfg->printer_out_path,
             _countof(cfg->printer_out_path),
             filename);
+
+    cfg->wait_time = GetPrivateProfileIntW(L"printer", L"waitTime", 0, filename);
 }

hooklib/printer.h

@@ -2,6 +2,7 @@
 
 #include <windows.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 struct printer_config {
     bool enable;
@@ -11,6 +12,13 @@ struct printer_config {
     wchar_t dsp_fw_path[MAX_PATH];
     wchar_t param_fw_path[MAX_PATH];
     wchar_t printer_out_path[MAX_PATH];
+    uint32_t wait_time;
 };
 
 void printer_hook_init(const struct printer_config *cfg, int rfid_port_no, HINSTANCE self);
+void printer_hook_insert_hooks(HMODULE target);
+
+void printer_set_dimensions(int width, int height);
+int WINAPI fwdlusb_updateFirmware_main(uint8_t update, LPCSTR filename, uint16_t *rResult);
+int WINAPI fwdlusb_updateFirmware_dsp(uint8_t update, LPCSTR filename, uint16_t *rResult);
+int WINAPI fwdlusb_updateFirmware_param(uint8_t update, LPCSTR filename, uint16_t *rResult);

iccard/felica.c

@@ -37,7 +37,7 @@ uint64_t felica_get_generic_PMm(void)
        Suica passes and other payment and transportation cards
        do not seem to be supported anymore. */
 
-    return 0x01168B868FBECBFFULL;
+    return 0x00F1000000014300;
 }
 
 HRESULT felica_transact(

idachook/config.c

@@ -89,6 +89,7 @@ void idac_hook_config_load(
     zinput_config_load(&cfg->zinput, filename);
     dvd_config_load(&cfg->dvd, filename);
     io4_config_load(&cfg->io4, filename);
+    ffb_config_load(&cfg->ffb, filename);
     led15070_config_load(&cfg->led15070, filename);
     indrun_config_load(&cfg->indrun, filename);
 }

idachook/config.h

@@ -19,6 +19,7 @@ struct idac_hook_config {
     struct aime_config aime;
     struct dvd_config dvd;
     struct io4_config io4;
+    struct ffb_config ffb;
     struct idac_dll_config dll;
     struct zinput_config zinput;
     struct led15070_config led15070;

idachook/dllmain.c

@@ -5,7 +5,9 @@
 
      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
+    COM2:   837-15070-02 IC BD LED Controller Board (DIPSW2 OFF)
+            OR
+            837-15070-04 IC BD LED Controller Board (DIPSW2 ON)
     COM3:   837-15286 "Gen 2" Aime Reader (DIPSW2 OFF)
             OR
             837-15396 "Gen 3" Aime Reader (DIPSW2 ON)
@@ -28,6 +30,7 @@
 #include "idachook/config.h"
 #include "idachook/idac-dll.h"
 #include "idachook/io4.h"
+#include "idachook/ffb.h"
 #include "idachook/zinput.h"
 
 #include "platform/platform.h"
@@ -84,6 +87,12 @@ static DWORD CALLBACK idac_pre_startup(void)
         goto fail;
     }
 
+    hr = idac_ffb_hook_init(&idac_hook_cfg.ffb, 1);
+
+    if (FAILED(hr)) {
+        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);
 

idachook/ffb.c

@@ -0,0 +1,59 @@
+#include <windows.h>
+
+#include <xinput.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "board/ffb.h"
+
+#include "idachook/idac-dll.h"
+
+#include "util/dprintf.h"
+
+static void idac_ffb_toggle(bool active);
+static void idac_ffb_constant_force(uint8_t direction, uint8_t force);
+static void idac_ffb_rumble(uint8_t force, uint8_t period);
+static void idac_ffb_damper(uint8_t force);
+
+static const struct ffb_ops idac_ffb_ops = {
+    .toggle         = idac_ffb_toggle,
+    .constant_force = idac_ffb_constant_force,
+    .rumble         = idac_ffb_rumble,
+    .damper         = idac_ffb_damper
+};
+
+HRESULT idac_ffb_hook_init(const struct ffb_config *cfg, unsigned int port_no)
+{
+    HRESULT hr;
+
+    assert(idac_dll.init != NULL);
+
+    hr = ffb_hook_init(cfg, &idac_ffb_ops, port_no);
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+
+    return idac_dll.ffb_init();
+}
+
+static void idac_ffb_toggle(bool active)
+{
+    idac_dll.ffb_toggle(active);
+}
+
+static void idac_ffb_constant_force(uint8_t direction, uint8_t force)
+{
+    idac_dll.ffb_constant_force(direction, force);
+}
+
+static void idac_ffb_rumble(uint8_t force, uint8_t period)
+{
+    idac_dll.ffb_rumble(force, period);
+}
+
+static void idac_ffb_damper(uint8_t force)
+{
+    idac_dll.ffb_damper(force);
+}

idachook/ffb.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <windows.h>
+
+#include "board/ffb.h"
+
+HRESULT idac_ffb_hook_init(const struct ffb_config *cfg, unsigned int port_no);

idachook/idac-dll.c

@@ -36,6 +36,21 @@ const struct dll_bind_sym idac_dll_syms[] = {
     }, {
         .sym = "idac_io_led_set_leds",
         .off = offsetof(struct idac_dll, led_set_leds),
+    }, {
+        .sym = "idac_io_ffb_init",
+        .off = offsetof(struct idac_dll, ffb_init),
+    }, {
+        .sym = "idac_io_ffb_toggle",
+        .off = offsetof(struct idac_dll, ffb_toggle),
+    }, {
+        .sym = "idac_io_ffb_constant_force",
+        .off = offsetof(struct idac_dll, ffb_constant_force),
+    }, {
+        .sym = "idac_io_ffb_rumble",
+        .off = offsetof(struct idac_dll, ffb_rumble),
+    }, {
+        .sym = "idac_io_ffb_damper",
+        .off = offsetof(struct idac_dll, ffb_damper),
     }
 };
 

idachook/idac-dll.h

@@ -15,6 +15,11 @@ struct idac_dll {
     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);
+    HRESULT (*ffb_init)(void);
+    void (*ffb_toggle)(bool active);
+    void (*ffb_constant_force)(uint8_t direction, uint8_t force);
+    void (*ffb_rumble)(uint8_t period, uint8_t force);
+    void (*ffb_damper)(uint8_t force);
 };
 
 struct idac_dll_config {

idachook/idachook.def

@@ -21,3 +21,8 @@ EXPORTS
     idac_io_led_set_fet_output
     idac_io_led_gs_update
     idac_io_led_set_leds
+    idac_io_ffb_init
+    idac_io_ffb_toggle
+    idac_io_ffb_constant_force
+    idac_io_ffb_rumble
+    idac_io_ffb_damper

idachook/io4.c

@@ -15,7 +15,7 @@ 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,
+    .poll       = idac_io4_poll,
     .write_gpio = idac_io4_write_gpio
 };
 
@@ -133,6 +133,8 @@ static HRESULT idac_io4_poll(void *ctx, struct io4_state *state)
 
 static HRESULT idac_io4_write_gpio(uint8_t* payload, size_t len) 
 {
+    assert(idac_dll.led_set_leds != NULL);
+    
     // Just fast fail if there aren't enough bytes in the payload
     if (len < 3) 
         return S_OK;

idachook/meson.build

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

idacio/backend.h

@@ -9,4 +9,9 @@ struct idac_io_backend {
     void (*get_gamebtns)(uint8_t *gamebtn);
     void (*get_shifter)(uint8_t *gear);
     void (*get_analogs)(struct idac_io_analog_state *state);
+    HRESULT (*ffb_init)(void);
+    void (*ffb_toggle)(bool active);
+    void (*ffb_constant_force)(uint8_t direction, uint8_t force);
+    void (*ffb_rumble)(uint8_t period, uint8_t force);
+    void (*ffb_damper)(uint8_t force);
 };

idacio/config.c

@@ -80,13 +80,29 @@ void idac_di_config_load(struct idac_di_config *cfg, const wchar_t *filename)
     }
 
     // FFB configuration
+    cfg->ffb_constant_force_strength = GetPrivateProfileIntW(
+            L"dinput",
+            L"constantForceStrength",
+            100,
+            filename);
 
-    cfg->center_spring_strength = GetPrivateProfileIntW(
-                            L"dinput",
-                            L"centerSpringStrength",
-                            30,
-                            filename);
+    cfg->ffb_rumble_strength = GetPrivateProfileIntW(
+            L"dinput",
+            L"rumbleStrength",
+            100,
+            filename);
 
+    cfg->ffb_damper_strength = GetPrivateProfileIntW(
+            L"dinput",
+            L"damperStrength",
+            100,
+            filename);
+
+    cfg->ffb_rumble_duration = GetPrivateProfileIntW(
+            L"dinput",
+            L"rumbleDuration",
+            1000,
+            filename);
 }
 
 void idac_xi_config_load(struct idac_xi_config *cfg, const wchar_t *filename)

idacio/config.h

@@ -25,7 +25,11 @@ struct idac_di_config {
     bool reverse_accel_axis;
 
     // FFB configuration
-    uint16_t center_spring_strength;
+    uint8_t ffb_constant_force_strength;
+    uint8_t ffb_rumble_strength;
+    uint8_t ffb_damper_strength;
+
+    uint32_t ffb_rumble_duration;
 };
 
 struct idac_xi_config {

idacio/di-dev.c

@@ -1,140 +1,45 @@
 #include <windows.h>
 #include <dinput.h>
-
+#include <stdbool.h>
 #include <assert.h>
 
 #include "idacio/di-dev.h"
 
 #include "util/dprintf.h"
 
-HRESULT idac_di_dev_start(IDirectInputDevice8W *dev, HWND wnd)
+const struct idac_di_config *idac_di_cfg;
+static HWND idac_di_wnd;
+static IDirectInputDevice8W *idac_di_dev;
+
+/* Individual DI Effects */
+static IDirectInputEffect *idac_di_fx;
+static IDirectInputEffect *idac_di_fx_rumble;
+static IDirectInputEffect *idac_di_fx_damper;
+
+/* Max FFB Board value is 127 */
+static const double idac_di_ffb_scale = 127.0;
+
+HRESULT idac_di_dev_init(
+    const struct idac_di_config *cfg,
+    IDirectInputDevice8W *dev,
+    HWND wnd)
 {
     HRESULT hr;
 
     assert(dev != NULL);
     assert(wnd != NULL);
 
-    hr = IDirectInputDevice8_SetCooperativeLevel(
-            dev,
-            wnd,
-            DISCL_BACKGROUND | DISCL_EXCLUSIVE);
+    idac_di_cfg = cfg;
+    idac_di_dev = dev;
+    idac_di_wnd = wnd;
 
-    if (FAILED(hr)) {
-        dprintf("DirectInput: SetCooperativeLevel failed: %08x\n", (int) hr);
-
-        return hr;
-    }
-
-    hr = IDirectInputDevice8_SetDataFormat(dev, &c_dfDIJoystick);
-
-    if (FAILED(hr)) {
-        dprintf("DirectInput: SetDataFormat failed: %08x\n", (int) hr);
-
-        return hr;
-    }
-
-    hr = IDirectInputDevice8_Acquire(dev);
-
-    if (FAILED(hr)) {
-        dprintf("DirectInput: Acquire failed: %08x\n", (int) hr);
-
-        return hr;
-    }
-
-    return hr;
-}
-
-void idac_di_dev_start_fx(
-    IDirectInputDevice8W *dev, IDirectInputEffect **out, uint16_t strength)
-{
-    /* Set up force-feedback on devices that support it. This is just a stub
-       for the time being, since we don't yet know how the serial port force
-       feedback protocol works.
-
-       I'm currently developing with an Xbox One Thrustmaster TMX wheel, if
-       we don't perform at least some perfunctory FFB initialization of this
-       nature (or indeed if no DirectInput application is running) then the
-       wheel exhibits considerable resistance, similar to that of a stationary
-       car. Changing cf.lMagnitude to a nonzero value does cause the wheel to
-       continuously turn in the given direction with the given force as one
-       would expect (max magnitude per DirectInput docs is +/- 10000).
-
-       Failure here is non-fatal, we log any errors and move on.
-
-       https://docs.microsoft.com/en-us/previous-versions/windows/desktop/ee416353(v=vs.85)
-    */
-
-    IDirectInputEffect *obj;
-    DWORD axis;
-    LONG direction;
-    DIEFFECT fx;
-    DICONDITION cond;
-    HRESULT hr;
-
-    assert(dev != NULL);
-    assert(out != NULL);
-
-    *out = NULL;
-
-    dprintf("DirectInput: Starting force feedback (may take a sec)\n");
-
-    // Auto-centering effect
-    axis = DIJOFS_X;
-    direction = 0;
-
-    memset(&cond, 0, sizeof(cond));
-    cond.lOffset = 0;
-    cond.lPositiveCoefficient = strength;
-    cond.lNegativeCoefficient = strength;
-    cond.dwPositiveSaturation = strength; // For FG920?
-    cond.dwNegativeSaturation = strength; // For FG920?
-    cond.lDeadBand = 0;
-
-    memset(&fx, 0, sizeof(fx));
-    fx.dwSize = sizeof(fx);
-    fx.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
-    fx.dwDuration = INFINITE;
-    fx.dwGain = DI_FFNOMINALMAX;
-    fx.dwTriggerButton = DIEB_NOTRIGGER;
-    fx.dwTriggerRepeatInterval = INFINITE;
-    fx.cAxes = 1;
-    fx.rgdwAxes = &axis;
-    fx.rglDirection = &direction;
-    fx.cbTypeSpecificParams = sizeof(cond);
-    fx.lpvTypeSpecificParams = &cond;
-
-    hr = IDirectInputDevice8_CreateEffect(
-            dev,
-            &GUID_Spring,
-            &fx,
-            &obj,
-            NULL);
-
-    if (FAILED(hr)) {
-        dprintf("DirectInput: Centering spring force feedback unavailable: %08x\n",
-                (int) hr);
-        return;
-    }
-
-    hr = IDirectInputEffect_Start(obj, INFINITE, 0);
-
-    if (FAILED(hr)) {
-        IDirectInputEffect_Release(obj);
-        dprintf("DirectInput: Centering spring force feedback start failed: %08x\n",
-                (int) hr);
-        return;
-    }
-
-    *out = obj;
-
-    dprintf("DirectInput: Centering spring effects initialized with strength %d%%\n", 
-            strength / 100);
+    return S_OK;
 }
 
 HRESULT idac_di_dev_poll(
-        IDirectInputDevice8W *dev,
-        HWND wnd,
-        union idac_di_state *out)
+    IDirectInputDevice8W *dev,
+    HWND wnd,
+    union idac_di_state *out)
 {
     HRESULT hr;
     MSG msg;
@@ -154,16 +59,313 @@ HRESULT idac_di_dev_poll(
     }
 
     hr = IDirectInputDevice8_GetDeviceState(
-            dev,
-            sizeof(out->st),
-            &out->st);
+        dev,
+        sizeof(out->st),
+        &out->st);
 
     if (FAILED(hr)) {
-        dprintf("DirectInput: GetDeviceState error: %08x\n", (int) hr);
+        dprintf("DirectInput: GetDeviceState error: %08x\n", (int)hr);
     }
 
-    /* JVS lacks a protocol for reporting hardware errors from poll command
-       responses, so this ends up returning zeroed input state instead. */
-
     return hr;
 }
+
+HRESULT idac_di_dev_start(IDirectInputDevice8W *dev, HWND wnd) {
+    HRESULT hr;
+
+    assert(dev != NULL);
+    assert(wnd != NULL);
+
+    hr = IDirectInputDevice8_SetCooperativeLevel(
+        dev,
+        wnd,
+        DISCL_BACKGROUND | DISCL_EXCLUSIVE);
+
+    if (FAILED(hr)) {
+        dprintf("DirectInput: SetCooperativeLevel failed: %08x\n", (int)hr);
+        return hr;
+    }
+
+    hr = IDirectInputDevice8_SetDataFormat(dev, &c_dfDIJoystick);
+
+    if (FAILED(hr)) {
+        dprintf("DirectInput: SetDataFormat failed: %08x\n", (int)hr);
+        return hr;
+    }
+
+    hr = IDirectInputDevice8_Acquire(dev);
+
+    if (FAILED(hr)) {
+        dprintf("DirectInput: Acquire failed: %08x\n", (int)hr);
+        return hr;
+    }
+
+    return hr;
+}
+
+HRESULT idac_di_ffb_init(void)
+{
+    HRESULT hr;
+
+    hr = idac_di_dev_start(idac_di_dev, idac_di_wnd);
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+
+    return S_OK;
+}
+
+void idac_di_ffb_toggle(bool active)
+{
+    if (active) {
+        return;
+    }
+
+    /* Stop and release all effects */
+    /* I never programmed DirectInput Effects, so this might be bad practice. */
+    if (idac_di_fx != NULL) {
+        IDirectInputEffect_Stop(idac_di_fx);
+        IDirectInputEffect_Release(idac_di_fx);
+        idac_di_fx = NULL;
+    }
+
+    if (idac_di_fx_rumble != NULL) {
+        IDirectInputEffect_Stop(idac_di_fx_rumble);
+        IDirectInputEffect_Release(idac_di_fx_rumble);
+        idac_di_fx_rumble = NULL;
+    }
+
+    if (idac_di_fx_damper != NULL) {
+        IDirectInputEffect_Stop(idac_di_fx_damper);
+        IDirectInputEffect_Release(idac_di_fx_damper);
+        idac_di_fx_damper = NULL;
+    }
+}
+
+void idac_di_ffb_constant_force(uint8_t direction_ffb, uint8_t force)
+{
+    /* DI expects a magnitude in the range of -10.000 to 10.000 */
+    uint16_t ffb_strength = idac_di_cfg->ffb_constant_force_strength * 100;
+    if (ffb_strength == 0) {
+        return;
+    }
+
+    DWORD axis;
+    LONG direction;
+    DIEFFECT fx;
+    DICONSTANTFORCE cf;
+    HRESULT hr;
+
+    /* Direction 0: move to the right, 1: move to the left */
+    LONG magnitude = (LONG)(((double)force / idac_di_ffb_scale) * ffb_strength);
+    cf.lMagnitude = (direction_ffb == 0) ? -magnitude : magnitude;
+
+    axis = DIJOFS_X;
+    direction = 0;
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    fx.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
+    fx.dwDuration = INFINITE;
+    fx.dwGain = DI_FFNOMINALMAX;
+    fx.dwTriggerButton = DIEB_NOTRIGGER;
+    fx.dwTriggerRepeatInterval = INFINITE;
+    fx.cAxes = 1;
+    fx.rgdwAxes = &axis;
+    fx.rglDirection = &direction;
+    fx.cbTypeSpecificParams = sizeof(cf);
+    fx.lpvTypeSpecificParams = &cf;
+
+    /* Check if the effect already exists */
+    if (idac_di_fx != NULL) {
+        hr = IDirectInputEffect_SetParameters(idac_di_fx, &fx, DIEP_TYPESPECIFICPARAMS);
+        if (SUCCEEDED(hr)) {
+            return; // Successfully updated existing effect
+        }
+        else {
+            dprintf("DirectInput: Failed to update constant force feedback, recreating effect: %08x\n", (int)hr);
+            IDirectInputEffect_Stop(idac_di_fx);
+            IDirectInputEffect_Release(idac_di_fx);
+            idac_di_fx = NULL; // Reset the pointer
+        }
+    }
+
+    /* Create a new constant force effect */
+    IDirectInputEffect *obj;
+    hr = IDirectInputDevice8_CreateEffect(
+        idac_di_dev,
+        &GUID_ConstantForce,
+        &fx,
+        &obj,
+        NULL);
+
+    if (FAILED(hr)) {
+        dprintf("DirectInput: Constant force feedback creation failed: %08x\n", (int)hr);
+        return;
+    }
+
+    /* Start the effect */
+    hr = IDirectInputEffect_Start(obj, INFINITE, 0);
+    if (FAILED(hr)) {
+        dprintf("DirectInput: Constant force feedback start failed: %08x\n", (int)hr);
+        IDirectInputEffect_Release(obj);
+        return;
+    }
+
+    idac_di_fx = obj;
+}
+
+void idac_di_ffb_rumble(uint8_t force, uint8_t period)
+{
+    /* DI expects a magnitude in the range of -10.000 to 10.000 */
+    uint16_t ffb_strength = idac_di_cfg->ffb_rumble_strength * 100;
+    if (ffb_strength == 0) {
+        return;
+    }
+
+    uint32_t ffb_duration = idac_di_cfg->ffb_rumble_duration;
+
+    DWORD axis;
+    LONG direction;
+    DIEFFECT fx;
+    DIPERIODIC pe;
+    HRESULT hr;
+
+    DWORD duration = (DWORD)((double)force * ffb_duration);
+
+    memset(&pe, 0, sizeof(pe));
+    pe.dwMagnitude = (DWORD)(((double)force / idac_di_ffb_scale) * ffb_strength);
+    pe.lOffset = 0;
+    pe.dwPhase = 0;
+    pe.dwPeriod = duration;
+
+    axis = DIJOFS_X;
+    direction = 0;
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    fx.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
+    fx.dwDuration = INFINITE;
+    fx.dwGain = DI_FFNOMINALMAX;
+    fx.dwTriggerButton = DIEB_NOTRIGGER;
+    fx.dwTriggerRepeatInterval = INFINITE;
+    fx.cAxes = 1;
+    fx.rgdwAxes = &axis;
+    fx.rglDirection = &direction;
+    fx.cbTypeSpecificParams = sizeof(pe);
+    fx.lpvTypeSpecificParams = &pe;
+
+    /* Check if the effect already exists */
+    if (idac_di_fx_rumble != NULL) {
+        hr = IDirectInputEffect_SetParameters(idac_di_fx_rumble, &fx, DIEP_TYPESPECIFICPARAMS);
+        if (SUCCEEDED(hr)) {
+            return;
+        }
+        else {
+            dprintf("DirectInput: Failed to update rumble feedback, recreating effect: %08x\n", (int)hr);
+            IDirectInputEffect_Stop(idac_di_fx_rumble);
+            IDirectInputEffect_Release(idac_di_fx_rumble);
+            idac_di_fx_rumble = NULL;
+        }
+    }
+
+    /* Create a new rumble effect */
+    IDirectInputEffect *obj;
+    hr = IDirectInputDevice8_CreateEffect(
+        idac_di_dev,
+        &GUID_Sine,
+        &fx,
+        &obj,
+        NULL);
+
+    if (FAILED(hr)) {
+        dprintf("DirectInput: Rumble effect creation failed: %08x\n", (int)hr);
+        return;
+    }
+
+    /* Start the effect */
+    hr = IDirectInputEffect_Start(obj, INFINITE, 0);
+    if (FAILED(hr)) {
+        dprintf("DirectInput: Rumble effect start failed: %08x\n", (int)hr);
+        IDirectInputEffect_Release(obj);
+        return;
+    }
+
+    idac_di_fx_rumble = obj;
+}
+
+void idac_di_ffb_damper(uint8_t force)
+{
+    /* DI expects a coefficient in the range of -10.000 to 10.000 */
+    uint16_t ffb_strength = idac_di_cfg->ffb_damper_strength * 100;
+    if (ffb_strength == 0) {
+        return;
+    }
+
+    DWORD axis;
+    LONG direction;
+    DIEFFECT fx;
+    DICONDITION cond;
+    HRESULT hr;
+
+    memset(&cond, 0, sizeof(cond));
+    cond.lOffset = 0;
+    cond.lPositiveCoefficient = (LONG)(((double)force / idac_di_ffb_scale) * ffb_strength);
+    cond.lNegativeCoefficient = (LONG)(((double)force / idac_di_ffb_scale) * ffb_strength);
+    /* Not sure on this one */
+    cond.dwPositiveSaturation = DI_FFNOMINALMAX;
+    cond.dwNegativeSaturation = DI_FFNOMINALMAX;
+    cond.lDeadBand = 0;
+
+    axis = DIJOFS_X;
+    direction = 0;
+
+    memset(&fx, 0, sizeof(fx));
+    fx.dwSize = sizeof(fx);
+    fx.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
+    fx.dwDuration = INFINITE;
+    fx.dwGain = DI_FFNOMINALMAX;
+    fx.dwTriggerButton = DIEB_NOTRIGGER;
+    fx.dwTriggerRepeatInterval = INFINITE;
+    fx.cAxes = 1;
+    fx.rgdwAxes = &axis;
+    fx.rglDirection = &direction;
+    fx.cbTypeSpecificParams = sizeof(cond);
+    fx.lpvTypeSpecificParams = &cond;
+
+    /* Check if the damper effect already exists */
+    if (idac_di_fx_damper != NULL) {
+        hr = IDirectInputEffect_SetParameters(idac_di_fx_damper, &fx, DIEP_TYPESPECIFICPARAMS);
+        if (SUCCEEDED(hr)) {
+            return;
+        }
+        else {
+            IDirectInputEffect_Stop(idac_di_fx_damper);
+            IDirectInputEffect_Release(idac_di_fx_damper);
+            idac_di_fx_damper = NULL;
+        }
+    }
+
+    /* Create a new damper effect */
+    IDirectInputEffect *obj;
+    hr = IDirectInputDevice8_CreateEffect(
+        idac_di_dev,
+        &GUID_Damper,
+        &fx,
+        &obj,
+        NULL);
+
+    if (FAILED(hr)) {
+        return;
+    }
+
+    /* Start the effect */
+    hr = IDirectInputEffect_Start(obj, fx.dwDuration, 0);
+    if (FAILED(hr)) {
+        IDirectInputEffect_Release(obj);
+        return;
+    }
+
+    idac_di_fx_damper = obj;
+}

idacio/di-dev.h

@@ -5,15 +5,26 @@
 
 #include <stdint.h>
 
+#include "idacio/config.h"
+
 union idac_di_state {
     DIJOYSTATE st;
     uint8_t bytes[sizeof(DIJOYSTATE)];
 };
 
+HRESULT idac_di_dev_init(
+    const struct idac_di_config *cfg,
+    IDirectInputDevice8W *dev,
+    HWND wnd);
+
 HRESULT idac_di_dev_start(IDirectInputDevice8W *dev, HWND wnd);
-void idac_di_dev_start_fx(IDirectInputDevice8W *dev, IDirectInputEffect **out, uint16_t strength);
 HRESULT idac_di_dev_poll(
         IDirectInputDevice8W *dev,
         HWND wnd,
         union idac_di_state *out);
 
+HRESULT idac_di_ffb_init(void);
+void idac_di_ffb_toggle(bool active);
+void idac_di_ffb_constant_force(uint8_t direction, uint8_t force);
+void idac_di_ffb_rumble(uint8_t force, uint8_t period);
+void idac_di_ffb_damper(uint8_t force);

idacio/di.c

@@ -52,9 +52,14 @@ static const struct idac_di_axis idac_di_axes[] = {
 };
 
 static const struct idac_io_backend idac_di_backend = {
-    .get_gamebtns   = idac_di_get_buttons,
-    .get_shifter   = idac_di_get_shifter,
-    .get_analogs   = idac_di_get_analogs,
+    .get_gamebtns       = idac_di_get_buttons,
+    .get_shifter        = idac_di_get_shifter,
+    .get_analogs        = idac_di_get_analogs,
+    .ffb_init           = idac_di_ffb_init,
+    .ffb_toggle         = idac_di_ffb_toggle,
+    .ffb_constant_force = idac_di_ffb_constant_force,
+    .ffb_rumble         = idac_di_ffb_rumble,
+    .ffb_damper         = idac_di_ffb_damper
 };
 
 static HWND idac_di_wnd;
@@ -62,7 +67,6 @@ static IDirectInput8W *idac_di_api;
 static IDirectInputDevice8W *idac_di_dev;
 static IDirectInputDevice8W *idac_di_pedals;
 static IDirectInputDevice8W *idac_di_shifter;
-static IDirectInputEffect *idac_di_fx;
 static size_t idac_di_off_brake;
 static size_t idac_di_off_accel;
 static uint8_t idac_di_shift_dn;
@@ -75,7 +79,6 @@ static uint8_t idac_di_gear[6];
 static bool idac_di_use_pedals;
 static bool idac_di_reverse_brake_axis;
 static bool idac_di_reverse_accel_axis;
-static uint16_t idac_di_center_spring_strength;
 
 HRESULT idac_di_init(
         const struct idac_di_config *cfg,
@@ -105,7 +108,7 @@ HRESULT idac_di_init(
         return hr;
     }
 
-    /* Initial D Zero has some built-in DirectInput support that is not
+    /* Initial D THE ARCADE has some built-in DirectInput support that is not
        particularly useful. idachook shorts this out by redirecting dinput8.dll
        to a no-op implementation of DirectInput. However, idacio does need to
        talk to the real operating system implementation of DirectInput without
@@ -168,16 +171,12 @@ HRESULT idac_di_init(
         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
     }
 
-    hr = idac_di_dev_start(idac_di_dev, idac_di_wnd);
+    hr = idac_di_dev_init(cfg, idac_di_dev, idac_di_wnd);
 
     if (FAILED(hr)) {
         return hr;
     }
 
-    // Convert the strength from 0-100 to 0-10000 for DirectInput
-    idac_di_dev_start_fx(idac_di_dev, &idac_di_fx, 
-                         idac_di_center_spring_strength * 100);
-
     if (cfg->pedals_name[0] != L'\0') {
         hr = IDirectInput8_EnumDevices(
                 idac_di_api,
@@ -367,15 +366,24 @@ static HRESULT idac_di_config_apply(const struct idac_di_config *cfg)
         idac_di_gear[i] = cfg->gear[i];
     }
 
-    // FFB configuration
+    /* FFB configuration */
+    if (cfg->ffb_constant_force_strength < 0 || cfg->ffb_constant_force_strength > 100) {
+        dprintf("Wheel: Invalid constant force strength: %i\n", cfg->ffb_constant_force_strength);
 
-    if (cfg->center_spring_strength < 0 || cfg->center_spring_strength > 100) {
-        dprintf("Wheel: Invalid center spring strength: %i\n", cfg->center_spring_strength);
+        return E_INVALIDARG;
+    }
+    
+    if (cfg->ffb_rumble_strength < 0 || cfg->ffb_rumble_strength > 100) {
+        dprintf("Wheel: Invalid rumble strength: %i\n", cfg->ffb_rumble_strength);
 
         return E_INVALIDARG;
     }
 
-    idac_di_center_spring_strength = cfg->center_spring_strength;
+    if (cfg->ffb_damper_strength < 0 || cfg->ffb_damper_strength > 100) {
+        dprintf("Wheel: Invalid damper strength: %i\n", cfg->ffb_damper_strength);
+
+        return E_INVALIDARG;
+    }
 
     return S_OK;
 }

idacio/dllmain.c

@@ -19,7 +19,7 @@ static bool idac_io_coin;
 
 uint16_t idac_io_get_api_version(void)
 {
-    return 0x0101;
+    return 0x0102;
 }
 
 HRESULT idac_io_init(void)
@@ -62,6 +62,8 @@ void idac_io_get_opbtns(uint8_t *opbtn_out)
 
     opbtn = 0;
 
+    /* Common operator buttons, not backend-specific */
+
     if (GetAsyncKeyState(idac_io_cfg.vk_test) & 0x8000) {
         opbtn |= IDAC_IO_OPBTN_TEST;
     }
@@ -159,3 +161,38 @@ void idac_io_led_set_leds(const uint8_t *rgb)
 
     return;
 }
+
+HRESULT idac_io_ffb_init(void)
+{
+    assert(idac_io_backend != NULL);
+
+    return idac_io_backend->ffb_init();
+}
+
+void idac_io_ffb_toggle(bool active)
+{
+    assert(idac_io_backend != NULL);
+    
+    idac_io_backend->ffb_toggle(active);
+}
+
+void idac_io_ffb_constant_force(uint8_t direction, uint8_t force)
+{
+    assert(idac_io_backend != NULL);
+    
+    idac_io_backend->ffb_constant_force(direction, force);
+}
+
+void idac_io_ffb_rumble(uint8_t period, uint8_t force)
+{
+    assert(idac_io_backend != NULL);
+    
+    idac_io_backend->ffb_rumble(period, force);
+}
+
+void idac_io_ffb_damper(uint8_t force)
+{
+    assert(idac_io_backend != NULL);
+    
+    idac_io_backend->ffb_damper(force);
+}

idacio/idacio.def

@@ -10,3 +10,8 @@ EXPORTS
     idac_io_led_set_fet_output
     idac_io_led_gs_update
     idac_io_led_set_leds
+    idac_io_ffb_init
+    idac_io_ffb_toggle
+    idac_io_ffb_constant_force
+    idac_io_ffb_rumble
+    idac_io_ffb_damper

idacio/idacio.h

@@ -2,6 +2,7 @@
 
 #include <windows.h>
 
+#include <stdbool.h>
 #include <stdint.h>
 
 enum {
@@ -160,3 +161,51 @@ void idac_io_led_gs_update(const uint8_t *rgb);
    Minimum API version: 0x0101 */
 
 void idac_io_led_set_leds(const uint8_t *rgb);
+
+/* Initialize FFB emulation. This function will be called before any
+   other idac_io_ffb_*() function calls.
+
+   This will always be called even if FFB board emulation is disabled to allow
+   the IO DLL to initialize any necessary resources.
+
+   Minimum API version: 0x0102 */
+
+HRESULT idac_io_ffb_init(void);
+
+/* Toggle FFB emulation. If active is true, FFB emulation should be enabled.
+   If active is false, FFB emulation should be disabled and all FFB effects
+   should be stopped and released.
+
+   Minimum API version: 0x0102 */
+
+void idac_io_ffb_toggle(bool active);
+
+/* Set a constant force FFB effect.
+   
+   Direction is 0 for right and 1 for left.
+   Force is the magnitude of the force, where 0 is no force and 127 is the
+   maximum force in a given direction.
+
+   Minimum API version: 0x0102 */
+
+void idac_io_ffb_constant_force(uint8_t direction, uint8_t force);
+
+/* Set a (sine) periodic force FFB effect.
+   
+   Period is the period of the effect in milliseconds (not sure).
+   Force is the magnitude of the force, where 0 is no force and 127 is the
+   maximum force.
+
+   Minimum API version: 0x0102 */
+
+void idac_io_ffb_rumble(uint8_t period, uint8_t force);
+
+/* Set a damper FFB effect.
+   
+   Force is the magnitude of the force, where 0 is no force and 40 is the
+   maximum force. Theoretically the maximum force is 127, but the game only
+   uses a maximum of 40.
+
+   Minimum API version: 0x0102 */
+
+void idac_io_ffb_damper(uint8_t force);

idacio/xi.c

@@ -1,5 +1,3 @@
-#include "idacio/xi.h"
-
 #include <assert.h>
 #include <math.h>
 #include <stdbool.h>
@@ -7,22 +5,35 @@
 #include <windows.h>
 #include <xinput.h>
 
+#include "idacio/xi.h"
 #include "idacio/backend.h"
 #include "idacio/config.h"
 #include "idacio/idacio.h"
 #include "idacio/shifter.h"
+
 #include "util/dprintf.h"
 
 static void idac_xi_get_gamebtns(uint8_t *gamebtn_out);
 static void idac_xi_get_shifter(uint8_t *gear);
 static void idac_xi_get_analogs(struct idac_io_analog_state *out);
 
+static HRESULT idac_xi_ffb_init(void);
+static void idac_xi_ffb_toggle(bool active);
+static void idac_xi_ffb_constant_force(uint8_t direction, uint8_t force);
+static void idac_xi_ffb_rumble(uint8_t force, uint8_t period);
+static void idac_xi_ffb_damper(uint8_t force);
+
 static HRESULT idac_xi_config_apply(const struct idac_xi_config *cfg);
 
 static const struct idac_io_backend idac_xi_backend = {
-    .get_gamebtns = idac_xi_get_gamebtns,
-    .get_shifter = idac_xi_get_shifter,
-    .get_analogs = idac_xi_get_analogs,
+    .get_gamebtns       = idac_xi_get_gamebtns,
+    .get_shifter        = idac_xi_get_shifter,
+    .get_analogs        = idac_xi_get_analogs,
+    .ffb_init           = idac_xi_ffb_init,
+    .ffb_toggle         = idac_xi_ffb_toggle,
+    .ffb_constant_force = idac_xi_ffb_constant_force,
+    .ffb_rumble         = idac_xi_ffb_rumble,
+    .ffb_damper         = idac_xi_ffb_damper
 };
 
 static bool idac_xi_single_stick_steering;
@@ -46,7 +57,7 @@ HRESULT idac_xi_init(const struct idac_xi_config *cfg, const struct idac_io_back
         return hr;
     }
 
-    dprintf("XInput: Using XInput controller\n");
+    dprintf("IDACIO: Using XInput controller\n");
     *backend = &idac_xi_backend;
 
     return S_OK;
@@ -205,3 +216,35 @@ static void idac_xi_get_analogs(struct idac_io_analog_state *out) {
     out->accel = xi.Gamepad.bRightTrigger << 8;
     out->brake = xi.Gamepad.bLeftTrigger << 8;
 }
+
+static HRESULT idac_xi_ffb_init(void) {
+    return S_OK;
+}
+
+static void idac_xi_ffb_toggle(bool active) {
+    XINPUT_VIBRATION vibration;
+
+    memset(&vibration, 0, sizeof(vibration));
+
+    XInputSetState(0, &vibration);
+}
+
+static void idac_xi_ffb_constant_force(uint8_t direction, uint8_t force) {
+    return;
+}
+
+static void idac_xi_ffb_rumble(uint8_t force, uint8_t period) {
+    XINPUT_VIBRATION vibration;
+    /* XInput max strength is 65.535, so multiply the 127.0 by 516. */
+    uint16_t strength = force * 516;
+
+    memset(&vibration, 0, sizeof(vibration));
+    vibration.wLeftMotorSpeed = strength;
+    vibration.wRightMotorSpeed = strength;
+
+    XInputSetState(0, &vibration);
+}
+
+static void idac_xi_ffb_damper(uint8_t force) {
+    return;
+}

idzhook/config.c

@@ -18,6 +18,42 @@
 #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 idz_dll_config_load(
         struct idz_dll_config *cfg,
         const wchar_t *filename)
@@ -47,6 +83,8 @@ void idz_hook_config_load(
     dvd_config_load(&cfg->dvd, filename);
     gfx_config_load(&cfg->gfx, filename);
     idz_dll_config_load(&cfg->dll, filename);
+    ffb_config_load(&cfg->ffb, filename);
+    led15070_config_load(&cfg->led15070, filename);
     zinput_config_load(&cfg->zinput, filename);
 }
 

idzhook/config.h

@@ -5,7 +5,8 @@
 
 #include "amex/amex.h"
 
-#include "board/sg-reader.h"
+#include "board/config.h"
+#include "board/led15070.h"
 
 #include "gfxhook/gfx.h"
 
@@ -23,6 +24,8 @@ struct idz_hook_config {
     struct dvd_config dvd;
     struct gfx_config gfx;
     struct idz_dll_config dll;
+    struct ffb_config ffb;
+    struct led15070_config led15070;
     struct zinput_config zinput;
 };
 

idzhook/dllmain.c

@@ -33,6 +33,7 @@
 #include "idzhook/config.h"
 #include "idzhook/idz-dll.h"
 #include "idzhook/jvs.h"
+#include "idzhook/ffb.h"
 #include "idzhook/zinput.h"
 
 #include "platform/platform.h"
@@ -102,6 +103,12 @@ static DWORD CALLBACK idz_pre_startup(void)
         goto fail;
     }
 
+    hr = idz_jvs_hook_init();
+
+    if (FAILED(hr)) {
+        goto fail;
+    }
+
     hr = amex_hook_init(&idz_hook_cfg.amex, idz_jvs_init);
 
     if (FAILED(hr)) {
@@ -114,6 +121,19 @@ static DWORD CALLBACK idz_pre_startup(void)
         goto fail;
     }
 
+    hr = idz_ffb_hook_init(&idz_hook_cfg.ffb, 1);
+
+    if (FAILED(hr)) {
+        goto fail;
+    }
+
+    hr = led15070_hook_init(&idz_hook_cfg.led15070, idz_dll.led_init, 
+        idz_dll.led_set_fet_output, NULL, idz_dll.led_gs_update, 11, 1);
+
+    if (FAILED(hr)) {
+        goto fail;
+    }
+
     /* Initialize debug helpers */
 
     spike_hook_init(L".\\segatools.ini");

idzhook/ffb.c

@@ -0,0 +1,59 @@
+#include <windows.h>
+
+#include <xinput.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "board/ffb.h"
+
+#include "idzhook/idz-dll.h"
+
+#include "util/dprintf.h"
+
+static void idz_ffb_toggle(bool active);
+static void idz_ffb_constant_force(uint8_t direction, uint8_t force);
+static void idz_ffb_rumble(uint8_t force, uint8_t period);
+static void idz_ffb_damper(uint8_t force);
+
+static const struct ffb_ops idz_ffb_ops = {
+    .toggle         = idz_ffb_toggle,
+    .constant_force = idz_ffb_constant_force,
+    .rumble         = idz_ffb_rumble,
+    .damper         = idz_ffb_damper
+};
+
+HRESULT idz_ffb_hook_init(const struct ffb_config *cfg, unsigned int port_no)
+{
+    HRESULT hr;
+
+    assert(idz_dll.jvs_init != NULL);
+
+    hr = ffb_hook_init(cfg, &idz_ffb_ops, port_no);
+
+    if (FAILED(hr)) {
+        return hr;
+    }
+
+    return idz_dll.ffb_init();
+}
+
+static void idz_ffb_toggle(bool active)
+{
+    idz_dll.ffb_toggle(active);
+}
+
+static void idz_ffb_constant_force(uint8_t direction, uint8_t force)
+{
+    idz_dll.ffb_constant_force(direction, force);
+}
+
+static void idz_ffb_rumble(uint8_t force, uint8_t period)
+{
+    idz_dll.ffb_rumble(force, period);
+}
+
+static void idz_ffb_damper(uint8_t force)
+{
+    idz_dll.ffb_damper(force);
+}

idzhook/ffb.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <windows.h>
+
+#include "board/ffb.h"
+
+HRESULT idz_ffb_hook_init(const struct ffb_config *cfg, unsigned int port_no);

idzhook/idz-dll.c

@@ -24,6 +24,33 @@ const struct dll_bind_sym idz_dll_syms[] = {
     }, {
         .sym = "idz_io_jvs_read_coin_counter",
         .off = offsetof(struct idz_dll, jvs_read_coin_counter),
+    }, {
+        .sym = "idz_io_led_init",
+        .off = offsetof(struct idz_dll, led_init),
+    }, {
+        .sym = "idz_io_led_set_fet_output",
+        .off = offsetof(struct idz_dll, led_set_fet_output),
+    }, {
+        .sym = "idz_io_led_gs_update",
+        .off = offsetof(struct idz_dll, led_gs_update),
+    }, {
+        .sym = "idz_io_led_set_leds",
+        .off = offsetof(struct idz_dll, led_set_leds),
+    }, {
+        .sym = "idz_io_ffb_init",
+        .off = offsetof(struct idz_dll, ffb_init),
+    }, {
+        .sym = "idz_io_ffb_toggle",
+        .off = offsetof(struct idz_dll, ffb_toggle),
+    }, {
+        .sym = "idz_io_ffb_constant_force",
+        .off = offsetof(struct idz_dll, ffb_constant_force),
+    }, {
+        .sym = "idz_io_ffb_rumble",
+        .off = offsetof(struct idz_dll, ffb_rumble),
+    }, {
+        .sym = "idz_io_ffb_damper",
+        .off = offsetof(struct idz_dll, ffb_damper),
     }
 };
 

idzhook/idz-dll.h

@@ -11,6 +11,15 @@ struct idz_dll {
     void (*jvs_read_buttons)(uint8_t *opbtn, uint8_t *gamebtn);
     void (*jvs_read_shifter)(uint8_t *gear);
     void (*jvs_read_coin_counter)(uint16_t *total);
+    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);
+    HRESULT (*ffb_init)(void);
+    void (*ffb_toggle)(bool active);
+    void (*ffb_constant_force)(uint8_t direction, uint8_t force);
+    void (*ffb_rumble)(uint8_t period, uint8_t force);
+    void (*ffb_damper)(uint8_t force);
 };
 
 struct idz_dll_config {

idzhook/idzhook.def

@@ -22,3 +22,12 @@ EXPORTS
     idz_io_jvs_read_buttons
     idz_io_jvs_read_coin_counter
     idz_io_jvs_read_shifter
+    idz_io_led_init
+    idz_io_led_set_fet_output
+    idz_io_led_gs_update
+    idz_io_led_set_leds
+    idz_io_ffb_init
+    idz_io_ffb_toggle
+    idz_io_ffb_constant_force
+    idz_io_ffb_rumble
+    idz_io_ffb_damper

idzhook/jvs.c

@@ -24,11 +24,13 @@ static void idz_jvs_read_coin_counter(
         void *ctx,
         uint8_t slot_no,
         uint16_t *out);
+static void idz_jvs_write_gpio(void *ctx, uint32_t state);
 
 static const struct io3_ops idz_jvs_io3_ops = {
     .read_switches      = idz_jvs_read_switches,
     .read_analogs       = idz_jvs_read_analogs,
     .read_coin_counter  = idz_jvs_read_coin_counter,
+    .write_gpio         = idz_jvs_write_gpio
 };
 
 static const uint16_t idz_jvs_gear_signals[] = {
@@ -50,21 +52,20 @@ static const uint16_t idz_jvs_gear_signals[] = {
 
 static struct io3 idz_jvs_io3;
 
+HRESULT idz_jvs_hook_init(void)
+{
+    HRESULT hr;
+
+    assert(idz_dll.jvs_init != NULL);
+
+    return idz_dll.jvs_init();
+}
+
 HRESULT idz_jvs_init(struct jvs_node **out)
 {
     HRESULT hr;
 
     assert(out != NULL);
-    assert(idz_dll.jvs_init != NULL);
-
-    dprintf("JVS I/O: Starting Initial D Zero backend DLL\n");
-    hr = idz_dll.jvs_init();
-
-    if (FAILED(hr)) {
-        dprintf("JVS I/O: Backend error, I/O disconnected; %x\n", (int) hr);
-
-        return hr;
-    }
 
     io3_init(&idz_jvs_io3, NULL, &idz_jvs_io3_ops, NULL);
     *out = io3_to_jvs_node(&idz_jvs_io3);
@@ -175,3 +176,21 @@ static void idz_jvs_read_coin_counter(
 
     idz_dll.jvs_read_coin_counter(out);
 }
+static void idz_jvs_write_gpio(void *ctx, uint32_t state) 
+{
+    assert(idz_dll.led_set_leds != NULL);
+    
+    // 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] = {
+        state & IDZ_IO_LED_START ? 0xFF : 0x00,
+        state & IDZ_IO_LED_VIEW_CHANGE ? 0xFF : 0x00,
+        state & IDZ_IO_LED_UP ? 0xFF : 0x00,
+        state & IDZ_IO_LED_DOWN ? 0xFF : 0x00,
+        state & IDZ_IO_LED_RIGHT ? 0xFF : 0x00,
+        state & IDZ_IO_LED_LEFT ? 0xFF : 0x00,
+    };
+
+    idz_dll.led_set_leds(rgb_out);
+}

idzhook/jvs.h

@@ -4,4 +4,6 @@
 
 #include "jvs/jvs-bus.h"
 
+HRESULT idz_jvs_hook_init(void);
+
 HRESULT idz_jvs_init(struct jvs_node **root);