drivers/thermal/devfreq_cooling.c

   1 /*
   2  * devfreq_cooling: Thermal cooling device implementation for devices using
   3  *                  devfreq
   4  *
   5  * Copyright (C) 2014-2015 ARM Limited
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  12  * kind, whether express or implied; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * TODO:
  17  *    - If OPPs are added or removed after devfreq cooling has
  18  *      registered, the devfreq cooling won't react to it.
  19  */
  20
  21 #include <linux/devfreq.h>
  22 #include <linux/devfreq_cooling.h>
  23 #include <linux/export.h>
  24 #include <linux/slab.h>
  25 #include <linux/pm_opp.h>
  26 #include <linux/thermal.h>
  27
  28 #include <trace/events/thermal.h>
  29
  30 static DEFINE_MUTEX(devfreq_lock);
  31 static DEFINE_IDR(devfreq_idr);
  32
  33 /**
  34  * struct devfreq_cooling_device - Devfreq cooling device
  35  * @id:         unique integer value corresponding to each
  36  *              devfreq_cooling_device registered.
  37  * @cdev:       Pointer to associated thermal cooling device.
  38  * @devfreq:    Pointer to associated devfreq device.
  39  * @cooling_state:      Current cooling state.
  40  * @power_table:        Pointer to table with maximum power draw for each
  41  *                      cooling state. State is the index into the table, and
  42  *                      the power is in mW.
  43  * @freq_table: Pointer to a table with the frequencies sorted in descending
  44  *              order.  You can index the table by cooling device state
  45  * @freq_table_size:    Size of the @freq_table and @power_table
  46  * @power_ops:  Pointer to devfreq_cooling_power, used to generate the
  47  *              @power_table.
  48  */
  49 struct devfreq_cooling_device {
  50         int id;
  51         struct thermal_cooling_device *cdev;
  52         struct devfreq *devfreq;
  53         unsigned long cooling_state;
  54         u32 *power_table;
  55         u32 *freq_table;
  56         size_t freq_table_size;
  57         struct devfreq_cooling_power *power_ops;
  58 };
  59
  60 /**
  61  * get_idr - function to get a unique id.
  62  * @idr: struct idr * handle used to create a id.
  63  * @id: int * value generated by this function.
  64  *
  65  * This function will populate @id with an unique
  66  * id, using the idr API.
  67  *
  68  * Return: 0 on success, an error code on failure.
  69  */
  70 static int get_idr(struct idr *idr, int *id)
  71 {
  72         int ret;
  73
  74         mutex_lock(&devfreq_lock);
  75         ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL);
  76         mutex_unlock(&devfreq_lock);
  77         if (unlikely(ret < 0))
  78                 return ret;
  79         *id = ret;
  80
  81         return 0;
  82 }
  83
  84 /**
  85  * release_idr - function to free the unique id.
  86  * @idr: struct idr * handle used for creating the id.
  87  * @id: int value representing the unique id.
  88  */
  89 static void release_idr(struct idr *idr, int id)
  90 {
  91         mutex_lock(&devfreq_lock);
  92         idr_remove(idr, id);
  93         mutex_unlock(&devfreq_lock);
  94 }
  95
  96 /**
  97  * partition_enable_opps() - disable all opps above a given state
  98  * @dfc:        Pointer to devfreq we are operating on
  99  * @cdev_state: cooling device state we're setting
 100  *
 101  * Go through the OPPs of the device, enabling all OPPs until
 102  * @cdev_state and disabling those frequencies above it.
 103  */
 104 static int partition_enable_opps(struct devfreq_cooling_device *dfc,
 105                                  unsigned long cdev_state)
 106 {
 107         int i;
 108         struct device *dev = dfc->devfreq->dev.parent;
 109
 110         for (i = 0; i < dfc->freq_table_size; i++) {
 111                 struct dev_pm_opp *opp;
 112                 int ret = 0;
 113                 unsigned int freq = dfc->freq_table[i];
 114                 bool want_enable = i >= cdev_state ? true : false;
 115
 116                 rcu_read_lock();
 117                 opp = dev_pm_opp_find_freq_exact(dev, freq, !want_enable);
 118                 rcu_read_unlock();
 119
 120                 if (PTR_ERR(opp) == -ERANGE)
 121                         continue;
 122                 else if (IS_ERR(opp))
 123                         return PTR_ERR(opp);
 124
 125                 if (want_enable)
 126                         ret = dev_pm_opp_enable(dev, freq);
 127                 else
 128                         ret = dev_pm_opp_disable(dev, freq);
 129
 130                 if (ret)
 131                         return ret;
 132         }
 133
 134         return 0;
 135 }
 136
 137 static int devfreq_cooling_get_max_state(struct thermal_cooling_device *cdev,
 138                                          unsigned long *state)
 139 {
 140         struct devfreq_cooling_device *dfc = cdev->devdata;
 141
 142         *state = dfc->freq_table_size - 1;
 143
 144         return 0;
 145 }
 146
 147 static int devfreq_cooling_get_cur_state(struct thermal_cooling_device *cdev,
 148                                          unsigned long *state)
 149 {
 150         struct devfreq_cooling_device *dfc = cdev->devdata;
 151
 152         *state = dfc->cooling_state;
 153
 154         return 0;
 155 }
 156
 157 static int devfreq_cooling_set_cur_state(struct thermal_cooling_device *cdev,
 158                                          unsigned long state)
 159 {
 160         struct devfreq_cooling_device *dfc = cdev->devdata;
 161         struct devfreq *df = dfc->devfreq;
 162         struct device *dev = df->dev.parent;
 163         int ret;
 164
 165         if (state == dfc->cooling_state)
 166                 return 0;
 167
 168         dev_dbg(dev, "Setting cooling state %lu\n", state);
 169
 170         if (state >= dfc->freq_table_size)
 171                 return -EINVAL;
 172
 173         ret = partition_enable_opps(dfc, state);
 174         if (ret)
 175                 return ret;
 176
 177         dfc->cooling_state = state;
 178
 179         return 0;
 180 }
 181
 182 /**
 183  * freq_get_state() - get the cooling state corresponding to a frequency
 184  * @dfc:        Pointer to devfreq cooling device
 185  * @freq:       frequency in Hz
 186  *
 187  * Return: the cooling state associated with the @freq, or
 188  * THERMAL_CSTATE_INVALID if it wasn't found.
 189  */
 190 static unsigned long
 191 freq_get_state(struct devfreq_cooling_device *dfc, unsigned long freq)
 192 {
 193         int i;
 194
 195         for (i = 0; i < dfc->freq_table_size; i++) {
 196                 if (dfc->freq_table[i] == freq)
 197                         return i;
 198         }
 199
 200         return THERMAL_CSTATE_INVALID;
 201 }
 202
 203 /**
 204  * get_static_power() - calculate the static power
 205  * @dfc:        Pointer to devfreq cooling device
 206  * @freq:       Frequency in Hz
 207  *
 208  * Calculate the static power in milliwatts using the supplied
 209  * get_static_power().  The current voltage is calculated using the
 210  * OPP library.  If no get_static_power() was supplied, assume the
 211  * static power is negligible.
 212  */
 213 static unsigned long
 214 get_static_power(struct devfreq_cooling_device *dfc, unsigned long freq)
 215 {
 216         struct devfreq *df = dfc->devfreq;
 217         struct device *dev = df->dev.parent;
 218         unsigned long voltage;
 219         struct dev_pm_opp *opp;
 220
 221         if (!dfc->power_ops->get_static_power)
 222                 return 0;
 223
 224         rcu_read_lock();
 225
 226         opp = dev_pm_opp_find_freq_exact(dev, freq, true);
 227         if (IS_ERR(opp) && (PTR_ERR(opp) == -ERANGE))
 228                 opp = dev_pm_opp_find_freq_exact(dev, freq, false);
 229
 230         voltage = dev_pm_opp_get_voltage(opp) / 1000; /* mV */
 231
 232         rcu_read_unlock();
 233
 234         if (voltage == 0) {
 235                 dev_warn_ratelimited(dev,
 236                                      "Failed to get voltage for frequency %lu: %ld\n",
 237                                      freq, IS_ERR(opp) ? PTR_ERR(opp) : 0);
 238                 return 0;
 239         }
 240
 241         return dfc->power_ops->get_static_power(df, voltage);
 242 }
 243
 244 /**
 245  * get_dynamic_power - calculate the dynamic power
 246  * @dfc:        Pointer to devfreq cooling device
 247  * @freq:       Frequency in Hz
 248  * @voltage:    Voltage in millivolts
 249  *
 250  * Calculate the dynamic power in milliwatts consumed by the device at
 251  * frequency @freq and voltage @voltage.  If the get_dynamic_power()
 252  * was supplied as part of the devfreq_cooling_power struct, then that
 253  * function is used.  Otherwise, a simple power model (Pdyn = Coeff *
 254  * Voltage^2 * Frequency) is used.
 255  */
 256 static unsigned long
 257 get_dynamic_power(struct devfreq_cooling_device *dfc, unsigned long freq,
 258                   unsigned long voltage)
 259 {
 260         u64 power;
 261         u32 freq_mhz;
 262         struct devfreq_cooling_power *dfc_power = dfc->power_ops;
 263
 264         if (dfc_power->get_dynamic_power)
 265                 return dfc_power->get_dynamic_power(dfc->devfreq, freq,
 266                                                     voltage);
 267
 268         freq_mhz = freq / 1000000;
 269         power = (u64)dfc_power->dyn_power_coeff * freq_mhz * voltage * voltage;
 270         do_div(power, 1000000000);
 271
 272         return power;
 273 }
 274
 275 static int devfreq_cooling_get_requested_power(struct thermal_cooling_device *cdev,
 276                                                struct thermal_zone_device *tz,
 277                                                u32 *power)
 278 {
 279         struct devfreq_cooling_device *dfc = cdev->devdata;
 280         struct devfreq *df = dfc->devfreq;
 281         struct devfreq_dev_status *status = &df->last_status;
 282         unsigned long state;
 283         unsigned long freq = status->current_frequency;
 284         u32 dyn_power, static_power;
 285
 286         /* Get dynamic power for state */
 287         state = freq_get_state(dfc, freq);
 288         if (state == THERMAL_CSTATE_INVALID)
 289                 return -EAGAIN;
 290
 291         dyn_power = dfc->power_table[state];
 292
 293         /* Scale dynamic power for utilization */
 294         dyn_power = (dyn_power * status->busy_time) / status->total_time;
 295
 296         /* Get static power */
 297         static_power = get_static_power(dfc, freq);
 298
 299         trace_thermal_power_devfreq_get_power(cdev, status, freq, dyn_power,
 300                                               static_power);
 301
 302         *power = dyn_power + static_power;
 303
 304         return 0;
 305 }
 306
 307 static int devfreq_cooling_state2power(struct thermal_cooling_device *cdev,
 308                                        struct thermal_zone_device *tz,
 309                                        unsigned long state,
 310                                        u32 *power)
 311 {
 312         struct devfreq_cooling_device *dfc = cdev->devdata;
 313         unsigned long freq;
 314         u32 static_power;
 315
 316         if (state >= dfc->freq_table_size)
 317                 return -EINVAL;
 318
 319         freq = dfc->freq_table[state];
 320         static_power = get_static_power(dfc, freq);
 321
 322         *power = dfc->power_table[state] + static_power;
 323         return 0;
 324 }
 325
 326 static int devfreq_cooling_power2state(struct thermal_cooling_device *cdev,
 327                                        struct thermal_zone_device *tz,
 328                                        u32 power, unsigned long *state)
 329 {
 330         struct devfreq_cooling_device *dfc = cdev->devdata;
 331         struct devfreq *df = dfc->devfreq;
 332         struct devfreq_dev_status *status = &df->last_status;
 333         unsigned long freq = status->current_frequency;
 334         unsigned long busy_time;
 335         s32 dyn_power;
 336         u32 static_power;
 337         int i;
 338
 339         static_power = get_static_power(dfc, freq);
 340
 341         dyn_power = power - static_power;
 342         dyn_power = dyn_power > 0 ? dyn_power : 0;
 343
 344         /* Scale dynamic power for utilization */
 345         busy_time = status->busy_time ?: 1;
 346         dyn_power = (dyn_power * status->total_time) / busy_time;
 347
 348         /*
 349          * Find the first cooling state that is within the power
 350          * budget for dynamic power.
 351          */
 352         for (i = 0; i < dfc->freq_table_size - 1; i++)
 353                 if (dyn_power >= dfc->power_table[i])
 354                         break;
 355
 356         *state = i;
 357         trace_thermal_power_devfreq_limit(cdev, freq, *state, power);
 358         return 0;
 359 }
 360
 361 static struct thermal_cooling_device_ops devfreq_cooling_ops = {
 362         .get_max_state = devfreq_cooling_get_max_state,
 363         .get_cur_state = devfreq_cooling_get_cur_state,
 364         .set_cur_state = devfreq_cooling_set_cur_state,
 365 };
 366
 367 /**
 368  * devfreq_cooling_gen_tables() - Generate power and freq tables.
 369  * @dfc: Pointer to devfreq cooling device.
 370  *
 371  * Generate power and frequency tables: the power table hold the
 372  * device's maximum power usage at each cooling state (OPP).  The
 373  * static and dynamic power using the appropriate voltage and
 374  * frequency for the state, is acquired from the struct
 375  * devfreq_cooling_power, and summed to make the maximum power draw.
 376  *
 377  * The frequency table holds the frequencies in descending order.
 378  * That way its indexed by cooling device state.
 379  *
 380  * The tables are malloced, and pointers put in dfc.  They must be
 381  * freed when unregistering the devfreq cooling device.
 382  *
 383  * Return: 0 on success, negative error code on failure.
 384  */
 385 static int devfreq_cooling_gen_tables(struct devfreq_cooling_device *dfc)
 386 {
 387         struct devfreq *df = dfc->devfreq;
 388         struct device *dev = df->dev.parent;
 389         int ret, num_opps;
 390         unsigned long freq;
 391         u32 *power_table = NULL;
 392         u32 *freq_table;
 393         int i;
 394
 395         num_opps = dev_pm_opp_get_opp_count(dev);
 396
 397         if (dfc->power_ops) {
 398                 power_table = kcalloc(num_opps, sizeof(*power_table),
 399                                       GFP_KERNEL);
 400                 if (!power_table)
 401                         return -ENOMEM;
 402         }
 403
 404         freq_table = kcalloc(num_opps, sizeof(*freq_table),
 405                              GFP_KERNEL);
 406         if (!freq_table) {
 407                 ret = -ENOMEM;
 408                 goto free_power_table;
 409         }
 410
 411         for (i = 0, freq = ULONG_MAX; i < num_opps; i++, freq--) {
 412                 unsigned long power_dyn, voltage;
 413                 struct dev_pm_opp *opp;
 414
 415                 rcu_read_lock();
 416
 417                 opp = dev_pm_opp_find_freq_floor(dev, &freq);
 418                 if (IS_ERR(opp)) {
 419                         rcu_read_unlock();
 420                         ret = PTR_ERR(opp);
 421                         goto free_tables;
 422                 }
 423
 424                 voltage = dev_pm_opp_get_voltage(opp) / 1000; /* mV */
 425
 426                 rcu_read_unlock();
 427
 428                 if (dfc->power_ops) {
 429                         power_dyn = get_dynamic_power(dfc, freq, voltage);
 430
 431                         dev_dbg(dev, "Dynamic power table: %lu MHz @ %lu mV: %lu = %lu mW\n",
 432                                 freq / 1000000, voltage, power_dyn, power_dyn);
 433
 434                         power_table[i] = power_dyn;
 435                 }
 436
 437                 freq_table[i] = freq;
 438         }
 439
 440         if (dfc->power_ops)
 441                 dfc->power_table = power_table;
 442
 443         dfc->freq_table = freq_table;
 444         dfc->freq_table_size = num_opps;
 445
 446         return 0;
 447
 448 free_tables:
 449         kfree(freq_table);
 450 free_power_table:
 451         kfree(power_table);
 452
 453         return ret;
 454 }
 455
 456 /**
 457  * of_devfreq_cooling_register_power() - Register devfreq cooling device,
 458  *                                      with OF and power information.
 459  * @np: Pointer to OF device_node.
 460  * @df: Pointer to devfreq device.
 461  * @dfc_power:  Pointer to devfreq_cooling_power.
 462  *
 463  * Register a devfreq cooling device.  The available OPPs must be
 464  * registered on the device.
 465  *
 466  * If @dfc_power is provided, the cooling device is registered with the
 467  * power extensions.  For the power extensions to work correctly,
 468  * devfreq should use the simple_ondemand governor, other governors
 469  * are not currently supported.
 470  */
 471 struct thermal_cooling_device *
 472 of_devfreq_cooling_register_power(struct device_node *np, struct devfreq *df,
 473                                   struct devfreq_cooling_power *dfc_power)
 474 {
 475         struct thermal_cooling_device *cdev;
 476         struct devfreq_cooling_device *dfc;
 477         char dev_name[THERMAL_NAME_LENGTH];
 478         int err;
 479
 480         dfc = kzalloc(sizeof(*dfc), GFP_KERNEL);
 481         if (!dfc)
 482                 return ERR_PTR(-ENOMEM);
 483
 484         dfc->devfreq = df;
 485
 486         if (dfc_power) {
 487                 dfc->power_ops = dfc_power;
 488
 489                 devfreq_cooling_ops.get_requested_power =
 490                         devfreq_cooling_get_requested_power;
 491                 devfreq_cooling_ops.state2power = devfreq_cooling_state2power;
 492                 devfreq_cooling_ops.power2state = devfreq_cooling_power2state;
 493         }
 494
 495         err = devfreq_cooling_gen_tables(dfc);
 496         if (err)
 497                 goto free_dfc;
 498
 499         err = get_idr(&devfreq_idr, &dfc->id);
 500         if (err)
 501                 goto free_tables;
 502
 503         snprintf(dev_name, sizeof(dev_name), "thermal-devfreq-%d", dfc->id);
 504
 505         cdev = thermal_of_cooling_device_register(np, dev_name, dfc,
 506                                                   &devfreq_cooling_ops);
 507         if (IS_ERR(cdev)) {
 508                 err = PTR_ERR(cdev);
 509                 dev_err(df->dev.parent,
 510                         "Failed to register devfreq cooling device (%d)\n",
 511                         err);
 512                 goto release_idr;
 513         }
 514
 515         dfc->cdev = cdev;
 516
 517         return cdev;
 518
 519 release_idr:
 520         release_idr(&devfreq_idr, dfc->id);
 521 free_tables:
 522         kfree(dfc->power_table);
 523         kfree(dfc->freq_table);
 524 free_dfc:
 525         kfree(dfc);
 526
 527         return ERR_PTR(err);
 528 }
 529 EXPORT_SYMBOL_GPL(of_devfreq_cooling_register_power);
 530
 531 /**
 532  * of_devfreq_cooling_register() - Register devfreq cooling device,
 533  *                                with OF information.
 534  * @np: Pointer to OF device_node.
 535  * @df: Pointer to devfreq device.
 536  */
 537 struct thermal_cooling_device *
 538 of_devfreq_cooling_register(struct device_node *np, struct devfreq *df)
 539 {
 540         return of_devfreq_cooling_register_power(np, df, NULL);
 541 }
 542 EXPORT_SYMBOL_GPL(of_devfreq_cooling_register);
 543
 544 /**
 545  * devfreq_cooling_register() - Register devfreq cooling device.
 546  * @df: Pointer to devfreq device.
 547  */
 548 struct thermal_cooling_device *devfreq_cooling_register(struct devfreq *df)
 549 {
 550         return of_devfreq_cooling_register(NULL, df);
 551 }
 552 EXPORT_SYMBOL_GPL(devfreq_cooling_register);
 553
 554 /**
 555  * devfreq_cooling_unregister() - Unregister devfreq cooling device.
 556  * @dfc: Pointer to devfreq cooling device to unregister.
 557  */
 558 void devfreq_cooling_unregister(struct thermal_cooling_device *cdev)
 559 {
 560         struct devfreq_cooling_device *dfc;
 561
 562         if (!cdev)
 563                 return;
 564
 565         dfc = cdev->devdata;
 566
 567         thermal_cooling_device_unregister(dfc->cdev);
 568         release_idr(&devfreq_idr, dfc->id);
 569         kfree(dfc->power_table);
 570         kfree(dfc->freq_table);
 571
 572         kfree(dfc);
 573 }
 574 EXPORT_SYMBOL_GPL(devfreq_cooling_unregister);