drivers/misc/nct1008.c

   1 /*
   2  * drivers/misc/nct1008.c
   3  *
   4  * Driver for NCT1008, temperature monitoring device from ON Semiconductors
   5  *
   6  * Copyright (c) 2010-2016, NVIDIA CORPORATION.  All rights reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21  */
  22
  23
  24 #include <linux/interrupt.h>
  25 #include <linux/module.h>
  26 #include <linux/i2c.h>
  27 #include <linux/slab.h>
  28 #include <linux/err.h>
  29 #include <linux/gpio.h>
  30 #include <linux/device.h>
  31 #include <linux/nct1008.h>
  32 #include <linux/of_gpio.h>
  33 #include <linux/delay.h>
  34 #include <linux/thermal.h>
  35 #include <linux/regulator/consumer.h>
  36
  37 /* Register Addresses used in this module. */
  38 #define LOC_TEMP_RD                  0x00
  39 #define EXT_TEMP_HI_RD               0x01
  40 #define STATUS_RD                    0x02
  41 #define CONFIG_RD                    0x03
  42 #define CONV_RATE_RD                 0x04
  43 #define LOC_TEMP_HI_LIMIT_RD         0x05
  44 #define LOC_TEMP_LO_LIMIT_RD         0x06
  45 #define EXT_TEMP_HI_LIMIT_HI_BYTE_RD 0x07
  46 #define EXT_TEMP_LO_LIMIT_HI_BYTE_RD 0x08
  47 #define CONFIG_WR                    0x09
  48 #define CONV_RATE_WR                 0x0A
  49 #define LOC_TEMP_HI_LIMIT_WR         0x0B
  50 #define LOC_TEMP_LO_LIMIT_WR         0x0C
  51 #define EXT_TEMP_HI_LIMIT_HI_BYTE_WR 0x0D
  52 #define EXT_TEMP_LO_LIMIT_HI_BYTE_WR 0x0E
  53 #define ONE_SHOT                     0x0F
  54 #define EXT_TEMP_LO_RD               0x10
  55 #define OFFSET_WR                    0x11
  56 #define OFFSET_QUARTER_WR            0x12
  57 #define EXT_TEMP_HI_LIMIT_LO_BYTE    0x13
  58 #define EXT_TEMP_LO_LIMIT_LO_BYTE    0x14
  59 /* NOT USED                          0x15 */
  60 /* NOT USED                          0x16 */
  61 /* NOT USED                          0x17 */
  62 /* NOT USED                          0x18 */
  63 #define EXT_THERM_LIMIT_WR           0x19
  64 /* NOT USED                          0x1A */
  65 /* NOT USED                          0x1B */
  66 /* NOT USED                          0x1C */
  67 /* NOT USED                          0x1D */
  68 /* NOT USED                          0x1E */
  69 /* NOT USED                          0x1F */
  70 #define LOC_THERM_LIMIT              0x20
  71 #define THERM_HYSTERESIS             0x21
  72 #define COSECUTIVE_ALERT             0x22
  73
  74 /* Set of register types that are sensor dependant. */
  75 enum nct1008_sensor_reg_types {
  76         TEMP_HI_LIMIT, TEMP_LO_LIMIT,
  77         TEMP_HI_LIMIT_RD, TEMP_LO_LIMIT_RD,
  78         TEMP_HI_LIMIT_WR, TEMP_LO_LIMIT_WR,
  79         TEMP_RD_LO, TEMP_RD_HI,
  80         TEMP_RD, TEMP_WR,
  81         REGS_COUNT /* This has to be the last element! */
  82 };
  83
  84 /* Mapping from register type on a given sensor to hardware specific address. */
  85 static int nct1008_sensor_regs[SENSORS_COUNT][REGS_COUNT] = {
  86         [LOC] = {
  87                 [TEMP_HI_LIMIT_RD] = LOC_TEMP_HI_LIMIT_RD,
  88                 [TEMP_HI_LIMIT_WR] = LOC_TEMP_HI_LIMIT_WR,
  89                 [TEMP_LO_LIMIT_RD] = LOC_TEMP_LO_LIMIT_RD,
  90                 [TEMP_LO_LIMIT_WR] = LOC_TEMP_LO_LIMIT_WR,
  91         },
  92         [EXT] = {
  93                 [TEMP_HI_LIMIT_RD] = EXT_TEMP_HI_LIMIT_HI_BYTE_RD,
  94                 [TEMP_HI_LIMIT_WR] = EXT_TEMP_HI_LIMIT_HI_BYTE_WR,
  95                 [TEMP_LO_LIMIT_RD] = EXT_TEMP_LO_LIMIT_HI_BYTE_RD,
  96                 [TEMP_LO_LIMIT_WR] = EXT_TEMP_LO_LIMIT_HI_BYTE_WR,
  97                 [TEMP_RD_LO] = EXT_TEMP_LO_RD,
  98                 [TEMP_RD_HI] = EXT_TEMP_HI_RD,
  99         },
 100 };
 101
 102 /* Accessor to the sensor specific registers. */
 103 #define NCT_REG(x, y) nct1008_sensor_regs[x][y]
 104
 105 /* Configuration register bits. */
 106 #define EXTENDED_RANGE_BIT BIT(2)
 107 #define THERM2_BIT         BIT(5)
 108 #define STANDBY_BIT        BIT(6)
 109 #define ALERT_BIT          BIT(7)
 110
 111 /* Status register trip point bits. */
 112 #define EXT_LO_BIT BIT(3) /* External Sensor has tripped 'temp <= LOW' */
 113 #define EXT_HI_BIT BIT(4) /* External Sensor has tripped 'temp > HIGH' */
 114 #define LOC_LO_BIT BIT(5) /* Local Sensor has tripped 'temp <= LOW' */
 115 #define LOC_HI_BIT BIT(6) /* Local Sensor has tripped 'temp > HIGH' */
 116
 117 /* Constants.  */
 118 #define EXTENDED_RANGE_OFFSET 64U
 119 #define STANDARD_RANGE_MAX    127U
 120 #define EXTENDED_RANGE_MAX   (150U + EXTENDED_RANGE_OFFSET)
 121
 122 #define NCT1008_MIN_TEMP       (-64)
 123 #define NCT1008_MAX_TEMP         191
 124 #define NCT1008_MAX_TEMP_MILLI   191750
 125
 126 #define MAX_STR_PRINT            50
 127 #define MAX_CONV_TIME_ONESHOT_MS 52
 128
 129 #define CELSIUS_TO_MILLICELSIUS(x) ((x)*1000)
 130 #define MILLICELSIUS_TO_CELSIUS(x) ((x)/1000)
 131
 132 struct nct1008_adjust_offset_table {
 133         int temp;
 134         int offset;
 135 };
 136
 137 struct nct1008_sensor_data {
 138         struct nct1008_adjust_offset_table offset_table[16];
 139         struct thermal_zone_device *thz;
 140         long current_hi_limit;
 141         long current_lo_limit;
 142         int temp;
 143 };
 144
 145 struct nct1008_data {
 146         struct workqueue_struct *workqueue;
 147         struct work_struct work;
 148         struct i2c_client *client;
 149         struct nct1008_platform_data plat_data;
 150         struct mutex mutex;
 151         u8 config;
 152         enum nct1008_chip chip;
 153         struct regulator *nct_reg;
 154         int conv_period_ms;
 155         int nct_disabled;
 156         int stop_workqueue;
 157
 158         struct nct1008_sensor_data sensors[SENSORS_COUNT];
 159 };
 160
 161 static int conv_period_ms_table[] =
 162         {16000, 8000, 4000, 2000, 1000, 500, 250, 125, 63, 32, 16};
 163
 164 static void nct1008_setup_shutdown_warning(struct nct1008_data *data);
 165
 166 static inline s16 value_to_temperature(bool extended, u8 value)
 167 {
 168         return extended ? (s16)(value - EXTENDED_RANGE_OFFSET) : (s16)value;
 169 }
 170
 171 static inline u8 temperature_to_value(bool extended, s16 temp)
 172 {
 173         return extended ? (u8)(temp + EXTENDED_RANGE_OFFSET) : (u8)temp;
 174 }
 175
 176 static int nct1008_write_reg(struct i2c_client *client, u8 reg, u16 value)
 177 {
 178         int ret = 0;
 179         struct nct1008_data *data = i2c_get_clientdata(client);
 180
 181         mutex_lock(&data->mutex);
 182         if (data && data->nct_disabled) {
 183                 mutex_unlock(&data->mutex);
 184                 return -ENODEV;
 185         }
 186
 187         ret = i2c_smbus_write_byte_data(client, reg, value);
 188         mutex_unlock(&data->mutex);
 189
 190         if (ret < 0)
 191                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
 192
 193         return ret;
 194 }
 195
 196 static int nct1008_read_reg(struct i2c_client *client, u8 reg)
 197 {
 198         int ret = 0;
 199         struct nct1008_data *data = i2c_get_clientdata(client);
 200         mutex_lock(&data->mutex);
 201         if (data && data->nct_disabled) {
 202                 mutex_unlock(&data->mutex);
 203                 return -ENODEV;
 204         }
 205
 206         ret = i2c_smbus_read_byte_data(client, reg);
 207         mutex_unlock(&data->mutex);
 208
 209         if (ret < 0)
 210                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
 211
 212         return ret;
 213 }
 214
 215 static int nct1008_get_temp_common(int sensor,
 216                                         struct nct1008_data *data,
 217                                         long *temp)
 218 {
 219         struct i2c_client *client = data->client;
 220         struct nct1008_platform_data *pdata = client->dev.platform_data;
 221         struct nct1008_sensor_data *sensorp;
 222         s16 temp_hi;
 223         s16 temp_lo;
 224         long temp_milli = 0;
 225         int i, off = 0;
 226         u8 value;
 227         int ret;
 228
 229         if (!((sensor == EXT) || (sensor == LOC)))
 230                 return -1;
 231
 232         /* Read External Temp */
 233         if (sensor == EXT) {
 234                 ret = nct1008_read_reg(client, NCT_REG(sensor, TEMP_RD_LO));
 235                 if (ret < 0)
 236                         return -1;
 237                 else
 238                         value = ret;
 239
 240                 temp_lo = (value >> 6);
 241
 242                 ret = nct1008_read_reg(client, EXT_TEMP_HI_RD);
 243                 if (ret < 0)
 244                         return -1;
 245                 else
 246                         value = ret;
 247
 248                 temp_hi = value_to_temperature(pdata->extended_range, value);
 249                 temp_milli = CELSIUS_TO_MILLICELSIUS(temp_hi) + temp_lo * 250;
 250
 251                 sensorp = &data->sensors[sensor];
 252                 for (i = 0; i < ARRAY_SIZE(sensorp->offset_table); i++) {
 253                         if (temp_milli <
 254                                 (sensorp->offset_table[i].temp * 1000)) {
 255                                 off = sensorp->offset_table[i].offset * 1000;
 256                                 break;
 257                         }
 258                 }
 259
 260                 temp_milli += off;
 261
 262         } else if (sensor == LOC) {
 263                 value = nct1008_read_reg(client, LOC_TEMP_RD);
 264                 if (value < 0)
 265                         return -1;
 266                 temp_hi = value_to_temperature(pdata->extended_range, value);
 267                 temp_milli = CELSIUS_TO_MILLICELSIUS(temp_hi);
 268         }
 269
 270         if (temp_milli > NCT1008_MAX_TEMP_MILLI)
 271                 return -1;
 272
 273         *temp = temp_milli;
 274         data->sensors[sensor].temp = temp_milli;
 275
 276         return 0;
 277 }
 278
 279 static ssize_t nct1008_show_temp(struct device *dev,
 280         struct device_attribute *attr, char *buf)
 281 {
 282         struct i2c_client *client = to_i2c_client(dev);
 283         struct nct1008_platform_data *pdata = client->dev.platform_data;
 284         s16 temp1 = 0;
 285         s16 temp = 0;
 286         u8 temp2 = 0;
 287         int value = 0;
 288
 289         if (!dev || !buf || !attr)
 290                 return -EINVAL;
 291
 292         value = nct1008_read_reg(client, LOC_TEMP_RD);
 293         if (value < 0)
 294                 goto error;
 295         temp1 = value_to_temperature(pdata->extended_range, value);
 296
 297         value = nct1008_read_reg(client, EXT_TEMP_LO_RD);
 298         if (value < 0)
 299                 goto error;
 300         temp2 = (value >> 6);
 301         value = nct1008_read_reg(client, EXT_TEMP_HI_RD);
 302         if (value < 0)
 303                 goto error;
 304         temp = value_to_temperature(pdata->extended_range, value);
 305
 306         return snprintf(buf, MAX_STR_PRINT, "%d %d.%d\n",
 307                 temp1, temp, temp2 * 25);
 308
 309 error:
 310         return snprintf(buf, MAX_STR_PRINT,
 311                 "Error read local/ext temperature\n");
 312 }
 313
 314 static ssize_t nct1008_show_temp_overheat(struct device *dev,
 315                                 struct device_attribute *attr,
 316                                 char *buf)
 317 {
 318         struct i2c_client *client = to_i2c_client(dev);
 319         struct nct1008_platform_data *pdata = client->dev.platform_data;
 320         int value;
 321         s16 temp, temp2;
 322
 323         /* Local temperature h/w shutdown limit */
 324         value = nct1008_read_reg(client, LOC_THERM_LIMIT);
 325         if (value < 0)
 326                 goto error;
 327         temp = value_to_temperature(pdata->extended_range, value);
 328
 329         /* External temperature h/w shutdown limit */
 330         value = nct1008_read_reg(client, EXT_THERM_LIMIT_WR);
 331         if (value < 0)
 332                 goto error;
 333         temp2 = value_to_temperature(pdata->extended_range, value);
 334
 335         return snprintf(buf, MAX_STR_PRINT, "%d %d\n", temp, temp2);
 336 error:
 337         dev_err(dev, "%s: failed to read temperature-overheat "
 338                 "\n", __func__);
 339         return snprintf(buf, MAX_STR_PRINT, " Rd overheat Error\n");
 340 }
 341
 342 static ssize_t nct1008_set_temp_overheat(struct device *dev,
 343                         struct device_attribute *attr,
 344                         const char *buf, size_t count)
 345 {
 346         long int num;
 347         int err;
 348         u8 temp;
 349         long curr_temp;
 350         struct i2c_client *client = to_i2c_client(dev);
 351         struct nct1008_data *data = i2c_get_clientdata(client);
 352         char bufTemp[MAX_STR_PRINT];
 353         char bufOverheat[MAX_STR_PRINT];
 354         unsigned int ret;
 355
 356         if (strict_strtol(buf, 0, &num)) {
 357                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 358                         __LINE__, __func__);
 359                 return -EINVAL;
 360         }
 361         if (((int)num < NCT1008_MIN_TEMP) || ((int)num >= NCT1008_MAX_TEMP)) {
 362                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 363                         __LINE__, __func__);
 364                 return -EINVAL;
 365         }
 366         /* check for system power down */
 367         err = nct1008_get_temp_common(EXT, data, &curr_temp);
 368         if (err)
 369                 goto error;
 370
 371         curr_temp = MILLICELSIUS_TO_CELSIUS(curr_temp);
 372
 373         if (curr_temp >= (int)num) {
 374                 ret = nct1008_show_temp(dev, attr, bufTemp);
 375                 ret = nct1008_show_temp_overheat(dev, attr, bufOverheat);
 376                 dev_err(dev, "\nCurrent temp: %s ", bufTemp);
 377                 dev_err(dev, "\nOld overheat limit: %s ", bufOverheat);
 378                 dev_err(dev, "\nReset from overheat: curr temp=%ld, new overheat temp=%d\n\n",
 379                         curr_temp, (int)num);
 380         }
 381
 382         /* External temperature h/w shutdown limit */
 383         temp = temperature_to_value(data->plat_data.extended_range, (s16)num);
 384         err = nct1008_write_reg(client, EXT_THERM_LIMIT_WR, temp);
 385         if (err < 0)
 386                 goto error;
 387
 388         /* Local temperature h/w shutdown limit */
 389         temp = temperature_to_value(data->plat_data.extended_range, (s16)num);
 390         err = nct1008_write_reg(client, LOC_THERM_LIMIT, temp);
 391         if (err < 0)
 392                 goto error;
 393
 394         data->plat_data.sensors[EXT].shutdown_limit = num;
 395         nct1008_setup_shutdown_warning(data);
 396
 397         return count;
 398 error:
 399         dev_err(dev, " %s: failed to set temperature-overheat\n", __func__);
 400         return err;
 401 }
 402
 403 static ssize_t nct1008_show_temp_alert(struct device *dev,
 404                                 struct device_attribute *attr,
 405                                 char *buf)
 406 {
 407         struct i2c_client *client = to_i2c_client(dev);
 408         struct nct1008_platform_data *pdata = client->dev.platform_data;
 409         int value;
 410         s16 temp_hi, temp_lo;
 411         /* External Temperature Throttling hi-limit */
 412         value = nct1008_read_reg(client, EXT_TEMP_HI_LIMIT_HI_BYTE_RD);
 413         if (value < 0)
 414                 goto error;
 415         temp_hi = value_to_temperature(pdata->extended_range, value);
 416
 417         /* External Temperature Throttling lo-limit */
 418         value = nct1008_read_reg(client, EXT_TEMP_LO_LIMIT_HI_BYTE_RD);
 419         if (value < 0)
 420                 goto error;
 421         temp_lo = value_to_temperature(pdata->extended_range, value);
 422
 423         return snprintf(buf, MAX_STR_PRINT, "lo:%d hi:%d\n", temp_lo, temp_hi);
 424 error:
 425         dev_err(dev, "%s: failed to read temperature-alert\n", __func__);
 426         return snprintf(buf, MAX_STR_PRINT, " Rd alert Error\n");
 427 }
 428
 429 static ssize_t nct1008_set_temp_alert(struct device *dev,
 430                         struct device_attribute *attr,
 431                         const char *buf, size_t count)
 432 {
 433         long int num;
 434         int value;
 435         int err;
 436         struct i2c_client *client = to_i2c_client(dev);
 437         struct nct1008_platform_data *pdata = client->dev.platform_data;
 438
 439         if (strict_strtol(buf, 0, &num)) {
 440                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 441                         __LINE__, __func__);
 442                 return -EINVAL;
 443         }
 444         if (((int)num < NCT1008_MIN_TEMP) || ((int)num >= NCT1008_MAX_TEMP)) {
 445                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 446                         __LINE__, __func__);
 447                 return -EINVAL;
 448         }
 449
 450         /* External Temperature Throttling limit */
 451         value = temperature_to_value(pdata->extended_range, (s16)num);
 452         err = nct1008_write_reg(client, EXT_TEMP_HI_LIMIT_HI_BYTE_WR, value);
 453         if (err < 0)
 454                 goto error;
 455
 456         /* Local Temperature Throttling limit */
 457         err = nct1008_write_reg(client, LOC_TEMP_HI_LIMIT_WR, value);
 458         if (err < 0)
 459                 goto error;
 460
 461         return count;
 462 error:
 463         dev_err(dev, "%s: failed to set temperature-alert "
 464                 "\n", __func__);
 465         return err;
 466 }
 467
 468 static ssize_t nct1008_show_sensor_temp(int sensor, struct device *dev,
 469         struct device_attribute *attr, char *buf)
 470 {
 471         struct i2c_client *client = to_i2c_client(dev);
 472         struct nct1008_platform_data *pdata = client->dev.platform_data;
 473         s16 temp_value;
 474         int data = 0;
 475         int data_lo;
 476
 477         if (!dev || !buf || !attr)
 478                 return -EINVAL;
 479
 480         /* When reading the full external temperature value, read the
 481          * LSB first. This causes the MSB to be locked (that is, the
 482          * ADC does not write to it) until it is read */
 483         data_lo = nct1008_read_reg(client, NCT_REG(sensor, TEMP_RD_LO));
 484         if (data_lo < 0) {
 485                 dev_err(&client->dev, "%s: failed to read "
 486                         "ext_temperature, i2c error=%d\n", __func__, data_lo);
 487                 goto error;
 488         }
 489
 490         data = nct1008_read_reg(client, NCT_REG(sensor, TEMP_RD_HI));
 491         if (data < 0) {
 492                 dev_err(&client->dev, "%s: failed to read "
 493                         "ext_temperature, i2c error=%d\n", __func__, data);
 494                 goto error;
 495         }
 496
 497         temp_value = value_to_temperature(pdata->extended_range, data);
 498
 499         return snprintf(buf, MAX_STR_PRINT, "%d.%d\n", temp_value,
 500                 (25 * (data_lo >> 6)));
 501 error:
 502         return snprintf(buf, MAX_STR_PRINT, "Error read ext temperature\n");
 503 }
 504
 505 static ssize_t pr_reg(struct nct1008_data *nct, char *buf, int max_s,
 506                         const char *reg_name, int offset)
 507 {
 508         int ret, sz = 0;
 509
 510         ret = nct1008_read_reg(nct->client, offset);
 511         if (ret >= 0)
 512                 sz += snprintf(buf + sz, PAGE_SIZE - sz,
 513                                 "%20s  0x%02x  0x%02x  0x%02x\n",
 514                                 reg_name, nct->client->addr, offset, ret);
 515         else
 516                 sz += snprintf(buf + sz, PAGE_SIZE - sz,
 517                                 "%s: line=%d, i2c ** read error=%d **\n",
 518                                 __func__, __LINE__, ret);
 519         return sz;
 520 }
 521
 522 static ssize_t nct1008_show_regs(struct device *dev,
 523         struct device_attribute *attr, char *buf)
 524 {
 525         struct i2c_client *client = to_i2c_client(dev);
 526         struct nct1008_data *nct = i2c_get_clientdata(client);
 527         char *name = nct->chip == NCT72 ? "nct72" : "nct1008";
 528         int sz = 0;
 529
 530         sz += snprintf(buf + sz, PAGE_SIZE - sz,
 531                 "%s Registers\n", name);
 532         sz += snprintf(buf + sz, PAGE_SIZE - sz,
 533                 "---------------------------------------\n");
 534         sz += snprintf(buf + sz, PAGE_SIZE - sz, "%20s  %4s  %4s  %s\n",
 535                 "Register Name       ", "Addr", "Reg", "Value");
 536         sz += snprintf(buf + sz, PAGE_SIZE - sz, "%20s  %4s  %4s  %s\n",
 537                 "--------------------", "----", "----", "-----");
 538         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 539                 "Status              ", STATUS_RD);
 540         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 541                 "Configuration       ", CONFIG_RD);
 542         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 543                 "Conversion Rate     ", CONV_RATE_RD);
 544         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 545                 "Hysteresis          ", THERM_HYSTERESIS);
 546         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 547                 "Consecutive Alert   ", COSECUTIVE_ALERT);
 548         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 549                 "Local Temp Value    ", LOC_TEMP_RD);
 550         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 551                 "Local Temp Hi Limit ", LOC_TEMP_HI_LIMIT_RD);
 552         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 553                 "Local Temp Lo Limit ", LOC_TEMP_LO_LIMIT_RD);
 554         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 555                 "Local Therm Limit   ", LOC_THERM_LIMIT);
 556         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 557                 "Ext Temp Value Hi   ", EXT_TEMP_HI_RD);
 558         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 559                 "Ext Temp Value Lo   ", EXT_TEMP_LO_RD);
 560         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 561                 "Ext Temp Hi Limit Hi", EXT_TEMP_HI_LIMIT_HI_BYTE_RD);
 562         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 563                 "Ext Temp Hi Limit Lo", EXT_TEMP_HI_LIMIT_LO_BYTE);
 564         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 565                 "Ext Temp Lo Limit Hi", EXT_TEMP_LO_LIMIT_HI_BYTE_RD);
 566         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 567                 "Ext Temp Lo Limit Lo", EXT_TEMP_LO_LIMIT_LO_BYTE);
 568         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 569                 "Ext Temp Offset Hi  ", OFFSET_WR);
 570         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 571                 "Ext Temp Offset Lo  ", OFFSET_QUARTER_WR);
 572         sz += pr_reg(nct, buf+sz, PAGE_SIZE-sz,
 573                 "Ext Therm Limit     ", EXT_THERM_LIMIT_WR);
 574
 575         return sz;
 576 }
 577
 578 static ssize_t nct1008_set_offsets(struct device *dev,
 579                         struct device_attribute *attr,
 580                         const char *buf, size_t count)
 581 {
 582         struct i2c_client *client = to_i2c_client(dev);
 583         struct nct1008_data *nct = i2c_get_clientdata(client);
 584         int index, temp, off;
 585         int rv = count;
 586
 587         strim((char *)buf);
 588         sscanf(buf, "[%u] %u %d", &index, &temp, &off);
 589
 590         if (index >= ARRAY_SIZE(nct->sensors[EXT].offset_table)) {
 591                 pr_info("%s: invalid index [%d]\n", __func__, index);
 592                 rv = -EINVAL;
 593         } else {
 594                 nct->sensors[EXT].offset_table[index].temp = temp;
 595                 nct->sensors[EXT].offset_table[index].offset = off;
 596         }
 597
 598         return rv;
 599 }
 600
 601 static ssize_t nct1008_show_offsets(struct device *dev,
 602         struct device_attribute *attr, char *buf)
 603 {
 604         struct i2c_client *client = to_i2c_client(dev);
 605         struct nct1008_data *nct = i2c_get_clientdata(client);
 606         char *name = nct->chip == NCT72 ? "nct72" : "nct1008";
 607         int i, sz = 0;
 608
 609         sz += snprintf(buf + sz, PAGE_SIZE - sz,
 610                                 "%s offsets table\n", name);
 611         sz += snprintf(buf + sz, PAGE_SIZE - sz,
 612                                 "%2s  %4s  %s\n", " #", "temp", "offset");
 613         sz += snprintf(buf + sz, PAGE_SIZE - sz,
 614                                 "%2s  %4s  %s\n", "--", "----", "------");
 615
 616         for (i = 0; i < ARRAY_SIZE(nct->sensors[EXT].offset_table); i++)
 617                 sz += snprintf(buf + sz, PAGE_SIZE - sz,
 618                                 "%2d  %4d  %3d\n",
 619                                 i, nct->sensors[EXT].offset_table[i].temp,
 620                                 nct->sensors[EXT].offset_table[i].offset);
 621         return sz;
 622 }
 623
 624
 625 /* This function is used by the system to show the temperature. */
 626 static ssize_t nct1008_show_ext_temp(struct device *dev,
 627                                         struct device_attribute *attr,
 628                                         char *buf)
 629 {
 630         return nct1008_show_sensor_temp(EXT, dev, attr, buf);
 631 }
 632
 633 static DEVICE_ATTR(temperature, S_IRUGO, nct1008_show_temp, NULL);
 634 static DEVICE_ATTR(temperature_overheat, (S_IRUGO | (S_IWUSR | S_IWGRP)),
 635                 nct1008_show_temp_overheat, nct1008_set_temp_overheat);
 636 static DEVICE_ATTR(temperature_alert, (S_IRUGO | (S_IWUSR | S_IWGRP)),
 637                 nct1008_show_temp_alert, nct1008_set_temp_alert);
 638 static DEVICE_ATTR(ext_temperature, S_IRUGO, nct1008_show_ext_temp, NULL);
 639 static DEVICE_ATTR(registers, S_IRUGO, nct1008_show_regs, NULL);
 640 static DEVICE_ATTR(offsets, (S_IRUGO | (S_IWUSR | S_IWGRP)),
 641                 nct1008_show_offsets, nct1008_set_offsets);
 642
 643 static struct attribute *nct1008_attributes[] = {
 644         &dev_attr_temperature.attr,
 645         &dev_attr_temperature_overheat.attr,
 646         &dev_attr_temperature_alert.attr,
 647         &dev_attr_ext_temperature.attr,
 648         &dev_attr_registers.attr,
 649         &dev_attr_offsets.attr,
 650         NULL
 651 };
 652
 653 static const struct attribute_group nct1008_attr_group = {
 654         .attrs = nct1008_attributes,
 655 };
 656
 657 static const unsigned long THERM_WARN_RANGE_HIGH_OFFSET = 3000;
 658 static unsigned long nct1008_shutdown_warning_cur_state;
 659 static long shutdown_warn_saved_temp;
 660
 661 static int nct1008_shutdown_warning_get_max_state(
 662                                         struct thermal_cooling_device *cdev,
 663                                         unsigned long *max_state)
 664 {
 665         /* A state for every 250mC */
 666         *max_state = THERM_WARN_RANGE_HIGH_OFFSET / 250;
 667         return 0;
 668 }
 669
 670 static int nct1008_shutdown_warning_get_cur_state(
 671                                         struct thermal_cooling_device *cdev,
 672                                         unsigned long *cur_state)
 673 {
 674         struct nct1008_data *data = cdev->devdata;
 675         long limit = data->plat_data.sensors[EXT].shutdown_limit * 1000;
 676         long temp;
 677
 678         if (nct1008_get_temp_common(EXT, data, &temp))
 679                 return -1;
 680
 681         if (temp >= (limit - THERM_WARN_RANGE_HIGH_OFFSET))
 682                 *cur_state = nct1008_shutdown_warning_cur_state;
 683         else
 684                 *cur_state = 0;
 685
 686         return 0;
 687 }
 688
 689 static int nct1008_shutdown_warning_set_cur_state(
 690                                         struct thermal_cooling_device *cdev,
 691                                         unsigned long cur_state)
 692 {
 693         struct nct1008_data *data = cdev->devdata;
 694         long limit = data->plat_data.sensors[EXT].shutdown_limit * 1000;
 695         long temp;
 696
 697         if (nct1008_get_temp_common(EXT, data, &temp))
 698                 return -1;
 699         else if (temp < 0)
 700                 goto ret;
 701
 702         if ((temp >= (limit - THERM_WARN_RANGE_HIGH_OFFSET)) &&
 703                 (temp != shutdown_warn_saved_temp)) {
 704                 pr_warn("NCT%s: Warning: chip temperature (%ld.%02ldC) is %s SHUTDOWN limit (%c%ldC).\n",
 705                         (data->chip == NCT72) ? "72" : "1008",
 706                         temp / 1000, (temp % 1000) / 10,
 707                         temp > limit ? "above" :
 708                         temp == limit ? "at" : "near",
 709                         temp > limit ? '>' : '<', limit / 1000);
 710                 shutdown_warn_saved_temp = temp;
 711         }
 712
 713  ret:
 714         nct1008_shutdown_warning_cur_state = cur_state;
 715         return 0;
 716 }
 717
 718 static struct thermal_cooling_device_ops nct1008_shutdown_warning_ops = {
 719         .get_max_state = nct1008_shutdown_warning_get_max_state,
 720         .get_cur_state = nct1008_shutdown_warning_get_cur_state,
 721         .set_cur_state = nct1008_shutdown_warning_set_cur_state,
 722 };
 723
 724 static int nct1008_thermal_set_limits(int sensor,
 725                                       struct nct1008_data *data,
 726                                       long lo_limit_milli,
 727                                       long hi_limit_milli)
 728 {
 729         int err;
 730         u8 value;
 731         bool extended_range = data->plat_data.extended_range;
 732         long lo_limit = MILLICELSIUS_TO_CELSIUS(lo_limit_milli);
 733         long hi_limit = MILLICELSIUS_TO_CELSIUS(hi_limit_milli);
 734
 735         if (lo_limit >= hi_limit)
 736                 return -EINVAL;
 737
 738         if (data->sensors[sensor].current_lo_limit != lo_limit) {
 739                 value = temperature_to_value(extended_range, lo_limit);
 740                 pr_debug("%s: set lo_limit %ld\n", __func__, lo_limit);
 741                 err = nct1008_write_reg(data->client,
 742                                 NCT_REG(sensor, TEMP_LO_LIMIT_WR), value);
 743                 if (err)
 744                         return err;
 745
 746                 data->sensors[sensor].current_lo_limit = lo_limit;
 747         }
 748
 749         if (data->sensors[sensor].current_hi_limit != hi_limit) {
 750                 value = temperature_to_value(extended_range, hi_limit);
 751                 pr_debug("%s: set hi_limit %ld\n", __func__, hi_limit);
 752                 err = nct1008_write_reg(data->client,
 753                                 NCT_REG(sensor, TEMP_HI_LIMIT_WR), value);
 754                 if (err)
 755                         return err;
 756
 757                 data->sensors[sensor].current_hi_limit = hi_limit;
 758         }
 759
 760         if (sensor == LOC)
 761                 pr_debug("NCT1008: LOC-sensor limits set to %ld - %ld\n",
 762                         lo_limit, hi_limit);
 763
 764         return 0;
 765 }
 766
 767 #ifdef CONFIG_THERMAL
 768 static void nct1008_update(int sensor, struct nct1008_data *data)
 769 {
 770         struct thermal_zone_device *thz;
 771         long low_temp, high_temp;
 772         struct thermal_trip_info *trip_state;
 773         long temp, trip_temp, hysteresis_temp;
 774         int count;
 775         enum thermal_trip_type trip_type;
 776         low_temp = 0, high_temp = NCT1008_MAX_TEMP * 1000;
 777         thz = data->sensors[sensor].thz;
 778
 779         if (!thz)
 780                 return;
 781
 782         thermal_zone_device_update(thz);
 783
 784         temp = thz->temperature;
 785
 786         for (count = 0; count < thz->trips; count++) {
 787                 trip_state = &data->plat_data.sensors[sensor].trips[count];
 788                 thz->ops->get_trip_temp(thz, count, &trip_temp);
 789                 thz->ops->get_trip_type(thz, count, &trip_type);
 790                 thz->ops->get_trip_hyst(thz, count, &hysteresis_temp);
 791                 hysteresis_temp = trip_temp - hysteresis_temp;
 792                 if ((trip_type == THERMAL_TRIP_PASSIVE) &&
 793                     !trip_state->tripped)
 794                         hysteresis_temp = trip_temp;
 795
 796                 if ((trip_temp > temp) && (trip_temp < high_temp))
 797                         high_temp = trip_temp;
 798
 799                 if ((hysteresis_temp < temp) && (hysteresis_temp > low_temp))
 800                         low_temp = hysteresis_temp;
 801         }
 802
 803         nct1008_thermal_set_limits(sensor, data, low_temp, high_temp);
 804 }
 805
 806 static int nct1008_ext_get_temp(struct thermal_zone_device *thz, long *temp)
 807 {
 808         struct nct1008_data *data = thz->devdata;
 809
 810         return nct1008_get_temp_common(EXT, data, temp);
 811 }
 812
 813 static int nct1008_ext_get_temp_as_sensor(void *data, long *temp)
 814 {
 815         return nct1008_get_temp_common(EXT, (struct nct1008_data *) data, temp);
 816 }
 817
 818 static int nct1008_ext_bind(struct thermal_zone_device *thz,
 819                             struct thermal_cooling_device *cdev)
 820 {
 821         struct nct1008_data *data = thz->devdata;
 822         int i;
 823         struct nct1008_sensor_platform_data *sensor;
 824
 825         sensor = &data->plat_data.sensors[EXT];
 826
 827         for (i = 0; i < sensor->num_trips; i++) {
 828                 if (!strcmp(sensor->trips[i].cdev_type, cdev->type))
 829                         thermal_zone_bind_cooling_device(thz, i, cdev,
 830                                         sensor->trips[i].upper,
 831                                         sensor->trips[i].lower);
 832         }
 833
 834         return 0;
 835 }
 836
 837
 838 static int nct1008_unbind(int sensor,
 839                                 struct thermal_zone_device *thz,
 840                                 struct thermal_cooling_device *cdev)
 841 {
 842         struct nct1008_data *data = thz->devdata;
 843         int i;
 844
 845         struct nct1008_sensor_platform_data *sensor_data;
 846
 847         sensor_data = &data->plat_data.sensors[sensor];
 848
 849         for (i = 0; i < sensor_data->num_trips; i++) {
 850                 if (!strcmp(sensor_data->trips[i].cdev_type, cdev->type))
 851                         thermal_zone_unbind_cooling_device(thz, i, cdev);
 852         }
 853         return 0;
 854 }
 855
 856 /* Helper function that is called in order to unbind external sensor from the
 857    cooling device. */
 858 static inline int nct1008_ext_unbind(struct thermal_zone_device *thz,
 859                                         struct thermal_cooling_device *cdev)
 860 {
 861         return nct1008_unbind(EXT, thz, cdev);
 862 }
 863
 864 /* Helper function that is called in order to unbind local sensor from the
 865    cooling device. */
 866 static inline int nct1008_loc_unbind(struct thermal_zone_device *thz,
 867                                         struct thermal_cooling_device *cdev)
 868 {
 869         return nct1008_unbind(LOC, thz, cdev);
 870 }
 871
 872 /* This function reads the temperature value set for the given trip point. */
 873 static int nct1008_get_trip_temp(int sensor,
 874                                         struct thermal_zone_device *thz,
 875                                         int trip, long *temp)
 876 {
 877         struct nct1008_data *data = thz->devdata;
 878         struct thermal_trip_info *trip_state =
 879                 &data->plat_data.sensors[sensor].trips[trip];
 880
 881         *temp = trip_state->trip_temp;
 882
 883         if (trip_state->trip_type != THERMAL_TRIP_PASSIVE)
 884                 return 0;
 885
 886         if (thz->temperature >= *temp) {
 887                 trip_state->tripped = true;
 888         } else if (trip_state->tripped) {
 889                 *temp -= trip_state->hysteresis;
 890                 if (thz->temperature < *temp)
 891                         trip_state->tripped = false;
 892         }
 893
 894         return 0;
 895 }
 896
 897 /* This function reads the temperature value set for the given trip point for
 898    the local sensor. */
 899 static inline int nct1008_loc_get_trip_temp(struct thermal_zone_device *thz,
 900                                                 int trip, long *temp)
 901 {
 902         return nct1008_get_trip_temp(LOC, thz, trip, temp);
 903 }
 904
 905 /* This function reads the temperature value set for the given trip point for
 906         the remote sensor. */
 907 static inline int nct1008_ext_get_trip_temp(struct thermal_zone_device *thz,
 908                                                 int trip, long *temp)
 909 {
 910         return nct1008_get_trip_temp(EXT, thz, trip, temp);
 911 }
 912
 913 /* This function allows setting trip point temperature for the sensor
 914    specified. */
 915 static int nct1008_set_trip_temp(int sensor,
 916                                         struct thermal_zone_device *thz,
 917                                         int trip, long temp)
 918 {
 919         struct nct1008_data *data = thz->devdata;
 920
 921         data->plat_data.sensors[sensor].trips[trip].trip_temp = temp;
 922         nct1008_update(sensor, data);
 923         return 0;
 924 }
 925
 926 /* This function allows setting trip point temperature for the local sensor. */
 927 static inline int nct1008_loc_set_trip_temp(struct thermal_zone_device *thz,
 928                                                 int trip, long temp)
 929 {
 930         return nct1008_set_trip_temp(LOC, thz, trip, temp);
 931 }
 932
 933 /* This function allows setting trip point temperature for the external
 934  * sensor. */
 935 static inline int nct1008_ext_set_trip_temp(struct thermal_zone_device *thz,
 936                                                 int trip, long temp)
 937 {
 938         return nct1008_set_trip_temp(EXT, thz, trip, temp);
 939 }
 940
 941 static int nct1008_loc_trip_update(void *of_data, int trip)
 942 {
 943         struct nct1008_data *data = (struct nct1008_data *)of_data;
 944
 945         nct1008_update(LOC, data);
 946
 947         return 0;
 948 }
 949
 950 static int nct1008_ext_trip_update(void *of_data, int trip)
 951 {
 952         struct nct1008_data *data = (struct nct1008_data *)of_data;
 953
 954         nct1008_update(EXT, data);
 955
 956         return 0;
 957 }
 958
 959 /* This function return the trip point type for the sensor specified. */
 960 static int nct1008_get_trip_type(int sensor,
 961                                         struct thermal_zone_device *thz,
 962                                         int trip,
 963                                         enum thermal_trip_type *type)
 964 {
 965         struct nct1008_data *data = thz->devdata;
 966
 967         *type = data->plat_data.sensors[sensor].trips[trip].trip_type;
 968         return 0;
 969 }
 970
 971 /* This function return the trip point type for the local sensor. */
 972 static inline int nct1008_loc_get_trip_type(struct thermal_zone_device *thz,
 973                                                 int trip,
 974                                                 enum thermal_trip_type *type)
 975 {
 976         return nct1008_get_trip_type(LOC, thz, trip, type);
 977 }
 978
 979 /* This function return the trip point type for the external sensor. */
 980 static inline int nct1008_ext_get_trip_type(struct thermal_zone_device *thz,
 981                                                 int trip,
 982                                                 enum thermal_trip_type *type)
 983 {
 984         return nct1008_get_trip_type(EXT, thz, trip, type);
 985 }
 986
 987 static int nct1008_get_trip_hyst(int sensor, struct thermal_zone_device *thz,
 988                                                 int trip,
 989                                                 long *hyst)
 990 {
 991         struct nct1008_data *data = thz->devdata;
 992
 993         *hyst = data->plat_data.sensors[sensor].trips[trip].hysteresis;
 994         return 0;
 995 }
 996
 997 static inline int  nct1008_loc_get_trip_hyst(struct thermal_zone_device *thz,
 998                                                 int trip,
 999                                                 long *hyst)
