apple/apple2.cpp, apple2e.cpp, apple2gs.cpp: Don't disable reading $C0nx from debug memory view; add the appropriate check to bus devices instead

* bus/a2bus: Add support for reading from open bus

Author: ajrhacker

src/devices/bus/a2bus/a2applicard.cpp

@@ -178,7 +178,8 @@ uint8_t a2bus_applicard_device::read_c0nx(uint8_t offset)
 	switch (offset & 0xf)
 	{
 		case 0:
-			m_6502stat = false;
+			if (!machine().side_effects_disabled())
+				m_6502stat = false;
 			return m_to6502;
 
 		case 1:
@@ -189,31 +190,37 @@ uint8_t a2bus_applicard_device::read_c0nx(uint8_t offset)
 			{
 				return 0x80;
 			}
-			return false;
+			return 0;
 
 		case 3:
 			if (m_6502stat)
 			{
 				return 0x80;
 			}
-			return false;
+			return 0;
 
 		case 5:
-			m_z80rom.select(0);
-			m_toz80 = false;
-			m_to6502 = false;
-			m_z80->reset();
+			if (!machine().side_effects_disabled())
+			{
+				m_z80rom.select(0);
+				m_toz80 = false;
+				m_to6502 = false;
+				m_z80->reset();
+			}
 			break;
 
 		case 6: // IRQ on Z80 via CTC channel 3 (CP/M doesn't use the CTC or IRQs)
-			fatalerror("Applicard: Z80 IRQ not supported yet\n");
+			if (!machine().side_effects_disabled())
+				fatalerror("Applicard: Z80 IRQ not supported yet\n");
+			break;
 
 		case 7: // NMI on Z80 (direct)
-			m_z80->pulse_input_line(INPUT_LINE_NMI, attotime::zero);
+			if (!machine().side_effects_disabled())
+				m_z80->pulse_input_line(INPUT_LINE_NMI, attotime::zero);
 			break;
 
 	}
-	return 0xff;
+	return get_open_bus();
 }
 
 void a2bus_applicard_device::write_c0nx(uint8_t offset, uint8_t data)

src/devices/bus/a2bus/a2bus.cpp

@@ -168,6 +168,7 @@ a2bus_device::a2bus_device(const machine_config &mconfig, device_type type, cons
 	, m_out_nmi_cb(*this)
 	, m_out_inh_cb(*this)
 	, m_out_dma_cb(*this)
+	, m_in_open_bus_cb(*this, 0xff)
 	, m_slot_irq_mask(0), m_slot_nmi_mask(0)
 {
 }
@@ -346,3 +347,49 @@ void device_a2bus_card_interface::interface_pre_start()
 		m_a2bus->add_a2bus_card(m_slot, this);
 	}
 }
+
+
+uint8_t device_a2bus_card_interface::read_c0nx(uint8_t offset)
+{
+	if (!device().machine().side_effects_disabled())
+		device().logerror("a2bus: unhandled read at C0n%x\n", offset);
+	return get_open_bus();
+}
+
+void device_a2bus_card_interface::write_c0nx(uint8_t offset, uint8_t data)
+{
+	device().logerror("a2bus: unhandled write %02x to C0n%x\n", data, offset);
+}
+
+uint8_t device_a2bus_card_interface::read_cnxx(uint8_t offset)
+{
+	return get_open_bus();
+}
+
+void device_a2bus_card_interface::write_cnxx(uint8_t offset, uint8_t data)
+{
+	device().logerror("a2bus: unhandled write %02x to Cn%02x\n", data, offset);
+}
+
+uint8_t device_a2bus_card_interface::read_c800(uint16_t offset)
+{
+	if (!device().machine().side_effects_disabled())
+		device().logerror("a2bus: unhandled read at %04x\n", offset + 0xc800);
+	return get_open_bus();
+}
+
+void device_a2bus_card_interface::write_c800(uint16_t offset, uint8_t data)
+{
+	device().logerror("a2bus: unhandled write %02x to %04x\n", data, offset + 0xc800);
+}
+
+uint8_t device_a2bus_card_interface::read_inh_rom(uint16_t offset)
+{
+	if (!device().machine().side_effects_disabled())
+		device().logerror("a2bus: unhandled read at C0n%x\n", offset);
+	return get_open_bus();
+}
+
+void device_a2bus_card_interface::write_inh_rom(uint16_t offset, uint8_t data)
+{
+}

src/devices/bus/a2bus/a2bus.h

@@ -75,6 +75,7 @@ class a2bus_device : public device_t
 	auto nmi_w() { return m_out_nmi_cb.bind(); }
 	auto inh_w() { return m_out_inh_cb.bind(); }
 	auto dma_w() { return m_out_dma_cb.bind(); }
