[deliverable/linux.git] / arch / sparc64 / kernel / ds.c

/* ds.c: Domain Services driver for Logical Domains
 *
 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/delay.h>

#include <asm/ldc.h>
#include <asm/vio.h>
#include <asm/power.h>

#define DRV_MODULE_NAME		"ds"
#define PFX DRV_MODULE_NAME	": "
#define DRV_MODULE_VERSION	"1.0"
#define DRV_MODULE_RELDATE	"Jul 11, 2007"

static char version[] __devinitdata =
	DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
MODULE_DESCRIPTION("Sun LDOM domain services driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_MODULE_VERSION);

struct ds_msg_tag {
	__u32			type;
#define DS_INIT_REQ		0x00
#define DS_INIT_ACK		0x01
#define DS_INIT_NACK		0x02
#define DS_REG_REQ		0x03
#define DS_REG_ACK		0x04
#define DS_REG_NACK		0x05
#define DS_UNREG_REQ		0x06
#define DS_UNREG_ACK		0x07
#define DS_UNREG_NACK		0x08
#define DS_DATA			0x09
#define DS_NACK			0x0a

	__u32			len;
};

/* Result codes */
#define DS_OK			0x00
#define DS_REG_VER_NACK		0x01
#define DS_REG_DUP		0x02
#define DS_INV_HDL		0x03
#define DS_TYPE_UNKNOWN		0x04

struct ds_version {
	__u16			major;
	__u16			minor;
};

struct ds_ver_req {
	struct ds_msg_tag	tag;
	struct ds_version	ver;
};

struct ds_ver_ack {
	struct ds_msg_tag	tag;
	__u16			minor;
};

struct ds_ver_nack {
	struct ds_msg_tag	tag;
	__u16			major;
};

struct ds_reg_req {
	struct ds_msg_tag	tag;
	__u64			handle;
	__u16			major;
	__u16			minor;
	char			svc_id[0];
};

struct ds_reg_ack {
	struct ds_msg_tag	tag;
	__u64			handle;
	__u16			minor;
};

struct ds_reg_nack {
	struct ds_msg_tag	tag;
	__u64			handle;
	__u16			major;
};

struct ds_unreg_req {
	struct ds_msg_tag	tag;
	__u64			handle;
};

struct ds_unreg_ack {
	struct ds_msg_tag	tag;
	__u64			handle;
};

struct ds_unreg_nack {
	struct ds_msg_tag	tag;
	__u64			handle;
};

struct ds_data {
	struct ds_msg_tag	tag;
	__u64			handle;
};

struct ds_data_nack {
	struct ds_msg_tag	tag;
	__u64			handle;
	__u64			result;
};

struct ds_cap_state {
	__u64			handle;

	void			(*data)(struct ldc_channel *lp,
					struct ds_cap_state *dp,
					void *buf, int len);

	const char		*service_id;

	u8			state;
#define CAP_STATE_UNKNOWN	0x00
#define CAP_STATE_REG_SENT	0x01
#define CAP_STATE_REGISTERED	0x02
};

static int ds_send(struct ldc_channel *lp, void *data, int len)
{
	int err, limit = 1000;

	err = -EINVAL;
	while (limit-- > 0) {
		err = ldc_write(lp, data, len);
		if (!err || (err != -EAGAIN))
			break;
		udelay(1);
	}

	return err;
}

struct ds_md_update_req {
	__u64				req_num;
};

struct ds_md_update_res {
	__u64				req_num;
	__u32				result;
};

static void md_update_data(struct ldc_channel *lp,
			   struct ds_cap_state *dp,
			   void *buf, int len)
{
	struct ds_data *dpkt = buf;
	struct ds_md_update_req *rp;
	struct {
		struct ds_data		data;
		struct ds_md_update_res	res;
	} pkt;

	rp = (struct ds_md_update_req *) (dpkt + 1);

	printk(KERN_ERR PFX "MD update REQ [%lx] len=%d\n",
	       rp->req_num, len);

	memset(&pkt, 0, sizeof(pkt));
	pkt.data.tag.type = DS_DATA;
	pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
	pkt.data.handle = dp->handle;
	pkt.res.req_num = rp->req_num;
	pkt.res.result = DS_OK;

	ds_send(lp, &pkt, sizeof(pkt));
}

struct ds_shutdown_req {
	__u64				req_num;
	__u32				ms_delay;
};

struct ds_shutdown_res {
	__u64				req_num;
	__u32				result;
	char				reason[1];
};

