Commit | Line | Data |
---|---|---|
76abbdde HS |
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; | |
459a25af | 29 | struct mutex lock; |
76abbdde HS |
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 | ||
65cdc691 OS |
44 | static ssize_t period_show(struct device *child, |
45 | struct device_attribute *attr, | |
46 | char *buf) | |
76abbdde HS |
47 | { |
48 | const struct pwm_device *pwm = child_to_pwm_device(child); | |
39100cee | 49 | struct pwm_state state; |
76abbdde | 50 | |
39100cee BB |
51 | pwm_get_state(pwm, &state); |
52 | ||
53 | return sprintf(buf, "%u\n", state.period); | |
76abbdde HS |
54 | } |
55 | ||
65cdc691 OS |
56 | static ssize_t period_store(struct device *child, |
57 | struct device_attribute *attr, | |
58 | const char *buf, size_t size) | |
76abbdde | 59 | { |
459a25af BB |
60 | struct pwm_export *export = child_to_pwm_export(child); |
61 | struct pwm_device *pwm = export->pwm; | |
39100cee | 62 | struct pwm_state state; |
76abbdde HS |
63 | unsigned int val; |
64 | int ret; | |
65 | ||
66 | ret = kstrtouint(buf, 0, &val); | |
67 | if (ret) | |
68 | return ret; | |
69 | ||
459a25af | 70 | mutex_lock(&export->lock); |
39100cee BB |
71 | pwm_get_state(pwm, &state); |
72 | state.period = val; | |
73 | ret = pwm_apply_state(pwm, &state); | |
459a25af | 74 | mutex_unlock(&export->lock); |
76abbdde HS |
75 | |
76 | return ret ? : size; | |
77 | } | |
78 | ||
65cdc691 OS |
79 | static ssize_t duty_cycle_show(struct device *child, |
80 | struct device_attribute *attr, | |
81 | char *buf) | |
76abbdde HS |
82 | { |
83 | const struct pwm_device *pwm = child_to_pwm_device(child); | |
39100cee BB |
84 | struct pwm_state state; |
85 | ||
86 | pwm_get_state(pwm, &state); | |
76abbdde | 87 | |
39100cee | 88 | return sprintf(buf, "%u\n", state.duty_cycle); |
76abbdde HS |
89 | } |
90 | ||
65cdc691 OS |
91 | static ssize_t duty_cycle_store(struct device *child, |
92 | struct device_attribute *attr, | |
93 | const char *buf, size_t size) | |
76abbdde | 94 | { |
459a25af BB |
95 | struct pwm_export *export = child_to_pwm_export(child); |
96 | struct pwm_device *pwm = export->pwm; | |
39100cee | 97 | struct pwm_state state; |
76abbdde HS |
98 | unsigned int val; |
99 | int ret; | |
100 | ||
101 | ret = kstrtouint(buf, 0, &val); | |
102 | if (ret) | |
103 | return ret; | |
104 | ||
459a25af | 105 | mutex_lock(&export->lock); |
39100cee BB |
106 | pwm_get_state(pwm, &state); |
107 | state.duty_cycle = val; | |
108 | ret = pwm_apply_state(pwm, &state); | |
459a25af | 109 | mutex_unlock(&export->lock); |
76abbdde HS |
110 | |
111 | return ret ? : size; | |
112 | } | |
113 | ||
65cdc691 OS |
114 | static ssize_t enable_show(struct device *child, |
115 | struct device_attribute *attr, | |
116 | char *buf) | |
76abbdde HS |
117 | { |
118 | const struct pwm_device *pwm = child_to_pwm_device(child); | |
39100cee | 119 | struct pwm_state state; |
76abbdde | 120 | |
39100cee BB |
121 | pwm_get_state(pwm, &state); |
122 | ||
123 | return sprintf(buf, "%d\n", state.enabled); | |
76abbdde HS |
124 | } |
125 | ||
65cdc691 OS |
126 | static ssize_t enable_store(struct device *child, |
127 | struct device_attribute *attr, | |
128 | const char *buf, size_t size) | |
76abbdde | 129 | { |
459a25af BB |
130 | struct pwm_export *export = child_to_pwm_export(child); |
131 | struct pwm_device *pwm = export->pwm; | |
39100cee | 132 | struct pwm_state state; |
76abbdde HS |
133 | int val, ret; |
134 | ||
135 | ret = kstrtoint(buf, 0, &val); | |
136 | if (ret) | |
137 | return ret; | |
138 | ||
459a25af BB |
139 | mutex_lock(&export->lock); |
140 | ||
39100cee BB |
141 | pwm_get_state(pwm, &state); |
142 | ||
76abbdde HS |
143 | switch (val) { |
144 | case 0: | |
39100cee | 145 | state.enabled = false; |
76abbdde HS |
146 | break; |
147 | case 1: | |
39100cee | 148 | state.enabled = true; |
76abbdde HS |
149 | break; |
150 | default: | |
151 | ret = -EINVAL; | |
39100cee | 152 | goto unlock; |
76abbdde HS |
153 | } |
154 | ||
39100cee | 155 | pwm_apply_state(pwm, &state); |
459a25af | 156 | |
39100cee BB |
157 | unlock: |
158 | mutex_unlock(&export->lock); | |
76abbdde HS |
159 | return ret ? : size; |
160 | } | |
161 | ||
65cdc691 OS |
162 | static ssize_t polarity_show(struct device *child, |
163 | struct device_attribute *attr, | |
164 | char *buf) | |
76abbdde HS |
165 | { |
166 | const struct pwm_device *pwm = child_to_pwm_device(child); | |
5a063d87 | 167 | const char *polarity = "unknown"; |
39100cee BB |
168 | struct pwm_state state; |
169 | ||
170 | pwm_get_state(pwm, &state); | |
76abbdde | 171 | |
39100cee | 172 | switch (state.polarity) { |
5a063d87 TR |
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); | |
76abbdde HS |
183 | } |
184 | ||
65cdc691 OS |
185 | static ssize_t polarity_store(struct device *child, |
186 | struct device_attribute *attr, | |
187 | const char *buf, size_t size) | |
76abbdde | 188 | { |
459a25af BB |
189 | struct pwm_export *export = child_to_pwm_export(child); |
190 | struct pwm_device *pwm = export->pwm; | |
76abbdde | 191 | enum pwm_polarity polarity; |
39100cee | 192 | struct pwm_state state; |
76abbdde HS |
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 | ||
459a25af | 202 | mutex_lock(&export->lock); |
39100cee BB |
203 | pwm_get_state(pwm, &state); |
204 | state.polarity = polarity; | |
205 | ret = pwm_apply_state(pwm, &state); | |
459a25af | 206 | mutex_unlock(&export->lock); |
76abbdde HS |
207 | |
208 | return ret ? : size; | |
209 | } | |
210 | ||
65cdc691 OS |
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); | |
76abbdde HS |
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 | }; | |
6ca142ad | 223 | ATTRIBUTE_GROUPS(pwm); |
76abbdde HS |
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; | |
459a25af | 247 | mutex_init(&export->lock); |
76abbdde HS |
248 | |
249 | export->child.release = pwm_export_release; | |
250 | export->child.parent = parent; | |
251 | export->child.devt = MKDEV(0, 0); | |
6ca142ad | 252 | export->child.groups = pwm_groups; |
76abbdde HS |
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 | ||
65cdc691 OS |
289 | static ssize_t export_store(struct device *parent, |
290 | struct device_attribute *attr, | |
291 | const char *buf, size_t len) | |
76abbdde HS |
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 | } | |
65cdc691 | 315 | static DEVICE_ATTR_WO(export); |
76abbdde | 316 | |
65cdc691 OS |
317 | static ssize_t unexport_store(struct device *parent, |
318 | struct device_attribute *attr, | |
319 | const char *buf, size_t len) | |
76abbdde HS |
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 | } | |
65cdc691 | 336 | static DEVICE_ATTR_WO(unexport); |
76abbdde | 337 | |
9da01759 GKH |
338 | static ssize_t npwm_show(struct device *parent, struct device_attribute *attr, |
339 | char *buf) | |
76abbdde HS |
340 | { |
341 | const struct pwm_chip *chip = dev_get_drvdata(parent); | |
342 | ||
343 | return sprintf(buf, "%u\n", chip->npwm); | |
344 | } | |
9da01759 | 345 | static DEVICE_ATTR_RO(npwm); |
76abbdde | 346 | |
9da01759 GKH |
347 | static struct attribute *pwm_chip_attrs[] = { |
348 | &dev_attr_export.attr, | |
349 | &dev_attr_unexport.attr, | |
350 | &dev_attr_npwm.attr, | |
351 | NULL, | |
76abbdde | 352 | }; |
9da01759 | 353 | ATTRIBUTE_GROUPS(pwm_chip); |
76abbdde HS |
354 | |
355 | static struct class pwm_class = { | |
412820dd TR |
356 | .name = "pwm", |
357 | .owner = THIS_MODULE, | |
358 | .dev_groups = pwm_chip_groups, | |
76abbdde HS |
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); |