summaryrefslogtreecommitdiffstatshomepage
path: root/src/mess/machine/mac.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/mess/machine/mac.c')
-rw-r--r--src/mess/machine/mac.c320
1 files changed, 144 insertions, 176 deletions
diff --git a/src/mess/machine/mac.c b/src/mess/machine/mac.c
index 10d918af75b..daa8fb2e21b 100644
--- a/src/mess/machine/mac.c
+++ b/src/mess/machine/mac.c
@@ -104,7 +104,7 @@
#include "machine/ram.h"
#include "debugger.h"
-#define AUDIO_IS_CLASSIC (mac->m_model <= MODEL_MAC_CLASSIC)
+#define AUDIO_IS_CLASSIC (m_model <= MODEL_MAC_CLASSIC)
#define MAC_HAS_VIA2 ((m_model >= MODEL_MAC_II) && (m_model != MODEL_MAC_IIFX))
#define ASC_INTS_RBV ((mac->m_model >= MODEL_MAC_IICI) && (mac->m_model <= MODEL_MAC_IIVI)) || ((mac->m_model >= MODEL_MAC_LC) && (mac->m_model <= MODEL_MAC_COLOR_CLASSIC))
@@ -132,49 +132,39 @@ extern TIMER_CALLBACK(mac_pmu_tick); // macadb.c
static int scan_keyboard(running_machine &machine);
static void keyboard_receive(running_machine &machine, int val);
-static DECLARE_READ8_DEVICE_HANDLER(mac_via_in_a);
-static DECLARE_READ8_DEVICE_HANDLER(mac_via_in_b);
-static DECLARE_READ8_DEVICE_HANDLER(mac_adb_via_in_cb2);
-static DECLARE_WRITE8_DEVICE_HANDLER(mac_via_out_a);
-static DECLARE_WRITE8_DEVICE_HANDLER(mac_via_out_b);
-static DECLARE_WRITE8_DEVICE_HANDLER(mac_adb_via_out_cb2);
-static DECLARE_WRITE8_DEVICE_HANDLER(mac_via_out_cb2);
-static DECLARE_READ8_DEVICE_HANDLER(mac_via2_in_a);
-static DECLARE_READ8_DEVICE_HANDLER(mac_via2_in_b);
-static DECLARE_WRITE8_DEVICE_HANDLER(mac_via2_out_a);
-static DECLARE_WRITE8_DEVICE_HANDLER(mac_via2_out_b);
+
static void mac_via_irq(device_t *device, int state);
static void mac_via2_irq(device_t *device, int state);
static offs_t mac_dasm_override(device_t &device, char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, int options);
const via6522_interface mac_via6522_intf =
{
- DEVCB_HANDLER(mac_via_in_a), DEVCB_HANDLER(mac_via_in_b),
+ DEVCB_DRIVER_MEMBER(mac_state,mac_via_in_a), DEVCB_DRIVER_MEMBER(mac_state,mac_via_in_b),
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
- DEVCB_HANDLER(mac_via_out_a), DEVCB_HANDLER(mac_via_out_b),
+ DEVCB_DRIVER_MEMBER(mac_state,mac_via_out_a), DEVCB_DRIVER_MEMBER(mac_state,mac_via_out_b),
DEVCB_NULL, DEVCB_NULL,
- DEVCB_NULL, DEVCB_HANDLER(mac_via_out_cb2),
+ DEVCB_NULL, DEVCB_DRIVER_MEMBER(mac_state,mac_via_out_cb2),
DEVCB_LINE(mac_via_irq)
};
const via6522_interface mac_via6522_adb_intf =
{
- DEVCB_HANDLER(mac_via_in_a), DEVCB_HANDLER(mac_via_in_b),
+ DEVCB_DRIVER_MEMBER(mac_state,mac_via_in_a), DEVCB_DRIVER_MEMBER(mac_state,mac_via_in_b),
DEVCB_NULL, DEVCB_NULL,
- DEVCB_NULL, DEVCB_HANDLER(mac_adb_via_in_cb2),
- DEVCB_HANDLER(mac_via_out_a), DEVCB_HANDLER(mac_via_out_b),
+ DEVCB_NULL, DEVCB_DRIVER_MEMBER(mac_state,mac_adb_via_in_cb2),
+ DEVCB_DRIVER_MEMBER(mac_state,mac_via_out_a), DEVCB_DRIVER_MEMBER(mac_state,mac_via_out_b),
DEVCB_NULL, DEVCB_NULL,
- DEVCB_NULL, DEVCB_HANDLER(mac_adb_via_out_cb2),
+ DEVCB_NULL, DEVCB_DRIVER_MEMBER(mac_state,mac_adb_via_out_cb2),
DEVCB_LINE(mac_via_irq)
};
const via6522_interface mac_via6522_2_intf =
{
- DEVCB_HANDLER(mac_via2_in_a), DEVCB_HANDLER(mac_via2_in_b),
+ DEVCB_DRIVER_MEMBER(mac_state,mac_via2_in_a), DEVCB_DRIVER_MEMBER(mac_state,mac_via2_in_b),
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
- DEVCB_HANDLER(mac_via2_out_a), DEVCB_HANDLER(mac_via2_out_b),
+ DEVCB_DRIVER_MEMBER(mac_state,mac_via2_out_a), DEVCB_DRIVER_MEMBER(mac_state,mac_via2_out_b),
DEVCB_NULL, DEVCB_NULL,
DEVCB_NULL, DEVCB_NULL,
DEVCB_LINE(mac_via2_irq)
@@ -735,21 +725,19 @@ static void kbd_shift_out(running_machine &machine, int data)
}
}
-static WRITE8_DEVICE_HANDLER(mac_via_out_cb2)
+WRITE8_MEMBER(mac_state::mac_via_out_cb2)
{
- mac_state *mac = space.machine().driver_data<mac_state>();
-
- if (mac->m_kbd_comm == FALSE && data == 0)
+ if (m_kbd_comm == FALSE && data == 0)
{
/* Mac pulls CB2 down to initiate communication */
- mac->m_kbd_comm = TRUE;
- mac->m_kbd_receive = TRUE;
- space.machine().scheduler().timer_set(attotime::from_usec(100), timer_expired_delegate(FUNC(mac_state::kbd_clock),mac));
+ m_kbd_comm = TRUE;
+ m_kbd_receive = TRUE;
+ machine().scheduler().timer_set(attotime::from_usec(100), timer_expired_delegate(FUNC(mac_state::kbd_clock),this));
}
- if (mac->m_kbd_comm == TRUE && mac->m_kbd_receive == TRUE)
+ if (m_kbd_comm == TRUE && m_kbd_receive == TRUE)
{
/* Shift in what mac is sending */
- mac->m_kbd_shift_reg = (mac->m_kbd_shift_reg & ~1) | data;
+ m_kbd_shift_reg = (m_kbd_shift_reg & ~1) | data;
}
}
@@ -1175,29 +1163,27 @@ WRITE16_MEMBER ( mac_state::mac_iwm_w )
applefdc_w(fdc, space, (offset >> 8), data>>8);
}
-static READ8_DEVICE_HANDLER(mac_adb_via_in_cb2)
+READ8_MEMBER(mac_state::mac_adb_via_in_cb2)
{
UINT8 ret;
- mac_state *mac = space.machine().driver_data<mac_state>();
-
if (ADB_IS_EGRET)
{
- ret = mac->m_egret->get_via_data();
+ ret = m_egret->get_via_data();
#if LOG_ADB
printf("68K: Read VIA_DATA %x\n", ret);
#endif
}
else if (ADB_IS_CUDA)
{
- ret = mac->m_cuda->get_via_data();
+ ret = m_cuda->get_via_data();
#if LOG_ADB
printf("68K: Read VIA_DATA %x\n", ret);
#endif
}
else
{
- ret = (mac->m_adb_send & 0x80)>>7;
- mac->m_adb_send <<= 1;
+ ret = (m_adb_send & 0x80)>>7;
+ m_adb_send <<= 1;
}
// printf("VIA IN CB2 = %x\n", ret);
@@ -1205,23 +1191,21 @@ static READ8_DEVICE_HANDLER(mac_adb_via_in_cb2)
return ret;
}
-static WRITE8_DEVICE_HANDLER(mac_adb_via_out_cb2)
+WRITE8_MEMBER(mac_state::mac_adb_via_out_cb2)
{
- mac_state *mac = space.machine().driver_data<mac_state>();
-
// printf("VIA OUT CB2 = %x\n", data);
if (ADB_IS_EGRET)
{
- mac->m_egret->set_via_data(data & 1);
+ m_egret->set_via_data(data & 1);
}
else if (ADB_IS_CUDA)
{
- mac->m_cuda->set_via_data(data & 1);
+ m_cuda->set_via_data(data & 1);
}
else
{
- mac->m_adb_command <<= 1;
- mac->m_adb_command |= data & 1;
+ m_adb_command <<= 1;
+ m_adb_command |= data & 1;
}
}
@@ -1261,20 +1245,18 @@ static WRITE8_DEVICE_HANDLER(mac_adb_via_out_cb2)
#define PA2 0x04
#define PA1 0x02
-static READ8_DEVICE_HANDLER(mac_via_in_a)
+READ8_MEMBER(mac_state::mac_via_in_a)
{
- mac_state *mac = space.machine().driver_data<mac_state>();
+// printf("VIA1 IN_A (PC %x)\n", machine().device("maincpu")->safe_pc());
-// printf("VIA1 IN_A (PC %x)\n", space.machine().device("maincpu")->safe_pc());
-
- switch (mac->m_model)
+ switch (m_model)
{
case MODEL_MAC_PORTABLE:
case MODEL_MAC_PB100:
#if LOG_ADB
-// printf("Read PM data %x\n", mac->m_pm_data_recv);
+// printf("Read PM data %x\n", m_pm_data_recv);
#endif
- return mac->m_pm_data_recv;
+ return m_pm_data_recv;
case MODEL_MAC_CLASSIC:
case MODEL_MAC_II:
@@ -1328,89 +1310,85 @@ static READ8_DEVICE_HANDLER(mac_via_in_a)
return 0x80;
}
-static READ8_DEVICE_HANDLER(mac_via_in_b)
+READ8_MEMBER(mac_state::mac_via_in_b)
{
int val = 0;
- mac_state *mac = space.machine().driver_data<mac_state>();
-
// portable/PB100 is pretty different
- if (mac->m_model >= MODEL_MAC_PORTABLE && mac->m_model <= MODEL_MAC_PB100)
+ if (m_model >= MODEL_MAC_PORTABLE && m_model <= MODEL_MAC_PB100)
{
-// printf("Read VIA B: PM_ACK %x\n", mac->m_pm_ack);
- val = 0x80 | 0x04 | mac->m_pm_ack; // SCC wait/request (bit 2 must be set at 900c1a or startup tests always fail)
+// printf("Read VIA B: PM_ACK %x\n", m_pm_ack);
+ val = 0x80 | 0x04 | m_pm_ack; // SCC wait/request (bit 2 must be set at 900c1a or startup tests always fail)
}
else
{
/* video beam in display (! VBLANK && ! HBLANK basically) */
- if (space.machine().primary_screen->vpos() >= MAC_V_VIS)
+ if (machine().primary_screen->vpos() >= MAC_V_VIS)
val |= 0x40;
- if (ADB_IS_BITBANG)
+ if (ADB_IS_BITBANG_CLASS)
{
- val |= mac->m_adb_state<<4;
+ val |= m_adb_state<<4;
- if (!mac->m_adb_irq_pending)
+ if (!m_adb_irq_pending)
{
val |= 0x08;
}
}
else if (ADB_IS_EGRET)
{
- val |= mac->m_egret->get_xcvr_session()<<3;
+ val |= m_egret->get_xcvr_session()<<3;
}
else if (ADB_IS_CUDA)
{
- val |= mac->m_cuda->get_treq()<<3;
+ val |= m_cuda->get_treq()<<3;
}
else
{
- if (mac->m_mouse_bit_y) /* Mouse Y2 */
+ if (m_mouse_bit_y) /* Mouse Y2 */
val |= 0x20;
- if (mac->m_mouse_bit_x) /* Mouse X2 */
+ if (m_mouse_bit_x) /* Mouse X2 */
val |= 0x10;
- if ((space.machine().root_device().ioport("MOUSE0")->read() & 0x01) == 0)
+ if ((machine().root_device().ioport("MOUSE0")->read() & 0x01) == 0)
val |= 0x08;
}
- if (mac->m_rtc_data_out)
+ if (m_rtc_data_out)
val |= 1;
}
-// printf("VIA1 IN_B = %02x (PC %x)\n", val, space.machine().device("maincpu")->safe_pc());
+// printf("VIA1 IN_B = %02x (PC %x)\n", val, machine().device("maincpu")->safe_pc());
return val;
}
-static WRITE8_DEVICE_HANDLER(mac_via_out_a)
+WRITE8_MEMBER(mac_state::mac_via_out_a)
{
- device_t *sound = space.machine().device("custom");
- device_t *fdc = space.machine().device("fdc");
- mac_state *mac = space.machine().driver_data<mac_state>();
-
-// printf("VIA1 OUT A: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
+ device_t *sound = machine().device("custom");
+ device_t *fdc = machine().device("fdc");
+// printf("VIA1 OUT A: %02x (PC %x)\n", data, machine().device("maincpu")->safe_pc());
if (ADB_IS_PM_VIA1)
{
#if LOG_ADB
// printf("%02x to PM\n", data);
#endif
- mac->m_pm_data_send = data;
+ m_pm_data_send = data;
return;
}
set_scc_waitrequest((data & 0x80) >> 7);
- mac->m_screen_buffer = (data & 0x40) >> 6;
+ m_screen_buffer = (data & 0x40) >> 6;
sony_set_sel_line(fdc,(data & 0x20) >> 5);
- if (mac->m_model == MODEL_MAC_SE) // on SE this selects which floppy drive (0 = upper, 1 = lower)
+ if (m_model == MODEL_MAC_SE) // on SE this selects which floppy drive (0 = upper, 1 = lower)
{
- mac->m_drive_select = ((data & 0x10) >> 4);
+ m_drive_select = ((data & 0x10) >> 4);
}
- if (mac->m_model < MODEL_MAC_SE) // SE no longer has dual buffers
+ if (m_model < MODEL_MAC_SE) // SE no longer has dual buffers
{
mac_set_sound_buffer(sound, (data & 0x08) >> 3);
}
- if (mac->m_model < MODEL_MAC_II)
+ if (m_model < MODEL_MAC_II)
{
mac_set_volume(sound, data & 0x07);
}
@@ -1418,81 +1396,79 @@ static WRITE8_DEVICE_HANDLER(mac_via_out_a)
/* Early Mac models had VIA A4 control overlaying. In the Mac SE (and
* possibly later models), overlay was set on reset, but cleared on the
* first access to the ROM. */
- if (mac->m_model < MODEL_MAC_SE)
+ if (m_model < MODEL_MAC_SE)
{
- mac->set_memory_overlay((data & 0x10) >> 4);
+ set_memory_overlay((data & 0x10) >> 4);
}
}
-static WRITE8_DEVICE_HANDLER(mac_via_out_b)
+WRITE8_MEMBER(mac_state::mac_via_out_b)
{
- device_t *sound = space.machine().device("custom");
+ device_t *sound = machine().device("custom");
int new_rtc_rTCClk;
- mac_state *mac = space.machine().driver_data<mac_state>();
-
-// printf("VIA1 OUT B: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
+// printf("VIA1 OUT B: %02x (PC %x)\n", data, machine().device("maincpu")->safe_pc());
if (ADB_IS_PM_VIA1)
{
- device_t *fdc = space.machine().device("fdc");
+ device_t *fdc = machine().device("fdc");
sony_set_sel_line(fdc,(data & 0x20) >> 5);
- mac->m_drive_select = ((data & 0x10) >> 4);
+ m_drive_select = ((data & 0x10) >> 4);
- if ((data & 1) && !(mac->m_pm_req & 1))
+ if ((data & 1) && !(m_pm_req & 1))
{
#if LOG_ADB
printf("PM: 68k dropping /REQ\n");
#endif
- if (mac->m_pm_state == 0) // do this in receive state only
+ if (m_pm_state == 0) // do this in receive state only
{
- mac->m_pm_data_recv = 0xff;
- mac->m_pm_ack |= 2;
+ m_pm_data_recv = 0xff;
+ m_pm_ack |= 2;
// check if length byte matches
- if ((mac->m_pm_dptr >= 2) && (mac->m_pm_cmd[1] == (mac->m_pm_dptr-2)))
+ if ((m_pm_dptr >= 2) && (m_pm_cmd[1] == (m_pm_dptr-2)))
{
- mac->pmu_exec();
+ pmu_exec();
#if LOG_ADB
- printf("PMU exec: command %02x length %d\n", mac->m_pm_cmd[0], mac->m_pm_cmd[1]);
+ printf("PMU exec: command %02x length %d\n", m_pm_cmd[0], m_pm_cmd[1]);
#endif
}
}
}
- else if (!(data & 1) && (mac->m_pm_req & 1))
+ else if (!(data & 1) && (m_pm_req & 1))
{
- if (mac->m_pm_state == 0)
+ if (m_pm_state == 0)
{
#if LOG_ADB
- printf("PM: 68k asserting /REQ, clocking in byte [%d] = %02x\n", mac->m_pm_dptr, mac->m_pm_data_send);
+ printf("PM: 68k asserting /REQ, clocking in byte [%d] = %02x\n", m_pm_dptr, m_pm_data_send);
#endif
- mac->m_pm_ack &= ~2; // clear, we're waiting for more bytes
- mac->m_pm_cmd[mac->m_pm_dptr++] = mac->m_pm_data_send;
+ m_pm_ack &= ~2; // clear, we're waiting for more bytes
+ m_pm_cmd[m_pm_dptr++] = m_pm_data_send;
}
else // receiving, so this is different
{
- mac->m_pm_data_recv = mac->m_pm_out[mac->m_pm_sptr++];
- mac->m_pm_slen--;
- mac->m_pm_ack |= 2; // raise ACK to indicate available byte
+ m_pm_data_recv = m_pm_out[m_pm_sptr++];
+ m_pm_slen--;
+ m_pm_ack |= 2; // raise ACK to indicate available byte
#if LOG_ADB
- printf("PM: 68k asserted /REQ, sending byte %02x\n", mac->m_pm_data_recv);
+ printf("PM: 68k asserted /REQ, sending byte %02x\n", m_pm_data_recv);
#endif
// another byte to send?
- if (mac->m_pm_slen)
+ if (m_pm_slen)
{
- mac->m_pmu_send_timer->adjust(attotime(0, ATTOSECONDS_IN_USEC(100)));
+ m_pmu_send_timer->adjust(attotime(0, ATTOSECONDS_IN_USEC(100)));
}
else
{
- mac->m_pm_state = 0; // back to receive state
- mac->m_pmu_send_timer->adjust(attotime::never);
+ m_pm_state = 0; // back to receive state
+ m_pmu_send_timer->adjust(attotime::never);
}
}
}
- mac->m_pm_req = data & 1;
+ m_pm_req = data & 1;
return;
}
@@ -1502,49 +1478,49 @@ static WRITE8_DEVICE_HANDLER(mac_via_out_b)
}
// SE and Classic have SCSI enable/disable here
- if ((mac->m_model == MODEL_MAC_SE) || (mac->m_model == MODEL_MAC_CLASSIC))
+ if ((m_model == MODEL_MAC_SE) || (m_model == MODEL_MAC_CLASSIC))
{
- mac->m_scsiirq_enable = (data & 0x40) ? 0 : 1;
-// printf("VIAB & 0x40 = %02x, IRQ enable %d\n", data & 0x40, mac->m_scsiirq_enable);
+ m_scsiirq_enable = (data & 0x40) ? 0 : 1;
+// printf("VIAB & 0x40 = %02x, IRQ enable %d\n", data & 0x40, m_scsiirq_enable);
}
- if (mac->m_model == MODEL_MAC_SE30)
+ if (m_model == MODEL_MAC_SE30)
{
// 0x40 = 0 means enable vblank on SE/30
- mac->m_se30_vbl_enable = (data & 0x40) ? 0 : 1;
+ m_se30_vbl_enable = (data & 0x40) ? 0 : 1;
// clear the interrupt if we disabled it
- if (!mac->m_se30_vbl_enable)
+ if (!m_se30_vbl_enable)
{
- mac->nubus_slot_interrupt(0xe, 0);
+ nubus_slot_interrupt(0xe, 0);
}
}
- mac->rtc_write_rTCEnb(data & 0x04);
+ rtc_write_rTCEnb(data & 0x04);
new_rtc_rTCClk = (data >> 1) & 0x01;
- if ((! new_rtc_rTCClk) && (mac->m_rtc_rTCClk))
- mac->rtc_shift_data(data & 0x01);
- mac->m_rtc_rTCClk = new_rtc_rTCClk;
+ if ((! new_rtc_rTCClk) && (m_rtc_rTCClk))
+ rtc_shift_data(data & 0x01);
+ m_rtc_rTCClk = new_rtc_rTCClk;
- if (ADB_IS_BITBANG)
+ if (ADB_IS_BITBANG_CLASS)
{
- mac->mac_adb_newaction((data & 0x30) >> 4);
+ mac_adb_newaction((data & 0x30) >> 4);
}
else if (ADB_IS_EGRET)
{
#if LOG_ADB
- printf("68K: New Egret state: SS %d VF %d (PC %x)\n", (data>>5)&1, (data>>4)&1, mac->m_maincpu->pc());
+ printf("68K: New Egret state: SS %d VF %d (PC %x)\n", (data>>5)&1, (data>>4)&1, m_maincpu->pc());
#endif
- mac->m_egret->set_via_full((data&0x10) ? 1 : 0);
- mac->m_egret->set_sys_session((data&0x20) ? 1 : 0);
+ m_egret->set_via_full((data&0x10) ? 1 : 0);
+ m_egret->set_sys_session((data&0x20) ? 1 : 0);
}
else if (ADB_IS_CUDA)
{
#if LOG_ADB
- printf("68K: New Cuda state: TIP %d BYTEACK %d (PC %x)\n", (data>>5)&1, (data>>4)&1, mac->m_maincpu->pc());
+ printf("68K: New Cuda state: TIP %d BYTEACK %d (PC %x)\n", (data>>5)&1, (data>>4)&1, m_maincpu->pc());
#endif
- mac->m_cuda->set_byteack((data&0x10) ? 1 : 0);
- mac->m_cuda->set_tip((data&0x20) ? 1 : 0);
+ m_cuda->set_byteack((data&0x10) ? 1 : 0);
+ m_cuda->set_tip((data&0x20) ? 1 : 0);
}
}
@@ -1628,36 +1604,32 @@ WRITE16_MEMBER ( mac_state::mac_via2_w )
}
-static READ8_DEVICE_HANDLER(mac_via2_in_a)
+READ8_MEMBER(mac_state::mac_via2_in_a)
{
UINT8 result;
- mac_state *mac = space.machine().driver_data<mac_state>();
-
if (ADB_IS_PM_VIA2)
{
- result = mac->m_pm_data_recv;
+ result = m_pm_data_recv;
}
- else if ((mac->m_model == MODEL_MAC_QUADRA_700) || (mac->m_model == MODEL_MAC_QUADRA_900) || (mac->m_model == MODEL_MAC_QUADRA_950))
+ else if ((m_model == MODEL_MAC_QUADRA_700) || (m_model == MODEL_MAC_QUADRA_900) || (m_model == MODEL_MAC_QUADRA_950))
{
- result = 0x80 | mac->m_nubus_irq_state;
+ result = 0x80 | m_nubus_irq_state;
}
else
{
- result = 0xc0 | mac->m_nubus_irq_state;
+ result = 0xc0 | m_nubus_irq_state;
}
return result;
}
-static READ8_DEVICE_HANDLER(mac_via2_in_b)
+READ8_MEMBER(mac_state::mac_via2_in_b)
{
- mac_state *mac =space.machine().driver_data<mac_state>();
-
-// logerror("VIA2 IN B (PC %x)\n", space.machine().device("maincpu")->safe_pc());
+// logerror("VIA2 IN B (PC %x)\n", machine().device("maincpu")->safe_pc());
if (ADB_IS_PM_VIA2)
{
- if (mac->m_pm_ack == 2)
+ if (m_pm_ack == 2)
{
return 0xcf;
}
@@ -1667,12 +1639,12 @@ static READ8_DEVICE_HANDLER(mac_via2_in_b)
}
}
- if ((mac->m_model == MODEL_MAC_LC) || (mac->m_model == MODEL_MAC_LC_II) || (mac->m_model == MODEL_MAC_CLASSIC_II))
+ if ((m_model == MODEL_MAC_LC) || (m_model == MODEL_MAC_LC_II) || (m_model == MODEL_MAC_CLASSIC_II))
{
return 0x4f;
}
- if ((mac->m_model == MODEL_MAC_SE30) || (mac->m_model == MODEL_MAC_IIX))
+ if ((m_model == MODEL_MAC_SE30) || (m_model == MODEL_MAC_IIX))
{
return 0x87; // bits 3 and 6 are tied low on SE/30
}
@@ -1680,91 +1652,87 @@ static READ8_DEVICE_HANDLER(mac_via2_in_b)
return 0xcf; // indicate no NuBus transaction error
}
-static WRITE8_DEVICE_HANDLER(mac_via2_out_a)
+WRITE8_MEMBER(mac_state::mac_via2_out_a)
{
- mac_state *mac = space.machine().driver_data<mac_state>();
-
-// logerror("VIA2 OUT A: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
+// logerror("VIA2 OUT A: %02x (PC %x)\n", data, machine().device("maincpu")->safe_pc());
if (ADB_IS_PM_VIA2)
{
- mac->m_pm_data_send = data;
+ m_pm_data_send = data;
return;
}
}
-static WRITE8_DEVICE_HANDLER(mac_via2_out_b)
+WRITE8_MEMBER(mac_state::mac_via2_out_b)
{
- mac_state *mac = space.machine().driver_data<mac_state>();
-
-// logerror("VIA2 OUT B: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
+// logerror("VIA2 OUT B: %02x (PC %x)\n", data, machine().device("maincpu")->safe_pc());
if (ADB_IS_PM_VIA2)
{
- if ((data & 4) && !(mac->m_pm_req & 4))
+ if ((data & 4) && !(m_pm_req & 4))
{
#if LOG_ADB
printf("PM: 68k dropping /REQ\n");
#endif
- if (mac->m_pm_state == 0) // do this in receive state only
+ if (m_pm_state == 0) // do this in receive state only
{
- mac->m_pm_data_recv = 0xff;
- mac->m_pm_ack |= 2;
+ m_pm_data_recv = 0xff;
+ m_pm_ack |= 2;
// check if length byte matches
- if ((mac->m_pm_dptr >= 2) && (mac->m_pm_cmd[1] == (mac->m_pm_dptr-2)))
+ if ((m_pm_dptr >= 2) && (m_pm_cmd[1] == (m_pm_dptr-2)))
{
- mac->pmu_exec();
+ pmu_exec();
#if LOG_ADB
- printf("PMU exec: command %02x length %d\n", mac->m_pm_cmd[0], mac->m_pm_cmd[1]);
+ printf("PMU exec: command %02x length %d\n", m_pm_cmd[0], m_pm_cmd[1]);
#endif
}
}
}
- else if (!(data & 4) && (mac->m_pm_req & 4))
+ else if (!(data & 4) && (m_pm_req & 4))
{
- if (mac->m_pm_state == 0)
+ if (m_pm_state == 0)
{
#if LOG_ADB
- printf("PM: 68k asserting /REQ, clocking in byte [%d] = %02x\n", mac->m_pm_dptr, mac->m_pm_data_send);
+ printf("PM: 68k asserting /REQ, clocking in byte [%d] = %02x\n", m_pm_dptr, m_pm_data_send);
#endif
- mac->m_pm_ack &= ~2; // clear, we're waiting for more bytes
- mac->m_pm_cmd[mac->m_pm_dptr++] = mac->m_pm_data_send;
+ m_pm_ack &= ~2; // clear, we're waiting for more bytes
+ m_pm_cmd[m_pm_dptr++] = m_pm_data_send;
}
else // receiving, so this is different
{
- mac->m_pm_data_recv = mac->m_pm_out[mac->m_pm_sptr++];
- mac->m_pm_slen--;
- mac->m_pm_ack |= 2; // raise ACK to indicate available byte
+ m_pm_data_recv = m_pm_out[m_pm_sptr++];
+ m_pm_slen--;
+ m_pm_ack |= 2; // raise ACK to indicate available byte
#if LOG_ADB
- printf("PM: 68k asserted /REQ, sending byte %02x\n", mac->m_pm_data_recv);
+ printf("PM: 68k asserted /REQ, sending byte %02x\n", m_pm_data_recv);
#endif
// another byte to send?
- if (mac->m_pm_slen)
+ if (m_pm_slen)
{
- mac->m_pmu_send_timer->adjust(attotime(0, ATTOSECONDS_IN_USEC(100)));
+ m_pmu_send_timer->adjust(attotime(0, ATTOSECONDS_IN_USEC(100)));
}
else
{
- mac->m_pm_state = 0; // back to receive state
- mac->m_pmu_send_timer->adjust(attotime::never);
+ m_pm_state = 0; // back to receive state
+ m_pmu_send_timer->adjust(attotime::never);
}
}
}
- mac->m_pm_req = data & 4;
+ m_pm_req = data & 4;
return;
}
else
{
// chain 60.15 Hz to VIA1
- mac->m_via1->write_ca1(data>>7);
+ m_via1->write_ca1(data>>7);
}
- if (mac->m_model == MODEL_MAC_II)
+ if (m_model == MODEL_MAC_II)
{
- m68k_set_hmmu_enable(mac->m_maincpu, (data & 0x8) ? M68K_HMMU_DISABLE : M68K_HMMU_ENABLE_II);
+ m68k_set_hmmu_enable(m_maincpu, (data & 0x8) ? M68K_HMMU_DISABLE : M68K_HMMU_ENABLE_II);
}
}