Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-05 20:33:45 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Changed device read/write functions to take a const device_config *.

Browse Source 
Reverted recent hacks to get around this and removed unnecessary casts.
This commit is contained in:
Aaron Giles 2008-04-13 15:01:23 +00:00
parent 19784846a1
commit 842ed3efb0
6 changed files with 250 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
src/emu/devconv.h
View File

@ -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; UINT16 result = 0;
if ((mem_mask & 0xff00) != 0xff00) 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) if ((mem_mask & 0x00ff) != 0x00ff)
result |= ((UINT16)(*handler)(param, offset * 2 + 1)) << 0; result |= ((UINT16)(*handler)(device, offset * 2 + 1)) << 0;
return result; 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) if ((mem_mask & 0xff00) != 0xff00)
(*handler)(param, offset * 2 + 0, data >> 8); (*handler)(device, offset * 2 + 0, data >> 8);
if ((mem_mask & 0x00ff) != 0x00ff) 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; UINT16 result = 0;
if ((mem_mask & 0x00ff) != 0x00ff) 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) if ((mem_mask & 0xff00) != 0xff00)
result |= ((UINT16) (*handler)(param, offset * 2 + 1)) << 8; result |= ((UINT16) (*handler)(device, offset * 2 + 1)) << 8;
return result; 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) if ((mem_mask & 0x00ff) != 0x00ff)
(*handler)(param, offset * 2 + 0, data >> 0); (*handler)(device, offset * 2 + 0, data >> 0);
if ((mem_mask & 0xff00) != 0xff00) 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; UINT32 result = 0;
if ((mem_mask & 0xffff0000) != 0xffff0000) 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) 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; 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) 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) 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; UINT32 result = 0;
if ((mem_mask & 0x0000ffff) != 0x0000ffff) 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) 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; 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) 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) 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; UINT32 result = 0;
if ((mem_mask & 0xffff0000) != 0xffff0000) 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) 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; 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) 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) 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; UINT32 result = 0;
if ((mem_mask & 0x0000ffff) != 0x0000ffff) 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) 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; 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) 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) 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; UINT32 result = 0;
mem_mask = FLIPENDIAN_INT32(mem_mask); 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); 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); data = FLIPENDIAN_INT32(data);
mem_mask = FLIPENDIAN_INT32(mem_mask); 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; UINT32 result = 0;
mem_mask = FLIPENDIAN_INT32(mem_mask); 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); 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); data = FLIPENDIAN_INT32(data);
mem_mask = FLIPENDIAN_INT32(mem_mask); 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; UINT64 result = 0;
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0xffffffff00000000)) != U64(0xffffffff00000000)) 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)) 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; 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)) 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)) 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; UINT64 result = 0;
if ((mem_mask & U64(0x00000000ffffffff)) != U64(0x00000000ffffffff)) 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)) 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; 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)) 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)) 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; UINT64 result;
mem_mask = FLIPENDIAN_INT64(mem_mask); 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); 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); data = FLIPENDIAN_INT64(data);
mem_mask = FLIPENDIAN_INT64(mem_mask); 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; UINT64 result;
mem_mask = FLIPENDIAN_INT64(mem_mask); 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); 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); data = FLIPENDIAN_INT64(data);
mem_mask = FLIPENDIAN_INT64(mem_mask); 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);
} }

208
src/emu/memconv.h
View File

@ -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; UINT16 result = 0;
if (ACCESSING_BITS_8_15) 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) if (ACCESSING_BITS_0_7)
result |= ((UINT16)(*handler)(param, offset * 2 + 1)) << 0; result |= ((UINT16)(*handler)(machine, offset * 2 + 1)) << 0;
return result; 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) if (ACCESSING_BITS_8_15)
(*handler)(param, offset * 2 + 0, data >> 8); (*handler)(machine, offset * 2 + 0, data >> 8);
if (ACCESSING_BITS_0_7) 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; UINT16 result = 0;
if (ACCESSING_BITS_0_7) 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) if (ACCESSING_BITS_8_15)
result |= ((UINT16) (*handler)(param, offset * 2 + 1)) << 8; result |= ((UINT16) (*handler)(machine, offset * 2 + 1)) << 8;
return result; 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) if (ACCESSING_BITS_0_7)
(*handler)(param, offset * 2 + 0, data >> 0); (*handler)(machine, offset * 2 + 0, data >> 0);
if (ACCESSING_BITS_8_15) 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; UINT32 result = 0;
if (ACCESSING_BITS_16_31) 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) 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; 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) 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) 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; UINT32 result = 0;
if (ACCESSING_BITS_0_15) 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) 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; 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) 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) 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; UINT32 result = 0;
if (ACCESSING_BITS_16_31) 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) 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; 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) 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) 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; UINT32 result = 0;
if (ACCESSING_BITS_0_15) 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) 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; 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) 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) 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; UINT32 result = 0;
mem_mask = FLIPENDIAN_INT32(mem_mask); 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); 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); data = FLIPENDIAN_INT32(data);
mem_mask = FLIPENDIAN_INT32(mem_mask); 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; UINT32 result = 0;
mem_mask = FLIPENDIAN_INT32(mem_mask); 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); 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); data = FLIPENDIAN_INT32(data);
mem_mask = FLIPENDIAN_INT32(mem_mask); 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; UINT64 result = 0;
if (ACCESSING_BITS_32_63) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_0_31) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_32_63) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_0_31) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_32_63) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_0_31) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_32_63) 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) 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; 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) 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) 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; UINT64 result = 0;
if (ACCESSING_BITS_0_31) 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) 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; 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) 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) 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; UINT64 result;
mem_mask = FLIPENDIAN_INT64(mem_mask); 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); 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); data = FLIPENDIAN_INT64(data);
mem_mask = FLIPENDIAN_INT64(mem_mask); 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; UINT64 result;
mem_mask = FLIPENDIAN_INT64(mem_mask); 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); 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); data = FLIPENDIAN_INT64(data);
mem_mask = FLIPENDIAN_INT64(mem_mask); 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) \ #define READ_TEMPLATE(bits, name, handler, func) \
READ##bits##_HANDLER( name##_r ) \ 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) \ #define READ_TEMPLATE_COND(bits, name, handler, func, cond) \
READ##bits##_HANDLER( name##_r ) \ READ##bits##_HANDLER( name##_r ) \
{ \ { \
if (cond) \ if (cond) \
return func(handler, param, offset, mem_mask); \ return func(handler, machine, offset, mem_mask); \
return 0; \ return 0; \
} }
#define WRITE_TEMPLATE(bits, name, handler, func) \ #define WRITE_TEMPLATE(bits, name, handler, func) \
WRITE##bits##_HANDLER( name##_w ) \ 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) \ #define WRITE_TEMPLATE_COND(bits, name, handler, func, cond) \
WRITE##bits##_HANDLER( name##_w ) \ WRITE##bits##_HANDLER( name##_w ) \
{ \ { \
if (cond) \ if (cond) \
return func(handler, param, offset, data, mem_mask); \ return func(handler, machine, offset, data, mem_mask); \
} }

