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

Memory handler normalization, part 1.

Browse Source 
READ/WRITE_DEVICE*_HANDLERs are now passed an
address_space &, and the 8-bit variants get a mem_mask
as well. This means they are now directly compatible
with the member function delegates. Added a generic
address space to the driver_device that can be used
when no specific address space is available. Also
added DECLARE_READ/WRITE_DEVICE*_HANDLER macros to
declare device callbacks with default mem_mask
parameters. [Aaron Giles]
This commit is contained in:
Aaron Giles 2012-09-17 07:43:37 +00:00
parent e25c13f253
commit cc16777cce
783 changed files with 4861 additions and 4769 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
src/emu/addrmap.c
View File

@ -66,18 +66,10 @@ address_map_entry::address_map_entry(address_map &map, offs_t start, offs_t end)
m_rspace16(NULL), m_rspace16(NULL),
m_rspace32(NULL), m_rspace32(NULL),
m_rspace64(NULL), m_rspace64(NULL),
m_rdevice8(NULL),
m_rdevice16(NULL),
m_rdevice32(NULL),
m_rdevice64(NULL),
m_wspace8(NULL), m_wspace8(NULL),
m_wspace16(NULL), m_wspace16(NULL),
m_wspace32(NULL), m_wspace32(NULL),
m_wspace64(NULL), m_wspace64(NULL),
m_wdevice8(NULL),
m_wdevice16(NULL),
m_wdevice32(NULL),
m_wdevice64(NULL),
m_memory(NULL), m_memory(NULL),
m_bytestart(0), m_bytestart(0),
m_byteend(0), m_byteend(0),
@ -234,39 +226,6 @@ void address_map_entry::internal_set_handler(read8_space_func rfunc, const char
} }
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(8, unitmask, string));
m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_read.m_bits = 8;
m_read.m_mask = unitmask;
m_read.m_name = string;
device.subtag(m_read.m_tag, tag);
m_rdevice8 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(8, unitmask, string));
m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_write.m_bits = 8;
m_write.m_mask = unitmask;
m_write.m_name = string;
device.subtag(m_write.m_tag, tag);
m_wdevice8 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 unitmask)
{
internal_set_handler(device, tag, rfunc, rstring, unitmask);
internal_set_handler(device, tag, wfunc, wstring, unitmask);
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 unitmask) void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
@ -336,39 +295,6 @@ void address_map_entry::internal_set_handler(read16_space_func rfunc, const char
} }
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(16, unitmask, string));
m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_read.m_bits = 16;
m_read.m_mask = unitmask;
m_read.m_name = string;
device.subtag(m_read.m_tag, tag);
m_rdevice16 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(16, unitmask, string));
m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_write.m_bits = 16;
m_write.m_mask = unitmask;
m_write.m_name = string;
device.subtag(m_write.m_tag, tag);
m_wdevice16 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 unitmask)
{
internal_set_handler(device, tag, rfunc, rstring, unitmask);
internal_set_handler(device, tag, wfunc, wstring, unitmask);
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 unitmask) void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
@ -438,39 +364,6 @@ void address_map_entry::internal_set_handler(read32_space_func rfunc, const char
} }
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(32, unitmask, string));
m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_read.m_bits = 32;
m_read.m_mask = unitmask;
m_read.m_name = string;
device.subtag(m_read.m_tag, tag);
m_rdevice32 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(32, unitmask, string));
m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_write.m_bits = 32;
m_write.m_mask = unitmask;
m_write.m_name = string;
device.subtag(m_write.m_tag, tag);
m_wdevice32 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 unitmask)
{
internal_set_handler(device, tag, rfunc, rstring, unitmask);
internal_set_handler(device, tag, wfunc, wstring, unitmask);
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 unitmask) void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());
@ -540,39 +433,6 @@ void address_map_entry::internal_set_handler(read64_space_func rfunc, const char
} }
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read64_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(64, unitmask, string));
m_read.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_read.m_bits = 64;
m_read.m_mask = 0;
m_read.m_name = string;
device.subtag(m_read.m_tag, tag);
m_rdevice64 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, write64_device_func func, const char *string, UINT64 unitmask)
{
assert(func != NULL);
assert(unitmask_is_appropriate(64, unitmask, string));
m_write.m_type = AMH_LEGACY_DEVICE_HANDLER;
m_write.m_bits = 64;
m_write.m_mask = 0;
m_write.m_name = string;
device.subtag(m_write.m_tag, tag);
m_wdevice64 = func;
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring, UINT64 unitmask)
{
internal_set_handler(device, tag, rfunc, rstring, unitmask);
internal_set_handler(device, tag, wfunc, wstring, unitmask);
}
void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 unitmask) void address_map_entry::internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 unitmask)
{ {
assert(!func.isnull()); assert(!func.isnull());

69
src/emu/addrmap.h
View File

@ -62,7 +62,6 @@ enum map_handler_type
AMH_UNMAP, AMH_UNMAP,
AMH_DEVICE_DELEGATE, AMH_DEVICE_DELEGATE,
AMH_LEGACY_SPACE_HANDLER, AMH_LEGACY_SPACE_HANDLER,
AMH_LEGACY_DEVICE_HANDLER,
AMH_PORT, AMH_PORT,
AMH_BANK, AMH_BANK,
AMH_DEVICE_SUBMAP AMH_DEVICE_SUBMAP
@ -160,10 +159,6 @@ public:
read16_space_func m_rspace16; // 16-bit legacy address space handler read16_space_func m_rspace16; // 16-bit legacy address space handler
read32_space_func m_rspace32; // 32-bit legacy address space handler read32_space_func m_rspace32; // 32-bit legacy address space handler
read64_space_func m_rspace64; // 64-bit legacy address space handler read64_space_func m_rspace64; // 64-bit legacy address space handler
read8_device_func m_rdevice8; // 8-bit legacy device handler
read16_device_func m_rdevice16; // 16-bit legacy device handler
read32_device_func m_rdevice32; // 32-bit legacy device handler
read64_device_func m_rdevice64; // 64-bit legacy device handler
write8_delegate m_wproto8; // 8-bit write proto-delegate write8_delegate m_wproto8; // 8-bit write proto-delegate
write16_delegate m_wproto16; // 16-bit write proto-delegate write16_delegate m_wproto16; // 16-bit write proto-delegate
write32_delegate m_wproto32; // 32-bit write proto-delegate write32_delegate m_wproto32; // 32-bit write proto-delegate
@ -172,10 +167,6 @@ public:
write16_space_func m_wspace16; // 16-bit legacy address space handler write16_space_func m_wspace16; // 16-bit legacy address space handler
write32_space_func m_wspace32; // 32-bit legacy address space handler write32_space_func m_wspace32; // 32-bit legacy address space handler
write64_space_func m_wspace64; // 64-bit legacy address space handler write64_space_func m_wspace64; // 64-bit legacy address space handler
write8_device_func m_wdevice8; // 8-bit legacy device handler
write16_device_func m_wdevice16; // 16-bit legacy device handler
write32_device_func m_wdevice32; // 32-bit legacy device handler
write64_device_func m_wdevice64; // 64-bit legacy device handler
address_map_delegate m_submap_delegate; address_map_delegate m_submap_delegate;
int m_submap_bits; int m_submap_bits;
@ -195,9 +186,6 @@ protected:
void internal_set_handler(read8_space_func func, const char *string, UINT64 mask); void internal_set_handler(read8_space_func func, const char *string, UINT64 mask);
void internal_set_handler(write8_space_func func, const char *string, UINT64 mask); void internal_set_handler(write8_space_func func, const char *string, UINT64 mask);
void internal_set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask); void internal_set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask);
@ -206,9 +194,6 @@ protected:
void internal_set_handler(read16_space_func func, const char *string, UINT64 mask); void internal_set_handler(read16_space_func func, const char *string, UINT64 mask);
void internal_set_handler(write16_space_func func, const char *string, UINT64 mask); void internal_set_handler(write16_space_func func, const char *string, UINT64 mask);
void internal_set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask); void internal_set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask);
@ -217,9 +202,6 @@ protected:
void internal_set_handler(read32_space_func func, const char *string, UINT64 mask); void internal_set_handler(read32_space_func func, const char *string, UINT64 mask);
void internal_set_handler(write32_space_func func, const char *string, UINT64 mask); void internal_set_handler(write32_space_func func, const char *string, UINT64 mask);
void internal_set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask); void internal_set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask);
@ -228,9 +210,6 @@ protected:
void internal_set_handler(read64_space_func func, const char *string, UINT64 mask); void internal_set_handler(read64_space_func func, const char *string, UINT64 mask);
void internal_set_handler(write64_space_func func, const char *string, UINT64 mask); void internal_set_handler(write64_space_func func, const char *string, UINT64 mask);
void internal_set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring, UINT64 mask); void internal_set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read64_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write64_device_func func, const char *string, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, write64_delegate func, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, write64_delegate func, UINT64 mask);
void internal_set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc, UINT64 mask); void internal_set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc, UINT64 mask);
@ -255,9 +234,6 @@ public:
void set_handler(read8_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(read8_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(write8_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(write8_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read8_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, read8_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, write8_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, write8_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
@ -278,9 +254,6 @@ public:
void set_handler(read16_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(read16_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(write16_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(write16_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read16_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, read16_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, write16_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, write16_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
@ -289,9 +262,6 @@ public:
void set_handler(read8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); } void set_handler(read8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); }
void set_handler(write8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); } void set_handler(write8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); }
void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT16 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT16 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT16 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT16 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
@ -312,9 +282,6 @@ public:
void set_handler(read32_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(read32_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(write32_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(write32_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read32_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, read32_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, write32_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, write32_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
@ -323,9 +290,6 @@ public:
void set_handler(read16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } void set_handler(read16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
void set_handler(write16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } void set_handler(write16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
@ -334,9 +298,6 @@ public:
void set_handler(read8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } void set_handler(read8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
void set_handler(write8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } void set_handler(write8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); }
void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
@ -357,9 +318,6 @@ public:
void set_handler(read64_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(read64_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(write64_space_func func, const char *string) { internal_set_handler(func, string, 0); } void set_handler(write64_space_func func, const char *string) { internal_set_handler(func, string, 0); }
void set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } void set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read64_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, write64_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); }
void set_handler(const device_t &device, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); }
void set_handler(const device_t &device, const char *tag, read64_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, read64_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, write64_delegate func) { internal_set_handler(device, tag, func, 0); } void set_handler(const device_t &device, const char *tag, write64_delegate func) { internal_set_handler(device, tag, func, 0); }
void set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } void set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); }
@ -368,9 +326,6 @@ public:
void set_handler(read32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } void set_handler(read32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
void set_handler(write32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } void set_handler(write32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
@ -379,9 +334,6 @@ public:
void set_handler(read16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } void set_handler(read16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
void set_handler(write16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } void set_handler(write16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
@ -390,9 +342,6 @@ public:
void set_handler(read8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } void set_handler(read8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
void set_handler(write8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } void set_handler(write8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); }
void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); }
void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); }
void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); }
void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); }
@ -546,38 +495,38 @@ void _class :: _name(address_map &map, const device_t &device) \
// legacy device reads // legacy device reads
#define AM_DEVREAD_LEGACY(_tag, _handler) \ #define AM_DEVREAD_LEGACY(_tag, _handler) \
curentry->set_handler(device, _tag, _handler, #_handler); \ curentry->set_handler(device, _tag, read_delegate(&_handler, #_handler, (device_t *)0)); \
#define AM_DEVREAD8_LEGACY(_tag, _handler, _unitmask) \ #define AM_DEVREAD8_LEGACY(_tag, _handler, _unitmask) \
curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ curentry->set_handler(device, _tag, read8_delegate(&_handler, #_handler, (device_t *)0), _unitmask); \
// legacy device writes // legacy device writes
#define AM_DEVWRITE_LEGACY(_tag, _handler) \ #define AM_DEVWRITE_LEGACY(_tag, _handler) \
curentry->set_handler(device, _tag, _handler, #_handler); \ curentry->set_handler(device, _tag, write_delegate(&_handler, #_handler, (device_t *)0)); \
#define AM_DEVWRITE8_LEGACY(_tag, _handler, _unitmask) \ #define AM_DEVWRITE8_LEGACY(_tag, _handler, _unitmask) \
curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ curentry->set_handler(device, _tag, write8_delegate(&_handler, #_handler, (device_t *)0), _unitmask); \
#define AM_DEVWRITE16_LEGACY(_tag, _handler, _unitmask) \ #define AM_DEVWRITE16_LEGACY(_tag, _handler, _unitmask) \
curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ curentry->set_handler(device, _tag, write16_delegate(&_handler, #_handler, (device_t *)0), _unitmask); \
// legacy device reads/writes // legacy device reads/writes
#define AM_DEVREADWRITE_LEGACY(_tag, _rhandler, _whandler) \ #define AM_DEVREADWRITE_LEGACY(_tag, _rhandler, _whandler) \
curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler); \ curentry->set_handler(device, _tag, read_delegate(&_rhandler, #_rhandler, (device_t *)0), write_delegate(&_whandler, #_whandler, (device_t *)0)); \
#define AM_DEVREADWRITE8_LEGACY(_tag, _rhandler, _whandler, _unitmask) \ #define AM_DEVREADWRITE8_LEGACY(_tag, _rhandler, _whandler, _unitmask) \
curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ curentry->set_handler(device, _tag, read8_delegate(&_rhandler, #_rhandler, (device_t *)0), write8_delegate(&_whandler, #_whandler, (device_t *)0), _unitmask); \
#define AM_DEVREADWRITE16_LEGACY(_tag, _rhandler, _whandler, _unitmask) \ #define AM_DEVREADWRITE16_LEGACY(_tag, _rhandler, _whandler, _unitmask) \
curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ curentry->set_handler(device, _tag, read16_delegate(&_rhandler, #_rhandler, (device_t *)0), write16_delegate(&_whandler, #_whandler, (device_t *)0), _unitmask); \
#define AM_DEVREADWRITE32_LEGACY(_tag, _rhandler, _whandler, _unitmask) \ #define AM_DEVREADWRITE32_LEGACY(_tag, _rhandler, _whandler, _unitmask) \
curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ curentry->set_handler(device, _tag, read32_delegate(&_rhandler, #_rhandler, (device_t *)0), write32_delegate(&_whandler, #_whandler, (device_t *)0), _unitmask); \
// driver data reads // driver data reads

6
src/emu/cpu/arm7/arm7.c
View File

@ -43,9 +43,9 @@
/* prototypes of coprocessor functions */ /* prototypes of coprocessor functions */
static WRITE32_DEVICE_HANDLER(arm7_do_callback); static DECLARE_WRITE32_DEVICE_HANDLER(arm7_do_callback);
static READ32_DEVICE_HANDLER(arm7_rt_r_callback); static DECLARE_READ32_DEVICE_HANDLER(arm7_rt_r_callback);
static WRITE32_DEVICE_HANDLER(arm7_rt_w_callback); static DECLARE_WRITE32_DEVICE_HANDLER(arm7_rt_w_callback);
void arm7_dt_r_callback(arm_state *cpustate, UINT32 insn, UINT32 *prn, UINT32 (*read32)(arm_state *cpustate, UINT32 addr)); void arm7_dt_r_callback(arm_state *cpustate, UINT32 insn, UINT32 *prn, UINT32 (*read32)(arm_state *cpustate, UINT32 addr));
void arm7_dt_w_callback(arm_state *cpustate, UINT32 insn, UINT32 *prn, void (*write32)(arm_state *cpustate, UINT32 addr, UINT32 data)); void arm7_dt_w_callback(arm_state *cpustate, UINT32 insn, UINT32 *prn, void (*write32)(arm_state *cpustate, UINT32 addr, UINT32 data));

6
src/emu/cpu/arm7/arm7ops.c
View File

@ -283,7 +283,7 @@ static void HandleCoProcDO(arm_state *cpustate, UINT32 insn)
{ {
// This instruction simply instructs the co-processor to do something, no data is returned to ARM7 core // This instruction simply instructs the co-processor to do something, no data is returned to ARM7 core
if (arm7_coproc_do_callback) if (arm7_coproc_do_callback)
arm7_coproc_do_callback(cpustate->device, insn, 0, 0); // simply pass entire opcode to callback - since data format is actually dependent on co-proc implementation arm7_coproc_do_callback(cpustate->device, *cpustate->program, insn, 0, 0); // simply pass entire opcode to callback - since data format is actually dependent on co-proc implementation
else else
LOG(("%08x: Co-Processor Data Operation executed, but no callback defined!\n", R15)); LOG(("%08x: Co-Processor Data Operation executed, but no callback defined!\n", R15));
} }
@ -299,7 +299,7 @@ static void HandleCoProcRT(arm_state *cpustate, UINT32 insn)
{ {
if (arm7_coproc_rt_r_callback) if (arm7_coproc_rt_r_callback)
{ {
UINT32 res = arm7_coproc_rt_r_callback(cpustate->device, insn, 0); // RT Read handler must parse opcode & return appropriate result UINT32 res = arm7_coproc_rt_r_callback(cpustate->device, *cpustate->program, insn, 0); // RT Read handler must parse opcode & return appropriate result
if (cpustate->pendingUnd == 0) if (cpustate->pendingUnd == 0)
{ {
SET_REGISTER(cpustate, (insn >> 12) & 0xf, res); SET_REGISTER(cpustate, (insn >> 12) & 0xf, res);
@ -312,7 +312,7 @@ static void HandleCoProcRT(arm_state *cpustate, UINT32 insn)
else else
{ {
if (arm7_coproc_rt_w_callback) if (arm7_coproc_rt_w_callback)
arm7_coproc_rt_w_callback(cpustate->device, insn, GET_REGISTER(cpustate, (insn >> 12) & 0xf), 0); arm7_coproc_rt_w_callback(cpustate->device, *cpustate->program, insn, GET_REGISTER(cpustate, (insn >> 12) & 0xf), 0);
else else
LOG(("%08x: Co-Processor Register Transfer executed, but no RT Write callback defined!\n", R15)); LOG(("%08x: Co-Processor Register Transfer executed, but no RT Write callback defined!\n", R15));
} }

8
src/emu/cpu/cubeqcpu/cubeqcpu.h
View File

@ -139,11 +139,11 @@ struct cubeqst_rot_config
PUBLIC FUNCTIONS PUBLIC FUNCTIONS
***************************************************************************/ ***************************************************************************/
extern READ16_DEVICE_HANDLER( cubeqcpu_sndram_r ); extern DECLARE_READ16_DEVICE_HANDLER( cubeqcpu_sndram_r );
extern WRITE16_DEVICE_HANDLER( cubeqcpu_sndram_w ); extern DECLARE_WRITE16_DEVICE_HANDLER( cubeqcpu_sndram_w );
extern READ16_DEVICE_HANDLER( cubeqcpu_rotram_r ); extern DECLARE_READ16_DEVICE_HANDLER( cubeqcpu_rotram_r );
extern WRITE16_DEVICE_HANDLER( cubeqcpu_rotram_w ); extern DECLARE_WRITE16_DEVICE_HANDLER( cubeqcpu_rotram_w );
void cubeqcpu_swap_line_banks(device_t *device); void cubeqcpu_swap_line_banks(device_t *device);

6
src/emu/cpu/esrip/esrip.c
View File

@ -1701,7 +1701,7 @@ static CPU_EXECUTE( esrip )
/* FDT RAM: /Enable, Direction and /RAM OE */ /* FDT RAM: /Enable, Direction and /RAM OE */
else if (!bl44 && !_BIT(cpustate->l2, 3) && bl46) else if (!bl44 && !_BIT(cpustate->l2, 3) && bl46)
y_bus = cpustate->fdt_r(device, cpustate->fdt_cnt, 0); y_bus = cpustate->fdt_r(device, *cpustate->program, cpustate->fdt_cnt, 0);
/* IPT RAM: /Enable and /READ */ /* IPT RAM: /Enable and /READ */
else if (!_BIT(cpustate->l2, 6) && !_BIT(cpustate->l4, 5)) else if (!_BIT(cpustate->l2, 6) && !_BIT(cpustate->l4, 5))
@ -1728,7 +1728,7 @@ static CPU_EXECUTE( esrip )
/* FDT RAM */ /* FDT RAM */
if (!bl44) if (!bl44)
x_bus = cpustate->fdt_r(device, cpustate->fdt_cnt, 0); x_bus = cpustate->fdt_r(device, *cpustate->program, cpustate->fdt_cnt, 0);
/* Buffer is enabled - write direction */ /* Buffer is enabled - write direction */
else if (!BIT(cpustate->l2, 3) && !bl46) else if (!BIT(cpustate->l2, 3) && !bl46)
@ -1753,7 +1753,7 @@ static CPU_EXECUTE( esrip )
/* Write FDT RAM: /Enable, Direction and WRITE */ /* Write FDT RAM: /Enable, Direction and WRITE */
if (!BIT(cpustate->l2, 3) && !bl46 && !BIT(cpustate->l4, 3)) if (!BIT(cpustate->l2, 3) && !bl46 && !BIT(cpustate->l4, 3))
cpustate->fdt_w(device, cpustate->fdt_cnt, x_bus, 0); cpustate->fdt_w(device, *cpustate->program, cpustate->fdt_cnt, x_bus, 0);
/* Write IPT RAM: /Enable and /WR */ /* Write IPT RAM: /Enable and /WR */
if (!BIT(cpustate->l2, 7) && !BIT(cpustate->l4, 5)) if (!BIT(cpustate->l2, 7) && !BIT(cpustate->l4, 5))

4
src/emu/cpu/m68000/68307ser.c
View File

@ -24,7 +24,7 @@ READ8_HANDLER( m68307_internal_serial_r )
// if we're piggybacking on the existing 68681 implementation... // if we're piggybacking on the existing 68681 implementation...
if (serial->m_duart68681) if (serial->m_duart68681)
{ {
if (offset&1) return duart68681_r(serial->m_duart68681, offset>>1); if (offset&1) return duart68681_r(serial->m_duart68681, *m68k->program, offset>>1);
} }
else else
{ {
@ -104,7 +104,7 @@ WRITE8_HANDLER( m68307_internal_serial_w )
// if we're piggybacking on the existing 68681 implementation... // if we're piggybacking on the existing 68681 implementation...
if (serial->m_duart68681) if (serial->m_duart68681)
{ {
if (offset&1) duart68681_w(serial->m_duart68681, offset>>1, data); if (offset&1) duart68681_w(serial->m_duart68681, *m68k->program, offset>>1, data);
} }
else else
{ {

4
src/emu/cpu/powerpc/ppccom.c
View File

@ -1121,7 +1121,7 @@ void ppccom_execute_mfdcr(powerpc_state *ppc)
else else
ppc->param1 = 0; ppc->param1 = 0;
} else { } else {
ppc->param1 = ppc->dcr_read_func(ppc->device,ppc->param0,0xffffffff); ppc->param1 = ppc->dcr_read_func(ppc->device,*ppc->program,ppc->param0,0xffffffff);
} }
} }
@ -1211,7 +1211,7 @@ void ppccom_execute_mtdcr(powerpc_state *ppc)
if (ppc->param0 < ARRAY_LENGTH(ppc->dcr)) if (ppc->param0 < ARRAY_LENGTH(ppc->dcr))
ppc->dcr[ppc->param0] = ppc->param1; ppc->dcr[ppc->param0] = ppc->param1;
} else { } else {
ppc->dcr_write_func(ppc->device,ppc->param0,ppc->param1,0xffffffff); ppc->dcr_write_func(ppc->device,*ppc->program,ppc->param0,ppc->param1,0xffffffff);
} }
} }

8
src/emu/cpu/rsp/rspdrc.c
View File

@ -472,14 +472,14 @@ static void cfunc_get_cop0_reg(void *param)
{ {
if(dest) if(dest)
{ {
rsp->r[dest] = (rsp->config->sp_reg_r)(rsp->device, reg, 0x00000000); rsp->r[dest] = (rsp->config->sp_reg_r)(rsp->device, *rsp->program, reg, 0x00000000);
} }
} }
else if (reg >= 8 && reg < 16) else if (reg >= 8 && reg < 16)
{ {
if(dest) if(dest)
{ {
rsp->r[dest] = (rsp->config->dp_reg_r)(rsp->device, reg - 8, 0x00000000); rsp->r[dest] = (rsp->config->dp_reg_r)(rsp->device, *rsp->program, reg - 8, 0x00000000);
} }
} }
else else
@ -496,11 +496,11 @@ static void cfunc_set_cop0_reg(void *param)
if (reg >= 0 && reg < 8) if (reg >= 0 && reg < 8)
{ {
(rsp->config->sp_reg_w)(rsp->device, reg, data, 0x00000000); (rsp->config->sp_reg_w)(rsp->device, *rsp->program, reg, data, 0x00000000);
} }
else if (reg >= 8 && reg < 16) else if (reg >= 8 && reg < 16)
{ {
(rsp->config->dp_reg_w)(rsp->device, reg - 8, data, 0x00000000); (rsp->config->dp_reg_w)(rsp->device, *rsp->program, reg - 8, data, 0x00000000);
} }
else else
{ {

10
src/emu/cpu/tms0980/tms0980.c
View File

@ -766,7 +766,7 @@ static void tms0980_set_cki_bus( device_t *device )
case 0x008: case 0x008:
if ( cpustate->config->read_k ) if ( cpustate->config->read_k )
{ {
cpustate->cki_bus = cpustate->config->read_k( device, 0 ); cpustate->cki_bus = cpustate->config->read_k( device, *cpustate->program, 0, 0xff );
} }
else else
{ {
@ -930,7 +930,7 @@ static CPU_EXECUTE( tms0980 )
cpustate->r = cpustate->r | ( 1 << cpustate->y ); cpustate->r = cpustate->r | ( 1 << cpustate->y );
if ( cpustate->config->write_r ) if ( cpustate->config->write_r )
{ {
cpustate->config->write_r( device, 0, cpustate->r & cpustate->r_mask, 0xffff ); cpustate->config->write_r( device, *cpustate->program, 0, cpustate->r & cpustate->r_mask, 0xffff );
} }
} }
if ( cpustate->decode & F_RSTR ) if ( cpustate->decode & F_RSTR )
@ -938,7 +938,7 @@ static CPU_EXECUTE( tms0980 )
cpustate->r = cpustate->r & ( ~( 1 << cpustate->y ) ); cpustate->r = cpustate->r & ( ~( 1 << cpustate->y ) );
if ( cpustate->config->write_r ) if ( cpustate->config->write_r )
{ {
cpustate->config->write_r( device, 0, cpustate->r & cpustate->r_mask, 0xffff ); cpustate->config->write_r( device, *cpustate->program, 0, cpustate->r & cpustate->r_mask, 0xffff );
} }
} }
if ( cpustate->decode & F_TDO ) if ( cpustate->decode & F_TDO )
@ -957,7 +957,7 @@ static CPU_EXECUTE( tms0980 )
if ( cpustate->config->write_o ) if ( cpustate->config->write_o )
{ {
cpustate->config->write_o( device, 0, cpustate->o & cpustate->o_mask, 0xffff ); cpustate->config->write_o( device, *cpustate->program, 0, cpustate->o & cpustate->o_mask, 0xffff );
} }
} }
if ( cpustate->decode & F_CLO ) if ( cpustate->decode & F_CLO )
@ -965,7 +965,7 @@ static CPU_EXECUTE( tms0980 )
cpustate->o = 0; cpustate->o = 0;
if ( cpustate->config->write_o ) if ( cpustate->config->write_o )
{ {
cpustate->config->write_o( device, 0, cpustate->o & cpustate->o_mask, 0xffff ); cpustate->config->write_o( device, *cpustate->program, 0, cpustate->o & cpustate->o_mask, 0xffff );
} }
} }
if ( cpustate->decode & F_LDX ) if ( cpustate->decode & F_LDX )

68
src/emu/devcb.c
View File

@ -232,7 +232,7 @@ int devcb_resolved_read_line::from_port()
int devcb_resolved_read_line::from_read8() int devcb_resolved_read_line::from_read8()
{ {
return ((*m_helper.read8_device)(m_object.device, 0) & 1) ? ASSERT_LINE : CLEAR_LINE; return ((*m_helper.read8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), 0, 0xff) & 1) ? ASSERT_LINE : CLEAR_LINE;
} }
@ -336,7 +336,7 @@ void devcb_resolved_write_line::to_port(int state)
void devcb_resolved_write_line::to_write8(int state) void devcb_resolved_write_line::to_write8(int state)
{ {
(*m_helper.write8_device)(m_object.device, 0, state); (*m_helper.write8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), 0, state, 0xff);
} }
@ -391,7 +391,10 @@ void devcb_resolved_read8::resolve(const devcb_read8 &desc, device_t &device)
case DEVCB_TYPE_DEVICE: case DEVCB_TYPE_DEVICE:
m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device); m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device);
if (desc.readdevice != NULL) if (desc.readdevice != NULL)
*static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(desc.readdevice, desc.name, m_object.device); {
m_helper.read8_device = desc.readdevice;
*static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(&devcb_resolved_read8::from_read8, desc.name, this);
}
else else
{ {
m_helper.read_line = desc.readline; m_helper.read_line = desc.readline;
@ -428,6 +431,17 @@ UINT8 devcb_resolved_read8::from_port(offs_t offset)
// line read value to an 8-bit value // line read value to an 8-bit value
//------------------------------------------------- //-------------------------------------------------
UINT8 devcb_resolved_read8::from_read8(offs_t offset)
{
return (*m_helper.read8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, 0xff);
}
//-------------------------------------------------
// from_readline - helper to convert from a device
// line read value to an 8-bit value
//-------------------------------------------------
UINT8 devcb_resolved_read8::from_readline(offs_t offset) UINT8 devcb_resolved_read8::from_readline(offs_t offset)
{ {
return (*m_helper.read_line)(m_object.device); return (*m_helper.read_line)(m_object.device);
@ -484,7 +498,10 @@ void devcb_resolved_write8::resolve(const devcb_write8 &desc, device_t &device)
case DEVCB_TYPE_DEVICE: case DEVCB_TYPE_DEVICE:
m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device); m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device);
if (desc.writedevice != NULL) if (desc.writedevice != NULL)
*static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(desc.writedevice, desc.name, m_object.device); {
m_helper.write8_device = desc.writedevice;
*static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(&devcb_resolved_write8::to_write8, desc.name, this);
}
else else
{ {
m_helper.write_line = desc.writeline; m_helper.write_line = desc.writeline;
@ -526,6 +543,17 @@ void devcb_resolved_write8::to_port(offs_t offset, UINT8 data)
} }
//-------------------------------------------------
// to_write8 - helper to convert to an 8-bit
// memory read value from a line value
//-------------------------------------------------
void devcb_resolved_write8::to_write8(offs_t offset, UINT8 data)
{
(*m_helper.write8_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, data, 0xff);
}
//------------------------------------------------- //-------------------------------------------------
// to_write8 - helper to convert to an 8-bit // to_write8 - helper to convert to an 8-bit
// memory read value from a line value // memory read value from a line value
@ -588,7 +616,10 @@ void devcb_resolved_read16::resolve(const devcb_read16 &desc, device_t &device)
case DEVCB_TYPE_DEVICE: case DEVCB_TYPE_DEVICE:
m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device); m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device);
if (desc.readdevice != NULL) if (desc.readdevice != NULL)
*static_cast<devcb_read16_delegate *>(this) = devcb_read16_delegate(desc.readdevice, desc.name, m_object.device); {
m_helper.read16_device = desc.readdevice;
*static_cast<devcb_read16_delegate *>(this) = devcb_read16_delegate(&devcb_resolved_read16::from_read16, desc.name, this);
}
else else
{ {
m_helper.read_line = desc.readline; m_helper.read_line = desc.readline;
@ -620,6 +651,17 @@ UINT16 devcb_resolved_read16::from_port(offs_t offset, UINT16 mask)
} }
//-------------------------------------------------
// from_read16 - helper to convert from a device
// line read value to a 16-bit value
//-------------------------------------------------
UINT16 devcb_resolved_read16::from_read16(offs_t offset, UINT16 mask)
{
return (*m_helper.read16_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, mask);
}
//------------------------------------------------- //-------------------------------------------------
// from_read16 - helper to convert from a device // from_read16 - helper to convert from a device
// line read value to a 16-bit value // line read value to a 16-bit value
@ -681,7 +723,10 @@ void devcb_resolved_write16::resolve(const devcb_write16 &desc, device_t &device
case DEVCB_TYPE_DEVICE: case DEVCB_TYPE_DEVICE:
m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device); m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device);
if (desc.writedevice != NULL) if (desc.writedevice != NULL)
*static_cast<devcb_write16_delegate *>(this) = devcb_write16_delegate(desc.writedevice, desc.name, m_object.device); {
m_helper.write16_device = desc.writedevice;
*static_cast<devcb_write16_delegate *>(this) = devcb_write16_delegate(&devcb_resolved_write16::to_write16, desc.name, this);
}
else else
{ {
m_helper.write_line = desc.writeline; m_helper.write_line = desc.writeline;
@ -723,6 +768,17 @@ void devcb_resolved_write16::to_port(offs_t offset, UINT16 data, UINT16 mask)
} }
//-------------------------------------------------
// to_write16 - helper to convert to a 16-bit
// memory read value from a line value
//-------------------------------------------------
void devcb_resolved_write16::to_write16(offs_t offset, UINT16 data, UINT16 mask)
{
(*m_helper.write16_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, data, mask);
}
//------------------------------------------------- //-------------------------------------------------
// to_write16 - helper to convert to a 16-bit // to_write16 - helper to convert to a 16-bit
// memory read value from a line value // memory read value from a line value

20
src/emu/devcb.h
View File

@ -109,18 +109,18 @@ int devcb_line_stub(device_t *device)
// static template for a read8 stub function that calls through a given READ8_MEMBER // static template for a read8 stub function that calls through a given READ8_MEMBER
template<class _Class, UINT8 (_Class::*_Function)(address_space &, offs_t, UINT8)> template<class _Class, UINT8 (_Class::*_Function)(address_space &, offs_t, UINT8)>
UINT8 devcb_stub(device_t *device, offs_t offset) UINT8 devcb_stub(device_t *device, address_space &space, offs_t offset, UINT8 mem_mask)
{ {
_Class *target = downcast<_Class *>(device); _Class *target = downcast<_Class *>(device);
return (target->*_Function)(*device->machine().memory().first_space(), offset, 0xff); return (target->*_Function)(space, offset, mem_mask);
} }
// static template for a read16 stub function that calls through a given READ16_MEMBER // static template for a read16 stub function that calls through a given READ16_MEMBER
template<class _Class, UINT16 (_Class::*_Function)(address_space &, offs_t, UINT16)> template<class _Class, UINT16 (_Class::*_Function)(address_space &, offs_t, UINT16)>
UINT16 devcb_stub16(device_t *device, offs_t offset, UINT16 mask) UINT16 devcb_stub16(device_t *device, address_space &space, offs_t offset, UINT16 mem_mask)
{ {
_Class *target = downcast<_Class *>(device); _Class *target = downcast<_Class *>(device);
return (target->*_Function)(*device->machine().memory().first_space(), offset, mask); return (target->*_Function)(space, offset, mem_mask);
} }
// static template for a write_line stub function that calls through a given WRITE_LINE_MEMBER // static template for a write_line stub function that calls through a given WRITE_LINE_MEMBER
@ -133,18 +133,18 @@ void devcb_line_stub(device_t *device, int state)
// static template for a write8 stub function that calls through a given WRITE8_MEMBER // static template for a write8 stub function that calls through a given WRITE8_MEMBER
template<class _Class, void (_Class::*_Function)(address_space &, offs_t, UINT8, UINT8)> template<class _Class, void (_Class::*_Function)(address_space &, offs_t, UINT8, UINT8)>
void devcb_stub(device_t *device, offs_t offset, UINT8 data) void devcb_stub(device_t *device, address_space &space, offs_t offset, UINT8 data, UINT8 mem_mask)
{ {
_Class *target = downcast<_Class *>(device); _Class *target = downcast<_Class *>(device);
(target->*_Function)(*device->machine().memory().first_space(), offset, data, 0xff); (target->*_Function)(space, offset, data, mem_mask);
} }
// static template for a write16 stub function that calls through a given WRITE16_MEMBER // static template for a write16 stub function that calls through a given WRITE16_MEMBER
template<class _Class, void (_Class::*_Function)(address_space &, offs_t, UINT16, UINT16)> template<class _Class, void (_Class::*_Function)(address_space &, offs_t, UINT16, UINT16)>
void devcb_stub16(device_t *device, offs_t offset, UINT16 data, UINT16 mask) void devcb_stub16(device_t *device, address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask)
{ {
_Class *target = downcast<_Class *>(device); _Class *target = downcast<_Class *>(device);
(target->*_Function)(*device->machine().memory().first_space(), offset, data, mask); (target->*_Function)(space, offset, data, mem_mask);
} }
#define DEVCB_NULL { DEVCB_TYPE_NULL } #define DEVCB_NULL { DEVCB_TYPE_NULL }
@ -374,6 +374,7 @@ public:
private: private:
// internal helpers // internal helpers
UINT8 from_port(offs_t offset); UINT8 from_port(offs_t offset);
UINT8 from_read8(offs_t offset);
UINT8 from_readline(offs_t offset); UINT8 from_readline(offs_t offset);
UINT8 from_constant(offs_t offset); UINT8 from_constant(offs_t offset);
@ -424,6 +425,7 @@ private:
// internal helpers // internal helpers
void to_null(offs_t offset, UINT8 data); void to_null(offs_t offset, UINT8 data);
void to_port(offs_t offset, UINT8 data); void to_port(offs_t offset, UINT8 data);
void to_write8(offs_t offset, UINT8 data);
void to_writeline(offs_t offset, UINT8 data); void to_writeline(offs_t offset, UINT8 data);
void to_input(offs_t offset, UINT8 data); void to_input(offs_t offset, UINT8 data);
@ -473,6 +475,7 @@ public:
private: private:
// internal helpers // internal helpers
UINT16 from_port(offs_t offset, UINT16 mask); UINT16 from_port(offs_t offset, UINT16 mask);
UINT16 from_read16(offs_t offset, UINT16 mask);
UINT16 from_readline(offs_t offset, UINT16 mask); UINT16 from_readline(offs_t offset, UINT16 mask);
UINT16 from_constant(offs_t offset, UINT16 mask); UINT16 from_constant(offs_t offset, UINT16 mask);
@ -523,6 +526,7 @@ private:
// internal helpers // internal helpers
void to_null(offs_t offset, UINT16 data, UINT16 mask); void to_null(offs_t offset, UINT16 data, UINT16 mask);
void to_port(offs_t offset, UINT16 data, UINT16 mask); void to_port(offs_t offset, UINT16 data, UINT16 mask);
void to_write16(offs_t offset, UINT16 data, UINT16 mask);
void to_writeline(offs_t offset, UINT16 data, UINT16 mask); void to_writeline(offs_t offset, UINT16 data, UINT16 mask);
void to_input(offs_t offset, UINT16 data, UINT16 mask); void to_input(offs_t offset, UINT16 data, UINT16 mask);

208
src/emu/devconv.h
View File

@ -85,23 +85,23 @@
* *
*************************************/ *************************************/
INLINE UINT16 read16be_with_read8_device_handler(read8_device_func handler, device_t *device, offs_t offset, UINT16 mem_mask) INLINE UINT16 read16be_with_read8_device_handler(read8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT16 mem_mask)
{ {
UINT16 result = 0; UINT16 result = 0;
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)
result |= ((UINT16)(*handler)(device, offset * 2 + 0)) << 8; result |= ((UINT16)(*handler)(device, space, offset * 2 + 0, mem_mask >> 8)) << 8;
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
result |= ((UINT16)(*handler)(device, offset * 2 + 1)) << 0; result |= ((UINT16)(*handler)(device, space, offset * 2 + 1, mem_mask >> 0)) << 0;
return result; return result;
} }
INLINE void write16be_with_write8_device_handler(write8_device_func handler, device_t *device, offs_t offset, UINT16 data, UINT16 mem_mask) INLINE void write16be_with_write8_device_handler(write8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask)
{ {
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)
(*handler)(device, offset * 2 + 0, data >> 8); (*handler)(device, space, offset * 2 + 0, data >> 8, mem_mask >> 8);
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
(*handler)(device, offset * 2 + 1, data >> 0); (*handler)(device, space, offset * 2 + 1, data >> 0, mem_mask >> 0);
} }
@ -111,23 +111,23 @@ INLINE void write16be_with_write8_device_handler(write8_device_func handler, dev
* *
*************************************/ *************************************/
INLINE UINT16 read16le_with_read8_device_handler(read8_device_func handler, device_t *device, offs_t offset, UINT16 mem_mask) INLINE UINT16 read16le_with_read8_device_handler(read8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT16 mem_mask)
{ {
UINT16 result = 0; UINT16 result = 0;
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
result |= ((UINT16) (*handler)(device, offset * 2 + 0)) << 0; result |= ((UINT16) (*handler)(device, space, offset * 2 + 0, mem_mask >> 0)) << 0;
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)
result |= ((UINT16) (*handler)(device, offset * 2 + 1)) << 8; result |= ((UINT16) (*handler)(device, space, offset * 2 + 1, mem_mask >> 8)) << 8;
return result; return result;
} }
INLINE void write16le_with_write8_device_handler(write8_device_func handler, device_t *device, offs_t offset, UINT16 data, UINT16 mem_mask) INLINE void write16le_with_write8_device_handler(write8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT16 data, UINT16 mem_mask)
{ {
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
(*handler)(device, offset * 2 + 0, data >> 0); (*handler)(device, space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_8_15) if (ACCESSING_BITS_8_15)
(*handler)(device, offset * 2 + 1, data >> 8); (*handler)(device, space, offset * 2 + 1, data >> 8, mem_mask >> 8);
} }
@ -137,23 +137,23 @@ INLINE void write16le_with_write8_device_handler(write8_device_func handler, dev
* *
*************************************/ *************************************/
INLINE UINT32 read32be_with_read8_device_handler(read8_device_func handler, device_t *device, offs_t offset, UINT32 mem_mask) INLINE UINT32 read32be_with_read8_device_handler(read8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 mem_mask)
{ {
UINT32 result = 0; UINT32 result = 0;
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
result |= read16be_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask >> 16) << 16; result |= read16be_with_read8_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 16) << 16;
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
result |= read16be_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask) << 0; result |= read16be_with_read8_device_handler(handler, device, space, offset * 2 + 1, mem_mask) << 0;
return result; return result;
} }
INLINE void write32be_with_write8_device_handler(write8_device_func handler, device_t *device, offs_t offset, UINT32 data, UINT32 mem_mask) INLINE void write32be_with_write8_device_handler(write8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
write16be_with_write8_device_handler(handler, device, offset * 2 + 0, data >> 16, mem_mask >> 16); write16be_with_write8_device_handler(handler, device, space, offset * 2 + 0, data >> 16, mem_mask >> 16);
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
write16be_with_write8_device_handler(handler, device, offset * 2 + 1, data, mem_mask); write16be_with_write8_device_handler(handler, device, space, offset * 2 + 1, data, mem_mask);
} }
@ -163,23 +163,23 @@ INLINE void write32be_with_write8_device_handler(write8_device_func handler, dev
* *
*************************************/ *************************************/
INLINE UINT32 read32le_with_read8_device_handler(read8_device_func handler, device_t *device, offs_t offset, UINT32 mem_mask) INLINE UINT32 read32le_with_read8_device_handler(read8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 mem_mask)
{ {
UINT32 result = 0; UINT32 result = 0;
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
result |= read16le_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask) << 0; result |= read16le_with_read8_device_handler(handler, device, space, offset * 2 + 0, mem_mask) << 0;
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
result |= read16le_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask >> 16) << 16; result |= read16le_with_read8_device_handler(handler, device, space, offset * 2 + 1, mem_mask >> 16) << 16;
return result; return result;
} }
INLINE void write32le_with_write8_device_handler(write8_device_func handler, device_t *device, offs_t offset, UINT32 data, UINT32 mem_mask) INLINE void write32le_with_write8_device_handler(write8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
write16le_with_write8_device_handler(handler, device, offset * 2 + 0, data, mem_mask); write16le_with_write8_device_handler(handler, device, space, offset * 2 + 0, data, mem_mask);
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
write16le_with_write8_device_handler(handler, device, offset * 2 + 1, data >> 16, mem_mask >> 16); write16le_with_write8_device_handler(handler, device, space, offset * 2 + 1, data >> 16, mem_mask >> 16);
} }
@ -189,23 +189,23 @@ INLINE void write32le_with_write8_device_handler(write8_device_func handler, dev
* *
*************************************/ *************************************/
INLINE UINT32 read32be_with_16be_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT32 mem_mask) INLINE UINT32 read32be_with_16be_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 mem_mask)
{ {
UINT32 result = 0; UINT32 result = 0;
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
result |= (*handler)(device, offset * 2 + 0, mem_mask >> 16) << 16; result |= (*handler)(device, space, offset * 2 + 0, mem_mask >> 16) << 16;
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
result |= (*handler)(device, offset * 2 + 1, mem_mask) << 0; result |= (*handler)(device, space, offset * 2 + 1, mem_mask) << 0;
return result; return result;
} }
INLINE void write32be_with_16be_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT32 data, UINT32 mem_mask) INLINE void write32be_with_16be_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
(*handler)(device, offset * 2 + 0, data >> 16, mem_mask >> 16); (*handler)(device, space, offset * 2 + 0, data >> 16, mem_mask >> 16);
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
(*handler)(device, offset * 2 + 1, data, mem_mask); (*handler)(device, space, offset * 2 + 1, data, mem_mask);
} }
@ -215,23 +215,23 @@ INLINE void write32be_with_16be_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT32 read32le_with_16le_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT32 mem_mask) INLINE UINT32 read32le_with_16le_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 mem_mask)
{ {
UINT32 result = 0; UINT32 result = 0;
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
result |= (*handler)(device, offset * 2 + 0, mem_mask) << 0; result |= (*handler)(device, space, offset * 2 + 0, mem_mask) << 0;
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
result |= (*handler)(device, offset * 2 + 1, mem_mask >> 16) << 16; result |= (*handler)(device, space, offset * 2 + 1, mem_mask >> 16) << 16;
return result; return result;
} }
INLINE void write32le_with_16le_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT32 data, UINT32 mem_mask) INLINE void write32le_with_16le_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
(*handler)(device, offset * 2 + 0, data, mem_mask); (*handler)(device, space, offset * 2 + 0, data, mem_mask);
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
(*handler)(device, offset * 2 + 1, data >> 16, mem_mask >> 16); (*handler)(device, space, offset * 2 + 1, data >> 16, mem_mask >> 16);
} }
@ -241,20 +241,20 @@ INLINE void write32le_with_16le_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT32 read32be_with_16le_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT32 mem_mask) INLINE UINT32 read32be_with_16le_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 mem_mask)
{ {
UINT32 result = 0; UINT32 result = 0;
mem_mask = FLIPENDIAN_INT32(mem_mask); mem_mask = FLIPENDIAN_INT32(mem_mask);
result = read32le_with_16le_device_handler(handler, device, offset, mem_mask); result = read32le_with_16le_device_handler(handler, device, space, offset, mem_mask);
return FLIPENDIAN_INT32(result); return FLIPENDIAN_INT32(result);
} }
INLINE void write32be_with_16le_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT32 data, UINT32 mem_mask) INLINE void write32be_with_16le_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
data = FLIPENDIAN_INT32(data); data = FLIPENDIAN_INT32(data);
mem_mask = FLIPENDIAN_INT32(mem_mask); mem_mask = FLIPENDIAN_INT32(mem_mask);
write32le_with_16le_device_handler(handler, device, offset, data, mem_mask); write32le_with_16le_device_handler(handler, device, space, offset, data, mem_mask);
} }
@ -264,20 +264,20 @@ INLINE void write32be_with_16le_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT32 read32le_with_16be_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT32 mem_mask) INLINE UINT32 read32le_with_16be_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 mem_mask)
{ {
UINT32 result = 0; UINT32 result = 0;
mem_mask = FLIPENDIAN_INT32(mem_mask); mem_mask = FLIPENDIAN_INT32(mem_mask);
result = read32be_with_16be_device_handler(handler, device, offset, mem_mask); result = read32be_with_16be_device_handler(handler, device, space, offset, mem_mask);
return FLIPENDIAN_INT32(result); return FLIPENDIAN_INT32(result);
} }
INLINE void write32le_with_16be_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT32 data, UINT32 mem_mask) INLINE void write32le_with_16be_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
data = FLIPENDIAN_INT32(data); data = FLIPENDIAN_INT32(data);
mem_mask = FLIPENDIAN_INT32(mem_mask); mem_mask = FLIPENDIAN_INT32(mem_mask);
write32be_with_16be_device_handler(handler, device, offset, data, mem_mask); write32be_with_16be_device_handler(handler, device, space, offset, data, mem_mask);
} }
@ -287,23 +287,23 @@ INLINE void write32le_with_16be_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT64 read64be_with_read8_device_handler(read8_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT64 read64be_with_read8_device_handler(read8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)read32be_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask >> 32) << 32; result |= (UINT64)read32be_with_read8_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 32) << 32;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)read32be_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask) << 0; result |= (UINT64)read32be_with_read8_device_handler(handler, device, space, offset * 2 + 1, mem_mask) << 0;
return result; return result;
} }
INLINE void write64be_with_write8_device_handler(write8_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64be_with_write8_device_handler(write8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
write32be_with_write8_device_handler(handler, device, offset * 2 + 0, data >> 32, mem_mask >> 32); write32be_with_write8_device_handler(handler, device, space, offset * 2 + 0, data >> 32, mem_mask >> 32);
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
write32be_with_write8_device_handler(handler, device, offset * 2 + 1, data, mem_mask); write32be_with_write8_device_handler(handler, device, space, offset * 2 + 1, data, mem_mask);
} }
@ -313,23 +313,23 @@ INLINE void write64be_with_write8_device_handler(write8_device_func handler, dev
* *
*************************************/ *************************************/
INLINE UINT64 read64le_with_read8_device_handler(read8_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT64 read64le_with_read8_device_handler(read8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)read32le_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask >> 0) << 0; result |= (UINT64)read32le_with_read8_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 0) << 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)read32le_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask >> 32) << 32; result |= (UINT64)read32le_with_read8_device_handler(handler, device, space, offset * 2 + 1, mem_mask >> 32) << 32;
return result; return result;
} }
INLINE void write64le_with_write8_device_handler(write8_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64le_with_write8_device_handler(write8_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
write32le_with_write8_device_handler(handler, device, offset * 2 + 0, data >> 0, mem_mask >> 0); write32le_with_write8_device_handler(handler, device, space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
write32le_with_write8_device_handler(handler, device, offset * 2 + 1, data >> 32, mem_mask >> 32); write32le_with_write8_device_handler(handler, device, space, offset * 2 + 1, data >> 32, mem_mask >> 32);
} }
@ -339,23 +339,23 @@ INLINE void write64le_with_write8_device_handler(write8_device_func handler, dev
* *
*************************************/ *************************************/
INLINE UINT32 read64be_with_16be_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT32 read64be_with_16be_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)read32be_with_16be_device_handler(handler, device, offset * 2 + 0, mem_mask >> 32) << 32; result |= (UINT64)read32be_with_16be_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 32) << 32;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)read32be_with_16be_device_handler(handler, device, offset * 2 + 1, mem_mask >> 0) << 0; result |= (UINT64)read32be_with_16be_device_handler(handler, device, space, offset * 2 + 1, mem_mask >> 0) << 0;
return result; return result;
} }
INLINE void write64be_with_16be_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64be_with_16be_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
write32be_with_16be_device_handler(handler, device, offset * 2 + 0, data >> 32, mem_mask >> 32); write32be_with_16be_device_handler(handler, device, space, offset * 2 + 0, data >> 32, mem_mask >> 32);
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
write32be_with_16be_device_handler(handler, device, offset * 2 + 1, data >> 0, mem_mask >> 0); write32be_with_16be_device_handler(handler, device, space, offset * 2 + 1, data >> 0, mem_mask >> 0);
} }
@ -365,23 +365,23 @@ INLINE void write64be_with_16be_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT32 read64le_with_16le_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT32 read64le_with_16le_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)read32le_with_16le_device_handler(handler, device, offset * 2 + 0, mem_mask >> 0) << 0; result |= (UINT64)read32le_with_16le_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 0) << 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)read32le_with_16le_device_handler(handler, device, offset * 2 + 1, mem_mask >> 32) << 32; result |= (UINT64)read32le_with_16le_device_handler(handler, device, space, offset * 2 + 1, mem_mask >> 32) << 32;
return result; return result;
} }
INLINE void write64le_with_16le_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64le_with_16le_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
write32le_with_16le_device_handler(handler, device, offset * 2 + 0, data >> 0, mem_mask >> 0); write32le_with_16le_device_handler(handler, device, space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
write32le_with_16le_device_handler(handler, device, offset * 2 + 1, data >> 32, mem_mask >> 32); write32le_with_16le_device_handler(handler, device, space, offset * 2 + 1, data >> 32, mem_mask >> 32);
} }
@ -391,23 +391,23 @@ INLINE void write64le_with_16le_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT32 read64be_with_16le_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT32 read64be_with_16le_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)read32be_with_16le_device_handler(handler, device, offset * 2 + 0, mem_mask >> 32) << 32; result |= (UINT64)read32be_with_16le_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 32) << 32;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)read32be_with_16le_device_handler(handler, device, offset * 2 + 1, mem_mask >> 0) << 0; result |= (UINT64)read32be_with_16le_device_handler(handler, device, space, offset * 2 + 1, mem_mask >> 0) << 0;
return result; return result;
} }
INLINE void write64be_with_16le_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64be_with_16le_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
write32be_with_16le_device_handler(handler, device, offset * 2 + 0, data >> 32, mem_mask >> 32); write32be_with_16le_device_handler(handler, device, space, offset * 2 + 0, data >> 32, mem_mask >> 32);
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
write32be_with_16le_device_handler(handler, device, offset * 2 + 1, data >> 0, mem_mask >> 0); write32be_with_16le_device_handler(handler, device, space, offset * 2 + 1, data >> 0, mem_mask >> 0);
} }
@ -417,23 +417,23 @@ INLINE void write64be_with_16le_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT32 read64le_with_16be_device_handler(read16_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT32 read64le_with_16be_device_handler(read16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)read32le_with_16be_device_handler(handler, device, offset * 2 + 0, mem_mask >> 0) << 0; result |= (UINT64)read32le_with_16be_device_handler(handler, device, space, offset * 2 + 0, mem_mask >> 0) << 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)read32le_with_16be_device_handler(handler, device, offset * 2 + 1, mem_mask >> 32) << 32; result |= (UINT64)read32le_with_16be_device_handler(handler, device, space, offset * 2 + 1, mem_mask >> 32) << 32;
return result; return result;
} }
INLINE void write64le_with_16be_device_handler(write16_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64le_with_16be_device_handler(write16_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
write32le_with_16be_device_handler(handler, device, offset * 2 + 0, data >> 0, mem_mask >> 0); write32le_with_16be_device_handler(handler, device, space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
write32le_with_16be_device_handler(handler, device, offset * 2 + 1, data >> 32, mem_mask >> 32); write32le_with_16be_device_handler(handler, device, space, offset * 2 + 1, data >> 32, mem_mask >> 32);
} }
@ -443,23 +443,23 @@ INLINE void write64le_with_16be_device_handler(write16_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT64 read64be_with_32be_device_handler(read32_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT64 read64be_with_32be_device_handler(read32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)(*handler)(device, offset * 2 + 0, mem_mask >> 32) << 32; result |= (UINT64)(*handler)(device, space, offset * 2 + 0, mem_mask >> 32) << 32;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)(*handler)(device, offset * 2 + 1, mem_mask >> 0) << 0; result |= (UINT64)(*handler)(device, space, offset * 2 + 1, mem_mask >> 0) << 0;
return result; return result;
} }
INLINE void write64be_with_32be_device_handler(write32_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64be_with_32be_device_handler(write32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
(*handler)(device, offset * 2 + 0, data >> 32, mem_mask >> 32); (*handler)(device, space, offset * 2 + 0, data >> 32, mem_mask >> 32);
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
(*handler)(device, offset * 2 + 1, data >> 0, mem_mask >> 0); (*handler)(device, space, offset * 2 + 1, data >> 0, mem_mask >> 0);
} }
@ -469,23 +469,23 @@ INLINE void write64be_with_32be_device_handler(write32_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT64 read64le_with_32le_device_handler(read32_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT64 read64le_with_32le_device_handler(read32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result = 0; UINT64 result = 0;
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
result |= (UINT64)(*handler)(device, offset * 2 + 0, mem_mask >> 0) << 0; result |= (UINT64)(*handler)(device, space, offset * 2 + 0, mem_mask >> 0) << 0;
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
result |= (UINT64)(*handler)(device, offset * 2 + 1, mem_mask >> 32) << 32; result |= (UINT64)(*handler)(device, space, offset * 2 + 1, mem_mask >> 32) << 32;
return result; return result;
} }
INLINE void write64le_with_32le_device_handler(write32_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64le_with_32le_device_handler(write32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
if (ACCESSING_BITS_0_31) if (ACCESSING_BITS_0_31)
(*handler)(device, offset * 2 + 0, data >> 0, mem_mask >> 0); (*handler)(device, space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_32_63) if (ACCESSING_BITS_32_63)
(*handler)(device, offset * 2 + 1, data >> 32, mem_mask >> 32); (*handler)(device, space, offset * 2 + 1, data >> 32, mem_mask >> 32);
} }
@ -495,20 +495,20 @@ INLINE void write64le_with_32le_device_handler(write32_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT64 read64be_with_32le_device_handler(read32_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT64 read64be_with_32le_device_handler(read32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result; UINT64 result;
mem_mask = FLIPENDIAN_INT64(mem_mask); mem_mask = FLIPENDIAN_INT64(mem_mask);
result = read64le_with_32le_device_handler(handler, device, offset, mem_mask); result = read64le_with_32le_device_handler(handler, device, space, offset, mem_mask);
return FLIPENDIAN_INT64(result); return FLIPENDIAN_INT64(result);
} }
INLINE void write64be_with_32le_device_handler(write32_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64be_with_32le_device_handler(write32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
data = FLIPENDIAN_INT64(data); data = FLIPENDIAN_INT64(data);
mem_mask = FLIPENDIAN_INT64(mem_mask); mem_mask = FLIPENDIAN_INT64(mem_mask);
write64le_with_32le_device_handler(handler, device, offset, data, mem_mask); write64le_with_32le_device_handler(handler, device, space, offset, data, mem_mask);
} }
@ -518,20 +518,20 @@ INLINE void write64be_with_32le_device_handler(write32_device_func handler, devi
* *
*************************************/ *************************************/
INLINE UINT64 read64le_with_32be_device_handler(read32_device_func handler, device_t *device, offs_t offset, UINT64 mem_mask) INLINE UINT64 read64le_with_32be_device_handler(read32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 mem_mask)
{ {
UINT64 result; UINT64 result;
mem_mask = FLIPENDIAN_INT64(mem_mask); mem_mask = FLIPENDIAN_INT64(mem_mask);
result = read64be_with_32be_device_handler(handler, device, offset, mem_mask); result = read64be_with_32be_device_handler(handler, device, space, offset, mem_mask);
return FLIPENDIAN_INT64(result); return FLIPENDIAN_INT64(result);
} }
INLINE void write64le_with_32be_device_handler(write32_device_func handler, device_t *device, offs_t offset, UINT64 data, UINT64 mem_mask) INLINE void write64le_with_32be_device_handler(write32_device_func handler, device_t *device, address_space &space, offs_t offset, UINT64 data, UINT64 mem_mask)
{ {
data = FLIPENDIAN_INT64(data); data = FLIPENDIAN_INT64(data);
mem_mask = FLIPENDIAN_INT64(mem_mask); mem_mask = FLIPENDIAN_INT64(mem_mask);
write64be_with_32be_device_handler(handler, device, offset, data, mem_mask); write64be_with_32be_device_handler(handler, device, space, offset, data, mem_mask);
} }
@ -545,28 +545,28 @@ INLINE void write64le_with_32be_device_handler(write32_device_func handler, devi
#define DEV_READ_TEMPLATE(bits, name, handler, func) \ #define DEV_READ_TEMPLATE(bits, name, handler, func) \
READ##bits##_DEVICE_HANDLER( name##_r ) \ READ##bits##_DEVICE_HANDLER( name##_r ) \
{ \ { \
return func(handler, device, offset, mem_mask); \ return func(handler, device, space, offset, mem_mask); \
} }
#define DEV_READ_TEMPLATE_COND(bits, name, handler, func, cond) \ #define DEV_READ_TEMPLATE_COND(bits, name, handler, func, cond) \
READ##bits##_DEVICE_HANDLER( name##_r ) \ READ##bits##_DEVICE_HANDLER( name##_r ) \
{ \ { \
if (cond) \ if (cond) \
return func(handler, device, offset, mem_mask); \ return func(handler, device, space, offset, mem_mask); \
return 0; \ return 0; \
} }
#define DEV_WRITE_TEMPLATE(bits, name, handler, func) \ #define DEV_WRITE_TEMPLATE(bits, name, handler, func) \
WRITE##bits##_DEVICE_HANDLER( name##_w ) \ WRITE##bits##_DEVICE_HANDLER( name##_w ) \
{ \ { \
func(handler, device, offset, data, mem_mask); \ func(handler, device, space, offset, data, mem_mask); \
} }
#define DEV_WRITE_TEMPLATE_COND(bits, name, handler, func, cond) \ #define DEV_WRITE_TEMPLATE_COND(bits, name, handler, func, cond) \
WRITE##bits##_DEVICE_HANDLER( name##_w ) \ WRITE##bits##_DEVICE_HANDLER( name##_w ) \
{ \ { \
if (cond) \ if (cond) \
func(handler, device, offset, data, mem_mask); \ func(handler, device, space, offset, data, mem_mask); \
} }

4
src/emu/dimemory.c
View File

@ -323,9 +323,9 @@ void device_memory_interface::interface_validity_check(validity_checker &valid)
} }
// make sure all devices exist // make sure all devices exist
if (entry->m_read.m_type == AMH_LEGACY_DEVICE_HANDLER && entry->m_read.m_tag && device().siblingdevice(entry->m_read.m_tag) == NULL) if (entry->m_read.m_type == AMH_DEVICE_DELEGATE && entry->m_read.m_tag && device().siblingdevice(entry->m_read.m_tag) == NULL)
mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_read.m_tag.cstr()); mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_read.m_tag.cstr());
if (entry->m_write.m_type == AMH_LEGACY_DEVICE_HANDLER && entry->m_write.m_tag && device().siblingdevice(entry->m_write.m_tag) == NULL) if (entry->m_write.m_type == AMH_DEVICE_DELEGATE && entry->m_write.m_tag && device().siblingdevice(entry->m_write.m_tag) == NULL)
mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_write.m_tag.cstr()); mame_printf_error("%s space memory map entry references nonexistant device '%s'\n", spaceconfig->m_name, entry->m_write.m_tag.cstr());
// make sure ports exist // make sure ports exist

