1
2
3
4
5
6
7
8
9
10
11
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
26static 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
36static void prepare_cpu_entries(SCLPDevice *sclp, CPUEntry *entry, int *count)
37{
38 MachineState *ms = MACHINE(qdev_get_machine());
39 uint8_t features[SCCB_CPU_FEATURE_LEN] = { 0 };
40 int i;
41
42 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CPU, features);
43 for (i = 0, *count = 0; i < ms->possible_cpus->len; i++) {
44 if (!ms->possible_cpus->cpus[i].cpu) {
45 continue;
46 }
47 entry[*count].address = ms->possible_cpus->cpus[i].arch_id;
48 entry[*count].type = 0;
49 memcpy(entry[*count].features, features, sizeof(features));
50 (*count)++;
51 }
52}
53
54
55static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
56{
57 ReadInfo *read_info = (ReadInfo *) sccb;
58 MachineState *machine = MACHINE(qdev_get_machine());
59 int cpu_count;
60 int rnsize, rnmax;
61 IplParameterBlock *ipib = s390_ipl_get_iplb();
62
63
64 prepare_cpu_entries(sclp, read_info->entries, &cpu_count);
65 read_info->entries_cpu = cpu_to_be16(cpu_count);
66 read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries));
67 read_info->highest_cpu = cpu_to_be16(machine->smp.max_cpus - 1);
68
69 read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
70
71 if (be16_to_cpu(sccb->h.length) <
72 (sizeof(ReadInfo) + cpu_count * sizeof(CPUEntry))) {
73 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
74 return;
75 }
76
77
78 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR,
79 read_info->conf_char);
80 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
81 read_info->conf_char_ext);
82
83 read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
84 SCLP_HAS_IOA_RECONFIG);
85
86 read_info->mha_pow = s390_get_mha_pow();
87 read_info->hmfai = cpu_to_be32(s390_get_hmfai());
88
89 rnsize = 1 << (sclp->increment_size - 20);
90 if (rnsize <= 128) {
91 read_info->rnsize = rnsize;
92 } else {
93 read_info->rnsize = 0;
94 read_info->rnsize2 = cpu_to_be32(rnsize);
95 }
96
97
98 rnmax = machine->ram_size >> sclp->increment_size;
99 if (rnmax < 0x10000) {
100 read_info->rnmax = cpu_to_be16(rnmax);
101 } else {
102 read_info->rnmax = cpu_to_be16(0);
103 read_info->rnmax2 = cpu_to_be64(rnmax);
104 }
105
106 if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) {
107 memcpy(&read_info->loadparm, &ipib->loadparm,
108 sizeof(read_info->loadparm));
109 } else {
110 s390_ipl_set_loadparm(read_info->loadparm);
111 }
112
113 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
114}
115
116
117static void sclp_read_cpu_info(SCLPDevice *sclp, SCCB *sccb)
118{
119 ReadCpuInfo *cpu_info = (ReadCpuInfo *) sccb;
120 int cpu_count;
121
122 prepare_cpu_entries(sclp, cpu_info->entries, &cpu_count);
123 cpu_info->nr_configured = cpu_to_be16(cpu_count);
124 cpu_info->offset_configured = cpu_to_be16(offsetof(ReadCpuInfo, entries));
125 cpu_info->nr_standby = cpu_to_be16(0);
126
127 if (be16_to_cpu(sccb->h.length) <
128 (sizeof(ReadCpuInfo) + cpu_count * sizeof(CPUEntry))) {
129 sccb->h.response_code = cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH);
130 return;
131 }
132
133
134 cpu_info->offset_standby = cpu_to_be16(cpu_info->offset_configured
135 + cpu_info->nr_configured*sizeof(CPUEntry));
136
137
138 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
139}
140
141static void sclp_configure_io_adapter(SCLPDevice *sclp, SCCB *sccb,
142 bool configure)
143{
144 int rc;
145
146 if (be16_to_cpu(sccb->h.length) < 16) {
147 rc = SCLP_RC_INSUFFICIENT_SCCB_LENGTH;
148 goto out_err;
149 }
150
151 switch (((IoaCfgSccb *)sccb)->atype) {
152 case SCLP_RECONFIG_PCI_ATYPE:
153 if (s390_has_feat(S390_FEAT_ZPCI)) {
154 if (configure) {
155 s390_pci_sclp_configure(sccb);
156 } else {
157 s390_pci_sclp_deconfigure(sccb);
158 }
159 return;
160 }
161
162 default:
163 rc = SCLP_RC_ADAPTER_TYPE_NOT_RECOGNIZED;
164 }
165
166 out_err:
167 sccb->h.response_code = cpu_to_be16(rc);
168}
169
170static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code)
171{
172 SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
173 SCLPEventFacility *ef = sclp->event_facility;
174 SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
175
176 switch (code & SCLP_CMD_CODE_MASK) {
177 case SCLP_CMDW_READ_SCP_INFO:
178 case SCLP_CMDW_READ_SCP_INFO_FORCED:
179 sclp_c->read_SCP_info(sclp, sccb);
180 break;
181 case SCLP_CMDW_READ_CPU_INFO:
182 sclp_c->read_cpu_info(sclp, sccb);
183 break;
184 case SCLP_CMDW_CONFIGURE_IOA:
185 sclp_configure_io_adapter(sclp, sccb, true);
186 break;
187 case SCLP_CMDW_DECONFIGURE_IOA:
188 sclp_configure_io_adapter(sclp, sccb, false);
189 break;
190 default:
191 efc->command_handler(ef, sccb, code);
192 break;
193 }
194}
195
196int sclp_service_call(CPUS390XState *env, uint64_t sccb, uint32_t code)
197{
198 SCLPDevice *sclp = get_sclp_device();
199 SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
200 int r = 0;
201 SCCB work_sccb;
202
203 hwaddr sccb_len = sizeof(SCCB);
204
205
206 if (env->psw.mask & PSW_MASK_PSTATE) {
207 r = -PGM_PRIVILEGED;
208 goto out;
209 }
210 if (cpu_physical_memory_is_io(sccb)) {
211 r = -PGM_ADDRESSING;
212 goto out;
213 }
214 if ((sccb & ~0x1fffUL) == 0 || (sccb & ~0x1fffUL) == env->psa
215 || (sccb & ~0x7ffffff8UL) != 0) {
216 r = -PGM_SPECIFICATION;
217 goto out;
218 }
219
220
221
222
223
224
225 cpu_physical_memory_read(sccb, &work_sccb, sccb_len);
226
227
228 if (be16_to_cpu(work_sccb.h.length) < sizeof(SCCBHeader)) {
229 r = -PGM_SPECIFICATION;
230 goto out;
231 }
232
233 switch (code & SCLP_CMD_CODE_MASK) {
234 case SCLP_CMDW_READ_SCP_INFO:
235 case SCLP_CMDW_READ_SCP_INFO_FORCED:
236 case SCLP_CMDW_READ_CPU_INFO:
237 case SCLP_CMDW_CONFIGURE_IOA:
238 case SCLP_CMDW_DECONFIGURE_IOA:
239 case SCLP_CMD_READ_EVENT_DATA:
240 case SCLP_CMD_WRITE_EVENT_DATA:
241 case SCLP_CMD_WRITE_EVENT_MASK:
242 break;
243 default:
244 work_sccb.h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
245 goto out_write;
246 }
247
248 if ((sccb + be16_to_cpu(work_sccb.h.length)) > ((sccb & PAGE_MASK) + PAGE_SIZE)) {
249 work_sccb.h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION);
250 goto out_write;
251 }
252
253 sclp_c->execute(sclp, &work_sccb, code);
254out_write:
255 cpu_physical_memory_write(sccb, &work_sccb,
256 be16_to_cpu(work_sccb.h.length));
257
258 sclp_c->service_interrupt(sclp, sccb);
259
260out:
261 return r;
262}
263
264static void service_interrupt(SCLPDevice *sclp, uint32_t sccb)
265{
266 SCLPEventFacility *ef = sclp->event_facility;
267 SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
268
269 uint32_t param = sccb & ~3;
270
271
272 param |= efc->event_pending(ef) ? 1 : 0;
273
274 if (!param) {
275
276 return;
277 }
278 s390_sclp_extint(param);
279}
280
281void sclp_service_interrupt(uint32_t sccb)
282{
283 SCLPDevice *sclp = get_sclp_device();
284 SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
285
286 sclp_c->service_interrupt(sclp, sccb);
287}
288
289
290
291void s390_sclp_init(void)
292{
293 Object *new = object_new(TYPE_SCLP);
294
295 object_property_add_child(qdev_get_machine(), TYPE_SCLP, new,
296 NULL);
297 object_unref(OBJECT(new));
298 qdev_init_nofail(DEVICE(new));
299}
300
301static void sclp_realize(DeviceState *dev, Error **errp)
302{
303 MachineState *machine = MACHINE(qdev_get_machine());
304 SCLPDevice *sclp = SCLP(dev);
305 Error *err = NULL;
306 uint64_t hw_limit;
307 int ret;
308
309 object_property_set_bool(OBJECT(sclp->event_facility), true, "realized",
310 &err);
311 if (err) {
312 goto out;
313 }
314
315
316
317
318
319 qdev_set_parent_bus(DEVICE(sclp->event_facility), sysbus_get_default());
320
321 ret = s390_set_memory_limit(machine->maxram_size, &hw_limit);
322 if (ret == -E2BIG) {
323 error_setg(&err, "host supports a maximum of %" PRIu64 " GB",
324 hw_limit / GiB);
325 } else if (ret) {
326 error_setg(&err, "setting the guest size failed");
327 }
328
329out:
330 error_propagate(errp, err);
331}
332
333static void sclp_memory_init(SCLPDevice *sclp)
334{
335 MachineState *machine = MACHINE(qdev_get_machine());
336 ram_addr_t initial_mem = machine->ram_size;
337 int increment_size = 20;
338
339
340
341
342
343 while ((initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) {
344 increment_size++;
345 }
346 sclp->increment_size = increment_size;
347
348
349
350
351 initial_mem = initial_mem >> increment_size << increment_size;
352
353 machine->ram_size = initial_mem;
354 machine->maxram_size = initial_mem;
355
356 ram_size = initial_mem;
357}
358
359static void sclp_init(Object *obj)
360{
361 SCLPDevice *sclp = SCLP(obj);
362 Object *new;
363
364 new = object_new(TYPE_SCLP_EVENT_FACILITY);
365 object_property_add_child(obj, TYPE_SCLP_EVENT_FACILITY, new, NULL);
366 object_unref(new);
367 sclp->event_facility = EVENT_FACILITY(new);
368
369 sclp_memory_init(sclp);
370}
371
372static void sclp_class_init(ObjectClass *oc, void *data)
373{
374 SCLPDeviceClass *sc = SCLP_CLASS(oc);
375 DeviceClass *dc = DEVICE_CLASS(oc);
376
377 dc->desc = "SCLP (Service-Call Logical Processor)";
378 dc->realize = sclp_realize;
379 dc->hotpluggable = false;
380 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
381
382
383
384
385 dc->user_creatable = false;
386
387 sc->read_SCP_info = read_SCP_info;
388 sc->read_cpu_info = sclp_read_cpu_info;
389 sc->execute = sclp_execute;
390 sc->service_interrupt = service_interrupt;
391}
392
393static TypeInfo sclp_info = {
394 .name = TYPE_SCLP,
395 .parent = TYPE_DEVICE,
396 .instance_init = sclp_init,
397 .instance_size = sizeof(SCLPDevice),
398 .class_init = sclp_class_init,
399 .class_size = sizeof(SCLPDeviceClass),
400};
401
402static void register_types(void)
403{
404 type_register_static(&sclp_info);
405}
406type_init(register_types);
407