[mirror_ubuntu-zesty-kernel.git] / arch / sparc64 / kernel / vio.c

/* vio.c: Virtual I/O channel devices probing infrastructure.
 *
 *    Copyright (c) 2003-2005 IBM Corp.
 *     Dave Engebretsen engebret@us.ibm.com
 *     Santiago Leon santil@us.ibm.com
 *     Hollis Blanchard <hollisb@us.ibm.com>
 *     Stephen Rothwell
 *
 * Adapted to sparc64 by David S. Miller davem@davemloft.net
 */

#include <linux/kernel.h>
#include <linux/irq.h>
#include <linux/init.h>

#include <asm/mdesc.h>
#include <asm/vio.h>

static inline int find_in_proplist(const char *list, const char *match,
				   int len)
{
	while (len > 0) {
		int l;

		if (!strcmp(list, match))
			return 1;
		l = strlen(list) + 1;
		list += l;
		len -= l;
	}
	return 0;
}

static const struct vio_device_id *vio_match_device(
	const struct vio_device_id *matches,
	const struct vio_dev *dev)
{
	const char *type, *compat;
	int len;

	type = dev->type;
	compat = dev->compat;
	len = dev->compat_len;

	while (matches->type[0] || matches->compat[0]) {
		int match = 1;
		if (matches->type[0]) {
			match &= type
				&& !strcmp(matches->type, type);
		}
		if (matches->compat[0]) {
			match &= compat &&
				find_in_proplist(compat, matches->compat, len);
		}
		if (match)
			return matches;
		matches++;
	}
	return NULL;
}

static int vio_bus_match(struct device *dev, struct device_driver *drv)
{
	struct vio_dev *vio_dev = to_vio_dev(dev);
	struct vio_driver *vio_drv = to_vio_driver(drv);
	const struct vio_device_id *matches = vio_drv->id_table;

	if (!matches)
		return 0;

	return vio_match_device(matches, vio_dev) != NULL;
}

static int vio_device_probe(struct device *dev)
{
	struct vio_dev *vdev = to_vio_dev(dev);
	struct vio_driver *drv = to_vio_driver(dev->driver);
	const struct vio_device_id *id;
	int error = -ENODEV;

	if (drv->probe) {
		id = vio_match_device(drv->id_table, vdev);
		if (id)
			error = drv->probe(vdev, id);
	}

	return error;
}

static int vio_device_remove(struct device *dev)
{
	struct vio_dev *vdev = to_vio_dev(dev);
	struct vio_driver *drv = to_vio_driver(dev->driver);

	if (drv->remove)
		return drv->remove(vdev);

	return 1;
}

static ssize_t devspec_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct vio_dev *vdev = to_vio_dev(dev);
	const char *str = "none";

	if (!strcmp(vdev->type, "network"))
		str = "vnet";
	else if (!strcmp(vdev->type, "block"))
		str = "vdisk";

	return sprintf(buf, "%s\n", str);
}

static ssize_t type_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct vio_dev *vdev = to_vio_dev(dev);
	return sprintf(buf, "%s\n", vdev->type);
}

static struct device_attribute vio_dev_attrs[] = {
	__ATTR_RO(devspec),
	__ATTR_RO(type),
	__ATTR_NULL
};

static struct bus_type vio_bus_type = {
	.name		= "vio",
	.dev_attrs	= vio_dev_attrs,
	.match		= vio_bus_match,
	.probe		= vio_device_probe,
	.remove		= vio_device_remove,
};

int vio_register_driver(struct vio_driver *viodrv)
{
	viodrv->driver.bus = &vio_bus_type;

	return driver_register(&viodrv->driver);
}
EXPORT_SYMBOL(vio_register_driver);

void vio_unregister_driver(struct vio_driver *viodrv)
{
	driver_unregister(&viodrv->driver);
}
EXPORT_SYMBOL(vio_unregister_driver);

static void __devinit vio_dev_release(struct device *dev)
{
	kfree(to_vio_dev(dev));
}

