X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fbitbang.c;h=41ef061a74632bb51e2d1e3be779ba0356aac368;hp=2065f62ab07439aa6b6074101a1d535343a00fe1;hb=dc575dc5bf8cb597a0e9a47794744ae6b1928087;hpb=5fcd1d704cea078f6651e8e928ce7ff67b283882

diff --git a/src/jtag/bitbang.c b/src/jtag/bitbang.c
index 2065f62ab0..41ef061a74 100644
--- a/src/jtag/bitbang.c
+++ b/src/jtag/bitbang.c
@@ -2,6 +2,9 @@
  *   Copyright (C) 2005 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
  *                                                                         *
+ *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
+ *   oyvind.harboe@zylin.com                                               *
+ *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
@@ -22,158 +25,207 @@
 #endif
 
 #include "bitbang.h"
+#include "interface.h"
+#include "commands.h"
 
-/* project specific includes */
-#include "log.h"
-#include "types.h"
-#include "jtag.h"
-#include "configuration.h"
-
-/* system includes */
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
+/**
+ * Function bitbang_stableclocks
+ * issues a number of clock cycles while staying in a stable state.
+ * Because the TMS value required to stay in the RESET state is a 1, whereas
+ * the TMS value required to stay in any of the other stable states is a 0,
+ * this function checks the current stable state to decide on the value of TMS
+ * to use.
+ */
+static void bitbang_stableclocks(int num_cycles);
 
-#include <sys/time.h>
-#include <time.h>
 
 bitbang_interface_t *bitbang_interface;
 
-int bitbang_execute_queue(void);
+/* DANGER!!!! clock absolutely *MUST* be 0 in idle or reset won't work!
+ *
+ * Set this to 1 and str912 reset halt will fail.
+ *
+ * If someone can submit a patch with an explanation it will be greatly
+ * appreciated, but as far as I can tell (ØH) DCLK is generated upon
+ * clk = 0 in TAP_IDLE. Good luck deducing that from the ARM documentation!
+ * The ARM documentation uses the term "DCLK is asserted while in the TAP_IDLE
+ * state". With hardware there is no such thing as *while* in a state. There
+ * are only edges. So clk => 0 is in fact a very subtle state transition that
+ * happens *while* in the TAP_IDLE state. "#&¤"#¤&"#&"#&
+ *
+ * For "reset halt" the last thing that happens before srst is asserted
+ * is that the breakpoint is set up. If DCLK is not wiggled one last
+ * time before the reset, then the breakpoint is not set up and
+ * "reset halt" will fail to halt.
+ *
+ */
+#define CLOCK_IDLE() 0
 
-void bitbang_end_state(enum tap_state state)
+
+/* The bitbang driver leaves the TCK 0 when in idle */
+static void bitbang_end_state(tap_state_t state)
 {
-	if (tap_move_map[state] != -1)
-		end_state = state;
+	if (tap_is_state_stable(state))
+		tap_set_end_state(state);
 	else
 	{
-		ERROR("BUG: %i is not a valid end state", state);
+		LOG_ERROR("BUG: %i is not a valid end state", state);
 		exit(-1);
 	}
 }
 
-void bitbang_state_move(void) {
-	
-	int i=0, tms=0;
-	u8 tms_scan = TAP_MOVE(cur_state, end_state);
-	
-	for (i = 0; i < 7; i++)
+static void bitbang_state_move(int skip)
+{
+	int i = 0, tms = 0;
+	uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
+	int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
+
+	for (i = skip; i < tms_count; i++)
 	{
 		tms = (tms_scan >> i) & 1;
 		bitbang_interface->write(0, tms, 0);
 		bitbang_interface->write(1, tms, 0);
 	}
-	bitbang_interface->write(0, tms, 0);
-	
-	cur_state = end_state;
+	bitbang_interface->write(CLOCK_IDLE(), tms, 0);
+
+	tap_set_state(tap_get_end_state());
 }
 
-void bitbang_path_move(pathmove_command_t *cmd)
+static void bitbang_path_move(pathmove_command_t *cmd)
 {
 	int num_states = cmd->num_states;
 	int state_count;
+	int tms = 0;
 
 	state_count = 0;
 	while (num_states)
 	{
-		if (tap_transitions[cur_state].low == cmd->path[state_count])
+		if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
 		{
-			bitbang_interface->write(0, 0, 0);
-			bitbang_interface->write(1, 0, 0);
+			tms = 0;
 		}
-		else if (tap_transitions[cur_state].high == cmd->path[state_count])
+		else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
 		{
-			bitbang_interface->write(0, 1, 0);
-			bitbang_interface->write(1, 1, 0);
-		}			
+			tms = 1;
+		}
 		else
 		{
-			ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
+			LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count]));
 			exit(-1);
 		}
