Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 ARM Ltd. |
| 3 | * Author: Marc Zyngier <marc.zyngier@arm.com> |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License version 2 as |
| 7 | * published by the Free Software Foundation. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | * GNU General Public License for more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU General Public License |
| 15 | * along with this program; if not, write to the Free Software |
| 16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 17 | */ |
| 18 | |
| 19 | #ifndef __ASM_ARM_KVM_VGIC_H |
| 20 | #define __ASM_ARM_KVM_VGIC_H |
| 21 | |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 22 | #include <linux/kernel.h> |
| 23 | #include <linux/kvm.h> |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 24 | #include <linux/irqreturn.h> |
| 25 | #include <linux/spinlock.h> |
| 26 | #include <linux/types.h> |
Andre Przywara | 6777f77 | 2015-03-26 14:39:34 +0000 | [diff] [blame] | 27 | #include <kvm/iodev.h> |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 28 | |
Marc Zyngier | 5fb66da | 2014-07-08 12:09:05 +0100 | [diff] [blame] | 29 | #define VGIC_NR_IRQS_LEGACY 256 |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 30 | #define VGIC_NR_SGIS 16 |
| 31 | #define VGIC_NR_PPIS 16 |
| 32 | #define VGIC_NR_PRIVATE_IRQS (VGIC_NR_SGIS + VGIC_NR_PPIS) |
Marc Zyngier | 8f186d5 | 2014-02-04 18:13:03 +0000 | [diff] [blame] | 33 | |
| 34 | #define VGIC_V2_MAX_LRS (1 << 6) |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 35 | #define VGIC_V3_MAX_LRS 16 |
Marc Zyngier | c3c9183 | 2014-07-08 12:09:04 +0100 | [diff] [blame] | 36 | #define VGIC_MAX_IRQS 1024 |
Andre Przywara | 3caa2d8 | 2014-06-02 16:26:01 +0200 | [diff] [blame] | 37 | #define VGIC_V2_MAX_CPUS 8 |
Ming Lei | ef74891 | 2015-09-02 14:31:21 +0800 | [diff] [blame] | 38 | #define VGIC_V3_MAX_CPUS 255 |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 39 | |
Marc Zyngier | 5fb66da | 2014-07-08 12:09:05 +0100 | [diff] [blame] | 40 | #if (VGIC_NR_IRQS_LEGACY & 31) |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 41 | #error "VGIC_NR_IRQS must be a multiple of 32" |
| 42 | #endif |
| 43 | |
Marc Zyngier | 5fb66da | 2014-07-08 12:09:05 +0100 | [diff] [blame] | 44 | #if (VGIC_NR_IRQS_LEGACY > VGIC_MAX_IRQS) |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 45 | #error "VGIC_NR_IRQS must be <= 1024" |
| 46 | #endif |
| 47 | |
| 48 | /* |
| 49 | * The GIC distributor registers describing interrupts have two parts: |
| 50 | * - 32 per-CPU interrupts (SGI + PPI) |
| 51 | * - a bunch of shared interrupts (SPI) |
| 52 | */ |
| 53 | struct vgic_bitmap { |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 54 | /* |
| 55 | * - One UL per VCPU for private interrupts (assumes UL is at |
| 56 | * least 32 bits) |
| 57 | * - As many UL as necessary for shared interrupts. |
| 58 | * |
| 59 | * The private interrupts are accessed via the "private" |
| 60 | * field, one UL per vcpu (the state for vcpu n is in |
| 61 | * private[n]). The shared interrupts are accessed via the |
| 62 | * "shared" pointer (IRQn state is at bit n-32 in the bitmap). |
| 63 | */ |
| 64 | unsigned long *private; |
| 65 | unsigned long *shared; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 66 | }; |
| 67 | |
| 68 | struct vgic_bytemap { |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 69 | /* |
| 70 | * - 8 u32 per VCPU for private interrupts |
| 71 | * - As many u32 as necessary for shared interrupts. |
| 72 | * |
| 73 | * The private interrupts are accessed via the "private" |
| 74 | * field, (the state for vcpu n is in private[n*8] to |
| 75 | * private[n*8 + 7]). The shared interrupts are accessed via |
| 76 | * the "shared" pointer (IRQn state is at byte (n-32)%4 of the |
| 77 | * shared[(n-32)/4] word). |
| 78 | */ |
| 79 | u32 *private; |
| 80 | u32 *shared; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 81 | }; |
| 82 | |
Marc Zyngier | 8d5c6b0 | 2013-06-03 15:55:02 +0100 | [diff] [blame] | 83 | struct kvm_vcpu; |
| 84 | |
Marc Zyngier | 1a9b130 | 2013-06-21 11:57:56 +0100 | [diff] [blame] | 85 | enum vgic_type { |
| 86 | VGIC_V2, /* Good ol' GICv2 */ |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 87 | VGIC_V3, /* New fancy GICv3 */ |
Marc Zyngier | 1a9b130 | 2013-06-21 11:57:56 +0100 | [diff] [blame] | 88 | }; |
| 89 | |
Marc Zyngier | 8d5c6b0 | 2013-06-03 15:55:02 +0100 | [diff] [blame] | 90 | #define LR_STATE_PENDING (1 << 0) |
| 91 | #define LR_STATE_ACTIVE (1 << 1) |
| 92 | #define LR_STATE_MASK (3 << 0) |
| 93 | #define LR_EOI_INT (1 << 2) |
Marc Zyngier | 32d2d80 | 2015-06-08 15:21:32 +0100 | [diff] [blame] | 94 | #define LR_HW (1 << 3) |
Marc Zyngier | 8d5c6b0 | 2013-06-03 15:55:02 +0100 | [diff] [blame] | 95 | |
| 96 | struct vgic_lr { |
Marc Zyngier | 32d2d80 | 2015-06-08 15:21:32 +0100 | [diff] [blame] | 97 | unsigned irq:10; |
| 98 | union { |
| 99 | unsigned hwirq:10; |
| 100 | unsigned source:3; |
| 101 | }; |
| 102 | unsigned state:4; |
Marc Zyngier | 8d5c6b0 | 2013-06-03 15:55:02 +0100 | [diff] [blame] | 103 | }; |
| 104 | |
Marc Zyngier | beee38b | 2014-02-04 17:48:10 +0000 | [diff] [blame] | 105 | struct vgic_vmcr { |
| 106 | u32 ctlr; |
| 107 | u32 abpr; |
| 108 | u32 bpr; |
| 109 | u32 pmr; |
| 110 | }; |
| 111 | |
Marc Zyngier | 8d5c6b0 | 2013-06-03 15:55:02 +0100 | [diff] [blame] | 112 | struct vgic_ops { |
| 113 | struct vgic_lr (*get_lr)(const struct kvm_vcpu *, int); |
| 114 | void (*set_lr)(struct kvm_vcpu *, int, struct vgic_lr); |
Marc Zyngier | 69bb2c9 | 2013-06-04 10:29:39 +0100 | [diff] [blame] | 115 | u64 (*get_elrsr)(const struct kvm_vcpu *vcpu); |
Marc Zyngier | 8d6a031 | 2013-06-04 10:33:43 +0100 | [diff] [blame] | 116 | u64 (*get_eisr)(const struct kvm_vcpu *vcpu); |
Christoffer Dall | ae70593 | 2015-03-13 17:02:56 +0000 | [diff] [blame] | 117 | void (*clear_eisr)(struct kvm_vcpu *vcpu); |
Marc Zyngier | 495dd85 | 2013-06-04 11:02:10 +0100 | [diff] [blame] | 118 | u32 (*get_interrupt_status)(const struct kvm_vcpu *vcpu); |
Marc Zyngier | 909d9b5 | 2013-06-04 11:24:17 +0100 | [diff] [blame] | 119 | void (*enable_underflow)(struct kvm_vcpu *vcpu); |
| 120 | void (*disable_underflow)(struct kvm_vcpu *vcpu); |
Marc Zyngier | beee38b | 2014-02-04 17:48:10 +0000 | [diff] [blame] | 121 | void (*get_vmcr)(struct kvm_vcpu *vcpu, struct vgic_vmcr *vmcr); |
| 122 | void (*set_vmcr)(struct kvm_vcpu *vcpu, struct vgic_vmcr *vmcr); |
Marc Zyngier | da8dafd1 | 2013-06-04 11:36:38 +0100 | [diff] [blame] | 123 | void (*enable)(struct kvm_vcpu *vcpu); |
Marc Zyngier | 8d5c6b0 | 2013-06-03 15:55:02 +0100 | [diff] [blame] | 124 | }; |
| 125 | |
Marc Zyngier | ca85f62 | 2013-06-18 19:17:28 +0100 | [diff] [blame] | 126 | struct vgic_params { |
Marc Zyngier | 1a9b130 | 2013-06-21 11:57:56 +0100 | [diff] [blame] | 127 | /* vgic type */ |
| 128 | enum vgic_type type; |
Marc Zyngier | ca85f62 | 2013-06-18 19:17:28 +0100 | [diff] [blame] | 129 | /* Physical address of vgic virtual cpu interface */ |
| 130 | phys_addr_t vcpu_base; |
| 131 | /* Number of list registers */ |
| 132 | u32 nr_lr; |
| 133 | /* Interrupt number */ |
| 134 | unsigned int maint_irq; |
| 135 | /* Virtual control interface base address */ |
| 136 | void __iomem *vctrl_base; |
Andre Przywara | 3caa2d8 | 2014-06-02 16:26:01 +0200 | [diff] [blame] | 137 | int max_gic_vcpus; |
Andre Przywara | b5d84ff | 2014-06-03 10:26:03 +0200 | [diff] [blame] | 138 | /* Only needed for the legacy KVM_CREATE_IRQCHIP */ |
| 139 | bool can_emulate_gicv2; |
Marc Zyngier | ca85f62 | 2013-06-18 19:17:28 +0100 | [diff] [blame] | 140 | }; |
| 141 | |
Andre Przywara | b26e5fd | 2014-06-02 16:19:12 +0200 | [diff] [blame] | 142 | struct vgic_vm_ops { |
Andre Przywara | b26e5fd | 2014-06-02 16:19:12 +0200 | [diff] [blame] | 143 | bool (*queue_sgi)(struct kvm_vcpu *, int irq); |
| 144 | void (*add_sgi_source)(struct kvm_vcpu *, int irq, int source); |
| 145 | int (*init_model)(struct kvm *); |
| 146 | int (*map_resources)(struct kvm *, const struct vgic_params *); |
| 147 | }; |
| 148 | |
Andre Przywara | 6777f77 | 2015-03-26 14:39:34 +0000 | [diff] [blame] | 149 | struct vgic_io_device { |
| 150 | gpa_t addr; |
| 151 | int len; |
| 152 | const struct vgic_io_range *reg_ranges; |
| 153 | struct kvm_vcpu *redist_vcpu; |
| 154 | struct kvm_io_device dev; |
| 155 | }; |
| 156 | |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 157 | struct irq_phys_map { |
| 158 | u32 virt_irq; |
| 159 | u32 phys_irq; |
| 160 | u32 irq; |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 161 | }; |
| 162 | |
| 163 | struct irq_phys_map_entry { |
| 164 | struct list_head entry; |
| 165 | struct rcu_head rcu; |
| 166 | struct irq_phys_map map; |
| 167 | }; |
| 168 | |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 169 | struct vgic_dist { |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 170 | spinlock_t lock; |
Marc Zyngier | f982cf4 | 2014-05-15 10:03:25 +0100 | [diff] [blame] | 171 | bool in_kernel; |
Marc Zyngier | 01ac5e3 | 2013-01-21 19:36:16 -0500 | [diff] [blame] | 172 | bool ready; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 173 | |
Andre Przywara | 59892136 | 2014-06-03 09:33:10 +0200 | [diff] [blame] | 174 | /* vGIC model the kernel emulates for the guest (GICv2 or GICv3) */ |
| 175 | u32 vgic_model; |
| 176 | |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 177 | int nr_cpus; |
| 178 | int nr_irqs; |
| 179 | |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 180 | /* Virtual control interface mapping */ |
| 181 | void __iomem *vctrl_base; |
| 182 | |
Christoffer Dall | 330690c | 2013-01-21 19:36:13 -0500 | [diff] [blame] | 183 | /* Distributor and vcpu interface mapping in the guest */ |
| 184 | phys_addr_t vgic_dist_base; |
Andre Przywara | a0675c2 | 2014-06-07 00:54:51 +0200 | [diff] [blame] | 185 | /* GICv2 and GICv3 use different mapped register blocks */ |
| 186 | union { |
| 187 | phys_addr_t vgic_cpu_base; |
| 188 | phys_addr_t vgic_redist_base; |
| 189 | }; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 190 | |
| 191 | /* Distributor enabled */ |
| 192 | u32 enabled; |
| 193 | |
| 194 | /* Interrupt enabled (one bit per IRQ) */ |
| 195 | struct vgic_bitmap irq_enabled; |
| 196 | |
Christoffer Dall | faa1b46 | 2014-06-14 21:54:51 +0200 | [diff] [blame] | 197 | /* Level-triggered interrupt external input is asserted */ |
| 198 | struct vgic_bitmap irq_level; |
| 199 | |
| 200 | /* |
| 201 | * Interrupt state is pending on the distributor |
| 202 | */ |
Christoffer Dall | 227844f | 2014-06-09 12:27:18 +0200 | [diff] [blame] | 203 | struct vgic_bitmap irq_pending; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 204 | |
Christoffer Dall | faa1b46 | 2014-06-14 21:54:51 +0200 | [diff] [blame] | 205 | /* |
| 206 | * Tracks writes to GICD_ISPENDRn and GICD_ICPENDRn for level-triggered |
| 207 | * interrupts. Essentially holds the state of the flip-flop in |
| 208 | * Figure 4-10 on page 4-101 in ARM IHI 0048B.b. |
| 209 | * Once set, it is only cleared for level-triggered interrupts on |
| 210 | * guest ACKs (when we queue it) or writes to GICD_ICPENDRn. |
| 211 | */ |
| 212 | struct vgic_bitmap irq_soft_pend; |
| 213 | |
Christoffer Dall | dbf20f9 | 2014-06-09 12:55:13 +0200 | [diff] [blame] | 214 | /* Level-triggered interrupt queued on VCPU interface */ |
| 215 | struct vgic_bitmap irq_queued; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 216 | |
Christoffer Dall | 47a98b1 | 2015-03-13 17:02:54 +0000 | [diff] [blame] | 217 | /* Interrupt was active when unqueue from VCPU interface */ |
| 218 | struct vgic_bitmap irq_active; |
| 219 | |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 220 | /* Interrupt priority. Not used yet. */ |
| 221 | struct vgic_bytemap irq_priority; |
| 222 | |
| 223 | /* Level/edge triggered */ |
| 224 | struct vgic_bitmap irq_cfg; |
| 225 | |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 226 | /* |
| 227 | * Source CPU per SGI and target CPU: |
| 228 | * |
| 229 | * Each byte represent a SGI observable on a VCPU, each bit of |
| 230 | * this byte indicating if the corresponding VCPU has |
| 231 | * generated this interrupt. This is a GICv2 feature only. |
| 232 | * |
| 233 | * For VCPUn (n < 8), irq_sgi_sources[n*16] to [n*16 + 15] are |
| 234 | * the SGIs observable on VCPUn. |
| 235 | */ |
| 236 | u8 *irq_sgi_sources; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 237 | |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 238 | /* |
| 239 | * Target CPU for each SPI: |
| 240 | * |
| 241 | * Array of available SPI, each byte indicating the target |
| 242 | * VCPU for SPI. IRQn (n >=32) is at irq_spi_cpu[n-32]. |
| 243 | */ |
| 244 | u8 *irq_spi_cpu; |
| 245 | |
| 246 | /* |
| 247 | * Reverse lookup of irq_spi_cpu for faster compute pending: |
| 248 | * |
| 249 | * Array of bitmaps, one per VCPU, describing if IRQn is |
| 250 | * routed to a particular VCPU. |
| 251 | */ |
| 252 | struct vgic_bitmap *irq_spi_target; |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 253 | |
Andre Przywara | a0675c2 | 2014-06-07 00:54:51 +0200 | [diff] [blame] | 254 | /* Target MPIDR for each IRQ (needed for GICv3 IROUTERn) only */ |
| 255 | u32 *irq_spi_mpidr; |
| 256 | |
Marc Zyngier | b47ef92 | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 257 | /* Bitmap indicating which CPU has something pending */ |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 258 | unsigned long *irq_pending_on_cpu; |
Andre Przywara | b26e5fd | 2014-06-02 16:19:12 +0200 | [diff] [blame] | 259 | |
Christoffer Dall | 47a98b1 | 2015-03-13 17:02:54 +0000 | [diff] [blame] | 260 | /* Bitmap indicating which CPU has active IRQs */ |
| 261 | unsigned long *irq_active_on_cpu; |
| 262 | |
Andre Przywara | b26e5fd | 2014-06-02 16:19:12 +0200 | [diff] [blame] | 263 | struct vgic_vm_ops vm_ops; |
Andre Przywara | a9cf86f | 2015-03-26 14:39:35 +0000 | [diff] [blame] | 264 | struct vgic_io_device dist_iodev; |
Andre Przywara | fb8f61a | 2015-03-26 14:39:37 +0000 | [diff] [blame] | 265 | struct vgic_io_device *redist_iodevs; |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 266 | |
| 267 | /* Virtual irq to hwirq mapping */ |
| 268 | spinlock_t irq_phys_map_lock; |
| 269 | struct list_head irq_phys_map_list; |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 270 | }; |
| 271 | |
Marc Zyngier | eede821 | 2013-05-30 10:20:36 +0100 | [diff] [blame] | 272 | struct vgic_v2_cpu_if { |
| 273 | u32 vgic_hcr; |
| 274 | u32 vgic_vmcr; |
| 275 | u32 vgic_misr; /* Saved only */ |
Christoffer Dall | 2df36a5 | 2014-09-28 16:04:26 +0200 | [diff] [blame] | 276 | u64 vgic_eisr; /* Saved only */ |
| 277 | u64 vgic_elrsr; /* Saved only */ |
Marc Zyngier | eede821 | 2013-05-30 10:20:36 +0100 | [diff] [blame] | 278 | u32 vgic_apr; |
Marc Zyngier | 8f186d5 | 2014-02-04 18:13:03 +0000 | [diff] [blame] | 279 | u32 vgic_lr[VGIC_V2_MAX_LRS]; |
Marc Zyngier | eede821 | 2013-05-30 10:20:36 +0100 | [diff] [blame] | 280 | }; |
| 281 | |
Marc Zyngier | 3c13b8f | 2015-12-01 13:48:56 +0000 | [diff] [blame] | 282 | /* |
| 283 | * LRs are stored in reverse order in memory. make sure we index them |
| 284 | * correctly. |
| 285 | */ |
| 286 | #define VGIC_V3_LR_INDEX(lr) (VGIC_V3_MAX_LRS - 1 - lr) |
| 287 | |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 288 | struct vgic_v3_cpu_if { |
Jean-Philippe Brucker | 4f64cb6 | 2015-10-01 13:47:19 +0100 | [diff] [blame] | 289 | #ifdef CONFIG_KVM_ARM_VGIC_V3 |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 290 | u32 vgic_hcr; |
| 291 | u32 vgic_vmcr; |
Andre Przywara | 2f5fa41 | 2014-06-03 08:58:15 +0200 | [diff] [blame] | 292 | u32 vgic_sre; /* Restored only, change ignored */ |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 293 | u32 vgic_misr; /* Saved only */ |
| 294 | u32 vgic_eisr; /* Saved only */ |
| 295 | u32 vgic_elrsr; /* Saved only */ |
| 296 | u32 vgic_ap0r[4]; |
| 297 | u32 vgic_ap1r[4]; |
| 298 | u64 vgic_lr[VGIC_V3_MAX_LRS]; |
| 299 | #endif |
| 300 | }; |
| 301 | |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 302 | struct vgic_cpu { |
Christoffer Dall | 47a98b1 | 2015-03-13 17:02:54 +0000 | [diff] [blame] | 303 | /* Pending/active/both interrupts on this VCPU */ |
Michal Marek | 5fdf876 | 2015-10-15 22:16:28 +0200 | [diff] [blame] | 304 | DECLARE_BITMAP(pending_percpu, VGIC_NR_PRIVATE_IRQS); |
| 305 | DECLARE_BITMAP(active_percpu, VGIC_NR_PRIVATE_IRQS); |
| 306 | DECLARE_BITMAP(pend_act_percpu, VGIC_NR_PRIVATE_IRQS); |
Christoffer Dall | 47a98b1 | 2015-03-13 17:02:54 +0000 | [diff] [blame] | 307 | |
| 308 | /* Pending/active/both shared interrupts, dynamically sized */ |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 309 | unsigned long *pending_shared; |
Christoffer Dall | 47a98b1 | 2015-03-13 17:02:54 +0000 | [diff] [blame] | 310 | unsigned long *active_shared; |
| 311 | unsigned long *pend_act_shared; |
Marc Zyngier | 9d949dc | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 312 | |
Marc Zyngier | 9d949dc | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 313 | /* Number of list registers on this CPU */ |
| 314 | int nr_lr; |
| 315 | |
| 316 | /* CPU vif control registers for world switch */ |
Marc Zyngier | eede821 | 2013-05-30 10:20:36 +0100 | [diff] [blame] | 317 | union { |
| 318 | struct vgic_v2_cpu_if vgic_v2; |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 319 | struct vgic_v3_cpu_if vgic_v3; |
Marc Zyngier | eede821 | 2013-05-30 10:20:36 +0100 | [diff] [blame] | 320 | }; |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 321 | |
| 322 | /* Protected by the distributor's irq_phys_map_lock */ |
| 323 | struct list_head irq_phys_map_list; |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 324 | }; |
| 325 | |
Marc Zyngier | 9d949dc | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 326 | #define LR_EMPTY 0xff |
| 327 | |
Marc Zyngier | 495dd85 | 2013-06-04 11:02:10 +0100 | [diff] [blame] | 328 | #define INT_STATUS_EOI (1 << 0) |
| 329 | #define INT_STATUS_UNDERFLOW (1 << 1) |
| 330 | |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 331 | struct kvm; |
| 332 | struct kvm_vcpu; |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 333 | |
Christoffer Dall | ce01e4e | 2013-09-23 14:55:56 -0700 | [diff] [blame] | 334 | int kvm_vgic_addr(struct kvm *kvm, unsigned long type, u64 *addr, bool write); |
Marc Zyngier | 01ac5e3 | 2013-01-21 19:36:16 -0500 | [diff] [blame] | 335 | int kvm_vgic_hyp_init(void); |
Peter Maydell | 6d3cfbe | 2014-12-04 15:02:24 +0000 | [diff] [blame] | 336 | int kvm_vgic_map_resources(struct kvm *kvm); |
Andre Przywara | 3caa2d8 | 2014-06-02 16:26:01 +0200 | [diff] [blame] | 337 | int kvm_vgic_get_max_vcpus(void); |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 338 | void kvm_vgic_early_init(struct kvm *kvm); |
Andre Przywara | 59892136 | 2014-06-03 09:33:10 +0200 | [diff] [blame] | 339 | int kvm_vgic_create(struct kvm *kvm, u32 type); |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 340 | void kvm_vgic_destroy(struct kvm *kvm); |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 341 | void kvm_vgic_vcpu_early_init(struct kvm_vcpu *vcpu); |
Marc Zyngier | c1bfb57 | 2014-07-08 12:09:01 +0100 | [diff] [blame] | 342 | void kvm_vgic_vcpu_destroy(struct kvm_vcpu *vcpu); |
Marc Zyngier | 9d949dc | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 343 | void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu); |
| 344 | void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu); |
Marc Zyngier | 5863c2c | 2013-01-21 19:36:15 -0500 | [diff] [blame] | 345 | int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid, unsigned int irq_num, |
| 346 | bool level); |
Marc Zyngier | 773299a | 2015-07-24 11:30:43 +0100 | [diff] [blame] | 347 | int kvm_vgic_inject_mapped_irq(struct kvm *kvm, int cpuid, |
| 348 | struct irq_phys_map *map, bool level); |
Andre Przywara | 6d52f35 | 2014-06-03 10:13:13 +0200 | [diff] [blame] | 349 | void vgic_v3_dispatch_sgi(struct kvm_vcpu *vcpu, u64 reg); |
Marc Zyngier | 9d949dc | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 350 | int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu); |
Marc Zyngier | 6c3d63c | 2014-06-23 17:37:18 +0100 | [diff] [blame] | 351 | struct irq_phys_map *kvm_vgic_map_phys_irq(struct kvm_vcpu *vcpu, |
| 352 | int virt_irq, int irq); |
| 353 | int kvm_vgic_unmap_phys_irq(struct kvm_vcpu *vcpu, struct irq_phys_map *map); |
Christoffer Dall | 0e3dfda | 2015-11-24 16:23:05 +0100 | [diff] [blame] | 354 | bool kvm_vgic_map_is_active(struct kvm_vcpu *vcpu, struct irq_phys_map *map); |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 355 | |
Marc Zyngier | f982cf4 | 2014-05-15 10:03:25 +0100 | [diff] [blame] | 356 | #define irqchip_in_kernel(k) (!!((k)->arch.vgic.in_kernel)) |
Christoffer Dall | 1f57be2 | 2014-12-09 14:30:36 +0100 | [diff] [blame] | 357 | #define vgic_initialized(k) (!!((k)->arch.vgic.nr_cpus)) |
Christoffer Dall | c52edf5 | 2014-12-09 14:28:09 +0100 | [diff] [blame] | 358 | #define vgic_ready(k) ((k)->arch.vgic.ready) |
Marc Zyngier | 9d949dc | 2013-01-21 19:36:14 -0500 | [diff] [blame] | 359 | |
Marc Zyngier | 8f186d5 | 2014-02-04 18:13:03 +0000 | [diff] [blame] | 360 | int vgic_v2_probe(struct device_node *vgic_node, |
| 361 | const struct vgic_ops **ops, |
| 362 | const struct vgic_params **params); |
Jean-Philippe Brucker | 4f64cb6 | 2015-10-01 13:47:19 +0100 | [diff] [blame] | 363 | #ifdef CONFIG_KVM_ARM_VGIC_V3 |
Marc Zyngier | b2fb1c0 | 2013-07-12 15:15:23 +0100 | [diff] [blame] | 364 | int vgic_v3_probe(struct device_node *vgic_node, |
| 365 | const struct vgic_ops **ops, |
| 366 | const struct vgic_params **params); |
| 367 | #else |
| 368 | static inline int vgic_v3_probe(struct device_node *vgic_node, |
| 369 | const struct vgic_ops **ops, |
| 370 | const struct vgic_params **params) |
| 371 | { |
| 372 | return -ENODEV; |
| 373 | } |
| 374 | #endif |
Marc Zyngier | 8f186d5 | 2014-02-04 18:13:03 +0000 | [diff] [blame] | 375 | |
Marc Zyngier | 1a89dd9 | 2013-01-21 19:36:12 -0500 | [diff] [blame] | 376 | #endif |