git.gag.com Git - fw/openocd/blob - src/target/cortex_m.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2006 by Magnus Lundin                                   *
   6  *   lundin@mlu.mine.nu                                                    *
   7  *                                                                         *
   8  *   Copyright (C) 2008 by Spencer Oliver                                  *
   9  *   spen@spen-soft.co.uk                                                  *
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  *   This program is distributed in the hope that it will be useful,       *
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  19  *   GNU General Public License for more details.                          *
  20  *                                                                         *
  21  *   You should have received a copy of the GNU General Public License     *
  22  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  23  *                                                                         *
  24  *                                                                         *
  25  *   Cortex-M3(tm) TRM, ARM DDI 0337E (r1p1) and 0337G (r2p0)              *
  26  *                                                                         *
  27  ***************************************************************************/
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include "jtag/interface.h"
  33 #include "breakpoints.h"
  34 #include "cortex_m.h"
  35 #include "target_request.h"
  36 #include "target_type.h"
  37 #include "arm_adi_v5.h"
  38 #include "arm_disassembler.h"
  39 #include "register.h"
  40 #include "arm_opcodes.h"
  41 #include "arm_semihosting.h"
  42 #include <helper/time_support.h>
  43 #include <rtt/rtt.h>
  44
  45 /* NOTE:  most of this should work fine for the Cortex-M1 and
  46  * Cortex-M0 cores too, although they're ARMv6-M not ARMv7-M.
  47  * Some differences:  M0/M1 doesn't have FPB remapping or the
  48  * DWT tracing/profiling support.  (So the cycle counter will
  49  * not be usable; the other stuff isn't currently used here.)
  50  *
  51  * Although there are some workarounds for errata seen only in r0p0
  52  * silicon, such old parts are hard to find and thus not much tested
  53  * any longer.
  54  */
  55
  56 /* Timeout for register r/w */
  57 #define DHCSR_S_REGRDY_TIMEOUT (500)
  58
  59 /* Supported Cortex-M Cores */
  60 static const struct cortex_m_part_info cortex_m_parts[] = {
  61         {
  62                 .partno = CORTEX_M0_PARTNO,
  63                 .name = "Cortex-M0",
  64                 .arch = ARM_ARCH_V6M,
  65         },
  66         {
  67                 .partno = CORTEX_M0P_PARTNO,
  68                 .name = "Cortex-M0+",
  69                 .arch = ARM_ARCH_V6M,
  70         },
  71         {
  72                 .partno = CORTEX_M1_PARTNO,
  73                 .name = "Cortex-M1",
  74                 .arch = ARM_ARCH_V6M,
  75         },
  76         {
  77                 .partno = CORTEX_M3_PARTNO,
  78                 .name = "Cortex-M3",
  79                 .arch = ARM_ARCH_V7M,
  80                 .flags = CORTEX_M_F_TAR_AUTOINCR_BLOCK_4K,
  81         },
  82         {
  83                 .partno = CORTEX_M4_PARTNO,
  84                 .name = "Cortex-M4",
  85                 .arch = ARM_ARCH_V7M,
  86                 .flags = CORTEX_M_F_HAS_FPV4 | CORTEX_M_F_TAR_AUTOINCR_BLOCK_4K,
  87         },
  88         {
  89                 .partno = CORTEX_M7_PARTNO,
  90                 .name = "Cortex-M7",
  91                 .arch = ARM_ARCH_V7M,
  92                 .flags = CORTEX_M_F_HAS_FPV5,
  93         },
  94         {
  95                 .partno = CORTEX_M23_PARTNO,
  96                 .name = "Cortex-M23",
  97                 .arch = ARM_ARCH_V8M,
  98         },
  99         {
 100                 .partno = CORTEX_M33_PARTNO,
 101                 .name = "Cortex-M33",
 102                 .arch = ARM_ARCH_V8M,
 103                 .flags = CORTEX_M_F_HAS_FPV5,
 104         },
 105         {
 106                 .partno = CORTEX_M35P_PARTNO,
 107                 .name = "Cortex-M35P",
 108                 .arch = ARM_ARCH_V8M,
 109                 .flags = CORTEX_M_F_HAS_FPV5,
 110         },
 111         {
 112                 .partno = CORTEX_M55_PARTNO,
 113                 .name = "Cortex-M55",
 114                 .arch = ARM_ARCH_V8M,
 115                 .flags = CORTEX_M_F_HAS_FPV5,
 116         },
 117 };
 118
 119 /* forward declarations */
 120 static int cortex_m_store_core_reg_u32(struct target *target,
 121                 uint32_t num, uint32_t value);
 122 static void cortex_m_dwt_free(struct target *target);
 123
 124 /** DCB DHCSR register contains S_RETIRE_ST and S_RESET_ST bits cleared
 125  *  on a read. Call this helper function each time DHCSR is read
 126  *  to preserve S_RESET_ST state in case of a reset event was detected.
 127  */
 128 static inline void cortex_m_cumulate_dhcsr_sticky(struct cortex_m_common *cortex_m,
 129                 uint32_t dhcsr)
 130 {
 131         cortex_m->dcb_dhcsr_cumulated_sticky |= dhcsr;
 132 }
 133
 134 /** Read DCB DHCSR register to cortex_m->dcb_dhcsr and cumulate
 135  * sticky bits in cortex_m->dcb_dhcsr_cumulated_sticky
 136  */
 137 static int cortex_m_read_dhcsr_atomic_sticky(struct target *target)
 138 {
 139         struct cortex_m_common *cortex_m = target_to_cm(target);
 140         struct armv7m_common *armv7m = target_to_armv7m(target);
 141
 142         int retval = mem_ap_read_atomic_u32(armv7m->debug_ap, DCB_DHCSR,
 143                                 &cortex_m->dcb_dhcsr);
 144         if (retval != ERROR_OK)
 145                 return retval;
 146
 147         cortex_m_cumulate_dhcsr_sticky(cortex_m, cortex_m->dcb_dhcsr);
 148         return ERROR_OK;
 149 }
 150
 151 static int cortex_m_load_core_reg_u32(struct target *target,
 152                 uint32_t regsel, uint32_t *value)
 153 {
 154         struct cortex_m_common *cortex_m = target_to_cm(target);
 155         struct armv7m_common *armv7m = target_to_armv7m(target);
 156         int retval;
 157         uint32_t dcrdr, tmp_value;
 158         int64_t then;
 159
 160         /* because the DCB_DCRDR is used for the emulated dcc channel
 161          * we have to save/restore the DCB_DCRDR when used */
 162         if (target->dbg_msg_enabled) {
 163                 retval = mem_ap_read_u32(armv7m->debug_ap, DCB_DCRDR, &dcrdr);
 164                 if (retval != ERROR_OK)
 165                         return retval;
 166         }
 167
 168         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DCRSR, regsel);
 169         if (retval != ERROR_OK)
 170                 return retval;
 171
 172         /* check if value from register is ready and pre-read it */
 173         then = timeval_ms();
 174         while (1) {
 175                 retval = mem_ap_read_u32(armv7m->debug_ap, DCB_DHCSR,
 176                                                                  &cortex_m->dcb_dhcsr);
 177                 if (retval != ERROR_OK)
 178                         return retval;
 179                 retval = mem_ap_read_atomic_u32(armv7m->debug_ap, DCB_DCRDR,
 180                                                                                 &tmp_value);
 181                 if (retval != ERROR_OK)
 182                         return retval;
 183                 cortex_m_cumulate_dhcsr_sticky(cortex_m, cortex_m->dcb_dhcsr);
 184                 if (cortex_m->dcb_dhcsr & S_REGRDY)
 185                         break;
 186                 cortex_m->slow_register_read = true; /* Polling (still) needed. */
 187                 if (timeval_ms() > then + DHCSR_S_REGRDY_TIMEOUT) {
 188                         LOG_ERROR("Timeout waiting for DCRDR transfer ready");
 189                         return ERROR_TIMEOUT_REACHED;
 190                 }
 191                 keep_alive();
 192         }
 193
 194         *value = tmp_value;
 195
 196         if (target->dbg_msg_enabled) {
 197                 /* restore DCB_DCRDR - this needs to be in a separate
 198                  * transaction otherwise the emulated DCC channel breaks */
 199                 if (retval == ERROR_OK)
 200                         retval = mem_ap_write_atomic_u32(armv7m->debug_ap, DCB_DCRDR, dcrdr);
 201         }
 202
 203         return retval;
 204 }
 205
 206 static int cortex_m_slow_read_all_regs(struct target *target)
 207 {
 208         struct cortex_m_common *cortex_m = target_to_cm(target);
 209         struct armv7m_common *armv7m = target_to_armv7m(target);
 210         const unsigned int num_regs = armv7m->arm.core_cache->num_regs;
 211
 212         /* Opportunistically restore fast read, it'll revert to slow
 213          * if any register needed polling in cortex_m_load_core_reg_u32(). */
 214         cortex_m->slow_register_read = false;
 215
 216         for (unsigned int reg_id = 0; reg_id < num_regs; reg_id++) {
 217                 struct reg *r = &armv7m->arm.core_cache->reg_list[reg_id];
 218                 if (r->exist) {
 219                         int retval = armv7m->arm.read_core_reg(target, r, reg_id, ARM_MODE_ANY);
 220                         if (retval != ERROR_OK)
 221                                 return retval;
 222                 }
 223         }
 224
 225         if (!cortex_m->slow_register_read)
 226                 LOG_DEBUG("Switching back to fast register reads");
 227
 228         return ERROR_OK;
 229 }
 230
 231 static int cortex_m_queue_reg_read(struct target *target, uint32_t regsel,
 232                 uint32_t *reg_value, uint32_t *dhcsr)
 233 {
 234         struct armv7m_common *armv7m = target_to_armv7m(target);
 235         int retval;
 236
 237         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DCRSR, regsel);
 238         if (retval != ERROR_OK)
 239                 return retval;
 240
 241         retval = mem_ap_read_u32(armv7m->debug_ap, DCB_DHCSR, dhcsr);
 242         if (retval != ERROR_OK)
 243                 return retval;
 244
 245         return mem_ap_read_u32(armv7m->debug_ap, DCB_DCRDR, reg_value);
 246 }
 247
 248 static int cortex_m_fast_read_all_regs(struct target *target)
 249 {
 250         struct cortex_m_common *cortex_m = target_to_cm(target);
 251         struct armv7m_common *armv7m = target_to_armv7m(target);
 252         int retval;
 253         uint32_t dcrdr;
 254
 255         /* because the DCB_DCRDR is used for the emulated dcc channel
 256          * we have to save/restore the DCB_DCRDR when used */
 257         if (target->dbg_msg_enabled) {
 258                 retval = mem_ap_read_u32(armv7m->debug_ap, DCB_DCRDR, &dcrdr);
 259                 if (retval != ERROR_OK)
 260                         return retval;
 261         }
 262
 263         const unsigned int num_regs = armv7m->arm.core_cache->num_regs;
 264         const unsigned int n_r32 = ARMV7M_LAST_REG - ARMV7M_CORE_FIRST_REG + 1
 265                                                            + ARMV7M_FPU_LAST_REG - ARMV7M_FPU_FIRST_REG + 1;
 266         /* we need one 32-bit word for each register except FP D0..D15, which
 267          * need two words */
 268         uint32_t r_vals[n_r32];
 269         uint32_t dhcsr[n_r32];
 270
 271         unsigned int wi = 0; /* write index to r_vals and dhcsr arrays */
 272         unsigned int reg_id; /* register index in the reg_list, ARMV7M_R0... */
 273         for (reg_id = 0; reg_id < num_regs; reg_id++) {
 274                 struct reg *r = &armv7m->arm.core_cache->reg_list[reg_id];
 275                 if (!r->exist)
 276                         continue;       /* skip non existent registers */
 277
 278                 if (r->size <= 8) {
 279                         /* Any 8-bit or shorter register is unpacked from a 32-bit
 280                          * container register. Skip it now. */
 281                         continue;
 282                 }
 283
 284                 uint32_t regsel = armv7m_map_id_to_regsel(reg_id);
 285                 retval = cortex_m_queue_reg_read(target, regsel, &r_vals[wi],
 286                                                                                  &dhcsr[wi]);
 287                 if (retval != ERROR_OK)
 288                         return retval;
 289                 wi++;
 290
 291                 assert(r->size == 32 || r->size == 64);
 292                 if (r->size == 32)
 293                         continue;       /* done with 32-bit register */
 294
 295                 assert(reg_id >= ARMV7M_FPU_FIRST_REG && reg_id <= ARMV7M_FPU_LAST_REG);
 296                 /* the odd part of FP register (S1, S3...) */
 297                 retval = cortex_m_queue_reg_read(target, regsel + 1, &r_vals[wi],
 298                                                                                          &dhcsr[wi]);
 299                 if (retval != ERROR_OK)
 300                         return retval;
 301                 wi++;
 302         }
 303
 304         assert(wi <= n_r32);
 305
 306         retval = dap_run(armv7m->debug_ap->dap);
 307         if (retval != ERROR_OK)
 308                 return retval;
 309
 310         if (target->dbg_msg_enabled) {
 311                 /* restore DCB_DCRDR - this needs to be in a separate
 312                  * transaction otherwise the emulated DCC channel breaks */
 313                 retval = mem_ap_write_atomic_u32(armv7m->debug_ap, DCB_DCRDR, dcrdr);
 314                 if (retval != ERROR_OK)
 315                         return retval;
 316         }
 317
 318         bool not_ready = false;
 319         for (unsigned int i = 0; i < wi; i++) {
 320                 if ((dhcsr[i] & S_REGRDY) == 0) {
 321                         not_ready = true;
 322                         LOG_DEBUG("Register %u was not ready during fast read", i);
 323                 }
 324                 cortex_m_cumulate_dhcsr_sticky(cortex_m, dhcsr[i]);
 325         }
 326
 327         if (not_ready) {
 328                 /* Any register was not ready,
 329                  * fall back to slow read with S_REGRDY polling */
 330                 return ERROR_TIMEOUT_REACHED;
 331         }
 332
 333         LOG_DEBUG("read %u 32-bit registers", wi);
 334
 335         unsigned int ri = 0; /* read index from r_vals array */
 336         for (reg_id = 0; reg_id < num_regs; reg_id++) {
 337                 struct reg *r = &armv7m->arm.core_cache->reg_list[reg_id];
 338                 if (!r->exist)
 339                         continue;       /* skip non existent registers */
 340
 341                 r->dirty = false;
 342
 343                 unsigned int reg32_id;
 344                 uint32_t offset;
 345                 if (armv7m_map_reg_packing(reg_id, &reg32_id, &offset)) {
 346                         /* Unpack a partial register from 32-bit container register */
 347                         struct reg *r32 = &armv7m->arm.core_cache->reg_list[reg32_id];
 348
 349                         /* The container register ought to precede all regs unpacked
 350                          * from it in the reg_list. So the value should be ready
 351                          * to unpack */
 352                         assert(r32->valid);
 353                         buf_cpy(r32->value + offset, r->value, r->size);
 354
 355                 } else {
 356                         assert(r->size == 32 || r->size == 64);
 357                         buf_set_u32(r->value, 0, 32, r_vals[ri++]);
 358
 359                         if (r->size == 64) {
 360                                 assert(reg_id >= ARMV7M_FPU_FIRST_REG && reg_id <= ARMV7M_FPU_LAST_REG);
 361                                 /* the odd part of FP register (S1, S3...) */
 362                                 buf_set_u32(r->value + 4, 0, 32, r_vals[ri++]);
 363                         }
 364                 }
 365                 r->valid = true;
 366         }
 367         assert(ri == wi);
 368
 369         return retval;
 370 }
 371
 372 static int cortex_m_store_core_reg_u32(struct target *target,
 373                 uint32_t regsel, uint32_t value)
 374 {
 375         struct cortex_m_common *cortex_m = target_to_cm(target);
 376         struct armv7m_common *armv7m = target_to_armv7m(target);
 377         int retval;
 378         uint32_t dcrdr;
 379         int64_t then;
 380
 381         /* because the DCB_DCRDR is used for the emulated dcc channel
 382          * we have to save/restore the DCB_DCRDR when used */
 383         if (target->dbg_msg_enabled) {
 384                 retval = mem_ap_read_u32(armv7m->debug_ap, DCB_DCRDR, &dcrdr);
 385                 if (retval != ERROR_OK)
 386                         return retval;
 387         }
 388
 389         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DCRDR, value);
 390         if (retval != ERROR_OK)
 391                 return retval;
 392
 393         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DCRSR, regsel | DCRSR_WNR);
 394         if (retval != ERROR_OK)
 395                 return retval;
 396
 397         /* check if value is written into register */
 398         then = timeval_ms();
 399         while (1) {
 400                 retval = cortex_m_read_dhcsr_atomic_sticky(target);
 401                 if (retval != ERROR_OK)
 402                         return retval;
 403                 if (cortex_m->dcb_dhcsr & S_REGRDY)
 404                         break;
 405                 if (timeval_ms() > then + DHCSR_S_REGRDY_TIMEOUT) {
 406                         LOG_ERROR("Timeout waiting for DCRDR transfer ready");
 407                         return ERROR_TIMEOUT_REACHED;
 408                 }
 409                 keep_alive();
 410         }
 411
 412         if (target->dbg_msg_enabled) {
 413                 /* restore DCB_DCRDR - this needs to be in a separate
 414                  * transaction otherwise the emulated DCC channel breaks */
 415                 if (retval == ERROR_OK)
 416                         retval = mem_ap_write_atomic_u32(armv7m->debug_ap, DCB_DCRDR, dcrdr);
 417         }
 418
 419         return retval;
 420 }
 421
 422 static int cortex_m_write_debug_halt_mask(struct target *target,
 423         uint32_t mask_on, uint32_t mask_off)
 424 {
 425         struct cortex_m_common *cortex_m = target_to_cm(target);
 426         struct armv7m_common *armv7m = &cortex_m->armv7m;
 427
 428         /* mask off status bits */
 429         cortex_m->dcb_dhcsr &= ~((0xFFFFul << 16) | mask_off);
 430         /* create new register mask */
 431         cortex_m->dcb_dhcsr |= DBGKEY | C_DEBUGEN | mask_on;
 432
 433         return mem_ap_write_atomic_u32(armv7m->debug_ap, DCB_DHCSR, cortex_m->dcb_dhcsr);
 434 }
 435
 436 static int cortex_m_set_maskints(struct target *target, bool mask)
 437 {
 438         struct cortex_m_common *cortex_m = target_to_cm(target);
 439         if (!!(cortex_m->dcb_dhcsr & C_MASKINTS) != mask)
 440                 return cortex_m_write_debug_halt_mask(target, mask ? C_MASKINTS : 0, mask ? 0 : C_MASKINTS);
 441         else
 442                 return ERROR_OK;
 443 }
 444
 445 static int cortex_m_set_maskints_for_halt(struct target *target)
 446 {
 447         struct cortex_m_common *cortex_m = target_to_cm(target);
 448         switch (cortex_m->isrmasking_mode) {
 449                 case CORTEX_M_ISRMASK_AUTO:
 450                         /* interrupts taken at resume, whether for step or run -> no mask */
 451                         return cortex_m_set_maskints(target, false);
 452
 453                 case CORTEX_M_ISRMASK_OFF:
 454                         /* interrupts never masked */
 455                         return cortex_m_set_maskints(target, false);
 456
 457                 case CORTEX_M_ISRMASK_ON:
 458                         /* interrupts always masked */
 459                         return cortex_m_set_maskints(target, true);
 460
 461                 case CORTEX_M_ISRMASK_STEPONLY:
 462                         /* interrupts masked for single step only -> mask now if MASKINTS
 463                          * erratum, otherwise only mask before stepping */
 464                         return cortex_m_set_maskints(target, cortex_m->maskints_erratum);
 465         }
 466         return ERROR_OK;
 467 }
 468
 469 static int cortex_m_set_maskints_for_run(struct target *target)
 470 {
 471         switch (target_to_cm(target)->isrmasking_mode) {
 472                 case CORTEX_M_ISRMASK_AUTO:
 473                         /* interrupts taken at resume, whether for step or run -> no mask */
 474                         return cortex_m_set_maskints(target, false);
 475
 476                 case CORTEX_M_ISRMASK_OFF:
 477                         /* interrupts never masked */
 478                         return cortex_m_set_maskints(target, false);
 479
 480                 case CORTEX_M_ISRMASK_ON:
 481                         /* interrupts always masked */
 482                         return cortex_m_set_maskints(target, true);
 483
 484                 case CORTEX_M_ISRMASK_STEPONLY:
 485                         /* interrupts masked for single step only -> no mask */
 486                         return cortex_m_set_maskints(target, false);
 487         }
 488         return ERROR_OK;
 489 }
 490
 491 static int cortex_m_set_maskints_for_step(struct target *target)
 492 {
 493         switch (target_to_cm(target)->isrmasking_mode) {
 494                 case CORTEX_M_ISRMASK_AUTO:
 495                         /* the auto-interrupt should already be done -> mask */
 496                         return cortex_m_set_maskints(target, true);
 497
 498                 case CORTEX_M_ISRMASK_OFF:
 499                         /* interrupts never masked */
 500                         return cortex_m_set_maskints(target, false);
 501
 502                 case CORTEX_M_ISRMASK_ON:
 503                         /* interrupts always masked */
 504                         return cortex_m_set_maskints(target, true);
 505
 506                 case CORTEX_M_ISRMASK_STEPONLY:
 507                         /* interrupts masked for single step only -> mask */
 508                         return cortex_m_set_maskints(target, true);
 509         }
 510         return ERROR_OK;
 511 }
 512
 513 static int cortex_m_clear_halt(struct target *target)
 514 {
 515         struct cortex_m_common *cortex_m = target_to_cm(target);
 516         struct armv7m_common *armv7m = &cortex_m->armv7m;
 517         int retval;
 518
 519         /* clear step if any */
 520         cortex_m_write_debug_halt_mask(target, C_HALT, C_STEP);
 521
 522         /* Read Debug Fault Status Register */
 523         retval = mem_ap_read_atomic_u32(armv7m->debug_ap, NVIC_DFSR, &cortex_m->nvic_dfsr);
 524         if (retval != ERROR_OK)
 525                 return retval;
 526
 527         /* Clear Debug Fault Status */
 528         retval = mem_ap_write_atomic_u32(armv7m->debug_ap, NVIC_DFSR, cortex_m->nvic_dfsr);
 529         if (retval != ERROR_OK)
 530                 return retval;
 531         LOG_DEBUG(" NVIC_DFSR 0x%" PRIx32 "", cortex_m->nvic_dfsr);
 532
 533         return ERROR_OK;
 534 }
 535
 536 static int cortex_m_single_step_core(struct target *target)
 537 {
 538         struct cortex_m_common *cortex_m = target_to_cm(target);
 539         int retval;
 540
 541         /* Mask interrupts before clearing halt, if not done already.  This avoids
 542          * Erratum 377497 (fixed in r1p0) where setting MASKINTS while clearing
 543          * HALT can put the core into an unknown state.
 544          */
 545         if (!(cortex_m->dcb_dhcsr & C_MASKINTS)) {
 546                 retval = cortex_m_write_debug_halt_mask(target, C_MASKINTS, 0);
 547                 if (retval != ERROR_OK)
 548                         return retval;
 549         }
 550         retval = cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT);
 551         if (retval != ERROR_OK)
 552                 return retval;
 553         LOG_DEBUG(" ");
 554
 555         /* restore dhcsr reg */
 556         cortex_m_clear_halt(target);
 557
 558         return ERROR_OK;
 559 }
 560
 561 static int cortex_m_enable_fpb(struct target *target)
 562 {
 563         int retval = target_write_u32(target, FP_CTRL, 3);
 564         if (retval != ERROR_OK)
 565                 return retval;
 566
 567         /* check the fpb is actually enabled */
 568         uint32_t fpctrl;
 569         retval = target_read_u32(target, FP_CTRL, &fpctrl);
 570         if (retval != ERROR_OK)
 571                 return retval;
 572
 573         if (fpctrl & 1)
 574                 return ERROR_OK;
 575
 576         return ERROR_FAIL;
 577 }
 578
 579 static int cortex_m_endreset_event(struct target *target)
 580 {
 581         int retval;
 582         uint32_t dcb_demcr;
 583         struct cortex_m_common *cortex_m = target_to_cm(target);
 584         struct armv7m_common *armv7m = &cortex_m->armv7m;
 585         struct adiv5_dap *swjdp = cortex_m->armv7m.arm.dap;
 586         struct cortex_m_fp_comparator *fp_list = cortex_m->fp_comparator_list;
 587         struct cortex_m_dwt_comparator *dwt_list = cortex_m->dwt_comparator_list;
 588
 589         /* REVISIT The four debug monitor bits are currently ignored... */
 590         retval = mem_ap_read_atomic_u32(armv7m->debug_ap, DCB_DEMCR, &dcb_demcr);
 591         if (retval != ERROR_OK)
 592                 return retval;
 593         LOG_DEBUG("DCB_DEMCR = 0x%8.8" PRIx32 "", dcb_demcr);
 594
 595         /* this register is used for emulated dcc channel */
 596         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DCRDR, 0);
 597         if (retval != ERROR_OK)
 598                 return retval;
 599
 600         retval = cortex_m_read_dhcsr_atomic_sticky(target);
 601         if (retval != ERROR_OK)
 602                 return retval;
 603
 604         if (!(cortex_m->dcb_dhcsr & C_DEBUGEN)) {
 605                 /* Enable debug requests */
 606                 retval = cortex_m_write_debug_halt_mask(target, 0, C_HALT | C_STEP | C_MASKINTS);
 607                 if (retval != ERROR_OK)
 608                         return retval;
 609         }
 610
 611         /* Restore proper interrupt masking setting for running CPU. */
 612         cortex_m_set_maskints_for_run(target);
 613
 614         /* Enable features controlled by ITM and DWT blocks, and catch only
 615          * the vectors we were told to pay attention to.
 616          *
 617          * Target firmware is responsible for all fault handling policy
 618          * choices *EXCEPT* explicitly scripted overrides like "vector_catch"
 619          * or manual updates to the NVIC SHCSR and CCR registers.
 620          */
 621         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DEMCR, TRCENA | armv7m->demcr);
 622         if (retval != ERROR_OK)
 623                 return retval;
 624
 625         /* Paranoia: evidently some (early?) chips don't preserve all the
 626          * debug state (including FPB, DWT, etc) across reset...
 627          */
 628
 629         /* Enable FPB */
 630         retval = cortex_m_enable_fpb(target);
 631         if (retval != ERROR_OK) {
 632                 LOG_ERROR("Failed to enable the FPB");
 633                 return retval;
 634         }
 635
 636         cortex_m->fpb_enabled = true;
 637
 638         /* Restore FPB registers */
 639         for (unsigned int i = 0; i < cortex_m->fp_num_code + cortex_m->fp_num_lit; i++) {
 640                 retval = target_write_u32(target, fp_list[i].fpcr_address, fp_list[i].fpcr_value);
 641                 if (retval != ERROR_OK)
 642                         return retval;
 643         }
 644
 645         /* Restore DWT registers */
 646         for (unsigned int i = 0; i < cortex_m->dwt_num_comp; i++) {
 647                 retval = target_write_u32(target, dwt_list[i].dwt_comparator_address + 0,
 648                                 dwt_list[i].comp);
 649                 if (retval != ERROR_OK)
 650                         return retval;
 651                 retval = target_write_u32(target, dwt_list[i].dwt_comparator_address + 4,
 652                                 dwt_list[i].mask);
 653                 if (retval != ERROR_OK)
 654                         return retval;
 655                 retval = target_write_u32(target, dwt_list[i].dwt_comparator_address + 8,
 656                                 dwt_list[i].function);
 657                 if (retval != ERROR_OK)
 658                         return retval;
 659         }
 660         retval = dap_run(swjdp);
 661         if (retval != ERROR_OK)
 662                 return retval;
 663
 664         register_cache_invalidate(armv7m->arm.core_cache);
 665
 666         /* make sure we have latest dhcsr flags */
 667         retval = cortex_m_read_dhcsr_atomic_sticky(target);
 668         if (retval != ERROR_OK)
 669                 return retval;
 670
 671         return retval;
 672 }
 673
 674 static int cortex_m_examine_debug_reason(struct target *target)
 675 {
 676         struct cortex_m_common *cortex_m = target_to_cm(target);
 677
 678         /* THIS IS NOT GOOD, TODO - better logic for detection of debug state reason
 679          * only check the debug reason if we don't know it already */
 680
 681         if ((target->debug_reason != DBG_REASON_DBGRQ)
 682                 && (target->debug_reason != DBG_REASON_SINGLESTEP)) {
 683                 if (cortex_m->nvic_dfsr & DFSR_BKPT) {
 684                         target->debug_reason = DBG_REASON_BREAKPOINT;
 685                         if (cortex_m->nvic_dfsr & DFSR_DWTTRAP)
 686                                 target->debug_reason = DBG_REASON_WPTANDBKPT;
 687                 } else if (cortex_m->nvic_dfsr & DFSR_DWTTRAP)
 688                         target->debug_reason = DBG_REASON_WATCHPOINT;
 689                 else if (cortex_m->nvic_dfsr & DFSR_VCATCH)
 690                         target->debug_reason = DBG_REASON_BREAKPOINT;
 691                 else if (cortex_m->nvic_dfsr & DFSR_EXTERNAL)
 692                         target->debug_reason = DBG_REASON_DBGRQ;
 693                 else    /* HALTED */
 694                         target->debug_reason = DBG_REASON_UNDEFINED;
 695         }
 696
 697         return ERROR_OK;
 698 }
 699
 700 static int cortex_m_examine_exception_reason(struct target *target)
 701 {
 702         uint32_t shcsr = 0, except_sr = 0, cfsr = -1, except_ar = -1;
 703         struct armv7m_common *armv7m = target_to_armv7m(target);
 704         struct adiv5_dap *swjdp = armv7m->arm.dap;
 705         int retval;
 706
 707         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_SHCSR, &shcsr);
 708         if (retval != ERROR_OK)
 709                 return retval;
 710         switch (armv7m->exception_number) {
 711                 case 2: /* NMI */
 712                         break;
 713                 case 3: /* Hard Fault */
 714                         retval = mem_ap_read_atomic_u32(armv7m->debug_ap, NVIC_HFSR, &except_sr);
 715                         if (retval != ERROR_OK)
 716                                 return retval;
 717                         if (except_sr & 0x40000000) {
 718                                 retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_CFSR, &cfsr);
 719                                 if (retval != ERROR_OK)
 720                                         return retval;
 721                         }
 722                         break;
 723                 case 4: /* Memory Management */
 724                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_CFSR, &except_sr);
 725                         if (retval != ERROR_OK)
 726                                 return retval;
 727                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_MMFAR, &except_ar);
 728                         if (retval != ERROR_OK)
 729                                 return retval;
 730                         break;
 731                 case 5: /* Bus Fault */
 732                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_CFSR, &except_sr);
 733                         if (retval != ERROR_OK)
 734                                 return retval;
 735                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_BFAR, &except_ar);
 736                         if (retval != ERROR_OK)
 737                                 return retval;
 738                         break;
 739                 case 6: /* Usage Fault */
 740                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_CFSR, &except_sr);
 741                         if (retval != ERROR_OK)
 742                                 return retval;
 743                         break;
 744                 case 7: /* Secure Fault */
 745                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_SFSR, &except_sr);
 746                         if (retval != ERROR_OK)
 747                                 return retval;
 748                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_SFAR, &except_ar);
 749                         if (retval != ERROR_OK)
 750                                 return retval;
 751                         break;
 752                 case 11:        /* SVCall */
 753                         break;
 754                 case 12:        /* Debug Monitor */
 755                         retval = mem_ap_read_u32(armv7m->debug_ap, NVIC_DFSR, &except_sr);
 756                         if (retval != ERROR_OK)
 757                                 return retval;
 758                         break;
 759                 case 14:        /* PendSV */
 760                         break;
 761                 case 15:        /* SysTick */
 762                         break;
 763                 default:
 764                         except_sr = 0;
 765                         break;
 766         }
 767         retval = dap_run(swjdp);
 768         if (retval == ERROR_OK)
 769                 LOG_DEBUG("%s SHCSR 0x%" PRIx32 ", SR 0x%" PRIx32
 770                         ", CFSR 0x%" PRIx32 ", AR 0x%" PRIx32,
 771                         armv7m_exception_string(armv7m->exception_number),
 772                         shcsr, except_sr, cfsr, except_ar);
 773         return retval;
 774 }
 775
 776 static int cortex_m_debug_entry(struct target *target)
 777 {
 778         uint32_t xPSR;
 779         int retval;
 780         struct cortex_m_common *cortex_m = target_to_cm(target);
 781         struct armv7m_common *armv7m = &cortex_m->armv7m;
 782         struct arm *arm = &armv7m->arm;
 783         struct reg *r;
 784
 785         LOG_DEBUG(" ");
 786
 787         /* Do this really early to minimize the window where the MASKINTS erratum
 788          * can pile up pending interrupts. */
 789         cortex_m_set_maskints_for_halt(target);
 790
 791         cortex_m_clear_halt(target);
 792
 793         retval = cortex_m_read_dhcsr_atomic_sticky(target);
 794         if (retval != ERROR_OK)
 795                 return retval;
 796
 797         retval = armv7m->examine_debug_reason(target);
 798         if (retval != ERROR_OK)
 799                 return retval;
 800
 801         /* examine PE security state */
 802         bool secure_state = false;
 803         if (armv7m->arm.arch == ARM_ARCH_V8M) {
 804                 uint32_t dscsr;
 805
 806                 retval = mem_ap_read_u32(armv7m->debug_ap, DCB_DSCSR, &dscsr);
 807                 if (retval != ERROR_OK)
 808                         return retval;
 809
 810                 secure_state = (dscsr & DSCSR_CDS) == DSCSR_CDS;
 811         }
 812
 813         /* Load all registers to arm.core_cache */
 814         if (!cortex_m->slow_register_read) {
 815                 retval = cortex_m_fast_read_all_regs(target);
 816                 if (retval == ERROR_TIMEOUT_REACHED) {
 817                         cortex_m->slow_register_read = true;
 818                         LOG_DEBUG("Switched to slow register read");
 819                 }
 820         }
 821
 822         if (cortex_m->slow_register_read)
 823                 retval = cortex_m_slow_read_all_regs(target);
 824
 825         if (retval != ERROR_OK)
 826                 return retval;
 827
 828         r = arm->cpsr;
 829         xPSR = buf_get_u32(r->value, 0, 32);
 830
 831         /* Are we in an exception handler */
 832         if (xPSR & 0x1FF) {
 833                 armv7m->exception_number = (xPSR & 0x1FF);
 834
 835                 arm->core_mode = ARM_MODE_HANDLER;
 836                 arm->map = armv7m_msp_reg_map;
 837         } else {
 838                 unsigned control = buf_get_u32(arm->core_cache
 839                                 ->reg_list[ARMV7M_CONTROL].value, 0, 3);
 840
 841                 /* is this thread privileged? */
 842                 arm->core_mode = control & 1
 843                         ? ARM_MODE_USER_THREAD
 844                         : ARM_MODE_THREAD;
 845
 846                 /* which stack is it using? */
 847                 if (control & 2)
 848                         arm->map = armv7m_psp_reg_map;
 849                 else
 850                         arm->map = armv7m_msp_reg_map;
 851
 852                 armv7m->exception_number = 0;
 853         }
 854
 855         if (armv7m->exception_number)
 856                 cortex_m_examine_exception_reason(target);
 857
 858         LOG_DEBUG("entered debug state in core mode: %s at PC 0x%" PRIx32 ", cpu in %s state, target->state: %s",
 859                 arm_mode_name(arm->core_mode),
 860                 buf_get_u32(arm->pc->value, 0, 32),
 861                 secure_state ? "Secure" : "Non-Secure",
 862                 target_state_name(target));
 863
 864         if (armv7m->post_debug_entry) {
 865                 retval = armv7m->post_debug_entry(target);
 866                 if (retval != ERROR_OK)
 867                         return retval;
 868         }
 869
 870         return ERROR_OK;
 871 }
 872
 873 static int cortex_m_poll(struct target *target)
 874 {
 875         int detected_failure = ERROR_OK;
 876         int retval = ERROR_OK;
 877         enum target_state prev_target_state = target->state;
 878         struct cortex_m_common *cortex_m = target_to_cm(target);
 879         struct armv7m_common *armv7m = &cortex_m->armv7m;
 880
 881         /* Read from Debug Halting Control and Status Register */
 882         retval = cortex_m_read_dhcsr_atomic_sticky(target);
 883         if (retval != ERROR_OK) {
 884                 target->state = TARGET_UNKNOWN;
 885                 return retval;
 886         }
 887
 888         /* Recover from lockup.  See ARMv7-M architecture spec,
 889          * section B1.5.15 "Unrecoverable exception cases".
 890          */
 891         if (cortex_m->dcb_dhcsr & S_LOCKUP) {
 892                 LOG_ERROR("%s -- clearing lockup after double fault",
 893                         target_name(target));
 894                 cortex_m_write_debug_halt_mask(target, C_HALT, 0);
 895                 target->debug_reason = DBG_REASON_DBGRQ;
 896
 897                 /* We have to execute the rest (the "finally" equivalent, but
 898                  * still throw this exception again).
 899                  */
 900                 detected_failure = ERROR_FAIL;
 901
 902                 /* refresh status bits */
 903                 retval = cortex_m_read_dhcsr_atomic_sticky(target);
 904                 if (retval != ERROR_OK)
 905                         return retval;
 906         }
 907
 908         if (cortex_m->dcb_dhcsr_cumulated_sticky & S_RESET_ST) {
 909                 cortex_m->dcb_dhcsr_cumulated_sticky &= ~S_RESET_ST;
 910                 if (target->state != TARGET_RESET) {
 911                         target->state = TARGET_RESET;
 912                         LOG_INFO("%s: external reset detected", target_name(target));
 913                 }
 914                 return ERROR_OK;
 915         }
 916
 917         if (target->state == TARGET_RESET) {
 918                 /* Cannot switch context while running so endreset is
 919                  * called with target->state == TARGET_RESET
 920                  */
 921                 LOG_DEBUG("Exit from reset with dcb_dhcsr 0x%" PRIx32,
 922                         cortex_m->dcb_dhcsr);
 923                 retval = cortex_m_endreset_event(target);
 924                 if (retval != ERROR_OK) {
 925                         target->state = TARGET_UNKNOWN;
 926                         return retval;
 927                 }
 928                 target->state = TARGET_RUNNING;
 929                 prev_target_state = TARGET_RUNNING;
 930         }
 931
 932         if (cortex_m->dcb_dhcsr & S_HALT) {
 933                 target->state = TARGET_HALTED;
 934
 935                 if ((prev_target_state == TARGET_RUNNING) || (prev_target_state == TARGET_RESET)) {
 936                         retval = cortex_m_debug_entry(target);
 937                         if (retval != ERROR_OK)
 938                                 return retval;
 939
 940                         if (arm_semihosting(target, &retval) != 0)
 941                                 return retval;
 942
 943                         target_call_event_callbacks(target, TARGET_EVENT_HALTED);
 944                 }
 945                 if (prev_target_state == TARGET_DEBUG_RUNNING) {
 946                         LOG_DEBUG(" ");
 947                         retval = cortex_m_debug_entry(target);
 948                         if (retval != ERROR_OK)
 949                                 return retval;
 950
 951                         target_call_event_callbacks(target, TARGET_EVENT_DEBUG_HALTED);
 952                 }
 953         }
 954
 955         if (target->state == TARGET_UNKNOWN) {
 956                 /* Check if processor is retiring instructions or sleeping.
 957                  * Unlike S_RESET_ST here we test if the target *is* running now,
 958                  * not if it has been running (possibly in the past). Instructions are
 959                  * typically processed much faster than OpenOCD polls DHCSR so S_RETIRE_ST
 960                  * is read always 1. That's the reason not to use dcb_dhcsr_cumulated_sticky.
 961                  */
 962                 if (cortex_m->dcb_dhcsr & S_RETIRE_ST || cortex_m->dcb_dhcsr & S_SLEEP) {
 963                         target->state = TARGET_RUNNING;
 964                         retval = ERROR_OK;
 965                 }
 966         }
 967
 968         /* Check that target is truly halted, since the target could be resumed externally */
 969         if ((prev_target_state == TARGET_HALTED) && !(cortex_m->dcb_dhcsr & S_HALT)) {
 970                 /* registers are now invalid */
 971                 register_cache_invalidate(armv7m->arm.core_cache);
 972
 973                 target->state = TARGET_RUNNING;
 974                 LOG_WARNING("%s: external resume detected", target_name(target));
 975                 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
 976                 retval = ERROR_OK;
 977         }
 978
 979         /* Did we detect a failure condition that we cleared? */
 980         if (detected_failure != ERROR_OK)
 981                 retval = detected_failure;
 982         return retval;
 983 }
 984
 985 static int cortex_m_halt(struct target *target)
 986 {
 987         LOG_DEBUG("target->state: %s",
 988                 target_state_name(target));
 989
 990         if (target->state == TARGET_HALTED) {
 991                 LOG_DEBUG("target was already halted");
 992                 return ERROR_OK;
 993         }
 994
 995         if (target->state == TARGET_UNKNOWN)
 996                 LOG_WARNING("target was in unknown state when halt was requested");
 997
 998         if (target->state == TARGET_RESET) {
 999                 if ((jtag_get_reset_config() & RESET_SRST_PULLS_TRST) && jtag_get_srst()) {
1000                         LOG_ERROR("can't request a halt while in reset if nSRST pulls nTRST");
1001                         return ERROR_TARGET_FAILURE;
1002                 } else {
1003                         /* we came here in a reset_halt or reset_init sequence
1004                          * debug entry was already prepared in cortex_m3_assert_reset()
1005                          */
1006                         target->debug_reason = DBG_REASON_DBGRQ;
1007
1008                         return ERROR_OK;
1009                 }
1010         }
1011
1012         /* Write to Debug Halting Control and Status Register */
1013         cortex_m_write_debug_halt_mask(target, C_HALT, 0);
1014
1015         /* Do this really early to minimize the window where the MASKINTS erratum
1016          * can pile up pending interrupts. */
1017         cortex_m_set_maskints_for_halt(target);
1018
1019         target->debug_reason = DBG_REASON_DBGRQ;
1020
1021         return ERROR_OK;
1022 }
1023
1024 static int cortex_m_soft_reset_halt(struct target *target)
1025 {
1026         struct cortex_m_common *cortex_m = target_to_cm(target);
1027         struct armv7m_common *armv7m = &cortex_m->armv7m;
1028         int retval, timeout = 0;
1029
1030         /* on single cortex_m MCU soft_reset_halt should be avoided as same functionality
1031          * can be obtained by using 'reset halt' and 'cortex_m reset_config vectreset'.
1032          * As this reset only uses VC_CORERESET it would only ever reset the cortex_m
1033          * core, not the peripherals */
1034         LOG_DEBUG("soft_reset_halt is discouraged, please use 'reset halt' instead.");
1035
1036         if (!cortex_m->vectreset_supported) {
1037                 LOG_ERROR("VECTRESET is not supported on this Cortex-M core");
1038                 return ERROR_FAIL;
1039         }
1040
1041         /* Set C_DEBUGEN */
1042         retval = cortex_m_write_debug_halt_mask(target, 0, C_STEP | C_MASKINTS);
1043         if (retval != ERROR_OK)
1044                 return retval;
1045
1046         /* Enter debug state on reset; restore DEMCR in endreset_event() */
1047         retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DEMCR,
1048                         TRCENA | VC_HARDERR | VC_BUSERR | VC_CORERESET);
1049         if (retval != ERROR_OK)
1050                 return retval;
1051
1052         /* Request a core-only reset */
1053         retval = mem_ap_write_atomic_u32(armv7m->debug_ap, NVIC_AIRCR,
1054                         AIRCR_VECTKEY | AIRCR_VECTRESET);
1055         if (retval != ERROR_OK)
1056                 return retval;
1057         target->state = TARGET_RESET;
1058
1059         /* registers are now invalid */
1060         register_cache_invalidate(cortex_m->armv7m.arm.core_cache);
1061
1062         while (timeout < 100) {
1063                 retval = cortex_m_read_dhcsr_atomic_sticky(target);
1064                 if (retval == ERROR_OK) {
1065                         retval = mem_ap_read_atomic_u32(armv7m->debug_ap, NVIC_DFSR,
1066                                         &cortex_m->nvic_dfsr);
1067                         if (retval != ERROR_OK)
1068                                 return retval;
1069                         if ((cortex_m->dcb_dhcsr & S_HALT)
1070                                 && (cortex_m->nvic_dfsr & DFSR_VCATCH)) {
1071                                 LOG_DEBUG("system reset-halted, DHCSR 0x%08" PRIx32 ", DFSR 0x%08" PRIx32,
1072                                         cortex_m->dcb_dhcsr, cortex_m->nvic_dfsr);
1073                                 cortex_m_poll(target);
1074                                 /* FIXME restore user's vector catch config */
1075                                 return ERROR_OK;
1076                         } else
1077                                 LOG_DEBUG("waiting for system reset-halt, "
1078                                         "DHCSR 0x%08" PRIx32 ", %d ms",
1079                                         cortex_m->dcb_dhcsr, timeout);
1080                 }
1081                 timeout++;
1082                 alive_sleep(1);
1083         }
1084
1085         return ERROR_OK;
1086 }
1087
1088 void cortex_m_enable_breakpoints(struct target *target)
1089 {
1090         struct breakpoint *breakpoint = target->breakpoints;
1091
1092         /* set any pending breakpoints */
1093         while (breakpoint) {
1094                 if (!breakpoint->set)
1095                         cortex_m_set_breakpoint(target, breakpoint);
1096                 breakpoint = breakpoint->next;
1097         }
1098 }
1099
1100 static int cortex_m_resume(struct target *target, int current,
1101         target_addr_t address, int handle_breakpoints, int debug_execution)
1102 {
1103         struct armv7m_common *armv7m = target_to_armv7m(target);
1104         struct breakpoint *breakpoint = NULL;
1105         uint32_t resume_pc;
1106         struct reg *r;
1107
1108         if (target->state != TARGET_HALTED) {
1109                 LOG_WARNING("target not halted");
1110                 return ERROR_TARGET_NOT_HALTED;
1111         }
1112
1113         if (!debug_execution) {
1114                 target_free_all_working_areas(target);
1115                 cortex_m_enable_breakpoints(target);
1116                 cortex_m_enable_watchpoints(target);
1117         }
1118
1119         if (debug_execution) {
1120                 r = armv7m->arm.core_cache->reg_list + ARMV7M_PRIMASK;
1121
1122                 /* Disable interrupts */
1123                 /* We disable interrupts in the PRIMASK register instead of
1124                  * masking with C_MASKINTS.  This is probably the same issue
1125                  * as Cortex-M3 Erratum 377493 (fixed in r1p0):  C_MASKINTS
1126                  * in parallel with disabled interrupts can cause local faults
1127                  * to not be taken.
1128                  *
1129                  * This breaks non-debug (application) execution if not
1130                  * called from armv7m_start_algorithm() which saves registers.
1131                  */
1132                 buf_set_u32(r->value, 0, 1, 1);
1133                 r->dirty = true;
1134                 r->valid = true;
1135
1136                 /* Make sure we are in Thumb mode, set xPSR.T bit */
1137                 /* armv7m_start_algorithm() initializes entire xPSR register.
1138                  * This duplicity handles the case when cortex_m_resume()
1139                  * is used with the debug_execution flag directly,
1140                  * not called through armv7m_start_algorithm().
1141                  */
1142                 r = armv7m->arm.cpsr;
1143                 buf_set_u32(r->value, 24, 1, 1);
1144                 r->dirty = true;
1145                 r->valid = true;
1146         }
1147
1148         /* current = 1: continue on current pc, otherwise continue at <address> */
1149         r = armv7m->arm.pc;
1150         if (!current) {
1151                 buf_set_u32(r->value, 0, 32, address);
1152                 r->dirty = true;
1153                 r->valid = true;
1154         }
1155
1156         /* if we halted last time due to a bkpt instruction
1157          * then we have to manually step over it, otherwise
1158          * the core will break again */
1159
1160         if (!breakpoint_find(target, buf_get_u32(r->value, 0, 32))
1161                 && !debug_execution)
1162                 armv7m_maybe_skip_bkpt_inst(target, NULL);
1163
1164         resume_pc = buf_get_u32(r->value, 0, 32);
1165
1166         armv7m_restore_context(target);
1167
1168         /* the front-end may request us not to handle breakpoints */
1169         if (handle_breakpoints) {
1170                 /* Single step past breakpoint at current address */
1171                 breakpoint = breakpoint_find(target, resume_pc);
1172                 if (breakpoint) {
1173                         LOG_DEBUG("unset breakpoint at " TARGET_ADDR_FMT " (ID: %" PRIu32 ")",
1174                                 breakpoint->address,
1175                                 breakpoint->unique_id);
1176                         cortex_m_unset_breakpoint(target, breakpoint);
1177                         cortex_m_single_step_core(target);
1178                         cortex_m_set_breakpoint(target, breakpoint);
1179                 }
1180         }
1181
1182         /* Restart core */
1183         cortex_m_set_maskints_for_run(target);
1184         cortex_m_write_debug_halt_mask(target, 0, C_HALT);
1185
1186         target->debug_reason = DBG_REASON_NOTHALTED;
1187
1188         /* registers are now invalid */
1189         register_cache_invalidate(armv7m->arm.core_cache);
1190
1191         if (!debug_execution) {
1192                 target->state = TARGET_RUNNING;
1193                 target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1194                 LOG_DEBUG("target resumed at 0x%" PRIx32 "", resume_pc);
1195         } else {
1196                 target->state = TARGET_DEBUG_RUNNING;
1197                 target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
1198                 LOG_DEBUG("target debug resumed at 0x%" PRIx32 "", resume_pc);
1199         }
1200
1201         return ERROR_OK;
1202 }
1203
1204 /* int irqstepcount = 0; */
1205 static int cortex_m_step(struct target *target, int current,
1206         target_addr_t address, int handle_breakpoints)
1207 {
1208         struct cortex_m_common *cortex_m = target_to_cm(target);
1209         struct armv7m_common *armv7m = &cortex_m->armv7m;
1210         struct breakpoint *breakpoint = NULL;
1211         struct reg *pc = armv7m->arm.pc;
1212         bool bkpt_inst_found = false;
1213         int retval;
1214         bool isr_timed_out = false;
1215
1216         if (target->state != TARGET_HALTED) {
1217                 LOG_WARNING("target not halted");
1218                 return ERROR_TARGET_NOT_HALTED;
1219         }
1220
1221         /* current = 1: continue on current pc, otherwise continue at <address> */
1222         if (!current) {
1223                 buf_set_u32(pc->value, 0, 32, address);
1224                 pc->dirty = true;
1225                 pc->valid = true;
1226         }
1227
1228         uint32_t pc_value = buf_get_u32(pc->value, 0, 32);
1229
1230         /* the front-end may request us not to handle breakpoints */
1231         if (handle_breakpoints) {
1232                 breakpoint = breakpoint_find(target, pc_value);
1233                 if (breakpoint)
1234                         cortex_m_unset_breakpoint(target, breakpoint);
1235         }
1236
1237         armv7m_maybe_skip_bkpt_inst(target, &bkpt_inst_found);
1238
1239         target->debug_reason = DBG_REASON_SINGLESTEP;
1240
1241         armv7m_restore_context(target);
1242
1243         target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
1244
1245         /* if no bkpt instruction is found at pc then we can perform
1246          * a normal step, otherwise we have to manually step over the bkpt
1247          * instruction - as such simulate a step */
1248         if (bkpt_inst_found == false) {
1249                 if (cortex_m->isrmasking_mode != CORTEX_M_ISRMASK_AUTO) {
1250                         /* Automatic ISR masking mode off: Just step over the next
1251                          * instruction, with interrupts on or off as appropriate. */
1252                         cortex_m_set_maskints_for_step(target);
1253                         cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT);
1254                 } else {
1255                         /* Process interrupts during stepping in a way they don't interfere
1256                          * debugging.
1257                          *
1258                          * Principle:
1259                          *
1260                          * Set a temporary break point at the current pc and let the core run
1261                          * with interrupts enabled. Pending interrupts get served and we run
1262                          * into the breakpoint again afterwards. Then we step over the next
1263                          * instruction with interrupts disabled.
1264                          *
1265                          * If the pending interrupts don't complete within time, we leave the
1266                          * core running. This may happen if the interrupts trigger faster
1267                          * than the core can process them or the handler doesn't return.
1268                          *
1269                          * If no more breakpoints are available we simply do a step with
1270                          * interrupts enabled.
1271                          *
1272                          */
1273
1274                         /* 2012-09-29 ph
1275                          *
1276                          * If a break point is already set on the lower half word then a break point on
1277                          * the upper half word will not break again when the core is restarted. So we
1278                          * just step over the instruction with interrupts disabled.
1279                          *
1280                          * The documentation has no information about this, it was found by observation
1281                          * on STM32F1 and STM32F2. Proper explanation welcome. STM32F0 doesn't seem to
1282                          * suffer from this problem.
1283                          *
1284                          * To add some confusion: pc_value has bit 0 always set, while the breakpoint
1285                          * address has it always cleared. The former is done to indicate thumb mode
1286                          * to gdb.
1287                          *
1288                          */
1289                         if ((pc_value & 0x02) && breakpoint_find(target, pc_value & ~0x03)) {
1290                                 LOG_DEBUG("Stepping over next instruction with interrupts disabled");
1291                                 cortex_m_write_debug_halt_mask(target, C_HALT | C_MASKINTS, 0);
1292                                 cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT);
1293                                 /* Re-enable interrupts if appropriate */
1294                                 cortex_m_write_debug_halt_mask(target, C_HALT, 0);
1295                                 cortex_m_set_maskints_for_halt(target);
1296                         } else {
1297
1298                                 /* Set a temporary break point */
1299                                 if (breakpoint) {
1300                                         retval = cortex_m_set_breakpoint(target, breakpoint);
1301                                 } else {
1302                                         enum breakpoint_type type = BKPT_HARD;
1303                                         if (cortex_m->fp_rev == 0 && pc_value > 0x1FFFFFFF) {
1304                                                 /* FPB rev.1 cannot handle such addr, try BKPT instr */
1305                                                 type = BKPT_SOFT;
1306                                         }
1307                                         retval = breakpoint_add(target, pc_value, 2, type);
1308                                 }
1309
1310                                 bool tmp_bp_set = (retval == ERROR_OK);
1311
1312                                 /* No more breakpoints left, just do a step */
1313                                 if (!tmp_bp_set) {
1314                                         cortex_m_set_maskints_for_step(target);
1315                                         cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT);
1316                                         /* Re-enable interrupts if appropriate */
1317                                         cortex_m_write_debug_halt_mask(target, C_HALT, 0);
1318                                         cortex_m_set_maskints_for_halt(target);
1319                                 } else {
1320                                         /* Start the core */
1321                                         LOG_DEBUG("Starting core to serve pending interrupts");
1322                                         int64_t t_start = timeval_ms();
1323                                         cortex_m_set_maskints_for_run(target);
1324                                         cortex_m_write_debug_halt_mask(target, 0, C_HALT | C_STEP);
1325
1326                                         /* Wait for pending handlers to complete or timeout */
1327                                         do {
1328                                                 retval = cortex_m_read_dhcsr_atomic_sticky(target);
1329                                                 if (retval != ERROR_OK) {
1330                                                         target->state = TARGET_UNKNOWN;
1331                                                         return retval;
1332                                                 }
1333                                                 isr_timed_out = ((timeval_ms() - t_start) > 500);
1334                                         } while (!((cortex_m->dcb_dhcsr & S_HALT) || isr_timed_out));
1335
1336                                         /* only remove breakpoint if we created it */
1337                                         if (breakpoint)
1338                                                 cortex_m_unset_breakpoint(target, breakpoint);
1339                                         else {
1340                                                 /* Remove the temporary breakpoint */
1341                                                 breakpoint_remove(target, pc_value);
1342                                         }
1343
1344                                         if (isr_timed_out) {
1345                                                 LOG_DEBUG("Interrupt handlers didn't complete within time, "
1346                                                         "leaving target running");
1347                                         } else {
1348                                                 /* Step over next instruction with interrupts disabled */
1349                                                 cortex_m_set_maskints_for_step(target);
1350                                                 cortex_m_write_debug_halt_mask(target,
1351                                                         C_HALT | C_MASKINTS,
1352                                                         0);
1353                                                 cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT);
1354                                                 /* Re-enable interrupts if appropriate */
1355                                                 cortex_m_write_debug_halt_mask(target, C_HALT, 0);
1356                                                 cortex_m_set_maskints_for_halt(target);
1357                                         }
1358                                 }
1359                         }
1360                 }
1361         }
1362
1363         retval = cortex_m_read_dhcsr_atomic_sticky(target);
1364         if (retval != ERROR_OK)
1365                 return retval;
1366
1367         /* registers are now invalid */
1368         register_cache_invalidate(armv7m->arm.core_cache);
1369
1370         if (breakpoint)
1371                 cortex_m_set_breakpoint(target, breakpoint);
1372
1373         if (isr_timed_out) {
1374                 /* Leave the core running. The user has to stop execution manually. */
1375                 target->debug_reason = DBG_REASON_NOTHALTED;
1376                 target->state = TARGET_RUNNING;
1377                 return ERROR_OK;
1378         }
1379
1380         LOG_DEBUG("target stepped dcb_dhcsr = 0x%" PRIx32
1381                 " nvic_icsr = 0x%" PRIx32,
1382                 cortex_m->dcb_dhcsr, cortex_m->nvic_icsr);
1383
1384         retval = cortex_m_debug_entry(target);
1385         if (retval != ERROR_OK)
1386                 return retval;
1387         target_call_event_callbacks(target, TARGET_EVENT_HALTED);
1388
1389         LOG_DEBUG("target stepped dcb_dhcsr = 0x%" PRIx32
1390                 " nvic_icsr = 0x%" PRIx32,
1391                 cortex_m->dcb_dhcsr, cortex_m->nvic_icsr);
1392
1393         return ERROR_OK;
1394 }
1395
1396 static int cortex_m_assert_reset(struct target *target)
1397 {
1398         struct cortex_m_common *cortex_m = target_to_cm(target);
1399         struct armv7m_common *armv7m = &cortex_m->armv7m;
1400         enum cortex_m_soft_reset_config reset_config = cortex_m->soft_reset_config;
1401
1402         LOG_DEBUG("target->state: %s",
1403                 target_state_name(target));
1404
1405         enum reset_types jtag_reset_config = jtag_get_reset_config();
1406
1407         if (target_has_event_action(target, TARGET_EVENT_RESET_ASSERT)) {
1408                 /* allow scripts to override the reset event */
1409
1410                 target_handle_event(target, TARGET_EVENT_RESET_ASSERT);
1411                 register_cache_invalidate(cortex_m->armv7m.arm.core_cache);
1412                 target->state = TARGET_RESET;
1413
1414                 return ERROR_OK;
1415         }
1416
1417         /* some cores support connecting while srst is asserted
1418          * use that mode is it has been configured */
1419
1420         bool srst_asserted = false;
1421
1422         if (!target_was_examined(target)) {
1423                 if (jtag_reset_config & RESET_HAS_SRST) {
1424                         adapter_assert_reset();
1425                         if (target->reset_halt)
1426                                 LOG_ERROR("Target not examined, will not halt after reset!");
1427                         return ERROR_OK;
1428                 } else {
1429                         LOG_ERROR("Target not examined, reset NOT asserted!");
1430                         return ERROR_FAIL;
1431                 }
1432         }
1433
1434         if ((jtag_reset_config & RESET_HAS_SRST) &&
1435             (jtag_reset_config & RESET_SRST_NO_GATING)) {
1436                 adapter_assert_reset();
1437                 srst_asserted = true;
1438         }
1439
1440         /* Enable debug requests */
1441         int retval = cortex_m_read_dhcsr_atomic_sticky(target);
1442
1443         /* Store important errors instead of failing and proceed to reset assert */
1444
1445         if (retval != ERROR_OK || !(cortex_m->dcb_dhcsr & C_DEBUGEN))
1446                 retval = cortex_m_write_debug_halt_mask(target, 0, C_HALT | C_STEP | C_MASKINTS);
1447
1448         /* If the processor is sleeping in a WFI or WFE instruction, the
1449          * C_HALT bit must be asserted to regain control */
1450         if (retval == ERROR_OK && (cortex_m->dcb_dhcsr & S_SLEEP))
1451                 retval = cortex_m_write_debug_halt_mask(target, C_HALT, 0);
1452
1453         mem_ap_write_u32(armv7m->debug_ap, DCB_DCRDR, 0);
1454         /* Ignore less important errors */
1455
1456         if (!target->reset_halt) {
1457                 /* Set/Clear C_MASKINTS in a separate operation */
1458                 cortex_m_set_maskints_for_run(target);
1459
1460                 /* clear any debug flags before resuming */
1461                 cortex_m_clear_halt(target);
1462
1463                 /* clear C_HALT in dhcsr reg */
1464                 cortex_m_write_debug_halt_mask(target, 0, C_HALT);
1465         } else {
1466                 /* Halt in debug on reset; endreset_event() restores DEMCR.
1467                  *
1468                  * REVISIT catching BUSERR presumably helps to defend against
1469                  * bad vector table entries.  Should this include MMERR or
1470                  * other flags too?
1471                  */
1472                 int retval2;
1473                 retval2 = mem_ap_write_atomic_u32(armv7m->debug_ap, DCB_DEMCR,
1474                                 TRCENA | VC_HARDERR | VC_BUSERR | VC_CORERESET);
1475                 if (retval != ERROR_OK || retval2 != ERROR_OK)
1476                         LOG_INFO("AP write error, reset will not halt");
1477         }
1478
1479         if (jtag_reset_config & RESET_HAS_SRST) {
1480                 /* default to asserting srst */
1481                 if (!srst_asserted)
1482                         adapter_assert_reset();
1483
1484                 /* srst is asserted, ignore AP access errors */
1485                 retval = ERROR_OK;
1486         } else {
1487                 /* Use a standard Cortex-M3 software reset mechanism.
1488                  * We default to using VECTRESET as it is supported on all current cores
1489                  * (except Cortex-M0, M0+ and M1 which support SYSRESETREQ only!)
1490                  * This has the disadvantage of not resetting the peripherals, so a
1491                  * reset-init event handler is needed to perform any peripheral resets.
1492                  */
1493                 if (!cortex_m->vectreset_supported
1494                                 && reset_config == CORTEX_M_RESET_VECTRESET) {
1495                         reset_config = CORTEX_M_RESET_SYSRESETREQ;
1496                         LOG_WARNING("VECTRESET is not supported on this Cortex-M core, using SYSRESETREQ instead.");
1497                         LOG_WARNING("Set 'cortex_m reset_config sysresetreq'.");
1498                 }
1499
1500                 LOG_DEBUG("Using Cortex-M %s", (reset_config == CORTEX_M_RESET_SYSRESETREQ)
1501                         ? "SYSRESETREQ" : "VECTRESET");
1502
1503                 if (reset_config == CORTEX_M_RESET_VECTRESET) {
1504                         LOG_WARNING("Only resetting the Cortex-M core, use a reset-init event "
1505                                 "handler to reset any peripherals or configure hardware srst support.");
1506                 }
1507
1508                 int retval3;
1509                 retval3 = mem_ap_write_atomic_u32(armv7m->debug_ap, NVIC_AIRCR,
1510                                 AIRCR_VECTKEY | ((reset_config == CORTEX_M_RESET_SYSRESETREQ)
1511                                 ? AIRCR_SYSRESETREQ : AIRCR_VECTRESET));
1512                 if (retval3 != ERROR_OK)
1513                         LOG_DEBUG("Ignoring AP write error right after reset");
1514
1515                 retval3 = dap_dp_init_or_reconnect(armv7m->debug_ap->dap);
1516                 if (retval3 != ERROR_OK) {
1517                         LOG_ERROR("DP initialisation failed");
1518                         /* The error return value must not be propagated in this case.
1519                          * SYSRESETREQ or VECTRESET have been possibly triggered
1520                          * so reset processing should continue */
1521                 } else {
1522                         /* I do not know why this is necessary, but it
1523                          * fixes strange effects (step/resume cause NMI
1524                          * after reset) on LM3S6918 -- Michael Schwingen
1525                          */
1526                         uint32_t tmp;
1527                         mem_ap_read_atomic_u32(armv7m->debug_ap, NVIC_AIRCR, &tmp);
1528                 }
1529         }
1530
1531         target->state = TARGET_RESET;
1532         jtag_sleep(50000);
1533
1534         register_cache_invalidate(cortex_m->armv7m.arm.core_cache);
1535
1536         /* now return stored error code if any */
1537         if (retval != ERROR_OK)
1538                 return retval;
1539
1540         if (target->reset_halt) {
1541                 retval = target_halt(target);
1542                 if (retval != ERROR_OK)
1543                         return retval;
1544         }
1545
1546         return ERROR_OK;
1547 }
1548
1549 static int cortex_m_deassert_reset(struct target *target)
1550 {
1551         struct armv7m_common *armv7m = &target_to_cm(target)->armv7m;
1552
1553         LOG_DEBUG("target->state: %s",
1554                 target_state_name(target));
1555
1556         /* deassert reset lines */
1557         adapter_deassert_reset();
1558
1559         enum reset_types jtag_reset_config = jtag_get_reset_config();
1560
1561         if ((jtag_reset_config & RESET_HAS_SRST) &&
1562             !(jtag_reset_config & RESET_SRST_NO_GATING) &&
1563                 target_was_examined(target)) {
1564
1565                 int retval = dap_dp_init_or_reconnect(armv7m->debug_ap->dap);
1566                 if (retval != ERROR_OK) {
1567                         LOG_ERROR("DP initialisation failed");
1568                         return retval;
1569                 }
1570         }
1571
1572         return ERROR_OK;
1573 }
1574
1575 int cortex_m_set_breakpoint(struct target *target, struct breakpoint *breakpoint)
1576 {
1577         int retval;
1578         unsigned int fp_num = 0;
1579         struct cortex_m_common *cortex_m = target_to_cm(target);
1580         struct cortex_m_fp_comparator *comparator_list = cortex_m->fp_comparator_list;
1581
1582         if (breakpoint->set) {
1583                 LOG_WARNING("breakpoint (BPID: %" PRIu32 ") already set", breakpoint->unique_id);
1584                 return ERROR_OK;
1585         }
1586
1587         if (breakpoint->type == BKPT_HARD) {
1588                 uint32_t fpcr_value;
1589                 while (comparator_list[fp_num].used && (fp_num < cortex_m->fp_num_code))
1590                         fp_num++;
1591                 if (fp_num >= cortex_m->fp_num_code) {
1592                         LOG_ERROR("Can not find free FPB Comparator!");
1593                         return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1594                 }
1595                 breakpoint->set = fp_num + 1;
1596                 fpcr_value = breakpoint->address | 1;
1597                 if (cortex_m->fp_rev == 0) {
1598                         if (breakpoint->address > 0x1FFFFFFF) {
1599                                 LOG_ERROR("Cortex-M Flash Patch Breakpoint rev.1 cannot handle HW breakpoint above address 0x1FFFFFFE");
1600                                 return ERROR_FAIL;
1601                         }
1602                         uint32_t hilo;
1603                         hilo = (breakpoint->address & 0x2) ? FPCR_REPLACE_BKPT_HIGH : FPCR_REPLACE_BKPT_LOW;
1604                         fpcr_value = (fpcr_value & 0x1FFFFFFC) | hilo | 1;
1605                 } else if (cortex_m->fp_rev > 1) {
1606                         LOG_ERROR("Unhandled Cortex-M Flash Patch Breakpoint architecture revision");
1607                         return ERROR_FAIL;
1608                 }
1609                 comparator_list[fp_num].used = true;
1610                 comparator_list[fp_num].fpcr_value = fpcr_value;
1611                 target_write_u32(target, comparator_list[fp_num].fpcr_address,
1612                         comparator_list[fp_num].fpcr_value);
1613                 LOG_DEBUG("fpc_num %i fpcr_value 0x%" PRIx32 "",
1614                         fp_num,
1615                         comparator_list[fp_num].fpcr_value);
1616                 if (!cortex_m->fpb_enabled) {
1617                         LOG_DEBUG("FPB wasn't enabled, do it now");
1618                         retval = cortex_m_enable_fpb(target);
1619                         if (retval != ERROR_OK) {
1620                                 LOG_ERROR("Failed to enable the FPB");
1621                                 return retval;
1622                         }
1623
1624                         cortex_m->fpb_enabled = true;
1625                 }
1626         } else if (breakpoint->type == BKPT_SOFT) {
1627                 uint8_t code[4];
1628
1629                 /* NOTE: on ARMv6-M and ARMv7-M, BKPT(0xab) is used for
1630                  * semihosting; don't use that.  Otherwise the BKPT
1631                  * parameter is arbitrary.
1632                  */
1633                 buf_set_u32(code, 0, 32, ARMV5_T_BKPT(0x11));
1634                 retval = target_read_memory(target,
1635                                 breakpoint->address & 0xFFFFFFFE,
1636                                 breakpoint->length, 1,
1637                                 breakpoint->orig_instr);
1638                 if (retval != ERROR_OK)
1639                         return retval;
1640                 retval = target_write_memory(target,
1641                                 breakpoint->address & 0xFFFFFFFE,
1642                                 breakpoint->length, 1,
1643                                 code);
1644                 if (retval != ERROR_OK)
1645                         return retval;
1646                 breakpoint->set = true;
1647         }
1648
1649         LOG_DEBUG("BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (set=%d)",
1650                 breakpoint->unique_id,
1651                 (int)(breakpoint->type),
1652                 breakpoint->address,
1653                 breakpoint->length,
1654                 breakpoint->set);
1655
1656         return ERROR_OK;
1657 }
1658
1659 int cortex_m_unset_breakpoint(struct target *target, struct breakpoint *breakpoint)
1660 {
1661         int retval;
1662         struct cortex_m_common *cortex_m = target_to_cm(target);
1663         struct cortex_m_fp_comparator *comparator_list = cortex_m->fp_comparator_list;
1664
1665         if (breakpoint->set <= 0) {
1666                 LOG_WARNING("breakpoint not set");
1667                 return ERROR_OK;
1668         }
1669
1670         LOG_DEBUG("BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (set=%d)",
1671                 breakpoint->unique_id,
1672                 (int)(breakpoint->type),
1673                 breakpoint->address,
1674                 breakpoint->length,
1675                 breakpoint->set);
1676
1677         if (breakpoint->type == BKPT_HARD) {
1678                 unsigned int fp_num = breakpoint->set - 1;
1679                 if (fp_num >= cortex_m->fp_num_code) {
1680                         LOG_DEBUG("Invalid FP Comparator number in breakpoint");
1681                         return ERROR_OK;
1682                 }
1683                 comparator_list[fp_num].used = false;
1684                 comparator_list[fp_num].fpcr_value = 0;
1685                 target_write_u32(target, comparator_list[fp_num].fpcr_address,
1686                         comparator_list[fp_num].fpcr_value);
1687         } else {
1688                 /* restore original instruction (kept in target endianness) */
1689                 retval = target_write_memory(target, breakpoint->address & 0xFFFFFFFE,
1690                                         breakpoint->length, 1,
1691                                         breakpoint->orig_instr);
1692                 if (retval != ERROR_OK)
1693                         return retval;
1694         }
1695         breakpoint->set = false;
1696
1697         return ERROR_OK;
1698 }
1699
1700 int cortex_m_add_breakpoint(struct target *target, struct breakpoint *breakpoint)
1701 {
1702         if (breakpoint->length == 3) {
1703                 LOG_DEBUG("Using a two byte breakpoint for 32bit Thumb-2 request");
1704                 breakpoint->length = 2;
1705         }
1706
1707         if ((breakpoint->length != 2)) {
1708                 LOG_INFO("only breakpoints of two bytes length supported");
1709                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1710         }
1711
1712         return cortex_m_set_breakpoint(target, breakpoint);
1713 }
1714
1715 int cortex_m_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
1716 {
1717         if (!breakpoint->set)
1718                 return ERROR_OK;
1719
1720         return cortex_m_unset_breakpoint(target, breakpoint);
1721 }
1722
1723 static int cortex_m_set_watchpoint(struct target *target, struct watchpoint *watchpoint)
1724 {
1725         unsigned int dwt_num = 0;
1726         struct cortex_m_common *cortex_m = target_to_cm(target);
1727
1728         /* REVISIT Don't fully trust these "not used" records ... users
1729          * may set up breakpoints by hand, e.g. dual-address data value
1730          * watchpoint using comparator #1; comparator #0 matching cycle
1731          * count; send data trace info through ITM and TPIU; etc
1732          */
1733         struct cortex_m_dwt_comparator *comparator;
1734
1735         for (comparator = cortex_m->dwt_comparator_list;
1736                 comparator->used && dwt_num < cortex_m->dwt_num_comp;
1737                 comparator++, dwt_num++)
1738                 continue;
1739         if (dwt_num >= cortex_m->dwt_num_comp) {
1740                 LOG_ERROR("Can not find free DWT Comparator");
1741                 return ERROR_FAIL;
1742         }
1743         comparator->used = true;
1744         watchpoint->set = dwt_num + 1;
1745
1746         comparator->comp = watchpoint->address;
1747         target_write_u32(target, comparator->dwt_comparator_address + 0,
1748                 comparator->comp);
1749
1750         if ((cortex_m->dwt_devarch & 0x1FFFFF) != DWT_DEVARCH_ARMV8M) {
1751                 uint32_t mask = 0, temp;
1752
1753                 /* watchpoint params were validated earlier */
1754                 temp = watchpoint->length;
1755                 while (temp) {
1756                         temp >>= 1;
1757                         mask++;
1758                 }
1759                 mask--;
1760
1761                 comparator->mask = mask;
1762                 target_write_u32(target, comparator->dwt_comparator_address + 4,
1763                         comparator->mask);
1764
1765                 switch (watchpoint->rw) {
1766                 case WPT_READ:
1767                         comparator->function = 5;
1768                         break;
1769                 case WPT_WRITE:
1770                         comparator->function = 6;
1771                         break;
1772                 case WPT_ACCESS:
1773                         comparator->function = 7;
1774                         break;
1775                 }
1776         } else {
1777                 uint32_t data_size = watchpoint->length >> 1;
1778                 comparator->mask = (watchpoint->length >> 1) | 1;
1779
1780                 switch (watchpoint->rw) {
1781                 case WPT_ACCESS:
1782                         comparator->function = 4;
1783                         break;
1784                 case WPT_WRITE:
1785                         comparator->function = 5;
1786                         break;
1787                 case WPT_READ:
1788                         comparator->function = 6;
1789                         break;
1790                 }
1791                 comparator->function = comparator->function | (1 << 4) |
1792                                 (data_size << 10);
1793         }
1794
1795         target_write_u32(target, comparator->dwt_comparator_address + 8,
1796                 comparator->function);
1797
1798         LOG_DEBUG("Watchpoint (ID %d) DWT%d 0x%08x 0x%x 0x%05x",
1799                 watchpoint->unique_id, dwt_num,
1800                 (unsigned) comparator->comp,
1801                 (unsigned) comparator->mask,
1802                 (unsigned) comparator->function);
1803         return ERROR_OK;
1804 }
1805
1806 static int cortex_m_unset_watchpoint(struct target *target, struct watchpoint *watchpoint)
1807 {
1808         struct cortex_m_common *cortex_m = target_to_cm(target);
1809         struct cortex_m_dwt_comparator *comparator;
1810
1811         if (watchpoint->set <= 0) {
1812                 LOG_WARNING("watchpoint (wpid: %d) not set",
1813                         watchpoint->unique_id);
1814                 return ERROR_OK;
1815         }
1816
1817         unsigned int dwt_num = watchpoint->set - 1;
1818
1819         LOG_DEBUG("Watchpoint (ID %d) DWT%d address: 0x%08x clear",
1820                 watchpoint->unique_id, dwt_num,
1821                 (unsigned) watchpoint->address);
1822
1823         if (dwt_num >= cortex_m->dwt_num_comp) {
1824                 LOG_DEBUG("Invalid DWT Comparator number in watchpoint");
1825                 return ERROR_OK;
1826         }
1827
1828         comparator = cortex_m->dwt_comparator_list + dwt_num;
1829         comparator->used = false;
1830         comparator->function = 0;
1831         target_write_u32(target, comparator->dwt_comparator_address + 8,
1832                 comparator->function);
1833
1834         watchpoint->set = false;
1835
1836         return ERROR_OK;
1837 }
1838
1839 int cortex_m_add_watchpoint(struct target *target, struct watchpoint *watchpoint)
1840 {
1841         struct cortex_m_common *cortex_m = target_to_cm(target);
1842
1843         if (cortex_m->dwt_comp_available < 1) {
1844                 LOG_DEBUG("no comparators?");
1845                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1846         }
1847
1848         /* hardware doesn't support data value masking */
1849         if (watchpoint->mask != ~(uint32_t)0) {
1850                 LOG_DEBUG("watchpoint value masks not supported");
1851                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1852         }
1853
1854         /* hardware allows address masks of up to 32K */
1855         unsigned mask;
1856
1857         for (mask = 0; mask < 16; mask++) {
1858                 if ((1u << mask) == watchpoint->length)
1859                         break;
1860         }
1861         if (mask == 16) {
1862                 LOG_DEBUG("unsupported watchpoint length");
1863                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1864         }
1865         if (watchpoint->address & ((1 << mask) - 1)) {
1866                 LOG_DEBUG("watchpoint address is unaligned");
1867                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1868         }
1869
1870         /* Caller doesn't seem to be able to describe watching for data
1871          * values of zero; that flags "no value".
1872          *
1873          * REVISIT This DWT may well be able to watch for specific data
1874          * values.  Requires comparator #1 to set DATAVMATCH and match
1875          * the data, and another comparator (DATAVADDR0) matching addr.
1876          */
1877         if (watchpoint->value) {
1878                 LOG_DEBUG("data value watchpoint not YET supported");
1879                 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1880         }
1881
1882         cortex_m->dwt_comp_available--;
1883         LOG_DEBUG("dwt_comp_available: %d", cortex_m->dwt_comp_available);
1884
1885         return ERROR_OK;
1886 }
1887
1888 int cortex_m_remove_watchpoint(struct target *target, struct watchpoint *watchpoint)
1889 {
1890         struct cortex_m_common *cortex_m = target_to_cm(target);
1891
1892         /* REVISIT why check? DWT can be updated with core running ... */
1893         if (target->state != TARGET_HALTED) {
1894                 LOG_WARNING("target not halted");
1895                 return ERROR_TARGET_NOT_HALTED;
1896         }
1897
1898         if (watchpoint->set)
1899                 cortex_m_unset_watchpoint(target, watchpoint);
1900
1901         cortex_m->dwt_comp_available++;
1902         LOG_DEBUG("dwt_comp_available: %d", cortex_m->dwt_comp_available);
1903
1904         return ERROR_OK;
1905 }
1906
1907 int cortex_m_hit_watchpoint(struct target *target, struct watchpoint **hit_watchpoint)
1908 {
1909         if (target->debug_reason != DBG_REASON_WATCHPOINT)
1910                 return ERROR_FAIL;
1911
1912         struct cortex_m_common *cortex_m = target_to_cm(target);
1913
1914         for (struct watchpoint *wp = target->watchpoints; wp; wp = wp->next) {
1915                 if (!wp->set)
1916                         continue;
1917
1918                 unsigned int dwt_num = wp->set - 1;
1919                 struct cortex_m_dwt_comparator *comparator = cortex_m->dwt_comparator_list + dwt_num;
1920
1921                 uint32_t dwt_function;
1922                 int retval = target_read_u32(target, comparator->dwt_comparator_address + 8, &dwt_function);
1923                 if (retval != ERROR_OK)
1924                         return ERROR_FAIL;
1925
1926                 /* check the MATCHED bit */
1927                 if (dwt_function & BIT(24)) {
1928                         *hit_watchpoint = wp;
1929                         return ERROR_OK;
1930                 }
1931         }
1932
1933         return ERROR_FAIL;
1934 }
1935
1936 void cortex_m_enable_watchpoints(struct target *target)
1937 {
1938         struct watchpoint *watchpoint = target->watchpoints;
1939
1940         /* set any pending watchpoints */
1941         while (watchpoint) {
1942                 if (!watchpoint->set)
1943                         cortex_m_set_watchpoint(target, watchpoint);
1944                 watchpoint = watchpoint->next;
1945         }
1946 }
1947
1948 static int cortex_m_read_memory(struct target *target, target_addr_t address,
1949         uint32_t size, uint32_t count, uint8_t *buffer)
1950 {
1951         struct armv7m_common *armv7m = target_to_armv7m(target);
1952
1953         if (armv7m->arm.arch == ARM_ARCH_V6M) {
1954                 /* armv6m does not handle unaligned memory access */
1955                 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1956                         return ERROR_TARGET_UNALIGNED_ACCESS;
1957         }
1958
1959         return mem_ap_read_buf(armv7m->debug_ap, buffer, size, count, address);
1960 }
1961
1962 static int cortex_m_write_memory(struct target *target, target_addr_t address,
1963         uint32_t size, uint32_t count, const uint8_t *buffer)
1964 {
1965         struct armv7m_common *armv7m = target_to_armv7m(target);
1966
1967         if (armv7m->arm.arch == ARM_ARCH_V6M) {
1968                 /* armv6m does not handle unaligned memory access */
1969                 if (((size == 4) && (address & 0x3u)) || ((size == 2) && (address & 0x1u)))
1970                         return ERROR_TARGET_UNALIGNED_ACCESS;
1971         }
1972
1973         return mem_ap_write_buf(armv7m->debug_ap, buffer, size, count, address);
1974 }
1975
1976 static int cortex_m_init_target(struct command_context *cmd_ctx,
1977         struct target *target)
1978 {
1979         armv7m_build_reg_cache(target);
1980         arm_semihosting_init(target);
1981         return ERROR_OK;
1982 }
1983
1984 void cortex_m_deinit_target(struct target *target)
1985 {
1986         struct cortex_m_common *cortex_m = target_to_cm(target);
1987
1988         free(cortex_m->fp_comparator_list);
1989
1990         cortex_m_dwt_free(target);
1991         armv7m_free_reg_cache(target);
1992
1993         free(target->private_config);
1994         free(cortex_m);
1995 }
1996
1997 int cortex_m_profiling(struct target *target, uint32_t *samples,
1998                               uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
1999 {
2000         struct timeval timeout, now;
2001         struct armv7m_common *armv7m = target_to_armv7m(target);
2002         uint32_t reg_value;
2003         int retval;
2004
2005         retval = target_read_u32(target, DWT_PCSR, &reg_value);
2006         if (retval != ERROR_OK) {
2007                 LOG_ERROR("Error while reading PCSR");
2008                 return retval;
2009         }
2010         if (reg_value == 0) {
2011                 LOG_INFO("PCSR sampling not supported on this processor.");
2012                 return target_profiling_default(target, samples, max_num_samples, num_samples, seconds);
2013         }
2014
2015         gettimeofday(&timeout, NULL);
2016         timeval_add_time(&timeout, seconds, 0);
2017
2018         LOG_INFO("Starting Cortex-M profiling. Sampling DWT_PCSR as fast as we can...");
2019
2020         /* Make sure the target is running */
2021         target_poll(target);
2022         if (target->state == TARGET_HALTED)
2023                 retval = target_resume(target, 1, 0, 0, 0);
2024
2025         if (retval != ERROR_OK) {
2026                 LOG_ERROR("Error while resuming target");
2027                 return retval;
2028         }
2029
2030         uint32_t sample_count = 0;
2031
2032         for (;;) {
2033                 if (armv7m && armv7m->debug_ap) {
2034                         uint32_t read_count = max_num_samples - sample_count;
2035                         if (read_count > 1024)
2036                                 read_count = 1024;
2037
2038                         retval = mem_ap_read_buf_noincr(armv7m->debug_ap,
2039                                                 (void *)&samples[sample_count],
2040                                                 4, read_count, DWT_PCSR);
2041                         sample_count += read_count;
2042                 } else {
2043                         target_read_u32(target, DWT_PCSR, &samples[sample_count++]);
2044                 }
2045
2046                 if (retval != ERROR_OK) {
2047                         LOG_ERROR("Error while reading PCSR");
2048                         return retval;
2049                 }
2050
2051
2052                 gettimeofday(&now, NULL);
2053                 if (sample_count >= max_num_samples || timeval_compare(&now, &timeout) > 0) {
2054                         LOG_INFO("Profiling completed. %" PRIu32 " samples.", sample_count);
2055                         break;
2056                 }
2057         }
2058
2059         *num_samples = sample_count;
2060         return retval;
2061 }
2062
2063
2064 /* REVISIT cache valid/dirty bits are unmaintained.  We could set "valid"
2065  * on r/w if the core is not running, and clear on resume or reset ... or
2066  * at least, in a post_restore_context() method.
2067  */
2068
2069 struct dwt_reg_state {
2070         struct target *target;
2071         uint32_t addr;
2072         uint8_t value[4];               /* scratch/cache */
2073 };
2074
2075 static int cortex_m_dwt_get_reg(struct reg *reg)
2076 {
2077         struct dwt_reg_state *state = reg->arch_info;
2078
2079         uint32_t tmp;
2080         int retval = target_read_u32(state->target, state->addr, &tmp);
2081         if (retval != ERROR_OK)
2082                 return retval;
2083
2084         buf_set_u32(state->value, 0, 32, tmp);
2085         return ERROR_OK;
2086 }
2087
2088 static int cortex_m_dwt_set_reg(struct reg *reg, uint8_t *buf)
2089 {
2090         struct dwt_reg_state *state = reg->arch_info;
2091
2092         return target_write_u32(state->target, state->addr,
2093                         buf_get_u32(buf, 0, reg->size));
2094 }
2095
2096 struct dwt_reg {
2097         uint32_t addr;
2098         const char *name;
2099         unsigned size;
2100 };
2101
2102 static const struct dwt_reg dwt_base_regs[] = {
2103         { DWT_CTRL, "dwt_ctrl", 32, },
2104         /* NOTE that Erratum 532314 (fixed r2p0) affects CYCCNT:  it wrongly
2105          * increments while the core is asleep.
2106          */
2107         { DWT_CYCCNT, "dwt_cyccnt", 32, },
2108         /* plus some 8 bit counters, useful for profiling with TPIU */
2109 };
2110
2111 static const struct dwt_reg dwt_comp[] = {
2112 #define DWT_COMPARATOR(i) \
2113                 { DWT_COMP0 + 0x10 * (i), "dwt_" #i "_comp", 32, }, \
2114                 { DWT_MASK0 + 0x10 * (i), "dwt_" #i "_mask", 4, }, \
2115                 { DWT_FUNCTION0 + 0x10 * (i), "dwt_" #i "_function", 32, }
2116         DWT_COMPARATOR(0),
2117         DWT_COMPARATOR(1),
2118         DWT_COMPARATOR(2),
2119         DWT_COMPARATOR(3),
2120         DWT_COMPARATOR(4),
2121         DWT_COMPARATOR(5),
2122         DWT_COMPARATOR(6),
2123         DWT_COMPARATOR(7),
2124         DWT_COMPARATOR(8),
2125         DWT_COMPARATOR(9),
2126         DWT_COMPARATOR(10),
2127         DWT_COMPARATOR(11),
2128         DWT_COMPARATOR(12),
2129         DWT_COMPARATOR(13),
2130         DWT_COMPARATOR(14),
2131         DWT_COMPARATOR(15),
2132 #undef DWT_COMPARATOR
2133 };
2134
2135 static const struct reg_arch_type dwt_reg_type = {
2136         .get = cortex_m_dwt_get_reg,
2137         .set = cortex_m_dwt_set_reg,
2138 };
2139
2140 static void cortex_m_dwt_addreg(struct target *t, struct reg *r, const struct dwt_reg *d)
2141 {
2142         struct dwt_reg_state *state;
2143
2144         state = calloc(1, sizeof(*state));
2145         if (!state)
2146                 return;
2147         state->addr = d->addr;
2148         state->target = t;
2149
2150         r->name = d->name;
2151         r->size = d->size;
2152         r->value = state->value;
2153         r->arch_info = state;
2154         r->type = &dwt_reg_type;
2155 }
2156
2157 static void cortex_m_dwt_setup(struct cortex_m_common *cm, struct target *target)
2158 {
2159         uint32_t dwtcr;
2160         struct reg_cache *cache;
2161         struct cortex_m_dwt_comparator *comparator;
2162         int reg;
2163
2164         target_read_u32(target, DWT_CTRL, &dwtcr);
2165         LOG_DEBUG("DWT_CTRL: 0x%" PRIx32, dwtcr);
2166         if (!dwtcr) {
2167                 LOG_DEBUG("no DWT");
2168                 return;
2169         }
2170
2171         target_read_u32(target, DWT_DEVARCH, &cm->dwt_devarch);
2172         LOG_DEBUG("DWT_DEVARCH: 0x%" PRIx32, cm->dwt_devarch);
2173
2174         cm->dwt_num_comp = (dwtcr >> 28) & 0xF;
2175         cm->dwt_comp_available = cm->dwt_num_comp;
2176         cm->dwt_comparator_list = calloc(cm->dwt_num_comp,
2177                         sizeof(struct cortex_m_dwt_comparator));
2178         if (!cm->dwt_comparator_list) {
2179 fail0:
2180                 cm->dwt_num_comp = 0;
2181                 LOG_ERROR("out of mem");
2182                 return;
2183         }
2184
2185         cache = calloc(1, sizeof(*cache));
2186         if (!cache) {
2187 fail1:
2188                 free(cm->dwt_comparator_list);
2189                 goto fail0;
2190         }
2191         cache->name = "Cortex-M DWT registers";
2192         cache->num_regs = 2 + cm->dwt_num_comp * 3;
2193         cache->reg_list = calloc(cache->num_regs, sizeof(*cache->reg_list));
2194         if (!cache->reg_list) {
2195                 free(cache);
2196                 goto fail1;
2197         }
2198
2199         for (reg = 0; reg < 2; reg++)
2200                 cortex_m_dwt_addreg(target, cache->reg_list + reg,
2201                         dwt_base_regs + reg);
2202
2203         comparator = cm->dwt_comparator_list;
2204         for (unsigned int i = 0; i < cm->dwt_num_comp; i++, comparator++) {
2205                 int j;
2206
2207                 comparator->dwt_comparator_address = DWT_COMP0 + 0x10 * i;
2208                 for (j = 0; j < 3; j++, reg++)
2209                         cortex_m_dwt_addreg(target, cache->reg_list + reg,
2210                                 dwt_comp + 3 * i + j);
2211
2212                 /* make sure we clear any watchpoints enabled on the target */
2213                 target_write_u32(target, comparator->dwt_comparator_address + 8, 0);
2214         }
2215
2216         *register_get_last_cache_p(&target->reg_cache) = cache;
2217         cm->dwt_cache = cache;
2218
2219         LOG_DEBUG("DWT dwtcr 0x%" PRIx32 ", comp %d, watch%s",
2220                 dwtcr, cm->dwt_num_comp,
2221                 (dwtcr & (0xf << 24)) ? " only" : "/trigger");
2222
2223         /* REVISIT:  if num_comp > 1, check whether comparator #1 can
2224          * implement single-address data value watchpoints ... so we
2225          * won't need to check it later, when asked to set one up.
2226          */
2227 }
2228
2229 static void cortex_m_dwt_free(struct target *target)
2230 {
2231         struct cortex_m_common *cm = target_to_cm(target);
2232         struct reg_cache *cache = cm->dwt_cache;
2233
2234         free(cm->dwt_comparator_list);
2235         cm->dwt_comparator_list = NULL;
2236         cm->dwt_num_comp = 0;
2237
2238         if (cache) {
2239                 register_unlink_cache(&target->reg_cache, cache);
2240
2241                 if (cache->reg_list) {
2242                         for (size_t i = 0; i < cache->num_regs; i++)
2243                                 free(cache->reg_list[i].arch_info);
2244                         free(cache->reg_list);
2245                 }
2246                 free(cache);
2247         }
2248         cm->dwt_cache = NULL;
2249 }
2250
2251 #define MVFR0 0xe000ef40
2252 #define MVFR1 0xe000ef44
2253
2254 #define MVFR0_DEFAULT_M4 0x10110021
2255 #define MVFR1_DEFAULT_M4 0x11000011
2256
2257 #define MVFR0_DEFAULT_M7_SP 0x10110021
2258 #define MVFR0_DEFAULT_M7_DP 0x10110221
2259 #define MVFR1_DEFAULT_M7_SP 0x11000011
2260 #define MVFR1_DEFAULT_M7_DP 0x12000011
2261
2262 static int cortex_m_find_mem_ap(struct adiv5_dap *swjdp,
2263                 struct adiv5_ap **debug_ap)
2264 {
2265         if (dap_find_ap(swjdp, AP_TYPE_AHB3_AP, debug_ap) == ERROR_OK)
2266                 return ERROR_OK;
2267
2268         return dap_find_ap(swjdp, AP_TYPE_AHB5_AP, debug_ap);
2269 }
2270
2271 int cortex_m_examine(struct target *target)
2272 {
2273         int retval;
2274         uint32_t cpuid, fpcr, mvfr0, mvfr1;
2275         struct cortex_m_common *cortex_m = target_to_cm(target);
2276         struct adiv5_dap *swjdp = cortex_m->armv7m.arm.dap;
2277         struct armv7m_common *armv7m = target_to_armv7m(target);
2278
2279         /* hla_target shares the examine handler but does not support
2280          * all its calls */
2281         if (!armv7m->is_hla_target) {
2282                 if (cortex_m->apsel == DP_APSEL_INVALID) {
2283                         /* Search for the MEM-AP */
2284                         retval = cortex_m_find_mem_ap(swjdp, &armv7m->debug_ap);
2285                         if (retval != ERROR_OK) {
2286                                 LOG_ERROR("Could not find MEM-AP to control the core");
2287                                 return retval;
2288                         }
2289                 } else {
2290                         armv7m->debug_ap = dap_ap(swjdp, cortex_m->apsel);
2291                 }
2292
2293                 armv7m->debug_ap->memaccess_tck = 8;
2294
2295                 retval = mem_ap_init(armv7m->debug_ap);
2296                 if (retval != ERROR_OK)
2297                         return retval;
2298         }
2299
2300         if (!target_was_examined(target)) {
2301                 target_set_examined(target);
2302
2303                 /* Read from Device Identification Registers */
2304                 retval = target_read_u32(target, CPUID, &cpuid);
2305                 if (retval != ERROR_OK)
2306                         return retval;
2307
2308                 /* Get ARCH and CPU types */
2309                 const enum cortex_m_partno core_partno = (cpuid & ARM_CPUID_PARTNO_MASK) >> ARM_CPUID_PARTNO_POS;
2310
2311                 for (unsigned int n = 0; n < ARRAY_SIZE(cortex_m_parts); n++) {
2312                         if (core_partno == cortex_m_parts[n].partno) {
2313                                 cortex_m->core_info = &cortex_m_parts[n];
2314                                 break;
2315                         }
2316                 }
2317
2318                 if (!cortex_m->core_info) {
2319                         LOG_ERROR("Cortex-M PARTNO 0x%x is unrecognized", core_partno);
2320                         return ERROR_FAIL;
2321                 }
2322
2323                 armv7m->arm.arch = cortex_m->core_info->arch;
2324
2325                 LOG_INFO("%s: %s r%" PRId8 "p%" PRId8 " processor detected",
2326                                 target_name(target),
2327                                 cortex_m->core_info->name,
2328                                 (uint8_t)((cpuid >> 20) & 0xf),
2329                                 (uint8_t)((cpuid >> 0) & 0xf));
2330
2331                 cortex_m->maskints_erratum = false;
2332                 if (core_partno == CORTEX_M7_PARTNO) {
2333                         uint8_t rev, patch;
2334                         rev = (cpuid >> 20) & 0xf;
2335                         patch = (cpuid >> 0) & 0xf;
2336                         if ((rev == 0) && (patch < 2)) {
2337                                 LOG_WARNING("Silicon bug: single stepping may enter pending exception handler!");
2338                                 cortex_m->maskints_erratum = true;
2339                         }
2340                 }
2341                 LOG_DEBUG("cpuid: 0x%8.8" PRIx32 "", cpuid);
2342
2343                 if (cortex_m->core_info->flags & CORTEX_M_F_HAS_FPV4) {
2344                         target_read_u32(target, MVFR0, &mvfr0);
2345                         target_read_u32(target, MVFR1, &mvfr1);
2346
2347                         /* test for floating point feature on Cortex-M4 */
2348                         if ((mvfr0 == MVFR0_DEFAULT_M4) && (mvfr1 == MVFR1_DEFAULT_M4)) {
2349                                 LOG_DEBUG("%s floating point feature FPv4_SP found", cortex_m->core_info->name);
2350                                 armv7m->fp_feature = FPV4_SP;
2351                         }
2352                 } else if (cortex_m->core_info->flags & CORTEX_M_F_HAS_FPV5) {
2353                         target_read_u32(target, MVFR0, &mvfr0);
2354                         target_read_u32(target, MVFR1, &mvfr1);
2355
2356                         /* test for floating point features on Cortex-M7 */
2357                         if ((mvfr0 == MVFR0_DEFAULT_M7_SP) && (mvfr1 == MVFR1_DEFAULT_M7_SP)) {
2358                                 LOG_DEBUG("%s floating point feature FPv5_SP found", cortex_m->core_info->name);
2359                                 armv7m->fp_feature = FPV5_SP;
2360                         } else if ((mvfr0 == MVFR0_DEFAULT_M7_DP) && (mvfr1 == MVFR1_DEFAULT_M7_DP)) {
2361                                 LOG_DEBUG("%s floating point feature FPv5_DP found", cortex_m->core_info->name);
2362                                 armv7m->fp_feature = FPV5_DP;
2363                         }
2364                 }
2365
2366                 /* VECTRESET is supported only on ARMv7-M cores */
2367                 cortex_m->vectreset_supported = armv7m->arm.arch == ARM_ARCH_V7M;
2368
2369                 /* Check for FPU, otherwise mark FPU register as non-existent */
2370                 if (armv7m->fp_feature == FP_NONE)
2371                         for (size_t idx = ARMV7M_FPU_FIRST_REG; idx <= ARMV7M_FPU_LAST_REG; idx++)
2372                                 armv7m->arm.core_cache->reg_list[idx].exist = false;
2373
2374                 if (armv7m->arm.arch != ARM_ARCH_V8M)
2375                         for (size_t idx = ARMV8M_FIRST_REG; idx <= ARMV8M_LAST_REG; idx++)
2376                                 armv7m->arm.core_cache->reg_list[idx].exist = false;
2377
2378                 if (!armv7m->is_hla_target) {
2379                         if (cortex_m->core_info->flags & CORTEX_M_F_TAR_AUTOINCR_BLOCK_4K)
2380                                 /* Cortex-M3/M4 have 4096 bytes autoincrement range,
2381                                  * s. ARM IHI 0031C: MEM-AP 7.2.2 */
2382                                 armv7m->debug_ap->tar_autoincr_block = (1 << 12);
2383                 }
2384
2385                 retval = target_read_u32(target, DCB_DHCSR, &cortex_m->dcb_dhcsr);
2386                 if (retval != ERROR_OK)
2387                         return retval;
2388                 cortex_m_cumulate_dhcsr_sticky(cortex_m, cortex_m->dcb_dhcsr);
2389
2390                 if (!(cortex_m->dcb_dhcsr & C_DEBUGEN)) {
2391                         /* Enable debug requests */
2392                         uint32_t dhcsr = (cortex_m->dcb_dhcsr | C_DEBUGEN) & ~(C_HALT | C_STEP | C_MASKINTS);
2393
2394                         retval = target_write_u32(target, DCB_DHCSR, DBGKEY | (dhcsr & 0x0000FFFFUL));
2395                         if (retval != ERROR_OK)
2396                                 return retval;
2397                         cortex_m->dcb_dhcsr = dhcsr;
2398                 }
2399
2400                 /* Configure trace modules */
2401                 retval = target_write_u32(target, DCB_DEMCR, TRCENA | armv7m->demcr);
2402                 if (retval != ERROR_OK)
2403                         return retval;
2404
2405                 if (armv7m->trace_config.itm_deferred_config)
2406                         armv7m_trace_itm_config(target);
2407
2408                 /* NOTE: FPB and DWT are both optional. */
2409
2410                 /* Setup FPB */
2411                 target_read_u32(target, FP_CTRL, &fpcr);
2412                 /* bits [14:12] and [7:4] */
2413                 cortex_m->fp_num_code = ((fpcr >> 8) & 0x70) | ((fpcr >> 4) & 0xF);
2414                 cortex_m->fp_num_lit = (fpcr >> 8) & 0xF;
2415                 /* Detect flash patch revision, see RM DDI 0403E.b page C1-817.
2416                    Revision is zero base, fp_rev == 1 means Rev.2 ! */
2417                 cortex_m->fp_rev = (fpcr >> 28) & 0xf;
2418                 free(cortex_m->fp_comparator_list);
2419                 cortex_m->fp_comparator_list = calloc(
2420                                 cortex_m->fp_num_code + cortex_m->fp_num_lit,
2421                                 sizeof(struct cortex_m_fp_comparator));
2422                 cortex_m->fpb_enabled = fpcr & 1;
2423                 for (unsigned int i = 0; i < cortex_m->fp_num_code + cortex_m->fp_num_lit; i++) {
2424                         cortex_m->fp_comparator_list[i].type =
2425                                 (i < cortex_m->fp_num_code) ? FPCR_CODE : FPCR_LITERAL;
2426                         cortex_m->fp_comparator_list[i].fpcr_address = FP_COMP0 + 4 * i;
2427
2428                         /* make sure we clear any breakpoints enabled on the target */
2429                         target_write_u32(target, cortex_m->fp_comparator_list[i].fpcr_address, 0);
2430                 }
2431                 LOG_DEBUG("FPB fpcr 0x%" PRIx32 ", numcode %i, numlit %i",
2432                         fpcr,
2433                         cortex_m->fp_num_code,
2434                         cortex_m->fp_num_lit);
2435
2436                 /* Setup DWT */
2437                 cortex_m_dwt_free(target);
2438                 cortex_m_dwt_setup(cortex_m, target);
2439
2440                 /* These hardware breakpoints only work for code in flash! */
2441                 LOG_INFO("%s: target has %d breakpoints, %d watchpoints",
2442                         target_name(target),
2443                         cortex_m->fp_num_code,
2444                         cortex_m->dwt_num_comp);
2445         }
2446
2447         return ERROR_OK;
2448 }
2449
2450 static int cortex_m_dcc_read(struct target *target, uint8_t *value, uint8_t *ctrl)
2451 {
2452         struct armv7m_common *armv7m = target_to_armv7m(target);
2453         uint16_t dcrdr;
2454         uint8_t buf[2];
2455         int retval;
2456
2457         retval = mem_ap_read_buf_noincr(armv7m->debug_ap, buf, 2, 1, DCB_DCRDR);
2458         if (retval != ERROR_OK)
2459                 return retval;
2460
2461         dcrdr = target_buffer_get_u16(target, buf);
2462         *ctrl = (uint8_t)dcrdr;
2463         *value = (uint8_t)(dcrdr >> 8);
2464
2465         LOG_DEBUG("data 0x%x ctrl 0x%x", *value, *ctrl);
2466
2467         /* write ack back to software dcc register
2468          * signify we have read data */
2469         if (dcrdr & (1 << 0)) {
2470                 target_buffer_set_u16(target, buf, 0);
2471                 retval = mem_ap_write_buf_noincr(armv7m->debug_ap, buf, 2, 1, DCB_DCRDR);
2472                 if (retval != ERROR_OK)
2473                         return retval;
2474         }
2475
2476         return ERROR_OK;
2477 }
2478
2479 static int cortex_m_target_request_data(struct target *target,
2480         uint32_t size, uint8_t *buffer)
2481 {
2482         uint8_t data;
2483         uint8_t ctrl;
2484         uint32_t i;
2485
2486         for (i = 0; i < (size * 4); i++) {
2487                 int retval = cortex_m_dcc_read(target, &data, &ctrl);
2488                 if (retval != ERROR_OK)
2489                         return retval;
2490                 buffer[i] = data;
2491         }
2492
2493         return ERROR_OK;
2494 }
2495
2496 static int cortex_m_handle_target_request(void *priv)
2497 {
2498         struct target *target = priv;
2499         if (!target_was_examined(target))
2500                 return ERROR_OK;
2501
2502         if (!target->dbg_msg_enabled)
2503                 return ERROR_OK;
2504
2505         if (target->state == TARGET_RUNNING) {
2506                 uint8_t data;
2507                 uint8_t ctrl;
2508                 int retval;
2509
2510                 retval = cortex_m_dcc_read(target, &data, &ctrl);
2511                 if (retval != ERROR_OK)
2512                         return retval;
2513
2514                 /* check if we have data */
2515                 if (ctrl & (1 << 0)) {
2516                         uint32_t request;
2517
2518                         /* we assume target is quick enough */
2519                         request = data;
2520                         for (int i = 1; i <= 3; i++) {
2521                                 retval = cortex_m_dcc_read(target, &data, &ctrl);
2522                                 if (retval != ERROR_OK)
2523                                         return retval;
2524                                 request |= ((uint32_t)data << (i * 8));
2525                         }
2526                         target_request(target, request);
2527                 }
2528         }
2529
2530         return ERROR_OK;
2531 }
2532
2533 static int cortex_m_init_arch_info(struct target *target,
2534         struct cortex_m_common *cortex_m, struct adiv5_dap *dap)
2535 {
2536         struct armv7m_common *armv7m = &cortex_m->armv7m;
2537
2538         armv7m_init_arch_info(target, armv7m);
2539
2540         /* default reset mode is to use srst if fitted
2541          * if not it will use CORTEX_M3_RESET_VECTRESET */
2542         cortex_m->soft_reset_config = CORTEX_M_RESET_VECTRESET;
2543
2544         armv7m->arm.dap = dap;
2545
2546         /* register arch-specific functions */
2547         armv7m->examine_debug_reason = cortex_m_examine_debug_reason;
2548
2549         armv7m->post_debug_entry = NULL;
2550
2551         armv7m->pre_restore_context = NULL;
2552
2553         armv7m->load_core_reg_u32 = cortex_m_load_core_reg_u32;
2554         armv7m->store_core_reg_u32 = cortex_m_store_core_reg_u32;
2555
2556         target_register_timer_callback(cortex_m_handle_target_request, 1,
2557                 TARGET_TIMER_TYPE_PERIODIC, target);
2558
2559         return ERROR_OK;
2560 }
2561
2562 static int cortex_m_target_create(struct target *target, Jim_Interp *interp)
2563 {
2564         struct adiv5_private_config *pc;
2565
2566         pc = (struct adiv5_private_config *)target->private_config;
2567         if (adiv5_verify_config(pc) != ERROR_OK)
2568                 return ERROR_FAIL;
2569
2570         struct cortex_m_common *cortex_m = calloc(1, sizeof(struct cortex_m_common));
2571         if (!cortex_m) {
2572                 LOG_ERROR("No memory creating target");
2573                 return ERROR_FAIL;
2574         }
2575
2576         cortex_m->common_magic = CORTEX_M_COMMON_MAGIC;
2577         cortex_m->apsel = pc->ap_num;
2578
2579         cortex_m_init_arch_info(target, cortex_m, pc->dap);
2580
2581         return ERROR_OK;
2582 }
2583
2584 /*--------------------------------------------------------------------------*/
2585
2586 static int cortex_m_verify_pointer(struct command_invocation *cmd,
2587         struct cortex_m_common *cm)
2588 {
2589         if (!is_cortex_m_with_dap_access(cm)) {
2590                 command_print(cmd, "target is not a Cortex-M");
2591                 return ERROR_TARGET_INVALID;
2592         }
2593         return ERROR_OK;
2594 }
2595
2596 /*
2597  * Only stuff below this line should need to verify that its target
2598  * is a Cortex-M3.  Everything else should have indirected through the
2599  * cortexm3_target structure, which is only used with CM3 targets.
2600  */
2601
2602 COMMAND_HANDLER(handle_cortex_m_vector_catch_command)
2603 {
2604         struct target *target = get_current_target(CMD_CTX);
2605         struct cortex_m_common *cortex_m = target_to_cm(target);
2606         struct armv7m_common *armv7m = &cortex_m->armv7m;
2607         uint32_t demcr = 0;
2608         int retval;
2609
2610         static const struct {
2611                 char name[10];
2612                 unsigned mask;
2613         } vec_ids[] = {
2614                 { "hard_err",   VC_HARDERR, },
2615                 { "int_err",    VC_INTERR, },
2616                 { "bus_err",    VC_BUSERR, },
2617                 { "state_err",  VC_STATERR, },
2618                 { "chk_err",    VC_CHKERR, },
2619                 { "nocp_err",   VC_NOCPERR, },
2620                 { "mm_err",     VC_MMERR, },
2621                 { "reset",      VC_CORERESET, },
2622         };
2623
2624         retval = cortex_m_verify_pointer(CMD, cortex_m);
2625         if (retval != ERROR_OK)
2626                 return retval;
2627
2628         if (!target_was_examined(target)) {
2629                 LOG_ERROR("Target not examined yet");
2630                 return ERROR_FAIL;
2631         }
2632
2633         retval = mem_ap_read_atomic_u32(armv7m->debug_ap, DCB_DEMCR, &demcr);
2634         if (retval != ERROR_OK)
2635                 return retval;
2636
2637         if (CMD_ARGC > 0) {
2638                 unsigned catch = 0;
2639
2640                 if (CMD_ARGC == 1) {
2641                         if (strcmp(CMD_ARGV[0], "all") == 0) {
2642                                 catch = VC_HARDERR | VC_INTERR | VC_BUSERR
2643                                         | VC_STATERR | VC_CHKERR | VC_NOCPERR
2644                                         | VC_MMERR | VC_CORERESET;
2645                                 goto write;
2646                         } else if (strcmp(CMD_ARGV[0], "none") == 0)
2647                                 goto write;
2648                 }
2649                 while (CMD_ARGC-- > 0) {
2650                         unsigned i;
2651                         for (i = 0; i < ARRAY_SIZE(vec_ids); i++) {
2652                                 if (strcmp(CMD_ARGV[CMD_ARGC], vec_ids[i].name) != 0)
2653                                         continue;
2654                                 catch |= vec_ids[i].mask;
2655                                 break;
2656                         }
2657                         if (i == ARRAY_SIZE(vec_ids)) {
2658                                 LOG_ERROR("No CM3 vector '%s'", CMD_ARGV[CMD_ARGC]);
2659                                 return ERROR_COMMAND_SYNTAX_ERROR;
2660                         }
2661                 }
2662 write:
2663                 /* For now, armv7m->demcr only stores vector catch flags. */
2664                 armv7m->demcr = catch;
2665
2666                 demcr &= ~0xffff;
2667                 demcr |= catch;
2668
2669                 /* write, but don't assume it stuck (why not??) */
2670                 retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DEMCR, demcr);
2671                 if (retval != ERROR_OK)
2672                         return retval;
2673                 retval = mem_ap_read_atomic_u32(armv7m->debug_ap, DCB_DEMCR, &demcr);
2674                 if (retval != ERROR_OK)
2675                         return retval;
2676
2677                 /* FIXME be sure to clear DEMCR on clean server shutdown.
2678                  * Otherwise the vector catch hardware could fire when there's
2679                  * no debugger hooked up, causing much confusion...
2680                  */
2681         }
2682
2683         for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) {
2684                 command_print(CMD, "%9s: %s", vec_ids[i].name,
2685                         (demcr & vec_ids[i].mask) ? "catch" : "ignore");
2686         }
2687
2688         return ERROR_OK;
2689 }
2690
2691 COMMAND_HANDLER(handle_cortex_m_mask_interrupts_command)
2692 {
2693         struct target *target = get_current_target(CMD_CTX);
2694         struct cortex_m_common *cortex_m = target_to_cm(target);
2695         int retval;
2696
2697         static const struct jim_nvp nvp_maskisr_modes[] = {
2698                 { .name = "auto", .value = CORTEX_M_ISRMASK_AUTO },
2699                 { .name = "off", .value = CORTEX_M_ISRMASK_OFF },
2700                 { .name = "on", .value = CORTEX_M_ISRMASK_ON },
2701                 { .name = "steponly", .value = CORTEX_M_ISRMASK_STEPONLY },
2702                 { .name = NULL, .value = -1 },
2703         };
2704         const struct jim_nvp *n;
2705
2706
2707         retval = cortex_m_verify_pointer(CMD, cortex_m);
2708         if (retval != ERROR_OK)
2709                 return retval;
2710
2711         if (target->state != TARGET_HALTED) {
2712                 command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
2713                 return ERROR_OK;
2714         }
2715
2716         if (CMD_ARGC > 0) {
2717                 n = jim_nvp_name2value_simple(nvp_maskisr_modes, CMD_ARGV[0]);
2718                 if (!n->name)
2719                         return ERROR_COMMAND_SYNTAX_ERROR;
2720                 cortex_m->isrmasking_mode = n->value;
2721                 cortex_m_set_maskints_for_halt(target);
2722         }
2723
2724         n = jim_nvp_value2name_simple(nvp_maskisr_modes, cortex_m->isrmasking_mode);
2725         command_print(CMD, "cortex_m interrupt mask %s", n->name);
2726
2727         return ERROR_OK;
2728 }
2729
2730 COMMAND_HANDLER(handle_cortex_m_reset_config_command)
2731 {
2732         struct target *target = get_current_target(CMD_CTX);
2733         struct cortex_m_common *cortex_m = target_to_cm(target);
2734         int retval;
2735         char *reset_config;
2736
2737         retval = cortex_m_verify_pointer(CMD, cortex_m);
2738         if (retval != ERROR_OK)
2739                 return retval;
2740
2741         if (CMD_ARGC > 0) {
2742                 if (strcmp(*CMD_ARGV, "sysresetreq") == 0)
2743                         cortex_m->soft_reset_config = CORTEX_M_RESET_SYSRESETREQ;
2744
2745                 else if (strcmp(*CMD_ARGV, "vectreset") == 0) {
2746                         if (target_was_examined(target)
2747                                         && !cortex_m->vectreset_supported)
2748                                 LOG_WARNING("VECTRESET is not supported on your Cortex-M core!");
2749                         else
2750                                 cortex_m->soft_reset_config = CORTEX_M_RESET_VECTRESET;
2751
2752                 } else
2753                         return ERROR_COMMAND_SYNTAX_ERROR;
2754         }
2755
2756         switch (cortex_m->soft_reset_config) {
2757                 case CORTEX_M_RESET_SYSRESETREQ:
2758                         reset_config = "sysresetreq";
2759                         break;
2760
2761                 case CORTEX_M_RESET_VECTRESET:
2762                         reset_config = "vectreset";
2763                         break;
2764
2765                 default:
2766                         reset_config = "unknown";
2767                         break;
2768         }
2769
2770         command_print(CMD, "cortex_m reset_config %s", reset_config);
2771
2772         return ERROR_OK;
2773 }
2774
2775 static const struct command_registration cortex_m_exec_command_handlers[] = {
2776         {
2777                 .name = "maskisr",
2778                 .handler = handle_cortex_m_mask_interrupts_command,
2779                 .mode = COMMAND_EXEC,
2780                 .help = "mask cortex_m interrupts",
2781                 .usage = "['auto'|'on'|'off'|'steponly']",
2782         },
2783         {
2784                 .name = "vector_catch",
2785                 .handler = handle_cortex_m_vector_catch_command,
2786                 .mode = COMMAND_EXEC,
2787                 .help = "configure hardware vectors to trigger debug entry",
2788                 .usage = "['all'|'none'|('bus_err'|'chk_err'|...)*]",
2789         },
2790         {
2791                 .name = "reset_config",
2792                 .handler = handle_cortex_m_reset_config_command,
2793                 .mode = COMMAND_ANY,
2794                 .help = "configure software reset handling",
2795                 .usage = "['sysresetreq'|'vectreset']",
2796         },
2797         COMMAND_REGISTRATION_DONE
2798 };
2799 static const struct command_registration cortex_m_command_handlers[] = {
2800         {
2801                 .chain = armv7m_command_handlers,
2802         },
2803         {
2804                 .chain = armv7m_trace_command_handlers,
2805         },
2806         /* START_DEPRECATED_TPIU */
2807         {
2808                 .chain = arm_tpiu_deprecated_command_handlers,
2809         },
2810         /* END_DEPRECATED_TPIU */
2811         {
2812                 .name = "cortex_m",
2813                 .mode = COMMAND_EXEC,
2814                 .help = "Cortex-M command group",
2815                 .usage = "",
2816                 .chain = cortex_m_exec_command_handlers,
2817         },
2818         {
2819                 .chain = rtt_target_command_handlers,
2820         },
2821         COMMAND_REGISTRATION_DONE
2822 };
2823
2824 struct target_type cortexm_target = {
2825         .name = "cortex_m",
2826
2827         .poll = cortex_m_poll,
2828         .arch_state = armv7m_arch_state,
2829
2830         .target_request_data = cortex_m_target_request_data,
2831
2832         .halt = cortex_m_halt,
2833         .resume = cortex_m_resume,
2834         .step = cortex_m_step,
2835
2836         .assert_reset = cortex_m_assert_reset,
2837         .deassert_reset = cortex_m_deassert_reset,
2838         .soft_reset_halt = cortex_m_soft_reset_halt,
2839
2840         .get_gdb_arch = arm_get_gdb_arch,
2841         .get_gdb_reg_list = armv7m_get_gdb_reg_list,
2842
2843         .read_memory = cortex_m_read_memory,
2844         .write_memory = cortex_m_write_memory,
2845         .checksum_memory = armv7m_checksum_memory,
2846         .blank_check_memory = armv7m_blank_check_memory,
2847
2848         .run_algorithm = armv7m_run_algorithm,
2849         .start_algorithm = armv7m_start_algorithm,
2850         .wait_algorithm = armv7m_wait_algorithm,
2851
2852         .add_breakpoint = cortex_m_add_breakpoint,
2853         .remove_breakpoint = cortex_m_remove_breakpoint,
2854         .add_watchpoint = cortex_m_add_watchpoint,
2855         .remove_watchpoint = cortex_m_remove_watchpoint,
2856         .hit_watchpoint = cortex_m_hit_watchpoint,
2857
2858         .commands = cortex_m_command_handlers,
2859         .target_create = cortex_m_target_create,
2860         .target_jim_configure = adiv5_jim_configure,
2861         .init_target = cortex_m_init_target,
2862         .examine = cortex_m_examine,
2863         .deinit_target = cortex_m_deinit_target,
2864
2865         .profiling = cortex_m_profiling,
2866 };