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 int event_type(void) 26 { 27 return 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 typedef struct QuiesceNotifier QuiesceNotifier; 69 70 static struct QuiesceNotifier { 71 Notifier notifier; 72 SCLPEvent *event; 73 } qn; 74 75 static void quiesce_powerdown_req(Notifier *n, void *opaque) 76 { 77 QuiesceNotifier *qn = container_of(n, QuiesceNotifier, notifier); 78 SCLPEvent *event = qn->event; 79 80 event->event_pending = true; 81 /* trigger SCLP read operation */ 82 sclp_service_interrupt(0); 83 } 84 85 static int quiesce_init(SCLPEvent *event) 86 { 87 event->event_type = SCLP_EVENT_SIGNAL_QUIESCE; 88 89 qn.notifier.notify = quiesce_powerdown_req; 90 qn.event = event; 91 92 qemu_register_powerdown_notifier(&qn.notifier); 93 94 return 0; 95 } 96 97 static void quiesce_class_init(ObjectClass *klass, void *data) 98 { 99 SCLPEventClass *k = SCLP_EVENT_CLASS(klass); 100 101 k->init = quiesce_init; 102 103 k->get_send_mask = send_mask; 104 k->get_receive_mask = receive_mask; 105 k->event_type = event_type; 106 k->read_event_data = read_event_data; 107 k->write_event_data = NULL; 108 } 109 110 static const TypeInfo sclp_quiesce_info = { 111 .name = "sclpquiesce", 112 .parent = TYPE_SCLP_EVENT, 113 .instance_size = sizeof(SCLPEvent), 114 .class_init = quiesce_class_init, 115 .class_size = sizeof(SCLPEventClass), 116 }; 117 118 static void register_types(void) 119 { 120 type_register_static(&sclp_quiesce_info); 121 } 122 123 type_init(register_types) 124