xref: /openbmc/linux/drivers/hwmon/tc654.c (revision 1975d167)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * tc654.c - Linux kernel modules for fan speed controller
4  *
5  * Copyright (C) 2016 Allied Telesis Labs NZ
6  */
7 
8 #include <linux/bitops.h>
9 #include <linux/err.h>
10 #include <linux/hwmon.h>
11 #include <linux/hwmon-sysfs.h>
12 #include <linux/i2c.h>
13 #include <linux/init.h>
14 #include <linux/jiffies.h>
15 #include <linux/module.h>
16 #include <linux/mutex.h>
17 #include <linux/slab.h>
18 #include <linux/thermal.h>
19 #include <linux/util_macros.h>
20 
21 enum tc654_regs {
22 	TC654_REG_RPM1 = 0x00,	/* RPM Output 1 */
23 	TC654_REG_RPM2 = 0x01,	/* RPM Output 2 */
24 	TC654_REG_FAN_FAULT1 = 0x02,	/* Fan Fault 1 Threshold */
25 	TC654_REG_FAN_FAULT2 = 0x03,	/* Fan Fault 2 Threshold */
26 	TC654_REG_CONFIG = 0x04,	/* Configuration */
27 	TC654_REG_STATUS = 0x05,	/* Status */
28 	TC654_REG_DUTY_CYCLE = 0x06,	/* Fan Speed Duty Cycle */
29 	TC654_REG_MFR_ID = 0x07,	/* Manufacturer Identification */
30 	TC654_REG_VER_ID = 0x08,	/* Version Identification */
31 };
32 
33 /* Macros to easily index the registers */
34 #define TC654_REG_RPM(idx)		(TC654_REG_RPM1 + (idx))
35 #define TC654_REG_FAN_FAULT(idx)	(TC654_REG_FAN_FAULT1 + (idx))
36 
37 /* Config register bits */
38 #define TC654_REG_CONFIG_RES		BIT(6)	/* Resolution Selection */
39 #define TC654_REG_CONFIG_DUTYC		BIT(5)	/* Duty Cycle Control */
40 #define TC654_REG_CONFIG_SDM		BIT(0)	/* Shutdown Mode */
41 
42 /* Status register bits */
43 #define TC654_REG_STATUS_F2F		BIT(1)	/* Fan 2 Fault */
44 #define TC654_REG_STATUS_F1F		BIT(0)	/* Fan 1 Fault */
45 
46 /* RPM resolution for RPM Output registers */
47 #define TC654_HIGH_RPM_RESOLUTION	25	/* 25 RPM resolution */
48 #define TC654_LOW_RPM_RESOLUTION	50	/* 50 RPM resolution */
49 
50 /* Convert to the fan fault RPM threshold from register value */
51 #define TC654_FAN_FAULT_FROM_REG(val)	((val) * 50)	/* 50 RPM resolution */
52 
53 /* Convert to register value from the fan fault RPM threshold */
54 #define TC654_FAN_FAULT_TO_REG(val)	(((val) / 50) & 0xff)
55 
56 /* Register data is read (and cached) at most once per second. */
57 #define TC654_UPDATE_INTERVAL		HZ
58 
59 struct tc654_data {
60 	struct i2c_client *client;
61 
62 	/* update mutex */
63 	struct mutex update_lock;
64 
65 	/* tc654 register cache */
66 	bool valid;
67 	unsigned long last_updated;	/* in jiffies */
68 
69 	u8 rpm_output[2];	/* The fan RPM data for fans 1 and 2 is then
70 				 * written to registers RPM1 and RPM2
71 				 */
72 	u8 fan_fault[2];	/* The Fan Fault Threshold Registers are used to
73 				 * set the fan fault threshold levels for fan 1
74 				 * and fan 2
75 				 */
76 	u8 config;	/* The Configuration Register is an 8-bit read/
77 			 * writable multi-function control register
78 			 *   7: Fan Fault Clear
79 			 *      1 = Clear Fan Fault
80 			 *      0 = Normal Operation (default)
81 			 *   6: Resolution Selection for RPM Output Registers
82 			 *      RPM Output Registers (RPM1 and RPM2) will be
83 			 *      set for
84 			 *      1 = 25 RPM (9-bit) resolution
85 			 *      0 = 50 RPM (8-bit) resolution (default)
86 			 *   5: Duty Cycle Control Method
87 			 *      The V OUT duty cycle will be controlled via
88 			 *      1 = the SMBus interface.
89 			 *      0 = via the V IN analog input pin. (default)
90 			 * 4,3: Fan 2 Pulses Per Rotation
91 			 *      00 = 1
92 			 *      01 = 2 (default)
93 			 *      10 = 4
94 			 *      11 = 8
95 			 * 2,1: Fan 1 Pulses Per Rotation
96 			 *      00 = 1
97 			 *      01 = 2 (default)
98 			 *      10 = 4
99 			 *      11 = 8
100 			 *   0: Shutdown Mode
101 			 *      1 = Shutdown mode.
102 			 *      0 = Normal operation. (default)
103 			 */
104 	u8 status;	/* The Status register provides all the information
105 			 * about what is going on within the TC654/TC655
106 			 * devices.
107 			 * 7,6: Unimplemented, Read as '0'
108 			 *   5: Over-Temperature Fault Condition
109 			 *      1 = Over-Temperature condition has occurred
110 			 *      0 = Normal operation. V IN is less than 2.6V
111 			 *   4: RPM2 Counter Overflow
112 			 *      1 = Fault condition
113 			 *      0 = Normal operation
114 			 *   3: RPM1 Counter Overflow
115 			 *      1 = Fault condition
116 			 *      0 = Normal operation
117 			 *   2: V IN Input Status
118 			 *      1 = V IN is open
119 			 *      0 = Normal operation. voltage present at V IN
120 			 *   1: Fan 2 Fault
121 			 *      1 = Fault condition
122 			 *      0 = Normal operation
123 			 *   0: Fan 1 Fault
124 			 *      1 = Fault condition
125 			 *      0 = Normal operation
126 			 */
127 	u8 duty_cycle;	/* The DUTY_CYCLE register is a 4-bit read/
128 			 * writable register used to control the duty
129 			 * cycle of the V OUT output.
130 			 */
131 };
132 
133 /* helper to grab and cache data, at most one time per second */
tc654_update_client(struct device * dev)134 static struct tc654_data *tc654_update_client(struct device *dev)
135 {
136 	struct tc654_data *data = dev_get_drvdata(dev);
137 	struct i2c_client *client = data->client;
138 	int ret = 0;
139 
140 	mutex_lock(&data->update_lock);
141 	if (time_before(jiffies, data->last_updated + TC654_UPDATE_INTERVAL) &&
142 	    likely(data->valid))
143 		goto out;
144 
145 	ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(0));
146 	if (ret < 0)
147 		goto out;
148 	data->rpm_output[0] = ret;
149 
150 	ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(1));
151 	if (ret < 0)
152 		goto out;
153 	data->rpm_output[1] = ret;
154 
155 	ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(0));
156 	if (ret < 0)
157 		goto out;
158 	data->fan_fault[0] = ret;
159 
160 	ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(1));
161 	if (ret < 0)
162 		goto out;
163 	data->fan_fault[1] = ret;
164 
165 	ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
166 	if (ret < 0)
167 		goto out;
168 	data->config = ret;
169 
170 	ret = i2c_smbus_read_byte_data(client, TC654_REG_STATUS);
171 	if (ret < 0)
172 		goto out;
173 	data->status = ret;
174 
175 	ret = i2c_smbus_read_byte_data(client, TC654_REG_DUTY_CYCLE);
176 	if (ret < 0)
177 		goto out;
178 	data->duty_cycle = ret & 0x0f;
179 
180 	data->last_updated = jiffies;
181 	data->valid = true;
182 out:
183 	mutex_unlock(&data->update_lock);
184 
185 	if (ret < 0)		/* upon error, encode it in return value */
186 		data = ERR_PTR(ret);
187 
188 	return data;
189 }
190 
191 /*
192  * sysfs attributes
193  */
194 
fan_show(struct device * dev,struct device_attribute * da,char * buf)195 static ssize_t fan_show(struct device *dev, struct device_attribute *da,
196 			char *buf)
197 {
198 	int nr = to_sensor_dev_attr(da)->index;
199 	struct tc654_data *data = tc654_update_client(dev);
200 	int val;
201 
202 	if (IS_ERR(data))
203 		return PTR_ERR(data);
204 
205 	if (data->config & TC654_REG_CONFIG_RES)
206 		val = data->rpm_output[nr] * TC654_HIGH_RPM_RESOLUTION;
207 	else
208 		val = data->rpm_output[nr] * TC654_LOW_RPM_RESOLUTION;
209 
210 	return sprintf(buf, "%d\n", val);
211 }
212 
fan_min_show(struct device * dev,struct device_attribute * da,char * buf)213 static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,
214 			    char *buf)
215 {
216 	int nr = to_sensor_dev_attr(da)->index;
217 	struct tc654_data *data = tc654_update_client(dev);
218 
219 	if (IS_ERR(data))
220 		return PTR_ERR(data);
221 
222 	return sprintf(buf, "%d\n",
223 		       TC654_FAN_FAULT_FROM_REG(data->fan_fault[nr]));
224 }
225 
fan_min_store(struct device * dev,struct device_attribute * da,const char * buf,size_t count)226 static ssize_t fan_min_store(struct device *dev, struct device_attribute *da,
227 			     const char *buf, size_t count)
228 {
229 	int nr = to_sensor_dev_attr(da)->index;
230 	struct tc654_data *data = dev_get_drvdata(dev);
231 	struct i2c_client *client = data->client;
232 	unsigned long val;
233 	int ret;
234 
235 	if (kstrtoul(buf, 10, &val))
236 		return -EINVAL;
237 
238 	val = clamp_val(val, 0, 12750);
239 
240 	mutex_lock(&data->update_lock);
241 
242 	data->fan_fault[nr] = TC654_FAN_FAULT_TO_REG(val);
243 	ret = i2c_smbus_write_byte_data(client, TC654_REG_FAN_FAULT(nr),
244 					data->fan_fault[nr]);
245 
246 	mutex_unlock(&data->update_lock);
247 	return ret < 0 ? ret : count;
248 }
249 
fan_alarm_show(struct device * dev,struct device_attribute * da,char * buf)250 static ssize_t fan_alarm_show(struct device *dev, struct device_attribute *da,
251 			      char *buf)
252 {
253 	int nr = to_sensor_dev_attr(da)->index;
254 	struct tc654_data *data = tc654_update_client(dev);
255 	int val;
256 
257 	if (IS_ERR(data))
258 		return PTR_ERR(data);
259 
260 	if (nr == 0)
261 		val = !!(data->status & TC654_REG_STATUS_F1F);
262 	else
263 		val = !!(data->status & TC654_REG_STATUS_F2F);
264 
265 	return sprintf(buf, "%d\n", val);
266 }
267 
268 static const u8 TC654_FAN_PULSE_SHIFT[] = { 1, 3 };
269 
fan_pulses_show(struct device * dev,struct device_attribute * da,char * buf)270 static ssize_t fan_pulses_show(struct device *dev,
271 			       struct device_attribute *da, char *buf)
272 {
273 	int nr = to_sensor_dev_attr(da)->index;
274 	struct tc654_data *data = tc654_update_client(dev);
275 	u8 val;
276 
277 	if (IS_ERR(data))
278 		return PTR_ERR(data);
279 
280 	val = BIT((data->config >> TC654_FAN_PULSE_SHIFT[nr]) & 0x03);
281 	return sprintf(buf, "%d\n", val);
282 }
283 
fan_pulses_store(struct device * dev,struct device_attribute * da,const char * buf,size_t count)284 static ssize_t fan_pulses_store(struct device *dev,
285 				struct device_attribute *da, const char *buf,
286 				size_t count)
287 {
288 	int nr = to_sensor_dev_attr(da)->index;
289 	struct tc654_data *data = dev_get_drvdata(dev);
290 	struct i2c_client *client = data->client;
291 	u8 config;
292 	unsigned long val;
293 	int ret;
294 
295 	if (kstrtoul(buf, 10, &val))
296 		return -EINVAL;
297 
298 	switch (val) {
299 	case 1:
300 		config = 0;
301 		break;
302 	case 2:
303 		config = 1;
304 		break;
305 	case 4:
306 		config = 2;
307 		break;
308 	case 8:
309 		config = 3;
310 		break;
311 	default:
312 		return -EINVAL;
313 	}
314 
315 	mutex_lock(&data->update_lock);
316 
317 	data->config &= ~(0x03 << TC654_FAN_PULSE_SHIFT[nr]);
318 	data->config |= (config << TC654_FAN_PULSE_SHIFT[nr]);
319 	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
320 
321 	mutex_unlock(&data->update_lock);
322 	return ret < 0 ? ret : count;
323 }
324 
pwm_mode_show(struct device * dev,struct device_attribute * da,char * buf)325 static ssize_t pwm_mode_show(struct device *dev, struct device_attribute *da,
326 			     char *buf)
327 {
328 	struct tc654_data *data = tc654_update_client(dev);
329 
330 	if (IS_ERR(data))
331 		return PTR_ERR(data);
332 
333 	return sprintf(buf, "%d\n", !!(data->config & TC654_REG_CONFIG_DUTYC));
334 }
335 
pwm_mode_store(struct device * dev,struct device_attribute * da,const char * buf,size_t count)336 static ssize_t pwm_mode_store(struct device *dev, struct device_attribute *da,
337 			      const char *buf, size_t count)
338 {
339 	struct tc654_data *data = dev_get_drvdata(dev);
340 	struct i2c_client *client = data->client;
341 	unsigned long val;
342 	int ret;
343 
344 	if (kstrtoul(buf, 10, &val))
345 		return -EINVAL;
346 
347 	if (val != 0 && val != 1)
348 		return -EINVAL;
349 
350 	mutex_lock(&data->update_lock);
351 
352 	if (val)
353 		data->config |= TC654_REG_CONFIG_DUTYC;
354 	else
355 		data->config &= ~TC654_REG_CONFIG_DUTYC;
356 
357 	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
358 
359 	mutex_unlock(&data->update_lock);
360 	return ret < 0 ? ret : count;
361 }
362 
363 static const int tc654_pwm_map[16] = { 77,  88, 102, 112, 124, 136, 148, 160,
364 				      172, 184, 196, 207, 219, 231, 243, 255};
365 
pwm_show(struct device * dev,struct device_attribute * da,char * buf)366 static ssize_t pwm_show(struct device *dev, struct device_attribute *da,
367 			char *buf)
368 {
369 	struct tc654_data *data = tc654_update_client(dev);
370 	int pwm;
371 
372 	if (IS_ERR(data))
373 		return PTR_ERR(data);
374 
375 	if (data->config & TC654_REG_CONFIG_SDM)
376 		pwm = 0;
377 	else
378 		pwm = tc654_pwm_map[data->duty_cycle];
379 
380 	return sprintf(buf, "%d\n", pwm);
381 }
382 
_set_pwm(struct tc654_data * data,unsigned long val)383 static int _set_pwm(struct tc654_data *data, unsigned long val)
384 {
385 	struct i2c_client *client = data->client;
386 	int ret;
387 
388 	mutex_lock(&data->update_lock);
389 
390 	if (val == 0) {
391 		data->config |= TC654_REG_CONFIG_SDM;
392 		data->duty_cycle = 0;
393 	} else {
394 		data->config &= ~TC654_REG_CONFIG_SDM;
395 		data->duty_cycle = val - 1;
396 	}
397 
398 	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
399 	if (ret < 0)
400 		goto out;
401 
402 	ret = i2c_smbus_write_byte_data(client, TC654_REG_DUTY_CYCLE,
403 					data->duty_cycle);
404 
405 out:
406 	mutex_unlock(&data->update_lock);
407 	return ret;
408 }
409 
pwm_store(struct device * dev,struct device_attribute * da,const char * buf,size_t count)410 static ssize_t pwm_store(struct device *dev, struct device_attribute *da,
411 			 const char *buf, size_t count)
412 {
413 	struct tc654_data *data = dev_get_drvdata(dev);
414 	unsigned long val;
415 	int ret;
416 
417 	if (kstrtoul(buf, 10, &val))
418 		return -EINVAL;
419 	if (val > 255)
420 		return -EINVAL;
421 	if (val > 0)
422 		val = find_closest(val, tc654_pwm_map, ARRAY_SIZE(tc654_pwm_map)) + 1;
423 
424 	ret = _set_pwm(data, val);
425 	return ret < 0 ? ret : count;
426 }
427 
428 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
429 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
430 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
431 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
432 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0);
433 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1);
434 static SENSOR_DEVICE_ATTR_RW(fan1_pulses, fan_pulses, 0);
435 static SENSOR_DEVICE_ATTR_RW(fan2_pulses, fan_pulses, 1);
436 static SENSOR_DEVICE_ATTR_RW(pwm1_mode, pwm_mode, 0);
437 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
438 
439 /* Driver data */
440 static struct attribute *tc654_attrs[] = {
441 	&sensor_dev_attr_fan1_input.dev_attr.attr,
442 	&sensor_dev_attr_fan2_input.dev_attr.attr,
443 	&sensor_dev_attr_fan1_min.dev_attr.attr,
444 	&sensor_dev_attr_fan2_min.dev_attr.attr,
445 	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
446 	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
447 	&sensor_dev_attr_fan1_pulses.dev_attr.attr,
448 	&sensor_dev_attr_fan2_pulses.dev_attr.attr,
449 	&sensor_dev_attr_pwm1_mode.dev_attr.attr,
450 	&sensor_dev_attr_pwm1.dev_attr.attr,
451 	NULL
452 };
453 
454 ATTRIBUTE_GROUPS(tc654);
455 
456 /*
457  * thermal cooling device functions
458  *
459  * Account for the "ShutDown Mode (SDM)" state by offsetting
460  * the 16 PWM duty cycle states by 1.
461  *
462  * State  0 =   0% PWM | Shutdown - Fan(s) are off
463  * State  1 =  30% PWM | duty_cycle =  0
464  * State  2 = ~35% PWM | duty_cycle =  1
465  * [...]
466  * State 15 = ~95% PWM | duty_cycle = 14
467  * State 16 = 100% PWM | duty_cycle = 15
468  */
469 #define TC654_MAX_COOLING_STATE	16
470 
tc654_get_max_state(struct thermal_cooling_device * cdev,unsigned long * state)471 static int tc654_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state)
472 {
473 	*state = TC654_MAX_COOLING_STATE;
474 	return 0;
475 }
476 
tc654_get_cur_state(struct thermal_cooling_device * cdev,unsigned long * state)477 static int tc654_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state)
478 {
479 	struct tc654_data *data = tc654_update_client(cdev->devdata);
480 
481 	if (IS_ERR(data))
482 		return PTR_ERR(data);
483 
484 	if (data->config & TC654_REG_CONFIG_SDM)
485 		*state = 0;	/* FAN is off */
486 	else
487 		*state = data->duty_cycle + 1;	/* offset PWM States by 1 */
488 
489 	return 0;
490 }
491 
tc654_set_cur_state(struct thermal_cooling_device * cdev,unsigned long state)492 static int tc654_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
493 {
494 	struct tc654_data *data = tc654_update_client(cdev->devdata);
495 
496 	if (IS_ERR(data))
497 		return PTR_ERR(data);
498 
499 	return _set_pwm(data, clamp_val(state, 0, TC654_MAX_COOLING_STATE));
500 }
501 
502 static const struct thermal_cooling_device_ops tc654_fan_cool_ops = {
503 	.get_max_state = tc654_get_max_state,
504 	.get_cur_state = tc654_get_cur_state,
505 	.set_cur_state = tc654_set_cur_state,
506 };
507 
508 /*
509  * device probe and removal
510  */
511 
tc654_probe(struct i2c_client * client)512 static int tc654_probe(struct i2c_client *client)
513 {
514 	struct device *dev = &client->dev;
515 	struct tc654_data *data;
516 	struct device *hwmon_dev;
517 	int ret;
518 
519 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
520 		return -ENODEV;
521 
522 	data = devm_kzalloc(dev, sizeof(struct tc654_data), GFP_KERNEL);
523 	if (!data)
524 		return -ENOMEM;
525 
526 	data->client = client;
527 	mutex_init(&data->update_lock);
528 
529 	ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
530 	if (ret < 0)
531 		return ret;
532 
533 	data->config = ret;
534 
535 	hwmon_dev =
536 	    devm_hwmon_device_register_with_groups(dev, client->name, data,
537 						   tc654_groups);
538 	if (IS_ERR(hwmon_dev))
539 		return PTR_ERR(hwmon_dev);
540 
541 	if (IS_ENABLED(CONFIG_THERMAL)) {
542 		struct thermal_cooling_device *cdev;
543 
544 		cdev = devm_thermal_of_cooling_device_register(dev, dev->of_node, client->name,
545 							       hwmon_dev, &tc654_fan_cool_ops);
546 		return PTR_ERR_OR_ZERO(cdev);
547 	}
548 
549 	return 0;
550 }
551 
552 static const struct i2c_device_id tc654_id[] = {
553 	{"tc654", 0},
554 	{"tc655", 0},
555 	{}
556 };
557 
558 MODULE_DEVICE_TABLE(i2c, tc654_id);
559 
560 static struct i2c_driver tc654_driver = {
561 	.driver = {
562 		   .name = "tc654",
563 		   },
564 	.probe = tc654_probe,
565 	.id_table = tc654_id,
566 };
567 
568 module_i2c_driver(tc654_driver);
569 
570 MODULE_AUTHOR("Allied Telesis Labs");
571 MODULE_DESCRIPTION("Microchip TC654/TC655 driver");
572 MODULE_LICENSE("GPL");
573