drivers/thermal/intel/intel_quark_dts_thermal.c

   1 /*
   2  * intel_quark_dts_thermal.c
   3  *
   4  * This file is provided under a dual BSD/GPLv2 license.  When using or
   5  * redistributing this file, you may do so under either license.
   6  *
   7  * GPL LICENSE SUMMARY
   8  *
   9  * Copyright(c) 2015 Intel Corporation.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of version 2 of the GNU General Public License as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * Contact Information:
  21  *  Ong Boon Leong <boon.leong.ong@intel.com>
  22  *  Intel Malaysia, Penang
  23  *
  24  * BSD LICENSE
  25  *
  26  * Copyright(c) 2015 Intel Corporation.
  27  *
  28  * Redistribution and use in source and binary forms, with or without
  29  * modification, are permitted provided that the following conditions
  30  * are met:
  31  *
  32  *   * Redistributions of source code must retain the above copyright
  33  *     notice, this list of conditions and the following disclaimer.
  34  *   * Redistributions in binary form must reproduce the above copyright
  35  *     notice, this list of conditions and the following disclaimer in
  36  *     the documentation and/or other materials provided with the
  37  *     distribution.
  38  *   * Neither the name of Intel Corporation nor the names of its
  39  *     contributors may be used to endorse or promote products derived
  40  *     from this software without specific prior written permission.
  41  *
  42  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  43  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  44  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  45  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  46  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  47  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  48  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  49  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  50  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  51  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  52  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  53  *
  54  * Quark DTS thermal driver is implemented by referencing
  55  * intel_soc_dts_thermal.c.
  56  */
  57
  58 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  59
  60 #include <linux/module.h>
  61 #include <linux/slab.h>
  62 #include <linux/interrupt.h>
  63 #include <linux/thermal.h>
  64 #include <asm/cpu_device_id.h>
  65 #include <asm/iosf_mbi.h>
  66
  67 /* DTS reset is programmed via QRK_MBI_UNIT_SOC */
  68 #define QRK_DTS_REG_OFFSET_RESET        0x34
  69 #define QRK_DTS_RESET_BIT               BIT(0)
  70
  71 /* DTS enable is programmed via QRK_MBI_UNIT_RMU */
  72 #define QRK_DTS_REG_OFFSET_ENABLE       0xB0
  73 #define QRK_DTS_ENABLE_BIT              BIT(15)
  74
  75 /* Temperature Register is read via QRK_MBI_UNIT_RMU */
  76 #define QRK_DTS_REG_OFFSET_TEMP         0xB1
  77 #define QRK_DTS_MASK_TEMP               0xFF
  78 #define QRK_DTS_OFFSET_TEMP             0
  79 #define QRK_DTS_OFFSET_REL_TEMP         16
  80 #define QRK_DTS_TEMP_BASE               50
  81
  82 /* Programmable Trip Point Register is configured via QRK_MBI_UNIT_RMU */
  83 #define QRK_DTS_REG_OFFSET_PTPS         0xB2
  84 #define QRK_DTS_MASK_TP_THRES           0xFF
  85 #define QRK_DTS_SHIFT_TP                8
  86 #define QRK_DTS_ID_TP_CRITICAL          0
  87 #define QRK_DTS_ID_TP_HOT               1
  88 #define QRK_DTS_SAFE_TP_THRES           105
  89
  90 /* Thermal Sensor Register Lock */
  91 #define QRK_DTS_REG_OFFSET_LOCK         0x71
  92 #define QRK_DTS_LOCK_BIT                BIT(5)
  93
  94 /* Quark DTS has 2 trip points: hot & catastrophic */
  95 #define QRK_MAX_DTS_TRIPS       2
  96 /* If DTS not locked, all trip points are configurable */
  97 #define QRK_DTS_WR_MASK_SET     0x3
  98 /* If DTS locked, all trip points are not configurable */
  99 #define QRK_DTS_WR_MASK_CLR     0
 100
 101 #define DEFAULT_POLL_DELAY      2000
 102
 103 struct soc_sensor_entry {
 104         bool locked;
 105         u32 store_ptps;
 106         u32 store_dts_enable;
 107         struct thermal_zone_device *tzone;
 108         struct thermal_trip trips[QRK_MAX_DTS_TRIPS];
 109 };
 110
 111 static struct soc_sensor_entry *soc_dts;
 112
 113 static int polling_delay = DEFAULT_POLL_DELAY;
 114 module_param(polling_delay, int, 0644);
 115 MODULE_PARM_DESC(polling_delay,
 116         "Polling interval for checking trip points (in milliseconds)");
 117
 118 static DEFINE_MUTEX(dts_update_mutex);
 119
 120 static int soc_dts_enable(struct thermal_zone_device *tzd)
 121 {
 122         u32 out;
 123         struct soc_sensor_entry *aux_entry = thermal_zone_device_priv(tzd);
 124         int ret;
 125
 126         ret = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 127                             QRK_DTS_REG_OFFSET_ENABLE, &out);
 128         if (ret)
 129                 return ret;
 130
 131         if (out & QRK_DTS_ENABLE_BIT)
 132                 return 0;
 133
 134         if (!aux_entry->locked) {
 135                 out |= QRK_DTS_ENABLE_BIT;
 136                 ret = iosf_mbi_write(QRK_MBI_UNIT_RMU, MBI_REG_WRITE,
 137                                      QRK_DTS_REG_OFFSET_ENABLE, out);
 138                 if (ret)
 139                         return ret;
 140         } else {
 141                 pr_info("DTS is locked. Cannot enable DTS\n");
 142                 ret = -EPERM;
 143         }
 144
 145         return ret;
 146 }
 147
 148 static int soc_dts_disable(struct thermal_zone_device *tzd)
 149 {
 150         u32 out;
 151         struct soc_sensor_entry *aux_entry = thermal_zone_device_priv(tzd);
 152         int ret;
 153
 154         ret = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 155                             QRK_DTS_REG_OFFSET_ENABLE, &out);
 156         if (ret)
 157                 return ret;
 158
 159         if (!(out & QRK_DTS_ENABLE_BIT))
 160                 return 0;
 161
 162         if (!aux_entry->locked) {
 163                 out &= ~QRK_DTS_ENABLE_BIT;
 164                 ret = iosf_mbi_write(QRK_MBI_UNIT_RMU, MBI_REG_WRITE,
 165                                      QRK_DTS_REG_OFFSET_ENABLE, out);
 166
 167                 if (ret)
 168                         return ret;
 169         } else {
 170                 pr_info("DTS is locked. Cannot disable DTS\n");
 171                 ret = -EPERM;
 172         }
 173
 174         return ret;
 175 }
 176
 177 static int get_trip_temp(int trip)
 178 {
 179         int status, temp;
 180         u32 out;
 181
 182         mutex_lock(&dts_update_mutex);
 183         status = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 184                                QRK_DTS_REG_OFFSET_PTPS, &out);
 185         mutex_unlock(&dts_update_mutex);
 186
 187         if (status)
 188                 return THERMAL_TEMP_INVALID;
 189
 190         /*
 191          * Thermal Sensor Programmable Trip Point Register has 8-bit
 192          * fields for critical (catastrophic) and hot set trip point
 193          * thresholds. The threshold value is always offset by its
 194          * temperature base (50 degree Celsius).
 195          */
 196         temp = (out >> (trip * QRK_DTS_SHIFT_TP)) & QRK_DTS_MASK_TP_THRES;
 197         temp -= QRK_DTS_TEMP_BASE;
 198
 199         return temp;
 200 }
 201
 202 static int update_trip_temp(struct soc_sensor_entry *aux_entry,
 203                                 int trip, int temp)
 204 {
 205         u32 out;
 206         u32 temp_out;
 207         u32 store_ptps;
 208         int ret;
 209
 210         mutex_lock(&dts_update_mutex);
 211         if (aux_entry->locked) {
 212                 ret = -EPERM;
 213                 goto failed;
 214         }
 215
 216         ret = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 217                             QRK_DTS_REG_OFFSET_PTPS, &store_ptps);
 218         if (ret)
 219                 goto failed;
 220
 221         /*
 222          * Protection against unsafe trip point thresdhold value.
 223          * As Quark X1000 data-sheet does not provide any recommendation
 224          * regarding the safe trip point threshold value to use, we choose
 225          * the safe value according to the threshold value set by UEFI BIOS.
 226          */
 227         if (temp > QRK_DTS_SAFE_TP_THRES)
 228                 temp = QRK_DTS_SAFE_TP_THRES;
 229
 230         /*
 231          * Thermal Sensor Programmable Trip Point Register has 8-bit
 232          * fields for critical (catastrophic) and hot set trip point
 233          * thresholds. The threshold value is always offset by its
 234          * temperature base (50 degree Celsius).
 235          */
 236         temp_out = temp + QRK_DTS_TEMP_BASE;
 237         out = (store_ptps & ~(QRK_DTS_MASK_TP_THRES <<
 238                 (trip * QRK_DTS_SHIFT_TP)));
 239         out |= (temp_out & QRK_DTS_MASK_TP_THRES) <<
 240                 (trip * QRK_DTS_SHIFT_TP);
 241
 242         ret = iosf_mbi_write(QRK_MBI_UNIT_RMU, MBI_REG_WRITE,
 243                              QRK_DTS_REG_OFFSET_PTPS, out);
 244
 245 failed:
 246         mutex_unlock(&dts_update_mutex);
 247         return ret;
 248 }
 249
 250 static inline int sys_set_trip_temp(struct thermal_zone_device *tzd, int trip,
 251                                 int temp)
 252 {
 253         return update_trip_temp(thermal_zone_device_priv(tzd), trip, temp);
 254 }
 255
 256 static int sys_get_curr_temp(struct thermal_zone_device *tzd,
 257                                 int *temp)
 258 {
 259         u32 out;
 260         int ret;
 261
 262         mutex_lock(&dts_update_mutex);
 263         ret = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 264                             QRK_DTS_REG_OFFSET_TEMP, &out);
 265         mutex_unlock(&dts_update_mutex);
 266
 267         if (ret)
 268                 return ret;
 269
 270         /*
 271          * Thermal Sensor Temperature Register has 8-bit field
 272          * for temperature value (offset by temperature base
 273          * 50 degree Celsius).
 274          */
 275         out = (out >> QRK_DTS_OFFSET_TEMP) & QRK_DTS_MASK_TEMP;
 276         *temp = out - QRK_DTS_TEMP_BASE;
 277
 278         return 0;
 279 }
 280
 281 static int sys_change_mode(struct thermal_zone_device *tzd,
 282                            enum thermal_device_mode mode)
 283 {
 284         int ret;
 285
 286         mutex_lock(&dts_update_mutex);
 287         if (mode == THERMAL_DEVICE_ENABLED)
 288                 ret = soc_dts_enable(tzd);
 289         else
 290                 ret = soc_dts_disable(tzd);
 291         mutex_unlock(&dts_update_mutex);
 292
 293         return ret;
 294 }
 295
 296 static struct thermal_zone_device_ops tzone_ops = {
 297         .get_temp = sys_get_curr_temp,
 298         .set_trip_temp = sys_set_trip_temp,
 299         .change_mode = sys_change_mode,
 300 };
 301
 302 static void free_soc_dts(struct soc_sensor_entry *aux_entry)
 303 {
 304         if (aux_entry) {
 305                 if (!aux_entry->locked) {
 306                         mutex_lock(&dts_update_mutex);
 307                         iosf_mbi_write(QRK_MBI_UNIT_RMU, MBI_REG_WRITE,
 308                                        QRK_DTS_REG_OFFSET_ENABLE,
 309                                        aux_entry->store_dts_enable);
 310
 311                         iosf_mbi_write(QRK_MBI_UNIT_RMU, MBI_REG_WRITE,
 312                                        QRK_DTS_REG_OFFSET_PTPS,
 313                                        aux_entry->store_ptps);
 314                         mutex_unlock(&dts_update_mutex);
 315                 }
 316                 thermal_zone_device_unregister(aux_entry->tzone);
 317                 kfree(aux_entry);
 318         }
 319 }
 320
 321 static struct soc_sensor_entry *alloc_soc_dts(void)
 322 {
 323         struct soc_sensor_entry *aux_entry;
 324         int err;
 325         u32 out;
 326         int wr_mask;
 327
 328         aux_entry = kzalloc(sizeof(*aux_entry), GFP_KERNEL);
 329         if (!aux_entry) {
 330                 err = -ENOMEM;
 331                 return ERR_PTR(-ENOMEM);
 332         }
 333
 334         /* Check if DTS register is locked */
 335         err = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 336                             QRK_DTS_REG_OFFSET_LOCK, &out);
 337         if (err)
 338                 goto err_ret;
 339
 340         if (out & QRK_DTS_LOCK_BIT) {
 341                 aux_entry->locked = true;
 342                 wr_mask = QRK_DTS_WR_MASK_CLR;
 343         } else {
 344                 aux_entry->locked = false;
 345                 wr_mask = QRK_DTS_WR_MASK_SET;
 346         }
 347
 348         /* Store DTS default state if DTS registers are not locked */
 349         if (!aux_entry->locked) {
 350                 /* Store DTS default enable for restore on exit */
 351                 err = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 352                                     QRK_DTS_REG_OFFSET_ENABLE,
 353                                     &aux_entry->store_dts_enable);
 354                 if (err)
 355                         goto err_ret;
 356
 357                 /* Store DTS default PTPS register for restore on exit */
 358                 err = iosf_mbi_read(QRK_MBI_UNIT_RMU, MBI_REG_READ,
 359                                     QRK_DTS_REG_OFFSET_PTPS,
 360                                     &aux_entry->store_ptps);
 361                 if (err)
 362                         goto err_ret;
 363         }
 364
 365         aux_entry->trips[QRK_DTS_ID_TP_CRITICAL].temperature = get_trip_temp(QRK_DTS_ID_TP_CRITICAL);
 366         aux_entry->trips[QRK_DTS_ID_TP_CRITICAL].type = THERMAL_TRIP_CRITICAL;
 367
 368         aux_entry->trips[QRK_DTS_ID_TP_HOT].temperature = get_trip_temp(QRK_DTS_ID_TP_HOT);
 369         aux_entry->trips[QRK_DTS_ID_TP_HOT].type = THERMAL_TRIP_HOT;
 370
 371         aux_entry->tzone = thermal_zone_device_register_with_trips("quark_dts",
 372                                                                    aux_entry->trips,
 373                                                                    QRK_MAX_DTS_TRIPS,
 374                                                                    wr_mask,
 375                                                                    aux_entry, &tzone_ops,
 376                                                                    NULL, 0, polling_delay);
 377         if (IS_ERR(aux_entry->tzone)) {
 378                 err = PTR_ERR(aux_entry->tzone);
 379                 goto err_ret;
 380         }
 381
 382         err = thermal_zone_device_enable(aux_entry->tzone);
 383         if (err)
 384                 goto err_aux_status;
 385
 386         return aux_entry;
 387
 388 err_aux_status:
 389         thermal_zone_device_unregister(aux_entry->tzone);
 390 err_ret:
 391         kfree(aux_entry);
 392         return ERR_PTR(err);
 393 }
 394
 395 static const struct x86_cpu_id qrk_thermal_ids[] __initconst  = {
 396         X86_MATCH_VENDOR_FAM_MODEL(INTEL, 5, INTEL_FAM5_QUARK_X1000, NULL),
 397         {}
 398 };
 399 MODULE_DEVICE_TABLE(x86cpu, qrk_thermal_ids);
 400
 401 static int __init intel_quark_thermal_init(void)
 402 {
 403         if (!x86_match_cpu(qrk_thermal_ids) || !iosf_mbi_available())
 404                 return -ENODEV;
 405
 406         soc_dts = alloc_soc_dts();
 407         if (IS_ERR(soc_dts))
 408                 return PTR_ERR(soc_dts);
 409
 410         return 0;
 411 }
 412
 413 static void __exit intel_quark_thermal_exit(void)
 414 {
 415         free_soc_dts(soc_dts);
 416 }
 417
 418 module_init(intel_quark_thermal_init)
 419 module_exit(intel_quark_thermal_exit)
 420
 421 MODULE_DESCRIPTION("Intel Quark DTS Thermal Driver");
 422 MODULE_AUTHOR("Ong Boon Leong <boon.leong.ong@intel.com>");
 423 MODULE_LICENSE("Dual BSD/GPL");