mame/video: simpified handlers in various devices (nw)

src/mame/drivers/de_3.cpp

@@ -231,12 +231,12 @@ WRITE8_MEMBER( de_3_state::pia2c_pa_w )
 	/* DMD data */
 	if(m_dmdtype2)
 	{
-		m_dmdtype2->data_w(space,offset,data);
+		m_dmdtype2->data_w(data);
 		logerror("DMD: Data write %02x\n", data);
 	}
 	else if(m_dmdtype1)
 	{
-		m_dmdtype1->data_w(space,offset,data);
+		m_dmdtype1->data_w(data);
 		logerror("DMD: Data write %02x\n", data);
 	}
 //  m_segment1 |= (data<<8);
@@ -251,9 +251,9 @@ WRITE8_MEMBER( de_3_state::pia2c_pa_w )
 READ8_MEMBER( de_3_state::pia2c_pb_r )
 {
 	if(m_dmdtype1)
-		return m_dmdtype1->busy_r(space,offset);
+		return m_dmdtype1->busy_r();
 	if(m_dmdtype2)
-		return m_dmdtype2->busy_r(space,offset);
+		return m_dmdtype2->busy_r();
 	return 0;
 }
 
@@ -262,12 +262,12 @@ WRITE8_MEMBER( de_3_state::pia2c_pb_w )
 	/* DMD ctrl */
 	if(m_dmdtype2)
 	{
-		m_dmdtype2->ctrl_w(space,offset,data);
+		m_dmdtype2->ctrl_w(data);
 		logerror("DMD: Control write %02x\n", data);
 	}
 	else if(m_dmdtype1)
 	{
-		m_dmdtype1->ctrl_w(space,offset,data);
+		m_dmdtype1->ctrl_w(data);
 		logerror("DMD: Control write %02x\n", data);
 	}
 
@@ -318,11 +318,11 @@ READ8_MEMBER( de_3_state::dmd_status_r )
 {
 	if(m_dmdtype1)
 	{
-		return m_dmdtype1->status_r(space,offset);
+		return m_dmdtype1->status_r();
 	}
 	else if(m_dmdtype2)
 	{
-		return m_dmdtype2->status_r(space,offset);
+		return m_dmdtype2->status_r();
 	}
 	return 0;
 }

src/mame/drivers/whitestar.cpp

