GNU Linux-libre 4.9.326-gnu1
[releases.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 #include <dt-bindings/pwm/pwm.h>
34
35 #define MAX_PWMS 1024
36
37 static DEFINE_MUTEX(pwm_lookup_lock);
38 static LIST_HEAD(pwm_lookup_list);
39 static DEFINE_MUTEX(pwm_lock);
40 static LIST_HEAD(pwm_chips);
41 static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
42 static RADIX_TREE(pwm_tree, GFP_KERNEL);
43
44 static struct pwm_device *pwm_to_device(unsigned int pwm)
45 {
46         return radix_tree_lookup(&pwm_tree, pwm);
47 }
48
49 static int alloc_pwms(int pwm, unsigned int count)
50 {
51         unsigned int from = 0;
52         unsigned int start;
53
54         if (pwm >= MAX_PWMS)
55                 return -EINVAL;
56
57         if (pwm >= 0)
58                 from = pwm;
59
60         start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from,
61                                            count, 0);
62
63         if (pwm >= 0 && start != pwm)
64                 return -EEXIST;
65
66         if (start + count > MAX_PWMS)
67                 return -ENOSPC;
68
69         return start;
70 }
71
72 static void free_pwms(struct pwm_chip *chip)
73 {
74         unsigned int i;
75
76         for (i = 0; i < chip->npwm; i++) {
77                 struct pwm_device *pwm = &chip->pwms[i];
78
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->args.period = args->args[1];
151
152         if (args->args[2] & PWM_POLARITY_INVERTED)
153                 pwm->args.polarity = PWM_POLARITY_INVERSED;
154         else
155                 pwm->args.polarity = 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->args.period = 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)
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  * Returns: 0 on success or a negative error code on failure.
206  */
207 int pwm_set_chip_data(struct pwm_device *pwm, void *data)
208 {
209         if (!pwm)
210                 return -EINVAL;
211
212         pwm->chip_data = data;
213
214         return 0;
215 }
216 EXPORT_SYMBOL_GPL(pwm_set_chip_data);
217
218 /**
219  * pwm_get_chip_data() - get private chip data for a PWM
220  * @pwm: PWM device
221  *
222  * Returns: A pointer to the chip-private data for the PWM device.
223  */
224 void *pwm_get_chip_data(struct pwm_device *pwm)
225 {
226         return pwm ? pwm->chip_data : NULL;
227 }
228 EXPORT_SYMBOL_GPL(pwm_get_chip_data);
229
230 static bool pwm_ops_check(const struct pwm_ops *ops)
231 {
232         /* driver supports legacy, non-atomic operation */
233         if (ops->config && ops->enable && ops->disable)
234                 return true;
235
236         /* driver supports atomic operation */
237         if (ops->apply)
238                 return true;
239
240         return false;
241 }
242
243 /**
244  * pwmchip_add_with_polarity() - register a new PWM chip
245  * @chip: the PWM chip to add
246  * @polarity: initial polarity of PWM channels
247  *
248  * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
249  * will be used. The initial polarity for all channels is specified by the
250  * @polarity parameter.
251  *
252  * Returns: 0 on success or a negative error code on failure.
253  */
254 int pwmchip_add_with_polarity(struct pwm_chip *chip,
255                               enum pwm_polarity polarity)
256 {
257         struct pwm_device *pwm;
258         unsigned int i;
259         int ret;
260
261         if (!chip || !chip->dev || !chip->ops || !chip->npwm)
262                 return -EINVAL;
263
264         if (!pwm_ops_check(chip->ops))
265                 return -EINVAL;
266
267         mutex_lock(&pwm_lock);
268
269         ret = alloc_pwms(chip->base, chip->npwm);
270         if (ret < 0)
271                 goto out;
272
273         chip->pwms = kcalloc(chip->npwm, sizeof(*pwm), GFP_KERNEL);
274         if (!chip->pwms) {
275                 ret = -ENOMEM;
276                 goto out;
277         }
278
279         chip->base = ret;
280
281         for (i = 0; i < chip->npwm; i++) {
282                 pwm = &chip->pwms[i];
283
284                 pwm->chip = chip;
285                 pwm->pwm = chip->base + i;
286                 pwm->hwpwm = i;
287                 pwm->state.polarity = polarity;
288
289                 if (chip->ops->get_state)
290                         chip->ops->get_state(chip, pwm, &pwm->state);
291
292                 radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
293         }
294
295         bitmap_set(allocated_pwms, chip->base, chip->npwm);
296
297         INIT_LIST_HEAD(&chip->list);
298         list_add(&chip->list, &pwm_chips);
299
300         ret = 0;
301
302         if (IS_ENABLED(CONFIG_OF))
303                 of_pwmchip_add(chip);
304
305 out:
306         mutex_unlock(&pwm_lock);
307
308         if (!ret)
309                 pwmchip_sysfs_export(chip);
310
311         return ret;
312 }
313 EXPORT_SYMBOL_GPL(pwmchip_add_with_polarity);
314
315 /**
316  * pwmchip_add() - register a new PWM chip
317  * @chip: the PWM chip to add
318  *
319  * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
320  * will be used. The initial polarity for all channels is normal.
321  *
322  * Returns: 0 on success or a negative error code on failure.
323  */
324 int pwmchip_add(struct pwm_chip *chip)
325 {
326         return pwmchip_add_with_polarity(chip, PWM_POLARITY_NORMAL);
327 }
328 EXPORT_SYMBOL_GPL(pwmchip_add);
329
330 /**
331  * pwmchip_remove() - remove a PWM chip
332  * @chip: the PWM chip to remove
333  *
334  * Removes a PWM chip. This function may return busy if the PWM chip provides
335  * a PWM device that is still requested.
336  *
337  * Returns: 0 on success or a negative error code on failure.
338  */
339 int pwmchip_remove(struct pwm_chip *chip)
340 {
341         unsigned int i;
342         int ret = 0;
343
344         pwmchip_sysfs_unexport(chip);
345
346         mutex_lock(&pwm_lock);
347
348         for (i = 0; i < chip->npwm; i++) {
349                 struct pwm_device *pwm = &chip->pwms[i];
350
351                 if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
352                         ret = -EBUSY;
353                         goto out;
354                 }
355         }
356
357         list_del_init(&chip->list);
358
359         if (IS_ENABLED(CONFIG_OF))
360                 of_pwmchip_remove(chip);
361
362         free_pwms(chip);
363
364 out:
365         mutex_unlock(&pwm_lock);
366         return ret;
367 }
368 EXPORT_SYMBOL_GPL(pwmchip_remove);
369
370 /**
371  * pwm_request() - request a PWM device
372  * @pwm: global PWM device index
373  * @label: PWM device label
374  *
375  * This function is deprecated, use pwm_get() instead.
376  *
377  * Returns: A pointer to a PWM device or an ERR_PTR()-encoded error code on
378  * failure.
379  */
380 struct pwm_device *pwm_request(int pwm, const char *label)
381 {
382         struct pwm_device *dev;
383         int err;
384
385         if (pwm < 0 || pwm >= MAX_PWMS)
386                 return ERR_PTR(-EINVAL);
387
388         mutex_lock(&pwm_lock);
389
390         dev = pwm_to_device(pwm);
391         if (!dev) {
392                 dev = ERR_PTR(-EPROBE_DEFER);
393                 goto out;
394         }
395
396         err = pwm_device_request(dev, label);
397         if (err < 0)
398                 dev = ERR_PTR(err);
399
400 out:
401         mutex_unlock(&pwm_lock);
402
403         return dev;
404 }
405 EXPORT_SYMBOL_GPL(pwm_request);
406
407 /**
408  * pwm_request_from_chip() - request a PWM device relative to a PWM chip
409  * @chip: PWM chip
410  * @index: per-chip index of the PWM to request
411  * @label: a literal description string of this PWM
412  *
413  * Returns: A pointer to the PWM device at the given index of the given PWM
414  * chip. A negative error code is returned if the index is not valid for the
415  * specified PWM chip or if the PWM device cannot be requested.
416  */
417 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
418                                          unsigned int index,
419                                          const char *label)
420 {
421         struct pwm_device *pwm;
422         int err;
423
424         if (!chip || index >= chip->npwm)
425                 return ERR_PTR(-EINVAL);
426
427         mutex_lock(&pwm_lock);
428         pwm = &chip->pwms[index];
429
430         err = pwm_device_request(pwm, label);
431         if (err < 0)
432                 pwm = ERR_PTR(err);
433
434         mutex_unlock(&pwm_lock);
435         return pwm;
436 }
437 EXPORT_SYMBOL_GPL(pwm_request_from_chip);
438
439 /**
440  * pwm_free() - free a PWM device
441  * @pwm: PWM device
442  *
443  * This function is deprecated, use pwm_put() instead.
444  */
445 void pwm_free(struct pwm_device *pwm)
446 {
447         pwm_put(pwm);
448 }
449 EXPORT_SYMBOL_GPL(pwm_free);
450
451 /**
452  * pwm_apply_state() - atomically apply a new state to a PWM device
453  * @pwm: PWM device
454  * @state: new state to apply. This can be adjusted by the PWM driver
455  *         if the requested config is not achievable, for example,
456  *         ->duty_cycle and ->period might be approximated.
457  */
458 int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state)
459 {
460         int err;
461
462         if (!pwm || !state || !state->period ||
463             state->duty_cycle > state->period)
464                 return -EINVAL;
465
466         if (!memcmp(state, &pwm->state, sizeof(*state)))
467                 return 0;
468
469         if (pwm->chip->ops->apply) {
470                 err = pwm->chip->ops->apply(pwm->chip, pwm, state);
471                 if (err)
472                         return err;
473
474                 pwm->state = *state;
475         } else {
476                 /*
477                  * FIXME: restore the initial state in case of error.
478                  */
479                 if (state->polarity != pwm->state.polarity) {
480                         if (!pwm->chip->ops->set_polarity)
481                                 return -ENOTSUPP;
482
483                         /*
484                          * Changing the polarity of a running PWM is
485                          * only allowed when the PWM driver implements
486                          * ->apply().
487                          */
488                         if (pwm->state.enabled) {
489                                 pwm->chip->ops->disable(pwm->chip, pwm);
490                                 pwm->state.enabled = false;
491                         }
492
493                         err = pwm->chip->ops->set_polarity(pwm->chip, pwm,
494                                                            state->polarity);
495                         if (err)
496                                 return err;
497
498                         pwm->state.polarity = state->polarity;
499                 }
500
501                 if (state->period != pwm->state.period ||
502                     state->duty_cycle != pwm->state.duty_cycle) {
503                         err = pwm->chip->ops->config(pwm->chip, pwm,
504                                                      state->duty_cycle,
505                                                      state->period);
506                         if (err)
507                                 return err;
508
509                         pwm->state.duty_cycle = state->duty_cycle;
510                         pwm->state.period = state->period;
511                 }
512
513                 if (state->enabled != pwm->state.enabled) {
514                         if (state->enabled) {
515                                 err = pwm->chip->ops->enable(pwm->chip, pwm);
516                                 if (err)
517                                         return err;
518                         } else {
519                                 pwm->chip->ops->disable(pwm->chip, pwm);
520                         }
521
522                         pwm->state.enabled = state->enabled;
523                 }
524         }
525
526         return 0;
527 }
528 EXPORT_SYMBOL_GPL(pwm_apply_state);
529
530 /**
531  * pwm_capture() - capture and report a PWM signal
532  * @pwm: PWM device
533  * @result: structure to fill with capture result
534  * @timeout: time to wait, in milliseconds, before giving up on capture
535  *
536  * Returns: 0 on success or a negative error code on failure.
537  */
538 int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,
539                 unsigned long timeout)
540 {
541         int err;
542
543         if (!pwm || !pwm->chip->ops)
544                 return -EINVAL;
545
546         if (!pwm->chip->ops->capture)
547                 return -ENOSYS;
548
549         mutex_lock(&pwm_lock);
550         err = pwm->chip->ops->capture(pwm->chip, pwm, result, timeout);
551         mutex_unlock(&pwm_lock);
552
553         return err;
554 }
555 EXPORT_SYMBOL_GPL(pwm_capture);
556
557 /**
558  * pwm_adjust_config() - adjust the current PWM config to the PWM arguments
559  * @pwm: PWM device
560  *
561  * This function will adjust the PWM config to the PWM arguments provided
562  * by the DT or PWM lookup table. This is particularly useful to adapt
563  * the bootloader config to the Linux one.
564  */
565 int pwm_adjust_config(struct pwm_device *pwm)
566 {
567         struct pwm_state state;
568         struct pwm_args pargs;
569
570         pwm_get_args(pwm, &pargs);
571         pwm_get_state(pwm, &state);
572
573         /*
574          * If the current period is zero it means that either the PWM driver
575          * does not support initial state retrieval or the PWM has not yet
576          * been configured.
577          *
578          * In either case, we setup the new period and polarity, and assign a
579          * duty cycle of 0.
580          */
581         if (!state.period) {
582                 state.duty_cycle = 0;
583                 state.period = pargs.period;
584                 state.polarity = pargs.polarity;
585
586                 return pwm_apply_state(pwm, &state);
587         }
588
589         /*
590          * Adjust the PWM duty cycle/period based on the period value provided
591          * in PWM args.
592          */
593         if (pargs.period != state.period) {
594                 u64 dutycycle = (u64)state.duty_cycle * pargs.period;
595
596                 do_div(dutycycle, state.period);
597                 state.duty_cycle = dutycycle;
598                 state.period = pargs.period;
599         }
600
601         /*
602          * If the polarity changed, we should also change the duty cycle.
603          */
604         if (pargs.polarity != state.polarity) {
605                 state.polarity = pargs.polarity;
606                 state.duty_cycle = state.period - state.duty_cycle;
607         }
608
609         return pwm_apply_state(pwm, &state);
610 }
611 EXPORT_SYMBOL_GPL(pwm_adjust_config);
612
613 static struct pwm_chip *of_node_to_pwmchip(struct device_node *np)
614 {
615         struct pwm_chip *chip;
616
617         mutex_lock(&pwm_lock);
618
619         list_for_each_entry(chip, &pwm_chips, list)
620                 if (chip->dev && chip->dev->of_node == np) {
621                         mutex_unlock(&pwm_lock);
622                         return chip;
623                 }
624
625         mutex_unlock(&pwm_lock);
626
627         return ERR_PTR(-EPROBE_DEFER);
628 }
629
630 /**
631  * of_pwm_get() - request a PWM via the PWM framework
632  * @np: device node to get the PWM from
633  * @con_id: consumer name
634  *
635  * Returns the PWM device parsed from the phandle and index specified in the
636  * "pwms" property of a device tree node or a negative error-code on failure.
637  * Values parsed from the device tree are stored in the returned PWM device
638  * object.
639  *
640  * If con_id is NULL, the first PWM device listed in the "pwms" property will
641  * be requested. Otherwise the "pwm-names" property is used to do a reverse
642  * lookup of the PWM index. This also means that the "pwm-names" property
643  * becomes mandatory for devices that look up the PWM device via the con_id
644  * parameter.
645  *
646  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
647  * error code on failure.
648  */
649 struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id)
650 {
651         struct pwm_device *pwm = NULL;
652         struct of_phandle_args args;
653         struct pwm_chip *pc;
654         int index = 0;
655         int err;
656
657         if (con_id) {
658                 index = of_property_match_string(np, "pwm-names", con_id);
659                 if (index < 0)
660                         return ERR_PTR(index);
661         }
662
663         err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
664                                          &args);
665         if (err) {
666                 pr_debug("%s(): can't parse \"pwms\" property\n", __func__);
667                 return ERR_PTR(err);
668         }
669
670         pc = of_node_to_pwmchip(args.np);
671         if (IS_ERR(pc)) {
672                 pr_debug("%s(): PWM chip not found\n", __func__);
673                 pwm = ERR_CAST(pc);
674                 goto put;
675         }
676
677         if (args.args_count != pc->of_pwm_n_cells) {
678                 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name,
679                          args.np->full_name);
680                 pwm = ERR_PTR(-EINVAL);
681                 goto put;
682         }
683
684         pwm = pc->of_xlate(pc, &args);
685         if (IS_ERR(pwm))
686                 goto put;
687
688         /*
689          * If a consumer name was not given, try to look it up from the
690          * "pwm-names" property if it exists. Otherwise use the name of
691          * the user device node.
692          */
693         if (!con_id) {
694                 err = of_property_read_string_index(np, "pwm-names", index,
695                                                     &con_id);
696                 if (err < 0)
697                         con_id = np->name;
698         }
699
700         pwm->label = con_id;
701
702 put:
703         of_node_put(args.np);
704
705         return pwm;
706 }
707 EXPORT_SYMBOL_GPL(of_pwm_get);
708
709 /**
710  * pwm_add_table() - register PWM device consumers
711  * @table: array of consumers to register
712  * @num: number of consumers in table
713  */
714 void pwm_add_table(struct pwm_lookup *table, size_t num)
715 {
716         mutex_lock(&pwm_lookup_lock);
717
718         while (num--) {
719                 list_add_tail(&table->list, &pwm_lookup_list);
720                 table++;
721         }
722
723         mutex_unlock(&pwm_lookup_lock);
724 }
725
726 /**
727  * pwm_remove_table() - unregister PWM device consumers
728  * @table: array of consumers to unregister
729  * @num: number of consumers in table
730  */
731 void pwm_remove_table(struct pwm_lookup *table, size_t num)
732 {
733         mutex_lock(&pwm_lookup_lock);
734
735         while (num--) {
736                 list_del(&table->list);
737                 table++;
738         }
739
740         mutex_unlock(&pwm_lookup_lock);
741 }
742
743 /**
744  * pwm_get() - look up and request a PWM device
745  * @dev: device for PWM consumer
746  * @con_id: consumer name
747  *
748  * Lookup is first attempted using DT. If the device was not instantiated from
749  * a device tree, a PWM chip and a relative index is looked up via a table
750  * supplied by board setup code (see pwm_add_table()).
751  *
752  * Once a PWM chip has been found the specified PWM device will be requested
753  * and is ready to be used.
754  *
755  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
756  * error code on failure.
757  */
758 struct pwm_device *pwm_get(struct device *dev, const char *con_id)
759 {
760         struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
761         const char *dev_id = dev ? dev_name(dev) : NULL;
762         struct pwm_chip *chip = NULL;
763         unsigned int best = 0;
764         struct pwm_lookup *p, *chosen = NULL;
765         unsigned int match;
766
767         /* look up via DT first */
768         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
769                 return of_pwm_get(dev->of_node, con_id);
770
771         /*
772          * We look up the provider in the static table typically provided by
773          * board setup code. We first try to lookup the consumer device by
774          * name. If the consumer device was passed in as NULL or if no match
775          * was found, we try to find the consumer by directly looking it up
776          * by name.
777          *
778          * If a match is found, the provider PWM chip is looked up by name
779          * and a PWM device is requested using the PWM device per-chip index.
780          *
781          * The lookup algorithm was shamelessly taken from the clock
782          * framework:
783          *
784          * We do slightly fuzzy matching here:
785          *  An entry with a NULL ID is assumed to be a wildcard.
786          *  If an entry has a device ID, it must match
787          *  If an entry has a connection ID, it must match
788          * Then we take the most specific entry - with the following order
789          * of precedence: dev+con > dev only > con only.
790          */
791         mutex_lock(&pwm_lookup_lock);
792
793         list_for_each_entry(p, &pwm_lookup_list, list) {
794                 match = 0;
795
796                 if (p->dev_id) {
797                         if (!dev_id || strcmp(p->dev_id, dev_id))
798                                 continue;
799
800                         match += 2;
801                 }
802
803                 if (p->con_id) {
804                         if (!con_id || strcmp(p->con_id, con_id))
805                                 continue;
806
807                         match += 1;
808                 }
809
810                 if (match > best) {
811                         chosen = p;
812
813                         if (match != 3)
814                                 best = match;
815                         else
816                                 break;
817                 }
818         }
819
820         if (!chosen) {
821                 pwm = ERR_PTR(-ENODEV);
822                 goto out;
823         }
824
825         chip = pwmchip_find_by_name(chosen->provider);
826         if (!chip)
827                 goto out;
828
829         pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);
830         if (IS_ERR(pwm))
831                 goto out;
832
833         pwm->args.period = chosen->period;
834         pwm->args.polarity = chosen->polarity;
835
836 out:
837         mutex_unlock(&pwm_lookup_lock);
838         return pwm;
839 }
840 EXPORT_SYMBOL_GPL(pwm_get);
841
842 /**
843  * pwm_put() - release a PWM device
844  * @pwm: PWM device
845  */
846 void pwm_put(struct pwm_device *pwm)
847 {
848         if (!pwm)
849                 return;
850
851         mutex_lock(&pwm_lock);
852
853         if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
854                 pr_warn("PWM device already freed\n");
855                 goto out;
856         }
857
858         if (pwm->chip->ops->free)
859                 pwm->chip->ops->free(pwm->chip, pwm);
860
861         pwm_set_chip_data(pwm, NULL);
862         pwm->label = NULL;
863
864         module_put(pwm->chip->ops->owner);
865 out:
866         mutex_unlock(&pwm_lock);
867 }
868 EXPORT_SYMBOL_GPL(pwm_put);
869
870 static void devm_pwm_release(struct device *dev, void *res)
871 {
872         pwm_put(*(struct pwm_device **)res);
873 }
874
875 /**
876  * devm_pwm_get() - resource managed pwm_get()
877  * @dev: device for PWM consumer
878  * @con_id: consumer name
879  *
880  * This function performs like pwm_get() but the acquired PWM device will
881  * automatically be released on driver detach.
882  *
883  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
884  * error code on failure.
885  */
886 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
887 {
888         struct pwm_device **ptr, *pwm;
889
890         ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
891         if (!ptr)
892                 return ERR_PTR(-ENOMEM);
893
894         pwm = pwm_get(dev, con_id);
895         if (!IS_ERR(pwm)) {
896                 *ptr = pwm;
897                 devres_add(dev, ptr);
898         } else {
899                 devres_free(ptr);
900         }
901
902         return pwm;
903 }
904 EXPORT_SYMBOL_GPL(devm_pwm_get);
905
906 /**
907  * devm_of_pwm_get() - resource managed of_pwm_get()
908  * @dev: device for PWM consumer
909  * @np: device node to get the PWM from
910  * @con_id: consumer name
911  *
912  * This function performs like of_pwm_get() but the acquired PWM device will
913  * automatically be released on driver detach.
914  *
915  * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
916  * error code on failure.
917  */
918 struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
919                                    const char *con_id)
920 {
921         struct pwm_device **ptr, *pwm;
922
923         ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
924         if (!ptr)
925                 return ERR_PTR(-ENOMEM);
926
927         pwm = of_pwm_get(np, con_id);
928         if (!IS_ERR(pwm)) {
929                 *ptr = pwm;
930                 devres_add(dev, ptr);
931         } else {
932                 devres_free(ptr);
933         }
934
935         return pwm;
936 }
937 EXPORT_SYMBOL_GPL(devm_of_pwm_get);
938
939 static int devm_pwm_match(struct device *dev, void *res, void *data)
940 {
941         struct pwm_device **p = res;
942
943         if (WARN_ON(!p || !*p))
944                 return 0;
945
946         return *p == data;
947 }
948
949 /**
950  * devm_pwm_put() - resource managed pwm_put()
951  * @dev: device for PWM consumer
952  * @pwm: PWM device
953  *
954  * Release a PWM previously allocated using devm_pwm_get(). Calling this
955  * function is usually not needed because devm-allocated resources are
956  * automatically released on driver detach.
957  */
958 void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
959 {
960         WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm));
961 }
962 EXPORT_SYMBOL_GPL(devm_pwm_put);
963
964 /**
965   * pwm_can_sleep() - report whether PWM access will sleep
966   * @pwm: PWM device
967   *
968   * Returns: True if accessing the PWM can sleep, false otherwise.
969   */
970 bool pwm_can_sleep(struct pwm_device *pwm)
971 {
972         return true;
973 }
974 EXPORT_SYMBOL_GPL(pwm_can_sleep);
975
976 #ifdef CONFIG_DEBUG_FS
977 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
978 {
979         unsigned int i;
980
981         for (i = 0; i < chip->npwm; i++) {
982                 struct pwm_device *pwm = &chip->pwms[i];
983                 struct pwm_state state;
984
985                 pwm_get_state(pwm, &state);
986
987                 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
988
989                 if (test_bit(PWMF_REQUESTED, &pwm->flags))
990                         seq_puts(s, " requested");
991
992                 if (state.enabled)
993                         seq_puts(s, " enabled");
994
995                 seq_printf(s, " period: %u ns", state.period);
996                 seq_printf(s, " duty: %u ns", state.duty_cycle);
997                 seq_printf(s, " polarity: %s",
998                            state.polarity ? "inverse" : "normal");
999
1000                 seq_puts(s, "\n");
1001         }
1002 }
1003
1004 static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
1005 {
1006         mutex_lock(&pwm_lock);
1007         s->private = "";
1008
1009         return seq_list_start(&pwm_chips, *pos);
1010 }
1011
1012 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
1013 {
1014         s->private = "\n";
1015
1016         return seq_list_next(v, &pwm_chips, pos);
1017 }
1018
1019 static void pwm_seq_stop(struct seq_file *s, void *v)
1020 {
1021         mutex_unlock(&pwm_lock);
1022 }
1023
1024 static int pwm_seq_show(struct seq_file *s, void *v)
1025 {
1026         struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
1027
1028         seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
1029                    chip->dev->bus ? chip->dev->bus->name : "no-bus",
1030                    dev_name(chip->dev), chip->npwm,
1031                    (chip->npwm != 1) ? "s" : "");
1032
1033         if (chip->ops->dbg_show)
1034                 chip->ops->dbg_show(chip, s);
1035         else
1036                 pwm_dbg_show(chip, s);
1037
1038         return 0;
1039 }
1040
1041 static const struct seq_operations pwm_seq_ops = {
1042         .start = pwm_seq_start,
1043         .next = pwm_seq_next,
1044         .stop = pwm_seq_stop,
1045         .show = pwm_seq_show,
1046 };
1047
1048 static int pwm_seq_open(struct inode *inode, struct file *file)
1049 {
1050         return seq_open(file, &pwm_seq_ops);
1051 }
1052
1053 static const struct file_operations pwm_debugfs_ops = {
1054         .owner = THIS_MODULE,
1055         .open = pwm_seq_open,
1056         .read = seq_read,
1057         .llseek = seq_lseek,
1058         .release = seq_release,
1059 };
1060
1061 static int __init pwm_debugfs_init(void)
1062 {
1063         debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL,
1064                             &pwm_debugfs_ops);
1065
1066         return 0;
1067 }
1068 subsys_initcall(pwm_debugfs_init);
1069 #endif /* CONFIG_DEBUG_FS */