From 64e85fdfbc0b50cdbb3d3f893ac52ca1c25a4c09 Mon Sep 17 00:00:00 2001 From: OBattler Date: Fri, 25 Jul 2025 16:30:40 +0200 Subject: [PATCH] Retooled ZIP emulation into more expansible Removable Disk emulation, ZIP 100 and 250 types remain selectable, alongside the new 86Box (ie. generic) option. --- src/86box.c | 10 +- src/CMakeLists.txt | 2 +- src/config.c | 212 +++- src/disk/CMakeLists.txt | 2 +- src/disk/hdc_ide.c | 2 +- src/disk/hdc_ide_cmd640.c | 10 +- src/disk/hdc_ide_cmd646.c | 8 +- src/disk/hdc_ide_rz1000.c | 10 +- src/disk/hdc_ide_sff8038i.c | 10 +- src/disk/hdc_ide_w83769f.c | 10 +- src/disk/{zip.c => rdisk.c} | 1084 +++++++++-------- src/include/86box/config.h | 2 +- src/include/86box/machine_status.h | 2 +- src/include/86box/plat.h | 6 +- src/include/86box/{zip.h => rdisk.h} | 107 +- src/include/86box/ui.h | 2 +- src/machine_status.c | 8 +- src/qt/icons/{zip.ico => rdisk.ico} | Bin .../{zip_disabled.ico => rdisk_disabled.ico} | Bin .../icons/{zip_image.ico => rdisk_image.ico} | Bin src/qt/qt_machinestatus.cpp | 100 +- src/qt/qt_machinestatus.hpp | 2 +- src/qt/qt_mediahistorymanager.cpp | 14 +- src/qt/qt_mediahistorymanager.hpp | 4 +- src/qt/qt_mediamenu.cpp | 226 ++-- src/qt/qt_mediamenu.hpp | 22 +- src/qt/qt_newfloppydialog.cpp | 18 +- src/qt/qt_newfloppydialog.hpp | 4 +- src/qt/qt_settings.cpp | 12 +- src/qt/qt_settings_bus_tracking.hpp | 4 +- src/qt/qt_settingsotherremovable.cpp | 267 ++-- src/qt/qt_settingsotherremovable.hpp | 16 +- src/qt/qt_settingsotherremovable.ui | 29 +- src/qt/qt_ui.cpp | 18 +- src/qt_resources.qrc | 14 +- src/scsi/scsi.c | 2 +- src/unix/unix.c | 14 +- src/unix/unix_cdrom.c | 52 +- 38 files changed, 1254 insertions(+), 1051 deletions(-) rename src/disk/{zip.c => rdisk.c} (65%) rename src/include/86box/{zip.h => rdisk.h} (53%) rename src/qt/icons/{zip.ico => rdisk.ico} (100%) rename src/qt/icons/{zip_disabled.ico => rdisk_disabled.ico} (100%) rename src/qt/icons/{zip_image.ico => rdisk_image.ico} (100%) diff --git a/src/86box.c b/src/86box.c index 71f877599..d9b450cf5 100644 --- a/src/86box.c +++ b/src/86box.c @@ -88,7 +88,7 @@ #include <86box/scsi_device.h> #include <86box/cdrom.h> #include <86box/cdrom_interface.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/scsi_disk.h> #include <86box/cdrom_image.h> @@ -1066,7 +1066,7 @@ usage: network_init(); mouse_init(); cdrom_global_init(); - zip_global_init(); + rdisk_global_init(); mo_global_init(); /* Initialize the keyboard accelerator list with default values */ @@ -1395,7 +1395,7 @@ pc_reset_hard_close(void) cdrom_close(); - zip_close(); + rdisk_close(); mo_close(); @@ -1501,7 +1501,7 @@ pc_reset_hard_init(void) mo_hard_reset(); - zip_hard_reset(); + rdisk_hard_reset(); /* Reset any ISA ROM cards. */ @@ -1664,7 +1664,7 @@ pc_close(UNUSED(thread_t *ptr)) cdrom_close(); - zip_close(); + rdisk_close(); mo_close(); diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8cf67043f..27db529f5 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -99,7 +99,7 @@ if(INSTRUMENT) add_compile_definitions(USE_INSTRUMENT) endif() -target_link_libraries(86Box cpu chipset mch dev mem fdd game cdrom zip mo hdd +target_link_libraries(86Box cpu chipset mch dev mem fdd game cdrom rdisk mo hdd net print scsi sio snd utils vid voodoo plat ui) if(HAIKU) diff --git a/src/config.c b/src/config.c index 9aa4a15e5..11646d2c0 100644 --- a/src/config.c +++ b/src/config.c @@ -65,7 +65,7 @@ #include <86box/scsi_device.h> #include <86box/cdrom.h> #include <86box/cdrom_interface.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/sound.h> #include <86box/midi.h> @@ -1458,32 +1458,35 @@ load_other_removable_devices(void) unsigned int board = 0; unsigned int dev = 0; int c; + int legacy_zip_drives = 0; memset(temp, 0x00, sizeof(temp)); - for (c = 0; c < ZIP_NUM; c++) { + for (c = 0; c < RDISK_NUM; c++) { sprintf(temp, "zip_%02i_parameters", c + 1); p = ini_section_get_string(cat, temp, NULL); - if (p != NULL) - sscanf(p, "%01u, %s", &zip_drives[c].is_250, s); - else - sscanf("0, none", "%01u, %s", &zip_drives[c].is_250, s); - zip_drives[c].bus_type = hdd_string_to_bus(s, 1); + if (p != NULL) { + sscanf(p, "%01u, %s", &rdisk_drives[c].type, s); + legacy_zip_drives++; + } else + sscanf("0, none", "%01u, %s", &rdisk_drives[c].type, s); + rdisk_drives[c].type++; + rdisk_drives[c].bus_type = hdd_string_to_bus(s, 1); /* Default values, needed for proper operation of the Settings dialog. */ - zip_drives[c].ide_channel = zip_drives[c].scsi_device_id = c + 2; + rdisk_drives[c].ide_channel = rdisk_drives[c].scsi_device_id = c + 2; - if (zip_drives[c].bus_type == ZIP_BUS_ATAPI) { + if (rdisk_drives[c].bus_type == RDISK_BUS_ATAPI) { sprintf(temp, "zip_%02i_ide_channel", c + 1); sprintf(tmp2, "%01u:%01u", (c + 2) >> 1, (c + 2) & 1); p = ini_section_get_string(cat, temp, tmp2); sscanf(p, "%01u:%01u", &board, &dev); board &= 3; dev &= 1; - zip_drives[c].ide_channel = (board << 1) + dev; + rdisk_drives[c].ide_channel = (board << 1) + dev; - if (zip_drives[c].ide_channel > 7) - zip_drives[c].ide_channel = 7; - } else if (zip_drives[c].bus_type == ZIP_BUS_SCSI) { + if (rdisk_drives[c].ide_channel > 7) + rdisk_drives[c].ide_channel = 7; + } else if (rdisk_drives[c].bus_type == RDISK_BUS_SCSI) { sprintf(temp, "zip_%02i_scsi_location", c + 1); sprintf(tmp2, "%01u:%02u", SCSI_BUS_MAX, c + 2); p = ini_section_get_string(cat, temp, tmp2); @@ -1491,23 +1494,23 @@ load_other_removable_devices(void) if (board >= SCSI_BUS_MAX) { /* Invalid bus - check legacy ID */ sprintf(temp, "zip_%02i_scsi_id", c + 1); - zip_drives[c].scsi_device_id = ini_section_get_int(cat, temp, c + 2); + rdisk_drives[c].scsi_device_id = ini_section_get_int(cat, temp, c + 2); - if (zip_drives[c].scsi_device_id > 15) - zip_drives[c].scsi_device_id = 15; + if (rdisk_drives[c].scsi_device_id > 15) + rdisk_drives[c].scsi_device_id = 15; } else { board %= SCSI_BUS_MAX; dev &= 15; - zip_drives[c].scsi_device_id = (board << 4) + dev; + rdisk_drives[c].scsi_device_id = (board << 4) + dev; } } - if (zip_drives[c].bus_type != ZIP_BUS_ATAPI) { + if (rdisk_drives[c].bus_type != RDISK_BUS_ATAPI) { sprintf(temp, "zip_%02i_ide_channel", c + 1); ini_section_delete_var(cat, temp); } - if (zip_drives[c].bus_type != ZIP_BUS_SCSI) { + if (rdisk_drives[c].bus_type != RDISK_BUS_SCSI) { sprintf(temp, "zip_%02i_scsi_location", c + 1); ini_section_delete_var(cat, temp); } @@ -1519,49 +1522,154 @@ load_other_removable_devices(void) p = ini_section_get_string(cat, temp, ""); sprintf(temp, "zip_%02i_writeprot", c + 1); - zip_drives[c].read_only = ini_section_get_int(cat, temp, 0); + rdisk_drives[c].read_only = ini_section_get_int(cat, temp, 0); ini_section_delete_var(cat, temp); if (!strcmp(p, usr_path)) p[0] = 0x00; if (p[0] != 0x00) { - if (load_image_file(zip_drives[c].image_path, p, &(zip_drives[c].read_only))) + if (load_image_file(rdisk_drives[c].image_path, p, &(rdisk_drives[c].read_only))) fatal("Configuration: Length of zip_%02i_image_path is more than 511\n", c + 1); } for (int i = 0; i < MAX_PREV_IMAGES; i++) { - zip_drives[c].image_history[i] = (char *) calloc((MAX_IMAGE_PATH_LEN + 1) << 1, sizeof(char)); + rdisk_drives[c].image_history[i] = (char *) calloc((MAX_IMAGE_PATH_LEN + 1) << 1, sizeof(char)); sprintf(temp, "zip_%02i_image_history_%02i", c + 1, i + 1); p = ini_section_get_string(cat, temp, NULL); if (p) { - if (load_image_file(zip_drives[c].image_history[i], p, NULL)) + if (load_image_file(rdisk_drives[c].image_history[i], p, NULL)) fatal("Configuration: Length of zip_%02i_image_history_%02i is more than %i\n", c + 1, i + 1, MAX_IMAGE_PATH_LEN - 1); } } - /* If the ZIP drive is disabled, delete all its variables. */ - if (zip_drives[c].bus_type == ZIP_BUS_DISABLED) { - sprintf(temp, "zip_%02i_parameters", c + 1); + sprintf(temp, "zip_%02i_parameters", c + 1); + ini_section_delete_var(cat, temp); + + sprintf(temp, "zip_%02i_ide_channel", c + 1); + ini_section_delete_var(cat, temp); + + sprintf(temp, "zip_%02i_scsi_location", c + 1); + ini_section_delete_var(cat, temp); + + sprintf(temp, "zip_%02i_image_path", c + 1); + ini_section_delete_var(cat, temp); + + for (int i = 0; i < MAX_PREV_IMAGES; i++) { + sprintf(temp, "zip_%02i_image_history_%02i", c + 1, i + 1); + ini_section_delete_var(cat, temp); + } + } + + if (legacy_zip_drives > 0) + goto go_to_mo; + + memset(temp, 0x00, sizeof(temp)); + for (c = 0; c < RDISK_NUM; c++) { + sprintf(temp, "rdisk_%02i_parameters", c + 1); + p = ini_section_get_string(cat, temp, NULL); + if (p != NULL) { + sscanf(p, "%01u, %s", &rdisk_drives[c].type, s); + legacy_zip_drives++; + } else + sscanf("0, none", "%01u, %s", &rdisk_drives[c].type, s); + rdisk_drives[c].bus_type = hdd_string_to_bus(s, 1); + + /* Default values, needed for proper operation of the Settings dialog. */ + rdisk_drives[c].ide_channel = rdisk_drives[c].scsi_device_id = c + 2; + + if (rdisk_drives[c].bus_type == RDISK_BUS_ATAPI) { + sprintf(temp, "rdisk_%02i_ide_channel", c + 1); + sprintf(tmp2, "%01u:%01u", (c + 2) >> 1, (c + 2) & 1); + p = ini_section_get_string(cat, temp, tmp2); + sscanf(p, "%01u:%01u", &board, &dev); + board &= 3; + dev &= 1; + rdisk_drives[c].ide_channel = (board << 1) + dev; + + if (rdisk_drives[c].ide_channel > 7) + rdisk_drives[c].ide_channel = 7; + } else if (rdisk_drives[c].bus_type == RDISK_BUS_SCSI) { + sprintf(temp, "rdisk_%02i_scsi_location", c + 1); + sprintf(tmp2, "%01u:%02u", SCSI_BUS_MAX, c + 2); + p = ini_section_get_string(cat, temp, tmp2); + sscanf(p, "%01u:%02u", &board, &dev); + if (board >= SCSI_BUS_MAX) { + /* Invalid bus - check legacy ID */ + sprintf(temp, "rdisk_%02i_scsi_id", c + 1); + rdisk_drives[c].scsi_device_id = ini_section_get_int(cat, temp, c + 2); + + if (rdisk_drives[c].scsi_device_id > 15) + rdisk_drives[c].scsi_device_id = 15; + } else { + board %= SCSI_BUS_MAX; + dev &= 15; + rdisk_drives[c].scsi_device_id = (board << 4) + dev; + } + } + + if (rdisk_drives[c].bus_type != RDISK_BUS_ATAPI) { + sprintf(temp, "rdisk_%02i_ide_channel", c + 1); + ini_section_delete_var(cat, temp); + } + + if (rdisk_drives[c].bus_type != RDISK_BUS_SCSI) { + sprintf(temp, "rdisk_%02i_scsi_location", c + 1); + ini_section_delete_var(cat, temp); + } + + sprintf(temp, "rdisk_%02i_scsi_id", c + 1); + ini_section_delete_var(cat, temp); + + sprintf(temp, "rdisk_%02i_image_path", c + 1); + p = ini_section_get_string(cat, temp, ""); + + sprintf(temp, "rdisk_%02i_writeprot", c + 1); + rdisk_drives[c].read_only = ini_section_get_int(cat, temp, 0); + ini_section_delete_var(cat, temp); + + if (!strcmp(p, usr_path)) + p[0] = 0x00; + + if (p[0] != 0x00) { + if (load_image_file(rdisk_drives[c].image_path, p, &(rdisk_drives[c].read_only))) + fatal("Configuration: Length of rdisk_%02i_image_path is more than 511\n", c + 1); + } + + for (int i = 0; i < MAX_PREV_IMAGES; i++) { + rdisk_drives[c].image_history[i] = (char *) calloc((MAX_IMAGE_PATH_LEN + 1) << 1, sizeof(char)); + sprintf(temp, "rdisk_%02i_image_history_%02i", c + 1, i + 1); + p = ini_section_get_string(cat, temp, NULL); + if (p) { + if (load_image_file(rdisk_drives[c].image_history[i], p, NULL)) + fatal("Configuration: Length of rdisk_%02i_image_history_%02i is more than %i\n", + c + 1, i + 1, MAX_IMAGE_PATH_LEN - 1); + } + } + + /* If the removable disk drive is disabled, delete all its variables. */ + if (rdisk_drives[c].bus_type == RDISK_BUS_DISABLED) { + sprintf(temp, "rdisk_%02i_parameters", c + 1); ini_section_delete_var(cat, temp); - sprintf(temp, "zip_%02i_ide_channel", c + 1); + sprintf(temp, "rdisk_%02i_ide_channel", c + 1); ini_section_delete_var(cat, temp); - sprintf(temp, "zip_%02i_scsi_location", c + 1); + sprintf(temp, "rdisk_%02i_scsi_location", c + 1); ini_section_delete_var(cat, temp); - sprintf(temp, "zip_%02i_image_path", c + 1); + sprintf(temp, "rdisk_%02i_image_path", c + 1); ini_section_delete_var(cat, temp); for (int i = 0; i < MAX_PREV_IMAGES; i++) { - sprintf(temp, "zip_%02i_image_history_%02i", c + 1, i + 1); + sprintf(temp, "rdisk_%02i_image_history_%02i", c + 1, i + 1); ini_section_delete_var(cat, temp); } } } +go_to_mo: memset(temp, 0x00, sizeof(temp)); for (c = 0; c < MO_NUM; c++) { sprintf(temp, "mo_%02i_parameters", c + 1); @@ -1820,7 +1928,7 @@ config_load(void) #ifdef USE_IOCTL memset(cdrom_ioctl, 0, sizeof(cdrom_ioctl_t) * CDROM_NUM); #endif - memset(zip_drives, 0, sizeof(zip_drive_t)); + memset(rdisk_drives, 0, sizeof(rdisk_drive_t)); config = ini_read(cfg_path); @@ -3045,52 +3153,52 @@ save_other_removable_devices(void) char tmp2[512]; int c; - for (c = 0; c < ZIP_NUM; c++) { - sprintf(temp, "zip_%02i_parameters", c + 1); - if (zip_drives[c].bus_type == 0) { + for (c = 0; c < RDISK_NUM; c++) { + sprintf(temp, "rdisk_%02i_parameters", c + 1); + if (rdisk_drives[c].bus_type == 0) { ini_section_delete_var(cat, temp); } else { - sprintf(tmp2, "%u, %s", zip_drives[c].is_250, - hdd_bus_to_string(zip_drives[c].bus_type, 1)); + sprintf(tmp2, "%u, %s", rdisk_drives[c].type, + hdd_bus_to_string(rdisk_drives[c].bus_type, 1)); ini_section_set_string(cat, temp, tmp2); } - sprintf(temp, "zip_%02i_ide_channel", c + 1); - if (zip_drives[c].bus_type != ZIP_BUS_ATAPI) + sprintf(temp, "rdisk_%02i_ide_channel", c + 1); + if (rdisk_drives[c].bus_type != RDISK_BUS_ATAPI) ini_section_delete_var(cat, temp); else { - sprintf(tmp2, "%01u:%01u", zip_drives[c].ide_channel >> 1, - zip_drives[c].ide_channel & 1); + sprintf(tmp2, "%01u:%01u", rdisk_drives[c].ide_channel >> 1, + rdisk_drives[c].ide_channel & 1); ini_section_set_string(cat, temp, tmp2); } - sprintf(temp, "zip_%02i_scsi_id", c + 1); + sprintf(temp, "rdisk_%02i_scsi_id", c + 1); ini_section_delete_var(cat, temp); - sprintf(temp, "zip_%02i_writeprot", c + 1); + sprintf(temp, "rdisk_%02i_writeprot", c + 1); ini_section_delete_var(cat, temp); - sprintf(temp, "zip_%02i_scsi_location", c + 1); - if (zip_drives[c].bus_type != ZIP_BUS_SCSI) + sprintf(temp, "rdisk_%02i_scsi_location", c + 1); + if (rdisk_drives[c].bus_type != RDISK_BUS_SCSI) ini_section_delete_var(cat, temp); else { - sprintf(tmp2, "%01u:%02u", zip_drives[c].scsi_device_id >> 4, - zip_drives[c].scsi_device_id & 15); + sprintf(tmp2, "%01u:%02u", rdisk_drives[c].scsi_device_id >> 4, + rdisk_drives[c].scsi_device_id & 15); ini_section_set_string(cat, temp, tmp2); } - sprintf(temp, "zip_%02i_image_path", c + 1); - if ((zip_drives[c].bus_type == 0) || (strlen(zip_drives[c].image_path) == 0)) + sprintf(temp, "rdisk_%02i_image_path", c + 1); + if ((rdisk_drives[c].bus_type == 0) || (strlen(rdisk_drives[c].image_path) == 0)) ini_section_delete_var(cat, temp); else - save_image_file(cat, temp, zip_drives[c].image_path); + save_image_file(cat, temp, rdisk_drives[c].image_path); for (int i = 0; i < MAX_PREV_IMAGES; i++) { - sprintf(temp, "zip_%02i_image_history_%02i", c + 1, i + 1); - if ((zip_drives[c].image_history[i] == 0) || strlen(zip_drives[c].image_history[i]) == 0) + sprintf(temp, "rdisk_%02i_image_history_%02i", c + 1, i + 1); + if ((rdisk_drives[c].image_history[i] == 0) || strlen(rdisk_drives[c].image_history[i]) == 0) ini_section_delete_var(cat, temp); else - save_image_file(cat, temp, zip_drives[c].image_history[i]); + save_image_file(cat, temp, rdisk_drives[c].image_history[i]); } } diff --git a/src/disk/CMakeLists.txt b/src/disk/CMakeLists.txt index 48d9e61ff..1cccfe2da 100644 --- a/src/disk/CMakeLists.txt +++ b/src/disk/CMakeLists.txt @@ -37,7 +37,7 @@ add_library(hdd OBJECT hdc_ide_w83769f.c ) -add_library(zip OBJECT zip.c) +add_library(rdisk OBJECT rdisk.c) add_library(mo OBJECT mo.c) diff --git a/src/disk/hdc_ide.c b/src/disk/hdc_ide.c index d725b2ace..5983d288c 100644 --- a/src/disk/hdc_ide.c +++ b/src/disk/hdc_ide.c @@ -46,7 +46,7 @@ #include <86box/hdc.h> #include <86box/hdc_ide.h> #include <86box/hdd.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/version.h> /* Bits of 'atastat' */ diff --git a/src/disk/hdc_ide_cmd640.c b/src/disk/hdc_ide_cmd640.c index 84a40efa4..259792008 100644 --- a/src/disk/hdc_ide_cmd640.c +++ b/src/disk/hdc_ide_cmd640.c @@ -34,7 +34,7 @@ #include <86box/hdc.h> #include <86box/hdc_ide.h> #include <86box/hdc_ide_sff8038i.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> typedef struct cmd640_t { @@ -417,10 +417,10 @@ cmd640_reset(void *priv) (cdrom[i].ide_channel <= max_channel) && cdrom[i].priv) scsi_cdrom_reset((scsi_common_t *) cdrom[i].priv); } - for (i = 0; i < ZIP_NUM; i++) { - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && (zip_drives[i].ide_channel >= min_channel) && - (zip_drives[i].ide_channel <= max_channel) && zip_drives[i].priv) - zip_reset((scsi_common_t *) zip_drives[i].priv); + for (i = 0; i < RDISK_NUM; i++) { + if ((rdisk_drives[i].bus_type == RDISK_BUS_ATAPI) && (rdisk_drives[i].ide_channel >= min_channel) && + (rdisk_drives[i].ide_channel <= max_channel) && rdisk_drives[i].priv) + rdisk_reset((scsi_common_t *) rdisk_drives[i].priv); } for (i = 0; i < MO_NUM; i++) { if ((mo_drives[i].bus_type == MO_BUS_ATAPI) && (mo_drives[i].ide_channel >= min_channel) && diff --git a/src/disk/hdc_ide_cmd646.c b/src/disk/hdc_ide_cmd646.c index a61b78ec3..b56c5f898 100644 --- a/src/disk/hdc_ide_cmd646.c +++ b/src/disk/hdc_ide_cmd646.c @@ -34,7 +34,7 @@ #include <86box/hdc.h> #include <86box/hdc_ide.h> #include <86box/hdc_ide_sff8038i.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> typedef struct cmd646_t { @@ -320,9 +320,9 @@ cmd646_reset(void *priv) if ((cdrom[i].bus_type == CDROM_BUS_ATAPI) && (cdrom[i].ide_channel < 4) && cdrom[i].priv) scsi_cdrom_reset((scsi_common_t *) cdrom[i].priv); } - for (i = 0; i < ZIP_NUM; i++) { - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && (zip_drives[i].ide_channel < 4) && zip_drives[i].priv) - zip_reset((scsi_common_t *) zip_drives[i].priv); + for (i = 0; i < RDISK_NUM; i++) { + if ((rdisk_drives[i].bus_type == RDISK_BUS_ATAPI) && (rdisk_drives[i].ide_channel < 4) && rdisk_drives[i].priv) + rdisk_reset((scsi_common_t *) rdisk_drives[i].priv); } for (i = 0; i < MO_NUM; i++) { if ((mo_drives[i].bus_type == MO_BUS_ATAPI) && (mo_drives[i].ide_channel < 4) && mo_drives[i].priv) diff --git a/src/disk/hdc_ide_rz1000.c b/src/disk/hdc_ide_rz1000.c index 06586b267..b1e6f4dd3 100644 --- a/src/disk/hdc_ide_rz1000.c +++ b/src/disk/hdc_ide_rz1000.c @@ -34,7 +34,7 @@ #include <86box/hdc.h> #include <86box/hdc_ide.h> #include <86box/hdc_ide_sff8038i.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> typedef struct rz1000_t { @@ -182,10 +182,10 @@ rz1000_reset(void *priv) (cdrom[i].ide_channel <= max_channel) && cdrom[i].priv) scsi_cdrom_reset((scsi_common_t *) cdrom[i].priv); } - for (i = 0; i < ZIP_NUM; i++) { - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && (zip_drives[i].ide_channel >= min_channel) && - (zip_drives[i].ide_channel <= max_channel) && zip_drives[i].priv) - zip_reset((scsi_common_t *) zip_drives[i].priv); + for (i = 0; i < RDISK_NUM; i++) { + if ((rdisk_drives[i].bus_type == RDISK_BUS_ATAPI) && (rdisk_drives[i].ide_channel >= min_channel) && + (rdisk_drives[i].ide_channel <= max_channel) && rdisk_drives[i].priv) + rdisk_reset((scsi_common_t *) rdisk_drives[i].priv); } for (i = 0; i < MO_NUM; i++) { if ((mo_drives[i].bus_type == MO_BUS_ATAPI) && (mo_drives[i].ide_channel >= min_channel) && diff --git a/src/disk/hdc_ide_sff8038i.c b/src/disk/hdc_ide_sff8038i.c index 7ded4372f..e962d366b 100644 --- a/src/disk/hdc_ide_sff8038i.c +++ b/src/disk/hdc_ide_sff8038i.c @@ -42,7 +42,7 @@ #include <86box/hdc.h> #include <86box/hdc_ide.h> #include <86box/hdc_ide_sff8038i.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/plat_unused.h> @@ -489,10 +489,10 @@ sff_reset(void *priv) cdrom[i].priv) scsi_cdrom_reset((scsi_common_t *) cdrom[i].priv); } - for (uint8_t i = 0; i < ZIP_NUM; i++) { - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && (zip_drives[i].ide_channel < 4) && - zip_drives[i].priv) - zip_reset((scsi_common_t *) zip_drives[i].priv); + for (uint8_t i = 0; i < RDISK_NUM; i++) { + if ((rdisk_drives[i].bus_type == RDISK_BUS_ATAPI) && (rdisk_drives[i].ide_channel < 4) && + rdisk_drives[i].priv) + rdisk_reset((scsi_common_t *) rdisk_drives[i].priv); } for (uint8_t i = 0; i < MO_NUM; i++) { if ((mo_drives[i].bus_type == MO_BUS_ATAPI) && (mo_drives[i].ide_channel < 4) && diff --git a/src/disk/hdc_ide_w83769f.c b/src/disk/hdc_ide_w83769f.c index 7829c5b92..25ee16d10 100644 --- a/src/disk/hdc_ide_w83769f.c +++ b/src/disk/hdc_ide_w83769f.c @@ -34,7 +34,7 @@ #include <86box/hdc.h> #include <86box/hdc_ide.h> #include <86box/hdc_ide_sff8038i.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> typedef struct w83769f_t { @@ -297,10 +297,10 @@ w83769f_reset(void *priv) (cdrom[i].ide_channel <= max_channel) && cdrom[i].priv) scsi_cdrom_reset((scsi_common_t *) cdrom[i].priv); } - for (i = 0; i < ZIP_NUM; i++) { - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && (zip_drives[i].ide_channel >= min_channel) && - (zip_drives[i].ide_channel <= max_channel) && zip_drives[i].priv) - zip_reset((scsi_common_t *) zip_drives[i].priv); + for (i = 0; i < RDISK_NUM; i++) { + if ((rdisk_drives[i].bus_type == RDISK_BUS_ATAPI) && (rdisk_drives[i].ide_channel >= min_channel) && + (rdisk_drives[i].ide_channel <= max_channel) && rdisk_drives[i].priv) + rdisk_reset((scsi_common_t *) rdisk_drives[i].priv); } for (i = 0; i < MO_NUM; i++) { if ((mo_drives[i].bus_type == MO_BUS_ATAPI) && (mo_drives[i].ide_channel >= min_channel) && diff --git a/src/disk/zip.c b/src/disk/rdisk.c similarity index 65% rename from src/disk/zip.c rename to src/disk/rdisk.c index 7602f8096..5780740ad 100644 --- a/src/disk/zip.c +++ b/src/disk/rdisk.c @@ -13,7 +13,7 @@ * * Copyright 2018-2025 Miran Grca. */ -#ifdef ENABLE_ZIP_LOG +#ifdef ENABLE_RDISK_LOG #include #endif #include @@ -31,18 +31,19 @@ #include <86box/plat.h> #include <86box/ui.h> #include <86box/hdc_ide.h> -#include <86box/zip.h> +#include <86box/rdisk.h> +#include <86box/version.h> #define IDE_ATAPI_IS_EARLY id->sc->pad0 -zip_drive_t zip_drives[ZIP_NUM]; +rdisk_drive_t rdisk_drives[RDISK_NUM]; // clang-format off /* Table of all SCSI commands and their flags, needed for the new disc change / not ready handler. */ -const uint8_t zip_command_flags[0x100] = { +const uint8_t rdisk_command_flags[0x100] = { [0x00] = IMPLEMENTED | CHECK_READY, [0x01] = IMPLEMENTED | ALLOW_UA | SCSI_ONLY, [0x03] = IMPLEMENTED | ALLOW_UA, @@ -139,35 +140,35 @@ static const mode_sense_pages_t zip_250_mode_sense_pages_changeable = { }; // clang-format on -static void zip_command_complete(zip_t *dev); -static void zip_init(zip_t *dev); +static void rdisk_command_complete(rdisk_t *dev); +static void rdisk_init(rdisk_t *dev); -#ifdef ENABLE_ZIP_LOG -int zip_do_log = ENABLE_ZIP_LOG; +#ifdef ENABLE_RDISK_LOG +int rdisk_do_log = ENABLE_RDISK_LOG; static void -zip_log(void *priv, const char *fmt, ...) +rdisk_log(void *priv, const char *fmt, ...) { va_list ap; - if (zip_do_log) { + if (rdisk_do_log) { va_start(ap, fmt); log_out(priv, fmt, ap); va_end(ap); } } #else -# define zip_log(priv, fmt, ...) +# define rdisk_log(priv, fmt, ...) #endif static int -zip_load_abort(const zip_t *dev) +rdisk_load_abort(const rdisk_t *dev) { if (dev->drv->fp) fclose(dev->drv->fp); dev->drv->fp = NULL; dev->drv->medium_size = 0; - zip_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */ + rdisk_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */ return 0; } @@ -178,9 +179,9 @@ image_is_zdi(const char *s) } int -zip_is_empty(const uint8_t id) +rdisk_is_empty(const uint8_t id) { - const zip_t *dev = (const zip_t *) zip_drives[id].priv; + const rdisk_t *dev = (const rdisk_t *) rdisk_drives[id].priv; int ret = 0; if ((dev->drv == NULL) || (dev->drv->fp == NULL)) @@ -190,9 +191,9 @@ zip_is_empty(const uint8_t id) } void -zip_load(const zip_t *dev, const char *fn, const int skip_insert) +rdisk_load(const rdisk_t *dev, const char *fn, const int skip_insert) { - const int was_empty = zip_is_empty(dev->id); + const int was_empty = rdisk_is_empty(dev->id); int ret = 0; int offs = 0; @@ -204,7 +205,7 @@ zip_load(const zip_t *dev, const char *fn, const int skip_insert) fn += offs; if (dev->drv == NULL) - zip_eject(dev->id); + rdisk_eject(dev->id); else { const int is_zdi = image_is_zdi(fn); @@ -215,11 +216,11 @@ zip_load(const zip_t *dev, const char *fn, const int skip_insert) if (!dev->drv->read_only) { dev->drv->fp = plat_fopen(fn, "rb"); if (dev->drv->fp == NULL) - ret = zip_load_abort(dev); + ret = rdisk_load_abort(dev); else dev->drv->read_only = 1; } else - ret = zip_load_abort(dev); + ret = rdisk_load_abort(dev); } if (ret) { @@ -233,17 +234,17 @@ zip_load(const zip_t *dev, const char *fn, const int skip_insert) } else dev->drv->base = 0; - if (dev->drv->is_250) { + if (dev->drv->type != RDISK_TYPE_ZIP_100) { if ((size != (ZIP_250_SECTORS << 9)) && (size != (ZIP_SECTORS << 9))) { - zip_log(dev->log, "File is incorrect size for a ZIP image\n"); - zip_log(dev->log, "Must be exactly %i or %i bytes\n", + rdisk_log(dev->log, "File is incorrect size for a RDISK image\n"); + rdisk_log(dev->log, "Must be exactly %i or %i bytes\n", ZIP_250_SECTORS << 9, ZIP_SECTORS << 9); - ret = zip_load_abort(dev); + ret = rdisk_load_abort(dev); } } else if (size != (ZIP_SECTORS << 9)) { - zip_log(dev->log, "File is incorrect size for a ZIP image\n"); - zip_log(dev->log, "Must be exactly %i bytes\n", ZIP_SECTORS << 9); - ret = zip_load_abort(dev); + rdisk_log(dev->log, "File is incorrect size for a RDISK image\n"); + rdisk_log(dev->log, "Must be exactly %i bytes\n", ZIP_SECTORS << 9); + ret = rdisk_load_abort(dev); } if (ret) @@ -252,7 +253,7 @@ zip_load(const zip_t *dev, const char *fn, const int skip_insert) if (ret) { if (fseek(dev->drv->fp, dev->drv->base, SEEK_SET) == -1) - log_fatal(dev->log, "zip_load(): Error seeking to the beginning of " + log_fatal(dev->log, "rdisk_load(): Error seeking to the beginning of " "the file\n"); strncpy(dev->drv->image_path, fn - offs, sizeof(dev->drv->image_path) - 1); @@ -272,26 +273,26 @@ zip_load(const zip_t *dev, const char *fn, const int skip_insert) if (ret && !skip_insert) { /* Signal media change to the emulated machine. */ - zip_insert((zip_t *) dev); + rdisk_insert((rdisk_t *) dev); /* The drive was previously empty, transition directly to UNIT ATTENTION. */ if (was_empty) - zip_insert((zip_t *) dev); + rdisk_insert((rdisk_t *) dev); } if (ret) - ui_sb_update_icon_wp(SB_ZIP | dev->id, dev->drv->read_only); + ui_sb_update_icon_wp(SB_RDISK | dev->id, dev->drv->read_only); } void -zip_disk_reload(const zip_t *dev) +rdisk_disk_reload(const rdisk_t *dev) { if (strlen(dev->drv->prev_image_path) != 0) - (void) zip_load(dev, dev->drv->prev_image_path, 0); + (void) rdisk_load(dev, dev->drv->prev_image_path, 0); } static void -zip_disk_unload(const zip_t *dev) +rdisk_disk_unload(const rdisk_t *dev) { if ((dev->drv != NULL) && (dev->drv->fp != NULL)) { fclose(dev->drv->fp); @@ -300,10 +301,10 @@ zip_disk_unload(const zip_t *dev) } void -zip_disk_close(const zip_t *dev) +rdisk_disk_close(const rdisk_t *dev) { if ((dev->drv != NULL) && (dev->drv->fp != NULL)) { - zip_disk_unload(dev); + rdisk_disk_unload(dev); memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path)); @@ -311,68 +312,68 @@ zip_disk_close(const zip_t *dev) dev->drv->medium_size = 0; - zip_insert((zip_t *) dev); + rdisk_insert((rdisk_t *) dev); } } static void -zip_set_callback(const zip_t *dev) +rdisk_set_callback(const rdisk_t *dev) { - if (dev->drv->bus_type != ZIP_BUS_SCSI) + if (dev->drv->bus_type != RDISK_BUS_SCSI) ide_set_callback(ide_drives[dev->drv->ide_channel], dev->callback); } static void -zip_init(zip_t *dev) +rdisk_init(rdisk_t *dev) { - if (dev->id < ZIP_NUM) { + if (dev->id < RDISK_NUM) { dev->requested_blocks = 1; dev->sense[0] = 0xf0; dev->sense[7] = 10; dev->drv->bus_mode = 0; - if (dev->drv->bus_type >= ZIP_BUS_ATAPI) + if (dev->drv->bus_type >= RDISK_BUS_ATAPI) dev->drv->bus_mode |= 2; - if (dev->drv->bus_type < ZIP_BUS_SCSI) + if (dev->drv->bus_type < RDISK_BUS_SCSI) dev->drv->bus_mode |= 1; - zip_log(dev->log, "Bus type %i, bus mode %i\n", dev->drv->bus_type, dev->drv->bus_mode); - if (dev->drv->bus_type < ZIP_BUS_SCSI) { + rdisk_log(dev->log, "Bus type %i, bus mode %i\n", dev->drv->bus_type, dev->drv->bus_mode); + if (dev->drv->bus_type < RDISK_BUS_SCSI) { dev->tf->phase = 1; dev->tf->request_length = 0xEB14; } dev->tf->status = READY_STAT | DSC_STAT; dev->tf->pos = 0; dev->packet_status = PHASE_NONE; - zip_sense_key = zip_asc = zip_ascq = dev->unit_attention = dev->transition = 0; - zip_info = 0x00000000; + rdisk_sense_key = rdisk_asc = rdisk_ascq = dev->unit_attention = dev->transition = 0; + rdisk_info = 0x00000000; } } static int -zip_supports_pio(const zip_t *dev) +rdisk_supports_pio(const rdisk_t *dev) { return (dev->drv->bus_mode & 1); } static int -zip_supports_dma(const zip_t *dev) +rdisk_supports_dma(const rdisk_t *dev) { return (dev->drv->bus_mode & 2); } /* Returns: 0 for none, 1 for PIO, 2 for DMA. */ static int -zip_current_mode(const zip_t *dev) +rdisk_current_mode(const rdisk_t *dev) { - if (!zip_supports_pio(dev) && !zip_supports_dma(dev)) + if (!rdisk_supports_pio(dev) && !rdisk_supports_dma(dev)) return 0; - if (zip_supports_pio(dev) && !zip_supports_dma(dev)) { - zip_log(dev->log, "Drive does not support DMA, setting to PIO\n"); + if (rdisk_supports_pio(dev) && !rdisk_supports_dma(dev)) { + rdisk_log(dev->log, "Drive does not support DMA, setting to PIO\n"); return 1; } - if (!zip_supports_pio(dev) && zip_supports_dma(dev)) + if (!rdisk_supports_pio(dev) && rdisk_supports_dma(dev)) return 2; - if (zip_supports_pio(dev) && zip_supports_dma(dev)) { - zip_log(dev->log, "Drive supports both, setting to %s\n", + if (rdisk_supports_pio(dev) && rdisk_supports_dma(dev)) { + rdisk_log(dev->log, "Drive supports both, setting to %s\n", (dev->tf->features & 1) ? "DMA" : "PIO"); return (dev->tf->features & 1) ? 2 : 1; } @@ -381,80 +382,81 @@ zip_current_mode(const zip_t *dev) } static void -zip_mode_sense_load(zip_t *dev) +rdisk_mode_sense_load(rdisk_t *dev) { char fn[512] = { 0 }; memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t)); - if (dev->drv->is_250) { - if (zip_drives[dev->id].bus_type == ZIP_BUS_SCSI) - memcpy(&dev->ms_pages_saved, &zip_250_mode_sense_pages_default_scsi, sizeof(mode_sense_pages_t)); - else - memcpy(&dev->ms_pages_saved, &zip_250_mode_sense_pages_default, sizeof(mode_sense_pages_t)); - } else { - if (zip_drives[dev->id].bus_type == ZIP_BUS_SCSI) + + if (dev->drv->type == RDISK_TYPE_ZIP_100) { + if (rdisk_drives[dev->id].bus_type == RDISK_BUS_SCSI) memcpy(&dev->ms_pages_saved, &zip_mode_sense_pages_default_scsi, sizeof(mode_sense_pages_t)); else memcpy(&dev->ms_pages_saved, &zip_mode_sense_pages_default, sizeof(mode_sense_pages_t)); + } else { + if (rdisk_drives[dev->id].bus_type == RDISK_BUS_SCSI) + memcpy(&dev->ms_pages_saved, &zip_250_mode_sense_pages_default_scsi, sizeof(mode_sense_pages_t)); + else + memcpy(&dev->ms_pages_saved, &zip_250_mode_sense_pages_default, sizeof(mode_sense_pages_t)); } - if (dev->drv->bus_type == ZIP_BUS_SCSI) - sprintf(fn, "scsi_zip_%02i_mode_sense_bin", dev->id); + if (dev->drv->bus_type == RDISK_BUS_SCSI) + sprintf(fn, "scsi_rdisk_%02i_mode_sense_bin", dev->id); else - sprintf(fn, "zip_%02i_mode_sense_bin", dev->id); + sprintf(fn, "rdisk_%02i_mode_sense_bin", dev->id); FILE *fp = plat_fopen(nvr_path(fn), "rb"); if (fp) { - /* Nothing to read, not used by ZIP. */ + /* Nothing to read, not used by RDISK. */ fclose(fp); } } static void -zip_mode_sense_save(const zip_t *dev) +rdisk_mode_sense_save(const rdisk_t *dev) { char fn[512] = { 0 }; - if (dev->drv->bus_type == ZIP_BUS_SCSI) - sprintf(fn, "scsi_zip_%02i_mode_sense_bin", dev->id); + if (dev->drv->bus_type == RDISK_BUS_SCSI) + sprintf(fn, "scsi_rdisk_%02i_mode_sense_bin", dev->id); else - sprintf(fn, "zip_%02i_mode_sense_bin", dev->id); + sprintf(fn, "rdisk_%02i_mode_sense_bin", dev->id); FILE *fp = plat_fopen(nvr_path(fn), "wb"); if (fp) { - /* Nothing to write, not used by ZIP. */ + /* Nothing to write, not used by RDISK. */ fclose(fp); } } /* SCSI Mode Sense 6/10. */ static uint8_t -zip_mode_sense_read(const zip_t *dev, const uint8_t pgctl, +zip_mode_sense_read(const rdisk_t *dev, const uint8_t pgctl, const uint8_t page, const uint8_t pos) { switch (pgctl) { case 0: case 3: - if (dev->drv->is_250 && (page == 5) && (pos == 9) && + if ((dev->drv->type != RDISK_TYPE_ZIP_100) && (page == 5) && (pos == 9) && (dev->drv->medium_size == ZIP_SECTORS)) return 0x60; return dev->ms_pages_saved.pages[page][pos]; case 1: - if (dev->drv->is_250) - return zip_250_mode_sense_pages_changeable.pages[page][pos]; - else + if (dev->drv->type == RDISK_TYPE_ZIP_100) return zip_mode_sense_pages_changeable.pages[page][pos]; + else + return zip_250_mode_sense_pages_changeable.pages[page][pos]; case 2: - if (dev->drv->is_250) { - if ((page == 5) && (pos == 9) && (dev->drv->medium_size == ZIP_SECTORS)) - return 0x60; - if (dev->drv->bus_type == ZIP_BUS_SCSI) - return zip_250_mode_sense_pages_default_scsi.pages[page][pos]; - else - return zip_250_mode_sense_pages_default.pages[page][pos]; - } else { - if (dev->drv->bus_type == ZIP_BUS_SCSI) + if (dev->drv->type == RDISK_TYPE_ZIP_100) { + if (dev->drv->bus_type == RDISK_BUS_SCSI) return zip_mode_sense_pages_default_scsi.pages[page][pos]; else return zip_mode_sense_pages_default.pages[page][pos]; + } else { + if ((page == 5) && (pos == 9) && (dev->drv->medium_size == ZIP_SECTORS)) + return 0x60; + if (dev->drv->bus_type == RDISK_BUS_SCSI) + return zip_250_mode_sense_pages_default_scsi.pages[page][pos]; + else + return zip_250_mode_sense_pages_default.pages[page][pos]; } default: @@ -465,16 +467,16 @@ zip_mode_sense_read(const zip_t *dev, const uint8_t pgctl, } static uint32_t -zip_mode_sense(const zip_t *dev, uint8_t *buf, uint32_t pos, +rdisk_mode_sense(const rdisk_t *dev, uint8_t *buf, uint32_t pos, uint8_t page, const uint8_t block_descriptor_len) { uint64_t pf; const uint8_t pgctl = (page >> 6) & 3; - if (dev->drv->is_250) - pf = zip_250_mode_sense_page_flags; - else + if (dev->drv->type == RDISK_TYPE_ZIP_100) pf = zip_mode_sense_page_flags; + else + pf = zip_250_mode_sense_page_flags; page &= 0x3f; @@ -495,7 +497,7 @@ zip_mode_sense(const zip_t *dev, uint8_t *buf, uint32_t pos, const uint8_t msplen = zip_mode_sense_read(dev, pgctl, i, 1); buf[pos++] = zip_mode_sense_read(dev, pgctl, i, 0); buf[pos++] = msplen; - zip_log(dev->log, "MODE SENSE: Page [%02X] length %i\n", i, msplen); + rdisk_log(dev->log, "MODE SENSE: Page [%02X] length %i\n", i, msplen); for (uint8_t j = 0; j < msplen; j++) buf[pos++] = zip_mode_sense_read(dev, pgctl, i, 2 + j); } @@ -506,7 +508,7 @@ zip_mode_sense(const zip_t *dev, uint8_t *buf, uint32_t pos, } static void -zip_update_request_length(zip_t *dev, int len, int block_len) +rdisk_update_request_length(rdisk_t *dev, int len, int block_len) { int bt; int min_len = 0; @@ -574,7 +576,7 @@ zip_update_request_length(zip_t *dev, int len, int block_len) } static double -zip_bus_speed(zip_t *dev) +rdisk_bus_speed(rdisk_t *dev) { double ret = -1.0; @@ -591,68 +593,68 @@ zip_bus_speed(zip_t *dev) } static void -zip_command_common(zip_t *dev) +rdisk_command_common(rdisk_t *dev) { dev->tf->status = BUSY_STAT; dev->tf->phase = 1; dev->tf->pos = 0; if (dev->packet_status == PHASE_COMPLETE) dev->callback = 0.0; - else if (dev->drv->bus_type == ZIP_BUS_SCSI) + else if (dev->drv->bus_type == RDISK_BUS_SCSI) dev->callback = -1.0; /* Speed depends on SCSI controller */ else - dev->callback = zip_bus_speed(dev) * (double) (dev->packet_len); + dev->callback = rdisk_bus_speed(dev) * (double) (dev->packet_len); - zip_set_callback(dev); + rdisk_set_callback(dev); } static void -zip_command_complete(zip_t *dev) +rdisk_command_complete(rdisk_t *dev) { dev->packet_status = PHASE_COMPLETE; - zip_command_common(dev); + rdisk_command_common(dev); } static void -zip_command_read(zip_t *dev) +rdisk_command_read(rdisk_t *dev) { dev->packet_status = PHASE_DATA_IN; - zip_command_common(dev); + rdisk_command_common(dev); } static void -zip_command_read_dma(zip_t *dev) +rdisk_command_read_dma(rdisk_t *dev) { dev->packet_status = PHASE_DATA_IN_DMA; - zip_command_common(dev); + rdisk_command_common(dev); } static void -zip_command_write(zip_t *dev) +rdisk_command_write(rdisk_t *dev) { dev->packet_status = PHASE_DATA_OUT; - zip_command_common(dev); + rdisk_command_common(dev); } static void -zip_command_write_dma(zip_t *dev) +rdisk_command_write_dma(rdisk_t *dev) { dev->packet_status = PHASE_DATA_OUT_DMA; - zip_command_common(dev); + rdisk_command_common(dev); } /* - dev = Pointer to current ZIP device; + dev = Pointer to current RDISK device; len = Total transfer length; block_len = Length of a single block (why does it matter?!); alloc_len = Allocated transfer length; direction = Transfer direction (0 = read from host, 1 = write to host). */ static void -zip_data_command_finish(zip_t *dev, int len, const int block_len, +rdisk_data_command_finish(rdisk_t *dev, int len, const int block_len, const int alloc_len, const int direction) { - zip_log(dev->log, "Finishing command (%02X): %i, %i, %i, %i, %i\n", + rdisk_log(dev->log, "Finishing command (%02X): %i, %i, %i, %i, %i\n", dev->current_cdb[0], len, block_len, alloc_len, direction, dev->tf->request_length); dev->tf->pos = 0; @@ -660,256 +662,256 @@ zip_data_command_finish(zip_t *dev, int len, const int block_len, if (alloc_len < len) len = alloc_len; } - if ((len == 0) || (zip_current_mode(dev) == 0)) { - if (dev->drv->bus_type != ZIP_BUS_SCSI) + if ((len == 0) || (rdisk_current_mode(dev) == 0)) { + if (dev->drv->bus_type != RDISK_BUS_SCSI) dev->packet_len = 0; - zip_command_complete(dev); + rdisk_command_complete(dev); } else { - if (zip_current_mode(dev) == 2) { - if (dev->drv->bus_type != ZIP_BUS_SCSI) + if (rdisk_current_mode(dev) == 2) { + if (dev->drv->bus_type != RDISK_BUS_SCSI) dev->packet_len = alloc_len; if (direction == 0) - zip_command_read_dma(dev); + rdisk_command_read_dma(dev); else - zip_command_write_dma(dev); + rdisk_command_write_dma(dev); } else { - zip_update_request_length(dev, len, block_len); - if ((dev->drv->bus_type != ZIP_BUS_SCSI) && + rdisk_update_request_length(dev, len, block_len); + if ((dev->drv->bus_type != RDISK_BUS_SCSI) && (dev->tf->request_length == 0)) - zip_command_complete(dev); + rdisk_command_complete(dev); else if (direction == 0) - zip_command_read(dev); + rdisk_command_read(dev); else - zip_command_write(dev); + rdisk_command_write(dev); } } - zip_log(dev->log, "Status: %i, cylinder %i, packet length: %i, position: %i, phase: %i\n", + rdisk_log(dev->log, "Status: %i, cylinder %i, packet length: %i, position: %i, phase: %i\n", dev->packet_status, dev->tf->request_length, dev->packet_len, dev->tf->pos, dev->tf->phase); } static void -zip_sense_clear(zip_t *dev, UNUSED(int command)) +rdisk_sense_clear(rdisk_t *dev, UNUSED(int command)) { - zip_sense_key = zip_asc = zip_ascq = 0; - zip_info = 0x00000000; + rdisk_sense_key = rdisk_asc = rdisk_ascq = 0; + rdisk_info = 0x00000000; } static void -zip_set_phase(const zip_t *dev, const uint8_t phase) +rdisk_set_phase(const rdisk_t *dev, const uint8_t phase) { const uint8_t scsi_bus = (dev->drv->scsi_device_id >> 4) & 0x0f; const uint8_t scsi_id = dev->drv->scsi_device_id & 0x0f; - if (dev->drv->bus_type == ZIP_BUS_SCSI) + if (dev->drv->bus_type == RDISK_BUS_SCSI) scsi_devices[scsi_bus][scsi_id].phase = phase; } static void -zip_cmd_error(zip_t *dev) +rdisk_cmd_error(rdisk_t *dev) { - zip_set_phase(dev, SCSI_PHASE_STATUS); - dev->tf->error = ((zip_sense_key & 0xf) << 4) | ABRT_ERR; + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + dev->tf->error = ((rdisk_sense_key & 0xf) << 4) | ABRT_ERR; dev->tf->status = READY_STAT | ERR_STAT; dev->tf->phase = 3; dev->tf->pos = 0; dev->packet_status = PHASE_ERROR; - dev->callback = 50.0 * ZIP_TIME; - zip_set_callback(dev); - ui_sb_update_icon(SB_ZIP | dev->id, 0); - ui_sb_update_icon_write(SB_ZIP | dev->id, 0); - zip_log(dev->log, "[%02X] ERROR: %02X/%02X/%02X\n", dev->current_cdb[0], zip_sense_key, - zip_asc, zip_ascq); + dev->callback = 50.0 * RDISK_TIME; + rdisk_set_callback(dev); + ui_sb_update_icon(SB_RDISK | dev->id, 0); + ui_sb_update_icon_write(SB_RDISK | dev->id, 0); + rdisk_log(dev->log, "[%02X] ERROR: %02X/%02X/%02X\n", dev->current_cdb[0], rdisk_sense_key, + rdisk_asc, rdisk_ascq); } static void -zip_unit_attention(zip_t *dev) +rdisk_unit_attention(rdisk_t *dev) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); dev->tf->error = (SENSE_UNIT_ATTENTION << 4) | ABRT_ERR; dev->tf->status = READY_STAT | ERR_STAT; dev->tf->phase = 3; dev->tf->pos = 0; dev->packet_status = PHASE_ERROR; - dev->callback = 50.0 * ZIP_TIME; - zip_set_callback(dev); - ui_sb_update_icon(SB_ZIP | dev->id, 0); - ui_sb_update_icon_write(SB_ZIP | dev->id, 0); - zip_log(dev->log, "UNIT ATTENTION\n", dev->id); + dev->callback = 50.0 * RDISK_TIME; + rdisk_set_callback(dev); + ui_sb_update_icon(SB_RDISK | dev->id, 0); + ui_sb_update_icon_write(SB_RDISK | dev->id, 0); + rdisk_log(dev->log, "UNIT ATTENTION\n", dev->id); } static void -zip_buf_alloc(zip_t *dev, const uint32_t len) +rdisk_buf_alloc(rdisk_t *dev, const uint32_t len) { - zip_log(dev->log, "Allocated buffer length: %i\n", len); + rdisk_log(dev->log, "Allocated buffer length: %i\n", len); if (dev->buffer == NULL) dev->buffer = (uint8_t *) malloc(len); } static void -zip_buf_free(zip_t *dev) +rdisk_buf_free(rdisk_t *dev) { if (dev->buffer != NULL) { - zip_log(dev->log, "ZIP %i: Freeing buffer...\n"); + rdisk_log(dev->log, "Removable Disk %i: Freeing buffer...\n"); free(dev->buffer); dev->buffer = NULL; } } static void -zip_bus_master_error(scsi_common_t *sc) +rdisk_bus_master_error(scsi_common_t *sc) { - zip_t *dev = (zip_t *) sc; + rdisk_t *dev = (rdisk_t *) sc; - zip_buf_free(dev); - zip_sense_key = zip_asc = zip_ascq = 0; - zip_info = (dev->sector_pos >> 24) | + rdisk_buf_free(dev); + rdisk_sense_key = rdisk_asc = rdisk_ascq = 0; + rdisk_info = (dev->sector_pos >> 24) | ((dev->sector_pos >> 16) << 8) | ((dev->sector_pos >> 8) << 16) | ( dev->sector_pos << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); } static void -zip_not_ready(zip_t *dev) +rdisk_not_ready(rdisk_t *dev) { - zip_sense_key = SENSE_NOT_READY; - zip_asc = ASC_MEDIUM_NOT_PRESENT; - zip_ascq = 0; - zip_info = 0x00000000; - zip_cmd_error(dev); + rdisk_sense_key = SENSE_NOT_READY; + rdisk_asc = ASC_MEDIUM_NOT_PRESENT; + rdisk_ascq = 0; + rdisk_info = 0x00000000; + rdisk_cmd_error(dev); } static void -zip_write_protected(zip_t *dev) +rdisk_write_protected(rdisk_t *dev) { - zip_sense_key = SENSE_UNIT_ATTENTION; - zip_asc = ASC_WRITE_PROTECTED; - zip_ascq = 0; - zip_info = (dev->sector_pos >> 24) | + rdisk_sense_key = SENSE_UNIT_ATTENTION; + rdisk_asc = ASC_WRITE_PROTECTED; + rdisk_ascq = 0; + rdisk_info = (dev->sector_pos >> 24) | ((dev->sector_pos >> 16) << 8) | ((dev->sector_pos >> 8) << 16) | ( dev->sector_pos << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); } static void -zip_write_error(zip_t *dev) +rdisk_write_error(rdisk_t *dev) { - zip_sense_key = SENSE_MEDIUM_ERROR; - zip_asc = ASC_WRITE_ERROR; - zip_ascq = 0; - zip_info = (dev->sector_pos >> 24) | + rdisk_sense_key = SENSE_MEDIUM_ERROR; + rdisk_asc = ASC_WRITE_ERROR; + rdisk_ascq = 0; + rdisk_info = (dev->sector_pos >> 24) | ((dev->sector_pos >> 16) << 8) | ((dev->sector_pos >> 8) << 16) | ( dev->sector_pos << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); } static void -zip_read_error(zip_t *dev) +rdisk_read_error(rdisk_t *dev) { - zip_sense_key = SENSE_MEDIUM_ERROR; - zip_asc = ASC_UNRECOVERED_READ_ERROR; - zip_ascq = 0; - zip_info = (dev->sector_pos >> 24) | + rdisk_sense_key = SENSE_MEDIUM_ERROR; + rdisk_asc = ASC_UNRECOVERED_READ_ERROR; + rdisk_ascq = 0; + rdisk_info = (dev->sector_pos >> 24) | ((dev->sector_pos >> 16) << 8) | ((dev->sector_pos >> 8) << 16) | ( dev->sector_pos << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); } static void -zip_invalid_lun(zip_t *dev, const uint8_t lun) +rdisk_invalid_lun(rdisk_t *dev, const uint8_t lun) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_INV_LUN; - zip_ascq = 0; - zip_info = lun << 24; - zip_cmd_error(dev); + rdisk_sense_key = SENSE_ILLEGAL_REQUEST; + rdisk_asc = ASC_INV_LUN; + rdisk_ascq = 0; + rdisk_info = lun << 24; + rdisk_cmd_error(dev); } static void -zip_illegal_opcode(zip_t *dev, const uint8_t opcode) +rdisk_illegal_opcode(rdisk_t *dev, const uint8_t opcode) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_ILLEGAL_OPCODE; - zip_ascq = 0; - zip_info = opcode << 24; - zip_cmd_error(dev); + rdisk_sense_key = SENSE_ILLEGAL_REQUEST; + rdisk_asc = ASC_ILLEGAL_OPCODE; + rdisk_ascq = 0; + rdisk_info = opcode << 24; + rdisk_cmd_error(dev); } static void -zip_lba_out_of_range(zip_t *dev) +rdisk_lba_out_of_range(rdisk_t *dev) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_LBA_OUT_OF_RANGE; - zip_ascq = 0; - zip_info = (dev->sector_pos >> 24) | + rdisk_sense_key = SENSE_ILLEGAL_REQUEST; + rdisk_asc = ASC_LBA_OUT_OF_RANGE; + rdisk_ascq = 0; + rdisk_info = (dev->sector_pos >> 24) | ((dev->sector_pos >> 16) << 8) | ((dev->sector_pos >> 8) << 16) | ( dev->sector_pos << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); } static void -zip_invalid_field(zip_t *dev, const uint32_t field) +rdisk_invalid_field(rdisk_t *dev, const uint32_t field) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_INV_FIELD_IN_CMD_PACKET; - zip_ascq = 0; - zip_info = (field >> 24) | + rdisk_sense_key = SENSE_ILLEGAL_REQUEST; + rdisk_asc = ASC_INV_FIELD_IN_CMD_PACKET; + rdisk_ascq = 0; + rdisk_info = (field >> 24) | ((field >> 16) << 8) | ((field >> 8) << 16) | ( field << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); dev->tf->status = 0x53; } static void -zip_invalid_field_pl(zip_t *dev, const uint32_t field) +rdisk_invalid_field_pl(rdisk_t *dev, const uint32_t field) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_INV_FIELD_IN_PARAMETER_LIST; - zip_ascq = 0; - zip_info = (field >> 24) | + rdisk_sense_key = SENSE_ILLEGAL_REQUEST; + rdisk_asc = ASC_INV_FIELD_IN_PARAMETER_LIST; + rdisk_ascq = 0; + rdisk_info = (field >> 24) | ((field >> 16) << 8) | ((field >> 8) << 16) | ( field << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); dev->tf->status = 0x53; } static void -zip_data_phase_error(zip_t *dev, const uint32_t info) +rdisk_data_phase_error(rdisk_t *dev, const uint32_t info) { - zip_sense_key = SENSE_ILLEGAL_REQUEST; - zip_asc = ASC_DATA_PHASE_ERROR; - zip_ascq = 0; - zip_info = (info >> 24) | + rdisk_sense_key = SENSE_ILLEGAL_REQUEST; + rdisk_asc = ASC_DATA_PHASE_ERROR; + rdisk_ascq = 0; + rdisk_info = (info >> 24) | ((info >> 16) << 8) | ((info >> 8) << 16) | ( info << 24); - zip_cmd_error(dev); + rdisk_cmd_error(dev); } static int -zip_blocks(zip_t *dev, int32_t *len, const int out) +rdisk_blocks(rdisk_t *dev, int32_t *len, const int out) { int ret = 1; *len = 0; if (dev->sector_len > 0) { - zip_log(dev->log, "%sing %i blocks starting from %i...\n", out ? "Writ" : "Read", + rdisk_log(dev->log, "%sing %i blocks starting from %i...\n", out ? "Writ" : "Read", dev->requested_blocks, dev->sector_pos); if (dev->sector_pos >= dev->drv->medium_size) { - zip_log(dev->log, "Trying to %s beyond the end of disk\n", + rdisk_log(dev->log, "Trying to %s beyond the end of disk\n", out ? "write" : "read"); - zip_lba_out_of_range(dev); + rdisk_lba_out_of_range(dev); ret = 0; } else { *len = dev->requested_blocks << 9; @@ -918,9 +920,9 @@ zip_blocks(zip_t *dev, int32_t *len, const int out) if (fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos << 9), SEEK_SET) == -1) { if (out) - zip_write_error(dev); + rdisk_write_error(dev); else - zip_read_error(dev); + rdisk_read_error(dev); ret = -1; } else { if (feof(dev->drv->fp)) @@ -929,15 +931,15 @@ zip_blocks(zip_t *dev, int32_t *len, const int out) if (out) { if (fwrite(dev->buffer + (i << 9), 1, 512, dev->drv->fp) != 512) { - zip_log(dev->log, "zip_blocks(): Error writing data\n"); - zip_write_error(dev); + rdisk_log(dev->log, "rdisk_blocks(): Error writing data\n"); + rdisk_write_error(dev); ret = -1; } else fflush(dev->drv->fp); } else if (fread(dev->buffer + (i << 9), 1, 512, dev->drv->fp) != 512) { - zip_log(dev->log, "zip_blocks(): Error reading data\n"); - zip_read_error(dev); + rdisk_log(dev->log, "rdisk_blocks(): Error reading data\n"); + rdisk_read_error(dev); ret = -1; } } @@ -949,14 +951,14 @@ zip_blocks(zip_t *dev, int32_t *len, const int out) } if (ret == 1) { - zip_log(dev->log, "%s %i bytes of blocks...\n", out ? "Written" : + rdisk_log(dev->log, "%s %i bytes of blocks...\n", out ? "Written" : "Read", *len); dev->sector_len -= dev->requested_blocks; } } } else { - zip_command_complete(dev); + rdisk_command_complete(dev); ret = 0; } @@ -964,61 +966,61 @@ zip_blocks(zip_t *dev, int32_t *len, const int out) } void -zip_insert(zip_t *dev) +rdisk_insert(rdisk_t *dev) { if ((dev != NULL) && (dev->drv != NULL)) { if (dev->drv->fp == NULL) { dev->unit_attention = 0; dev->transition = 0; - zip_log(dev->log, "Media removal\n"); + rdisk_log(dev->log, "Media removal\n"); } else if (dev->transition) { dev->unit_attention = 1; /* Turn off the medium changed status. */ dev->transition = 0; - zip_log(dev->log, "Media insert\n"); + rdisk_log(dev->log, "Media insert\n"); } else { dev->unit_attention = 0; dev->transition = 1; - zip_log(dev->log, "Media transition\n"); + rdisk_log(dev->log, "Media transition\n"); } } } static int -zip_pre_execution_check(zip_t *dev, const uint8_t *cdb) +rdisk_pre_execution_check(rdisk_t *dev, const uint8_t *cdb) { int ready; if ((cdb[0] != GPCMD_REQUEST_SENSE) && (dev->cur_lun == SCSI_LUN_USE_CDB) && (cdb[1] & 0xe0)) { - zip_log(dev->log, "Attempting to execute a unknown command targeted at SCSI LUN %i\n", + rdisk_log(dev->log, "Attempting to execute a unknown command targeted at SCSI LUN %i\n", ((dev->tf->request_length >> 5) & 7)); - zip_invalid_lun(dev, cdb[1] >> 5); + rdisk_invalid_lun(dev, cdb[1] >> 5); return 0; } - if (!(zip_command_flags[cdb[0]] & IMPLEMENTED)) { - zip_log(dev->log, "Attempting to execute unknown command %02X over %s\n", - cdb[0], (dev->drv->bus_type == ZIP_BUS_SCSI) ? + if (!(rdisk_command_flags[cdb[0]] & IMPLEMENTED)) { + rdisk_log(dev->log, "Attempting to execute unknown command %02X over %s\n", + cdb[0], (dev->drv->bus_type == RDISK_BUS_SCSI) ? "SCSI" : "ATAPI"); - zip_illegal_opcode(dev, cdb[0]); + rdisk_illegal_opcode(dev, cdb[0]); return 0; } - if ((dev->drv->bus_type < ZIP_BUS_SCSI) && - (zip_command_flags[cdb[0]] & SCSI_ONLY)) { - zip_log(dev->log, "Attempting to execute SCSI-only command %02X " + if ((dev->drv->bus_type < RDISK_BUS_SCSI) && + (rdisk_command_flags[cdb[0]] & SCSI_ONLY)) { + rdisk_log(dev->log, "Attempting to execute SCSI-only command %02X " "over ATAPI\n", cdb[0]); - zip_illegal_opcode(dev, cdb[0]); + rdisk_illegal_opcode(dev, cdb[0]); return 0; } - if ((dev->drv->bus_type == ZIP_BUS_SCSI) && - (zip_command_flags[cdb[0]] & ATAPI_ONLY)) { - zip_log(dev->log, "Attempting to execute ATAPI-only command %02X " + if ((dev->drv->bus_type == RDISK_BUS_SCSI) && + (rdisk_command_flags[cdb[0]] & ATAPI_ONLY)) { + rdisk_log(dev->log, "Attempting to execute ATAPI-only command %02X " "over SCSI\n", cdb[0]); - zip_illegal_opcode(dev, cdb[0]); + rdisk_illegal_opcode(dev, cdb[0]); return 0; } @@ -1026,9 +1028,9 @@ zip_pre_execution_check(zip_t *dev, const uint8_t *cdb) if ((cdb[0] == GPCMD_TEST_UNIT_READY) || (cdb[0] == GPCMD_REQUEST_SENSE)) ready = 0; else { - if (!(zip_command_flags[cdb[0]] & ALLOW_UA)) { - zip_log(dev->log, "(ext_medium_changed != 0): zip_insert()\n"); - zip_insert((void *) dev); + if (!(rdisk_command_flags[cdb[0]] & ALLOW_UA)) { + rdisk_log(dev->log, "(ext_medium_changed != 0): rdisk_insert()\n"); + rdisk_insert((void *) dev); } ready = (dev->drv->fp != NULL); @@ -1053,17 +1055,17 @@ zip_pre_execution_check(zip_t *dev, const uint8_t *cdb) Only increment the unit attention phase if the command can not pass through it. */ - if (!(zip_command_flags[cdb[0]] & ALLOW_UA)) { - zip_log(dev->log, "Unit attention now 2\n"); + if (!(rdisk_command_flags[cdb[0]] & ALLOW_UA)) { + rdisk_log(dev->log, "Unit attention now 2\n"); dev->unit_attention++; - zip_log(dev->log, "UNIT ATTENTION: Command %02X not allowed to pass through\n", + rdisk_log(dev->log, "UNIT ATTENTION: Command %02X not allowed to pass through\n", cdb[0]); - zip_unit_attention(dev); + rdisk_unit_attention(dev); return 0; } } else if (dev->unit_attention == 2) { if (cdb[0] != GPCMD_REQUEST_SENSE) { - zip_log(dev->log, "Unit attention now 0\n"); + rdisk_log(dev->log, "Unit attention now 0\n"); dev->unit_attention = 0; } } @@ -1073,51 +1075,51 @@ zip_pre_execution_check(zip_t *dev, const uint8_t *cdb) the UNIT ATTENTION condition if it's set. */ if (cdb[0] != GPCMD_REQUEST_SENSE) - zip_sense_clear(dev, cdb[0]); + rdisk_sense_clear(dev, cdb[0]); - if (!ready && (zip_command_flags[cdb[0]] & CHECK_READY)) { - zip_log(dev->log, "Not ready (%02X)\n", cdb[0]); - zip_not_ready(dev); + if (!ready && (rdisk_command_flags[cdb[0]] & CHECK_READY)) { + rdisk_log(dev->log, "Not ready (%02X)\n", cdb[0]); + rdisk_not_ready(dev); return 0; } - zip_log(dev->log, "Continuing with command %02X\n", cdb[0]); + rdisk_log(dev->log, "Continuing with command %02X\n", cdb[0]); return 1; } static void -zip_seek(zip_t *dev, const uint32_t pos) +rdisk_seek(rdisk_t *dev, const uint32_t pos) { dev->sector_pos = pos; } static void -zip_rezero(zip_t *dev) +rdisk_rezero(rdisk_t *dev) { dev->sector_pos = dev->sector_len = 0; - zip_seek(dev, 0); + rdisk_seek(dev, 0); } void -zip_reset(scsi_common_t *sc) +rdisk_reset(scsi_common_t *sc) { - zip_t *dev = (zip_t *) sc; + rdisk_t *dev = (rdisk_t *) sc; - zip_rezero(dev); + rdisk_rezero(dev); dev->tf->status = 0; dev->callback = 0.0; - zip_set_callback(dev); + rdisk_set_callback(dev); dev->tf->phase = 1; dev->tf->request_length = 0xEB14; dev->packet_status = PHASE_NONE; dev->unit_attention = 0; dev->cur_lun = SCSI_LUN_USE_CDB; - zip_sense_key = zip_asc = zip_ascq = dev->unit_attention = dev->transition = 0; - zip_info = 0x00000000; + rdisk_sense_key = rdisk_asc = rdisk_ascq = dev->unit_attention = dev->transition = 0; + rdisk_info = 0x00000000; } static void -zip_request_sense(zip_t *dev, uint8_t *buffer, const uint8_t alloc_length, const int desc) +rdisk_request_sense(rdisk_t *dev, uint8_t *buffer, const uint8_t alloc_length, const int desc) { /*Will return 18 bytes of 0*/ if (alloc_length != 0) { @@ -1125,9 +1127,9 @@ zip_request_sense(zip_t *dev, uint8_t *buffer, const uint8_t alloc_length, const if (!desc) memcpy(buffer, dev->sense, alloc_length); else { - buffer[1] = zip_sense_key; - buffer[2] = zip_asc; - buffer[3] = zip_ascq; + buffer[1] = rdisk_sense_key; + buffer[2] = rdisk_asc; + buffer[3] = rdisk_ascq; } } @@ -1135,13 +1137,13 @@ zip_request_sense(zip_t *dev, uint8_t *buffer, const uint8_t alloc_length, const if (!desc) buffer[7] = 10; - if (dev->unit_attention && (zip_sense_key == 0)) { + if (dev->unit_attention && (rdisk_sense_key == 0)) { buffer[desc ? 1 : 2] = SENSE_UNIT_ATTENTION; buffer[desc ? 2 : 12] = ASC_MEDIUM_MAY_HAVE_CHANGED; buffer[desc ? 3 : 13] = 0; } - zip_log(dev->log, "Reporting sense: %02X %02X %02X\n", buffer[2], + rdisk_log(dev->log, "Reporting sense: %02X %02X %02X\n", buffer[2], buffer[12], buffer[13]); if (buffer[desc ? 1 : 2] == SENSE_UNIT_ATTENTION) { @@ -1151,18 +1153,18 @@ zip_request_sense(zip_t *dev, uint8_t *buffer, const uint8_t alloc_length, const } /* Clear the sense stuff as per the spec. */ - zip_sense_clear(dev, GPCMD_REQUEST_SENSE); + rdisk_sense_clear(dev, GPCMD_REQUEST_SENSE); if (dev->transition) { - zip_log(dev->log, "ZIP_TRANSITION: zip_insert()\n"); - zip_insert((void *) dev); + rdisk_log(dev->log, "Removable Disk_TRANSITION: rdisk_insert()\n"); + rdisk_insert((void *) dev); } } static void -zip_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, const uint8_t alloc_length) +rdisk_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, const uint8_t alloc_length) { - zip_t *dev = (zip_t *) sc; + rdisk_t *dev = (rdisk_t *) sc; const int ready = (dev->drv->fp != NULL); if (!ready && dev->unit_attention) { @@ -1174,32 +1176,33 @@ zip_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, const uint8_t all } /* Do *NOT* advance the unit attention phase. */ - zip_request_sense(dev, buffer, alloc_length, 0); + rdisk_request_sense(dev, buffer, alloc_length, 0); } static void -zip_set_buf_len(const zip_t *dev, int32_t *BufLen, int32_t *src_len) +rdisk_set_buf_len(const rdisk_t *dev, int32_t *BufLen, int32_t *src_len) { - if (dev->drv->bus_type == ZIP_BUS_SCSI) { + if (dev->drv->bus_type == RDISK_BUS_SCSI) { if (*BufLen == -1) *BufLen = *src_len; else { *BufLen = MIN(*src_len, *BufLen); *src_len = *BufLen; } - zip_log(dev->log, "Actual transfer length: %i\n", *BufLen); + rdisk_log(dev->log, "Actual transfer length: %i\n", *BufLen); } } static void -zip_command(scsi_common_t *sc, const uint8_t *cdb) +rdisk_command(scsi_common_t *sc, const uint8_t *cdb) { - zip_t *dev = (zip_t *) sc; - const uint8_t scsi_bus = (dev->drv->scsi_device_id >> 4) & 0x0f; - const uint8_t scsi_id = dev->drv->scsi_device_id & 0x0f; - int pos = 0; - int idx = 0; - int32_t blen = 0; + rdisk_t *dev = (rdisk_t *) sc; + char device_identify[9] = { '8', '6', 'B', '_', 'R', 'D', '0', '0', 0 }; + const uint8_t scsi_bus = (dev->drv->scsi_device_id >> 4) & 0x0f; + const uint8_t scsi_id = dev->drv->scsi_device_id & 0x0f; + int pos = 0; + int idx = 0; + int32_t blen = 0; uint32_t i; unsigned preamble_len; int32_t len; @@ -1209,7 +1212,7 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) int size_idx; int32_t * BufLen; - if (dev->drv->bus_type == ZIP_BUS_SCSI) { + if (dev->drv->bus_type == RDISK_BUS_SCSI) { BufLen = &scsi_devices[scsi_bus][scsi_id].buffer_length; dev->tf->status &= ~ERR_STAT; } else { @@ -1220,15 +1223,17 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) dev->packet_len = 0; dev->request_pos = 0; + device_identify[7] = dev->id + 0x30; + memcpy(dev->current_cdb, cdb, 12); if (cdb[0] != 0) { - zip_log(dev->log, "Command 0x%02X, Sense Key %02X, Asc %02X, Ascq %02X, " + rdisk_log(dev->log, "Command 0x%02X, Sense Key %02X, Asc %02X, Ascq %02X, " "Unit attention: %i\n", - cdb[0], zip_sense_key, zip_asc, zip_ascq, dev->unit_attention); - zip_log(dev->log, "Request length: %04X\n", dev->tf->request_length); + cdb[0], rdisk_sense_key, rdisk_asc, rdisk_ascq, dev->unit_attention); + rdisk_log(dev->log, "Request length: %04X\n", dev->tf->request_length); - zip_log(dev->log, "CDB: %02X %02X %02X %02X %02X %02X %02X %02X " + rdisk_log(dev->log, "CDB: %02X %02X %02X %02X %02X %02X %02X %02X " "%02X %02X %02X %02X\n", cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], cdb[8], cdb[9], cdb[10], cdb[11]); @@ -1236,43 +1241,43 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) dev->sector_len = 0; - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); /* This handles the Not Ready/Unit Attention check if it has to be handled at this point. */ - if (zip_pre_execution_check(dev, cdb) == 0) + if (rdisk_pre_execution_check(dev, cdb) == 0) return; switch (cdb[0]) { case GPCMD_SEND_DIAGNOSTIC: if (!(cdb[1] & (1 << 2))) { - zip_invalid_field(dev, cdb[1]); + rdisk_invalid_field(dev, cdb[1]); return; } fallthrough; case GPCMD_SCSI_RESERVE: case GPCMD_SCSI_RELEASE: case GPCMD_TEST_UNIT_READY: - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_command_complete(dev); break; case GPCMD_FORMAT_UNIT: if (dev->drv->read_only) - zip_write_protected(dev); + rdisk_write_protected(dev); else { - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_command_complete(dev); } break; case GPCMD_IOMEGA_SENSE: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); max_len = cdb[4]; - zip_buf_alloc(dev, 256); - zip_set_buf_len(dev, BufLen, &max_len); + rdisk_buf_alloc(dev, 256); + rdisk_set_buf_len(dev, BufLen, &max_len); memset(dev->buffer, 0, 256); if (cdb[2] == 1) { /* @@ -1294,17 +1299,17 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) for (i = 0x00; i < 0x27; i++) dev->buffer[i + 0x16] = 0x00; } else { - zip_invalid_field(dev, cdb[2]); - zip_buf_free(dev); + rdisk_invalid_field(dev, cdb[2]); + rdisk_buf_free(dev); return; } - zip_data_command_finish(dev, 18, 18, cdb[4], 0); + rdisk_data_command_finish(dev, 18, 18, cdb[4], 0); break; case GPCMD_REZERO_UNIT: dev->sector_pos = dev->sector_len = 0; - zip_seek(dev, 0); - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_seek(dev, 0); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); break; case GPCMD_REQUEST_SENSE: @@ -1313,41 +1318,41 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) standalone REQUEST SENSE should forget about the not ready, and report unit attention straight away. */ - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); max_len = cdb[4]; if (!max_len) { - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); dev->packet_status = PHASE_COMPLETE; - dev->callback = 20.0 * ZIP_TIME; - zip_set_callback(dev); + dev->callback = 20.0 * RDISK_TIME; + rdisk_set_callback(dev); break; } - zip_buf_alloc(dev, 256); - zip_set_buf_len(dev, BufLen, &max_len); + rdisk_buf_alloc(dev, 256); + rdisk_set_buf_len(dev, BufLen, &max_len); len = (cdb[1] & 1) ? 8 : 18; - zip_request_sense(dev, dev->buffer, max_len, cdb[1] & 1); - zip_data_command_finish(dev, len, len, cdb[4], 0); + rdisk_request_sense(dev, dev->buffer, max_len, cdb[1] & 1); + rdisk_data_command_finish(dev, len, len, cdb[4], 0); break; case GPCMD_MECHANISM_STATUS: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); len = (cdb[8] << 8) | cdb[9]; - zip_buf_alloc(dev, 8); - zip_set_buf_len(dev, BufLen, &len); + rdisk_buf_alloc(dev, 8); + rdisk_set_buf_len(dev, BufLen, &len); memset(dev->buffer, 0, 8); dev->buffer[5] = 1; - zip_data_command_finish(dev, 8, 8, len, 0); + rdisk_data_command_finish(dev, 8, 8, len, 0); break; case GPCMD_READ_6: case GPCMD_READ_10: case GPCMD_READ_12: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); alloc_length = 512; switch (cdb[0]) { @@ -1361,13 +1366,13 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) dev->sector_len = 256; dev->sector_pos = ((((uint32_t) cdb[1]) & 0x1f) << 16) | (((uint32_t) cdb[2]) << 8) | ((uint32_t) cdb[3]); - zip_log(dev->log, "Length: %i, LBA: %i\n", dev->sector_len, dev->sector_pos); + rdisk_log(dev->log, "Length: %i, LBA: %i\n", dev->sector_len, dev->sector_pos); break; case GPCMD_READ_10: dev->sector_len = (cdb[7] << 8) | cdb[8]; dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; - zip_log(dev->log, "Length: %i, LBA: %i\n", dev->sector_len, dev->sector_pos); + rdisk_log(dev->log, "Length: %i, LBA: %i\n", dev->sector_len, dev->sector_pos); break; case GPCMD_READ_12: dev->sector_len = (((uint32_t) cdb[6]) << 24) | @@ -1383,41 +1388,41 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) } if (dev->sector_pos >= dev->drv->medium_size) - zip_lba_out_of_range(dev); + rdisk_lba_out_of_range(dev); else if (dev->sector_len) { max_len = dev->sector_len; dev->requested_blocks = max_len; dev->packet_len = max_len * alloc_length; - zip_buf_alloc(dev, dev->packet_len); + rdisk_buf_alloc(dev, dev->packet_len); - const int ret = zip_blocks(dev, &alloc_length, 0); + const int ret = rdisk_blocks(dev, &alloc_length, 0); alloc_length = dev->requested_blocks * 512; if (ret > 0) { dev->requested_blocks = max_len; dev->packet_len = alloc_length; - zip_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); + rdisk_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); - zip_data_command_finish(dev, alloc_length, 512, + rdisk_data_command_finish(dev, alloc_length, 512, alloc_length, 0); - ui_sb_update_icon(SB_ZIP | dev->id, + ui_sb_update_icon(SB_RDISK | dev->id, dev->packet_status != PHASE_COMPLETE); } else { - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); dev->packet_status = (ret < 0) ? PHASE_ERROR : PHASE_COMPLETE; - dev->callback = 20.0 * ZIP_TIME; - zip_set_callback(dev); - zip_buf_free(dev); + dev->callback = 20.0 * RDISK_TIME; + rdisk_set_callback(dev); + rdisk_buf_free(dev); } } else { - zip_set_phase(dev, SCSI_PHASE_STATUS); - /* zip_log(dev->log, "All done - callback set\n"); */ + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + /* rdisk_log(dev->log, "All done - callback set\n"); */ dev->packet_status = PHASE_COMPLETE; - dev->callback = 20.0 * ZIP_TIME; - zip_set_callback(dev); + dev->callback = 20.0 * RDISK_TIME; + rdisk_set_callback(dev); break; } break; @@ -1426,8 +1431,8 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) case GPCMD_VERIFY_10: case GPCMD_VERIFY_12: if (!(cdb[1] & 2)) { - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_command_complete(dev); break; } fallthrough; @@ -1436,11 +1441,11 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) case GPCMD_WRITE_AND_VERIFY_10: case GPCMD_WRITE_12: case GPCMD_WRITE_AND_VERIFY_12: - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + rdisk_set_phase(dev, SCSI_PHASE_DATA_OUT); alloc_length = 512; if (dev->drv->read_only) { - zip_write_protected(dev); + rdisk_write_protected(dev); break; } @@ -1463,7 +1468,7 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) dev->sector_len = (cdb[7] << 8) | cdb[8]; dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; - zip_log(dev->log, "Length: %i, LBA: %i\n", + rdisk_log(dev->log, "Length: %i, LBA: %i\n", dev->sector_len, dev->sector_pos); break; case GPCMD_VERIFY_12: @@ -1482,71 +1487,71 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) } if (dev->sector_pos >= dev->drv->medium_size) - zip_lba_out_of_range(dev); + rdisk_lba_out_of_range(dev); if (dev->sector_len) { max_len = dev->sector_len; dev->requested_blocks = max_len; dev->packet_len = max_len * alloc_length; - zip_buf_alloc(dev, dev->packet_len); + rdisk_buf_alloc(dev, dev->packet_len); dev->requested_blocks = max_len; dev->packet_len = max_len << 9; - zip_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); + rdisk_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); - zip_data_command_finish(dev, dev->packet_len, 512, + rdisk_data_command_finish(dev, dev->packet_len, 512, dev->packet_len, 1); - ui_sb_update_icon_write(SB_ZIP | dev->id, + ui_sb_update_icon_write(SB_RDISK | dev->id, dev->packet_status != PHASE_COMPLETE); } else { - zip_set_phase(dev, SCSI_PHASE_STATUS); - /* zip_log(dev->log, "All done - callback set\n"); */ + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + /* rdisk_log(dev->log, "All done - callback set\n"); */ dev->packet_status = PHASE_COMPLETE; - dev->callback = 20.0 * ZIP_TIME; - zip_set_callback(dev); + dev->callback = 20.0 * RDISK_TIME; + rdisk_set_callback(dev); } break; case GPCMD_WRITE_SAME_10: - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + rdisk_set_phase(dev, SCSI_PHASE_DATA_OUT); alloc_length = 512; if ((cdb[1] & 6) == 6) - zip_invalid_field(dev, cdb[1]); + rdisk_invalid_field(dev, cdb[1]); else { if (dev->drv->read_only) - zip_write_protected(dev); + rdisk_write_protected(dev); else { dev->sector_len = (cdb[7] << 8) | cdb[8]; dev->sector_pos = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; if (dev->sector_pos >= dev->drv->medium_size) - zip_lba_out_of_range(dev); + rdisk_lba_out_of_range(dev); else if (dev->sector_len) { - zip_buf_alloc(dev, alloc_length); - zip_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); + rdisk_buf_alloc(dev, alloc_length); + rdisk_set_buf_len(dev, BufLen, (int32_t *) &dev->packet_len); max_len = 1; dev->requested_blocks = 1; dev->packet_len = alloc_length; - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + rdisk_set_phase(dev, SCSI_PHASE_DATA_OUT); - zip_data_command_finish(dev, 512, 512, + rdisk_data_command_finish(dev, 512, 512, alloc_length, 1); - ui_sb_update_icon_write(SB_ZIP | dev->id, + ui_sb_update_icon_write(SB_RDISK | dev->id, dev->packet_status != PHASE_COMPLETE); } else { - zip_set_phase(dev, SCSI_PHASE_STATUS); - /* zip_log(dev->log, "All done - callback set\n"); */ + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + /* rdisk_log(dev->log, "All done - callback set\n"); */ dev->packet_status = PHASE_COMPLETE; - dev->callback = 20.0 * ZIP_TIME; - zip_set_callback(dev); + dev->callback = 20.0 * RDISK_TIME; + rdisk_set_callback(dev); } } } @@ -1554,19 +1559,19 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) case GPCMD_MODE_SENSE_6: case GPCMD_MODE_SENSE_10: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); - if (dev->drv->bus_type == ZIP_BUS_SCSI) + if (dev->drv->bus_type == RDISK_BUS_SCSI) block_desc = ((cdb[1] >> 3) & 1) ? 0 : 1; else block_desc = 0; if (cdb[0] == GPCMD_MODE_SENSE_6) { len = cdb[4]; - zip_buf_alloc(dev, 256); + rdisk_buf_alloc(dev, 256); } else { len = (cdb[8] | (cdb[7] << 8)); - zip_buf_alloc(dev, 65536); + rdisk_buf_alloc(dev, 65536); } if (zip_mode_sense_page_flags & (1LL << (uint64_t) (cdb[2] & 0x3f))) { @@ -1574,16 +1579,16 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) alloc_length = len; if (cdb[0] == GPCMD_MODE_SENSE_6) { - len = zip_mode_sense(dev, dev->buffer, 4, cdb[2], - block_desc); + len = rdisk_mode_sense(dev, dev->buffer, 4, cdb[2], + block_desc); len = MIN(len, alloc_length); dev->buffer[0] = len - 1; dev->buffer[1] = 0; if (block_desc) dev->buffer[3] = 8; } else { - len = zip_mode_sense(dev, dev->buffer, 8, cdb[2], - block_desc); + len = rdisk_mode_sense(dev, dev->buffer, 8, cdb[2], + block_desc); len = MIN(len, alloc_length); dev->buffer[0] = (len - 2) >> 8; dev->buffer[1] = (len - 2) & 255; @@ -1594,70 +1599,70 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) } } - zip_set_buf_len(dev, BufLen, &len); + rdisk_set_buf_len(dev, BufLen, &len); - zip_log(dev->log, "Reading mode page: %02X...\n", cdb[2]); + rdisk_log(dev->log, "Reading mode page: %02X...\n", cdb[2]); - zip_data_command_finish(dev, len, len, alloc_length, 0); + rdisk_data_command_finish(dev, len, len, alloc_length, 0); } else { - zip_invalid_field(dev, cdb[2]); - zip_buf_free(dev); + rdisk_invalid_field(dev, cdb[2]); + rdisk_buf_free(dev); } break; case GPCMD_MODE_SELECT_6: case GPCMD_MODE_SELECT_10: - zip_set_phase(dev, SCSI_PHASE_DATA_OUT); + rdisk_set_phase(dev, SCSI_PHASE_DATA_OUT); if (cdb[0] == GPCMD_MODE_SELECT_6) { len = cdb[4]; - zip_buf_alloc(dev, 256); + rdisk_buf_alloc(dev, 256); } else { len = (cdb[7] << 8) | cdb[8]; - zip_buf_alloc(dev, 65536); + rdisk_buf_alloc(dev, 65536); } - zip_set_buf_len(dev, BufLen, &len); + rdisk_set_buf_len(dev, BufLen, &len); dev->total_length = len; dev->do_page_save = cdb[1] & 1; - zip_data_command_finish(dev, len, len, len, 1); + rdisk_data_command_finish(dev, len, len, len, 1); return; case GPCMD_START_STOP_UNIT: - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); switch (cdb[4] & 3) { case 0: /* Stop the disc. */ - zip_eject(dev->id); /* The Iomega Windows 9x drivers require this. */ + rdisk_eject(dev->id); /* The Iomega Windows 9x drivers require this. */ break; case 1: /* Start the disc and read the TOC. */ break; case 2: /* Eject the disc if possible. */ #if 0 - zip_eject(dev->id); + rdisk_eject(dev->id); #endif break; case 3: /* Load the disc (close tray). */ - zip_reload(dev->id); + rdisk_reload(dev->id); break; default: break; } - zip_command_complete(dev); + rdisk_command_complete(dev); break; case GPCMD_INQUIRY: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); max_len = cdb[3]; max_len <<= 8; max_len |= cdb[4]; - zip_buf_alloc(dev, 65536); + rdisk_buf_alloc(dev, 65536); if (cdb[1] & 1) { preamble_len = 4; @@ -1676,8 +1681,8 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) break; case 0x83: if (idx + 24 > max_len) { - zip_data_phase_error(dev, cdb[2]); - zip_buf_free(dev); + rdisk_data_phase_error(dev, cdb[2]); + rdisk_buf_free(dev); return; } @@ -1695,21 +1700,26 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) dev->buffer[idx++] = 0x00; dev->buffer[idx++] = 68; /* Vendor */ - ide_padstr8(dev->buffer + idx, 8, "IOMEGA "); + if (dev->drv->type >= RDISK_TYPE_ZIP_100) + ide_padstr8(dev->buffer + idx, 8, "IOMEGA "); + else + ide_padstr8(dev->buffer + 8, 8, EMU_NAME); /* Vendor */ idx += 8; /* Product */ - if (dev->drv->is_250) + if (dev->drv->type == RDISK_TYPE_ZIP_250) ide_padstr8(dev->buffer + idx, 40, "ZIP 250 "); - else + else if (dev->drv->type == RDISK_TYPE_ZIP_100) ide_padstr8(dev->buffer + idx, 40, "ZIP 100 "); + else + ide_padstr8(dev->buffer + 16, 40, device_identify); /* Product */ idx += 40; ide_padstr8(dev->buffer + idx, 20, "53R141"); idx += 20; break; default: - zip_log(dev->log, "INQUIRY: Invalid page: %02X\n", cdb[2]); - zip_invalid_field(dev, cdb[2]); - zip_buf_free(dev); + rdisk_log(dev->log, "INQUIRY: Invalid page: %02X\n", cdb[2]); + rdisk_invalid_field(dev, cdb[2]); + rdisk_buf_free(dev); return; } } else { @@ -1723,20 +1733,20 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) dev->buffer[0] = 0x00; /* Hard disk */ dev->buffer[1] = 0x80; /* Removable */ /* SCSI-2 compliant */ - dev->buffer[2] = (dev->drv->bus_type == ZIP_BUS_SCSI) ? 0x02 : 0x00; - dev->buffer[3] = (dev->drv->bus_type == ZIP_BUS_SCSI) ? 0x02 : 0x21; + dev->buffer[2] = (dev->drv->bus_type == RDISK_BUS_SCSI) ? 0x02 : 0x00; + dev->buffer[3] = (dev->drv->bus_type == RDISK_BUS_SCSI) ? 0x02 : 0x21; #if 0 dev->buffer[4] = 31; #endif dev->buffer[4] = 0; - if (dev->drv->bus_type == ZIP_BUS_SCSI) { + if (dev->drv->bus_type == RDISK_BUS_SCSI) { dev->buffer[6] = 1; /* 16-bit transfers supported */ dev->buffer[7] = 0x20; /* Wide bus supported */ } dev->buffer[7] |= 0x02; ide_padstr8(dev->buffer + 8, 8, "IOMEGA "); /* Vendor */ - if (dev->drv->is_250) { + if (dev->drv->type == RDISK_TYPE_ZIP_250) { /* Product */ ide_padstr8(dev->buffer + 16, 16, "ZIP 250 "); /* Revision */ @@ -1746,11 +1756,18 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb) ide_padstr8(dev->buffer + 36, 8, "08/08/01"); if (max_len >= 122) ide_padstr8(dev->buffer + 96, 26, "(c) Copyright IOMEGA 2000 "); /* Copyright string */ - } else { + } else if (dev->drv->type == RDISK_TYPE_ZIP_100) { /* Product */ ide_padstr8(dev->buffer + 16, 16, "ZIP 100 "); /* Revision */ ide_padstr8(dev->buffer + 32, 4, "E.08"); + } else { + ide_padstr8(dev->buffer + 8, 8, + EMU_NAME); /* Vendor */ + ide_padstr8(dev->buffer + 16, 16, + device_identify); /* Product */ + ide_padstr8(dev->buffer + 32, 4, + EMU_VERSION_EX); /* Revision */ } idx = 36; @@ -1768,19 +1785,19 @@ atapi_out: len = idx; len = MIN(len, max_len); - zip_set_buf_len(dev, BufLen, &len); + rdisk_set_buf_len(dev, BufLen, &len); - zip_data_command_finish(dev, len, len, max_len, 0); + rdisk_data_command_finish(dev, len, len, max_len, 0); break; case GPCMD_PREVENT_REMOVAL: - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_command_complete(dev); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_command_complete(dev); break; case GPCMD_SEEK_6: case GPCMD_SEEK_10: - zip_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); switch (cdb[0]) { case GPCMD_SEEK_6: @@ -1793,14 +1810,14 @@ atapi_out: default: break; } - zip_seek(dev, pos); - zip_command_complete(dev); + rdisk_seek(dev, pos); + rdisk_command_complete(dev); break; case GPCMD_READ_CDROM_CAPACITY: - zip_set_phase(dev, SCSI_PHASE_DATA_IN); + rdisk_set_phase(dev, SCSI_PHASE_DATA_IN); - zip_buf_alloc(dev, 8); + rdisk_buf_alloc(dev, 8); /* IMPORTANT: What's returned is the last LBA block. */ max_len = dev->drv->medium_size - 1; @@ -1812,21 +1829,21 @@ atapi_out: dev->buffer[6] = 2; /* 512 = 0x0200 */ len = 8; - zip_set_buf_len(dev, BufLen, &len); + rdisk_set_buf_len(dev, BufLen, &len); - zip_data_command_finish(dev, len, len, len, 0); + rdisk_data_command_finish(dev, len, len, len, 0); break; case GPCMD_IOMEGA_EJECT: - zip_set_phase(dev, SCSI_PHASE_STATUS); - zip_eject(dev->id); - zip_command_complete(dev); + rdisk_set_phase(dev, SCSI_PHASE_STATUS); + rdisk_eject(dev->id); + rdisk_command_complete(dev); break; case GPCMD_READ_FORMAT_CAPACITIES: len = (cdb[7] << 8) | cdb[8]; - zip_buf_alloc(dev, len); + rdisk_buf_alloc(dev, len); memset(dev->buffer, 0, len); pos = 0; @@ -1841,7 +1858,18 @@ atapi_out: dev->buffer[pos++] = 8; /* Current/Maximum capacity header */ - if (dev->drv->is_250) { + if (dev->drv->type == RDISK_TYPE_ZIP_100) { + /* ZIP 100 only supports ZIP 100 media as well, so we always return + the ZIP 100 size. */ + dev->buffer[pos++] = (ZIP_SECTORS >> 24) & 0xff; + dev->buffer[pos++] = (ZIP_SECTORS >> 16) & 0xff; + dev->buffer[pos++] = (ZIP_SECTORS >> 8) & 0xff; + dev->buffer[pos++] = ZIP_SECTORS & 0xff; + if (dev->drv->fp != NULL) + dev->buffer[pos++] = 2; + else + dev->buffer[pos++] = 3; + } else { /* ZIP 250 also supports ZIP 100 media, so if the medium is inserted, we return the inserted medium's size, otherwise, the ZIP 250 size. */ if (dev->drv->fp != NULL) { @@ -1857,17 +1885,6 @@ atapi_out: dev->buffer[pos++] = ZIP_250_SECTORS & 0xff; dev->buffer[pos++] = 3; /* Maximum medium capacity */ } - } else { - /* ZIP 100 only supports ZIP 100 media as well, so we always return - the ZIP 100 size. */ - dev->buffer[pos++] = (ZIP_SECTORS >> 24) & 0xff; - dev->buffer[pos++] = (ZIP_SECTORS >> 16) & 0xff; - dev->buffer[pos++] = (ZIP_SECTORS >> 8) & 0xff; - dev->buffer[pos++] = ZIP_SECTORS & 0xff; - if (dev->drv->fp != NULL) - dev->buffer[pos++] = 2; - else - dev->buffer[pos++] = 3; } dev->buffer[pos++] = 512 >> 16; @@ -1886,39 +1903,39 @@ atapi_out: dev->buffer[pos++] = 512 & 0xff; } - zip_set_buf_len(dev, BufLen, &len); + rdisk_set_buf_len(dev, BufLen, &len); - zip_data_command_finish(dev, len, len, len, 0); + rdisk_data_command_finish(dev, len, len, len, 0); break; default: - zip_illegal_opcode(dev, cdb[0]); + rdisk_illegal_opcode(dev, cdb[0]); break; } #if 0 - zip_log(dev->log, "Phase: %02X, request length: %i\n", + rdisk_log(dev->log, "Phase: %02X, request length: %i\n", dev->tf->phase, dev->tf->request_length); #endif if ((dev->packet_status == PHASE_COMPLETE) || (dev->packet_status == PHASE_ERROR)) - zip_buf_free(dev); + rdisk_buf_free(dev); } static void -zip_command_stop(scsi_common_t *sc) +rdisk_command_stop(scsi_common_t *sc) { - zip_t *dev = (zip_t *) sc; + rdisk_t *dev = (rdisk_t *) sc; - zip_command_complete(dev); - zip_buf_free(dev); + rdisk_command_complete(dev); + rdisk_buf_free(dev); } /* The command second phase function, needed for Mode Select. */ static uint8_t -zip_phase_data_out(scsi_common_t *sc) +rdisk_phase_data_out(scsi_common_t *sc) { - zip_t *dev = (zip_t *) sc; + rdisk_t *dev = (rdisk_t *) sc; int len = 0; uint8_t error = 0; uint32_t last_to_write; @@ -1940,7 +1957,7 @@ zip_phase_data_out(scsi_common_t *sc) case GPCMD_WRITE_12: case GPCMD_WRITE_AND_VERIFY_12: if (dev->requested_blocks > 0) - zip_blocks(dev, &len, 1); + rdisk_blocks(dev, &len, 1); break; case GPCMD_WRITE_SAME_10: if (!dev->current_cdb[7] && !dev->current_cdb[8]) { @@ -1955,7 +1972,7 @@ zip_phase_data_out(scsi_common_t *sc) dev->buffer[2] = (i >> 8) & 0xff; dev->buffer[3] = i & 0xff; } else if (dev->current_cdb[1] & 4) { - /* CHS are 96, 1, 2048 (ZIP 100) and 239, 1, 2048 (ZIP 250) */ + /* CHS are 96, 1, 2048 (RDISK 100) and 239, 1, 2048 (RDISK 250) */ const uint32_t s = (i % 2048); const uint32_t h = ((i - s) / 2048) % 1; const uint32_t c = ((i - s) / 2048) / 1; @@ -1970,9 +1987,9 @@ zip_phase_data_out(scsi_common_t *sc) } if (fseek(dev->drv->fp, dev->drv->base + (i << 9), SEEK_SET) == -1) - log_fatal(dev->log, "zip_phase_data_out(): Error seeking\n"); + log_fatal(dev->log, "rdisk_phase_data_out(): Error seeking\n"); if (fwrite(dev->buffer, 1, 512, dev->drv->fp) != 512) - log_fatal(dev->log, "zip_phase_data_out(): Error writing data\n"); + log_fatal(dev->log, "rdisk_phase_data_out(): Error writing data\n"); } fflush(dev->drv->fp); @@ -1989,7 +2006,7 @@ zip_phase_data_out(scsi_common_t *sc) param_list_len = dev->current_cdb[4]; } - if (dev->drv->bus_type == ZIP_BUS_SCSI) { + if (dev->drv->bus_type == RDISK_BUS_SCSI) { if (dev->current_cdb[0] == GPCMD_MODE_SELECT_6) { block_desc_len = dev->buffer[2]; block_desc_len <<= 8; @@ -2006,7 +2023,7 @@ zip_phase_data_out(scsi_common_t *sc) while (1) { if (pos >= param_list_len) { - zip_log(dev->log, "Buffer has only block descriptor\n"); + rdisk_log(dev->log, "Buffer has only block descriptor\n"); break; } @@ -2026,26 +2043,26 @@ zip_phase_data_out(scsi_common_t *sc) dev->ms_pages_saved.pages[page][i + 2] = val; else { error |= 1; - zip_invalid_field_pl(dev, val); + rdisk_invalid_field_pl(dev, val); } } } pos += page_len; - if (dev->drv->bus_type == ZIP_BUS_SCSI) + if (dev->drv->bus_type == RDISK_BUS_SCSI) val = zip_mode_sense_pages_default_scsi.pages[page][0] & 0x80; else val = zip_mode_sense_pages_default.pages[page][0] & 0x80; if (dev->do_page_save && val) - zip_mode_sense_save(dev); + rdisk_mode_sense_save(dev); if (pos >= dev->total_length) break; } if (error) { - zip_buf_free(dev); + rdisk_buf_free(dev); return 0; } break; @@ -2054,20 +2071,20 @@ zip_phase_data_out(scsi_common_t *sc) break; } - zip_command_stop((scsi_common_t *) dev); + rdisk_command_stop((scsi_common_t *) dev); return 1; } /* Peform a master init on the entire module. */ void -zip_global_init(void) +rdisk_global_init(void) { /* Clear the global data. */ - memset(zip_drives, 0x00, sizeof(zip_drives)); + memset(rdisk_drives, 0x00, sizeof(rdisk_drives)); } static int -zip_get_max(UNUSED(const ide_t *ide), const int ide_has_dma, const int type) +rdisk_get_max(UNUSED(const ide_t *ide), const int ide_has_dma, const int type) { int ret; @@ -2091,7 +2108,7 @@ zip_get_max(UNUSED(const ide_t *ide), const int ide_has_dma, const int type) } static int -zip_get_timings(UNUSED(const ide_t *ide), const int ide_has_dma, const int type) +rdisk_get_timings(UNUSED(const ide_t *ide), const int ide_has_dma, const int type) { int ret; @@ -2114,14 +2131,14 @@ zip_get_timings(UNUSED(const ide_t *ide), const int ide_has_dma, const int type) } static void -zip_100_identify(const ide_t *ide) +rdisk_zip_100_identify(const ide_t *ide) { ide_padstr((char *) (ide->buffer + 23), "E.08", 8); /* Firmware */ ide_padstr((char *) (ide->buffer + 27), "IOMEGA ZIP 100 ATAPI", 40); /* Model */ } static void -zip_250_identify(const ide_t *ide, const int ide_has_dma) +rdisk_zip_250_identify(const ide_t *ide, const int ide_has_dma) { /* Firmware */ ide_padstr((char *) (ide->buffer + 23), "42.S", 8); @@ -2136,14 +2153,31 @@ zip_250_identify(const ide_t *ide, const int ide_has_dma) } static void -zip_identify(const ide_t *ide, const int ide_has_dma) +rdisk_generic_identify(const ide_t *ide, const int ide_has_dma, const rdisk_t *rdisk) { - const zip_t *zip = (zip_t *) ide->sc; + char model[40]; + + memset(model, 0, 40); + snprintf(model, 40, "%s %s%02i", EMU_NAME, "86B_RD", rdisk->id); + ide_padstr((char *) (ide->buffer + 23), EMU_VERSION_EX, 8); /* Firmware */ + ide_padstr((char *) (ide->buffer + 27), model, 40); /* Model */ + + if (ide_has_dma) { + ide->buffer[80] = 0x70; /* Supported ATA versions : ATA/ATAPI-4 ATA/ATAPI-6 */ + /* Maximum ATA revision supported : ATA/ATAPI-6 T13 1410D revision 3a */ + ide->buffer[81] = 0x19; + } +} + +static void +rdisk_identify(const ide_t *ide, const int ide_has_dma) +{ + const rdisk_t *rdisk = (rdisk_t *) ide->sc; /* ATAPI device, direct-access device, removable media, interrupt DRQ: - Using (2 << 5) below makes the ASUS P/I-P54TP4XE misdentify the ZIP drive + Using (2 << 5) below makes the ASUS P/I-P54TP4XE misdentify the RDISK drive as a LS-120. */ ide->buffer[0] = 0x8000 | (0 << 8) | 0x80 | (1 << 5); @@ -2152,50 +2186,52 @@ zip_identify(const ide_t *ide, const int ide_has_dma) /* Interpret zero byte count limit as maximum length */ ide->buffer[126] = 0xfffe; - if (zip_drives[zip->id].is_250) - zip_250_identify(ide, ide_has_dma); + if (rdisk_drives[rdisk->id].type == RDISK_TYPE_ZIP_250) + rdisk_zip_250_identify(ide, ide_has_dma); + else if (rdisk_drives[rdisk->id].type == RDISK_TYPE_ZIP_100) + rdisk_zip_100_identify(ide); else - zip_100_identify(ide); + rdisk_generic_identify(ide, ide_has_dma, rdisk); } static void -zip_drive_reset(const int c) +rdisk_drive_reset(const int c) { - const uint8_t scsi_bus = (zip_drives[c].scsi_device_id >> 4) & 0x0f; - const uint8_t scsi_id = zip_drives[c].scsi_device_id & 0x0f; + const uint8_t scsi_bus = (rdisk_drives[c].scsi_device_id >> 4) & 0x0f; + const uint8_t scsi_id = rdisk_drives[c].scsi_device_id & 0x0f; - if (zip_drives[c].priv == NULL) { - zip_drives[c].priv = (zip_t *) calloc(1, sizeof(zip_t)); - zip_t *dev = (zip_t *) zip_drives[c].priv; + if (rdisk_drives[c].priv == NULL) { + rdisk_drives[c].priv = (rdisk_t *) calloc(1, sizeof(rdisk_t)); + rdisk_t *dev = (rdisk_t *) rdisk_drives[c].priv; char n[1024] = { 0 }; - sprintf(n, "ZIP %i", c + 1); + sprintf(n, "Removable Disk %i", c + 1); dev->log = log_open(n); } - zip_t *dev = (zip_t *) zip_drives[c].priv; + rdisk_t *dev = (rdisk_t *) rdisk_drives[c].priv; dev->id = c; dev->cur_lun = SCSI_LUN_USE_CDB; - if (zip_drives[c].bus_type == ZIP_BUS_SCSI) { + if (rdisk_drives[c].bus_type == RDISK_BUS_SCSI) { if (dev->tf == NULL) dev->tf = (ide_tf_t *) calloc(1, sizeof(ide_tf_t)); - /* SCSI ZIP, attach to the SCSI bus. */ + /* SCSI RDISK, attach to the SCSI bus. */ scsi_device_t *sd = &scsi_devices[scsi_bus][scsi_id]; sd->sc = (scsi_common_t *) dev; - sd->command = zip_command; - sd->request_sense = zip_request_sense_for_scsi; - sd->reset = zip_reset; - sd->phase_data_out = zip_phase_data_out; - sd->command_stop = zip_command_stop; + sd->command = rdisk_command; + sd->request_sense = rdisk_request_sense_for_scsi; + sd->reset = rdisk_reset; + sd->phase_data_out = rdisk_phase_data_out; + sd->command_stop = rdisk_command_stop; sd->type = SCSI_REMOVABLE_DISK; - } else if (zip_drives[c].bus_type == ZIP_BUS_ATAPI) { + } else if (rdisk_drives[c].bus_type == RDISK_BUS_ATAPI) { /* ATAPI CD-ROM, attach to the IDE bus. */ - ide_t *id = ide_get_drive(zip_drives[c].ide_channel); + ide_t *id = ide_get_drive(rdisk_drives[c].ide_channel); /* If the IDE channel is initialized, we attach to it, otherwise, we do nothing - it's going to be a drive that's not attached to anything. */ @@ -2203,15 +2239,15 @@ zip_drive_reset(const int c) id->sc = (scsi_common_t *) dev; dev->tf = id->tf; IDE_ATAPI_IS_EARLY = 0; - id->get_max = zip_get_max; - id->get_timings = zip_get_timings; - id->identify = zip_identify; + id->get_max = rdisk_get_max; + id->get_timings = rdisk_get_timings; + id->identify = rdisk_identify; id->stop = NULL; - id->packet_command = zip_command; - id->device_reset = zip_reset; - id->phase_data_out = zip_phase_data_out; - id->command_stop = zip_command_stop; - id->bus_master_error = zip_bus_master_error; + id->packet_command = rdisk_command; + id->device_reset = rdisk_reset; + id->phase_data_out = rdisk_phase_data_out; + id->command_stop = rdisk_command_stop; + id->bus_master_error = rdisk_bus_master_error; id->interrupt_drq = 1; ide_atapi_attach(id); @@ -2220,85 +2256,85 @@ zip_drive_reset(const int c) } void -zip_hard_reset(void) +rdisk_hard_reset(void) { - for (uint8_t c = 0; c < ZIP_NUM; c++) { - if ((zip_drives[c].bus_type == ZIP_BUS_ATAPI) || (zip_drives[c].bus_type == ZIP_BUS_SCSI)) { + for (uint8_t c = 0; c < RDISK_NUM; c++) { + if ((rdisk_drives[c].bus_type == RDISK_BUS_ATAPI) || (rdisk_drives[c].bus_type == RDISK_BUS_SCSI)) { - if (zip_drives[c].bus_type == ZIP_BUS_SCSI) { - const uint8_t scsi_bus = (zip_drives[c].scsi_device_id >> 4) & 0x0f; - const uint8_t scsi_id = zip_drives[c].scsi_device_id & 0x0f; + if (rdisk_drives[c].bus_type == RDISK_BUS_SCSI) { + const uint8_t scsi_bus = (rdisk_drives[c].scsi_device_id >> 4) & 0x0f; + const uint8_t scsi_id = rdisk_drives[c].scsi_device_id & 0x0f; - /* Make sure to ignore any SCSI ZIP drive that has an out of range SCSI bus. */ + /* Make sure to ignore any SCSI RDISK drive that has an out of range SCSI bus. */ if (scsi_bus >= SCSI_BUS_MAX) continue; - /* Make sure to ignore any SCSI ZIP drive that has an out of range ID. */ + /* Make sure to ignore any SCSI RDISK drive that has an out of range ID. */ if (scsi_id >= SCSI_ID_MAX) continue; } - /* Make sure to ignore any ATAPI ZIP drive that has an out of range IDE channel. */ - if ((zip_drives[c].bus_type == ZIP_BUS_ATAPI) && (zip_drives[c].ide_channel > 7)) + /* Make sure to ignore any ATAPI RDISK drive that has an out of range IDE channel. */ + if ((rdisk_drives[c].bus_type == RDISK_BUS_ATAPI) && (rdisk_drives[c].ide_channel > 7)) continue; - zip_drive_reset(c); + rdisk_drive_reset(c); - zip_t *dev = (zip_t *) zip_drives[c].priv; + rdisk_t *dev = (rdisk_t *) rdisk_drives[c].priv; - zip_log(dev->log, "ZIP hard_reset drive=%d\n", c); + rdisk_log(dev->log, "Removable Disk hard_reset drive=%d\n", c); if (dev->tf == NULL) continue; dev->id = c; - dev->drv = &zip_drives[c]; + dev->drv = &rdisk_drives[c]; - zip_init(dev); + rdisk_init(dev); - if (strlen(zip_drives[c].image_path)) - zip_load(dev, zip_drives[c].image_path, 0); + if (strlen(rdisk_drives[c].image_path)) + rdisk_load(dev, rdisk_drives[c].image_path, 0); - zip_mode_sense_load(dev); + rdisk_mode_sense_load(dev); - if (zip_drives[c].bus_type == ZIP_BUS_SCSI) - zip_log(dev->log, "SCSI ZIP drive %i attached to SCSI ID %i\n", - c, zip_drives[c].scsi_device_id); - else if (zip_drives[c].bus_type == ZIP_BUS_ATAPI) - zip_log(dev->log, "ATAPI ZIP drive %i attached to IDE channel %i\n", - c, zip_drives[c].ide_channel); + if (rdisk_drives[c].bus_type == RDISK_BUS_SCSI) + rdisk_log(dev->log, "SCSI RDISK drive %i attached to SCSI ID %i\n", + c, rdisk_drives[c].scsi_device_id); + else if (rdisk_drives[c].bus_type == RDISK_BUS_ATAPI) + rdisk_log(dev->log, "ATAPI RDISK drive %i attached to IDE channel %i\n", + c, rdisk_drives[c].ide_channel); } } } void -zip_close(void) +rdisk_close(void) { - for (uint8_t c = 0; c < ZIP_NUM; c++) { - if (zip_drives[c].bus_type == ZIP_BUS_SCSI) { - const uint8_t scsi_bus = (zip_drives[c].scsi_device_id >> 4) & 0x0f; - const uint8_t scsi_id = zip_drives[c].scsi_device_id & 0x0f; + for (uint8_t c = 0; c < RDISK_NUM; c++) { + if (rdisk_drives[c].bus_type == RDISK_BUS_SCSI) { + const uint8_t scsi_bus = (rdisk_drives[c].scsi_device_id >> 4) & 0x0f; + const uint8_t scsi_id = rdisk_drives[c].scsi_device_id & 0x0f; memset(&scsi_devices[scsi_bus][scsi_id], 0x00, sizeof(scsi_device_t)); } - zip_t *dev = (zip_t *) zip_drives[c].priv; + rdisk_t *dev = (rdisk_t *) rdisk_drives[c].priv; if (dev) { - zip_disk_unload(dev); + rdisk_disk_unload(dev); if (dev->tf) free(dev->tf); if (dev->log != NULL) { - zip_log(dev->log, "Log closed\n"); + rdisk_log(dev->log, "Log closed\n"); log_close(dev->log); dev->log = NULL; } free(dev); - zip_drives[c].priv = NULL; + rdisk_drives[c].priv = NULL; } } } diff --git a/src/include/86box/config.h b/src/include/86box/config.h index 34447266b..b2391527a 100644 --- a/src/include/86box/config.h +++ b/src/include/86box/config.h @@ -133,7 +133,7 @@ typedef struct config_t { /* Other removable devices category */ storage_cfg_t cdrom[CDROM_NUM]; /* CD-ROM drives */ - storage_cfg_t rdisk[ZIP_NUM]; /* Removable disk drives */ + storage_cfg_t rdisk[RDISK_NUM]; /* Removable disk drives */ } config_t; #endif diff --git a/src/include/86box/machine_status.h b/src/include/86box/machine_status.h index 66805e653..c5640ac08 100644 --- a/src/include/86box/machine_status.h +++ b/src/include/86box/machine_status.h @@ -20,7 +20,7 @@ typedef struct dev_status_empty_t { typedef struct machine_status_t { dev_status_empty_active_t fdd[FDD_NUM]; dev_status_empty_active_t cdrom[CDROM_NUM]; - dev_status_empty_active_t zip[ZIP_NUM]; + dev_status_empty_active_t rdisk[RDISK_NUM]; dev_status_empty_active_t mo[MO_NUM]; dev_status_empty_active_t cassette; dev_status_active_t hdd[HDD_BUS_USB]; diff --git a/src/include/86box/plat.h b/src/include/86box/plat.h index e6a366f4c..fa7faddff 100644 --- a/src/include/86box/plat.h +++ b/src/include/86box/plat.h @@ -185,9 +185,9 @@ extern void floppy_mount(uint8_t id, char *fn, uint8_t wp); extern void floppy_eject(uint8_t id); extern void cdrom_mount(uint8_t id, char *fn); extern void plat_cdrom_ui_update(uint8_t id, uint8_t reload); -extern void zip_eject(uint8_t id); -extern void zip_mount(uint8_t id, char *fn, uint8_t wp); -extern void zip_reload(uint8_t id); +extern void rdisk_eject(uint8_t id); +extern void rdisk_mount(uint8_t id, char *fn, uint8_t wp); +extern void rdisk_reload(uint8_t id); extern void mo_eject(uint8_t id); extern void mo_mount(uint8_t id, char *fn, uint8_t wp); extern void mo_reload(uint8_t id); diff --git a/src/include/86box/zip.h b/src/include/86box/rdisk.h similarity index 53% rename from src/include/86box/zip.h rename to src/include/86box/rdisk.h index 969ce27f5..297cbcbc3 100644 --- a/src/include/86box/zip.h +++ b/src/include/86box/rdisk.h @@ -16,29 +16,60 @@ * Copyright 2018-2025 Miran Grca. */ -#ifndef EMU_ZIP_H -#define EMU_ZIP_H +#ifndef EMU_RDISK_H +#define EMU_RDISK_H -#define ZIP_NUM 4 +#define RDISK_NUM 4 -#define BUF_SIZE 32768 +#define BUF_SIZE 32768 -#define ZIP_TIME 10.0 +#define RDISK_TIME 10.0 -#define ZIP_SECTORS (96 * 2048) +#define ZIP_SECTORS (96 * 2048) -#define ZIP_250_SECTORS (489532) +#define ZIP_250_SECTORS (489532) -#define ZIP_IMAGE_HISTORY 10 +#define RDISK_IMAGE_HISTORY 10 enum { - ZIP_BUS_DISABLED = 0, - ZIP_BUS_ATAPI = 5, - ZIP_BUS_SCSI = 6, - ZIP_BUS_USB = 7 + RDISK_TYPE_GENERIC = 0, + RDISK_TYPE_ZIP_100, + RDISK_TYPE_ZIP_250 }; -typedef struct zip_drive_t { +typedef struct rdisk_type_t { + uint32_t sectors; + uint16_t bytes_per_sector; +} rdisk_type_t; + +#define KNOWN_RDISK_TYPES 2 +static const rdisk_type_t rdisk_types[KNOWN_RDISK_TYPES] = { + { ZIP_SECTORS, 512 }, + { ZIP_250_SECTORS, 512 }, +}; + +typedef struct rdisk_drive_type_t { + const char *vendor; + const char *model; + const char *revision; + int8_t supported_media[KNOWN_RDISK_TYPES]; +} rdisk_drive_type_t; + +#define KNOWN_RDISK_DRIVE_TYPES 3 +static const rdisk_drive_type_t rdisk_drive_types[KNOWN_RDISK_DRIVE_TYPES] = { + { "86BOX", "REMOVABLE DISK", "1.00", { 1, 1 }}, + { "IOMEGA", "ZIP 100", "E.08", { 1, 0 }}, + { "IOMEGA", "ZIP 250", "42.S", { 1, 1 }} +}; + +enum { + RDISK_BUS_DISABLED = 0, + RDISK_BUS_ATAPI = 5, + RDISK_BUS_SCSI = 6, + RDISK_BUS_USB = 7 +}; + +typedef struct rdisk_drive_t { uint8_t id; union { @@ -64,17 +95,17 @@ typedef struct zip_drive_t { char image_path[1024]; char prev_image_path[1024]; - char *image_history[ZIP_IMAGE_HISTORY]; + char *image_history[RDISK_IMAGE_HISTORY]; - uint32_t is_250; + uint32_t type; uint32_t medium_size; uint32_t base; -} zip_drive_t; +} rdisk_drive_t; -typedef struct zip_t { +typedef struct rdisk_t { mode_sense_pages_t ms_pages_saved; - zip_drive_t *drv; + rdisk_drive_t *drv; #ifdef EMU_IDE_H ide_tf_t *tf; #else @@ -113,37 +144,37 @@ typedef struct zip_t { double callback; uint8_t (*ven_cmd)(void *sc, uint8_t *cdb, int32_t *BufLen); -} zip_t; +} rdisk_t; -extern zip_t *zip[ZIP_NUM]; -extern zip_drive_t zip_drives[ZIP_NUM]; -extern uint8_t atapi_zip_drives[8]; -extern uint8_t scsi_zip_drives[16]; +extern rdisk_t *rdisk[RDISK_NUM]; +extern rdisk_drive_t rdisk_drives[RDISK_NUM]; +extern uint8_t atapi_rdisk_drives[8]; +extern uint8_t scsi_rdisk_drives[16]; -#define zip_sense_error dev->sense[0] -#define zip_sense_key dev->sense[2] -#define zip_info *(uint32_t *) &(dev->sense[3]) -#define zip_asc dev->sense[12] -#define zip_ascq dev->sense[13] +#define rdisk_sense_error dev->sense[0] +#define rdisk_sense_key dev->sense[2] +#define rdisk_info *(uint32_t *) &(dev->sense[3]) +#define rdisk_asc dev->sense[12] +#define rdisk_ascq dev->sense[13] #ifdef __cplusplus extern "C" { #endif -extern void zip_disk_close(const zip_t *dev); -extern void zip_disk_reload(const zip_t *dev); -extern void zip_insert(zip_t *dev); +extern void rdisk_disk_close(const rdisk_t *dev); +extern void rdisk_disk_reload(const rdisk_t *dev); +extern void rdisk_insert(rdisk_t *dev); -extern void zip_global_init(void); -extern void zip_hard_reset(void); +extern void rdisk_global_init(void); +extern void rdisk_hard_reset(void); -extern void zip_reset(scsi_common_t *sc); -extern int zip_is_empty(const uint8_t id); -extern void zip_load(const zip_t *dev, const char *fn, const int skip_insert); -extern void zip_close(void); +extern void rdisk_reset(scsi_common_t *sc); +extern int rdisk_is_empty(const uint8_t id); +extern void rdisk_load(const rdisk_t *dev, const char *fn, const int skip_insert); +extern void rdisk_close(void); #ifdef __cplusplus } #endif -#endif /*EMU_ZIP_H*/ +#endif /*EMU_RDISK_H*/ diff --git a/src/include/86box/ui.h b/src/include/86box/ui.h index f4efd6ec1..63243a666 100644 --- a/src/include/86box/ui.h +++ b/src/include/86box/ui.h @@ -49,7 +49,7 @@ extern int ui_msgbox_header(int flags, void *header, void *message); #define SB_CARTRIDGE 0x10 #define SB_FLOPPY 0x20 #define SB_CDROM 0x30 -#define SB_ZIP 0x40 +#define SB_RDISK 0x40 #define SB_MO 0x50 #define SB_HDD 0x60 #define SB_NETWORK 0x70 diff --git a/src/machine_status.c b/src/machine_status.c index 3eb2762bc..c1396975d 100644 --- a/src/machine_status.c +++ b/src/machine_status.c @@ -16,7 +16,7 @@ #include <86box/cartridge.h> #include <86box/cassette.h> #include <86box/cdrom.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/hdd.h> #include <86box/thread.h> @@ -36,9 +36,9 @@ machine_status_init(void) machine_status.cdrom[i].empty = (strlen(cdrom[i].image_path) == 0); machine_status.cdrom[i].active = false; } - for (size_t i = 0; i < ZIP_NUM; i++) { - machine_status.zip[i].empty = (strlen(zip_drives[i].image_path) == 0); - machine_status.zip[i].active = false; + for (size_t i = 0; i < RDISK_NUM; i++) { + machine_status.rdisk[i].empty = (strlen(rdisk_drives[i].image_path) == 0); + machine_status.rdisk[i].active = false; } for (size_t i = 0; i < MO_NUM; i++) { machine_status.mo[i].empty = (strlen(mo_drives[i].image_path) == 0); diff --git a/src/qt/icons/zip.ico b/src/qt/icons/rdisk.ico similarity index 100% rename from src/qt/icons/zip.ico rename to src/qt/icons/rdisk.ico diff --git a/src/qt/icons/zip_disabled.ico b/src/qt/icons/rdisk_disabled.ico similarity index 100% rename from src/qt/icons/zip_disabled.ico rename to src/qt/icons/rdisk_disabled.ico diff --git a/src/qt/icons/zip_image.ico b/src/qt/icons/rdisk_image.ico similarity index 100% rename from src/qt/icons/zip_image.ico rename to src/qt/icons/rdisk_image.ico diff --git a/src/qt/qt_machinestatus.cpp b/src/qt/qt_machinestatus.cpp index 131b6ad6c..1b95ad1fe 100644 --- a/src/qt/qt_machinestatus.cpp +++ b/src/qt/qt_machinestatus.cpp @@ -31,7 +31,7 @@ extern "C" { #include <86box/hdc.h> #include <86box/scsi.h> #include <86box/scsi_device.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/plat.h> #include <86box/machine.h> @@ -102,7 +102,7 @@ struct Pixmaps { PixmapSetEmptyActive floppy_525; PixmapSetEmptyActive floppy_35; PixmapSetEmptyActive cdrom; - PixmapSetEmptyActive zip; + PixmapSetEmptyActive rdisk; PixmapSetEmptyActive mo; PixmapSetActive hd; PixmapSetEmptyActive net; @@ -283,7 +283,7 @@ struct MachineStatus::States { pixmaps.floppy_525.load(QIcon(":/settings/qt/icons/floppy_525.ico")); pixmaps.floppy_35.load(QIcon(":/settings/qt/icons/floppy_35.ico")); pixmaps.cdrom.load(QIcon(":/settings/qt/icons/cdrom.ico")); - pixmaps.zip.load(QIcon(":/settings/qt/icons/zip.ico")); + pixmaps.rdisk.load(QIcon(":/settings/qt/icons/rdisk.ico")); pixmaps.mo.load(QIcon(":/settings/qt/icons/mo.ico")); pixmaps.hd.load(QIcon(":/settings/qt/icons/hard_disk.ico")); pixmaps.net.load(QIcon(":/settings/qt/icons/network.ico")); @@ -298,8 +298,8 @@ struct MachineStatus::States { for (auto &c : cdrom) { c.pixmaps = &pixmaps.cdrom; } - for (auto &z : zip) { - z.pixmaps = &pixmaps.zip; + for (auto &z : rdisk) { + z.pixmaps = &pixmaps.rdisk; } for (auto &m : mo) { m.pixmaps = &pixmaps.mo; @@ -316,7 +316,7 @@ struct MachineStatus::States { StateEmptyActive cassette; std::array fdd; std::array cdrom; - std::array zip; + std::array rdisk; std::array mo; std::array hdds; std::array net; @@ -397,21 +397,21 @@ MachineStatus::iterateCDROM(const std::function &cb) } void -MachineStatus::iterateZIP(const std::function &cb) +MachineStatus::iterateRDisk(const std::function &cb) { auto hdc_name = QString(hdc_get_internal_name(hdc_current[0])); - for (size_t i = 0; i < ZIP_NUM; i++) { + for (size_t i = 0; i < RDISK_NUM; i++) { /* Could be Internal or External IDE.. */ - if ((zip_drives[i].bus_type == ZIP_BUS_ATAPI) && !hasIDE() && + if ((rdisk_drives[i].bus_type == RDISK_BUS_ATAPI) && !hasIDE() && (hdc_name.left(3) != QStringLiteral("ide")) && (hdc_name.left(5) != QStringLiteral("xtide")) && (hdc_name.left(5) != QStringLiteral("mcide"))) continue; - if ((zip_drives[i].bus_type == ZIP_BUS_SCSI) && !hasSCSI() && + if ((rdisk_drives[i].bus_type == RDISK_BUS_SCSI) && !hasSCSI() && (scsi_card_current[0] == 0) && (scsi_card_current[1] == 0) && (scsi_card_current[2] == 0) && (scsi_card_current[3] == 0)) continue; - if (zip_drives[i].bus_type != 0) { + if (rdisk_drives[i].bus_type != 0) { cb(i); } } @@ -475,9 +475,9 @@ MachineStatus::refreshEmptyIcons() } for (size_t i = 0; i < CDROM_NUM; ++i) d->cdrom[i].setEmpty(machine_status.cdrom[i].empty); - for (size_t i = 0; i < ZIP_NUM; i++) { - d->zip[i].setEmpty(machine_status.zip[i].empty); - d->zip[i].setWriteProtected(machine_status.zip[i].write_prot); + for (size_t i = 0; i < RDISK_NUM; i++) { + d->rdisk[i].setEmpty(machine_status.rdisk[i].empty); + d->rdisk[i].setWriteProtected(machine_status.rdisk[i].write_prot); } for (size_t i = 0; i < MO_NUM; i++) { d->mo[i].setEmpty(machine_status.mo[i].empty); @@ -515,13 +515,13 @@ MachineStatus::refreshIcons() ui_sb_update_icon_write(SB_CDROM | i, 0); } } - for (size_t i = 0; i < ZIP_NUM; i++) { - d->zip[i].setActive(machine_status.zip[i].active); - d->zip[i].setWriteActive(machine_status.zip[i].write_active); - if (machine_status.zip[i].active) - ui_sb_update_icon(SB_ZIP | i, 0); - if (machine_status.zip[i].write_active) - ui_sb_update_icon_write(SB_ZIP | i, 0); + for (size_t i = 0; i < RDISK_NUM; i++) { + d->rdisk[i].setActive(machine_status.rdisk[i].active); + d->rdisk[i].setWriteActive(machine_status.rdisk[i].write_active); + if (machine_status.rdisk[i].active) + ui_sb_update_icon(SB_RDISK | i, 0); + if (machine_status.rdisk[i].write_active) + ui_sb_update_icon_write(SB_RDISK | i, 0); } for (size_t i = 0; i < MO_NUM; i++) { d->mo[i].setActive(machine_status.mo[i].active); @@ -558,9 +558,9 @@ MachineStatus::clearActivity() cdrom.setActive(false); cdrom.setWriteActive(false); } - for (auto &zip : d->zip) { - zip.setActive(false); - zip.setWriteActive(false); + for (auto &rdisk : d->rdisk) { + rdisk.setActive(false); + rdisk.setWriteActive(false); } for (auto &mo : d->mo) { mo.setActive(false); @@ -600,8 +600,8 @@ MachineStatus::refresh(QStatusBar *sbar) for (size_t i = 0; i < CDROM_NUM; i++) { sbar->removeWidget(d->cdrom[i].label.get()); } - for (size_t i = 0; i < ZIP_NUM; i++) { - sbar->removeWidget(d->zip[i].label.get()); + for (size_t i = 0; i < RDISK_NUM; i++) { + sbar->removeWidget(d->rdisk[i].label.get()); } for (size_t i = 0; i < MO_NUM; i++) { sbar->removeWidget(d->mo[i].label.get()); @@ -700,38 +700,38 @@ MachineStatus::refresh(QStatusBar *sbar) sbar->addWidget(d->cdrom[i].label.get()); }); - iterateZIP([this, sbar](int i) { - d->zip[i].label = std::make_unique(); - d->zip[i].setEmpty(QString(zip_drives[i].image_path).isEmpty()); - if (QString(zip_drives[i].image_path).isEmpty()) - d->zip[i].setWriteProtected(false); - else if (QString(zip_drives[i].image_path).left(5) == "wp://") - d->zip[i].setWriteProtected(true); + iterateRDisk([this, sbar](int i) { + d->rdisk[i].label = std::make_unique(); + d->rdisk[i].setEmpty(QString(rdisk_drives[i].image_path).isEmpty()); + if (QString(rdisk_drives[i].image_path).isEmpty()) + d->rdisk[i].setWriteProtected(false); + else if (QString(rdisk_drives[i].image_path).left(5) == "wp://") + d->rdisk[i].setWriteProtected(true); else - d->zip[i].setWriteProtected(zip_drives[i].read_only); - d->zip[i].setActive(false); - d->zip[i].setWriteActive(false); - d->zip[i].refresh(); - connect((ClickableLabel *) d->zip[i].label.get(), &ClickableLabel::clicked, [i](QPoint pos) { - MediaMenu::ptr->zipMenus[i]->popup(pos - QPoint(0, MediaMenu::ptr->zipMenus[i]->sizeHint().height())); + d->rdisk[i].setWriteProtected(rdisk_drives[i].read_only); + d->rdisk[i].setActive(false); + d->rdisk[i].setWriteActive(false); + d->rdisk[i].refresh(); + connect((ClickableLabel *) d->rdisk[i].label.get(), &ClickableLabel::clicked, [i](QPoint pos) { + MediaMenu::ptr->rdiskMenus[i]->popup(pos - QPoint(0, MediaMenu::ptr->rdiskMenus[i]->sizeHint().height())); }); - connect((ClickableLabel *) d->zip[i].label.get(), &ClickableLabel::dropped, [i](QString str) { - MediaMenu::ptr->zipMount(i, str, false); + connect((ClickableLabel *) d->rdisk[i].label.get(), &ClickableLabel::dropped, [i](QString str) { + MediaMenu::ptr->rdiskMount(i, str, false); }); - d->zip[i].label->setToolTip(MediaMenu::ptr->zipMenus[i]->title()); - d->zip[i].label->setAcceptDrops(true); - sbar->addWidget(d->zip[i].label.get()); + d->rdisk[i].label->setToolTip(MediaMenu::ptr->rdiskMenus[i]->title()); + d->rdisk[i].label->setAcceptDrops(true); + sbar->addWidget(d->rdisk[i].label.get()); }); iterateMO([this, sbar](int i) { d->mo[i].label = std::make_unique(); d->mo[i].setEmpty(QString(mo_drives[i].image_path).isEmpty()); - if (QString(zip_drives[i].image_path).isEmpty()) + if (QString(rdisk_drives[i].image_path).isEmpty()) d->mo[i].setWriteProtected(false); - else if (QString(zip_drives[i].image_path).left(5) == "wp://") + else if (QString(rdisk_drives[i].image_path).left(5) == "wp://") d->mo[i].setWriteProtected(true); else - d->mo[i].setWriteProtected(zip_drives[i].read_only); + d->mo[i].setWriteProtected(rdisk_drives[i].read_only); d->mo[i].setActive(false); d->mo[i].setWriteActive(false); d->mo[i].refresh(); @@ -924,9 +924,9 @@ MachineStatus::updateTip(int tag) if (d->cdrom[item].label && MediaMenu::ptr->cdromMenus[item]) d->cdrom[item].label->setToolTip(MediaMenu::ptr->cdromMenus[item]->title()); break; - case SB_ZIP: - if (d->zip[item].label && MediaMenu::ptr->zipMenus[item]) - d->zip[item].label->setToolTip(MediaMenu::ptr->zipMenus[item]->title()); + case SB_RDISK: + if (d->rdisk[item].label && MediaMenu::ptr->rdiskMenus[item]) + d->rdisk[item].label->setToolTip(MediaMenu::ptr->rdiskMenus[item]->title()); break; case SB_MO: if (d->mo[item].label && MediaMenu::ptr->moMenus[item]) diff --git a/src/qt/qt_machinestatus.hpp b/src/qt/qt_machinestatus.hpp index ad6425b5a..9dde36a63 100644 --- a/src/qt/qt_machinestatus.hpp +++ b/src/qt/qt_machinestatus.hpp @@ -67,7 +67,7 @@ public: static bool hasSCSI(); static void iterateFDD(const std::function &cb); static void iterateCDROM(const std::function &cb); - static void iterateZIP(const std::function &cb); + static void iterateRDisk(const std::function &cb); static void iterateMO(const std::function &cb); static void iterateNIC(const std::function &cb); diff --git a/src/qt/qt_mediahistorymanager.cpp b/src/qt/qt_mediahistorymanager.cpp index 74d596866..724616d1c 100644 --- a/src/qt/qt_mediahistorymanager.cpp +++ b/src/qt/qt_mediahistorymanager.cpp @@ -33,7 +33,7 @@ extern "C" { #include <86box/fdd.h> #include <86box/cdrom.h> #include <86box/scsi_device.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/path.h> } @@ -114,8 +114,8 @@ MediaHistoryManager::maxDevicesSupported(ui::MediaType type) return CDROM_NUM; case ui::MediaType::Floppy: return FDD_NUM; - case ui::MediaType::Zip: - return ZIP_NUM; + case ui::MediaType::RDisk: + return RDISK_NUM; case ui::MediaType::Mo: return MO_NUM; case ui::MediaType::Cassette: @@ -200,8 +200,8 @@ MediaHistoryManager::initialDeduplication() case ui::MediaType::Optical: current_image = cdrom[device_index].image_path; break; - case ui::MediaType::Zip: - current_image = zip_drives[device_index].image_path; + case ui::MediaType::RDisk: + current_image = rdisk_drives[device_index].image_path; break; case ui::MediaType::Mo: current_image = mo_drives[device_index].image_path; @@ -237,8 +237,8 @@ MediaHistoryManager::getEmuHistoryVarForType(ui::MediaType type, int index) return &fdd_image_history[index][0]; case ui::MediaType::Optical: return &cdrom[index].image_history[0]; - case ui::MediaType::Zip: - return &zip_drives[index].image_history[0]; + case ui::MediaType::RDisk: + return &rdisk_drives[index].image_history[0]; case ui::MediaType::Mo: return &mo_drives[index].image_history[0]; } diff --git a/src/qt/qt_mediahistorymanager.hpp b/src/qt/qt_mediahistorymanager.hpp index 29ada8e2a..92b5939d3 100644 --- a/src/qt/qt_mediahistorymanager.hpp +++ b/src/qt/qt_mediahistorymanager.hpp @@ -45,7 +45,7 @@ Q_NAMESPACE enum class MediaType { Floppy, Optical, - Zip, + RDisk, Mo, Cassette, Cartridge @@ -62,7 +62,7 @@ typedef QHash master_list_t; static const MediaType AllSupportedMediaHistoryTypes[] = { MediaType::Optical, MediaType::Floppy, - MediaType::Zip, + MediaType::RDisk, MediaType::Mo, MediaType::Cassette, MediaType::Cartridge diff --git a/src/qt/qt_mediamenu.cpp b/src/qt/qt_mediamenu.cpp index 2a0b3bbfd..c23e11cdb 100644 --- a/src/qt/qt_mediamenu.cpp +++ b/src/qt/qt_mediamenu.cpp @@ -56,7 +56,7 @@ extern "C" { #include <86box/fdd_86f.h> #include <86box/cdrom.h> #include <86box/scsi_device.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/sound.h> #include <86box/ui.h> @@ -187,24 +187,24 @@ MediaMenu::refresh(QMenu *parentMenu) cdromUpdateMenu(i); }); - zipMenus.clear(); - MachineStatus::iterateZIP([this, parentMenu](int i) { + rdiskMenus.clear(); + MachineStatus::iterateRDisk([this, parentMenu](int i) { auto *menu = parentMenu->addMenu(""); - QIcon img_icon = QIcon(":/settings/qt/icons/zip_image.ico"); - menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, New), tr("&New image..."), [this, i]() { zipNewImage(i); }); + QIcon img_icon = QIcon(":/settings/qt/icons/rdisk_image.ico"); + menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, New), tr("&New image..."), [this, i]() { rdiskNewImage(i); }); menu->addSeparator(); - menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, Browse), tr("&Existing image..."), [this, i]() { zipSelectImage(i, false); }); - menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, WriteProtectedBrowse), tr("Existing image (&Write-protected)..."), [this, i]() { zipSelectImage(i, true); }); + menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, Browse), tr("&Existing image..."), [this, i]() { rdiskSelectImage(i, false); }); + menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, WriteProtectedBrowse), tr("Existing image (&Write-protected)..."), [this, i]() { rdiskSelectImage(i, true); }); menu->addSeparator(); for (int slot = 0; slot < MAX_PREV_IMAGES; slot++) { - zipImageHistoryPos[slot] = menu->children().count(); - menu->addAction(img_icon, tr("Image %1").arg(slot), [this, i, slot]() { zipReload(i, slot); })->setCheckable(false); + rdiskImageHistoryPos[slot] = menu->children().count(); + menu->addAction(img_icon, tr("Image %1").arg(slot), [this, i, slot]() { rdiskReload(i, slot); })->setCheckable(false); } menu->addSeparator(); - zipEjectPos = menu->children().count(); - menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, Eject), tr("E&ject"), [this, i]() { zipEject(i); }); - zipMenus[i] = menu; - zipUpdateMenu(i); + rdiskEjectPos = menu->children().count(); + menu->addAction(getIconWithIndicator(img_icon, pixmap_size, QIcon::Normal, Eject), tr("E&ject"), [this, i]() { rdiskEject(i); }); + rdiskMenus[i] = menu; + rdiskUpdateMenu(i); }); moMenus.clear(); @@ -725,12 +725,12 @@ MediaMenu::updateImageHistory(int index, int slot, ui::MediaType type) } imageHistoryUpdatePos->setIcon(menu_icon); break; - case ui::MediaType::Zip: - if (!zipMenus.contains(index)) + case ui::MediaType::RDisk: + if (!rdiskMenus.contains(index)) return; - menu = zipMenus[index]; + menu = rdiskMenus[index]; children = menu->children(); - imageHistoryUpdatePos = dynamic_cast(children[zipImageHistoryPos[slot]]); + imageHistoryUpdatePos = dynamic_cast(children[rdiskImageHistoryPos[slot]]); menu_icon = QIcon(":/settings/qt/icons/mo_image.ico"); if (fn.left(5) == "wp://") fi.setFile(fn.right(fn.length() - 5)); @@ -842,145 +842,178 @@ MediaMenu::cdromUpdateMenu(int i) } void -MediaMenu::zipNewImage(int i) +MediaMenu::rdiskNewImage(int i) { - NewFloppyDialog dialog(NewFloppyDialog::MediaType::Zip, parentWidget); + NewFloppyDialog dialog(NewFloppyDialog::MediaType::RDisk, parentWidget); switch (dialog.exec()) { default: break; case QDialog::Accepted: QByteArray filename = dialog.fileName().toUtf8(); - zipMount(i, filename, false); + rdiskMount(i, filename, false); break; } } void -MediaMenu::zipSelectImage(int i, bool wp) +MediaMenu::rdiskSelectImage(int i, bool wp) { const auto filename = QFileDialog::getOpenFileName( parentWidget, QString(), QString(), - tr("ZIP images") % util::DlgFilter({ "im?", "zdi" }) % tr("All files") % util::DlgFilter({ "*" }, true)); + tr("Removable disk images") % util::DlgFilter({ "im?", "rdi", "zdi" }) % tr("All files") % util::DlgFilter({ "*" }, true)); if (!filename.isEmpty()) - zipMount(i, filename, wp); + rdiskMount(i, filename, wp); } void -MediaMenu::zipMount(int i, const QString &filename, bool wp) +MediaMenu::rdiskMount(int i, const QString &filename, bool wp) { - const auto dev = static_cast(zip_drives[i].priv); - int was_empty = zip_is_empty(i); + const auto dev = static_cast(rdisk_drives[i].priv); + int was_empty = rdisk_is_empty(i); - zip_disk_close(dev); - zip_drives[i].read_only = wp; + rdisk_disk_close(dev); + rdisk_drives[i].read_only = wp; if (!filename.isEmpty()) { QByteArray filenameBytes = filename.toUtf8(); if (filename.left(5) == "wp://") - zip_drives[i].read_only = 1; - else if (zip_drives[i].read_only) + rdisk_drives[i].read_only = 1; + else if (rdisk_drives[i].read_only) filenameBytes = QString::asprintf(R"(wp://%s)", filename.toUtf8().data()).toUtf8(); - zip_load(dev, filenameBytes.data(), 1); + rdisk_load(dev, filenameBytes.data(), 1); /* Signal media change to the emulated machine. */ - zip_insert(dev); + rdisk_insert(dev); /* The drive was previously empty, transition directly to UNIT ATTENTION. */ if (was_empty) - zip_insert(dev); + rdisk_insert(dev); } - mhm.addImageToHistory(i, ui::MediaType::Zip, zip_drives[i].prev_image_path, zip_drives[i].image_path); + mhm.addImageToHistory(i, ui::MediaType::RDisk, rdisk_drives[i].prev_image_path, rdisk_drives[i].image_path); - ui_sb_update_icon_state(SB_ZIP | i, filename.isEmpty() ? 1 : 0); - ui_sb_update_icon_wp(SB_ZIP | i, wp); - zipUpdateMenu(i); - ui_sb_update_tip(SB_ZIP | i); + ui_sb_update_icon_state(SB_RDISK | i, filename.isEmpty() ? 1 : 0); + ui_sb_update_icon_wp(SB_RDISK | i, wp); + rdiskUpdateMenu(i); + ui_sb_update_tip(SB_RDISK | i); config_save(); } void -MediaMenu::zipEject(int i) +MediaMenu::rdiskEject(int i) { - const auto dev = static_cast(zip_drives[i].priv); + const auto dev = static_cast(rdisk_drives[i].priv); - mhm.addImageToHistory(i, ui::MediaType::Zip, zip_drives[i].image_path, QString()); - zip_disk_close(dev); - zip_drives[i].image_path[0] = 0; - if (zip_drives[i].bus_type) { + mhm.addImageToHistory(i, ui::MediaType::RDisk, rdisk_drives[i].image_path, QString()); + rdisk_disk_close(dev); + rdisk_drives[i].image_path[0] = 0; + if (rdisk_drives[i].bus_type) { /* Signal disk change to the emulated machine. */ - zip_insert(dev); + rdisk_insert(dev); } - ui_sb_update_icon_state(SB_ZIP | i, 1); - zipUpdateMenu(i); - ui_sb_update_tip(SB_ZIP | i); + ui_sb_update_icon_state(SB_RDISK | i, 1); + rdiskUpdateMenu(i); + ui_sb_update_tip(SB_RDISK | i); config_save(); } void -MediaMenu::zipReloadPrev(int i) +MediaMenu::rdiskReloadPrev(int i) { - const auto dev = static_cast(zip_drives[i].priv); + const auto dev = static_cast(rdisk_drives[i].priv); - zip_disk_reload(dev); - if (strlen(zip_drives[i].image_path) == 0) { - ui_sb_update_icon_state(SB_ZIP | i, 1); + rdisk_disk_reload(dev); + if (strlen(rdisk_drives[i].image_path) == 0) { + ui_sb_update_icon_state(SB_RDISK | i, 1); } else { - ui_sb_update_icon_state(SB_ZIP | i, 0); + ui_sb_update_icon_state(SB_RDISK | i, 0); } - ui_sb_update_icon_wp(SB_ZIP | i, zip_drives[i].read_only); + ui_sb_update_icon_wp(SB_RDISK | i, rdisk_drives[i].read_only); - zipUpdateMenu(i); - ui_sb_update_tip(SB_ZIP | i); + rdiskUpdateMenu(i); + ui_sb_update_tip(SB_RDISK | i); config_save(); } void -MediaMenu::zipReload(int index, int slot) +MediaMenu::rdiskReload(int index, int slot) { - const QString filename = mhm.getImageForSlot(index, slot, ui::MediaType::Zip); - zipMount(index, filename, zip_drives[index].read_only); - zipUpdateMenu(index); - ui_sb_update_tip(SB_ZIP | index); + const QString filename = mhm.getImageForSlot(index, slot, ui::MediaType::RDisk); + rdiskMount(index, filename, rdisk_drives[index].read_only); + rdiskUpdateMenu(index); + ui_sb_update_tip(SB_RDISK | index); } void -MediaMenu::zipUpdateMenu(int i) +MediaMenu::moUpdateMenu(int i) { - const QString name = zip_drives[i].image_path; - const QString prev_name = zip_drives[i].prev_image_path; - QFileInfo fi(zip_drives[i].image_path); - if (!zipMenus.contains(i)) + QString name = mo_drives[i].image_path; + QString prev_name = mo_drives[i].prev_image_path; + QFileInfo fi(mo_drives[i].image_path); + if (!moMenus.contains(i)) return; - auto *menu = zipMenus[i]; + auto *menu = moMenus[i]; auto childs = menu->children(); - auto *ejectMenu = dynamic_cast(childs[zipEjectPos]); + auto *ejectMenu = dynamic_cast(childs[moEjectPos]); ejectMenu->setEnabled(!name.isEmpty()); ejectMenu->setText(name.isEmpty() ? tr("E&ject") : tr("E&ject %1").arg(fi.fileName())); QString busName = tr("Unknown Bus"); - switch (zip_drives[i].bus_type) { + switch (mo_drives[i].bus_type) { default: break; - case ZIP_BUS_ATAPI: + case MO_BUS_ATAPI: busName = "ATAPI"; break; - case ZIP_BUS_SCSI: + case MO_BUS_SCSI: busName = "SCSI"; break; } - menu->setTitle(tr("ZIP %1 %2 (%3): %4").arg((zip_drives[i].is_250 > 0) ? QString("250") : QString("100"), QString::number(i + 1), busName, name.isEmpty() ? tr("(empty)") : name)); + menu->setTitle(tr("MO %1 (%2): %3").arg(QString::number(i + 1), busName, name.isEmpty() ? tr("(empty)") : name)); for (int slot = 0; slot < MAX_PREV_IMAGES; slot++) - updateImageHistory(i, slot, ui::MediaType::Zip); + updateImageHistory(i, slot, ui::MediaType::Mo); +} + +void +MediaMenu::rdiskUpdateMenu(int i) +{ + const QString name = rdisk_drives[i].image_path; + const QString prev_name = rdisk_drives[i].prev_image_path; + QFileInfo fi(rdisk_drives[i].image_path); + if (!rdiskMenus.contains(i)) + return; + auto *menu = rdiskMenus[i]; + auto childs = menu->children(); + + auto *ejectMenu = dynamic_cast(childs[rdiskEjectPos]); + ejectMenu->setEnabled(!name.isEmpty()); + ejectMenu->setText(name.isEmpty() ? tr("E&ject") : tr("E&ject %1").arg(fi.fileName())); + + QString busName = tr("Unknown Bus"); + switch (rdisk_drives[i].bus_type) { + default: + break; + case RDISK_BUS_ATAPI: + busName = "ATAPI"; + break; + case RDISK_BUS_SCSI: + busName = "SCSI"; + break; + } + + menu->setTitle(tr("Removable disk %1 (%2): %3").arg(QString::number(i + 1), busName, name.isEmpty() ? tr("(empty)") : name)); + + for (int slot = 0; slot < MAX_PREV_IMAGES; slot++) + updateImageHistory(i, slot, ui::MediaType::RDisk); } void @@ -1094,39 +1127,6 @@ MediaMenu::moReload(int index, int slot) ui_sb_update_tip(SB_MO | index); } -void -MediaMenu::moUpdateMenu(int i) -{ - QString name = mo_drives[i].image_path; - QString prev_name = mo_drives[i].prev_image_path; - QFileInfo fi(mo_drives[i].image_path); - if (!moMenus.contains(i)) - return; - auto *menu = moMenus[i]; - auto childs = menu->children(); - - auto *ejectMenu = dynamic_cast(childs[moEjectPos]); - ejectMenu->setEnabled(!name.isEmpty()); - ejectMenu->setText(name.isEmpty() ? tr("E&ject") : tr("E&ject %1").arg(fi.fileName())); - - QString busName = tr("Unknown Bus"); - switch (mo_drives[i].bus_type) { - default: - break; - case MO_BUS_ATAPI: - busName = "ATAPI"; - break; - case MO_BUS_SCSI: - busName = "SCSI"; - break; - } - - menu->setTitle(tr("MO %1 (%2): %3").arg(QString::number(i + 1), busName, name.isEmpty() ? tr("(empty)") : name)); - - for (int slot = 0; slot < MAX_PREV_IMAGES; slot++) - updateImageHistory(i, slot, ui::MediaType::Mo); -} - void MediaMenu::nicConnect(int i) { @@ -1241,21 +1241,21 @@ plat_cdrom_ui_update(uint8_t id, uint8_t reload) } void -zip_eject(uint8_t id) +rdisk_eject(uint8_t id) { - MediaMenu::ptr->zipEject(id); + MediaMenu::ptr->rdiskEject(id); } void -zip_mount(uint8_t id, char *fn, uint8_t wp) +rdisk_mount(uint8_t id, char *fn, uint8_t wp) { - MediaMenu::ptr->zipMount(id, QString(fn), wp); + MediaMenu::ptr->rdiskMount(id, QString(fn), wp); } void -zip_reload(uint8_t id) +rdisk_reload(uint8_t id) { - MediaMenu::ptr->zipReloadPrev(id); + MediaMenu::ptr->rdiskReloadPrev(id); } void diff --git a/src/qt/qt_mediamenu.hpp b/src/qt/qt_mediamenu.hpp index ed97a0a50..fb24d24e0 100644 --- a/src/qt/qt_mediamenu.hpp +++ b/src/qt/qt_mediamenu.hpp @@ -17,7 +17,7 @@ public: void refresh(QMenu *parentMenu); - // because some 86box C-only code needs to call zip and + // because some 86box C-only code needs to call rdisk and // mo eject directly static std::shared_ptr ptr; @@ -51,13 +51,13 @@ public: void clearImageHistory(); void cdromUpdateMenu(int i); - void zipNewImage(int i); - void zipSelectImage(int i, bool wp); - void zipMount(int i, const QString &filename, bool wp); - void zipEject(int i); - void zipReloadPrev(int i); - void zipReload(int index, int slot); - void zipUpdateMenu(int i); + void rdiskNewImage(int i); + void rdiskSelectImage(int i, bool wp); + void rdiskMount(int i, const QString &filename, bool wp); + void rdiskEject(int i); + void rdiskReloadPrev(int i); + void rdiskReload(int index, int slot); + void rdiskUpdateMenu(int i); void moNewImage(int i); void moSelectImage(int i, bool wp); @@ -84,7 +84,7 @@ private: QMap cartridgeMenus; QMap floppyMenus; QMap cdromMenus; - QMap zipMenus; + QMap rdiskMenus; QMap moMenus; QMap netMenus; @@ -111,8 +111,8 @@ private: int cdromEjectPos; int cdromImageHistoryPos[MAX_PREV_IMAGES]; - int zipEjectPos; - int zipImageHistoryPos[MAX_PREV_IMAGES]; + int rdiskEjectPos; + int rdiskImageHistoryPos[MAX_PREV_IMAGES]; int moEjectPos; int moImageHistoryPos[MAX_PREV_IMAGES]; diff --git a/src/qt/qt_newfloppydialog.cpp b/src/qt/qt_newfloppydialog.cpp index 58a7a3df2..d9ae09d0c 100644 --- a/src/qt/qt_newfloppydialog.cpp +++ b/src/qt/qt_newfloppydialog.cpp @@ -29,7 +29,7 @@ extern "C" { #include <86box/plat.h> #include <86box/random.h> #include <86box/scsi_device.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> } @@ -110,7 +110,7 @@ static const QStringList floppyTypes = { "2.88 MB", }; -static const QStringList zipTypes = { +static const QStringList rdiskTypes = { "ZIP 100", "ZIP 250", }; @@ -146,11 +146,11 @@ NewFloppyDialog::NewFloppyDialog(MediaType type, QWidget *parent) tr("All images") % util::DlgFilter({ "86f", "dsk", "flp", "im?", "img", "*fd?" }) % tr("Basic sector images") % util::DlgFilter({ "dsk", "flp", "im?", "img", "*fd?" }) % tr("Surface images") % util::DlgFilter({ "86f" }, true)); break; - case MediaType::Zip: - for (int i = 0; i < zipTypes.size(); ++i) { - Models::AddEntry(model, tr(zipTypes[i].toUtf8().data()), i); + case MediaType::RDisk: + for (int i = 0; i < rdiskTypes.size(); ++i) { + Models::AddEntry(model, tr(rdiskTypes[i].toUtf8().data()), i); } - ui->fileField->setFilter(tr("ZIP images") % util::DlgFilter({ "im?", "img", "zdi" }, true)); + ui->fileField->setFilter(tr("Removable disk images") % util::DlgFilter({ "im?", "img", "rdi", "zdi" }, true)); break; case MediaType::Mo: for (int i = 0; i < moTypes.size(); ++i) { @@ -218,13 +218,13 @@ NewFloppyDialog::onCreate() } } break; - case MediaType::Zip: + case MediaType::RDisk: { fileType = fi.suffix().toLower() == QStringLiteral("zdi") ? FileType::Zdi : FileType::Img; std::atomic_bool res; std::thread t([this, &res, filename, fileType, &progress] { - res = createZipSectorImage(filename, disk_sizes[ui->comboBoxSize->currentIndex() + 12], fileType, progress); + res = createRDiskSectorImage(filename, disk_sizes[ui->comboBoxSize->currentIndex() + 12], fileType, progress); }); progress.exec(); t.join(); @@ -463,7 +463,7 @@ NewFloppyDialog::createSectorImage(const QString &filename, const disk_size_t &d } bool -NewFloppyDialog::createZipSectorImage(const QString &filename, const disk_size_t &disk_size, FileType type, QProgressDialog &pbar) +NewFloppyDialog::createRDiskSectorImage(const QString &filename, const disk_size_t &disk_size, FileType type, QProgressDialog &pbar) { uint64_t total_size = 0; uint32_t total_sectors = 0; diff --git a/src/qt/qt_newfloppydialog.hpp b/src/qt/qt_newfloppydialog.hpp index a342df567..7429fc186 100644 --- a/src/qt/qt_newfloppydialog.hpp +++ b/src/qt/qt_newfloppydialog.hpp @@ -16,7 +16,7 @@ class NewFloppyDialog : public QDialog { public: enum class MediaType { Floppy, - Zip, + RDisk, Mo, }; enum class FileType { @@ -42,7 +42,7 @@ private: bool create86f(const QString &filename, const disk_size_t &disk_size, uint8_t rpm_mode); bool createSectorImage(const QString &filename, const disk_size_t &disk_size, FileType type); - bool createZipSectorImage(const QString &filename, const disk_size_t &disk_size, FileType type, QProgressDialog &pbar); + bool createRDiskSectorImage(const QString &filename, const disk_size_t &disk_size, FileType type, QProgressDialog &pbar); bool createMoSectorImage(const QString &filename, int8_t disk_size, FileType type, QProgressDialog &pbar); }; diff --git a/src/qt/qt_settings.cpp b/src/qt/qt_settings.cpp index 19a537652..3d06f53e3 100644 --- a/src/qt/qt_settings.cpp +++ b/src/qt/qt_settings.cpp @@ -164,24 +164,24 @@ Settings::Settings(QWidget *parent) connect(floppyCdrom, &SettingsFloppyCDROM::cdromChannelChanged, otherRemovable, &SettingsOtherRemovable::reloadBusChannels_MO); connect(floppyCdrom, &SettingsFloppyCDROM::cdromChannelChanged, otherRemovable, - &SettingsOtherRemovable::reloadBusChannels_ZIP); + &SettingsOtherRemovable::reloadBusChannels_RDisk); connect(harddisks, &SettingsHarddisks::driveChannelChanged, floppyCdrom, &SettingsFloppyCDROM::reloadBusChannels); connect(harddisks, &SettingsHarddisks::driveChannelChanged, otherRemovable, &SettingsOtherRemovable::reloadBusChannels_MO); connect(harddisks, &SettingsHarddisks::driveChannelChanged, otherRemovable, - &SettingsOtherRemovable::reloadBusChannels_ZIP); + &SettingsOtherRemovable::reloadBusChannels_RDisk); connect(otherRemovable, &SettingsOtherRemovable::moChannelChanged, harddisks, &SettingsHarddisks::reloadBusChannels); connect(otherRemovable, &SettingsOtherRemovable::moChannelChanged, floppyCdrom, &SettingsFloppyCDROM::reloadBusChannels); connect(otherRemovable, &SettingsOtherRemovable::moChannelChanged, otherRemovable, - &SettingsOtherRemovable::reloadBusChannels_ZIP); - connect(otherRemovable, &SettingsOtherRemovable::zipChannelChanged, harddisks, + &SettingsOtherRemovable::reloadBusChannels_RDisk); + connect(otherRemovable, &SettingsOtherRemovable::rdiskChannelChanged, harddisks, &SettingsHarddisks::reloadBusChannels); - connect(otherRemovable, &SettingsOtherRemovable::zipChannelChanged, floppyCdrom, + connect(otherRemovable, &SettingsOtherRemovable::rdiskChannelChanged, floppyCdrom, &SettingsFloppyCDROM::reloadBusChannels); - connect(otherRemovable, &SettingsOtherRemovable::zipChannelChanged, otherRemovable, + connect(otherRemovable, &SettingsOtherRemovable::rdiskChannelChanged, otherRemovable, &SettingsOtherRemovable::reloadBusChannels_MO); connect(ui->listView->selectionModel(), &QItemSelectionModel::currentChanged, this, diff --git a/src/qt/qt_settings_bus_tracking.hpp b/src/qt/qt_settings_bus_tracking.hpp index 917706428..ac1f3ca5b 100644 --- a/src/qt/qt_settings_bus_tracking.hpp +++ b/src/qt/qt_settings_bus_tracking.hpp @@ -8,7 +8,7 @@ #define DEV_HDD 0x01 #define DEV_CDROM 0x02 -#define DEV_ZIP 0x04 +#define DEV_RDISK 0x04 #define DEV_MO 0x08 #define BUS_MFM 0 @@ -44,7 +44,7 @@ public: int scsi_bus_full(); /* Set: 0 = Clear the device from the tracking, 1 = Set the device on the tracking. - Device type: 1 = Hard Disk, 2 = CD-ROM, 4 = ZIP, 8 = Magneto-Optical. + Device type: 1 = Hard Disk, 2 = CD-ROM, 4 = Removable disk, 8 = Magneto-Optical. Bus: 0 = MFM, 1 = ESDI, 2 = XTA, 3 = IDE, 4 = SCSI. */ void device_track(int set, uint8_t dev_type, int bus, int channel); diff --git a/src/qt/qt_settingsotherremovable.cpp b/src/qt/qt_settingsotherremovable.cpp index 8a810a4fb..8088f0969 100644 --- a/src/qt/qt_settingsotherremovable.cpp +++ b/src/qt/qt_settingsotherremovable.cpp @@ -23,7 +23,7 @@ extern "C" { #include <86box/timer.h> #include <86box/scsi_device.h> #include <86box/mo.h> -#include <86box/zip.h> +#include <86box/rdisk.h> } #include @@ -40,6 +40,13 @@ moDriveTypeName(int i) mo_drive_types[i].revision); } +static QString +rdiskDriveTypeName(int i) +{ + return QString("%1 %2 %3").arg(rdisk_drive_types[i].vendor, rdisk_drive_types[i].model, + rdisk_drive_types[i].revision); +} + static void setMOBus(QAbstractItemModel *model, const QModelIndex &idx, uint8_t bus, uint8_t channel) { @@ -65,27 +72,16 @@ setMOBus(QAbstractItemModel *model, const QModelIndex &idx, uint8_t bus, uint8_t } static void -setMOType(QAbstractItemModel *model, const QModelIndex &idx, uint32_t type) -{ - auto i = idx.siblingAtColumn(1); - if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() == MO_BUS_DISABLED) - model->setData(i, QCoreApplication::translate("", "None")); - else - model->setData(i, moDriveTypeName(type)); - model->setData(i, type, Qt::UserRole); -} - -static void -setZIPBus(QAbstractItemModel *model, const QModelIndex &idx, uint8_t bus, uint8_t channel) +setRDiskBus(QAbstractItemModel *model, const QModelIndex &idx, uint8_t bus, uint8_t channel) { QIcon icon; switch (bus) { - case ZIP_BUS_DISABLED: - icon = QIcon(":/settings/qt/icons/zip_disabled.ico"); + case RDISK_BUS_DISABLED: + icon = QIcon(":/settings/qt/icons/rdisk_disabled.ico"); break; - case ZIP_BUS_ATAPI: - case ZIP_BUS_SCSI: - icon = QIcon(":/settings/qt/icons/zip.ico"); + case RDISK_BUS_ATAPI: + case RDISK_BUS_SCSI: + icon = QIcon(":/settings/qt/icons/rdisk.ico"); break; default: @@ -100,11 +96,25 @@ setZIPBus(QAbstractItemModel *model, const QModelIndex &idx, uint8_t bus, uint8_ } static void -setZIPType(QAbstractItemModel *model, const QModelIndex &idx, bool is250) +setMOType(QAbstractItemModel *model, const QModelIndex &idx, uint32_t type) { auto i = idx.siblingAtColumn(1); - model->setData(i, is250 ? "ZIP 250" : "ZIP 100"); - model->setData(i, is250, Qt::UserRole); + if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() == MO_BUS_DISABLED) + model->setData(i, QCoreApplication::translate("", "None")); + else + model->setData(i, moDriveTypeName(type)); + model->setData(i, type, Qt::UserRole); +} + +static void +setRDiskType(QAbstractItemModel *model, const QModelIndex &idx, uint32_t type) +{ + auto i = idx.siblingAtColumn(1); + if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() == RDISK_BUS_DISABLED) + model->setData(i, QCoreApplication::translate("", "None")); + else + model->setData(i, rdiskDriveTypeName(type)); + model->setData(i, type, Qt::UserRole); } SettingsOtherRemovable::SettingsOtherRemovable(QWidget *parent) @@ -136,24 +146,28 @@ SettingsOtherRemovable::SettingsOtherRemovable(QWidget *parent) connect(ui->tableViewMO->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &SettingsOtherRemovable::onMORowChanged); ui->tableViewMO->setCurrentIndex(model->index(0, 0)); - Harddrives::populateRemovableBuses(ui->comboBoxZIPBus->model()); + Harddrives::populateRemovableBuses(ui->comboBoxRDiskBus->model()); + model = ui->comboBoxRDiskType->model(); + for (uint32_t i = 0; i < KNOWN_RDISK_DRIVE_TYPES; i++) { + Models::AddEntry(model, rdiskDriveTypeName(i), i); + } model = new QStandardItemModel(0, 2, this); - ui->tableViewZIP->setModel(model); + ui->tableViewRDisk->setModel(model); model->setHeaderData(0, Qt::Horizontal, tr("Bus")); model->setHeaderData(1, Qt::Horizontal, tr("Type")); - model->insertRows(0, ZIP_NUM); - for (int i = 0; i < ZIP_NUM; i++) { + model->insertRows(0, RDISK_NUM); + for (int i = 0; i < RDISK_NUM; i++) { auto idx = model->index(i, 0); - setZIPBus(model, idx, zip_drives[i].bus_type, zip_drives[i].res); - setZIPType(model, idx, zip_drives[i].is_250 > 0); - Harddrives::busTrackClass->device_track(1, DEV_ZIP, zip_drives[i].bus_type, zip_drives[i].bus_type == ZIP_BUS_ATAPI ? zip_drives[i].ide_channel : zip_drives[i].scsi_device_id); + setRDiskBus(model, idx, rdisk_drives[i].bus_type, rdisk_drives[i].res); + setRDiskType(model, idx.siblingAtColumn(1), rdisk_drives[i].type); + Harddrives::busTrackClass->device_track(1, DEV_MO, rdisk_drives[i].bus_type, rdisk_drives[i].bus_type == RDISK_BUS_ATAPI ? rdisk_drives[i].ide_channel : rdisk_drives[i].scsi_device_id); } - ui->tableViewZIP->resizeColumnsToContents(); - ui->tableViewZIP->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch); + ui->tableViewRDisk->resizeColumnsToContents(); + ui->tableViewRDisk->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch); - connect(ui->tableViewZIP->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &SettingsOtherRemovable::onZIPRowChanged); - ui->tableViewZIP->setCurrentIndex(model->index(0, 0)); + connect(ui->tableViewRDisk->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &SettingsOtherRemovable::onRDiskRowChanged); + ui->tableViewRDisk->setCurrentIndex(model->index(0, 0)); } SettingsOtherRemovable::~SettingsOtherRemovable() @@ -173,13 +187,13 @@ SettingsOtherRemovable::save() mo_drives[i].type = model->index(i, 1).data(Qt::UserRole).toUInt(); } - model = ui->tableViewZIP->model(); - for (uint8_t i = 0; i < ZIP_NUM; i++) { - zip_drives[i].fp = NULL; - zip_drives[i].priv = NULL; - zip_drives[i].bus_type = model->index(i, 0).data(Qt::UserRole).toUInt(); - zip_drives[i].res = model->index(i, 0).data(Qt::UserRole + 1).toUInt(); - zip_drives[i].is_250 = model->index(i, 1).data(Qt::UserRole).toBool() ? 1 : 0; + model = ui->tableViewRDisk->model(); + for (uint8_t i = 0; i < RDISK_NUM; i++) { + rdisk_drives[i].fp = NULL; + rdisk_drives[i].priv = NULL; + rdisk_drives[i].bus_type = model->index(i, 0).data(Qt::UserRole).toUInt(); + rdisk_drives[i].res = model->index(i, 0).data(Qt::UserRole + 1).toUInt(); + rdisk_drives[i].type = model->index(i, 1).data(Qt::UserRole).toUInt(); } } @@ -205,24 +219,24 @@ SettingsOtherRemovable::onMORowChanged(const QModelIndex ¤t) } void -SettingsOtherRemovable::onZIPRowChanged(const QModelIndex ¤t) +SettingsOtherRemovable::onRDiskRowChanged(const QModelIndex ¤t) { uint8_t bus = current.siblingAtColumn(0).data(Qt::UserRole).toUInt(); uint8_t channel = current.siblingAtColumn(0).data(Qt::UserRole + 1).toUInt(); - bool is250 = current.siblingAtColumn(1).data(Qt::UserRole).toBool(); + uint8_t type = current.siblingAtColumn(1).data(Qt::UserRole).toUInt(); - ui->comboBoxZIPBus->setCurrentIndex(-1); - const auto *model = ui->comboBoxZIPBus->model(); + ui->comboBoxRDiskBus->setCurrentIndex(-1); + const auto *model = ui->comboBoxRDiskBus->model(); auto match = model->match(model->index(0, 0), Qt::UserRole, bus); if (!match.isEmpty()) - ui->comboBoxZIPBus->setCurrentIndex(match.first().row()); + ui->comboBoxRDiskBus->setCurrentIndex(match.first().row()); - model = ui->comboBoxZIPChannel->model(); + model = ui->comboBoxRDiskChannel->model(); match = model->match(model->index(0, 0), Qt::UserRole, channel); if (!match.isEmpty()) - ui->comboBoxZIPChannel->setCurrentIndex(match.first().row()); - ui->checkBoxZIP250->setChecked(is250); - enableCurrentlySelectedChannel_ZIP(); + ui->comboBoxRDiskChannel->setCurrentIndex(match.first().row()); + ui->comboBoxRDiskType->setCurrentIndex(type); + enableCurrentlySelectedChannel_RDisk(); } void @@ -234,6 +248,15 @@ SettingsOtherRemovable::reloadBusChannels_MO() { enableCurrentlySelectedChannel_MO(); } +void +SettingsOtherRemovable::reloadBusChannels_RDisk() { + auto selected = ui->comboBoxRDiskChannel->currentIndex(); + Harddrives::populateBusChannels(ui->comboBoxRDiskChannel->model(), + ui->comboBoxRDiskBus->currentData().toInt(), Harddrives::busTrackClass); + ui->comboBoxRDiskChannel->setCurrentIndex(selected); + enableCurrentlySelectedChannel_RDisk(); +} + void SettingsOtherRemovable::on_comboBoxMOBus_currentIndexChanged(int index) { @@ -246,6 +269,18 @@ SettingsOtherRemovable::on_comboBoxMOBus_currentIndexChanged(int index) } } +void +SettingsOtherRemovable::on_comboBoxRDiskBus_currentIndexChanged(int index) +{ + if (index >= 0) { + int bus = ui->comboBoxRDiskBus->currentData().toInt(); + bool enabled = (bus != RDISK_BUS_DISABLED); + ui->comboBoxRDiskChannel->setEnabled(enabled); + ui->comboBoxRDiskType->setEnabled(enabled); + Harddrives::populateBusChannels(ui->comboBoxRDiskChannel->model(), bus, Harddrives::busTrackClass); + } +} + void SettingsOtherRemovable::on_comboBoxMOBus_activated(int) { @@ -253,9 +288,9 @@ SettingsOtherRemovable::on_comboBoxMOBus_activated(int) Harddrives::busTrackClass->device_track(0, DEV_MO, ui->tableViewMO->model()->data(i, Qt::UserRole).toInt(), ui->tableViewMO->model()->data(i, Qt::UserRole + 1).toInt()); - ui->comboBoxMOChannel->setCurrentIndex(ui->comboBoxMOBus->currentData().toUInt() == - MO_BUS_ATAPI ? Harddrives::busTrackClass->next_free_ide_channel() : - Harddrives::busTrackClass->next_free_scsi_id()); + ui->comboBoxMOChannel->setCurrentIndex(ui->comboBoxMOBus->currentData().toUInt() == MO_BUS_ATAPI ? + Harddrives::busTrackClass->next_free_ide_channel() : + Harddrives::busTrackClass->next_free_scsi_id()); ui->tableViewMO->model()->data(i, Qt::UserRole + 1); setMOBus(ui->tableViewMO->model(), ui->tableViewMO->selectionModel()->currentIndex(), @@ -272,6 +307,32 @@ SettingsOtherRemovable::on_comboBoxMOBus_activated(int) emit moChannelChanged(); } +void +SettingsOtherRemovable::on_comboBoxRDiskBus_activated(int) +{ + auto i = ui->tableViewRDisk->selectionModel()->currentIndex().siblingAtColumn(0); + Harddrives::busTrackClass->device_track(0, DEV_RDISK, ui->tableViewRDisk->model()->data(i, + Qt::UserRole).toInt(), ui->tableViewRDisk->model()->data(i, + Qt::UserRole + 1).toInt()); + ui->comboBoxRDiskChannel->setCurrentIndex(ui->comboBoxRDiskBus->currentData().toUInt() == RDISK_BUS_ATAPI ? + Harddrives::busTrackClass->next_free_ide_channel() : + Harddrives::busTrackClass->next_free_scsi_id()); + ui->tableViewRDisk->model()->data(i, Qt::UserRole + 1); + setRDiskBus(ui->tableViewRDisk->model(), + ui->tableViewRDisk->selectionModel()->currentIndex(), + ui->comboBoxRDiskBus->currentData().toUInt(), + ui->comboBoxRDiskChannel->currentData().toUInt()); + setRDiskType(ui->tableViewRDisk->model(), + ui->tableViewRDisk->selectionModel()->currentIndex(), + ui->comboBoxRDiskType->currentData().toUInt()); + ui->tableViewRDisk->resizeColumnsToContents(); + ui->tableViewRDisk->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch); + Harddrives::busTrackClass->device_track(1, DEV_RDISK, ui->tableViewRDisk->model()->data(i, + Qt::UserRole).toInt(), ui->tableViewRDisk->model()->data(i, + Qt::UserRole + 1).toInt()); + emit rdiskChannelChanged(); +} + void SettingsOtherRemovable::enableCurrentlySelectedChannel_MO() { @@ -282,6 +343,15 @@ SettingsOtherRemovable::enableCurrentlySelectedChannel_MO() item->setEnabled(true); } +void +SettingsOtherRemovable::enableCurrentlySelectedChannel_RDisk() +{ + const auto *item_model = qobject_cast(ui->comboBoxRDiskChannel->model()); + const auto index = ui->comboBoxRDiskChannel->currentIndex(); + auto *item = item_model->item(index); + if (item) + item->setEnabled(true); +} void SettingsOtherRemovable::on_comboBoxMOChannel_activated(int) { @@ -299,6 +369,23 @@ SettingsOtherRemovable::on_comboBoxMOChannel_activated(int) emit moChannelChanged(); } +void +SettingsOtherRemovable::on_comboBoxRDiskChannel_activated(int) +{ + auto i = ui->tableViewRDisk->selectionModel()->currentIndex().siblingAtColumn(0); + Harddrives::busTrackClass->device_track(0, DEV_RDISK, ui->tableViewRDisk->model()->data(i, + Qt::UserRole).toInt(), ui->tableViewRDisk->model()->data(i, + Qt::UserRole + 1).toInt()); + setRDiskBus(ui->tableViewRDisk->model(), + ui->tableViewRDisk->selectionModel()->currentIndex(), + ui->comboBoxRDiskBus->currentData().toUInt(), + ui->comboBoxRDiskChannel->currentData().toUInt()); + Harddrives::busTrackClass->device_track(1, DEV_RDISK, ui->tableViewRDisk->model()->data(i, + Qt::UserRole).toInt(), + ui->tableViewRDisk->model()->data(i, Qt::UserRole + 1).toInt()); + emit rdiskChannelChanged(); +} + void SettingsOtherRemovable::on_comboBoxMOType_activated(int) { @@ -310,77 +397,11 @@ SettingsOtherRemovable::on_comboBoxMOType_activated(int) } void -SettingsOtherRemovable::reloadBusChannels_ZIP() { - auto selected = ui->comboBoxZIPChannel->currentIndex(); - Harddrives::populateBusChannels(ui->comboBoxZIPChannel->model(), - ui->comboBoxZIPBus->currentData().toInt(), Harddrives::busTrackClass); - ui->comboBoxZIPChannel->setCurrentIndex(selected); - enableCurrentlySelectedChannel_ZIP(); -} - -void -SettingsOtherRemovable::on_comboBoxZIPBus_currentIndexChanged(int index) +SettingsOtherRemovable::on_comboBoxRDiskType_activated(int) { - if (index >= 0) { - int bus = ui->comboBoxZIPBus->currentData().toInt(); - bool enabled = (bus != ZIP_BUS_DISABLED); - ui->comboBoxZIPChannel->setEnabled(enabled); - ui->checkBoxZIP250->setEnabled(enabled); - Harddrives::populateBusChannels(ui->comboBoxZIPChannel->model(), bus, Harddrives::busTrackClass); - } -} - -void -SettingsOtherRemovable::on_comboBoxZIPBus_activated(int) -{ - auto i = ui->tableViewZIP->selectionModel()->currentIndex().siblingAtColumn(0); - Harddrives::busTrackClass->device_track(0, DEV_ZIP, ui->tableViewZIP->model()->data(i, - Qt::UserRole).toInt(), ui->tableViewZIP->model()->data(i, - Qt::UserRole + 1).toInt()); - ui->comboBoxZIPChannel->setCurrentIndex(ui->comboBoxZIPBus->currentData().toUInt() == ZIP_BUS_ATAPI ? - Harddrives::busTrackClass->next_free_ide_channel() : - Harddrives::busTrackClass->next_free_scsi_id()); - setZIPBus(ui->tableViewZIP->model(), - ui->tableViewZIP->selectionModel()->currentIndex(), - ui->comboBoxZIPBus->currentData().toUInt(), - ui->comboBoxZIPChannel->currentData().toUInt()); - Harddrives::busTrackClass->device_track(1, DEV_ZIP, ui->tableViewZIP->model()->data(i, - Qt::UserRole).toInt(), ui->tableViewZIP->model()->data(i, - Qt::UserRole + 1).toInt()); - emit zipChannelChanged(); -} - -void -SettingsOtherRemovable::enableCurrentlySelectedChannel_ZIP() -{ - const auto *item_model = qobject_cast(ui->comboBoxZIPChannel->model()); - const auto index = ui->comboBoxZIPChannel->currentIndex(); - auto *item = item_model->item(index); - if (item) - item->setEnabled(true); -} - -void -SettingsOtherRemovable::on_comboBoxZIPChannel_activated(int) -{ - auto i = ui->tableViewZIP->selectionModel()->currentIndex().siblingAtColumn(0); - Harddrives::busTrackClass->device_track(0, DEV_ZIP, ui->tableViewZIP->model()->data(i, - Qt::UserRole).toInt(), ui->tableViewZIP->model()->data(i, - Qt::UserRole + 1).toInt()); - setZIPBus(ui->tableViewZIP->model(), - ui->tableViewZIP->selectionModel()->currentIndex(), - ui->comboBoxZIPBus->currentData().toUInt(), - ui->comboBoxZIPChannel->currentData().toUInt()); - Harddrives::busTrackClass->device_track(1, DEV_ZIP, ui->tableViewZIP->model()->data(i, - Qt::UserRole).toInt(), - ui->tableViewZIP->model()->data(i, Qt::UserRole + 1).toInt()); - emit zipChannelChanged(); -} - -void -SettingsOtherRemovable::on_checkBoxZIP250_stateChanged(int state) -{ - setZIPType(ui->tableViewZIP->model(), - ui->tableViewZIP->selectionModel()->currentIndex(), - state == Qt::Checked); + setRDiskType(ui->tableViewRDisk->model(), + ui->tableViewRDisk->selectionModel()->currentIndex(), + ui->comboBoxRDiskType->currentData().toUInt()); + ui->tableViewRDisk->resizeColumnsToContents(); + ui->tableViewRDisk->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch); } diff --git a/src/qt/qt_settingsotherremovable.hpp b/src/qt/qt_settingsotherremovable.hpp index 1459ed043..79fcfbf3f 100644 --- a/src/qt/qt_settingsotherremovable.hpp +++ b/src/qt/qt_settingsotherremovable.hpp @@ -14,13 +14,13 @@ public: explicit SettingsOtherRemovable(QWidget *parent = nullptr); ~SettingsOtherRemovable(); void reloadBusChannels_MO(); - void reloadBusChannels_ZIP(); + void reloadBusChannels_RDisk(); void save(); signals: void moChannelChanged(); - void zipChannelChanged(); + void rdiskChannelChanged(); private slots: void onMORowChanged(const QModelIndex ¤t); @@ -29,16 +29,16 @@ private slots: void on_comboBoxMOChannel_activated(int index); void on_comboBoxMOType_activated(int index); - void onZIPRowChanged(const QModelIndex ¤t); - void on_comboBoxZIPBus_currentIndexChanged(int index); - void on_comboBoxZIPBus_activated(int index); - void on_comboBoxZIPChannel_activated(int index); - void on_checkBoxZIP250_stateChanged(int arg1); + void onRDiskRowChanged(const QModelIndex ¤t); + void on_comboBoxRDiskBus_currentIndexChanged(int index); + void on_comboBoxRDiskBus_activated(int index); + void on_comboBoxRDiskChannel_activated(int index); + void on_comboBoxRDiskType_activated(int index); private: Ui::SettingsOtherRemovable *ui; void enableCurrentlySelectedChannel_MO(); - void enableCurrentlySelectedChannel_ZIP(); + void enableCurrentlySelectedChannel_RDisk(); }; #endif // QT_SETTINGSOTHERREMOVABLE_HPP diff --git a/src/qt/qt_settingsotherremovable.ui b/src/qt/qt_settingsotherremovable.ui index ae7839e54..6a5d509a9 100644 --- a/src/qt/qt_settingsotherremovable.ui +++ b/src/qt/qt_settingsotherremovable.ui @@ -113,14 +113,14 @@ - + - ZIP drives: + Removable disk drives: - + 0 @@ -151,40 +151,47 @@ - + - + Bus: - + 30 - + Channel: - + 30 - - + + - ZIP 250 + Type: + + + + + + + 30 diff --git a/src/qt/qt_ui.cpp b/src/qt/qt_ui.cpp index 337b438f3..d4a257887 100644 --- a/src/qt/qt_ui.cpp +++ b/src/qt/qt_ui.cpp @@ -50,7 +50,7 @@ extern "C" { #include <86box/cartridge.h> #include <86box/cassette.h> #include <86box/cdrom.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/mo.h> #include <86box/hdd.h> #include <86box/thread.h> @@ -278,8 +278,8 @@ ui_sb_update_icon_wp(int tag, int state) case SB_FLOPPY: machine_status.fdd[item].write_prot = state > 0 ? true : false; break; - case SB_ZIP: - machine_status.zip[item].write_prot = state > 0 ? true : false; + case SB_RDISK: + machine_status.rdisk[item].write_prot = state > 0 ? true : false; break; case SB_MO: machine_status.mo[item].write_prot = state > 0 ? true : false; @@ -312,8 +312,8 @@ ui_sb_update_icon_state(int tag, int state) case SB_CDROM: machine_status.cdrom[item].empty = state > 0 ? true : false; break; - case SB_ZIP: - machine_status.zip[item].empty = state > 0 ? true : false; + case SB_RDISK: + machine_status.rdisk[item].empty = state > 0 ? true : false; break; case SB_MO: machine_status.mo[item].empty = state > 0 ? true : false; @@ -350,8 +350,8 @@ ui_sb_update_icon(int tag, int active) case SB_CDROM: machine_status.cdrom[item].active = active > 0 ? true : false; break; - case SB_ZIP: - machine_status.zip[item].active = active > 0 ? true : false; + case SB_RDISK: + machine_status.rdisk[item].active = active > 0 ? true : false; break; case SB_MO: machine_status.mo[item].active = active > 0 ? true : false; @@ -386,8 +386,8 @@ ui_sb_update_icon_write(int tag, int write) case SB_CDROM: machine_status.cdrom[item].write_active = write > 0 ? true : false; break; - case SB_ZIP: - machine_status.zip[item].write_active = write > 0 ? true : false; + case SB_RDISK: + machine_status.rdisk[item].write_active = write > 0 ? true : false; break; case SB_MO: machine_status.mo[item].write_active = write > 0 ? true : false; diff --git a/src/qt_resources.qrc b/src/qt_resources.qrc index f0ea8d945..01bbc866a 100644 --- a/src/qt_resources.qrc +++ b/src/qt_resources.qrc @@ -1,6 +1,5 @@ - qt/icons/browse.ico qt/icons/cartridge.ico qt/icons/cartridge_image.ico qt/icons/cassette_image.ico @@ -13,8 +12,6 @@ qt/icons/cdrom_folder.ico qt/icons/cdrom_host.ico qt/icons/display.ico - qt/icons/eject.ico - qt/icons/export.ico qt/icons/fast_forward.ico qt/icons/floppy_35.ico qt/icons/floppy_35_image.ico @@ -29,10 +26,12 @@ qt/icons/mo_image.ico qt/icons/mo_disabled.ico qt/icons/network.ico - qt/icons/new.ico qt/icons/other_peripherals.ico qt/icons/other_removable_devices.ico qt/icons/ports.ico + qt/icons/rdisk.ico + qt/icons/rdisk_image.ico + qt/icons/rdisk_disabled.ico qt/icons/record.ico qt/icons/rewind.ico qt/icons/sound.ico @@ -40,10 +39,11 @@ qt/icons/superdisk.ico qt/icons/superdisk_image.ico qt/icons/superdisk_disabled.ico - qt/icons/zip.ico - qt/icons/zip_image.ico - qt/icons/zip_disabled.ico qt/icons/active.ico + qt/icons/browse.ico + qt/icons/eject.ico + qt/icons/export.ico + qt/icons/new.ico qt/icons/write_protected.ico qt/icons/write_active.ico qt/icons/disabled.ico diff --git a/src/scsi/scsi.c b/src/scsi/scsi.c index 0b0ca7211..a2bdc92ce 100644 --- a/src/scsi/scsi.c +++ b/src/scsi/scsi.c @@ -33,7 +33,7 @@ #include <86box/scsi.h> #include <86box/scsi_device.h> #include <86box/cdrom.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/scsi_disk.h> #include <86box/scsi_aha154x.h> #include <86box/scsi_buslogic.h> diff --git a/src/unix/unix.c b/src/unix/unix.c index cfd5d9244..5bd7eac46 100644 --- a/src/unix/unix.c +++ b/src/unix/unix.c @@ -1006,12 +1006,12 @@ monitor_thread(UNUSED(void *param)) printf( "fddload - Load floppy disk image into drive .\n" "cdload - Load CD-ROM image into drive .\n" - "zipload - Load ZIP image into ZIP drive .\n" + "rdiskload - Load removable disk image into removable disk drive .\n" "cartload - Load cartridge image into cartridge drive .\n" "moload - Load MO image into MO drive .\n\n" "fddeject - eject disk from floppy drive .\n" "cdeject - eject disc from CD-ROM drive .\n" - "zipeject - eject ZIP image from ZIP drive .\n" + "rdiskeject - eject removable disk image from removable disk drive .\n" "carteject - eject cartridge from drive .\n" "moeject - eject image from MO drive .\n\n" "hardreset - hard reset the emulated system.\n" @@ -1116,8 +1116,8 @@ monitor_thread(UNUSED(void *param)) mo_eject(atoi(xargv[1])); } else if (strncasecmp(xargv[0], "carteject", 8) == 0 && cmdargc >= 2) { cartridge_eject(atoi(xargv[1])); - } else if (strncasecmp(xargv[0], "zipeject", 8) == 0 && cmdargc >= 2) { - zip_eject(atoi(xargv[1])); + } else if (strncasecmp(xargv[0], "rdiskeject", 8) == 0 && cmdargc >= 2) { + rdisk_eject(atoi(xargv[1])); } else if (strncasecmp(xargv[0], "fddload", 7) == 0 && cmdargc >= 4) { uint8_t id; uint8_t wp; @@ -1184,7 +1184,7 @@ monitor_thread(UNUSED(void *param)) printf("Inserting tape into cartridge holder %hhu: %s\n", id, fn); cartridge_mount(id, fn, wp); } - } else if (strncasecmp(xargv[0], "zipload", 7) == 0 && cmdargc >= 4) { + } else if (strncasecmp(xargv[0], "rdiskload", 7) == 0 && cmdargc >= 4) { uint8_t id; uint8_t wp; bool err = false; @@ -1203,8 +1203,8 @@ monitor_thread(UNUSED(void *param)) if (fn[strlen(fn) - 1] == '\'' || fn[strlen(fn) - 1] == '"') fn[strlen(fn) - 1] = '\0'; - printf("Inserting disk into ZIP drive %c: %s\n", id + 'A', fn); - zip_mount(id, fn, wp); + printf("Inserting disk into removable disk drive %c: %s\n", id + 'A', fn); + rdisk_mount(id, fn, wp); } } free(line); diff --git a/src/unix/unix_cdrom.c b/src/unix/unix_cdrom.c index b1096b0b4..09aaa5092 100644 --- a/src/unix/unix_cdrom.c +++ b/src/unix/unix_cdrom.c @@ -6,7 +6,7 @@ * * This file is part of the 86Box distribution. * - * Handle the platform-side of CDROM/ZIP/MO drives. + * Handle the platform-side of CDROM/RDisk/MO drives. * * * @@ -34,7 +34,7 @@ #include <86box/cdrom.h> #include <86box/cdrom_image.h> #include <86box/mo.h> -#include <86box/zip.h> +#include <86box/rdisk.h> #include <86box/scsi_disk.h> #include <86box/plat.h> #include <86box/ui.h> @@ -220,58 +220,58 @@ mo_reload(uint8_t id) } void -zip_eject(uint8_t id) +rdisk_eject(uint8_t id) { - zip_t *dev = (zip_t *) zip_drives[id].priv; + rdisk_t *dev = (rdisk_t *) rdisk_drives[id].priv; - zip_disk_close(dev); - if (zip_drives[id].bus_type) { + rdisk_disk_close(dev); + if (rdisk_drives[id].bus_type) { /* Signal disk change to the emulated machine. */ - zip_insert(dev); + rdisk_insert(dev); } - ui_sb_update_icon_state(SB_ZIP | id, 1); + ui_sb_update_icon_state(SB_RDISK | id, 1); #if 0 - media_menu_update_zip(id); + media_menu_update_rdisk(id); #endif - ui_sb_update_tip(SB_ZIP | id); + ui_sb_update_tip(SB_RDISK | id); config_save(); } void -zip_mount(uint8_t id, char *fn, uint8_t wp) +rdisk_mount(uint8_t id, char *fn, uint8_t wp) { - zip_t *dev = (zip_t *) zip_drives[id].priv; + rdisk_t *dev = (rdisk_t *) rdisk_drives[id].priv; - zip_disk_close(dev); - zip_drives[id].read_only = wp; - zip_load(dev, fn, 0); + rdisk_disk_close(dev); + rdisk_drives[id].read_only = wp; + rdisk_load(dev, fn, 0); - ui_sb_update_icon_state(SB_ZIP | id, strlen(zip_drives[id].image_path) ? 0 : 1); + ui_sb_update_icon_state(SB_RDISK | id, strlen(rdisk_drives[id].image_path) ? 0 : 1); #if 0 - media_menu_update_zip(id); + media_menu_update_rdisk(id); #endif - ui_sb_update_tip(SB_ZIP | id); + ui_sb_update_tip(SB_RDISK | id); config_save(); } void -zip_reload(uint8_t id) +rdisk_reload(uint8_t id) { - zip_t *dev = (zip_t *) zip_drives[id].priv; + rdisk_t *dev = (rdisk_t *) rdisk_drives[id].priv; - zip_disk_reload(dev); - if (strlen(zip_drives[id].image_path) == 0) { - ui_sb_update_icon_state(SB_ZIP | id, 1); + rdisk_disk_reload(dev); + if (strlen(rdisk_drives[id].image_path) == 0) { + ui_sb_update_icon_state(SB_RDISK | id, 1); } else { - ui_sb_update_icon_state(SB_ZIP | id, 0); + ui_sb_update_icon_state(SB_RDISK | id, 0); } #if 0 - media_menu_update_zip(id); + media_menu_update_rdisk(id); #endif - ui_sb_update_tip(SB_ZIP | id); + ui_sb_update_tip(SB_RDISK | id); config_save(); }