src/target/adi_v5_cmsis_dap.c

   1 /***************************************************************************
   2  *   Copyright (C) 2013 by mike brown                                      *
   3  *   mike@theshedworks.org.uk                                              *
   4  *                                                                         *
   5  *   Copyright (C) 2013 by Spencer Oliver                                  *
   6  *   spen@spen-soft.co.uk                                                  *
   7  *                                                                         *
   8  *   This program is free software; you can redistribute it and/or modify  *
   9  *   it under the terms of the GNU General Public License as published by  *
  10  *   the Free Software Foundation; either version 2 of the License, or     *
  11  *   (at your option) any later version.                                   *
  12  *                                                                         *
  13  *   This program is distributed in the hope that it will be useful,       *
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  16  *   GNU General Public License for more details.                          *
  17  *                                                                         *
  18  *   You should have received a copy of the GNU General Public License     *
  19  *   along with this program; if not, write to the                         *
  20  *   Free Software Foundation, Inc.,                                       *
  21  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  22  ***************************************************************************/
  23
  24 /**
  25  * @file
  26  * Utilities to support ARM "CMSIS-DAP", The CoreSight Debug Access Port.
  27  * This is coupled to recent versions of ARM's "CoreSight" debug framework.
  28  * This specific code is a transport level interface, with
  29  * "target/arm_adi_v5.[hc]" code understanding operation semantics,
  30  * shared with the SWD & JTAG transports.
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include "arm.h"
  38 #include "arm_adi_v5.h"
  39 #include <helper/time_support.h>
  40
  41 #include <transport/transport.h>
  42 #include <jtag/interface.h>
  43
  44 #include <jtag/swd.h>
  45
  46 #define CMSIS_CMD_DP            (0   << 0)    /* set only for AP access */
  47 #define CMSIS_CMD_AP            (1   << 0)    /* set only for AP access */
  48 #define CMSIS_CMD_READ          (1   << 1)    /* set only for read access */
  49 #define CMSIS_CMD_WRITE         (0   << 1)    /* set only for read access */
  50 #define CMSIS_CMD_A32(n)        ((n)&0x0C)    /* bits A[3:2] of register addr */
  51 #define CMSIS_CMD_VAL_MATCH     (1   << 4)    /* Value Match */
  52 #define CMSIS_CMD_MATCH_MSK     (1   << 5)    /* Match Mask */
  53
  54 /* YUK! - but this is currently a global.... */
  55 extern struct jtag_interface *jtag_interface;
  56
  57 static int (cmsis_dap_queue_ap_abort)(struct adiv5_dap *dap, uint8_t *ack)
  58 {
  59         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_ap_abort");
  60
  61         /* FIXME: implement this properly cmsis-dap has DAP_WriteABORT()
  62          * for now just hack @ everything */
  63         return jtag_interface->swd->write_reg(
  64                         (CMSIS_CMD_DP | CMSIS_CMD_WRITE | CMSIS_CMD_A32(DP_ABORT)), 0x1e);
  65 }
  66
  67 static int cmsis_dap_queue_dp_read(struct adiv5_dap *dap, unsigned reg, uint32_t *data)
  68 {
  69         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_dp_read %d", reg);
  70
  71         int retval = jtag_interface->swd->read_reg(
  72                         (CMSIS_CMD_DP | CMSIS_CMD_READ | CMSIS_CMD_A32(reg)), data);
  73
  74         if (retval != ERROR_OK) {
  75                 /* fault response */
  76                 uint8_t ack = retval & 0xff;
  77                 cmsis_dap_queue_ap_abort(dap, &ack);
  78         }
  79
  80         return retval;
  81 }
  82
  83 static int cmsis_dap_queue_idcode_read(struct adiv5_dap *dap, uint8_t *ack, uint32_t *data)
  84 {
  85         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_idcode_read");
  86
  87         int retval = cmsis_dap_queue_dp_read(dap, DP_IDCODE, data);
  88         if (retval != ERROR_OK)
  89                 return retval;
  90
  91         *ack = retval;
  92
  93         return ERROR_OK;
  94 }
  95
  96 static int (cmsis_dap_queue_dp_write)(struct adiv5_dap *dap, unsigned reg, uint32_t data)
  97 {
  98         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_dp_write %d 0x%08" PRIx32, reg, data);
  99
 100         /* setting the ORUNDETECT bit causes issues for some targets,
 101          * disable until we find out why */
 102         if (reg == DP_CTRL_STAT) {
 103                 LOG_DEBUG("disabling overrun detection");
 104                 data &= ~CORUNDETECT;
 105         }
 106
 107         int retval = jtag_interface->swd->write_reg(
 108                         (CMSIS_CMD_DP | CMSIS_CMD_WRITE | CMSIS_CMD_A32(reg)), data);
 109
 110         if (retval != ERROR_OK) {
 111                 /* fault response */
 112                 uint8_t ack = retval & 0xff;
 113                 cmsis_dap_queue_ap_abort(dap, &ack);
 114         }
 115
 116         return retval;
 117 }
 118
 119 /** Select the AP register bank matching bits 7:4 of reg. */
 120 static int cmsis_dap_ap_q_bankselect(struct adiv5_dap *dap, unsigned reg)
 121 {
 122         uint32_t select_ap_bank = reg & 0x000000F0;
 123
 124         if (select_ap_bank == dap->ap_bank_value)
 125                 return ERROR_OK;
 126
 127         dap->ap_bank_value = select_ap_bank;
 128         select_ap_bank |= dap->ap_current;
 129
 130         return cmsis_dap_queue_dp_write(dap, DP_SELECT, select_ap_bank);
 131 }
 132
 133 static int (cmsis_dap_queue_ap_read)(struct adiv5_dap *dap, unsigned reg, uint32_t *data)
 134 {
 135         int retval = cmsis_dap_ap_q_bankselect(dap, reg);
 136         if (retval != ERROR_OK)
 137                 return retval;
 138
 139         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_ap_read %d", reg);
 140
 141         retval = jtag_interface->swd->read_reg(
 142                         (CMSIS_CMD_AP | CMSIS_CMD_READ | CMSIS_CMD_A32(reg)), data);
 143
 144         if (retval != ERROR_OK) {
 145                 /* fault response */
 146                 uint8_t ack = retval & 0xff;
 147                 cmsis_dap_queue_ap_abort(dap, &ack);
 148         }
 149
 150         return retval;
 151 }
 152
 153 static int (cmsis_dap_queue_ap_write)(struct adiv5_dap *dap, unsigned reg, uint32_t data)
 154 {
 155
 156
 157         /* TODO: CSW_DBGSWENABLE (bit31) causes issues for some targets
 158          * disable until we find out why */
 159         if (reg == AP_REG_CSW)
 160                 data &= ~CSW_DBGSWENABLE;
 161
 162         int retval = cmsis_dap_ap_q_bankselect(dap, reg);
 163         if (retval != ERROR_OK)
 164                 return retval;
 165
 166         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_ap_write %d 0x%08" PRIx32, reg, data);
 167
 168         retval = jtag_interface->swd->write_reg(
 169                         (CMSIS_CMD_AP | CMSIS_CMD_WRITE | CMSIS_CMD_A32(reg)), data);
 170
 171         if (retval != ERROR_OK) {
 172                 /* fault response */
 173                 uint8_t ack = retval & 0xff;
 174                 cmsis_dap_queue_ap_abort(dap, &ack);
 175         }
 176
 177         return retval;
 178 }
 179
 180 static int (cmsis_dap_queue_ap_read_block)(struct adiv5_dap *dap, unsigned reg,
 181                 uint32_t blocksize, uint8_t *buffer)
 182 {
 183         LOG_DEBUG("CMSIS-ADI: cmsis_dap_queue_ap_read_block 0x%08" PRIx32, blocksize);
 184
 185         int retval = jtag_interface->swd->read_block(
 186                         (CMSIS_CMD_AP | CMSIS_CMD_READ | CMSIS_CMD_A32(AP_REG_DRW)),
 187                         blocksize, buffer);
 188
 189         if (retval != ERROR_OK) {
 190                 /* fault response */
 191                 uint8_t ack = retval & 0xff;
 192                 cmsis_dap_queue_ap_abort(dap, &ack);
 193         }
 194
 195         return retval;
 196 }
 197
 198 /** Executes all queued DAP operations. */
 199 static int cmsis_dap_run(struct adiv5_dap *dap)
 200 {
 201         LOG_DEBUG("CMSIS-ADI: cmsis_dap_run");
 202         /* FIXME: for now the CMSIS-DAP interface hard-wires a zero-size queue. */
 203
 204         return ERROR_OK;
 205 }
 206
 207 const struct dap_ops cmsis_dap_ops = {
 208         .is_swd = true,
 209         .queue_idcode_read   = cmsis_dap_queue_idcode_read,
 210         .queue_dp_read       = cmsis_dap_queue_dp_read,
 211         .queue_dp_write      = cmsis_dap_queue_dp_write,
 212         .queue_ap_read       = cmsis_dap_queue_ap_read,
 213         .queue_ap_write      = cmsis_dap_queue_ap_write,
 214         .queue_ap_read_block = cmsis_dap_queue_ap_read_block,
 215         .queue_ap_abort      = cmsis_dap_queue_ap_abort,
 216         .run = cmsis_dap_run,
 217 };
 218
 219 static const struct command_registration cmsis_dap_commands[] = {
 220         {
 221         /*
 222         * Set up SWD and JTAG targets identically, unless/until
 223         * infrastructure improves ...  meanwhile, ignore all
 224         * JTAG-specific stuff like IR length for SWD.
 225         *
 226         * REVISIT can we verify "just one SWD DAP" here/early?
 227         */
 228                 .name = "newdap",
 229                 .jim_handler = jim_jtag_newtap,
 230                 .mode = COMMAND_CONFIG,
 231                 .help = "declare a new CMSIS-DAP"
 232         },
 233         COMMAND_REGISTRATION_DONE
 234 };
 235
 236 static const struct command_registration cmsis_dap_handlers[] = {
 237         {
 238                 .name = "cmsis-dap",
 239                 .mode = COMMAND_ANY,
 240                 .help = "cmsis_dap command group",
 241                 .chain = cmsis_dap_commands,
 242         },
 243         COMMAND_REGISTRATION_DONE
 244 };
 245
 246 static int cmsis_dap_select(struct command_context *ctx)
 247 {
 248         LOG_DEBUG("CMSIS-ADI: cmsis_dap_select");
 249
 250         int retval = register_commands(ctx, NULL, cmsis_dap_handlers);
 251
 252         if (retval != ERROR_OK)
 253                 return retval;
 254
 255         /* FIXME: This needs a real overhaul!! FIXME
 256          * be sure driver is in SWD mode; start
 257          * with hardware default TRN (1), it can be changed later
 258          * we use a bogus 'swd' driver to implement cmsis-dap as it is quite similar */
 259
 260         const struct swd_driver *swd = jtag_interface->swd;
 261         if (!swd || !swd->read_reg || !swd->write_reg || !swd->init) {
 262                 LOG_ERROR("no SWD driver?");
 263                 return ERROR_FAIL;
 264         }
 265
 266         retval = swd->init(1);
 267         if (retval != ERROR_OK) {
 268                 LOG_ERROR("unable to init CMSIS-DAP driver");
 269                 return retval;
 270         }
 271
 272         return retval;
 273 }
 274
 275 static int cmsis_dap_init(struct command_context *ctx)
 276 {
 277         struct target *target = get_current_target(ctx);
 278         struct arm *arm = target_to_arm(target);
 279         struct adiv5_dap *dap = arm->dap;
 280         uint32_t idcode;
 281         int status;
 282
 283         LOG_DEBUG("CMSIS-ADI: cmsis_dap_init");
 284
 285         /* Force the DAP's ops vector for CMSIS-DAP mode.
 286          * messy - is there a better way? */
 287         arm->dap->ops = &cmsis_dap_ops;
 288
 289         /* FIXME validate transport config ... is the
 290          * configured DAP present (check IDCODE)?
 291          * Is *only* one DAP configured?
 292          *
 293          * MUST READ IDCODE
 294          */
 295
 296         /* Note, debugport_init() does setup too */
 297
 298 #if 0
 299         const struct swd_driver *swd = jtag_interface->swd;
 300         if (!swd || !swd->read_reg || !swd->write_reg || !swd->init) {
 301                 LOG_ERROR("no SWD driver?");
 302                 return ERROR_FAIL;
 303         }
 304
 305         int retval = swd->init(1);
 306         if (retval != ERROR_OK) {
 307                 LOG_ERROR("unable to init CMSIS-DAP driver");
 308                 return retval;
 309         }
 310 #endif
 311
 312         uint8_t ack;
 313
 314         status = cmsis_dap_queue_idcode_read(dap, &ack, &idcode);
 315
 316         if (status == ERROR_OK)
 317                 LOG_INFO("IDCODE 0x%08" PRIx32, idcode);
 318
 319         /* force clear all sticky faults */
 320         cmsis_dap_queue_ap_abort(dap, &ack);
 321
 322         /* this is a workaround to get polling working */
 323         jtag_add_reset(0, 0);
 324
 325         return status;
 326 }
 327
 328 static struct transport cmsis_dap_transport = {
 329         .name = "cmsis-dap",
 330         .select = cmsis_dap_select,
 331         .init = cmsis_dap_init,
 332 };
 333
 334 static void cmsis_dap_constructor(void) __attribute__((constructor));
 335 static void cmsis_dap_constructor(void)
 336 {
 337         transport_register(&cmsis_dap_transport);
 338 }
 339
 340 /** Returns true if the current debug session
 341  * is using CMSIS-DAP as its transport.
 342  */
 343 bool transport_is_cmsis_dap(void)
 344 {
 345         return get_current_transport() == &cmsis_dap_transport;
 346 }