hw/intc/armv7m_nvic.c

   1 /*
   2  * ARM Nested Vectored Interrupt Controller
   3  *
   4  * Copyright (c) 2006-2007 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licensed under the GPL.
   8  *
   9  * The ARMv7M System controller is fairly tightly tied in with the
  10  * NVIC.  Much of that is also implemented here.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qapi/error.h"
  15 #include "qemu-common.h"
  16 #include "cpu.h"
  17 #include "hw/sysbus.h"
  18 #include "qemu/timer.h"
  19 #include "hw/arm/arm.h"
  20 #include "hw/intc/armv7m_nvic.h"
  21 #include "target/arm/cpu.h"
  22 #include "exec/exec-all.h"
  23 #include "qemu/log.h"
  24 #include "trace.h"
  25
  26 /* IRQ number counting:
  27  *
  28  * the num-irq property counts the number of external IRQ lines
  29  *
  30  * NVICState::num_irq counts the total number of exceptions
  31  * (external IRQs, the 15 internal exceptions including reset,
  32  * and one for the unused exception number 0).
  33  *
  34  * NVIC_MAX_IRQ is the highest permitted number of external IRQ lines.
  35  *
  36  * NVIC_MAX_VECTORS is the highest permitted number of exceptions.
  37  *
  38  * Iterating through all exceptions should typically be done with
  39  * for (i = 1; i < s->num_irq; i++) to avoid the unused slot 0.
  40  *
  41  * The external qemu_irq lines are the NVIC's external IRQ lines,
  42  * so line 0 is exception 16.
  43  *
  44  * In the terminology of the architecture manual, "interrupts" are
  45  * a subcategory of exception referring to the external interrupts
  46  * (which are exception numbers NVIC_FIRST_IRQ and upward).
  47  * For historical reasons QEMU tends to use "interrupt" and
  48  * "exception" more or less interchangeably.
  49  */
  50 #define NVIC_FIRST_IRQ NVIC_INTERNAL_VECTORS
  51 #define NVIC_MAX_IRQ (NVIC_MAX_VECTORS - NVIC_FIRST_IRQ)
  52
  53 /* Effective running priority of the CPU when no exception is active
  54  * (higher than the highest possible priority value)
  55  */
  56 #define NVIC_NOEXC_PRIO 0x100
  57
  58 static const uint8_t nvic_id[] = {
  59     0x00, 0xb0, 0x1b, 0x00, 0x0d, 0xe0, 0x05, 0xb1
  60 };
  61
  62 static int nvic_pending_prio(NVICState *s)
  63 {
  64     /* return the group priority of the current pending interrupt,
  65      * or NVIC_NOEXC_PRIO if no interrupt is pending
  66      */
  67     return s->vectpending_prio;
  68 }
  69
  70 /* Return the value of the ISCR RETTOBASE bit:
  71  * 1 if there is exactly one active exception
  72  * 0 if there is more than one active exception
  73  * UNKNOWN if there are no active exceptions (we choose 1,
  74  * which matches the choice Cortex-M3 is documented as making).
  75  *
  76  * NB: some versions of the documentation talk about this
  77  * counting "active exceptions other than the one shown by IPSR";
  78  * this is only different in the obscure corner case where guest
  79  * code has manually deactivated an exception and is about
  80  * to fail an exception-return integrity check. The definition
  81  * above is the one from the v8M ARM ARM and is also in line
  82  * with the behaviour documented for the Cortex-M3.
  83  */
  84 static bool nvic_rettobase(NVICState *s)
  85 {
  86     int irq, nhand = 0;
  87
  88     for (irq = ARMV7M_EXCP_RESET; irq < s->num_irq; irq++) {
  89         if (s->vectors[irq].active) {
  90             nhand++;
  91             if (nhand == 2) {
  92                 return 0;
  93             }
  94         }
  95     }
  96
  97     return 1;
  98 }
  99
 100 /* Return the value of the ISCR ISRPENDING bit:
 101  * 1 if an external interrupt is pending
 102  * 0 if no external interrupt is pending
 103  */
 104 static bool nvic_isrpending(NVICState *s)
 105 {
 106     int irq;
 107
 108     /* We can shortcut if the highest priority pending interrupt
 109      * happens to be external or if there is nothing pending.
 110      */
 111     if (s->vectpending > NVIC_FIRST_IRQ) {
 112         return true;
 113     }
 114     if (s->vectpending == 0) {
 115         return false;
 116     }
 117
 118     for (irq = NVIC_FIRST_IRQ; irq < s->num_irq; irq++) {
 119         if (s->vectors[irq].pending) {
 120             return true;
 121         }
 122     }
 123     return false;
 124 }
 125
 126 /* Return a mask word which clears the subpriority bits from
 127  * a priority value for an M-profile exception, leaving only
 128  * the group priority.
 129  */
 130 static inline uint32_t nvic_gprio_mask(NVICState *s)
 131 {
 132     return ~0U << (s->prigroup + 1);
 133 }
 134
 135 /* Recompute vectpending and exception_prio */
 136 static void nvic_recompute_state(NVICState *s)
 137 {
 138     int i;
 139     int pend_prio = NVIC_NOEXC_PRIO;
 140     int active_prio = NVIC_NOEXC_PRIO;
 141     int pend_irq = 0;
 142
 143     for (i = 1; i < s->num_irq; i++) {
 144         VecInfo *vec = &s->vectors[i];
 145
 146         if (vec->enabled && vec->pending && vec->prio < pend_prio) {
 147             pend_prio = vec->prio;
 148             pend_irq = i;
 149         }
 150         if (vec->active && vec->prio < active_prio) {
 151             active_prio = vec->prio;
 152         }
 153     }
 154
 155     if (active_prio > 0) {
 156         active_prio &= nvic_gprio_mask(s);
 157     }
 158
 159     if (pend_prio > 0) {
 160         pend_prio &= nvic_gprio_mask(s);
 161     }
 162
 163     s->vectpending = pend_irq;
 164     s->vectpending_prio = pend_prio;
 165     s->exception_prio = active_prio;
 166
 167     trace_nvic_recompute_state(s->vectpending,
 168                                s->vectpending_prio,
 169                                s->exception_prio);
 170 }
 171
 172 /* Return the current execution priority of the CPU
 173  * (equivalent to the pseudocode ExecutionPriority function).
 174  * This is a value between -2 (NMI priority) and NVIC_NOEXC_PRIO.
 175  */
 176 static inline int nvic_exec_prio(NVICState *s)
 177 {
 178     CPUARMState *env = &s->cpu->env;
 179     int running;
 180
 181     if (env->v7m.faultmask[env->v7m.secure]) {
 182         running = -1;
 183     } else if (env->v7m.primask[env->v7m.secure]) {
 184         running = 0;
 185     } else if (env->v7m.basepri[env->v7m.secure] > 0) {
 186         running = env->v7m.basepri[env->v7m.secure] & nvic_gprio_mask(s);
 187     } else {
 188         running = NVIC_NOEXC_PRIO; /* lower than any possible priority */
 189     }
 190     /* consider priority of active handler */
 191     return MIN(running, s->exception_prio);
 192 }
 193
 194 bool armv7m_nvic_can_take_pending_exception(void *opaque)
 195 {
 196     NVICState *s = opaque;
 197
 198     return nvic_exec_prio(s) > nvic_pending_prio(s);
 199 }
 200
 201 int armv7m_nvic_raw_execution_priority(void *opaque)
 202 {
 203     NVICState *s = opaque;
 204
 205     return s->exception_prio;
 206 }
 207
 208 /* caller must call nvic_irq_update() after this */
 209 static void set_prio(NVICState *s, unsigned irq, uint8_t prio)
 210 {
 211     assert(irq > ARMV7M_EXCP_NMI); /* only use for configurable prios */
 212     assert(irq < s->num_irq);
 213
 214     s->vectors[irq].prio = prio;
 215
 216     trace_nvic_set_prio(irq, prio);
 217 }
 218
 219 /* Recompute state and assert irq line accordingly.
 220  * Must be called after changes to:
 221  *  vec->active, vec->enabled, vec->pending or vec->prio for any vector
 222  *  prigroup
 223  */
 224 static void nvic_irq_update(NVICState *s)
 225 {
 226     int lvl;
 227     int pend_prio;
 228
 229     nvic_recompute_state(s);
 230     pend_prio = nvic_pending_prio(s);
 231
 232     /* Raise NVIC output if this IRQ would be taken, except that we
 233      * ignore the effects of the BASEPRI, FAULTMASK and PRIMASK (which
 234      * will be checked for in arm_v7m_cpu_exec_interrupt()); changes
 235      * to those CPU registers don't cause us to recalculate the NVIC
 236      * pending info.
 237      */
 238     lvl = (pend_prio < s->exception_prio);
 239     trace_nvic_irq_update(s->vectpending, pend_prio, s->exception_prio, lvl);
 240     qemu_set_irq(s->excpout, lvl);
 241 }
 242
 243 static void armv7m_nvic_clear_pending(void *opaque, int irq)
 244 {
 245     NVICState *s = (NVICState *)opaque;
 246     VecInfo *vec;
 247
 248     assert(irq > ARMV7M_EXCP_RESET && irq < s->num_irq);
 249
 250     vec = &s->vectors[irq];
 251     trace_nvic_clear_pending(irq, vec->enabled, vec->prio);
 252     if (vec->pending) {
 253         vec->pending = 0;
 254         nvic_irq_update(s);
 255     }
 256 }
 257
 258 void armv7m_nvic_set_pending(void *opaque, int irq)
 259 {
 260     NVICState *s = (NVICState *)opaque;
 261     VecInfo *vec;
 262
 263     assert(irq > ARMV7M_EXCP_RESET && irq < s->num_irq);
 264
 265     vec = &s->vectors[irq];
 266     trace_nvic_set_pending(irq, vec->enabled, vec->prio);
 267
 268
 269     if (irq >= ARMV7M_EXCP_HARD && irq < ARMV7M_EXCP_PENDSV) {
 270         /* If a synchronous exception is pending then it may be
 271          * escalated to HardFault if:
 272          *  * it is equal or lower priority to current execution
 273          *  * it is disabled
 274          * (ie we need to take it immediately but we can't do so).
 275          * Asynchronous exceptions (and interrupts) simply remain pending.
 276          *
 277          * For QEMU, we don't have any imprecise (asynchronous) faults,
 278          * so we can assume that PREFETCH_ABORT and DATA_ABORT are always
 279          * synchronous.
 280          * Debug exceptions are awkward because only Debug exceptions
 281          * resulting from the BKPT instruction should be escalated,
 282          * but we don't currently implement any Debug exceptions other
 283          * than those that result from BKPT, so we treat all debug exceptions
 284          * as needing escalation.
 285          *
 286          * This all means we can identify whether to escalate based only on
 287          * the exception number and don't (yet) need the caller to explicitly
 288          * tell us whether this exception is synchronous or not.
 289          */
 290         int running = nvic_exec_prio(s);
 291         bool escalate = false;
 292
 293         if (vec->prio >= running) {
 294             trace_nvic_escalate_prio(irq, vec->prio, running);
 295             escalate = true;
 296         } else if (!vec->enabled) {
 297             trace_nvic_escalate_disabled(irq);
 298             escalate = true;
 299         }
 300
 301         if (escalate) {
 302             if (running < 0) {
 303                 /* We want to escalate to HardFault but we can't take a
 304                  * synchronous HardFault at this point either. This is a
 305                  * Lockup condition due to a guest bug. We don't model
 306                  * Lockup, so report via cpu_abort() instead.
 307                  */
 308                 cpu_abort(&s->cpu->parent_obj,
 309                           "Lockup: can't escalate %d to HardFault "
 310                           "(current priority %d)\n", irq, running);
 311             }
 312
 313             /* We can do the escalation, so we take HardFault instead */
 314             irq = ARMV7M_EXCP_HARD;
 315             vec = &s->vectors[irq];
 316             s->cpu->env.v7m.hfsr |= R_V7M_HFSR_FORCED_MASK;
 317         }
 318     }
 319
 320     if (!vec->pending) {
 321         vec->pending = 1;
 322         nvic_irq_update(s);
 323     }
 324 }
 325
 326 /* Make pending IRQ active.  */
 327 void armv7m_nvic_acknowledge_irq(void *opaque)
 328 {
 329     NVICState *s = (NVICState *)opaque;
 330     CPUARMState *env = &s->cpu->env;
 331     const int pending = s->vectpending;
 332     const int running = nvic_exec_prio(s);
 333     VecInfo *vec;
 334
 335     assert(pending > ARMV7M_EXCP_RESET && pending < s->num_irq);
 336
 337     vec = &s->vectors[pending];
 338
 339     assert(vec->enabled);
 340     assert(vec->pending);
 341
 342     assert(s->vectpending_prio < running);
 343
 344     trace_nvic_acknowledge_irq(pending, s->vectpending_prio);
 345
 346     vec->active = 1;
 347     vec->pending = 0;
 348
 349     env->v7m.exception = s->vectpending;
 350
 351     nvic_irq_update(s);
 352 }
 353
 354 int armv7m_nvic_complete_irq(void *opaque, int irq)
 355 {
 356     NVICState *s = (NVICState *)opaque;
 357     VecInfo *vec;
 358     int ret;
 359
 360     assert(irq > ARMV7M_EXCP_RESET && irq < s->num_irq);
 361
 362     vec = &s->vectors[irq];
 363
 364     trace_nvic_complete_irq(irq);
 365
 366     if (!vec->active) {
 367         /* Tell the caller this was an illegal exception return */
 368         return -1;
 369     }
 370
 371     ret = nvic_rettobase(s);
 372
 373     vec->active = 0;
 374     if (vec->level) {
 375         /* Re-pend the exception if it's still held high; only
 376          * happens for extenal IRQs
 377          */
 378         assert(irq >= NVIC_FIRST_IRQ);
 379         vec->pending = 1;
 380     }
 381
 382     nvic_irq_update(s);
 383
 384     return ret;
 385 }
 386
 387 /* callback when external interrupt line is changed */
 388 static void set_irq_level(void *opaque, int n, int level)
 389 {
 390     NVICState *s = opaque;
 391     VecInfo *vec;
 392
 393     n += NVIC_FIRST_IRQ;
 394
 395     assert(n >= NVIC_FIRST_IRQ && n < s->num_irq);
 396
 397     trace_nvic_set_irq_level(n, level);
 398
 399     /* The pending status of an external interrupt is
 400      * latched on rising edge and exception handler return.
 401      *
 402      * Pulsing the IRQ will always run the handler
 403      * once, and the handler will re-run until the
 404      * level is low when the handler completes.
 405      */
 406     vec = &s->vectors[n];
 407     if (level != vec->level) {
 408         vec->level = level;
 409         if (level) {
 410             armv7m_nvic_set_pending(s, n);
 411         }
 412     }
 413 }
 414
 415 static uint32_t nvic_readl(NVICState *s, uint32_t offset, MemTxAttrs attrs)
 416 {
 417     ARMCPU *cpu = s->cpu;
 418     uint32_t val;
 419
 420     switch (offset) {
 421     case 4: /* Interrupt Control Type.  */
 422         return ((s->num_irq - NVIC_FIRST_IRQ) / 32) - 1;
 423     case 0xd00: /* CPUID Base.  */
 424         return cpu->midr;
 425     case 0xd04: /* Interrupt Control State.  */
 426         /* VECTACTIVE */
 427         val = cpu->env.v7m.exception;
 428         /* VECTPENDING */
 429         val |= (s->vectpending & 0xff) << 12;
 430         /* ISRPENDING - set if any external IRQ is pending */
 431         if (nvic_isrpending(s)) {
 432             val |= (1 << 22);
 433         }
 434         /* RETTOBASE - set if only one handler is active */
 435         if (nvic_rettobase(s)) {
 436             val |= (1 << 11);
 437         }
 438         /* PENDSTSET */
 439         if (s->vectors[ARMV7M_EXCP_SYSTICK].pending) {
 440             val |= (1 << 26);
 441         }
 442         /* PENDSVSET */
 443         if (s->vectors[ARMV7M_EXCP_PENDSV].pending) {
 444             val |= (1 << 28);
 445         }
 446         /* NMIPENDSET */
 447         if (s->vectors[ARMV7M_EXCP_NMI].pending) {
 448             val |= (1 << 31);
 449         }
 450         /* ISRPREEMPT not implemented */
 451         return val;
 452     case 0xd08: /* Vector Table Offset.  */
 453         return cpu->env.v7m.vecbase[attrs.secure];
 454     case 0xd0c: /* Application Interrupt/Reset Control.  */
 455         return 0xfa050000 | (s->prigroup << 8);
 456     case 0xd10: /* System Control.  */
 457         /* TODO: Implement SLEEPONEXIT.  */
 458         return 0;
 459     case 0xd14: /* Configuration Control.  */
 460         /* The BFHFNMIGN bit is the only non-banked bit; we
 461          * keep it in the non-secure copy of the register.
 462          */
 463         val = cpu->env.v7m.ccr[attrs.secure];
 464         val |= cpu->env.v7m.ccr[M_REG_NS] & R_V7M_CCR_BFHFNMIGN_MASK;
 465         return val;
 466     case 0xd24: /* System Handler Status.  */
 467         val = 0;
 468         if (s->vectors[ARMV7M_EXCP_MEM].active) {
 469             val |= (1 << 0);
 470         }
 471         if (s->vectors[ARMV7M_EXCP_BUS].active) {
 472             val |= (1 << 1);
 473         }
 474         if (s->vectors[ARMV7M_EXCP_USAGE].active) {
 475             val |= (1 << 3);
 476         }
 477         if (s->vectors[ARMV7M_EXCP_SVC].active) {
 478             val |= (1 << 7);
 479         }
 480         if (s->vectors[ARMV7M_EXCP_DEBUG].active) {
 481             val |= (1 << 8);
 482         }
 483         if (s->vectors[ARMV7M_EXCP_PENDSV].active) {
 484             val |= (1 << 10);
 485         }
 486         if (s->vectors[ARMV7M_EXCP_SYSTICK].active) {
 487             val |= (1 << 11);
 488         }
 489         if (s->vectors[ARMV7M_EXCP_USAGE].pending) {
 490             val |= (1 << 12);
 491         }
 492         if (s->vectors[ARMV7M_EXCP_MEM].pending) {
 493             val |= (1 << 13);
 494         }
 495         if (s->vectors[ARMV7M_EXCP_BUS].pending) {
 496             val |= (1 << 14);
 497         }
 498         if (s->vectors[ARMV7M_EXCP_SVC].pending) {
 499             val |= (1 << 15);
 500         }
 501         if (s->vectors[ARMV7M_EXCP_MEM].enabled) {
 502             val |= (1 << 16);
 503         }
 504         if (s->vectors[ARMV7M_EXCP_BUS].enabled) {
 505             val |= (1 << 17);
 506         }
 507         if (s->vectors[ARMV7M_EXCP_USAGE].enabled) {
 508             val |= (1 << 18);
 509         }
 510         return val;
 511     case 0xd28: /* Configurable Fault Status.  */
 512         /* The BFSR bits [15:8] are shared between security states
 513          * and we store them in the NS copy
 514          */
 515         val = cpu->env.v7m.cfsr[attrs.secure];
 516         val |= cpu->env.v7m.cfsr[M_REG_NS] & R_V7M_CFSR_BFSR_MASK;
 517         return val;
 518     case 0xd2c: /* Hard Fault Status.  */
 519         return cpu->env.v7m.hfsr;
 520     case 0xd30: /* Debug Fault Status.  */
 521         return cpu->env.v7m.dfsr;
 522     case 0xd34: /* MMFAR MemManage Fault Address */
 523         return cpu->env.v7m.mmfar[attrs.secure];
 524     case 0xd38: /* Bus Fault Address.  */
 525         return cpu->env.v7m.bfar;
 526     case 0xd3c: /* Aux Fault Status.  */
 527         /* TODO: Implement fault status registers.  */
 528         qemu_log_mask(LOG_UNIMP,
 529                       "Aux Fault status registers unimplemented\n");
 530         return 0;
 531     case 0xd40: /* PFR0.  */
 532         return 0x00000030;
 533     case 0xd44: /* PRF1.  */
 534         return 0x00000200;
 535     case 0xd48: /* DFR0.  */
 536         return 0x00100000;
 537     case 0xd4c: /* AFR0.  */
 538         return 0x00000000;
 539     case 0xd50: /* MMFR0.  */
 540         return 0x00000030;
 541     case 0xd54: /* MMFR1.  */
 542         return 0x00000000;
 543     case 0xd58: /* MMFR2.  */
 544         return 0x00000000;
 545     case 0xd5c: /* MMFR3.  */
 546         return 0x00000000;
 547     case 0xd60: /* ISAR0.  */
 548         return 0x01141110;
 549     case 0xd64: /* ISAR1.  */
 550         return 0x02111000;
 551     case 0xd68: /* ISAR2.  */
 552         return 0x21112231;
 553     case 0xd6c: /* ISAR3.  */
 554         return 0x01111110;
 555     case 0xd70: /* ISAR4.  */
 556         return 0x01310102;
 557     /* TODO: Implement debug registers.  */
 558     case 0xd90: /* MPU_TYPE */
 559         /* Unified MPU; if the MPU is not present this value is zero */
 560         return cpu->pmsav7_dregion << 8;
 561         break;
 562     case 0xd94: /* MPU_CTRL */
 563         return cpu->env.v7m.mpu_ctrl[attrs.secure];
 564     case 0xd98: /* MPU_RNR */
 565         return cpu->env.pmsav7.rnr[attrs.secure];
 566     case 0xd9c: /* MPU_RBAR */
 567     case 0xda4: /* MPU_RBAR_A1 */
 568     case 0xdac: /* MPU_RBAR_A2 */
 569     case 0xdb4: /* MPU_RBAR_A3 */
 570     {
 571         int region = cpu->env.pmsav7.rnr[attrs.secure];
 572
 573         if (arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 574             /* PMSAv8M handling of the aliases is different from v7M:
 575              * aliases A1, A2, A3 override the low two bits of the region
 576              * number in MPU_RNR, and there is no 'region' field in the
 577              * RBAR register.
 578              */
 579             int aliasno = (offset - 0xd9c) / 8; /* 0..3 */
 580             if (aliasno) {
 581                 region = deposit32(region, 0, 2, aliasno);
 582             }
 583             if (region >= cpu->pmsav7_dregion) {
 584                 return 0;
 585             }
 586             return cpu->env.pmsav8.rbar[attrs.secure][region];
 587         }
 588
 589         if (region >= cpu->pmsav7_dregion) {
 590             return 0;
 591         }
 592         return (cpu->env.pmsav7.drbar[region] & 0x1f) | (region & 0xf);
 593     }
 594     case 0xda0: /* MPU_RASR (v7M), MPU_RLAR (v8M) */
 595     case 0xda8: /* MPU_RASR_A1 (v7M), MPU_RLAR_A1 (v8M) */
 596     case 0xdb0: /* MPU_RASR_A2 (v7M), MPU_RLAR_A2 (v8M) */
 597     case 0xdb8: /* MPU_RASR_A3 (v7M), MPU_RLAR_A3 (v8M) */
 598     {
 599         int region = cpu->env.pmsav7.rnr[attrs.secure];
 600
 601         if (arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 602             /* PMSAv8M handling of the aliases is different from v7M:
 603              * aliases A1, A2, A3 override the low two bits of the region
 604              * number in MPU_RNR.
 605              */
 606             int aliasno = (offset - 0xda0) / 8; /* 0..3 */
 607             if (aliasno) {
 608                 region = deposit32(region, 0, 2, aliasno);
 609             }
 610             if (region >= cpu->pmsav7_dregion) {
 611                 return 0;
 612             }
 613             return cpu->env.pmsav8.rlar[attrs.secure][region];
 614         }
 615
 616         if (region >= cpu->pmsav7_dregion) {
 617             return 0;
 618         }
 619         return ((cpu->env.pmsav7.dracr[region] & 0xffff) << 16) |
 620             (cpu->env.pmsav7.drsr[region] & 0xffff);
 621     }
 622     case 0xdc0: /* MPU_MAIR0 */
 623         if (!arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 624             goto bad_offset;
 625         }
 626         return cpu->env.pmsav8.mair0[attrs.secure];
 627     case 0xdc4: /* MPU_MAIR1 */
 628         if (!arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 629             goto bad_offset;
 630         }
 631         return cpu->env.pmsav8.mair1[attrs.secure];
 632     default:
 633     bad_offset:
 634         qemu_log_mask(LOG_GUEST_ERROR, "NVIC: Bad read offset 0x%x\n", offset);
 635         return 0;
 636     }
 637 }
 638
 639 static void nvic_writel(NVICState *s, uint32_t offset, uint32_t value,
 640                         MemTxAttrs attrs)
 641 {
 642     ARMCPU *cpu = s->cpu;
 643
 644     switch (offset) {
 645     case 0xd04: /* Interrupt Control State.  */
 646         if (value & (1 << 31)) {
 647             armv7m_nvic_set_pending(s, ARMV7M_EXCP_NMI);
 648         }
 649         if (value & (1 << 28)) {
 650             armv7m_nvic_set_pending(s, ARMV7M_EXCP_PENDSV);
 651         } else if (value & (1 << 27)) {
 652             armv7m_nvic_clear_pending(s, ARMV7M_EXCP_PENDSV);
 653         }
 654         if (value & (1 << 26)) {
 655             armv7m_nvic_set_pending(s, ARMV7M_EXCP_SYSTICK);
 656         } else if (value & (1 << 25)) {
 657             armv7m_nvic_clear_pending(s, ARMV7M_EXCP_SYSTICK);
 658         }
 659         break;
 660     case 0xd08: /* Vector Table Offset.  */
 661         cpu->env.v7m.vecbase[attrs.secure] = value & 0xffffff80;
 662         break;
 663     case 0xd0c: /* Application Interrupt/Reset Control.  */
 664         if ((value >> 16) == 0x05fa) {
 665             if (value & 4) {
 666                 qemu_irq_pulse(s->sysresetreq);
 667             }
 668             if (value & 2) {
 669                 qemu_log_mask(LOG_GUEST_ERROR,
 670                               "Setting VECTCLRACTIVE when not in DEBUG mode "
 671                               "is UNPREDICTABLE\n");
 672             }
 673             if (value & 1) {
 674                 qemu_log_mask(LOG_GUEST_ERROR,
 675                               "Setting VECTRESET when not in DEBUG mode "
 676                               "is UNPREDICTABLE\n");
 677             }
 678             s->prigroup = extract32(value, 8, 3);
 679             nvic_irq_update(s);
 680         }
 681         break;
 682     case 0xd10: /* System Control.  */
 683         /* TODO: Implement control registers.  */
 684         qemu_log_mask(LOG_UNIMP, "NVIC: SCR unimplemented\n");
 685         break;
 686     case 0xd14: /* Configuration Control.  */
 687         /* Enforce RAZ/WI on reserved and must-RAZ/WI bits */
 688         value &= (R_V7M_CCR_STKALIGN_MASK |
 689                   R_V7M_CCR_BFHFNMIGN_MASK |
 690                   R_V7M_CCR_DIV_0_TRP_MASK |
 691                   R_V7M_CCR_UNALIGN_TRP_MASK |
 692                   R_V7M_CCR_USERSETMPEND_MASK |
 693                   R_V7M_CCR_NONBASETHRDENA_MASK);
 694
 695         if (arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 696             /* v8M makes NONBASETHRDENA and STKALIGN be RES1 */
 697             value |= R_V7M_CCR_NONBASETHRDENA_MASK
 698                 | R_V7M_CCR_STKALIGN_MASK;
 699         }
 700         if (attrs.secure) {
 701             /* the BFHFNMIGN bit is not banked; keep that in the NS copy */
 702             cpu->env.v7m.ccr[M_REG_NS] =
 703                 (cpu->env.v7m.ccr[M_REG_NS] & ~R_V7M_CCR_BFHFNMIGN_MASK)
 704                 | (value & R_V7M_CCR_BFHFNMIGN_MASK);
 705             value &= ~R_V7M_CCR_BFHFNMIGN_MASK;
 706         }
 707
 708         cpu->env.v7m.ccr[attrs.secure] = value;
 709         break;
 710     case 0xd24: /* System Handler Control.  */
 711         s->vectors[ARMV7M_EXCP_MEM].active = (value & (1 << 0)) != 0;
 712         s->vectors[ARMV7M_EXCP_BUS].active = (value & (1 << 1)) != 0;
 713         s->vectors[ARMV7M_EXCP_USAGE].active = (value & (1 << 3)) != 0;
 714         s->vectors[ARMV7M_EXCP_SVC].active = (value & (1 << 7)) != 0;
 715         s->vectors[ARMV7M_EXCP_DEBUG].active = (value & (1 << 8)) != 0;
 716         s->vectors[ARMV7M_EXCP_PENDSV].active = (value & (1 << 10)) != 0;
 717         s->vectors[ARMV7M_EXCP_SYSTICK].active = (value & (1 << 11)) != 0;
 718         s->vectors[ARMV7M_EXCP_USAGE].pending = (value & (1 << 12)) != 0;
 719         s->vectors[ARMV7M_EXCP_MEM].pending = (value & (1 << 13)) != 0;
 720         s->vectors[ARMV7M_EXCP_BUS].pending = (value & (1 << 14)) != 0;
 721         s->vectors[ARMV7M_EXCP_SVC].pending = (value & (1 << 15)) != 0;
 722         s->vectors[ARMV7M_EXCP_MEM].enabled = (value & (1 << 16)) != 0;
 723         s->vectors[ARMV7M_EXCP_BUS].enabled = (value & (1 << 17)) != 0;
 724         s->vectors[ARMV7M_EXCP_USAGE].enabled = (value & (1 << 18)) != 0;
 725         nvic_irq_update(s);
 726         break;
 727     case 0xd28: /* Configurable Fault Status.  */
 728         cpu->env.v7m.cfsr[attrs.secure] &= ~value; /* W1C */
 729         if (attrs.secure) {
 730             /* The BFSR bits [15:8] are shared between security states
 731              * and we store them in the NS copy.
 732              */
 733             cpu->env.v7m.cfsr[M_REG_NS] &= ~(value & R_V7M_CFSR_BFSR_MASK);
 734         }
 735         break;
 736     case 0xd2c: /* Hard Fault Status.  */
 737         cpu->env.v7m.hfsr &= ~value; /* W1C */
 738         break;
 739     case 0xd30: /* Debug Fault Status.  */
 740         cpu->env.v7m.dfsr &= ~value; /* W1C */
 741         break;
 742     case 0xd34: /* Mem Manage Address.  */
 743         cpu->env.v7m.mmfar[attrs.secure] = value;
 744         return;
 745     case 0xd38: /* Bus Fault Address.  */
 746         cpu->env.v7m.bfar = value;
 747         return;
 748     case 0xd3c: /* Aux Fault Status.  */
 749         qemu_log_mask(LOG_UNIMP,
 750                       "NVIC: Aux fault status registers unimplemented\n");
 751         break;
 752     case 0xd90: /* MPU_TYPE */
 753         return; /* RO */
 754     case 0xd94: /* MPU_CTRL */
 755         if ((value &
 756              (R_V7M_MPU_CTRL_HFNMIENA_MASK | R_V7M_MPU_CTRL_ENABLE_MASK))
 757             == R_V7M_MPU_CTRL_HFNMIENA_MASK) {
 758             qemu_log_mask(LOG_GUEST_ERROR, "MPU_CTRL: HFNMIENA and !ENABLE is "
 759                           "UNPREDICTABLE\n");
 760         }
 761         cpu->env.v7m.mpu_ctrl[attrs.secure]
 762             = value & (R_V7M_MPU_CTRL_ENABLE_MASK |
 763                        R_V7M_MPU_CTRL_HFNMIENA_MASK |
 764                        R_V7M_MPU_CTRL_PRIVDEFENA_MASK);
 765         tlb_flush(CPU(cpu));
 766         break;
 767     case 0xd98: /* MPU_RNR */
 768         if (value >= cpu->pmsav7_dregion) {
 769             qemu_log_mask(LOG_GUEST_ERROR, "MPU region out of range %"
 770                           PRIu32 "/%" PRIu32 "\n",
 771                           value, cpu->pmsav7_dregion);
 772         } else {
 773             cpu->env.pmsav7.rnr[attrs.secure] = value;
 774         }
 775         break;
 776     case 0xd9c: /* MPU_RBAR */
 777     case 0xda4: /* MPU_RBAR_A1 */
 778     case 0xdac: /* MPU_RBAR_A2 */
 779     case 0xdb4: /* MPU_RBAR_A3 */
 780     {
 781         int region;
 782
 783         if (arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 784             /* PMSAv8M handling of the aliases is different from v7M:
 785              * aliases A1, A2, A3 override the low two bits of the region
 786              * number in MPU_RNR, and there is no 'region' field in the
 787              * RBAR register.
 788              */
 789             int aliasno = (offset - 0xd9c) / 8; /* 0..3 */
 790
 791             region = cpu->env.pmsav7.rnr[attrs.secure];
 792             if (aliasno) {
 793                 region = deposit32(region, 0, 2, aliasno);
 794             }
 795             if (region >= cpu->pmsav7_dregion) {
 796                 return;
 797             }
 798             cpu->env.pmsav8.rbar[attrs.secure][region] = value;
 799             tlb_flush(CPU(cpu));
 800             return;
 801         }
 802
 803         if (value & (1 << 4)) {
 804             /* VALID bit means use the region number specified in this
 805              * value and also update MPU_RNR.REGION with that value.
 806              */
 807             region = extract32(value, 0, 4);
 808             if (region >= cpu->pmsav7_dregion) {
 809                 qemu_log_mask(LOG_GUEST_ERROR,
 810                               "MPU region out of range %u/%" PRIu32 "\n",
 811                               region, cpu->pmsav7_dregion);
 812                 return;
 813             }
 814             cpu->env.pmsav7.rnr[attrs.secure] = region;
 815         } else {
 816             region = cpu->env.pmsav7.rnr[attrs.secure];
 817         }
 818
 819         if (region >= cpu->pmsav7_dregion) {
 820             return;
 821         }
 822
 823         cpu->env.pmsav7.drbar[region] = value & ~0x1f;
 824         tlb_flush(CPU(cpu));
 825         break;
 826     }
 827     case 0xda0: /* MPU_RASR (v7M), MPU_RLAR (v8M) */
 828     case 0xda8: /* MPU_RASR_A1 (v7M), MPU_RLAR_A1 (v8M) */
 829     case 0xdb0: /* MPU_RASR_A2 (v7M), MPU_RLAR_A2 (v8M) */
 830     case 0xdb8: /* MPU_RASR_A3 (v7M), MPU_RLAR_A3 (v8M) */
 831     {
 832         int region = cpu->env.pmsav7.rnr[attrs.secure];
 833
 834         if (arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 835             /* PMSAv8M handling of the aliases is different from v7M:
 836              * aliases A1, A2, A3 override the low two bits of the region
 837              * number in MPU_RNR.
 838              */
 839             int aliasno = (offset - 0xd9c) / 8; /* 0..3 */
 840
 841             region = cpu->env.pmsav7.rnr[attrs.secure];
 842             if (aliasno) {
 843                 region = deposit32(region, 0, 2, aliasno);
 844             }
 845             if (region >= cpu->pmsav7_dregion) {
 846                 return;
 847             }
 848             cpu->env.pmsav8.rlar[attrs.secure][region] = value;
 849             tlb_flush(CPU(cpu));
 850             return;
 851         }
 852
 853         if (region >= cpu->pmsav7_dregion) {
 854             return;
 855         }
 856
 857         cpu->env.pmsav7.drsr[region] = value & 0xff3f;
 858         cpu->env.pmsav7.dracr[region] = (value >> 16) & 0x173f;
 859         tlb_flush(CPU(cpu));
 860         break;
 861     }
 862     case 0xdc0: /* MPU_MAIR0 */
 863         if (!arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 864             goto bad_offset;
 865         }
 866         if (cpu->pmsav7_dregion) {
 867             /* Register is RES0 if no MPU regions are implemented */
 868             cpu->env.pmsav8.mair0[attrs.secure] = value;
 869         }
 870         /* We don't need to do anything else because memory attributes
 871          * only affect cacheability, and we don't implement caching.
 872          */
 873         break;
 874     case 0xdc4: /* MPU_MAIR1 */
 875         if (!arm_feature(&cpu->env, ARM_FEATURE_V8)) {
 876             goto bad_offset;
 877         }
 878         if (cpu->pmsav7_dregion) {
 879             /* Register is RES0 if no MPU regions are implemented */
 880             cpu->env.pmsav8.mair1[attrs.secure] = value;
 881         }
 882         /* We don't need to do anything else because memory attributes
 883          * only affect cacheability, and we don't implement caching.
 884          */
 885         break;
 886     case 0xf00: /* Software Triggered Interrupt Register */
 887     {
 888         int excnum = (value & 0x1ff) + NVIC_FIRST_IRQ;
 889         if (excnum < s->num_irq) {
 890             armv7m_nvic_set_pending(s, excnum);
 891         }
 892         break;
 893     }
 894     default:
 895     bad_offset:
 896         qemu_log_mask(LOG_GUEST_ERROR,
 897                       "NVIC: Bad write offset 0x%x\n", offset);
 898     }
 899 }
 900
 901 static bool nvic_user_access_ok(NVICState *s, hwaddr offset, MemTxAttrs attrs)
 902 {
 903     /* Return true if unprivileged access to this register is permitted. */
 904     switch (offset) {
 905     case 0xf00: /* STIR: accessible only if CCR.USERSETMPEND permits */
 906         /* For access via STIR_NS it is the NS CCR.USERSETMPEND that
 907          * controls access even though the CPU is in Secure state (I_QDKX).
 908          */
 909         return s->cpu->env.v7m.ccr[attrs.secure] & R_V7M_CCR_USERSETMPEND_MASK;
 910     default:
 911         /* All other user accesses cause a BusFault unconditionally */
 912         return false;
 913     }
 914 }
 915
 916 static MemTxResult nvic_sysreg_read(void *opaque, hwaddr addr,
 917                                     uint64_t *data, unsigned size,
 918                                     MemTxAttrs attrs)
 919 {
 920     NVICState *s = (NVICState *)opaque;
 921     uint32_t offset = addr;
 922     unsigned i, startvec, end;
 923     uint32_t val;
 924
 925     if (attrs.user && !nvic_user_access_ok(s, addr, attrs)) {
 926         /* Generate BusFault for unprivileged accesses */
 927         return MEMTX_ERROR;
 928     }
 929
 930     switch (offset) {
 931     /* reads of set and clear both return the status */
 932     case 0x100 ... 0x13f: /* NVIC Set enable */
 933         offset += 0x80;
 934         /* fall through */
 935     case 0x180 ... 0x1bf: /* NVIC Clear enable */
 936         val = 0;
 937         startvec = offset - 0x180 + NVIC_FIRST_IRQ; /* vector # */
 938
 939         for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
 940             if (s->vectors[startvec + i].enabled) {
 941                 val |= (1 << i);
 942             }
 943         }
 944         break;
 945     case 0x200 ... 0x23f: /* NVIC Set pend */
 946         offset += 0x80;
 947         /* fall through */
 948     case 0x280 ... 0x2bf: /* NVIC Clear pend */
 949         val = 0;
 950         startvec = offset - 0x280 + NVIC_FIRST_IRQ; /* vector # */
 951         for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
 952             if (s->vectors[startvec + i].pending) {
 953                 val |= (1 << i);
 954             }
 955         }
 956         break;
 957     case 0x300 ... 0x33f: /* NVIC Active */
 958         val = 0;
 959         startvec = offset - 0x300 + NVIC_FIRST_IRQ; /* vector # */
 960
 961         for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
 962             if (s->vectors[startvec + i].active) {
 963                 val |= (1 << i);
 964             }
 965         }
 966         break;
 967     case 0x400 ... 0x5ef: /* NVIC Priority */
 968         val = 0;
 969         startvec = offset - 0x400 + NVIC_FIRST_IRQ; /* vector # */
 970
 971         for (i = 0; i < size && startvec + i < s->num_irq; i++) {
 972             val |= s->vectors[startvec + i].prio << (8 * i);
 973         }
 974         break;
 975     case 0xd18 ... 0xd23: /* System Handler Priority.  */
 976         val = 0;
 977         for (i = 0; i < size; i++) {
 978             val |= s->vectors[(offset - 0xd14) + i].prio << (i * 8);
 979         }
 980         break;
 981     case 0xfe0 ... 0xfff: /* ID.  */
 982         if (offset & 3) {
 983             val = 0;
 984         } else {
 985             val = nvic_id[(offset - 0xfe0) >> 2];
 986         }
 987         break;
 988     default:
 989         if (size == 4) {
 990             val = nvic_readl(s, offset, attrs);
 991         } else {
 992             qemu_log_mask(LOG_GUEST_ERROR,
 993                           "NVIC: Bad read of size %d at offset 0x%x\n",
 994                           size, offset);
 995             val = 0;
 996         }
 997     }
 998
 999     trace_nvic_sysreg_read(addr, val, size);