32
src/emu/memory.h
View File

@ -107,14 +107,14 @@ typedef void (*write64_machine_func)(ATTR_UNUSED running_machine *machine, ATTR_
/* device read/write handlers */ /* device read/write handlers */
typedef UINT8 (*read8_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset); typedef UINT8 (*read8_device_func) (ATTR_UNUSED const 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 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask); 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, 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 */ /* data_accessors is a struct with accessors of all flavors */
@ -359,14 +359,14 @@ union _addrmap64_token
/* device read/write handler function macros */ /* device read/write handler function macros */
#define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset) #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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data) #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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask) #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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 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 device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, 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 */ /* static memory handler (SMH) macros that can be used in place of read/write handlers */

20
src/mame/drivers/gamecstl.c
View File

@ -57,11 +57,11 @@ static UINT32 *cga_ram;
static UINT32 *bios_ram; static UINT32 *bios_ram;
static struct { static struct {
device_config *pit8254; const device_config *pit8254;
device_config *pic8259_1; const device_config *pic8259_1;
device_config *pic8259_2; const device_config *pic8259_2;
device_config *dma8237_1; const device_config *dma8237_1;
device_config *dma8237_2; const device_config *dma8237_2;
} gamecstl_devices; } gamecstl_devices;
@ -572,11 +572,11 @@ static MACHINE_RESET(gamecstl)
cpunum_set_irq_callback(0, irq_callback); cpunum_set_irq_callback(0, irq_callback);
gamecstl_devices.pit8254 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" ); gamecstl_devices.pit8254 = 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_1 = 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.pic8259_2 = 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_1 = 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.dma8237_2 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
} }

20
src/mame/drivers/mediagx.c
View File

@ -120,11 +120,11 @@ static UINT32 ad1847_sample_counter = 0;
static UINT32 ad1847_sample_rate; static UINT32 ad1847_sample_rate;
static struct { static struct {
device_config *pit8254; const device_config *pit8254;
device_config *pic8259_1; const device_config *pic8259_1;
device_config *pic8259_2; const device_config *pic8259_2;
device_config *dma8237_1; const device_config *dma8237_1;
device_config *dma8237_2; const device_config *dma8237_2;
} mediagx_devices; } mediagx_devices;
@ -990,11 +990,11 @@ static MACHINE_RESET(mediagx)
dmadac_enable(0, 2, 1); dmadac_enable(0, 2, 1);
ide_controller_reset(0); ide_controller_reset(0);
mediagx_devices.pit8254 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" ); mediagx_devices.pit8254 = 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_1 = 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.pic8259_2 = 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_1 = 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.dma8237_2 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
} }
/************************************************************* /*************************************************************

20
src/mame/drivers/taitowlf.c
View File

@ -22,11 +22,11 @@ static UINT32 *cga_ram;
static UINT32 *bios_ram; static UINT32 *bios_ram;
static struct { static struct {
device_config *pit8254; const device_config *pit8254;
device_config *pic8259_1; const device_config *pic8259_1;
device_config *pic8259_2; const device_config *pic8259_2;
device_config *dma8237_1; const device_config *dma8237_1;
device_config *dma8237_2; const device_config *dma8237_2;
} taitowlf_devices; } taitowlf_devices;
@ -538,11 +538,11 @@ static MACHINE_RESET(taitowlf)
cpunum_set_irq_callback(0, irq_callback); cpunum_set_irq_callback(0, irq_callback);
taitowlf_devices.pit8254 = (device_config*)device_list_find_by_tag( machine->config->devicelist, PIT8254, "pit8254" ); taitowlf_devices.pit8254 = 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_1 = 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.pic8259_2 = 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_1 = 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.dma8237_2 = device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" );
} }