xref: /openbmc/linux/drivers/hwmon/thmc50.c (revision 1975d167)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * thmc50.c - Part of lm_sensors, Linux kernel modules for hardware
4  *	      monitoring
5  * Copyright (C) 2007 Krzysztof Helt <krzysztof.h1@wp.pl>
6  * Based on 2.4 driver by Frodo Looijaard <frodol@dds.nl> and
7  * Philip Edelbrock <phil@netroedge.com>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/slab.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 #include <linux/jiffies.h>
19 
20 MODULE_LICENSE("GPL");
21 
22 /* Addresses to scan */
23 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
24 
25 /* Insmod parameters */
26 enum chips { thmc50, adm1022 };
27 
28 static unsigned short adm1022_temp3[16];
29 static unsigned int adm1022_temp3_num;
30 module_param_array(adm1022_temp3, ushort, &adm1022_temp3_num, 0);
31 MODULE_PARM_DESC(adm1022_temp3,
32 		 "List of adapter,address pairs to enable 3rd temperature (ADM1022 only)");
33 
34 /* Many THMC50 constants specified below */
35 
36 /* The THMC50 registers */
37 #define THMC50_REG_CONF				0x40
38 #define THMC50_REG_COMPANY_ID			0x3E
39 #define THMC50_REG_DIE_CODE			0x3F
40 #define THMC50_REG_ANALOG_OUT			0x19
41 /*
42  * The mirror status register cannot be used as
43  * reading it does not clear alarms.
44  */
45 #define THMC50_REG_INTR				0x41
46 
47 static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 };
48 static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C };
49 static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B };
50 static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 };
51 static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 };
52 
53 #define THMC50_REG_CONF_nFANOFF			0x20
54 #define THMC50_REG_CONF_PROGRAMMED		0x08
55 
56 /* Each client has this additional data */
57 struct thmc50_data {
58 	struct i2c_client *client;
59 	const struct attribute_group *groups[3];
60 
61 	struct mutex update_lock;
62 	enum chips type;
63 	unsigned long last_updated;	/* In jiffies */
64 	char has_temp3;		/* !=0 if it is ADM1022 in temp3 mode */
65 	bool valid;		/* true if following fields are valid */
66 
67 	/* Register values */
68 	s8 temp_input[3];
69 	s8 temp_max[3];
70 	s8 temp_min[3];
71 	s8 temp_critical[3];
72 	u8 analog_out;
73 	u8 alarms;
74 };
75 
thmc50_update_device(struct device * dev)76 static struct thmc50_data *thmc50_update_device(struct device *dev)
77 {
78 	struct thmc50_data *data = dev_get_drvdata(dev);
79 	struct i2c_client *client = data->client;
80 	int timeout = HZ / 5 + (data->type == thmc50 ? HZ : 0);
81 
82 	mutex_lock(&data->update_lock);
83 
84 	if (time_after(jiffies, data->last_updated + timeout)
85 	    || !data->valid) {
86 
87 		int temps = data->has_temp3 ? 3 : 2;
88 		int i;
89 		int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
90 
91 		prog &= THMC50_REG_CONF_PROGRAMMED;
92 
93 		for (i = 0; i < temps; i++) {
94 			data->temp_input[i] = i2c_smbus_read_byte_data(client,
95 						THMC50_REG_TEMP[i]);
96 			data->temp_max[i] = i2c_smbus_read_byte_data(client,
97 						THMC50_REG_TEMP_MAX[i]);
98 			data->temp_min[i] = i2c_smbus_read_byte_data(client,
99 						THMC50_REG_TEMP_MIN[i]);
100 			data->temp_critical[i] =
101 				i2c_smbus_read_byte_data(client,
102 					prog ? THMC50_REG_TEMP_CRITICAL[i]
103 					     : THMC50_REG_TEMP_DEFAULT[i]);
104 		}
105 		data->analog_out =
106 		    i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT);
107 		data->alarms =
108 		    i2c_smbus_read_byte_data(client, THMC50_REG_INTR);
109 		data->last_updated = jiffies;
110 		data->valid = true;
111 	}
112 
113 	mutex_unlock(&data->update_lock);
114 
115 	return data;
116 }
117 
analog_out_show(struct device * dev,struct device_attribute * attr,char * buf)118 static ssize_t analog_out_show(struct device *dev,
119 			       struct device_attribute *attr, char *buf)
120 {
121 	struct thmc50_data *data = thmc50_update_device(dev);
122 	return sprintf(buf, "%d\n", data->analog_out);
123 }
124 
analog_out_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)125 static ssize_t analog_out_store(struct device *dev,
126 				struct device_attribute *attr,
127 				const char *buf, size_t count)
128 {
129 	struct thmc50_data *data = dev_get_drvdata(dev);
130 	struct i2c_client *client = data->client;
131 	int config;
132 	unsigned long tmp;
133 	int err;
134 
135 	err = kstrtoul(buf, 10, &tmp);
136 	if (err)
137 		return err;
138 
139 	mutex_lock(&data->update_lock);
140 	data->analog_out = clamp_val(tmp, 0, 255);
141 	i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT,
142 				  data->analog_out);
143 
144 	config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
145 	if (data->analog_out == 0)
146 		config &= ~THMC50_REG_CONF_nFANOFF;
147 	else
148 		config |= THMC50_REG_CONF_nFANOFF;
149 	i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config);
150 
151 	mutex_unlock(&data->update_lock);
152 	return count;
153 }
154 
155 /* There is only one PWM mode = DC */
pwm_mode_show(struct device * dev,struct device_attribute * attr,char * buf)156 static ssize_t pwm_mode_show(struct device *dev,
157 			     struct device_attribute *attr, char *buf)
158 {
159 	return sprintf(buf, "0\n");
160 }
161 
162 /* Temperatures */
temp_show(struct device * dev,struct device_attribute * attr,char * buf)163 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
164 			 char *buf)
165 {
166 	int nr = to_sensor_dev_attr(attr)->index;
167 	struct thmc50_data *data = thmc50_update_device(dev);
168 	return sprintf(buf, "%d\n", data->temp_input[nr] * 1000);
169 }
170 
temp_min_show(struct device * dev,struct device_attribute * attr,char * buf)171 static ssize_t temp_min_show(struct device *dev,
172 			     struct device_attribute *attr, char *buf)
173 {
174 	int nr = to_sensor_dev_attr(attr)->index;
175 	struct thmc50_data *data = thmc50_update_device(dev);
176 	return sprintf(buf, "%d\n", data->temp_min[nr] * 1000);
177 }
178 
temp_min_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)179 static ssize_t temp_min_store(struct device *dev,
180 			      struct device_attribute *attr, const char *buf,
181 			      size_t count)
182 {
183 	int nr = to_sensor_dev_attr(attr)->index;
184 	struct thmc50_data *data = dev_get_drvdata(dev);
185 	struct i2c_client *client = data->client;
186 	long val;
187 	int err;
188 
189 	err = kstrtol(buf, 10, &val);
190 	if (err)
191 		return err;
192 
193 	mutex_lock(&data->update_lock);
194 	data->temp_min[nr] = clamp_val(val / 1000, -128, 127);
195 	i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MIN[nr],
196 				  data->temp_min[nr]);
197 	mutex_unlock(&data->update_lock);
198 	return count;
199 }
200 
temp_max_show(struct device * dev,struct device_attribute * attr,char * buf)201 static ssize_t temp_max_show(struct device *dev,
202 			     struct device_attribute *attr, char *buf)
203 {
204 	int nr = to_sensor_dev_attr(attr)->index;
205 	struct thmc50_data *data = thmc50_update_device(dev);
206 	return sprintf(buf, "%d\n", data->temp_max[nr] * 1000);
207 }
208 
temp_max_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)209 static ssize_t temp_max_store(struct device *dev,
210 			      struct device_attribute *attr, const char *buf,
211 			      size_t count)
212 {
213 	int nr = to_sensor_dev_attr(attr)->index;
214 	struct thmc50_data *data = dev_get_drvdata(dev);
215 	struct i2c_client *client = data->client;
216 	long val;
217 	int err;
218 
219 	err = kstrtol(buf, 10, &val);
220 	if (err)
221 		return err;
222 
223 	mutex_lock(&data->update_lock);
224 	data->temp_max[nr] = clamp_val(val / 1000, -128, 127);
225 	i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MAX[nr],
226 				  data->temp_max[nr]);
227 	mutex_unlock(&data->update_lock);
228 	return count;
229 }
230 
temp_critical_show(struct device * dev,struct device_attribute * attr,char * buf)231 static ssize_t temp_critical_show(struct device *dev,
232 				  struct device_attribute *attr, char *buf)
233 {
234 	int nr = to_sensor_dev_attr(attr)->index;
235 	struct thmc50_data *data = thmc50_update_device(dev);
236 	return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000);
237 }
238 
alarm_show(struct device * dev,struct device_attribute * attr,char * buf)239 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
240 			  char *buf)
241 {
242 	int index = to_sensor_dev_attr(attr)->index;
243 	struct thmc50_data *data = thmc50_update_device(dev);
244 
245 	return sprintf(buf, "%u\n", (data->alarms >> index) & 1);
246 }
247 
248 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
249 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
250 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
251 static SENSOR_DEVICE_ATTR_RO(temp1_crit, temp_critical, 0);
252 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
253 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
254 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
255 static SENSOR_DEVICE_ATTR_RO(temp2_crit, temp_critical, 1);
256 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
257 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
258 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
259 static SENSOR_DEVICE_ATTR_RO(temp3_crit, temp_critical, 2);
260 
261 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0);
262 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);
263 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1);
264 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 7);
265 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 2);
266 
267 static SENSOR_DEVICE_ATTR_RW(pwm1, analog_out, 0);
268 static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0);
269 
270 static struct attribute *thmc50_attributes[] = {
271 	&sensor_dev_attr_temp1_max.dev_attr.attr,
272 	&sensor_dev_attr_temp1_min.dev_attr.attr,
273 	&sensor_dev_attr_temp1_input.dev_attr.attr,
274 	&sensor_dev_attr_temp1_crit.dev_attr.attr,
275 	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
276 	&sensor_dev_attr_temp2_max.dev_attr.attr,
277 	&sensor_dev_attr_temp2_min.dev_attr.attr,
278 	&sensor_dev_attr_temp2_input.dev_attr.attr,
279 	&sensor_dev_attr_temp2_crit.dev_attr.attr,
280 	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
281 	&sensor_dev_attr_temp2_fault.dev_attr.attr,
282 	&sensor_dev_attr_pwm1.dev_attr.attr,
283 	&sensor_dev_attr_pwm1_mode.dev_attr.attr,
284 	NULL
285 };
286 
287 static const struct attribute_group thmc50_group = {
288 	.attrs = thmc50_attributes,
289 };
290 
291 /* for ADM1022 3rd temperature mode */
292 static struct attribute *temp3_attributes[] = {
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 	&sensor_dev_attr_temp3_crit.dev_attr.attr,
297 	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
298 	&sensor_dev_attr_temp3_fault.dev_attr.attr,
299 	NULL
300 };
301 
302 static const struct attribute_group temp3_group = {
303 	.attrs = temp3_attributes,
304 };
305 
306 /* Return 0 if detection is successful, -ENODEV otherwise */
thmc50_detect(struct i2c_client * client,struct i2c_board_info * info)307 static int thmc50_detect(struct i2c_client *client,
308 			 struct i2c_board_info *info)
309 {
310 	unsigned company;
311 	unsigned revision;
312 	unsigned config;
313 	struct i2c_adapter *adapter = client->adapter;
314 	const char *type_name;
315 
316 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
317 		pr_debug("thmc50: detect failed, smbus byte data not supported!\n");
318 		return -ENODEV;
319 	}
320 
321 	pr_debug("thmc50: Probing for THMC50 at 0x%2X on bus %d\n",
322 		 client->addr, i2c_adapter_id(client->adapter));
323 
324 	company = i2c_smbus_read_byte_data(client, THMC50_REG_COMPANY_ID);
325 	revision = i2c_smbus_read_byte_data(client, THMC50_REG_DIE_CODE);
326 	config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
327 	if (revision < 0xc0 || (config & 0x10))
328 		return -ENODEV;
329 
330 	if (company == 0x41) {
331 		int id = i2c_adapter_id(client->adapter);
332 		int i;
333 
334 		type_name = "adm1022";
335 		for (i = 0; i + 1 < adm1022_temp3_num; i += 2)
336 			if (adm1022_temp3[i] == id &&
337 			    adm1022_temp3[i + 1] == client->addr) {
338 				/* enable 2nd remote temp */
339 				config |= (1 << 7);
340 				i2c_smbus_write_byte_data(client,
341 							  THMC50_REG_CONF,
342 							  config);
343 				break;
344 			}
345 	} else if (company == 0x49) {
346 		type_name = "thmc50";
347 	} else {
348 		pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n");
349 		return -ENODEV;
350 	}
351 
352 	pr_debug("thmc50: Detected %s (version %x, revision %x)\n",
353 		 type_name, (revision >> 4) - 0xc, revision & 0xf);
354 
355 	strscpy(info->type, type_name, I2C_NAME_SIZE);
356 
357 	return 0;
358 }
359 
thmc50_init_client(struct thmc50_data * data)360 static void thmc50_init_client(struct thmc50_data *data)
361 {
362 	struct i2c_client *client = data->client;
363 	int config;
364 
365 	data->analog_out = i2c_smbus_read_byte_data(client,
366 						    THMC50_REG_ANALOG_OUT);
367 	/* set up to at least 1 */
368 	if (data->analog_out == 0) {
369 		data->analog_out = 1;
370 		i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT,
371 					  data->analog_out);
372 	}
373 	config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
374 	config |= 0x1;	/* start the chip if it is in standby mode */
375 	if (data->type == adm1022 && (config & (1 << 7)))
376 		data->has_temp3 = 1;
377 	i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config);
378 }
379 
380 static const struct i2c_device_id thmc50_id[];
381 
thmc50_probe(struct i2c_client * client)382 static int thmc50_probe(struct i2c_client *client)
383 {
384 	struct device *dev = &client->dev;
385 	struct thmc50_data *data;
386 	struct device *hwmon_dev;
387 	int idx = 0;
388 
389 	data = devm_kzalloc(dev, sizeof(struct thmc50_data), GFP_KERNEL);
390 	if (!data)
391 		return -ENOMEM;
392 
393 	data->client = client;
394 	data->type = i2c_match_id(thmc50_id, client)->driver_data;
395 	mutex_init(&data->update_lock);
396 
397 	thmc50_init_client(data);
398 
399 	/* sysfs hooks */
400 	data->groups[idx++] = &thmc50_group;
401 
402 	/* Register additional ADM1022 sysfs hooks */
403 	if (data->has_temp3)
404 		data->groups[idx++] = &temp3_group;
405 
406 	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
407 							   data, data->groups);
408 	return PTR_ERR_OR_ZERO(hwmon_dev);
409 }
410 
411 static const struct i2c_device_id thmc50_id[] = {
412 	{ "adm1022", adm1022 },
413 	{ "thmc50", thmc50 },
414 	{ }
415 };
416 MODULE_DEVICE_TABLE(i2c, thmc50_id);
417 
418 static struct i2c_driver thmc50_driver = {
419 	.class = I2C_CLASS_HWMON,
420 	.driver = {
421 		.name = "thmc50",
422 	},
423 	.probe = thmc50_probe,
424 	.id_table = thmc50_id,
425 	.detect = thmc50_detect,
426 	.address_list = normal_i2c,
427 };
428 
429 module_i2c_driver(thmc50_driver);
430 
431 MODULE_AUTHOR("Krzysztof Helt <krzysztof.h1@wp.pl>");
432 MODULE_DESCRIPTION("THMC50 driver");
433