13
src/emu/driver.c
View File

@ -51,6 +51,7 @@
driver_device::driver_device(const machine_config &mconfig, device_type type, const char *tag) driver_device::driver_device(const machine_config &mconfig, device_type type, const char *tag)
: device_t(mconfig, type, "Driver Device", tag, NULL, 0), : device_t(mconfig, type, "Driver Device", tag, NULL, 0),
device_memory_interface(mconfig, *this),
m_generic_paletteram_8(*this, "paletteram"), m_generic_paletteram_8(*this, "paletteram"),
m_generic_paletteram2_8(*this, "paletteram2"), m_generic_paletteram2_8(*this, "paletteram2"),
m_generic_paletteram_16(*this, "paletteram"), m_generic_paletteram_16(*this, "paletteram"),
@ -58,6 +59,7 @@ driver_device::driver_device(const machine_config &mconfig, device_type type, co
m_generic_paletteram_32(*this, "paletteram"), m_generic_paletteram_32(*this, "paletteram"),
m_generic_paletteram2_32(*this, "paletteram2"), m_generic_paletteram2_32(*this, "paletteram2"),
m_system(NULL), m_system(NULL),
m_generic_space_config("generic", ENDIANNESS_LITTLE, 8, 8),
m_latch_clear_value(0), m_latch_clear_value(0),
m_flip_screen_x(0), m_flip_screen_x(0),
m_flip_screen_y(0) m_flip_screen_y(0)
@ -313,6 +315,17 @@ void driver_device::device_reset_after_children()
} }
//-------------------------------------------------
// memory_space_config - return a description of
// any address spaces owned by this device
//-------------------------------------------------
const address_space_config *driver_device::memory_space_config(address_spacenum spacenum) const
{
return (spacenum == 0) ? &m_generic_space_config : NULL;
}
//************************************************************************** //**************************************************************************
// INTERRUPT ENABLE AND VECTOR HELPERS // INTERRUPT ENABLE AND VECTOR HELPERS

