blob: f57ce7b73943564f4d44dcbe0cf03672586bf914 [file] [log] [blame]
Heinz Graalfsf6c98f922012-10-29 02:13:22 +00001/*
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
Peter Maydell96154952016-01-26 18:17:00 +000015#include "qemu/osdep.h"
Philippe Mathieu-Daudé393fc4c2018-06-25 09:42:11 -030016#include "qemu/units.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010017#include "qapi/error.h"
Heinz Graalfsf6c98f922012-10-29 02:13:22 +000018#include "cpu.h"
Jason J. Herne8cc3aec2014-01-20 14:51:49 -050019#include "sysemu/sysemu.h"
David Hildenbrand311467f2015-05-29 13:14:50 +020020#include "hw/boards.h"
Paolo Bonzini83c9f4c2013-02-04 15:40:22 +010021#include "hw/s390x/sclp.h"
Heinz Graalfs477a72a2013-12-18 10:10:49 +010022#include "hw/s390x/event-facility.h"
Frank Blaschka8cba80c2015-01-09 09:04:38 +010023#include "hw/s390x/s390-pci-bus.h"
Farhan Alib0384112016-03-29 16:34:37 +020024#include "hw/s390x/ipl.h"
Heinz Graalfsf6c98f922012-10-29 02:13:22 +000025
David Hildenbrand25a3c5a2015-05-27 10:04:56 +020026static inline SCLPDevice *get_sclp_device(void)
27{
Christian Borntraeger989fd862016-08-10 12:14:19 +020028 static SCLPDevice *sclp;
29
30 if (!sclp) {
31 sclp = SCLP(object_resolve_path_type("", TYPE_SCLP, NULL));
32 }
33 return sclp;
David Hildenbrand25a3c5a2015-05-27 10:04:56 +020034}
35
David Hildenbrandbb535bb2017-09-13 15:24:16 +020036static void prepare_cpu_entries(SCLPDevice *sclp, CPUEntry *entry, int *count)
David Hildenbrand026546e2016-09-05 10:52:27 +020037{
David Hildenbrandbb535bb2017-09-13 15:24:16 +020038 MachineState *ms = MACHINE(qdev_get_machine());
David Hildenbrand4dd42002016-09-05 10:52:29 +020039 uint8_t features[SCCB_CPU_FEATURE_LEN] = { 0 };
David Hildenbrand026546e2016-09-05 10:52:27 +020040 int i;
41
David Hildenbrand4dd42002016-09-05 10:52:29 +020042 s390_get_feat_block(S390_FEAT_TYPE_SCLP_CPU, features);
David Hildenbrandbb535bb2017-09-13 15:24:16 +020043 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)++;
David Hildenbrand026546e2016-09-05 10:52:27 +020051 }
52}
53
Heinz Graalfsf6c98f922012-10-29 02:13:22 +000054/* Provide information about the configuration, CPUs and storage */
David Hildenbrand25a3c5a2015-05-27 10:04:56 +020055static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
Heinz Graalfsf6c98f922012-10-29 02:13:22 +000056{
57 ReadInfo *read_info = (ReadInfo *) sccb;
David Hildenbrand311467f2015-05-29 13:14:50 +020058 MachineState *machine = MACHINE(qdev_get_machine());
David Hildenbrandbb535bb2017-09-13 15:24:16 +020059 int cpu_count;
Matthew Rosato1def6652014-08-28 11:25:35 -040060 int rnsize, rnmax;
Farhan Alib0384112016-03-29 16:34:37 +020061 IplParameterBlock *ipib = s390_ipl_get_iplb();
Jason J. Herne8cc3aec2014-01-20 14:51:49 -050062
Jason J. Herne8cc3aec2014-01-20 14:51:49 -050063 /* CPU information */
David Hildenbrandbb535bb2017-09-13 15:24:16 +020064 prepare_cpu_entries(sclp, read_info->entries, &cpu_count);
Jason J. Herne8cc3aec2014-01-20 14:51:49 -050065 read_info->entries_cpu = cpu_to_be16(cpu_count);
66 read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries));
Like Xuae71ed82019-05-19 04:54:24 +080067 read_info->highest_cpu = cpu_to_be16(machine->smp.max_cpus - 1);
Jason J. Herne8cc3aec2014-01-20 14:51:49 -050068
David Hildenbrand059be522016-09-05 10:52:30 +020069 read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
70
Claudio Imbrenda832be0d2019-09-27 15:33:23 +020071 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
David Hildenbrand4dd42002016-09-05 10:52:29 +020077 /* Configuration Characteristic (Extension) */
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
Frank Blaschka8cba80c2015-01-09 09:04:38 +010083 read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
Cornelia Huck80b7a262017-07-06 17:13:14 +020084 SCLP_HAS_IOA_RECONFIG);
Heinz Graalfsf6c98f922012-10-29 02:13:22 +000085
David Hildenbrand3fad3252016-09-05 10:52:31 +020086 read_info->mha_pow = s390_get_mha_pow();
David Hildenbranda3669302016-09-05 10:52:32 +020087 read_info->hmfai = cpu_to_be32(s390_get_hmfai());
Matthew Rosato1def6652014-08-28 11:25:35 -040088
David Hildenbrand71a2fd32015-06-01 13:03:23 +020089 rnsize = 1 << (sclp->increment_size - 20);
Matthew Rosato1def6652014-08-28 11:25:35 -040090 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
David Hildenbrand82fab5c2018-02-19 18:42:31 +010097 /* we don't support standby memory, maxram_size is never exposed */
98 rnmax = machine->ram_size >> sclp->increment_size;
Matthew Rosato1def6652014-08-28 11:25:35 -040099 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
Farhan Alib0384112016-03-29 16:34:37 +0200106 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
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000113 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
114}
115
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500116/* Provide information about the CPU */
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200117static void sclp_read_cpu_info(SCLPDevice *sclp, SCCB *sccb)
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500118{
119 ReadCpuInfo *cpu_info = (ReadCpuInfo *) sccb;
David Hildenbrandbb535bb2017-09-13 15:24:16 +0200120 int cpu_count;
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500121
David Hildenbrandbb535bb2017-09-13 15:24:16 +0200122 prepare_cpu_entries(sclp, cpu_info->entries, &cpu_count);
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500123 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
Claudio Imbrenda832be0d2019-09-27 15:33:23 +0200127 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
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500133 /* The standby offset is 16-byte for each CPU */
134 cpu_info->offset_standby = cpu_to_be16(cpu_info->offset_configured
135 + cpu_info->nr_configured*sizeof(CPUEntry));
136
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500137
138 sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
139}
140
Cornelia Huck80b7a262017-07-06 17:13:14 +0200141static 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 /* fallthrough */
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
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200170static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code)
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000171{
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200172 SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
173 SCLPEventFacility *ef = sclp->event_facility;
Heinz Graalfs477a72a2013-12-18 10:10:49 +0100174 SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
Heinz Graalfs559a17a2012-10-29 02:13:23 +0000175
Jason J. Herne5f04c142014-01-20 14:51:48 -0500176 switch (code & SCLP_CMD_CODE_MASK) {
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000177 case SCLP_CMDW_READ_SCP_INFO:
178 case SCLP_CMDW_READ_SCP_INFO_FORCED:
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200179 sclp_c->read_SCP_info(sclp, sccb);
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000180 break;
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500181 case SCLP_CMDW_READ_CPU_INFO:
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200182 sclp_c->read_cpu_info(sclp, sccb);
Jason J. Herne8cc3aec2014-01-20 14:51:49 -0500183 break;
Cornelia Huck80b7a262017-07-06 17:13:14 +0200184 case SCLP_CMDW_CONFIGURE_IOA:
185 sclp_configure_io_adapter(sclp, sccb, true);
Frank Blaschka8cba80c2015-01-09 09:04:38 +0100186 break;
Cornelia Huck80b7a262017-07-06 17:13:14 +0200187 case SCLP_CMDW_DECONFIGURE_IOA:
188 sclp_configure_io_adapter(sclp, sccb, false);
Frank Blaschka8cba80c2015-01-09 09:04:38 +0100189 break;
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000190 default:
Heinz Graalfs477a72a2013-12-18 10:10:49 +0100191 efc->command_handler(ef, sccb, code);
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000192 break;
193 }
194}
195
Thomas Huth6e252802014-01-13 12:55:55 +0100196int sclp_service_call(CPUS390XState *env, uint64_t sccb, uint32_t code)
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000197{
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200198 SCLPDevice *sclp = get_sclp_device();
199 SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000200 int r = 0;
201 SCCB work_sccb;
202
203 hwaddr sccb_len = sizeof(SCCB);
204
205 /* first some basic checks on program checks */
Thomas Huth6e252802014-01-13 12:55:55 +0100206 if (env->psw.mask & PSW_MASK_PSTATE) {
207 r = -PGM_PRIVILEGED;
208 goto out;
209 }
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000210 if (cpu_physical_memory_is_io(sccb)) {
211 r = -PGM_ADDRESSING;
212 goto out;
213 }
Thomas Huth6e252802014-01-13 12:55:55 +0100214 if ((sccb & ~0x1fffUL) == 0 || (sccb & ~0x1fffUL) == env->psa
215 || (sccb & ~0x7ffffff8UL) != 0) {
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000216 r = -PGM_SPECIFICATION;
217 goto out;
218 }
219
220 /*
221 * we want to work on a private copy of the sccb, to prevent guests
222 * from playing dirty tricks by modifying the memory content after
223 * the host has checked the values
224 */
225 cpu_physical_memory_read(sccb, &work_sccb, sccb_len);
226
227 /* Valid sccb sizes */
Janosch Frankd959f6c2019-09-27 15:33:22 +0200228 if (be16_to_cpu(work_sccb.h.length) < sizeof(SCCBHeader)) {
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000229 r = -PGM_SPECIFICATION;
230 goto out;
231 }
232
Janosch Frank679b8442019-09-27 15:33:20 +0200233 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 }
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000247
Janosch Frank6f6c9332019-09-27 15:33:21 +0200248 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
Janosch Frank679b8442019-09-27 15:33:20 +0200253 sclp_c->execute(sclp, &work_sccb, code);
254out_write:
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000255 cpu_physical_memory_write(sccb, &work_sccb,
256 be16_to_cpu(work_sccb.h.length));
257
David Hildenbrand1723a1b2015-05-13 15:06:44 +0200258 sclp_c->service_interrupt(sclp, sccb);
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000259
260out:
261 return r;
262}
263
David Hildenbrand1723a1b2015-05-13 15:06:44 +0200264static void service_interrupt(SCLPDevice *sclp, uint32_t sccb)
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000265{
David Hildenbrand1723a1b2015-05-13 15:06:44 +0200266 SCLPEventFacility *ef = sclp->event_facility;
Heinz Graalfs477a72a2013-12-18 10:10:49 +0100267 SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
268
Heinz Graalfs559a17a2012-10-29 02:13:23 +0000269 uint32_t param = sccb & ~3;
270
271 /* Indicate whether an event is still pending */
Heinz Graalfs477a72a2013-12-18 10:10:49 +0100272 param |= efc->event_pending(ef) ? 1 : 0;
Heinz Graalfs559a17a2012-10-29 02:13:23 +0000273
274 if (!param) {
275 /* No need to send an interrupt, there's nothing to be notified about */
276 return;
277 }
278 s390_sclp_extint(param);
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000279}
280
David Hildenbrand1723a1b2015-05-13 15:06:44 +0200281void 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
Heinz Graalfsf6c98f922012-10-29 02:13:22 +0000289/* qemu object creation and initialization functions */
290
Heinz Graalfs559a17a2012-10-29 02:13:23 +0000291void s390_sclp_init(void)
292{
David Hildenbrand515190d2015-05-27 09:49:43 +0200293 Object *new = object_new(TYPE_SCLP);
Heinz Graalfs559a17a2012-10-29 02:13:23 +0000294
David Hildenbrand515190d2015-05-27 09:49:43 +0200295 object_property_add_child(qdev_get_machine(), TYPE_SCLP, new,
296 NULL);
297 object_unref(OBJECT(new));
298 qdev_init_nofail(DEVICE(new));
Heinz Graalfs559a17a2012-10-29 02:13:23 +0000299}
Matthew Rosato0844df72014-08-28 11:25:32 -0400300
David Hildenbrand515190d2015-05-27 09:49:43 +0200301static void sclp_realize(DeviceState *dev, Error **errp)
302{
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200303 MachineState *machine = MACHINE(qdev_get_machine());
David Hildenbrand515190d2015-05-27 09:49:43 +0200304 SCLPDevice *sclp = SCLP(dev);
Markus Armbrustere6da7802015-12-18 16:35:25 +0100305 Error *err = NULL;
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200306 uint64_t hw_limit;
307 int ret;
David Hildenbrand515190d2015-05-27 09:49:43 +0200308
309 object_property_set_bool(OBJECT(sclp->event_facility), true, "realized",
Markus Armbrustere6da7802015-12-18 16:35:25 +0100310 &err);
311 if (err) {
Markus Armbruster24da21f2015-12-18 16:35:26 +0100312 goto out;
David Hildenbrand515190d2015-05-27 09:49:43 +0200313 }
David Hildenbrand8b638c42015-11-23 13:03:08 +0100314 /*
315 * qdev_device_add searches the sysbus for TYPE_SCLP_EVENTS_BUS. As long
316 * as we can't find a fitting bus via the qom tree, we have to add the
317 * event facility to the sysbus, so e.g. a sclp console can be created.
318 */
319 qdev_set_parent_bus(DEVICE(sclp->event_facility), sysbus_get_default());
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200320
321 ret = s390_set_memory_limit(machine->maxram_size, &hw_limit);
322 if (ret == -E2BIG) {
Ishani Chughd0e31a12017-04-13 21:44:39 +0530323 error_setg(&err, "host supports a maximum of %" PRIu64 " GB",
Philippe Mathieu-Daudé393fc4c2018-06-25 09:42:11 -0300324 hw_limit / GiB);
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200325 } else if (ret) {
Ishani Chughd0e31a12017-04-13 21:44:39 +0530326 error_setg(&err, "setting the guest size failed");
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200327 }
Markus Armbruster24da21f2015-12-18 16:35:26 +0100328
329out:
Markus Armbrustere6da7802015-12-18 16:35:25 +0100330 error_propagate(errp, err);
David Hildenbrand515190d2015-05-27 09:49:43 +0200331}
332
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200333static void sclp_memory_init(SCLPDevice *sclp)
334{
335 MachineState *machine = MACHINE(qdev_get_machine());
336 ram_addr_t initial_mem = machine->ram_size;
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200337 int increment_size = 20;
338
339 /* The storage increment size is a multiple of 1M and is a power of 2.
340 * The number of storage increments must be MAX_STORAGE_INCREMENTS or fewer.
341 * The variable 'increment_size' is an exponent of 2 that can be
342 * used to calculate the size (in bytes) of an increment. */
343 while ((initial_mem >> increment_size) > MAX_STORAGE_INCREMENTS) {
344 increment_size++;
345 }
David Hildenbrand71a2fd32015-06-01 13:03:23 +0200346 sclp->increment_size = increment_size;
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200347
David Hildenbrand82fab5c2018-02-19 18:42:31 +0100348 /* The core memory area needs to be aligned with the increment size.
349 * In effect, this can cause the user-specified memory size to be rounded
350 * down to align with the nearest increment boundary. */
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200351 initial_mem = initial_mem >> increment_size << increment_size;
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200352
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200353 machine->ram_size = initial_mem;
Christian Borntraeger408e5ac2018-07-30 16:09:26 +0200354 machine->maxram_size = initial_mem;
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200355 /* let's propagate the changed ram size into the global variable. */
356 ram_size = initial_mem;
357}
358
David Hildenbrand515190d2015-05-27 09:49:43 +0200359static 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);
David Hildenbrand515190d2015-05-27 09:49:43 +0200366 object_unref(new);
367 sclp->event_facility = EVENT_FACILITY(new);
David Hildenbrand1cf065f2015-05-29 13:53:08 +0200368
369 sclp_memory_init(sclp);
David Hildenbrand515190d2015-05-27 09:49:43 +0200370}
371
372static void sclp_class_init(ObjectClass *oc, void *data)
373{
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200374 SCLPDeviceClass *sc = SCLP_CLASS(oc);
David Hildenbrand515190d2015-05-27 09:49:43 +0200375 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);
Thomas Huthe6cb60b2017-10-04 15:53:19 +0200381 /*
382 * Reason: Creates TYPE_SCLP_EVENT_FACILITY in sclp_init
383 * which is a non-pluggable sysbus device
384 */
385 dc->user_creatable = false;
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200386
387 sc->read_SCP_info = read_SCP_info;
David Hildenbrand25a3c5a2015-05-27 10:04:56 +0200388 sc->read_cpu_info = sclp_read_cpu_info;
389 sc->execute = sclp_execute;
David Hildenbrand1723a1b2015-05-13 15:06:44 +0200390 sc->service_interrupt = service_interrupt;
David Hildenbrand515190d2015-05-27 09:49:43 +0200391}
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
Matthew Rosato0844df72014-08-28 11:25:32 -0400402static void register_types(void)
403{
David Hildenbrand515190d2015-05-27 09:49:43 +0200404 type_register_static(&sclp_info);
Matthew Rosato0844df72014-08-28 11:25:32 -0400405}
406type_init(register_types);