[deliverable/linux.git] / arch / tile / kernel / sysfs.c

/*
 * Copyright 2011 Tilera Corporation. All Rights Reserved.
 *
 *   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, version 2.
 *
 *   This program is distributed in the hope that it will be useful, but
 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 *
 * /sys entry support.
 */

#include <linux/device.h>
#include <linux/cpu.h>
#include <linux/slab.h>
#include <linux/smp.h>
#include <linux/stat.h>
#include <hv/hypervisor.h>

/* Return a string queried from the hypervisor, truncated to page size. */
static ssize_t get_hv_confstr(char *page, int query)
{
	ssize_t n = hv_confstr(query, (unsigned long)page, PAGE_SIZE - 1);
	n = n < 0 ? 0 : min(n, (ssize_t)PAGE_SIZE - 1) - 1;
	if (n)
		page[n++] = '\n';
	page[n] = '\0';
	return n;
}

static ssize_t chip_width_show(struct device *dev,
			       struct device_attribute *attr,
			       char *page)
{
	return sprintf(page, "%u\n", smp_width);
}
static DEVICE_ATTR(chip_width, 0444, chip_width_show, NULL);

static ssize_t chip_height_show(struct device *dev,
				struct device_attribute *attr,
				char *page)
{
	return sprintf(page, "%u\n", smp_height);
}
static DEVICE_ATTR(chip_height, 0444, chip_height_show, NULL);

static ssize_t chip_serial_show(struct device *dev,
				struct device_attribute *attr,
				char *page)
{
	return get_hv_confstr(page, HV_CONFSTR_CHIP_SERIAL_NUM);
}
static DEVICE_ATTR(chip_serial, 0444, chip_serial_show, NULL);

static ssize_t chip_revision_show(struct device *dev,
				  struct device_attribute *attr,
				  char *page)
{
	return get_hv_confstr(page, HV_CONFSTR_CHIP_REV);
}
static DEVICE_ATTR(chip_revision, 0444, chip_revision_show, NULL);


static ssize_t type_show(struct device *dev,
			    struct device_attribute *attr,
			    char *page)
{
	return sprintf(page, "tilera\n");
}
static DEVICE_ATTR(type, 0444, type_show, NULL);

