arm_gicv3_redist.c (39004B)
1 /* 2 * ARM GICv3 emulation: Redistributor 3 * 4 * Copyright (c) 2015 Huawei. 5 * Copyright (c) 2016 Linaro Limited. 6 * Written by Shlomo Pongratz, Peter Maydell 7 * 8 * This code is licensed under the GPL, version 2 or (at your option) 9 * any later version. 10 */ 11 12 #include "qemu/osdep.h" 13 #include "qemu/log.h" 14 #include "trace.h" 15 #include "gicv3_internal.h" 16 17 static uint32_t mask_group(GICv3CPUState *cs, MemTxAttrs attrs) 18 { 19 /* Return a 32-bit mask which should be applied for this set of 32 20 * interrupts; each bit is 1 if access is permitted by the 21 * combination of attrs.secure and GICR_GROUPR. (GICR_NSACR does 22 * not affect config register accesses, unlike GICD_NSACR.) 23 */ 24 if (!attrs.secure && !(cs->gic->gicd_ctlr & GICD_CTLR_DS)) { 25 /* bits for Group 0 or Secure Group 1 interrupts are RAZ/WI */ 26 return cs->gicr_igroupr0; 27 } 28 return 0xFFFFFFFFU; 29 } 30 31 static int gicr_ns_access(GICv3CPUState *cs, int irq) 32 { 33 /* Return the 2 bit NSACR.NS_access field for this SGI */ 34 assert(irq < 16); 35 return extract32(cs->gicr_nsacr, irq * 2, 2); 36 } 37 38 static void gicr_write_set_bitmap_reg(GICv3CPUState *cs, MemTxAttrs attrs, 39 uint32_t *reg, uint32_t val) 40 { 41 /* Helper routine to implement writing to a "set-bitmap" register */ 42 val &= mask_group(cs, attrs); 43 *reg |= val; 44 gicv3_redist_update(cs); 45 } 46 47 static void gicr_write_clear_bitmap_reg(GICv3CPUState *cs, MemTxAttrs attrs, 48 uint32_t *reg, uint32_t val) 49 { 50 /* Helper routine to implement writing to a "clear-bitmap" register */ 51 val &= mask_group(cs, attrs); 52 *reg &= ~val; 53 gicv3_redist_update(cs); 54 } 55 56 static uint32_t gicr_read_bitmap_reg(GICv3CPUState *cs, MemTxAttrs attrs, 57 uint32_t reg) 58 { 59 reg &= mask_group(cs, attrs); 60 return reg; 61 } 62 63 static bool vcpu_resident(GICv3CPUState *cs, uint64_t vptaddr) 64 { 65 /* 66 * Return true if a vCPU is resident, which is defined by 67 * whether the GICR_VPENDBASER register is marked VALID and 68 * has the right virtual pending table address. 69 */ 70 if (!FIELD_EX64(cs->gicr_vpendbaser, GICR_VPENDBASER, VALID)) { 71 return false; 72 } 73 return vptaddr == (cs->gicr_vpendbaser & R_GICR_VPENDBASER_PHYADDR_MASK); 74 } 75 76 /** 77 * update_for_one_lpi: Update pending information if this LPI is better 78 * 79 * @cs: GICv3CPUState 80 * @irq: interrupt to look up in the LPI Configuration table 81 * @ctbase: physical address of the LPI Configuration table to use 82 * @ds: true if priority value should not be shifted 83 * @hpp: points to pending information to update 84 * 85 * Look up @irq in the Configuration table specified by @ctbase 86 * to see if it is enabled and what its priority is. If it is an 87 * enabled interrupt with a higher priority than that currently 88 * recorded in @hpp, update @hpp. 89 */ 90 static void update_for_one_lpi(GICv3CPUState *cs, int irq, 91 uint64_t ctbase, bool ds, PendingIrq *hpp) 92 { 93 uint8_t lpite; 94 uint8_t prio; 95 96 address_space_read(&cs->gic->dma_as, 97 ctbase + ((irq - GICV3_LPI_INTID_START) * sizeof(lpite)), 98 MEMTXATTRS_UNSPECIFIED, &lpite, sizeof(lpite)); 99 100 if (!(lpite & LPI_CTE_ENABLED)) { 101 return; 102 } 103 104 if (ds) { 105 prio = lpite & LPI_PRIORITY_MASK; 106 } else { 107 prio = ((lpite & LPI_PRIORITY_MASK) >> 1) | 0x80; 108 } 109 110 if ((prio < hpp->prio) || 111 ((prio == hpp->prio) && (irq <= hpp->irq))) { 112 hpp->irq = irq; 113 hpp->prio = prio; 114 /* LPIs and vLPIs are always non-secure Grp1 interrupts */ 115 hpp->grp = GICV3_G1NS; 116 } 117 } 118 119 /** 120 * update_for_all_lpis: Fully scan LPI tables and find best pending LPI 121 * 122 * @cs: GICv3CPUState 123 * @ptbase: physical address of LPI Pending table 124 * @ctbase: physical address of LPI Configuration table 125 * @ptsizebits: size of tables, specified as number of interrupt ID bits minus 1 126 * @ds: true if priority value should not be shifted 127 * @hpp: points to pending information to set 128 * 129 * Recalculate the highest priority pending enabled LPI from scratch, 130 * and set @hpp accordingly. 131 * 132 * We scan the LPI pending table @ptbase; for each pending LPI, we read the 133 * corresponding entry in the LPI configuration table @ctbase to extract 134 * the priority and enabled information. 135 * 136 * We take @ptsizebits in the form idbits-1 because this is the way that 137 * LPI table sizes are architecturally specified in GICR_PROPBASER.IDBits 138 * and in the VMAPP command's VPT_size field. 139 */ 140 static void update_for_all_lpis(GICv3CPUState *cs, uint64_t ptbase, 141 uint64_t ctbase, unsigned ptsizebits, 142 bool ds, PendingIrq *hpp) 143 { 144 AddressSpace *as = &cs->gic->dma_as; 145 uint8_t pend; 146 uint32_t pendt_size = (1ULL << (ptsizebits + 1)); 147 int i, bit; 148 149 hpp->prio = 0xff; 150 151 for (i = GICV3_LPI_INTID_START / 8; i < pendt_size / 8; i++) { 152 address_space_read(as, ptbase + i, MEMTXATTRS_UNSPECIFIED, &pend, 1); 153 while (pend) { 154 bit = ctz32(pend); 155 update_for_one_lpi(cs, i * 8 + bit, ctbase, ds, hpp); 156 pend &= ~(1 << bit); 157 } 158 } 159 } 160 161 /** 162 * set_lpi_pending_bit: Set or clear pending bit for an LPI 163 * 164 * @cs: GICv3CPUState 165 * @ptbase: physical address of LPI Pending table 166 * @irq: LPI to change pending state for 167 * @level: false to clear pending state, true to set 168 * 169 * Returns true if we needed to do something, false if the pending bit 170 * was already at @level. 171 */ 172 static bool set_pending_table_bit(GICv3CPUState *cs, uint64_t ptbase, 173 int irq, bool level) 174 { 175 AddressSpace *as = &cs->gic->dma_as; 176 uint64_t addr = ptbase + irq / 8; 177 uint8_t pend; 178 179 address_space_read(as, addr, MEMTXATTRS_UNSPECIFIED, &pend, 1); 180 if (extract32(pend, irq % 8, 1) == level) { 181 /* Bit already at requested state, no action required */ 182 return false; 183 } 184 pend = deposit32(pend, irq % 8, 1, level ? 1 : 0); 185 address_space_write(as, addr, MEMTXATTRS_UNSPECIFIED, &pend, 1); 186 return true; 187 } 188 189 static uint8_t gicr_read_ipriorityr(GICv3CPUState *cs, MemTxAttrs attrs, 190 int irq) 191 { 192 /* Read the value of GICR_IPRIORITYR<n> for the specified interrupt, 193 * honouring security state (these are RAZ/WI for Group 0 or Secure 194 * Group 1 interrupts). 195 */ 196 uint32_t prio; 197 198 prio = cs->gicr_ipriorityr[irq]; 199 200 if (!attrs.secure && !(cs->gic->gicd_ctlr & GICD_CTLR_DS)) { 201 if (!(cs->gicr_igroupr0 & (1U << irq))) { 202 /* Fields for Group 0 or Secure Group 1 interrupts are RAZ/WI */ 203 return 0; 204 } 205 /* NS view of the interrupt priority */ 206 prio = (prio << 1) & 0xff; 207 } 208 return prio; 209 } 210 211 static void gicr_write_ipriorityr(GICv3CPUState *cs, MemTxAttrs attrs, int irq, 212 uint8_t value) 213 { 214 /* Write the value of GICD_IPRIORITYR<n> for the specified interrupt, 215 * honouring security state (these are RAZ/WI for Group 0 or Secure 216 * Group 1 interrupts). 217 */ 218 if (!attrs.secure && !(cs->gic->gicd_ctlr & GICD_CTLR_DS)) { 219 if (!(cs->gicr_igroupr0 & (1U << irq))) { 220 /* Fields for Group 0 or Secure Group 1 interrupts are RAZ/WI */ 221 return; 222 } 223 /* NS view of the interrupt priority */ 224 value = 0x80 | (value >> 1); 225 } 226 cs->gicr_ipriorityr[irq] = value; 227 } 228 229 static void gicv3_redist_update_vlpi_only(GICv3CPUState *cs) 230 { 231 uint64_t ptbase, ctbase, idbits; 232 233 if (!FIELD_EX64(cs->gicr_vpendbaser, GICR_VPENDBASER, VALID)) { 234 cs->hppvlpi.prio = 0xff; 235 return; 236 } 237 238 ptbase = cs->gicr_vpendbaser & R_GICR_VPENDBASER_PHYADDR_MASK; 239 ctbase = cs->gicr_vpropbaser & R_GICR_VPROPBASER_PHYADDR_MASK; 240 idbits = FIELD_EX64(cs->gicr_vpropbaser, GICR_VPROPBASER, IDBITS); 241 242 update_for_all_lpis(cs, ptbase, ctbase, idbits, true, &cs->hppvlpi); 243 } 244 245 static void gicv3_redist_update_vlpi(GICv3CPUState *cs) 246 { 247 gicv3_redist_update_vlpi_only(cs); 248 gicv3_cpuif_virt_irq_fiq_update(cs); 249 } 250 251 static void gicr_write_vpendbaser(GICv3CPUState *cs, uint64_t newval) 252 { 253 /* Write @newval to GICR_VPENDBASER, handling its effects */ 254 bool oldvalid = FIELD_EX64(cs->gicr_vpendbaser, GICR_VPENDBASER, VALID); 255 bool newvalid = FIELD_EX64(newval, GICR_VPENDBASER, VALID); 256 bool pendinglast; 257 258 /* 259 * The DIRTY bit is read-only and for us is always zero; 260 * other fields are writable. 261 */ 262 newval &= R_GICR_VPENDBASER_INNERCACHE_MASK | 263 R_GICR_VPENDBASER_SHAREABILITY_MASK | 264 R_GICR_VPENDBASER_PHYADDR_MASK | 265 R_GICR_VPENDBASER_OUTERCACHE_MASK | 266 R_GICR_VPENDBASER_PENDINGLAST_MASK | 267 R_GICR_VPENDBASER_IDAI_MASK | 268 R_GICR_VPENDBASER_VALID_MASK; 269 270 if (oldvalid && newvalid) { 271 /* 272 * Changing other fields while VALID is 1 is UNPREDICTABLE; 273 * we choose to log and ignore the write. 274 */ 275 if (cs->gicr_vpendbaser ^ newval) { 276 qemu_log_mask(LOG_GUEST_ERROR, 277 "%s: Changing GICR_VPENDBASER when VALID=1 " 278 "is UNPREDICTABLE\n", __func__); 279 } 280 return; 281 } 282 if (!oldvalid && !newvalid) { 283 cs->gicr_vpendbaser = newval; 284 return; 285 } 286 287 if (newvalid) { 288 /* 289 * Valid going from 0 to 1: update hppvlpi from tables. 290 * If IDAI is 0 we are allowed to use the info we cached in 291 * the IMPDEF area of the table. 292 * PendingLast is RES1 when we make this transition. 293 */ 294 pendinglast = true; 295 } else { 296 /* 297 * Valid going from 1 to 0: 298 * Set PendingLast if there was a pending enabled interrupt 299 * for the vPE that was just descheduled. 300 * If we cache info in the IMPDEF area, write it out here. 301 */ 302 pendinglast = cs->hppvlpi.prio != 0xff; 303 } 304 305 newval = FIELD_DP64(newval, GICR_VPENDBASER, PENDINGLAST, pendinglast); 306 cs->gicr_vpendbaser = newval; 307 gicv3_redist_update_vlpi(cs); 308 } 309 310 static MemTxResult gicr_readb(GICv3CPUState *cs, hwaddr offset, 311 uint64_t *data, MemTxAttrs attrs) 312 { 313 switch (offset) { 314 case GICR_IPRIORITYR ... GICR_IPRIORITYR + 0x1f: 315 *data = gicr_read_ipriorityr(cs, attrs, offset - GICR_IPRIORITYR); 316 return MEMTX_OK; 317 default: 318 return MEMTX_ERROR; 319 } 320 } 321 322 static MemTxResult gicr_writeb(GICv3CPUState *cs, hwaddr offset, 323 uint64_t value, MemTxAttrs attrs) 324 { 325 switch (offset) { 326 case GICR_IPRIORITYR ... GICR_IPRIORITYR + 0x1f: 327 gicr_write_ipriorityr(cs, attrs, offset - GICR_IPRIORITYR, value); 328 gicv3_redist_update(cs); 329 return MEMTX_OK; 330 default: 331 return MEMTX_ERROR; 332 } 333 } 334 335 static MemTxResult gicr_readl(GICv3CPUState *cs, hwaddr offset, 336 uint64_t *data, MemTxAttrs attrs) 337 { 338 switch (offset) { 339 case GICR_CTLR: 340 *data = cs->gicr_ctlr; 341 return MEMTX_OK; 342 case GICR_IIDR: 343 *data = gicv3_iidr(); 344 return MEMTX_OK; 345 case GICR_TYPER: 346 *data = extract64(cs->gicr_typer, 0, 32); 347 return MEMTX_OK; 348 case GICR_TYPER + 4: 349 *data = extract64(cs->gicr_typer, 32, 32); 350 return MEMTX_OK; 351 case GICR_STATUSR: 352 /* RAZ/WI for us (this is an optional register and our implementation 353 * does not track RO/WO/reserved violations to report them to the guest) 354 */ 355 *data = 0; 356 return MEMTX_OK; 357 case GICR_WAKER: 358 *data = cs->gicr_waker; 359 return MEMTX_OK; 360 case GICR_PROPBASER: 361 *data = extract64(cs->gicr_propbaser, 0, 32); 362 return MEMTX_OK; 363 case GICR_PROPBASER + 4: 364 *data = extract64(cs->gicr_propbaser, 32, 32); 365 return MEMTX_OK; 366 case GICR_PENDBASER: 367 *data = extract64(cs->gicr_pendbaser, 0, 32); 368 return MEMTX_OK; 369 case GICR_PENDBASER + 4: 370 *data = extract64(cs->gicr_pendbaser, 32, 32); 371 return MEMTX_OK; 372 case GICR_IGROUPR0: 373 if (!attrs.secure && !(cs->gic->gicd_ctlr & GICD_CTLR_DS)) { 374 *data = 0; 375 return MEMTX_OK; 376 } 377 *data = cs->gicr_igroupr0; 378 return MEMTX_OK; 379 case GICR_ISENABLER0: 380 case GICR_ICENABLER0: 381 *data = gicr_read_bitmap_reg(cs, attrs, cs->gicr_ienabler0); 382 return MEMTX_OK; 383 case GICR_ISPENDR0: 384 case GICR_ICPENDR0: 385 { 386 /* The pending register reads as the logical OR of the pending 387 * latch and the input line level for level-triggered interrupts. 388 */ 389 uint32_t val = cs->gicr_ipendr0 | (~cs->edge_trigger & cs->level); 390 *data = gicr_read_bitmap_reg(cs, attrs, val); 391 return MEMTX_OK; 392 } 393 case GICR_ISACTIVER0: 394 case GICR_ICACTIVER0: 395 *data = gicr_read_bitmap_reg(cs, attrs, cs->gicr_iactiver0); 396 return MEMTX_OK; 397 case GICR_IPRIORITYR ... GICR_IPRIORITYR + 0x1f: 398 { 399 int i, irq = offset - GICR_IPRIORITYR; 400 uint32_t value = 0; 401 402 for (i = irq + 3; i >= irq; i--) { 403 value <<= 8; 404 value |= gicr_read_ipriorityr(cs, attrs, i); 405 } 406 *data = value; 407 return MEMTX_OK; 408 } 409 case GICR_ICFGR0: 410 case GICR_ICFGR1: 411 { 412 /* Our edge_trigger bitmap is one bit per irq; take the correct 413 * half of it, and spread it out into the odd bits. 414 */ 415 uint32_t value; 416 417 value = cs->edge_trigger & mask_group(cs, attrs); 418 value = extract32(value, (offset == GICR_ICFGR1) ? 16 : 0, 16); 419 value = half_shuffle32(value) << 1; 420 *data = value; 421 return MEMTX_OK; 422 } 423 case GICR_IGRPMODR0: 424 if ((cs->gic->gicd_ctlr & GICD_CTLR_DS) || !attrs.secure) { 425 /* RAZ/WI if security disabled, or if 426 * security enabled and this is an NS access 427 */ 428 *data = 0; 429 return MEMTX_OK; 430 } 431 *data = cs->gicr_igrpmodr0; 432 return MEMTX_OK; 433 case GICR_NSACR: 434 if ((cs->gic->gicd_ctlr & GICD_CTLR_DS) || !attrs.secure) { 435 /* RAZ/WI if security disabled, or if 436 * security enabled and this is an NS access 437 */ 438 *data = 0; 439 return MEMTX_OK; 440 } 441 *data = cs->gicr_nsacr; 442 return MEMTX_OK; 443 case GICR_IDREGS ... GICR_IDREGS + 0x2f: 444 *data = gicv3_idreg(cs->gic, offset - GICR_IDREGS, GICV3_PIDR0_REDIST); 445 return MEMTX_OK; 446 /* 447 * VLPI frame registers. We don't need a version check for 448 * VPROPBASER and VPENDBASER because gicv3_redist_size() will 449 * prevent pre-v4 GIC from passing us offsets this high. 450 */ 451 case GICR_VPROPBASER: 452 *data = extract64(cs->gicr_vpropbaser, 0, 32); 453 return MEMTX_OK; 454 case GICR_VPROPBASER + 4: 455 *data = extract64(cs->gicr_vpropbaser, 32, 32); 456 return MEMTX_OK; 457 case GICR_VPENDBASER: 458 *data = extract64(cs->gicr_vpendbaser, 0, 32); 459 return MEMTX_OK; 460 case GICR_VPENDBASER + 4: 461 *data = extract64(cs->gicr_vpendbaser, 32, 32); 462 return MEMTX_OK; 463 default: 464 return MEMTX_ERROR; 465 } 466 } 467 468 static MemTxResult gicr_writel(GICv3CPUState *cs, hwaddr offset, 469 uint64_t value, MemTxAttrs attrs) 470 { 471 switch (offset) { 472 case GICR_CTLR: 473 /* For our implementation, GICR_TYPER.DPGS is 0 and so all 474 * the DPG bits are RAZ/WI. We don't do anything asynchronously, 475 * so UWP and RWP are RAZ/WI. GICR_TYPER.LPIS is 1 (we 476 * implement LPIs) so Enable_LPIs is programmable. 477 */ 478 if (cs->gicr_typer & GICR_TYPER_PLPIS) { 479 if (value & GICR_CTLR_ENABLE_LPIS) { 480 cs->gicr_ctlr |= GICR_CTLR_ENABLE_LPIS; 481 /* Check for any pending interr in pending table */ 482 gicv3_redist_update_lpi(cs); 483 } else { 484 cs->gicr_ctlr &= ~GICR_CTLR_ENABLE_LPIS; 485 /* cs->hppi might have been an LPI; recalculate */ 486 gicv3_redist_update(cs); 487 } 488 } 489 return MEMTX_OK; 490 case GICR_STATUSR: 491 /* RAZ/WI for our implementation */ 492 return MEMTX_OK; 493 case GICR_WAKER: 494 /* Only the ProcessorSleep bit is writable. When the guest sets 495 * it, it requests that we transition the channel between the 496 * redistributor and the cpu interface to quiescent, and that 497 * we set the ChildrenAsleep bit once the inteface has reached the 498 * quiescent state. 499 * Setting the ProcessorSleep to 0 reverses the quiescing, and 500 * ChildrenAsleep is cleared once the transition is complete. 501 * Since our interface is not asynchronous, we complete these 502 * transitions instantaneously, so we set ChildrenAsleep to the 503 * same value as ProcessorSleep here. 504 */ 505 value &= GICR_WAKER_ProcessorSleep; 506 if (value & GICR_WAKER_ProcessorSleep) { 507 value |= GICR_WAKER_ChildrenAsleep; 508 } 509 cs->gicr_waker = value; 510 return MEMTX_OK; 511 case GICR_PROPBASER: 512 cs->gicr_propbaser = deposit64(cs->gicr_propbaser, 0, 32, value); 513 return MEMTX_OK; 514 case GICR_PROPBASER + 4: 515 cs->gicr_propbaser = deposit64(cs->gicr_propbaser, 32, 32, value); 516 return MEMTX_OK; 517 case GICR_PENDBASER: 518 cs->gicr_pendbaser = deposit64(cs->gicr_pendbaser, 0, 32, value); 519 return MEMTX_OK; 520 case GICR_PENDBASER + 4: 521 cs->gicr_pendbaser = deposit64(cs->gicr_pendbaser, 32, 32, value); 522 return MEMTX_OK; 523 case GICR_IGROUPR0: 524 if (!attrs.secure && !(cs->gic->gicd_ctlr & GICD_CTLR_DS)) { 525 return MEMTX_OK; 526 } 527 cs->gicr_igroupr0 = value; 528 gicv3_redist_update(cs); 529 return MEMTX_OK; 530 case GICR_ISENABLER0: 531 gicr_write_set_bitmap_reg(cs, attrs, &cs->gicr_ienabler0, value); 532 return MEMTX_OK; 533 case GICR_ICENABLER0: 534 gicr_write_clear_bitmap_reg(cs, attrs, &cs->gicr_ienabler0, value); 535 return MEMTX_OK; 536 case GICR_ISPENDR0: 537 gicr_write_set_bitmap_reg(cs, attrs, &cs->gicr_ipendr0, value); 538 return MEMTX_OK; 539 case GICR_ICPENDR0: 540 gicr_write_clear_bitmap_reg(cs, attrs, &cs->gicr_ipendr0, value); 541 return MEMTX_OK; 542 case GICR_ISACTIVER0: 543 gicr_write_set_bitmap_reg(cs, attrs, &cs->gicr_iactiver0, value); 544 return MEMTX_OK; 545 case GICR_ICACTIVER0: 546 gicr_write_clear_bitmap_reg(cs, attrs, &cs->gicr_iactiver0, value); 547 return MEMTX_OK; 548 case GICR_IPRIORITYR ... GICR_IPRIORITYR + 0x1f: 549 { 550 int i, irq = offset - GICR_IPRIORITYR; 551 552 for (i = irq; i < irq + 4; i++, value >>= 8) { 553 gicr_write_ipriorityr(cs, attrs, i, value); 554 } 555 gicv3_redist_update(cs); 556 return MEMTX_OK; 557 } 558 case GICR_ICFGR0: 559 /* Register is all RAZ/WI or RAO/WI bits */ 560 return MEMTX_OK; 561 case GICR_ICFGR1: 562 { 563 uint32_t mask; 564 565 /* Since our edge_trigger bitmap is one bit per irq, our input 566 * 32-bits will compress down into 16 bits which we need 567 * to write into the bitmap. 568 */ 569 value = half_unshuffle32(value >> 1) << 16; 570 mask = mask_group(cs, attrs) & 0xffff0000U; 571 572 cs->edge_trigger &= ~mask; 573 cs->edge_trigger |= (value & mask); 574 575 gicv3_redist_update(cs); 576 return MEMTX_OK; 577 } 578 case GICR_IGRPMODR0: 579 if ((cs->gic->gicd_ctlr & GICD_CTLR_DS) || !attrs.secure) { 580 /* RAZ/WI if security disabled, or if 581 * security enabled and this is an NS access 582 */ 583 return MEMTX_OK; 584 } 585 cs->gicr_igrpmodr0 = value; 586 gicv3_redist_update(cs); 587 return MEMTX_OK; 588 case GICR_NSACR: 589 if ((cs->gic->gicd_ctlr & GICD_CTLR_DS) || !attrs.secure) { 590 /* RAZ/WI if security disabled, or if 591 * security enabled and this is an NS access 592 */ 593 return MEMTX_OK; 594 } 595 cs->gicr_nsacr = value; 596 /* no update required as this only affects access permission checks */ 597 return MEMTX_OK; 598 case GICR_IIDR: 599 case GICR_TYPER: 600 case GICR_IDREGS ... GICR_IDREGS + 0x2f: 601 /* RO registers, ignore the write */ 602 qemu_log_mask(LOG_GUEST_ERROR, 603 "%s: invalid guest write to RO register at offset " 604 TARGET_FMT_plx "\n", __func__, offset); 605 return MEMTX_OK; 606 /* 607 * VLPI frame registers. We don't need a version check for 608 * VPROPBASER and VPENDBASER because gicv3_redist_size() will 609 * prevent pre-v4 GIC from passing us offsets this high. 610 */ 611 case GICR_VPROPBASER: 612 cs->gicr_vpropbaser = deposit64(cs->gicr_vpropbaser, 0, 32, value); 613 return MEMTX_OK; 614 case GICR_VPROPBASER + 4: 615 cs->gicr_vpropbaser = deposit64(cs->gicr_vpropbaser, 32, 32, value); 616 return MEMTX_OK; 617 case GICR_VPENDBASER: 618 gicr_write_vpendbaser(cs, deposit64(cs->gicr_vpendbaser, 0, 32, value)); 619 return MEMTX_OK; 620 case GICR_VPENDBASER + 4: 621 gicr_write_vpendbaser(cs, deposit64(cs->gicr_vpendbaser, 32, 32, value)); 622 return MEMTX_OK; 623 default: 624 return MEMTX_ERROR; 625 } 626 } 627 628 static MemTxResult gicr_readll(GICv3CPUState *cs, hwaddr offset, 629 uint64_t *data, MemTxAttrs attrs) 630 { 631 switch (offset) { 632 case GICR_TYPER: 633 *data = cs->gicr_typer; 634 return MEMTX_OK; 635 case GICR_PROPBASER: 636 *data = cs->gicr_propbaser; 637 return MEMTX_OK; 638 case GICR_PENDBASER: 639 *data = cs->gicr_pendbaser; 640 return MEMTX_OK; 641 /* 642 * VLPI frame registers. We don't need a version check for 643 * VPROPBASER and VPENDBASER because gicv3_redist_size() will 644 * prevent pre-v4 GIC from passing us offsets this high. 645 */ 646 case GICR_VPROPBASER: 647 *data = cs->gicr_vpropbaser; 648 return MEMTX_OK; 649 case GICR_VPENDBASER: 650 *data = cs->gicr_vpendbaser; 651 return MEMTX_OK; 652 default: 653 return MEMTX_ERROR; 654 } 655 } 656 657 static MemTxResult gicr_writell(GICv3CPUState *cs, hwaddr offset, 658 uint64_t value, MemTxAttrs attrs) 659 { 660 switch (offset) { 661 case GICR_PROPBASER: 662 cs->gicr_propbaser = value; 663 return MEMTX_OK; 664 case GICR_PENDBASER: 665 cs->gicr_pendbaser = value; 666 return MEMTX_OK; 667 case GICR_TYPER: 668 /* RO register, ignore the write */ 669 qemu_log_mask(LOG_GUEST_ERROR, 670 "%s: invalid guest write to RO register at offset " 671 TARGET_FMT_plx "\n", __func__, offset); 672 return MEMTX_OK; 673 /* 674 * VLPI frame registers. We don't need a version check for 675 * VPROPBASER and VPENDBASER because gicv3_redist_size() will 676 * prevent pre-v4 GIC from passing us offsets this high. 677 */ 678 case GICR_VPROPBASER: 679 cs->gicr_vpropbaser = value; 680 return MEMTX_OK; 681 case GICR_VPENDBASER: 682 gicr_write_vpendbaser(cs, value); 683 return MEMTX_OK; 684 default: 685 return MEMTX_ERROR; 686 } 687 } 688 689 MemTxResult gicv3_redist_read(void *opaque, hwaddr offset, uint64_t *data, 690 unsigned size, MemTxAttrs attrs) 691 { 692 GICv3RedistRegion *region = opaque; 693 GICv3State *s = region->gic; 694 GICv3CPUState *cs; 695 MemTxResult r; 696 int cpuidx; 697 698 assert((offset & (size - 1)) == 0); 699 700 /* 701 * There are (for GICv3) two 64K redistributor pages per CPU. 702 * In some cases the redistributor pages for all CPUs are not 703 * contiguous (eg on the virt board they are split into two 704 * parts if there are too many CPUs to all fit in the same place 705 * in the memory map); if so then the GIC has multiple MemoryRegions 706 * for the redistributors. 707 */ 708 cpuidx = region->cpuidx + offset / gicv3_redist_size(s); 709 offset %= gicv3_redist_size(s); 710 711 cs = &s->cpu[cpuidx]; 712 713 switch (size) { 714 case 1: 715 r = gicr_readb(cs, offset, data, attrs); 716 break; 717 case 4: 718 r = gicr_readl(cs, offset, data, attrs); 719 break; 720 case 8: 721 r = gicr_readll(cs, offset, data, attrs); 722 break; 723 default: 724 r = MEMTX_ERROR; 725 break; 726 } 727 728 if (r != MEMTX_OK) { 729 qemu_log_mask(LOG_GUEST_ERROR, 730 "%s: invalid guest read at offset " TARGET_FMT_plx 731 " size %u\n", __func__, offset, size); 732 trace_gicv3_redist_badread(gicv3_redist_affid(cs), offset, 733 size, attrs.secure); 734 /* The spec requires that reserved registers are RAZ/WI; 735 * so use MEMTX_ERROR returns from leaf functions as a way to 736 * trigger the guest-error logging but don't return it to 737 * the caller, or we'll cause a spurious guest data abort. 738 */ 739 r = MEMTX_OK; 740 *data = 0; 741 } else { 742 trace_gicv3_redist_read(gicv3_redist_affid(cs), offset, *data, 743 size, attrs.secure); 744 } 745 return r; 746 } 747 748 MemTxResult gicv3_redist_write(void *opaque, hwaddr offset, uint64_t data, 749 unsigned size, MemTxAttrs attrs) 750 { 751 GICv3RedistRegion *region = opaque; 752 GICv3State *s = region->gic; 753 GICv3CPUState *cs; 754 MemTxResult r; 755 int cpuidx; 756 757 assert((offset & (size - 1)) == 0); 758 759 /* 760 * There are (for GICv3) two 64K redistributor pages per CPU. 761 * In some cases the redistributor pages for all CPUs are not 762 * contiguous (eg on the virt board they are split into two 763 * parts if there are too many CPUs to all fit in the same place 764 * in the memory map); if so then the GIC has multiple MemoryRegions 765 * for the redistributors. 766 */ 767 cpuidx = region->cpuidx + offset / gicv3_redist_size(s); 768 offset %= gicv3_redist_size(s); 769 770 cs = &s->cpu[cpuidx]; 771 772 switch (size) { 773 case 1: 774 r = gicr_writeb(cs, offset, data, attrs); 775 break; 776 case 4: 777 r = gicr_writel(cs, offset, data, attrs); 778 break; 779 case 8: 780 r = gicr_writell(cs, offset, data, attrs); 781 break; 782 default: 783 r = MEMTX_ERROR; 784 break; 785 } 786 787 if (r != MEMTX_OK) { 788 qemu_log_mask(LOG_GUEST_ERROR, 789 "%s: invalid guest write at offset " TARGET_FMT_plx 790 " size %u\n", __func__, offset, size); 791 trace_gicv3_redist_badwrite(gicv3_redist_affid(cs), offset, data, 792 size, attrs.secure); 793 /* The spec requires that reserved registers are RAZ/WI; 794 * so use MEMTX_ERROR returns from leaf functions as a way to 795 * trigger the guest-error logging but don't return it to 796 * the caller, or we'll cause a spurious guest data abort. 797 */ 798 r = MEMTX_OK; 799 } else { 800 trace_gicv3_redist_write(gicv3_redist_affid(cs), offset, data, 801 size, attrs.secure); 802 } 803 return r; 804 } 805 806 static void gicv3_redist_check_lpi_priority(GICv3CPUState *cs, int irq) 807 { 808 uint64_t lpict_baddr = cs->gicr_propbaser & R_GICR_PROPBASER_PHYADDR_MASK; 809 810 update_for_one_lpi(cs, irq, lpict_baddr, 811 cs->gic->gicd_ctlr & GICD_CTLR_DS, 812 &cs->hpplpi); 813 } 814 815 void gicv3_redist_update_lpi_only(GICv3CPUState *cs) 816 { 817 /* 818 * This function scans the LPI pending table and for each pending 819 * LPI, reads the corresponding entry from LPI configuration table 820 * to extract the priority info and determine if the current LPI 821 * priority is lower than the last computed high priority lpi interrupt. 822 * If yes, replace current LPI as the new high priority lpi interrupt. 823 */ 824 uint64_t lpipt_baddr, lpict_baddr; 825 uint64_t idbits; 826 827 idbits = MIN(FIELD_EX64(cs->gicr_propbaser, GICR_PROPBASER, IDBITS), 828 GICD_TYPER_IDBITS); 829 830 if (!(cs->gicr_ctlr & GICR_CTLR_ENABLE_LPIS)) { 831 return; 832 } 833 834 lpipt_baddr = cs->gicr_pendbaser & R_GICR_PENDBASER_PHYADDR_MASK; 835 lpict_baddr = cs->gicr_propbaser & R_GICR_PROPBASER_PHYADDR_MASK; 836 837 update_for_all_lpis(cs, lpipt_baddr, lpict_baddr, idbits, 838 cs->gic->gicd_ctlr & GICD_CTLR_DS, &cs->hpplpi); 839 } 840 841 void gicv3_redist_update_lpi(GICv3CPUState *cs) 842 { 843 gicv3_redist_update_lpi_only(cs); 844 gicv3_redist_update(cs); 845 } 846 847 void gicv3_redist_lpi_pending(GICv3CPUState *cs, int irq, int level) 848 { 849 /* 850 * This function updates the pending bit in lpi pending table for 851 * the irq being activated or deactivated. 852 */ 853 uint64_t lpipt_baddr; 854 855 lpipt_baddr = cs->gicr_pendbaser & R_GICR_PENDBASER_PHYADDR_MASK; 856 if (!set_pending_table_bit(cs, lpipt_baddr, irq, level)) { 857 /* no change in the value of pending bit, return */ 858 return; 859 } 860 861 /* 862 * check if this LPI is better than the current hpplpi, if yes 863 * just set hpplpi.prio and .irq without doing a full rescan 864 */ 865 if (level) { 866 gicv3_redist_check_lpi_priority(cs, irq); 867 gicv3_redist_update(cs); 868 } else { 869 if (irq == cs->hpplpi.irq) { 870 gicv3_redist_update_lpi(cs); 871 } 872 } 873 } 874 875 void gicv3_redist_process_lpi(GICv3CPUState *cs, int irq, int level) 876 { 877 uint64_t idbits; 878 879 idbits = MIN(FIELD_EX64(cs->gicr_propbaser, GICR_PROPBASER, IDBITS), 880 GICD_TYPER_IDBITS); 881 882 if (!(cs->gicr_ctlr & GICR_CTLR_ENABLE_LPIS) || 883 (irq > (1ULL << (idbits + 1)) - 1) || irq < GICV3_LPI_INTID_START) { 884 return; 885 } 886 887 /* set/clear the pending bit for this irq */ 888 gicv3_redist_lpi_pending(cs, irq, level); 889 } 890 891 void gicv3_redist_inv_lpi(GICv3CPUState *cs, int irq) 892 { 893 /* 894 * The only cached information for LPIs we have is the HPPLPI. 895 * We could be cleverer about identifying when we don't need 896 * to do a full rescan of the pending table, but until we find 897 * this is a performance issue, just always recalculate. 898 */ 899 gicv3_redist_update_lpi(cs); 900 } 901 902 void gicv3_redist_mov_lpi(GICv3CPUState *src, GICv3CPUState *dest, int irq) 903 { 904 /* 905 * Move the specified LPI's pending state from the source redistributor 906 * to the destination. 907 * 908 * If LPIs are disabled on dest this is CONSTRAINED UNPREDICTABLE: 909 * we choose to NOP. If LPIs are disabled on source there's nothing 910 * to be transferred anyway. 911 */ 912 uint64_t idbits; 913 uint32_t pendt_size; 914 uint64_t src_baddr; 915 916 if (!(src->gicr_ctlr & GICR_CTLR_ENABLE_LPIS) || 917 !(dest->gicr_ctlr & GICR_CTLR_ENABLE_LPIS)) { 918 return; 919 } 920 921 idbits = MIN(FIELD_EX64(src->gicr_propbaser, GICR_PROPBASER, IDBITS), 922 GICD_TYPER_IDBITS); 923 idbits = MIN(FIELD_EX64(dest->gicr_propbaser, GICR_PROPBASER, IDBITS), 924 idbits); 925 926 pendt_size = 1ULL << (idbits + 1); 927 if ((irq / 8) >= pendt_size) { 928 return; 929 } 930 931 src_baddr = src->gicr_pendbaser & R_GICR_PENDBASER_PHYADDR_MASK; 932 933 if (!set_pending_table_bit(src, src_baddr, irq, 0)) { 934 /* Not pending on source, nothing to do */ 935 return; 936 } 937 if (irq == src->hpplpi.irq) { 938 /* 939 * We just made this LPI not-pending so only need to update 940 * if it was previously the highest priority pending LPI 941 */ 942 gicv3_redist_update_lpi(src); 943 } 944 /* Mark it pending on the destination */ 945 gicv3_redist_lpi_pending(dest, irq, 1); 946 } 947 948 void gicv3_redist_movall_lpis(GICv3CPUState *src, GICv3CPUState *dest) 949 { 950 /* 951 * We must move all pending LPIs from the source redistributor 952 * to the destination. That is, for every pending LPI X on 953 * src, we must set it not-pending on src and pending on dest. 954 * LPIs that are already pending on dest are not cleared. 955 * 956 * If LPIs are disabled on dest this is CONSTRAINED UNPREDICTABLE: 957 * we choose to NOP. If LPIs are disabled on source there's nothing 958 * to be transferred anyway. 959 */ 960 AddressSpace *as = &src->gic->dma_as; 961 uint64_t idbits; 962 uint32_t pendt_size; 963 uint64_t src_baddr, dest_baddr; 964 int i; 965 966 if (!(src->gicr_ctlr & GICR_CTLR_ENABLE_LPIS) || 967 !(dest->gicr_ctlr & GICR_CTLR_ENABLE_LPIS)) { 968 return; 969 } 970 971 idbits = MIN(FIELD_EX64(src->gicr_propbaser, GICR_PROPBASER, IDBITS), 972 GICD_TYPER_IDBITS); 973 idbits = MIN(FIELD_EX64(dest->gicr_propbaser, GICR_PROPBASER, IDBITS), 974 idbits); 975 976 pendt_size = 1ULL << (idbits + 1); 977 src_baddr = src->gicr_pendbaser & R_GICR_PENDBASER_PHYADDR_MASK; 978 dest_baddr = dest->gicr_pendbaser & R_GICR_PENDBASER_PHYADDR_MASK; 979 980 for (i = GICV3_LPI_INTID_START / 8; i < pendt_size / 8; i++) { 981 uint8_t src_pend, dest_pend; 982 983 address_space_read(as, src_baddr + i, MEMTXATTRS_UNSPECIFIED, 984 &src_pend, sizeof(src_pend)); 985 if (!src_pend) { 986 continue; 987 } 988 address_space_read(as, dest_baddr + i, MEMTXATTRS_UNSPECIFIED, 989 &dest_pend, sizeof(dest_pend)); 990 dest_pend |= src_pend; 991 src_pend = 0; 992 address_space_write(as, src_baddr + i, MEMTXATTRS_UNSPECIFIED, 993 &src_pend, sizeof(src_pend)); 994 address_space_write(as, dest_baddr + i, MEMTXATTRS_UNSPECIFIED, 995 &dest_pend, sizeof(dest_pend)); 996 } 997 998 gicv3_redist_update_lpi(src); 999 gicv3_redist_update_lpi(dest); 1000 } 1001 1002 void gicv3_redist_vlpi_pending(GICv3CPUState *cs, int irq, int level) 1003 { 1004 /* 1005 * Change the pending state of the specified vLPI. 1006 * Unlike gicv3_redist_process_vlpi(), we know here that the 1007 * vCPU is definitely resident on this redistributor, and that 1008 * the irq is in range. 1009 */ 1010 uint64_t vptbase, ctbase; 1011 1012 vptbase = FIELD_EX64(cs->gicr_vpendbaser, GICR_VPENDBASER, PHYADDR) << 16; 1013 1014 if (set_pending_table_bit(cs, vptbase, irq, level)) { 1015 if (level) { 1016 /* Check whether this vLPI is now the best */ 1017 ctbase = cs->gicr_vpropbaser & R_GICR_VPROPBASER_PHYADDR_MASK; 1018 update_for_one_lpi(cs, irq, ctbase, true, &cs->hppvlpi); 1019 gicv3_cpuif_virt_irq_fiq_update(cs); 1020 } else { 1021 /* Only need to recalculate if this was previously the best vLPI */ 1022 if (irq == cs->hppvlpi.irq) { 1023 gicv3_redist_update_vlpi(cs); 1024 } 1025 } 1026 } 1027 } 1028 1029 void gicv3_redist_process_vlpi(GICv3CPUState *cs, int irq, uint64_t vptaddr, 1030 int doorbell, int level) 1031 { 1032 bool bit_changed; 1033 bool resident = vcpu_resident(cs, vptaddr); 1034 uint64_t ctbase; 1035 1036 if (resident) { 1037 uint32_t idbits = FIELD_EX64(cs->gicr_vpropbaser, GICR_VPROPBASER, IDBITS); 1038 if (irq >= (1ULL << (idbits + 1))) { 1039 return; 1040 } 1041 } 1042 1043 bit_changed = set_pending_table_bit(cs, vptaddr, irq, level); 1044 if (resident && bit_changed) { 1045 if (level) { 1046 /* Check whether this vLPI is now the best */ 1047 ctbase = cs->gicr_vpropbaser & R_GICR_VPROPBASER_PHYADDR_MASK; 1048 update_for_one_lpi(cs, irq, ctbase, true, &cs->hppvlpi); 1049 gicv3_cpuif_virt_irq_fiq_update(cs); 1050 } else { 1051 /* Only need to recalculate if this was previously the best vLPI */ 1052 if (irq == cs->hppvlpi.irq) { 1053 gicv3_redist_update_vlpi(cs); 1054 } 1055 } 1056 } 1057 1058 if (!resident && level && doorbell != INTID_SPURIOUS && 1059 (cs->gicr_ctlr & GICR_CTLR_ENABLE_LPIS)) { 1060 /* vCPU is not currently resident: ring the doorbell */ 1061 gicv3_redist_process_lpi(cs, doorbell, 1); 1062 } 1063 } 1064 1065 void gicv3_redist_mov_vlpi(GICv3CPUState *src, uint64_t src_vptaddr, 1066 GICv3CPUState *dest, uint64_t dest_vptaddr, 1067 int irq, int doorbell) 1068 { 1069 /* 1070 * Move the specified vLPI's pending state from the source redistributor 1071 * to the destination. 1072 */ 1073 if (!set_pending_table_bit(src, src_vptaddr, irq, 0)) { 1074 /* Not pending on source, nothing to do */ 1075 return; 1076 } 1077 if (vcpu_resident(src, src_vptaddr) && irq == src->hppvlpi.irq) { 1078 /* 1079 * Update src's cached highest-priority pending vLPI if we just made 1080 * it not-pending 1081 */ 1082 gicv3_redist_update_vlpi(src); 1083 } 1084 /* 1085 * Mark the vLPI pending on the destination (ringing the doorbell 1086 * if the vCPU isn't resident) 1087 */ 1088 gicv3_redist_process_vlpi(dest, irq, dest_vptaddr, doorbell, irq); 1089 } 1090 1091 void gicv3_redist_vinvall(GICv3CPUState *cs, uint64_t vptaddr) 1092 { 1093 if (!vcpu_resident(cs, vptaddr)) { 1094 /* We don't have anything cached if the vCPU isn't resident */ 1095 return; 1096 } 1097 1098 /* Otherwise, our only cached information is the HPPVLPI info */ 1099 gicv3_redist_update_vlpi(cs); 1100 } 1101 1102 void gicv3_redist_inv_vlpi(GICv3CPUState *cs, int irq, uint64_t vptaddr) 1103 { 1104 /* 1105 * The only cached information for LPIs we have is the HPPLPI. 1106 * We could be cleverer about identifying when we don't need 1107 * to do a full rescan of the pending table, but until we find 1108 * this is a performance issue, just always recalculate. 1109 */ 1110 gicv3_redist_vinvall(cs, vptaddr); 1111 } 1112 1113 void gicv3_redist_set_irq(GICv3CPUState *cs, int irq, int level) 1114 { 1115 /* Update redistributor state for a change in an external PPI input line */ 1116 if (level == extract32(cs->level, irq, 1)) { 1117 return; 1118 } 1119 1120 trace_gicv3_redist_set_irq(gicv3_redist_affid(cs), irq, level); 1121 1122 cs->level = deposit32(cs->level, irq, 1, level); 1123 1124 if (level) { 1125 /* 0->1 edges latch the pending bit for edge-triggered interrupts */ 1126 if (extract32(cs->edge_trigger, irq, 1)) { 1127 cs->gicr_ipendr0 = deposit32(cs->gicr_ipendr0, irq, 1, 1); 1128 } 1129 } 1130 1131 gicv3_redist_update(cs); 1132 } 1133 1134 void gicv3_redist_send_sgi(GICv3CPUState *cs, int grp, int irq, bool ns) 1135 { 1136 /* Update redistributor state for a generated SGI */ 1137 int irqgrp = gicv3_irq_group(cs->gic, cs, irq); 1138 1139 /* If we are asked for a Secure Group 1 SGI and it's actually 1140 * configured as Secure Group 0 this is OK (subject to the usual 1141 * NSACR checks). 1142 */ 1143 if (grp == GICV3_G1 && irqgrp == GICV3_G0) { 1144 grp = GICV3_G0; 1145 } 1146 1147 if (grp != irqgrp) { 1148 return; 1149 } 1150 1151 if (ns && !(cs->gic->gicd_ctlr & GICD_CTLR_DS)) { 1152 /* If security is enabled we must test the NSACR bits */ 1153 int nsaccess = gicr_ns_access(cs, irq); 1154 1155 if ((irqgrp == GICV3_G0 && nsaccess < 1) || 1156 (irqgrp == GICV3_G1 && nsaccess < 2)) { 1157 return; 1158 } 1159 } 1160 1161 /* OK, we can accept the SGI */ 1162 trace_gicv3_redist_send_sgi(gicv3_redist_affid(cs), irq); 1163 cs->gicr_ipendr0 = deposit32(cs->gicr_ipendr0, irq, 1, 1); 1164 gicv3_redist_update(cs); 1165 }