xref: /openbmc/qemu/hw/intc/s390_flic.c (revision d8d7942df6b042219c148cc3a86d888794cd18ec) 
1 /*
2  * QEMU S390x floating interrupt controller (flic)
3  *
4  * Copyright 2014 IBM Corp.
5  * Author(s): Jens Freimann <jfrei@linux.vnet.ibm.com>
6  *            Cornelia Huck <cornelia.huck@de.ibm.com>
7  *
8  * This work is licensed under the terms of the GNU GPL, version 2 or (at
9  * your option) any later version. See the COPYING file in the top-level
10  * directory.
11  */
12 
13 #include "qemu/osdep.h"
14 #include "qemu/error-report.h"
15 #include "hw/sysbus.h"
16 #include "hw/s390x/ioinst.h"
17 #include "hw/s390x/s390_flic.h"
18 #include "hw/s390x/css.h"
19 #include "trace.h"
20 #include "cpu.h"
21 #include "hw/qdev.h"
22 #include "qapi/error.h"
23 #include "hw/s390x/s390-virtio-ccw.h"
24 
25 S390FLICState *s390_get_flic(void)
26 {
27     static S390FLICState *fs;
28 
29     if (!fs) {
30         fs = S390_FLIC_COMMON(object_resolve_path_type("",
31                                                        TYPE_S390_FLIC_COMMON,
32                                                        NULL));
33     }
34     return fs;
35 }
36 
37 void s390_flic_init(void)
38 {
39     DeviceState *dev;
40 
41     if (kvm_enabled()) {
42         dev = qdev_create(NULL, TYPE_KVM_S390_FLIC);
43         object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC,
44                                   OBJECT(dev), NULL);
45     } else {
46         dev = qdev_create(NULL, TYPE_QEMU_S390_FLIC);
47         object_property_add_child(qdev_get_machine(), TYPE_QEMU_S390_FLIC,
48                                   OBJECT(dev), NULL);
49     }
50     qdev_init_nofail(dev);
51 }
52 
53 static int qemu_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
54                                          uint8_t isc, bool swap,
55                                          bool is_maskable, uint8_t flags)
56 {
57     /* nothing to do */
58     return 0;
59 }
60 
61 static int qemu_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
62                                     uint64_t map_addr, bool do_map)
63 {
64     /* nothing to do */
65     return 0;
66 }
67 
68 static int qemu_s390_add_adapter_routes(S390FLICState *fs,
69                                         AdapterRoutes *routes)
70 {
71     return -ENOSYS;
72 }
73 
74 static void qemu_s390_release_adapter_routes(S390FLICState *fs,
75                                              AdapterRoutes *routes)
76 {
77 }
78 
79 static int qemu_s390_clear_io_flic(S390FLICState *fs, uint16_t subchannel_id,
80                            uint16_t subchannel_nr)
81 {
82     /* Fixme TCG */
83     return -ENOSYS;
84 }
85 
86 static int qemu_s390_modify_ais_mode(S390FLICState *fs, uint8_t isc,
87                                      uint16_t mode)
88 {
89     QEMUS390FLICState *flic  = QEMU_S390_FLIC(fs);
90 
91     switch (mode) {
92     case SIC_IRQ_MODE_ALL:
93         flic->simm &= ~AIS_MODE_MASK(isc);
94         flic->nimm &= ~AIS_MODE_MASK(isc);
95         break;
96     case SIC_IRQ_MODE_SINGLE:
97         flic->simm |= AIS_MODE_MASK(isc);
98         flic->nimm &= ~AIS_MODE_MASK(isc);
99         break;
100     default:
101         return -EINVAL;
102     }
103 
104     return 0;
105 }
106 
107 static int qemu_s390_inject_airq(S390FLICState *fs, uint8_t type,
108                                  uint8_t isc, uint8_t flags)
109 {
110     QEMUS390FLICState *flic = QEMU_S390_FLIC(fs);
111     S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs);
112     bool flag = flags & S390_ADAPTER_SUPPRESSIBLE;
113     uint32_t io_int_word = (isc << 27) | IO_INT_WORD_AI;
114 
115     if (flag && (flic->nimm & AIS_MODE_MASK(isc))) {
116         trace_qemu_s390_airq_suppressed(type, isc);
117         return 0;
118     }
119 
120     fsc->inject_io(fs, 0, 0, 0, io_int_word);
121 
122     if (flag && (flic->simm & AIS_MODE_MASK(isc))) {
123         flic->nimm |= AIS_MODE_MASK(isc);
124         trace_qemu_s390_suppress_airq(isc, "Single-Interruption Mode",
125                                       "NO-Interruptions Mode");
126     }
127 
128     return 0;
129 }
130 
131 static void qemu_s390_inject_service(S390FLICState *fs, uint32_t parm)
132 {
133 
134     S390CPU *dummy_cpu = s390_cpu_addr2state(0);
135 
136     /* FIXME: don't inject into dummy CPU */
137     cpu_inject_service(dummy_cpu, parm);
138 }
139 
140 static void qemu_s390_inject_io(S390FLICState *fs, uint16_t subchannel_id,
141                                 uint16_t subchannel_nr, uint32_t io_int_parm,
142                                 uint32_t io_int_word)
143 {
144     S390CPU *dummy_cpu = s390_cpu_addr2state(0);
145 
146     /* FIXME: don't inject into dummy CPU */
147     cpu_inject_io(dummy_cpu, subchannel_id, subchannel_nr, io_int_parm,
148                   io_int_word);
149 }
150 
151 static void qemu_s390_inject_crw_mchk(S390FLICState *fs)
152 {
153     S390CPU *dummy_cpu = s390_cpu_addr2state(0);
154 
155     /* FIXME: don't inject into dummy CPU */
156     cpu_inject_crw_mchk(dummy_cpu);
157 }
158 
159 static void qemu_s390_flic_reset(DeviceState *dev)
160 {
161     QEMUS390FLICState *flic = QEMU_S390_FLIC(dev);
162 
163     flic->simm = 0;
164     flic->nimm = 0;
165 }
166 
167 bool ais_needed(void *opaque)
168 {
169     S390FLICState *s = opaque;
170 
171     return s->ais_supported;
172 }
173 
174 static const VMStateDescription qemu_s390_flic_vmstate = {
175     .name = "qemu-s390-flic",
176     .version_id = 1,
177     .minimum_version_id = 1,
178     .needed = ais_needed,
179     .fields = (VMStateField[]) {
180         VMSTATE_UINT8(simm, QEMUS390FLICState),
181         VMSTATE_UINT8(nimm, QEMUS390FLICState),
182         VMSTATE_END_OF_LIST()
183     }
184 };
185 
186 static void qemu_s390_flic_class_init(ObjectClass *oc, void *data)
187 {
188     DeviceClass *dc = DEVICE_CLASS(oc);
189     S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc);
190 
191     dc->reset = qemu_s390_flic_reset;
192     dc->vmsd = &qemu_s390_flic_vmstate;
193     fsc->register_io_adapter = qemu_s390_register_io_adapter;
194     fsc->io_adapter_map = qemu_s390_io_adapter_map;
195     fsc->add_adapter_routes = qemu_s390_add_adapter_routes;
196     fsc->release_adapter_routes = qemu_s390_release_adapter_routes;
197     fsc->clear_io_irq = qemu_s390_clear_io_flic;
198     fsc->modify_ais_mode = qemu_s390_modify_ais_mode;
199     fsc->inject_airq = qemu_s390_inject_airq;
200     fsc->inject_service = qemu_s390_inject_service;
201     fsc->inject_io = qemu_s390_inject_io;
202     fsc->inject_crw_mchk = qemu_s390_inject_crw_mchk;
203 }
204 
205 static Property s390_flic_common_properties[] = {
206     DEFINE_PROP_UINT32("adapter_routes_max_batch", S390FLICState,
207                        adapter_routes_max_batch, ADAPTER_ROUTES_MAX_GSI),
208     DEFINE_PROP_END_OF_LIST(),
209 };
210 
211 static void s390_flic_common_realize(DeviceState *dev, Error **errp)
212 {
213     S390FLICState *fs = S390_FLIC_COMMON(dev);
214     uint32_t max_batch = fs->adapter_routes_max_batch;
215 
216     if (max_batch > ADAPTER_ROUTES_MAX_GSI) {
217         error_setg(errp, "flic property adapter_routes_max_batch too big"
218                    " (%d > %d)", max_batch, ADAPTER_ROUTES_MAX_GSI);
219         return;
220     }
221 
222     fs->ais_supported = s390_has_feat(S390_FEAT_ADAPTER_INT_SUPPRESSION);
223 }
224 
225 static void s390_flic_class_init(ObjectClass *oc, void *data)
226 {
227     DeviceClass *dc = DEVICE_CLASS(oc);
228 
229     dc->props = s390_flic_common_properties;
230     dc->realize = s390_flic_common_realize;
231 }
232 
233 static const TypeInfo qemu_s390_flic_info = {
234     .name          = TYPE_QEMU_S390_FLIC,
235     .parent        = TYPE_S390_FLIC_COMMON,
236     .instance_size = sizeof(QEMUS390FLICState),
237     .class_init    = qemu_s390_flic_class_init,
238 };
239 
240 
241 static const TypeInfo s390_flic_common_info = {
242     .name          = TYPE_S390_FLIC_COMMON,
243     .parent        = TYPE_SYS_BUS_DEVICE,
244     .instance_size = sizeof(S390FLICState),
245     .class_init    = s390_flic_class_init,
246     .class_size    = sizeof(S390FLICStateClass),
247 };
248 
249 static void qemu_s390_flic_register_types(void)
250 {
251     type_register_static(&s390_flic_common_info);
252     type_register_static(&qemu_s390_flic_info);
253 }
254 
255 type_init(qemu_s390_flic_register_types)
256 
257 static bool adapter_info_so_needed(void *opaque)
258 {
259     return css_migration_enabled();
260 }
261 
262 const VMStateDescription vmstate_adapter_info_so = {
263     .name = "s390_adapter_info/summary_offset",
264     .version_id = 1,
265     .minimum_version_id = 1,
266     .needed = adapter_info_so_needed,
267     .fields = (VMStateField[]) {
268         VMSTATE_UINT32(summary_offset, AdapterInfo),
269         VMSTATE_END_OF_LIST()
270     }
271 };
272 
273 const VMStateDescription vmstate_adapter_info = {
274     .name = "s390_adapter_info",
275     .version_id = 1,
276     .minimum_version_id = 1,
277     .fields = (VMStateField[]) {
278         VMSTATE_UINT64(ind_offset, AdapterInfo),
279         /*
280          * We do not have to migrate neither the id nor the addresses.
281          * The id is set by css_register_io_adapter and the addresses
282          * are set based on the IndAddr objects after those get mapped.
283          */
284         VMSTATE_END_OF_LIST()
285     },
286     .subsections = (const VMStateDescription * []) {
287         &vmstate_adapter_info_so,
288         NULL
289     }
290 };
291 
292 const VMStateDescription vmstate_adapter_routes = {
293 
294     .name = "s390_adapter_routes",
295     .version_id = 1,
296     .minimum_version_id = 1,
297     .fields = (VMStateField[]) {
298         VMSTATE_STRUCT(adapter, AdapterRoutes, 1, vmstate_adapter_info,
299                        AdapterInfo),
300         VMSTATE_END_OF_LIST()
301     }
302 };
303