#define HV_CONF_ATTR(name, conf)					\
	static ssize_t name ## _show(struct device *dev,		\
				     struct device_attribute *attr, \
				     char *page)			\
	{								\
		return get_hv_confstr(page, conf);			\
	}								\
	static DEVICE_ATTR(name, 0444, name ## _show, NULL);

HV_CONF_ATTR(version,		HV_CONFSTR_HV_SW_VER)
HV_CONF_ATTR(config_version,	HV_CONFSTR_HV_CONFIG_VER)

HV_CONF_ATTR(board_part,	HV_CONFSTR_BOARD_PART_NUM)
HV_CONF_ATTR(board_serial,	HV_CONFSTR_BOARD_SERIAL_NUM)
HV_CONF_ATTR(board_revision,	HV_CONFSTR_BOARD_REV)
HV_CONF_ATTR(board_description,	HV_CONFSTR_BOARD_DESC)
HV_CONF_ATTR(mezz_part,		HV_CONFSTR_MEZZ_PART_NUM)
HV_CONF_ATTR(mezz_serial,	HV_CONFSTR_MEZZ_SERIAL_NUM)
HV_CONF_ATTR(mezz_revision,	HV_CONFSTR_MEZZ_REV)
HV_CONF_ATTR(mezz_description,	HV_CONFSTR_MEZZ_DESC)
HV_CONF_ATTR(cpumod_part,	HV_CONFSTR_CPUMOD_PART_NUM)
HV_CONF_ATTR(cpumod_serial,	HV_CONFSTR_CPUMOD_SERIAL_NUM)
HV_CONF_ATTR(cpumod_revision,	HV_CONFSTR_CPUMOD_REV)
HV_CONF_ATTR(cpumod_description,HV_CONFSTR_CPUMOD_DESC)
HV_CONF_ATTR(switch_control,	HV_CONFSTR_SWITCH_CONTROL)

static struct attribute *board_attrs[] = {
	&dev_attr_board_part.attr,
	&dev_attr_board_serial.attr,
	&dev_attr_board_revision.attr,
	&dev_attr_board_description.attr,
	&dev_attr_mezz_part.attr,
	&dev_attr_mezz_serial.attr,
	&dev_attr_mezz_revision.attr,
	&dev_attr_mezz_description.attr,
	&dev_attr_cpumod_part.attr,
	&dev_attr_cpumod_serial.attr,
	&dev_attr_cpumod_revision.attr,
	&dev_attr_cpumod_description.attr,
	&dev_attr_switch_control.attr,
	NULL
};

static struct attribute_group board_attr_group = {
	.name   = "board",
	.attrs  = board_attrs,
};


static struct bin_attribute hvconfig_bin;

static ssize_t
hvconfig_bin_read(struct file *filp, struct kobject *kobj,
		  struct bin_attribute *bin_attr,
		  char *buf, loff_t off, size_t count)
{
	static size_t size;

	/* Lazily learn the true size (minus the trailing NUL). */
	if (size == 0)
		size = hv_confstr(HV_CONFSTR_HV_CONFIG, 0, 0) - 1;

	/* Check and adjust input parameters. */
	if (off > size)
		return -EINVAL;
	if (count > size - off)
		count = size - off;

	if (count) {
		/* Get a copy of the hvc and copy out the relevant portion. */
		char *hvc;

		size = off + count;
		hvc = kmalloc(size, GFP_KERNEL);
		if (hvc == NULL)
			return -ENOMEM;
		hv_confstr(HV_CONFSTR_HV_CONFIG, (unsigned long)hvc, size);
		memcpy(buf, hvc + off, count);
		kfree(hvc);
	}

	return count;
}

static ssize_t hv_stats_show(struct device *dev,
			     struct device_attribute *attr,
			     char *page)
{
	int cpu = dev->id;
	long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu));

	ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS,
			       (unsigned long)page, PAGE_SIZE - 1,
			       lotar, 0);
	n = n < 0 ? 0 : min(n, (ssize_t)PAGE_SIZE - 1);
	page[n] = '\0';
	return n;
}

static ssize_t hv_stats_store(struct device *dev,
			      struct device_attribute *attr,
			      const char *page,
			      size_t count)
{
	int cpu = dev->id;
	long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu));

	ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS, 0, 0, lotar, 1);
	return n < 0 ? n : count;
}

static DEVICE_ATTR(hv_stats, 0644, hv_stats_show, hv_stats_store);

static int hv_stats_device_add(struct device *dev, struct subsys_interface *sif)
{
	int err, cpu = dev->id;

	if (!cpu_online(cpu))
		return 0;

	err = sysfs_create_file(&dev->kobj, &dev_attr_hv_stats.attr);

	return err;
}

static void hv_stats_device_remove(struct device *dev,
				   struct subsys_interface *sif)
{
	int cpu = dev->id;

	if (cpu_online(cpu))
		sysfs_remove_file(&dev->kobj, &dev_attr_hv_stats.attr);
}


static struct subsys_interface hv_stats_interface = {
	.name			= "hv_stats",
	.subsys			= &cpu_subsys,
	.add_dev		= hv_stats_device_add,
	.remove_dev		= hv_stats_device_remove,
};