15
src/emu/driver.h
View File

@ -166,7 +166,8 @@ typedef void (*legacy_callback_func)(running_machine &machine);
// ======================> driver_device // ======================> driver_device
// base class for machine driver-specific devices // base class for machine driver-specific devices
class driver_device : public device_t class driver_device : public device_t,
public device_memory_interface
{ {
public: public:
// construction/destruction // construction/destruction
@ -201,7 +202,11 @@ public:
(machine.driver_data<_DriverClass>()->*_Function)(); (machine.driver_data<_DriverClass>()->*_Function)();
} }
void init_0() {}; // dummy driver_init callbacks
void init_0() { }
// memory helpers
address_space &generic_space() const { return *space(AS_PROGRAM); }
// generic interrupt generators // generic interrupt generators
void generic_pulse_irq_line(device_execute_interface &exec, int irqline, int cycles); void generic_pulse_irq_line(device_execute_interface &exec, int irqline, int cycles);
@ -399,6 +404,9 @@ protected:
virtual void device_start(); virtual void device_start();
virtual void device_reset_after_children(); virtual void device_reset_after_children();
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
// internal helpers // internal helpers
inline UINT16 paletteram16_le(offs_t offset) const { return m_generic_paletteram_8[offset & ~1] | (m_generic_paletteram_8[offset | 1] << 8); } inline UINT16 paletteram16_le(offs_t offset) const { return m_generic_paletteram_8[offset & ~1] | (m_generic_paletteram_8[offset | 1] << 8); }
inline UINT16 paletteram16_be(offs_t offset) const { return m_generic_paletteram_8[offset | 1] | (m_generic_paletteram_8[offset & ~1] << 8); } inline UINT16 paletteram16_be(offs_t offset) const { return m_generic_paletteram_8[offset | 1] | (m_generic_paletteram_8[offset & ~1] << 8); }
@ -425,6 +433,9 @@ private:
driver_callback_delegate m_callbacks[CB_COUNT]; // start/reset callbacks driver_callback_delegate m_callbacks[CB_COUNT]; // start/reset callbacks
legacy_callback_func m_legacy_callbacks[CB_COUNT]; // legacy start/reset callbacks legacy_callback_func m_legacy_callbacks[CB_COUNT]; // legacy start/reset callbacks
// memory state
address_space_config m_generic_space_config;
// generic audio // generic audio
UINT16 m_latch_clear_value; UINT16 m_latch_clear_value;
UINT16 m_latched_value[4]; UINT16 m_latched_value[4];

