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