Split USB memory path configurations

dist/ddr/ddr-11-us.conf

@@ -22,8 +22,11 @@ ddrhook1.use_15khz=false
 # Enable USB memory data emulation
 ddrhook1.usbmem_enabled=false
 
-# Specify path for USB memory data
+# Specify path for USB memory data for P1
-ddrhook1.usbmem_path=usbmem
+ddrhook1.usbmem_path_p1=usbmem_p1
+
+# Specify path for USB memory data for P2
+ddrhook1.usbmem_path_p2=usbmem_p2
 
 # Run the game windowed
 gfx.windowed=false

dist/ddr/ddr-11.conf

@@ -22,8 +22,11 @@ ddrhook1.use_15khz=false
 # Enable USB memory data emulation
 ddrhook1.usbmem_enabled=false
 
-# Specify path for USB memory data
+# Specify path for P1 USB memory data
-ddrhook1.usbmem_path=usbmem
+ddrhook1.usbmem_path_p1=usbmem_p1
+
+# Specify path for P2 USB memory data
+ddrhook1.usbmem_path_p2=usbmem_p2
 
 # Run the game windowed
 gfx.windowed=false

src/main/ddrhook-util/usbmem.c

@@ -48,6 +48,7 @@ struct USBMEM_STATE {
     bool errored;
     USBMEM_FILE_TYPE file_type;
 
+    char basepath[MAX_PATH];
     char path[MAX_PATH];
     char filename[MAX_PATH];
 
@@ -57,8 +58,6 @@ struct USBMEM_STATE {
     int buffer_frame;
 };
 
-static char usb_data_path[MAX_PATH];
-
 static int target_device_id;
 static struct USBMEM_STATE usbmem_state[USBMEM_DEVICE_COUNT];
 
@@ -75,11 +74,12 @@ static void usbmem_reset_file_state(int port)
     usbmem_state[port].file_type = USBMEM_FILE_TYPE_NONE;
 }
 
