1/*
2 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
3 * for Non-CPU Devices.
4 *
5 * Copyright (C) 2011 Samsung Electronics
6 * MyungJoo Ham <myungjoo.ham@samsung.com>
7 *
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.
11 */
12
13#include <linux/kernel.h>
14#include <linux/kmod.h>
15#include <linux/sched.h>
16#include <linux/errno.h>
17#include <linux/err.h>
18#include <linux/init.h>
19#include <linux/export.h>
20#include <linux/slab.h>
21#include <linux/stat.h>
22#include <linux/pm_opp.h>
23#include <linux/devfreq.h>
24#include <linux/workqueue.h>
25#include <linux/platform_device.h>
26#include <linux/list.h>
27#include <linux/printk.h>
28#include <linux/hrtimer.h>
29#include <linux/of.h>
30#include "governor.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.
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 NULL;
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
399/**
400 * devfreq_monitor_start() - Start load monitoring of devfreq instance
401 * @devfreq: the devfreq instance.
402 *
403 * Helper function for starting devfreq device load monitoing. By
404 * default delayed work based monitoring is supported. Function
405 * to be called from governor in response to DEVFREQ_GOV_START
406 * event when device is added to devfreq framework.
407 */
408void devfreq_monitor_start(struct devfreq *devfreq)
409{
410 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
411 if (devfreq->profile->polling_ms)
412 queue_delayed_work(devfreq_wq, &devfreq->work,
413 msecs_to_jiffies(devfreq->profile->polling_ms));
414}
415EXPORT_SYMBOL(devfreq_monitor_start);
416
417/**
418 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
419 * @devfreq: the devfreq instance.
420 *
421 * Helper function to stop devfreq device load monitoing. Function
422 * to be called from governor in response to DEVFREQ_GOV_STOP
423 * event when device is removed from devfreq framework.
424 */
425void devfreq_monitor_stop(struct devfreq *devfreq)
426{
427 cancel_delayed_work_sync(&devfreq->work);
428}
429EXPORT_SYMBOL(devfreq_monitor_stop);
430
431/**
432 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
433 * @devfreq: the devfreq instance.
434 *
435 * Helper function to suspend devfreq device load monitoing. Function
436 * to be called from governor in response to DEVFREQ_GOV_SUSPEND
437 * event or when polling interval is set to zero.
438 *
439 * Note: Though this function is same as devfreq_monitor_stop(),
440 * intentionally kept separate to provide hooks for collecting
441 * transition statistics.
442 */
443void devfreq_monitor_suspend(struct devfreq *devfreq)
444{
445 mutex_lock(&devfreq->lock);
446 if (devfreq->stop_polling) {
447 mutex_unlock(&devfreq->lock);
448 return;
449 }
450
451 devfreq_update_status(devfreq, devfreq->previous_freq);
452 devfreq->stop_polling = true;
453 mutex_unlock(&devfreq->lock);
454 cancel_delayed_work_sync(&devfreq->work);
455}
456EXPORT_SYMBOL(devfreq_monitor_suspend);
457
458/**
459 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
460 * @devfreq: the devfreq instance.
461 *
462 * Helper function to resume devfreq device load monitoing. Function
463 * to be called from governor in response to DEVFREQ_GOV_RESUME
464 * event or when polling interval is set to non-zero.
465 */
466void devfreq_monitor_resume(struct devfreq *devfreq)
467{
468 unsigned long freq;
469
470 mutex_lock(&devfreq->lock);
471 if (!devfreq->stop_polling)
472 goto out;
473
474 if (!delayed_work_pending(&devfreq->work) &&
475 devfreq->profile->polling_ms)
476 queue_delayed_work(devfreq_wq, &devfreq->work,
477 msecs_to_jiffies(devfreq->profile->polling_ms));
478
479 devfreq->last_stat_updated = jiffies;
480 devfreq->stop_polling = false;
481
482 if (devfreq->profile->get_cur_freq &&
483 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
484 devfreq->previous_freq = freq;
485
486out:
487 mutex_unlock(&devfreq->lock);
488}
489EXPORT_SYMBOL(devfreq_monitor_resume);
490
491/**
492 * devfreq_interval_update() - Update device devfreq monitoring interval
493 * @devfreq: the devfreq instance.
494 * @delay: new polling interval to be set.
495 *
496 * Helper function to set new load monitoring polling interval. Function
497 * to be called from governor in response to DEVFREQ_GOV_INTERVAL event.
498 */
499void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay)
500{
501 unsigned int cur_delay = devfreq->profile->polling_ms;
502 unsigned int new_delay = *delay;
503
504 mutex_lock(&devfreq->lock);
505 devfreq->profile->polling_ms = new_delay;
506
507 if (devfreq->stop_polling)
508 goto out;
509
510 /* if new delay is zero, stop polling */
511 if (!new_delay) {
512 mutex_unlock(&devfreq->lock);
513 cancel_delayed_work_sync(&devfreq->work);
514 return;
515 }
516
517 /* if current delay is zero, start polling with new delay */
518 if (!cur_delay) {
519 queue_delayed_work(devfreq_wq, &devfreq->work,
520 msecs_to_jiffies(devfreq->profile->polling_ms));
521 goto out;
522 }
523
524 /* if current delay is greater than new delay, restart polling */
525 if (cur_delay > new_delay) {
526 mutex_unlock(&devfreq->lock);
527 cancel_delayed_work_sync(&devfreq->work);
528 mutex_lock(&devfreq->lock);
529 if (!devfreq->stop_polling)
530 queue_delayed_work(devfreq_wq, &devfreq->work,
531 msecs_to_jiffies(devfreq->profile->polling_ms));
532 }
533out:
534 mutex_unlock(&devfreq->lock);
535}
536EXPORT_SYMBOL(devfreq_interval_update);
537
538/**
539 * devfreq_notifier_call() - Notify that the device frequency requirements
540 * has been changed out of devfreq framework.
541 * @nb: the notifier_block (supposed to be devfreq->nb)
542 * @type: not used
543 * @devp: not used
544 *
545 * Called by a notifier that uses devfreq->nb.
546 */
547static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
548 void *devp)
549{
550 struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
551 int ret;
552
553 mutex_lock(&devfreq->lock);
554
555 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
556 if (!devfreq->scaling_min_freq) {
557 mutex_unlock(&devfreq->lock);
558 return -EINVAL;
559 }
560
561 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
562 if (!devfreq->scaling_max_freq) {
563 mutex_unlock(&devfreq->lock);
564 return -EINVAL;
565 }
566
567 ret = update_devfreq(devfreq);
568 mutex_unlock(&devfreq->lock);
569
570 return ret;
571}
572
573/**
574 * devfreq_dev_release() - Callback for struct device to release the device.
575 * @dev: the devfreq device
576 *
577 * Remove devfreq from the list and release its resources.
578 */
579static void devfreq_dev_release(struct device *dev)
580{
581 struct devfreq *devfreq = to_devfreq(dev);
582
583 mutex_lock(&devfreq_list_lock);
584 if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) {
585 mutex_unlock(&devfreq_list_lock);
586 dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n");
587 return;
588 }
589 list_del(&devfreq->node);
590 mutex_unlock(&devfreq_list_lock);
591
592 if (devfreq->profile->exit)
593 devfreq->profile->exit(devfreq->dev.parent);
594
595 mutex_destroy(&devfreq->lock);
596 kfree(devfreq);
597}
598
599/**
600 * devfreq_add_device() - Add devfreq feature to the device
601 * @dev: the device to add devfreq feature.
602 * @profile: device-specific profile to run devfreq.
603 * @governor_name: name of the policy to choose frequency.
604 * @data: private data for the governor. The devfreq framework does not
605 * touch this value.
606 */
607struct devfreq *devfreq_add_device(struct device *dev,
608 struct devfreq_dev_profile *profile,
609 const char *governor_name,
610 void *data)
611{
612 struct devfreq *devfreq;
613 struct devfreq_governor *governor;
614 static atomic_t devfreq_no = ATOMIC_INIT(-1);
615 int err = 0;
616
617 if (!dev || !profile || !governor_name) {
618 dev_err(dev, "%s: Invalid parameters.\n", __func__);
619 return ERR_PTR(-EINVAL);
620 }
621
622 mutex_lock(&devfreq_list_lock);
623 devfreq = find_device_devfreq(dev);
624 mutex_unlock(&devfreq_list_lock);
625 if (!IS_ERR(devfreq)) {
626 dev_err(dev, "%s: Unable to create devfreq for the device.\n",
627 __func__);
628 err = -EINVAL;
629 goto err_out;
630 }
631
632 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
633 if (!devfreq) {
634 err = -ENOMEM;
635 goto err_out;
636 }
637
638 mutex_init(&devfreq->lock);
639 mutex_lock(&devfreq->lock);
640 devfreq->dev.parent = dev;
641 devfreq->dev.class = devfreq_class;
642 devfreq->dev.release = devfreq_dev_release;
643 devfreq->profile = profile;
644 strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
645 devfreq->previous_freq = profile->initial_freq;
646 devfreq->last_status.current_frequency = profile->initial_freq;
647 devfreq->data = data;
648 devfreq->nb.notifier_call = devfreq_notifier_call;
649
650 if (!devfreq->profile->max_state && !devfreq->profile->freq_table) {
651 mutex_unlock(&devfreq->lock);
652 err = set_freq_table(devfreq);
653 if (err < 0)
654 goto err_out;
655 mutex_lock(&devfreq->lock);
656 }
657
658 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
659 if (!devfreq->scaling_min_freq) {
660 mutex_unlock(&devfreq->lock);
661 err = -EINVAL;
662 goto err_dev;
663 }
664 devfreq->min_freq = devfreq->scaling_min_freq;
665
666 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
667 if (!devfreq->scaling_max_freq) {
668 mutex_unlock(&devfreq->lock);
669 err = -EINVAL;
670 goto err_dev;
671 }
672 devfreq->max_freq = devfreq->scaling_max_freq;
673
674 devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev);
675 atomic_set(&devfreq->suspend_count, 0);
676
677 dev_set_name(&devfreq->dev, "devfreq%d",
678 atomic_inc_return(&devfreq_no));
679 err = device_register(&devfreq->dev);
680 if (err) {
681 mutex_unlock(&devfreq->lock);
682 put_device(&devfreq->dev);
683 goto err_out;
684 }
685
686 devfreq->trans_table =
687 devm_kzalloc(&devfreq->dev,
688 array3_size(sizeof(unsigned int),
689 devfreq->profile->max_state,
690 devfreq->profile->max_state),
691 GFP_KERNEL);
692 devfreq->time_in_state = devm_kcalloc(&devfreq->dev,
693 devfreq->profile->max_state,
694 sizeof(unsigned long),
695 GFP_KERNEL);
696 devfreq->last_stat_updated = jiffies;
697
698 srcu_init_notifier_head(&devfreq->transition_notifier_list);
699
700 mutex_unlock(&devfreq->lock);
701
702 mutex_lock(&devfreq_list_lock);
703
704 governor = try_then_request_governor(devfreq->governor_name);
705 if (IS_ERR(governor)) {
706 dev_err(dev, "%s: Unable to find governor for the device\n",
707 __func__);
708 err = PTR_ERR(governor);
709 goto err_init;
710 }
711
712 devfreq->governor = governor;
713 err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
714 NULL);
715 if (err) {
716 dev_err(dev, "%s: Unable to start governor for the device\n",
717 __func__);
718 goto err_init;
719 }
720
721 list_add(&devfreq->node, &devfreq_list);
722
723 mutex_unlock(&devfreq_list_lock);
724
725 return devfreq;
726
727err_init:
728 mutex_unlock(&devfreq_list_lock);
729
730 devfreq_remove_device(devfreq);
731 devfreq = NULL;
732err_dev:
733 kfree(devfreq);
734err_out:
735 return ERR_PTR(err);
736}
737EXPORT_SYMBOL(devfreq_add_device);
738
739/**
740 * devfreq_remove_device() - Remove devfreq feature from a device.
741 * @devfreq: the devfreq instance to be removed
742 *
743 * The opposite of devfreq_add_device().
744 */
745int devfreq_remove_device(struct devfreq *devfreq)
746{
747 if (!devfreq)
748 return -EINVAL;
749
750 if (devfreq->governor)
751 devfreq->governor->event_handler(devfreq,
752 DEVFREQ_GOV_STOP, NULL);
753 device_unregister(&devfreq->dev);
754
755 return 0;
756}
757EXPORT_SYMBOL(devfreq_remove_device);
758
759static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
760{
761 struct devfreq **r = res;
762
763 if (WARN_ON(!r || !*r))
764 return 0;
765
766 return *r == data;
767}
768
769static void devm_devfreq_dev_release(struct device *dev, void *res)
770{
771 devfreq_remove_device(*(struct devfreq **)res);
772}
773
774/**
775 * devm_devfreq_add_device() - Resource-managed devfreq_add_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: private data for the governor. The devfreq framework does not
780 * touch this value.
781 *
782 * This function manages automatically the memory of devfreq device using device
783 * resource management and simplify the free operation for memory of devfreq
784 * device.
785 */
786struct devfreq *devm_devfreq_add_device(struct device *dev,
787 struct devfreq_dev_profile *profile,
788 const char *governor_name,
789 void *data)
790{
791 struct devfreq **ptr, *devfreq;
792
793 ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
794 if (!ptr)
795 return ERR_PTR(-ENOMEM);
796
797 devfreq = devfreq_add_device(dev, profile, governor_name, data);
798 if (IS_ERR(devfreq)) {
799 devres_free(ptr);
800 return devfreq;
801 }
802
803 *ptr = devfreq;
804 devres_add(dev, ptr);
805
806 return devfreq;
807}
808EXPORT_SYMBOL(devm_devfreq_add_device);
809
810#ifdef CONFIG_OF
811/*
812 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
813 * @dev - instance to the given device
814 * @index - index into list of devfreq
815 *
816 * return the instance of devfreq device
817 */
818struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
819{
820 struct device_node *node;
821 struct devfreq *devfreq;
822
823 if (!dev)
824 return ERR_PTR(-EINVAL);
825
826 if (!dev->of_node)
827 return ERR_PTR(-EINVAL);
828
829 node = of_parse_phandle(dev->of_node, "devfreq", index);
830 if (!node)
831 return ERR_PTR(-ENODEV);
832
833 mutex_lock(&devfreq_list_lock);
834 list_for_each_entry(devfreq, &devfreq_list, node) {
835 if (devfreq->dev.parent
836 && devfreq->dev.parent->of_node == node) {
837 mutex_unlock(&devfreq_list_lock);
838 of_node_put(node);
839 return devfreq;
840 }
841 }
842 mutex_unlock(&devfreq_list_lock);
843 of_node_put(node);
844
845 return ERR_PTR(-EPROBE_DEFER);
846}
847#else
848struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
849{
850 return ERR_PTR(-ENODEV);
851}
852#endif /* CONFIG_OF */
853EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
854
855/**
856 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
857 * @dev: the device to add devfreq feature.
858 * @devfreq: the devfreq instance to be removed
859 */
860void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
861{
862 WARN_ON(devres_release(dev, devm_devfreq_dev_release,
863 devm_devfreq_dev_match, devfreq));
864}
865EXPORT_SYMBOL(devm_devfreq_remove_device);
866
867/**
868 * devfreq_suspend_device() - Suspend devfreq of a device.
869 * @devfreq: the devfreq instance to be suspended
870 *
871 * This function is intended to be called by the pm callbacks
872 * (e.g., runtime_suspend, suspend) of the device driver that
873 * holds the devfreq.
874 */
875int devfreq_suspend_device(struct devfreq *devfreq)
876{
877 int ret;
878
879 if (!devfreq)
880 return -EINVAL;
881
882 if (atomic_inc_return(&devfreq->suspend_count) > 1)
883 return 0;
884
885 if (devfreq->governor) {
886 ret = devfreq->governor->event_handler(devfreq,
887 DEVFREQ_GOV_SUSPEND, NULL);
888 if (ret)
889 return ret;
890 }
891
892 if (devfreq->suspend_freq) {
893 ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
894 if (ret)
895 return ret;
896 }
897
898 return 0;
899}
900EXPORT_SYMBOL(devfreq_suspend_device);
901
902/**
903 * devfreq_resume_device() - Resume devfreq of a device.
904 * @devfreq: the devfreq instance to be resumed
905 *
906 * This function is intended to be called by the pm callbacks
907 * (e.g., runtime_resume, resume) of the device driver that
908 * holds the devfreq.
909 */
910int devfreq_resume_device(struct devfreq *devfreq)
911{
912 int ret;
913
914 if (!devfreq)
915 return -EINVAL;
916
917 if (atomic_dec_return(&devfreq->suspend_count) >= 1)
918 return 0;
919
920 if (devfreq->resume_freq) {
921 ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
922 if (ret)
923 return ret;
924 }
925
926 if (devfreq->governor) {
927 ret = devfreq->governor->event_handler(devfreq,
928 DEVFREQ_GOV_RESUME, NULL);
929 if (ret)
930 return ret;
931 }
932
933 return 0;
934}
935EXPORT_SYMBOL(devfreq_resume_device);
936
937/**
938 * devfreq_suspend() - Suspend devfreq governors and devices
939 *
940 * Called during system wide Suspend/Hibernate cycles for suspending governors
941 * and devices preserving the state for resume. On some platforms the devfreq
942 * device must have precise state (frequency) after resume in order to provide
943 * fully operating setup.
944 */
945void devfreq_suspend(void)
946{
947 struct devfreq *devfreq;
948 int ret;
949
950 mutex_lock(&devfreq_list_lock);
951 list_for_each_entry(devfreq, &devfreq_list, node) {
952 ret = devfreq_suspend_device(devfreq);
953 if (ret)
954 dev_err(&devfreq->dev,
955 "failed to suspend devfreq device\n");
956 }
957 mutex_unlock(&devfreq_list_lock);
958}
959
960/**
961 * devfreq_resume() - Resume devfreq governors and devices
962 *
963 * Called during system wide Suspend/Hibernate cycle for resuming governors and
964 * devices that are suspended with devfreq_suspend().
965 */
966void devfreq_resume(void)
967{
968 struct devfreq *devfreq;
969 int ret;
970
971 mutex_lock(&devfreq_list_lock);
972 list_for_each_entry(devfreq, &devfreq_list, node) {
973 ret = devfreq_resume_device(devfreq);
974 if (ret)
975 dev_warn(&devfreq->dev,
976 "failed to resume devfreq device\n");
977 }
978 mutex_unlock(&devfreq_list_lock);
979}
980
981/**
982 * devfreq_add_governor() - Add devfreq governor
983 * @governor: the devfreq governor to be added
984 */
985int devfreq_add_governor(struct devfreq_governor *governor)
986{
987 struct devfreq_governor *g;
988 struct devfreq *devfreq;
989 int err = 0;
990
991 if (!governor) {
992 pr_err("%s: Invalid parameters.\n", __func__);
993 return -EINVAL;
994 }
995
996 mutex_lock(&devfreq_list_lock);
997 g = find_devfreq_governor(governor->name);
998 if (!IS_ERR(g)) {
999 pr_err("%s: governor %s already registered\n", __func__,
1000 g->name);
1001 err = -EINVAL;
1002 goto err_out;
1003 }
1004
1005 list_add(&governor->node, &devfreq_governor_list);
1006
1007 list_for_each_entry(devfreq, &devfreq_list, node) {
1008 int ret = 0;
1009 struct device *dev = devfreq->dev.parent;
1010
1011 if (!strncmp(devfreq->governor_name, governor->name,
1012 DEVFREQ_NAME_LEN)) {
1013 /* The following should never occur */
1014 if (devfreq->governor) {
1015 dev_warn(dev,
1016 "%s: Governor %s already present\n",
1017 __func__, devfreq->governor->name);
1018 ret = devfreq->governor->event_handler(devfreq,
1019 DEVFREQ_GOV_STOP, NULL);
1020 if (ret) {
1021 dev_warn(dev,
1022 "%s: Governor %s stop = %d\n",
1023 __func__,
1024 devfreq->governor->name, ret);
1025 }
1026 /* Fall through */
1027 }
1028 devfreq->governor = governor;
1029 ret = devfreq->governor->event_handler(devfreq,
1030 DEVFREQ_GOV_START, NULL);
1031 if (ret) {
1032 dev_warn(dev, "%s: Governor %s start=%d\n",
1033 __func__, devfreq->governor->name,
1034 ret);
1035 }
1036 }
1037 }
1038
1039err_out:
1040 mutex_unlock(&devfreq_list_lock);
1041
1042 return err;
1043}
1044EXPORT_SYMBOL(devfreq_add_governor);
1045
1046/**
1047 * devfreq_remove_governor() - Remove devfreq feature from a device.
1048 * @governor: the devfreq governor to be removed
1049 */
1050int devfreq_remove_governor(struct devfreq_governor *governor)
1051{
1052 struct devfreq_governor *g;
1053 struct devfreq *devfreq;
1054 int err = 0;
1055
1056 if (!governor) {
1057 pr_err("%s: Invalid parameters.\n", __func__);
1058 return -EINVAL;
1059 }
1060
1061 mutex_lock(&devfreq_list_lock);
1062 g = find_devfreq_governor(governor->name);
1063 if (IS_ERR(g)) {
1064 pr_err("%s: governor %s not registered\n", __func__,
1065 governor->name);
1066 err = PTR_ERR(g);
1067 goto err_out;
1068 }
1069 list_for_each_entry(devfreq, &devfreq_list, node) {
1070 int ret;
1071 struct device *dev = devfreq->dev.parent;
1072
1073 if (!strncmp(devfreq->governor_name, governor->name,
1074 DEVFREQ_NAME_LEN)) {
1075 /* we should have a devfreq governor! */
1076 if (!devfreq->governor) {
1077 dev_warn(dev, "%s: Governor %s NOT present\n",
1078 __func__, governor->name);
1079 continue;
1080 /* Fall through */
1081 }
1082 ret = devfreq->governor->event_handler(devfreq,
1083 DEVFREQ_GOV_STOP, NULL);
1084 if (ret) {
1085 dev_warn(dev, "%s: Governor %s stop=%d\n",
1086 __func__, devfreq->governor->name,
1087 ret);
1088 }
1089 devfreq->governor = NULL;
1090 }
1091 }
1092
1093 list_del(&governor->node);
1094err_out:
1095 mutex_unlock(&devfreq_list_lock);
1096
1097 return err;
1098}
1099EXPORT_SYMBOL(devfreq_remove_governor);
1100
1101static ssize_t governor_show(struct device *dev,
1102 struct device_attribute *attr, char *buf)
1103{
1104 if (!to_devfreq(dev)->governor)
1105 return -EINVAL;
1106
1107 return sprintf(buf, "%s\n", to_devfreq(dev)->governor->name);
1108}
1109
1110static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
1111 const char *buf, size_t count)
1112{
1113 struct devfreq *df = to_devfreq(dev);
1114 int ret;
1115 char str_governor[DEVFREQ_NAME_LEN + 1];
1116 struct devfreq_governor *governor;
1117
1118 ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
1119 if (ret != 1)
1120 return -EINVAL;
1121
1122 mutex_lock(&devfreq_list_lock);
1123 governor = try_then_request_governor(str_governor);
1124 if (IS_ERR(governor)) {
1125 ret = PTR_ERR(governor);
1126 goto out;
1127 }
1128 if (df->governor == governor) {
1129 ret = 0;
1130 goto out;
1131 } else if ((df->governor && df->governor->immutable) ||
1132 governor->immutable) {
1133 ret = -EINVAL;
1134 goto out;
1135 }
1136
1137 if (df->governor) {
1138 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1139 if (ret) {
1140 dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1141 __func__, df->governor->name, ret);
1142 goto out;
1143 }
1144 }
1145 df->governor = governor;
1146 strncpy(df->governor_name, governor->name, DEVFREQ_NAME_LEN);
1147 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1148 if (ret)
1149 dev_warn(dev, "%s: Governor %s not started(%d)\n",
1150 __func__, df->governor->name, ret);
1151out:
1152 mutex_unlock(&devfreq_list_lock);
1153
1154 if (!ret)
1155 ret = count;
1156 return ret;
1157}
1158static DEVICE_ATTR_RW(governor);
1159
1160static ssize_t available_governors_show(struct device *d,
1161 struct device_attribute *attr,
1162 char *buf)
1163{
1164 struct devfreq *df = to_devfreq(d);
1165 ssize_t count = 0;
1166
1167 mutex_lock(&devfreq_list_lock);
1168
1169 /*
1170 * The devfreq with immutable governor (e.g., passive) shows
1171 * only own governor.
1172 */
1173 if (df->governor->immutable) {
1174 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
1175 "%s ", df->governor_name);
1176 /*
1177 * The devfreq device shows the registered governor except for
1178 * immutable governors such as passive governor .
1179 */
1180 } else {
1181 struct devfreq_governor *governor;
1182
1183 list_for_each_entry(governor, &devfreq_governor_list, node) {
1184 if (governor->immutable)
1185 continue;
1186 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1187 "%s ", governor->name);
1188 }
1189 }
1190
1191 mutex_unlock(&devfreq_list_lock);
1192
1193 /* Truncate the trailing space */
1194 if (count)
1195 count--;
1196
1197 count += sprintf(&buf[count], "\n");
1198
1199 return count;
1200}
1201static DEVICE_ATTR_RO(available_governors);
1202
1203static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr,
1204 char *buf)
1205{
1206 unsigned long freq;
1207 struct devfreq *devfreq = to_devfreq(dev);
1208
1209 if (devfreq->profile->get_cur_freq &&
1210 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
1211 return sprintf(buf, "%lu\n", freq);
1212
1213 return sprintf(buf, "%lu\n", devfreq->previous_freq);
1214}
1215static DEVICE_ATTR_RO(cur_freq);
1216
1217static ssize_t target_freq_show(struct device *dev,
1218 struct device_attribute *attr, char *buf)
1219{
1220 return sprintf(buf, "%lu\n", to_devfreq(dev)->previous_freq);
1221}
1222static DEVICE_ATTR_RO(target_freq);
1223
1224static ssize_t polling_interval_show(struct device *dev,
1225 struct device_attribute *attr, char *buf)
1226{
1227 return sprintf(buf, "%d\n", to_devfreq(dev)->profile->polling_ms);
1228}
1229
1230static ssize_t polling_interval_store(struct device *dev,
1231 struct device_attribute *attr,
1232 const char *buf, size_t count)
1233{
1234 struct devfreq *df = to_devfreq(dev);
1235 unsigned int value;
1236 int ret;
1237
1238 if (!df->governor)
1239 return -EINVAL;
1240
1241 ret = sscanf(buf, "%u", &value);
1242 if (ret != 1)
1243 return -EINVAL;
1244
1245 df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value);
1246 ret = count;
1247
1248 return ret;
1249}
1250static DEVICE_ATTR_RW(polling_interval);
1251
1252static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
1253 const char *buf, size_t count)
1254{
1255 struct devfreq *df = to_devfreq(dev);
1256 unsigned long value;
1257 int ret;
1258
1259 ret = sscanf(buf, "%lu", &value);
1260 if (ret != 1)
1261 return -EINVAL;
1262
1263 mutex_lock(&df->lock);
1264
1265 if (value) {
1266 if (value > df->max_freq) {
1267 ret = -EINVAL;
1268 goto unlock;
1269 }
1270 } else {
1271 unsigned long *freq_table = df->profile->freq_table;
1272
1273 /* Get minimum frequency according to sorting order */
1274 if (freq_table[0] < freq_table[df->profile->max_state - 1])
1275 value = freq_table[0];
1276 else
1277 value = freq_table[df->profile->max_state - 1];
1278 }
1279
1280 df->min_freq = value;
1281 update_devfreq(df);
1282 ret = count;
1283unlock:
1284 mutex_unlock(&df->lock);
1285 return ret;
1286}
1287
1288static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr,
1289 char *buf)
1290{
1291 struct devfreq *df = to_devfreq(dev);
1292
1293 return sprintf(buf, "%lu\n", max(df->scaling_min_freq, df->min_freq));
1294}
1295
1296static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
1297 const char *buf, size_t count)
1298{
1299 struct devfreq *df = to_devfreq(dev);
1300 unsigned long value;
1301 int ret;
1302
1303 ret = sscanf(buf, "%lu", &value);
1304 if (ret != 1)
1305 return -EINVAL;
1306
1307 mutex_lock(&df->lock);
1308
1309 if (value) {
1310 if (value < df->min_freq) {
1311 ret = -EINVAL;
1312 goto unlock;
1313 }
1314 } else {
1315 unsigned long *freq_table = df->profile->freq_table;
1316
1317 /* Get maximum frequency according to sorting order */
1318 if (freq_table[0] < freq_table[df->profile->max_state - 1])
1319 value = freq_table[df->profile->max_state - 1];
1320 else
1321 value = freq_table[0];
1322 }
1323
1324 df->max_freq = value;
1325 update_devfreq(df);
1326 ret = count;
1327unlock:
1328 mutex_unlock(&df->lock);
1329 return ret;
1330}
1331static DEVICE_ATTR_RW(min_freq);
1332
1333static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr,
1334 char *buf)
1335{
1336 struct devfreq *df = to_devfreq(dev);
1337
1338 return sprintf(buf, "%lu\n", min(df->scaling_max_freq, df->max_freq));
1339}
1340static DEVICE_ATTR_RW(max_freq);
1341
1342static ssize_t available_frequencies_show(struct device *d,
1343 struct device_attribute *attr,
1344 char *buf)
1345{
1346 struct devfreq *df = to_devfreq(d);
1347 ssize_t count = 0;
1348 int i;
1349
1350 mutex_lock(&df->lock);
1351
1352 for (i = 0; i < df->profile->max_state; i++)
1353 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1354 "%lu ", df->profile->freq_table[i]);
1355
1356 mutex_unlock(&df->lock);
1357 /* Truncate the trailing space */
1358 if (count)
1359 count--;
1360
1361 count += sprintf(&buf[count], "\n");
1362
1363 return count;
1364}
1365static DEVICE_ATTR_RO(available_frequencies);
1366
1367static ssize_t trans_stat_show(struct device *dev,
1368 struct device_attribute *attr, char *buf)
1369{
1370 struct devfreq *devfreq = to_devfreq(dev);
1371 ssize_t len;
1372 int i, j;
1373 unsigned int max_state = devfreq->profile->max_state;
1374
1375 if (!devfreq->stop_polling &&
1376 devfreq_update_status(devfreq, devfreq->previous_freq))
1377 return 0;
1378 if (max_state == 0)
1379 return sprintf(buf, "Not Supported.\n");
1380
1381 len = sprintf(buf, " From : To\n");
1382 len += sprintf(buf + len, " :");
1383 for (i = 0; i < max_state; i++)
1384 len += sprintf(buf + len, "%10lu",
1385 devfreq->profile->freq_table[i]);
1386
1387 len += sprintf(buf + len, " time(ms)\n");
1388
1389 for (i = 0; i < max_state; i++) {
1390 if (devfreq->profile->freq_table[i]
1391 == devfreq->previous_freq) {
1392 len += sprintf(buf + len, "*");
1393 } else {
1394 len += sprintf(buf + len, " ");
1395 }
1396 len += sprintf(buf + len, "%10lu:",
1397 devfreq->profile->freq_table[i]);
1398 for (j = 0; j < max_state; j++)
1399 len += sprintf(buf + len, "%10u",
1400 devfreq->trans_table[(i * max_state) + j]);
1401 len += sprintf(buf + len, "%10u\n",
1402 jiffies_to_msecs(devfreq->time_in_state[i]));
1403 }
1404
1405 len += sprintf(buf + len, "Total transition : %u\n",
1406 devfreq->total_trans);
1407 return len;
1408}
1409static DEVICE_ATTR_RO(trans_stat);
1410
1411static struct attribute *devfreq_attrs[] = {
1412 &dev_attr_governor.attr,
1413 &dev_attr_available_governors.attr,
1414 &dev_attr_cur_freq.attr,
1415 &dev_attr_available_frequencies.attr,
1416 &dev_attr_target_freq.attr,
1417 &dev_attr_polling_interval.attr,
1418 &dev_attr_min_freq.attr,
1419 &dev_attr_max_freq.attr,
1420 &dev_attr_trans_stat.attr,
1421 NULL,
1422};
1423ATTRIBUTE_GROUPS(devfreq);
1424
1425static int __init devfreq_init(void)
1426{
1427 devfreq_class = class_create(THIS_MODULE, "devfreq");
1428 if (IS_ERR(devfreq_class)) {
1429 pr_err("%s: couldn't create class\n", __FILE__);
1430 return PTR_ERR(devfreq_class);
1431 }
1432
1433 devfreq_wq = create_freezable_workqueue("devfreq_wq");
1434 if (!devfreq_wq) {
1435 class_destroy(devfreq_class);
1436 pr_err("%s: couldn't create workqueue\n", __FILE__);
1437 return -ENOMEM;
1438 }
1439 devfreq_class->dev_groups = devfreq_groups;
1440
1441 return 0;
1442}
1443subsys_initcall(devfreq_init);
1444
1445/*
1446 * The following are helper functions for devfreq user device drivers with
1447 * OPP framework.
1448 */
1449
1450/**
1451 * devfreq_recommended_opp() - Helper function to get proper OPP for the
1452 * freq value given to target callback.
1453 * @dev: The devfreq user device. (parent of devfreq)
1454 * @freq: The frequency given to target function
1455 * @flags: Flags handed from devfreq framework.
1456 *
1457 * The callers are required to call dev_pm_opp_put() for the returned OPP after
1458 * use.
1459 */
1460struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
1461 unsigned long *freq,
1462 u32 flags)
1463{
1464 struct dev_pm_opp *opp;
1465
1466 if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
1467 /* The freq is an upper bound. opp should be lower */
1468 opp = dev_pm_opp_find_freq_floor(dev, freq);
1469
1470 /* If not available, use the closest opp */
1471 if (opp == ERR_PTR(-ERANGE))
1472 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1473 } else {
1474 /* The freq is an lower bound. opp should be higher */
1475 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1476
1477 /* If not available, use the closest opp */
1478 if (opp == ERR_PTR(-ERANGE))
1479 opp = dev_pm_opp_find_freq_floor(dev, freq);
1480 }
1481
1482 return opp;
1483}
1484EXPORT_SYMBOL(devfreq_recommended_opp);
1485
1486/**
1487 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1488 * for any changes in the OPP availability
1489 * changes
1490 * @dev: The devfreq user device. (parent of devfreq)
1491 * @devfreq: The devfreq object.
1492 */
1493int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1494{
1495 return dev_pm_opp_register_notifier(dev, &devfreq->nb);
1496}
1497EXPORT_SYMBOL(devfreq_register_opp_notifier);
1498
1499/**
1500 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1501 * notified for any changes in the OPP
1502 * availability changes anymore.
1503 * @dev: The devfreq user device. (parent of devfreq)
1504 * @devfreq: The devfreq object.
1505 *
1506 * At exit() callback of devfreq_dev_profile, this must be included if
1507 * devfreq_recommended_opp is used.
1508 */
1509int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1510{
1511 return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
1512}
1513EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
1514
1515static void devm_devfreq_opp_release(struct device *dev, void *res)
1516{
1517 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
1518}
1519
1520/**
1521 * devm_ devfreq_register_opp_notifier()
1522 * - Resource-managed devfreq_register_opp_notifier()
1523 * @dev: The devfreq user device. (parent of devfreq)
1524 * @devfreq: The devfreq object.
1525 */
1526int devm_devfreq_register_opp_notifier(struct device *dev,
1527 struct devfreq *devfreq)
1528{
1529 struct devfreq **ptr;
1530 int ret;
1531
1532 ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
1533 if (!ptr)
1534 return -ENOMEM;
1535
1536 ret = devfreq_register_opp_notifier(dev, devfreq);
1537 if (ret) {
1538 devres_free(ptr);
1539 return ret;
1540 }
1541
1542 *ptr = devfreq;
1543 devres_add(dev, ptr);
1544
1545 return 0;
1546}
1547EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
1548
1549/**
1550 * devm_devfreq_unregister_opp_notifier()
1551 * - Resource-managed devfreq_unregister_opp_notifier()
1552 * @dev: The devfreq user device. (parent of devfreq)
1553 * @devfreq: The devfreq object.
1554 */
1555void devm_devfreq_unregister_opp_notifier(struct device *dev,
1556 struct devfreq *devfreq)
1557{
1558 WARN_ON(devres_release(dev, devm_devfreq_opp_release,
1559 devm_devfreq_dev_match, devfreq));
1560}
1561EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
1562
1563/**
1564 * devfreq_register_notifier() - Register a driver with devfreq
1565 * @devfreq: The devfreq object.
1566 * @nb: The notifier block to register.
1567 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1568 */
1569int devfreq_register_notifier(struct devfreq *devfreq,
1570 struct notifier_block *nb,
1571 unsigned int list)
1572{
1573 int ret = 0;
1574
1575 if (!devfreq)
1576 return -EINVAL;
1577
1578 switch (list) {
1579 case DEVFREQ_TRANSITION_NOTIFIER:
1580 ret = srcu_notifier_chain_register(
1581 &devfreq->transition_notifier_list, nb);
1582 break;
1583 default:
1584 ret = -EINVAL;
1585 }
1586
1587 return ret;
1588}
1589EXPORT_SYMBOL(devfreq_register_notifier);
1590
1591/*
1592 * devfreq_unregister_notifier() - Unregister a driver with devfreq
1593 * @devfreq: The devfreq object.
1594 * @nb: The notifier block to be unregistered.
1595 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1596 */
1597int devfreq_unregister_notifier(struct devfreq *devfreq,
1598 struct notifier_block *nb,
1599 unsigned int list)
1600{
1601 int ret = 0;
1602
1603 if (!devfreq)
1604 return -EINVAL;
1605
1606 switch (list) {
1607 case DEVFREQ_TRANSITION_NOTIFIER:
1608 ret = srcu_notifier_chain_unregister(
1609 &devfreq->transition_notifier_list, nb);
1610 break;
1611 default:
1612 ret = -EINVAL;
1613 }
1614
1615 return ret;
1616}
1617EXPORT_SYMBOL(devfreq_unregister_notifier);
1618
1619struct devfreq_notifier_devres {
1620 struct devfreq *devfreq;
1621 struct notifier_block *nb;
1622 unsigned int list;
1623};
1624
1625static void devm_devfreq_notifier_release(struct device *dev, void *res)
1626{
1627 struct devfreq_notifier_devres *this = res;
1628
1629 devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
1630}
1631
1632/**
1633 * devm_devfreq_register_notifier()
1634 - Resource-managed devfreq_register_notifier()
1635 * @dev: The devfreq user device. (parent of devfreq)
1636 * @devfreq: The devfreq object.
1637 * @nb: The notifier block to be unregistered.
1638 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1639 */
1640int devm_devfreq_register_notifier(struct device *dev,
1641 struct devfreq *devfreq,
1642 struct notifier_block *nb,
1643 unsigned int list)
1644{
1645 struct devfreq_notifier_devres *ptr;
1646 int ret;
1647
1648 ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
1649 GFP_KERNEL);
1650 if (!ptr)
1651 return -ENOMEM;
1652
1653 ret = devfreq_register_notifier(devfreq, nb, list);
1654 if (ret) {
1655 devres_free(ptr);
1656 return ret;
1657 }
1658
1659 ptr->devfreq = devfreq;
1660 ptr->nb = nb;
1661 ptr->list = list;
1662 devres_add(dev, ptr);
1663
1664 return 0;
1665}
1666EXPORT_SYMBOL(devm_devfreq_register_notifier);
1667
1668/**
1669 * devm_devfreq_unregister_notifier()
1670 - Resource-managed devfreq_unregister_notifier()
1671 * @dev: The devfreq user device. (parent of devfreq)
1672 * @devfreq: The devfreq object.
1673 * @nb: The notifier block to be unregistered.
1674 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1675 */
1676void devm_devfreq_unregister_notifier(struct device *dev,
1677 struct devfreq *devfreq,
1678 struct notifier_block *nb,
1679 unsigned int list)
1680{
1681 WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
1682 devm_devfreq_dev_match, devfreq));
1683}
1684EXPORT_SYMBOL(devm_devfreq_unregister_notifier);
1685