src/jtag/bitbang.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008 Øyvind Harboe                                      *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   This program is free software; you can redistribute it and/or modify  *
   9  *   it under the terms of the GNU General Public License as published by  *
  10  *   the Free Software Foundation; either version 2 of the License, or     *
  11  *   (at your option) any later version.                                   *
  12  *                                                                         *
  13  *   This program is distributed in the hope that it will be useful,       *
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  16  *   GNU General Public License for more details.                          *
  17  *                                                                         *
  18  *   You should have received a copy of the GNU General Public License     *
  19  *   along with this program; if not, write to the                         *
  20  *   Free Software Foundation, Inc.,                                       *
  21  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  22  ***************************************************************************/
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "bitbang.h"
  28
  29 /* project specific includes */
  30 #include "log.h"
  31 #include "types.h"
  32 #include "jtag.h"
  33 #include "configuration.h"
  34
  35 /* system includes */
  36 #include <string.h>
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39
  40 bitbang_interface_t *bitbang_interface;
  41
  42
  43 /* DANGER!!!! clock absolutely *MUST* be 0 in idle or reset won't work!
  44  *
  45  * Set this to 1 and str912 reset halt will fail.
  46  *
  47  * If someone can submit a patch with an explanation it will be greatly
  48  * appreciated, but as far as I can tell (ØH) DCLK is generated upon
  49  * clk=0 in TAP_RTI. Good luck deducing that from the ARM documentation!
  50  * The ARM documentation uses the term "DCLK is asserted while in the TAP_RTI
  51  * state". With hardware there is no such thing as *while* in a state. There
  52  * are only edges. So clk => 0 is in fact a very subtle state transition that
  53  * happens *while* in the TAP_RTI state. "#&¤"#¤&"#&"#&
  54  *
  55  * For "reset halt" the last thing that happens before srst is asserted
  56  * is that the breakpoint is set up. If DCLK is not wiggled one last
  57  * time before the reset, then the breakpoint is not set up and
  58  * "reset halt" will fail to halt.
  59  *
  60  */
  61 #define CLOCK_IDLE() 0
  62
  63 int bitbang_execute_queue(void);
  64
  65 /* The bitbang driver leaves the TCK 0 when in idle */
  66
  67 void bitbang_end_state(enum tap_state state)
  68 {
  69         if (tap_move_map[state] != -1)
  70                 end_state = state;
  71         else
  72         {
  73                 LOG_ERROR("BUG: %i is not a valid end state", state);
  74                 exit(-1);
  75         }
  76 }
  77
  78 void bitbang_state_move(void) {
  79
  80         int i=0, tms=0;
  81         u8 tms_scan = TAP_MOVE(cur_state, end_state);
  82
  83         for (i = 0; i < 7; i++)
  84         {
  85                 tms = (tms_scan >> i) & 1;
  86                 bitbang_interface->write(0, tms, 0);
  87                 bitbang_interface->write(1, tms, 0);
  88         }
  89         bitbang_interface->write(CLOCK_IDLE(), tms, 0);
  90
  91         cur_state = end_state;
  92 }
  93
  94 void bitbang_path_move(pathmove_command_t *cmd)
  95 {
  96         int num_states = cmd->num_states;
  97         int state_count;
  98         int tms = 0;
  99
 100         state_count = 0;
 101         while (num_states)
 102         {
 103                 if (tap_transitions[cur_state].low == cmd->path[state_count])
 104                 {
 105                         tms = 0;
 106                 }
 107                 else if (tap_transitions[cur_state].high == cmd->path[state_count])
 108                 {
 109                         tms = 1;
 110                 }
 111                 else
 112                 {
 113                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
 114                         exit(-1);
 115                 }
 116
 117                 bitbang_interface->write(0, tms, 0);
 118                 bitbang_interface->write(1, tms, 0);
 119
 120                 cur_state = cmd->path[state_count];
 121                 state_count++;
 122                 num_states--;
 123         }
 124
 125         bitbang_interface->write(CLOCK_IDLE(), tms, 0);
 126
 127         end_state = cur_state;
 128 }
 129
 130 void bitbang_runtest(int num_cycles)
 131 {
 132         int i;
 133
 134         enum tap_state saved_end_state = end_state;
 135
 136         /* only do a state_move when we're not already in RTI */
 137         if (cur_state != TAP_RTI)
 138         {
 139                 bitbang_end_state(TAP_RTI);
 140                 bitbang_state_move();
 141         }
 142
 143         /* execute num_cycles */
 144         for (i = 0; i < num_cycles; i++)
 145         {
 146                 bitbang_interface->write(0, 0, 0);
 147                 bitbang_interface->write(1, 0, 0);
 148         }
 149         bitbang_interface->write(CLOCK_IDLE(), 0, 0);
 150
 151         /* finish in end_state */
 152         bitbang_end_state(saved_end_state);
 153         if (cur_state != end_state)
 154                 bitbang_state_move();
 155 }
 156
 157 void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
 158 {
 159         enum tap_state saved_end_state = end_state;
 160         int bit_cnt;
 161
 162         if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))
 163         {
 164                 if (ir_scan)
 165                         bitbang_end_state(TAP_SI);
 166                 else
 167                         bitbang_end_state(TAP_SD);
 168
 169                 bitbang_state_move();
 170                 bitbang_end_state(saved_end_state);
 171         }
 172
 173         for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
 174         {
 175                 /* if we're just reading the scan, but don't care about the output
 176                  * default to outputting 'low', this also makes valgrind traces more readable,
 177                  * as it removes the dependency on an uninitialised value
 178                  */
 179                 if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1))
 180                 {
 181                         bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 1);
 182                         bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 1);
 183                 } else {
 184                         bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 0);
 185                         bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 0);
 186                 }
 187
 188                 if (type != SCAN_OUT)
 189                 {
 190                         /*
 191                         TDO should be sampled on the rising edge, and will change
 192                         on the falling edge.
 193
 194                         Because there is no way to read the signal exactly at the rising edge,
 195                         read after the rising edge.
 196
 197                         This is plain IEEE 1149 JTAG - nothing specific to the OpenOCD or its JTAG
 198                         API.
 199                         */
 200                         if (bitbang_interface->read())
 201                                 buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8);
 202                         else
 203                                 buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8));
 204                 }
 205         }
 206
 207         /* TAP_SD & TAP_SI are illegal end states, so we always transition to the pause
 208          * state which is a legal stable state from which statemove will work.
 209          *
 210          * Exit1 -> Pause
 211          */
 212         bitbang_interface->write(0, 0, 0);
 213         bitbang_interface->write(1, 0, 0);
 214         bitbang_interface->write(CLOCK_IDLE(), 0, 0);
 215
 216         if (ir_scan)
 217                 cur_state = TAP_PI;
 218         else
 219                 cur_state = TAP_PD;
 220
 221         if (cur_state != end_state)
 222                 bitbang_state_move();
 223 }
 224
 225 int bitbang_execute_queue(void)
 226 {
 227         jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
 228         int scan_size;
 229         enum scan_type type;
 230         u8 *buffer;
 231         int retval;
 232
 233         if (!bitbang_interface)
 234         {
 235                 LOG_ERROR("BUG: Bitbang interface called, but not yet initialized");
 236                 exit(-1);
 237         }
 238
 239         /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
 240          * that wasn't handled by a caller-provided error handler
 241          */
 242         retval = ERROR_OK;
 243
 244         if(bitbang_interface->blink)
 245                 bitbang_interface->blink(1);
 246
 247         while (cmd)
 248         {
 249                 switch (cmd->type)
 250                 {
 251                         case JTAG_END_STATE:
 252 #ifdef _DEBUG_JTAG_IO_
 253                                 LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
 254 #endif
 255                                 if (cmd->cmd.end_state->end_state != -1)
 256                                         bitbang_end_state(cmd->cmd.end_state->end_state);
 257                                 break;
 258                         case JTAG_RESET:
 259 #ifdef _DEBUG_JTAG_IO_
 260                                 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 261 #endif
 262                                 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST)))
 263                                 {
 264                                         cur_state = TAP_TLR;
 265                                 }
 266                                 bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 267                                 break;
 268                         case JTAG_RUNTEST:
 269 #ifdef _DEBUG_JTAG_IO_
 270                                 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
 271 #endif
 272                                 if (cmd->cmd.runtest->end_state != -1)
 273                                         bitbang_end_state(cmd->cmd.runtest->end_state);
 274                                 bitbang_runtest(cmd->cmd.runtest->num_cycles);
 275                                 break;
 276                         case JTAG_STATEMOVE:
 277 #ifdef _DEBUG_JTAG_IO_
 278                                 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
 279 #endif
 280                                 if (cmd->cmd.statemove->end_state != -1)
 281                                         bitbang_end_state(cmd->cmd.statemove->end_state);
 282                                 bitbang_state_move();
 283                                 break;
 284                         case JTAG_PATHMOVE:
 285 #ifdef _DEBUG_JTAG_IO_
 286                                 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
 287 #endif
 288                                 bitbang_path_move(cmd->cmd.pathmove);
 289                                 break;
 290                         case JTAG_SCAN:
 291 #ifdef _DEBUG_JTAG_IO_
 292                                 LOG_DEBUG("%s scan end in %i",  (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
 293 #endif
 294                                 if (cmd->cmd.scan->end_state != -1)
 295                                         bitbang_end_state(cmd->cmd.scan->end_state);
 296                                 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
 297                                 type = jtag_scan_type(cmd->cmd.scan);
 298                                 bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
 299                                 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
 300                                         retval = ERROR_JTAG_QUEUE_FAILED;
 301                                 if (buffer)
 302                                         free(buffer);
 303                                 break;
 304                         case JTAG_SLEEP:
 305 #ifdef _DEBUG_JTAG_IO_
 306                                 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
 307 #endif
 308                                 jtag_sleep(cmd->cmd.sleep->us);
 309                                 break;
 310                         default:
 311                                 LOG_ERROR("BUG: unknown JTAG command type encountered");
 312                                 exit(-1);
 313                 }
 314                 cmd = cmd->next;
 315         }
 316         if(bitbang_interface->blink)
 317                 bitbang_interface->blink(0);
 318
 319         return retval;
 320 }
 321