linux/drivers/thermal/thermal_core.c
<<
>>
Prefs
   1/*
   2 *  thermal.c - Generic Thermal Management Sysfs support.
   3 *
   4 *  Copyright (C) 2008 Intel Corp
   5 *  Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
   6 *  Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
   7 *
   8 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9 *
  10 *  This program is free software; you can redistribute it and/or modify
  11 *  it under the terms of the GNU General Public License as published by
  12 *  the Free Software Foundation; version 2 of the License.
  13 *
  14 *  This program is distributed in the hope that it will be useful, but
  15 *  WITHOUT ANY WARRANTY; without even the implied warranty of
  16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 *  General Public License for more details.
  18 *
  19 *  You should have received a copy of the GNU General Public License along
  20 *  with this program; if not, write to the Free Software Foundation, Inc.,
  21 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  22 *
  23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  24 */
  25
  26#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  27
  28#include <linux/module.h>
  29#include <linux/device.h>
  30#include <linux/err.h>
  31#include <linux/slab.h>
  32#include <linux/kdev_t.h>
  33#include <linux/idr.h>
  34#include <linux/thermal.h>
  35#include <linux/reboot.h>
  36#include <net/netlink.h>
  37#include <net/genetlink.h>
  38
  39#include "thermal_core.h"
  40
  41MODULE_AUTHOR("Zhang Rui");
  42MODULE_DESCRIPTION("Generic thermal management sysfs support");
  43MODULE_LICENSE("GPL v2");
  44
  45static DEFINE_IDR(thermal_tz_idr);
  46static DEFINE_IDR(thermal_cdev_idr);
  47static DEFINE_MUTEX(thermal_idr_lock);
  48
  49static LIST_HEAD(thermal_tz_list);
  50static LIST_HEAD(thermal_cdev_list);
  51static LIST_HEAD(thermal_governor_list);
  52
  53static DEFINE_MUTEX(thermal_list_lock);
  54static DEFINE_MUTEX(thermal_governor_lock);
  55
  56static struct thermal_governor *__find_governor(const char *name)
  57{
  58        struct thermal_governor *pos;
  59
  60        list_for_each_entry(pos, &thermal_governor_list, governor_list)
  61                if (!strnicmp(name, pos->name, THERMAL_NAME_LENGTH))
  62                        return pos;
  63
  64        return NULL;
  65}
  66
  67int thermal_register_governor(struct thermal_governor *governor)
  68{
  69        int err;
  70        const char *name;
  71        struct thermal_zone_device *pos;
  72
  73        if (!governor)
  74                return -EINVAL;
  75
  76        mutex_lock(&thermal_governor_lock);
  77
  78        err = -EBUSY;
  79        if (__find_governor(governor->name) == NULL) {
  80                err = 0;
  81                list_add(&governor->governor_list, &thermal_governor_list);
  82        }
  83
  84        mutex_lock(&thermal_list_lock);
  85
  86        list_for_each_entry(pos, &thermal_tz_list, node) {
  87                if (pos->governor)
  88                        continue;
  89                if (pos->tzp)
  90                        name = pos->tzp->governor_name;
  91                else
  92                        name = DEFAULT_THERMAL_GOVERNOR;
  93                if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH))
  94                        pos->governor = governor;
  95        }
  96
  97        mutex_unlock(&thermal_list_lock);
  98        mutex_unlock(&thermal_governor_lock);
  99
 100        return err;
 101}
 102
 103void thermal_unregister_governor(struct thermal_governor *governor)
 104{
 105        struct thermal_zone_device *pos;
 106
 107        if (!governor)
 108                return;
 109
 110        mutex_lock(&thermal_governor_lock);
 111
 112        if (__find_governor(governor->name) == NULL)
 113                goto exit;
 114
 115        mutex_lock(&thermal_list_lock);
 116
 117        list_for_each_entry(pos, &thermal_tz_list, node) {
 118                if (!strnicmp(pos->governor->name, governor->name,
 119                                                THERMAL_NAME_LENGTH))
 120                        pos->governor = NULL;
 121        }
 122
 123        mutex_unlock(&thermal_list_lock);
 124        list_del(&governor->governor_list);
 125exit:
 126        mutex_unlock(&thermal_governor_lock);
 127        return;
 128}
 129
 130static int get_idr(struct idr *idr, struct mutex *lock, int *id)
 131{
 132        int ret;
 133
 134        if (lock)
 135                mutex_lock(lock);
 136        ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL);
 137        if (lock)
 138                mutex_unlock(lock);
 139        if (unlikely(ret < 0))
 140                return ret;
 141        *id = ret;
 142        return 0;
 143}
 144
 145static void release_idr(struct idr *idr, struct mutex *lock, int id)
 146{
 147        if (lock)
 148                mutex_lock(lock);
 149        idr_remove(idr, id);
 150        if (lock)
 151                mutex_unlock(lock);
 152}
 153
 154int get_tz_trend(struct thermal_zone_device *tz, int trip)
 155{
 156        enum thermal_trend trend;
 157
 158        if (!tz->ops->get_trend || tz->ops->get_trend(tz, trip, &trend)) {
 159                if (tz->temperature > tz->last_temperature)
 160                        trend = THERMAL_TREND_RAISING;
 161                else if (tz->temperature < tz->last_temperature)
 162                        trend = THERMAL_TREND_DROPPING;
 163                else
 164                        trend = THERMAL_TREND_STABLE;
 165        }
 166
 167        return trend;
 168}
 169EXPORT_SYMBOL(get_tz_trend);
 170
 171struct thermal_instance *get_thermal_instance(struct thermal_zone_device *tz,
 172                        struct thermal_cooling_device *cdev, int trip)
 173{
 174        struct thermal_instance *pos = NULL;
 175        struct thermal_instance *target_instance = NULL;
 176
 177        mutex_lock(&tz->lock);
 178        mutex_lock(&cdev->lock);
 179
 180        list_for_each_entry(pos, &tz->thermal_instances, tz_node) {
 181                if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
 182                        target_instance = pos;
 183                        break;
 184                }
 185        }
 186
 187        mutex_unlock(&cdev->lock);
 188        mutex_unlock(&tz->lock);
 189
 190        return target_instance;
 191}
 192EXPORT_SYMBOL(get_thermal_instance);
 193
 194static void print_bind_err_msg(struct thermal_zone_device *tz,
 195                        struct thermal_cooling_device *cdev, int ret)
 196{
 197        dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n",
 198                                tz->type, cdev->type, ret);
 199}
 200
 201static void __bind(struct thermal_zone_device *tz, int mask,
 202                        struct thermal_cooling_device *cdev)
 203{
 204        int i, ret;
 205
 206        for (i = 0; i < tz->trips; i++) {
 207                if (mask & (1 << i)) {
 208                        ret = thermal_zone_bind_cooling_device(tz, i, cdev,
 209                                        THERMAL_NO_LIMIT, THERMAL_NO_LIMIT);
 210                        if (ret)
 211                                print_bind_err_msg(tz, cdev, ret);
 212                }
 213        }
 214}
 215
 216static void __unbind(struct thermal_zone_device *tz, int mask,
 217                        struct thermal_cooling_device *cdev)
 218{
 219        int i;
 220
 221        for (i = 0; i < tz->trips; i++)
 222                if (mask & (1 << i))
 223                        thermal_zone_unbind_cooling_device(tz, i, cdev);
 224}
 225
 226static void bind_cdev(struct thermal_cooling_device *cdev)
 227{
 228        int i, ret;
 229        const struct thermal_zone_params *tzp;
 230        struct thermal_zone_device *pos = NULL;
 231
 232        mutex_lock(&thermal_list_lock);
 233
 234        list_for_each_entry(pos, &thermal_tz_list, node) {
 235                if (!pos->tzp && !pos->ops->bind)
 236                        continue;
 237
 238                if (!pos->tzp && pos->ops->bind) {
 239                        ret = pos->ops->bind(pos, cdev);
 240                        if (ret)
 241                                print_bind_err_msg(pos, cdev, ret);
 242                }
 243
 244                tzp = pos->tzp;
 245                if (!tzp || !tzp->tbp)
 246                        continue;
 247
 248                for (i = 0; i < tzp->num_tbps; i++) {
 249                        if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
 250                                continue;
 251                        if (tzp->tbp[i].match(pos, cdev))
 252                                continue;
 253                        tzp->tbp[i].cdev = cdev;
 254                        __bind(pos, tzp->tbp[i].trip_mask, cdev);
 255                }
 256        }
 257
 258        mutex_unlock(&thermal_list_lock);
 259}
 260
 261static void bind_tz(struct thermal_zone_device *tz)
 262{
 263        int i, ret;
 264        struct thermal_cooling_device *pos = NULL;
 265        const struct thermal_zone_params *tzp = tz->tzp;
 266
 267        if (!tzp && !tz->ops->bind)
 268                return;
 269
 270        mutex_lock(&thermal_list_lock);
 271
 272        /* If there is no platform data, try to use ops->bind */
 273        if (!tzp && tz->ops->bind) {
 274                list_for_each_entry(pos, &thermal_cdev_list, node) {
 275                        ret = tz->ops->bind(tz, pos);
 276                        if (ret)
 277                                print_bind_err_msg(tz, pos, ret);
 278                }
 279                goto exit;
 280        }
 281
 282        if (!tzp || !tzp->tbp)
 283                goto exit;
 284
 285        list_for_each_entry(pos, &thermal_cdev_list, node) {
 286                for (i = 0; i < tzp->num_tbps; i++) {
 287                        if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
 288                                continue;
 289                        if (tzp->tbp[i].match(tz, pos))
 290                                continue;
 291                        tzp->tbp[i].cdev = pos;
 292                        __bind(tz, tzp->tbp[i].trip_mask, pos);
 293                }
 294        }
 295exit:
 296        mutex_unlock(&thermal_list_lock);
 297}
 298
 299static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
 300                                            int delay)
 301{
 302        if (delay > 1000)
 303                mod_delayed_work(system_freezable_wq, &tz->poll_queue,
 304                                 round_jiffies(msecs_to_jiffies(delay)));
 305        else if (delay)
 306                mod_delayed_work(system_freezable_wq, &tz->poll_queue,
 307                                 msecs_to_jiffies(delay));
 308        else
 309                cancel_delayed_work(&tz->poll_queue);
 310}
 311
 312static void monitor_thermal_zone(struct thermal_zone_device *tz)
 313{
 314        mutex_lock(&tz->lock);
 315
 316        if (tz->passive)
 317                thermal_zone_device_set_polling(tz, tz->passive_delay);
 318        else if (tz->polling_delay)
 319                thermal_zone_device_set_polling(tz, tz->polling_delay);
 320        else
 321                thermal_zone_device_set_polling(tz, 0);
 322
 323        mutex_unlock(&tz->lock);
 324}
 325
 326static void handle_non_critical_trips(struct thermal_zone_device *tz,
 327                        int trip, enum thermal_trip_type trip_type)
 328{
 329        if (tz->governor)
 330                tz->governor->throttle(tz, trip);
 331}
 332
 333static void handle_critical_trips(struct thermal_zone_device *tz,
 334                                int trip, enum thermal_trip_type trip_type)
 335{
 336        long trip_temp;
 337
 338        tz->ops->get_trip_temp(tz, trip, &trip_temp);
 339
 340        /* If we have not crossed the trip_temp, we do not care. */
 341        if (tz->temperature < trip_temp)
 342                return;
 343
 344        if (tz->ops->notify)
 345                tz->ops->notify(tz, trip, trip_type);
 346
 347        if (trip_type == THERMAL_TRIP_CRITICAL) {
 348                dev_emerg(&tz->device,
 349                          "critical temperature reached(%d C),shutting down\n",
 350                          tz->temperature / 1000);
 351                orderly_poweroff(true);
 352        }
 353}
 354
 355static void handle_thermal_trip(struct thermal_zone_device *tz, int trip)
 356{
 357        enum thermal_trip_type type;
 358
 359        tz->ops->get_trip_type(tz, trip, &type);
 360
 361        if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT)
 362                handle_critical_trips(tz, trip, type);
 363        else
 364                handle_non_critical_trips(tz, trip, type);
 365        /*
 366         * Alright, we handled this trip successfully.
 367         * So, start monitoring again.
 368         */
 369        monitor_thermal_zone(tz);
 370}
 371
 372/**
 373 * thermal_zone_get_temp() - returns its the temperature of thermal zone
 374 * @tz: a valid pointer to a struct thermal_zone_device
 375 * @temp: a valid pointer to where to store the resulting temperature.
 376 *
 377 * When a valid thermal zone reference is passed, it will fetch its
 378 * temperature and fill @temp.
 379 *
 380 * Return: On success returns 0, an error code otherwise
 381 */
 382int thermal_zone_get_temp(struct thermal_zone_device *tz, unsigned long *temp)
 383{
 384        int ret = -EINVAL;
 385#ifdef CONFIG_THERMAL_EMULATION
 386        int count;
 387        unsigned long crit_temp = -1UL;
 388        enum thermal_trip_type type;
 389#endif
 390
 391        if (!tz || IS_ERR(tz))
 392                goto exit;
 393
 394        mutex_lock(&tz->lock);
 395
 396        ret = tz->ops->get_temp(tz, temp);
 397#ifdef CONFIG_THERMAL_EMULATION
 398        if (!tz->emul_temperature)
 399                goto skip_emul;
 400
 401        for (count = 0; count < tz->trips; count++) {
 402                ret = tz->ops->get_trip_type(tz, count, &type);
 403                if (!ret && type == THERMAL_TRIP_CRITICAL) {
 404                        ret = tz->ops->get_trip_temp(tz, count, &crit_temp);
 405                        break;
 406                }
 407        }
 408
 409        if (ret)
 410                goto skip_emul;
 411
 412        if (*temp < crit_temp)
 413                *temp = tz->emul_temperature;
 414skip_emul:
 415#endif
 416        mutex_unlock(&tz->lock);
 417exit:
 418        return ret;
 419}
 420EXPORT_SYMBOL_GPL(thermal_zone_get_temp);
 421
 422static void update_temperature(struct thermal_zone_device *tz)
 423{
 424        long temp;
 425        int ret;
 426
 427        ret = thermal_zone_get_temp(tz, &temp);
 428        if (ret) {
 429                dev_warn(&tz->device, "failed to read out thermal zone %d\n",
 430                         tz->id);
 431                return;
 432        }
 433
 434        mutex_lock(&tz->lock);
 435        tz->last_temperature = tz->temperature;
 436        tz->temperature = temp;
 437        mutex_unlock(&tz->lock);
 438}
 439
 440void thermal_zone_device_update(struct thermal_zone_device *tz)
 441{
 442        int count;
 443
 444        update_temperature(tz);
 445
 446        for (count = 0; count < tz->trips; count++)
 447                handle_thermal_trip(tz, count);
 448}
 449EXPORT_SYMBOL_GPL(thermal_zone_device_update);
 450
 451static void thermal_zone_device_check(struct work_struct *work)
 452{
 453        struct thermal_zone_device *tz = container_of(work, struct
 454                                                      thermal_zone_device,
 455                                                      poll_queue.work);
 456        thermal_zone_device_update(tz);
 457}
 458
 459/* sys I/F for thermal zone */
 460
 461#define to_thermal_zone(_dev) \
 462        container_of(_dev, struct thermal_zone_device, device)
 463
 464static ssize_t
 465type_show(struct device *dev, struct device_attribute *attr, char *buf)
 466{
 467        struct thermal_zone_device *tz = to_thermal_zone(dev);
 468
 469        return sprintf(buf, "%s\n", tz->type);
 470}
 471
 472static ssize_t
 473temp_show(struct device *dev, struct device_attribute *attr, char *buf)
 474{
 475        struct thermal_zone_device *tz = to_thermal_zone(dev);
 476        long temperature;
 477        int ret;
 478
 479        ret = thermal_zone_get_temp(tz, &temperature);
 480
 481        if (ret)
 482                return ret;
 483
 484        return sprintf(buf, "%ld\n", temperature);
 485}
 486
 487static ssize_t
 488mode_show(struct device *dev, struct device_attribute *attr, char *buf)
 489{
 490        struct thermal_zone_device *tz = to_thermal_zone(dev);
 491        enum thermal_device_mode mode;
 492        int result;
 493
 494        if (!tz->ops->get_mode)
 495                return -EPERM;
 496
 497        result = tz->ops->get_mode(tz, &mode);
 498        if (result)
 499                return result;
 500
 501        return sprintf(buf, "%s\n", mode == THERMAL_DEVICE_ENABLED ? "enabled"
 502                       : "disabled");
 503}
 504
 505static ssize_t
 506mode_store(struct device *dev, struct device_attribute *attr,
 507           const char *buf, size_t count)
 508{
 509        struct thermal_zone_device *tz = to_thermal_zone(dev);
 510        int result;
 511
 512        if (!tz->ops->set_mode)
 513                return -EPERM;
 514
 515        if (!strncmp(buf, "enabled", sizeof("enabled") - 1))
 516                result = tz->ops->set_mode(tz, THERMAL_DEVICE_ENABLED);
 517        else if (!strncmp(buf, "disabled", sizeof("disabled") - 1))
 518                result = tz->ops->set_mode(tz, THERMAL_DEVICE_DISABLED);
 519        else
 520                result = -EINVAL;
 521
 522        if (result)
 523                return result;
 524
 525        return count;
 526}
 527
 528static ssize_t
 529trip_point_type_show(struct device *dev, struct device_attribute *attr,
 530                     char *buf)
 531{
 532        struct thermal_zone_device *tz = to_thermal_zone(dev);
 533        enum thermal_trip_type type;
 534        int trip, result;
 535
 536        if (!tz->ops->get_trip_type)
 537                return -EPERM;
 538
 539        if (!sscanf(attr->attr.name, "trip_point_%d_type", &trip))
 540                return -EINVAL;
 541
 542        result = tz->ops->get_trip_type(tz, trip, &type);
 543        if (result)
 544                return result;
 545
 546        switch (type) {
 547        case THERMAL_TRIP_CRITICAL:
 548                return sprintf(buf, "critical\n");
 549        case THERMAL_TRIP_HOT:
 550                return sprintf(buf, "hot\n");
 551        case THERMAL_TRIP_PASSIVE:
 552                return sprintf(buf, "passive\n");
 553        case THERMAL_TRIP_ACTIVE:
 554                return sprintf(buf, "active\n");
 555        default:
 556                return sprintf(buf, "unknown\n");
 557        }
 558}
 559
 560static ssize_t
 561trip_point_temp_store(struct device *dev, struct device_attribute *attr,
 562                     const char *buf, size_t count)
 563{
 564        struct thermal_zone_device *tz = to_thermal_zone(dev);
 565        int trip, ret;
 566        unsigned long temperature;
 567
 568        if (!tz->ops->set_trip_temp)
 569                return -EPERM;
 570
 571        if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip))
 572                return -EINVAL;
 573
 574        if (kstrtoul(buf, 10, &temperature))
 575                return -EINVAL;
 576
 577        ret = tz->ops->set_trip_temp(tz, trip, temperature);
 578
 579        return ret ? ret : count;
 580}
 581
 582static ssize_t
 583trip_point_temp_show(struct device *dev, struct device_attribute *attr,
 584                     char *buf)
 585{
 586        struct thermal_zone_device *tz = to_thermal_zone(dev);
 587        int trip, ret;
 588        long temperature;
 589
 590        if (!tz->ops->get_trip_temp)
 591                return -EPERM;
 592
 593        if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip))
 594                return -EINVAL;
 595
 596        ret = tz->ops->get_trip_temp(tz, trip, &temperature);
 597
 598        if (ret)
 599                return ret;
 600
 601        return sprintf(buf, "%ld\n", temperature);
 602}
 603
 604static ssize_t
 605trip_point_hyst_store(struct device *dev, struct device_attribute *attr,
 606                        const char *buf, size_t count)
 607{
 608        struct thermal_zone_device *tz = to_thermal_zone(dev);
 609        int trip, ret;
 610        unsigned long temperature;
 611
 612        if (!tz->ops->set_trip_hyst)
 613                return -EPERM;
 614
 615        if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip))
 616                return -EINVAL;
 617
 618        if (kstrtoul(buf, 10, &temperature))
 619                return -EINVAL;
 620
 621        /*
 622         * We are not doing any check on the 'temperature' value
 623         * here. The driver implementing 'set_trip_hyst' has to
 624         * take care of this.
 625         */
 626        ret = tz->ops->set_trip_hyst(tz, trip, temperature);
 627
 628        return ret ? ret : count;
 629}
 630
 631static ssize_t
 632trip_point_hyst_show(struct device *dev, struct device_attribute *attr,
 633                        char *buf)
 634{
 635        struct thermal_zone_device *tz = to_thermal_zone(dev);
 636        int trip, ret;
 637        unsigned long temperature;
 638
 639        if (!tz->ops->get_trip_hyst)
 640                return -EPERM;
 641
 642        if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip))
 643                return -EINVAL;
 644
 645        ret = tz->ops->get_trip_hyst(tz, trip, &temperature);
 646
 647        return ret ? ret : sprintf(buf, "%ld\n", temperature);
 648}
 649
 650static ssize_t
 651passive_store(struct device *dev, struct device_attribute *attr,
 652                    const char *buf, size_t count)
 653{
 654        struct thermal_zone_device *tz = to_thermal_zone(dev);
 655        struct thermal_cooling_device *cdev = NULL;
 656        int state;
 657
 658        if (!sscanf(buf, "%d\n", &state))
 659                return -EINVAL;
 660
 661        /* sanity check: values below 1000 millicelcius don't make sense
 662         * and can cause the system to go into a thermal heart attack
 663         */
 664        if (state && state < 1000)
 665                return -EINVAL;
 666
 667        if (state && !tz->forced_passive) {
 668                mutex_lock(&thermal_list_lock);
 669                list_for_each_entry(cdev, &thermal_cdev_list, node) {
 670                        if (!strncmp("Processor", cdev->type,
 671                                     sizeof("Processor")))
 672                                thermal_zone_bind_cooling_device(tz,
 673                                                THERMAL_TRIPS_NONE, cdev,
 674                                                THERMAL_NO_LIMIT,
 675                                                THERMAL_NO_LIMIT);
 676                }
 677                mutex_unlock(&thermal_list_lock);
 678                if (!tz->passive_delay)
 679                        tz->passive_delay = 1000;
 680        } else if (!state && tz->forced_passive) {
 681                mutex_lock(&thermal_list_lock);
 682                list_for_each_entry(cdev, &thermal_cdev_list, node) {
 683                        if (!strncmp("Processor", cdev->type,
 684                                     sizeof("Processor")))
 685                                thermal_zone_unbind_cooling_device(tz,
 686                                                                   THERMAL_TRIPS_NONE,
 687                                                                   cdev);
 688                }
 689                mutex_unlock(&thermal_list_lock);
 690                tz->passive_delay = 0;
 691        }
 692
 693        tz->forced_passive = state;
 694
 695        thermal_zone_device_update(tz);
 696
 697        return count;
 698}
 699
 700static ssize_t
 701passive_show(struct device *dev, struct device_attribute *attr,
 702                   char *buf)
 703{
 704        struct thermal_zone_device *tz = to_thermal_zone(dev);
 705
 706        return sprintf(buf, "%d\n", tz->forced_passive);
 707}
 708
 709static ssize_t
 710policy_store(struct device *dev, struct device_attribute *attr,
 711                    const char *buf, size_t count)
 712{
 713        int ret = -EINVAL;
 714        struct thermal_zone_device *tz = to_thermal_zone(dev);
 715        struct thermal_governor *gov;
 716
 717        mutex_lock(&thermal_governor_lock);
 718
 719        gov = __find_governor(buf);
 720        if (!gov)
 721                goto exit;
 722
 723        tz->governor = gov;
 724        ret = count;
 725
 726exit:
 727        mutex_unlock(&thermal_governor_lock);
 728        return ret;
 729}
 730
 731static ssize_t
 732policy_show(struct device *dev, struct device_attribute *devattr, char *buf)
 733{
 734        struct thermal_zone_device *tz = to_thermal_zone(dev);
 735
 736        return sprintf(buf, "%s\n", tz->governor->name);
 737}
 738
 739#ifdef CONFIG_THERMAL_EMULATION
 740static ssize_t
 741emul_temp_store(struct device *dev, struct device_attribute *attr,
 742                     const char *buf, size_t count)
 743{
 744        struct thermal_zone_device *tz = to_thermal_zone(dev);
 745        int ret = 0;
 746        unsigned long temperature;
 747
 748        if (kstrtoul(buf, 10, &temperature))
 749                return -EINVAL;
 750
 751        if (!tz->ops->set_emul_temp) {
 752                mutex_lock(&tz->lock);
 753                tz->emul_temperature = temperature;
 754                mutex_unlock(&tz->lock);
 755        } else {
 756                ret = tz->ops->set_emul_temp(tz, temperature);
 757        }
 758
 759        return ret ? ret : count;
 760}
 761static DEVICE_ATTR(emul_temp, S_IWUSR, NULL, emul_temp_store);
 762#endif/*CONFIG_THERMAL_EMULATION*/
 763
 764static DEVICE_ATTR(type, 0444, type_show, NULL);
 765static DEVICE_ATTR(temp, 0444, temp_show, NULL);
 766static DEVICE_ATTR(mode, 0644, mode_show, mode_store);
 767static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store);
 768static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store);
 769
 770/* sys I/F for cooling device */
 771#define to_cooling_device(_dev) \
 772        container_of(_dev, struct thermal_cooling_device, device)
 773
 774static ssize_t
 775thermal_cooling_device_type_show(struct device *dev,
 776                                 struct device_attribute *attr, char *buf)
 777{
 778        struct thermal_cooling_device *cdev = to_cooling_device(dev);
 779
 780        return sprintf(buf, "%s\n", cdev->type);
 781}
 782
 783static ssize_t
 784thermal_cooling_device_max_state_show(struct device *dev,
 785                                      struct device_attribute *attr, char *buf)
 786{
 787        struct thermal_cooling_device *cdev = to_cooling_device(dev);
 788        unsigned long state;
 789        int ret;
 790
 791        ret = cdev->ops->get_max_state(cdev, &state);
 792        if (ret)
 793                return ret;
 794        return sprintf(buf, "%ld\n", state);
 795}
 796
 797static ssize_t
 798thermal_cooling_device_cur_state_show(struct device *dev,
 799                                      struct device_attribute *attr, char *buf)
 800{
 801        struct thermal_cooling_device *cdev = to_cooling_device(dev);
 802        unsigned long state;
 803        int ret;
 804
 805        ret = cdev->ops->get_cur_state(cdev, &state);
 806        if (ret)
 807                return ret;
 808        return sprintf(buf, "%ld\n", state);
 809}
 810
 811static ssize_t
 812thermal_cooling_device_cur_state_store(struct device *dev,
 813                                       struct device_attribute *attr,
 814                                       const char *buf, size_t count)
 815{
 816        struct thermal_cooling_device *cdev = to_cooling_device(dev);
 817        unsigned long state;
 818        int result;
 819
 820        if (!sscanf(buf, "%ld\n", &state))
 821                return -EINVAL;
 822
 823        if ((long)state < 0)
 824                return -EINVAL;
 825
 826        result = cdev->ops->set_cur_state(cdev, state);
 827        if (result)
 828                return result;
 829        return count;
 830}
 831
 832static struct device_attribute dev_attr_cdev_type =
 833__ATTR(type, 0444, thermal_cooling_device_type_show, NULL);
 834static DEVICE_ATTR(max_state, 0444,
 835                   thermal_cooling_device_max_state_show, NULL);
 836static DEVICE_ATTR(cur_state, 0644,
 837                   thermal_cooling_device_cur_state_show,
 838                   thermal_cooling_device_cur_state_store);
 839
 840static ssize_t
 841thermal_cooling_device_trip_point_show(struct device *dev,
 842                                       struct device_attribute *attr, char *buf)
 843{
 844        struct thermal_instance *instance;
 845
 846        instance =
 847            container_of(attr, struct thermal_instance, attr);
 848
 849        if (instance->trip == THERMAL_TRIPS_NONE)
 850                return sprintf(buf, "-1\n");
 851        else
 852                return sprintf(buf, "%d\n", instance->trip);
 853}
 854
 855/* Device management */
 856
 857#if defined(CONFIG_THERMAL_HWMON)
 858
 859/* hwmon sys I/F */
 860#include <linux/hwmon.h>
 861
 862/* thermal zone devices with the same type share one hwmon device */
 863struct thermal_hwmon_device {
 864        char type[THERMAL_NAME_LENGTH];
 865        struct device *device;
 866        int count;
 867        struct list_head tz_list;
 868        struct list_head node;
 869};
 870
 871struct thermal_hwmon_attr {
 872        struct device_attribute attr;
 873        char name[16];
 874};
 875
 876/* one temperature input for each thermal zone */
 877struct thermal_hwmon_temp {
 878        struct list_head hwmon_node;
 879        struct thermal_zone_device *tz;
 880        struct thermal_hwmon_attr temp_input;   /* hwmon sys attr */
 881        struct thermal_hwmon_attr temp_crit;    /* hwmon sys attr */
 882};
 883
 884static LIST_HEAD(thermal_hwmon_list);
 885
 886static ssize_t
 887name_show(struct device *dev, struct device_attribute *attr, char *buf)
 888{
 889        struct thermal_hwmon_device *hwmon = dev_get_drvdata(dev);
 890        return sprintf(buf, "%s\n", hwmon->type);
 891}
 892static DEVICE_ATTR(name, 0444, name_show, NULL);
 893
 894static ssize_t
 895temp_input_show(struct device *dev, struct device_attribute *attr, char *buf)
 896{
 897        long temperature;
 898        int ret;
 899        struct thermal_hwmon_attr *hwmon_attr
 900                        = container_of(attr, struct thermal_hwmon_attr, attr);
 901        struct thermal_hwmon_temp *temp
 902                        = container_of(hwmon_attr, struct thermal_hwmon_temp,
 903                                       temp_input);
 904        struct thermal_zone_device *tz = temp->tz;
 905
 906        ret = thermal_zone_get_temp(tz, &temperature);
 907
 908        if (ret)
 909                return ret;
 910
 911        return sprintf(buf, "%ld\n", temperature);
 912}
 913
 914static ssize_t
 915temp_crit_show(struct device *dev, struct device_attribute *attr,
 916                char *buf)
 917{
 918        struct thermal_hwmon_attr *hwmon_attr
 919                        = container_of(attr, struct thermal_hwmon_attr, attr);
 920        struct thermal_hwmon_temp *temp
 921                        = container_of(hwmon_attr, struct thermal_hwmon_temp,
 922                                       temp_crit);
 923        struct thermal_zone_device *tz = temp->tz;
 924        long temperature;
 925        int ret;
 926
 927        ret = tz->ops->get_trip_temp(tz, 0, &temperature);
 928        if (ret)
 929                return ret;
 930
 931        return sprintf(buf, "%ld\n", temperature);
 932}
 933
 934
 935static struct thermal_hwmon_device *
 936thermal_hwmon_lookup_by_type(const struct thermal_zone_device *tz)
 937{
 938        struct thermal_hwmon_device *hwmon;
 939
 940        mutex_lock(&thermal_list_lock);
 941        list_for_each_entry(hwmon, &thermal_hwmon_list, node)
 942                if (!strcmp(hwmon->type, tz->type)) {
 943                        mutex_unlock(&thermal_list_lock);
 944                        return hwmon;
 945                }
 946        mutex_unlock(&thermal_list_lock);
 947
 948        return NULL;
 949}
 950
 951/* Find the temperature input matching a given thermal zone */
 952static struct thermal_hwmon_temp *
 953thermal_hwmon_lookup_temp(const struct thermal_hwmon_device *hwmon,
 954                          const struct thermal_zone_device *tz)
 955{
 956        struct thermal_hwmon_temp *temp;
 957
 958        mutex_lock(&thermal_list_lock);
 959        list_for_each_entry(temp, &hwmon->tz_list, hwmon_node)
 960                if (temp->tz == tz) {
 961                        mutex_unlock(&thermal_list_lock);
 962                        return temp;
 963                }
 964        mutex_unlock(&thermal_list_lock);
 965
 966        return NULL;
 967}
 968
 969static int
 970thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
 971{
 972        struct thermal_hwmon_device *hwmon;
 973        struct thermal_hwmon_temp *temp;
 974        int new_hwmon_device = 1;
 975        int result;
 976
 977        hwmon = thermal_hwmon_lookup_by_type(tz);
 978        if (hwmon) {
 979                new_hwmon_device = 0;
 980                goto register_sys_interface;
 981        }
 982
 983        hwmon = kzalloc(sizeof(struct thermal_hwmon_device), GFP_KERNEL);
 984        if (!hwmon)
 985                return -ENOMEM;
 986
 987        INIT_LIST_HEAD(&hwmon->tz_list);
 988        strlcpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH);
 989        hwmon->device = hwmon_device_register(NULL);
 990        if (IS_ERR(hwmon->device)) {
 991                result = PTR_ERR(hwmon->device);
 992                goto free_mem;
 993        }
 994        dev_set_drvdata(hwmon->device, hwmon);
 995        result = device_create_file(hwmon->device, &dev_attr_name);
 996        if (result)
 997                goto free_mem;
 998
 999 register_sys_interface:
