misc: nct1008: sub-zero temperature support
[linux-2.6.git] / 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/mutex.h>
26 #include <linux/module.h>
27 #include <linux/i2c.h>
28 #include <linux/slab.h>
29 #include <linux/err.h>
30 #include <linux/gpio.h>
31 #include <linux/device.h>
32 #include <linux/nct1008.h>
33 #include <linux/delay.h>
34 #include <linux/regulator/consumer.h>
35
36 #define DRIVER_NAME "nct1008"
37
38 /* Register Addresses */
39 #define LOCAL_TEMP_RD                   0x00
40 #define EXT_TEMP_RD_HI                  0x01
41 #define EXT_TEMP_RD_LO                  0x10
42 #define STATUS_RD                       0x02
43 #define CONFIG_RD                       0x03
44
45 #define LOCAL_TEMP_HI_LIMIT_RD          0x05
46 #define LOCAL_TEMP_LO_LIMIT_RD          0x06
47
48 #define EXT_TEMP_HI_LIMIT_HI_BYTE_RD    0x07
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 OFFSET_WR                       0x11
57 #define EXT_THERM_LIMIT_WR              0x19
58 #define LOCAL_THERM_LIMIT_WR            0x20
59 #define THERM_HYSTERESIS_WR             0x21
60
61 /* Configuration Register Bits */
62 #define EXTENDED_RANGE_BIT              BIT(2)
63 #define THERM2_BIT                      BIT(5)
64 #define STANDBY_BIT                     BIT(6)
65 #define ALERT_BIT                       BIT(7)
66
67 /* Max Temperature Measurements */
68 #define EXTENDED_RANGE_OFFSET           64U
69 #define STANDARD_RANGE_MAX              127U
70 #define EXTENDED_RANGE_MAX              (150U + EXTENDED_RANGE_OFFSET)
71
72 #define NCT1008_MIN_TEMP -64
73 #define NCT1008_MAX_TEMP 191
74
75 #define MAX_STR_PRINT 50
76
77 struct nct1008_data {
78         struct work_struct work;
79         struct i2c_client *client;
80         struct nct1008_platform_data plat_data;
81         struct mutex mutex;
82         u8 config;
83         s8 *limits;
84         u8 limits_sz;
85         void (*alarm_fn)(bool raised);
86         struct regulator *nct_reg;
87 };
88
89 static inline s8 value_to_temperature(bool extended, u8 value)
90 {
91         return extended ? (s8)(value - EXTENDED_RANGE_OFFSET) : (s8)value;
92 }
93
94 static inline u8 temperature_to_value(bool extended, s8 temp)
95 {
96         return extended ? (u8)(temp + EXTENDED_RANGE_OFFSET) : (u8)temp;
97 }
98
99 static int nct1008_get_temp(struct device *dev, u8 *pTemp)
100 {
101         struct i2c_client *client = to_i2c_client(dev);
102         struct nct1008_platform_data *pdata = client->dev.platform_data;
103         s8 temp1;
104         u8 temp2;
105         s8 temp;
106         u8 value;
107         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_RD);
108         if (value < 0)
109                 goto error;
110         temp1 = value_to_temperature(pdata->ext_range, value);
111
112         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
113         if (value < 0)
114                 goto error;
115         temp2 = (value >> 6);
116         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
117         if (value < 0)
118                 goto error;
119         temp = value_to_temperature(pdata->ext_range, value);
120         if (temp2 > 0)
121                 *pTemp = max((int)temp1, (int)temp + 1);
122         else
123                 *pTemp = max(temp1, temp);
124
125         dev_dbg(dev, "\n %s: ret temp=%dC ", __func__, *pTemp);
126         return 0;
127 error:
128         dev_err(&client->dev, "\n error in file=: %s %s() line=%d: "
129                 "error=%d ", __FILE__, __func__, __LINE__, value);
130         return value;
131 }
132
133 static ssize_t nct1008_show_temp(struct device *dev,
134         struct device_attribute *attr, char *buf)
135 {
136         struct i2c_client *client = to_i2c_client(dev);
137         struct nct1008_platform_data *pdata = client->dev.platform_data;
138         s8 temp1 = 0;
139         s8 temp = 0;
140         u8 temp2 = 0;
141         u8 value = 0;
142
143         if (!dev || !buf || !attr)
144                 return -EINVAL;
145
146         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_RD);
147         if (value < 0)
148                 goto error;
149         temp1 = value_to_temperature(pdata->ext_range, value);
150
151         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
152         if (value < 0)
153                 goto error;
154         temp2 = (value >> 6);
155         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
156         if (value < 0)
157                 goto error;
158         temp = value_to_temperature(pdata->ext_range, value);
159
160         return snprintf(buf, MAX_STR_PRINT, "%d %d.%d\n",
161                 temp1, temp, temp2 * 25);
162
163 error:
164         snprintf(buf, MAX_STR_PRINT, " Rd Error\n");
165         return value;
166 }
167
168 static ssize_t nct1008_show_temp_overheat(struct device *dev,
169                                 struct device_attribute *attr,
170                                 char *buf)
171 {
172         struct i2c_client *client = to_i2c_client(dev);
173         struct nct1008_platform_data *pdata = client->dev.platform_data;
174         u8 value;
175         s8 temp, temp2;
176
177         /* Local temperature h/w shutdown limit */
178         value = i2c_smbus_read_byte_data(client, LOCAL_THERM_LIMIT_WR);
179         if (value < 0)
180                 goto error;
181         temp = value_to_temperature(pdata->ext_range, value);
182
183         /* External temperature h/w shutdown limit */
184         value = i2c_smbus_read_byte_data(client, EXT_THERM_LIMIT_WR);
185         if (value < 0)
186                 goto error;
187         temp2 = value_to_temperature(pdata->ext_range, value);
188
189         return snprintf(buf, MAX_STR_PRINT, "%d %d\n", temp, temp2);
190 error:
191         snprintf(buf, MAX_STR_PRINT, " Rd overheat Error\n");
192         dev_err(dev, "%s: failed to read temperature-overheat "
193                 "\n", __func__);
194         return value;
195 }
196
197 static ssize_t nct1008_set_temp_overheat(struct device *dev,
198                         struct device_attribute *attr,
199                         const char *buf, size_t count)
200 {
201         long int num;
202         int err;
203         u8 temp;
204         u8 currTemp;
205         struct i2c_client *client = to_i2c_client(dev);
206         struct nct1008_platform_data *pdata = client->dev.platform_data;
207         char bufTemp[MAX_STR_PRINT];
208         char bufOverheat[MAX_STR_PRINT];
209         unsigned int ret;
210
211         if (strict_strtol(buf, 0, &num)) {
212                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
213                         __LINE__, __func__);
214                 return -EINVAL;
215         }
216         if (((int)num < NCT1008_MIN_TEMP) || ((int)num >= NCT1008_MAX_TEMP)) {
217                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
218                         __LINE__, __func__);
219                 return -EINVAL;
220         }
221         /* check for system power down */
222         err = nct1008_get_temp(dev, &currTemp);
223         if (err)
224                 goto error;
225
226         if (currTemp >= (int)num) {
227                 ret = nct1008_show_temp(dev, attr, bufTemp);
228                 ret = nct1008_show_temp_overheat(dev, attr, bufOverheat);
229                 dev_err(dev, "\nCurrent temp: %s ", bufTemp);
230                 dev_err(dev, "\nOld overheat limit: %s ", bufOverheat);
231                 dev_err(dev, "\nReset from overheat: curr temp=%d, "
232                         "new overheat temp=%d\n\n", currTemp, (int)num);
233         }
234
235         /* External temperature h/w shutdown limit */
236         temp = temperature_to_value(pdata->ext_range, (s8)num);
237         err = i2c_smbus_write_byte_data(client, EXT_THERM_LIMIT_WR, temp);
238         if (err < 0)
239                 goto error;
240
241         /* Local temperature h/w shutdown limit */
242         temp = temperature_to_value(pdata->ext_range, (s8)num);
243         err = i2c_smbus_write_byte_data(client, LOCAL_THERM_LIMIT_WR, temp);
244         if (err < 0)
245                 goto error;
246         return count;
247 error:
248         dev_err(dev, " %s: failed to set temperature-overheat\n", __func__);
249         return err;
250 }
251
252 static ssize_t nct1008_show_temp_alert(struct device *dev,
253                                 struct device_attribute *attr,
254                                 char *buf)
255 {
256         struct i2c_client *client = to_i2c_client(dev);
257         struct nct1008_platform_data *pdata = client->dev.platform_data;
258         u8 value;
259         s8 temp, temp2;
260         /* External Temperature Throttling limit */
261         value = i2c_smbus_read_byte_data(client, EXT_TEMP_HI_LIMIT_HI_BYTE_RD);
262         if (value < 0)
263                 goto error;
264         temp2 = value_to_temperature(pdata->ext_range, value);
265
266         /* Local Temperature Throttling limit */
267         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_HI_LIMIT_RD);
268         if (value < 0)
269                 goto error;
270         temp = value_to_temperature(pdata->ext_range, value);
271
272         return snprintf(buf, MAX_STR_PRINT, "%d %d\n", temp, temp2);
273 error:
274         snprintf(buf, MAX_STR_PRINT, " Rd overheat Error\n");
275         dev_err(dev, "%s: failed to read temperature-overheat "
276                 "\n", __func__);
277         return value;
278 }
279
280 static ssize_t nct1008_set_temp_alert(struct device *dev,
281                         struct device_attribute *attr,
282                         const char *buf, size_t count)
283 {
284         long int num;
285         int value;
286         int err;
287         struct i2c_client *client = to_i2c_client(dev);
288         struct nct1008_platform_data *pdata = client->dev.platform_data;
289
290         if (strict_strtol(buf, 0, &num)) {
291                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
292                         __LINE__, __func__);
293                 return -EINVAL;
294         }
295         if (((int)num < NCT1008_MIN_TEMP) || ((int)num >= NCT1008_MAX_TEMP)) {
296                 dev_err(dev, "\n file: %s, line=%d return %s() ", __FILE__,
297                         __LINE__, __func__);
298                 return -EINVAL;
299         }
300
301         /* External Temperature Throttling limit */
302         value = temperature_to_value(pdata->ext_range, (s8)num);
303         err = i2c_smbus_write_byte_data(client, EXT_TEMP_HI_LIMIT_HI_BYTE_WR,
304                 value);
305         if (err < 0)
306                 goto error;
307
308         /* Local Temperature Throttling limit */
309         err = i2c_smbus_write_byte_data(client, LOCAL_TEMP_HI_LIMIT_WR,
310                 value);
311         if (err < 0)
312                 goto error;
313
314         return count;
315 error:
316         dev_err(dev, "%s: failed to set temperature-alert "
317                 "\n", __func__);
318         return err;
319 }
320
321 static ssize_t nct1008_show_ext_temp(struct device *dev,
322         struct device_attribute *attr, char *buf)
323 {
324         struct i2c_client *client = to_i2c_client(dev);
325         struct nct1008_platform_data *pdata = client->dev.platform_data;
326         s8 temp_value;
327         u8 data = 0;
328         u8 data_lo;
329
330         if (!dev || !buf || !attr)
331                 return -EINVAL;
332
333         /* When reading the full external temperature value, read the
334          * LSB first. This causes the MSB to be locked (that is, the
335          * ADC does not write to it) until it is read */
336         data_lo = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
337
338         data = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
339         if (data < 0) {
340                 dev_err(&client->dev, "%s: failed to read "
341                         "ext_temperature\n", __func__);
342                 return -EINVAL;
343         }
344
345         temp_value = value_to_temperature(pdata->ext_range, data);
346
347         return sprintf(buf, "%d.%d\n", temp_value, (25 * (data_lo >> 6)));
348 }
349
350 static DEVICE_ATTR(temperature, S_IRUGO, nct1008_show_temp, NULL);
351 static DEVICE_ATTR(temperature_overheat, (S_IRUGO | (S_IWUSR | S_IWGRP)),
352                 nct1008_show_temp_overheat, nct1008_set_temp_overheat);
353 static DEVICE_ATTR(temperature_alert, (S_IRUGO | (S_IWUSR | S_IWGRP)),
354                 nct1008_show_temp_alert, nct1008_set_temp_alert);
355 static DEVICE_ATTR(ext_temperature, S_IRUGO, nct1008_show_ext_temp, NULL);
356
357 static struct attribute *nct1008_attributes[] = {
358         &dev_attr_temperature.attr,
359         &dev_attr_temperature_overheat.attr,
360         &dev_attr_temperature_alert.attr,
361         &dev_attr_ext_temperature.attr,
362         NULL
363 };
364
365 static const struct attribute_group nct1008_attr_group = {
366         .attrs = nct1008_attributes,
367 };
368
369 static void nct1008_enable(struct i2c_client *client)
370 {
371         struct nct1008_data *data = i2c_get_clientdata(client);
372
373         i2c_smbus_write_byte_data(client, CONFIG_WR,
374                                   data->config & ~STANDBY_BIT);
375 }
376
377 static void nct1008_disable(struct i2c_client *client)
378 {
379         struct nct1008_data *data = i2c_get_clientdata(client);
380
381         i2c_smbus_write_byte_data(client, CONFIG_WR,
382                                   data->config | STANDBY_BIT);
383 }
384
385 static int nct1008_disable_alert(struct nct1008_data *data)
386 {
387         struct i2c_client *client = data->client;
388         int ret = 0;
389         u8 val;
390
391         /*
392          * Disable ALERT# output, because these chips don't implement
393          * SMBus alert correctly; they should only hold the alert line
394          * low briefly.
395          */
396         val = i2c_smbus_read_byte_data(data->client, CONFIG_RD);
397         ret = i2c_smbus_write_byte_data(client, CONFIG_WR, val | ALERT_BIT);
398         if (ret)
399                 pr_err("%s: fail to disable alert#\n", __func__);
400
401         return ret;
402 }
403
404 static int nct1008_enable_alert(struct nct1008_data *data)
405 {
406         u8 val;
407         int ret;
408
409         val = i2c_smbus_read_byte_data(data->client, CONFIG_RD);
410         val &= ~(ALERT_BIT | THERM2_BIT);
411         ret = i2c_smbus_write_byte_data(data->client, CONFIG_WR, val);
412         if (ret) {
413                 pr_err("%s: fail to enable alert#\n", __func__);
414                 return ret;
415         }
416
417         return ret;
418 }
419
420 static bool throttle_enb;
421 static void therm_throttle(struct nct1008_data *data, bool enable)
422 {
423         if (!data->alarm_fn) {
424                 pr_err("system too hot. no way to cool down!\n");
425                 return;
426         }
427
428         if (throttle_enb != enable) {
429                 mutex_lock(&data->mutex);
430                 data->alarm_fn(enable);
431                 throttle_enb = enable;
432                 mutex_unlock(&data->mutex);
433         }
434 }
435
436 #define ALERT_HYSTERESIS        3
437 static int edp_thermal_zone_val = -1;
438 static int current_hi_limit = -1;
439 static int current_lo_limit = -1;
440
441 static void nct1008_work_func(struct work_struct *work)
442 {
443         struct nct1008_data *data = container_of(work, struct nct1008_data,
444                                                 work);
445         bool extended_range = data->plat_data.ext_range;
446         u8 temperature, value;
447         int err = 0, i;
448         int nentries = data->limits_sz;
449         int lo_limit = 0, hi_limit = 0;
450         int intr_status = i2c_smbus_read_byte_data(data->client, STATUS_RD);
451
452         err = nct1008_get_temp(&data->client->dev, &temperature);
453         if (err) {
454                 pr_err("%s: get temp fail(%d)", __func__, err);
455                 return;
456         }
457
458         intr_status &= (BIT(3) | BIT(4));
459         if (!intr_status)
460                 return;
461
462         nct1008_disable_alert(data);
463
464         if (temperature < data->limits[0]) {
465                 lo_limit = 0;
466                 hi_limit = data->limits[0];
467         } else if (temperature >= data->limits[nentries-1]) {
468                 lo_limit = data->limits[nentries-1] - ALERT_HYSTERESIS;
469                 hi_limit = data->plat_data.shutdown_ext_limit;
470         } else {
471                 for (i = 0; (i + 1) < nentries; i++) {
472                         if (temperature >= data->limits[i] &&
473                             temperature < data->limits[i + 1]) {
474                                 lo_limit = data->limits[i] - ALERT_HYSTERESIS;
475                                 hi_limit = data->limits[i + 1];
476                                 break;
477                         }
478                 }
479         }
480
481         if (temperature >= data->plat_data.throttling_ext_limit) {
482                 /* start throttling */
483                 therm_throttle(data, true);
484         } else if (temperature <=
485                    (data->plat_data.throttling_ext_limit - ALERT_HYSTERESIS)) {
486                 /* switch off throttling */
487                 therm_throttle(data, false);
488         }
489
490         if (lo_limit == hi_limit) {
491                 err = -ENODATA;
492                 goto out;
493         }
494
495         if (current_lo_limit == lo_limit && current_hi_limit == hi_limit)
496                 goto out;
497
498         if (current_lo_limit != lo_limit) {
499                 value = temperature_to_value(extended_range, lo_limit);
500                 pr_debug("%s: %d\n", __func__, value);
501                 err = i2c_smbus_write_byte_data(data->client,
502                         EXT_TEMP_LO_LIMIT_HI_BYTE_WR, value);
503                 if (err)
504                         goto out;
505
506                 current_lo_limit = lo_limit;
507         }
508
509         if (current_hi_limit != hi_limit) {
510                 value = temperature_to_value(extended_range, hi_limit);
511                 pr_debug("%s: %d\n", __func__, value);
512                 err = i2c_smbus_write_byte_data(data->client,
513                         EXT_TEMP_HI_LIMIT_HI_BYTE_WR, value);
514                 if (err)
515                         goto out;
516
517                 current_hi_limit = hi_limit;
518         }
519
520         /* inform edp governor */
521         if (edp_thermal_zone_val != temperature)
522                 /*
523                  * FIXME: Move this direct tegra_ function call to be called
524                  * via a pointer in 'struct nct1008_data' (like 'alarm_fn')
525                  */
526                 tegra_edp_update_thermal_zone(temperature);
527
528         edp_thermal_zone_val = temperature;
529
530 out:
531         nct1008_enable_alert(data);
532
533         if (err)
534                 pr_err("%s: fail(%d)\n", __func__, err);
535         else
536                 pr_debug("%s: done\n", __func__);
537 }
538
539 static irqreturn_t nct1008_irq(int irq, void *dev_id)
540 {
541         struct nct1008_data *data = dev_id;
542
543         schedule_work(&data->work);
544         return IRQ_HANDLED;
545 }
546
547 static void nct1008_power_control(struct nct1008_data *data, bool is_enable)
548 {
549         int ret;
550         if (!data->nct_reg) {
551                 data->nct_reg = regulator_get(NULL, "vdd_nct1008");
552                 if (IS_ERR_OR_NULL(data->nct_reg)) {
553                         dev_warn(&data->client->dev, "Error in getting the "
554                                 "regulator handle for vdd_nct1008\n");
555                         data->nct_reg = NULL;
556                         return;
557                 }
558         }
559         if (is_enable)
560                 ret = regulator_enable(data->nct_reg);
561         else
562                 ret = regulator_disable(data->nct_reg);
563
564         if (ret < 0)
565                 dev_err(&data->client->dev, "Error in %s rail vdd_nct1008, "
566                         "error %d\n", (is_enable) ? "enabling" : "disabling",
567                         ret);
568         else
569                 dev_info(&data->client->dev, "success in %s rail vdd_nct1008\n",
570                         (is_enable) ? "enabling" : "disabling");
571 }
572
573 static int __devinit nct1008_configure_sensor(struct nct1008_data* data)
574 {
575         struct i2c_client *client = data->client;
576         struct nct1008_platform_data *pdata = client->dev.platform_data;
577         u8 value;
578         s8 temp;
579         u8 temp2;
580         int err;
581         int hi_limit;
582
583         if (!pdata || !pdata->supported_hwrev)
584                 return -ENODEV;
585
586         /*
587          * Initial Configuration - device is placed in standby and
588          * ALERT/THERM2 pin is configured as THERM2
589          */
590         data->config = pdata->ext_range ?
591                 (STANDBY_BIT | EXTENDED_RANGE_BIT) : STANDBY_BIT;
592
593         if (pdata->thermal_zones_sz)
594                 data->config &= ~(THERM2_BIT | ALERT_BIT);
595         else
596                 data->config |= (ALERT_BIT | THERM2_BIT);
597
598         value = data->config;
599         err = i2c_smbus_write_byte_data(client, CONFIG_WR, value);
600         if (err)
601                 goto error;
602
603         /* Temperature conversion rate */
604         err = i2c_smbus_write_byte_data(client, CONV_RATE_WR, pdata->conv_rate);
605         if (err)
606                 goto error;
607
608         /* External temperature h/w shutdown limit */
609         value = temperature_to_value(pdata->ext_range,
610                         pdata->shutdown_ext_limit);
611         err = i2c_smbus_write_byte_data(client, EXT_THERM_LIMIT_WR, value);
612         if (err)
613                 goto error;
614
615         /* Local temperature h/w shutdown limit */
616         value = temperature_to_value(pdata->ext_range,
617                         pdata->shutdown_local_limit);
618         err = i2c_smbus_write_byte_data(client, LOCAL_THERM_LIMIT_WR, value);
619         if (err)
620                 goto error;
621
622         if (pdata->thermal_zones_sz) {
623                 data->limits = pdata->thermal_zones;
624                 data->limits_sz = pdata->thermal_zones_sz;
625
626                 /* setup alarm */
627                 hi_limit = pdata->thermal_zones[0];
628
629                 err = i2c_smbus_write_byte_data(client,
630                         EXT_TEMP_LO_LIMIT_HI_BYTE_WR, 0);
631                 if (err)
632                         goto error;
633
634                 err = i2c_smbus_write_byte_data(client,
635                         LOCAL_TEMP_HI_LIMIT_WR, NCT1008_MAX_TEMP);
636                 if (err)
637                         goto error;
638
639                 err = i2c_smbus_write_byte_data(client,
640                         LOCAL_TEMP_LO_LIMIT_WR, 0);
641                 if (err)
642                         goto error;
643         } else {
644                 /*
645                  * External Temperature Throttling limit:
646                  *   Applies when 'Thermal Zones' are not specified.
647                  */
648                 hi_limit = pdata->throttling_ext_limit;
649         }
650
651         value = temperature_to_value(pdata->ext_range, hi_limit);
652         err = i2c_smbus_write_byte_data(client, EXT_TEMP_HI_LIMIT_HI_BYTE_WR,
653                         value);
654         if (err)
655                 goto error;
656
657         /* read initial temperature */
658         value = i2c_smbus_read_byte_data(client, LOCAL_TEMP_RD);
659         if (value < 0) {
660                 err = value;
661                 goto error;
662         }
663         temp = value_to_temperature(pdata->ext_range, value);
664         dev_dbg(&client->dev, "\n initial local temp = %d ", temp);
665
666         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_LO);
667         if (value < 0) {
668                 err = value;
669                 goto error;
670         }
671         temp2 = (value >> 6);
672         value = i2c_smbus_read_byte_data(client, EXT_TEMP_RD_HI);
673         if (value < 0) {
674                 err = value;
675                 goto error;
676         }
677         temp = value_to_temperature(pdata->ext_range, value);
678
679         if (temp2 > 0)
680                 dev_dbg(&client->dev, "\n initial ext temp = %d.%d deg",
681                                 temp, temp2 * 25);
682         else
683                 dev_dbg(&client->dev, "\n initial ext temp = %d.0 deg", temp);
684
685         /* Remote channel offset */
686         err = i2c_smbus_write_byte_data(client, OFFSET_WR, pdata->offset);
687         if (err < 0)
688                 goto error;
689
690         /* THERM hysteresis */
691         err = i2c_smbus_write_byte_data(client, THERM_HYSTERESIS_WR,
692                         pdata->hysteresis);
693         if (err < 0)
694                 goto error;
695
696         /* register sysfs hooks */
697         err = sysfs_create_group(&client->dev.kobj, &nct1008_attr_group);
698         if (err < 0) {
699                 dev_err(&client->dev, "\n sysfs create err=%d ", err);
700                 goto error;
701         }
702
703         data->alarm_fn = pdata->alarm_fn;
704         return 0;
705 error:
706         dev_err(&client->dev, "\n exit %s, err=%d ", __func__, err);
707         return err;
708 }
709
710 static int __devinit nct1008_configure_irq(struct nct1008_data *data)
711 {
712         INIT_WORK(&data->work, nct1008_work_func);
713
714         if (data->client->irq < 0)
715                 return 0;
716         else
717                 return request_irq(data->client->irq, nct1008_irq,
718                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
719                         DRIVER_NAME, data);
720 }
721
722 static unsigned int get_ext_mode_delay_ms(unsigned int conv_rate)
723 {
724         switch (conv_rate) {
725         case 0:
726                 return 16000;
727         case 1:
728                 return 8000;
729         case 2:
730                 return 4000;
731         case 3:
732                 return 2000;
733         case 4:
734                 return 1000;
735         case 5:
736                 return 500;
737         case 6:
738                 return 250;
739         case 7:
740                 return 125;
741         case 9:
742                 return 32;
743         case 10:
744                 return 16;
745         case 8:
746         default:
747                 return 63;
748         }
749 }
750
751 static int __devinit nct1008_probe(struct i2c_client *client,
752                                 const struct i2c_device_id *id)
753 {
754         struct nct1008_data *data;
755         int err;
756         u8 temperature;
757         unsigned int delay;
758
759         data = kzalloc(sizeof(struct nct1008_data), GFP_KERNEL);
760
761         if (!data)
762                 return -ENOMEM;
763
764         data->client = client;
765         memcpy(&data->plat_data, client->dev.platform_data,
766                 sizeof(struct nct1008_platform_data));
767         i2c_set_clientdata(client, data);
768         mutex_init(&data->mutex);
769
770         nct1008_power_control(data, true);
771         err = nct1008_configure_sensor(data);   /* sensor is in standby */
772         if (err < 0) {
773                 dev_err(&client->dev, "\n error file: %s : %s(), line=%d ",
774                         __FILE__, __func__, __LINE__);
775                 goto error;
776         }
777
778         err = nct1008_configure_irq(data);
779         if (err < 0) {
780                 dev_err(&client->dev, "\n error file: %s : %s(), line=%d ",
781                         __FILE__, __func__, __LINE__);
782                 goto error;
783         }
784         dev_info(&client->dev, "%s: initialized\n", __func__);
785
786         nct1008_enable(client);         /* sensor is running */
787
788         /* switch to extended mode reports correct temperature
789          * from next measurement cycle */
790         if (data->plat_data.ext_range) {
791                 delay = get_ext_mode_delay_ms(
792                         data->plat_data.conv_rate);
793                 msleep(delay); /* 63msec for default conv rate 0x8 */
794         }
795         err = nct1008_get_temp(&data->client->dev, &temperature);
796         if (err) {
797                 pr_err("%s: get temp fail(%d)", __func__, err);
798                 return 0;       /*do not fail init on the 1st read */
799         }
800
801         tegra_edp_update_thermal_zone(temperature);
802         return 0;
803
804 error:
805         dev_err(&client->dev, "\n exit %s, err=%d ", __func__, err);
806         nct1008_power_control(data, false);
807         if (data->nct_reg)
808                 regulator_put(data->nct_reg);
809         kfree(data);
810         return err;
811 }
812
813 static int __devexit nct1008_remove(struct i2c_client *client)
814 {
815         struct nct1008_data *data = i2c_get_clientdata(client);
816
817         free_irq(data->client->irq, data);
818         cancel_work_sync(&data->work);
819         sysfs_remove_group(&client->dev.kobj, &nct1008_attr_group);
820         nct1008_power_control(data, false);
821         if (data->nct_reg)
822                 regulator_put(data->nct_reg);
823         kfree(data);
824
825         return 0;
826 }
827
828 #ifdef CONFIG_PM
829 static int nct1008_suspend(struct i2c_client *client, pm_message_t state)
830 {
831         disable_irq(client->irq);
832         nct1008_disable(client);
833
834         return 0;
835 }
836
837 static int nct1008_resume(struct i2c_client *client)
838 {
839         struct nct1008_data *data = i2c_get_clientdata(client);
840
841         nct1008_enable(client);
842         enable_irq(client->irq);
843         schedule_work(&data->work);
844
845         return 0;
846 }
847 #endif
848
849 static const struct i2c_device_id nct1008_id[] = {
850         { DRIVER_NAME, 0 },
851         { }
852 };
853 MODULE_DEVICE_TABLE(i2c, nct1008_id);
854
855 static struct i2c_driver nct1008_driver = {
856         .driver = {
857                 .name   = DRIVER_NAME,
858         },
859         .probe          = nct1008_probe,
860         .remove         = __devexit_p(nct1008_remove),
861         .id_table       = nct1008_id,
862 #ifdef CONFIG_PM
863         .suspend        = nct1008_suspend,
864         .resume         = nct1008_resume,
865 #endif
866 };
867
868 static int __init nct1008_init(void)
869 {
870         return i2c_add_driver(&nct1008_driver);
871 }
872
873 static void __exit nct1008_exit(void)
874 {
875         i2c_del_driver(&nct1008_driver);
876 }
877
878 MODULE_DESCRIPTION("Temperature sensor driver for OnSemi NCT1008");
879 MODULE_LICENSE("GPL");
880
881 module_init(nct1008_init);
882 module_exit(nct1008_exit);