projects/linux·blob v4.10 · refs

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