sysfs.c 8.99 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * A simple sysfs interface for the generic PWM framework
 *
 * Copyright (C) 2013 H Hartley Sweeten <hsweeten@visionengravers.com>
 *
 * Based on previous work by Lars Poeschel <poeschel@lemonage.de>
 *
 * 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, 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.
 */

#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/kdev_t.h>
#include <linux/pwm.h>

struct pwm_export {
	struct device child;
	struct pwm_device *pwm;
29
	struct mutex lock;
30 31 32 33 34 35 36 37 38 39 40 41 42 43
};

static struct pwm_export *child_to_pwm_export(struct device *child)
{
	return container_of(child, struct pwm_export, child);
}

static struct pwm_device *child_to_pwm_device(struct device *child)
{
	struct pwm_export *export = child_to_pwm_export(child);

	return export->pwm;
}

44 45 46
static ssize_t period_show(struct device *child,
			   struct device_attribute *attr,
			   char *buf)
47 48
{
	const struct pwm_device *pwm = child_to_pwm_device(child);
49
	struct pwm_state state;
50

51 52 53
	pwm_get_state(pwm, &state);

	return sprintf(buf, "%u\n", state.period);
54 55
}

56 57 58
static ssize_t period_store(struct device *child,
			    struct device_attribute *attr,
			    const char *buf, size_t size)
59
{
60 61
	struct pwm_export *export = child_to_pwm_export(child);
	struct pwm_device *pwm = export->pwm;
62
	struct pwm_state state;
63 64 65 66 67 68 69
	unsigned int val;
	int ret;

	ret = kstrtouint(buf, 0, &val);
	if (ret)
		return ret;

70
	mutex_lock(&export->lock);
71 72 73
	pwm_get_state(pwm, &state);
	state.period = val;
	ret = pwm_apply_state(pwm, &state);
74
	mutex_unlock(&export->lock);
75 76 77 78

	return ret ? : size;
}

79 80 81
static ssize_t duty_cycle_show(struct device *child,
			       struct device_attribute *attr,
			       char *buf)
82 83
{
	const struct pwm_device *pwm = child_to_pwm_device(child);
84 85 86
	struct pwm_state state;

	pwm_get_state(pwm, &state);
87

88
	return sprintf(buf, "%u\n", state.duty_cycle);
89 90
}

91 92 93
static ssize_t duty_cycle_store(struct device *child,
				struct device_attribute *attr,
				const char *buf, size_t size)
94
{
95 96
	struct pwm_export *export = child_to_pwm_export(child);
	struct pwm_device *pwm = export->pwm;
97
	struct pwm_state state;
98 99 100 101 102 103 104
	unsigned int val;
	int ret;

	ret = kstrtouint(buf, 0, &val);
	if (ret)
		return ret;

105
	mutex_lock(&export->lock);
106 107 108
	pwm_get_state(pwm, &state);
	state.duty_cycle = val;
	ret = pwm_apply_state(pwm, &state);
109
	mutex_unlock(&export->lock);
110 111 112 113

	return ret ? : size;
}

114 115 116
static ssize_t enable_show(struct device *child,
			   struct device_attribute *attr,
			   char *buf)
117 118
{
	const struct pwm_device *pwm = child_to_pwm_device(child);
119
	struct pwm_state state;
120

121 122 123
	pwm_get_state(pwm, &state);

	return sprintf(buf, "%d\n", state.enabled);
124 125
}

126 127 128
static ssize_t enable_store(struct device *child,
			    struct device_attribute *attr,
			    const char *buf, size_t size)
