diff options
Diffstat (limited to 'trunk/src/emu/devlegcy.h')
-rw-r--r-- | trunk/src/emu/devlegcy.h | 546 |
1 files changed, 546 insertions, 0 deletions
diff --git a/trunk/src/emu/devlegcy.h b/trunk/src/emu/devlegcy.h new file mode 100644 index 00000000000..52d685cd780 --- /dev/null +++ b/trunk/src/emu/devlegcy.h @@ -0,0 +1,546 @@ +/*************************************************************************** + + devlegcy.h + + Legacy device helpers. + +**************************************************************************** + + 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 __DEVLEGCY_H__ +#define __DEVLEGCY_H__ + +#include <stddef.h> + +//************************************************************************** +// CONSTANTS +//************************************************************************** + +#define DEVINFO_IMAGE_CREATE_OPTMAX 32 + +// state constants passed to the device_get_config_func +enum +{ + // --- the following bits of info are returned as 64-bit signed integers --- + DEVINFO_INT_FIRST = 0x00000, + + DEVINFO_INT_TOKEN_BYTES = DEVINFO_INT_FIRST, // R/O: bytes to allocate for the token + DEVINFO_INT_INLINE_CONFIG_BYTES, // R/O: bytes to allocate for the inline configuration + + DEVINFO_INT_ENDIANNESS, // R/O: either ENDIANNESS_BIG or ENDIANNESS_LITTLE + DEVINFO_INT_DATABUS_WIDTH, // R/O: data bus size for each address space (8,16,32,64) + DEVINFO_INT_DATABUS_WIDTH_0 = DEVINFO_INT_DATABUS_WIDTH + 0, + DEVINFO_INT_DATABUS_WIDTH_1 = DEVINFO_INT_DATABUS_WIDTH + 1, + DEVINFO_INT_DATABUS_WIDTH_2 = DEVINFO_INT_DATABUS_WIDTH + 2, + DEVINFO_INT_DATABUS_WIDTH_3 = DEVINFO_INT_DATABUS_WIDTH + 3, + DEVINFO_INT_DATABUS_WIDTH_LAST = DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACES - 1, + DEVINFO_INT_ADDRBUS_WIDTH, // R/O: address bus size for each address space (12-32) + DEVINFO_INT_ADDRBUS_WIDTH_0 = DEVINFO_INT_ADDRBUS_WIDTH + 0, + DEVINFO_INT_ADDRBUS_WIDTH_1 = DEVINFO_INT_ADDRBUS_WIDTH + 1, + DEVINFO_INT_ADDRBUS_WIDTH_2 = DEVINFO_INT_ADDRBUS_WIDTH + 2, + DEVINFO_INT_ADDRBUS_WIDTH_3 = DEVINFO_INT_ADDRBUS_WIDTH + 3, + DEVINFO_INT_ADDRBUS_WIDTH_LAST = DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACES - 1, + DEVINFO_INT_ADDRBUS_SHIFT, // R/O: shift applied to addresses each address space (+3 means >>3, -1 means <<1) + DEVINFO_INT_ADDRBUS_SHIFT_0 = DEVINFO_INT_ADDRBUS_SHIFT + 0, + DEVINFO_INT_ADDRBUS_SHIFT_1 = DEVINFO_INT_ADDRBUS_SHIFT + 1, + DEVINFO_INT_ADDRBUS_SHIFT_2 = DEVINFO_INT_ADDRBUS_SHIFT + 2, + DEVINFO_INT_ADDRBUS_SHIFT_3 = DEVINFO_INT_ADDRBUS_SHIFT + 3, + DEVINFO_INT_ADDRBUS_SHIFT_LAST = DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACES - 1, + + DEVINFO_INT_CLASS_SPECIFIC = 0x04000, // R/W: device-specific values start here + DEVINFO_INT_DEVICE_SPECIFIC = 0x08000, // R/W: device-specific values start here + DEVINFO_INT_LAST = 0x0ffff, + + // --- the following bits of info are returned as pointers --- + DEVINFO_PTR_FIRST = 0x10000, + + DEVINFO_PTR_ROM_REGION = DEVINFO_PTR_FIRST, // R/O: pointer to device-specific ROM region + DEVINFO_PTR_MACHINE_CONFIG, // R/O: pointer to device-specific machine config + DEVINFO_PTR_INPUT_PORTS, + + DEVINFO_PTR_INTERNAL_MEMORY_MAP, // R/O: address_map_constructor map + DEVINFO_PTR_INTERNAL_MEMORY_MAP_0 = DEVINFO_PTR_INTERNAL_MEMORY_MAP + 0, + DEVINFO_PTR_INTERNAL_MEMORY_MAP_1 = DEVINFO_PTR_INTERNAL_MEMORY_MAP + 1, + DEVINFO_PTR_INTERNAL_MEMORY_MAP_2 = DEVINFO_PTR_INTERNAL_MEMORY_MAP + 2, + DEVINFO_PTR_INTERNAL_MEMORY_MAP_3 = DEVINFO_PTR_INTERNAL_MEMORY_MAP + 3, + DEVINFO_PTR_INTERNAL_MEMORY_MAP_LAST = DEVINFO_PTR_INTERNAL_MEMORY_MAP + ADDRESS_SPACES - 1, + + DEVINFO_PTR_DEFAULT_MEMORY_MAP, // R/O: address_map_constructor map + DEVINFO_PTR_DEFAULT_MEMORY_MAP_0 = DEVINFO_PTR_DEFAULT_MEMORY_MAP + 0, + DEVINFO_PTR_DEFAULT_MEMORY_MAP_1 = DEVINFO_PTR_DEFAULT_MEMORY_MAP + 1, + DEVINFO_PTR_DEFAULT_MEMORY_MAP_2 = DEVINFO_PTR_DEFAULT_MEMORY_MAP + 2, + DEVINFO_PTR_DEFAULT_MEMORY_MAP_3 = DEVINFO_PTR_DEFAULT_MEMORY_MAP + 3, + DEVINFO_PTR_DEFAULT_MEMORY_MAP_LAST = DEVINFO_PTR_DEFAULT_MEMORY_MAP + ADDRESS_SPACES - 1, + + DEVINFO_PTR_CLASS_SPECIFIC = 0x14000, // R/W: device-specific values start here + DEVINFO_PTR_DEVICE_SPECIFIC = 0x18000, // R/W: device-specific values start here + DEVINFO_PTR_LAST = 0x1ffff, + + // --- the following bits of info are returned as pointers to functions --- + DEVINFO_FCT_FIRST = 0x20000, + + DEVINFO_FCT_START = DEVINFO_FCT_FIRST, // R/O: device_start_func + DEVINFO_FCT_STOP, // R/O: device_stop_func + DEVINFO_FCT_RESET, // R/O: device_reset_func + DEVINFO_FCT_EXECUTE, // R/O: device_execute_func + DEVINFO_FCT_NVRAM, // R/O: device_nvram_func + DEVINFO_FCT_VALIDITY_CHECK, // R/O: device_validity_check_func + + DEVINFO_FCT_CLASS_SPECIFIC = 0x24000, // R/W: device-specific values start here + DEVINFO_FCT_DEVICE_SPECIFIC = 0x28000, // R/W: device-specific values start here + DEVINFO_FCT_LAST = 0x2ffff, + + // --- the following bits of info are returned as NULL-terminated strings --- + DEVINFO_STR_FIRST = 0x30000, + + DEVINFO_STR_NAME = DEVINFO_STR_FIRST, // R/O: name of the device + DEVINFO_STR_SHORTNAME, // R/O: search path of device, used for media loading + DEVINFO_STR_FAMILY, // R/O: family of the device + DEVINFO_STR_VERSION, // R/O: version of the device + DEVINFO_STR_SOURCE_FILE, // R/O: file containing the device implementation + DEVINFO_STR_CREDITS, // R/O: credits for the device implementation + + DEVINFO_STR_CLASS_SPECIFIC = 0x34000, // R/W: device-specific values start here + DEVINFO_STR_DEVICE_SPECIFIC = 0x38000, // R/W: device-specific values start here + DEVINFO_STR_LAST = 0x3ffff, + + /* --- image device related --- */ + /* --- the following bits of info are returned as integers --- */ + DEVINFO_INT_IMAGE_FIRST = DEVINFO_INT_FIRST + 0x7000, + DEVINFO_INT_IMAGE_TYPE, + DEVINFO_INT_IMAGE_READABLE, + DEVINFO_INT_IMAGE_WRITEABLE, + DEVINFO_INT_IMAGE_CREATABLE, + DEVINFO_INT_IMAGE_MUST_BE_LOADED, + DEVINFO_INT_IMAGE_RESET_ON_LOAD, + DEVINFO_INT_IMAGE_CREATE_OPTCOUNT, + DEVINFO_INT_IMAGE_LAST = DEVINFO_INT_IMAGE_FIRST + 0x0fff, + + /* --- the following bits of info are returned as pointers --- */ + DEVINFO_PTR_IMAGE_FIRST = DEVINFO_PTR_FIRST + 0x7000, + DEVINFO_PTR_IMAGE_CREATE_OPTGUIDE, + DEVINFO_PTR_IMAGE_CREATE_OPTSPEC, + + /* --- the following bits of info are returned as pointers to functions --- */ + DEVINFO_FCT_IMAGE_FIRST = DEVINFO_FCT_FIRST + 0x7000, + DEVINFO_FCT_IMAGE_LOAD, /* R/O: device_image_load_func */ + DEVINFO_FCT_IMAGE_CREATE, /* R/O: device_image_create_func */ + DEVINFO_FCT_IMAGE_UNLOAD, /* R/O: device_image_unload_func */ + DEVINFO_FCT_IMAGE_DISPLAY, /* R/O: device_image_display_func */ + DEVINFO_FCT_IMAGE_PARTIAL_HASH, /* R/O: device_image_partialhash_func */ + DEVINFO_FCT_IMAGE_DISPLAY_INFO, /* R/O: device_image_display_info_func */ + DEVINFO_FCT_IMAGE_GET_DEVICES, /* R/O: device_image_get_devices_func */ + DEVINFO_FCT_IMAGE_SOFTLIST_LOAD, /* R/O: device_image_softlist_load_func */ + DEVINFO_FCT_IMAGE_LAST = DEVINFO_FCT_FIRST + 0x0fff, + + /* --- the following bits of info are returned as NULL-terminated strings --- */ + DEVINFO_STR_IMAGE_FIRST = DEVINFO_STR_FIRST + 0x7000, + DEVINFO_STR_IMAGE_FILE_EXTENSIONS, + DEVINFO_STR_IMAGE_INSTANCE_NAME, + DEVINFO_STR_IMAGE_BRIEF_INSTANCE_NAME, + DEVINFO_STR_IMAGE_CREATE_OPTNAME, + DEVINFO_STR_IMAGE_CREATE_OPTDESC = DEVINFO_STR_IMAGE_CREATE_OPTNAME + DEVINFO_IMAGE_CREATE_OPTMAX, + DEVINFO_STR_IMAGE_CREATE_OPTEXTS = DEVINFO_STR_IMAGE_CREATE_OPTDESC + DEVINFO_IMAGE_CREATE_OPTMAX, + DEVINFO_STR_IMAGE_INTERFACE, + DEVINFO_STR_IMAGE_LAST = DEVINFO_STR_IMAGE_FIRST + 0x0fff +}; + +//************************************************************************** +// MACROS +//************************************************************************** + +// macro for declaring the configuration and device classes of a legacy device +#define _DECLARE_LEGACY_DEVICE(name, basename, deviceclass, basedeviceclass) \ + \ +DEVICE_GET_INFO( basename ); \ + \ +class deviceclass : public basedeviceclass \ +{ \ +public: \ + deviceclass(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock); \ +}; \ + \ +extern const device_type name + +// macro for defining the implementation needed for configuration and device classes +#define _DEFINE_LEGACY_DEVICE(name, basename, deviceclass, basedeviceclass) \ + \ +deviceclass::deviceclass(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock) \ + : basedeviceclass(mconfig, type, tag, owner, clock, DEVICE_GET_INFO_NAME(basename)) \ +{ \ +} \ + \ +const device_type name = &legacy_device_creator<deviceclass> + +// this template function creates a stub which constructs a device +template<class _DeviceClass> +device_t *legacy_device_creator(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) +{ + return global_alloc(_DeviceClass(mconfig, &legacy_device_creator<_DeviceClass>, tag, owner, clock)); +} + + +// reduced macros that are easier to use, and map to the above two macros +#define DECLARE_LEGACY_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_device_base) +#define DECLARE_LEGACY_SOUND_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_sound_device_base) +#define DECLARE_LEGACY_MEMORY_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_memory_device_base) +#define DECLARE_LEGACY_NVRAM_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_nvram_device_base) +#define DECLARE_LEGACY_IMAGE_DEVICE(name, basename) _DECLARE_LEGACY_DEVICE(name, basename, basename##_device, legacy_image_device_base) + +#define DEFINE_LEGACY_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_device_base) +#define DEFINE_LEGACY_SOUND_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_sound_device_base) +#define DEFINE_LEGACY_MEMORY_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_memory_device_base) +#define DEFINE_LEGACY_NVRAM_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_nvram_device_base) +#define DEFINE_LEGACY_IMAGE_DEVICE(name, basename) _DEFINE_LEGACY_DEVICE(name, basename, basename##_device, legacy_image_device_base) + + +// macros to wrap legacy device functions +#define DEVICE_GET_INFO_NAME(name) device_get_config_##name +#define DEVICE_GET_INFO(name) void DEVICE_GET_INFO_NAME(name)(const device_t *device, UINT32 state, deviceinfo *info) +#define DEVICE_GET_INFO_CALL(name) DEVICE_GET_INFO_NAME(name)(device, state, info) + +#define DEVICE_VALIDITY_CHECK_NAME(name) device_validity_check_##name +#define DEVICE_VALIDITY_CHECK(name) int DEVICE_VALIDITY_CHECK_NAME(name)(const game_driver *driver, const device_t *device, emu_options &options) +#define DEVICE_VALIDITY_CHECK_CALL(name) DEVICE_VALIDITY_CHECK_NAME(name)(driver, device) + +#define DEVICE_START_NAME(name) device_start_##name +#define DEVICE_START(name) void DEVICE_START_NAME(name)(device_t *device) +#define DEVICE_START_CALL(name) DEVICE_START_NAME(name)(device) + +#define DEVICE_STOP_NAME(name) device_stop_##name +#define DEVICE_STOP(name) void DEVICE_STOP_NAME(name)(device_t *device) +#define DEVICE_STOP_CALL(name) DEVICE_STOP_NAME(name)(device) + +#define DEVICE_RESET_NAME(name) device_reset_##name +#define DEVICE_RESET(name) void DEVICE_RESET_NAME(name)(device_t *device) +#define DEVICE_RESET_CALL(name) DEVICE_RESET_NAME(name)(device) + +#define DEVICE_EXECUTE_NAME(name) device_execute_##name +#define DEVICE_EXECUTE(name) INT32 DEVICE_EXECUTE_NAME(name)(device_t *device, INT32 clocks) +#define DEVICE_EXECUTE_CALL(name) DEVICE_EXECUTE_NAME(name)(device, clocks) + +#define DEVICE_NVRAM_NAME(name) device_nvram_##name +#define DEVICE_NVRAM(name) void DEVICE_NVRAM_NAME(name)(device_t *device, emu_file *file, int read_or_write) +#define DEVICE_NVRAM_CALL(name) DEVICE_NVRAM_NAME(name)(device, file, read_or_write) + + + +//************************************************************************** +// DEVICE_CONFIGURATION_MACROS +//************************************************************************** + +#define structsizeof(_struct, _field) sizeof(((_struct *)NULL)->_field) + +// inline device configurations that require 32 bits of storage in the token +#define MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(_size, _offset, _val) \ + legacy_device_base::static_set_inline32(*device, _offset, _size, (UINT32)(_val)); + +#define MCFG_DEVICE_CONFIG_DATA32(_struct, _field, _val) \ + MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(structsizeof(_struct, _field), offsetof(_struct, _field), _val) + +#define MCFG_DEVICE_CONFIG_DATA32_ARRAY(_struct, _field, _index, _val) \ + MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(structsizeof(_struct, _field[0]), offsetof(_struct, _field) + (_index) * structsizeof(_struct, _field[0]), _val) + +#define MCFG_DEVICE_CONFIG_DATA32_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) \ + MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(structsizeof(_memstruct, _member), offsetof(_struct, _field) + (_index) * structsizeof(_struct, _field[0]) + offsetof(_memstruct, _member), _val) + +#define MCFG_NEW_DEVICE_CONFIG_DATA32(_struct, _field, _val) \ + MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(DEVCONFIG_SIZEOF(_struct, _field), DEVCONFIG_OFFSETOF(_struct, _field), _val) + +#define MCFG_NEW_DEVICE_CONFIG_DATA32_ARRAY(_struct, _field, _index, _val) \ + MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(DEVCONFIG_SIZEOF(_struct, _field[0]), DEVCONFIG_OFFSETOF(_struct, _field) + (_index) * DEVCONFIG_SIZEOF(_struct, _field[0]), _val) + +#define MCFG_NEW_DEVICE_CONFIG_DATA32_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) \ + MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(DEVCONFIG_SIZEOF(_memstruct, _member), DEVCONFIG_OFFSETOF(_struct, _field) + (_index) * DEVCONFIG_SIZEOF(_struct, _field[0]) + DEVCONFIG_OFFSETOF(_memstruct, _member), _val) + + +// inline device configurations that require 32 bits of fixed-point storage in the token +#define MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(_size, _offset, _val, _fixbits) \ + legacy_device_base::static_set_inline_float(*device, _offset, _size, (float)(_val)); + +#define MCFG_DEVICE_CONFIG_DATAFP32(_struct, _field, _val, _fixbits) \ + MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(structsizeof(_struct, _field), offsetof(_struct, _field), _val, _fixbits) + +#define MCFG_DEVICE_CONFIG_DATAFP32_ARRAY(_struct, _field, _index, _val, _fixbits) \ + MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(structsizeof(_struct, _field[0]), offsetof(_struct, _field) + (_index) * structsizeof(_struct, _field[0]), _val, _fixbits) + +#define MCFG_DEVICE_CONFIG_DATAFP32_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val, _fixbits) \ + MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(structsizeof(_memstruct, _member), offsetof(_struct, _field) + (_index) * structsizeof(_struct, _field[0]) + offsetof(_memstruct, _member), _val, _fixbits) + +#define MCFG_DEVICE_NEW_CONFIG_DATAFP32(_struct, _field, _val, _fixbits) \ + MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(DEVCONFIG_SIZEOF(_struct, _field), DEVCONFIG_OFFSETOF(_struct, _field), _val, _fixbits) + +#define MCFG_DEVICE_NEW_CONFIG_DATAFP32_ARRAY(_struct, _field, _index, _val, _fixbits) \ + MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(DEVCONFIG_SIZEOF(_struct, _field[0]), DEVCONFIG_OFFSETOF(_struct, _field) + (_index) * DEVCONFIG_SIZEOF(_struct, _field[0]), _val, _fixbits) + +#define MCFG_DEVICE_NEW_CONFIG_DATAFP32_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val, _fixbits) \ + MCFG_DEVICE_CONFIG_DATAFP32_EXPLICIT(DEVCONFIG_SIZEOF(_memstruct, _member), DEVCONFIG_OFFSETOF(_struct, _field) + (_index) * DEVCONFIG_SIZEOF(_struct, _field[0]) + DEVCONFIG_OFFSETOF(_memstruct, _member), _val, _fixbits) + + +// inline device configurations that require 64 bits of storage in the token +#define MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(_size, _offset, _val) \ + legacy_device_base::static_set_inline64(*device, _offset, _size, (UINT64)(_val)); + +#define MCFG_DEVICE_CONFIG_DATA64(_struct, _field, _val) \ + MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(structsizeof(_struct, _field), offsetof(_struct, _field), _val) + +#define MCFG_DEVICE_CONFIG_DATA64_ARRAY(_struct, _field, _index, _val) \ + MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(structsizeof(_struct, _field[0]), offsetof(_struct, _field) + (_index) * structsizeof(_struct, _field[0]), _val) + +#define MCFG_DEVICE_CONFIG_DATA64_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) \ + MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(structsizeof(_memstruct, _member), offsetof(_struct, _field) + (_index) * structsizeof(_struct, _field[0]) + offsetof(_memstruct, _member), _val) + +#define MCFG_DEVICE_NEW_CONFIG_DATA64(_struct, _field, _val) \ + MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(DEVCONFIG_SIZEOF(_struct, _field), DEVCONFIG_OFFSETOF(_struct, _field), _val) + +#define MCFG_DEVICE_NEW_CONFIG_DATA64_ARRAY(_struct, _field, _index, _val) \ + MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(DEVCONFIG_SIZEOF(_struct, _field[0]), DEVCONFIG_OFFSETOF(_struct, _field) + (_index) * DEVCONFIG_SIZEOF(_struct, _field[0]), _val) + +#define MCFG_DEVICE_NEW_CONFIG_DATA64_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) \ + MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(DEVCONFIG_SIZEOF(_memstruct, _member), DEVCONFIG_OFFSETOF(_struct, _field) + (_index) * DEVCONFIG_SIZEOF(_struct, _field[0]) + DEVCONFIG_OFFSETOF(_memstruct, _member), _val) + + +// inline device configurations that require a pointer-sized amount of storage in the token +#ifdef PTR64 +#define MCFG_DEVICE_CONFIG_DATAPTR_EXPLICIT(_struct, _size, _offset) MCFG_DEVICE_CONFIG_DATA64_EXPLICIT(_struct, _size, _offset) +#define MCFG_DEVICE_CONFIG_DATAPTR(_struct, _field, _val) MCFG_DEVICE_CONFIG_DATA64(_struct, _field, _val) +#define MCFG_DEVICE_CONFIG_DATAPTR_ARRAY(_struct, _field, _index, _val) MCFG_DEVICE_CONFIG_DATA64_ARRAY(_struct, _field, _index, _val) +#define MCFG_DEVICE_CONFIG_DATAPTR_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) MCFG_DEVICE_CONFIG_DATA64_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) +#define MCFG_DEVICE_NEW_CONFIG_DATAPTR(_struct, _field, _val) MCFG_DEVICE_NEW_CONFIG_DATA64(_struct, _field, _val) +#define MCFG_DEVICE_NEW_CONFIG_DATAPTR_ARRAY(_struct, _field, _index, _val) MCFG_DEVICE_NEW_CONFIG_DATA64_ARRAY(_struct, _field, _index, _val) +#define MCFG_DEVICE_NEW_CONFIG_DATAPTR_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) MCFG_DEVICE_NEW_CONFIG_DATA64_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) +#else +#define MCFG_DEVICE_CONFIG_DATAPTR_EXPLICIT(_struct, _size, _offset) MCFG_DEVICE_CONFIG_DATA32_EXPLICIT(_struct, _size, _offset) +#define MCFG_DEVICE_CONFIG_DATAPTR(_struct, _field, _val) MCFG_DEVICE_CONFIG_DATA32(_struct, _field, _val) +#define MCFG_DEVICE_CONFIG_DATAPTR_ARRAY(_struct, _field, _index, _val) MCFG_DEVICE_CONFIG_DATA32_ARRAY(_struct, _field, _index, _val) +#define MCFG_DEVICE_CONFIG_DATAPTR_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) MCFG_DEVICE_CONFIG_DATA32_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) +#define MCFG_DEVICE_CONFIG_NEW_DATAPTR(_struct, _field, _val) MCFG_DEVICE_NEW_CONFIG_DATA32(_struct, _field, _val) +#define MCFG_DEVICE_CONFIG_NEW_DATAPTR_ARRAY(_struct, _field, _index, _val) MCFG_DEVICE_NEW_CONFIG_DATA32_ARRAY(_struct, _field, _index, _val) +#define MCFG_DEVICE_CONFIG_NEW_DATAPTR_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) MCFG_DEVICE_NEW_CONFIG_DATA32_ARRAY_MEMBER(_struct, _field, _index, _memstruct, _member, _val) +#endif + + + +//************************************************************************** +// TYPE DEFINITIONS +//************************************************************************** + +union deviceinfo; +class machine_config; +class device_t; + +char *get_temp_string_buffer(void); +resource_pool &machine_get_pool(running_machine &machine); + + +// device interface function types +typedef void (*device_get_config_func)(const device_t *device, UINT32 state, deviceinfo *info); +typedef int (*device_validity_check_func)(const game_driver *driver, const device_t *device, emu_options &options); + +typedef void (*device_start_func)(device_t *device); +typedef void (*device_stop_func)(device_t *device); +typedef INT32 (*device_execute_func)(device_t *device, INT32 clocks); +typedef void (*device_reset_func)(device_t *device); +typedef void (*device_nvram_func)(device_t *device, emu_file *file, int read_or_write); + +// the actual deviceinfo union +union deviceinfo +{ + INT64 i; // generic integers + void * p; // generic pointers + genf * f; // generic function pointers + char * s; // generic strings + + device_start_func start; // DEVINFO_FCT_START + device_stop_func stop; // DEVINFO_FCT_STOP + device_reset_func reset; // DEVINFO_FCT_RESET + device_execute_func execute; // DEVINFO_FCT_EXECUTE + device_nvram_func nvram; // DEVINFO_FCT_NVRAM + const rom_entry * romregion; // DEVINFO_PTR_ROM_REGION + machine_config_constructor machine_config; // DEVINFO_PTR_MACHINE_CONFIG + ioport_constructor ipt; // DEVINFO_PTR_INPUT_PORTS + address_map_constructor internal_map8; // DEVINFO_PTR_INTERNAL_MEMORY_MAP + address_map_constructor internal_map16; // DEVINFO_PTR_INTERNAL_MEMORY_MAP + address_map_constructor internal_map32; // DEVINFO_PTR_INTERNAL_MEMORY_MAP + address_map_constructor internal_map64; // DEVINFO_PTR_INTERNAL_MEMORY_MAP + address_map_constructor default_map8; // DEVINFO_PTR_DEFAULT_MEMORY_MAP + address_map_constructor default_map16; // DEVINFO_PTR_DEFAULT_MEMORY_MAP + address_map_constructor default_map32; // DEVINFO_PTR_DEFAULT_MEMORY_MAP + address_map_constructor default_map64; // DEVINFO_PTR_DEFAULT_MEMORY_MAP +}; + + +// ======================> legacy_device_base + +// legacy_device_base serves as a common base class for legacy devices +class legacy_device_base : public device_t +{ +protected: + // construction/destruction + legacy_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, device_get_config_func get_config); + virtual ~legacy_device_base(); + +public: + // access to legacy inline configuartion + void *inline_config() const { return m_inline_config; } + + // inline configuration helpers + static void static_set_inline32(device_t &device, UINT32 offset, UINT32 size, UINT32 value); + static void static_set_inline64(device_t &device, UINT32 offset, UINT32 size, UINT64 value); + static void static_set_inline_float(device_t &device, UINT32 offset, UINT32 size, float value); + + // access to legacy token + void *token() const { assert(m_token != NULL); return m_token; } + +protected: + // device-level overrides + virtual const rom_entry *device_rom_region() const { return reinterpret_cast<const rom_entry *>(get_legacy_ptr(DEVINFO_PTR_ROM_REGION)); } + virtual machine_config_constructor device_mconfig_additions() const { return reinterpret_cast<machine_config_constructor>(get_legacy_ptr(DEVINFO_PTR_MACHINE_CONFIG)); } + virtual ioport_constructor device_input_ports() const { return reinterpret_cast<ioport_constructor>(get_legacy_ptr(DEVINFO_PTR_INPUT_PORTS)); } + virtual bool device_validity_check(emu_options &options, const game_driver &driver) const; + virtual void device_start(); + virtual void device_reset(); + virtual void device_stop(); + + // access to legacy configuration info + INT64 get_legacy_int(UINT32 state) const; + void *get_legacy_ptr(UINT32 state) const; + genf *get_legacy_fct(UINT32 state) const; + const char *get_legacy_string(UINT32 state) const; + + // configuration state + device_get_config_func m_get_config_func; + void * m_inline_config; + + // internal state + void * m_token; +}; + + + +// ======================> legacy_sound_device_base + +// legacy_sound_device is a legacy_device_base with a sound interface +class legacy_sound_device_base : public legacy_device_base, + public device_sound_interface +{ +protected: + // construction/destruction + legacy_sound_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, device_get_config_func get_config); + + // sound stream update overrides + virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples); +}; + + + +// ======================> legacy_memory_device_base + +// legacy_memory_device is a legacy_device_base with a memory interface +class legacy_memory_device_base : public legacy_device_base, + public device_memory_interface +{ +protected: + // construction/destruction + legacy_memory_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, device_get_config_func get_config); + + // device overrides + virtual void device_config_complete(); + + // device_memory_interface overrides + virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == 0) ? &m_space_config : NULL; } + + // internal state + address_space_config m_space_config; +}; + + + +// ======================> legacy_nvram_device + +// legacy_nvram_device is a legacy_device_base with a nvram interface +class legacy_nvram_device_base : public legacy_device_base, + public device_nvram_interface +{ +protected: + // construction/destruction + legacy_nvram_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, device_get_config_func get_config); + + // device_nvram_interface overrides + virtual void nvram_default(); + virtual void nvram_read(emu_file &file); + virtual void nvram_write(emu_file &file); +}; + + + +// ======================> legacy_image_device + +// legacy_image_device is a legacy_device_base with a image interface +class legacy_image_device_base : public legacy_device_base, + public device_image_interface +{ +public: + virtual bool call_load(); + virtual bool call_softlist_load(char *swlist, char *swname, rom_entry *start_entry); + virtual bool call_create(int format_type, option_resolution *format_options); + virtual void call_unload(); + virtual void call_display(); + virtual void call_display_info(); + virtual device_image_partialhash_func get_partial_hash() const; + virtual void call_get_devices(); + virtual void *get_device_specific_call(); + + virtual iodevice_t image_type() const { return static_cast<iodevice_t>(get_legacy_int(DEVINFO_INT_IMAGE_TYPE)); } + + virtual bool is_readable() const { return get_legacy_int(DEVINFO_INT_IMAGE_READABLE)!=0; } + virtual bool is_writeable() const { return get_legacy_int(DEVINFO_INT_IMAGE_WRITEABLE)!=0; } + virtual bool is_creatable() const { return get_legacy_int(DEVINFO_INT_IMAGE_CREATABLE)!=0; } + virtual bool must_be_loaded() const { return get_legacy_int(DEVINFO_INT_IMAGE_MUST_BE_LOADED)!=0; } + virtual bool is_reset_on_load() const { return get_legacy_int(DEVINFO_INT_IMAGE_RESET_ON_LOAD)!=0; } + virtual const char *image_interface() const { return get_legacy_string(DEVINFO_STR_IMAGE_INTERFACE); } + virtual const char *file_extensions() const { return get_legacy_string(DEVINFO_STR_IMAGE_FILE_EXTENSIONS); } + virtual const option_guide *create_option_guide() const { return reinterpret_cast<const option_guide *>(get_legacy_ptr(DEVINFO_PTR_IMAGE_CREATE_OPTGUIDE)); } +protected: + // device overrides + virtual void device_config_complete(); + + // construction/destruction + legacy_image_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, device_get_config_func get_config); + ~legacy_image_device_base(); +}; + + +#endif /* __DEVLEGCY_H__ */ |