static void handle_eoi(running_machine &machine,int data) { compis_state *state = machine.driver_data<compis_state>(); int i, j; /* specific case */ if (!(data & 0x8000)) { /* turn off the appropriate in-service bit */ switch (data & 0x1f) { case 0x08: state->m_i186.intr.in_service &= ~0x01; break; case 0x12: state->m_i186.intr.in_service &= ~0x01; break; case 0x13: state->m_i186.intr.in_service &= ~0x01; break; case 0x0a: state->m_i186.intr.in_service &= ~0x04; break; case 0x0b: state->m_i186.intr.in_service &= ~0x08; break; case 0x0c: state->m_i186.intr.in_service &= ~0x10; break; case 0x0d: state->m_i186.intr.in_service &= ~0x20; break; case 0x0e: state->m_i186.intr.in_service &= ~0x40; break; case 0x0f: state->m_i186.intr.in_service &= ~0x80; break; default: logerror("%05X:ERROR - 80186 EOI with unknown vector %02X\n", cpu_get_pc(machine.device("maincpu")), data & 0x1f); } if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for vector %02X\n", machine.time().as_double(), data & 0x1f); } /* non-specific case */ else { /* loop over priorities */ for (i = 0; i <= 7; i++) { /* check for in-service timers */ if ((state->m_i186.intr.timer & 7) == i && (state->m_i186.intr.in_service & 0x01)) { state->m_i186.intr.in_service &= ~0x01; if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for timer\n", machine.time().as_double()); return; } /* check for in-service DMA interrupts */ for (j = 0; j < 2; j++) if ((state->m_i186.intr.dma[j] & 7) == i && (state->m_i186.intr.in_service & (0x04 << j))) { state->m_i186.intr.in_service &= ~(0x04 << j); if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for DMA%d\n", machine.time().as_double(), j); return; } /* check external interrupts */ for (j = 0; j < 4; j++) if ((state->m_i186.intr.ext[j] & 7) == i && (state->m_i186.intr.in_service & (0x10 << j))) { state->m_i186.intr.in_service &= ~(0x10 << j); if (LOG_INTERRUPTS) logerror("(%f) **** Got EOI for INT%d\n", machine.time().as_double(), j); return; } } } }
static void command_end(running_machine &machine) { /* at the end of our test */ state = STATE_DONE; final_time = machine.time(); machine.schedule_exit(); }
static void ssystem3_playfield_write(running_machine &machine, int reset, int signal) { ssystem3_state *state = machine.driver_data<ssystem3_state>(); int d=FALSE; if (!reset) { state->m_playfield.count=0; state->m_playfield.bit=0; state->m_playfield.started=FALSE; state->m_playfield.signal=signal; state->m_playfield.time=machine.time(); } if (!signal && state->m_playfield.signal) { attotime t=machine.time(); state->m_playfield.high_time=t - state->m_playfield.time; state->m_playfield.time=t; // logerror("%.4x playfield %d lowtime %s hightime %s\n",(int)activecpu_get_pc(), state->m_playfield.count, // state->m_playfield.low_time.as_string(7), state->m_playfield.high_time.as_string(7) ); if (state->m_playfield.started) { // 0 twice as long low // 1 twice as long high if (state->m_playfield.low_time > state->m_playfield.high_time) d=TRUE; state->m_playfield.data&=~(1<<(state->m_playfield.bit^7)); if (d) state->m_playfield.data|=1<<(state->m_playfield.bit^7); state->m_playfield.bit++; if (state->m_playfield.bit==8) { logerror("%.4x playfield wrote %d %02x\n", (int)cpu_get_pc(machine.device("maincpu")), state->m_playfield.count, state->m_playfield.data); state->m_playfield.u.data[state->m_playfield.count]=state->m_playfield.data; state->m_playfield.bit=0; state->m_playfield.count=(state->m_playfield.count+1)%ARRAY_LENGTH(state->m_playfield.u.data); if (state->m_playfield.count==0) state->m_playfield.started=FALSE; } } } else if (signal && !state->m_playfield.signal) { attotime t=machine.time(); state->m_playfield.low_time= t - state->m_playfield.time; state->m_playfield.time=t; state->m_playfield.started=TRUE; } state->m_playfield.signal=signal; }
static UINT8 read_port_and_t0( running_machine &machine, int port ) { hitme_state *state = machine.driver_data<hitme_state>(); static const char *const portnames[] = { "IN0", "IN1", "IN2", "IN3" }; UINT8 val = machine.root_device().ioport(portnames[port])->read(); if (machine.time() > state->m_timeout_time) val ^= 0x80; return val; }
static void update_plunger( running_machine &machine ) { mgolf_state *state = machine.driver_data<mgolf_state>(); UINT8 val = state->ioport("BUTTON")->read(); if (state->m_prev != val) { if (val == 0) { state->m_time_released = machine.time(); if (!state->m_mask) state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE); } else state->m_time_pushed = machine.time(); state->m_prev = val; } }
static void update_plunger(running_machine &machine) { videopin_state *state = machine.driver_data<videopin_state>(); UINT8 val = input_port_read(machine, "IN2"); if (state->m_prev != val) { if (val == 0) { state->m_time_released = machine.time(); if (!state->m_mask) cputag_set_input_line(machine, "maincpu", INPUT_LINE_NMI, ASSERT_LINE); } else state->m_time_pushed = machine.time(); state->m_prev = val; } }
static void command_rawinput(running_machine &machine) { //int parts; attotime current_time = machine.time(); static const char *position; #if 0 int i; double rate = attotime::from_seconds(1); const char *s; char buf[256]; #endif if (state == STATE_READY) { /* beginning of a raw input command */ //parts = 1; position = current_command->u.input_args.input_chars; wait_target = current_time; state = STATE_INCOMMAND; } else if (current_time > wait_target) { #if 0 do { /* process the next command */ while(!isspace(*position)) position++; /* look up the input to trigger */ for (i = 0; input_keywords[i].name; i++) { if (!strncmp(position, input_keywords[i].name, strlen(input_keywords[i].name))) break; } /* go to next command */ position = strchr(position, ','); if (position) position++; } while(position && !input_keywords[i].name); current_fake_input = input_keywords[i].name ? &input_keywords[i] : NULL; if (position) wait_target = current_time + rate; else state = STATE_READY; #endif } }
static void command_wait(running_machine &machine) { attotime current_time = machine.time(); if (state == STATE_READY) { /* beginning a wait command */ wait_target = current_time + attotime::from_msec(current_command->u.wait_time); state = STATE_INCOMMAND; } else { /* during a wait command */ state = (current_time >= wait_target) ? STATE_READY : STATE_INCOMMAND; } }
static double calc_plunger_pos(running_machine &machine) { mgolf_state *state = machine.driver_data<mgolf_state>(); return (machine.time().as_double() - state->m_time_released.as_double()) * (state->m_time_released.as_double() - state->m_time_pushed.as_double() + 0.2); }
void osd_update(running_machine &machine, int skip_redraw) { int i; attotime time_limit; attotime current_time; target->get_primitives(); /* don't do anything if we are initializing! */ switch(machine.phase()) { case MACHINE_PHASE_PREINIT: case MACHINE_PHASE_INIT: case MACHINE_PHASE_RESET: return; default: break; } /* if we have already aborted or completed, our work is done */ if ((state == STATE_ABORTED) || (state == STATE_DONE)) { machine.schedule_exit(); return; } /* have we hit the time limit? */ current_time = machine.time(); time_limit = (current_testcase.time_limit != attotime::zero) ? current_testcase.time_limit : attotime::from_seconds(600); if (current_time > time_limit) { state = STATE_ABORTED; report_message(MSG_FAILURE, "Time limit of %s attoseconds exceeded", time_limit.as_string(9)); return; } for (i = 0; i < ARRAY_LENGTH(commands); i++) { if (current_command->command_type == commands[i].command_type) { commands[i].proc(machine); break; } } /* if we are ready for the next command, advance to it */ if (state == STATE_READY) { /* if we are at the end, and we are dumping screenshots, and we didn't * just dump a screenshot, dump one now */ if ((test_flags & MESSTEST_ALWAYS_DUMP_SCREENSHOT) && (current_command[0].command_type != MESSTEST_COMMAND_SCREENSHOT) && (current_command[1].command_type == MESSTEST_COMMAND_END)) { dump_screenshot(machine, TRUE); } current_command++; } }
static void update_interrupt_state(running_machine &machine) { compis_state *state = machine.driver_data<compis_state>(); int i, j, new_vector = 0; if (LOG_INTERRUPTS) logerror("update_interrupt_status: req=%02X stat=%02X serv=%02X\n", state->m_i186.intr.request, state->m_i186.intr.status, state->m_i186.intr.in_service); /* loop over priorities */ for (i = 0; i <= state->m_i186.intr.priority_mask; i++) { /* note: by checking 4 bits, we also verify that the mask is off */ if ((state->m_i186.intr.timer & 15) == i) { /* if we're already servicing something at this level, don't generate anything new */ if (state->m_i186.intr.in_service & 0x01) return; /* if there's something pending, generate an interrupt */ if (state->m_i186.intr.status & 0x07) { if (state->m_i186.intr.status & 1) new_vector = 0x08; else if (state->m_i186.intr.status & 2) new_vector = 0x12; else if (state->m_i186.intr.status & 4) new_vector = 0x13; else popmessage("Invalid timer interrupt!"); /* set the clear mask and generate the int */ state->m_i186.intr.ack_mask = 0x0001; goto generate_int; } } /* check DMA interrupts */ for (j = 0; j < 2; j++) if ((state->m_i186.intr.dma[j] & 15) == i) { /* if we're already servicing something at this level, don't generate anything new */ if (state->m_i186.intr.in_service & (0x04 << j)) return; /* if there's something pending, generate an interrupt */ if (state->m_i186.intr.request & (0x04 << j)) { new_vector = 0x0a + j; /* set the clear mask and generate the int */ state->m_i186.intr.ack_mask = 0x0004 << j; goto generate_int; } } /* check external interrupts */ for (j = 0; j < 4; j++) if ((state->m_i186.intr.ext[j] & 15) == i) { /* if we're already servicing something at this level, don't generate anything new */ if (state->m_i186.intr.in_service & (0x10 << j)) return; /* if there's something pending, generate an interrupt */ if (state->m_i186.intr.request & (0x10 << j)) { /* otherwise, generate an interrupt for this request */ new_vector = 0x0c + j; /* set the clear mask and generate the int */ state->m_i186.intr.ack_mask = 0x0010 << j; goto generate_int; } } } return; generate_int: /* generate the appropriate interrupt */ state->m_i186.intr.poll_status = 0x8000 | new_vector; if (!state->m_i186.intr.pending) cputag_set_input_line(machine, "maincpu", 0, ASSERT_LINE); state->m_i186.intr.pending = 1; machine.scheduler().trigger(CPU_RESUME_TRIGGER); if (LOG_OPTIMIZATION) logerror(" - trigger due to interrupt pending\n"); if (LOG_INTERRUPTS) logerror("(%f) **** Requesting interrupt vector %02X\n", machine.time().as_double(), new_vector); }