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