xref: /qemu/hw/s390x/sclpquiesce.c (revision 67cc32eb) 
1 /*
2  * SCLP event type
3  *    Signal Quiesce - trigger system powerdown request
4  *
5  * Copyright IBM, Corp. 2012
6  *
7  * Authors:
8  *  Heinz Graalfs <graalfs@de.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 #include <hw/qdev.h>
15 #include "sysemu/sysemu.h"
16 #include "hw/s390x/sclp.h"
17 #include "hw/s390x/event-facility.h"
18 
19 typedef struct SignalQuiesce {
20     EventBufferHeader ebh;
21     uint16_t timeout;
22     uint8_t unit;
23 } QEMU_PACKED SignalQuiesce;
24 
25 static bool can_handle_event(uint8_t type)
26 {
27     return type == SCLP_EVENT_SIGNAL_QUIESCE;
28 }
29 
30 static unsigned int send_mask(void)
31 {
32     return SCLP_EVENT_MASK_SIGNAL_QUIESCE;
33 }
34 
35 static unsigned int receive_mask(void)
36 {
37     return 0;
38 }
39 
40 static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
41                            int *slen)
42 {
43     SignalQuiesce *sq = (SignalQuiesce *) evt_buf_hdr;
44 
45     if (*slen < sizeof(SignalQuiesce)) {
46         return 0;
47     }
48 
49     if (!event->event_pending) {
50         return 0;
51     }
52     event->event_pending = false;
53 
54     sq->ebh.length = cpu_to_be16(sizeof(SignalQuiesce));
55     sq->ebh.type = SCLP_EVENT_SIGNAL_QUIESCE;
56     sq->ebh.flags |= SCLP_EVENT_BUFFER_ACCEPTED;
57     /*
58      * system_powerdown does not have a timeout. Fortunately the
59      * timeout value is currently ignored by Linux, anyway
60      */
61     sq->timeout = cpu_to_be16(0);
62     sq->unit = cpu_to_be16(0);
63     *slen -= sizeof(SignalQuiesce);
64 
65     return 1;
66 }
67 
68 static const VMStateDescription vmstate_sclpquiesce = {
69     .name = TYPE_SCLP_QUIESCE,
70     .version_id = 0,
71     .minimum_version_id = 0,
72     .fields = (VMStateField[]) {
73         VMSTATE_BOOL(event_pending, SCLPEvent),
74         VMSTATE_END_OF_LIST()
75      }
76 };
77 
78 typedef struct QuiesceNotifier QuiesceNotifier;
79 
80 static struct QuiesceNotifier {
81     Notifier notifier;
82     SCLPEvent *event;
83 } qn;
84 
85 static void quiesce_powerdown_req(Notifier *n, void *opaque)
86 {
87     QuiesceNotifier *qn = container_of(n, QuiesceNotifier, notifier);
88     SCLPEvent *event = qn->event;
89 
90     event->event_pending = true;
91     /* trigger SCLP read operation */
92     sclp_service_interrupt(0);
93 }
94 
95 static int quiesce_init(SCLPEvent *event)
96 {
97     qn.notifier.notify = quiesce_powerdown_req;
98     qn.event = event;
99 
100     qemu_register_powerdown_notifier(&qn.notifier);
101 
102     return 0;
103 }
104 
105 static void quiesce_reset(DeviceState *dev)
106 {
107    SCLPEvent *event = SCLP_EVENT(dev);
108 
109    event->event_pending = false;
110 }
111 
112 static void quiesce_class_init(ObjectClass *klass, void *data)
113 {
114     DeviceClass *dc = DEVICE_CLASS(klass);
115     SCLPEventClass *k = SCLP_EVENT_CLASS(klass);
116 
117     dc->reset = quiesce_reset;
118     dc->vmsd = &vmstate_sclpquiesce;
119     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
120     k->init = quiesce_init;
121 
122     k->get_send_mask = send_mask;
123     k->get_receive_mask = receive_mask;
124     k->can_handle_event = can_handle_event;
125     k->read_event_data = read_event_data;
126     k->write_event_data = NULL;
127 }
128 
129 static const TypeInfo sclp_quiesce_info = {
130     .name          = TYPE_SCLP_QUIESCE,
131     .parent        = TYPE_SCLP_EVENT,
132     .instance_size = sizeof(SCLPEvent),
133     .class_init    = quiesce_class_init,
134     .class_size    = sizeof(SCLPEventClass),
135 };
136 
137 static void register_types(void)
138 {
139     type_register_static(&sclp_quiesce_info);
140 }
141 
142 type_init(register_types)
143