1000 {
1001         return nct1008_get_trip_hyst(LOC, thz, trip, hyst);
1002 }
1003
1004 static inline int  nct1008_ext_get_trip_hyst(struct thermal_zone_device *thz,
1005                                                 int trip,
1006                                                 long *hyst)
1007 {
1008         return nct1008_get_trip_hyst(EXT, thz, trip, hyst);
1009 }
1010
1011 /* This function returns value of trend for the temperature change, depending
1012    on the trip point type. */
1013 static int nct1008_get_trend(struct thermal_zone_device *thz,
1014                                 int trip,
1015                                 enum thermal_trend *trend)
1016 {
1017         long trip_temp, trip_hyst;
1018         enum thermal_trip_type trip_type;
1019
1020         thz->ops->get_trip_temp(thz, trip, &trip_temp);
1021         thz->ops->get_trip_type(thz, trip, &trip_type);
1022         thz->ops->get_trip_hyst(thz, trip, &trip_hyst);
1023
1024         switch (trip_type) {
1025         case THERMAL_TRIP_ACTIVE:
1026                 if (thz->temperature >= trip_temp)
1027                         *trend = THERMAL_TREND_RAISING;
1028                 else
1029                         *trend = THERMAL_TREND_DROPPING;
1030                 break;
1031         case THERMAL_TRIP_PASSIVE:
1032                 if (thz->temperature > thz->last_temperature)
1033                         *trend = THERMAL_TREND_RAISING;
1034                 else if (thz->temperature < (thz->last_temperature - trip_hyst))
1035                         *trend = THERMAL_TREND_DROPPING;
1036                 else
1037                         *trend = THERMAL_TREND_STABLE;
1038                 break;
1039         default:
1040                 return -EINVAL;
1041         }
1042
1043         return 0;
1044 }
1045
1046 static int nct1008_get_trend_as_sensor(int sensor,
1047                                 struct nct1008_data *data,
1048                                         long *trend)
1049 {
1050         struct thermal_zone_device *thz = data->sensors[sensor].thz;
1051
1052         return thz->temperature - thz->last_temperature;
1053 }
1054
1055 /* Helper function to get trend for the local sensor. */
1056 static inline int nct1008_loc_get_trend_as_sensor(void *data,
1057                                                 long *trend)
1058 {
1059         return nct1008_get_trend_as_sensor(LOC,
1060                 (struct nct1008_data *) data, trend);
1061 }
1062
1063 static inline int nct1008_ext_get_trend_as_sensor(void *data,
1064                                                 long *trend)
1065 {
1066         return nct1008_get_trend_as_sensor
1067                 (EXT, (struct nct1008_data *) data, trend);
1068 }
1069
1070
1071 /* Helper function to get temperature of the local sensor. */
1072 static int nct1008_loc_get_temp(struct thermal_zone_device *thz, long *temp)
1073 {
1074         struct nct1008_data *data = thz->devdata;
1075
1076         return nct1008_get_temp_common(LOC, data, temp);
1077 }
1078
1079 static int nct1008_loc_get_temp_as_sensor(void *data, long *temp)
1080 {
1081         return nct1008_get_temp_common(LOC, (struct nct1008_data *) data, temp);
1082 }
1083 /* Helper function to bind local sensor with the cooling device specified. */
1084 static int nct1008_loc_bind(struct thermal_zone_device *thz,
1085                                 struct thermal_cooling_device *cdev)
1086 {
1087         struct nct1008_data *data = thz->devdata;
1088         int i;
1089         struct nct1008_sensor_platform_data *sensor_data;
1090
1091         pr_debug("NCT1008: LOC-sensor bind %s, %s attempt\n",
1092                  thz->type, cdev->type);
1093
1094         sensor_data = &data->plat_data.sensors[LOC];
1095
1096         for (i = 0; i < sensor_data->num_trips; i++) {
1097                 if (!strcmp(sensor_data->trips[i].cdev_type, cdev->type)) {
1098                         thermal_zone_bind_cooling_device(thz, i, cdev,
1099                                 sensor_data->trips[i].upper,
1100                                 sensor_data->trips[i].lower);
1101                         break;
1102                 }
1103         }
1104
1105         return 0;
1106 }
1107
1108 static struct thermal_zone_device_ops nct_loc_ops = {
1109         .get_temp = nct1008_loc_get_temp,
1110         .bind = nct1008_loc_bind,
1111         .unbind = nct1008_loc_unbind,
1112         .get_trip_type = nct1008_loc_get_trip_type,
1113         .get_trip_temp = nct1008_loc_get_trip_temp,
1114         .get_trip_hyst = nct1008_loc_get_trip_hyst,
1115         .set_trip_temp = nct1008_loc_set_trip_temp,
1116         .get_trend = nct1008_get_trend,
1117 };
1118
1119 static struct thermal_zone_device_ops nct_ext_ops = {
1120         .get_temp = nct1008_ext_get_temp,
1121         .bind = nct1008_ext_bind,
1122         .unbind = nct1008_ext_unbind,
1123         .get_trip_type = nct1008_ext_get_trip_type,
1124         .get_trip_temp = nct1008_ext_get_trip_temp,
1125         .get_trip_hyst = nct1008_ext_get_trip_hyst,
1126         .set_trip_temp = nct1008_ext_set_trip_temp,
1127         .get_trend = nct1008_get_trend,
1128 };
1129 #else
1130 static void nct1008_update(nct1008_sensors sensor, struct nct1008_data *data)
1131 {
1132 }
1133 #endif /* CONFIG_THERMAL */
1134
1135 static int nct1008_enable(struct i2c_client *client)
1136 {
1137         struct nct1008_data *data = i2c_get_clientdata(client);
1138         int err;
1139
1140         err = nct1008_write_reg(client, CONFIG_WR, data->config);
1141         if (err < 0)
1142                 dev_err(&client->dev, "%s, line=%d, i2c write error=%d\n",
1143                 __func__, __LINE__, err);
1144         return err;
1145 }
1146
1147 static int nct1008_disable(struct i2c_client *client)
1148 {
1149         struct nct1008_data *data = i2c_get_clientdata(client);
1150         int err;
1151
1152         err = nct1008_write_reg(client, CONFIG_WR,
1153                                 data->config | STANDBY_BIT);
1154         if (err < 0)
1155                 dev_err(&client->dev, "%s, line=%d, i2c write error=%d\n",
1156                 __func__, __LINE__, err);
1157         return err;
1158 }
1159
1160 static void nct1008_work_func(struct work_struct *work)
1161 {
1162         struct nct1008_data *data = container_of(work, struct nct1008_data,
1163                                                 work);
1164         int err;
1165         struct timespec ts;
1166         int intr_status;
1167
1168         mutex_lock(&data->mutex);
1169         if (data->stop_workqueue) {
1170                 mutex_unlock(&data->mutex);
1171                 return;
1172         }
1173         mutex_unlock(&data->mutex);
1174
1175         err = nct1008_disable(data->client);
1176         if (err == -ENODEV)
1177                 return;
1178
1179         intr_status = nct1008_read_reg(data->client, STATUS_RD);
1180         pr_debug("NCT1008: interruption (0x%08x)\n", intr_status);
1181
1182         if (intr_status & (LOC_LO_BIT | LOC_HI_BIT)) {
1183                 pr_debug("NCT1008: LOC-sensor is not within limits\n");
1184                 nct1008_update(LOC, data);
1185         }
1186
1187         if (intr_status & (EXT_LO_BIT | EXT_HI_BIT))
1188                 nct1008_update(EXT, data);
1189
1190         /* Initiate one-shot conversion */
1191         nct1008_write_reg(data->client, ONE_SHOT, 0x1);
1192
1193         /* Give hardware necessary time to finish conversion */
1194         ts = ns_to_timespec(MAX_CONV_TIME_ONESHOT_MS * 1000 * 1000);
1195         hrtimer_nanosleep(&ts, NULL, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
1196
1197         nct1008_read_reg(data->client, STATUS_RD);
1198
1199         nct1008_enable(data->client);
1200
1201         enable_irq(data->client->irq);
1202 }
1203
1204 static irqreturn_t nct1008_irq(int irq, void *dev_id)
1205 {
1206         struct nct1008_data *data = dev_id;
1207
1208         disable_irq_nosync(irq);
1209         queue_work(data->workqueue, &data->work);
1210
1211         return IRQ_HANDLED;
1212 }
1213
1214 static void nct1008_power_control(struct nct1008_data *data, bool is_enable)
1215 {
1216         int ret;
1217
1218         mutex_lock(&data->mutex);
1219         if (!data->nct_reg) {
1220                 data->nct_reg = regulator_get(&data->client->dev, "vdd");
1221                 if (IS_ERR_OR_NULL(data->nct_reg)) {
1222                         if (PTR_ERR(data->nct_reg) == -ENODEV)
1223                                 dev_info(&data->client->dev,
1224                                         "no regulator found for vdd."
1225                                         " Assuming vdd is always powered");
1226                         else
1227                                 dev_warn(&data->client->dev, "Error [%ld] in "
1228                                         "getting the regulator handle for"
1229                                         " vdd\n", PTR_ERR(data->nct_reg));
1230                         data->nct_reg = NULL;
1231                         mutex_unlock(&data->mutex);
1232                         return;
1233                 }
1234         }
1235         if (is_enable)
1236                 ret = regulator_enable(data->nct_reg);
1237         else
1238                 ret = regulator_disable(data->nct_reg);
1239
1240         if (ret < 0)
1241                 dev_err(&data->client->dev, "Error in %s rail vdd_nct%s, "
1242                         "error %d\n", (is_enable) ? "enabling" : "disabling",
1243                         (data->chip == NCT72) ? "72" : "1008",
1244                         ret);
1245         else
1246                 dev_info(&data->client->dev, "success in %s rail vdd_nct%s\n",
1247                         (is_enable) ? "enabling" : "disabling",
1248                         (data->chip == NCT72) ? "72" : "1008");
1249         data->nct_disabled = !is_enable;
1250         mutex_unlock(&data->mutex);
1251 }
1252
1253 static void nct1008_setup_shutdown_warning(struct nct1008_data *data)
1254 {
1255         static struct thermal_cooling_device *cdev;
1256         long limit = data->plat_data.sensors[EXT].shutdown_limit * 1000;
1257         long warn_temp = limit - THERM_WARN_RANGE_HIGH_OFFSET;
1258         int i;
1259         struct nct1008_sensor_platform_data *sensor_data;
1260
1261         if (cdev)
1262                 thermal_cooling_device_unregister(cdev);
1263         cdev = thermal_cooling_device_register("shutdown_warning", data,
1264                                         &nct1008_shutdown_warning_ops);
1265         if (IS_ERR_OR_NULL(cdev)) {
1266                 cdev = NULL;
1267                 return;
1268         }
1269
1270         sensor_data = &data->plat_data.sensors[EXT];
1271
1272         for (i = 0; i < sensor_data->num_trips; i++) {
1273                 if (!strcmp(sensor_data->trips[i].cdev_type,
1274                                                 "shutdown_warning")) {
1275                         sensor_data->trips[i].trip_temp = warn_temp;
1276                         nct1008_update(EXT, data);
1277                         break;
1278                 }
1279         }
1280
1281         pr_info("NCT%s: Enabled overheat logging at %ld.%02ldC\n",
1282                         (data->chip == NCT72) ? "72" : "1008",
1283                         warn_temp / 1000, (warn_temp % 1000) / 10);
1284 }
1285
1286 static int nct1008_configure_sensor(struct nct1008_data *data)
1287 {
1288         struct i2c_client *client = data->client;
1289         struct nct1008_platform_data *pdata = client->dev.platform_data;
1290         u8 value;
1291         s16 temp;
1292         u8 temp2;
1293         int ret;
1294         bool ext_err = false;
1295
1296         if (!pdata || !pdata->supported_hwrev)
1297                 return -ENODEV;
1298
1299         ret = nct1008_read_reg(data->client, STATUS_RD);
1300         if (ret & BIT(2)) {
1301                 pr_info("NCT%s: ERR: remote sensor circuit is open (0x%02x)\n",
1302                         (data->chip == NCT72) ? "72" : "1008", ret);
1303                 ext_err = true; /* flag the error */
1304         }
1305
1306         /* Initially place in Standby */
1307         ret = nct1008_write_reg(client, CONFIG_WR, STANDBY_BIT);
1308         if (ret)
1309                 goto error;
1310
1311         /* Local temperature h/w shutdown limit */
1312         value = temperature_to_value(pdata->extended_range,
1313                                         pdata->sensors[LOC].shutdown_limit);
1314         ret = nct1008_write_reg(client, LOC_THERM_LIMIT, value);
1315         if (ret)
1316                 goto error;
1317
1318         /* set extended range mode if needed */
1319         if (pdata->extended_range)
1320                 data->config |= EXTENDED_RANGE_BIT;
1321         data->config &= ~(THERM2_BIT | ALERT_BIT);
1322
1323         ret = nct1008_write_reg(client, CONFIG_WR, data->config | STANDBY_BIT);
1324         if (ret)
1325                 goto error;
1326
1327         /* Temperature conversion rate */
1328         ret = nct1008_write_reg(client, CONV_RATE_WR, pdata->conv_rate);
1329         if (ret)
1330                 goto error;
1331
1332         data->conv_period_ms = conv_period_ms_table[pdata->conv_rate];
1333
1334         /* Setup local hi and lo limits. */
1335         ret = nct1008_write_reg(client, LOC_TEMP_HI_LIMIT_WR, NCT1008_MAX_TEMP);
1336         if (ret)
1337                 goto error;
1338
1339         ret = nct1008_write_reg(client, LOC_TEMP_LO_LIMIT_WR, 0);
1340         if (ret)
1341                 goto error;
1342
1343         /* Initiate one-shot conversion  */
1344         nct1008_write_reg(data->client, ONE_SHOT, 0x1);
1345
1346         /* Give hardware necessary time to finish conversion */
1347         msleep(MAX_CONV_TIME_ONESHOT_MS);
1348
1349         /* read initial temperature */
1350         ret = nct1008_read_reg(client, LOC_TEMP_RD);
1351         if (ret < 0)
1352                 goto error;
1353         else
1354                 value = ret;
1355
1356         temp = value_to_temperature(pdata->extended_range, value);
1357         dev_dbg(&client->dev, "\n initial local temp = %d ", temp);
1358
1359         if (ext_err)
1360                 return ext_err; /* skip configuration of EXT sensor */
1361
1362         /* External temperature h/w shutdown limit. */
1363         value = temperature_to_value(pdata->extended_range,
1364                                         pdata->sensors[EXT].shutdown_limit);
1365         ret = nct1008_write_reg(client, EXT_THERM_LIMIT_WR, value);
1366         if (ret)
1367                 goto error;
1368
1369         /* Setup external hi and lo limits */
1370         ret = nct1008_write_reg(client, EXT_TEMP_LO_LIMIT_HI_BYTE_WR, 0);
1371         if (ret)
1372                 goto error;
1373         ret = nct1008_write_reg(client, EXT_TEMP_HI_LIMIT_HI_BYTE_WR,
1374                         NCT1008_MAX_TEMP);
1375         if (ret)
1376                 goto error;
1377
1378         ret = nct1008_read_reg(client, EXT_TEMP_LO_RD);
1379         if (ret < 0)
1380                 goto error;
1381         else
1382                 value = ret;
1383
1384         temp2 = (value >> 6);
1385         ret = nct1008_read_reg(client, EXT_TEMP_HI_RD);
1386         if (ret < 0)
1387                 goto error;
1388         else
1389                 value = ret;
1390
1391         temp = value_to_temperature(pdata->extended_range, value);
1392
1393         if (temp2 > 0)
1394                 dev_dbg(&client->dev, "\n initial ext temp = %d.%d deg",
1395                                 temp, temp2 * 25);
1396         else
1397                 dev_dbg(&client->dev, "\n initial ext temp = %d.0 deg", temp);
1398
1399         /* Remote channel offset */
1400         ret = nct1008_write_reg(client, OFFSET_WR, pdata->offset / 4);
1401         if (ret < 0)
1402                 goto error;
1403
1404         /* Remote channel offset fraction (quarters) */
1405         ret = nct1008_write_reg(client, OFFSET_QUARTER_WR,
1406                                         (pdata->offset % 4) << 6);
1407         if (ret < 0)
1408                 goto error;
1409
1410         /* Reset current hi/lo limit values with register values */
1411         ret = nct1008_read_reg(data->client, EXT_TEMP_LO_LIMIT_HI_BYTE_RD);
1412         if (ret < 0)
1413                 goto error;
1414         else
1415                 value = ret;
1416         data->sensors[EXT].current_lo_limit =
1417                 value_to_temperature(pdata->extended_range, value);
1418
1419         ret = nct1008_read_reg(data->client, EXT_TEMP_HI_LIMIT_HI_BYTE_RD);
1420         if (ret < 0)
1421                 goto error;
1422         else
1423                 value = ret;
1424
1425         data->sensors[EXT].current_hi_limit =
1426                 value_to_temperature(pdata->extended_range, value);
1427
1428         ret = nct1008_read_reg(data->client, LOC_TEMP_LO_LIMIT_RD);
1429         if (ret < 0)
1430                 goto error;
1431         else
1432                 value = ret;
1433
1434         data->sensors[LOC].current_lo_limit =
1435                 value_to_temperature(pdata->extended_range, value);
1436
1437         value = nct1008_read_reg(data->client, LOC_TEMP_HI_LIMIT_RD);
1438         if (ret < 0)
1439                 goto error;
1440         else
1441                 value = ret;
1442
1443         data->sensors[LOC].current_hi_limit =
1444                 value_to_temperature(pdata->extended_range, value);
1445
1446         nct1008_setup_shutdown_warning(data);
1447
1448         return 0;
1449 error:
1450         dev_err(&client->dev, "\n exit %s, err=%d ", __func__, ret);
1451         return ret;
1452 }
1453
1454 static int nct1008_configure_irq(struct nct1008_data *data)
1455 {
1456         data->workqueue = create_singlethread_workqueue((data->chip == NCT72) \
1457                                                         ? "nct72" : "nct1008");
1458
1459         INIT_WORK(&data->work, nct1008_work_func);
1460
1461         if (data->client->irq < 0)
1462                 return 0;
1463         else
1464                 return request_irq(data->client->irq, nct1008_irq,
1465                         IRQF_TRIGGER_LOW,
1466                         (data->chip == NCT72) ? "nct72" : "nct1008",
1467                         data);
1468 }
1469
1470 static struct nct1008_platform_data *nct1008_dt_parse(struct i2c_client *client)
1471 {
1472         struct device_node *np = client->dev.of_node;
1473         struct device_node *child_sensor;
1474         struct nct1008_platform_data *pdata;
1475         int nct72_gpio;
1476         unsigned int proc, index = 0;
1477         if (!np) {
1478                 dev_err(&client->dev,
1479                         "Cannot found the DT node\n");
1480                 goto err_parse_dt;
1481         }
1482
1483         dev_info(&client->dev, "starting parse dt\n");
1484         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
1485         if (!pdata) {
1486                 dev_err(&client->dev,
1487                         "Parse DT fails at malloc pdata\n");
1488                 goto err_parse_dt;
1489         }
1490
1491         pdata->loc_name = of_get_property(np, "sensor-name", NULL);
1492         if (pdata->loc_name == NULL) {
1493                 dev_err(&client->dev,
1494                         "Cannot found the name\n");
1495                 goto err_parse_dt;
1496         }
1497
1498         if (client->irq == 0)
1499                 client->irq = -1;
1500
1501         if (of_property_read_u32(np, "conv-rate", &proc))
1502                 goto err_parse_dt;
1503         pdata->conv_rate = proc;
1504
1505         if (of_property_read_u32(np, "supported-hwrev", &proc))
1506                 goto err_parse_dt;
1507         pdata->supported_hwrev = (bool) proc;
1508
1509         if (of_property_read_u32(np, "extended-rage", &proc))
1510                 goto err_parse_dt;
1511         pdata->extended_range = (bool) proc;
1512
1513         if (of_property_read_u32(np, "offset", &proc))
1514                 goto err_parse_dt;
1515         pdata->offset =  proc;
1516
1517         if (of_property_read_bool(np, "temp-alert-gpio")) {
1518                 nct72_gpio = of_get_named_gpio(
1519                         np,  "temp-alert-gpio", 0);
1520                 if (gpio_request(nct72_gpio, "temp_alert") < 0)
1521                         dev_err(&client->dev,
1522                                 "%s gpio request error\n", __FILE__);
1523                 if (gpio_direction_input(nct72_gpio) < 0) {
1524                         dev_err(&client->dev,
1525                                 "%s gpio direction_input fail\n", __FILE__);
1526                         gpio_free(nct72_gpio);
1527                 }
1528         }
1529
1530         for_each_child_of_node(np, child_sensor) {
1531                 if (of_property_read_u32(child_sensor, "shutdown-limit", &proc))
1532                         goto err_parse_dt;
1533                 pdata->sensors[index].shutdown_limit = proc;
1534
1535                 proc = 0;
1536                 of_property_read_u32(child_sensor, "suspend_limit_hi", &proc);
1537                 pdata->sensors[index].suspend_limit_hi = proc;
1538                 of_property_read_u32(child_sensor, "suspend_limit_lo", &proc);
1539                 pdata->sensors[index].suspend_limit_lo = proc;
1540                 index++;
1541         }
1542
1543         dev_info(&client->dev, "success parsing dt\n");
1544         client->dev.platform_data = pdata;
1545         return pdata;
1546
1547 err_parse_dt:
1548         dev_err(&client->dev, "Parsing device tree data error.\n");
1549         return NULL;
1550 }
1551
1552 /*
1553  * Manufacturer(OnSemi) recommended sequence for
1554  * Extended Range mode is as follows
1555  * 1. Place in Standby
1556  * 2. Scale the THERM and ALERT limits
1557  *      appropriately(for Extended Range mode).
1558  * 3. Enable Extended Range mode.
1559  *      ALERT mask/THERM2 mode may be done here
1560  *      as these are not critical
1561  * 4. Set Conversion Rate as required
1562  * 5. Take device out of Standby
1563  */
1564
1565 /*
1566  * function nct1008_probe takes care of initial configuration
1567  */
1568 static int nct1008_probe(struct i2c_client *client,
1569                                 const struct i2c_device_id *id)
1570 {
1571         struct nct1008_data *data;
1572         struct nct1008_platform_data *pdata;
1573         struct thermal_zone_device *zone_device;
1574         int err;
1575         int i;
1576         u64 mask = 0;
1577         char nct_loc_name[THERMAL_NAME_LENGTH];
1578         char nct_ext_name[THERMAL_NAME_LENGTH];
1579         bool ext_err;
1580         struct nct1008_sensor_platform_data *sensor_data;
1581         struct thermal_of_sensor_ops loc_sops = {
1582                 .get_temp = nct1008_loc_get_temp_as_sensor,
1583                 .get_trend = nct1008_loc_get_trend_as_sensor,
1584                 .trip_update = nct1008_loc_trip_update,
1585         };
1586
1587         struct thermal_of_sensor_ops ext_sops = {
1588                 .get_temp = nct1008_ext_get_temp_as_sensor,
1589                 .get_trend = nct1008_ext_get_trend_as_sensor,
1590                 .trip_update = nct1008_ext_trip_update,
1591         };
1592
1593         if (client->dev.of_node) {
1594                 dev_info(&client->dev, "find device tree node, parsing dt\n");
1595                 pdata = nct1008_dt_parse(client);
1596                 if (IS_ERR(pdata)) {
1597                         err = PTR_ERR(pdata);
1598                         dev_err(&client->dev,
1599                                 "Parsing of node failed, %d\n", err);
1600                         return err;
1601                 }
1602         }
1603
1604         data = kzalloc(sizeof(struct nct1008_data), GFP_KERNEL);
1605         if (!data)
1606                 return -ENOMEM;
1607
1608         data->client = client;
1609         data->chip = id->driver_data;
1610         memcpy(&data->plat_data, client->dev.platform_data,
1611                 sizeof(struct nct1008_platform_data));
1612
1613         i2c_set_clientdata(client, data);
1614         mutex_init(&data->mutex);
1615
1616         nct1008_power_control(data, true);
1617         if (!data->nct_reg) {
1618                 /* power up failure */
1619                 err = -EIO;
1620                 goto cleanup;
1621         }
1622         /* extended range recommended steps 1 through 4 taken care
1623          * in nct1008_configure_sensor function */
1624         err = nct1008_configure_sensor(data);   /* sensor is in standby */
1625         ext_err = err;
1626         if (err < 0) {
1627                 dev_err(&client->dev, "\n error file: %s : %s(), line=%d ",
1628                         __FILE__, __func__, __LINE__);
1629                 goto error;
1630         }
1631
1632         err = nct1008_configure_irq(data);
1633         if (err < 0) {
1634                 dev_err(&client->dev, "\n error file: %s : %s(), line=%d ",
1635                         __FILE__, __func__, __LINE__);
1636                 goto error;
1637         }
1638         dev_info(&client->dev, "%s: initialized\n", __func__);
1639
1640         /* extended range recommended step 5 is in nct1008_enable function */
1641         err = nct1008_enable(client);           /* sensor is running */
1642         if (err < 0) {
1643                 dev_err(&client->dev, "Error: %s, line=%d, error=%d\n",
1644                         __func__, __LINE__, err);
1645                 goto error;
1646         }
1647
1648         /* register sysfs hooks */
1649         err = sysfs_create_group(&client->dev.kobj, &nct1008_attr_group);
1650         if (err < 0) {
1651                 dev_err(&client->dev, "\n sysfs create err=%d ", err);
1652                 goto error;
1653         }
1654
1655 #ifdef CONFIG_THERMAL
1656         if (data->plat_data.loc_name) {
1657                 strcpy(nct_loc_name, "Tboard_");
1658                 strcpy(nct_ext_name, "Tdiode_");
1659                 strncat(nct_loc_name, data->plat_data.loc_name,
1660                         (THERMAL_NAME_LENGTH - strlen("Tboard_")) - 1);
1661                 strncat(nct_ext_name, data->plat_data.loc_name,
1662                         (THERMAL_NAME_LENGTH - strlen("Tdiode_")) - 1);
1663         } else {
1664                 strcpy(nct_loc_name, "Tboard");
1665                 strcpy(nct_ext_name, "Tdiode");
1666         }
1667
1668         if (client->dev.of_node) {
1669                 /* Config for the Local sensor. */
1670                 zone_device =
1671                         thermal_zone_of_sensor_register2(&client->dev, LOC,
1672                                 data, &loc_sops);
1673
1674                 if (!IS_ERR_OR_NULL(zone_device))
1675                         data->sensors[LOC].thz = zone_device;
1676
1677                 /* register External sensor if connection is good  */
1678                 zone_device =
1679                         thermal_zone_of_sensor_register2(&client->dev, EXT,
1680                                         data, &ext_sops);
1681                 if (!IS_ERR_OR_NULL(zone_device))
1682                         data->sensors[EXT].thz = zone_device;
1683         } else {
1684                 sensor_data = &data->plat_data.sensors[LOC];
1685
1686                 /* Config for the Local sensor. */
1687                 mask = 0;
1688                 for (i = 0; i < sensor_data->num_trips; i++)
1689                         if (data->plat_data.sensors[LOC].trips[i].mask)
1690                                 mask |= 1ULL << i;
1691
1692                 data->sensors[LOC].thz =
1693                         thermal_zone_device_register(nct_loc_name,
1694                                                 sensor_data->num_trips,
1695                                                 mask,
1696                                                 data,
1697                                                 &nct_loc_ops,
1698                                                 sensor_data->tzp,
1699                                                 2000,
1700                                                 0);
1701
1702                 /* Config for the External sensor. */
1703                 mask = 0;
1704                 for (i = 0; i < data->plat_data.sensors[EXT].num_trips; i++)
1705                         if (data->plat_data.sensors[EXT].trips[i].mask > 0)
1706                                 mask |= 1ULL << i;
1707
1708                 /* register External sensor if connection is good  */
1709                 data->sensors[EXT].thz = ext_err ? NULL :
1710                         thermal_zone_device_register(nct_ext_name,
1711                                 data->plat_data.sensors[EXT].num_trips,
1712                                 mask,
1713                                 data,
1714                                 &nct_ext_ops,
1715                                 data->plat_data.sensors[EXT].tzp,
1716                                 data->plat_data.sensors[EXT].passive_delay,
1717                                 data->plat_data.sensors[EXT].polling_delay);
1718         }
1719
1720         if (!IS_ERR_OR_NULL(data->sensors[LOC].thz)) {
1721                 nct1008_update(LOC, data);
1722         }
1723
1724         if (!IS_ERR_OR_NULL(data->sensors[EXT].thz)) {
1725                 nct1008_update(EXT, data);
1726                 shutdown_warn_saved_temp = data->sensors[EXT].thz->temperature;
1727         }
1728
1729 #endif
1730         return 0;
1731
1732 error:
1733         dev_err(&client->dev, "\n exit %s, err=%d ", __func__, err);
1734         nct1008_power_control(data, false);
1735 cleanup:
1736         mutex_destroy(&data->mutex);
1737         if (data->nct_reg)
1738                 regulator_put(data->nct_reg);
1739         kfree(data);
1740         return err;
1741 }
1742
1743 static int nct1008_remove(struct i2c_client *client)
1744 {
1745         struct nct1008_data *data = i2c_get_clientdata(client);
1746
1747         mutex_lock(&data->mutex);
1748         data->stop_workqueue = 1;
1749         mutex_unlock(&data->mutex);
1750
1751         cancel_work_sync(&data->work);
1752         free_irq(data->client->irq, data);
1753         sysfs_remove_group(&client->dev.kobj, &nct1008_attr_group);
1754         nct1008_power_control(data, false);
1755
1756         if (data->nct_reg)
1757                 regulator_put(data->nct_reg);
1758
1759         mutex_destroy(&data->mutex);
1760         kfree(data);
1761
1762         return 0;
1763 }
1764
1765 static void nct1008_shutdown(struct i2c_client *client)
1766 {
1767         struct nct1008_data *data = i2c_get_clientdata(client);
1768
1769         mutex_lock(&data->mutex);
1770         data->stop_workqueue = 1;
1771         mutex_unlock(&data->mutex);
1772
1773         if (data->sensors[LOC].thz) {
1774                 if (client->dev.of_node)
1775                         thermal_zone_of_sensor_unregister
1776                                 (&(client->dev), data->sensors[LOC].thz);
1777                 else
1778                         thermal_zone_device_unregister(data->sensors[LOC].thz);
1779                 data->sensors[LOC].thz = NULL;
1780         }
1781         if (data->sensors[EXT].thz) {
1782                 if (client->dev.of_node)
1783                         thermal_zone_of_sensor_unregister
1784                                 (&(client->dev), data->sensors[EXT].thz);
1785                 else
1786                         thermal_zone_device_unregister(data->sensors[EXT].thz);
1787                 data->sensors[EXT].thz = NULL;
1788         }
1789
1790         cancel_work_sync(&data->work);
1791
1792         if (client->irq)
1793                 disable_irq(client->irq);
1794
1795         mutex_lock(&data->mutex);
1796         data->nct_disabled = 1;
1797         mutex_unlock(&data->mutex);
1798 }
1799
1800 #ifdef CONFIG_PM_SLEEP
1801 static int nct1008_suspend_powerdown(struct device *dev)
1802 {
1803         struct i2c_client *client = to_i2c_client(dev);
1804         int err;
1805         struct nct1008_data *data = i2c_get_clientdata(client);
1806
1807         mutex_lock(&data->mutex);
1808         data->stop_workqueue = 1;
1809         mutex_unlock(&data->mutex);
1810         cancel_work_sync(&data->work);
1811         disable_irq(client->irq);
1812         err = nct1008_disable(client);
1813         nct1008_power_control(data, false);
1814         return err;
1815 }
1816
1817 static int nct1008_suspend_wakeup(struct device *dev)
1818 {
1819         struct i2c_client *client = to_i2c_client(dev);
1820         int err;
1821         struct nct1008_data *data = i2c_get_clientdata(client);
1822         long temp;
1823         int sensor_nr;
1824         struct nct1008_sensor_platform_data *sensor_data;
1825
1826         for (sensor_nr = 0; sensor_nr < SENSORS_COUNT; sensor_nr++) {
1827                 sensor_data = &data->plat_data.sensors[sensor_nr];
1828
1829                 err = nct1008_get_temp_common(sensor_nr, data, &temp);
1830
1831                 if (err)
1832                         goto error;
1833
1834                 if (temp > sensor_data->suspend_limit_lo)
1835                         err = nct1008_thermal_set_limits(sensor_nr, data,
1836                                 sensor_data->suspend_limit_lo,
1837                                 NCT1008_MAX_TEMP * 1000);
1838                 else
1839                         err = nct1008_thermal_set_limits(sensor_nr, data,
1840                                 NCT1008_MIN_TEMP * 1000,
1841                                 sensor_data->suspend_limit_hi);
1842
1843                 if (err)
1844                         goto error;
1845         }
1846
1847         /* Enable NCT wake. */
1848         err = enable_irq_wake(client->irq);
1849         if (err)
1850                 dev_err(&client->dev, "Error: %s, error=%d. failed to enable NCT wakeup\n",
1851                         __func__, err);
1852         return err;
1853
1854 error:
1855         dev_err(&client->dev, "\n error in file=: %s %s() line=%d: "
1856                 "error=%d. Can't set correct LP1 alarm limits or set wakeup irq, "
1857                 "shutting down device", __FILE__, __func__, __LINE__, err);
1858
1859         return nct1008_suspend_powerdown(dev);
1860 }
1861
1862 static int nct1008_suspend(struct device *dev)
1863 {
1864         struct i2c_client *client = to_i2c_client(dev);
1865         struct nct1008_data *data = i2c_get_clientdata(client);
1866
1867         if (data->plat_data.suspend_with_wakeup &&
1868                 data->plat_data.suspend_with_wakeup())
1869                 return nct1008_suspend_wakeup(dev);
1870         else
1871                 return nct1008_suspend_powerdown(dev);
1872 }
1873
1874
1875 static int nct1008_resume_wakeup(struct device *dev)
1876 {
1877         int err = 0;
1878         struct i2c_client *client = to_i2c_client(dev);
1879
1880         err = disable_irq_wake(client->irq);
1881         if (err) {
1882                 dev_err(&client->dev, "Error: %s, error=%d. failed to disable NCT "
1883                                 "wakeup\n", __func__, err);
1884                 return err;
1885         }
1886
1887         /* NCT wasn't powered down, so IRQ is still enabled. */
1888         /* Disable it before calling update */
1889         disable_irq(client->irq);
1890
1891         return err;
1892 }
1893
1894 static int nct1008_resume_powerdown(struct device *dev)
1895 {
1896         struct i2c_client *client = to_i2c_client(dev);
1897         int err = 0;
1898         struct nct1008_data *data = i2c_get_clientdata(client);
1899
1900         nct1008_power_control(data, true);
1901         nct1008_configure_sensor(data);
1902         err = nct1008_enable(client);
1903         if (err < 0) {
1904                 dev_err(&client->dev, "Error: %s, error=%d\n",
1905                         __func__, err);
1906                 return err;
1907         }
1908
1909         return err;
1910 }
1911
1912 static int nct1008_resume(struct device *dev)
1913 {
1914         struct i2c_client *client = to_i2c_client(dev);
1915         int err;
1916         struct nct1008_data *data = i2c_get_clientdata(client);
1917
1918         if (data->plat_data.suspend_with_wakeup &&
1919                 data->plat_data.suspend_with_wakeup())
1920                 err = nct1008_resume_wakeup(dev);
1921         else
1922                 err = nct1008_resume_powerdown(dev);
1923
1924         if (err)
1925                 return err;
1926
1927         nct1008_update(LOC, data);
1928         nct1008_update(EXT, data);
1929         mutex_lock(&data->mutex);
1930         data->stop_workqueue = 0;
1931         mutex_unlock(&data->mutex);
1932         enable_irq(client->irq);
1933
1934         return 0;
1935 }
1936
1937 static const struct dev_pm_ops nct1008_pm_ops = {
1938         .suspend        = nct1008_suspend,
1939         .resume         = nct1008_resume,
1940 };
1941
1942 #endif
1943
1944 static const struct i2c_device_id nct1008_id[] = {
1945         { "nct1008", NCT1008 },
1946         { "nct72", NCT72},
1947         {}
1948 };
1949 MODULE_DEVICE_TABLE(i2c, nct1008_id);
1950
1951 static const struct of_device_id nct1008_of_match[] = {
1952         {.compatible = "onsemi,nct72", },
1953         { }
1954 };
1955
1956 static struct i2c_driver nct1008_driver = {
1957         .driver = {
1958                 .name   = "nct1008_nct72",
1959 #ifdef CONFIG_PM_SLEEP
1960                 .pm = &nct1008_pm_ops,
1961 #endif
1962                 .of_match_table = nct1008_of_match,
1963         },
1964         .probe          = nct1008_probe,
1965         .remove         = nct1008_remove,
1966         .id_table       = nct1008_id,
1967         .shutdown       = nct1008_shutdown,
1968 };
1969
1970 static int __init nct1008_sync_thz(struct device *dev, void *unused)
1971 {
1972         struct nct1008_data *data = dev_get_drvdata(dev);
1973         if (data->sensors[LOC].thz)
1974                 thermal_zone_device_update(data->sensors[LOC].thz);
1975         if (data->sensors[EXT].thz)
1976                 thermal_zone_device_update(data->sensors[EXT].thz);
1977         return 0;
1978 }
1979
1980 static int __init nct1008_sync(void)
1981 {
1982         return driver_for_each_device(
1983                 &nct1008_driver.driver, NULL, NULL, nct1008_sync_thz);
1984 }
1985 late_initcall_sync(nct1008_sync);
1986
1987 static int __init nct1008_init(void)
1988 {
1989         return i2c_add_driver(&nct1008_driver);
1990 }
1991
1992 static void __exit nct1008_exit(void)
1993 {
1994         i2c_del_driver(&nct1008_driver);
1995 }
1996
1997 MODULE_DESCRIPTION("Temperature sensor driver for OnSemi NCT1008/NCT72");
1998 MODULE_LICENSE("GPL");
1999
2000 module_init(nct1008_init);
2001 module_exit(nct1008_exit);