Commit | Line | Data |
---|---|---|
74ba9207 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
731b4cac | 2 | /* |
b6707b78 GR |
3 | * Copyright (c) 2011 David George <david.george@ska.ac.za> |
4 | * | |
5 | * based on adm1021.c | |
6 | * some credit to Christoph Scheurer, but largely a rewrite | |
b6707b78 | 7 | */ |
731b4cac DG |
8 | |
9 | #include <linux/module.h> | |
10 | #include <linux/init.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/jiffies.h> | |
13 | #include <linux/i2c.h> | |
14 | #include <linux/hwmon.h> | |
15 | #include <linux/hwmon-sysfs.h> | |
16 | #include <linux/err.h> | |
17 | #include <linux/mutex.h> | |
18 | ||
19 | /* Addresses to scan */ | |
28681d71 | 20 | static const unsigned short max1668_addr_list[] = { |
731b4cac DG |
21 | 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END }; |
22 | ||
23 | /* max1668 registers */ | |
24 | ||
25 | #define MAX1668_REG_TEMP(nr) (nr) | |
26 | #define MAX1668_REG_STAT1 0x05 | |
27 | #define MAX1668_REG_STAT2 0x06 | |
28 | #define MAX1668_REG_MAN_ID 0xfe | |
29 | #define MAX1668_REG_DEV_ID 0xff | |
30 | ||
31 | /* limits */ | |
32 | ||
33 | /* write high limits */ | |
34 | #define MAX1668_REG_LIMH_WR(nr) (0x13 + 2 * (nr)) | |
35 | /* write low limits */ | |
36 | #define MAX1668_REG_LIML_WR(nr) (0x14 + 2 * (nr)) | |
37 | /* read high limits */ | |
38 | #define MAX1668_REG_LIMH_RD(nr) (0x08 + 2 * (nr)) | |
39 | /* read low limits */ | |
40 | #define MAX1668_REG_LIML_RD(nr) (0x09 + 2 * (nr)) | |
41 | ||
42 | /* manufacturer and device ID Constants */ | |
43 | #define MAN_ID_MAXIM 0x4d | |
44 | #define DEV_ID_MAX1668 0x3 | |
45 | #define DEV_ID_MAX1805 0x5 | |
46 | #define DEV_ID_MAX1989 0xb | |
47 | ||
48 | /* read only mode module parameter */ | |
90ab5ee9 | 49 | static bool read_only; |
731b4cac DG |
50 | module_param(read_only, bool, 0); |
51 | MODULE_PARM_DESC(read_only, "Don't set any values, read only mode"); | |
52 | ||
53 | enum chips { max1668, max1805, max1989 }; | |
54 | ||
55 | struct max1668_data { | |
5230551a GR |
56 | struct i2c_client *client; |
57 | const struct attribute_group *groups[3]; | |
731b4cac DG |
58 | enum chips type; |
59 | ||
60 | struct mutex update_lock; | |
952a11ca | 61 | bool valid; /* true if following fields are valid */ |
731b4cac DG |
62 | unsigned long last_updated; /* In jiffies */ |
63 | ||
64 | /* 1x local and 4x remote */ | |
65 | s8 temp_max[5]; | |
66 | s8 temp_min[5]; | |
67 | s8 temp[5]; | |
68 | u16 alarms; | |
69 | }; | |
70 | ||
71 | static struct max1668_data *max1668_update_device(struct device *dev) | |
72 | { | |
5230551a GR |
73 | struct max1668_data *data = dev_get_drvdata(dev); |
74 | struct i2c_client *client = data->client; | |
731b4cac DG |
75 | struct max1668_data *ret = data; |
76 | s32 val; | |
77 | int i; | |
78 | ||
79 | mutex_lock(&data->update_lock); | |
80 | ||
81 | if (data->valid && !time_after(jiffies, | |
82 | data->last_updated + HZ + HZ / 2)) | |
83 | goto abort; | |
84 | ||
85 | for (i = 0; i < 5; i++) { | |
86 | val = i2c_smbus_read_byte_data(client, MAX1668_REG_TEMP(i)); | |
87 | if (unlikely(val < 0)) { | |
88 | ret = ERR_PTR(val); | |
89 | goto abort; | |
90 | } | |
91 | data->temp[i] = (s8) val; | |
92 | ||
93 | val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIMH_RD(i)); | |
94 | if (unlikely(val < 0)) { | |
95 | ret = ERR_PTR(val); | |
96 | goto abort; | |
97 | } | |
98 | data->temp_max[i] = (s8) val; | |
99 | ||
100 | val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIML_RD(i)); | |
101 | if (unlikely(val < 0)) { | |
102 | ret = ERR_PTR(val); | |
103 | goto abort; | |
104 | } | |
105 | data->temp_min[i] = (s8) val; | |
106 | } | |
107 | ||
108 | val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT1); | |
109 | if (unlikely(val < 0)) { | |
110 | ret = ERR_PTR(val); | |
111 | goto abort; | |
112 | } | |
dabaa0d2 | 113 | data->alarms = val << 8; |
731b4cac DG |
114 | |
115 | val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT2); | |
116 | if (unlikely(val < 0)) { | |
117 | ret = ERR_PTR(val); | |
118 | goto abort; | |
119 | } | |
dabaa0d2 | 120 | data->alarms |= val; |
731b4cac DG |
121 | |
122 | data->last_updated = jiffies; | |
952a11ca | 123 | data->valid = true; |
731b4cac DG |
124 | abort: |
125 | mutex_unlock(&data->update_lock); | |
126 | ||
127 | return ret; | |
128 | } | |
129 | ||
130 | static ssize_t show_temp(struct device *dev, | |
131 | struct device_attribute *devattr, char *buf) | |
132 | { | |
133 | int index = to_sensor_dev_attr(devattr)->index; | |
134 | struct max1668_data *data = max1668_update_device(dev); | |
135 | ||
136 | if (IS_ERR(data)) | |
137 | return PTR_ERR(data); | |
138 | ||
139 | return sprintf(buf, "%d\n", data->temp[index] * 1000); | |
140 | } | |
141 | ||
142 | static ssize_t show_temp_max(struct device *dev, | |
143 | struct device_attribute *devattr, char *buf) | |
144 | { | |
145 | int index = to_sensor_dev_attr(devattr)->index; | |
146 | struct max1668_data *data = max1668_update_device(dev); | |
147 | ||
148 | if (IS_ERR(data)) | |
149 | return PTR_ERR(data); | |
150 | ||
151 | return sprintf(buf, "%d\n", data->temp_max[index] * 1000); | |
152 | } | |
153 | ||
154 | static ssize_t show_temp_min(struct device *dev, | |
155 | struct device_attribute *devattr, char *buf) | |
156 | { | |
157 | int index = to_sensor_dev_attr(devattr)->index; | |
158 | struct max1668_data *data = max1668_update_device(dev); | |
159 | ||
160 | if (IS_ERR(data)) | |
161 | return PTR_ERR(data); | |
162 | ||
163 | return sprintf(buf, "%d\n", data->temp_min[index] * 1000); | |
164 | } | |
165 | ||
166 | static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, | |
167 | char *buf) | |
168 | { | |
169 | int index = to_sensor_dev_attr(attr)->index; | |
170 | struct max1668_data *data = max1668_update_device(dev); | |
171 | ||
172 | if (IS_ERR(data)) | |
173 | return PTR_ERR(data); | |
174 | ||
175 | return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1); | |
176 | } | |
177 | ||
dabaa0d2 GR |
178 | static ssize_t show_fault(struct device *dev, |
179 | struct device_attribute *devattr, char *buf) | |
180 | { | |
181 | int index = to_sensor_dev_attr(devattr)->index; | |
182 | struct max1668_data *data = max1668_update_device(dev); | |
183 | ||
184 | if (IS_ERR(data)) | |
185 | return PTR_ERR(data); | |
186 | ||
187 | return sprintf(buf, "%u\n", | |
188 | (data->alarms & (1 << 12)) && data->temp[index] == 127); | |
189 | } | |
190 | ||
731b4cac DG |
191 | static ssize_t set_temp_max(struct device *dev, |
192 | struct device_attribute *devattr, | |
193 | const char *buf, size_t count) | |
194 | { | |
195 | int index = to_sensor_dev_attr(devattr)->index; | |
5230551a GR |
196 | struct max1668_data *data = dev_get_drvdata(dev); |
197 | struct i2c_client *client = data->client; | |
731b4cac DG |
198 | long temp; |
199 | int ret; | |
200 | ||
201 | ret = kstrtol(buf, 10, &temp); | |
202 | if (ret < 0) | |
203 | return ret; | |
204 | ||
205 | mutex_lock(&data->update_lock); | |
2a844c14 | 206 | data->temp_max[index] = clamp_val(temp/1000, -128, 127); |
c5a70669 | 207 | ret = i2c_smbus_write_byte_data(client, |
731b4cac | 208 | MAX1668_REG_LIMH_WR(index), |
c5a70669 GR |
209 | data->temp_max[index]); |
210 | if (ret < 0) | |
211 | count = ret; | |
731b4cac DG |
212 | mutex_unlock(&data->update_lock); |
213 | ||
214 | return count; | |
215 | } | |
216 | ||
217 | static ssize_t set_temp_min(struct device *dev, | |
218 | struct device_attribute *devattr, | |
219 | const char *buf, size_t count) | |
220 | { | |
221 | int index = to_sensor_dev_attr(devattr)->index; | |
5230551a GR |
222 | struct max1668_data *data = dev_get_drvdata(dev); |
223 | struct i2c_client *client = data->client; | |
731b4cac DG |
224 | long temp; |
225 | int ret; | |
226 | ||
227 | ret = kstrtol(buf, 10, &temp); | |
228 | if (ret < 0) | |
229 | return ret; | |
230 | ||
231 | mutex_lock(&data->update_lock); | |
2a844c14 | 232 | data->temp_min[index] = clamp_val(temp/1000, -128, 127); |
c5a70669 | 233 | ret = i2c_smbus_write_byte_data(client, |
731b4cac | 234 | MAX1668_REG_LIML_WR(index), |
c5a70669 GR |
235 | data->temp_min[index]); |
236 | if (ret < 0) | |
237 | count = ret; | |
731b4cac DG |
238 | mutex_unlock(&data->update_lock); |
239 | ||
240 | return count; | |
241 | } | |
242 | ||
243 | static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); | |
244 | static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max, | |
245 | set_temp_max, 0); | |
246 | static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min, | |
247 | set_temp_min, 0); | |
248 | static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); | |
249 | static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max, | |
250 | set_temp_max, 1); | |
251 | static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min, | |
252 | set_temp_min, 1); | |
253 | static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2); | |
254 | static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max, | |
255 | set_temp_max, 2); | |
256 | static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min, | |
257 | set_temp_min, 2); | |
258 | static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3); | |
259 | static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max, | |
260 | set_temp_max, 3); | |
261 | static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min, | |
262 | set_temp_min, 3); | |
263 | static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4); | |
264 | static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max, | |
265 | set_temp_max, 4); | |
266 | static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min, | |
267 | set_temp_min, 4); | |
268 | ||
269 | static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 14); | |
270 | static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 13); | |
271 | static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 7); | |
272 | static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 6); | |
273 | static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 5); | |
274 | static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4); | |
275 | static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 3); | |
276 | static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 2); | |
277 | static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 1); | |
278 | static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 0); | |
279 | ||
dabaa0d2 GR |
280 | static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1); |
281 | static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2); | |
282 | static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3); | |
283 | static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_fault, NULL, 4); | |
284 | ||
731b4cac DG |
285 | /* Attributes common to MAX1668, MAX1989 and MAX1805 */ |
286 | static struct attribute *max1668_attribute_common[] = { | |
287 | &sensor_dev_attr_temp1_max.dev_attr.attr, | |
288 | &sensor_dev_attr_temp1_min.dev_attr.attr, | |
289 | &sensor_dev_attr_temp1_input.dev_attr.attr, | |
290 | &sensor_dev_attr_temp2_max.dev_attr.attr, | |
291 | &sensor_dev_attr_temp2_min.dev_attr.attr, | |
292 | &sensor_dev_attr_temp2_input.dev_attr.attr, | |
293 | &sensor_dev_attr_temp3_max.dev_attr.attr, | |
294 | &sensor_dev_attr_temp3_min.dev_attr.attr, | |
295 | &sensor_dev_attr_temp3_input.dev_attr.attr, | |
296 | ||
297 | &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, | |
298 | &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, | |
299 | &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, | |
300 | &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, | |
301 | &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, | |
302 | &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, | |
dabaa0d2 GR |
303 | |
304 | &sensor_dev_attr_temp2_fault.dev_attr.attr, | |
305 | &sensor_dev_attr_temp3_fault.dev_attr.attr, | |
731b4cac DG |
306 | NULL |
307 | }; | |
308 | ||
309 | /* Attributes not present on MAX1805 */ | |
310 | static struct attribute *max1668_attribute_unique[] = { | |
311 | &sensor_dev_attr_temp4_max.dev_attr.attr, | |
312 | &sensor_dev_attr_temp4_min.dev_attr.attr, | |
313 | &sensor_dev_attr_temp4_input.dev_attr.attr, | |
314 | &sensor_dev_attr_temp5_max.dev_attr.attr, | |
315 | &sensor_dev_attr_temp5_min.dev_attr.attr, | |
316 | &sensor_dev_attr_temp5_input.dev_attr.attr, | |
317 | ||
318 | &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, | |
319 | &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, | |
320 | &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, | |
321 | &sensor_dev_attr_temp5_min_alarm.dev_attr.attr, | |
dabaa0d2 GR |
322 | |
323 | &sensor_dev_attr_temp4_fault.dev_attr.attr, | |
324 | &sensor_dev_attr_temp5_fault.dev_attr.attr, | |
731b4cac DG |
325 | NULL |
326 | }; | |
327 | ||
587a1f16 | 328 | static umode_t max1668_attribute_mode(struct kobject *kobj, |
731b4cac DG |
329 | struct attribute *attr, int index) |
330 | { | |
587a1f16 | 331 | umode_t ret = S_IRUGO; |
731b4cac DG |
332 | if (read_only) |
333 | return ret; | |
334 | if (attr == &sensor_dev_attr_temp1_max.dev_attr.attr || | |
335 | attr == &sensor_dev_attr_temp2_max.dev_attr.attr || | |
336 | attr == &sensor_dev_attr_temp3_max.dev_attr.attr || | |
337 | attr == &sensor_dev_attr_temp4_max.dev_attr.attr || | |
338 | attr == &sensor_dev_attr_temp5_max.dev_attr.attr || | |
339 | attr == &sensor_dev_attr_temp1_min.dev_attr.attr || | |
340 | attr == &sensor_dev_attr_temp2_min.dev_attr.attr || | |
341 | attr == &sensor_dev_attr_temp3_min.dev_attr.attr || | |
342 | attr == &sensor_dev_attr_temp4_min.dev_attr.attr || | |
343 | attr == &sensor_dev_attr_temp5_min.dev_attr.attr) | |
344 | ret |= S_IWUSR; | |
345 | return ret; | |
346 | } | |
347 | ||
348 | static const struct attribute_group max1668_group_common = { | |
349 | .attrs = max1668_attribute_common, | |
350 | .is_visible = max1668_attribute_mode | |
351 | }; | |
352 | ||
353 | static const struct attribute_group max1668_group_unique = { | |
354 | .attrs = max1668_attribute_unique, | |
355 | .is_visible = max1668_attribute_mode | |
356 | }; | |
357 | ||
358 | /* Return 0 if detection is successful, -ENODEV otherwise */ | |
359 | static int max1668_detect(struct i2c_client *client, | |
360 | struct i2c_board_info *info) | |
361 | { | |
362 | struct i2c_adapter *adapter = client->adapter; | |
363 | const char *type_name; | |
364 | int man_id, dev_id; | |
365 | ||
366 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | |
367 | return -ENODEV; | |
368 | ||
369 | /* Check for unsupported part */ | |
370 | man_id = i2c_smbus_read_byte_data(client, MAX1668_REG_MAN_ID); | |
371 | if (man_id != MAN_ID_MAXIM) | |
372 | return -ENODEV; | |
373 | ||
374 | dev_id = i2c_smbus_read_byte_data(client, MAX1668_REG_DEV_ID); | |
375 | if (dev_id < 0) | |
376 | return -ENODEV; | |
377 | ||
378 | type_name = NULL; | |
379 | if (dev_id == DEV_ID_MAX1668) | |
380 | type_name = "max1668"; | |
381 | else if (dev_id == DEV_ID_MAX1805) | |
382 | type_name = "max1805"; | |
383 | else if (dev_id == DEV_ID_MAX1989) | |
384 | type_name = "max1989"; | |
385 | ||
386 | if (!type_name) | |
387 | return -ENODEV; | |
388 | ||
f2f394db | 389 | strscpy(info->type, type_name, I2C_NAME_SIZE); |
731b4cac DG |
390 | |
391 | return 0; | |
392 | } | |
393 | ||
67487038 SK |
394 | static const struct i2c_device_id max1668_id[]; |
395 | ||
396 | static int max1668_probe(struct i2c_client *client) | |
731b4cac DG |
397 | { |
398 | struct i2c_adapter *adapter = client->adapter; | |
5230551a GR |
399 | struct device *dev = &client->dev; |
400 | struct device *hwmon_dev; | |
731b4cac | 401 | struct max1668_data *data; |
731b4cac DG |
402 | |
403 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | |
404 | return -ENODEV; | |
405 | ||
5230551a | 406 | data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL); |
731b4cac DG |
407 | if (!data) |
408 | return -ENOMEM; | |
409 | ||
5230551a | 410 | data->client = client; |
67487038 | 411 | data->type = i2c_match_id(max1668_id, client)->driver_data; |
731b4cac DG |
412 | mutex_init(&data->update_lock); |
413 | ||
5230551a GR |
414 | /* sysfs hooks */ |
415 | data->groups[0] = &max1668_group_common; | |
731b4cac | 416 | if (data->type == max1668 || data->type == max1989) |
5230551a | 417 | data->groups[1] = &max1668_group_unique; |
731b4cac | 418 | |
5230551a GR |
419 | hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, |
420 | data, data->groups); | |
421 | return PTR_ERR_OR_ZERO(hwmon_dev); | |
731b4cac DG |
422 | } |
423 | ||
424 | static const struct i2c_device_id max1668_id[] = { | |
425 | { "max1668", max1668 }, | |
426 | { "max1805", max1805 }, | |
427 | { "max1989", max1989 }, | |
428 | { } | |
429 | }; | |
430 | MODULE_DEVICE_TABLE(i2c, max1668_id); | |
431 | ||
432 | /* This is the driver that will be inserted */ | |
433 | static struct i2c_driver max1668_driver = { | |
434 | .class = I2C_CLASS_HWMON, | |
435 | .driver = { | |
436 | .name = "max1668", | |
437 | }, | |
1975d167 | 438 | .probe = max1668_probe, |
731b4cac DG |
439 | .id_table = max1668_id, |
440 | .detect = max1668_detect, | |
441 | .address_list = max1668_addr_list, | |
442 | }; | |
443 | ||
f0967eea | 444 | module_i2c_driver(max1668_driver); |
731b4cac DG |
445 | |
446 | MODULE_AUTHOR("David George <david.george@ska.ac.za>"); | |
447 | MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver"); | |
448 | MODULE_LICENSE("GPL"); |