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