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

Non-working MKE/Panasonic interface

Browse Source
This commit is contained in:
Cacodemon345
2025-07-25 16:26:36 +06:00
parent 8e948d541c
commit 472f0cb7d9
14 changed files with 644 additions and 13 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.c
cdrom_image.c cdrom_image.c
cdrom_image_viso.c cdrom_image_viso.c
cdrom_mke.c
) )
target_link_libraries(86Box PkgConfig::SNDFILE) target_link_libraries(86Box PkgConfig::SNDFILE)

2
src/cdrom/cdrom.c
View File

@@ -32,6 +32,7 @@
#ifdef USE_CDROM_MITSUMI #ifdef USE_CDROM_MITSUMI
#include <86box/cdrom_mitsumi.h> #include <86box/cdrom_mitsumi.h>
#endif #endif
#include <86box/cdrom_mke.h>
#include <86box/log.h> #include <86box/log.h>
#include <86box/plat.h> #include <86box/plat.h>
#include <86box/plat_cdrom_ioctl.h> #include <86box/plat_cdrom_ioctl.h>
@@ -123,6 +124,7 @@ static const struct {
#ifdef USE_CDROM_MITSUMI #ifdef USE_CDROM_MITSUMI
{ &mitsumi_cdrom_device }, { &mitsumi_cdrom_device },
#endif #endif
{ &mke_cdrom_device },
{ NULL } { NULL }
// clang-format on // clang-format on
}; };

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

