Commit | Line | Data |
---|---|---|
74ba9207 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 | 2 | /* |
19f2c059 GR |
3 | * ds1621.c - Part of lm_sensors, Linux kernel modules for hardware |
4 | * monitoring | |
5 | * Christian W. Zuckschwerdt <zany@triq.net> 2000-11-23 | |
6 | * based on lm75.c by Frodo Looijaard <frodol@dds.nl> | |
7 | * Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with | |
7c81c60f | 8 | * the help of Jean Delvare <jdelvare@suse.de> |
19f2c059 | 9 | * |
cd6c8a42 RC |
10 | * The DS1621 device is a digital temperature/thermometer with 9-bit |
11 | * resolution, a thermal alarm output (Tout), and user-defined minimum | |
12 | * and maximum temperature thresholds (TH and TL). | |
13 | * | |
260f81ff RC |
14 | * The DS1625, DS1631, DS1721, and DS1731 are pin compatible with the DS1621 |
15 | * and similar in operation, with slight variations as noted in the device | |
cd6c8a42 RC |
16 | * datasheets (please refer to www.maximintegrated.com for specific |
17 | * device information). | |
18 | * | |
19 | * Since the DS1621 was the first chipset supported by this driver, | |
20 | * most comments will refer to this chipset, but are actually general | |
21 | * and concern all supported chipsets, unless mentioned otherwise. | |
19f2c059 | 22 | */ |
1da177e4 LT |
23 | |
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> | |
943b0830 | 29 | #include <linux/hwmon.h> |
46a2e71c | 30 | #include <linux/hwmon-sysfs.h> |
943b0830 | 31 | #include <linux/err.h> |
9a61bf63 | 32 | #include <linux/mutex.h> |
a5ebe668 | 33 | #include <linux/sysfs.h> |
cd6c8a42 | 34 | #include <linux/kernel.h> |
1da177e4 | 35 | |
cd6c8a42 | 36 | /* Supported devices */ |
260f81ff | 37 | enum chips { ds1621, ds1625, ds1631, ds1721, ds1731 }; |
cd6c8a42 | 38 | |
1da177e4 | 39 | /* Insmod parameters */ |
1da177e4 LT |
40 | static int polarity = -1; |
41 | module_param(polarity, int, 0); | |
42 | MODULE_PARM_DESC(polarity, "Output's polarity: 0 = active high, 1 = active low"); | |
43 | ||
cd6c8a42 RC |
44 | /* |
45 | * The Configuration/Status register | |
46 | * | |
47 | * - DS1621: | |
48 | * 7 6 5 4 3 2 1 0 | |
49 | * |Done|THF |TLF |NVB | X | X |POL |1SHOT| | |
50 | * | |
51 | * - DS1625: | |
52 | * 7 6 5 4 3 2 1 0 | |
53 | * |Done|THF |TLF |NVB | 1 | 0 |POL |1SHOT| | |
54 | * | |
260f81ff | 55 | * - DS1631, DS1731: |
79c1cc1c RC |
56 | * 7 6 5 4 3 2 1 0 |
57 | * |Done|THF |TLF |NVB | R1 | R0 |POL |1SHOT| | |
58 | * | |
cd6c8a42 RC |
59 | * - DS1721: |
60 | * 7 6 5 4 3 2 1 0 | |
61 | * |Done| X | X | U | R1 | R0 |POL |1SHOT| | |
62 | * | |
63 | * Where: | |
64 | * - 'X' is Reserved | |
65 | * - 'U' is Undefined | |
66 | */ | |
1da177e4 | 67 | #define DS1621_REG_CONFIG_NVB 0x10 |
cd6c8a42 | 68 | #define DS1621_REG_CONFIG_RESOL 0x0C |
1da177e4 LT |
69 | #define DS1621_REG_CONFIG_POLARITY 0x02 |
70 | #define DS1621_REG_CONFIG_1SHOT 0x01 | |
71 | #define DS1621_REG_CONFIG_DONE 0x80 | |
72 | ||
cd6c8a42 RC |
73 | #define DS1621_REG_CONFIG_RESOL_SHIFT 2 |
74 | ||
75 | /* ds1721 conversion rates: {C/LSB, time(ms), resolution bit setting} */ | |
76 | static const unsigned short ds1721_convrates[] = { | |
77 | 94, /* 9-bits (0.5, 93.75, RES[0..1] = 0 */ | |
78 | 188, /* 10-bits (0.25, 187.5, RES[0..1] = 1 */ | |
79 | 375, /* 11-bits (0.125, 375, RES[0..1] = 2 */ | |
80 | 750, /* 12-bits (0.0625, 750, RES[0..1] = 3 */ | |
81 | }; | |
82 | ||
83 | #define DS1621_CONVERSION_MAX 750 | |
84 | #define DS1625_CONVERSION_MAX 500 | |
85 | ||
86 | #define DS1621_TEMP_MAX 125000 | |
87 | #define DS1621_TEMP_MIN (-55000) | |
88 | ||
89 | /* The DS1621 temperature registers */ | |
46a2e71c JD |
90 | static const u8 DS1621_REG_TEMP[3] = { |
91 | 0xAA, /* input, word, RO */ | |
92 | 0xA2, /* min, word, RW */ | |
93 | 0xA1, /* max, word, RW */ | |
94 | }; | |
1da177e4 LT |
95 | #define DS1621_REG_CONF 0xAC /* byte, RW */ |
96 | #define DS1621_COM_START 0xEE /* no data */ | |
cd6c8a42 | 97 | #define DS1721_COM_START 0x51 /* no data */ |
1da177e4 LT |
98 | #define DS1621_COM_STOP 0x22 /* no data */ |
99 | ||
100 | /* The DS1621 configuration register */ | |
101 | #define DS1621_ALARM_TEMP_HIGH 0x40 | |
102 | #define DS1621_ALARM_TEMP_LOW 0x20 | |
103 | ||
75819f01 | 104 | /* Conversions */ |
1da177e4 | 105 | #define ALARMS_FROM_REG(val) ((val) & \ |
19f2c059 | 106 | (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW)) |
1da177e4 LT |
107 | |
108 | /* Each client has this additional data */ | |
109 | struct ds1621_data { | |
8269b75a | 110 | struct i2c_client *client; |
9a61bf63 | 111 | struct mutex update_lock; |
952a11ca | 112 | bool valid; /* true if following fields are valid */ |
1da177e4 | 113 | unsigned long last_updated; /* In jiffies */ |
cd6c8a42 | 114 | enum chips kind; /* device type */ |
1da177e4 | 115 | |
46a2e71c | 116 | u16 temp[3]; /* Register values, word */ |
1da177e4 | 117 | u8 conf; /* Register encoding, combined */ |
a50d9a4d GR |
118 | u8 zbits; /* Resolution encoded as number of |
119 | * zero bits */ | |
cd6c8a42 | 120 | u16 update_interval; /* Conversion rate in milliseconds */ |
1da177e4 LT |
121 | }; |
122 | ||
cd6c8a42 RC |
123 | static inline int DS1621_TEMP_FROM_REG(u16 reg) |
124 | { | |
125 | return DIV_ROUND_CLOSEST(((s16)reg / 16) * 625, 10); | |
126 | } | |
127 | ||
128 | /* | |
129 | * TEMP: 0.001C/bit (-55C to +125C) | |
130 | * REG: | |
a50d9a4d GR |
131 | * - 1621, 1625: 0.5C/bit, 7 zero-bits |
132 | * - 1631, 1721, 1731: 0.0625C/bit, 4 zero-bits | |
cd6c8a42 | 133 | */ |
a50d9a4d | 134 | static inline u16 DS1621_TEMP_TO_REG(long temp, u8 zbits) |
cd6c8a42 | 135 | { |
a50d9a4d GR |
136 | temp = clamp_val(temp, DS1621_TEMP_MIN, DS1621_TEMP_MAX); |
137 | temp = DIV_ROUND_CLOSEST(temp * (1 << (8 - zbits)), 1000) << zbits; | |
138 | return temp; | |
cd6c8a42 RC |
139 | } |
140 | ||
8269b75a GR |
141 | static void ds1621_init_client(struct ds1621_data *data, |
142 | struct i2c_client *client) | |
1da177e4 | 143 | { |
cd6c8a42 | 144 | u8 conf, new_conf, sreg, resol; |
e4879e28 JD |
145 | |
146 | new_conf = conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF); | |
44bbe87e | 147 | /* switch to continuous conversion mode */ |
e4879e28 | 148 | new_conf &= ~DS1621_REG_CONFIG_1SHOT; |
1da177e4 LT |
149 | |
150 | /* setup output polarity */ | |
151 | if (polarity == 0) | |
e4879e28 | 152 | new_conf &= ~DS1621_REG_CONFIG_POLARITY; |
1da177e4 | 153 | else if (polarity == 1) |
e4879e28 | 154 | new_conf |= DS1621_REG_CONFIG_POLARITY; |
19f2c059 | 155 | |
e4879e28 JD |
156 | if (conf != new_conf) |
157 | i2c_smbus_write_byte_data(client, DS1621_REG_CONF, new_conf); | |
19f2c059 | 158 | |
cd6c8a42 RC |
159 | switch (data->kind) { |
160 | case ds1625: | |
161 | data->update_interval = DS1625_CONVERSION_MAX; | |
a50d9a4d | 162 | data->zbits = 7; |
cd6c8a42 RC |
163 | sreg = DS1621_COM_START; |
164 | break; | |
79c1cc1c | 165 | case ds1631: |
cd6c8a42 | 166 | case ds1721: |
260f81ff | 167 | case ds1731: |
cd6c8a42 RC |
168 | resol = (new_conf & DS1621_REG_CONFIG_RESOL) >> |
169 | DS1621_REG_CONFIG_RESOL_SHIFT; | |
170 | data->update_interval = ds1721_convrates[resol]; | |
a50d9a4d | 171 | data->zbits = 7 - resol; |
cd6c8a42 RC |
172 | sreg = DS1721_COM_START; |
173 | break; | |
174 | default: | |
175 | data->update_interval = DS1621_CONVERSION_MAX; | |
a50d9a4d | 176 | data->zbits = 7; |
cd6c8a42 RC |
177 | sreg = DS1621_COM_START; |
178 | break; | |
179 | } | |
180 | ||
1da177e4 | 181 | /* start conversion */ |
cd6c8a42 | 182 | i2c_smbus_write_byte(client, sreg); |
1da177e4 LT |
183 | } |
184 | ||
9202add6 JD |
185 | static struct ds1621_data *ds1621_update_client(struct device *dev) |
186 | { | |
8269b75a GR |
187 | struct ds1621_data *data = dev_get_drvdata(dev); |
188 | struct i2c_client *client = data->client; | |
9202add6 JD |
189 | u8 new_conf; |
190 | ||
191 | mutex_lock(&data->update_lock); | |
192 | ||
cd6c8a42 RC |
193 | if (time_after(jiffies, data->last_updated + data->update_interval) || |
194 | !data->valid) { | |
9202add6 JD |
195 | int i; |
196 | ||
197 | dev_dbg(&client->dev, "Starting ds1621 update\n"); | |
198 | ||
594592dc | 199 | data->conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF); |
9202add6 JD |
200 | |
201 | for (i = 0; i < ARRAY_SIZE(data->temp); i++) | |
90f4102c | 202 | data->temp[i] = i2c_smbus_read_word_swapped(client, |
594592dc | 203 | DS1621_REG_TEMP[i]); |
9202add6 JD |
204 | |
205 | /* reset alarms if necessary */ | |
206 | new_conf = data->conf; | |
207 | if (data->temp[0] > data->temp[1]) /* input > min */ | |
208 | new_conf &= ~DS1621_ALARM_TEMP_LOW; | |
209 | if (data->temp[0] < data->temp[2]) /* input < max */ | |
210 | new_conf &= ~DS1621_ALARM_TEMP_HIGH; | |
211 | if (data->conf != new_conf) | |
594592dc JD |
212 | i2c_smbus_write_byte_data(client, DS1621_REG_CONF, |
213 | new_conf); | |
9202add6 JD |
214 | |
215 | data->last_updated = jiffies; | |
952a11ca | 216 | data->valid = true; |
9202add6 JD |
217 | } |
218 | ||
219 | mutex_unlock(&data->update_lock); | |
220 | ||
221 | return data; | |
222 | } | |
223 | ||
0ad85c07 | 224 | static ssize_t temp_show(struct device *dev, struct device_attribute *da, |
46a2e71c JD |
225 | char *buf) |
226 | { | |
227 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); | |
228 | struct ds1621_data *data = ds1621_update_client(dev); | |
229 | return sprintf(buf, "%d\n", | |
cd6c8a42 | 230 | DS1621_TEMP_FROM_REG(data->temp[attr->index])); |
1da177e4 LT |
231 | } |
232 | ||
0ad85c07 GR |
233 | static ssize_t temp_store(struct device *dev, struct device_attribute *da, |
234 | const char *buf, size_t count) | |
46a2e71c JD |
235 | { |
236 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); | |
8269b75a | 237 | struct ds1621_data *data = dev_get_drvdata(dev); |
19f2c059 GR |
238 | long val; |
239 | int err; | |
240 | ||
241 | err = kstrtol(buf, 10, &val); | |
242 | if (err) | |
243 | return err; | |
1da177e4 | 244 | |
46a2e71c | 245 | mutex_lock(&data->update_lock); |
a50d9a4d | 246 | data->temp[attr->index] = DS1621_TEMP_TO_REG(val, data->zbits); |
8269b75a | 247 | i2c_smbus_write_word_swapped(data->client, DS1621_REG_TEMP[attr->index], |
90f4102c | 248 | data->temp[attr->index]); |
46a2e71c JD |
249 | mutex_unlock(&data->update_lock); |
250 | return count; | |
251 | } | |
1da177e4 | 252 | |
345d52fa | 253 | static ssize_t alarms_show(struct device *dev, struct device_attribute *da, |
46a2e71c | 254 | char *buf) |
1da177e4 LT |
255 | { |
256 | struct ds1621_data *data = ds1621_update_client(dev); | |
257 | return sprintf(buf, "%d\n", ALARMS_FROM_REG(data->conf)); | |
258 | } | |
259 | ||
0ad85c07 | 260 | static ssize_t alarm_show(struct device *dev, struct device_attribute *da, |
87f0f31b JD |
261 | char *buf) |
262 | { | |
263 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); | |
264 | struct ds1621_data *data = ds1621_update_client(dev); | |
265 | return sprintf(buf, "%d\n", !!(data->conf & attr->index)); | |
266 | } | |
267 | ||
345d52fa JL |
268 | static ssize_t update_interval_show(struct device *dev, |
269 | struct device_attribute *da, char *buf) | |
3a8fe331 | 270 | { |
8269b75a | 271 | struct ds1621_data *data = dev_get_drvdata(dev); |
3a8fe331 RC |
272 | return scnprintf(buf, PAGE_SIZE, "%hu\n", data->update_interval); |
273 | } | |
274 | ||
345d52fa JL |
275 | static ssize_t update_interval_store(struct device *dev, |
276 | struct device_attribute *da, | |
277 | const char *buf, size_t count) | |
3a8fe331 | 278 | { |
8269b75a GR |
279 | struct ds1621_data *data = dev_get_drvdata(dev); |
280 | struct i2c_client *client = data->client; | |
3a8fe331 RC |
281 | unsigned long convrate; |
282 | s32 err; | |
283 | int resol = 0; | |
284 | ||
285 | err = kstrtoul(buf, 10, &convrate); | |
286 | if (err) | |
287 | return err; | |
288 | ||
289 | /* Convert rate into resolution bits */ | |
290 | while (resol < (ARRAY_SIZE(ds1721_convrates) - 1) && | |
291 | convrate > ds1721_convrates[resol]) | |
292 | resol++; | |
293 | ||
294 | mutex_lock(&data->update_lock); | |
295 | data->conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF); | |
296 | data->conf &= ~DS1621_REG_CONFIG_RESOL; | |
297 | data->conf |= (resol << DS1621_REG_CONFIG_RESOL_SHIFT); | |
298 | i2c_smbus_write_byte_data(client, DS1621_REG_CONF, data->conf); | |
299 | data->update_interval = ds1721_convrates[resol]; | |
39c627a0 | 300 | data->zbits = 7 - resol; |
3a8fe331 RC |
301 | mutex_unlock(&data->update_lock); |
302 | ||
303 | return count; | |
304 | } | |
305 | ||
345d52fa JL |
306 | static DEVICE_ATTR_RO(alarms); |
307 | static DEVICE_ATTR_RW(update_interval); | |
3a8fe331 | 308 | |
0ad85c07 GR |
309 | static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0); |
310 | static SENSOR_DEVICE_ATTR_RW(temp1_min, temp, 1); | |
311 | static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, 2); | |
312 | static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, alarm, DS1621_ALARM_TEMP_LOW); | |
313 | static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, DS1621_ALARM_TEMP_HIGH); | |
1da177e4 | 314 | |
a5ebe668 | 315 | static struct attribute *ds1621_attributes[] = { |
46a2e71c JD |
316 | &sensor_dev_attr_temp1_input.dev_attr.attr, |
317 | &sensor_dev_attr_temp1_min.dev_attr.attr, | |
318 | &sensor_dev_attr_temp1_max.dev_attr.attr, | |
87f0f31b JD |
319 | &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, |
320 | &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, | |
a5ebe668 | 321 | &dev_attr_alarms.attr, |
3a8fe331 | 322 | &dev_attr_update_interval.attr, |
a5ebe668 JD |
323 | NULL |
324 | }; | |
325 | ||
3a8fe331 RC |
326 | static umode_t ds1621_attribute_visible(struct kobject *kobj, |
327 | struct attribute *attr, int index) | |
328 | { | |
f3e3464e | 329 | struct device *dev = kobj_to_dev(kobj); |
8269b75a | 330 | struct ds1621_data *data = dev_get_drvdata(dev); |
3a8fe331 RC |
331 | |
332 | if (attr == &dev_attr_update_interval.attr) | |
79c1cc1c | 333 | if (data->kind == ds1621 || data->kind == ds1625) |
3a8fe331 RC |
334 | /* shhh, we're hiding update_interval */ |
335 | return 0; | |
336 | return attr->mode; | |
337 | } | |
338 | ||
a5ebe668 JD |
339 | static const struct attribute_group ds1621_group = { |
340 | .attrs = ds1621_attributes, | |
3a8fe331 | 341 | .is_visible = ds1621_attribute_visible |
a5ebe668 | 342 | }; |
0d36dce0 | 343 | __ATTRIBUTE_GROUPS(ds1621); |
8269b75a | 344 | |
67487038 SK |
345 | static const struct i2c_device_id ds1621_id[]; |
346 | ||
347 | static int ds1621_probe(struct i2c_client *client) | |
70313eab JD |
348 | { |
349 | struct ds1621_data *data; | |
8269b75a | 350 | struct device *hwmon_dev; |
70313eab | 351 | |
e20b4b38 GR |
352 | data = devm_kzalloc(&client->dev, sizeof(struct ds1621_data), |
353 | GFP_KERNEL); | |
354 | if (!data) | |
355 | return -ENOMEM; | |
70313eab | 356 | |
70313eab | 357 | mutex_init(&data->update_lock); |
1da177e4 | 358 | |
67487038 | 359 | data->kind = i2c_match_id(ds1621_id, client)->driver_data; |
8269b75a | 360 | data->client = client; |
cd6c8a42 | 361 | |
1da177e4 | 362 | /* Initialize the DS1621 chip */ |
8269b75a | 363 | ds1621_init_client(data, client); |
1da177e4 | 364 | |
0d36dce0 GR |
365 | hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev, |
366 | client->name, data, | |
367 | ds1621_groups); | |
31ab1ad7 | 368 | return PTR_ERR_OR_ZERO(hwmon_dev); |
1da177e4 LT |
369 | } |
370 | ||
9202add6 | 371 | static const struct i2c_device_id ds1621_id[] = { |
cd6c8a42 RC |
372 | { "ds1621", ds1621 }, |
373 | { "ds1625", ds1625 }, | |
79c1cc1c | 374 | { "ds1631", ds1631 }, |
cd6c8a42 | 375 | { "ds1721", ds1721 }, |
260f81ff | 376 | { "ds1731", ds1731 }, |
9202add6 JD |
377 | { } |
378 | }; | |
379 | MODULE_DEVICE_TABLE(i2c, ds1621_id); | |
1da177e4 | 380 | |
9202add6 JD |
381 | /* This is the driver that will be inserted */ |
382 | static struct i2c_driver ds1621_driver = { | |
383 | .class = I2C_CLASS_HWMON, | |
384 | .driver = { | |
385 | .name = "ds1621", | |
386 | }, | |
67487038 | 387 | .probe_new = ds1621_probe, |
9202add6 | 388 | .id_table = ds1621_id, |
9202add6 | 389 | }; |
1da177e4 | 390 | |
f0967eea | 391 | module_i2c_driver(ds1621_driver); |
1da177e4 LT |
392 | |
393 | MODULE_AUTHOR("Christian W. Zuckschwerdt <zany@triq.net>"); | |
394 | MODULE_DESCRIPTION("DS1621 driver"); | |
395 | MODULE_LICENSE("GPL"); |