mirror of
https://github.com/holub/mame
synced 2025-05-28 16:43:04 +03:00
Changed device read/write functions to take a const device_config *.
Reverted recent hacks to get around this and removed unnecessary casts.
This commit is contained in:
Aaron Giles
parent
19784846a1
commit
842ed3efb0
@ -85,23 +85,23 @@
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT16 read16be_with_read8_device_handler(read8_device_func handler, void *param, offs_t offset, UINT16 mem_mask)
|
||||
INLINE UINT16 read16be_with_read8_device_handler(read8_device_func handler, const device_config *device, offs_t offset, UINT16 mem_mask)
|
||||
{
|
||||
UINT16 result = 0;
|
||||
if ((mem_mask & 0xff00) != 0xff00)
|
||||
result |= ((UINT16)(*handler)(param, offset * 2 + 0)) << 8;
|
||||
result |= ((UINT16)(*handler)(device, offset * 2 + 0)) << 8;
|
||||
if ((mem_mask & 0x00ff) != 0x00ff)
|
||||
result |= ((UINT16)(*handler)(param, offset * 2 + 1)) << 0;
|
||||
result |= ((UINT16)(*handler)(device, offset * 2 + 1)) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write16be_with_write8_device_handler(write8_device_func handler, void *param, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
INLINE void write16be_with_write8_device_handler(write8_device_func handler, const device_config *device, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
{
|
||||
if ((mem_mask & 0xff00) != 0xff00)
|
||||
(*handler)(param, offset * 2 + 0, data >> 8);
|
||||
(*handler)(device, offset * 2 + 0, data >> 8);
|
||||
if ((mem_mask & 0x00ff) != 0x00ff)
|
||||
(*handler)(param, offset * 2 + 1, data >> 0);
|
||||
(*handler)(device, offset * 2 + 1, data >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -111,23 +111,23 @@ INLINE void write16be_with_write8_device_handler(write8_device_func handler, voi
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT16 read16le_with_read8_device_handler(read8_device_func handler, void *param, offs_t offset, UINT16 mem_mask)
|
||||
INLINE UINT16 read16le_with_read8_device_handler(read8_device_func handler, const device_config *device, offs_t offset, UINT16 mem_mask)
|
||||
{
|
||||
UINT16 result = 0;
|
||||
if ((mem_mask & 0x00ff) != 0x00ff)
|
||||
result |= ((UINT16) (*handler)(param, offset * 2 + 0)) << 0;
|
||||
result |= ((UINT16) (*handler)(device, offset * 2 + 0)) << 0;
|
||||
if ((mem_mask & 0xff00) != 0xff00)
|
||||
result |= ((UINT16) (*handler)(param, offset * 2 + 1)) << 8;
|
||||
result |= ((UINT16) (*handler)(device, offset * 2 + 1)) << 8;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write16le_with_write8_device_handler(write8_device_func handler, void *param, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
INLINE void write16le_with_write8_device_handler(write8_device_func handler, const device_config *device, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
{
|
||||
if ((mem_mask & 0x00ff) != 0x00ff)
|
||||
(*handler)(param, offset * 2 + 0, data >> 0);
|
||||
(*handler)(device, offset * 2 + 0, data >> 0);
|
||||
if ((mem_mask & 0xff00) != 0xff00)
|
||||
(*handler)(param, offset * 2 + 1, data >> 8);
|
||||
(*handler)(device, offset * 2 + 1, data >> 8);
|
||||
}
|
||||
|
||||
|
||||
@ -137,23 +137,23 @@ INLINE void write16le_with_write8_device_handler(write8_device_func handler, voi
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32be_with_read8_device_handler(read8_device_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32be_with_read8_device_handler(read8_device_func handler, const device_config *device, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
result |= read16be_with_read8_device_handler(handler, param, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
result |= read16be_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
result |= read16be_with_read8_device_handler(handler, param, offset * 2 + 1, mem_mask) << 0;
|
||||
result |= read16be_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32be_with_write8_device_handler(write8_device_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32be_with_write8_device_handler(write8_device_func handler, const device_config *device, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
write16be_with_write8_device_handler(handler, param, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
write16be_with_write8_device_handler(handler, device, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
write16be_with_write8_device_handler(handler, param, offset * 2 + 1, data, mem_mask);
|
||||
write16be_with_write8_device_handler(handler, device, offset * 2 + 1, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -163,23 +163,23 @@ INLINE void write32be_with_write8_device_handler(write8_device_func handler, voi
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32le_with_read8_device_handler(read8_device_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32le_with_read8_device_handler(read8_device_func handler, const device_config *device, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
result |= read16le_with_read8_device_handler(handler, param, offset * 2 + 0, mem_mask) << 0;
|
||||
result |= read16le_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask) << 0;
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
result |= read16le_with_read8_device_handler(handler, param, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
result |= read16le_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32le_with_write8_device_handler(write8_device_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32le_with_write8_device_handler(write8_device_func handler, const device_config *device, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
write16le_with_write8_device_handler(handler, param, offset * 2 + 0, data, mem_mask);
|
||||
write16le_with_write8_device_handler(handler, device, offset * 2 + 0, data, mem_mask);
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
write16le_with_write8_device_handler(handler, param, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
write16le_with_write8_device_handler(handler, device, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
}
|
||||
|
||||
|
||||
@ -189,23 +189,23 @@ INLINE void write32le_with_write8_device_handler(write8_device_func handler, voi
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32be_with_16be_device_handler(read16_device_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32be_with_16be_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
result |= (*handler)(param, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
result |= (*handler)(device, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
result |= (*handler)(param, offset * 2 + 1, mem_mask) << 0;
|
||||
result |= (*handler)(device, offset * 2 + 1, mem_mask) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32be_with_16be_device_handler(write16_device_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32be_with_16be_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
(*handler)(param, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
(*handler)(device, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
(*handler)(param, offset * 2 + 1, data, mem_mask);
|
||||
(*handler)(device, offset * 2 + 1, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -215,23 +215,23 @@ INLINE void write32be_with_16be_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32le_with_16le_device_handler(read16_device_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32le_with_16le_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
result |= (*handler)(param, offset * 2 + 0, mem_mask) << 0;
|
||||
result |= (*handler)(device, offset * 2 + 0, mem_mask) << 0;
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
result |= (*handler)(param, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
result |= (*handler)(device, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32le_with_16le_device_handler(write16_device_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32le_with_16le_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if ((mem_mask & 0x0000ffff) != 0x0000ffff)
|
||||
(*handler)(param, offset * 2 + 0, data, mem_mask);
|
||||
(*handler)(device, offset * 2 + 0, data, mem_mask);
|
||||
if ((mem_mask & 0xffff0000) != 0xffff0000)
|
||||
(*handler)(param, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
(*handler)(device, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
}
|
||||
|
||||
|
||||
@ -241,20 +241,20 @@ INLINE void write32le_with_16le_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32be_with_16le_device_handler(read16_device_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32be_with_16le_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
result = read32le_with_16le_device_handler(handler, param, offset, mem_mask);
|
||||
result = read32le_with_16le_device_handler(handler, device, offset, mem_mask);
|
||||
return FLIPENDIAN_INT32(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32be_with_16le_device_handler(write16_device_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32be_with_16le_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT32(data);
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
write32le_with_16le_device_handler(handler, param, offset, data, mem_mask);
|
||||
write32le_with_16le_device_handler(handler, device, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -264,20 +264,20 @@ INLINE void write32be_with_16le_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32le_with_16be_device_handler(read16_device_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32le_with_16be_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
result = read32be_with_16be_device_handler(handler, param, offset, mem_mask);
|
||||
result = read32be_with_16be_device_handler(handler, device, offset, mem_mask);
|
||||
return FLIPENDIAN_INT32(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32le_with_16be_device_handler(write16_device_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32le_with_16be_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT32(data);
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
write32be_with_16be_device_handler(handler, param, offset, data, mem_mask);
|
||||
write32be_with_16be_device_handler(handler, device, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -287,23 +287,23 @@ INLINE void write32le_with_16be_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64be_with_read8_device_handler(read8_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64be_with_read8_device_handler(read8_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)read32be_with_read8_device_handler(handler, param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32be_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)read32be_with_read8_device_handler(handler, param, offset * 2 + 1, mem_mask) << 0;
|
||||
result |= (UINT64)read32be_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_write8_device_handler(write8_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_write8_device_handler(write8_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
write32be_with_write8_device_handler(handler, param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
write32be_with_write8_device_handler(handler, device, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
write32be_with_write8_device_handler(handler, param, offset * 2 + 1, data, mem_mask);
|
||||
write32be_with_write8_device_handler(handler, device, offset * 2 + 1, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -313,23 +313,23 @@ INLINE void write64be_with_write8_device_handler(write8_device_func handler, voi
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64le_with_read8_device_handler(read8_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64le_with_read8_device_handler(read8_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)read32le_with_read8_device_handler(handler, param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32le_with_read8_device_handler(handler, device, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)read32le_with_read8_device_handler(handler, param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32le_with_read8_device_handler(handler, device, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_write8_device_handler(write8_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_write8_device_handler(write8_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
write32le_with_write8_device_handler(handler, param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
write32le_with_write8_device_handler(handler, device, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
write32le_with_write8_device_handler(handler, param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
write32le_with_write8_device_handler(handler, device, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -339,23 +339,23 @@ INLINE void write64le_with_write8_device_handler(write8_device_func handler, voi
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64be_with_16be_device_handler(read16_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64be_with_16be_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)read32be_with_16be_device_handler(handler, param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32be_with_16be_device_handler(handler, device, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)read32be_with_16be_device_handler(handler, param, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32be_with_16be_device_handler(handler, device, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_16be_device_handler(write16_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_16be_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
write32be_with_16be_device_handler(handler, param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
write32be_with_16be_device_handler(handler, device, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
write32be_with_16be_device_handler(handler, param, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
write32be_with_16be_device_handler(handler, device, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -365,23 +365,23 @@ INLINE void write64be_with_16be_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64le_with_16le_device_handler(read16_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64le_with_16le_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)read32le_with_16le_device_handler(handler, param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32le_with_16le_device_handler(handler, device, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)read32le_with_16le_device_handler(handler, param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32le_with_16le_device_handler(handler, device, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_16le_device_handler(write16_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_16le_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
write32le_with_16le_device_handler(handler, param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
write32le_with_16le_device_handler(handler, device, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
write32le_with_16le_device_handler(handler, param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
write32le_with_16le_device_handler(handler, device, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -391,23 +391,23 @@ INLINE void write64le_with_16le_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64be_with_16le_device_handler(read16_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64be_with_16le_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)read32be_with_16le_device_handler(handler, param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32be_with_16le_device_handler(handler, device, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)read32be_with_16le_device_handler(handler, param, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32be_with_16le_device_handler(handler, device, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_16le_device_handler(write16_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_16le_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
write32be_with_16le_device_handler(handler, param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
write32be_with_16le_device_handler(handler, device, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
write32be_with_16le_device_handler(handler, param, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
write32be_with_16le_device_handler(handler, device, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -417,23 +417,23 @@ INLINE void write64be_with_16le_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64le_with_16be_device_handler(read16_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64le_with_16be_device_handler(read16_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)read32le_with_16be_device_handler(handler, param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32le_with_16be_device_handler(handler, device, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)read32le_with_16be_device_handler(handler, param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32le_with_16be_device_handler(handler, device, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_16be_device_handler(write16_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_16be_device_handler(write16_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
write32le_with_16be_device_handler(handler, param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
write32le_with_16be_device_handler(handler, device, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
write32le_with_16be_device_handler(handler, param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
write32le_with_16be_device_handler(handler, device, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -443,23 +443,23 @@ INLINE void write64le_with_16be_device_handler(write16_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64be_with_32be_device_handler(read32_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64be_with_32be_device_handler(read32_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)(*handler)(device, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)(*handler)(device, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_32be_device_handler(write32_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_32be_device_handler(write32_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
(*handler)(param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
(*handler)(device, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
(*handler)(param, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
(*handler)(device, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -469,23 +469,23 @@ INLINE void write64be_with_32be_device_handler(write32_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64le_with_32le_device_handler(read32_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64le_with_32le_device_handler(read32_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)(*handler)(device, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)(*handler)(device, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_32le_device_handler(write32_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_32le_device_handler(write32_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff))
|
||||
(*handler)(param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
(*handler)(device, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000))
|
||||
(*handler)(param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
(*handler)(device, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -495,20 +495,20 @@ INLINE void write64le_with_32le_device_handler(write32_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64be_with_32le_device_handler(read32_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64be_with_32le_device_handler(read32_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result;
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
result = read64le_with_32le_device_handler(handler, param, offset, mem_mask);
|
||||
result = read64le_with_32le_device_handler(handler, device, offset, mem_mask);
|
||||
return FLIPENDIAN_INT64(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_32le_device_handler(write32_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_32le_device_handler(write32_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT64(data);
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
write64le_with_32le_device_handler(handler, param, offset, data, mem_mask);
|
||||
write64le_with_32le_device_handler(handler, device, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -518,20 +518,20 @@ INLINE void write64be_with_32le_device_handler(write32_device_func handler, void
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64le_with_32be_device_handler(read32_device_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64le_with_32be_device_handler(read32_device_func handler, const device_config *device, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result;
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
result = read64be_with_32be_device_handler(handler, param, offset, mem_mask);
|
||||
result = read64be_with_32be_device_handler(handler, device, offset, mem_mask);
|
||||
return FLIPENDIAN_INT64(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_32be_device_handler(write32_device_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_32be_device_handler(write32_device_func handler, const device_config *device, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT64(data);
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
write64be_with_32be_device_handler(handler, param, offset, data, mem_mask);
|
||||
write64be_with_32be_device_handler(handler, device, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -85,23 +85,23 @@
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT16 read16be_with_read8_handler(read8_machine_func handler, void *param, offs_t offset, UINT16 mem_mask)
|
||||
INLINE UINT16 read16be_with_read8_handler(read8_machine_func handler, running_machine *machine, offs_t offset, UINT16 mem_mask)
|
||||
{
|
||||
UINT16 result = 0;
|
||||
if (ACCESSING_BITS_8_15)
|
||||
result |= ((UINT16)(*handler)(param, offset * 2 + 0)) << 8;
|
||||
result |= ((UINT16)(*handler)(machine, offset * 2 + 0)) << 8;
|
||||
if (ACCESSING_BITS_0_7)
|
||||
result |= ((UINT16)(*handler)(param, offset * 2 + 1)) << 0;
|
||||
result |= ((UINT16)(*handler)(machine, offset * 2 + 1)) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write16be_with_write8_handler(write8_machine_func handler, void *param, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
INLINE void write16be_with_write8_handler(write8_machine_func handler, running_machine *machine, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_8_15)
|
||||
(*handler)(param, offset * 2 + 0, data >> 8);
|
||||
(*handler)(machine, offset * 2 + 0, data >> 8);
|
||||
if (ACCESSING_BITS_0_7)
|
||||
(*handler)(param, offset * 2 + 1, data >> 0);
|
||||
(*handler)(machine, offset * 2 + 1, data >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -111,23 +111,23 @@ INLINE void write16be_with_write8_handler(write8_machine_func handler, void *par
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT16 read16le_with_read8_handler(read8_machine_func handler, void *param, offs_t offset, UINT16 mem_mask)
|
||||
INLINE UINT16 read16le_with_read8_handler(read8_machine_func handler, running_machine *machine, offs_t offset, UINT16 mem_mask)
|
||||
{
|
||||
UINT16 result = 0;
|
||||
if (ACCESSING_BITS_0_7)
|
||||
result |= ((UINT16) (*handler)(param, offset * 2 + 0)) << 0;
|
||||
result |= ((UINT16) (*handler)(machine, offset * 2 + 0)) << 0;
|
||||
if (ACCESSING_BITS_8_15)
|
||||
result |= ((UINT16) (*handler)(param, offset * 2 + 1)) << 8;
|
||||
result |= ((UINT16) (*handler)(machine, offset * 2 + 1)) << 8;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write16le_with_write8_handler(write8_machine_func handler, void *param, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
INLINE void write16le_with_write8_handler(write8_machine_func handler, running_machine *machine, offs_t offset, UINT16 data, UINT16 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_7)
|
||||
(*handler)(param, offset * 2 + 0, data >> 0);
|
||||
(*handler)(machine, offset * 2 + 0, data >> 0);
|
||||
if (ACCESSING_BITS_8_15)
|
||||
(*handler)(param, offset * 2 + 1, data >> 8);
|
||||
(*handler)(machine, offset * 2 + 1, data >> 8);
|
||||
}
|
||||
|
||||
|
||||
@ -137,23 +137,23 @@ INLINE void write16le_with_write8_handler(write8_machine_func handler, void *par
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32be_with_read8_handler(read8_machine_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32be_with_read8_handler(read8_machine_func handler, running_machine *machine, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if (ACCESSING_BITS_16_31)
|
||||
result |= read16be_with_read8_handler(handler, param, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
result |= read16be_with_read8_handler(handler, machine, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
if (ACCESSING_BITS_0_15)
|
||||
result |= read16be_with_read8_handler(handler, param, offset * 2 + 1, mem_mask) << 0;
|
||||
result |= read16be_with_read8_handler(handler, machine, offset * 2 + 1, mem_mask) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32be_with_write8_handler(write8_machine_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32be_with_write8_handler(write8_machine_func handler, running_machine *machine, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_16_31)
|
||||
write16be_with_write8_handler(handler, param, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
write16be_with_write8_handler(handler, machine, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
if (ACCESSING_BITS_0_15)
|
||||
write16be_with_write8_handler(handler, param, offset * 2 + 1, data, mem_mask);
|
||||
write16be_with_write8_handler(handler, machine, offset * 2 + 1, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -163,23 +163,23 @@ INLINE void write32be_with_write8_handler(write8_machine_func handler, void *par
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32le_with_read8_handler(read8_machine_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32le_with_read8_handler(read8_machine_func handler, running_machine *machine, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if (ACCESSING_BITS_0_15)
|
||||
result |= read16le_with_read8_handler(handler, param, offset * 2 + 0, mem_mask) << 0;
|
||||
result |= read16le_with_read8_handler(handler, machine, offset * 2 + 0, mem_mask) << 0;
|
||||
if (ACCESSING_BITS_16_31)
|
||||
result |= read16le_with_read8_handler(handler, param, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
result |= read16le_with_read8_handler(handler, machine, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32le_with_write8_handler(write8_machine_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32le_with_write8_handler(write8_machine_func handler, running_machine *machine, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_15)
|
||||
write16le_with_write8_handler(handler, param, offset * 2 + 0, data, mem_mask);
|
||||
write16le_with_write8_handler(handler, machine, offset * 2 + 0, data, mem_mask);
|
||||
if (ACCESSING_BITS_16_31)
|
||||
write16le_with_write8_handler(handler, param, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
write16le_with_write8_handler(handler, machine, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
}
|
||||
|
||||
|
||||
@ -189,23 +189,23 @@ INLINE void write32le_with_write8_handler(write8_machine_func handler, void *par
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32be_with_16be_handler(read16_machine_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32be_with_16be_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if (ACCESSING_BITS_16_31)
|
||||
result |= (*handler)(param, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
result |= (*handler)(machine, offset * 2 + 0, mem_mask >> 16) << 16;
|
||||
if (ACCESSING_BITS_0_15)
|
||||
result |= (*handler)(param, offset * 2 + 1, mem_mask) << 0;
|
||||
result |= (*handler)(machine, offset * 2 + 1, mem_mask) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32be_with_16be_handler(write16_machine_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32be_with_16be_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_16_31)
|
||||
(*handler)(param, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
(*handler)(machine, offset * 2 + 0, data >> 16, mem_mask >> 16);
|
||||
if (ACCESSING_BITS_0_15)
|
||||
(*handler)(param, offset * 2 + 1, data, mem_mask);
|
||||
(*handler)(machine, offset * 2 + 1, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -215,23 +215,23 @@ INLINE void write32be_with_16be_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32le_with_16le_handler(read16_machine_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32le_with_16le_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
if (ACCESSING_BITS_0_15)
|
||||
result |= (*handler)(param, offset * 2 + 0, mem_mask) << 0;
|
||||
result |= (*handler)(machine, offset * 2 + 0, mem_mask) << 0;
|
||||
if (ACCESSING_BITS_16_31)
|
||||
result |= (*handler)(param, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
result |= (*handler)(machine, offset * 2 + 1, mem_mask >> 16) << 16;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32le_with_16le_handler(write16_machine_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32le_with_16le_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_15)
|
||||
(*handler)(param, offset * 2 + 0, data, mem_mask);
|
||||
(*handler)(machine, offset * 2 + 0, data, mem_mask);
|
||||
if (ACCESSING_BITS_16_31)
|
||||
(*handler)(param, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
(*handler)(machine, offset * 2 + 1, data >> 16, mem_mask >> 16);
|
||||
}
|
||||
|
||||
|
||||
@ -241,20 +241,20 @@ INLINE void write32le_with_16le_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32be_with_16le_handler(read16_machine_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32be_with_16le_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
result = read32le_with_16le_handler(handler, param, offset, mem_mask);
|
||||
result = read32le_with_16le_handler(handler, machine, offset, mem_mask);
|
||||
return FLIPENDIAN_INT32(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32be_with_16le_handler(write16_machine_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32be_with_16le_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT32(data);
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
write32le_with_16le_handler(handler, param, offset, data, mem_mask);
|
||||
write32le_with_16le_handler(handler, machine, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -264,20 +264,20 @@ INLINE void write32be_with_16le_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read32le_with_16be_handler(read16_machine_func handler, void *param, offs_t offset, UINT32 mem_mask)
|
||||
INLINE UINT32 read32le_with_16be_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT32 mem_mask)
|
||||
{
|
||||
UINT32 result = 0;
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
result = read32be_with_16be_handler(handler, param, offset, mem_mask);
|
||||
result = read32be_with_16be_handler(handler, machine, offset, mem_mask);
|
||||
return FLIPENDIAN_INT32(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write32le_with_16be_handler(write16_machine_func handler, void *param, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
INLINE void write32le_with_16be_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT32 data, UINT32 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT32(data);
|
||||
mem_mask = FLIPENDIAN_INT32(mem_mask);
|
||||
write32be_with_16be_handler(handler, param, offset, data, mem_mask);
|
||||
write32be_with_16be_handler(handler, machine, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -287,23 +287,23 @@ INLINE void write32le_with_16be_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64be_with_read8_handler(read8_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64be_with_read8_handler(read8_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)read32be_with_read8_handler(handler, param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32be_with_read8_handler(handler, machine, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)read32be_with_read8_handler(handler, param, offset * 2 + 1, mem_mask) << 0;
|
||||
result |= (UINT64)read32be_with_read8_handler(handler, machine, offset * 2 + 1, mem_mask) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_write8_handler(write8_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_write8_handler(write8_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_32_63)
|
||||
write32be_with_write8_handler(handler, param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
write32be_with_write8_handler(handler, machine, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if (ACCESSING_BITS_0_31)
|
||||
write32be_with_write8_handler(handler, param, offset * 2 + 1, data, mem_mask);
|
||||
write32be_with_write8_handler(handler, machine, offset * 2 + 1, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -313,23 +313,23 @@ INLINE void write64be_with_write8_handler(write8_machine_func handler, void *par
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64le_with_read8_handler(read8_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64le_with_read8_handler(read8_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)read32le_with_read8_handler(handler, param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32le_with_read8_handler(handler, machine, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)read32le_with_read8_handler(handler, param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32le_with_read8_handler(handler, machine, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_write8_handler(write8_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_write8_handler(write8_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_31)
|
||||
write32le_with_write8_handler(handler, param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
write32le_with_write8_handler(handler, machine, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if (ACCESSING_BITS_32_63)
|
||||
write32le_with_write8_handler(handler, param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
write32le_with_write8_handler(handler, machine, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -339,23 +339,23 @@ INLINE void write64le_with_write8_handler(write8_machine_func handler, void *par
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64be_with_16be_handler(read16_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64be_with_16be_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)read32be_with_16be_handler(handler, param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32be_with_16be_handler(handler, machine, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)read32be_with_16be_handler(handler, param, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32be_with_16be_handler(handler, machine, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_16be_handler(write16_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_16be_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_32_63)
|
||||
write32be_with_16be_handler(handler, param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
write32be_with_16be_handler(handler, machine, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if (ACCESSING_BITS_0_31)
|
||||
write32be_with_16be_handler(handler, param, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
write32be_with_16be_handler(handler, machine, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -365,23 +365,23 @@ INLINE void write64be_with_16be_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64le_with_16le_handler(read16_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64le_with_16le_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)read32le_with_16le_handler(handler, param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32le_with_16le_handler(handler, machine, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)read32le_with_16le_handler(handler, param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32le_with_16le_handler(handler, machine, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_16le_handler(write16_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_16le_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_31)
|
||||
write32le_with_16le_handler(handler, param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
write32le_with_16le_handler(handler, machine, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if (ACCESSING_BITS_32_63)
|
||||
write32le_with_16le_handler(handler, param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
write32le_with_16le_handler(handler, machine, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -391,23 +391,23 @@ INLINE void write64le_with_16le_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64be_with_16le_handler(read16_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64be_with_16le_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)read32be_with_16le_handler(handler, param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32be_with_16le_handler(handler, machine, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)read32be_with_16le_handler(handler, param, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32be_with_16le_handler(handler, machine, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_16le_handler(write16_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_16le_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_32_63)
|
||||
write32be_with_16le_handler(handler, param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
write32be_with_16le_handler(handler, machine, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if (ACCESSING_BITS_0_31)
|
||||
write32be_with_16le_handler(handler, param, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
write32be_with_16le_handler(handler, machine, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -417,23 +417,23 @@ INLINE void write64be_with_16le_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT32 read64le_with_16be_handler(read16_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT32 read64le_with_16be_handler(read16_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)read32le_with_16be_handler(handler, param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)read32le_with_16be_handler(handler, machine, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)read32le_with_16be_handler(handler, param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)read32le_with_16be_handler(handler, machine, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_16be_handler(write16_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_16be_handler(write16_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_31)
|
||||
write32le_with_16be_handler(handler, param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
write32le_with_16be_handler(handler, machine, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if (ACCESSING_BITS_32_63)
|
||||
write32le_with_16be_handler(handler, param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
write32le_with_16be_handler(handler, machine, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -443,23 +443,23 @@ INLINE void write64le_with_16be_handler(write16_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64be_with_32be_handler(read32_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64be_with_32be_handler(read32_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)(*handler)(machine, offset * 2 + 0, mem_mask >> 32) << 32;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)(*handler)(machine, offset * 2 + 1, mem_mask >> 0) << 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_32be_handler(write32_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_32be_handler(write32_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_32_63)
|
||||
(*handler)(param, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
(*handler)(machine, offset * 2 + 0, data >> 32, mem_mask >> 32);
|
||||
if (ACCESSING_BITS_0_31)
|
||||
(*handler)(param, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
(*handler)(machine, offset * 2 + 1, data >> 0, mem_mask >> 0);
|
||||
}
|
||||
|
||||
|
||||
@ -469,23 +469,23 @@ INLINE void write64be_with_32be_handler(write32_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64le_with_32le_handler(read32_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64le_with_32le_handler(read32_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result = 0;
|
||||
if (ACCESSING_BITS_0_31)
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
result |= (UINT64)(*handler)(machine, offset * 2 + 0, mem_mask >> 0) << 0;
|
||||
if (ACCESSING_BITS_32_63)
|
||||
result |= (UINT64)(*handler)(param, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
result |= (UINT64)(*handler)(machine, offset * 2 + 1, mem_mask >> 32) << 32;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_32le_handler(write32_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_32le_handler(write32_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
if (ACCESSING_BITS_0_31)
|
||||
(*handler)(param, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
(*handler)(machine, offset * 2 + 0, data >> 0, mem_mask >> 0);
|
||||
if (ACCESSING_BITS_32_63)
|
||||
(*handler)(param, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
(*handler)(machine, offset * 2 + 1, data >> 32, mem_mask >> 32);
|
||||
}
|
||||
|
||||
|
||||
@ -495,20 +495,20 @@ INLINE void write64le_with_32le_handler(write32_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64be_with_32le_handler(read32_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64be_with_32le_handler(read32_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result;
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
result = read64le_with_32le_handler(handler, param, offset, mem_mask);
|
||||
result = read64le_with_32le_handler(handler, machine, offset, mem_mask);
|
||||
return FLIPENDIAN_INT64(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64be_with_32le_handler(write32_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64be_with_32le_handler(write32_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT64(data);
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
write64le_with_32le_handler(handler, param, offset, data, mem_mask);
|
||||
write64le_with_32le_handler(handler, machine, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -518,20 +518,20 @@ INLINE void write64be_with_32le_handler(write32_machine_func handler, void *para
|
||||
*
|
||||
*************************************/
|
||||
|
||||
INLINE UINT64 read64le_with_32be_handler(read32_machine_func handler, void *param, offs_t offset, UINT64 mem_mask)
|
||||
INLINE UINT64 read64le_with_32be_handler(read32_machine_func handler, running_machine *machine, offs_t offset, UINT64 mem_mask)
|
||||
{
|
||||
UINT64 result;
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
result = read64be_with_32be_handler(handler, param, offset, mem_mask);
|
||||
result = read64be_with_32be_handler(handler, machine, offset, mem_mask);
|
||||
return FLIPENDIAN_INT64(result);
|
||||
}
|
||||
|
||||
|
||||
INLINE void write64le_with_32be_handler(write32_machine_func handler, void *param, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
INLINE void write64le_with_32be_handler(write32_machine_func handler, running_machine *machine, offs_t offset, UINT64 data, UINT64 mem_mask)
|
||||
{
|
||||
data = FLIPENDIAN_INT64(data);
|
||||
mem_mask = FLIPENDIAN_INT64(mem_mask);
|
||||
write64be_with_32be_handler(handler, param, offset, data, mem_mask);
|
||||
write64be_with_32be_handler(handler, machine, offset, data, mem_mask);
|
||||
}
|
||||
|
||||
|
||||
@ -545,28 +545,28 @@ INLINE void write64le_with_32be_handler(write32_machine_func handler, void *para
|
||||
#define READ_TEMPLATE(bits, name, handler, func) \
|
||||
READ##bits##_HANDLER( name##_r ) \
|
||||
{ \
|
||||
return func(handler, param, offset, mem_mask); \
|
||||
return func(handler, machine, offset, mem_mask); \
|
||||
}
|
||||
|
||||
#define READ_TEMPLATE_COND(bits, name, handler, func, cond) \
|
||||
READ##bits##_HANDLER( name##_r ) \
|
||||
{ \
|
||||
if (cond) \
|
||||
return func(handler, param, offset, mem_mask); \
|
||||
return func(handler, machine, offset, mem_mask); \
|
||||
return 0; \
|
||||
}
|
||||
|
||||
#define WRITE_TEMPLATE(bits, name, handler, func) \
|
||||
WRITE##bits##_HANDLER( name##_w ) \
|
||||
{ \
|
||||
func(handler, param, offset, data, mem_mask); \
|
||||
func(handler, machine, offset, data, mem_mask); \
|
||||
}
|
||||
|
||||
#define WRITE_TEMPLATE_COND(bits, name, handler, func, cond) \
|
||||
WRITE##bits##_HANDLER( name##_w ) \
|
||||
{ \
|
||||
if (cond) \
|
||||
return func(handler, param, offset, data, mem_mask); \
|
||||
return func(handler, machine, offset, data, mem_mask); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -107,14 +107,14 @@ typedef void (*write64_machine_func)(ATTR_UNUSED running_machine *machine, ATTR_
|
||||
|
||||
|
||||
/* device read/write handlers */
|
||||
typedef UINT8 (*read8_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset);
|
||||
typedef void (*write8_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data);
|
||||
typedef UINT16 (*read16_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask);
|
||||
typedef void (*write16_device_func)(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask);
|
||||
typedef UINT32 (*read32_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask);
|
||||
typedef void (*write32_device_func)(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask);
|
||||
typedef UINT64 (*read64_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask);
|
||||
typedef void (*write64_device_func)(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask);
|
||||
typedef UINT8 (*read8_device_func) (ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset);
|
||||
typedef void (*write8_device_func) (ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data);
|
||||
typedef UINT16 (*read16_device_func) (ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask);
|
||||
typedef void (*write16_device_func)(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask);
|
||||
typedef UINT32 (*read32_device_func) (ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask);
|
||||
typedef void (*write32_device_func)(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask);
|
||||
typedef UINT64 (*read64_device_func) (ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask);
|
||||
typedef void (*write64_device_func)(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask);
|
||||
|
||||
|
||||
/* data_accessors is a struct with accessors of all flavors */
|
||||
@ -359,14 +359,14 @@ union _addrmap64_token
|
||||
|
||||
|
||||
/* device read/write handler function macros */
|
||||
#define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset)
|
||||
#define WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data)
|
||||
#define READ16_DEVICE_HANDLER(name) UINT16 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask)
|
||||
#define WRITE16_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask)
|
||||
#define READ32_DEVICE_HANDLER(name) UINT32 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask)
|
||||
#define WRITE32_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask)
|
||||
#define READ64_DEVICE_HANDLER(name) UINT64 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask)
|
||||
#define WRITE64_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask)
|
||||
#define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset)
|
||||
#define WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data)
|
||||
#define READ16_DEVICE_HANDLER(name) UINT16 name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask)
|
||||
#define WRITE16_DEVICE_HANDLER(name) void name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask)
|
||||
#define READ32_DEVICE_HANDLER(name) UINT32 name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask)
|
||||
#define WRITE32_DEVICE_HANDLER(name) void name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask)
|
||||
#define READ64_DEVICE_HANDLER(name) UINT64 name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask)
|
||||
#define WRITE64_DEVICE_HANDLER(name) void name(ATTR_UNUSED const device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask)
|
||||
|
||||
|
||||
/* static memory handler (SMH) macros that can be used in place of read/write handlers */
|
||||
|
||||
@ -57,11 +57,11 @@ static UINT32 *cga_ram;
|
||||
static UINT32 *bios_ram;
|
||||
|
||||
static struct {
|
||||
device_config *pit8254;
|
||||
device_config *pic8259_1;
|
||||
device_config *pic8259_2;
|
||||
device_config *dma8237_1;
|
||||
device_config *dma8237_2;
|
||||
const device_config *pit8254;
|
||||
const device_config *pic8259_1;
|
||||
const device_config *pic8259_2;
|
||||
const device_config *dma8237_1;
|
||||
const device_config *dma8237_2;
|
||||
} gamecstl_devices;
|
||||
|
||||
|
||||
@ -572,11 +572,11 @@ static MACHINE_RESET(gamecstl)
|
||||
|
||||
cpunum_set_irq_callback(0, irq_callback);
|
||||
|
||||
gamecstl_devices.pit8254 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" );
|
||||
gamecstl_devices.pic8259_1 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_1" );
|
||||
gamecstl_devices.pic8259_2 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_2" );
|
||||
gamecstl_devices.dma8237_1 = (device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" );
|
||||
gamecstl_devices.dma8237_2 = (device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
|
||||
gamecstl_devices.pit8254 = device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" );
|
||||
gamecstl_devices.pic8259_1 = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_1" );
|
||||
gamecstl_devices.pic8259_2 = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_2" );
|
||||
gamecstl_devices.dma8237_1 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" );
|
||||
gamecstl_devices.dma8237_2 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -120,11 +120,11 @@ static UINT32 ad1847_sample_counter = 0;
|
||||
static UINT32 ad1847_sample_rate;
|
||||
|
||||
static struct {
|
||||
device_config *pit8254;
|
||||
device_config *pic8259_1;
|
||||
device_config *pic8259_2;
|
||||
device_config *dma8237_1;
|
||||
device_config *dma8237_2;
|
||||
const device_config *pit8254;
|
||||
const device_config *pic8259_1;
|
||||
const device_config *pic8259_2;
|
||||
const device_config *dma8237_1;
|
||||
const device_config *dma8237_2;
|
||||
} mediagx_devices;
|
||||
|
||||
|
||||
@ -990,11 +990,11 @@ static MACHINE_RESET(mediagx)
|
||||
dmadac_enable(0, 2, 1);
|
||||
ide_controller_reset(0);
|
||||
|
||||
mediagx_devices.pit8254 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" );
|
||||
mediagx_devices.pic8259_1 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_1" );
|
||||
mediagx_devices.pic8259_2 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_2" );
|
||||
mediagx_devices.dma8237_1 = (device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" );
|
||||
mediagx_devices.dma8237_2 = (device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
|
||||
mediagx_devices.pit8254 = device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" );
|
||||
mediagx_devices.pic8259_1 = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_1" );
|
||||
mediagx_devices.pic8259_2 = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_2" );
|
||||
mediagx_devices.dma8237_1 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" );
|
||||
mediagx_devices.dma8237_2 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
|
||||
}
|
||||
|
||||
/*************************************************************
|
||||
|
||||
@ -22,11 +22,11 @@ static UINT32 *cga_ram;
|
||||
static UINT32 *bios_ram;
|
||||
|
||||
static struct {
|
||||
device_config *pit8254;
|
||||
device_config *pic8259_1;
|
||||
device_config *pic8259_2;
|
||||
device_config *dma8237_1;
|
||||
device_config *dma8237_2;
|
||||
const device_config *pit8254;
|
||||
const device_config *pic8259_1;
|
||||
const device_config *pic8259_2;
|
||||
const device_config *dma8237_1;
|
||||
const device_config *dma8237_2;
|
||||
} taitowlf_devices;
|
||||
|
||||
|
||||
@ -538,11 +538,11 @@ static MACHINE_RESET(taitowlf)
|
||||
|
||||
cpunum_set_irq_callback(0, irq_callback);
|
||||
|
||||
taitowlf_devices.pit8254 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" );
|
||||
taitowlf_devices.pic8259_1 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_1" );
|
||||
taitowlf_devices.pic8259_2 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_2" );
|
||||
taitowlf_devices.dma8237_1 = (device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" );
|
||||
taitowlf_devices.dma8237_2 = (device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
|
||||
taitowlf_devices.pit8254 = device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" );
|
||||
taitowlf_devices.pic8259_1 = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_1" );
|
||||
taitowlf_devices.pic8259_2 = device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259_2" );
|
||||
taitowlf_devices.dma8237_1 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_1" );
|
||||
taitowlf_devices.dma8237_2 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user