#include "config.h"
#endif
+#include <jtag/jtag.h>
#include "bitq.h"
-#include "interface.h"
+#include <jtag/interface.h>
struct bitq_interface* bitq_interface; /* low level bit queue interface */
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;
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)
{
+ /* 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);
+
if ((tdo = bitq_interface->in()) < 0)
{
#ifdef _DEBUG_JTAG_IO_
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;
- uint8_t* out_ptr;
+ const uint8_t* out_ptr;
uint8_t out_mask;
if (field->in_value)
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)
bitq_runtest(cmd->cmd.runtest->num_cycles);
break;
- case JTAG_STATEMOVE:
+ case JTAG_TLR_RESET:
#ifdef _DEBUG_JTAG_IO_
LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
#endif
void bitq_cleanup(void)
{
- if (bitq_in_buffer != NULL)
- {
- free(bitq_in_buffer);
- bitq_in_buffer = NULL;
- }
}