xref: /openbmc/qemu/hw/intc/riscv_imsic.c (revision b1f4b9b8) 
1 /*
2  * RISC-V IMSIC (Incoming Message Signaled Interrupt Controller)
3  *
4  * Copyright (c) 2021 Western Digital Corporation or its affiliates.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2 or later, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along with
16  * this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 
19 #include "qemu/osdep.h"
20 #include "qapi/error.h"
21 #include "qemu/log.h"
22 #include "qemu/module.h"
23 #include "qemu/error-report.h"
24 #include "qemu/bswap.h"
25 #include "exec/address-spaces.h"
26 #include "hw/sysbus.h"
27 #include "hw/pci/msi.h"
28 #include "hw/boards.h"
29 #include "hw/qdev-properties.h"
30 #include "hw/intc/riscv_imsic.h"
31 #include "hw/irq.h"
32 #include "target/riscv/cpu.h"
33 #include "target/riscv/cpu_bits.h"
34 #include "sysemu/sysemu.h"
35 #include "migration/vmstate.h"
36 
37 #define IMSIC_MMIO_PAGE_LE             0x00
38 #define IMSIC_MMIO_PAGE_BE             0x04
39 
40 #define IMSIC_MIN_ID                   ((IMSIC_EIPx_BITS * 2) - 1)
41 #define IMSIC_MAX_ID                   (IMSIC_TOPEI_IID_MASK)
42 
43 #define IMSIC_EISTATE_PENDING          (1U << 0)
44 #define IMSIC_EISTATE_ENABLED          (1U << 1)
45 #define IMSIC_EISTATE_ENPEND           (IMSIC_EISTATE_ENABLED | \
46                                         IMSIC_EISTATE_PENDING)
47 
48 static uint32_t riscv_imsic_topei(RISCVIMSICState *imsic, uint32_t page)
49 {
50     uint32_t i, max_irq, base;
51 
52     base = page * imsic->num_irqs;
53     max_irq = (imsic->eithreshold[page] &&
54                (imsic->eithreshold[page] <= imsic->num_irqs)) ?
55                imsic->eithreshold[page] : imsic->num_irqs;
56     for (i = 1; i < max_irq; i++) {
57         if ((imsic->eistate[base + i] & IMSIC_EISTATE_ENPEND) ==
58                 IMSIC_EISTATE_ENPEND) {
59             return (i << IMSIC_TOPEI_IID_SHIFT) | i;
60         }
61     }
62 
63     return 0;
64 }
65 
66 static void riscv_imsic_update(RISCVIMSICState *imsic, uint32_t page)
67 {
68     if (imsic->eidelivery[page] && riscv_imsic_topei(imsic, page)) {
69         qemu_irq_raise(imsic->external_irqs[page]);
70     } else {
71         qemu_irq_lower(imsic->external_irqs[page]);
72     }
73 }
74 
75 static int riscv_imsic_eidelivery_rmw(RISCVIMSICState *imsic, uint32_t page,
76                                       target_ulong *val,
77                                       target_ulong new_val,
78                                       target_ulong wr_mask)
79 {
80     target_ulong old_val = imsic->eidelivery[page];
81 
82     if (val) {
83         *val = old_val;
84     }
85 
86     wr_mask &= 0x1;
87     imsic->eidelivery[page] = (old_val & ~wr_mask) | (new_val & wr_mask);
88 
89     riscv_imsic_update(imsic, page);
90     return 0;
91 }
92 
93 static int riscv_imsic_eithreshold_rmw(RISCVIMSICState *imsic, uint32_t page,
94                                       target_ulong *val,
95                                       target_ulong new_val,
96                                       target_ulong wr_mask)
97 {
98     target_ulong old_val = imsic->eithreshold[page];
99 
100     if (val) {
101         *val = old_val;
102     }
103 
104     wr_mask &= IMSIC_MAX_ID;
105     imsic->eithreshold[page] = (old_val & ~wr_mask) | (new_val & wr_mask);
106 
107     riscv_imsic_update(imsic, page);
108     return 0;
109 }
110 
111 static int riscv_imsic_topei_rmw(RISCVIMSICState *imsic, uint32_t page,
112                                  target_ulong *val, target_ulong new_val,
113                                  target_ulong wr_mask)
114 {
115     uint32_t base, topei = riscv_imsic_topei(imsic, page);
116 
117     /* Read pending and enabled interrupt with highest priority */
118     if (val) {
119         *val = topei;
120     }
121 
122     /* Writes ignore value and clear top pending interrupt */
123     if (topei && wr_mask) {
124         topei >>= IMSIC_TOPEI_IID_SHIFT;
125         base = page * imsic->num_irqs;
126         if (topei) {
127             imsic->eistate[base + topei] &= ~IMSIC_EISTATE_PENDING;
128         }
129 
130         riscv_imsic_update(imsic, page);
131     }
132 
133     return 0;
134 }
135 
136 static int riscv_imsic_eix_rmw(RISCVIMSICState *imsic,
137                                uint32_t xlen, uint32_t page,
138                                uint32_t num, bool pend, target_ulong *val,
139                                target_ulong new_val, target_ulong wr_mask)
140 {
141     uint32_t i, base;
142     target_ulong mask;
143     uint32_t state = (pend) ? IMSIC_EISTATE_PENDING : IMSIC_EISTATE_ENABLED;
144 
145     if (xlen != 32) {
146         if (num & 0x1) {
147             return -EINVAL;
148         }
149         num >>= 1;
150     }
151     if (num >= (imsic->num_irqs / xlen)) {
152         return -EINVAL;
153     }
154 
155     base = (page * imsic->num_irqs) + (num * xlen);
156 
157     if (val) {
158         *val = 0;
159         for (i = 0; i < xlen; i++) {
160             mask = (target_ulong)1 << i;
161             *val |= (imsic->eistate[base + i] & state) ? mask : 0;
162         }
163     }
164 
165     for (i = 0; i < xlen; i++) {
166         /* Bit0 of eip0 and eie0 are read-only zero */
167         if (!num && !i) {
168             continue;
169         }
170 
171         mask = (target_ulong)1 << i;
172         if (wr_mask & mask) {
173             if (new_val & mask) {
174                 imsic->eistate[base + i] |= state;
175             } else {
176                 imsic->eistate[base + i] &= ~state;
177             }
178         }
179     }
180 
181     riscv_imsic_update(imsic, page);
182     return 0;
183 }
184 
185 static int riscv_imsic_rmw(void *arg, target_ulong reg, target_ulong *val,
186                            target_ulong new_val, target_ulong wr_mask)
187 {
188     RISCVIMSICState *imsic = arg;
189     uint32_t isel, priv, virt, vgein, xlen, page;
190 
191     priv = AIA_IREG_PRIV(reg);
192     virt = AIA_IREG_VIRT(reg);
193     isel = AIA_IREG_ISEL(reg);
194     vgein = AIA_IREG_VGEIN(reg);
195     xlen = AIA_IREG_XLEN(reg);
196 
197     if (imsic->mmode) {
198         if (priv == PRV_M && !virt) {
199             page = 0;
200         } else {
201             goto err;
202         }
203     } else {
204         if (priv == PRV_S) {
205             if (virt) {
206                 if (vgein && vgein < imsic->num_pages) {
207                     page = vgein;
208                 } else {
209                     goto err;
210                 }
211             } else {
212                 page = 0;
213             }
214         } else {
215             goto err;
216         }
217     }
218 
219     switch (isel) {
220     case ISELECT_IMSIC_EIDELIVERY:
221         return riscv_imsic_eidelivery_rmw(imsic, page, val,
222                                           new_val, wr_mask);
223     case ISELECT_IMSIC_EITHRESHOLD:
224         return riscv_imsic_eithreshold_rmw(imsic, page, val,
225                                            new_val, wr_mask);
226     case ISELECT_IMSIC_TOPEI:
227         return riscv_imsic_topei_rmw(imsic, page, val, new_val, wr_mask);
228     case ISELECT_IMSIC_EIP0 ... ISELECT_IMSIC_EIP63:
229         return riscv_imsic_eix_rmw(imsic, xlen, page,
230                                    isel - ISELECT_IMSIC_EIP0,
231                                    true, val, new_val, wr_mask);
232     case ISELECT_IMSIC_EIE0 ... ISELECT_IMSIC_EIE63:
233         return riscv_imsic_eix_rmw(imsic, xlen, page,
234                                    isel - ISELECT_IMSIC_EIE0,
235                                    false, val, new_val, wr_mask);
236     default:
237         break;
238     };
239 
240 err:
241     qemu_log_mask(LOG_GUEST_ERROR,
242                   "%s: Invalid register priv=%d virt=%d isel=%d vgein=%d\n",
243                   __func__, priv, virt, isel, vgein);
244     return -EINVAL;
245 }
246 
247 static uint64_t riscv_imsic_read(void *opaque, hwaddr addr, unsigned size)
248 {
249     RISCVIMSICState *imsic = opaque;
250 
251     /* Reads must be 4 byte words */
252     if ((addr & 0x3) != 0) {
253         goto err;
254     }
255 
256     /* Reads cannot be out of range */
257     if (addr > IMSIC_MMIO_SIZE(imsic->num_pages)) {
258         goto err;
259     }
260 
261     return 0;
262 
263 err:
264     qemu_log_mask(LOG_GUEST_ERROR,
265                   "%s: Invalid register read 0x%" HWADDR_PRIx "\n",
266                   __func__, addr);
267     return 0;
268 }
269 
270 static void riscv_imsic_write(void *opaque, hwaddr addr, uint64_t value,
271         unsigned size)
272 {
273     RISCVIMSICState *imsic = opaque;
274     uint32_t page;
275 
276     /* Writes must be 4 byte words */
277     if ((addr & 0x3) != 0) {
278         goto err;
279     }
280 
281     /* Writes cannot be out of range */
282     if (addr > IMSIC_MMIO_SIZE(imsic->num_pages)) {
283         goto err;
284     }
285 
286     /* Writes only supported for MSI little-endian registers */
287     page = addr >> IMSIC_MMIO_PAGE_SHIFT;
288     if ((addr & (IMSIC_MMIO_PAGE_SZ - 1)) == IMSIC_MMIO_PAGE_LE) {
289         if (value && (value < imsic->num_irqs)) {
290             imsic->eistate[(page * imsic->num_irqs) + value] |=
291                                                     IMSIC_EISTATE_PENDING;
292         }
293     }
294 
295     /* Update CPU external interrupt status */
296     riscv_imsic_update(imsic, page);
297 
298     return;
299 
300 err:
301     qemu_log_mask(LOG_GUEST_ERROR,
302                   "%s: Invalid register write 0x%" HWADDR_PRIx "\n",
303                   __func__, addr);
304 }
305 
306 static const MemoryRegionOps riscv_imsic_ops = {
307     .read = riscv_imsic_read,
308     .write = riscv_imsic_write,
309     .endianness = DEVICE_LITTLE_ENDIAN,
310     .valid = {
311         .min_access_size = 4,
312         .max_access_size = 4
313     }
314 };
315 
316 static void riscv_imsic_realize(DeviceState *dev, Error **errp)
317 {
318     RISCVIMSICState *imsic = RISCV_IMSIC(dev);
319     RISCVCPU *rcpu = RISCV_CPU(qemu_get_cpu(imsic->hartid));
320     CPUState *cpu = qemu_get_cpu(imsic->hartid);
321     CPURISCVState *env = cpu ? cpu->env_ptr : NULL;
322 
323     imsic->num_eistate = imsic->num_pages * imsic->num_irqs;
324     imsic->eidelivery = g_new0(uint32_t, imsic->num_pages);
325     imsic->eithreshold = g_new0(uint32_t, imsic->num_pages);
326     imsic->eistate = g_new0(uint32_t, imsic->num_eistate);
327 
328     memory_region_init_io(&imsic->mmio, OBJECT(dev), &riscv_imsic_ops,
329                           imsic, TYPE_RISCV_IMSIC,
330                           IMSIC_MMIO_SIZE(imsic->num_pages));
331     sysbus_init_mmio(SYS_BUS_DEVICE(dev), &imsic->mmio);
332 
333     /* Claim the CPU interrupt to be triggered by this IMSIC */
334     if (riscv_cpu_claim_interrupts(rcpu,
335             (imsic->mmode) ? MIP_MEIP : MIP_SEIP) < 0) {
336         error_setg(errp, "%s already claimed",
337                    (imsic->mmode) ? "MEIP" : "SEIP");
338         return;
339     }
340 
341     /* Create output IRQ lines */
342     imsic->external_irqs = g_malloc(sizeof(qemu_irq) * imsic->num_pages);
343     qdev_init_gpio_out(dev, imsic->external_irqs, imsic->num_pages);
344 
345     /* Force select AIA feature and setup CSR read-modify-write callback */
346     if (env) {
347         riscv_set_feature(env, RISCV_FEATURE_AIA);
348         if (!imsic->mmode) {
349             riscv_cpu_set_geilen(env, imsic->num_pages - 1);
350         }
351         riscv_cpu_set_aia_ireg_rmw_fn(env, (imsic->mmode) ? PRV_M : PRV_S,
352                                       riscv_imsic_rmw, imsic);
353     }
354 
355     msi_nonbroken = true;
356 }
357 
358 static Property riscv_imsic_properties[] = {
359     DEFINE_PROP_BOOL("mmode", RISCVIMSICState, mmode, 0),
360     DEFINE_PROP_UINT32("hartid", RISCVIMSICState, hartid, 0),
361     DEFINE_PROP_UINT32("num-pages", RISCVIMSICState, num_pages, 0),
362     DEFINE_PROP_UINT32("num-irqs", RISCVIMSICState, num_irqs, 0),
363     DEFINE_PROP_END_OF_LIST(),
364 };
365 
366 static const VMStateDescription vmstate_riscv_imsic = {
367     .name = "riscv_imsic",
368     .version_id = 1,
369     .minimum_version_id = 1,
370     .fields = (VMStateField[]) {
371             VMSTATE_VARRAY_UINT32(eidelivery, RISCVIMSICState,
372                                   num_pages, 0,
373                                   vmstate_info_uint32, uint32_t),
374             VMSTATE_VARRAY_UINT32(eithreshold, RISCVIMSICState,
375                                   num_pages, 0,
376                                   vmstate_info_uint32, uint32_t),
377             VMSTATE_VARRAY_UINT32(eistate, RISCVIMSICState,
378                                   num_eistate, 0,
379                                   vmstate_info_uint32, uint32_t),
380             VMSTATE_END_OF_LIST()
381         }
382 };
383 
384 static void riscv_imsic_class_init(ObjectClass *klass, void *data)
385 {
386     DeviceClass *dc = DEVICE_CLASS(klass);
387 
388     device_class_set_props(dc, riscv_imsic_properties);
389     dc->realize = riscv_imsic_realize;
390     dc->vmsd = &vmstate_riscv_imsic;
391 }
392 
393 static const TypeInfo riscv_imsic_info = {
394     .name          = TYPE_RISCV_IMSIC,
395     .parent        = TYPE_SYS_BUS_DEVICE,
396     .instance_size = sizeof(RISCVIMSICState),
397     .class_init    = riscv_imsic_class_init,
398 };
399 
400 static void riscv_imsic_register_types(void)
401 {
402     type_register_static(&riscv_imsic_info);
403 }
404 
405 type_init(riscv_imsic_register_types)
406 
407 /*
408  * Create IMSIC device.
409  */
410 DeviceState *riscv_imsic_create(hwaddr addr, uint32_t hartid, bool mmode,
411                                 uint32_t num_pages, uint32_t num_ids)
412 {
413     DeviceState *dev = qdev_new(TYPE_RISCV_IMSIC);
414     CPUState *cpu = qemu_get_cpu(hartid);
415     uint32_t i;
416 
417     assert(!(addr & (IMSIC_MMIO_PAGE_SZ - 1)));
418     if (mmode) {
419         assert(num_pages == 1);
420     } else {
421         assert(num_pages >= 1 && num_pages <= (IRQ_LOCAL_GUEST_MAX + 1));
422     }
423     assert(IMSIC_MIN_ID <= num_ids);
424     assert(num_ids <= IMSIC_MAX_ID);
425     assert((num_ids & IMSIC_MIN_ID) == IMSIC_MIN_ID);
426 
427     qdev_prop_set_bit(dev, "mmode", mmode);
428     qdev_prop_set_uint32(dev, "hartid", hartid);
429     qdev_prop_set_uint32(dev, "num-pages", num_pages);
430     qdev_prop_set_uint32(dev, "num-irqs", num_ids + 1);
431 
432     sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal);
433     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, addr);
434 
435     for (i = 0; i < num_pages; i++) {
436         if (!i) {
437             qdev_connect_gpio_out_named(dev, NULL, i,
438                                         qdev_get_gpio_in(DEVICE(cpu),
439                                             (mmode) ? IRQ_M_EXT : IRQ_S_EXT));
440         } else {
441             qdev_connect_gpio_out_named(dev, NULL, i,
442                                         qdev_get_gpio_in(DEVICE(cpu),
443                                             IRQ_LOCAL_MAX + i - 1));
444         }
445     }
446 
447     return dev;
448 }
449