diff --git a/src/mess/drivers/x68k.c b/src/mess/drivers/x68k.c index 1264e153f25..9ce6148eb08 100644 --- a/src/mess/drivers/x68k.c +++ b/src/mess/drivers/x68k.c @@ -168,13 +168,12 @@ static attotime prescale(int val) } #endif -static void mfp_init(running_machine &machine) +void x68k_state::mfp_init() { - x68k_state *state = machine.driver_data(); - state->m_mfp.tadr = state->m_mfp.tbdr = state->m_mfp.tcdr = state->m_mfp.tddr = 0xff; + m_mfp.tadr = m_mfp.tbdr = m_mfp.tcdr = m_mfp.tddr = 0xff; - state->m_mfp.irqline = 6; // MFP is connected to 68000 IRQ line 6 - state->m_mfp.current_irq = -1; // No current interrupt + m_mfp.irqline = 6; // MFP is connected to 68000 IRQ line 6 + m_mfp.current_irq = -1; // No current interrupt #if 0 mfp_timer[0] = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(x68k_state::mfp_timer_a_callback),this)); @@ -338,19 +337,19 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_led_callback) } // 4 channel DMA controller (Hitachi HD63450) -static WRITE16_HANDLER( x68k_dmac_w ) +WRITE16_HANDLER(x68k_state::x68k_dmac_w) { - device_t* device = space.machine().device("hd63450"); + device_t* device = machine().device("hd63450"); hd63450_w(device, space, offset, data, mem_mask); } -static READ16_HANDLER( x68k_dmac_r ) +READ16_HANDLER(x68k_state::x68k_dmac_r) { - device_t* device = space.machine().device("hd63450"); + device_t* device = machine().device("hd63450"); return hd63450_r(device, space, offset, mem_mask); } -static void x68k_keyboard_ctrl_w(x68k_state *state, int data) +void x68k_state::x68k_keyboard_ctrl_w(int data) { /* Keyboard control commands: 00xxxxxx - TV Control @@ -403,63 +402,62 @@ static void x68k_keyboard_ctrl_w(x68k_state *state, int data) if((data & 0xf8) == 0x48) // Keyboard enable { - state->m_keyboard.enabled = data & 0x01; - logerror("KB: Keyboard enable bit = %i\n",state->m_keyboard.enabled); + m_keyboard.enabled = data & 0x01; + logerror("KB: Keyboard enable bit = %i\n",m_keyboard.enabled); } if((data & 0xf0) == 0x60) // Key delay time { - state->m_keyboard.delay = data & 0x0f; + m_keyboard.delay = data & 0x0f; logerror("KB: Keypress delay time is now %ims\n",(data & 0x0f)*100+200); } if((data & 0xf0) == 0x70) // Key repeat rate { - state->m_keyboard.repeat = data & 0x0f; + m_keyboard.repeat = data & 0x0f; logerror("KB: Keypress repeat rate is now %ims\n",((data & 0x0f)^2)*5+30); } } -static int x68k_keyboard_pop_scancode(x68k_state *state) +int x68k_state::x68k_keyboard_pop_scancode() { int ret; - if(state->m_keyboard.keynum == 0) // no scancodes in USART buffer + if(m_keyboard.keynum == 0) // no scancodes in USART buffer return 0x00; - state->m_keyboard.keynum--; - ret = state->m_keyboard.buffer[state->m_keyboard.tailpos++]; - if(state->m_keyboard.tailpos > 15) - state->m_keyboard.tailpos = 0; + m_keyboard.keynum--; + ret = m_keyboard.buffer[m_keyboard.tailpos++]; + if(m_keyboard.tailpos > 15) + m_keyboard.tailpos = 0; logerror("MFP: Keyboard buffer pop 0x%02x\n",ret); return ret; } -static void x68k_keyboard_push_scancode(running_machine &machine,unsigned char code) -{ - x68k_state *state = machine.driver_data(); - state->m_keyboard.keynum++; - if(state->m_keyboard.keynum >= 1) +void x68k_state::x68k_keyboard_push_scancode(unsigned char code) +{ + m_keyboard.keynum++; + if(m_keyboard.keynum >= 1) { // keyboard buffer full - if(state->m_keyboard.enabled != 0) + if(m_keyboard.enabled != 0) { - state->m_mfp.rsr |= 0x80; // Buffer full + m_mfp.rsr |= 0x80; // Buffer full // mfp_trigger_irq(MFP_IRQ_RX_FULL); - if(machine.root_device().ioport("options")->read() & 0x01) + if(machine().root_device().ioport("options")->read() & 0x01) { - state->m_current_vector[6] = 0x4c; - machine.device("maincpu")->execute().set_input_line_and_vector(6,ASSERT_LINE,0x4c); + m_current_vector[6] = 0x4c; + machine().device("maincpu")->execute().set_input_line_and_vector(6,ASSERT_LINE,0x4c); logerror("MFP: Receive buffer full IRQ sent\n"); } } } - state->m_keyboard.buffer[state->m_keyboard.headpos++] = code; - if(state->m_keyboard.headpos > 15) + m_keyboard.buffer[m_keyboard.headpos++] = code; + if(m_keyboard.headpos > 15) { - state->m_keyboard.headpos = 0; + m_keyboard.headpos = 0; // mfp_trigger_irq(MFP_IRQ_RX_ERROR); - state->m_current_vector[6] = 0x4b; + m_current_vector[6] = 0x4b; // machine.device("maincpu")->execute().set_input_line_and_vector(6,ASSERT_LINE,0x4b); } } @@ -480,7 +478,7 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_keyboard_poll) { if(m_keyboard.keyon[x] != 0) { - x68k_keyboard_push_scancode(machine(),0x80 + x); + x68k_keyboard_push_scancode(0x80 + x); m_keyboard.keytime[x] = 0; m_keyboard.keyon[x] = 0; m_keyboard.last_pressed = 0; @@ -492,7 +490,7 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_keyboard_poll) { if(machine().root_device().ioport(keynames[m_keyboard.last_pressed / 32])->read() & (1 << (m_keyboard.last_pressed % 32))) { - x68k_keyboard_push_scancode(machine(),m_keyboard.last_pressed); + x68k_keyboard_push_scancode(m_keyboard.last_pressed); m_keyboard.keytime[m_keyboard.last_pressed] = (m_keyboard.repeat^2)*5+30; logerror("KB: Holding key 0x%02x\n",m_keyboard.last_pressed); } @@ -501,7 +499,7 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_keyboard_poll) { if(m_keyboard.keyon[x] == 0) { - x68k_keyboard_push_scancode(machine(),x); + x68k_keyboard_push_scancode(x); m_keyboard.keytime[x] = m_keyboard.delay * 100 + 200; m_keyboard.keyon[x] = 1; m_keyboard.last_pressed = x; @@ -528,38 +526,37 @@ void mfp_recv_data(int data) // mouse input // port B of the Z8530 SCC // typically read from the SCC data port on receive buffer full interrupt per byte -static int x68k_read_mouse(running_machine &machine) +int x68k_state::x68k_read_mouse() { - x68k_state *state = machine.driver_data(); - scc8530_t *scc = machine.device("scc"); + scc8530_t *scc = machine().device("scc"); char val = 0; char ipt = 0; if(!(scc->get_reg_b(5) & 0x02)) return 0xff; - switch(state->m_mouse.inputtype) + switch(m_mouse.inputtype) { case 0: - ipt = machine.root_device().ioport("mouse1")->read(); + ipt = machine().root_device().ioport("mouse1")->read(); break; case 1: - val = machine.root_device().ioport("mouse2")->read(); - ipt = val - state->m_mouse.last_mouse_x; - state->m_mouse.last_mouse_x = val; + val = machine().root_device().ioport("mouse2")->read(); + ipt = val - m_mouse.last_mouse_x; + m_mouse.last_mouse_x = val; break; case 2: - val = machine.root_device().ioport("mouse3")->read(); - ipt = val - state->m_mouse.last_mouse_y; - state->m_mouse.last_mouse_y = val; + val = machine().root_device().ioport("mouse3")->read(); + ipt = val - m_mouse.last_mouse_y; + m_mouse.last_mouse_y = val; break; } - state->m_mouse.inputtype++; - if(state->m_mouse.inputtype > 2) + m_mouse.inputtype++; + if(m_mouse.inputtype > 2) { int i_val = scc->get_reg_b(0); - state->m_mouse.inputtype = 0; - state->m_mouse.bufferempty = 1; + m_mouse.inputtype = 0; + m_mouse.bufferempty = 1; i_val &= ~0x01; scc->set_reg_b(0, i_val); logerror("SCC: mouse buffer empty\n"); @@ -574,16 +571,16 @@ static int x68k_read_mouse(running_machine &machine) 0xe98005 - Z8530 command port A 0xe98007 - Z8530 data port A (RS232) */ -static READ16_HANDLER( x68k_scc_r ) +READ16_MEMBER(x68k_state::x68k_scc_r ) { - scc8530_t *scc = space.machine().device("scc"); + scc8530_t *scc = machine().device("scc"); offset %= 4; switch(offset) { case 0: return scc->reg_r(space, 0); case 1: - return x68k_read_mouse(space.machine()); + return x68k_read_mouse(); case 2: return scc->reg_r(space, 1); case 3: @@ -593,22 +590,21 @@ static READ16_HANDLER( x68k_scc_r ) } } -static WRITE16_HANDLER( x68k_scc_w ) +WRITE16_MEMBER(x68k_state::x68k_scc_w ) { - x68k_state *state = space.machine().driver_data(); - scc8530_t *scc = space.machine().device("scc"); + scc8530_t *scc = machine().device("scc"); offset %= 4; switch(offset) { case 0: scc->reg_w(space, 0,(UINT8)data); - if((scc->get_reg_b(5) & 0x02) != state->m_scc_prev) + if((scc->get_reg_b(5) & 0x02) != m_scc_prev) { if(scc->get_reg_b(5) & 0x02) // Request to Send { int val = scc->get_reg_b(0); - state->m_mouse.bufferempty = 0; + m_mouse.bufferempty = 0; val |= 0x01; scc->set_reg_b(0,val); } @@ -624,7 +620,7 @@ static WRITE16_HANDLER( x68k_scc_w ) scc->reg_w(space, 3,(UINT8)data); break; } - state->m_scc_prev = scc->get_reg_b(5) & 0x02; + m_scc_prev = scc->get_reg_b(5) & 0x02; } TIMER_CALLBACK_MEMBER(x68k_state::x68k_scc_ack) @@ -652,13 +648,12 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_scc_ack) } } -static void x68k_set_adpcm(running_machine &machine) +void x68k_state::x68k_set_adpcm() { - x68k_state *state = machine.driver_data(); - device_t *dev = machine.device("hd63450"); + device_t *dev = machine().device("hd63450"); UINT32 rate = 0; - switch(state->m_adpcm.rate & 0x0c) + switch(m_adpcm.rate & 0x0c) { case 0x00: rate = 7812/2; @@ -673,7 +668,7 @@ static void x68k_set_adpcm(running_machine &machine) logerror("PPI: Invalid ADPCM sample rate set.\n"); rate = 15625/2; } - if(state->m_adpcm.clock != 0) + if(m_adpcm.clock != 0) rate = rate/2; hd63450_set_timer(dev,3,attotime::from_hz(rate)); } @@ -684,14 +679,13 @@ static void x68k_set_adpcm(running_machine &machine) // Button inputs (Start, A, B and C) are read in bits 5 and 6 (rather than 4 // and 5 like on a Megadrive) -static UINT8 md_3button_r(device_t* device, int port) +UINT8 x68k_state::md_3button_r(int port) { - x68k_state *state = device->machine().driver_data(); if(port == 1) { - UINT8 porta = device->machine().root_device().ioport("md3b")->read() & 0xff; - UINT8 portb = (state->ioport("md3b")->read() >> 8) & 0xff; - if(state->m_mdctrl.mux1 & 0x10) + UINT8 porta = machine().root_device().ioport("md3b")->read() & 0xff; + UINT8 portb = (ioport("md3b")->read() >> 8) & 0xff; + if(m_mdctrl.mux1 & 0x10) { return porta | 0x90; } @@ -702,9 +696,9 @@ static UINT8 md_3button_r(device_t* device, int port) } if(port == 2) { - UINT8 porta = (device->machine().root_device().ioport("md3b")->read() >> 16) & 0xff; - UINT8 portb = (device->machine().root_device().ioport("md3b")->read() >> 24) & 0xff; - if(state->m_mdctrl.mux2 & 0x20) + UINT8 porta = (machine().root_device().ioport("md3b")->read() >> 16) & 0xff; + UINT8 portb = (machine().root_device().ioport("md3b")->read() >> 24) & 0xff; + if(m_mdctrl.mux2 & 0x20) { return porta | 0x90; } @@ -727,27 +721,25 @@ TIMER_CALLBACK_MEMBER(x68k_state::md_6button_port2_timeout) m_mdctrl.seq2 = 0; } -static void md_6button_init(running_machine &machine) +void x68k_state::md_6button_init() { - x68k_state *state = machine.driver_data(); - state->m_mdctrl.io_timeout1 = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(x68k_state::md_6button_port1_timeout),state)); - state->m_mdctrl.io_timeout2 = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(x68k_state::md_6button_port2_timeout),state)); + m_mdctrl.io_timeout1 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(x68k_state::md_6button_port1_timeout),this)); + m_mdctrl.io_timeout2 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(x68k_state::md_6button_port2_timeout),this)); } -static UINT8 md_6button_r(device_t* device, int port) +UINT8 x68k_state::md_6button_r(int port) { - x68k_state *state = device->machine().driver_data(); if(port == 1) { - UINT8 porta = device->machine().root_device().ioport("md6b")->read() & 0xff; - UINT8 portb = (device->machine().root_device().ioport("md6b")->read() >> 8) & 0xff; - UINT8 extra = state->ioport("md6b_extra")->read() & 0x0f; + UINT8 porta = machine().root_device().ioport("md6b")->read() & 0xff; + UINT8 portb = (machine().root_device().ioport("md6b")->read() >> 8) & 0xff; + UINT8 extra = ioport("md6b_extra")->read() & 0x0f; - switch(state->m_mdctrl.seq1) + switch(m_mdctrl.seq1) { case 1: default: - if(state->m_mdctrl.mux1 & 0x10) + if(m_mdctrl.mux1 & 0x10) { return porta | 0x90; } @@ -756,7 +748,7 @@ static UINT8 md_6button_r(device_t* device, int port) return (portb & 0x60) | (porta & 0x03) | 0x90; } case 2: - if(state->m_mdctrl.mux1 & 0x10) + if(m_mdctrl.mux1 & 0x10) { return porta | 0x90; } @@ -765,7 +757,7 @@ static UINT8 md_6button_r(device_t* device, int port) return (portb & 0x60) | 0x90; } case 3: - if(state->m_mdctrl.mux1 & 0x10) + if(m_mdctrl.mux1 & 0x10) { return (porta & 0x60) | (extra & 0x0f) | 0x90; } @@ -777,15 +769,15 @@ static UINT8 md_6button_r(device_t* device, int port) } if(port == 2) { - UINT8 porta = (device->machine().root_device().ioport("md6b")->read() >> 16) & 0xff; - UINT8 portb = (device->machine().root_device().ioport("md6b")->read() >> 24) & 0xff; - UINT8 extra = (device->machine().root_device().ioport("md6b_extra")->read() >> 4) & 0x0f; + UINT8 porta = (machine().root_device().ioport("md6b")->read() >> 16) & 0xff; + UINT8 portb = (machine().root_device().ioport("md6b")->read() >> 24) & 0xff; + UINT8 extra = (machine().root_device().ioport("md6b_extra")->read() >> 4) & 0x0f; - switch(state->m_mdctrl.seq2) + switch(m_mdctrl.seq2) { case 1: default: - if(state->m_mdctrl.mux2 & 0x20) + if(m_mdctrl.mux2 & 0x20) { return porta | 0x90; } @@ -794,7 +786,7 @@ static UINT8 md_6button_r(device_t* device, int port) return (portb & 0x60) | (porta & 0x03) | 0x90; } case 2: - if(state->m_mdctrl.mux2 & 0x20) + if(m_mdctrl.mux2 & 0x20) { return porta | 0x90; } @@ -803,7 +795,7 @@ static UINT8 md_6button_r(device_t* device, int port) return (portb & 0x60) | 0x90; } case 3: - if(state->m_mdctrl.mux2 & 0x20) + if(m_mdctrl.mux2 & 0x20) { return (porta & 0x60) | (extra & 0x0f) | 0x90; } @@ -823,14 +815,13 @@ static UINT8 md_6button_r(device_t* device, int port) // Output is the same as for standard controllers, but when ctl is high, // the directions refer to the right D-pad, and when low, the left D-pad // The buttons are read the same as normal, regardless of ctl. -static UINT8 xpd1lr_r(device_t* device, int port) +UINT8 x68k_state::xpd1lr_r(int port) { - x68k_state *state = device->machine().driver_data(); if(port == 1) { - UINT8 porta = device->machine().root_device().ioport("xpd1lr")->read() & 0xff; - UINT8 portb = (state->ioport("xpd1lr")->read() >> 8) & 0xff; - if(state->m_mdctrl.mux1 & 0x10) + UINT8 porta = machine().root_device().ioport("xpd1lr")->read() & 0xff; + UINT8 portb = (ioport("xpd1lr")->read() >> 8) & 0xff; + if(m_mdctrl.mux1 & 0x10) { return porta; } @@ -841,9 +832,9 @@ static UINT8 xpd1lr_r(device_t* device, int port) } if(port == 2) { - UINT8 porta = (device->machine().root_device().ioport("xpd1lr")->read() >> 16) & 0xff; - UINT8 portb = (device->machine().root_device().ioport("xpd1lr")->read() >> 24) & 0xff; - if(state->m_mdctrl.mux2 & 0x20) + UINT8 porta = (machine().root_device().ioport("xpd1lr")->read() >> 16) & 0xff; + UINT8 portb = (machine().root_device().ioport("xpd1lr")->read() >> 24) & 0xff; + if(m_mdctrl.mux2 & 0x20) { return porta; } @@ -868,11 +859,11 @@ READ8_MEMBER(x68k_state::ppi_port_a_r) else return 0xff; case 0x01: // 3-button Megadrive gamepad - return md_3button_r(machine().device("ppi8255"),1); + return md_3button_r(1); case 0x02: // 6-button Megadrive gamepad - return md_6button_r(machine().device("ppi8255"),1); + return md_6button_r(1); case 0x03: // XPD-1LR - return xpd1lr_r(machine().device("ppi8255"),1); + return xpd1lr_r(1); } return 0xff; @@ -890,11 +881,11 @@ READ8_MEMBER(x68k_state::ppi_port_b_r) else return 0xff; case 0x10: // 3-button Megadrive gamepad - return md_3button_r(machine().device("ppi8255"),2); + return md_3button_r(2); case 0x20: // 6-button Megadrive gamepad - return md_6button_r(machine().device("ppi8255"),2); + return md_6button_r(2); case 0x30: // XPD-1LR - return xpd1lr_r(machine().device("ppi8255"),2); + return xpd1lr_r(2); } return 0xff; @@ -923,7 +914,7 @@ WRITE8_MEMBER(x68k_state::ppi_port_c_w) { m_adpcm.pan = data & 0x03; m_adpcm.rate = data & 0x0c; - x68k_set_adpcm(machine()); + x68k_set_adpcm(); okim6258_set_divider(oki, (data >> 2) & 3); } @@ -951,10 +942,9 @@ WRITE8_MEMBER(x68k_state::ppi_port_c_w) // NEC uPD72065 at 0xe94000 -static WRITE16_HANDLER( x68k_fdc_w ) +WRITE16_MEMBER(x68k_state::x68k_fdc_w) { - x68k_state *state = space.machine().driver_data(); - device_t *fdc = space.machine().device("upd72065"); + device_t *fdc = machine().device("upd72065"); unsigned int drive, x; switch(offset) { @@ -966,35 +956,35 @@ static WRITE16_HANDLER( x68k_fdc_w ) x = data & 0x0f; for(drive=0;drive<4;drive++) { - if(state->m_fdc.selected_drive & (1 << drive)) + if(m_fdc.selected_drive & (1 << drive)) { if(!(x & (1 << drive))) // functions take place on 1->0 transitions of drive bits only { - state->m_fdc.led_ctrl[drive] = data & 0x80; // blinking drive LED if no disk inserted - state->m_fdc.led_eject[drive] = data & 0x40; // eject button LED (on when set to 0) + m_fdc.led_ctrl[drive] = data & 0x80; // blinking drive LED if no disk inserted + m_fdc.led_eject[drive] = data & 0x40; // eject button LED (on when set to 0) output_set_indexed_value("eject_drv",drive,(data & 0x40) ? 1 : 0); if(data & 0x20) // ejects disk { - (dynamic_cast(floppy_get_device(space.machine(), drive)))->unload(); - floppy_mon_w(floppy_get_device(space.machine(), drive), ASSERT_LINE); + (dynamic_cast(floppy_get_device(machine(), drive)))->unload(); + floppy_mon_w(floppy_get_device(machine(), drive), ASSERT_LINE); } } } } - state->m_fdc.selected_drive = data & 0x0f; + m_fdc.selected_drive = data & 0x0f; logerror("FDC: signal control set to %02x\n",data); break; case 0x03: - state->m_fdc.media_density[data & 0x03] = data & 0x10; - state->m_fdc.motor[data & 0x03] = data & 0x80; - floppy_mon_w(floppy_get_device(space.machine(), data & 0x03), !BIT(data, 7)); + m_fdc.media_density[data & 0x03] = data & 0x10; + m_fdc.motor[data & 0x03] = data & 0x80; + floppy_mon_w(floppy_get_device(machine(), data & 0x03), !BIT(data, 7)); if(data & 0x80) { for(drive=0;drive<4;drive++) // enable motor for this drive { if(drive == (data & 0x03)) { - floppy_mon_w(floppy_get_device(space.machine(), drive), CLEAR_LINE); + floppy_mon_w(floppy_get_device(machine(), drive), CLEAR_LINE); output_set_indexed_value("access_drv",drive,0); } else @@ -1005,14 +995,14 @@ static WRITE16_HANDLER( x68k_fdc_w ) { for(drive=0;drive<4;drive++) { - floppy_mon_w(floppy_get_device(space.machine(), drive), ASSERT_LINE); + floppy_mon_w(floppy_get_device(machine(), drive), ASSERT_LINE); output_set_indexed_value("access_drv",drive,1); } } - floppy_drive_set_ready_state(floppy_get_device(space.machine(), 0),1,1); - floppy_drive_set_ready_state(floppy_get_device(space.machine(), 1),1,1); - floppy_drive_set_ready_state(floppy_get_device(space.machine(), 2),1,1); - floppy_drive_set_ready_state(floppy_get_device(space.machine(), 3),1,1); + floppy_drive_set_ready_state(floppy_get_device(machine(), 0),1,1); + floppy_drive_set_ready_state(floppy_get_device(machine(), 1),1,1); + floppy_drive_set_ready_state(floppy_get_device(machine(), 2),1,1); + floppy_drive_set_ready_state(floppy_get_device(machine(), 3),1,1); #if 0 for(drive=0;drive<4;drive++) { @@ -1030,12 +1020,11 @@ static WRITE16_HANDLER( x68k_fdc_w ) } } -static READ16_HANDLER( x68k_fdc_r ) +READ16_MEMBER(x68k_state::x68k_fdc_r) { - x68k_state *state = space.machine().driver_data(); unsigned int ret; int x; - device_t *fdc = space.machine().device("upd72065"); + device_t *fdc = machine().device("upd72065"); switch(offset) { @@ -1047,10 +1036,10 @@ static READ16_HANDLER( x68k_fdc_r ) ret = 0x00; for(x=0;x<4;x++) { - if(state->m_fdc.selected_drive & (1 << x)) + if(m_fdc.selected_drive & (1 << x)) { ret = 0x00; - if(state->m_fdc.disk_inserted[x] != 0) + if(m_fdc.disk_inserted[x] != 0) { ret |= 0x80; } @@ -1104,21 +1093,21 @@ WRITE_LINE_MEMBER(x68k_state::fdc_drq) m_fdc.drq_state = state; } -static WRITE16_HANDLER( x68k_fm_w ) +WRITE16_MEMBER(x68k_state::x68k_fm_w) { switch(offset) { case 0x00: case 0x01: - ym2151_w(space.machine().device("ym2151"), space, offset, data); + ym2151_w(machine().device("ym2151"), space, offset, data); break; } } -static READ16_HANDLER( x68k_fm_r ) +READ16_MEMBER(x68k_state::x68k_fm_r) { if(offset == 0x01) - return ym2151_r(space.machine().device("ym2151"), space, 1); + return ym2151_r(machine().device("ym2151"), space, 1); return 0xffff; } @@ -1133,7 +1122,7 @@ WRITE8_MEMBER(x68k_state::x68k_ct_w) // CT2 - 1 = Set ready state of FDC upd765_ready_w(fdc,data & 0x01); m_adpcm.clock = data & 0x02; - x68k_set_adpcm(machine()); + x68k_set_adpcm(); okim6258_set_clock(okim, data & 0x02 ? 4000000 : 8000000); } @@ -1153,32 +1142,31 @@ WRITE8_MEMBER(x68k_state::x68k_ct_w) - bits 7-2 = vector - bits 1,0 = device (00 = FDC, 01 = FDD, 10 = HDD, 11 = Printer) */ -static WRITE16_HANDLER( x68k_ioc_w ) +WRITE16_MEMBER(x68k_state::x68k_ioc_w) { - x68k_state *state = space.machine().driver_data(); switch(offset) { case 0x00: - state->m_ioc.irqstatus = data & 0x0f; + m_ioc.irqstatus = data & 0x0f; logerror("I/O: Status register write %02x\n",data); break; case 0x01: switch(data & 0x03) { case 0x00: - state->m_ioc.fdcvector = data & 0xfc; + m_ioc.fdcvector = data & 0xfc; logerror("IOC: FDC IRQ vector = 0x%02x\n",data & 0xfc); break; case 0x01: - state->m_ioc.fddvector = data & 0xfc; + m_ioc.fddvector = data & 0xfc; logerror("IOC: FDD IRQ vector = 0x%02x\n",data & 0xfc); break; case 0x02: - state->m_ioc.hdcvector = data & 0xfc; + m_ioc.hdcvector = data & 0xfc; logerror("IOC: HDD IRQ vector = 0x%02x\n",data & 0xfc); break; case 0x03: - state->m_ioc.prnvector = data & 0xfc; + m_ioc.prnvector = data & 0xfc; logerror("IOC: Printer IRQ vector = 0x%02x\n",data & 0xfc); break; } @@ -1186,14 +1174,13 @@ static WRITE16_HANDLER( x68k_ioc_w ) } } -static READ16_HANDLER( x68k_ioc_r ) +READ16_MEMBER(x68k_state::x68k_ioc_r) { - x68k_state *state = space.machine().driver_data(); switch(offset) { case 0x00: logerror("I/O: Status register read\n"); - return (state->m_ioc.irqstatus & 0xdf) | 0x20; + return (m_ioc.irqstatus & 0xdf) | 0x20; default: return 0x00; } @@ -1219,23 +1206,22 @@ static READ16_HANDLER( x68k_ioc_r ) Any other value, then SRAM is read only. Port 8 (0xe8e00f) - Power off control - write 0x00, 0x0f, 0x0f sequentially to switch power off. */ -static WRITE16_HANDLER( x68k_sysport_w ) +WRITE16_MEMBER(x68k_state::x68k_sysport_w) { - x68k_state *state = space.machine().driver_data(); switch(offset) { case 0x00: - state->m_sysport.contrast = data & 0x0f; // often used for screen fades / blanking + m_sysport.contrast = data & 0x0f; // often used for screen fades / blanking // TODO: implement a decent, not slow, brightness control break; case 0x01: - state->m_sysport.monitor = data & 0x08; + m_sysport.monitor = data & 0x08; break; case 0x03: - state->m_sysport.keyctrl = data & 0x08; // bit 3 = enable keyboard data transmission + m_sysport.keyctrl = data & 0x08; // bit 3 = enable keyboard data transmission break; case 0x06: - state->m_sysport.sram_writeprotect = data; + m_sysport.sram_writeprotect = data; break; default: // logerror("SYS: [%08x] Wrote %04x to invalid or unimplemented system port %04x\n",space.device().safe_pc(),data,offset); @@ -1243,21 +1229,20 @@ static WRITE16_HANDLER( x68k_sysport_w ) } } -static READ16_HANDLER( x68k_sysport_r ) +READ16_MEMBER(x68k_state::x68k_sysport_r) { - x68k_state *state = space.machine().driver_data(); int ret = 0; switch(offset) { case 0x00: // monitor contrast setting (bits3-0) - return state->m_sysport.contrast; + return m_sysport.contrast; case 0x01: // monitor control (bit3) / 3D Scope (bits1,0) - ret |= state->m_sysport.monitor; + ret |= m_sysport.monitor; return ret; case 0x03: // bit 3 = key control (is 1 if keyboard is connected) return 0x08; case 0x05: // CPU type and speed - return state->m_sysport.cputype; + return m_sysport.cputype; default: logerror("Read from invalid or unimplemented system port %04x\n",offset); return 0xff; @@ -1265,17 +1250,16 @@ static READ16_HANDLER( x68k_sysport_r ) } #ifdef UNUSED_FUNCTION -static READ16_HANDLER( x68k_mfp_r ) +READ16_MEMBER(x68k_state::x68k_mfp_r) { - device_t *x68k_mfp = space.machine().device(MC68901_TAG); + device_t *x68k_mfp = machine().device(MC68901_TAG); return mc68901_register_r(x68k_mfp, offset); } #endif -static READ16_HANDLER( x68k_mfp_r ) +READ16_MEMBER(x68k_state::x68k_mfp_r) { - x68k_state *state = space.machine().driver_data(); // Initial settings indicate that IRQs are generated for FM (YM2151), Receive buffer error or full, // MFP Timer C, and the power switch @@ -1285,62 +1269,61 @@ static READ16_HANDLER( x68k_mfp_r ) #if 0 case 0x00: // GPIP - General purpose I/O register (read-only) ret = 0x23; - if(machine.primary_screen->vpos() == state->m_crtc.reg[9]) + if(machine.primary_screen->vpos() == m_crtc.reg[9]) ret |= 0x40; - if(state->m_crtc.vblank == 0) + if(m_crtc.vblank == 0) ret |= 0x10; // Vsync signal (low if in vertical retrace) -// if(state->m_mfp.isrb & 0x08) +// if(m_mfp.isrb & 0x08) // ret |= 0x08; // FM IRQ signal - if(machine.primary_screen->hpos() > state->m_crtc.width - 32) + if(machine.primary_screen->hpos() > m_crtc.width - 32) ret |= 0x80; // Hsync signal // logerror("MFP: [%08x] Reading offset %i (ret=%02x)\n",space.device().safe_pc(),offset,ret); return ret; // bit 5 is always 1 case 3: - return state->m_mfp.iera; + return m_mfp.iera; case 4: - return state->m_mfp.ierb; + return m_mfp.ierb; case 5: - return state->m_mfp.ipra; + return m_mfp.ipra; case 6: - return state->m_mfp.iprb; + return m_mfp.iprb; case 7: - if(state->m_mfp.eoi_mode == 0) // forced low in auto EOI mode + if(m_mfp.eoi_mode == 0) // forced low in auto EOI mode return 0; else - return state->m_mfp.isra; + return m_mfp.isra; case 8: - if(state->m_mfp.eoi_mode == 0) // forced low in auto EOI mode + if(m_mfp.eoi_mode == 0) // forced low in auto EOI mode return 0; else - return state->m_mfp.isrb; + return m_mfp.isrb; case 9: - return state->m_mfp.imra; + return m_mfp.imra; case 10: - return state->m_mfp.imrb; + return m_mfp.imrb; case 15: // TADR - return state->m_mfp.timer[0].counter; // Timer data registers return their main counter values + return m_mfp.timer[0].counter; // Timer data registers return their main counter values case 16: // TBDR - return state->m_mfp.timer[1].counter; + return m_mfp.timer[1].counter; case 17: // TCDR - return state->m_mfp.timer[2].counter; + return m_mfp.timer[2].counter; case 18: // TDDR - return state->m_mfp.timer[3].counter; + return m_mfp.timer[3].counter; #endif case 21: // RSR - return state->m_mfp.rsr; + return m_mfp.rsr; case 22: // TSR - return state->m_mfp.tsr | 0x80; // buffer is typically empty? + return m_mfp.tsr | 0x80; // buffer is typically empty? case 23: - return x68k_keyboard_pop_scancode(state); + return x68k_keyboard_pop_scancode(); default: - if (ACCESSING_BITS_0_7) return state->m_mfpdev->read(space, offset); + if (ACCESSING_BITS_0_7) return m_mfpdev->read(space, offset); } return 0xffff; } -static WRITE16_HANDLER( x68k_mfp_w ) +WRITE16_MEMBER(x68k_state::x68k_mfp_w) { - x68k_state *state = space.machine().driver_data(); /* For the Interrupt registers, the bits are set out as such: Reg A - bit 7: GPIP7 (HSync) @@ -1367,133 +1350,129 @@ static WRITE16_HANDLER( x68k_mfp_w ) // All bits are inputs generally, so no action taken. break; case 1: // AER - state->m_mfp.aer = data; + m_mfp.aer = data; break; case 2: // DDR - state->m_mfp.ddr = data; // usually all bits are 0 (input) + m_mfp.ddr = data; // usually all bits are 0 (input) break; case 3: // IERA - state->m_mfp.iera = data; + m_mfp.iera = data; break; case 4: // IERB - state->m_mfp.ierb = data; + m_mfp.ierb = data; break; case 5: // IPRA - state->m_mfp.ipra = data; + m_mfp.ipra = data; break; case 6: // IPRB - state->m_mfp.iprb = data; + m_mfp.iprb = data; break; case 7: - state->m_mfp.isra = data; + m_mfp.isra = data; break; case 8: - state->m_mfp.isrb = data; + m_mfp.isrb = data; break; case 9: - state->m_mfp.imra = data; + m_mfp.imra = data; // mfp_update_irq(0); // logerror("MFP: IRQ Mask A write: %02x\n",data); break; case 10: - state->m_mfp.imrb = data; + m_mfp.imrb = data; // mfp_update_irq(0); // logerror("MFP: IRQ Mask B write: %02x\n",data); break; case 11: // VR - state->m_mfp.vr = 0x40;//data; // High 4 bits = high 4 bits of IRQ vector - state->m_mfp.eoi_mode = data & 0x08; // 0 = Auto, 1 = Software End-of-interrupt - if(state->m_mfp.eoi_mode == 0) // In-service registers are cleared if this bit is cleared. + m_mfp.vr = 0x40;//data; // High 4 bits = high 4 bits of IRQ vector + m_mfp.eoi_mode = data & 0x08; // 0 = Auto, 1 = Software End-of-interrupt + if(m_mfp.eoi_mode == 0) // In-service registers are cleared if this bit is cleared. { - state->m_mfp.isra = 0; - state->m_mfp.isrb = 0; + m_mfp.isra = 0; + m_mfp.isrb = 0; } break; case 12: // TACR - state->m_mfp.tacr = data; + m_mfp.tacr = data; mfp_set_timer(0,data & 0x0f); break; case 13: // TBCR - state->m_mfp.tbcr = data; + m_mfp.tbcr = data; mfp_set_timer(1,data & 0x0f); break; case 14: // TCDCR - state->m_mfp.tcdcr = data; + m_mfp.tcdcr = data; mfp_set_timer(2,(data & 0x70)>>4); mfp_set_timer(3,data & 0x07); break; case 15: // TADR - state->m_mfp.tadr = data; - state->m_mfp.timer[0].counter = data; + m_mfp.tadr = data; + m_mfp.timer[0].counter = data; break; case 16: // TBDR - state->m_mfp.tbdr = data; - state->m_mfp.timer[1].counter = data; + m_mfp.tbdr = data; + m_mfp.timer[1].counter = data; break; case 17: // TCDR - state->m_mfp.tcdr = data; - state->m_mfp.timer[2].counter = data; + m_mfp.tcdr = data; + m_mfp.timer[2].counter = data; break; case 18: // TDDR - state->m_mfp.tddr = data; - state->m_mfp.timer[3].counter = data; + m_mfp.tddr = data; + m_mfp.timer[3].counter = data; break; case 20: - state->m_mfp.ucr = data; + m_mfp.ucr = data; break; #endif case 21: if(data & 0x01) - state->m_mfp.usart.recv_enable = 1; + m_mfp.usart.recv_enable = 1; else - state->m_mfp.usart.recv_enable = 0; + m_mfp.usart.recv_enable = 0; break; case 22: if(data & 0x01) - state->m_mfp.usart.send_enable = 1; + m_mfp.usart.send_enable = 1; else - state->m_mfp.usart.send_enable = 0; + m_mfp.usart.send_enable = 0; break; case 23: - if(state->m_mfp.usart.send_enable != 0) + if(m_mfp.usart.send_enable != 0) { // Keyboard control command. - state->m_mfp.usart.send_buffer = data; - x68k_keyboard_ctrl_w(state, data); + m_mfp.usart.send_buffer = data; + x68k_keyboard_ctrl_w(data); // logerror("MFP: [%08x] USART Sent data %04x\n",space.device().safe_pc(),data); } break; default: - if (ACCESSING_BITS_0_7) state->m_mfpdev->write(space, offset, data & 0xff); + if (ACCESSING_BITS_0_7) m_mfpdev->write(space, offset, data & 0xff); return; } } -static WRITE16_HANDLER( x68k_ppi_w ) +WRITE16_MEMBER(x68k_state::x68k_ppi_w) { - i8255_device *ppi = space.machine().device("ppi8255"); + i8255_device *ppi = machine().device("ppi8255"); ppi->write(space,offset & 0x03,data); } -static READ16_HANDLER( x68k_ppi_r ) +READ16_MEMBER(x68k_state::x68k_ppi_r) { - i8255_device *ppi = space.machine().device("ppi8255"); + i8255_device *ppi = machine().device("ppi8255"); return ppi->read(space,offset & 0x03); } -static READ16_HANDLER( x68k_rtc_r ) +READ16_MEMBER(x68k_state::x68k_rtc_r) { - x68k_state *state = space.machine().driver_data(); - - return state->m_rtc->read(space, offset); + return m_rtc->read(space, offset); } -static WRITE16_HANDLER( x68k_rtc_w ) +WRITE16_MEMBER(x68k_state::x68k_rtc_w) { - x68k_state *state = space.machine().driver_data(); - - state->m_rtc->write(space, offset, data); + m_rtc->write(space, offset, data); } WRITE_LINE_MEMBER(x68k_state::x68k_rtc_alarm_irq) @@ -1519,24 +1498,21 @@ WRITE_LINE_MEMBER(x68k_state::x68k_rtc_alarm_irq) } -static WRITE16_HANDLER( x68k_sram_w ) +WRITE16_MEMBER(x68k_state::x68k_sram_w) { - x68k_state *state = space.machine().driver_data(); - - if(state->m_sysport.sram_writeprotect == 0x31) + if(m_sysport.sram_writeprotect == 0x31) { - COMBINE_DATA(state->m_nvram16 + offset); + COMBINE_DATA(m_nvram16 + offset); } } -static READ16_HANDLER( x68k_sram_r ) +READ16_MEMBER(x68k_state::x68k_sram_r) { - x68k_state *state = space.machine().driver_data(); // HACKS! // if(offset == 0x5a/2) // 0x5a should be 0 if no SASI HDs are present. // return 0x0000; if(offset == 0x08/2) - return space.machine().device(RAM_TAG)->size() >> 16; // RAM size + return machine().device(RAM_TAG)->size() >> 16; // RAM size #if 0 if(offset == 0x46/2) return 0x0024; @@ -1545,14 +1521,13 @@ static READ16_HANDLER( x68k_sram_r ) if(offset == 0x70/2) return 0x0700; #endif - return state->m_nvram16[offset]; + return m_nvram16[offset]; } -static READ32_HANDLER( x68k_sram32_r ) +READ32_MEMBER(x68k_state::x68k_sram32_r) { - x68k_state *state = space.machine().driver_data(); if(offset == 0x08/4) - return (space.machine().device(RAM_TAG)->size() & 0xffff0000); // RAM size + return (machine().device(RAM_TAG)->size() & 0xffff0000); // RAM size #if 0 if(offset == 0x46/2) return 0x0024; @@ -1561,90 +1536,87 @@ static READ32_HANDLER( x68k_sram32_r ) if(offset == 0x70/2) return 0x0700; #endif - return state->m_nvram32[offset]; + return m_nvram32[offset]; } -static WRITE32_HANDLER( x68k_sram32_w ) +WRITE32_MEMBER(x68k_state::x68k_sram32_w) { - x68k_state *state = space.machine().driver_data(); - if(state->m_sysport.sram_writeprotect == 0x31) + if(m_sysport.sram_writeprotect == 0x31) { - COMBINE_DATA(state->m_nvram32 + offset); + COMBINE_DATA(m_nvram32 + offset); } } -static WRITE16_HANDLER( x68k_vid_w ) +WRITE16_MEMBER(x68k_state::x68k_vid_w) { - x68k_state *state = space.machine().driver_data(); int val; if(offset < 0x100) // Graphic layer palette { - COMBINE_DATA(state->m_video.gfx_pal+offset); - val = state->m_video.gfx_pal[offset]; - palette_set_color_rgb(space.machine(),offset,(val & 0x07c0) >> 3,(val & 0xf800) >> 8,(val & 0x003e) << 2); + COMBINE_DATA(m_video.gfx_pal+offset); + val = m_video.gfx_pal[offset]; + palette_set_color_rgb(machine(),offset,(val & 0x07c0) >> 3,(val & 0xf800) >> 8,(val & 0x003e) << 2); return; } if(offset >= 0x100 && offset < 0x200) // Text / Sprites / Tilemap palette { - COMBINE_DATA(state->m_video.text_pal+(offset-0x100)); - val = state->m_video.text_pal[offset-0x100]; - palette_set_color_rgb(space.machine(),offset,(val & 0x07c0) >> 3,(val & 0xf800) >> 8,(val & 0x003e) << 2); + COMBINE_DATA(m_video.text_pal+(offset-0x100)); + val = m_video.text_pal[offset-0x100]; + palette_set_color_rgb(machine(),offset,(val & 0x07c0) >> 3,(val & 0xf800) >> 8,(val & 0x003e) << 2); return; } switch(offset) { case 0x200: - COMBINE_DATA(state->m_video.reg); + COMBINE_DATA(m_video.reg); break; case 0x280: // priority levels - COMBINE_DATA(state->m_video.reg+1); + COMBINE_DATA(m_video.reg+1); if(ACCESSING_BITS_0_7) { - state->m_video.gfxlayer_pri[0] = data & 0x0003; - state->m_video.gfxlayer_pri[1] = (data & 0x000c) >> 2; - state->m_video.gfxlayer_pri[2] = (data & 0x0030) >> 4; - state->m_video.gfxlayer_pri[3] = (data & 0x00c0) >> 6; + m_video.gfxlayer_pri[0] = data & 0x0003; + m_video.gfxlayer_pri[1] = (data & 0x000c) >> 2; + m_video.gfxlayer_pri[2] = (data & 0x0030) >> 4; + m_video.gfxlayer_pri[3] = (data & 0x00c0) >> 6; } if(ACCESSING_BITS_8_15) { - state->m_video.gfx_pri = (data & 0x0300) >> 8; - state->m_video.text_pri = (data & 0x0c00) >> 10; - state->m_video.sprite_pri = (data & 0x3000) >> 12; - if(state->m_video.gfx_pri == 3) - state->m_video.gfx_pri--; - if(state->m_video.text_pri == 3) - state->m_video.text_pri--; - if(state->m_video.sprite_pri == 3) - state->m_video.sprite_pri--; + m_video.gfx_pri = (data & 0x0300) >> 8; + m_video.text_pri = (data & 0x0c00) >> 10; + m_video.sprite_pri = (data & 0x3000) >> 12; + if(m_video.gfx_pri == 3) + m_video.gfx_pri--; + if(m_video.text_pri == 3) + m_video.text_pri--; + if(m_video.sprite_pri == 3) + m_video.sprite_pri--; } break; case 0x300: - COMBINE_DATA(state->m_video.reg+2); + COMBINE_DATA(m_video.reg+2); break; default: logerror("VC: Invalid video controller write (offset = 0x%04x, data = %04x)\n",offset,data); } } -static READ16_HANDLER( x68k_vid_r ) +READ16_MEMBER(x68k_state::x68k_vid_r) { - x68k_state *state = space.machine().driver_data(); if(offset < 0x100) - return state->m_video.gfx_pal[offset]; + return m_video.gfx_pal[offset]; if(offset >= 0x100 && offset < 0x200) - return state->m_video.text_pal[offset-0x100]; + return m_video.text_pal[offset-0x100]; switch(offset) { case 0x200: - return state->m_video.reg[0]; + return m_video.reg[0]; case 0x280: - return state->m_video.reg[1]; + return m_video.reg[1]; case 0x300: - return state->m_video.reg[2]; + return m_video.reg[2]; default: logerror("VC: Invalid video controller read (offset = 0x%04x)\n",offset); } @@ -1652,19 +1624,19 @@ static READ16_HANDLER( x68k_vid_r ) return 0xff; } -static READ16_HANDLER( x68k_areaset_r ) +READ16_MEMBER(x68k_state::x68k_areaset_r) { // register is write-only return 0xffff; } -static WRITE16_HANDLER( x68k_areaset_w ) +WRITE16_MEMBER(x68k_state::x68k_areaset_w) { // TODO logerror("SYS: Supervisor area set: 0x%02x\n",data & 0xff); } -static WRITE16_HANDLER( x68k_enh_areaset_w ) +WRITE16_MEMBER(x68k_state::x68k_enh_areaset_w ) { // TODO logerror("SYS: Enhanced Supervisor area set (from %iMB): 0x%02x\n",(offset + 1) * 2,data & 0xff); @@ -1688,105 +1660,99 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_bus_error) } } -static READ16_HANDLER( x68k_rom0_r ) +READ16_MEMBER(x68k_state::x68k_rom0_r) { - x68k_state *state = space.machine().driver_data(); /* this location contains the address of some expansion device ROM, if no ROM exists, then access causes a bus error */ - state->m_current_vector[2] = 0x02; // bus error - state->m_current_irq_line = 2; -// space.machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,state->m_current_vector[2]); - if(state->ioport("options")->read() & 0x02) + m_current_vector[2] = 0x02; // bus error + m_current_irq_line = 2; +// machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,m_current_vector[2]); + if(ioport("options")->read() & 0x02) { offset *= 2; if(ACCESSING_BITS_0_7) offset++; - space.machine().scheduler().timer_set(space.machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),state), 0xbffffc+offset); + machine().scheduler().timer_set(machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),this), 0xbffffc+offset); } return 0xff; } -static WRITE16_HANDLER( x68k_rom0_w ) +WRITE16_MEMBER(x68k_state::x68k_rom0_w) { - x68k_state *state = space.machine().driver_data(); /* this location contains the address of some expansion device ROM, if no ROM exists, then access causes a bus error */ - state->m_current_vector[2] = 0x02; // bus error - state->m_current_irq_line = 2; -// space.machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,state->m_current_vector[2]); - if(state->ioport("options")->read() & 0x02) + m_current_vector[2] = 0x02; // bus error + m_current_irq_line = 2; +// machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,m_current_vector[2]); + if(ioport("options")->read() & 0x02) { offset *= 2; if(ACCESSING_BITS_0_7) offset++; - space.machine().scheduler().timer_set(space.machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),state), 0xbffffc+offset); + machine().scheduler().timer_set(machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),this), 0xbffffc+offset); } } -static READ16_HANDLER( x68k_emptyram_r ) +READ16_MEMBER(x68k_state::x68k_emptyram_r) { - x68k_state *state = space.machine().driver_data(); /* this location is unused RAM, access here causes a bus error Often a method for detecting amount of installed RAM, is to read or write at 1MB intervals, until a bus error occurs */ - state->m_current_vector[2] = 0x02; // bus error - state->m_current_irq_line = 2; -// space.machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,state->m_current_vector[2]); - if(state->ioport("options")->read() & 0x02) + m_current_vector[2] = 0x02; // bus error + m_current_irq_line = 2; +// machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,m_current_vector[2]); + if(ioport("options")->read() & 0x02) { offset *= 2; if(ACCESSING_BITS_0_7) offset++; - space.machine().scheduler().timer_set(space.machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),state), offset); + machine().scheduler().timer_set(machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),this), offset); } return 0xff; } -static WRITE16_HANDLER( x68k_emptyram_w ) +WRITE16_MEMBER(x68k_state::x68k_emptyram_w) { - x68k_state *state = space.machine().driver_data(); /* this location is unused RAM, access here causes a bus error Often a method for detecting amount of installed RAM, is to read or write at 1MB intervals, until a bus error occurs */ - state->m_current_vector[2] = 0x02; // bus error - state->m_current_irq_line = 2; -// space.machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,state->m_current_vector[2]); - if(state->ioport("options")->read() & 0x02) + m_current_vector[2] = 0x02; // bus error + m_current_irq_line = 2; +// machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,m_current_vector[2]); + if(ioport("options")->read() & 0x02) { offset *= 2; if(ACCESSING_BITS_0_7) offset++; - space.machine().scheduler().timer_set(space.machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),state), offset); + machine().scheduler().timer_set(machine().device("maincpu")->cycles_to_attotime(4), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),this), offset); } } -static READ16_HANDLER( x68k_exp_r ) +READ16_MEMBER(x68k_state::x68k_exp_r) { - x68k_state *state = space.machine().driver_data(); /* These are expansion devices, if not present, they cause a bus error */ - if(state->ioport("options")->read() & 0x02) + if(ioport("options")->read() & 0x02) { - state->m_current_vector[2] = 0x02; // bus error - state->m_current_irq_line = 2; + m_current_vector[2] = 0x02; // bus error + m_current_irq_line = 2; offset *= 2; if(ACCESSING_BITS_0_7) offset++; - space.machine().scheduler().timer_set(space.machine().device("maincpu")->cycles_to_attotime(16), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),state), 0xeafa00+offset); + machine().scheduler().timer_set(machine().device("maincpu")->cycles_to_attotime(16), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),this), 0xeafa00+offset); // machine.device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,state->m_current_vector[2]); } return 0xffff; } -static WRITE16_HANDLER( x68k_exp_w ) +WRITE16_MEMBER(x68k_state::x68k_exp_w) { - x68k_state *state = space.machine().driver_data(); /* These are expansion devices, if not present, they cause a bus error */ - if(state->ioport("options")->read() & 0x02) + if(ioport("options")->read() & 0x02) { - state->m_current_vector[2] = 0x02; // bus error - state->m_current_irq_line = 2; + m_current_vector[2] = 0x02; // bus error + m_current_irq_line = 2; offset *= 2; if(ACCESSING_BITS_0_7) offset++; - space.machine().scheduler().timer_set(space.machine().device("maincpu")->cycles_to_attotime(16), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),state), 0xeafa00+offset); + machine().scheduler().timer_set(machine().device("maincpu")->cycles_to_attotime(16), timer_expired_delegate(FUNC(x68k_state::x68k_bus_error),this), 0xeafa00+offset); // machine.device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,state->m_current_vector[2]); } } @@ -1821,18 +1787,17 @@ static void x68k_dma_error(running_machine &machine, int channel, int irq) } } -static void x68k_fm_irq(device_t *device, int irq) +WRITE_LINE_MEMBER(x68k_state::x68k_fm_irq) { - x68k_state *state = device->machine().driver_data(); - if(irq == CLEAR_LINE) + if(state == CLEAR_LINE) { - state->m_mfp.gpio |= 0x08; - state->m_mfpdev->i3_w(1); + m_mfp.gpio |= 0x08; + m_mfpdev->i3_w(1); } else { - state->m_mfp.gpio &= ~0x08; - state->m_mfpdev->i3_w(0); + m_mfp.gpio &= ~0x08; + m_mfpdev->i3_w(0); } } @@ -1942,72 +1907,72 @@ WRITE_LINE_MEMBER(x68k_state::x68k_scsi_drq) static ADDRESS_MAP_START(x68k_map, AS_PROGRAM, 16, x68k_state ) // AM_RANGE(0x000000, 0xbfffff) AM_RAMBANK(1) - AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE_LEGACY(x68k_rom0_r, x68k_rom0_w) -// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram") -// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram") + AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE(x68k_rom0_r, x68k_rom0_w) +// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram") +// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram") AM_RANGE(0xc00000, 0xdfffff) AM_RAMBANK("bank2") AM_SHARE("gvram16") AM_RANGE(0xe00000, 0xe7ffff) AM_RAMBANK("bank3") AM_SHARE("tvram16") - AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE_LEGACY(x68k_crtc_r, x68k_crtc_w) - AM_RANGE(0xe82000, 0xe83fff) AM_READWRITE_LEGACY(x68k_vid_r, x68k_vid_w) - AM_RANGE(0xe84000, 0xe85fff) AM_READWRITE_LEGACY(x68k_dmac_r, x68k_dmac_w) - AM_RANGE(0xe86000, 0xe87fff) AM_READWRITE_LEGACY(x68k_areaset_r, x68k_areaset_w) - AM_RANGE(0xe88000, 0xe89fff) AM_READWRITE_LEGACY(x68k_mfp_r, x68k_mfp_w) - AM_RANGE(0xe8a000, 0xe8bfff) AM_READWRITE_LEGACY(x68k_rtc_r, x68k_rtc_w) -// AM_RANGE(0xe8c000, 0xe8dfff) AM_READWRITE_LEGACY(x68k_printer_r, x68k_printer_w) - AM_RANGE(0xe8e000, 0xe8ffff) AM_READWRITE_LEGACY(x68k_sysport_r, x68k_sysport_w) - AM_RANGE(0xe90000, 0xe91fff) AM_READWRITE_LEGACY(x68k_fm_r, x68k_fm_w) + AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE(x68k_crtc_r, x68k_crtc_w) + AM_RANGE(0xe82000, 0xe83fff) AM_READWRITE(x68k_vid_r, x68k_vid_w) + AM_RANGE(0xe84000, 0xe85fff) AM_READWRITE(x68k_dmac_r, x68k_dmac_w) + AM_RANGE(0xe86000, 0xe87fff) AM_READWRITE(x68k_areaset_r, x68k_areaset_w) + AM_RANGE(0xe88000, 0xe89fff) AM_READWRITE(x68k_mfp_r, x68k_mfp_w) + AM_RANGE(0xe8a000, 0xe8bfff) AM_READWRITE(x68k_rtc_r, x68k_rtc_w) +// AM_RANGE(0xe8c000, 0xe8dfff) AM_READWRITE(x68k_printer_r, x68k_printer_w) + AM_RANGE(0xe8e000, 0xe8ffff) AM_READWRITE(x68k_sysport_r, x68k_sysport_w) + AM_RANGE(0xe90000, 0xe91fff) AM_READWRITE(x68k_fm_r, x68k_fm_w) AM_RANGE(0xe92000, 0xe92001) AM_DEVREADWRITE8_LEGACY("okim6258", okim6258_status_r, okim6258_ctrl_w, 0x00ff) AM_RANGE(0xe92002, 0xe92003) AM_DEVREADWRITE8_LEGACY("okim6258", okim6258_status_r, okim6258_data_w, 0x00ff) - AM_RANGE(0xe94000, 0xe95fff) AM_READWRITE_LEGACY(x68k_fdc_r, x68k_fdc_w) + AM_RANGE(0xe94000, 0xe95fff) AM_READWRITE(x68k_fdc_r, x68k_fdc_w) AM_RANGE(0xe96000, 0xe9601f) AM_DEVREADWRITE("x68k_hdc", x68k_hdc_image_device, hdc_r, hdc_w) - AM_RANGE(0xe98000, 0xe99fff) AM_READWRITE_LEGACY(x68k_scc_r, x68k_scc_w) - AM_RANGE(0xe9a000, 0xe9bfff) AM_READWRITE_LEGACY(x68k_ppi_r, x68k_ppi_w) - AM_RANGE(0xe9c000, 0xe9dfff) AM_READWRITE_LEGACY(x68k_ioc_r, x68k_ioc_w) - AM_RANGE(0xea0000, 0xea1fff) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) // external SCSI ROM and controller - AM_RANGE(0xeafa00, 0xeafa1f) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) - AM_RANGE(0xeafa80, 0xeafa89) AM_READWRITE_LEGACY(x68k_areaset_r, x68k_enh_areaset_w) - AM_RANGE(0xeb0000, 0xeb7fff) AM_READWRITE_LEGACY(x68k_spritereg_r, x68k_spritereg_w) - AM_RANGE(0xeb8000, 0xebffff) AM_READWRITE_LEGACY(x68k_spriteram_r, x68k_spriteram_w) - AM_RANGE(0xece000, 0xece3ff) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) // User I/O -// AM_RANGE(0xed0000, 0xed3fff) AM_READWRITE_LEGACY(sram_r, sram_w) + AM_RANGE(0xe98000, 0xe99fff) AM_READWRITE(x68k_scc_r, x68k_scc_w) + AM_RANGE(0xe9a000, 0xe9bfff) AM_READWRITE(x68k_ppi_r, x68k_ppi_w) + AM_RANGE(0xe9c000, 0xe9dfff) AM_READWRITE(x68k_ioc_r, x68k_ioc_w) + AM_RANGE(0xea0000, 0xea1fff) AM_READWRITE(x68k_exp_r, x68k_exp_w) // external SCSI ROM and controller + AM_RANGE(0xeafa00, 0xeafa1f) AM_READWRITE(x68k_exp_r, x68k_exp_w) + AM_RANGE(0xeafa80, 0xeafa89) AM_READWRITE(x68k_areaset_r, x68k_enh_areaset_w) + AM_RANGE(0xeb0000, 0xeb7fff) AM_READWRITE(x68k_spritereg_r, x68k_spritereg_w) + AM_RANGE(0xeb8000, 0xebffff) AM_READWRITE(x68k_spriteram_r, x68k_spriteram_w) + AM_RANGE(0xece000, 0xece3ff) AM_READWRITE(x68k_exp_r, x68k_exp_w) // User I/O +// AM_RANGE(0xed0000, 0xed3fff) AM_READWRITE(sram_r, sram_w) AM_RANGE(0xed0000, 0xed3fff) AM_RAMBANK("bank4") AM_SHARE("nvram16") AM_RANGE(0xed4000, 0xefffff) AM_NOP AM_RANGE(0xf00000, 0xfbffff) AM_ROM - AM_RANGE(0xfc0000, 0xfdffff) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) // internal SCSI ROM + AM_RANGE(0xfc0000, 0xfdffff) AM_READWRITE(x68k_exp_r, x68k_exp_w) // internal SCSI ROM AM_RANGE(0xfe0000, 0xffffff) AM_ROM ADDRESS_MAP_END static ADDRESS_MAP_START(x68kxvi_map, AS_PROGRAM, 16, x68k_state ) // AM_RANGE(0x000000, 0xbfffff) AM_RAMBANK(1) - AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE_LEGACY(x68k_rom0_r, x68k_rom0_w) -// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram") -// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram") + AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE(x68k_rom0_r, x68k_rom0_w) +// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram") +// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram") AM_RANGE(0xc00000, 0xdfffff) AM_RAMBANK("bank2") AM_SHARE("gvram16") AM_RANGE(0xe00000, 0xe7ffff) AM_RAMBANK("bank3") AM_SHARE("tvram16") - AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE_LEGACY(x68k_crtc_r, x68k_crtc_w) - AM_RANGE(0xe82000, 0xe83fff) AM_READWRITE_LEGACY(x68k_vid_r, x68k_vid_w) - AM_RANGE(0xe84000, 0xe85fff) AM_READWRITE_LEGACY(x68k_dmac_r, x68k_dmac_w) - AM_RANGE(0xe86000, 0xe87fff) AM_READWRITE_LEGACY(x68k_areaset_r, x68k_areaset_w) - AM_RANGE(0xe88000, 0xe89fff) AM_READWRITE_LEGACY(x68k_mfp_r, x68k_mfp_w) - AM_RANGE(0xe8a000, 0xe8bfff) AM_READWRITE_LEGACY(x68k_rtc_r, x68k_rtc_w) -// AM_RANGE(0xe8c000, 0xe8dfff) AM_READWRITE_LEGACY(x68k_printer_r, x68k_printer_w) - AM_RANGE(0xe8e000, 0xe8ffff) AM_READWRITE_LEGACY(x68k_sysport_r, x68k_sysport_w) - AM_RANGE(0xe90000, 0xe91fff) AM_READWRITE_LEGACY(x68k_fm_r, x68k_fm_w) + AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE(x68k_crtc_r, x68k_crtc_w) + AM_RANGE(0xe82000, 0xe83fff) AM_READWRITE(x68k_vid_r, x68k_vid_w) + AM_RANGE(0xe84000, 0xe85fff) AM_READWRITE(x68k_dmac_r, x68k_dmac_w) + AM_RANGE(0xe86000, 0xe87fff) AM_READWRITE(x68k_areaset_r, x68k_areaset_w) + AM_RANGE(0xe88000, 0xe89fff) AM_READWRITE(x68k_mfp_r, x68k_mfp_w) + AM_RANGE(0xe8a000, 0xe8bfff) AM_READWRITE(x68k_rtc_r, x68k_rtc_w) +// AM_RANGE(0xe8c000, 0xe8dfff) AM_READWRITE(x68k_printer_r, x68k_printer_w) + AM_RANGE(0xe8e000, 0xe8ffff) AM_READWRITE(x68k_sysport_r, x68k_sysport_w) + AM_RANGE(0xe90000, 0xe91fff) AM_READWRITE(x68k_fm_r, x68k_fm_w) AM_RANGE(0xe92000, 0xe92001) AM_DEVREADWRITE8_LEGACY("okim6258", okim6258_status_r, okim6258_ctrl_w, 0x00ff) AM_RANGE(0xe92002, 0xe92003) AM_DEVREADWRITE8_LEGACY("okim6258", okim6258_status_r, okim6258_data_w, 0x00ff) - AM_RANGE(0xe94000, 0xe95fff) AM_READWRITE_LEGACY(x68k_fdc_r, x68k_fdc_w) + AM_RANGE(0xe94000, 0xe95fff) AM_READWRITE(x68k_fdc_r, x68k_fdc_w) // AM_RANGE(0xe96000, 0xe9601f) AM_DEVREADWRITE_LEGACY("x68k_hdc",x68k_hdc_r, x68k_hdc_w) AM_RANGE(0xe96020, 0xe9603f) AM_DEVREADWRITE8("scsi:mb89352",mb89352_device,mb89352_r,mb89352_w,0x00ff) - AM_RANGE(0xe98000, 0xe99fff) AM_READWRITE_LEGACY(x68k_scc_r, x68k_scc_w) - AM_RANGE(0xe9a000, 0xe9bfff) AM_READWRITE_LEGACY(x68k_ppi_r, x68k_ppi_w) - AM_RANGE(0xe9c000, 0xe9dfff) AM_READWRITE_LEGACY(x68k_ioc_r, x68k_ioc_w) - AM_RANGE(0xea0000, 0xea1fff) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) // external SCSI ROM and controller - AM_RANGE(0xeafa00, 0xeafa1f) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) - AM_RANGE(0xeafa80, 0xeafa89) AM_READWRITE_LEGACY(x68k_areaset_r, x68k_enh_areaset_w) - AM_RANGE(0xeb0000, 0xeb7fff) AM_READWRITE_LEGACY(x68k_spritereg_r, x68k_spritereg_w) - AM_RANGE(0xeb8000, 0xebffff) AM_READWRITE_LEGACY(x68k_spriteram_r, x68k_spriteram_w) - AM_RANGE(0xece000, 0xece3ff) AM_READWRITE_LEGACY(x68k_exp_r, x68k_exp_w) // User I/O -// AM_RANGE(0xed0000, 0xed3fff) AM_READWRITE_LEGACY(sram_r, sram_w) + AM_RANGE(0xe98000, 0xe99fff) AM_READWRITE(x68k_scc_r, x68k_scc_w) + AM_RANGE(0xe9a000, 0xe9bfff) AM_READWRITE(x68k_ppi_r, x68k_ppi_w) + AM_RANGE(0xe9c000, 0xe9dfff) AM_READWRITE(x68k_ioc_r, x68k_ioc_w) + AM_RANGE(0xea0000, 0xea1fff) AM_READWRITE(x68k_exp_r, x68k_exp_w) // external SCSI ROM and controller + AM_RANGE(0xeafa00, 0xeafa1f) AM_READWRITE(x68k_exp_r, x68k_exp_w) + AM_RANGE(0xeafa80, 0xeafa89) AM_READWRITE(x68k_areaset_r, x68k_enh_areaset_w) + AM_RANGE(0xeb0000, 0xeb7fff) AM_READWRITE(x68k_spritereg_r, x68k_spritereg_w) + AM_RANGE(0xeb8000, 0xebffff) AM_READWRITE(x68k_spriteram_r, x68k_spriteram_w) + AM_RANGE(0xece000, 0xece3ff) AM_READWRITE(x68k_exp_r, x68k_exp_w) // User I/O +// AM_RANGE(0xed0000, 0xed3fff) AM_READWRITE(sram_r, sram_w) AM_RANGE(0xed0000, 0xed3fff) AM_RAMBANK("bank4") AM_SHARE("nvram16") AM_RANGE(0xed4000, 0xefffff) AM_NOP AM_RANGE(0xf00000, 0xfbffff) AM_ROM @@ -2018,34 +1983,34 @@ ADDRESS_MAP_END static ADDRESS_MAP_START(x68030_map, AS_PROGRAM, 32, x68k_state ) ADDRESS_MAP_GLOBAL_MASK(0x00ffffff) // Still only has 24-bit address space // AM_RANGE(0x000000, 0xbfffff) AM_RAMBANK(1) - AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE16_LEGACY(x68k_rom0_r, x68k_rom0_w,0xffffffff) -// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram") -// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram") + AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE16(x68k_rom0_r, x68k_rom0_w,0xffffffff) +// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram") +// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram") AM_RANGE(0xc00000, 0xdfffff) AM_RAMBANK("bank2") AM_SHARE("gvram32") AM_RANGE(0xe00000, 0xe7ffff) AM_RAMBANK("bank3") AM_SHARE("tvram32") - AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE16_LEGACY(x68k_crtc_r, x68k_crtc_w,0xffffffff) - AM_RANGE(0xe82000, 0xe83fff) AM_READWRITE16_LEGACY(x68k_vid_r, x68k_vid_w,0xffffffff) - AM_RANGE(0xe84000, 0xe85fff) AM_READWRITE16_LEGACY(x68k_dmac_r, x68k_dmac_w,0xffffffff) - AM_RANGE(0xe86000, 0xe87fff) AM_READWRITE16_LEGACY(x68k_areaset_r, x68k_areaset_w,0xffffffff) - AM_RANGE(0xe88000, 0xe89fff) AM_READWRITE16_LEGACY(x68k_mfp_r, x68k_mfp_w,0xffffffff) - AM_RANGE(0xe8a000, 0xe8bfff) AM_READWRITE16_LEGACY(x68k_rtc_r, x68k_rtc_w,0xffffffff) -// AM_RANGE(0xe8c000, 0xe8dfff) AM_READWRITE_LEGACY(x68k_printer_r, x68k_printer_w) - AM_RANGE(0xe8e000, 0xe8ffff) AM_READWRITE16_LEGACY(x68k_sysport_r, x68k_sysport_w,0xffffffff) - AM_RANGE(0xe90000, 0xe91fff) AM_READWRITE16_LEGACY(x68k_fm_r, x68k_fm_w,0xffffffff) + AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE16(x68k_crtc_r, x68k_crtc_w,0xffffffff) + AM_RANGE(0xe82000, 0xe83fff) AM_READWRITE16(x68k_vid_r, x68k_vid_w,0xffffffff) + AM_RANGE(0xe84000, 0xe85fff) AM_READWRITE16(x68k_dmac_r, x68k_dmac_w,0xffffffff) + AM_RANGE(0xe86000, 0xe87fff) AM_READWRITE16(x68k_areaset_r, x68k_areaset_w,0xffffffff) + AM_RANGE(0xe88000, 0xe89fff) AM_READWRITE16(x68k_mfp_r, x68k_mfp_w,0xffffffff) + AM_RANGE(0xe8a000, 0xe8bfff) AM_READWRITE16(x68k_rtc_r, x68k_rtc_w,0xffffffff) +// AM_RANGE(0xe8c000, 0xe8dfff) AM_READWRITE(x68k_printer_r, x68k_printer_w) + AM_RANGE(0xe8e000, 0xe8ffff) AM_READWRITE16(x68k_sysport_r, x68k_sysport_w,0xffffffff) + AM_RANGE(0xe90000, 0xe91fff) AM_READWRITE16(x68k_fm_r, x68k_fm_w,0xffffffff) AM_RANGE(0xe92000, 0xe92003) AM_DEVREAD8_LEGACY("okim6258", okim6258_status_r, 0x00ff00ff) AM_WRITE8(x68030_adpcm_w, 0x00ff00ff) - AM_RANGE(0xe94000, 0xe95fff) AM_READWRITE16_LEGACY(x68k_fdc_r, x68k_fdc_w,0xffffffff) + AM_RANGE(0xe94000, 0xe95fff) AM_READWRITE16(x68k_fdc_r, x68k_fdc_w,0xffffffff) // AM_RANGE(0xe96000, 0xe9601f) AM_DEVREADWRITE16_LEGACY("x68k_hdc",x68k_hdc_r, x68k_hdc_w,0xffffffff) AM_RANGE(0xe96020, 0xe9603f) AM_DEVREADWRITE8("scsi:mb89352",mb89352_device,mb89352_r,mb89352_w,0x00ff00ff) - AM_RANGE(0xe98000, 0xe99fff) AM_READWRITE16_LEGACY(x68k_scc_r, x68k_scc_w,0xffffffff) - AM_RANGE(0xe9a000, 0xe9bfff) AM_READWRITE16_LEGACY(x68k_ppi_r, x68k_ppi_w,0xffffffff) - AM_RANGE(0xe9c000, 0xe9dfff) AM_READWRITE16_LEGACY(x68k_ioc_r, x68k_ioc_w,0xffffffff) + AM_RANGE(0xe98000, 0xe99fff) AM_READWRITE16(x68k_scc_r, x68k_scc_w,0xffffffff) + AM_RANGE(0xe9a000, 0xe9bfff) AM_READWRITE16(x68k_ppi_r, x68k_ppi_w,0xffffffff) + AM_RANGE(0xe9c000, 0xe9dfff) AM_READWRITE16(x68k_ioc_r, x68k_ioc_w,0xffffffff) AM_RANGE(0xea0000, 0xea1fff) AM_NOP//AM_READWRITE16_LEGACY(x68k_exp_r, x68k_exp_w,0xffffffff) // external SCSI ROM and controller - AM_RANGE(0xeafa00, 0xeafa1f) AM_READWRITE16_LEGACY(x68k_exp_r, x68k_exp_w,0xffffffff) - AM_RANGE(0xeafa80, 0xeafa8b) AM_READWRITE16_LEGACY(x68k_areaset_r, x68k_enh_areaset_w,0xffffffff) - AM_RANGE(0xeb0000, 0xeb7fff) AM_READWRITE16_LEGACY(x68k_spritereg_r, x68k_spritereg_w,0xffffffff) - AM_RANGE(0xeb8000, 0xebffff) AM_READWRITE16_LEGACY(x68k_spriteram_r, x68k_spriteram_w,0xffffffff) - AM_RANGE(0xece000, 0xece3ff) AM_READWRITE16_LEGACY(x68k_exp_r, x68k_exp_w,0xffffffff) // User I/O -// AM_RANGE(0xed0000, 0xed3fff) AM_READWRITE_LEGACY(sram_r, sram_w) + AM_RANGE(0xeafa00, 0xeafa1f) AM_READWRITE16(x68k_exp_r, x68k_exp_w,0xffffffff) + AM_RANGE(0xeafa80, 0xeafa8b) AM_READWRITE16(x68k_areaset_r, x68k_enh_areaset_w,0xffffffff) + AM_RANGE(0xeb0000, 0xeb7fff) AM_READWRITE16(x68k_spritereg_r, x68k_spritereg_w,0xffffffff) + AM_RANGE(0xeb8000, 0xebffff) AM_READWRITE16(x68k_spriteram_r, x68k_spriteram_w,0xffffffff) + AM_RANGE(0xece000, 0xece3ff) AM_READWRITE16(x68k_exp_r, x68k_exp_w,0xffffffff) // User I/O +// AM_RANGE(0xed0000, 0xed3fff) AM_READWRITE(sram_r, sram_w) AM_RANGE(0xed0000, 0xed3fff) AM_RAMBANK("bank4") AM_SHARE("nvram32") AM_RANGE(0xed4000, 0xefffff) AM_NOP AM_RANGE(0xf00000, 0xfbffff) AM_ROM @@ -2111,7 +2076,7 @@ static const upd765_interface fdc_interface = static const ym2151_interface x68k_ym2151_interface = { - DEVCB_LINE(x68k_fm_irq), + DEVCB_DRIVER_LINE_MEMBER(x68k_state,x68k_fm_irq), DEVCB_DRIVER_MEMBER(x68k_state,x68k_ct_w) // CT1, CT2 from YM2151 port 0x1b }; @@ -2470,15 +2435,14 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_net_irq) machine().device("maincpu")->execute().set_input_line_and_vector(2,ASSERT_LINE,m_current_vector[2]); } -static void x68k_irq2_line(device_t* device,int state) +WRITE_LINE_MEMBER(x68k_state::x68k_irq2_line) { - x68k_state *tstate = device->machine().driver_data(); if(state==ASSERT_LINE) { - tstate->m_net_timer->adjust(attotime::from_usec(16)); + m_net_timer->adjust(attotime::from_usec(16)); } else - device->machine().device("maincpu")->execute().set_input_line_and_vector(2,CLEAR_LINE,tstate->m_current_vector[2]); + machine().device("maincpu")->execute().set_input_line_and_vector(2,CLEAR_LINE,m_current_vector[2]); logerror("EXP: IRQ2 set to %i\n",state); } @@ -2515,7 +2479,7 @@ static const mb89352_interface x68k_scsi_intf = static X68K_EXPANSION_INTERFACE(x68k_exp_intf) { - DEVCB_LINE(x68k_irq2_line), + DEVCB_DRIVER_LINE_MEMBER(x68k_state,x68k_irq2_line), DEVCB_CPU_INPUT_LINE("maincpu", M68K_IRQ_4), DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_NMI), DEVCB_NULL // RESET @@ -2564,7 +2528,7 @@ MACHINE_RESET_MEMBER(x68k_state,x68000) m_crtc.reg[7] = 552; // Vertical end m_crtc.reg[8] = 27; // Horizontal adjust - mfp_init(machine()); + mfp_init(); m_scanline = machine().primary_screen->vpos();// = m_crtc.reg[6]; // Vertical start @@ -2604,18 +2568,18 @@ MACHINE_START_MEMBER(x68k_state,x68000) address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM); /* Install RAM handlers */ m_spriteram = (UINT16*)(*memregion("user1")); - space.install_legacy_read_handler(0x000000,0xbffffb,0xffffffff,0,FUNC(x68k_emptyram_r)); - space.install_legacy_write_handler(0x000000,0xbffffb,0xffffffff,0,FUNC(x68k_emptyram_w)); + space.install_read_handler(0x000000,0xbffffb,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_emptyram_r),this)); + space.install_write_handler(0x000000,0xbffffb,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_emptyram_w),this)); space.install_readwrite_bank(0x000000,machine().device(RAM_TAG)->size()-1,0xffffffff,0,"bank1"); membank("bank1")->set_base(machine().device(RAM_TAG)->pointer()); - space.install_legacy_read_handler(0xc00000,0xdfffff,0xffffffff,0,FUNC(x68k_gvram_r)); - space.install_legacy_write_handler(0xc00000,0xdfffff,0xffffffff,0,FUNC(x68k_gvram_w)); + space.install_read_handler(0xc00000,0xdfffff,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_gvram_r),this)); + space.install_write_handler(0xc00000,0xdfffff,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_gvram_w),this)); membank("bank2")->set_base(m_gvram16); // so that code in VRAM is executable - needed for Terra Cresta - space.install_legacy_read_handler(0xe00000,0xe7ffff,0xffffffff,0,FUNC(x68k_tvram_r)); - space.install_legacy_write_handler(0xe00000,0xe7ffff,0xffffffff,0,FUNC(x68k_tvram_w)); + space.install_read_handler(0xe00000,0xe7ffff,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_tvram_r),this)); + space.install_write_handler(0xe00000,0xe7ffff,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_tvram_w),this)); membank("bank3")->set_base(m_tvram16); // so that code in VRAM is executable - needed for Terra Cresta - space.install_legacy_read_handler(0xed0000,0xed3fff,0xffffffff,0,FUNC(x68k_sram_r)); - space.install_legacy_write_handler(0xed0000,0xed3fff,0xffffffff,0,FUNC(x68k_sram_w)); + space.install_read_handler(0xed0000,0xed3fff,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_sram_r),this)); + space.install_write_handler(0xed0000,0xed3fff,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_sram_w),this)); membank("bank4")->set_base(m_nvram16); // so that code in SRAM is executable, there is an option for booting from SRAM // start keyboard timer @@ -2634,18 +2598,18 @@ MACHINE_START_MEMBER(x68k_state,x68030) address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM); /* Install RAM handlers */ m_spriteram = (UINT16*)(*memregion("user1")); - space.install_legacy_read_handler(0x000000,0xbffffb,0xffffffff,0,FUNC(x68k_rom0_r),0xffffffff); - space.install_legacy_write_handler(0x000000,0xbffffb,0xffffffff,0,FUNC(x68k_rom0_w),0xffffffff); + space.install_read_handler(0x000000,0xbffffb,0xffffffff,0,read16_delegate(FUNC(x68k_state::x68k_rom0_r),this),0xffffffff); + space.install_write_handler(0x000000,0xbffffb,0xffffffff,0,write16_delegate(FUNC(x68k_state::x68k_rom0_w),this),0xffffffff); space.install_readwrite_bank(0x000000,machine().device(RAM_TAG)->size()-1,0xffffffff,0,"bank1"); membank("bank1")->set_base(machine().device(RAM_TAG)->pointer()); - space.install_legacy_read_handler(0xc00000,0xdfffff,0xffffffff,0,FUNC(x68k_gvram32_r)); - space.install_legacy_write_handler(0xc00000,0xdfffff,0xffffffff,0,FUNC(x68k_gvram32_w)); + space.install_read_handler(0xc00000,0xdfffff,0xffffffff,0,read32_delegate(FUNC(x68k_state::x68k_gvram32_r),this)); + space.install_write_handler(0xc00000,0xdfffff,0xffffffff,0,write32_delegate(FUNC(x68k_state::x68k_gvram32_w),this)); membank("bank2")->set_base(m_gvram32); // so that code in VRAM is executable - needed for Terra Cresta - space.install_legacy_read_handler(0xe00000,0xe7ffff,0xffffffff,0,FUNC(x68k_tvram32_r)); - space.install_legacy_write_handler(0xe00000,0xe7ffff,0xffffffff,0,FUNC(x68k_tvram32_w)); + space.install_read_handler(0xe00000,0xe7ffff,0xffffffff,0,read32_delegate(FUNC(x68k_state::x68k_tvram32_r),this)); + space.install_write_handler(0xe00000,0xe7ffff,0xffffffff,0,write32_delegate(FUNC(x68k_state::x68k_tvram32_w),this)); membank("bank3")->set_base(m_tvram32); // so that code in VRAM is executable - needed for Terra Cresta - space.install_legacy_read_handler(0xed0000,0xed3fff,0xffffffff,0,FUNC(x68k_sram32_r)); - space.install_legacy_write_handler(0xed0000,0xed3fff,0xffffffff,0,FUNC(x68k_sram32_w)); + space.install_read_handler(0xed0000,0xed3fff,0xffffffff,0,read32_delegate(FUNC(x68k_state::x68k_sram32_r),this)); + space.install_write_handler(0xed0000,0xed3fff,0xffffffff,0,write32_delegate(FUNC(x68k_state::x68k_sram32_w),this)); membank("bank4")->set_base(m_nvram32); // so that code in SRAM is executable, there is an option for booting from SRAM // start keyboard timer @@ -2680,7 +2644,7 @@ DRIVER_INIT_MEMBER(x68k_state,x68000) // copy last half of BIOS to a user region, to use for inital startup memcpy(user2,(rom+0xff0000),0x10000); - mfp_init(machine()); + mfp_init(); machine().device("maincpu")->execute().set_irq_acknowledge_callback(x68k_int_ack); @@ -2696,7 +2660,7 @@ DRIVER_INIT_MEMBER(x68k_state,x68000) m_net_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(x68k_state::x68k_net_irq),this)); // Initialise timers for 6-button MD controllers - md_6button_init(machine()); + md_6button_init(); m_sysport.cputype = 0xff; // 68000, 10MHz m_is_32bit = false; diff --git a/src/mess/includes/x68k.h b/src/mess/includes/x68k.h index 66222e76b36..261833f0769 100644 --- a/src/mess/includes/x68k.h +++ b/src/mess/includes/x68k.h @@ -297,34 +297,79 @@ public: DECLARE_WRITE_LINE_MEMBER(mfp_irq_callback); DECLARE_WRITE_LINE_MEMBER(x68k_scsi_irq); DECLARE_WRITE_LINE_MEMBER(x68k_scsi_drq); + + void mfp_init(); + void x68k_keyboard_ctrl_w(int data); + int x68k_keyboard_pop_scancode(); + void x68k_keyboard_push_scancode(unsigned char code); + int x68k_read_mouse(); + void x68k_set_adpcm(); + UINT8 md_3button_r(int port); + void md_6button_init(); + UINT8 md_6button_r(int port); + UINT8 xpd1lr_r(int port); + + DECLARE_WRITE_LINE_MEMBER(x68k_fm_irq); + DECLARE_WRITE_LINE_MEMBER(x68k_irq2_line); + + DECLARE_WRITE16_MEMBER(x68k_dmac_w); + DECLARE_READ16_MEMBER(x68k_dmac_r); + DECLARE_WRITE16_MEMBER(x68k_scc_w); + DECLARE_WRITE16_MEMBER(x68k_fdc_w); + DECLARE_READ16_MEMBER(x68k_fdc_r); + DECLARE_WRITE16_MEMBER(x68k_fm_w); + DECLARE_READ16_MEMBER(x68k_fm_r); + DECLARE_WRITE16_MEMBER(x68k_ioc_w); + DECLARE_READ16_MEMBER(x68k_ioc_r); + DECLARE_WRITE16_MEMBER(x68k_sysport_w); + DECLARE_READ16_MEMBER(x68k_sysport_r); + DECLARE_READ16_MEMBER(x68k_mfp_r); + DECLARE_WRITE16_MEMBER(x68k_mfp_w); + DECLARE_WRITE16_MEMBER(x68k_ppi_w); + DECLARE_READ16_MEMBER(x68k_ppi_r); + DECLARE_READ16_MEMBER(x68k_rtc_r); + DECLARE_WRITE16_MEMBER(x68k_rtc_w); + DECLARE_WRITE16_MEMBER(x68k_sram_w); + DECLARE_READ16_MEMBER(x68k_sram_r); + DECLARE_READ32_MEMBER(x68k_sram32_r); + DECLARE_WRITE32_MEMBER(x68k_sram32_w); + DECLARE_WRITE16_MEMBER(x68k_vid_w); + DECLARE_READ16_MEMBER(x68k_vid_r); + DECLARE_READ16_MEMBER(x68k_areaset_r); + DECLARE_WRITE16_MEMBER(x68k_areaset_w); + DECLARE_WRITE16_MEMBER(x68k_enh_areaset_w); + DECLARE_READ16_MEMBER(x68k_rom0_r); + DECLARE_WRITE16_MEMBER(x68k_rom0_w); + DECLARE_READ16_MEMBER(x68k_emptyram_r); + DECLARE_WRITE16_MEMBER(x68k_emptyram_w); + DECLARE_READ16_MEMBER(x68k_exp_r); + DECLARE_WRITE16_MEMBER(x68k_exp_w); + DECLARE_READ16_MEMBER(x68k_scc_r); + + DECLARE_READ16_MEMBER(x68k_spritereg_r); + DECLARE_WRITE16_MEMBER(x68k_spritereg_w); + DECLARE_READ16_MEMBER(x68k_spriteram_r); + DECLARE_WRITE16_MEMBER(x68k_spriteram_w); + DECLARE_WRITE16_MEMBER(x68k_crtc_w); + DECLARE_READ16_MEMBER(x68k_crtc_r); + DECLARE_WRITE16_MEMBER(x68k_gvram_w); + DECLARE_READ16_MEMBER(x68k_gvram_r); + DECLARE_WRITE16_MEMBER(x68k_tvram_w); + DECLARE_READ16_MEMBER(x68k_tvram_r); + DECLARE_WRITE32_MEMBER(x68k_gvram32_w); + DECLARE_READ32_MEMBER(x68k_gvram32_r); + DECLARE_WRITE32_MEMBER(x68k_tvram32_w); + DECLARE_READ32_MEMBER(x68k_tvram32_r); +private: + inline void x68k_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color); + void x68k_crtc_text_copy(int src, int dest); + void x68k_crtc_refresh_mode(); + void x68k_draw_text(bitmap_ind16 &bitmap, int xscr, int yscr, rectangle rect); + void x68k_draw_gfx_scanline(bitmap_ind16 &bitmap, rectangle cliprect, UINT8 priority); + void x68k_draw_gfx(bitmap_ind16 &bitmap,rectangle cliprect); + void x68k_draw_sprites(bitmap_ind16 &bitmap, int priority, rectangle cliprect); }; -/*----------- defined in drivers/x68k.c -----------*/ - -#ifdef UNUSED_FUNCTION -void mfp_trigger_irq(int); -TIMER_CALLBACK(mfp_timer_a_callback); -TIMER_CALLBACK(mfp_timer_b_callback); -TIMER_CALLBACK(mfp_timer_c_callback); -TIMER_CALLBACK(mfp_timer_d_callback); -#endif - -/*----------- defined in video/x68k.c -----------*/ -DECLARE_READ16_HANDLER( x68k_spritereg_r ); -DECLARE_WRITE16_HANDLER( x68k_spritereg_w ); -DECLARE_READ16_HANDLER( x68k_spriteram_r ); -DECLARE_WRITE16_HANDLER( x68k_spriteram_w ); -DECLARE_WRITE16_HANDLER( x68k_crtc_w ); -DECLARE_READ16_HANDLER( x68k_crtc_r ); -DECLARE_WRITE16_HANDLER( x68k_gvram_w ); -DECLARE_READ16_HANDLER( x68k_gvram_r ); -DECLARE_WRITE16_HANDLER( x68k_tvram_w ); -DECLARE_READ16_HANDLER( x68k_tvram_r ); -DECLARE_WRITE32_HANDLER( x68k_gvram32_w ); -DECLARE_READ32_HANDLER( x68k_gvram32_r ); -DECLARE_WRITE32_HANDLER( x68k_tvram32_w ); -DECLARE_READ32_HANDLER( x68k_tvram32_r ); - #endif /* X68K_H_ */ diff --git a/src/mess/video/x68k.c b/src/mess/video/x68k.c index 56b285c0eed..2793ad70a11 100644 --- a/src/mess/video/x68k.c +++ b/src/mess/video/x68k.c @@ -33,9 +33,7 @@ -static void x68k_crtc_refresh_mode(running_machine &machine); - -INLINE void x68k_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color) +inline void x68k_state::x68k_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color) { bitmap.pix16(y, x) = (UINT16)color; } @@ -78,7 +76,7 @@ static bitmap_ind16* x68k_get_gfx_page(int pri,int type) return NULL; // should never reach here either. } */ -static void x68k_crtc_text_copy(x68k_state *state, int src, int dest) +void x68k_state::x68k_crtc_text_copy(int src, int dest) { // copys one raster in T-VRAM to another raster UINT16* tvram; @@ -86,10 +84,10 @@ static void x68k_crtc_text_copy(x68k_state *state, int src, int dest) int dest_ram = dest * 256; int line; - if(state->m_is_32bit) - tvram = (UINT16*)state->m_tvram32.target(); + if(m_is_32bit) + tvram = (UINT16*)m_tvram32.target(); else - tvram = (UINT16*)state->m_tvram16.target(); + tvram = (UINT16*)m_tvram16.target(); if(dest > 250) return; // for some reason, Salamander causes a SIGSEGV in a debug build in this function. @@ -114,48 +112,47 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_crtc_operation_end) m_crtc.operation &= ~bit; } -static void x68k_crtc_refresh_mode(running_machine &machine) +void x68k_state::x68k_crtc_refresh_mode() { - x68k_state *state = machine.driver_data(); // rectangle rect; // double scantime; rectangle scr,visiblescr; int length; // Calculate data from register values - state->m_crtc.vmultiple = 1; - if((state->m_crtc.reg[20] & 0x10) != 0 && (state->m_crtc.reg[20] & 0x0c) == 0) - state->m_crtc.vmultiple = 2; // 31.5kHz + 256 lines = doublescan - if(state->m_crtc.interlace != 0) - state->m_crtc.vmultiple = 0.5f; // 31.5kHz + 1024 lines or 15kHz + 512 lines = interlaced - state->m_crtc.htotal = (state->m_crtc.reg[0] + 1) * 8; - state->m_crtc.vtotal = (state->m_crtc.reg[4] + 1) / state->m_crtc.vmultiple; // default is 567 (568 scanlines) - state->m_crtc.hbegin = (state->m_crtc.reg[2] * 8) + 1; - state->m_crtc.hend = (state->m_crtc.reg[3] * 8); - state->m_crtc.vbegin = (state->m_crtc.reg[6]) / state->m_crtc.vmultiple; - state->m_crtc.vend = (state->m_crtc.reg[7] - 1) / state->m_crtc.vmultiple; - state->m_crtc.hsync_end = (state->m_crtc.reg[1]) * 8; - state->m_crtc.vsync_end = (state->m_crtc.reg[5]) / state->m_crtc.vmultiple; - state->m_crtc.hsyncadjust = state->m_crtc.reg[8]; - scr.set(0, state->m_crtc.htotal - 8, 0, state->m_crtc.vtotal); - if(scr.max_y <= state->m_crtc.vend) - scr.max_y = state->m_crtc.vend + 2; - if(scr.max_x <= state->m_crtc.hend) - scr.max_x = state->m_crtc.hend + 2; - visiblescr.set(state->m_crtc.hbegin, state->m_crtc.hend, state->m_crtc.vbegin, state->m_crtc.vend); + m_crtc.vmultiple = 1; + if((m_crtc.reg[20] & 0x10) != 0 && (m_crtc.reg[20] & 0x0c) == 0) + m_crtc.vmultiple = 2; // 31.5kHz + 256 lines = doublescan + if(m_crtc.interlace != 0) + m_crtc.vmultiple = 0.5f; // 31.5kHz + 1024 lines or 15kHz + 512 lines = interlaced + m_crtc.htotal = (m_crtc.reg[0] + 1) * 8; + m_crtc.vtotal = (m_crtc.reg[4] + 1) / m_crtc.vmultiple; // default is 567 (568 scanlines) + m_crtc.hbegin = (m_crtc.reg[2] * 8) + 1; + m_crtc.hend = (m_crtc.reg[3] * 8); + m_crtc.vbegin = (m_crtc.reg[6]) / m_crtc.vmultiple; + m_crtc.vend = (m_crtc.reg[7] - 1) / m_crtc.vmultiple; + m_crtc.hsync_end = (m_crtc.reg[1]) * 8; + m_crtc.vsync_end = (m_crtc.reg[5]) / m_crtc.vmultiple; + m_crtc.hsyncadjust = m_crtc.reg[8]; + scr.set(0, m_crtc.htotal - 8, 0, m_crtc.vtotal); + if(scr.max_y <= m_crtc.vend) + scr.max_y = m_crtc.vend + 2; + if(scr.max_x <= m_crtc.hend) + scr.max_x = m_crtc.hend + 2; + visiblescr.set(m_crtc.hbegin, m_crtc.hend, m_crtc.vbegin, m_crtc.vend); // expand visible area to the size indicated by CRTC reg 20 - length = state->m_crtc.hend - state->m_crtc.hbegin; - if (length < state->m_crtc.width) + length = m_crtc.hend - m_crtc.hbegin; + if (length < m_crtc.width) { - visiblescr.min_x = state->m_crtc.hbegin - ((state->m_crtc.width - length)/2); - visiblescr.max_x = state->m_crtc.hend + ((state->m_crtc.width - length)/2); + visiblescr.min_x = m_crtc.hbegin - ((m_crtc.width - length)/2); + visiblescr.max_x = m_crtc.hend + ((m_crtc.width - length)/2); } - length = state->m_crtc.vend - state->m_crtc.vbegin; - if (length < state->m_crtc.height) + length = m_crtc.vend - m_crtc.vbegin; + if (length < m_crtc.height) { - visiblescr.min_y = state->m_crtc.vbegin - ((state->m_crtc.height - length)/2); - visiblescr.max_y = state->m_crtc.vend + ((state->m_crtc.height - length)/2); + visiblescr.min_y = m_crtc.vbegin - ((m_crtc.height - length)/2); + visiblescr.max_y = m_crtc.vend + ((m_crtc.height - length)/2); } // bounds check if(visiblescr.min_x < 0) @@ -167,10 +164,10 @@ static void x68k_crtc_refresh_mode(running_machine &machine) if(visiblescr.max_y >= scr.max_y - 1) visiblescr.max_y = scr.max_y - 2; -// logerror("CRTC regs - %i %i %i %i - %i %i %i %i - %i - %i\n",state->m_crtc.reg[0],state->m_crtc.reg[1],state->m_crtc.reg[2],state->m_crtc.reg[3], -// state->m_crtc.reg[4],state->m_crtc.reg[5],state->m_crtc.reg[6],state->m_crtc.reg[7],state->m_crtc.reg[8],state->m_crtc.reg[9]); +// logerror("CRTC regs - %i %i %i %i - %i %i %i %i - %i - %i\n",m_crtc.reg[0],m_crtc.reg[1],m_crtc.reg[2],m_crtc.reg[3], +// m_crtc.reg[4],m_crtc.reg[5],m_crtc.reg[6],m_crtc.reg[7],m_crtc.reg[8],m_crtc.reg[9]); logerror("video_screen_configure(machine.primary_screen,%i,%i,[%i,%i,%i,%i],55.45)\n",scr.max_x,scr.max_y,visiblescr.min_x,visiblescr.min_y,visiblescr.max_x,visiblescr.max_y); - machine.primary_screen->configure(scr.max_x,scr.max_y,visiblescr,HZ_TO_ATTOSECONDS(55.45)); + machine().primary_screen->configure(scr.max_x,scr.max_y,visiblescr,HZ_TO_ATTOSECONDS(55.45)); } TIMER_CALLBACK_MEMBER(x68k_state::x68k_hsync) @@ -370,10 +367,9 @@ TIMER_CALLBACK_MEMBER(x68k_state::x68k_crtc_vblank_irq) * Operation Port bits are cleared automatically when the requested * operation is completed. */ -WRITE16_HANDLER( x68k_crtc_w ) +WRITE16_MEMBER(x68k_state::x68k_crtc_w ) { - x68k_state *state = space.machine().driver_data(); - COMBINE_DATA(state->m_crtc.reg+offset); + COMBINE_DATA(m_crtc.reg+offset); switch(offset) { case 0: @@ -385,83 +381,82 @@ WRITE16_HANDLER( x68k_crtc_w ) case 6: case 7: case 8: - x68k_crtc_refresh_mode(space.machine()); + x68k_crtc_refresh_mode(); break; case 9: // CRTC raster IRQ (GPIP6) { attotime irq_time; - irq_time = space.machine().primary_screen->time_until_pos((data) / state->m_crtc.vmultiple,2); + irq_time = machine().primary_screen->time_until_pos((data) / m_crtc.vmultiple,2); if(irq_time.as_double() > 0) - state->m_raster_irq->adjust(irq_time, (data) / state->m_crtc.vmultiple); + m_raster_irq->adjust(irq_time, (data) / m_crtc.vmultiple); } logerror("CRTC: Write to raster IRQ register - %i\n",data); break; case 20: if(ACCESSING_BITS_0_7) { - state->m_crtc.interlace = 0; + m_crtc.interlace = 0; switch(data & 0x0c) { case 0x00: - state->m_crtc.height = 256; + m_crtc.height = 256; break; case 0x08: case 0x0c: // TODO: 1024 vertical, if horizontal freq = 31kHz - state->m_crtc.height = 512; - state->m_crtc.interlace = 1; // if 31kHz, 1024 lines = interlaced + m_crtc.height = 512; + m_crtc.interlace = 1; // if 31kHz, 1024 lines = interlaced break; case 0x04: - state->m_crtc.height = 512; - if(!(state->m_crtc.reg[20] & 0x0010)) // if 15kHz, 512 lines = interlaced - state->m_crtc.interlace = 1; + m_crtc.height = 512; + if(!(m_crtc.reg[20] & 0x0010)) // if 15kHz, 512 lines = interlaced + m_crtc.interlace = 1; break; } switch(data & 0x03) { case 0x00: - state->m_crtc.width = 256; + m_crtc.width = 256; break; case 0x01: - state->m_crtc.width = 512; + m_crtc.width = 512; break; case 0x02: case 0x03: // 0x03 = 50MHz clock mode (XVI only) - state->m_crtc.width = 768; + m_crtc.width = 768; break; } } /* if(ACCESSING_BITS_8_15) { - state->m_crtc.interlace = 0; + m_crtc.interlace = 0; if(data & 0x0400) - state->m_crtc.interlace = 1; + m_crtc.interlace = 1; }*/ - x68k_crtc_refresh_mode(space.machine()); + x68k_crtc_refresh_mode(); break; case 576: // operation register - state->m_crtc.operation = data; + m_crtc.operation = data; if(data & 0x08) // text screen raster copy { - x68k_crtc_text_copy(state, (state->m_crtc.reg[22] & 0xff00) >> 8,(state->m_crtc.reg[22] & 0x00ff)); - space.machine().scheduler().timer_set(attotime::from_msec(1), timer_expired_delegate(FUNC(x68k_state::x68k_crtc_operation_end),state), 0x02); // time taken to do operation is a complete guess. + x68k_crtc_text_copy((m_crtc.reg[22] & 0xff00) >> 8,(m_crtc.reg[22] & 0x00ff)); + machine().scheduler().timer_set(attotime::from_msec(1), timer_expired_delegate(FUNC(x68k_state::x68k_crtc_operation_end),this), 0x02); // time taken to do operation is a complete guess. } if(data & 0x02) // high-speed graphic screen clear { - if(state->m_is_32bit) - memset(state->m_gvram32,0,0x40000); + if(m_is_32bit) + memset(m_gvram32,0,0x40000); else - memset(state->m_gvram16,0,0x40000); - space.machine().scheduler().timer_set(attotime::from_msec(10), timer_expired_delegate(FUNC(x68k_state::x68k_crtc_operation_end),state), 0x02); // time taken to do operation is a complete guess. + memset(m_gvram16,0,0x40000); + machine().scheduler().timer_set(attotime::from_msec(10), timer_expired_delegate(FUNC(x68k_state::x68k_crtc_operation_end),this), 0x02); // time taken to do operation is a complete guess. } break; } -// logerror("CRTC: [%08x] Wrote %04x to CRTC register %i\n",space.machine().device("maincpu")->safe_pc(),data,offset); +// logerror("CRTC: [%08x] Wrote %04x to CRTC register %i\n",machine().device("maincpu")->safe_pc(),data,offset); } -READ16_HANDLER( x68k_crtc_r ) +READ16_MEMBER(x68k_state::x68k_crtc_r ) { - x68k_state *state = space.machine().driver_data(); #if 0 switch(offset) { @@ -473,7 +468,7 @@ READ16_HANDLER( x68k_crtc_r ) if(offset < 24) { -// logerror("CRTC: [%08x] Read %04x from CRTC register %i\n",space.machine().device("maincpu")->safe_pc(),state->m_crtc.reg[offset],offset); +// logerror("CRTC: [%08x] Read %04x from CRTC register %i\n",machine().device("maincpu")->safe_pc(),m_crtc.reg[offset],offset); switch(offset) { case 9: @@ -482,27 +477,26 @@ READ16_HANDLER( x68k_crtc_r ) case 11: case 12: // Graphic layer 0 scroll case 13: - return state->m_crtc.reg[offset] & 0x3ff; + return m_crtc.reg[offset] & 0x3ff; case 14: // Graphic layer 1 scroll case 15: case 16: // Graphic layer 2 scroll case 17: case 18: // Graphic layer 3 scroll case 19: - return state->m_crtc.reg[offset] & 0x1ff; + return m_crtc.reg[offset] & 0x1ff; default: - return state->m_crtc.reg[offset]; + return m_crtc.reg[offset]; } } if(offset == 576) // operation port, operation bits are set to 0 when operation is complete - return state->m_crtc.operation; + return m_crtc.operation; // logerror("CRTC: [%08x] Read from unknown CRTC register %i\n",activecpu_get_pc(),offset); return 0xffff; } -WRITE16_HANDLER( x68k_gvram_w ) +WRITE16_MEMBER(x68k_state::x68k_gvram_w ) { - x68k_state *state = space.machine().driver_data(); UINT16* gvram; // int xloc,yloc,pageoffset; /* @@ -520,20 +514,20 @@ WRITE16_HANDLER( x68k_gvram_w ) Page 3 - 0xd00000-0xd7ffff Page 4 - 0xd80000-0xdfffff */ - if(state->m_is_32bit) - gvram = (UINT16*)state->m_gvram32.target(); + if(m_is_32bit) + gvram = (UINT16*)m_gvram32.target(); else - gvram = (UINT16*)state->m_gvram16.target(); + gvram = (UINT16*)m_gvram16.target(); // handle different G-VRAM page setups - if(state->m_crtc.reg[20] & 0x08) // G-VRAM set to buffer + if(m_crtc.reg[20] & 0x08) // G-VRAM set to buffer { if(offset < 0x40000) COMBINE_DATA(gvram+offset); } else { - switch(state->m_crtc.reg[20] & 0x0300) + switch(m_crtc.reg[20] & 0x0300) { case 0x0300: if(offset < 0x40000) @@ -573,29 +567,28 @@ WRITE16_HANDLER( x68k_gvram_w ) } } -WRITE16_HANDLER( x68k_tvram_w ) +WRITE16_MEMBER(x68k_state::x68k_tvram_w ) { - x68k_state *state = space.machine().driver_data(); UINT16* tvram; UINT16 text_mask; - if(state->m_is_32bit) - tvram = (UINT16*)state->m_tvram32.target(); + if(m_is_32bit) + tvram = (UINT16*)m_tvram32.target(); else - tvram = (UINT16*)state->m_tvram16.target(); + tvram = (UINT16*)m_tvram16.target(); - text_mask = ~(state->m_crtc.reg[23]) & mem_mask; + text_mask = ~(m_crtc.reg[23]) & mem_mask; - if(!(state->m_crtc.reg[21] & 0x0200)) // text access mask enable + if(!(m_crtc.reg[21] & 0x0200)) // text access mask enable text_mask = 0xffff & mem_mask; mem_mask = text_mask; - if(state->m_crtc.reg[21] & 0x0100) + if(m_crtc.reg[21] & 0x0100) { // simultaneous T-VRAM plane access (I think ;)) int plane,wr; offset = offset & 0x00ffff; - wr = (state->m_crtc.reg[21] & 0x00f0) >> 4; + wr = (m_crtc.reg[21] & 0x00f0) >> 4; for(plane=0;plane<4;plane++) { if(wr & (1 << plane)) @@ -610,21 +603,20 @@ WRITE16_HANDLER( x68k_tvram_w ) } } -READ16_HANDLER( x68k_gvram_r ) +READ16_MEMBER(x68k_state::x68k_gvram_r ) { - x68k_state *state = space.machine().driver_data(); const UINT16* gvram; UINT16 ret = 0; - if(state->m_is_32bit) - gvram = (const UINT16*)state->m_gvram32.target(); + if(m_is_32bit) + gvram = (const UINT16*)m_gvram32.target(); else - gvram = (const UINT16*)state->m_gvram16.target(); + gvram = (const UINT16*)m_gvram16.target(); - if(state->m_crtc.reg[20] & 0x08) // G-VRAM set to buffer + if(m_crtc.reg[20] & 0x08) // G-VRAM set to buffer return gvram[offset]; - switch(state->m_crtc.reg[20] & 0x0300) // colour setup determines G-VRAM use + switch(m_crtc.reg[20] & 0x0300) // colour setup determines G-VRAM use { case 0x0300: // 65,536 colour (RGB) - 16-bits per word if(offset < 0x40000) @@ -658,20 +650,19 @@ READ16_HANDLER( x68k_gvram_r ) return ret; } -READ16_HANDLER( x68k_tvram_r ) +READ16_MEMBER(x68k_state::x68k_tvram_r ) { - x68k_state *state = space.machine().driver_data(); const UINT16* tvram; - if(state->m_is_32bit) - tvram = (const UINT16*)state->m_tvram32.target(); + if(m_is_32bit) + tvram = (const UINT16*)m_tvram32.target(); else - tvram = (const UINT16*)state->m_tvram16.target(); + tvram = (const UINT16*)m_tvram16.target(); return tvram[offset]; } -READ32_HANDLER( x68k_tvram32_r ) +READ32_MEMBER(x68k_state::x68k_tvram32_r ) { UINT32 ret = 0; @@ -683,7 +674,7 @@ READ32_HANDLER( x68k_tvram32_r ) return ret; } -READ32_HANDLER( x68k_gvram32_r ) +READ32_MEMBER(x68k_state::x68k_gvram32_r ) { UINT32 ret = 0; @@ -695,7 +686,7 @@ READ32_HANDLER( x68k_gvram32_r ) return ret; } -WRITE32_HANDLER( x68k_tvram32_w ) +WRITE32_MEMBER(x68k_state::x68k_tvram32_w ) { if(ACCESSING_BITS_0_7) x68k_tvram_w(space,(offset*2)+1,data,0x00ff); @@ -707,7 +698,7 @@ WRITE32_HANDLER( x68k_tvram32_w ) x68k_tvram_w(space,offset*2,data >> 16,0xff00); } -WRITE32_HANDLER( x68k_gvram32_w ) +WRITE32_MEMBER(x68k_state::x68k_gvram32_w ) { if(ACCESSING_BITS_0_7) x68k_gvram_w(space,(offset*2)+1,data,0x00ff); @@ -719,112 +710,107 @@ WRITE32_HANDLER( x68k_gvram32_w ) x68k_gvram_w(space,offset*2,data >> 16,0xff00); } -WRITE16_HANDLER( x68k_spritereg_w ) +WRITE16_MEMBER(x68k_state::x68k_spritereg_w ) { - x68k_state *state = space.machine().driver_data(); - COMBINE_DATA(state->m_spritereg+offset); + COMBINE_DATA(m_spritereg+offset); switch(offset) { case 0x400: - state->m_bg0_8->set_scrollx(0,(data - state->m_crtc.hbegin - state->m_crtc.bg_hshift) & 0x3ff); - state->m_bg0_16->set_scrollx(0,(data - state->m_crtc.hbegin - state->m_crtc.bg_hshift) & 0x3ff); + m_bg0_8->set_scrollx(0,(data - m_crtc.hbegin - m_crtc.bg_hshift) & 0x3ff); + m_bg0_16->set_scrollx(0,(data - m_crtc.hbegin - m_crtc.bg_hshift) & 0x3ff); break; case 0x401: - state->m_bg0_8->set_scrolly(0,(data - state->m_crtc.vbegin) & 0x3ff); - state->m_bg0_16->set_scrolly(0,(data - state->m_crtc.vbegin) & 0x3ff); + m_bg0_8->set_scrolly(0,(data - m_crtc.vbegin) & 0x3ff); + m_bg0_16->set_scrolly(0,(data - m_crtc.vbegin) & 0x3ff); break; case 0x402: - state->m_bg1_8->set_scrollx(0,(data - state->m_crtc.hbegin - state->m_crtc.bg_hshift) & 0x3ff); - state->m_bg1_16->set_scrollx(0,(data - state->m_crtc.hbegin - state->m_crtc.bg_hshift) & 0x3ff); + m_bg1_8->set_scrollx(0,(data - m_crtc.hbegin - m_crtc.bg_hshift) & 0x3ff); + m_bg1_16->set_scrollx(0,(data - m_crtc.hbegin - m_crtc.bg_hshift) & 0x3ff); break; case 0x403: - state->m_bg1_8->set_scrolly(0,(data - state->m_crtc.vbegin) & 0x3ff); - state->m_bg1_16->set_scrolly(0,(data - state->m_crtc.vbegin) & 0x3ff); + m_bg1_8->set_scrolly(0,(data - m_crtc.vbegin) & 0x3ff); + m_bg1_16->set_scrolly(0,(data - m_crtc.vbegin) & 0x3ff); break; case 0x406: // BG H-DISP (normally equals CRTC reg 2 value + 4) if(data != 0x00ff) { - state->m_crtc.bg_visible_width = (state->m_crtc.reg[3] - ((data & 0x003f) - 4)) * 8; - state->m_crtc.bg_hshift = ((data - (state->m_crtc.reg[2]+4)) * 8); - if(state->m_crtc.bg_hshift > 0) - state->m_crtc.bg_hshift = 0; + m_crtc.bg_visible_width = (m_crtc.reg[3] - ((data & 0x003f) - 4)) * 8; + m_crtc.bg_hshift = ((data - (m_crtc.reg[2]+4)) * 8); + if(m_crtc.bg_hshift > 0) + m_crtc.bg_hshift = 0; } break; case 0x407: // BG V-DISP (like CRTC reg 6) - state->m_crtc.bg_vshift = state->m_crtc.vshift; + m_crtc.bg_vshift = m_crtc.vshift; break; case 0x408: // BG H/V-Res - state->m_crtc.bg_hvres = data & 0x1f; + m_crtc.bg_hvres = data & 0x1f; if(data != 0xff) { // Handle when the PCG is using 256 and the CRTC is using 512 - if((state->m_crtc.bg_hvres & 0x0c) == 0x00 && (state->m_crtc.reg[20] & 0x0c) == 0x04) - state->m_crtc.bg_double = 2; + if((m_crtc.bg_hvres & 0x0c) == 0x00 && (m_crtc.reg[20] & 0x0c) == 0x04) + m_crtc.bg_double = 2; else - state->m_crtc.bg_double = 1; + m_crtc.bg_double = 1; } else - state->m_crtc.bg_double = 1; + m_crtc.bg_double = 1; break; } } -READ16_HANDLER( x68k_spritereg_r ) +READ16_MEMBER(x68k_state::x68k_spritereg_r ) { - x68k_state *state = space.machine().driver_data(); if(offset >= 0x400 && offset < 0x404) - return state->m_spritereg[offset] & 0x3ff; - return state->m_spritereg[offset]; + return m_spritereg[offset] & 0x3ff; + return m_spritereg[offset]; } -WRITE16_HANDLER( x68k_spriteram_w ) +WRITE16_MEMBER(x68k_state::x68k_spriteram_w ) { - x68k_state *state = space.machine().driver_data(); - COMBINE_DATA(state->m_spriteram+offset); - state->m_video.tile8_dirty[offset / 16] = 1; - state->m_video.tile16_dirty[offset / 64] = 1; + COMBINE_DATA(m_spriteram+offset); + m_video.tile8_dirty[offset / 16] = 1; + m_video.tile16_dirty[offset / 64] = 1; if(offset < 0x2000) { - state->m_bg1_8->mark_all_dirty(); - state->m_bg1_16->mark_all_dirty(); - state->m_bg0_8->mark_all_dirty(); - state->m_bg0_16->mark_all_dirty(); + m_bg1_8->mark_all_dirty(); + m_bg1_16->mark_all_dirty(); + m_bg0_8->mark_all_dirty(); + m_bg0_16->mark_all_dirty(); } if(offset >= 0x2000 && offset < 0x3000) { - state->m_bg1_8->mark_tile_dirty(offset & 0x0fff); - state->m_bg1_16->mark_tile_dirty(offset & 0x0fff); + m_bg1_8->mark_tile_dirty(offset & 0x0fff); + m_bg1_16->mark_tile_dirty(offset & 0x0fff); } if(offset >= 0x3000) { - state->m_bg0_8->mark_tile_dirty(offset & 0x0fff); - state->m_bg0_16->mark_tile_dirty(offset & 0x0fff); + m_bg0_8->mark_tile_dirty(offset & 0x0fff); + m_bg0_16->mark_tile_dirty(offset & 0x0fff); } } -READ16_HANDLER( x68k_spriteram_r ) +READ16_MEMBER(x68k_state::x68k_spriteram_r ) { - x68k_state *state = space.machine().driver_data(); - return state->m_spriteram[offset]; + return m_spriteram[offset]; } -static void x68k_draw_text(running_machine &machine,bitmap_ind16 &bitmap, int xscr, int yscr, rectangle rect) +void x68k_state::x68k_draw_text(bitmap_ind16 &bitmap, int xscr, int yscr, rectangle rect) { - x68k_state *state = machine.driver_data(); const UINT16* tvram; unsigned int line,pixel; // location on screen UINT32 loc; // location in TVRAM UINT32 colour; int bit; - if(state->m_is_32bit) - tvram = (const UINT16*)state->m_tvram32.target(); + if(m_is_32bit) + tvram = (const UINT16*)m_tvram32.target(); else - tvram = (const UINT16*)state->m_tvram16.target(); + tvram = (const UINT16*)m_tvram16.target(); for(line=rect.min_y;line<=rect.max_y;line++) // per scanline { // adjust for scroll registers - loc = (((line - state->m_crtc.vbegin) + yscr) & 0x3ff) * 64; + loc = (((line - m_crtc.vbegin) + yscr) & 0x3ff) * 64; loc += (xscr / 16) & 0x7f; loc &= 0xffff; bit = 15 - (xscr & 0x0f); @@ -834,14 +820,14 @@ static void x68k_draw_text(running_machine &machine,bitmap_ind16 &bitmap, int xs + (((tvram[loc+0x10000] >> bit) & 0x01) ? 2 : 0) + (((tvram[loc+0x20000] >> bit) & 0x01) ? 4 : 0) + (((tvram[loc+0x30000] >> bit) & 0x01) ? 8 : 0); - if(state->m_video.text_pal[colour] != 0x0000) // any colour but black + if(m_video.text_pal[colour] != 0x0000) // any colour but black { // Colour 0 is displayable if the text layer is at the priority level 2 - if(colour == 0 && (state->m_video.reg[1] & 0x0c00) == 0x0800) - bitmap.pix16(line, pixel) = 512 + (state->m_video.text_pal[colour] >> 1); + if(colour == 0 && (m_video.reg[1] & 0x0c00) == 0x0800) + bitmap.pix16(line, pixel) = 512 + (m_video.text_pal[colour] >> 1); else if(colour != 0) - bitmap.pix16(line, pixel) = 512 + (state->m_video.text_pal[colour] >> 1); + bitmap.pix16(line, pixel) = 512 + (m_video.text_pal[colour] >> 1); } bit--; if(bit < 0) @@ -854,9 +840,8 @@ static void x68k_draw_text(running_machine &machine,bitmap_ind16 &bitmap, int xs } } -static void x68k_draw_gfx_scanline(running_machine &machine, bitmap_ind16 &bitmap, rectangle cliprect, UINT8 priority) +void x68k_state::x68k_draw_gfx_scanline( bitmap_ind16 &bitmap, rectangle cliprect, UINT8 priority) { - x68k_state *state = machine.driver_data(); const UINT16* gvram; int pixel; int page; @@ -867,23 +852,23 @@ static void x68k_draw_gfx_scanline(running_machine &machine, bitmap_ind16 &bitma int shift; int scanline; - if(state->m_is_32bit) - gvram = (const UINT16*)state->m_gvram32.target(); + if(m_is_32bit) + gvram = (const UINT16*)m_gvram32.target(); else - gvram = (const UINT16*)state->m_gvram16.target(); + gvram = (const UINT16*)m_gvram16.target(); for(scanline=cliprect.min_y;scanline<=cliprect.max_y;scanline++) // per scanline { - if(state->m_crtc.reg[20] & 0x0400) // 1024x1024 "real" screen size - use 1024x1024 16-colour gfx layer + if(m_crtc.reg[20] & 0x0400) // 1024x1024 "real" screen size - use 1024x1024 16-colour gfx layer { // adjust for scroll registers - if(state->m_video.reg[2] & 0x0010 && priority == state->m_video.gfxlayer_pri[0]) + if(m_video.reg[2] & 0x0010 && priority == m_video.gfxlayer_pri[0]) { - xscr = (state->m_crtc.reg[12] & 0x3ff); - yscr = (state->m_crtc.reg[13] & 0x3ff); - lineoffset = (((scanline - state->m_crtc.vbegin) + yscr) & 0x3ff) * 1024; + xscr = (m_crtc.reg[12] & 0x3ff); + yscr = (m_crtc.reg[13] & 0x3ff); + lineoffset = (((scanline - m_crtc.vbegin) + yscr) & 0x3ff) * 1024; loc = xscr & 0x3ff; - for(pixel=state->m_crtc.hbegin;pixel<=state->m_crtc.hend;pixel++) + for(pixel=m_crtc.hbegin;pixel<=m_crtc.hend;pixel++) { switch(lineoffset & 0xc0000) { @@ -901,7 +886,7 @@ static void x68k_draw_gfx_scanline(running_machine &machine, bitmap_ind16 &bitma break; } if(colour != 0) - bitmap.pix16(scanline, pixel) = 512 + (state->m_video.gfx_pal[colour] >> 1); + bitmap.pix16(scanline, pixel) = 512 + (m_video.gfx_pal[colour] >> 1); loc++; loc &= 0x3ff; } @@ -909,23 +894,23 @@ static void x68k_draw_gfx_scanline(running_machine &machine, bitmap_ind16 &bitma } else // else 512x512 "real" screen size { - if(state->m_video.reg[2] & (1 << priority)) + if(m_video.reg[2] & (1 << priority)) { - page = state->m_video.gfxlayer_pri[priority]; + page = m_video.gfxlayer_pri[priority]; // adjust for scroll registers - switch(state->m_video.reg[0] & 0x03) + switch(m_video.reg[0] & 0x03) { case 0x00: // 16 colours - xscr = ((state->m_crtc.reg[12+(page*2)])) & 0x1ff; - yscr = ((state->m_crtc.reg[13+(page*2)])) & 0x1ff; - lineoffset = (((scanline - state->m_crtc.vbegin) + yscr) & 0x1ff) * 512; + xscr = ((m_crtc.reg[12+(page*2)])) & 0x1ff; + yscr = ((m_crtc.reg[13+(page*2)])) & 0x1ff; + lineoffset = (((scanline - m_crtc.vbegin) + yscr) & 0x1ff) * 512; loc = xscr & 0x1ff; shift = 4; - for(pixel=state->m_crtc.hbegin;pixel<=state->m_crtc.hend;pixel++) + for(pixel=m_crtc.hbegin;pixel<=m_crtc.hend;pixel++) { colour = ((gvram[lineoffset + loc] >> page*shift) & 0x000f); if(colour != 0) - bitmap.pix16(scanline, pixel) = 512 + (state->m_video.gfx_pal[colour & 0x0f] >> 1); + bitmap.pix16(scanline, pixel) = 512 + (m_video.gfx_pal[colour & 0x0f] >> 1); loc++; loc &= 0x1ff; } @@ -933,27 +918,27 @@ static void x68k_draw_gfx_scanline(running_machine &machine, bitmap_ind16 &bitma case 0x01: // 256 colours if(page == 0 || page == 2) { - xscr = ((state->m_crtc.reg[12+(page*2)])) & 0x1ff; - yscr = ((state->m_crtc.reg[13+(page*2)])) & 0x1ff; - lineoffset = (((scanline - state->m_crtc.vbegin) + yscr) & 0x1ff) * 512; + xscr = ((m_crtc.reg[12+(page*2)])) & 0x1ff; + yscr = ((m_crtc.reg[13+(page*2)])) & 0x1ff; + lineoffset = (((scanline - m_crtc.vbegin) + yscr) & 0x1ff) * 512; loc = xscr & 0x1ff; shift = 4; - for(pixel=state->m_crtc.hbegin;pixel<=state->m_crtc.hend;pixel++) + for(pixel=m_crtc.hbegin;pixel<=m_crtc.hend;pixel++) { colour = ((gvram[lineoffset + loc] >> page*shift) & 0x00ff); if(colour != 0) - bitmap.pix16(scanline, pixel) = 512 + (state->m_video.gfx_pal[colour & 0xff] >> 1); + bitmap.pix16(scanline, pixel) = 512 + (m_video.gfx_pal[colour & 0xff] >> 1); loc++; loc &= 0x1ff; } } break; case 0x03: // 65536 colours - xscr = ((state->m_crtc.reg[12])) & 0x1ff; - yscr = ((state->m_crtc.reg[13])) & 0x1ff; - lineoffset = (((scanline - state->m_crtc.vbegin) + yscr) & 0x1ff) * 512; + xscr = ((m_crtc.reg[12])) & 0x1ff; + yscr = ((m_crtc.reg[13])) & 0x1ff; + lineoffset = (((scanline - m_crtc.vbegin) + yscr) & 0x1ff) * 512; loc = xscr & 0x1ff; - for(pixel=state->m_crtc.hbegin;pixel<=state->m_crtc.hend;pixel++) + for(pixel=m_crtc.hbegin;pixel<=m_crtc.hend;pixel++) { colour = gvram[lineoffset + loc]; if(colour != 0) @@ -968,27 +953,25 @@ static void x68k_draw_gfx_scanline(running_machine &machine, bitmap_ind16 &bitma } } -static void x68k_draw_gfx(running_machine &machine, bitmap_ind16 &bitmap,rectangle cliprect) +void x68k_state::x68k_draw_gfx(bitmap_ind16 &bitmap,rectangle cliprect) { - x68k_state *state = machine.driver_data(); int priority; //rectangle rect; //int xscr,yscr; //int gpage; - if(state->m_crtc.reg[20] & 0x0800) // if graphic layers are set to buffer, then they aren't visible + if(m_crtc.reg[20] & 0x0800) // if graphic layers are set to buffer, then they aren't visible return; for(priority=3;priority>=0;priority--) { - x68k_draw_gfx_scanline(machine, bitmap,cliprect,priority); + x68k_draw_gfx_scanline(bitmap,cliprect,priority); } } // Sprite controller "Cynthia" at 0xeb0000 -static void x68k_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, int priority, rectangle cliprect) +void x68k_state::x68k_draw_sprites(bitmap_ind16 &bitmap, int priority, rectangle cliprect) { - x68k_state *state = machine.driver_data(); /* 0xeb0000 - 0xeb07ff - Sprite registers (up to 128) + 00 : b9-0, Sprite X position @@ -1022,29 +1005,29 @@ static void x68k_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, in for(ptr=508;ptr>=0;ptr-=4) // stepping through sprites { - pri = state->m_spritereg[ptr+3] & 0x03; + pri = m_spritereg[ptr+3] & 0x03; #ifdef MAME_DEBUG - if(!(machine.input().code_pressed(KEYCODE_I))) + if(!(machine().input().code_pressed(KEYCODE_I))) #endif if(pri == priority) { // if at the right priority level, draw the sprite rectangle rect; - int code = state->m_spritereg[ptr+2] & 0x00ff; - int colour = (state->m_spritereg[ptr+2] & 0x0f00) >> 8; - int xflip = state->m_spritereg[ptr+2] & 0x4000; - int yflip = state->m_spritereg[ptr+2] & 0x8000; - int sx = (state->m_spritereg[ptr+0] & 0x3ff) - 16; - int sy = (state->m_spritereg[ptr+1] & 0x3ff) - 16; + int code = m_spritereg[ptr+2] & 0x00ff; + int colour = (m_spritereg[ptr+2] & 0x0f00) >> 8; + int xflip = m_spritereg[ptr+2] & 0x4000; + int yflip = m_spritereg[ptr+2] & 0x8000; + int sx = (m_spritereg[ptr+0] & 0x3ff) - 16; + int sy = (m_spritereg[ptr+1] & 0x3ff) - 16; - rect.min_x=state->m_crtc.hshift; - rect.min_y=state->m_crtc.vshift; - rect.max_x=rect.min_x + state->m_crtc.visible_width-1; - rect.max_y=rect.min_y + state->m_crtc.visible_height-1; + rect.min_x=m_crtc.hshift; + rect.min_y=m_crtc.vshift; + rect.max_x=rect.min_x + m_crtc.visible_width-1; + rect.max_y=rect.min_y + m_crtc.visible_height-1; - sx += state->m_crtc.bg_hshift; - sx += state->m_sprite_shift; + sx += m_crtc.bg_hshift; + sx += m_sprite_shift; - drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1],code,colour+0x10,xflip,yflip,state->m_crtc.hbegin+sx,state->m_crtc.vbegin+(sy*state->m_crtc.bg_double),0x10000,0x10000*state->m_crtc.bg_double,0x00); + drawgfxzoom_transpen(bitmap,cliprect,machine().gfx[1],code,colour+0x10,xflip,yflip,m_crtc.hbegin+sx,m_crtc.vbegin+(sy*m_crtc.bg_double),0x10000,0x10000*m_crtc.bg_double,0x00); } } } @@ -1214,12 +1197,12 @@ UINT32 x68k_state::screen_update_x68000(screen_device &screen, bitmap_ind16 &bit { // Graphics screen(s) if(priority == m_video.gfx_pri) - x68k_draw_gfx(machine(),bitmap,rect); + x68k_draw_gfx(bitmap,rect); // Sprite / BG Tiles if(priority == m_video.sprite_pri /*&& (m_spritereg[0x404] & 0x0200)*/ && (m_video.reg[2] & 0x0040)) { - x68k_draw_sprites(machine(), bitmap,1,rect); + x68k_draw_sprites(bitmap,1,rect); if((m_spritereg[0x404] & 0x0008)) { if((m_spritereg[0x404] & 0x0030) == 0x10) // BG1 TXSEL @@ -1235,7 +1218,7 @@ UINT32 x68k_state::screen_update_x68000(screen_device &screen, bitmap_ind16 &bit x68k_bg1->draw(bitmap,rect,0,0); } } - x68k_draw_sprites(machine(),bitmap,2,rect); + x68k_draw_sprites(bitmap,2,rect); if((m_spritereg[0x404] & 0x0001)) { if((m_spritereg[0x404] & 0x0006) == 0x02) // BG0 TXSEL @@ -1251,7 +1234,7 @@ UINT32 x68k_state::screen_update_x68000(screen_device &screen, bitmap_ind16 &bit x68k_bg1->draw(bitmap,rect,0,0); } } - x68k_draw_sprites(machine(),bitmap,3,rect); + x68k_draw_sprites(bitmap,3,rect); } // Text screen @@ -1260,7 +1243,7 @@ UINT32 x68k_state::screen_update_x68000(screen_device &screen, bitmap_ind16 &bit xscr = (m_crtc.reg[10] & 0x3ff); yscr = (m_crtc.reg[11] & 0x3ff); if(!(m_crtc.reg[20] & 0x1000)) // if text layer is set to buffer, then it's not visible - x68k_draw_text(machine(),bitmap,xscr,yscr,rect); + x68k_draw_text(bitmap,xscr,yscr,rect); } }