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-2011, NVIDIA Corporation.
   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/delay.h>
  33 #include <linux/regulator/consumer.h>
  34
  35 #define DRIVER_NAME "nct1008"
  36
  37 /* Register Addresses */
  38 #define LOCAL_TEMP_RD                   0x00
  39 #define EXT_TEMP_RD_HI                  0x01
  40 #define EXT_TEMP_RD_LO                  0x10
  41 #define STATUS_RD                       0x02
  42 #define CONFIG_RD                       0x03
  43
  44 #define LOCAL_TEMP_HI_LIMIT_RD          0x05
  45 #define LOCAL_TEMP_LO_LIMIT_RD          0x06
  46
  47 #define EXT_TEMP_HI_LIMIT_HI_BYTE_RD    0x07
  48 #define EXT_TEMP_LO_LIMIT_HI_BYTE_RD    0x08
  49
  50 #define CONFIG_WR                       0x09
  51 #define CONV_RATE_WR                    0x0A
  52 #define LOCAL_TEMP_HI_LIMIT_WR          0x0B
  53 #define LOCAL_TEMP_LO_LIMIT_WR          0x0C
  54 #define EXT_TEMP_HI_LIMIT_HI_BYTE_WR    0x0D
  55 #define EXT_TEMP_LO_LIMIT_HI_BYTE_WR    0x0E
  56 #define ONE_SHOT                        0x0F
  57 #define OFFSET_WR                       0x11
  58 #define OFFSET_QUARTER_WR               0x12
  59 #define EXT_THERM_LIMIT_WR              0x19
  60 #define LOCAL_THERM_LIMIT_WR            0x20
  61 #define THERM_HYSTERESIS_WR             0x21
  62
  63 /* Configuration Register Bits */
  64 #define EXTENDED_RANGE_BIT              BIT(2)
  65 #define THERM2_BIT                      BIT(5)
  66 #define STANDBY_BIT                     BIT(6)
  67 #define ALERT_BIT                       BIT(7)
  68
  69 /* Max Temperature Measurements */
  70 #define EXTENDED_RANGE_OFFSET           64U
  71 #define STANDARD_RANGE_MAX              127U
  72 #define EXTENDED_RANGE_MAX              (150U + EXTENDED_RANGE_OFFSET)
  73
  74 #define NCT1008_MIN_TEMP -64
  75 #define NCT1008_MAX_TEMP 191
  76
  77 #define MAX_STR_PRINT 50
  78
  79 #define MAX_CONV_TIME_ONESHOT_MS (52)
  80 #define CELSIUS_TO_MILLICELSIUS(x) ((x)*1000)
  81 #define MILLICELSIUS_TO_CELSIUS(x) ((x)/1000)
  82
  83
  84 static int conv_period_ms_table[] =
  85         {16000, 8000, 4000, 2000, 1000, 500, 250, 125, 63, 32, 16};
  86
  87 static inline s8 value_to_temperature(bool extended, u8 value)
  88 {
  89         return extended ? (s8)(value - EXTENDED_RANGE_OFFSET) : (s8)value;
  90 }
  91
  92 static inline u8 temperature_to_value(bool extended, s8 temp)
  93 {
  94         return extended ? (u8)(temp + EXTENDED_RANGE_OFFSET) : (u8)temp;
  95 }
  96
  97 static int nct1008_get_temp(struct device *dev, long *pTemp)
  98 {
  99         struct i2c_client *client = to_i2c_client(dev);
 100         struct nct1008_platform_data *pdata = client->dev.platform_data;
 101         s8 temp_local;
 102         u8 temp_ext_lo;
 103         s8 temp_ext_hi;
 104         long temp_ext_milli;
 105         long temp_local_milli;
 106         u8 value;
 107
 108         /* Read Local Temp */
 109         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_RD);
 110         if (value < 0)
 111                 goto error;
 112         temp_local = value_to_temperature(pdata->ext_range, value);
 113         temp_local_milli = CELSIUS_TO_MILLICELSIUS(temp_local);
 114
 115         /* Read External Temp */
 116         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
 117         if (value < 0)
 118                 goto error;
 119         temp_ext_lo = (value >> 6);
 120
 121         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
 122         if (value < 0)
 123                 goto error;
 124         temp_ext_hi = value_to_temperature(pdata->ext_range, value);
 125
 126         temp_ext_milli = CELSIUS_TO_MILLICELSIUS(temp_ext_hi) +
 127                                 temp_ext_lo * 250;
 128
 129         /* Return max between Local and External Temp */
 130         *pTemp = max(temp_local_milli, temp_ext_milli);
 131
 132         dev_dbg(dev, "\n %s: ret temp=%ldC ", __func__, *pTemp);
 133         return 0;
 134 error:
 135         dev_err(&client->dev, "\n error in file=: %s %s() line=%d: "
 136                 "error=%d ", __FILE__, __func__, __LINE__, value);
 137         return value;
 138 }
 139
 140 static ssize_t nct1008_show_temp(struct device *dev,
 141         struct device_attribute *attr, char *buf)
 142 {
 143         struct i2c_client *client = to_i2c_client(dev);
 144         struct nct1008_platform_data *pdata = client->dev.platform_data;
 145         s8 temp1 = 0;
 146         s8 temp = 0;
 147         u8 temp2 = 0;
 148         int value = 0;
 149
 150         if (!dev || !buf || !attr)
 151                 return -EINVAL;
 152
 153         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_RD);
 154         if (value < 0)
 155                 goto error;
 156         temp1 = value_to_temperature(pdata->ext_range, value);
 157
 158         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
 159         if (value < 0)
 160                 goto error;
 161         temp2 = (value >> 6);
 162         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
 163         if (value < 0)
 164                 goto error;
 165         temp = value_to_temperature(pdata->ext_range, value);
 166
 167         return snprintf(buf, MAX_STR_PRINT, "%d %d.%d\n",
 168                 temp1, temp, temp2 * 25);
 169
 170 error:
 171         return snprintf(buf, MAX_STR_PRINT,
 172                 "Error read local/ext temperature\n");
 173 }
 174
 175 static ssize_t nct1008_show_temp_overheat(struct device *dev,
 176                                 struct device_attribute *attr,
 177                                 char *buf)
 178 {
 179         struct i2c_client *client = to_i2c_client(dev);
 180         struct nct1008_platform_data *pdata = client->dev.platform_data;
 181         int value;
 182         s8 temp, temp2;
 183
 184         /* Local temperature h/w shutdown limit */
 185         value = i2c_smbus_read_byte_data(client, LOCAL_THERM_LIMIT_WR);
 186         if (value < 0)
 187                 goto error;
 188         temp = value_to_temperature(pdata->ext_range, value);
 189
 190         /* External temperature h/w shutdown limit */
 191         value = i2c_smbus_read_byte_data(client, EXT_THERM_LIMIT_WR);
 192         if (value < 0)
 193                 goto error;
 194         temp2 = value_to_temperature(pdata->ext_range, value);
 195
 196         return snprintf(buf, MAX_STR_PRINT, "%d %d\n", temp, temp2);
 197 error:
 198         dev_err(dev, "%s: failed to read temperature-overheat "
 199                 "\n", __func__);
 200         return snprintf(buf, MAX_STR_PRINT, " Rd overheat Error\n");
 201 }
 202
 203 static ssize_t nct1008_set_temp_overheat(struct device *dev,
 204                         struct device_attribute *attr,
 205                         const char *buf, size_t count)
 206 {
 207         long int num;
 208         int err;
 209         u8 temp;
 210         long currTemp;
 211         struct i2c_client *client = to_i2c_client(dev);
 212         struct nct1008_platform_data *pdata = client->dev.platform_data;
 213         char bufTemp[MAX_STR_PRINT];
 214         char bufOverheat[MAX_STR_PRINT];
 215         unsigned int ret;
 216
 217         if (strict_strtol(buf, 0, &num)) {
 218                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 219                         __LINE__, __func__);
 220                 return -EINVAL;
 221         }
 222         if (((int)num < NCT1008_MIN_TEMP) || ((int)num >= NCT1008_MAX_TEMP)) {
 223                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 224                         __LINE__, __func__);
 225                 return -EINVAL;
 226         }
 227         /* check for system power down */
 228         err = nct1008_get_temp(dev, &currTemp);
 229         if (err)
 230                 goto error;
 231
 232         currTemp = MILLICELSIUS_TO_CELSIUS(currTemp);
 233
 234         if (currTemp >= (int)num) {
 235                 ret = nct1008_show_temp(dev, attr, bufTemp);
 236                 ret = nct1008_show_temp_overheat(dev, attr, bufOverheat);
 237                 dev_err(dev, "\nCurrent temp: %s ", bufTemp);
 238                 dev_err(dev, "\nOld overheat limit: %s ", bufOverheat);
 239                 dev_err(dev, "\nReset from overheat: curr temp=%ld, "
 240                         "new overheat temp=%d\n\n", currTemp, (int)num);
 241         }
 242
 243         /* External temperature h/w shutdown limit */
 244         temp = temperature_to_value(pdata->ext_range, (s8)num);
 245         err = i2c_smbus_write_byte_data(client, EXT_THERM_LIMIT_WR, temp);
 246         if (err < 0)
 247                 goto error;
 248
 249         /* Local temperature h/w shutdown limit */
 250         temp = temperature_to_value(pdata->ext_range, (s8)num);
 251         err = i2c_smbus_write_byte_data(client, LOCAL_THERM_LIMIT_WR, temp);
 252         if (err < 0)
 253                 goto error;
 254         return count;
 255 error:
 256         dev_err(dev, " %s: failed to set temperature-overheat\n", __func__);
 257         return err;
 258 }
 259
 260 static ssize_t nct1008_show_temp_alert(struct device *dev,
 261                                 struct device_attribute *attr,
 262                                 char *buf)
 263 {
 264         struct i2c_client *client = to_i2c_client(dev);
 265         struct nct1008_platform_data *pdata = client->dev.platform_data;
 266         int value;
 267         s8 temp_hi, temp_lo;
 268         /* External Temperature Throttling hi-limit */
 269         value = i2c_smbus_read_byte_data(client, EXT_TEMP_HI_LIMIT_HI_BYTE_RD);
 270         if (value < 0)
 271                 goto error;
 272         temp_hi = value_to_temperature(pdata->ext_range, value);
 273
 274         /* External Temperature Throttling lo-limit */
 275         value = i2c_smbus_read_byte_data(client, EXT_TEMP_LO_LIMIT_HI_BYTE_RD);
 276         if (value < 0)
 277                 goto error;
 278         temp_lo = value_to_temperature(pdata->ext_range, value);
 279
 280         return snprintf(buf, MAX_STR_PRINT, "lo:%d hi:%d\n", temp_lo, temp_hi);
 281 error:
 282         dev_err(dev, "%s: failed to read temperature-alert\n", __func__);
 283         return snprintf(buf, MAX_STR_PRINT, " Rd alert Error\n");
 284 }
 285
 286 static ssize_t nct1008_set_temp_alert(struct device *dev,
 287                         struct device_attribute *attr,
 288                         const char *buf, size_t count)
 289 {
 290         long int num;
 291         int value;
 292         int err;
 293         struct i2c_client *client = to_i2c_client(dev);
 294         struct nct1008_platform_data *pdata = client->dev.platform_data;
 295
 296         if (strict_strtol(buf, 0, &num)) {
 297                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 298                         __LINE__, __func__);
 299                 return -EINVAL;
 300         }
 301         if (((int)num < NCT1008_MIN_TEMP) || ((int)num >= NCT1008_MAX_TEMP)) {
 302                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
 303                         __LINE__, __func__);
 304                 return -EINVAL;
 305         }
 306
 307         /* External Temperature Throttling limit */
 308         value = temperature_to_value(pdata->ext_range, (s8)num);
 309         err = i2c_smbus_write_byte_data(client, EXT_TEMP_HI_LIMIT_HI_BYTE_WR,
 310                 value);
 311         if (err < 0)
 312                 goto error;
 313
 314         /* Local Temperature Throttling limit */
 315         err = i2c_smbus_write_byte_data(client, LOCAL_TEMP_HI_LIMIT_WR,
 316                 value);
 317         if (err < 0)
 318                 goto error;
 319
 320         return count;
 321 error:
 322         dev_err(dev, "%s: failed to set temperature-alert "
 323                 "\n", __func__);
 324         return err;
 325 }
 326
 327 static ssize_t nct1008_show_ext_temp(struct device *dev,
 328         struct device_attribute *attr, char *buf)
 329 {
 330         struct i2c_client *client = to_i2c_client(dev);
 331         struct nct1008_platform_data *pdata = client->dev.platform_data;
 332         s8 temp_value;
 333         int data = 0;
 334         int data_lo;
 335
 336         if (!dev || !buf || !attr)
 337                 return -EINVAL;
 338
 339         /* When reading the full external temperature value, read the
 340          * LSB first. This causes the MSB to be locked (that is, the
 341          * ADC does not write to it) until it is read */
 342         data_lo = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
 343         if (data_lo < 0) {
 344                 dev_err(&client->dev, "%s: failed to read "
 345                         "ext_temperature, i2c error=%d\n", __func__, data_lo);
 346                 goto error;
 347         }
 348
 349         data = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
 350         if (data < 0) {
 351                 dev_err(&client->dev, "%s: failed to read "
 352                         "ext_temperature, i2c error=%d\n", __func__, data);
 353                 goto error;
 354         }
 355
 356         temp_value = value_to_temperature(pdata->ext_range, data);
 357
 358         return snprintf(buf, MAX_STR_PRINT, "%d.%d\n", temp_value,
 359                 (25 * (data_lo >> 6)));
 360 error:
 361         return snprintf(buf, MAX_STR_PRINT, "Error read ext temperature\n");
 362 }
 363
 364 static DEVICE_ATTR(temperature, S_IRUGO, nct1008_show_temp, NULL);
 365 static DEVICE_ATTR(temperature_overheat, (S_IRUGO | (S_IWUSR | S_IWGRP)),
 366                 nct1008_show_temp_overheat, nct1008_set_temp_overheat);
 367 static DEVICE_ATTR(temperature_alert, (S_IRUGO | (S_IWUSR | S_IWGRP)),
 368                 nct1008_show_temp_alert, nct1008_set_temp_alert);
 369 static DEVICE_ATTR(ext_temperature, S_IRUGO, nct1008_show_ext_temp, NULL);
 370
 371 static struct attribute *nct1008_attributes[] = {
 372         &dev_attr_temperature.attr,
 373         &dev_attr_temperature_overheat.attr,
 374         &dev_attr_temperature_alert.attr,
 375         &dev_attr_ext_temperature.attr,
 376         NULL
 377 };
 378
 379 static const struct attribute_group nct1008_attr_group = {
 380         .attrs = nct1008_attributes,
 381 };
 382
 383 #ifdef CONFIG_DEBUG_FS
 384 #include <linux/debugfs.h>
 385 #include <linux/seq_file.h>
 386 static void print_reg(const char *reg_name, struct seq_file *s,
 387                 int offset)
 388 {
 389         struct nct1008_data *nct_data = s->private;
 390         int ret;
 391
 392         ret = i2c_smbus_read_byte_data(nct_data->client,
 393                 offset);
 394         if (ret >= 0)
 395                 seq_printf(s, "Reg %s Addr = 0x%02x Reg 0x%02x "
 396                 "Value 0x%02x\n", reg_name,
 397                 nct_data->client->addr,
 398                         offset, ret);
 399         else
 400                 seq_printf(s, "%s: line=%d, i2c read error=%d\n",
 401                 __func__, __LINE__, ret);
 402 }
 403
 404 static int dbg_nct1008_show(struct seq_file *s, void *unused)
 405 {
 406         seq_printf(s, "nct1008 Registers\n");
 407         seq_printf(s, "------------------\n");
 408         print_reg("Local Temp Value    ",     s, 0x00);
 409         print_reg("Ext Temp Value Hi   ",     s, 0x01);
 410         print_reg("Status              ",     s, 0x02);
 411         print_reg("Configuration       ",     s, 0x03);
 412         print_reg("Conversion Rate     ",     s, 0x04);
 413         print_reg("Local Temp Hi Limit ",     s, 0x05);
 414         print_reg("Local Temp Lo Limit ",     s, 0x06);
 415         print_reg("Ext Temp Hi Limit Hi",     s, 0x07);
 416         print_reg("Ext Temp Hi Limit Lo",     s, 0x13);
 417         print_reg("Ext Temp Lo Limit Hi",     s, 0x08);
 418         print_reg("Ext Temp Lo Limit Lo",     s, 0x14);
 419         print_reg("Ext Temp Value Lo   ",     s, 0x10);
 420         print_reg("Ext Temp Offset Hi  ",     s, 0x11);
 421         print_reg("Ext Temp Offset Lo  ",     s, 0x12);
 422         print_reg("Ext THERM Limit     ",     s, 0x19);
 423         print_reg("Local THERM Limit   ",     s, 0x20);
 424         print_reg("THERM Hysteresis    ",     s, 0x21);
 425         print_reg("Consecutive ALERT   ",     s, 0x22);
 426         return 0;
 427 }
 428
 429 static int dbg_nct1008_open(struct inode *inode, struct file *file)
 430 {
 431         return single_open(file, dbg_nct1008_show, inode->i_private);
 432 }
 433
 434 static const struct file_operations debug_fops = {
 435         .open           = dbg_nct1008_open,
 436         .read           = seq_read,
 437         .llseek         = seq_lseek,
 438         .release        = single_release,
 439 };
 440
 441 static int __init nct1008_debuginit(struct nct1008_data *nct)
 442 {
 443         int err = 0;
 444         struct dentry *d;
 445         d = debugfs_create_file("nct1008", S_IRUGO, NULL,
 446                         (void *)nct, &debug_fops);
 447         if ((!d) || IS_ERR(d)) {
 448                 dev_err(&nct->client->dev, "Error: %s debugfs_create_file"
 449                         " returned an error\n", __func__);
 450                 err = -ENOENT;
 451                 goto end;
 452         }
 453         if (d == ERR_PTR(-ENODEV)) {
 454                 dev_err(&nct->client->dev, "Error: %s debugfs not supported "
 455                         "error=-ENODEV\n", __func__);
 456                 err = -ENODEV;
 457         } else {
 458                 nct->dent = d;
 459         }
 460 end:
 461         return err;
 462 }
 463 #else
 464 static int __init nct1008_debuginit(struct nct1008_data *nct)
 465 {
 466         return 0;
 467 }
 468 #endif
 469
 470 static int nct1008_enable(struct i2c_client *client)
 471 {
 472         struct nct1008_data *data = i2c_get_clientdata(client);
 473         int err;
 474
 475         err = i2c_smbus_write_byte_data(client, CONFIG_WR,
 476                                   data->config & ~STANDBY_BIT);
 477         if (err < 0)
 478                 dev_err(&client->dev, "%s, line=%d, i2c write error=%d\n",
 479                 __func__, __LINE__, err);
 480         return err;
 481 }
 482
 483 static int nct1008_disable(struct i2c_client *client)
 484 {
 485         struct nct1008_data *data = i2c_get_clientdata(client);
 486         int err;
 487
 488         err = i2c_smbus_write_byte_data(client, CONFIG_WR,
 489                                   data->config | STANDBY_BIT);
 490         if (err < 0)
 491                 dev_err(&client->dev, "%s, line=%d, i2c write error=%d\n",
 492                 __func__, __LINE__, err);
 493         return err;
 494 }
 495
 496 static int nct1008_within_limits(struct nct1008_data *data)
 497 {
 498         int intr_status;
 499
 500         intr_status = i2c_smbus_read_byte_data(data->client, STATUS_RD);
 501
 502         return !(intr_status & (BIT(3) | BIT(4)));
 503 }
 504
 505 static void nct1008_work_func(struct work_struct *work)
 506 {
 507         struct nct1008_data *data = container_of(work, struct nct1008_data,
 508                                                 work);
 509         int intr_status;
 510         struct timespec ts;
 511
 512         nct1008_disable(data->client);
 513
 514         if (data->alert_func)
 515                 if (!nct1008_within_limits(data))
 516                         data->alert_func(data->alert_data);
 517
 518         /* Initiate one-shot conversion */
 519         i2c_smbus_write_byte_data(data->client, ONE_SHOT, 0x1);
 520
 521         /* Give hardware necessary time to finish conversion */
 522         ts = ns_to_timespec(MAX_CONV_TIME_ONESHOT_MS * 1000 * 1000);
 523         hrtimer_nanosleep(&ts, NULL, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 524
 525         intr_status = i2c_smbus_read_byte_data(data->client, STATUS_RD);
 526
 527         nct1008_enable(data->client);
 528
 529         enable_irq(data->client->irq);
 530 }
 531
 532 static irqreturn_t nct1008_irq(int irq, void *dev_id)
 533 {
 534         struct nct1008_data *data = dev_id;
 535
 536         disable_irq_nosync(irq);
 537         queue_work(data->workqueue, &data->work);
 538
 539         return IRQ_HANDLED;
 540 }
 541
 542 static void nct1008_power_control(struct nct1008_data *data, bool is_enable)
 543 {
 544         int ret;
 545         if (!data->nct_reg) {
 546                 data->nct_reg = regulator_get(&data->client->dev, "vdd");
 547                 if (IS_ERR_OR_NULL(data->nct_reg)) {
 548                         if (PTR_ERR(data->nct_reg) == -ENODEV)
 549                                 dev_info(&data->client->dev,
 550                                         "no regulator found for vdd."
 551                                         " Assuming vdd is always powered");
 552                         else
 553                                 dev_warn(&data->client->dev, "Error [%ld] in "
 554                                         "getting the regulator handle for"
 555                                         " vdd\n", PTR_ERR(data->nct_reg));
 556                         data->nct_reg = NULL;
 557                         return;
 558                 }
 559         }
 560         if (is_enable)
 561                 ret = regulator_enable(data->nct_reg);
 562         else
 563                 ret = regulator_disable(data->nct_reg);
 564
 565         if (ret < 0)
 566                 dev_err(&data->client->dev, "Error in %s rail vdd_nct1008, "
 567                         "error %d\n", (is_enable) ? "enabling" : "disabling",
 568                         ret);
 569         else
 570                 dev_info(&data->client->dev, "success in %s rail vdd_nct1008\n",
 571                         (is_enable) ? "enabling" : "disabling");
 572 }
 573
 574 static int __devinit nct1008_configure_sensor(struct nct1008_data* data)
 575 {
 576         struct i2c_client *client = data->client;
 577         struct nct1008_platform_data *pdata = client->dev.platform_data;
 578         u8 value;
 579         s8 temp;
 580         u8 temp2;
 581         int err;
 582
 583         if (!pdata || !pdata->supported_hwrev)
 584                 return -ENODEV;
 585
 586         /* Place in Standby */
 587         data->config = STANDBY_BIT;
 588         err = i2c_smbus_write_byte_data(client, CONFIG_WR, data->config);
 589         if (err)
 590                 goto error;
 591
 592         /* External temperature h/w shutdown limit */
 593         value = temperature_to_value(pdata->ext_range, NCT1008_MAX_TEMP);
 594         err = i2c_smbus_write_byte_data(client, EXT_THERM_LIMIT_WR, value);
 595         if (err)
 596                 goto error;
 597
 598         /* Local temperature h/w shutdown limit */
 599         value = temperature_to_value(pdata->ext_range, NCT1008_MAX_TEMP);
 600         err = i2c_smbus_write_byte_data(client, LOCAL_THERM_LIMIT_WR, value);
 601         if (err)
 602                 goto error;
 603
 604         /* set extended range mode if needed */
 605         if (pdata->ext_range)
 606                 data->config |= EXTENDED_RANGE_BIT;
 607         data->config &= ~(THERM2_BIT | ALERT_BIT);
 608
 609         err = i2c_smbus_write_byte_data(client, CONFIG_WR, data->config);
 610         if (err)
 611                 goto error;
 612
 613         /* Temperature conversion rate */
 614         err = i2c_smbus_write_byte_data(client, CONV_RATE_WR, pdata->conv_rate);
 615         if (err)
 616                 goto error;
 617
 618         data->conv_period_ms = conv_period_ms_table[pdata->conv_rate];
 619
 620         /* Setup local hi and lo limits */
 621         err = i2c_smbus_write_byte_data(client,
 622                 LOCAL_TEMP_HI_LIMIT_WR, NCT1008_MAX_TEMP);
 623         if (err)
 624                 goto error;
 625
 626         err = i2c_smbus_write_byte_data(client,
 627                 LOCAL_TEMP_LO_LIMIT_WR, 0);
 628         if (err)
 629                 goto error;
 630
 631         /* Setup external hi and lo limits */
 632         err = i2c_smbus_write_byte_data(client,
 633                 EXT_TEMP_LO_LIMIT_HI_BYTE_WR, 0);
 634         if (err)
 635                 goto error;
 636         err = i2c_smbus_write_byte_data(client, EXT_TEMP_HI_LIMIT_HI_BYTE_WR,
 637                         NCT1008_MAX_TEMP);
 638         if (err)
 639                 goto error;
 640
 641         /* read initial temperature */
 642         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_RD);
 643         if (value < 0) {
 644                 err = value;
 645                 goto error;
 646         }
 647         temp = value_to_temperature(pdata->ext_range, value);
 648         dev_dbg(&client->dev, "\n initial local temp = %d ", temp);
 649
 650         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
 651         if (value < 0) {
 652                 err = value;
 653                 goto error;
 654         }
 655         temp2 = (value >> 6);
 656         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
 657         if (value < 0) {
 658                 err = value;
 659                 goto error;
 660         }
 661         temp = value_to_temperature(pdata->ext_range, value);
 662
 663         if (temp2 > 0)
 664                 dev_dbg(&client->dev, "\n initial ext temp = %d.%d deg",
 665                                 temp, temp2 * 25);
 666         else
 667                 dev_dbg(&client->dev, "\n initial ext temp = %d.0 deg", temp);
 668
 669         /* Remote channel offset */
 670         err = i2c_smbus_write_byte_data(client, OFFSET_WR, pdata->offset / 4);
 671         if (err < 0)
 672                 goto error;
 673
 674         /* Remote channel offset fraction (quarters) */
 675         err = i2c_smbus_write_byte_data(client, OFFSET_QUARTER_WR,
 676                                         (pdata->offset % 4) << 6);
 677         if (err < 0)
 678                 goto error;
 679
 680         /* register sysfs hooks */
 681         err = sysfs_create_group(&client->dev.kobj, &nct1008_attr_group);
 682         if (err < 0) {
 683                 dev_err(&client->dev, "\n sysfs create err=%d ", err);
 684                 goto error;
 685         }
 686
 687         return 0;
 688 error:
 689         dev_err(&client->dev, "\n exit %s, err=%d ", __func__, err);
 690         return err;
 691 }
 692
 693 static int __devinit nct1008_configure_irq(struct nct1008_data *data)
 694 {
 695         data->workqueue = create_singlethread_workqueue("nct1008");
 696
 697         INIT_WORK(&data->work, nct1008_work_func);
 698
 699         if (data->client->irq < 0)
 700                 return 0;
 701         else
 702                 return request_irq(data->client->irq, nct1008_irq,
 703                         IRQF_TRIGGER_LOW,
 704                         DRIVER_NAME, data);
 705 }
 706
 707 int nct1008_thermal_get_temp(struct nct1008_data *data, long *temp)
 708 {
 709         return nct1008_get_temp(&data->client->dev, temp);
 710 }
 711
 712 int nct1008_thermal_get_temp_low(struct nct1008_data *data, long *temp)
 713 {
 714         *temp = 0;
 715         return 0;
 716 }
 717
 718 int nct1008_thermal_set_limits(struct nct1008_data *data,
 719                                 long lo_limit_milli,
 720                                 long hi_limit_milli)
 721 {
 722         int err;
 723         u8 value;
 724         bool extended_range = data->plat_data.ext_range;
 725         long lo_limit = MILLICELSIUS_TO_CELSIUS(lo_limit_milli);
 726         long hi_limit = MILLICELSIUS_TO_CELSIUS(hi_limit_milli);
 727
 728         if (lo_limit >= hi_limit)
 729                 return -EINVAL;
 730
 731         if (data->current_lo_limit != lo_limit) {
 732                 value = temperature_to_value(extended_range, lo_limit);
 733                 pr_debug("%s: set lo_limit %ld\n", __func__, lo_limit);
 734                 err = i2c_smbus_write_byte_data(data->client,
 735                                 EXT_TEMP_LO_LIMIT_HI_BYTE_WR, value);
 736                 if (err)
 737                         return err;
 738
 739                 data->current_lo_limit = lo_limit;
 740         }
 741
 742         if (data->current_hi_limit != hi_limit) {
 743                 value = temperature_to_value(extended_range, hi_limit);
 744                 pr_debug("%s: set hi_limit %ld\n", __func__, hi_limit);
 745                 err = i2c_smbus_write_byte_data(data->client,
 746                                 EXT_TEMP_HI_LIMIT_HI_BYTE_WR, value);
 747                 if (err)
 748                         return err;
 749
 750                 data->current_hi_limit = hi_limit;
 751         }
 752
 753         return 0;
 754 }
 755
 756 int nct1008_thermal_set_alert(struct nct1008_data *data,
 757                                 void (*alert_func)(void *),
 758                                 void *alert_data)
 759 {
 760         data->alert_data = alert_data;
 761         data->alert_func = alert_func;
 762
 763         return 0;
 764 }
 765
 766 int nct1008_thermal_set_shutdown_temp(struct nct1008_data *data,
 767                                         long shutdown_temp_milli)
 768 {
 769         struct i2c_client *client = data->client;
 770         struct nct1008_platform_data *pdata = client->dev.platform_data;
 771         int err;
 772         u8 value;
 773         long shutdown_temp;
 774
 775         shutdown_temp = MILLICELSIUS_TO_CELSIUS(shutdown_temp_milli);
 776
 777         /* External temperature h/w shutdown limit */
 778         value = temperature_to_value(pdata->ext_range, shutdown_temp);
 779         err = i2c_smbus_write_byte_data(client, EXT_THERM_LIMIT_WR, value);
 780         if (err)
 781                 return err;
 782
 783         /* Local temperature h/w shutdown limit */
 784         value = temperature_to_value(pdata->ext_range, shutdown_temp);
 785         err = i2c_smbus_write_byte_data(client, LOCAL_THERM_LIMIT_WR, value);
 786         if (err)
 787                 return err;
 788
 789         return 0;
 790 }
 791
 792 /*
 793  * Manufacturer(OnSemi) recommended sequence for
 794  * Extended Range mode is as follows
 795  * 1. Place in Standby
 796  * 2. Scale the THERM and ALERT limits
 797  *      appropriately(for Extended Range mode).
 798  * 3. Enable Extended Range mode.
 799  *      ALERT mask/THERM2 mode may be done here
 800  *      as these are not critical
 801  * 4. Set Conversion Rate as required
 802  * 5. Take device out of Standby
 803  */
 804
 805 /*
 806  * function nct1008_probe takes care of initial configuration
 807  */
 808 static int __devinit nct1008_probe(struct i2c_client *client,
 809                                 const struct i2c_device_id *id)
 810 {
 811         struct nct1008_data *data;
 812         int err;
 813         unsigned int delay;
 814
 815         data = kzalloc(sizeof(struct nct1008_data), GFP_KERNEL);
 816         if (!data)
 817                 return -ENOMEM;
 818
 819         data->client = client;
 820         memcpy(&data->plat_data, client->dev.platform_data,
 821                 sizeof(struct nct1008_platform_data));
 822         i2c_set_clientdata(client, data);
 823
 824         nct1008_power_control(data, true);
 825         /* extended range recommended steps 1 through 4 taken care
 826          * in nct1008_configure_sensor function */
 827         err = nct1008_configure_sensor(data);   /* sensor is in standby */
 828         if (err < 0) {
 829                 dev_err(&client->dev, "\n error file: %s : %s(), line=%d ",
 830                         __FILE__, __func__, __LINE__);
 831                 goto error;
 832         }
 833
 834         err = nct1008_configure_irq(data);
 835         if (err < 0) {
 836                 dev_err(&client->dev, "\n error file: %s : %s(), line=%d ",
 837                         __FILE__, __func__, __LINE__);
 838                 goto error;
 839         }
 840         dev_info(&client->dev, "%s: initialized\n", __func__);
 841
 842         /* extended range recommended step 5 is in nct1008_enable function */
 843         err = nct1008_enable(client);           /* sensor is running */
 844         if (err < 0) {
 845                 dev_err(&client->dev, "Error: %s, line=%d, error=%d\n",
 846                         __func__, __LINE__, err);
 847                 goto error;
 848         }
 849
 850         err = nct1008_debuginit(data);
 851         if (err < 0)
 852                 err = 0; /* without debugfs we may continue */
 853
 854         /* notify callback that probe is done */
 855         if (data->plat_data.probe_callback)
 856                 data->plat_data.probe_callback(data);
 857
 858         return 0;
 859
 860 error:
 861         dev_err(&client->dev, "\n exit %s, err=%d ", __func__, err);
 862         nct1008_power_control(data, false);
 863         if (data->nct_reg)
 864                 regulator_put(data->nct_reg);
 865         kfree(data);
 866         return err;
 867 }
 868
 869 static int __devexit nct1008_remove(struct i2c_client *client)
 870 {
 871         struct nct1008_data *data = i2c_get_clientdata(client);
 872
 873         if (data->dent)
 874                 debugfs_remove(data->dent);
 875
 876         free_irq(data->client->irq, data);
 877         cancel_work_sync(&data->work);
 878         sysfs_remove_group(&client->dev.kobj, &nct1008_attr_group);
 879         nct1008_power_control(data, false);
 880         if (data->nct_reg)
 881                 regulator_put(data->nct_reg);
 882
 883         kfree(data);
 884
 885         return 0;
 886 }
 887
 888 #ifdef CONFIG_PM
 889 static int nct1008_suspend(struct i2c_client *client, pm_message_t state)
 890 {
 891         int err;
 892
 893         disable_irq(client->irq);
 894         err = nct1008_disable(client);
 895         return err;
 896 }
 897
 898 static int nct1008_resume(struct i2c_client *client)
 899 {
 900         struct nct1008_data *data = i2c_get_clientdata(client);
 901         int err;
 902
 903         err = nct1008_enable(client);
 904         if (err < 0) {
 905                 dev_err(&client->dev, "Error: %s, error=%d\n",
 906                         __func__, err);
 907                 return err;
 908         }
 909         enable_irq(client->irq);
 910
 911         return 0;
 912 }
 913 #endif
 914
 915 static const struct i2c_device_id nct1008_id[] = {
 916         { DRIVER_NAME, 0 },
 917         { }
 918 };
 919 MODULE_DEVICE_TABLE(i2c, nct1008_id);
 920
 921 static struct i2c_driver nct1008_driver = {
 922         .driver = {
 923                 .name   = DRIVER_NAME,
 924         },
 925         .probe          = nct1008_probe,
 926         .remove         = __devexit_p(nct1008_remove),
 927         .id_table       = nct1008_id,
 928 #ifdef CONFIG_PM
 929         .suspend        = nct1008_suspend,
 930         .resume         = nct1008_resume,
 931 #endif
 932 };
 933
 934 static int __init nct1008_init(void)
 935 {
 936         return i2c_add_driver(&nct1008_driver);
 937 }
 938
 939 static void __exit nct1008_exit(void)
 940 {
 941         i2c_del_driver(&nct1008_driver);
 942 }
 943
 944 MODULE_DESCRIPTION("Temperature sensor driver for OnSemi NCT1008");
 945 MODULE_LICENSE("GPL");
 946
 947 module_init(nct1008_init);
 948 module_exit(nct1008_exit);