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 "interface.h"
  25 #include "bitbang.h"
  26
  27
  28 /* my private tap controller state, which tracks state for calling code */
  29 static tap_state_t dummy_state = TAP_RESET;
  30
  31 static int dummy_clock;         /* edge detector */
  32
  33 static int clock_count;         /* count clocks in any stable state, only stable states */
  34
  35 static uint32_t dummy_data;
  36
  37
  38 static int dummy_speed(int speed);
  39 static int dummy_register_commands(struct command_context_s *cmd_ctx);
  40 static int dummy_init(void);
  41 static 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 static int dummy_read(void);
  65 static void dummy_write(int tck, int tms, int tdi);
  66 static void dummy_reset(int trst, int srst);
  67 static void dummy_led(int on);
  68
  69 static 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 static int dummy_read(void)
  78 {
  79         int data = 1 & dummy_data;
  80         dummy_data = (dummy_data >> 1) | (1 << 31);
  81         return data;
  82 }
  83
  84
  85 static void dummy_write(int tck, int tms, int tdi)
  86 {
  87         /* TAP standard: "state transitions occur on rising edge of clock" */
  88         if ( tck != dummy_clock )
  89         {
  90                 if ( tck )
  91                 {
  92                         tap_state_t old_state = dummy_state;
  93                         dummy_state = tap_state_transition( old_state, tms );
  94
  95                         if ( old_state != dummy_state )
  96                         {
  97                                 if ( clock_count )
  98                                 {
  99                                         LOG_DEBUG("dummy_tap: %d stable clocks", clock_count);
 100                                         clock_count = 0;
 101                                 }
 102
 103                                 LOG_DEBUG("dummy_tap: %s", tap_state_name(dummy_state) );
 104
 105 #if defined(DEBUG)
 106                                 if (dummy_state == TAP_DRCAPTURE)
 107                                         dummy_data = 0x01255043;
 108 #endif
 109                         }
 110                         else
 111                         {
 112                                 /* this is a stable state clock edge, no change of state here,
 113                                  * simply increment clock_count for subsequent logging
 114                                  */
 115                                 ++clock_count;
 116                         }
 117                 }
 118                 dummy_clock = tck;
 119         }
 120 }
 121
 122 static void dummy_reset(int trst, int srst)
 123 {
 124         dummy_clock = 0;
 125
 126         if (trst || (srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
 127                 dummy_state = TAP_RESET;
 128
 129         LOG_DEBUG("reset to: %s", tap_state_name(dummy_state) );
 130 }
 131
 132 static int dummy_khz(int khz, int *jtag_speed)
 133 {
 134         if (khz == 0)
 135         {
 136                 *jtag_speed = 0;
 137         }
 138         else
 139         {
 140                 *jtag_speed = 64000/khz;
 141         }
 142         return ERROR_OK;
 143 }
 144
 145 static int dummy_speed_div(int speed, int *khz)
 146 {
 147         if (speed == 0)
 148         {
 149                 *khz = 0;
 150         }
 151         else
 152         {
 153                 *khz = 64000/speed;
 154         }
 155
 156         return ERROR_OK;
 157 }
 158
 159 static int dummy_speed(int speed)
 160 {
 161         return ERROR_OK;
 162 }
 163
 164 static int dummy_register_commands(struct command_context_s *cmd_ctx)
 165 {
 166         return ERROR_OK;
 167 }
 168
 169 static int dummy_init(void)
 170 {
 171         bitbang_interface = &dummy_bitbang;
 172
 173         return ERROR_OK;
 174 }
 175
 176 static int dummy_quit(void)
 177 {
 178         return ERROR_OK;
 179 }
 180
 181 static void dummy_led(int on)
 182 {
 183 }
 184