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