[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / rapidio / rio-sysfs.c

/*
 * RapidIO sysfs attributes and support
 *
 * Copyright 2005 MontaVista Software, Inc.
 * Matt Porter <mporter@kernel.crashing.org>
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/rio.h>
#include <linux/rio_drv.h>
#include <linux/stat.h>
#include <linux/capability.h>

#include "rio.h"

/* Sysfs support */
#define rio_config_attr(field, format_string)					\
static ssize_t								\
field##_show(struct device *dev, struct device_attribute *attr, char *buf)			\
{									\
	struct rio_dev *rdev = to_rio_dev(dev);				\
									\
	return sprintf(buf, format_string, rdev->field);		\
}									\

rio_config_attr(did, "0x%04x\n");
rio_config_attr(vid, "0x%04x\n");
rio_config_attr(device_rev, "0x%08x\n");
rio_config_attr(asm_did, "0x%04x\n");
rio_config_attr(asm_vid, "0x%04x\n");
rio_config_attr(asm_rev, "0x%04x\n");
rio_config_attr(destid, "0x%04x\n");
rio_config_attr(hopcount, "0x%02x\n");

static ssize_t routes_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct rio_dev *rdev = to_rio_dev(dev);
	char *str = buf;
	int i;

	for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
			i++) {
		if (rdev->rswitch->route_table[i] == RIO_INVALID_ROUTE)
			continue;
		str +=
		    sprintf(str, "%04x %02x\n", i,
			    rdev->rswitch->route_table[i]);
	}

	return (str - buf);
}

static ssize_t lprev_show(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	struct rio_dev *rdev = to_rio_dev(dev);

	return sprintf(buf, "%s\n",
			(rdev->prev) ? rio_name(rdev->prev) : "root");
}

static ssize_t lnext_show(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	struct rio_dev *rdev = to_rio_dev(dev);
	char *str = buf;
	int i;

	if (rdev->pef & RIO_PEF_SWITCH) {
		for (i = 0; i < RIO_GET_TOTAL_PORTS(rdev->swpinfo); i++) {
			if (rdev->rswitch->nextdev[i])
				str += sprintf(str, "%s\n",
					rio_name(rdev->rswitch->nextdev[i]));
			else
				str += sprintf(str, "null\n");
		}
	}

	return str - buf;
}

struct device_attribute rio_dev_attrs[] = {
	__ATTR_RO(did),
	__ATTR_RO(vid),
	__ATTR_RO(device_rev),
	__ATTR_RO(asm_did),
	__ATTR_RO(asm_vid),
	__ATTR_RO(asm_rev),
	__ATTR_RO(lprev),
	__ATTR_RO(destid),
	__ATTR_NULL,
};

static DEVICE_ATTR(routes, S_IRUGO, routes_show, NULL);
static DEVICE_ATTR(lnext, S_IRUGO, lnext_show, NULL);
static DEVICE_ATTR(hopcount, S_IRUGO, hopcount_show, NULL);

static ssize_t
rio_read_config(struct file *filp, struct kobject *kobj,
		struct bin_attribute *bin_attr,
		char *buf, loff_t off, size_t count)
{
	struct rio_dev *dev =
	    to_rio_dev(container_of(kobj, struct device, kobj));
	unsigned int size = 0x100;
	loff_t init_off = off;
	u8 *data = (u8 *) buf;

	/* Several chips lock up trying to read undefined config space */
	if (capable(CAP_SYS_ADMIN))
		size = RIO_MAINT_SPACE_SZ;

	if (off >= size)
		return 0;
	if (off + count > size) {
		size -= off;
		count = size;
	} else {
		size = count;
	}

	if ((off & 1) && size) {
		u8 val;
		rio_read_config_8(dev, off, &val);
		data[off - init_off] = val;
		off++;
		size--;
	}

	if ((off & 3) && size > 2) {
		u16 val;
		rio_read_config_16(dev, off, &val);
		data[off - init_off] = (val >> 8) & 0xff;
		data[off - init_off + 1] = val & 0xff;
		off += 2;
		size -= 2;
	}

	while (size > 3) {
		u32 val;
		rio_read_config_32(dev, off, &val);
		data[off - init_off] = (val >> 24) & 0xff;
		data[off - init_off + 1] = (val >> 16) & 0xff;
		data[off - init_off + 2] = (val >> 8) & 0xff;
		data[off - init_off + 3] = val & 0xff;
		off += 4;
		size -= 4;
	}

	if (size >= 2) {
		u16 val;
		rio_read_config_16(dev, off, &val);
		data[off - init_off] = (val >> 8) & 0xff;
		data[off - init_off + 1] = val & 0xff;
		off += 2;
		size -= 2;
	}

	if (size > 0) {
		u8 val;
		rio_read_config_8(dev, off, &val);
		data[off - init_off] = val;
		off++;
		--size;
	}

	return count;
}

