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