hypervisor/arch/arm/gic-v3.c

   1 /*
   2  * Jailhouse, a Linux-based partitioning hypervisor
   3  *
   4  * Copyright (c) ARM Limited, 2014
   5  *
   6  * Authors:
   7  *  Jean-Philippe Brucker <jean-philippe.brucker@arm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  */
  12
  13 #include <jailhouse/control.h>
  14 #include <jailhouse/mmio.h>
  15 #include <jailhouse/printk.h>
  16 #include <jailhouse/processor.h>
  17 #include <jailhouse/types.h>
  18 #include <asm/control.h>
  19 #include <asm/gic_common.h>
  20 #include <asm/irqchip.h>
  21 #include <asm/platform.h>
  22 #include <asm/setup.h>
  23 #include <asm/traps.h>
  24
  25 /*
  26  * This implementation assumes that the kernel driver already initialised most
  27  * of the GIC.
  28  * There is almost no instruction barrier, since IRQs are always disabled in the
  29  * hyp, and ERET serves as the context synchronization event.
  30  */
  31
  32 static unsigned int gic_num_lr;
  33 static unsigned int gic_num_priority_bits;
  34 static u32 gic_version;
  35
  36 extern void *gicd_base;
  37 extern unsigned int gicd_size;
  38 static void *gicr_base;
  39 static unsigned int gicr_size;
  40
  41 static int gic_init(void)
  42 {
  43         int err;
  44
  45         /* FIXME: parse a dt */
  46         gicr_base = GICR_BASE;
  47         gicr_size = GICR_SIZE;
  48
  49         /* Let the per-cpu code access the redistributors */
  50         err = arch_map_device(gicr_base, gicr_base, gicr_size);
  51
  52         return err;
  53 }
  54
  55 static void gic_clear_pending_irqs(void)
  56 {
  57         unsigned int n;
  58
  59         /* Clear list registers. */
  60         for (n = 0; n < gic_num_lr; n++)
  61                 gic_write_lr(n, 0);
  62
  63         /* Clear active priority bits */
  64         if (gic_num_priority_bits >= 5)
  65                 arm_write_sysreg(ICH_AP1R0_EL2, 0);
  66         if (gic_num_priority_bits >= 6)
  67                 arm_write_sysreg(ICH_AP1R1_EL2, 0);
  68         if (gic_num_priority_bits > 6) {
  69                 arm_write_sysreg(ICH_AP1R2_EL2, 0);
  70                 arm_write_sysreg(ICH_AP1R3_EL2, 0);
  71         }
  72 }
  73
  74 static int gic_cpu_reset(struct per_cpu *cpu_data, bool is_shutdown)
  75 {
  76         unsigned int i;
  77         void *gicr = cpu_data->gicr_base;
  78         unsigned long active;
  79         bool root_shutdown = is_shutdown && (cpu_data->cell == &root_cell);
  80         u32 ich_vmcr;
  81
  82         if (gicr == 0)
  83                 return -ENODEV;
  84
  85         gic_clear_pending_irqs();
  86
  87         gicr += GICR_SGI_BASE;
  88         active = mmio_read32(gicr + GICR_ICACTIVER);
  89         /* Deactivate all active PPIs */
  90         for (i = 16; i < 32; i++) {
  91                 if (test_bit(i, &active))
  92                         arm_write_sysreg(ICC_DIR_EL1, i);
  93         }
  94
  95         /*
  96          * Disable all PPIs, ensure IPIs are enabled.
  97          * On shutdown, the root cell expects to find all its PPIs still enabled
  98          * when returning to the driver.
  99          */
 100         if (!root_shutdown)
 101                 mmio_write32(gicr + GICR_ICENABLER, 0xffff0000);
 102         mmio_write32(gicr + GICR_ISENABLER, 0x0000ffff);
 103
 104         if (root_shutdown) {
 105                 /* Restore the root config */
 106                 arm_read_sysreg(ICH_VMCR_EL2, ich_vmcr);
 107
 108                 if (!(ich_vmcr & ICH_VMCR_VEOIM)) {
 109                         u32 icc_ctlr;
 110                         arm_read_sysreg(ICC_CTLR_EL1, icc_ctlr);
 111                         icc_ctlr &= ~ICC_CTLR_EOImode;
 112                         arm_write_sysreg(ICC_CTLR_EL1, icc_ctlr);
 113                 }
 114
 115                 arm_write_sysreg(ICH_HCR_EL2, 0);
 116         }
 117
 118         arm_write_sysreg(ICH_VMCR_EL2, 0);
 119
 120         return 0;
 121 }
 122
 123 static int gic_cpu_init(struct per_cpu *cpu_data)
 124 {
 125         u64 typer;
 126         u32 pidr;
 127         u32 cell_icc_ctlr, cell_icc_pmr, cell_icc_igrpen1;
 128         u32 ich_vtr;
 129         u32 ich_vmcr;
 130         void *redist_base = gicr_base;
 131
 132         /* Find redistributor */
 133         do {
 134                 pidr = mmio_read32(redist_base + GICR_PIDR2);
 135                 gic_version = GICR_PIDR2_ARCH(pidr);
 136                 if (gic_version != 3 && gic_version != 4)
 137                         break;
 138
 139                 typer = mmio_read64(redist_base + GICR_TYPER);
 140                 if ((typer >> 32) == cpu_data->cpu_id) {
 141                         cpu_data->gicr_base = redist_base;
 142                         break;
 143                 }
 144
 145                 redist_base += 0x20000;
 146                 if (gic_version == 4)
 147                         redist_base += 0x20000;
 148         } while (!(typer & GICR_TYPER_Last));
 149
 150         if (cpu_data->gicr_base == 0) {
 151                 printk("GIC: No redist found for CPU%d\n", cpu_data->cpu_id);
 152                 return -ENODEV;
 153         }
 154
 155         /* Ensure all IPIs are enabled */
 156         mmio_write32(redist_base + GICR_SGI_BASE + GICR_ISENABLER, 0x0000ffff);
 157
 158         /*
 159          * Set EOIMode to 1
 160          * This allow to drop the priority of level-triggered interrupts without
 161          * deactivating them, and thus ensure that they won't be immediately
 162          * re-triggered. (e.g. timer)
 163          * They can then be injected into the guest using the LR.HW bit, and
 164          * will be deactivated once the guest does an EOI after handling the
 165          * interrupt source.
 166          */
 167         arm_read_sysreg(ICC_CTLR_EL1, cell_icc_ctlr);
 168         arm_write_sysreg(ICC_CTLR_EL1, ICC_CTLR_EOImode);
 169
 170         arm_read_sysreg(ICC_PMR_EL1, cell_icc_pmr);
 171         arm_write_sysreg(ICC_PMR_EL1, ICC_PMR_DEFAULT);
 172
 173         arm_read_sysreg(ICC_IGRPEN1_EL1, cell_icc_igrpen1);
 174         arm_write_sysreg(ICC_IGRPEN1_EL1, ICC_IGRPEN1_EN);
 175
 176         arm_read_sysreg(ICH_VTR_EL2, ich_vtr);
 177         gic_num_lr = (ich_vtr & 0xf) + 1;
 178         gic_num_priority_bits = (ich_vtr >> 29) + 1;
 179
 180         /*
 181          * Clear pending virtual IRQs in case anything is left from previous
 182          * use. Physically pending IRQs will be forwarded to Linux once we
 183          * enable interrupts for the hypervisor.
 184          */
 185         gic_clear_pending_irqs();
 186
 187         ich_vmcr = (cell_icc_pmr & ICC_PMR_MASK) << ICH_VMCR_VPMR_SHIFT;
 188         if (cell_icc_igrpen1 & ICC_IGRPEN1_EN)
 189                 ich_vmcr |= ICH_VMCR_VENG1;
 190         if (cell_icc_ctlr & ICC_CTLR_EOImode)
 191                 ich_vmcr |= ICH_VMCR_VEOIM;
 192         arm_write_sysreg(ICH_VMCR_EL2, ich_vmcr);
 193
 194         /* After this, the cells access the virtual interface of the GIC. */
 195         arm_write_sysreg(ICH_HCR_EL2, ICH_HCR_EN);
 196
 197         return 0;
 198 }
 199
 200 static void gic_route_spis(struct cell *config_cell, struct cell *dest_cell)
 201 {
 202         int i;
 203         void *irouter = gicd_base + GICD_IROUTER;
 204         unsigned int first_cpu;
 205
 206         /* Use the core functions to retrieve the first physical id */
 207         for_each_cpu(first_cpu, dest_cell->cpu_set)
 208                 break;
 209
 210         for (i = 0; i < 64; i++, irouter += 8) {
 211                 if (spi_in_cell(config_cell, i))
 212                         mmio_write64(irouter, first_cpu);
 213         }
 214 }
 215
 216 static enum mmio_result gic_handle_redist_access(void *arg,
 217                                                  struct mmio_access *mmio)
 218 {
 219         struct cell *cell = this_cell();
 220         unsigned int cpu;
 221         unsigned int virt_id;
 222         void *virt_redist = 0;
 223         void *phys_redist = 0;
 224         unsigned int redist_size = (gic_version == 4) ? 0x40000 : 0x20000;
 225         void *address = (void *)(mmio->address + (unsigned long)gicr_base);
 226
 227         /*
 228          * The redistributor accessed by the cell is not the one stored in these
 229          * cpu_datas, but the one associated to its virtual id. So we first
 230          * need to translate the redistributor address.
 231          */
 232         for_each_cpu(cpu, cell->cpu_set) {
 233                 virt_id = arm_cpu_phys2virt(cpu);
 234                 virt_redist = per_cpu(virt_id)->gicr_base;
 235                 if (address >= virt_redist && address < virt_redist
 236                                 + redist_size) {
 237                         phys_redist = per_cpu(cpu)->gicr_base;
 238                         break;
 239                 }
 240         }
 241
 242         if (phys_redist == NULL)
 243                 return MMIO_ERROR;
 244
 245         mmio->address = address - virt_redist;
 246
 247         /* Change the ID register, all other accesses are allowed. */
 248         if (!mmio->is_write) {
 249                 switch (mmio->address) {
 250                 case GICR_TYPER:
 251                         if (virt_id == cell->arch.last_virt_id)
 252                                 mmio->value = GICR_TYPER_Last;
 253                         else
 254                                 mmio->value = 0;
 255                         /* AArch64 can use a writeq for this register */
 256                         if (mmio->size == 8)
 257                                 mmio->value |= (u64)virt_id << 32;
 258
 259                         return MMIO_HANDLED;
 260                 case GICR_TYPER + 4:
 261                         /* Upper bits contain the affinity */
 262                         mmio->value = virt_id;
 263                         return MMIO_HANDLED;
 264                 }
 265         }
 266         mmio_perform_access(phys_redist, mmio);
 267         return MMIO_HANDLED;
 268 }
 269
 270 static int gic_cell_init(struct cell *cell)
 271 {
 272         gic_route_spis(cell, cell);
 273
 274         mmio_region_register(cell, (unsigned long)gicd_base, gicd_size,
 275                              gic_handle_dist_access, NULL);
 276         mmio_region_register(cell, (unsigned long)gicr_base, gicr_size,
 277                              gic_handle_redist_access, NULL);
 278
 279         return 0;
 280 }
 281
 282 static void gic_cell_exit(struct cell *cell)
 283 {
 284         /* Reset interrupt routing of the cell's spis*/
 285         gic_route_spis(cell, &root_cell);
 286 }
 287
 288 static int gic_send_sgi(struct sgi *sgi)
 289 {
 290         u64 val;
 291         u16 targets = sgi->targets;
 292
 293         if (!is_sgi(sgi->id))
 294                 return -EINVAL;
 295
 296         if (sgi->routing_mode == 2)
 297                 targets = 1 << phys_processor_id();
 298
 299         val = (u64)sgi->aff3 << ICC_SGIR_AFF3_SHIFT
 300             | (u64)sgi->aff2 << ICC_SGIR_AFF2_SHIFT
 301             | sgi->aff1 << ICC_SGIR_AFF1_SHIFT
 302             | (targets & ICC_SGIR_TARGET_MASK)
 303             | (sgi->id & 0xf) << ICC_SGIR_IRQN_SHIFT;
 304
 305         if (sgi->routing_mode == 1)
 306                 val |= ICC_SGIR_ROUTING_BIT;
 307
 308         /*
 309          * Ensure the targets see our modifications to their per-cpu
 310          * structures.
 311          */
 312         dsb(ish);
 313
 314         arm_write_sysreg(ICC_SGI1R_EL1, val);
 315         isb();
 316
 317         return 0;
 318 }
 319
 320 void gicv3_handle_sgir_write(u64 sgir)
 321 {
 322         struct sgi sgi;
 323         unsigned long routing_mode = !!(sgir & ICC_SGIR_ROUTING_BIT);
 324
 325         /* FIXME: clusters are not supported yet. */
 326         sgi.targets = sgir & ICC_SGIR_TARGET_MASK;
 327         sgi.routing_mode = routing_mode;
 328         sgi.aff1 = sgir >> ICC_SGIR_AFF1_SHIFT & 0xff;
 329         sgi.aff2 = sgir >> ICC_SGIR_AFF2_SHIFT & 0xff;
 330         sgi.aff3 = sgir >> ICC_SGIR_AFF3_SHIFT & 0xff;
 331         sgi.id = sgir >> ICC_SGIR_IRQN_SHIFT & 0xf;
 332
 333         gic_handle_sgir_write(&sgi, true);
 334 }
 335
 336 static void gic_eoi_irq(u32 irq_id, bool deactivate)
 337 {
 338         arm_write_sysreg(ICC_EOIR1_EL1, irq_id);
 339         if (deactivate)
 340                 arm_write_sysreg(ICC_DIR_EL1, irq_id);
 341 }
 342
 343 static int gic_inject_irq(struct per_cpu *cpu_data, struct pending_irq *irq)
 344 {
 345         int i;
 346         int free_lr = -1;
 347         u32 elsr;
 348         u64 lr;
 349
 350         arm_read_sysreg(ICH_ELSR_EL2, elsr);
 351         for (i = 0; i < gic_num_lr; i++) {
 352                 if ((elsr >> i) & 1) {
 353                         /* Entry is invalid, candidate for injection */
 354                         if (free_lr == -1)
 355                                 free_lr = i;
 356                         continue;
 357                 }
 358
 359                 /*
 360                  * Entry is in use, check that it doesn't match the one we want
 361                  * to inject.
 362                  */
 363                 lr = gic_read_lr(i);
 364
 365                 /*
 366                  * A strict phys->virt id mapping is used for SPIs, so this test
 367                  * should be sufficient.
 368                  */
 369                 if ((u32)lr == irq->virt_id)
 370                         return -EINVAL;
 371         }
 372
 373         if (free_lr == -1) {
 374                 u32 hcr;
 375                 /*
 376                  * All list registers are in use, trigger a maintenance
 377                  * interrupt once they are available again.
 378                  */
 379                 arm_read_sysreg(ICH_HCR_EL2, hcr);
 380                 hcr |= ICH_HCR_UIE;
 381                 arm_write_sysreg(ICH_HCR_EL2, hcr);
 382
 383                 return -EBUSY;
 384         }
 385
 386         lr = irq->virt_id;
 387         /* Only group 1 interrupts */
 388         lr |= ICH_LR_GROUP_BIT;
 389         lr |= ICH_LR_PENDING;
 390         if (irq->hw) {
 391                 lr |= ICH_LR_HW_BIT;
 392                 lr |= (u64)irq->type.irq << ICH_LR_PHYS_ID_SHIFT;
 393         }
 394
 395         gic_write_lr(free_lr, lr);
 396
 397         return 0;
 398 }
 399
 400 unsigned int irqchip_mmio_count_regions(struct cell *cell)
 401 {
 402         return 2;
 403 }
 404
 405 struct irqchip_ops gic_irqchip = {
 406         .init = gic_init,
 407         .cpu_init = gic_cpu_init,
 408         .cpu_reset = gic_cpu_reset,
 409         .cell_init = gic_cell_init,
 410         .cell_exit = gic_cell_exit,
 411         .send_sgi = gic_send_sgi,
 412         .handle_irq = gic_handle_irq,
 413         .inject_irq = gic_inject_irq,
 414         .eoi_irq = gic_eoi_irq,
 415 };