129
{
130 131
	struct pwm_export *export = child_to_pwm_export(child);
	struct pwm_device *pwm = export->pwm;
132
	struct pwm_state state;
133 134 135 136 137 138
	int val, ret;

	ret = kstrtoint(buf, 0, &val);
	if (ret)
		return ret;

139 140
	mutex_lock(&export->lock);

141 142
	pwm_get_state(pwm, &state);

143 144
	switch (val) {
	case 0:
145
		state.enabled = false;
146 147
		break;
	case 1:
148
		state.enabled = true;
149 150 151
		break;
	default:
		ret = -EINVAL;
152
		goto unlock;
153 154
	}

155
	ret = pwm_apply_state(pwm, &state);
156

157 158
unlock:
	mutex_unlock(&export->lock);
159 160 161
	return ret ? : size;
}

162 163 164
static ssize_t polarity_show(struct device *child,
			     struct device_attribute *attr,
			     char *buf)
165 166
{
	const struct pwm_device *pwm = child_to_pwm_device(child);
167
	const char *polarity = "unknown";
168 169 170
	struct pwm_state state;

	pwm_get_state(pwm, &state);
171

172
	switch (state.polarity) {
173 174 175 176 177 178 179 180 181 182
	case PWM_POLARITY_NORMAL:
		polarity = "normal";
		break;

	case PWM_POLARITY_INVERSED:
		polarity = "inversed";
		break;
	}

	return sprintf(buf, "%s\n", polarity);
183 184
}

185 186 187
static ssize_t polarity_store(struct device *child,
			      struct device_attribute *attr,
			      const char *buf, size_t size)
188
{
189 190
	struct pwm_export *export = child_to_pwm_export(child);
	struct pwm_device *pwm = export->pwm;
191
	enum pwm_polarity polarity;
192
	struct pwm_state state;
193 194 195 196 197 198 199 200 201
	int ret;

	if (sysfs_streq(buf, "normal"))
		polarity = PWM_POLARITY_NORMAL;
	else if (sysfs_streq(buf, "inversed"))
		polarity = PWM_POLARITY_INVERSED;
	else
		return -EINVAL;

202
	mutex_lock(&export->lock);
203 204 205
	pwm_get_state(pwm, &state);
	state.polarity = polarity;
	ret = pwm_apply_state(pwm, &state);
206
	mutex_unlock(&export->lock);
207 208 209 210

	return ret ? : size;
}

211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
static ssize_t capture_show(struct device *child,
			    struct device_attribute *attr,
			    char *buf)
{
	struct pwm_device *pwm = child_to_pwm_device(child);
	struct pwm_capture result;
	int ret;

	ret = pwm_capture(pwm, &result, jiffies_to_msecs(HZ));
	if (ret)
		return ret;

	return sprintf(buf, "%u %u\n", result.period, result.duty_cycle);
}

226 227 228 229
static DEVICE_ATTR_RW(period);
static DEVICE_ATTR_RW(duty_cycle);
static DEVICE_ATTR_RW(enable);
static DEVICE_ATTR_RW(polarity);
230
static DEVICE_ATTR_RO(capture);
231 232 233 234 235 236

static struct attribute *pwm_attrs[] = {
	&dev_attr_period.attr,
	&dev_attr_duty_cycle.attr,
	&dev_attr_enable.attr,
	&dev_attr_polarity.attr,
237
	&dev_attr_capture.attr,
238 239
	NULL
};
240
ATTRIBUTE_GROUPS(pwm);
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263

static void pwm_export_release(struct device *child)
{
	struct pwm_export *export = child_to_pwm_export(child);

	kfree(export);
}

static int pwm_export_child(struct device *parent, struct pwm_device *pwm)
{
	struct pwm_export *export;
	int ret;

	if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags))
		return -EBUSY;

	export = kzalloc(sizeof(*export), GFP_KERNEL);
	if (!export) {
		clear_bit(PWMF_EXPORTED, &pwm->flags);
		return -ENOMEM;
	}

	export->pwm = pwm;
264
	mutex_init(&export->lock);
265 266 267 268

	export->child.release = pwm_export_release;
	export->child.parent = parent;
	export->child.devt = MKDEV(0, 0);
269
	export->child.groups = pwm_groups;
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
	dev_set_name(&export->child, "pwm%u", pwm->hwpwm);

	ret = device_register(&export->child);
	if (ret) {
		clear_bit(PWMF_EXPORTED, &pwm->flags);
		kfree(export);
		return ret;
	}

	return 0;
}

