Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-01 08:18:59 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

- made MCFG_DEVICE_VBLANK_INT_DEVICE param order more logic (nw)

Browse Source 
- updated device_execute_interface::interface_post_reset so screen is searched
  from same context
- removed tilelgcy.h since no more users exist
- made bfm_adr2 a device
This commit is contained in:
Miodrag Milanovic 2013-07-25 12:42:53 +00:00
parent 8a514c6435
commit a8899a4685
8 changed files with 250 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -1787,7 +1787,6 @@ src/emu/speaker.c svneol=native#text/plain
src/emu/speaker.h svneol=native#text/plain src/emu/speaker.h svneol=native#text/plain
src/emu/sprite.c svneol=native#text/plain src/emu/sprite.c svneol=native#text/plain
src/emu/sprite.h svneol=native#text/plain src/emu/sprite.h svneol=native#text/plain
src/emu/tilelgcy.h svneol=native#text/plain
src/emu/tilemap.c svneol=native#text/plain src/emu/tilemap.c svneol=native#text/plain
src/emu/tilemap.h svneol=native#text/plain src/emu/tilemap.h svneol=native#text/plain
src/emu/timer.c svneol=native#text/plain src/emu/timer.c svneol=native#text/plain

7
src/emu/diexec.c
View File

@ -610,9 +610,10 @@ void device_execute_interface::interface_post_reset()
// new style - use screen tag directly // new style - use screen tag directly
screen_device *screen; screen_device *screen;
if (m_vblank_interrupt_screen != NULL) if (m_vblank_interrupt_screen != NULL) {
screen = downcast<screen_device *>(device().machine().device(m_vblank_interrupt_screen)); astring tempstring;
screen = downcast<screen_device *>(device().machine().device(device().siblingtag(tempstring,m_vblank_interrupt_screen)));
}
// old style 'hack' setup - use screen #0 // old style 'hack' setup - use screen #0
else else
screen = device().machine().first_screen(); screen = device().machine().first_screen();

2
src/emu/diexec.h
View File