-void usbmem_init(const char *path, const bool enabled)
+void usbmem_init(const char *path_p1, const char *path_p2, const bool enabled)
 {
     log_assert(usbmem_fd == NULL);
 
     HRESULT hr;
+    char usb_data_path[USBMEM_DEVICE_COUNT][MAX_PATH];
 
     hr = iohook_open_nul_fd(&usbmem_fd);
 
@@ -89,22 +89,23 @@ void usbmem_init(const char *path, const bool enabled)
 
     usbmem_enabled = enabled;
 
-    GetFullPathNameA(path, sizeof(usb_data_path), usb_data_path, NULL);
+    GetFullPathNameA(path_p1, sizeof(usb_data_path[0]), usb_data_path[0], NULL);
-    log_misc("USB memory data path: %s", usb_data_path);
+    log_misc("USB memory data path (P1): %s", usb_data_path[0]);
 
-    if (!path_exists(usb_data_path)) {
+    GetFullPathNameA(path_p2, sizeof(usb_data_path[1]), usb_data_path[1], NULL);
+    log_misc("USB memory data path (P2): %s", usb_data_path[1]);
+
+    if (enabled && !path_exists(usb_data_path[0]) && !path_exists(usb_data_path[1])) {
         log_warning("USB memory data path does not exist, disabling");
         usbmem_enabled = false;
     }
 
     target_device_id = -1;
     for (int i = 0; i < USBMEM_DEVICE_COUNT; i++) {
-        char subpath[MAX_PATH];
-        snprintf(subpath, sizeof(subpath), "%s\\p%d", usb_data_path, i + 1);
-
         usbmem_state[i].connected = false;
         usbmem_state[i].opened = false;
         usbmem_state[i].errored = false;
+        strcpy(usbmem_state[i].basepath, usb_data_path[i]);
         memset(usbmem_state[i].path, 0, sizeof(usbmem_state[i].path));
         memset(usbmem_state[i].filename, 0, sizeof(usbmem_state[i].filename));
         usbmem_reset_file_state(i);
@@ -183,7 +184,7 @@ static HRESULT usbmem_write(struct irp *irp)
     if (!usbmem_pending && target_device_id >= 0 && target_device_id < USBMEM_DEVICE_COUNT && usbmem_state[target_device_id].file_type == USBMEM_FILE_TYPE_READ) {
         memset(usbmem_response, 0, sizeof(usbmem_response));
 
-        log_misc("Read progress %08x/%08x bytes", usbmem_state[target_device_id].buffer_index, usbmem_state[target_device_id].buffer_len);
+        // log_misc("Read progress %08x/%08x bytes", usbmem_state[target_device_id].buffer_index, usbmem_state[target_device_id].buffer_len);
 
         if (usbmem_state[target_device_id].buffer_index < usbmem_state[target_device_id].buffer_len) {
             usbmem_response_length = sizeof(usbmem_response);
@@ -223,11 +224,7 @@ static HRESULT usbmem_write(struct irp *irp)
             target_device_val = *(target_device_id_ptr - 1);
         }
 
-        // Counterintuitively, b is P1 and a is P2
+        // TODO: Rewrite this code to more cleanly handle hotplugging USB drives
-        if (target_device_val == 'a' || target_device_val == 'b') {
-            target_device_id = target_device_val - 'a';
-        }
-
         if (str_eq(request, "sver")) {
             str_cpy(
                 usbmem_response,
@@ -235,129 +232,134 @@ static HRESULT usbmem_write(struct irp *irp)
                 "done GQHDXJAA DJHACKRS");
         } else if (str_eq(request, "init") || str_eq(request, "start")) {
             str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-        } else if (target_device_id < 0 || target_device_id >= USBMEM_DEVICE_COUNT) {
+        } else if (target_device_val == 'a' || target_device_val == 'b') {
-            str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+            // Counterintuitively, b is P1 and a is P2
-        } else if ((target_device_val == 'a' || target_device_val == 'b') && usbmem_state[target_device_id].errored) {
+            target_device_id = target_device_val == 'b' ? 0 : 1;
-            // If the device went through the entire process once and the file didn't exist
-            // then just force it to be disabled because otherwise it'll get stuck in a loop.
-            str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-        } else if (!usbmem_enabled) {
-            // Ignore all other USB device specific commands and pretend a device isn't plugged in.
-            str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-        } else if (str_eq(request, "on_a") || str_eq(request, "on_b")) {
-            usbmem_state[target_device_id].connected = true;
-            usbmem_reset_file_state(target_device_id);
-            str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-        } else if (str_eq(request, "offa") || str_eq(request, "offb")) {
-            usbmem_state[target_device_id].connected = false;
-            usbmem_reset_file_state(target_device_id);
-            str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-        } else if (str_eq(request, "opna") || str_eq(request, "opnb")) {
-            char temp[MAX_PATH];
-            snprintf(temp, sizeof(temp), "%s\\p%d", usb_data_path, 2 - (request[3] - 'a'));
 
-            usbmem_state[target_device_id].opened = false;
+            if (!usbmem_enabled) {
+                // Ignore all other USB device specific commands and pretend a device isn't plugged in
+                // when USB memory emulation is disabled.
+                str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+            } else if (usbmem_state[target_device_id].errored) {
+                // If the device went through the entire process once and the file didn't exist
+                // then just force it to be disabled until the game is restarted because otherwise
+                // it'll get stuck in a loop.
+                // TODO: This could be better emulated by using a keybind to simulate inserting and
+                // ejecting the USB drive to additionally clear the error flag.
+                str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+            } else if (str_eq(request, "on_a") || str_eq(request, "on_b")) {
+                usbmem_state[target_device_id].connected = path_exists(usbmem_state[target_device_id].basepath);
+                usbmem_state[target_device_id].errored = false;
 
-            if (usbmem_state[target_device_id].connected != true || !path_exists(temp)) {
+                usbmem_reset_file_state(target_device_id);
-                str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-            } else {
-                usbmem_state[target_device_id].opened = true;
-                str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-            }
-        } else if (str_eq(request, "clsa") || str_eq(request, "clsb")) {
-            if (usbmem_state[target_device_id].connected != true) {
-                str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-            } else if (usbmem_state[target_device_id].opened != true) {
-                str_cpy(usbmem_response, sizeof(usbmem_response), "already");
-            } else {
-                str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-            }
 
-            usbmem_state[target_device_id].opened = false;
+                if (usbmem_state[target_device_id].connected)
-            usbmem_reset_file_state(target_device_id);
-        } else if (strncmp(request, "cda ", 4) == 0 || strncmp(request, "cdb ", 4) == 0) {
-            char *path = request + 4;
-            int path_target_device_id = -1;
-
-            if (path[0] == 'a' || path[0] == 'b') {
-                path_target_device_id = path[0] - 'a';
-            }
-
-            if (usbmem_state[target_device_id].connected != true || usbmem_state[target_device_id].opened != true) {
-                str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-            } else if (path_target_device_id == -1 || path_target_device_id != target_device_id) {
-                // Don't allow access to another drive
-                str_cpy(usbmem_response, sizeof(usbmem_response), "illegal");
-            } else if (path[1] == ':') {
-                // Absolute path
-                char temp[MAX_PATH];
-                snprintf(temp, sizeof(temp), "%s\\p%d\\%s", usb_data_path, 2 - target_device_id, path + 3);
-
-                if (!path_exists(temp)) {
-                    log_warning("Couldn't find path %s\n", temp);
                     str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-                } else {
+                else
-                    log_misc("Changing path to %s\n", temp);
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-                    str_cpy(usbmem_state[target_device_id].path, sizeof(usbmem_state[target_device_id].path), temp);
+            } else if (str_eq(request, "offa") || str_eq(request, "offb")) {
+                if (usbmem_state[target_device_id].connected)
                     str_cpy(usbmem_response, sizeof(usbmem_response), "done");
-                }
+                else
-            } else {
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
-                str_cpy(usbmem_response, sizeof(usbmem_response), "illegal");
-            }
-        } else if (strncmp(request, "rda ", 4) == 0 || strncmp(request, "rdb ", 4) == 0) {
-            usbmem_reset_file_state(target_device_id);
 
-            if (usbmem_state[target_device_id].connected != true || usbmem_state[target_device_id].opened != true) {
+                usbmem_state[target_device_id].connected = false;
-                str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
+                usbmem_reset_file_state(target_device_id);
-            } else {
+            } else if (str_eq(request, "opna") || str_eq(request, "opnb")) {
-                char temp[MAX_PATH] = {0};
+                bool basepath_exists = path_exists(usbmem_state[target_device_id].basepath);
-                char *filename = request + 4;
 
-                snprintf(temp, sizeof(temp), "%s\\%s", usbmem_state[target_device_id].path, filename);
+                if (!usbmem_state[target_device_id].connected || !basepath_exists) {
-
-                if (usbmem_state[target_device_id].buffer) {
-                    free(usbmem_state[target_device_id].buffer);
-                    usbmem_state[target_device_id].buffer = NULL;
-                }
-
-                usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_NONE;
-                usbmem_state[target_device_id].buffer_len = 0;
-                usbmem_state[target_device_id].buffer_index = 0;
-                usbmem_state[target_device_id].buffer_frame = 0;
-                memset(usbmem_state[target_device_id].filename, 0, sizeof(usbmem_state[target_device_id].filename));
-
-                if (!path_exists(temp)) {
-                    log_warning("Couldn't find file %s\n", temp);
-                    str_cpy(usbmem_response, sizeof(usbmem_response), "not exist");
-                    usbmem_state[target_device_id].connected = false;
                     usbmem_state[target_device_id].opened = false;
-                    usbmem_state[target_device_id].errored = true;
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
                 } else {
-                    bool loaded = file_load(temp, (void**)&usbmem_state[target_device_id].buffer,
+                    usbmem_state[target_device_id].opened = true;
-                        &usbmem_state[target_device_id].buffer_len, false);
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "done");
+                }
+            } else if (str_eq(request, "clsa") || str_eq(request, "clsb")) {
+                if (usbmem_state[target_device_id].opened)
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "done");
+                else
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "not connected");
 
-                    if (loaded) {
+                usbmem_state[target_device_id].opened = false;
-                        log_misc("Reading file %s\n", temp);
+                usbmem_reset_file_state(target_device_id);
-                        usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_READ;
+            } else if (strncmp(request, "cda ", 4) == 0 || strncmp(request, "cdb ", 4) == 0) {
+                char *path = request + 4;
 
-                        str_cpy(usbmem_state[target_device_id].filename, sizeof(usbmem_state[target_device_id].filename), filename);
+                if (!usbmem_state[target_device_id].connected || !usbmem_state[target_device_id].opened) {
-                        str_cpy(usbmem_response, sizeof(usbmem_response), "start");
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "done");
+                } else if (path[1] == ':') {
+                    // Absolute path
+                    char temp[MAX_PATH];
+                    snprintf(temp, sizeof(temp), "%s\\%s", usbmem_state[target_device_id].basepath, path + 3);
+
+                    if (!path_exists(temp)) {
+                        log_warning("Couldn't find path %s", temp);
+                        str_cpy(usbmem_response, sizeof(usbmem_response), "done");
                     } else {
-                        log_warning("Couldn't read file %s\n", temp);
+                        log_misc("Changing path to %s", temp);
+                        str_cpy(usbmem_state[target_device_id].path, sizeof(usbmem_state[target_device_id].path), temp);
+                        str_cpy(usbmem_response, sizeof(usbmem_response), "done");
+                    }
+                } else {
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+                }
+            } else if (strncmp(request, "rda ", 4) == 0 || strncmp(request, "rdb ", 4) == 0) {
+                usbmem_reset_file_state(target_device_id);
+
+                if (!usbmem_state[target_device_id].connected || !usbmem_state[target_device_id].opened) {
+                    str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+                } else {
+                    char temp[MAX_PATH] = {0};
+                    char *filename = request + 4;
+
+                    snprintf(temp, sizeof(temp), "%s\\%s", usbmem_state[target_device_id].path, filename);
+
+                    if (usbmem_state[target_device_id].buffer) {
+                        free(usbmem_state[target_device_id].buffer);
+                        usbmem_state[target_device_id].buffer = NULL;
+                    }
+
+                    usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_NONE;
+                    usbmem_state[target_device_id].buffer_len = 0;
+                    usbmem_state[target_device_id].buffer_index = 0;
+                    usbmem_state[target_device_id].buffer_frame = 0;
+                    memset(usbmem_state[target_device_id].filename, 0, sizeof(usbmem_state[target_device_id].filename));
+
+                    if (!path_exists(temp)) {
+                        log_warning("Couldn't find file %s", temp);
                         str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+                        usbmem_state[target_device_id].errored = true;
+                    } else {
+                        bool loaded = file_load(temp, (void**)&usbmem_state[target_device_id].buffer,
+                            &usbmem_state[target_device_id].buffer_len, false);
+
+                        if (loaded) {
+                            log_misc("Reading file %s", temp);
+                            usbmem_state[target_device_id].file_type = USBMEM_FILE_TYPE_READ;
+
+                            str_cpy(usbmem_state[target_device_id].filename, sizeof(usbmem_state[target_device_id].filename), filename);
+                            str_cpy(usbmem_response, sizeof(usbmem_response), "start");
+                        } else {
+                            log_warning("Couldn't read file %s", temp);
+                            str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
+                            usbmem_state[target_device_id].errored = true;
+                        }
                     }
                 }
+            } else if (strncmp(request, "wra ", 4) == 0 || strncmp(request, "wrb ", 4) == 0) {
+                // Open file for writing
+                usbmem_reset_file_state(target_device_id);
+                str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
+            } else if (strncmp(request, "wha ", 4) == 0 || strncmp(request, "whb ", 4) == 0) {
+                // Something relating to writing?
+                str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
+            } else if (strncmp(request, "lma ", 4) == 0 || strncmp(request, "lmb ", 4) == 0) {
+                // What is "lm"?
+                str_cpy(usbmem_response, sizeof(usbmem_response), "done");
+            } else {
+                str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
             }
-        } else if (strncmp(request, "wra ", 4) == 0 || strncmp(request, "wrb ", 4) == 0) {
-            // Open file for writing
-            usbmem_reset_file_state(target_device_id);
-            str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
-        } else if (strncmp(request, "wha ", 4) == 0 || strncmp(request, "whb ", 4) == 0) {
-            // Something relating to writing?
-            str_cpy(usbmem_response, sizeof(usbmem_response), "not supported");
-        } else if (strncmp(request, "lma ", 4) == 0 || strncmp(request, "lmb ", 4) == 0) {
-            // What is "lm"?
-            str_cpy(usbmem_response, sizeof(usbmem_response), "done");
         } else {
             str_cpy(usbmem_response, sizeof(usbmem_response), "fail");
         }

src/main/ddrhook-util/usbmem.h

@@ -1,7 +1,7 @@
 #ifndef DDRHOOK_UTIL_USBMEM_H
 #define DDRHOOK_UTIL_USBMEM_H
 
-void usbmem_init(const char *path, const bool enabled);
+void usbmem_init(const char *path_p1, const char *path_p2, const bool enabled);
 void usbmem_fini(void);
 HRESULT usbmem_dispatch_irp(struct irp *irp);
 

src/main/ddrhook1/config-ddrhook1.c

@@ -9,14 +9,16 @@
 #define DDRHOOK1_CONFIG_DDRHOOK1_USE_COM4_EMU_KEY "ddrhook1.use_com4_emu"
 #define DDRHOOK1_CONFIG_DDRHOOK1_STANDARD_DEF_KEY "ddrhook1.standard_def"
 #define DDRHOOK1_CONFIG_DDRHOOK1_USE_15KHZ_KEY "ddrhook1.use_15khz"
-#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH "ddrhook1.usbmem_path"
 #define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_ENABLED "ddrhook1.usbmem_enabled"
+#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1 "ddrhook1.usbmem_path_p1"
+#define DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2 "ddrhook1.usbmem_path_p2"
 
 #define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USE_COM4_EMU_VALUE true
 #define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_STANDARD_DEF_VALUE false
 #define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USE_15KHZ_VALUE false
 #define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_ENABLED false
-#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH "usbmem"
+#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1 "usbmem_p1"
+#define DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2 "usbmem_p2"
 
 void ddrhook1_config_ddrhook1_init(struct cconfig *config)
 {
@@ -42,9 +44,14 @@ void ddrhook1_config_ddrhook1_init(struct cconfig *config)
         "Enable USB memory data emulation");
     cconfig_util_set_str(
         config,
-        DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH,
+        DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1,
-        DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH,
+        DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1,
-        "Specify path for USB memory data");
+        "Specify path for P1 USB memory data");
+    cconfig_util_set_str(
+        config,
+        DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2,
+        DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2,
+        "Specify path for P2 USB memory data");
 }
 
 void ddrhook1_config_ddrhook1_get(
@@ -96,14 +103,26 @@ void ddrhook1_config_ddrhook1_get(
     }
     if (!cconfig_util_get_str(
             config,
-            DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH,
+            DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1,
-            config_ddrhook1->usbmem_path,
+            config_ddrhook1->usbmem_path_p1,
-            sizeof(config_ddrhook1->usbmem_path) - 1,
+            sizeof(config_ddrhook1->usbmem_path_p1) - 1,
-            DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH)) {
+            DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1)) {
         log_warning(
             "Invalid value for key '%s' specified, fallback "
             "to default '%s'",
-            DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH,
+            DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P1,
-            DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH);
+            DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P1);
+    }
+    if (!cconfig_util_get_str(
+            config,
+            DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2,
+            config_ddrhook1->usbmem_path_p2,
+            sizeof(config_ddrhook1->usbmem_path_p2) - 1,
+            DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2)) {
+        log_warning(
+            "Invalid value for key '%s' specified, fallback "
+            "to default '%s'",
+            DDRHOOK1_CONFIG_DDRHOOK1_USBMEM_PATH_P2,
+            DDRHOOK1_CONFIG_DDRHOOK1_DEFAULT_USBMEM_PATH_P2);
     }
 }