@@ -0,0 +1,567 @@
#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/sound.h>
#include <86box/fifo8.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 data_select;
uint8_t media_selected;//temporary hack
Fifo8 data_fifo, info_fifo;
Fifo8 errors_fifo;
cdrom_t* cdrom_dev;
uint32_t sector_type, sector_flags;
uint32_t unit_attention;
uint8_t cdbuffer[624240];
} mke_t;
mke_t mke;
#define mke_log(x, ...)
#define CHECK_READY() { if (mke.cdrom_dev->image_path[0] == 0) { fifo8_push(&mke.errors_fifo, 0x03); return; } }
static uint8_t temp_buf[65536];
void mke_get_subq(cdrom_t *dev,uint8_t *b) {
//dev->ops->get_subchannel(dev, dev->seek_pos, &subc);
//cdrom_get_current_subchannel(dev, &subc);
//cdrom_get_current_subcodeq(dev, b);
cdrom_get_current_subcodeq(dev, temp_buf);
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; //??
}
uint8_t mke_read_toc(cdrom_t *dev, unsigned char *b, uint8_t track) {
track_info_t ti;
int first_track;
int last_track;
//dev->ops->get_tracks(dev, &first_track, &last_track);
cdrom_read_toc(dev, temp_buf, CD_TOC_NORMAL, 0, 0, 65536);
first_track = temp_buf[2];
last_track = temp_buf[3];
if(track > last_track) return 0; //should we allow +1 here?
dev->ops->get_track_info(dev, track, 0, &ti);
b[0]=0x0;
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;
return 1;
}
uint8_t mke_disc_info(cdrom_t *dev, unsigned char *b) {
track_info_t ti;
int first_track;
int last_track;
cdrom_read_toc(dev, temp_buf, CD_TOC_NORMAL, 0, 0, 65536);
first_track = temp_buf[2];
last_track = temp_buf[3];
dev->ops->get_track_info(dev, last_track+1, 0, &ti);
b[0]=0x0;
b[1]=first_track;
b[2]=last_track;
b[3]=ti.m;
b[4]=ti.s;
b[5]=ti.f;
return 1;
}
uint8_t mke_disc_capacity(cdrom_t *dev, unsigned char *b) {
track_info_t ti;
int first_track;
int last_track;
//dev->ops->get_tracks(dev, &first_track, &last_track);
cdrom_read_toc(dev, temp_buf, CD_TOC_NORMAL, 0, 0, 65536);
first_track = temp_buf[2];
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;
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(dev->image_path[0] != 0) {
status |= STAT_DISK;
status |= STAT_READY;
}
return status;
}
void MKE_COMMAND(uint8_t value) {
uint16_t i,len;
uint8_t x[12];//this is wasteful handling of buffers for compatibility, but will optimize later.
subchannel_t subc;
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);
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]) {
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_READ: {
//cdrom_readsector_raw(mke.cdrom_dev, )
uint32_t count = mke.command_buffer[6];
uint8_t* buf = mke.cdbuffer;
int len = 0;
int res = 0;
int error = 0;
uint64_t lba = MSFtoLBA(mke.command_buffer[1], mke.command_buffer[2], mke.command_buffer[3]);
CHECK_READY();
while (count) {
if ((res = cdrom_readsector_raw(mke.cdrom_dev, mke.cdbuffer, 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;
} else {
fifo8_push(&mke.errors_fifo, res == 0 ? 0x10 : 0x05);
break;
}
count--;
}
if (count != 0) {
fifo8_reset(&mke.data_fifo);
}
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);
/*
for(i=0;i<11;i++) {
cdrom_fifo_write(&cdrom.info_fifo,x[i]);
}
*/
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");
fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke));
break;
case CMD1_GETMODE://6
mke_log("GET MODE\n");
uint8_t mode[5] = {[1] = 0x08};
fifo8_push_all(&mke.info_fifo, mode, 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);
/*
for(i=0;i<6;i++) {
mke_log("%02x ",x[i]);
cdrom_fifo_write(&cdrom.info_fifo,x[i]);
}
mke_log("\n");
*/
fifo8_push(&mke.info_fifo, mke_cdrom_status(mke.cdrom_dev, &mke));
break;
case CMD1_READTOC:
CHECK_READY();
fifo8_reset(&mke.info_fifo);
/*
mke_log("READ TOC:");
for(i=0;i<6;i++) {
mke_log("%02x ",mke.command_buffer[i+1]);
}
mke_log(" | ");
*/
mke_read_toc(mke.cdrom_dev,(uint8_t *)&x,mke.command_buffer[2]);
fifo8_push_all(&mke.info_fifo, x, 8);
/*
for(i=0;i<8;i++) {
mke_log("%02x ",x[i]);
cdrom_fifo_write(&cdrom.info_fifo,x[i]);
}
*/
/* mke_log("\n"); */
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");
//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]
//);
{
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);
}
}
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);
cdrom_seek(mke.cdrom_dev, (mke.command_buffer[1] << 16) | (mke.command_buffer[2] << 8) | mke.command_buffer[3], 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, 0, -1);
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");
uint8_t session_info[6] = {0};
fifo8_push_all(&mke.info_fifo, session_info, 6);
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);
mke_log("CMD: READ VER\n");
uint8_t ver[10] = "CR-5631.02";
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 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) {
return fifo8_pop(&mke.data_fifo); //cdrom_fifo_read(&cdrom.data_fifo);
} else {
return fifo8_pop(&mke.info_fifo);
//return cdrom_fifo_read(&cdrom.info_fifo);
}
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_pop(&mke.data_fifo);
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);
}
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;
fifo8_push(&dev->errors_fifo, 0x11);
} else if (dev->cdrom_dev->cd_status & CD_STATUS_TRANSITION) {
dev->unit_attention = 1;
/* Turn off the medium changed status. */
dev->cdrom_dev->cd_status &= ~CD_STATUS_TRANSITION;
fifo8_push(&dev->errors_fifo, 0x11);
} else {
dev->unit_attention = 0;
dev->cdrom_dev->cd_status |= CD_STATUS_TRANSITION;
}
}
void* mke_init(const device_t* info)
{
cdrom_t* dev;
memset(&mke, 0, sizeof(mke_t));
for (int 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);
fifo8_create(&mke.errors_fifo, 8);
mke.cdrom_dev = dev;
mke.command_buffer_pending = 7;
mke.sector_type = 0x08 | (1 << 4);
mke.sector_flags = 0x10;
dev->priv = &mke;
dev->insert = mke_cdrom_insert;
dev->cached_sector = -1;
dev->sector_size = 2048;
io_sethandler(0x250, 16, MKE_READ, NULL, NULL, MKE_WRITE, NULL, NULL, &mke);
return &mke;
}
const device_t mke_cdrom_device = {
.name = "Panasonic/MKE CD-ROM interface",
.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 = NULL
};