static int __init create_sysfs_entries(void)
{
	int err = 0;

#define create_cpu_attr(name)						\
	if (!err)							\
		err = device_create_file(cpu_subsys.dev_root, &dev_attr_##name);
	create_cpu_attr(chip_width);
	create_cpu_attr(chip_height);
	create_cpu_attr(chip_serial);
	create_cpu_attr(chip_revision);

#define create_hv_attr(name)						\
	if (!err)							\
		err = sysfs_create_file(hypervisor_kobj, &dev_attr_##name.attr);
	create_hv_attr(type);
	create_hv_attr(version);
	create_hv_attr(config_version);

	if (!err)
		err = sysfs_create_group(hypervisor_kobj, &board_attr_group);

	if (!err) {
		sysfs_bin_attr_init(&hvconfig_bin);
		hvconfig_bin.attr.name = "hvconfig";
		hvconfig_bin.attr.mode = S_IRUGO;
		hvconfig_bin.read = hvconfig_bin_read;
		hvconfig_bin.size = PAGE_SIZE;
		err = sysfs_create_bin_file(hypervisor_kobj, &hvconfig_bin);
	}

	if (!err) {
		/*
		 * Don't bother adding the hv_stats files on each CPU if
		 * our hypervisor doesn't supply statistics.
		 */
		int cpu = raw_smp_processor_id();
		long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu));
		char dummy;
		ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS,
				       (unsigned long) &dummy, 1,
				       lotar, 0);
		if (n >= 0)
			err = subsys_interface_register(&hv_stats_interface);
	}

	return err;
}
subsys_initcall(create_sysfs_entries);
Commit	Line	Data
f133ecca CM	1	/*
	2	* Copyright 2011 Tilera Corporation. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation, version 2.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	11	* NON INFRINGEMENT. See the GNU General Public License for
	12	* more details.
	13	*
	14	* /sys entry support.
	15	*/
	16
8a25a2fd	17	#include <linux/device.h>
f133ecca CM	18	#include <linux/cpu.h>
	19	#include <linux/slab.h>
	20	#include <linux/smp.h>
3989efb7	21	#include <linux/stat.h>
f133ecca CM	22	#include <hv/hypervisor.h>
	23
	24	/* Return a string queried from the hypervisor, truncated to page size. */
	25	static ssize_t get_hv_confstr(char *page, int query)
	26	{
	27	ssize_t n = hv_confstr(query, (unsigned long)page, PAGE_SIZE - 1);
	28	n = n < 0 ? 0 : min(n, (ssize_t)PAGE_SIZE - 1) - 1;
	29	if (n)
	30	page[n++] = '\n';
	31	page[n] = '\0';
	32	return n;
	33	}
	34
8a25a2fd KS	35	static ssize_t chip_width_show(struct device *dev,
8a25a2fd KS	36	struct device_attribute *attr,
f133ecca CM	37	char *page)
	38	{
	39	return sprintf(page, "%u\n", smp_width);
	40	}
8a25a2fd	41	static DEVICE_ATTR(chip_width, 0444, chip_width_show, NULL);
f133ecca	42
8a25a2fd KS	43	static ssize_t chip_height_show(struct device *dev,
8a25a2fd KS	44	struct device_attribute *attr,
f133ecca CM	45	char *page)
	46	{
	47	return sprintf(page, "%u\n", smp_height);
	48	}
8a25a2fd	49	static DEVICE_ATTR(chip_height, 0444, chip_height_show, NULL);
f133ecca	50
8a25a2fd KS	51	static ssize_t chip_serial_show(struct device *dev,
8a25a2fd KS	52	struct device_attribute *attr,
f133ecca CM	53	char *page)
	54	{
	55	return get_hv_confstr(page, HV_CONFSTR_CHIP_SERIAL_NUM);
	56	}
8a25a2fd	57	static DEVICE_ATTR(chip_serial, 0444, chip_serial_show, NULL);
f133ecca	58
8a25a2fd KS	59	static ssize_t chip_revision_show(struct device *dev,
8a25a2fd KS	60	struct device_attribute *attr,
f133ecca CM	61	char *page)
	62	{
	63	return get_hv_confstr(page, HV_CONFSTR_CHIP_REV);
	64	}
8a25a2fd	65	static DEVICE_ATTR(chip_revision, 0444, chip_revision_show, NULL);
f133ecca CM	66
f133ecca CM	67
8a25a2fd KS	68	static ssize_t type_show(struct device *dev,
8a25a2fd KS	69	struct device_attribute *attr,
f133ecca CM	70	char *page)
	71	{
	72	return sprintf(page, "tilera\n");
	73	}
8a25a2fd	74	static DEVICE_ATTR(type, 0444, type_show, NULL);
f133ecca CM	75
f133ecca CM	76	#define HV_CONF_ATTR(name, conf) \
8a25a2fd KS	77	static ssize_t name ## _show(struct device *dev, \
8a25a2fd KS	78	struct device_attribute *attr, \
f133ecca CM	79	char *page) \
	80	{ \
	81	return get_hv_confstr(page, conf); \
	82	} \
