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 #define INCLUDE_JTAG_INTERFACE_H
  25 #include "jtag.h"
  26 #include "bitbang.h"
  27
  28
  29 /* my private tap controller state, which tracks state for calling code */
  30 static tap_state_t dummy_state = TAP_RESET;
  31
  32 static int dummy_clock;         /* edge detector */
  33
  34 static int clock_count;         /* count clocks in any stable state, only stable states */
  35
  36 static u32 dummy_data;
  37
  38
  39 static int dummy_speed(int speed);
  40 static int dummy_register_commands(struct command_context_s *cmd_ctx);
  41 static int dummy_init(void);
  42 static int dummy_quit(void);
  43 static int dummy_khz(int khz, int *jtag_speed);
  44 static int dummy_speed_div(int speed, int *khz);
  45
  46
  47 /* The dummy driver is used to easily check the code path
  48  * where the target is unresponsive.
  49  */
  50 jtag_interface_t dummy_interface =
  51 {
  52         .name = "dummy",
  53
  54         .execute_queue = bitbang_execute_queue,
  55
  56         .speed = dummy_speed,
  57         .register_commands = dummy_register_commands,
  58         .khz = dummy_khz,
  59         .speed_div = dummy_speed_div,
  60
  61         .init = dummy_init,
  62         .quit = dummy_quit,
  63 };
  64
  65 static int dummy_read(void);
  66 static void dummy_write(int tck, int tms, int tdi);
  67 static void dummy_reset(int trst, int srst);
  68 static void dummy_led(int on);
  69
  70 static bitbang_interface_t dummy_bitbang =
  71 {
  72         .read = dummy_read,
  73         .write = dummy_write,
  74         .reset = dummy_reset,
  75         .blink = dummy_led
  76 };
  77
  78 static int dummy_read(void)
  79 {
  80         int data = 1 & dummy_data;
  81         dummy_data = (dummy_data >> 1) | (1<<31);
  82         return data;
  83 }
  84
  85
  86 static void dummy_write(int tck, int tms, int tdi)
  87 {
  88         /* TAP standard: "state transitions occur on rising edge of clock" */
  89         if( tck != dummy_clock )
  90         {
  91                 if( tck )
  92                 {
  93                         tap_state_t old_state = dummy_state;
  94                         dummy_state = tap_state_transition( old_state, tms );
  95
  96                         if( old_state != dummy_state )
  97                         {
  98                                 if( clock_count )
  99                                 {
 100                                         LOG_DEBUG("dummy_tap: %d stable clocks", clock_count);
 101                                         clock_count = 0;
 102                                 }
 103
 104                                 LOG_DEBUG("dummy_tap: %s", tap_state_name(dummy_state) );
 105
 106 #if defined(DEBUG)
 107                                 if(dummy_state == TAP_DRCAPTURE)
 108                                         dummy_data = 0x01255043;
 109 #endif
 110                         }
 111                         else
 112                         {
 113                                 /* this is a stable state clock edge, no change of state here,
 114                                  * simply increment clock_count for subsequent logging
 115                                  */
 116                                 ++clock_count;
 117                         }
 118                 }
 119                 dummy_clock = tck;
 120         }
 121 }
 122
 123 static void dummy_reset(int trst, int srst)
 124 {
 125         dummy_clock = 0;
 126
 127         if (trst || (srst && (jtag_reset_config & RESET_SRST_PULLS_TRST)))
 128                 dummy_state = TAP_RESET;
 129
 130         LOG_DEBUG("reset to: %s", tap_state_name(dummy_state) );
 131 }
 132
 133 static int dummy_khz(int khz, int *jtag_speed)
 134 {
 135         if (khz==0)
 136         {
 137                 *jtag_speed=0;
 138         }
 139         else
 140         {
 141                 *jtag_speed=64000/khz;
 142         }
 143         return ERROR_OK;
 144 }
 145
 146 static int dummy_speed_div(int speed, int *khz)
 147 {
 148         if (speed==0)
 149         {
 150                 *khz = 0;
 151         }
 152         else
 153         {
 154                 *khz=64000/speed;
 155         }
 156
 157         return ERROR_OK;
 158 }
 159
 160 static int dummy_speed(int speed)
 161 {
 162         return ERROR_OK;
 163 }
 164
 165 static int dummy_register_commands(struct command_context_s *cmd_ctx)
 166 {
 167         return ERROR_OK;
 168 }
 169
 170 static int dummy_init(void)
 171 {
 172         bitbang_interface = &dummy_bitbang;
 173
 174         return ERROR_OK;
 175 }
 176
 177 static int dummy_quit(void)
 178 {
 179         return ERROR_OK;
 180 }
 181
 182 static void dummy_led(int on)
 183 {
 184 }
 185