@@ -112,9 +112,9 @@ WRITE8_MEMBER(whitestar_state::bank_w)
 // Whitestar automatically pulses the DMD IRQ line?  DE hardware doesn't do that...
 WRITE8_MEMBER(whitestar_state::dmddata_w)
 {
-	m_decodmd->data_w(space,offset,data);
+	m_decodmd->data_w(data);
-	m_decodmd->ctrl_w(space,0,1);
+	m_decodmd->ctrl_w(1);
-	m_decodmd->ctrl_w(space,0,0);
+	m_decodmd->ctrl_w(0);
 }
 void whitestar_state::machine_start()
 {

src/mame/video/733_asr.cpp

@@ -315,7 +315,7 @@ void asr733_device::receive_callback(int dummy)
     14: DSR data set ready, 1 if online
     15: INT interrupt, 1 if interrupt
 */
-READ8_MEMBER( asr733_device::cru_r )
+uint8_t asr733_device::cru_r(offs_t offset)
 {
 	int reply = 0;
 
@@ -346,7 +346,7 @@ READ8_MEMBER( asr733_device::cru_r )
     14: enable interrupts, 1 to enable interrupts
     15: diagnostic mode, 0 for normal mode
 */
-WRITE8_MEMBER( asr733_device::cru_w )
+void asr733_device::cru_w(offs_t offset, uint8_t data)
 {
 	switch (offset)
 	{

src/mame/video/733_asr.h

@@ -21,8 +21,8 @@ public:
 
 	asr733_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_READ8_MEMBER(cru_r);
+	uint8_t cru_r(offs_t offset);
-	DECLARE_WRITE8_MEMBER(cru_w);
+	void cru_w(offs_t offset, uint8_t data);
 
 	auto keyint_cb() { return m_keyint_line.bind(); }
 	auto lineint_cb() { return m_lineint_line.bind(); }

src/mame/video/911_vdt.cpp

@@ -276,7 +276,7 @@ void vdt911_device::device_timer(emu_timer &timer, device_timer_id id, int param
 /*
     CRU interface read
 */
-READ8_MEMBER( vdt911_device::cru_r )
+uint8_t vdt911_device::cru_r(offs_t offset)
 {
 	int reply=0;
 
@@ -327,7 +327,7 @@ READ8_MEMBER( vdt911_device::cru_r )
 /*
     CRU interface write
 */
-WRITE8_MEMBER( vdt911_device::cru_w )
+void vdt911_device::cru_w(offs_t offset, uint8_t data)
 {
 	offset &= 0xf;
 

src/mame/video/911_vdt.h

@@ -47,8 +47,8 @@ public:
 
 	vdt911_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_READ8_MEMBER(cru_r);
+	uint8_t cru_r(offs_t offset);
-	DECLARE_WRITE8_MEMBER(cru_w);
+	void cru_w(offs_t offset, uint8_t data);
 
 	auto keyint_cb() { return m_keyint_line.bind(); }
 	auto lineint_cb() { return m_lineint_line.bind(); }

src/mame/video/abc1600.cpp

@@ -321,7 +321,7 @@ inline void abc1600_mover_device::write_videoram(offs_t offset, uint16_t data, u
 //  video_ram_r -
 //-------------------------------------------------
 
-READ8_MEMBER( abc1600_mover_device::video_ram_r )
+uint8_t abc1600_mover_device::video_ram_r(offs_t offset)
 {
 	offs_t addr = (offset & VIDEORAM8_MASK) >> 1;
 	uint8_t data = 0;
@@ -343,7 +343,7 @@ READ8_MEMBER( abc1600_mover_device::video_ram_r )
 //  video_ram_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::video_ram_w )
+void abc1600_mover_device::video_ram_w(offs_t offset, uint8_t data)
 {
 	offs_t addr = (offset & VIDEORAM8_MASK) >> 1;
 
@@ -392,7 +392,7 @@ WRITE8_MEMBER( abc1600_mover_device::video_ram_w )
 //  iord0_r -
 //-------------------------------------------------
 
-READ8_MEMBER( abc1600_mover_device::iord0_r )
+uint8_t abc1600_mover_device::iord0_r()
 {
 	/*
 
@@ -425,7 +425,7 @@ READ8_MEMBER( abc1600_mover_device::iord0_r )
 //  ldsx_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldsx_hb_w )
+void abc1600_mover_device::ldsx_hb_w(uint8_t data)
 {
 	/*
 
@@ -454,7 +454,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldsx_hb_w )
 //  ldsx_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldsx_lb_w )
+void abc1600_mover_device::ldsx_lb_w(uint8_t data)
 {
 	/*
 
@@ -481,7 +481,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldsx_lb_w )
 //  ldsy_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldsy_hb_w )
+void abc1600_mover_device::ldsy_hb_w(uint8_t data)
 {
 	/*
 
@@ -508,7 +508,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldsy_hb_w )
 //  ldsy_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldsy_lb_w )
+void abc1600_mover_device::ldsy_lb_w(uint8_t data)
 {
 	/*
 
@@ -535,7 +535,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldsy_lb_w )
 //  ldtx_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldtx_hb_w )
+void abc1600_mover_device::ldtx_hb_w(uint8_t data)
 {
 	/*
 
@@ -563,7 +563,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldtx_hb_w )
 //  ldtx_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldtx_lb_w )
+void abc1600_mover_device::ldtx_lb_w(uint8_t data)
 {
 	/*
 
@@ -591,7 +591,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldtx_lb_w )
 //  ldty_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldty_hb_w )
+void abc1600_mover_device::ldty_hb_w(uint8_t data)
 {
 	/*
 
@@ -622,7 +622,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldty_hb_w )
 //  ldty_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldty_lb_w )
+void abc1600_mover_device::ldty_lb_w(uint8_t data)
 {
 	/*
 
@@ -653,7 +653,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldty_lb_w )
 //  ldfx_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldfx_hb_w )
+void abc1600_mover_device::ldfx_hb_w(uint8_t data)
 {
 	/*
 
@@ -681,7 +681,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldfx_hb_w )
 //  ldfx_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldfx_lb_w )
+void abc1600_mover_device::ldfx_lb_w(uint8_t data)
 {
 	/*
 
@@ -709,7 +709,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldfx_lb_w )
 //  ldfy_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldfy_hb_w )
+void abc1600_mover_device::ldfy_hb_w(uint8_t data)
 {
 	/*
 
@@ -736,7 +736,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldfy_hb_w )
 //  ldfy_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::ldfy_lb_w )
+void abc1600_mover_device::ldfy_lb_w(uint8_t data)
 {
 	/*
 
@@ -765,7 +765,7 @@ WRITE8_MEMBER( abc1600_mover_device::ldfy_lb_w )
 //  wrml_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::wrml_w )
+void abc1600_mover_device::wrml_w(offs_t offset, uint8_t data)
 {
 	/*
 
@@ -795,7 +795,7 @@ WRITE8_MEMBER( abc1600_mover_device::wrml_w )
 //  wrdl_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::wrdl_w )
+void abc1600_mover_device::wrdl_w(offs_t offset, uint8_t data)
 {
 	/*
 
@@ -825,7 +825,7 @@ WRITE8_MEMBER( abc1600_mover_device::wrdl_w )
 //  wrmask_strobe_hb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::wrmask_strobe_hb_w )
+void abc1600_mover_device::wrmask_strobe_hb_w(uint8_t data)
 {
 	if (REPLACE)
 	{
@@ -846,7 +846,7 @@ WRITE8_MEMBER( abc1600_mover_device::wrmask_strobe_hb_w )
 //  wrmask_strobe_lb_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::wrmask_strobe_lb_w )
+void abc1600_mover_device::wrmask_strobe_lb_w(uint8_t data)
 {
 	if (REPLACE)
 	{
@@ -867,7 +867,7 @@ WRITE8_MEMBER( abc1600_mover_device::wrmask_strobe_lb_w )
 //  enable_clocks_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::enable_clocks_w )
+void abc1600_mover_device::enable_clocks_w(uint8_t data)
 {
 	LOG("ENABLE CLOCKS\n");
 	m_clocks_disabled = 0;
@@ -878,7 +878,7 @@ WRITE8_MEMBER( abc1600_mover_device::enable_clocks_w )
 //  flag_strobe_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::flag_strobe_w )
+void abc1600_mover_device::flag_strobe_w(uint8_t data)
 {
 	/*
 
@@ -904,7 +904,7 @@ WRITE8_MEMBER( abc1600_mover_device::flag_strobe_w )
 //  endisp_w -
 //-------------------------------------------------
 
-WRITE8_MEMBER( abc1600_mover_device::endisp_w )
+void abc1600_mover_device::endisp_w(uint8_t data)
 {
 	m_endisp = 1;
 	LOG("ENDISP\n");

src/mame/video/abc1600.h

@@ -69,29 +69,29 @@ private:
 	inline void load_xy_reg();
 	void mover();
 
-	DECLARE_READ8_MEMBER( video_ram_r );
+	uint8_t video_ram_r(offs_t offset);
-	DECLARE_WRITE8_MEMBER( video_ram_w );
+	void video_ram_w(offs_t offset, uint8_t data);
 
-	DECLARE_READ8_MEMBER( iord0_r );
+	uint8_t iord0_r();
-	DECLARE_WRITE8_MEMBER( ldsx_hb_w );
+	void ldsx_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldsx_lb_w );
+	void ldsx_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldsy_hb_w );
+	void ldsy_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldsy_lb_w );
+	void ldsy_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldtx_hb_w );
+	void ldtx_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldtx_lb_w );
+	void ldtx_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldty_hb_w );
+	void ldty_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldty_lb_w );
+	void ldty_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldfx_hb_w );
+	void ldfx_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldfx_lb_w );
+	void ldfx_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldfy_hb_w );
+	void ldfy_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( ldfy_lb_w );
+	void ldfy_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( wrml_w );
+	void wrml_w(offs_t offset, uint8_t data);
-	DECLARE_WRITE8_MEMBER( wrdl_w );
+	void wrdl_w(offs_t offset, uint8_t data);
-	DECLARE_WRITE8_MEMBER( wrmask_strobe_hb_w );
+	void wrmask_strobe_hb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( wrmask_strobe_lb_w );
+	void wrmask_strobe_lb_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( enable_clocks_w );
+	void enable_clocks_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( flag_strobe_w );
+	void flag_strobe_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( endisp_w );
+	void endisp_w(uint8_t data);
 
 	uint32_t screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
 

src/mame/video/agat7.cpp

@@ -92,7 +92,7 @@ void agat7video_device::device_reset()
 }
 
 
-READ8_MEMBER(agat7video_device::read)
+uint8_t agat7video_device::read(offs_t offset)
 {
 	if(!machine().side_effects_disabled())
 		do_io(offset);
@@ -100,7 +100,7 @@ READ8_MEMBER(agat7video_device::read)
 	return 0;
 }
 
-WRITE8_MEMBER(agat7video_device::write)
+void agat7video_device::write(offs_t offset, uint8_t data)
 {
 	do_io(offset);
 }

src/mame/video/agat7.h

@@ -33,8 +33,8 @@ public:
 
 	agat7video_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_READ8_MEMBER(read);
+	uint8_t read(offs_t offset);
-	DECLARE_WRITE8_MEMBER(write);
+	void write(offs_t offset, uint8_t data);
 
 protected:
 	virtual void device_start() override;

src/mame/video/agat9.cpp

@@ -147,7 +147,7 @@ void agat9video_device::device_reset()
 }
 
 
-READ8_MEMBER(agat9video_device::read)
+uint8_t agat9video_device::read(offs_t offset)
 {
 	if(!machine().side_effects_disabled())
 		do_io(offset);
@@ -155,12 +155,12 @@ READ8_MEMBER(agat9video_device::read)
 	return m_mode;
 }
 
-WRITE8_MEMBER(agat9video_device::write)
+void agat9video_device::write(offs_t offset, uint8_t data)
 {
 	do_io(offset);
 }
 
-READ8_MEMBER(agat9video_device::apple_read)
+uint8_t agat9video_device::apple_read(offs_t offset)
 {
 	logerror("%s: %04x read (%s)\n", machine().describe_context(), 0xc050 + offset, offset<8?"apple":"palette");
 
@@ -170,7 +170,7 @@ READ8_MEMBER(agat9video_device::apple_read)
 	return m_mode;
 }
 
-WRITE8_MEMBER(agat9video_device::apple_write)
+void agat9video_device::apple_write(offs_t offset, uint8_t data)
 {
 	logerror("%s: %04x write (%s)\n", machine().describe_context(), 0xc050 + offset, offset<8?"apple":"palette");
 

src/mame/video/agat9.h

@@ -33,10 +33,10 @@ public:
 
 	agat9video_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_READ8_MEMBER(read);
+	uint8_t read(offs_t offset);
-	DECLARE_WRITE8_MEMBER(write);
+	void write(offs_t offset, uint8_t data);
-	DECLARE_READ8_MEMBER(apple_read);
+	uint8_t apple_read(offs_t offset);
-	DECLARE_WRITE8_MEMBER(apple_write);
+	void apple_write(offs_t offset, uint8_t data);
 
 	bool m_page2;
 	bool m_flash;

src/mame/video/airraid_dev.cpp

@@ -239,13 +239,13 @@ uint32_t airraid_video_device::screen_update_airraid(screen_device &screen, bitm
 
 // public functions
 
-WRITE8_MEMBER(airraid_video_device::txram_w)
+void airraid_video_device::txram_w(offs_t offset, uint8_t data)
 {
 	m_txram[offset] = data;
 	m_tx_tilemap->mark_tile_dirty(offset/2);
 }
 
-WRITE8_MEMBER(airraid_video_device::vregs_w)
+void airraid_video_device::vregs_w(offs_t offset, uint8_t data)
 {
 	m_vregs[offset] = data;
 

src/mame/video/airraid_dev.h

@@ -20,8 +20,8 @@ public:
 	// construction/destruction
 	airraid_video_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_WRITE8_MEMBER(txram_w);
+	void txram_w(offs_t offset, uint8_t data);
-	DECLARE_WRITE8_MEMBER(vregs_w);
+	void vregs_w(offs_t offset, uint8_t data);
 	void layer_enable_w(uint8_t enable);
 
 protected:

src/mame/video/antic.cpp

@@ -1131,7 +1131,7 @@ void antic_device::cclk_init()
  * Read ANTIC hardware registers
  *
  **************************************************************/
-READ8_MEMBER ( antic_device::read )
+uint8_t antic_device::read(offs_t offset)
 {
 	uint8_t data = 0xff;
 
@@ -1197,7 +1197,7 @@ READ8_MEMBER ( antic_device::read )
  *
  **************************************************************/
 
-WRITE8_MEMBER ( antic_device::write )
+void antic_device::write(offs_t offset, uint8_t data)
 {
 	int temp;
 

src/mame/video/antic.h

@@ -52,8 +52,8 @@ public:
 
 	template <typename T> void set_gtia_tag(T &&tag) { m_gtia.set_tag(std::forward<T>(tag)); }
 
-	DECLARE_READ8_MEMBER( read );
+	uint8_t read(offs_t offset);
-	DECLARE_WRITE8_MEMBER( write );
+	void write(offs_t offset, uint8_t data);
 
 	uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
 	void generic_interrupt(int button_count);

src/mame/video/bfm_adr2.cpp

@@ -281,14 +281,14 @@ WRITE_LINE_MEMBER(bfm_adder2_device::adder2_vbl_w)
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_adder2_device::screen_ram_r )
+uint8_t bfm_adder2_device::screen_ram_r(offs_t offset)
 {
 	return m_screen_page_reg & SL_ACCESS ? m_screen_ram[1][offset]:m_screen_ram[0][offset];
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::screen_ram_w )
+void bfm_adder2_device::screen_ram_w(offs_t offset, uint8_t data)
 {
 	int dirty_off = (offset>>7)*50 + ((offset & 0x7F)>>1);
 
@@ -320,28 +320,28 @@ WRITE8_MEMBER( bfm_adder2_device::screen_ram_w )
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_adder2_device::normal_ram_r )
+uint8_t bfm_adder2_device::normal_ram_r(offs_t offset)
 {
 	return m_adder_ram[offset];
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::normal_ram_w )
+void bfm_adder2_device::normal_ram_w(offs_t offset, uint8_t data)
 {
 	m_adder_ram[offset] = data;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::adder2_rom_page_w )
+void bfm_adder2_device::adder2_rom_page_w(uint8_t data)
 {
 	membank("bank2")->set_entry(data&0x03);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::adder2_c001_w )
+void bfm_adder2_device::adder2_c001_w(uint8_t data)
 {
 	logerror("c101 = %02X\n",data);
 
@@ -350,14 +350,14 @@ WRITE8_MEMBER( bfm_adder2_device::adder2_c001_w )
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::adder2_screen_page_w )
+void bfm_adder2_device::adder2_screen_page_w(uint8_t data)
 {
 	m_screen_page_reg = data;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_adder2_device::adder2_vbl_ctrl_r )
+uint8_t bfm_adder2_device::adder2_vbl_ctrl_r()
 {
 	m_vbl_triggered = false;    // clear VBL start IRQ
 
@@ -366,14 +366,14 @@ READ8_MEMBER( bfm_adder2_device::adder2_vbl_ctrl_r )
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::adder2_vbl_ctrl_w )
+void bfm_adder2_device::adder2_vbl_ctrl_w(uint8_t data)
 {
 	m_c101 = data;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_adder2_device::adder2_uart_ctrl_r )
+uint8_t bfm_adder2_device::adder2_uart_ctrl_r()
 {
 	int status = 0;
 
@@ -385,7 +385,7 @@ READ8_MEMBER( bfm_adder2_device::adder2_uart_ctrl_r )
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::adder2_uart_ctrl_w )
+void bfm_adder2_device::adder2_uart_ctrl_w(uint8_t data)
 {
 	m_data_from_sc2 = false;    // data available for adder from sc2
 	m_sc2data       = 0;        // data
@@ -397,7 +397,7 @@ WRITE8_MEMBER( bfm_adder2_device::adder2_uart_ctrl_w )
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_adder2_device::adder2_uart_rx_r )
+uint8_t bfm_adder2_device::adder2_uart_rx_r()
 {
 	int data = m_sc2data;
 	m_data_from_sc2 = false;    // clr flag, data from scorpion2 board available
@@ -409,7 +409,7 @@ READ8_MEMBER( bfm_adder2_device::adder2_uart_rx_r )
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_adder2_device::adder2_uart_tx_w )
+void bfm_adder2_device::adder2_uart_tx_w(uint8_t data)
 {
 	m_data_to_sc2 = true;       // set flag, data from adder available
 	m_adder2_data = data;       // store data
@@ -419,7 +419,7 @@ WRITE8_MEMBER( bfm_adder2_device::adder2_uart_tx_w )
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_adder2_device::adder2_irq_r )
+uint8_t bfm_adder2_device::adder2_irq_r()
 {
 	int status = 0;
 
@@ -432,7 +432,7 @@ READ8_MEMBER( bfm_adder2_device::adder2_irq_r )
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER(bfm_adder2_device::vid_uart_tx_w)
+void bfm_adder2_device::vid_uart_tx_w(uint8_t data)
 {
 	m_data_from_sc2  = true;    // set flag, data from scorpion2 board available
 	m_sc2data        = data;    // store data
@@ -446,13 +446,13 @@ WRITE8_MEMBER(bfm_adder2_device::vid_uart_tx_w)
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER(bfm_adder2_device::vid_uart_ctrl_w)
+void bfm_adder2_device::vid_uart_ctrl_w(uint8_t data)
 {
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER(bfm_adder2_device::vid_uart_rx_r)
+uint8_t bfm_adder2_device::vid_uart_rx_r()
 {
 	uint8_t data = m_adder2_data;
 	m_data_to_sc2 = false;   // clr flag, data from adder available
@@ -464,7 +464,7 @@ READ8_MEMBER(bfm_adder2_device::vid_uart_rx_r)
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER(bfm_adder2_device::vid_uart_ctrl_r)
+uint8_t bfm_adder2_device::vid_uart_ctrl_r()
 {
 	int status = 0;
 

src/mame/video/bfm_adr2.h

@@ -17,25 +17,25 @@ public:
 	TILE_GET_INFO_MEMBER( get_tile0_info );
 	TILE_GET_INFO_MEMBER( get_tile1_info );
 
-	DECLARE_READ8_MEMBER( screen_ram_r );
+	uint8_t screen_ram_r(offs_t offset);
-	DECLARE_WRITE8_MEMBER( screen_ram_w );
+	void screen_ram_w(offs_t offset, uint8_t data);
-	DECLARE_READ8_MEMBER( normal_ram_r );
+	uint8_t normal_ram_r(offs_t offset);
-	DECLARE_WRITE8_MEMBER( normal_ram_w );
+	void normal_ram_w(offs_t offset, uint8_t data);
-	DECLARE_WRITE8_MEMBER( adder2_rom_page_w );
+	void adder2_rom_page_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( adder2_c001_w );
+	void adder2_c001_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER( adder2_screen_page_w );
+	void adder2_screen_page_w(uint8_t data);
-	DECLARE_READ8_MEMBER( adder2_vbl_ctrl_r );
+	uint8_t adder2_vbl_ctrl_r();
-	DECLARE_WRITE8_MEMBER( adder2_vbl_ctrl_w );
+	void adder2_vbl_ctrl_w(uint8_t data);
-	DECLARE_READ8_MEMBER( adder2_uart_ctrl_r );
+	uint8_t adder2_uart_ctrl_r();
-	DECLARE_WRITE8_MEMBER( adder2_uart_ctrl_w );
+	void adder2_uart_ctrl_w(uint8_t data);
-	DECLARE_READ8_MEMBER( adder2_uart_rx_r );
+	uint8_t adder2_uart_rx_r();
-	DECLARE_WRITE8_MEMBER( adder2_uart_tx_w );
+	void adder2_uart_tx_w(uint8_t data);
-	DECLARE_READ8_MEMBER( adder2_irq_r );
+	uint8_t adder2_irq_r();
 
-	DECLARE_WRITE8_MEMBER(vid_uart_tx_w);
+	void vid_uart_tx_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER(vid_uart_ctrl_w);
+	void vid_uart_ctrl_w(uint8_t data);
-	DECLARE_READ8_MEMBER(vid_uart_rx_r);
+	uint8_t vid_uart_rx_r();
-	DECLARE_READ8_MEMBER(vid_uart_ctrl_r);
+	uint8_t vid_uart_ctrl_r();
 
 	void adder2_decode_char_roms();
 

src/mame/video/bfm_dm01.cpp

@@ -134,14 +134,14 @@ int bfm_dm01_device::read_data(void)
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_dm01_device::control_r )
+uint8_t bfm_dm01_device::control_r()
 {
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_dm01_device::control_w )
+void bfm_dm01_device::control_w(uint8_t data)
 {
 	int changed = m_control ^ data;
 
@@ -168,14 +168,14 @@ WRITE8_MEMBER( bfm_dm01_device::control_w )
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_dm01_device::mux_r )
+uint8_t bfm_dm01_device::mux_r()
 {
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_dm01_device::mux_w )
+void bfm_dm01_device::mux_w(uint8_t data)
 {
 	g_profiler.start(PROFILER_USER2);
 
@@ -224,7 +224,7 @@ WRITE8_MEMBER( bfm_dm01_device::mux_w )
 
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_dm01_device::comm_r )
+uint8_t bfm_dm01_device::comm_r()
 {
 	int result = 0;
 
@@ -245,19 +245,19 @@ READ8_MEMBER( bfm_dm01_device::comm_r )
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_dm01_device::comm_w )
+void bfm_dm01_device::comm_w(uint8_t data)
 {
 }
 ///////////////////////////////////////////////////////////////////////////
 
-READ8_MEMBER( bfm_dm01_device::unknown_r )
+uint8_t bfm_dm01_device::unknown_r()
 {
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-WRITE8_MEMBER( bfm_dm01_device::unknown_w )
+void bfm_dm01_device::unknown_w(uint8_t data)
 {
 	m_matrixcpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE ); //?
 }

src/mame/video/bfm_dm01.h

@@ -21,14 +21,14 @@ public:
 
 	auto busy_callback() { return m_busy_cb.bind(); }
 
-	DECLARE_READ8_MEMBER( control_r );
+	uint8_t control_r();
-	DECLARE_WRITE8_MEMBER( control_w );
+	void control_w(uint8_t data);
-	DECLARE_READ8_MEMBER( mux_r );
+	uint8_t mux_r();
-	DECLARE_WRITE8_MEMBER( mux_w );
+	void mux_w(uint8_t data);
-	DECLARE_READ8_MEMBER( comm_r );
+	uint8_t comm_r();
-	DECLARE_WRITE8_MEMBER( comm_w );
+	void comm_w(uint8_t data);
-	DECLARE_READ8_MEMBER( unknown_r );
+	uint8_t unknown_r();
-	DECLARE_WRITE8_MEMBER( unknown_w );
+	void unknown_w(uint8_t data);
 
 	void writedata(uint8_t data);
 	int busy(void);

src/mame/video/decodmd1.cpp

@@ -13,23 +13,23 @@
 
 DEFINE_DEVICE_TYPE(DECODMD1, decodmd_type1_device, "decodmd1", "Data East Pinball Dot Matrix Display Type 1")
 
-READ8_MEMBER( decodmd_type1_device::latch_r )
+uint8_t decodmd_type1_device::latch_r()
 {
 	return 0;
 }
 
-WRITE8_MEMBER( decodmd_type1_device::data_w )
+void decodmd_type1_device::data_w(uint8_t data)
 {
 	m_latch = data;
 }
 
-READ8_MEMBER( decodmd_type1_device::busy_r )
+uint8_t decodmd_type1_device::busy_r()
 {
 	return m_status;
 }
 
 
-WRITE8_MEMBER( decodmd_type1_device::ctrl_w )
+void decodmd_type1_device::ctrl_w(uint8_t data)
 {
 	if((data | m_ctrl) & 0x01)
 	{
@@ -49,19 +49,19 @@ WRITE8_MEMBER( decodmd_type1_device::ctrl_w )
 	m_ctrl = data;
 }
 
-READ8_MEMBER( decodmd_type1_device::ctrl_r )
+uint8_t decodmd_type1_device::ctrl_r()
 {
 	return m_ctrl;
 }
 
-READ8_MEMBER( decodmd_type1_device::status_r )
+uint8_t decodmd_type1_device::status_r()
 {
 	return (m_busy & 0x01) | (m_status << 1);
 }
 
 // Z80 I/O ports not fully decoded.
 // if bit 7 = 0, then when bit 2 is 0 selects COCLK, and when bit 2 is 1 selects CLATCH
-READ8_MEMBER( decodmd_type1_device::dmd_port_r )
+uint8_t decodmd_type1_device::dmd_port_r(offs_t offset)
 {
 	if((offset & 0x84) == 0x80)
 	{
@@ -74,7 +74,7 @@ READ8_MEMBER( decodmd_type1_device::dmd_port_r )
 	return 0xff;
 }
 
-WRITE8_MEMBER( decodmd_type1_device::dmd_port_w )
+void decodmd_type1_device::dmd_port_w(offs_t offset, uint8_t data)
 {
 	uint8_t bit;
 

src/mame/video/decodmd1.h

@@ -27,14 +27,14 @@ public:
 
 	decodmd_type1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_READ8_MEMBER(latch_r);
+	uint8_t latch_r();
-	DECLARE_WRITE8_MEMBER(data_w);
+	void data_w(uint8_t data);
-	DECLARE_READ8_MEMBER(busy_r);
+	uint8_t busy_r();
-	DECLARE_WRITE8_MEMBER(ctrl_w);
+	void ctrl_w(uint8_t data);
-	DECLARE_READ8_MEMBER(ctrl_r);
+	uint8_t ctrl_r();
-	DECLARE_READ8_MEMBER(status_r);
+	uint8_t status_r();
-	DECLARE_READ8_MEMBER(dmd_port_r);
+	uint8_t dmd_port_r(offs_t offset);
-	DECLARE_WRITE8_MEMBER(dmd_port_w);
+	void dmd_port_w(offs_t offset, uint8_t data);
 
 	DECLARE_WRITE_LINE_MEMBER(blank_w);
 	DECLARE_WRITE_LINE_MEMBER(status_w);

src/mame/video/decodmd2.cpp

@@ -14,29 +14,29 @@
 
 DEFINE_DEVICE_TYPE(DECODMD2, decodmd_type2_device, "decodmd2", "Data East Pinball Dot Matrix Display Type 2")
 
-WRITE8_MEMBER( decodmd_type2_device::bank_w )
+void decodmd_type2_device::bank_w(uint8_t data)
 {
 	m_rombank1->set_entry(data & 0x1f);
 }
 
-WRITE8_MEMBER( decodmd_type2_device::crtc_address_w )
+void decodmd_type2_device::crtc_address_w(uint8_t data)
 {
 	m_mc6845->address_w(data);
 	m_crtc_index = data;
 }
 
-READ8_MEMBER( decodmd_type2_device::crtc_status_r )
+uint8_t decodmd_type2_device::crtc_status_r()
 {
 	return m_mc6845->register_r();
 }
 
-WRITE8_MEMBER( decodmd_type2_device::crtc_register_w )
+void decodmd_type2_device::crtc_register_w(uint8_t data)
 {
 	m_mc6845->register_w(data);
 	m_crtc_reg[m_crtc_index] = data;
 }
 
-READ8_MEMBER( decodmd_type2_device::latch_r )
+uint8_t decodmd_type2_device::latch_r()
 {
 	// clear IRQ?
 	m_cpu->set_input_line(M6809_IRQ_LINE,CLEAR_LINE);
@@ -44,13 +44,13 @@ READ8_MEMBER( decodmd_type2_device::latch_r )
 	return m_command;
 }
 
-WRITE8_MEMBER( decodmd_type2_device::data_w )
+void decodmd_type2_device::data_w(uint8_t data)
 {
 	// set IRQ?
 	m_latch = data;
 }
 
-READ8_MEMBER( decodmd_type2_device::busy_r )
+uint8_t decodmd_type2_device::busy_r()
 {
 	uint8_t ret = 0x00;
 
@@ -63,7 +63,7 @@ READ8_MEMBER( decodmd_type2_device::busy_r )
 }
 
 
-WRITE8_MEMBER( decodmd_type2_device::ctrl_w )
+void decodmd_type2_device::ctrl_w(uint8_t data)
 {
 	if(!(m_ctrl & 0x01) && (data & 0x01))
 	{
@@ -80,17 +80,17 @@ WRITE8_MEMBER( decodmd_type2_device::ctrl_w )
 	m_ctrl = data;
 }
 
-READ8_MEMBER( decodmd_type2_device::ctrl_r )
+uint8_t decodmd_type2_device::ctrl_r()
 {
 	return m_ctrl;
 }
 
-READ8_MEMBER( decodmd_type2_device::status_r )
+uint8_t decodmd_type2_device::status_r()
 {
 	return m_status;
 }
 
-WRITE8_MEMBER( decodmd_type2_device::status_w )
+void decodmd_type2_device::status_w(uint8_t data)
 {
 	m_status = data & 0x0f;
 }

src/mame/video/decodmd2.h

@@ -27,17 +27,17 @@ public:
 
 	decodmd_type2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	DECLARE_WRITE8_MEMBER(bank_w);
+	void bank_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER(crtc_address_w);
+	void crtc_address_w(uint8_t data);
-	DECLARE_WRITE8_MEMBER(crtc_register_w);
+	void crtc_register_w(uint8_t data);
-	DECLARE_READ8_MEMBER(crtc_status_r);
+	uint8_t crtc_status_r();
-	DECLARE_READ8_MEMBER(latch_r);
+	uint8_t latch_r();
-	DECLARE_WRITE8_MEMBER(data_w);
+	void data_w(uint8_t data);
-	DECLARE_READ8_MEMBER(busy_r);
+	uint8_t busy_r();
-	DECLARE_WRITE8_MEMBER(ctrl_w);
+	void ctrl_w(uint8_t data);
-	DECLARE_READ8_MEMBER(ctrl_r);
+	uint8_t ctrl_r();
-	DECLARE_READ8_MEMBER(status_r);
+	uint8_t status_r();
-	DECLARE_WRITE8_MEMBER(status_w);
+	void status_w(uint8_t data);
 
 	template <typename T> void set_gfxregion(T &&tag) { m_rom.set_tag(std::forward<T>(tag)); }
 

src/mame/video/dynax_blitter_rev2.cpp

@@ -272,7 +272,7 @@ void dynax_blitter_rev2_device::scroll_w(u8 data)
 //  pen_w - set the destination pen
 //-------------------------------------------------
 
-WRITE8_MEMBER(dynax_blitter_rev2_device::pen_w)
+void dynax_blitter_rev2_device::pen_w(uint8_t data)
 {
 	m_blit_pen = data;
 	LOG("%s: P=%02X\n", machine().describe_context(), data);
@@ -283,7 +283,7 @@ WRITE8_MEMBER(dynax_blitter_rev2_device::pen_w)
 //  regs_w - handle blitter register writes
 //-------------------------------------------------
 
-WRITE8_MEMBER(dynax_blitter_rev2_device::regs_w)
+void dynax_blitter_rev2_device::regs_w(offs_t offset, uint8_t data)
 {
 	switch (offset)
 	{
@@ -350,7 +350,7 @@ void cdracula_blitter_device::device_resolve_objects()
 //  bootleg blitter
 //-------------------------------------------------
 
-WRITE8_MEMBER(cdracula_blitter_device::flags_w)
+void cdracula_blitter_device::flags_w(uint8_t data)
 {
 	LOG("%s: FLG=%02X\n", machine().describe_context(), data);
 
@@ -367,7 +367,7 @@ WRITE8_MEMBER(cdracula_blitter_device::flags_w)
 //  (slightly different for bootleg)
 //-------------------------------------------------
 
-WRITE8_MEMBER(cdracula_blitter_device::regs_w)
+void cdracula_blitter_device::regs_w(offs_t offset, uint8_t data)
 {
 	// first register does not trigger a blit, it sets the destination
 	switch (offset)

src/mame/video/dynax_blitter_rev2.h

@@ -30,8 +30,8 @@ public:
 	auto ready_cb() { return m_ready_cb.bind(); }
 
 	// write handlers
-	DECLARE_WRITE8_MEMBER(pen_w);
+	void pen_w(uint8_t data);
-	virtual DECLARE_WRITE8_MEMBER(regs_w);
+	virtual void regs_w(offs_t offset, uint8_t data);
 
 	// getter
 	u8 blit_pen() const { return m_blit_pen; }
@@ -79,8 +79,8 @@ public:
 	auto blit_dest_cb() { return m_blit_dest_cb.bind(); }
 
 	// write handlers
-	DECLARE_WRITE8_MEMBER(flags_w);
+	void flags_w(uint8_t data);
-	virtual DECLARE_WRITE8_MEMBER(regs_w) override;
+	virtual void regs_w(offs_t offset, uint8_t data) override;
 
 private:
 	// device-level overrides