src/main/ddrhook1/config-ddrhook1.h

@@ -13,7 +13,8 @@ struct ddrhook1_config_ddrhook1 {
     bool standard_def;
     bool use_15khz;
     bool usbmem_enabled;
-    char usbmem_path[MAX_PATH];
+    char usbmem_path_p1[MAX_PATH];
+    char usbmem_path_p2[MAX_PATH];
 };
 
 /**

src/main/ddrhook1/dllmain.c

@@ -129,7 +129,8 @@ static DWORD STDCALL my_main()
         &security_rp_sign_key_black_ddrx,
         &security_rp_sign_key_white_eamuse);
     extio_init();
-    usbmem_init(config_ddrhook1.usbmem_path, config_ddrhook1.usbmem_enabled);
+    usbmem_init(config_ddrhook1.usbmem_path_p1, config_ddrhook1.usbmem_path_p2,
+        config_ddrhook1.usbmem_enabled);
     spike_init();
     com4_init();
 

src/main/ddrhook1/filesystem.c

@@ -136,26 +136,26 @@ static char *ddrhook1_filesystem_get_path(LPCTSTR path)
     } else if (strnicmp(path, "E:/conf", 7) == 0
     || strnicmp(path, "E:\\conf", 7) == 0) {
         char *launcher_folder;
-        char *conf_path;
+        char *sub_path;
 
         ddrhook1_get_launcher_path_parts(NULL, &launcher_folder);
-        conf_path = strstr(path, "conf");
+        sub_path = strstr(path, "conf");
 
-        if (conf_path && launcher_folder) {
+        if (sub_path && launcher_folder) {
             new_path = (char*)xmalloc(MAX_PATH);
-            sprintf(new_path, "%s\\%s", launcher_folder, conf_path);
+            sprintf(new_path, "%s\\%s", launcher_folder, sub_path);
         }
     } else if (stricmp(path, "F:/update") == 0
     || stricmp(path, "F:\\update") == 0) {
         char *launcher_folder;
-        char *conf_path;
+        char *sub_path;
 
         ddrhook1_get_launcher_path_parts(NULL, &launcher_folder);
-        conf_path = strstr(path, "update");
+        sub_path = strstr(path, "update");
 
-        if (conf_path && launcher_folder) {
+        if (sub_path && launcher_folder) {
             new_path = (char*)xmalloc(MAX_PATH);
-            sprintf(new_path, "%s\\%s", launcher_folder, conf_path);
+            sprintf(new_path, "%s\\%s", launcher_folder, sub_path);
         }
     }
 
@@ -187,7 +187,7 @@ static HANDLE STDCALL my_FindFirstFileA(
             new_path,
             lpFindFileData);
 
-        log_misc("FindFirstFileA remapped path: %s -> %s\n", lpFileName, new_path);
+        log_misc("FindFirstFileA remapped path: %s -> %s", lpFileName, new_path);
 
         free(new_path);
         return r;

src/main/ddrhook2/dllmain.c

@@ -40,7 +40,8 @@ static bool my_dll_entry_init(char *sidcode, struct property_node *param)
     bool com4;
     bool ok;
     int i;
-    char usbmem_data_path[MAX_PATH] = "";
+    char usbmem_data_path_p1[MAX_PATH] = "";
+    char usbmem_data_path_p2[MAX_PATH] = "";
     bool usbmem_enabled = false;
 
     log_info("--- Begin ddrhook dll_entry_init ---");
@@ -71,10 +72,20 @@ static bool my_dll_entry_init(char *sidcode, struct property_node *param)
 
                 break;
 
-            case 'm':
+            case 'a':
-                /* Specify a USB memory path */
+                /* Specify a USB memory path for P1 */
                 if (i + 1 < argc) {
-                    strcpy(usbmem_data_path, argv[i+1]);
+                    strcpy(usbmem_data_path_p1, argv[i+1]);
+                    usbmem_enabled = true;
+                    i++; // Move forward one to skip the path parameter
+                }
+
+                break;
+
+            case 'b':
+                /* Specify a USB memory path for P2 */
+                if (i + 1 < argc) {
+                    strcpy(usbmem_data_path_p2, argv[i+1]);
                     usbmem_enabled = true;
                     i++; // Move forward one to skip the path parameter
                 }
@@ -102,7 +113,7 @@ static bool my_dll_entry_init(char *sidcode, struct property_node *param)
     ddrhook2_master_insert_hooks(NULL);
     p3io_ddr_init();
     extio_init();
-    usbmem_init(usbmem_data_path, usbmem_enabled);
+    usbmem_init(usbmem_data_path_p1, usbmem_data_path_p2, usbmem_enabled);
     spike_init();
     com4_init();