xref: /openbmc/qemu/hw/s390x/sclp.c (revision de15df5e) 
1 /*
2  * SCLP Support
3  *
4  * Copyright IBM, Corp. 2012
5  *
6  * Authors:
7  *  Christian Borntraeger <borntraeger@de.ibm.com>
8  *  Heinz Graalfs <graalfs@linux.vnet.ibm.com>
9  *
10  * This work is licensed under the terms of the GNU GPL, version 2 or (at your
11  * option) any later version.  See the COPYING file in the top-level directory.
12  *
13  */
14 
15 #include "qemu/osdep.h"
16 #include "qemu/units.h"
17 #include "qapi/error.h"
18 #include "cpu.h"
19 #include "sysemu/sysemu.h"
20 #include "hw/boards.h"
21 #include "hw/s390x/sclp.h"
22 #include "hw/s390x/event-facility.h"
23 #include "hw/s390x/s390-pci-bus.h"
24 #include "hw/s390x/ipl.h"
25 
26 static inline SCLPDevice *get_sclp_device(void)
27 {
28     static SCLPDevice *sclp;
29 
30     if (!sclp) {
31         sclp = SCLP(object_resolve_path_type("", TYPE_SCLP, NULL));
32     }
33     return sclp;
34 }
35 
36 static inline bool sclp_command_code_valid(uint32_t code)
37 {
38     switch (code & SCLP_CMD_CODE_MASK) {
39     case SCLP_CMDW_READ_SCP_INFO:
40     case SCLP_CMDW_READ_SCP_INFO_FORCED:
41     case SCLP_CMDW_READ_CPU_INFO:
42     case SCLP_CMDW_CONFIGURE_IOA:
43     case SCLP_CMDW_DECONFIGURE_IOA:
44     case SCLP_CMD_READ_EVENT_DATA:
45     case SCLP_CMD_WRITE_EVENT_DATA:
46     case SCLP_CMD_WRITE_EVENT_MASK:
47         return true;
48     }
49     return false;
50 }
51 
52 static void prepare_cpu_entries(SCLPDevice *sclp, CPUEntry *entry, int *count)
53 {
54     MachineState *ms = MACHINE(qdev_get_machine());
55     uint8_t features[SCCB_CPU_FEATURE_LEN] = { 0 };
56     int i;
57 
58     s390_get_feat_block(S390_FEAT_TYPE_SCLP_CPU, features);
59     for (i = 0, *count = 0; i < ms->possible_cpus->len; i++) {
60         if (!ms->possible_cpus->cpus[i].cpu) {
61             continue;
62         }
63         entry[*count].address = ms->possible_cpus->cpus[i].arch_id;
64         entry[*count].type = 0;
65         memcpy(entry[*count].features, features, sizeof(features));
66         (*count)++;
67     }
68 }
69 
70 /* Provide information about the configuration, CPUs and storage */
71 static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
72 {
73     ReadInfo *read_info = (ReadInfo *) sccb;
74     MachineState *machine = MACHINE(qdev_get_machine());
75     int cpu_count;
76     int rnsize, rnmax;
77     IplParameterBlock *ipib = s390_ipl_get_iplb();
78 
79     /* CPU information */
80     prepare_cpu_entries(sclp, read_info->entries, &cpu_count);
81     read_info->entries_cpu = cpu_to_be16(cpu_count);
82     read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries));
83     read_info->highest_cpu = cpu_to_be16(machine->smp.max_cpus - 1);
84 
85     read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
86 
87     if (be16_to_cpu(sccb->h.length) <
88             (sizeof(ReadInfo) + cpu_count * sizeof(CPUEntry))) {
89         sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
90         return;
91     }
92 
93     /* Configuration Characteristic (Extension) */
94     s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR,
95                          read_info->conf_char);
96     s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
97                          read_info->conf_char_ext);
98 
99     read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
100                                         SCLP_HAS_IOA_RECONFIG);
101 
102     read_info->mha_pow = s390_get_mha_pow();
103     read_info->hmfai = cpu_to_be32(s390_get_hmfai());
104 
105     rnsize = 1 << (sclp->increment_size - 20);
106     if (rnsize <= 128) {
107         read_info->rnsize = rnsize;
108     } else {
109         read_info->rnsize = 0;
110         read_info->rnsize2 = cpu_to_be32(rnsize);
111     }
112 
113     /* we don't support standby memory, maxram_size is never exposed */
114     rnmax = machine->ram_size >> sclp->increment_size;
115     if (rnmax < 0x10000) {
116         read_info->rnmax = cpu_to_be16(rnmax);
117     } else {
118         read_info->rnmax = cpu_to_be16(0);
119         read_info->rnmax2 = cpu_to_be64(rnmax);
120     }
121 
122     if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) {
123         memcpy(&read_info->loadparm, &ipib->loadparm,
124                sizeof(read_info->loadparm));
125     } else {
126         s390_ipl_set_loadparm(read_info->loadparm);
127     }
128 
129     sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
130 }
131 
132 /* Provide information about the CPU */
133 static void sclp_read_cpu_info(SCLPDevice *sclp, SCCB *sccb)
134 {
135     ReadCpuInfo *cpu_info = (ReadCpuInfo *) sccb;
136     int cpu_count;
137 
138     prepare_cpu_entries(sclp, cpu_info->entries, &cpu_count);
139     cpu_info->nr_configured = cpu_to_be16(cpu_count);
140     cpu_info->offset_configured = cpu_to_be16(offsetof(ReadCpuInfo, entries));
141     cpu_info->nr_standby = cpu_to_be16(0);
142 
143     if (be16_to_cpu(sccb->h.length) <
144             (sizeof(ReadCpuInfo) + cpu_count * sizeof(CPUEntry))) {
145         sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
146         return;
147     }
148 
149     /* The standby offset is 16-byte for each CPU */
150     cpu_info->offset_standby = cpu_to_be16(cpu_info->offset_configured
151         + cpu_info->nr_configured*sizeof(CPUEntry));
152 
153 
154     sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
155 }
156 
157 static void sclp_configure_io_adapter(SCLPDevice *sclp, SCCB *sccb,
158                                       bool configure)
159 {
160     int rc;
161 
162     if (be16_to_cpu(sccb->h.length) < 16) {
163         rc = SCLP_RC_INSUFFICIENT_SCCB_LENGTH;
164         goto out_err;
165     }
166 
167     switch (((IoaCfgSccb *)sccb)->atype) {
168     case SCLP_RECONFIG_PCI_ATYPE:
169         if (s390_has_feat(S390_FEAT_ZPCI)) {
170             if (configure) {
171                 s390_pci_sclp_configure(sccb);
172             } else {
173                 s390_pci_sclp_deconfigure(sccb);
174             }
175             return;
176         }
177         /* fallthrough */
178     default:
179         rc = SCLP_RC_ADAPTER_TYPE_NOT_RECOGNIZED;
180     }
181 
182  out_err:
183     sccb->h.response_code = cpu_to_be16(rc);
184 }
185 
186 static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code)
187 {
188     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
189     SCLPEventFacility *ef = sclp->event_facility;
190     SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
191 
192     switch (code & SCLP_CMD_CODE_MASK) {
193     case SCLP_CMDW_READ_SCP_INFO:
194     case SCLP_CMDW_READ_SCP_INFO_FORCED:
195         sclp_c->read_SCP_info(sclp, sccb);
196         break;
197     case SCLP_CMDW_READ_CPU_INFO:
198         sclp_c->read_cpu_info(sclp, sccb);
199         break;
200     case SCLP_CMDW_CONFIGURE_IOA:
201         sclp_configure_io_adapter(sclp, sccb, true);
202         break;
203     case SCLP_CMDW_DECONFIGURE_IOA:
204         sclp_configure_io_adapter(sclp, sccb, false);
205         break;
206     default:
207         efc->command_handler(ef, sccb, code);
208         break;
209     }
210 }
211 
212 /*
213  * We only need the address to have something valid for the
214  * service_interrupt call.
215  */
216 #define SCLP_PV_DUMMY_ADDR 0x4000
217 int sclp_service_call_protected(CPUS390XState *env, uint64_t sccb,
218                                 uint32_t code)
219 {
220     SCLPDevice *sclp = get_sclp_device();
221     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
222     SCCB work_sccb;
223     hwaddr sccb_len = sizeof(SCCB);
224 
225     s390_cpu_pv_mem_read(env_archcpu(env), 0, &work_sccb, sccb_len);
226 
227     if (!sclp_command_code_valid(code)) {
228         work_sccb.h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
229         goto out_write;
230     }
231 
232     sclp_c->execute(sclp, &work_sccb, code);
233 out_write:
234     s390_cpu_pv_mem_write(env_archcpu(env), 0, &work_sccb,
235                           be16_to_cpu(work_sccb.h.length));
236     sclp_c->service_interrupt(sclp, SCLP_PV_DUMMY_ADDR);
237     return 0;
238 }
239 
240 int sclp_service_call(CPUS390XState *env, uint64_t sccb, uint32_t code)
241 {
242     SCLPDevice *sclp = get_sclp_device();
243     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
244     SCCB work_sccb;
245 
246     hwaddr sccb_len = sizeof(SCCB);
247 
248     /* first some basic checks on program checks */
249     if (env->psw.mask & PSW_MASK_PSTATE) {
250         return -PGM_PRIVILEGED;
251     }
252     if (cpu_physical_memory_is_io(sccb)) {
253         return -PGM_ADDRESSING;
254     }
255     if ((sccb & ~0x1fffUL) == 0 || (sccb & ~0x1fffUL) == env->psa
256         || (sccb & ~0x7ffffff8UL) != 0) {
257         return -PGM_SPECIFICATION;
258     }
259 
260     /*
261      * we want to work on a private copy of the sccb, to prevent guests
262      * from playing dirty tricks by modifying the memory content after
263      * the host has checked the values
264      */
265     cpu_physical_memory_read(sccb, &work_sccb, sccb_len);
266 
267     /* Valid sccb sizes */
268     if (be16_to_cpu(work_sccb.h.length) < sizeof(SCCBHeader)) {
269         return -PGM_SPECIFICATION;
270     }
271 
272     if (!sclp_command_code_valid(code)) {
273         work_sccb.h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
274         goto out_write;
275     }
276 
277     if ((sccb + be16_to_cpu(work_sccb.h.length)) > ((sccb & PAGE_MASK) + PAGE_SIZE)) {
278         work_sccb.h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION);
279         goto out_write;
280     }
281 
282     sclp_c->execute(sclp, &work_sccb, code);
283 out_write:
284     cpu_physical_memory_write(sccb, &work_sccb,
285                               be16_to_cpu(work_sccb.h.length));
286 
287     sclp_c->service_interrupt(sclp, sccb);
288 
289     return 0;
290 }
291 
292 static void service_interrupt(SCLPDevice *sclp, uint32_t sccb)
293 {
294     SCLPEventFacility *ef = sclp->event_facility;
295     SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
296 
297     uint32_t param = sccb & ~3;
298 
299     /* Indicate whether an event is still pending */
300     param |= efc->event_pending(ef) ? 1 : 0;
301 
302     if (!param) {
303         /* No need to send an interrupt, there's nothing to be notified about */
304         return;
305     }
306     s390_sclp_extint(param);
307 }
308 
309 void sclp_service_interrupt(uint32_t sccb)
310 {
311     SCLPDevice *sclp = get_sclp_device();
312     SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
313 
314     sclp_c->service_interrupt(sclp, sccb);
315 }
316 
317 /* qemu object creation and initialization functions */
318 
319 void s390_sclp_init(void)
320 {
321     Object *new = object_new(TYPE_SCLP);
322 
323     object_property_add_child(qdev_get_machine(), TYPE_SCLP, new);
324     object_unref(new);
325     qdev_realize(DEVICE(new), NULL, &error_fatal);
326 }
327 
328 static void sclp_realize(DeviceState *dev, Error **errp)
329 {
330     MachineState *machine = MACHINE(qdev_get_machine());
331     SCLPDevice *sclp = SCLP(dev);
332     Error *err = NULL;
333     uint64_t hw_limit;
334     int ret;
335 
336     /*
337      * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long
338      * as we can't find a fitting bus via the qom tree, we have to add the
339      * event facility to the sysbus, so e.g. a sclp console can be created.
340      */
341     sysbus_realize(SYS_BUS_DEVICE(sclp->event_facility), &err);
342     if (err) {
343         goto out;
344     }
345 
346     ret = s390_set_memory_limit(machine->maxram_size, &hw_limit);
347     if (ret == -E2BIG) {
348         error_setg(&err, "host supports a maximum of %" PRIu64 " GB",
349                    hw_limit / GiB);
350     } else if (ret) {
351         error_setg(&err, "setting the guest size failed");
352     }
353 
354 out:
355     error_propagate(errp, err);
356 }
357 
358 static void sclp_memory_init(SCLPDevice *sclp)
359 {
360     MachineState *machine = MACHINE(qdev_get_machine());
361     MachineClass *machine_class = MACHINE_GET_CLASS(qdev_get_machine());
362     ram_addr_t initial_mem = machine->ram_size;
363     int increment_size = 20;
364 
365     /* The storage increment size is a multiple of 1M and is a power of 2.
366      * For some machine types, the number of storage increments must be
367      * MAX_STORAGE_INCREMENTS or fewer.
368      * The variable 'increment_size' is an exponent of 2 that can be
369      * used to calculate the size (in bytes) of an increment. */
370     while (machine_class->fixup_ram_size != NULL &&
371            (initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) {
372         increment_size++;
373     }
374     sclp->increment_size = increment_size;
375 }
376 
377 static void sclp_init(Object *obj)
378 {
379     SCLPDevice *sclp = SCLP(obj);
380     Object *new;
381 
382     new = object_new(TYPE_SCLP_EVENT_FACILITY);
383     object_property_add_child(obj, TYPE_SCLP_EVENT_FACILITY, new);
384     object_unref(new);
385     sclp->event_facility = EVENT_FACILITY(new);
386 
387     sclp_memory_init(sclp);
388 }
389 
390 static void sclp_class_init(ObjectClass *oc, void *data)
391 {
392     SCLPDeviceClass *sc = SCLP_CLASS(oc);
393     DeviceClass *dc = DEVICE_CLASS(oc);
394 
395     dc->desc = "SCLP (Service-Call Logical Processor)";
396     dc->realize = sclp_realize;
397     dc->hotpluggable = false;
398     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
399     /*
400      * Reason: Creates TYPE_SCLP_EVENT_FACILITY in sclp_init
401      * which is a non-pluggable sysbus device
402      */
403     dc->user_creatable = false;
404 
405     sc->read_SCP_info = read_SCP_info;
406     sc->read_cpu_info = sclp_read_cpu_info;
407     sc->execute = sclp_execute;
408     sc->service_interrupt = service_interrupt;
409 }
410 
411 static TypeInfo sclp_info = {
412     .name = TYPE_SCLP,
413     .parent = TYPE_DEVICE,
414     .instance_init = sclp_init,
415     .instance_size = sizeof(SCLPDevice),
416     .class_init = sclp_class_init,
417     .class_size = sizeof(SCLPDeviceClass),
418 };
419 
420 static void register_types(void)
421 {
422     type_register_static(&sclp_info);
423 }
424 type_init(register_types);
425