1000     *data = val;
1001     return MEMTX_OK;
1002 }
1003
1004 static MemTxResult nvic_sysreg_write(void *opaque, hwaddr addr,
1005                                      uint64_t value, unsigned size,
1006                                      MemTxAttrs attrs)
1007 {
1008     NVICState *s = (NVICState *)opaque;
1009     uint32_t offset = addr;
1010     unsigned i, startvec, end;
1011     unsigned setval = 0;
1012
1013     trace_nvic_sysreg_write(addr, value, size);
1014
1015     if (attrs.user && !nvic_user_access_ok(s, addr, attrs)) {
1016         /* Generate BusFault for unprivileged accesses */
1017         return MEMTX_ERROR;
1018     }
1019
1020     switch (offset) {
1021     case 0x100 ... 0x13f: /* NVIC Set enable */
1022         offset += 0x80;
1023         setval = 1;
1024         /* fall through */
1025     case 0x180 ... 0x1bf: /* NVIC Clear enable */
1026         startvec = 8 * (offset - 0x180) + NVIC_FIRST_IRQ;
1027
1028         for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
1029             if (value & (1 << i)) {
1030                 s->vectors[startvec + i].enabled = setval;
1031             }
1032         }
1033         nvic_irq_update(s);
1034         return MEMTX_OK;
1035     case 0x200 ... 0x23f: /* NVIC Set pend */
1036         /* the special logic in armv7m_nvic_set_pending()
1037          * is not needed since IRQs are never escalated
1038          */
1039         offset += 0x80;
1040         setval = 1;
1041         /* fall through */
1042     case 0x280 ... 0x2bf: /* NVIC Clear pend */
1043         startvec = 8 * (offset - 0x280) + NVIC_FIRST_IRQ; /* vector # */
1044
1045         for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
1046             if (value & (1 << i)) {
1047                 s->vectors[startvec + i].pending = setval;
1048             }
1049         }
1050         nvic_irq_update(s);
1051         return MEMTX_OK;
1052     case 0x300 ... 0x33f: /* NVIC Active */
1053         return MEMTX_OK; /* R/O */
1054     case 0x400 ... 0x5ef: /* NVIC Priority */
1055         startvec = 8 * (offset - 0x400) + NVIC_FIRST_IRQ; /* vector # */
1056
1057         for (i = 0; i < size && startvec + i < s->num_irq; i++) {
1058             set_prio(s, startvec + i, (value >> (i * 8)) & 0xff);
1059         }
1060         nvic_irq_update(s);
1061         return MEMTX_OK;
1062     case 0xd18 ... 0xd23: /* System Handler Priority.  */
1063         for (i = 0; i < size; i++) {
1064             unsigned hdlidx = (offset - 0xd14) + i;
1065             set_prio(s, hdlidx, (value >> (i * 8)) & 0xff);
1066         }
1067         nvic_irq_update(s);
1068         return MEMTX_OK;
1069     }
1070     if (size == 4) {
1071         nvic_writel(s, offset, value, attrs);
1072         return MEMTX_OK;
1073     }
1074     qemu_log_mask(LOG_GUEST_ERROR,
1075                   "NVIC: Bad write of size %d at offset 0x%x\n", size, offset);
1076     /* This is UNPREDICTABLE; treat as RAZ/WI */
1077     return MEMTX_OK;
1078 }
1079
1080 static const MemoryRegionOps nvic_sysreg_ops = {
1081     .read_with_attrs = nvic_sysreg_read,
1082     .write_with_attrs = nvic_sysreg_write,
1083     .endianness = DEVICE_NATIVE_ENDIAN,
1084 };
1085
1086 static MemTxResult nvic_sysreg_ns_write(void *opaque, hwaddr addr,
1087                                         uint64_t value, unsigned size,
1088                                         MemTxAttrs attrs)
1089 {
1090     if (attrs.secure) {
1091         /* S accesses to the alias act like NS accesses to the real region */
1092         attrs.secure = 0;
1093         return nvic_sysreg_write(opaque, addr, value, size, attrs);
1094     } else {
1095         /* NS attrs are RAZ/WI for privileged, and BusFault for user */
1096         if (attrs.user) {
1097             return MEMTX_ERROR;
1098         }
1099         return MEMTX_OK;
1100     }
1101 }
1102
1103 static MemTxResult nvic_sysreg_ns_read(void *opaque, hwaddr addr,
1104                                        uint64_t *data, unsigned size,
1105                                        MemTxAttrs attrs)
1106 {
1107     if (attrs.secure) {
1108         /* S accesses to the alias act like NS accesses to the real region */
1109         attrs.secure = 0;
1110         return nvic_sysreg_read(opaque, addr, data, size, attrs);
1111     } else {
1112         /* NS attrs are RAZ/WI for privileged, and BusFault for user */
1113         if (attrs.user) {
1114             return MEMTX_ERROR;
1115         }
1116         *data = 0;
1117         return MEMTX_OK;
1118     }
1119 }
1120
1121 static const MemoryRegionOps nvic_sysreg_ns_ops = {
1122     .read_with_attrs = nvic_sysreg_ns_read,
1123     .write_with_attrs = nvic_sysreg_ns_write,
1124     .endianness = DEVICE_NATIVE_ENDIAN,
1125 };
1126
1127 static int nvic_post_load(void *opaque, int version_id)
1128 {
1129     NVICState *s = opaque;
1130     unsigned i;
1131
1132     /* Check for out of range priority settings */
1133     if (s->vectors[ARMV7M_EXCP_RESET].prio != -3 ||
1134         s->vectors[ARMV7M_EXCP_NMI].prio != -2 ||
1135         s->vectors[ARMV7M_EXCP_HARD].prio != -1) {
1136         return 1;
1137     }
1138     for (i = ARMV7M_EXCP_MEM; i < s->num_irq; i++) {
1139         if (s->vectors[i].prio & ~0xff) {
1140             return 1;
1141         }
1142     }
1143
1144     nvic_recompute_state(s);
1145
1146     return 0;
1147 }
1148
1149 static const VMStateDescription vmstate_VecInfo = {
1150     .name = "armv7m_nvic_info",
1151     .version_id = 1,
1152     .minimum_version_id = 1,
1153     .fields = (VMStateField[]) {
1154         VMSTATE_INT16(prio, VecInfo),
1155         VMSTATE_UINT8(enabled, VecInfo),
1156         VMSTATE_UINT8(pending, VecInfo),
1157         VMSTATE_UINT8(active, VecInfo),
1158         VMSTATE_UINT8(level, VecInfo),
1159         VMSTATE_END_OF_LIST()
1160     }
1161 };
1162
1163 static bool nvic_security_needed(void *opaque)
1164 {
1165     NVICState *s = opaque;
1166
1167     return arm_feature(&s->cpu->env, ARM_FEATURE_M_SECURITY);
1168 }
1169
1170 static int nvic_security_post_load(void *opaque, int version_id)
1171 {
1172     NVICState *s = opaque;
1173     int i;
1174
1175     /* Check for out of range priority settings */
1176     if (s->sec_vectors[ARMV7M_EXCP_HARD].prio != -1) {
1177         return 1;
1178     }
1179     for (i = ARMV7M_EXCP_MEM; i < ARRAY_SIZE(s->sec_vectors); i++) {
1180         if (s->sec_vectors[i].prio & ~0xff) {
1181             return 1;
1182         }
1183     }
1184     return 0;
1185 }
1186
1187 static const VMStateDescription vmstate_nvic_security = {
1188     .name = "nvic/m-security",
1189     .version_id = 1,
1190     .minimum_version_id = 1,
1191     .needed = nvic_security_needed,
1192     .post_load = &nvic_security_post_load,
1193     .fields = (VMStateField[]) {
1194         VMSTATE_STRUCT_ARRAY(sec_vectors, NVICState, NVIC_INTERNAL_VECTORS, 1,
1195                              vmstate_VecInfo, VecInfo),
1196         VMSTATE_END_OF_LIST()
1197     }
1198 };
1199
1200 static const VMStateDescription vmstate_nvic = {
1201     .name = "armv7m_nvic",
1202     .version_id = 4,
1203     .minimum_version_id = 4,
1204     .post_load = &nvic_post_load,
1205     .fields = (VMStateField[]) {
1206         VMSTATE_STRUCT_ARRAY(vectors, NVICState, NVIC_MAX_VECTORS, 1,
1207                              vmstate_VecInfo, VecInfo),
1208         VMSTATE_UINT32(prigroup, NVICState),
1209         VMSTATE_END_OF_LIST()
1210     },
1211     .subsections = (const VMStateDescription*[]) {
1212         &vmstate_nvic_security,
1213         NULL
1214     }
1215 };
1216
1217 static Property props_nvic[] = {
1218     /* Number of external IRQ lines (so excluding the 16 internal exceptions) */
1219     DEFINE_PROP_UINT32("num-irq", NVICState, num_irq, 64),
1220     DEFINE_PROP_END_OF_LIST()
1221 };
1222
1223 static void armv7m_nvic_reset(DeviceState *dev)
1224 {
1225     NVICState *s = NVIC(dev);
1226
1227     s->vectors[ARMV7M_EXCP_NMI].enabled = 1;
1228     s->vectors[ARMV7M_EXCP_HARD].enabled = 1;
1229     /* MEM, BUS, and USAGE are enabled through
1230      * the System Handler Control register
1231      */
1232     s->vectors[ARMV7M_EXCP_SVC].enabled = 1;
1233     s->vectors[ARMV7M_EXCP_DEBUG].enabled = 1;
1234     s->vectors[ARMV7M_EXCP_PENDSV].enabled = 1;
1235     s->vectors[ARMV7M_EXCP_SYSTICK].enabled = 1;
1236
1237     s->vectors[ARMV7M_EXCP_RESET].prio = -3;
1238     s->vectors[ARMV7M_EXCP_NMI].prio = -2;
1239     s->vectors[ARMV7M_EXCP_HARD].prio = -1;
1240
1241     if (arm_feature(&s->cpu->env, ARM_FEATURE_M_SECURITY)) {
1242         s->sec_vectors[ARMV7M_EXCP_HARD].enabled = 1;
1243         s->sec_vectors[ARMV7M_EXCP_SVC].enabled = 1;
1244         s->sec_vectors[ARMV7M_EXCP_PENDSV].enabled = 1;
1245         s->sec_vectors[ARMV7M_EXCP_SYSTICK].enabled = 1;
1246
1247         /* AIRCR.BFHFNMINS resets to 0 so Secure HF is priority -1 (R_CMTC) */
1248         s->sec_vectors[ARMV7M_EXCP_HARD].prio = -1;
1249     }
1250
1251     /* Strictly speaking the reset handler should be enabled.
1252      * However, we don't simulate soft resets through the NVIC,
1253      * and the reset vector should never be pended.
1254      * So we leave it disabled to catch logic errors.
1255      */
1256
1257     s->exception_prio = NVIC_NOEXC_PRIO;
1258     s->vectpending = 0;
1259     s->vectpending_is_s_banked = false;
1260     s->vectpending_prio = NVIC_NOEXC_PRIO;
1261 }
1262
1263 static void nvic_systick_trigger(void *opaque, int n, int level)
1264 {
1265     NVICState *s = opaque;
1266
1267     if (level) {
1268         /* SysTick just asked us to pend its exception.
1269          * (This is different from an external interrupt line's
1270          * behaviour.)
1271          */
1272         armv7m_nvic_set_pending(s, ARMV7M_EXCP_SYSTICK);
1273     }
1274 }
1275
1276 static void armv7m_nvic_realize(DeviceState *dev, Error **errp)
1277 {
1278     NVICState *s = NVIC(dev);
1279     SysBusDevice *systick_sbd;
1280     Error *err = NULL;
1281     int regionlen;
1282
1283     s->cpu = ARM_CPU(qemu_get_cpu(0));
1284     assert(s->cpu);
1285
1286     if (s->num_irq > NVIC_MAX_IRQ) {
1287         error_setg(errp, "num-irq %d exceeds NVIC maximum", s->num_irq);
1288         return;
1289     }
1290
1291     qdev_init_gpio_in(dev, set_irq_level, s->num_irq);
1292
1293     /* include space for internal exception vectors */
1294     s->num_irq += NVIC_FIRST_IRQ;
1295
1296     object_property_set_bool(OBJECT(&s->systick), true, "realized", &err);
1297     if (err != NULL) {
1298         error_propagate(errp, err);
1299         return;
1300     }
1301     systick_sbd = SYS_BUS_DEVICE(&s->systick);
1302     sysbus_connect_irq(systick_sbd, 0,
1303                        qdev_get_gpio_in_named(dev, "systick-trigger", 0));
1304
1305     /* The NVIC and System Control Space (SCS) starts at 0xe000e000
1306      * and looks like this:
1307      *  0x004 - ICTR
1308      *  0x010 - 0xff - systick
1309      *  0x100..0x7ec - NVIC
1310      *  0x7f0..0xcff - Reserved
1311      *  0xd00..0xd3c - SCS registers
1312      *  0xd40..0xeff - Reserved or Not implemented
1313      *  0xf00 - STIR
1314      *
1315      * Some registers within this space are banked between security states.
1316      * In v8M there is a second range 0xe002e000..0xe002efff which is the
1317      * NonSecure alias SCS; secure accesses to this behave like NS accesses
1318      * to the main SCS range, and non-secure accesses (including when
1319      * the security extension is not implemented) are RAZ/WI.
1320      * Note that both the main SCS range and the alias range are defined
1321      * to be exempt from memory attribution (R_BLJT) and so the memory
1322      * transaction attribute always matches the current CPU security
1323      * state (attrs.secure == env->v7m.secure). In the nvic_sysreg_ns_ops
1324      * wrappers we change attrs.secure to indicate the NS access; so
1325      * generally code determining which banked register to use should
1326      * use attrs.secure; code determining actual behaviour of the system
1327      * should use env->v7m.secure.
1328      */
1329     regionlen = arm_feature(&s->cpu->env, ARM_FEATURE_V8) ? 0x21000 : 0x1000;
1330     memory_region_init(&s->container, OBJECT(s), "nvic", regionlen);
1331     /* The system register region goes at the bottom of the priority
1332      * stack as it covers the whole page.
1333      */
1334     memory_region_init_io(&s->sysregmem, OBJECT(s), &nvic_sysreg_ops, s,
1335                           "nvic_sysregs", 0x1000);
1336     memory_region_add_subregion(&s->container, 0, &s->sysregmem);
1337     memory_region_add_subregion_overlap(&s->container, 0x10,
1338                                         sysbus_mmio_get_region(systick_sbd, 0),
1339                                         1);
1340
1341     if (arm_feature(&s->cpu->env, ARM_FEATURE_V8)) {
1342         memory_region_init_io(&s->sysreg_ns_mem, OBJECT(s),
1343                               &nvic_sysreg_ns_ops, s,
1344                               "nvic_sysregs_ns", 0x1000);
1345         memory_region_add_subregion(&s->container, 0x20000, &s->sysreg_ns_mem);
1346     }
1347
1348     sysbus_init_mmio(SYS_BUS_DEVICE(dev), &s->container);
1349 }
1350
1351 static void armv7m_nvic_instance_init(Object *obj)
1352 {
1353     /* We have a different default value for the num-irq property
1354      * than our superclass. This function runs after qdev init
1355      * has set the defaults from the Property array and before
1356      * any user-specified property setting, so just modify the
1357      * value in the GICState struct.
1358      */
1359     DeviceState *dev = DEVICE(obj);
1360     NVICState *nvic = NVIC(obj);
1361     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
1362
1363     object_initialize(&nvic->systick, sizeof(nvic->systick), TYPE_SYSTICK);
1364     qdev_set_parent_bus(DEVICE(&nvic->systick), sysbus_get_default());
1365
1366     sysbus_init_irq(sbd, &nvic->excpout);
1367     qdev_init_gpio_out_named(dev, &nvic->sysresetreq, "SYSRESETREQ", 1);
1368     qdev_init_gpio_in_named(dev, nvic_systick_trigger, "systick-trigger", 1);
1369 }
1370
1371 static void armv7m_nvic_class_init(ObjectClass *klass, void *data)
1372 {
1373     DeviceClass *dc = DEVICE_CLASS(klass);
1374
1375     dc->vmsd  = &vmstate_nvic;
1376     dc->props = props_nvic;
1377     dc->reset = armv7m_nvic_reset;
1378     dc->realize = armv7m_nvic_realize;
1379 }
1380
1381 static const TypeInfo armv7m_nvic_info = {
1382     .name          = TYPE_NVIC,
1383     .parent        = TYPE_SYS_BUS_DEVICE,
1384     .instance_init = armv7m_nvic_instance_init,
1385     .instance_size = sizeof(NVICState),
1386     .class_init    = armv7m_nvic_class_init,
1387     .class_size    = sizeof(SysBusDeviceClass),
1388 };
1389
1390 static void armv7m_nvic_register_types(void)
1391 {
1392     type_register_static(&armv7m_nvic_info);
1393 }
1394
1395 type_init(armv7m_nvic_register_types)