static ssize_t
rio_write_config(struct file *filp, struct kobject *kobj,
		 struct bin_attribute *bin_attr,
		 char *buf, loff_t off, size_t count)
{
	struct rio_dev *dev =
	    to_rio_dev(container_of(kobj, struct device, kobj));
	unsigned int size = count;
	loff_t init_off = off;
	u8 *data = (u8 *) buf;

	if (off >= RIO_MAINT_SPACE_SZ)
		return 0;
	if (off + count > RIO_MAINT_SPACE_SZ) {
		size = RIO_MAINT_SPACE_SZ - off;
		count = size;
	}

	if ((off & 1) && size) {
		rio_write_config_8(dev, off, data[off - init_off]);
		off++;
		size--;
	}

	if ((off & 3) && (size > 2)) {
		u16 val = data[off - init_off + 1];
		val |= (u16) data[off - init_off] << 8;
		rio_write_config_16(dev, off, val);
		off += 2;
		size -= 2;
	}

	while (size > 3) {
		u32 val = data[off - init_off + 3];
		val |= (u32) data[off - init_off + 2] << 8;
		val |= (u32) data[off - init_off + 1] << 16;
		val |= (u32) data[off - init_off] << 24;
		rio_write_config_32(dev, off, val);
		off += 4;
		size -= 4;
	}

	if (size >= 2) {
		u16 val = data[off - init_off + 1];
		val |= (u16) data[off - init_off] << 8;
		rio_write_config_16(dev, off, val);
		off += 2;
		size -= 2;
	}

	if (size) {
		rio_write_config_8(dev, off, data[off - init_off]);
		off++;
		--size;
	}

	return count;
}

static struct bin_attribute rio_config_attr = {
	.attr = {
		 .name = "config",
		 .mode = S_IRUGO | S_IWUSR,
		 },
	.size = RIO_MAINT_SPACE_SZ,
	.read = rio_read_config,
	.write = rio_write_config,
};

/**
 * rio_create_sysfs_dev_files - create RIO specific sysfs files
 * @rdev: device whose entries should be created
 *
 * Create files when @rdev is added to sysfs.
 */
int rio_create_sysfs_dev_files(struct rio_dev *rdev)
{
	int err = 0;

	err = device_create_bin_file(&rdev->dev, &rio_config_attr);

	if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
		err |= device_create_file(&rdev->dev, &dev_attr_routes);
		err |= device_create_file(&rdev->dev, &dev_attr_lnext);
		err |= device_create_file(&rdev->dev, &dev_attr_hopcount);
		if (!err && rdev->rswitch->sw_sysfs)
			err = rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_CREATE);
	}

	if (err)
		pr_warning("RIO: Failed to create attribute file(s) for %s\n",
			   rio_name(rdev));

	return err;
}

/**
 * rio_remove_sysfs_dev_files - cleanup RIO specific sysfs files
 * @rdev: device whose entries we should free
 *
 * Cleanup when @rdev is removed from sysfs.
 */
void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
{
	device_remove_bin_file(&rdev->dev, &rio_config_attr);
	if (rdev->pef & RIO_PEF_SWITCH) {
		device_remove_file(&rdev->dev, &dev_attr_routes);
		device_remove_file(&rdev->dev, &dev_attr_lnext);
		device_remove_file(&rdev->dev, &dev_attr_hopcount);
		if (rdev->rswitch->sw_sysfs)
			rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_REMOVE);
	}
}

static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
				size_t count)
{
	long val;
	struct rio_mport *port = NULL;
	int rc;

	if (kstrtol(buf, 0, &val) < 0)
		return -EINVAL;

	if (val == RIO_MPORT_ANY) {
		rc = rio_init_mports();
		goto exit;
	}

	if (val < 0 || val >= RIO_MAX_MPORTS)
		return -EINVAL;

	port = rio_find_mport((int)val);

	if (!port) {
		pr_debug("RIO: %s: mport_%d not available\n",
			 __func__, (int)val);
		return -EINVAL;
	}

	if (!port->nscan)
		return -EINVAL;

	if (port->host_deviceid >= 0)
		rc = port->nscan->enumerate(port, 0);
	else
		rc = port->nscan->discover(port, RIO_SCAN_ENUM_NO_WAIT);
exit:
	if (!rc)
		rc = count;

	return rc;
}

