git.gag.com Git - fw/openocd/blob - src/target/arm_adi_v5.c

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Magnus Lundin                                   *
   3  *   lundin@mlu.mine.nu                                                    *
   4  *                                                                         *
   5  *   Copyright (C) 2008 by Spencer Oliver                                  *
   6  *   spen@spen-soft.co.uk                                                  *
   7  *                                                                         *
   8  *   Copyright (C) 2009-2010 by Oyvind Harboe                              *
   9  *   oyvind.harboe@zylin.com                                               *
  10  *                                                                         *
  11  *   Copyright (C) 2009-2010 by David Brownell                             *
  12  *                                                                         *
  13  *   Copyright (C) 2013 by Andreas Fritiofson                              *
  14  *   andreas.fritiofson@gmail.com                                          *
  15  *                                                                         *
  16  *   Copyright (C) 2019-2021, Ampere Computing LLC                         *
  17  *                                                                         *
  18  *   This program is free software; you can redistribute it and/or modify  *
  19  *   it under the terms of the GNU General Public License as published by  *
  20  *   the Free Software Foundation; either version 2 of the License, or     *
  21  *   (at your option) any later version.                                   *
  22  *                                                                         *
  23  *   This program is distributed in the hope that it will be useful,       *
  24  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  25  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  26  *   GNU General Public License for more details.                          *
  27  *                                                                         *
  28  *   You should have received a copy of the GNU General Public License     *
  29  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  30  ***************************************************************************/
  31
  32 /**
  33  * @file
  34  * This file implements support for the ARM Debug Interface version 5 (ADIv5)
  35  * debugging architecture.  Compared with previous versions, this includes
  36  * a low pin-count Serial Wire Debug (SWD) alternative to JTAG for message
  37  * transport, and focuses on memory mapped resources as defined by the
  38  * CoreSight architecture.
  39  *
  40  * A key concept in ADIv5 is the Debug Access Port, or DAP.  A DAP has two
  41  * basic components:  a Debug Port (DP) transporting messages to and from a
  42  * debugger, and an Access Port (AP) accessing resources.  Three types of DP
  43  * are defined.  One uses only JTAG for communication, and is called JTAG-DP.
  44  * One uses only SWD for communication, and is called SW-DP.  The third can
  45  * use either SWD or JTAG, and is called SWJ-DP.  The most common type of AP
  46  * is used to access memory mapped resources and is called a MEM-AP.  Also a
  47  * JTAG-AP is also defined, bridging to JTAG resources; those are uncommon.
  48  *
  49  * This programming interface allows DAP pipelined operations through a
  50  * transaction queue.  This primarily affects AP operations (such as using
  51  * a MEM-AP to access memory or registers).  If the current transaction has
  52  * not finished by the time the next one must begin, and the ORUNDETECT bit
  53  * is set in the DP_CTRL_STAT register, the SSTICKYORUN status is set and
  54  * further AP operations will fail.  There are two basic methods to avoid
  55  * such overrun errors.  One involves polling for status instead of using
  56  * transaction pipelining.  The other involves adding delays to ensure the
  57  * AP has enough time to complete one operation before starting the next
  58  * one.  (For JTAG these delays are controlled by memaccess_tck.)
  59  */
  60
  61 /*
  62  * Relevant specifications from ARM include:
  63  *
  64  * ARM(tm) Debug Interface v5 Architecture Specification    ARM IHI 0031E
  65  * CoreSight(tm) v1.0 Architecture Specification            ARM IHI 0029B
  66  *
  67  * CoreSight(tm) DAP-Lite TRM, ARM DDI 0316D
  68  * Cortex-M3(tm) TRM, ARM DDI 0337G
  69  */
  70
  71 #ifdef HAVE_CONFIG_H
  72 #include "config.h"
  73 #endif
  74
  75 #include "jtag/interface.h"
  76 #include "arm.h"
  77 #include "arm_adi_v5.h"
  78 #include "jtag/swd.h"
  79 #include "transport/transport.h"
  80 #include <helper/jep106.h>
  81 #include <helper/time_support.h>
  82 #include <helper/list.h>
  83 #include <helper/jim-nvp.h>
  84
  85 /* ARM ADI Specification requires at least 10 bits used for TAR autoincrement  */
  86
  87 /*
  88         uint32_t tar_block_size(uint32_t address)
  89         Return the largest block starting at address that does not cross a tar block size alignment boundary
  90 */
  91 static uint32_t max_tar_block_size(uint32_t tar_autoincr_block, target_addr_t address)
  92 {
  93         return tar_autoincr_block - ((tar_autoincr_block - 1) & address);
  94 }
  95
  96 /***************************************************************************
  97  *                                                                         *
  98  * DP and MEM-AP  register access  through APACC and DPACC                 *
  99  *                                                                         *
 100 ***************************************************************************/
 101
 102 static int mem_ap_setup_csw(struct adiv5_ap *ap, uint32_t csw)
 103 {
 104         csw |= ap->csw_default;
 105
 106         if (csw != ap->csw_value) {
 107                 /* LOG_DEBUG("DAP: Set CSW %x",csw); */
 108                 int retval = dap_queue_ap_write(ap, MEM_AP_REG_CSW, csw);
 109                 if (retval != ERROR_OK) {
 110                         ap->csw_value = 0;
 111                         return retval;
 112                 }
 113                 ap->csw_value = csw;
 114         }
 115         return ERROR_OK;
 116 }
 117
 118 static int mem_ap_setup_tar(struct adiv5_ap *ap, target_addr_t tar)
 119 {
 120         if (!ap->tar_valid || tar != ap->tar_value) {
 121                 /* LOG_DEBUG("DAP: Set TAR %x",tar); */
 122                 int retval = dap_queue_ap_write(ap, MEM_AP_REG_TAR, (uint32_t)(tar & 0xffffffffUL));
 123                 if (retval == ERROR_OK && is_64bit_ap(ap)) {
 124                         /* See if bits 63:32 of tar is different from last setting */
 125                         if ((ap->tar_value >> 32) != (tar >> 32))
 126                                 retval = dap_queue_ap_write(ap, MEM_AP_REG_TAR64, (uint32_t)(tar >> 32));
 127                 }
 128                 if (retval != ERROR_OK) {
 129                         ap->tar_valid = false;
 130                         return retval;
 131                 }
 132                 ap->tar_value = tar;
 133                 ap->tar_valid = true;
 134         }
 135         return ERROR_OK;
 136 }
 137
 138 static int mem_ap_read_tar(struct adiv5_ap *ap, target_addr_t *tar)
 139 {
 140         uint32_t lower;
 141         uint32_t upper = 0;
 142
 143         int retval = dap_queue_ap_read(ap, MEM_AP_REG_TAR, &lower);
 144         if (retval == ERROR_OK && is_64bit_ap(ap))
 145                 retval = dap_queue_ap_read(ap, MEM_AP_REG_TAR64, &upper);
 146
 147         if (retval != ERROR_OK) {
 148                 ap->tar_valid = false;
 149                 return retval;
 150         }
 151
 152         retval = dap_run(ap->dap);
 153         if (retval != ERROR_OK) {
 154                 ap->tar_valid = false;
 155                 return retval;
 156         }
 157
 158         *tar = (((target_addr_t)upper) << 32) | (target_addr_t)lower;
 159
 160         ap->tar_value = *tar;
 161         ap->tar_valid = true;
 162         return ERROR_OK;
 163 }
 164
 165 static uint32_t mem_ap_get_tar_increment(struct adiv5_ap *ap)
 166 {
 167         switch (ap->csw_value & CSW_ADDRINC_MASK) {
 168         case CSW_ADDRINC_SINGLE:
 169                 switch (ap->csw_value & CSW_SIZE_MASK) {
 170                 case CSW_8BIT:
 171                         return 1;
 172                 case CSW_16BIT:
 173                         return 2;
 174                 case CSW_32BIT:
 175                         return 4;
 176                 default:
 177                         return 0;
 178                 }
 179         case CSW_ADDRINC_PACKED:
 180                 return 4;
 181         }
 182         return 0;
 183 }
 184
 185 /* mem_ap_update_tar_cache is called after an access to MEM_AP_REG_DRW
 186  */
 187 static void mem_ap_update_tar_cache(struct adiv5_ap *ap)
 188 {
 189         if (!ap->tar_valid)
 190                 return;
 191
 192         uint32_t inc = mem_ap_get_tar_increment(ap);
 193         if (inc >= max_tar_block_size(ap->tar_autoincr_block, ap->tar_value))
 194                 ap->tar_valid = false;
 195         else
 196                 ap->tar_value += inc;
 197 }
 198
 199 /**
 200  * Queue transactions setting up transfer parameters for the
 201  * currently selected MEM-AP.
 202  *
 203  * Subsequent transfers using registers like MEM_AP_REG_DRW or MEM_AP_REG_BD2
 204  * initiate data reads or writes using memory or peripheral addresses.
 205  * If the CSW is configured for it, the TAR may be automatically
 206  * incremented after each transfer.
 207  *
 208  * @param ap The MEM-AP.
 209  * @param csw MEM-AP Control/Status Word (CSW) register to assign.  If this
 210  *      matches the cached value, the register is not changed.
 211  * @param tar MEM-AP Transfer Address Register (TAR) to assign.  If this
 212  *      matches the cached address, the register is not changed.
 213  *
 214  * @return ERROR_OK if the transaction was properly queued, else a fault code.
 215  */
 216 static int mem_ap_setup_transfer(struct adiv5_ap *ap, uint32_t csw, target_addr_t tar)
 217 {
 218         int retval;
 219         retval = mem_ap_setup_csw(ap, csw);
 220         if (retval != ERROR_OK)
 221                 return retval;
 222         retval = mem_ap_setup_tar(ap, tar);
 223         if (retval != ERROR_OK)
 224                 return retval;
 225         return ERROR_OK;
 226 }
 227
 228 /**
 229  * Asynchronous (queued) read of a word from memory or a system register.
 230  *
 231  * @param ap The MEM-AP to access.
 232  * @param address Address of the 32-bit word to read; it must be
 233  *      readable by the currently selected MEM-AP.
 234  * @param value points to where the word will be stored when the
 235  *      transaction queue is flushed (assuming no errors).
 236  *
 237  * @return ERROR_OK for success.  Otherwise a fault code.
 238  */
 239 int mem_ap_read_u32(struct adiv5_ap *ap, target_addr_t address,
 240                 uint32_t *value)
 241 {
 242         int retval;
 243
 244         /* Use banked addressing (REG_BDx) to avoid some link traffic
 245          * (updating TAR) when reading several consecutive addresses.
 246          */
 247         retval = mem_ap_setup_transfer(ap,
 248                         CSW_32BIT | (ap->csw_value & CSW_ADDRINC_MASK),
 249                         address & 0xFFFFFFFFFFFFFFF0ull);
 250         if (retval != ERROR_OK)
 251                 return retval;
 252
 253         return dap_queue_ap_read(ap, MEM_AP_REG_BD0 | (address & 0xC), value);
 254 }
 255
 256 /**
 257  * Synchronous read of a word from memory or a system register.
 258  * As a side effect, this flushes any queued transactions.
 259  *
 260  * @param ap The MEM-AP to access.
 261  * @param address Address of the 32-bit word to read; it must be
 262  *      readable by the currently selected MEM-AP.
 263  * @param value points to where the result will be stored.
 264  *
 265  * @return ERROR_OK for success; *value holds the result.
 266  * Otherwise a fault code.
 267  */
 268 int mem_ap_read_atomic_u32(struct adiv5_ap *ap, target_addr_t address,
 269                 uint32_t *value)
 270 {
 271         int retval;
 272
 273         retval = mem_ap_read_u32(ap, address, value);
 274         if (retval != ERROR_OK)
 275                 return retval;
 276
 277         return dap_run(ap->dap);
 278 }
 279
 280 /**
 281  * Asynchronous (queued) write of a word to memory or a system register.
 282  *
 283  * @param ap The MEM-AP to access.
 284  * @param address Address to be written; it must be writable by
 285  *      the currently selected MEM-AP.
 286  * @param value Word that will be written to the address when transaction
 287  *      queue is flushed (assuming no errors).
 288  *
 289  * @return ERROR_OK for success.  Otherwise a fault code.
 290  */
 291 int mem_ap_write_u32(struct adiv5_ap *ap, target_addr_t address,
 292                 uint32_t value)
 293 {
 294         int retval;
 295
 296         /* Use banked addressing (REG_BDx) to avoid some link traffic
 297          * (updating TAR) when writing several consecutive addresses.
 298          */
 299         retval = mem_ap_setup_transfer(ap,
 300                         CSW_32BIT | (ap->csw_value & CSW_ADDRINC_MASK),
 301                         address & 0xFFFFFFFFFFFFFFF0ull);
 302         if (retval != ERROR_OK)
 303                 return retval;
 304
 305         return dap_queue_ap_write(ap, MEM_AP_REG_BD0 | (address & 0xC),
 306                         value);
 307 }
 308
 309 /**
 310  * Synchronous write of a word to memory or a system register.
 311  * As a side effect, this flushes any queued transactions.
 312  *
 313  * @param ap The MEM-AP to access.
 314  * @param address Address to be written; it must be writable by
 315  *      the currently selected MEM-AP.
 316  * @param value Word that will be written.
 317  *
 318  * @return ERROR_OK for success; the data was written.  Otherwise a fault code.
 319  */
 320 int mem_ap_write_atomic_u32(struct adiv5_ap *ap, target_addr_t address,
 321                 uint32_t value)
 322 {
 323         int retval = mem_ap_write_u32(ap, address, value);
 324
 325         if (retval != ERROR_OK)
 326                 return retval;
 327
 328         return dap_run(ap->dap);
 329 }
 330
 331 /**
 332  * Synchronous write of a block of memory, using a specific access size.
 333  *
 334  * @param ap The MEM-AP to access.
 335  * @param buffer The data buffer to write. No particular alignment is assumed.
 336  * @param size Which access size to use, in bytes. 1, 2 or 4.
 337  * @param count The number of writes to do (in size units, not bytes).
 338  * @param address Address to be written; it must be writable by the currently selected MEM-AP.
 339  * @param addrinc Whether the target address should be increased for each write or not. This
 340  *  should normally be true, except when writing to e.g. a FIFO.
 341  * @return ERROR_OK on success, otherwise an error code.
 342  */
 343 static int mem_ap_write(struct adiv5_ap *ap, const uint8_t *buffer, uint32_t size, uint32_t count,
 344                 target_addr_t address, bool addrinc)
 345 {
 346         struct adiv5_dap *dap = ap->dap;
 347         size_t nbytes = size * count;
 348         const uint32_t csw_addrincr = addrinc ? CSW_ADDRINC_SINGLE : CSW_ADDRINC_OFF;
 349         uint32_t csw_size;
 350         target_addr_t addr_xor;
 351         int retval = ERROR_OK;
 352
 353         /* TI BE-32 Quirks mode:
 354          * Writes on big-endian TMS570 behave very strangely. Observed behavior:
 355          *   size   write address   bytes written in order
 356          *   4      TAR ^ 0         (val >> 24), (val >> 16), (val >> 8), (val)
 357          *   2      TAR ^ 2         (val >> 8), (val)
 358          *   1      TAR ^ 3         (val)
 359          * For example, if you attempt to write a single byte to address 0, the processor
 360          * will actually write a byte to address 3.
 361          *
 362          * To make writes of size < 4 work as expected, we xor a value with the address before
 363          * setting the TAP, and we set the TAP after every transfer rather then relying on
 364          * address increment. */
 365
 366         if (size == 4) {
 367                 csw_size = CSW_32BIT;
 368                 addr_xor = 0;
 369         } else if (size == 2) {
 370                 csw_size = CSW_16BIT;
 371                 addr_xor = dap->ti_be_32_quirks ? 2 : 0;
 372         } else if (size == 1) {
 373                 csw_size = CSW_8BIT;
 374                 addr_xor = dap->ti_be_32_quirks ? 3 : 0;
 375         } else {
 376                 return ERROR_TARGET_UNALIGNED_ACCESS;
 377         }
 378
 379         if (ap->unaligned_access_bad && (address % size != 0))
 380                 return ERROR_TARGET_UNALIGNED_ACCESS;
 381
 382         while (nbytes > 0) {
 383                 uint32_t this_size = size;
 384
 385                 /* Select packed transfer if possible */
 386                 if (addrinc && ap->packed_transfers && nbytes >= 4
 387                                 && max_tar_block_size(ap->tar_autoincr_block, address) >= 4) {
 388                         this_size = 4;
 389                         retval = mem_ap_setup_csw(ap, csw_size | CSW_ADDRINC_PACKED);
 390                 } else {
 391                         retval = mem_ap_setup_csw(ap, csw_size | csw_addrincr);
 392                 }
 393
 394                 if (retval != ERROR_OK)
 395                         break;
 396
 397                 retval = mem_ap_setup_tar(ap, address ^ addr_xor);
 398                 if (retval != ERROR_OK)
 399                         return retval;
 400
 401                 /* How many source bytes each transfer will consume, and their location in the DRW,
 402                  * depends on the type of transfer and alignment. See ARM document IHI0031C. */
 403                 uint32_t outvalue = 0;
 404                 uint32_t drw_byte_idx = address;
 405                 if (dap->ti_be_32_quirks) {
 406                         switch (this_size) {
 407                         case 4:
 408                                 outvalue |= (uint32_t)*buffer++ << 8 * (3 ^ (drw_byte_idx++ & 3) ^ addr_xor);
 409                                 outvalue |= (uint32_t)*buffer++ << 8 * (3 ^ (drw_byte_idx++ & 3) ^ addr_xor);
 410                                 outvalue |= (uint32_t)*buffer++ << 8 * (3 ^ (drw_byte_idx++ & 3) ^ addr_xor);
 411                                 outvalue |= (uint32_t)*buffer++ << 8 * (3 ^ (drw_byte_idx & 3) ^ addr_xor);
 412                                 break;
 413                         case 2:
 414                                 outvalue |= (uint32_t)*buffer++ << 8 * (1 ^ (drw_byte_idx++ & 3) ^ addr_xor);
 415                                 outvalue |= (uint32_t)*buffer++ << 8 * (1 ^ (drw_byte_idx & 3) ^ addr_xor);
 416                                 break;
 417                         case 1:
 418                                 outvalue |= (uint32_t)*buffer++ << 8 * (0 ^ (drw_byte_idx & 3) ^ addr_xor);
 419                                 break;
 420                         }
 421                 } else {
 422                         switch (this_size) {
 423                         case 4:
 424                                 outvalue |= (uint32_t)*buffer++ << 8 * (drw_byte_idx++ & 3);
 425                                 outvalue |= (uint32_t)*buffer++ << 8 * (drw_byte_idx++ & 3);
 426                                 /* fallthrough */
 427                         case 2:
 428                                 outvalue |= (uint32_t)*buffer++ << 8 * (drw_byte_idx++ & 3);
 429                                 /* fallthrough */
 430                         case 1:
 431                                 outvalue |= (uint32_t)*buffer++ << 8 * (drw_byte_idx & 3);
 432                         }
 433                 }
 434
 435                 nbytes -= this_size;
 436
 437                 retval = dap_queue_ap_write(ap, MEM_AP_REG_DRW, outvalue);
 438                 if (retval != ERROR_OK)
 439                         break;
 440
 441                 mem_ap_update_tar_cache(ap);
 442                 if (addrinc)
 443                         address += this_size;
 444         }
 445
 446         /* REVISIT: Might want to have a queued version of this function that does not run. */
 447         if (retval == ERROR_OK)
 448                 retval = dap_run(dap);
 449
 450         if (retval != ERROR_OK) {
 451                 target_addr_t tar;
 452                 if (mem_ap_read_tar(ap, &tar) == ERROR_OK)
 453                         LOG_ERROR("Failed to write memory at " TARGET_ADDR_FMT, tar);
 454                 else
 455                         LOG_ERROR("Failed to write memory and, additionally, failed to find out where");
 456         }
 457
 458         return retval;
 459 }
 460
 461 /**
 462  * Synchronous read of a block of memory, using a specific access size.
 463  *
 464  * @param ap The MEM-AP to access.
 465  * @param buffer The data buffer to receive the data. No particular alignment is assumed.
 466  * @param size Which access size to use, in bytes. 1, 2 or 4.
 467  * @param count The number of reads to do (in size units, not bytes).
 468  * @param adr Address to be read; it must be readable by the currently selected MEM-AP.
 469  * @param addrinc Whether the target address should be increased after each read or not. This
 470  *  should normally be true, except when reading from e.g. a FIFO.
 471  * @return ERROR_OK on success, otherwise an error code.
 472  */
 473 static int mem_ap_read(struct adiv5_ap *ap, uint8_t *buffer, uint32_t size, uint32_t count,
 474                 target_addr_t adr, bool addrinc)
 475 {
 476         struct adiv5_dap *dap = ap->dap;
 477         size_t nbytes = size * count;
 478         const uint32_t csw_addrincr = addrinc ? CSW_ADDRINC_SINGLE : CSW_ADDRINC_OFF;
 479         uint32_t csw_size;
 480         target_addr_t address = adr;
 481         int retval = ERROR_OK;
 482
 483         /* TI BE-32 Quirks mode:
 484          * Reads on big-endian TMS570 behave strangely differently than writes.
 485          * They read from the physical address requested, but with DRW byte-reversed.
 486          * For example, a byte read from address 0 will place the result in the high bytes of DRW.
 487          * Also, packed 8-bit and 16-bit transfers seem to sometimes return garbage in some bytes,
 488          * so avoid them. */
 489
 490         if (size == 4)
 491                 csw_size = CSW_32BIT;
 492         else if (size == 2)
 493                 csw_size = CSW_16BIT;
 494         else if (size == 1)
 495                 csw_size = CSW_8BIT;
 496         else
 497                 return ERROR_TARGET_UNALIGNED_ACCESS;
 498
 499         if (ap->unaligned_access_bad && (adr % size != 0))
 500                 return ERROR_TARGET_UNALIGNED_ACCESS;
 501
 502         /* Allocate buffer to hold the sequence of DRW reads that will be made. This is a significant
 503          * over-allocation if packed transfers are going to be used, but determining the real need at
 504          * this point would be messy. */
 505         uint32_t *read_buf = calloc(count, sizeof(uint32_t));
 506         /* Multiplication count * sizeof(uint32_t) may overflow, calloc() is safe */
 507         uint32_t *read_ptr = read_buf;
 508         if (!read_buf) {
 509                 LOG_ERROR("Failed to allocate read buffer");
 510                 return ERROR_FAIL;
 511         }
 512
 513         /* Queue up all reads. Each read will store the entire DRW word in the read buffer. How many
 514          * useful bytes it contains, and their location in the word, depends on the type of transfer
 515          * and alignment. */
 516         while (nbytes > 0) {
 517                 uint32_t this_size = size;
 518
 519                 /* Select packed transfer if possible */
 520                 if (addrinc && ap->packed_transfers && nbytes >= 4
 521                                 && max_tar_block_size(ap->tar_autoincr_block, address) >= 4) {
 522                         this_size = 4;
 523                         retval = mem_ap_setup_csw(ap, csw_size | CSW_ADDRINC_PACKED);
 524                 } else {
 525                         retval = mem_ap_setup_csw(ap, csw_size | csw_addrincr);
 526                 }
 527                 if (retval != ERROR_OK)
 528                         break;
 529
 530                 retval = mem_ap_setup_tar(ap, address);
 531                 if (retval != ERROR_OK)
 532                         break;
 533
 534                 retval = dap_queue_ap_read(ap, MEM_AP_REG_DRW, read_ptr++);
 535                 if (retval != ERROR_OK)
 536                         break;
 537
 538                 nbytes -= this_size;
 539                 if (addrinc)
 540                         address += this_size;
 541
 542                 mem_ap_update_tar_cache(ap);
 543         }
 544
 545         if (retval == ERROR_OK)
 546                 retval = dap_run(dap);
 547
 548         /* Restore state */
 549         address = adr;
 550         nbytes = size * count;
 551         read_ptr = read_buf;
 552
 553         /* If something failed, read TAR to find out how much data was successfully read, so we can
 554          * at least give the caller what we have. */
 555         if (retval != ERROR_OK) {
 556                 target_addr_t tar;
 557                 if (mem_ap_read_tar(ap, &tar) == ERROR_OK) {
 558                         /* TAR is incremented after failed transfer on some devices (eg Cortex-M4) */
 559                         LOG_ERROR("Failed to read memory at " TARGET_ADDR_FMT, tar);
 560                         if (nbytes > tar - address)
 561                                 nbytes = tar - address;
 562                 } else {
 563                         LOG_ERROR("Failed to read memory and, additionally, failed to find out where");
 564                         nbytes = 0;
 565                 }
 566         }
 567
 568         /* Replay loop to populate caller's buffer from the correct word and byte lane */
 569         while (nbytes > 0) {
 570                 uint32_t this_size = size;
 571
 572                 if (addrinc && ap->packed_transfers && nbytes >= 4
 573                                 && max_tar_block_size(ap->tar_autoincr_block, address) >= 4) {
 574                         this_size = 4;
 575                 }
 576
 577                 if (dap->ti_be_32_quirks) {
 578                         switch (this_size) {
 579                         case 4:
 580                                 *buffer++ = *read_ptr >> 8 * (3 - (address++ & 3));
 581                                 *buffer++ = *read_ptr >> 8 * (3 - (address++ & 3));
 582                                 /* fallthrough */
 583                         case 2:
 584                                 *buffer++ = *read_ptr >> 8 * (3 - (address++ & 3));
 585                                 /* fallthrough */
 586                         case 1:
 587                                 *buffer++ = *read_ptr >> 8 * (3 - (address++ & 3));
 588                         }
 589                 } else {
 590                         switch (this_size) {
 591                         case 4:
 592                                 *buffer++ = *read_ptr >> 8 * (address++ & 3);
 593                                 *buffer++ = *read_ptr >> 8 * (address++ & 3);
 594                                 /* fallthrough */
 595                         case 2:
 596                                 *buffer++ = *read_ptr >> 8 * (address++ & 3);
 597                                 /* fallthrough */
 598                         case 1:
 599                                 *buffer++ = *read_ptr >> 8 * (address++ & 3);
 600                         }
 601                 }
 602
 603                 read_ptr++;
 604                 nbytes -= this_size;
 605         }
 606
 607         free(read_buf);
 608         return retval;
 609 }
 610
 611 int mem_ap_read_buf(struct adiv5_ap *ap,
 612                 uint8_t *buffer, uint32_t size, uint32_t count, target_addr_t address)
 613 {
 614         return mem_ap_read(ap, buffer, size, count, address, true);
 615 }
 616
 617 int mem_ap_write_buf(struct adiv5_ap *ap,
 618                 const uint8_t *buffer, uint32_t size, uint32_t count, target_addr_t address)
 619 {
 620         return mem_ap_write(ap, buffer, size, count, address, true);
 621 }
 622
 623 int mem_ap_read_buf_noincr(struct adiv5_ap *ap,
 624                 uint8_t *buffer, uint32_t size, uint32_t count, target_addr_t address)
 625 {
 626         return mem_ap_read(ap, buffer, size, count, address, false);
 627 }
 628
 629 int mem_ap_write_buf_noincr(struct adiv5_ap *ap,
 630                 const uint8_t *buffer, uint32_t size, uint32_t count, target_addr_t address)
 631 {
 632         return mem_ap_write(ap, buffer, size, count, address, false);
 633 }
 634
 635 /*--------------------------------------------------------------------------*/
 636
 637
 638 #define DAP_POWER_DOMAIN_TIMEOUT (10)
 639
 640 /*--------------------------------------------------------------------------*/
 641
 642 /**
 643  * Invalidate cached DP select and cached TAR and CSW of all APs
 644  */
 645 void dap_invalidate_cache(struct adiv5_dap *dap)
 646 {
 647         dap->select = DP_SELECT_INVALID;
 648         dap->last_read = NULL;
 649
 650         int i;
 651         for (i = 0; i <= 255; i++) {
 652                 /* force csw and tar write on the next mem-ap access */
 653                 dap->ap[i].tar_valid = false;
 654                 dap->ap[i].csw_value = 0;
 655         }
 656 }
 657
 658 /**
 659  * Initialize a DAP.  This sets up the power domains, prepares the DP
 660  * for further use and activates overrun checking.
 661  *
 662  * @param dap The DAP being initialized.
 663  */
 664 int dap_dp_init(struct adiv5_dap *dap)
 665 {
 666         int retval;
 667
 668         LOG_DEBUG("%s", adiv5_dap_name(dap));
 669
 670         dap->do_reconnect = false;
 671         dap_invalidate_cache(dap);
 672
 673         /*
 674          * Early initialize dap->dp_ctrl_stat.
 675          * In jtag mode only, if the following queue run (in dap_dp_poll_register)
 676          * fails and sets the sticky error, it will trigger the clearing
 677          * of the sticky. Without this initialization system and debug power
 678          * would be disabled while clearing the sticky error bit.
 679          */
 680         dap->dp_ctrl_stat = CDBGPWRUPREQ | CSYSPWRUPREQ;
 681
 682         /*
 683          * This write operation clears the sticky error bit in jtag mode only and
 684          * is ignored in swd mode. It also powers-up system and debug domains in
 685          * both jtag and swd modes, if not done before.
 686          */
 687         retval = dap_queue_dp_write(dap, DP_CTRL_STAT, dap->dp_ctrl_stat | SSTICKYERR);
 688         if (retval != ERROR_OK)
 689                 return retval;
 690
 691         retval = dap_queue_dp_read(dap, DP_CTRL_STAT, NULL);
 692         if (retval != ERROR_OK)
 693                 return retval;
 694
 695         retval = dap_queue_dp_write(dap, DP_CTRL_STAT, dap->dp_ctrl_stat);
 696         if (retval != ERROR_OK)
 697                 return retval;
 698
 699         /* Check that we have debug power domains activated */
 700         LOG_DEBUG("DAP: wait CDBGPWRUPACK");
 701         retval = dap_dp_poll_register(dap, DP_CTRL_STAT,
 702                                       CDBGPWRUPACK, CDBGPWRUPACK,
 703                                       DAP_POWER_DOMAIN_TIMEOUT);
 704         if (retval != ERROR_OK)
 705                 return retval;
 706
 707         if (!dap->ignore_syspwrupack) {
 708                 LOG_DEBUG("DAP: wait CSYSPWRUPACK");
 709                 retval = dap_dp_poll_register(dap, DP_CTRL_STAT,
 710                                               CSYSPWRUPACK, CSYSPWRUPACK,
 711                                               DAP_POWER_DOMAIN_TIMEOUT);
 712                 if (retval != ERROR_OK)
 713                         return retval;
 714         }
 715
 716         retval = dap_queue_dp_read(dap, DP_CTRL_STAT, NULL);
 717         if (retval != ERROR_OK)
 718                 return retval;
 719
 720         /* With debug power on we can activate OVERRUN checking */
 721         dap->dp_ctrl_stat = CDBGPWRUPREQ | CSYSPWRUPREQ | CORUNDETECT;
 722         retval = dap_queue_dp_write(dap, DP_CTRL_STAT, dap->dp_ctrl_stat);
 723         if (retval != ERROR_OK)
 724                 return retval;
 725         retval = dap_queue_dp_read(dap, DP_CTRL_STAT, NULL);
 726         if (retval != ERROR_OK)
 727                 return retval;
 728
 729         retval = dap_run(dap);
 730         if (retval != ERROR_OK)
 731                 return retval;
 732
 733         return retval;
 734 }
 735
 736 /**
 737  * Initialize a DAP or do reconnect if DAP is not accessible.
 738  *
 739  * @param dap The DAP being initialized.
 740  */
 741 int dap_dp_init_or_reconnect(struct adiv5_dap *dap)
 742 {
 743         LOG_DEBUG("%s", adiv5_dap_name(dap));
 744
 745         /*
 746          * Early initialize dap->dp_ctrl_stat.
 747          * In jtag mode only, if the following atomic reads fail and set the
 748          * sticky error, it will trigger the clearing of the sticky. Without this
 749          * initialization system and debug power would be disabled while clearing
 750          * the sticky error bit.
 751          */
 752         dap->dp_ctrl_stat = CDBGPWRUPREQ | CSYSPWRUPREQ;
 753
 754         dap->do_reconnect = false;
 755
 756         dap_dp_read_atomic(dap, DP_CTRL_STAT, NULL);
 757         if (dap->do_reconnect) {
 758                 /* dap connect calls dap_dp_init() after transport dependent initialization */
 759                 return dap->ops->connect(dap);
 760         } else {
 761                 return dap_dp_init(dap);
 762         }
 763 }
 764
 765 /**
 766  * Initialize a DAP.  This sets up the power domains, prepares the DP
 767  * for further use, and arranges to use AP #0 for all AP operations
 768  * until dap_ap-select() changes that policy.
 769  *
 770  * @param ap The MEM-AP being initialized.
 771  */
 772 int mem_ap_init(struct adiv5_ap *ap)
 773 {
 774         /* check that we support packed transfers */
 775         uint32_t csw, cfg;
 776         int retval;
 777         struct adiv5_dap *dap = ap->dap;
 778
 779         /* Set ap->cfg_reg before calling mem_ap_setup_transfer(). */
 780         /* mem_ap_setup_transfer() needs to know if the MEM_AP supports LPAE. */
 781         retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG, &cfg);
 782         if (retval != ERROR_OK)
 783                 return retval;
 784
 785         retval = dap_run(dap);
 786         if (retval != ERROR_OK)
 787                 return retval;
 788
 789         ap->cfg_reg = cfg;
 790         ap->tar_valid = false;
 791         ap->csw_value = 0;      /* force csw and tar write */
 792         retval = mem_ap_setup_transfer(ap, CSW_8BIT | CSW_ADDRINC_PACKED, 0);
 793         if (retval != ERROR_OK)
 794                 return retval;
 795
 796         retval = dap_queue_ap_read(ap, MEM_AP_REG_CSW, &csw);
 797         if (retval != ERROR_OK)
 798                 return retval;
 799
 800         retval = dap_run(dap);
 801         if (retval != ERROR_OK)
 802                 return retval;
 803
 804         if (csw & CSW_ADDRINC_PACKED)
 805                 ap->packed_transfers = true;
 806         else
 807                 ap->packed_transfers = false;
 808
 809         /* Packed transfers on TI BE-32 processors do not work correctly in
 810          * many cases. */
 811         if (dap->ti_be_32_quirks)
 812                 ap->packed_transfers = false;
 813
 814         LOG_DEBUG("MEM_AP Packed Transfers: %s",
 815                         ap->packed_transfers ? "enabled" : "disabled");
 816
 817         /* The ARM ADI spec leaves implementation-defined whether unaligned
 818          * memory accesses work, only work partially, or cause a sticky error.
 819          * On TI BE-32 processors, reads seem to return garbage in some bytes
 820          * and unaligned writes seem to cause a sticky error.
 821          * TODO: it would be nice to have a way to detect whether unaligned
 822          * operations are supported on other processors. */
 823         ap->unaligned_access_bad = dap->ti_be_32_quirks;
 824
 825         LOG_DEBUG("MEM_AP CFG: large data %d, long address %d, big-endian %d",
 826                         !!(cfg & MEM_AP_REG_CFG_LD), !!(cfg & MEM_AP_REG_CFG_LA), !!(cfg & MEM_AP_REG_CFG_BE));
 827
 828         return ERROR_OK;
 829 }
 830
 831 /**
 832  * Put the debug link into SWD mode, if the target supports it.
 833  * The link's initial mode may be either JTAG (for example,
 834  * with SWJ-DP after reset) or SWD.
 835  *
 836  * Note that targets using the JTAG-DP do not support SWD, and that
 837  * some targets which could otherwise support it may have been
 838  * configured to disable SWD signaling
 839  *
 840  * @param dap The DAP used
 841  * @return ERROR_OK or else a fault code.
 842  */
 843 int dap_to_swd(struct adiv5_dap *dap)
 844 {
 845         LOG_DEBUG("Enter SWD mode");
 846
 847         return dap_send_sequence(dap, JTAG_TO_SWD);
 848 }
 849
 850 /**
 851  * Put the debug link into JTAG mode, if the target supports it.
 852  * The link's initial mode may be either SWD or JTAG.
 853  *
 854  * Note that targets implemented with SW-DP do not support JTAG, and
 855  * that some targets which could otherwise support it may have been
 856  * configured to disable JTAG signaling
 857  *
 858  * @param dap The DAP used
 859  * @return ERROR_OK or else a fault code.
 860  */
 861 int dap_to_jtag(struct adiv5_dap *dap)
 862 {
 863         LOG_DEBUG("Enter JTAG mode");
 864
 865         return dap_send_sequence(dap, SWD_TO_JTAG);
 866 }
 867
 868 /* CID interpretation -- see ARM IHI 0029B section 3
 869  * and ARM IHI 0031A table 13-3.
 870  */
 871 static const char *class_description[16] = {
 872         "Reserved", "ROM table", "Reserved", "Reserved",
 873         "Reserved", "Reserved", "Reserved", "Reserved",
 874         "Reserved", "CoreSight component", "Reserved", "Peripheral Test Block",
 875         "Reserved", "OptimoDE DESS",
 876         "Generic IP component", "PrimeCell or System component"
 877 };
 878
 879 static bool is_dap_cid_ok(uint32_t cid)
 880 {
 881         return (cid & 0xffff0fff) == 0xb105000d;
 882 }
 883
 884 /*
 885  * This function checks the ID for each access port to find the requested Access Port type
 886  */
 887 int dap_find_ap(struct adiv5_dap *dap, enum ap_type type_to_find, struct adiv5_ap **ap_out)
 888 {
 889         int ap_num;
 890
 891         /* Maximum AP number is 255 since the SELECT register is 8 bits */
 892         for (ap_num = 0; ap_num <= DP_APSEL_MAX; ap_num++) {
 893
 894                 /* read the IDR register of the Access Port */
 895                 uint32_t id_val = 0;
 896
 897                 int retval = dap_queue_ap_read(dap_ap(dap, ap_num), AP_REG_IDR, &id_val);
 898                 if (retval != ERROR_OK)
 899                         return retval;
 900
 901                 retval = dap_run(dap);
 902
 903                 /* IDR bits:
 904                  * 31-28 : Revision
 905                  * 27-24 : JEDEC bank (0x4 for ARM)
 906                  * 23-17 : JEDEC code (0x3B for ARM)
 907                  * 16-13 : Class (0b1000=Mem-AP)
 908                  * 12-8  : Reserved
 909                  *  7-4  : AP Variant (non-zero for JTAG-AP)
 910                  *  3-0  : AP Type (0=JTAG-AP 1=AHB-AP 2=APB-AP 4=AXI-AP)
 911                  */
 912
 913                 /* Reading register for a non-existent AP should not cause an error,
 914                  * but just to be sure, try to continue searching if an error does happen.
 915                  */
 916                 if ((retval == ERROR_OK) &&                  /* Register read success */
 917                         ((id_val & IDR_JEP106) == IDR_JEP106_ARM) && /* Jedec codes match */
 918                         ((id_val & IDR_TYPE) == type_to_find)) {      /* type matches*/
 919
 920                         LOG_DEBUG("Found %s at AP index: %d (IDR=0x%08" PRIX32 ")",
 921                                                 (type_to_find == AP_TYPE_AHB3_AP)  ? "AHB3-AP"  :
 922                                                 (type_to_find == AP_TYPE_AHB5_AP)  ? "AHB5-AP"  :
 923                                                 (type_to_find == AP_TYPE_APB_AP)  ? "APB-AP"  :
 924                                                 (type_to_find == AP_TYPE_AXI_AP)  ? "AXI-AP"  :
 925                                                 (type_to_find == AP_TYPE_JTAG_AP) ? "JTAG-AP" : "Unknown",
 926                                                 ap_num, id_val);
 927
 928                         *ap_out = &dap->ap[ap_num];
 929                         return ERROR_OK;
 930                 }
 931         }
 932
 933         LOG_DEBUG("No %s found",
 934                                 (type_to_find == AP_TYPE_AHB3_AP)  ? "AHB3-AP"  :
 935                                 (type_to_find == AP_TYPE_AHB5_AP)  ? "AHB5-AP"  :
 936                                 (type_to_find == AP_TYPE_APB_AP)  ? "APB-AP"  :
 937                                 (type_to_find == AP_TYPE_AXI_AP)  ? "AXI-AP"  :
 938                                 (type_to_find == AP_TYPE_JTAG_AP) ? "JTAG-AP" : "Unknown");
 939         return ERROR_FAIL;
 940 }
 941
 942 int dap_get_debugbase(struct adiv5_ap *ap,
 943                         target_addr_t *dbgbase, uint32_t *apid)
 944 {
 945         struct adiv5_dap *dap = ap->dap;
 946         int retval;
 947         uint32_t baseptr_upper, baseptr_lower;
 948
 949         baseptr_upper = 0;
 950
 951         if (is_64bit_ap(ap)) {
 952                 /* Read higher order 32-bits of base address */
 953                 retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64, &baseptr_upper);
 954                 if (retval != ERROR_OK)
 955                         return retval;
 956         }
 957
 958         retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, &baseptr_lower);
 959         if (retval != ERROR_OK)
 960                 return retval;
 961         retval = dap_queue_ap_read(ap, AP_REG_IDR, apid);
 962         if (retval != ERROR_OK)
 963                 return retval;
 964         retval = dap_run(dap);
 965         if (retval != ERROR_OK)
 966                 return retval;
 967
 968         *dbgbase = (((target_addr_t)baseptr_upper) << 32) | baseptr_lower;
 969
 970         return ERROR_OK;
 971 }
 972
 973 int dap_lookup_cs_component(struct adiv5_ap *ap,
 974                         target_addr_t dbgbase, uint8_t type, target_addr_t *addr, int32_t *idx)
 975 {
 976         uint32_t romentry, entry_offset = 0, devtype;
 977         target_addr_t component_base;
 978         int retval;
 979
 980         dbgbase &= 0xFFFFFFFFFFFFF000ull;
 981         *addr = 0;
 982
 983         do {
 984                 retval = mem_ap_read_atomic_u32(ap, dbgbase |
 985                                                 entry_offset, &romentry);
 986                 if (retval != ERROR_OK)
 987                         return retval;
 988
 989                 component_base = dbgbase + (target_addr_t)(romentry & 0xFFFFF000);
 990
 991                 if (romentry & 0x1) {
 992                         uint32_t c_cid1;
 993                         retval = mem_ap_read_atomic_u32(ap, component_base | 0xff4, &c_cid1);
 994                         if (retval != ERROR_OK) {
 995                                 LOG_ERROR("Can't read component with base address " TARGET_ADDR_FMT
 996                                           ", the corresponding core might be turned off", component_base);
 997                                 return retval;
 998                         }
 999                         if (((c_cid1 >> 4) & 0x0f) == 1) {
1000                                 retval = dap_lookup_cs_component(ap, component_base,
1001                                                         type, addr, idx);
1002                                 if (retval == ERROR_OK)
1003                                         break;
1004                                 if (retval != ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1005                                         return retval;
1006                         }
1007
1008                         retval = mem_ap_read_atomic_u32(ap, component_base | 0xfcc, &devtype);
1009                         if (retval != ERROR_OK)
1010                                 return retval;
1011                         if ((devtype & 0xff) == type) {
1012                                 if (!*idx) {
1013                                         *addr = component_base;
1014                                         break;
1015                                 } else
1016                                         (*idx)--;
1017                         }
1018                 }
1019                 entry_offset += 4;
1020         } while ((romentry > 0) && (entry_offset < 0xf00));
1021
1022         if (!*addr)
1023                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1024
1025         return ERROR_OK;
1026 }
1027
1028 static int dap_read_part_id(struct adiv5_ap *ap, target_addr_t component_base, uint32_t *cid, uint64_t *pid)
1029 {
1030         assert((component_base & 0xFFF) == 0);
1031         assert(ap && cid && pid);
1032
1033         uint32_t cid0, cid1, cid2, cid3;
1034         uint32_t pid0, pid1, pid2, pid3, pid4;
1035         int retval;
1036
1037         /* IDs are in last 4K section */
1038         retval = mem_ap_read_u32(ap, component_base + 0xFE0, &pid0);
1039         if (retval != ERROR_OK)
1040                 return retval;
1041         retval = mem_ap_read_u32(ap, component_base + 0xFE4, &pid1);
1042         if (retval != ERROR_OK)
1043                 return retval;
1044         retval = mem_ap_read_u32(ap, component_base + 0xFE8, &pid2);
1045         if (retval != ERROR_OK)
1046                 return retval;
1047         retval = mem_ap_read_u32(ap, component_base + 0xFEC, &pid3);
1048         if (retval != ERROR_OK)
1049                 return retval;
1050         retval = mem_ap_read_u32(ap, component_base + 0xFD0, &pid4);
1051         if (retval != ERROR_OK)
1052                 return retval;
1053         retval = mem_ap_read_u32(ap, component_base + 0xFF0, &cid0);
1054         if (retval != ERROR_OK)
1055                 return retval;
1056         retval = mem_ap_read_u32(ap, component_base + 0xFF4, &cid1);
1057         if (retval != ERROR_OK)
1058                 return retval;
1059         retval = mem_ap_read_u32(ap, component_base + 0xFF8, &cid2);
1060         if (retval != ERROR_OK)
1061                 return retval;
1062         retval = mem_ap_read_u32(ap, component_base + 0xFFC, &cid3);
1063         if (retval != ERROR_OK)
1064                 return retval;
1065
1066         retval = dap_run(ap->dap);
1067         if (retval != ERROR_OK)
1068                 return retval;
1069
1070         *cid = (cid3 & 0xff) << 24
1071                         | (cid2 & 0xff) << 16
1072                         | (cid1 & 0xff) << 8
1073                         | (cid0 & 0xff);
1074         *pid = (uint64_t)(pid4 & 0xff) << 32
1075                         | (pid3 & 0xff) << 24
1076                         | (pid2 & 0xff) << 16
1077                         | (pid1 & 0xff) << 8
1078                         | (pid0 & 0xff);
1079
1080         return ERROR_OK;
1081 }
1082
1083 /* The designer identity code is encoded as:
1084  * bits 11:8 : JEP106 Bank (number of continuation codes), only valid when bit 7 is 1.
1085  * bit 7     : Set when bits 6:0 represent a JEP106 ID and cleared when bits 6:0 represent
1086  *             a legacy ASCII Identity Code.
1087  * bits 6:0  : JEP106 Identity Code (without parity) or legacy ASCII code according to bit 7.
1088  * JEP106 is a standard available from jedec.org
1089  */
1090
1091 /* Part number interpretations are from Cortex
1092  * core specs, the CoreSight components TRM
1093  * (ARM DDI 0314H), CoreSight System Design
1094  * Guide (ARM DGI 0012D) and ETM specs; also
1095  * from chip observation (e.g. TI SDTI).
1096  */
1097
1098 /* The legacy code only used the part number field to identify CoreSight peripherals.
1099  * This meant that the same part number from two different manufacturers looked the same.
1100  * It is desirable for all future additions to identify with both part number and JEP106.
1101  * "ANY_ID" is a wildcard (any JEP106) only to preserve legacy behavior for legacy entries.
1102  */
1103
1104 #define ANY_ID 0x1000
1105
1106 #define ARM_ID 0x4BB
1107
1108 static const struct {
1109         uint16_t designer_id;
1110         uint16_t part_num;
1111         const char *type;
1112         const char *full;
1113 } dap_partnums[] = {
1114         { ARM_ID, 0x000, "Cortex-M3 SCS",              "(System Control Space)", },
1115         { ARM_ID, 0x001, "Cortex-M3 ITM",              "(Instrumentation Trace Module)", },
1116         { ARM_ID, 0x002, "Cortex-M3 DWT",              "(Data Watchpoint and Trace)", },
1117         { ARM_ID, 0x003, "Cortex-M3 FPB",              "(Flash Patch and Breakpoint)", },
1118         { ARM_ID, 0x008, "Cortex-M0 SCS",              "(System Control Space)", },
1119         { ARM_ID, 0x00a, "Cortex-M0 DWT",              "(Data Watchpoint and Trace)", },
1120         { ARM_ID, 0x00b, "Cortex-M0 BPU",              "(Breakpoint Unit)", },
1121         { ARM_ID, 0x00c, "Cortex-M4 SCS",              "(System Control Space)", },
1122         { ARM_ID, 0x00d, "CoreSight ETM11",            "(Embedded Trace)", },
1123         { ARM_ID, 0x00e, "Cortex-M7 FPB",              "(Flash Patch and Breakpoint)", },
1124         { ARM_ID, 0x470, "Cortex-M1 ROM",              "(ROM Table)", },
1125         { ARM_ID, 0x471, "Cortex-M0 ROM",              "(ROM Table)", },
1126         { ARM_ID, 0x490, "Cortex-A15 GIC",             "(Generic Interrupt Controller)", },
1127         { ARM_ID, 0x4a1, "Cortex-A53 ROM",             "(v8 Memory Map ROM Table)", },
1128         { ARM_ID, 0x4a2, "Cortex-A57 ROM",             "(ROM Table)", },
1129         { ARM_ID, 0x4a3, "Cortex-A53 ROM",             "(v7 Memory Map ROM Table)", },
1130         { ARM_ID, 0x4a4, "Cortex-A72 ROM",             "(ROM Table)", },
1131         { ARM_ID, 0x4a9, "Cortex-A9 ROM",              "(ROM Table)", },
1132         { ARM_ID, 0x4aa, "Cortex-A35 ROM",             "(v8 Memory Map ROM Table)", },
1133         { ARM_ID, 0x4af, "Cortex-A15 ROM",             "(ROM Table)", },
1134         { ARM_ID, 0x4b5, "Cortex-R5 ROM",              "(ROM Table)", },
1135         { ARM_ID, 0x4c0, "Cortex-M0+ ROM",             "(ROM Table)", },
1136         { ARM_ID, 0x4c3, "Cortex-M3 ROM",              "(ROM Table)", },
1137         { ARM_ID, 0x4c4, "Cortex-M4 ROM",              "(ROM Table)", },
1138         { ARM_ID, 0x4c7, "Cortex-M7 PPB ROM",          "(Private Peripheral Bus ROM Table)", },
1139         { ARM_ID, 0x4c8, "Cortex-M7 ROM",              "(ROM Table)", },
1140         { ARM_ID, 0x4e0, "Cortex-A35 ROM",             "(v7 Memory Map ROM Table)", },
1141         { ARM_ID, 0x906, "CoreSight CTI",              "(Cross Trigger)", },
1142         { ARM_ID, 0x907, "CoreSight ETB",              "(Trace Buffer)", },
1143         { ARM_ID, 0x908, "CoreSight CSTF",             "(Trace Funnel)", },
1144         { ARM_ID, 0x909, "CoreSight ATBR",             "(Advanced Trace Bus Replicator)", },
1145         { ARM_ID, 0x910, "CoreSight ETM9",             "(Embedded Trace)", },
1146         { ARM_ID, 0x912, "CoreSight TPIU",             "(Trace Port Interface Unit)", },
1147         { ARM_ID, 0x913, "CoreSight ITM",              "(Instrumentation Trace Macrocell)", },
1148         { ARM_ID, 0x914, "CoreSight SWO",              "(Single Wire Output)", },
1149         { ARM_ID, 0x917, "CoreSight HTM",              "(AHB Trace Macrocell)", },
1150         { ARM_ID, 0x920, "CoreSight ETM11",            "(Embedded Trace)", },
1151         { ARM_ID, 0x921, "Cortex-A8 ETM",              "(Embedded Trace)", },
1152         { ARM_ID, 0x922, "Cortex-A8 CTI",              "(Cross Trigger)", },
1153         { ARM_ID, 0x923, "Cortex-M3 TPIU",             "(Trace Port Interface Unit)", },
1154         { ARM_ID, 0x924, "Cortex-M3 ETM",              "(Embedded Trace)", },
1155         { ARM_ID, 0x925, "Cortex-M4 ETM",              "(Embedded Trace)", },
1156         { ARM_ID, 0x930, "Cortex-R4 ETM",              "(Embedded Trace)", },
1157         { ARM_ID, 0x931, "Cortex-R5 ETM",              "(Embedded Trace)", },
1158         { ARM_ID, 0x932, "CoreSight MTB-M0+",          "(Micro Trace Buffer)", },
1159         { ARM_ID, 0x941, "CoreSight TPIU-Lite",        "(Trace Port Interface Unit)", },
1160         { ARM_ID, 0x950, "Cortex-A9 PTM",              "(Program Trace Macrocell)", },
1161         { ARM_ID, 0x955, "Cortex-A5 ETM",              "(Embedded Trace)", },
1162         { ARM_ID, 0x95a, "Cortex-A72 ETM",             "(Embedded Trace)", },
1163         { ARM_ID, 0x95b, "Cortex-A17 PTM",             "(Program Trace Macrocell)", },
1164         { ARM_ID, 0x95d, "Cortex-A53 ETM",             "(Embedded Trace)", },
1165         { ARM_ID, 0x95e, "Cortex-A57 ETM",             "(Embedded Trace)", },
1166         { ARM_ID, 0x95f, "Cortex-A15 PTM",             "(Program Trace Macrocell)", },
1167         { ARM_ID, 0x961, "CoreSight TMC",              "(Trace Memory Controller)", },
1168         { ARM_ID, 0x962, "CoreSight STM",              "(System Trace Macrocell)", },
1169         { ARM_ID, 0x975, "Cortex-M7 ETM",              "(Embedded Trace)", },
1170         { ARM_ID, 0x9a0, "CoreSight PMU",              "(Performance Monitoring Unit)", },
1171         { ARM_ID, 0x9a1, "Cortex-M4 TPIU",             "(Trace Port Interface Unit)", },
1172         { ARM_ID, 0x9a4, "CoreSight GPR",              "(Granular Power Requester)", },
1173         { ARM_ID, 0x9a5, "Cortex-A5 PMU",              "(Performance Monitor Unit)", },
1174         { ARM_ID, 0x9a7, "Cortex-A7 PMU",              "(Performance Monitor Unit)", },
1175         { ARM_ID, 0x9a8, "Cortex-A53 CTI",             "(Cross Trigger)", },
1176         { ARM_ID, 0x9a9, "Cortex-M7 TPIU",             "(Trace Port Interface Unit)", },
1177         { ARM_ID, 0x9ae, "Cortex-A17 PMU",             "(Performance Monitor Unit)", },
1178         { ARM_ID, 0x9af, "Cortex-A15 PMU",             "(Performance Monitor Unit)", },
1179         { ARM_ID, 0x9b7, "Cortex-R7 PMU",              "(Performance Monitor Unit)", },
1180         { ARM_ID, 0x9d3, "Cortex-A53 PMU",             "(Performance Monitor Unit)", },
1181         { ARM_ID, 0x9d7, "Cortex-A57 PMU",             "(Performance Monitor Unit)", },
1182         { ARM_ID, 0x9d8, "Cortex-A72 PMU",             "(Performance Monitor Unit)", },
1183         { ARM_ID, 0x9da, "Cortex-A35 PMU/CTI/ETM",     "(Performance Monitor Unit/Cross Trigger/ETM)", },
1184         { ARM_ID, 0xc05, "Cortex-A5 Debug",            "(Debug Unit)", },
1185         { ARM_ID, 0xc07, "Cortex-A7 Debug",            "(Debug Unit)", },
1186         { ARM_ID, 0xc08, "Cortex-A8 Debug",            "(Debug Unit)", },
1187         { ARM_ID, 0xc09, "Cortex-A9 Debug",            "(Debug Unit)", },
1188         { ARM_ID, 0xc0e, "Cortex-A17 Debug",           "(Debug Unit)", },
1189         { ARM_ID, 0xc0f, "Cortex-A15 Debug",           "(Debug Unit)", },
1190         { ARM_ID, 0xc14, "Cortex-R4 Debug",            "(Debug Unit)", },
1191         { ARM_ID, 0xc15, "Cortex-R5 Debug",            "(Debug Unit)", },
1192         { ARM_ID, 0xc17, "Cortex-R7 Debug",            "(Debug Unit)", },
1193         { ARM_ID, 0xd03, "Cortex-A53 Debug",           "(Debug Unit)", },
1194         { ARM_ID, 0xd04, "Cortex-A35 Debug",           "(Debug Unit)", },
1195         { ARM_ID, 0xd07, "Cortex-A57 Debug",           "(Debug Unit)", },
1196         { ARM_ID, 0xd08, "Cortex-A72 Debug",           "(Debug Unit)", },
1197         { 0x097,  0x9af, "MSP432 ROM",                 "(ROM Table)" },
1198         { 0x09f,  0xcd0, "Atmel CPU with DSU",         "(CPU)" },
1199         { 0x0c1,  0x1db, "XMC4500 ROM",                "(ROM Table)" },
1200         { 0x0c1,  0x1df, "XMC4700/4800 ROM",           "(ROM Table)" },
1201         { 0x0c1,  0x1ed, "XMC1000 ROM",                "(ROM Table)" },
1202         { 0x0E5,  0x000, "SHARC+/Blackfin+",           "", },
1203         { 0x0F0,  0x440, "Qualcomm QDSS Component v1", "(Qualcomm Designed CoreSight Component v1)", },
1204         { 0x1bf,  0x100, "Brahma-B53 Debug",           "(Debug Unit)", },
1205         { 0x1bf,  0x9d3, "Brahma-B53 PMU",             "(Performance Monitor Unit)", },
1206         { 0x1bf,  0x4a1, "Brahma-B53 ROM",             "(ROM Table)", },
1207         { 0x1bf,  0x721, "Brahma-B53 ROM",             "(ROM Table)", },
1208         { 0x3eb,  0x181, "Tegra 186 ROM",              "(ROM Table)", },
1209         { 0x3eb,  0x202, "Denver ETM",                 "(Denver Embedded Trace)", },
1210         { 0x3eb,  0x211, "Tegra 210 ROM",              "(ROM Table)", },
1211         { 0x3eb,  0x302, "Denver Debug",               "(Debug Unit)", },
1212         { 0x3eb,  0x402, "Denver PMU",                 "(Performance Monitor Unit)", },
1213         /* legacy comment: 0x113: what? */
1214         { ANY_ID, 0x120, "TI SDTI",                    "(System Debug Trace Interface)", }, /* from OMAP3 memmap */
1215         { ANY_ID, 0x343, "TI DAPCTL",                  "", }, /* from OMAP3 memmap */
1216 };
1217
1218 static int dap_rom_display(struct command_invocation *cmd,
1219                                 struct adiv5_ap *ap, target_addr_t dbgbase, int depth)
1220 {
1221         int retval;
1222         uint64_t pid;
1223         uint32_t cid;
1224         char tabs[16] = "";
1225
1226         if (depth > 16) {
1227                 command_print(cmd, "\tTables too deep");
1228                 return ERROR_FAIL;
1229         }
1230
1231         if (depth)
1232                 snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
1233
1234         target_addr_t base_addr = dbgbase & 0xFFFFFFFFFFFFF000ull;
1235         command_print(cmd, "\t\tComponent base address " TARGET_ADDR_FMT, base_addr);
1236
1237         retval = dap_read_part_id(ap, base_addr, &cid, &pid);
1238         if (retval != ERROR_OK) {
1239                 command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off");
1240                 return ERROR_OK; /* Don't abort recursion */
1241         }
1242
1243         if (!is_dap_cid_ok(cid)) {
1244                 command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid);
1245                 return ERROR_OK; /* Don't abort recursion */
1246         }
1247
1248         /* component may take multiple 4K pages */
1249         uint32_t size = (pid >> 36) & 0xf;
1250         if (size > 0)
1251                 command_print(cmd, "\t\tStart address " TARGET_ADDR_FMT, base_addr - 0x1000 * size);
1252
1253         command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid);
1254
1255         uint8_t class = (cid >> 12) & 0xf;
1256         uint16_t part_num = pid & 0xfff;
1257         uint16_t designer_id = ((pid >> 32) & 0xf) << 8 | ((pid >> 12) & 0xff);
1258
1259         if (designer_id & 0x80) {
1260                 /* JEP106 code */
1261                 command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s",
1262                                 designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
1263         } else {
1264                 /* Legacy ASCII ID, clear invalid bits */
1265                 designer_id &= 0x7f;
1266                 command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
1267                                 designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
1268         }
1269
1270         /* default values to be overwritten upon finding a match */
1271         const char *type = "Unrecognized";
1272         const char *full = "";
1273
1274         /* search dap_partnums[] array for a match */
1275         for (unsigned entry = 0; entry < ARRAY_SIZE(dap_partnums); entry++) {
1276
1277                 if ((dap_partnums[entry].designer_id != designer_id) && (dap_partnums[entry].designer_id != ANY_ID))
1278                         continue;
1279
1280                 if (dap_partnums[entry].part_num != part_num)
1281                         continue;
1282
1283                 type = dap_partnums[entry].type;
1284                 full = dap_partnums[entry].full;
1285                 break;
1286         }
1287
1288         command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
1289         command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
1290
1291         if (class == 1) { /* ROM Table */
1292                 uint32_t memtype;
1293                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &memtype);
1294                 if (retval != ERROR_OK)
1295                         return retval;
1296
1297                 if (memtype & 0x01)
1298                         command_print(cmd, "\t\tMEMTYPE system memory present on bus");
1299                 else
1300                         command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus");
1301
1302                 /* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
1303                 for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
1304                         uint32_t romentry;
1305                         retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
1306                         if (retval != ERROR_OK)
1307                                 return retval;
1308                         command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
1309                                         tabs, entry_offset, romentry);
1310                         if (romentry & 0x01) {
1311                                 /* Recurse */
1312                                 retval = dap_rom_display(cmd, ap, base_addr + (romentry & 0xFFFFF000), depth + 1);
1313                                 if (retval != ERROR_OK)
1314                                         return retval;
1315                         } else if (romentry != 0) {
1316                                 command_print(cmd, "\t\tComponent not present");
1317                         } else {
1318                                 command_print(cmd, "\t%s\tEnd of ROM table", tabs);
1319                                 break;
1320                         }
1321                 }
1322         } else if (class == 9) { /* CoreSight component */
1323                 const char *major = "Reserved", *subtype = "Reserved";
1324
1325                 uint32_t devtype;
1326                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &devtype);
1327                 if (retval != ERROR_OK)
1328                         return retval;
1329                 unsigned minor = (devtype >> 4) & 0x0f;
1330                 switch (devtype & 0x0f) {
1331                 case 0:
1332                         major = "Miscellaneous";
1333                         switch (minor) {
1334                         case 0:
1335                                 subtype = "other";
1336                                 break;
1337                         case 4:
1338                                 subtype = "Validation component";
1339                                 break;
1340                         }
1341                         break;
1342                 case 1:
1343                         major = "Trace Sink";
1344                         switch (minor) {
1345                         case 0:
1346                                 subtype = "other";
1347                                 break;
1348                         case 1:
1349                                 subtype = "Port";
1350                                 break;
1351                         case 2:
1352                                 subtype = "Buffer";
1353                                 break;
1354                         case 3:
1355                                 subtype = "Router";
1356                                 break;
1357                         }
1358                         break;
1359                 case 2:
1360                         major = "Trace Link";
1361                         switch (minor) {
1362                         case 0:
1363                                 subtype = "other";
1364                                 break;
1365                         case 1:
1366                                 subtype = "Funnel, router";
1367                                 break;
1368                         case 2:
1369                                 subtype = "Filter";
1370                                 break;
1371                         case 3:
1372                                 subtype = "FIFO, buffer";
1373                                 break;
1374                         }
1375                         break;
1376                 case 3:
1377                         major = "Trace Source";
1378                         switch (minor) {
1379                         case 0:
1380                                 subtype = "other";
1381                                 break;
1382                         case 1:
1383                                 subtype = "Processor";
1384                                 break;
1385                         case 2:
1386                                 subtype = "DSP";
1387                                 break;
1388                         case 3:
1389                                 subtype = "Engine/Coprocessor";
1390                                 break;
1391                         case 4:
1392                                 subtype = "Bus";
1393                                 break;
1394                         case 6:
1395                                 subtype = "Software";
1396                                 break;
1397                         }
1398                         break;
1399                 case 4:
1400                         major = "Debug Control";
1401                         switch (minor) {
1402                         case 0:
1403                                 subtype = "other";
1404                                 break;
1405                         case 1:
1406                                 subtype = "Trigger Matrix";
1407                                 break;
1408                         case 2:
1409                                 subtype = "Debug Auth";
1410                                 break;
1411                         case 3:
1412                                 subtype = "Power Requestor";
1413                                 break;
1414                         }
1415                         break;
1416                 case 5:
1417                         major = "Debug Logic";
1418                         switch (minor) {
1419                         case 0:
1420                                 subtype = "other";
1421                                 break;
1422                         case 1:
1423                                 subtype = "Processor";
1424                                 break;
1425                         case 2:
1426                                 subtype = "DSP";
1427                                 break;
1428                         case 3:
1429                                 subtype = "Engine/Coprocessor";
1430                                 break;
1431                         case 4:
1432                                 subtype = "Bus";
1433                                 break;
1434                         case 5:
1435                                 subtype = "Memory";
1436                                 break;
1437                         }
1438                         break;
1439                 case 6:
1440                         major = "Performance Monitor";
1441                         switch (minor) {
1442                         case 0:
1443                                 subtype = "other";
1444                                 break;
1445                         case 1:
1446                                 subtype = "Processor";
1447                                 break;
1448                         case 2:
1449                                 subtype = "DSP";
1450                                 break;
1451                         case 3:
1452                                 subtype = "Engine/Coprocessor";
1453                                 break;
1454                         case 4:
1455                                 subtype = "Bus";
1456                                 break;
1457                         case 5:
1458                                 subtype = "Memory";
1459                                 break;
1460                         }
1461                         break;
1462                 }
1463                 command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s",
1464                                 (uint8_t)(devtype & 0xff),
1465                                 major, subtype);
1466                 /* REVISIT also show 0xfc8 DevId */
1467         }
1468
1469         return ERROR_OK;
1470 }
1471
1472 int dap_info_command(struct command_invocation *cmd,
1473                 struct adiv5_ap *ap)
1474 {
1475         int retval;
1476         uint32_t apid;
1477         target_addr_t dbgbase;
1478         target_addr_t dbgaddr;
1479         uint8_t mem_ap;
1480
1481         /* Now we read ROM table ID registers, ref. ARM IHI 0029B sec  */
1482         retval = dap_get_debugbase(ap, &dbgbase, &apid);
1483         if (retval != ERROR_OK)
1484                 return retval;
1485
1486         command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
1487         if (apid == 0) {
1488                 command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
1489                 return ERROR_FAIL;
1490         }
1491
1492         switch (apid & (IDR_JEP106 | IDR_TYPE)) {
1493         case IDR_JEP106_ARM | AP_TYPE_JTAG_AP:
1494                 command_print(cmd, "\tType is JTAG-AP");
1495                 break;
1496         case IDR_JEP106_ARM | AP_TYPE_AHB3_AP:
1497                 command_print(cmd, "\tType is MEM-AP AHB3");
1498                 break;
1499         case IDR_JEP106_ARM | AP_TYPE_AHB5_AP:
1500                 command_print(cmd, "\tType is MEM-AP AHB5");
1501                 break;
1502         case IDR_JEP106_ARM | AP_TYPE_APB_AP:
1503                 command_print(cmd, "\tType is MEM-AP APB");
1504                 break;
1505         case IDR_JEP106_ARM | AP_TYPE_AXI_AP:
1506                 command_print(cmd, "\tType is MEM-AP AXI");
1507                 break;
1508         default:
1509                 command_print(cmd, "\tUnknown AP type");
1510                 break;
1511         }
1512
1513         /* NOTE: a MEM-AP may have a single CoreSight component that's
1514          * not a ROM table ... or have no such components at all.
1515          */
1516         mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP;
1517         if (mem_ap) {
1518                 if (is_64bit_ap(ap))
1519                         dbgaddr = 0xFFFFFFFFFFFFFFFFull;
1520                 else
1521                         dbgaddr = 0xFFFFFFFFul;
1522
1523                 command_print(cmd, "MEM-AP BASE " TARGET_ADDR_FMT, dbgbase);
1524
1525                 if (dbgbase == dbgaddr || (dbgbase & 0x3) == 0x2) {
1526                         command_print(cmd, "\tNo ROM table present");
1527                 } else {
1528                         if (dbgbase & 0x01)
1529                                 command_print(cmd, "\tValid ROM table present");
1530                         else
1531                                 command_print(cmd, "\tROM table in legacy format");
1532
1533                         dap_rom_display(cmd, ap, dbgbase & 0xFFFFFFFFFFFFF000ull, 0);
1534                 }
1535         }
1536
1537         return ERROR_OK;
1538 }
1539
1540 enum adiv5_cfg_param {
1541         CFG_DAP,
1542         CFG_AP_NUM,
1543         CFG_BASEADDR,
1544         CFG_CTIBASE, /* DEPRECATED */
1545 };
1546
1547 static const struct jim_nvp nvp_config_opts[] = {
1548         { .name = "-dap",       .value = CFG_DAP },
1549         { .name = "-ap-num",    .value = CFG_AP_NUM },
1550         { .name = "-baseaddr",  .value = CFG_BASEADDR },
1551         { .name = "-ctibase",   .value = CFG_CTIBASE }, /* DEPRECATED */
1552         { .name = NULL, .value = -1 }
1553 };
1554
1555 static int adiv5_jim_spot_configure(struct jim_getopt_info *goi,
1556                 struct adiv5_dap **dap_p, int *ap_num_p, uint32_t *base_p)
1557 {
1558         if (!goi->argc)
1559                 return JIM_OK;
1560
1561         Jim_SetEmptyResult(goi->interp);
1562
1563         struct jim_nvp *n;
1564         int e = jim_nvp_name2value_obj(goi->interp, nvp_config_opts,
1565                                 goi->argv[0], &n);
1566         if (e != JIM_OK)
1567                 return JIM_CONTINUE;
1568
1569         /* base_p can be NULL, then '-baseaddr' option is treated as unknown */
1570         if (!base_p && (n->value == CFG_BASEADDR || n->value == CFG_CTIBASE))
1571                 return JIM_CONTINUE;
1572
1573         e = jim_getopt_obj(goi, NULL);
1574         if (e != JIM_OK)
1575                 return e;
1576
1577         switch (n->value) {
1578         case CFG_DAP:
1579                 if (goi->isconfigure) {
1580                         Jim_Obj *o_t;
1581                         struct adiv5_dap *dap;
1582                         e = jim_getopt_obj(goi, &o_t);
1583                         if (e != JIM_OK)
1584                                 return e;
1585                         dap = dap_instance_by_jim_obj(goi->interp, o_t);
1586                         if (!dap) {
1587                                 Jim_SetResultString(goi->interp, "DAP name invalid!", -1);
1588                                 return JIM_ERR;
1589                         }
1590                         if (*dap_p && *dap_p != dap) {
1591                                 Jim_SetResultString(goi->interp,
1592                                         "DAP assignment cannot be changed!", -1);
1593                                 return JIM_ERR;
1594                         }
1595                         *dap_p = dap;
1596                 } else {
1597                         if (goi->argc)
1598                                 goto err_no_param;
1599                         if (!*dap_p) {
1600                                 Jim_SetResultString(goi->interp, "DAP not configured", -1);
1601                                 return JIM_ERR;
1602                         }
1603                         Jim_SetResultString(goi->interp, adiv5_dap_name(*dap_p), -1);
1604                 }
1605                 break;
1606
1607         case CFG_AP_NUM:
1608                 if (goi->isconfigure) {
1609                         jim_wide ap_num;
1610                         e = jim_getopt_wide(goi, &ap_num);
1611                         if (e != JIM_OK)
1612                                 return e;
1613                         if (ap_num < 0 || ap_num > DP_APSEL_MAX) {
1614                                 Jim_SetResultString(goi->interp, "Invalid AP number!", -1);
1615                                 return JIM_ERR;
1616                         }
1617                         *ap_num_p = ap_num;
1618                 } else {
1619                         if (goi->argc)
1620                                 goto err_no_param;
1621                         if (*ap_num_p == DP_APSEL_INVALID) {
1622                                 Jim_SetResultString(goi->interp, "AP number not configured", -1);
1623                                 return JIM_ERR;
1624                         }
1625                         Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, *ap_num_p));
1626                 }
1627                 break;
1628
1629         case CFG_CTIBASE:
1630                 LOG_WARNING("DEPRECATED! use \'-baseaddr' not \'-ctibase\'");
1631                 /* fall through */
1632         case CFG_BASEADDR:
1633                 if (goi->isconfigure) {
1634                         jim_wide base;
1635                         e = jim_getopt_wide(goi, &base);
1636                         if (e != JIM_OK)
1637                                 return e;
1638                         *base_p = (uint32_t)base;
1639                 } else {
1640                         if (goi->argc)
1641                                 goto err_no_param;
1642                         Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, *base_p));
1643                 }
1644                 break;
1645         };
1646
1647         return JIM_OK;
1648
1649 err_no_param:
1650         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
1651         return JIM_ERR;
1652 }
1653
1654 int adiv5_jim_configure(struct target *target, struct jim_getopt_info *goi)
1655 {
1656         struct adiv5_private_config *pc;
1657         int e;
1658
1659         pc = (struct adiv5_private_config *)target->private_config;
1660         if (!pc) {
1661                 pc = calloc(1, sizeof(struct adiv5_private_config));
1662                 pc->ap_num = DP_APSEL_INVALID;
1663                 target->private_config = pc;
1664         }
1665
1666         target->has_dap = true;
1667
1668         e = adiv5_jim_spot_configure(goi, &pc->dap, &pc->ap_num, NULL);
1669         if (e != JIM_OK)
1670                 return e;
1671
1672         if (pc->dap && !target->dap_configured) {
1673                 if (target->tap_configured) {
1674                         pc->dap = NULL;
1675                         Jim_SetResultString(goi->interp,
1676                                 "-chain-position and -dap configparams are mutually exclusive!", -1);
1677                         return JIM_ERR;
1678                 }
1679                 target->tap = pc->dap->tap;
1680                 target->dap_configured = true;
1681         }
1682
1683         return JIM_OK;
1684 }
1685
1686 int adiv5_verify_config(struct adiv5_private_config *pc)
1687 {
1688         if (!pc)
1689                 return ERROR_FAIL;
1690
1691         if (!pc->dap)
1692                 return ERROR_FAIL;
1693
1694         return ERROR_OK;
1695 }
1696
1697 int adiv5_jim_mem_ap_spot_configure(struct adiv5_mem_ap_spot *cfg,
1698                 struct jim_getopt_info *goi)
1699 {
1700         return adiv5_jim_spot_configure(goi, &cfg->dap, &cfg->ap_num, &cfg->base);
1701 }
1702
1703 int adiv5_mem_ap_spot_init(struct adiv5_mem_ap_spot *p)
1704 {
1705         p->dap = NULL;
1706         p->ap_num = DP_APSEL_INVALID;
1707         p->base = 0;
1708         return ERROR_OK;
1709 }
1710
1711 COMMAND_HANDLER(handle_dap_info_command)
1712 {
1713         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1714         uint32_t apsel;
1715
1716         switch (CMD_ARGC) {
1717         case 0:
1718                 apsel = dap->apsel;
1719                 break;
1720         case 1:
1721                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1722                 if (apsel > DP_APSEL_MAX) {
1723                         command_print(CMD, "Invalid AP number");
1724                         return ERROR_COMMAND_ARGUMENT_INVALID;
1725                 }
1726                 break;
1727         default:
1728                 return ERROR_COMMAND_SYNTAX_ERROR;
1729         }
1730
1731         return dap_info_command(CMD, &dap->ap[apsel]);
1732 }
1733
1734 COMMAND_HANDLER(dap_baseaddr_command)
1735 {
1736         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1737         uint32_t apsel, baseaddr_lower, baseaddr_upper;
1738         struct adiv5_ap *ap;
1739         target_addr_t baseaddr;
1740         int retval;
1741
1742         baseaddr_upper = 0;
1743
1744         switch (CMD_ARGC) {
1745         case 0:
1746                 apsel = dap->apsel;
1747                 break;
1748         case 1:
1749                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1750                 /* AP address is in bits 31:24 of DP_SELECT */
1751                 if (apsel > DP_APSEL_MAX) {
1752                         command_print(CMD, "Invalid AP number");
1753                         return ERROR_COMMAND_ARGUMENT_INVALID;
1754                 }
1755                 break;
1756         default:
1757                 return ERROR_COMMAND_SYNTAX_ERROR;
1758         }
1759
1760         /* NOTE:  assumes we're talking to a MEM-AP, which
1761          * has a base address.  There are other kinds of AP,
1762          * though they're not common for now.  This should
1763          * use the ID register to verify it's a MEM-AP.
1764          */
1765
1766         ap = dap_ap(dap, apsel);
1767         retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, &baseaddr_lower);
1768
1769         if (is_64bit_ap(ap) && retval == ERROR_OK)
1770                 retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64, &baseaddr_upper);
1771         if (retval != ERROR_OK)
1772                 return retval;
1773         retval = dap_run(dap);
1774         if (retval != ERROR_OK)
1775                 return retval;
1776         if (is_64bit_ap(ap)) {
1777                 baseaddr = (((target_addr_t)baseaddr_upper) << 32) | baseaddr_lower;
1778                 command_print(CMD, "0x%016" PRIx64, baseaddr);
1779         } else
1780                 command_print(CMD, "0x%08" PRIx32, baseaddr_lower);
1781
1782         return retval;
1783 }
1784
1785 COMMAND_HANDLER(dap_memaccess_command)
1786 {
1787         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1788         uint32_t memaccess_tck;
1789
1790         switch (CMD_ARGC) {
1791         case 0:
1792                 memaccess_tck = dap->ap[dap->apsel].memaccess_tck;
1793                 break;
1794         case 1:
1795                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], memaccess_tck);
1796                 break;
1797         default:
1798                 return ERROR_COMMAND_SYNTAX_ERROR;
1799         }
1800         dap->ap[dap->apsel].memaccess_tck = memaccess_tck;
1801
1802         command_print(CMD, "memory bus access delay set to %" PRIu32 " tck",
1803                         dap->ap[dap->apsel].memaccess_tck);
1804
1805         return ERROR_OK;
1806 }
1807
1808 COMMAND_HANDLER(dap_apsel_command)
1809 {
1810         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1811         uint32_t apsel;
1812
1813         switch (CMD_ARGC) {
1814         case 0:
1815                 command_print(CMD, "%" PRIu32, dap->apsel);
1816                 return ERROR_OK;
1817         case 1:
1818                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1819                 /* AP address is in bits 31:24 of DP_SELECT */
1820                 if (apsel > DP_APSEL_MAX) {
1821                         command_print(CMD, "Invalid AP number");
1822                         return ERROR_COMMAND_ARGUMENT_INVALID;
1823                 }
1824                 break;
1825         default:
1826                 return ERROR_COMMAND_SYNTAX_ERROR;
1827         }
1828
1829         dap->apsel = apsel;
1830         return ERROR_OK;
1831 }
1832
1833 COMMAND_HANDLER(dap_apcsw_command)
1834 {
1835         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1836         uint32_t apcsw = dap->ap[dap->apsel].csw_default;
1837         uint32_t csw_val, csw_mask;
1838
1839         switch (CMD_ARGC) {
1840         case 0:
1841                 command_print(CMD, "ap %" PRIu32 " selected, csw 0x%8.8" PRIx32,
1842                         dap->apsel, apcsw);
1843                 return ERROR_OK;
1844         case 1:
1845                 if (strcmp(CMD_ARGV[0], "default") == 0)
1846                         csw_val = CSW_AHB_DEFAULT;
1847                 else
1848                         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1849
1850                 if (csw_val & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1851                         LOG_ERROR("CSW value cannot include 'Size' and 'AddrInc' bit-fields");
1852                         return ERROR_COMMAND_ARGUMENT_INVALID;
1853                 }
1854                 apcsw = csw_val;
1855                 break;
1856         case 2:
1857                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1858                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], csw_mask);
1859                 if (csw_mask & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1860                         LOG_ERROR("CSW mask cannot include 'Size' and 'AddrInc' bit-fields");
1861                         return ERROR_COMMAND_ARGUMENT_INVALID;
1862                 }
1863                 apcsw = (apcsw & ~csw_mask) | (csw_val & csw_mask);
1864                 break;
1865         default:
1866                 return ERROR_COMMAND_SYNTAX_ERROR;
1867         }
1868         dap->ap[dap->apsel].csw_default = apcsw;
1869
1870         return 0;
1871 }
1872
1873
1874
1875 COMMAND_HANDLER(dap_apid_command)
1876 {
1877         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1878         uint32_t apsel, apid;
1879         int retval;
1880
1881         switch (CMD_ARGC) {
1882         case 0:
1883                 apsel = dap->apsel;
1884                 break;
1885         case 1:
1886                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1887                 /* AP address is in bits 31:24 of DP_SELECT */
1888                 if (apsel > DP_APSEL_MAX) {
1889                         command_print(CMD, "Invalid AP number");
1890                         return ERROR_COMMAND_ARGUMENT_INVALID;
1891                 }
1892                 break;
1893         default:
1894                 return ERROR_COMMAND_SYNTAX_ERROR;
1895         }
1896
1897         retval = dap_queue_ap_read(dap_ap(dap, apsel), AP_REG_IDR, &apid);
1898         if (retval != ERROR_OK)
1899                 return retval;
1900         retval = dap_run(dap);
1901         if (retval != ERROR_OK)
1902                 return retval;
1903
1904         command_print(CMD, "0x%8.8" PRIx32, apid);
1905
1906         return retval;
1907 }
1908
1909 COMMAND_HANDLER(dap_apreg_command)
1910 {
1911         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1912         uint32_t apsel, reg, value;
1913         struct adiv5_ap *ap;
1914         int retval;
1915
1916         if (CMD_ARGC < 2 || CMD_ARGC > 3)
1917                 return ERROR_COMMAND_SYNTAX_ERROR;
1918
1919         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1920         /* AP address is in bits 31:24 of DP_SELECT */
1921         if (apsel > DP_APSEL_MAX) {
1922                 command_print(CMD, "Invalid AP number");
1923                 return ERROR_COMMAND_ARGUMENT_INVALID;
1924         }
1925
1926         ap = dap_ap(dap, apsel);
1927
1928         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], reg);
1929         if (reg >= 256 || (reg & 3)) {
1930                 command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
1931                 return ERROR_COMMAND_ARGUMENT_INVALID;
1932         }
1933
1934         if (CMD_ARGC == 3) {
1935                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
1936                 switch (reg) {
1937                 case MEM_AP_REG_CSW:
1938                         ap->csw_value = 0;  /* invalid, in case write fails */
1939                         retval = dap_queue_ap_write(ap, reg, value);
1940                         if (retval == ERROR_OK)
1941                                 ap->csw_value = value;
1942                         break;
1943                 case MEM_AP_REG_TAR:
1944                         retval = dap_queue_ap_write(ap, reg, value);
1945                         if (retval == ERROR_OK)
1946                                 ap->tar_value = (ap->tar_value & ~0xFFFFFFFFull) | value;
1947                         else {
1948                                 /* To track independent writes to TAR and TAR64, two tar_valid flags */
1949                                 /* should be used. To keep it simple, tar_valid is only invalidated on a */
1950                                 /* write fail. This approach causes a later re-write of the TAR and TAR64 */
1951                                 /* if tar_valid is false. */
1952                                 ap->tar_valid = false;
1953                         }
1954                         break;
1955                 case MEM_AP_REG_TAR64:
1956                         retval = dap_queue_ap_write(ap, reg, value);
1957                         if (retval == ERROR_OK)
1958                                 ap->tar_value = (ap->tar_value & 0xFFFFFFFFull) | (((target_addr_t)value) << 32);
1959                         else {
1960                                 /* See above comment for the MEM_AP_REG_TAR failed write case */
1961                                 ap->tar_valid = false;
1962                         }
1963                         break;
1964                 default:
1965                         retval = dap_queue_ap_write(ap, reg, value);
1966                         break;
1967                 }
1968         } else {
1969                 retval = dap_queue_ap_read(ap, reg, &value);
1970         }
1971         if (retval == ERROR_OK)
1972                 retval = dap_run(dap);
1973
1974         if (retval != ERROR_OK)
1975                 return retval;
1976
1977         if (CMD_ARGC == 2)
1978                 command_print(CMD, "0x%08" PRIx32, value);
1979
1980         return retval;
1981 }
1982
1983 COMMAND_HANDLER(dap_dpreg_command)
1984 {
1985         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1986         uint32_t reg, value;
1987         int retval;
1988
1989         if (CMD_ARGC < 1 || CMD_ARGC > 2)
1990                 return ERROR_COMMAND_SYNTAX_ERROR;
1991
1992         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg);
1993         if (reg >= 256 || (reg & 3)) {
1994                 command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
1995                 return ERROR_COMMAND_ARGUMENT_INVALID;
1996         }
1997
1998         if (CMD_ARGC == 2) {
1999                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2000                 retval = dap_queue_dp_write(dap, reg, value);
2001         } else {
2002                 retval = dap_queue_dp_read(dap, reg, &value);
2003         }
2004         if (retval == ERROR_OK)
2005                 retval = dap_run(dap);
2006
2007         if (retval != ERROR_OK)
2008                 return retval;
2009
2010         if (CMD_ARGC == 1)
2011                 command_print(CMD, "0x%08" PRIx32, value);
2012
2013         return retval;
2014 }
2015
2016 COMMAND_HANDLER(dap_ti_be_32_quirks_command)
2017 {
2018         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
2019         return CALL_COMMAND_HANDLER(handle_command_parse_bool, &dap->ti_be_32_quirks,
2020                 "TI BE-32 quirks mode");
2021 }
2022
2023 const struct command_registration dap_instance_commands[] = {
2024         {
2025                 .name = "info",
2026                 .handler = handle_dap_info_command,
2027                 .mode = COMMAND_EXEC,
2028                 .help = "display ROM table for MEM-AP "
2029                         "(default currently selected AP)",
2030                 .usage = "[ap_num]",
2031         },
2032         {
2033                 .name = "apsel",
2034                 .handler = dap_apsel_command,
2035                 .mode = COMMAND_ANY,
2036                 .help = "Set the currently selected AP (default 0) "
2037                         "and display the result",
2038                 .usage = "[ap_num]",
2039         },
2040         {
2041                 .name = "apcsw",
2042                 .handler = dap_apcsw_command,
2043                 .mode = COMMAND_ANY,
2044                 .help = "Set CSW default bits",
2045                 .usage = "[value [mask]]",
2046         },
2047
2048         {
2049                 .name = "apid",
2050                 .handler = dap_apid_command,
2051                 .mode = COMMAND_EXEC,
2052                 .help = "return ID register from AP "
2053                         "(default currently selected AP)",
2054                 .usage = "[ap_num]",
2055         },
2056         {
2057                 .name = "apreg",
2058                 .handler = dap_apreg_command,
2059                 .mode = COMMAND_EXEC,
2060                 .help = "read/write a register from AP "
2061                         "(reg is byte address of a word register, like 0 4 8...)",
2062                 .usage = "ap_num reg [value]",
2063         },
2064         {
2065                 .name = "dpreg",
2066                 .handler = dap_dpreg_command,
2067                 .mode = COMMAND_EXEC,
2068                 .help = "read/write a register from DP "
2069                         "(reg is byte address (bank << 4 | reg) of a word register, like 0 4 8...)",
2070                 .usage = "reg [value]",
2071         },
2072         {
2073                 .name = "baseaddr",
2074                 .handler = dap_baseaddr_command,
2075                 .mode = COMMAND_EXEC,
2076                 .help = "return debug base address from MEM-AP "
2077                         "(default currently selected AP)",
2078                 .usage = "[ap_num]",
2079         },
2080         {
2081                 .name = "memaccess",
2082                 .handler = dap_memaccess_command,
2083                 .mode = COMMAND_EXEC,
2084                 .help = "set/get number of extra tck for MEM-AP memory "
2085                         "bus access [0-255]",
2086                 .usage = "[cycles]",
2087         },
2088         {
2089                 .name = "ti_be_32_quirks",
2090                 .handler = dap_ti_be_32_quirks_command,
2091                 .mode = COMMAND_CONFIG,
2092                 .help = "set/get quirks mode for TI TMS450/TMS570 processors",
2093                 .usage = "[enable]",
2094         },
2095         COMMAND_REGISTRATION_DONE
2096 };