claunia/86Box
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #5825 from Cacodemon345/mke

Browse Source 
Panasonic/MKE CD-ROM interface backport from PicoGUS
This commit is contained in:
Miran Grča
2025-07-27 17:46:27 +02:00
committed by GitHub
parent 029c2f5906 c89283deef
commit 07bbf62563
14 changed files with 979 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/cdrom/CMakeLists.txt
View File

@@ -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)

8
src/cdrom/cdrom.c
View File

@@ -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
};

880
src/cdrom/cdrom_mke.c Normal file
View File

@@ -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, <mgrca8@gmail.com>
* Kevin Moonlight, <me@yyzkevin.com>
* Cacodemon345
*
* Copyright (C) 2025 Miran Grca.
* Copyright (C) 2025 Cacodemon345.
* Copyright (C) 2024 Kevin Moonlight.
*/
#include <inttypes.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <wchar.h>
#include <stdbool.h>
#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
};

3
src/config.c
View File

@@ -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

17
src/disk/hdd.c
View File

@@ -79,6 +79,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;

3
src/include/86box/cdrom.h
View File

@@ -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

23
src/include/86box/cdrom_mke.h Normal file
View File

@@ -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, <mgrca8@gmail.com>
* 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*/

13
src/qt/qt_harddrive_common.cpp
View File

@@ -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;

2
src/qt/qt_machinestatus.cpp
View File

@@ -388,7 +388,7 @@ MachineStatus::iterateCDROM(const std::function<void(int)> &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);

7
src/qt/qt_mediamenu.cpp
View File

@@ -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));

18
src/qt/qt_settings_bus_tracking.cpp
View File

@@ -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<int> 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));

3
src/qt/qt_settings_bus_tracking.hpp
View File

@@ -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

14
src/qt/qt_settingsfloppycdrom.cpp
View File

@@ -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(),

3
src/qt/qt_settingsotherremovable.cpp
View File

@@ -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);