1
2
3
4
5
6
7
8
9
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13#include <linux/clk.h>
14#include <linux/errno.h>
15#include <linux/err.h>
16#include <linux/slab.h>
17#include <linux/device.h>
18#include <linux/export.h>
19#include <linux/pm_domain.h>
20#include <linux/regulator/consumer.h>
21
22#include "opp.h"
23
24
25
26
27
28
29LIST_HEAD(opp_tables);
30
31DEFINE_MUTEX(opp_table_lock);
32
33static struct opp_device *_find_opp_dev(const struct device *dev,
34 struct opp_table *opp_table)
35{
36 struct opp_device *opp_dev;
37
38 list_for_each_entry(opp_dev, &opp_table->dev_list, node)
39 if (opp_dev->dev == dev)
40 return opp_dev;
41
42 return NULL;
43}
44
45static struct opp_table *_find_opp_table_unlocked(struct device *dev)
46{
47 struct opp_table *opp_table;
48 bool found;
49
50 list_for_each_entry(opp_table, &opp_tables, node) {
51 mutex_lock(&opp_table->lock);
52 found = !!_find_opp_dev(dev, opp_table);
53 mutex_unlock(&opp_table->lock);
54
55 if (found) {
56 _get_opp_table_kref(opp_table);
57
58 return opp_table;
59 }
60 }
61
62 return ERR_PTR(-ENODEV);
63}
64
65
66
67
68
69
70
71
72
73
74
75
76struct opp_table *_find_opp_table(struct device *dev)
77{
78 struct opp_table *opp_table;
79
80 if (IS_ERR_OR_NULL(dev)) {
81 pr_err("%s: Invalid parameters\n", __func__);
82 return ERR_PTR(-EINVAL);
83 }
84
85 mutex_lock(&opp_table_lock);
86 opp_table = _find_opp_table_unlocked(dev);
87 mutex_unlock(&opp_table_lock);
88
89 return opp_table;
90}
91
92
93
94
95
96
97
98
99
100
101unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
102{
103 if (IS_ERR_OR_NULL(opp)) {
104 pr_err("%s: Invalid parameters\n", __func__);
105 return 0;
106 }
107
108 return opp->supplies[0].u_volt;
109}
110EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
111
112
113
114
115
116
117
118
119unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
120{
121 if (IS_ERR_OR_NULL(opp) || !opp->available) {
122 pr_err("%s: Invalid parameters\n", __func__);
123 return 0;
124 }
125
126 return opp->rate;
127}
128EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
129
130
131
132
133
134
135
136
137unsigned int dev_pm_opp_get_level(struct dev_pm_opp *opp)
138{
139 if (IS_ERR_OR_NULL(opp) || !opp->available) {
140 pr_err("%s: Invalid parameters\n", __func__);
141 return 0;
142 }
143
144 return opp->level;
145}
146EXPORT_SYMBOL_GPL(dev_pm_opp_get_level);
147
148
149
150
151
152
153
154
155
156
157
158bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)
159{
160 if (IS_ERR_OR_NULL(opp) || !opp->available) {
161 pr_err("%s: Invalid parameters\n", __func__);
162 return false;
163 }
164
165 return opp->turbo;
166}
167EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo);
168
169
170
171
172
173
174
175unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)
176{
177 struct opp_table *opp_table;
178 unsigned long clock_latency_ns;
179
180 opp_table = _find_opp_table(dev);
181 if (IS_ERR(opp_table))
182 return 0;
183
184 clock_latency_ns = opp_table->clock_latency_ns_max;
185
186 dev_pm_opp_put_opp_table(opp_table);
187
188 return clock_latency_ns;
189}
190EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency);
191
192
193
194
195
196
197
198unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev)
199{
200 struct opp_table *opp_table;
201 struct dev_pm_opp *opp;
202 struct regulator *reg;
203 unsigned long latency_ns = 0;
204 int ret, i, count;
205 struct {
206 unsigned long min;
207 unsigned long max;
208 } *uV;
209
210 opp_table = _find_opp_table(dev);
211 if (IS_ERR(opp_table))
212 return 0;
213
214
215 if (!opp_table->regulators)
216 goto put_opp_table;
217
218 count = opp_table->regulator_count;
219
220 uV = kmalloc_array(count, sizeof(*uV), GFP_KERNEL);
221 if (!uV)
222 goto put_opp_table;
223
224 mutex_lock(&opp_table->lock);
225
226 for (i = 0; i < count; i++) {
227 uV[i].min = ~0;
228 uV[i].max = 0;
229
230 list_for_each_entry(opp, &opp_table->opp_list, node) {
231 if (!opp->available)
232 continue;
233
234 if (opp->supplies[i].u_volt_min < uV[i].min)
235 uV[i].min = opp->supplies[i].u_volt_min;
236 if (opp->supplies[i].u_volt_max > uV[i].max)
237 uV[i].max = opp->supplies[i].u_volt_max;
238 }
239 }
240
241 mutex_unlock(&opp_table->lock);
242
243
244
245
246
247 for (i = 0; i < count; i++) {
248 reg = opp_table->regulators[i];
249 ret = regulator_set_voltage_time(reg, uV[i].min, uV[i].max);
250 if (ret > 0)
251 latency_ns += ret * 1000;
252 }
253
254 kfree(uV);
255put_opp_table:
256 dev_pm_opp_put_opp_table(opp_table);
257
258 return latency_ns;
259}
260EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_volt_latency);
261
262
263
264
265
266
267
268
269
270unsigned long dev_pm_opp_get_max_transition_latency(struct device *dev)
271{
272 return dev_pm_opp_get_max_volt_latency(dev) +
273 dev_pm_opp_get_max_clock_latency(dev);
274}
275EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_transition_latency);
276
277
278
279
280
281
282
283
284unsigned long dev_pm_opp_get_suspend_opp_freq(struct device *dev)
285{
286 struct opp_table *opp_table;
287 unsigned long freq = 0;
288
289 opp_table = _find_opp_table(dev);
290 if (IS_ERR(opp_table))
291 return 0;
292
293 if (opp_table->suspend_opp && opp_table->suspend_opp->available)
294 freq = dev_pm_opp_get_freq(opp_table->suspend_opp);
295
296 dev_pm_opp_put_opp_table(opp_table);
297
298 return freq;
299}
300EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp_freq);
301
302int _get_opp_count(struct opp_table *opp_table)
303{
304 struct dev_pm_opp *opp;
305 int count = 0;
306
307 mutex_lock(&opp_table->lock);
308
309 list_for_each_entry(opp, &opp_table->opp_list, node) {
310 if (opp->available)
311 count++;
312 }
313
314 mutex_unlock(&opp_table->lock);
315
316 return count;
317}
318
319
320
321
322
323
324
325
326int dev_pm_opp_get_opp_count(struct device *dev)
327{
328 struct opp_table *opp_table;
329 int count;
330
331 opp_table = _find_opp_table(dev);
332 if (IS_ERR(opp_table)) {
333 count = PTR_ERR(opp_table);
334 dev_dbg(dev, "%s: OPP table not found (%d)\n",
335 __func__, count);
336 return count;
337 }
338
339 count = _get_opp_count(opp_table);
340 dev_pm_opp_put_opp_table(opp_table);
341
342 return count;
343}
344EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
370 unsigned long freq,
371 bool available)
372{
373 struct opp_table *opp_table;
374 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
375
376 opp_table = _find_opp_table(dev);
377 if (IS_ERR(opp_table)) {
378 int r = PTR_ERR(opp_table);
379
380 dev_err(dev, "%s: OPP table not found (%d)\n", __func__, r);
381 return ERR_PTR(r);
382 }
383
384 mutex_lock(&opp_table->lock);
385
386 list_for_each_entry(temp_opp, &opp_table->opp_list, node) {
387 if (temp_opp->available == available &&
388 temp_opp->rate == freq) {
389 opp = temp_opp;
390
391
392 dev_pm_opp_get(opp);
393 break;
394 }
395 }
396
397 mutex_unlock(&opp_table->lock);
398 dev_pm_opp_put_opp_table(opp_table);
399
400 return opp;
401}
402EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
403
404static noinline struct dev_pm_opp *_find_freq_ceil(struct opp_table *opp_table,
405 unsigned long *freq)
406{
407 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
408
409 mutex_lock(&opp_table->lock);
410
411 list_for_each_entry(temp_opp, &opp_table->opp_list, node) {
412 if (temp_opp->available && temp_opp->rate >= *freq) {
413 opp = temp_opp;
414 *freq = opp->rate;
415
416
417 dev_pm_opp_get(opp);
418 break;
419 }
420 }
421
422 mutex_unlock(&opp_table->lock);
423
424 return opp;
425}
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
446 unsigned long *freq)
447{
448 struct opp_table *opp_table;
449 struct dev_pm_opp *opp;
450
451 if (!dev || !freq) {
452 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
453 return ERR_PTR(-EINVAL);
454 }
455
456 opp_table = _find_opp_table(dev);
457 if (IS_ERR(opp_table))
458 return ERR_CAST(opp_table);
459
460 opp = _find_freq_ceil(opp_table, freq);
461
462 dev_pm_opp_put_opp_table(opp_table);
463
464 return opp;
465}
466EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
487 unsigned long *freq)
488{
489 struct opp_table *opp_table;
490 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
491
492 if (!dev || !freq) {
493 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
494 return ERR_PTR(-EINVAL);
495 }
496
497 opp_table = _find_opp_table(dev);
498 if (IS_ERR(opp_table))
499 return ERR_CAST(opp_table);
500
501 mutex_lock(&opp_table->lock);
502
503 list_for_each_entry(temp_opp, &opp_table->opp_list, node) {
504 if (temp_opp->available) {
505
506 if (temp_opp->rate > *freq)
507 break;
508 else
509 opp = temp_opp;
510 }
511 }
512
513
514 if (!IS_ERR(opp))
515 dev_pm_opp_get(opp);
516 mutex_unlock(&opp_table->lock);
517 dev_pm_opp_put_opp_table(opp_table);
518
519 if (!IS_ERR(opp))
520 *freq = opp->rate;
521
522 return opp;
523}
524EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543struct dev_pm_opp *dev_pm_opp_find_freq_ceil_by_volt(struct device *dev,
544 unsigned long u_volt)
545{
546 struct opp_table *opp_table;
547 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
548
549 if (!dev || !u_volt) {
550 dev_err(dev, "%s: Invalid argument volt=%lu\n", __func__,
551 u_volt);
552 return ERR_PTR(-EINVAL);
553 }
554
555 opp_table = _find_opp_table(dev);
556 if (IS_ERR(opp_table))
557 return ERR_CAST(opp_table);
558
559 mutex_lock(&opp_table->lock);
560
561 list_for_each_entry(temp_opp, &opp_table->opp_list, node) {
562 if (temp_opp->available) {
563 if (temp_opp->supplies[0].u_volt > u_volt)
564 break;
565 opp = temp_opp;
566 }
567 }
568
569
570 if (!IS_ERR(opp))
571 dev_pm_opp_get(opp);
572
573 mutex_unlock(&opp_table->lock);
574 dev_pm_opp_put_opp_table(opp_table);
575
576 return opp;
577}
578EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil_by_volt);
579
580static int _set_opp_voltage(struct device *dev, struct regulator *reg,
581 struct dev_pm_opp_supply *supply)
582{
583 int ret;
584
585
586 if (IS_ERR(reg)) {
587 dev_dbg(dev, "%s: regulator not available: %ld\n", __func__,
588 PTR_ERR(reg));
589 return 0;
590 }
591
592 dev_dbg(dev, "%s: voltages (mV): %lu %lu %lu\n", __func__,
593 supply->u_volt_min, supply->u_volt, supply->u_volt_max);
594
595 ret = regulator_set_voltage_triplet(reg, supply->u_volt_min,
596 supply->u_volt, supply->u_volt_max);
597 if (ret)
598 dev_err(dev, "%s: failed to set voltage (%lu %lu %lu mV): %d\n",
599 __func__, supply->u_volt_min, supply->u_volt,
600 supply->u_volt_max, ret);
601
602 return ret;
603}
604
605static inline int _generic_set_opp_clk_only(struct device *dev, struct clk *clk,
606 unsigned long freq)
607{
608 int ret;
609
610 ret = clk_set_rate(clk, freq);
611 if (ret) {
612 dev_err(dev, "%s: failed to set clock rate: %d\n", __func__,
613 ret);
614 }
615
616 return ret;
617}
618
619static int _generic_set_opp_regulator(const struct opp_table *opp_table,
620 struct device *dev,
621 unsigned long old_freq,
622 unsigned long freq,
623 struct dev_pm_opp_supply *old_supply,
624 struct dev_pm_opp_supply *new_supply)
625{
626 struct regulator *reg = opp_table->regulators[0];
627 int ret;
628
629
630 if (WARN_ON(opp_table->regulator_count > 1)) {
631 dev_err(dev, "multiple regulators are not supported\n");
632 return -EINVAL;
633 }
634
635
636 if (freq >= old_freq) {
637 ret = _set_opp_voltage(dev, reg, new_supply);
638 if (ret)
639 goto restore_voltage;
640 }
641
642
643 ret = _generic_set_opp_clk_only(dev, opp_table->clk, freq);
644 if (ret)
645 goto restore_voltage;
646
647
648 if (freq < old_freq) {
649 ret = _set_opp_voltage(dev, reg, new_supply);
650 if (ret)
651 goto restore_freq;
652 }
653
654 return 0;
655
656restore_freq:
657 if (_generic_set_opp_clk_only(dev, opp_table->clk, old_freq))
658 dev_err(dev, "%s: failed to restore old-freq (%lu Hz)\n",
659 __func__, old_freq);
660restore_voltage:
661
662 if (old_supply)
663 _set_opp_voltage(dev, reg, old_supply);
664
665 return ret;
666}
667
668static int _set_opp_custom(const struct opp_table *opp_table,
669 struct device *dev, unsigned long old_freq,
670 unsigned long freq,
671 struct dev_pm_opp_supply *old_supply,
672 struct dev_pm_opp_supply *new_supply)
673{
674 struct dev_pm_set_opp_data *data;
675 int size;
676
677 data = opp_table->set_opp_data;
678 data->regulators = opp_table->regulators;
679 data->regulator_count = opp_table->regulator_count;
680 data->clk = opp_table->clk;
681 data->dev = dev;
682
683 data->old_opp.rate = old_freq;
684 size = sizeof(*old_supply) * opp_table->regulator_count;
685 if (!old_supply)
686 memset(data->old_opp.supplies, 0, size);
687 else
688 memcpy(data->old_opp.supplies, old_supply, size);
689
690 data->new_opp.rate = freq;
691 memcpy(data->new_opp.supplies, new_supply, size);
692
693 return opp_table->set_opp(data);
694}
695
696
697static int _set_required_opps(struct device *dev,
698 struct opp_table *opp_table,
699 struct dev_pm_opp *opp)
700{
701 struct opp_table **required_opp_tables = opp_table->required_opp_tables;
702 struct device **genpd_virt_devs = opp_table->genpd_virt_devs;
703 unsigned int pstate;
704 int i, ret = 0;
705
706 if (!required_opp_tables)
707 return 0;
708
709
710 if (!genpd_virt_devs) {
711 pstate = likely(opp) ? opp->required_opps[0]->pstate : 0;
712 ret = dev_pm_genpd_set_performance_state(dev, pstate);
713 if (ret) {
714 dev_err(dev, "Failed to set performance state of %s: %d (%d)\n",
715 dev_name(dev), pstate, ret);
716 }
717 return ret;
718 }
719
720
721
722
723
724
725
726 mutex_lock(&opp_table->genpd_virt_dev_lock);
727
728 for (i = 0; i < opp_table->required_opp_count; i++) {
729 pstate = likely(opp) ? opp->required_opps[i]->pstate : 0;
730
731 if (!genpd_virt_devs[i])
732 continue;
733
734 ret = dev_pm_genpd_set_performance_state(genpd_virt_devs[i], pstate);
735 if (ret) {
736 dev_err(dev, "Failed to set performance rate of %s: %d (%d)\n",
737 dev_name(genpd_virt_devs[i]), pstate, ret);
738 break;
739 }
740 }
741 mutex_unlock(&opp_table->genpd_virt_dev_lock);
742
743 return ret;
744}
745
746
747
748
749
750
751
752
753
754
755
756
757int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq)
758{
759 struct opp_table *opp_table;
760 unsigned long freq, old_freq, temp_freq;
761 struct dev_pm_opp *old_opp, *opp;
762 struct clk *clk;
763 int ret;
764
765 opp_table = _find_opp_table(dev);
766 if (IS_ERR(opp_table)) {
767 dev_err(dev, "%s: device opp doesn't exist\n", __func__);
768 return PTR_ERR(opp_table);
769 }
770
771 if (unlikely(!target_freq)) {
772 if (opp_table->required_opp_tables) {
773 ret = _set_required_opps(dev, opp_table, NULL);
774 } else {
775 dev_err(dev, "target frequency can't be 0\n");
776 ret = -EINVAL;
777 }
778
779 goto put_opp_table;
780 }
781
782 clk = opp_table->clk;
783 if (IS_ERR(clk)) {
784 dev_err(dev, "%s: No clock available for the device\n",
785 __func__);
786 ret = PTR_ERR(clk);
787 goto put_opp_table;
788 }
789
790 freq = clk_round_rate(clk, target_freq);
791 if ((long)freq <= 0)
792 freq = target_freq;
793
794 old_freq = clk_get_rate(clk);
795
796
797 if (old_freq == freq) {
798 dev_dbg(dev, "%s: old/new frequencies (%lu Hz) are same, nothing to do\n",
799 __func__, freq);
800 ret = 0;
801 goto put_opp_table;
802 }
803
804 temp_freq = old_freq;
805 old_opp = _find_freq_ceil(opp_table, &temp_freq);
806 if (IS_ERR(old_opp)) {
807 dev_err(dev, "%s: failed to find current OPP for freq %lu (%ld)\n",
808 __func__, old_freq, PTR_ERR(old_opp));
809 }
810
811 temp_freq = freq;
812 opp = _find_freq_ceil(opp_table, &temp_freq);
813 if (IS_ERR(opp)) {
814 ret = PTR_ERR(opp);
815 dev_err(dev, "%s: failed to find OPP for freq %lu (%d)\n",
816 __func__, freq, ret);
817 goto put_old_opp;
818 }
819
820 dev_dbg(dev, "%s: switching OPP: %lu Hz --> %lu Hz\n", __func__,
821 old_freq, freq);
822
823
824 if (freq >= old_freq) {
825 ret = _set_required_opps(dev, opp_table, opp);
826 if (ret)
827 goto put_opp;
828 }
829
830 if (opp_table->set_opp) {
831 ret = _set_opp_custom(opp_table, dev, old_freq, freq,
832 IS_ERR(old_opp) ? NULL : old_opp->supplies,
833 opp->supplies);
834 } else if (opp_table->regulators) {
835 ret = _generic_set_opp_regulator(opp_table, dev, old_freq, freq,
836 IS_ERR(old_opp) ? NULL : old_opp->supplies,
837 opp->supplies);
838 } else {
839
840 ret = _generic_set_opp_clk_only(dev, clk, freq);
841 }
842
843
844 if (!ret && freq < old_freq) {
845 ret = _set_required_opps(dev, opp_table, opp);
846 if (ret)
847 dev_err(dev, "Failed to set required opps: %d\n", ret);
848 }
849
850put_opp:
851 dev_pm_opp_put(opp);
852put_old_opp:
853 if (!IS_ERR(old_opp))
854 dev_pm_opp_put(old_opp);
855put_opp_table:
856 dev_pm_opp_put_opp_table(opp_table);
857 return ret;
858}
859EXPORT_SYMBOL_GPL(dev_pm_opp_set_rate);
860
861
862static void _remove_opp_dev(struct opp_device *opp_dev,
863 struct opp_table *opp_table)
864{
865 opp_debug_unregister(opp_dev, opp_table);
866 list_del(&opp_dev->node);
867 kfree(opp_dev);
868}
869
870static struct opp_device *_add_opp_dev_unlocked(const struct device *dev,
871 struct opp_table *opp_table)
872{
873 struct opp_device *opp_dev;
874
875 opp_dev = kzalloc(sizeof(*opp_dev), GFP_KERNEL);
876 if (!opp_dev)
877 return NULL;
878
879
880 opp_dev->dev = dev;
881
882 list_add(&opp_dev->node, &opp_table->dev_list);
883
884
885 opp_debug_register(opp_dev, opp_table);
886
887 return opp_dev;
888}
889
890struct opp_device *_add_opp_dev(const struct device *dev,
891 struct opp_table *opp_table)
892{
893 struct opp_device *opp_dev;
894
895 mutex_lock(&opp_table->lock);
896 opp_dev = _add_opp_dev_unlocked(dev, opp_table);
897 mutex_unlock(&opp_table->lock);
898
899 return opp_dev;
900}
901
902static struct opp_table *_allocate_opp_table(struct device *dev, int index)
903{
904 struct opp_table *opp_table;
905 struct opp_device *opp_dev;
906 int ret;
907
908
909
910
911
912 opp_table = kzalloc(sizeof(*opp_table), GFP_KERNEL);
913 if (!opp_table)
914 return NULL;
915
916 mutex_init(&opp_table->lock);
917 mutex_init(&opp_table->genpd_virt_dev_lock);
918 INIT_LIST_HEAD(&opp_table->dev_list);
919
920
921 opp_table->regulator_count = -1;
922
923 opp_dev = _add_opp_dev(dev, opp_table);
924 if (!opp_dev) {
925 kfree(opp_table);
926 return NULL;
927 }
928
929 _of_init_opp_table(opp_table, dev, index);
930
931
932 opp_table->clk = clk_get(dev, NULL);
933 if (IS_ERR(opp_table->clk)) {
934 ret = PTR_ERR(opp_table->clk);
935 if (ret != -EPROBE_DEFER)
936 dev_dbg(dev, "%s: Couldn't find clock: %d\n", __func__,
937 ret);
938 }
939
940 BLOCKING_INIT_NOTIFIER_HEAD(&opp_table->head);
941 INIT_LIST_HEAD(&opp_table->opp_list);
942 kref_init(&opp_table->kref);
943
944
945 list_add(&opp_table->node, &opp_tables);
946 return opp_table;
947}
948
949void _get_opp_table_kref(struct opp_table *opp_table)
950{
951 kref_get(&opp_table->kref);
952}
953
954static struct opp_table *_opp_get_opp_table(struct device *dev, int index)
955{
956 struct opp_table *opp_table;
957
958
959 mutex_lock(&opp_table_lock);
960
961 opp_table = _find_opp_table_unlocked(dev);
962 if (!IS_ERR(opp_table))
963 goto unlock;
964
965 opp_table = _managed_opp(dev, index);
966 if (opp_table) {
967 if (!_add_opp_dev_unlocked(dev, opp_table)) {
968 dev_pm_opp_put_opp_table(opp_table);
969 opp_table = NULL;
970 }
971 goto unlock;
972 }
973
974 opp_table = _allocate_opp_table(dev, index);
975
976unlock:
977 mutex_unlock(&opp_table_lock);
978
979 return opp_table;
980}
981
982struct opp_table *dev_pm_opp_get_opp_table(struct device *dev)
983{
984 return _opp_get_opp_table(dev, 0);
985}
986EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_table);
987
988struct opp_table *dev_pm_opp_get_opp_table_indexed(struct device *dev,
989 int index)
990{
991 return _opp_get_opp_table(dev, index);
992}
993
994static void _opp_table_kref_release(struct kref *kref)
995{
996 struct opp_table *opp_table = container_of(kref, struct opp_table, kref);
997 struct opp_device *opp_dev, *temp;
998
999 _of_clear_opp_table(opp_table);
1000
1001
1002 if (!IS_ERR(opp_table->clk))
1003 clk_put(opp_table->clk);
1004
1005 WARN_ON(!list_empty(&opp_table->opp_list));
1006
1007 list_for_each_entry_safe(opp_dev, temp, &opp_table->dev_list, node) {
1008
1009
1010
1011
1012 if (opp_table->genpd_performance_state)
1013 dev_pm_genpd_set_performance_state((struct device *)(opp_dev->dev), 0);
1014
1015 _remove_opp_dev(opp_dev, opp_table);
1016 }
1017
1018 mutex_destroy(&opp_table->genpd_virt_dev_lock);
1019 mutex_destroy(&opp_table->lock);
1020 list_del(&opp_table->node);
1021 kfree(opp_table);
1022
1023 mutex_unlock(&opp_table_lock);
1024}
1025
1026void _opp_remove_all_static(struct opp_table *opp_table)
1027{
1028 struct dev_pm_opp *opp, *tmp;
1029
1030 list_for_each_entry_safe(opp, tmp, &opp_table->opp_list, node) {
1031 if (!opp->dynamic)
1032 dev_pm_opp_put(opp);
1033 }
1034
1035 opp_table->parsed_static_opps = false;
1036}
1037
1038static void _opp_table_list_kref_release(struct kref *kref)
1039{
1040 struct opp_table *opp_table = container_of(kref, struct opp_table,
1041 list_kref);
1042
1043 _opp_remove_all_static(opp_table);
1044 mutex_unlock(&opp_table_lock);
1045}
1046
1047void _put_opp_list_kref(struct opp_table *opp_table)
1048{
1049 kref_put_mutex(&opp_table->list_kref, _opp_table_list_kref_release,
1050 &opp_table_lock);
1051}
1052
1053void dev_pm_opp_put_opp_table(struct opp_table *opp_table)
1054{
1055 kref_put_mutex(&opp_table->kref, _opp_table_kref_release,
1056 &opp_table_lock);
1057}
1058EXPORT_SYMBOL_GPL(dev_pm_opp_put_opp_table);
1059
1060void _opp_free(struct dev_pm_opp *opp)
1061{
1062 kfree(opp);
1063}
1064
1065static void _opp_kref_release(struct dev_pm_opp *opp,
1066 struct opp_table *opp_table)
1067{
1068
1069
1070
1071
1072 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_REMOVE, opp);
1073 _of_opp_free_required_opps(opp_table, opp);
1074 opp_debug_remove_one(opp);
1075 list_del(&opp->node);
1076 kfree(opp);
1077}
1078
1079static void _opp_kref_release_unlocked(struct kref *kref)
1080{
1081 struct dev_pm_opp *opp = container_of(kref, struct dev_pm_opp, kref);
1082 struct opp_table *opp_table = opp->opp_table;
1083
1084 _opp_kref_release(opp, opp_table);
1085}
1086
1087static void _opp_kref_release_locked(struct kref *kref)
1088{
1089 struct dev_pm_opp *opp = container_of(kref, struct dev_pm_opp, kref);
1090 struct opp_table *opp_table = opp->opp_table;
1091
1092 _opp_kref_release(opp, opp_table);
1093 mutex_unlock(&opp_table->lock);
1094}
1095
1096void dev_pm_opp_get(struct dev_pm_opp *opp)
1097{
1098 kref_get(&opp->kref);
1099}
1100
1101void dev_pm_opp_put(struct dev_pm_opp *opp)
1102{
1103 kref_put_mutex(&opp->kref, _opp_kref_release_locked,
1104 &opp->opp_table->lock);
1105}
1106EXPORT_SYMBOL_GPL(dev_pm_opp_put);
1107
1108static void dev_pm_opp_put_unlocked(struct dev_pm_opp *opp)
1109{
1110 kref_put(&opp->kref, _opp_kref_release_unlocked);
1111}
1112
1113
1114
1115
1116
1117
1118
1119
1120void dev_pm_opp_remove(struct device *dev, unsigned long freq)
1121{
1122 struct dev_pm_opp *opp;
1123 struct opp_table *opp_table;
1124 bool found = false;
1125
1126 opp_table = _find_opp_table(dev);
1127 if (IS_ERR(opp_table))
1128 return;
1129
1130 mutex_lock(&opp_table->lock);
1131
1132 list_for_each_entry(opp, &opp_table->opp_list, node) {
1133 if (opp->rate == freq) {
1134 found = true;
1135 break;
1136 }
1137 }
1138
1139 mutex_unlock(&opp_table->lock);
1140
1141 if (found) {
1142 dev_pm_opp_put(opp);
1143
1144
1145 dev_pm_opp_put_opp_table(opp_table);
1146 } else {
1147 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
1148 __func__, freq);
1149 }
1150
1151
1152 dev_pm_opp_put_opp_table(opp_table);
1153}
1154EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
1155
1156
1157
1158
1159
1160
1161
1162void dev_pm_opp_remove_all_dynamic(struct device *dev)
1163{
1164 struct opp_table *opp_table;
1165 struct dev_pm_opp *opp, *temp;
1166 int count = 0;
1167
1168 opp_table = _find_opp_table(dev);
1169 if (IS_ERR(opp_table))
1170 return;
1171
1172 mutex_lock(&opp_table->lock);
1173 list_for_each_entry_safe(opp, temp, &opp_table->opp_list, node) {
1174 if (opp->dynamic) {
1175 dev_pm_opp_put_unlocked(opp);
1176 count++;
1177 }
1178 }
1179 mutex_unlock(&opp_table->lock);
1180
1181
1182 while (count--)
1183 dev_pm_opp_put_opp_table(opp_table);
1184
1185
1186 dev_pm_opp_put_opp_table(opp_table);
1187}
1188EXPORT_SYMBOL_GPL(dev_pm_opp_remove_all_dynamic);
1189
1190struct dev_pm_opp *_opp_allocate(struct opp_table *table)
1191{
1192 struct dev_pm_opp *opp;
1193 int count, supply_size;
1194
1195
1196 count = table->regulator_count > 0 ? table->regulator_count : 1;
1197 supply_size = sizeof(*opp->supplies) * count;
1198
1199
1200 opp = kzalloc(sizeof(*opp) + supply_size, GFP_KERNEL);
1201 if (!opp)
1202 return NULL;
1203
1204
1205 opp->supplies = (struct dev_pm_opp_supply *)(opp + 1);
1206 INIT_LIST_HEAD(&opp->node);
1207
1208 return opp;
1209}
1210
1211static bool _opp_supported_by_regulators(struct dev_pm_opp *opp,
1212 struct opp_table *opp_table)
1213{
1214 struct regulator *reg;
1215 int i;
1216
1217 if (!opp_table->regulators)
1218 return true;
1219
1220 for (i = 0; i < opp_table->regulator_count; i++) {
1221 reg = opp_table->regulators[i];
1222
1223 if (!regulator_is_supported_voltage(reg,
1224 opp->supplies[i].u_volt_min,
1225 opp->supplies[i].u_volt_max)) {
1226 pr_warn("%s: OPP minuV: %lu maxuV: %lu, not supported by regulator\n",
1227 __func__, opp->supplies[i].u_volt_min,
1228 opp->supplies[i].u_volt_max);
1229 return false;
1230 }
1231 }
1232
1233 return true;
1234}
1235
1236static int _opp_is_duplicate(struct device *dev, struct dev_pm_opp *new_opp,
1237 struct opp_table *opp_table,
1238 struct list_head **head)
1239{
1240 struct dev_pm_opp *opp;
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250 list_for_each_entry(opp, &opp_table->opp_list, node) {
1251 if (new_opp->rate > opp->rate) {
1252 *head = &opp->node;
1253 continue;
1254 }
1255
1256 if (new_opp->rate < opp->rate)
1257 return 0;
1258
1259
1260 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
1261 __func__, opp->rate, opp->supplies[0].u_volt,
1262 opp->available, new_opp->rate,
1263 new_opp->supplies[0].u_volt, new_opp->available);
1264
1265
1266 return opp->available &&
1267 new_opp->supplies[0].u_volt == opp->supplies[0].u_volt ? -EBUSY : -EEXIST;
1268 }
1269
1270 return 0;
1271}
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,
1284 struct opp_table *opp_table, bool rate_not_available)
1285{
1286 struct list_head *head;
1287 int ret;
1288
1289 mutex_lock(&opp_table->lock);
1290 head = &opp_table->opp_list;
1291
1292 if (likely(!rate_not_available)) {
1293 ret = _opp_is_duplicate(dev, new_opp, opp_table, &head);
1294 if (ret) {
1295 mutex_unlock(&opp_table->lock);
1296 return ret;
1297 }
1298 }
1299
1300 list_add(&new_opp->node, head);
1301 mutex_unlock(&opp_table->lock);
1302
1303 new_opp->opp_table = opp_table;
1304 kref_init(&new_opp->kref);
1305
1306 opp_debug_create_one(new_opp, opp_table);
1307
1308 if (!_opp_supported_by_regulators(new_opp, opp_table)) {
1309 new_opp->available = false;
1310 dev_warn(dev, "%s: OPP not supported by regulators (%lu)\n",
1311 __func__, new_opp->rate);
1312 }
1313
1314 return 0;
1315}
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339int _opp_add_v1(struct opp_table *opp_table, struct device *dev,
1340 unsigned long freq, long u_volt, bool dynamic)
1341{
1342 struct dev_pm_opp *new_opp;
1343 unsigned long tol;
1344 int ret;
1345
1346 new_opp = _opp_allocate(opp_table);
1347 if (!new_opp)
1348 return -ENOMEM;
1349
1350
1351 new_opp->rate = freq;
1352 tol = u_volt * opp_table->voltage_tolerance_v1 / 100;
1353 new_opp->supplies[0].u_volt = u_volt;
1354 new_opp->supplies[0].u_volt_min = u_volt - tol;
1355 new_opp->supplies[0].u_volt_max = u_volt + tol;
1356 new_opp->available = true;
1357 new_opp->dynamic = dynamic;
1358
1359 ret = _opp_add(dev, new_opp, opp_table, false);
1360 if (ret) {
1361
1362 if (ret == -EBUSY)
1363 ret = 0;
1364 goto free_opp;
1365 }
1366
1367
1368
1369
1370
1371 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp);
1372 return 0;
1373
1374free_opp:
1375 _opp_free(new_opp);
1376
1377 return ret;
1378}
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391struct opp_table *dev_pm_opp_set_supported_hw(struct device *dev,
1392 const u32 *versions, unsigned int count)
1393{
1394 struct opp_table *opp_table;
1395
1396 opp_table = dev_pm_opp_get_opp_table(dev);
1397 if (!opp_table)
1398 return ERR_PTR(-ENOMEM);
1399
1400
1401 WARN_ON(!list_empty(&opp_table->opp_list));
1402
1403
1404 if (opp_table->supported_hw)
1405 return opp_table;
1406
1407 opp_table->supported_hw = kmemdup(versions, count * sizeof(*versions),
1408 GFP_KERNEL);
1409 if (!opp_table->supported_hw) {
1410 dev_pm_opp_put_opp_table(opp_table);
1411 return ERR_PTR(-ENOMEM);
1412 }
1413
1414 opp_table->supported_hw_count = count;
1415
1416 return opp_table;
1417}
1418EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw);
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428void dev_pm_opp_put_supported_hw(struct opp_table *opp_table)
1429{
1430
1431 WARN_ON(!list_empty(&opp_table->opp_list));
1432
1433 kfree(opp_table->supported_hw);
1434 opp_table->supported_hw = NULL;
1435 opp_table->supported_hw_count = 0;
1436
1437 dev_pm_opp_put_opp_table(opp_table);
1438}
1439EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw);
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451struct opp_table *dev_pm_opp_set_prop_name(struct device *dev, const char *name)
1452{
1453 struct opp_table *opp_table;
1454
1455 opp_table = dev_pm_opp_get_opp_table(dev);
1456 if (!opp_table)
1457 return ERR_PTR(-ENOMEM);
1458
1459
1460 WARN_ON(!list_empty(&opp_table->opp_list));
1461
1462
1463 if (opp_table->prop_name)
1464 return opp_table;
1465
1466 opp_table->prop_name = kstrdup(name, GFP_KERNEL);
1467 if (!opp_table->prop_name) {
1468 dev_pm_opp_put_opp_table(opp_table);
1469 return ERR_PTR(-ENOMEM);
1470 }
1471
1472 return opp_table;
1473}
1474EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name);
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484void dev_pm_opp_put_prop_name(struct opp_table *opp_table)
1485{
1486
1487 WARN_ON(!list_empty(&opp_table->opp_list));
1488
1489 kfree(opp_table->prop_name);
1490 opp_table->prop_name = NULL;
1491
1492 dev_pm_opp_put_opp_table(opp_table);
1493}
1494EXPORT_SYMBOL_GPL(dev_pm_opp_put_prop_name);
1495
1496static int _allocate_set_opp_data(struct opp_table *opp_table)
1497{
1498 struct dev_pm_set_opp_data *data;
1499 int len, count = opp_table->regulator_count;
1500
1501 if (WARN_ON(!opp_table->regulators))
1502 return -EINVAL;
1503
1504
1505 len = sizeof(*data);
1506
1507
1508 len += 2 * sizeof(struct dev_pm_opp_supply) * count;
1509
1510 data = kzalloc(len, GFP_KERNEL);
1511 if (!data)
1512 return -ENOMEM;
1513
1514 data->old_opp.supplies = (void *)(data + 1);
1515 data->new_opp.supplies = data->old_opp.supplies + count;
1516
1517 opp_table->set_opp_data = data;
1518
1519 return 0;
1520}
1521
1522static void _free_set_opp_data(struct opp_table *opp_table)
1523{
1524 kfree(opp_table->set_opp_data);
1525 opp_table->set_opp_data = NULL;
1526}
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540struct opp_table *dev_pm_opp_set_regulators(struct device *dev,
1541 const char * const names[],
1542 unsigned int count)
1543{
1544 struct opp_table *opp_table;
1545 struct regulator *reg;
1546 int ret, i;
1547
1548 opp_table = dev_pm_opp_get_opp_table(dev);
1549 if (!opp_table)
1550 return ERR_PTR(-ENOMEM);
1551
1552
1553 if (WARN_ON(!list_empty(&opp_table->opp_list))) {
1554 ret = -EBUSY;
1555 goto err;
1556 }
1557
1558
1559 if (opp_table->regulators)
1560 return opp_table;
1561
1562 opp_table->regulators = kmalloc_array(count,
1563 sizeof(*opp_table->regulators),
1564 GFP_KERNEL);
1565 if (!opp_table->regulators) {
1566 ret = -ENOMEM;
1567 goto err;
1568 }
1569
1570 for (i = 0; i < count; i++) {
1571 reg = regulator_get_optional(dev, names[i]);
1572 if (IS_ERR(reg)) {
1573 ret = PTR_ERR(reg);
1574 if (ret != -EPROBE_DEFER)
1575 dev_err(dev, "%s: no regulator (%s) found: %d\n",
1576 __func__, names[i], ret);
1577 goto free_regulators;
1578 }
1579
1580 opp_table->regulators[i] = reg;
1581 }
1582
1583 opp_table->regulator_count = count;
1584
1585
1586 ret = _allocate_set_opp_data(opp_table);
1587 if (ret)
1588 goto free_regulators;
1589
1590 return opp_table;
1591
1592free_regulators:
1593 while (i != 0)
1594 regulator_put(opp_table->regulators[--i]);
1595
1596 kfree(opp_table->regulators);
1597 opp_table->regulators = NULL;
1598 opp_table->regulator_count = -1;
1599err:
1600 dev_pm_opp_put_opp_table(opp_table);
1601
1602 return ERR_PTR(ret);
1603}
1604EXPORT_SYMBOL_GPL(dev_pm_opp_set_regulators);
1605
1606
1607
1608
1609
1610void dev_pm_opp_put_regulators(struct opp_table *opp_table)
1611{
1612 int i;
1613
1614 if (!opp_table->regulators)
1615 goto put_opp_table;
1616
1617
1618 WARN_ON(!list_empty(&opp_table->opp_list));
1619
1620 for (i = opp_table->regulator_count - 1; i >= 0; i--)
1621 regulator_put(opp_table->regulators[i]);
1622
1623 _free_set_opp_data(opp_table);
1624
1625 kfree(opp_table->regulators);
1626 opp_table->regulators = NULL;
1627 opp_table->regulator_count = -1;
1628
1629put_opp_table:
1630 dev_pm_opp_put_opp_table(opp_table);
1631}
1632EXPORT_SYMBOL_GPL(dev_pm_opp_put_regulators);
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646struct opp_table *dev_pm_opp_set_clkname(struct device *dev, const char *name)
1647{
1648 struct opp_table *opp_table;
1649 int ret;
1650
1651 opp_table = dev_pm_opp_get_opp_table(dev);
1652 if (!opp_table)
1653 return ERR_PTR(-ENOMEM);
1654
1655
1656 if (WARN_ON(!list_empty(&opp_table->opp_list))) {
1657 ret = -EBUSY;
1658 goto err;
1659 }
1660
1661
1662 if (!IS_ERR(opp_table->clk))
1663 clk_put(opp_table->clk);
1664
1665
1666 opp_table->clk = clk_get(dev, name);
1667 if (IS_ERR(opp_table->clk)) {
1668 ret = PTR_ERR(opp_table->clk);
1669 if (ret != -EPROBE_DEFER) {
1670 dev_err(dev, "%s: Couldn't find clock: %d\n", __func__,
1671 ret);
1672 }
1673 goto err;
1674 }
1675
1676 return opp_table;
1677
1678err:
1679 dev_pm_opp_put_opp_table(opp_table);
1680
1681 return ERR_PTR(ret);
1682}
1683EXPORT_SYMBOL_GPL(dev_pm_opp_set_clkname);
1684
1685
1686
1687
1688
1689void dev_pm_opp_put_clkname(struct opp_table *opp_table)
1690{
1691
1692 WARN_ON(!list_empty(&opp_table->opp_list));
1693
1694 clk_put(opp_table->clk);
1695 opp_table->clk = ERR_PTR(-EINVAL);
1696
1697 dev_pm_opp_put_opp_table(opp_table);
1698}
1699EXPORT_SYMBOL_GPL(dev_pm_opp_put_clkname);
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711struct opp_table *dev_pm_opp_register_set_opp_helper(struct device *dev,
1712 int (*set_opp)(struct dev_pm_set_opp_data *data))
1713{
1714 struct opp_table *opp_table;
1715
1716 if (!set_opp)
1717 return ERR_PTR(-EINVAL);
1718
1719 opp_table = dev_pm_opp_get_opp_table(dev);
1720 if (!opp_table)
1721 return ERR_PTR(-ENOMEM);
1722
1723
1724 if (WARN_ON(!list_empty(&opp_table->opp_list))) {
1725 dev_pm_opp_put_opp_table(opp_table);
1726 return ERR_PTR(-EBUSY);
1727 }
1728
1729
1730 if (!opp_table->set_opp)
1731 opp_table->set_opp = set_opp;
1732
1733 return opp_table;
1734}
1735EXPORT_SYMBOL_GPL(dev_pm_opp_register_set_opp_helper);
1736
1737
1738
1739
1740
1741
1742
1743
1744void dev_pm_opp_unregister_set_opp_helper(struct opp_table *opp_table)
1745{
1746
1747 WARN_ON(!list_empty(&opp_table->opp_list));
1748
1749 opp_table->set_opp = NULL;
1750 dev_pm_opp_put_opp_table(opp_table);
1751}
1752EXPORT_SYMBOL_GPL(dev_pm_opp_unregister_set_opp_helper);
1753
1754static void _opp_detach_genpd(struct opp_table *opp_table)
1755{
1756 int index;
1757
1758 for (index = 0; index < opp_table->required_opp_count; index++) {
1759 if (!opp_table->genpd_virt_devs[index])
1760 continue;
1761
1762 dev_pm_domain_detach(opp_table->genpd_virt_devs[index], false);
1763 opp_table->genpd_virt_devs[index] = NULL;
1764 }
1765
1766 kfree(opp_table->genpd_virt_devs);
1767 opp_table->genpd_virt_devs = NULL;
1768}
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788struct opp_table *dev_pm_opp_attach_genpd(struct device *dev, const char **names)
1789{
1790 struct opp_table *opp_table;
1791 struct device *virt_dev;
1792 int index, ret = -EINVAL;
1793 const char **name = names;
1794
1795 opp_table = dev_pm_opp_get_opp_table(dev);
1796 if (!opp_table)
1797 return ERR_PTR(-ENOMEM);
1798
1799
1800
1801
1802
1803
1804 if (!opp_table->required_opp_count) {
1805 ret = -EPROBE_DEFER;
1806 goto put_table;
1807 }
1808
1809 mutex_lock(&opp_table->genpd_virt_dev_lock);
1810
1811 opp_table->genpd_virt_devs = kcalloc(opp_table->required_opp_count,
1812 sizeof(*opp_table->genpd_virt_devs),
1813 GFP_KERNEL);
1814 if (!opp_table->genpd_virt_devs)
1815 goto unlock;
1816
1817 while (*name) {
1818 index = of_property_match_string(dev->of_node,
1819 "power-domain-names", *name);
1820 if (index < 0) {
1821 dev_err(dev, "Failed to find power domain: %s (%d)\n",
1822 *name, index);
1823 goto err;
1824 }
1825
1826 if (index >= opp_table->required_opp_count) {
1827 dev_err(dev, "Index can't be greater than required-opp-count - 1, %s (%d : %d)\n",
1828 *name, opp_table->required_opp_count, index);
1829 goto err;
1830 }
1831
1832 if (opp_table->genpd_virt_devs[index]) {
1833 dev_err(dev, "Genpd virtual device already set %s\n",
1834 *name);
1835 goto err;
1836 }
1837
1838 virt_dev = dev_pm_domain_attach_by_name(dev, *name);
1839 if (IS_ERR(virt_dev)) {
1840 ret = PTR_ERR(virt_dev);
1841 dev_err(dev, "Couldn't attach to pm_domain: %d\n", ret);
1842 goto err;
1843 }
1844
1845 opp_table->genpd_virt_devs[index] = virt_dev;
1846 name++;
1847 }
1848
1849 mutex_unlock(&opp_table->genpd_virt_dev_lock);
1850
1851 return opp_table;
1852
1853err:
1854 _opp_detach_genpd(opp_table);
1855unlock:
1856 mutex_unlock(&opp_table->genpd_virt_dev_lock);
1857
1858put_table:
1859 dev_pm_opp_put_opp_table(opp_table);
1860
1861 return ERR_PTR(ret);
1862}
1863EXPORT_SYMBOL_GPL(dev_pm_opp_attach_genpd);
1864
1865
1866
1867
1868
1869
1870
1871
1872void dev_pm_opp_detach_genpd(struct opp_table *opp_table)
1873{
1874
1875
1876
1877
1878 mutex_lock(&opp_table->genpd_virt_dev_lock);
1879 _opp_detach_genpd(opp_table);
1880 mutex_unlock(&opp_table->genpd_virt_dev_lock);
1881
1882 dev_pm_opp_put_opp_table(opp_table);
1883}
1884EXPORT_SYMBOL_GPL(dev_pm_opp_detach_genpd);
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899int dev_pm_opp_xlate_performance_state(struct opp_table *src_table,
1900 struct opp_table *dst_table,
1901 unsigned int pstate)
1902{
1903 struct dev_pm_opp *opp;
1904 int dest_pstate = -EINVAL;
1905 int i;
1906
1907 if (!pstate)
1908 return 0;
1909
1910
1911
1912
1913
1914
1915
1916
1917 if (!src_table->required_opp_count)
1918 return pstate;
1919
1920 for (i = 0; i < src_table->required_opp_count; i++) {
1921 if (src_table->required_opp_tables[i]->np == dst_table->np)
1922 break;
1923 }
1924
1925 if (unlikely(i == src_table->required_opp_count)) {
1926 pr_err("%s: Couldn't find matching OPP table (%p: %p)\n",
1927 __func__, src_table, dst_table);
1928 return -EINVAL;
1929 }
1930
1931 mutex_lock(&src_table->lock);
1932
1933 list_for_each_entry(opp, &src_table->opp_list, node) {
1934 if (opp->pstate == pstate) {
1935 dest_pstate = opp->required_opps[i]->pstate;
1936 goto unlock;
1937 }
1938 }
1939
1940 pr_err("%s: Couldn't find matching OPP (%p: %p)\n", __func__, src_table,
1941 dst_table);
1942
1943unlock:
1944 mutex_unlock(&src_table->lock);
1945
1946 return dest_pstate;
1947}
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
1967{
1968 struct opp_table *opp_table;
1969 int ret;
1970
1971 opp_table = dev_pm_opp_get_opp_table(dev);
1972 if (!opp_table)
1973 return -ENOMEM;
1974
1975
1976 opp_table->regulator_count = 1;
1977
1978 ret = _opp_add_v1(opp_table, dev, freq, u_volt, true);
1979 if (ret)
1980 dev_pm_opp_put_opp_table(opp_table);
1981
1982 return ret;
1983}
1984EXPORT_SYMBOL_GPL(dev_pm_opp_add);
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999static int _opp_set_availability(struct device *dev, unsigned long freq,
2000 bool availability_req)
2001{
2002 struct opp_table *opp_table;
2003 struct dev_pm_opp *tmp_opp, *opp = ERR_PTR(-ENODEV);
2004 int r = 0;
2005
2006
2007 opp_table = _find_opp_table(dev);
2008 if (IS_ERR(opp_table)) {
2009 r = PTR_ERR(opp_table);
2010 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
2011 return r;
2012 }
2013
2014 mutex_lock(&opp_table->lock);
2015
2016
2017 list_for_each_entry(tmp_opp, &opp_table->opp_list, node) {
2018 if (tmp_opp->rate == freq) {
2019 opp = tmp_opp;
2020 break;
2021 }
2022 }
2023
2024 if (IS_ERR(opp)) {
2025 r = PTR_ERR(opp);
2026 goto unlock;
2027 }
2028
2029
2030 if (opp->available == availability_req)
2031 goto unlock;
2032
2033 opp->available = availability_req;
2034
2035 dev_pm_opp_get(opp);
2036 mutex_unlock(&opp_table->lock);
2037
2038
2039 if (availability_req)
2040 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ENABLE,
2041 opp);
2042 else
2043 blocking_notifier_call_chain(&opp_table->head,
2044 OPP_EVENT_DISABLE, opp);
2045
2046 dev_pm_opp_put(opp);
2047 goto put_table;
2048
2049unlock:
2050 mutex_unlock(&opp_table->lock);
2051put_table:
2052 dev_pm_opp_put_opp_table(opp_table);
2053 return r;
2054}
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069int dev_pm_opp_enable(struct device *dev, unsigned long freq)
2070{
2071 return _opp_set_availability(dev, freq, true);
2072}
2073EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089int dev_pm_opp_disable(struct device *dev, unsigned long freq)
2090{
2091 return _opp_set_availability(dev, freq, false);
2092}
2093EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
2094
2095
2096
2097
2098
2099
2100
2101
2102int dev_pm_opp_register_notifier(struct device *dev, struct notifier_block *nb)
2103{
2104 struct opp_table *opp_table;
2105 int ret;
2106
2107 opp_table = _find_opp_table(dev);
2108 if (IS_ERR(opp_table))
2109 return PTR_ERR(opp_table);
2110
2111 ret = blocking_notifier_chain_register(&opp_table->head, nb);
2112
2113 dev_pm_opp_put_opp_table(opp_table);
2114
2115 return ret;
2116}
2117EXPORT_SYMBOL(dev_pm_opp_register_notifier);
2118
2119
2120
2121
2122
2123
2124
2125
2126int dev_pm_opp_unregister_notifier(struct device *dev,
2127 struct notifier_block *nb)
2128{
2129 struct opp_table *opp_table;
2130 int ret;
2131
2132 opp_table = _find_opp_table(dev);
2133 if (IS_ERR(opp_table))
2134 return PTR_ERR(opp_table);
2135
2136 ret = blocking_notifier_chain_unregister(&opp_table->head, nb);
2137
2138 dev_pm_opp_put_opp_table(opp_table);
2139
2140 return ret;
2141}
2142EXPORT_SYMBOL(dev_pm_opp_unregister_notifier);
2143
2144void _dev_pm_opp_find_and_remove_table(struct device *dev)
2145{
2146 struct opp_table *opp_table;
2147
2148
2149 opp_table = _find_opp_table(dev);
2150 if (IS_ERR(opp_table)) {
2151 int error = PTR_ERR(opp_table);
2152
2153 if (error != -ENODEV)
2154 WARN(1, "%s: opp_table: %d\n",
2155 IS_ERR_OR_NULL(dev) ?
2156 "Invalid device" : dev_name(dev),
2157 error);
2158 return;
2159 }
2160
2161 _put_opp_list_kref(opp_table);
2162
2163
2164 dev_pm_opp_put_opp_table(opp_table);
2165
2166
2167 dev_pm_opp_put_opp_table(opp_table);
2168}
2169
2170
2171
2172
2173
2174
2175
2176
2177void dev_pm_opp_remove_table(struct device *dev)
2178{
2179 _dev_pm_opp_find_and_remove_table(dev);
2180}
2181EXPORT_SYMBOL_GPL(dev_pm_opp_remove_table);
2182