static int pwm_unexport_match(struct device *child, void *data)
{
	return child_to_pwm_device(child) == data;
}

static int pwm_unexport_child(struct device *parent, struct pwm_device *pwm)
{
	struct device *child;

	if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags))
		return -ENODEV;

	child = device_find_child(parent, pwm, pwm_unexport_match);
	if (!child)
		return -ENODEV;

	/* for device_find_child() */
	put_device(child);
	device_unregister(child);
	pwm_put(pwm);

	return 0;
}

306 307 308
static ssize_t export_store(struct device *parent,
			    struct device_attribute *attr,
			    const char *buf, size_t len)
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
{
	struct pwm_chip *chip = dev_get_drvdata(parent);
	struct pwm_device *pwm;
	unsigned int hwpwm;
	int ret;

	ret = kstrtouint(buf, 0, &hwpwm);
	if (ret < 0)
		return ret;

	if (hwpwm >= chip->npwm)
		return -ENODEV;

	pwm = pwm_request_from_chip(chip, hwpwm, "sysfs");
	if (IS_ERR(pwm))
		return PTR_ERR(pwm);

	ret = pwm_export_child(parent, pwm);
	if (ret < 0)
		pwm_put(pwm);

	return ret ? : len;
}
332
static DEVICE_ATTR_WO(export);
333

334 335 336
static ssize_t unexport_store(struct device *parent,
			      struct device_attribute *attr,
			      const char *buf, size_t len)
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
{
	struct pwm_chip *chip = dev_get_drvdata(parent);
	unsigned int hwpwm;
	int ret;

	ret = kstrtouint(buf, 0, &hwpwm);
	if (ret < 0)
		return ret;

	if (hwpwm >= chip->npwm)
		return -ENODEV;

	ret = pwm_unexport_child(parent, &chip->pwms[hwpwm]);

	return ret ? : len;
}
353
static DEVICE_ATTR_WO(unexport);
354

355 356
static ssize_t npwm_show(struct device *parent, struct device_attribute *attr,
			 char *buf)
357 358 359 360 361
{
	const struct pwm_chip *chip = dev_get_drvdata(parent);

	return sprintf(buf, "%u\n", chip->npwm);
}
362
static DEVICE_ATTR_RO(npwm);
363

364 365 366 367 368
static struct attribute *pwm_chip_attrs[] = {
	&dev_attr_export.attr,
	&dev_attr_unexport.attr,
	&dev_attr_npwm.attr,
	NULL,
369
};
370
ATTRIBUTE_GROUPS(pwm_chip);
371 372

static struct class pwm_class = {
373 374 375
	.name = "pwm",
	.owner = THIS_MODULE,
	.dev_groups = pwm_chip_groups,
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
};

static int pwmchip_sysfs_match(struct device *parent, const void *data)
{
	return dev_get_drvdata(parent) == data;
}

void pwmchip_sysfs_export(struct pwm_chip *chip)
{
	struct device *parent;

	/*
	 * If device_create() fails the pwm_chip is still usable by
	 * the kernel its just not exported.
	 */
	parent = device_create(&pwm_class, chip->dev, MKDEV(0, 0), chip,
			       "pwmchip%d", chip->base);
	if (IS_ERR(parent)) {
		dev_warn(chip->dev,
			 "device_create failed for pwm_chip sysfs export\n");
	}
}

void pwmchip_sysfs_unexport(struct pwm_chip *chip)
{
	struct device *parent;

	parent = class_find_device(&pwm_class, NULL, chip,
				   pwmchip_sysfs_match);
	if (parent) {
		/* for class_find_device() */
		put_device(parent);
		device_unregister(parent);
	}
}

static int __init pwm_sysfs_init(void)
{
	return class_register(&pwm_class);
}
subsys_initcall(pwm_sysfs_init);