X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fbitq.c;h=cb7b511a285427961c0cd1d1eb97f15ef675d39d;hb=2d9863e121ff0c02b33f1b8a3e74fae55d901fa6;hp=40b704b9ed04f8d5b396af094f09a81395eed4da;hpb=a88871bc6ad13561d9e60fbd9152b8f0c05329b1;p=openocd.git

diff --git a/src/jtag/bitq.c b/src/jtag/bitq.c
index 40b704b9ed..cb7b511a28 100644
--- a/src/jtag/bitq.c
+++ b/src/jtag/bitq.c
@@ -21,15 +21,15 @@
 #include "config.h"
 #endif
 
-#define INCLUDE_JTAG_INTERFACE_H
 #include "bitq.h"
+#include "interface.h"
 
 
 bitq_interface_t* bitq_interface;       /* low level bit queue interface */
 
 static bitq_state_t      bitq_in_state;        /* state of input queue */
 
-static u8* bitq_in_buffer;                     /* buffer dynamically reallocated as needed */
+static uint8_t* bitq_in_buffer;                     /* buffer dynamically reallocated as needed */
 static int     bitq_in_bufsize = 32; /* min. buffer size */
 
 /*
@@ -40,9 +40,9 @@ static int     bitq_in_bufsize = 32; /* min. buffer size */
 void bitq_in_proc(void)
 {
 	/* static information preserved between calls to increase performance */
-	static u8*    in_buff;  /* pointer to buffer for scanned data */
+	static uint8_t*    in_buff;  /* pointer to buffer for scanned data */
 	static int    in_idx;   /* index of byte being scanned */
-	static u8     in_mask;  /* mask of next bit to be scanned */
+	static uint8_t     in_mask;  /* mask of next bit to be scanned */
 
 	scan_field_t* field;
 	int           tdo;
@@ -51,15 +51,15 @@ void bitq_in_proc(void)
 	while (bitq_in_state.cmd)
 	{
 		/* only JTAG_SCAN command may return data */
-		if (bitq_in_state.cmd->type==JTAG_SCAN)
+		if (bitq_in_state.cmd->type == JTAG_SCAN)
 		{
 			/* loop through the fields */
-			while (bitq_in_state.field_idx<bitq_in_state.cmd->cmd.scan->num_fields)
+			while (bitq_in_state.field_idx < bitq_in_state.cmd->cmd.scan->num_fields)
 			{
 				field = &bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx];
 				if (field->in_value)
 				{
-					if (bitq_in_state.bit_pos==0)
+					if (bitq_in_state.bit_pos == 0)
 					{
 						/* initialize field scanning */
 						in_mask = 0x01;
@@ -69,21 +69,21 @@ void bitq_in_proc(void)
 						else
 						{
 							/* buffer reallocation needed? */
-							if (field->num_bits>bitq_in_bufsize * 8)
+							if (field->num_bits > bitq_in_bufsize * 8)
 							{
 								/* buffer previously allocated? */
-								if (bitq_in_buffer!=NULL)
+								if (bitq_in_buffer != NULL)
 								{
 									/* free it */
 									free(bitq_in_buffer);
 									bitq_in_buffer = NULL;
 								}
 								/* double the buffer size until it fits */
-								while (field->num_bits>bitq_in_bufsize * 8)
+								while (field->num_bits > bitq_in_bufsize * 8)
 									bitq_in_bufsize *= 2;
 							}
 							/* if necessary, allocate buffer and check for malloc error */
-							if (bitq_in_buffer==NULL && ( bitq_in_buffer = malloc(bitq_in_bufsize) )==NULL)
+							if (bitq_in_buffer == NULL && (bitq_in_buffer = malloc(bitq_in_bufsize)) == NULL)
 							{
 								LOG_ERROR("malloc error");
 								exit(-1);
@@ -93,20 +93,20 @@ void bitq_in_proc(void)
 					}
 
 					/* field scanning */
-					while (bitq_in_state.bit_pos<field->num_bits)
+					while (bitq_in_state.bit_pos < field->num_bits)
 					{
-						if ( ( tdo = bitq_interface->in() )<0 )
+						if ((tdo = bitq_interface->in()) < 0)
 						{
 #ifdef _DEBUG_JTAG_IO_
 							LOG_DEBUG("bitq in EOF");
 #endif
 							return;
 						}
-						if (in_mask==0x01)
+						if (in_mask == 0x01)
 							in_buff[in_idx] = 0;
 						if (tdo)
 							in_buff[in_idx] |= in_mask;
-						if (in_mask==0x80)
+						if (in_mask == 0x80)
 						{
 							in_mask = 0x01;
 							in_idx++;
@@ -131,16 +131,13 @@ void bitq_io(int tms, int tdi, int tdo_req)
 {
 	bitq_interface->out(tms, tdi, tdo_req);
 	/* check and process the input queue */
-	if ( bitq_interface->in_rdy() )
+	if (bitq_interface->in_rdy())
 		bitq_in_proc();
 }
 
 
 void bitq_end_state(tap_state_t state)
 {
-	if (state==TAP_INVALID)
-		return;
-
 	if (!tap_is_state_stable(state))
 	{
 		LOG_ERROR("BUG: %i is not a valid end state", state);
@@ -153,7 +150,7 @@ void bitq_end_state(tap_state_t state)
 void bitq_state_move(tap_state_t new_state)
 {
 	int i = 0;
-	u8  tms_scan;
+	uint8_t  tms_scan;
 
 	if (!tap_is_state_stable(tap_get_state()) || !tap_is_state_stable(new_state))
 	{
@@ -164,7 +161,7 @@ void bitq_state_move(tap_state_t new_state)
 	tms_scan = tap_get_tms_path(tap_get_state(), new_state);
 	int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
 
-	for (i = 0; i<tms_count; i++)
+	for (i = 0; i < tms_count; i++)
 	{
 		bitq_io(tms_scan & 1, 0, 0);
 		tms_scan >>= 1;
@@ -178,7 +175,7 @@ void bitq_path_move(pathmove_command_t* cmd)
 {
 	int i;
 
-	for (i = 0; i<=cmd->num_states; i++)
+	for (i = 0; i <= cmd->num_states; i++)
 	{
 		if (tap_state_transition(tap_get_state(), false) == cmd->path[i])
 			bitq_io(0, 0, 0);
@@ -186,15 +183,15 @@ void bitq_path_move(pathmove_command_t* cmd)
 			bitq_io(1, 0, 0);
 		else
 		{
-			LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition", tap_state_name(
-							 tap_get_state() ), tap_state_name(cmd->path[i]) );
+			LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(
+							 tap_get_state()), tap_state_name(cmd->path[i]));
 			exit(-1);
 		}
 
 		tap_set_state(cmd->path[i]);
 	}
 
-	tap_set_end_state( tap_get_state() );
+	tap_set_end_state(tap_get_state());
 }
 
 
@@ -211,8 +208,8 @@ void bitq_runtest(int num_cycles)
 		bitq_io(0, 0, 0);
 
 	/* finish in end_state */
-	if ( tap_get_state() != tap_get_end_state() )
-		bitq_state_move( tap_get_end_state() );
+	if (tap_get_state() != tap_get_end_state())
+		bitq_state_move(tap_get_end_state());
 }
 
 
@@ -221,18 +218,18 @@ void bitq_scan_field(scan_field_t* field, int pause)
 	int bit_cnt;
 	int tdo_req;
 
-	u8* out_ptr;
-	u8  out_mask;
+	uint8_t* out_ptr;
+	uint8_t  out_mask;
 
 	if (field->in_value)
 		tdo_req = 1;
 	else
 		tdo_req = 0;
 
-	if (field->out_value==NULL)
+	if (field->out_value == NULL)
 	{
 		/* just send zeros and request data from TDO */
-		for (bit_cnt = field->num_bits; bit_cnt>1; bit_cnt--)
+		for (bit_cnt = field->num_bits; bit_cnt > 1; bit_cnt--)
 			bitq_io(0, 0, tdo_req);
 
 		bitq_io(pause, 0, tdo_req);
@@ -242,10 +239,10 @@ void bitq_scan_field(scan_field_t* field, int pause)
 		/* send data, and optionally request TDO */
 		out_mask = 0x01;
 		out_ptr  = field->out_value;
-		for (bit_cnt = field->num_bits; bit_cnt>1; bit_cnt--)
+		for (bit_cnt = field->num_bits; bit_cnt > 1; bit_cnt--)
 		{
-			bitq_io(0, ( (*out_ptr) & out_mask )!=0, tdo_req);
-			if (out_mask==0x80)
+			bitq_io(0, ((*out_ptr) & out_mask) != 0, tdo_req);
+			if (out_mask == 0x80)
 			{
 				out_mask = 0x01;
 				out_ptr++;
@@ -254,15 +251,15 @@ void bitq_scan_field(scan_field_t* field, int pause)
 				out_mask <<= 1;
 		}
 
-		bitq_io(pause, ( (*out_ptr) & out_mask )!=0, tdo_req);
+		bitq_io(pause, ((*out_ptr) & out_mask) != 0, tdo_req);
 	}
 
 	if (pause)
 	{
 		bitq_io(0, 0, 0);
-		if (tap_get_state()==TAP_IRSHIFT)
+		if (tap_get_state() == TAP_IRSHIFT)
 			tap_set_state(TAP_IRPAUSE);
-		else if (tap_get_state()==TAP_DRSHIFT)
+		else if (tap_get_state() == TAP_DRSHIFT)
 			tap_set_state(TAP_DRPAUSE);
 	}
 }
@@ -301,12 +298,12 @@ int bitq_execute_queue(void)
 #ifdef _DEBUG_JTAG_IO_
 			LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 #endif
-			if ( (cmd->cmd.reset->trst == 1) || ( cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST) ) )
+			if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
 			{
 				tap_set_state(TAP_RESET);
 			}
 			bitq_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-			if ( bitq_interface->in_rdy() )
+			if (bitq_interface->in_rdy())
 				bitq_in_proc();
 			break;
 
@@ -323,7 +320,7 @@ int bitq_execute_queue(void)
 			LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
 #endif
 			bitq_end_state(cmd->cmd.statemove->end_state);
-			bitq_state_move( tap_get_end_state() );   /* uncoditional TAP move */
+			bitq_state_move(tap_get_end_state());   /* uncoditional TAP move */
 			break;
 
 		case JTAG_PATHMOVE:
@@ -344,8 +341,8 @@ int bitq_execute_queue(void)
 #endif
 			bitq_end_state(cmd->cmd.scan->end_state);
 			bitq_scan(cmd->cmd.scan);
-			if ( tap_get_state() != tap_get_end_state() )
-				bitq_state_move( tap_get_end_state() );
+			if (tap_get_state() != tap_get_end_state())
+				bitq_state_move(tap_get_end_state());
 			break;
 
 		case JTAG_SLEEP:
@@ -353,7 +350,7 @@ int bitq_execute_queue(void)
 			LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
 #endif
 			bitq_interface->sleep(cmd->cmd.sleep->us);
-			if ( bitq_interface->in_rdy() )
+			if (bitq_interface->in_rdy())
 				bitq_in_proc();
 			break;
 
@@ -373,7 +370,7 @@ int bitq_execute_queue(void)
 		LOG_ERROR("missing data from bitq interface");
 		return ERROR_JTAG_QUEUE_FAILED;
 	}
-	if (bitq_interface->in()>=0)
+	if (bitq_interface->in() >= 0)
 	{
 		LOG_ERROR("extra data from bitq interface");
 		return ERROR_JTAG_QUEUE_FAILED;
@@ -385,7 +382,7 @@ int bitq_execute_queue(void)
 
 void bitq_cleanup(void)
 {
-	if (bitq_in_buffer!=NULL)
+	if (bitq_in_buffer != NULL)
 	{
 		free(bitq_in_buffer);
 		bitq_in_buffer = NULL;