[linux.git] / drivers / ptp / ptp_sysfs.c

/*
 * PTP 1588 clock support - sysfs interface.
 *
 * Copyright (C) 2010 OMICRON electronics GmbH
 *
 *  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.
 *
 *  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.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <linux/capability.h>
#include <linux/slab.h>

#include "ptp_private.h"

static ssize_t clock_name_show(struct device *dev,
			       struct device_attribute *attr, char *page)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	return snprintf(page, PAGE_SIZE-1, "%s\n", ptp->info->name);
}
static DEVICE_ATTR_RO(clock_name);

#define PTP_SHOW_INT(name, var)						\
static ssize_t var##_show(struct device *dev,				\
			   struct device_attribute *attr, char *page)	\
{									\
	struct ptp_clock *ptp = dev_get_drvdata(dev);			\
	return snprintf(page, PAGE_SIZE-1, "%d\n", ptp->info->var);	\
}									\
static DEVICE_ATTR(name, 0444, var##_show, NULL);

PTP_SHOW_INT(max_adjustment, max_adj);
PTP_SHOW_INT(n_alarms, n_alarm);
PTP_SHOW_INT(n_external_timestamps, n_ext_ts);
PTP_SHOW_INT(n_periodic_outputs, n_per_out);
PTP_SHOW_INT(n_programmable_pins, n_pins);
PTP_SHOW_INT(pps_available, pps);

static struct attribute *ptp_attrs[] = {
	&dev_attr_clock_name.attr,
	&dev_attr_max_adjustment.attr,
	&dev_attr_n_alarms.attr,
	&dev_attr_n_external_timestamps.attr,
	&dev_attr_n_periodic_outputs.attr,
	&dev_attr_n_programmable_pins.attr,
	&dev_attr_pps_available.attr,
	NULL,
};

static const struct attribute_group ptp_group = {
	.attrs = ptp_attrs,
};

const struct attribute_group *ptp_groups[] = {
	&ptp_group,
	NULL,
};


static ssize_t extts_enable_store(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	struct ptp_clock_info *ops = ptp->info;
	struct ptp_clock_request req = { .type = PTP_CLK_REQ_EXTTS };
	int cnt, enable;
	int err = -EINVAL;

	cnt = sscanf(buf, "%u %d", &req.extts.index, &enable);
	if (cnt != 2)
		goto out;
	if (req.extts.index >= ops->n_ext_ts)
		goto out;

	err = ops->enable(ops, &req, enable ? 1 : 0);
	if (err)
		goto out;

	return count;
out:
	return err;
}

static ssize_t extts_fifo_show(struct device *dev,
			       struct device_attribute *attr, char *page)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	struct timestamp_event_queue *queue = &ptp->tsevq;
	struct ptp_extts_event event;
	unsigned long flags;
	size_t qcnt;
	int cnt = 0;

	memset(&event, 0, sizeof(event));

	if (mutex_lock_interruptible(&ptp->tsevq_mux))
		return -ERESTARTSYS;

	spin_lock_irqsave(&queue->lock, flags);
	qcnt = queue_cnt(queue);
	if (qcnt) {
		event = queue->buf[queue->head];
		queue->head = (queue->head + 1) % PTP_MAX_TIMESTAMPS;
	}
	spin_unlock_irqrestore(&queue->lock, flags);

	if (!qcnt)
		goto out;

	cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n",
		       event.index, event.t.sec, event.t.nsec);
out:
	mutex_unlock(&ptp->tsevq_mux);
	return cnt;
}

static ssize_t period_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	struct ptp_clock_info *ops = ptp->info;
	struct ptp_clock_request req = { .type = PTP_CLK_REQ_PEROUT };
	int cnt, enable, err = -EINVAL;

	cnt = sscanf(buf, "%u %lld %u %lld %u", &req.perout.index,
		     &req.perout.start.sec, &req.perout.start.nsec,
		     &req.perout.period.sec, &req.perout.period.nsec);
	if (cnt != 5)
		goto out;
	if (req.perout.index >= ops->n_per_out)
		goto out;

	enable = req.perout.period.sec || req.perout.period.nsec;
	err = ops->enable(ops, &req, enable);
	if (err)
		goto out;

	return count;
out:
	return err;
}

static ssize_t pps_enable_store(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	struct ptp_clock_info *ops = ptp->info;
	struct ptp_clock_request req = { .type = PTP_CLK_REQ_PPS };
	int cnt, enable;
	int err = -EINVAL;

	if (!capable(CAP_SYS_TIME))
		return -EPERM;

	cnt = sscanf(buf, "%d", &enable);
	if (cnt != 1)
		goto out;

	err = ops->enable(ops, &req, enable ? 1 : 0);
	if (err)
		goto out;

	return count;
out:
	return err;
}

static int ptp_pin_name2index(struct ptp_clock *ptp, const char *name)
{
	int i;
	for (i = 0; i < ptp->info->n_pins; i++) {
		if (!strcmp(ptp->info->pin_config[i].name, name))
			return i;
	}
	return -1;
}

static ssize_t ptp_pin_show(struct device *dev, struct device_attribute *attr,
			    char *page)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	unsigned int func, chan;
	int index;

	index = ptp_pin_name2index(ptp, attr->attr.name);
	if (index < 0)
		return -EINVAL;

	if (mutex_lock_interruptible(&ptp->pincfg_mux))
		return -ERESTARTSYS;

	func = ptp->info->pin_config[index].func;
	chan = ptp->info->pin_config[index].chan;

	mutex_unlock(&ptp->pincfg_mux);

	return snprintf(page, PAGE_SIZE, "%u %u\n", func, chan);
}

static ssize_t ptp_pin_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct ptp_clock *ptp = dev_get_drvdata(dev);
	unsigned int func, chan;
	int cnt, err, index;

	cnt = sscanf(buf, "%u %u", &func, &chan);
	if (cnt != 2)
		return -EINVAL;

	index = ptp_pin_name2index(ptp, attr->attr.name);
	if (index < 0)
		return -EINVAL;

	if (mutex_lock_interruptible(&ptp->pincfg_mux))
		return -ERESTARTSYS;
	err = ptp_set_pinfunc(ptp, index, func, chan);
	mutex_unlock(&ptp->pincfg_mux);
	if (err)
		return err;

	return count;
}

static DEVICE_ATTR(extts_enable, 0220, NULL, extts_enable_store);
static DEVICE_ATTR(fifo,         0444, extts_fifo_show, NULL);
static DEVICE_ATTR(period,       0220, NULL, period_store);
static DEVICE_ATTR(pps_enable,   0220, NULL, pps_enable_store);

int ptp_cleanup_sysfs(struct ptp_clock *ptp)
{
	struct device *dev = ptp->dev;
	struct ptp_clock_info *info = ptp->info;

	if (info->n_ext_ts) {
		device_remove_file(dev, &dev_attr_extts_enable);
		device_remove_file(dev, &dev_attr_fifo);
	}
	if (info->n_per_out)
		device_remove_file(dev, &dev_attr_period);

	if (info->pps)
		device_remove_file(dev, &dev_attr_pps_enable);

	if (info->n_pins) {
		sysfs_remove_group(&dev->kobj, &ptp->pin_attr_group);
		kfree(ptp->pin_attr);
		kfree(ptp->pin_dev_attr);
	}
	return 0;
}

static int ptp_populate_pins(struct ptp_clock *ptp)
{
	struct device *dev = ptp->dev;
	struct ptp_clock_info *info = ptp->info;
	int err = -ENOMEM, i, n_pins = info->n_pins;

	ptp->pin_dev_attr = kzalloc(n_pins * sizeof(*ptp->pin_dev_attr),
				    GFP_KERNEL);
	if (!ptp->pin_dev_attr)
		goto no_dev_attr;

	ptp->pin_attr = kzalloc((1 + n_pins) * sizeof(struct attribute *),
				GFP_KERNEL);
	if (!ptp->pin_attr)
		goto no_pin_attr;

	for (i = 0; i < n_pins; i++) {
		struct device_attribute *da = &ptp->pin_dev_attr[i];
		sysfs_attr_init(&da->attr);
		da->attr.name = info->pin_config[i].name;
		da->attr.mode = 0644;
		da->show = ptp_pin_show;
		da->store = ptp_pin_store;
		ptp->pin_attr[i] = &da->attr;
	}

	ptp->pin_attr_group.name = "pins";
	ptp->pin_attr_group.attrs = ptp->pin_attr;

	err = sysfs_create_group(&dev->kobj, &ptp->pin_attr_group);
	if (err)
		goto no_group;
	return 0;

no_group:
	kfree(ptp->pin_attr);
no_pin_attr:
	kfree(ptp->pin_dev_attr);
no_dev_attr:
	return err;
}

int ptp_populate_sysfs(struct ptp_clock *ptp)
{
	struct device *dev = ptp->dev;
	struct ptp_clock_info *info = ptp->info;
	int err;

	if (info->n_ext_ts) {
		err = device_create_file(dev, &dev_attr_extts_enable);
		if (err)
			goto out1;
		err = device_create_file(dev, &dev_attr_fifo);
		if (err)
			goto out2;
	}
	if (info->n_per_out) {
		err = device_create_file(dev, &dev_attr_period);
		if (err)
			goto out3;
	}
	if (info->pps) {
		err = device_create_file(dev, &dev_attr_pps_enable);
		if (err)
			goto out4;
	}
	if (info->n_pins) {
		err = ptp_populate_pins(ptp);
		if (err)
			goto out5;
	}
	return 0;
out5:
	if (info->pps)
		device_remove_file(dev, &dev_attr_pps_enable);
out4:
	if (info->n_per_out)
		device_remove_file(dev, &dev_attr_period);
out3:
	if (info->n_ext_ts)
		device_remove_file(dev, &dev_attr_fifo);
out2:
	if (info->n_ext_ts)
		device_remove_file(dev, &dev_attr_extts_enable);
out1:
	return err;
}
Commit	Line	Data
d94ba80e RC	1	/*
	2	* PTP 1588 clock support - sysfs interface.
	3	*
	4	* Copyright (C) 2010 OMICRON electronics GmbH
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20	#include <linux/capability.h>
653104d1	21	#include <linux/slab.h>
d94ba80e RC	22
	23	#include "ptp_private.h"
	24
	25	static ssize_t clock_name_show(struct device *dev,
	26	struct device_attribute attr, char page)
	27	{
	28	struct ptp_clock *ptp = dev_get_drvdata(dev);
	29	return snprintf(page, PAGE_SIZE-1, "%s\n", ptp->info->name);
	30	}
63215705	31	static DEVICE_ATTR_RO(clock_name);
d94ba80e	32
3499116b GKH	33	#define PTP_SHOW_INT(name, var) \
3499116b GKH	34	static ssize_t var##_show(struct device *dev, \
d94ba80e RC	35	struct device_attribute attr, char page) \
	36	{ \
	37	struct ptp_clock *ptp = dev_get_drvdata(dev); \
3499116b GKH	38	return snprintf(page, PAGE_SIZE-1, "%d\n", ptp->info->var); \
	39	} \
	40	static DEVICE_ATTR(name, 0444, var##_show, NULL);
d94ba80e	41
3499116b GKH	42	PTP_SHOW_INT(max_adjustment, max_adj);
	43	PTP_SHOW_INT(n_alarms, n_alarm);
	44	PTP_SHOW_INT(n_external_timestamps, n_ext_ts);
	45	PTP_SHOW_INT(n_periodic_outputs, n_per_out);
653104d1	46	PTP_SHOW_INT(n_programmable_pins, n_pins);
3499116b	47	PTP_SHOW_INT(pps_available, pps);
d94ba80e	48
3499116b GKH	49	static struct attribute *ptp_attrs[] = {
	50	&dev_attr_clock_name.attr,
	51	&dev_attr_max_adjustment.attr,
	52	&dev_attr_n_alarms.attr,
	53	&dev_attr_n_external_timestamps.attr,
	54	&dev_attr_n_periodic_outputs.attr,
653104d1	55	&dev_attr_n_programmable_pins.attr,
3499116b GKH	56	&dev_attr_pps_available.attr,
	57	NULL,
	58	};
d94ba80e	59
3499116b GKH	60	static const struct attribute_group ptp_group = {
3499116b GKH	61	.attrs = ptp_attrs,
d94ba80e RC	62	};
d94ba80e RC	63
3499116b GKH	64	const struct attribute_group *ptp_groups[] = {
	65	&ptp_group,
	66	NULL,
	67	};
	68
	69
d94ba80e RC	70	static ssize_t extts_enable_store(struct device *dev,
	71	struct device_attribute *attr,
	72	const char *buf, size_t count)
	73	{
	74	struct ptp_clock *ptp = dev_get_drvdata(dev);
	75	struct ptp_clock_info *ops = ptp->info;
	76	struct ptp_clock_request req = { .type = PTP_CLK_REQ_EXTTS };
	77	int cnt, enable;
	78	int err = -EINVAL;
	79
	80	cnt = sscanf(buf, "%u %d", &req.extts.index, &enable);
	81	if (cnt != 2)
	82	goto out;
	83	if (req.extts.index >= ops->n_ext_ts)
	84	goto out;
	85
	86	err = ops->enable(ops, &req, enable ? 1 : 0);
	87	if (err)
	88	goto out;
	89
	90	return count;
	91	out:
	92	return err;
	93	}
	94
	95	static ssize_t extts_fifo_show(struct device *dev,
	96	struct device_attribute attr, char page)
	97	{
	98	struct ptp_clock *ptp = dev_get_drvdata(dev);
	99	struct timestamp_event_queue *queue = &ptp->tsevq;
	100	struct ptp_extts_event event;
	101	unsigned long flags;
	102	size_t qcnt;
	103	int cnt = 0;
	104
	105	memset(&event, 0, sizeof(event));
	106
	107	if (mutex_lock_interruptible(&ptp->tsevq_mux))
	108	return -ERESTARTSYS;
	109
	110	spin_lock_irqsave(&queue->lock, flags);
	111	qcnt = queue_cnt(queue);
	112	if (qcnt) {
	113	event = queue->buf[queue->head];
	114	queue->head = (queue->head + 1) % PTP_MAX_TIMESTAMPS;
	115	}
	116	spin_unlock_irqrestore(&queue->lock, flags);
	117
	118	if (!qcnt)
	119	goto out;
	120
	121	cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n",
	122	event.index, event.t.sec, event.t.nsec);
	123	out:
	124	mutex_unlock(&ptp->tsevq_mux);
	125	return cnt;
	126	}
	127
	128	static ssize_t period_store(struct device *dev,
	129	struct device_attribute *attr,
	130	const char *buf, size_t count)
	131	{
	132	struct ptp_clock *ptp = dev_get_drvdata(dev);
	133	struct ptp_clock_info *ops = ptp->info;
134	struct ptp_clock_request req = { .type = PTP_CLK_REQ_PEROUT };
135	int cnt, enable, err = -EINVAL;
136
137	cnt = sscanf(buf, "%u %lld %u %lld %u", &req.perout.index,
138	&req.perout.start.sec, &req.perout.start.nsec,
139	&req.perout.period.sec, &req.perout.period.nsec);
140	if (cnt != 5)
141	goto out;
142	if (req.perout.index >= ops->n_per_out)
143	goto out;
144
145	enable = req.perout.period.sec \|\| req.perout.period.nsec;
146	err = ops->enable(ops, &req, enable);
147	if (err)
148	goto out;
149
150	return count;
151	out:
152	return err;
153	}
154
155	static ssize_t pps_enable_store(struct device *dev,
156	struct device_attribute *attr,
157	const char *buf, size_t count)
158	{
159	struct ptp_clock *ptp = dev_get_drvdata(dev);
160	struct ptp_clock_info *ops = ptp->info;
161	struct ptp_clock_request req = { .type = PTP_CLK_REQ_PPS };
162	int cnt, enable;
163	int err = -EINVAL;
164
165	if (!capable(CAP_SYS_TIME))
166	return -EPERM;
167
168	cnt = sscanf(buf, "%d", &enable);
169	if (cnt != 1)
170	goto out;
171
172	err = ops->enable(ops, &req, enable ? 1 : 0);
173	if (err)
174	goto out;
175
176	return count;
177	out:
178	return err;
179	}
180
653104d1 RC	181	static int ptp_pin_name2index(struct ptp_clock ptp, const char name)
	182	{
	183	int i;
	184	for (i = 0; i < ptp->info->n_pins; i++) {
	185	if (!strcmp(ptp->info->pin_config[i].name, name))
	186	return i;
	187	}
	188	return -1;
	189	}
	190
	191	static ssize_t ptp_pin_show(struct device dev, struct device_attribute attr,
	192	char *page)
	193	{
	194	struct ptp_clock *ptp = dev_get_drvdata(dev);
	195	unsigned int func, chan;
	196	int index;
	197
	198	index = ptp_pin_name2index(ptp, attr->attr.name);
	199	if (index < 0)
	200	return -EINVAL;
	201
	202	if (mutex_lock_interruptible(&ptp->pincfg_mux))
	203	return -ERESTARTSYS;
	204
	205	func = ptp->info->pin_config[index].func;
	206	chan = ptp->info->pin_config[index].chan;
	207
	208	mutex_unlock(&ptp->pincfg_mux);
	209
	210	return snprintf(page, PAGE_SIZE, "%u %u\n", func, chan);
	211	}
	212
	213	static ssize_t ptp_pin_store(struct device dev, struct device_attribute attr,
	214	const char *buf, size_t count)
	215	{
	216	struct ptp_clock *ptp = dev_get_drvdata(dev);
	217	unsigned int func, chan;
	218	int cnt, err, index;
	219
	220	cnt = sscanf(buf, "%u %u", &func, &chan);
	221	if (cnt != 2)
	222	return -EINVAL;
	223
	224	index = ptp_pin_name2index(ptp, attr->attr.name);
	225	if (index < 0)
	226	return -EINVAL;
	227
	228	if (mutex_lock_interruptible(&ptp->pincfg_mux))
	229	return -ERESTARTSYS;
	230	err = ptp_set_pinfunc(ptp, index, func, chan);
	231	mutex_unlock(&ptp->pincfg_mux);
	232	if (err)
	233	return err;
	234
	235	return count;
	236	}
	237
d94ba80e RC	238	static DEVICE_ATTR(extts_enable, 0220, NULL, extts_enable_store);
	239	static DEVICE_ATTR(fifo, 0444, extts_fifo_show, NULL);
	240	static DEVICE_ATTR(period, 0220, NULL, period_store);
	241	static DEVICE_ATTR(pps_enable, 0220, NULL, pps_enable_store);
	242
	243	int ptp_cleanup_sysfs(struct ptp_clock *ptp)
	244	{
	245	struct device *dev = ptp->dev;
	246	struct ptp_clock_info *info = ptp->info;
	247
	248	if (info->n_ext_ts) {
	249	device_remove_file(dev, &dev_attr_extts_enable);
	250	device_remove_file(dev, &dev_attr_fifo);
	251	}
	252	if (info->n_per_out)
	253	device_remove_file(dev, &dev_attr_period);
	254
	255	if (info->pps)
	256	device_remove_file(dev, &dev_attr_pps_enable);
	257
653104d1 RC	258	if (info->n_pins) {
	259	sysfs_remove_group(&dev->kobj, &ptp->pin_attr_group);
	260	kfree(ptp->pin_attr);
	261	kfree(ptp->pin_dev_attr);
	262	}
d94ba80e RC	263	return 0;
	264	}
	265
653104d1 RC	266	static int ptp_populate_pins(struct ptp_clock *ptp)
	267	{
	268	struct device *dev = ptp->dev;
	269	struct ptp_clock_info *info = ptp->info;
	270	int err = -ENOMEM, i, n_pins = info->n_pins;
	271
	272	ptp->pin_dev_attr = kzalloc(n_pins * sizeof(*ptp->pin_dev_attr),
	273	GFP_KERNEL);
	274	if (!ptp->pin_dev_attr)
	275	goto no_dev_attr;
	276
	277	ptp->pin_attr = kzalloc((1 + n_pins) * sizeof(struct attribute *),
	278	GFP_KERNEL);
	279	if (!ptp->pin_attr)
	280	goto no_pin_attr;
	281
	282	for (i = 0; i < n_pins; i++) {
	283	struct device_attribute *da = &ptp->pin_dev_attr[i];
	284	sysfs_attr_init(&da->attr);
	285	da->attr.name = info->pin_config[i].name;
	286	da->attr.mode = 0644;
	287	da->show = ptp_pin_show;
	288	da->store = ptp_pin_store;
	289	ptp->pin_attr[i] = &da->attr;
	290	}
	291
	292	ptp->pin_attr_group.name = "pins";
	293	ptp->pin_attr_group.attrs = ptp->pin_attr;
	294
	295	err = sysfs_create_group(&dev->kobj, &ptp->pin_attr_group);
	296	if (err)
	297	goto no_group;
	298	return 0;
	299
	300	no_group:
	301	kfree(ptp->pin_attr);
	302	no_pin_attr:
	303	kfree(ptp->pin_dev_attr);
	304	no_dev_attr:
	305	return err;
	306	}
	307
d94ba80e RC	308	int ptp_populate_sysfs(struct ptp_clock *ptp)
	309	{
	310	struct device *dev = ptp->dev;
	311	struct ptp_clock_info *info = ptp->info;
	312	int err;
	313
	314	if (info->n_ext_ts) {
	315	err = device_create_file(dev, &dev_attr_extts_enable);
	316	if (err)
	317	goto out1;
	318	err = device_create_file(dev, &dev_attr_fifo);
	319	if (err)
	320	goto out2;
	321	}
	322	if (info->n_per_out) {
	323	err = device_create_file(dev, &dev_attr_period);
	324	if (err)
	325	goto out3;
	326	}
	327	if (info->pps) {
	328	err = device_create_file(dev, &dev_attr_pps_enable);
	329	if (err)
	330	goto out4;
	331	}
653104d1 RC	332	if (info->n_pins) {
	333	err = ptp_populate_pins(ptp);
	334	if (err)
	335	goto out5;
	336	}
d94ba80e	337	return 0;
653104d1 RC	338	out5:
	339	if (info->pps)
	340	device_remove_file(dev, &dev_attr_pps_enable);
d94ba80e RC	341	out4:
	342	if (info->n_per_out)
	343	device_remove_file(dev, &dev_attr_period);
	344	out3:
	345	if (info->n_ext_ts)
	346	device_remove_file(dev, &dev_attr_fifo);
	347	out2:
	348	if (info->n_ext_ts)
	349	device_remove_file(dev, &dev_attr_extts_enable);
	350	out1:
	351	return err;
	352	}