2
src/emu/imagedev/flopdrv.h
View File

@ -155,7 +155,7 @@ WRITE_LINE_DEVICE_HANDLER( floppy_ds0_w );
WRITE_LINE_DEVICE_HANDLER( floppy_ds1_w ); WRITE_LINE_DEVICE_HANDLER( floppy_ds1_w );
WRITE_LINE_DEVICE_HANDLER( floppy_ds2_w ); WRITE_LINE_DEVICE_HANDLER( floppy_ds2_w );
WRITE_LINE_DEVICE_HANDLER( floppy_ds3_w ); WRITE_LINE_DEVICE_HANDLER( floppy_ds3_w );
WRITE8_DEVICE_HANDLER( floppy_ds_w ); DECLARE_WRITE8_DEVICE_HANDLER( floppy_ds_w );
WRITE_LINE_DEVICE_HANDLER( floppy_mon_w ); WRITE_LINE_DEVICE_HANDLER( floppy_mon_w );
WRITE_LINE_DEVICE_HANDLER( floppy_drtn_w ); WRITE_LINE_DEVICE_HANDLER( floppy_drtn_w );

16
src/emu/machine/6525tpi.h
View File

@ -86,17 +86,17 @@ extern const device_type TPI6525;
FUNCTION PROTOTYPES FUNCTION PROTOTYPES
***************************************************************************/ ***************************************************************************/
READ8_DEVICE_HANDLER( tpi6525_r ); DECLARE_READ8_DEVICE_HANDLER( tpi6525_r );
WRITE8_DEVICE_HANDLER( tpi6525_w ); DECLARE_WRITE8_DEVICE_HANDLER( tpi6525_w );
READ8_DEVICE_HANDLER( tpi6525_porta_r ); DECLARE_READ8_DEVICE_HANDLER( tpi6525_porta_r );
WRITE8_DEVICE_HANDLER( tpi6525_porta_w ); DECLARE_WRITE8_DEVICE_HANDLER( tpi6525_porta_w );
READ8_DEVICE_HANDLER( tpi6525_portb_r ); DECLARE_READ8_DEVICE_HANDLER( tpi6525_portb_r );
WRITE8_DEVICE_HANDLER( tpi6525_portb_w ); DECLARE_WRITE8_DEVICE_HANDLER( tpi6525_portb_w );
READ8_DEVICE_HANDLER( tpi6525_portc_r ); DECLARE_READ8_DEVICE_HANDLER( tpi6525_portc_r );
WRITE8_DEVICE_HANDLER( tpi6525_portc_w ); DECLARE_WRITE8_DEVICE_HANDLER( tpi6525_portc_w );
WRITE_LINE_DEVICE_HANDLER( tpi6525_i0_w ); WRITE_LINE_DEVICE_HANDLER( tpi6525_i0_w );
WRITE_LINE_DEVICE_HANDLER( tpi6525_i1_w ); WRITE_LINE_DEVICE_HANDLER( tpi6525_i1_w );

8
src/emu/machine/6526cia.h
View File

@ -268,12 +268,12 @@ extern const device_type MOS5710;
***************************************************************************/ ***************************************************************************/
/* register access */ /* register access */
READ8_DEVICE_HANDLER( mos6526_r ); DECLARE_READ8_DEVICE_HANDLER( mos6526_r );
WRITE8_DEVICE_HANDLER( mos6526_w ); DECLARE_WRITE8_DEVICE_HANDLER( mos6526_w );
/* port access */ /* port access */
READ8_DEVICE_HANDLER( mos6526_pa_r ); DECLARE_READ8_DEVICE_HANDLER( mos6526_pa_r );
READ8_DEVICE_HANDLER( mos6526_pb_r ); DECLARE_READ8_DEVICE_HANDLER( mos6526_pb_r );
/* interrupt request */ /* interrupt request */
READ_LINE_DEVICE_HANDLER( mos6526_irq_r ); READ_LINE_DEVICE_HANDLER( mos6526_irq_r );

4
src/emu/machine/6532riot.h
View File

@ -121,8 +121,8 @@ extern const device_type RIOT6532;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
READ8_DEVICE_HANDLER( riot6532_r ); DECLARE_READ8_DEVICE_HANDLER( riot6532_r );
WRITE8_DEVICE_HANDLER( riot6532_w ); DECLARE_WRITE8_DEVICE_HANDLER( riot6532_w );
void riot6532_porta_in_set(device_t *device, UINT8 data, UINT8 mask); void riot6532_porta_in_set(device_t *device, UINT8 data, UINT8 mask);
void riot6532_portb_in_set(device_t *device, UINT8 data, UINT8 mask); void riot6532_portb_in_set(device_t *device, UINT8 data, UINT8 mask);

4
src/emu/machine/68681.h
View File

@ -40,8 +40,8 @@ extern const device_type DUART68681;
MCFG_DEVICE_CONFIG(_config) MCFG_DEVICE_CONFIG(_config)
READ8_DEVICE_HANDLER(duart68681_r); DECLARE_READ8_DEVICE_HANDLER(duart68681_r);
WRITE8_DEVICE_HANDLER(duart68681_w); DECLARE_WRITE8_DEVICE_HANDLER(duart68681_w);
void duart68681_rx_data( device_t* device, int ch, UINT8 data ); void duart68681_rx_data( device_t* device, int ch, UINT8 data );

7
src/emu/machine/74123.c
View File

@ -55,7 +55,6 @@ void ttl74123_device::device_config_complete()
m_a = 0; m_a = 0;
m_b = 0; m_b = 0;
m_clear = 0; m_clear = 0;
memset(&m_output_changed_cb, 0, sizeof(m_output_changed_cb));
} }
} }
@ -66,6 +65,8 @@ void ttl74123_device::device_config_complete()
void ttl74123_device::device_start() void ttl74123_device::device_start()
{ {
m_output_changed.resolve(m_output_changed_cb, *this);
m_timer = machine().scheduler().timer_alloc(FUNC(clear_callback), (void *)this); m_timer = machine().scheduler().timer_alloc(FUNC(clear_callback), (void *)this);
/* register for state saving */ /* register for state saving */
@ -145,7 +146,7 @@ TIMER_CALLBACK( ttl74123_device::output_callback )
void ttl74123_device::output(INT32 param) void ttl74123_device::output(INT32 param)
{ {
m_output_changed_cb(this, 0, param); m_output_changed(0, param);
} }
@ -177,7 +178,7 @@ void ttl74123_device::clear()
{ {
int output = timer_running(); int output = timer_running();
m_output_changed_cb(this, 0, output); m_output_changed(0, output);
} }

11
src/emu/machine/74123.h
View File

@ -82,7 +82,7 @@ struct ttl74123_interface
int m_a; /* initial/constant value of the A pin */ int m_a; /* initial/constant value of the A pin */
int m_b; /* initial/constant value of the B pin */ int m_b; /* initial/constant value of the B pin */
int m_clear; /* initial/constant value of the Clear pin */ int m_clear; /* initial/constant value of the Clear pin */
write8_device_func m_output_changed_cb; devcb_write8 m_output_changed_cb;
}; };
@ -122,6 +122,7 @@ private:
void clear(); void clear();
emu_timer *m_timer; emu_timer *m_timer;
devcb_resolved_write8 m_output_changed;
}; };
@ -134,9 +135,9 @@ extern const device_type TTL74123;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
WRITE8_DEVICE_HANDLER( ttl74123_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ttl74123_a_w );
WRITE8_DEVICE_HANDLER( ttl74123_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ttl74123_b_w );
WRITE8_DEVICE_HANDLER( ttl74123_clear_w ); DECLARE_WRITE8_DEVICE_HANDLER( ttl74123_clear_w );
WRITE8_DEVICE_HANDLER( ttl74123_reset_w ); /* reset the latch */ DECLARE_WRITE8_DEVICE_HANDLER( ttl74123_reset_w ); /* reset the latch */
#endif #endif

4
src/emu/machine/8237dma.h
View File

@ -189,8 +189,8 @@ extern const device_type I8237;
***************************************************************************/ ***************************************************************************/
/* register access */ /* register access */
READ8_DEVICE_HANDLER( i8237_r ); DECLARE_READ8_DEVICE_HANDLER( i8237_r );
WRITE8_DEVICE_HANDLER( i8237_w ); DECLARE_WRITE8_DEVICE_HANDLER( i8237_w );
/* hold acknowledge */ /* hold acknowledge */
WRITE_LINE_DEVICE_HANDLER( i8237_hlda_w ); WRITE_LINE_DEVICE_HANDLER( i8237_hlda_w );

4
src/emu/machine/8257dma.h
View File

@ -147,8 +147,8 @@ extern const device_type I8257;
***************************************************************************/ ***************************************************************************/
/* register access */ /* register access */
READ8_DEVICE_HANDLER( i8257_r ); DECLARE_READ8_DEVICE_HANDLER( i8257_r );
WRITE8_DEVICE_HANDLER( i8257_w ); DECLARE_WRITE8_DEVICE_HANDLER( i8257_w );
/* hold acknowledge */ /* hold acknowledge */
WRITE_LINE_DEVICE_HANDLER( i8257_hlda_w ); WRITE_LINE_DEVICE_HANDLER( i8257_hlda_w );

12
src/emu/machine/adc1213x.h
View File

