/** Return the lamp associated with a switch */
U8 switch_lookup_lamp (const switchnum_t sw)
{
U8 lamp;
const switch_info_t *swinfo = switch_lookup (sw);
lamp = swinfo->lamp;
return lamp;
}
/**
* Handle a switch that has just become stable; i.e. it changed
* and held steady for at least 2 consecutive readings. It is
* also known not to be in the heavy debounce queue already.
*
* If the switch requires a longer debounce period, then it is
* put into a queue and we wait a little while to see if it
* remains stable, then it will be scheduled.
*/
static void switch_update_stable (const U8 sw)
{
/* Queue the switch if it requires further debouncing.
* Otherwise, it is eligible for scheduling. */
if (switch_lookup (sw)->debounce != 0)
switch_queue_add (sw);
else
switch_transitioned (sw);
}
/** Add a new entry to the switch queue. */
void switch_queue_add (const switchnum_t sw)
{
if (switch_queue_top < switch_queue + MAX_QUEUED_SWITCHES)
{
dbprintf ("adding %d to queue\n", sw);
switch_queue_top->id = sw;
switch_queue_top->timer = switch_lookup(sw)->debounce;
bit_on (sw_queued, sw);
switch_queue_top++;
}
}
/**
* This task runs during a switch stress test. During a game,
* it randomly invokes switch handlers as if the switches had actually
* been activated by the pinball.
*/
void switch_stress_task (void)
{
U8 sw;
const switch_info_t *swinfo;
task_pid_t tp;
/* Delay a few seconds before starting the simulation. This allows
time for the Start Button to be used to add players, instead of simulating
endball. */
task_sleep_sec (3);
task_create_peer (switch_stress_flipper_task);
for (;;)
{
task_sleep (TIME_100MS);
if (in_test)
continue;
/* Choose a switch at random. Skip certain well-known switches that are
* never to be activated. */
sw = random_scaled (NUM_SWITCHES);
#ifdef SW_ALWAYS_CLOSED
if (sw == SW_ALWAYS_CLOSED)
continue;
#endif
#ifdef MACHINE_OUTHOLE_SWITCH
if (sw == MACHINE_OUTHOLE_SWITCH)
continue;
#endif
/* Lookup the switch properties. Skip switches which aren't normally
* activated on the playfield. For switches in a ball container,
* simulate device entry there, otherwise simulate a switch event. */
swinfo = switch_lookup (sw);
if (SW_HAS_DEVICE (swinfo))
{
device_t *dev = device_entry (SW_GET_DEVICE (swinfo));
if (trough_dev_p (dev))
{
/* Don't always trigger the trough device. The probability
of a ball drain is treated as proportional to the number of
balls in play. So in big multiballs, we allow this to happen
more frequently.
We need to do this occasionally so that multiball modes
will eventually end, else nothing else gets tested. */
if (random () < CONFIG_STRESS_DRAIN_PROB * live_balls)
switch_stress_drain ();
}
else if (dev->max_count < dev->size)
{
/* Don't throw an enter event if the device thinks
it is full: it has "locked" as many balls as it
can hold. The device code will throw a fatal if
it sees this, which should never happen with real
balls. */
dbprintf ("Sim. enter dev %d\n", dev->devno);
device_call_op (dev, enter);
task_sleep (TIME_1S);
}
}
else if (swinfo->flags & SW_PLAYFIELD)
{
/* Simulate the switch */
tp = task_create_gid (GID_SW_HANDLER, switch_sched_task);
task_set_arg (tp, sw);
}
}
}
static int find_route(ib_portid_t * from, ib_portid_t * to, int dump)
{
Node *node, fromnode, tonode, nextnode;
Port *port, fromport, toport, nextport;
Switch sw;
int maxhops = MAXHOPS;
int portnum, outport;
DEBUG("from %s", portid2str(from));
if (get_node(&fromnode, &fromport, from) < 0 ||
get_node(&tonode, &toport, to) < 0) {
IBWARN("can't reach to/from ports");
if (!force)
return -1;
if (to->lid > 0)
toport.lid = to->lid;
IBWARN("Force: look for lid %d", to->lid);
}
node = &fromnode;
port = &fromport;
portnum = port->portnum;
dump_endnode(dump, "From", node, port);
while (maxhops--) {
if (port->state != 4)
goto badport;
if (sameport(port, &toport))
break; /* found */
outport = portnum;
if (node->type == IB_NODE_SWITCH) {
DEBUG("switch node");
if ((outport = switch_lookup(&sw, from, to->lid)) < 0 ||
outport > node->numports)
goto badtbl;
if (extend_dpath(&from->drpath, outport) < 0)
goto badpath;
if (get_node(&nextnode, &nextport, from) < 0) {
IBWARN("can't reach port at %s",
portid2str(from));
return -1;
}
if (outport == 0) {
if (!sameport(&nextport, &toport))
goto badtbl;
else
break; /* found SMA port */
}
} else if ((node->type == IB_NODE_CA) ||
(node->type == IB_NODE_ROUTER)) {
int ca_src = 0;
DEBUG("ca or router node");
if (!sameport(port, &fromport)) {
IBWARN
("can't continue: reached CA or router port %"
PRIx64 ", lid %d", port->portguid,
port->lid);
return -1;
}
/* we are at CA or router "from" - go one hop back to (hopefully) a switch */
if (from->drpath.cnt > 0) {
DEBUG("ca or router node - return back 1 hop");
from->drpath.cnt--;
} else {
ca_src = 1;
if (portnum
&& extend_dpath(&from->drpath, portnum) < 0)
goto badpath;
}
if (get_node(&nextnode, &nextport, from) < 0) {
IBWARN("can't reach port at %s",
portid2str(from));
return -1;
}
/* fix port num to be seen from the CA or router side */
if (!ca_src)
nextport.portnum =
from->drpath.p[from->drpath.cnt + 1];
}
port = &nextport;
if (port->state != 4)
goto badoutport;
node = &nextnode;
portnum = port->portnum;
dump_route(dump, node, outport, port);
}
if (maxhops <= 0) {
IBWARN("no route found after %d hops", MAXHOPS);
return -1;
}
dump_endnode(dump, "To", node, port);
return 0;
badport:
IBWARN("Bad port state found: node \"%s\" port %d state %d",
clean_nodedesc(node->nodedesc), portnum, port->state);
return -1;
badoutport:
IBWARN("Bad out port state found: node \"%s\" outport %d state %d",
clean_nodedesc(node->nodedesc), outport, port->state);
return -1;
badtbl:
IBWARN
("Bad forwarding table entry found at: node \"%s\" lid entry %d is %d (top %d)",
clean_nodedesc(node->nodedesc), to->lid, outport, sw.linearFDBtop);
return -1;
badpath:
IBWARN("Direct path too long!");
return -1;
}
/*
* The entry point for processing a switch transition. It performs
* some of the common switch handling logic before calling all
* event handlers. Then it also performs some common post-processing.
* This function runs in a separate task context for each switch that
* needs to be processed.
*/
void switch_sched_task (void)
{
const U8 sw = (U8)task_get_arg ();
const switch_info_t * const swinfo = switch_lookup (sw);
/* Ignore any switch that doesn't have a processing function.
This shouldn't ever happen if things are working correctly, but it
was observed on PIC games when the PIC code is broken and reporting
bad switch returns. genmachine ensures that all defined switches
have a non-null value (null_function if nothing needs to be done) */
if (swinfo->fn == 0)
goto cleanup;
/* For test mode : this lets it see what was the last switch
* to be scheduled. Used by the Switch Edges test. */
sw_last_scheduled = sw;
log_event (SEV_INFO, MOD_SWITCH, EV_SW_SCHEDULE, sw);
/* Don't service switches marked SW_IN_GAME if we're
* not presently in a game */
if ((swinfo->flags & SW_IN_GAME) && !in_game)
goto cleanup;
/* Don't service switches not marked SW_IN_TEST, unless we're
* actually in test mode */
if (!(swinfo->flags & SW_IN_TEST) && in_test)
goto cleanup;
/* If the switch has an associated lamp, then flicker the lamp when
* the switch triggers. */
if ((swinfo->lamp != 0) && in_live_game)
{
task_pid_t tp = task_create_gid (GID_SWITCH_LAMP_PULSE,
switch_lamp_pulse);
lamp_pulse_data_t *cdata = task_init_class_data (tp, lamp_pulse_data_t);
cdata->swinfo = swinfo;
}
/* If we're in a live game and the switch declares a standard
* sound, then make it happen. */
if ((swinfo->sound != 0) && in_live_game)
sound_send (swinfo->sound);
#ifdef DEBUGGER
if (swinfo->fn != null_function && sw < 72)
{
dbprintf ("SW: ");
sprintf_far_string (names_of_switches + sw);
dbprintf1 ();
#ifdef DEBUG_SWITCH_NUMBER
dbprintf (" (%d) ", sw);
#endif
dbprintf ("\n");
}
#endif
/* If the switch declares a processing function, call it. */
if (swinfo->fn)
callset_pointer_invoke (swinfo->fn);
/* Declare this as a hardware event that affects the random number
generator. */
random_hw_event ();
/* If a switch is marked SW_PLAYFIELD and we're in a game,
* then call the global playfield switch handler and check for
* valid playfield. Also, reset the ball search timer so that
* it doesn't expire.
*/
if ((swinfo->flags & SW_PLAYFIELD) && in_game)
{
callset_invoke (any_pf_switch);
/* If valid playfield was not asserted yet, then see if this
* switch validates it. Most playfield switches do this right
* away, but for some switches, like special solenoids (jets
* or slings), which could repeatedly trigger if misaligned,
* count the activations and validate only when some number
* of different switches have triggered. Device counting
* switches are ignored here, but an 'enter' event will
* set it. */
if (!valid_playfield)
{
if (swinfo->flags & SW_NOVALID)
{
if (!SW_HAS_DEVICE (swinfo))
try_validate_playfield (sw);
}
else
set_valid_playfield ();
}
ball_search_timer_reset ();
}
cleanup:
/* If the switch is part of a device, then let the device
* subsystem process the event. Note this will always occur
* regardless of any of the above conditions checked. */
if (SW_HAS_DEVICE (swinfo))
device_sw_handler (SW_GET_DEVICE (swinfo));
task_exit ();
}
