bitq: remove the remaining static variables

[fw/openocd] / src / jtag / drivers / bitq.c

diff --git a/src/jtag/drivers/bitq.c b/src/jtag/drivers/bitq.c
index d04a39e109c0869236265eaf15ed11b6a727857b..064f43b01146696f9e274e8d00a22efb7db3c6eb 100644 (file)
--- a/src/jtag/drivers/bitq.c
+++ b/src/jtag/drivers/bitq.c
@@ -21,6 +21,7 @@
 #include "config.h"
 #endif
 
+#include <jtag/jtag.h>
 #include "bitq.h"
 #include <jtag/interface.h>
 
@@ -31,26 +32,17 @@ 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;
 
@@ -66,42 +58,14 @@ void bitq_in_proc(void)
                                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_
@@ -110,16 +74,9 @@ void bitq_in_proc(void)
                                                        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++;
                                        }
                                }
@@ -220,12 +177,12 @@ void bitq_runtest(int num_cycles)
 }
 
 
-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)
@@ -239,7 +196,7 @@ void bitq_scan_field(struct scan_field* field, int pause)
                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
        {
@@ -258,10 +215,10 @@ void bitq_scan_field(struct scan_field* field, int pause)
                                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)
@@ -322,7 +279,7 @@ int bitq_execute_queue(void)
                        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
@@ -389,9 +346,4 @@ int bitq_execute_queue(void)
 
 void bitq_cleanup(void)
 {
-       if (bitq_in_buffer != NULL)
-       {
-               free(bitq_in_buffer);
-               bitq_in_buffer = NULL;
-       }
 }