static ssize_t
show_pciobppath_attr(struct device *dev, struct device_attribute *attr,
		     char *buf)
{
	struct vio_dev *vdev;
	struct device_node *dp;

	vdev = to_vio_dev(dev);
	dp = vdev->dp;

	return snprintf (buf, PAGE_SIZE, "%s\n", dp->full_name);
}

static DEVICE_ATTR(obppath, S_IRUSR | S_IRGRP | S_IROTH,
		   show_pciobppath_attr, NULL);

struct device_node *cdev_node;

static struct vio_dev *root_vdev;
static u64 cdev_cfg_handle;

static void vio_fill_channel_info(struct mdesc_handle *hp, u64 mp,
				  struct vio_dev *vdev)
{
	u64 a;

	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
		const u64 *chan_id;
		const u64 *irq;
		u64 target;

		target = mdesc_arc_target(hp, a);

		irq = mdesc_get_property(hp, target, "tx-ino", NULL);
		if (irq)
			vdev->tx_irq = sun4v_build_virq(cdev_cfg_handle, *irq);

		irq = mdesc_get_property(hp, target, "rx-ino", NULL);
		if (irq)
			vdev->rx_irq = sun4v_build_virq(cdev_cfg_handle, *irq);

		chan_id = mdesc_get_property(hp, target, "id", NULL);
		if (chan_id)
			vdev->channel_id = *chan_id;
	}
}

static struct vio_dev *vio_create_one(struct mdesc_handle *hp, u64 mp,
				      struct device *parent)
{
	const char *type, *compat;
	struct device_node *dp;
	struct vio_dev *vdev;
	int err, clen;

	type = mdesc_get_property(hp, mp, "device-type", NULL);
	if (!type) {
		type = mdesc_get_property(hp, mp, "name", NULL);
		if (!type)
			type = mdesc_node_name(hp, mp);
	}
	compat = mdesc_get_property(hp, mp, "device-type", &clen);

	vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
	if (!vdev) {
		printk(KERN_ERR "VIO: Could not allocate vio_dev\n");
		return NULL;
	}

	vdev->mp = mp;
	vdev->type = type;
	vdev->compat = compat;
	vdev->compat_len = clen;

	vdev->channel_id = ~0UL;
	vdev->tx_irq = ~0;
	vdev->rx_irq = ~0;

	vio_fill_channel_info(hp, mp, vdev);

	snprintf(vdev->dev.bus_id, BUS_ID_SIZE, "%lx", mp);
	vdev->dev.parent = parent;
	vdev->dev.bus = &vio_bus_type;
	vdev->dev.release = vio_dev_release;

	if (parent == NULL) {
		dp = cdev_node;
	} else if (to_vio_dev(parent) == root_vdev) {
		dp = of_get_next_child(cdev_node, NULL);
		while (dp) {
			if (!strcmp(dp->type, type))
				break;

			dp = of_get_next_child(cdev_node, dp);
		}
	} else {
		dp = to_vio_dev(parent)->dp;
	}
	vdev->dp = dp;

	err = device_register(&vdev->dev);
	if (err) {
		printk(KERN_ERR "VIO: Could not register device %s, err=%d\n",
		       vdev->dev.bus_id, err);
		kfree(vdev);
		return NULL;
	}
	if (vdev->dp)
		err = sysfs_create_file(&vdev->dev.kobj,
					&dev_attr_obppath.attr);

	return vdev;
}

static void walk_tree(struct mdesc_handle *hp, u64 n, struct vio_dev *parent)
{
	u64 a;

	mdesc_for_each_arc(a, hp, n, MDESC_ARC_TYPE_FWD) {
		struct vio_dev *vdev;
		u64 target;

		target = mdesc_arc_target(hp, a);
		vdev = vio_create_one(hp, target, &parent->dev);
		if (vdev)
			walk_tree(hp, target, vdev);
	}
}

static void create_devices(struct mdesc_handle *hp, u64 root)
{
	u64 mp;

	root_vdev = vio_create_one(hp, root, NULL);
	if (!root_vdev) {
		printk(KERN_ERR "VIO: Coult not create root device.\n");
		return;
	}

	walk_tree(hp, root, root_vdev);

	/* Domain services is odd as it doesn't sit underneath the
	 * channel-devices node, so we plug it in manually.
	 */
	mp = mdesc_node_by_name(hp, MDESC_NODE_NULL, "domain-services");
	if (mp != MDESC_NODE_NULL) {
		struct vio_dev *parent = vio_create_one(hp, mp,
							&root_vdev->dev);

		if (parent)
			walk_tree(hp, mp, parent);
	}
}

