2 ds1621.c - Part of lm_sensors, Linux kernel modules for hardware
4 Christian W. Zuckschwerdt <zany@triq.net> 2000-11-23
5 based on lm75.c by Frodo Looijaard <frodol@dds.nl>
6 Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
7 the help of Jean Delvare <khali@linux-fr.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h>
32 #include <linux/mutex.h>
33 #include <linux/sysfs.h>
36 /* Addresses to scan */
37 static unsigned short normal_i2c
[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
38 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
};
40 /* Insmod parameters */
41 I2C_CLIENT_INSMOD_1(ds1621
);
42 static int polarity
= -1;
43 module_param(polarity
, int, 0);
44 MODULE_PARM_DESC(polarity
, "Output's polarity: 0 = active high, 1 = active low");
46 /* Many DS1621 constants specified below */
47 /* Config register used for detection */
49 /* |Done|THF |TLF |NVB | X | X |POL |1SHOT| */
50 #define DS1621_REG_CONFIG_NVB 0x10
51 #define DS1621_REG_CONFIG_POLARITY 0x02
52 #define DS1621_REG_CONFIG_1SHOT 0x01
53 #define DS1621_REG_CONFIG_DONE 0x80
55 /* The DS1621 registers */
56 static const u8 DS1621_REG_TEMP
[3] = {
57 0xAA, /* input, word, RO */
58 0xA2, /* min, word, RW */
59 0xA1, /* max, word, RW */
61 #define DS1621_REG_CONF 0xAC /* byte, RW */
62 #define DS1621_COM_START 0xEE /* no data */
63 #define DS1621_COM_STOP 0x22 /* no data */
65 /* The DS1621 configuration register */
66 #define DS1621_ALARM_TEMP_HIGH 0x40
67 #define DS1621_ALARM_TEMP_LOW 0x20
70 #define ALARMS_FROM_REG(val) ((val) & \
71 (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW))
73 /* Each client has this additional data */
75 struct i2c_client client
;
76 struct class_device
*class_dev
;
77 struct mutex update_lock
;
78 char valid
; /* !=0 if following fields are valid */
79 unsigned long last_updated
; /* In jiffies */
81 u16 temp
[3]; /* Register values, word */
82 u8 conf
; /* Register encoding, combined */
85 static int ds1621_attach_adapter(struct i2c_adapter
*adapter
);
86 static int ds1621_detect(struct i2c_adapter
*adapter
, int address
,
88 static void ds1621_init_client(struct i2c_client
*client
);
89 static int ds1621_detach_client(struct i2c_client
*client
);
90 static struct ds1621_data
*ds1621_update_client(struct device
*dev
);
92 /* This is the driver that will be inserted */
93 static struct i2c_driver ds1621_driver
= {
97 .id
= I2C_DRIVERID_DS1621
,
98 .attach_adapter
= ds1621_attach_adapter
,
99 .detach_client
= ds1621_detach_client
,
102 /* All registers are word-sized, except for the configuration register.
103 DS1621 uses a high-byte first convention, which is exactly opposite to
104 the SMBus standard. */
105 static int ds1621_read_value(struct i2c_client
*client
, u8 reg
)
107 if (reg
== DS1621_REG_CONF
)
108 return i2c_smbus_read_byte_data(client
, reg
);
110 return swab16(i2c_smbus_read_word_data(client
, reg
));
113 static int ds1621_write_value(struct i2c_client
*client
, u8 reg
, u16 value
)
115 if (reg
== DS1621_REG_CONF
)
116 return i2c_smbus_write_byte_data(client
, reg
, value
);
118 return i2c_smbus_write_word_data(client
, reg
, swab16(value
));
121 static void ds1621_init_client(struct i2c_client
*client
)
123 int reg
= ds1621_read_value(client
, DS1621_REG_CONF
);
124 /* switch to continuous conversion mode */
125 reg
&= ~ DS1621_REG_CONFIG_1SHOT
;
127 /* setup output polarity */
129 reg
&= ~DS1621_REG_CONFIG_POLARITY
;
130 else if (polarity
== 1)
131 reg
|= DS1621_REG_CONFIG_POLARITY
;
133 ds1621_write_value(client
, DS1621_REG_CONF
, reg
);
135 /* start conversion */
136 i2c_smbus_write_byte(client
, DS1621_COM_START
);
139 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*da
,
142 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
143 struct ds1621_data
*data
= ds1621_update_client(dev
);
144 return sprintf(buf
, "%d\n",
145 LM75_TEMP_FROM_REG(data
->temp
[attr
->index
]));
148 static ssize_t
set_temp(struct device
*dev
, struct device_attribute
*da
,
149 const char *buf
, size_t count
)
151 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
152 struct i2c_client
*client
= to_i2c_client(dev
);
153 struct ds1621_data
*data
= ds1621_update_client(dev
);
154 u16 val
= LM75_TEMP_TO_REG(simple_strtoul(buf
, NULL
, 10));
156 mutex_lock(&data
->update_lock
);
157 data
->temp
[attr
->index
] = val
;
158 ds1621_write_value(client
, DS1621_REG_TEMP
[attr
->index
],
159 data
->temp
[attr
->index
]);
160 mutex_unlock(&data
->update_lock
);
164 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*da
,
167 struct ds1621_data
*data
= ds1621_update_client(dev
);
168 return sprintf(buf
, "%d\n", ALARMS_FROM_REG(data
->conf
));
171 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
172 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
173 static SENSOR_DEVICE_ATTR(temp1_min
, S_IWUSR
| S_IRUGO
, show_temp
, set_temp
, 1);
174 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp
, set_temp
, 2);
176 static struct attribute
*ds1621_attributes
[] = {
177 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
178 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
179 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
180 &dev_attr_alarms
.attr
,
184 static const struct attribute_group ds1621_group
= {
185 .attrs
= ds1621_attributes
,
189 static int ds1621_attach_adapter(struct i2c_adapter
*adapter
)
191 if (!(adapter
->class & I2C_CLASS_HWMON
))
193 return i2c_probe(adapter
, &addr_data
, ds1621_detect
);
196 /* This function is called by i2c_probe */
197 static int ds1621_detect(struct i2c_adapter
*adapter
, int address
,
201 struct i2c_client
*client
;
202 struct ds1621_data
*data
;
205 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
206 | I2C_FUNC_SMBUS_WORD_DATA
207 | I2C_FUNC_SMBUS_WRITE_BYTE
))
210 /* OK. For now, we presume we have a valid client. We now create the
211 client structure, even though we cannot fill it completely yet.
212 But it allows us to access ds1621_{read,write}_value. */
213 if (!(data
= kzalloc(sizeof(struct ds1621_data
), GFP_KERNEL
))) {
218 client
= &data
->client
;
219 i2c_set_clientdata(client
, data
);
220 client
->addr
= address
;
221 client
->adapter
= adapter
;
222 client
->driver
= &ds1621_driver
;
224 /* Now, we do the remaining detection. It is lousy. */
226 /* The NVB bit should be low if no EEPROM write has been
227 requested during the latest 10ms, which is highly
228 improbable in our case. */
229 conf
= ds1621_read_value(client
, DS1621_REG_CONF
);
230 if (conf
& DS1621_REG_CONFIG_NVB
)
232 /* The 7 lowest bits of a temperature should always be 0. */
233 for (i
= 0; i
< ARRAY_SIZE(data
->temp
); i
++) {
234 temp
= ds1621_read_value(client
, DS1621_REG_TEMP
[i
]);
240 /* Fill in remaining client fields and put it into the global list */
241 strlcpy(client
->name
, "ds1621", I2C_NAME_SIZE
);
242 mutex_init(&data
->update_lock
);
244 /* Tell the I2C layer a new client has arrived */
245 if ((err
= i2c_attach_client(client
)))
248 /* Initialize the DS1621 chip */
249 ds1621_init_client(client
);
251 /* Register sysfs hooks */
252 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &ds1621_group
)))
255 data
->class_dev
= hwmon_device_register(&client
->dev
);
256 if (IS_ERR(data
->class_dev
)) {
257 err
= PTR_ERR(data
->class_dev
);
258 goto exit_remove_files
;
264 sysfs_remove_group(&client
->dev
.kobj
, &ds1621_group
);
266 i2c_detach_client(client
);
273 static int ds1621_detach_client(struct i2c_client
*client
)
275 struct ds1621_data
*data
= i2c_get_clientdata(client
);
278 hwmon_device_unregister(data
->class_dev
);
279 sysfs_remove_group(&client
->dev
.kobj
, &ds1621_group
);
281 if ((err
= i2c_detach_client(client
)))
290 static struct ds1621_data
*ds1621_update_client(struct device
*dev
)
292 struct i2c_client
*client
= to_i2c_client(dev
);
293 struct ds1621_data
*data
= i2c_get_clientdata(client
);
296 mutex_lock(&data
->update_lock
);
298 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
302 dev_dbg(&client
->dev
, "Starting ds1621 update\n");
304 data
->conf
= ds1621_read_value(client
, DS1621_REG_CONF
);
306 for (i
= 0; i
< ARRAY_SIZE(data
->temp
); i
++)
307 data
->temp
[i
] = ds1621_read_value(client
,
310 /* reset alarms if necessary */
311 new_conf
= data
->conf
;
312 if (data
->temp
[0] > data
->temp
[1]) /* input > min */
313 new_conf
&= ~DS1621_ALARM_TEMP_LOW
;
314 if (data
->temp
[0] < data
->temp
[2]) /* input < max */
315 new_conf
&= ~DS1621_ALARM_TEMP_HIGH
;
316 if (data
->conf
!= new_conf
)
317 ds1621_write_value(client
, DS1621_REG_CONF
,
320 data
->last_updated
= jiffies
;
324 mutex_unlock(&data
->update_lock
);
329 static int __init
ds1621_init(void)
331 return i2c_add_driver(&ds1621_driver
);
334 static void __exit
ds1621_exit(void)
336 i2c_del_driver(&ds1621_driver
);
340 MODULE_AUTHOR("Christian W. Zuckschwerdt <zany@triq.net>");
341 MODULE_DESCRIPTION("DS1621 driver");
342 MODULE_LICENSE("GPL");
344 module_init(ds1621_init
);
345 module_exit(ds1621_exit
);