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 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 | /* Provide information about the configuration, CPUs and storage */ |
55 | static 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 | /* CPU information */ |
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 | /* 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 | |
77 | read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO | |
78 | SCLP_HAS_IOA_RECONFIG); |
79 | |
80 | read_info->mha_pow = s390_get_mha_pow(); |
81 | read_info->hmfai = cpu_to_be32(s390_get_hmfai()); |
82 | |
83 | rnsize = 1 << (sclp->increment_size - 20); |
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 | |
91 | /* we don't support standby memory, maxram_size is never exposed */ |
92 | rnmax = machine->ram_size >> sclp->increment_size; |
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 | |
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 | |
107 | sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION); |
108 | } |
109 | |
110 | /* Provide information about the CPU */ |
111 | static void sclp_read_cpu_info(SCLPDevice *sclp, SCCB *sccb) |
112 | { |
113 | ReadCpuInfo *cpu_info = (ReadCpuInfo *) sccb; |
114 | int cpu_count; |
115 | |
116 | prepare_cpu_entries(sclp, cpu_info->entries, &cpu_count); |
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 | |
125 | |
126 | sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION); |
127 | } |
128 | |
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 | |
158 | static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code) |
159 | { |
160 | SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); |
161 | SCLPEventFacility *ef = sclp->event_facility; |
162 | SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef); |
163 | |
164 | switch (code & SCLP_CMD_CODE_MASK) { |
165 | case SCLP_CMDW_READ_SCP_INFO: |
166 | case SCLP_CMDW_READ_SCP_INFO_FORCED: |
167 | sclp_c->read_SCP_info(sclp, sccb); |
168 | break; |
169 | case SCLP_CMDW_READ_CPU_INFO: |
170 | sclp_c->read_cpu_info(sclp, sccb); |
171 | break; |
172 | case SCLP_CMDW_CONFIGURE_IOA: |
173 | sclp_configure_io_adapter(sclp, sccb, true); |
174 | break; |
175 | case SCLP_CMDW_DECONFIGURE_IOA: |
176 | sclp_configure_io_adapter(sclp, sccb, false); |
177 | break; |
178 | default: |
179 | efc->command_handler(ef, sccb, code); |
180 | break; |
181 | } |
182 | } |
183 | |
184 | int sclp_service_call(CPUS390XState *env, uint64_t sccb, uint32_t code) |
185 | { |
186 | SCLPDevice *sclp = get_sclp_device(); |
187 | SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); |
188 | int r = 0; |
189 | SCCB work_sccb; |
190 | |
191 | hwaddr sccb_len = sizeof(SCCB); |
192 | |
193 | /* first some basic checks on program checks */ |
194 | if (env->psw.mask & PSW_MASK_PSTATE) { |
195 | r = -PGM_PRIVILEGED; |
196 | goto out; |
197 | } |
198 | if (cpu_physical_memory_is_io(sccb)) { |
199 | r = -PGM_ADDRESSING; |
200 | goto out; |
201 | } |
202 | if ((sccb & ~0x1fffUL) == 0 || (sccb & ~0x1fffUL) == env->psa |
203 | || (sccb & ~0x7ffffff8UL) != 0) { |
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 */ |
216 | if (be16_to_cpu(work_sccb.h.length) < sizeof(SCCBHeader) || |
217 | be16_to_cpu(work_sccb.h.length) > SCCB_SIZE) { |
218 | r = -PGM_SPECIFICATION; |
219 | goto out; |
220 | } |
221 | |
222 | sclp_c->execute(sclp, &work_sccb, code); |
223 | |
224 | cpu_physical_memory_write(sccb, &work_sccb, |
225 | be16_to_cpu(work_sccb.h.length)); |
226 | |
227 | sclp_c->service_interrupt(sclp, sccb); |
228 | |
229 | out: |
230 | return r; |
231 | } |
232 | |
233 | static void service_interrupt(SCLPDevice *sclp, uint32_t sccb) |
234 | { |
235 | SCLPEventFacility *ef = sclp->event_facility; |
236 | SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef); |
237 | |
238 | uint32_t param = sccb & ~3; |
239 | |
240 | /* Indicate whether an event is still pending */ |
241 | param |= efc->event_pending(ef) ? 1 : 0; |
242 | |
243 | if (!param) { |
244 | /* No need to send an interrupt, there's nothing to be notified about */ |
245 | return; |
246 | } |
247 | s390_sclp_extint(param); |
248 | } |
249 | |
250 | void sclp_service_interrupt(uint32_t sccb) |
251 | { |
252 | SCLPDevice *sclp = get_sclp_device(); |
253 | SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); |
254 | |
255 | sclp_c->service_interrupt(sclp, sccb); |
256 | } |
257 | |
258 | /* qemu object creation and initialization functions */ |
259 | |
260 | void s390_sclp_init(void) |
261 | { |
262 | Object *new = object_new(TYPE_SCLP); |
263 | |
264 | object_property_add_child(qdev_get_machine(), TYPE_SCLP, new, |
265 | NULL); |
266 | object_unref(OBJECT(new)); |
267 | qdev_init_nofail(DEVICE(new)); |
268 | } |
269 | |
270 | static void sclp_realize(DeviceState *dev, Error **errp) |
271 | { |
272 | MachineState *machine = MACHINE(qdev_get_machine()); |
273 | SCLPDevice *sclp = SCLP(dev); |
274 | Error *err = NULL; |
275 | uint64_t hw_limit; |
276 | int ret; |
277 | |
278 | object_property_set_bool(OBJECT(sclp->event_facility), true, "realized" , |
279 | &err); |
280 | if (err) { |
281 | goto out; |
282 | } |
283 | /* |
284 | * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long |
285 | * as we can't find a fitting bus via the qom tree, we have to add the |
286 | * event facility to the sysbus, so e.g. a sclp console can be created. |
287 | */ |
288 | qdev_set_parent_bus(DEVICE(sclp->event_facility), sysbus_get_default()); |
289 | |
290 | ret = s390_set_memory_limit(machine->maxram_size, &hw_limit); |
291 | if (ret == -E2BIG) { |
292 | error_setg(&err, "host supports a maximum of %" PRIu64 " GB" , |
293 | hw_limit / GiB); |
294 | } else if (ret) { |
295 | error_setg(&err, "setting the guest size failed" ); |
296 | } |
297 | |
298 | out: |
299 | error_propagate(errp, err); |
300 | } |
301 | |
302 | static void sclp_memory_init(SCLPDevice *sclp) |
303 | { |
304 | MachineState *machine = MACHINE(qdev_get_machine()); |
305 | ram_addr_t initial_mem = machine->ram_size; |
306 | int increment_size = 20; |
307 | |
308 | /* The storage increment size is a multiple of 1M and is a power of 2. |
309 | * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer. |
310 | * The variable 'increment_size' is an exponent of 2 that can be |
311 | * used to calculate the size (in bytes) of an increment. */ |
312 | while ((initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) { |
313 | increment_size++; |
314 | } |
315 | sclp->increment_size = increment_size; |
316 | |
317 | /* The core memory area needs to be aligned with the increment size. |
318 | * In effect, this can cause the user-specified memory size to be rounded |
319 | * down to align with the nearest increment boundary. */ |
320 | initial_mem = initial_mem >> increment_size << increment_size; |
321 | |
322 | machine->ram_size = initial_mem; |
323 | machine->maxram_size = initial_mem; |
324 | /* let's propagate the changed ram size into the global variable. */ |
325 | ram_size = initial_mem; |
326 | } |
327 | |
328 | static void sclp_init(Object *obj) |
329 | { |
330 | SCLPDevice *sclp = SCLP(obj); |
331 | Object *new; |
332 | |
333 | new = object_new(TYPE_SCLP_EVENT_FACILITY); |
334 | object_property_add_child(obj, TYPE_SCLP_EVENT_FACILITY, new, NULL); |
335 | object_unref(new); |
336 | sclp->event_facility = EVENT_FACILITY(new); |
337 | |
338 | sclp_memory_init(sclp); |
339 | } |
340 | |
341 | static void sclp_class_init(ObjectClass *oc, void *data) |
342 | { |
343 | SCLPDeviceClass *sc = SCLP_CLASS(oc); |
344 | DeviceClass *dc = DEVICE_CLASS(oc); |
345 | |
346 | dc->desc = "SCLP (Service-Call Logical Processor)" ; |
347 | dc->realize = sclp_realize; |
348 | dc->hotpluggable = false; |
349 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); |
350 | /* |
351 | * Reason: Creates TYPE_SCLP_EVENT_FACILITY in sclp_init |
352 | * which is a non-pluggable sysbus device |
353 | */ |
354 | dc->user_creatable = false; |
355 | |
356 | sc->read_SCP_info = read_SCP_info; |
357 | sc->read_cpu_info = sclp_read_cpu_info; |
358 | sc->execute = sclp_execute; |
359 | sc->service_interrupt = service_interrupt; |
360 | } |
361 | |
362 | static TypeInfo sclp_info = { |
363 | .name = TYPE_SCLP, |
364 | .parent = TYPE_DEVICE, |
365 | .instance_init = sclp_init, |
366 | .instance_size = sizeof(SCLPDevice), |
367 | .class_init = sclp_class_init, |
368 | .class_size = sizeof(SCLPDeviceClass), |
369 | }; |
370 | |
371 | static void register_types(void) |
372 | { |
373 | type_register_static(&sclp_info); |
374 | } |
375 | type_init(register_types); |
376 | |