4 * handles SCLP event types
5 * - Signal Quiesce - system power down
6 * - ASCII Console Data - VT220 read and write
8 * Copyright IBM, Corp. 2012
11 * Heinz Graalfs <graalfs@de.ibm.com>
13 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
14 * option) any later version. See the COPYING file in the top-level directory.
18 #include "sysemu/sysemu.h"
20 #include "hw/s390x/sclp.h"
21 #include "hw/s390x/event-facility.h"
23 typedef struct SCLPEventsBus
{
27 struct SCLPEventFacility
{
28 SysBusDevice parent_obj
;
30 /* guest' receive mask */
31 unsigned int receive_mask
;
34 static SCLPEvent cpu_hotplug
;
36 /* return true if any child has event pending set */
37 static bool event_pending(SCLPEventFacility
*ef
)
41 SCLPEventClass
*event_class
;
43 QTAILQ_FOREACH(kid
, &ef
->sbus
.qbus
.children
, sibling
) {
44 DeviceState
*qdev
= kid
->child
;
45 event
= DO_UPCAST(SCLPEvent
, qdev
, qdev
);
46 event_class
= SCLP_EVENT_GET_CLASS(event
);
47 if (event
->event_pending
&&
48 event_class
->get_send_mask() & ef
->receive_mask
) {
55 static unsigned int get_host_send_mask(SCLPEventFacility
*ef
)
59 SCLPEventClass
*child
;
63 QTAILQ_FOREACH(kid
, &ef
->sbus
.qbus
.children
, sibling
) {
64 DeviceState
*qdev
= kid
->child
;
65 child
= SCLP_EVENT_GET_CLASS((SCLPEvent
*) qdev
);
66 mask
|= child
->get_send_mask();
71 static unsigned int get_host_receive_mask(SCLPEventFacility
*ef
)
75 SCLPEventClass
*child
;
79 QTAILQ_FOREACH(kid
, &ef
->sbus
.qbus
.children
, sibling
) {
80 DeviceState
*qdev
= kid
->child
;
81 child
= SCLP_EVENT_GET_CLASS((SCLPEvent
*) qdev
);
82 mask
|= child
->get_receive_mask();
87 static uint16_t write_event_length_check(SCCB
*sccb
)
91 EventBufferHeader
*event
;
92 WriteEventData
*wed
= (WriteEventData
*) sccb
;
94 event
= (EventBufferHeader
*) &wed
->ebh
;
95 for (slen
= sccb_data_len(sccb
); slen
> 0; slen
-= elen
) {
96 elen
= be16_to_cpu(event
->length
);
97 if (elen
< sizeof(*event
) || elen
> slen
) {
98 return SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR
;
100 event
= (void *) event
+ elen
;
103 return SCLP_RC_INCONSISTENT_LENGTHS
;
105 return SCLP_RC_NORMAL_COMPLETION
;
108 static uint16_t handle_write_event_buf(SCLPEventFacility
*ef
,
109 EventBufferHeader
*event_buf
, SCCB
*sccb
)
116 rc
= SCLP_RC_INVALID_FUNCTION
;
118 QTAILQ_FOREACH(kid
, &ef
->sbus
.qbus
.children
, sibling
) {
119 DeviceState
*qdev
= kid
->child
;
120 event
= (SCLPEvent
*) qdev
;
121 ec
= SCLP_EVENT_GET_CLASS(event
);
123 if (ec
->write_event_data
&&
124 ec
->can_handle_event(event_buf
->type
)) {
125 rc
= ec
->write_event_data(event
, event_buf
);
132 static uint16_t handle_sccb_write_events(SCLPEventFacility
*ef
, SCCB
*sccb
)
137 EventBufferHeader
*event_buf
;
138 WriteEventData
*wed
= (WriteEventData
*) sccb
;
140 event_buf
= &wed
->ebh
;
141 rc
= SCLP_RC_NORMAL_COMPLETION
;
143 /* loop over all contained event buffers */
144 for (slen
= sccb_data_len(sccb
); slen
> 0; slen
-= elen
) {
145 elen
= be16_to_cpu(event_buf
->length
);
147 /* in case of a previous error mark all trailing buffers
149 if (rc
!= SCLP_RC_NORMAL_COMPLETION
) {
150 event_buf
->flags
&= ~(SCLP_EVENT_BUFFER_ACCEPTED
);
152 rc
= handle_write_event_buf(ef
, event_buf
, sccb
);
154 event_buf
= (void *) event_buf
+ elen
;
159 static void write_event_data(SCLPEventFacility
*ef
, SCCB
*sccb
)
161 if (sccb
->h
.function_code
!= SCLP_FC_NORMAL_WRITE
) {
162 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_FUNCTION
);
165 if (be16_to_cpu(sccb
->h
.length
) < 8) {
166 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH
);
169 /* first do a sanity check of the write events */
170 sccb
->h
.response_code
= cpu_to_be16(write_event_length_check(sccb
));
172 /* if no early error, then execute */
173 if (sccb
->h
.response_code
== be16_to_cpu(SCLP_RC_NORMAL_COMPLETION
)) {
174 sccb
->h
.response_code
=
175 cpu_to_be16(handle_sccb_write_events(ef
, sccb
));
182 static uint16_t handle_sccb_read_events(SCLPEventFacility
*ef
, SCCB
*sccb
,
191 EventBufferHeader
*event_buf
;
192 ReadEventData
*red
= (ReadEventData
*) sccb
;
194 event_buf
= &red
->ebh
;
195 event_buf
->length
= 0;
196 slen
= sizeof(sccb
->data
);
198 rc
= SCLP_RC_NO_EVENT_BUFFERS_STORED
;
200 QTAILQ_FOREACH(kid
, &ef
->sbus
.qbus
.children
, sibling
) {
201 DeviceState
*qdev
= kid
->child
;
202 event
= (SCLPEvent
*) qdev
;
203 ec
= SCLP_EVENT_GET_CLASS(event
);
205 if (mask
& ec
->get_send_mask()) {
206 if (ec
->read_event_data(event
, event_buf
, &slen
)) {
207 elen
= be16_to_cpu(event_buf
->length
);
208 event_buf
= (EventBufferHeader
*) ((char *)event_buf
+ elen
);
209 rc
= SCLP_RC_NORMAL_COMPLETION
;
214 if (sccb
->h
.control_mask
[2] & SCLP_VARIABLE_LENGTH_RESPONSE
) {
215 /* architecture suggests to reset variable-length-response bit */
216 sccb
->h
.control_mask
[2] &= ~SCLP_VARIABLE_LENGTH_RESPONSE
;
217 /* with a new length value */
218 sccb
->h
.length
= cpu_to_be16(SCCB_SIZE
- slen
);
223 static void read_event_data(SCLPEventFacility
*ef
, SCCB
*sccb
)
225 unsigned int sclp_active_selection_mask
;
226 unsigned int sclp_cp_receive_mask
;
228 ReadEventData
*red
= (ReadEventData
*) sccb
;
230 if (be16_to_cpu(sccb
->h
.length
) != SCCB_SIZE
) {
231 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INSUFFICIENT_SCCB_LENGTH
);
235 sclp_cp_receive_mask
= ef
->receive_mask
;
237 /* get active selection mask */
238 switch (sccb
->h
.function_code
) {
239 case SCLP_UNCONDITIONAL_READ
:
240 sclp_active_selection_mask
= sclp_cp_receive_mask
;
242 case SCLP_SELECTIVE_READ
:
243 if (!(sclp_cp_receive_mask
& be32_to_cpu(red
->mask
))) {
244 sccb
->h
.response_code
=
245 cpu_to_be16(SCLP_RC_INVALID_SELECTION_MASK
);
248 sclp_active_selection_mask
= be32_to_cpu(red
->mask
);
251 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_FUNCTION
);
254 sccb
->h
.response_code
= cpu_to_be16(
255 handle_sccb_read_events(ef
, sccb
, sclp_active_selection_mask
));
261 static void write_event_mask(SCLPEventFacility
*ef
, SCCB
*sccb
)
263 WriteEventMask
*we_mask
= (WriteEventMask
*) sccb
;
265 /* Attention: We assume that Linux uses 4-byte masks, what it actually
266 does. Architecture allows for masks of variable size, though */
267 if (be16_to_cpu(we_mask
->mask_length
) != 4) {
268 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_MASK_LENGTH
);
272 /* keep track of the guest's capability masks */
273 ef
->receive_mask
= be32_to_cpu(we_mask
->cp_receive_mask
);
275 /* return the SCLP's capability masks to the guest */
276 we_mask
->send_mask
= cpu_to_be32(get_host_send_mask(ef
));
277 we_mask
->receive_mask
= cpu_to_be32(get_host_receive_mask(ef
));
279 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_NORMAL_COMPLETION
);
285 /* qemu object creation and initialization functions */
287 #define TYPE_SCLP_EVENTS_BUS "s390-sclp-events-bus"
289 static void sclp_events_bus_class_init(ObjectClass
*klass
, void *data
)
293 static const TypeInfo sclp_events_bus_info
= {
294 .name
= TYPE_SCLP_EVENTS_BUS
,
296 .class_init
= sclp_events_bus_class_init
,
299 static void command_handler(SCLPEventFacility
*ef
, SCCB
*sccb
, uint64_t code
)
301 switch (code
& SCLP_CMD_CODE_MASK
) {
302 case SCLP_CMD_READ_EVENT_DATA
:
303 read_event_data(ef
, sccb
);
305 case SCLP_CMD_WRITE_EVENT_DATA
:
306 write_event_data(ef
, sccb
);
308 case SCLP_CMD_WRITE_EVENT_MASK
:
309 write_event_mask(ef
, sccb
);
312 sccb
->h
.response_code
= cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND
);
317 static const VMStateDescription vmstate_event_facility
= {
318 .name
= "vmstate-event-facility",
320 .minimum_version_id
= 0,
321 .fields
= (VMStateField
[]) {
322 VMSTATE_UINT32(receive_mask
, SCLPEventFacility
),
323 VMSTATE_END_OF_LIST()
327 static int init_event_facility(SCLPEventFacility
*event_facility
)
329 DeviceState
*sdev
= DEVICE(event_facility
);
330 DeviceState
*quiesce
;
332 /* Spawn a new bus for SCLP events */
333 qbus_create_inplace(&event_facility
->sbus
, sizeof(event_facility
->sbus
),
334 TYPE_SCLP_EVENTS_BUS
, sdev
, NULL
);
336 quiesce
= qdev_create(&event_facility
->sbus
.qbus
, "sclpquiesce");
340 qdev_init_nofail(quiesce
);
342 object_initialize(&cpu_hotplug
, sizeof(cpu_hotplug
), TYPE_SCLP_CPU_HOTPLUG
);
343 qdev_set_parent_bus(DEVICE(&cpu_hotplug
), BUS(&event_facility
->sbus
));
344 object_property_set_bool(OBJECT(&cpu_hotplug
), true, "realized", NULL
);
349 static void reset_event_facility(DeviceState
*dev
)
351 SCLPEventFacility
*sdev
= EVENT_FACILITY(dev
);
353 sdev
->receive_mask
= 0;
356 static void init_event_facility_class(ObjectClass
*klass
, void *data
)
358 SysBusDeviceClass
*sbdc
= SYS_BUS_DEVICE_CLASS(klass
);
359 DeviceClass
*dc
= DEVICE_CLASS(sbdc
);
360 SCLPEventFacilityClass
*k
= EVENT_FACILITY_CLASS(dc
);
362 dc
->reset
= reset_event_facility
;
363 dc
->vmsd
= &vmstate_event_facility
;
364 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
365 k
->init
= init_event_facility
;
366 k
->command_handler
= command_handler
;
367 k
->event_pending
= event_pending
;
370 static const TypeInfo sclp_event_facility_info
= {
371 .name
= TYPE_SCLP_EVENT_FACILITY
,
372 .parent
= TYPE_SYS_BUS_DEVICE
,
373 .instance_size
= sizeof(SCLPEventFacility
),
374 .class_init
= init_event_facility_class
,
375 .class_size
= sizeof(SCLPEventFacilityClass
),
378 static void event_realize(DeviceState
*qdev
, Error
**errp
)
380 SCLPEvent
*event
= SCLP_EVENT(qdev
);
381 SCLPEventClass
*child
= SCLP_EVENT_GET_CLASS(event
);
384 int rc
= child
->init(event
);
386 error_setg(errp
, "SCLP event initialization failed.");
392 static void event_unrealize(DeviceState
*qdev
, Error
**errp
)
394 SCLPEvent
*event
= SCLP_EVENT(qdev
);
395 SCLPEventClass
*child
= SCLP_EVENT_GET_CLASS(event
);
397 int rc
= child
->exit(event
);
399 error_setg(errp
, "SCLP event exit failed.");
405 static void event_class_init(ObjectClass
*klass
, void *data
)
407 DeviceClass
*dc
= DEVICE_CLASS(klass
);
409 dc
->bus_type
= TYPE_SCLP_EVENTS_BUS
;
410 dc
->realize
= event_realize
;
411 dc
->unrealize
= event_unrealize
;
414 static const TypeInfo sclp_event_type_info
= {
415 .name
= TYPE_SCLP_EVENT
,
416 .parent
= TYPE_DEVICE
,
417 .instance_size
= sizeof(SCLPEvent
),
418 .class_init
= event_class_init
,
419 .class_size
= sizeof(SCLPEventClass
),
423 static void register_types(void)
425 type_register_static(&sclp_events_bus_info
);
426 type_register_static(&sclp_event_facility_info
);
427 type_register_static(&sclp_event_type_info
);
430 type_init(register_types
)