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 piplining.  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         int retval;
 808
 809         LOG_DEBUG("Enter SWD mode");
 810
 811         if (transport_is_jtag()) {
 812                 retval =  jtag_add_tms_seq(swd_seq_jtag_to_swd_len,
 813                                 swd_seq_jtag_to_swd, TAP_INVALID);
 814                 if (retval == ERROR_OK)
 815                         retval = jtag_execute_queue();
 816                 return retval;
 817         }
 818
 819         if (transport_is_swd()) {
 820                 const struct swd_driver *swd = adiv5_dap_swd_driver(dap);
 821
 822                 return swd->switch_seq(JTAG_TO_SWD);
 823         }
 824
 825         LOG_ERROR("Nor JTAG nor SWD transport");
 826         return ERROR_FAIL;
 827 }
 828
 829 /**
 830  * Put the debug link into JTAG mode, if the target supports it.
 831  * The link's initial mode may be either SWD or JTAG.
 832  *
 833  * Note that targets implemented with SW-DP do not support JTAG, and
 834  * that some targets which could otherwise support it may have been
 835  * configured to disable JTAG signaling
 836  *
 837  * @param dap The DAP used
 838  * @return ERROR_OK or else a fault code.
 839  */
 840 int dap_to_jtag(struct adiv5_dap *dap)
 841 {
 842         int retval;
 843
 844         LOG_DEBUG("Enter JTAG mode");
 845
 846         if (transport_is_jtag()) {
 847                 retval = jtag_add_tms_seq(swd_seq_swd_to_jtag_len,
 848                                 swd_seq_swd_to_jtag, TAP_RESET);
 849                 if (retval == ERROR_OK)
 850                         retval = jtag_execute_queue();
 851                 return retval;
 852         }
 853
 854         if (transport_is_swd()) {
 855                 const struct swd_driver *swd = adiv5_dap_swd_driver(dap);
 856
 857                 return swd->switch_seq(SWD_TO_JTAG);
 858         }
 859
 860         LOG_ERROR("Nor JTAG nor SWD transport");
 861         return ERROR_FAIL;
 862 }
 863
 864 /* CID interpretation -- see ARM IHI 0029B section 3
 865  * and ARM IHI 0031A table 13-3.
 866  */
 867 static const char *class_description[16] = {
 868         "Reserved", "ROM table", "Reserved", "Reserved",
 869         "Reserved", "Reserved", "Reserved", "Reserved",
 870         "Reserved", "CoreSight component", "Reserved", "Peripheral Test Block",
 871         "Reserved", "OptimoDE DESS",
 872         "Generic IP component", "PrimeCell or System component"
 873 };
 874
 875 static bool is_dap_cid_ok(uint32_t cid)
 876 {
 877         return (cid & 0xffff0fff) == 0xb105000d;
 878 }
 879
 880 /*
 881  * This function checks the ID for each access port to find the requested Access Port type
 882  */
 883 int dap_find_ap(struct adiv5_dap *dap, enum ap_type type_to_find, struct adiv5_ap **ap_out)
 884 {
 885         int ap_num;
 886
 887         /* Maximum AP number is 255 since the SELECT register is 8 bits */
 888         for (ap_num = 0; ap_num <= DP_APSEL_MAX; ap_num++) {
 889
 890                 /* read the IDR register of the Access Port */
 891                 uint32_t id_val = 0;
 892
 893                 int retval = dap_queue_ap_read(dap_ap(dap, ap_num), AP_REG_IDR, &id_val);
 894                 if (retval != ERROR_OK)
 895                         return retval;
 896
 897                 retval = dap_run(dap);
 898
 899                 /* IDR bits:
 900                  * 31-28 : Revision
 901                  * 27-24 : JEDEC bank (0x4 for ARM)
 902                  * 23-17 : JEDEC code (0x3B for ARM)
 903                  * 16-13 : Class (0b1000=Mem-AP)
 904                  * 12-8  : Reserved
 905                  *  7-4  : AP Variant (non-zero for JTAG-AP)
 906                  *  3-0  : AP Type (0=JTAG-AP 1=AHB-AP 2=APB-AP 4=AXI-AP)
 907                  */
 908
 909                 /* Reading register for a non-existant AP should not cause an error,
 910                  * but just to be sure, try to continue searching if an error does happen.
 911                  */
 912                 if ((retval == ERROR_OK) &&                  /* Register read success */
 913                         ((id_val & IDR_JEP106) == IDR_JEP106_ARM) && /* Jedec codes match */
 914                         ((id_val & IDR_TYPE) == type_to_find)) {      /* type matches*/
 915
 916                         LOG_DEBUG("Found %s at AP index: %d (IDR=0x%08" PRIX32 ")",
 917                                                 (type_to_find == AP_TYPE_AHB3_AP)  ? "AHB3-AP"  :
 918                                                 (type_to_find == AP_TYPE_AHB5_AP)  ? "AHB5-AP"  :
 919                                                 (type_to_find == AP_TYPE_APB_AP)  ? "APB-AP"  :
 920                                                 (type_to_find == AP_TYPE_AXI_AP)  ? "AXI-AP"  :
 921                                                 (type_to_find == AP_TYPE_JTAG_AP) ? "JTAG-AP" : "Unknown",
 922                                                 ap_num, id_val);
 923
 924                         *ap_out = &dap->ap[ap_num];
 925                         return ERROR_OK;
 926                 }
 927         }
 928
 929         LOG_DEBUG("No %s found",
 930                                 (type_to_find == AP_TYPE_AHB3_AP)  ? "AHB3-AP"  :
 931                                 (type_to_find == AP_TYPE_AHB5_AP)  ? "AHB5-AP"  :
 932                                 (type_to_find == AP_TYPE_APB_AP)  ? "APB-AP"  :
 933                                 (type_to_find == AP_TYPE_AXI_AP)  ? "AXI-AP"  :
 934                                 (type_to_find == AP_TYPE_JTAG_AP) ? "JTAG-AP" : "Unknown");
 935         return ERROR_FAIL;
 936 }
 937
 938 int dap_get_debugbase(struct adiv5_ap *ap,
 939                         uint32_t *dbgbase, uint32_t *apid)
 940 {
 941         struct adiv5_dap *dap = ap->dap;
 942         int retval;
 943
 944         retval = dap_queue_ap_read(ap, MEM_AP_REG_BASE, dbgbase);
 945         if (retval != ERROR_OK)
 946                 return retval;
 947         retval = dap_queue_ap_read(ap, AP_REG_IDR, apid);
 948         if (retval != ERROR_OK)
 949                 return retval;
 950         retval = dap_run(dap);
 951         if (retval != ERROR_OK)
 952                 return retval;
 953
 954         return ERROR_OK;
 955 }
 956
 957 int dap_lookup_cs_component(struct adiv5_ap *ap,
 958                         uint32_t dbgbase, uint8_t type, uint32_t *addr, int32_t *idx)
 959 {
 960         uint32_t romentry, entry_offset = 0, component_base, devtype;
 961         int retval;
 962
 963         *addr = 0;
 964
 965         do {
 966                 retval = mem_ap_read_atomic_u32(ap, (dbgbase&0xFFFFF000) |
 967                                                 entry_offset, &romentry);
 968                 if (retval != ERROR_OK)
 969                         return retval;
 970
 971                 component_base = (dbgbase & 0xFFFFF000)
 972                         + (romentry & 0xFFFFF000);
 973
 974                 if (romentry & 0x1) {
 975                         uint32_t c_cid1;
 976                         retval = mem_ap_read_atomic_u32(ap, component_base | 0xff4, &c_cid1);
 977                         if (retval != ERROR_OK) {
 978                                 LOG_ERROR("Can't read component with base address 0x%" PRIx32
 979                                           ", the corresponding core might be turned off", component_base);
 980                                 return retval;
 981                         }
 982                         if (((c_cid1 >> 4) & 0x0f) == 1) {
 983                                 retval = dap_lookup_cs_component(ap, component_base,
 984                                                         type, addr, idx);
 985                                 if (retval == ERROR_OK)
 986                                         break;
 987                                 if (retval != ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
 988                                         return retval;
 989                         }
 990
 991                         retval = mem_ap_read_atomic_u32(ap,
 992                                         (component_base & 0xfffff000) | 0xfcc,
 993                                         &devtype);
 994                         if (retval != ERROR_OK)
 995                                 return retval;
 996                         if ((devtype & 0xff) == type) {
 997                                 if (!*idx) {
 998                                         *addr = component_base;
 999                                         break;
1000                                 } else
1001                                         (*idx)--;
1002                         }
1003                 }
1004                 entry_offset += 4;
1005         } while (romentry > 0);
1006
1007         if (!*addr)
1008                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1009
1010         return ERROR_OK;
1011 }
1012
1013 static int dap_read_part_id(struct adiv5_ap *ap, uint32_t component_base, uint32_t *cid, uint64_t *pid)
1014 {
1015         assert((component_base & 0xFFF) == 0);
1016         assert(ap != NULL && cid != NULL && pid != NULL);
1017
1018         uint32_t cid0, cid1, cid2, cid3;
1019         uint32_t pid0, pid1, pid2, pid3, pid4;
1020         int retval;
1021
1022         /* IDs are in last 4K section */
1023         retval = mem_ap_read_u32(ap, component_base + 0xFE0, &pid0);
1024         if (retval != ERROR_OK)
1025                 return retval;
1026         retval = mem_ap_read_u32(ap, component_base + 0xFE4, &pid1);
1027         if (retval != ERROR_OK)
1028                 return retval;
1029         retval = mem_ap_read_u32(ap, component_base + 0xFE8, &pid2);
1030         if (retval != ERROR_OK)
1031                 return retval;
1032         retval = mem_ap_read_u32(ap, component_base + 0xFEC, &pid3);
1033         if (retval != ERROR_OK)
1034                 return retval;
1035         retval = mem_ap_read_u32(ap, component_base + 0xFD0, &pid4);
1036         if (retval != ERROR_OK)
1037                 return retval;
1038         retval = mem_ap_read_u32(ap, component_base + 0xFF0, &cid0);
1039         if (retval != ERROR_OK)
1040                 return retval;
1041         retval = mem_ap_read_u32(ap, component_base + 0xFF4, &cid1);
1042         if (retval != ERROR_OK)
1043                 return retval;
1044         retval = mem_ap_read_u32(ap, component_base + 0xFF8, &cid2);
1045         if (retval != ERROR_OK)
1046                 return retval;
1047         retval = mem_ap_read_u32(ap, component_base + 0xFFC, &cid3);
1048         if (retval != ERROR_OK)
1049                 return retval;
1050
1051         retval = dap_run(ap->dap);
1052         if (retval != ERROR_OK)
1053                 return retval;
1054
1055         *cid = (cid3 & 0xff) << 24
1056                         | (cid2 & 0xff) << 16
1057                         | (cid1 & 0xff) << 8
1058                         | (cid0 & 0xff);
1059         *pid = (uint64_t)(pid4 & 0xff) << 32
1060                         | (pid3 & 0xff) << 24
1061                         | (pid2 & 0xff) << 16
1062                         | (pid1 & 0xff) << 8
1063                         | (pid0 & 0xff);
1064
1065         return ERROR_OK;
1066 }
1067
1068 /* The designer identity code is encoded as:
1069  * bits 11:8 : JEP106 Bank (number of continuation codes), only valid when bit 7 is 1.
1070  * bit 7     : Set when bits 6:0 represent a JEP106 ID and cleared when bits 6:0 represent
1071  *             a legacy ASCII Identity Code.
1072  * bits 6:0  : JEP106 Identity Code (without parity) or legacy ASCII code according to bit 7.
1073  * JEP106 is a standard available from jedec.org
1074  */
1075
1076 /* Part number interpretations are from Cortex
1077  * core specs, the CoreSight components TRM
1078  * (ARM DDI 0314H), CoreSight System Design
1079  * Guide (ARM DGI 0012D) and ETM specs; also
1080  * from chip observation (e.g. TI SDTI).
1081  */
1082
1083 /* The legacy code only used the part number field to identify CoreSight peripherals.
1084  * This meant that the same part number from two different manufacturers looked the same.
1085  * It is desirable for all future additions to identify with both part number and JEP106.
1086  * "ANY_ID" is a wildcard (any JEP106) only to preserve legacy behavior for legacy entries.
1087  */
1088
1089 #define ANY_ID 0x1000
1090
1091 #define ARM_ID 0x4BB
1092
1093 static const struct {
1094         uint16_t designer_id;
1095         uint16_t part_num;
1096         const char *type;
1097         const char *full;
1098 } dap_partnums[] = {
1099         { ARM_ID, 0x000, "Cortex-M3 SCS",              "(System Control Space)", },
1100         { ARM_ID, 0x001, "Cortex-M3 ITM",              "(Instrumentation Trace Module)", },
1101         { ARM_ID, 0x002, "Cortex-M3 DWT",              "(Data Watchpoint and Trace)", },
1102         { ARM_ID, 0x003, "Cortex-M3 FPB",              "(Flash Patch and Breakpoint)", },
1103         { ARM_ID, 0x008, "Cortex-M0 SCS",              "(System Control Space)", },
1104         { ARM_ID, 0x00a, "Cortex-M0 DWT",              "(Data Watchpoint and Trace)", },
1105         { ARM_ID, 0x00b, "Cortex-M0 BPU",              "(Breakpoint Unit)", },
1106         { ARM_ID, 0x00c, "Cortex-M4 SCS",              "(System Control Space)", },
1107         { ARM_ID, 0x00d, "CoreSight ETM11",            "(Embedded Trace)", },
1108         { ARM_ID, 0x00e, "Cortex-M7 FPB",              "(Flash Patch and Breakpoint)", },
1109         { ARM_ID, 0x490, "Cortex-A15 GIC",             "(Generic Interrupt Controller)", },
1110         { ARM_ID, 0x4a1, "Cortex-A53 ROM",             "(v8 Memory Map ROM Table)", },
1111         { ARM_ID, 0x4a2, "Cortex-A57 ROM",             "(ROM Table)", },
1112         { ARM_ID, 0x4a3, "Cortex-A53 ROM",             "(v7 Memory Map ROM Table)", },
1113         { ARM_ID, 0x4a4, "Cortex-A72 ROM",             "(ROM Table)", },
1114         { ARM_ID, 0x4a9, "Cortex-A9 ROM",              "(ROM Table)", },
1115         { ARM_ID, 0x4af, "Cortex-A15 ROM",             "(ROM Table)", },
1116         { ARM_ID, 0x4c0, "Cortex-M0+ ROM",             "(ROM Table)", },
1117         { ARM_ID, 0x4c3, "Cortex-M3 ROM",              "(ROM Table)", },
1118         { ARM_ID, 0x4c4, "Cortex-M4 ROM",              "(ROM Table)", },
1119         { ARM_ID, 0x4c7, "Cortex-M7 PPB ROM",          "(Private Peripheral Bus ROM Table)", },
1120         { ARM_ID, 0x4c8, "Cortex-M7 ROM",              "(ROM Table)", },
1121         { ARM_ID, 0x4b5, "Cortex-R5 ROM",              "(ROM Table)", },
1122         { ARM_ID, 0x470, "Cortex-M1 ROM",              "(ROM Table)", },
1123         { ARM_ID, 0x471, "Cortex-M0 ROM",              "(ROM Table)", },
1124         { ARM_ID, 0x906, "CoreSight CTI",              "(Cross Trigger)", },
1125         { ARM_ID, 0x907, "CoreSight ETB",              "(Trace Buffer)", },
1126         { ARM_ID, 0x908, "CoreSight CSTF",             "(Trace Funnel)", },
1127         { ARM_ID, 0x909, "CoreSight ATBR",             "(Advanced Trace Bus Replicator)", },
1128         { ARM_ID, 0x910, "CoreSight ETM9",             "(Embedded Trace)", },
1129         { ARM_ID, 0x912, "CoreSight TPIU",             "(Trace Port Interface Unit)", },
1130         { ARM_ID, 0x913, "CoreSight ITM",              "(Instrumentation Trace Macrocell)", },
1131         { ARM_ID, 0x914, "CoreSight SWO",              "(Single Wire Output)", },
1132         { ARM_ID, 0x917, "CoreSight HTM",              "(AHB Trace Macrocell)", },
1133         { ARM_ID, 0x920, "CoreSight ETM11",            "(Embedded Trace)", },
1134         { ARM_ID, 0x921, "Cortex-A8 ETM",              "(Embedded Trace)", },
1135         { ARM_ID, 0x922, "Cortex-A8 CTI",              "(Cross Trigger)", },
1136         { ARM_ID, 0x923, "Cortex-M3 TPIU",             "(Trace Port Interface Unit)", },
1137         { ARM_ID, 0x924, "Cortex-M3 ETM",              "(Embedded Trace)", },
1138         { ARM_ID, 0x925, "Cortex-M4 ETM",              "(Embedded Trace)", },
1139         { ARM_ID, 0x930, "Cortex-R4 ETM",              "(Embedded Trace)", },
1140         { ARM_ID, 0x931, "Cortex-R5 ETM",              "(Embedded Trace)", },
1141         { ARM_ID, 0x932, "CoreSight MTB-M0+",          "(Micro Trace Buffer)", },
1142         { ARM_ID, 0x941, "CoreSight TPIU-Lite",        "(Trace Port Interface Unit)", },
1143         { ARM_ID, 0x950, "Cortex-A9 PTM",              "(Program Trace Macrocell)", },
1144         { ARM_ID, 0x955, "Cortex-A5 ETM",              "(Embedded Trace)", },
1145         { ARM_ID, 0x95a, "Cortex-A72 ETM",             "(Embedded Trace)", },
1146         { ARM_ID, 0x95b, "Cortex-A17 PTM",             "(Program Trace Macrocell)", },
1147         { ARM_ID, 0x95d, "Cortex-A53 ETM",             "(Embedded Trace)", },
1148         { ARM_ID, 0x95e, "Cortex-A57 ETM",             "(Embedded Trace)", },
1149         { ARM_ID, 0x95f, "Cortex-A15 PTM",             "(Program Trace Macrocell)", },
1150         { ARM_ID, 0x961, "CoreSight TMC",              "(Trace Memory Controller)", },
1151         { ARM_ID, 0x962, "CoreSight STM",              "(System Trace Macrocell)", },
1152         { ARM_ID, 0x975, "Cortex-M7 ETM",              "(Embedded Trace)", },
1153         { ARM_ID, 0x9a0, "CoreSight PMU",              "(Performance Monitoring Unit)", },
1154         { ARM_ID, 0x9a1, "Cortex-M4 TPIU",             "(Trace Port Interface Unit)", },
1155         { ARM_ID, 0x9a4, "CoreSight GPR",              "(Granular Power Requester)", },
1156         { ARM_ID, 0x9a5, "Cortex-A5 PMU",              "(Performance Monitor Unit)", },
1157         { ARM_ID, 0x9a7, "Cortex-A7 PMU",              "(Performance Monitor Unit)", },
1158         { ARM_ID, 0x9a8, "Cortex-A53 CTI",             "(Cross Trigger)", },
1159         { ARM_ID, 0x9a9, "Cortex-M7 TPIU",             "(Trace Port Interface Unit)", },
1160         { ARM_ID, 0x9ae, "Cortex-A17 PMU",             "(Performance Monitor Unit)", },
1161         { ARM_ID, 0x9af, "Cortex-A15 PMU",             "(Performance Monitor Unit)", },
1162         { ARM_ID, 0x9b7, "Cortex-R7 PMU",              "(Performance Monitor Unit)", },
1163         { ARM_ID, 0x9d3, "Cortex-A53 PMU",             "(Performance Monitor Unit)", },
1164         { ARM_ID, 0x9d7, "Cortex-A57 PMU",             "(Performance Monitor Unit)", },
1165         { ARM_ID, 0x9d8, "Cortex-A72 PMU",             "(Performance Monitor Unit)", },
1166         { ARM_ID, 0xc05, "Cortex-A5 Debug",            "(Debug Unit)", },
1167         { ARM_ID, 0xc07, "Cortex-A7 Debug",            "(Debug Unit)", },
1168         { ARM_ID, 0xc08, "Cortex-A8 Debug",            "(Debug Unit)", },
1169         { ARM_ID, 0xc09, "Cortex-A9 Debug",            "(Debug Unit)", },
1170         { ARM_ID, 0xc0e, "Cortex-A17 Debug",           "(Debug Unit)", },
1171         { ARM_ID, 0xc0f, "Cortex-A15 Debug",           "(Debug Unit)", },
1172         { ARM_ID, 0xc14, "Cortex-R4 Debug",            "(Debug Unit)", },
1173         { ARM_ID, 0xc15, "Cortex-R5 Debug",            "(Debug Unit)", },
1174         { ARM_ID, 0xc17, "Cortex-R7 Debug",            "(Debug Unit)", },
1175         { ARM_ID, 0xd03, "Cortex-A53 Debug",           "(Debug Unit)", },
1176         { ARM_ID, 0xd07, "Cortex-A57 Debug",           "(Debug Unit)", },
1177         { ARM_ID, 0xd08, "Cortex-A72 Debug",           "(Debug Unit)", },
1178         { 0x097,  0x9af, "MSP432 ROM",                 "(ROM Table)" },
1179         { 0x09f,  0xcd0, "Atmel CPU with DSU",         "(CPU)" },
1180         { 0x0c1,  0x1db, "XMC4500 ROM",                "(ROM Table)" },
1181         { 0x0c1,  0x1df, "XMC4700/4800 ROM",           "(ROM Table)" },
1182         { 0x0c1,  0x1ed, "XMC1000 ROM",                "(ROM Table)" },
1183         { 0x0E5,  0x000, "SHARC+/Blackfin+",           "", },
1184         { 0x0F0,  0x440, "Qualcomm QDSS Component v1", "(Qualcomm Designed CoreSight Component v1)", },
1185         { 0x3eb,  0x181, "Tegra 186 ROM",              "(ROM Table)", },
1186         { 0x3eb,  0x211, "Tegra 210 ROM",              "(ROM Table)", },
1187         { 0x3eb,  0x202, "Denver ETM",                 "(Denver Embedded Trace)", },
1188         { 0x3eb,  0x302, "Denver Debug",               "(Debug Unit)", },
1189         { 0x3eb,  0x402, "Denver PMU",                 "(Performance Monitor Unit)", },
1190         /* legacy comment: 0x113: what? */
1191         { ANY_ID, 0x120, "TI SDTI",                    "(System Debug Trace Interface)", }, /* from OMAP3 memmap */
1192         { ANY_ID, 0x343, "TI DAPCTL",                  "", }, /* from OMAP3 memmap */
1193 };
1194
1195 static int dap_rom_display(struct command_invocation *cmd,
1196                                 struct adiv5_ap *ap, uint32_t dbgbase, int depth)
1197 {
1198         int retval;
1199         uint64_t pid;
1200         uint32_t cid;
1201         char tabs[16] = "";
1202
1203         if (depth > 16) {
1204                 command_print(cmd, "\tTables too deep");
1205                 return ERROR_FAIL;
1206         }
1207
1208         if (depth)
1209                 snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
1210
1211         uint32_t base_addr = dbgbase & 0xFFFFF000;
1212         command_print(cmd, "\t\tComponent base address 0x%08" PRIx32, base_addr);
1213
1214         retval = dap_read_part_id(ap, base_addr, &cid, &pid);
1215         if (retval != ERROR_OK) {
1216                 command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off");
1217                 return ERROR_OK; /* Don't abort recursion */
1218         }
1219
1220         if (!is_dap_cid_ok(cid)) {
1221                 command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid);
1222                 return ERROR_OK; /* Don't abort recursion */
1223         }
1224
1225         /* component may take multiple 4K pages */
1226         uint32_t size = (pid >> 36) & 0xf;
1227         if (size > 0)
1228                 command_print(cmd, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
1229
1230         command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid);
1231
1232         uint8_t class = (cid >> 12) & 0xf;
1233         uint16_t part_num = pid & 0xfff;
1234         uint16_t designer_id = ((pid >> 32) & 0xf) << 8 | ((pid >> 12) & 0xff);
1235
1236         if (designer_id & 0x80) {
1237                 /* JEP106 code */
1238                 command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s",
1239                                 designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
1240         } else {
1241                 /* Legacy ASCII ID, clear invalid bits */
1242                 designer_id &= 0x7f;
1243                 command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
1244                                 designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
1245         }
1246
1247         /* default values to be overwritten upon finding a match */
1248         const char *type = "Unrecognized";
1249         const char *full = "";
1250
1251         /* search dap_partnums[] array for a match */
1252         for (unsigned entry = 0; entry < ARRAY_SIZE(dap_partnums); entry++) {
1253
1254                 if ((dap_partnums[entry].designer_id != designer_id) && (dap_partnums[entry].designer_id != ANY_ID))
1255                         continue;
1256
1257                 if (dap_partnums[entry].part_num != part_num)
1258                         continue;
1259
1260                 type = dap_partnums[entry].type;
1261                 full = dap_partnums[entry].full;
1262                 break;
1263         }
1264
1265         command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
1266         command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
1267
1268         if (class == 1) { /* ROM Table */
1269                 uint32_t memtype;
1270                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &memtype);
1271                 if (retval != ERROR_OK)
1272                         return retval;
1273
1274                 if (memtype & 0x01)
1275                         command_print(cmd, "\t\tMEMTYPE system memory present on bus");
1276                 else
1277                         command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus");
1278
1279                 /* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
1280                 for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
1281                         uint32_t romentry;
1282                         retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
1283                         if (retval != ERROR_OK)
1284                                 return retval;
1285                         command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
1286                                         tabs, entry_offset, romentry);
1287                         if (romentry & 0x01) {
1288                                 /* Recurse */
1289                                 retval = dap_rom_display(cmd, ap, base_addr + (romentry & 0xFFFFF000), depth + 1);
1290                                 if (retval != ERROR_OK)
1291                                         return retval;
1292                         } else if (romentry != 0) {
1293                                 command_print(cmd, "\t\tComponent not present");
1294                         } else {
1295                                 command_print(cmd, "\t%s\tEnd of ROM table", tabs);
1296                                 break;
1297                         }
1298                 }
1299         } else if (class == 9) { /* CoreSight component */
1300                 const char *major = "Reserved", *subtype = "Reserved";
1301
1302                 uint32_t devtype;
1303                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &devtype);
1304                 if (retval != ERROR_OK)
1305                         return retval;
1306                 unsigned minor = (devtype >> 4) & 0x0f;
1307                 switch (devtype & 0x0f) {
1308                 case 0:
1309                         major = "Miscellaneous";
1310                         switch (minor) {
1311                         case 0:
1312                                 subtype = "other";
1313                                 break;
1314                         case 4:
1315                                 subtype = "Validation component";
1316                                 break;
1317                         }
1318                         break;
1319                 case 1:
1320                         major = "Trace Sink";
1321                         switch (minor) {
1322                         case 0:
1323                                 subtype = "other";
1324                                 break;
1325                         case 1:
1326                                 subtype = "Port";
1327                                 break;
1328                         case 2:
1329                                 subtype = "Buffer";
1330                                 break;
1331                         case 3:
1332                                 subtype = "Router";
1333                                 break;
1334                         }
1335                         break;
1336                 case 2:
1337                         major = "Trace Link";
1338                         switch (minor) {
1339                         case 0:
1340                                 subtype = "other";
1341                                 break;
1342                         case 1:
1343                                 subtype = "Funnel, router";
1344                                 break;
1345                         case 2:
1346                                 subtype = "Filter";
1347                                 break;
1348                         case 3:
1349                                 subtype = "FIFO, buffer";
1350                                 break;
1351                         }
1352                         break;
1353                 case 3:
1354                         major = "Trace Source";
1355                         switch (minor) {
1356                         case 0:
1357                                 subtype = "other";
1358                                 break;
1359                         case 1:
1360                                 subtype = "Processor";
1361                                 break;
1362                         case 2:
1363                                 subtype = "DSP";
1364                                 break;
1365                         case 3:
1366                                 subtype = "Engine/Coprocessor";
1367                                 break;
1368                         case 4:
1369                                 subtype = "Bus";
1370                                 break;
1371                         case 6:
1372                                 subtype = "Software";
1373                                 break;
1374                         }
1375                         break;
1376                 case 4:
1377                         major = "Debug Control";
1378                         switch (minor) {
1379                         case 0:
1380                                 subtype = "other";
1381                                 break;
1382                         case 1:
1383                                 subtype = "Trigger Matrix";
1384                                 break;
1385                         case 2:
1386                                 subtype = "Debug Auth";
1387                                 break;
1388                         case 3:
1389                                 subtype = "Power Requestor";
1390                                 break;
1391                         }
1392                         break;
1393                 case 5:
1394                         major = "Debug Logic";
1395                         switch (minor) {
1396                         case 0:
1397                                 subtype = "other";
1398                                 break;
1399                         case 1:
1400                                 subtype = "Processor";
1401                                 break;
1402                         case 2:
1403                                 subtype = "DSP";
1404                                 break;
1405                         case 3:
1406                                 subtype = "Engine/Coprocessor";
1407                                 break;
1408                         case 4:
1409                                 subtype = "Bus";
1410                                 break;
1411                         case 5:
1412                                 subtype = "Memory";
1413                                 break;
1414                         }
1415                         break;
1416                 case 6:
1417                         major = "Performance Monitor";
1418                         switch (minor) {
1419                         case 0:
1420                                 subtype = "other";
1421                                 break;
1422                         case 1:
1423                                 subtype = "Processor";
1424                                 break;
1425                         case 2:
1426                                 subtype = "DSP";
1427                                 break;
1428                         case 3:
1429                                 subtype = "Engine/Coprocessor";
1430                                 break;
1431                         case 4:
1432                                 subtype = "Bus";
1433                                 break;
1434                         case 5:
1435                                 subtype = "Memory";
1436                                 break;
1437                         }
1438                         break;
1439                 }
1440                 command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s",
1441                                 (uint8_t)(devtype & 0xff),
1442                                 major, subtype);
1443                 /* REVISIT also show 0xfc8 DevId */
1444         }
1445
1446         return ERROR_OK;
1447 }
1448
1449 int dap_info_command(struct command_invocation *cmd,
1450                 struct adiv5_ap *ap)
1451 {
1452         int retval;
1453         uint32_t dbgbase, apid;
1454         uint8_t mem_ap;
1455
1456         /* Now we read ROM table ID registers, ref. ARM IHI 0029B sec  */
1457         retval = dap_get_debugbase(ap, &dbgbase, &apid);
1458         if (retval != ERROR_OK)
1459                 return retval;
1460
1461         command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
1462         if (apid == 0) {
1463                 command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
1464                 return ERROR_FAIL;
1465         }
1466
1467         switch (apid & (IDR_JEP106 | IDR_TYPE)) {
1468         case IDR_JEP106_ARM | AP_TYPE_JTAG_AP:
1469                 command_print(cmd, "\tType is JTAG-AP");
1470                 break;
1471         case IDR_JEP106_ARM | AP_TYPE_AHB3_AP:
1472                 command_print(cmd, "\tType is MEM-AP AHB3");
1473                 break;
1474         case IDR_JEP106_ARM | AP_TYPE_AHB5_AP:
1475                 command_print(cmd, "\tType is MEM-AP AHB5");
1476                 break;
1477         case IDR_JEP106_ARM | AP_TYPE_APB_AP:
1478                 command_print(cmd, "\tType is MEM-AP APB");
1479                 break;
1480         case IDR_JEP106_ARM | AP_TYPE_AXI_AP:
1481                 command_print(cmd, "\tType is MEM-AP AXI");
1482                 break;
1483         default:
1484                 command_print(cmd, "\tUnknown AP type");
1485                 break;
1486         }
1487
1488         /* NOTE: a MEM-AP may have a single CoreSight component that's
1489          * not a ROM table ... or have no such components at all.
1490          */
1491         mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP;
1492         if (mem_ap) {
1493                 command_print(cmd, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
1494
1495                 if (dbgbase == 0xFFFFFFFF || (dbgbase & 0x3) == 0x2) {
1496                         command_print(cmd, "\tNo ROM table present");
1497                 } else {
1498                         if (dbgbase & 0x01)
1499                                 command_print(cmd, "\tValid ROM table present");
1500                         else
1501                                 command_print(cmd, "\tROM table in legacy format");
1502
1503                         dap_rom_display(cmd, ap, dbgbase & 0xFFFFF000, 0);
1504                 }
1505         }
1506
1507         return ERROR_OK;
1508 }
1509
1510 enum adiv5_cfg_param {
1511         CFG_DAP,
1512         CFG_AP_NUM
1513 };
1514
1515 static const Jim_Nvp nvp_config_opts[] = {
1516         { .name = "-dap",    .value = CFG_DAP },
1517         { .name = "-ap-num", .value = CFG_AP_NUM },
1518         { .name = NULL, .value = -1 }
1519 };
1520
1521 int adiv5_jim_configure(struct target *target, Jim_GetOptInfo *goi)
1522 {
1523         struct adiv5_private_config *pc;
1524         int e;
1525
1526         pc = (struct adiv5_private_config *)target->private_config;
1527         if (pc == NULL) {
1528                 pc = calloc(1, sizeof(struct adiv5_private_config));
1529                 pc->ap_num = DP_APSEL_INVALID;
1530                 target->private_config = pc;
1531         }
1532
1533         target->has_dap = true;
1534
1535         if (goi->argc > 0) {
1536                 Jim_Nvp *n;
1537
1538                 Jim_SetEmptyResult(goi->interp);
1539
1540                 /* check first if topmost item is for us */
1541                 e = Jim_Nvp_name2value_obj(goi->interp, nvp_config_opts,
1542                                                                    goi->argv[0], &n);
1543                 if (e != JIM_OK)
1544                         return JIM_CONTINUE;
1545
1546                 e = Jim_GetOpt_Obj(goi, NULL);
1547                 if (e != JIM_OK)
1548                         return e;
1549
1550                 switch (n->value) {
1551                 case CFG_DAP:
1552                         if (goi->isconfigure) {
1553                                 Jim_Obj *o_t;
1554                                 struct adiv5_dap *dap;
1555                                 e = Jim_GetOpt_Obj(goi, &o_t);
1556                                 if (e != JIM_OK)
1557                                         return e;
1558                                 dap = dap_instance_by_jim_obj(goi->interp, o_t);
1559                                 if (dap == NULL) {
1560                                         Jim_SetResultString(goi->interp, "DAP name invalid!", -1);
1561                                         return JIM_ERR;
1562                                 }
1563                                 if (pc->dap != NULL && pc->dap != dap) {
1564                                         Jim_SetResultString(goi->interp,
1565                                                 "DAP assignment cannot be changed after target was created!", -1);
1566                                         return JIM_ERR;
1567                                 }
1568                                 if (target->tap_configured) {
1569                                         Jim_SetResultString(goi->interp,
1570                                                 "-chain-position and -dap configparams are mutually exclusive!", -1);
1571                                         return JIM_ERR;
1572                                 }
1573                                 pc->dap = dap;
1574                                 target->tap = dap->tap;
1575                                 target->dap_configured = true;
1576                         } else {
1577                                 if (goi->argc != 0) {
1578                                         Jim_WrongNumArgs(goi->interp,
1579                                                                                 goi->argc, goi->argv,
1580                                         "NO PARAMS");
1581                                         return JIM_ERR;
1582                                 }
1583
1584                                 if (pc->dap == NULL) {
1585                                         Jim_SetResultString(goi->interp, "DAP not configured", -1);
1586                                         return JIM_ERR;
1587                                 }
1588                                 Jim_SetResultString(goi->interp, adiv5_dap_name(pc->dap), -1);
1589                         }
1590                         break;
1591
1592                 case CFG_AP_NUM:
1593                         if (goi->isconfigure) {
1594                                 jim_wide ap_num;
1595                                 e = Jim_GetOpt_Wide(goi, &ap_num);
1596                                 if (e != JIM_OK)
1597                                         return e;
1598                                 if (ap_num < 0 || ap_num > DP_APSEL_MAX) {
1599                                         Jim_SetResultString(goi->interp, "Invalid AP number!", -1);
1600                                         return JIM_ERR;
1601                                 }
1602                                 pc->ap_num = ap_num;
1603                         } else {
1604                                 if (goi->argc != 0) {
1605                                         Jim_WrongNumArgs(goi->interp,
1606                                                                          goi->argc, goi->argv,
1607                                           "NO PARAMS");
1608                                         return JIM_ERR;
1609                                 }
1610
1611                                 if (pc->ap_num == DP_APSEL_INVALID) {
1612                                         Jim_SetResultString(goi->interp, "AP number not configured", -1);
1613                                         return JIM_ERR;
1614                                 }
1615                                 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, pc->ap_num));
1616                         }
1617                         break;
1618                 }
1619         }
1620
1621         return JIM_OK;
1622 }
1623
1624 int adiv5_verify_config(struct adiv5_private_config *pc)
1625 {
1626         if (pc == NULL)
1627                 return ERROR_FAIL;
1628
1629         if (pc->dap == NULL)
1630                 return ERROR_FAIL;
1631
1632         return ERROR_OK;
1633 }
1634
1635
1636 COMMAND_HANDLER(handle_dap_info_command)
1637 {
1638         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1639         uint32_t apsel;
1640
1641         switch (CMD_ARGC) {
1642         case 0:
1643                 apsel = dap->apsel;
1644                 break;
1645         case 1:
1646                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1647                 if (apsel > DP_APSEL_MAX)
1648                         return ERROR_COMMAND_SYNTAX_ERROR;
1649                 break;
1650         default:
1651                 return ERROR_COMMAND_SYNTAX_ERROR;
1652         }
1653
1654         return dap_info_command(CMD, &dap->ap[apsel]);
1655 }
1656
1657 COMMAND_HANDLER(dap_baseaddr_command)
1658 {
1659         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1660         uint32_t apsel, baseaddr;
1661         int retval;
1662
1663         switch (CMD_ARGC) {
1664         case 0:
1665                 apsel = dap->apsel;
1666                 break;
1667         case 1:
1668                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1669                 /* AP address is in bits 31:24 of DP_SELECT */
1670                 if (apsel > DP_APSEL_MAX)
1671                         return ERROR_COMMAND_SYNTAX_ERROR;
1672                 break;
1673         default:
1674                 return ERROR_COMMAND_SYNTAX_ERROR;
1675         }
1676
1677         /* NOTE:  assumes we're talking to a MEM-AP, which
1678          * has a base address.  There are other kinds of AP,
1679          * though they're not common for now.  This should
1680          * use the ID register to verify it's a MEM-AP.
1681          */
1682         retval = dap_queue_ap_read(dap_ap(dap, apsel), MEM_AP_REG_BASE, &baseaddr);
1683         if (retval != ERROR_OK)
1684                 return retval;
1685         retval = dap_run(dap);
1686         if (retval != ERROR_OK)
1687                 return retval;
1688
1689         command_print(CMD, "0x%8.8" PRIx32, baseaddr);
1690
1691         return retval;
1692 }
1693
1694 COMMAND_HANDLER(dap_memaccess_command)
1695 {
1696         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1697         uint32_t memaccess_tck;
1698
1699         switch (CMD_ARGC) {
1700         case 0:
1701                 memaccess_tck = dap->ap[dap->apsel].memaccess_tck;
1702                 break;
1703         case 1:
1704                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], memaccess_tck);
1705                 break;
1706         default:
1707                 return ERROR_COMMAND_SYNTAX_ERROR;
1708         }
1709         dap->ap[dap->apsel].memaccess_tck = memaccess_tck;
1710
1711         command_print(CMD, "memory bus access delay set to %" PRIi32 " tck",
1712                         dap->ap[dap->apsel].memaccess_tck);
1713
1714         return ERROR_OK;
1715 }
1716
1717 COMMAND_HANDLER(dap_apsel_command)
1718 {
1719         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1720         uint32_t apsel;
1721
1722         switch (CMD_ARGC) {
1723         case 0:
1724                 command_print(CMD, "%" PRIi32, dap->apsel);
1725                 return ERROR_OK;
1726         case 1:
1727                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1728                 /* AP address is in bits 31:24 of DP_SELECT */
1729                 if (apsel > DP_APSEL_MAX)
1730                         return ERROR_COMMAND_SYNTAX_ERROR;
1731                 break;
1732         default:
1733                 return ERROR_COMMAND_SYNTAX_ERROR;
1734         }
1735
1736         dap->apsel = apsel;
1737         return ERROR_OK;
1738 }
1739
1740 COMMAND_HANDLER(dap_apcsw_command)
1741 {
1742         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1743         uint32_t apcsw = dap->ap[dap->apsel].csw_default;
1744         uint32_t csw_val, csw_mask;
1745
1746         switch (CMD_ARGC) {
1747         case 0:
1748                 command_print(CMD, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32,
1749                         dap->apsel, apcsw);
1750                 return ERROR_OK;
1751         case 1:
1752                 if (strcmp(CMD_ARGV[0], "default") == 0)
1753                         csw_val = CSW_AHB_DEFAULT;
1754                 else
1755                         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1756
1757                 if (csw_val & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1758                         LOG_ERROR("CSW value cannot include 'Size' and 'AddrInc' bit-fields");
1759                         return ERROR_COMMAND_SYNTAX_ERROR;
1760                 }
1761                 apcsw = csw_val;
1762                 break;
1763         case 2:
1764                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1765                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], csw_mask);
1766                 if (csw_mask & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1767                         LOG_ERROR("CSW mask cannot include 'Size' and 'AddrInc' bit-fields");
1768                         return ERROR_COMMAND_SYNTAX_ERROR;
1769                 }
1770                 apcsw = (apcsw & ~csw_mask) | (csw_val & csw_mask);
1771                 break;
1772         default:
1773                 return ERROR_COMMAND_SYNTAX_ERROR;
1774         }
1775         dap->ap[dap->apsel].csw_default = apcsw;
1776
1777         return 0;
1778 }
1779
1780
1781
1782 COMMAND_HANDLER(dap_apid_command)
1783 {
1784         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1785         uint32_t apsel, apid;
1786         int retval;
1787
1788         switch (CMD_ARGC) {
1789         case 0:
1790                 apsel = dap->apsel;
1791                 break;
1792         case 1:
1793                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1794                 /* AP address is in bits 31:24 of DP_SELECT */
1795                 if (apsel > DP_APSEL_MAX)
1796                         return ERROR_COMMAND_SYNTAX_ERROR;
1797                 break;
1798         default:
1799                 return ERROR_COMMAND_SYNTAX_ERROR;
1800         }
1801
1802         retval = dap_queue_ap_read(dap_ap(dap, apsel), AP_REG_IDR, &apid);
1803         if (retval != ERROR_OK)
1804                 return retval;
1805         retval = dap_run(dap);
1806         if (retval != ERROR_OK)
1807                 return retval;
1808
1809         command_print(CMD, "0x%8.8" PRIx32, apid);
1810
1811         return retval;
1812 }
1813
1814 COMMAND_HANDLER(dap_apreg_command)
1815 {
1816         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1817         uint32_t apsel, reg, value;
1818         struct adiv5_ap *ap;
1819         int retval;
1820
1821         if (CMD_ARGC < 2 || CMD_ARGC > 3)
1822                 return ERROR_COMMAND_SYNTAX_ERROR;
1823
1824         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1825         /* AP address is in bits 31:24 of DP_SELECT */
1826         if (apsel > DP_APSEL_MAX)
1827                 return ERROR_COMMAND_SYNTAX_ERROR;
1828         ap = dap_ap(dap, apsel);
1829
1830         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], reg);
1831         if (reg >= 256 || (reg & 3))
1832                 return ERROR_COMMAND_SYNTAX_ERROR;
1833
1834         if (CMD_ARGC == 3) {
1835                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
1836                 switch (reg) {
1837                 case MEM_AP_REG_CSW:
1838                         ap->csw_value = 0;  /* invalid, in case write fails */
1839                         retval = dap_queue_ap_write(ap, reg, value);
1840                         if (retval == ERROR_OK)
1841                                 ap->csw_value = value;
1842                         break;
1843                 case MEM_AP_REG_TAR:
1844                         ap->tar_valid = false;  /* invalid, force write */
1845                         retval = mem_ap_setup_tar(ap, value);
1846                         break;
1847                 default:
1848                         retval = dap_queue_ap_write(ap, reg, value);
1849                         break;
1850                 }
1851         } else {
1852                 retval = dap_queue_ap_read(ap, reg, &value);
1853         }
1854         if (retval == ERROR_OK)
1855                 retval = dap_run(dap);
1856
1857         if (retval != ERROR_OK)
1858                 return retval;
1859
1860         if (CMD_ARGC == 2)
1861                 command_print(CMD, "0x%08" PRIx32, value);
1862
1863         return retval;
1864 }
1865
1866 COMMAND_HANDLER(dap_dpreg_command)
1867 {
1868         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1869         uint32_t reg, value;
1870         int retval;
1871
1872         if (CMD_ARGC < 1 || CMD_ARGC > 2)
1873                 return ERROR_COMMAND_SYNTAX_ERROR;
1874
1875         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg);
1876         if (reg >= 256 || (reg & 3))
1877                 return ERROR_COMMAND_SYNTAX_ERROR;
1878
1879         if (CMD_ARGC == 2) {
1880                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
1881                 retval = dap_queue_dp_write(dap, reg, value);
1882         } else {
1883                 retval = dap_queue_dp_read(dap, reg, &value);
1884         }
1885         if (retval == ERROR_OK)
1886                 retval = dap_run(dap);
1887
1888         if (retval != ERROR_OK)
1889                 return retval;
1890
1891         if (CMD_ARGC == 1)
1892                 command_print(CMD, "0x%08" PRIx32, value);
1893
1894         return retval;
1895 }
1896
1897 COMMAND_HANDLER(dap_ti_be_32_quirks_command)
1898 {
1899         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1900         uint32_t enable = dap->ti_be_32_quirks;
1901
1902         switch (CMD_ARGC) {
1903         case 0:
1904                 break;
1905         case 1:
1906                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], enable);
1907                 if (enable > 1)
1908                         return ERROR_COMMAND_SYNTAX_ERROR;
1909                 break;
1910         default:
1911                 return ERROR_COMMAND_SYNTAX_ERROR;
1912         }
1913         dap->ti_be_32_quirks = enable;
1914         command_print(CMD, "TI BE-32 quirks mode %s",
1915                 enable ? "enabled" : "disabled");
1916
1917         return 0;
1918 }
1919
1920 const struct command_registration dap_instance_commands[] = {
1921         {
1922                 .name = "info",
1923                 .handler = handle_dap_info_command,
1924                 .mode = COMMAND_EXEC,
1925                 .help = "display ROM table for MEM-AP "
1926                         "(default currently selected AP)",
1927                 .usage = "[ap_num]",
1928         },
1929         {
1930                 .name = "apsel",
1931                 .handler = dap_apsel_command,
1932                 .mode = COMMAND_ANY,
1933                 .help = "Set the currently selected AP (default 0) "
1934                         "and display the result",
1935                 .usage = "[ap_num]",
1936         },
1937         {
1938                 .name = "apcsw",
1939                 .handler = dap_apcsw_command,
1940                 .mode = COMMAND_ANY,
1941                 .help = "Set CSW default bits",
1942                 .usage = "[value [mask]]",
1943         },
1944
1945         {
1946                 .name = "apid",
1947                 .handler = dap_apid_command,
1948                 .mode = COMMAND_EXEC,
1949                 .help = "return ID register from AP "
1950                         "(default currently selected AP)",
1951                 .usage = "[ap_num]",
1952         },
1953         {
1954                 .name = "apreg",
1955                 .handler = dap_apreg_command,
1956                 .mode = COMMAND_EXEC,
1957                 .help = "read/write a register from AP "
1958                         "(reg is byte address of a word register, like 0 4 8...)",
1959                 .usage = "ap_num reg [value]",
1960         },
1961         {
1962                 .name = "dpreg",
1963                 .handler = dap_dpreg_command,
1964                 .mode = COMMAND_EXEC,
1965                 .help = "read/write a register from DP "
1966                         "(reg is byte address (bank << 4 | reg) of a word register, like 0 4 8...)",
1967                 .usage = "reg [value]",
1968         },
1969         {
1970                 .name = "baseaddr",
1971                 .handler = dap_baseaddr_command,
1972                 .mode = COMMAND_EXEC,
1973                 .help = "return debug base address from MEM-AP "
1974                         "(default currently selected AP)",
1975                 .usage = "[ap_num]",
1976         },
1977         {
1978                 .name = "memaccess",
1979                 .handler = dap_memaccess_command,
1980                 .mode = COMMAND_EXEC,
1981                 .help = "set/get number of extra tck for MEM-AP memory "
1982                         "bus access [0-255]",
1983                 .usage = "[cycles]",
1984         },
1985         {
1986                 .name = "ti_be_32_quirks",
1987                 .handler = dap_ti_be_32_quirks_command,
1988                 .mode = COMMAND_CONFIG,
1989                 .help = "set/get quirks mode for TI TMS450/TMS570 processors",
1990                 .usage = "[enable]",
1991         },
1992         COMMAND_REGISTRATION_DONE
1993 };