Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
0004  *      for Non-CPU Devices.
0005  *
0006  * Copyright (C) 2011 Samsung Electronics
0007  *  MyungJoo Ham <myungjoo.ham@samsung.com>
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/kmod.h>
0012 #include <linux/sched.h>
0013 #include <linux/debugfs.h>
0014 #include <linux/devfreq_cooling.h>
0015 #include <linux/errno.h>
0016 #include <linux/err.h>
0017 #include <linux/init.h>
0018 #include <linux/export.h>
0019 #include <linux/slab.h>
0020 #include <linux/stat.h>
0021 #include <linux/pm_opp.h>
0022 #include <linux/devfreq.h>
0023 #include <linux/workqueue.h>
0024 #include <linux/platform_device.h>
0025 #include <linux/list.h>
0026 #include <linux/printk.h>
0027 #include <linux/hrtimer.h>
0028 #include <linux/of.h>
0029 #include <linux/pm_qos.h>
0030 #include <linux/units.h>
0031 #include "governor.h"
0032 
0033 #define CREATE_TRACE_POINTS
0034 #include <trace/events/devfreq.h>
0035 
0036 #define IS_SUPPORTED_FLAG(f, name) ((f & DEVFREQ_GOV_FLAG_##name) ? true : false)
0037 #define IS_SUPPORTED_ATTR(f, name) ((f & DEVFREQ_GOV_ATTR_##name) ? true : false)
0038 
0039 static struct class *devfreq_class;
0040 static struct dentry *devfreq_debugfs;
0041 
0042 /*
0043  * devfreq core provides delayed work based load monitoring helper
0044  * functions. Governors can use these or can implement their own
0045  * monitoring mechanism.
0046  */
0047 static struct workqueue_struct *devfreq_wq;
0048 
0049 /* The list of all device-devfreq governors */
0050 static LIST_HEAD(devfreq_governor_list);
0051 /* The list of all device-devfreq */
0052 static LIST_HEAD(devfreq_list);
0053 static DEFINE_MUTEX(devfreq_list_lock);
0054 
0055 static const char timer_name[][DEVFREQ_NAME_LEN] = {
0056     [DEVFREQ_TIMER_DEFERRABLE] = { "deferrable" },
0057     [DEVFREQ_TIMER_DELAYED] = { "delayed" },
0058 };
0059 
0060 /**
0061  * find_device_devfreq() - find devfreq struct using device pointer
0062  * @dev:    device pointer used to lookup device devfreq.
0063  *
0064  * Search the list of device devfreqs and return the matched device's
0065  * devfreq info. devfreq_list_lock should be held by the caller.
0066  */
0067 static struct devfreq *find_device_devfreq(struct device *dev)
0068 {
0069     struct devfreq *tmp_devfreq;
0070 
0071     lockdep_assert_held(&devfreq_list_lock);
0072 
0073     if (IS_ERR_OR_NULL(dev)) {
0074         pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
0075         return ERR_PTR(-EINVAL);
0076     }
0077 
0078     list_for_each_entry(tmp_devfreq, &devfreq_list, node) {
0079         if (tmp_devfreq->dev.parent == dev)
0080             return tmp_devfreq;
0081     }
0082 
0083     return ERR_PTR(-ENODEV);
0084 }
0085 
0086 static unsigned long find_available_min_freq(struct devfreq *devfreq)
0087 {
0088     struct dev_pm_opp *opp;
0089     unsigned long min_freq = 0;
0090 
0091     opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &min_freq);
0092     if (IS_ERR(opp))
0093         min_freq = 0;
0094     else
0095         dev_pm_opp_put(opp);
0096 
0097     return min_freq;
0098 }
0099 
0100 static unsigned long find_available_max_freq(struct devfreq *devfreq)
0101 {
0102     struct dev_pm_opp *opp;
0103     unsigned long max_freq = ULONG_MAX;
0104 
0105     opp = dev_pm_opp_find_freq_floor(devfreq->dev.parent, &max_freq);
0106     if (IS_ERR(opp))
0107         max_freq = 0;
0108     else
0109         dev_pm_opp_put(opp);
0110 
0111     return max_freq;
0112 }
0113 
0114 /**
0115  * devfreq_get_freq_range() - Get the current freq range
0116  * @devfreq:    the devfreq instance
0117  * @min_freq:   the min frequency
0118  * @max_freq:   the max frequency
0119  *
0120  * This takes into consideration all constraints.
0121  */
0122 void devfreq_get_freq_range(struct devfreq *devfreq,
0123                 unsigned long *min_freq,
0124                 unsigned long *max_freq)
0125 {
0126     unsigned long *freq_table = devfreq->freq_table;
0127     s32 qos_min_freq, qos_max_freq;
0128 
0129     lockdep_assert_held(&devfreq->lock);
0130 
0131     /*
0132      * Initialize minimum/maximum frequency from freq table.
0133      * The devfreq drivers can initialize this in either ascending or
0134      * descending order and devfreq core supports both.
0135      */
0136     if (freq_table[0] < freq_table[devfreq->max_state - 1]) {
0137         *min_freq = freq_table[0];
0138         *max_freq = freq_table[devfreq->max_state - 1];
0139     } else {
0140         *min_freq = freq_table[devfreq->max_state - 1];
0141         *max_freq = freq_table[0];
0142     }
0143 
0144     /* Apply constraints from PM QoS */
0145     qos_min_freq = dev_pm_qos_read_value(devfreq->dev.parent,
0146                          DEV_PM_QOS_MIN_FREQUENCY);
0147     qos_max_freq = dev_pm_qos_read_value(devfreq->dev.parent,
0148                          DEV_PM_QOS_MAX_FREQUENCY);
0149     *min_freq = max(*min_freq, (unsigned long)HZ_PER_KHZ * qos_min_freq);
0150     if (qos_max_freq != PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE)
0151         *max_freq = min(*max_freq,
0152                 (unsigned long)HZ_PER_KHZ * qos_max_freq);
0153 
0154     /* Apply constraints from OPP interface */
0155     *min_freq = max(*min_freq, devfreq->scaling_min_freq);
0156     *max_freq = min(*max_freq, devfreq->scaling_max_freq);
0157 
0158     if (*min_freq > *max_freq)
0159         *min_freq = *max_freq;
0160 }
0161 EXPORT_SYMBOL(devfreq_get_freq_range);
0162 
0163 /**
0164  * devfreq_get_freq_level() - Lookup freq_table for the frequency
0165  * @devfreq:    the devfreq instance
0166  * @freq:   the target frequency
0167  */
0168 static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq)
0169 {
0170     int lev;
0171 
0172     for (lev = 0; lev < devfreq->max_state; lev++)
0173         if (freq == devfreq->freq_table[lev])
0174             return lev;
0175 
0176     return -EINVAL;
0177 }
0178 
0179 static int set_freq_table(struct devfreq *devfreq)
0180 {
0181     struct dev_pm_opp *opp;
0182     unsigned long freq;
0183     int i, count;
0184 
0185     /* Initialize the freq_table from OPP table */
0186     count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
0187     if (count <= 0)
0188         return -EINVAL;
0189 
0190     devfreq->max_state = count;
0191     devfreq->freq_table = devm_kcalloc(devfreq->dev.parent,
0192                        devfreq->max_state,
0193                        sizeof(*devfreq->freq_table),
0194                        GFP_KERNEL);
0195     if (!devfreq->freq_table)
0196         return -ENOMEM;
0197 
0198     for (i = 0, freq = 0; i < devfreq->max_state; i++, freq++) {
0199         opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
0200         if (IS_ERR(opp)) {
0201             devm_kfree(devfreq->dev.parent, devfreq->freq_table);
0202             return PTR_ERR(opp);
0203         }
0204         dev_pm_opp_put(opp);
0205         devfreq->freq_table[i] = freq;
0206     }
0207 
0208     return 0;
0209 }
0210 
0211 /**
0212  * devfreq_update_status() - Update statistics of devfreq behavior
0213  * @devfreq:    the devfreq instance
0214  * @freq:   the update target frequency
0215  */
0216 int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
0217 {
0218     int lev, prev_lev, ret = 0;
0219     u64 cur_time;
0220 
0221     lockdep_assert_held(&devfreq->lock);
0222     cur_time = get_jiffies_64();
0223 
0224     /* Immediately exit if previous_freq is not initialized yet. */
0225     if (!devfreq->previous_freq)
0226         goto out;
0227 
0228     prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq);
0229     if (prev_lev < 0) {
0230         ret = prev_lev;
0231         goto out;
0232     }
0233 
0234     devfreq->stats.time_in_state[prev_lev] +=
0235             cur_time - devfreq->stats.last_update;
0236 
0237     lev = devfreq_get_freq_level(devfreq, freq);
0238     if (lev < 0) {
0239         ret = lev;
0240         goto out;
0241     }
0242 
0243     if (lev != prev_lev) {
0244         devfreq->stats.trans_table[
0245             (prev_lev * devfreq->max_state) + lev]++;
0246         devfreq->stats.total_trans++;
0247     }
0248 
0249 out:
0250     devfreq->stats.last_update = cur_time;
0251     return ret;
0252 }
0253 EXPORT_SYMBOL(devfreq_update_status);
0254 
0255 /**
0256  * find_devfreq_governor() - find devfreq governor from name
0257  * @name:   name of the governor
0258  *
0259  * Search the list of devfreq governors and return the matched
0260  * governor's pointer. devfreq_list_lock should be held by the caller.
0261  */
0262 static struct devfreq_governor *find_devfreq_governor(const char *name)
0263 {
0264     struct devfreq_governor *tmp_governor;
0265 
0266     lockdep_assert_held(&devfreq_list_lock);
0267 
0268     if (IS_ERR_OR_NULL(name)) {
0269         pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
0270         return ERR_PTR(-EINVAL);
0271     }
0272 
0273     list_for_each_entry(tmp_governor, &devfreq_governor_list, node) {
0274         if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN))
0275             return tmp_governor;
0276     }
0277 
0278     return ERR_PTR(-ENODEV);
0279 }
0280 
0281 /**
0282  * try_then_request_governor() - Try to find the governor and request the
0283  *                               module if is not found.
0284  * @name:   name of the governor
0285  *
0286  * Search the list of devfreq governors and request the module and try again
0287  * if is not found. This can happen when both drivers (the governor driver
0288  * and the driver that call devfreq_add_device) are built as modules.
0289  * devfreq_list_lock should be held by the caller. Returns the matched
0290  * governor's pointer or an error pointer.
0291  */
0292 static struct devfreq_governor *try_then_request_governor(const char *name)
0293 {
0294     struct devfreq_governor *governor;
0295     int err = 0;
0296 
0297     lockdep_assert_held(&devfreq_list_lock);
0298 
0299     if (IS_ERR_OR_NULL(name)) {
0300         pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
0301         return ERR_PTR(-EINVAL);
0302     }
0303 
0304     governor = find_devfreq_governor(name);
0305     if (IS_ERR(governor)) {
0306         mutex_unlock(&devfreq_list_lock);
0307 
0308         if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND,
0309                  DEVFREQ_NAME_LEN))
0310             err = request_module("governor_%s", "simpleondemand");
0311         else
0312             err = request_module("governor_%s", name);
0313         /* Restore previous state before return */
0314         mutex_lock(&devfreq_list_lock);
0315         if (err)
0316             return (err < 0) ? ERR_PTR(err) : ERR_PTR(-EINVAL);
0317 
0318         governor = find_devfreq_governor(name);
0319     }
0320 
0321     return governor;
0322 }
0323 
0324 static int devfreq_notify_transition(struct devfreq *devfreq,
0325         struct devfreq_freqs *freqs, unsigned int state)
0326 {
0327     if (!devfreq)
0328         return -EINVAL;
0329 
0330     switch (state) {
0331     case DEVFREQ_PRECHANGE:
0332         srcu_notifier_call_chain(&devfreq->transition_notifier_list,
0333                 DEVFREQ_PRECHANGE, freqs);
0334         break;
0335 
0336     case DEVFREQ_POSTCHANGE:
0337         srcu_notifier_call_chain(&devfreq->transition_notifier_list,
0338                 DEVFREQ_POSTCHANGE, freqs);
0339         break;
0340     default:
0341         return -EINVAL;
0342     }
0343 
0344     return 0;
0345 }
0346 
0347 static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq,
0348                   u32 flags)
0349 {
0350     struct devfreq_freqs freqs;
0351     unsigned long cur_freq;
0352     int err = 0;
0353 
0354     if (devfreq->profile->get_cur_freq)
0355         devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
0356     else
0357         cur_freq = devfreq->previous_freq;
0358 
0359     freqs.old = cur_freq;
0360     freqs.new = new_freq;
0361     devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
0362 
0363     err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags);
0364     if (err) {
0365         freqs.new = cur_freq;
0366         devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
0367         return err;
0368     }
0369 
0370     /*
0371      * Print devfreq_frequency trace information between DEVFREQ_PRECHANGE
0372      * and DEVFREQ_POSTCHANGE because for showing the correct frequency
0373      * change order of between devfreq device and passive devfreq device.
0374      */
0375     if (trace_devfreq_frequency_enabled() && new_freq != cur_freq)
0376         trace_devfreq_frequency(devfreq, new_freq, cur_freq);
0377 
0378     freqs.new = new_freq;
0379     devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
0380 
0381     if (devfreq_update_status(devfreq, new_freq))
0382         dev_warn(&devfreq->dev,
0383              "Couldn't update frequency transition information.\n");
0384 
0385     devfreq->previous_freq = new_freq;
0386 
0387     if (devfreq->suspend_freq)
0388         devfreq->resume_freq = new_freq;
0389 
0390     return err;
0391 }
0392 
0393 /**
0394  * devfreq_update_target() - Reevaluate the device and configure frequency
0395  *             on the final stage.
0396  * @devfreq:    the devfreq instance.
0397  * @freq:   the new frequency of parent device. This argument
0398  *      is only used for devfreq device using passive governor.
0399  *
0400  * Note: Lock devfreq->lock before calling devfreq_update_target. This function
0401  *   should be only used by both update_devfreq() and devfreq governors.
0402  */
0403 int devfreq_update_target(struct devfreq *devfreq, unsigned long freq)
0404 {
0405     unsigned long min_freq, max_freq;
0406     int err = 0;
0407     u32 flags = 0;
0408 
0409     lockdep_assert_held(&devfreq->lock);
0410 
0411     if (!devfreq->governor)
0412         return -EINVAL;
0413 
0414     /* Reevaluate the proper frequency */
0415     err = devfreq->governor->get_target_freq(devfreq, &freq);
0416     if (err)
0417         return err;
0418     devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
0419 
0420     if (freq < min_freq) {
0421         freq = min_freq;
0422         flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */
0423     }
0424     if (freq > max_freq) {
0425         freq = max_freq;
0426         flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */
0427     }
0428 
0429     return devfreq_set_target(devfreq, freq, flags);
0430 }
0431 EXPORT_SYMBOL(devfreq_update_target);
0432 
0433 /* Load monitoring helper functions for governors use */
0434 
0435 /**
0436  * update_devfreq() - Reevaluate the device and configure frequency.
0437  * @devfreq:    the devfreq instance.
0438  *
0439  * Note: Lock devfreq->lock before calling update_devfreq
0440  *   This function is exported for governors.
0441  */
0442 int update_devfreq(struct devfreq *devfreq)
0443 {
0444     return devfreq_update_target(devfreq, 0L);
0445 }
0446 EXPORT_SYMBOL(update_devfreq);
0447 
0448 /**
0449  * devfreq_monitor() - Periodically poll devfreq objects.
0450  * @work:   the work struct used to run devfreq_monitor periodically.
0451  *
0452  */
0453 static void devfreq_monitor(struct work_struct *work)
0454 {
0455     int err;
0456     struct devfreq *devfreq = container_of(work,
0457                     struct devfreq, work.work);
0458 
0459     mutex_lock(&devfreq->lock);
0460     err = update_devfreq(devfreq);
0461     if (err)
0462         dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
0463 
0464     queue_delayed_work(devfreq_wq, &devfreq->work,
0465                 msecs_to_jiffies(devfreq->profile->polling_ms));
0466     mutex_unlock(&devfreq->lock);
0467 
0468     trace_devfreq_monitor(devfreq);
0469 }
0470 
0471 /**
0472  * devfreq_monitor_start() - Start load monitoring of devfreq instance
0473  * @devfreq:    the devfreq instance.
0474  *
0475  * Helper function for starting devfreq device load monitoring. By
0476  * default delayed work based monitoring is supported. Function
0477  * to be called from governor in response to DEVFREQ_GOV_START
0478  * event when device is added to devfreq framework.
0479  */
0480 void devfreq_monitor_start(struct devfreq *devfreq)
0481 {
0482     if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
0483         return;
0484 
0485     switch (devfreq->profile->timer) {
0486     case DEVFREQ_TIMER_DEFERRABLE:
0487         INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
0488         break;
0489     case DEVFREQ_TIMER_DELAYED:
0490         INIT_DELAYED_WORK(&devfreq->work, devfreq_monitor);
0491         break;
0492     default:
0493         return;
0494     }
0495 
0496     if (devfreq->profile->polling_ms)
0497         queue_delayed_work(devfreq_wq, &devfreq->work,
0498             msecs_to_jiffies(devfreq->profile->polling_ms));
0499 }
0500 EXPORT_SYMBOL(devfreq_monitor_start);
0501 
0502 /**
0503  * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
0504  * @devfreq:    the devfreq instance.
0505  *
0506  * Helper function to stop devfreq device load monitoring. Function
0507  * to be called from governor in response to DEVFREQ_GOV_STOP
0508  * event when device is removed from devfreq framework.
0509  */
0510 void devfreq_monitor_stop(struct devfreq *devfreq)
0511 {
0512     if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
0513         return;
0514 
0515     cancel_delayed_work_sync(&devfreq->work);
0516 }
0517 EXPORT_SYMBOL(devfreq_monitor_stop);
0518 
0519 /**
0520  * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
0521  * @devfreq:    the devfreq instance.
0522  *
0523  * Helper function to suspend devfreq device load monitoring. Function
0524  * to be called from governor in response to DEVFREQ_GOV_SUSPEND
0525  * event or when polling interval is set to zero.
0526  *
0527  * Note: Though this function is same as devfreq_monitor_stop(),
0528  * intentionally kept separate to provide hooks for collecting
0529  * transition statistics.
0530  */
0531 void devfreq_monitor_suspend(struct devfreq *devfreq)
0532 {
0533     mutex_lock(&devfreq->lock);
0534     if (devfreq->stop_polling) {
0535         mutex_unlock(&devfreq->lock);
0536         return;
0537     }
0538 
0539     devfreq_update_status(devfreq, devfreq->previous_freq);
0540     devfreq->stop_polling = true;
0541     mutex_unlock(&devfreq->lock);
0542 
0543     if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
0544         return;
0545 
0546     cancel_delayed_work_sync(&devfreq->work);
0547 }
0548 EXPORT_SYMBOL(devfreq_monitor_suspend);
0549 
0550 /**
0551  * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
0552  * @devfreq:    the devfreq instance.
0553  *
0554  * Helper function to resume devfreq device load monitoring. Function
0555  * to be called from governor in response to DEVFREQ_GOV_RESUME
0556  * event or when polling interval is set to non-zero.
0557  */
0558 void devfreq_monitor_resume(struct devfreq *devfreq)
0559 {
0560     unsigned long freq;
0561 
0562     mutex_lock(&devfreq->lock);
0563 
0564     if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
0565         goto out_update;
0566 
0567     if (!devfreq->stop_polling)
0568         goto out;
0569 
0570     if (!delayed_work_pending(&devfreq->work) &&
0571             devfreq->profile->polling_ms)
0572         queue_delayed_work(devfreq_wq, &devfreq->work,
0573             msecs_to_jiffies(devfreq->profile->polling_ms));
0574 
0575 out_update:
0576     devfreq->stats.last_update = get_jiffies_64();
0577     devfreq->stop_polling = false;
0578 
0579     if (devfreq->profile->get_cur_freq &&
0580         !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
0581         devfreq->previous_freq = freq;
0582 
0583 out:
0584     mutex_unlock(&devfreq->lock);
0585 }
0586 EXPORT_SYMBOL(devfreq_monitor_resume);
0587 
0588 /**
0589  * devfreq_update_interval() - Update device devfreq monitoring interval
0590  * @devfreq:    the devfreq instance.
0591  * @delay:      new polling interval to be set.
0592  *
0593  * Helper function to set new load monitoring polling interval. Function
0594  * to be called from governor in response to DEVFREQ_GOV_UPDATE_INTERVAL event.
0595  */
0596 void devfreq_update_interval(struct devfreq *devfreq, unsigned int *delay)
0597 {
0598     unsigned int cur_delay = devfreq->profile->polling_ms;
0599     unsigned int new_delay = *delay;
0600 
0601     mutex_lock(&devfreq->lock);
0602     devfreq->profile->polling_ms = new_delay;
0603 
0604     if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
0605         goto out;
0606 
0607     if (devfreq->stop_polling)
0608         goto out;
0609 
0610     /* if new delay is zero, stop polling */
0611     if (!new_delay) {
0612         mutex_unlock(&devfreq->lock);
0613         cancel_delayed_work_sync(&devfreq->work);
0614         return;
0615     }
0616 
0617     /* if current delay is zero, start polling with new delay */
0618     if (!cur_delay) {
0619         queue_delayed_work(devfreq_wq, &devfreq->work,
0620             msecs_to_jiffies(devfreq->profile->polling_ms));
0621         goto out;
0622     }
0623 
0624     /* if current delay is greater than new delay, restart polling */
0625     if (cur_delay > new_delay) {
0626         mutex_unlock(&devfreq->lock);
0627         cancel_delayed_work_sync(&devfreq->work);
0628         mutex_lock(&devfreq->lock);
0629         if (!devfreq->stop_polling)
0630             queue_delayed_work(devfreq_wq, &devfreq->work,
0631                 msecs_to_jiffies(devfreq->profile->polling_ms));
0632     }
0633 out:
0634     mutex_unlock(&devfreq->lock);
0635 }
0636 EXPORT_SYMBOL(devfreq_update_interval);
0637 
0638 /**
0639  * devfreq_notifier_call() - Notify that the device frequency requirements
0640  *               has been changed out of devfreq framework.
0641  * @nb:     the notifier_block (supposed to be devfreq->nb)
0642  * @type:   not used
0643  * @devp:   not used
0644  *
0645  * Called by a notifier that uses devfreq->nb.
0646  */
0647 static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
0648                  void *devp)
0649 {
0650     struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
0651     int err = -EINVAL;
0652 
0653     mutex_lock(&devfreq->lock);
0654 
0655     devfreq->scaling_min_freq = find_available_min_freq(devfreq);
0656     if (!devfreq->scaling_min_freq)
0657         goto out;
0658 
0659     devfreq->scaling_max_freq = find_available_max_freq(devfreq);
0660     if (!devfreq->scaling_max_freq) {
0661         devfreq->scaling_max_freq = ULONG_MAX;
0662         goto out;
0663     }
0664 
0665     err = update_devfreq(devfreq);
0666 
0667 out:
0668     mutex_unlock(&devfreq->lock);
0669     if (err)
0670         dev_err(devfreq->dev.parent,
0671             "failed to update frequency from OPP notifier (%d)\n",
0672             err);
0673 
0674     return NOTIFY_OK;
0675 }
0676 
0677 /**
0678  * qos_notifier_call() - Common handler for QoS constraints.
0679  * @devfreq:    the devfreq instance.
0680  */
0681 static int qos_notifier_call(struct devfreq *devfreq)
0682 {
0683     int err;
0684 
0685     mutex_lock(&devfreq->lock);
0686     err = update_devfreq(devfreq);
0687     mutex_unlock(&devfreq->lock);
0688     if (err)
0689         dev_err(devfreq->dev.parent,
0690             "failed to update frequency from PM QoS (%d)\n",
0691             err);
0692 
0693     return NOTIFY_OK;
0694 }
0695 
0696 /**
0697  * qos_min_notifier_call() - Callback for QoS min_freq changes.
0698  * @nb:     Should be devfreq->nb_min
0699  * @val:    not used
0700  * @ptr:    not used
0701  */
0702 static int qos_min_notifier_call(struct notifier_block *nb,
0703                      unsigned long val, void *ptr)
0704 {
0705     return qos_notifier_call(container_of(nb, struct devfreq, nb_min));
0706 }
0707 
0708 /**
0709  * qos_max_notifier_call() - Callback for QoS max_freq changes.
0710  * @nb:     Should be devfreq->nb_max
0711  * @val:    not used
0712  * @ptr:    not used
0713  */
0714 static int qos_max_notifier_call(struct notifier_block *nb,
0715                      unsigned long val, void *ptr)
0716 {
0717     return qos_notifier_call(container_of(nb, struct devfreq, nb_max));
0718 }
0719 
0720 /**
0721  * devfreq_dev_release() - Callback for struct device to release the device.
0722  * @dev:    the devfreq device
0723  *
0724  * Remove devfreq from the list and release its resources.
0725  */
0726 static void devfreq_dev_release(struct device *dev)
0727 {
0728     struct devfreq *devfreq = to_devfreq(dev);
0729     int err;
0730 
0731     mutex_lock(&devfreq_list_lock);
0732     list_del(&devfreq->node);
0733     mutex_unlock(&devfreq_list_lock);
0734 
0735     err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_max,
0736                      DEV_PM_QOS_MAX_FREQUENCY);
0737     if (err && err != -ENOENT)
0738         dev_warn(dev->parent,
0739             "Failed to remove max_freq notifier: %d\n", err);
0740     err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_min,
0741                      DEV_PM_QOS_MIN_FREQUENCY);
0742     if (err && err != -ENOENT)
0743         dev_warn(dev->parent,
0744             "Failed to remove min_freq notifier: %d\n", err);
0745 
0746     if (dev_pm_qos_request_active(&devfreq->user_max_freq_req)) {
0747         err = dev_pm_qos_remove_request(&devfreq->user_max_freq_req);
0748         if (err < 0)
0749             dev_warn(dev->parent,
0750                 "Failed to remove max_freq request: %d\n", err);
0751     }
0752     if (dev_pm_qos_request_active(&devfreq->user_min_freq_req)) {
0753         err = dev_pm_qos_remove_request(&devfreq->user_min_freq_req);
0754         if (err < 0)
0755             dev_warn(dev->parent,
0756                 "Failed to remove min_freq request: %d\n", err);
0757     }
0758 
0759     if (devfreq->profile->exit)
0760         devfreq->profile->exit(devfreq->dev.parent);
0761 
0762     if (devfreq->opp_table)
0763         dev_pm_opp_put_opp_table(devfreq->opp_table);
0764 
0765     mutex_destroy(&devfreq->lock);
0766     kfree(devfreq);
0767 }
0768 
0769 static void create_sysfs_files(struct devfreq *devfreq,
0770                 const struct devfreq_governor *gov);
0771 static void remove_sysfs_files(struct devfreq *devfreq,
0772                 const struct devfreq_governor *gov);
0773 
0774 /**
0775  * devfreq_add_device() - Add devfreq feature to the device
0776  * @dev:    the device to add devfreq feature.
0777  * @profile:    device-specific profile to run devfreq.
0778  * @governor_name:  name of the policy to choose frequency.
0779  * @data:   private data for the governor. The devfreq framework does not
0780  *      touch this value.
0781  */
0782 struct devfreq *devfreq_add_device(struct device *dev,
0783                    struct devfreq_dev_profile *profile,
0784                    const char *governor_name,
0785                    void *data)
0786 {
0787     struct devfreq *devfreq;
0788     struct devfreq_governor *governor;
0789     unsigned long min_freq, max_freq;
0790     int err = 0;
0791 
0792     if (!dev || !profile || !governor_name) {
0793         dev_err(dev, "%s: Invalid parameters.\n", __func__);
0794         return ERR_PTR(-EINVAL);
0795     }
0796 
0797     mutex_lock(&devfreq_list_lock);
0798     devfreq = find_device_devfreq(dev);
0799     mutex_unlock(&devfreq_list_lock);
0800     if (!IS_ERR(devfreq)) {
0801         dev_err(dev, "%s: devfreq device already exists!\n",
0802             __func__);
0803         err = -EINVAL;
0804         goto err_out;
0805     }
0806 
0807     devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
0808     if (!devfreq) {
0809         err = -ENOMEM;
0810         goto err_out;
0811     }
0812 
0813     mutex_init(&devfreq->lock);
0814     mutex_lock(&devfreq->lock);
0815     devfreq->dev.parent = dev;
0816     devfreq->dev.class = devfreq_class;
0817     devfreq->dev.release = devfreq_dev_release;
0818     INIT_LIST_HEAD(&devfreq->node);
0819     devfreq->profile = profile;
0820     devfreq->previous_freq = profile->initial_freq;
0821     devfreq->last_status.current_frequency = profile->initial_freq;
0822     devfreq->data = data;
0823     devfreq->nb.notifier_call = devfreq_notifier_call;
0824 
0825     if (devfreq->profile->timer < 0
0826         || devfreq->profile->timer >= DEVFREQ_TIMER_NUM) {
0827         mutex_unlock(&devfreq->lock);
0828         err = -EINVAL;
0829         goto err_dev;
0830     }
0831 
0832     if (!devfreq->profile->max_state || !devfreq->profile->freq_table) {
0833         mutex_unlock(&devfreq->lock);
0834         err = set_freq_table(devfreq);
0835         if (err < 0)
0836             goto err_dev;
0837         mutex_lock(&devfreq->lock);
0838     } else {
0839         devfreq->freq_table = devfreq->profile->freq_table;
0840         devfreq->max_state = devfreq->profile->max_state;
0841     }
0842 
0843     devfreq->scaling_min_freq = find_available_min_freq(devfreq);
0844     if (!devfreq->scaling_min_freq) {
0845         mutex_unlock(&devfreq->lock);
0846         err = -EINVAL;
0847         goto err_dev;
0848     }
0849 
0850     devfreq->scaling_max_freq = find_available_max_freq(devfreq);
0851     if (!devfreq->scaling_max_freq) {
0852         mutex_unlock(&devfreq->lock);
0853         err = -EINVAL;
0854         goto err_dev;
0855     }
0856 
0857     devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
0858 
0859     devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev);
0860     devfreq->opp_table = dev_pm_opp_get_opp_table(dev);
0861     if (IS_ERR(devfreq->opp_table))
0862         devfreq->opp_table = NULL;
0863 
0864     atomic_set(&devfreq->suspend_count, 0);
0865 
0866     dev_set_name(&devfreq->dev, "%s", dev_name(dev));
0867     err = device_register(&devfreq->dev);
0868     if (err) {
0869         mutex_unlock(&devfreq->lock);
0870         put_device(&devfreq->dev);
0871         goto err_out;
0872     }
0873 
0874     devfreq->stats.trans_table = devm_kzalloc(&devfreq->dev,
0875             array3_size(sizeof(unsigned int),
0876                     devfreq->max_state,
0877                     devfreq->max_state),
0878             GFP_KERNEL);
0879     if (!devfreq->stats.trans_table) {
0880         mutex_unlock(&devfreq->lock);
0881         err = -ENOMEM;
0882         goto err_devfreq;
0883     }
0884 
0885     devfreq->stats.time_in_state = devm_kcalloc(&devfreq->dev,
0886             devfreq->max_state,
0887             sizeof(*devfreq->stats.time_in_state),
0888             GFP_KERNEL);
0889     if (!devfreq->stats.time_in_state) {
0890         mutex_unlock(&devfreq->lock);
0891         err = -ENOMEM;
0892         goto err_devfreq;
0893     }
0894 
0895     devfreq->stats.total_trans = 0;
0896     devfreq->stats.last_update = get_jiffies_64();
0897 
0898     srcu_init_notifier_head(&devfreq->transition_notifier_list);
0899 
0900     mutex_unlock(&devfreq->lock);
0901 
0902     err = dev_pm_qos_add_request(dev, &devfreq->user_min_freq_req,
0903                      DEV_PM_QOS_MIN_FREQUENCY, 0);
0904     if (err < 0)
0905         goto err_devfreq;
0906     err = dev_pm_qos_add_request(dev, &devfreq->user_max_freq_req,
0907                      DEV_PM_QOS_MAX_FREQUENCY,
0908                      PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
0909     if (err < 0)
0910         goto err_devfreq;
0911 
0912     devfreq->nb_min.notifier_call = qos_min_notifier_call;
0913     err = dev_pm_qos_add_notifier(dev, &devfreq->nb_min,
0914                       DEV_PM_QOS_MIN_FREQUENCY);
0915     if (err)
0916         goto err_devfreq;
0917 
0918     devfreq->nb_max.notifier_call = qos_max_notifier_call;
0919     err = dev_pm_qos_add_notifier(dev, &devfreq->nb_max,
0920                       DEV_PM_QOS_MAX_FREQUENCY);
0921     if (err)
0922         goto err_devfreq;
0923 
0924     mutex_lock(&devfreq_list_lock);
0925 
0926     governor = try_then_request_governor(governor_name);
0927     if (IS_ERR(governor)) {
0928         dev_err(dev, "%s: Unable to find governor for the device\n",
0929             __func__);
0930         err = PTR_ERR(governor);
0931         goto err_init;
0932     }
0933 
0934     devfreq->governor = governor;
0935     err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
0936                         NULL);
0937     if (err) {
0938         dev_err_probe(dev, err,
0939             "%s: Unable to start governor for the device\n",
0940              __func__);
0941         goto err_init;
0942     }
0943     create_sysfs_files(devfreq, devfreq->governor);
0944 
0945     list_add(&devfreq->node, &devfreq_list);
0946 
0947     mutex_unlock(&devfreq_list_lock);
0948 
0949     if (devfreq->profile->is_cooling_device) {
0950         devfreq->cdev = devfreq_cooling_em_register(devfreq, NULL);
0951         if (IS_ERR(devfreq->cdev))
0952             devfreq->cdev = NULL;
0953     }
0954 
0955     return devfreq;
0956 
0957 err_init:
0958     mutex_unlock(&devfreq_list_lock);
0959 err_devfreq:
0960     devfreq_remove_device(devfreq);
0961     devfreq = NULL;
0962 err_dev:
0963     kfree(devfreq);
0964 err_out:
0965     return ERR_PTR(err);
0966 }
0967 EXPORT_SYMBOL(devfreq_add_device);
0968 
0969 /**
0970  * devfreq_remove_device() - Remove devfreq feature from a device.
0971  * @devfreq:    the devfreq instance to be removed
0972  *
0973  * The opposite of devfreq_add_device().
0974  */
0975 int devfreq_remove_device(struct devfreq *devfreq)
0976 {
0977     if (!devfreq)
0978         return -EINVAL;
0979 
0980     devfreq_cooling_unregister(devfreq->cdev);
0981 
0982     if (devfreq->governor) {
0983         devfreq->governor->event_handler(devfreq,
0984                          DEVFREQ_GOV_STOP, NULL);
0985         remove_sysfs_files(devfreq, devfreq->governor);
0986     }
0987 
0988     device_unregister(&devfreq->dev);
0989 
0990     return 0;
0991 }
0992 EXPORT_SYMBOL(devfreq_remove_device);
0993 
0994 static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
0995 {
0996     struct devfreq **r = res;
0997 
0998     if (WARN_ON(!r || !*r))
0999         return 0;
1000 
1001     return *r == data;
1002 }
1003 
1004 static void devm_devfreq_dev_release(struct device *dev, void *res)
1005 {
1006     devfreq_remove_device(*(struct devfreq **)res);
1007 }
1008 
1009 /**
1010  * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
1011  * @dev:    the device to add devfreq feature.
1012  * @profile:    device-specific profile to run devfreq.
1013  * @governor_name:  name of the policy to choose frequency.
1014  * @data:   private data for the governor. The devfreq framework does not
1015  *      touch this value.
1016  *
1017  * This function manages automatically the memory of devfreq device using device
1018  * resource management and simplify the free operation for memory of devfreq
1019  * device.
1020  */
1021 struct devfreq *devm_devfreq_add_device(struct device *dev,
1022                     struct devfreq_dev_profile *profile,
1023                     const char *governor_name,
1024                     void *data)
1025 {
1026     struct devfreq **ptr, *devfreq;
1027 
1028     ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
1029     if (!ptr)
1030         return ERR_PTR(-ENOMEM);
1031 
1032     devfreq = devfreq_add_device(dev, profile, governor_name, data);
1033     if (IS_ERR(devfreq)) {
1034         devres_free(ptr);
1035         return devfreq;
1036     }
1037 
1038     *ptr = devfreq;
1039     devres_add(dev, ptr);
1040 
1041     return devfreq;
1042 }
1043 EXPORT_SYMBOL(devm_devfreq_add_device);
1044 
1045 #ifdef CONFIG_OF
1046 /*
1047  * devfreq_get_devfreq_by_node - Get the devfreq device from devicetree
1048  * @node - pointer to device_node
1049  *
1050  * return the instance of devfreq device
1051  */
1052 struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1053 {
1054     struct devfreq *devfreq;
1055 
1056     if (!node)
1057         return ERR_PTR(-EINVAL);
1058 
1059     mutex_lock(&devfreq_list_lock);
1060     list_for_each_entry(devfreq, &devfreq_list, node) {
1061         if (devfreq->dev.parent
1062             && devfreq->dev.parent->of_node == node) {
1063             mutex_unlock(&devfreq_list_lock);
1064             return devfreq;
1065         }
1066     }
1067     mutex_unlock(&devfreq_list_lock);
1068 
1069     return ERR_PTR(-ENODEV);
1070 }
1071 
1072 /*
1073  * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
1074  * @dev - instance to the given device
1075  * @phandle_name - name of property holding a phandle value
1076  * @index - index into list of devfreq
1077  *
1078  * return the instance of devfreq device
1079  */
1080 struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev,
1081                     const char *phandle_name, int index)
1082 {
1083     struct device_node *node;
1084     struct devfreq *devfreq;
1085 
1086     if (!dev || !phandle_name)
1087         return ERR_PTR(-EINVAL);
1088 
1089     if (!dev->of_node)
1090         return ERR_PTR(-EINVAL);
1091 
1092     node = of_parse_phandle(dev->of_node, phandle_name, index);
1093     if (!node)
1094         return ERR_PTR(-ENODEV);
1095 
1096     devfreq = devfreq_get_devfreq_by_node(node);
1097     of_node_put(node);
1098 
1099     return devfreq;
1100 }
1101 
1102 #else
1103 struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1104 {
1105     return ERR_PTR(-ENODEV);
1106 }
1107 
1108 struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev,
1109                     const char *phandle_name, int index)
1110 {
1111     return ERR_PTR(-ENODEV);
1112 }
1113 #endif /* CONFIG_OF */
1114 EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_node);
1115 EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
1116 
1117 /**
1118  * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
1119  * @dev:    the device from which to remove devfreq feature.
1120  * @devfreq:    the devfreq instance to be removed
1121  */
1122 void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
1123 {
1124     WARN_ON(devres_release(dev, devm_devfreq_dev_release,
1125                    devm_devfreq_dev_match, devfreq));
1126 }
1127 EXPORT_SYMBOL(devm_devfreq_remove_device);
1128 
1129 /**
1130  * devfreq_suspend_device() - Suspend devfreq of a device.
1131  * @devfreq: the devfreq instance to be suspended
1132  *
1133  * This function is intended to be called by the pm callbacks
1134  * (e.g., runtime_suspend, suspend) of the device driver that
1135  * holds the devfreq.
1136  */
1137 int devfreq_suspend_device(struct devfreq *devfreq)
1138 {
1139     int ret;
1140 
1141     if (!devfreq)
1142         return -EINVAL;
1143 
1144     if (atomic_inc_return(&devfreq->suspend_count) > 1)
1145         return 0;
1146 
1147     if (devfreq->governor) {
1148         ret = devfreq->governor->event_handler(devfreq,
1149                     DEVFREQ_GOV_SUSPEND, NULL);
1150         if (ret)
1151             return ret;
1152     }
1153 
1154     if (devfreq->suspend_freq) {
1155         mutex_lock(&devfreq->lock);
1156         ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
1157         mutex_unlock(&devfreq->lock);
1158         if (ret)
1159             return ret;
1160     }
1161 
1162     return 0;
1163 }
1164 EXPORT_SYMBOL(devfreq_suspend_device);
1165 
1166 /**
1167  * devfreq_resume_device() - Resume devfreq of a device.
1168  * @devfreq: the devfreq instance to be resumed
1169  *
1170  * This function is intended to be called by the pm callbacks
1171  * (e.g., runtime_resume, resume) of the device driver that
1172  * holds the devfreq.
1173  */
1174 int devfreq_resume_device(struct devfreq *devfreq)
1175 {
1176     int ret;
1177 
1178     if (!devfreq)
1179         return -EINVAL;
1180 
1181     if (atomic_dec_return(&devfreq->suspend_count) >= 1)
1182         return 0;
1183 
1184     if (devfreq->resume_freq) {
1185         mutex_lock(&devfreq->lock);
1186         ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
1187         mutex_unlock(&devfreq->lock);
1188         if (ret)
1189             return ret;
1190     }
1191 
1192     if (devfreq->governor) {
1193         ret = devfreq->governor->event_handler(devfreq,
1194                     DEVFREQ_GOV_RESUME, NULL);
1195         if (ret)
1196             return ret;
1197     }
1198 
1199     return 0;
1200 }
1201 EXPORT_SYMBOL(devfreq_resume_device);
1202 
1203 /**
1204  * devfreq_suspend() - Suspend devfreq governors and devices
1205  *
1206  * Called during system wide Suspend/Hibernate cycles for suspending governors
1207  * and devices preserving the state for resume. On some platforms the devfreq
1208  * device must have precise state (frequency) after resume in order to provide
1209  * fully operating setup.
1210  */
1211 void devfreq_suspend(void)
1212 {
1213     struct devfreq *devfreq;
1214     int ret;
1215 
1216     mutex_lock(&devfreq_list_lock);
1217     list_for_each_entry(devfreq, &devfreq_list, node) {
1218         ret = devfreq_suspend_device(devfreq);
1219         if (ret)
1220             dev_err(&devfreq->dev,
1221                 "failed to suspend devfreq device\n");
1222     }
1223     mutex_unlock(&devfreq_list_lock);
1224 }
1225 
1226 /**
1227  * devfreq_resume() - Resume devfreq governors and devices
1228  *
1229  * Called during system wide Suspend/Hibernate cycle for resuming governors and
1230  * devices that are suspended with devfreq_suspend().
1231  */
1232 void devfreq_resume(void)
1233 {
1234     struct devfreq *devfreq;
1235     int ret;
1236 
1237     mutex_lock(&devfreq_list_lock);
1238     list_for_each_entry(devfreq, &devfreq_list, node) {
1239         ret = devfreq_resume_device(devfreq);
1240         if (ret)
1241             dev_warn(&devfreq->dev,
1242                  "failed to resume devfreq device\n");
1243     }
1244     mutex_unlock(&devfreq_list_lock);
1245 }
1246 
1247 /**
1248  * devfreq_add_governor() - Add devfreq governor
1249  * @governor:   the devfreq governor to be added
1250  */
1251 int devfreq_add_governor(struct devfreq_governor *governor)
1252 {
1253     struct devfreq_governor *g;
1254     struct devfreq *devfreq;
1255     int err = 0;
1256 
1257     if (!governor) {
1258         pr_err("%s: Invalid parameters.\n", __func__);
1259         return -EINVAL;
1260     }
1261 
1262     mutex_lock(&devfreq_list_lock);
1263     g = find_devfreq_governor(governor->name);
1264     if (!IS_ERR(g)) {
1265         pr_err("%s: governor %s already registered\n", __func__,
1266                g->name);
1267         err = -EINVAL;
1268         goto err_out;
1269     }
1270 
1271     list_add(&governor->node, &devfreq_governor_list);
1272 
1273     list_for_each_entry(devfreq, &devfreq_list, node) {
1274         int ret = 0;
1275         struct device *dev = devfreq->dev.parent;
1276 
1277         if (!strncmp(devfreq->governor->name, governor->name,
1278                  DEVFREQ_NAME_LEN)) {
1279             /* The following should never occur */
1280             if (devfreq->governor) {
1281                 dev_warn(dev,
1282                      "%s: Governor %s already present\n",
1283                      __func__, devfreq->governor->name);
1284                 ret = devfreq->governor->event_handler(devfreq,
1285                             DEVFREQ_GOV_STOP, NULL);
1286                 if (ret) {
1287                     dev_warn(dev,
1288                          "%s: Governor %s stop = %d\n",
1289                          __func__,
1290                          devfreq->governor->name, ret);
1291                 }
1292                 /* Fall through */
1293             }
1294             devfreq->governor = governor;
1295             ret = devfreq->governor->event_handler(devfreq,
1296                         DEVFREQ_GOV_START, NULL);
1297             if (ret) {
1298                 dev_warn(dev, "%s: Governor %s start=%d\n",
1299                      __func__, devfreq->governor->name,
1300                      ret);
1301             }
1302         }
1303     }
1304 
1305 err_out:
1306     mutex_unlock(&devfreq_list_lock);
1307 
1308     return err;
1309 }
1310 EXPORT_SYMBOL(devfreq_add_governor);
1311 
1312 static void devm_devfreq_remove_governor(void *governor)
1313 {
1314     WARN_ON(devfreq_remove_governor(governor));
1315 }
1316 
1317 /**
1318  * devm_devfreq_add_governor() - Add devfreq governor
1319  * @dev:    device which adds devfreq governor
1320  * @governor:   the devfreq governor to be added
1321  *
1322  * This is a resource-managed variant of devfreq_add_governor().
1323  */
1324 int devm_devfreq_add_governor(struct device *dev,
1325                   struct devfreq_governor *governor)
1326 {
1327     int err;
1328 
1329     err = devfreq_add_governor(governor);
1330     if (err)
1331         return err;
1332 
1333     return devm_add_action_or_reset(dev, devm_devfreq_remove_governor,
1334                     governor);
1335 }
1336 EXPORT_SYMBOL(devm_devfreq_add_governor);
1337 
1338 /**
1339  * devfreq_remove_governor() - Remove devfreq feature from a device.
1340  * @governor:   the devfreq governor to be removed
1341  */
1342 int devfreq_remove_governor(struct devfreq_governor *governor)
1343 {
1344     struct devfreq_governor *g;
1345     struct devfreq *devfreq;
1346     int err = 0;
1347 
1348     if (!governor) {
1349         pr_err("%s: Invalid parameters.\n", __func__);
1350         return -EINVAL;
1351     }
1352 
1353     mutex_lock(&devfreq_list_lock);
1354     g = find_devfreq_governor(governor->name);
1355     if (IS_ERR(g)) {
1356         pr_err("%s: governor %s not registered\n", __func__,
1357                governor->name);
1358         err = PTR_ERR(g);
1359         goto err_out;
1360     }
1361     list_for_each_entry(devfreq, &devfreq_list, node) {
1362         int ret;
1363         struct device *dev = devfreq->dev.parent;
1364 
1365         if (!strncmp(devfreq->governor->name, governor->name,
1366                  DEVFREQ_NAME_LEN)) {
1367             /* we should have a devfreq governor! */
1368             if (!devfreq->governor) {
1369                 dev_warn(dev, "%s: Governor %s NOT present\n",
1370                      __func__, governor->name);
1371                 continue;
1372                 /* Fall through */
1373             }
1374             ret = devfreq->governor->event_handler(devfreq,
1375                         DEVFREQ_GOV_STOP, NULL);
1376             if (ret) {
1377                 dev_warn(dev, "%s: Governor %s stop=%d\n",
1378                      __func__, devfreq->governor->name,
1379                      ret);
1380             }
1381             devfreq->governor = NULL;
1382         }
1383     }
1384 
1385     list_del(&governor->node);
1386 err_out:
1387     mutex_unlock(&devfreq_list_lock);
1388 
1389     return err;
1390 }
1391 EXPORT_SYMBOL(devfreq_remove_governor);
1392 
1393 static ssize_t name_show(struct device *dev,
1394             struct device_attribute *attr, char *buf)
1395 {
1396     struct devfreq *df = to_devfreq(dev);
1397     return sprintf(buf, "%s\n", dev_name(df->dev.parent));
1398 }
1399 static DEVICE_ATTR_RO(name);
1400 
1401 static ssize_t governor_show(struct device *dev,
1402                  struct device_attribute *attr, char *buf)
1403 {
1404     struct devfreq *df = to_devfreq(dev);
1405 
1406     if (!df->governor)
1407         return -EINVAL;
1408 
1409     return sprintf(buf, "%s\n", df->governor->name);
1410 }
1411 
1412 static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
1413                   const char *buf, size_t count)
1414 {
1415     struct devfreq *df = to_devfreq(dev);
1416     int ret;
1417     char str_governor[DEVFREQ_NAME_LEN + 1];
1418     const struct devfreq_governor *governor, *prev_governor;
1419 
1420     if (!df->governor)
1421         return -EINVAL;
1422 
1423     ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
1424     if (ret != 1)
1425         return -EINVAL;
1426 
1427     mutex_lock(&devfreq_list_lock);
1428     governor = try_then_request_governor(str_governor);
1429     if (IS_ERR(governor)) {
1430         ret = PTR_ERR(governor);
1431         goto out;
1432     }
1433     if (df->governor == governor) {
1434         ret = 0;
1435         goto out;
1436     } else if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE)
1437         || IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE)) {
1438         ret = -EINVAL;
1439         goto out;
1440     }
1441 
1442     /*
1443      * Stop the current governor and remove the specific sysfs files
1444      * which depend on current governor.
1445      */
1446     ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1447     if (ret) {
1448         dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1449              __func__, df->governor->name, ret);
1450         goto out;
1451     }
1452     remove_sysfs_files(df, df->governor);
1453 
1454     /*
1455      * Start the new governor and create the specific sysfs files
1456      * which depend on the new governor.
1457      */
1458     prev_governor = df->governor;
1459     df->governor = governor;
1460     ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1461     if (ret) {
1462         dev_warn(dev, "%s: Governor %s not started(%d)\n",
1463              __func__, df->governor->name, ret);
1464 
1465         /* Restore previous governor */
1466         df->governor = prev_governor;
1467         ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1468         if (ret) {
1469             dev_err(dev,
1470                 "%s: reverting to Governor %s failed (%d)\n",
1471                 __func__, prev_governor->name, ret);
1472             df->governor = NULL;
1473             goto out;
1474         }
1475     }
1476 
1477     /*
1478      * Create the sysfs files for the new governor. But if failed to start
1479      * the new governor, restore the sysfs files of previous governor.
1480      */
1481     create_sysfs_files(df, df->governor);
1482 
1483 out:
1484     mutex_unlock(&devfreq_list_lock);
1485 
1486     if (!ret)
1487         ret = count;
1488     return ret;
1489 }
1490 static DEVICE_ATTR_RW(governor);
1491 
1492 static ssize_t available_governors_show(struct device *d,
1493                     struct device_attribute *attr,
1494                     char *buf)
1495 {
1496     struct devfreq *df = to_devfreq(d);
1497     ssize_t count = 0;
1498 
1499     if (!df->governor)
1500         return -EINVAL;
1501 
1502     mutex_lock(&devfreq_list_lock);
1503 
1504     /*
1505      * The devfreq with immutable governor (e.g., passive) shows
1506      * only own governor.
1507      */
1508     if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE)) {
1509         count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
1510                   "%s ", df->governor->name);
1511     /*
1512      * The devfreq device shows the registered governor except for
1513      * immutable governors such as passive governor .
1514      */
1515     } else {
1516         struct devfreq_governor *governor;
1517 
1518         list_for_each_entry(governor, &devfreq_governor_list, node) {
1519             if (IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE))
1520                 continue;
1521             count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1522                        "%s ", governor->name);
1523         }
1524     }
1525 
1526     mutex_unlock(&devfreq_list_lock);
1527 
1528     /* Truncate the trailing space */
1529     if (count)
1530         count--;
1531 
1532     count += sprintf(&buf[count], "\n");
1533 
1534     return count;
1535 }
1536 static DEVICE_ATTR_RO(available_governors);
1537 
1538 static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr,
1539                  char *buf)
1540 {
1541     unsigned long freq;
1542     struct devfreq *df = to_devfreq(dev);
1543 
1544     if (!df->profile)
1545         return -EINVAL;
1546 
1547     if (df->profile->get_cur_freq &&
1548         !df->profile->get_cur_freq(df->dev.parent, &freq))
1549         return sprintf(buf, "%lu\n", freq);
1550 
1551     return sprintf(buf, "%lu\n", df->previous_freq);
1552 }
1553 static DEVICE_ATTR_RO(cur_freq);
1554 
1555 static ssize_t target_freq_show(struct device *dev,
1556                 struct device_attribute *attr, char *buf)
1557 {
1558     struct devfreq *df = to_devfreq(dev);
1559 
1560     return sprintf(buf, "%lu\n", df->previous_freq);
1561 }
1562 static DEVICE_ATTR_RO(target_freq);
1563 
1564 static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
1565                   const char *buf, size_t count)
1566 {
1567     struct devfreq *df = to_devfreq(dev);
1568     unsigned long value;
1569     int ret;
1570 
1571     /*
1572      * Protect against theoretical sysfs writes between
1573      * device_add and dev_pm_qos_add_request
1574      */
1575     if (!dev_pm_qos_request_active(&df->user_min_freq_req))
1576         return -EAGAIN;
1577 
1578     ret = sscanf(buf, "%lu", &value);
1579     if (ret != 1)
1580         return -EINVAL;
1581 
1582     /* Round down to kHz for PM QoS */
1583     ret = dev_pm_qos_update_request(&df->user_min_freq_req,
1584                     value / HZ_PER_KHZ);
1585     if (ret < 0)
1586         return ret;
1587 
1588     return count;
1589 }
1590 
1591 static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr,
1592                  char *buf)
1593 {
1594     struct devfreq *df = to_devfreq(dev);
1595     unsigned long min_freq, max_freq;
1596 
1597     mutex_lock(&df->lock);
1598     devfreq_get_freq_range(df, &min_freq, &max_freq);
1599     mutex_unlock(&df->lock);
1600 
1601     return sprintf(buf, "%lu\n", min_freq);
1602 }
1603 static DEVICE_ATTR_RW(min_freq);
1604 
1605 static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
1606                   const char *buf, size_t count)
1607 {
1608     struct devfreq *df = to_devfreq(dev);
1609     unsigned long value;
1610     int ret;
1611 
1612     /*
1613      * Protect against theoretical sysfs writes between
1614      * device_add and dev_pm_qos_add_request
1615      */
1616     if (!dev_pm_qos_request_active(&df->user_max_freq_req))
1617         return -EINVAL;
1618 
1619     ret = sscanf(buf, "%lu", &value);
1620     if (ret != 1)
1621         return -EINVAL;
1622 
1623     /*
1624      * PM QoS frequencies are in kHz so we need to convert. Convert by
1625      * rounding upwards so that the acceptable interval never shrinks.
1626      *
1627      * For example if the user writes "666666666" to sysfs this value will
1628      * be converted to 666667 kHz and back to 666667000 Hz before an OPP
1629      * lookup, this ensures that an OPP of 666666666Hz is still accepted.
1630      *
1631      * A value of zero means "no limit".
1632      */
1633     if (value)
1634         value = DIV_ROUND_UP(value, HZ_PER_KHZ);
1635     else
1636         value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;
1637 
1638     ret = dev_pm_qos_update_request(&df->user_max_freq_req, value);
1639     if (ret < 0)
1640         return ret;
1641 
1642     return count;
1643 }
1644 
1645 static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr,
1646                  char *buf)
1647 {
1648     struct devfreq *df = to_devfreq(dev);
1649     unsigned long min_freq, max_freq;
1650 
1651     mutex_lock(&df->lock);
1652     devfreq_get_freq_range(df, &min_freq, &max_freq);
1653     mutex_unlock(&df->lock);
1654 
1655     return sprintf(buf, "%lu\n", max_freq);
1656 }
1657 static DEVICE_ATTR_RW(max_freq);
1658 
1659 static ssize_t available_frequencies_show(struct device *d,
1660                       struct device_attribute *attr,
1661                       char *buf)
1662 {
1663     struct devfreq *df = to_devfreq(d);
1664     ssize_t count = 0;
1665     int i;
1666 
1667     if (!df->profile)
1668         return -EINVAL;
1669 
1670     mutex_lock(&df->lock);
1671 
1672     for (i = 0; i < df->max_state; i++)
1673         count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1674                 "%lu ", df->freq_table[i]);
1675 
1676     mutex_unlock(&df->lock);
1677     /* Truncate the trailing space */
1678     if (count)
1679         count--;
1680 
1681     count += sprintf(&buf[count], "\n");
1682 
1683     return count;
1684 }
1685 static DEVICE_ATTR_RO(available_frequencies);
1686 
1687 static ssize_t trans_stat_show(struct device *dev,
1688                    struct device_attribute *attr, char *buf)
1689 {
1690     struct devfreq *df = to_devfreq(dev);
1691     ssize_t len;
1692     int i, j;
1693     unsigned int max_state;
1694 
1695     if (!df->profile)
1696         return -EINVAL;
1697     max_state = df->max_state;
1698 
1699     if (max_state == 0)
1700         return sprintf(buf, "Not Supported.\n");
1701 
1702     mutex_lock(&df->lock);
1703     if (!df->stop_polling &&
1704             devfreq_update_status(df, df->previous_freq)) {
1705         mutex_unlock(&df->lock);
1706         return 0;
1707     }
1708     mutex_unlock(&df->lock);
1709 
1710     len = sprintf(buf, "     From  :   To\n");
1711     len += sprintf(buf + len, "           :");
1712     for (i = 0; i < max_state; i++)
1713         len += sprintf(buf + len, "%10lu",
1714                 df->freq_table[i]);
1715 
1716     len += sprintf(buf + len, "   time(ms)\n");
1717 
1718     for (i = 0; i < max_state; i++) {
1719         if (df->freq_table[i] == df->previous_freq)
1720             len += sprintf(buf + len, "*");
1721         else
1722             len += sprintf(buf + len, " ");
1723 
1724         len += sprintf(buf + len, "%10lu:", df->freq_table[i]);
1725         for (j = 0; j < max_state; j++)
1726             len += sprintf(buf + len, "%10u",
1727                 df->stats.trans_table[(i * max_state) + j]);
1728 
1729         len += sprintf(buf + len, "%10llu\n", (u64)
1730             jiffies64_to_msecs(df->stats.time_in_state[i]));
1731     }
1732 
1733     len += sprintf(buf + len, "Total transition : %u\n",
1734                     df->stats.total_trans);
1735     return len;
1736 }
1737 
1738 static ssize_t trans_stat_store(struct device *dev,
1739                 struct device_attribute *attr,
1740                 const char *buf, size_t count)
1741 {
1742     struct devfreq *df = to_devfreq(dev);
1743     int err, value;
1744 
1745     if (!df->profile)
1746         return -EINVAL;
1747 
1748     if (df->max_state == 0)
1749         return count;
1750 
1751     err = kstrtoint(buf, 10, &value);
1752     if (err || value != 0)
1753         return -EINVAL;
1754 
1755     mutex_lock(&df->lock);
1756     memset(df->stats.time_in_state, 0, (df->max_state *
1757                     sizeof(*df->stats.time_in_state)));
1758     memset(df->stats.trans_table, 0, array3_size(sizeof(unsigned int),
1759                     df->max_state,
1760                     df->max_state));
1761     df->stats.total_trans = 0;
1762     df->stats.last_update = get_jiffies_64();
1763     mutex_unlock(&df->lock);
1764 
1765     return count;
1766 }
1767 static DEVICE_ATTR_RW(trans_stat);
1768 
1769 static struct attribute *devfreq_attrs[] = {
1770     &dev_attr_name.attr,
1771     &dev_attr_governor.attr,
1772     &dev_attr_available_governors.attr,
1773     &dev_attr_cur_freq.attr,
1774     &dev_attr_available_frequencies.attr,
1775     &dev_attr_target_freq.attr,
1776     &dev_attr_min_freq.attr,
1777     &dev_attr_max_freq.attr,
1778     &dev_attr_trans_stat.attr,
1779     NULL,
1780 };
1781 ATTRIBUTE_GROUPS(devfreq);
1782 
1783 static ssize_t polling_interval_show(struct device *dev,
1784                      struct device_attribute *attr, char *buf)
1785 {
1786     struct devfreq *df = to_devfreq(dev);
1787 
1788     if (!df->profile)
1789         return -EINVAL;
1790 
1791     return sprintf(buf, "%d\n", df->profile->polling_ms);
1792 }
1793 
1794 static ssize_t polling_interval_store(struct device *dev,
1795                       struct device_attribute *attr,
1796                       const char *buf, size_t count)
1797 {
1798     struct devfreq *df = to_devfreq(dev);
1799     unsigned int value;
1800     int ret;
1801 
1802     if (!df->governor)
1803         return -EINVAL;
1804 
1805     ret = sscanf(buf, "%u", &value);
1806     if (ret != 1)
1807         return -EINVAL;
1808 
1809     df->governor->event_handler(df, DEVFREQ_GOV_UPDATE_INTERVAL, &value);
1810     ret = count;
1811 
1812     return ret;
1813 }
1814 static DEVICE_ATTR_RW(polling_interval);
1815 
1816 static ssize_t timer_show(struct device *dev,
1817                  struct device_attribute *attr, char *buf)
1818 {
1819     struct devfreq *df = to_devfreq(dev);
1820 
1821     if (!df->profile)
1822         return -EINVAL;
1823 
1824     return sprintf(buf, "%s\n", timer_name[df->profile->timer]);
1825 }
1826 
1827 static ssize_t timer_store(struct device *dev, struct device_attribute *attr,
1828                   const char *buf, size_t count)
1829 {
1830     struct devfreq *df = to_devfreq(dev);
1831     char str_timer[DEVFREQ_NAME_LEN + 1];
1832     int timer = -1;
1833     int ret = 0, i;
1834 
1835     if (!df->governor || !df->profile)
1836         return -EINVAL;
1837 
1838     ret = sscanf(buf, "%16s", str_timer);
1839     if (ret != 1)
1840         return -EINVAL;
1841 
1842     for (i = 0; i < DEVFREQ_TIMER_NUM; i++) {
1843         if (!strncmp(timer_name[i], str_timer, DEVFREQ_NAME_LEN)) {
1844             timer = i;
1845             break;
1846         }
1847     }
1848 
1849     if (timer < 0) {
1850         ret = -EINVAL;
1851         goto out;
1852     }
1853 
1854     if (df->profile->timer == timer) {
1855         ret = 0;
1856         goto out;
1857     }
1858 
1859     mutex_lock(&df->lock);
1860     df->profile->timer = timer;
1861     mutex_unlock(&df->lock);
1862 
1863     ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1864     if (ret) {
1865         dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1866              __func__, df->governor->name, ret);
1867         goto out;
1868     }
1869 
1870     ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1871     if (ret)
1872         dev_warn(dev, "%s: Governor %s not started(%d)\n",
1873              __func__, df->governor->name, ret);
1874 out:
1875     return ret ? ret : count;
1876 }
1877 static DEVICE_ATTR_RW(timer);
1878 
1879 #define CREATE_SYSFS_FILE(df, name)                 \
1880 {                                   \
1881     int ret;                            \
1882     ret = sysfs_create_file(&df->dev.kobj, &dev_attr_##name.attr);  \
1883     if (ret < 0) {                          \
1884         dev_warn(&df->dev,                  \
1885             "Unable to create attr(%s)\n", "##name");   \
1886     }                               \
1887 }                                   \
1888 
1889 /* Create the specific sysfs files which depend on each governor. */
1890 static void create_sysfs_files(struct devfreq *devfreq,
1891                 const struct devfreq_governor *gov)
1892 {
1893     if (IS_SUPPORTED_ATTR(gov->attrs, POLLING_INTERVAL))
1894         CREATE_SYSFS_FILE(devfreq, polling_interval);
1895     if (IS_SUPPORTED_ATTR(gov->attrs, TIMER))
1896         CREATE_SYSFS_FILE(devfreq, timer);
1897 }
1898 
1899 /* Remove the specific sysfs files which depend on each governor. */
1900 static void remove_sysfs_files(struct devfreq *devfreq,
1901                 const struct devfreq_governor *gov)
1902 {
1903     if (IS_SUPPORTED_ATTR(gov->attrs, POLLING_INTERVAL))
1904         sysfs_remove_file(&devfreq->dev.kobj,
1905                 &dev_attr_polling_interval.attr);
1906     if (IS_SUPPORTED_ATTR(gov->attrs, TIMER))
1907         sysfs_remove_file(&devfreq->dev.kobj, &dev_attr_timer.attr);
1908 }
1909 
1910 /**
1911  * devfreq_summary_show() - Show the summary of the devfreq devices
1912  * @s:      seq_file instance to show the summary of devfreq devices
1913  * @data:   not used
1914  *
1915  * Show the summary of the devfreq devices via 'devfreq_summary' debugfs file.
1916  * It helps that user can know the detailed information of the devfreq devices.
1917  *
1918  * Return 0 always because it shows the information without any data change.
1919  */
1920 static int devfreq_summary_show(struct seq_file *s, void *data)
1921 {
1922     struct devfreq *devfreq;
1923     struct devfreq *p_devfreq = NULL;
1924     unsigned long cur_freq, min_freq, max_freq;
1925     unsigned int polling_ms;
1926     unsigned int timer;
1927 
1928     seq_printf(s, "%-30s %-30s %-15s %-10s %10s %12s %12s %12s\n",
1929             "dev",
1930             "parent_dev",
1931             "governor",
1932             "timer",
1933             "polling_ms",
1934             "cur_freq_Hz",
1935             "min_freq_Hz",
1936             "max_freq_Hz");
1937     seq_printf(s, "%30s %30s %15s %10s %10s %12s %12s %12s\n",
1938             "------------------------------",
1939             "------------------------------",
1940             "---------------",
1941             "----------",
1942             "----------",
1943             "------------",
1944             "------------",
1945             "------------");
1946 
1947     mutex_lock(&devfreq_list_lock);
1948 
1949     list_for_each_entry_reverse(devfreq, &devfreq_list, node) {
1950 #if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE)
1951         if (!strncmp(devfreq->governor->name, DEVFREQ_GOV_PASSIVE,
1952                             DEVFREQ_NAME_LEN)) {
1953             struct devfreq_passive_data *data = devfreq->data;
1954 
1955             if (data)
1956                 p_devfreq = data->parent;
1957         } else {
1958             p_devfreq = NULL;
1959         }
1960 #endif
1961 
1962         mutex_lock(&devfreq->lock);
1963         cur_freq = devfreq->previous_freq;
1964         devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
1965         timer = devfreq->profile->timer;
1966 
1967         if (IS_SUPPORTED_ATTR(devfreq->governor->attrs, POLLING_INTERVAL))
1968             polling_ms = devfreq->profile->polling_ms;
1969         else
1970             polling_ms = 0;
1971         mutex_unlock(&devfreq->lock);
1972 
1973         seq_printf(s,
1974             "%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n",
1975             dev_name(&devfreq->dev),
1976             p_devfreq ? dev_name(&p_devfreq->dev) : "null",
1977             devfreq->governor->name,
1978             polling_ms ? timer_name[timer] : "null",
1979             polling_ms,
1980             cur_freq,
1981             min_freq,
1982             max_freq);
1983     }
1984 
1985     mutex_unlock(&devfreq_list_lock);
1986 
1987     return 0;
1988 }
1989 DEFINE_SHOW_ATTRIBUTE(devfreq_summary);
1990 
1991 static int __init devfreq_init(void)
1992 {
1993     devfreq_class = class_create(THIS_MODULE, "devfreq");
1994     if (IS_ERR(devfreq_class)) {
1995         pr_err("%s: couldn't create class\n", __FILE__);
1996         return PTR_ERR(devfreq_class);
1997     }
1998 
1999     devfreq_wq = create_freezable_workqueue("devfreq_wq");
2000     if (!devfreq_wq) {
2001         class_destroy(devfreq_class);
2002         pr_err("%s: couldn't create workqueue\n", __FILE__);
2003         return -ENOMEM;
2004     }
2005     devfreq_class->dev_groups = devfreq_groups;
2006 
2007     devfreq_debugfs = debugfs_create_dir("devfreq", NULL);
2008     debugfs_create_file("devfreq_summary", 0444,
2009                 devfreq_debugfs, NULL,
2010                 &devfreq_summary_fops);
2011 
2012     return 0;
2013 }
2014 subsys_initcall(devfreq_init);
2015 
2016 /*
2017  * The following are helper functions for devfreq user device drivers with
2018  * OPP framework.
2019  */
2020 
2021 /**
2022  * devfreq_recommended_opp() - Helper function to get proper OPP for the
2023  *               freq value given to target callback.
2024  * @dev:    The devfreq user device. (parent of devfreq)
2025  * @freq:   The frequency given to target function
2026  * @flags:  Flags handed from devfreq framework.
2027  *
2028  * The callers are required to call dev_pm_opp_put() for the returned OPP after
2029  * use.
2030  */
2031 struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
2032                        unsigned long *freq,
2033                        u32 flags)
2034 {
2035     struct dev_pm_opp *opp;
2036 
2037     if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
2038         /* The freq is an upper bound. opp should be lower */
2039         opp = dev_pm_opp_find_freq_floor(dev, freq);
2040 
2041         /* If not available, use the closest opp */
2042         if (opp == ERR_PTR(-ERANGE))
2043             opp = dev_pm_opp_find_freq_ceil(dev, freq);
2044     } else {
2045         /* The freq is an lower bound. opp should be higher */
2046         opp = dev_pm_opp_find_freq_ceil(dev, freq);
2047 
2048         /* If not available, use the closest opp */
2049         if (opp == ERR_PTR(-ERANGE))
2050             opp = dev_pm_opp_find_freq_floor(dev, freq);
2051     }
2052 
2053     return opp;
2054 }
2055 EXPORT_SYMBOL(devfreq_recommended_opp);
2056 
2057 /**
2058  * devfreq_register_opp_notifier() - Helper function to get devfreq notified
2059  *                   for any changes in the OPP availability
2060  *                   changes
2061  * @dev:    The devfreq user device. (parent of devfreq)
2062  * @devfreq:    The devfreq object.
2063  */
2064 int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
2065 {
2066     return dev_pm_opp_register_notifier(dev, &devfreq->nb);
2067 }
2068 EXPORT_SYMBOL(devfreq_register_opp_notifier);
2069 
2070 /**
2071  * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
2072  *                     notified for any changes in the OPP
2073  *                     availability changes anymore.
2074  * @dev:    The devfreq user device. (parent of devfreq)
2075  * @devfreq:    The devfreq object.
2076  *
2077  * At exit() callback of devfreq_dev_profile, this must be included if
2078  * devfreq_recommended_opp is used.
2079  */
2080 int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
2081 {
2082     return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
2083 }
2084 EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
2085 
2086 static void devm_devfreq_opp_release(struct device *dev, void *res)
2087 {
2088     devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
2089 }
2090 
2091 /**
2092  * devm_devfreq_register_opp_notifier() - Resource-managed
2093  *                    devfreq_register_opp_notifier()
2094  * @dev:    The devfreq user device. (parent of devfreq)
2095  * @devfreq:    The devfreq object.
2096  */
2097 int devm_devfreq_register_opp_notifier(struct device *dev,
2098                        struct devfreq *devfreq)
2099 {
2100     struct devfreq **ptr;
2101     int ret;
2102 
2103     ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
2104     if (!ptr)
2105         return -ENOMEM;
2106 
2107     ret = devfreq_register_opp_notifier(dev, devfreq);
2108     if (ret) {
2109         devres_free(ptr);
2110         return ret;
2111     }
2112 
2113     *ptr = devfreq;
2114     devres_add(dev, ptr);
2115 
2116     return 0;
2117 }
2118 EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
2119 
2120 /**
2121  * devm_devfreq_unregister_opp_notifier() - Resource-managed
2122  *                      devfreq_unregister_opp_notifier()
2123  * @dev:    The devfreq user device. (parent of devfreq)
2124  * @devfreq:    The devfreq object.
2125  */
2126 void devm_devfreq_unregister_opp_notifier(struct device *dev,
2127                      struct devfreq *devfreq)
2128 {
2129     WARN_ON(devres_release(dev, devm_devfreq_opp_release,
2130                    devm_devfreq_dev_match, devfreq));
2131 }
2132 EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
2133 
2134 /**
2135  * devfreq_register_notifier() - Register a driver with devfreq
2136  * @devfreq:    The devfreq object.
2137  * @nb:     The notifier block to register.
2138  * @list:   DEVFREQ_TRANSITION_NOTIFIER.
2139  */
2140 int devfreq_register_notifier(struct devfreq *devfreq,
2141                   struct notifier_block *nb,
2142                   unsigned int list)
2143 {
2144     int ret = 0;
2145 
2146     if (!devfreq)
2147         return -EINVAL;
2148 
2149     switch (list) {
2150     case DEVFREQ_TRANSITION_NOTIFIER:
2151         ret = srcu_notifier_chain_register(
2152                 &devfreq->transition_notifier_list, nb);
2153         break;
2154     default:
2155         ret = -EINVAL;
2156     }
2157 
2158     return ret;
2159 }
2160 EXPORT_SYMBOL(devfreq_register_notifier);
2161 
2162 /*
2163  * devfreq_unregister_notifier() - Unregister a driver with devfreq
2164  * @devfreq:    The devfreq object.
2165  * @nb:     The notifier block to be unregistered.
2166  * @list:   DEVFREQ_TRANSITION_NOTIFIER.
2167  */
2168 int devfreq_unregister_notifier(struct devfreq *devfreq,
2169                 struct notifier_block *nb,
2170                 unsigned int list)
2171 {
2172     int ret = 0;
2173 
2174     if (!devfreq)
2175         return -EINVAL;
2176 
2177     switch (list) {
2178     case DEVFREQ_TRANSITION_NOTIFIER:
2179         ret = srcu_notifier_chain_unregister(
2180                 &devfreq->transition_notifier_list, nb);
2181         break;
2182     default:
2183         ret = -EINVAL;
2184     }
2185 
2186     return ret;
2187 }
2188 EXPORT_SYMBOL(devfreq_unregister_notifier);
2189 
2190 struct devfreq_notifier_devres {
2191     struct devfreq *devfreq;
2192     struct notifier_block *nb;
2193     unsigned int list;
2194 };
2195 
2196 static void devm_devfreq_notifier_release(struct device *dev, void *res)
2197 {
2198     struct devfreq_notifier_devres *this = res;
2199 
2200     devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
2201 }
2202 
2203 /**
2204  * devm_devfreq_register_notifier()
2205  *  - Resource-managed devfreq_register_notifier()
2206  * @dev:    The devfreq user device. (parent of devfreq)
2207  * @devfreq:    The devfreq object.
2208  * @nb:     The notifier block to be unregistered.
2209  * @list:   DEVFREQ_TRANSITION_NOTIFIER.
2210  */
2211 int devm_devfreq_register_notifier(struct device *dev,
2212                 struct devfreq *devfreq,
2213                 struct notifier_block *nb,
2214                 unsigned int list)
2215 {
2216     struct devfreq_notifier_devres *ptr;
2217     int ret;
2218 
2219     ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
2220                 GFP_KERNEL);
2221     if (!ptr)
2222         return -ENOMEM;
2223 
2224     ret = devfreq_register_notifier(devfreq, nb, list);
2225     if (ret) {
2226         devres_free(ptr);
2227         return ret;
2228     }
2229 
2230     ptr->devfreq = devfreq;
2231     ptr->nb = nb;
2232     ptr->list = list;
2233     devres_add(dev, ptr);
2234 
2235     return 0;
2236 }
2237 EXPORT_SYMBOL(devm_devfreq_register_notifier);
2238 
2239 /**
2240  * devm_devfreq_unregister_notifier()
2241  *  - Resource-managed devfreq_unregister_notifier()
2242  * @dev:    The devfreq user device. (parent of devfreq)
2243  * @devfreq:    The devfreq object.
2244  * @nb:     The notifier block to be unregistered.
2245  * @list:   DEVFREQ_TRANSITION_NOTIFIER.
2246  */
2247 void devm_devfreq_unregister_notifier(struct device *dev,
2248                       struct devfreq *devfreq,
2249                       struct notifier_block *nb,
2250                       unsigned int list)
2251 {
2252     WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
2253                    devm_devfreq_dev_match, devfreq));
2254 }
2255 EXPORT_SYMBOL(devm_devfreq_unregister_notifier);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!