struct bus_attribute rio_bus_attrs[] = {
	__ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store),
	__ATTR_NULL
};
Commit	Line	Data
394b701c MP	1	/*
	2	* RapidIO sysfs attributes and support
	3	*
	4	* Copyright 2005 MontaVista Software, Inc.
	5	* Matt Porter <mporter@kernel.crashing.org>
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the
	9	* Free Software Foundation; either version 2 of the License, or (at your
	10	* option) any later version.
	11	*/
	12
394b701c MP	13	#include <linux/kernel.h>
	14	#include <linux/rio.h>
	15	#include <linux/rio_drv.h>
	16	#include <linux/stat.h>
388b78ad	17	#include <linux/capability.h>
394b701c MP	18
	19	#include "rio.h"
	20
	21	/* Sysfs support */
	22	#define rio_config_attr(field, format_string) \
	23	static ssize_t \
6978bbc0	24	field##_show(struct device dev, struct device_attribute attr, char *buf) \
394b701c MP	25	{ \
	26	struct rio_dev *rdev = to_rio_dev(dev); \
	27	\
	28	return sprintf(buf, format_string, rdev->field); \
	29	} \
	30
	31	rio_config_attr(did, "0x%04x\n");
	32	rio_config_attr(vid, "0x%04x\n");
	33	rio_config_attr(device_rev, "0x%08x\n");
	34	rio_config_attr(asm_did, "0x%04x\n");
	35	rio_config_attr(asm_vid, "0x%04x\n");
	36	rio_config_attr(asm_rev, "0x%04x\n");
cd8b974f AB	37	rio_config_attr(destid, "0x%04x\n");
cd8b974f AB	38	rio_config_attr(hopcount, "0x%02x\n");
394b701c	39
6978bbc0	40	static ssize_t routes_show(struct device dev, struct device_attribute attr, char *buf)
394b701c MP	41	{
	42	struct rio_dev *rdev = to_rio_dev(dev);
	43	char *str = buf;
	44	int i;
	45
e0423236 ZW	46	for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
e0423236 ZW	47	i++) {
394b701c MP	48	if (rdev->rswitch->route_table[i] == RIO_INVALID_ROUTE)
	49	continue;
	50	str +=
	51	sprintf(str, "%04x %02x\n", i,
	52	rdev->rswitch->route_table[i]);
	53	}
	54
394b701c MP	55	return (str - buf);
	56	}
	57
cd8b974f AB	58	static ssize_t lprev_show(struct device *dev,
	59	struct device_attribute attr, char buf)
	60	{
	61	struct rio_dev *rdev = to_rio_dev(dev);
	62
	63	return sprintf(buf, "%s\n",
	64	(rdev->prev) ? rio_name(rdev->prev) : "root");
	65	}
	66
	67	static ssize_t lnext_show(struct device *dev,
	68	struct device_attribute attr, char buf)
	69	{
	70	struct rio_dev *rdev = to_rio_dev(dev);
	71	char *str = buf;
	72	int i;
	73
	74	if (rdev->pef & RIO_PEF_SWITCH) {
	75	for (i = 0; i < RIO_GET_TOTAL_PORTS(rdev->swpinfo); i++) {
	76	if (rdev->rswitch->nextdev[i])
	77	str += sprintf(str, "%s\n",
	78	rio_name(rdev->rswitch->nextdev[i]));
	79	else
	80	str += sprintf(str, "null\n");
	81	}
	82	}
	83
	84	return str - buf;
	85	}
	86
394b701c MP	87	struct device_attribute rio_dev_attrs[] = {
	88	__ATTR_RO(did),
	89	__ATTR_RO(vid),
	90	__ATTR_RO(device_rev),
	91	__ATTR_RO(asm_did),
	92	__ATTR_RO(asm_vid),
	93	__ATTR_RO(asm_rev),
cd8b974f AB	94	__ATTR_RO(lprev),
cd8b974f AB	95	__ATTR_RO(destid),
394b701c MP	96	__ATTR_NULL,
	97	};
	98
