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 = "sclpquiesce", 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 = "sclpquiesce", 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