2 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
5 * Copyright (C) 2011 Samsung Electronics
6 * MyungJoo Ham <myungjoo.ham@samsung.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/kernel.h>
14 #include <linux/sched.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>
31 static struct class *devfreq_class
;
34 * devfreq core provides delayed work based load monitoring helper
35 * functions. Governors can use these or can implement their own
36 * monitoring mechanism.
38 static struct workqueue_struct
*devfreq_wq
;
40 /* The list of all device-devfreq governors */
41 static LIST_HEAD(devfreq_governor_list
);
42 /* The list of all device-devfreq */
43 static LIST_HEAD(devfreq_list
);
44 static DEFINE_MUTEX(devfreq_list_lock
);
47 * find_device_devfreq() - find devfreq struct using device pointer
48 * @dev: device pointer used to lookup device devfreq.
50 * Search the list of device devfreqs and return the matched device's
51 * devfreq info. devfreq_list_lock should be held by the caller.
53 static struct devfreq
*find_device_devfreq(struct device
*dev
)
55 struct devfreq
*tmp_devfreq
;
57 if (IS_ERR_OR_NULL(dev
)) {
58 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__
);
59 return ERR_PTR(-EINVAL
);
61 WARN(!mutex_is_locked(&devfreq_list_lock
),
62 "devfreq_list_lock must be locked.");
64 list_for_each_entry(tmp_devfreq
, &devfreq_list
, node
) {
65 if (tmp_devfreq
->dev
.parent
== dev
)
69 return ERR_PTR(-ENODEV
);
73 * devfreq_get_freq_level() - Lookup freq_table for the frequency
74 * @devfreq: the devfreq instance
75 * @freq: the target frequency
77 static int devfreq_get_freq_level(struct devfreq
*devfreq
, unsigned long freq
)
81 for (lev
= 0; lev
< devfreq
->profile
->max_state
; lev
++)
82 if (freq
== devfreq
->profile
->freq_table
[lev
])
89 * devfreq_set_freq_table() - Initialize freq_table for the frequency
90 * @devfreq: the devfreq instance
92 static void devfreq_set_freq_table(struct devfreq
*devfreq
)
94 struct devfreq_dev_profile
*profile
= devfreq
->profile
;
95 struct dev_pm_opp
*opp
;
99 /* Initialize the freq_table from OPP table */
100 count
= dev_pm_opp_get_opp_count(devfreq
->dev
.parent
);
104 profile
->max_state
= count
;
105 profile
->freq_table
= devm_kcalloc(devfreq
->dev
.parent
,
107 sizeof(*profile
->freq_table
),
109 if (!profile
->freq_table
) {
110 profile
->max_state
= 0;
114 for (i
= 0, freq
= 0; i
< profile
->max_state
; i
++, freq
++) {
115 opp
= dev_pm_opp_find_freq_ceil(devfreq
->dev
.parent
, &freq
);
117 devm_kfree(devfreq
->dev
.parent
, profile
->freq_table
);
118 profile
->max_state
= 0;
122 profile
->freq_table
[i
] = freq
;
127 * devfreq_update_status() - Update statistics of devfreq behavior
128 * @devfreq: the devfreq instance
129 * @freq: the update target frequency
131 int devfreq_update_status(struct devfreq
*devfreq
, unsigned long freq
)
133 int lev
, prev_lev
, ret
= 0;
134 unsigned long cur_time
;
138 /* Immediately exit if previous_freq is not initialized yet. */
139 if (!devfreq
->previous_freq
)
142 prev_lev
= devfreq_get_freq_level(devfreq
, devfreq
->previous_freq
);
148 devfreq
->time_in_state
[prev_lev
] +=
149 cur_time
- devfreq
->last_stat_updated
;
151 lev
= devfreq_get_freq_level(devfreq
, freq
);
157 if (lev
!= prev_lev
) {
158 devfreq
->trans_table
[(prev_lev
*
159 devfreq
->profile
->max_state
) + lev
]++;
160 devfreq
->total_trans
++;
164 devfreq
->last_stat_updated
= cur_time
;
167 EXPORT_SYMBOL(devfreq_update_status
);
170 * find_devfreq_governor() - find devfreq governor from name
171 * @name: name of the governor
173 * Search the list of devfreq governors and return the matched
174 * governor's pointer. devfreq_list_lock should be held by the caller.
176 static struct devfreq_governor
*find_devfreq_governor(const char *name
)
178 struct devfreq_governor
*tmp_governor
;
180 if (IS_ERR_OR_NULL(name
)) {
181 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__
);
182 return ERR_PTR(-EINVAL
);
184 WARN(!mutex_is_locked(&devfreq_list_lock
),
185 "devfreq_list_lock must be locked.");
187 list_for_each_entry(tmp_governor
, &devfreq_governor_list
, node
) {
188 if (!strncmp(tmp_governor
->name
, name
, DEVFREQ_NAME_LEN
))
192 return ERR_PTR(-ENODEV
);
195 static int devfreq_notify_transition(struct devfreq
*devfreq
,
196 struct devfreq_freqs
*freqs
, unsigned int state
)
202 case DEVFREQ_PRECHANGE
:
203 srcu_notifier_call_chain(&devfreq
->transition_notifier_list
,
204 DEVFREQ_PRECHANGE
, freqs
);
207 case DEVFREQ_POSTCHANGE
:
208 srcu_notifier_call_chain(&devfreq
->transition_notifier_list
,
209 DEVFREQ_POSTCHANGE
, freqs
);
218 /* Load monitoring helper functions for governors use */
221 * update_devfreq() - Reevaluate the device and configure frequency.
222 * @devfreq: the devfreq instance.
224 * Note: Lock devfreq->lock before calling update_devfreq
225 * This function is exported for governors.
227 int update_devfreq(struct devfreq
*devfreq
)
229 struct devfreq_freqs freqs
;
230 unsigned long freq
, cur_freq
;
234 if (!mutex_is_locked(&devfreq
->lock
)) {
235 WARN(true, "devfreq->lock must be locked by the caller.\n");
239 if (!devfreq
->governor
)
242 /* Reevaluate the proper frequency */
243 err
= devfreq
->governor
->get_target_freq(devfreq
, &freq
);
248 * Adjust the frequency with user freq and QoS.
250 * List from the highest priority
255 if (devfreq
->min_freq
&& freq
< devfreq
->min_freq
) {
256 freq
= devfreq
->min_freq
;
257 flags
&= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND
; /* Use GLB */
259 if (devfreq
->max_freq
&& freq
> devfreq
->max_freq
) {
260 freq
= devfreq
->max_freq
;
261 flags
|= DEVFREQ_FLAG_LEAST_UPPER_BOUND
; /* Use LUB */
264 if (devfreq
->profile
->get_cur_freq
)
265 devfreq
->profile
->get_cur_freq(devfreq
->dev
.parent
, &cur_freq
);
267 cur_freq
= devfreq
->previous_freq
;
269 freqs
.old
= cur_freq
;
271 devfreq_notify_transition(devfreq
, &freqs
, DEVFREQ_PRECHANGE
);
273 err
= devfreq
->profile
->target(devfreq
->dev
.parent
, &freq
, flags
);
275 freqs
.new = cur_freq
;
276 devfreq_notify_transition(devfreq
, &freqs
, DEVFREQ_POSTCHANGE
);
281 devfreq_notify_transition(devfreq
, &freqs
, DEVFREQ_POSTCHANGE
);
283 if (devfreq
->profile
->freq_table
)
284 if (devfreq_update_status(devfreq
, freq
))
285 dev_err(&devfreq
->dev
,
286 "Couldn't update frequency transition information.\n");
288 devfreq
->previous_freq
= freq
;
291 EXPORT_SYMBOL(update_devfreq
);
294 * devfreq_monitor() - Periodically poll devfreq objects.
295 * @work: the work struct used to run devfreq_monitor periodically.
298 static void devfreq_monitor(struct work_struct
*work
)
301 struct devfreq
*devfreq
= container_of(work
,
302 struct devfreq
, work
.work
);
304 mutex_lock(&devfreq
->lock
);
305 err
= update_devfreq(devfreq
);
307 dev_err(&devfreq
->dev
, "dvfs failed with (%d) error\n", err
);
309 queue_delayed_work(devfreq_wq
, &devfreq
->work
,
310 msecs_to_jiffies(devfreq
->profile
->polling_ms
));
311 mutex_unlock(&devfreq
->lock
);
315 * devfreq_monitor_start() - Start load monitoring of devfreq instance
316 * @devfreq: the devfreq instance.
318 * Helper function for starting devfreq device load monitoing. By
319 * default delayed work based monitoring is supported. Function
320 * to be called from governor in response to DEVFREQ_GOV_START
321 * event when device is added to devfreq framework.
323 void devfreq_monitor_start(struct devfreq
*devfreq
)
325 INIT_DEFERRABLE_WORK(&devfreq
->work
, devfreq_monitor
);
326 if (devfreq
->profile
->polling_ms
)
327 queue_delayed_work(devfreq_wq
, &devfreq
->work
,
328 msecs_to_jiffies(devfreq
->profile
->polling_ms
));
330 EXPORT_SYMBOL(devfreq_monitor_start
);
333 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
334 * @devfreq: the devfreq instance.
336 * Helper function to stop devfreq device load monitoing. Function
337 * to be called from governor in response to DEVFREQ_GOV_STOP
338 * event when device is removed from devfreq framework.
340 void devfreq_monitor_stop(struct devfreq
*devfreq
)
342 cancel_delayed_work_sync(&devfreq
->work
);
344 EXPORT_SYMBOL(devfreq_monitor_stop
);
347 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
348 * @devfreq: the devfreq instance.
350 * Helper function to suspend devfreq device load monitoing. Function
351 * to be called from governor in response to DEVFREQ_GOV_SUSPEND
352 * event or when polling interval is set to zero.
354 * Note: Though this function is same as devfreq_monitor_stop(),
355 * intentionally kept separate to provide hooks for collecting
356 * transition statistics.
358 void devfreq_monitor_suspend(struct devfreq
*devfreq
)
360 mutex_lock(&devfreq
->lock
);
361 if (devfreq
->stop_polling
) {
362 mutex_unlock(&devfreq
->lock
);
366 devfreq_update_status(devfreq
, devfreq
->previous_freq
);
367 devfreq
->stop_polling
= true;
368 mutex_unlock(&devfreq
->lock
);
369 cancel_delayed_work_sync(&devfreq
->work
);
371 EXPORT_SYMBOL(devfreq_monitor_suspend
);
374 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
375 * @devfreq: the devfreq instance.
377 * Helper function to resume devfreq device load monitoing. Function
378 * to be called from governor in response to DEVFREQ_GOV_RESUME
379 * event or when polling interval is set to non-zero.
381 void devfreq_monitor_resume(struct devfreq
*devfreq
)
385 mutex_lock(&devfreq
->lock
);
386 if (!devfreq
->stop_polling
)
389 if (!delayed_work_pending(&devfreq
->work
) &&
390 devfreq
->profile
->polling_ms
)
391 queue_delayed_work(devfreq_wq
, &devfreq
->work
,
392 msecs_to_jiffies(devfreq
->profile
->polling_ms
));
394 devfreq
->last_stat_updated
= jiffies
;
395 devfreq
->stop_polling
= false;
397 if (devfreq
->profile
->get_cur_freq
&&
398 !devfreq
->profile
->get_cur_freq(devfreq
->dev
.parent
, &freq
))
399 devfreq
->previous_freq
= freq
;
402 mutex_unlock(&devfreq
->lock
);
404 EXPORT_SYMBOL(devfreq_monitor_resume
);
407 * devfreq_interval_update() - Update device devfreq monitoring interval
408 * @devfreq: the devfreq instance.
409 * @delay: new polling interval to be set.
411 * Helper function to set new load monitoring polling interval. Function
412 * to be called from governor in response to DEVFREQ_GOV_INTERVAL event.
414 void devfreq_interval_update(struct devfreq
*devfreq
, unsigned int *delay
)
416 unsigned int cur_delay
= devfreq
->profile
->polling_ms
;
417 unsigned int new_delay
= *delay
;
419 mutex_lock(&devfreq
->lock
);
420 devfreq
->profile
->polling_ms
= new_delay
;
422 if (devfreq
->stop_polling
)
425 /* if new delay is zero, stop polling */
427 mutex_unlock(&devfreq
->lock
);
428 cancel_delayed_work_sync(&devfreq
->work
);
432 /* if current delay is zero, start polling with new delay */
434 queue_delayed_work(devfreq_wq
, &devfreq
->work
,
435 msecs_to_jiffies(devfreq
->profile
->polling_ms
));
439 /* if current delay is greater than new delay, restart polling */
440 if (cur_delay
> new_delay
) {
441 mutex_unlock(&devfreq
->lock
);
442 cancel_delayed_work_sync(&devfreq
->work
);
443 mutex_lock(&devfreq
->lock
);
444 if (!devfreq
->stop_polling
)
445 queue_delayed_work(devfreq_wq
, &devfreq
->work
,
446 msecs_to_jiffies(devfreq
->profile
->polling_ms
));
449 mutex_unlock(&devfreq
->lock
);
451 EXPORT_SYMBOL(devfreq_interval_update
);
454 * devfreq_notifier_call() - Notify that the device frequency requirements
455 * has been changed out of devfreq framework.
456 * @nb: the notifier_block (supposed to be devfreq->nb)
460 * Called by a notifier that uses devfreq->nb.
462 static int devfreq_notifier_call(struct notifier_block
*nb
, unsigned long type
,
465 struct devfreq
*devfreq
= container_of(nb
, struct devfreq
, nb
);
468 mutex_lock(&devfreq
->lock
);
469 ret
= update_devfreq(devfreq
);
470 mutex_unlock(&devfreq
->lock
);
476 * devfreq_dev_release() - Callback for struct device to release the device.
477 * @dev: the devfreq device
479 * Remove devfreq from the list and release its resources.
481 static void devfreq_dev_release(struct device
*dev
)
483 struct devfreq
*devfreq
= to_devfreq(dev
);
485 mutex_lock(&devfreq_list_lock
);
486 if (IS_ERR(find_device_devfreq(devfreq
->dev
.parent
))) {
487 mutex_unlock(&devfreq_list_lock
);
488 dev_warn(&devfreq
->dev
, "releasing devfreq which doesn't exist\n");
491 list_del(&devfreq
->node
);
492 mutex_unlock(&devfreq_list_lock
);
494 if (devfreq
->governor
)
495 devfreq
->governor
->event_handler(devfreq
,
496 DEVFREQ_GOV_STOP
, NULL
);
498 if (devfreq
->profile
->exit
)
499 devfreq
->profile
->exit(devfreq
->dev
.parent
);
501 mutex_destroy(&devfreq
->lock
);
506 * devfreq_add_device() - Add devfreq feature to the device
507 * @dev: the device to add devfreq feature.
508 * @profile: device-specific profile to run devfreq.
509 * @governor_name: name of the policy to choose frequency.
510 * @data: private data for the governor. The devfreq framework does not
513 struct devfreq
*devfreq_add_device(struct device
*dev
,
514 struct devfreq_dev_profile
*profile
,
515 const char *governor_name
,
518 struct devfreq
*devfreq
;
519 struct devfreq_governor
*governor
;
520 static atomic_t devfreq_no
= ATOMIC_INIT(-1);
523 if (!dev
|| !profile
|| !governor_name
) {
524 dev_err(dev
, "%s: Invalid parameters.\n", __func__
);
525 return ERR_PTR(-EINVAL
);
528 mutex_lock(&devfreq_list_lock
);
529 devfreq
= find_device_devfreq(dev
);
530 mutex_unlock(&devfreq_list_lock
);
531 if (!IS_ERR(devfreq
)) {
532 dev_err(dev
, "%s: Unable to create devfreq for the device.\n",
538 devfreq
= kzalloc(sizeof(struct devfreq
), GFP_KERNEL
);
544 mutex_init(&devfreq
->lock
);
545 mutex_lock(&devfreq
->lock
);
546 devfreq
->dev
.parent
= dev
;
547 devfreq
->dev
.class = devfreq_class
;
548 devfreq
->dev
.release
= devfreq_dev_release
;
549 devfreq
->profile
= profile
;
550 strncpy(devfreq
->governor_name
, governor_name
, DEVFREQ_NAME_LEN
);
551 devfreq
->previous_freq
= profile
->initial_freq
;
552 devfreq
->last_status
.current_frequency
= profile
->initial_freq
;
553 devfreq
->data
= data
;
554 devfreq
->nb
.notifier_call
= devfreq_notifier_call
;
556 if (!devfreq
->profile
->max_state
&& !devfreq
->profile
->freq_table
) {
557 mutex_unlock(&devfreq
->lock
);
558 devfreq_set_freq_table(devfreq
);
559 mutex_lock(&devfreq
->lock
);
562 dev_set_name(&devfreq
->dev
, "devfreq%d",
563 atomic_inc_return(&devfreq_no
));
564 err
= device_register(&devfreq
->dev
);
566 mutex_unlock(&devfreq
->lock
);
570 devfreq
->trans_table
= devm_kzalloc(&devfreq
->dev
,
571 sizeof(unsigned int) *
572 devfreq
->profile
->max_state
*
573 devfreq
->profile
->max_state
,
575 devfreq
->time_in_state
= devm_kzalloc(&devfreq
->dev
,
576 sizeof(unsigned long) *
577 devfreq
->profile
->max_state
,
579 devfreq
->last_stat_updated
= jiffies
;
581 srcu_init_notifier_head(&devfreq
->transition_notifier_list
);
583 mutex_unlock(&devfreq
->lock
);
585 mutex_lock(&devfreq_list_lock
);
586 list_add(&devfreq
->node
, &devfreq_list
);
588 governor
= find_devfreq_governor(devfreq
->governor_name
);
589 if (IS_ERR(governor
)) {
590 dev_err(dev
, "%s: Unable to find governor for the device\n",
592 err
= PTR_ERR(governor
);
596 devfreq
->governor
= governor
;
597 err
= devfreq
->governor
->event_handler(devfreq
, DEVFREQ_GOV_START
,
600 dev_err(dev
, "%s: Unable to start governor for the device\n",
604 mutex_unlock(&devfreq_list_lock
);
609 list_del(&devfreq
->node
);
610 mutex_unlock(&devfreq_list_lock
);
612 device_unregister(&devfreq
->dev
);
616 EXPORT_SYMBOL(devfreq_add_device
);
619 * devfreq_remove_device() - Remove devfreq feature from a device.
620 * @devfreq: the devfreq instance to be removed
622 * The opposite of devfreq_add_device().
624 int devfreq_remove_device(struct devfreq
*devfreq
)
629 device_unregister(&devfreq
->dev
);
633 EXPORT_SYMBOL(devfreq_remove_device
);
635 static int devm_devfreq_dev_match(struct device
*dev
, void *res
, void *data
)
637 struct devfreq
**r
= res
;
639 if (WARN_ON(!r
|| !*r
))
645 static void devm_devfreq_dev_release(struct device
*dev
, void *res
)
647 devfreq_remove_device(*(struct devfreq
**)res
);
651 * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
652 * @dev: the device to add devfreq feature.
653 * @profile: device-specific profile to run devfreq.
654 * @governor_name: name of the policy to choose frequency.
655 * @data: private data for the governor. The devfreq framework does not
658 * This function manages automatically the memory of devfreq device using device
659 * resource management and simplify the free operation for memory of devfreq
662 struct devfreq
*devm_devfreq_add_device(struct device
*dev
,
663 struct devfreq_dev_profile
*profile
,
664 const char *governor_name
,
667 struct devfreq
**ptr
, *devfreq
;
669 ptr
= devres_alloc(devm_devfreq_dev_release
, sizeof(*ptr
), GFP_KERNEL
);
671 return ERR_PTR(-ENOMEM
);
673 devfreq
= devfreq_add_device(dev
, profile
, governor_name
, data
);
674 if (IS_ERR(devfreq
)) {
676 return ERR_PTR(-ENOMEM
);
680 devres_add(dev
, ptr
);
684 EXPORT_SYMBOL(devm_devfreq_add_device
);
688 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
689 * @dev - instance to the given device
690 * @index - index into list of devfreq
692 * return the instance of devfreq device
694 struct devfreq
*devfreq_get_devfreq_by_phandle(struct device
*dev
, int index
)
696 struct device_node
*node
;
697 struct devfreq
*devfreq
;
700 return ERR_PTR(-EINVAL
);
703 return ERR_PTR(-EINVAL
);
705 node
= of_parse_phandle(dev
->of_node
, "devfreq", index
);
707 return ERR_PTR(-ENODEV
);
709 mutex_lock(&devfreq_list_lock
);
710 list_for_each_entry(devfreq
, &devfreq_list
, node
) {
711 if (devfreq
->dev
.parent
712 && devfreq
->dev
.parent
->of_node
== node
) {
713 mutex_unlock(&devfreq_list_lock
);
718 mutex_unlock(&devfreq_list_lock
);
721 return ERR_PTR(-EPROBE_DEFER
);
724 struct devfreq
*devfreq_get_devfreq_by_phandle(struct device
*dev
, int index
)
726 return ERR_PTR(-ENODEV
);
728 #endif /* CONFIG_OF */
729 EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle
);
732 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
733 * @dev: the device to add devfreq feature.
734 * @devfreq: the devfreq instance to be removed
736 void devm_devfreq_remove_device(struct device
*dev
, struct devfreq
*devfreq
)
738 WARN_ON(devres_release(dev
, devm_devfreq_dev_release
,
739 devm_devfreq_dev_match
, devfreq
));
741 EXPORT_SYMBOL(devm_devfreq_remove_device
);
744 * devfreq_suspend_device() - Suspend devfreq of a device.
745 * @devfreq: the devfreq instance to be suspended
747 * This function is intended to be called by the pm callbacks
748 * (e.g., runtime_suspend, suspend) of the device driver that
751 int devfreq_suspend_device(struct devfreq
*devfreq
)
756 if (!devfreq
->governor
)
759 return devfreq
->governor
->event_handler(devfreq
,
760 DEVFREQ_GOV_SUSPEND
, NULL
);
762 EXPORT_SYMBOL(devfreq_suspend_device
);
765 * devfreq_resume_device() - Resume devfreq of a device.
766 * @devfreq: the devfreq instance to be resumed
768 * This function is intended to be called by the pm callbacks
769 * (e.g., runtime_resume, resume) of the device driver that
772 int devfreq_resume_device(struct devfreq
*devfreq
)
777 if (!devfreq
->governor
)
780 return devfreq
->governor
->event_handler(devfreq
,
781 DEVFREQ_GOV_RESUME
, NULL
);
783 EXPORT_SYMBOL(devfreq_resume_device
);
786 * devfreq_add_governor() - Add devfreq governor
787 * @governor: the devfreq governor to be added
789 int devfreq_add_governor(struct devfreq_governor
*governor
)
791 struct devfreq_governor
*g
;
792 struct devfreq
*devfreq
;
796 pr_err("%s: Invalid parameters.\n", __func__
);
800 mutex_lock(&devfreq_list_lock
);
801 g
= find_devfreq_governor(governor
->name
);
803 pr_err("%s: governor %s already registered\n", __func__
,
809 list_add(&governor
->node
, &devfreq_governor_list
);
811 list_for_each_entry(devfreq
, &devfreq_list
, node
) {
813 struct device
*dev
= devfreq
->dev
.parent
;
815 if (!strncmp(devfreq
->governor_name
, governor
->name
,
817 /* The following should never occur */
818 if (devfreq
->governor
) {
820 "%s: Governor %s already present\n",
821 __func__
, devfreq
->governor
->name
);
822 ret
= devfreq
->governor
->event_handler(devfreq
,
823 DEVFREQ_GOV_STOP
, NULL
);
826 "%s: Governor %s stop = %d\n",
828 devfreq
->governor
->name
, ret
);
832 devfreq
->governor
= governor
;
833 ret
= devfreq
->governor
->event_handler(devfreq
,
834 DEVFREQ_GOV_START
, NULL
);
836 dev_warn(dev
, "%s: Governor %s start=%d\n",
837 __func__
, devfreq
->governor
->name
,
844 mutex_unlock(&devfreq_list_lock
);
848 EXPORT_SYMBOL(devfreq_add_governor
);
851 * devfreq_remove_governor() - Remove devfreq feature from a device.
852 * @governor: the devfreq governor to be removed
854 int devfreq_remove_governor(struct devfreq_governor
*governor
)
856 struct devfreq_governor
*g
;
857 struct devfreq
*devfreq
;
861 pr_err("%s: Invalid parameters.\n", __func__
);
865 mutex_lock(&devfreq_list_lock
);
866 g
= find_devfreq_governor(governor
->name
);
868 pr_err("%s: governor %s not registered\n", __func__
,
873 list_for_each_entry(devfreq
, &devfreq_list
, node
) {
875 struct device
*dev
= devfreq
->dev
.parent
;
877 if (!strncmp(devfreq
->governor_name
, governor
->name
,
879 /* we should have a devfreq governor! */
880 if (!devfreq
->governor
) {
881 dev_warn(dev
, "%s: Governor %s NOT present\n",
882 __func__
, governor
->name
);
886 ret
= devfreq
->governor
->event_handler(devfreq
,
887 DEVFREQ_GOV_STOP
, NULL
);
889 dev_warn(dev
, "%s: Governor %s stop=%d\n",
890 __func__
, devfreq
->governor
->name
,
893 devfreq
->governor
= NULL
;
897 list_del(&governor
->node
);
899 mutex_unlock(&devfreq_list_lock
);
903 EXPORT_SYMBOL(devfreq_remove_governor
);
905 static ssize_t
governor_show(struct device
*dev
,
906 struct device_attribute
*attr
, char *buf
)
908 if (!to_devfreq(dev
)->governor
)
911 return sprintf(buf
, "%s\n", to_devfreq(dev
)->governor
->name
);
914 static ssize_t
governor_store(struct device
*dev
, struct device_attribute
*attr
,
915 const char *buf
, size_t count
)
917 struct devfreq
*df
= to_devfreq(dev
);
919 char str_governor
[DEVFREQ_NAME_LEN
+ 1];
920 struct devfreq_governor
*governor
;
922 ret
= sscanf(buf
, "%" __stringify(DEVFREQ_NAME_LEN
) "s", str_governor
);
926 mutex_lock(&devfreq_list_lock
);
927 governor
= find_devfreq_governor(str_governor
);
928 if (IS_ERR(governor
)) {
929 ret
= PTR_ERR(governor
);
932 if (df
->governor
== governor
) {
935 } else if (df
->governor
->immutable
|| governor
->immutable
) {
941 ret
= df
->governor
->event_handler(df
, DEVFREQ_GOV_STOP
, NULL
);
943 dev_warn(dev
, "%s: Governor %s not stopped(%d)\n",
944 __func__
, df
->governor
->name
, ret
);
948 df
->governor
= governor
;
949 strncpy(df
->governor_name
, governor
->name
, DEVFREQ_NAME_LEN
);
950 ret
= df
->governor
->event_handler(df
, DEVFREQ_GOV_START
, NULL
);
952 dev_warn(dev
, "%s: Governor %s not started(%d)\n",
953 __func__
, df
->governor
->name
, ret
);
955 mutex_unlock(&devfreq_list_lock
);
961 static DEVICE_ATTR_RW(governor
);
963 static ssize_t
available_governors_show(struct device
*d
,
964 struct device_attribute
*attr
,
967 struct devfreq
*df
= to_devfreq(d
);
970 mutex_lock(&devfreq_list_lock
);
973 * The devfreq with immutable governor (e.g., passive) shows
976 if (df
->governor
->immutable
) {
977 count
= scnprintf(&buf
[count
], DEVFREQ_NAME_LEN
,
978 "%s ", df
->governor_name
);
980 * The devfreq device shows the registered governor except for
981 * immutable governors such as passive governor .
984 struct devfreq_governor
*governor
;
986 list_for_each_entry(governor
, &devfreq_governor_list
, node
) {
987 if (governor
->immutable
)
989 count
+= scnprintf(&buf
[count
], (PAGE_SIZE
- count
- 2),
990 "%s ", governor
->name
);
994 mutex_unlock(&devfreq_list_lock
);
996 /* Truncate the trailing space */
1000 count
+= sprintf(&buf
[count
], "\n");
1004 static DEVICE_ATTR_RO(available_governors
);
1006 static ssize_t
cur_freq_show(struct device
*dev
, struct device_attribute
*attr
,
1010 struct devfreq
*devfreq
= to_devfreq(dev
);
1012 if (devfreq
->profile
->get_cur_freq
&&
1013 !devfreq
->profile
->get_cur_freq(devfreq
->dev
.parent
, &freq
))
1014 return sprintf(buf
, "%lu\n", freq
);
1016 return sprintf(buf
, "%lu\n", devfreq
->previous_freq
);
1018 static DEVICE_ATTR_RO(cur_freq
);
1020 static ssize_t
target_freq_show(struct device
*dev
,
1021 struct device_attribute
*attr
, char *buf
)
1023 return sprintf(buf
, "%lu\n", to_devfreq(dev
)->previous_freq
);
1025 static DEVICE_ATTR_RO(target_freq
);
1027 static ssize_t
polling_interval_show(struct device
*dev
,
1028 struct device_attribute
*attr
, char *buf
)
1030 return sprintf(buf
, "%d\n", to_devfreq(dev
)->profile
->polling_ms
);
1033 static ssize_t
polling_interval_store(struct device
*dev
,
1034 struct device_attribute
*attr
,
1035 const char *buf
, size_t count
)
1037 struct devfreq
*df
= to_devfreq(dev
);
1044 ret
= sscanf(buf
, "%u", &value
);
1048 df
->governor
->event_handler(df
, DEVFREQ_GOV_INTERVAL
, &value
);
1053 static DEVICE_ATTR_RW(polling_interval
);
1055 static ssize_t
min_freq_store(struct device
*dev
, struct device_attribute
*attr
,
1056 const char *buf
, size_t count
)
1058 struct devfreq
*df
= to_devfreq(dev
);
1059 unsigned long value
;
1063 ret
= sscanf(buf
, "%lu", &value
);
1067 mutex_lock(&df
->lock
);
1069 if (value
&& max
&& value
> max
) {
1074 df
->min_freq
= value
;
1078 mutex_unlock(&df
->lock
);
1082 static ssize_t
max_freq_store(struct device
*dev
, struct device_attribute
*attr
,
1083 const char *buf
, size_t count
)
1085 struct devfreq
*df
= to_devfreq(dev
);
1086 unsigned long value
;
1090 ret
= sscanf(buf
, "%lu", &value
);
1094 mutex_lock(&df
->lock
);
1096 if (value
&& min
&& value
< min
) {
1101 df
->max_freq
= value
;
1105 mutex_unlock(&df
->lock
);
1109 #define show_one(name) \
1110 static ssize_t name##_show \
1111 (struct device *dev, struct device_attribute *attr, char *buf) \
1113 return sprintf(buf, "%lu\n", to_devfreq(dev)->name); \
1118 static DEVICE_ATTR_RW(min_freq
);
1119 static DEVICE_ATTR_RW(max_freq
);
1121 static ssize_t
available_frequencies_show(struct device
*d
,
1122 struct device_attribute
*attr
,
1125 struct devfreq
*df
= to_devfreq(d
);
1126 struct device
*dev
= df
->dev
.parent
;
1127 struct dev_pm_opp
*opp
;
1129 unsigned long freq
= 0;
1132 opp
= dev_pm_opp_find_freq_ceil(dev
, &freq
);
1136 dev_pm_opp_put(opp
);
1137 count
+= scnprintf(&buf
[count
], (PAGE_SIZE
- count
- 2),
1142 /* Truncate the trailing space */
1146 count
+= sprintf(&buf
[count
], "\n");
1150 static DEVICE_ATTR_RO(available_frequencies
);
1152 static ssize_t
trans_stat_show(struct device
*dev
,
1153 struct device_attribute
*attr
, char *buf
)
1155 struct devfreq
*devfreq
= to_devfreq(dev
);
1158 unsigned int max_state
= devfreq
->profile
->max_state
;
1160 if (!devfreq
->stop_polling
&&
1161 devfreq_update_status(devfreq
, devfreq
->previous_freq
))
1164 return sprintf(buf
, "Not Supported.\n");
1166 len
= sprintf(buf
, " From : To\n");
1167 len
+= sprintf(buf
+ len
, " :");
1168 for (i
= 0; i
< max_state
; i
++)
1169 len
+= sprintf(buf
+ len
, "%10lu",
1170 devfreq
->profile
->freq_table
[i
]);
1172 len
+= sprintf(buf
+ len
, " time(ms)\n");
1174 for (i
= 0; i
< max_state
; i
++) {
1175 if (devfreq
->profile
->freq_table
[i
]
1176 == devfreq
->previous_freq
) {
1177 len
+= sprintf(buf
+ len
, "*");
1179 len
+= sprintf(buf
+ len
, " ");
1181 len
+= sprintf(buf
+ len
, "%10lu:",
1182 devfreq
->profile
->freq_table
[i
]);
1183 for (j
= 0; j
< max_state
; j
++)
1184 len
+= sprintf(buf
+ len
, "%10u",
1185 devfreq
->trans_table
[(i
* max_state
) + j
]);
1186 len
+= sprintf(buf
+ len
, "%10u\n",
1187 jiffies_to_msecs(devfreq
->time_in_state
[i
]));
1190 len
+= sprintf(buf
+ len
, "Total transition : %u\n",
1191 devfreq
->total_trans
);
1194 static DEVICE_ATTR_RO(trans_stat
);
1196 static struct attribute
*devfreq_attrs
[] = {
1197 &dev_attr_governor
.attr
,
1198 &dev_attr_available_governors
.attr
,
1199 &dev_attr_cur_freq
.attr
,
1200 &dev_attr_available_frequencies
.attr
,
1201 &dev_attr_target_freq
.attr
,
1202 &dev_attr_polling_interval
.attr
,
1203 &dev_attr_min_freq
.attr
,
1204 &dev_attr_max_freq
.attr
,
1205 &dev_attr_trans_stat
.attr
,
1208 ATTRIBUTE_GROUPS(devfreq
);
1210 static int __init
devfreq_init(void)
1212 devfreq_class
= class_create(THIS_MODULE
, "devfreq");
1213 if (IS_ERR(devfreq_class
)) {
1214 pr_err("%s: couldn't create class\n", __FILE__
);
1215 return PTR_ERR(devfreq_class
);
1218 devfreq_wq
= create_freezable_workqueue("devfreq_wq");
1220 class_destroy(devfreq_class
);
1221 pr_err("%s: couldn't create workqueue\n", __FILE__
);
1224 devfreq_class
->dev_groups
= devfreq_groups
;
1228 subsys_initcall(devfreq_init
);
1231 * The following are helper functions for devfreq user device drivers with
1236 * devfreq_recommended_opp() - Helper function to get proper OPP for the
1237 * freq value given to target callback.
1238 * @dev: The devfreq user device. (parent of devfreq)
1239 * @freq: The frequency given to target function
1240 * @flags: Flags handed from devfreq framework.
1242 * The callers are required to call dev_pm_opp_put() for the returned OPP after
1245 struct dev_pm_opp
*devfreq_recommended_opp(struct device
*dev
,
1246 unsigned long *freq
,
1249 struct dev_pm_opp
*opp
;
1251 if (flags
& DEVFREQ_FLAG_LEAST_UPPER_BOUND
) {
1252 /* The freq is an upper bound. opp should be lower */
1253 opp
= dev_pm_opp_find_freq_floor(dev
, freq
);
1255 /* If not available, use the closest opp */
1256 if (opp
== ERR_PTR(-ERANGE
))
1257 opp
= dev_pm_opp_find_freq_ceil(dev
, freq
);
1259 /* The freq is an lower bound. opp should be higher */
1260 opp
= dev_pm_opp_find_freq_ceil(dev
, freq
);
1262 /* If not available, use the closest opp */
1263 if (opp
== ERR_PTR(-ERANGE
))
1264 opp
= dev_pm_opp_find_freq_floor(dev
, freq
);
1269 EXPORT_SYMBOL(devfreq_recommended_opp
);
1272 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1273 * for any changes in the OPP availability
1275 * @dev: The devfreq user device. (parent of devfreq)
1276 * @devfreq: The devfreq object.
1278 int devfreq_register_opp_notifier(struct device
*dev
, struct devfreq
*devfreq
)
1280 return dev_pm_opp_register_notifier(dev
, &devfreq
->nb
);
1282 EXPORT_SYMBOL(devfreq_register_opp_notifier
);
1285 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1286 * notified for any changes in the OPP
1287 * availability changes anymore.
1288 * @dev: The devfreq user device. (parent of devfreq)
1289 * @devfreq: The devfreq object.
1291 * At exit() callback of devfreq_dev_profile, this must be included if
1292 * devfreq_recommended_opp is used.
1294 int devfreq_unregister_opp_notifier(struct device
*dev
, struct devfreq
*devfreq
)
1296 return dev_pm_opp_unregister_notifier(dev
, &devfreq
->nb
);
1298 EXPORT_SYMBOL(devfreq_unregister_opp_notifier
);
1300 static void devm_devfreq_opp_release(struct device
*dev
, void *res
)
1302 devfreq_unregister_opp_notifier(dev
, *(struct devfreq
**)res
);
1306 * devm_ devfreq_register_opp_notifier()
1307 * - Resource-managed devfreq_register_opp_notifier()
1308 * @dev: The devfreq user device. (parent of devfreq)
1309 * @devfreq: The devfreq object.
1311 int devm_devfreq_register_opp_notifier(struct device
*dev
,
1312 struct devfreq
*devfreq
)
1314 struct devfreq
**ptr
;
1317 ptr
= devres_alloc(devm_devfreq_opp_release
, sizeof(*ptr
), GFP_KERNEL
);
1321 ret
= devfreq_register_opp_notifier(dev
, devfreq
);
1328 devres_add(dev
, ptr
);
1332 EXPORT_SYMBOL(devm_devfreq_register_opp_notifier
);
1335 * devm_devfreq_unregister_opp_notifier()
1336 * - Resource-managed devfreq_unregister_opp_notifier()
1337 * @dev: The devfreq user device. (parent of devfreq)
1338 * @devfreq: The devfreq object.
1340 void devm_devfreq_unregister_opp_notifier(struct device
*dev
,
1341 struct devfreq
*devfreq
)
1343 WARN_ON(devres_release(dev
, devm_devfreq_opp_release
,
1344 devm_devfreq_dev_match
, devfreq
));
1346 EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier
);
1349 * devfreq_register_notifier() - Register a driver with devfreq
1350 * @devfreq: The devfreq object.
1351 * @nb: The notifier block to register.
1352 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1354 int devfreq_register_notifier(struct devfreq
*devfreq
,
1355 struct notifier_block
*nb
,
1364 case DEVFREQ_TRANSITION_NOTIFIER
:
1365 ret
= srcu_notifier_chain_register(
1366 &devfreq
->transition_notifier_list
, nb
);
1374 EXPORT_SYMBOL(devfreq_register_notifier
);
1377 * devfreq_unregister_notifier() - Unregister a driver with devfreq
1378 * @devfreq: The devfreq object.
1379 * @nb: The notifier block to be unregistered.
1380 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1382 int devfreq_unregister_notifier(struct devfreq
*devfreq
,
1383 struct notifier_block
*nb
,
1392 case DEVFREQ_TRANSITION_NOTIFIER
:
1393 ret
= srcu_notifier_chain_unregister(
1394 &devfreq
->transition_notifier_list
, nb
);
1402 EXPORT_SYMBOL(devfreq_unregister_notifier
);
1404 struct devfreq_notifier_devres
{
1405 struct devfreq
*devfreq
;
1406 struct notifier_block
*nb
;
1410 static void devm_devfreq_notifier_release(struct device
*dev
, void *res
)
1412 struct devfreq_notifier_devres
*this = res
;
1414 devfreq_unregister_notifier(this->devfreq
, this->nb
, this->list
);
1418 * devm_devfreq_register_notifier()
1419 - Resource-managed devfreq_register_notifier()
1420 * @dev: The devfreq user device. (parent of devfreq)
1421 * @devfreq: The devfreq object.
1422 * @nb: The notifier block to be unregistered.
1423 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1425 int devm_devfreq_register_notifier(struct device
*dev
,
1426 struct devfreq
*devfreq
,
1427 struct notifier_block
*nb
,
1430 struct devfreq_notifier_devres
*ptr
;
1433 ptr
= devres_alloc(devm_devfreq_notifier_release
, sizeof(*ptr
),
1438 ret
= devfreq_register_notifier(devfreq
, nb
, list
);
1444 ptr
->devfreq
= devfreq
;
1447 devres_add(dev
, ptr
);
1451 EXPORT_SYMBOL(devm_devfreq_register_notifier
);
1454 * devm_devfreq_unregister_notifier()
1455 - Resource-managed devfreq_unregister_notifier()
1456 * @dev: The devfreq user device. (parent of devfreq)
1457 * @devfreq: The devfreq object.
1458 * @nb: The notifier block to be unregistered.
1459 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1461 void devm_devfreq_unregister_notifier(struct device
*dev
,
1462 struct devfreq
*devfreq
,
1463 struct notifier_block
*nb
,
1466 WARN_ON(devres_release(dev
, devm_devfreq_notifier_release
,
1467 devm_devfreq_dev_match
, devfreq
));
1469 EXPORT_SYMBOL(devm_devfreq_unregister_notifier
);