1 /*
2  * ARM GIC support
3  *
4  * Copyright (c) 2012 Linaro Limited
5  * Copyright (c) 2015 Huawei.
6  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
7  * Written by Peter Maydell
8  * Reworked for GICv3 by Shlomo Pongratz and Pavel Fedin
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License along
21  * with this program; if not, see <http://www.gnu.org/licenses/>.
22  */
23 
24 #ifndef HW_ARM_GICV3_COMMON_H
25 #define HW_ARM_GICV3_COMMON_H
26 
27 #include "hw/sysbus.h"
28 #include "hw/intc/arm_gic_common.h"
29 #include "qom/object.h"
30 
31 /*
32  * Maximum number of possible interrupts, determined by the GIC architecture.
33  * Note that this does not include LPIs. When implemented, these should be
34  * dealt with separately.
35  */
36 #define GICV3_MAXIRQ 1020
37 #define GICV3_MAXSPI (GICV3_MAXIRQ - GIC_INTERNAL)
38 
39 #define GICV3_LPI_INTID_START 8192
40 
41 /*
42  * The redistributor in GICv3 has two 64KB frames per CPU; in
43  * GICv4 it has four 64KB frames per CPU.
44  */
45 #define GICV3_REDIST_SIZE 0x20000
46 #define GICV4_REDIST_SIZE 0x40000
47 
48 /* Number of SGI target-list bits */
49 #define GICV3_TARGETLIST_BITS 16
50 
51 /* Maximum number of list registers (architectural limit) */
52 #define GICV3_LR_MAX 16
53 
54 /* For some distributor fields we want to model the array of 32-bit
55  * register values which hold various bitmaps corresponding to enabled,
56  * pending, etc bits. These macros and functions facilitate that; the
57  * APIs are generally modelled on the generic bitmap.h functions
58  * (which are unsuitable here because they use 'unsigned long' as the
59  * underlying storage type, which is very awkward when you need to
60  * access the data as 32-bit values.)
61  * Each bitmap contains a bit for each interrupt. Although there is
62  * space for the PPIs and SGIs, those bits (the first 32) are never
63  * used as that state lives in the redistributor. The unused bits are
64  * provided purely so that interrupt X's state is always in bit X; this
65  * avoids bugs where we forget to subtract GIC_INTERNAL from an
66  * interrupt number.
67  */
68 #define GICV3_BMP_SIZE DIV_ROUND_UP(GICV3_MAXIRQ, 32)
69 
70 #define GIC_DECLARE_BITMAP(name) \
71     uint32_t name[GICV3_BMP_SIZE]
72 
73 #define GIC_BIT_MASK(nr) (1U << ((nr) % 32))
74 #define GIC_BIT_WORD(nr) ((nr) / 32)
75 
76 static inline void gic_bmp_set_bit(int nr, uint32_t *addr)
77 {
78     uint32_t mask = GIC_BIT_MASK(nr);
79     uint32_t *p = addr + GIC_BIT_WORD(nr);
80 
81     *p |= mask;
82 }
83 
84 static inline void gic_bmp_clear_bit(int nr, uint32_t *addr)
85 {
86     uint32_t mask = GIC_BIT_MASK(nr);
87     uint32_t *p = addr + GIC_BIT_WORD(nr);
88 
89     *p &= ~mask;
90 }
91 
92 static inline int gic_bmp_test_bit(int nr, const uint32_t *addr)
93 {
94     return 1U & (addr[GIC_BIT_WORD(nr)] >> (nr & 31));
95 }
96 
97 static inline void gic_bmp_replace_bit(int nr, uint32_t *addr, int val)
98 {
99     uint32_t mask = GIC_BIT_MASK(nr);
100     uint32_t *p = addr + GIC_BIT_WORD(nr);
101 
102     *p &= ~mask;
103     *p |= (val & 1U) << (nr % 32);
104 }
105 
106 /* Return a pointer to the 32-bit word containing the specified bit. */
107 static inline uint32_t *gic_bmp_ptr32(uint32_t *addr, int nr)
108 {
109     return addr + GIC_BIT_WORD(nr);
110 }
111 
112 typedef struct GICv3State GICv3State;
113 typedef struct GICv3CPUState GICv3CPUState;
114 
115 /* Some CPU interface registers come in three flavours:
116  * Group0, Group1 (Secure) and Group1 (NonSecure)
117  * (where the latter two are exposed as a single banked system register).
118  * In the state struct they are implemented as a 3-element array which
119  * can be indexed into by the GICV3_G0, GICV3_G1 and GICV3_G1NS constants.
120  * If the CPU doesn't support EL3 then the G1 element is unused.
121  *
122  * These constants are also used to communicate the group to use for
123  * an interrupt or SGI when it is passed between the cpu interface and
124  * the redistributor or distributor. For those purposes the receiving end
125  * must be prepared to cope with a Group 1 Secure interrupt even if it does
126  * not have security support enabled, because security can be disabled
127  * independently in the CPU and in the GIC. In that case the receiver should
128  * treat an incoming Group 1 Secure interrupt as if it were Group 0.
129  * (This architectural requirement is why the _G1 element is the unused one
130  * in a no-EL3 CPU:  we would otherwise have to translate back and forth
131  * between (G0, G1NS) from the distributor and (G0, G1) in the CPU i/f.)
132  */
133 #define GICV3_G0 0
134 #define GICV3_G1 1
135 #define GICV3_G1NS 2
136 
137 /* ICC_CTLR_EL1, GICD_STATUSR and GICR_STATUSR are banked but not
138  * group-related, so those indices are just 0 for S and 1 for NS.
139  * (If the CPU or the GIC, respectively, don't support the Security
140  * extensions then the S element is unused.)
141  */
142 #define GICV3_S 0
143 #define GICV3_NS 1
144 
145 typedef struct {
146     int irq;
147     uint8_t prio;
148     int grp;
149 } PendingIrq;
150 
151 struct GICv3CPUState {
152     GICv3State *gic;
153     CPUState *cpu;
154     qemu_irq parent_irq;
155     qemu_irq parent_fiq;
156     qemu_irq parent_virq;
157     qemu_irq parent_vfiq;
158 
159     /* Redistributor */
160     uint32_t level;                  /* Current IRQ level */
161     /* RD_base page registers */
162     uint32_t gicr_ctlr;
163     uint64_t gicr_typer;
164     uint32_t gicr_statusr[2];
165     uint32_t gicr_waker;
166     uint64_t gicr_propbaser;
167     uint64_t gicr_pendbaser;
168     /* SGI_base page registers */
169     uint32_t gicr_igroupr0;
170     uint32_t gicr_ienabler0;
171     uint32_t gicr_ipendr0;
172     uint32_t gicr_iactiver0;
173     uint32_t edge_trigger; /* ICFGR0 and ICFGR1 even bits */
174     uint32_t gicr_igrpmodr0;
175     uint32_t gicr_nsacr;
176     uint8_t gicr_ipriorityr[GIC_INTERNAL];
177     /* VLPI_base page registers */
178     uint64_t gicr_vpropbaser;
179     uint64_t gicr_vpendbaser;
180 
181     /* CPU interface */
182     uint64_t icc_sre_el1;
183     uint64_t icc_ctlr_el1[2];
184     uint64_t icc_pmr_el1;
185     uint64_t icc_bpr[3];
186     uint64_t icc_apr[3][4];
187     uint64_t icc_igrpen[3];
188     uint64_t icc_ctlr_el3;
189 
190     /* Virtualization control interface */
191     uint64_t ich_apr[3][4]; /* ich_apr[GICV3_G1][x] never used */
192     uint64_t ich_hcr_el2;
193     uint64_t ich_lr_el2[GICV3_LR_MAX];
194     uint64_t ich_vmcr_el2;
195 
196     /* Properties of the CPU interface. These are initialized from
197      * the settings in the CPU proper.
198      * If the number of implemented list registers is 0 then the
199      * virtualization support is not implemented.
200      */
201     int num_list_regs;
202     int vpribits; /* number of virtual priority bits */
203     int vprebits; /* number of virtual preemption bits */
204     int pribits; /* number of physical priority bits */
205     int prebits; /* number of physical preemption bits */
206 
207     /* Current highest priority pending interrupt for this CPU.
208      * This is cached information that can be recalculated from the
209      * real state above; it doesn't need to be migrated.
210      */
211     PendingIrq hppi;
212 
213     /*
214      * Cached information recalculated from LPI tables
215      * in guest memory
216      */
217     PendingIrq hpplpi;
218 
219     /* Cached information recalculated from vLPI tables in guest memory */
220     PendingIrq hppvlpi;
221 
222     /* This is temporary working state, to avoid a malloc in gicv3_update() */
223     bool seenbetter;
224 };
225 
226 /*
227  * The redistributor pages might be split into more than one region
228  * on some machine types if there are many CPUs.
229  */
230 typedef struct GICv3RedistRegion {
231     GICv3State *gic;
232     MemoryRegion iomem;
233     uint32_t cpuidx; /* index of first CPU this region covers */
234 } GICv3RedistRegion;
235 
236 struct GICv3State {
237     /*< private >*/
238     SysBusDevice parent_obj;
239     /*< public >*/
240 
241     MemoryRegion iomem_dist; /* Distributor */
242     GICv3RedistRegion *redist_regions; /* Redistributor Regions */
243     uint32_t *redist_region_count; /* redistributor count within each region */
244     uint32_t nb_redist_regions; /* number of redist regions */
245 
246     uint32_t num_cpu;
247     uint32_t num_irq;
248     uint32_t revision;
249     bool lpi_enable;
250     bool security_extn;
251     bool force_8bit_prio;
252     bool irq_reset_nonsecure;
253     bool gicd_no_migration_shift_bug;
254 
255     int dev_fd; /* kvm device fd if backed by kvm vgic support */
256     Error *migration_blocker;
257 
258     MemoryRegion *dma;
259     AddressSpace dma_as;
260 
261     /* Distributor */
262 
263     /* for a GIC with the security extensions the NS banked version of this
264      * register is just an alias of bit 1 of the S banked version.
265      */
266     uint32_t gicd_ctlr;
267     uint32_t gicd_statusr[2];
268     GIC_DECLARE_BITMAP(group);        /* GICD_IGROUPR */
269     GIC_DECLARE_BITMAP(grpmod);       /* GICD_IGRPMODR */
270     GIC_DECLARE_BITMAP(enabled);      /* GICD_ISENABLER */
271     GIC_DECLARE_BITMAP(pending);      /* GICD_ISPENDR */
272     GIC_DECLARE_BITMAP(active);       /* GICD_ISACTIVER */
273     GIC_DECLARE_BITMAP(level);        /* Current level */
274     GIC_DECLARE_BITMAP(edge_trigger); /* GICD_ICFGR even bits */
275     uint8_t gicd_ipriority[GICV3_MAXIRQ];
276     uint64_t gicd_irouter[GICV3_MAXIRQ];
277     /* Cached information: pointer to the cpu i/f for the CPUs specified
278      * in the IROUTER registers
279      */
280     GICv3CPUState *gicd_irouter_target[GICV3_MAXIRQ];
281     uint32_t gicd_nsacr[DIV_ROUND_UP(GICV3_MAXIRQ, 16)];
282 
283     GICv3CPUState *cpu;
284     /* List of all ITSes connected to this GIC */
285     GPtrArray *itslist;
286 };
287 
288 #define GICV3_BITMAP_ACCESSORS(BMP)                                     \
289     static inline void gicv3_gicd_##BMP##_set(GICv3State *s, int irq)   \
290     {                                                                   \
291         gic_bmp_set_bit(irq, s->BMP);                                   \
292     }                                                                   \
293     static inline int gicv3_gicd_##BMP##_test(GICv3State *s, int irq)   \
294     {                                                                   \
295         return gic_bmp_test_bit(irq, s->BMP);                           \
296     }                                                                   \
297     static inline void gicv3_gicd_##BMP##_clear(GICv3State *s, int irq) \
298     {                                                                   \
299         gic_bmp_clear_bit(irq, s->BMP);                                 \
300     }                                                                   \
301     static inline void gicv3_gicd_##BMP##_replace(GICv3State *s,        \
302                                                   int irq, int value)   \
303     {                                                                   \
304         gic_bmp_replace_bit(irq, s->BMP, value);                        \
305     }
306 
307 GICV3_BITMAP_ACCESSORS(group)
308 GICV3_BITMAP_ACCESSORS(grpmod)
309 GICV3_BITMAP_ACCESSORS(enabled)
310 GICV3_BITMAP_ACCESSORS(pending)
311 GICV3_BITMAP_ACCESSORS(active)
312 GICV3_BITMAP_ACCESSORS(level)
313 GICV3_BITMAP_ACCESSORS(edge_trigger)
314 
315 #define TYPE_ARM_GICV3_COMMON "arm-gicv3-common"
316 typedef struct ARMGICv3CommonClass ARMGICv3CommonClass;
317 DECLARE_OBJ_CHECKERS(GICv3State, ARMGICv3CommonClass,
318                      ARM_GICV3_COMMON, TYPE_ARM_GICV3_COMMON)
319 
320 struct ARMGICv3CommonClass {
321     /*< private >*/
322     SysBusDeviceClass parent_class;
323     /*< public >*/
324 
325     void (*pre_save)(GICv3State *s);
326     void (*post_load)(GICv3State *s);
327 };
328 
329 void gicv3_init_irqs_and_mmio(GICv3State *s, qemu_irq_handler handler,
330                               const MemoryRegionOps *ops);
331 
332 /**
333  * gicv3_class_name
334  *
335  * Return name of GICv3 class to use depending on whether KVM acceleration is
336  * in use. May throw an error if the chosen implementation is not available.
337  *
338  * Returns: class name to use
339  */
340 const char *gicv3_class_name(void);
341 
342 #endif
343