src/jtag/dummy.c

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Øyvind Harboe                                   *
   3  *   oyvind.harboe@zylin.com                                               *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "replacements.h"
  25
  26 #include "jtag.h"
  27 #include "bitbang.h"
  28
  29
  30 /* my private tap controller state, which tracks state for calling code */
  31 static tap_state_t dummy_state = TAP_RESET;
  32
  33 static int dummy_clock;         /* edge detector */
  34
  35 static tap_state_t tap_state_transition(tap_state_t cur_state, int tms);
  36
  37
  38 int dummy_speed(int speed);
  39 int dummy_register_commands(struct command_context_s *cmd_ctx);
  40 int dummy_init(void);
  41 int dummy_quit(void);
  42 static int dummy_khz(int khz, int *jtag_speed);
  43 static int dummy_speed_div(int speed, int *khz);
  44
  45
  46 /* The dummy driver is used to easily check the code path
  47  * where the target is unresponsive.
  48  */
  49 jtag_interface_t dummy_interface =
  50 {
  51         .name = "dummy",
  52
  53         .execute_queue = bitbang_execute_queue,
  54
  55         .speed = dummy_speed,
  56         .register_commands = dummy_register_commands,
  57         .khz = dummy_khz,
  58         .speed_div = dummy_speed_div,
  59
  60         .init = dummy_init,
  61         .quit = dummy_quit,
  62 };
  63
  64 int dummy_read(void);
  65 void dummy_write(int tck, int tms, int tdi);
  66 void dummy_reset(int trst, int srst);
  67 void dummy_led(int on);
  68
  69 bitbang_interface_t dummy_bitbang =
  70 {
  71         .read = dummy_read,
  72         .write = dummy_write,
  73         .reset = dummy_reset,
  74         .blink = dummy_led
  75 };
  76
  77 int dummy_read(void)
  78 {
  79         return 1;
  80 }
  81
  82
  83 void dummy_write(int tck, int tms, int tdi)
  84 {
  85         /* TAP standard: "state transitions occur on rising edge of clock" */
  86         if( tck != dummy_clock )
  87         {
  88                 if( tck )
  89                 {
  90                         int old_state = dummy_state;
  91                         dummy_state = tap_state_transition( dummy_state, tms );
  92                         if( old_state != dummy_state )
  93                                 LOG_DEBUG( "dummy_tap=%s", jtag_state_name(dummy_state) );
  94                 }
  95                 dummy_clock = tck;
  96         }
  97 }
  98
  99 void dummy_reset(int trst, int srst)
 100 {
 101         dummy_clock = 0;
 102         dummy_state = TAP_RESET;
 103         LOG_DEBUG( "reset to %s", jtag_state_name(dummy_state) );
 104 }
 105
 106 static int dummy_khz(int khz, int *jtag_speed)
 107 {
 108         if (khz==0)
 109         {
 110                 *jtag_speed=0;
 111         }
 112         else
 113         {
 114                 *jtag_speed=64000/khz;
 115         }
 116         return ERROR_OK;
 117 }
 118
 119 static int dummy_speed_div(int speed, int *khz)
 120 {
 121         if (speed==0)
 122         {
 123                 *khz = 0;
 124         }
 125         else
 126         {
 127                 *khz=64000/speed;
 128         }
 129
 130         return ERROR_OK;
 131 }
 132
 133 int dummy_speed(int speed)
 134 {
 135         return ERROR_OK;
 136 }
 137
 138 int dummy_register_commands(struct command_context_s *cmd_ctx)
 139 {
 140         return ERROR_OK;
 141 }
 142
 143 int dummy_init(void)
 144 {
 145         bitbang_interface = &dummy_bitbang;
 146
 147         return ERROR_OK;
 148 }
 149
 150 int dummy_quit(void)
 151 {
 152         return ERROR_OK;
 153 }
 154
 155 void dummy_led(int on)
 156 {
 157 }
 158
 159
 160 /**
 161  * Function tap_state_transition
 162  * takes a current TAP state and returns the next state according to the tms value.
 163  *
 164  * Even though there is code to duplicate this elsewhere, we do it here a little
 165  * differently just to get a second opinion, i.e. a verification, on state tracking
 166  * in that other logic. Plus array lookups without index checking are no favorite thing.
 167  * This is educational for developers new to TAP controllers.
 168  */
 169 static tap_state_t tap_state_transition(tap_state_t cur_state, int tms)
 170 {
 171         tap_state_t new_state;
 172
 173         if (tms)
 174         {
 175                 switch (cur_state)
 176                 {
 177                 case TAP_RESET:
 178                         new_state = cur_state;
 179                         break;
 180                 case TAP_IDLE:
 181                 case TAP_DRUPDATE:
 182                 case TAP_IRUPDATE:
 183                         new_state = TAP_DRSELECT;
 184                         break;
 185                 case TAP_DRSELECT:
 186                         new_state = TAP_IRSELECT;
 187                         break;
 188                 case TAP_DRCAPTURE:
 189                 case TAP_DRSHIFT:
 190                         new_state = TAP_DREXIT1;
 191                         break;
 192                 case TAP_DREXIT1:
 193                 case TAP_DREXIT2:
 194                         new_state = TAP_DRUPDATE;
 195                         break;
 196                 case TAP_DRPAUSE:
 197                         new_state = TAP_DREXIT2;
 198                         break;
 199                 case TAP_IRSELECT:
 200                         new_state = TAP_RESET;
 201                         break;
 202                 case TAP_IRCAPTURE:
 203                 case TAP_IRSHIFT:
 204                         new_state = TAP_IREXIT1;
 205                         break;
 206                 case TAP_IREXIT1:
 207                 case TAP_IREXIT2:
 208                         new_state = TAP_IRUPDATE;
 209                         break;
 210                 case TAP_IRPAUSE:
 211                         new_state = TAP_IREXIT2;
 212                         break;
 213                 default:
 214                         LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
 215                         exit(1);
 216                         break;
 217                 }
 218         }
 219         else
 220         {
 221                 switch (cur_state)
 222                 {
 223                 case TAP_RESET:
 224                 case TAP_IDLE:
 225                 case TAP_DRUPDATE:
 226                 case TAP_IRUPDATE:
 227                         new_state = TAP_IDLE;
 228                         break;
 229                 case TAP_DRSELECT:
 230                         new_state = TAP_DRCAPTURE;
 231                         break;
 232                 case TAP_DRCAPTURE:
 233                 case TAP_DRSHIFT:
 234                 case TAP_DREXIT2:
 235                         new_state = TAP_DRSHIFT;
 236                         break;
 237                 case TAP_DREXIT1:
 238                 case TAP_DRPAUSE:
 239                         new_state = TAP_DRPAUSE;
 240                         break;
 241                 case TAP_IRSELECT:
 242                         new_state = TAP_IRCAPTURE;
 243                         break;
 244                 case TAP_IRCAPTURE:
 245                 case TAP_IRSHIFT:
 246                 case TAP_IREXIT2:
 247                         new_state = TAP_IRSHIFT;
 248                         break;
 249                 case TAP_IREXIT1:
 250                 case TAP_IRPAUSE:
 251                         new_state = TAP_IRPAUSE;
 252                         break;
 253                 default:
 254                         LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
 255                         exit(1);
 256                         break;
 257                 }
 258         }
 259
 260         return new_state;
 261 }