+	auto open_bus_r() { return m_in_open_bus_cb.bind(); }
 
 	void add_a2bus_card(int slot, device_a2bus_card_interface *card);
 	device_a2bus_card_interface *get_a2bus_card(int slot);
@@ -88,6 +89,7 @@ class a2bus_device : public device_t
 	uint8_t dma_r(uint16_t offset);
 	void dma_w(uint16_t offset, uint8_t data);
 	void reset_bus();
+	uint8_t get_open_bus() { return m_in_open_bus_cb(); }
 
 	void irq_w(int state);
 	void nmi_w(int state);
@@ -106,6 +108,7 @@ class a2bus_device : public device_t
 	devcb_write_line    m_out_nmi_cb;
 	devcb_write8        m_out_inh_cb;
 	devcb_write_line    m_out_dma_cb;
+	devcb_read8         m_in_open_bus_cb;
 
 	device_a2bus_card_interface *m_device_list[8];
 
@@ -127,15 +130,15 @@ class device_a2bus_card_interface : public device_interface
 	// construction/destruction
 	virtual ~device_a2bus_card_interface();
 
-	virtual uint8_t read_c0nx(uint8_t offset) { device().logerror("a2bus: unhandled read at C0n%x\n", offset); return 0; }       // C0nX - /DEVSEL
-	virtual void write_c0nx(uint8_t offset, uint8_t data) { device().logerror("a2bus: unhandled write %02x to C0n%x\n", data, offset); }
-	virtual uint8_t read_cnxx(uint8_t offset) { return 0; }       // CnXX - /IOSEL
-	virtual void write_cnxx(uint8_t offset, uint8_t data) { device().logerror("a2bus: unhandled write %02x to Cn%02x\n", data, offset); }
-	virtual uint8_t read_c800(uint16_t offset) { return 0; }      // C800 - /IOSTB
-	virtual void write_c800(uint16_t offset, uint8_t data) {device().logerror("a2bus: unhandled write %02x to %04x\n", data, offset + 0xc800); }
-	virtual bool take_c800() const { return false; }   // override and return true if your card can take over the /IOSTB space
-	virtual uint8_t read_inh_rom(uint16_t offset) { return 0; }
-	virtual void write_inh_rom(uint16_t offset, uint8_t data) { }
+	virtual uint8_t read_c0nx(uint8_t offset);          // C0nX - /DEVSEL
+	virtual void write_c0nx(uint8_t offset, uint8_t data);
+	virtual uint8_t read_cnxx(uint8_t offset);          // CnXX - /IOSEL
+	virtual void write_cnxx(uint8_t offset, uint8_t data);
+	virtual uint8_t read_c800(uint16_t offset);         // C800 - /IOSTB
+	virtual void write_c800(uint16_t offset, uint8_t data);
+	virtual bool take_c800() const { return false; }    // override and return true if your card can take over the /IOSTB space
+	virtual uint8_t read_inh_rom(uint16_t offset);
+	virtual void write_inh_rom(uint16_t offset, uint8_t data);
 	virtual uint16_t inh_start() { return INH_START_INVALID; }
 	virtual uint16_t inh_end() { return INH_END_INVALID; }
 	virtual bool inh_check(uint16_t offset, bool bIsWrite) { return false; }
@@ -162,6 +165,7 @@ class device_a2bus_card_interface : public device_interface
 	void recalc_slot_inh() { m_a2bus->recalc_inh(m_slot); }
 	void raise_slot_dma() { m_a2bus->set_dma_line(ASSERT_LINE); }
 	void lower_slot_dma() { m_a2bus->set_dma_line(CLEAR_LINE); }
+	uint8_t get_open_bus() { return m_a2bus->get_open_bus(); }
 
 	device_a2bus_card_interface(const machine_config &mconfig, device_t &device);
 

src/devices/bus/a2bus/a2cffa.cpp

@@ -194,16 +194,18 @@ uint8_t a2bus_cffa2000_device::read_c0nx(uint8_t offset)
 			return m_lastreaddata >> 8;
 
 		case 3:
-			m_writeprotect = false;
+			if (!machine().side_effects_disabled())
+				m_writeprotect = false;
 			break;
 
 		case 4:
-			m_writeprotect = true;
+			if (!machine().side_effects_disabled())
+				m_writeprotect = true;
 			break;
 
 		case 8:
 			// Apple /// driver uses sta $c080,x when writing, which causes spurious reads of c088
