+void tap_set_state_impl( tap_state_t new_state )
+{
+ /* this is the state we think the TAPs are in now, was cur_state */
+ state_follower = new_state;
+}
+
+tap_state_t tap_get_state()
+{
+ return state_follower;
+}
+
+/**
+ * @see tap_set_end_state() and tap_get_end_state() accessors.
+ * Actual name is not important because accessors hide it.
+ */
+static tap_state_t end_state_follower = TAP_RESET;
+
+void tap_set_end_state( tap_state_t new_end_state )
+{
+ /* this is the state we think the TAPs will be in at completion of the
+ current TAP operation, was end_state
+ */
+ end_state_follower = new_end_state;
+}
+
+tap_state_t tap_get_end_state()
+{
+ return end_state_follower;
+}
+
+
+int tap_move_ndx( tap_state_t astate )
+{
+ /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
+
+ /* old version
+ const static int move_map[16] =
+ {
+ 0, -1, -1, 2, -1, 3, -1, -1,
+ 1, -1, -1, 4, -1, 5, -1, -1
+ };
+ */
+
+ int ndx;
+
+ switch( astate )
+ {
+ case TAP_RESET: ndx = 0; break;
+ case TAP_DRSHIFT: ndx = 2; break;
+ case TAP_DRPAUSE: ndx = 3; break;
+ case TAP_IDLE: ndx = 1; break;
+ case TAP_IRSHIFT: ndx = 4; break;
+ case TAP_IRPAUSE: ndx = 5; break;
+ default:
+ LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
+ exit(1);
+ }
+
+ return ndx;
+}
+
+int tap_get_tms_path( tap_state_t from, tap_state_t to )
+{
+ /* tap_move[i][j]: tap movement command to go from state i to state j
+ * 0: Test-Logic-Reset
+ * 1: Run-Test/Idle
+ * 2: Shift-DR
+ * 3: Pause-DR
+ * 4: Shift-IR
+ * 5: Pause-IR
+ *
+ * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
+ */
+ static const u8 tms_seqs[6][6] =
+ {
+ /* value clocked to TMS to move from one of six stable states to another */
+
+ /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
+ { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
+ { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
+ { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
+ { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
+ { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
+ { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
+ };
+
+ if( !tap_is_state_stable(from) )
+ {
+ LOG_ERROR( "fatal: tap_state \"from\" (=%s) is not stable", tap_state_name(from) );
+ exit(1);
+ }
+
+ if( !tap_is_state_stable(to) )
+ {
+ LOG_ERROR( "fatal: tap_state \"to\" (=%s) is not stable", tap_state_name(to) );
+ exit(1);
+ }
+
+ /* @todo: support other than 7 clocks ? */
+ return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)];
+}
+
+
+bool tap_is_state_stable(tap_state_t astate)
+{
+ bool is_stable;
+
+ /* A switch() is used because it is symbol dependent
+ (not value dependent like an array), and can also check bounds.
+ */
+ switch( astate )
+ {
+ case TAP_RESET:
+ case TAP_IDLE:
+ case TAP_DRSHIFT:
+ case TAP_DRPAUSE:
+ case TAP_IRSHIFT:
+ case TAP_IRPAUSE:
+ is_stable = true;
+ break;
+ default:
+ is_stable = false;
+ }
+
+ return is_stable;
+}
+
+tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
+{
+ tap_state_t new_state;
+
+ /* A switch is used because it is symbol dependent and not value dependent
+ like an array. Also it can check for out of range conditions.
+ */
+
+ if (tms)
+ {
+ switch (cur_state)
+ {
+ case TAP_RESET:
+ new_state = cur_state;
+ break;
+ case TAP_IDLE:
+ case TAP_DRUPDATE:
+ case TAP_IRUPDATE:
+ new_state = TAP_DRSELECT;
+ break;
+ case TAP_DRSELECT:
+ new_state = TAP_IRSELECT;
+ break;
+ case TAP_DRCAPTURE:
+ case TAP_DRSHIFT:
+ new_state = TAP_DREXIT1;
+ break;
+ case TAP_DREXIT1:
+ case TAP_DREXIT2:
+ new_state = TAP_DRUPDATE;
+ break;
+ case TAP_DRPAUSE:
+ new_state = TAP_DREXIT2;
+ break;
+ case TAP_IRSELECT:
+ new_state = TAP_RESET;
+ break;
+ case TAP_IRCAPTURE:
+ case TAP_IRSHIFT:
+ new_state = TAP_IREXIT1;
+ break;
+ case TAP_IREXIT1:
+ case TAP_IREXIT2:
+ new_state = TAP_IRUPDATE;
+ break;
+ case TAP_IRPAUSE:
+ new_state = TAP_IREXIT2;
+ break;
+ default:
+ LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
+ exit(1);
+ break;
+ }
+ }
+ else
+ {
+ switch (cur_state)
+ {
+ case TAP_RESET:
+ case TAP_IDLE:
+ case TAP_DRUPDATE:
+ case TAP_IRUPDATE:
+ new_state = TAP_IDLE;
+ break;
+ case TAP_DRSELECT:
+ new_state = TAP_DRCAPTURE;
+ break;
+ case TAP_DRCAPTURE:
+ case TAP_DRSHIFT:
+ case TAP_DREXIT2:
+ new_state = TAP_DRSHIFT;
+ break;
+ case TAP_DREXIT1:
+ case TAP_DRPAUSE:
+ new_state = TAP_DRPAUSE;
+ break;
+ case TAP_IRSELECT:
+ new_state = TAP_IRCAPTURE;
+ break;
+ case TAP_IRCAPTURE:
+ case TAP_IRSHIFT:
+ case TAP_IREXIT2:
+ new_state = TAP_IRSHIFT;
+ break;
+ case TAP_IREXIT1:
+ case TAP_IRPAUSE:
+ new_state = TAP_IRPAUSE;
+ break;
+ default:
+ LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
+ exit(1);
+ break;
+ }
+ }
+
+ return new_state;
+}
+
+const char* tap_state_name(tap_state_t state)