encapsulate bitq_state structure

[openocd.git] / src / jtag / bitq.c

diff --git a/src/jtag/bitq.c b/src/jtag/bitq.c
index 65dbb6568efdd93c02a9387a893f964d7a7310fa..56cc31e4f64ff92a8ae008a7eb4e03426e620450 100644 (file)
--- a/src/jtag/bitq.c
+++ b/src/jtag/bitq.c
@@ -27,7 +27,14 @@
 
 bitq_interface_t* bitq_interface;       /* low level bit queue interface */
 
-static bitq_state_t      bitq_in_state;        /* state of input queue */
+/* state of input queue */
+struct bitq_state {
+       jtag_command_t *cmd; /* command currently processed */
+       int field_idx; /* index of field currently being processed */
+       int bit_pos; /* position of bit curently 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 */
@@ -44,22 +51,22 @@ void bitq_in_proc(void)
        static int    in_idx;   /* index of byte being scanned */
        static uint8_t     in_mask;  /* mask of next bit to be scanned */
 
-       scan_field_t* field;
+       struct scan_field* field;
        int           tdo;
 
        /* loop through the queue */
        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,7 +76,7 @@ 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)
@@ -79,11 +86,11 @@ void bitq_in_proc(void)
                                                                        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 +100,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,7 +138,7 @@ 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();
 }
 
@@ -161,7 +168,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;
@@ -183,15 +190,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());
 }
 
 
@@ -208,12 +215,12 @@ 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());
 }
 
 
-void bitq_scan_field(scan_field_t* field, int pause)
+void bitq_scan_field(struct scan_field* field, int pause)
 {
        int bit_cnt;
        int tdo_req;
@@ -226,10 +233,10 @@ void bitq_scan_field(scan_field_t* field, int pause)
        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);
@@ -239,10 +246,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++;
@@ -251,15 +258,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);
        }
 }
@@ -298,12 +305,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_get_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;
 
@@ -320,7 +327,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:
@@ -341,8 +348,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:
@@ -350,7 +357,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;