blob: 32221cb0cbe713622c8773822fc1f6e5be91e49d [file] [log] [blame]
Sascha Hauer0c2498f2011-01-28 09:40:40 +01001/*
2 * Generic pwmlib implementation
3 *
4 * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de>
Thierry Redingf051c462011-12-14 11:12:23 +01005 * Copyright (C) 2011-2012 Avionic Design GmbH
Sascha Hauer0c2498f2011-01-28 09:40:40 +01006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; see the file COPYING. If not, write to
19 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22#include <linux/module.h>
23#include <linux/pwm.h>
Thierry Redingf051c462011-12-14 11:12:23 +010024#include <linux/radix-tree.h>
Sascha Hauer0c2498f2011-01-28 09:40:40 +010025#include <linux/list.h>
26#include <linux/mutex.h>
27#include <linux/err.h>
28#include <linux/slab.h>
29#include <linux/device.h>
Thierry Reding62099ab2012-03-26 09:31:48 +020030#include <linux/debugfs.h>
31#include <linux/seq_file.h>
Sascha Hauer0c2498f2011-01-28 09:40:40 +010032
Thierry Redingf051c462011-12-14 11:12:23 +010033#define MAX_PWMS 1024
Sascha Hauer0c2498f2011-01-28 09:40:40 +010034
Philip, Avinash83af2402012-11-21 13:10:44 +053035/* flags in the third cell of the DT PWM specifier */
36#define PWM_SPEC_POLARITY (1 << 0)
37
Thierry Reding8138d2d2012-03-26 08:42:48 +020038static DEFINE_MUTEX(pwm_lookup_lock);
39static LIST_HEAD(pwm_lookup_list);
Sascha Hauer0c2498f2011-01-28 09:40:40 +010040static DEFINE_MUTEX(pwm_lock);
Thierry Redingf051c462011-12-14 11:12:23 +010041static LIST_HEAD(pwm_chips);
42static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
43static RADIX_TREE(pwm_tree, GFP_KERNEL);
Sascha Hauer0c2498f2011-01-28 09:40:40 +010044
Thierry Redingf051c462011-12-14 11:12:23 +010045static struct pwm_device *pwm_to_device(unsigned int pwm)
Sascha Hauer0c2498f2011-01-28 09:40:40 +010046{
Thierry Redingf051c462011-12-14 11:12:23 +010047 return radix_tree_lookup(&pwm_tree, pwm);
48}
Sascha Hauer0c2498f2011-01-28 09:40:40 +010049
Thierry Redingf051c462011-12-14 11:12:23 +010050static int alloc_pwms(int pwm, unsigned int count)
51{
52 unsigned int from = 0;
53 unsigned int start;
54
55 if (pwm >= MAX_PWMS)
56 return -EINVAL;
57
58 if (pwm >= 0)
59 from = pwm;
60
61 start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from,
62 count, 0);
63
64 if (pwm >= 0 && start != pwm)
65 return -EEXIST;
66
67 if (start + count > MAX_PWMS)
68 return -ENOSPC;
69
70 return start;
71}
72
73static void free_pwms(struct pwm_chip *chip)
74{
75 unsigned int i;
76
77 for (i = 0; i < chip->npwm; i++) {
78 struct pwm_device *pwm = &chip->pwms[i];
79 radix_tree_delete(&pwm_tree, pwm->pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +010080 }
81
Thierry Redingf051c462011-12-14 11:12:23 +010082 bitmap_clear(allocated_pwms, chip->base, chip->npwm);
83
84 kfree(chip->pwms);
85 chip->pwms = NULL;
86}
87
Thierry Reding8138d2d2012-03-26 08:42:48 +020088static struct pwm_chip *pwmchip_find_by_name(const char *name)
89{
90 struct pwm_chip *chip;
91
92 if (!name)
93 return NULL;
94
95 mutex_lock(&pwm_lock);
96
97 list_for_each_entry(chip, &pwm_chips, list) {
98 const char *chip_name = dev_name(chip->dev);
99
100 if (chip_name && strcmp(chip_name, name) == 0) {
101 mutex_unlock(&pwm_lock);
102 return chip;
103 }
104 }
105
106 mutex_unlock(&pwm_lock);
107
108 return NULL;
109}
110
Thierry Redingf051c462011-12-14 11:12:23 +0100111static int pwm_device_request(struct pwm_device *pwm, const char *label)
112{
113 int err;
114
115 if (test_bit(PWMF_REQUESTED, &pwm->flags))
116 return -EBUSY;
117
118 if (!try_module_get(pwm->chip->ops->owner))
119 return -ENODEV;
120
121 if (pwm->chip->ops->request) {
122 err = pwm->chip->ops->request(pwm->chip, pwm);
123 if (err) {
124 module_put(pwm->chip->ops->owner);
125 return err;
126 }
127 }
128
129 set_bit(PWMF_REQUESTED, &pwm->flags);
130 pwm->label = label;
131
132 return 0;
133}
134
Philip, Avinash83af2402012-11-21 13:10:44 +0530135struct pwm_device *
136of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args)
137{
138 struct pwm_device *pwm;
139
140 if (pc->of_pwm_n_cells < 3)
141 return ERR_PTR(-EINVAL);
142
143 if (args->args[0] >= pc->npwm)
144 return ERR_PTR(-EINVAL);
145
146 pwm = pwm_request_from_chip(pc, args->args[0], NULL);
147 if (IS_ERR(pwm))
148 return pwm;
149
150 pwm_set_period(pwm, args->args[1]);
151
152 if (args->args[2] & PWM_SPEC_POLARITY)
153 pwm_set_polarity(pwm, PWM_POLARITY_INVERSED);
154 else
155 pwm_set_polarity(pwm, PWM_POLARITY_NORMAL);
156
157 return pwm;
158}
Thierry Reding417328c2012-11-28 15:12:07 +0100159EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
Philip, Avinash83af2402012-11-21 13:10:44 +0530160
Sachin Kamate50d3522012-08-10 16:41:13 +0530161static struct pwm_device *
162of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
Thierry Reding7299ab72011-12-14 11:10:32 +0100163{
164 struct pwm_device *pwm;
165
166 if (pc->of_pwm_n_cells < 2)
167 return ERR_PTR(-EINVAL);
168
169 if (args->args[0] >= pc->npwm)
170 return ERR_PTR(-EINVAL);
171
172 pwm = pwm_request_from_chip(pc, args->args[0], NULL);
173 if (IS_ERR(pwm))
174 return pwm;
175
176 pwm_set_period(pwm, args->args[1]);
177
178 return pwm;
179}
180
Sachin Kamatdfeb86e2012-08-02 12:32:42 +0530181static void of_pwmchip_add(struct pwm_chip *chip)
Thierry Reding7299ab72011-12-14 11:10:32 +0100182{
183 if (!chip->dev || !chip->dev->of_node)
184 return;
185
186 if (!chip->of_xlate) {
187 chip->of_xlate = of_pwm_simple_xlate;
188 chip->of_pwm_n_cells = 2;
189 }
190
191 of_node_get(chip->dev->of_node);
192}
193
Sachin Kamatdfeb86e2012-08-02 12:32:42 +0530194static void of_pwmchip_remove(struct pwm_chip *chip)
Thierry Reding7299ab72011-12-14 11:10:32 +0100195{
196 if (chip->dev && chip->dev->of_node)
197 of_node_put(chip->dev->of_node);
198}
199
Thierry Redingf051c462011-12-14 11:12:23 +0100200/**
201 * pwm_set_chip_data() - set private chip data for a PWM
202 * @pwm: PWM device
203 * @data: pointer to chip-specific data
204 */
205int pwm_set_chip_data(struct pwm_device *pwm, void *data)
206{
207 if (!pwm)
208 return -EINVAL;
209
210 pwm->chip_data = data;
211
212 return 0;
213}
Thierry Reding928c4472013-01-30 09:22:24 +0100214EXPORT_SYMBOL_GPL(pwm_set_chip_data);
Thierry Redingf051c462011-12-14 11:12:23 +0100215
216/**
217 * pwm_get_chip_data() - get private chip data for a PWM
218 * @pwm: PWM device
219 */
220void *pwm_get_chip_data(struct pwm_device *pwm)
221{
222 return pwm ? pwm->chip_data : NULL;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100223}
Thierry Reding928c4472013-01-30 09:22:24 +0100224EXPORT_SYMBOL_GPL(pwm_get_chip_data);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100225
226/**
227 * pwmchip_add() - register a new PWM chip
228 * @chip: the PWM chip to add
Thierry Redingf051c462011-12-14 11:12:23 +0100229 *
230 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
231 * will be used.
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100232 */
233int pwmchip_add(struct pwm_chip *chip)
234{
235 struct pwm_device *pwm;
Thierry Redingf051c462011-12-14 11:12:23 +0100236 unsigned int i;
237 int ret;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100238
Thierry Redingf051c462011-12-14 11:12:23 +0100239 if (!chip || !chip->dev || !chip->ops || !chip->ops->config ||
240 !chip->ops->enable || !chip->ops->disable)
241 return -EINVAL;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100242
243 mutex_lock(&pwm_lock);
244
Thierry Redingf051c462011-12-14 11:12:23 +0100245 ret = alloc_pwms(chip->base, chip->npwm);
246 if (ret < 0)
247 goto out;
248
249 chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL);
250 if (!chip->pwms) {
251 ret = -ENOMEM;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100252 goto out;
253 }
254
Thierry Redingf051c462011-12-14 11:12:23 +0100255 chip->base = ret;
256
257 for (i = 0; i < chip->npwm; i++) {
258 pwm = &chip->pwms[i];
259
260 pwm->chip = chip;
261 pwm->pwm = chip->base + i;
262 pwm->hwpwm = i;
263
264 radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
265 }
266
267 bitmap_set(allocated_pwms, chip->base, chip->npwm);
268
269 INIT_LIST_HEAD(&chip->list);
270 list_add(&chip->list, &pwm_chips);
271
272 ret = 0;
273
Thierry Reding7299ab72011-12-14 11:10:32 +0100274 if (IS_ENABLED(CONFIG_OF))
275 of_pwmchip_add(chip);
276
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100277out:
278 mutex_unlock(&pwm_lock);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100279 return ret;
280}
281EXPORT_SYMBOL_GPL(pwmchip_add);
282
283/**
284 * pwmchip_remove() - remove a PWM chip
285 * @chip: the PWM chip to remove
286 *
287 * Removes a PWM chip. This function may return busy if the PWM chip provides
288 * a PWM device that is still requested.
289 */
290int pwmchip_remove(struct pwm_chip *chip)
291{
Thierry Redingf051c462011-12-14 11:12:23 +0100292 unsigned int i;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100293 int ret = 0;
294
295 mutex_lock(&pwm_lock);
296
Thierry Redingf051c462011-12-14 11:12:23 +0100297 for (i = 0; i < chip->npwm; i++) {
298 struct pwm_device *pwm = &chip->pwms[i];
299
300 if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
301 ret = -EBUSY;
302 goto out;
303 }
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100304 }
305
Thierry Redingf051c462011-12-14 11:12:23 +0100306 list_del_init(&chip->list);
Thierry Reding7299ab72011-12-14 11:10:32 +0100307
308 if (IS_ENABLED(CONFIG_OF))
309 of_pwmchip_remove(chip);
310
Thierry Redingf051c462011-12-14 11:12:23 +0100311 free_pwms(chip);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100312
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100313out:
314 mutex_unlock(&pwm_lock);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100315 return ret;
316}
317EXPORT_SYMBOL_GPL(pwmchip_remove);
318
319/**
320 * pwm_request() - request a PWM device
321 * @pwm_id: global PWM device index
322 * @label: PWM device label
Thierry Reding8138d2d2012-03-26 08:42:48 +0200323 *
324 * This function is deprecated, use pwm_get() instead.
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100325 */
Thierry Redingf051c462011-12-14 11:12:23 +0100326struct pwm_device *pwm_request(int pwm, const char *label)
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100327{
Thierry Redingf051c462011-12-14 11:12:23 +0100328 struct pwm_device *dev;
329 int err;
330
331 if (pwm < 0 || pwm >= MAX_PWMS)
332 return ERR_PTR(-EINVAL);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100333
334 mutex_lock(&pwm_lock);
335
Thierry Redingf051c462011-12-14 11:12:23 +0100336 dev = pwm_to_device(pwm);
337 if (!dev) {
338 dev = ERR_PTR(-EPROBE_DEFER);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100339 goto out;
340 }
341
Thierry Redingf051c462011-12-14 11:12:23 +0100342 err = pwm_device_request(dev, label);
343 if (err < 0)
344 dev = ERR_PTR(err);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100345
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100346out:
347 mutex_unlock(&pwm_lock);
348
Thierry Redingf051c462011-12-14 11:12:23 +0100349 return dev;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100350}
351EXPORT_SYMBOL_GPL(pwm_request);
352
353/**
Thierry Redingf051c462011-12-14 11:12:23 +0100354 * pwm_request_from_chip() - request a PWM device relative to a PWM chip
355 * @chip: PWM chip
356 * @index: per-chip index of the PWM to request
357 * @label: a literal description string of this PWM
358 *
359 * Returns the PWM at the given index of the given PWM chip. A negative error
360 * code is returned if the index is not valid for the specified PWM chip or
361 * if the PWM device cannot be requested.
362 */
363struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
364 unsigned int index,
365 const char *label)
366{
367 struct pwm_device *pwm;
368 int err;
369
370 if (!chip || index >= chip->npwm)
371 return ERR_PTR(-EINVAL);
372
373 mutex_lock(&pwm_lock);
374 pwm = &chip->pwms[index];
375
376 err = pwm_device_request(pwm, label);
377 if (err < 0)
378 pwm = ERR_PTR(err);
379
380 mutex_unlock(&pwm_lock);
381 return pwm;
382}
383EXPORT_SYMBOL_GPL(pwm_request_from_chip);
384
385/**
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100386 * pwm_free() - free a PWM device
387 * @pwm: PWM device
Thierry Reding8138d2d2012-03-26 08:42:48 +0200388 *
389 * This function is deprecated, use pwm_put() instead.
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100390 */
391void pwm_free(struct pwm_device *pwm)
392{
Thierry Reding8138d2d2012-03-26 08:42:48 +0200393 pwm_put(pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100394}
395EXPORT_SYMBOL_GPL(pwm_free);
396
397/**
398 * pwm_config() - change a PWM device configuration
399 * @pwm: PWM device
400 * @duty_ns: "on" time (in nanoseconds)
401 * @period_ns: duration (in nanoseconds) of one cycle
402 */
403int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
404{
Thierry Redingc2d476a2012-09-02 22:13:40 +0200405 if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns)
Thierry Redingf051c462011-12-14 11:12:23 +0100406 return -EINVAL;
407
408 return pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100409}
410EXPORT_SYMBOL_GPL(pwm_config);
411
412/**
Philip, Avinash0aa08692012-07-24 19:35:32 +0530413 * pwm_set_polarity() - configure the polarity of a PWM signal
414 * @pwm: PWM device
415 * @polarity: new polarity of the PWM signal
416 *
417 * Note that the polarity cannot be configured while the PWM device is enabled
418 */
419int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity)
420{
421 if (!pwm || !pwm->chip->ops)
422 return -EINVAL;
423
424 if (!pwm->chip->ops->set_polarity)
425 return -ENOSYS;
426
427 if (test_bit(PWMF_ENABLED, &pwm->flags))
428 return -EBUSY;
429
430 return pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity);
431}
432EXPORT_SYMBOL_GPL(pwm_set_polarity);
433
434/**
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100435 * pwm_enable() - start a PWM output toggling
436 * @pwm: PWM device
437 */
438int pwm_enable(struct pwm_device *pwm)
439{
Thierry Redingf051c462011-12-14 11:12:23 +0100440 if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags))
441 return pwm->chip->ops->enable(pwm->chip, pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100442
Thierry Redingf051c462011-12-14 11:12:23 +0100443 return pwm ? 0 : -EINVAL;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100444}
445EXPORT_SYMBOL_GPL(pwm_enable);
446
447/**
448 * pwm_disable() - stop a PWM output toggling
449 * @pwm: PWM device
450 */
451void pwm_disable(struct pwm_device *pwm)
452{
Thierry Redingf051c462011-12-14 11:12:23 +0100453 if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags))
454 pwm->chip->ops->disable(pwm->chip, pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100455}
456EXPORT_SYMBOL_GPL(pwm_disable);
Thierry Reding62099ab2012-03-26 09:31:48 +0200457
Thierry Reding7299ab72011-12-14 11:10:32 +0100458static struct pwm_chip *of_node_to_pwmchip(struct device_node *np)
459{
460 struct pwm_chip *chip;
461
462 mutex_lock(&pwm_lock);
463
464 list_for_each_entry(chip, &pwm_chips, list)
465 if (chip->dev && chip->dev->of_node == np) {
466 mutex_unlock(&pwm_lock);
467 return chip;
468 }
469
470 mutex_unlock(&pwm_lock);
471
472 return ERR_PTR(-EPROBE_DEFER);
473}
474
475/**
Peter Ujfalusi8eb96122012-12-21 01:43:58 -0800476 * of_pwm_get() - request a PWM via the PWM framework
Thierry Reding7299ab72011-12-14 11:10:32 +0100477 * @np: device node to get the PWM from
478 * @con_id: consumer name
479 *
480 * Returns the PWM device parsed from the phandle and index specified in the
481 * "pwms" property of a device tree node or a negative error-code on failure.
482 * Values parsed from the device tree are stored in the returned PWM device
483 * object.
484 *
485 * If con_id is NULL, the first PWM device listed in the "pwms" property will
486 * be requested. Otherwise the "pwm-names" property is used to do a reverse
487 * lookup of the PWM index. This also means that the "pwm-names" property
488 * becomes mandatory for devices that look up the PWM device via the con_id
489 * parameter.
490 */
Peter Ujfalusi8eb96122012-12-21 01:43:58 -0800491struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id)
Thierry Reding7299ab72011-12-14 11:10:32 +0100492{
493 struct pwm_device *pwm = NULL;
494 struct of_phandle_args args;
495 struct pwm_chip *pc;
496 int index = 0;
497 int err;
498
499 if (con_id) {
500 index = of_property_match_string(np, "pwm-names", con_id);
501 if (index < 0)
502 return ERR_PTR(index);
503 }
504
505 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
506 &args);
507 if (err) {
508 pr_debug("%s(): can't parse \"pwms\" property\n", __func__);
509 return ERR_PTR(err);
510 }
511
512 pc = of_node_to_pwmchip(args.np);
513 if (IS_ERR(pc)) {
514 pr_debug("%s(): PWM chip not found\n", __func__);
515 pwm = ERR_CAST(pc);
516 goto put;
517 }
518
519 if (args.args_count != pc->of_pwm_n_cells) {
520 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name,
521 args.np->full_name);
522 pwm = ERR_PTR(-EINVAL);
523 goto put;
524 }
525
526 pwm = pc->of_xlate(pc, &args);
527 if (IS_ERR(pwm))
528 goto put;
529
530 /*
531 * If a consumer name was not given, try to look it up from the
532 * "pwm-names" property if it exists. Otherwise use the name of
533 * the user device node.
534 */
535 if (!con_id) {
536 err = of_property_read_string_index(np, "pwm-names", index,
537 &con_id);
538 if (err < 0)
539 con_id = np->name;
540 }
541
542 pwm->label = con_id;
543
544put:
545 of_node_put(args.np);
546
547 return pwm;
548}
Peter Ujfalusi8eb96122012-12-21 01:43:58 -0800549EXPORT_SYMBOL_GPL(of_pwm_get);
Thierry Reding7299ab72011-12-14 11:10:32 +0100550
Thierry Reding8138d2d2012-03-26 08:42:48 +0200551/**
552 * pwm_add_table() - register PWM device consumers
553 * @table: array of consumers to register
554 * @num: number of consumers in table
555 */
556void __init pwm_add_table(struct pwm_lookup *table, size_t num)
557{
558 mutex_lock(&pwm_lookup_lock);
559
560 while (num--) {
561 list_add_tail(&table->list, &pwm_lookup_list);
562 table++;
563 }
564
565 mutex_unlock(&pwm_lookup_lock);
566}
567
568/**
569 * pwm_get() - look up and request a PWM device
570 * @dev: device for PWM consumer
571 * @con_id: consumer name
572 *
Thierry Reding7299ab72011-12-14 11:10:32 +0100573 * Lookup is first attempted using DT. If the device was not instantiated from
574 * a device tree, a PWM chip and a relative index is looked up via a table
575 * supplied by board setup code (see pwm_add_table()).
Thierry Reding8138d2d2012-03-26 08:42:48 +0200576 *
577 * Once a PWM chip has been found the specified PWM device will be requested
578 * and is ready to be used.
579 */
580struct pwm_device *pwm_get(struct device *dev, const char *con_id)
581{
582 struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
Sachin Kamate50d3522012-08-10 16:41:13 +0530583 const char *dev_id = dev ? dev_name(dev) : NULL;
Thierry Reding8138d2d2012-03-26 08:42:48 +0200584 struct pwm_chip *chip = NULL;
Thierry Redingd295b122012-07-11 08:05:05 +0200585 unsigned int index = 0;
Thierry Reding8138d2d2012-03-26 08:42:48 +0200586 unsigned int best = 0;
587 struct pwm_lookup *p;
Thierry Reding8138d2d2012-03-26 08:42:48 +0200588 unsigned int match;
589
Thierry Reding7299ab72011-12-14 11:10:32 +0100590 /* look up via DT first */
591 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
Peter Ujfalusi8eb96122012-12-21 01:43:58 -0800592 return of_pwm_get(dev->of_node, con_id);
Thierry Reding7299ab72011-12-14 11:10:32 +0100593
Thierry Reding8138d2d2012-03-26 08:42:48 +0200594 /*
595 * We look up the provider in the static table typically provided by
596 * board setup code. We first try to lookup the consumer device by
597 * name. If the consumer device was passed in as NULL or if no match
598 * was found, we try to find the consumer by directly looking it up
599 * by name.
600 *
601 * If a match is found, the provider PWM chip is looked up by name
602 * and a PWM device is requested using the PWM device per-chip index.
603 *
604 * The lookup algorithm was shamelessly taken from the clock
605 * framework:
606 *
607 * We do slightly fuzzy matching here:
608 * An entry with a NULL ID is assumed to be a wildcard.
609 * If an entry has a device ID, it must match
610 * If an entry has a connection ID, it must match
611 * Then we take the most specific entry - with the following order
612 * of precedence: dev+con > dev only > con only.
613 */
614 mutex_lock(&pwm_lookup_lock);
615
616 list_for_each_entry(p, &pwm_lookup_list, list) {
617 match = 0;
618
619 if (p->dev_id) {
620 if (!dev_id || strcmp(p->dev_id, dev_id))
621 continue;
622
623 match += 2;
624 }
625
626 if (p->con_id) {
627 if (!con_id || strcmp(p->con_id, con_id))
628 continue;
629
630 match += 1;
631 }
632
633 if (match > best) {
634 chip = pwmchip_find_by_name(p->provider);
635 index = p->index;
636
637 if (match != 3)
638 best = match;
639 else
640 break;
641 }
642 }
643
644 if (chip)
645 pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id);
646
647 mutex_unlock(&pwm_lookup_lock);
648
649 return pwm;
650}
651EXPORT_SYMBOL_GPL(pwm_get);
652
653/**
654 * pwm_put() - release a PWM device
655 * @pwm: PWM device
656 */
657void pwm_put(struct pwm_device *pwm)
658{
659 if (!pwm)
660 return;
661
662 mutex_lock(&pwm_lock);
663
664 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
Sachin Kamate50d3522012-08-10 16:41:13 +0530665 pr_warn("PWM device already freed\n");
Thierry Reding8138d2d2012-03-26 08:42:48 +0200666 goto out;
667 }
668
669 if (pwm->chip->ops->free)
670 pwm->chip->ops->free(pwm->chip, pwm);
671
672 pwm->label = NULL;
673
674 module_put(pwm->chip->ops->owner);
675out:
676 mutex_unlock(&pwm_lock);
677}
678EXPORT_SYMBOL_GPL(pwm_put);
679
Alexandre Courbot63543162012-08-01 19:20:58 +0900680static void devm_pwm_release(struct device *dev, void *res)
681{
682 pwm_put(*(struct pwm_device **)res);
683}
684
685/**
686 * devm_pwm_get() - resource managed pwm_get()
687 * @dev: device for PWM consumer
688 * @con_id: consumer name
689 *
690 * This function performs like pwm_get() but the acquired PWM device will
691 * automatically be released on driver detach.
692 */
693struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
694{
695 struct pwm_device **ptr, *pwm;
696
697 ptr = devres_alloc(devm_pwm_release, sizeof(**ptr), GFP_KERNEL);
698 if (!ptr)
699 return ERR_PTR(-ENOMEM);
700
701 pwm = pwm_get(dev, con_id);
702 if (!IS_ERR(pwm)) {
703 *ptr = pwm;
704 devres_add(dev, ptr);
705 } else {
706 devres_free(ptr);
707 }
708
709 return pwm;
710}
711EXPORT_SYMBOL_GPL(devm_pwm_get);
712
Peter Ujfalusi261a5ed2012-12-21 01:43:59 -0800713/**
714 * devm_of_pwm_get() - resource managed of_pwm_get()
715 * @dev: device for PWM consumer
716 * @np: device node to get the PWM from
717 * @con_id: consumer name
718 *
719 * This function performs like of_pwm_get() but the acquired PWM device will
720 * automatically be released on driver detach.
721 */
722struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
723 const char *con_id)
724{
725 struct pwm_device **ptr, *pwm;
726
727 ptr = devres_alloc(devm_pwm_release, sizeof(**ptr), GFP_KERNEL);
728 if (!ptr)
729 return ERR_PTR(-ENOMEM);
730
731 pwm = of_pwm_get(np, con_id);
732 if (!IS_ERR(pwm)) {
733 *ptr = pwm;
734 devres_add(dev, ptr);
735 } else {
736 devres_free(ptr);
737 }
738
739 return pwm;
740}
741EXPORT_SYMBOL_GPL(devm_of_pwm_get);
742
Alexandre Courbot63543162012-08-01 19:20:58 +0900743static int devm_pwm_match(struct device *dev, void *res, void *data)
744{
745 struct pwm_device **p = res;
746
747 if (WARN_ON(!p || !*p))
748 return 0;
749
750 return *p == data;
751}
752
753/**
754 * devm_pwm_put() - resource managed pwm_put()
755 * @dev: device for PWM consumer
756 * @pwm: PWM device
757 *
758 * Release a PWM previously allocated using devm_pwm_get(). Calling this
759 * function is usually not needed because devm-allocated resources are
760 * automatically released on driver detach.
761 */
762void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
763{
764 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm));
765}
766EXPORT_SYMBOL_GPL(devm_pwm_put);
767
Florian Vaussard6e69ab12013-01-28 15:00:57 +0100768/**
769 * pwm_can_sleep() - report whether PWM access will sleep
770 * @pwm: PWM device
771 *
772 * It returns true if accessing the PWM can sleep, false otherwise.
773 */
774bool pwm_can_sleep(struct pwm_device *pwm)
775{
776 return pwm->chip->can_sleep;
777}
778EXPORT_SYMBOL_GPL(pwm_can_sleep);
779
Thierry Reding62099ab2012-03-26 09:31:48 +0200780#ifdef CONFIG_DEBUG_FS
781static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
782{
783 unsigned int i;
784
785 for (i = 0; i < chip->npwm; i++) {
786 struct pwm_device *pwm = &chip->pwms[i];
787
788 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
789
790 if (test_bit(PWMF_REQUESTED, &pwm->flags))
791 seq_printf(s, " requested");
792
793 if (test_bit(PWMF_ENABLED, &pwm->flags))
794 seq_printf(s, " enabled");
795
796 seq_printf(s, "\n");
797 }
798}
799
800static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
801{
802 mutex_lock(&pwm_lock);
803 s->private = "";
804
805 return seq_list_start(&pwm_chips, *pos);
806}
807
808static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
809{
810 s->private = "\n";
811
812 return seq_list_next(v, &pwm_chips, pos);
813}
814
815static void pwm_seq_stop(struct seq_file *s, void *v)
816{
817 mutex_unlock(&pwm_lock);
818}
819
820static int pwm_seq_show(struct seq_file *s, void *v)
821{
822 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
823
824 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
825 chip->dev->bus ? chip->dev->bus->name : "no-bus",
826 dev_name(chip->dev), chip->npwm,
827 (chip->npwm != 1) ? "s" : "");
828
829 if (chip->ops->dbg_show)
830 chip->ops->dbg_show(chip, s);
831 else
832 pwm_dbg_show(chip, s);
833
834 return 0;
835}
836
837static const struct seq_operations pwm_seq_ops = {
838 .start = pwm_seq_start,
839 .next = pwm_seq_next,
840 .stop = pwm_seq_stop,
841 .show = pwm_seq_show,
842};
843
844static int pwm_seq_open(struct inode *inode, struct file *file)
845{
846 return seq_open(file, &pwm_seq_ops);
847}
848
849static const struct file_operations pwm_debugfs_ops = {
850 .owner = THIS_MODULE,
851 .open = pwm_seq_open,
852 .read = seq_read,
853 .llseek = seq_lseek,
854 .release = seq_release,
855};
856
857static int __init pwm_debugfs_init(void)
858{
859 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL,
860 &pwm_debugfs_ops);
861
862 return 0;
863}
864
865subsys_initcall(pwm_debugfs_init);
866#endif /* CONFIG_DEBUG_FS */