1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
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 |
8 | * the help of Jean Delvare <jdelvare@suse.de> |
9 | * |
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 | * |
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 |
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. |
22 | */ |
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> |
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> |
34 | #include <linux/kernel.h> |
35 | |
36 | /* Supported devices */ |
37 | enum chips { ds1621, ds1625, ds1631, ds1721, ds1731 }; |
38 | |
39 | /* Insmod parameters */ |
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 | |
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 | * |
55 | * - DS1631, DS1731: |
56 | * 7 6 5 4 3 2 1 0 |
57 | * |Done|THF |TLF |NVB | R1 | R0 |POL |1SHOT| |
58 | * |
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 | */ |
67 | #define DS1621_REG_CONFIG_NVB 0x10 |
68 | #define DS1621_REG_CONFIG_RESOL 0x0C |
69 | #define DS1621_REG_CONFIG_POLARITY 0x02 |
70 | #define DS1621_REG_CONFIG_1SHOT 0x01 |
71 | #define DS1621_REG_CONFIG_DONE 0x80 |
72 | |
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 */ |
90 | static const u8 DS1621_REG_TEMP[3] = { |
91 | 0xAA, /* input, word, RO */ |
92 | 0xA2, /* min, word, RW */ |
93 | 0xA1, /* max, word, RW */ |
94 | }; |
95 | #define DS1621_REG_CONF 0xAC /* byte, RW */ |
96 | #define DS1621_COM_START 0xEE /* no data */ |
97 | #define DS1721_COM_START 0x51 /* no data */ |
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 | |
104 | /* Conversions */ |
105 | #define ALARMS_FROM_REG(val) ((val) & \ |
106 | (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW)) |
107 | |
108 | /* Each client has this additional data */ |
109 | struct ds1621_data { |
110 | struct i2c_client *client; |
111 | struct mutex update_lock; |
112 | bool valid; /* true if following fields are valid */ |
113 | unsigned long last_updated; /* In jiffies */ |
114 | enum chips kind; /* device type */ |
115 | |
116 | u16 temp[3]; /* Register values, word */ |
117 | u8 conf; /* Register encoding, combined */ |
118 | u8 zbits; /* Resolution encoded as number of |
119 | * zero bits */ |
120 | u16 update_interval; /* Conversion rate in milliseconds */ |
121 | }; |
122 | |
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: |
131 | * - 1621, 1625: 0.5C/bit, 7 zero-bits |
132 | * - 1631, 1721, 1731: 0.0625C/bit, 4 zero-bits |
133 | */ |
134 | static inline u16 DS1621_TEMP_TO_REG(long temp, u8 zbits) |
135 | { |
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; |
139 | } |
140 | |
141 | static void ds1621_init_client(struct ds1621_data *data, |
142 | struct i2c_client *client) |
143 | { |
144 | u8 conf, new_conf, sreg, resol; |
145 | |
146 | new_conf = conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF); |
147 | /* switch to continuous conversion mode */ |
148 | new_conf &= ~DS1621_REG_CONFIG_1SHOT; |
149 | |
150 | /* setup output polarity */ |
151 | if (polarity == 0) |
152 | new_conf &= ~DS1621_REG_CONFIG_POLARITY; |
153 | else if (polarity == 1) |
154 | new_conf |= DS1621_REG_CONFIG_POLARITY; |
155 | |
156 | if (conf != new_conf) |
157 | i2c_smbus_write_byte_data(client, DS1621_REG_CONF, value: new_conf); |
158 | |
159 | switch (data->kind) { |
160 | case ds1625: |
161 | data->update_interval = DS1625_CONVERSION_MAX; |
162 | data->zbits = 7; |
163 | sreg = DS1621_COM_START; |
164 | break; |
165 | case ds1631: |
166 | case ds1721: |
167 | case ds1731: |
168 | resol = (new_conf & DS1621_REG_CONFIG_RESOL) >> |
169 | DS1621_REG_CONFIG_RESOL_SHIFT; |
170 | data->update_interval = ds1721_convrates[resol]; |
171 | data->zbits = 7 - resol; |
172 | sreg = DS1721_COM_START; |
173 | break; |
174 | default: |
175 | data->update_interval = DS1621_CONVERSION_MAX; |
176 | data->zbits = 7; |
177 | sreg = DS1621_COM_START; |
178 | break; |
179 | } |
180 | |
181 | /* start conversion */ |
182 | i2c_smbus_write_byte(client, value: sreg); |
183 | } |
184 | |
185 | static struct ds1621_data *ds1621_update_client(struct device *dev) |
186 | { |
187 | struct ds1621_data *data = dev_get_drvdata(dev); |
188 | struct i2c_client *client = data->client; |
189 | u8 new_conf; |
190 | |
191 | mutex_lock(&data->update_lock); |
192 | |
193 | if (time_after(jiffies, data->last_updated + data->update_interval) || |
194 | !data->valid) { |
195 | int i; |
196 | |
197 | dev_dbg(&client->dev, "Starting ds1621 update\n" ); |
198 | |
199 | data->conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF); |
200 | |
201 | for (i = 0; i < ARRAY_SIZE(data->temp); i++) |
202 | data->temp[i] = i2c_smbus_read_word_swapped(client, |
203 | command: DS1621_REG_TEMP[i]); |
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) |
212 | i2c_smbus_write_byte_data(client, DS1621_REG_CONF, |
213 | value: new_conf); |
214 | |
215 | data->last_updated = jiffies; |
216 | data->valid = true; |
217 | } |
218 | |
219 | mutex_unlock(lock: &data->update_lock); |
220 | |
221 | return data; |
222 | } |
223 | |
224 | static ssize_t temp_show(struct device *dev, struct device_attribute *da, |
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, fmt: "%d\n" , |
230 | DS1621_TEMP_FROM_REG(reg: data->temp[attr->index])); |
231 | } |
232 | |
233 | static ssize_t temp_store(struct device *dev, struct device_attribute *da, |
234 | const char *buf, size_t count) |
235 | { |
236 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); |
237 | struct ds1621_data *data = dev_get_drvdata(dev); |
238 | long val; |
239 | int err; |
240 | |
241 | err = kstrtol(s: buf, base: 10, res: &val); |
242 | if (err) |
243 | return err; |
244 | |
245 | mutex_lock(&data->update_lock); |
246 | data->temp[attr->index] = DS1621_TEMP_TO_REG(temp: val, zbits: data->zbits); |
247 | i2c_smbus_write_word_swapped(client: data->client, command: DS1621_REG_TEMP[attr->index], |
248 | value: data->temp[attr->index]); |
249 | mutex_unlock(lock: &data->update_lock); |
250 | return count; |
251 | } |
252 | |
253 | static ssize_t alarms_show(struct device *dev, struct device_attribute *da, |
254 | char *buf) |
255 | { |
256 | struct ds1621_data *data = ds1621_update_client(dev); |
257 | return sprintf(buf, fmt: "%d\n" , ALARMS_FROM_REG(data->conf)); |
258 | } |
259 | |
260 | static ssize_t alarm_show(struct device *dev, struct device_attribute *da, |
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, fmt: "%d\n" , !!(data->conf & attr->index)); |
266 | } |
267 | |
268 | static ssize_t update_interval_show(struct device *dev, |
269 | struct device_attribute *da, char *buf) |
270 | { |
271 | struct ds1621_data *data = dev_get_drvdata(dev); |
272 | return sysfs_emit(buf, fmt: "%hu\n" , data->update_interval); |
273 | } |
274 | |
275 | static ssize_t update_interval_store(struct device *dev, |
276 | struct device_attribute *da, |
277 | const char *buf, size_t count) |
278 | { |
279 | struct ds1621_data *data = dev_get_drvdata(dev); |
280 | struct i2c_client *client = data->client; |
281 | unsigned long convrate; |
282 | s32 err; |
283 | int resol = 0; |
284 | |
285 | err = kstrtoul(s: buf, base: 10, res: &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, value: data->conf); |
299 | data->update_interval = ds1721_convrates[resol]; |
300 | data->zbits = 7 - resol; |
301 | mutex_unlock(lock: &data->update_lock); |
302 | |
303 | return count; |
304 | } |
305 | |
306 | static DEVICE_ATTR_RO(alarms); |
307 | static DEVICE_ATTR_RW(update_interval); |
308 | |
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); |
314 | |
315 | static struct attribute *ds1621_attributes[] = { |
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, |
319 | &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, |
320 | &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, |
321 | &dev_attr_alarms.attr, |
322 | &dev_attr_update_interval.attr, |
323 | NULL |
324 | }; |
325 | |
326 | static umode_t ds1621_attribute_visible(struct kobject *kobj, |
327 | struct attribute *attr, int index) |
328 | { |
329 | struct device *dev = kobj_to_dev(kobj); |
330 | struct ds1621_data *data = dev_get_drvdata(dev); |
331 | |
332 | if (attr == &dev_attr_update_interval.attr) |
333 | if (data->kind == ds1621 || data->kind == ds1625) |
334 | /* shhh, we're hiding update_interval */ |
335 | return 0; |
336 | return attr->mode; |
337 | } |
338 | |
339 | static const struct attribute_group ds1621_group = { |
340 | .attrs = ds1621_attributes, |
341 | .is_visible = ds1621_attribute_visible |
342 | }; |
343 | __ATTRIBUTE_GROUPS(ds1621); |
344 | |
345 | static const struct i2c_device_id ds1621_id[]; |
346 | |
347 | static int ds1621_probe(struct i2c_client *client) |
348 | { |
349 | struct ds1621_data *data; |
350 | struct device *hwmon_dev; |
351 | |
352 | data = devm_kzalloc(dev: &client->dev, size: sizeof(struct ds1621_data), |
353 | GFP_KERNEL); |
354 | if (!data) |
355 | return -ENOMEM; |
356 | |
357 | mutex_init(&data->update_lock); |
358 | |
359 | data->kind = i2c_match_id(id: ds1621_id, client)->driver_data; |
360 | data->client = client; |
361 | |
362 | /* Initialize the DS1621 chip */ |
363 | ds1621_init_client(data, client); |
364 | |
365 | hwmon_dev = devm_hwmon_device_register_with_groups(dev: &client->dev, |
366 | name: client->name, drvdata: data, |
367 | groups: ds1621_groups); |
368 | return PTR_ERR_OR_ZERO(ptr: hwmon_dev); |
369 | } |
370 | |
371 | static const struct i2c_device_id ds1621_id[] = { |
372 | { "ds1621" , ds1621 }, |
373 | { "ds1625" , ds1625 }, |
374 | { "ds1631" , ds1631 }, |
375 | { "ds1721" , ds1721 }, |
376 | { "ds1731" , ds1731 }, |
377 | { } |
378 | }; |
379 | MODULE_DEVICE_TABLE(i2c, ds1621_id); |
380 | |
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 | }, |
387 | .probe = ds1621_probe, |
388 | .id_table = ds1621_id, |
389 | }; |
390 | |
391 | module_i2c_driver(ds1621_driver); |
392 | |
393 | MODULE_AUTHOR("Christian W. Zuckschwerdt <zany@triq.net>" ); |
394 | MODULE_DESCRIPTION("DS1621 driver" ); |
395 | MODULE_LICENSE("GPL" ); |
396 | |