ac38d723	99	static DEVICE_ATTR(routes, S_IRUGO, routes_show, NULL);
cd8b974f AB	100	static DEVICE_ATTR(lnext, S_IRUGO, lnext_show, NULL);
cd8b974f AB	101	static DEVICE_ATTR(hopcount, S_IRUGO, hopcount_show, NULL);
ac38d723	102
394b701c	103	static ssize_t
2c3c8bea CW	104	rio_read_config(struct file filp, struct kobject kobj,
2c3c8bea CW	105	struct bin_attribute *bin_attr,
91a69029	106	char *buf, loff_t off, size_t count)
394b701c MP	107	{
	108	struct rio_dev *dev =
	109	to_rio_dev(container_of(kobj, struct device, kobj));
	110	unsigned int size = 0x100;
	111	loff_t init_off = off;
	112	u8 data = (u8 ) buf;
	113
	114	/* Several chips lock up trying to read undefined config space */
	115	if (capable(CAP_SYS_ADMIN))
fe41947e	116	size = RIO_MAINT_SPACE_SZ;
394b701c	117
fe41947e	118	if (off >= size)
394b701c MP	119	return 0;
	120	if (off + count > size) {
	121	size -= off;
	122	count = size;
	123	} else {
	124	size = count;
	125	}
	126
	127	if ((off & 1) && size) {
	128	u8 val;
	129	rio_read_config_8(dev, off, &val);
	130	data[off - init_off] = val;
	131	off++;
	132	size--;
	133	}
	134
	135	if ((off & 3) && size > 2) {
	136	u16 val;
	137	rio_read_config_16(dev, off, &val);
	138	data[off - init_off] = (val >> 8) & 0xff;
	139	data[off - init_off + 1] = val & 0xff;
	140	off += 2;
	141	size -= 2;
	142	}
	143
	144	while (size > 3) {
	145	u32 val;
	146	rio_read_config_32(dev, off, &val);
	147	data[off - init_off] = (val >> 24) & 0xff;
	148	data[off - init_off + 1] = (val >> 16) & 0xff;
	149	data[off - init_off + 2] = (val >> 8) & 0xff;
	150	data[off - init_off + 3] = val & 0xff;
	151	off += 4;
	152	size -= 4;
	153	}
	154
	155	if (size >= 2) {
	156	u16 val;
	157	rio_read_config_16(dev, off, &val);
	158	data[off - init_off] = (val >> 8) & 0xff;
	159	data[off - init_off + 1] = val & 0xff;
	160	off += 2;
	161	size -= 2;
	162	}
	163
	164	if (size > 0) {
	165	u8 val;
	166	rio_read_config_8(dev, off, &val);
	167	data[off - init_off] = val;
	168	off++;
	169	--size;
	170	}
	171
	172	return count;
	173	}
	174
	175	static ssize_t