-			if (!m_inwritecycle)
+			if (!m_inwritecycle && !machine().side_effects_disabled())
 			{
 				m_lastreaddata = m_ata->cs0_r(offset - 8);
 			}
@@ -219,7 +221,7 @@ uint8_t a2bus_cffa2000_device::read_c0nx(uint8_t offset)
 			return m_ata->cs0_r(offset - 8, 0xff);
 	}
 
-	return 0xff;
+	return get_open_bus();
 }
 
 

src/devices/bus/a2bus/a2mockingboard.cpp

@@ -45,7 +45,7 @@ class a2bus_ayboard_device:
 	virtual void device_add_mconfig(machine_config &config) override ATTR_COLD;
 
 	// device_a2bus_card_interface implementation
-	virtual u8 read_c0nx(u8 offset) override { return 0xff; }
+	virtual u8 read_c0nx(u8 offset) override { return get_open_bus(); }
 	virtual void write_c0nx(u8 offset, u8 data) override { }
 	virtual u8 read_cnxx(u8 offset) override;
 	virtual void write_cnxx(u8 offset, u8 data) override;
@@ -568,9 +568,12 @@ void a2bus_phasor_device::set_clocks()
 
 u8 a2bus_phasor_device::read_c0nx(u8 offset)
 {
-	m_native = BIT(offset, 0);
-	set_clocks();
-	return 0xff;
+	if (!machine().side_effects_disabled())
+	{
+		m_native = BIT(offset, 0);
+		set_clocks();
+	}
+	return get_open_bus();
 }
 
 void a2bus_phasor_device::write_c0nx(u8 offset, u8 data)

src/devices/bus/a2bus/a2parprn.cpp

@@ -171,7 +171,7 @@ u8 a2bus_parprn_device::read_c0nx(u8 offset)
 		write_c0nx(offset, 0xffU);
 	}
 
-	return 0x00U;
+	return get_open_bus();
 }
 
 

src/devices/bus/a2bus/a2pic.cpp

@@ -218,7 +218,7 @@ u8 a2bus_pic_device::read_c0nx(u8 offset)
 		return 0x97U | (m_perror_in << 5) | (m_select_in << 6) | (m_fault_in << 3);
 
 	case 4U:
-		return (m_ack_latch << 7) | (m_ack_in ^ BIT(m_input_sw1->read(), 4));
+		return (m_ack_latch << 7) | (get_open_bus() & 0x7eU) | (m_ack_in ^ BIT(m_input_sw1->read(), 4));
 
 	case 5U:
 		logerror("500ns negative strobe not implemented\n");
@@ -235,7 +235,7 @@ u8 a2bus_pic_device::read_c0nx(u8 offset)
 		break;
 	}
 
-	return 0x00U;
+	return get_open_bus();
 }
 
 void a2bus_pic_device::write_c0nx(u8 offset, u8 data)

src/devices/bus/a2bus/a2sic.cpp

@@ -117,7 +117,7 @@ u8 a2sic_device::read_cnxx(u8 offset)
 u8 a2sic_device::read_c800(u16 offset)
 {
 	if (BIT(offset, 9))
-		return 0xff; // TODO: select open bus
+		return get_open_bus(); // TODO: deselect card
 	else
 		return m_p8[offset & 0x1ff];
 }

src/devices/bus/a2bus/a2videoterm.cpp

@@ -388,7 +388,7 @@ uint8_t a2bus_videx80_device::read_c0nx(uint8_t offset)
 		return m_crtc->register_r();   // status_r?
 	}
 
-	return 0xff;
+	return get_open_bus();
 }
 
 
@@ -450,10 +450,12 @@ uint8_t a2bus_videx80_device::read_c800(uint16_t offset)
 //        printf("Read VRAM at %x = %02x\n", offset+m_rambank, m_ram[offset + m_rambank]);
 		return m_rom[offset];
 	}
-	else
+	else if (offset < 0x600)
 	{
 		return m_ram[(offset & 0x1ff) + m_rambank];
 	}
+	else
+		return get_open_bus();
 }
 
 /*-------------------------------------------------

src/devices/bus/a2bus/grappler.cpp

@@ -291,15 +291,15 @@ u8 a2bus_grappler_device::read_c0nx(u8 offset)
 	if (BIT(offset, 0)) // A0 - printer status
 	{
 		return
-				0xf0U | // TODO: actually open bus
+				(get_open_bus() & 0xf0U) |
 				(busy_in() << 3) |
 				(pe_in() << 2) |
 				(slct_in() << 1) |
 				m_ack_latch;
 	}
 	else
 	{
-		return 0xffU; // TODO: actually open bus
+		return get_open_bus();
 	}
 }