xref: /openbmc/linux/drivers/hwmon/max1668.c (revision c4f7ac64)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /*
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
7   */
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 */
20  static const unsigned short max1668_addr_list[] = {
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 */
49  static bool read_only;
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 {
56  	struct i2c_client *client;
57  	const struct attribute_group *groups[3];
58  	enum chips type;
59  
60  	struct mutex update_lock;
61  	char valid;		/* !=0 if following fields are valid */
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  {
73  	struct max1668_data *data = dev_get_drvdata(dev);
74  	struct i2c_client *client = data->client;
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  	}
113  	data->alarms = val << 8;
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  	}
120  	data->alarms |= val;
121  
122  	data->last_updated = jiffies;
123  	data->valid = 1;
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  
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  
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;
196  	struct max1668_data *data = dev_get_drvdata(dev);
197  	struct i2c_client *client = data->client;
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);
206  	data->temp_max[index] = clamp_val(temp/1000, -128, 127);
207  	ret = i2c_smbus_write_byte_data(client,
208  					MAX1668_REG_LIMH_WR(index),
209  					data->temp_max[index]);
210  	if (ret < 0)
211  		count = ret;
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;
222  	struct max1668_data *data = dev_get_drvdata(dev);
223  	struct i2c_client *client = data->client;
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);
232  	data->temp_min[index] = clamp_val(temp/1000, -128, 127);
233  	ret = i2c_smbus_write_byte_data(client,
234  					MAX1668_REG_LIML_WR(index),
235  					data->temp_min[index]);
236  	if (ret < 0)
237  		count = ret;
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  
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  
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,
303  
304  	&sensor_dev_attr_temp2_fault.dev_attr.attr,
305  	&sensor_dev_attr_temp3_fault.dev_attr.attr,
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,
322  
323  	&sensor_dev_attr_temp4_fault.dev_attr.attr,
324  	&sensor_dev_attr_temp5_fault.dev_attr.attr,
325  	NULL
326  };
327  
328  static umode_t max1668_attribute_mode(struct kobject *kobj,
329  				     struct attribute *attr, int index)
330  {
331  	umode_t ret = S_IRUGO;
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  
389  	strlcpy(info->type, type_name, I2C_NAME_SIZE);
390  
391  	return 0;
392  }
393  
394  static const struct i2c_device_id max1668_id[];
395  
396  static int max1668_probe(struct i2c_client *client)
397  {
398  	struct i2c_adapter *adapter = client->adapter;
399  	struct device *dev = &client->dev;
400  	struct device *hwmon_dev;
401  	struct max1668_data *data;
402  
403  	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
404  		return -ENODEV;
405  
406  	data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL);
407  	if (!data)
408  		return -ENOMEM;
409  
410  	data->client = client;
411  	data->type = i2c_match_id(max1668_id, client)->driver_data;
412  	mutex_init(&data->update_lock);
413  
414  	/* sysfs hooks */
415  	data->groups[0] = &max1668_group_common;
416  	if (data->type == max1668 || data->type == max1989)
417  		data->groups[1] = &max1668_group_unique;
418  
419  	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
420  							   data, data->groups);
421  	return PTR_ERR_OR_ZERO(hwmon_dev);
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  		  },
438  	.probe_new = max1668_probe,
439  	.id_table = max1668_id,
440  	.detect	= max1668_detect,
441  	.address_list = max1668_addr_list,
442  };
443  
444  module_i2c_driver(max1668_driver);
445  
446  MODULE_AUTHOR("David George <david.george@ska.ac.za>");
447  MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver");
448  MODULE_LICENSE("GPL");
449