2c3c8bea CW	176	rio_write_config(struct file filp, struct kobject kobj,
2c3c8bea CW	177	struct bin_attribute *bin_attr,
91a69029	178	char *buf, loff_t off, size_t count)
394b701c MP	179	{
	180	struct rio_dev *dev =
	181	to_rio_dev(container_of(kobj, struct device, kobj));
	182	unsigned int size = count;
	183	loff_t init_off = off;
	184	u8 data = (u8 ) buf;
	185
fe41947e	186	if (off >= RIO_MAINT_SPACE_SZ)
394b701c	187	return 0;
fe41947e AB	188	if (off + count > RIO_MAINT_SPACE_SZ) {
fe41947e AB	189	size = RIO_MAINT_SPACE_SZ - off;
394b701c MP	190	count = size;
	191	}
	192
	193	if ((off & 1) && size) {
	194	rio_write_config_8(dev, off, data[off - init_off]);
	195	off++;
	196	size--;
	197	}
	198
	199	if ((off & 3) && (size > 2)) {
	200	u16 val = data[off - init_off + 1];
	201	val \|= (u16) data[off - init_off] << 8;
	202	rio_write_config_16(dev, off, val);
	203	off += 2;
	204	size -= 2;
	205	}
	206
	207	while (size > 3) {
	208	u32 val = data[off - init_off + 3];
	209	val \|= (u32) data[off - init_off + 2] << 8;
	210	val \|= (u32) data[off - init_off + 1] << 16;
	211	val \|= (u32) data[off - init_off] << 24;
	212	rio_write_config_32(dev, off, val);
	213	off += 4;
	214	size -= 4;
	215	}
	216
	217	if (size >= 2) {
	218	u16 val = data[off - init_off + 1];
	219	val \|= (u16) data[off - init_off] << 8;
	220	rio_write_config_16(dev, off, val);
	221	off += 2;
	222	size -= 2;
	223	}
	224
	225	if (size) {
	226	rio_write_config_8(dev, off, data[off - init_off]);
	227	off++;
	228	--size;
	229	}
	230
	231	return count;
	232	}
	233
	234	static struct bin_attribute rio_config_attr = {
	235	.attr = {
	236	.name = "config",
	237	.mode = S_IRUGO \| S_IWUSR,
394b701c	238	},
fe41947e	239	.size = RIO_MAINT_SPACE_SZ,
394b701c MP	240	.read = rio_read_config,
	241	.write = rio_write_config,
	242	};
	243
	244	/**
	245	* rio_create_sysfs_dev_files - create RIO specific sysfs files
	246	* @rdev: device whose entries should be created
	247	*
	248	* Create files when @rdev is added to sysfs.
	249	*/
	250	int rio_create_sysfs_dev_files(struct rio_dev *rdev)
	251	{
5f28c520	252	int err = 0;
394b701c	253
ac38d723 AB	254	err = device_create_bin_file(&rdev->dev, &rio_config_attr);
ac38d723 AB	255
ded05782	256	if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
cd8b974f AB	257	err \|= device_create_file(&rdev->dev, &dev_attr_routes);
	258	err \|= device_create_file(&rdev->dev, &dev_attr_lnext);
	259	err \|= device_create_file(&rdev->dev, &dev_attr_hopcount);
ac38d723 AB	260	if (!err && rdev->rswitch->sw_sysfs)
	261	err = rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_CREATE);
	262	}
	263
	264	if (err)
	265	pr_warning("RIO: Failed to create attribute file(s) for %s\n",
	266	rio_name(rdev));
5f28c520 YL	267
5f28c520 YL	268	return err;
394b701c MP	269	}
	270
	271	/**
	272	* rio_remove_sysfs_dev_files - cleanup RIO specific sysfs files
	273	* @rdev: device whose entries we should free
	274	*
	275	* Cleanup when @rdev is removed from sysfs.
	276	*/
	277	void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
	278	{
ac38d723	279	device_remove_bin_file(&rdev->dev, &rio_config_attr);
ded05782	280	if (rdev->pef & RIO_PEF_SWITCH) {
ac38d723	281	device_remove_file(&rdev->dev, &dev_attr_routes);
cd8b974f AB	282	device_remove_file(&rdev->dev, &dev_attr_lnext);
cd8b974f AB	283	device_remove_file(&rdev->dev, &dev_attr_hopcount);
ac38d723 AB	284	if (rdev->rswitch->sw_sysfs)
	285	rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_REMOVE);
	286	}
394b701c	287	}
bc8fcfea AB	288
	289	static ssize_t bus_scan_store(struct bus_type bus, const char buf,
	290	size_t count)
	291	{
	292	long val;
	293	struct rio_mport *port = NULL;
	294	int rc;
	295
	296	if (kstrtol(buf, 0, &val) < 0)
	297	return -EINVAL;
	298
	299	if (val == RIO_MPORT_ANY) {
	300	rc = rio_init_mports();
	301	goto exit;
	302	}
	303
	304	if (val < 0 \|\| val >= RIO_MAX_MPORTS)
	305	return -EINVAL;
	306
	307	port = rio_find_mport((int)val);
	308
	309	if (!port) {
	310	pr_debug("RIO: %s: mport_%d not available\n",
	311	__func__, (int)val);
	312	return -EINVAL;
	313	}
	314
	315	if (!port->nscan)
	316	return -EINVAL;
	317
	318	if (port->host_deviceid >= 0)
	319	rc = port->nscan->enumerate(port, 0);
	320	else
	321	rc = port->nscan->discover(port, RIO_SCAN_ENUM_NO_WAIT);
	322	exit:
	323	if (!rc)
	324	rc = count;
	325
	326	return rc;
	327	}
	328
	329	struct bus_attribute rio_bus_attrs[] = {
	330	__ATTR(scan, (S_IWUSR\|S_IWGRP), NULL, bus_scan_store),
	331	__ATTR_NULL
	332	};