@ -82,11 +82,11 @@ struct adc12138_interface
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
extern WRITE8_DEVICE_HANDLER( adc1213x_di_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( adc1213x_di_w );
extern WRITE8_DEVICE_HANDLER( adc1213x_cs_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( adc1213x_cs_w );
extern WRITE8_DEVICE_HANDLER( adc1213x_sclk_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( adc1213x_sclk_w );
extern WRITE8_DEVICE_HANDLER( adc1213x_conv_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( adc1213x_conv_w );
extern READ8_DEVICE_HANDLER( adc1213x_do_r ); extern DECLARE_READ8_DEVICE_HANDLER( adc1213x_do_r );
extern READ8_DEVICE_HANDLER( adc1213x_eoc_r ); extern DECLARE_READ8_DEVICE_HANDLER( adc1213x_eoc_r );
#endif /* __ADC1213X_H__ */ #endif /* __ADC1213X_H__ */

4
src/emu/machine/at28c16.h
View File

@ -84,8 +84,8 @@ extern const device_type AT28C16;
// READ/WRITE HANDLERS // READ/WRITE HANDLERS
//************************************************************************** //**************************************************************************
WRITE8_DEVICE_HANDLER( at28c16_w ); DECLARE_WRITE8_DEVICE_HANDLER( at28c16_w );
READ8_DEVICE_HANDLER( at28c16_r ); DECLARE_READ8_DEVICE_HANDLER( at28c16_r );
WRITE_LINE_DEVICE_HANDLER( at28c16_a9_12v ); WRITE_LINE_DEVICE_HANDLER( at28c16_a9_12v );
WRITE_LINE_DEVICE_HANDLER( at28c16_oe_12v ); WRITE_LINE_DEVICE_HANDLER( at28c16_oe_12v );

10
src/emu/machine/ds2404.h
View File

@ -128,13 +128,13 @@ extern const device_type DS2404;
***************************************************************************/ ***************************************************************************/
/* 1-wire interface reset */ /* 1-wire interface reset */
WRITE8_DEVICE_HANDLER( ds2404_1w_reset_w ); DECLARE_WRITE8_DEVICE_HANDLER( ds2404_1w_reset_w );
/* 3-wire interface reset */ /* 3-wire interface reset */
WRITE8_DEVICE_HANDLER( ds2404_3w_reset_w ); DECLARE_WRITE8_DEVICE_HANDLER( ds2404_3w_reset_w );
READ8_DEVICE_HANDLER( ds2404_data_r ); DECLARE_READ8_DEVICE_HANDLER( ds2404_data_r );
WRITE8_DEVICE_HANDLER( ds2404_data_w ); DECLARE_WRITE8_DEVICE_HANDLER( ds2404_data_w );
WRITE8_DEVICE_HANDLER( ds2404_clk_w ); DECLARE_WRITE8_DEVICE_HANDLER( ds2404_clk_w );
#endif #endif

4
src/emu/machine/f3853.h
View File

@ -120,8 +120,8 @@ extern const device_type F3853;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
READ8_DEVICE_HANDLER( f3853_r ); DECLARE_READ8_DEVICE_HANDLER( f3853_r );
WRITE8_DEVICE_HANDLER( f3853_w ); DECLARE_WRITE8_DEVICE_HANDLER( f3853_w );
void f3853_set_external_interrupt_in_line(device_t *device, int level); void f3853_set_external_interrupt_in_line(device_t *device, int level);
void f3853_set_priority_in_line(device_t *device, int level); void f3853_set_priority_in_line(device_t *device, int level);

6
src/emu/machine/i8243.h
View File

@ -88,10 +88,10 @@ extern const device_type I8243;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
READ8_DEVICE_HANDLER( i8243_p2_r ); DECLARE_READ8_DEVICE_HANDLER( i8243_p2_r );
WRITE8_DEVICE_HANDLER( i8243_p2_w ); DECLARE_WRITE8_DEVICE_HANDLER( i8243_p2_w );
WRITE8_DEVICE_HANDLER( i8243_prog_w ); DECLARE_WRITE8_DEVICE_HANDLER( i8243_prog_w );
#endif /* __I8243_H__ */ #endif /* __I8243_H__ */

16
src/emu/machine/idectrl.h
View File

@ -172,15 +172,15 @@ void ide_bus_w(device_t *config, int select, int offset, int data);
UINT32 ide_controller_r(device_t *config, int reg, int size); UINT32 ide_controller_r(device_t *config, int reg, int size);
void ide_controller_w(device_t *config, int reg, int size, UINT32 data); void ide_controller_w(device_t *config, int reg, int size, UINT32 data);
READ32_DEVICE_HANDLER( ide_controller32_r ); DECLARE_READ32_DEVICE_HANDLER( ide_controller32_r );
WRITE32_DEVICE_HANDLER( ide_controller32_w ); DECLARE_WRITE32_DEVICE_HANDLER( ide_controller32_w );
READ32_DEVICE_HANDLER( ide_controller32_pcmcia_r ); DECLARE_READ32_DEVICE_HANDLER( ide_controller32_pcmcia_r );
WRITE32_DEVICE_HANDLER( ide_controller32_pcmcia_w ); DECLARE_WRITE32_DEVICE_HANDLER( ide_controller32_pcmcia_w );
READ32_DEVICE_HANDLER( ide_bus_master32_r ); DECLARE_READ32_DEVICE_HANDLER( ide_bus_master32_r );
WRITE32_DEVICE_HANDLER( ide_bus_master32_w ); DECLARE_WRITE32_DEVICE_HANDLER( ide_bus_master32_w );
READ16_DEVICE_HANDLER( ide_controller16_r ); DECLARE_READ16_DEVICE_HANDLER( ide_controller16_r );
WRITE16_DEVICE_HANDLER( ide_controller16_w ); DECLARE_WRITE16_DEVICE_HANDLER( ide_controller16_w );
/* ----- device interface ----- */ /* ----- device interface ----- */

8
src/emu/machine/ins8154.h
View File

@ -116,11 +116,11 @@ extern const device_type INS8154;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
READ8_DEVICE_HANDLER( ins8154_r ); DECLARE_READ8_DEVICE_HANDLER( ins8154_r );
WRITE8_DEVICE_HANDLER( ins8154_w ); DECLARE_WRITE8_DEVICE_HANDLER( ins8154_w );
WRITE8_DEVICE_HANDLER( ins8154_porta_w ); DECLARE_WRITE8_DEVICE_HANDLER( ins8154_porta_w );
WRITE8_DEVICE_HANDLER( ins8154_portb_w ); DECLARE_WRITE8_DEVICE_HANDLER( ins8154_portb_w );
#endif /* __INS8154_H__ */ #endif /* __INS8154_H__ */

4
src/emu/machine/k033906.h
View File

@ -81,8 +81,8 @@ extern const device_type K033906;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
extern READ32_DEVICE_HANDLER( k033906_r ); extern DECLARE_READ32_DEVICE_HANDLER( k033906_r );
extern WRITE32_DEVICE_HANDLER( k033906_w ); extern DECLARE_WRITE32_DEVICE_HANDLER( k033906_w );
extern WRITE_LINE_DEVICE_HANDLER( k033906_set_reg ); extern WRITE_LINE_DEVICE_HANDLER( k033906_set_reg );

4
src/emu/machine/k053252.h
View File

@ -49,8 +49,8 @@ struct k053252_interface
/** Konami 053252 **/ /** Konami 053252 **/
/* CRT and interrupt control unit */ /* CRT and interrupt control unit */
READ8_DEVICE_HANDLER( k053252_r ); // CCU registers DECLARE_READ8_DEVICE_HANDLER( k053252_r ); // CCU registers
WRITE8_DEVICE_HANDLER( k053252_w ); DECLARE_WRITE8_DEVICE_HANDLER( k053252_w );

8
src/emu/machine/k056230.h
View File

@ -80,10 +80,10 @@ extern const device_type K056230;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
extern READ32_DEVICE_HANDLER( lanc_ram_r ); extern DECLARE_READ32_DEVICE_HANDLER( lanc_ram_r );
extern WRITE32_DEVICE_HANDLER( lanc_ram_w ); extern DECLARE_WRITE32_DEVICE_HANDLER( lanc_ram_w );
extern READ8_DEVICE_HANDLER( k056230_r ); extern DECLARE_READ8_DEVICE_HANDLER( k056230_r );
extern WRITE8_DEVICE_HANDLER( k056230_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( k056230_w );
#endif /* __K056230_H__ */ #endif /* __K056230_H__ */

6
src/emu/machine/latch8.c
View File

@ -42,7 +42,7 @@ static void update(device_t *device, UINT8 new_val, UINT8 mask)
UINT8 changed = old_val ^ latch8->value; UINT8 changed = old_val ^ latch8->value;
for (i=0; i<8; i++) for (i=0; i<8; i++)
if (((changed & (1<<i)) != 0) && latch8->intf->node_map[i] != 0) if (((changed & (1<<i)) != 0) && latch8->intf->node_map[i] != 0)
discrete_sound_w(device->machine().device(latch8->intf->node_device[i]), latch8->intf->node_map[i] , (latch8->value >> i) & 1); discrete_sound_w(device->machine().device(latch8->intf->node_device[i]), device->machine().driver_data()->generic_space(), latch8->intf->node_map[i] , (latch8->value >> i) & 1);
} }
} }
@ -74,14 +74,14 @@ READ8_DEVICE_HANDLER( latch8_r )
if (read_dev != NULL) if (read_dev != NULL)
{ {
res &= ~( 1 << i); res &= ~( 1 << i);
res |= ((latch8->intf->devread[i].devread_handler(read_dev, 0) >> latch8->intf->devread[i].from_bit) & 0x01) << i; res |= ((latch8->intf->devread[i].devread_handler(read_dev, device->machine().driver_data()->generic_space(), 0, 0xff) >> latch8->intf->devread[i].from_bit) & 0x01) << i;
} }
} }
} }
if (latch8->has_read) if (latch8->has_read)
{ {
/* temporary hack until all relevant systems are devices */ /* temporary hack until all relevant systems are devices */
address_space *space = device->machine().firstcpu->space(AS_PROGRAM); address_space *space = &device->machine().driver_data()->generic_space();
int i; int i;
for (i=0; i<8; i++) for (i=0; i<8; i++)
{ {

54
src/emu/machine/latch8.h
View File

@ -126,47 +126,47 @@ extern const device_type LATCH8;
/* write & read full byte */ /* write & read full byte */
READ8_DEVICE_HANDLER( latch8_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_r );
WRITE8_DEVICE_HANDLER( latch8_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_w );
/* reset the latch */ /* reset the latch */
WRITE8_DEVICE_HANDLER( latch8_reset ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_reset );
/* read bit x */ /* read bit x */
/* return (latch >> x) & 0x01 */ /* return (latch >> x) & 0x01 */
READ8_DEVICE_HANDLER( latch8_bit0_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit0_r );
READ8_DEVICE_HANDLER( latch8_bit1_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit1_r );
READ8_DEVICE_HANDLER( latch8_bit2_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit2_r );
READ8_DEVICE_HANDLER( latch8_bit3_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit3_r );
READ8_DEVICE_HANDLER( latch8_bit4_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit4_r );
READ8_DEVICE_HANDLER( latch8_bit5_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit5_r );
READ8_DEVICE_HANDLER( latch8_bit6_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit6_r );
READ8_DEVICE_HANDLER( latch8_bit7_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit7_r );
/* read inverted bit x */ /* read inverted bit x */
/* return (latch >> x) & 0x01 */ /* return (latch >> x) & 0x01 */
READ8_DEVICE_HANDLER( latch8_bit0_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit0_q_r );
READ8_DEVICE_HANDLER( latch8_bit1_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit1_q_r );
READ8_DEVICE_HANDLER( latch8_bit2_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit2_q_r );
READ8_DEVICE_HANDLER( latch8_bit3_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit3_q_r );
READ8_DEVICE_HANDLER( latch8_bit4_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit4_q_r );
READ8_DEVICE_HANDLER( latch8_bit5_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit5_q_r );
READ8_DEVICE_HANDLER( latch8_bit6_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit6_q_r );
READ8_DEVICE_HANDLER( latch8_bit7_q_r ); DECLARE_READ8_DEVICE_HANDLER( latch8_bit7_q_r );
/* write bit x from data into bit determined by offset */ /* write bit x from data into bit determined by offset */
/* latch = (latch & ~(1<<offset)) | (((data >> x) & 0x01) << offset) */ /* latch = (latch & ~(1<<offset)) | (((data >> x) & 0x01) << offset) */
WRITE8_DEVICE_HANDLER( latch8_bit0_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit0_w );
WRITE8_DEVICE_HANDLER( latch8_bit1_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit1_w );
WRITE8_DEVICE_HANDLER( latch8_bit2_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit2_w );
WRITE8_DEVICE_HANDLER( latch8_bit3_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit3_w );
WRITE8_DEVICE_HANDLER( latch8_bit4_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit4_w );
WRITE8_DEVICE_HANDLER( latch8_bit5_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit5_w );
WRITE8_DEVICE_HANDLER( latch8_bit6_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit6_w );
WRITE8_DEVICE_HANDLER( latch8_bit7_w ); DECLARE_WRITE8_DEVICE_HANDLER( latch8_bit7_w );
#endif /* __LATCH8_H_ */ #endif /* __LATCH8_H_ */

6
src/emu/machine/mb14241.h
View File

@ -43,9 +43,9 @@ extern const device_type MB14241;
DEVICE I/O FUNCTIONS DEVICE I/O FUNCTIONS
***************************************************************************/ ***************************************************************************/
WRITE8_DEVICE_HANDLER ( mb14241_shift_count_w ); DECLARE_WRITE8_DEVICE_HANDLER ( mb14241_shift_count_w );
WRITE8_DEVICE_HANDLER ( mb14241_shift_data_w ); DECLARE_WRITE8_DEVICE_HANDLER ( mb14241_shift_data_w );
READ8_DEVICE_HANDLER( mb14241_shift_result_r ); DECLARE_READ8_DEVICE_HANDLER( mb14241_shift_result_r );
#endif /* __MB14241_H__ */ #endif /* __MB14241_H__ */

6
src/emu/machine/pd4990a.h
View File

@ -48,9 +48,9 @@ extern const device_type UPD4990A;
/* this should be refactored, once RTCs get unified */ /* this should be refactored, once RTCs get unified */
extern void upd4990a_addretrace( device_t *device ); extern void upd4990a_addretrace( device_t *device );
extern READ8_DEVICE_HANDLER( upd4990a_testbit_r ); extern DECLARE_READ8_DEVICE_HANDLER( upd4990a_testbit_r );
extern READ8_DEVICE_HANDLER( upd4990a_databit_r ); extern DECLARE_READ8_DEVICE_HANDLER( upd4990a_databit_r );
extern WRITE16_DEVICE_HANDLER( upd4990a_control_16_w ); extern DECLARE_WRITE16_DEVICE_HANDLER( upd4990a_control_16_w );
#endif /*__PD4990A_H__*/ #endif /*__PD4990A_H__*/

4
src/emu/machine/pic8259.h
View File

@ -74,8 +74,8 @@ struct pic8259_interface
/* device interface */ /* device interface */
READ8_DEVICE_HANDLER( pic8259_r ); DECLARE_READ8_DEVICE_HANDLER( pic8259_r );
WRITE8_DEVICE_HANDLER( pic8259_w ); DECLARE_WRITE8_DEVICE_HANDLER( pic8259_w );
int pic8259_acknowledge(device_t *device); int pic8259_acknowledge(device_t *device);
/* interrupt requests */ /* interrupt requests */

4
src/emu/machine/pit8253.h
View File

@ -85,8 +85,8 @@ extern const device_type PIT8254;
MCFG_DEVICE_CONFIG(_intrf) MCFG_DEVICE_CONFIG(_intrf)
READ8_DEVICE_HANDLER( pit8253_r ); DECLARE_READ8_DEVICE_HANDLER( pit8253_r );
WRITE8_DEVICE_HANDLER( pit8253_w ); DECLARE_WRITE8_DEVICE_HANDLER( pit8253_w );
WRITE_LINE_DEVICE_HANDLER( pit8253_clk0_w ); WRITE_LINE_DEVICE_HANDLER( pit8253_clk0_w );
WRITE_LINE_DEVICE_HANDLER( pit8253_clk1_w ); WRITE_LINE_DEVICE_HANDLER( pit8253_clk1_w );

14
src/emu/machine/rp5h01.h
View File

@ -48,12 +48,12 @@ extern const device_type RP5H01;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
WRITE8_DEVICE_HANDLER( rp5h01_enable_w ); /* /CE */ DECLARE_WRITE8_DEVICE_HANDLER( rp5h01_enable_w ); /* /CE */
WRITE8_DEVICE_HANDLER( rp5h01_reset_w ); /* RESET */ DECLARE_WRITE8_DEVICE_HANDLER( rp5h01_reset_w ); /* RESET */
WRITE8_DEVICE_HANDLER( rp5h01_cs_w ); /* CS */ DECLARE_WRITE8_DEVICE_HANDLER( rp5h01_cs_w ); /* CS */
WRITE8_DEVICE_HANDLER( rp5h01_clock_w ); /* DATA CLOCK (active low) */ DECLARE_WRITE8_DEVICE_HANDLER( rp5h01_clock_w ); /* DATA CLOCK (active low) */
WRITE8_DEVICE_HANDLER( rp5h01_test_w ); /* TEST */ DECLARE_WRITE8_DEVICE_HANDLER( rp5h01_test_w ); /* TEST */
READ8_DEVICE_HANDLER( rp5h01_counter_r ); /* COUNTER OUT */ DECLARE_READ8_DEVICE_HANDLER( rp5h01_counter_r ); /* COUNTER OUT */
READ8_DEVICE_HANDLER( rp5h01_data_r ); /* DATA */ DECLARE_READ8_DEVICE_HANDLER( rp5h01_data_r ); /* DATA */
#endif /* __RP5H01_H__ */ #endif /* __RP5H01_H__ */

2
src/emu/machine/s3c2410.h
View File

@ -63,7 +63,7 @@ public:
extern const device_type S3C2410; extern const device_type S3C2410;
READ32_DEVICE_HANDLER( s3c2410_lcd_r ); DECLARE_READ32_DEVICE_HANDLER( s3c2410_lcd_r );
/******************************************************************************* /*******************************************************************************
TYPE DEFINITIONS TYPE DEFINITIONS

12
src/emu/machine/s3c24xx.c
View File

@ -2686,7 +2686,7 @@ INLINE void iface_i2s_data_w( device_t *device, int ch, UINT16 data)
s3c24xx_t *s3c24xx = get_token( device); s3c24xx_t *s3c24xx = get_token( device);
if (s3c24xx->iface->i2s.data_w) if (s3c24xx->iface->i2s.data_w)
{ {
(s3c24xx->iface->i2s.data_w)( device, ch, data, 0); (s3c24xx->iface->i2s.data_w)( device, device->machine().driver_data()->generic_space(), ch, data, 0);
} }
} }
@ -2949,7 +2949,7 @@ static UINT32 iface_adc_data_r( device_t *device, int ch)
offs += 2; offs += 2;
} }
#endif #endif
return (s3c24xx->iface->adc.data_r)( device, offs, 0); return (s3c24xx->iface->adc.data_r)( device, device->machine().driver_data()->generic_space(), offs, 0);
} }
else else
{ {
@ -3181,7 +3181,7 @@ INLINE void iface_nand_command_w( device_t *device, UINT8 data)
s3c24xx_t *s3c24xx = get_token( device); s3c24xx_t *s3c24xx = get_token( device);
if (s3c24xx->iface->nand.command_w) if (s3c24xx->iface->nand.command_w)
{ {
(s3c24xx->iface->nand.command_w)( device, 0, data); (s3c24xx->iface->nand.command_w)( device, device->machine().driver_data()->generic_space(), 0, data, 0xff);
} }
} }
@ -3190,7 +3190,7 @@ INLINE void iface_nand_address_w( device_t *device, UINT8 data)
s3c24xx_t *s3c24xx = get_token( device); s3c24xx_t *s3c24xx = get_token( device);
if (s3c24xx->iface->nand.address_w) if (s3c24xx->iface->nand.address_w)
{ {
(s3c24xx->iface->nand.address_w)( device, 0, data); (s3c24xx->iface->nand.address_w)( device, device->machine().driver_data()->generic_space(), 0, data, 0xff);
} }
} }
@ -3199,7 +3199,7 @@ INLINE UINT8 iface_nand_data_r( device_t *device)
s3c24xx_t *s3c24xx = get_token( device); s3c24xx_t *s3c24xx = get_token( device);
if (s3c24xx->iface->nand.data_r) if (s3c24xx->iface->nand.data_r)
{ {
return (s3c24xx->iface->nand.data_r)( device, 0); return (s3c24xx->iface->nand.data_r)( device, device->machine().driver_data()->generic_space(), 0, 0xff);
} }
else else
{ {
@ -3212,7 +3212,7 @@ INLINE void iface_nand_data_w( device_t *device, UINT8 data)
s3c24xx_t *s3c24xx = get_token( device); s3c24xx_t *s3c24xx = get_token( device);
if (s3c24xx->iface->nand.data_w) if (s3c24xx->iface->nand.data_w)
{ {
(s3c24xx->iface->nand.data_w)( device, 0, data); (s3c24xx->iface->nand.data_w)( device, device->machine().driver_data()->generic_space(), 0, data, 0xff);
} }
} }

4
src/emu/machine/smc91c9x.h
View File

@ -44,8 +44,8 @@ struct smc91c9x_config
FUNCTION PROTOTYPES FUNCTION PROTOTYPES
***************************************************************************/ ***************************************************************************/
READ16_DEVICE_HANDLER( smc91c9x_r ); DECLARE_READ16_DEVICE_HANDLER( smc91c9x_r );
WRITE16_DEVICE_HANDLER( smc91c9x_w ); DECLARE_WRITE16_DEVICE_HANDLER( smc91c9x_w );
/* ----- device interface ----- */ /* ----- device interface ----- */

4
src/emu/machine/timekpr.h
View File

@ -154,7 +154,7 @@ extern const device_type MK48T08;
// READ/WRITE HANDLERS // READ/WRITE HANDLERS
//************************************************************************** //**************************************************************************
WRITE8_DEVICE_HANDLER( timekeeper_w ); DECLARE_WRITE8_DEVICE_HANDLER( timekeeper_w );
READ8_DEVICE_HANDLER( timekeeper_r ); DECLARE_READ8_DEVICE_HANDLER( timekeeper_r );
#endif // __TIMEKPR_H__ #endif // __TIMEKPR_H__

2
src/emu/machine/tms6100.h
View File

@ -10,7 +10,7 @@
WRITE_LINE_DEVICE_HANDLER( tms6100_m0_w ); WRITE_LINE_DEVICE_HANDLER( tms6100_m0_w );
WRITE_LINE_DEVICE_HANDLER( tms6100_m1_w ); WRITE_LINE_DEVICE_HANDLER( tms6100_m1_w );
WRITE_LINE_DEVICE_HANDLER( tms6100_romclock_w ); WRITE_LINE_DEVICE_HANDLER( tms6100_romclock_w );
WRITE8_DEVICE_HANDLER( tms6100_addr_w ); DECLARE_WRITE8_DEVICE_HANDLER( tms6100_addr_w );
READ_LINE_DEVICE_HANDLER( tms6100_data_r ); READ_LINE_DEVICE_HANDLER( tms6100_data_r );

22
src/emu/machine/upd4701.h
View File

@ -44,18 +44,18 @@ extern const device_type UPD4701;
PROTOTYPES PROTOTYPES
***************************************************************************/ ***************************************************************************/
extern WRITE8_DEVICE_HANDLER( upd4701_cs_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( upd4701_cs_w );
extern WRITE8_DEVICE_HANDLER( upd4701_xy_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( upd4701_xy_w );
extern WRITE8_DEVICE_HANDLER( upd4701_ul_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( upd4701_ul_w );
extern WRITE8_DEVICE_HANDLER( upd4701_resetx_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( upd4701_resetx_w );
extern WRITE8_DEVICE_HANDLER( upd4701_resety_w ); extern DECLARE_WRITE8_DEVICE_HANDLER( upd4701_resety_w );
extern WRITE16_DEVICE_HANDLER( upd4701_x_add ); extern DECLARE_WRITE16_DEVICE_HANDLER( upd4701_x_add );
extern WRITE16_DEVICE_HANDLER( upd4701_y_add ); extern DECLARE_WRITE16_DEVICE_HANDLER( upd4701_y_add );
extern WRITE8_DEVICE_HANDLER( upd4701_switches_set ); extern DECLARE_WRITE8_DEVICE_HANDLER( upd4701_switches_set );
extern READ16_DEVICE_HANDLER( upd4701_d_r ); extern DECLARE_READ16_DEVICE_HANDLER( upd4701_d_r );
extern READ8_DEVICE_HANDLER( upd4701_cf_r ); extern DECLARE_READ8_DEVICE_HANDLER( upd4701_cf_r );
extern READ8_DEVICE_HANDLER( upd4701_sf_r ); extern DECLARE_READ8_DEVICE_HANDLER( upd4701_sf_r );
#endif /* __UPD4701_H__ */ #endif /* __UPD4701_H__ */

16
src/emu/machine/wd17xx.c
View File

@ -1993,10 +1993,10 @@ READ8_DEVICE_HANDLER( wd17xx_r )
switch (offset & 0x03) switch (offset & 0x03)
{ {
case 0: data = wd17xx_status_r(device, 0); break; case 0: data = wd17xx_status_r(device, device->machine().driver_data()->generic_space(), 0); break;
case 1: data = wd17xx_track_r(device, 0); break; case 1: data = wd17xx_track_r(device, device->machine().driver_data()->generic_space(), 0); break;
case 2: data = wd17xx_sector_r(device, 0); break; case 2: data = wd17xx_sector_r(device, device->machine().driver_data()->generic_space(), 0); break;
case 3: data = wd17xx_data_r(device, 0); break; case 3: data = wd17xx_data_r(device, device->machine().driver_data()->generic_space(), 0); break;
} }
return data; return data;
@ -2006,10 +2006,10 @@ WRITE8_DEVICE_HANDLER( wd17xx_w )
{ {
switch (offset & 0x03) switch (offset & 0x03)
{ {
case 0: wd17xx_command_w(device, 0, data); break; case 0: wd17xx_command_w(device, device->machine().driver_data()->generic_space(), 0, data); break;
case 1: wd17xx_track_w(device, 0, data); break; case 1: wd17xx_track_w(device, device->machine().driver_data()->generic_space(), 0, data); break;
case 2: wd17xx_sector_w(device, 0, data); break; case 2: wd17xx_sector_w(device, device->machine().driver_data()->generic_space(), 0, data); break;
case 3: wd17xx_data_w(device, 0, data); break; case 3: wd17xx_data_w(device, device->machine().driver_data()->generic_space(), 0, data); break;
} }
} }

20
src/emu/machine/wd17xx.h
View File

@ -255,18 +255,18 @@ void wd17xx_set_side(device_t *device, UINT8); /* set side wd179x is accessing
void wd17xx_set_pause_time(device_t *device, int usec); /* default is 40 usec if not set */ void wd17xx_set_pause_time(device_t *device, int usec); /* default is 40 usec if not set */
void wd17xx_index_pulse_callback(device_t *controller, device_t *img, int state); void wd17xx_index_pulse_callback(device_t *controller, device_t *img, int state);
READ8_DEVICE_HANDLER( wd17xx_status_r ); DECLARE_READ8_DEVICE_HANDLER( wd17xx_status_r );
READ8_DEVICE_HANDLER( wd17xx_track_r ); DECLARE_READ8_DEVICE_HANDLER( wd17xx_track_r );
READ8_DEVICE_HANDLER( wd17xx_sector_r ); DECLARE_READ8_DEVICE_HANDLER( wd17xx_sector_r );
READ8_DEVICE_HANDLER( wd17xx_data_r ); DECLARE_READ8_DEVICE_HANDLER( wd17xx_data_r );
WRITE8_DEVICE_HANDLER( wd17xx_command_w ); DECLARE_WRITE8_DEVICE_HANDLER( wd17xx_command_w );
WRITE8_DEVICE_HANDLER( wd17xx_track_w ); DECLARE_WRITE8_DEVICE_HANDLER( wd17xx_track_w );
WRITE8_DEVICE_HANDLER( wd17xx_sector_w ); DECLARE_WRITE8_DEVICE_HANDLER( wd17xx_sector_w );
WRITE8_DEVICE_HANDLER( wd17xx_data_w ); DECLARE_WRITE8_DEVICE_HANDLER( wd17xx_data_w );
READ8_DEVICE_HANDLER( wd17xx_r ); DECLARE_READ8_DEVICE_HANDLER( wd17xx_r );
WRITE8_DEVICE_HANDLER( wd17xx_w ); DECLARE_WRITE8_DEVICE_HANDLER( wd17xx_w );
WRITE_LINE_DEVICE_HANDLER( wd17xx_mr_w ); WRITE_LINE_DEVICE_HANDLER( wd17xx_mr_w );
WRITE_LINE_DEVICE_HANDLER( wd17xx_rdy_w ); WRITE_LINE_DEVICE_HANDLER( wd17xx_rdy_w );

12
src/emu/machine/z80dart.c
View File

@ -1452,22 +1452,22 @@ WRITE_LINE_DEVICE_HANDLER( z80dart_rxtxcb_w ) { downcast<z80dart_device *>(devic
READ8_DEVICE_HANDLER( z80dart_cd_ba_r ) READ8_DEVICE_HANDLER( z80dart_cd_ba_r )
{ {
return (offset & 2) ? z80dart_c_r(device, offset & 1) : z80dart_d_r(device, offset & 1); return (offset & 2) ? z80dart_c_r(device, space, offset & 1) : z80dart_d_r(device, space, offset & 1);
} }
WRITE8_DEVICE_HANDLER( z80dart_cd_ba_w ) WRITE8_DEVICE_HANDLER( z80dart_cd_ba_w )
{ {
if (offset & 2) if (offset & 2)
z80dart_c_w(device, offset & 1, data); z80dart_c_w(device, space, offset & 1, data);
else else
z80dart_d_w(device, offset & 1, data); z80dart_d_w(device, space, offset & 1, data);
} }
READ8_DEVICE_HANDLER( z80dart_ba_cd_r ) READ8_DEVICE_HANDLER( z80dart_ba_cd_r )
{ {
int channel = BIT(offset, 1); int channel = BIT(offset, 1);
return (offset & 1) ? z80dart_c_r(device, channel) : z80dart_d_r(device, channel); return (offset & 1) ? z80dart_c_r(device, space, channel) : z80dart_d_r(device, space, channel);
} }
WRITE8_DEVICE_HANDLER( z80dart_ba_cd_w ) WRITE8_DEVICE_HANDLER( z80dart_ba_cd_w )
@ -1475,7 +1475,7 @@ WRITE8_DEVICE_HANDLER( z80dart_ba_cd_w )
int channel = BIT(offset, 1); int channel = BIT(offset, 1);
if (offset & 1) if (offset & 1)
z80dart_c_w(device, channel, data); z80dart_c_w(device, space, channel, data);
else else
z80dart_d_w(device, channel, data); z80dart_d_w(device, space, channel, data);
} }

16
src/emu/machine/z80dart.h
View File

@ -341,19 +341,19 @@ extern const device_type Z80SIO4;
//************************************************************************** //**************************************************************************
// register access // register access
READ8_DEVICE_HANDLER( z80dart_cd_ba_r ); DECLARE_READ8_DEVICE_HANDLER( z80dart_cd_ba_r );
WRITE8_DEVICE_HANDLER( z80dart_cd_ba_w ); DECLARE_WRITE8_DEVICE_HANDLER( z80dart_cd_ba_w );
READ8_DEVICE_HANDLER( z80dart_ba_cd_r ); DECLARE_READ8_DEVICE_HANDLER( z80dart_ba_cd_r );
WRITE8_DEVICE_HANDLER( z80dart_ba_cd_w ); DECLARE_WRITE8_DEVICE_HANDLER( z80dart_ba_cd_w );
// control register access // control register access
WRITE8_DEVICE_HANDLER( z80dart_c_w ); DECLARE_WRITE8_DEVICE_HANDLER( z80dart_c_w );
READ8_DEVICE_HANDLER( z80dart_c_r ); DECLARE_READ8_DEVICE_HANDLER( z80dart_c_r );
// data register access // data register access
WRITE8_DEVICE_HANDLER( z80dart_d_w ); DECLARE_WRITE8_DEVICE_HANDLER( z80dart_d_w );
READ8_DEVICE_HANDLER( z80dart_d_r ); DECLARE_READ8_DEVICE_HANDLER( z80dart_d_r );
// serial clocks // serial clocks
WRITE_LINE_DEVICE_HANDLER( z80dart_rxca_w ); WRITE_LINE_DEVICE_HANDLER( z80dart_rxca_w );

4
src/emu/machine/z80dma.h
View File

@ -168,8 +168,8 @@ extern const device_type Z80DMA;
//************************************************************************** //**************************************************************************
// register access // register access
READ8_DEVICE_HANDLER( z80dma_r ); DECLARE_READ8_DEVICE_HANDLER( z80dma_r );
WRITE8_DEVICE_HANDLER( z80dma_w ); DECLARE_WRITE8_DEVICE_HANDLER( z80dma_w );
// ready // ready
WRITE_LINE_DEVICE_HANDLER( z80dma_rdy_w ); WRITE_LINE_DEVICE_HANDLER( z80dma_rdy_w );

42
src/emu/machine/z80sio.c
View File

@ -243,8 +243,8 @@ const UINT8 z80sio_device::k_int_priority[] =
inline void z80sio_device::update_interrupt_state() inline void z80sio_device::update_interrupt_state()
{ {
// if we have a callback, update it with the current state // if we have a callback, update it with the current state
if (m_irq_cb != NULL) if (!m_irq.isnull())
(*m_irq_cb)(this, (z80daisy_irq_state() & Z80_DAISY_INT) ? ASSERT_LINE : CLEAR_LINE); m_irq((z80daisy_irq_state() & Z80_DAISY_INT) ? ASSERT_LINE : CLEAR_LINE);
} }
@ -318,17 +318,6 @@ void z80sio_device::device_config_complete()
const z80sio_interface *intf = reinterpret_cast<const z80sio_interface *>(static_config()); const z80sio_interface *intf = reinterpret_cast<const z80sio_interface *>(static_config());
if (intf != NULL) if (intf != NULL)
*static_cast<z80sio_interface *>(this) = *intf; *static_cast<z80sio_interface *>(this) = *intf;
// or initialize to defaults if none provided
else
{
m_irq_cb = NULL;
m_dtr_changed_cb = NULL;
m_rts_changed_cb = NULL;
m_break_changed_cb = NULL;
m_transmit_cb = NULL;
m_receive_poll_cb = NULL;
}
} }
@ -338,6 +327,13 @@ void z80sio_device::device_config_complete()
void z80sio_device::device_start() void z80sio_device::device_start()
{ {
m_irq.resolve(m_irq_cb, *this);
m_dtr_changed.resolve(m_dtr_changed_cb, *this);
m_rts_changed.resolve(m_rts_changed_cb, *this);
m_break_changed.resolve(m_break_changed_cb, *this);
m_transmit.resolve(m_transmit_cb, *this);
m_received_poll.resolve(m_received_poll_cb, *this);
m_channel[0].start(this, 0); m_channel[0].start(this, 0);
m_channel[1].start(this, 1); m_channel[1].start(this, 1);
} }
@ -566,12 +562,12 @@ void z80sio_device::sio_channel::control_write(UINT8 data)
// SIO write register 5 // SIO write register 5
case 5: case 5:
if (((old ^ data) & SIO_WR5_DTR) && m_device->m_dtr_changed_cb) if (((old ^ data) & SIO_WR5_DTR) && !m_device->m_dtr_changed.isnull())
(*m_device->m_dtr_changed_cb)(m_device, m_index, (data & SIO_WR5_DTR) != 0); m_device->m_dtr_changed(m_index, (data & SIO_WR5_DTR) != 0);
if (((old ^ data) & SIO_WR5_SEND_BREAK) && m_device->m_break_changed_cb) if (((old ^ data) & SIO_WR5_SEND_BREAK) && !m_device->m_break_changed.isnull())
(*m_device->m_break_changed_cb)(m_device, m_index, (data & SIO_WR5_SEND_BREAK) != 0); m_device->m_break_changed(m_index, (data & SIO_WR5_SEND_BREAK) != 0);
if (((old ^ data) & SIO_WR5_RTS) && m_device->m_rts_changed_cb) if (((old ^ data) & SIO_WR5_RTS) && !m_device->m_rts_changed.isnull())
(*m_device->m_rts_changed_cb)(m_device, m_index, (data & SIO_WR5_RTS) != 0); m_device->m_rts_changed(m_index, (data & SIO_WR5_RTS) != 0);
break; break;
} }
} }
@ -741,8 +737,8 @@ void z80sio_device::sio_channel::serial_callback()
VPRINTF(("serial_callback(%c): Transmitting %02x\n", 'A' + m_index, m_outbuf)); VPRINTF(("serial_callback(%c): Transmitting %02x\n", 'A' + m_index, m_outbuf));
// actually transmit the character // actually transmit the character
if (m_device->m_transmit_cb != NULL) if (!m_device->m_transmit.isnull())
(*m_device->m_transmit_cb)(m_device, m_index, m_outbuf); m_device->m_transmit(m_index, m_outbuf, 0xffff);
// update the status register // update the status register
m_status[0] |= SIO_RR0_TX_BUFFER_EMPTY; m_status[0] |= SIO_RR0_TX_BUFFER_EMPTY;
@ -756,8 +752,8 @@ void z80sio_device::sio_channel::serial_callback()
} }
// ask the polling callback if there is data to receive // ask the polling callback if there is data to receive
if (m_device->m_receive_poll_cb != NULL) if (!m_device->m_received_poll.isnull())
data = (*m_device->m_receive_poll_cb)(m_device, m_index); data = INT16(m_device->m_received_poll(m_index, 0xffff));
// if we have buffered data, pull it // if we have buffered data, pull it
if (m_receive_inptr != m_receive_outptr) if (m_receive_inptr != m_receive_outptr)

