1
2
3
4
5
6
7
8
9#include <linux/acpi.h>
10#include <linux/module.h>
11#include <linux/pwm.h>
12#include <linux/radix-tree.h>
13#include <linux/list.h>
14#include <linux/mutex.h>
15#include <linux/err.h>
16#include <linux/slab.h>
17#include <linux/device.h>
18#include <linux/debugfs.h>
19#include <linux/seq_file.h>
20
21#include <dt-bindings/pwm/pwm.h>
22
23#define CREATE_TRACE_POINTS
24#include <trace/events/pwm.h>
25
26#define MAX_PWMS 1024
27
28static DEFINE_MUTEX(pwm_lookup_lock);
29static LIST_HEAD(pwm_lookup_list);
30static DEFINE_MUTEX(pwm_lock);
31static LIST_HEAD(pwm_chips);
32static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
33static RADIX_TREE(pwm_tree, GFP_KERNEL);
34
35static struct pwm_device *pwm_to_device(unsigned int pwm)
36{
37 return radix_tree_lookup(&pwm_tree, pwm);
38}
39
40static int alloc_pwms(unsigned int count)
41{
42 unsigned int start;
43
44 start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, 0,
45 count, 0);
46
47 if (start + count > MAX_PWMS)
48 return -ENOSPC;
49
50 return start;
51}
52
53static void free_pwms(struct pwm_chip *chip)
54{
55 unsigned int i;
56
57 for (i = 0; i < chip->npwm; i++) {
58 struct pwm_device *pwm = &chip->pwms[i];
59
60 radix_tree_delete(&pwm_tree, pwm->pwm);
61 }
62
63 bitmap_clear(allocated_pwms, chip->base, chip->npwm);
64
65 kfree(chip->pwms);
66 chip->pwms = NULL;
67}
68
69static struct pwm_chip *pwmchip_find_by_name(const char *name)
70{
71 struct pwm_chip *chip;
72
73 if (!name)
74 return NULL;
75
76 mutex_lock(&pwm_lock);
77
78 list_for_each_entry(chip, &pwm_chips, list) {
79 const char *chip_name = dev_name(chip->dev);
80
81 if (chip_name && strcmp(chip_name, name) == 0) {
82 mutex_unlock(&pwm_lock);
83 return chip;
84 }
85 }
86
87 mutex_unlock(&pwm_lock);
88
89 return NULL;
90}
91
92static int pwm_device_request(struct pwm_device *pwm, const char *label)
93{
94 int err;
95
96 if (test_bit(PWMF_REQUESTED, &pwm->flags))
97 return -EBUSY;
98
99 if (!try_module_get(pwm->chip->ops->owner))
100 return -ENODEV;
101
102 if (pwm->chip->ops->request) {
103 err = pwm->chip->ops->request(pwm->chip, pwm);
104 if (err) {
105 module_put(pwm->chip->ops->owner);
106 return err;
107 }
108 }
109
110 if (pwm->chip->ops->get_state) {
111 pwm->chip->ops->get_state(pwm->chip, pwm, &pwm->state);
112 trace_pwm_get(pwm, &pwm->state);
113
114 if (IS_ENABLED(CONFIG_PWM_DEBUG))
115 pwm->last = pwm->state;
116 }
117
118 set_bit(PWMF_REQUESTED, &pwm->flags);
119 pwm->label = label;
120
121 return 0;
122}
123
124struct pwm_device *
125of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args)
126{
127 struct pwm_device *pwm;
128
129 if (pc->of_pwm_n_cells < 2)
130 return ERR_PTR(-EINVAL);
131
132
133 if (args->args_count < 2)
134 return ERR_PTR(-EINVAL);
135
136 if (args->args[0] >= pc->npwm)
137 return ERR_PTR(-EINVAL);
138
139 pwm = pwm_request_from_chip(pc, args->args[0], NULL);
140 if (IS_ERR(pwm))
141 return pwm;
142
143 pwm->args.period = args->args[1];
144 pwm->args.polarity = PWM_POLARITY_NORMAL;
145
146 if (pc->of_pwm_n_cells >= 3) {
147 if (args->args_count > 2 && args->args[2] & PWM_POLARITY_INVERTED)
148 pwm->args.polarity = PWM_POLARITY_INVERSED;
149 }
150
151 return pwm;
152}
153EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
154
155static void of_pwmchip_add(struct pwm_chip *chip)
156{
157 if (!chip->dev || !chip->dev->of_node)
158 return;
159
160 if (!chip->of_xlate) {
161 u32 pwm_cells;
162
163 if (of_property_read_u32(chip->dev->of_node, "#pwm-cells",
164 &pwm_cells))
165 pwm_cells = 2;
166
167 chip->of_xlate = of_pwm_xlate_with_flags;
168 chip->of_pwm_n_cells = pwm_cells;
169 }
170
171 of_node_get(chip->dev->of_node);
172}
173
174static void of_pwmchip_remove(struct pwm_chip *chip)
175{
176 if (chip->dev)
177 of_node_put(chip->dev->of_node);
178}
179
180
181
182
183
184
185
186
187int pwm_set_chip_data(struct pwm_device *pwm, void *data)
188{
189 if (!pwm)
190 return -EINVAL;
191
192 pwm->chip_data = data;
193
194 return 0;
195}
196EXPORT_SYMBOL_GPL(pwm_set_chip_data);
197
198
199
200
201
202
203
204void *pwm_get_chip_data(struct pwm_device *pwm)
205{
206 return pwm ? pwm->chip_data : NULL;
207}
208EXPORT_SYMBOL_GPL(pwm_get_chip_data);
209
210static bool pwm_ops_check(const struct pwm_chip *chip)
211{
212
213 const struct pwm_ops *ops = chip->ops;
214
215
216 if (ops->config && ops->enable && ops->disable) {
217 if (IS_ENABLED(CONFIG_PWM_DEBUG))
218 dev_warn(chip->dev,
219 "Driver needs updating to atomic API\n");
220
221 return true;
222 }
223
224 if (!ops->apply)
225 return false;
226
227 if (IS_ENABLED(CONFIG_PWM_DEBUG) && !ops->get_state)
228 dev_warn(chip->dev,
229 "Please implement the .get_state() callback\n");
230
231 return true;
232}
233
234
235
236
237
238
239
240
241
242int pwmchip_add(struct pwm_chip *chip)
243{
244 struct pwm_device *pwm;
245 unsigned int i;
246 int ret;
247
248 if (!chip || !chip->dev || !chip->ops || !chip->npwm)
249 return -EINVAL;
250
251 if (!pwm_ops_check(chip))
252 return -EINVAL;
253
254 mutex_lock(&pwm_lock);
255
256 ret = alloc_pwms(chip->npwm);
257 if (ret < 0)
258 goto out;
259
260 chip->base = ret;
261
262 chip->pwms = kcalloc(chip->npwm, sizeof(*pwm), GFP_KERNEL);
263 if (!chip->pwms) {
264 ret = -ENOMEM;
265 goto out;
266 }
267
268 for (i = 0; i < chip->npwm; i++) {
269 pwm = &chip->pwms[i];
270
271 pwm->chip = chip;
272 pwm->pwm = chip->base + i;
273 pwm->hwpwm = i;
274
275 radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
276 }
277
278 bitmap_set(allocated_pwms, chip->base, chip->npwm);
279
280 INIT_LIST_HEAD(&chip->list);
281 list_add(&chip->list, &pwm_chips);
282
283 ret = 0;
284
285 if (IS_ENABLED(CONFIG_OF))
286 of_pwmchip_add(chip);
287
288out:
289 mutex_unlock(&pwm_lock);
290
291 if (!ret)
292 pwmchip_sysfs_export(chip);
293
294 return ret;
295}
296EXPORT_SYMBOL_GPL(pwmchip_add);
297
298
299
300
301
302
303
304
305
306
307void pwmchip_remove(struct pwm_chip *chip)
308{
309 pwmchip_sysfs_unexport(chip);
310
311 mutex_lock(&pwm_lock);
312
313 list_del_init(&chip->list);
314
315 if (IS_ENABLED(CONFIG_OF))
316 of_pwmchip_remove(chip);
317
318 free_pwms(chip);
319
320 mutex_unlock(&pwm_lock);
321}
322EXPORT_SYMBOL_GPL(pwmchip_remove);
323
324static void devm_pwmchip_remove(void *data)
325{
326 struct pwm_chip *chip = data;
327
328 pwmchip_remove(chip);
329}
330
331int devm_pwmchip_add(struct device *dev, struct pwm_chip *chip)
332{
333 int ret;
334
335 ret = pwmchip_add(chip);
336 if (ret)
337 return ret;
338
339 return devm_add_action_or_reset(dev, devm_pwmchip_remove, chip);
340}
341EXPORT_SYMBOL_GPL(devm_pwmchip_add);
342
343
344
345
346
347
348
349
350
351
352
353struct pwm_device *pwm_request(int pwm, const char *label)
354{
355 struct pwm_device *dev;
356 int err;
357
358 if (pwm < 0 || pwm >= MAX_PWMS)
359 return ERR_PTR(-EINVAL);
360
361 mutex_lock(&pwm_lock);
362
363 dev = pwm_to_device(pwm);
364 if (!dev) {
365 dev = ERR_PTR(-EPROBE_DEFER);
366 goto out;
367 }
368
369 err = pwm_device_request(dev, label);
370 if (err < 0)
371 dev = ERR_PTR(err);
372
373out:
374 mutex_unlock(&pwm_lock);
375
376 return dev;
377}
378EXPORT_SYMBOL_GPL(pwm_request);
379
380
381
382
383
384
385
386
387
388
389
390struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
391 unsigned int index,
392 const char *label)
393{
394 struct pwm_device *pwm;
395 int err;
396
397 if (!chip || index >= chip->npwm)
398 return ERR_PTR(-EINVAL);
399
400 mutex_lock(&pwm_lock);
401 pwm = &chip->pwms[index];
402
403 err = pwm_device_request(pwm, label);
404 if (err < 0)
405 pwm = ERR_PTR(err);
406
407 mutex_unlock(&pwm_lock);
408 return pwm;
409}
410EXPORT_SYMBOL_GPL(pwm_request_from_chip);
411
412
413
414
415
416
417
418void pwm_free(struct pwm_device *pwm)
419{
420 pwm_put(pwm);
421}
422EXPORT_SYMBOL_GPL(pwm_free);
423
424static void pwm_apply_state_debug(struct pwm_device *pwm,
425 const struct pwm_state *state)
426{
427 struct pwm_state *last = &pwm->last;
428 struct pwm_chip *chip = pwm->chip;
429 struct pwm_state s1, s2;
430 int err;
431
432 if (!IS_ENABLED(CONFIG_PWM_DEBUG))
433 return;
434
435
436 if (!chip->ops->get_state)
437 return;
438
439
440
441
442
443
444 chip->ops->get_state(chip, pwm, &s1);
445 trace_pwm_get(pwm, &s1);
446
447
448
449
450
451
452 if (s1.enabled && s1.polarity != state->polarity) {
453 s2.polarity = state->polarity;
454 s2.duty_cycle = s1.period - s1.duty_cycle;
455 s2.period = s1.period;
456 s2.enabled = s1.enabled;
457 } else {
458 s2 = s1;
459 }
460
461 if (s2.polarity != state->polarity &&
462 state->duty_cycle < state->period)
463 dev_warn(chip->dev, ".apply ignored .polarity\n");
464
465 if (state->enabled &&
466 last->polarity == state->polarity &&
467 last->period > s2.period &&
468 last->period <= state->period)
469 dev_warn(chip->dev,
470 ".apply didn't pick the best available period (requested: %llu, applied: %llu, possible: %llu)\n",
471 state->period, s2.period, last->period);
472
473 if (state->enabled && state->period < s2.period)
474 dev_warn(chip->dev,
475 ".apply is supposed to round down period (requested: %llu, applied: %llu)\n",
476 state->period, s2.period);
477
478 if (state->enabled &&
479 last->polarity == state->polarity &&
480 last->period == s2.period &&
481 last->duty_cycle > s2.duty_cycle &&
482 last->duty_cycle <= state->duty_cycle)
483 dev_warn(chip->dev,
484 ".apply didn't pick the best available duty cycle (requested: %llu/%llu, applied: %llu/%llu, possible: %llu/%llu)\n",
485 state->duty_cycle, state->period,
486 s2.duty_cycle, s2.period,
487 last->duty_cycle, last->period);
488
489 if (state->enabled && state->duty_cycle < s2.duty_cycle)
490 dev_warn(chip->dev,
491 ".apply is supposed to round down duty_cycle (requested: %llu/%llu, applied: %llu/%llu)\n",
492 state->duty_cycle, state->period,
493 s2.duty_cycle, s2.period);
494
495 if (!state->enabled && s2.enabled && s2.duty_cycle > 0)
496 dev_warn(chip->dev,
497 "requested disabled, but yielded enabled with duty > 0\n");
498
499
500 err = chip->ops->apply(chip, pwm, &s1);
501 if (err) {
502 *last = s1;
503 dev_err(chip->dev, "failed to reapply current setting\n");
504 return;
505 }
506
507 trace_pwm_apply(pwm, &s1);
508
509 chip->ops->get_state(chip, pwm, last);
510 trace_pwm_get(pwm, last);
511
512
513 if (s1.enabled != last->enabled ||
514 s1.polarity != last->polarity ||
515 (s1.enabled && s1.period != last->period) ||
516 (s1.enabled && s1.duty_cycle != last->duty_cycle)) {
517 dev_err(chip->dev,
518 ".apply is not idempotent (ena=%d pol=%d %llu/%llu) -> (ena=%d pol=%d %llu/%llu)\n",
519 s1.enabled, s1.polarity, s1.duty_cycle, s1.period,
520 last->enabled, last->polarity, last->duty_cycle,
521 last->period);
522 }
523}
524
525
526
527
528
529
530int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
531{
532 struct pwm_chip *chip;
533 int err;
534
535 if (!pwm || !state || !state->period ||
536 state->duty_cycle > state->period)
537 return -EINVAL;
538
539 chip = pwm->chip;
540
541 if (state->period == pwm->state.period &&
542 state->duty_cycle == pwm->state.duty_cycle &&
543 state->polarity == pwm->state.polarity &&
544 state->enabled == pwm->state.enabled &&
545 state->usage_power == pwm->state.usage_power)
546 return 0;
547
548 if (chip->ops->apply) {
549 err = chip->ops->apply(chip, pwm, state);
550 if (err)
551 return err;
552
553 trace_pwm_apply(pwm, state);
554
555 pwm->state = *state;
556
557
558
559
560
561 pwm_apply_state_debug(pwm, state);
562 } else {
563
564
565
566 if (state->polarity != pwm->state.polarity) {
567 if (!chip->ops->set_polarity)
568 return -EINVAL;
569
570
571
572
573
574
575 if (pwm->state.enabled) {
576 chip->ops->disable(chip, pwm);
577 pwm->state.enabled = false;
578 }
579
580 err = chip->ops->set_polarity(chip, pwm,
581 state->polarity);
582 if (err)
583 return err;
584
585 pwm->state.polarity = state->polarity;
586 }
587
588 if (state->period != pwm->state.period ||
589 state->duty_cycle != pwm->state.duty_cycle) {
590 err = chip->ops->config(pwm->chip, pwm,
591 state->duty_cycle,
592 state->period);
593 if (err)
594 return err;
595
596 pwm->state.duty_cycle = state->duty_cycle;
597 pwm->state.period = state->period;
598 }
599
600 if (state->enabled != pwm->state.enabled) {
601 if (state->enabled) {
602 err = chip->ops->enable(chip, pwm);
603 if (err)
604 return err;
605 } else {
606 chip->ops->disable(chip, pwm);
607 }
608
609 pwm->state.enabled = state->enabled;
610 }
611 }
612
613 return 0;
614}
615EXPORT_SYMBOL_GPL(pwm_apply_state);
616
617
618
619
620
621
622
623
624
625int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,
626 unsigned long timeout)
627{
628 int err;
629
630 if (!pwm || !pwm->chip->ops)
631 return -EINVAL;
632
633 if (!pwm->chip->ops->capture)
634 return -ENOSYS;
635
636 mutex_lock(&pwm_lock);
637 err = pwm->chip->ops->capture(pwm->chip, pwm, result, timeout);
638 mutex_unlock(&pwm_lock);
639
640 return err;
641}
642EXPORT_SYMBOL_GPL(pwm_capture);
643
644
645
646
647
648
649
650
651
652int pwm_adjust_config(struct pwm_device *pwm)
653{
654 struct pwm_state state;
655 struct pwm_args pargs;
656
657 pwm_get_args(pwm, &pargs);
658 pwm_get_state(pwm, &state);
659
660
661
662
663
664
665
666
667
668 if (!state.period) {
669 state.duty_cycle = 0;
670 state.period = pargs.period;
671 state.polarity = pargs.polarity;
672
673 return pwm_apply_state(pwm, &state);
674 }
675
676
677
678
679
680 if (pargs.period != state.period) {
681 u64 dutycycle = (u64)state.duty_cycle * pargs.period;
682
683 do_div(dutycycle, state.period);
684 state.duty_cycle = dutycycle;
685 state.period = pargs.period;
686 }
687
688
689
690
691 if (pargs.polarity != state.polarity) {
692 state.polarity = pargs.polarity;
693 state.duty_cycle = state.period - state.duty_cycle;
694 }
695
696 return pwm_apply_state(pwm, &state);
697}
698EXPORT_SYMBOL_GPL(pwm_adjust_config);
699
700static struct pwm_chip *fwnode_to_pwmchip(struct fwnode_handle *fwnode)
701{
702 struct pwm_chip *chip;
703
704 mutex_lock(&pwm_lock);
705
706 list_for_each_entry(chip, &pwm_chips, list)
707 if (chip->dev && dev_fwnode(chip->dev) == fwnode) {
708 mutex_unlock(&pwm_lock);
709 return chip;
710 }
711
712 mutex_unlock(&pwm_lock);
713
714 return ERR_PTR(-EPROBE_DEFER);
715}
716
717static struct device_link *pwm_device_link_add(struct device *dev,
718 struct pwm_device *pwm)
719{
720 struct device_link *dl;
721
722 if (!dev) {
723
724
725
726
727
728 dev_warn(pwm->chip->dev,
729 "No consumer device specified to create a link to\n");
730 return NULL;
731 }
732
733 dl = device_link_add(dev, pwm->chip->dev, DL_FLAG_AUTOREMOVE_CONSUMER);
734 if (!dl) {
735 dev_err(dev, "failed to create device link to %s\n",
736 dev_name(pwm->chip->dev));
737 return ERR_PTR(-EINVAL);
738 }
739
740 return dl;
741}
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763struct pwm_device *of_pwm_get(struct device *dev, struct device_node *np,
764 const char *con_id)
765{
766 struct pwm_device *pwm = NULL;
767 struct of_phandle_args args;
768 struct device_link *dl;
769 struct pwm_chip *pc;
770 int index = 0;
771 int err;
772
773 if (con_id) {
774 index = of_property_match_string(np, "pwm-names", con_id);
775 if (index < 0)
776 return ERR_PTR(index);
777 }
778
779 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
780 &args);
781 if (err) {
782 pr_err("%s(): can't parse \"pwms\" property\n", __func__);
783 return ERR_PTR(err);
784 }
785
786 pc = fwnode_to_pwmchip(of_fwnode_handle(args.np));
787 if (IS_ERR(pc)) {
788 if (PTR_ERR(pc) != -EPROBE_DEFER)
789 pr_err("%s(): PWM chip not found\n", __func__);
790
791 pwm = ERR_CAST(pc);
792 goto put;
793 }
794
795 pwm = pc->of_xlate(pc, &args);
796 if (IS_ERR(pwm))
797 goto put;
798
799 dl = pwm_device_link_add(dev, pwm);
800 if (IS_ERR(dl)) {
801
802 pwm_free(pwm);
803 pwm = ERR_CAST(dl);
804 goto put;
805 }
806
807
808
809
810
811
812 if (!con_id) {
813 err = of_property_read_string_index(np, "pwm-names", index,
814 &con_id);
815 if (err < 0)
816 con_id = np->name;
817 }
818
819 pwm->label = con_id;
820
821put:
822 of_node_put(args.np);
823
824 return pwm;
825}
826EXPORT_SYMBOL_GPL(of_pwm_get);
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845static struct pwm_device *acpi_pwm_get(const struct fwnode_handle *fwnode)
846{
847 struct pwm_device *pwm;
848 struct fwnode_reference_args args;
849 struct pwm_chip *chip;
850 int ret;
851
852 memset(&args, 0, sizeof(args));
853
854 ret = __acpi_node_get_property_reference(fwnode, "pwms", 0, 3, &args);
855 if (ret < 0)
856 return ERR_PTR(ret);
857
858 if (args.nargs < 2)
859 return ERR_PTR(-EPROTO);
860
861 chip = fwnode_to_pwmchip(args.fwnode);
862 if (IS_ERR(chip))
863 return ERR_CAST(chip);
864
865 pwm = pwm_request_from_chip(chip, args.args[0], NULL);
866 if (IS_ERR(pwm))
867 return pwm;
868
869 pwm->args.period = args.args[1];
870 pwm->args.polarity = PWM_POLARITY_NORMAL;
871
872 if (args.nargs > 2 && args.args[2] & PWM_POLARITY_INVERTED)
873 pwm->args.polarity = PWM_POLARITY_INVERSED;
874
875 return pwm;
876}
877
878
879
880
881
882
883void pwm_add_table(struct pwm_lookup *table, size_t num)
884{
885 mutex_lock(&pwm_lookup_lock);
886
887 while (num--) {
888 list_add_tail(&table->list, &pwm_lookup_list);
889 table++;
890 }
891
892 mutex_unlock(&pwm_lookup_lock);
893}
894
895
896
897
898
899
900void pwm_remove_table(struct pwm_lookup *table, size_t num)
901{
902 mutex_lock(&pwm_lookup_lock);
903
904 while (num--) {
905 list_del(&table->list);
906 table++;
907 }
908
909 mutex_unlock(&pwm_lookup_lock);
910}
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927struct pwm_device *pwm_get(struct device *dev, const char *con_id)
928{
929 const struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL;
930 const char *dev_id = dev ? dev_name(dev) : NULL;
931 struct pwm_device *pwm;
932 struct pwm_chip *chip;
933 struct device_link *dl;
934 unsigned int best = 0;
935 struct pwm_lookup *p, *chosen = NULL;
936 unsigned int match;
937 int err;
938
939
940 if (is_of_node(fwnode))
941 return of_pwm_get(dev, to_of_node(fwnode), con_id);
942
943
944 if (is_acpi_node(fwnode)) {
945 pwm = acpi_pwm_get(fwnode);
946 if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT)
947 return pwm;
948 }
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970 mutex_lock(&pwm_lookup_lock);
971
972 list_for_each_entry(p, &pwm_lookup_list, list) {
973 match = 0;
974
975 if (p->dev_id) {
976 if (!dev_id || strcmp(p->dev_id, dev_id))
977 continue;
978
979 match += 2;
980 }
981
982 if (p->con_id) {
983 if (!con_id || strcmp(p->con_id, con_id))
984 continue;
985
986 match += 1;
987 }
988
989 if (match > best) {
990 chosen = p;
991
992 if (match != 3)
993 best = match;
994 else
995 break;
996 }
997 }
998
999 mutex_unlock(&pwm_lookup_lock);
1000
1001 if (!chosen)
1002 return ERR_PTR(-ENODEV);
1003
1004 chip = pwmchip_find_by_name(chosen->provider);
1005
1006
1007
1008
1009
1010
1011
1012 if (!chip && chosen->module) {
1013 err = request_module(chosen->module);
1014 if (err == 0)
1015 chip = pwmchip_find_by_name(chosen->provider);
1016 }
1017
1018 if (!chip)
1019 return ERR_PTR(-EPROBE_DEFER);
1020
1021 pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);
1022 if (IS_ERR(pwm))
1023 return pwm;
1024
1025 dl = pwm_device_link_add(dev, pwm);
1026 if (IS_ERR(dl)) {
1027 pwm_free(pwm);
1028 return ERR_CAST(dl);
1029 }
1030
1031 pwm->args.period = chosen->period;
1032 pwm->args.polarity = chosen->polarity;
1033
1034 return pwm;
1035}
1036EXPORT_SYMBOL_GPL(pwm_get);
1037
1038
1039
1040
1041
1042void pwm_put(struct pwm_device *pwm)
1043{
1044 if (!pwm)
1045 return;
1046
1047 mutex_lock(&pwm_lock);
1048
1049 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
1050 pr_warn("PWM device already freed\n");
1051 goto out;
1052 }
1053
1054 if (pwm->chip->ops->free)
1055 pwm->chip->ops->free(pwm->chip, pwm);
1056
1057 pwm_set_chip_data(pwm, NULL);
1058 pwm->label = NULL;
1059
1060 module_put(pwm->chip->ops->owner);
1061out:
1062 mutex_unlock(&pwm_lock);
1063}
1064EXPORT_SYMBOL_GPL(pwm_put);
1065
1066static void devm_pwm_release(void *pwm)
1067{
1068 pwm_put(pwm);
1069}
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
1083{
1084 struct pwm_device *pwm;
1085 int ret;
1086
1087 pwm = pwm_get(dev, con_id);
1088 if (IS_ERR(pwm))
1089 return pwm;
1090
1091 ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
1092 if (ret)
1093 return ERR_PTR(ret);
1094
1095 return pwm;
1096}
1097EXPORT_SYMBOL_GPL(devm_pwm_get);
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
1112 const char *con_id)
1113{
1114 struct pwm_device *pwm;
1115 int ret;
1116
1117 pwm = of_pwm_get(dev, np, con_id);
1118 if (IS_ERR(pwm))
1119 return pwm;
1120
1121 ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
1122 if (ret)
1123 return ERR_PTR(ret);
1124
1125 return pwm;
1126}
1127EXPORT_SYMBOL_GPL(devm_of_pwm_get);
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141struct pwm_device *devm_fwnode_pwm_get(struct device *dev,
1142 struct fwnode_handle *fwnode,
1143 const char *con_id)
1144{
1145 struct pwm_device *pwm = ERR_PTR(-ENODEV);
1146 int ret;
1147
1148 if (is_of_node(fwnode))
1149 pwm = of_pwm_get(dev, to_of_node(fwnode), con_id);
1150 else if (is_acpi_node(fwnode))
1151 pwm = acpi_pwm_get(fwnode);
1152 if (IS_ERR(pwm))
1153 return pwm;
1154
1155 ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
1156 if (ret)
1157 return ERR_PTR(ret);
1158
1159 return pwm;
1160}
1161EXPORT_SYMBOL_GPL(devm_fwnode_pwm_get);
1162
1163#ifdef CONFIG_DEBUG_FS
1164static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
1165{
1166 unsigned int i;
1167
1168 for (i = 0; i < chip->npwm; i++) {
1169 struct pwm_device *pwm = &chip->pwms[i];
1170 struct pwm_state state;
1171
1172 pwm_get_state(pwm, &state);
1173
1174 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
1175
1176 if (test_bit(PWMF_REQUESTED, &pwm->flags))
1177 seq_puts(s, " requested");
1178
1179 if (state.enabled)
1180 seq_puts(s, " enabled");
1181
1182 seq_printf(s, " period: %llu ns", state.period);
1183 seq_printf(s, " duty: %llu ns", state.duty_cycle);
1184 seq_printf(s, " polarity: %s",
1185 state.polarity ? "inverse" : "normal");
1186
1187 if (state.usage_power)
1188 seq_puts(s, " usage_power");
1189
1190 seq_puts(s, "\n");
1191 }
1192}
1193
1194static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
1195{
1196 mutex_lock(&pwm_lock);
1197 s->private = "";
1198
1199 return seq_list_start(&pwm_chips, *pos);
1200}
1201
1202static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
1203{
1204 s->private = "\n";
1205
1206 return seq_list_next(v, &pwm_chips, pos);
1207}
1208
1209static void pwm_seq_stop(struct seq_file *s, void *v)
1210{
1211 mutex_unlock(&pwm_lock);
1212}
1213
1214static int pwm_seq_show(struct seq_file *s, void *v)
1215{
1216 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
1217
1218 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
1219 chip->dev->bus ? chip->dev->bus->name : "no-bus",
1220 dev_name(chip->dev), chip->npwm,
1221 (chip->npwm != 1) ? "s" : "");
1222
1223 pwm_dbg_show(chip, s);
1224
1225 return 0;
1226}
1227
1228static const struct seq_operations pwm_debugfs_sops = {
1229 .start = pwm_seq_start,
1230 .next = pwm_seq_next,
1231 .stop = pwm_seq_stop,
1232 .show = pwm_seq_show,
1233};
1234
1235DEFINE_SEQ_ATTRIBUTE(pwm_debugfs);
1236
1237static int __init pwm_debugfs_init(void)
1238{
1239 debugfs_create_file("pwm", S_IFREG | 0444, NULL, NULL,
1240 &pwm_debugfs_fops);
1241
1242 return 0;
1243}
1244subsys_initcall(pwm_debugfs_init);
1245#endif
1246