in_handler in_check_mask and in_check_value now removed from field. Last big patch in the series of JTAG API cleanup.

git-svn-id: svn://svn.berlios.de/openocd/trunk@1672 b42882b7-edfa-0310-969c-e2dbd0fdcd60

4 files changed, 11 insertions, 135 deletions

diff --git a/src/jtag/bitq.c b/src/jtag/bitq.c
index 6d47c48b..cbba5511 100644
--- a/src/jtag/bitq.c
+++ b/src/jtag/bitq.c
@@ -66,7 +66,7 @@ void bitq_in_proc(void)
 			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 || field->in_handler)
+				if (field->in_value)
 				{
 					if (bitq_in_state.bit_pos==0)
 					{
@@ -124,12 +124,6 @@ void bitq_in_proc(void)
 							in_mask <<= 1;
 						bitq_in_state.bit_pos++;
 					}
-
-
-					if (field->in_handler && bitq_in_state.status==ERROR_OK)
-					{
-						bitq_in_state.status = (*field->in_handler)(in_buff, field->in_handler_priv, field);
-					}
 				}
 
 				bitq_in_state.field_idx++;  /* advance to next field */
@@ -238,7 +232,7 @@ void bitq_scan_field(scan_field_t* field, int pause)
 	u8* out_ptr;
 	u8  out_mask;
 
-	if (field->in_value || field->in_handler)
+	if (field->in_value)
 		tdo_req = 1;
 	else
 		tdo_req = 0;
diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c
index 28b648bf..2fd4c2c1 100644
--- a/src/jtag/jtag.c
+++ b/src/jtag/jtag.c
@@ -623,7 +623,6 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields,
 		(*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
 		(*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
 		(*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
-		(*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL;	/* disable verification by default */
 
 		/* search the list */
 		for (j = 0; j < num_fields; j++)
@@ -690,10 +689,6 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f
 		(*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
 		(*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
 		(*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
-		(*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
-		(*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
-		(*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
-		(*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
 	}
 	return ERROR_OK;
 }
@@ -772,10 +767,7 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields,
 				(*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
 				(*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
 				(*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
-				(*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
-				(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
-				(*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
-				(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
+				field_count++;
 			}
 		}
 		if (!found)
@@ -792,10 +784,7 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields,
 			(*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
 			(*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
 			(*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
+			field_count++;
 		}
 		else
 		{
@@ -881,10 +870,7 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
 				(*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
 				(*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
 				(*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
-				(*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
-				(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
-				(*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
-				(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
+				field_count++;
 			}
 		} else
 		{
@@ -900,10 +886,7 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
 			(*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
 			(*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
 			(*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
-			(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
+			field_count++;
 		}
 	}
 }
@@ -945,10 +928,6 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f
 		(*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
 		(*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
 		(*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
-		(*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
-		(*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
-		(*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
-		(*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
 	}
 
 	return ERROR_OK;
@@ -1333,7 +1312,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
 		/* if neither in_value nor in_handler
 		 * are specified we don't have to examine this field
 		 */
-		if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
+		if (cmd->fields[i].in_value)
 		{
 			int num_bits = cmd->fields[i].num_bits;
 			u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
@@ -1347,28 +1326,6 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
 			if (cmd->fields[i].in_value)
 			{
 				buf_cpy(captured, cmd->fields[i].in_value, num_bits);
-
-				if (cmd->fields[i].in_handler)
-				{
-					if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
-					{
-						LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
-						retval = ERROR_JTAG_QUEUE_FAILED;
-					}
-				}
-			}
-
-			/* no in_value specified, but a handler takes care of the scanned data */
-			if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
-			{
-				if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
-				{
-					/* We're going to call the error:handler later, but if the in_handler
-					 * reported an error we report this failure upstream
-					 */
-					LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s",  cmd->ir_scan ? "SIR" : "SDR" );
-					retval = ERROR_JTAG_QUEUE_FAILED;
-				}
 			}
 
 			free(captured);
@@ -1432,26 +1389,6 @@ int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value
 	return retval;
 }
 
-int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
-{
-	return jtag_check_value_inner(captured, field, field->in_check_value, field->in_check_mask);
-}
-
-/*
-  set up checking of this field using the in_handler. The values passed in must be valid until
-  after jtag_execute() has completed.
- */
-void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, struct invalidstruct *obsolete)
-{
-	if (value)
-		field->in_handler = jtag_check_value;
-	else
-		field->in_handler = NULL;	/* No check, e.g. embeddedice uses value==NULL to indicate no check */
-	field->in_handler_priv = NULL;
-	field->in_check_value = value;
-	field->in_check_mask = mask;
-}
-
 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
 {
 	assert(field->in_value != NULL);
@@ -1466,7 +1403,6 @@ void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
 
 	int retval=jtag_check_value_inner(field->in_value, field, value, mask);
 	jtag_set_error(retval);
-
 }
 
 
@@ -1478,7 +1414,7 @@ enum scan_type jtag_scan_type(scan_command_t *cmd)
 
 	for (i = 0; i < cmd->num_fields; i++)
 	{
-		if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
+		if (cmd->fields[i].in_value)
 			type |= SCAN_IN;
 		if (cmd->fields[i].out_value)
 			type |= SCAN_OUT;
@@ -1566,7 +1502,7 @@ int jtag_examine_chain(void)
 	field.in_value = idcode_buffer;
 
 
-	field.in_handler = NULL;
+
 
 	for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
 	{
@@ -1740,7 +1676,7 @@ int jtag_validate_chain(void)
 	field.num_bits = total_ir_length;
 	field.out_value = ir_test;
 	field.in_value = ir_test;
-	field.in_handler = NULL;
+
 
 	jtag_add_plain_ir_scan(1, &field, TAP_RESET);
 	jtag_execute_queue();
@@ -2858,9 +2794,6 @@ static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, c
 		fields[i].out_value = malloc(CEIL(field_size, 8));
 		buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
 		fields[i].in_value = NULL;
-		fields[i].in_check_mask = NULL;
-		fields[i].in_handler = NULL;
-		fields[i].in_handler_priv = NULL;
 	}
 
 	jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
@@ -2973,10 +2906,7 @@ static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args
 		fields[field_count].out_value = malloc(CEIL(bits, 8));
 		str_to_buf(str, len, fields[field_count].out_value, bits, 0);
 		fields[field_count].in_value = fields[field_count].out_value;
-		fields[field_count].in_check_mask = NULL;
-		fields[field_count].in_check_value = NULL;
-		fields[field_count].in_handler = NULL;
-		fields[field_count++].in_handler_priv = NULL;
+		field_count++;
 	}
 
 	jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h
index 656741f9..dc6ef36c 100644
--- a/src/jtag/jtag.h
+++ b/src/jtag/jtag.h
@@ -272,11 +272,6 @@ typedef struct scan_field_s
 	int         num_bits;           /* number of bits this field specifies (up to 32) */
 	u8*         out_value;          /* value to be scanned into the device */
 	u8*         in_value;           /* pointer to a 32-bit memory location to take data scanned out */
-	/* in_check_value/mask, in_handler_error_handler, in_handler_priv can be used by the in handler, otherwise they contain garbage  */
-	u8*          in_check_value;    /* deprecated! only used from jtag_set_check_value. used to validate scan results */
-	u8*          in_check_mask;     /* deprecated! only used from jtag_set_check_value.  check specified bits against check_value */
-	in_handler_t in_handler;        /* deprecated! SET TO NULL. DO NOT USE! process received buffer using this handler */
-	void*        in_handler_priv;   /* deprecated! only used by obsolete in_handler implementations */
 } scan_field_t;
 
 enum scan_type {
@@ -736,7 +731,6 @@ struct invalidstruct
 
 };
 
-extern void           jtag_set_check_value(scan_field_t* field, u8* value, u8* mask, struct invalidstruct *obsolete);
 /* execute jtag queue and check value and use mask if mask is != NULL. invokes
  * jtag_set_error() with any error. */
 extern void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask);
diff --git a/src/jtag/zy1000.c b/src/jtag/zy1000.c
index b1778068..ae082e2c 100644
--- a/src/jtag/zy1000.c
+++ b/src/jtag/zy1000.c
@@ -468,24 +468,6 @@ static __inline void scanFields(int num_fields, scan_field_t *fields, tap_state_
 		if (fields[i].in_value!=NULL)
 		{
 			inBuffer=fields[i].in_value;
-		} else if (fields[i].in_handler!=NULL)
-		{
-			if (in_buff_size*8<num_bits)
-			{
-				// we need more space
-				if (in_buff!=NULL)
-					free(in_buff);
-				in_buff=NULL;
-				in_buff_size=(num_bits+7)/8;
-				in_buff=malloc(in_buff_size);
-				if (in_buff==NULL)
-				{
-					LOG_ERROR("Out of memory");
-					jtag_error=ERROR_JTAG_QUEUE_FAILED;
-					return;
-				}
-			}
-			inBuffer=in_buff;
 		}
 
 		// here we shuffle N bits out/in
@@ -535,17 +517,6 @@ static __inline void scanFields(int num_fields, scan_field_t *fields, tap_state_
 			}
 			j+=k;
 		}
-
-		if (fields[i].in_handler!=NULL)
-		{
-			// invoke callback
-			int r=fields[i].in_handler(inBuffer, fields[i].in_handler_priv, fields+i);
-			if (r!=ERROR_OK)
-			{
-				/* this will cause jtag_execute_queue() to return an error */
-				jtag_error=r;
-			}
-		}
 	}
 }
 
@@ -577,15 +548,6 @@ int interface_jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t
 			{
 				found = 1;
 
-				if ((jtag_verify_capture_ir)&&(fields[j].in_handler==NULL))
-				{
-					jtag_set_check_value(fields+j, tap->expected, tap->expected_mask, NULL);
-				} else if (jtag_verify_capture_ir)
-				{
-					fields[j].in_check_value = tap->expected;
-					fields[j].in_check_mask = tap->expected_mask;
-				}
-
 				scanFields(1, fields+j, TAP_IRSHIFT, pause);
 				/* update device information */
 				buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
@@ -656,10 +618,6 @@ int interface_jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t
 			tmp.num_bits = 1;
 			tmp.out_value = NULL;
 			tmp.in_value = NULL;
-			tmp.in_check_value = NULL;
-			tmp.in_check_mask = NULL;
-			tmp.in_handler = NULL;
-			tmp.in_handler_priv = NULL;
 
 			scanFields(1, &tmp, TAP_DRSHIFT, pause);
 		}