Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
4 * for Non-CPU Devices.
5 *
6 * Copyright (C) 2011 Samsung Electronics
7 * MyungJoo Ham <myungjoo.ham@samsung.com>
8 */
9
10#include <linux/kernel.h>
11#include <linux/kmod.h>
12#include <linux/sched.h>
13#include <linux/errno.h>
14#include <linux/err.h>
15#include <linux/init.h>
16#include <linux/export.h>
17#include <linux/slab.h>
18#include <linux/stat.h>
19#include <linux/pm_opp.h>
20#include <linux/devfreq.h>
21#include <linux/workqueue.h>
22#include <linux/platform_device.h>
23#include <linux/list.h>
24#include <linux/printk.h>
25#include <linux/hrtimer.h>
26#include <linux/of.h>
27#include "governor.h"
28
29#define CREATE_TRACE_POINTS
30#include <trace/events/devfreq.h>
31
32static struct class *devfreq_class;
33
34/*
35 * devfreq core provides delayed work based load monitoring helper
36 * functions. Governors can use these or can implement their own
37 * monitoring mechanism.
38 */
39static struct workqueue_struct *devfreq_wq;
40
41/* The list of all device-devfreq governors */
42static LIST_HEAD(devfreq_governor_list);
43/* The list of all device-devfreq */
44static LIST_HEAD(devfreq_list);
45static DEFINE_MUTEX(devfreq_list_lock);
46
47/**
48 * find_device_devfreq() - find devfreq struct using device pointer
49 * @dev: device pointer used to lookup device devfreq.
50 *
51 * Search the list of device devfreqs and return the matched device's
52 * devfreq info. devfreq_list_lock should be held by the caller.
53 */
54static struct devfreq *find_device_devfreq(struct device *dev)
55{
56 struct devfreq *tmp_devfreq;
57
58 if (IS_ERR_OR_NULL(dev)) {
59 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
60 return ERR_PTR(-EINVAL);
61 }
62 WARN(!mutex_is_locked(&devfreq_list_lock),
63 "devfreq_list_lock must be locked.");
64
65 list_for_each_entry(tmp_devfreq, &devfreq_list, node) {
66 if (tmp_devfreq->dev.parent == dev)
67 return tmp_devfreq;
68 }
69
70 return ERR_PTR(-ENODEV);
71}
72
73static unsigned long find_available_min_freq(struct devfreq *devfreq)
74{
75 struct dev_pm_opp *opp;
76 unsigned long min_freq = 0;
77
78 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &min_freq);
79 if (IS_ERR(opp))
80 min_freq = 0;
81 else
82 dev_pm_opp_put(opp);
83
84 return min_freq;
85}
86
87static unsigned long find_available_max_freq(struct devfreq *devfreq)
88{
89 struct dev_pm_opp *opp;
90 unsigned long max_freq = ULONG_MAX;
91
92 opp = dev_pm_opp_find_freq_floor(devfreq->dev.parent, &max_freq);
93 if (IS_ERR(opp))
94 max_freq = 0;
95 else
96 dev_pm_opp_put(opp);
97
98 return max_freq;
99}
100
101/**
102 * devfreq_get_freq_level() - Lookup freq_table for the frequency
103 * @devfreq: the devfreq instance
104 * @freq: the target frequency
105 */
106static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq)
107{
108 int lev;
109
110 for (lev = 0; lev < devfreq->profile->max_state; lev++)
111 if (freq == devfreq->profile->freq_table[lev])
112 return lev;
113
114 return -EINVAL;
115}
116
117static int set_freq_table(struct devfreq *devfreq)
118{
119 struct devfreq_dev_profile *profile = devfreq->profile;
120 struct dev_pm_opp *opp;
121 unsigned long freq;
122 int i, count;
123
124 /* Initialize the freq_table from OPP table */
125 count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
126 if (count <= 0)
127 return -EINVAL;
128
129 profile->max_state = count;
130 profile->freq_table = devm_kcalloc(devfreq->dev.parent,
131 profile->max_state,
132 sizeof(*profile->freq_table),
133 GFP_KERNEL);
134 if (!profile->freq_table) {
135 profile->max_state = 0;
136 return -ENOMEM;
137 }
138
139 for (i = 0, freq = 0; i < profile->max_state; i++, freq++) {
140 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
141 if (IS_ERR(opp)) {
142 devm_kfree(devfreq->dev.parent, profile->freq_table);
143 profile->max_state = 0;
144 return PTR_ERR(opp);
145 }
146 dev_pm_opp_put(opp);
147 profile->freq_table[i] = freq;
148 }
149
150 return 0;
151}
152
153/**
154 * devfreq_update_status() - Update statistics of devfreq behavior
155 * @devfreq: the devfreq instance
156 * @freq: the update target frequency
157 */
158int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
159{
160 int lev, prev_lev, ret = 0;
161 unsigned long cur_time;
162
163 cur_time = jiffies;
164
165 /* Immediately exit if previous_freq is not initialized yet. */
166 if (!devfreq->previous_freq)
167 goto out;
168
169 prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq);
170 if (prev_lev < 0) {
171 ret = prev_lev;
172 goto out;
173 }
174
175 devfreq->time_in_state[prev_lev] +=
176 cur_time - devfreq->last_stat_updated;
177
178 lev = devfreq_get_freq_level(devfreq, freq);
179 if (lev < 0) {
180 ret = lev;
181 goto out;
182 }
183
184 if (lev != prev_lev) {
185 devfreq->trans_table[(prev_lev *
186 devfreq->profile->max_state) + lev]++;
187 devfreq->total_trans++;
188 }
189
190out:
191 devfreq->last_stat_updated = cur_time;
192 return ret;
193}
194EXPORT_SYMBOL(devfreq_update_status);
195
196/**
197 * find_devfreq_governor() - find devfreq governor from name
198 * @name: name of the governor
199 *
200 * Search the list of devfreq governors and return the matched
201 * governor's pointer. devfreq_list_lock should be held by the caller.
202 */
203static struct devfreq_governor *find_devfreq_governor(const char *name)
204{
205 struct devfreq_governor *tmp_governor;
206
207 if (IS_ERR_OR_NULL(name)) {
208 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
209 return ERR_PTR(-EINVAL);
210 }
211 WARN(!mutex_is_locked(&devfreq_list_lock),
212 "devfreq_list_lock must be locked.");
213
214 list_for_each_entry(tmp_governor, &devfreq_governor_list, node) {
215 if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN))
216 return tmp_governor;
217 }
218
219 return ERR_PTR(-ENODEV);
220}
221
222/**
223 * try_then_request_governor() - Try to find the governor and request the
224 * module if is not found.
225 * @name: name of the governor
226 *
227 * Search the list of devfreq governors and request the module and try again
228 * if is not found. This can happen when both drivers (the governor driver
229 * and the driver that call devfreq_add_device) are built as modules.
230 * devfreq_list_lock should be held by the caller. Returns the matched
231 * governor's pointer or an error pointer.
232 */
233static struct devfreq_governor *try_then_request_governor(const char *name)
234{
235 struct devfreq_governor *governor;
236 int err = 0;
237
238 if (IS_ERR_OR_NULL(name)) {
239 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
240 return ERR_PTR(-EINVAL);
241 }
242 WARN(!mutex_is_locked(&devfreq_list_lock),
243 "devfreq_list_lock must be locked.");
244
245 governor = find_devfreq_governor(name);
246 if (IS_ERR(governor)) {
247 mutex_unlock(&devfreq_list_lock);
248
249 if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND,
250 DEVFREQ_NAME_LEN))
251 err = request_module("governor_%s", "simpleondemand");
252 else
253 err = request_module("governor_%s", name);
254 /* Restore previous state before return */
255 mutex_lock(&devfreq_list_lock);
256 if (err)
257 return (err < 0) ? ERR_PTR(err) : ERR_PTR(-EINVAL);
258
259 governor = find_devfreq_governor(name);
260 }
261
262 return governor;
263}
264
265static int devfreq_notify_transition(struct devfreq *devfreq,
266 struct devfreq_freqs *freqs, unsigned int state)
267{
268 if (!devfreq)
269 return -EINVAL;
270
271 switch (state) {
272 case DEVFREQ_PRECHANGE:
273 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
274 DEVFREQ_PRECHANGE, freqs);
275 break;
276
277 case DEVFREQ_POSTCHANGE:
278 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
279 DEVFREQ_POSTCHANGE, freqs);
280 break;
281 default:
282 return -EINVAL;
283 }
284
285 return 0;
286}
287
288static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq,
289 u32 flags)
290{
291 struct devfreq_freqs freqs;
292 unsigned long cur_freq;
293 int err = 0;
294
295 if (devfreq->profile->get_cur_freq)
296 devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
297 else
298 cur_freq = devfreq->previous_freq;
299
300 freqs.old = cur_freq;
301 freqs.new = new_freq;
302 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
303
304 err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags);
305 if (err) {
306 freqs.new = cur_freq;
307 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
308 return err;
309 }
310
311 freqs.new = new_freq;
312 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
313
314 if (devfreq_update_status(devfreq, new_freq))
315 dev_err(&devfreq->dev,
316 "Couldn't update frequency transition information.\n");
317
318 devfreq->previous_freq = new_freq;
319
320 if (devfreq->suspend_freq)
321 devfreq->resume_freq = cur_freq;
322
323 return err;
324}
325
326/* Load monitoring helper functions for governors use */
327
328/**
329 * update_devfreq() - Reevaluate the device and configure frequency.
330 * @devfreq: the devfreq instance.
331 *
332 * Note: Lock devfreq->lock before calling update_devfreq
333 * This function is exported for governors.
334 */
335int update_devfreq(struct devfreq *devfreq)
336{
337 unsigned long freq, min_freq, max_freq;
338 int err = 0;
339 u32 flags = 0;
340
341 if (!mutex_is_locked(&devfreq->lock)) {
342 WARN(true, "devfreq->lock must be locked by the caller.\n");
343 return -EINVAL;
344 }
345
346 if (!devfreq->governor)
347 return -EINVAL;
348
349 /* Reevaluate the proper frequency */
350 err = devfreq->governor->get_target_freq(devfreq, &freq);
351 if (err)
352 return err;
353
354 /*
355 * Adjust the frequency with user freq, QoS and available freq.
356 *
357 * List from the highest priority
358 * max_freq
359 * min_freq
360 */
361 max_freq = min(devfreq->scaling_max_freq, devfreq->max_freq);
362 min_freq = max(devfreq->scaling_min_freq, devfreq->min_freq);
363
364 if (freq < min_freq) {
365 freq = min_freq;
366 flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */
367 }
368 if (freq > max_freq) {
369 freq = max_freq;
370 flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */
371 }
372
373 return devfreq_set_target(devfreq, freq, flags);
374
375}
376EXPORT_SYMBOL(update_devfreq);
377
378/**
379 * devfreq_monitor() - Periodically poll devfreq objects.
380 * @work: the work struct used to run devfreq_monitor periodically.
381 *
382 */
383static void devfreq_monitor(struct work_struct *work)
384{
385 int err;
386 struct devfreq *devfreq = container_of(work,
387 struct devfreq, work.work);
388
389 mutex_lock(&devfreq->lock);
390 err = update_devfreq(devfreq);
391 if (err)
392 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
393
394 queue_delayed_work(devfreq_wq, &devfreq->work,
395 msecs_to_jiffies(devfreq->profile->polling_ms));
396 mutex_unlock(&devfreq->lock);
397
398 trace_devfreq_monitor(devfreq);
399}
400
401/**
402 * devfreq_monitor_start() - Start load monitoring of devfreq instance
403 * @devfreq: the devfreq instance.
404 *
405 * Helper function for starting devfreq device load monitoring. By
406 * default delayed work based monitoring is supported. Function
407 * to be called from governor in response to DEVFREQ_GOV_START
408 * event when device is added to devfreq framework.
409 */
410void devfreq_monitor_start(struct devfreq *devfreq)
411{
412 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
413 if (devfreq->profile->polling_ms)
414 queue_delayed_work(devfreq_wq, &devfreq->work,
415 msecs_to_jiffies(devfreq->profile->polling_ms));
416}
417EXPORT_SYMBOL(devfreq_monitor_start);
418
419/**
420 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
421 * @devfreq: the devfreq instance.
422 *
423 * Helper function to stop devfreq device load monitoring. Function
424 * to be called from governor in response to DEVFREQ_GOV_STOP
425 * event when device is removed from devfreq framework.
426 */
427void devfreq_monitor_stop(struct devfreq *devfreq)
428{
429 cancel_delayed_work_sync(&devfreq->work);
430}
431EXPORT_SYMBOL(devfreq_monitor_stop);
432
433/**
434 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
435 * @devfreq: the devfreq instance.
436 *
437 * Helper function to suspend devfreq device load monitoring. Function
438 * to be called from governor in response to DEVFREQ_GOV_SUSPEND
439 * event or when polling interval is set to zero.
440 *
441 * Note: Though this function is same as devfreq_monitor_stop(),
442 * intentionally kept separate to provide hooks for collecting
443 * transition statistics.
444 */
445void devfreq_monitor_suspend(struct devfreq *devfreq)
446{
447 mutex_lock(&devfreq->lock);
448 if (devfreq->stop_polling) {
449 mutex_unlock(&devfreq->lock);
450 return;
451 }
452
453 devfreq_update_status(devfreq, devfreq->previous_freq);
454 devfreq->stop_polling = true;
455 mutex_unlock(&devfreq->lock);
456 cancel_delayed_work_sync(&devfreq->work);
457}
458EXPORT_SYMBOL(devfreq_monitor_suspend);
459
460/**
461 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
462 * @devfreq: the devfreq instance.
463 *
464 * Helper function to resume devfreq device load monitoring. Function
465 * to be called from governor in response to DEVFREQ_GOV_RESUME
466 * event or when polling interval is set to non-zero.
467 */
468void devfreq_monitor_resume(struct devfreq *devfreq)
469{
470 unsigned long freq;
471
472 mutex_lock(&devfreq->lock);
473 if (!devfreq->stop_polling)
474 goto out;
475
476 if (!delayed_work_pending(&devfreq->work) &&
477 devfreq->profile->polling_ms)
478 queue_delayed_work(devfreq_wq, &devfreq->work,
479 msecs_to_jiffies(devfreq->profile->polling_ms));
480
481 devfreq->last_stat_updated = jiffies;
482 devfreq->stop_polling = false;
483
484 if (devfreq->profile->get_cur_freq &&
485 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
486 devfreq->previous_freq = freq;
487
488out:
489 mutex_unlock(&devfreq->lock);
490}
491EXPORT_SYMBOL(devfreq_monitor_resume);
492
493/**
494 * devfreq_interval_update() - Update device devfreq monitoring interval
495 * @devfreq: the devfreq instance.
496 * @delay: new polling interval to be set.
497 *
498 * Helper function to set new load monitoring polling interval. Function
499 * to be called from governor in response to DEVFREQ_GOV_INTERVAL event.
500 */
501void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay)
502{
503 unsigned int cur_delay = devfreq->profile->polling_ms;
504 unsigned int new_delay = *delay;
505
506 mutex_lock(&devfreq->lock);
507 devfreq->profile->polling_ms = new_delay;
508
509 if (devfreq->stop_polling)
510 goto out;
511
512 /* if new delay is zero, stop polling */
513 if (!new_delay) {
514 mutex_unlock(&devfreq->lock);
515 cancel_delayed_work_sync(&devfreq->work);
516 return;
517 }
518
519 /* if current delay is zero, start polling with new delay */
520 if (!cur_delay) {
521 queue_delayed_work(devfreq_wq, &devfreq->work,
522 msecs_to_jiffies(devfreq->profile->polling_ms));
523 goto out;
524 }
525
526 /* if current delay is greater than new delay, restart polling */
527 if (cur_delay > new_delay) {
528 mutex_unlock(&devfreq->lock);
529 cancel_delayed_work_sync(&devfreq->work);
530 mutex_lock(&devfreq->lock);
531 if (!devfreq->stop_polling)
532 queue_delayed_work(devfreq_wq, &devfreq->work,
533 msecs_to_jiffies(devfreq->profile->polling_ms));
534 }
535out:
536 mutex_unlock(&devfreq->lock);
537}
538EXPORT_SYMBOL(devfreq_interval_update);
539
540/**
541 * devfreq_notifier_call() - Notify that the device frequency requirements
542 * has been changed out of devfreq framework.
543 * @nb: the notifier_block (supposed to be devfreq->nb)
544 * @type: not used
545 * @devp: not used
546 *
547 * Called by a notifier that uses devfreq->nb.
548 */
549static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
550 void *devp)
551{
552 struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
553 int ret;
554
555 mutex_lock(&devfreq->lock);
556
557 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
558 if (!devfreq->scaling_min_freq) {
559 mutex_unlock(&devfreq->lock);
560 return -EINVAL;
561 }
562
563 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
564 if (!devfreq->scaling_max_freq) {
565 mutex_unlock(&devfreq->lock);
566 return -EINVAL;
567 }
568
569 ret = update_devfreq(devfreq);
570 mutex_unlock(&devfreq->lock);
571
572 return ret;
573}
574
575/**
576 * devfreq_dev_release() - Callback for struct device to release the device.
577 * @dev: the devfreq device
578 *
579 * Remove devfreq from the list and release its resources.
580 */
581static void devfreq_dev_release(struct device *dev)
582{
583 struct devfreq *devfreq = to_devfreq(dev);
584
585 mutex_lock(&devfreq_list_lock);
586 if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) {
587 mutex_unlock(&devfreq_list_lock);
588 dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n");
589 return;
590 }
591 list_del(&devfreq->node);
592 mutex_unlock(&devfreq_list_lock);
593
594 if (devfreq->profile->exit)
595 devfreq->profile->exit(devfreq->dev.parent);
596
597 mutex_destroy(&devfreq->lock);
598 kfree(devfreq);
599}
600
601/**
602 * devfreq_add_device() - Add devfreq feature to the device
603 * @dev: the device to add devfreq feature.
604 * @profile: device-specific profile to run devfreq.
605 * @governor_name: name of the policy to choose frequency.
606 * @data: private data for the governor. The devfreq framework does not
607 * touch this value.
608 */
609struct devfreq *devfreq_add_device(struct device *dev,
610 struct devfreq_dev_profile *profile,
611 const char *governor_name,
612 void *data)
613{
614 struct devfreq *devfreq;
615 struct devfreq_governor *governor;
616 static atomic_t devfreq_no = ATOMIC_INIT(-1);
617 int err = 0;
618
619 if (!dev || !profile || !governor_name) {
620 dev_err(dev, "%s: Invalid parameters.\n", __func__);
621 return ERR_PTR(-EINVAL);
622 }
623
624 mutex_lock(&devfreq_list_lock);
625 devfreq = find_device_devfreq(dev);
626 mutex_unlock(&devfreq_list_lock);
627 if (!IS_ERR(devfreq)) {
628 dev_err(dev, "%s: Unable to create devfreq for the device.\n",
629 __func__);
630 err = -EINVAL;
631 goto err_out;
632 }
633
634 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
635 if (!devfreq) {
636 err = -ENOMEM;
637 goto err_out;
638 }
639
640 mutex_init(&devfreq->lock);
641 mutex_lock(&devfreq->lock);
642 devfreq->dev.parent = dev;
643 devfreq->dev.class = devfreq_class;
644 devfreq->dev.release = devfreq_dev_release;
645 devfreq->profile = profile;
646 strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
647 devfreq->previous_freq = profile->initial_freq;
648 devfreq->last_status.current_frequency = profile->initial_freq;
649 devfreq->data = data;
650 devfreq->nb.notifier_call = devfreq_notifier_call;
651
652 if (!devfreq->profile->max_state && !devfreq->profile->freq_table) {
653 mutex_unlock(&devfreq->lock);
654 err = set_freq_table(devfreq);
655 if (err < 0)
656 goto err_dev;
657 mutex_lock(&devfreq->lock);
658 }
659
660 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
661 if (!devfreq->scaling_min_freq) {
662 mutex_unlock(&devfreq->lock);
663 err = -EINVAL;
664 goto err_dev;
665 }
666 devfreq->min_freq = devfreq->scaling_min_freq;
667
668 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
669 if (!devfreq->scaling_max_freq) {
670 mutex_unlock(&devfreq->lock);
671 err = -EINVAL;
672 goto err_dev;
673 }
674 devfreq->max_freq = devfreq->scaling_max_freq;
675
676 devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev);
677 atomic_set(&devfreq->suspend_count, 0);
678
679 dev_set_name(&devfreq->dev, "devfreq%d",
680 atomic_inc_return(&devfreq_no));
681 err = device_register(&devfreq->dev);
682 if (err) {
683 mutex_unlock(&devfreq->lock);
684 put_device(&devfreq->dev);
685 goto err_out;
686 }
687
688 devfreq->trans_table = devm_kzalloc(&devfreq->dev,
689 array3_size(sizeof(unsigned int),
690 devfreq->profile->max_state,
691 devfreq->profile->max_state),
692 GFP_KERNEL);
693 if (!devfreq->trans_table) {
694 mutex_unlock(&devfreq->lock);
695 err = -ENOMEM;
696 goto err_devfreq;
697 }
698
699 devfreq->time_in_state = devm_kcalloc(&devfreq->dev,
700 devfreq->profile->max_state,
701 sizeof(unsigned long),
702 GFP_KERNEL);
703 if (!devfreq->time_in_state) {
704 mutex_unlock(&devfreq->lock);
705 err = -ENOMEM;
706 goto err_devfreq;
707 }
708
709 devfreq->last_stat_updated = jiffies;
710
711 srcu_init_notifier_head(&devfreq->transition_notifier_list);
712
713 mutex_unlock(&devfreq->lock);
714
715 mutex_lock(&devfreq_list_lock);
716
717 governor = try_then_request_governor(devfreq->governor_name);
718 if (IS_ERR(governor)) {
719 dev_err(dev, "%s: Unable to find governor for the device\n",
720 __func__);
721 err = PTR_ERR(governor);
722 goto err_init;
723 }
724
725 devfreq->governor = governor;
726 err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
727 NULL);
728 if (err) {
729 dev_err(dev, "%s: Unable to start governor for the device\n",
730 __func__);
731 goto err_init;
732 }
733
734 list_add(&devfreq->node, &devfreq_list);
735
736 mutex_unlock(&devfreq_list_lock);
737
738 return devfreq;
739
740err_init:
741 mutex_unlock(&devfreq_list_lock);
742err_devfreq:
743 devfreq_remove_device(devfreq);
744 devfreq = NULL;
745err_dev:
746 kfree(devfreq);
747err_out:
748 return ERR_PTR(err);
749}
750EXPORT_SYMBOL(devfreq_add_device);
751
752/**
753 * devfreq_remove_device() - Remove devfreq feature from a device.
754 * @devfreq: the devfreq instance to be removed
755 *
756 * The opposite of devfreq_add_device().
757 */
758int devfreq_remove_device(struct devfreq *devfreq)
759{
760 if (!devfreq)
761 return -EINVAL;
762
763 if (devfreq->governor)
764 devfreq->governor->event_handler(devfreq,
765 DEVFREQ_GOV_STOP, NULL);
766 device_unregister(&devfreq->dev);
767
768 return 0;
769}
770EXPORT_SYMBOL(devfreq_remove_device);
771
772static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
773{
774 struct devfreq **r = res;
775
776 if (WARN_ON(!r || !*r))
777 return 0;
778
779 return *r == data;
780}
781
782static void devm_devfreq_dev_release(struct device *dev, void *res)
783{
784 devfreq_remove_device(*(struct devfreq **)res);
785}
786
787/**
788 * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
789 * @dev: the device to add devfreq feature.
790 * @profile: device-specific profile to run devfreq.
791 * @governor_name: name of the policy to choose frequency.
792 * @data: private data for the governor. The devfreq framework does not
793 * touch this value.
794 *
795 * This function manages automatically the memory of devfreq device using device
796 * resource management and simplify the free operation for memory of devfreq
797 * device.
798 */
799struct devfreq *devm_devfreq_add_device(struct device *dev,
800 struct devfreq_dev_profile *profile,
801 const char *governor_name,
802 void *data)
803{
804 struct devfreq **ptr, *devfreq;
805
806 ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
807 if (!ptr)
808 return ERR_PTR(-ENOMEM);
809
810 devfreq = devfreq_add_device(dev, profile, governor_name, data);
811 if (IS_ERR(devfreq)) {
812 devres_free(ptr);
813 return devfreq;
814 }
815
816 *ptr = devfreq;
817 devres_add(dev, ptr);
818
819 return devfreq;
820}
821EXPORT_SYMBOL(devm_devfreq_add_device);
822
823#ifdef CONFIG_OF
824/*
825 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
826 * @dev - instance to the given device
827 * @index - index into list of devfreq
828 *
829 * return the instance of devfreq device
830 */
831struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
832{
833 struct device_node *node;
834 struct devfreq *devfreq;
835
836 if (!dev)
837 return ERR_PTR(-EINVAL);
838
839 if (!dev->of_node)
840 return ERR_PTR(-EINVAL);
841
842 node = of_parse_phandle(dev->of_node, "devfreq", index);
843 if (!node)
844 return ERR_PTR(-ENODEV);
845
846 mutex_lock(&devfreq_list_lock);
847 list_for_each_entry(devfreq, &devfreq_list, node) {
848 if (devfreq->dev.parent
849 && devfreq->dev.parent->of_node == node) {
850 mutex_unlock(&devfreq_list_lock);
851 of_node_put(node);
852 return devfreq;
853 }
854 }
855 mutex_unlock(&devfreq_list_lock);
856 of_node_put(node);
857
858 return ERR_PTR(-EPROBE_DEFER);
859}
860#else
861struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
862{
863 return ERR_PTR(-ENODEV);
864}
865#endif /* CONFIG_OF */
866EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
867
868/**
869 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
870 * @dev: the device from which to remove devfreq feature.
871 * @devfreq: the devfreq instance to be removed
872 */
873void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
874{
875 WARN_ON(devres_release(dev, devm_devfreq_dev_release,
876 devm_devfreq_dev_match, devfreq));
877}
878EXPORT_SYMBOL(devm_devfreq_remove_device);
879
880/**
881 * devfreq_suspend_device() - Suspend devfreq of a device.
882 * @devfreq: the devfreq instance to be suspended
883 *
884 * This function is intended to be called by the pm callbacks
885 * (e.g., runtime_suspend, suspend) of the device driver that
886 * holds the devfreq.
887 */
888int devfreq_suspend_device(struct devfreq *devfreq)
889{
890 int ret;
891
892 if (!devfreq)
893 return -EINVAL;
894
895 if (atomic_inc_return(&devfreq->suspend_count) > 1)
896 return 0;
897
898 if (devfreq->governor) {
899 ret = devfreq->governor->event_handler(devfreq,
900 DEVFREQ_GOV_SUSPEND, NULL);
901 if (ret)
902 return ret;
903 }
904
905 if (devfreq->suspend_freq) {
906 ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
907 if (ret)
908 return ret;
909 }
910
911 return 0;
912}
913EXPORT_SYMBOL(devfreq_suspend_device);
914
915/**
916 * devfreq_resume_device() - Resume devfreq of a device.
917 * @devfreq: the devfreq instance to be resumed
918 *
919 * This function is intended to be called by the pm callbacks
920 * (e.g., runtime_resume, resume) of the device driver that
921 * holds the devfreq.
922 */
923int devfreq_resume_device(struct devfreq *devfreq)
924{
925 int ret;
926
927 if (!devfreq)
928 return -EINVAL;
929
930 if (atomic_dec_return(&devfreq->suspend_count) >= 1)
931 return 0;
932
933 if (devfreq->resume_freq) {
934 ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
935 if (ret)
936 return ret;
937 }
938
939 if (devfreq->governor) {
940 ret = devfreq->governor->event_handler(devfreq,
941 DEVFREQ_GOV_RESUME, NULL);
942 if (ret)
943 return ret;
944 }
945
946 return 0;
947}
948EXPORT_SYMBOL(devfreq_resume_device);
949
950/**
951 * devfreq_suspend() - Suspend devfreq governors and devices
952 *
953 * Called during system wide Suspend/Hibernate cycles for suspending governors
954 * and devices preserving the state for resume. On some platforms the devfreq
955 * device must have precise state (frequency) after resume in order to provide
956 * fully operating setup.
957 */
958void devfreq_suspend(void)
959{
960 struct devfreq *devfreq;
961 int ret;
962
963 mutex_lock(&devfreq_list_lock);
964 list_for_each_entry(devfreq, &devfreq_list, node) {
965 ret = devfreq_suspend_device(devfreq);
966 if (ret)
967 dev_err(&devfreq->dev,
968 "failed to suspend devfreq device\n");
969 }
970 mutex_unlock(&devfreq_list_lock);
971}
972
973/**
974 * devfreq_resume() - Resume devfreq governors and devices
975 *
976 * Called during system wide Suspend/Hibernate cycle for resuming governors and
977 * devices that are suspended with devfreq_suspend().
978 */
979void devfreq_resume(void)
980{
981 struct devfreq *devfreq;
982 int ret;
983
984 mutex_lock(&devfreq_list_lock);
985 list_for_each_entry(devfreq, &devfreq_list, node) {
986 ret = devfreq_resume_device(devfreq);
987 if (ret)
988 dev_warn(&devfreq->dev,
989 "failed to resume devfreq device\n");
990 }
991 mutex_unlock(&devfreq_list_lock);
992}
993
994/**
995 * devfreq_add_governor() - Add devfreq governor
996 * @governor: the devfreq governor to be added
997 */
998int devfreq_add_governor(struct devfreq_governor *governor)
999{
1000 struct devfreq_governor *g;
1001 struct devfreq *devfreq;
1002 int err = 0;
1003
1004 if (!governor) {
1005 pr_err("%s: Invalid parameters.\n", __func__);
1006 return -EINVAL;
1007 }
1008
1009 mutex_lock(&devfreq_list_lock);
1010 g = find_devfreq_governor(governor->name);
1011 if (!IS_ERR(g)) {
1012 pr_err("%s: governor %s already registered\n", __func__,
1013 g->name);
1014 err = -EINVAL;
1015 goto err_out;
1016 }
1017
1018 list_add(&governor->node, &devfreq_governor_list);
1019
1020 list_for_each_entry(devfreq, &devfreq_list, node) {
1021 int ret = 0;
1022 struct device *dev = devfreq->dev.parent;
1023
1024 if (!strncmp(devfreq->governor_name, governor->name,
1025 DEVFREQ_NAME_LEN)) {
1026 /* The following should never occur */
1027 if (devfreq->governor) {
1028 dev_warn(dev,
1029 "%s: Governor %s already present\n",
1030 __func__, devfreq->governor->name);
1031 ret = devfreq->governor->event_handler(devfreq,
1032 DEVFREQ_GOV_STOP, NULL);
1033 if (ret) {
1034 dev_warn(dev,
1035 "%s: Governor %s stop = %d\n",
1036 __func__,
1037 devfreq->governor->name, ret);
1038 }
1039 /* Fall through */
1040 }
1041 devfreq->governor = governor;
1042 ret = devfreq->governor->event_handler(devfreq,
1043 DEVFREQ_GOV_START, NULL);
1044 if (ret) {
1045 dev_warn(dev, "%s: Governor %s start=%d\n",
1046 __func__, devfreq->governor->name,
1047 ret);
1048 }
1049 }
1050 }
1051
1052err_out:
1053 mutex_unlock(&devfreq_list_lock);
1054
1055 return err;
1056}
1057EXPORT_SYMBOL(devfreq_add_governor);
1058
1059/**
1060 * devfreq_remove_governor() - Remove devfreq feature from a device.
1061 * @governor: the devfreq governor to be removed
1062 */
1063int devfreq_remove_governor(struct devfreq_governor *governor)
1064{
1065 struct devfreq_governor *g;
1066 struct devfreq *devfreq;
1067 int err = 0;
1068
1069 if (!governor) {
1070 pr_err("%s: Invalid parameters.\n", __func__);
1071 return -EINVAL;
1072 }
1073
1074 mutex_lock(&devfreq_list_lock);
1075 g = find_devfreq_governor(governor->name);
1076 if (IS_ERR(g)) {
1077 pr_err("%s: governor %s not registered\n", __func__,
1078 governor->name);
1079 err = PTR_ERR(g);
1080 goto err_out;
1081 }
1082 list_for_each_entry(devfreq, &devfreq_list, node) {
1083 int ret;
1084 struct device *dev = devfreq->dev.parent;
1085
1086 if (!strncmp(devfreq->governor_name, governor->name,
1087 DEVFREQ_NAME_LEN)) {
1088 /* we should have a devfreq governor! */
1089 if (!devfreq->governor) {
1090 dev_warn(dev, "%s: Governor %s NOT present\n",
1091 __func__, governor->name);
1092 continue;
1093 /* Fall through */
1094 }
1095 ret = devfreq->governor->event_handler(devfreq,
1096 DEVFREQ_GOV_STOP, NULL);
1097 if (ret) {
1098 dev_warn(dev, "%s: Governor %s stop=%d\n",
1099 __func__, devfreq->governor->name,
1100 ret);
1101 }
1102 devfreq->governor = NULL;
1103 }
1104 }
1105
1106 list_del(&governor->node);
1107err_out:
1108 mutex_unlock(&devfreq_list_lock);
1109
1110 return err;
1111}
1112EXPORT_SYMBOL(devfreq_remove_governor);
1113
1114static ssize_t governor_show(struct device *dev,
1115 struct device_attribute *attr, char *buf)
1116{
1117 if (!to_devfreq(dev)->governor)
1118 return -EINVAL;
1119
1120 return sprintf(buf, "%s\n", to_devfreq(dev)->governor->name);
1121}
1122
1123static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
1124 const char *buf, size_t count)
1125{
1126 struct devfreq *df = to_devfreq(dev);
1127 int ret;
1128 char str_governor[DEVFREQ_NAME_LEN + 1];
1129 const struct devfreq_governor *governor, *prev_governor;
1130
1131 ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
1132 if (ret != 1)
1133 return -EINVAL;
1134
1135 mutex_lock(&devfreq_list_lock);
1136 governor = try_then_request_governor(str_governor);
1137 if (IS_ERR(governor)) {
1138 ret = PTR_ERR(governor);
1139 goto out;
1140 }
1141 if (df->governor == governor) {
1142 ret = 0;
1143 goto out;
1144 } else if ((df->governor && df->governor->immutable) ||
1145 governor->immutable) {
1146 ret = -EINVAL;
1147 goto out;
1148 }
1149
1150 if (df->governor) {
1151 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1152 if (ret) {
1153 dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1154 __func__, df->governor->name, ret);
1155 goto out;
1156 }
1157 }
1158 prev_governor = df->governor;
1159 df->governor = governor;
1160 strncpy(df->governor_name, governor->name, DEVFREQ_NAME_LEN);
1161 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1162 if (ret) {
1163 dev_warn(dev, "%s: Governor %s not started(%d)\n",
1164 __func__, df->governor->name, ret);
1165 df->governor = prev_governor;
1166 strncpy(df->governor_name, prev_governor->name,
1167 DEVFREQ_NAME_LEN);
1168 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1169 if (ret) {
1170 dev_err(dev,
1171 "%s: reverting to Governor %s failed (%d)\n",
1172 __func__, df->governor_name, ret);
1173 df->governor = NULL;
1174 }
1175 }
1176out:
1177 mutex_unlock(&devfreq_list_lock);
1178
1179 if (!ret)
1180 ret = count;
1181 return ret;
1182}
1183static DEVICE_ATTR_RW(governor);
1184
1185static ssize_t available_governors_show(struct device *d,
1186 struct device_attribute *attr,
1187 char *buf)
1188{
1189 struct devfreq *df = to_devfreq(d);
1190 ssize_t count = 0;
1191
1192 mutex_lock(&devfreq_list_lock);
1193
1194 /*
1195 * The devfreq with immutable governor (e.g., passive) shows
1196 * only own governor.
1197 */
1198 if (df->governor->immutable) {
1199 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
1200 "%s ", df->governor_name);
1201 /*
1202 * The devfreq device shows the registered governor except for
1203 * immutable governors such as passive governor .
1204 */
1205 } else {
1206 struct devfreq_governor *governor;
1207
1208 list_for_each_entry(governor, &devfreq_governor_list, node) {
1209 if (governor->immutable)
1210 continue;
1211 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1212 "%s ", governor->name);
1213 }
1214 }
1215
1216 mutex_unlock(&devfreq_list_lock);
1217
1218 /* Truncate the trailing space */
1219 if (count)
1220 count--;
1221
1222 count += sprintf(&buf[count], "\n");
1223
1224 return count;
1225}
1226static DEVICE_ATTR_RO(available_governors);
1227
1228static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr,
1229 char *buf)
1230{
1231 unsigned long freq;
1232 struct devfreq *devfreq = to_devfreq(dev);
1233
1234 if (devfreq->profile->get_cur_freq &&
1235 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
1236 return sprintf(buf, "%lu\n", freq);
1237
1238 return sprintf(buf, "%lu\n", devfreq->previous_freq);
1239}
1240static DEVICE_ATTR_RO(cur_freq);
1241
1242static ssize_t target_freq_show(struct device *dev,
1243 struct device_attribute *attr, char *buf)
1244{
1245 return sprintf(buf, "%lu\n", to_devfreq(dev)->previous_freq);
1246}
1247static DEVICE_ATTR_RO(target_freq);
1248
1249static ssize_t polling_interval_show(struct device *dev,
1250 struct device_attribute *attr, char *buf)
1251{
1252 return sprintf(buf, "%d\n", to_devfreq(dev)->profile->polling_ms);
1253}
1254
1255static ssize_t polling_interval_store(struct device *dev,
1256 struct device_attribute *attr,
1257 const char *buf, size_t count)
1258{
1259 struct devfreq *df = to_devfreq(dev);
1260 unsigned int value;
1261 int ret;
1262
1263 if (!df->governor)
1264 return -EINVAL;
1265
1266 ret = sscanf(buf, "%u", &value);
1267 if (ret != 1)
1268 return -EINVAL;
1269
1270 df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value);
1271 ret = count;
1272
1273 return ret;
1274}
1275static DEVICE_ATTR_RW(polling_interval);
1276
1277static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
1278 const char *buf, size_t count)
1279{
1280 struct devfreq *df = to_devfreq(dev);
1281 unsigned long value;
1282 int ret;
1283
1284 ret = sscanf(buf, "%lu", &value);
1285 if (ret != 1)
1286 return -EINVAL;
1287
1288 mutex_lock(&df->lock);
1289
1290 if (value) {
1291 if (value > df->max_freq) {
1292 ret = -EINVAL;
1293 goto unlock;
1294 }
1295 } else {
1296 unsigned long *freq_table = df->profile->freq_table;
1297
1298 /* Get minimum frequency according to sorting order */
1299 if (freq_table[0] < freq_table[df->profile->max_state - 1])
1300 value = freq_table[0];
1301 else
1302 value = freq_table[df->profile->max_state - 1];
1303 }
1304
1305 df->min_freq = value;
1306 update_devfreq(df);
1307 ret = count;
1308unlock:
1309 mutex_unlock(&df->lock);
1310 return ret;
1311}
1312
1313static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr,
1314 char *buf)
1315{
1316 struct devfreq *df = to_devfreq(dev);
1317
1318 return sprintf(buf, "%lu\n", max(df->scaling_min_freq, df->min_freq));
1319}
1320
1321static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
1322 const char *buf, size_t count)
1323{
1324 struct devfreq *df = to_devfreq(dev);
1325 unsigned long value;
1326 int ret;
1327
1328 ret = sscanf(buf, "%lu", &value);
1329 if (ret != 1)
1330 return -EINVAL;
1331
1332 mutex_lock(&df->lock);
1333
1334 if (value) {
1335 if (value < df->min_freq) {
1336 ret = -EINVAL;
1337 goto unlock;
1338 }
1339 } else {
1340 unsigned long *freq_table = df->profile->freq_table;
1341
1342 /* Get maximum frequency according to sorting order */
1343 if (freq_table[0] < freq_table[df->profile->max_state - 1])
1344 value = freq_table[df->profile->max_state - 1];
1345 else
1346 value = freq_table[0];
1347 }
1348
1349 df->max_freq = value;
1350 update_devfreq(df);
1351 ret = count;
1352unlock:
1353 mutex_unlock(&df->lock);
1354 return ret;
1355}
1356static DEVICE_ATTR_RW(min_freq);
1357
1358static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr,
1359 char *buf)
1360{
1361 struct devfreq *df = to_devfreq(dev);
1362
1363 return sprintf(buf, "%lu\n", min(df->scaling_max_freq, df->max_freq));
1364}
1365static DEVICE_ATTR_RW(max_freq);
1366
1367static ssize_t available_frequencies_show(struct device *d,
1368 struct device_attribute *attr,
1369 char *buf)
1370{
1371 struct devfreq *df = to_devfreq(d);
1372 ssize_t count = 0;
1373 int i;
1374
1375 mutex_lock(&df->lock);
1376
1377 for (i = 0; i < df->profile->max_state; i++)
1378 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1379 "%lu ", df->profile->freq_table[i]);
1380
1381 mutex_unlock(&df->lock);
1382 /* Truncate the trailing space */
1383 if (count)
1384 count--;
1385
1386 count += sprintf(&buf[count], "\n");
1387
1388 return count;
1389}
1390static DEVICE_ATTR_RO(available_frequencies);
1391
1392static ssize_t trans_stat_show(struct device *dev,
1393 struct device_attribute *attr, char *buf)
1394{
1395 struct devfreq *devfreq = to_devfreq(dev);
1396 ssize_t len;
1397 int i, j;
1398 unsigned int max_state = devfreq->profile->max_state;
1399
1400 if (!devfreq->stop_polling &&
1401 devfreq_update_status(devfreq, devfreq->previous_freq))
1402 return 0;
1403 if (max_state == 0)
1404 return sprintf(buf, "Not Supported.\n");
1405
1406 len = sprintf(buf, " From : To\n");
1407 len += sprintf(buf + len, " :");
1408 for (i = 0; i < max_state; i++)
1409 len += sprintf(buf + len, "%10lu",
1410 devfreq->profile->freq_table[i]);
1411
1412 len += sprintf(buf + len, " time(ms)\n");
1413
1414 for (i = 0; i < max_state; i++) {
1415 if (devfreq->profile->freq_table[i]
1416 == devfreq->previous_freq) {
1417 len += sprintf(buf + len, "*");
1418 } else {
1419 len += sprintf(buf + len, " ");
1420 }
1421 len += sprintf(buf + len, "%10lu:",
1422 devfreq->profile->freq_table[i]);
1423 for (j = 0; j < max_state; j++)
1424 len += sprintf(buf + len, "%10u",
1425 devfreq->trans_table[(i * max_state) + j]);
1426 len += sprintf(buf + len, "%10u\n",
1427 jiffies_to_msecs(devfreq->time_in_state[i]));
1428 }
1429
1430 len += sprintf(buf + len, "Total transition : %u\n",
1431 devfreq->total_trans);
1432 return len;
1433}
1434static DEVICE_ATTR_RO(trans_stat);
1435
1436static struct attribute *devfreq_attrs[] = {
1437 &dev_attr_governor.attr,
1438 &dev_attr_available_governors.attr,
1439 &dev_attr_cur_freq.attr,
1440 &dev_attr_available_frequencies.attr,
1441 &dev_attr_target_freq.attr,
1442 &dev_attr_polling_interval.attr,
1443 &dev_attr_min_freq.attr,
1444 &dev_attr_max_freq.attr,
1445 &dev_attr_trans_stat.attr,
1446 NULL,
1447};
1448ATTRIBUTE_GROUPS(devfreq);
1449
1450static int __init devfreq_init(void)
1451{
1452 devfreq_class = class_create(THIS_MODULE, "devfreq");
1453 if (IS_ERR(devfreq_class)) {
1454 pr_err("%s: couldn't create class\n", __FILE__);
1455 return PTR_ERR(devfreq_class);
1456 }
1457
1458 devfreq_wq = create_freezable_workqueue("devfreq_wq");
1459 if (!devfreq_wq) {
1460 class_destroy(devfreq_class);
1461 pr_err("%s: couldn't create workqueue\n", __FILE__);
1462 return -ENOMEM;
1463 }
1464 devfreq_class->dev_groups = devfreq_groups;
1465
1466 return 0;
1467}
1468subsys_initcall(devfreq_init);
1469
1470/*
1471 * The following are helper functions for devfreq user device drivers with
1472 * OPP framework.
1473 */
1474
1475/**
1476 * devfreq_recommended_opp() - Helper function to get proper OPP for the
1477 * freq value given to target callback.
1478 * @dev: The devfreq user device. (parent of devfreq)
1479 * @freq: The frequency given to target function
1480 * @flags: Flags handed from devfreq framework.
1481 *
1482 * The callers are required to call dev_pm_opp_put() for the returned OPP after
1483 * use.
1484 */
1485struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
1486 unsigned long *freq,
1487 u32 flags)
1488{
1489 struct dev_pm_opp *opp;
1490
1491 if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
1492 /* The freq is an upper bound. opp should be lower */
1493 opp = dev_pm_opp_find_freq_floor(dev, freq);
1494
1495 /* If not available, use the closest opp */
1496 if (opp == ERR_PTR(-ERANGE))
1497 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1498 } else {
1499 /* The freq is an lower bound. opp should be higher */
1500 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1501
1502 /* If not available, use the closest opp */
1503 if (opp == ERR_PTR(-ERANGE))
1504 opp = dev_pm_opp_find_freq_floor(dev, freq);
1505 }
1506
1507 return opp;
1508}
1509EXPORT_SYMBOL(devfreq_recommended_opp);
1510
1511/**
1512 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1513 * for any changes in the OPP availability
1514 * changes
1515 * @dev: The devfreq user device. (parent of devfreq)
1516 * @devfreq: The devfreq object.
1517 */
1518int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1519{
1520 return dev_pm_opp_register_notifier(dev, &devfreq->nb);
1521}
1522EXPORT_SYMBOL(devfreq_register_opp_notifier);
1523
1524/**
1525 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1526 * notified for any changes in the OPP
1527 * availability changes anymore.
1528 * @dev: The devfreq user device. (parent of devfreq)
1529 * @devfreq: The devfreq object.
1530 *
1531 * At exit() callback of devfreq_dev_profile, this must be included if
1532 * devfreq_recommended_opp is used.
1533 */
1534int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1535{
1536 return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
1537}
1538EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
1539
1540static void devm_devfreq_opp_release(struct device *dev, void *res)
1541{
1542 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
1543}
1544
1545/**
1546 * devm_devfreq_register_opp_notifier() - Resource-managed
1547 * devfreq_register_opp_notifier()
1548 * @dev: The devfreq user device. (parent of devfreq)
1549 * @devfreq: The devfreq object.
1550 */
1551int devm_devfreq_register_opp_notifier(struct device *dev,
1552 struct devfreq *devfreq)
1553{
1554 struct devfreq **ptr;
1555 int ret;
1556
1557 ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
1558 if (!ptr)
1559 return -ENOMEM;
1560
1561 ret = devfreq_register_opp_notifier(dev, devfreq);
1562 if (ret) {
1563 devres_free(ptr);
1564 return ret;
1565 }
1566
1567 *ptr = devfreq;
1568 devres_add(dev, ptr);
1569
1570 return 0;
1571}
1572EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
1573
1574/**
1575 * devm_devfreq_unregister_opp_notifier() - Resource-managed
1576 * devfreq_unregister_opp_notifier()
1577 * @dev: The devfreq user device. (parent of devfreq)
1578 * @devfreq: The devfreq object.
1579 */
1580void devm_devfreq_unregister_opp_notifier(struct device *dev,
1581 struct devfreq *devfreq)
1582{
1583 WARN_ON(devres_release(dev, devm_devfreq_opp_release,
1584 devm_devfreq_dev_match, devfreq));
1585}
1586EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
1587
1588/**
1589 * devfreq_register_notifier() - Register a driver with devfreq
1590 * @devfreq: The devfreq object.
1591 * @nb: The notifier block to register.
1592 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1593 */
1594int devfreq_register_notifier(struct devfreq *devfreq,
1595 struct notifier_block *nb,
1596 unsigned int list)
1597{
1598 int ret = 0;
1599
1600 if (!devfreq)
1601 return -EINVAL;
1602
1603 switch (list) {
1604 case DEVFREQ_TRANSITION_NOTIFIER:
1605 ret = srcu_notifier_chain_register(
1606 &devfreq->transition_notifier_list, nb);
1607 break;
1608 default:
1609 ret = -EINVAL;
1610 }
1611
1612 return ret;
1613}
1614EXPORT_SYMBOL(devfreq_register_notifier);
1615
1616/*
1617 * devfreq_unregister_notifier() - Unregister a driver with devfreq
1618 * @devfreq: The devfreq object.
1619 * @nb: The notifier block to be unregistered.
1620 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1621 */
1622int devfreq_unregister_notifier(struct devfreq *devfreq,
1623 struct notifier_block *nb,
1624 unsigned int list)
1625{
1626 int ret = 0;
1627
1628 if (!devfreq)
1629 return -EINVAL;
1630
1631 switch (list) {
1632 case DEVFREQ_TRANSITION_NOTIFIER:
1633 ret = srcu_notifier_chain_unregister(
1634 &devfreq->transition_notifier_list, nb);
1635 break;
1636 default:
1637 ret = -EINVAL;
1638 }
1639
1640 return ret;
1641}
1642EXPORT_SYMBOL(devfreq_unregister_notifier);
1643
1644struct devfreq_notifier_devres {
1645 struct devfreq *devfreq;
1646 struct notifier_block *nb;
1647 unsigned int list;
1648};
1649
1650static void devm_devfreq_notifier_release(struct device *dev, void *res)
1651{
1652 struct devfreq_notifier_devres *this = res;
1653
1654 devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
1655}
1656
1657/**
1658 * devm_devfreq_register_notifier()
1659 - Resource-managed devfreq_register_notifier()
1660 * @dev: The devfreq user device. (parent of devfreq)
1661 * @devfreq: The devfreq object.
1662 * @nb: The notifier block to be unregistered.
1663 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1664 */
1665int devm_devfreq_register_notifier(struct device *dev,
1666 struct devfreq *devfreq,
1667 struct notifier_block *nb,
1668 unsigned int list)
1669{
1670 struct devfreq_notifier_devres *ptr;
1671 int ret;
1672
1673 ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
1674 GFP_KERNEL);
1675 if (!ptr)
1676 return -ENOMEM;
1677
1678 ret = devfreq_register_notifier(devfreq, nb, list);
1679 if (ret) {
1680 devres_free(ptr);
1681 return ret;
1682 }
1683
1684 ptr->devfreq = devfreq;
1685 ptr->nb = nb;
1686 ptr->list = list;
1687 devres_add(dev, ptr);
1688
1689 return 0;
1690}
1691EXPORT_SYMBOL(devm_devfreq_register_notifier);
1692
1693/**
1694 * devm_devfreq_unregister_notifier()
1695 - Resource-managed devfreq_unregister_notifier()
1696 * @dev: The devfreq user device. (parent of devfreq)
1697 * @devfreq: The devfreq object.
1698 * @nb: The notifier block to be unregistered.
1699 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1700 */
1701void devm_devfreq_unregister_notifier(struct device *dev,
1702 struct devfreq *devfreq,
1703 struct notifier_block *nb,
1704 unsigned int list)
1705{
1706 WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
1707 devm_devfreq_dev_match, devfreq));
1708}
1709EXPORT_SYMBOL(devm_devfreq_unregister_notifier);
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
4 * for Non-CPU Devices.
5 *
6 * Copyright (C) 2011 Samsung Electronics
7 * MyungJoo Ham <myungjoo.ham@samsung.com>
8 */
9
10#include <linux/kernel.h>
11#include <linux/kmod.h>
12#include <linux/sched.h>
13#include <linux/debugfs.h>
14#include <linux/devfreq_cooling.h>
15#include <linux/errno.h>
16#include <linux/err.h>
17#include <linux/init.h>
18#include <linux/export.h>
19#include <linux/slab.h>
20#include <linux/stat.h>
21#include <linux/pm_opp.h>
22#include <linux/devfreq.h>
23#include <linux/workqueue.h>
24#include <linux/platform_device.h>
25#include <linux/list.h>
26#include <linux/printk.h>
27#include <linux/hrtimer.h>
28#include <linux/of.h>
29#include <linux/pm_qos.h>
30#include <linux/units.h>
31#include "governor.h"
32
33#define CREATE_TRACE_POINTS
34#include <trace/events/devfreq.h>
35
36#define IS_SUPPORTED_FLAG(f, name) ((f & DEVFREQ_GOV_FLAG_##name) ? true : false)
37#define IS_SUPPORTED_ATTR(f, name) ((f & DEVFREQ_GOV_ATTR_##name) ? true : false)
38
39static struct class *devfreq_class;
40static struct dentry *devfreq_debugfs;
41
42/*
43 * devfreq core provides delayed work based load monitoring helper
44 * functions. Governors can use these or can implement their own
45 * monitoring mechanism.
46 */
47static struct workqueue_struct *devfreq_wq;
48
49/* The list of all device-devfreq governors */
50static LIST_HEAD(devfreq_governor_list);
51/* The list of all device-devfreq */
52static LIST_HEAD(devfreq_list);
53static DEFINE_MUTEX(devfreq_list_lock);
54
55static const char timer_name[][DEVFREQ_NAME_LEN] = {
56 [DEVFREQ_TIMER_DEFERRABLE] = { "deferrable" },
57 [DEVFREQ_TIMER_DELAYED] = { "delayed" },
58};
59
60/**
61 * find_device_devfreq() - find devfreq struct using device pointer
62 * @dev: device pointer used to lookup device devfreq.
63 *
64 * Search the list of device devfreqs and return the matched device's
65 * devfreq info. devfreq_list_lock should be held by the caller.
66 */
67static struct devfreq *find_device_devfreq(struct device *dev)
68{
69 struct devfreq *tmp_devfreq;
70
71 lockdep_assert_held(&devfreq_list_lock);
72
73 if (IS_ERR_OR_NULL(dev)) {
74 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
75 return ERR_PTR(-EINVAL);
76 }
77
78 list_for_each_entry(tmp_devfreq, &devfreq_list, node) {
79 if (tmp_devfreq->dev.parent == dev)
80 return tmp_devfreq;
81 }
82
83 return ERR_PTR(-ENODEV);
84}
85
86static unsigned long find_available_min_freq(struct devfreq *devfreq)
87{
88 struct dev_pm_opp *opp;
89 unsigned long min_freq = 0;
90
91 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &min_freq);
92 if (IS_ERR(opp))
93 min_freq = 0;
94 else
95 dev_pm_opp_put(opp);
96
97 return min_freq;
98}
99
100static unsigned long find_available_max_freq(struct devfreq *devfreq)
101{
102 struct dev_pm_opp *opp;
103 unsigned long max_freq = ULONG_MAX;
104
105 opp = dev_pm_opp_find_freq_floor(devfreq->dev.parent, &max_freq);
106 if (IS_ERR(opp))
107 max_freq = 0;
108 else
109 dev_pm_opp_put(opp);
110
111 return max_freq;
112}
113
114/**
115 * devfreq_get_freq_range() - Get the current freq range
116 * @devfreq: the devfreq instance
117 * @min_freq: the min frequency
118 * @max_freq: the max frequency
119 *
120 * This takes into consideration all constraints.
121 */
122void devfreq_get_freq_range(struct devfreq *devfreq,
123 unsigned long *min_freq,
124 unsigned long *max_freq)
125{
126 unsigned long *freq_table = devfreq->freq_table;
127 s32 qos_min_freq, qos_max_freq;
128
129 lockdep_assert_held(&devfreq->lock);
130
131 /*
132 * Initialize minimum/maximum frequency from freq table.
133 * The devfreq drivers can initialize this in either ascending or
134 * descending order and devfreq core supports both.
135 */
136 if (freq_table[0] < freq_table[devfreq->max_state - 1]) {
137 *min_freq = freq_table[0];
138 *max_freq = freq_table[devfreq->max_state - 1];
139 } else {
140 *min_freq = freq_table[devfreq->max_state - 1];
141 *max_freq = freq_table[0];
142 }
143
144 /* Apply constraints from PM QoS */
145 qos_min_freq = dev_pm_qos_read_value(devfreq->dev.parent,
146 DEV_PM_QOS_MIN_FREQUENCY);
147 qos_max_freq = dev_pm_qos_read_value(devfreq->dev.parent,
148 DEV_PM_QOS_MAX_FREQUENCY);
149 *min_freq = max(*min_freq, (unsigned long)HZ_PER_KHZ * qos_min_freq);
150 if (qos_max_freq != PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE)
151 *max_freq = min(*max_freq,
152 (unsigned long)HZ_PER_KHZ * qos_max_freq);
153
154 /* Apply constraints from OPP interface */
155 *min_freq = max(*min_freq, devfreq->scaling_min_freq);
156 *max_freq = min(*max_freq, devfreq->scaling_max_freq);
157
158 if (*min_freq > *max_freq)
159 *min_freq = *max_freq;
160}
161EXPORT_SYMBOL(devfreq_get_freq_range);
162
163/**
164 * devfreq_get_freq_level() - Lookup freq_table for the frequency
165 * @devfreq: the devfreq instance
166 * @freq: the target frequency
167 */
168static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq)
169{
170 int lev;
171
172 for (lev = 0; lev < devfreq->max_state; lev++)
173 if (freq == devfreq->freq_table[lev])
174 return lev;
175
176 return -EINVAL;
177}
178
179static int set_freq_table(struct devfreq *devfreq)
180{
181 struct dev_pm_opp *opp;
182 unsigned long freq;
183 int i, count;
184
185 /* Initialize the freq_table from OPP table */
186 count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
187 if (count <= 0)
188 return -EINVAL;
189
190 devfreq->max_state = count;
191 devfreq->freq_table = devm_kcalloc(devfreq->dev.parent,
192 devfreq->max_state,
193 sizeof(*devfreq->freq_table),
194 GFP_KERNEL);
195 if (!devfreq->freq_table)
196 return -ENOMEM;
197
198 for (i = 0, freq = 0; i < devfreq->max_state; i++, freq++) {
199 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
200 if (IS_ERR(opp)) {
201 devm_kfree(devfreq->dev.parent, devfreq->freq_table);
202 return PTR_ERR(opp);
203 }
204 dev_pm_opp_put(opp);
205 devfreq->freq_table[i] = freq;
206 }
207
208 return 0;
209}
210
211/**
212 * devfreq_update_status() - Update statistics of devfreq behavior
213 * @devfreq: the devfreq instance
214 * @freq: the update target frequency
215 */
216int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
217{
218 int lev, prev_lev, ret = 0;
219 u64 cur_time;
220
221 lockdep_assert_held(&devfreq->lock);
222 cur_time = get_jiffies_64();
223
224 /* Immediately exit if previous_freq is not initialized yet. */
225 if (!devfreq->previous_freq)
226 goto out;
227
228 prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq);
229 if (prev_lev < 0) {
230 ret = prev_lev;
231 goto out;
232 }
233
234 devfreq->stats.time_in_state[prev_lev] +=
235 cur_time - devfreq->stats.last_update;
236
237 lev = devfreq_get_freq_level(devfreq, freq);
238 if (lev < 0) {
239 ret = lev;
240 goto out;
241 }
242
243 if (lev != prev_lev) {
244 devfreq->stats.trans_table[
245 (prev_lev * devfreq->max_state) + lev]++;
246 devfreq->stats.total_trans++;
247 }
248
249out:
250 devfreq->stats.last_update = cur_time;
251 return ret;
252}
253EXPORT_SYMBOL(devfreq_update_status);
254
255/**
256 * find_devfreq_governor() - find devfreq governor from name
257 * @name: name of the governor
258 *
259 * Search the list of devfreq governors and return the matched
260 * governor's pointer. devfreq_list_lock should be held by the caller.
261 */
262static struct devfreq_governor *find_devfreq_governor(const char *name)
263{
264 struct devfreq_governor *tmp_governor;
265
266 lockdep_assert_held(&devfreq_list_lock);
267
268 if (IS_ERR_OR_NULL(name)) {
269 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
270 return ERR_PTR(-EINVAL);
271 }
272
273 list_for_each_entry(tmp_governor, &devfreq_governor_list, node) {
274 if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN))
275 return tmp_governor;
276 }
277
278 return ERR_PTR(-ENODEV);
279}
280
281/**
282 * try_then_request_governor() - Try to find the governor and request the
283 * module if is not found.
284 * @name: name of the governor
285 *
286 * Search the list of devfreq governors and request the module and try again
287 * if is not found. This can happen when both drivers (the governor driver
288 * and the driver that call devfreq_add_device) are built as modules.
289 * devfreq_list_lock should be held by the caller. Returns the matched
290 * governor's pointer or an error pointer.
291 */
292static struct devfreq_governor *try_then_request_governor(const char *name)
293{
294 struct devfreq_governor *governor;
295 int err = 0;
296
297 lockdep_assert_held(&devfreq_list_lock);
298
299 if (IS_ERR_OR_NULL(name)) {
300 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
301 return ERR_PTR(-EINVAL);
302 }
303
304 governor = find_devfreq_governor(name);
305 if (IS_ERR(governor)) {
306 mutex_unlock(&devfreq_list_lock);
307
308 if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND,
309 DEVFREQ_NAME_LEN))
310 err = request_module("governor_%s", "simpleondemand");
311 else
312 err = request_module("governor_%s", name);
313 /* Restore previous state before return */
314 mutex_lock(&devfreq_list_lock);
315 if (err)
316 return (err < 0) ? ERR_PTR(err) : ERR_PTR(-EINVAL);
317
318 governor = find_devfreq_governor(name);
319 }
320
321 return governor;
322}
323
324static int devfreq_notify_transition(struct devfreq *devfreq,
325 struct devfreq_freqs *freqs, unsigned int state)
326{
327 if (!devfreq)
328 return -EINVAL;
329
330 switch (state) {
331 case DEVFREQ_PRECHANGE:
332 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
333 DEVFREQ_PRECHANGE, freqs);
334 break;
335
336 case DEVFREQ_POSTCHANGE:
337 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
338 DEVFREQ_POSTCHANGE, freqs);
339 break;
340 default:
341 return -EINVAL;
342 }
343
344 return 0;
345}
346
347static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq,
348 u32 flags)
349{
350 struct devfreq_freqs freqs;
351 unsigned long cur_freq;
352 int err = 0;
353
354 if (devfreq->profile->get_cur_freq)
355 devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
356 else
357 cur_freq = devfreq->previous_freq;
358
359 freqs.old = cur_freq;
360 freqs.new = new_freq;
361 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
362
363 err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags);
364 if (err) {
365 freqs.new = cur_freq;
366 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
367 return err;
368 }
369
370 /*
371 * Print devfreq_frequency trace information between DEVFREQ_PRECHANGE
372 * and DEVFREQ_POSTCHANGE because for showing the correct frequency
373 * change order of between devfreq device and passive devfreq device.
374 */
375 if (trace_devfreq_frequency_enabled() && new_freq != cur_freq)
376 trace_devfreq_frequency(devfreq, new_freq, cur_freq);
377
378 freqs.new = new_freq;
379 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
380
381 if (devfreq_update_status(devfreq, new_freq))
382 dev_warn(&devfreq->dev,
383 "Couldn't update frequency transition information.\n");
384
385 devfreq->previous_freq = new_freq;
386
387 if (devfreq->suspend_freq)
388 devfreq->resume_freq = new_freq;
389
390 return err;
391}
392
393/**
394 * devfreq_update_target() - Reevaluate the device and configure frequency
395 * on the final stage.
396 * @devfreq: the devfreq instance.
397 * @freq: the new frequency of parent device. This argument
398 * is only used for devfreq device using passive governor.
399 *
400 * Note: Lock devfreq->lock before calling devfreq_update_target. This function
401 * should be only used by both update_devfreq() and devfreq governors.
402 */
403int devfreq_update_target(struct devfreq *devfreq, unsigned long freq)
404{
405 unsigned long min_freq, max_freq;
406 int err = 0;
407 u32 flags = 0;
408
409 lockdep_assert_held(&devfreq->lock);
410
411 if (!devfreq->governor)
412 return -EINVAL;
413
414 /* Reevaluate the proper frequency */
415 err = devfreq->governor->get_target_freq(devfreq, &freq);
416 if (err)
417 return err;
418 devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
419
420 if (freq < min_freq) {
421 freq = min_freq;
422 flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */
423 }
424 if (freq > max_freq) {
425 freq = max_freq;
426 flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */
427 }
428
429 return devfreq_set_target(devfreq, freq, flags);
430}
431EXPORT_SYMBOL(devfreq_update_target);
432
433/* Load monitoring helper functions for governors use */
434
435/**
436 * update_devfreq() - Reevaluate the device and configure frequency.
437 * @devfreq: the devfreq instance.
438 *
439 * Note: Lock devfreq->lock before calling update_devfreq
440 * This function is exported for governors.
441 */
442int update_devfreq(struct devfreq *devfreq)
443{
444 return devfreq_update_target(devfreq, 0L);
445}
446EXPORT_SYMBOL(update_devfreq);
447
448/**
449 * devfreq_monitor() - Periodically poll devfreq objects.
450 * @work: the work struct used to run devfreq_monitor periodically.
451 *
452 */
453static void devfreq_monitor(struct work_struct *work)
454{
455 int err;
456 struct devfreq *devfreq = container_of(work,
457 struct devfreq, work.work);
458
459 mutex_lock(&devfreq->lock);
460 err = update_devfreq(devfreq);
461 if (err)
462 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
463
464 queue_delayed_work(devfreq_wq, &devfreq->work,
465 msecs_to_jiffies(devfreq->profile->polling_ms));
466 mutex_unlock(&devfreq->lock);
467
468 trace_devfreq_monitor(devfreq);
469}
470
471/**
472 * devfreq_monitor_start() - Start load monitoring of devfreq instance
473 * @devfreq: the devfreq instance.
474 *
475 * Helper function for starting devfreq device load monitoring. By
476 * default delayed work based monitoring is supported. Function
477 * to be called from governor in response to DEVFREQ_GOV_START
478 * event when device is added to devfreq framework.
479 */
480void devfreq_monitor_start(struct devfreq *devfreq)
481{
482 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
483 return;
484
485 switch (devfreq->profile->timer) {
486 case DEVFREQ_TIMER_DEFERRABLE:
487 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
488 break;
489 case DEVFREQ_TIMER_DELAYED:
490 INIT_DELAYED_WORK(&devfreq->work, devfreq_monitor);
491 break;
492 default:
493 return;
494 }
495
496 if (devfreq->profile->polling_ms)
497 queue_delayed_work(devfreq_wq, &devfreq->work,
498 msecs_to_jiffies(devfreq->profile->polling_ms));
499}
500EXPORT_SYMBOL(devfreq_monitor_start);
501
502/**
503 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
504 * @devfreq: the devfreq instance.
505 *
506 * Helper function to stop devfreq device load monitoring. Function
507 * to be called from governor in response to DEVFREQ_GOV_STOP
508 * event when device is removed from devfreq framework.
509 */
510void devfreq_monitor_stop(struct devfreq *devfreq)
511{
512 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
513 return;
514
515 cancel_delayed_work_sync(&devfreq->work);
516}
517EXPORT_SYMBOL(devfreq_monitor_stop);
518
519/**
520 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
521 * @devfreq: the devfreq instance.
522 *
523 * Helper function to suspend devfreq device load monitoring. Function
524 * to be called from governor in response to DEVFREQ_GOV_SUSPEND
525 * event or when polling interval is set to zero.
526 *
527 * Note: Though this function is same as devfreq_monitor_stop(),
528 * intentionally kept separate to provide hooks for collecting
529 * transition statistics.
530 */
531void devfreq_monitor_suspend(struct devfreq *devfreq)
532{
533 mutex_lock(&devfreq->lock);
534 if (devfreq->stop_polling) {
535 mutex_unlock(&devfreq->lock);
536 return;
537 }
538
539 devfreq_update_status(devfreq, devfreq->previous_freq);
540 devfreq->stop_polling = true;
541 mutex_unlock(&devfreq->lock);
542
543 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
544 return;
545
546 cancel_delayed_work_sync(&devfreq->work);
547}
548EXPORT_SYMBOL(devfreq_monitor_suspend);
549
550/**
551 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
552 * @devfreq: the devfreq instance.
553 *
554 * Helper function to resume devfreq device load monitoring. Function
555 * to be called from governor in response to DEVFREQ_GOV_RESUME
556 * event or when polling interval is set to non-zero.
557 */
558void devfreq_monitor_resume(struct devfreq *devfreq)
559{
560 unsigned long freq;
561
562 mutex_lock(&devfreq->lock);
563
564 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
565 goto out_update;
566
567 if (!devfreq->stop_polling)
568 goto out;
569
570 if (!delayed_work_pending(&devfreq->work) &&
571 devfreq->profile->polling_ms)
572 queue_delayed_work(devfreq_wq, &devfreq->work,
573 msecs_to_jiffies(devfreq->profile->polling_ms));
574
575out_update:
576 devfreq->stats.last_update = get_jiffies_64();
577 devfreq->stop_polling = false;
578
579 if (devfreq->profile->get_cur_freq &&
580 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
581 devfreq->previous_freq = freq;
582
583out:
584 mutex_unlock(&devfreq->lock);
585}
586EXPORT_SYMBOL(devfreq_monitor_resume);
587
588/**
589 * devfreq_update_interval() - Update device devfreq monitoring interval
590 * @devfreq: the devfreq instance.
591 * @delay: new polling interval to be set.
592 *
593 * Helper function to set new load monitoring polling interval. Function
594 * to be called from governor in response to DEVFREQ_GOV_UPDATE_INTERVAL event.
595 */
596void devfreq_update_interval(struct devfreq *devfreq, unsigned int *delay)
597{
598 unsigned int cur_delay = devfreq->profile->polling_ms;
599 unsigned int new_delay = *delay;
600
601 mutex_lock(&devfreq->lock);
602 devfreq->profile->polling_ms = new_delay;
603
604 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
605 goto out;
606
607 if (devfreq->stop_polling)
608 goto out;
609
610 /* if new delay is zero, stop polling */
611 if (!new_delay) {
612 mutex_unlock(&devfreq->lock);
613 cancel_delayed_work_sync(&devfreq->work);
614 return;
615 }
616
617 /* if current delay is zero, start polling with new delay */
618 if (!cur_delay) {
619 queue_delayed_work(devfreq_wq, &devfreq->work,
620 msecs_to_jiffies(devfreq->profile->polling_ms));
621 goto out;
622 }
623
624 /* if current delay is greater than new delay, restart polling */
625 if (cur_delay > new_delay) {
626 mutex_unlock(&devfreq->lock);
627 cancel_delayed_work_sync(&devfreq->work);
628 mutex_lock(&devfreq->lock);
629 if (!devfreq->stop_polling)
630 queue_delayed_work(devfreq_wq, &devfreq->work,
631 msecs_to_jiffies(devfreq->profile->polling_ms));
632 }
633out:
634 mutex_unlock(&devfreq->lock);
635}
636EXPORT_SYMBOL(devfreq_update_interval);
637
638/**
639 * devfreq_notifier_call() - Notify that the device frequency requirements
640 * has been changed out of devfreq framework.
641 * @nb: the notifier_block (supposed to be devfreq->nb)
642 * @type: not used
643 * @devp: not used
644 *
645 * Called by a notifier that uses devfreq->nb.
646 */
647static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
648 void *devp)
649{
650 struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
651 int err = -EINVAL;
652
653 mutex_lock(&devfreq->lock);
654
655 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
656 if (!devfreq->scaling_min_freq)
657 goto out;
658
659 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
660 if (!devfreq->scaling_max_freq) {
661 devfreq->scaling_max_freq = ULONG_MAX;
662 goto out;
663 }
664
665 err = update_devfreq(devfreq);
666
667out:
668 mutex_unlock(&devfreq->lock);
669 if (err)
670 dev_err(devfreq->dev.parent,
671 "failed to update frequency from OPP notifier (%d)\n",
672 err);
673
674 return NOTIFY_OK;
675}
676
677/**
678 * qos_notifier_call() - Common handler for QoS constraints.
679 * @devfreq: the devfreq instance.
680 */
681static int qos_notifier_call(struct devfreq *devfreq)
682{
683 int err;
684
685 mutex_lock(&devfreq->lock);
686 err = update_devfreq(devfreq);
687 mutex_unlock(&devfreq->lock);
688 if (err)
689 dev_err(devfreq->dev.parent,
690 "failed to update frequency from PM QoS (%d)\n",
691 err);
692
693 return NOTIFY_OK;
694}
695
696/**
697 * qos_min_notifier_call() - Callback for QoS min_freq changes.
698 * @nb: Should be devfreq->nb_min
699 * @val: not used
700 * @ptr: not used
701 */
702static int qos_min_notifier_call(struct notifier_block *nb,
703 unsigned long val, void *ptr)
704{
705 return qos_notifier_call(container_of(nb, struct devfreq, nb_min));
706}
707
708/**
709 * qos_max_notifier_call() - Callback for QoS max_freq changes.
710 * @nb: Should be devfreq->nb_max
711 * @val: not used
712 * @ptr: not used
713 */
714static int qos_max_notifier_call(struct notifier_block *nb,
715 unsigned long val, void *ptr)
716{
717 return qos_notifier_call(container_of(nb, struct devfreq, nb_max));
718}
719
720/**
721 * devfreq_dev_release() - Callback for struct device to release the device.
722 * @dev: the devfreq device
723 *
724 * Remove devfreq from the list and release its resources.
725 */
726static void devfreq_dev_release(struct device *dev)
727{
728 struct devfreq *devfreq = to_devfreq(dev);
729 int err;
730
731 mutex_lock(&devfreq_list_lock);
732 list_del(&devfreq->node);
733 mutex_unlock(&devfreq_list_lock);
734
735 err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_max,
736 DEV_PM_QOS_MAX_FREQUENCY);
737 if (err && err != -ENOENT)
738 dev_warn(dev->parent,
739 "Failed to remove max_freq notifier: %d\n", err);
740 err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_min,
741 DEV_PM_QOS_MIN_FREQUENCY);
742 if (err && err != -ENOENT)
743 dev_warn(dev->parent,
744 "Failed to remove min_freq notifier: %d\n", err);
745
746 if (dev_pm_qos_request_active(&devfreq->user_max_freq_req)) {
747 err = dev_pm_qos_remove_request(&devfreq->user_max_freq_req);
748 if (err < 0)
749 dev_warn(dev->parent,
750 "Failed to remove max_freq request: %d\n", err);
751 }
752 if (dev_pm_qos_request_active(&devfreq->user_min_freq_req)) {
753 err = dev_pm_qos_remove_request(&devfreq->user_min_freq_req);
754 if (err < 0)
755 dev_warn(dev->parent,
756 "Failed to remove min_freq request: %d\n", err);
757 }
758
759 if (devfreq->profile->exit)
760 devfreq->profile->exit(devfreq->dev.parent);
761
762 if (devfreq->opp_table)
763 dev_pm_opp_put_opp_table(devfreq->opp_table);
764
765 mutex_destroy(&devfreq->lock);
766 kfree(devfreq);
767}
768
769static void create_sysfs_files(struct devfreq *devfreq,
770 const struct devfreq_governor *gov);
771static void remove_sysfs_files(struct devfreq *devfreq,
772 const struct devfreq_governor *gov);
773
774/**
775 * devfreq_add_device() - Add devfreq feature to the device
776 * @dev: the device to add devfreq feature.
777 * @profile: device-specific profile to run devfreq.
778 * @governor_name: name of the policy to choose frequency.
779 * @data: devfreq driver pass to governors, governor should not change it.
780 */
781struct devfreq *devfreq_add_device(struct device *dev,
782 struct devfreq_dev_profile *profile,
783 const char *governor_name,
784 void *data)
785{
786 struct devfreq *devfreq;
787 struct devfreq_governor *governor;
788 unsigned long min_freq, max_freq;
789 int err = 0;
790
791 if (!dev || !profile || !governor_name) {
792 dev_err(dev, "%s: Invalid parameters.\n", __func__);
793 return ERR_PTR(-EINVAL);
794 }
795
796 mutex_lock(&devfreq_list_lock);
797 devfreq = find_device_devfreq(dev);
798 mutex_unlock(&devfreq_list_lock);
799 if (!IS_ERR(devfreq)) {
800 dev_err(dev, "%s: devfreq device already exists!\n",
801 __func__);
802 err = -EINVAL;
803 goto err_out;
804 }
805
806 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
807 if (!devfreq) {
808 err = -ENOMEM;
809 goto err_out;
810 }
811
812 mutex_init(&devfreq->lock);
813 mutex_lock(&devfreq->lock);
814 devfreq->dev.parent = dev;
815 devfreq->dev.class = devfreq_class;
816 devfreq->dev.release = devfreq_dev_release;
817 INIT_LIST_HEAD(&devfreq->node);
818 devfreq->profile = profile;
819 devfreq->previous_freq = profile->initial_freq;
820 devfreq->last_status.current_frequency = profile->initial_freq;
821 devfreq->data = data;
822 devfreq->nb.notifier_call = devfreq_notifier_call;
823
824 if (devfreq->profile->timer < 0
825 || devfreq->profile->timer >= DEVFREQ_TIMER_NUM) {
826 mutex_unlock(&devfreq->lock);
827 err = -EINVAL;
828 goto err_dev;
829 }
830
831 if (!devfreq->profile->max_state || !devfreq->profile->freq_table) {
832 mutex_unlock(&devfreq->lock);
833 err = set_freq_table(devfreq);
834 if (err < 0)
835 goto err_dev;
836 mutex_lock(&devfreq->lock);
837 } else {
838 devfreq->freq_table = devfreq->profile->freq_table;
839 devfreq->max_state = devfreq->profile->max_state;
840 }
841
842 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
843 if (!devfreq->scaling_min_freq) {
844 mutex_unlock(&devfreq->lock);
845 err = -EINVAL;
846 goto err_dev;
847 }
848
849 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
850 if (!devfreq->scaling_max_freq) {
851 mutex_unlock(&devfreq->lock);
852 err = -EINVAL;
853 goto err_dev;
854 }
855
856 devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
857
858 devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev);
859 devfreq->opp_table = dev_pm_opp_get_opp_table(dev);
860 if (IS_ERR(devfreq->opp_table))
861 devfreq->opp_table = NULL;
862
863 atomic_set(&devfreq->suspend_count, 0);
864
865 dev_set_name(&devfreq->dev, "%s", dev_name(dev));
866 err = device_register(&devfreq->dev);
867 if (err) {
868 mutex_unlock(&devfreq->lock);
869 put_device(&devfreq->dev);
870 goto err_out;
871 }
872
873 devfreq->stats.trans_table = devm_kzalloc(&devfreq->dev,
874 array3_size(sizeof(unsigned int),
875 devfreq->max_state,
876 devfreq->max_state),
877 GFP_KERNEL);
878 if (!devfreq->stats.trans_table) {
879 mutex_unlock(&devfreq->lock);
880 err = -ENOMEM;
881 goto err_devfreq;
882 }
883
884 devfreq->stats.time_in_state = devm_kcalloc(&devfreq->dev,
885 devfreq->max_state,
886 sizeof(*devfreq->stats.time_in_state),
887 GFP_KERNEL);
888 if (!devfreq->stats.time_in_state) {
889 mutex_unlock(&devfreq->lock);
890 err = -ENOMEM;
891 goto err_devfreq;
892 }
893
894 devfreq->stats.total_trans = 0;
895 devfreq->stats.last_update = get_jiffies_64();
896
897 srcu_init_notifier_head(&devfreq->transition_notifier_list);
898
899 mutex_unlock(&devfreq->lock);
900
901 err = dev_pm_qos_add_request(dev, &devfreq->user_min_freq_req,
902 DEV_PM_QOS_MIN_FREQUENCY, 0);
903 if (err < 0)
904 goto err_devfreq;
905 err = dev_pm_qos_add_request(dev, &devfreq->user_max_freq_req,
906 DEV_PM_QOS_MAX_FREQUENCY,
907 PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
908 if (err < 0)
909 goto err_devfreq;
910
911 devfreq->nb_min.notifier_call = qos_min_notifier_call;
912 err = dev_pm_qos_add_notifier(dev, &devfreq->nb_min,
913 DEV_PM_QOS_MIN_FREQUENCY);
914 if (err)
915 goto err_devfreq;
916
917 devfreq->nb_max.notifier_call = qos_max_notifier_call;
918 err = dev_pm_qos_add_notifier(dev, &devfreq->nb_max,
919 DEV_PM_QOS_MAX_FREQUENCY);
920 if (err)
921 goto err_devfreq;
922
923 mutex_lock(&devfreq_list_lock);
924
925 governor = try_then_request_governor(governor_name);
926 if (IS_ERR(governor)) {
927 dev_err(dev, "%s: Unable to find governor for the device\n",
928 __func__);
929 err = PTR_ERR(governor);
930 goto err_init;
931 }
932
933 devfreq->governor = governor;
934 err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
935 NULL);
936 if (err) {
937 dev_err_probe(dev, err,
938 "%s: Unable to start governor for the device\n",
939 __func__);
940 goto err_init;
941 }
942 create_sysfs_files(devfreq, devfreq->governor);
943
944 list_add(&devfreq->node, &devfreq_list);
945
946 mutex_unlock(&devfreq_list_lock);
947
948 if (devfreq->profile->is_cooling_device) {
949 devfreq->cdev = devfreq_cooling_em_register(devfreq, NULL);
950 if (IS_ERR(devfreq->cdev))
951 devfreq->cdev = NULL;
952 }
953
954 return devfreq;
955
956err_init:
957 mutex_unlock(&devfreq_list_lock);
958err_devfreq:
959 devfreq_remove_device(devfreq);
960 devfreq = NULL;
961err_dev:
962 kfree(devfreq);
963err_out:
964 return ERR_PTR(err);
965}
966EXPORT_SYMBOL(devfreq_add_device);
967
968/**
969 * devfreq_remove_device() - Remove devfreq feature from a device.
970 * @devfreq: the devfreq instance to be removed
971 *
972 * The opposite of devfreq_add_device().
973 */
974int devfreq_remove_device(struct devfreq *devfreq)
975{
976 if (!devfreq)
977 return -EINVAL;
978
979 devfreq_cooling_unregister(devfreq->cdev);
980
981 if (devfreq->governor) {
982 devfreq->governor->event_handler(devfreq,
983 DEVFREQ_GOV_STOP, NULL);
984 remove_sysfs_files(devfreq, devfreq->governor);
985 }
986
987 device_unregister(&devfreq->dev);
988
989 return 0;
990}
991EXPORT_SYMBOL(devfreq_remove_device);
992
993static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
994{
995 struct devfreq **r = res;
996
997 if (WARN_ON(!r || !*r))
998 return 0;
999
1000 return *r == data;
1001}
1002
1003static void devm_devfreq_dev_release(struct device *dev, void *res)
1004{
1005 devfreq_remove_device(*(struct devfreq **)res);
1006}
1007
1008/**
1009 * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
1010 * @dev: the device to add devfreq feature.
1011 * @profile: device-specific profile to run devfreq.
1012 * @governor_name: name of the policy to choose frequency.
1013 * @data: devfreq driver pass to governors, governor should not change it.
1014 *
1015 * This function manages automatically the memory of devfreq device using device
1016 * resource management and simplify the free operation for memory of devfreq
1017 * device.
1018 */
1019struct devfreq *devm_devfreq_add_device(struct device *dev,
1020 struct devfreq_dev_profile *profile,
1021 const char *governor_name,
1022 void *data)
1023{
1024 struct devfreq **ptr, *devfreq;
1025
1026 ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
1027 if (!ptr)
1028 return ERR_PTR(-ENOMEM);
1029
1030 devfreq = devfreq_add_device(dev, profile, governor_name, data);
1031 if (IS_ERR(devfreq)) {
1032 devres_free(ptr);
1033 return devfreq;
1034 }
1035
1036 *ptr = devfreq;
1037 devres_add(dev, ptr);
1038
1039 return devfreq;
1040}
1041EXPORT_SYMBOL(devm_devfreq_add_device);
1042
1043#ifdef CONFIG_OF
1044/*
1045 * devfreq_get_devfreq_by_node - Get the devfreq device from devicetree
1046 * @node - pointer to device_node
1047 *
1048 * return the instance of devfreq device
1049 */
1050struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1051{
1052 struct devfreq *devfreq;
1053
1054 if (!node)
1055 return ERR_PTR(-EINVAL);
1056
1057 mutex_lock(&devfreq_list_lock);
1058 list_for_each_entry(devfreq, &devfreq_list, node) {
1059 if (devfreq->dev.parent
1060 && device_match_of_node(devfreq->dev.parent, node)) {
1061 mutex_unlock(&devfreq_list_lock);
1062 return devfreq;
1063 }
1064 }
1065 mutex_unlock(&devfreq_list_lock);
1066
1067 return ERR_PTR(-ENODEV);
1068}
1069
1070/*
1071 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
1072 * @dev - instance to the given device
1073 * @phandle_name - name of property holding a phandle value
1074 * @index - index into list of devfreq
1075 *
1076 * return the instance of devfreq device
1077 */
1078struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev,
1079 const char *phandle_name, int index)
1080{
1081 struct device_node *node;
1082 struct devfreq *devfreq;
1083
1084 if (!dev || !phandle_name)
1085 return ERR_PTR(-EINVAL);
1086
1087 if (!dev->of_node)
1088 return ERR_PTR(-EINVAL);
1089
1090 node = of_parse_phandle(dev->of_node, phandle_name, index);
1091 if (!node)
1092 return ERR_PTR(-ENODEV);
1093
1094 devfreq = devfreq_get_devfreq_by_node(node);
1095 of_node_put(node);
1096
1097 return devfreq;
1098}
1099
1100#else
1101struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1102{
1103 return ERR_PTR(-ENODEV);
1104}
1105
1106struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev,
1107 const char *phandle_name, int index)
1108{
1109 return ERR_PTR(-ENODEV);
1110}
1111#endif /* CONFIG_OF */
1112EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_node);
1113EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
1114
1115/**
1116 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
1117 * @dev: the device from which to remove devfreq feature.
1118 * @devfreq: the devfreq instance to be removed
1119 */
1120void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
1121{
1122 WARN_ON(devres_release(dev, devm_devfreq_dev_release,
1123 devm_devfreq_dev_match, devfreq));
1124}
1125EXPORT_SYMBOL(devm_devfreq_remove_device);
1126
1127/**
1128 * devfreq_suspend_device() - Suspend devfreq of a device.
1129 * @devfreq: the devfreq instance to be suspended
1130 *
1131 * This function is intended to be called by the pm callbacks
1132 * (e.g., runtime_suspend, suspend) of the device driver that
1133 * holds the devfreq.
1134 */
1135int devfreq_suspend_device(struct devfreq *devfreq)
1136{
1137 int ret;
1138
1139 if (!devfreq)
1140 return -EINVAL;
1141
1142 if (atomic_inc_return(&devfreq->suspend_count) > 1)
1143 return 0;
1144
1145 if (devfreq->governor) {
1146 ret = devfreq->governor->event_handler(devfreq,
1147 DEVFREQ_GOV_SUSPEND, NULL);
1148 if (ret)
1149 return ret;
1150 }
1151
1152 if (devfreq->suspend_freq) {
1153 mutex_lock(&devfreq->lock);
1154 ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
1155 mutex_unlock(&devfreq->lock);
1156 if (ret)
1157 return ret;
1158 }
1159
1160 return 0;
1161}
1162EXPORT_SYMBOL(devfreq_suspend_device);
1163
1164/**
1165 * devfreq_resume_device() - Resume devfreq of a device.
1166 * @devfreq: the devfreq instance to be resumed
1167 *
1168 * This function is intended to be called by the pm callbacks
1169 * (e.g., runtime_resume, resume) of the device driver that
1170 * holds the devfreq.
1171 */
1172int devfreq_resume_device(struct devfreq *devfreq)
1173{
1174 int ret;
1175
1176 if (!devfreq)
1177 return -EINVAL;
1178
1179 if (atomic_dec_return(&devfreq->suspend_count) >= 1)
1180 return 0;
1181
1182 if (devfreq->resume_freq) {
1183 mutex_lock(&devfreq->lock);
1184 ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
1185 mutex_unlock(&devfreq->lock);
1186 if (ret)
1187 return ret;
1188 }
1189
1190 if (devfreq->governor) {
1191 ret = devfreq->governor->event_handler(devfreq,
1192 DEVFREQ_GOV_RESUME, NULL);
1193 if (ret)
1194 return ret;
1195 }
1196
1197 return 0;
1198}
1199EXPORT_SYMBOL(devfreq_resume_device);
1200
1201/**
1202 * devfreq_suspend() - Suspend devfreq governors and devices
1203 *
1204 * Called during system wide Suspend/Hibernate cycles for suspending governors
1205 * and devices preserving the state for resume. On some platforms the devfreq
1206 * device must have precise state (frequency) after resume in order to provide
1207 * fully operating setup.
1208 */
1209void devfreq_suspend(void)
1210{
1211 struct devfreq *devfreq;
1212 int ret;
1213
1214 mutex_lock(&devfreq_list_lock);
1215 list_for_each_entry(devfreq, &devfreq_list, node) {
1216 ret = devfreq_suspend_device(devfreq);
1217 if (ret)
1218 dev_err(&devfreq->dev,
1219 "failed to suspend devfreq device\n");
1220 }
1221 mutex_unlock(&devfreq_list_lock);
1222}
1223
1224/**
1225 * devfreq_resume() - Resume devfreq governors and devices
1226 *
1227 * Called during system wide Suspend/Hibernate cycle for resuming governors and
1228 * devices that are suspended with devfreq_suspend().
1229 */
1230void devfreq_resume(void)
1231{
1232 struct devfreq *devfreq;
1233 int ret;
1234
1235 mutex_lock(&devfreq_list_lock);
1236 list_for_each_entry(devfreq, &devfreq_list, node) {
1237 ret = devfreq_resume_device(devfreq);
1238 if (ret)
1239 dev_warn(&devfreq->dev,
1240 "failed to resume devfreq device\n");
1241 }
1242 mutex_unlock(&devfreq_list_lock);
1243}
1244
1245/**
1246 * devfreq_add_governor() - Add devfreq governor
1247 * @governor: the devfreq governor to be added
1248 */
1249int devfreq_add_governor(struct devfreq_governor *governor)
1250{
1251 struct devfreq_governor *g;
1252 struct devfreq *devfreq;
1253 int err = 0;
1254
1255 if (!governor) {
1256 pr_err("%s: Invalid parameters.\n", __func__);
1257 return -EINVAL;
1258 }
1259
1260 mutex_lock(&devfreq_list_lock);
1261 g = find_devfreq_governor(governor->name);
1262 if (!IS_ERR(g)) {
1263 pr_err("%s: governor %s already registered\n", __func__,
1264 g->name);
1265 err = -EINVAL;
1266 goto err_out;
1267 }
1268
1269 list_add(&governor->node, &devfreq_governor_list);
1270
1271 list_for_each_entry(devfreq, &devfreq_list, node) {
1272 int ret = 0;
1273 struct device *dev = devfreq->dev.parent;
1274
1275 if (!strncmp(devfreq->governor->name, governor->name,
1276 DEVFREQ_NAME_LEN)) {
1277 /* The following should never occur */
1278 if (devfreq->governor) {
1279 dev_warn(dev,
1280 "%s: Governor %s already present\n",
1281 __func__, devfreq->governor->name);
1282 ret = devfreq->governor->event_handler(devfreq,
1283 DEVFREQ_GOV_STOP, NULL);
1284 if (ret) {
1285 dev_warn(dev,
1286 "%s: Governor %s stop = %d\n",
1287 __func__,
1288 devfreq->governor->name, ret);
1289 }
1290 /* Fall through */
1291 }
1292 devfreq->governor = governor;
1293 ret = devfreq->governor->event_handler(devfreq,
1294 DEVFREQ_GOV_START, NULL);
1295 if (ret) {
1296 dev_warn(dev, "%s: Governor %s start=%d\n",
1297 __func__, devfreq->governor->name,
1298 ret);
1299 }
1300 }
1301 }
1302
1303err_out:
1304 mutex_unlock(&devfreq_list_lock);
1305
1306 return err;
1307}
1308EXPORT_SYMBOL(devfreq_add_governor);
1309
1310static void devm_devfreq_remove_governor(void *governor)
1311{
1312 WARN_ON(devfreq_remove_governor(governor));
1313}
1314
1315/**
1316 * devm_devfreq_add_governor() - Add devfreq governor
1317 * @dev: device which adds devfreq governor
1318 * @governor: the devfreq governor to be added
1319 *
1320 * This is a resource-managed variant of devfreq_add_governor().
1321 */
1322int devm_devfreq_add_governor(struct device *dev,
1323 struct devfreq_governor *governor)
1324{
1325 int err;
1326
1327 err = devfreq_add_governor(governor);
1328 if (err)
1329 return err;
1330
1331 return devm_add_action_or_reset(dev, devm_devfreq_remove_governor,
1332 governor);
1333}
1334EXPORT_SYMBOL(devm_devfreq_add_governor);
1335
1336/**
1337 * devfreq_remove_governor() - Remove devfreq feature from a device.
1338 * @governor: the devfreq governor to be removed
1339 */
1340int devfreq_remove_governor(struct devfreq_governor *governor)
1341{
1342 struct devfreq_governor *g;
1343 struct devfreq *devfreq;
1344 int err = 0;
1345
1346 if (!governor) {
1347 pr_err("%s: Invalid parameters.\n", __func__);
1348 return -EINVAL;
1349 }
1350
1351 mutex_lock(&devfreq_list_lock);
1352 g = find_devfreq_governor(governor->name);
1353 if (IS_ERR(g)) {
1354 pr_err("%s: governor %s not registered\n", __func__,
1355 governor->name);
1356 err = PTR_ERR(g);
1357 goto err_out;
1358 }
1359 list_for_each_entry(devfreq, &devfreq_list, node) {
1360 int ret;
1361 struct device *dev = devfreq->dev.parent;
1362
1363 if (!strncmp(devfreq->governor->name, governor->name,
1364 DEVFREQ_NAME_LEN)) {
1365 /* we should have a devfreq governor! */
1366 if (!devfreq->governor) {
1367 dev_warn(dev, "%s: Governor %s NOT present\n",
1368 __func__, governor->name);
1369 continue;
1370 /* Fall through */
1371 }
1372 ret = devfreq->governor->event_handler(devfreq,
1373 DEVFREQ_GOV_STOP, NULL);
1374 if (ret) {
1375 dev_warn(dev, "%s: Governor %s stop=%d\n",
1376 __func__, devfreq->governor->name,
1377 ret);
1378 }
1379 devfreq->governor = NULL;
1380 }
1381 }
1382
1383 list_del(&governor->node);
1384err_out:
1385 mutex_unlock(&devfreq_list_lock);
1386
1387 return err;
1388}
1389EXPORT_SYMBOL(devfreq_remove_governor);
1390
1391static ssize_t name_show(struct device *dev,
1392 struct device_attribute *attr, char *buf)
1393{
1394 struct devfreq *df = to_devfreq(dev);
1395 return sprintf(buf, "%s\n", dev_name(df->dev.parent));
1396}
1397static DEVICE_ATTR_RO(name);
1398
1399static ssize_t governor_show(struct device *dev,
1400 struct device_attribute *attr, char *buf)
1401{
1402 struct devfreq *df = to_devfreq(dev);
1403
1404 if (!df->governor)
1405 return -EINVAL;
1406
1407 return sprintf(buf, "%s\n", df->governor->name);
1408}
1409
1410static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
1411 const char *buf, size_t count)
1412{
1413 struct devfreq *df = to_devfreq(dev);
1414 int ret;
1415 char str_governor[DEVFREQ_NAME_LEN + 1];
1416 const struct devfreq_governor *governor, *prev_governor;
1417
1418 if (!df->governor)
1419 return -EINVAL;
1420
1421 ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
1422 if (ret != 1)
1423 return -EINVAL;
1424
1425 mutex_lock(&devfreq_list_lock);
1426 governor = try_then_request_governor(str_governor);
1427 if (IS_ERR(governor)) {
1428 ret = PTR_ERR(governor);
1429 goto out;
1430 }
1431 if (df->governor == governor) {
1432 ret = 0;
1433 goto out;
1434 } else if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE)
1435 || IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE)) {
1436 ret = -EINVAL;
1437 goto out;
1438 }
1439
1440 /*
1441 * Stop the current governor and remove the specific sysfs files
1442 * which depend on current governor.
1443 */
1444 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1445 if (ret) {
1446 dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1447 __func__, df->governor->name, ret);
1448 goto out;
1449 }
1450 remove_sysfs_files(df, df->governor);
1451
1452 /*
1453 * Start the new governor and create the specific sysfs files
1454 * which depend on the new governor.
1455 */
1456 prev_governor = df->governor;
1457 df->governor = governor;
1458 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1459 if (ret) {
1460 dev_warn(dev, "%s: Governor %s not started(%d)\n",
1461 __func__, df->governor->name, ret);
1462
1463 /* Restore previous governor */
1464 df->governor = prev_governor;
1465 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1466 if (ret) {
1467 dev_err(dev,
1468 "%s: reverting to Governor %s failed (%d)\n",
1469 __func__, prev_governor->name, ret);
1470 df->governor = NULL;
1471 goto out;
1472 }
1473 }
1474
1475 /*
1476 * Create the sysfs files for the new governor. But if failed to start
1477 * the new governor, restore the sysfs files of previous governor.
1478 */
1479 create_sysfs_files(df, df->governor);
1480
1481out:
1482 mutex_unlock(&devfreq_list_lock);
1483
1484 if (!ret)
1485 ret = count;
1486 return ret;
1487}
1488static DEVICE_ATTR_RW(governor);
1489
1490static ssize_t available_governors_show(struct device *d,
1491 struct device_attribute *attr,
1492 char *buf)
1493{
1494 struct devfreq *df = to_devfreq(d);
1495 ssize_t count = 0;
1496
1497 if (!df->governor)
1498 return -EINVAL;
1499
1500 mutex_lock(&devfreq_list_lock);
1501
1502 /*
1503 * The devfreq with immutable governor (e.g., passive) shows
1504 * only own governor.
1505 */
1506 if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE)) {
1507 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
1508 "%s ", df->governor->name);
1509 /*
1510 * The devfreq device shows the registered governor except for
1511 * immutable governors such as passive governor .
1512 */
1513 } else {
1514 struct devfreq_governor *governor;
1515
1516 list_for_each_entry(governor, &devfreq_governor_list, node) {
1517 if (IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE))
1518 continue;
1519 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1520 "%s ", governor->name);
1521 }
1522 }
1523
1524 mutex_unlock(&devfreq_list_lock);
1525
1526 /* Truncate the trailing space */
1527 if (count)
1528 count--;
1529
1530 count += sprintf(&buf[count], "\n");
1531
1532 return count;
1533}
1534static DEVICE_ATTR_RO(available_governors);
1535
1536static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr,
1537 char *buf)
1538{
1539 unsigned long freq;
1540 struct devfreq *df = to_devfreq(dev);
1541
1542 if (!df->profile)
1543 return -EINVAL;
1544
1545 if (df->profile->get_cur_freq &&
1546 !df->profile->get_cur_freq(df->dev.parent, &freq))
1547 return sprintf(buf, "%lu\n", freq);
1548
1549 return sprintf(buf, "%lu\n", df->previous_freq);
1550}
1551static DEVICE_ATTR_RO(cur_freq);
1552
1553static ssize_t target_freq_show(struct device *dev,
1554 struct device_attribute *attr, char *buf)
1555{
1556 struct devfreq *df = to_devfreq(dev);
1557
1558 return sprintf(buf, "%lu\n", df->previous_freq);
1559}
1560static DEVICE_ATTR_RO(target_freq);
1561
1562static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
1563 const char *buf, size_t count)
1564{
1565 struct devfreq *df = to_devfreq(dev);
1566 unsigned long value;
1567 int ret;
1568
1569 /*
1570 * Protect against theoretical sysfs writes between
1571 * device_add and dev_pm_qos_add_request
1572 */
1573 if (!dev_pm_qos_request_active(&df->user_min_freq_req))
1574 return -EAGAIN;
1575
1576 ret = sscanf(buf, "%lu", &value);
1577 if (ret != 1)
1578 return -EINVAL;
1579
1580 /* Round down to kHz for PM QoS */
1581 ret = dev_pm_qos_update_request(&df->user_min_freq_req,
1582 value / HZ_PER_KHZ);
1583 if (ret < 0)
1584 return ret;
1585
1586 return count;
1587}
1588
1589static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr,
1590 char *buf)
1591{
1592 struct devfreq *df = to_devfreq(dev);
1593 unsigned long min_freq, max_freq;
1594
1595 mutex_lock(&df->lock);
1596 devfreq_get_freq_range(df, &min_freq, &max_freq);
1597 mutex_unlock(&df->lock);
1598
1599 return sprintf(buf, "%lu\n", min_freq);
1600}
1601static DEVICE_ATTR_RW(min_freq);
1602
1603static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
1604 const char *buf, size_t count)
1605{
1606 struct devfreq *df = to_devfreq(dev);
1607 unsigned long value;
1608 int ret;
1609
1610 /*
1611 * Protect against theoretical sysfs writes between
1612 * device_add and dev_pm_qos_add_request
1613 */
1614 if (!dev_pm_qos_request_active(&df->user_max_freq_req))
1615 return -EINVAL;
1616
1617 ret = sscanf(buf, "%lu", &value);
1618 if (ret != 1)
1619 return -EINVAL;
1620
1621 /*
1622 * PM QoS frequencies are in kHz so we need to convert. Convert by
1623 * rounding upwards so that the acceptable interval never shrinks.
1624 *
1625 * For example if the user writes "666666666" to sysfs this value will
1626 * be converted to 666667 kHz and back to 666667000 Hz before an OPP
1627 * lookup, this ensures that an OPP of 666666666Hz is still accepted.
1628 *
1629 * A value of zero means "no limit".
1630 */
1631 if (value)
1632 value = DIV_ROUND_UP(value, HZ_PER_KHZ);
1633 else
1634 value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;
1635
1636 ret = dev_pm_qos_update_request(&df->user_max_freq_req, value);
1637 if (ret < 0)
1638 return ret;
1639
1640 return count;
1641}
1642
1643static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr,
1644 char *buf)
1645{
1646 struct devfreq *df = to_devfreq(dev);
1647 unsigned long min_freq, max_freq;
1648
1649 mutex_lock(&df->lock);
1650 devfreq_get_freq_range(df, &min_freq, &max_freq);
1651 mutex_unlock(&df->lock);
1652
1653 return sprintf(buf, "%lu\n", max_freq);
1654}
1655static DEVICE_ATTR_RW(max_freq);
1656
1657static ssize_t available_frequencies_show(struct device *d,
1658 struct device_attribute *attr,
1659 char *buf)
1660{
1661 struct devfreq *df = to_devfreq(d);
1662 ssize_t count = 0;
1663 int i;
1664
1665 if (!df->profile)
1666 return -EINVAL;
1667
1668 mutex_lock(&df->lock);
1669
1670 for (i = 0; i < df->max_state; i++)
1671 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1672 "%lu ", df->freq_table[i]);
1673
1674 mutex_unlock(&df->lock);
1675 /* Truncate the trailing space */
1676 if (count)
1677 count--;
1678
1679 count += sprintf(&buf[count], "\n");
1680
1681 return count;
1682}
1683static DEVICE_ATTR_RO(available_frequencies);
1684
1685static ssize_t trans_stat_show(struct device *dev,
1686 struct device_attribute *attr, char *buf)
1687{
1688 struct devfreq *df = to_devfreq(dev);
1689 ssize_t len;
1690 int i, j;
1691 unsigned int max_state;
1692
1693 if (!df->profile)
1694 return -EINVAL;
1695 max_state = df->max_state;
1696
1697 if (max_state == 0)
1698 return sprintf(buf, "Not Supported.\n");
1699
1700 mutex_lock(&df->lock);
1701 if (!df->stop_polling &&
1702 devfreq_update_status(df, df->previous_freq)) {
1703 mutex_unlock(&df->lock);
1704 return 0;
1705 }
1706 mutex_unlock(&df->lock);
1707
1708 len = sprintf(buf, " From : To\n");
1709 len += sprintf(buf + len, " :");
1710 for (i = 0; i < max_state; i++)
1711 len += sprintf(buf + len, "%10lu",
1712 df->freq_table[i]);
1713
1714 len += sprintf(buf + len, " time(ms)\n");
1715
1716 for (i = 0; i < max_state; i++) {
1717 if (df->freq_table[i] == df->previous_freq)
1718 len += sprintf(buf + len, "*");
1719 else
1720 len += sprintf(buf + len, " ");
1721
1722 len += sprintf(buf + len, "%10lu:", df->freq_table[i]);
1723 for (j = 0; j < max_state; j++)
1724 len += sprintf(buf + len, "%10u",
1725 df->stats.trans_table[(i * max_state) + j]);
1726
1727 len += sprintf(buf + len, "%10llu\n", (u64)
1728 jiffies64_to_msecs(df->stats.time_in_state[i]));
1729 }
1730
1731 len += sprintf(buf + len, "Total transition : %u\n",
1732 df->stats.total_trans);
1733 return len;
1734}
1735
1736static ssize_t trans_stat_store(struct device *dev,
1737 struct device_attribute *attr,
1738 const char *buf, size_t count)
1739{
1740 struct devfreq *df = to_devfreq(dev);
1741 int err, value;
1742
1743 if (!df->profile)
1744 return -EINVAL;
1745
1746 if (df->max_state == 0)
1747 return count;
1748
1749 err = kstrtoint(buf, 10, &value);
1750 if (err || value != 0)
1751 return -EINVAL;
1752
1753 mutex_lock(&df->lock);
1754 memset(df->stats.time_in_state, 0, (df->max_state *
1755 sizeof(*df->stats.time_in_state)));
1756 memset(df->stats.trans_table, 0, array3_size(sizeof(unsigned int),
1757 df->max_state,
1758 df->max_state));
1759 df->stats.total_trans = 0;
1760 df->stats.last_update = get_jiffies_64();
1761 mutex_unlock(&df->lock);
1762
1763 return count;
1764}
1765static DEVICE_ATTR_RW(trans_stat);
1766
1767static struct attribute *devfreq_attrs[] = {
1768 &dev_attr_name.attr,
1769 &dev_attr_governor.attr,
1770 &dev_attr_available_governors.attr,
1771 &dev_attr_cur_freq.attr,
1772 &dev_attr_available_frequencies.attr,
1773 &dev_attr_target_freq.attr,
1774 &dev_attr_min_freq.attr,
1775 &dev_attr_max_freq.attr,
1776 &dev_attr_trans_stat.attr,
1777 NULL,
1778};
1779ATTRIBUTE_GROUPS(devfreq);
1780
1781static ssize_t polling_interval_show(struct device *dev,
1782 struct device_attribute *attr, char *buf)
1783{
1784 struct devfreq *df = to_devfreq(dev);
1785
1786 if (!df->profile)
1787 return -EINVAL;
1788
1789 return sprintf(buf, "%d\n", df->profile->polling_ms);
1790}
1791
1792static ssize_t polling_interval_store(struct device *dev,
1793 struct device_attribute *attr,
1794 const char *buf, size_t count)
1795{
1796 struct devfreq *df = to_devfreq(dev);
1797 unsigned int value;
1798 int ret;
1799
1800 if (!df->governor)
1801 return -EINVAL;
1802
1803 ret = sscanf(buf, "%u", &value);
1804 if (ret != 1)
1805 return -EINVAL;
1806
1807 df->governor->event_handler(df, DEVFREQ_GOV_UPDATE_INTERVAL, &value);
1808 ret = count;
1809
1810 return ret;
1811}
1812static DEVICE_ATTR_RW(polling_interval);
1813
1814static ssize_t timer_show(struct device *dev,
1815 struct device_attribute *attr, char *buf)
1816{
1817 struct devfreq *df = to_devfreq(dev);
1818
1819 if (!df->profile)
1820 return -EINVAL;
1821
1822 return sprintf(buf, "%s\n", timer_name[df->profile->timer]);
1823}
1824
1825static ssize_t timer_store(struct device *dev, struct device_attribute *attr,
1826 const char *buf, size_t count)
1827{
1828 struct devfreq *df = to_devfreq(dev);
1829 char str_timer[DEVFREQ_NAME_LEN + 1];
1830 int timer = -1;
1831 int ret = 0, i;
1832
1833 if (!df->governor || !df->profile)
1834 return -EINVAL;
1835
1836 ret = sscanf(buf, "%16s", str_timer);
1837 if (ret != 1)
1838 return -EINVAL;
1839
1840 for (i = 0; i < DEVFREQ_TIMER_NUM; i++) {
1841 if (!strncmp(timer_name[i], str_timer, DEVFREQ_NAME_LEN)) {
1842 timer = i;
1843 break;
1844 }
1845 }
1846
1847 if (timer < 0) {
1848 ret = -EINVAL;
1849 goto out;
1850 }
1851
1852 if (df->profile->timer == timer) {
1853 ret = 0;
1854 goto out;
1855 }
1856
1857 mutex_lock(&df->lock);
1858 df->profile->timer = timer;
1859 mutex_unlock(&df->lock);
1860
1861 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1862 if (ret) {
1863 dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1864 __func__, df->governor->name, ret);
1865 goto out;
1866 }
1867
1868 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1869 if (ret)
1870 dev_warn(dev, "%s: Governor %s not started(%d)\n",
1871 __func__, df->governor->name, ret);
1872out:
1873 return ret ? ret : count;
1874}
1875static DEVICE_ATTR_RW(timer);
1876
1877#define CREATE_SYSFS_FILE(df, name) \
1878{ \
1879 int ret; \
1880 ret = sysfs_create_file(&df->dev.kobj, &dev_attr_##name.attr); \
1881 if (ret < 0) { \
1882 dev_warn(&df->dev, \
1883 "Unable to create attr(%s)\n", "##name"); \
1884 } \
1885} \
1886
1887/* Create the specific sysfs files which depend on each governor. */
1888static void create_sysfs_files(struct devfreq *devfreq,
1889 const struct devfreq_governor *gov)
1890{
1891 if (IS_SUPPORTED_ATTR(gov->attrs, POLLING_INTERVAL))
1892 CREATE_SYSFS_FILE(devfreq, polling_interval);
1893 if (IS_SUPPORTED_ATTR(gov->attrs, TIMER))
1894 CREATE_SYSFS_FILE(devfreq, timer);
1895}
1896
1897/* Remove the specific sysfs files which depend on each governor. */
1898static void remove_sysfs_files(struct devfreq *devfreq,
1899 const struct devfreq_governor *gov)
1900{
1901 if (IS_SUPPORTED_ATTR(gov->attrs, POLLING_INTERVAL))
1902 sysfs_remove_file(&devfreq->dev.kobj,
1903 &dev_attr_polling_interval.attr);
1904 if (IS_SUPPORTED_ATTR(gov->attrs, TIMER))
1905 sysfs_remove_file(&devfreq->dev.kobj, &dev_attr_timer.attr);
1906}
1907
1908/**
1909 * devfreq_summary_show() - Show the summary of the devfreq devices
1910 * @s: seq_file instance to show the summary of devfreq devices
1911 * @data: not used
1912 *
1913 * Show the summary of the devfreq devices via 'devfreq_summary' debugfs file.
1914 * It helps that user can know the detailed information of the devfreq devices.
1915 *
1916 * Return 0 always because it shows the information without any data change.
1917 */
1918static int devfreq_summary_show(struct seq_file *s, void *data)
1919{
1920 struct devfreq *devfreq;
1921 struct devfreq *p_devfreq = NULL;
1922 unsigned long cur_freq, min_freq, max_freq;
1923 unsigned int polling_ms;
1924 unsigned int timer;
1925
1926 seq_printf(s, "%-30s %-30s %-15s %-10s %10s %12s %12s %12s\n",
1927 "dev",
1928 "parent_dev",
1929 "governor",
1930 "timer",
1931 "polling_ms",
1932 "cur_freq_Hz",
1933 "min_freq_Hz",
1934 "max_freq_Hz");
1935 seq_printf(s, "%30s %30s %15s %10s %10s %12s %12s %12s\n",
1936 "------------------------------",
1937 "------------------------------",
1938 "---------------",
1939 "----------",
1940 "----------",
1941 "------------",
1942 "------------",
1943 "------------");
1944
1945 mutex_lock(&devfreq_list_lock);
1946
1947 list_for_each_entry_reverse(devfreq, &devfreq_list, node) {
1948#if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE)
1949 if (!strncmp(devfreq->governor->name, DEVFREQ_GOV_PASSIVE,
1950 DEVFREQ_NAME_LEN)) {
1951 struct devfreq_passive_data *data = devfreq->data;
1952
1953 if (data)
1954 p_devfreq = data->parent;
1955 } else {
1956 p_devfreq = NULL;
1957 }
1958#endif
1959
1960 mutex_lock(&devfreq->lock);
1961 cur_freq = devfreq->previous_freq;
1962 devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
1963 timer = devfreq->profile->timer;
1964
1965 if (IS_SUPPORTED_ATTR(devfreq->governor->attrs, POLLING_INTERVAL))
1966 polling_ms = devfreq->profile->polling_ms;
1967 else
1968 polling_ms = 0;
1969 mutex_unlock(&devfreq->lock);
1970
1971 seq_printf(s,
1972 "%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n",
1973 dev_name(&devfreq->dev),
1974 p_devfreq ? dev_name(&p_devfreq->dev) : "null",
1975 devfreq->governor->name,
1976 polling_ms ? timer_name[timer] : "null",
1977 polling_ms,
1978 cur_freq,
1979 min_freq,
1980 max_freq);
1981 }
1982
1983 mutex_unlock(&devfreq_list_lock);
1984
1985 return 0;
1986}
1987DEFINE_SHOW_ATTRIBUTE(devfreq_summary);
1988
1989static int __init devfreq_init(void)
1990{
1991 devfreq_class = class_create(THIS_MODULE, "devfreq");
1992 if (IS_ERR(devfreq_class)) {
1993 pr_err("%s: couldn't create class\n", __FILE__);
1994 return PTR_ERR(devfreq_class);
1995 }
1996
1997 devfreq_wq = create_freezable_workqueue("devfreq_wq");
1998 if (!devfreq_wq) {
1999 class_destroy(devfreq_class);
2000 pr_err("%s: couldn't create workqueue\n", __FILE__);
2001 return -ENOMEM;
2002 }
2003 devfreq_class->dev_groups = devfreq_groups;
2004
2005 devfreq_debugfs = debugfs_create_dir("devfreq", NULL);
2006 debugfs_create_file("devfreq_summary", 0444,
2007 devfreq_debugfs, NULL,
2008 &devfreq_summary_fops);
2009
2010 return 0;
2011}
2012subsys_initcall(devfreq_init);
2013
2014/*
2015 * The following are helper functions for devfreq user device drivers with
2016 * OPP framework.
2017 */
2018
2019/**
2020 * devfreq_recommended_opp() - Helper function to get proper OPP for the
2021 * freq value given to target callback.
2022 * @dev: The devfreq user device. (parent of devfreq)
2023 * @freq: The frequency given to target function
2024 * @flags: Flags handed from devfreq framework.
2025 *
2026 * The callers are required to call dev_pm_opp_put() for the returned OPP after
2027 * use.
2028 */
2029struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
2030 unsigned long *freq,
2031 u32 flags)
2032{
2033 struct dev_pm_opp *opp;
2034
2035 if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
2036 /* The freq is an upper bound. opp should be lower */
2037 opp = dev_pm_opp_find_freq_floor(dev, freq);
2038
2039 /* If not available, use the closest opp */
2040 if (opp == ERR_PTR(-ERANGE))
2041 opp = dev_pm_opp_find_freq_ceil(dev, freq);
2042 } else {
2043 /* The freq is an lower bound. opp should be higher */
2044 opp = dev_pm_opp_find_freq_ceil(dev, freq);
2045
2046 /* If not available, use the closest opp */
2047 if (opp == ERR_PTR(-ERANGE))
2048 opp = dev_pm_opp_find_freq_floor(dev, freq);
2049 }
2050
2051 return opp;
2052}
2053EXPORT_SYMBOL(devfreq_recommended_opp);
2054
2055/**
2056 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
2057 * for any changes in the OPP availability
2058 * changes
2059 * @dev: The devfreq user device. (parent of devfreq)
2060 * @devfreq: The devfreq object.
2061 */
2062int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
2063{
2064 return dev_pm_opp_register_notifier(dev, &devfreq->nb);
2065}
2066EXPORT_SYMBOL(devfreq_register_opp_notifier);
2067
2068/**
2069 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
2070 * notified for any changes in the OPP
2071 * availability changes anymore.
2072 * @dev: The devfreq user device. (parent of devfreq)
2073 * @devfreq: The devfreq object.
2074 *
2075 * At exit() callback of devfreq_dev_profile, this must be included if
2076 * devfreq_recommended_opp is used.
2077 */
2078int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
2079{
2080 return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
2081}
2082EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
2083
2084static void devm_devfreq_opp_release(struct device *dev, void *res)
2085{
2086 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
2087}
2088
2089/**
2090 * devm_devfreq_register_opp_notifier() - Resource-managed
2091 * devfreq_register_opp_notifier()
2092 * @dev: The devfreq user device. (parent of devfreq)
2093 * @devfreq: The devfreq object.
2094 */
2095int devm_devfreq_register_opp_notifier(struct device *dev,
2096 struct devfreq *devfreq)
2097{
2098 struct devfreq **ptr;
2099 int ret;
2100
2101 ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
2102 if (!ptr)
2103 return -ENOMEM;
2104
2105 ret = devfreq_register_opp_notifier(dev, devfreq);
2106 if (ret) {
2107 devres_free(ptr);
2108 return ret;
2109 }
2110
2111 *ptr = devfreq;
2112 devres_add(dev, ptr);
2113
2114 return 0;
2115}
2116EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
2117
2118/**
2119 * devm_devfreq_unregister_opp_notifier() - Resource-managed
2120 * devfreq_unregister_opp_notifier()
2121 * @dev: The devfreq user device. (parent of devfreq)
2122 * @devfreq: The devfreq object.
2123 */
2124void devm_devfreq_unregister_opp_notifier(struct device *dev,
2125 struct devfreq *devfreq)
2126{
2127 WARN_ON(devres_release(dev, devm_devfreq_opp_release,
2128 devm_devfreq_dev_match, devfreq));
2129}
2130EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
2131
2132/**
2133 * devfreq_register_notifier() - Register a driver with devfreq
2134 * @devfreq: The devfreq object.
2135 * @nb: The notifier block to register.
2136 * @list: DEVFREQ_TRANSITION_NOTIFIER.
2137 */
2138int devfreq_register_notifier(struct devfreq *devfreq,
2139 struct notifier_block *nb,
2140 unsigned int list)
2141{
2142 int ret = 0;
2143
2144 if (!devfreq)
2145 return -EINVAL;
2146
2147 switch (list) {
2148 case DEVFREQ_TRANSITION_NOTIFIER:
2149 ret = srcu_notifier_chain_register(
2150 &devfreq->transition_notifier_list, nb);
2151 break;
2152 default:
2153 ret = -EINVAL;
2154 }
2155
2156 return ret;
2157}
2158EXPORT_SYMBOL(devfreq_register_notifier);
2159
2160/*
2161 * devfreq_unregister_notifier() - Unregister a driver with devfreq
2162 * @devfreq: The devfreq object.
2163 * @nb: The notifier block to be unregistered.
2164 * @list: DEVFREQ_TRANSITION_NOTIFIER.
2165 */
2166int devfreq_unregister_notifier(struct devfreq *devfreq,
2167 struct notifier_block *nb,
2168 unsigned int list)
2169{
2170 int ret = 0;
2171
2172 if (!devfreq)
2173 return -EINVAL;
2174
2175 switch (list) {
2176 case DEVFREQ_TRANSITION_NOTIFIER:
2177 ret = srcu_notifier_chain_unregister(
2178 &devfreq->transition_notifier_list, nb);
2179 break;
2180 default:
2181 ret = -EINVAL;
2182 }
2183
2184 return ret;
2185}
2186EXPORT_SYMBOL(devfreq_unregister_notifier);
2187
2188struct devfreq_notifier_devres {
2189 struct devfreq *devfreq;
2190 struct notifier_block *nb;
2191 unsigned int list;
2192};
2193
2194static void devm_devfreq_notifier_release(struct device *dev, void *res)
2195{
2196 struct devfreq_notifier_devres *this = res;
2197
2198 devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
2199}
2200
2201/**
2202 * devm_devfreq_register_notifier()
2203 * - Resource-managed devfreq_register_notifier()
2204 * @dev: The devfreq user device. (parent of devfreq)
2205 * @devfreq: The devfreq object.
2206 * @nb: The notifier block to be unregistered.
2207 * @list: DEVFREQ_TRANSITION_NOTIFIER.
2208 */
2209int devm_devfreq_register_notifier(struct device *dev,
2210 struct devfreq *devfreq,
2211 struct notifier_block *nb,
2212 unsigned int list)
2213{
2214 struct devfreq_notifier_devres *ptr;
2215 int ret;
2216
2217 ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
2218 GFP_KERNEL);
2219 if (!ptr)
2220 return -ENOMEM;
2221
2222 ret = devfreq_register_notifier(devfreq, nb, list);
2223 if (ret) {
2224 devres_free(ptr);
2225 return ret;
2226 }
2227
2228 ptr->devfreq = devfreq;
2229 ptr->nb = nb;
2230 ptr->list = list;
2231 devres_add(dev, ptr);
2232
2233 return 0;
2234}
2235EXPORT_SYMBOL(devm_devfreq_register_notifier);
2236
2237/**
2238 * devm_devfreq_unregister_notifier()
2239 * - Resource-managed devfreq_unregister_notifier()
2240 * @dev: The devfreq user device. (parent of devfreq)
2241 * @devfreq: The devfreq object.
2242 * @nb: The notifier block to be unregistered.
2243 * @list: DEVFREQ_TRANSITION_NOTIFIER.
2244 */
2245void devm_devfreq_unregister_notifier(struct device *dev,
2246 struct devfreq *devfreq,
2247 struct notifier_block *nb,
2248 unsigned int list)
2249{
2250 WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
2251 devm_devfreq_dev_match, devfreq));
2252}
2253EXPORT_SYMBOL(devm_devfreq_unregister_notifier);