Merge tag 'for-3.9-rc1' of git://gitorious.org/linux-pwm/linux-pwm
[~shefty/rdma-dev.git] / drivers / pwm / core.c
1 /*
2  * Generic pwmlib implementation
3  *
4  * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de>
5  * Copyright (C) 2011-2012 Avionic Design GmbH
6  *
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>
24 #include <linux/radix-tree.h>
25 #include <linux/list.h>
26 #include <linux/mutex.h>
27 #include <linux/err.h>
28 #include <linux/slab.h>
29 #include <linux/device.h>
30 #include <linux/debugfs.h>
31 #include <linux/seq_file.h>
32
33 #define MAX_PWMS 1024
34
35 /* flags in the third cell of the DT PWM specifier */
36 #define PWM_SPEC_POLARITY       (1 << 0)
37
38 static DEFINE_MUTEX(pwm_lookup_lock);
39 static LIST_HEAD(pwm_lookup_list);
40 static DEFINE_MUTEX(pwm_lock);
41 static LIST_HEAD(pwm_chips);
42 static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
43 static RADIX_TREE(pwm_tree, GFP_KERNEL);
44
45 static struct pwm_device *pwm_to_device(unsigned int pwm)
46 {
47         return radix_tree_lookup(&pwm_tree, pwm);
48 }
49
50 static 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
73 static 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);
80         }
81
82         bitmap_clear(allocated_pwms, chip->base, chip->npwm);
83
84         kfree(chip->pwms);
85         chip->pwms = NULL;
86 }
87
88 static 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
111 static 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
135 struct pwm_device *
136 of_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 }
159 EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
160
161 static struct pwm_device *
162 of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
163 {
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
181 static void of_pwmchip_add(struct pwm_chip *chip)
182 {
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
194 static void of_pwmchip_remove(struct pwm_chip *chip)
195 {
196         if (chip->dev && chip->dev->of_node)
197                 of_node_put(chip->dev->of_node);
198 }
199
200 /**
201  * pwm_set_chip_data() - set private chip data for a PWM
202  * @pwm: PWM device
203  * @data: pointer to chip-specific data
204  */
205 int 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 }
214 EXPORT_SYMBOL_GPL(pwm_set_chip_data);
215
216 /**
217  * pwm_get_chip_data() - get private chip data for a PWM
218  * @pwm: PWM device
219  */
220 void *pwm_get_chip_data(struct pwm_device *pwm)
221 {
222         return pwm ? pwm->chip_data : NULL;
223 }
224 EXPORT_SYMBOL_GPL(pwm_get_chip_data);
225
226 /**
227  * pwmchip_add() - register a new PWM chip
228  * @chip: the PWM chip to add
229  *
230  * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
231  * will be used.
232  */
233 int pwmchip_add(struct pwm_chip *chip)
234 {
235         struct pwm_device *pwm;
236         unsigned int i;
237         int ret;
238
239         if (!chip || !chip->dev || !chip->ops || !chip->ops->config ||
240             !chip->ops->enable || !chip->ops->disable)
241                 return -EINVAL;
242
243         mutex_lock(&pwm_lock);
244
245         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;
252                 goto out;
253         }
254
255         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
274         if (IS_ENABLED(CONFIG_OF))
275                 of_pwmchip_add(chip);
276
277 out:
278         mutex_unlock(&pwm_lock);
279         return ret;
280 }
281 EXPORT_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  */
290 int pwmchip_remove(struct pwm_chip *chip)
291 {
292         unsigned int i;
293         int ret = 0;
294
295         mutex_lock(&pwm_lock);
296
297         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                 }
304         }
305
306         list_del_init(&chip->list);
307
308         if (IS_ENABLED(CONFIG_OF))
309                 of_pwmchip_remove(chip);
310
311         free_pwms(chip);
312
313 out:
314         mutex_unlock(&pwm_lock);
315         return ret;
316 }
317 EXPORT_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
323  *
324  * This function is deprecated, use pwm_get() instead.
325  */
326 struct pwm_device *pwm_request(int pwm, const char *label)
327 {
328         struct pwm_device *dev;
329         int err;
330
331         if (pwm < 0 || pwm >= MAX_PWMS)
332                 return ERR_PTR(-EINVAL);
333
334         mutex_lock(&pwm_lock);
335
336         dev = pwm_to_device(pwm);
337         if (!dev) {
338                 dev = ERR_PTR(-EPROBE_DEFER);
339                 goto out;
340         }
341
342         err = pwm_device_request(dev, label);
343         if (err < 0)
344                 dev = ERR_PTR(err);
345
346 out:
347         mutex_unlock(&pwm_lock);
348
349         return dev;
350 }
351 EXPORT_SYMBOL_GPL(pwm_request);
352
353 /**
354  * 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  */
363 struct 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 }
383 EXPORT_SYMBOL_GPL(pwm_request_from_chip);
384
385 /**
386  * pwm_free() - free a PWM device
387  * @pwm: PWM device
388  *
389  * This function is deprecated, use pwm_put() instead.
390  */
391 void pwm_free(struct pwm_device *pwm)
392 {
393         pwm_put(pwm);
394 }
395 EXPORT_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  */
403 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
404 {
405         if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns)
406                 return -EINVAL;
407
408         return pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns);
409 }
410 EXPORT_SYMBOL_GPL(pwm_config);
411
412 /**
413  * 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  */
419 int 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 }
432 EXPORT_SYMBOL_GPL(pwm_set_polarity);
433
434 /**
435  * pwm_enable() - start a PWM output toggling
436  * @pwm: PWM device
437  */
438 int pwm_enable(struct pwm_device *pwm)
439 {
440         if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags))
441                 return pwm->chip->ops->enable(pwm->chip, pwm);
442
443         return pwm ? 0 : -EINVAL;
444 }
445 EXPORT_SYMBOL_GPL(pwm_enable);
446
447 /**
448  * pwm_disable() - stop a PWM output toggling
449  * @pwm: PWM device
450  */
451 void pwm_disable(struct pwm_device *pwm)
452 {
453         if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags))
454                 pwm->chip->ops->disable(pwm->chip, pwm);
455 }
456 EXPORT_SYMBOL_GPL(pwm_disable);
457
458 static 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 /**
476  * of_pwm_get() - request a PWM via the PWM framework
477  * @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  */
491 struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id)
492 {
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
544 put:
545         of_node_put(args.np);
546
547         return pwm;
548 }
549 EXPORT_SYMBOL_GPL(of_pwm_get);
550
551 /**
552  * pwm_add_table() - register PWM device consumers
553  * @table: array of consumers to register
554  * @num: number of consumers in table
555  */
556 void __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  *
573  * 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()).
576  *
577  * Once a PWM chip has been found the specified PWM device will be requested
578  * and is ready to be used.
579  */
580 struct pwm_device *pwm_get(struct device *dev, const char *con_id)
581 {
582         struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
583         const char *dev_id = dev ? dev_name(dev) : NULL;
584         struct pwm_chip *chip = NULL;
585         unsigned int index = 0;
586         unsigned int best = 0;
587         struct pwm_lookup *p;
588         unsigned int match;
589
590         /* look up via DT first */
591         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
592                 return of_pwm_get(dev->of_node, con_id);
593
594         /*
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 }
651 EXPORT_SYMBOL_GPL(pwm_get);
652
653 /**
654  * pwm_put() - release a PWM device
655  * @pwm: PWM device
656  */
657 void 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)) {
665                 pr_warn("PWM device already freed\n");
666                 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);
675 out:
676         mutex_unlock(&pwm_lock);
677 }
678 EXPORT_SYMBOL_GPL(pwm_put);
679
680 static 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  */
693 struct 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 }
711 EXPORT_SYMBOL_GPL(devm_pwm_get);
712
713 /**
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  */
722 struct 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 }
741 EXPORT_SYMBOL_GPL(devm_of_pwm_get);
742
743 static 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  */
762 void 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 }
766 EXPORT_SYMBOL_GPL(devm_pwm_put);
767
768 /**
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   */
774 bool pwm_can_sleep(struct pwm_device *pwm)
775 {
776         return pwm->chip->can_sleep;
777 }
778 EXPORT_SYMBOL_GPL(pwm_can_sleep);
779
780 #ifdef CONFIG_DEBUG_FS
781 static 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
800 static 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
808 static 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
815 static void pwm_seq_stop(struct seq_file *s, void *v)
816 {
817         mutex_unlock(&pwm_lock);
818 }
819
820 static 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
837 static 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
844 static int pwm_seq_open(struct inode *inode, struct file *file)
845 {
846         return seq_open(file, &pwm_seq_ops);
847 }
848
849 static 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
857 static 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
865 subsys_initcall(pwm_debugfs_init);
866 #endif /* CONFIG_DEBUG_FS */