static void domain_shutdown_data(struct ldc_channel *lp,
				 struct ds_cap_state *dp,
				 void *buf, int len)
{
	struct ds_data *dpkt = buf;
	struct ds_shutdown_req *rp;
	struct {
		struct ds_data		data;
		struct ds_shutdown_res	res;
	} pkt;

	rp = (struct ds_shutdown_req *) (dpkt + 1);

	printk(KERN_ALERT PFX "Shutdown request from "
	       "LDOM manager received.\n");

	memset(&pkt, 0, sizeof(pkt));
	pkt.data.tag.type = DS_DATA;
	pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
	pkt.data.handle = dp->handle;
	pkt.res.req_num = rp->req_num;
	pkt.res.result = DS_OK;
	pkt.res.reason[0] = 0;

	ds_send(lp, &pkt, sizeof(pkt));

	wake_up_powerd();
}

struct ds_panic_req {
	__u64				req_num;
};

struct ds_panic_res {
	__u64				req_num;
	__u32				result;
	char				reason[1];
};

static void domain_panic_data(struct ldc_channel *lp,
			      struct ds_cap_state *dp,
			      void *buf, int len)
{
	struct ds_data *dpkt = buf;
	struct ds_panic_req *rp;
	struct {
		struct ds_data		data;
		struct ds_panic_res	res;
	} pkt;

	rp = (struct ds_panic_req *) (dpkt + 1);

	printk(KERN_ERR PFX "Panic REQ [%lx], len=%d\n",
	       rp->req_num, len);

	memset(&pkt, 0, sizeof(pkt));
	pkt.data.tag.type = DS_DATA;
	pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
	pkt.data.handle = dp->handle;
	pkt.res.req_num = rp->req_num;
	pkt.res.result = DS_OK;
	pkt.res.reason[0] = 0;

	ds_send(lp, &pkt, sizeof(pkt));

	panic("PANIC requested by LDOM manager.");
}

struct ds_cpu_tag {
	__u64				req_num;
	__u32				type;
#define DS_CPU_CONFIGURE		0x43
#define DS_CPU_UNCONFIGURE		0x55
#define DS_CPU_FORCE_UNCONFIGURE	0x46
#define DS_CPU_STATUS			0x53

/* Responses */
#define DS_CPU_OK			0x6f
#define DS_CPU_ERROR			0x65

	__u32				num_records;
};

struct ds_cpu_record {
	__u32				cpu_id;
};

static void dr_cpu_data(struct ldc_channel *lp,
			struct ds_cap_state *dp,
			void *buf, int len)
{
	struct ds_data *dpkt = buf;
	struct ds_cpu_tag *rp;

	rp = (struct ds_cpu_tag *) (dpkt + 1);

	printk(KERN_ERR PFX "CPU REQ [%lx:%x], len=%d\n",
	       rp->req_num, rp->type, len);
}

struct ds_pri_msg {
	__u64				req_num;
	__u64				type;
#define DS_PRI_REQUEST			0x00
#define DS_PRI_DATA			0x01
#define DS_PRI_UPDATE			0x02
};

static void ds_pri_data(struct ldc_channel *lp,
			struct ds_cap_state *dp,
			void *buf, int len)
{
	struct ds_data *dpkt = buf;
	struct ds_pri_msg *rp;

	rp = (struct ds_pri_msg *) (dpkt + 1);

	printk(KERN_ERR PFX "PRI REQ [%lx:%lx], len=%d\n",
	       rp->req_num, rp->type, len);
}

struct ds_cap_state ds_states[] = {
	{
		.service_id	= "md-update",
		.data		= md_update_data,
	},
	{
		.service_id	= "domain-shutdown",
		.data		= domain_shutdown_data,
	},
	{
		.service_id	= "domain-panic",
		.data		= domain_panic_data,
	},
	{
		.service_id	= "dr-cpu",
		.data		= dr_cpu_data,
	},
	{
		.service_id	= "pri",
		.data		= ds_pri_data,
	},
};

static struct ds_cap_state *find_cap(u64 handle)
{
	unsigned int index = handle >> 32;

	if (index >= ARRAY_SIZE(ds_states))
		return NULL;
	return &ds_states[index];
}

static DEFINE_SPINLOCK(ds_lock);

struct ds_info {
	struct ldc_channel	*lp;
	u8			hs_state;
#define DS_HS_START		0x01
#define DS_HS_DONE		0x02

	void			*rcv_buf;
	int			rcv_buf_len;
};

static void ds_conn_reset(struct ds_info *dp)
{
	printk(KERN_ERR PFX "ds_conn_reset() from %p\n",
	       __builtin_return_address(0));
}