@ -120,7 +120,7 @@ enum
device_execute_interface::static_set_vblank_int(*device, _func, _tag); device_execute_interface::static_set_vblank_int(*device, _func, _tag);
#define MCFG_DEVICE_VBLANK_INT_DRIVER(_tag, _class, _func) \ #define MCFG_DEVICE_VBLANK_INT_DRIVER(_tag, _class, _func) \
device_execute_interface::static_set_vblank_int(*device, device_interrupt_delegate(&_class::_func, #_class "::" #_func, DEVICE_SELF, (_class *)0), _tag); device_execute_interface::static_set_vblank_int(*device, device_interrupt_delegate(&_class::_func, #_class "::" #_func, DEVICE_SELF, (_class *)0), _tag);
#define MCFG_DEVICE_VBLANK_INT_DEVICE(_devtag, _tag, _class, _func) \ #define MCFG_DEVICE_VBLANK_INT_DEVICE(_tag, _devtag, _class, _func) \
device_execute_interface::static_set_vblank_int(*device, device_interrupt_delegate(&_class::_func, #_class "::" #_func, _devtag, (_class *)0), _tag); device_execute_interface::static_set_vblank_int(*device, device_interrupt_delegate(&_class::_func, #_class "::" #_func, _devtag, (_class *)0), _tag);
#define MCFG_DEVICE_PERIODIC_INT(_func, _rate) \ #define MCFG_DEVICE_PERIODIC_INT(_func, _rate) \
device_execute_interface::static_set_periodic_int(*device, _func, attotime::from_hz(_rate)); device_execute_interface::static_set_periodic_int(*device, _func, attotime::from_hz(_rate));

81
src/emu/tilelgcy.h
View File

@ -1,81 +0,0 @@
/***************************************************************************
tilelgcy.h
Legacy tilemap helpers.
****************************************************************************
Copyright Aaron Giles
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name 'MAME' nor the names of its contributors may be
used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
***************************************************************************/
#pragma once
#ifndef __TILELGCY_H__
#define __TILELGCY_H__
//**************************************************************************
// MACROS
//**************************************************************************
#define TILE_GET_INFO(_name) void _name(driver_device &device, tilemap_t &tilemap, tile_data &tileinfo, tilemap_memory_index tile_index)
#define TILEMAP_MAPPER(_name) tilemap_memory_index _name(driver_device &device, UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows)
#define SET_TILE_INFO(GFX,CODE,COLOR,FLAGS) tileinfo.set(device.machine(), GFX, CODE, COLOR, FLAGS)
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
// legacy callbacks
typedef void (*tile_get_info_func)(driver_device &device, tilemap_t &tilemap, tile_data &tileinfo, tilemap_memory_index tile_index);
typedef tilemap_memory_index (*tilemap_mapper_func)(driver_device &device, UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows);
//**************************************************************************
// FUNCTION PROTOTYPES
//**************************************************************************
// ----- tilemap creation and configuration -----
// create a new tilemap; note that tilemaps are tracked by the core so there is no dispose
inline tilemap_t *tilemap_create(running_machine &machine, tile_get_info_func tile_get_info, tilemap_mapper_func mapper, int tilewidth, int tileheight, int cols, int rows)
{ return &machine.tilemap().create(tilemap_get_info_delegate(tile_get_info, "", machine.driver_data()), tilemap_mapper_delegate(mapper, "", machine.driver_data()), tilewidth, tileheight, cols, rows); }
inline tilemap_t *tilemap_create(running_machine &machine, tile_get_info_func tile_get_info, tilemap_standard_mapper mapper, int tilewidth, int tileheight, int cols, int rows)
{ return &machine.tilemap().create(tilemap_get_info_delegate(tile_get_info, "", machine.driver_data()), mapper, tilewidth, tileheight, cols, rows); }
#endif /* __TILELGCY_H__ */

49
src/mame/drivers/bfm_sc1.c
View File

@ -100,8 +100,6 @@ Optional (on expansion card) (Viper)
#include "sound/upd7759.h" #include "sound/upd7759.h"
#include "machine/nvram.h" #include "machine/nvram.h"
#include "machine/bfm_comn.h" #include "machine/bfm_comn.h"
#include "drivlgcy.h"
#include "scrlegcy.h"
#include "sc1_vfd.lh" #include "sc1_vfd.lh"
#include "sc1_vid.lh" #include "sc1_vid.lh"
@ -113,8 +111,7 @@ public:
: driver_device(mconfig, type, tag), : driver_device(mconfig, type, tag),
m_vfd0(*this, "vfd0"), m_vfd0(*this, "vfd0"),
m_maincpu(*this, "maincpu"), m_maincpu(*this, "maincpu"),
m_upd7759(*this, "upd"), m_upd7759(*this, "upd") { }
m_adder2(*this, "adder2") { }
optional_device<bfm_bd1_t> m_vfd0; optional_device<bfm_bd1_t> m_vfd0;
@ -167,10 +164,6 @@ public:
DECLARE_READ8_MEMBER(aciadata_r); DECLARE_READ8_MEMBER(aciadata_r);
DECLARE_WRITE8_MEMBER(triac_w); DECLARE_WRITE8_MEMBER(triac_w);
DECLARE_READ8_MEMBER(triac_r); DECLARE_READ8_MEMBER(triac_r);
DECLARE_WRITE8_MEMBER(vid_uart_tx_w);
DECLARE_WRITE8_MEMBER(vid_uart_ctrl_w);
DECLARE_READ8_MEMBER(vid_uart_rx_r);
DECLARE_READ8_MEMBER(vid_uart_ctrl_r);
DECLARE_READ8_MEMBER(nec_r); DECLARE_READ8_MEMBER(nec_r);
DECLARE_WRITE8_MEMBER(nec_reset_w); DECLARE_WRITE8_MEMBER(nec_reset_w);
DECLARE_WRITE8_MEMBER(nec_latch_w); DECLARE_WRITE8_MEMBER(nec_latch_w);
@ -189,8 +182,7 @@ public:
int Scorpion1_GetSwitchState(int strobe, int data); int Scorpion1_GetSwitchState(int strobe, int data);
int sc1_find_project_string( ); int sc1_find_project_string( );
required_device<cpu_device> m_maincpu; required_device<cpu_device> m_maincpu;
optional_device<upd7759_device> m_upd7759; optional_device<upd7759_device> m_upd7759;
optional_device<cpu_device> m_adder2;
}; };
#define VFD_RESET 0x20 #define VFD_RESET 0x20
@ -619,35 +611,6 @@ WRITE8_MEMBER(bfm_sc1_state::nec_latch_w)
m_upd7759->start_w(1); // start m_upd7759->start_w(1); // start
} }
/////////////////////////////////////////////////////////////////////////////////////
WRITE8_MEMBER(bfm_sc1_state::vid_uart_tx_w)
{
adder2_send(data);
m_adder2->set_input_line(M6809_IRQ_LINE, ASSERT_LINE );//HOLD_LINE);// trigger IRQ
}
///////////////////////////////////////////////////////////////////////////
WRITE8_MEMBER(bfm_sc1_state::vid_uart_ctrl_w)
{
}
///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_sc1_state::vid_uart_rx_r)
{
return adder2_receive();
}
///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_sc1_state::vid_uart_ctrl_r)
{
return adder2_status();
}
// machine start (called only once) ///////////////////////////////////////////////// // machine start (called only once) /////////////////////////////////////////////////
void bfm_sc1_state::machine_reset() void bfm_sc1_state::machine_reset()
@ -742,8 +705,8 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( sc1_adder2, AS_PROGRAM, 8, bfm_sc1_state ) static ADDRESS_MAP_START( sc1_adder2, AS_PROGRAM, 8, bfm_sc1_state )
AM_IMPORT_FROM( sc1_base ) AM_IMPORT_FROM( sc1_base )
AM_RANGE(0x3E00, 0x3E00) AM_READWRITE(vid_uart_ctrl_r,vid_uart_ctrl_w) // video uart control reg read AM_RANGE(0x3E00, 0x3E00) AM_DEVREADWRITE("adder2", bfm_adder2_device, vid_uart_ctrl_r,vid_uart_ctrl_w) // video uart control reg read
AM_RANGE(0x3E01, 0x3E01) AM_READWRITE(vid_uart_rx_r,vid_uart_tx_w) // video uart receive reg AM_RANGE(0x3E01, 0x3E01) AM_DEVREADWRITE("adder2", bfm_adder2_device, vid_uart_rx_r,vid_uart_tx_w) // video uart receive reg
ADDRESS_MAP_END ADDRESS_MAP_END
@ -1130,8 +1093,7 @@ static MACHINE_CONFIG_DERIVED( scorpion1_adder2, scorpion1 )
MCFG_DEFAULT_LAYOUT(layout_sc1_vid) MCFG_DEFAULT_LAYOUT(layout_sc1_vid)
//MCFG_BFM_ADDER2_ADD("adder2") MCFG_BFM_ADDER2_ADD("adder2")
MCFG_FRAGMENT_ADD(adder2)
MACHINE_CONFIG_END MACHINE_CONFIG_END
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
@ -1244,7 +1206,6 @@ int bfm_sc1_state::sc1_find_project_string( )
DRIVER_INIT_MEMBER(bfm_sc1_state,toppoker) DRIVER_INIT_MEMBER(bfm_sc1_state,toppoker)
{ {
sc1_common_init(3,1, 3); sc1_common_init(3,1, 3);
adder2_decode_char_roms(machine()); // decode GFX roms
MechMtr_config(machine(),8); MechMtr_config(machine(),8);
sc1_find_project_string(); sc1_find_project_string();
} }

54
src/mame/drivers/bfm_sc2.c
View File

