diff --git a/src/cdrom/CMakeLists.txt b/src/cdrom/CMakeLists.txt index 621b069b0..7e18a72a0 100644 --- a/src/cdrom/CMakeLists.txt +++ b/src/cdrom/CMakeLists.txt @@ -23,6 +23,7 @@ add_library(cdrom OBJECT cdrom.c cdrom_image.c cdrom_image_viso.c + cdrom_mke.c ) target_link_libraries(86Box PkgConfig::SNDFILE) diff --git a/src/cdrom/cdrom.c b/src/cdrom/cdrom.c index 59ea13905..7e1791771 100644 --- a/src/cdrom/cdrom.c +++ b/src/cdrom/cdrom.c @@ -32,6 +32,7 @@ #ifdef USE_CDROM_MITSUMI #include <86box/cdrom_mitsumi.h> #endif +#include <86box/cdrom_mke.h> #include <86box/log.h> #include <86box/plat.h> #include <86box/plat_cdrom_ioctl.h> @@ -119,11 +120,12 @@ static const struct { const device_t *device; } controllers[] = { // clang-format off - { &cdrom_interface_none_device }, + { &cdrom_interface_none_device }, #ifdef USE_CDROM_MITSUMI - { &mitsumi_cdrom_device }, + { &mitsumi_cdrom_device }, #endif - { NULL } + { &mke_cdrom_device }, + { NULL } // clang-format on }; diff --git a/src/cdrom/cdrom_mke.c b/src/cdrom/cdrom_mke.c new file mode 100644 index 000000000..f57df031c --- /dev/null +++ b/src/cdrom/cdrom_mke.c @@ -0,0 +1,880 @@ +/* + * 86Box A hypervisor and IBM PC system emulator that specializes in + * running old operating systems and software designed for IBM + * PC systems and compatibles from 1981 through fairly recent + * system designs based on the PCI bus. + * + * This file is part of the 86Box distribution. + * + * Panasonic/MKE CD-ROM emulation for the ISA bus. + * + * Authors: Miran Grca, + * Kevin Moonlight, + * Cacodemon345 + * + * Copyright (C) 2025 Miran Grca. + * Copyright (C) 2025 Cacodemon345. + * Copyright (C) 2024 Kevin Moonlight. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#define HAVE_STDARG_H +#include <86box/86box.h> +#include <86box/device.h> +#include <86box/io.h> +#include <86box/pic.h> +#include <86box/dma.h> +#include <86box/cdrom.h> +#include <86box/cdrom_interface.h> +#include <86box/cdrom_mke.h> +#include <86box/plat.h> +#include <86box/ui.h> +#include <86box/sound.h> +#include <86box/fifo8.h> +#include <86box/timer.h> + +/* +https://elixir.bootlin.com/linux/2.0.29/source/include/linux/sbpcd.h +CR-562-B is classified as Family1 in this driver, so uses the CMD1_ prefix. +*/ +#define CDROM_STATUS_DOOR 0x80 +#define CDROM_STATUS_DISC_IN 0x40 +#define CDROM_STATUS_SPIN_UP 0x20 +#define CDROM_STATUS_ERROR 0x10 +#define CDROM_STATUS_DOUBLE_SPEED 0x02 +#define CDROM_STATUS_READY 0x01 + +// Status returned from device +#define STAT_READY 0x01 +#define STAT_PLAY 0x08 +#define STAT_ERROR 0x10 +#define STAT_DISK 0x40 +#define STAT_TRAY 0x80 // Seems Correct + +#define CMD1_PAUSERESUME 0x0D +#define CMD1_RESET 0x0a +#define CMD1_LOCK_CTL 0x0c +#define CMD1_TRAY_CTL 0x07 +#define CMD1_MULTISESS 0x8d +#define CMD1_SUBCHANINF 0x11 +#define CMD1_ABORT 0x08 +// #define CMD1_PATH_CHECK 0x??? +#define CMD1_SEEK 0x01 +#define CMD1_READ 0x10 +#define CMD1_SPINUP 0x02 +#define CMD1_SPINDOWN 0x06 +#define CMD1_READ_UPC 0x88 +// #define CMD1_PLAY 0x??? +#define CMD1_PLAY_MSF 0x0e +#define CMD1_PLAY_TI 0x0f +#define CMD1_STATUS 0x05 +#define CMD1_READ_ERR 0x82 +#define CMD1_READ_VER 0x83 +#define CMD1_SETMODE 0x09 +#define CMD1_GETMODE 0x84 +#define CMD1_CAPACITY 0x85 +#define CMD1_READSUBQ 0x87 +#define CMD1_DISKINFO 0x8b +#define CMD1_READTOC 0x8c +#define CMD1_PAU_RES 0x0d +#define CMD1_PACKET 0x8e +#define CMD1_SESSINFO 0x8d + +typedef struct mke_t { + bool tray_open; + + uint8_t enable_register; + + uint8_t command_buffer[7]; + uint8_t command_buffer_pending; + + uint8_t vol0, vol1, patch0, patch1; + uint8_t mode_select[5]; + + uint8_t data_select; + + uint8_t media_selected; // temporary hack + + Fifo8 data_fifo; + Fifo8 info_fifo; + Fifo8 errors_fifo; + + cdrom_t *cdrom_dev; + + uint32_t sector_type; + uint32_t sector_flags; + + uint32_t unit_attention; + + uint8_t cdbuffer[624240 * 2]; + + uint32_t data_to_push; + + pc_timer_t timer; +} mke_t; +mke_t mke; + +#define mke_log(x, ...) + +#define CHECK_READY() \ + { \ + if (mke.cdrom_dev->cd_status == CD_STATUS_EMPTY) { \ + fifo8_push(&mke.errors_fifo, 0x03); \ + return; \ + } \ + } + +static uint8_t temp_buf[65536]; + +void +mke_get_subq(cdrom_t *dev, uint8_t *b) +{ +#if 0 + dev->ops->get_subchannel(dev, dev->seek_pos, &subc); + cdrom_get_current_subchannel(dev, &subc); + cdrom_get_current_subcodeq(dev, b); +#endif + cdrom_get_current_subchannel_sony(dev, temp_buf, 1); + b[0] = 0x80; //? + b[1] = ((temp_buf[0] & 0xf) << 4) | ((temp_buf[0] & 0xf0) >> 4); + b[2] = temp_buf[1]; + b[3] = temp_buf[2]; + b[4] = temp_buf[6]; + b[5] = temp_buf[7]; + b[6] = temp_buf[8]; + b[7] = temp_buf[3]; + b[8] = temp_buf[4]; + b[9] = temp_buf[5]; + b[10] = 0; //?? + pclog("mke_get_subq: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n", b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10]); +} + +// Lifted from FreeBSD + +static void blk_to_msf(int blk, unsigned char *msf) +{ + blk = blk + 150; /*2 seconds skip required to + reach ISO data*/ + msf[0] = blk / 4500; + blk = blk % 4500; + msf[1] = blk / 75; + msf[2] = blk % 75; + return; +} + +uint8_t mke_read_toc(cdrom_t *dev, unsigned char *b, uint8_t track) { + track_info_t ti; + int last_track; + cdrom_read_toc(dev, temp_buf, CD_TOC_NORMAL, 0, 0, 65536); + last_track = temp_buf[3]; + if(track > last_track) return 0; //should we allow +1 here? + dev->ops->get_track_info(dev->local, track, 0, &ti); + b[0]=0; + b[1]=ti.attr; + b[2]=ti.number; + b[3]=0; + b[4]=ti.m; + b[5]=ti.s; + b[6]=ti.f; + b[7]=0; + pclog("mke_read_toc: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n", b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]); + return 1; +} + + +uint8_t +mke_disc_info(cdrom_t *dev, unsigned char *b) +{ + uint8_t disc_type_buf[34]; + int first_track; + int last_track; + cdrom_read_toc(dev, temp_buf, CD_TOC_NORMAL, 0, 2 << 8, 65536); + cdrom_read_disc_information(dev, disc_type_buf); + first_track = temp_buf[2]; + last_track = temp_buf[3]; + // dev->ops->get_track_info(dev, last_track + 1, 0, &ti); + b[0] = disc_type_buf[8]; + b[1] = first_track; + b[2] = last_track; + b[3] = 0; + b[4] = 0; + b[5] = 0; + blk_to_msf(dev->cdrom_capacity, &b[3]); + pclog("mke_disc_info: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n", b[0], b[1], b[2], b[3], b[4], b[5]); + return 1; +} + +uint8_t +mke_disc_capacity(cdrom_t *dev, unsigned char *b) +{ + track_info_t ti; + int last_track; + // dev->ops->get_tracks(dev, &first_track, &last_track); + cdrom_read_toc(dev, temp_buf, CD_TOC_NORMAL, 0, 2 << 8, 65536); + last_track = temp_buf[3]; + dev->ops->get_track_info(dev, last_track + 1, 0, &ti); + b[0] = ti.m; + b[1] = ti.s; + b[2] = ti.f - 1; // TODO THIS NEEDS TO HANDLE FRAME 0, JUST BEING LAZY 6AM + b[3] = 0x08; + b[4] = 0x00; + + blk_to_msf(dev->cdrom_capacity, &b[0]); + pclog("mke_disc_capacity: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n", b[0], b[1], b[2], b[3], b[4]); + return 1; +} + +uint8_t +mke_cdrom_status(cdrom_t *dev, mke_t *mke) +{ + uint8_t status = 0; + status |= 2; // this bit seems to always be set? + // bit 4 never set? + if (dev->cd_status == CD_STATUS_PLAYING) + status |= STAT_PLAY; + if (dev->cd_status == CD_STATUS_PAUSED) + status |= STAT_PLAY; + if (fifo8_num_used(&mke->errors_fifo)) + status |= 0x10; + status |= 0x20; // always set? + status |= STAT_TRAY; + if (mke->cdrom_dev->cd_status != CD_STATUS_EMPTY) { + status |= STAT_DISK; + status |= STAT_READY; + } + + return status; +} + +void +mke_read_multisess(void) +{ + int len = cdrom_read_toc(mke.cdrom_dev, temp_buf, CD_TOC_SESSION, 0, 1, 65536); + if (temp_buf[9] != 0 || temp_buf[10] != 0 || temp_buf[11] != 0) { + /* Multi-session disc. */ + fifo8_push(&mke.info_fifo, 0x80); + fifo8_push(&mke.info_fifo, temp_buf[9]); + fifo8_push(&mke.info_fifo, temp_buf[10]); + fifo8_push(&mke.info_fifo, temp_buf[11]); + fifo8_push(&mke.info_fifo, 0); + fifo8_push(&mke.info_fifo, 0); + } else { + uint8_t no_multisess[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + fifo8_push_all(&mke.info_fifo, no_multisess, 6); + } +} + +uint8_t ver[10] = "CR-5630.75"; + +static void +mke_reset(void) +{ + cdrom_stop(mke.cdrom_dev); + timer_disable(&mke.timer); + mke.sector_type = 0x08 | (1 << 4); + mke.sector_flags = 0x10; + memset(mke.mode_select, 0, 5); + mke.mode_select[2] = 0x08; + mke.patch0 = 0x01; + mke.patch1 = 0x02; + mke.vol0 = 255; + mke.vol1 = 255; + mke.cdrom_dev->sector_size = 2048; +} + +void +mke_command_callback(void* priv) +{ + switch (mke.command_buffer[0]) { + case CMD1_SEEK: { + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + } + case CMD1_READ: { + fifo8_push_all(&mke.data_fifo, mke.cdbuffer, mke.data_to_push); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + mke.data_to_push = 0; + ui_sb_update_icon(SB_CDROM | mke.cdrom_dev->id, 0); + break; + } + } +} + +void +mke_command(uint8_t value) +{ + uint16_t i; + uint8_t x[12]; // this is wasteful handling of buffers for compatibility, but will optimize later. + int old_cd_status; + + if (mke.command_buffer_pending) { + mke.command_buffer[6 - mke.command_buffer_pending + 1] = value; + mke.command_buffer_pending--; + } + + if (mke.command_buffer[0] == CMD1_ABORT) { + mke_log("CMD_ABORT\n"); + // fifo8_reset(&mke.info_fifo); + fifo8_reset(&mke.info_fifo); + fifo8_reset(&mke.data_fifo); + timer_disable(&mke.timer); + mke.command_buffer[0] = 0; + mke.command_buffer_pending = 7; + // fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + } + + if (!mke.command_buffer_pending && mke.command_buffer[0]) { + mke.command_buffer_pending = 7; + pclog("mke_command: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n", mke.command_buffer[0], mke.command_buffer[1], mke.command_buffer[2], mke.command_buffer[3], mke.command_buffer[4], mke.command_buffer[5], mke.command_buffer[6]); + switch (mke.command_buffer[0]) { + case 06: + { + fifo8_reset(&mke.info_fifo); + cdrom_stop(mke.cdrom_dev); + cdrom_eject(mke.cdrom_dev->id); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + } + case 07: + { + fifo8_reset(&mke.info_fifo); + cdrom_reload(mke.cdrom_dev->id); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + } + case CMD1_RESET: + { + mke_reset(); + break; + } + case CMD1_READ: + { + uint32_t count = mke.command_buffer[6]; + uint8_t *buf = mke.cdbuffer; + int res = 0; + uint64_t lba = MSFtoLBA(mke.command_buffer[1], mke.command_buffer[2], mke.command_buffer[3]) - 150; + int len __attribute__((unused)) = 0; + CHECK_READY(); + mke.data_to_push = 0; + while (count) { + if ((res = cdrom_readsector_raw(mke.cdrom_dev, buf, lba, 0, mke.sector_type, mke.sector_flags, &len, 0)) > 0) { + //fifo8_push_all(&mke.data_fifo, buf, mke.cdrom_dev->sector_size); + lba++; + buf += mke.cdrom_dev->sector_size; + mke.data_to_push += mke.cdrom_dev->sector_size; + } else { + fifo8_push(&mke.errors_fifo, res == 0 ? 0x10 : 0x05); + break; + } + count--; + } + if (count != 0) { + fifo8_reset(&mke.data_fifo); + mke.data_to_push = 0; + } else { + //fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + ui_sb_update_icon(SB_CDROM | mke.cdrom_dev->id, 1); + timer_on_auto(&mke.timer, (1000000.0 / (176400.0 * 2.)) * mke.data_to_push); + } + break; + } + case CMD1_READSUBQ: + CHECK_READY(); + mke_get_subq(mke.cdrom_dev, (uint8_t *) &x); + fifo8_reset(&mke.info_fifo); + // fifo8_push_all(&cdrom.info_fifo, x, 11); + fifo8_push_all(&mke.info_fifo, x, 11); +#if 0 + for (i=0; i < 11; i++) { + cdrom_fifo_write(&cdrom.info_fifo,x[i]); + } +#endif + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_SETMODE: // Returns 1 + fifo8_reset(&mke.info_fifo); + mke_log("CMD: SET MODE:"); + for (i = 0; i < 6; i++) { + mke_log("%02x ", mke.command_buffer[i + 1]); + } + mke_log("\n"); + switch (mke.command_buffer[1]) { + case 0: + { + switch (mke.command_buffer[2]) { + case 0x00: /* Cooked */ { + mke.sector_type = 0x08 | (1 << 4); + mke.sector_flags = 0x10; + mke.cdrom_dev->sector_size = 2048; + break; + } + case 0x81: /* XA */ + case 0x01: /* User */ { + uint32_t sector_size = (mke.command_buffer[3] << 8) | mke.command_buffer[4]; + if (!sector_size) { + fifo8_push(&mke.errors_fifo, 0x0e); + return; + } else { + switch (sector_size) { + case 2048: { + mke.sector_type = 0x08 | (1 << 4); + mke.sector_flags = 0x10; + mke.cdrom_dev->sector_size = 2048; + break; + } + case 2052: { + mke.sector_type = 0x18; + mke.sector_flags = 0x30; + mke.cdrom_dev->sector_size = 2052; + break; + } + case 2324: { + mke.sector_type = 0x1b; + mke.sector_flags = 0x18; + mke.cdrom_dev->sector_size = 2324; + break; + } + case 2336: { + mke.sector_type = 0x1c; + mke.sector_flags = 0x58; + mke.cdrom_dev->sector_size = 2336; + break; + } + case 2340: { + mke.sector_type = 0x18; + mke.sector_flags = 0x78; + mke.cdrom_dev->sector_size = 2340; + break; + } + case 2352: { + mke.sector_type = 0x00; + mke.sector_flags = 0xf8; + mke.cdrom_dev->sector_size = 2352; + break; + } + default: { + fifo8_push(&mke.errors_fifo, 0x0e); + return; + } + } + } + } + case 0x82: /* DA */ { + mke.sector_type = 0x00; + mke.sector_flags = 0xf8; + mke.cdrom_dev->sector_size = 2352; + break; + } + default: { + fifo8_push(&mke.errors_fifo, 0x0e); + return; + } + } + + memcpy(mke.mode_select, &mke.command_buffer[2], 5); + } + case 5: { + mke.vol0 = mke.command_buffer[4]; + mke.vol1 = mke.command_buffer[6]; + mke.patch0 = mke.command_buffer[3]; + mke.patch1 = mke.command_buffer[5]; + break; + } + } + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_GETMODE: // 6 + mke_log("GET MODE\n"); + if (mke.command_buffer[1] == 5) { + uint8_t volsettings[5] = { 0, mke.patch0, mke.vol0, mke.patch1, mke.vol1 }; + fifo8_push_all(&mke.info_fifo, volsettings, 5); + } + else + fifo8_push_all(&mke.info_fifo, mke.mode_select, 5); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_PAUSERESUME: + CHECK_READY(); + cdrom_audio_pause_resume(mke.cdrom_dev, mke.command_buffer[1] >> 7); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_CAPACITY: // 6 + mke_log("DISK CAPACITY\n"); + CHECK_READY(); + mke_disc_capacity(mke.cdrom_dev, (uint8_t *) &x); + // fifo8_push_all(&cdrom.info_fifo, x, 5); + fifo8_push_all(&mke.info_fifo, x, 5); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_DISKINFO: // 7 + mke_log("DISK INFO\n"); + CHECK_READY(); + mke_disc_info(mke.cdrom_dev, (uint8_t *) &x); + fifo8_push_all(&mke.info_fifo, x, 6); +#if 0 + for (i=0; i<6; i++) { + mke_log("%02x ",x[i]); + cdrom_fifo_write(&cdrom.info_fifo,x[i]); + } + mke_log("\n"); +#endif + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_READTOC: + CHECK_READY(); + fifo8_reset(&mke.info_fifo); +#if 0 + mke_log("READ TOC:"); + for (i=0; i<6; i++) { + mke_log("%02x ",mke.command_buffer[i+1]); + } + mke_log(" | "); +#endif + mke_read_toc(mke.cdrom_dev, (uint8_t *) &x, mke.command_buffer[2]); + fifo8_push_all(&mke.info_fifo, x, 8); +#if 0 + for (i=0; i<8; i++) { + mke_log("%02x ",x[i]); + cdrom_fifo_write(&cdrom.info_fifo,x[i]); + } + mke_log("\n"); +#endif + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_PLAY_TI: + { + CHECK_READY(); + /* Index is ignored for now. */ + fifo8_reset(&mke.info_fifo); + if (!cdrom_audio_play(mke.cdrom_dev, mke.command_buffer[1], mke.command_buffer[3], 2)) { + fifo8_push(&mke.errors_fifo, 0x0E); + fifo8_push(&mke.errors_fifo, 0x10); + } else { + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + } + break; + } + case CMD1_PLAY_MSF: + CHECK_READY(); + fifo8_reset(&mke.info_fifo); + mke_log("PLAY MSF:"); + for (i = 0; i < 6; i++) { + mke_log("%02x ", mke.command_buffer[i + 1]); + } + mke_log("\n"); +#if 0 + cdrom_audio_playmsf(&cdrom, + mke.command_buffer[1], + mke.command_buffer[2], + mke.command_buffer[3], + mke.command_buffer[4], + mke.command_buffer[5], + mke.command_buffer[6] + ); +#endif + { + int msf = 1; + int pos = (mke.command_buffer[1] << 16) | (mke.command_buffer[2] << 8) | mke.command_buffer[3]; + int len = (mke.command_buffer[4] << 16) | (mke.command_buffer[5] << 8) | mke.command_buffer[6]; + if (!cdrom_audio_play(mke.cdrom_dev, pos, len, msf)) { + fifo8_push(&mke.errors_fifo, 0x0E); + fifo8_push(&mke.errors_fifo, 0x10); + } else { + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + } + } + break; + case CMD1_SEEK: + CHECK_READY(); + old_cd_status = mke.cdrom_dev->cd_status; + fifo8_reset(&mke.info_fifo); + mke_log("SEEK MSF:"); // TODO: DOES THIS IMPACT CURRENT PLAY LENGTH? + for (i = 0; i < 6; i++) { + mke_log("%02x ", mke.command_buffer[i + 1]); + } + + cdrom_stop(mke.cdrom_dev); + /* Note for self: Panasonic/MKE drives send seek commands in MSF format. */ + cdrom_seek(mke.cdrom_dev, MSFtoLBA(mke.command_buffer[1], mke.command_buffer[2], mke.command_buffer[3]) - 150, 0); + if (old_cd_status == CD_STATUS_PLAYING || old_cd_status == CD_STATUS_PAUSED) { + cdrom_audio_play(mke.cdrom_dev, mke.cdrom_dev->seek_pos, -1, 0); + cdrom_audio_pause_resume(mke.cdrom_dev, old_cd_status == CD_STATUS_PLAYING); + } + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_SESSINFO: + CHECK_READY(); + fifo8_reset(&mke.info_fifo); + mke_log("CMD: READ SESSION INFO\n"); + mke_read_multisess(); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_READ_UPC: + CHECK_READY(); + fifo8_reset(&mke.info_fifo); + mke_log("CMD: READ UPC\n"); + uint8_t upc[8] = { [0] = 80 }; + fifo8_push_all(&mke.info_fifo, upc, 8); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_READ_ERR: + fifo8_reset(&mke.info_fifo); + mke_log("CMD: READ ERR\n"); + // cdrom_read_errors(&cdrom,(uint8_t *)x); + memset(x, 0, 8); + if (fifo8_num_used(&mke.errors_fifo)) { + fifo8_pop_buf(&mke.errors_fifo, x, fifo8_num_used(&mke.errors_fifo)); + } + fifo8_push_all(&mke.info_fifo, x, 8); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + fifo8_reset(&mke.errors_fifo); + break; + case CMD1_READ_VER: + /* + SB2CD Expects 12 bytes, but drive only returns 11. + */ + fifo8_reset(&mke.info_fifo); + // pclog("CMD: READ VER\n"); + fifo8_push_all(&mke.info_fifo, ver, 10); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + case CMD1_STATUS: + fifo8_reset(&mke.info_fifo); + fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke)); + break; + default: + mke_log("MKE: Unknown Commnad [%02x]\n", mke.command_buffer[0]); + } + } else if (!mke.command_buffer_pending) { // we are done byt not in a command. should we make sure it is a valid command here? + mke.command_buffer[0] = value; + mke.command_buffer_pending = 6; + } +} + +void +mke_write(uint16_t address, uint8_t value, void *priv) +{ + //pclog("MKEWRITE: 0x%X, 0x%02X\n", address & 0xf, value); + if (mke.enable_register && ((address & 0xF) != 3)) { + // mke_log("Ignore Write Unit %u\n",mke.enable_register); + return; + } + // mke_log("MKE WRITE: %02x => %03x\n",value,address); + switch (address & 0xF) { + case 0: + mke_command(value); + break; + case 1: + mke.data_select = value; + break; + case 2: + mke_reset(); + break; + case 3: + mke.enable_register = value; + break; + default: + pclog("w %03x %02x\n", address, value); + break; + } +} + +uint8_t +mke_read(uint16_t address, void *priv) +{ + uint8_t x; + if (mke.enable_register) { + // pclog("Ignore Read Unit %u\n",mke.enable_register); + return 0; + } + // pclog("MKEREAD: 0x%X\n", address & 0xf); + switch (address & 0xF) { + case 0: // Info + if (mke.data_select) { + x = fifo8_num_used(&mke.data_fifo) ? fifo8_pop(&mke.data_fifo) : 0; // cdrom_fifo_read(&cdrom.data_fifo); + } else { + x = fifo8_num_used(&mke.info_fifo) ? fifo8_pop(&mke.info_fifo) : 0; + // return cdrom_fifo_read(&cdrom.info_fifo); + } + // pclog("Read FIFO 0x%X, %d\n", x, mke.data_select); + return x; + break; + case 1: // Status + /* + 1 = Status Change + 2 = Data Ready + 4 = Response Ready + 8 = Attention / Issue ? + */ + x = 0xFF; + // if(cdrom.media_changed) x ^= 1; + if (fifo8_num_used(&mke.data_fifo)) + x ^= 2; // DATA FIFO + if (fifo8_num_used(&mke.info_fifo)) + x ^= 4; // STATUS FIFO + if (fifo8_num_used(&mke.errors_fifo)) + x ^= 8; + return x; + break; + case 2: // Data + return fifo8_num_used(&mke.data_fifo) ? fifo8_pop(&mke.data_fifo) : 0; + case 3: + return mke.enable_register; + break; + default: + /* mke_log("MKE Unknown Read Address: %03x\n",address); */ + pclog("MKE Unknown Read Address: %03x\n", address); + break; + } + return 0xff; +} + +void +mke_close(void *priv) +{ + fifo8_destroy(&mke.info_fifo); + fifo8_destroy(&mke.data_fifo); + fifo8_destroy(&mke.errors_fifo); + timer_disable(&mke.timer); +} + +static void +mke_cdrom_insert(void *priv) +{ + mke_t *dev = (mke_t *) priv; + + if ((dev == NULL) || (dev->cdrom_dev == NULL)) + return; + + if (dev->cdrom_dev->ops == NULL) { + // dev->unit_attention = 0; + dev->cdrom_dev->cd_status = CD_STATUS_EMPTY; + if (timer_is_enabled(&dev->timer)) { + timer_disable(&dev->timer); + mke.data_to_push = 0; + fifo8_push(&dev->errors_fifo, 0x15); + } + fifo8_push(&dev->errors_fifo, 0x11); + } else { + // dev->unit_attention = 1; + /* Turn off the medium changed status. */ + dev->cdrom_dev->cd_status &= ~CD_STATUS_TRANSITION; + fifo8_push(&dev->errors_fifo, 0x11); + } +} + +uint32_t +mke_get_volume(void *priv, int channel) +{ + return channel == 0 ? mke.vol0 : mke.vol1; +} + +uint32_t +mke_get_channel(void *priv, int channel) +{ + return channel == 0 ? mke.patch0 : mke.patch1; +} + +void * +mke_init(const device_t *info) +{ + cdrom_t *dev = NULL; + memset(&mke, 0, sizeof(mke_t)); + + for (uint8_t i = 0; i < CDROM_NUM; i++) { + if (cdrom[i].bus_type == CDROM_BUS_MKE) { + dev = &cdrom[i]; + break; + } + } + + if (!dev) + return NULL; + + fifo8_create(&mke.info_fifo, 128); + fifo8_create(&mke.data_fifo, 624240 * 2); + fifo8_create(&mke.errors_fifo, 8); + fifo8_reset(&mke.info_fifo); + fifo8_reset(&mke.data_fifo); + fifo8_reset(&mke.errors_fifo); + mke.cdrom_dev = dev; + mke.command_buffer_pending = 7; + mke.sector_type = 0x08 | (1 << 4); + mke.sector_flags = 0x10; + mke.mode_select[2] = 0x08; + mke.patch0 = 0x01; + mke.patch1 = 0x02; + mke.vol0 = 255; + mke.vol1 = 255; + dev->sector_size = 2048; + + dev->priv = &mke; + dev->insert = mke_cdrom_insert; + dev->get_volume = mke_get_volume; + dev->get_channel = mke_get_channel; + dev->cached_sector = -1; + + timer_add(&mke.timer, mke_command_callback, &mke, 0); + uint16_t base = device_get_config_hex16("base"); + io_sethandler(base, 16, mke_read, NULL, NULL, mke_write, NULL, NULL, &mke); + return &mke; +} + +static const device_config_t mke_config[] = { + // clang-format off + { + .name = "base", + .description = "Address", + .type = CONFIG_HEX16, + .default_string = NULL, + .default_int = 0x250, + .file_filter = NULL, + .spinner = { 0 }, + .selection = { + { .description = "230H", .value = 0x230 }, + { .description = "250H", .value = 0x250 }, + { .description = "260H", .value = 0x260 }, + { .description = "270H", .value = 0x270 }, + { .description = "290H", .value = 0x290 }, + { NULL } + }, + .bios = { { 0 } } + }, + { .name = "", .description = "", .type = CONFIG_END } +// clang-format off +}; + +const device_t mke_cdrom_device = { + .name = "Panasonic/MKE CD-ROM interface (Creative)", + .internal_name = "mkecd", + .flags = DEVICE_ISA16, + .local = 0, + .init = mke_init, + .close = mke_close, + .reset = NULL, + .available = NULL, + .speed_changed = NULL, + .force_redraw = NULL, + .config = mke_config +}; + +const device_t mke_cdrom_noncreative_device = { + .name = "Panasonic/MKE CD-ROM interface", + .internal_name = "mkecd_normal", + .flags = DEVICE_ISA16, + .local = 0, + .init = mke_init, + .close = mke_close, + .reset = NULL, + .available = NULL, + .speed_changed = NULL, + .force_redraw = NULL, + .config = mke_config +}; diff --git a/src/config.c b/src/config.c index 2ba178bfe..03b9421ec 100644 --- a/src/config.c +++ b/src/config.c @@ -948,6 +948,7 @@ load_storage_controllers(void) p = NULL; } + free_p = 0; p = ini_section_get_string(cat, "cdrom_interface", NULL); if (p != NULL) cdrom_interface_current = cdrom_interface_get_from_internal_name(p); @@ -3127,7 +3128,7 @@ save_floppy_and_cdrom_drives(void) sprintf(temp, "cdrom_%02i_type", c + 1); char *tn = cdrom_get_internal_name(cdrom_get_type(c)); - if ((cdrom[c].bus_type == 0) || (cdrom[c].bus_type == CDROM_BUS_MITSUMI) || + if ((cdrom[c].bus_type == 0) || (cdrom[c].bus_type == CDROM_BUS_MITSUMI) || (cdrom[c].bus_type == CDROM_BUS_MKE) || !strcmp(tn, "86cd")) ini_section_delete_var(cat, temp); else diff --git a/src/disk/hdd.c b/src/disk/hdd.c index e051cc841..ddab10c97 100644 --- a/src/disk/hdd.c +++ b/src/disk/hdd.c @@ -78,6 +78,12 @@ no_cdrom: if (!strcmp(str, "scsi")) return HDD_BUS_SCSI; + + if (!strcmp(str, "mitsumi")) + return CDROM_BUS_MITSUMI; + + if (!strcmp(str, "mke")) + return CDROM_BUS_MKE; return 0; } @@ -89,6 +95,17 @@ hdd_bus_to_string(int bus, UNUSED(int cdrom)) switch (bus) { default: + if (cdrom) { + switch (bus) { + case CDROM_BUS_MITSUMI: + s = "mitsumi"; + break; + case CDROM_BUS_MKE: + s = "mke"; + break; + } + break; + } case HDD_BUS_DISABLED: break; diff --git a/src/include/86box/cdrom.h b/src/include/86box/cdrom.h index e4c8d4251..9aea9104d 100644 --- a/src/include/86box/cdrom.h +++ b/src/include/86box/cdrom.h @@ -98,7 +98,8 @@ enum { CDROM_BUS_ATAPI = 5, CDROM_BUS_SCSI = 6, CDROM_BUS_MITSUMI = 7, - CDROM_BUS_USB = 8 + CDROM_BUS_MKE = 8, + CDROM_BUS_USB = 9 }; #define BUS_TYPE_IDE CDROM_BUS_ATAPI diff --git a/src/include/86box/cdrom_mke.h b/src/include/86box/cdrom_mke.h new file mode 100644 index 000000000..3c946246c --- /dev/null +++ b/src/include/86box/cdrom_mke.h @@ -0,0 +1,23 @@ +/* + * 86Box A hypervisor and IBM PC system emulator that specializes in + * running old operating systems and software designed for IBM + * PC systems and compatibles from 1981 through fairly recent + * system designs based on the PCI bus. + * + * This file is part of the 86Box distribution. + * + * Panasonic/MKE CD-ROM emulation for the ISA bus. + * + * Authors: Miran Grca, + * Cacodemon345 + * + * Copyright 2022-2025 Miran Grca. + * Copyright 2025 Cacodemon345. + */ + +#ifndef CDROM_MKE_H +#define CDROM_MKE_H + +extern const device_t mke_cdrom_device; + +#endif /*CDROM_MKE_H*/ diff --git a/src/qt/qt_harddrive_common.cpp b/src/qt/qt_harddrive_common.cpp index 52ae10a98..973b78820 100644 --- a/src/qt/qt_harddrive_common.cpp +++ b/src/qt/qt_harddrive_common.cpp @@ -52,15 +52,18 @@ Harddrives::populateRemovableBuses(QAbstractItemModel *model) { model->removeRows(0, model->rowCount()); #ifdef USE_CDROM_MITSUMI - model->insertRows(0, 4); + model->insertRows(0, 5); #else - model->insertRows(0, 3); + model->insertRows(0, 4); #endif model->setData(model->index(0, 0), QObject::tr("Disabled")); model->setData(model->index(1, 0), QObject::tr("ATAPI")); model->setData(model->index(2, 0), QObject::tr("SCSI")); #ifdef USE_CDROM_MITSUMI model->setData(model->index(3, 0), QObject::tr("Mitsumi")); + model->setData(model->index(4, 0), QObject::tr("Panasonic/MKE")); +#else + model->setData(model->index(3, 0), QObject::tr("Panasonic/MKE")); #endif model->setData(model->index(0, 0), HDD_BUS_DISABLED, Qt::UserRole); @@ -68,6 +71,9 @@ Harddrives::populateRemovableBuses(QAbstractItemModel *model) model->setData(model->index(2, 0), HDD_BUS_SCSI, Qt::UserRole); #ifdef USE_CDROM_MITSUMI model->setData(model->index(3, 0), CDROM_BUS_MITSUMI, Qt::UserRole); + model->setData(model->index(4, 0), CDROM_BUS_MKE, Qt::UserRole); +#else + model->setData(model->index(3, 0), CDROM_BUS_MKE, Qt::UserRole); #endif } @@ -189,6 +195,9 @@ Harddrives::BusChannelName(uint8_t bus, uint8_t channel) case CDROM_BUS_MITSUMI: busName = QString("Mitsumi"); break; + case CDROM_BUS_MKE: + busName = QString("Panasonic/MKE"); + break; } return busName; diff --git a/src/qt/qt_machinestatus.cpp b/src/qt/qt_machinestatus.cpp index 1b95ad1fe..ab7c72620 100644 --- a/src/qt/qt_machinestatus.cpp +++ b/src/qt/qt_machinestatus.cpp @@ -388,7 +388,7 @@ MachineStatus::iterateCDROM(const std::function &cb) (scsi_card_current[0] == 0) && (scsi_card_current[1] == 0) && (scsi_card_current[2] == 0) && (scsi_card_current[3] == 0)) continue; - if ((cdrom[i].bus_type == CDROM_BUS_MITSUMI) && (cdrom_interface_current == 0)) + if ((cdrom[i].bus_type == CDROM_BUS_MITSUMI || cdrom[i].bus_type == CDROM_BUS_MKE) && (cdrom_interface_current == 0)) continue; if (cdrom[i].bus_type != 0) { cb(i); diff --git a/src/qt/qt_mediamenu.cpp b/src/qt/qt_mediamenu.cpp index c23e11cdb..0e5dea4d7 100644 --- a/src/qt/qt_mediamenu.cpp +++ b/src/qt/qt_mediamenu.cpp @@ -834,8 +834,11 @@ MediaMenu::cdromUpdateMenu(int i) busName = "SCSI"; break; case CDROM_BUS_MITSUMI: - busName = "Mitsumi"; - break; + busName = "Mitsumi"; + break; + case CDROM_BUS_MKE: + busName = "Panasonic/MKE"; + break; } menu->setTitle(tr("CD-ROM %1 (%2): %3").arg(QString::number(i+1), busName, name.isEmpty() ? tr("(empty)") : name2)); diff --git a/src/qt/qt_settings_bus_tracking.cpp b/src/qt/qt_settings_bus_tracking.cpp index 6fb8637da..75c6dbbe5 100644 --- a/src/qt/qt_settings_bus_tracking.cpp +++ b/src/qt/qt_settings_bus_tracking.cpp @@ -23,10 +23,14 @@ #include "86box/hdd.h" #include "86box/scsi.h" +#include "86box/cdrom.h" #include "qt_settings_bus_tracking.hpp" SettingsBusTracking::SettingsBusTracking() { + mitsumi_tracking = false; + mke_tracking = false; + mfm_tracking = 0x0000000000000000ULL; esdi_tracking = 0x0000000000000000ULL; xta_tracking = 0x0000000000000000ULL; @@ -204,6 +208,14 @@ QList SettingsBusTracking::busChannelsInUse(const int bus) { int element; uint64_t mask; switch (bus) { + case CDROM_BUS_MKE: + if (mke_tracking) + channelsInUse.append(0); + break; + case CDROM_BUS_MITSUMI: + if (mitsumi_tracking) + channelsInUse.append(0); + break; case HDD_BUS_MFM: for (uint8_t i = 0; i < 32; i++) { mask = 0xffULL << ((uint64_t) ((i << 3) & 0x3f)); @@ -263,6 +275,12 @@ SettingsBusTracking::device_track(int set, uint8_t dev_type, int bus, int channe uint64_t mask; switch (bus) { + case CDROM_BUS_MKE: + mke_tracking = set; + break; + case CDROM_BUS_MITSUMI: + mitsumi_tracking = set; + break; case HDD_BUS_MFM: mask = ((uint64_t) dev_type) << ((uint64_t) ((channel << 3) & 0x3f)); diff --git a/src/qt/qt_settings_bus_tracking.hpp b/src/qt/qt_settings_bus_tracking.hpp index ac1f3ca5b..26eaccae0 100644 --- a/src/qt/qt_settings_bus_tracking.hpp +++ b/src/qt/qt_settings_bus_tracking.hpp @@ -61,6 +61,9 @@ private: 8 bits per device (future-proofing) = 2048 bits. */ uint64_t scsi_tracking[32] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + + bool mitsumi_tracking; + bool mke_tracking; }; #endif // QT_SETTINGS_BUS_TRACKING_HPP diff --git a/src/qt/qt_settingsfloppycdrom.cpp b/src/qt/qt_settingsfloppycdrom.cpp index bf1499076..c88073ded 100644 --- a/src/qt/qt_settingsfloppycdrom.cpp +++ b/src/qt/qt_settingsfloppycdrom.cpp @@ -69,6 +69,7 @@ setCDROMBus(QAbstractItemModel *model, const QModelIndex &idx, uint8_t bus, uint case CDROM_BUS_ATAPI: case CDROM_BUS_SCSI: case CDROM_BUS_MITSUMI: + case CDROM_BUS_MKE: icon = QIcon(":/settings/qt/icons/cdrom.ico"); break; } @@ -104,7 +105,8 @@ setCDROMType(QAbstractItemModel *model, const QModelIndex &idx, int type) auto i = idx.siblingAtColumn(2); if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() == CDROM_BUS_DISABLED) model->setData(i, QCoreApplication::translate("", "None")); - else if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() != CDROM_BUS_MITSUMI) + else if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() != CDROM_BUS_MITSUMI && + idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() != CDROM_BUS_MKE) model->setData(i, CDROMName(type)); model->setData(i, type, Qt::UserRole); } @@ -175,7 +177,7 @@ SettingsFloppyCDROM::SettingsFloppyCDROM(QWidget *parent) else if (cdrom[i].bus_type == CDROM_BUS_SCSI) Harddrives::busTrackClass->device_track(1, DEV_CDROM, cdrom[i].bus_type, cdrom[i].scsi_device_id); - else if (cdrom[i].bus_type == CDROM_BUS_MITSUMI) + else if (cdrom[i].bus_type == CDROM_BUS_MITSUMI || cdrom[i].bus_type == CDROM_BUS_MKE) Harddrives::busTrackClass->device_track(1, DEV_CDROM, cdrom[i].bus_type, 0); } ui->tableViewCDROM->resizeColumnsToContents(); @@ -341,9 +343,9 @@ SettingsFloppyCDROM::on_comboBoxBus_currentIndexChanged(int index) if (index >= 0) { int bus = ui->comboBoxBus->currentData().toInt(); bool enabled = (bus != CDROM_BUS_DISABLED); - ui->comboBoxChannel->setEnabled((bus == CDROM_BUS_MITSUMI) ? 0 : enabled); - ui->comboBoxSpeed->setEnabled((bus == CDROM_BUS_MITSUMI) ? 0 : enabled); - ui->comboBoxCDROMType->setEnabled((bus == CDROM_BUS_MITSUMI) ? 0 : enabled); + ui->comboBoxChannel->setEnabled((bus == CDROM_BUS_MITSUMI || bus == CDROM_BUS_MKE) ? 0 : enabled); + ui->comboBoxSpeed->setEnabled((bus == CDROM_BUS_MITSUMI || bus == CDROM_BUS_MKE) ? 0 : enabled); + ui->comboBoxCDROMType->setEnabled((bus == CDROM_BUS_MITSUMI || bus == CDROM_BUS_MKE) ? 0 : enabled); Harddrives::populateBusChannels(ui->comboBoxChannel->model(), bus, Harddrives::busTrackClass); } @@ -370,7 +372,7 @@ SettingsFloppyCDROM::on_comboBoxBus_activated(int) ui->comboBoxChannel->setCurrentIndex(Harddrives::busTrackClass->next_free_ide_channel()); else if (bus_type == CDROM_BUS_SCSI) ui->comboBoxChannel->setCurrentIndex(Harddrives::busTrackClass->next_free_scsi_id()); - else if (bus_type == CDROM_BUS_MITSUMI) + else if (bus_type == CDROM_BUS_MITSUMI || bus_type == CDROM_BUS_MKE) ui->comboBoxChannel->setCurrentIndex(0); setCDROMBus(ui->tableViewCDROM->model(), diff --git a/src/qt/qt_settingsotherremovable.cpp b/src/qt/qt_settingsotherremovable.cpp index 8088f0969..4ba07161c 100644 --- a/src/qt/qt_settingsotherremovable.cpp +++ b/src/qt/qt_settingsotherremovable.cpp @@ -124,6 +124,7 @@ SettingsOtherRemovable::SettingsOtherRemovable(QWidget *parent) ui->setupUi(this); Harddrives::populateRemovableBuses(ui->comboBoxMOBus->model()); + ui->comboBoxMOBus->model()->removeRows(3, ui->comboBoxMOBus->model()->rowCount() - 3); auto *model = ui->comboBoxMOType->model(); for (uint32_t i = 0; i < KNOWN_MO_DRIVE_TYPES; i++) { Models::AddEntry(model, moDriveTypeName(i), i); @@ -147,6 +148,8 @@ SettingsOtherRemovable::SettingsOtherRemovable(QWidget *parent) ui->tableViewMO->setCurrentIndex(model->index(0, 0)); Harddrives::populateRemovableBuses(ui->comboBoxRDiskBus->model()); + if ((ui->comboBoxRDiskBus->model()->rowCount() - 3) > 0) + ui->comboBoxRDiskBus->model()->removeRows(3, ui->comboBoxRDiskBus->model()->rowCount() - 3); model = ui->comboBoxRDiskType->model(); for (uint32_t i = 0; i < KNOWN_RDISK_DRIVE_TYPES; i++) { Models::AddEntry(model, rdiskDriveTypeName(i), i);