20
src/emu/machine/z80sio.h
View File

@ -32,12 +32,12 @@
struct z80sio_interface struct z80sio_interface
{ {
void (*m_irq_cb)(device_t *device, int state); devcb_write_line m_irq_cb;
write8_device_func m_dtr_changed_cb; devcb_write8 m_dtr_changed_cb;
write8_device_func m_rts_changed_cb; devcb_write8 m_rts_changed_cb;
write8_device_func m_break_changed_cb; devcb_write8 m_break_changed_cb;
write8_device_func m_transmit_cb; devcb_write16 m_transmit_cb;
int (*m_receive_poll_cb)(device_t *device, int channel); devcb_read16 m_received_poll_cb;
}; };
@ -140,6 +140,14 @@ private:
sio_channel m_channel[2]; // 2 channels sio_channel m_channel[2]; // 2 channels
UINT8 m_int_state[8]; // interrupt states UINT8 m_int_state[8]; // interrupt states
// callbacks
devcb_resolved_write_line m_irq;
devcb_resolved_write8 m_dtr_changed;
devcb_resolved_write8 m_rts_changed;
devcb_resolved_write8 m_break_changed;
devcb_resolved_write16 m_transmit;
devcb_resolved_read16 m_received_poll;
static const UINT8 k_int_priority[]; static const UINT8 k_int_priority[];
}; };

4
src/emu/machine/z80sti.h
View File

@ -183,8 +183,8 @@ extern const device_type Z80STI;
//************************************************************************** //**************************************************************************
// register access // register access
READ8_DEVICE_HANDLER( z80sti_r ); DECLARE_READ8_DEVICE_HANDLER( z80sti_r );
WRITE8_DEVICE_HANDLER( z80sti_w ); DECLARE_WRITE8_DEVICE_HANDLER( z80sti_w );
// receive clock // receive clock
WRITE_LINE_DEVICE_HANDLER( z80sti_rc_w ); WRITE_LINE_DEVICE_HANDLER( z80sti_rc_w );

23
src/emu/memory.c
View File

@ -1998,29 +1998,6 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
} }
break; break;
case AMH_LEGACY_DEVICE_HANDLER:
target_device = device().siblingdevice(data.m_tag);
if (target_device == NULL)
fatalerror("Attempted to map a non-existent device '%s' in space %s of device '%s'\n", data.m_tag.cstr(), m_name, m_device.tag());
if (readorwrite == ROW_READ)
switch (data.m_bits)
{
case 8: install_legacy_read_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_rdevice8, data.m_name, data.m_mask); break;
case 16: install_legacy_read_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_rdevice16, data.m_name, data.m_mask); break;
case 32: install_legacy_read_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_rdevice32, data.m_name, data.m_mask); break;
case 64: install_legacy_read_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_rdevice64, data.m_name, data.m_mask); break;
}
else
switch (data.m_bits)
{
case 8: install_legacy_write_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_wdevice8, data.m_name, data.m_mask); break;
case 16: install_legacy_write_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_wdevice16, data.m_name, data.m_mask); break;
case 32: install_legacy_write_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_wdevice32, data.m_name, data.m_mask); break;
case 64: install_legacy_write_handler(*target_device, entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, entry.m_wdevice64, data.m_name, data.m_mask); break;
}
break;
case AMH_PORT: case AMH_PORT:
install_readwrite_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, install_readwrite_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
(readorwrite == ROW_READ) ? data.m_tag.cstr() : NULL, (readorwrite == ROW_READ) ? data.m_tag.cstr() : NULL,

41
src/emu/memory.h
View File

@ -122,14 +122,14 @@ typedef UINT64 (*read64_space_func) (ATTR_UNUSED address_space *space, ATTR_UNUS
typedef void (*write64_space_func)(ATTR_UNUSED address_space *space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask); typedef void (*write64_space_func)(ATTR_UNUSED address_space *space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask);
// legacy device read/write handlers // legacy device read/write handlers
typedef UINT8 (*read8_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset); typedef UINT8 (*read8_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask);
typedef void (*write8_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data); typedef void (*write8_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask);
typedef UINT16 (*read16_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask); typedef UINT16 (*read16_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask);
typedef void (*write16_device_func)(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask); typedef void (*write16_device_func)(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask);
typedef UINT32 (*read32_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask); typedef UINT32 (*read32_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask);
typedef void (*write32_device_func)(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask); typedef void (*write32_device_func)(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask);
typedef UINT64 (*read64_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask); typedef UINT64 (*read64_device_func) (ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask);
typedef void (*write64_device_func)(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask); typedef void (*write64_device_func)(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask);
// struct with function pointers for accessors; use is generally discouraged unless necessary // struct with function pointers for accessors; use is generally discouraged unless necessary
@ -887,14 +887,23 @@ private:
// device read/write handler function macros // device read/write handler function macros
#define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset) #define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask)
#define WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data) #define WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask)
#define READ16_DEVICE_HANDLER(name) UINT16 name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask) #define READ16_DEVICE_HANDLER(name) UINT16 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask)
#define WRITE16_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask) #define WRITE16_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask)
#define READ32_DEVICE_HANDLER(name) UINT32 name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask) #define READ32_DEVICE_HANDLER(name) UINT32 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask)
#define WRITE32_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask) #define WRITE32_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask)
#define READ64_DEVICE_HANDLER(name) UINT64 name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask) #define READ64_DEVICE_HANDLER(name) UINT64 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask)
#define WRITE64_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask) #define WRITE64_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask)
#define DECLARE_READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 mem_mask = 0xff)
#define DECLARE_WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data, ATTR_UNUSED UINT8 mem_mask = 0xff)
#define DECLARE_READ16_DEVICE_HANDLER(name) UINT16 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask = 0xffff)
#define DECLARE_WRITE16_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask = 0xffff)
#define DECLARE_READ32_DEVICE_HANDLER(name) UINT32 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask = 0xffffffff)
#define DECLARE_WRITE32_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask = 0xffffffff)
#define DECLARE_READ64_DEVICE_HANDLER(name) UINT64 name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask = U64(0xffffffffffffffff))
#define DECLARE_WRITE64_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_t *device, ATTR_UNUSED address_space &space, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask = U64(0xffffffffffffffff))
// space read/write handler function macros // space read/write handler function macros

6
src/emu/sound/2151intf.c
View File

@ -112,10 +112,10 @@ WRITE8_DEVICE_HANDLER( ym2151_w )
} }
READ8_DEVICE_HANDLER( ym2151_status_port_r ) { return ym2151_r(device, 1); } READ8_DEVICE_HANDLER( ym2151_status_port_r ) { return ym2151_r(device, space, 1); }
WRITE8_DEVICE_HANDLER( ym2151_register_port_w ) { ym2151_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym2151_register_port_w ) { ym2151_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym2151_data_port_w ) { ym2151_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym2151_data_port_w ) { ym2151_w(device, space, 1, data); }
const device_type YM2151 = &device_creator<ym2151_device>; const device_type YM2151 = &device_creator<ym2151_device>;

10
src/emu/sound/2151intf.h
View File

@ -11,12 +11,12 @@ struct ym2151_interface
devcb_write8 portwritehandler; devcb_write8 portwritehandler;
}; };
READ8_DEVICE_HANDLER( ym2151_r ); DECLARE_READ8_DEVICE_HANDLER( ym2151_r );
WRITE8_DEVICE_HANDLER( ym2151_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2151_w );
READ8_DEVICE_HANDLER( ym2151_status_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym2151_status_port_r );
WRITE8_DEVICE_HANDLER( ym2151_register_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2151_register_port_w );
WRITE8_DEVICE_HANDLER( ym2151_data_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2151_data_port_w );
class ym2151_device : public device_t, class ym2151_device : public device_t,
public device_sound_interface public device_sound_interface

8
src/emu/sound/2203intf.c
View File

@ -175,10 +175,10 @@ WRITE8_DEVICE_HANDLER( ym2203_w )
} }
READ8_DEVICE_HANDLER( ym2203_status_port_r ) { return ym2203_r(device, 0); } READ8_DEVICE_HANDLER( ym2203_status_port_r ) { return ym2203_r(device, space, 0); }
READ8_DEVICE_HANDLER( ym2203_read_port_r ) { return ym2203_r(device, 1); } READ8_DEVICE_HANDLER( ym2203_read_port_r ) { return ym2203_r(device, space, 1); }
WRITE8_DEVICE_HANDLER( ym2203_control_port_w ) { ym2203_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym2203_control_port_w ) { ym2203_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym2203_write_port_w ) { ym2203_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym2203_write_port_w ) { ym2203_w(device, space, 1, data); }
const device_type YM2203 = &device_creator<ym2203_device>; const device_type YM2203 = &device_creator<ym2203_device>;

12
src/emu/sound/2203intf.h
View File

@ -15,13 +15,13 @@ struct ym2203_interface
devcb_write_line irqhandler; devcb_write_line irqhandler;
}; };
READ8_DEVICE_HANDLER( ym2203_r ); DECLARE_READ8_DEVICE_HANDLER( ym2203_r );
WRITE8_DEVICE_HANDLER( ym2203_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2203_w );
READ8_DEVICE_HANDLER( ym2203_status_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym2203_status_port_r );
READ8_DEVICE_HANDLER( ym2203_read_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym2203_read_port_r );
WRITE8_DEVICE_HANDLER( ym2203_control_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2203_control_port_w );
WRITE8_DEVICE_HANDLER( ym2203_write_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2203_write_port_w );
class ym2203_device : public device_t, class ym2203_device : public device_t,
public device_sound_interface public device_sound_interface

4
src/emu/sound/2413intf.c
View File

@ -111,8 +111,8 @@ WRITE8_DEVICE_HANDLER( ym2413_w )
ym2413_write(info->chip, offset & 1, data); ym2413_write(info->chip, offset & 1, data);
} }
WRITE8_DEVICE_HANDLER( ym2413_register_port_w ) { ym2413_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym2413_register_port_w ) { ym2413_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym2413_data_port_w ) { ym2413_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym2413_data_port_w ) { ym2413_w(device, space, 1, data); }
const device_type YM2413 = &device_creator<ym2413_device>; const device_type YM2413 = &device_creator<ym2413_device>;

6
src/emu/sound/2413intf.h
View File

@ -5,10 +5,10 @@
#include "devlegcy.h" #include "devlegcy.h"
WRITE8_DEVICE_HANDLER( ym2413_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2413_w );
WRITE8_DEVICE_HANDLER( ym2413_register_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2413_register_port_w );
WRITE8_DEVICE_HANDLER( ym2413_data_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2413_data_port_w );
class ym2413_device : public device_t, class ym2413_device : public device_t,
public device_sound_interface public device_sound_interface

14
src/emu/sound/2608intf.c
View File

@ -194,14 +194,14 @@ WRITE8_DEVICE_HANDLER( ym2608_w )
ym2608_write(info->chip, offset & 3, data); ym2608_write(info->chip, offset & 3, data);
} }
READ8_DEVICE_HANDLER( ym2608_read_port_r ) { return ym2608_r(device, 1); } READ8_DEVICE_HANDLER( ym2608_read_port_r ) { return ym2608_r(device, space, 1); }
READ8_DEVICE_HANDLER( ym2608_status_port_a_r ) { return ym2608_r(device, 0); } READ8_DEVICE_HANDLER( ym2608_status_port_a_r ) { return ym2608_r(device, space, 0); }
READ8_DEVICE_HANDLER( ym2608_status_port_b_r ) { return ym2608_r(device, 2); } READ8_DEVICE_HANDLER( ym2608_status_port_b_r ) { return ym2608_r(device, space, 2); }
WRITE8_DEVICE_HANDLER( ym2608_control_port_a_w ) { ym2608_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym2608_control_port_a_w ) { ym2608_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym2608_control_port_b_w ) { ym2608_w(device, 2, data); } WRITE8_DEVICE_HANDLER( ym2608_control_port_b_w ) { ym2608_w(device, space, 2, data); }
WRITE8_DEVICE_HANDLER( ym2608_data_port_a_w ) { ym2608_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym2608_data_port_a_w ) { ym2608_w(device, space, 1, data); }
WRITE8_DEVICE_HANDLER( ym2608_data_port_b_w ) { ym2608_w(device, 3, data); } WRITE8_DEVICE_HANDLER( ym2608_data_port_b_w ) { ym2608_w(device, space, 3, data); }
const device_type YM2608 = &device_creator<ym2608_device>; const device_type YM2608 = &device_creator<ym2608_device>;

18
src/emu/sound/2608intf.h
View File

@ -16,17 +16,17 @@ struct ym2608_interface
void ( *handler )( device_t *device, int irq ); /* IRQ handler for the YM2608 */ void ( *handler )( device_t *device, int irq ); /* IRQ handler for the YM2608 */
}; };
READ8_DEVICE_HANDLER( ym2608_r ); DECLARE_READ8_DEVICE_HANDLER( ym2608_r );
WRITE8_DEVICE_HANDLER( ym2608_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2608_w );
READ8_DEVICE_HANDLER( ym2608_read_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym2608_read_port_r );
READ8_DEVICE_HANDLER( ym2608_status_port_a_r ); DECLARE_READ8_DEVICE_HANDLER( ym2608_status_port_a_r );
READ8_DEVICE_HANDLER( ym2608_status_port_b_r ); DECLARE_READ8_DEVICE_HANDLER( ym2608_status_port_b_r );
WRITE8_DEVICE_HANDLER( ym2608_control_port_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2608_control_port_a_w );
WRITE8_DEVICE_HANDLER( ym2608_control_port_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2608_control_port_b_w );
WRITE8_DEVICE_HANDLER( ym2608_data_port_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2608_data_port_a_w );
WRITE8_DEVICE_HANDLER( ym2608_data_port_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2608_data_port_b_w );
class ym2608_device : public device_t, class ym2608_device : public device_t,
public device_sound_interface public device_sound_interface

14
src/emu/sound/2610intf.c
View File

@ -207,14 +207,14 @@ WRITE8_DEVICE_HANDLER( ym2610_w )
} }
READ8_DEVICE_HANDLER( ym2610_status_port_a_r ) { return ym2610_r(device, 0); } READ8_DEVICE_HANDLER( ym2610_status_port_a_r ) { return ym2610_r(device, space, 0); }
READ8_DEVICE_HANDLER( ym2610_status_port_b_r ) { return ym2610_r(device, 2); } READ8_DEVICE_HANDLER( ym2610_status_port_b_r ) { return ym2610_r(device, space, 2); }
READ8_DEVICE_HANDLER( ym2610_read_port_r ) { return ym2610_r(device, 1); } READ8_DEVICE_HANDLER( ym2610_read_port_r ) { return ym2610_r(device, space, 1); }
WRITE8_DEVICE_HANDLER( ym2610_control_port_a_w ) { ym2610_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym2610_control_port_a_w ) { ym2610_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym2610_control_port_b_w ) { ym2610_w(device, 2, data); } WRITE8_DEVICE_HANDLER( ym2610_control_port_b_w ) { ym2610_w(device, space, 2, data); }
WRITE8_DEVICE_HANDLER( ym2610_data_port_a_w ) { ym2610_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym2610_data_port_a_w ) { ym2610_w(device, space, 1, data); }
WRITE8_DEVICE_HANDLER( ym2610_data_port_b_w ) { ym2610_w(device, 3, data); } WRITE8_DEVICE_HANDLER( ym2610_data_port_b_w ) { ym2610_w(device, space, 3, data); }
const device_type YM2610 = &device_creator<ym2610_device>; const device_type YM2610 = &device_creator<ym2610_device>;