@ -171,8 +171,6 @@ Adder hardware:
#include "sc2_dmd.lh" #include "sc2_dmd.lh"
#include "drwho.lh" #include "drwho.lh"
#include "machine/bfm_comn.h" #include "machine/bfm_comn.h"
#include "drivlgcy.h"
#include "scrlegcy.h"
class bfm_sc2_state : public driver_device class bfm_sc2_state : public driver_device
@ -183,8 +181,7 @@ public:
m_vfd0(*this, "vfd0"), m_vfd0(*this, "vfd0"),
m_vfd1(*this, "vfd1"), m_vfd1(*this, "vfd1"),
m_maincpu(*this, "maincpu"), m_maincpu(*this, "maincpu"),
m_upd7759(*this, "upd"), m_upd7759(*this, "upd") { }
m_adder2(*this, "adder2") { }
optional_device<bfm_bd1_t> m_vfd0; optional_device<bfm_bd1_t> m_vfd0;
optional_device<bfm_bd1_t> m_vfd1; optional_device<bfm_bd1_t> m_vfd1;
@ -270,10 +267,6 @@ public:
DECLARE_READ8_MEMBER(uart2data_r); DECLARE_READ8_MEMBER(uart2data_r);
DECLARE_WRITE8_MEMBER(uart2ctrl_w); DECLARE_WRITE8_MEMBER(uart2ctrl_w);
DECLARE_WRITE8_MEMBER(uart2data_w); DECLARE_WRITE8_MEMBER(uart2data_w);
DECLARE_WRITE8_MEMBER(vid_uart_tx_w);
DECLARE_WRITE8_MEMBER(vid_uart_ctrl_w);
DECLARE_READ8_MEMBER(vid_uart_rx_r);
DECLARE_READ8_MEMBER(vid_uart_ctrl_r);
DECLARE_READ8_MEMBER(key_r); DECLARE_READ8_MEMBER(key_r);
DECLARE_READ8_MEMBER(vfd_status_r); DECLARE_READ8_MEMBER(vfd_status_r);
DECLARE_WRITE8_MEMBER(vfd1_bd1_w); DECLARE_WRITE8_MEMBER(vfd1_bd1_w);
@ -321,7 +314,6 @@ public:
void sc2awpdmd_common_init(int reels, int decrypt); void sc2awpdmd_common_init(int reels, int decrypt);
required_device<cpu_device> m_maincpu; required_device<cpu_device> m_maincpu;
required_device<upd7759_device> m_upd7759; required_device<upd7759_device> m_upd7759;
optional_device<cpu_device> m_adder2;
}; };
@ -1027,40 +1019,8 @@ WRITE8_MEMBER(bfm_sc2_state::uart2data_w)
UART_LOG(("uart2:%x\n", data)); UART_LOG(("uart2:%x\n", data));
} }
///////////////////////////////////////////////////////////////////////////
WRITE8_MEMBER(bfm_sc2_state::vid_uart_tx_w)
{
adder2_send(data);
m_adder2->set_input_line(M6809_IRQ_LINE, HOLD_LINE );
LOG_SERIAL(("sadder %02X (%c)\n",data, data ));
}
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
WRITE8_MEMBER(bfm_sc2_state::vid_uart_ctrl_w)
{
}
///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_sc2_state::vid_uart_rx_r)
{
int data = adder2_receive();
LOG_SERIAL(("radder: %02X(%c)\n",data, data ));
return data;
}
///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_sc2_state::vid_uart_ctrl_r)
{
return adder2_status();
}
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_sc2_state::key_r) READ8_MEMBER(bfm_sc2_state::key_r)
@ -1490,8 +1450,8 @@ static ADDRESS_MAP_START( memmap_vid, AS_PROGRAM, 8, bfm_sc2_state )
AM_RANGE(0x3C00, 0x3C07) AM_READ(key_r ) AM_RANGE(0x3C00, 0x3C07) AM_READ(key_r )
AM_RANGE(0x3C80, 0x3C80) AM_WRITE(e2ram_w ) AM_RANGE(0x3C80, 0x3C80) AM_WRITE(e2ram_w )
AM_RANGE(0x3E00, 0x3E00) AM_READWRITE(vid_uart_ctrl_r, vid_uart_ctrl_w) // video uart control reg AM_RANGE(0x3E00, 0x3E00) AM_DEVREADWRITE("adder2", bfm_adder2_device, vid_uart_ctrl_r, vid_uart_ctrl_w) // video uart control reg
AM_RANGE(0x3E01, 0x3E01) AM_READWRITE(vid_uart_rx_r, vid_uart_tx_w) // video uart data reg AM_RANGE(0x3E01, 0x3E01) AM_DEVREADWRITE("adder2", bfm_adder2_device, vid_uart_rx_r, vid_uart_tx_w) // video uart data reg
ADDRESS_MAP_END ADDRESS_MAP_END
// input ports for pyramid //////////////////////////////////////// // input ports for pyramid ////////////////////////////////////////
@ -2164,8 +2124,7 @@ static MACHINE_CONFIG_START( scorpion2_vid, bfm_sc2_state )
MCFG_NVRAM_ADD_CUSTOM_DRIVER("e2ram", bfm_sc2_state, e2ram_init) MCFG_NVRAM_ADD_CUSTOM_DRIVER("e2ram", bfm_sc2_state, e2ram_init)
MCFG_DEFAULT_LAYOUT(layout_sc2_vid) MCFG_DEFAULT_LAYOUT(layout_sc2_vid)
//MCFG_BFM_ADDER2_ADD("adder2") MCFG_BFM_ADDER2_ADD("adder2")
MCFG_FRAGMENT_ADD(adder2)
MCFG_SPEAKER_STANDARD_MONO("mono") MCFG_SPEAKER_STANDARD_MONO("mono")
MCFG_SOUND_ADD("upd", UPD7759, UPD7759_STANDARD_CLOCK) MCFG_SOUND_ADD("upd", UPD7759, UPD7759_STANDARD_CLOCK)
@ -2275,7 +2234,6 @@ void bfm_sc2_state::adder2_common_init()
DRIVER_INIT_MEMBER(bfm_sc2_state,quintoon) DRIVER_INIT_MEMBER(bfm_sc2_state,quintoon)
{ {
sc2_common_init( 1); sc2_common_init( 1);
adder2_decode_char_roms(machine());
MechMtr_config(machine(),8); // setup mech meters MechMtr_config(machine(),8); // setup mech meters
m_has_hopper = 0; m_has_hopper = 0;
@ -2296,7 +2254,6 @@ DRIVER_INIT_MEMBER(bfm_sc2_state,quintoon)
DRIVER_INIT_MEMBER(bfm_sc2_state,pyramid) DRIVER_INIT_MEMBER(bfm_sc2_state,pyramid)
{ {
sc2_common_init(1); sc2_common_init(1);
adder2_decode_char_roms(machine()); // decode GFX roms
adder2_common_init(); adder2_common_init();
m_has_hopper = 1; m_has_hopper = 1;
@ -2313,7 +2270,6 @@ DRIVER_INIT_MEMBER(bfm_sc2_state,pyramid)
DRIVER_INIT_MEMBER(bfm_sc2_state,sltsbelg) DRIVER_INIT_MEMBER(bfm_sc2_state,sltsbelg)
{ {
sc2_common_init(1); sc2_common_init(1);
adder2_decode_char_roms(machine()); // decode GFX roms
adder2_common_init(); adder2_common_init();
m_has_hopper = 1; m_has_hopper = 1;
@ -2327,7 +2283,6 @@ DRIVER_INIT_MEMBER(bfm_sc2_state,sltsbelg)
DRIVER_INIT_MEMBER(bfm_sc2_state,adder_dutch) DRIVER_INIT_MEMBER(bfm_sc2_state,adder_dutch)
{ {
sc2_common_init(1); sc2_common_init(1);
adder2_decode_char_roms(machine()); // decode GFX roms
adder2_common_init(); adder2_common_init();
m_has_hopper = 0; m_has_hopper = 0;
@ -2345,7 +2300,6 @@ DRIVER_INIT_MEMBER(bfm_sc2_state,adder_dutch)
DRIVER_INIT_MEMBER(bfm_sc2_state,gldncrwn) DRIVER_INIT_MEMBER(bfm_sc2_state,gldncrwn)
{ {
sc2_common_init(1); sc2_common_init(1);
adder2_decode_char_roms(machine()); // decode GFX roms
adder2_common_init(); adder2_common_init();
m_has_hopper = 0; m_has_hopper = 0;

317
src/mame/video/bfm_adr2.c
View File

@ -95,9 +95,6 @@ E000-FFFF | R | D D D D D D D D | 8K ROM
#include "machine/bfm_bd1.h" // vfd #include "machine/bfm_bd1.h" // vfd
#include "video/bfm_adr2.h" #include "video/bfm_adr2.h"
#include "rendlay.h" #include "rendlay.h"
#include "tilelgcy.h"
#include "drivlgcy.h"
#include "scrlegcy.h"
#ifdef MAME_DEBUG #ifdef MAME_DEBUG
#define VERBOSE 1 #define VERBOSE 1
@ -115,27 +112,19 @@ E000-FFFF | R | D D D D D D D D | 8K ROM
#define ADDER_CLOCK (XTAL_8MHz) #define ADDER_CLOCK (XTAL_8MHz)
static int adder2_screen_page_reg; // access/display select
static int adder2_c101;
static int adder2_rx;
static int adder_vbl_triggered; // flag <>0, VBL IRQ triggered
static int adder2_acia_triggered; // flag <>0, ACIA receive IRQ
static UINT8 adder_ram[0xE80]; // normal RAM const device_type BFM_ADDER2 = &device_creator<bfm_adder2_device>;
static UINT8 adder_screen_ram[2][0x1180]; // paged display RAM
static tilemap_t *tilemap0; // tilemap screen0 bfm_adder2_device::bfm_adder2_device( const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock )
static tilemap_t *tilemap1; // timemap screen1 : device_t(mconfig, BFM_ADDER2, "BFM ADDER2", tag, owner, clock, "bfm_adder2", __FILE__),
m_cpu(*this, "adder2")
{
}
static UINT8 adder2_data_from_sc2;
static UINT8 adder2_data_to_sc2;
static UINT8 adder2_data;
static UINT8 adder2_sc2data;
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static TILE_GET_INFO( get_tile0_info ) TILE_GET_INFO_MEMBER( bfm_adder2_device::get_tile0_info )
{ {
short data; short data;
int code, color, flags,x,y; int code, color, flags,x,y;
@ -145,20 +134,20 @@ static TILE_GET_INFO( get_tile0_info )
tile_index = y * 128 + (x * 2); tile_index = y * 128 + (x * 2);
data = adder_screen_ram[0][tile_index ]<<8; data = m_adder_screen_ram[0][tile_index ]<<8;
data |= adder_screen_ram[0][tile_index + 1]; data |= m_adder_screen_ram[0][tile_index + 1];
code = data & 0x1FFF; code = data & 0x1FFF;
color = 0; color = 0;
flags = ((data & 0x4000)?TILE_FLIPY:0) | flags = ((data & 0x4000)?TILE_FLIPY:0) |
((data & 0x2000)?TILE_FLIPX:0); ((data & 0x2000)?TILE_FLIPX:0);
SET_TILE_INFO(0, code, color, flags); SET_TILE_INFO_MEMBER(0, code, color, flags);
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static TILE_GET_INFO( get_tile1_info ) TILE_GET_INFO_MEMBER( bfm_adder2_device::get_tile1_info )
{ {
short data; short data;
int code, color, flags,x,y; int code, color, flags,x,y;
@ -168,111 +157,109 @@ static TILE_GET_INFO( get_tile1_info )
tile_index = y * 128 + (x * 2); tile_index = y * 128 + (x * 2);
data = adder_screen_ram[1][tile_index ]<<8; data = m_adder_screen_ram[1][tile_index ]<<8;
data |= adder_screen_ram[1][tile_index + 1]; data |= m_adder_screen_ram[1][tile_index + 1];
code = data & 0x1FFF; code = data & 0x1FFF;
color = 0; color = 0;
flags = ((data & 0x4000)?TILE_FLIPY:0) | flags = ((data & 0x4000)?TILE_FLIPY:0) |
((data & 0x2000)?TILE_FLIPX:0); ((data & 0x2000)?TILE_FLIPX:0);
SET_TILE_INFO(0, code, color, flags); SET_TILE_INFO_MEMBER(0, code, color, flags);
} }
// video initialisation /////////////////////////////////////////////////// // video initialisation ///////////////////////////////////////////////////
static VIDEO_RESET( adder2 ) void bfm_adder2_device::device_reset()
{ {
adder2_screen_page_reg = 0; m_adder2_screen_page_reg = 0;
adder2_c101 = 0; m_adder2_c101 = 0;
adder2_rx = 0; m_adder2_rx = 0;
adder_vbl_triggered = 0; m_adder_vbl_triggered = 0;
adder2_acia_triggered = 0; m_adder2_acia_triggered = 0;
adder2_data_from_sc2 = 0; m_adder2_data_from_sc2 = 0;
adder2_data_to_sc2 = 0; m_adder2_data_to_sc2 = 0;
{ {
UINT8 *rom = machine.root_device().memregion("adder2")->base(); UINT8 *rom = machine().root_device().memregion("adder2")->base();
machine.root_device().membank("bank2")->configure_entries(0, 4, &rom[0x00000], 0x08000); membank("bank2")->configure_entries(0, 4, &rom[0x00000], 0x08000);
machine.root_device().membank("bank2")->set_entry(0&0x03); membank("bank2")->set_entry(0&0x03);
} }
} }
static VIDEO_START( adder2 ) void bfm_adder2_device::device_start()
{ {
machine.save().save_item(NAME(adder2_screen_page_reg)); adder2_decode_char_roms();
machine.save().save_item(NAME(adder2_c101));
machine.save().save_item(NAME(adder2_rx)); save_item(NAME(m_adder2_screen_page_reg));
machine.save().save_item(NAME(adder_vbl_triggered)); save_item(NAME(m_adder2_c101));
machine.save().save_item(NAME(adder2_acia_triggered)); save_item(NAME(m_adder2_rx));
save_item(NAME(m_adder_vbl_triggered));
save_item(NAME(m_adder2_acia_triggered));
machine.save().save_item(NAME(adder2_data_from_sc2)); save_item(NAME(m_adder2_data_from_sc2));
machine.save().save_item(NAME(adder2_data_to_sc2)); save_item(NAME(m_adder2_data_to_sc2));
machine.save().save_item(NAME(adder_ram)); save_item(NAME(m_adder_ram));
machine.save().save_item(NAME(adder_screen_ram)); save_item(NAME(m_adder_screen_ram));
tilemap0 = tilemap_create(machine, get_tile0_info, TILEMAP_SCAN_ROWS, 8, 8, 50, 35); m_tilemap0 = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(bfm_adder2_device::get_tile0_info),this), TILEMAP_SCAN_ROWS, 8, 8, 50, 35);
tilemap1 = tilemap_create(machine, get_tile1_info, TILEMAP_SCAN_ROWS, 8, 8, 50, 35); m_tilemap1 = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(bfm_adder2_device::get_tile1_info),this), TILEMAP_SCAN_ROWS, 8, 8, 50, 35);
palette_set_color(machine(), 0,MAKE_RGB(0x00,0x00,0x00));
palette_set_color(machine(), 1,MAKE_RGB(0x00,0x00,0xFF));
palette_set_color(machine(), 2,MAKE_RGB(0x00,0xFF,0x00));
palette_set_color(machine(), 3,MAKE_RGB(0x00,0xFF,0xFF));
palette_set_color(machine(), 4,MAKE_RGB(0xFF,0x00,0x00));
palette_set_color(machine(), 5,MAKE_RGB(0xFF,0x00,0xFF));
palette_set_color(machine(), 6,MAKE_RGB(0xFF,0xFF,0x00));
palette_set_color(machine(), 7,MAKE_RGB(0xFF,0xFF,0xFF));
palette_set_color(machine(), 8,MAKE_RGB(0x80,0x80,0x80));
palette_set_color(machine(), 9,MAKE_RGB(0x00,0x00,0x80));
palette_set_color(machine(),10,MAKE_RGB(0x00,0x80,0x00));
palette_set_color(machine(),11,MAKE_RGB(0x00,0x80,0x80));
palette_set_color(machine(),12,MAKE_RGB(0x80,0x00,0x00));
palette_set_color(machine(),13,MAKE_RGB(0x80,0x00,0x80));
palette_set_color(machine(),14,MAKE_RGB(0x80,0x80,0x00));
palette_set_color(machine(),15,MAKE_RGB(0x80,0x80,0x80));
} }
// video update /////////////////////////////////////////////////////////// // video update ///////////////////////////////////////////////////////////
static SCREEN_UPDATE_IND16( adder2 ) UINT32 bfm_adder2_device::update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
const rectangle visible1(0, 400-1, 0, 280-1); //minx,maxx, miny,maxy const rectangle visible1(0, 400-1, 0, 280-1); //minx,maxx, miny,maxy
if (adder2_screen_page_reg & SL_DISPLAY) tilemap1->draw(bitmap, visible1, 0, 0); if (m_adder2_screen_page_reg & SL_DISPLAY) m_tilemap1->draw(bitmap, visible1, 0, 0);
else tilemap0->draw(bitmap, visible1, 0, 0); else m_tilemap0->draw(bitmap, visible1, 0, 0);
return 0; return 0;
} }
// adder2 palette initialisation //////////////////////////////////////////
static PALETTE_INIT( adder2 )
{
palette_set_color(machine, 0,MAKE_RGB(0x00,0x00,0x00));
palette_set_color(machine, 1,MAKE_RGB(0x00,0x00,0xFF));
palette_set_color(machine, 2,MAKE_RGB(0x00,0xFF,0x00));
palette_set_color(machine, 3,MAKE_RGB(0x00,0xFF,0xFF));
palette_set_color(machine, 4,MAKE_RGB(0xFF,0x00,0x00));
palette_set_color(machine, 5,MAKE_RGB(0xFF,0x00,0xFF));
palette_set_color(machine, 6,MAKE_RGB(0xFF,0xFF,0x00));
palette_set_color(machine, 7,MAKE_RGB(0xFF,0xFF,0xFF));
palette_set_color(machine, 8,MAKE_RGB(0x80,0x80,0x80));
palette_set_color(machine, 9,MAKE_RGB(0x00,0x00,0x80));
palette_set_color(machine,10,MAKE_RGB(0x00,0x80,0x00));
palette_set_color(machine,11,MAKE_RGB(0x00,0x80,0x80));
palette_set_color(machine,12,MAKE_RGB(0x80,0x00,0x00));
palette_set_color(machine,13,MAKE_RGB(0x80,0x00,0x80));
palette_set_color(machine,14,MAKE_RGB(0x80,0x80,0x00));
palette_set_color(machine,15,MAKE_RGB(0x80,0x80,0x80));
}
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static INTERRUPT_GEN( adder2_vbl ) INTERRUPT_GEN_MEMBER( bfm_adder2_device::adder2_vbl )
{ {
if ( adder2_c101 & 0x01 ) if ( m_adder2_c101 & 0x01 )
{ {
adder_vbl_triggered = 1; m_adder_vbl_triggered = 1;
device->execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE ); device.execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE );
} }
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static READ8_HANDLER( screen_ram_r ) READ8_MEMBER( bfm_adder2_device::screen_ram_r )
{ {
return adder2_screen_page_reg & SL_ACCESS ? adder_screen_ram[1][offset]:adder_screen_ram[0][offset]; return m_adder2_screen_page_reg & SL_ACCESS ? m_adder_screen_ram[1][offset]:m_adder_screen_ram[0][offset];
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( screen_ram_w ) WRITE8_MEMBER( bfm_adder2_device::screen_ram_w )
{ {
int dirty_off = (offset>>7)*50 + ((offset & 0x7F)>>1); int dirty_off = (offset>>7)*50 + ((offset & 0x7F)>>1);
@ -289,102 +276,102 @@ static WRITE8_HANDLER( screen_ram_w )
palette_set_color(space.machine(), pal, MAKE_RGB(r,g,b)); palette_set_color(space.machine(), pal, MAKE_RGB(r,g,b));
} }
if ( adder2_screen_page_reg & SL_ACCESS ) if ( m_adder2_screen_page_reg & SL_ACCESS )
{ {
adder_screen_ram[1][offset] = data; m_adder_screen_ram[1][offset] = data;
tilemap1->mark_tile_dirty(dirty_off); m_tilemap1->mark_tile_dirty(dirty_off);
} }
else else
{ {
adder_screen_ram[0][offset] = data; m_adder_screen_ram[0][offset] = data;
tilemap0->mark_tile_dirty(dirty_off); m_tilemap0->mark_tile_dirty(dirty_off);
} }
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static READ8_HANDLER( normal_ram_r ) READ8_MEMBER( bfm_adder2_device::normal_ram_r )
{ {
return adder_ram[offset]; return m_adder_ram[offset];
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( normal_ram_w ) WRITE8_MEMBER( bfm_adder2_device::normal_ram_w )
{ {
adder_ram[offset] = data; m_adder_ram[offset] = data;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( adder2_rom_page_w ) WRITE8_MEMBER( bfm_adder2_device::adder2_rom_page_w )
{ {
space.machine().root_device().membank("bank2")->set_entry(data&0x03); membank("bank2")->set_entry(data&0x03);
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( adder2_c001_w ) WRITE8_MEMBER( bfm_adder2_device::adder2_c001_w )
{ {
logerror("c101 = %02X\n",data); logerror("c101 = %02X\n",data);
//adder2_screen_page_reg = 0; //m_adder2_screen_page_reg = 0;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( adder2_screen_page_w ) WRITE8_MEMBER( bfm_adder2_device::adder2_screen_page_w )
{ {
adder2_screen_page_reg = data; m_adder2_screen_page_reg = data;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static READ8_HANDLER( adder2_vbl_ctrl_r ) READ8_MEMBER( bfm_adder2_device::adder2_vbl_ctrl_r )
{ {
adder_vbl_triggered = 0; // clear VBL start IRQ m_adder_vbl_triggered = 0; // clear VBL start IRQ
return adder2_c101; return m_adder2_c101;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( adder2_vbl_ctrl_w ) WRITE8_MEMBER( bfm_adder2_device::adder2_vbl_ctrl_w )
{ {
adder2_c101 = data; m_adder2_c101 = data;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static READ8_HANDLER( adder2_uart_ctrl_r ) READ8_MEMBER( bfm_adder2_device::adder2_uart_ctrl_r )
{ {
int status = 0; int status = 0;
if ( adder2_data_from_sc2 ) status |= 0x01; // receive buffer full if ( m_adder2_data_from_sc2 ) status |= 0x01; // receive buffer full
if ( !adder2_data_to_sc2 ) status |= 0x02; // transmit buffer empty if ( !m_adder2_data_to_sc2 ) status |= 0x02; // transmit buffer empty
return status; return status;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( adder2_uart_ctrl_w ) WRITE8_MEMBER( bfm_adder2_device::adder2_uart_ctrl_w )
{ {
adder2_data_from_sc2 = 0; // data available for adder from sc2 m_adder2_data_from_sc2 = 0; // data available for adder from sc2
adder2_sc2data = 0; // data m_adder2_sc2data = 0; // data
adder2_data_to_sc2 = 0; // data available for sc2 from adder m_adder2_data_to_sc2 = 0; // data available for sc2 from adder
adder2_data = 0; // data m_adder2_data = 0; // data
LOG_CTRL(("adder2 uart ctrl:%02X\n", data)); LOG_CTRL(("adder2 uart ctrl:%02X\n", data));
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static READ8_HANDLER( adder2_uart_rx_r ) READ8_MEMBER( bfm_adder2_device::adder2_uart_rx_r )
{ {
int data = adder2_sc2data; int data = m_adder2_sc2data;
adder2_data_from_sc2 = 0; // clr flag, data from scorpion2 board available m_adder2_data_from_sc2 = 0; // clr flag, data from scorpion2 board available
LOG_CTRL(("rsc2:%02X (%c)\n",data, data )); LOG_CTRL(("rsc2:%02X (%c)\n",data, data ));
@ -393,69 +380,87 @@ static READ8_HANDLER( adder2_uart_rx_r )
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static WRITE8_HANDLER( adder2_uart_tx_w ) WRITE8_MEMBER( bfm_adder2_device::adder2_uart_tx_w )
{ {
adder2_data_to_sc2 = 1; // set flag, data from adder available m_adder2_data_to_sc2 = 1; // set flag, data from adder available
adder2_data = data; // store data m_adder2_data = data; // store data
LOG_CTRL(("ssc2 %02X(%c)\n",data, data )); LOG_CTRL(("ssc2 %02X(%c)\n",data, data ));
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static READ8_HANDLER( adder2_irq_r ) READ8_MEMBER( bfm_adder2_device::adder2_irq_r )
{ {
int status = 0; int status = 0;
if ( adder_vbl_triggered ) status |= 0x02; if ( m_adder_vbl_triggered ) status |= 0x02;
if ( adder2_acia_triggered ) status |= 0x08; if ( m_adder2_acia_triggered ) status |= 0x08;
return status; return status;
} }
void adder2_send(int data)
{
adder2_data_from_sc2 = 1; // set flag, data from scorpion2 board available
adder2_sc2data = data; // store data
adder2_acia_triggered = 1; // set flag, acia IRQ triggered ///////////////////////////////////////////////////////////////////////////
WRITE8_MEMBER(bfm_adder2_device::vid_uart_tx_w)
{
m_adder2_data_from_sc2 = 1; // set flag, data from scorpion2 board available
m_adder2_sc2data = data; // store data
m_adder2_acia_triggered = 1; // set flag, acia IRQ triggered
m_cpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE );
//LOG_SERIAL(("sadder %02X (%c)\n",data, data ));
} }
int adder2_receive(void) ///////////////////////////////////////////////////////////////////////////
WRITE8_MEMBER(bfm_adder2_device::vid_uart_ctrl_w)
{ {
UINT8 data = adder2_data; }
adder2_data_to_sc2 = 0; // clr flag, data from adder available
///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_adder2_device::vid_uart_rx_r)
{
UINT8 data = m_adder2_data;
m_adder2_data_to_sc2 = 0; // clr flag, data from adder available
//LOG_SERIAL(("radder: %02X(%c)\n",data, data ));
return data; return data;
} }
int adder2_status() ///////////////////////////////////////////////////////////////////////////
READ8_MEMBER(bfm_adder2_device::vid_uart_ctrl_r)
{ {
int status = 0; int status = 0;
if ( adder2_data_to_sc2 ) status |= 0x01; // receive buffer full if ( m_adder2_data_to_sc2 ) status |= 0x01; // receive buffer full
if ( !adder2_data_from_sc2) status |= 0x02; // transmit buffer empty if ( !m_adder2_data_from_sc2) status |= 0x02; // transmit buffer empty
return status; return status;
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// // // //
// decode character data to a format which can be decoded by MAME // // decode character data to a format which can be decoded by MAME //
// // // //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void adder2_decode_char_roms(running_machine &machine) void bfm_adder2_device::adder2_decode_char_roms()
{ {
UINT8 *p; UINT8 *p = machine().root_device().memregion("gfx1")->base();
p = machine.root_device().memregion("gfx1")->base();
if ( p ) if ( p )
{ {
UINT8 *s; UINT8 *s;
s = auto_alloc_array(machine, UINT8, 0x40000 ); s = auto_alloc_array(machine(), UINT8, 0x40000 );
{ {
int x, y; int x, y;
@ -482,7 +487,7 @@ void adder2_decode_char_roms(running_machine &machine)
} }
y++; y++;
} }
auto_free(machine, s); auto_free(machine(), s);
} }
} }
} }
@ -491,25 +496,25 @@ void adder2_decode_char_roms(running_machine &machine)
// adder2 board memorymap ///////////////////////////////////////////////// // adder2 board memorymap /////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
static ADDRESS_MAP_START( adder2_memmap, AS_PROGRAM, 8, driver_device ) static ADDRESS_MAP_START( adder2_memmap, AS_PROGRAM, 8, bfm_adder2_device )
AM_RANGE(0x0000, 0x0000) AM_WRITE_LEGACY(adder2_screen_page_w) // screen access/display select AM_RANGE(0x0000, 0x0000) AM_WRITE(adder2_screen_page_w) // screen access/display select
AM_RANGE(0x0000, 0x7FFF) AM_ROMBANK("bank2") // 8k paged ROM (4 pages) AM_RANGE(0x0000, 0x7FFF) AM_ROMBANK("bank2") // 8k paged ROM (4 pages)
AM_RANGE(0x8000, 0x917F) AM_READWRITE_LEGACY(screen_ram_r, screen_ram_w) AM_RANGE(0x8000, 0x917F) AM_READWRITE(screen_ram_r, screen_ram_w)
AM_RANGE(0x9180, 0x9FFF) AM_READWRITE_LEGACY(normal_ram_r, normal_ram_w) AM_RANGE(0x9180, 0x9FFF) AM_READWRITE(normal_ram_r, normal_ram_w)
AM_RANGE(0xC000, 0xC000) AM_WRITE_LEGACY(adder2_rom_page_w) // ROM page select AM_RANGE(0xC000, 0xC000) AM_WRITE(adder2_rom_page_w) // ROM page select
AM_RANGE(0xC001, 0xC001) AM_WRITE_LEGACY(adder2_c001_w) // ?? AM_RANGE(0xC001, 0xC001) AM_WRITE(adder2_c001_w) // ??
AM_RANGE(0xC101, 0xC101) AM_READWRITE_LEGACY(adder2_vbl_ctrl_r, adder2_vbl_ctrl_w) AM_RANGE(0xC101, 0xC101) AM_READWRITE(adder2_vbl_ctrl_r, adder2_vbl_ctrl_w)
AM_RANGE(0xC103, 0xC103) AM_READ_LEGACY(adder2_irq_r) // IRQ latch read AM_RANGE(0xC103, 0xC103) AM_READ(adder2_irq_r) // IRQ latch read
// MC6850 compatible uart connected to main (scorpion2) board /////////////////////////////////////// // MC6850 compatible uart connected to main (scorpion2) board ///////////////////////////////////////
AM_RANGE(0xC200, 0xC200) AM_READWRITE_LEGACY(adder2_uart_ctrl_r, adder2_uart_ctrl_w ) // 6850 compatible uart control reg AM_RANGE(0xC200, 0xC200) AM_READWRITE(adder2_uart_ctrl_r, adder2_uart_ctrl_w ) // 6850 compatible uart control reg
AM_RANGE(0xC201, 0xC201) AM_READWRITE_LEGACY(adder2_uart_rx_r, adder2_uart_tx_w ) // 6850 compatible uart data reg AM_RANGE(0xC201, 0xC201) AM_READWRITE(adder2_uart_rx_r, adder2_uart_tx_w ) // 6850 compatible uart data reg
AM_RANGE(0xE000, 0xFFFF) AM_ROM // 8k ROM AM_RANGE(0xE000, 0xFFFF) AM_ROM AM_REGION(":adder2", 0xE000) // 8k ROM
ADDRESS_MAP_END ADDRESS_MAP_END
static const gfx_layout charlayout = static const gfx_layout charlayout =
@ -534,21 +539,29 @@ GFXDECODE_END
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
MACHINE_CONFIG_FRAGMENT( adder2 ) static MACHINE_CONFIG_FRAGMENT( adder2 )
MCFG_SCREEN_ADD("adder", RASTER) MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_SIZE( 400, 280) MCFG_SCREEN_SIZE( 400, 280)
MCFG_SCREEN_VISIBLE_AREA( 0, 400-1, 0, 280-1) MCFG_SCREEN_VISIBLE_AREA( 0, 400-1, 0, 280-1)
MCFG_SCREEN_REFRESH_RATE(50) MCFG_SCREEN_REFRESH_RATE(50)
MCFG_VIDEO_START( adder2) MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, bfm_adder2_device, update_screen)
MCFG_SCREEN_UPDATE_STATIC(adder2)
MCFG_VIDEO_RESET( adder2)
MCFG_PALETTE_LENGTH(16) MCFG_PALETTE_LENGTH(16)
MCFG_PALETTE_INIT(adder2)
MCFG_GFXDECODE(adder2) MCFG_GFXDECODE(adder2)
MCFG_CPU_ADD("adder2", M6809, ADDER_CLOCK/4 ) // adder2 board 6809 CPU at 2 Mhz MCFG_CPU_ADD("adder2", M6809, ADDER_CLOCK/4 ) // adder2 board 6809 CPU at 2 Mhz
MCFG_CPU_PROGRAM_MAP(adder2_memmap) // setup adder2 board memorymap MCFG_CPU_PROGRAM_MAP(adder2_memmap) // setup adder2 board memorymap
MCFG_CPU_VBLANK_INT("adder", adder2_vbl) // board has a VBL IRQ MCFG_DEVICE_VBLANK_INT_DEVICE("screen", DEVICE_SELF, bfm_adder2_device, adder2_vbl) // board has a VBL IRQ
MACHINE_CONFIG_END MACHINE_CONFIG_END
//-------------------------------------------------
// machine_config_additions - device-specific
// machine configurations
//-------------------------------------------------
machine_config_constructor bfm_adder2_device::device_mconfig_additions() const
{
return MACHINE_CONFIG_NAME( adder2 );
}

76
src/mame/video/bfm_adr2.h
View File

@ -1,10 +1,76 @@
#ifndef INC_BFMADDER2 #ifndef INC_BFMADDER2
#define INC_BFMADDER2 #define INC_BFMADDER2
int adder2_receive(void); class bfm_adder2_device : public device_t
void adder2_send(int data); {
int adder2_status(void); public:
// construction/destruction
bfm_adder2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
TILE_GET_INFO_MEMBER( get_tile0_info );
TILE_GET_INFO_MEMBER( get_tile1_info );
UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER( adder2_vbl );
DECLARE_READ8_MEMBER( screen_ram_r );
DECLARE_WRITE8_MEMBER( screen_ram_w );
DECLARE_READ8_MEMBER( normal_ram_r );
DECLARE_WRITE8_MEMBER( normal_ram_w );
DECLARE_WRITE8_MEMBER( adder2_rom_page_w );
DECLARE_WRITE8_MEMBER( adder2_c001_w );
DECLARE_WRITE8_MEMBER( adder2_screen_page_w );
DECLARE_READ8_MEMBER( adder2_vbl_ctrl_r );
DECLARE_WRITE8_MEMBER( adder2_vbl_ctrl_w );
DECLARE_READ8_MEMBER( adder2_uart_ctrl_r );
DECLARE_WRITE8_MEMBER( adder2_uart_ctrl_w );
DECLARE_READ8_MEMBER( adder2_uart_rx_r );
DECLARE_WRITE8_MEMBER( adder2_uart_tx_w );
DECLARE_READ8_MEMBER( adder2_irq_r );
DECLARE_WRITE8_MEMBER(vid_uart_tx_w);
DECLARE_WRITE8_MEMBER(vid_uart_ctrl_w);
DECLARE_READ8_MEMBER(vid_uart_rx_r);
DECLARE_READ8_MEMBER(vid_uart_ctrl_r);
void adder2_decode_char_roms();
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual machine_config_constructor device_mconfig_additions() const;
private:
int m_adder2_screen_page_reg; // access/display select
int m_adder2_c101;
int m_adder2_rx;
int m_adder_vbl_triggered; // flag <>0, VBL IRQ triggered
int m_adder2_acia_triggered; // flag <>0, ACIA receive IRQ
UINT8 m_adder_ram[0xE80]; // normal RAM
UINT8 m_adder_screen_ram[2][0x1180]; // paged display RAM
tilemap_t *m_tilemap0; // tilemap screen0
tilemap_t *m_tilemap1; // timemap screen1
UINT8 m_adder2_data_from_sc2;
UINT8 m_adder2_data_to_sc2;
UINT8 m_adder2_data;
UINT8 m_adder2_sc2data;
optional_device<cpu_device> m_cpu;
};
// device type definition
extern const device_type BFM_ADDER2;
//**************************************************************************
// INTERFACE CONFIGURATION MACROS
//**************************************************************************
#define MCFG_BFM_ADDER2_ADD(_tag) \
MCFG_DEVICE_ADD(_tag, BFM_ADDER2, 0)
void adder2_decode_char_roms(running_machine &machine);
MACHINE_CONFIG_EXTERN(adder2);
#endif #endif