xref: /openbmc/linux/drivers/hwmon/max31730.c (revision 39f03438)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Driver for MAX31730 3-Channel Remote Temperature Sensor
4  *
5  * Copyright (c) 2019 Guenter Roeck <linux@roeck-us.net>
6  */
7 
8 #include <linux/bits.h>
9 #include <linux/err.h>
10 #include <linux/i2c.h>
11 #include <linux/init.h>
12 #include <linux/hwmon.h>
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/slab.h>
16 
17 /* Addresses scanned */
18 static const unsigned short normal_i2c[] = { 0x1c, 0x1d, 0x1e, 0x1f, 0x4c,
19 					     0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
20 
21 /* The MAX31730 registers */
22 #define MAX31730_REG_TEMP		0x00
23 #define MAX31730_REG_CONF		0x13
24 #define  MAX31730_STOP			BIT(7)
25 #define  MAX31730_EXTRANGE		BIT(1)
26 #define MAX31730_REG_TEMP_OFFSET	0x16
27 #define  MAX31730_TEMP_OFFSET_BASELINE	0x77
28 #define MAX31730_REG_OFFSET_ENABLE	0x17
29 #define MAX31730_REG_TEMP_MAX		0x20
30 #define MAX31730_REG_TEMP_MIN		0x30
31 #define MAX31730_REG_STATUS_HIGH	0x32
32 #define MAX31730_REG_STATUS_LOW		0x33
33 #define MAX31730_REG_CHANNEL_ENABLE	0x35
34 #define MAX31730_REG_TEMP_FAULT		0x36
35 
36 #define MAX31730_REG_MFG_ID		0x50
37 #define  MAX31730_MFG_ID		0x4d
38 #define MAX31730_REG_MFG_REV		0x51
39 #define  MAX31730_MFG_REV		0x01
40 
41 #define MAX31730_TEMP_MIN		(-128000)
42 #define MAX31730_TEMP_MAX		127937
43 
44 /* Each client has this additional data */
45 struct max31730_data {
46 	struct i2c_client	*client;
47 	u8			orig_conf;
48 	u8			current_conf;
49 	u8			offset_enable;
50 	u8			channel_enable;
51 };
52 
53 /*-----------------------------------------------------------------------*/
54 
max31730_reg_to_mc(s16 temp)55 static inline long max31730_reg_to_mc(s16 temp)
56 {
57 	return DIV_ROUND_CLOSEST((temp >> 4) * 1000, 16);
58 }
59 
max31730_write_config(struct max31730_data * data,u8 set_mask,u8 clr_mask)60 static int max31730_write_config(struct max31730_data *data, u8 set_mask,
61 				 u8 clr_mask)
62 {
63 	u8 value;
64 
65 	clr_mask |= MAX31730_EXTRANGE;
66 	value = data->current_conf & ~clr_mask;
67 	value |= set_mask;
68 
69 	if (data->current_conf != value) {
70 		s32 err;
71 
72 		err = i2c_smbus_write_byte_data(data->client, MAX31730_REG_CONF,
73 						value);
74 		if (err)
75 			return err;
76 		data->current_conf = value;
77 	}
78 	return 0;
79 }
80 
max31730_set_enable(struct i2c_client * client,int reg,u8 * confdata,int channel,bool enable)81 static int max31730_set_enable(struct i2c_client *client, int reg,
82 			       u8 *confdata, int channel, bool enable)
83 {
84 	u8 regval = *confdata;
85 	int err;
86 
87 	if (enable)
88 		regval |= BIT(channel);
89 	else
90 		regval &= ~BIT(channel);
91 
92 	if (regval != *confdata) {
93 		err = i2c_smbus_write_byte_data(client, reg, regval);
94 		if (err)
95 			return err;
96 		*confdata = regval;
97 	}
98 	return 0;
99 }
100 
max31730_set_offset_enable(struct max31730_data * data,int channel,bool enable)101 static int max31730_set_offset_enable(struct max31730_data *data, int channel,
102 				      bool enable)
103 {
104 	return max31730_set_enable(data->client, MAX31730_REG_OFFSET_ENABLE,
105 				   &data->offset_enable, channel, enable);
106 }
107 
max31730_set_channel_enable(struct max31730_data * data,int channel,bool enable)108 static int max31730_set_channel_enable(struct max31730_data *data, int channel,
109 				       bool enable)
110 {
111 	return max31730_set_enable(data->client, MAX31730_REG_CHANNEL_ENABLE,
112 				   &data->channel_enable, channel, enable);
113 }
114 
max31730_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)115 static int max31730_read(struct device *dev, enum hwmon_sensor_types type,
116 			 u32 attr, int channel, long *val)
117 {
118 	struct max31730_data *data = dev_get_drvdata(dev);
119 	int regval, reg, offset;
120 
121 	if (type != hwmon_temp)
122 		return -EINVAL;
123 
124 	switch (attr) {
125 	case hwmon_temp_input:
126 		if (!(data->channel_enable & BIT(channel)))
127 			return -ENODATA;
128 		reg = MAX31730_REG_TEMP + (channel * 2);
129 		break;
130 	case hwmon_temp_max:
131 		reg = MAX31730_REG_TEMP_MAX + (channel * 2);
132 		break;
133 	case hwmon_temp_min:
134 		reg = MAX31730_REG_TEMP_MIN;
135 		break;
136 	case hwmon_temp_enable:
137 		*val = !!(data->channel_enable & BIT(channel));
138 		return 0;
139 	case hwmon_temp_offset:
140 		if (!channel)
141 			return -EINVAL;
142 		if (!(data->offset_enable & BIT(channel))) {
143 			*val = 0;
144 			return 0;
145 		}
146 		offset = i2c_smbus_read_byte_data(data->client,
147 						  MAX31730_REG_TEMP_OFFSET);
148 		if (offset < 0)
149 			return offset;
150 		*val = (offset - MAX31730_TEMP_OFFSET_BASELINE) * 125;
151 		return 0;
152 	case hwmon_temp_fault:
153 		regval = i2c_smbus_read_byte_data(data->client,
154 						  MAX31730_REG_TEMP_FAULT);
155 		if (regval < 0)
156 			return regval;
157 		*val = !!(regval & BIT(channel));
158 		return 0;
159 	case hwmon_temp_min_alarm:
160 		regval = i2c_smbus_read_byte_data(data->client,
161 						  MAX31730_REG_STATUS_LOW);
162 		if (regval < 0)
163 			return regval;
164 		*val = !!(regval & BIT(channel));
165 		return 0;
166 	case hwmon_temp_max_alarm:
167 		regval = i2c_smbus_read_byte_data(data->client,
168 						  MAX31730_REG_STATUS_HIGH);
169 		if (regval < 0)
170 			return regval;
171 		*val = !!(regval & BIT(channel));
172 		return 0;
173 	default:
174 		return -EINVAL;
175 	}
176 	regval = i2c_smbus_read_word_swapped(data->client, reg);
177 	if (regval < 0)
178 		return regval;
179 
180 	*val = max31730_reg_to_mc(regval);
181 
182 	return 0;
183 }
184 
max31730_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)185 static int max31730_write(struct device *dev, enum hwmon_sensor_types type,
186 			  u32 attr, int channel, long val)
187 {
188 	struct max31730_data *data = dev_get_drvdata(dev);
189 	int reg, err;
190 
191 	if (type != hwmon_temp)
192 		return -EINVAL;
193 
194 	switch (attr) {
195 	case hwmon_temp_max:
196 		reg = MAX31730_REG_TEMP_MAX + channel * 2;
197 		break;
198 	case hwmon_temp_min:
199 		reg = MAX31730_REG_TEMP_MIN;
200 		break;
201 	case hwmon_temp_enable:
202 		if (val != 0 && val != 1)
203 			return -EINVAL;
204 		return max31730_set_channel_enable(data, channel, val);
205 	case hwmon_temp_offset:
206 		val = clamp_val(val, -14875, 17000) + 14875;
207 		val = DIV_ROUND_CLOSEST(val, 125);
208 		err = max31730_set_offset_enable(data, channel,
209 					val != MAX31730_TEMP_OFFSET_BASELINE);
210 		if (err)
211 			return err;
212 		return i2c_smbus_write_byte_data(data->client,
213 						 MAX31730_REG_TEMP_OFFSET, val);
214 	default:
215 		return -EINVAL;
216 	}
217 
218 	val = clamp_val(val, MAX31730_TEMP_MIN, MAX31730_TEMP_MAX);
219 	val = DIV_ROUND_CLOSEST(val << 4, 1000) << 4;
220 
221 	return i2c_smbus_write_word_swapped(data->client, reg, (u16)val);
222 }
223 
max31730_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)224 static umode_t max31730_is_visible(const void *data,
225 				   enum hwmon_sensor_types type,
226 				   u32 attr, int channel)
227 {
228 	switch (type) {
229 	case hwmon_temp:
230 		switch (attr) {
231 		case hwmon_temp_input:
232 		case hwmon_temp_min_alarm:
233 		case hwmon_temp_max_alarm:
234 		case hwmon_temp_fault:
235 			return 0444;
236 		case hwmon_temp_min:
237 			return channel ? 0444 : 0644;
238 		case hwmon_temp_offset:
239 		case hwmon_temp_enable:
240 		case hwmon_temp_max:
241 			return 0644;
242 		}
243 		break;
244 	default:
245 		break;
246 	}
247 	return 0;
248 }
249 
250 static const struct hwmon_channel_info * const max31730_info[] = {
251 	HWMON_CHANNEL_INFO(chip,
252 			   HWMON_C_REGISTER_TZ),
253 	HWMON_CHANNEL_INFO(temp,
254 			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
255 			   HWMON_T_ENABLE |
256 			   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM,
257 			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
258 			   HWMON_T_OFFSET | HWMON_T_ENABLE |
259 			   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
260 			   HWMON_T_FAULT,
261 			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
262 			   HWMON_T_OFFSET | HWMON_T_ENABLE |
263 			   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
264 			   HWMON_T_FAULT,
265 			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
266 			   HWMON_T_OFFSET | HWMON_T_ENABLE |
267 			   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
268 			   HWMON_T_FAULT
269 			   ),
270 	NULL
271 };
272 
273 static const struct hwmon_ops max31730_hwmon_ops = {
274 	.is_visible = max31730_is_visible,
275 	.read = max31730_read,
276 	.write = max31730_write,
277 };
278 
279 static const struct hwmon_chip_info max31730_chip_info = {
280 	.ops = &max31730_hwmon_ops,
281 	.info = max31730_info,
282 };
283 
max31730_remove(void * data)284 static void max31730_remove(void *data)
285 {
286 	struct max31730_data *max31730 = data;
287 	struct i2c_client *client = max31730->client;
288 
289 	i2c_smbus_write_byte_data(client, MAX31730_REG_CONF,
290 				  max31730->orig_conf);
291 }
292 
293 static int
max31730_probe(struct i2c_client * client)294 max31730_probe(struct i2c_client *client)
295 {
296 	struct device *dev = &client->dev;
297 	struct device *hwmon_dev;
298 	struct max31730_data *data;
299 	int status, err;
300 
301 	if (!i2c_check_functionality(client->adapter,
302 			I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
303 		return -EIO;
304 
305 	data = devm_kzalloc(dev, sizeof(struct max31730_data), GFP_KERNEL);
306 	if (!data)
307 		return -ENOMEM;
308 
309 	data->client = client;
310 
311 	/* Cache original configuration and enable status */
312 	status = i2c_smbus_read_byte_data(client, MAX31730_REG_CHANNEL_ENABLE);
313 	if (status < 0)
314 		return status;
315 	data->channel_enable = status;
316 
317 	status = i2c_smbus_read_byte_data(client, MAX31730_REG_OFFSET_ENABLE);
318 	if (status < 0)
319 		return status;
320 	data->offset_enable = status;
321 
322 	status = i2c_smbus_read_byte_data(client, MAX31730_REG_CONF);
323 	if (status < 0)
324 		return status;
325 	data->orig_conf = status;
326 	data->current_conf = status;
327 
328 	err = max31730_write_config(data,
329 				    data->channel_enable ? 0 : MAX31730_STOP,
330 				    data->channel_enable ? MAX31730_STOP : 0);
331 	if (err)
332 		return err;
333 
334 	dev_set_drvdata(dev, data);
335 
336 	err = devm_add_action_or_reset(dev, max31730_remove, data);
337 	if (err)
338 		return err;
339 
340 	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
341 							 data,
342 							 &max31730_chip_info,
343 							 NULL);
344 	return PTR_ERR_OR_ZERO(hwmon_dev);
345 }
346 
347 static const struct i2c_device_id max31730_ids[] = {
348 	{ "max31730", 0, },
349 	{ }
350 };
351 MODULE_DEVICE_TABLE(i2c, max31730_ids);
352 
353 static const struct of_device_id __maybe_unused max31730_of_match[] = {
354 	{
355 		.compatible = "maxim,max31730",
356 	},
357 	{ },
358 };
359 MODULE_DEVICE_TABLE(of, max31730_of_match);
360 
max31730_check_reg_temp(struct i2c_client * client,int reg)361 static bool max31730_check_reg_temp(struct i2c_client *client,
362 				    int reg)
363 {
364 	int regval;
365 
366 	regval = i2c_smbus_read_byte_data(client, reg + 1);
367 	return regval < 0 || (regval & 0x0f);
368 }
369 
370 /* Return 0 if detection is successful, -ENODEV otherwise */
max31730_detect(struct i2c_client * client,struct i2c_board_info * info)371 static int max31730_detect(struct i2c_client *client,
372 			   struct i2c_board_info *info)
373 {
374 	struct i2c_adapter *adapter = client->adapter;
375 	int regval;
376 	int i;
377 
378 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
379 				     I2C_FUNC_SMBUS_WORD_DATA))
380 		return -ENODEV;
381 
382 	regval = i2c_smbus_read_byte_data(client, MAX31730_REG_MFG_ID);
383 	if (regval != MAX31730_MFG_ID)
384 		return -ENODEV;
385 	regval = i2c_smbus_read_byte_data(client, MAX31730_REG_MFG_REV);
386 	if (regval != MAX31730_MFG_REV)
387 		return -ENODEV;
388 
389 	/* lower 4 bit of temperature and limit registers must be 0 */
390 	if (max31730_check_reg_temp(client, MAX31730_REG_TEMP_MIN))
391 		return -ENODEV;
392 
393 	for (i = 0; i < 4; i++) {
394 		if (max31730_check_reg_temp(client, MAX31730_REG_TEMP + i * 2))
395 			return -ENODEV;
396 		if (max31730_check_reg_temp(client,
397 					    MAX31730_REG_TEMP_MAX + i * 2))
398 			return -ENODEV;
399 	}
400 
401 	strscpy(info->type, "max31730", I2C_NAME_SIZE);
402 
403 	return 0;
404 }
405 
max31730_suspend(struct device * dev)406 static int max31730_suspend(struct device *dev)
407 {
408 	struct max31730_data *data = dev_get_drvdata(dev);
409 
410 	return max31730_write_config(data, MAX31730_STOP, 0);
411 }
412 
max31730_resume(struct device * dev)413 static int max31730_resume(struct device *dev)
414 {
415 	struct max31730_data *data = dev_get_drvdata(dev);
416 
417 	return max31730_write_config(data, 0, MAX31730_STOP);
418 }
419 
420 static DEFINE_SIMPLE_DEV_PM_OPS(max31730_pm_ops, max31730_suspend, max31730_resume);
421 
422 static struct i2c_driver max31730_driver = {
423 	.class		= I2C_CLASS_HWMON,
424 	.driver = {
425 		.name	= "max31730",
426 		.of_match_table = of_match_ptr(max31730_of_match),
427 		.pm	= pm_sleep_ptr(&max31730_pm_ops),
428 	},
429 	.probe		= max31730_probe,
430 	.id_table	= max31730_ids,
431 	.detect		= max31730_detect,
432 	.address_list	= normal_i2c,
433 };
434 
435 module_i2c_driver(max31730_driver);
436 
437 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
438 MODULE_DESCRIPTION("MAX31730 driver");
439 MODULE_LICENSE("GPL");
440