mirror of
https://github.com/holub/mame
synced 2025-04-25 09:50:04 +03:00
Fixed bug where required shared pointers were not actually required.
Added optional/required_shared_ptr_array classes so that you can populate an array of shared pointers. You provide a base tag name, and each item in the array is populated with tag.n, where n is the array index. Updated a couple of drivers using arrays to either not use arrays (where they weren't really providing any benefit) or to use the new array classes.
This commit is contained in:
Aaron Giles
parent
d2812cfea3
commit
9ecbecb503
@ -116,12 +116,12 @@ device_t::device_t(const machine_config &mconfig, device_type type, const char *
|
||||
m_machine_config(mconfig),
|
||||
m_static_config(NULL),
|
||||
m_input_defaults(NULL),
|
||||
m_auto_finder_list(NULL),
|
||||
m_machine(NULL),
|
||||
m_save(NULL),
|
||||
m_basetag(tag),
|
||||
m_config_complete(false),
|
||||
m_started(false)
|
||||
m_started(false),
|
||||
m_auto_finder_list(NULL)
|
||||
{
|
||||
if (owner != NULL)
|
||||
m_tag.cpy((owner->owner() == NULL) ? "" : owner->tag()).cat(":").cat(tag);
|
||||
@ -863,7 +863,11 @@ void *device_t::finder_base::find_memory(UINT8 width, size_t &bytes, bool requir
|
||||
{
|
||||
memory_share *share = m_base.machine().memory().shared(m_base, m_tag);
|
||||
if (share == NULL)
|
||||
{
|
||||
if (required)
|
||||
throw emu_fatalerror("Shared ptr '%s' not found", m_tag);
|
||||
return NULL;
|
||||
}
|
||||
if (share->width() != width)
|
||||
{
|
||||
if (required)
|
||||
|
||||
365
src/emu/device.h
365
src/emu/device.h
@ -124,7 +124,6 @@ typedef int (*read_line_device_func)(device_t *device);
|
||||
typedef void (*write_line_device_func)(device_t *device, int state);
|
||||
|
||||
|
||||
|
||||
// ======================> device_t
|
||||
|
||||
// device_t represents a device
|
||||
@ -228,6 +227,18 @@ public:
|
||||
device_debug *debug() const { return m_debug; }
|
||||
|
||||
protected:
|
||||
// internal helper classes (defined below)
|
||||
class finder_base;
|
||||
template<class _DeviceClass, bool _Required> class device_finder;
|
||||
template<class _DeviceClass> class optional_device;
|
||||
template<class _DeviceClass> class required_device;
|
||||
template<typename _PointerType, bool _Required> class shared_ptr_finder;
|
||||
template<typename _PointerType> class optional_shared_ptr;
|
||||
template<typename _PointerType> class required_shared_ptr;
|
||||
template<typename _PointerType, int _Count, bool _Required> class shared_ptr_array_finder;
|
||||
template<typename _PointerType, int _Count> class optional_shared_ptr_array;
|
||||
template<typename _PointerType, int _Count> class required_shared_ptr_array;
|
||||
|
||||
// miscellaneous helpers
|
||||
void set_machine(running_machine &machine);
|
||||
void start();
|
||||
@ -236,6 +247,7 @@ protected:
|
||||
void pre_save();
|
||||
void post_load();
|
||||
void notify_clock_changed();
|
||||
finder_base *register_auto_finder(finder_base &autodev);
|
||||
|
||||
//------------------- begin derived class overrides
|
||||
|
||||
@ -288,155 +300,6 @@ protected:
|
||||
const void * m_static_config; // static device configuration
|
||||
const input_device_default *m_input_defaults; // devices input ports default overrides
|
||||
|
||||
// helper class to request auto-object discovery in the constructor of a derived class
|
||||
class finder_base
|
||||
{
|
||||
friend class device_t;
|
||||
|
||||
public:
|
||||
// construction/destruction
|
||||
finder_base(device_t &base, const char *tag);
|
||||
virtual ~finder_base();
|
||||
|
||||
// getters
|
||||
virtual void findit() = 0;
|
||||
|
||||
protected:
|
||||
// static helpers
|
||||
void *find_memory(UINT8 width, size_t &bytes, bool required);
|
||||
|
||||
// internal state
|
||||
finder_base *m_next;
|
||||
device_t &m_base;
|
||||
const char *m_tag;
|
||||
};
|
||||
|
||||
// device finder template
|
||||
template<typename _DeviceClass, bool _Required>
|
||||
class device_finder : public finder_base
|
||||
{
|
||||
public:
|
||||
// construction/destruction
|
||||
device_finder(device_t &base, const char *tag)
|
||||
: finder_base(base, tag),
|
||||
m_target(0) { }
|
||||
|
||||
// operators to make use transparent
|
||||
operator _DeviceClass *() { return m_target; }
|
||||
operator _DeviceClass *() const { return m_target; }
|
||||
_DeviceClass *operator->() { return m_target; }
|
||||
|
||||
// getter for explicit fetching
|
||||
_DeviceClass *target() const { return m_target; }
|
||||
|
||||
// setter for setting the object
|
||||
void set_target(_DeviceClass *target)
|
||||
{
|
||||
m_target = target;
|
||||
if (target == 0 && _Required)
|
||||
throw emu_fatalerror("Unable to find required device '%s'", this->m_tag);
|
||||
}
|
||||
|
||||
// finder
|
||||
virtual void findit() { set_target(m_base.subdevice<_DeviceClass>(m_tag)); }
|
||||
|
||||
protected:
|
||||
// internal state
|
||||
_DeviceClass *m_target;
|
||||
};
|
||||
|
||||
// optional device finder
|
||||
template<class _DeviceClass>
|
||||
class optional_device : public device_finder<_DeviceClass, false>
|
||||
{
|
||||
public:
|
||||
optional_device(device_t &base, const char *tag) : device_finder<_DeviceClass, false>(base, tag) { }
|
||||
};
|
||||
|
||||
// required devices are similar but throw an error if they are not found
|
||||
template<class _DeviceClass>
|
||||
class required_device : public device_finder<_DeviceClass, true>
|
||||
{
|
||||
public:
|
||||
required_device(device_t &base, const char *tag) : device_finder<_DeviceClass, true>(base, tag) { }
|
||||
};
|
||||
|
||||
// shared pointer finder template
|
||||
template<typename _PointerType, bool _Required>
|
||||
class shared_ptr_finder : public finder_base
|
||||
{
|
||||
public:
|
||||
// construction/destruction
|
||||
shared_ptr_finder(device_t &base, const char *tag, UINT8 width = 0)
|
||||
: finder_base(base, tag),
|
||||
m_target(0),
|
||||
m_bytes(0),
|
||||
m_allocated(false),
|
||||
m_width((width != 0) ? width : sizeof(_PointerType) * 8) { }
|
||||
|
||||
virtual ~shared_ptr_finder() { if (m_allocated) global_free(m_target); }
|
||||
|
||||
// operators to make use transparent
|
||||
operator _PointerType *() const { return m_target; }
|
||||
_PointerType operator[](int index) const { return m_target[index]; }
|
||||
_PointerType &operator[](int index) { return m_target[index]; }
|
||||
_PointerType *operator->() { return m_target; }
|
||||
|
||||
// getter for explicit fetching
|
||||
_PointerType *target() const { return m_target; }
|
||||
UINT32 bytes() const { return m_bytes; }
|
||||
|
||||
// setter for setting the object
|
||||
void set_target(_PointerType *target, size_t bytes)
|
||||
{
|
||||
m_target = target;
|
||||
m_bytes = bytes;
|
||||
if (target == 0 && _Required)
|
||||
throw emu_fatalerror("Unable to find required shared pointer '%s'", this->m_tag);
|
||||
}
|
||||
|
||||
// dynamic allocation of a shared pointer
|
||||
void allocate(UINT32 entries)
|
||||
{
|
||||
assert(!m_allocated);
|
||||
m_allocated = true;
|
||||
m_target = global_alloc_array_clear(_PointerType, entries);
|
||||
m_bytes = entries * sizeof(_PointerType);
|
||||
m_base.save_pointer(m_target, m_tag, entries);
|
||||
}
|
||||
|
||||
// finder
|
||||
virtual void findit() { m_target = reinterpret_cast<_PointerType *>(find_memory(m_width, m_bytes, _Required)); }
|
||||
|
||||
protected:
|
||||
// internal state
|
||||
_PointerType *m_target;
|
||||
size_t m_bytes;
|
||||
bool m_allocated;
|
||||
UINT8 m_width;
|
||||
};
|
||||
|
||||
// optional device finder
|
||||
template<class _PointerType>
|
||||
class optional_shared_ptr : public shared_ptr_finder<_PointerType, false>
|
||||
{
|
||||
public:
|
||||
optional_shared_ptr(device_t &base, const char *tag, UINT8 width = 0) : shared_ptr_finder<_PointerType, false>(base, tag, width) { }
|
||||
};
|
||||
|
||||
// required devices are similar but throw an error if they are not found
|
||||
template<class _PointerType>
|
||||
class required_shared_ptr : public shared_ptr_finder<_PointerType, true>
|
||||
{
|
||||
public:
|
||||
required_shared_ptr(device_t &base, const char *tag, UINT8 width = 0) : shared_ptr_finder<_PointerType, true>(base, tag, width) { }
|
||||
};
|
||||
|
||||
// internal helpers
|
||||
finder_base *register_auto_finder(finder_base &autodev);
|
||||
|
||||
finder_base * m_auto_finder_list;
|
||||
|
||||
private:
|
||||
// private helpers
|
||||
device_t *add_subdevice(device_type type, const char *tag, UINT32 clock);
|
||||
@ -451,9 +314,211 @@ private:
|
||||
astring m_basetag; // base part of the tag
|
||||
bool m_config_complete; // have we completed our configuration?
|
||||
bool m_started; // true if the start function has succeeded
|
||||
finder_base * m_auto_finder_list; // list of objects to auto-find
|
||||
};
|
||||
|
||||
|
||||
// ======================> finder_base
|
||||
|
||||
// helper class to request auto-object discovery in the constructor of a derived class
|
||||
class device_t::finder_base
|
||||
{
|
||||
friend class device_t;
|
||||
|
||||
public:
|
||||
// construction/destruction
|
||||
finder_base(device_t &base, const char *tag);
|
||||
virtual ~finder_base();
|
||||
|
||||
// getters
|
||||
virtual void findit() = 0;
|
||||
|
||||
protected:
|
||||
// helpers
|
||||
void *find_memory(UINT8 width, size_t &bytes, bool required);
|
||||
|
||||
// internal state
|
||||
finder_base *m_next;
|
||||
device_t &m_base;
|
||||
const char *m_tag;
|
||||
};
|
||||
|
||||
|
||||
// ======================> device_finder
|
||||
|
||||
// device finder template
|
||||
template<class _DeviceClass, bool _Required>
|
||||
class device_t::device_finder : public device_t::finder_base
|
||||
{
|
||||
public:
|
||||
// construction/destruction
|
||||
device_finder(device_t &base, const char *tag)
|
||||
: finder_base(base, tag),
|
||||
m_target(0) { }
|
||||
|
||||
// operators to make use transparent
|
||||
operator _DeviceClass *() { return m_target; }
|
||||
operator _DeviceClass *() const { return m_target; }
|
||||
_DeviceClass *operator->() { assert(m_target != NULL); return m_target; }
|
||||
|
||||
// getter for explicit fetching
|
||||
_DeviceClass *target() const { return m_target; }
|
||||
|
||||
// setter for setting the object
|
||||
void set_target(_DeviceClass *target)
|
||||
{
|
||||
m_target = target;
|
||||
if (target == 0 && _Required)
|
||||
throw emu_fatalerror("Unable to find required device '%s'", this->m_tag);
|
||||
}
|
||||
|
||||
// finder
|
||||
virtual void findit() { set_target(m_base.subdevice<_DeviceClass>(m_tag)); }
|
||||
|
||||
protected:
|
||||
// internal state
|
||||
_DeviceClass *m_target;
|
||||
};
|
||||
|
||||
// optional device finder
|
||||
template<class _DeviceClass>
|
||||
class device_t::optional_device : public device_t::device_finder<_DeviceClass, false>
|
||||
{
|
||||
public:
|
||||
optional_device(device_t &base, const char *tag) : device_finder<_DeviceClass, false>(base, tag) { }
|
||||
};
|
||||
|
||||
// required devices are similar but throw an error if they are not found
|
||||
template<class _DeviceClass>
|
||||
class device_t::required_device : public device_t::device_finder<_DeviceClass, true>
|
||||
{
|
||||
public:
|
||||
required_device(device_t &base, const char *tag) : device_finder<_DeviceClass, true>(base, tag) { }
|
||||
};
|
||||
|
||||
|
||||
// ======================> shared_ptr_finder
|
||||
|
||||
// shared pointer finder template
|
||||
template<typename _PointerType, bool _Required>
|
||||
class device_t::shared_ptr_finder : public device_t::finder_base
|
||||
{
|
||||
public:
|
||||
// construction/destruction
|
||||
shared_ptr_finder(device_t &base, const char *tag, UINT8 width = 0)
|
||||
: finder_base(base, tag),
|
||||
m_target(0),
|
||||
m_bytes(0),
|
||||
m_allocated(false),
|
||||
m_width((width != 0) ? width : sizeof(_PointerType) * 8) { }
|
||||
|
||||
virtual ~shared_ptr_finder() { if (m_allocated) global_free(m_target); }
|
||||
|
||||
// operators to make use transparent
|
||||
operator _PointerType *() const { return m_target; }
|
||||
_PointerType operator[](int index) const { return m_target[index]; }
|
||||
_PointerType &operator[](int index) { return m_target[index]; }
|
||||
_PointerType *operator->() { return m_target; }
|
||||
|
||||
// getter for explicit fetching
|
||||
_PointerType *target() const { return m_target; }
|
||||
UINT32 bytes() const { return m_bytes; }
|
||||
|
||||
// setter for setting the object
|
||||
void set_target(_PointerType *target, size_t bytes)
|
||||
{
|
||||
m_target = target;
|
||||
m_bytes = bytes;
|
||||
if (target == 0 && _Required)
|
||||
throw emu_fatalerror("Unable to find required shared pointer '%s'", this->m_tag);
|
||||
}
|
||||
|
||||
// dynamic allocation of a shared pointer
|
||||
void allocate(UINT32 entries)
|
||||
{
|
||||
assert(!m_allocated);
|
||||
m_allocated = true;
|
||||
m_target = global_alloc_array_clear(_PointerType, entries);
|
||||
m_bytes = entries * sizeof(_PointerType);
|
||||
m_base.save_pointer(m_target, m_tag, entries);
|
||||
}
|
||||
|
||||
// finder
|
||||
virtual void findit() { m_target = reinterpret_cast<_PointerType *>(find_memory(m_width, m_bytes, _Required)); }
|
||||
|
||||
protected:
|
||||
// internal state
|
||||
_PointerType *m_target;
|
||||
size_t m_bytes;
|
||||
bool m_allocated;
|
||||
UINT8 m_width;
|
||||
};
|
||||
|
||||
// optional shared pointer finder
|
||||
template<class _PointerType>
|
||||
class device_t::optional_shared_ptr : public device_t::shared_ptr_finder<_PointerType, false>
|
||||
{
|
||||
public:
|
||||
optional_shared_ptr(device_t &base, const char *tag, UINT8 width = 0) : shared_ptr_finder<_PointerType, false>(base, tag, width) { }
|
||||
};
|
||||
|
||||
// required shared pointer finder
|
||||
template<class _PointerType>
|
||||
class device_t::required_shared_ptr : public device_t::shared_ptr_finder<_PointerType, true>
|
||||
{
|
||||
public:
|
||||
required_shared_ptr(device_t &base, const char *tag, UINT8 width = 0) : shared_ptr_finder<_PointerType, true>(base, tag, width) { }
|
||||
};
|
||||
|
||||
|
||||
// ======================> shared_ptr_array_finder
|
||||
|
||||
// shared pointer array finder template
|
||||
template<typename _PointerType, int _Count, bool _Required>
|
||||
class device_t::shared_ptr_array_finder
|
||||
{
|
||||
typedef shared_ptr_finder<_PointerType, _Required> shared_ptr_type;
|
||||
|
||||
public:
|
||||
// construction/destruction
|
||||
shared_ptr_array_finder(device_t &base, const char *basetag, UINT8 width = 0)
|
||||
{
|
||||
for (int index = 0; index < _Count; index++)
|
||||
m_array[index] = global_alloc(shared_ptr_type(base, m_tag[index].format("%s.%d", basetag, index), width));
|
||||
}
|
||||
|
||||
virtual ~shared_ptr_array_finder()
|
||||
{
|
||||
for (int index = 0; index < _Count; index++)
|
||||
global_free(m_array[index]);
|
||||
}
|
||||
|
||||
// array accessors
|
||||
const shared_ptr_type &operator[](int index) const { assert(index < _Count); return *m_array[index]; }
|
||||
shared_ptr_type &operator[](int index) { assert(index < _Count); return *m_array[index]; }
|
||||
|
||||
protected:
|
||||
// internal state
|
||||
shared_ptr_type *m_array[_Count];
|
||||
astring m_tag[_Count];
|
||||
};
|
||||
|
||||
// optional shared pointer array finder
|
||||
template<class _PointerType, int _Count>
|
||||
class device_t::optional_shared_ptr_array : public device_t::shared_ptr_array_finder<_PointerType, _Count, false>
|
||||
{
|
||||
public:
|
||||
optional_shared_ptr_array(device_t &base, const char *tag, UINT8 width = 0) : shared_ptr_array_finder<_PointerType, _Count, false>(base, tag, width) { }
|
||||
};
|
||||
|
||||
// required shared pointer array finder
|
||||
template<class _PointerType, int _Count>
|
||||
class device_t::required_shared_ptr_array : public device_t::shared_ptr_array_finder<_PointerType, _Count, true>
|
||||
{
|
||||
public:
|
||||
required_shared_ptr_array(device_t &base, const char *tag, UINT8 width = 0) : shared_ptr_array_finder<_PointerType, _Count, true>(base, tag, width) { }
|
||||
};
|
||||
|
||||
|
||||
// ======================> device_interface
|
||||
|
||||
|
||||
@ -43,7 +43,10 @@ class blitz68k_state : public driver_device
|
||||
public:
|
||||
blitz68k_state(const machine_config &mconfig, device_type type, const char *tag)
|
||||
: driver_device(mconfig, type, tag),
|
||||
m_nvram(*this, "nvram") { }
|
||||
m_nvram(*this, "nvram"),
|
||||
m_leds0(*this, "leds0"),
|
||||
m_leds1(*this, "leds1"),
|
||||
m_leds2(*this, "leds2") { }
|
||||
|
||||
optional_shared_ptr<UINT16> m_nvram;
|
||||
UINT8 *m_blit_buffer;
|
||||
@ -55,7 +58,9 @@ public:
|
||||
UINT16 *m_blit_dst_ram_hiword;
|
||||
UINT16 *m_blit_vregs;
|
||||
UINT16 *m_blit_transpen;
|
||||
UINT16 *m_leds[3];
|
||||
required_shared_ptr<UINT16> m_leds0;
|
||||
required_shared_ptr<UINT16> m_leds1;
|
||||
optional_shared_ptr<UINT16> m_leds2;
|
||||
DECLARE_WRITE16_MEMBER(blit_copy_w);
|
||||
DECLARE_READ8_MEMBER(blit_status_r);
|
||||
DECLARE_WRITE8_MEMBER(blit_x_w);
|
||||
@ -505,13 +510,13 @@ WRITE8_MEMBER(blitz68k_state::blit_hwyxa_draw_w)
|
||||
void blitz68k_state::show_leds123()
|
||||
{
|
||||
#ifdef MAME_DEBUG
|
||||
popmessage("led %02x %02x %02x", m_leds[0][0]>>8, m_leds[1][0]>>8, m_leds[2][0]>>8);
|
||||
popmessage("led %02x %02x %02x", m_leds0[0]>>8, m_leds1[0]>>8, m_leds2[0]>>8);
|
||||
#endif
|
||||
}
|
||||
void blitz68k_state::show_leds12()
|
||||
{
|
||||
#ifdef MAME_DEBUG
|
||||
popmessage("led %02x %02x", m_leds[0][0]>>8, m_leds[1][0]>>8);
|
||||
popmessage("led %02x %02x", m_leds0[0]>>8, m_leds1[0]>>8);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -793,7 +798,7 @@ ADDRESS_MAP_END
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::cjffruit_leds1_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[0]);
|
||||
data = COMBINE_DATA(m_leds0);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
coin_counter_w(machine(), 0, data & 0x0100); // coin in
|
||||
@ -810,7 +815,7 @@ WRITE16_MEMBER(blitz68k_state::cjffruit_leds1_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::cjffruit_leds2_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[1]);
|
||||
data = COMBINE_DATA(m_leds1);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
set_led_status(machine(), 7, data & 0x0100); // start
|
||||
@ -827,7 +832,7 @@ WRITE16_MEMBER(blitz68k_state::cjffruit_leds2_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::cjffruit_leds3_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[2]);
|
||||
data = COMBINE_DATA(m_leds2);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
set_led_status(machine(), 15, data & 0x0100); // hopper coins?
|
||||
@ -902,9 +907,9 @@ static ADDRESS_MAP_START( cjffruit_map, AS_PROGRAM, 16, blitz68k_state )
|
||||
|
||||
AM_RANGE(0x8e0000, 0x8e0001) AM_WRITE(cjffruit_mcu_w )
|
||||
|
||||
AM_RANGE(0x8f8000, 0x8f8001) AM_WRITE(cjffruit_leds1_w) AM_BASE(m_leds[0])
|
||||
AM_RANGE(0x8fa000, 0x8fa001) AM_WRITE(cjffruit_leds2_w) AM_BASE(m_leds[1])
|
||||
AM_RANGE(0x8fc000, 0x8fc001) AM_WRITE(cjffruit_leds3_w) AM_BASE(m_leds[2])
|
||||
AM_RANGE(0x8f8000, 0x8f8001) AM_WRITE(cjffruit_leds1_w) AM_SHARE("leds0")
|
||||
AM_RANGE(0x8fa000, 0x8fa001) AM_WRITE(cjffruit_leds2_w) AM_SHARE("leds1")
|
||||
AM_RANGE(0x8fc000, 0x8fc001) AM_WRITE(cjffruit_leds3_w) AM_SHARE("leds2")
|
||||
|
||||
AM_RANGE(0x8fe000, 0x8fe003) AM_WRITE8(blit_flags_w, 0xffff) // flipx,y,solid,trans
|
||||
AM_RANGE(0x8fe004, 0x8fe005) AM_WRITEONLY
|
||||
@ -932,7 +937,7 @@ WRITE16_MEMBER(blitz68k_state::deucesw2_mcu_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::deucesw2_leds1_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[0]);
|
||||
data = COMBINE_DATA(m_leds0);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
coin_counter_w(machine(), 0, data & 0x0100); // coin in
|
||||
@ -949,7 +954,7 @@ WRITE16_MEMBER(blitz68k_state::deucesw2_leds1_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::deucesw2_leds2_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[1]);
|
||||
data = COMBINE_DATA(m_leds1);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
set_led_status(machine(), 7, data & 0x0100); // start
|
||||
@ -966,7 +971,7 @@ WRITE16_MEMBER(blitz68k_state::deucesw2_leds2_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::deucesw2_leds3_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[2]);
|
||||
data = COMBINE_DATA(m_leds2);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
set_led_status(machine(), 15, data & 0x0100); // hopper coins?
|
||||
@ -1001,9 +1006,9 @@ static ADDRESS_MAP_START( deucesw2_map, AS_PROGRAM, 16, blitz68k_state )
|
||||
|
||||
AM_RANGE(0x896000, 0x896001) AM_WRITE(deucesw2_mcu_w )
|
||||
|
||||
AM_RANGE(0x898000, 0x898001) AM_WRITE(deucesw2_leds1_w) AM_BASE(m_leds[0])
|
||||
AM_RANGE(0x89a000, 0x89a001) AM_WRITE(deucesw2_leds2_w) AM_BASE(m_leds[1])
|
||||
AM_RANGE(0x89c000, 0x89c001) AM_WRITE(deucesw2_leds3_w) AM_BASE(m_leds[2])
|
||||
AM_RANGE(0x898000, 0x898001) AM_WRITE(deucesw2_leds1_w) AM_SHARE("leds0")
|
||||
AM_RANGE(0x89a000, 0x89a001) AM_WRITE(deucesw2_leds2_w) AM_SHARE("leds1")
|
||||
AM_RANGE(0x89c000, 0x89c001) AM_WRITE(deucesw2_leds3_w) AM_SHARE("leds2")
|
||||
|
||||
AM_RANGE(0x89e000, 0x89e003) AM_WRITE8(blit_flags_w, 0xffff) // flipx,y,solid,trans
|
||||
AM_RANGE(0x89e004, 0x89e005) AM_WRITEONLY
|
||||
@ -1122,7 +1127,7 @@ WRITE16_MEMBER(blitz68k_state::hermit_mcu_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::hermit_leds1_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[0]);
|
||||
data = COMBINE_DATA(m_leds0);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
coin_counter_w(machine(), 0, data & 0x0100); // coin in
|
||||
@ -1132,7 +1137,7 @@ WRITE16_MEMBER(blitz68k_state::hermit_leds1_w)
|
||||
|
||||
WRITE16_MEMBER(blitz68k_state::hermit_leds2_w)
|
||||
{
|
||||
data = COMBINE_DATA(m_leds[1]);
|
||||
data = COMBINE_DATA(m_leds1);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
{
|
||||
set_led_status(machine(), 7, data & 0x0100); // button
|
||||
@ -1176,8 +1181,8 @@ static ADDRESS_MAP_START( hermit_map, AS_PROGRAM, 16, blitz68k_state )
|
||||
AM_RANGE(0x9d0000, 0x9d0001) AM_READ_PORT("IN2")
|
||||
AM_RANGE(0x9d8000, 0x9d8001) AM_READ_PORT("DSW")
|
||||
|
||||
AM_RANGE(0x9e0000, 0x9e0001) AM_WRITE(hermit_leds1_w) AM_BASE(m_leds[0])
|
||||
AM_RANGE(0x9e8000, 0x9e8001) AM_WRITE(hermit_leds2_w) AM_BASE(m_leds[1])
|
||||
AM_RANGE(0x9e0000, 0x9e0001) AM_WRITE(hermit_leds1_w) AM_SHARE("leds0")
|
||||
AM_RANGE(0x9e8000, 0x9e8001) AM_WRITE(hermit_leds2_w) AM_SHARE("leds1")
|
||||
|
||||
AM_RANGE(0x9f0000, 0x9f0003) AM_WRITE8(blit_flags_w, 0xffff) // flipx,y,solid,trans
|
||||
AM_RANGE(0x9f0004, 0x9f0005) AM_WRITEONLY
|
||||
|
||||
@ -98,24 +98,37 @@ class bnstars_state : public driver_device
|
||||
{
|
||||
public:
|
||||
bnstars_state(const machine_config &mconfig, device_type type, const char *tag)
|
||||
: driver_device(mconfig, type, tag) { }
|
||||
: driver_device(mconfig, type, tag),
|
||||
m_ms32_tx0_ram(*this, "tx0_ram"),
|
||||
m_ms32_tx1_ram(*this, "tx1_ram"),
|
||||
m_ms32_bg0_ram(*this, "bg0_ram"),
|
||||
m_ms32_bg1_ram(*this, "bg1_ram"),
|
||||
m_ms32_roz0_ram(*this, "roz0_ram"),
|
||||
m_ms32_roz1_ram(*this, "roz1_ram"),
|
||||
m_ms32_pal_ram(*this, "pal_ram"),
|
||||
m_ms32_roz_ctrl(*this, "roz_ctrl"),
|
||||
m_ms32_spram(*this, "spram"),
|
||||
m_ms32_tx0_scroll(*this, "tx0_scroll"),
|
||||
m_ms32_bg0_scroll(*this, "bg0_scroll"),
|
||||
m_ms32_tx1_scroll(*this, "tx1_scroll"),
|
||||
m_ms32_bg1_scroll(*this, "bg1_scroll") { }
|
||||
|
||||
tilemap_t *m_ms32_tx_tilemap[2];
|
||||
tilemap_t *m_ms32_bg_tilemap[2];
|
||||
tilemap_t *m_ms32_roz_tilemap[2];
|
||||
UINT32 *m_ms32_tx0_ram;
|
||||
UINT32 *m_ms32_tx1_ram;
|
||||
UINT32 *m_ms32_bg0_ram;
|
||||
UINT32 *m_ms32_bg1_ram;
|
||||
UINT32 *m_ms32_roz0_ram;
|
||||
UINT32 *m_ms32_roz1_ram;
|
||||
UINT32 *m_ms32_pal_ram[2];
|
||||
UINT32 *m_ms32_roz_ctrl[2];
|
||||
UINT32 *m_ms32_spram;
|
||||
UINT32 *m_ms32_tx0_scroll;
|
||||
UINT32 *m_ms32_bg0_scroll;
|
||||
UINT32 *m_ms32_tx1_scroll;
|
||||
UINT32 *m_ms32_bg1_scroll;
|
||||
required_shared_ptr<UINT32> m_ms32_tx0_ram;
|
||||
required_shared_ptr<UINT32> m_ms32_tx1_ram;
|
||||
required_shared_ptr<UINT32> m_ms32_bg0_ram;
|
||||
required_shared_ptr<UINT32> m_ms32_bg1_ram;
|
||||
required_shared_ptr<UINT32> m_ms32_roz0_ram;
|
||||
required_shared_ptr<UINT32> m_ms32_roz1_ram;
|
||||
required_shared_ptr_array<UINT32, 2> m_ms32_pal_ram;
|
||||
required_shared_ptr_array<UINT32, 2> m_ms32_roz_ctrl;
|
||||
required_shared_ptr<UINT32> m_ms32_spram;
|
||||
required_shared_ptr<UINT32> m_ms32_tx0_scroll;
|
||||
required_shared_ptr<UINT32> m_ms32_bg0_scroll;
|
||||
required_shared_ptr<UINT32> m_ms32_tx1_scroll;
|
||||
required_shared_ptr<UINT32> m_ms32_bg1_scroll;
|
||||
UINT32 m_bnstars1_mahjong_select;
|
||||
int m_ms32_reverse_sprite_order;
|
||||
int m_flipscreen;
|
||||
@ -1276,27 +1289,27 @@ static ADDRESS_MAP_START( bnstars_map, AS_PROGRAM, 32, bnstars_state )
|
||||
AM_RANGE(0xfce00058, 0xfce0005b) AM_WRITENOP
|
||||
AM_RANGE(0xfce0005c, 0xfce0005f) AM_WRITENOP
|
||||
|
||||
AM_RANGE(0xfce00400, 0xfce0045f) AM_WRITEONLY AM_BASE(m_ms32_roz_ctrl[0])
|
||||
AM_RANGE(0xfce00700, 0xfce0075f) AM_WRITEONLY AM_BASE(m_ms32_roz_ctrl[1]) // guess
|
||||
AM_RANGE(0xfce00a00, 0xfce00a17) AM_WRITEONLY AM_BASE(m_ms32_tx0_scroll)
|
||||
AM_RANGE(0xfce00a20, 0xfce00a37) AM_WRITEONLY AM_BASE(m_ms32_bg0_scroll)
|
||||
AM_RANGE(0xfce00c00, 0xfce00c17) AM_WRITEONLY AM_BASE(m_ms32_tx1_scroll)
|
||||
AM_RANGE(0xfce00c20, 0xfce00c37) AM_WRITEONLY AM_BASE(m_ms32_bg1_scroll)
|
||||
AM_RANGE(0xfce00400, 0xfce0045f) AM_WRITEONLY AM_SHARE("roz_ctrl.0")
|
||||
AM_RANGE(0xfce00700, 0xfce0075f) AM_WRITEONLY AM_SHARE("roz_ctrl.1") // guess
|
||||
AM_RANGE(0xfce00a00, 0xfce00a17) AM_WRITEONLY AM_SHARE("tx0_scroll")
|
||||
AM_RANGE(0xfce00a20, 0xfce00a37) AM_WRITEONLY AM_SHARE("bg0_scroll")
|
||||
AM_RANGE(0xfce00c00, 0xfce00c17) AM_WRITEONLY AM_SHARE("tx1_scroll")
|
||||
AM_RANGE(0xfce00c20, 0xfce00c37) AM_WRITEONLY AM_SHARE("bg1_scroll")
|
||||
|
||||
AM_RANGE(0xfce00e00, 0xfce00e03) AM_WRITE(bnstars1_mahjong_select_w) // ?
|
||||
|
||||
/* wrote together */
|
||||
AM_RANGE(0xfd040000, 0xfd047fff) AM_RAM // priority ram
|
||||
AM_RANGE(0xfd080000, 0xfd087fff) AM_RAM
|
||||
AM_RANGE(0xfd200000, 0xfd237fff) AM_RAM_WRITE(ms32_pal1_ram_w) AM_BASE(m_ms32_pal_ram[1])
|
||||
AM_RANGE(0xfd400000, 0xfd437fff) AM_RAM_WRITE(ms32_pal0_ram_w) AM_BASE(m_ms32_pal_ram[0])
|
||||
AM_RANGE(0xfe000000, 0xfe01ffff) AM_RAM_WRITE(ms32_roz1_ram_w) AM_BASE(m_ms32_roz1_ram)
|
||||
AM_RANGE(0xfe400000, 0xfe41ffff) AM_RAM_WRITE(ms32_roz0_ram_w) AM_BASE(m_ms32_roz0_ram)
|
||||
AM_RANGE(0xfe800000, 0xfe83ffff) AM_RAM_WRITE(ms32_spramx_w) AM_BASE(m_ms32_spram)
|
||||
AM_RANGE(0xfea00000, 0xfea07fff) AM_RAM_WRITE(ms32_tx1_ram_w) AM_BASE(m_ms32_tx1_ram)
|
||||
AM_RANGE(0xfea08000, 0xfea0ffff) AM_RAM_WRITE(ms32_bg1_ram_w) AM_BASE(m_ms32_bg1_ram)
|
||||
AM_RANGE(0xfec00000, 0xfec07fff) AM_RAM_WRITE(ms32_tx0_ram_w) AM_BASE(m_ms32_tx0_ram)
|
||||
AM_RANGE(0xfec08000, 0xfec0ffff) AM_RAM_WRITE(ms32_bg0_ram_w) AM_BASE(m_ms32_bg0_ram)
|
||||
AM_RANGE(0xfd200000, 0xfd237fff) AM_RAM_WRITE(ms32_pal1_ram_w) AM_SHARE("pal_ram.1")
|
||||
AM_RANGE(0xfd400000, 0xfd437fff) AM_RAM_WRITE(ms32_pal0_ram_w) AM_SHARE("pal_ram.0")
|
||||
AM_RANGE(0xfe000000, 0xfe01ffff) AM_RAM_WRITE(ms32_roz1_ram_w) AM_SHARE("roz1_ram")
|
||||
AM_RANGE(0xfe400000, 0xfe41ffff) AM_RAM_WRITE(ms32_roz0_ram_w) AM_SHARE("roz0_ram")
|
||||
AM_RANGE(0xfe800000, 0xfe83ffff) AM_RAM_WRITE(ms32_spramx_w) AM_SHARE("spram")
|
||||
AM_RANGE(0xfea00000, 0xfea07fff) AM_RAM_WRITE(ms32_tx1_ram_w) AM_SHARE("tx1_ram")
|
||||
AM_RANGE(0xfea08000, 0xfea0ffff) AM_RAM_WRITE(ms32_bg1_ram_w) AM_SHARE("bg1_ram")
|
||||
AM_RANGE(0xfec00000, 0xfec07fff) AM_RAM_WRITE(ms32_tx0_ram_w) AM_SHARE("tx0_ram")
|
||||
AM_RANGE(0xfec08000, 0xfec0ffff) AM_RAM_WRITE(ms32_bg0_ram_w) AM_SHARE("bg0_ram")
|
||||
|
||||
AM_RANGE(0xfee00000, 0xfee1ffff) AM_RAM
|
||||
AM_RANGE(0xffe00000, 0xffffffff) AM_ROMBANK("bank1")
|
||||
|
||||
@ -327,12 +327,16 @@ class hornet_state : public driver_device
|
||||
{
|
||||
public:
|
||||
hornet_state(const machine_config &mconfig, device_type type, const char *tag)
|
||||
: driver_device(mconfig, type, tag) { }
|
||||
: driver_device(mconfig, type, tag),
|
||||
m_workram(*this, "workram"),
|
||||
m_sharc_dataram0(*this, "share_dataram0"),
|
||||
m_sharc_dataram1(*this, "share_dataram1") { }
|
||||
|
||||
UINT8 m_led_reg0;
|
||||
UINT8 m_led_reg1;
|
||||
UINT32 *m_workram;
|
||||
UINT32 *m_sharc_dataram[2];
|
||||
required_shared_ptr<UINT32> m_workram;
|
||||
required_shared_ptr<UINT32> m_sharc_dataram0;
|
||||
required_shared_ptr<UINT32> m_sharc_dataram1;
|
||||
UINT8 *m_jvs_sdata;
|
||||
UINT32 m_jvs_sdata_ptr;
|
||||
emu_timer *m_sound_irq_timer;
|
||||
@ -622,7 +626,7 @@ WRITE32_MEMBER(hornet_state::gun_w)
|
||||
/*****************************************************************************/
|
||||
|
||||
static ADDRESS_MAP_START( hornet_map, AS_PROGRAM, 32, hornet_state )
|
||||
AM_RANGE(0x00000000, 0x003fffff) AM_RAM AM_BASE(m_workram) /* Work RAM */
|
||||
AM_RANGE(0x00000000, 0x003fffff) AM_RAM AM_SHARE("workram") /* Work RAM */
|
||||
AM_RANGE(0x74000000, 0x740000ff) AM_READWRITE(hornet_k037122_reg_r, hornet_k037122_reg_w)
|
||||
AM_RANGE(0x74020000, 0x7403ffff) AM_READWRITE(hornet_k037122_sram_r, hornet_k037122_sram_w)
|
||||
AM_RANGE(0x74040000, 0x7407ffff) AM_READWRITE(hornet_k037122_char_r, hornet_k037122_char_w)
|
||||
@ -699,27 +703,27 @@ ADDRESS_MAP_END
|
||||
|
||||
READ32_MEMBER(hornet_state::dsp_dataram0_r)
|
||||
{
|
||||
return m_sharc_dataram[0][offset] & 0xffff;
|
||||
return m_sharc_dataram0[offset] & 0xffff;
|
||||
}
|
||||
|
||||
WRITE32_MEMBER(hornet_state::dsp_dataram0_w)
|
||||
{
|
||||
m_sharc_dataram[0][offset] = data;
|
||||
m_sharc_dataram0[offset] = data;
|
||||
}
|
||||
|
||||
READ32_MEMBER(hornet_state::dsp_dataram1_r)
|
||||
{
|
||||
return m_sharc_dataram[1][offset] & 0xffff;
|
||||
return m_sharc_dataram1[offset] & 0xffff;
|
||||
}
|
||||
|
||||
WRITE32_MEMBER(hornet_state::dsp_dataram1_w)
|
||||
{
|
||||
m_sharc_dataram[1][offset] = data;
|
||||
m_sharc_dataram1[offset] = data;
|
||||
}
|
||||
|
||||
static ADDRESS_MAP_START( sharc0_map, AS_DATA, 32, hornet_state )
|
||||
AM_RANGE(0x0400000, 0x041ffff) AM_READWRITE_LEGACY(cgboard_0_shared_sharc_r, cgboard_0_shared_sharc_w)
|
||||
AM_RANGE(0x0500000, 0x05fffff) AM_READWRITE(dsp_dataram0_r, dsp_dataram0_w) AM_BASE(m_sharc_dataram[0])
|
||||
AM_RANGE(0x0500000, 0x05fffff) AM_READWRITE(dsp_dataram0_r, dsp_dataram0_w) AM_SHARE("sharc_dataram0")
|
||||
AM_RANGE(0x1400000, 0x14fffff) AM_RAM
|
||||
AM_RANGE(0x2400000, 0x27fffff) AM_DEVREADWRITE_LEGACY("voodoo0", voodoo_r, voodoo_w)
|
||||
AM_RANGE(0x3400000, 0x34000ff) AM_READWRITE_LEGACY(cgboard_0_comm_sharc_r, cgboard_0_comm_sharc_w)
|
||||
@ -729,7 +733,7 @@ ADDRESS_MAP_END
|
||||
|
||||
static ADDRESS_MAP_START( sharc1_map, AS_DATA, 32, hornet_state )
|
||||
AM_RANGE(0x0400000, 0x041ffff) AM_READWRITE_LEGACY(cgboard_1_shared_sharc_r, cgboard_1_shared_sharc_w)
|
||||
AM_RANGE(0x0500000, 0x05fffff) AM_READWRITE(dsp_dataram1_r, dsp_dataram1_w) AM_BASE(m_sharc_dataram[1])
|
||||
AM_RANGE(0x0500000, 0x05fffff) AM_READWRITE(dsp_dataram1_r, dsp_dataram1_w) AM_SHARE("sharc_dataram1")
|
||||
AM_RANGE(0x1400000, 0x14fffff) AM_RAM
|
||||
AM_RANGE(0x2400000, 0x27fffff) AM_DEVREADWRITE_LEGACY("voodoo1", voodoo_r, voodoo_w)
|
||||
AM_RANGE(0x3400000, 0x34000ff) AM_READWRITE_LEGACY(cgboard_1_comm_sharc_r, cgboard_1_comm_sharc_w)
|
||||
|
||||
@ -93,23 +93,32 @@ class rabbit_state : public driver_device
|
||||
{
|
||||
public:
|
||||
rabbit_state(const machine_config &mconfig, device_type type, const char *tag)
|
||||
: driver_device(mconfig, type, tag) { }
|
||||
: driver_device(mconfig, type, tag),
|
||||
m_viewregs0(*this, "viewregs0"),
|
||||
m_viewregs6(*this, "viewregs6"),
|
||||
m_viewregs7(*this, "viewregs7"),
|
||||
m_viewregs9(*this, "viewregs9"),
|
||||
m_viewregs10(*this, "viewregs10"),
|
||||
m_tilemap_regs(*this, "tilemap_regs"),
|
||||
m_spriteregs(*this, "spriteregs"),
|
||||
m_blitterregs(*this, "blitterregs"),
|
||||
m_spriteram(*this, "spriteram") { }
|
||||
|
||||
UINT32 *m_viewregs0;
|
||||
UINT32 *m_viewregs6;
|
||||
UINT32 *m_viewregs7;
|
||||
UINT32 *m_viewregs9;
|
||||
UINT32 *m_viewregs10;
|
||||
UINT32 *m_tilemap_regs[4];
|
||||
UINT32 *m_spriteregs;
|
||||
UINT32 *m_blitterregs;
|
||||
required_shared_ptr<UINT32> m_viewregs0;
|
||||
required_shared_ptr<UINT32> m_viewregs6;
|
||||
required_shared_ptr<UINT32> m_viewregs7;
|
||||
required_shared_ptr<UINT32> m_viewregs9;
|
||||
required_shared_ptr<UINT32> m_viewregs10;
|
||||
required_shared_ptr_array<UINT32, 4> m_tilemap_regs;
|
||||
required_shared_ptr<UINT32> m_spriteregs;
|
||||
required_shared_ptr<UINT32> m_blitterregs;
|
||||
bitmap_ind16 *m_sprite_bitmap;
|
||||
rectangle m_sprite_clip;
|
||||
int m_vblirqlevel;
|
||||
int m_bltirqlevel;
|
||||
int m_banking;
|
||||
UINT32 *m_tilemap_ram[4];
|
||||
UINT32 *m_spriteram;
|
||||
required_shared_ptr<UINT32> m_spriteram;
|
||||
tilemap_t *m_tilemap[4];
|
||||
DECLARE_WRITE32_MEMBER(rabbit_tilemap0_w);
|
||||
DECLARE_WRITE32_MEMBER(rabbit_tilemap1_w);
|
||||
@ -747,20 +756,20 @@ static ADDRESS_MAP_START( rabbit_map, AS_PROGRAM, 32, rabbit_state )
|
||||
AM_RANGE(0x400980, 0x400983) AM_READ(randomrabbits) // sound chip status?
|
||||
AM_RANGE(0x400984, 0x400987) AM_READ(randomrabbits) // sound chip status?
|
||||
/* this lot are probably gfxchip/blitter etc. related */
|
||||
AM_RANGE(0x400010, 0x400013) AM_WRITEONLY AM_BASE(m_viewregs0 )
|
||||
AM_RANGE(0x400100, 0x400117) AM_WRITEONLY AM_BASE(m_tilemap_regs[0] ) // tilemap regs1
|
||||
AM_RANGE(0x400120, 0x400137) AM_WRITEONLY AM_BASE(m_tilemap_regs[1] ) // tilemap regs2
|
||||
AM_RANGE(0x400140, 0x400157) AM_WRITEONLY AM_BASE(m_tilemap_regs[2] ) // tilemap regs3
|
||||
AM_RANGE(0x400160, 0x400177) AM_WRITEONLY AM_BASE(m_tilemap_regs[3] ) // tilemap regs4
|
||||
AM_RANGE(0x400200, 0x40021b) AM_WRITEONLY AM_BASE(m_spriteregs ) // sprregs?
|
||||
AM_RANGE(0x400010, 0x400013) AM_WRITEONLY AM_SHARE("viewregs0" )
|
||||
AM_RANGE(0x400100, 0x400117) AM_WRITEONLY AM_SHARE("tilemap_regs.0" ) // tilemap regs1
|
||||
AM_RANGE(0x400120, 0x400137) AM_WRITEONLY AM_SHARE("tilemap_regs.1" ) // tilemap regs2
|
||||
AM_RANGE(0x400140, 0x400157) AM_WRITEONLY AM_SHARE("tilemap_regs.2" ) // tilemap regs3
|
||||
AM_RANGE(0x400160, 0x400177) AM_WRITEONLY AM_SHARE("tilemap_regs.3" ) // tilemap regs4
|
||||
AM_RANGE(0x400200, 0x40021b) AM_WRITEONLY AM_SHARE("spriteregs" ) // sprregs?
|
||||
AM_RANGE(0x400300, 0x400303) AM_WRITE(rabbit_rombank_w) // used during rom testing, rombank/area select + something else?
|
||||
AM_RANGE(0x400400, 0x400413) AM_WRITEONLY AM_BASE(m_viewregs6 ) // some global controls? (brightness etc.?)
|
||||
AM_RANGE(0x400500, 0x400503) AM_WRITEONLY AM_BASE(m_viewregs7 )
|
||||
AM_RANGE(0x400700, 0x40070f) AM_WRITE(rabbit_blitter_w) AM_BASE(m_blitterregs )
|
||||
AM_RANGE(0x400800, 0x40080f) AM_WRITEONLY AM_BASE(m_viewregs9 ) // never changes?
|
||||
AM_RANGE(0x400400, 0x400413) AM_WRITEONLY AM_SHARE("viewregs6" ) // some global controls? (brightness etc.?)
|
||||
AM_RANGE(0x400500, 0x400503) AM_WRITEONLY AM_SHARE("viewregs7" )
|
||||
AM_RANGE(0x400700, 0x40070f) AM_WRITE(rabbit_blitter_w) AM_SHARE("blitterregs" )
|
||||
AM_RANGE(0x400800, 0x40080f) AM_WRITEONLY AM_SHARE("viewregs9" ) // never changes?
|
||||
AM_RANGE(0x400900, 0x40098f) AM_WRITE(rabbit_audio_w)
|
||||
/* hmm */
|
||||
AM_RANGE(0x479700, 0x479713) AM_WRITEONLY AM_BASE(m_viewregs10 )
|
||||
AM_RANGE(0x479700, 0x479713) AM_WRITEONLY AM_SHARE("viewregs10" )
|
||||
|
||||
AM_RANGE(0x440000, 0x47ffff) AM_ROMBANK("bank1") // data (gfx / sound) rom readback for ROM testing
|
||||
/* tilemaps */
|
||||
@ -768,7 +777,7 @@ static ADDRESS_MAP_START( rabbit_map, AS_PROGRAM, 32, rabbit_state )
|
||||
AM_RANGE(0x484000, 0x487fff) AM_READWRITE(rabbit_tilemap1_r,rabbit_tilemap1_w)
|
||||
AM_RANGE(0x488000, 0x48bfff) AM_READWRITE(rabbit_tilemap2_r,rabbit_tilemap2_w)
|
||||
AM_RANGE(0x48c000, 0x48ffff) AM_READWRITE(rabbit_tilemap3_r,rabbit_tilemap3_w)
|
||||
AM_RANGE(0x494000, 0x497fff) AM_RAM AM_BASE(m_spriteram) // sprites?
|
||||
AM_RANGE(0x494000, 0x497fff) AM_RAM AM_SHARE("spriteram") // sprites?
|
||||
AM_RANGE(0x4a0000, 0x4affff) AM_RAM_WRITE(rabbit_paletteram_dword_w) AM_SHARE("paletteram")
|
||||
AM_RANGE(0xff0000, 0xffffff) AM_RAM
|
||||
ADDRESS_MAP_END
|
||||
|
||||
@ -39,12 +39,15 @@ class tmmjprd_state : public driver_device
|
||||
{
|
||||
public:
|
||||
tmmjprd_state(const machine_config &mconfig, device_type type, const char *tag)
|
||||
: driver_device(mconfig, type, tag) { }
|
||||
: driver_device(mconfig, type, tag),
|
||||
m_tilemap_regs(*this, "tilemap_regs"),
|
||||
m_spriteregs(*this, "spriteregs"),
|
||||
m_spriteram(*this, "spriteram") { }
|
||||
|
||||
UINT32 *m_tilemap_regs[4];
|
||||
UINT32 *m_spriteregs;
|
||||
required_shared_ptr_array<UINT32, 4> m_tilemap_regs;
|
||||
required_shared_ptr<UINT32> m_spriteregs;
|
||||
UINT32 *m_tilemap_ram[4];
|
||||
UINT32 *m_spriteram;
|
||||
required_shared_ptr<UINT32> m_spriteram;
|
||||
UINT8 m_mux_data;
|
||||
UINT8 m_system_in;
|
||||
double m_old_brt1;
|
||||
@ -672,11 +675,11 @@ static ADDRESS_MAP_START( tmmjprd_map, AS_PROGRAM, 32, tmmjprd_state )
|
||||
AM_RANGE(0x200984, 0x200987) AM_READ(randomtmmjprds) // sound chip status?
|
||||
/* check these are used .. */
|
||||
// AM_RANGE(0x200010, 0x200013) AM_WRITEONLY AM_BASE_LEGACY(&tmmjprd_viewregs0 )
|
||||
AM_RANGE(0x200100, 0x200117) AM_WRITEONLY AM_BASE(m_tilemap_regs[0] ) // tilemap regs1
|
||||
AM_RANGE(0x200120, 0x200137) AM_WRITEONLY AM_BASE(m_tilemap_regs[1] ) // tilemap regs2
|
||||
AM_RANGE(0x200140, 0x200157) AM_WRITEONLY AM_BASE(m_tilemap_regs[2] ) // tilemap regs3
|
||||
AM_RANGE(0x200160, 0x200177) AM_WRITEONLY AM_BASE(m_tilemap_regs[3] ) // tilemap regs4
|
||||
AM_RANGE(0x200200, 0x20021b) AM_WRITEONLY AM_BASE(m_spriteregs ) // sprregs?
|
||||
AM_RANGE(0x200100, 0x200117) AM_WRITEONLY AM_SHARE("tilemap_regs.0" ) // tilemap regs1
|
||||
AM_RANGE(0x200120, 0x200137) AM_WRITEONLY AM_SHARE("tilemap_regs.1" ) // tilemap regs2
|
||||
AM_RANGE(0x200140, 0x200157) AM_WRITEONLY AM_SHARE("tilemap_regs.2" ) // tilemap regs3
|
||||
AM_RANGE(0x200160, 0x200177) AM_WRITEONLY AM_SHARE("tilemap_regs.3" ) // tilemap regs4
|
||||
AM_RANGE(0x200200, 0x20021b) AM_WRITEONLY AM_SHARE("spriteregs" ) // sprregs?
|
||||
// AM_RANGE(0x200300, 0x200303) AM_WRITE_LEGACY(tmmjprd_rombank_w) // used during rom testing, rombank/area select + something else?
|
||||
AM_RANGE(0x20040c, 0x20040f) AM_WRITE(tmmjprd_brt_1_w)
|
||||
AM_RANGE(0x200410, 0x200413) AM_WRITE(tmmjprd_brt_2_w)
|
||||
@ -692,7 +695,7 @@ static ADDRESS_MAP_START( tmmjprd_map, AS_PROGRAM, 32, tmmjprd_state )
|
||||
AM_RANGE(0x288000, 0x28bfff) AM_READWRITE(tmmjprd_tilemap2_r,tmmjprd_tilemap2_w)
|
||||
AM_RANGE(0x28c000, 0x28ffff) AM_READWRITE(tmmjprd_tilemap3_r,tmmjprd_tilemap3_w)
|
||||
/* ?? is palette ram shared with sprites in this case or just a different map */
|
||||
AM_RANGE(0x290000, 0x29bfff) AM_RAM AM_BASE(m_spriteram)
|
||||
AM_RANGE(0x290000, 0x29bfff) AM_RAM AM_SHARE("spriteram")
|
||||
AM_RANGE(0x29c000, 0x29ffff) AM_RAM_WRITE(tmmjprd_paletteram_dword_w) AM_SHARE("paletteram")
|
||||
|
||||
AM_RANGE(0x400000, 0x400003) AM_READ(tmmjprd_mux_r) AM_DEVWRITE_LEGACY("eeprom", tmmjprd_eeprom_write)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user