]>
Commit | Line | Data |
---|---|---|
f6c98f92 HG |
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 | ||
9615495a | 15 | #include "qemu/osdep.h" |
393fc4c7 | 16 | #include "qemu/units.h" |
da34e65c | 17 | #include "qapi/error.h" |
f6c98f92 | 18 | #include "cpu.h" |
8cc3aecf | 19 | #include "sysemu/sysemu.h" |
311467f7 | 20 | #include "hw/boards.h" |
83c9f4ca | 21 | #include "hw/s390x/sclp.h" |
477a72a1 | 22 | #include "hw/s390x/event-facility.h" |
8cba80c3 | 23 | #include "hw/s390x/s390-pci-bus.h" |
b038411d | 24 | #include "hw/s390x/ipl.h" |
f6c98f92 | 25 | |
25a3c5af DH |
26 | static inline SCLPDevice *get_sclp_device(void) |
27 | { | |
989fd865 CB |
28 | static SCLPDevice *sclp; |
29 | ||
30 | if (!sclp) { | |
31 | sclp = SCLP(object_resolve_path_type("", TYPE_SCLP, NULL)); | |
32 | } | |
33 | return sclp; | |
25a3c5af DH |
34 | } |
35 | ||
bb535bb6 | 36 | static void prepare_cpu_entries(SCLPDevice *sclp, CPUEntry *entry, int *count) |
026546e6 | 37 | { |
bb535bb6 | 38 | MachineState *ms = MACHINE(qdev_get_machine()); |
4dd4200e | 39 | uint8_t features[SCCB_CPU_FEATURE_LEN] = { 0 }; |
026546e6 DH |
40 | int i; |
41 | ||
4dd4200e | 42 | s390_get_feat_block(S390_FEAT_TYPE_SCLP_CPU, features); |
bb535bb6 DH |
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)++; | |
026546e6 DH |
51 | } |
52 | } | |
53 | ||
f6c98f92 | 54 | /* Provide information about the configuration, CPUs and storage */ |
25a3c5af | 55 | static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb) |
f6c98f92 HG |
56 | { |
57 | ReadInfo *read_info = (ReadInfo *) sccb; | |
311467f7 | 58 | MachineState *machine = MACHINE(qdev_get_machine()); |
bb535bb6 | 59 | int cpu_count; |
1def6656 | 60 | int rnsize, rnmax; |
b038411d | 61 | IplParameterBlock *ipib = s390_ipl_get_iplb(); |
8cc3aecf | 62 | |
8cc3aecf | 63 | /* CPU information */ |
bb535bb6 | 64 | prepare_cpu_entries(sclp, read_info->entries, &cpu_count); |
8cc3aecf JH |
65 | read_info->entries_cpu = cpu_to_be16(cpu_count); |
66 | read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries)); | |
ae71ed86 | 67 | read_info->highest_cpu = cpu_to_be16(machine->smp.max_cpus - 1); |
8cc3aecf | 68 | |
059be520 DH |
69 | read_info->ibc_val = cpu_to_be32(s390_get_ibc_val()); |
70 | ||
4dd4200e DH |
71 | /* Configuration Characteristic (Extension) */ |
72 | s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR, | |
73 | read_info->conf_char); | |
74 | s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT, | |
75 | read_info->conf_char_ext); | |
76 | ||
8cba80c3 | 77 | read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO | |
80b7a265 | 78 | SCLP_HAS_IOA_RECONFIG); |
f6c98f92 | 79 | |
3fad3252 | 80 | read_info->mha_pow = s390_get_mha_pow(); |
a3669307 | 81 | read_info->hmfai = cpu_to_be32(s390_get_hmfai()); |
1def6656 | 82 | |
71a2fd35 | 83 | rnsize = 1 << (sclp->increment_size - 20); |
1def6656 MR |
84 | if (rnsize <= 128) { |
85 | read_info->rnsize = rnsize; | |
86 | } else { | |
87 | read_info->rnsize = 0; | |
88 | read_info->rnsize2 = cpu_to_be32(rnsize); | |
89 | } | |
90 | ||
82fab5c5 DH |
91 | /* we don't support standby memory, maxram_size is never exposed */ |
92 | rnmax = machine->ram_size >> sclp->increment_size; | |
1def6656 MR |
93 | if (rnmax < 0x10000) { |
94 | read_info->rnmax = cpu_to_be16(rnmax); | |
95 | } else { | |
96 | read_info->rnmax = cpu_to_be16(0); | |
97 | read_info->rnmax2 = cpu_to_be64(rnmax); | |
98 | } | |
99 | ||
b038411d FA |
100 | if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) { |
101 | memcpy(&read_info->loadparm, &ipib->loadparm, | |
102 | sizeof(read_info->loadparm)); | |
103 | } else { | |
104 | s390_ipl_set_loadparm(read_info->loadparm); | |
105 | } | |
106 | ||
1def6656 MR |
107 | sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION); |
108 | } | |
109 | ||
8cc3aecf | 110 | /* Provide information about the CPU */ |
25a3c5af | 111 | static void sclp_read_cpu_info(SCLPDevice *sclp, SCCB *sccb) |
8cc3aecf JH |
112 | { |
113 | ReadCpuInfo *cpu_info = (ReadCpuInfo *) sccb; | |
bb535bb6 | 114 | int cpu_count; |
8cc3aecf | 115 | |
bb535bb6 | 116 | prepare_cpu_entries(sclp, cpu_info->entries, &cpu_count); |
8cc3aecf JH |
117 | cpu_info->nr_configured = cpu_to_be16(cpu_count); |
118 | cpu_info->offset_configured = cpu_to_be16(offsetof(ReadCpuInfo, entries)); | |
119 | cpu_info->nr_standby = cpu_to_be16(0); | |
120 | ||
121 | /* The standby offset is 16-byte for each CPU */ | |
122 | cpu_info->offset_standby = cpu_to_be16(cpu_info->offset_configured | |
123 | + cpu_info->nr_configured*sizeof(CPUEntry)); | |
124 | ||
8cc3aecf JH |
125 | |
126 | sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION); | |
127 | } | |
128 | ||
80b7a265 CH |
129 | static void sclp_configure_io_adapter(SCLPDevice *sclp, SCCB *sccb, |
130 | bool configure) | |
131 | { | |
132 | int rc; | |
133 | ||
134 | if (be16_to_cpu(sccb->h.length) < 16) { | |
135 | rc = SCLP_RC_INSUFFICIENT_SCCB_LENGTH; | |
136 | goto out_err; | |
137 | } | |
138 | ||
139 | switch (((IoaCfgSccb *)sccb)->atype) { | |
140 | case SCLP_RECONFIG_PCI_ATYPE: | |
141 | if (s390_has_feat(S390_FEAT_ZPCI)) { | |
142 | if (configure) { | |
143 | s390_pci_sclp_configure(sccb); | |
144 | } else { | |
145 | s390_pci_sclp_deconfigure(sccb); | |
146 | } | |
147 | return; | |
148 | } | |
149 | /* fallthrough */ | |
150 | default: | |
151 | rc = SCLP_RC_ADAPTER_TYPE_NOT_RECOGNIZED; | |
152 | } | |
153 | ||
154 | out_err: | |
155 | sccb->h.response_code = cpu_to_be16(rc); | |
156 | } | |
157 | ||
25a3c5af | 158 | static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code) |
f6c98f92 | 159 | { |
25a3c5af DH |
160 | SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); |
161 | SCLPEventFacility *ef = sclp->event_facility; | |
477a72a1 | 162 | SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef); |
559a17a1 | 163 | |
5f04c14a | 164 | switch (code & SCLP_CMD_CODE_MASK) { |
f6c98f92 HG |
165 | case SCLP_CMDW_READ_SCP_INFO: |
166 | case SCLP_CMDW_READ_SCP_INFO_FORCED: | |
25a3c5af | 167 | sclp_c->read_SCP_info(sclp, sccb); |
f6c98f92 | 168 | break; |
8cc3aecf | 169 | case SCLP_CMDW_READ_CPU_INFO: |
25a3c5af | 170 | sclp_c->read_cpu_info(sclp, sccb); |
8cc3aecf | 171 | break; |
80b7a265 CH |
172 | case SCLP_CMDW_CONFIGURE_IOA: |
173 | sclp_configure_io_adapter(sclp, sccb, true); | |
8cba80c3 | 174 | break; |
80b7a265 CH |
175 | case SCLP_CMDW_DECONFIGURE_IOA: |
176 | sclp_configure_io_adapter(sclp, sccb, false); | |
8cba80c3 | 177 | break; |
f6c98f92 | 178 | default: |
477a72a1 | 179 | efc->command_handler(ef, sccb, code); |
f6c98f92 HG |
180 | break; |
181 | } | |
182 | } | |
183 | ||
6e252802 | 184 | int sclp_service_call(CPUS390XState *env, uint64_t sccb, uint32_t code) |
f6c98f92 | 185 | { |
25a3c5af DH |
186 | SCLPDevice *sclp = get_sclp_device(); |
187 | SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); | |
f6c98f92 HG |
188 | int r = 0; |
189 | SCCB work_sccb; | |
190 | ||
191 | hwaddr sccb_len = sizeof(SCCB); | |
192 | ||
193 | /* first some basic checks on program checks */ | |
6e252802 TH |
194 | if (env->psw.mask & PSW_MASK_PSTATE) { |
195 | r = -PGM_PRIVILEGED; | |
196 | goto out; | |
197 | } | |
f6c98f92 HG |
198 | if (cpu_physical_memory_is_io(sccb)) { |
199 | r = -PGM_ADDRESSING; | |
200 | goto out; | |
201 | } | |
6e252802 TH |
202 | if ((sccb & ~0x1fffUL) == 0 || (sccb & ~0x1fffUL) == env->psa |
203 | || (sccb & ~0x7ffffff8UL) != 0) { | |
f6c98f92 HG |
204 | r = -PGM_SPECIFICATION; |
205 | goto out; | |
206 | } | |
207 | ||
208 | /* | |
209 | * we want to work on a private copy of the sccb, to prevent guests | |
210 | * from playing dirty tricks by modifying the memory content after | |
211 | * the host has checked the values | |
212 | */ | |
213 | cpu_physical_memory_read(sccb, &work_sccb, sccb_len); | |
214 | ||
215 | /* Valid sccb sizes */ | |
d959f6cf | 216 | if (be16_to_cpu(work_sccb.h.length) < sizeof(SCCBHeader)) { |
f6c98f92 HG |
217 | r = -PGM_SPECIFICATION; |
218 | goto out; | |
219 | } | |
220 | ||
679b8447 JF |
221 | switch (code & SCLP_CMD_CODE_MASK) { |
222 | case SCLP_CMDW_READ_SCP_INFO: | |
223 | case SCLP_CMDW_READ_SCP_INFO_FORCED: | |
224 | case SCLP_CMDW_READ_CPU_INFO: | |
225 | case SCLP_CMDW_CONFIGURE_IOA: | |
226 | case SCLP_CMDW_DECONFIGURE_IOA: | |
227 | case SCLP_CMD_READ_EVENT_DATA: | |
228 | case SCLP_CMD_WRITE_EVENT_DATA: | |
229 | case SCLP_CMD_WRITE_EVENT_MASK: | |
230 | break; | |
231 | default: | |
232 | work_sccb.h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND); | |
233 | goto out_write; | |
234 | } | |
f6c98f92 | 235 | |
6f6c9333 JF |
236 | if ((sccb + be16_to_cpu(work_sccb.h.length)) > ((sccb & PAGE_MASK) + PAGE_SIZE)) { |
237 | work_sccb.h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION); | |
238 | goto out_write; | |
239 | } | |
240 | ||
679b8447 JF |
241 | sclp_c->execute(sclp, &work_sccb, code); |
242 | out_write: | |
f6c98f92 HG |
243 | cpu_physical_memory_write(sccb, &work_sccb, |
244 | be16_to_cpu(work_sccb.h.length)); | |
245 | ||
1723a1b6 | 246 | sclp_c->service_interrupt(sclp, sccb); |
f6c98f92 HG |
247 | |
248 | out: | |
249 | return r; | |
250 | } | |
251 | ||
1723a1b6 | 252 | static void service_interrupt(SCLPDevice *sclp, uint32_t sccb) |
f6c98f92 | 253 | { |
1723a1b6 | 254 | SCLPEventFacility *ef = sclp->event_facility; |
477a72a1 HG |
255 | SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef); |
256 | ||
559a17a1 HG |
257 | uint32_t param = sccb & ~3; |
258 | ||
259 | /* Indicate whether an event is still pending */ | |
477a72a1 | 260 | param |= efc->event_pending(ef) ? 1 : 0; |
559a17a1 HG |
261 | |
262 | if (!param) { | |
263 | /* No need to send an interrupt, there's nothing to be notified about */ | |
264 | return; | |
265 | } | |
266 | s390_sclp_extint(param); | |
f6c98f92 HG |
267 | } |
268 | ||
1723a1b6 DH |
269 | void sclp_service_interrupt(uint32_t sccb) |
270 | { | |
271 | SCLPDevice *sclp = get_sclp_device(); | |
272 | SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); | |
273 | ||
274 | sclp_c->service_interrupt(sclp, sccb); | |
275 | } | |
276 | ||
f6c98f92 HG |
277 | /* qemu object creation and initialization functions */ |
278 | ||
559a17a1 HG |
279 | void s390_sclp_init(void) |
280 | { | |
515190d9 | 281 | Object *new = object_new(TYPE_SCLP); |
559a17a1 | 282 | |
515190d9 DH |
283 | object_property_add_child(qdev_get_machine(), TYPE_SCLP, new, |
284 | NULL); | |
285 | object_unref(OBJECT(new)); | |
286 | qdev_init_nofail(DEVICE(new)); | |
559a17a1 | 287 | } |
0844df77 | 288 | |
515190d9 DH |
289 | static void sclp_realize(DeviceState *dev, Error **errp) |
290 | { | |
1cf065fb | 291 | MachineState *machine = MACHINE(qdev_get_machine()); |
515190d9 | 292 | SCLPDevice *sclp = SCLP(dev); |
e6da780d | 293 | Error *err = NULL; |
1cf065fb DH |
294 | uint64_t hw_limit; |
295 | int ret; | |
515190d9 DH |
296 | |
297 | object_property_set_bool(OBJECT(sclp->event_facility), true, "realized", | |
e6da780d MA |
298 | &err); |
299 | if (err) { | |
24da21f2 | 300 | goto out; |
515190d9 | 301 | } |
8b638c43 DH |
302 | /* |
303 | * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long | |
304 | * as we can't find a fitting bus via the qom tree, we have to add the | |
305 | * event facility to the sysbus, so e.g. a sclp console can be created. | |
306 | */ | |
307 | qdev_set_parent_bus(DEVICE(sclp->event_facility), sysbus_get_default()); | |
1cf065fb DH |
308 | |
309 | ret = s390_set_memory_limit(machine->maxram_size, &hw_limit); | |
310 | if (ret == -E2BIG) { | |
d0e31a10 | 311 | error_setg(&err, "host supports a maximum of %" PRIu64 " GB", |
393fc4c7 | 312 | hw_limit / GiB); |
1cf065fb | 313 | } else if (ret) { |
d0e31a10 | 314 | error_setg(&err, "setting the guest size failed"); |
1cf065fb | 315 | } |
24da21f2 MA |
316 | |
317 | out: | |
e6da780d | 318 | error_propagate(errp, err); |
515190d9 DH |
319 | } |
320 | ||
1cf065fb DH |
321 | static void sclp_memory_init(SCLPDevice *sclp) |
322 | { | |
323 | MachineState *machine = MACHINE(qdev_get_machine()); | |
324 | ram_addr_t initial_mem = machine->ram_size; | |
1cf065fb DH |
325 | int increment_size = 20; |
326 | ||
327 | /* The storage increment size is a multiple of 1M and is a power of 2. | |
328 | * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer. | |
329 | * The variable 'increment_size' is an exponent of 2 that can be | |
330 | * used to calculate the size (in bytes) of an increment. */ | |
331 | while ((initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) { | |
332 | increment_size++; | |
333 | } | |
71a2fd35 | 334 | sclp->increment_size = increment_size; |
1cf065fb | 335 | |
82fab5c5 DH |
336 | /* The core memory area needs to be aligned with the increment size. |
337 | * In effect, this can cause the user-specified memory size to be rounded | |
338 | * down to align with the nearest increment boundary. */ | |
1cf065fb | 339 | initial_mem = initial_mem >> increment_size << increment_size; |
1cf065fb | 340 | |
1cf065fb | 341 | machine->ram_size = initial_mem; |
408e5ace | 342 | machine->maxram_size = initial_mem; |
1cf065fb DH |
343 | /* let's propagate the changed ram size into the global variable. */ |
344 | ram_size = initial_mem; | |
345 | } | |
346 | ||
515190d9 DH |
347 | static void sclp_init(Object *obj) |
348 | { | |
349 | SCLPDevice *sclp = SCLP(obj); | |
350 | Object *new; | |
351 | ||
352 | new = object_new(TYPE_SCLP_EVENT_FACILITY); | |
353 | object_property_add_child(obj, TYPE_SCLP_EVENT_FACILITY, new, NULL); | |
515190d9 DH |
354 | object_unref(new); |
355 | sclp->event_facility = EVENT_FACILITY(new); | |
1cf065fb DH |
356 | |
357 | sclp_memory_init(sclp); | |
515190d9 DH |
358 | } |
359 | ||
360 | static void sclp_class_init(ObjectClass *oc, void *data) | |
361 | { | |
25a3c5af | 362 | SCLPDeviceClass *sc = SCLP_CLASS(oc); |
515190d9 DH |
363 | DeviceClass *dc = DEVICE_CLASS(oc); |
364 | ||
365 | dc->desc = "SCLP (Service-Call Logical Processor)"; | |
366 | dc->realize = sclp_realize; | |
367 | dc->hotpluggable = false; | |
368 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); | |
e6cb60bf TH |
369 | /* |
370 | * Reason: Creates TYPE_SCLP_EVENT_FACILITY in sclp_init | |
371 | * which is a non-pluggable sysbus device | |
372 | */ | |
373 | dc->user_creatable = false; | |
25a3c5af DH |
374 | |
375 | sc->read_SCP_info = read_SCP_info; | |
25a3c5af DH |
376 | sc->read_cpu_info = sclp_read_cpu_info; |
377 | sc->execute = sclp_execute; | |
1723a1b6 | 378 | sc->service_interrupt = service_interrupt; |
515190d9 DH |
379 | } |
380 | ||
381 | static TypeInfo sclp_info = { | |
382 | .name = TYPE_SCLP, | |
383 | .parent = TYPE_DEVICE, | |
384 | .instance_init = sclp_init, | |
385 | .instance_size = sizeof(SCLPDevice), | |
386 | .class_init = sclp_class_init, | |
387 | .class_size = sizeof(SCLPDeviceClass), | |
388 | }; | |
389 | ||
0844df77 MR |
390 | static void register_types(void) |
391 | { | |
515190d9 | 392 | type_register_static(&sclp_info); |
0844df77 MR |
393 | } |
394 | type_init(register_types); |