-		
-		cur_state = cmd->path[state_count];
+
+		bitbang_interface->write(0, tms, 0);
+		bitbang_interface->write(1, tms, 0);
+
+		tap_set_state(cmd->path[state_count]);
 		state_count++;
 		num_states--;
 	}
-	
-	end_state = cur_state;
+
+	bitbang_interface->write(CLOCK_IDLE(), tms, 0);
+
+	tap_set_end_state(tap_get_state());
 }
 
-void bitbang_runtest(int num_cycles)
+static void bitbang_runtest(int num_cycles)
 {
 	int i;
-	
-	enum tap_state saved_end_state = end_state;
-	
-	/* only do a state_move when we're not already in RTI */
-	if (cur_state != TAP_RTI)
+
+	tap_state_t saved_end_state = tap_get_end_state();
+
+	/* only do a state_move when we're not already in IDLE */
+	if (tap_get_state() != TAP_IDLE)
 	{
-		bitbang_end_state(TAP_RTI);
-		bitbang_state_move();
+		bitbang_end_state(TAP_IDLE);
+		bitbang_state_move(0);
 	}
-	
+
 	/* execute num_cycles */
-	bitbang_interface->write(0, 0, 0);
 	for (i = 0; i < num_cycles; i++)
 	{
-		bitbang_interface->write(1, 0, 0);
 		bitbang_interface->write(0, 0, 0);
+		bitbang_interface->write(1, 0, 0);
 	}
-	
+	bitbang_interface->write(CLOCK_IDLE(), 0, 0);
+
 	/* finish in end_state */
 	bitbang_end_state(saved_end_state);
-	if (cur_state != end_state)
-		bitbang_state_move();
+	if (tap_get_state() != tap_get_end_state())
+		bitbang_state_move(0);
 }
 
-void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
+
+static void bitbang_stableclocks(int num_cycles)
 {
-	enum tap_state saved_end_state = end_state;
+	int tms = (tap_get_state() == TAP_RESET ? 1 : 0);
+	int i;
+
+	/* send num_cycles clocks onto the cable */
+	for (i = 0; i < num_cycles; i++)
+	{
+		bitbang_interface->write(1, tms, 0);
+		bitbang_interface->write(0, tms, 0);
+	}
+}
+
+
+
+static void bitbang_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
+{
+	tap_state_t saved_end_state = tap_get_end_state();
 	int bit_cnt;
-	
-	if (ir_scan)
-		bitbang_end_state(TAP_SI);
-	else
-		bitbang_end_state(TAP_SD);
 
-	bitbang_state_move();
-	bitbang_end_state(saved_end_state);
+	if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) || (ir_scan && (tap_get_state() == TAP_IRSHIFT))))
+	{
+		if (ir_scan)
+			bitbang_end_state(TAP_IRSHIFT);
+		else
+			bitbang_end_state(TAP_DRSHIFT);
+
+		bitbang_state_move(0);
+		bitbang_end_state(saved_end_state);
+	}
 
 	for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
 	{
+		int val = 0;
+		int tms = (bit_cnt == scan_size-1) ? 1 : 0;
+		int tdi;
+		int bytec = bit_cnt/8;
+		int bcval = 1 << (bit_cnt % 8);
+
 		/* if we're just reading the scan, but don't care about the output
 		 * default to outputting 'low', this also makes valgrind traces more readable,
 		 * as it removes the dependency on an uninitialised value
-		 */ 
-		if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1)) {
-			bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 1);
-			bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 1);
-		} else {
-			bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 0);
-			bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 0);
-		}
-		
+		 */
+		tdi = 0;
+		if ((type != SCAN_IN) && (buffer[bytec] & bcval))
+			tdi = 1;
+
+		bitbang_interface->write(0, tms, tdi);
+
+		if (type != SCAN_OUT)
+			val = bitbang_interface->read();
+
+		bitbang_interface->write(1, tms, tdi);
+
 		if (type != SCAN_OUT)
 		{
-			if (bitbang_interface->read())
-				buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8);
+			if (val)
+				buffer[bytec] |= bcval;
 			else
-				buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8));
+				buffer[bytec] &= ~bcval;
 		}
 	}
-	
-	/* Exit1 -> Pause */
-	bitbang_interface->write(0, 0, 0);
-	bitbang_interface->write(1, 0, 0);
-	
-	if (ir_scan)
-		cur_state = TAP_PI;
-	else
-		cur_state = TAP_PD;
-	
-	if (cur_state != end_state)
-		bitbang_state_move();
+
+	if (tap_get_state() != tap_get_end_state())
+	{
+		/* we *KNOW* the above loop transitioned out of
+		 * the shift state, so we skip the first state
+		 * and move directly to the end state.
+		 */
+		bitbang_state_move(1);
+	}
 }
 
 int bitbang_execute_queue(void)