const char *channel_devices_node = "channel-devices";
const char *channel_devices_compat = "SUNW,sun4v-channel-devices";
const char *cfg_handle_prop = "cfg-handle";

static int __init vio_init(void)
{
	struct mdesc_handle *hp;
	const char *compat;
	const u64 *cfg_handle;
	int err, len;
	u64 root;

	hp = mdesc_grab();
	if (!hp)
		return 0;

	root = mdesc_node_by_name(hp, MDESC_NODE_NULL, channel_devices_node);
	if (root == MDESC_NODE_NULL) {
		printk(KERN_INFO "VIO: No channel-devices MDESC node.\n");
		mdesc_release(hp);
		return 0;
	}

	cdev_node = of_find_node_by_name(NULL, "channel-devices");
	err = -ENODEV;
	if (!cdev_node) {
		printk(KERN_INFO "VIO: No channel-devices OBP node.\n");
		goto out_release;
	}

	compat = mdesc_get_property(hp, root, "compatible", &len);
	if (!compat) {
		printk(KERN_ERR "VIO: Channel devices lacks compatible "
		       "property\n");
		goto out_release;
	}
	if (!find_in_proplist(compat, channel_devices_compat, len)) {
		printk(KERN_ERR "VIO: Channel devices node lacks (%s) "
		       "compat entry.\n", channel_devices_compat);
		goto out_release;
	}

	cfg_handle = mdesc_get_property(hp, root, cfg_handle_prop, NULL);
	if (!cfg_handle) {
		printk(KERN_ERR "VIO: Channel devices lacks %s property\n",
		       cfg_handle_prop);
		goto out_release;
	}

	cdev_cfg_handle = *cfg_handle;

	err = bus_register(&vio_bus_type);
	if (err) {
		printk(KERN_ERR "VIO: Could not register bus type err=%d\n",
		       err);
		return err;
	}

	create_devices(hp, root);

	mdesc_release(hp);

	return 0;

out_release:
	mdesc_release(hp);
	return err;
}

