projects/linux·blob v4.14 · refs

1472 lines · 36.7 KiB

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 <[email protected]>
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/sched.h>
15#include <linux/errno.h>
16#include <linux/err.h>
17#include <linux/init.h>
18#include <linux/export.h>
19#include <linux/slab.h>
20#include <linux/stat.h>
21#include <linux/pm_opp.h>
22#include <linux/devfreq.h>
23#include <linux/workqueue.h>
24#include <linux/platform_device.h>
25#include <linux/list.h>
26#include <linux/printk.h>
27#include <linux/hrtimer.h>
28#include <linux/of.h>
29#include "governor.h"
30
31static struct class *devfreq_class;
32
33/*
34 * devfreq core provides delayed work based load monitoring helper
35 * functions. Governors can use these or can implement their own
36 * monitoring mechanism.
37 */
38static struct workqueue_struct *devfreq_wq;
39
40/* The list of all device-devfreq governors */
41static LIST_HEAD(devfreq_governor_list);
42/* The list of all device-devfreq */
43static LIST_HEAD(devfreq_list);
44static DEFINE_MUTEX(devfreq_list_lock);
45
46/**
47 * find_device_devfreq() - find devfreq struct using device pointer
48 * @dev: device pointer used to lookup device devfreq.
49 *
50 * Search the list of device devfreqs and return the matched device's
51 * devfreq info. devfreq_list_lock should be held by the caller.
52 */
53static struct devfreq *find_device_devfreq(struct device *dev)
54{
55 struct devfreq *tmp_devfreq;
56
57 if (IS_ERR_OR_NULL(dev)) {
58 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
59 return ERR_PTR(-EINVAL);
60 }
61 WARN(!mutex_is_locked(&devfreq_list_lock),
62 "devfreq_list_lock must be locked.");
63
64 list_for_each_entry(tmp_devfreq, &devfreq_list, node) {
65 if (tmp_devfreq->dev.parent == dev)
66 return tmp_devfreq;
67 }
68
69 return ERR_PTR(-ENODEV);
70}
71
72/**
73 * devfreq_get_freq_level() - Lookup freq_table for the frequency
74 * @devfreq: the devfreq instance
75 * @freq: the target frequency
76 */
77static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq)
78{
79 int lev;
80
81 for (lev = 0; lev < devfreq->profile->max_state; lev++)
82 if (freq == devfreq->profile->freq_table[lev])
83 return lev;
84
85 return -EINVAL;
86}
87
88/**
89 * devfreq_set_freq_table() - Initialize freq_table for the frequency
90 * @devfreq: the devfreq instance
91 */
92static void devfreq_set_freq_table(struct devfreq *devfreq)
93{
94 struct devfreq_dev_profile *profile = devfreq->profile;
95 struct dev_pm_opp *opp;
96 unsigned long freq;
97 int i, count;
98
99 /* Initialize the freq_table from OPP table */
100 count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
101 if (count <= 0)
102 return;
103
104 profile->max_state = count;
105 profile->freq_table = devm_kcalloc(devfreq->dev.parent,
106 profile->max_state,
107 sizeof(*profile->freq_table),
108 GFP_KERNEL);
109 if (!profile->freq_table) {
110 profile->max_state = 0;
111 return;
112 }
113
114 for (i = 0, freq = 0; i < profile->max_state; i++, freq++) {
115 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
116 if (IS_ERR(opp)) {
117 devm_kfree(devfreq->dev.parent, profile->freq_table);
118 profile->max_state = 0;
119 return;
120 }
121 dev_pm_opp_put(opp);
122 profile->freq_table[i] = freq;
123 }
124}
125
126/**
127 * devfreq_update_status() - Update statistics of devfreq behavior
128 * @devfreq: the devfreq instance
129 * @freq: the update target frequency
130 */
131int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
132{
133 int lev, prev_lev, ret = 0;
134 unsigned long cur_time;
135
136 cur_time = jiffies;
137
138 /* Immediately exit if previous_freq is not initialized yet. */
139 if (!devfreq->previous_freq)
140 goto out;
141
142 prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq);
143 if (prev_lev < 0) {
144 ret = prev_lev;
145 goto out;
146 }
147
148 devfreq->time_in_state[prev_lev] +=
149 cur_time - devfreq->last_stat_updated;
150
151 lev = devfreq_get_freq_level(devfreq, freq);
152 if (lev < 0) {
153 ret = lev;
154 goto out;
155 }
156
157 if (lev != prev_lev) {
158 devfreq->trans_table[(prev_lev *
159 devfreq->profile->max_state) + lev]++;
160 devfreq->total_trans++;
161 }
162
163out:
164 devfreq->last_stat_updated = cur_time;
165 return ret;
166}
167EXPORT_SYMBOL(devfreq_update_status);
168
169/**
170 * find_devfreq_governor() - find devfreq governor from name
171 * @name: name of the governor
172 *
173 * Search the list of devfreq governors and return the matched
174 * governor's pointer. devfreq_list_lock should be held by the caller.
175 */
176static struct devfreq_governor *find_devfreq_governor(const char *name)
177{
178 struct devfreq_governor *tmp_governor;
179
180 if (IS_ERR_OR_NULL(name)) {
181 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
182 return ERR_PTR(-EINVAL);
183 }
184 WARN(!mutex_is_locked(&devfreq_list_lock),
185 "devfreq_list_lock must be locked.");
186
187 list_for_each_entry(tmp_governor, &devfreq_governor_list, node) {
188 if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN))
189 return tmp_governor;
190 }
191
192 return ERR_PTR(-ENODEV);
193}
194
195static int devfreq_notify_transition(struct devfreq *devfreq,
196 struct devfreq_freqs *freqs, unsigned int state)
197{
198 if (!devfreq)
199 return -EINVAL;
200
201 switch (state) {
202 case DEVFREQ_PRECHANGE:
203 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
204 DEVFREQ_PRECHANGE, freqs);
205 break;
206
207 case DEVFREQ_POSTCHANGE:
208 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
209 DEVFREQ_POSTCHANGE, freqs);
210 break;
211 default:
212 return -EINVAL;
213 }
214
215 return 0;
216}
217
218/* Load monitoring helper functions for governors use */
219
220/**
221 * update_devfreq() - Reevaluate the device and configure frequency.
222 * @devfreq: the devfreq instance.
223 *
224 * Note: Lock devfreq->lock before calling update_devfreq
225 * This function is exported for governors.
226 */
227int update_devfreq(struct devfreq *devfreq)
228{
229 struct devfreq_freqs freqs;
230 unsigned long freq, cur_freq;
231 int err = 0;
232 u32 flags = 0;
233
234 if (!mutex_is_locked(&devfreq->lock)) {
235 WARN(true, "devfreq->lock must be locked by the caller.\n");
236 return -EINVAL;
237 }
238
239 if (!devfreq->governor)
240 return -EINVAL;
241
242 /* Reevaluate the proper frequency */
243 err = devfreq->governor->get_target_freq(devfreq, &freq);
244 if (err)
245 return err;
246
247 /*
248 * Adjust the frequency with user freq and QoS.
249 *
250 * List from the highest priority
251 * max_freq
252 * min_freq
253 */
254
255 if (devfreq->min_freq && freq < devfreq->min_freq) {
256 freq = devfreq->min_freq;
257 flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */
258 }
259 if (devfreq->max_freq && freq > devfreq->max_freq) {
260 freq = devfreq->max_freq;
261 flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */
262 }
263
264 if (devfreq->profile->get_cur_freq)
265 devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
266 else
267 cur_freq = devfreq->previous_freq;
268
269 freqs.old = cur_freq;
270 freqs.new = freq;
271 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
272
273 err = devfreq->profile->target(devfreq->dev.parent, &freq, flags);
274 if (err) {
275 freqs.new = cur_freq;
276 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
277 return err;
278 }
279
280 freqs.new = freq;
281 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
282
283 if (devfreq->profile->freq_table)
284 if (devfreq_update_status(devfreq, freq))
285 dev_err(&devfreq->dev,
286 "Couldn't update frequency transition information.\n");
287
288 devfreq->previous_freq = freq;
289 return err;
290}
291EXPORT_SYMBOL(update_devfreq);
292
293/**
294 * devfreq_monitor() - Periodically poll devfreq objects.
295 * @work: the work struct used to run devfreq_monitor periodically.
296 *
297 */
298static void devfreq_monitor(struct work_struct *work)
299{
300 int err;
301 struct devfreq *devfreq = container_of(work,
302 struct devfreq, work.work);
303
304 mutex_lock(&devfreq->lock);
305 err = update_devfreq(devfreq);
306 if (err)
307 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
308
309 queue_delayed_work(devfreq_wq, &devfreq->work,
310 msecs_to_jiffies(devfreq->profile->polling_ms));
311 mutex_unlock(&devfreq->lock);
312}
313
314/**
315 * devfreq_monitor_start() - Start load monitoring of devfreq instance
316 * @devfreq: the devfreq instance.
317 *
318 * Helper function for starting devfreq device load monitoing. By
319 * default delayed work based monitoring is supported. Function
320 * to be called from governor in response to DEVFREQ_GOV_START
321 * event when device is added to devfreq framework.
322 */
323void devfreq_monitor_start(struct devfreq *devfreq)
324{
325 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
326 if (devfreq->profile->polling_ms)
327 queue_delayed_work(devfreq_wq, &devfreq->work,
328 msecs_to_jiffies(devfreq->profile->polling_ms));
329}
330EXPORT_SYMBOL(devfreq_monitor_start);
331
332/**
333 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
334 * @devfreq: the devfreq instance.
335 *
336 * Helper function to stop devfreq device load monitoing. Function
337 * to be called from governor in response to DEVFREQ_GOV_STOP
338 * event when device is removed from devfreq framework.
339 */
340void devfreq_monitor_stop(struct devfreq *devfreq)
341{
342 cancel_delayed_work_sync(&devfreq->work);
343}
344EXPORT_SYMBOL(devfreq_monitor_stop);
345
346/**
347 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
348 * @devfreq: the devfreq instance.
349 *
350 * Helper function to suspend devfreq device load monitoing. Function
351 * to be called from governor in response to DEVFREQ_GOV_SUSPEND
352 * event or when polling interval is set to zero.
353 *
354 * Note: Though this function is same as devfreq_monitor_stop(),
355 * intentionally kept separate to provide hooks for collecting
356 * transition statistics.
357 */
358void devfreq_monitor_suspend(struct devfreq *devfreq)
359{
360 mutex_lock(&devfreq->lock);
361 if (devfreq->stop_polling) {
362 mutex_unlock(&devfreq->lock);
363 return;
364 }
365
366 devfreq_update_status(devfreq, devfreq->previous_freq);
367 devfreq->stop_polling = true;
368 mutex_unlock(&devfreq->lock);
369 cancel_delayed_work_sync(&devfreq->work);
370}
371EXPORT_SYMBOL(devfreq_monitor_suspend);
372
373/**
374 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
375 * @devfreq: the devfreq instance.
376 *
377 * Helper function to resume devfreq device load monitoing. Function
378 * to be called from governor in response to DEVFREQ_GOV_RESUME
379 * event or when polling interval is set to non-zero.
380 */
381void devfreq_monitor_resume(struct devfreq *devfreq)
382{
383 unsigned long freq;
384
385 mutex_lock(&devfreq->lock);
386 if (!devfreq->stop_polling)
387 goto out;
388
389 if (!delayed_work_pending(&devfreq->work) &&
390 devfreq->profile->polling_ms)
391 queue_delayed_work(devfreq_wq, &devfreq->work,
392 msecs_to_jiffies(devfreq->profile->polling_ms));
393
394 devfreq->last_stat_updated = jiffies;
395 devfreq->stop_polling = false;
396
397 if (devfreq->profile->get_cur_freq &&
398 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
399 devfreq->previous_freq = freq;
400
401out:
402 mutex_unlock(&devfreq->lock);
403}
404EXPORT_SYMBOL(devfreq_monitor_resume);
405
406/**
407 * devfreq_interval_update() - Update device devfreq monitoring interval
408 * @devfreq: the devfreq instance.
409 * @delay: new polling interval to be set.
410 *
411 * Helper function to set new load monitoring polling interval. Function
412 * to be called from governor in response to DEVFREQ_GOV_INTERVAL event.
413 */
414void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay)
415{
416 unsigned int cur_delay = devfreq->profile->polling_ms;
417 unsigned int new_delay = *delay;
418
419 mutex_lock(&devfreq->lock);
420 devfreq->profile->polling_ms = new_delay;
421
422 if (devfreq->stop_polling)
423 goto out;
424
425 /* if new delay is zero, stop polling */
426 if (!new_delay) {
427 mutex_unlock(&devfreq->lock);
428 cancel_delayed_work_sync(&devfreq->work);
429 return;
430 }
431
432 /* if current delay is zero, start polling with new delay */
433 if (!cur_delay) {
434 queue_delayed_work(devfreq_wq, &devfreq->work,
435 msecs_to_jiffies(devfreq->profile->polling_ms));
436 goto out;
437 }
438
439 /* if current delay is greater than new delay, restart polling */
440 if (cur_delay > new_delay) {
441 mutex_unlock(&devfreq->lock);
442 cancel_delayed_work_sync(&devfreq->work);
443 mutex_lock(&devfreq->lock);
444 if (!devfreq->stop_polling)
445 queue_delayed_work(devfreq_wq, &devfreq->work,
446 msecs_to_jiffies(devfreq->profile->polling_ms));
447 }
448out:
449 mutex_unlock(&devfreq->lock);
450}
451EXPORT_SYMBOL(devfreq_interval_update);
452
453/**
454 * devfreq_notifier_call() - Notify that the device frequency requirements
455 * has been changed out of devfreq framework.
456 * @nb: the notifier_block (supposed to be devfreq->nb)
457 * @type: not used
458 * @devp: not used
459 *
460 * Called by a notifier that uses devfreq->nb.
461 */
462static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
463 void *devp)
464{
465 struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
466 int ret;
467
468 mutex_lock(&devfreq->lock);
469 ret = update_devfreq(devfreq);
470 mutex_unlock(&devfreq->lock);
471
472 return ret;
473}
474
475/**
476 * devfreq_dev_release() - Callback for struct device to release the device.
477 * @dev: the devfreq device
478 *
479 * Remove devfreq from the list and release its resources.
480 */
481static void devfreq_dev_release(struct device *dev)
482{
483 struct devfreq *devfreq = to_devfreq(dev);
484
485 mutex_lock(&devfreq_list_lock);
486 if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) {
487 mutex_unlock(&devfreq_list_lock);
488 dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n");
489 return;
490 }
491 list_del(&devfreq->node);
492 mutex_unlock(&devfreq_list_lock);
493
494 if (devfreq->governor)
495 devfreq->governor->event_handler(devfreq,
496 DEVFREQ_GOV_STOP, NULL);
497
498 if (devfreq->profile->exit)
499 devfreq->profile->exit(devfreq->dev.parent);
500
501 mutex_destroy(&devfreq->lock);
502 kfree(devfreq);
503}
504
505/**
506 * devfreq_add_device() - Add devfreq feature to the device
507 * @dev: the device to add devfreq feature.
508 * @profile: device-specific profile to run devfreq.
509 * @governor_name: name of the policy to choose frequency.
510 * @data: private data for the governor. The devfreq framework does not
511 * touch this value.
512 */
513struct devfreq *devfreq_add_device(struct device *dev,
514 struct devfreq_dev_profile *profile,
515 const char *governor_name,
516 void *data)
517{
518 struct devfreq *devfreq;
519 struct devfreq_governor *governor;
520 static atomic_t devfreq_no = ATOMIC_INIT(-1);
521 int err = 0;
522
523 if (!dev || !profile || !governor_name) {
524 dev_err(dev, "%s: Invalid parameters.\n", __func__);
525 return ERR_PTR(-EINVAL);
526 }
527
528 mutex_lock(&devfreq_list_lock);
529 devfreq = find_device_devfreq(dev);
530 mutex_unlock(&devfreq_list_lock);
531 if (!IS_ERR(devfreq)) {
532 dev_err(dev, "%s: Unable to create devfreq for the device.\n",
533 __func__);
534 err = -EINVAL;
535 goto err_out;
536 }
537
538 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
539 if (!devfreq) {
540 err = -ENOMEM;
541 goto err_out;
542 }
543
544 mutex_init(&devfreq->lock);
545 mutex_lock(&devfreq->lock);
546 devfreq->dev.parent = dev;
547 devfreq->dev.class = devfreq_class;
548 devfreq->dev.release = devfreq_dev_release;
549 devfreq->profile = profile;
550 strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
551 devfreq->previous_freq = profile->initial_freq;
552 devfreq->last_status.current_frequency = profile->initial_freq;
553 devfreq->data = data;
554 devfreq->nb.notifier_call = devfreq_notifier_call;
555
556 if (!devfreq->profile->max_state && !devfreq->profile->freq_table) {
557 mutex_unlock(&devfreq->lock);
558 devfreq_set_freq_table(devfreq);
559 mutex_lock(&devfreq->lock);
560 }
561
562 dev_set_name(&devfreq->dev, "devfreq%d",
563 atomic_inc_return(&devfreq_no));
564 err = device_register(&devfreq->dev);
565 if (err) {
566 mutex_unlock(&devfreq->lock);
567 goto err_dev;
568 }
569
570 devfreq->trans_table = devm_kzalloc(&devfreq->dev,
571 sizeof(unsigned int) *
572 devfreq->profile->max_state *
573 devfreq->profile->max_state,
574 GFP_KERNEL);
575 devfreq->time_in_state = devm_kzalloc(&devfreq->dev,
576 sizeof(unsigned long) *
577 devfreq->profile->max_state,
578 GFP_KERNEL);
579 devfreq->last_stat_updated = jiffies;
580
581 srcu_init_notifier_head(&devfreq->transition_notifier_list);
582
583 mutex_unlock(&devfreq->lock);
584
585 mutex_lock(&devfreq_list_lock);
586 list_add(&devfreq->node, &devfreq_list);
587
588 governor = find_devfreq_governor(devfreq->governor_name);
589 if (IS_ERR(governor)) {
590 dev_err(dev, "%s: Unable to find governor for the device\n",
591 __func__);
592 err = PTR_ERR(governor);
593 goto err_init;
594 }
595
596 devfreq->governor = governor;
597 err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
598 NULL);
599 if (err) {
600 dev_err(dev, "%s: Unable to start governor for the device\n",
601 __func__);
602 goto err_init;
603 }
604 mutex_unlock(&devfreq_list_lock);
605
606 return devfreq;
607
608err_init:
609 list_del(&devfreq->node);
610 mutex_unlock(&devfreq_list_lock);
611
612 device_unregister(&devfreq->dev);
613err_dev:
614 if (devfreq)
615 kfree(devfreq);
616err_out:
617 return ERR_PTR(err);
618}
619EXPORT_SYMBOL(devfreq_add_device);
620
621/**
622 * devfreq_remove_device() - Remove devfreq feature from a device.
623 * @devfreq: the devfreq instance to be removed
624 *
625 * The opposite of devfreq_add_device().
626 */
627int devfreq_remove_device(struct devfreq *devfreq)
628{
629 if (!devfreq)
630 return -EINVAL;
631
632 device_unregister(&devfreq->dev);
633
634 return 0;
635}
636EXPORT_SYMBOL(devfreq_remove_device);
637
638static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
639{
640 struct devfreq **r = res;
641
642 if (WARN_ON(!r || !*r))
643 return 0;
644
645 return *r == data;
646}
647
648static void devm_devfreq_dev_release(struct device *dev, void *res)
649{
650 devfreq_remove_device(*(struct devfreq **)res);
651}
652
653/**
654 * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
655 * @dev: the device to add devfreq feature.
656 * @profile: device-specific profile to run devfreq.
657 * @governor_name: name of the policy to choose frequency.
658 * @data: private data for the governor. The devfreq framework does not
659 * touch this value.
660 *
661 * This function manages automatically the memory of devfreq device using device
662 * resource management and simplify the free operation for memory of devfreq
663 * device.
664 */
665struct devfreq *devm_devfreq_add_device(struct device *dev,
666 struct devfreq_dev_profile *profile,
667 const char *governor_name,
668 void *data)
669{
670 struct devfreq **ptr, *devfreq;
671
672 ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
673 if (!ptr)
674 return ERR_PTR(-ENOMEM);
675
676 devfreq = devfreq_add_device(dev, profile, governor_name, data);
677 if (IS_ERR(devfreq)) {
678 devres_free(ptr);
679 return ERR_PTR(-ENOMEM);
680 }
681
682 *ptr = devfreq;
683 devres_add(dev, ptr);
684
685 return devfreq;
686}
687EXPORT_SYMBOL(devm_devfreq_add_device);
688
689#ifdef CONFIG_OF
690/*
691 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
692 * @dev - instance to the given device
693 * @index - index into list of devfreq
694 *
695 * return the instance of devfreq device
696 */
697struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
698{
699 struct device_node *node;
700 struct devfreq *devfreq;
701
702 if (!dev)
703 return ERR_PTR(-EINVAL);
704
705 if (!dev->of_node)
706 return ERR_PTR(-EINVAL);
707
708 node = of_parse_phandle(dev->of_node, "devfreq", index);
709 if (!node)
710 return ERR_PTR(-ENODEV);
711
712 mutex_lock(&devfreq_list_lock);
713 list_for_each_entry(devfreq, &devfreq_list, node) {
714 if (devfreq->dev.parent
715 && devfreq->dev.parent->of_node == node) {
716 mutex_unlock(&devfreq_list_lock);
717 of_node_put(node);
718 return devfreq;
719 }
720 }
721 mutex_unlock(&devfreq_list_lock);
722 of_node_put(node);
723
724 return ERR_PTR(-EPROBE_DEFER);
725}
726#else
727struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
728{
729 return ERR_PTR(-ENODEV);
730}
731#endif /* CONFIG_OF */
732EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
733
734/**
735 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
736 * @dev: the device to add devfreq feature.
737 * @devfreq: the devfreq instance to be removed
738 */
739void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
740{
741 WARN_ON(devres_release(dev, devm_devfreq_dev_release,
742 devm_devfreq_dev_match, devfreq));
743}
744EXPORT_SYMBOL(devm_devfreq_remove_device);
745
746/**
747 * devfreq_suspend_device() - Suspend devfreq of a device.
748 * @devfreq: the devfreq instance to be suspended
749 *
750 * This function is intended to be called by the pm callbacks
751 * (e.g., runtime_suspend, suspend) of the device driver that
752 * holds the devfreq.
753 */
754int devfreq_suspend_device(struct devfreq *devfreq)
755{
756 if (!devfreq)
757 return -EINVAL;
758
759 if (!devfreq->governor)
760 return 0;
761
762 return devfreq->governor->event_handler(devfreq,
763 DEVFREQ_GOV_SUSPEND, NULL);
764}
765EXPORT_SYMBOL(devfreq_suspend_device);
766
767/**
768 * devfreq_resume_device() - Resume devfreq of a device.
769 * @devfreq: the devfreq instance to be resumed
770 *
771 * This function is intended to be called by the pm callbacks
772 * (e.g., runtime_resume, resume) of the device driver that
773 * holds the devfreq.
774 */
775int devfreq_resume_device(struct devfreq *devfreq)
776{
777 if (!devfreq)
778 return -EINVAL;
779
780 if (!devfreq->governor)
781 return 0;
782
783 return devfreq->governor->event_handler(devfreq,
784 DEVFREQ_GOV_RESUME, NULL);
785}
786EXPORT_SYMBOL(devfreq_resume_device);
787
788/**
789 * devfreq_add_governor() - Add devfreq governor
790 * @governor: the devfreq governor to be added
791 */
792int devfreq_add_governor(struct devfreq_governor *governor)
793{
794 struct devfreq_governor *g;
795 struct devfreq *devfreq;
796 int err = 0;
797
798 if (!governor) {
799 pr_err("%s: Invalid parameters.\n", __func__);
800 return -EINVAL;
801 }
802
803 mutex_lock(&devfreq_list_lock);
804 g = find_devfreq_governor(governor->name);
805 if (!IS_ERR(g)) {
806 pr_err("%s: governor %s already registered\n", __func__,
807 g->name);
808 err = -EINVAL;
809 goto err_out;
810 }
811
812 list_add(&governor->node, &devfreq_governor_list);
813
814 list_for_each_entry(devfreq, &devfreq_list, node) {
815 int ret = 0;
816 struct device *dev = devfreq->dev.parent;
817
818 if (!strncmp(devfreq->governor_name, governor->name,
819 DEVFREQ_NAME_LEN)) {
820 /* The following should never occur */
821 if (devfreq->governor) {
822 dev_warn(dev,
823 "%s: Governor %s already present\n",
824 __func__, devfreq->governor->name);
825 ret = devfreq->governor->event_handler(devfreq,
826 DEVFREQ_GOV_STOP, NULL);
827 if (ret) {
828 dev_warn(dev,
829 "%s: Governor %s stop = %d\n",
830 __func__,
831 devfreq->governor->name, ret);
832 }
833 /* Fall through */
834 }
835 devfreq->governor = governor;
836 ret = devfreq->governor->event_handler(devfreq,
837 DEVFREQ_GOV_START, NULL);
838 if (ret) {
839 dev_warn(dev, "%s: Governor %s start=%d\n",
840 __func__, devfreq->governor->name,
841 ret);
842 }
843 }
844 }
845
846err_out:
847 mutex_unlock(&devfreq_list_lock);
848
849 return err;
850}
851EXPORT_SYMBOL(devfreq_add_governor);
852
853/**
854 * devfreq_remove_governor() - Remove devfreq feature from a device.
855 * @governor: the devfreq governor to be removed
856 */
857int devfreq_remove_governor(struct devfreq_governor *governor)
858{
859 struct devfreq_governor *g;
860 struct devfreq *devfreq;
861 int err = 0;
862
863 if (!governor) {
864 pr_err("%s: Invalid parameters.\n", __func__);
865 return -EINVAL;
866 }
867
868 mutex_lock(&devfreq_list_lock);
869 g = find_devfreq_governor(governor->name);
870 if (IS_ERR(g)) {
871 pr_err("%s: governor %s not registered\n", __func__,
872 governor->name);
873 err = PTR_ERR(g);
874 goto err_out;
875 }
876 list_for_each_entry(devfreq, &devfreq_list, node) {
877 int ret;
878 struct device *dev = devfreq->dev.parent;
879
880 if (!strncmp(devfreq->governor_name, governor->name,
881 DEVFREQ_NAME_LEN)) {
882 /* we should have a devfreq governor! */
883 if (!devfreq->governor) {
884 dev_warn(dev, "%s: Governor %s NOT present\n",
885 __func__, governor->name);
886 continue;
887 /* Fall through */
888 }
889 ret = devfreq->governor->event_handler(devfreq,
890 DEVFREQ_GOV_STOP, NULL);
891 if (ret) {
892 dev_warn(dev, "%s: Governor %s stop=%d\n",
893 __func__, devfreq->governor->name,
894 ret);
895 }
896 devfreq->governor = NULL;
897 }
898 }
899
900 list_del(&governor->node);
901err_out:
902 mutex_unlock(&devfreq_list_lock);
903
904 return err;
905}
906EXPORT_SYMBOL(devfreq_remove_governor);
907
908static ssize_t governor_show(struct device *dev,
909 struct device_attribute *attr, char *buf)
910{
911 if (!to_devfreq(dev)->governor)
912 return -EINVAL;
913
914 return sprintf(buf, "%s\n", to_devfreq(dev)->governor->name);
915}
916
917static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
918 const char *buf, size_t count)
919{
920 struct devfreq *df = to_devfreq(dev);
921 int ret;
922 char str_governor[DEVFREQ_NAME_LEN + 1];
923 struct devfreq_governor *governor;
924
925 ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
926 if (ret != 1)
927 return -EINVAL;
928
929 mutex_lock(&devfreq_list_lock);
930 governor = find_devfreq_governor(str_governor);
931 if (IS_ERR(governor)) {
932 ret = PTR_ERR(governor);
933 goto out;
934 }
935 if (df->governor == governor) {
936 ret = 0;
937 goto out;
938 } else if (df->governor->immutable || governor->immutable) {
939 ret = -EINVAL;
940 goto out;
941 }
942
943 if (df->governor) {
944 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
945 if (ret) {
946 dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
947 __func__, df->governor->name, ret);
948 goto out;
949 }
950 }
951 df->governor = governor;
952 strncpy(df->governor_name, governor->name, DEVFREQ_NAME_LEN);
953 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
954 if (ret)
955 dev_warn(dev, "%s: Governor %s not started(%d)\n",
956 __func__, df->governor->name, ret);
957out:
958 mutex_unlock(&devfreq_list_lock);
959
960 if (!ret)
961 ret = count;
962 return ret;
963}
964static DEVICE_ATTR_RW(governor);
965
966static ssize_t available_governors_show(struct device *d,
967 struct device_attribute *attr,
968 char *buf)
969{
970 struct devfreq *df = to_devfreq(d);
971 ssize_t count = 0;
972
973 mutex_lock(&devfreq_list_lock);
974
975 /*
976 * The devfreq with immutable governor (e.g., passive) shows
977 * only own governor.
978 */
979 if (df->governor->immutable) {
980 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
981 "%s ", df->governor_name);
982 /*
983 * The devfreq device shows the registered governor except for
984 * immutable governors such as passive governor .
985 */
986 } else {
987 struct devfreq_governor *governor;
988
989 list_for_each_entry(governor, &devfreq_governor_list, node) {
990 if (governor->immutable)
991 continue;
992 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
993 "%s ", governor->name);
994 }
995 }
996
997 mutex_unlock(&devfreq_list_lock);
998
999 /* Truncate the trailing space */
1000 if (count)
1001 count--;
1002
1003 count += sprintf(&buf[count], "\n");
1004
1005 return count;
1006}
1007static DEVICE_ATTR_RO(available_governors);
1008
1009static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr,
1010 char *buf)
1011{
1012 unsigned long freq;
1013 struct devfreq *devfreq = to_devfreq(dev);
1014
1015 if (devfreq->profile->get_cur_freq &&
1016 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
1017 return sprintf(buf, "%lu\n", freq);
1018
1019 return sprintf(buf, "%lu\n", devfreq->previous_freq);
1020}
1021static DEVICE_ATTR_RO(cur_freq);
1022
1023static ssize_t target_freq_show(struct device *dev,
1024 struct device_attribute *attr, char *buf)
1025{
1026 return sprintf(buf, "%lu\n", to_devfreq(dev)->previous_freq);
1027}
1028static DEVICE_ATTR_RO(target_freq);
1029
1030static ssize_t polling_interval_show(struct device *dev,
1031 struct device_attribute *attr, char *buf)
1032{
1033 return sprintf(buf, "%d\n", to_devfreq(dev)->profile->polling_ms);
1034}
1035
1036static ssize_t polling_interval_store(struct device *dev,
1037 struct device_attribute *attr,
1038 const char *buf, size_t count)
1039{
1040 struct devfreq *df = to_devfreq(dev);
1041 unsigned int value;
1042 int ret;
1043
1044 if (!df->governor)
1045 return -EINVAL;
1046
1047 ret = sscanf(buf, "%u", &value);
1048 if (ret != 1)
1049 return -EINVAL;
1050
1051 df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value);
1052 ret = count;
1053
1054 return ret;
1055}
1056static DEVICE_ATTR_RW(polling_interval);
1057
1058static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
1059 const char *buf, size_t count)
1060{
1061 struct devfreq *df = to_devfreq(dev);
1062 unsigned long value;
1063 int ret;
1064 unsigned long max;
1065
1066 ret = sscanf(buf, "%lu", &value);
1067 if (ret != 1)
1068 return -EINVAL;
1069
1070 mutex_lock(&df->lock);
1071 max = df->max_freq;
1072 if (value && max && value > max) {
1073 ret = -EINVAL;
1074 goto unlock;
1075 }
1076
1077 df->min_freq = value;
1078 update_devfreq(df);
1079 ret = count;
1080unlock:
1081 mutex_unlock(&df->lock);
1082 return ret;
1083}
1084
1085static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
1086 const char *buf, size_t count)
1087{
1088 struct devfreq *df = to_devfreq(dev);
1089 unsigned long value;
1090 int ret;
1091 unsigned long min;
1092
1093 ret = sscanf(buf, "%lu", &value);
1094 if (ret != 1)
1095 return -EINVAL;
1096
1097 mutex_lock(&df->lock);
1098 min = df->min_freq;
1099 if (value && min && value < min) {
1100 ret = -EINVAL;
1101 goto unlock;
1102 }
1103
1104 df->max_freq = value;
1105 update_devfreq(df);
1106 ret = count;
1107unlock:
1108 mutex_unlock(&df->lock);
1109 return ret;
1110}
1111
1112#define show_one(name) \
1113static ssize_t name##_show \
1114(struct device *dev, struct device_attribute *attr, char *buf) \
1115{ \
1116 return sprintf(buf, "%lu\n", to_devfreq(dev)->name); \
1117}
1118show_one(min_freq);
1119show_one(max_freq);
1120
1121static DEVICE_ATTR_RW(min_freq);
1122static DEVICE_ATTR_RW(max_freq);
1123
1124static ssize_t available_frequencies_show(struct device *d,
1125 struct device_attribute *attr,
1126 char *buf)
1127{
1128 struct devfreq *df = to_devfreq(d);
1129 struct device *dev = df->dev.parent;
1130 struct dev_pm_opp *opp;
1131 ssize_t count = 0;
1132 unsigned long freq = 0;
1133
1134 do {
1135 opp = dev_pm_opp_find_freq_ceil(dev, &freq);
1136 if (IS_ERR(opp))
1137 break;
1138
1139 dev_pm_opp_put(opp);
1140 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1141 "%lu ", freq);
1142 freq++;
1143 } while (1);
1144
1145 /* Truncate the trailing space */
1146 if (count)
1147 count--;
1148
1149 count += sprintf(&buf[count], "\n");
1150
1151 return count;
1152}
1153static DEVICE_ATTR_RO(available_frequencies);
1154
1155static ssize_t trans_stat_show(struct device *dev,
1156 struct device_attribute *attr, char *buf)
1157{
1158 struct devfreq *devfreq = to_devfreq(dev);
1159 ssize_t len;
1160 int i, j;
1161 unsigned int max_state = devfreq->profile->max_state;
1162
1163 if (!devfreq->stop_polling &&
1164 devfreq_update_status(devfreq, devfreq->previous_freq))
1165 return 0;
1166 if (max_state == 0)
1167 return sprintf(buf, "Not Supported.\n");
1168
1169 len = sprintf(buf, " From : To\n");
1170 len += sprintf(buf + len, " :");
1171 for (i = 0; i < max_state; i++)
1172 len += sprintf(buf + len, "%10lu",
1173 devfreq->profile->freq_table[i]);
1174
1175 len += sprintf(buf + len, " time(ms)\n");
1176
1177 for (i = 0; i < max_state; i++) {
1178 if (devfreq->profile->freq_table[i]
1179 == devfreq->previous_freq) {
1180 len += sprintf(buf + len, "*");
1181 } else {
1182 len += sprintf(buf + len, " ");
1183 }
1184 len += sprintf(buf + len, "%10lu:",
1185 devfreq->profile->freq_table[i]);
1186 for (j = 0; j < max_state; j++)
1187 len += sprintf(buf + len, "%10u",
1188 devfreq->trans_table[(i * max_state) + j]);
1189 len += sprintf(buf + len, "%10u\n",
1190 jiffies_to_msecs(devfreq->time_in_state[i]));
1191 }
1192
1193 len += sprintf(buf + len, "Total transition : %u\n",
1194 devfreq->total_trans);
1195 return len;
1196}
1197static DEVICE_ATTR_RO(trans_stat);
1198
1199static struct attribute *devfreq_attrs[] = {
1200 &dev_attr_governor.attr,
1201 &dev_attr_available_governors.attr,
1202 &dev_attr_cur_freq.attr,
1203 &dev_attr_available_frequencies.attr,
1204 &dev_attr_target_freq.attr,
1205 &dev_attr_polling_interval.attr,
1206 &dev_attr_min_freq.attr,
1207 &dev_attr_max_freq.attr,
1208 &dev_attr_trans_stat.attr,
1209 NULL,
1210};
1211ATTRIBUTE_GROUPS(devfreq);
1212
1213static int __init devfreq_init(void)
1214{
1215 devfreq_class = class_create(THIS_MODULE, "devfreq");
1216 if (IS_ERR(devfreq_class)) {
1217 pr_err("%s: couldn't create class\n", __FILE__);
1218 return PTR_ERR(devfreq_class);
1219 }
1220
1221 devfreq_wq = create_freezable_workqueue("devfreq_wq");
1222 if (!devfreq_wq) {
1223 class_destroy(devfreq_class);
1224 pr_err("%s: couldn't create workqueue\n", __FILE__);
1225 return -ENOMEM;
1226 }
1227 devfreq_class->dev_groups = devfreq_groups;
1228
1229 return 0;
1230}
1231subsys_initcall(devfreq_init);
1232
1233/*
1234 * The following are helper functions for devfreq user device drivers with
1235 * OPP framework.
1236 */
1237
1238/**
1239 * devfreq_recommended_opp() - Helper function to get proper OPP for the
1240 * freq value given to target callback.
1241 * @dev: The devfreq user device. (parent of devfreq)
1242 * @freq: The frequency given to target function
1243 * @flags: Flags handed from devfreq framework.
1244 *
1245 * The callers are required to call dev_pm_opp_put() for the returned OPP after
1246 * use.
1247 */
1248struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
1249 unsigned long *freq,
1250 u32 flags)
1251{
1252 struct dev_pm_opp *opp;
1253
1254 if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
1255 /* The freq is an upper bound. opp should be lower */
1256 opp = dev_pm_opp_find_freq_floor(dev, freq);
1257
1258 /* If not available, use the closest opp */
1259 if (opp == ERR_PTR(-ERANGE))
1260 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1261 } else {
1262 /* The freq is an lower bound. opp should be higher */
1263 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1264
1265 /* If not available, use the closest opp */
1266 if (opp == ERR_PTR(-ERANGE))
1267 opp = dev_pm_opp_find_freq_floor(dev, freq);
1268 }
1269
1270 return opp;
1271}
1272EXPORT_SYMBOL(devfreq_recommended_opp);
1273
1274/**
1275 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1276 * for any changes in the OPP availability
1277 * changes
1278 * @dev: The devfreq user device. (parent of devfreq)
1279 * @devfreq: The devfreq object.
1280 */
1281int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1282{
1283 return dev_pm_opp_register_notifier(dev, &devfreq->nb);
1284}
1285EXPORT_SYMBOL(devfreq_register_opp_notifier);
1286
1287/**
1288 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1289 * notified for any changes in the OPP
1290 * availability changes anymore.
1291 * @dev: The devfreq user device. (parent of devfreq)
1292 * @devfreq: The devfreq object.
1293 *
1294 * At exit() callback of devfreq_dev_profile, this must be included if
1295 * devfreq_recommended_opp is used.
1296 */
1297int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1298{
1299 return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
1300}
1301EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
1302
1303static void devm_devfreq_opp_release(struct device *dev, void *res)
1304{
1305 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
1306}
1307
1308/**
1309 * devm_ devfreq_register_opp_notifier()
1310 * - Resource-managed devfreq_register_opp_notifier()
1311 * @dev: The devfreq user device. (parent of devfreq)
1312 * @devfreq: The devfreq object.
1313 */
1314int devm_devfreq_register_opp_notifier(struct device *dev,
1315 struct devfreq *devfreq)
1316{
1317 struct devfreq **ptr;
1318 int ret;
1319
1320 ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
1321 if (!ptr)
1322 return -ENOMEM;
1323
1324 ret = devfreq_register_opp_notifier(dev, devfreq);
1325 if (ret) {
1326 devres_free(ptr);
1327 return ret;
1328 }
1329
1330 *ptr = devfreq;
1331 devres_add(dev, ptr);
1332
1333 return 0;
1334}
1335EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
1336
1337/**
1338 * devm_devfreq_unregister_opp_notifier()
1339 * - Resource-managed devfreq_unregister_opp_notifier()
1340 * @dev: The devfreq user device. (parent of devfreq)
1341 * @devfreq: The devfreq object.
1342 */
1343void devm_devfreq_unregister_opp_notifier(struct device *dev,
1344 struct devfreq *devfreq)
1345{
1346 WARN_ON(devres_release(dev, devm_devfreq_opp_release,
1347 devm_devfreq_dev_match, devfreq));
1348}
1349EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
1350
1351/**
1352 * devfreq_register_notifier() - Register a driver with devfreq
1353 * @devfreq: The devfreq object.
1354 * @nb: The notifier block to register.
1355 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1356 */
1357int devfreq_register_notifier(struct devfreq *devfreq,
1358 struct notifier_block *nb,
1359 unsigned int list)
1360{
1361 int ret = 0;
1362
1363 if (!devfreq)
1364 return -EINVAL;
1365
1366 switch (list) {
1367 case DEVFREQ_TRANSITION_NOTIFIER:
1368 ret = srcu_notifier_chain_register(
1369 &devfreq->transition_notifier_list, nb);
1370 break;
1371 default:
1372 ret = -EINVAL;
1373 }
1374
1375 return ret;
1376}
1377EXPORT_SYMBOL(devfreq_register_notifier);
1378
1379/*
1380 * devfreq_unregister_notifier() - Unregister a driver with devfreq
1381 * @devfreq: The devfreq object.
1382 * @nb: The notifier block to be unregistered.
1383 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1384 */
1385int devfreq_unregister_notifier(struct devfreq *devfreq,
1386 struct notifier_block *nb,
1387 unsigned int list)
1388{
1389 int ret = 0;
1390
1391 if (!devfreq)
1392 return -EINVAL;
1393
1394 switch (list) {
1395 case DEVFREQ_TRANSITION_NOTIFIER:
1396 ret = srcu_notifier_chain_unregister(
1397 &devfreq->transition_notifier_list, nb);
1398 break;
1399 default:
1400 ret = -EINVAL;
1401 }
1402
1403 return ret;
1404}
1405EXPORT_SYMBOL(devfreq_unregister_notifier);
1406
1407struct devfreq_notifier_devres {
1408 struct devfreq *devfreq;
1409 struct notifier_block *nb;
1410 unsigned int list;
1411};
1412
1413static void devm_devfreq_notifier_release(struct device *dev, void *res)
1414{
1415 struct devfreq_notifier_devres *this = res;
1416
1417 devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
1418}
1419
1420/**
1421 * devm_devfreq_register_notifier()
1422 - Resource-managed devfreq_register_notifier()
1423 * @dev: The devfreq user device. (parent of devfreq)
1424 * @devfreq: The devfreq object.
1425 * @nb: The notifier block to be unregistered.
1426 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1427 */
1428int devm_devfreq_register_notifier(struct device *dev,
1429 struct devfreq *devfreq,
1430 struct notifier_block *nb,
1431 unsigned int list)
1432{
1433 struct devfreq_notifier_devres *ptr;
1434 int ret;
1435
1436 ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
1437 GFP_KERNEL);
1438 if (!ptr)
1439 return -ENOMEM;
1440
1441 ret = devfreq_register_notifier(devfreq, nb, list);
1442 if (ret) {
1443 devres_free(ptr);
1444 return ret;
1445 }
1446
1447 ptr->devfreq = devfreq;
1448 ptr->nb = nb;
1449 ptr->list = list;
1450 devres_add(dev, ptr);
1451
1452 return 0;
1453}
1454EXPORT_SYMBOL(devm_devfreq_register_notifier);
1455
1456/**
1457 * devm_devfreq_unregister_notifier()
1458 - Resource-managed devfreq_unregister_notifier()
1459 * @dev: The devfreq user device. (parent of devfreq)
1460 * @devfreq: The devfreq object.
1461 * @nb: The notifier block to be unregistered.
1462 * @list: DEVFREQ_TRANSITION_NOTIFIER.
1463 */
1464void devm_devfreq_unregister_notifier(struct device *dev,
1465 struct devfreq *devfreq,
1466 struct notifier_block *nb,
1467 unsigned int list)
1468{
1469 WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
1470 devm_devfreq_dev_match, devfreq));
1471}
1472EXPORT_SYMBOL(devm_devfreq_unregister_notifier);