static int register_services(struct ds_info *dp)
{
	struct ldc_channel *lp = dp->lp;
	int i;

	for (i = 0; i < ARRAY_SIZE(ds_states); i++) {
		struct {
			struct ds_reg_req req;
			u8 id_buf[256];
		} pbuf;
		struct ds_cap_state *cp = &ds_states[i];
		int err, msg_len;
		u64 new_count;

		if (cp->state == CAP_STATE_REGISTERED)
			continue;

		new_count = sched_clock() & 0xffffffff;
		cp->handle = ((u64) i << 32) | new_count;

		msg_len = (sizeof(struct ds_reg_req) +
			   strlen(cp->service_id));

		memset(&pbuf, 0, sizeof(pbuf));
		pbuf.req.tag.type = DS_REG_REQ;
		pbuf.req.tag.len = (msg_len - sizeof(struct ds_msg_tag));
		pbuf.req.handle = cp->handle;
		pbuf.req.major = 1;
		pbuf.req.minor = 0;
		strcpy(pbuf.req.svc_id, cp->service_id);

		err = ds_send(lp, &pbuf, msg_len);
		if (err > 0)
			cp->state = CAP_STATE_REG_SENT;
	}
	return 0;
}

static int ds_handshake(struct ds_info *dp, struct ds_msg_tag *pkt)
{

	if (dp->hs_state == DS_HS_START) {
		if (pkt->type != DS_INIT_ACK)
			goto conn_reset;

		dp->hs_state = DS_HS_DONE;

		return register_services(dp);
	}

	if (dp->hs_state != DS_HS_DONE)
		goto conn_reset;

	if (pkt->type == DS_REG_ACK) {
		struct ds_reg_ack *ap = (struct ds_reg_ack *) pkt;
		struct ds_cap_state *cp = find_cap(ap->handle);

		if (!cp) {
			printk(KERN_ERR PFX "REG ACK for unknown handle %lx\n",
			       ap->handle);
			return 0;
		}
		printk(KERN_INFO PFX "Registered %s service.\n",
		       cp->service_id);
		cp->state = CAP_STATE_REGISTERED;
	} else if (pkt->type == DS_REG_NACK) {
		struct ds_reg_nack *np = (struct ds_reg_nack *) pkt;
		struct ds_cap_state *cp = find_cap(np->handle);

		if (!cp) {
			printk(KERN_ERR PFX "REG NACK for "
			       "unknown handle %lx\n",
			       np->handle);
			return 0;
		}
		printk(KERN_ERR PFX "Could not register %s service\n",
		       cp->service_id);
		cp->state = CAP_STATE_UNKNOWN;
	}

	return 0;

conn_reset:
	ds_conn_reset(dp);
	return -ECONNRESET;
}

static int ds_data(struct ds_info *dp, struct ds_msg_tag *pkt, int len)
{
	struct ds_data *dpkt = (struct ds_data *) pkt;
	struct ds_cap_state *cp = find_cap(dpkt->handle);

	if (!cp) {
		struct ds_data_nack nack = {
			.tag = {
				.type = DS_NACK,
				.len = (sizeof(struct ds_data_nack) -
					sizeof(struct ds_msg_tag)),
			},
			.handle = dpkt->handle,
			.result = DS_INV_HDL,
		};

		printk(KERN_ERR PFX "Data for unknown handle %lu\n",
		       dpkt->handle);
		ds_send(dp->lp, &nack, sizeof(nack));
	} else {
		cp->data(dp->lp, cp, dpkt, len);
	}
	return 0;
}

static void ds_up(struct ds_info *dp)
{
	struct ldc_channel *lp = dp->lp;
	struct ds_ver_req req;
	int err;

	req.tag.type = DS_INIT_REQ;
	req.tag.len = sizeof(req) - sizeof(struct ds_msg_tag);
	req.ver.major = 1;
	req.ver.minor = 0;

	err = ds_send(lp, &req, sizeof(req));
	if (err > 0)
		dp->hs_state = DS_HS_START;
}