3
src/config.c
View File

@@ -898,6 +898,7 @@ load_storage_controllers(void)
p = NULL; p = NULL;
} }
free_p = 0;
p = ini_section_get_string(cat, "cdrom_interface", NULL); p = ini_section_get_string(cat, "cdrom_interface", NULL);
if (p != NULL) if (p != NULL)
cdrom_interface_current = cdrom_interface_get_from_internal_name(p); cdrom_interface_current = cdrom_interface_get_from_internal_name(p);
@@ -2967,7 +2968,7 @@ save_floppy_and_cdrom_drives(void)
sprintf(temp, "cdrom_%02i_type", c + 1); sprintf(temp, "cdrom_%02i_type", c + 1);
char *tn = cdrom_get_internal_name(cdrom_get_type(c)); 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")) !strcmp(tn, "86cd"))
ini_section_delete_var(cat, temp); ini_section_delete_var(cat, temp);
else else

17
src/disk/hdd.c
View File

@@ -78,6 +78,12 @@ no_cdrom:
if (!strcmp(str, "scsi")) if (!strcmp(str, "scsi"))
return HDD_BUS_SCSI; return HDD_BUS_SCSI;
if (!strcmp(str, "mitsumi"))
return CDROM_BUS_MITSUMI;
if (!strcmp(str, "mke"))
return CDROM_BUS_MKE;
return 0; return 0;
} }
@@ -89,6 +95,17 @@ hdd_bus_to_string(int bus, UNUSED(int cdrom))
switch (bus) { switch (bus) {
default: default:
if (cdrom) {
switch (bus) {
case CDROM_BUS_MITSUMI:
s = "mitsumi";
break;
case CDROM_BUS_MKE:
s = "mke";
break;
}
break;
}
case HDD_BUS_DISABLED: case HDD_BUS_DISABLED:
break; break;

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

@@ -97,7 +97,8 @@ enum {
CDROM_BUS_ATAPI = 5, CDROM_BUS_ATAPI = 5,
CDROM_BUS_SCSI = 6, CDROM_BUS_SCSI = 6,
CDROM_BUS_MITSUMI = 7, CDROM_BUS_MITSUMI = 7,
CDROM_BUS_USB = 8 CDROM_BUS_MKE = 8,
CDROM_BUS_USB = 9
}; };
#define BUS_TYPE_IDE CDROM_BUS_ATAPI #define BUS_TYPE_IDE CDROM_BUS_ATAPI

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

@@ -0,0 +1,6 @@
#ifndef CDROM_MKE_H
#define CDROM_MKE_H
extern const device_t mke_cdrom_device;
#endif /*CDROM_MITSUMI_H*/

13
src/qt/qt_harddrive_common.cpp
View File

@@ -52,15 +52,18 @@ Harddrives::populateRemovableBuses(QAbstractItemModel *model)
{ {
model->removeRows(0, model->rowCount()); model->removeRows(0, model->rowCount());
#ifdef USE_CDROM_MITSUMI #ifdef USE_CDROM_MITSUMI
model->insertRows(0, 4); model->insertRows(0, 5);
#else #else
model->insertRows(0, 3); model->insertRows(0, 4);
#endif #endif
model->setData(model->index(0, 0), QObject::tr("Disabled")); model->setData(model->index(0, 0), QObject::tr("Disabled"));
model->setData(model->index(1, 0), QObject::tr("ATAPI")); model->setData(model->index(1, 0), QObject::tr("ATAPI"));
model->setData(model->index(2, 0), QObject::tr("SCSI")); model->setData(model->index(2, 0), QObject::tr("SCSI"));
#ifdef USE_CDROM_MITSUMI #ifdef USE_CDROM_MITSUMI
model->setData(model->index(3, 0), QObject::tr("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 #endif
model->setData(model->index(0, 0), HDD_BUS_DISABLED, Qt::UserRole); 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); model->setData(model->index(2, 0), HDD_BUS_SCSI, Qt::UserRole);
#ifdef USE_CDROM_MITSUMI #ifdef USE_CDROM_MITSUMI
model->setData(model->index(3, 0), CDROM_BUS_MITSUMI, Qt::UserRole); 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 #endif
} }
@@ -189,6 +195,9 @@ Harddrives::BusChannelName(uint8_t bus, uint8_t channel)
case CDROM_BUS_MITSUMI: case CDROM_BUS_MITSUMI:
busName = QString("Mitsumi"); busName = QString("Mitsumi");
break; break;
case CDROM_BUS_MKE:
busName = QString("Panasonic/MKE");
break;
} }
return busName; 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[0] == 0) && (scsi_card_current[1] == 0) &&
(scsi_card_current[2] == 0) && (scsi_card_current[3] == 0)) (scsi_card_current[2] == 0) && (scsi_card_current[3] == 0))
continue; 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; continue;
if (cdrom[i].bus_type != 0) { if (cdrom[i].bus_type != 0) {
cb(i); cb(i);

7
src/qt/qt_mediamenu.cpp
View File

@@ -834,8 +834,11 @@ MediaMenu::cdromUpdateMenu(int i)
busName = "SCSI"; busName = "SCSI";
break; break;
case CDROM_BUS_MITSUMI: case CDROM_BUS_MITSUMI:
busName = "Mitsumi"; busName = "Mitsumi";
break; 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)); 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/hdd.h"
#include "86box/scsi.h" #include "86box/scsi.h"
#include "86box/cdrom.h"
#include "qt_settings_bus_tracking.hpp" #include "qt_settings_bus_tracking.hpp"
SettingsBusTracking::SettingsBusTracking() SettingsBusTracking::SettingsBusTracking()
{ {
mitsumi_tracking = false;
mke_tracking = false;
mfm_tracking = 0x0000000000000000ULL; mfm_tracking = 0x0000000000000000ULL;
esdi_tracking = 0x0000000000000000ULL; esdi_tracking = 0x0000000000000000ULL;
xta_tracking = 0x0000000000000000ULL; xta_tracking = 0x0000000000000000ULL;
@@ -204,6 +208,14 @@ QList<int> SettingsBusTracking::busChannelsInUse(const int bus) {
int element; int element;
uint64_t mask; uint64_t mask;
switch (bus) { 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: case HDD_BUS_MFM:
for (uint8_t i = 0; i < 32; i++) { for (uint8_t i = 0; i < 32; i++) {
mask = 0xffULL << ((uint64_t) ((i << 3) & 0x3f)); 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; uint64_t mask;
switch (bus) { switch (bus) {
case CDROM_BUS_MKE:
mke_tracking = set;
break;
case CDROM_BUS_MITSUMI:
mitsumi_tracking = set;
break;
case HDD_BUS_MFM: case HDD_BUS_MFM:
mask = ((uint64_t) dev_type) << ((uint64_t) ((channel << 3) & 0x3f)); mask = ((uint64_t) dev_type) << ((uint64_t) ((channel << 3) & 0x3f));

2
src/qt/qt_settings_bus_tracking.hpp
View File

@@ -61,6 +61,8 @@ private:
8 bits per device (future-proofing) = 2048 bits. */ 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, 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 }; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
bool mitsumi_tracking, mke_tracking;
}; };
#endif // QT_SETTINGS_BUS_TRACKING_HPP #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_ATAPI:
case CDROM_BUS_SCSI: case CDROM_BUS_SCSI:
case CDROM_BUS_MITSUMI: case CDROM_BUS_MITSUMI:
case CDROM_BUS_MKE:
icon = QIcon(":/settings/qt/icons/cdrom.ico"); icon = QIcon(":/settings/qt/icons/cdrom.ico");
break; break;
} }
@@ -104,7 +105,8 @@ setCDROMType(QAbstractItemModel *model, const QModelIndex &idx, int type)
auto i = idx.siblingAtColumn(2); auto i = idx.siblingAtColumn(2);
if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() == CDROM_BUS_DISABLED) if (idx.siblingAtColumn(0).data(Qt::UserRole).toUInt() == CDROM_BUS_DISABLED)
model->setData(i, QCoreApplication::translate("", "None")); 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, CDROMName(type));
model->setData(i, type, Qt::UserRole); model->setData(i, type, Qt::UserRole);
} }
@@ -175,7 +177,7 @@ SettingsFloppyCDROM::SettingsFloppyCDROM(QWidget *parent)
else if (cdrom[i].bus_type == CDROM_BUS_SCSI) else if (cdrom[i].bus_type == CDROM_BUS_SCSI)
Harddrives::busTrackClass->device_track(1, DEV_CDROM, cdrom[i].bus_type, Harddrives::busTrackClass->device_track(1, DEV_CDROM, cdrom[i].bus_type,
cdrom[i].scsi_device_id); 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); Harddrives::busTrackClass->device_track(1, DEV_CDROM, cdrom[i].bus_type, 0);
} }
ui->tableViewCDROM->resizeColumnsToContents(); ui->tableViewCDROM->resizeColumnsToContents();
@@ -341,9 +343,9 @@ SettingsFloppyCDROM::on_comboBoxBus_currentIndexChanged(int index)
if (index >= 0) { if (index >= 0) {
int bus = ui->comboBoxBus->currentData().toInt(); int bus = ui->comboBoxBus->currentData().toInt();
bool enabled = (bus != CDROM_BUS_DISABLED); bool enabled = (bus != CDROM_BUS_DISABLED);
ui->comboBoxChannel->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) ? 0 : enabled); ui->comboBoxSpeed->setEnabled((bus == CDROM_BUS_MITSUMI || bus == CDROM_BUS_MKE) ? 0 : enabled);
ui->comboBoxCDROMType->setEnabled((bus == CDROM_BUS_MITSUMI) ? 0 : enabled); ui->comboBoxCDROMType->setEnabled((bus == CDROM_BUS_MITSUMI || bus == CDROM_BUS_MKE) ? 0 : enabled);
Harddrives::populateBusChannels(ui->comboBoxChannel->model(), bus, Harddrives::busTrackClass); 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()); ui->comboBoxChannel->setCurrentIndex(Harddrives::busTrackClass->next_free_ide_channel());
else if (bus_type == CDROM_BUS_SCSI) else if (bus_type == CDROM_BUS_SCSI)
ui->comboBoxChannel->setCurrentIndex(Harddrives::busTrackClass->next_free_scsi_id()); 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); ui->comboBoxChannel->setCurrentIndex(0);
setCDROMBus(ui->tableViewCDROM->model(), setCDROMBus(ui->tableViewCDROM->model(),

2
src/qt/qt_settingsotherremovable.cpp
View File

@@ -114,6 +114,7 @@ SettingsOtherRemovable::SettingsOtherRemovable(QWidget *parent)
ui->setupUi(this); ui->setupUi(this);
Harddrives::populateRemovableBuses(ui->comboBoxMOBus->model()); Harddrives::populateRemovableBuses(ui->comboBoxMOBus->model());
ui->comboBoxMOBus->model()->removeRows(3, ui->comboBoxMOBus->model()->rowCount() - 3);
auto *model = ui->comboBoxMOType->model(); auto *model = ui->comboBoxMOType->model();
for (uint32_t i = 0; i < KNOWN_MO_DRIVE_TYPES; i++) { for (uint32_t i = 0; i < KNOWN_MO_DRIVE_TYPES; i++) {
Models::AddEntry(model, moDriveTypeName(i), i); Models::AddEntry(model, moDriveTypeName(i), i);
@@ -137,6 +138,7 @@ SettingsOtherRemovable::SettingsOtherRemovable(QWidget *parent)
ui->tableViewMO->setCurrentIndex(model->index(0, 0)); ui->tableViewMO->setCurrentIndex(model->index(0, 0));
Harddrives::populateRemovableBuses(ui->comboBoxZIPBus->model()); Harddrives::populateRemovableBuses(ui->comboBoxZIPBus->model());
ui->comboBoxZIPBus->model()->removeRows(3, ui->comboBoxZIPBus->model()->rowCount() - 3);
model = new QStandardItemModel(0, 2, this); model = new QStandardItemModel(0, 2, this);
ui->tableViewZIP->setModel(model); ui->tableViewZIP->setModel(model);