#if defined(_FM77AV_VARIANTS)
# include "mb61vh010.h"
#endif
+#include "fm7_mainio.h"
+#include "./fm7_keyboard.h"
+#include "./kanjirom.h"
DISPLAY::DISPLAY(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
{
int i;
double usec;
- keyboard->write_signal(SIG_FM7KEY_SET_INSLED, 0x00, 0x01);
- mainio->write_signal(SIG_FM7_SUB_HALT, 0x00, 0xff);
+ call_write_signal(keyboard, SIG_FM7KEY_SET_INSLED, 0x00, 0x01);
+ call_write_signal(mainio, SIG_FM7_SUB_HALT, 0x00, 0xff);
sub_busy = true;
palette_changed = true;
}
//usec = 16.0;
//register_event(this, EVENT_FM7SUB_VSTART, usec, false, &vstart_event_id); // NEXT CYCLE_
- mainio->write_signal(SIG_DISPLAY_DISPLAY, 0x00, 0xff);
- mainio->write_signal(SIG_DISPLAY_VSYNC, 0xff, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_DISPLAY, 0x00, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_VSYNC, 0xff, 0xff);
//#endif
display_page = 0;
display_page_bak = 0;
alu->reset();
# if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
- alu->write_signal(SIG_ALU_X_WIDTH, (mode320 || mode256k) ? 40 : 80, 0xffff);
- alu->write_signal(SIG_ALU_Y_HEIGHT, (display_mode == DISPLAY_MODE_8_400L) ? 400: 200, 0xffff);
- alu->write_signal(SIG_ALU_400LINE, (display_mode == DISPLAY_MODE_8_400L) ? 0xffffffff : 0, 0xffffffff);
+ call_write_signal(alu, SIG_ALU_X_WIDTH, (mode320 || mode256k) ? 40 : 80, 0xffff);
+ call_write_signal(alu, SIG_ALU_Y_HEIGHT, (display_mode == DISPLAY_MODE_8_400L) ? 400: 200, 0xffff);
+ call_write_signal(alu, SIG_ALU_400LINE, (display_mode == DISPLAY_MODE_8_400L) ? 0xffffffff : 0, 0xffffffff);
# else
- alu->write_signal(SIG_ALU_X_WIDTH, (mode320) ? 40 : 80, 0xffff);
- alu->write_signal(SIG_ALU_Y_HEIGHT, 200, 0xffff);
- alu->write_signal(SIG_ALU_400LINE, 0, 0xffffffff);
+ call_write_signal(alu, SIG_ALU_X_WIDTH, (mode320) ? 40 : 80, 0xffff);
+ call_write_signal(alu, SIG_ALU_Y_HEIGHT, 200, 0xffff);
+ call_write_signal(alu, SIG_ALU_400LINE, 0, 0xffffffff);
# endif
- alu->write_signal(SIG_ALU_MULTIPAGE, multimode_accessmask, 0x07);
- alu->write_signal(SIG_ALU_PLANES, 3, 3);
+ call_write_signal(alu, SIG_ALU_MULTIPAGE, multimode_accessmask, 0x07);
+ call_write_signal(alu, SIG_ALU_PLANES, 3, 3);
#endif
for(i = 0; i < 8; i++) set_dpalette(i, i);
memcpy(dpalette_pixel, dpalette_pixel_tmp, sizeof(dpalette_pixel));
void DISPLAY::reset_subcpu(bool _check_firq)
{
- subcpu->write_signal(SIG_CPU_HALTREQ, 0, 1);
- subcpu->write_signal(SIG_CPU_BUSREQ, 0, 1);
+ call_write_signal(subcpu, SIG_CPU_HALTREQ, 0, 1);
+ call_write_signal(subcpu, SIG_CPU_BUSREQ, 0, 1);
subcpu->reset();
if(_check_firq) {
do_firq(!firq_mask && key_firq_req);
void DISPLAY::do_irq(bool flag)
{
- subcpu->write_signal(SIG_CPU_IRQ, flag ? 1: 0, 1);
+ call_write_signal(subcpu, SIG_CPU_IRQ, flag ? 1: 0, 1);
}
void DISPLAY::do_firq(bool flag)
{
- subcpu->write_signal(SIG_CPU_FIRQ, flag ? 1: 0, 1);
+ call_write_signal(subcpu, SIG_CPU_FIRQ, flag ? 1: 0, 1);
}
void DISPLAY::do_nmi(bool flag)
#if defined(_FM77AV_VARIANTS)
if(!nmi_enable) flag = false;
#endif
- subcpu->write_signal(SIG_CPU_NMI, flag ? 1 : 0, 1);
+ call_write_signal(subcpu, SIG_CPU_NMI, flag ? 1 : 0, 1);
}
void DISPLAY::set_multimode(uint8_t val)
}
vram_wrote = true;
# if defined(_FM77AV_VARIANTS)
- alu->write_signal(SIG_ALU_MULTIPAGE, multimode_accessmask, 0x07);
+ call_write_signal(alu, SIG_ALU_MULTIPAGE, multimode_accessmask, 0x07);
# endif
#endif
}
void DISPLAY::halt_subcpu(void)
{
- //subcpu->write_signal(SIG_CPU_BUSREQ, 0x01, 0x01);
- subcpu->write_signal(SIG_CPU_HALTREQ, 0x01, 0x01);
+ //call_write_signal(subcpu, SIG_CPU_BUSREQ, 0x01, 0x01);
+ call_write_signal(subcpu, SIG_CPU_HALTREQ, 0x01, 0x01);
}
void DISPLAY::go_subcpu(void)
{
- subcpu->write_signal(SIG_CPU_HALTREQ, 0x00, 0x01);
+ call_write_signal(subcpu, SIG_CPU_HALTREQ, 0x00, 0x01);
}
void DISPLAY::enter_display(void)
//SUB:D403:R
uint8_t DISPLAY::beep(void)
{
- mainio->write_signal(FM7_MAINIO_BEEP, 0x01, 0x01);
+ call_write_signal(mainio, FM7_MAINIO_BEEP, 0x01, 0x01);
return 0xff; // True?
}
// SUB:D404 : R
uint8_t DISPLAY::attention_irq(void)
{
- mainio->write_signal(FM7_MAINIO_SUB_ATTENTION, 0x01, 0x01);
+ call_write_signal(mainio, FM7_MAINIO_SUB_ATTENTION, 0x01, 0x01);
return 0xff;
}
// D410
void DISPLAY::alu_write_cmdreg(uint32_t val)
{
- alu->write_data8(ALU_CMDREG, val);
+ call_write_data8(alu, ALU_CMDREG, val);
if((val & 0x80) != 0) {
use_alu = true;
} else {
void DISPLAY::alu_write_logical_color(uint8_t val)
{
uint32_t data = (uint32_t)val;
- alu->write_data8(ALU_LOGICAL_COLOR, data);
+ call_write_data8(alu, ALU_LOGICAL_COLOR, data);
}
// D412
void DISPLAY::alu_write_mask_reg(uint8_t val)
{
uint32_t data = (uint32_t)val;
- alu->write_data8(ALU_WRITE_MASKREG, data);
+ call_write_data8(alu, ALU_WRITE_MASKREG, data);
}
// D413 - D41A
{
uint32_t data = (uint32_t)val;
addr = addr & 7;
- alu->write_data8(ALU_CMPDATA_REG + addr, data);
+ call_write_data8(alu, ALU_CMPDATA_REG + addr, data);
}
// D41B
void DISPLAY::alu_write_disable_reg(uint8_t val)
{
uint32_t data = (uint32_t)val;
- alu->write_data8(ALU_BANK_DISABLE, data);
+ call_write_data8(alu, ALU_BANK_DISABLE, data);
}
// D41C - D41F
uint32_t data = (uint32_t)val;
switch(addr & 3) {
case 0: // $D41C
- alu->write_data8(ALU_TILEPAINT_B, data);
+ call_write_data8(alu, ALU_TILEPAINT_B, data);
break;
case 1: // $D41D
- alu->write_data8(ALU_TILEPAINT_R, data);
+ call_write_data8(alu, ALU_TILEPAINT_R, data);
break;
case 2: // $D41E
- alu->write_data8(ALU_TILEPAINT_G, data);
+ call_write_data8(alu, ALU_TILEPAINT_G, data);
break;
case 3: // xxxx
- //alu->write_data8(ALU_TILEPAINT_L, 0xff);
+ //call_write_data8(alu, ALU_TILEPAINT_L, 0xff);
break;
}
}
// D420
void DISPLAY::alu_write_offsetreg_hi(uint8_t val)
{
- alu->write_data8(ALU_OFFSET_REG_HIGH, val & 0x7f);
+ call_write_data8(alu, ALU_OFFSET_REG_HIGH, val & 0x7f);
}
// D421
void DISPLAY::alu_write_offsetreg_lo(uint8_t val)
{
- alu->write_data8(ALU_OFFSET_REG_LO, val);
+ call_write_data8(alu, ALU_OFFSET_REG_LO, val);
}
// D422
void DISPLAY::alu_write_linepattern_hi(uint8_t val)
{
- alu->write_data8(ALU_LINEPATTERN_REG_HIGH, val);
+ call_write_data8(alu, ALU_LINEPATTERN_REG_HIGH, val);
}
// D423
void DISPLAY::alu_write_linepattern_lo(uint8_t val)
{
- alu->write_data8(ALU_LINEPATTERN_REG_LO, val);
+ call_write_data8(alu, ALU_LINEPATTERN_REG_LO, val);
}
// D424-D42B
uint32_t data = (uint32_t)val;
switch(addr) {
case 0:
- alu->write_data8(ALU_LINEPOS_START_X_HIGH, data & 0x03);
+ call_write_data8(alu, ALU_LINEPOS_START_X_HIGH, data & 0x03);
break;
case 1:
- alu->write_data8(ALU_LINEPOS_START_X_LOW, data);
+ call_write_data8(alu, ALU_LINEPOS_START_X_LOW, data);
break;
case 2:
- alu->write_data8(ALU_LINEPOS_START_Y_HIGH, data & 0x01);
+ call_write_data8(alu, ALU_LINEPOS_START_Y_HIGH, data & 0x01);
break;
case 3:
- alu->write_data8(ALU_LINEPOS_START_Y_LOW, data);
+ call_write_data8(alu, ALU_LINEPOS_START_Y_LOW, data);
break;
case 4:
- alu->write_data8(ALU_LINEPOS_END_X_HIGH, data & 0x03);
+ call_write_data8(alu, ALU_LINEPOS_END_X_HIGH, data & 0x03);
break;
case 5:
- alu->write_data8(ALU_LINEPOS_END_X_LOW, data);
+ call_write_data8(alu, ALU_LINEPOS_END_X_LOW, data);
break;
case 6:
- alu->write_data8(ALU_LINEPOS_END_Y_HIGH, data & 0x01);
+ call_write_data8(alu, ALU_LINEPOS_END_Y_HIGH, data & 0x01);
break;
case 7:
- alu->write_data8(ALU_LINEPOS_END_Y_LOW, data);
+ call_write_data8(alu, ALU_LINEPOS_END_Y_LOW, data);
break;
}
}
bool f = false;
double usec;
hblank = false;
- mainio->write_signal(SIG_DISPLAY_DISPLAY, 0x02, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_DISPLAY, 0x02, 0xff);
if(display_mode == DISPLAY_MODE_8_400L) {
if(displine < 400) f = true;
} else {
hblank = true;
hblank_event_id = -1;
- mainio->write_signal(SIG_DISPLAY_DISPLAY, 0x00, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_DISPLAY, 0x00, 0xff);
if(display_mode == DISPLAY_MODE_8_400L) {
if((displine < 400)) f = true;
usec = 11.0;
display_page_bak = display_page;
// Parameter from XM7/VM/display.c , thanks, Ryu.
- mainio->write_signal(SIG_DISPLAY_DISPLAY, 0x00, 0xff);
- mainio->write_signal(SIG_DISPLAY_VSYNC, 0x00, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_DISPLAY, 0x00, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_VSYNC, 0x00, 0xff);
if(vblank_count != 0) {
if(display_mode == DISPLAY_MODE_8_400L) {
} else {
usec = 0.51 * 1000.0;
}
- mainio->write_signal(SIG_DISPLAY_VSYNC, 0x01, 0xff);
- mainio->write_signal(SIG_DISPLAY_DISPLAY, 0x00, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_VSYNC, 0x01, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_DISPLAY, 0x00, 0xff);
//register_event(this, EVENT_FM7SUB_VSTART, usec, false, &vstart_event_id); // NEXT CYCLE_
if(palette_changed) {
} else {
usec = 1.52 * 1000.0;
}
- mainio->write_signal(SIG_DISPLAY_VSYNC, 0x01, 0xff);
- mainio->write_signal(SIG_DISPLAY_DISPLAY, 0x00, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_VSYNC, 0x01, 0xff);
+ call_write_signal(mainio, SIG_DISPLAY_DISPLAY, 0x00, 0xff);
register_event(this, EVENT_FM7SUB_VSTART, usec, false, &vstart_event_id); // NEXT CYCLE_
vblank_count = 1;
#endif
sub_busy = true;
}
halt_flag = flag;
- //mainio->write_signal(SIG_FM7_SUB_HALT, data, mask);
+ //call_write_signal(mainio, SIG_FM7_SUB_HALT, data, mask);
break;
case SIG_DISPLAY_HALT:
if(flag) {
//emu->set_vm_screen_lines(200);
}
vram_wrote = true;
- alu->write_signal(SIG_ALU_X_WIDTH, (mode320 || mode256k) ? 40 : 80, 0xffff);
- alu->write_signal(SIG_ALU_Y_HEIGHT, (display_mode == DISPLAY_MODE_8_400L) ? 400 : 200, 0xffff);
- alu->write_signal(SIG_ALU_400LINE, (display_mode == DISPLAY_MODE_8_400L) ? 0xff : 0x00, 0xff);
+ call_write_signal(alu, SIG_ALU_X_WIDTH, (mode320 || mode256k) ? 40 : 80, 0xffff);
+ call_write_signal(alu, SIG_ALU_Y_HEIGHT, (display_mode == DISPLAY_MODE_8_400L) ? 400 : 200, 0xffff);
+ call_write_signal(alu, SIG_ALU_400LINE, (display_mode == DISPLAY_MODE_8_400L) ? 0xff : 0x00, 0xff);
frame_skip_count_draw = 3;
frame_skip_count_transfer = 3;
setup_display_mode();
//emu->set_vm_screen_lines(200);
}
vram_wrote = true;
- alu->write_signal(SIG_ALU_X_WIDTH, (mode320) ? 40 : 80, 0xffff);
- alu->write_signal(SIG_ALU_Y_HEIGHT, 200, 0xffff);
- alu->write_signal(SIG_ALU_400LINE, 0x00, 0xff);
+ call_write_signal(alu, SIG_ALU_X_WIDTH, (mode320) ? 40 : 80, 0xffff);
+ call_write_signal(alu, SIG_ALU_Y_HEIGHT, 200, 0xffff);
+ call_write_signal(alu, SIG_ALU_400LINE, 0x00, 0xff);
setup_display_mode();
//frame_skip_count = 3;
}
}
display_mode = (mode320 == true) ? DISPLAY_MODE_4096 : DISPLAY_MODE_8_200L;
- alu->write_signal(SIG_ALU_X_WIDTH, (mode320) ? 40 : 80, 0xffff);
- alu->write_signal(SIG_ALU_Y_HEIGHT, 200, 0xffff);
- alu->write_signal(SIG_ALU_400LINE, 0, 0xffffffff);
+ call_write_signal(alu, SIG_ALU_X_WIDTH, (mode320) ? 40 : 80, 0xffff);
+ call_write_signal(alu, SIG_ALU_Y_HEIGHT, 200, 0xffff);
+ call_write_signal(alu, SIG_ALU_400LINE, 0, 0xffffffff);
vram_wrote = true;
setup_display_mode();
}
#endif
switch(raddr) {
case 0x00: // Read keyboard
- retval = (keyboard->read_data8(0x00) != 0) ? 0xff : 0x7f;
+ retval = (call_read_data8(keyboard, 0x00) != 0) ? 0xff : 0x7f;
break;
case 0x01: // Read keyboard
- retval = keyboard->read_data8(0x01) & 0xff;
+ retval = call_read_data8(keyboard, 0x01) & 0xff;
break;
case 0x02: // Acknowledge
acknowledge_irq();
if(!kanjisub) return 0xff;
# if !defined(_FM77_VARIANTS)
if(kanji_level2) {
- return (uint8_t)kanjiclass2->read_data8(KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff));
+ return (uint8_t)call_read_data8(kanjiclass2, KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff));
}
# endif
- if(kanjiclass1 != NULL) retval = kanjiclass1->read_data8(KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff));
+ if(kanjiclass1 != NULL) retval = call_read_data8(kanjiclass1, KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff));
break;
case 0x07:
if(!kanjisub) return 0xff;
# if !defined(_FM77_VARIANTS)
if(kanji_level2) {
- return (uint8_t)kanjiclass2->read_data8(KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff) + 1);
+ return (uint8_t)call_read_data8(kanjiclass2, KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff) + 1);
}
# endif
- if(kanjiclass1 != NULL) retval = kanjiclass1->read_data8(KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff) + 1);
+ if(kanjiclass1 != NULL) retval = call_read_data8(kanjiclass1, KANJIROM_DIRECTADDR + ((kanjiaddr.d << 1) & 0x1ffff) + 1);
break;
#endif
case 0x08:
reset_subbusy();
break;
case 0x0d:
- keyboard->write_signal(SIG_FM7KEY_SET_INSLED, 0x01, 0x01);
+ call_write_signal(keyboard, SIG_FM7KEY_SET_INSLED, 0x01, 0x01);
break;
#if defined(_FM77AV_VARIANTS)
// ALU
case 0x10:
- retval = alu->read_data8(ALU_CMDREG);
+ retval = call_read_data8(alu, ALU_CMDREG);
break;
case 0x11:
- retval = alu->read_data8(ALU_LOGICAL_COLOR);
+ retval = call_read_data8(alu, ALU_LOGICAL_COLOR);
break;
case 0x12:
- retval = alu->read_data8(ALU_WRITE_MASKREG);
+ retval = call_read_data8(alu, ALU_WRITE_MASKREG);
break;
case 0x13:
- retval = alu->read_data8(ALU_CMP_STATUS_REG);
+ retval = call_read_data8(alu, ALU_CMP_STATUS_REG);
break;
case 0x1b:
- retval = alu->read_data8(ALU_BANK_DISABLE);
+ retval = call_read_data8(alu, ALU_BANK_DISABLE);
break;
# if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
case 0x2f: // VRAM BANK
break;
// KEY ENCODER.
case 0x31:
- retval = keyboard->read_data8(0x31);
+ retval = call_read_data8(keyboard, 0x31);
break;
case 0x32:
- retval = keyboard->read_data8(0x32);
+ retval = call_read_data8(keyboard, 0x32);
break;
#endif
default:
uint8_t color;
#if defined(_FM77AV_VARIANTS)
if(use_alu) {
- alu->read_data8(addr);
+ call_read_data8(alu, addr);
}
#endif
return read_vram_data8(addr);
break;
// LED
case 0x0d:
- keyboard->write_signal(SIG_FM7KEY_SET_INSLED, 0x00, 0x01);
+ call_write_signal(keyboard, SIG_FM7KEY_SET_INSLED, 0x00, 0x01);
break;
// OFFSET
case 0x0e:
break;
// KEYBOARD ENCODER
case 0x31:
- keyboard->write_data8(0x31, data);
+ call_write_data8(keyboard, 0x31, data);
break;
# if defined(_FM77AV40EX) || defined(_FM77AV40SX)
case 0x33: //
uint32_t color = (addr & 0xc000) >> 14;
#if defined(_FM77AV_VARIANTS)
if(use_alu) {
- alu->read_data8(addr);
+ call_read_data8(alu, addr);
return;
}
#endif
#define _CSP_FM7_DISPLAY_H
#include "../device.h"
-#include "../device.h"
#include "../mc6809.h"
#include "fm7_common.h"
class DEVICE;
class MC6809;
+class FM7_MAINIO;
+class KEYBOARD;
+class KANJIROM;
+class MB61VH010;
+
class DISPLAY: public DEVICE
{
private:
uint8_t subsys_ram[0x2000];
uint8_t cgram_bank;
bool kanji_level2;
- DEVICE *kanjiclass1;
- DEVICE *kanjiclass2;
+ KANJIROM *kanjiclass1;
+ KANJIROM *kanjiclass2;
#elif defined(_FM77_VARIANTS)
- DEVICE *kanjiclass1;
+ KANJIROM *kanjiclass1;
#endif
bool vram_wrote_shadow;
bool vram_wrote_table[411 * 5];
uint32_t vram_wrote_addr_2[411];
#if defined(_FM77AV_VARIANTS)
bool use_alu;
- DEVICE *alu;
+ MB61VH010 *alu;
#endif
- DEVICE *mainio;
- DEVICE *subcpu;
- DEVICE *keyboard;
+ FM7_MAINIO *mainio;
+ MC6809 *subcpu;
+ KEYBOARD *keyboard;
bool vram_wrote;
void GETVRAM_8_200L(int yoff, scrntype_t *p, scrntype_t *px, bool window_inv, bool scan_line);
void GETVRAM_4096(int yoff, scrntype_t *p, scrntype_t *px, uint32_t rgbmask, bool window_inv, bool scan_line);
void event_callback_hdisp(void);
void event_callback_hblank(void);
+ template <class T>
+ void call_write_signal(T *np, int id, uint32_t data, uint32_t mask)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_signal(id, data, mask);
+ }
+ template <class T>
+ void call_write_data8(T *np, uint32_t addr, uint32_t data)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_data8(addr, data);
+ }
+ template <class T>
+ uint32_t call_read_data8(T *np, uint32_t addr)
+ {
+ //T *nnp = static_cast<T *>(np);
+ return static_cast<T *>(np)->read_data8(addr);
+ }
+ template <class T>
+ void call_write_dma_data8(T *np, uint32_t addr, uint32_t data)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_dma_data8(addr, data);
+ }
+ template <class T>
+ uint32_t call_read_dma_data8(T *np, uint32_t addr)
+ {
+ //T *nnp = static_cast<T *>(np);
+ return static_cast<T *>(np)->read_dma_data8(addr);
+ }
+
public:
DISPLAY(VM *parent_vm, EMU *parent_emu);
~DISPLAY();
#if defined(_FM77_VARIANTS) || \
defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
- kanjiclass1 = p;
+ kanjiclass1 = (KANJIROM *)p;
#endif
}
void set_context_kanjiclass2(DEVICE *p) {
#if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)|| \
defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
- kanjiclass2 = p;
+ kanjiclass2 = (KANJIROM *)p;
if(p != NULL) kanji_level2 = true;
#endif
}
void set_context_mainio(DEVICE *p) {
- mainio = p;
+ mainio = (FM7_MAINIO *)p;
}
void set_context_keyboard(DEVICE *p) {
- keyboard = p;
+ keyboard = (KEYBOARD *)p;
}
void set_context_subcpu(DEVICE *p) {
- subcpu = p;
+ subcpu = (MC6809 *)p;
}
#if defined(_FM77AV_VARIANTS)
void set_context_alu(DEVICE *p) {
- alu = p;
+ alu = (MB61VH010 *)p;
}
#endif
};
# if defined(_FM77AV20) || defined(_FM77AV40) || defined(_FM77AV20EX) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
#include "../and.h"
#endif
-
+#include "./fm7_mainmem.h"
+#include "./fm7_display.h"
+#include "./fm7_keyboard.h"
+#include "./kanjirom.h"
+#include "./joystick.h"
+#if defined(CAPABLE_JCOMMCARD)
+#include "./jcommcard.h"
+#endif
FM7_MAINIO::FM7_MAINIO(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
} else {
clock_fast = false;
}
- this->write_signals(&clock_status, clock_fast ? 0xffffffff : 0);
+ write_signals(&clock_status, clock_fast ? 0xffffffff : 0);
// FD03
irqmask_syndet = true;
midi_uart_irqmask = midi_syndet = midi_rxrdy = midi_txrdy = false;
// FD00
if(drec != NULL) {
- drec->write_signal(SIG_DATAREC_MIC, 0x00, 0x01);
- drec->write_signal(SIG_DATAREC_REMOTE, 0x00, 0x02);
+ call_write_signal(drec, SIG_DATAREC_MIC, 0x00, 0x01);
+ call_write_signal(drec, SIG_DATAREC_REMOTE, 0x00, 0x02);
}
reset_fdc();
reset_sound();
reg_fd12 = 0xbc; // 0b10111100
#endif
#if defined(WITH_Z80)
- if(z80 != NULL) z80->write_signal(SIG_CPU_BUSREQ, 0xffffffff, 0xffffffff);
+ if(z80 != NULL) call_write_signal(z80, SIG_CPU_BUSREQ, 0xffffffff, 0xffffffff);
#endif
- maincpu->write_signal(SIG_CPU_BUSREQ, 0, 0xffffffff);
- maincpu->write_signal(SIG_CPU_HALTREQ, 0, 0xffffffff);
+ call_write_signal(maincpu, SIG_CPU_BUSREQ, 0, 0xffffffff);
+ call_write_signal(maincpu, SIG_CPU_HALTREQ, 0, 0xffffffff);
do_irq();
//#if !defined(_FM8)
lpt_strobe = false;
// FD01
lpt_outdata = 0x00;
- this->write_signals(&printer_strobe_bus, 0);
- this->write_signals(&printer_select_bus, 0xffffffff);
- this->write_signals(&printer_reset_bus, 0xffffffff);
+ write_signals(&printer_strobe_bus, 0);
+ write_signals(&printer_select_bus, 0xffffffff);
+ write_signals(&printer_reset_bus, 0xffffffff);
register_event(this, EVENT_PRINTER_RESET_COMPLETED, 5.0 * 1000.0, false, NULL);
if(lpt_type == 0) {
printer->write_signal(SIG_PRINTER_STROBE, 0x00, 0xff);
clock_fast = true;
}
if(f != clock_fast) {
- this->write_signal(FM7_MAINIO_CLOCKMODE, clock_fast ? 1 : 0, 1);
+ write_signal(FM7_MAINIO_CLOCKMODE, clock_fast ? 1 : 0, 1);
}
}
void FM7_MAINIO::set_port_fd00(uint8_t data)
{
if(drec != NULL) {
- drec->write_signal(SIG_DATAREC_MIC, data, 0x01);
- drec->write_signal(SIG_DATAREC_REMOTE, data, 0x02);
+ call_write_signal(drec, SIG_DATAREC_MIC, data, 0x01);
+ call_write_signal(drec, SIG_DATAREC_REMOTE, data, 0x02);
}
lpt_slctin = ((data & 0x80) == 0);
lpt_strobe = ((data & 0x40) != 0);
- this->write_signals(&printer_strobe_bus, lpt_strobe ? 0xffffffff : 0);
- this->write_signals(&printer_select_bus, lpt_slctin ? 0xffffffff : 0);
+ write_signals(&printer_strobe_bus, lpt_strobe ? 0xffffffff : 0);
+ write_signals(&printer_select_bus, lpt_slctin ? 0xffffffff : 0);
if((lpt_type == 0) && (lpt_slctin)) {
printer->write_signal(SIG_PRINTER_STROBE, lpt_strobe ? 0xff : 0x00, 0xff);
}
irqmask_keyboard = true;
}
if(keyirq_bak != irqmask_keyboard) {
- display->write_signal(SIG_FM7_SUB_KEY_MASK, irqmask_keyboard ? 1 : 0, 1);
+ call_write_signal(display, SIG_FM7_SUB_KEY_MASK, irqmask_keyboard ? 1 : 0, 1);
set_irq_keyboard(irqreq_keyboard);
}
//#endif
{
// NOOP?
#if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
- display->write_signal(SIG_DISPLAY_EXTRA_MODE, val, 0xff);
+ call_write_signal(display, SIG_DISPLAY_EXTRA_MODE, val, 0xff);
stat_kanjirom = ((val & 0x20) != 0);
#elif defined(_FM77_VARIANTS)
- display->write_signal(SIG_DISPLAY_EXTRA_MODE, val, 0xff);
+ call_write_signal(display, SIG_DISPLAY_EXTRA_MODE, val, 0xff);
stat_kanjirom = ((val & 0x20) != 0);
#endif
#if defined(HAS_2HD)
sub_cancel = ((val & 0x40) != 0) ? true : false;
sub_halt = ((val & 0x80) != 0) ? true : false;
//if(sub_halt != sub_halt_bak) {
- display->write_signal(SIG_DISPLAY_HALT, (sub_halt) ? 0xff : 0x00, 0xff);
+ call_write_signal(display, SIG_DISPLAY_HALT, (sub_halt) ? 0xff : 0x00, 0xff);
//}
sub_halt_bak = sub_halt;
//if(sub_cancel != sub_cancel_bak) {
- display->write_signal(SIG_FM7_SUB_CANCEL, (sub_cancel) ? 0xff : 0x00, 0xff); // HACK
+ call_write_signal(display, SIG_FM7_SUB_CANCEL, (sub_cancel) ? 0xff : 0x00, 0xff); // HACK
//}
sub_cancel_bak = sub_cancel;
#ifdef WITH_Z80
if((val & 0x01) != 0) {
- maincpu->write_signal(SIG_CPU_HALTREQ, 1, 1);
+ call_write_signal(maincpu, SIG_CPU_HALTREQ, 1, 1);
req_z80run = true;
} else {
req_z80run = false;
- if(z80 != NULL) z80->write_signal(SIG_CPU_BUSREQ, 1, 1);
+ if(z80 != NULL) call_write_signal(z80, SIG_CPU_BUSREQ, 1, 1);
}
#endif
}
void FM7_MAINIO::write_fd0f(void)
{
- mainmem->write_signal(FM7_MAINIO_PUSH_FD0F, 0, 0xffffffff);
+ call_write_signal(mainmem, FM7_MAINIO_PUSH_FD0F, 0, 0xffffffff);
}
uint8_t FM7_MAINIO::read_fd0f(void)
{
- mainmem->write_signal(FM7_MAINIO_PUSH_FD0F, 0xffffffff, 0xffffffff);
+ call_write_signal(mainmem, FM7_MAINIO_PUSH_FD0F, 0xffffffff, 0xffffffff);
return 0xff;
}
} else {
clock_fast = false;
}
- this->write_signals(&clock_status, clock_fast ? 0xffffffff : 0);
+ write_signals(&clock_status, clock_fast ? 0xffffffff : 0);
break;
case FM7_MAINIO_CMT_RECV: // FD02
cmt_indat = val_b ^ cmt_invert;
#if defined(WITH_Z80)
case FM7_MAINIO_RUN_Z80:
if((req_z80run)/* && (val_b) */) {
- if(z80 != NULL) z80->write_signal(SIG_CPU_BUSREQ, 0, 1);
+ if(z80 != NULL) call_write_signal(z80, SIG_CPU_BUSREQ, 0, 1);
z80_run = true;
//z80->reset(); // OK?
}
if(!(req_z80run) /* && (val_b) */ && (z80_run)) {
z80_run = false;
// Wait dead cycle?
- maincpu->write_signal(SIG_CPU_HALTREQ, 0, 1);
+ call_write_signal(maincpu, SIG_CPU_HALTREQ, 0, 1);
}
break;
#endif
#if defined(_FM77AV_VARIANTS)
case 0x10:
flag = ((data & 0x02) == 0) ? true : false;
- mainmem->write_signal(FM7_MAINIO_INITROM_ENABLED, (flag) ? 0xffffffff : 0 , 0xffffffff);
+ call_write_signal(mainmem, FM7_MAINIO_INITROM_ENABLED, (flag) ? 0xffffffff : 0 , 0xffffffff);
break;
case 0x12:
- display->write_signal(SIG_DISPLAY_MODE320, data, 0x40);
+ call_write_signal(display, SIG_DISPLAY_MODE320, data, 0x40);
reg_fd12 &= ~0x40;
reg_fd12 |= (data & 0x40);
break;
case 0x13:
sub_monitor_type = data & 0x07;
- display->write_signal(SIG_FM7_SUB_BANK, sub_monitor_type, 0x07);
+ call_write_signal(display, SIG_FM7_SUB_BANK, sub_monitor_type, 0x07);
break;
#endif
case 0x15: // OPN CMD
break;
#if defined(CAPABLE_DICTROM)
case 0x2e: //
- mainmem->write_signal(FM7_MAINIO_EXTBANK, data, 0xff);
+ call_write_signal(mainmem, FM7_MAINIO_EXTBANK, data, 0xff);
break;
#endif
#if defined(_FM77AV_VARIANTS)
#endif
//#if !defined(_FM8)
case 0x37: // Multi page
- display->write_signal(SIG_DISPLAY_MULTIPAGE, data, 0x00ff);
+ call_write_signal(display, SIG_DISPLAY_MULTIPAGE, data, 0x00ff);
break;
case 0x40: // MODEM
case 0x41:
mainmem->write_data8(FM7_MAINIO_WINDOW_OFFSET, (uint32_t)(data & 0x00ff));
break;
case 0x93:
- mainmem->write_signal(FM7_MAINIO_BOOTRAM_RW, data, 0x01);
- mainmem->write_signal(FM7_MAINIO_WINDOW_ENABLED, data , 0x40);
+ call_write_signal(mainmem, FM7_MAINIO_BOOTRAM_RW, data, 0x01);
+ call_write_signal(mainmem, FM7_MAINIO_WINDOW_ENABLED, data , 0x40);
//this->write_signal(FM7_MAINIO_CLOCKMODE, clock_fast ? 1 : 0, 1);
//mainmem->write_signal(FM7_MAINIO_CLOCKMODE, clock_fast ? 1 : 0, 1);
- mainmem->write_signal(FM7_MAINIO_MMR_ENABLED, data, 0x80);
+ call_write_signal(mainmem, FM7_MAINIO_MMR_ENABLED, data, 0x80);
//}
break;
#endif
#if defined(_FM77AV40) || defined(_FM77AV40SX) || defined(_FM77AV40EX) || \
defined(_FM77AV20) || defined(_FM77AV20SX) || defined(_FM77AV20EX)
case 0x94:
- mainmem->write_signal(FM7_MAINIO_MMR_EXTENDED, data, 0x80);
- mainmem->write_signal(FM7_MAINIO_MEM_REFRESH_FAST, data, 0x04);
- mainmem->write_signal(FM7_MAINIO_WINDOW_FAST , data, 0x01);
+ call_write_signal(mainmem, FM7_MAINIO_MMR_EXTENDED, data, 0x80);
+ call_write_signal(mainmem, FM7_MAINIO_MEM_REFRESH_FAST, data, 0x04);
+ call_write_signal(mainmem, FM7_MAINIO_WINDOW_FAST , data, 0x01);
break;
# if defined(_FM77AV40SX) || defined(_FM77AV40EX)
case 0x95:
- mainmem->write_signal(FM7_MAINIO_FASTMMR_ENABLED, data, 0x08);
- mainmem->write_signal(FM7_MAINIO_EXTROM, data , 0x80);
+ call_write_signal(mainmem, FM7_MAINIO_FASTMMR_ENABLED, data, 0x08);
+ call_write_signal(mainmem, FM7_MAINIO_EXTROM, data , 0x80);
break;
# endif
#endif
event_beep_cycle();
break;
case EVENT_UP_BREAK:
- keyboard->write_signal(SIG_FM7KEY_OVERRIDE_PRESS_BREAK, 0, 0xffffffff);
+ call_write_signal(keyboard, SIG_FM7KEY_OVERRIDE_PRESS_BREAK, 0, 0xffffffff);
set_break_key(false);
break;
//#if !defined(_FM8)
break;
#endif
case EVENT_PRINTER_RESET_COMPLETED:
- this->write_signals(&printer_reset_bus, 0x00);
+ write_signals(&printer_reset_bus, 0x00);
break;
default:
break;
clock_fast = false;
break;
}
- this->write_signals(&clock_status, clock_fast ? 0xffffffff : 0);
+ write_signals(&clock_status, clock_fast ? 0xffffffff : 0);
}
void FM7_MAINIO::event_vline(int v, int clock)
class MB8877;
class I8251;
class AND;
-
#if defined(HAS_DMA)
class HD6844;
#endif
+class JOYSTICK;
+class FM7_MAINMEM;
+class DISPLAY;
+class KEYBOARD;
+class KANJIROM;
+#if defined(CAPABLE_JCOMMCARD)
+class FM7_JCOMMCARD;
+#endif
+
class FM7_MAINIO : public DEVICE {
protected:
bool opn_psg_77av;
#endif
DATAREC* drec;
- DEVICE* pcm1bit;
- DEVICE* joystick;
+ PCM1BIT* pcm1bit;
+ JOYSTICK* joystick;
I8251 *uart[3];
# if defined(_FM77AV20) || defined(_FM77AV40) || defined(_FM77AV20EX) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
DEVICE *printer;
//FM7_RS232C *rs232c;
/* */
- DEVICE *kanjiclass1;
- DEVICE *kanjiclass2;
- DEVICE *display;
- DEVICE *keyboard;
+ KANJIROM *kanjiclass1;
+ KANJIROM *kanjiclass2;
+ DISPLAY *display;
+ KEYBOARD *keyboard;
MC6809 *maincpu;
- DEVICE *mainmem;
+ FM7_MAINMEM *mainmem;
MC6809 *subcpu;
#ifdef WITH_Z80
Z80 *z80;
#endif
#if defined(CAPABLE_JCOMMCARD)
- DEVICE *jcommcard;
+ FM7_JCOMMCARD *jcommcard;
#endif
+ template <class T>
+ void call_write_signal(T *np, int id, uint32_t data, uint32_t mask)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_signal(id, data, mask);
+ }
+ template <class T>
+ void call_write_data8(T *np, uint32_t addr, uint32_t data)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_data8(addr, data);
+ }
+ template <class T>
+ uint32_t call_read_data8(T *np, uint32_t addr)
+ {
+ //T *nnp = static_cast<T *>(np);
+ return static_cast<T *>(np)->read_data8(addr);
+ }
+ template <class T>
+ void call_write_dma_data8(T *np, uint32_t addr, uint32_t data)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_dma_data8(addr, data);
+ }
+ template <class T>
+ uint32_t call_read_dma_data8(T *np, uint32_t addr)
+ {
+ //T *nnp = static_cast<T *>(np);
+ return static_cast<T *>(np)->read_dma_data8(addr);
+ }
public:
FM7_MAINIO(VM* parent_vm, EMU* parent_emu);
~FM7_MAINIO();
}
void set_context_kanjirom_class1(DEVICE *p)
{
- kanjiclass1 = p;
+ kanjiclass1 = (KANJIROM *)p;
if(p != NULL) connect_kanjiroml1 = true;
}
virtual void set_context_kanjirom_class2(DEVICE *p)
{
#if defined(_FM77AV_VARIANTS)
- kanjiclass2 = p;
+ kanjiclass2 = (KANJIROM *)p;
if(p != NULL) connect_kanjiroml2 = true;
#endif
}
void set_context_beep(DEVICE *p)
{
- pcm1bit = p;
+ pcm1bit = (PCM1BIT *)p;
//beep = p;
}
void set_context_datarec(DATAREC *p)
{
- drec = p;
+ drec = (DATAREC *)p;
}
//#if !defined(_FM8)
void set_context_opn(YM2203 *p, int ch)
maincpu = p;
}
void set_context_mainmem(DEVICE *p){
- mainmem = p;
+ mainmem = (FM7_MAINMEM *)p;
}
void set_context_subcpu(MC6809 *p){
subcpu = p;
}
void set_context_display(DEVICE *p){
- display = p;
+ display = (DISPLAY *)p;
}
void set_context_keyboard(DEVICE *p){
- keyboard = p;
+ keyboard = (KEYBOARD *)p;
}
void set_context_joystick(DEVICE *p){
- joystick = p;
+ joystick = (JOYSTICK *)p;
}
void set_context_clock_status(DEVICE *p, int id, uint32_t mask) {
register_output_signal(&clock_status, p, id, mask);
}
void set_context_jcommcard(DEVICE *p) {
#if defined(CAPABLE_JCOMMCARD)
- jcommcard = p;
+ jcommcard = (FM7_JCOMMCARD *)p;
#endif
}
void set_context_uart(int num, I8251 *p) {
#include "vm.h"
#include "emu.h"
#include "fm7_mainmem.h"
-
+#include "fm7_mainio.h"
+#include "fm7_display.h"
+#if defined(CAPABLE_DICTROM)
+#include "kanjirom.h"
+#endif
FM7_MAINMEM::FM7_MAINMEM(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
p_vm = parent_vm;
}
}
+uint32_t FM7_MAINMEM::read_io8(uint32_t addr)
+{
+ return mainio->read_io8(addr);
+}
+
+void FM7_MAINMEM::write_io8(uint32_t addr, uint32_t data)
+{
+ return mainio->write_io8(addr, data);
+}
uint32_t FM7_MAINMEM::read_dma_data8(uint32_t addr)
{
void FM7_MAINMEM::write_dma_data8(uint32_t addr, uint32_t data)
{
#if defined(HAS_MMR)
- this->write_data8_main(addr & 0xffff, data, true);
+ write_data8_main(addr & 0xffff, data, true);
#else
- this->write_data8(addr & 0xffff, data);
+ write_data8(addr & 0xffff, data);
#endif
}
void FM7_MAINMEM::write_dma_io8(uint32_t addr, uint32_t data)
{
#if defined(HAS_MMR)
- this->write_data8_main(addr & 0xffff, data, true);
+ write_data8_main(addr & 0xffff, data, true);
#else
- this->write_data8(addr & 0xffff, data);
+ write_data8(addr & 0xffff, data);
#endif
}
{
state_fio->FputUint32_BE(STATE_VERSION);
state_fio->FputInt32_BE(this_device_id);
- this->out_debug_log(_T("Save State: MAINMEM: id=%d ver=%d\n"), this_device_id, STATE_VERSION);
+ out_debug_log(_T("Save State: MAINMEM: id=%d ver=%d\n"), this_device_id, STATE_VERSION);
// V1
state_fio->FputBool(ioaccess_wait);
uint32_t version;
version = state_fio->FgetUint32_BE();
if(this_device_id != state_fio->FgetInt32_BE()) return false;
- this->out_debug_log(_T("Load State: MAINMEM: id=%d ver=%d\n"), this_device_id, version);
+ out_debug_log(_T("Load State: MAINMEM: id=%d ver=%d\n"), this_device_id, version);
if(version >= 1) {
// V1
ioaccess_wait = state_fio->FgetBool();
class DEVICE;
class MEMORY;
class FM7_MAINIO;
+class KANJIROM;
+class DISPLAY;
class FM7_MAINMEM : public DEVICE
{
# endif
#endif
#if defined(CAPABLE_DICTROM)
- DEVICE *kanjiclass1;
+ KANJIROM *kanjiclass1;
//KANJIROM *kanjiclass2;
#endif
MC6809 *maincpu;
- DEVICE *mainio;
- DEVICE *display;
+ FM7_MAINIO *mainio;
+ DISPLAY *display;
bool diag_load_basicrom;
bool diag_load_bootrom_bas;
uint8_t read_with_mmr(uint32_t addr, uint32_t segment, uint32_t dmamode);
void write_with_mmr(uint32_t addr, uint32_t segment, uint32_t data, uint32_t dmamode);
+ template <class T>
+ void call_write_signal(T *np, int id, uint32_t data, uint32_t mask)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_signal(id, data, mask);
+ }
+ template <class T>
+ void call_write_data8(T *np, uint32_t addr, uint32_t data)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_data8(addr, data);
+ }
+ template <class T>
+ uint32_t call_read_data8(T *np, uint32_t addr)
+ {
+ //T *nnp = static_cast<T *>(np);
+ return static_cast<T *>(np)->read_data8(addr);
+ }
+ template <class T>
+ void call_write_dma_data8(T *np, uint32_t addr, uint32_t data)
+ {
+ //T *nnp = static_cast<T *>(np);
+ static_cast<T *>(np)->write_dma_data8(addr, data);
+ }
+ template <class T>
+ uint32_t call_read_dma_data8(T *np, uint32_t addr)
+ {
+ //T *nnp = static_cast<T *>(np);
+ return static_cast<T *>(np)->read_dma_data8(addr);
+ }
public:
FM7_MAINMEM(VM* parent_vm, EMU* parent_emu);
~FM7_MAINMEM();
bool load_state(FILEIO *state_fio);
void set_context_display(DEVICE *p){
- display = p;
+ display = (DISPLAY *)p;
}
void set_context_maincpu(MC6809 *p){
- maincpu = p;
+ maincpu = (MC6809 *)p;
}
void set_context_mainio(DEVICE *p){
- mainio = p;
+ mainio = (FM7_MAINIO *)p;
}
#if defined(CAPABLE_DICTROM)
void set_context_kanjirom_class1(DEVICE *p){
- kanjiclass1 = p;
+ kanjiclass1 = (KANJIROM *)p;
}
#endif
void write_signal(int sigid, uint32_t data, uint32_t mask);
uint32_t read_signal(int sigid);
- uint32_t read_io8(uint32_t addr) {
- return mainio->read_io8(addr);
- }
- void write_io8(uint32_t addr, uint32_t data) {
- return mainio->write_io8(addr, data);
- }
+ uint32_t read_io8(uint32_t addr);
+ void write_io8(uint32_t addr, uint32_t data);
};
#endif
#include "vm.h"
#include "emu.h"
#include "fm7_mainmem.h"
+#include "./kanjirom.h"
int FM7_MAINMEM::check_page2(uint32_t addr, uint32_t *realaddr, bool write_state, bool dmamode)
{
uint8_t FM7_MAINMEM::read_kanjirom_level1(uint32_t realaddr, bool dmamode)
{
#if defined(CAPABLE_DICTROM)
- return kanjiclass1->read_data8(KANJIROM_DIRECTADDR + realaddr);
+ return call_read_data8(kanjiclass1, KANJIROM_DIRECTADDR + realaddr);
#else
return 0xff;
#endif
#include "vm.h"
#include "emu.h"
#include "fm7_mainmem.h"
+#include "fm7_mainio.h"
+#include "fm7_display.h"
+#include "kanjirom.h"
uint8_t FM7_MAINMEM::read_data_tbl(uint32_t addr, bool dmamode)
{
{
realaddr = realaddr & 0x7f;
if(!sub_halted) return 0xff; // Not halt
- return display->read_data8(realaddr + 0xd380); // Okay?
+ return call_read_data8(display, realaddr + 0xd380); // Okay?
}
uint8_t FM7_MAINMEM::read_direct_access(uint32_t realaddr, bool dmamode)
#if defined(_FM77AV_VARIANTS)
if(!sub_halted) return 0xff; // Not halt
if(dmamode) {
- return display->read_dma_data8(realaddr & 0xffff); // Okay?
+ return call_read_dma_data8(display, realaddr & 0xffff); // Okay?
} else {
- return display->read_data8(realaddr & 0xffff); // Okay?
+ return call_read_data8(display, realaddr & 0xffff); // Okay?
}
#else
return 0xff;
addr &= 0xff;
iowait();
if(mainio != NULL) {
- return mainio->read_data8(addr);
+ return call_read_data8(mainio, addr);
}
return 0xff;
}
#include "vm.h"
#include "emu.h"
#include "fm7_mainmem.h"
+#include "fm7_mainio.h"
+#include "fm7_display.h"
+#include "kanjirom.h"
void FM7_MAINMEM::write_data_tbl(uint32_t addr, uint32_t data, bool dmamode)
{
{
realaddr = realaddr & 0x7f;
if(!sub_halted) return; // Not halt
- return display->write_data8(realaddr + 0xd380, data); // Okay?
+ return call_write_data8(display, realaddr + 0xd380, data); // Okay?
}
void FM7_MAINMEM::write_direct_access(uint32_t realaddr, uint32_t data, bool dmamode)
#if defined(_FM77AV_VARIANTS)
if(!sub_halted) return; // Not halt
if(dmamode) {
- display->write_dma_data8(realaddr & 0xffff, data); // Okay?
+ call_write_dma_data8(display, realaddr & 0xffff, data); // Okay?
} else {
- display->write_data8(realaddr & 0xffff, data); // Okay?
+ call_write_data8(display, realaddr & 0xffff, data); // Okay?
}
#else
return;
{
addr &= 0xff;
iowait();
- if(mainio != NULL) {
- mainio->write_data8(addr, data);
- }
+ call_write_data8(mainio, addr, data);
return;
}
#include "fm7_mainio.h"
#include "../ay_3_891x.h"
#include "../../config.h"
+#include "./joystick.h"
void FM7_MAINIO::reset_sound(void)
{
OSDN Git Service