18
src/emu/sound/2610intf.h
View File

@ -14,17 +14,17 @@ struct ym2610_interface
void ( *handler )( device_t *device, int irq ); /* IRQ handler for the YM2610 */ void ( *handler )( device_t *device, int irq ); /* IRQ handler for the YM2610 */
}; };
READ8_DEVICE_HANDLER( ym2610_r ); DECLARE_READ8_DEVICE_HANDLER( ym2610_r );
WRITE8_DEVICE_HANDLER( ym2610_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2610_w );
READ8_DEVICE_HANDLER( ym2610_status_port_a_r ); DECLARE_READ8_DEVICE_HANDLER( ym2610_status_port_a_r );
READ8_DEVICE_HANDLER( ym2610_status_port_b_r ); DECLARE_READ8_DEVICE_HANDLER( ym2610_status_port_b_r );
READ8_DEVICE_HANDLER( ym2610_read_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym2610_read_port_r );
WRITE8_DEVICE_HANDLER( ym2610_control_port_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2610_control_port_a_w );
WRITE8_DEVICE_HANDLER( ym2610_control_port_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2610_control_port_b_w );
WRITE8_DEVICE_HANDLER( ym2610_data_port_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2610_data_port_a_w );
WRITE8_DEVICE_HANDLER( ym2610_data_port_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2610_data_port_b_w );
class ym2610_device : public device_t, class ym2610_device : public device_t,

16
src/emu/sound/2612intf.c
View File

@ -146,15 +146,15 @@ WRITE8_DEVICE_HANDLER( ym2612_w )
} }
READ8_DEVICE_HANDLER( ym2612_status_port_a_r ) { return ym2612_r(device, 0); } READ8_DEVICE_HANDLER( ym2612_status_port_a_r ) { return ym2612_r(device, space, 0); }
READ8_DEVICE_HANDLER( ym2612_status_port_b_r ) { return ym2612_r(device, 2); } READ8_DEVICE_HANDLER( ym2612_status_port_b_r ) { return ym2612_r(device, space, 2); }
READ8_DEVICE_HANDLER( ym2612_data_port_a_r ) { return ym2612_r(device, 1); } READ8_DEVICE_HANDLER( ym2612_data_port_a_r ) { return ym2612_r(device, space, 1); }
READ8_DEVICE_HANDLER( ym2612_data_port_b_r ) { return ym2612_r(device, 3); } READ8_DEVICE_HANDLER( ym2612_data_port_b_r ) { return ym2612_r(device, space, 3); }
WRITE8_DEVICE_HANDLER( ym2612_control_port_a_w ) { ym2612_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym2612_control_port_a_w ) { ym2612_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym2612_control_port_b_w ) { ym2612_w(device, 2, data); } WRITE8_DEVICE_HANDLER( ym2612_control_port_b_w ) { ym2612_w(device, space, 2, data); }
WRITE8_DEVICE_HANDLER( ym2612_data_port_a_w ) { ym2612_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym2612_data_port_a_w ) { ym2612_w(device, space, 1, data); }
WRITE8_DEVICE_HANDLER( ym2612_data_port_b_w ) { ym2612_w(device, 3, data); } WRITE8_DEVICE_HANDLER( ym2612_data_port_b_w ) { ym2612_w(device, space, 3, data); }
const device_type YM2612 = &device_creator<ym2612_device>; const device_type YM2612 = &device_creator<ym2612_device>;

20
src/emu/sound/2612intf.h
View File

@ -12,18 +12,18 @@ struct ym2612_interface
void (*handler)(device_t *device, int irq); void (*handler)(device_t *device, int irq);
}; };
READ8_DEVICE_HANDLER( ym2612_r ); DECLARE_READ8_DEVICE_HANDLER( ym2612_r );
WRITE8_DEVICE_HANDLER( ym2612_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2612_w );
READ8_DEVICE_HANDLER( ym2612_status_port_a_r ); DECLARE_READ8_DEVICE_HANDLER( ym2612_status_port_a_r );
READ8_DEVICE_HANDLER( ym2612_status_port_b_r ); DECLARE_READ8_DEVICE_HANDLER( ym2612_status_port_b_r );
READ8_DEVICE_HANDLER( ym2612_data_port_a_r ); DECLARE_READ8_DEVICE_HANDLER( ym2612_data_port_a_r );
READ8_DEVICE_HANDLER( ym2612_data_port_b_r ); DECLARE_READ8_DEVICE_HANDLER( ym2612_data_port_b_r );
WRITE8_DEVICE_HANDLER( ym2612_control_port_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2612_control_port_a_w );
WRITE8_DEVICE_HANDLER( ym2612_control_port_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2612_control_port_b_w );
WRITE8_DEVICE_HANDLER( ym2612_data_port_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2612_data_port_a_w );
WRITE8_DEVICE_HANDLER( ym2612_data_port_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym2612_data_port_b_w );
class ym2612_device : public device_t, class ym2612_device : public device_t,

10
src/emu/sound/262intf.c
View File

@ -124,11 +124,11 @@ WRITE8_DEVICE_HANDLER( ymf262_w )
ymf262_write(info->chip, offset & 3, data); ymf262_write(info->chip, offset & 3, data);
} }
READ8_DEVICE_HANDLER ( ymf262_status_r ) { return ymf262_r(device, 0); } READ8_DEVICE_HANDLER ( ymf262_status_r ) { return ymf262_r(device, space, 0); }
WRITE8_DEVICE_HANDLER( ymf262_register_a_w ) { ymf262_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ymf262_register_a_w ) { ymf262_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ymf262_register_b_w ) { ymf262_w(device, 2, data); } WRITE8_DEVICE_HANDLER( ymf262_register_b_w ) { ymf262_w(device, space, 2, data); }
WRITE8_DEVICE_HANDLER( ymf262_data_a_w ) { ymf262_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ymf262_data_a_w ) { ymf262_w(device, space, 1, data); }
WRITE8_DEVICE_HANDLER( ymf262_data_b_w ) { ymf262_w(device, 3, data); } WRITE8_DEVICE_HANDLER( ymf262_data_b_w ) { ymf262_w(device, space, 3, data); }
const device_type YMF262 = &device_creator<ymf262_device>; const device_type YMF262 = &device_creator<ymf262_device>;

14
src/emu/sound/262intf.h
View File

@ -12,14 +12,14 @@ struct ymf262_interface
}; };
READ8_DEVICE_HANDLER( ymf262_r ); DECLARE_READ8_DEVICE_HANDLER( ymf262_r );
WRITE8_DEVICE_HANDLER( ymf262_w ); DECLARE_WRITE8_DEVICE_HANDLER( ymf262_w );
READ8_DEVICE_HANDLER ( ymf262_status_r ); DECLARE_READ8_DEVICE_HANDLER ( ymf262_status_r );
WRITE8_DEVICE_HANDLER( ymf262_register_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ymf262_register_a_w );
WRITE8_DEVICE_HANDLER( ymf262_register_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ymf262_register_b_w );
WRITE8_DEVICE_HANDLER( ymf262_data_a_w ); DECLARE_WRITE8_DEVICE_HANDLER( ymf262_data_a_w );
WRITE8_DEVICE_HANDLER( ymf262_data_b_w ); DECLARE_WRITE8_DEVICE_HANDLER( ymf262_data_b_w );
class ymf262_device : public device_t, class ymf262_device : public device_t,

8
src/emu/sound/3526intf.c
View File

@ -138,10 +138,10 @@ WRITE8_DEVICE_HANDLER( ym3526_w )
ym3526_write(info->chip, offset & 1, data); ym3526_write(info->chip, offset & 1, data);
} }
READ8_DEVICE_HANDLER( ym3526_status_port_r ) { return ym3526_r(device, 0); } READ8_DEVICE_HANDLER( ym3526_status_port_r ) { return ym3526_r(device, space, 0); }
READ8_DEVICE_HANDLER( ym3526_read_port_r ) { return ym3526_r(device, 1); } READ8_DEVICE_HANDLER( ym3526_read_port_r ) { return ym3526_r(device, space, 1); }
WRITE8_DEVICE_HANDLER( ym3526_control_port_w ) { ym3526_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym3526_control_port_w ) { ym3526_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym3526_write_port_w ) { ym3526_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym3526_write_port_w ) { ym3526_w(device, space, 1, data); }
const device_type YM3526 = &device_creator<ym3526_device>; const device_type YM3526 = &device_creator<ym3526_device>;

12
src/emu/sound/3526intf.h
View File

@ -10,13 +10,13 @@ struct ym3526_interface
devcb_write_line out_int_func; devcb_write_line out_int_func;
}; };
READ8_DEVICE_HANDLER( ym3526_r ); DECLARE_READ8_DEVICE_HANDLER( ym3526_r );
WRITE8_DEVICE_HANDLER( ym3526_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym3526_w );
READ8_DEVICE_HANDLER( ym3526_status_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym3526_status_port_r );
READ8_DEVICE_HANDLER( ym3526_read_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym3526_read_port_r );
WRITE8_DEVICE_HANDLER( ym3526_control_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym3526_control_port_w );
WRITE8_DEVICE_HANDLER( ym3526_write_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym3526_write_port_w );
class ym3526_device : public device_t, class ym3526_device : public device_t,
public device_sound_interface public device_sound_interface

8
src/emu/sound/3812intf.c
View File

@ -134,10 +134,10 @@ WRITE8_DEVICE_HANDLER( ym3812_w )
ym3812_write(info->chip, offset & 1, data); ym3812_write(info->chip, offset & 1, data);
} }
READ8_DEVICE_HANDLER( ym3812_status_port_r ) { return ym3812_r(device, 0); } READ8_DEVICE_HANDLER( ym3812_status_port_r ) { return ym3812_r(device, space, 0); }
READ8_DEVICE_HANDLER( ym3812_read_port_r ) { return ym3812_r(device, 1); } READ8_DEVICE_HANDLER( ym3812_read_port_r ) { return ym3812_r(device, space, 1); }
WRITE8_DEVICE_HANDLER( ym3812_control_port_w ) { ym3812_w(device, 0, data); } WRITE8_DEVICE_HANDLER( ym3812_control_port_w ) { ym3812_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( ym3812_write_port_w ) { ym3812_w(device, 1, data); } WRITE8_DEVICE_HANDLER( ym3812_write_port_w ) { ym3812_w(device, space, 1, data); }
const device_type YM3812 = &device_creator<ym3812_device>; const device_type YM3812 = &device_creator<ym3812_device>;

12
src/emu/sound/3812intf.h
View File

@ -10,13 +10,13 @@ struct ym3812_interface
void (*handler)(device_t *device, int linestate); void (*handler)(device_t *device, int linestate);
}; };
READ8_DEVICE_HANDLER( ym3812_r ); DECLARE_READ8_DEVICE_HANDLER( ym3812_r );
WRITE8_DEVICE_HANDLER( ym3812_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym3812_w );
READ8_DEVICE_HANDLER( ym3812_status_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym3812_status_port_r );
READ8_DEVICE_HANDLER( ym3812_read_port_r ); DECLARE_READ8_DEVICE_HANDLER( ym3812_read_port_r );
WRITE8_DEVICE_HANDLER( ym3812_control_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym3812_control_port_w );
WRITE8_DEVICE_HANDLER( ym3812_write_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( ym3812_write_port_w );
class ym3812_device : public device_t, class ym3812_device : public device_t,
public device_sound_interface public device_sound_interface

42
src/emu/sound/8950intf.c
View File

@ -28,7 +28,7 @@ struct y8950_state
emu_timer * timer[2]; emu_timer * timer[2];
void * chip; void * chip;
const y8950_interface *intf; const y8950_interface *intf;
device_t *device; y8950_device *device;
}; };
@ -43,7 +43,7 @@ INLINE y8950_state *get_safe_token(device_t *device)
static void IRQHandler(void *param,int irq) static void IRQHandler(void *param,int irq)
{ {
y8950_state *info = (y8950_state *)param; y8950_state *info = (y8950_state *)param;
if (info->intf->handler) (info->intf->handler)(info->device, irq ? ASSERT_LINE : CLEAR_LINE); if (!info->device->m_handler.isnull()) info->device->m_handler(irq ? ASSERT_LINE : CLEAR_LINE);
} }
static TIMER_CALLBACK( timer_callback_0 ) static TIMER_CALLBACK( timer_callback_0 )
{ {
@ -72,31 +72,31 @@ static void TimerHandler(void *param,int c,attotime period)
static unsigned char Y8950PortHandler_r(void *param) static unsigned char Y8950PortHandler_r(void *param)
{ {
y8950_state *info = (y8950_state *)param; y8950_state *info = (y8950_state *)param;
if (info->intf->portread) if (!info->device->m_portread.isnull())
return info->intf->portread(info->device,0); return info->device->m_portread(0);
return 0; return 0;
} }
static void Y8950PortHandler_w(void *param,unsigned char data) static void Y8950PortHandler_w(void *param,unsigned char data)
{ {
y8950_state *info = (y8950_state *)param; y8950_state *info = (y8950_state *)param;
if (info->intf->portwrite) if (!info->device->m_portwrite.isnull())
info->intf->portwrite(info->device,0,data); info->device->m_portwrite(0,data);
} }
static unsigned char Y8950KeyboardHandler_r(void *param) static unsigned char Y8950KeyboardHandler_r(void *param)
{ {
y8950_state *info = (y8950_state *)param; y8950_state *info = (y8950_state *)param;
if (info->intf->keyboardread) if (!info->device->m_keyboardread.isnull())
return info->intf->keyboardread(info->device,0); return info->device->m_keyboardread(0);
return 0; return 0;
} }
static void Y8950KeyboardHandler_w(void *param,unsigned char data) static void Y8950KeyboardHandler_w(void *param,unsigned char data)
{ {
y8950_state *info = (y8950_state *)param; y8950_state *info = (y8950_state *)param;
if (info->intf->keyboardwrite) if (!info->device->m_keyboardwrite.isnull())
info->intf->keyboardwrite(info->device,0,data); info->device->m_keyboardwrite(0,data);
} }
static STREAM_UPDATE( y8950_stream_update ) static STREAM_UPDATE( y8950_stream_update )
@ -114,12 +114,12 @@ static void _stream_update(void *param, int interval)
static DEVICE_START( y8950 ) static DEVICE_START( y8950 )
{ {
static const y8950_interface dummy = { 0 }; static const y8950_interface dummy = { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL };
y8950_state *info = get_safe_token(device); y8950_state *info = get_safe_token(device);
int rate = device->clock()/72; int rate = device->clock()/72;
info->intf = device->static_config() ? (const y8950_interface *)device->static_config() : &dummy; info->intf = device->static_config() ? (const y8950_interface *)device->static_config() : &dummy;
info->device = device; info->device = downcast<y8950_device *>(device);
/* stream system initialize */ /* stream system initialize */
info->chip = y8950_init(device,device->clock(),rate); info->chip = y8950_init(device,device->clock(),rate);
@ -167,10 +167,10 @@ WRITE8_DEVICE_HANDLER( y8950_w )
y8950_write(info->chip, offset & 1, data); y8950_write(info->chip, offset & 1, data);
} }
READ8_DEVICE_HANDLER( y8950_status_port_r ) { return y8950_r(device, 0); } READ8_DEVICE_HANDLER( y8950_status_port_r ) { return y8950_r(device, space, 0); }
READ8_DEVICE_HANDLER( y8950_read_port_r ) { return y8950_r(device, 1); } READ8_DEVICE_HANDLER( y8950_read_port_r ) { return y8950_r(device, space, 1); }
WRITE8_DEVICE_HANDLER( y8950_control_port_w ) { y8950_w(device, 0, data); } WRITE8_DEVICE_HANDLER( y8950_control_port_w ) { y8950_w(device, space, 0, data); }
WRITE8_DEVICE_HANDLER( y8950_write_port_w ) { y8950_w(device, 1, data); } WRITE8_DEVICE_HANDLER( y8950_write_port_w ) { y8950_w(device, space, 1, data); }
const device_type Y8950 = &device_creator<y8950_device>; const device_type Y8950 = &device_creator<y8950_device>;
@ -198,6 +198,16 @@ void y8950_device::device_config_complete()
void y8950_device::device_start() void y8950_device::device_start()
{ {
const y8950_interface *intf = (const y8950_interface *)static_config();
if (intf != NULL)
{
m_handler.resolve(intf->handler_cb, *this);
m_keyboardread.resolve(intf->keyboardread_cb, *this);
m_keyboardwrite.resolve(intf->keyboardwrite_cb, *this);
m_portread.resolve(intf->portread_cb, *this);
m_portwrite.resolve(intf->portwrite_cb, *this);
}
DEVICE_START_NAME( y8950 )(this); DEVICE_START_NAME( y8950 )(this);
} }

29
src/emu/sound/8950intf.h
View File

@ -7,21 +7,20 @@
struct y8950_interface struct y8950_interface
{ {
void (*handler)(device_t *device, int linestate); devcb_write_line handler_cb;
devcb_read8 keyboardread_cb;
read8_device_func keyboardread; devcb_write8 keyboardwrite_cb;
write8_device_func keyboardwrite; devcb_read8 portread_cb;
read8_device_func portread; devcb_write8 portwrite_cb;
write8_device_func portwrite;
}; };
READ8_DEVICE_HANDLER( y8950_r ); DECLARE_READ8_DEVICE_HANDLER( y8950_r );
WRITE8_DEVICE_HANDLER( y8950_w ); DECLARE_WRITE8_DEVICE_HANDLER( y8950_w );
READ8_DEVICE_HANDLER( y8950_status_port_r ); DECLARE_READ8_DEVICE_HANDLER( y8950_status_port_r );
READ8_DEVICE_HANDLER( y8950_read_port_r ); DECLARE_READ8_DEVICE_HANDLER( y8950_read_port_r );
WRITE8_DEVICE_HANDLER( y8950_control_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( y8950_control_port_w );
WRITE8_DEVICE_HANDLER( y8950_write_port_w ); DECLARE_WRITE8_DEVICE_HANDLER( y8950_write_port_w );
class y8950_device : public device_t, class y8950_device : public device_t,
public device_sound_interface public device_sound_interface
@ -44,6 +43,12 @@ protected:
private: private:
// internal state // internal state
void *m_token; void *m_token;
public:
devcb_resolved_write_line m_handler;
devcb_resolved_read8 m_keyboardread;
devcb_resolved_write8 m_keyboardwrite;
devcb_resolved_read8 m_portread;
devcb_resolved_write8 m_portwrite;
}; };
extern const device_type Y8950; extern const device_type Y8950;

20
src/emu/sound/aica.c
View File

@ -681,7 +681,7 @@ static void AICA_UpdateSlotReg(aica_state *AICA,int s,int r)
} }
} }
static void AICA_UpdateReg(aica_state *AICA, int reg) static void AICA_UpdateReg(aica_state *AICA, address_space &space, int reg)
{ {
switch(reg&0xff) switch(reg&0xff)
{ {
@ -702,7 +702,7 @@ static void AICA_UpdateReg(aica_state *AICA, int reg)
break; break;
case 0x8: case 0x8:
case 0x9: case 0x9:
aica_midi_in(AICA->device, 0, AICA->udata.data[0x8/2]&0xff, 0xffff); aica_midi_in(AICA->device, space, 0, AICA->udata.data[0x8/2]&0xff, 0xffff);
break; break;
case 0x12: case 0x12:
case 0x13: case 0x13:
@ -823,7 +823,7 @@ static void AICA_UpdateSlotRegR(aica_state *AICA, int slot,int reg)
} }
static void AICA_UpdateRegR(aica_state *AICA, int reg) static void AICA_UpdateRegR(aica_state *AICA, address_space &space, int reg)
{ {
switch(reg&0xff) switch(reg&0xff)
{ {
@ -894,7 +894,7 @@ static void AICA_UpdateRegR(aica_state *AICA, int reg)
} }
} }
static void AICA_w16(aica_state *AICA,unsigned int addr,unsigned short val) static void AICA_w16(aica_state *AICA,address_space &space,unsigned int addr,unsigned short val)
{ {
addr&=0xffff; addr&=0xffff;
if(addr<0x2000) if(addr<0x2000)
@ -919,7 +919,7 @@ static void AICA_w16(aica_state *AICA,unsigned int addr,unsigned short val)
{ {
// printf("%x to AICA global @ %x\n", val, addr & 0xff); // printf("%x to AICA global @ %x\n", val, addr & 0xff);
*((unsigned short *) (AICA->udata.datab+((addr&0xff)))) = val; *((unsigned short *) (AICA->udata.datab+((addr&0xff)))) = val;
AICA_UpdateReg(AICA, addr&0xff); AICA_UpdateReg(AICA, space, addr&0xff);
} }
else if (addr == 0x2d00) else if (addr == 0x2d00)
{ {
@ -954,7 +954,7 @@ static void AICA_w16(aica_state *AICA,unsigned int addr,unsigned short val)
} }
} }
static unsigned short AICA_r16(aica_state *AICA, unsigned int addr) static unsigned short AICA_r16(aica_state *AICA, address_space &space, unsigned int addr)
{ {
unsigned short v=0; unsigned short v=0;
addr&=0xffff; addr&=0xffff;
@ -973,7 +973,7 @@ static unsigned short AICA_r16(aica_state *AICA, unsigned int addr)
} }
else if (addr < 0x28be) else if (addr < 0x28be)
{ {
AICA_UpdateRegR(AICA, addr&0xff); AICA_UpdateRegR(AICA, space, addr&0xff);
v= *((unsigned short *) (AICA->udata.datab+((addr&0xff)))); v= *((unsigned short *) (AICA->udata.datab+((addr&0xff))));
if((addr&0xfffe)==0x2810) AICA->udata.data[0x10/2] &= 0x7FFF; // reset LP on read if((addr&0xfffe)==0x2810) AICA->udata.data[0x10/2] &= 0x7FFF; // reset LP on read
} }
@ -1323,7 +1323,7 @@ void aica_set_ram_base(device_t *device, void *base, int size)
READ16_DEVICE_HANDLER( aica_r ) READ16_DEVICE_HANDLER( aica_r )
{ {
aica_state *AICA = get_safe_token(device); aica_state *AICA = get_safe_token(device);
return AICA_r16(AICA, offset*2); return AICA_r16(AICA, space,offset*2);
} }
WRITE16_DEVICE_HANDLER( aica_w ) WRITE16_DEVICE_HANDLER( aica_w )
@ -1331,9 +1331,9 @@ WRITE16_DEVICE_HANDLER( aica_w )
aica_state *AICA = get_safe_token(device); aica_state *AICA = get_safe_token(device);
UINT16 tmp; UINT16 tmp;
tmp = AICA_r16(AICA, offset*2); tmp = AICA_r16(AICA, space, offset*2);
COMBINE_DATA(&tmp); COMBINE_DATA(&tmp);
AICA_w16(AICA, offset*2, tmp); AICA_w16(AICA, space, offset*2, tmp);
} }
WRITE16_DEVICE_HANDLER( aica_midi_in ) WRITE16_DEVICE_HANDLER( aica_midi_in )

