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