postcore_initcall(vio_init);
Commit	Line	Data
e53e97ce DM	1	/* vio.c: Virtual I/O channel devices probing infrastructure.
	2	*
	3	* Copyright (c) 2003-2005 IBM Corp.
	4	* Dave Engebretsen engebret@us.ibm.com
	5	* Santiago Leon santil@us.ibm.com
	6	* Hollis Blanchard <hollisb@us.ibm.com>
	7	* Stephen Rothwell
	8	*
	9	* Adapted to sparc64 by David S. Miller davem@davemloft.net
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/irq.h>
	14	#include <linux/init.h>
	15
	16	#include <asm/mdesc.h>
	17	#include <asm/vio.h>
	18
	19	static inline int find_in_proplist(const char list, const char match,
	20	int len)
	21	{
	22	while (len > 0) {
	23	int l;
	24
	25	if (!strcmp(list, match))
	26	return 1;
	27	l = strlen(list) + 1;
	28	list += l;
	29	len -= l;
	30	}
	31	return 0;
	32	}
	33
	34	static const struct vio_device_id *vio_match_device(
	35	const struct vio_device_id *matches,
	36	const struct vio_dev *dev)
	37	{
	38	const char type, compat;
	39	int len;
	40
	41	type = dev->type;
	42	compat = dev->compat;
	43	len = dev->compat_len;
	44
	45	while (matches->type[0] \|\| matches->compat[0]) {
	46	int match = 1;
	47	if (matches->type[0]) {
	48	match &= type
	49	&& !strcmp(matches->type, type);
	50	}
	51	if (matches->compat[0]) {
	52	match &= compat &&
	53	find_in_proplist(compat, matches->compat, len);
	54	}
	55	if (match)
	56	return matches;
	57	matches++;
	58	}
	59	return NULL;
	60	}
	61
	62	static int vio_bus_match(struct device dev, struct device_driver drv)
	63	{
	64	struct vio_dev *vio_dev = to_vio_dev(dev);
65	struct vio_driver *vio_drv = to_vio_driver(drv);
66	const struct vio_device_id *matches = vio_drv->id_table;
67
68	if (!matches)
69	return 0;
70
71	return vio_match_device(matches, vio_dev) != NULL;
72	}
73
74	static int vio_device_probe(struct device *dev)
75	{
76	struct vio_dev *vdev = to_vio_dev(dev);
77	struct vio_driver *drv = to_vio_driver(dev->driver);
78	const struct vio_device_id *id;
79	int error = -ENODEV;
80
81	if (drv->probe) {
82	id = vio_match_device(drv->id_table, vdev);
83	if (id)
84	error = drv->probe(vdev, id);
85	}
86
87	return error;
88	}
89
90	static int vio_device_remove(struct device *dev)
91	{
92	struct vio_dev *vdev = to_vio_dev(dev);
93	struct vio_driver *drv = to_vio_driver(dev->driver);
94
95	if (drv->remove)
96	return drv->remove(vdev);
97
98	return 1;
99	}
100
101	static ssize_t devspec_show(struct device *dev,
102	struct device_attribute attr, char buf)
103	{
104	struct vio_dev *vdev = to_vio_dev(dev);
105	const char *str = "none";
106
2c4f4ecb DM	107	if (!strcmp(vdev->type, "network"))
	108	str = "vnet";
	109	else if (!strcmp(vdev->type, "block"))
	110	str = "vdisk";
e53e97ce DM	111
	112	return sprintf(buf, "%s\n", str);
	113	}
	114
2c4f4ecb DM	115	static ssize_t type_show(struct device *dev,
	116	struct device_attribute attr, char buf)
	117	{
	118	struct vio_dev *vdev = to_vio_dev(dev);
	119	return sprintf(buf, "%s\n", vdev->type);
	120	}
	121
e53e97ce DM	122	static struct device_attribute vio_dev_attrs[] = {
e53e97ce DM	123	__ATTR_RO(devspec),
2c4f4ecb	124	__ATTR_RO(type),
e53e97ce DM	125	__ATTR_NULL
	126	};
	127
	128	static struct bus_type vio_bus_type = {
	129	.name = "vio",
	130	.dev_attrs = vio_dev_attrs,
	131	.match = vio_bus_match,
	132	.probe = vio_device_probe,
	133	.remove = vio_device_remove,
	134	};
	135
	136	int vio_register_driver(struct vio_driver *viodrv)
	137	{
	138	viodrv->driver.bus = &vio_bus_type;
	139
	140	return driver_register(&viodrv->driver);
	141	}
	142	EXPORT_SYMBOL(vio_register_driver);
	143
	144	void vio_unregister_driver(struct vio_driver *viodrv)
	145	{
	146	driver_unregister(&viodrv->driver);
	147	}
	148	EXPORT_SYMBOL(vio_unregister_driver);
	149
e53e97ce DM	150	static void __devinit vio_dev_release(struct device *dev)
	151	{
	152	kfree(to_vio_dev(dev));
	153	}
	154
	155	static ssize_t
	156	show_pciobppath_attr(struct device dev, struct device_attribute attr,
	157	char *buf)
	158	{
	159	struct vio_dev *vdev;
	160	struct device_node *dp;
	161
	162	vdev = to_vio_dev(dev);
	163	dp = vdev->dp;
	164
	165	return snprintf (buf, PAGE_SIZE, "%s\n", dp->full_name);
	166	}
	167
	168	static DEVICE_ATTR(obppath, S_IRUSR \| S_IRGRP \| S_IROTH,
	169	show_pciobppath_attr, NULL);
	170
	171	struct device_node *cdev_node;
	172
	173	static struct vio_dev *root_vdev;
	174	static u64 cdev_cfg_handle;
	175
43fdf274 DM	176	static void vio_fill_channel_info(struct mdesc_handle *hp, u64 mp,
	177	struct vio_dev *vdev)
	178	{
	179	u64 a;
	180
	181	mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
	182	const u64 *chan_id;
	183	const u64 *irq;
	184	u64 target;
	185
	186	target = mdesc_arc_target(hp, a);
	187
	188	irq = mdesc_get_property(hp, target, "tx-ino", NULL);
	189	if (irq)
	190	vdev->tx_irq = sun4v_build_virq(cdev_cfg_handle, *irq);
	191
	192	irq = mdesc_get_property(hp, target, "rx-ino", NULL);
	193	if (irq)
	194	vdev->rx_irq = sun4v_build_virq(cdev_cfg_handle, *irq);
	195
	196	chan_id = mdesc_get_property(hp, target, "id", NULL);
	197	if (chan_id)
	198	vdev->channel_id = *chan_id;
	199	}
	200	}
	201
	202	static struct vio_dev vio_create_one(struct mdesc_handle hp, u64 mp,
e53e97ce DM	203	struct device *parent)
	204	{
	205	const char type, compat;
	206	struct device_node *dp;
	207	struct vio_dev *vdev;
e53e97ce DM	208	int err, clen;
e53e97ce DM	209
43fdf274	210	type = mdesc_get_property(hp, mp, "device-type", NULL);
2c4f4ecb	211	if (!type) {
43fdf274	212	type = mdesc_get_property(hp, mp, "name", NULL);
2c4f4ecb	213	if (!type)
43fdf274	214	type = mdesc_node_name(hp, mp);
2c4f4ecb	215	}
43fdf274	216	compat = mdesc_get_property(hp, mp, "device-type", &clen);
e53e97ce DM	217
	218	vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
	219	if (!vdev) {
	220	printk(KERN_ERR "VIO: Could not allocate vio_dev\n");
	221	return NULL;
	222	}
	223
	224	vdev->mp = mp;
	225	vdev->type = type;
	226	vdev->compat = compat;
	227	vdev->compat_len = clen;
	228
43fdf274 DM	229	vdev->channel_id = ~0UL;
	230	vdev->tx_irq = ~0;
	231	vdev->rx_irq = ~0;
e53e97ce	232
43fdf274	233	vio_fill_channel_info(hp, mp, vdev);
e53e97ce	234
43fdf274	235	snprintf(vdev->dev.bus_id, BUS_ID_SIZE, "%lx", mp);
e53e97ce DM	236	vdev->dev.parent = parent;
	237	vdev->dev.bus = &vio_bus_type;
	238	vdev->dev.release = vio_dev_release;
	239
	240	if (parent == NULL) {
	241	dp = cdev_node;
	242	} else if (to_vio_dev(parent) == root_vdev) {
	243	dp = of_get_next_child(cdev_node, NULL);
	244	while (dp) {
	245	if (!strcmp(dp->type, type))
	246	break;
	247
	248	dp = of_get_next_child(cdev_node, dp);
	249	}
	250	} else {
	251	dp = to_vio_dev(parent)->dp;
	252	}
	253	vdev->dp = dp;
	254
	255	err = device_register(&vdev->dev);
	256	if (err) {
	257	printk(KERN_ERR "VIO: Could not register device %s, err=%d\n",
	258	vdev->dev.bus_id, err);
	259	kfree(vdev);
	260	return NULL;
	261	}
	262	if (vdev->dp)
	263	err = sysfs_create_file(&vdev->dev.kobj,
	264	&dev_attr_obppath.attr);
	265
	266	return vdev;
	267	}
	268
43fdf274	269	static void walk_tree(struct mdesc_handle hp, u64 n, struct vio_dev parent)
e53e97ce	270	{
43fdf274	271	u64 a;
e53e97ce	272
43fdf274	273	mdesc_for_each_arc(a, hp, n, MDESC_ARC_TYPE_FWD) {
e53e97ce	274	struct vio_dev *vdev;
43fdf274	275	u64 target;
e53e97ce	276
43fdf274 DM	277	target = mdesc_arc_target(hp, a);
	278	vdev = vio_create_one(hp, target, &parent->dev);
	279	if (vdev)
	280	walk_tree(hp, target, vdev);
e53e97ce DM	281	}
	282	}
	283
43fdf274	284	static void create_devices(struct mdesc_handle *hp, u64 root)
e53e97ce	285	{
43fdf274	286	u64 mp;
2c4f4ecb	287
43fdf274	288	root_vdev = vio_create_one(hp, root, NULL);
e53e97ce DM	289	if (!root_vdev) {
	290	printk(KERN_ERR "VIO: Coult not create root device.\n");
	291	return;
	292	}
	293
43fdf274	294	walk_tree(hp, root, root_vdev);
2c4f4ecb DM	295
	296	/* Domain services is odd as it doesn't sit underneath the
	297	* channel-devices node, so we plug it in manually.
	298	*/
