[qemu.git] / hw / s390x / sclpquiesce.c

/*
 * SCLP event type
 *    Signal Quiesce - trigger system powerdown request
 *
 * Copyright IBM, Corp. 2012
 *
 * Authors:
 *  Heinz Graalfs <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
 * option) any later version.  See the COPYING file in the top-level directory.
 *
 */
#include <hw/qdev.h>
#include "sysemu/sysemu.h"
#include "sclp.h"
#include "event-facility.h"

typedef struct SignalQuiesce {
    EventBufferHeader ebh;
    uint16_t timeout;
    uint8_t unit;
} QEMU_PACKED SignalQuiesce;

static int event_type(void)
{
    return SCLP_EVENT_SIGNAL_QUIESCE;
}

static unsigned int send_mask(void)
{
    return SCLP_EVENT_MASK_SIGNAL_QUIESCE;
}

static unsigned int receive_mask(void)
{
    return 0;
}

static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
                           int *slen)
{
    SignalQuiesce *sq = (SignalQuiesce *) evt_buf_hdr;

    if (*slen < sizeof(SignalQuiesce)) {
        return 0;
    }

    if (!event->event_pending) {
        return 0;
    }
    event->event_pending = false;

    sq->ebh.length = cpu_to_be16(sizeof(SignalQuiesce));
    sq->ebh.type = SCLP_EVENT_SIGNAL_QUIESCE;
    sq->ebh.flags |= SCLP_EVENT_BUFFER_ACCEPTED;
    /*
     * system_powerdown does not have a timeout. Fortunately the
     * timeout value is currently ignored by Linux, anyway
     */
    sq->timeout = cpu_to_be16(0);
    sq->unit = cpu_to_be16(0);
    *slen -= sizeof(SignalQuiesce);

    return 1;
}

typedef struct QuiesceNotifier QuiesceNotifier;

static struct QuiesceNotifier {
    Notifier notifier;
    SCLPEvent *event;
} qn;

static void quiesce_powerdown_req(Notifier *n, void *opaque)
{
    QuiesceNotifier *qn = container_of(n, QuiesceNotifier, notifier);
    SCLPEvent *event = qn->event;

    event->event_pending = true;
    /* trigger SCLP read operation */
    sclp_service_interrupt(0);
}

static int quiesce_init(SCLPEvent *event)
{
    event->event_type = SCLP_EVENT_SIGNAL_QUIESCE;

    qn.notifier.notify = quiesce_powerdown_req;
    qn.event = event;

    qemu_register_powerdown_notifier(&qn.notifier);

    return 0;
}

static void quiesce_class_init(ObjectClass *klass, void *data)
{
    SCLPEventClass *k = SCLP_EVENT_CLASS(klass);

    k->init = quiesce_init;

    k->get_send_mask = send_mask;
    k->get_receive_mask = receive_mask;
    k->event_type = event_type;
    k->read_event_data = read_event_data;
    k->write_event_data = NULL;
}

static const TypeInfo sclp_quiesce_info = {
    .name          = "sclpquiesce",
    .parent        = TYPE_SCLP_EVENT,
    .instance_size = sizeof(SCLPEvent),
    .class_init    = quiesce_class_init,
    .class_size    = sizeof(SCLPEventClass),
};

static void register_types(void)
{
    type_register_static(&sclp_quiesce_info);
}

type_init(register_types)
Commit	Line	Data
ab9074b5 HG	1	/*
	2	* SCLP event type
	3	* Signal Quiesce - trigger system powerdown request
	4	*
	5	* Copyright IBM, Corp. 2012
	6	*
	7	* Authors:
	8	* Heinz Graalfs <[email protected]>
	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>
9c17d615	15	#include "sysemu/sysemu.h"
ab9074b5 HG	16	#include "sclp.h"
	17	#include "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
8c43a6f0	110	static const TypeInfo sclp_quiesce_info = {
ab9074b5 HG	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)