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