projects/linux·blob v5.7 · refs

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