43fdf274 DM	299	mp = mdesc_node_by_name(hp, MDESC_NODE_NULL, "domain-services");
	300	if (mp != MDESC_NODE_NULL) {
	301	struct vio_dev *parent = vio_create_one(hp, mp,
	302	&root_vdev->dev);
2c4f4ecb DM	303
2c4f4ecb DM	304	if (parent)
43fdf274	305	walk_tree(hp, mp, parent);
2c4f4ecb	306	}
e53e97ce DM	307	}
	308
	309	const char *channel_devices_node = "channel-devices";
	310	const char *channel_devices_compat = "SUNW,sun4v-channel-devices";
	311	const char *cfg_handle_prop = "cfg-handle";
	312
	313	static int __init vio_init(void)
	314	{
43fdf274	315	struct mdesc_handle *hp;
e53e97ce DM	316	const char *compat;
	317	const u64 *cfg_handle;
	318	int err, len;
43fdf274 DM	319	u64 root;
	320
	321	hp = mdesc_grab();
	322	if (!hp)
	323	return 0;
e53e97ce	324
43fdf274 DM	325	root = mdesc_node_by_name(hp, MDESC_NODE_NULL, channel_devices_node);
43fdf274 DM	326	if (root == MDESC_NODE_NULL) {
e53e97ce	327	printk(KERN_INFO "VIO: No channel-devices MDESC node.\n");
43fdf274	328	mdesc_release(hp);
e53e97ce DM	329	return 0;
	330	}
	331
	332	cdev_node = of_find_node_by_name(NULL, "channel-devices");
43fdf274	333	err = -ENODEV;
e53e97ce DM	334	if (!cdev_node) {
e53e97ce DM	335	printk(KERN_INFO "VIO: No channel-devices OBP node.\n");
43fdf274	336	goto out_release;
e53e97ce DM	337	}
e53e97ce DM	338
43fdf274	339	compat = mdesc_get_property(hp, root, "compatible", &len);
e53e97ce DM	340	if (!compat) {
	341	printk(KERN_ERR "VIO: Channel devices lacks compatible "
	342	"property\n");
43fdf274	343	goto out_release;
e53e97ce DM	344	}
	345	if (!find_in_proplist(compat, channel_devices_compat, len)) {
	346	printk(KERN_ERR "VIO: Channel devices node lacks (%s) "
	347	"compat entry.\n", channel_devices_compat);
43fdf274	348	goto out_release;
e53e97ce DM	349	}
e53e97ce DM	350
43fdf274	351	cfg_handle = mdesc_get_property(hp, root, cfg_handle_prop, NULL);
e53e97ce DM	352	if (!cfg_handle) {
	353	printk(KERN_ERR "VIO: Channel devices lacks %s property\n",
	354	cfg_handle_prop);
43fdf274	355	goto out_release;
e53e97ce DM	356	}
	357
	358	cdev_cfg_handle = *cfg_handle;
	359
	360	err = bus_register(&vio_bus_type);
	361	if (err) {
	362	printk(KERN_ERR "VIO: Could not register bus type err=%d\n",
	363	err);
	364	return err;
	365	}
	366
43fdf274 DM	367	create_devices(hp, root);
	368
	369	mdesc_release(hp);
e53e97ce DM	370
e53e97ce DM	371	return 0;
43fdf274 DM	372
	373	out_release:
	374	mdesc_release(hp);
	375	return err;
e53e97ce DM	376	}
	377
	378	postcore_initcall(vio_init);