projects/linux·blob v5.12 · refs

2212 lines · 55.6 KiB

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