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         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-existant 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, 0x490, "Cortex-A15 GIC",             "(Generic Interrupt Controller)", },
1076         { ARM_ID, 0x4a1, "Cortex-A53 ROM",             "(v8 Memory Map ROM Table)", },
1077         { ARM_ID, 0x4a2, "Cortex-A57 ROM",             "(ROM Table)", },
1078         { ARM_ID, 0x4a3, "Cortex-A53 ROM",             "(v7 Memory Map ROM Table)", },
1079         { ARM_ID, 0x4a4, "Cortex-A72 ROM",             "(ROM Table)", },
1080         { ARM_ID, 0x4a9, "Cortex-A9 ROM",              "(ROM Table)", },
1081         { ARM_ID, 0x4af, "Cortex-A15 ROM",             "(ROM Table)", },
1082         { ARM_ID, 0x4c0, "Cortex-M0+ ROM",             "(ROM Table)", },
1083         { ARM_ID, 0x4c3, "Cortex-M3 ROM",              "(ROM Table)", },
1084         { ARM_ID, 0x4c4, "Cortex-M4 ROM",              "(ROM Table)", },
1085         { ARM_ID, 0x4c7, "Cortex-M7 PPB ROM",          "(Private Peripheral Bus ROM Table)", },
1086         { ARM_ID, 0x4c8, "Cortex-M7 ROM",              "(ROM Table)", },
1087         { ARM_ID, 0x4b5, "Cortex-R5 ROM",              "(ROM Table)", },
1088         { ARM_ID, 0x470, "Cortex-M1 ROM",              "(ROM Table)", },
1089         { ARM_ID, 0x471, "Cortex-M0 ROM",              "(ROM Table)", },
1090         { ARM_ID, 0x906, "CoreSight CTI",              "(Cross Trigger)", },
1091         { ARM_ID, 0x907, "CoreSight ETB",              "(Trace Buffer)", },
1092         { ARM_ID, 0x908, "CoreSight CSTF",             "(Trace Funnel)", },
1093         { ARM_ID, 0x909, "CoreSight ATBR",             "(Advanced Trace Bus Replicator)", },
1094         { ARM_ID, 0x910, "CoreSight ETM9",             "(Embedded Trace)", },
1095         { ARM_ID, 0x912, "CoreSight TPIU",             "(Trace Port Interface Unit)", },
1096         { ARM_ID, 0x913, "CoreSight ITM",              "(Instrumentation Trace Macrocell)", },
1097         { ARM_ID, 0x914, "CoreSight SWO",              "(Single Wire Output)", },
1098         { ARM_ID, 0x917, "CoreSight HTM",              "(AHB Trace Macrocell)", },
1099         { ARM_ID, 0x920, "CoreSight ETM11",            "(Embedded Trace)", },
1100         { ARM_ID, 0x921, "Cortex-A8 ETM",              "(Embedded Trace)", },
1101         { ARM_ID, 0x922, "Cortex-A8 CTI",              "(Cross Trigger)", },
1102         { ARM_ID, 0x923, "Cortex-M3 TPIU",             "(Trace Port Interface Unit)", },
1103         { ARM_ID, 0x924, "Cortex-M3 ETM",              "(Embedded Trace)", },
1104         { ARM_ID, 0x925, "Cortex-M4 ETM",              "(Embedded Trace)", },
1105         { ARM_ID, 0x930, "Cortex-R4 ETM",              "(Embedded Trace)", },
1106         { ARM_ID, 0x931, "Cortex-R5 ETM",              "(Embedded Trace)", },
1107         { ARM_ID, 0x932, "CoreSight MTB-M0+",          "(Micro Trace Buffer)", },
1108         { ARM_ID, 0x941, "CoreSight TPIU-Lite",        "(Trace Port Interface Unit)", },
1109         { ARM_ID, 0x950, "Cortex-A9 PTM",              "(Program Trace Macrocell)", },
1110         { ARM_ID, 0x955, "Cortex-A5 ETM",              "(Embedded Trace)", },
1111         { ARM_ID, 0x95a, "Cortex-A72 ETM",             "(Embedded Trace)", },
1112         { ARM_ID, 0x95b, "Cortex-A17 PTM",             "(Program Trace Macrocell)", },
1113         { ARM_ID, 0x95d, "Cortex-A53 ETM",             "(Embedded Trace)", },
1114         { ARM_ID, 0x95e, "Cortex-A57 ETM",             "(Embedded Trace)", },
1115         { ARM_ID, 0x95f, "Cortex-A15 PTM",             "(Program Trace Macrocell)", },
1116         { ARM_ID, 0x961, "CoreSight TMC",              "(Trace Memory Controller)", },
1117         { ARM_ID, 0x962, "CoreSight STM",              "(System Trace Macrocell)", },
1118         { ARM_ID, 0x975, "Cortex-M7 ETM",              "(Embedded Trace)", },
1119         { ARM_ID, 0x9a0, "CoreSight PMU",              "(Performance Monitoring Unit)", },
1120         { ARM_ID, 0x9a1, "Cortex-M4 TPIU",             "(Trace Port Interface Unit)", },
1121         { ARM_ID, 0x9a4, "CoreSight GPR",              "(Granular Power Requester)", },
1122         { ARM_ID, 0x9a5, "Cortex-A5 PMU",              "(Performance Monitor Unit)", },
1123         { ARM_ID, 0x9a7, "Cortex-A7 PMU",              "(Performance Monitor Unit)", },
1124         { ARM_ID, 0x9a8, "Cortex-A53 CTI",             "(Cross Trigger)", },
1125         { ARM_ID, 0x9a9, "Cortex-M7 TPIU",             "(Trace Port Interface Unit)", },
1126         { ARM_ID, 0x9ae, "Cortex-A17 PMU",             "(Performance Monitor Unit)", },
1127         { ARM_ID, 0x9af, "Cortex-A15 PMU",             "(Performance Monitor Unit)", },
1128         { ARM_ID, 0x9b7, "Cortex-R7 PMU",              "(Performance Monitor Unit)", },
1129         { ARM_ID, 0x9d3, "Cortex-A53 PMU",             "(Performance Monitor Unit)", },
1130         { ARM_ID, 0x9d7, "Cortex-A57 PMU",             "(Performance Monitor Unit)", },
1131         { ARM_ID, 0x9d8, "Cortex-A72 PMU",             "(Performance Monitor Unit)", },
1132         { ARM_ID, 0xc05, "Cortex-A5 Debug",            "(Debug Unit)", },
1133         { ARM_ID, 0xc07, "Cortex-A7 Debug",            "(Debug Unit)", },
1134         { ARM_ID, 0xc08, "Cortex-A8 Debug",            "(Debug Unit)", },
1135         { ARM_ID, 0xc09, "Cortex-A9 Debug",            "(Debug Unit)", },
1136         { ARM_ID, 0xc0e, "Cortex-A17 Debug",           "(Debug Unit)", },
1137         { ARM_ID, 0xc0f, "Cortex-A15 Debug",           "(Debug Unit)", },
1138         { ARM_ID, 0xc14, "Cortex-R4 Debug",            "(Debug Unit)", },
1139         { ARM_ID, 0xc15, "Cortex-R5 Debug",            "(Debug Unit)", },
1140         { ARM_ID, 0xc17, "Cortex-R7 Debug",            "(Debug Unit)", },
1141         { ARM_ID, 0xd03, "Cortex-A53 Debug",           "(Debug Unit)", },
1142         { ARM_ID, 0xd07, "Cortex-A57 Debug",           "(Debug Unit)", },
1143         { ARM_ID, 0xd08, "Cortex-A72 Debug",           "(Debug Unit)", },
1144         { 0x097,  0x9af, "MSP432 ROM",                 "(ROM Table)" },
1145         { 0x09f,  0xcd0, "Atmel CPU with DSU",         "(CPU)" },
1146         { 0x0c1,  0x1db, "XMC4500 ROM",                "(ROM Table)" },
1147         { 0x0c1,  0x1df, "XMC4700/4800 ROM",           "(ROM Table)" },
1148         { 0x0c1,  0x1ed, "XMC1000 ROM",                "(ROM Table)" },
1149         { 0x0E5,  0x000, "SHARC+/Blackfin+",           "", },
1150         { 0x0F0,  0x440, "Qualcomm QDSS Component v1", "(Qualcomm Designed CoreSight Component v1)", },
1151         { 0x3eb,  0x181, "Tegra 186 ROM",              "(ROM Table)", },
1152         { 0x3eb,  0x211, "Tegra 210 ROM",              "(ROM Table)", },
1153         { 0x3eb,  0x202, "Denver ETM",                 "(Denver Embedded Trace)", },
1154         { 0x3eb,  0x302, "Denver Debug",               "(Debug Unit)", },
1155         { 0x3eb,  0x402, "Denver PMU",                 "(Performance Monitor Unit)", },
1156         /* legacy comment: 0x113: what? */
1157         { ANY_ID, 0x120, "TI SDTI",                    "(System Debug Trace Interface)", }, /* from OMAP3 memmap */
1158         { ANY_ID, 0x343, "TI DAPCTL",                  "", }, /* from OMAP3 memmap */
1159 };
1160
1161 static int dap_rom_display(struct command_invocation *cmd,
1162                                 struct adiv5_ap *ap, uint32_t dbgbase, int depth)
1163 {
1164         int retval;
1165         uint64_t pid;
1166         uint32_t cid;
1167         char tabs[16] = "";
1168
1169         if (depth > 16) {
1170                 command_print(cmd, "\tTables too deep");
1171                 return ERROR_FAIL;
1172         }
1173
1174         if (depth)
1175                 snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
1176
1177         uint32_t base_addr = dbgbase & 0xFFFFF000;
1178         command_print(cmd, "\t\tComponent base address 0x%08" PRIx32, base_addr);
1179
1180         retval = dap_read_part_id(ap, base_addr, &cid, &pid);
1181         if (retval != ERROR_OK) {
1182                 command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off");
1183                 return ERROR_OK; /* Don't abort recursion */
1184         }
1185
1186         if (!is_dap_cid_ok(cid)) {
1187                 command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid);
1188                 return ERROR_OK; /* Don't abort recursion */
1189         }
1190
1191         /* component may take multiple 4K pages */
1192         uint32_t size = (pid >> 36) & 0xf;
1193         if (size > 0)
1194                 command_print(cmd, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
1195
1196         command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid);
1197
1198         uint8_t class = (cid >> 12) & 0xf;
1199         uint16_t part_num = pid & 0xfff;
1200         uint16_t designer_id = ((pid >> 32) & 0xf) << 8 | ((pid >> 12) & 0xff);
1201
1202         if (designer_id & 0x80) {
1203                 /* JEP106 code */
1204                 command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s",
1205                                 designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
1206         } else {
1207                 /* Legacy ASCII ID, clear invalid bits */
1208                 designer_id &= 0x7f;
1209                 command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
1210                                 designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
1211         }
1212
1213         /* default values to be overwritten upon finding a match */
1214         const char *type = "Unrecognized";
1215         const char *full = "";
1216
1217         /* search dap_partnums[] array for a match */
1218         for (unsigned entry = 0; entry < ARRAY_SIZE(dap_partnums); entry++) {
1219
1220                 if ((dap_partnums[entry].designer_id != designer_id) && (dap_partnums[entry].designer_id != ANY_ID))
1221                         continue;
1222
1223                 if (dap_partnums[entry].part_num != part_num)
1224                         continue;
1225
1226                 type = dap_partnums[entry].type;
1227                 full = dap_partnums[entry].full;
1228                 break;
1229         }
1230
1231         command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
1232         command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
1233
1234         if (class == 1) { /* ROM Table */
1235                 uint32_t memtype;
1236                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &memtype);
1237                 if (retval != ERROR_OK)
1238                         return retval;
1239
1240                 if (memtype & 0x01)
1241                         command_print(cmd, "\t\tMEMTYPE system memory present on bus");
1242                 else
1243                         command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus");
1244
1245                 /* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
1246                 for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
1247                         uint32_t romentry;
1248                         retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
1249                         if (retval != ERROR_OK)
1250                                 return retval;
1251                         command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
1252                                         tabs, entry_offset, romentry);
1253                         if (romentry & 0x01) {
1254                                 /* Recurse */
1255                                 retval = dap_rom_display(cmd, ap, base_addr + (romentry & 0xFFFFF000), depth + 1);
1256                                 if (retval != ERROR_OK)
1257                                         return retval;
1258                         } else if (romentry != 0) {
1259                                 command_print(cmd, "\t\tComponent not present");
1260                         } else {
1261                                 command_print(cmd, "\t%s\tEnd of ROM table", tabs);
1262                                 break;
1263                         }
1264                 }
1265         } else if (class == 9) { /* CoreSight component */
1266                 const char *major = "Reserved", *subtype = "Reserved";
1267
1268                 uint32_t devtype;
1269                 retval = mem_ap_read_atomic_u32(ap, base_addr | 0xFCC, &devtype);
1270                 if (retval != ERROR_OK)
1271                         return retval;
1272                 unsigned minor = (devtype >> 4) & 0x0f;
1273                 switch (devtype & 0x0f) {
1274                 case 0:
1275                         major = "Miscellaneous";
1276                         switch (minor) {
1277                         case 0:
1278                                 subtype = "other";
1279                                 break;
1280                         case 4:
1281                                 subtype = "Validation component";
1282                                 break;
1283                         }
1284                         break;
1285                 case 1:
1286                         major = "Trace Sink";
1287                         switch (minor) {
1288                         case 0:
1289                                 subtype = "other";
1290                                 break;
1291                         case 1:
1292                                 subtype = "Port";
1293                                 break;
1294                         case 2:
1295                                 subtype = "Buffer";
1296                                 break;
1297                         case 3:
1298                                 subtype = "Router";
1299                                 break;
1300                         }
1301                         break;
1302                 case 2:
1303                         major = "Trace Link";
1304                         switch (minor) {
1305                         case 0:
1306                                 subtype = "other";
1307                                 break;
1308                         case 1:
1309                                 subtype = "Funnel, router";
1310                                 break;
1311                         case 2:
1312                                 subtype = "Filter";
1313                                 break;
1314                         case 3:
1315                                 subtype = "FIFO, buffer";
1316                                 break;
1317                         }
1318                         break;
1319                 case 3:
1320                         major = "Trace Source";
1321                         switch (minor) {
1322                         case 0:
1323                                 subtype = "other";
1324                                 break;
1325                         case 1:
1326                                 subtype = "Processor";
1327                                 break;
1328                         case 2:
1329                                 subtype = "DSP";
1330                                 break;
1331                         case 3:
1332                                 subtype = "Engine/Coprocessor";
1333                                 break;
1334                         case 4:
1335                                 subtype = "Bus";
1336                                 break;
1337                         case 6:
1338                                 subtype = "Software";
1339                                 break;
1340                         }
1341                         break;
1342                 case 4:
1343                         major = "Debug Control";
1344                         switch (minor) {
1345                         case 0:
1346                                 subtype = "other";
1347                                 break;
1348                         case 1:
1349                                 subtype = "Trigger Matrix";
1350                                 break;
1351                         case 2:
1352                                 subtype = "Debug Auth";
1353                                 break;
1354                         case 3:
1355                                 subtype = "Power Requestor";
1356                                 break;
1357                         }
1358                         break;
1359                 case 5:
1360                         major = "Debug Logic";
1361                         switch (minor) {
1362                         case 0:
1363                                 subtype = "other";
1364                                 break;
1365                         case 1:
1366                                 subtype = "Processor";
1367                                 break;
1368                         case 2:
1369                                 subtype = "DSP";
1370                                 break;
1371                         case 3:
1372                                 subtype = "Engine/Coprocessor";
1373                                 break;
1374                         case 4:
1375                                 subtype = "Bus";
1376                                 break;
1377                         case 5:
1378                                 subtype = "Memory";
1379                                 break;
1380                         }
1381                         break;
1382                 case 6:
1383                         major = "Performance Monitor";
1384                         switch (minor) {
1385                         case 0:
1386                                 subtype = "other";
1387                                 break;
1388                         case 1:
1389                                 subtype = "Processor";
1390                                 break;
1391                         case 2:
1392                                 subtype = "DSP";
1393                                 break;
1394                         case 3:
1395                                 subtype = "Engine/Coprocessor";
1396                                 break;
1397                         case 4:
1398                                 subtype = "Bus";
1399                                 break;
1400                         case 5:
1401                                 subtype = "Memory";
1402                                 break;
1403                         }
1404                         break;
1405                 }
1406                 command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s",
1407                                 (uint8_t)(devtype & 0xff),
1408                                 major, subtype);
1409                 /* REVISIT also show 0xfc8 DevId */
1410         }
1411
1412         return ERROR_OK;
1413 }
1414
1415 int dap_info_command(struct command_invocation *cmd,
1416                 struct adiv5_ap *ap)
1417 {
1418         int retval;
1419         uint32_t dbgbase, apid;
1420         uint8_t mem_ap;
1421
1422         /* Now we read ROM table ID registers, ref. ARM IHI 0029B sec  */
1423         retval = dap_get_debugbase(ap, &dbgbase, &apid);
1424         if (retval != ERROR_OK)
1425                 return retval;
1426
1427         command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
1428         if (apid == 0) {
1429                 command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
1430                 return ERROR_FAIL;
1431         }
1432
1433         switch (apid & (IDR_JEP106 | IDR_TYPE)) {
1434         case IDR_JEP106_ARM | AP_TYPE_JTAG_AP:
1435                 command_print(cmd, "\tType is JTAG-AP");
1436                 break;
1437         case IDR_JEP106_ARM | AP_TYPE_AHB3_AP:
1438                 command_print(cmd, "\tType is MEM-AP AHB3");
1439                 break;
1440         case IDR_JEP106_ARM | AP_TYPE_AHB5_AP:
1441                 command_print(cmd, "\tType is MEM-AP AHB5");
1442                 break;
1443         case IDR_JEP106_ARM | AP_TYPE_APB_AP:
1444                 command_print(cmd, "\tType is MEM-AP APB");
1445                 break;
1446         case IDR_JEP106_ARM | AP_TYPE_AXI_AP:
1447                 command_print(cmd, "\tType is MEM-AP AXI");
1448                 break;
1449         default:
1450                 command_print(cmd, "\tUnknown AP type");
1451                 break;
1452         }
1453
1454         /* NOTE: a MEM-AP may have a single CoreSight component that's
1455          * not a ROM table ... or have no such components at all.
1456          */
1457         mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP;
1458         if (mem_ap) {
1459                 command_print(cmd, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
1460
1461                 if (dbgbase == 0xFFFFFFFF || (dbgbase & 0x3) == 0x2) {
1462                         command_print(cmd, "\tNo ROM table present");
1463                 } else {
1464                         if (dbgbase & 0x01)
1465                                 command_print(cmd, "\tValid ROM table present");
1466                         else
1467                                 command_print(cmd, "\tROM table in legacy format");
1468
1469                         dap_rom_display(cmd, ap, dbgbase & 0xFFFFF000, 0);
1470                 }
1471         }
1472
1473         return ERROR_OK;
1474 }
1475
1476 enum adiv5_cfg_param {
1477         CFG_DAP,
1478         CFG_AP_NUM
1479 };
1480
1481 static const Jim_Nvp nvp_config_opts[] = {
1482         { .name = "-dap",    .value = CFG_DAP },
1483         { .name = "-ap-num", .value = CFG_AP_NUM },
1484         { .name = NULL, .value = -1 }
1485 };
1486
1487 int adiv5_jim_configure(struct target *target, Jim_GetOptInfo *goi)
1488 {
1489         struct adiv5_private_config *pc;
1490         int e;
1491
1492         pc = (struct adiv5_private_config *)target->private_config;
1493         if (pc == NULL) {
1494                 pc = calloc(1, sizeof(struct adiv5_private_config));
1495                 pc->ap_num = DP_APSEL_INVALID;
1496                 target->private_config = pc;
1497         }
1498
1499         target->has_dap = true;
1500
1501         if (goi->argc > 0) {
1502                 Jim_Nvp *n;
1503
1504                 Jim_SetEmptyResult(goi->interp);
1505
1506                 /* check first if topmost item is for us */
1507                 e = Jim_Nvp_name2value_obj(goi->interp, nvp_config_opts,
1508                                                                    goi->argv[0], &n);
1509                 if (e != JIM_OK)
1510                         return JIM_CONTINUE;
1511
1512                 e = Jim_GetOpt_Obj(goi, NULL);
1513                 if (e != JIM_OK)
1514                         return e;
1515
1516                 switch (n->value) {
1517                 case CFG_DAP:
1518                         if (goi->isconfigure) {
1519                                 Jim_Obj *o_t;
1520                                 struct adiv5_dap *dap;
1521                                 e = Jim_GetOpt_Obj(goi, &o_t);
1522                                 if (e != JIM_OK)
1523                                         return e;
1524                                 dap = dap_instance_by_jim_obj(goi->interp, o_t);
1525                                 if (dap == NULL) {
1526                                         Jim_SetResultString(goi->interp, "DAP name invalid!", -1);
1527                                         return JIM_ERR;
1528                                 }
1529                                 if (pc->dap != NULL && pc->dap != dap) {
1530                                         Jim_SetResultString(goi->interp,
1531                                                 "DAP assignment cannot be changed after target was created!", -1);
1532                                         return JIM_ERR;
1533                                 }
1534                                 if (target->tap_configured) {
1535                                         Jim_SetResultString(goi->interp,
1536                                                 "-chain-position and -dap configparams are mutually exclusive!", -1);
1537                                         return JIM_ERR;
1538                                 }
1539                                 pc->dap = dap;
1540                                 target->tap = dap->tap;
1541                                 target->dap_configured = true;
1542                         } else {
1543                                 if (goi->argc != 0) {
1544                                         Jim_WrongNumArgs(goi->interp,
1545                                                                                 goi->argc, goi->argv,
1546                                         "NO PARAMS");
1547                                         return JIM_ERR;
1548                                 }
1549
1550                                 if (pc->dap == NULL) {
1551                                         Jim_SetResultString(goi->interp, "DAP not configured", -1);
1552                                         return JIM_ERR;
1553                                 }
1554                                 Jim_SetResultString(goi->interp, adiv5_dap_name(pc->dap), -1);
1555                         }
1556                         break;
1557
1558                 case CFG_AP_NUM:
1559                         if (goi->isconfigure) {
1560                                 jim_wide ap_num;
1561                                 e = Jim_GetOpt_Wide(goi, &ap_num);
1562                                 if (e != JIM_OK)
1563                                         return e;
1564                                 if (ap_num < 0 || ap_num > DP_APSEL_MAX) {
1565                                         Jim_SetResultString(goi->interp, "Invalid AP number!", -1);
1566                                         return JIM_ERR;
1567                                 }
1568                                 pc->ap_num = ap_num;
1569                         } else {
1570                                 if (goi->argc != 0) {
1571                                         Jim_WrongNumArgs(goi->interp,
1572                                                                          goi->argc, goi->argv,
1573                                           "NO PARAMS");
1574                                         return JIM_ERR;
1575                                 }
1576
1577                                 if (pc->ap_num == DP_APSEL_INVALID) {
1578                                         Jim_SetResultString(goi->interp, "AP number not configured", -1);
1579                                         return JIM_ERR;
1580                                 }
1581                                 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, pc->ap_num));
1582                         }
1583                         break;
1584                 }
1585         }
1586
1587         return JIM_OK;
1588 }
1589
1590 int adiv5_verify_config(struct adiv5_private_config *pc)
1591 {
1592         if (pc == NULL)
1593                 return ERROR_FAIL;
1594
1595         if (pc->dap == NULL)
1596                 return ERROR_FAIL;
1597
1598         return ERROR_OK;
1599 }
1600
1601
1602 COMMAND_HANDLER(handle_dap_info_command)
1603 {
1604         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1605         uint32_t apsel;
1606
1607         switch (CMD_ARGC) {
1608         case 0:
1609                 apsel = dap->apsel;
1610                 break;
1611         case 1:
1612                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1613                 if (apsel > DP_APSEL_MAX) {
1614                         command_print(CMD, "Invalid AP number");
1615                         return ERROR_COMMAND_ARGUMENT_INVALID;
1616                 }
1617                 break;
1618         default:
1619                 return ERROR_COMMAND_SYNTAX_ERROR;
1620         }
1621
1622         return dap_info_command(CMD, &dap->ap[apsel]);
1623 }
1624
1625 COMMAND_HANDLER(dap_baseaddr_command)
1626 {
1627         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1628         uint32_t apsel, baseaddr;
1629         int retval;
1630
1631         switch (CMD_ARGC) {
1632         case 0:
1633                 apsel = dap->apsel;
1634                 break;
1635         case 1:
1636                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1637                 /* AP address is in bits 31:24 of DP_SELECT */
1638                 if (apsel > DP_APSEL_MAX) {
1639                         command_print(CMD, "Invalid AP number");
1640                         return ERROR_COMMAND_ARGUMENT_INVALID;
1641                 }
1642                 break;
1643         default:
1644                 return ERROR_COMMAND_SYNTAX_ERROR;
1645         }
1646
1647         /* NOTE:  assumes we're talking to a MEM-AP, which
1648          * has a base address.  There are other kinds of AP,
1649          * though they're not common for now.  This should
1650          * use the ID register to verify it's a MEM-AP.
1651          */
1652         retval = dap_queue_ap_read(dap_ap(dap, apsel), MEM_AP_REG_BASE, &baseaddr);
1653         if (retval != ERROR_OK)
1654                 return retval;
1655         retval = dap_run(dap);
1656         if (retval != ERROR_OK)
1657                 return retval;
1658
1659         command_print(CMD, "0x%8.8" PRIx32, baseaddr);
1660
1661         return retval;
1662 }
1663
1664 COMMAND_HANDLER(dap_memaccess_command)
1665 {
1666         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1667         uint32_t memaccess_tck;
1668
1669         switch (CMD_ARGC) {
1670         case 0:
1671                 memaccess_tck = dap->ap[dap->apsel].memaccess_tck;
1672                 break;
1673         case 1:
1674                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], memaccess_tck);
1675                 break;
1676         default:
1677                 return ERROR_COMMAND_SYNTAX_ERROR;
1678         }
1679         dap->ap[dap->apsel].memaccess_tck = memaccess_tck;
1680
1681         command_print(CMD, "memory bus access delay set to %" PRIi32 " tck",
1682                         dap->ap[dap->apsel].memaccess_tck);
1683
1684         return ERROR_OK;
1685 }
1686
1687 COMMAND_HANDLER(dap_apsel_command)
1688 {
1689         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1690         uint32_t apsel;
1691
1692         switch (CMD_ARGC) {
1693         case 0:
1694                 command_print(CMD, "%" PRIi32, dap->apsel);
1695                 return ERROR_OK;
1696         case 1:
1697                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1698                 /* AP address is in bits 31:24 of DP_SELECT */
1699                 if (apsel > DP_APSEL_MAX) {
1700                         command_print(CMD, "Invalid AP number");
1701                         return ERROR_COMMAND_ARGUMENT_INVALID;
1702                 }
1703                 break;
1704         default:
1705                 return ERROR_COMMAND_SYNTAX_ERROR;
1706         }
1707
1708         dap->apsel = apsel;
1709         return ERROR_OK;
1710 }
1711
1712 COMMAND_HANDLER(dap_apcsw_command)
1713 {
1714         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1715         uint32_t apcsw = dap->ap[dap->apsel].csw_default;
1716         uint32_t csw_val, csw_mask;
1717
1718         switch (CMD_ARGC) {
1719         case 0:
1720                 command_print(CMD, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32,
1721                         dap->apsel, apcsw);
1722                 return ERROR_OK;
1723         case 1:
1724                 if (strcmp(CMD_ARGV[0], "default") == 0)
1725                         csw_val = CSW_AHB_DEFAULT;
1726                 else
1727                         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1728
1729                 if (csw_val & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1730                         LOG_ERROR("CSW value cannot include 'Size' and 'AddrInc' bit-fields");
1731                         return ERROR_COMMAND_ARGUMENT_INVALID;
1732                 }
1733                 apcsw = csw_val;
1734                 break;
1735         case 2:
1736                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val);
1737                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], csw_mask);
1738                 if (csw_mask & (CSW_SIZE_MASK | CSW_ADDRINC_MASK)) {
1739                         LOG_ERROR("CSW mask cannot include 'Size' and 'AddrInc' bit-fields");
1740                         return ERROR_COMMAND_ARGUMENT_INVALID;
1741                 }
1742                 apcsw = (apcsw & ~csw_mask) | (csw_val & csw_mask);
1743                 break;
1744         default:
1745                 return ERROR_COMMAND_SYNTAX_ERROR;
1746         }
1747         dap->ap[dap->apsel].csw_default = apcsw;
1748
1749         return 0;
1750 }
1751
1752
1753
1754 COMMAND_HANDLER(dap_apid_command)
1755 {
1756         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1757         uint32_t apsel, apid;
1758         int retval;
1759
1760         switch (CMD_ARGC) {
1761         case 0:
1762                 apsel = dap->apsel;
1763                 break;
1764         case 1:
1765                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1766                 /* AP address is in bits 31:24 of DP_SELECT */
1767                 if (apsel > DP_APSEL_MAX) {
1768                         command_print(CMD, "Invalid AP number");
1769                         return ERROR_COMMAND_ARGUMENT_INVALID;
1770                 }
1771                 break;
1772         default:
1773                 return ERROR_COMMAND_SYNTAX_ERROR;
1774         }
1775
1776         retval = dap_queue_ap_read(dap_ap(dap, apsel), AP_REG_IDR, &apid);
1777         if (retval != ERROR_OK)
1778                 return retval;
1779         retval = dap_run(dap);
1780         if (retval != ERROR_OK)
1781                 return retval;
1782
1783         command_print(CMD, "0x%8.8" PRIx32, apid);
1784
1785         return retval;
1786 }
1787
1788 COMMAND_HANDLER(dap_apreg_command)
1789 {
1790         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1791         uint32_t apsel, reg, value;
1792         struct adiv5_ap *ap;
1793         int retval;
1794
1795         if (CMD_ARGC < 2 || CMD_ARGC > 3)
1796                 return ERROR_COMMAND_SYNTAX_ERROR;
1797
1798         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
1799         /* AP address is in bits 31:24 of DP_SELECT */
1800         if (apsel > DP_APSEL_MAX) {
1801                 command_print(CMD, "Invalid AP number");
1802                 return ERROR_COMMAND_ARGUMENT_INVALID;
1803         }
1804
1805         ap = dap_ap(dap, apsel);
1806
1807         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], reg);
1808         if (reg >= 256 || (reg & 3)) {
1809                 command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
1810                 return ERROR_COMMAND_ARGUMENT_INVALID;
1811         }
1812
1813         if (CMD_ARGC == 3) {
1814                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
1815                 switch (reg) {
1816                 case MEM_AP_REG_CSW:
1817                         ap->csw_value = 0;  /* invalid, in case write fails */
1818                         retval = dap_queue_ap_write(ap, reg, value);
1819                         if (retval == ERROR_OK)
1820                                 ap->csw_value = value;
1821                         break;
1822                 case MEM_AP_REG_TAR:
1823                         ap->tar_valid = false;  /* invalid, force write */
1824                         retval = mem_ap_setup_tar(ap, value);
1825                         break;
1826                 default:
1827                         retval = dap_queue_ap_write(ap, reg, value);
1828                         break;
1829                 }
1830         } else {
1831                 retval = dap_queue_ap_read(ap, reg, &value);
1832         }
1833         if (retval == ERROR_OK)
1834                 retval = dap_run(dap);
1835
1836         if (retval != ERROR_OK)
1837                 return retval;
1838
1839         if (CMD_ARGC == 2)
1840                 command_print(CMD, "0x%08" PRIx32, value);
1841
1842         return retval;
1843 }
1844
1845 COMMAND_HANDLER(dap_dpreg_command)
1846 {
1847         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1848         uint32_t reg, value;
1849         int retval;
1850
1851         if (CMD_ARGC < 1 || CMD_ARGC > 2)
1852                 return ERROR_COMMAND_SYNTAX_ERROR;
1853
1854         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg);
1855         if (reg >= 256 || (reg & 3)) {
1856                 command_print(CMD, "Invalid reg value (should be less than 256 and 4 bytes aligned)");
1857                 return ERROR_COMMAND_ARGUMENT_INVALID;
1858         }
1859
1860         if (CMD_ARGC == 2) {
1861                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
1862                 retval = dap_queue_dp_write(dap, reg, value);
1863         } else {
1864                 retval = dap_queue_dp_read(dap, reg, &value);
1865         }
1866         if (retval == ERROR_OK)
1867                 retval = dap_run(dap);
1868
1869         if (retval != ERROR_OK)
1870                 return retval;
1871
1872         if (CMD_ARGC == 1)
1873                 command_print(CMD, "0x%08" PRIx32, value);
1874
1875         return retval;
1876 }
1877
1878 COMMAND_HANDLER(dap_ti_be_32_quirks_command)
1879 {
1880         struct adiv5_dap *dap = adiv5_get_dap(CMD_DATA);
1881         uint32_t enable = dap->ti_be_32_quirks;
1882
1883         switch (CMD_ARGC) {
1884         case 0:
1885                 break;
1886         case 1:
1887                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], enable);
1888                 if (enable > 1)
1889                         return ERROR_COMMAND_ARGUMENT_INVALID;
1890                 break;
1891         default:
1892                 return ERROR_COMMAND_SYNTAX_ERROR;
1893         }
1894         dap->ti_be_32_quirks = enable;
1895         command_print(CMD, "TI BE-32 quirks mode %s",
1896                 enable ? "enabled" : "disabled");
1897
1898         return 0;
1899 }
1900
1901 const struct command_registration dap_instance_commands[] = {
1902         {
1903                 .name = "info",
1904                 .handler = handle_dap_info_command,
1905                 .mode = COMMAND_EXEC,
1906                 .help = "display ROM table for MEM-AP "
1907                         "(default currently selected AP)",
1908                 .usage = "[ap_num]",
1909         },
1910         {
1911                 .name = "apsel",
1912                 .handler = dap_apsel_command,
1913                 .mode = COMMAND_ANY,
1914                 .help = "Set the currently selected AP (default 0) "
1915                         "and display the result",
1916                 .usage = "[ap_num]",
1917         },
1918         {
1919                 .name = "apcsw",
1920                 .handler = dap_apcsw_command,
1921                 .mode = COMMAND_ANY,
1922                 .help = "Set CSW default bits",
1923                 .usage = "[value [mask]]",
1924         },
1925
1926         {
1927                 .name = "apid",
1928                 .handler = dap_apid_command,
1929                 .mode = COMMAND_EXEC,
1930                 .help = "return ID register from AP "
1931                         "(default currently selected AP)",
1932                 .usage = "[ap_num]",
1933         },
1934         {
1935                 .name = "apreg",
1936                 .handler = dap_apreg_command,
1937                 .mode = COMMAND_EXEC,
1938                 .help = "read/write a register from AP "
1939                         "(reg is byte address of a word register, like 0 4 8...)",
1940                 .usage = "ap_num reg [value]",
1941         },
1942         {
1943                 .name = "dpreg",
1944                 .handler = dap_dpreg_command,
1945                 .mode = COMMAND_EXEC,
1946                 .help = "read/write a register from DP "
1947                         "(reg is byte address (bank << 4 | reg) of a word register, like 0 4 8...)",
1948                 .usage = "reg [value]",
1949         },
1950         {
1951                 .name = "baseaddr",
1952                 .handler = dap_baseaddr_command,
1953                 .mode = COMMAND_EXEC,
1954                 .help = "return debug base address from MEM-AP "
1955                         "(default currently selected AP)",
1956                 .usage = "[ap_num]",
1957         },
1958         {
1959                 .name = "memaccess",
1960                 .handler = dap_memaccess_command,
1961                 .mode = COMMAND_EXEC,
1962                 .help = "set/get number of extra tck for MEM-AP memory "
1963                         "bus access [0-255]",
1964                 .usage = "[cycles]",
1965         },
1966         {
1967                 .name = "ti_be_32_quirks",
1968                 .handler = dap_ti_be_32_quirks_command,
1969                 .mode = COMMAND_CONFIG,
1970                 .help = "set/get quirks mode for TI TMS450/TMS570 processors",
1971                 .usage = "[enable]",
1972         },
1973         COMMAND_REGISTRATION_DONE
1974 };