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