8
src/emu/sound/aica.h
View File

@ -18,12 +18,12 @@ struct aica_interface
void aica_set_ram_base(device_t *device, void *base, int size); void aica_set_ram_base(device_t *device, void *base, int size);
// AICA register access // AICA register access
READ16_DEVICE_HANDLER( aica_r ); DECLARE_READ16_DEVICE_HANDLER( aica_r );
WRITE16_DEVICE_HANDLER( aica_w ); DECLARE_WRITE16_DEVICE_HANDLER( aica_w );
// MIDI I/O access // MIDI I/O access
WRITE16_DEVICE_HANDLER( aica_midi_in ); DECLARE_WRITE16_DEVICE_HANDLER( aica_midi_in );
READ16_DEVICE_HANDLER( aica_midi_out_r ); DECLARE_READ16_DEVICE_HANDLER( aica_midi_out_r );
class aica_device : public device_t, class aica_device : public device_t,
public device_sound_interface public device_sound_interface

2
src/emu/sound/astrocde.h
View File

@ -5,7 +5,7 @@
#include "devlegcy.h" #include "devlegcy.h"
WRITE8_DEVICE_HANDLER( astrocade_sound_w ); DECLARE_WRITE8_DEVICE_HANDLER( astrocade_sound_w );
class astrocade_device : public device_t, class astrocade_device : public device_t,
public device_sound_interface public device_sound_interface

12
src/emu/sound/ay8910.c
View File

@ -1000,7 +1000,7 @@ WRITE8_DEVICE_HANDLER( ay8910_address_w )
#if ENABLE_REGISTER_TEST #if ENABLE_REGISTER_TEST
return; return;
#else #else
ay8910_data_address_w(device, 1, data); ay8910_data_address_w(device, space, 1, data);
#endif #endif
} }
@ -1009,7 +1009,7 @@ WRITE8_DEVICE_HANDLER( ay8910_data_w )
#if ENABLE_REGISTER_TEST #if ENABLE_REGISTER_TEST
return; return;
#else #else
ay8910_data_address_w(device, 0, data); ay8910_data_address_w(device, space, 0, data);
#endif #endif
} }
@ -1023,15 +1023,15 @@ static const int mapping8914to8910[16] = { 0, 2, 4, 11, 1, 3, 5, 12, 7, 6, 13, 8
READ8_DEVICE_HANDLER( ay8914_r ) READ8_DEVICE_HANDLER( ay8914_r )
{ {
UINT16 rv; UINT16 rv;
ay8910_address_w(device, 0, mapping8914to8910[offset & 0xff]); ay8910_address_w(device, space, 0, mapping8914to8910[offset & 0xff]);
rv = (UINT16)ay8910_r(device, 0); rv = (UINT16)ay8910_r(device, space, 0);
return rv; return rv;
} }
WRITE8_DEVICE_HANDLER( ay8914_w ) WRITE8_DEVICE_HANDLER( ay8914_w )
{ {
ay8910_address_w(device, 0, mapping8914to8910[offset & 0xff]); ay8910_address_w(device, space, 0, mapping8914to8910[offset & 0xff]);
ay8910_data_w(device, 0, data & 0xff); ay8910_data_w(device, space, 0, data & 0xff);
} }

16
src/emu/sound/ay8910.h
View File

@ -90,22 +90,22 @@ struct ay8910_interface
void ay8910_set_volume(device_t *device,int channel,int volume); void ay8910_set_volume(device_t *device,int channel,int volume);
READ8_DEVICE_HANDLER( ay8910_r ); DECLARE_READ8_DEVICE_HANDLER( ay8910_r );
WRITE8_DEVICE_HANDLER( ay8910_address_w ); DECLARE_WRITE8_DEVICE_HANDLER( ay8910_address_w );
WRITE8_DEVICE_HANDLER( ay8910_data_w ); DECLARE_WRITE8_DEVICE_HANDLER( ay8910_data_w );
/* /RES */ /* /RES */
WRITE8_DEVICE_HANDLER( ay8910_reset_w ); DECLARE_WRITE8_DEVICE_HANDLER( ay8910_reset_w );
/* use this when BC1 == A0; here, BC1=0 selects 'data' and BC1=1 selects 'latch address' */ /* use this when BC1 == A0; here, BC1=0 selects 'data' and BC1=1 selects 'latch address' */
WRITE8_DEVICE_HANDLER( ay8910_data_address_w ); DECLARE_WRITE8_DEVICE_HANDLER( ay8910_data_address_w );
/* use this when BC1 == !A0; here, BC1=0 selects 'latch address' and BC1=1 selects 'data' */ /* use this when BC1 == !A0; here, BC1=0 selects 'latch address' and BC1=1 selects 'data' */
WRITE8_DEVICE_HANDLER( ay8910_address_data_w ); DECLARE_WRITE8_DEVICE_HANDLER( ay8910_address_data_w );
/* AY8914 handlers needed due to different register map */ /* AY8914 handlers needed due to different register map */
READ8_DEVICE_HANDLER( ay8914_r ); DECLARE_READ8_DEVICE_HANDLER( ay8914_r );
WRITE8_DEVICE_HANDLER( ay8914_w ); DECLARE_WRITE8_DEVICE_HANDLER( ay8914_w );
/*********** An interface for SSG of YM2203 ***********/ /*********** An interface for SSG of YM2203 ***********/

4
src/emu/sound/c140.h
View File

@ -7,8 +7,8 @@
#include "devlegcy.h" #include "devlegcy.h"
READ8_DEVICE_HANDLER( c140_r ); DECLARE_READ8_DEVICE_HANDLER( c140_r );
WRITE8_DEVICE_HANDLER( c140_w ); DECLARE_WRITE8_DEVICE_HANDLER( c140_w );
void c140_set_base(device_t *device, void *base); void c140_set_base(device_t *device, void *base);

4
src/emu/sound/c6280.h
View File

@ -11,8 +11,8 @@ struct c6280_interface
}; };
/* Function prototypes */ /* Function prototypes */
WRITE8_DEVICE_HANDLER( c6280_w ); DECLARE_WRITE8_DEVICE_HANDLER( c6280_w );
READ8_DEVICE_HANDLER( c6280_r ); DECLARE_READ8_DEVICE_HANDLER( c6280_r );
class c6280_device : public device_t, class c6280_device : public device_t,
public device_sound_interface public device_sound_interface

2
src/emu/sound/digitalk.h
View File

@ -7,7 +7,7 @@ void digitalker_0_cs_w(device_t *device, int line);
void digitalker_0_cms_w(device_t *device, int line); void digitalker_0_cms_w(device_t *device, int line);
void digitalker_0_wr_w(device_t *device, int line); void digitalker_0_wr_w(device_t *device, int line);
int digitalker_0_intr_r(device_t *device); int digitalker_0_intr_r(device_t *device);
WRITE8_DEVICE_HANDLER(digitalker_data_w); DECLARE_WRITE8_DEVICE_HANDLER(digitalker_data_w);
class digitalker_device : public device_t, class digitalker_device : public device_t,
public device_sound_interface public device_sound_interface

4
src/emu/sound/discrete.h
View File

@ -4256,8 +4256,8 @@ public:
* *
*************************************/ *************************************/
WRITE8_DEVICE_HANDLER( discrete_sound_w ); DECLARE_WRITE8_DEVICE_HANDLER( discrete_sound_w );
READ8_DEVICE_HANDLER( discrete_sound_r ); DECLARE_READ8_DEVICE_HANDLER( discrete_sound_r );
//************************************************************************** //**************************************************************************
// INTERFACE CONFIGURATION MACROS // INTERFACE CONFIGURATION MACROS

8
src/emu/sound/es5506.h
View File

@ -20,8 +20,8 @@ struct es5505_interface
UINT16 (*read_port)(device_t *device); /* input port read */ UINT16 (*read_port)(device_t *device); /* input port read */
}; };
READ16_DEVICE_HANDLER( es5505_r ); DECLARE_READ16_DEVICE_HANDLER( es5505_r );
WRITE16_DEVICE_HANDLER( es5505_w ); DECLARE_WRITE16_DEVICE_HANDLER( es5505_w );
void es5505_voice_bank_w(device_t *device, int voice, int bank); void es5505_voice_bank_w(device_t *device, int voice, int bank);
class es5506_device : public device_t, class es5506_device : public device_t,
@ -62,8 +62,8 @@ struct es5506_interface
UINT16 (*read_port)(device_t *device); /* input port read */ UINT16 (*read_port)(device_t *device); /* input port read */
}; };
READ8_DEVICE_HANDLER( es5506_r ); DECLARE_READ8_DEVICE_HANDLER( es5506_r );
WRITE8_DEVICE_HANDLER( es5506_w ); DECLARE_WRITE8_DEVICE_HANDLER( es5506_w );
void es5506_voice_bank_w(device_t *device, int voice, int bank); void es5506_voice_bank_w(device_t *device, int voice, int bank);
class es5505_device : public es5506_device class es5505_device : public es5506_device

2
src/emu/sound/es8712.h
View File

@ -11,7 +11,7 @@ void es8712_play(device_t *device);
void es8712_set_bank_base(device_t *device, int base); void es8712_set_bank_base(device_t *device, int base);
void es8712_set_frequency(device_t *device, int frequency); void es8712_set_frequency(device_t *device, int frequency);
WRITE8_DEVICE_HANDLER( es8712_w ); DECLARE_WRITE8_DEVICE_HANDLER( es8712_w );
class es8712_device : public device_t, class es8712_device : public device_t,
public device_sound_interface public device_sound_interface

4
src/emu/sound/gaelco.h
View File

@ -11,8 +11,8 @@ struct gaelcosnd_interface
int banks[4]; /* start of each ROM bank */ int banks[4]; /* start of each ROM bank */
}; };
WRITE16_DEVICE_HANDLER( gaelcosnd_w ); DECLARE_WRITE16_DEVICE_HANDLER( gaelcosnd_w );
READ16_DEVICE_HANDLER( gaelcosnd_r ); DECLARE_READ16_DEVICE_HANDLER( gaelcosnd_r );
class gaelco_gae1_device : public device_t, class gaelco_gae1_device : public device_t,
public device_sound_interface public device_sound_interface

4
src/emu/sound/ics2115.h
View File

@ -98,8 +98,8 @@ public:
// inline configuration helpers // inline configuration helpers
static void static_set_irqf(device_t &device, void (*irqf)(device_t *device, int state)); static void static_set_irqf(device_t &device, void (*irqf)(device_t *device, int state));
static READ8_DEVICE_HANDLER(read); static DECLARE_READ8_DEVICE_HANDLER(read);
static WRITE8_DEVICE_HANDLER(write); static DECLARE_WRITE8_DEVICE_HANDLER(write);
//UINT8 read(offs_t offset); //UINT8 read(offs_t offset);
//void write(offs_t offset, UINT8 data); //void write(offs_t offset, UINT8 data);
static TIMER_CALLBACK(timer_cb_0); static TIMER_CALLBACK(timer_cb_0);

4
src/emu/sound/iremga20.h
View File

@ -10,8 +10,8 @@
#include "devlegcy.h" #include "devlegcy.h"
WRITE8_DEVICE_HANDLER( irem_ga20_w ); DECLARE_WRITE8_DEVICE_HANDLER( irem_ga20_w );
READ8_DEVICE_HANDLER( irem_ga20_r ); DECLARE_READ8_DEVICE_HANDLER( irem_ga20_r );
class iremga20_device : public device_t, class iremga20_device : public device_t,
public device_sound_interface public device_sound_interface

12
src/emu/sound/k005289.h
View File

@ -5,12 +5,12 @@
#include "devlegcy.h" #include "devlegcy.h"
WRITE8_DEVICE_HANDLER( k005289_control_A_w ); DECLARE_WRITE8_DEVICE_HANDLER( k005289_control_A_w );
WRITE8_DEVICE_HANDLER( k005289_control_B_w ); DECLARE_WRITE8_DEVICE_HANDLER( k005289_control_B_w );
WRITE8_DEVICE_HANDLER( k005289_pitch_A_w ); DECLARE_WRITE8_DEVICE_HANDLER( k005289_pitch_A_w );
WRITE8_DEVICE_HANDLER( k005289_pitch_B_w ); DECLARE_WRITE8_DEVICE_HANDLER( k005289_pitch_B_w );
WRITE8_DEVICE_HANDLER( k005289_keylatch_A_w ); DECLARE_WRITE8_DEVICE_HANDLER( k005289_keylatch_A_w );
WRITE8_DEVICE_HANDLER( k005289_keylatch_B_w ); DECLARE_WRITE8_DEVICE_HANDLER( k005289_keylatch_B_w );
class k005289_device : public device_t, class k005289_device : public device_t,
public device_sound_interface public device_sound_interface

4
src/emu/sound/k007232.h
View File

@ -14,8 +14,8 @@ struct k007232_interface
void (*portwritehandler)(device_t *, int); void (*portwritehandler)(device_t *, int);
}; };
WRITE8_DEVICE_HANDLER( k007232_w ); DECLARE_WRITE8_DEVICE_HANDLER( k007232_w );
READ8_DEVICE_HANDLER( k007232_r ); DECLARE_READ8_DEVICE_HANDLER( k007232_r );
void k007232_set_bank( device_t *device, int chABank, int chBBank ); void k007232_set_bank( device_t *device, int chABank, int chBBank );

2
src/emu/sound/k051649.c
View File

@ -276,7 +276,7 @@ WRITE8_DEVICE_HANDLER( k051649_test_w )
READ8_DEVICE_HANDLER ( k051649_test_r ) READ8_DEVICE_HANDLER ( k051649_test_r )
{ {
/* reading the test register sets it to $ff! */ /* reading the test register sets it to $ff! */
k051649_test_w(device, offset, 0xff); k051649_test_w(device, space, offset, 0xff);
return 0xff; return 0xff;
} }

18
src/emu/sound/k051649.h
View File

@ -5,16 +5,16 @@
#include "devlegcy.h" #include "devlegcy.h"
WRITE8_DEVICE_HANDLER( k051649_waveform_w ); DECLARE_WRITE8_DEVICE_HANDLER( k051649_waveform_w );
READ8_DEVICE_HANDLER ( k051649_waveform_r ); DECLARE_READ8_DEVICE_HANDLER ( k051649_waveform_r );
WRITE8_DEVICE_HANDLER( k051649_volume_w ); DECLARE_WRITE8_DEVICE_HANDLER( k051649_volume_w );
WRITE8_DEVICE_HANDLER( k051649_frequency_w ); DECLARE_WRITE8_DEVICE_HANDLER( k051649_frequency_w );
WRITE8_DEVICE_HANDLER( k051649_keyonoff_w ); DECLARE_WRITE8_DEVICE_HANDLER( k051649_keyonoff_w );
WRITE8_DEVICE_HANDLER( k051649_test_w ); DECLARE_WRITE8_DEVICE_HANDLER( k051649_test_w );
READ8_DEVICE_HANDLER ( k051649_test_r ); DECLARE_READ8_DEVICE_HANDLER ( k051649_test_r );
WRITE8_DEVICE_HANDLER( k052539_waveform_w ); DECLARE_WRITE8_DEVICE_HANDLER( k052539_waveform_w );
READ8_DEVICE_HANDLER ( k052539_waveform_r ); DECLARE_READ8_DEVICE_HANDLER ( k052539_waveform_r );
class k051649_device : public device_t, class k051649_device : public device_t,
public device_sound_interface public device_sound_interface

4
src/emu/sound/k053260.h
View File

@ -17,8 +17,8 @@ struct k053260_interface {
}; };
WRITE8_DEVICE_HANDLER( k053260_w ); DECLARE_WRITE8_DEVICE_HANDLER( k053260_w );
READ8_DEVICE_HANDLER( k053260_r ); DECLARE_READ8_DEVICE_HANDLER( k053260_r );
class k053260_device : public device_t, class k053260_device : public device_t,
public device_sound_interface public device_sound_interface

8
src/emu/sound/k056800.h
View File

@ -57,10 +57,10 @@ extern const device_type K056800;
DEVICE I/O FUNCTIONS DEVICE I/O FUNCTIONS
***************************************************************************/ ***************************************************************************/
READ32_DEVICE_HANDLER( k056800_host_r ); DECLARE_READ32_DEVICE_HANDLER( k056800_host_r );
WRITE32_DEVICE_HANDLER( k056800_host_w ); DECLARE_WRITE32_DEVICE_HANDLER( k056800_host_w );
READ16_DEVICE_HANDLER( k056800_sound_r ); DECLARE_READ16_DEVICE_HANDLER( k056800_sound_r );
WRITE16_DEVICE_HANDLER( k056800_sound_w ); DECLARE_WRITE16_DEVICE_HANDLER( k056800_sound_w );
#endif /* __K056800_H__ */ #endif /* __K056800_H__ */

12
src/emu/sound/msm5232.c
View File

@ -69,7 +69,7 @@ struct msm5232_state {
double external_capacity[8]; /* in Farads, eg 0.39e-6 = 0.36 uF (microFarads) */ double external_capacity[8]; /* in Farads, eg 0.39e-6 = 0.36 uF (microFarads) */
device_t *device; device_t *device;
void (*gate_handler)(device_t *device, int state); /* callback called when the GATE output pin changes state */ devcb_resolved_write_line gate_handler;/* callback called when the GATE output pin changes state */
}; };
@ -260,10 +260,10 @@ static void msm5232_gate_update(msm5232_state *chip)
{ {
int new_state = (chip->control2 & 0x20) ? chip->voi[7].GF : 0; int new_state = (chip->control2 & 0x20) ? chip->voi[7].GF : 0;
if (chip->gate != new_state && chip->gate_handler) if (chip->gate != new_state && !chip->gate_handler.isnull())
{ {
chip->gate = new_state; chip->gate = new_state;
(*chip->gate_handler)(chip->device, new_state); chip->gate_handler(new_state);
} }
} }
@ -275,8 +275,8 @@ static DEVICE_RESET( msm5232 )
for (i=0; i<8; i++) for (i=0; i<8; i++)
{ {
msm5232_w(device,i,0x80); msm5232_w(device,device->machine().driver_data()->generic_space(),i,0x80);
msm5232_w(device,i,0x00); msm5232_w(device,device->machine().driver_data()->generic_space(),i,0x00);
} }
chip->noise_cnt = 0; chip->noise_cnt = 0;
chip->noise_rng = 1; chip->noise_rng = 1;
@ -309,7 +309,7 @@ static void msm5232_init(msm5232_state *chip, const msm5232_interface *intf, int
chip->external_capacity[j] = intf->capacity[j]; chip->external_capacity[j] = intf->capacity[j];
} }
chip->gate_handler = intf->gate_handler; chip->gate_handler.resolve(intf->gate_handler_cb, *chip->device);
msm5232_init_tables( chip ); msm5232_init_tables( chip );

4
src/emu/sound/msm5232.h
View File

@ -8,10 +8,10 @@
struct msm5232_interface struct msm5232_interface
{ {
double capacity[8]; /* in Farads, capacitors connected to pins: 24,25,26,27 and 37,38,39,40 */ double capacity[8]; /* in Farads, capacitors connected to pins: 24,25,26,27 and 37,38,39,40 */
void (*gate_handler)(device_t *device, int state); /* callback called when the GATE output pin changes state */ devcb_write_line gate_handler_cb; /* callback called when the GATE output pin changes state */
}; };
WRITE8_DEVICE_HANDLER( msm5232_w ); DECLARE_WRITE8_DEVICE_HANDLER( msm5232_w );
void msm5232_set_clock(device_t *device, int clock); void msm5232_set_clock(device_t *device, int clock);

Some files were not shown because too many files have changed in this diff Show More