diff options
Diffstat (limited to 'trunk/src/emu/addrmap.h')
-rw-r--r-- | trunk/src/emu/addrmap.h | 1151 |
1 files changed, 1151 insertions, 0 deletions
diff --git a/trunk/src/emu/addrmap.h b/trunk/src/emu/addrmap.h new file mode 100644 index 00000000000..846bbba0066 --- /dev/null +++ b/trunk/src/emu/addrmap.h @@ -0,0 +1,1151 @@ +/*************************************************************************** + + addrmap.h + + Macros and helper functions for handling address map definitions. + +**************************************************************************** + + Copyright Aaron Giles + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + * Neither the name 'MAME' nor the names of its contributors may be + used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + +***************************************************************************/ + +#pragma once + +#ifndef __EMU_H__ +#error Dont include this file directly; include emu.h instead. +#endif + +#ifndef __ADDRMAP_H__ +#define __ADDRMAP_H__ + + + +//************************************************************************** +// CONSTANTS +//************************************************************************** + +// address map handler types +enum map_handler_type +{ + AMH_NONE = 0, + AMH_RAM, + AMH_ROM, + AMH_NOP, + AMH_UNMAP, + AMH_DEVICE_DELEGATE, + AMH_LEGACY_SPACE_HANDLER, + AMH_LEGACY_DEVICE_HANDLER, + AMH_PORT, + AMH_BANK, + AMH_DEVICE_SUBMAP +}; + + + +//************************************************************************** +// TYPE DEFINITIONS +//************************************************************************** + +// submap retriever delegate +typedef delegate<void (address_map &, const device_t &)> address_map_delegate; + +// address map handler data +class map_handler_data +{ +public: + map_handler_data() + : m_type(AMH_NONE), + m_bits(0), + m_mask(0), + m_name(NULL), + m_tag(NULL) { } + + map_handler_type m_type; // type of the handler + UINT8 m_bits; // width of the handler in bits, or 0 for default + UINT64 m_mask; // mask for which lanes apply + const char * m_name; // name of the handler + const char * m_tag; // tag pointing to a reference + astring m_derived_tag; // string used to hold derived names + + void set_tag(const device_t &device, const char *tag); +}; + + + +// ======================> address_map_entry + +// address_map_entry is a linked list element describing one address range in a map +class address_map_entry +{ +public: + // construction/destruction + address_map_entry(address_map &map, offs_t start, offs_t end); + + // getters + address_map_entry *next() const { return m_next; } + + // simple inline setters + void set_mirror(offs_t _mirror) { m_addrmirror = _mirror; } + void set_read_type(map_handler_type _type) { m_read.m_type = _type; } + void set_write_type(map_handler_type _type) { m_write.m_type = _type; } + void set_region(const char *tag, offs_t offset) { m_region = tag; m_rgnoffs = offset; } + void set_share(const char *tag) { m_share = tag; } + void set_sizeptr(size_t *_sizeptr) { m_sizeptr = _sizeptr; } + void set_member_baseptr(FPTR offs) { m_baseptroffs_plus1 = offs + 1; } + void set_member_sizeptr(FPTR offs) { m_sizeptroffs_plus1 = offs + 1; } + void set_generic_baseptr(FPTR offs) { m_genbaseptroffs_plus1 = offs + 1; } + void set_generic_sizeptr(FPTR offs) { m_gensizeptroffs_plus1 = offs + 1; } + + // mask setting + void set_mask(offs_t _mask); + + // I/O port configuration + void set_read_port(const device_t &device, const char *tag); + void set_write_port(const device_t &device, const char *tag); + void set_readwrite_port(const device_t &device, const char *tag); + + // memory bank configuration + void set_read_bank(const device_t &device, const char *tag); + void set_write_bank(const device_t &device, const char *tag); + void set_readwrite_bank(const device_t &device, const char *tag); + + // submap referencing + void set_submap(const device_t &device, const char *tag, address_map_delegate func, int bits, UINT64 mask); + + // public state + address_map_entry * m_next; // pointer to the next entry + address_map & m_map; // reference to our owning map + astring m_region_string; // string used to hold derived names + + // basic information + offs_t m_addrstart; // start address + offs_t m_addrend; // end address + offs_t m_addrmirror; // mirror bits + offs_t m_addrmask; // mask bits + map_handler_data m_read; // data for read handler + map_handler_data m_write; // data for write handler + const char * m_share; // tag of a shared memory block + void ** m_baseptr; // receives pointer to memory (optional) + size_t * m_sizeptr; // receives size of area in bytes (optional) + UINT32 m_baseptroffs_plus1; // offset of base pointer within driver_data, plus 1 + UINT32 m_sizeptroffs_plus1; // offset of size pointer within driver_data, plus 1 + UINT32 m_genbaseptroffs_plus1; // offset of base pointer within generic_pointers, plus 1 + UINT32 m_gensizeptroffs_plus1; // offset of size pointer within generic_pointers, plus 1 + const char * m_region; // tag of region containing the memory backing this entry + offs_t m_rgnoffs; // offset within the region + + // handlers + read8_delegate m_rproto8; // 8-bit read proto-delegate + read16_delegate m_rproto16; // 16-bit read proto-delegate + read32_delegate m_rproto32; // 32-bit read proto-delegate + read64_delegate m_rproto64; // 64-bit read proto-delegate + read8_space_func m_rspace8; // 8-bit legacy address space handler + read16_space_func m_rspace16; // 16-bit legacy address space handler + read32_space_func m_rspace32; // 32-bit legacy address space handler + read64_space_func m_rspace64; // 64-bit legacy address space handler + read8_device_func m_rdevice8; // 8-bit legacy device handler + read16_device_func m_rdevice16; // 16-bit legacy device handler + read32_device_func m_rdevice32; // 32-bit legacy device handler + read64_device_func m_rdevice64; // 64-bit legacy device handler + write8_delegate m_wproto8; // 8-bit write proto-delegate + write16_delegate m_wproto16; // 16-bit write proto-delegate + write32_delegate m_wproto32; // 32-bit write proto-delegate + write64_delegate m_wproto64; // 64-bit write proto-delegate + write8_space_func m_wspace8; // 8-bit legacy address space handler + write16_space_func m_wspace16; // 16-bit legacy address space handler + write32_space_func m_wspace32; // 32-bit legacy address space handler + write64_space_func m_wspace64; // 64-bit legacy address space handler + write8_device_func m_wdevice8; // 8-bit legacy device handler + write16_device_func m_wdevice16; // 16-bit legacy device handler + write32_device_func m_wdevice32; // 32-bit legacy device handler + write64_device_func m_wdevice64; // 64-bit legacy device handler + + address_map_delegate m_submap_delegate; + int m_submap_bits; + + // information used during processing + void * m_memory; // pointer to memory backing this entry + offs_t m_bytestart; // byte-adjusted start address + offs_t m_byteend; // byte-adjusted end address + offs_t m_bytemirror; // byte-adjusted mirror bits + offs_t m_bytemask; // byte-adjusted mask bits + +protected: + // internal base pointer setting (derived classes provide typed versions) + void internal_set_baseptr(void **_baseptr) { m_baseptr = _baseptr; } + + // internal handler setters for 8-bit functions + void internal_set_handler(read8_space_func func, const char *string, UINT64 mask); + void internal_set_handler(write8_space_func func, const char *string, UINT64 mask); + void internal_set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask); + + // internal handler setters for 16-bit functions + void internal_set_handler(read16_space_func func, const char *string, UINT64 mask); + void internal_set_handler(write16_space_func func, const char *string, UINT64 mask); + void internal_set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask); + + // internal handler setters for 32-bit functions + void internal_set_handler(read32_space_func func, const char *string, UINT64 mask); + void internal_set_handler(write32_space_func func, const char *string, UINT64 mask); + void internal_set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask); + + // internal handler setters for 64-bit functions + void internal_set_handler(read64_space_func func, const char *string, UINT64 mask); + void internal_set_handler(write64_space_func func, const char *string, UINT64 mask); + void internal_set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read64_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write64_device_func func, const char *string, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read64_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, write64_delegate func, UINT64 mask); + void internal_set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc, UINT64 mask); + +private: + // helper functions + bool unitmask_is_appropriate(UINT8 width, UINT64 unitmask, const char *string); +}; + + +// ======================> address_map_entry8 + +// 8-bit address map version of address_map_entry which only permits valid 8-bit handlers +class address_map_entry8 : public address_map_entry +{ +public: + address_map_entry8(address_map &map, offs_t start, offs_t end); + + void set_baseptr(UINT8 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); } + + // native-size handlers + void set_handler(read8_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(write8_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read8_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, write8_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } +}; + + +// ======================> address_map_entry16 + +// 16-bit address map version of address_map_entry which only permits valid 16-bit handlers +class address_map_entry16 : public address_map_entry +{ +public: + address_map_entry16(address_map &map, offs_t start, offs_t end); + + void set_baseptr(UINT16 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); } + + // native-size handlers + void set_handler(read16_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(write16_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read16_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, write16_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } + + // 8-bit handlers + void set_handler(read8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); } + void set_handler(write8_space_func func, const char *string, UINT16 mask) { internal_set_handler(func, string, mask); } + void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT16 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT16 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT16 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT16 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT16 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } +}; + + +// ======================> address_map_entry32 + +// 32-bit address map version of address_map_entry which only permits valid 32-bit handlers +class address_map_entry32 : public address_map_entry +{ +public: + address_map_entry32(address_map &map, offs_t start, offs_t end); + + void set_baseptr(UINT32 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); } + + // native-size handlers + void set_handler(read32_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(write32_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read32_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, write32_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } + + // 16-bit handlers + void set_handler(read16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } + void set_handler(write16_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } + void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } + + // 8-bit handlers + void set_handler(read8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } + void set_handler(write8_space_func func, const char *string, UINT32 mask) { internal_set_handler(func, string, mask); } + void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT32 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT32 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT32 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT32 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } +}; + + +// ======================> address_map_entry64 + +// 64-bit address map version of address_map_entry which only permits valid 64-bit handlers +class address_map_entry64 : public address_map_entry +{ +public: + address_map_entry64(address_map &map, offs_t start, offs_t end); + + void set_baseptr(UINT64 **baseptr) { internal_set_baseptr(reinterpret_cast<void **>(baseptr)); } + + // native-size handlers + void set_handler(read64_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(write64_space_func func, const char *string) { internal_set_handler(func, string, 0); } + void set_handler(read64_space_func rfunc, const char *rstring, write64_space_func wfunc, const char *wstring) { internal_set_handler(rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read64_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, write64_device_func func, const char *string) { internal_set_handler(device, tag, func, string, 0); } + void set_handler(const device_t &device, const char *tag, read64_device_func rfunc, const char *rstring, write64_device_func wfunc, const char *wstring) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, 0); } + void set_handler(const device_t &device, const char *tag, read64_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, write64_delegate func) { internal_set_handler(device, tag, func, 0); } + void set_handler(const device_t &device, const char *tag, read64_delegate rfunc, write64_delegate wfunc) { internal_set_handler(device, tag, rfunc, wfunc, 0); } + + // 32-bit handlers + void set_handler(read32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } + void set_handler(write32_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } + void set_handler(read32_space_func rfunc, const char *rstring, write32_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read32_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, write32_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, read32_device_func rfunc, const char *rstring, write32_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, write32_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, read32_delegate rfunc, write32_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } + + // 16-bit handlers + void set_handler(read16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } + void set_handler(write16_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } + void set_handler(read16_space_func rfunc, const char *rstring, write16_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read16_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, write16_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, read16_device_func rfunc, const char *rstring, write16_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, write16_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, read16_delegate rfunc, write16_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } + + // 8-bit handlers + void set_handler(read8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } + void set_handler(write8_space_func func, const char *string, UINT64 mask) { internal_set_handler(func, string, mask); } + void set_handler(read8_space_func rfunc, const char *rstring, write8_space_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read8_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, write8_device_func func, const char *string, UINT64 mask) { internal_set_handler(device, tag, func, string, mask); } + void set_handler(const device_t &device, const char *tag, read8_device_func rfunc, const char *rstring, write8_device_func wfunc, const char *wstring, UINT64 mask) { internal_set_handler(device, tag, rfunc, rstring, wfunc, wstring, mask); } + void set_handler(const device_t &device, const char *tag, read8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, write8_delegate func, UINT64 mask) { internal_set_handler(device, tag, func, mask); } + void set_handler(const device_t &device, const char *tag, read8_delegate rfunc, write8_delegate wfunc, UINT64 mask) { internal_set_handler(device, tag, rfunc, wfunc, mask); } +}; + + +// ======================> address_map + +// address_map holds global map parameters plus the head of the list of entries +class address_map +{ +public: + // construction/destruction + address_map(const device_t &device, address_spacenum spacenum); + address_map(const device_t &device, address_map_entry *entry); + ~address_map(); + + // configuration + void configure(address_spacenum _spacenum, UINT8 _databits); + + // setters + void set_global_mask(offs_t mask); + void set_unmap_value(UINT8 value) { m_unmapval = value; } + + // add a new entry of the given type + address_map_entry8 *add(offs_t start, offs_t end, address_map_entry8 *ptr); + address_map_entry16 *add(offs_t start, offs_t end, address_map_entry16 *ptr); + address_map_entry32 *add(offs_t start, offs_t end, address_map_entry32 *ptr); + address_map_entry64 *add(offs_t start, offs_t end, address_map_entry64 *ptr); + + // public data + address_spacenum m_spacenum; // space number of the map + UINT8 m_databits; // data bits represented by the map + UINT8 m_unmapval; // unmapped memory value + offs_t m_globalmask; // global mask + simple_list<address_map_entry> m_entrylist; // list of entries + + void uplift_submaps(running_machine &machine, device_t &device, endianness_t endian); +}; + + +//************************************************************************** +// ADDRESS MAP MACROS +//************************************************************************** + +// +// There are two versions of the macros below +// +// By default, the legacy forms are enabled; however, if ADDRESS_MAP_MODERN is #defined +// prior to including this file, the new format are enabled instead. +// + +// so that "0" can be used for unneeded address maps +#define construct_address_map_0 NULL + + +#ifndef ADDRESS_MAP_MODERN + +// +// Legacy ADDRESS_MAPs +// + +// start/end tags for the address map +#define ADDRESS_MAP_NAME(_name) construct_address_map_##_name + +#define ADDRESS_MAP_START(_name, _space, _bits) \ +void ADDRESS_MAP_NAME(_name)(address_map &map, const device_t &device) \ +{ \ + typedef read##_bits##_delegate read_delegate; \ + typedef write##_bits##_delegate write_delegate; \ + address_map_entry##_bits *curentry = NULL; \ + (void)curentry; \ + map.configure(_space, _bits); \ + +#define ADDRESS_MAP_END \ +} + +// use this to declare external references to an address map +#define ADDRESS_MAP_EXTERN(_name, _bits) \ + extern void ADDRESS_MAP_NAME(_name)(address_map &map, const device_t &device) + +// use this to declare an address map as a member of a modern device class +#define DECLARE_ADDRESS_MAP(_name, _bits) \ + void _name(address_map &map, const device_t &device) + + +// global controls +#define ADDRESS_MAP_GLOBAL_MASK(_mask) \ + map.set_global_mask(_mask); \ + +#define ADDRESS_MAP_UNMAP_LOW \ + map.set_unmap_value(0); \ + +#define ADDRESS_MAP_UNMAP_HIGH \ + map.set_unmap_value(~0); \ + + +// importing data from other address maps +#define AM_IMPORT_FROM(_name) \ + ADDRESS_MAP_NAME(_name)(map, device); \ + + +// address ranges +#define AM_RANGE(_start, _end) \ + curentry = map.add(_start, _end, curentry); \ + +#define AM_MASK(_mask) \ + curentry->set_mask(_mask); \ + +#define AM_MIRROR(_mirror) \ + curentry->set_mirror(_mirror); \ + + +// legacy space reads +#define AM_READ(_handler) \ + curentry->set_handler(_handler, #_handler); \ + +#define AM_READ8(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_READ16(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_READ32(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + + +// legacy space writes +#define AM_WRITE(_handler) \ + curentry->set_handler(_handler, #_handler); \ + +#define AM_WRITE8(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_WRITE16(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_WRITE32(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + + +// legacy space reads/writes +#define AM_READWRITE(_rhandler, _whandler) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler); \ + +#define AM_READWRITE8(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_READWRITE16(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_READWRITE32(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + + +// legacy device reads +#define AM_DEVREAD(_tag, _handler) \ + curentry->set_handler(device, _tag, _handler, #_handler); \ + +#define AM_DEVREAD8(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVREAD16(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVREAD32(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + + +// legacy device writes +#define AM_DEVWRITE(_tag, _handler) \ + curentry->set_handler(device, _tag, _handler, #_handler); \ + +#define AM_DEVWRITE8(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVWRITE16(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVWRITE32(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + + +// legacy device reads/writes +#define AM_DEVREADWRITE(_tag, _rhandler, _whandler) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler); \ + +#define AM_DEVREADWRITE8(_tag, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_DEVREADWRITE16(_tag, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_DEVREADWRITE32(_tag, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + + +// device reads +#define AM_DEVREAD_MODERN(_tag, _class, _handler) \ + curentry->set_handler(device, _tag, read_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0)); \ + +#define AM_DEVREAD8_MODERN(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, read8_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVREAD16_MODERN(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, read16_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVREAD32_MODERN(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, read32_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + + +// device writes +#define AM_DEVWRITE_MODERN(_tag, _class, _handler) \ + curentry->set_handler(device, _tag, write_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0)); \ + +#define AM_DEVWRITE8_MODERN(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, write8_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVWRITE16_MODERN(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, write16_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVWRITE32_MODERN(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, write32_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + + +// device reads/writes +#define AM_DEVREADWRITE_MODERN(_tag, _class, _rhandler, _whandler) \ + curentry->set_handler(device, _tag, read_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0)); \ + +#define AM_DEVREADWRITE8_MODERN(_tag, _class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, read8_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write8_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \ + +#define AM_DEVREADWRITE16_MODERN(_tag, _class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, read16_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write16_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \ + +#define AM_DEVREADWRITE32_MODERN(_tag, _class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, read32_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write32_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \ + + +// device mapping +#define AM_DEVICE(_tag, _class, _handler) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 0, 0); \ + +#define AM_DEVICE8(_tag, _class, _handler, _unitmask) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 8, _unitmask); \ + +#define AM_DEVICE16(_tag, _class, _handler, _unitmask) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 16, _unitmask); \ + +#define AM_DEVICE32(_tag, _class, _handler, _unitmask) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 32, _unitmask); \ + + + +// special-case accesses +#define AM_ROM \ + curentry->set_read_type(AMH_ROM); \ + +#define AM_RAM \ + curentry->set_read_type(AMH_RAM); \ + curentry->set_write_type(AMH_RAM); \ + +#define AM_READONLY \ + curentry->set_read_type(AMH_RAM); \ + +#define AM_WRITEONLY \ + curentry->set_write_type(AMH_RAM); \ + +#define AM_UNMAP \ + curentry->set_read_type(AMH_UNMAP); \ + curentry->set_write_type(AMH_UNMAP); \ + +#define AM_NOP \ + curentry->set_read_type(AMH_NOP); \ + curentry->set_write_type(AMH_NOP); \ + +#define AM_READNOP \ + curentry->set_read_type(AMH_NOP); \ + +#define AM_WRITENOP \ + curentry->set_write_type(AMH_NOP); \ + + +// port accesses +#define AM_READ_PORT(_tag) \ + curentry->set_read_port(device, _tag); \ + +#define AM_WRITE_PORT(_tag) \ + curentry->set_write_port(device, _tag); \ + +#define AM_READWRITE_PORT(_tag) \ + curentry->set_readwrite_port(device, _tag); \ + + +// bank accesses +#define AM_READ_BANK(_tag) \ + curentry->set_read_bank(device, _tag); \ + +#define AM_WRITE_BANK(_tag) \ + curentry->set_write_bank(device, _tag); \ + +#define AM_READWRITE_BANK(_tag) \ + curentry->set_readwrite_bank(device, _tag); \ + + +// attributes for accesses +#define AM_REGION(_tag, _offs) \ + curentry->set_region(_tag, _offs); \ + +#define AM_SHARE(_tag) \ + curentry->set_share(_tag); \ + +#define AM_BASE(_base) \ + curentry->set_baseptr(_base); \ + +#define myoffsetof(_struct, _member) ((FPTR)&((_struct *)0x1000)->_member - 0x1000) +#define AM_BASE_MEMBER(_struct, _member) \ + curentry->set_member_baseptr(myoffsetof(_struct, _member)); \ + +#define AM_BASE_GENERIC(_member) \ + curentry->set_generic_baseptr(myoffsetof(generic_pointers, _member)); \ + +#define AM_SIZE(_size) \ + curentry->set_sizeptr(_size); \ + +#define AM_SIZE_MEMBER(_struct, _member) \ + curentry->set_member_sizeptr(myoffsetof(_struct, _member)); \ + +#define AM_SIZE_GENERIC(_member) \ + curentry->set_generic_sizeptr(myoffsetof(generic_pointers, _member##_size)); \ + + +// common shortcuts +#define AM_ROMBANK(_bank) AM_READ_BANK(_bank) +#define AM_RAMBANK(_bank) AM_READWRITE_BANK(_bank) +#define AM_RAM_READ(_read) AM_READ(_read) AM_WRITEONLY +#define AM_RAM_WRITE(_write) AM_READONLY AM_WRITE(_write) +#define AM_RAM_DEVREAD(_tag, _read) AM_DEVREAD(_tag, _read) AM_WRITEONLY +#define AM_RAM_DEVWRITE(_tag, _write) AM_READONLY AM_DEVWRITE(_tag, _write) + +#define AM_BASE_SIZE_MEMBER(_struct, _base, _size) AM_BASE_MEMBER(_struct, _base) AM_SIZE_MEMBER(_struct, _size) +#define AM_BASE_SIZE_GENERIC(_member) AM_BASE_GENERIC(_member) AM_SIZE_GENERIC(_member) + + +#else + +// +// Modern ADDRESS_MAPs +// + +// start/end tags for the address map +#define ADDRESS_MAP_NAME(_name) construct_address_map_##_name + +#define ADDRESS_MAP_START(_name, _space, _bits, _class) \ +void ADDRESS_MAP_NAME(_name)(address_map &map, const device_t &device) \ +{ \ + typedef read##_bits##_delegate read_delegate; \ + typedef write##_bits##_delegate write_delegate; \ + address_map_entry##_bits *curentry = NULL; \ + (void)curentry; \ + map.configure(_space, _bits); \ + typedef _class drivdata_class; \ + +#define DEVICE_ADDRESS_MAP_START(_name, _bits, _class) \ +void _class :: _name(address_map &map, const device_t &device) \ +{ \ + typedef read##_bits##_delegate read_delegate; \ + typedef write##_bits##_delegate write_delegate; \ + address_map_entry##_bits *curentry = NULL; \ + (void)curentry; \ + map.configure(AS_PROGRAM, _bits); \ + typedef _class drivdata_class; \ + +#define ADDRESS_MAP_END \ +} + +// use this to declare external references to an address map +#define ADDRESS_MAP_EXTERN(_name, _bits) \ + extern void ADDRESS_MAP_NAME(_name)(address_map &map, const device_t &device) + +// use this to declare an address map as a member of a modern device class +#define DECLARE_ADDRESS_MAP(_name, _bits) \ + void _name(address_map &map, const device_t &device) + + +// global controls +#define ADDRESS_MAP_GLOBAL_MASK(_mask) \ + map.set_global_mask(_mask); \ + +#define ADDRESS_MAP_UNMAP_LOW \ + map.set_unmap_value(0); \ + +#define ADDRESS_MAP_UNMAP_HIGH \ + map.set_unmap_value(~0); \ + + +// importing data from other address maps +#define AM_IMPORT_FROM(_name) \ + ADDRESS_MAP_NAME(_name)(map, device); \ + +// importing data from inherited address maps +#define AM_INHERIT_FROM(_name) \ + _name(map, device); \ + + +// address ranges +#define AM_RANGE(_start, _end) \ + curentry = map.add(_start, _end, curentry); \ + +#define AM_MASK(_mask) \ + curentry->set_mask(_mask); \ + +#define AM_MIRROR(_mirror) \ + curentry->set_mirror(_mirror); \ + + +// legacy space reads +#define AM_READ_LEGACY(_handler) \ + curentry->set_handler(_handler, #_handler); \ + +#define AM_READ8_LEGACY(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_READ16_LEGACY(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_READ32_LEGACY(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + + +// legacy space writes +#define AM_WRITE_LEGACY(_handler) \ + curentry->set_handler(_handler, #_handler); \ + +#define AM_WRITE8_LEGACY(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_WRITE16_LEGACY(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + +#define AM_WRITE32_LEGACY(_handler, _unitmask) \ + curentry->set_handler(_handler, #_handler, _unitmask); \ + + +// legacy space reads/writes +#define AM_READWRITE_LEGACY(_rhandler, _whandler) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler); \ + +#define AM_READWRITE8_LEGACY(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_READWRITE16_LEGACY(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_READWRITE32_LEGACY(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(_rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + + +// legacy device reads +#define AM_DEVREAD_LEGACY(_tag, _handler) \ + curentry->set_handler(device, _tag, _handler, #_handler); \ + +#define AM_DEVREAD8_LEGACY(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVREAD16_LEGACY(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVREAD32_LEGACY(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + + +// legacy device writes +#define AM_DEVWRITE_LEGACY(_tag, _handler) \ + curentry->set_handler(device, _tag, _handler, #_handler); \ + +#define AM_DEVWRITE8_LEGACY(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVWRITE16_LEGACY(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + +#define AM_DEVWRITE32_LEGACY(_tag, _handler, _unitmask) \ + curentry->set_handler(device, _tag, _handler, #_handler, _unitmask); \ + + +// legacy device reads/writes +#define AM_DEVREADWRITE_LEGACY(_tag, _rhandler, _whandler) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler); \ + +#define AM_DEVREADWRITE8_LEGACY(_tag, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_DEVREADWRITE16_LEGACY(_tag, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + +#define AM_DEVREADWRITE32_LEGACY(_tag, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, _rhandler, #_rhandler, _whandler, #_whandler, _unitmask); \ + + +// driver data base reads +#define AM_READ_BASE(_class, _handler) \ + curentry->set_handler(device, DEVICE_SELF, read_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0)); \ + +#define AM_READ8_BASE(_class, _handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read8_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0), _unitmask); \ + +#define AM_READ16_BASE(_class, _handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read16_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0), _unitmask); \ + +#define AM_READ32_BASE(_class, _handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read32_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0), _unitmask); \ + + +// driver data base writes +#define AM_WRITE_BASE(_class, _handler) \ + curentry->set_handler(device, DEVICE_SELF, write_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0)); \ + +#define AM_WRITE8_BASE(_class, _handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, write8_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0), _unitmask); \ + +#define AM_WRITE16_BASE(_class, _handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, write16_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0), _unitmask); \ + +#define AM_WRITE32_BASE(_class, _handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, write32_delegate(&_class::_handler, "driver_data::" #_handler, (_class *)0), _unitmask); \ + + +// driver data base reads/writes +#define AM_READWRITE_BASE(_class, _rhandler, _whandler) \ + curentry->set_handler(device, DEVICE_SELF, read_delegate(&_class::_rhandler, "driver_data::" #_rhandler, (_class *)0), write_delegate(&_class::_whandler, "driver_data::" #_whandler, (_class *)0)); \ + +#define AM_READWRITE8_BASE(_class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read8_delegate(&_class::_rhandler, "driver_data::" #_rhandler, (_class *)0), write8_delegate(&_class::_whandler, "driver_data::" #_whandler, (_class *)0), _unitmask); \ + +#define AM_READWRITE16_BASE(_class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read16_delegate(&_class::_rhandler, "driver_data::" #_rhandler, (_class *)0), write16_delegate(&_class::_whandler, "driver_data::" #_whandler, (_class *)0), _unitmask); \ + +#define AM_READWRITE32_BASE(_class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read32_delegate(&_class::_rhandler, "driver_data::" #_rhandler, (_class *)0), write32_delegate(&_class::_whandler, "driver_data::" #_whandler, (_class *)0), _unitmask); \ + + +// driver data reads +#define AM_READ(_handler) \ + curentry->set_handler(device, DEVICE_SELF, read_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0)); \ + +#define AM_READ8(_handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read8_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \ + +#define AM_READ16(_handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read16_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \ + +#define AM_READ32(_handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read32_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \ + + +// driver data writes +#define AM_WRITE(_handler) \ + curentry->set_handler(device, DEVICE_SELF, write_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0)); \ + +#define AM_WRITE8(_handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, write8_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \ + +#define AM_WRITE16(_handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, write16_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \ + +#define AM_WRITE32(_handler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, write32_delegate(&drivdata_class::_handler, "driver_data::" #_handler, (drivdata_class *)0), _unitmask); \ + + +// driver data reads/writes +#define AM_READWRITE(_rhandler, _whandler) \ + curentry->set_handler(device, DEVICE_SELF, read_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0)); \ + +#define AM_READWRITE8(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read8_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write8_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0), _unitmask); \ + +#define AM_READWRITE16(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read16_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write16_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0), _unitmask); \ + +#define AM_READWRITE32(_rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, DEVICE_SELF, read32_delegate(&drivdata_class::_rhandler, "driver_data::" #_rhandler, (drivdata_class *)0), write32_delegate(&drivdata_class::_whandler, "driver_data::" #_whandler, (drivdata_class *)0), _unitmask); \ + + +// device reads +#define AM_DEVREAD(_tag, _class, _handler) \ + curentry->set_handler(device, _tag, read_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0)); \ + +#define AM_DEVREAD8(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, read8_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVREAD16(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, read16_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVREAD32(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, read32_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + + +// device writes +#define AM_DEVWRITE(_tag, _class, _handler) \ + curentry->set_handler(device, _tag, write_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0)); \ + +#define AM_DEVWRITE8(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, write8_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVWRITE16(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, write16_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + +#define AM_DEVWRITE32(_tag, _class, _handler, _unitmask) \ + curentry->set_handler(device, _tag, write32_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), _unitmask); \ + + +// device reads/writes +#define AM_DEVREADWRITE(_tag, _class, _rhandler, _whandler) \ + curentry->set_handler(device, _tag, read_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0)); \ + +#define AM_DEVREADWRITE8(_tag, _class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, read8_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write8_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \ + +#define AM_DEVREADWRITE16(_tag, _class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, read16_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write16_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \ + +#define AM_DEVREADWRITE32(_tag, _class, _rhandler, _whandler, _unitmask) \ + curentry->set_handler(device, _tag, read32_delegate(&_class::_rhandler, #_class "::" #_rhandler, (_class *)0), write32_delegate(&_class::_whandler, #_class "::" #_whandler, (_class *)0), _unitmask); \ + + +// device mapping +#define AM_DEVICE(_tag, _class, _handler) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 0, 0); \ + +#define AM_DEVICE8(_tag, _class, _handler, _unitmask) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 8, _unitmask); \ + +#define AM_DEVICE16(_tag, _class, _handler, _unitmask) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 16, _unitmask); \ + +#define AM_DEVICE32(_tag, _class, _handler, _unitmask) \ + curentry->set_submap(device, _tag, address_map_delegate(&_class::_handler, #_class "::" #_handler, (_class *)0), 32, _unitmask); \ + + +// special-case accesses +#define AM_ROM \ + curentry->set_read_type(AMH_ROM); \ + +#define AM_RAM \ + curentry->set_read_type(AMH_RAM); \ + curentry->set_write_type(AMH_RAM); \ + +#define AM_READONLY \ + curentry->set_read_type(AMH_RAM); \ + +#define AM_WRITEONLY \ + curentry->set_write_type(AMH_RAM); \ + +#define AM_UNMAP \ + curentry->set_read_type(AMH_UNMAP); \ + curentry->set_write_type(AMH_UNMAP); \ + +#define AM_NOP \ + curentry->set_read_type(AMH_NOP); \ + curentry->set_write_type(AMH_NOP); \ + +#define AM_READNOP \ + curentry->set_read_type(AMH_NOP); \ + +#define AM_WRITENOP \ + curentry->set_write_type(AMH_NOP); \ + + +// port accesses +#define AM_READ_PORT(_tag) \ + curentry->set_read_port(device, _tag); \ + +#define AM_WRITE_PORT(_tag) \ + curentry->set_write_port(device, _tag); \ + +#define AM_READWRITE_PORT(_tag) \ + curentry->set_readwrite_port(device, _tag); \ + + +// bank accesses +#define AM_READ_BANK(_tag) \ + curentry->set_read_bank(device, _tag); \ + +#define AM_WRITE_BANK(_tag) \ + curentry->set_write_bank(device, _tag); \ + +#define AM_READWRITE_BANK(_tag) \ + curentry->set_readwrite_bank(device, _tag); \ + + +// attributes for accesses +#define AM_REGION(_tag, _offs) \ + curentry->set_region(_tag, _offs); \ + +#define AM_SHARE(_tag) \ + curentry->set_share(_tag); \ + +#define AM_BASE_LEGACY(_base) \ + curentry->set_baseptr(_base); \ + +#define myoffsetof(_struct, _member) ((FPTR)&((_struct *)0x1000)->_member - 0x1000) +#define AM_BASE(_member) \ + curentry->set_member_baseptr(myoffsetof(drivdata_class, _member)); \ + +#define AM_BASE_GENERIC(_member) \ + curentry->set_generic_baseptr(myoffsetof(generic_pointers, _member)); \ + +#define AM_SIZE_LEGACY(_size) \ + curentry->set_sizeptr(_size); \ + +#define AM_SIZE(_struct, _member) \ + curentry->set_member_sizeptr(myoffsetof(drivdata_class, _member)); \ + +#define AM_SIZE_GENERIC(_member) \ + curentry->set_generic_sizeptr(myoffsetof(generic_pointers, _member##_size)); \ + + +// common shortcuts +#define AM_ROMBANK(_bank) AM_READ_BANK(_bank) +#define AM_RAMBANK(_bank) AM_READWRITE_BANK(_bank) +#define AM_RAM_READ(_read) AM_READ(_read) AM_WRITEONLY +#define AM_RAM_WRITE(_write) AM_READONLY AM_WRITE(_write) +#define AM_RAM_DEVREAD(_tag, _class, _read) AM_DEVREAD(_tag, _class, _read) AM_WRITEONLY +#define AM_RAM_DEVWRITE(_tag, _class, _write) AM_READONLY AM_DEVWRITE(_tag, _class, _write) + +#define AM_BASE_SIZE(_base, _size) AM_BASE_MEMBER(_base) AM_SIZE_MEMBER(_size) +#define AM_BASE_SIZE_GENERIC(_member) AM_BASE_GENERIC(_member) AM_SIZE_GENERIC(_member) + +#endif + + + +//************************************************************************** +// GLOBAL VARIABLES +//************************************************************************** + +// use this to refer to the owning device when providing a device tag +static const char DEVICE_SELF[] = ""; + +// use this to refer to the owning device's owner when providing a device tag +static const char DEVICE_SELF_OWNER[] = "^"; + + +#endif /* __ADDRMAP_H__ */ |