2 * ADT7410 digital temperature sensor driver supporting ADT7410
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
9 #include <linux/interrupt.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/sysfs.h>
14 #include <linux/list.h>
15 #include <linux/i2c.h>
21 * ADT7410 registers definition
24 #define ADT7410_TEMPERATURE 0
25 #define ADT7410_STATUS 2
26 #define ADT7410_CONFIG 3
27 #define ADT7410_T_ALARM_HIGH 4
28 #define ADT7410_T_ALARM_LOW 6
29 #define ADT7410_T_CRIT 8
30 #define ADT7410_T_HYST 0xA
31 #define ADT7410_ID 0xB
32 #define ADT7410_RESET 0x2F
37 #define ADT7410_STAT_T_LOW 0x10
38 #define ADT7410_STAT_T_HIGH 0x20
39 #define ADT7410_STAT_T_CRIT 0x40
40 #define ADT7410_STAT_NOT_RDY 0x80
45 #define ADT7410_FAULT_QUEUE_MASK 0x3
46 #define ADT7410_CT_POLARITY 0x4
47 #define ADT7410_INT_POLARITY 0x8
48 #define ADT7410_EVENT_MODE 0x10
49 #define ADT7410_MODE_MASK 0x60
50 #define ADT7410_ONESHOT 0x20
51 #define ADT7410_SPS 0x40
52 #define ADT7410_PD 0x60
53 #define ADT7410_RESOLUTION 0x80
58 #define ADT7410_T16_VALUE_SIGN 0x8000
59 #define ADT7410_T16_VALUE_FLOAT_OFFSET 7
60 #define ADT7410_T16_VALUE_FLOAT_MASK 0x7F
61 #define ADT7410_T13_VALUE_SIGN 0x1000
62 #define ADT7410_T13_VALUE_OFFSET 3
63 #define ADT7410_T13_VALUE_FLOAT_OFFSET 4
64 #define ADT7410_T13_VALUE_FLOAT_MASK 0xF
65 #define ADT7410_T_HYST_MASK 0xF
66 #define ADT7410_DEVICE_ID_MASK 0xF
67 #define ADT7410_MANUFACTORY_ID_MASK 0xF0
68 #define ADT7410_MANUFACTORY_ID_OFFSET 4
70 #define ADT7410_IRQS 2
73 * struct adt7410_chip_info - chip specifc information
76 struct adt7410_chip_info
{
77 struct i2c_client
*client
;
78 struct iio_dev
*indio_dev
;
83 * adt7410 register access by I2C
86 static int adt7410_i2c_read_word(struct adt7410_chip_info
*chip
, u8 reg
, u16
*data
)
88 struct i2c_client
*client
= chip
->client
;
91 ret
= i2c_smbus_read_word_data(client
, reg
);
93 dev_err(&client
->dev
, "I2C read error\n");
97 *data
= swab16((u16
)ret
);
102 static int adt7410_i2c_write_word(struct adt7410_chip_info
*chip
, u8 reg
, u16 data
)
104 struct i2c_client
*client
= chip
->client
;
107 ret
= i2c_smbus_write_word_data(client
, reg
, swab16(data
));
109 dev_err(&client
->dev
, "I2C write error\n");
114 static int adt7410_i2c_read_byte(struct adt7410_chip_info
*chip
, u8 reg
, u8
*data
)
116 struct i2c_client
*client
= chip
->client
;
119 ret
= i2c_smbus_read_byte_data(client
, reg
);
121 dev_err(&client
->dev
, "I2C read error\n");
130 static int adt7410_i2c_write_byte(struct adt7410_chip_info
*chip
, u8 reg
, u8 data
)
132 struct i2c_client
*client
= chip
->client
;
135 ret
= i2c_smbus_write_byte_data(client
, reg
, data
);
137 dev_err(&client
->dev
, "I2C write error\n");
142 static ssize_t
adt7410_show_mode(struct device
*dev
,
143 struct device_attribute
*attr
,
146 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
147 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
150 config
= chip
->config
& ADT7410_MODE_MASK
;
154 return sprintf(buf
, "power-down\n");
155 case ADT7410_ONESHOT
:
156 return sprintf(buf
, "one-shot\n");
158 return sprintf(buf
, "sps\n");
160 return sprintf(buf
, "full\n");
164 static ssize_t
adt7410_store_mode(struct device
*dev
,
165 struct device_attribute
*attr
,
169 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
170 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
174 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
178 config
= chip
->config
& (~ADT7410_MODE_MASK
);
179 if (strcmp(buf
, "power-down"))
180 config
|= ADT7410_PD
;
181 else if (strcmp(buf
, "one-shot"))
182 config
|= ADT7410_ONESHOT
;
183 else if (strcmp(buf
, "sps"))
184 config
|= ADT7410_SPS
;
186 ret
= adt7410_i2c_write_byte(chip
, ADT7410_CONFIG
, config
);
190 chip
->config
= config
;
195 static IIO_DEVICE_ATTR(mode
, S_IRUGO
| S_IWUSR
,
200 static ssize_t
adt7410_show_available_modes(struct device
*dev
,
201 struct device_attribute
*attr
,
204 return sprintf(buf
, "full\none-shot\nsps\npower-down\n");
207 static IIO_DEVICE_ATTR(available_modes
, S_IRUGO
, adt7410_show_available_modes
, NULL
, 0);
209 static ssize_t
adt7410_show_resolution(struct device
*dev
,
210 struct device_attribute
*attr
,
213 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
214 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
218 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
222 if (chip
->config
& ADT7410_RESOLUTION
)
227 return sprintf(buf
, "%d bits\n", bits
);
230 static ssize_t
adt7410_store_resolution(struct device
*dev
,
231 struct device_attribute
*attr
,
235 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
236 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
241 ret
= strict_strtoul(buf
, 10, &data
);
245 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
249 config
= chip
->config
& (~ADT7410_RESOLUTION
);
251 config
|= ADT7410_RESOLUTION
;
253 ret
= adt7410_i2c_write_byte(chip
, ADT7410_CONFIG
, config
);
257 chip
->config
= config
;
262 static IIO_DEVICE_ATTR(resolution
, S_IRUGO
| S_IWUSR
,
263 adt7410_show_resolution
,
264 adt7410_store_resolution
,
267 static ssize_t
adt7410_show_id(struct device
*dev
,
268 struct device_attribute
*attr
,
271 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
272 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
276 ret
= adt7410_i2c_read_byte(chip
, ADT7410_ID
, &id
);
280 return sprintf(buf
, "device id: 0x%x\nmanufactory id: 0x%x\n",
281 id
& ADT7410_DEVICE_ID_MASK
,
282 (id
& ADT7410_MANUFACTORY_ID_MASK
) >> ADT7410_MANUFACTORY_ID_OFFSET
);
285 static IIO_DEVICE_ATTR(id
, S_IRUGO
| S_IWUSR
,
290 static ssize_t
adt7410_convert_temperature(struct adt7410_chip_info
*chip
,
295 if (chip
->config
& ADT7410_RESOLUTION
) {
296 if (data
& ADT7410_T16_VALUE_SIGN
) {
297 /* convert supplement to positive value */
298 data
= (u16
)((ADT7410_T16_VALUE_SIGN
<< 1) - (u32
)data
);
301 return sprintf(buf
, "%c%d.%.7d\n", sign
,
302 (data
>> ADT7410_T16_VALUE_FLOAT_OFFSET
),
303 (data
& ADT7410_T16_VALUE_FLOAT_MASK
) * 78125);
305 if (data
& ADT7410_T13_VALUE_SIGN
) {
306 /* convert supplement to positive value */
307 data
>>= ADT7410_T13_VALUE_OFFSET
;
308 data
= (ADT7410_T13_VALUE_SIGN
<< 1) - data
;
311 return sprintf(buf
, "%c%d.%.4d\n", sign
,
312 (data
>> ADT7410_T13_VALUE_FLOAT_OFFSET
),
313 (data
& ADT7410_T13_VALUE_FLOAT_MASK
) * 625);
317 static ssize_t
adt7410_show_value(struct device
*dev
,
318 struct device_attribute
*attr
,
321 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
322 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
328 ret
= adt7410_i2c_read_byte(chip
, ADT7410_STATUS
, &status
);
334 } while (status
& ADT7410_STAT_NOT_RDY
);
336 ret
= adt7410_i2c_read_word(chip
, ADT7410_TEMPERATURE
, &data
);
340 return adt7410_convert_temperature(chip
, data
, buf
);
343 static IIO_DEVICE_ATTR(value
, S_IRUGO
, adt7410_show_value
, NULL
, 0);
345 static struct attribute
*adt7410_attributes
[] = {
346 &iio_dev_attr_available_modes
.dev_attr
.attr
,
347 &iio_dev_attr_mode
.dev_attr
.attr
,
348 &iio_dev_attr_resolution
.dev_attr
.attr
,
349 &iio_dev_attr_id
.dev_attr
.attr
,
350 &iio_dev_attr_value
.dev_attr
.attr
,
354 static const struct attribute_group adt7410_attribute_group
= {
355 .attrs
= adt7410_attributes
,
359 * temperature bound events
362 #define IIO_EVENT_CODE_ADT7410_ABOVE_ALARM IIO_BUFFER_EVENT_CODE(0)
363 #define IIO_EVENT_CODE_ADT7410_BELLOW_ALARM IIO_BUFFER_EVENT_CODE(1)
364 #define IIO_EVENT_CODE_ADT7410_ABOVE_CRIT IIO_BUFFER_EVENT_CODE(2)
366 static irqreturn_t
adt7410_event_handler(int irq
, void *private)
368 struct iio_dev
*indio_dev
= private;
369 struct adt7410_chip_info
*chip
= iio_dev_get_devdata(indio_dev
);
370 s64 timestamp
= iio_get_time_ns();
373 if (adt7410_i2c_read_byte(chip
, ADT7410_STATUS
, &status
))
376 if (status
& ADT7410_STAT_T_HIGH
)
377 iio_push_event(indio_dev
, 0,
378 IIO_EVENT_CODE_ADT7410_ABOVE_ALARM
,
380 if (status
& ADT7410_STAT_T_LOW
)
381 iio_push_event(indio_dev
, 0,
382 IIO_EVENT_CODE_ADT7410_BELLOW_ALARM
,
384 if (status
& ADT7410_STAT_T_CRIT
)
385 iio_push_event(indio_dev
, 0,
386 IIO_EVENT_CODE_ADT7410_ABOVE_CRIT
,
392 static ssize_t
adt7410_show_event_mode(struct device
*dev
,
393 struct device_attribute
*attr
,
396 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
397 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
400 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
404 if (chip
->config
& ADT7410_EVENT_MODE
)
405 return sprintf(buf
, "interrupt\n");
407 return sprintf(buf
, "comparator\n");
410 static ssize_t
adt7410_set_event_mode(struct device
*dev
,
411 struct device_attribute
*attr
,
415 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
416 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
420 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
424 config
= chip
->config
&= ~ADT7410_EVENT_MODE
;
425 if (strcmp(buf
, "comparator") != 0)
426 config
|= ADT7410_EVENT_MODE
;
428 ret
= adt7410_i2c_write_byte(chip
, ADT7410_CONFIG
, config
);
432 chip
->config
= config
;
437 static ssize_t
adt7410_show_available_event_modes(struct device
*dev
,
438 struct device_attribute
*attr
,
441 return sprintf(buf
, "comparator\ninterrupt\n");
444 static ssize_t
adt7410_show_fault_queue(struct device
*dev
,
445 struct device_attribute
*attr
,
448 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
449 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
452 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
456 return sprintf(buf
, "%d\n", chip
->config
& ADT7410_FAULT_QUEUE_MASK
);
459 static ssize_t
adt7410_set_fault_queue(struct device
*dev
,
460 struct device_attribute
*attr
,
464 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
465 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
470 ret
= strict_strtoul(buf
, 10, &data
);
474 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
478 config
= chip
->config
& ~ADT7410_FAULT_QUEUE_MASK
;
480 ret
= adt7410_i2c_write_byte(chip
, ADT7410_CONFIG
, config
);
484 chip
->config
= config
;
489 static inline ssize_t
adt7410_show_t_bound(struct device
*dev
,
490 struct device_attribute
*attr
,
494 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
495 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
499 ret
= adt7410_i2c_read_word(chip
, bound_reg
, &data
);
503 return adt7410_convert_temperature(chip
, data
, buf
);
506 static inline ssize_t
adt7410_set_t_bound(struct device
*dev
,
507 struct device_attribute
*attr
,
512 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
513 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
519 pos
= strchr(buf
, '.');
521 ret
= strict_strtol(buf
, 10, &tmp1
);
523 if (ret
|| tmp1
> 127 || tmp1
< -128)
529 if (chip
->config
& ADT7410_RESOLUTION
) {
530 if (len
> ADT7410_T16_VALUE_FLOAT_OFFSET
)
531 len
= ADT7410_T16_VALUE_FLOAT_OFFSET
;
533 ret
= strict_strtol(pos
, 10, &tmp2
);
536 tmp2
= (tmp2
/ 78125) * 78125;
538 if (len
> ADT7410_T13_VALUE_FLOAT_OFFSET
)
539 len
= ADT7410_T13_VALUE_FLOAT_OFFSET
;
541 ret
= strict_strtol(pos
, 10, &tmp2
);
544 tmp2
= (tmp2
/ 625) * 625;
553 if (chip
->config
& ADT7410_RESOLUTION
) {
554 data
= (data
<< ADT7410_T16_VALUE_FLOAT_OFFSET
) |
555 (tmp2
& ADT7410_T16_VALUE_FLOAT_MASK
);
558 /* convert positive value to supplyment */
559 data
= (u16
)((ADT7410_T16_VALUE_SIGN
<< 1) - (u32
)data
);
561 data
= (data
<< ADT7410_T13_VALUE_FLOAT_OFFSET
) |
562 (tmp2
& ADT7410_T13_VALUE_FLOAT_MASK
);
565 /* convert positive value to supplyment */
566 data
= (ADT7410_T13_VALUE_SIGN
<< 1) - data
;
567 data
<<= ADT7410_T13_VALUE_OFFSET
;
570 ret
= adt7410_i2c_write_word(chip
, bound_reg
, data
);
577 static ssize_t
adt7410_show_t_alarm_high(struct device
*dev
,
578 struct device_attribute
*attr
,
581 return adt7410_show_t_bound(dev
, attr
,
582 ADT7410_T_ALARM_HIGH
, buf
);
585 static inline ssize_t
adt7410_set_t_alarm_high(struct device
*dev
,
586 struct device_attribute
*attr
,
590 return adt7410_set_t_bound(dev
, attr
,
591 ADT7410_T_ALARM_HIGH
, buf
, len
);
594 static ssize_t
adt7410_show_t_alarm_low(struct device
*dev
,
595 struct device_attribute
*attr
,
598 return adt7410_show_t_bound(dev
, attr
,
599 ADT7410_T_ALARM_LOW
, buf
);
602 static inline ssize_t
adt7410_set_t_alarm_low(struct device
*dev
,
603 struct device_attribute
*attr
,
607 return adt7410_set_t_bound(dev
, attr
,
608 ADT7410_T_ALARM_LOW
, buf
, len
);
611 static ssize_t
adt7410_show_t_crit(struct device
*dev
,
612 struct device_attribute
*attr
,
615 return adt7410_show_t_bound(dev
, attr
,
616 ADT7410_T_CRIT
, buf
);
619 static inline ssize_t
adt7410_set_t_crit(struct device
*dev
,
620 struct device_attribute
*attr
,
624 return adt7410_set_t_bound(dev
, attr
,
625 ADT7410_T_CRIT
, buf
, len
);
628 static ssize_t
adt7410_show_t_hyst(struct device
*dev
,
629 struct device_attribute
*attr
,
632 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
633 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
637 ret
= adt7410_i2c_read_byte(chip
, ADT7410_T_HYST
, &t_hyst
);
641 return sprintf(buf
, "%d\n", t_hyst
& ADT7410_T_HYST_MASK
);
644 static inline ssize_t
adt7410_set_t_hyst(struct device
*dev
,
645 struct device_attribute
*attr
,
649 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
650 struct adt7410_chip_info
*chip
= dev_info
->dev_data
;
655 ret
= strict_strtol(buf
, 10, &data
);
657 if (ret
|| data
> ADT7410_T_HYST_MASK
)
662 ret
= adt7410_i2c_write_byte(chip
, ADT7410_T_HYST
, t_hyst
);
669 static IIO_DEVICE_ATTR(event_mode
,
671 adt7410_show_event_mode
, adt7410_set_event_mode
, 0);
672 static IIO_DEVICE_ATTR(available_event_modes
,
674 adt7410_show_available_event_modes
, NULL
, 0);
675 static IIO_DEVICE_ATTR(fault_queue
,
677 adt7410_show_fault_queue
, adt7410_set_fault_queue
, 0);
678 static IIO_DEVICE_ATTR(t_alarm_high
,
680 adt7410_show_t_alarm_high
, adt7410_set_t_alarm_high
, 0);
681 static IIO_DEVICE_ATTR(t_alarm_low
,
683 adt7410_show_t_alarm_low
, adt7410_set_t_alarm_low
, 0);
684 static IIO_DEVICE_ATTR(t_crit
,
686 adt7410_show_t_crit
, adt7410_set_t_crit
, 0);
687 static IIO_DEVICE_ATTR(t_hyst
,
689 adt7410_show_t_hyst
, adt7410_set_t_hyst
, 0);
691 static struct attribute
*adt7410_event_int_attributes
[] = {
692 &iio_dev_attr_event_mode
.dev_attr
.attr
,
693 &iio_dev_attr_available_event_modes
.dev_attr
.attr
,
694 &iio_dev_attr_fault_queue
.dev_attr
.attr
,
695 &iio_dev_attr_t_alarm_high
.dev_attr
.attr
,
696 &iio_dev_attr_t_alarm_low
.dev_attr
.attr
,
697 &iio_dev_attr_t_hyst
.dev_attr
.attr
,
701 static struct attribute
*adt7410_event_ct_attributes
[] = {
702 &iio_dev_attr_event_mode
.dev_attr
.attr
,
703 &iio_dev_attr_available_event_modes
.dev_attr
.attr
,
704 &iio_dev_attr_fault_queue
.dev_attr
.attr
,
705 &iio_dev_attr_t_crit
.dev_attr
.attr
,
706 &iio_dev_attr_t_hyst
.dev_attr
.attr
,
710 static struct attribute_group adt7410_event_attribute_group
[ADT7410_IRQS
] = {
712 .attrs
= adt7410_event_int_attributes
,
714 .attrs
= adt7410_event_ct_attributes
,
719 * device probe and remove
722 static int __devinit
adt7410_probe(struct i2c_client
*client
,
723 const struct i2c_device_id
*id
)
725 struct adt7410_chip_info
*chip
;
727 unsigned long *adt7410_platform_data
= client
->dev
.platform_data
;
729 chip
= kzalloc(sizeof(struct adt7410_chip_info
), GFP_KERNEL
);
734 /* this is only used for device removal purposes */
735 i2c_set_clientdata(client
, chip
);
737 chip
->client
= client
;
739 chip
->indio_dev
= iio_allocate_device(0);
740 if (chip
->indio_dev
== NULL
) {
742 goto error_free_chip
;
744 chip
->indio_dev
->name
= id
->name
;
745 chip
->indio_dev
->dev
.parent
= &client
->dev
;
746 chip
->indio_dev
->attrs
= &adt7410_attribute_group
;
747 chip
->indio_dev
->event_attrs
= adt7410_event_attribute_group
;
748 chip
->indio_dev
->dev_data
= (void *)chip
;
749 chip
->indio_dev
->driver_module
= THIS_MODULE
;
750 chip
->indio_dev
->num_interrupt_lines
= ADT7410_IRQS
;
751 chip
->indio_dev
->modes
= INDIO_DIRECT_MODE
;
753 ret
= iio_device_register(chip
->indio_dev
);
757 /* CT critcal temperature event. line 0 */
759 ret
= request_threaded_irq(client
->irq
,
761 &adt7410_event_handler
,
766 goto error_unreg_dev
;
769 /* INT bound temperature alarm event. line 1 */
770 if (adt7410_platform_data
[0]) {
771 ret
= request_threaded_irq(adt7410_platform_data
[0],
773 &adt7410_event_handler
,
774 adt7410_platform_data
[1],
778 goto error_unreg_ct_irq
;
781 if (client
->irq
&& adt7410_platform_data
[0]) {
783 ret
= adt7410_i2c_read_byte(chip
, ADT7410_CONFIG
, &chip
->config
);
786 goto error_unreg_int_irq
;
789 /* set irq polarity low level */
790 chip
->config
&= ~ADT7410_CT_POLARITY
;
792 if (adt7410_platform_data
[1] & IRQF_TRIGGER_HIGH
)
793 chip
->config
|= ADT7410_INT_POLARITY
;
795 chip
->config
&= ~ADT7410_INT_POLARITY
;
797 ret
= adt7410_i2c_write_byte(chip
, ADT7410_CONFIG
, chip
->config
);
800 goto error_unreg_int_irq
;
804 dev_info(&client
->dev
, "%s temperature sensor registered.\n",
810 free_irq(adt7410_platform_data
[0], chip
->indio_dev
);
812 free_irq(client
->irq
, chip
->indio_dev
);
814 iio_device_unregister(chip
->indio_dev
);
816 iio_free_device(chip
->indio_dev
);
823 static int __devexit
adt7410_remove(struct i2c_client
*client
)
825 struct adt7410_chip_info
*chip
= i2c_get_clientdata(client
);
826 struct iio_dev
*indio_dev
= chip
->indio_dev
;
827 unsigned long *adt7410_platform_data
= client
->dev
.platform_data
;
829 if (adt7410_platform_data
[0])
830 free_irq(adt7410_platform_data
[0], chip
->indio_dev
);
832 free_irq(client
->irq
, chip
->indio_dev
);
833 iio_device_unregister(indio_dev
);
834 iio_free_device(chip
->indio_dev
);
840 static const struct i2c_device_id adt7410_id
[] = {
845 MODULE_DEVICE_TABLE(i2c
, adt7410_id
);
847 static struct i2c_driver adt7410_driver
= {
851 .probe
= adt7410_probe
,
852 .remove
= __devexit_p(adt7410_remove
),
853 .id_table
= adt7410_id
,
856 static __init
int adt7410_init(void)
858 return i2c_add_driver(&adt7410_driver
);
861 static __exit
void adt7410_exit(void)
863 i2c_del_driver(&adt7410_driver
);
866 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
867 MODULE_DESCRIPTION("Analog Devices ADT7410 digital"
868 " temperature sensor driver");
869 MODULE_LICENSE("GPL v2");
871 module_init(adt7410_init
);
872 module_exit(adt7410_exit
);