/********************************************************************* generic.c Generic simple machine functions. Copyright Nicola Salmoria and the MAME Team. Visit http://mamedev.org for licensing and usage restrictions. *********************************************************************/ #include "driver.h" #include "deprecat.h" #include "config.h" #include "generic.h" /*************************************************************************** GLOBAL VARIABLES ***************************************************************************/ /* These globals are only kept on a machine basis - LBO 042898 */ UINT32 dispensed_tickets; UINT32 coin_count[COIN_COUNTERS]; UINT32 coinlockedout[COIN_COUNTERS]; static UINT32 lastcoin[COIN_COUNTERS]; /* generic NVRAM */ size_t generic_nvram_size; UINT8 *generic_nvram; UINT16 *generic_nvram16; UINT32 *generic_nvram32; /* memory card status */ static int memcard_inserted; /* interrupt status */ static UINT8 interrupt_enable[MAX_CPU]; /*************************************************************************** FUNCTION PROTOTYPES ***************************************************************************/ static void counters_load(running_machine *machine, int config_type, xml_data_node *parentnode); static void counters_save(running_machine *machine, int config_type, xml_data_node *parentnode); static void interrupt_reset(running_machine *machine); /*************************************************************************** INITIALIZATION ***************************************************************************/ /*------------------------------------------------- generic_machine_init - initialize globals and register for save states -------------------------------------------------*/ void generic_machine_init(running_machine *machine) { int counternum; /* reset coin counters */ for (counternum = 0; counternum < COIN_COUNTERS; counternum++) { lastcoin[counternum] = 0; coinlockedout[counternum] = 0; } /* register coin save state */ state_save_register_item_array("coin", 0, coin_count); state_save_register_item_array("coin", 0, coinlockedout); state_save_register_item_array("coin", 0, lastcoin); /* reset NVRAM size and pointers */ generic_nvram_size = 0; generic_nvram = NULL; generic_nvram16 = NULL; generic_nvram32 = NULL; /* reset memory card info */ memcard_inserted = -1; /* register a reset callback and save state for interrupt enable */ add_reset_callback(machine, interrupt_reset); state_save_register_item_array("cpu", 0, interrupt_enable); /* register for configuration */ config_register(machine, "counters", counters_load, counters_save); /* for memory cards, request save state and an exit callback */ if (machine->config->memcard_handler != NULL) { state_save_register_global(memcard_inserted); add_exit_callback(machine, memcard_eject); } } /*************************************************************************** COIN COUNTERS ***************************************************************************/ /*------------------------------------------------- counters_load - load the state of the counters and tickets -------------------------------------------------*/ static void counters_load(running_machine *machine, int config_type, xml_data_node *parentnode) { xml_data_node *coinnode, *ticketnode; /* on init, reset the counters */ if (config_type == CONFIG_TYPE_INIT) { memset(coin_count, 0, sizeof(coin_count)); dispensed_tickets = 0; } /* only care about game-specific data */ if (config_type != CONFIG_TYPE_GAME) return; /* might not have any data */ if (!parentnode) return; /* iterate over coins nodes */ for (coinnode = xml_get_sibling(parentnode->child, "coins"); coinnode; coinnode = xml_get_sibling(coinnode->next, "coins")) { int index = xml_get_attribute_int(coinnode, "index", -1); if (index >= 0 && index < COIN_COUNTERS) coin_count[index] = xml_get_attribute_int(coinnode, "number", 0); } /* get the single tickets node */ ticketnode = xml_get_sibling(parentnode->child, "tickets"); if (ticketnode) dispensed_tickets = xml_get_attribute_int(ticketnode, "number", 0); } /*------------------------------------------------- counters_save - save the state of the counters and tickets -------------------------------------------------*/ static void counters_save(running_machine *machine, int config_type, xml_data_node *parentnode) { int i; /* only care about game-specific data */ if (config_type != CONFIG_TYPE_GAME) return; /* iterate over coin counters */ for (i = 0; i < COIN_COUNTERS; i++) if (coin_count[i] != 0) { xml_data_node *coinnode = xml_add_child(parentnode, "coins", NULL); if (coinnode) { xml_set_attribute_int(coinnode, "index", i); xml_set_attribute_int(coinnode, "number", coin_count[i]); } } /* output tickets */ if (dispensed_tickets != 0) { xml_data_node *tickets = xml_add_child(parentnode, "tickets", NULL); if (tickets) xml_set_attribute_int(tickets, "number", dispensed_tickets); } } /*------------------------------------------------- coin_counter_w - sets input for coin counter -------------------------------------------------*/ void coin_counter_w(int num,int on) { if (num >= COIN_COUNTERS) return; /* Count it only if the data has changed from 0 to non-zero */ if (on && (lastcoin[num] == 0)) { coin_count[num]++; } lastcoin[num] = on; } /*------------------------------------------------- coin_lockout_w - locks out one coin input -------------------------------------------------*/ void coin_lockout_w(int num,int on) { if (num >= COIN_COUNTERS) return; coinlockedout[num] = on; } /*------------------------------------------------- coin_lockout_global_w - locks out all the coin inputs -------------------------------------------------*/ void coin_lockout_global_w(int on) { int i; for (i = 0; i < COIN_COUNTERS; i++) { coin_lockout_w(i,on); } } /*************************************************************************** NVRAM MANAGEMENT ***************************************************************************/ /*------------------------------------------------- nvram_select - select the right pointer based on which ones are non-NULL -------------------------------------------------*/ INLINE void *nvram_select(void) { if (generic_nvram) return generic_nvram; if (generic_nvram16) return generic_nvram16; if (generic_nvram32) return generic_nvram32; fatalerror("generic nvram handler called without nvram in the memory map"); return 0; } /*------------------------------------------------- nvram_fopen - open an NVRAM file directly -------------------------------------------------*/ mame_file *nvram_fopen(running_machine *machine, UINT32 openflags) { file_error filerr; mame_file *file; astring *fname; fname = astring_assemble_2(astring_alloc(), machine->basename, ".nv"); filerr = mame_fopen(SEARCHPATH_NVRAM, astring_c(fname), openflags, &file); astring_free(fname); return (filerr == FILERR_NONE) ? file : NULL; } /*------------------------------------------------- nvram_load - load a system's NVRAM -------------------------------------------------*/ void nvram_load(running_machine *machine) { mame_file *nvram_file = NULL; device_config *device; if (machine->config->nvram_handler != NULL) { nvram_file = nvram_fopen(machine, OPEN_FLAG_READ); (*machine->config->nvram_handler)(machine, nvram_file, 0); } for (device = (device_config *)machine->config->devicelist; device != NULL; device = device->next) { if (device->nvram != NULL) { if (nvram_file == NULL) { nvram_file = nvram_fopen(machine, OPEN_FLAG_READ); } (*device->nvram)(device, nvram_file, 0); } } if (nvram_file != NULL) { mame_fclose(nvram_file); } } /*------------------------------------------------- nvram_save - save a system's NVRAM -------------------------------------------------*/ void nvram_save(running_machine *machine) { mame_file *nvram_file = NULL; device_config *device; if (machine->config->nvram_handler != NULL) { nvram_file = nvram_fopen(machine, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); (*machine->config->nvram_handler)(machine, nvram_file, 1); } for (device = (device_config *)machine->config->devicelist; device != NULL; device = device->next) { if (device->nvram != NULL) { if (nvram_file == NULL) { nvram_file = nvram_fopen(machine, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); } (*device->nvram)(device, nvram_file, 1); } } if (nvram_file != NULL) { mame_fclose(nvram_file); } } /*------------------------------------------------- NVRAM_HANDLER( generic_0fill ) - generic NVRAM with a 0 fill -------------------------------------------------*/ NVRAM_HANDLER( generic_0fill ) { if (read_or_write) mame_fwrite(file, nvram_select(), generic_nvram_size); else if (file) mame_fread(file, nvram_select(), generic_nvram_size); else memset(nvram_select(), 0, generic_nvram_size); } /*------------------------------------------------- NVRAM_HANDLER( generic_1fill ) - generic NVRAM with a 1 fill -------------------------------------------------*/ NVRAM_HANDLER( generic_1fill ) { if (read_or_write) mame_fwrite(file, nvram_select(), generic_nvram_size); else if (file) mame_fread(file, nvram_select(), generic_nvram_size); else memset(nvram_select(), 0xff, generic_nvram_size); } /*------------------------------------------------- NVRAM_HANDLER( generic_randfill ) - generic NVRAM with a random fill -------------------------------------------------*/ NVRAM_HANDLER( generic_randfill ) { int i; if (read_or_write) mame_fwrite(file, nvram_select(), generic_nvram_size); else if (file) mame_fread(file, nvram_select(), generic_nvram_size); else { UINT8 *nvram = nvram_select(); for (i = 0; i < generic_nvram_size; i++) nvram[i] = mame_rand(machine); } } /*************************************************************************** MEMORY CARD MANAGEMENT ***************************************************************************/ /*------------------------------------------------- memcard_name - determine the name of a memcard file -------------------------------------------------*/ INLINE void memcard_name(int index, char *buffer) { sprintf(buffer, "memcard.%03d", index); } /*------------------------------------------------- memcard_create - create a new memory card with the given index -------------------------------------------------*/ int memcard_create(running_machine *machine, int index, int overwrite) { file_error filerr; mame_file *file; astring *fname; char name[16]; /* create a name */ memcard_name(index, name); /* if we can't overwrite, fail if the file already exists */ fname = astring_assemble_3(astring_alloc(), machine->basename, PATH_SEPARATOR, name); if (!overwrite) { filerr = mame_fopen(SEARCHPATH_MEMCARD, astring_c(fname), OPEN_FLAG_READ, &file); if (filerr == FILERR_NONE) { mame_fclose(file); astring_free(fname); return 1; } } /* create a new file */ filerr = mame_fopen(SEARCHPATH_MEMCARD, astring_c(fname), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file); astring_free(fname); if (filerr != FILERR_NONE) return 1; /* initialize and then save the card */ if (machine->config->memcard_handler) (*machine->config->memcard_handler)(machine, file, MEMCARD_CREATE); /* close the file */ mame_fclose(file); return 0; } /*------------------------------------------------- memcard_insert - insert an existing memory card with the given index -------------------------------------------------*/ int memcard_insert(running_machine *machine, int index) { file_error filerr; mame_file *file; char name[16]; astring *fname; /* if a card is already inserted, eject it first */ if (memcard_inserted != -1) memcard_eject(machine); assert(memcard_inserted == -1); /* create a name */ memcard_name(index, name); fname = astring_assemble_3(astring_alloc(), machine->basename, PATH_SEPARATOR, name); /* open the file; if we can't, it's an error */ filerr = mame_fopen(SEARCHPATH_MEMCARD, astring_c(fname), OPEN_FLAG_READ, &file); astring_free(fname); if (filerr != FILERR_NONE) return 1; /* initialize and then load the card */ if (machine->config->memcard_handler) (*machine->config->memcard_handler)(machine, file, MEMCARD_INSERT); /* close the file */ mame_fclose(file); memcard_inserted = index; return 0; } /*------------------------------------------------- memcard_eject - eject a memory card, saving its contents along the way -------------------------------------------------*/ void memcard_eject(running_machine *machine) { file_error filerr; mame_file *file; char name[16]; astring *fname; /* if no card is preset, just ignore */ if (memcard_inserted == -1) return; /* create a name */ memcard_name(memcard_inserted, name); fname = astring_assemble_3(astring_alloc(), machine->basename, PATH_SEPARATOR, name); /* open the file; if we can't, it's an error */ filerr = mame_fopen(SEARCHPATH_MEMCARD, astring_c(fname), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file); astring_free(fname); if (filerr != FILERR_NONE) { mame_fclose(file); return; } /* initialize and then load the card */ if (machine->config->memcard_handler) (*machine->config->memcard_handler)(machine, file, MEMCARD_EJECT); /* close the file */ mame_fclose(file); memcard_inserted = -1; } /*------------------------------------------------- memcard_present - return the currently loaded card index, or -1 if none -------------------------------------------------*/ int memcard_present(void) { return memcard_inserted; } /*************************************************************************** LED CODE ***************************************************************************/ /*------------------------------------------------- set_led_status - set the state of a given LED -------------------------------------------------*/ void set_led_status(int num, int on) { output_set_led_value(num, on); } /*************************************************************************** INTERRUPT ENABLE AND VECTOR HELPERS ***************************************************************************/ /*------------------------------------------------- interrupt_reset - reset the interrupt enable states on a reset -------------------------------------------------*/ static void interrupt_reset(running_machine *machine) { int cpunum; /* on a reset, enable all interrupts */ for (cpunum = 0; cpunum < ARRAY_LENGTH(machine->cpu); cpunum++) interrupt_enable[cpunum] = 1; } /*------------------------------------------------- clear_all_lines - sets the state of all input lines and the NMI line to clear -------------------------------------------------*/ static TIMER_CALLBACK( clear_all_lines ) { int cpunum = param; int inputcount = cpu_get_input_lines(machine->cpu[cpunum]); int line; /* clear NMI and all inputs */ cpu_set_input_line(machine->cpu[cpunum], INPUT_LINE_NMI, CLEAR_LINE); for (line = 0; line < inputcount; line++) cpu_set_input_line(machine->cpu[cpunum], line, CLEAR_LINE); } /*------------------------------------------------- cpu_interrupt_enable - controls the enable/ disable value for global interrupts -------------------------------------------------*/ void cpu_interrupt_enable(int cpunum, int enabled) { assert_always(cpunum >= 0 && cpunum < ARRAY_LENGTH(Machine->cpu) && Machine->cpu[cpunum] != NULL, "cpu_interrupt_enable() called for invalid cpu num!"); /* set the new state */ interrupt_enable[cpunum] = enabled; /* make sure there are no queued interrupts */ if (enabled == 0) timer_call_after_resynch(NULL, cpunum, clear_all_lines); } /*------------------------------------------------- interrupt_enable_w - set the global interrupt enable -------------------------------------------------*/ WRITE8_HANDLER( interrupt_enable_w ) { int activecpu = cpunum_get_active(); assert_always(activecpu >= 0, "interrupt_enable_w() called with no active cpu!"); cpu_interrupt_enable(activecpu, data); } /*------------------------------------------------- interrupt_enable_r - read the global interrupt enable -------------------------------------------------*/ READ8_HANDLER( interrupt_enable_r ) { int activecpu = cpunum_get_active(); assert_always(activecpu >= 0, "interrupt_enable_r() called with no active cpu!"); return interrupt_enable[activecpu]; } /*************************************************************************** INTERRUPT GENERATION CALLBACK HELPERS ***************************************************************************/ /*------------------------------------------------- irqn_line_set - set the given IRQ line to the specified state on the active CPU -------------------------------------------------*/ INLINE void irqn_line_set(const device_config *device, int line, int state) { if (interrupt_enable[cpu_get_index(device)]) cpu_set_input_line(device, line, state); } /*------------------------------------------------- NMI callbacks -------------------------------------------------*/ INTERRUPT_GEN( nmi_line_pulse ) { irqn_line_set(device, INPUT_LINE_NMI, PULSE_LINE); } INTERRUPT_GEN( nmi_line_assert ) { irqn_line_set(device, INPUT_LINE_NMI, ASSERT_LINE); } /*------------------------------------------------- IRQn callbacks -------------------------------------------------*/ INTERRUPT_GEN( irq0_line_hold ) { irqn_line_set(device, 0, HOLD_LINE); } INTERRUPT_GEN( irq0_line_pulse ) { irqn_line_set(device, 0, PULSE_LINE); } INTERRUPT_GEN( irq0_line_assert ) { irqn_line_set(device, 0, ASSERT_LINE); } INTERRUPT_GEN( irq1_line_hold ) { irqn_line_set(device, 1, HOLD_LINE); } INTERRUPT_GEN( irq1_line_pulse ) { irqn_line_set(device, 1, PULSE_LINE); } INTERRUPT_GEN( irq1_line_assert ) { irqn_line_set(device, 1, ASSERT_LINE); } INTERRUPT_GEN( irq2_line_hold ) { irqn_line_set(device, 2, HOLD_LINE); } INTERRUPT_GEN( irq2_line_pulse ) { irqn_line_set(device, 2, PULSE_LINE); } INTERRUPT_GEN( irq2_line_assert ) { irqn_line_set(device, 2, ASSERT_LINE); } INTERRUPT_GEN( irq3_line_hold ) { irqn_line_set(device, 3, HOLD_LINE); } INTERRUPT_GEN( irq3_line_pulse ) { irqn_line_set(device, 3, PULSE_LINE); } INTERRUPT_GEN( irq3_line_assert ) { irqn_line_set(device, 3, ASSERT_LINE); } INTERRUPT_GEN( irq4_line_hold ) { irqn_line_set(device, 4, HOLD_LINE); } INTERRUPT_GEN( irq4_line_pulse ) { irqn_line_set(device, 4, PULSE_LINE); } INTERRUPT_GEN( irq4_line_assert ) { irqn_line_set(device, 4, ASSERT_LINE); } INTERRUPT_GEN( irq5_line_hold ) { irqn_line_set(device, 5, HOLD_LINE); } INTERRUPT_GEN( irq5_line_pulse ) { irqn_line_set(device, 5, PULSE_LINE); } INTERRUPT_GEN( irq5_line_assert ) { irqn_line_set(device, 5, ASSERT_LINE); } INTERRUPT_GEN( irq6_line_hold ) { irqn_line_set(device, 6, HOLD_LINE); } INTERRUPT_GEN( irq6_line_pulse ) { irqn_line_set(device, 6, PULSE_LINE); } INTERRUPT_GEN( irq6_line_assert ) { irqn_line_set(device, 6, ASSERT_LINE); } INTERRUPT_GEN( irq7_line_hold ) { irqn_line_set(device, 7, HOLD_LINE); } INTERRUPT_GEN( irq7_line_pulse ) { irqn_line_set(device, 7, PULSE_LINE); } INTERRUPT_GEN( irq7_line_assert ) { irqn_line_set(device, 7, ASSERT_LINE); } /*************************************************************************** WATCHDOG READ/WRITE HELPERS ***************************************************************************/ /*------------------------------------------------- 8-bit reset read/write handlers -------------------------------------------------*/ WRITE8_HANDLER( watchdog_reset_w ) { watchdog_reset(machine); } READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(machine); return 0xff; } /*------------------------------------------------- 16-bit reset read/write handlers -------------------------------------------------*/ WRITE16_HANDLER( watchdog_reset16_w ) { watchdog_reset(machine); } READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(machine); return 0xffff; } /*------------------------------------------------- 32-bit reset read/write handlers -------------------------------------------------*/ WRITE32_HANDLER( watchdog_reset32_w ) { watchdog_reset(machine); } READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(machine); return 0xffffffff; } /*************************************************************************** PORT READING HELPERS ***************************************************************************/ /*------------------------------------------------- input_port_read_indexed - return the value of an input port specified by index -------------------------------------------------*/ static input_port_value input_port_read_indexed(running_machine *machine, int portnum) { const input_port_config *port = input_port_by_index(machine->portconfig, portnum); return (port == NULL) ? 0 : input_port_read_direct(port); } /*------------------------------------------------- 8-bit read handlers -------------------------------------------------*/ READ8_HANDLER( input_port_0_r ) { return input_port_read_indexed(machine, 0); } READ8_HANDLER( input_port_1_r ) { return input_port_read_indexed(machine, 1); } READ8_HANDLER( input_port_2_r ) { return input_port_read_indexed(machine, 2); } READ8_HANDLER( input_port_3_r ) { return input_port_read_indexed(machine, 3); } READ8_HANDLER( input_port_4_r ) { return input_port_read_indexed(machine, 4); } READ8_HANDLER( input_port_5_r ) { return input_port_read_indexed(machine, 5); } READ8_HANDLER( input_port_6_r ) { return input_port_read_indexed(machine, 6); } READ8_HANDLER( input_port_7_r ) { return input_port_read_indexed(machine, 7); } READ8_HANDLER( input_port_8_r ) { return input_port_read_indexed(machine, 8); } READ8_HANDLER( input_port_9_r ) { return input_port_read_indexed(machine, 9); } READ8_HANDLER( input_port_10_r ) { return input_port_read_indexed(machine, 10); } READ8_HANDLER( input_port_11_r ) { return input_port_read_indexed(machine, 11); } READ8_HANDLER( input_port_12_r ) { return input_port_read_indexed(machine, 12); } READ8_HANDLER( input_port_13_r ) { return input_port_read_indexed(machine, 13); } READ8_HANDLER( input_port_14_r ) { return input_port_read_indexed(machine, 14); } READ8_HANDLER( input_port_15_r ) { return input_port_read_indexed(machine, 15); } READ8_HANDLER( input_port_16_r ) { return input_port_read_indexed(machine, 16); } READ8_HANDLER( input_port_17_r ) { return input_port_read_indexed(machine, 17); } READ8_HANDLER( input_port_18_r ) { return input_port_read_indexed(machine, 18); } READ8_HANDLER( input_port_19_r ) { return input_port_read_indexed(machine, 19); } READ8_HANDLER( input_port_20_r ) { return input_port_read_indexed(machine, 20); } READ8_HANDLER( input_port_21_r ) { return input_port_read_indexed(machine, 21); } READ8_HANDLER( input_port_22_r ) { return input_port_read_indexed(machine, 22); } READ8_HANDLER( input_port_23_r ) { return input_port_read_indexed(machine, 23); } READ8_HANDLER( input_port_24_r ) { return input_port_read_indexed(machine, 24); } READ8_HANDLER( input_port_25_r ) { return input_port_read_indexed(machine, 25); } READ8_HANDLER( input_port_26_r ) { return input_port_read_indexed(machine, 26); } READ8_HANDLER( input_port_27_r ) { return input_port_read_indexed(machine, 27); } READ8_HANDLER( input_port_28_r ) { return input_port_read_indexed(machine, 28); } READ8_HANDLER( input_port_29_r ) { return input_port_read_indexed(machine, 29); } READ8_HANDLER( input_port_30_r ) { return input_port_read_indexed(machine, 30); } READ8_HANDLER( input_port_31_r ) { return input_port_read_indexed(machine, 31); } /*------------------------------------------------- 16-bit read handlers -------------------------------------------------*/ READ16_HANDLER( input_port_0_word_r ) { return input_port_read_indexed(machine, 0); } READ16_HANDLER( input_port_1_word_r ) { return input_port_read_indexed(machine, 1); } READ16_HANDLER( input_port_2_word_r ) { return input_port_read_indexed(machine, 2); } READ16_HANDLER( input_port_3_word_r ) { return input_port_read_indexed(machine, 3); } READ16_HANDLER( input_port_4_word_r ) { return input_port_read_indexed(machine, 4); } READ16_HANDLER( input_port_5_word_r ) { return input_port_read_indexed(machine, 5); } READ16_HANDLER( input_port_6_word_r ) { return input_port_read_indexed(machine, 6); } READ16_HANDLER( input_port_7_word_r ) { return input_port_read_indexed(machine, 7); } READ16_HANDLER( input_port_8_word_r ) { return input_port_read_indexed(machine, 8); } READ16_HANDLER( input_port_9_word_r ) { return input_port_read_indexed(machine, 9); } READ16_HANDLER( input_port_10_word_r ) { return input_port_read_indexed(machine, 10); } READ16_HANDLER( input_port_11_word_r ) { return input_port_read_indexed(machine, 11); } READ16_HANDLER( input_port_12_word_r ) { return input_port_read_indexed(machine, 12); } READ16_HANDLER( input_port_13_word_r ) { return input_port_read_indexed(machine, 13); } READ16_HANDLER( input_port_14_word_r ) { return input_port_read_indexed(machine, 14); } READ16_HANDLER( input_port_15_word_r ) { return input_port_read_indexed(machine, 15); } READ16_HANDLER( input_port_16_word_r ) { return input_port_read_indexed(machine, 16); } READ16_HANDLER( input_port_17_word_r ) { return input_port_read_indexed(machine, 17); } READ16_HANDLER( input_port_18_word_r ) { return input_port_read_indexed(machine, 18); } READ16_HANDLER( input_port_19_word_r ) { return input_port_read_indexed(machine, 19); } READ16_HANDLER( input_port_20_word_r ) { return input_port_read_indexed(machine, 20); } READ16_HANDLER( input_port_21_word_r ) { return input_port_read_indexed(machine, 21); } READ16_HANDLER( input_port_22_word_r ) { return input_port_read_indexed(machine, 22); } READ16_HANDLER( input_port_23_word_r ) { return input_port_read_indexed(machine, 23); } READ16_HANDLER( input_port_24_word_r ) { return input_port_read_indexed(machine, 24); } READ16_HANDLER( input_port_25_word_r ) { return input_port_read_indexed(machine, 25); } READ16_HANDLER( input_port_26_word_r ) { return input_port_read_indexed(machine, 26); } READ16_HANDLER( input_port_27_word_r ) { return input_port_read_indexed(machine, 27); } READ16_HANDLER( input_port_28_word_r ) { return input_port_read_indexed(machine, 28); } READ16_HANDLER( input_port_29_word_r ) { return input_port_read_indexed(machine, 29); } READ16_HANDLER( input_port_30_word_r ) { return input_port_read_indexed(machine, 30); } READ16_HANDLER( input_port_31_word_r ) { return input_port_read_indexed(machine, 31); } /*------------------------------------------------- 32-bit read handlers -------------------------------------------------*/ READ32_HANDLER( input_port_0_dword_r ) { return input_port_read_indexed(machine, 0); } READ32_HANDLER( input_port_1_dword_r ) { return input_port_read_indexed(machine, 1); } READ32_HANDLER( input_port_2_dword_r ) { return input_port_read_indexed(machine, 2); } READ32_HANDLER( input_port_3_dword_r ) { return input_port_read_indexed(machine, 3); } READ32_HANDLER( input_port_4_dword_r ) { return input_port_read_indexed(machine, 4); } READ32_HANDLER( input_port_5_dword_r ) { return input_port_read_indexed(machine, 5); } READ32_HANDLER( input_port_6_dword_r ) { return input_port_read_indexed(machine, 6); } READ32_HANDLER( input_port_7_dword_r ) { return input_port_read_indexed(machine, 7); } READ32_HANDLER( input_port_8_dword_r ) { return input_port_read_indexed(machine, 8); } READ32_HANDLER( input_port_9_dword_r ) { return input_port_read_indexed(machine, 9); } READ32_HANDLER( input_port_10_dword_r ) { return input_port_read_indexed(machine, 10); } READ32_HANDLER( input_port_11_dword_r ) { return input_port_read_indexed(machine, 11); } READ32_HANDLER( input_port_12_dword_r ) { return input_port_read_indexed(machine, 12); } READ32_HANDLER( input_port_13_dword_r ) { return input_port_read_indexed(machine, 13); } READ32_HANDLER( input_port_14_dword_r ) { return input_port_read_indexed(machine, 14); } READ32_HANDLER( input_port_15_dword_r ) { return input_port_read_indexed(machine, 15); } READ32_HANDLER( input_port_16_dword_r ) { return input_port_read_indexed(machine, 16); } READ32_HANDLER( input_port_17_dword_r ) { return input_port_read_indexed(machine, 17); } READ32_HANDLER( input_port_18_dword_r ) { return input_port_read_indexed(machine, 18); } READ32_HANDLER( input_port_19_dword_r ) { return input_port_read_indexed(machine, 19); } READ32_HANDLER( input_port_20_dword_r ) { return input_port_read_indexed(machine, 20); } READ32_HANDLER( input_port_21_dword_r ) { return input_port_read_indexed(machine, 21); } READ32_HANDLER( input_port_22_dword_r ) { return input_port_read_indexed(machine, 22); } READ32_HANDLER( input_port_23_dword_r ) { return input_port_read_indexed(machine, 23); } READ32_HANDLER( input_port_24_dword_r ) { return input_port_read_indexed(machine, 24); } READ32_HANDLER( input_port_25_dword_r ) { return input_port_read_indexed(machine, 25); } READ32_HANDLER( input_port_26_dword_r ) { return input_port_read_indexed(machine, 26); } READ32_HANDLER( input_port_27_dword_r ) { return input_port_read_indexed(machine, 27); } READ32_HANDLER( input_port_28_dword_r ) { return input_port_read_indexed(machine, 28); } READ32_HANDLER( input_port_29_dword_r ) { return input_port_read_indexed(machine, 29); } READ32_HANDLER( input_port_30_dword_r ) { return input_port_read_indexed(machine, 30); } READ32_HANDLER( input_port_31_dword_r ) { return input_port_read_indexed(machine, 31); } /*------------------------------------------------- custom_port_read - act like input_port_read but it is a custom port, it is useful for e.g. input ports which expect the same port repeated both in the upper and lower half -------------------------------------------------*/ CUSTOM_INPUT( custom_port_read ) { const char *tag = param; return input_port_read(field->port->machine, tag); }