8a25a2fd	83	static DEVICE_ATTR(name, 0444, name ## _show, NULL);
f133ecca CM	84
	85	HV_CONF_ATTR(version, HV_CONFSTR_HV_SW_VER)
	86	HV_CONF_ATTR(config_version, HV_CONFSTR_HV_CONFIG_VER)
	87
	88	HV_CONF_ATTR(board_part, HV_CONFSTR_BOARD_PART_NUM)
	89	HV_CONF_ATTR(board_serial, HV_CONFSTR_BOARD_SERIAL_NUM)
	90	HV_CONF_ATTR(board_revision, HV_CONFSTR_BOARD_REV)
	91	HV_CONF_ATTR(board_description, HV_CONFSTR_BOARD_DESC)
	92	HV_CONF_ATTR(mezz_part, HV_CONFSTR_MEZZ_PART_NUM)
	93	HV_CONF_ATTR(mezz_serial, HV_CONFSTR_MEZZ_SERIAL_NUM)
	94	HV_CONF_ATTR(mezz_revision, HV_CONFSTR_MEZZ_REV)
	95	HV_CONF_ATTR(mezz_description, HV_CONFSTR_MEZZ_DESC)
8703d6e0 CM	96	HV_CONF_ATTR(cpumod_part, HV_CONFSTR_CPUMOD_PART_NUM)
	97	HV_CONF_ATTR(cpumod_serial, HV_CONFSTR_CPUMOD_SERIAL_NUM)
	98	HV_CONF_ATTR(cpumod_revision, HV_CONFSTR_CPUMOD_REV)
	99	HV_CONF_ATTR(cpumod_description,HV_CONFSTR_CPUMOD_DESC)
f133ecca CM	100	HV_CONF_ATTR(switch_control, HV_CONFSTR_SWITCH_CONTROL)
	101
	102	static struct attribute *board_attrs[] = {
8a25a2fd KS	103	&dev_attr_board_part.attr,
	104	&dev_attr_board_serial.attr,
	105	&dev_attr_board_revision.attr,
	106	&dev_attr_board_description.attr,
	107	&dev_attr_mezz_part.attr,
	108	&dev_attr_mezz_serial.attr,
	109	&dev_attr_mezz_revision.attr,
	110	&dev_attr_mezz_description.attr,
8703d6e0 CM	111	&dev_attr_cpumod_part.attr,
	112	&dev_attr_cpumod_serial.attr,
	113	&dev_attr_cpumod_revision.attr,
	114	&dev_attr_cpumod_description.attr,
8a25a2fd	115	&dev_attr_switch_control.attr,
f133ecca CM	116	NULL
	117	};
	118
	119	static struct attribute_group board_attr_group = {
	120	.name = "board",
	121	.attrs = board_attrs,
	122	};
	123
	124
	125	static struct bin_attribute hvconfig_bin;
	126
	127	static ssize_t
	128	hvconfig_bin_read(struct file filp, struct kobject kobj,
	129	struct bin_attribute *bin_attr,
	130	char *buf, loff_t off, size_t count)
	131	{
	132	static size_t size;
	133
	134	/* Lazily learn the true size (minus the trailing NUL). */
	135	if (size == 0)
	136	size = hv_confstr(HV_CONFSTR_HV_CONFIG, 0, 0) - 1;
	137
	138	/* Check and adjust input parameters. */
	139	if (off > size)
	140	return -EINVAL;
	141	if (count > size - off)
	142	count = size - off;
	143
	144	if (count) {
	145	/* Get a copy of the hvc and copy out the relevant portion. */
	146	char *hvc;
	147
	148	size = off + count;
	149	hvc = kmalloc(size, GFP_KERNEL);
	150	if (hvc == NULL)
	151	return -ENOMEM;
	152	hv_confstr(HV_CONFSTR_HV_CONFIG, (unsigned long)hvc, size);
	153	memcpy(buf, hvc + off, count);
	154	kfree(hvc);
	155	}
	156
	157	return count;
	158	}
	159
80f18410 CM	160	static ssize_t hv_stats_show(struct device *dev,
	161	struct device_attribute *attr,
	162	char *page)
	163	{
	164	int cpu = dev->id;
	165	long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu));
	166
	167	ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS,
	168	(unsigned long)page, PAGE_SIZE - 1,
	169	lotar, 0);
	170	n = n < 0 ? 0 : min(n, (ssize_t)PAGE_SIZE - 1);
	171	page[n] = '\0';
	172	return n;
	173	}
	174
	175	static ssize_t hv_stats_store(struct device *dev,
	176	struct device_attribute *attr,
	177	const char *page,
	178	size_t count)
	179	{
	180	int cpu = dev->id;
	181	long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu));
	182
	183	ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS, 0, 0, lotar, 1);
	184	return n < 0 ? n : count;
	185	}
	186
	187	static DEVICE_ATTR(hv_stats, 0644, hv_stats_show, hv_stats_store);
	188
	189	static int hv_stats_device_add(struct device dev, struct subsys_interface sif)
	190	{
	191	int err, cpu = dev->id;
	192
	193	if (!cpu_online(cpu))
	194	return 0;
	195
	196	err = sysfs_create_file(&dev->kobj, &dev_attr_hv_stats.attr);
	197
	198	return err;
	199	}
	200
