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