@@ -181,84 +233,93 @@ int bitbang_execute_queue(void)
 	jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
 	int scan_size;
 	enum scan_type type;
-	u8 *buffer;
-	
+	uint8_t *buffer;
+	int retval;
+
 	if (!bitbang_interface)
 	{
-		ERROR("BUG: Bitbang interface called, but not yet initialized");
+		LOG_ERROR("BUG: Bitbang interface called, but not yet initialized");
 		exit(-1);
 	}
-		
+
+	/* return ERROR_OK, unless a jtag_read_buffer returns a failed check
+	 * that wasn't handled by a caller-provided error handler
+	 */
+	retval = ERROR_OK;
+
+	if (bitbang_interface->blink)
+		bitbang_interface->blink(1);
+
 	while (cmd)
 	{
 		switch (cmd->type)
 		{
-			case JTAG_END_STATE:
-#ifdef _DEBUG_JTAG_IO_
-				DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
-#endif
-				if (cmd->cmd.end_state->end_state != -1)
-					bitbang_end_state(cmd->cmd.end_state->end_state);
-				break;
 			case JTAG_RESET:
 #ifdef _DEBUG_JTAG_IO_
-				DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+				LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 #endif
-				if (cmd->cmd.reset->trst == 1)
+				if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
 				{
-					cur_state = TAP_TLR;
+					tap_set_state(TAP_RESET);
 				}
 				bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 				break;
 			case JTAG_RUNTEST:
 #ifdef _DEBUG_JTAG_IO_
-				DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
+				LOG_DEBUG("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state));
 #endif
-				if (cmd->cmd.runtest->end_state != -1)
-					bitbang_end_state(cmd->cmd.runtest->end_state);
+				bitbang_end_state(cmd->cmd.runtest->end_state);
 				bitbang_runtest(cmd->cmd.runtest->num_cycles);
 				break;
+
+			case JTAG_STABLECLOCKS:
+				/* this is only allowed while in a stable state.  A check for a stable
+				 * state was done in jtag_add_clocks()
+				 */
+				bitbang_stableclocks(cmd->cmd.stableclocks->num_cycles);
+				break;
+
 			case JTAG_STATEMOVE:
 #ifdef _DEBUG_JTAG_IO_
-				DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
+				LOG_DEBUG("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state));
 #endif
-				if (cmd->cmd.statemove->end_state != -1)
-					bitbang_end_state(cmd->cmd.statemove->end_state);
-				bitbang_state_move();
+				bitbang_end_state(cmd->cmd.statemove->end_state);
+				bitbang_state_move(0);
 				break;
 			case JTAG_PATHMOVE:
 #ifdef _DEBUG_JTAG_IO_
-				DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
+				LOG_DEBUG("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states,
+					tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
 #endif
 				bitbang_path_move(cmd->cmd.pathmove);
 				break;
 			case JTAG_SCAN:
 #ifdef _DEBUG_JTAG_IO_
-				DEBUG("scan end in %i", cmd->cmd.scan->end_state);
+				LOG_DEBUG("%s scan end in %s",  (cmd->cmd.scan->ir_scan) ? "IR" : "DR", tap_state_name(cmd->cmd.scan->end_state));
 #endif
-				if (cmd->cmd.scan->end_state != -1)
-					bitbang_end_state(cmd->cmd.scan->end_state);
+				bitbang_end_state(cmd->cmd.scan->end_state);
 				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
 				type = jtag_scan_type(cmd->cmd.scan);
 				bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
 				if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
-					return ERROR_JTAG_QUEUE_FAILED;
+					retval = ERROR_JTAG_QUEUE_FAILED;
 				if (buffer)
 					free(buffer);
 				break;
 			case JTAG_SLEEP:
 #ifdef _DEBUG_JTAG_IO_
-				DEBUG("sleep", cmd->cmd.sleep->us);
+				LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
 #endif
 				jtag_sleep(cmd->cmd.sleep->us);
 				break;
 			default:
-				ERROR("BUG: unknown JTAG command type encountered");
+				LOG_ERROR("BUG: unknown JTAG command type encountered");
 				exit(-1);
 		}
 		cmd = cmd->next;
 	}
-	
-	return ERROR_OK;
-}
+	if (bitbang_interface->blink)
+		bitbang_interface->blink(0);
 
+	return retval;
+}