71db87ba VK	201	static void hv_stats_device_remove(struct device *dev,
71db87ba VK	202	struct subsys_interface *sif)
80f18410 CM	203	{
	204	int cpu = dev->id;
	205
71db87ba VK	206	if (cpu_online(cpu))
71db87ba VK	207	sysfs_remove_file(&dev->kobj, &dev_attr_hv_stats.attr);
80f18410 CM	208	}
	209
	210
	211	static struct subsys_interface hv_stats_interface = {
	212	.name = "hv_stats",
	213	.subsys = &cpu_subsys,
	214	.add_dev = hv_stats_device_add,
	215	.remove_dev = hv_stats_device_remove,
	216	};
	217
f133ecca CM	218	static int __init create_sysfs_entries(void)
f133ecca CM	219	{
f133ecca CM	220	int err = 0;
	221
	222	#define create_cpu_attr(name) \
	223	if (!err) \
8a25a2fd	224	err = device_create_file(cpu_subsys.dev_root, &dev_attr_##name);
f133ecca CM	225	create_cpu_attr(chip_width);
	226	create_cpu_attr(chip_height);
	227	create_cpu_attr(chip_serial);
	228	create_cpu_attr(chip_revision);
	229
	230	#define create_hv_attr(name) \
	231	if (!err) \
688b4db0	232	err = sysfs_create_file(hypervisor_kobj, &dev_attr_##name.attr);
f133ecca CM	233	create_hv_attr(type);
	234	create_hv_attr(version);
	235	create_hv_attr(config_version);
	236
	237	if (!err)
	238	err = sysfs_create_group(hypervisor_kobj, &board_attr_group);
	239
	240	if (!err) {
	241	sysfs_bin_attr_init(&hvconfig_bin);
	242	hvconfig_bin.attr.name = "hvconfig";
	243	hvconfig_bin.attr.mode = S_IRUGO;
	244	hvconfig_bin.read = hvconfig_bin_read;
	245	hvconfig_bin.size = PAGE_SIZE;
	246	err = sysfs_create_bin_file(hypervisor_kobj, &hvconfig_bin);
	247	}
	248
80f18410 CM	249	if (!err) {
	250	/*
	251	* Don't bother adding the hv_stats files on each CPU if
	252	* our hypervisor doesn't supply statistics.
	253	*/
	254	int cpu = raw_smp_processor_id();
	255	long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu));
	256	char dummy;
	257	ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS,
	258	(unsigned long) &dummy, 1,
	259	lotar, 0);
	260	if (n >= 0)
	261	err = subsys_interface_register(&hv_stats_interface);
	262	}
	263
f133ecca CM	264	return err;
	265	}
	266	subsys_initcall(create_sysfs_entries);