xref: /openbmc/linux/drivers/pwm/sysfs.c (revision 4f205687)
1 /*
2  * A simple sysfs interface for the generic PWM framework
3  *
4  * Copyright (C) 2013 H Hartley Sweeten <hsweeten@visionengravers.com>
5  *
6  * Based on previous work by Lars Poeschel <poeschel@lemonage.de>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  */
18 
19 #include <linux/device.h>
20 #include <linux/mutex.h>
21 #include <linux/err.h>
22 #include <linux/slab.h>
23 #include <linux/kdev_t.h>
24 #include <linux/pwm.h>
25 
26 struct pwm_export {
27 	struct device child;
28 	struct pwm_device *pwm;
29 	struct mutex lock;
30 };
31 
32 static struct pwm_export *child_to_pwm_export(struct device *child)
33 {
34 	return container_of(child, struct pwm_export, child);
35 }
36 
37 static struct pwm_device *child_to_pwm_device(struct device *child)
38 {
39 	struct pwm_export *export = child_to_pwm_export(child);
40 
41 	return export->pwm;
42 }
43 
44 static ssize_t period_show(struct device *child,
45 			   struct device_attribute *attr,
46 			   char *buf)
47 {
48 	const struct pwm_device *pwm = child_to_pwm_device(child);
49 	struct pwm_state state;
50 
51 	pwm_get_state(pwm, &state);
52 
53 	return sprintf(buf, "%u\n", state.period);
54 }
55 
56 static ssize_t period_store(struct device *child,
57 			    struct device_attribute *attr,
58 			    const char *buf, size_t size)
59 {
60 	struct pwm_export *export = child_to_pwm_export(child);
61 	struct pwm_device *pwm = export->pwm;
62 	struct pwm_state state;
63 	unsigned int val;
64 	int ret;
65 
66 	ret = kstrtouint(buf, 0, &val);
67 	if (ret)
68 		return ret;
69 
70 	mutex_lock(&export->lock);
71 	pwm_get_state(pwm, &state);
72 	state.period = val;
73 	ret = pwm_apply_state(pwm, &state);
74 	mutex_unlock(&export->lock);
75 
76 	return ret ? : size;
77 }
78 
79 static ssize_t duty_cycle_show(struct device *child,
80 			       struct device_attribute *attr,
81 			       char *buf)
82 {
83 	const struct pwm_device *pwm = child_to_pwm_device(child);
84 	struct pwm_state state;
85 
86 	pwm_get_state(pwm, &state);
87 
88 	return sprintf(buf, "%u\n", state.duty_cycle);
89 }
90 
91 static ssize_t duty_cycle_store(struct device *child,
92 				struct device_attribute *attr,
93 				const char *buf, size_t size)
94 {
95 	struct pwm_export *export = child_to_pwm_export(child);
96 	struct pwm_device *pwm = export->pwm;
97 	struct pwm_state state;
98 	unsigned int val;
99 	int ret;
100 
101 	ret = kstrtouint(buf, 0, &val);
102 	if (ret)
103 		return ret;
104 
105 	mutex_lock(&export->lock);
106 	pwm_get_state(pwm, &state);
107 	state.duty_cycle = val;
108 	ret = pwm_apply_state(pwm, &state);
109 	mutex_unlock(&export->lock);
110 
111 	return ret ? : size;
112 }
113 
114 static ssize_t enable_show(struct device *child,
115 			   struct device_attribute *attr,
116 			   char *buf)
117 {
118 	const struct pwm_device *pwm = child_to_pwm_device(child);
119 	struct pwm_state state;
120 
121 	pwm_get_state(pwm, &state);
122 
123 	return sprintf(buf, "%d\n", state.enabled);
124 }
125 
126 static ssize_t enable_store(struct device *child,
127 			    struct device_attribute *attr,
128 			    const char *buf, size_t size)
129 {
130 	struct pwm_export *export = child_to_pwm_export(child);
131 	struct pwm_device *pwm = export->pwm;
132 	struct pwm_state state;
133 	int val, ret;
134 
135 	ret = kstrtoint(buf, 0, &val);
136 	if (ret)
137 		return ret;
138 
139 	mutex_lock(&export->lock);
140 
141 	pwm_get_state(pwm, &state);
142 
143 	switch (val) {
144 	case 0:
145 		state.enabled = false;
146 		break;
147 	case 1:
148 		state.enabled = true;
149 		break;
150 	default:
151 		ret = -EINVAL;
152 		goto unlock;
153 	}
154 
155 	ret = pwm_apply_state(pwm, &state);
156 
157 unlock:
158 	mutex_unlock(&export->lock);
159 	return ret ? : size;
160 }
161 
162 static ssize_t polarity_show(struct device *child,
163 			     struct device_attribute *attr,
164 			     char *buf)
165 {
166 	const struct pwm_device *pwm = child_to_pwm_device(child);
167 	const char *polarity = "unknown";
168 	struct pwm_state state;
169 
170 	pwm_get_state(pwm, &state);
171 
172 	switch (state.polarity) {
173 	case PWM_POLARITY_NORMAL:
174 		polarity = "normal";
175 		break;
176 
177 	case PWM_POLARITY_INVERSED:
178 		polarity = "inversed";
179 		break;
180 	}
181 
182 	return sprintf(buf, "%s\n", polarity);
183 }
184 
185 static ssize_t polarity_store(struct device *child,
186 			      struct device_attribute *attr,
187 			      const char *buf, size_t size)
188 {
189 	struct pwm_export *export = child_to_pwm_export(child);
190 	struct pwm_device *pwm = export->pwm;
191 	enum pwm_polarity polarity;
192 	struct pwm_state state;
193 	int ret;
194 
195 	if (sysfs_streq(buf, "normal"))
196 		polarity = PWM_POLARITY_NORMAL;
197 	else if (sysfs_streq(buf, "inversed"))
198 		polarity = PWM_POLARITY_INVERSED;
199 	else
200 		return -EINVAL;
201 
202 	mutex_lock(&export->lock);
203 	pwm_get_state(pwm, &state);
204 	state.polarity = polarity;
205 	ret = pwm_apply_state(pwm, &state);
206 	mutex_unlock(&export->lock);
207 
208 	return ret ? : size;
209 }
210 
211 static DEVICE_ATTR_RW(period);
212 static DEVICE_ATTR_RW(duty_cycle);
213 static DEVICE_ATTR_RW(enable);
214 static DEVICE_ATTR_RW(polarity);
215 
216 static struct attribute *pwm_attrs[] = {
217 	&dev_attr_period.attr,
218 	&dev_attr_duty_cycle.attr,
219 	&dev_attr_enable.attr,
220 	&dev_attr_polarity.attr,
221 	NULL
222 };
223 ATTRIBUTE_GROUPS(pwm);
224 
225 static void pwm_export_release(struct device *child)
226 {
227 	struct pwm_export *export = child_to_pwm_export(child);
228 
229 	kfree(export);
230 }
231 
232 static int pwm_export_child(struct device *parent, struct pwm_device *pwm)
233 {
234 	struct pwm_export *export;
235 	int ret;
236 
237 	if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags))
238 		return -EBUSY;
239 
240 	export = kzalloc(sizeof(*export), GFP_KERNEL);
241 	if (!export) {
242 		clear_bit(PWMF_EXPORTED, &pwm->flags);
243 		return -ENOMEM;
244 	}
245 
246 	export->pwm = pwm;
247 	mutex_init(&export->lock);
248 
249 	export->child.release = pwm_export_release;
250 	export->child.parent = parent;
251 	export->child.devt = MKDEV(0, 0);
252 	export->child.groups = pwm_groups;
253 	dev_set_name(&export->child, "pwm%u", pwm->hwpwm);
254 
255 	ret = device_register(&export->child);
256 	if (ret) {
257 		clear_bit(PWMF_EXPORTED, &pwm->flags);
258 		kfree(export);
259 		return ret;
260 	}
261 
262 	return 0;
263 }
264 
265 static int pwm_unexport_match(struct device *child, void *data)
266 {
267 	return child_to_pwm_device(child) == data;
268 }
269 
270 static int pwm_unexport_child(struct device *parent, struct pwm_device *pwm)
271 {
272 	struct device *child;
273 
274 	if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags))
275 		return -ENODEV;
276 
277 	child = device_find_child(parent, pwm, pwm_unexport_match);
278 	if (!child)
279 		return -ENODEV;
280 
281 	/* for device_find_child() */
282 	put_device(child);
283 	device_unregister(child);
284 	pwm_put(pwm);
285 
286 	return 0;
287 }
288 
289 static ssize_t export_store(struct device *parent,
290 			    struct device_attribute *attr,
291 			    const char *buf, size_t len)
292 {
293 	struct pwm_chip *chip = dev_get_drvdata(parent);
294 	struct pwm_device *pwm;
295 	unsigned int hwpwm;
296 	int ret;
297 
298 	ret = kstrtouint(buf, 0, &hwpwm);
299 	if (ret < 0)
300 		return ret;
301 
302 	if (hwpwm >= chip->npwm)
303 		return -ENODEV;
304 
305 	pwm = pwm_request_from_chip(chip, hwpwm, "sysfs");
306 	if (IS_ERR(pwm))
307 		return PTR_ERR(pwm);
308 
309 	ret = pwm_export_child(parent, pwm);
310 	if (ret < 0)
311 		pwm_put(pwm);
312 
313 	return ret ? : len;
314 }
315 static DEVICE_ATTR_WO(export);
316 
317 static ssize_t unexport_store(struct device *parent,
318 			      struct device_attribute *attr,
319 			      const char *buf, size_t len)
320 {
321 	struct pwm_chip *chip = dev_get_drvdata(parent);
322 	unsigned int hwpwm;
323 	int ret;
324 
325 	ret = kstrtouint(buf, 0, &hwpwm);
326 	if (ret < 0)
327 		return ret;
328 
329 	if (hwpwm >= chip->npwm)
330 		return -ENODEV;
331 
332 	ret = pwm_unexport_child(parent, &chip->pwms[hwpwm]);
333 
334 	return ret ? : len;
335 }
336 static DEVICE_ATTR_WO(unexport);
337 
338 static ssize_t npwm_show(struct device *parent, struct device_attribute *attr,
339 			 char *buf)
340 {
341 	const struct pwm_chip *chip = dev_get_drvdata(parent);
342 
343 	return sprintf(buf, "%u\n", chip->npwm);
344 }
345 static DEVICE_ATTR_RO(npwm);
346 
347 static struct attribute *pwm_chip_attrs[] = {
348 	&dev_attr_export.attr,
349 	&dev_attr_unexport.attr,
350 	&dev_attr_npwm.attr,
351 	NULL,
352 };
353 ATTRIBUTE_GROUPS(pwm_chip);
354 
355 static struct class pwm_class = {
356 	.name = "pwm",
357 	.owner = THIS_MODULE,
358 	.dev_groups = pwm_chip_groups,
359 };
360 
361 static int pwmchip_sysfs_match(struct device *parent, const void *data)
362 {
363 	return dev_get_drvdata(parent) == data;
364 }
365 
366 void pwmchip_sysfs_export(struct pwm_chip *chip)
367 {
368 	struct device *parent;
369 
370 	/*
371 	 * If device_create() fails the pwm_chip is still usable by
372 	 * the kernel its just not exported.
373 	 */
374 	parent = device_create(&pwm_class, chip->dev, MKDEV(0, 0), chip,
375 			       "pwmchip%d", chip->base);
376 	if (IS_ERR(parent)) {
377 		dev_warn(chip->dev,
378 			 "device_create failed for pwm_chip sysfs export\n");
379 	}
380 }
381 
382 void pwmchip_sysfs_unexport(struct pwm_chip *chip)
383 {
384 	struct device *parent;
385 
386 	parent = class_find_device(&pwm_class, NULL, chip,
387 				   pwmchip_sysfs_match);
388 	if (parent) {
389 		/* for class_find_device() */
390 		put_device(parent);
391 		device_unregister(parent);
392 	}
393 }
394 
395 static int __init pwm_sysfs_init(void)
396 {
397 	return class_register(&pwm_class);
398 }
399 subsys_initcall(pwm_sysfs_init);
400