struct bitq_state {
struct jtag_command *cmd; /* command currently processed */
int field_idx; /* index of field currently being processed */
- int bit_pos; /* position of bit curently being processed */
+ int bit_pos; /* position of bit currently being processed */
int status; /* processing status */
};
static struct bitq_state bitq_in_state;
-static uint8_t* bitq_in_buffer; /* buffer dynamically reallocated as needed */
-static int bitq_in_bufsize = 32; /* min. buffer size */
-
/*
* input queue processing does not use jtag_read_buffer() to avoid unnecessary overhead
- * also the buffer for incomming data is reallocated only if necessary
* no parameters, makes use of stored state information
*/
void bitq_in_proc(void)
{
- /* static information preserved between calls to increase performance */
- static uint8_t* in_buff; /* pointer to buffer for scanned data */
- static int in_idx; /* index of byte being scanned */
- static uint8_t in_mask; /* mask of next bit to be scanned */
-
- struct scan_field* field;
- int tdo;
-
/* loop through the queue */
while (bitq_in_state.cmd)
{
/* loop through the fields */
while (bitq_in_state.field_idx < bitq_in_state.cmd->cmd.scan->num_fields)
{
+ struct scan_field *field;
field = &bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx];
if (field->in_value)
{
- if (bitq_in_state.bit_pos == 0)
- {
- /* initialize field scanning */
- in_mask = 0x01;
- in_idx = 0;
- if (field->in_value)
- in_buff = field->in_value;
- else
- {
- /* buffer reallocation needed? */
- if (field->num_bits > bitq_in_bufsize * 8)
- {
- /* buffer previously allocated? */
- 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)
- 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)
- {
- LOG_ERROR("malloc error");
- exit(-1);
- }
- in_buff = (void*) bitq_in_buffer;
- }
- }
-
/* field scanning */
while (bitq_in_state.bit_pos < field->num_bits)
{
- if ((tdo = bitq_interface->in()) < 0)
+ /* index of byte being scanned */
+ int in_idx = bitq_in_state.bit_pos / 8;
+ /* mask of next bit to be scanned */
+ uint8_t in_mask = 1 << (bitq_in_state.bit_pos % 8);
+
+ int tdo = bitq_interface->in();
+ if (tdo < 0)
{
#ifdef _DEBUG_JTAG_IO_
LOG_DEBUG("bitq in EOF");
return;
}
if (in_mask == 0x01)
- in_buff[in_idx] = 0;
+ field->in_value[in_idx] = 0;
if (tdo)
- in_buff[in_idx] |= in_mask;
- if (in_mask == 0x80)
- {
- in_mask = 0x01;
- in_idx++;
- }
- else
- in_mask <<= 1;
+ field->in_value[in_idx] |= in_mask;
bitq_in_state.bit_pos++;
}
}
}
-void bitq_scan_field(struct scan_field* field, int pause)
+void bitq_scan_field(struct scan_field* field, int do_pause)
{
int bit_cnt;
int tdo_req;
for (bit_cnt = field->num_bits; bit_cnt > 1; bit_cnt--)
bitq_io(0, 0, tdo_req);
- bitq_io(pause, 0, tdo_req);
+ bitq_io(do_pause, 0, tdo_req);
}
else
{
out_mask <<= 1;
}
- bitq_io(pause, ((*out_ptr) & out_mask) != 0, tdo_req);
+ bitq_io(do_pause, ((*out_ptr) & out_mask) != 0, tdo_req);
}
- if (pause)
+ if (do_pause)
{
bitq_io(0, 0, 0);
if (tap_get_state() == TAP_IRSHIFT)
void bitq_cleanup(void)
{
- if (bitq_in_buffer != NULL)
- {
- free(bitq_in_buffer);
- bitq_in_buffer = NULL;
- }
}