drivers/cpufreq/cpufreq_opp.c

   1 /*
   2  * Generic OPP helper interface for CPUFreq drivers
   3  *
   4  * Copyright (C) 2009-2014 Texas Instruments Incorporated.
   5  *      Nishanth Menon
   6  *      Romit Dasgupta
   7  *      Kevin Hilman
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13 #include <linux/cpufreq.h>
  14 #include <linux/device.h>
  15 #include <linux/err.h>
  16 #include <linux/errno.h>
  17 #include <linux/export.h>
  18 #include <linux/kernel.h>
  19 #include <linux/pm_opp.h>
  20 #include <linux/rcupdate.h>
  21 #include <linux/slab.h>
  22
  23 /**
  24  * dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
  25  * @dev:        device for which we do this operation
  26  * @table:      Cpufreq table returned back to caller
  27  *
  28  * Generate a cpufreq table for a provided device- this assumes that the
  29  * opp list is already initialized and ready for usage.
  30  *
  31  * This function allocates required memory for the cpufreq table. It is
  32  * expected that the caller does the required maintenance such as freeing
  33  * the table as required.
  34  *
  35  * Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
  36  * if no memory available for the operation (table is not populated), returns 0
  37  * if successful and table is populated.
  38  *
  39  * WARNING: It is  important for the callers to ensure refreshing their copy of
  40  * the table if any of the mentioned functions have been invoked in the interim.
  41  *
  42  * Locking: The internal device_opp and opp structures are RCU protected.
  43  * Since we just use the regular accessor functions to access the internal data
  44  * structures, we use RCU read lock inside this function. As a result, users of
  45  * this function DONOT need to use explicit locks for invoking.
  46  */
  47 int dev_pm_opp_init_cpufreq_table(struct device *dev,
  48                                   struct cpufreq_frequency_table **table)
  49 {
  50         struct dev_pm_opp *opp;
  51         struct cpufreq_frequency_table *freq_table = NULL;
  52         int i, max_opps, ret = 0;
  53         unsigned long rate;
  54
  55         rcu_read_lock();
  56
  57         max_opps = dev_pm_opp_get_opp_count(dev);
  58         if (max_opps <= 0) {
  59                 ret = max_opps ? max_opps : -ENODATA;
  60                 goto out;
  61         }
  62
  63         freq_table = kcalloc((max_opps + 1), sizeof(*freq_table), GFP_ATOMIC);
  64         if (!freq_table) {
  65                 ret = -ENOMEM;
  66                 goto out;
  67         }
  68
  69         for (i = 0, rate = 0; i < max_opps; i++, rate++) {
  70                 /* find next rate */
  71                 opp = dev_pm_opp_find_freq_ceil(dev, &rate);
  72                 if (IS_ERR(opp)) {
  73                         ret = PTR_ERR(opp);
  74                         goto out;
  75                 }
  76                 freq_table[i].driver_data = i;
  77                 freq_table[i].frequency = rate / 1000;
  78
  79                 /* Is Boost/turbo opp ? */
  80                 if (dev_pm_opp_is_turbo(opp))
  81                         freq_table[i].flags = CPUFREQ_BOOST_FREQ;
  82         }
  83
  84         freq_table[i].driver_data = i;
  85         freq_table[i].frequency = CPUFREQ_TABLE_END;
  86
  87         *table = &freq_table[0];
  88
  89 out:
  90         rcu_read_unlock();
  91         if (ret)
  92                 kfree(freq_table);
  93
  94         return ret;
  95 }
  96 EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);
  97
  98 /**
  99  * dev_pm_opp_free_cpufreq_table() - free the cpufreq table
 100  * @dev:        device for which we do this operation
 101  * @table:      table to free
 102  *
 103  * Free up the table allocated by dev_pm_opp_init_cpufreq_table
 104  */
 105 void dev_pm_opp_free_cpufreq_table(struct device *dev,
 106                                    struct cpufreq_frequency_table **table)
 107 {
 108         if (!table)
 109                 return;
 110
 111         kfree(*table);
 112         *table = NULL;
 113 }
 114 EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);