static void ds_event(void *arg, int event)
{
	struct ds_info *dp = arg;
	struct ldc_channel *lp = dp->lp;
	unsigned long flags;
	int err;

	spin_lock_irqsave(&ds_lock, flags);

	if (event == LDC_EVENT_UP) {
		ds_up(dp);
		spin_unlock_irqrestore(&ds_lock, flags);
		return;
	}

	if (event != LDC_EVENT_DATA_READY) {
		printk(KERN_WARNING PFX "Unexpected LDC event %d\n", event);
		spin_unlock_irqrestore(&ds_lock, flags);
		return;
	}

	err = 0;
	while (1) {
		struct ds_msg_tag *tag;

		err = ldc_read(lp, dp->rcv_buf, sizeof(*tag));

		if (unlikely(err < 0)) {
			if (err == -ECONNRESET)
				ds_conn_reset(dp);
			break;
		}
		if (err == 0)
			break;

		tag = dp->rcv_buf;
		err = ldc_read(lp, tag + 1, tag->len);

		if (unlikely(err < 0)) {
			if (err == -ECONNRESET)
				ds_conn_reset(dp);
			break;
		}
		if (err < tag->len)
			break;

		if (tag->type < DS_DATA)
			err = ds_handshake(dp, dp->rcv_buf);
		else
			err = ds_data(dp, dp->rcv_buf,
				      sizeof(*tag) + err);
		if (err == -ECONNRESET)
			break;
	}

	spin_unlock_irqrestore(&ds_lock, flags);
}

static int __devinit ds_probe(struct vio_dev *vdev,
			      const struct vio_device_id *id)
{
	static int ds_version_printed;
	struct mdesc_node *endp;
	struct ldc_channel_config ds_cfg = {
		.event		= ds_event,
		.mtu		= 4096,
		.mode		= LDC_MODE_STREAM,
	};
	struct ldc_channel *lp;
	struct ds_info *dp;
	const u64 *chan_id;
	int err;

	if (ds_version_printed++ == 0)
		printk(KERN_INFO "%s", version);

	endp = vio_find_endpoint(vdev);
	if (!endp)
		return -ENODEV;

	chan_id = md_get_property(endp, "id", NULL);
	if (!chan_id)
		return -ENODEV;

	dp = kzalloc(sizeof(*dp), GFP_KERNEL);
	err = -ENOMEM;
	if (!dp)
		goto out_err;

	dp->rcv_buf = kzalloc(4096, GFP_KERNEL);
	if (!dp->rcv_buf)
		goto out_free_dp;

	dp->rcv_buf_len = 4096;

	ds_cfg.tx_irq = endp->irqs[0];
	ds_cfg.rx_irq = endp->irqs[1];

	lp = ldc_alloc(*chan_id, &ds_cfg, dp);
	if (IS_ERR(lp)) {
		err = PTR_ERR(lp);
		goto out_free_rcv_buf;
	}
	dp->lp = lp;

	err = ldc_bind(lp);
	if (err)
		goto out_free_ldc;

	start_powerd();

	return err;

out_free_ldc:
	ldc_free(dp->lp);

out_free_rcv_buf:
	kfree(dp->rcv_buf);

out_free_dp:
	kfree(dp);

out_err:
	return err;
}

static int ds_remove(struct vio_dev *vdev)
{
	return 0;
}

static struct vio_device_id ds_match[] = {
	{
		.type = "domain-services-port",
	},
	{},
};

static struct vio_driver ds_driver = {
	.id_table	= ds_match,
	.probe		= ds_probe,
	.remove		= ds_remove,
	.driver		= {
		.name	= "ds",
		.owner	= THIS_MODULE,
	}
};

static int __init ds_init(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(ds_states); i++)
		ds_states[i].handle = ((u64)i << 32);

	return vio_register_driver(&ds_driver);
}

subsys_initcall(ds_init);
Commit	Line	Data
e450992d DM	1	/* ds.c: Domain Services driver for Logical Domains
	2	*
	3	* Copyright (C) 2007 David S. Miller <davem@davemloft.net>
	4	*/
	5
	6	#include <linux/kernel.h>
	7	#include <linux/module.h>
	8	#include <linux/types.h>
	9	#include <linux/module.h>
	10	#include <linux/string.h>
	11	#include <linux/slab.h>
	12	#include <linux/sched.h>
	13	#include <linux/delay.h>
	14
	15	#include <asm/ldc.h>
	16	#include <asm/vio.h>
	17	#include <asm/power.h>
	18
	19	#define DRV_MODULE_NAME "ds"
	20	#define PFX DRV_MODULE_NAME ": "
	21	#define DRV_MODULE_VERSION "1.0"
	22	#define DRV_MODULE_RELDATE "Jul 11, 2007"
	23
	24	static char version[] __devinitdata =
	25	DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
	26	MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
	27	MODULE_DESCRIPTION("Sun LDOM domain services driver");
	28	MODULE_LICENSE("GPL");
	29	MODULE_VERSION(DRV_MODULE_VERSION);
	30
	31	struct ds_msg_tag {
	32	__u32 type;
	33	#define DS_INIT_REQ 0x00
	34	#define DS_INIT_ACK 0x01
	35	#define DS_INIT_NACK 0x02
	36	#define DS_REG_REQ 0x03
	37	#define DS_REG_ACK 0x04
	38	#define DS_REG_NACK 0x05
	39	#define DS_UNREG_REQ 0x06
	40	#define DS_UNREG_ACK 0x07
	41	#define DS_UNREG_NACK 0x08
	42	#define DS_DATA 0x09
	43	#define DS_NACK 0x0a
	44
	45	__u32 len;
	46	};
	47
	48	/* Result codes */
	49	#define DS_OK 0x00
	50	#define DS_REG_VER_NACK 0x01
	51	#define DS_REG_DUP 0x02
	52	#define DS_INV_HDL 0x03
	53	#define DS_TYPE_UNKNOWN 0x04
	54
	55	struct ds_version {
	56	__u16 major;
	57	__u16 minor;
	58	};
	59
	60	struct ds_ver_req {
	61	struct ds_msg_tag tag;
	62	struct ds_version ver;
	63	};
	64