1000        temp = kzalloc(sizeof(struct thermal_hwmon_temp), GFP_KERNEL);
1001        if (!temp) {
1002                result = -ENOMEM;
1003                goto unregister_name;
1004        }
1005
1006        temp->tz = tz;
1007        hwmon->count++;
1008
1009        snprintf(temp->temp_input.name, sizeof(temp->temp_input.name),
1010                 "temp%d_input", hwmon->count);
1011        temp->temp_input.attr.attr.name = temp->temp_input.name;
1012        temp->temp_input.attr.attr.mode = 0444;
1013        temp->temp_input.attr.show = temp_input_show;
1014        sysfs_attr_init(&temp->temp_input.attr.attr);
1015        result = device_create_file(hwmon->device, &temp->temp_input.attr);
1016        if (result)
1017                goto free_temp_mem;
1018
1019        if (tz->ops->get_crit_temp) {
1020                unsigned long temperature;
1021                if (!tz->ops->get_crit_temp(tz, &temperature)) {
1022                        snprintf(temp->temp_crit.name,
1023                                 sizeof(temp->temp_crit.name),
1024                                "temp%d_crit", hwmon->count);
1025                        temp->temp_crit.attr.attr.name = temp->temp_crit.name;
1026                        temp->temp_crit.attr.attr.mode = 0444;
1027                        temp->temp_crit.attr.show = temp_crit_show;
1028                        sysfs_attr_init(&temp->temp_crit.attr.attr);
1029                        result = device_create_file(hwmon->device,
1030                                                    &temp->temp_crit.attr);
1031                        if (result)
1032                                goto unregister_input;
1033                }
1034        }
1035
1036        mutex_lock(&thermal_list_lock);
1037        if (new_hwmon_device)
1038                list_add_tail(&hwmon->node, &thermal_hwmon_list);
1039        list_add_tail(&temp->hwmon_node, &hwmon->tz_list);
1040        mutex_unlock(&thermal_list_lock);
1041
1042        return 0;
1043
1044 unregister_input:
1045        device_remove_file(hwmon->device, &temp->temp_input.attr);
1046 free_temp_mem:
1047        kfree(temp);
1048 unregister_name:
1049        if (new_hwmon_device) {
1050                device_remove_file(hwmon->device, &dev_attr_name);
1051                hwmon_device_unregister(hwmon->device);
1052        }
1053 free_mem:
1054        if (new_hwmon_device)
1055                kfree(hwmon);
1056
1057        return result;
1058}
1059
1060static void
1061thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
1062{
1063        struct thermal_hwmon_device *hwmon;
1064        struct thermal_hwmon_temp *temp;
1065
1066        hwmon = thermal_hwmon_lookup_by_type(tz);
1067        if (unlikely(!hwmon)) {
1068                /* Should never happen... */
1069                dev_dbg(&tz->device, "hwmon device lookup failed!\n");
1070                return;
1071        }
1072
1073        temp = thermal_hwmon_lookup_temp(hwmon, tz);
1074        if (unlikely(!temp)) {
1075                /* Should never happen... */
1076                dev_dbg(&tz->device, "temperature input lookup failed!\n");
1077                return;
1078        }
1079
1080        device_remove_file(hwmon->device, &temp->temp_input.attr);
1081        if (tz->ops->get_crit_temp)
1082                device_remove_file(hwmon->device, &temp->temp_crit.attr);
1083
1084        mutex_lock(&thermal_list_lock);
1085        list_del(&temp->hwmon_node);
1086        kfree(temp);
1087        if (!list_empty(&hwmon->tz_list)) {
1088                mutex_unlock(&thermal_list_lock);
1089                return;
1090        }
1091        list_del(&hwmon->node);
1092        mutex_unlock(&thermal_list_lock);
1093
1094        device_remove_file(hwmon->device, &dev_attr_name);
1095        hwmon_device_unregister(hwmon->device);
1096        kfree(hwmon);
1097}
1098#else
1099static int
1100thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
1101{
1102        return 0;
1103}
1104
1105static void
1106thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
1107{
1108}
1109#endif
1110
1111/**
1112 * thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone
1113 * @tz:         pointer to struct thermal_zone_device
1114 * @trip:       indicates which trip point the cooling devices is
1115 *              associated with in this thermal zone.
1116 * @cdev:       pointer to struct thermal_cooling_device
1117 * @upper:      the Maximum cooling state for this trip point.
1118 *              THERMAL_NO_LIMIT means no upper limit,
1119 *              and the cooling device can be in max_state.
1120 * @lower:      the Minimum cooling state can be used for this trip point.
1121 *              THERMAL_NO_LIMIT means no lower limit,
1122 *              and the cooling device can be in cooling state 0.
1123 *
1124 * This interface function bind a thermal cooling device to the certain trip
1125 * point of a thermal zone device.
1126 * This function is usually called in the thermal zone device .bind callback.
1127 *
1128 * Return: 0 on success, the proper error value otherwise.
1129 */
1130int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
1131                                     int trip,
1132                                     struct thermal_cooling_device *cdev,
1133                                     unsigned long upper, unsigned long lower)
1134{
1135        struct thermal_instance *dev;
1136        struct thermal_instance *pos;
1137        struct thermal_zone_device *pos1;
1138        struct thermal_cooling_device *pos2;
1139        unsigned long max_state;
1140        int result;
1141
1142        if (trip >= tz->trips || (trip < 0 && trip != THERMAL_TRIPS_NONE))
1143                return -EINVAL;
1144
1145        list_for_each_entry(pos1, &thermal_tz_list, node) {
1146                if (pos1 == tz)
1147                        break;
1148        }
1149        list_for_each_entry(pos2, &thermal_cdev_list, node) {
1150                if (pos2 == cdev)
1151                        break;
1152        }
1153
1154        if (tz != pos1 || cdev != pos2)
1155                return -EINVAL;
1156
1157        cdev->ops->get_max_state(cdev, &max_state);
1158
1159        /* lower default 0, upper default max_state */
1160        lower = lower == THERMAL_NO_LIMIT ? 0 : lower;
1161        upper = upper == THERMAL_NO_LIMIT ? max_state : upper;
1162
1163        if (lower > upper || upper > max_state)
1164                return -EINVAL;
1165
1166        dev =
1167            kzalloc(sizeof(struct thermal_instance), GFP_KERNEL);
1168        if (!dev)
1169                return -ENOMEM;
1170        dev->tz = tz;
1171        dev->cdev = cdev;
1172        dev->trip = trip;
1173        dev->upper = upper;
1174        dev->lower = lower;
1175        dev->target = THERMAL_NO_TARGET;
1176
1177        result = get_idr(&tz->idr, &tz->lock, &dev->id);
1178        if (result)
1179                goto free_mem;
1180
1181        sprintf(dev->name, "cdev%d", dev->id);
1182        result =
1183            sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);
1184        if (result)
1185                goto release_idr;
1186
1187        sprintf(dev->attr_name, "cdev%d_trip_point", dev->id);
1188        sysfs_attr_init(&dev->attr.attr);
1189        dev->attr.attr.name = dev->attr_name;
1190        dev->attr.attr.mode = 0444;
1191        dev->attr.show = thermal_cooling_device_trip_point_show;
1192        result = device_create_file(&tz->device, &dev->attr);
1193        if (result)
1194                goto remove_symbol_link;
1195
1196        mutex_lock(&tz->lock);
1197        mutex_lock(&cdev->lock);
1198        list_for_each_entry(pos, &tz->thermal_instances, tz_node)
1199            if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
1200                result = -EEXIST;
1201                break;
1202        }
1203        if (!result) {
1204                list_add_tail(&dev->tz_node, &tz->thermal_instances);
1205                list_add_tail(&dev->cdev_node, &cdev->thermal_instances);
1206        }
1207        mutex_unlock(&cdev->lock);
1208        mutex_unlock(&tz->lock);
1209
1210        if (!result)
1211                return 0;
1212
1213        device_remove_file(&tz->device, &dev->attr);
1214remove_symbol_link:
1215        sysfs_remove_link(&tz->device.kobj, dev->name);
1216release_idr:
1217        release_idr(&tz->idr, &tz->lock, dev->id);
1218free_mem:
1219        kfree(dev);
1220        return result;
1221}
1222EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device);
1223
1224/**
1225 * thermal_zone_unbind_cooling_device() - unbind a cooling device from a
1226 *                                        thermal zone.
1227 * @tz:         pointer to a struct thermal_zone_device.
1228 * @trip:       indicates which trip point the cooling devices is
1229 *              associated with in this thermal zone.
1230 * @cdev:       pointer to a struct thermal_cooling_device.
1231 *
1232 * This interface function unbind a thermal cooling device from the certain
1233 * trip point of a thermal zone device.
1234 * This function is usually called in the thermal zone device .unbind callback.
1235 *
1236 * Return: 0 on success, the proper error value otherwise.
1237 */
1238int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
1239                                       int trip,
1240                                       struct thermal_cooling_device *cdev)
1241{
1242        struct thermal_instance *pos, *next;
1243
1244        mutex_lock(&tz->lock);
1245        mutex_lock(&cdev->lock);
1246        list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) {
1247                if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
1248                        list_del(&pos->tz_node);
1249                        list_del(&pos->cdev_node);
1250                        mutex_unlock(&cdev->lock);
1251                        mutex_unlock(&tz->lock);
1252                        goto unbind;
1253                }
1254        }
1255        mutex_unlock(&cdev->lock);
1256        mutex_unlock(&tz->lock);
1257
1258        return -ENODEV;
1259
1260unbind:
1261        device_remove_file(&tz->device, &pos->attr);
1262        sysfs_remove_link(&tz->device.kobj, pos->name);
1263        release_idr(&tz->idr, &tz->lock, pos->id);
1264        kfree(pos);
1265        return 0;
1266}
1267EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device);
1268
1269static void thermal_release(struct device *dev)
1270{
1271        struct thermal_zone_device *tz;
1272        struct thermal_cooling_device *cdev;
1273
1274        if (!strncmp(dev_name(dev), "thermal_zone",
1275                     sizeof("thermal_zone") - 1)) {
1276                tz = to_thermal_zone(dev);
1277                kfree(tz);
1278        } else {
1279                cdev = to_cooling_device(dev);
1280                kfree(cdev);
1281        }
1282}
1283
1284static struct class thermal_class = {
1285        .name = "thermal",
1286        .dev_release = thermal_release,
1287};
1288
1289/**
1290 * thermal_cooling_device_register() - register a new thermal cooling device
1291 * @type:       the thermal cooling device type.
1292 * @devdata:    device private data.
1293 * @ops:                standard thermal cooling devices callbacks.
1294 *
1295 * This interface function adds a new thermal cooling device (fan/processor/...)
1296 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1297 * to all the thermal zone devices registered at the same time.
1298 *
1299 * Return: a pointer to the created struct thermal_cooling_device or an
1300 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1301 */
1302struct thermal_cooling_device *
1303thermal_cooling_device_register(char *type, void *devdata,
1304                                const struct thermal_cooling_device_ops *ops)
1305{
1306        struct thermal_cooling_device *cdev;
1307        int result;
1308
1309        if (type && strlen(type) >= THERMAL_NAME_LENGTH)
1310                return ERR_PTR(-EINVAL);
1311
1312        if (!ops || !ops->get_max_state || !ops->get_cur_state ||
1313            !ops->set_cur_state)
1314                return ERR_PTR(-EINVAL);
1315
1316        cdev = kzalloc(sizeof(struct thermal_cooling_device), GFP_KERNEL);
1317        if (!cdev)
1318                return ERR_PTR(-ENOMEM);
1319
1320        result = get_idr(&thermal_cdev_idr, &thermal_idr_lock, &cdev->id);
1321        if (result) {
1322                kfree(cdev);
1323                return ERR_PTR(result);
1324        }
1325
1326        strlcpy(cdev->type, type ? : "", sizeof(cdev->type));
1327        mutex_init(&cdev->lock);
1328        INIT_LIST_HEAD(&cdev->thermal_instances);
1329        cdev->ops = ops;
1330        cdev->updated = true;
1331        cdev->device.class = &thermal_class;
1332        cdev->devdata = devdata;
1333        dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
1334        result = device_register(&cdev->device);
1335        if (result) {
1336                release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
1337                kfree(cdev);
1338                return ERR_PTR(result);
1339        }
1340
1341        /* sys I/F */
1342        if (type) {
1343                result = device_create_file(&cdev->device, &dev_attr_cdev_type);
1344                if (result)
1345                        goto unregister;
1346        }
1347
1348        result = device_create_file(&cdev->device, &dev_attr_max_state);
1349        if (result)
1350                goto unregister;
1351
1352        result = device_create_file(&cdev->device, &dev_attr_cur_state);
1353        if (result)
1354                goto unregister;
1355
1356        /* Add 'this' new cdev to the global cdev list */
1357        mutex_lock(&thermal_list_lock);
1358        list_add(&cdev->node, &thermal_cdev_list);
1359        mutex_unlock(&thermal_list_lock);
1360
1361        /* Update binding information for 'this' new cdev */
1362        bind_cdev(cdev);
1363
1364        return cdev;
1365
1366unregister:
1367        release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
1368        device_unregister(&cdev->device);
1369        return ERR_PTR(result);
1370}
1371EXPORT_SYMBOL_GPL(thermal_cooling_device_register);
1372
1373/**
1374 * thermal_cooling_device_unregister - removes the registered thermal cooling device
1375 * @cdev:       the thermal cooling device to remove.
1376 *
1377 * thermal_cooling_device_unregister() must be called when the device is no
1378 * longer needed.
1379 */
1380void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev)
1381{
1382        int i;
1383        const struct thermal_zone_params *tzp;
1384        struct thermal_zone_device *tz;
1385        struct thermal_cooling_device *pos = NULL;
1386
1387        if (!cdev)
1388                return;
1389
1390        mutex_lock(&thermal_list_lock);
1391        list_for_each_entry(pos, &thermal_cdev_list, node)
1392            if (pos == cdev)
1393                break;
1394        if (pos != cdev) {
1395                /* thermal cooling device not found */
1396                mutex_unlock(&thermal_list_lock);
1397                return;
1398        }
1399        list_del(&cdev->node);
1400
1401        /* Unbind all thermal zones associated with 'this' cdev */
1402        list_for_each_entry(tz, &thermal_tz_list, node) {
1403                if (tz->ops->unbind) {
1404                        tz->ops->unbind(tz, cdev);
1405                        continue;
1406                }
1407
1408                if (!tz->tzp || !tz->tzp->tbp)
1409                        continue;
1410
1411                tzp = tz->tzp;
1412                for (i = 0; i < tzp->num_tbps; i++) {
1413                        if (tzp->tbp[i].cdev == cdev) {
1414                                __unbind(tz, tzp->tbp[i].trip_mask, cdev);
1415                                tzp->tbp[i].cdev = NULL;
1416                        }
1417                }
1418        }
1419
1420        mutex_unlock(&thermal_list_lock);
1421
1422        if (cdev->type[0])
1423                device_remove_file(&cdev->device, &dev_attr_cdev_type);
1424        device_remove_file(&cdev->device, &dev_attr_max_state);
1425        device_remove_file(&cdev->device, &dev_attr_cur_state);
1426
1427        release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
1428        device_unregister(&cdev->device);
1429        return;
1430}
1431EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister);
1432
1433void thermal_cdev_update(struct thermal_cooling_device *cdev)
1434{
1435        struct thermal_instance *instance;
1436        unsigned long target = 0;
1437
1438        /* cooling device is updated*/
1439        if (cdev->updated)
1440                return;
1441
1442        mutex_lock(&cdev->lock);
1443        /* Make sure cdev enters the deepest cooling state */
1444        list_for_each_entry(instance, &cdev->thermal_instances, cdev_node) {
1445                if (instance->target == THERMAL_NO_TARGET)
1446                        continue;
1447                if (instance->target > target)
1448                        target = instance->target;
1449        }
1450        mutex_unlock(&cdev->lock);
1451        cdev->ops->set_cur_state(cdev, target);
1452        cdev->updated = true;
1453}
1454EXPORT_SYMBOL(thermal_cdev_update);
1455
1456/**
1457 * thermal_notify_framework - Sensor drivers use this API to notify framework
1458 * @tz:         thermal zone device
1459 * @trip:       indicates which trip point has been crossed
1460 *
1461 * This function handles the trip events from sensor drivers. It starts
1462 * throttling the cooling devices according to the policy configured.
1463 * For CRITICAL and HOT trip points, this notifies the respective drivers,
1464 * and does actual throttling for other trip points i.e ACTIVE and PASSIVE.
1465 * The throttling policy is based on the configured platform data; if no
1466 * platform data is provided, this uses the step_wise throttling policy.
1467 */
1468void thermal_notify_framework(struct thermal_zone_device *tz, int trip)
1469{
1470        handle_thermal_trip(tz, trip);
1471}
1472EXPORT_SYMBOL_GPL(thermal_notify_framework);
1473
1474/**
1475 * create_trip_attrs() - create attributes for trip points
1476 * @tz:         the thermal zone device
1477 * @mask:       Writeable trip point bitmap.
1478 *
1479 * helper function to instantiate sysfs entries for every trip
1480 * point and its properties of a struct thermal_zone_device.
1481 *
1482 * Return: 0 on success, the proper error value otherwise.
1483 */
1484static int create_trip_attrs(struct thermal_zone_device *tz, int mask)
1485{
1486        int indx;
1487        int size = sizeof(struct thermal_attr) * tz->trips;
1488
1489        tz->trip_type_attrs = kzalloc(size, GFP_KERNEL);
1490        if (!tz->trip_type_attrs)
1491                return -ENOMEM;
1492
1493        tz->trip_temp_attrs = kzalloc(size, GFP_KERNEL);
1494        if (!tz->trip_temp_attrs) {
1495                kfree(tz->trip_type_attrs);
1496                return -ENOMEM;
1497        }
1498
1499        if (tz->ops->get_trip_hyst) {
1500                tz->trip_hyst_attrs = kzalloc(size, GFP_KERNEL);
1501                if (!tz->trip_hyst_attrs) {
1502                        kfree(tz->trip_type_attrs);
1503                        kfree(tz->trip_temp_attrs);
1504                        return -ENOMEM;
1505                }
1506        }
1507
1508
1509        for (indx = 0; indx < tz->trips; indx++) {
1510                /* create trip type attribute */
1511                snprintf(tz->trip_type_attrs[indx].name, THERMAL_NAME_LENGTH,
1512                         "trip_point_%d_type", indx);
1513
1514                sysfs_attr_init(&tz->trip_type_attrs[indx].attr.attr);
1515                tz->trip_type_attrs[indx].attr.attr.name =
1516                                                tz->trip_type_attrs[indx].name;
1517                tz->trip_type_attrs[indx].attr.attr.mode = S_IRUGO;
1518                tz->trip_type_attrs[indx].attr.show = trip_point_type_show;
1519
1520                device_create_file(&tz->device,
1521                                   &tz->trip_type_attrs[indx].attr);
1522
1523                /* create trip temp attribute */
1524                snprintf(tz->trip_temp_attrs[indx].name, THERMAL_NAME_LENGTH,
1525                         "trip_point_%d_temp", indx);
1526
1527                sysfs_attr_init(&tz->trip_temp_attrs[indx].attr.attr);
1528                tz->trip_temp_attrs[indx].attr.attr.name =
1529                                                tz->trip_temp_attrs[indx].name;
1530                tz->trip_temp_attrs[indx].attr.attr.mode = S_IRUGO;
1531                tz->trip_temp_attrs[indx].attr.show = trip_point_temp_show;
1532                if (mask & (1 << indx)) {
1533                        tz->trip_temp_attrs[indx].attr.attr.mode |= S_IWUSR;
1534                        tz->trip_temp_attrs[indx].attr.store =
1535                                                        trip_point_temp_store;
1536                }
1537
1538                device_create_file(&tz->device,
1539                                   &tz->trip_temp_attrs[indx].attr);
1540
1541                /* create Optional trip hyst attribute */
1542                if (!tz->ops->get_trip_hyst)
1543                        continue;
1544                snprintf(tz->trip_hyst_attrs[indx].name, THERMAL_NAME_LENGTH,
1545                         "trip_point_%d_hyst", indx);
1546
1547                sysfs_attr_init(&tz->trip_hyst_attrs[indx].attr.attr);
1548                tz->trip_hyst_attrs[indx].attr.attr.name =
1549                                        tz->trip_hyst_attrs[indx].name;
1550                tz->trip_hyst_attrs[indx].attr.attr.mode = S_IRUGO;
1551                tz->trip_hyst_attrs[indx].attr.show = trip_point_hyst_show;
1552                if (tz->ops->set_trip_hyst) {
1553                        tz->trip_hyst_attrs[indx].attr.attr.mode |= S_IWUSR;
1554                        tz->trip_hyst_attrs[indx].attr.store =
1555                                        trip_point_hyst_store;
1556                }
1557
1558                device_create_file(&tz->device,
1559                                   &tz->trip_hyst_attrs[indx].attr);
1560        }
1561        return 0;
1562}
1563
1564static void remove_trip_attrs(struct thermal_zone_device *tz)
1565{
1566        int indx;
1567
1568        for (indx = 0; indx < tz->trips; indx++) {
1569                device_remove_file(&tz->device,
1570                                   &tz->trip_type_attrs[indx].attr);
1571                device_remove_file(&tz->device,
1572                                   &tz->trip_temp_attrs[indx].attr);
1573                if (tz->ops->get_trip_hyst)
1574                        device_remove_file(&tz->device,
1575                                  &tz->trip_hyst_attrs[indx].attr);
1576        }
1577        kfree(tz->trip_type_attrs);
1578        kfree(tz->trip_temp_attrs);
1579        kfree(tz->trip_hyst_attrs);
1580}
1581
1582/**
1583 * thermal_zone_device_register() - register a new thermal zone device
1584 * @type:       the thermal zone device type
1585 * @trips:      the number of trip points the thermal zone support
1586 * @mask:       a bit string indicating the writeablility of trip points
1587 * @devdata:    private device data
1588 * @ops:        standard thermal zone device callbacks
1589 * @tzp:        thermal zone platform parameters
1590 * @passive_delay: number of milliseconds to wait between polls when
1591 *                 performing passive cooling
1592 * @polling_delay: number of milliseconds to wait between polls when checking
1593 *                 whether trip points have been crossed (0 for interrupt
1594 *                 driven systems)
1595 *
1596 * This interface function adds a new thermal zone device (sensor) to
1597 * /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the
1598 * thermal cooling devices registered at the same time.
1599 * thermal_zone_device_unregister() must be called when the device is no
1600 * longer needed. The passive cooling depends on the .get_trend() return value.
1601 *
1602 * Return: a pointer to the created struct thermal_zone_device or an
1603 * in case of error, an ERR_PTR. Caller must check return value with
1604 * IS_ERR*() helpers.
1605 */
1606struct thermal_zone_device *thermal_zone_device_register(const char *type,
1607        int trips, int mask, void *devdata,
1608        const struct thermal_zone_device_ops *ops,
1609        const struct thermal_zone_params *tzp,
1610        int passive_delay, int polling_delay)
1611{
1612        struct thermal_zone_device *tz;
1613        enum thermal_trip_type trip_type;
1614        int result;
1615        int count;
1616        int passive = 0;
1617
1618        if (type && strlen(type) >= THERMAL_NAME_LENGTH)
1619                return ERR_PTR(-EINVAL);
1620
1621        if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips)
1622                return ERR_PTR(-EINVAL);
1623
1624        if (!ops || !ops->get_temp)
1625                return ERR_PTR(-EINVAL);
1626
1627        if (trips > 0 && !ops->get_trip_type)
1628                return ERR_PTR(-EINVAL);
1629
1630        tz = kzalloc(sizeof(struct thermal_zone_device), GFP_KERNEL);
1631        if (!tz)
1632                return ERR_PTR(-ENOMEM);
1633
1634        INIT_LIST_HEAD(&tz->thermal_instances);
1635        idr_init(&tz->idr);
1636        mutex_init(&tz->lock);
1637        result = get_idr(&thermal_tz_idr, &thermal_idr_lock, &tz->id);
1638        if (result) {
1639                kfree(tz);
1640                return ERR_PTR(result);
1641        }
1642
1643        strlcpy(tz->type, type ? : "", sizeof(tz->type));
1644        tz->ops = ops;
1645        tz->tzp = tzp;
1646        tz->device.class = &thermal_class;
1647        tz->devdata = devdata;
1648        tz->trips = trips;
1649        tz->passive_delay = passive_delay;
1650        tz->polling_delay = polling_delay;
1651
1652        dev_set_name(&tz->device, "thermal_zone%d", tz->id);
1653        result = device_register(&tz->device);
1654        if (result) {
1655                release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1656                kfree(tz);
1657                return ERR_PTR(result);
1658        }
1659
1660        /* sys I/F */
1661        if (type) {
1662                result = device_create_file(&tz->device, &dev_attr_type);
1663                if (result)
1664                        goto unregister;
1665        }
1666
1667        result = device_create_file(&tz->device, &dev_attr_temp);
1668        if (result)
1669                goto unregister;
1670
1671        if (ops->get_mode) {
1672                result = device_create_file(&tz->device, &dev_attr_mode);
1673                if (result)
1674                        goto unregister;
1675        }
1676
1677        result = create_trip_attrs(tz, mask);
1678        if (result)
1679                goto unregister;
1680
1681        for (count = 0; count < trips; count++) {
1682                tz->ops->get_trip_type(tz, count, &trip_type);
1683                if (trip_type == THERMAL_TRIP_PASSIVE)
1684                        passive = 1;
1685        }
1686
1687        if (!passive) {
1688                result = device_create_file(&tz->device, &dev_attr_passive);
1689                if (result)
1690                        goto unregister;
1691        }
1692
1693#ifdef CONFIG_THERMAL_EMULATION
1694        result = device_create_file(&tz->device, &dev_attr_emul_temp);
1695        if (result)
1696                goto unregister;
1697#endif
1698        /* Create policy attribute */
1699        result = device_create_file(&tz->device, &dev_attr_policy);
1700        if (result)
1701                goto unregister;
1702
1703        /* Update 'this' zone's governor information */
1704        mutex_lock(&thermal_governor_lock);
1705
1706        if (tz->tzp)
1707                tz->governor = __find_governor(tz->tzp->governor_name);
1708        else
1709                tz->governor = __find_governor(DEFAULT_THERMAL_GOVERNOR);
1710
1711        mutex_unlock(&thermal_governor_lock);
1712
1713        result = thermal_add_hwmon_sysfs(tz);
1714        if (result)
1715                goto unregister;
1716
1717        mutex_lock(&thermal_list_lock);
1718        list_add_tail(&tz->node, &thermal_tz_list);
1719        mutex_unlock(&thermal_list_lock);
1720
1721        /* Bind cooling devices for this zone */
1722        bind_tz(tz);
1723
1724        INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check);
1725
1726        thermal_zone_device_update(tz);
1727
1728        if (!result)
1729                return tz;
1730
1731unregister:
1732        release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1733        device_unregister(&tz->device);
1734        return ERR_PTR(result);
1735}
1736EXPORT_SYMBOL_GPL(thermal_zone_device_register);
1737
1738/**
1739 * thermal_device_unregister - removes the registered thermal zone device
1740 * @tz: the thermal zone device to remove
1741 */
1742void thermal_zone_device_unregister(struct thermal_zone_device *tz)
1743{
1744        int i;
1745        const struct thermal_zone_params *tzp;
1746        struct thermal_cooling_device *cdev;
1747        struct thermal_zone_device *pos = NULL;
1748
1749        if (!tz)
1750                return;
1751
1752        tzp = tz->tzp;
1753
1754        mutex_lock(&thermal_list_lock);
1755        list_for_each_entry(pos, &thermal_tz_list, node)
1756            if (pos == tz)
1757                break;
1758        if (pos != tz) {
1759                /* thermal zone device not found */
1760                mutex_unlock(&thermal_list_lock);
1761                return;
1762        }
1763        list_del(&tz->node);
1764
1765        /* Unbind all cdevs associated with 'this' thermal zone */
1766        list_for_each_entry(cdev, &thermal_cdev_list, node) {
1767                if (tz->ops->unbind) {
1768                        tz->ops->unbind(tz, cdev);
1769                        continue;
1770                }
1771
1772                if (!tzp || !tzp->tbp)
1773                        break;
1774
1775                for (i = 0; i < tzp->num_tbps; i++) {
1776                        if (tzp->tbp[i].cdev == cdev) {
1777                                __unbind(tz, tzp->tbp[i].trip_mask, cdev);
1778                                tzp->tbp[i].cdev = NULL;
1779                        }
1780                }
1781        }
1782
1783        mutex_unlock(&thermal_list_lock);
1784
1785        thermal_zone_device_set_polling(tz, 0);
1786
1787        if (tz->type[0])
1788                device_remove_file(&tz->device, &dev_attr_type);
1789        device_remove_file(&tz->device, &dev_attr_temp);
1790        if (tz->ops->get_mode)
1791                device_remove_file(&tz->device, &dev_attr_mode);
1792        device_remove_file(&tz->device, &dev_attr_policy);
1793        remove_trip_attrs(tz);
1794        tz->governor = NULL;
1795
1796        thermal_remove_hwmon_sysfs(tz);
1797        release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1798        idr_destroy(&tz->idr);
1799        mutex_destroy(&tz->lock);
1800        device_unregister(&tz->device);
1801        return;
1802}
1803EXPORT_SYMBOL_GPL(thermal_zone_device_unregister);
1804
1805/**
1806 * thermal_zone_get_zone_by_name() - search for a zone and returns its ref
1807 * @name: thermal zone name to fetch the temperature
1808 *
1809 * When only one zone is found with the passed name, returns a reference to it.
1810 *
1811 * Return: On success returns a reference to an unique thermal zone with
1812 * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid
1813 * paramenters, -ENODEV for not found and -EEXIST for multiple matches).
1814 */
1815struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name)
1816{
1817        struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL);
1818        unsigned int found = 0;
1819
1820        if (!name)
1821                goto exit;
1822
1823        mutex_lock(&thermal_list_lock);
1824        list_for_each_entry(pos, &thermal_tz_list, node)
1825                if (!strnicmp(name, pos->type, THERMAL_NAME_LENGTH)) {
1826                        found++;
1827                        ref = pos;
1828                }
1829        mutex_unlock(&thermal_list_lock);
1830
1831        /* nothing has been found, thus an error code for it */
1832        if (found == 0)
1833                ref = ERR_PTR(-ENODEV);
1834        else if (found > 1)
1835        /* Success only when an unique zone is found */
1836                ref = ERR_PTR(-EEXIST);
1837
1838exit:
1839        return ref;
1840}
1841EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name);
1842
1843#ifdef CONFIG_NET
1844static struct genl_family thermal_event_genl_family = {
1845        .id = GENL_ID_GENERATE,
1846        .name = THERMAL_GENL_FAMILY_NAME,
1847        .version = THERMAL_GENL_VERSION,
1848        .maxattr = THERMAL_GENL_ATTR_MAX,
1849};
1850
1851static struct genl_multicast_group thermal_event_mcgrp = {
1852        .name = THERMAL_GENL_MCAST_GROUP_NAME,
1853};
1854
1855int thermal_generate_netlink_event(struct thermal_zone_device *tz,
1856                                        enum events event)
1857{
1858        struct sk_buff *skb;
1859        struct nlattr *attr;
1860        struct thermal_genl_event *thermal_event;
1861        void *msg_header;
1862        int size;
1863        int result;
1864        static unsigned int thermal_event_seqnum;
1865
1866        if (!tz)
1867                return -EINVAL;
1868
1869        /* allocate memory */
1870        size = nla_total_size(sizeof(struct thermal_genl_event)) +
1871               nla_total_size(0);
1872
1873        skb = genlmsg_new(size, GFP_ATOMIC);
1874        if (!skb)
1875                return -ENOMEM;
1876
1877        /* add the genetlink message header */
1878        msg_header = genlmsg_put(skb, 0, thermal_event_seqnum++,
1879                                 &thermal_event_genl_family, 0,
1880                                 THERMAL_GENL_CMD_EVENT);
1881        if (!msg_header) {
1882                nlmsg_free(skb);
1883                return -ENOMEM;
1884        }
1885
1886        /* fill the data */
1887        attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT,
1888                           sizeof(struct thermal_genl_event));
1889
1890        if (!attr) {
1891                nlmsg_free(skb);
1892                return -EINVAL;
1893        }
1894
1895        thermal_event = nla_data(attr);
1896        if (!thermal_event) {
1897                nlmsg_free(skb);
1898                return -EINVAL;
1899        }
1900
1901        memset(thermal_event, 0, sizeof(struct thermal_genl_event));
1902
1903        thermal_event->orig = tz->id;
1904        thermal_event->event = event;
1905
1906        /* send multicast genetlink message */
1907        result = genlmsg_end(skb, msg_header);
1908        if (result < 0) {
1909                nlmsg_free(skb);
1910                return result;
1911        }
1912
1913        result = genlmsg_multicast(skb, 0, thermal_event_mcgrp.id, GFP_ATOMIC);
1914        if (result)
1915                dev_err(&tz->device, "Failed to send netlink event:%d", result);
1916
1917        return result;
1918}
1919EXPORT_SYMBOL_GPL(thermal_generate_netlink_event);
1920
1921static int genetlink_init(void)
1922{
1923        int result;
1924
1925        result = genl_register_family(&thermal_event_genl_family);
1926        if (result)
1927                return result;
1928
1929        result = genl_register_mc_group(&thermal_event_genl_family,
1930                                        &thermal_event_mcgrp);
1931        if (result)
1932                genl_unregister_family(&thermal_event_genl_family);
1933        return result;
1934}
1935
1936static void genetlink_exit(void)
1937{
1938        genl_unregister_family(&thermal_event_genl_family);
1939}
1940#else /* !CONFIG_NET */
1941static inline int genetlink_init(void) { return 0; }
1942static inline void genetlink_exit(void) {}
1943#endif /* !CONFIG_NET */
1944
1945static int __init thermal_register_governors(void)
1946{
1947        int result;
1948
1949        result = thermal_gov_step_wise_register();
1950        if (result)
1951                return result;
1952
1953        result = thermal_gov_fair_share_register();
1954        if (result)
1955                return result;
1956
1957        return thermal_gov_user_space_register();
1958}
1959
1960static void thermal_unregister_governors(void)
1961{
1962        thermal_gov_step_wise_unregister();
1963        thermal_gov_fair_share_unregister();
1964        thermal_gov_user_space_unregister();
1965}
1966
1967static int __init thermal_init(void)
1968{
1969        int result;
1970
1971        result = thermal_register_governors();
1972        if (result)
1973                goto error;
1974
1975        result = class_register(&thermal_class);
1976        if (result)
1977                goto unregister_governors;
1978
1979        result = genetlink_init();
1980        if (result)
1981                goto unregister_class;
1982
1983        return 0;
1984
1985unregister_governors:
1986        thermal_unregister_governors();
1987unregister_class:
1988        class_unregister(&thermal_class);
1989error:
1990        idr_destroy(&thermal_tz_idr);
1991        idr_destroy(&thermal_cdev_idr);
1992        mutex_destroy(&thermal_idr_lock);
1993        mutex_destroy(&thermal_list_lock);
1994        mutex_destroy(&thermal_governor_lock);
1995        return result;
1996}
1997
1998static void __exit thermal_exit(void)
1999{
2000        genetlink_exit();
2001        class_unregister(&thermal_class);
2002        thermal_unregister_governors();
2003        idr_destroy(&thermal_tz_idr);
2004        idr_destroy(&thermal_cdev_idr);
2005        mutex_destroy(&thermal_idr_lock);
2006        mutex_destroy(&thermal_list_lock);
2007        mutex_destroy(&thermal_governor_lock);
2008}
2009
2010fs_initcall(thermal_init);
2011module_exit(thermal_exit);
2012
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.