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