65	struct ds_ver_ack {
66	struct ds_msg_tag tag;
67	__u16 minor;
68	};
69
70	struct ds_ver_nack {
71	struct ds_msg_tag tag;
72	__u16 major;
73	};
74
75	struct ds_reg_req {
76	struct ds_msg_tag tag;
77	__u64 handle;
78	__u16 major;
79	__u16 minor;
80	char svc_id[0];
81	};
82
83	struct ds_reg_ack {
84	struct ds_msg_tag tag;
85	__u64 handle;
86	__u16 minor;
87	};
88
89	struct ds_reg_nack {
90	struct ds_msg_tag tag;
91	__u64 handle;
92	__u16 major;
93	};
94
95	struct ds_unreg_req {
96	struct ds_msg_tag tag;
97	__u64 handle;
98	};
99
100	struct ds_unreg_ack {
101	struct ds_msg_tag tag;
102	__u64 handle;
103	};
104
105	struct ds_unreg_nack {
106	struct ds_msg_tag tag;
107	__u64 handle;
108	};
109
110	struct ds_data {
111	struct ds_msg_tag tag;
112	__u64 handle;
113	};
114
115	struct ds_data_nack {
116	struct ds_msg_tag tag;
117	__u64 handle;
118	__u64 result;
119	};
120
121	struct ds_cap_state {
122	__u64 handle;
123
124	void (data)(struct ldc_channel lp,
125	struct ds_cap_state *dp,
126	void *buf, int len);
127
128	const char *service_id;
129
130	u8 state;
131	#define CAP_STATE_UNKNOWN 0x00
132	#define CAP_STATE_REG_SENT 0x01
133	#define CAP_STATE_REGISTERED 0x02
134	};
135
136	static int ds_send(struct ldc_channel lp, void data, int len)
137	{
138	int err, limit = 1000;
139
140	err = -EINVAL;
141	while (limit-- > 0) {
142	err = ldc_write(lp, data, len);
143	if (!err \|\| (err != -EAGAIN))
144	break;
145	udelay(1);
146	}
147
148	return err;
149	}
150
151	struct ds_md_update_req {
152	__u64 req_num;
153	};
154
155	struct ds_md_update_res {
156	__u64 req_num;
157	__u32 result;
158	};
159
160	static void md_update_data(struct ldc_channel *lp,
161	struct ds_cap_state *dp,
162	void *buf, int len)
163	{
164	struct ds_data *dpkt = buf;
165	struct ds_md_update_req *rp;
166	struct {
167	struct ds_data data;
168	struct ds_md_update_res res;
169	} pkt;
170
171	rp = (struct ds_md_update_req *) (dpkt + 1);
172
173	printk(KERN_ERR PFX "MD update REQ [%lx] len=%d\n",
174	rp->req_num, len);
175
176	memset(&pkt, 0, sizeof(pkt));
177	pkt.data.tag.type = DS_DATA;
178	pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
179	pkt.data.handle = dp->handle;
180	pkt.res.req_num = rp->req_num;
181	pkt.res.result = DS_OK;
182
183	ds_send(lp, &pkt, sizeof(pkt));
184	}
185
186	struct ds_shutdown_req {
187	__u64 req_num;
188	__u32 ms_delay;
189	};
190
191	struct ds_shutdown_res {
192	__u64 req_num;
193	__u32 result;
194	char reason[1];
195	};
196
197	static void domain_shutdown_data(struct ldc_channel *lp,
198	struct ds_cap_state *dp,
199	void *buf, int len)
200	{
201	struct ds_data *dpkt = buf;
202	struct ds_shutdown_req *rp;
203	struct {
204	struct ds_data data;
205	struct ds_shutdown_res res;
206	} pkt;
207
208	rp = (struct ds_shutdown_req *) (dpkt + 1);
209
210	printk(KERN_ALERT PFX "Shutdown request from "
211	"LDOM manager received.\n");
212
213	memset(&pkt, 0, sizeof(pkt));
214	pkt.data.tag.type = DS_DATA;
215	pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
216	pkt.data.handle = dp->handle;
217	pkt.res.req_num = rp->req_num;
218	pkt.res.result = DS_OK;
219	pkt.res.reason[0] = 0;
220
221	ds_send(lp, &pkt, sizeof(pkt));
222
223	wake_up_powerd();
224	}
225
226	struct ds_panic_req {
227	__u64 req_num;
228	};
229
230	struct ds_panic_res {
231	__u64 req_num;
232	__u32 result;
233	char reason[1];
234	};
235
236	static void domain_panic_data(struct ldc_channel *lp,
237	struct ds_cap_state *dp,
238	void *buf, int len)
239	{
240	struct ds_data *dpkt = buf;
241	struct ds_panic_req *rp;
242	struct {
243	struct ds_data data;
244	struct ds_panic_res res;
245	} pkt;
246
247	rp = (struct ds_panic_req *) (dpkt + 1);
248
249	printk(KERN_ERR PFX "Panic REQ [%lx], len=%d\n",
250	rp->req_num, len);
251
252	memset(&pkt, 0, sizeof(pkt));
253	pkt.data.tag.type = DS_DATA;
254	pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
255	pkt.data.handle = dp->handle;
256	pkt.res.req_num = rp->req_num;
257	pkt.res.result = DS_OK;
258	pkt.res.reason[0] = 0;
259
260	ds_send(lp, &pkt, sizeof(pkt));
261
262	panic("PANIC requested by LDOM manager.");
263	}
264
265	struct ds_cpu_tag {
266	__u64 req_num;
267	__u32 type;
268	#define DS_CPU_CONFIGURE 0x43
269	#define DS_CPU_UNCONFIGURE 0x55
270	#define DS_CPU_FORCE_UNCONFIGURE 0x46
271	#define DS_CPU_STATUS 0x53
272
273	/* Responses */
274	#define DS_CPU_OK 0x6f
275	#define DS_CPU_ERROR 0x65
276
277	__u32 num_records;
278	};
279
280	struct ds_cpu_record {
281	__u32 cpu_id;
282	};
283
284	static void dr_cpu_data(struct ldc_channel *lp,
285	struct ds_cap_state *dp,
286	void *buf, int len)
287	{
288	struct ds_data *dpkt = buf;
289	struct ds_cpu_tag *rp;
290
291	rp = (struct ds_cpu_tag *) (dpkt + 1);
292
293	printk(KERN_ERR PFX "CPU REQ [%lx:%x], len=%d\n",
294	rp->req_num, rp->type, len);
295	}
296
297	struct ds_pri_msg {
298	__u64 req_num;
299	__u64 type;
300	#define DS_PRI_REQUEST 0x00
301	#define DS_PRI_DATA 0x01
302	#define DS_PRI_UPDATE 0x02
303	};
304
305	static void ds_pri_data(struct ldc_channel *lp,
306	struct ds_cap_state *dp,
307	void *buf, int len)
308	{
309	struct ds_data *dpkt = buf;
310	struct ds_pri_msg *rp;
311
312	rp = (struct ds_pri_msg *) (dpkt + 1);
313
314	printk(KERN_ERR PFX "PRI REQ [%lx:%lx], len=%d\n",
315	rp->req_num, rp->type, len);
316	}
317
318	struct ds_cap_state ds_states[] = {
319	{
320	.service_id = "md-update",
321	.data = md_update_data,
322	},
323	{
324	.service_id = "domain-shutdown",
325	.data = domain_shutdown_data,
326	},
327	{
328	.service_id = "domain-panic",
329	.data = domain_panic_data,
330	},
331	{
332	.service_id = "dr-cpu",
333	.data = dr_cpu_data,
334	},
335	{
336	.service_id = "pri",
337	.data = ds_pri_data,
338	},
339	};
340
341	static struct ds_cap_state *find_cap(u64 handle)
342	{
343	unsigned int index = handle >> 32;
344
345	if (index >= ARRAY_SIZE(ds_states))
346	return NULL;
347	return &ds_states[index];
348	}
349
350	static DEFINE_SPINLOCK(ds_lock);
351
352	struct ds_info {
353	struct ldc_channel *lp;
354	u8 hs_state;
355	#define DS_HS_START 0x01
356	#define DS_HS_DONE 0x02
357
358	void *rcv_buf;
359	int rcv_buf_len;
360	};
361
362	static void ds_conn_reset(struct ds_info *dp)
363	{
364	printk(KERN_ERR PFX "ds_conn_reset() from %p\n",
365	__builtin_return_address(0));
366	}
367
368	static int register_services(struct ds_info *dp)
369	{
370	struct ldc_channel *lp = dp->lp;
371	int i;
372
373	for (i = 0; i < ARRAY_SIZE(ds_states); i++) {
374	struct {
375	struct ds_reg_req req;
376	u8 id_buf[256];
377	} pbuf;
378	struct ds_cap_state *cp = &ds_states[i];
379	int err, msg_len;
380	u64 new_count;
381
382	if (cp->state == CAP_STATE_REGISTERED)
383	continue;
384
385	new_count = sched_clock() & 0xffffffff;
386	cp->handle = ((u64) i << 32) \| new_count;
387
388	msg_len = (sizeof(struct ds_reg_req) +
389	strlen(cp->service_id));
390
391	memset(&pbuf, 0, sizeof(pbuf));
392	pbuf.req.tag.type = DS_REG_REQ;
393	pbuf.req.tag.len = (msg_len - sizeof(struct ds_msg_tag));
394	pbuf.req.handle = cp->handle;
395	pbuf.req.major = 1;
396	pbuf.req.minor = 0;
397	strcpy(pbuf.req.svc_id, cp->service_id);
398
399	err = ds_send(lp, &pbuf, msg_len);
400	if (err > 0)
401	cp->state = CAP_STATE_REG_SENT;
402	}
403	return 0;
404	}
405
406	static int ds_handshake(struct ds_info dp, struct ds_msg_tag pkt)
407	{
408
409	if (dp->hs_state == DS_HS_START) {
410	if (pkt->type != DS_INIT_ACK)
411	goto conn_reset;
412
413	dp->hs_state = DS_HS_DONE;
414
415	return register_services(dp);
416	}
417
418	if (dp->hs_state != DS_HS_DONE)
419	goto conn_reset;
420
421	if (pkt->type == DS_REG_ACK) {
422	struct ds_reg_ack ap = (struct ds_reg_ack ) pkt;
423	struct ds_cap_state *cp = find_cap(ap->handle);
424
425	if (!cp) {
426	printk(KERN_ERR PFX "REG ACK for unknown handle %lx\n",
427	ap->handle);
428	return 0;
429	}
430	printk(KERN_INFO PFX "Registered %s service.\n",
431	cp->service_id);
432	cp->state = CAP_STATE_REGISTERED;
433	} else if (pkt->type == DS_REG_NACK) {
434	struct ds_reg_nack np = (struct ds_reg_nack ) pkt;
435	struct ds_cap_state *cp = find_cap(np->handle);
436
437	if (!cp) {
438	printk(KERN_ERR PFX "REG NACK for "
439	"unknown handle %lx\n",
440	np->handle);
441	return 0;
442	}
443	printk(KERN_ERR PFX "Could not register %s service\n",
444	cp->service_id);
445	cp->state = CAP_STATE_UNKNOWN;
446	}
447
448	return 0;
449
450	conn_reset:
451	ds_conn_reset(dp);
452	return -ECONNRESET;
453	}
454
455	static int ds_data(struct ds_info dp, struct ds_msg_tag pkt, int len)
456	{
457	struct ds_data dpkt = (struct ds_data ) pkt;
458	struct ds_cap_state *cp = find_cap(dpkt->handle);
459
460	if (!cp) {
461	struct ds_data_nack nack = {
462	.tag = {
463	.type = DS_NACK,
464	.len = (sizeof(struct ds_data_nack) -
465	sizeof(struct ds_msg_tag)),
466	},
467	.handle = dpkt->handle,
468	.result = DS_INV_HDL,
469	};
470
471	printk(KERN_ERR PFX "Data for unknown handle %lu\n",
472	dpkt->handle);
473	ds_send(dp->lp, &nack, sizeof(nack));
474	} else {
475	cp->data(dp->lp, cp, dpkt, len);
476	}
477	return 0;
478	}
479
480	static void ds_up(struct ds_info *dp)
481	{
482	struct ldc_channel *lp = dp->lp;
483	struct ds_ver_req req;
484	int err;
485
486	req.tag.type = DS_INIT_REQ;
487	req.tag.len = sizeof(req) - sizeof(struct ds_msg_tag);
488	req.ver.major = 1;
489	req.ver.minor = 0;
490
491	err = ds_send(lp, &req, sizeof(req));
492	if (err > 0)
493	dp->hs_state = DS_HS_START;
494	}
495
496	static void ds_event(void *arg, int event)
497	{
498	struct ds_info *dp = arg;
499	struct ldc_channel *lp = dp->lp;
500	unsigned long flags;
501	int err;
502
503	spin_lock_irqsave(&ds_lock, flags);
504
505	if (event == LDC_EVENT_UP) {
506	ds_up(dp);
507	spin_unlock_irqrestore(&ds_lock, flags);
508	return;
509	}
510
511	if (event != LDC_EVENT_DATA_READY) {
512	printk(KERN_WARNING PFX "Unexpected LDC event %d\n", event);
513	spin_unlock_irqrestore(&ds_lock, flags);
514	return;
515	}
516
517	err = 0;
518	while (1) {
519	struct ds_msg_tag *tag;
520
521	err = ldc_read(lp, dp->rcv_buf, sizeof(*tag));
522
523	if (unlikely(err < 0)) {
524	if (err == -ECONNRESET)
525	ds_conn_reset(dp);
526	break;
527	}
528	if (err == 0)
529	break;
530
531	tag = dp->rcv_buf;
532	err = ldc_read(lp, tag + 1, tag->len);
533
534	if (unlikely(err < 0)) {
535	if (err == -ECONNRESET)
536	ds_conn_reset(dp);
537	break;
538	}
539	if (err < tag->len)
540	break;
541
542	if (tag->type < DS_DATA)
543	err = ds_handshake(dp, dp->rcv_buf);
544	else
545	err = ds_data(dp, dp->rcv_buf,
546	sizeof(*tag) + err);
547	if (err == -ECONNRESET)
548	break;
549	}
550
551	spin_unlock_irqrestore(&ds_lock, flags);
552	}
553
554	static int __devinit ds_probe(struct vio_dev *vdev,
555	const struct vio_device_id *id)
556	{
557	static int ds_version_printed;
558	struct mdesc_node *endp;
559	struct ldc_channel_config ds_cfg = {
560	.event = ds_event,
561	.mtu = 4096,
562	.mode = LDC_MODE_STREAM,
563	};
564	struct ldc_channel *lp;
565	struct ds_info *dp;
566	const u64 *chan_id;
567	int err;
568
569	if (ds_version_printed++ == 0)
570	printk(KERN_INFO "%s", version);
571
572	endp = vio_find_endpoint(vdev);
573	if (!endp)
574	return -ENODEV;
575
576	chan_id = md_get_property(endp, "id", NULL);
577	if (!chan_id)
578	return -ENODEV;
579
580	dp = kzalloc(sizeof(*dp), GFP_KERNEL);
581	err = -ENOMEM;
582	if (!dp)
583	goto out_err;
584
585	dp->rcv_buf = kzalloc(4096, GFP_KERNEL);
586	if (!dp->rcv_buf)
587	goto out_free_dp;
588
589	dp->rcv_buf_len = 4096;
590
591	ds_cfg.tx_irq = endp->irqs[0];
592	ds_cfg.rx_irq = endp->irqs[1];
593
594	lp = ldc_alloc(*chan_id, &ds_cfg, dp);
595	if (IS_ERR(lp)) {
596	err = PTR_ERR(lp);
597	goto out_free_rcv_buf;
598	}
599	dp->lp = lp;
600
601	err = ldc_bind(lp);
602	if (err)
603	goto out_free_ldc;
604
605	start_powerd();
606
607	return err;
608
609	out_free_ldc:
610	ldc_free(dp->lp);
611
612	out_free_rcv_buf:
613	kfree(dp->rcv_buf);
614
615	out_free_dp:
616	kfree(dp);
617
618	out_err:
619	return err;
620	}
621
622	static int ds_remove(struct vio_dev *vdev)
623	{
624	return 0;
625	}
626
627	static struct vio_device_id ds_match[] = {
628	{
629	.type = "domain-services-port",
630	},
631	{},
632	};
633
634	static struct vio_driver ds_driver = {
635	.id_table = ds_match,
636	.probe = ds_probe,
637	.remove = ds_remove,
638	.driver = {
639	.name = "ds",
640	.owner = THIS_MODULE,
641	}
642	};
643
644	static int __init ds_init(void)
645	{
646	int i;
647
648	for (i = 0; i < ARRAY_SIZE(ds_states); i++)
649	ds_states[i].handle = ((u64)i << 32);
650
651	return vio_register_driver(&ds_driver);
652	}
653
654	subsys_initcall(ds_init);