int romMapperGameReaderCreate(int cartSlot, int slot, int sslot)
{
DeviceCallbacks callbacks = { destroy, NULL, saveState, loadState };
RomMapperGameReader* rm;
int i;
rm = malloc(sizeof(RomMapperGameReader));
rm->deviceHandle = deviceManagerRegister(ROM_GAMEREADER, &callbacks, rm);
rm->slot = slot;
rm->sslot = sslot;
rm->cartSlot = cartSlot;
// f = fopen("c:\\grlog.txt", "w+");
rm->gameReader = gameReaderCreate(cartSlot);
for (i = 0; i < CACHE_LINES; i++) {
rm->cacheLineEnabled[i] = 0;
}
if (rm->gameReader != NULL) {
ioPortRegisterUnused(cartSlot, readIo, writeIo, rm);
slotRegister(slot, sslot, 0, 8, read, read, write, destroy, rm);
for (i = 0; i < 8; i++) {
slotMapPage(rm->slot, rm->sslot, i, NULL, 0, 0);
}
}
return 1;
}
int romMapperMoonsoundCreate(char* filename, UInt8* romData, int size, int sramSize)
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
DebugCallbacks dbgCallbacks = { getDebugInfo, NULL, NULL, NULL };
RomMapperMoonsound* rm = malloc(sizeof(RomMapperMoonsound));
rm->deviceHandle = deviceManagerRegister(ROM_MOONSOUND, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_AUDIO, langDbgDevMoonsound(), &dbgCallbacks, rm);
rm->moonsound = NULL;
if (boardGetMoonsoundEnable()) {
rm->moonsound = moonsoundCreate(boardGetMixer(), romData, size, sramSize);
ioPortRegister(0x7e, read, write, rm);
ioPortRegister(0x7f, read, write, rm);
ioPortRegister(0xc4, read, write, rm);
ioPortRegister(0xc5, read, write, rm);
ioPortRegister(0xc6, read, write, rm);
ioPortRegister(0xc7, read, write, rm);
}
else {
// moonsound emulation has ownership of rom data. Need to
// free it if its not being used.
free(romData);
}
reset(rm);
return 1;
}
int romMapperPlayBallCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { (DeviceCallback)destroy, NULL, NULL, NULL };
RomMapperPlayBall* rm;
rm = malloc(sizeof(RomMapperPlayBall));
if (size > 0x8000) {
size = 0x8000;
}
rm->deviceHandle = deviceManagerRegister(ROM_PLAYBALL, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, NULL, NULL, NULL, (SlotEject)destroy, rm);
rm->romData = malloc(0x8000);
memset(rm->romData + size, 0xff, 0x8000 - size);
memcpy(rm->romData, romData, size);
rm->size = size;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
slotMapPage(rm->slot, rm->sslot, rm->startPage, rm->romData + 0x0000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 1, rm->romData + 0x2000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 2, rm->romData + 0x4000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 3, rm->romData + 0x6000, 0, 0);
return 1;
}
int romMapperDramCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { (DeviceCallback)destroy, NULL, NULL, NULL };
RomMapperDram* rm;
int pages = size / 0x2000 + ((size & 0x1fff) ? 1 : 0);
if (pages == 0 || (startPage + pages) > 8) {
return 0;
}
rm = malloc(sizeof(RomMapperDram));
rm->deviceHandle = deviceManagerRegister(ROM_DRAM, &callbacks, rm);
slotRegister(slot, sslot, startPage, pages, NULL, NULL, NULL, (SlotEject)destroy, rm);
rm->sramHandle = panasonicDramRegister((PanasonicDramCallback)setDram, rm);
rm->romData = malloc(pages * 0x2000);
memcpy(rm->romData, romData, size);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->pages = pages;
setDram(rm, 0);
return 1;
}
int ramMapperIoCreate()
{
RamMapperIo* rm;
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
NULL,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
DebugCallbacks dbgCallbacks = { (void(*)(void*,DbgDevice*))getDebugInfo, NULL, NULL, NULL };
rm = malloc(sizeof(RamMapperIo));
rm->count = 0;
rm->mask = 0;
rm->handleCount = 0;
rm->port[0] = 3;
rm->port[1] = 2;
rm->port[2] = 1;
rm->port[3] = 0;
rm->deviceHandle = deviceManagerRegister(RAM_MAPPER, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_BIOS, langDbgDevRamMapper(), &dbgCallbacks, rm);
ioPortRegister(0xfc, (IoPortRead)read, (IoPortWrite)write, rm);
ioPortRegister(0xfd, (IoPortRead)read, (IoPortWrite)write, rm);
ioPortRegister(0xfe, (IoPortRead)read, (IoPortWrite)write, rm);
ioPortRegister(0xff, (IoPortRead)read, (IoPortWrite)write, rm);
mapperIo = rm;
return 1;
}
int romMapperFmDasCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperFmDas* rm;
if (size != 0x8000 || startPage != 0) {
return 0;
}
rm = malloc(sizeof(RomMapperFmDas));
rm->deviceHandle = deviceManagerRegister(ROM_FMDAS, &callbacks, rm);
slotRegister(slot, sslot, startPage, 8, NULL, NULL, NULL, destroy, rm);
rm->romData = malloc(0x8000);
memcpy(rm->romData, romData, 0x8000);
memset(rm->romData + 0x2000, 0xff, 0x2000);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
slotMapPage(slot, sslot, 0, rm->romData + 0x0000, 1, 0);
slotMapPage(slot, sslot, 1, rm->romData + 0x2000, 1, 1);
slotMapPage(slot, sslot, 2, rm->romData + 0x4000, 1, 0);
slotMapPage(slot, sslot, 3, rm->romData + 0x6000, 1, 0);
slotMapPage(slot, sslot, 4, rm->romData + 0x0000, 1, 0);
slotMapPage(slot, sslot, 5, rm->romData + 0x2000, 1, 1);
slotMapPage(slot, sslot, 6, rm->romData + 0x4000, 1, 0);
slotMapPage(slot, sslot, 7, rm->romData + 0x6000, 1, 0);
return 1;
}
int romMapperSf7000IplCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperSf7000Ipl* rm;
int pages = 2;
int i;
rm = malloc(sizeof(RomMapperSf7000Ipl));
rm->deviceHandle = deviceManagerRegister(ROM_NORMAL, &callbacks, rm);
slotRegister(slot, sslot, startPage, pages, NULL, NULL, write, destroy, rm);
rm->romData = malloc(0x4000);
if (size > 0x4000) {
size = 0x4000;
}
memcpy(rm->romData, romData, size);
memset(rm->romData + size, 0xff, 0x4000 - size);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
for (i = 0; i < pages; i++) {
slotMapPage(slot, sslot, i + startPage, rm->romData + 0x2000 * i, 1, 0);
}
return 1;
}
void sviPPICreate(SviJoyIo* joyIO)
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
DebugCallbacks dbgCallbacks = { getDebugInfo, NULL, NULL, NULL };
SviPPI* ppi = malloc(sizeof(SviPPI));
ppi->deviceHandle = deviceManagerRegister(RAM_MAPPER, &callbacks, ppi);
ppi->debugHandle = debugDeviceRegister(DBGTYPE_BIOS, langDbgDevPpi(), &dbgCallbacks, ppi);
ppi->joyIO = joyIO;
ppi->i8255 = i8255Create(peekA, readA, NULL,
peekB, readB, NULL,
NULL, NULL, writeCLo,
NULL, NULL, writeCHi,
ppi);
ppi->keyClick = audioKeyClickCreate(boardGetMixer());
ppi->dac = dacCreate(boardGetMixer(), DAC_MONO);
ioPortRegister(0x98, i8255Read, i8255Write, ppi->i8255); // PPI Port A
ioPortRegister(0x99, i8255Read, i8255Write, ppi->i8255); // PPI Port B
ioPortRegister(0x96, i8255Read, i8255Write, ppi->i8255); // PPI Port C
ioPortRegister(0x97, i8255Read, i8255Write, ppi->i8255); // PPI Mode
ioPortRegister(0x9A, readRow, NULL, ppi); // PPI Return Port C (Low)
reset(ppi);
}
int romMapperPACCreate(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, saveState, loadState };
RomMapperPAC* rm;
rm = malloc(sizeof(RomMapperPAC));
rm->deviceHandle = deviceManagerRegister(ROM_PAC, &callbacks, rm);
slotRegister(slot, sslot, startPage, 2, read, read, write, destroy, rm);
memset(rm->sram, 0xff, 0x2000);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->sramEnabled = 0;
strcpy(rm->sramFilename, sramCreateFilename(filename));
sramLoad(rm->sramFilename, rm->sram, 0x1ffe, pacHeader, strlen(pacHeader));
slotMapPage(rm->slot, rm->sslot, rm->startPage, NULL, 0, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 1, NULL, 0, 0);
return 1;
}
int romMapperKanji12Create(UInt8* romData, int size)
{
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
NULL,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
DebugCallbacks dbgCallbacks = { (void(*)(void*,DbgDevice*))getDebugInfo, NULL, NULL, NULL };
RomMapperKanji12* rm;
if (size != 0x20000 && size != 0x40000) {
return 0;
}
rm = malloc(sizeof(RomMapperKanji12));
rm->size = size;
rm->address = 0;
rm->deviceHandle = deviceManagerRegister(ROM_KANJI12, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_CART, langDbgDevKanji12(), &dbgCallbacks, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
ioPortRegisterSub(0xf7, (IoPortRead)read, (IoPortWrite)write, rm);
return 1;
}
int svi328FdcCreate(void)
{
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
(DeviceCallback)reset,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
DebugCallbacks dbgCallbacks = { (void(*)(void*,DbgDevice*))getDebugInfo, NULL, NULL, NULL };
Svi328Fdc* rm;
rm = malloc(sizeof(Svi328Fdc));
rm->deviceHandle = deviceManagerRegister(ROM_SVI328FDC, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_PORT, langDbgDevSviFdc(), &dbgCallbacks, rm);
ioPortRegister(0x30, (IoPortRead)readIo, (IoPortWrite)writeIo, rm);
ioPortRegister(0x31, (IoPortRead)readIo, (IoPortWrite)writeIo, rm);
ioPortRegister(0x32, (IoPortRead)readIo, (IoPortWrite)writeIo, rm);
ioPortRegister(0x33, (IoPortRead)readIo, (IoPortWrite)writeIo, rm);
ioPortRegister(0x34, (IoPortRead)readIo, (IoPortWrite)writeIo, rm);
ioPortRegister(0x38, (IoPortRead)readIo, (IoPortWrite)writeIo, rm);
rm->fdc = wd2793Create(FDC_TYPE_WD2793);
reset(rm);
return 1;
}
/*****************************************
** MSX MIDI Create Method
******************************************
*/
int MSXMidiCreate()
{
DeviceCallbacks callbacks = {destroy, reset, saveState, loadState};
DebugCallbacks dbgCallbacks = { getDebugInfo, NULL, NULL, NULL };
MSXMidi* msxMidi;
msxMidi = malloc(sizeof(MSXMidi));
msxMidi->deviceHandle = deviceManagerRegister(ROM_MSXMIDI, &callbacks, msxMidi);
msxMidi->debugHandle = debugDeviceRegister(DBGTYPE_AUDIO, langDbgDevMsxMidi(), &dbgCallbacks, msxMidi);
msxMidi->i8254 = i8254Create(4000000, pitOut0, pitOut1, pitOut2, msxMidi);
msxMidi->i8251 = i8251Create(transmit, signal8251, setDataBits, setStopBits, setParity,
setRxReady, setDtr, setRts, getDtr, getRts, msxMidi);
ioPortRegister(0xe8, readIo, writeIo, msxMidi);
ioPortRegister(0xe9, readIo, writeIo, msxMidi);
ioPortRegister(0xea, readIo, writeIo, msxMidi);
ioPortRegister(0xeb, readIo, writeIo, msxMidi);
ioPortRegister(0xec, readIo, writeIo, msxMidi);
ioPortRegister(0xed, readIo, writeIo, msxMidi);
ioPortRegister(0xee, readIo, writeIo, msxMidi);
ioPortRegister(0xef, readIo, writeIo, msxMidi);
msxMidi->midiIo = midiIoCreate(midiInCallback, msxMidi);
reset(msxMidi);
return 1;
}
int romMapperOpcodeSaveRamCreate(int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
DebugCallbacks dbgCallbacks = { getDebugInfo, NULL, NULL, NULL };
RomMapperOpcodeSaveRam* rm = malloc(sizeof(RomMapperOpcodeSaveRam));
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
memset(rm->saveRam, 0xff, sizeof(rm->saveRam));
slotRegister(rm->slot, rm->sslot, rm->startPage, 4, NULL, NULL, write, destroy, rm);
rm->deviceHandle = deviceManagerRegister(ROM_OPCODESAVE, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_RAM, "SAVERAM", &dbgCallbacks, rm);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 0, rm->saveRam + 0x0000, 1, 1);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 1, rm->saveRam + 0x2000, 1, 1);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 2, rm->saveRam + 0x4000, 1, 1);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 3, rm->saveRam + 0x6000, 1, 1);
strcpy(rm->saveRamFilename, sramCreateFilename("SaveRam"));
sramLoad(rm->saveRamFilename, rm->saveRam, sizeof(rm->saveRam), NULL, 0);
reset(rm);
return 1;
}
int romMapperKonamiSynthCreate(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperKonamiSynth* rm;
int i;
if (size != 0x8000) {
return 0;
}
rm = malloc(sizeof(RomMapperKonamiSynth));
rm->deviceHandle = deviceManagerRegister(ROM_KONAMISYNTH, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, NULL, NULL, write, destroy, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->dac = dacCreate(boardGetMixer(), DAC_MONO);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
for (i = 0; i < 4; i++) {
slotMapPage(rm->slot, rm->sslot, rm->startPage + i, rm->romData + i * 0x2000, 1, 0);
}
return 1;
}
int romMapperSg1000Create(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperSg1000* rm;
int pages = size / 0x2000 + ((size & 0x1fff) ? 1 : 0);
int i;
if (pages == 0 || (startPage + pages) > 8) {
return 0;
}
rm = malloc(sizeof(RomMapperSg1000));
rm->deviceHandle = deviceManagerRegister(ROM_SG1000, &callbacks, rm);
slotRegister(slot, sslot, startPage, pages, NULL, NULL, NULL, destroy, rm);
rm->romData = malloc(pages * 0x2000);
memcpy(rm->romData, romData, size);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
for (i = 0; i < pages; i++) {
if (i + startPage >= 2) slot = 0;
slotMapPage(slot, sslot, i + startPage, rm->romData + 0x2000 * i, 1, 0);
}
return 1;
}
int romMapperKonamiWordProCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
RomMapperKonamiWordPro* rm;
int pages = 8;
int i;
if (size != 0x8000) {
return 0;
}
rm = malloc(sizeof(RomMapperKonamiWordPro));
if (pages == 8)
startPage = 0;
rm->deviceHandle = deviceManagerRegister(ROM_KONWORDPRO, &callbacks, rm);
slotRegister(slot, sslot, startPage, pages, read, read, write, destroy, rm);
rm->romData = calloc(1, size);
memcpy(rm->romData, romData, size);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
for (i = 0; i < pages; i++) {
slotMapPage(rm->slot, rm->sslot, rm->startPage + i, rm->romData + i * 0x2000, 0, 0);
}
reset(rm);
return 1;
}
int romMapperOpcodeMegaRamCreate(int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
(DeviceCallback)reset,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
DebugCallbacks dbgCallbacks = { (void(*)(void*,DbgDevice*))getDebugInfo, NULL, NULL, NULL };
RomMapperOpcodeMegaRam* rm = malloc(sizeof(RomMapperOpcodeMegaRam));
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
memset(rm->megaRam, 0xff, sizeof(rm->megaRam));
rm->deviceHandle = deviceManagerRegister(ROM_OPCODEMEGA, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_RAM, "MEGARAM", &dbgCallbacks, rm);
ioPortRegister(0x48, (SlotRead)read, (SlotWrite)write, rm);
ioPortRegister(0x49, (SlotRead)read, (SlotWrite)write, rm);
ioPortRegister(0x4a, (SlotRead)read, (SlotWrite)write, rm);
ioPortRegister(0x4b, (SlotRead)read, (SlotWrite)write, rm);
reset(rm);
return 1;
}
int romMapperTC8566AFCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage,
RomType romType)
{
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
(DeviceCallback)reset,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
RomMapperTC8566AF* rm;
rm = malloc(sizeof(RomMapperTC8566AF));
rm->deviceHandle = deviceManagerRegister(romType, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, (SlotRead)read, (SlotRead)peek, (SlotWrite)write, (SlotEject)destroy, rm);
size = (size + 0x3fff) & ~0x3fff;
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->romMask = size / 0x4000 - 1;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->romType = romType;
rm->fdc = tc8566afCreate();
reset(rm);
return 1;
}
int romMapperSonyHBI55Create()
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
DebugCallbacks dbgCallbacks = { getDebugInfo, NULL, NULL, NULL };
SonyHBI55* rm = malloc(sizeof(SonyHBI55));
rm->deviceHandle = deviceManagerRegister(ROM_SONYHBI55, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_CART, langDbgDevHbi55(), &dbgCallbacks, rm);
memset(rm->sram, 0xff, sizeof(rm->sram));
sramLoad(sramCreateFilename("HBI-55.SRAM"), rm->sram, 0x1000, NULL, 0);
rm->sram[0] = 0x53;
rm->i8255 = i8255Create(NULL, NULL, writeA,
NULL, NULL, writeB,
readCLo, readCLo, writeCLo,
readCHi, readCHi, writeCHi,
rm);
ioPortRegister(0xb0, i8255Read, i8255Write, rm->i8255);
ioPortRegister(0xb1, i8255Read, i8255Write, rm->i8255);
ioPortRegister(0xb2, i8255Read, i8255Write, rm->i8255);
ioPortRegister(0xb3, i8255Read, i8255Write, rm->i8255);
reset(rm);
return 1;
}
int romMapperNationalFdcCreate(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, saveState, loadState };
RomMapperNationalFdc* rm;
int pages = 4;
int i;
if ((startPage + pages) > 8) {
return 0;
}
rm = malloc(sizeof(RomMapperNationalFdc));
rm->deviceHandle = deviceManagerRegister(ROM_NATIONALFDC, &callbacks, rm);
slotRegister(slot, sslot, startPage, pages, read, peek, write, destroy, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
for (i = 0; i < pages; i++) {
slotMapPage(slot, sslot, i + startPage, NULL, 0, 0);
}
rm->fdc = wd2793Create(FDC_TYPE_WD2793);
reset(rm);
return 1;
}
int romMapperBasicCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperBasic* rm;
if (size > 0x8000) {
return 0;
}
rm = malloc(sizeof(RomMapperBasic));
rm->romData = malloc(0x8000);
memset(rm->romData, 0xff, 0x8000);
memcpy(rm->romData, romData, size);
rm->size = size;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->deviceHandle = deviceManagerRegister(ROM_BASIC, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, NULL, NULL, NULL, destroy, rm);
slotMapPage(slot, sslot, startPage + 0, rm->romData + 0x0000, 1, 0);
slotMapPage(slot, sslot, startPage + 1, rm->romData + 0x2000, 1, 0);
slotMapPage(slot, sslot, startPage + 2, rm->romData + 0x4000, 1, 0);
slotMapPage(slot, sslot, startPage + 3, rm->romData + 0x6000, 1, 0);
return 1;
}
int romMapperA1FMModemCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
(DeviceCallback)reset,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
RomMapperA1FMModem* rm;
rm = malloc(sizeof(RomMapperA1FMModem));
rm->deviceHandle = deviceManagerRegister(ROM_FSA1FMMODEM, &callbacks, rm);
slotRegister(slot, sslot, startPage, 2, (SlotRead)read, (SlotRead)read, (SlotWrite)write, (SlotEject)destroy, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->romSize = size;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->romMapper = 0;
reset(rm);
return 1;
}
int romMapperMajutsushiCreate(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, saveState, loadState };
RomMapperMajutsushi* rm;
int i;
if (size < 0x8000) {
return 0;
}
rm = malloc(sizeof(RomMapperMajutsushi));
rm->deviceHandle = deviceManagerRegister(ROM_MAJUTSUSHI, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, NULL, NULL, write, destroy, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->dac = dacCreate(boardGetMixer(), DAC_MONO);
rm->size = size;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->romMapper[0] = 0;
rm->romMapper[1] = 1;
rm->romMapper[2] = 2;
rm->romMapper[3] = 3;
for (i = 0; i < 4; i++) {
slotMapPage(rm->slot, rm->sslot, rm->startPage + i, rm->romData + rm->romMapper[i] * 0x2000, 1, 0);
}
return 1;
}
int romMapperSvi328Col80Create(int frameRate, UInt8* romData, int size)
{
DeviceCallbacks callbacks = {destroy, reset, saveState, loadState};
DebugCallbacks dbgCallbacks = {getDebugInfo, NULL, NULL, NULL};
RomMapperSvi328Col80* svi328col80;
if (size != 0x1000)
return 0;
svi328col80 = malloc(sizeof(RomMapperSvi328Col80));
svi328col80Instance = svi328col80;
svi328col80->deviceHandle = deviceManagerRegister(ROM_SVI328COL80, &callbacks, svi328col80);
svi328col80->crtc6845 = NULL;
svi328col80->crtc6845 = crtc6845Create(frameRate, romData, size, 0x800, 7, 0, 82, 4);
svi328col80->debugHandle = debugDeviceRegister(DBGTYPE_VIDEO, langDbgDevSvi80Col(), &dbgCallbacks, svi328col80);
ioPortRegister(0x50, NULL, writeIo, svi328col80);
ioPortRegister(0x51, readIo, writeIo, svi328col80);
ioPortRegister(0x58, readIo, writeIo, svi328col80);
reset(svi328col80);
return 1;
}
int romMapperPlayBallCreate(char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperPlayBall* rm;
rm = malloc(sizeof(RomMapperPlayBall));
rm->samplePlayer = samplePlayerCreate(boardGetMixer(), MIXER_CHANNEL_PCM, 8, 11025);
if (size > 0x8000) {
size = 0x8000;
}
rm->deviceHandle = deviceManagerRegister(ROM_PLAYBALL, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, read, read, write, destroy, rm);
rm->romData = malloc(0x8000);
memset(rm->romData + size, 0xff, 0x8000 - size);
memcpy(rm->romData, romData, size);
rm->size = size;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
slotMapPage(rm->slot, rm->sslot, rm->startPage, rm->romData + 0x0000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 1, rm->romData + 0x2000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 2, rm->romData + 0x4000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 3, rm->romData + 0x6000, 0, 0);
return 1;
}
int romMapperKorean126Create(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, saveState, loadState };
RomMapperKorean126* rm;
int i;
if (size < 0x8000) {
return 0;
}
rm = malloc(sizeof(RomMapperKorean126));
rm->deviceHandle = deviceManagerRegister(ROM_KOREAN126, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, NULL, NULL, write, destroy, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->size = size;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->romMapper[0] = 0;
rm->romMapper[2] = 0;
for (i = 0; i < 4; i += 2) {
slotMapPage(rm->slot, rm->sslot, rm->startPage + i, rm->romData + rm->romMapper[i] * 0x2000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + i + 1, rm->romData + rm->romMapper[i] * 0x2000 + 0x2000, 1, 0);
}
return 1;
}
int romMapperSvi328RsIdeCreate(int hdId)
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
DebugCallbacks dbgCallbacks = { getDebugInfo, NULL, NULL, NULL };
RomMapperRsIde* rm;
rm = malloc(sizeof(RomMapperRsIde));
rm->deviceHandle = deviceManagerRegister(ROM_SVI328RSIDE, &callbacks, rm);
rm->debugHandle = debugDeviceRegister(DBGTYPE_PORT, langDbgDevIdeSviRs(), &dbgCallbacks, rm);
rm->i8255 = i8255Create( NULL, NULL, writeA,
NULL, readB, writeB,
NULL, readCLo, writeCLo,
NULL, readCHi, writeCHi,
rm);
ioPortRegister(0x14, i8255Read, i8255Write, rm->i8255); // PPI Port A
ioPortRegister(0x15, i8255Read, i8255Write, rm->i8255); // PPI Port B
ioPortRegister(0x16, i8255Read, i8255Write, rm->i8255); // PPI Port C
ioPortRegister(0x17, i8255Read, i8255Write, rm->i8255); // PPI Mode
rm->hdide = harddiskIdeCreate(diskGetHdDriveId(hdId, 0));
reset(rm);
return 1;
}
int ramMirroredCreate(int size, int slot, int sslot, int startPage,
UInt32 ramBlockSize, UInt8** ramPtr, UInt32* ramSize)
{
DeviceCallbacks callbacks = {
(DeviceCallback)destroy,
NULL,
(DeviceCallback)saveState,
(DeviceCallback)loadState
};
DebugCallbacks dbgCallbacks = {
(void(*)(void*,DbgDevice*))getDebugInfo,
(int(*)(void*,char*,void*,int,int))dbgWriteMemory,
NULL,
NULL
};
Ram1kBMirrored* rm;
int pages = size / 0x2000;
int i;
if (size > 0x10000 || (size & 0x1fff)) {
return 0;
}
// Start page must be zero (only full slot allowed)
if (startPage + pages > 8) {
return 0;
}
rm = malloc(sizeof(Ram1kBMirrored));
rm->mask = ramBlockSize - 1;
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->pages = pages;
memset(rm->ramData, 0, sizeof(rm->ramData));
rm->debugHandle = debugDeviceRegister(DBGTYPE_RAM, langDbgDevRam(), &dbgCallbacks, rm);
for (i = 0; i < pages; i++) {
slotMapPage(slot, sslot, i + startPage, NULL, 0, 0);
}
rm->deviceHandle = deviceManagerRegister(ramBlockSize == 0x400 ? RAM_1KB_MIRRORED : RAM_2KB_MIRRORED,
&callbacks, rm);
slotRegister(slot, sslot, startPage, pages, (SlotRead)read, (SlotRead)read, (SlotWrite)write, (SlotEject)destroy, rm);
if (ramPtr != NULL) {
*ramPtr = rm->ramData;
}
if (ramSize != NULL) {
*ramSize = rm->pages * 0x2000;
}
return 1;
}
int romMapperSCCplusCreate(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage, SccType sccType)
{
DeviceCallbacks callbacks = { destroy, reset, saveState, loadState };
RomMapperSCCplus* rm;
rm = malloc(sizeof(RomMapperSCCplus));
rm->deviceHandle = deviceManagerRegister(ROM_SCCEXTENDED, &callbacks, rm);
slotRegister(slot, sslot, startPage, 4, read, peek, write, destroy, rm);
memset(rm->romData, 0xff, 0x22000);
if (romData) {
if (size > 0x20000) {
size = 0x20000;
}
memcpy(rm->romData, romData, size);
}
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
rm->modeRegister = sccType == SCCP_EXTENDED ? 0x20 : 0;
rm->isRamSegment[0] = 0;
rm->isRamSegment[1] = 0;
rm->isRamSegment[2] = 0;
rm->isRamSegment[3] = 0;
rm->isMapped[0] = sccType != SCC_SDSNATCHER;
rm->isMapped[1] = sccType != SCC_SDSNATCHER;
rm->isMapped[2] = sccType != SCC_SDSNATCHER;
rm->isMapped[3] = sccType != SCC_SDSNATCHER;
rm->mapperMask = sccType == SCC_MIRRORED ? 0x07 : 0x0f;
rm->scc = sccCreate(boardGetMixer());
rm->sccType = sccType;
rm->sccMode = SCC_NONE;
rm->romMapper[0] = 0;
rm->romMapper[1] = 1;
rm->romMapper[2] = 2;
rm->romMapper[3] = 3;
if (sccType != SCC_SDSNATCHER) {
slotMapPage(rm->slot, rm->sslot, rm->startPage, rm->romData + 0x0000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 1, rm->romData + 0x2000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 2, rm->romData + 0x4000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 3, rm->romData + 0x6000, 1, 0);
}
else {
slotMapPage(rm->slot, rm->sslot, rm->startPage, rm->romData + 0x20000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 1, rm->romData + 0x20000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 2, rm->romData + 0x20000, 1, 0);
slotMapPage(rm->slot, rm->sslot, rm->startPage + 3, rm->romData + 0x20000, 1, 0);
}
return 1;
}
int romMapperCasetteCreate(const char* filename, UInt8* romData,
int size, int slot, int sslot, int startPage)
{
DeviceCallbacks callbacks = { destroy, NULL, NULL, NULL };
RomMapperCasette* rm;
int pages = size / 0x2000;
int i;
if (pages == 0 || (startPage + pages) > 8) {
return 0;
}
rm = malloc(sizeof(RomMapperCasette));
rm->deviceHandle = deviceManagerRegister(ROM_CASPATCH, &callbacks, rm);
slotRegister(slot, sslot, startPage, pages, NULL, NULL, NULL, destroy, rm);
rm->romData = malloc(size);
memcpy(rm->romData, romData, size);
rm->slot = slot;
rm->sslot = sslot;
rm->startPage = startPage;
if (boardGetType() == BOARD_SVI) {
// Patch the SVI-328 BIOS and BASIC for cassette handling
for (i = 0; patchAddressSVI[i]; i++) {
UInt8* ptr = rm->romData + patchAddressSVI[i];
ptr[0] = 0xed;
ptr[1] = 0xfe;
ptr[2] = 0xc9;
}
rm->romData[0x2073]=0x01; // Skip delay loop after save
rm->romData[0x20D0]=0x10; // Write $55 only $10 times, instead
rm->romData[0x20D1]=0x00; // of $190
rm->romData[0x20E3]=0x00; // Cancel instruction
rm->romData[0x20E4]=0x00;
rm->romData[0x20E5]=0x00;
rm->romData[0x20E6]=0xED;
rm->romData[0x20E7]=0xFE;
}
else {
// Patch the casette rom
for (i = 0; patchAddress[i]; i++) {
UInt8* ptr = rm->romData + patchAddress[i];
ptr[0] = 0xed;
ptr[1] = 0xfe;
ptr[2] = 0xc9;
}
}
for (i = 0; i < pages; i++) {
slotMapPage(slot, sslot, i + startPage, rm->romData + 0x2000 * i, 1, 0);
}
return 1;
}
