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 <= DP_APSEL_MAX; 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         if (ap->cfg_reg == MEM_AP_REG_CFG_INVALID) {
 950                 retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG, &ap->cfg_reg);
 951                 if (retval != ERROR_OK)
 952                         return retval;
 953         }
 954         retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, &baseptr_lower);
 955         if (retval != ERROR_OK)
 956                 return retval;
 957         retval = dap_queue_ap_read(ap, AP_REG_IDR, apid);
 958         if (retval != ERROR_OK)
 959                 return retval;
 960         /* MEM_AP_REG_BASE64 is defined as 'RES0'; can be read and then ignored on 32 bits AP */
 961         if (ap->cfg_reg == MEM_AP_REG_CFG_INVALID || is_64bit_ap(ap)) {
 962                 retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64, &baseptr_upper);
 963                 if (retval != ERROR_OK)
 964                         return retval;
 965         }
 966
 967         retval = dap_run(dap);
 968         if (retval != ERROR_OK)
 969                 return retval;
 970
 971         if (!is_64bit_ap(ap))
 972                 baseptr_upper = 0;
 973         *dbgbase = (((target_addr_t)baseptr_upper) << 32) | baseptr_lower;
 974
 975         return ERROR_OK;
 976 }
 977
 978 int dap_lookup_cs_component(struct adiv5_ap *ap,
 979                         target_addr_t dbgbase, uint8_t type, target_addr_t *addr, int32_t *idx)
 980 {
 981         uint32_t romentry, entry_offset = 0, devtype;
 982         target_addr_t component_base;
 983         int retval;
 984
 985         dbgbase &= 0xFFFFFFFFFFFFF000ull;
 986         *addr = 0;
 987
 988         do {
 989                 retval = mem_ap_read_atomic_u32(ap, dbgbase |
 990                                                 entry_offset, &romentry);
 991                 if (retval != ERROR_OK)
 992                         return retval;
 993
 994                 component_base = dbgbase + (target_addr_t)(romentry & 0xFFFFF000);
 995
 996                 if (romentry & 0x1) {
 997                         uint32_t c_cid1;
 998                         retval = mem_ap_read_atomic_u32(ap, component_base | 0xff4, &c_cid1);
 999                         if (retval != ERROR_OK) {
1000                                 LOG_ERROR("Can't read component with base address " TARGET_ADDR_FMT
1001                                           ", the corresponding core might be turned off", component_base);
1002                                 return retval;
1003                         }
1004                         if (((c_cid1 >> 4) & 0x0f) == 1) {
1005                                 retval = dap_lookup_cs_component(ap, component_base,
1006                                                         type, addr, idx);
1007                                 if (retval == ERROR_OK)
1008                                         break;
1009                                 if (retval != ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1010                                         return retval;
1011                         }
1012
1013                         retval = mem_ap_read_atomic_u32(ap, component_base | 0xfcc, &devtype);
1014                         if (retval != ERROR_OK)
1015                                 return retval;
1016                         if ((devtype & 0xff) == type) {
1017                                 if (!*idx) {
1018                                         *addr = component_base;
1019                                         break;
1020                                 } else
1021                                         (*idx)--;
1022                         }
1023                 }
1024                 entry_offset += 4;
1025         } while ((romentry > 0) && (entry_offset < 0xf00));
1026
1027         if (!*addr)
1028                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1029
1030         return ERROR_OK;
1031 }
1032
1033 static int dap_read_part_id(struct adiv5_ap *ap, target_addr_t component_base, uint32_t *cid, uint64_t *pid)
1034 {
1035         assert((component_base & 0xFFF) == 0);
1036         assert(ap && cid && pid);
1037
1038         uint32_t cid0, cid1, cid2, cid3;
1039         uint32_t pid0, pid1, pid2, pid3, pid4;
1040         int retval;
1041
1042         /* IDs are in last 4K section */
1043         retval = mem_ap_read_u32(ap, component_base + 0xFE0, &pid0);
1044         if (retval != ERROR_OK)
1045                 return retval;
1046         retval = mem_ap_read_u32(ap, component_base + 0xFE4, &pid1);
1047         if (retval != ERROR_OK)
1048                 return retval;
1049         retval = mem_ap_read_u32(ap, component_base + 0xFE8, &pid2);
1050         if (retval != ERROR_OK)
1051                 return retval;
1052         retval = mem_ap_read_u32(ap, component_base + 0xFEC, &pid3);
1053         if (retval != ERROR_OK)
1054                 return retval;
1055         retval = mem_ap_read_u32(ap, component_base + 0xFD0, &pid4);
1056         if (retval != ERROR_OK)
1057                 return retval;
1058         retval = mem_ap_read_u32(ap, component_base + 0xFF0, &cid0);
1059         if (retval != ERROR_OK)
1060                 return retval;
1061         retval = mem_ap_read_u32(ap, component_base + 0xFF4, &cid1);
1062         if (retval != ERROR_OK)
1063                 return retval;
1064         retval = mem_ap_read_u32(ap, component_base + 0xFF8, &cid2);
1065         if (retval != ERROR_OK)
1066                 return retval;
1067         retval = mem_ap_read_u32(ap, component_base + 0xFFC, &cid3);
1068         if (retval != ERROR_OK)
1069                 return retval;
1070
1071         retval = dap_run(ap->dap);
1072         if (retval != ERROR_OK)
1073                 return retval;
1074
1075         *cid = (cid3 & 0xff) << 24
1076                         | (cid2 & 0xff) << 16
1077                         | (cid1 & 0xff) << 8
1078                         | (cid0 & 0xff);
1079         *pid = (uint64_t)(pid4 & 0xff) << 32
1080                         | (pid3 & 0xff) << 24
1081                         | (pid2 & 0xff) << 16
1082                         | (pid1 & 0xff) << 8
1083                         | (pid0 & 0xff);
1084
1085         return ERROR_OK;
1086 }
1087
1088 /* The designer identity code is encoded as:
1089  * bits 11:8 : JEP106 Bank (number of continuation codes), only valid when bit 7 is 1.
1090  * bit 7     : Set when bits 6:0 represent a JEP106 ID and cleared when bits 6:0 represent
1091  *             a legacy ASCII Identity Code.
1092  * bits 6:0  : JEP106 Identity Code (without parity) or legacy ASCII code according to bit 7.
1093  * JEP106 is a standard available from jedec.org
1094  */
1095
1096 /* Part number interpretations are from Cortex
1097  * core specs, the CoreSight components TRM
1098  * (ARM DDI 0314H), CoreSight System Design
1099  * Guide (ARM DGI 0012D) and ETM specs; also
1100  * from chip observation (e.g. TI SDTI).
1101  */
1102
1103 /* The legacy code only used the part number field to identify CoreSight peripherals.
1104  * This meant that the same part number from two different manufacturers looked the same.
1105  * It is desirable for all future additions to identify with both part number and JEP106.
1106  * "ANY_ID" is a wildcard (any JEP106) only to preserve legacy behavior for legacy entries.
1107  */
1108
1109 #define ANY_ID 0x1000
1110
1111 #define ARM_ID 0x4BB
1112
1113 static const struct {
1114         uint16_t designer_id;
1115         uint16_t part_num;
1116         const char *type;
1117         const char *full;
1118 } dap_partnums[] = {
1119         { ARM_ID, 0x000, "Cortex-M3 SCS",              "(System Control Space)", },
1120         { ARM_ID, 0x001, "Cortex-M3 ITM",              "(Instrumentation Trace Module)", },
1121         { ARM_ID, 0x002, "Cortex-M3 DWT",              "(Data Watchpoint and Trace)", },
1122         { ARM_ID, 0x003, "Cortex-M3 FPB",              "(Flash Patch and Breakpoint)", },
1123         { ARM_ID, 0x008, "Cortex-M0 SCS",              "(System Control Space)", },
1124         { ARM_ID, 0x00a, "Cortex-M0 DWT",              "(Data Watchpoint and Trace)", },
1125         { ARM_ID, 0x00b, "Cortex-M0 BPU",              "(Breakpoint Unit)", },
1126         { ARM_ID, 0x00c, "Cortex-M4 SCS",              "(System Control Space)", },
1127         { ARM_ID, 0x00d, "CoreSight ETM11",            "(Embedded Trace)", },
1128         { ARM_ID, 0x00e, "Cortex-M7 FPB",              "(Flash Patch and Breakpoint)", },
1129         { ARM_ID, 0x470, "Cortex-M1 ROM",              "(ROM Table)", },
1130         { ARM_ID, 0x471, "Cortex-M0 ROM",              "(ROM Table)", },
1131         { ARM_ID, 0x490, "Cortex-A15 GIC",             "(Generic Interrupt Controller)", },
1132         { ARM_ID, 0x4a1, "Cortex-A53 ROM",             "(v8 Memory Map ROM Table)", },
1133         { ARM_ID, 0x4a2, "Cortex-A57 ROM",             "(ROM Table)", },
1134         { ARM_ID, 0x4a3, "Cortex-A53 ROM",             "(v7 Memory Map ROM Table)", },
1135         { ARM_ID, 0x4a4, "Cortex-A72 ROM",             "(ROM Table)", },
1136         { ARM_ID, 0x4a9, "Cortex-A9 ROM",              "(ROM Table)", },
1137         { ARM_ID, 0x4aa, "Cortex-A35 ROM",             "(v8 Memory Map ROM Table)", },
1138         { ARM_ID, 0x4af, "Cortex-A15 ROM",             "(ROM Table)", },
1139         { ARM_ID, 0x4b5, "Cortex-R5 ROM",              "(ROM Table)", },
1140         { ARM_ID, 0x4c0, "Cortex-M0+ ROM",             "(ROM Table)", },
1141         { ARM_ID, 0x4c3, "Cortex-M3 ROM",              "(ROM Table)", },
1142         { ARM_ID, 0x4c4, "Cortex-M4 ROM",              "(ROM Table)", },
1143         { ARM_ID, 0x4c7, "Cortex-M7 PPB ROM",          "(Private Peripheral Bus ROM Table)", },
1144         { ARM_ID, 0x4c8, "Cortex-M7 ROM",              "(ROM Table)", },
1145         { ARM_ID, 0x4e0, "Cortex-A35 ROM",             "(v7 Memory Map ROM Table)", },
1146         { ARM_ID, 0x4e4, "Cortex-A76 ROM",             "(ROM Table)", },
1147         { ARM_ID, 0x906, "CoreSight CTI",              "(Cross Trigger)", },
1148         { ARM_ID, 0x907, "CoreSight ETB",              "(Trace Buffer)", },
1149         { ARM_ID, 0x908, "CoreSight CSTF",             "(Trace Funnel)", },
1150         { ARM_ID, 0x909, "CoreSight ATBR",             "(Advanced Trace Bus Replicator)", },
1151         { ARM_ID, 0x910, "CoreSight ETM9",             "(Embedded Trace)", },
1152         { ARM_ID, 0x912, "CoreSight TPIU",             "(Trace Port Interface Unit)", },
1153         { ARM_ID, 0x913, "CoreSight ITM",              "(Instrumentation Trace Macrocell)", },
1154         { ARM_ID, 0x914, "CoreSight SWO",              "(Single Wire Output)", },
1155         { ARM_ID, 0x917, "CoreSight HTM",              "(AHB Trace Macrocell)", },
1156         { ARM_ID, 0x920, "CoreSight ETM11",            "(Embedded Trace)", },
1157         { ARM_ID, 0x921, "Cortex-A8 ETM",              "(Embedded Trace)", },
1158         { ARM_ID, 0x922, "Cortex-A8 CTI",              "(Cross Trigger)", },
1159         { ARM_ID, 0x923, "Cortex-M3 TPIU",             "(Trace Port Interface Unit)", },
1160         { ARM_ID, 0x924, "Cortex-M3 ETM",              "(Embedded Trace)", },
1161         { ARM_ID, 0x925, "Cortex-M4 ETM",              "(Embedded Trace)", },
1162         { ARM_ID, 0x930, "Cortex-R4 ETM",              "(Embedded Trace)", },
1163         { ARM_ID, 0x931, "Cortex-R5 ETM",              "(Embedded Trace)", },
1164         { ARM_ID, 0x932, "CoreSight MTB-M0+",          "(Micro Trace Buffer)", },
1165         { ARM_ID, 0x941, "CoreSight TPIU-Lite",        "(Trace Port Interface Unit)", },
1166         { ARM_ID, 0x950, "Cortex-A9 PTM",              "(Program Trace Macrocell)", },
1167         { ARM_ID, 0x955, "Cortex-A5 ETM",              "(Embedded Trace)", },
1168         { ARM_ID, 0x95a, "Cortex-A72 ETM",             "(Embedded Trace)", },
1169         { ARM_ID, 0x95b, "Cortex-A17 PTM",             "(Program Trace Macrocell)", },
1170         { ARM_ID, 0x95d, "Cortex-A53 ETM",             "(Embedded Trace)", },
1171         { ARM_ID, 0x95e, "Cortex-A57 ETM",             "(Embedded Trace)", },
1172         { ARM_ID, 0x95f, "Cortex-A15 PTM",             "(Program Trace Macrocell)", },
1173         { ARM_ID, 0x961, "CoreSight TMC",              "(Trace Memory Controller)", },
1174         { ARM_ID, 0x962, "CoreSight STM",              "(System Trace Macrocell)", },
1175         { ARM_ID, 0x975, "Cortex-M7 ETM",              "(Embedded Trace)", },
1176         { ARM_ID, 0x9a0, "CoreSight PMU",              "(Performance Monitoring Unit)", },
1177         { ARM_ID, 0x9a1, "Cortex-M4 TPIU",             "(Trace Port Interface Unit)", },
1178         { ARM_ID, 0x9a4, "CoreSight GPR",              "(Granular Power Requester)", },
1179         { ARM_ID, 0x9a5, "Cortex-A5 PMU",              "(Performance Monitor Unit)", },
1180         { ARM_ID, 0x9a7, "Cortex-A7 PMU",              "(Performance Monitor Unit)", },
1181         { ARM_ID, 0x9a8, "Cortex-A53 CTI",             "(Cross Trigger)", },
1182         { ARM_ID, 0x9a9, "Cortex-M7 TPIU",             "(Trace Port Interface Unit)", },
1183         { ARM_ID, 0x9ae, "Cortex-A17 PMU",             "(Performance Monitor Unit)", },
1184         { ARM_ID, 0x9af, "Cortex-A15 PMU",             "(Performance Monitor Unit)", },
1185         { ARM_ID, 0x9b7, "Cortex-R7 PMU",              "(Performance Monitor Unit)", },
1186         { ARM_ID, 0x9d3, "Cortex-A53 PMU",             "(Performance Monitor Unit)", },
1187         { ARM_ID, 0x9d7, "Cortex-A57 PMU",             "(Performance Monitor Unit)", },
1188         { ARM_ID, 0x9d8, "Cortex-A72 PMU",             "(Performance Monitor Unit)", },
1189         { ARM_ID, 0x9da, "Cortex-A35 PMU/CTI/ETM",     "(Performance Monitor Unit/Cross Trigger/ETM)", },
1190         { ARM_ID, 0xc05, "Cortex-A5 Debug",            "(Debug Unit)", },
1191         { ARM_ID, 0xc07, "Cortex-A7 Debug",            "(Debug Unit)", },
1192         { ARM_ID, 0xc08, "Cortex-A8 Debug",            "(Debug Unit)", },
1193         { ARM_ID, 0xc09, "Cortex-A9 Debug",            "(Debug Unit)", },
1194         { ARM_ID, 0xc0e, "Cortex-A17 Debug",           "(Debug Unit)", },
1195         { ARM_ID, 0xc0f, "Cortex-A15 Debug",           "(Debug Unit)", },
1196         { ARM_ID, 0xc14, "Cortex-R4 Debug",            "(Debug Unit)", },
1197         { ARM_ID, 0xc15, "Cortex-R5 Debug",            "(Debug Unit)", },
1198         { ARM_ID, 0xc17, "Cortex-R7 Debug",            "(Debug Unit)", },
1199         { ARM_ID, 0xd03, "Cortex-A53 Debug",           "(Debug Unit)", },
1200         { ARM_ID, 0xd04, "Cortex-A35 Debug",           "(Debug Unit)", },
1201         { ARM_ID, 0xd07, "Cortex-A57 Debug",           "(Debug Unit)", },
1202         { ARM_ID, 0xd08, "Cortex-A72 Debug",           "(Debug Unit)", },
1203         { ARM_ID, 0xd0b, "Cortex-A76 Debug",           "(Debug Unit)", },
1204         { 0x097,  0x9af, "MSP432 ROM",                 "(ROM Table)" },
1205         { 0x09f,  0xcd0, "Atmel CPU with DSU",         "(CPU)" },
1206         { 0x0c1,  0x1db, "XMC4500 ROM",                "(ROM Table)" },
1207         { 0x0c1,  0x1df, "XMC4700/4800 ROM",           "(ROM Table)" },
1208         { 0x0c1,  0x1ed, "XMC1000 ROM",                "(ROM Table)" },
1209         { 0x0E5,  0x000, "SHARC+/Blackfin+",           "", },
1210         { 0x0F0,  0x440, "Qualcomm QDSS Component v1", "(Qualcomm Designed CoreSight Component v1)", },
1211         { 0x1bf,  0x100, "Brahma-B53 Debug",           "(Debug Unit)", },
1212         { 0x1bf,  0x9d3, "Brahma-B53 PMU",             "(Performance Monitor Unit)", },
1213         { 0x1bf,  0x4a1, "Brahma-B53 ROM",             "(ROM Table)", },
1214         { 0x1bf,  0x721, "Brahma-B53 ROM",             "(ROM Table)", },
1215         { 0x3eb,  0x181, "Tegra 186 ROM",              "(ROM Table)", },
1216         { 0x3eb,  0x202, "Denver ETM",                 "(Denver Embedded Trace)", },
1217         { 0x3eb,  0x211, "Tegra 210 ROM",              "(ROM Table)", },
1218         { 0x3eb,  0x302, "Denver Debug",               "(Debug Unit)", },
1219         { 0x3eb,  0x402, "Denver PMU",                 "(Performance Monitor Unit)", },
1220         /* legacy comment: 0x113: what? */
1221         { ANY_ID, 0x120, "TI SDTI",                    "(System Debug Trace Interface)", }, /* from OMAP3 memmap */
1222         { ANY_ID, 0x343, "TI DAPCTL",                  "", }, /* from OMAP3 memmap */
1223 };
1224
1225 static int dap_rom_display(struct command_invocation *cmd,
1226                                 struct adiv5_ap *ap, target_addr_t dbgbase, int depth)
1227 {
1228         int retval;
1229         uint64_t pid;
1230         uint32_t cid;
1231         char tabs[16] = "";
1232
1233         if (depth > 16) {
1234                 command_print(cmd, "\tTables too deep");
1235                 return ERROR_FAIL;
1236         }
1237
1238         if (depth)
1239                 snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
1240
1241         target_addr_t base_addr = dbgbase & 0xFFFFFFFFFFFFF000ull;
1242         command_print(cmd, "\t\tComponent base address " TARGET_ADDR_FMT, base_addr);
1243
1244         retval = dap_read_part_id(ap, base_addr, &cid, &pid);
1245         if (retval != ERROR_OK) {
1246                 command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off");
1247                 return ERROR_OK; /* Don't abort recursion */
1248         }
1249
1250         if (!is_dap_cid_ok(cid)) {
1251                 command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid);
1252                 return ERROR_OK; /* Don't abort recursion */
1253         }
1254
1255         /* component may take multiple 4K pages */
1256         uint32_t size = (pid >> 36) & 0xf;
1257         if (size > 0)
1258                 command_print(cmd, "\t\tStart address " TARGET_ADDR_FMT, base_addr - 0x1000 * size);
1259
1260         command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid);
1261
1262         uint8_t class = (cid >> 12) & 0xf;
1263         uint16_t part_num = pid & 0xfff;
1264         uint16_t designer_id = ((pid >> 32) & 0xf) << 8 | ((pid >> 12) & 0xff);
1265
1266         if (designer_id & 0x80) {
1267                 /* JEP106 code */
1268                 command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s",
1269                                 designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
1270         } else {
1271                 /* Legacy ASCII ID, clear invalid bits */
1272                 designer_id &= 0x7f;
1273                 command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
1274                                 designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
1275         }
1276
1277         /* default values to be overwritten upon finding a match */
1278         const char *type = "Unrecognized";
1279         const char *full = "";
1280
1281         /* search dap_partnums[] array for a match */
1282         for (unsigned entry = 0; entry < ARRAY_SIZE(dap_partnums); entry++) {
1283
1284                 if ((dap_partnums[entry].designer_id != designer_id) && (dap_partnums[entry].designer_id != ANY_ID))
1285                         continue;
1286
1287                 if (dap_partnums[entry].part_num != part_num)
1288                         continue;
1289
1290                 type = dap_partnums[entry].type;
1291                 full = dap_partnums[entry].full;
1292                 break;
1293         }
1294
1295         command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
1296         command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
1297
1298         if (class == 1) { /* ROM Table */
1299                 uint32_t memtype;
1300                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &memtype);
1301                 if (retval != ERROR_OK)
1302                         return retval;
1303
1304                 if (memtype & 0x01)
1305                         command_print(cmd, "\t\tMEMTYPE system memory present on bus");
1306                 else
1307                         command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus");
1308
1309                 /* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
1310                 for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
1311                         uint32_t romentry;
1312                         retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
1313                         if (retval != ERROR_OK)
1314                                 return retval;
1315                         command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
1316                                         tabs, entry_offset, romentry);
1317                         if (romentry & 0x01) {
1318                                 /* Recurse. "romentry" is signed */
1319                                 retval = dap_rom_display(cmd, ap, base_addr + (int32_t)(romentry & 0xFFFFF000), depth + 1);
1320                                 if (retval != ERROR_OK)
1321                                         return retval;
1322                         } else if (romentry != 0) {
1323                                 command_print(cmd, "\t\tComponent not present");
1324                         } else {
1325                                 command_print(cmd, "\t%s\tEnd of ROM table", tabs);
1326                                 break;
1327                         }
1328                 }
1329         } else if (class == 9) { /* CoreSight component */
1330                 const char *major = "Reserved", *subtype = "Reserved";
1331
1332                 uint32_t devtype;
1333                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &devtype);
1334                 if (retval != ERROR_OK)
1335                         return retval;
1336                 unsigned minor = (devtype >> 4) & 0x0f;
1337                 switch (devtype & 0x0f) {
1338                 case 0:
1339                         major = "Miscellaneous";
1340                         switch (minor) {
1341                         case 0:
1342                                 subtype = "other";
1343                                 break;
1344                         case 4:
1345                                 subtype = "Validation component";
1346                                 break;
1347                         }
1348                         break;
1349                 case 1:
1350                         major = "Trace Sink";
1351                         switch (minor) {
1352                         case 0:
1353                                 subtype = "other";
1354                                 break;
1355                         case 1:
1356                                 subtype = "Port";
1357                                 break;
1358                         case 2:
1359                                 subtype = "Buffer";
1360                                 break;
1361                         case 3:
1362                                 subtype = "Router";
1363                                 break;
1364                         }
1365                         break;
1366                 case 2:
1367                         major = "Trace Link";
1368                         switch (minor) {
1369                         case 0:
1370                                 subtype = "other";
1371                                 break;
1372                         case 1:
1373                                 subtype = "Funnel, router";
1374                                 break;
1375                         case 2:
1376                                 subtype = "Filter";
1377                                 break;
1378                         case 3:
1379                                 subtype = "FIFO, buffer";
1380                                 break;
1381                         }
1382                         break;
1383                 case 3:
1384                         major = "Trace Source";
1385                         switch (minor) {
1386                         case 0:
1387                                 subtype = "other";
1388                                 break;
1389                         case 1:
1390                                 subtype = "Processor";
1391                                 break;
1392                         case 2:
1393                                 subtype = "DSP";
1394                                 break;
1395                         case 3:
1396                                 subtype = "Engine/Coprocessor";
1397                                 break;
1398                         case 4:
1399                                 subtype = "Bus";
1400                                 break;
1401                         case 6:
1402                                 subtype = "Software";
1403                                 break;
1404                         }
1405                         break;
1406                 case 4:
1407                         major = "Debug Control";
1408                         switch (minor) {
1409                         case 0:
1410                                 subtype = "other";
1411                                 break;
1412                         case 1:
1413                                 subtype = "Trigger Matrix";
1414                                 break;
1415                         case 2:
1416                                 subtype = "Debug Auth";
1417                                 break;
1418                         case 3:
1419                                 subtype = "Power Requestor";
1420                                 break;
1421                         }
1422                         break;
1423                 case 5:
1424                         major = "Debug Logic";
1425                         switch (minor) {
1426                         case 0:
1427                                 subtype = "other";
1428                                 break;
1429                         case 1:
1430                                 subtype = "Processor";
1431                                 break;
1432                         case 2:
1433                                 subtype = "DSP";
1434                                 break;
1435                         case 3:
1436                                 subtype = "Engine/Coprocessor";
1437                                 break;
1438                         case 4:
1439                                 subtype = "Bus";
1440                                 break;
1441                         case 5:
1442                                 subtype = "Memory";
1443                                 break;
1444                         }
1445                         break;
1446                 case 6:
1447                         major = "Performance Monitor";
1448                         switch (minor) {
1449                         case 0:
1450                                 subtype = "other";
1451                                 break;
1452                         case 1:
1453                                 subtype = "Processor";
1454                                 break;
1455                         case 2:
1456                                 subtype = "DSP";
1457                                 break;
1458                         case 3:
1459                                 subtype = "Engine/Coprocessor";
1460                                 break;
1461                         case 4:
1462                                 subtype = "Bus";
1463                                 break;
1464                         case 5:
1465                                 subtype = "Memory";
1466                                 break;
1467                         }
1468                         break;
1469                 }
1470                 command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s",
1471                                 (uint8_t)(devtype & 0xff),
1472                                 major, subtype);
1473                 /* REVISIT also show 0xfc8 DevId */
1474         }
1475
1476         return ERROR_OK;
1477 }
1478
1479 int dap_info_command(struct command_invocation *cmd,
1480                 struct adiv5_ap *ap)
1481 {
1482         int retval;
1483         uint32_t apid;
1484         target_addr_t dbgbase;
1485         target_addr_t dbgaddr;
1486         uint8_t mem_ap;
1487
1488         /* Now we read ROM table ID registers, ref. ARM IHI 0029B sec  */
1489         retval = dap_get_debugbase(ap, &dbgbase, &apid);
1490         if (retval != ERROR_OK)
1491                 return retval;
1492
1493         command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
1494         if (apid == 0) {
1495                 command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
1496                 return ERROR_FAIL;
1497         }
1498
1499         switch (apid & (IDR_JEP106 | IDR_TYPE)) {
1500         case IDR_JEP106_ARM | AP_TYPE_JTAG_AP:
1501                 command_print(cmd, "\tType is JTAG-AP");
1502                 break;
1503         case IDR_JEP106_ARM | AP_TYPE_AHB3_AP:
1504                 command_print(cmd, "\tType is MEM-AP AHB3");
1505                 break;
1506         case IDR_JEP106_ARM | AP_TYPE_AHB5_AP:
1507                 command_print(cmd, "\tType is MEM-AP AHB5");
1508                 break;
1509         case IDR_JEP106_ARM | AP_TYPE_APB_AP:
1510                 command_print(cmd, "\tType is MEM-AP APB");
1511                 break;
1512         case IDR_JEP106_ARM | AP_TYPE_AXI_AP:
1513                 command_print(cmd, "\tType is MEM-AP AXI");
1514                 break;
1515         default:
1516                 command_print(cmd, "\tUnknown AP type");
1517                 break;
1518         }
1519
1520         /* NOTE: a MEM-AP may have a single CoreSight component that's
1521          * not a ROM table ... or have no such components at all.
1522          */
1523         mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP;
1524         if (mem_ap) {
1525                 if (is_64bit_ap(ap))
1526                         dbgaddr = 0xFFFFFFFFFFFFFFFFull;
1527                 else
1528                         dbgaddr = 0xFFFFFFFFul;
1529
1530                 command_print(cmd, "MEM-AP BASE " TARGET_ADDR_FMT, dbgbase);
1531
1532                 if (dbgbase == dbgaddr || (dbgbase & 0x3) == 0x2) {
1533                         command_print(cmd, "\tNo ROM table present");
1534                 } else {
1535                         if (dbgbase & 0x01)
1536                                 command_print(cmd, "\tValid ROM table present");
1537                         else
1538                                 command_print(cmd, "\tROM table in legacy format");
1539
1540                         dap_rom_display(cmd, ap, dbgbase & 0xFFFFFFFFFFFFF000ull, 0);
1541                 }
1542         }
1543
1544         return ERROR_OK;
1545 }
1546
1547 enum adiv5_cfg_param {
1548         CFG_DAP,
1549         CFG_AP_NUM,
1550         CFG_BASEADDR,
1551         CFG_CTIBASE, /* DEPRECATED */
1552 };
1553
1554 static const struct jim_nvp nvp_config_opts[] = {
1555         { .name = "-dap",       .value = CFG_DAP },
1556         { .name = "-ap-num",    .value = CFG_AP_NUM },
1557         { .name = "-baseaddr",  .value = CFG_BASEADDR },
1558         { .name = "-ctibase",   .value = CFG_CTIBASE }, /* DEPRECATED */
1559         { .name = NULL, .value = -1 }
1560 };
1561
1562 static int adiv5_jim_spot_configure(struct jim_getopt_info *goi,
1563                 struct adiv5_dap **dap_p, int *ap_num_p, uint32_t *base_p)
1564 {
1565         if (!goi->argc)
1566                 return JIM_OK;
1567
1568         Jim_SetEmptyResult(goi->interp);
1569
1570         struct jim_nvp *n;
1571         int e = jim_nvp_name2value_obj(goi->interp, nvp_config_opts,
1572                                 goi->argv[0], &n);
1573         if (e != JIM_OK)
1574                 return JIM_CONTINUE;
1575
1576         /* base_p can be NULL, then '-baseaddr' option is treated as unknown */
1577         if (!base_p && (n->value == CFG_BASEADDR || n->value == CFG_CTIBASE))
1578                 return JIM_CONTINUE;
1579
1580         e = jim_getopt_obj(goi, NULL);
1581         if (e != JIM_OK)
1582                 return e;
1583
1584         switch (n->value) {
1585         case CFG_DAP:
1586                 if (goi->isconfigure) {
1587                         Jim_Obj *o_t;
1588                         struct adiv5_dap *dap;
1589                         e = jim_getopt_obj(goi, &o_t);
1590                         if (e != JIM_OK)
1591                                 return e;
1592                         dap = dap_instance_by_jim_obj(goi->interp, o_t);
1593                         if (!dap) {
1594                                 Jim_SetResultString(goi->interp, "DAP name invalid!", -1);
1595                                 return JIM_ERR;
1596                         }
1597                         if (*dap_p && *dap_p != dap) {
1598                                 Jim_SetResultString(goi->interp,
1599                                         "DAP assignment cannot be changed!", -1);
1600                                 return JIM_ERR;
1601                         }
1602                         *dap_p = dap;
1603                 } else {
1604                         if (goi->argc)
1605                                 goto err_no_param;
1606                         if (!*dap_p) {
1607                                 Jim_SetResultString(goi->interp, "DAP not configured", -1);
1608                                 return JIM_ERR;
1609                         }
1610                         Jim_SetResultString(goi->interp, adiv5_dap_name(*dap_p), -1);
1611                 }
1612                 break;
1613
1614         case CFG_AP_NUM:
1615                 if (goi->isconfigure) {
1616                         jim_wide ap_num;
1617                         e = jim_getopt_wide(goi, &ap_num);
1618                         if (e != JIM_OK)
1619                                 return e;
1620                         if (ap_num < 0 || ap_num > DP_APSEL_MAX) {
1621                                 Jim_SetResultString(goi->interp, "Invalid AP number!", -1);
1622                                 return JIM_ERR;
1623                         }
1624                         *ap_num_p = ap_num;
1625                 } else {
1626                         if (goi->argc)
1627                                 goto err_no_param;
1628                         if (*ap_num_p == DP_APSEL_INVALID) {
1629                                 Jim_SetResultString(goi->interp, "AP number not configured", -1);
1630                                 return JIM_ERR;
1631                         }
1632                         Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, *ap_num_p));
1633                 }
1634                 break;
1635
1636         case CFG_CTIBASE:
1637                 LOG_WARNING("DEPRECATED! use \'-baseaddr' not \'-ctibase\'");
1638                 /* fall through */
1639         case CFG_BASEADDR:
1640                 if (goi->isconfigure) {
1641                         jim_wide base;
1642                         e = jim_getopt_wide(goi, &base);
1643                         if (e != JIM_OK)
1644                                 return e;
1645                         *base_p = (uint32_t)base;
1646                 } else {
1647                         if (goi->argc)
1648                                 goto err_no_param;
1649                         Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, *base_p));
1650                 }
1651                 break;
1652         };
1653
1654         return JIM_OK;
1655
1656 err_no_param:
1657         Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
1658         return JIM_ERR;
1659 }
1660
1661 int adiv5_jim_configure(struct target *target, struct jim_getopt_info *goi)
1662 {
1663         struct adiv5_private_config *pc;
1664         int e;
1665
1666         pc = (struct adiv5_private_config *)target->private_config;
1667         if (!pc) {
1668                 pc = calloc(1, sizeof(struct adiv5_private_config));
1669                 pc->ap_num = DP_APSEL_INVALID;
1670                 target->private_config = pc;
1671         }
1672
1673         target->has_dap = true;
1674
1675         e = adiv5_jim_spot_configure(goi, &pc->dap, &pc->ap_num, NULL);
1676         if (e != JIM_OK)
1677                 return e;
1678
1679         if (pc->dap && !target->dap_configured) {
1680                 if (target->tap_configured) {
1681                         pc->dap = NULL;
1682                         Jim_SetResultString(goi->interp,
1683                                 "-chain-position and -dap configparams are mutually exclusive!", -1);
1684                         return JIM_ERR;
1685                 }
1686                 target->tap = pc->dap->tap;
1687                 target->dap_configured = true;
1688         }
1689
1690         return JIM_OK;
1691 }
1692
1693 int adiv5_verify_config(struct adiv5_private_config *pc)
1694 {
1695         if (!pc)
1696                 return ERROR_FAIL;
1697
1698         if (!pc->dap)
1699                 return ERROR_FAIL;
1700
1701         return ERROR_OK;
1702 }
1703
1704 int adiv5_jim_mem_ap_spot_configure(struct adiv5_mem_ap_spot *cfg,
1705                 struct jim_getopt_info *goi)
1706 {
1707         return adiv5_jim_spot_configure(goi, &cfg->dap, &cfg->ap_num, &cfg->base);
1708 }
1709
1710 int adiv5_mem_ap_spot_init(struct adiv5_mem_ap_spot *p)
1711 {
1712         p->dap = NULL;
1713         p->ap_num = DP_APSEL_INVALID;
1714         p->base = 0;
1715         return ERROR_OK;
1716 }
1717
1718 COMMAND_HANDLER(handle_dap_info_command)
1719 {
1720         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1721         uint32_t apsel;
1722
1723         switch (CMD_ARGC) {
1724         case 0:
1725                 apsel = dap->apsel;
1726                 break;
1727         case 1:
1728                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1729                 if (apsel > DP_APSEL_MAX) {
1730                         command_print(CMD, "Invalid AP number");
1731                         return ERROR_COMMAND_ARGUMENT_INVALID;
1732                 }
1733                 break;
1734         default:
1735                 return ERROR_COMMAND_SYNTAX_ERROR;
1736         }
1737
1738         return dap_info_command(CMD, &dap->ap[apsel]);
1739 }
1740
1741 COMMAND_HANDLER(dap_baseaddr_command)
1742 {
1743         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1744         uint32_t apsel, baseaddr_lower, baseaddr_upper;
1745         struct adiv5_ap *ap;
1746         target_addr_t baseaddr;
1747         int retval;
1748
1749         baseaddr_upper = 0;
1750
1751         switch (CMD_ARGC) {
1752         case 0:
1753                 apsel = dap->apsel;
1754                 break;
1755         case 1:
1756                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1757                 /* AP address is in bits 31:24 of DP_SELECT */
1758                 if (apsel > DP_APSEL_MAX) {
1759                         command_print(CMD, "Invalid AP number");
1760                         return ERROR_COMMAND_ARGUMENT_INVALID;
1761                 }
1762                 break;
1763         default:
1764                 return ERROR_COMMAND_SYNTAX_ERROR;
1765         }
1766
1767         /* NOTE:  assumes we're talking to a MEM-AP, which
1768          * has a base address.  There are other kinds of AP,
1769          * though they're not common for now.  This should
1770          * use the ID register to verify it's a MEM-AP.
1771          */
1772
1773         ap = dap_ap(dap, apsel);
1774         retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, &baseaddr_lower);
1775
1776         if (retval == ERROR_OK && ap->cfg_reg == MEM_AP_REG_CFG_INVALID)
1777                 retval = dap_queue_ap_read(ap, MEM_AP_REG_CFG, &ap->cfg_reg);
1778
1779         if (retval == ERROR_OK && (ap->cfg_reg == MEM_AP_REG_CFG_INVALID || is_64bit_ap(ap))) {
1780                 /* MEM_AP_REG_BASE64 is defined as 'RES0'; can be read and then ignored on 32 bits AP */
1781                 retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE64, &baseaddr_upper);
1782         }
1783
1784         if (retval == ERROR_OK)
1785                 retval = dap_run(dap);
1786         if (retval != ERROR_OK)
1787                 return retval;
1788
1789         if (is_64bit_ap(ap)) {
1790                 baseaddr = (((target_addr_t)baseaddr_upper) << 32) | baseaddr_lower;
1791                 command_print(CMD, "0x%016" PRIx64, baseaddr);
1792         } else
1793                 command_print(CMD, "0x%08" PRIx32, baseaddr_lower);
1794
1795         return ERROR_OK;
1796 }
1797
1798 COMMAND_HANDLER(dap_memaccess_command)
1799 {
1800         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1801         uint32_t memaccess_tck;
1802
1803         switch (CMD_ARGC) {
1804         case 0:
1805                 memaccess_tck = dap->ap[dap->apsel].memaccess_tck;
1806                 break;
1807         case 1:
1808                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], memaccess_tck);
1809                 break;
1810         default:
1811                 return ERROR_COMMAND_SYNTAX_ERROR;
1812         }
1813         dap->ap[dap->apsel].memaccess_tck = memaccess_tck;
1814
1815         command_print(CMD, "memory bus access delay set to %" PRIu32 " tck",
1816                         dap->ap[dap->apsel].memaccess_tck);
1817
1818         return ERROR_OK;
1819 }
1820
1821 COMMAND_HANDLER(dap_apsel_command)
1822 {
1823         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1824         uint32_t apsel;
1825
1826         switch (CMD_ARGC) {
1827         case 0:
1828                 command_print(CMD, "%" PRIu32, dap->apsel);
1829                 return ERROR_OK;
1830         case 1:
1831                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1832                 /* AP address is in bits 31:24 of DP_SELECT */
1833                 if (apsel > DP_APSEL_MAX) {
1834                         command_print(CMD, "Invalid AP number");
1835                         return ERROR_COMMAND_ARGUMENT_INVALID;
1836                 }
1837                 break;
1838         default:
1839                 return ERROR_COMMAND_SYNTAX_ERROR;
1840         }
1841
1842         dap->apsel = apsel;
1843         return ERROR_OK;
1844 }
1845
1846 COMMAND_HANDLER(dap_apcsw_command)
1847 {
1848         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1849         uint32_t apcsw = dap->ap[dap->apsel].csw_default;
1850         uint32_t csw_val, csw_mask;
1851
1852         switch (CMD_ARGC) {
1853         case 0:
1854                 command_print(CMD, "ap %" PRIu32 " selected, csw 0x%8.8" PRIx32,
1855                         dap->apsel, apcsw);
1856                 return ERROR_OK;
1857         case 1:
1858                 if (strcmp(CMD_ARGV[0], "default") == 0)
1859                         csw_val = CSW_AHB_DEFAULT;
1860                 else
1861                         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1862
1863                 if (csw_val & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1864                         LOG_ERROR("CSW value cannot include 'Size' and 'AddrInc' bit-fields");
1865                         return ERROR_COMMAND_ARGUMENT_INVALID;
1866                 }
1867                 apcsw = csw_val;
1868                 break;
1869         case 2:
1870                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1871                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], csw_mask);
1872                 if (csw_mask & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1873                         LOG_ERROR("CSW mask cannot include 'Size' and 'AddrInc' bit-fields");
1874                         return ERROR_COMMAND_ARGUMENT_INVALID;
1875                 }
1876                 apcsw = (apcsw & ~csw_mask) | (csw_val & csw_mask);
1877                 break;
1878         default:
1879                 return ERROR_COMMAND_SYNTAX_ERROR;
1880         }
1881         dap->ap[dap->apsel].csw_default = apcsw;
1882
1883         return 0;
1884 }
1885
1886
1887
1888 COMMAND_HANDLER(dap_apid_command)
1889 {
1890         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1891         uint32_t apsel, apid;
1892         int retval;
1893
1894         switch (CMD_ARGC) {
1895         case 0:
1896                 apsel = dap->apsel;
1897                 break;
1898         case 1:
1899                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1900                 /* AP address is in bits 31:24 of DP_SELECT */
1901                 if (apsel > DP_APSEL_MAX) {
1902                         command_print(CMD, "Invalid AP number");
1903                         return ERROR_COMMAND_ARGUMENT_INVALID;
1904                 }
1905                 break;
1906         default:
1907                 return ERROR_COMMAND_SYNTAX_ERROR;
1908         }
1909
1910         retval = dap_queue_ap_read(dap_ap(dap, apsel), AP_REG_IDR, &apid);
1911         if (retval != ERROR_OK)
1912                 return retval;
1913         retval = dap_run(dap);
1914         if (retval != ERROR_OK)
1915                 return retval;
1916
1917         command_print(CMD, "0x%8.8" PRIx32, apid);
1918
1919         return retval;
1920 }
1921
1922 COMMAND_HANDLER(dap_apreg_command)
1923 {
1924         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1925         uint32_t apsel, reg, value;
1926         struct adiv5_ap *ap;
1927         int retval;
1928
1929         if (CMD_ARGC < 2 || CMD_ARGC > 3)
1930                 return ERROR_COMMAND_SYNTAX_ERROR;
1931
1932         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1933         /* AP address is in bits 31:24 of DP_SELECT */
1934         if (apsel > DP_APSEL_MAX) {
1935                 command_print(CMD, "Invalid AP number");
1936                 return ERROR_COMMAND_ARGUMENT_INVALID;
1937         }
1938
1939         ap = dap_ap(dap, apsel);
1940
1941         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], reg);
1942         if (reg >= 256 || (reg & 3)) {
1943                 command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
1944                 return ERROR_COMMAND_ARGUMENT_INVALID;
1945         }
1946
1947         if (CMD_ARGC == 3) {
1948                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
1949                 switch (reg) {
1950                 case MEM_AP_REG_CSW:
1951                         ap->csw_value = 0;  /* invalid, in case write fails */
1952                         retval = dap_queue_ap_write(ap, reg, value);
1953                         if (retval == ERROR_OK)
1954                                 ap->csw_value = value;
1955                         break;
1956                 case MEM_AP_REG_TAR:
1957                         retval = dap_queue_ap_write(ap, reg, value);
1958                         if (retval == ERROR_OK)
1959                                 ap->tar_value = (ap->tar_value & ~0xFFFFFFFFull) | value;
1960                         else {
1961                                 /* To track independent writes to TAR and TAR64, two tar_valid flags */
1962                                 /* should be used. To keep it simple, tar_valid is only invalidated on a */
1963                                 /* write fail. This approach causes a later re-write of the TAR and TAR64 */
1964                                 /* if tar_valid is false. */
1965                                 ap->tar_valid = false;
1966                         }
1967                         break;
1968                 case MEM_AP_REG_TAR64:
1969                         retval = dap_queue_ap_write(ap, reg, value);
1970                         if (retval == ERROR_OK)
1971                                 ap->tar_value = (ap->tar_value & 0xFFFFFFFFull) | (((target_addr_t)value) << 32);
1972                         else {
1973                                 /* See above comment for the MEM_AP_REG_TAR failed write case */
1974                                 ap->tar_valid = false;
1975                         }
1976                         break;
1977                 default:
1978                         retval = dap_queue_ap_write(ap, reg, value);
1979                         break;
1980                 }
1981         } else {
1982                 retval = dap_queue_ap_read(ap, reg, &value);
1983         }
1984         if (retval == ERROR_OK)
1985                 retval = dap_run(dap);
1986
1987         if (retval != ERROR_OK)
1988                 return retval;
1989
1990         if (CMD_ARGC == 2)
1991                 command_print(CMD, "0x%08" PRIx32, value);
1992
1993         return retval;
1994 }
1995
1996 COMMAND_HANDLER(dap_dpreg_command)
1997 {
1998         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1999         uint32_t reg, value;
2000         int retval;
2001
2002         if (CMD_ARGC < 1 || CMD_ARGC > 2)
2003                 return ERROR_COMMAND_SYNTAX_ERROR;
2004
2005         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg);
2006         if (reg >= 256 || (reg & 3)) {
2007                 command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
2008                 return ERROR_COMMAND_ARGUMENT_INVALID;
2009         }
2010
2011         if (CMD_ARGC == 2) {
2012                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2013                 retval = dap_queue_dp_write(dap, reg, value);
2014         } else {
2015                 retval = dap_queue_dp_read(dap, reg, &value);
2016         }
2017         if (retval == ERROR_OK)
2018                 retval = dap_run(dap);
2019
2020         if (retval != ERROR_OK)
2021                 return retval;
2022
2023         if (CMD_ARGC == 1)
2024                 command_print(CMD, "0x%08" PRIx32, value);
2025
2026         return retval;
2027 }
2028
2029 COMMAND_HANDLER(dap_ti_be_32_quirks_command)
2030 {
2031         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
2032         return CALL_COMMAND_HANDLER(handle_command_parse_bool, &dap->ti_be_32_quirks,
2033                 "TI BE-32 quirks mode");
2034 }
2035
2036 const struct command_registration dap_instance_commands[] = {
2037         {
2038                 .name = "info",
2039                 .handler = handle_dap_info_command,
2040                 .mode = COMMAND_EXEC,
2041                 .help = "display ROM table for MEM-AP "
2042                         "(default currently selected AP)",
2043                 .usage = "[ap_num]",
2044         },
2045         {
2046                 .name = "apsel",
2047                 .handler = dap_apsel_command,
2048                 .mode = COMMAND_ANY,
2049                 .help = "Set the currently selected AP (default 0) "
2050                         "and display the result",
2051                 .usage = "[ap_num]",
2052         },
2053         {
2054                 .name = "apcsw",
2055                 .handler = dap_apcsw_command,
2056                 .mode = COMMAND_ANY,
2057                 .help = "Set CSW default bits",
2058                 .usage = "[value [mask]]",
2059         },
2060
2061         {
2062                 .name = "apid",
2063                 .handler = dap_apid_command,
2064                 .mode = COMMAND_EXEC,
2065                 .help = "return ID register from AP "
2066                         "(default currently selected AP)",
2067                 .usage = "[ap_num]",
2068         },
2069         {
2070                 .name = "apreg",
2071                 .handler = dap_apreg_command,
2072                 .mode = COMMAND_EXEC,
2073                 .help = "read/write a register from AP "
2074                         "(reg is byte address of a word register, like 0 4 8...)",
2075                 .usage = "ap_num reg [value]",
2076         },
2077         {
2078                 .name = "dpreg",
2079                 .handler = dap_dpreg_command,
2080                 .mode = COMMAND_EXEC,
2081                 .help = "read/write a register from DP "
2082                         "(reg is byte address (bank << 4 | reg) of a word register, like 0 4 8...)",
2083                 .usage = "reg [value]",
2084         },
2085         {
2086                 .name = "baseaddr",
2087                 .handler = dap_baseaddr_command,
2088                 .mode = COMMAND_EXEC,
2089                 .help = "return debug base address from MEM-AP "
2090                         "(default currently selected AP)",
2091                 .usage = "[ap_num]",
2092         },
2093         {
2094                 .name = "memaccess",
2095                 .handler = dap_memaccess_command,
2096                 .mode = COMMAND_EXEC,
2097                 .help = "set/get number of extra tck for MEM-AP memory "
2098                         "bus access [0-255]",
2099                 .usage = "[cycles]",
2100         },
2101         {
2102                 .name = "ti_be_32_quirks",
2103                 .handler = dap_ti_be_32_quirks_command,
2104                 .mode = COMMAND_CONFIG,
2105                 .help = "set/get quirks mode for TI TMS450/TMS570 processors",
2106                 .usage = "[enable]",
2107         },
2108         COMMAND_REGISTRATION_DONE
2109 };