mvebu: remove linux 4.4 support
[openwrt/openwrt.git] / target / linux / apm821xx / patches-4.4 / 901-hwmon-add-driver-for-Microchip-TC654-TC655-PWM-fan-c.patch
1 From 5ea2e152d846bf60901107fefd81a58f792f3bc2 Mon Sep 17 00:00:00 2001
2 From: Christian Lamparter <chunkeey@gmail.com>
3 Date: Fri, 10 Jun 2016 03:00:46 +0200
4 Subject: [PATCH] hwmon: add driver for Microchip TC654/TC655 PWM fan
5 controllers
6
7 This patch adds a hwmon driver for the Microchip TC654 and TC655
8 Dual SMBus PWM Fan Speed Controllers with Fan Fault detection.
9
10 The chip is described in the DS2001734C Spec Document from Microchip.
11 It supports:
12 - Shared PWM Fan Drive for two fans
13 - Provides RPM
14 - automatic PWM controller (needs additional
15 NTC/PTC Thermistors.)
16 - Overtemperature alarm (when using NTC/PTC
17 Thermistors)
18
19 Signed-off-by: Christian Lamparter <chunkeey@gmail.com>
20 ---
21 drivers/hwmon/Kconfig | 10 +
22 drivers/hwmon/Makefile | 1 +
23 drivers/hwmon/tc654.c | 969 +++++++++++++++++++++++++++++++++++++++++++++++++
24 3 files changed, 980 insertions(+)
25 create mode 100644 drivers/hwmon/tc654.c
26
27 --- a/drivers/hwmon/Kconfig
28 +++ b/drivers/hwmon/Kconfig
29 @@ -1484,6 +1484,16 @@ config SENSORS_INA2XX
30 This driver can also be built as a module. If so, the module
31 will be called ina2xx.
32
33 +config SENSORS_TC654
34 + tristate "Microchip TC654 and TC655"
35 + depends on I2C
36 + help
37 + If you say yes here you get support for Microchip TC655 and TC654
38 + Dual PWM Fan Speed Controllers and sensor chips.
39 +
40 + This driver can also be built as a module. If so, the module
41 + will be called tc654.
42 +
43 config SENSORS_TC74
44 tristate "Microchip TC74"
45 depends on I2C
46 --- a/drivers/hwmon/Makefile
47 +++ b/drivers/hwmon/Makefile
48 @@ -143,6 +143,7 @@ obj-$(CONFIG_SENSORS_SMSC47B397)+= smsc4
49 obj-$(CONFIG_SENSORS_SMSC47M1) += smsc47m1.o
50 obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o
51 obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o
52 +obj-$(CONFIG_SENSORS_TC654) += tc654.o
53 obj-$(CONFIG_SENSORS_TC74) += tc74.o
54 obj-$(CONFIG_SENSORS_THMC50) += thmc50.o
55 obj-$(CONFIG_SENSORS_TMP102) += tmp102.o
56 --- /dev/null
57 +++ b/drivers/hwmon/tc654.c
58 @@ -0,0 +1,969 @@
59 +/*
60 + * tc654.c - Support for Microchip TC654/TC655
61 + * "A Dual SMBus PWM FAN Speed Controllers with Fan Fault Detection"
62 + *
63 + * Copyright (c) 2016 Christian Lamparter <chunkeey@gmail.com>
64 + *
65 + * This program is free software; you can redistribute it and/or modify
66 + * it under the terms of the GNU General Public License as published by
67 + * the Free Software Foundation version 2 of the License.
68 + *
69 + * This program is distributed in the hope that it will be useful,
70 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
71 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
72 + * GNU General Public License for more details.
73 + *
74 + * The chip is described in the DS2001734C Spec Document from Microchip.
75 + */
76 +
77 +#include <linux/module.h>
78 +#include <linux/init.h>
79 +#include <linux/slab.h>
80 +#include <linux/jiffies.h>
81 +#include <linux/i2c.h>
82 +#include <linux/hwmon.h>
83 +#include <linux/hwmon-sysfs.h>
84 +#include <linux/err.h>
85 +#include <linux/mutex.h>
86 +#include <linux/thermal.h>
87 +
88 +/* Hardware definitions */
89 +/* 5.1.4 Address Byte stats that TC654/TC655 are fixed at 0x1b */
90 +static const unsigned short normal_i2c[] = { 0x1b, I2C_CLIENT_END };
91 +
92 +enum TC654_REGS {
93 + TC654_REG_RPM1 = 0x00,
94 + TC654_REG_RPM2,
95 + TC654_REG_FAN1_FAULT_THRESH,
96 + TC654_REG_FAN2_FAULT_THRESH,
97 + TC654_REG_CONFIG,
98 + TC654_REG_STATUS,
99 + TC654_REG_DUTY_CYCLE,
100 + TC654_REG_MFR_ID,
101 + TC654_REG_VER_ID,
102 +
103 + /* keep last */
104 + __TC654_REG_NUM,
105 +};
106 +
107 +#define TC654_MFR_ID_MICROCHIP 0x84
108 +#define TC654_VER_ID 0x00
109 +#define TC655_VER_ID 0x01
110 +
111 +enum TC654_CONTROL_BITS {
112 + TC654_CTRL_SDM = BIT(0),
113 + TC654_CTRL_F1PPR_S = 1,
114 + TC654_CTRL_F1PPR_M = (BIT(1) | BIT(2)),
115 + TC654_CTRL_F2PPR_S = 3,
116 + TC654_CTRL_F2PPR_M = (BIT(3) | BIT(4)),
117 + TC654_CTRL_DUTYC = BIT(5),
118 + TC654_CTRL_RES = BIT(6),
119 + TC654_CTRL_FFCLR = BIT(7),
120 +};
121 +
122 +enum TC654_STATUS_BITS {
123 + TC654_STATUS_F1F = BIT(0),
124 + TC654_STATUS_F2F = BIT(1),
125 + TC654_STATUS_VSTAT = BIT(2),
126 + TC654_STATUS_R1CO = BIT(3),
127 + TC654_STATUS_R2CO = BIT(4),
128 + TC654_STATUS_OTF = BIT(5),
129 +};
130 +
131 +enum TC654_FAN {
132 + TC654_FAN1 = 0,
133 + TC654_FAN2,
134 +
135 + /* keep last */
136 + __NUM_TC654_FAN,
137 +};
138 +
139 +enum TC654_FAN_MODE {
140 + TC654_PWM_OFF, /* Shutdown Mode - switch of both fans */
141 + TC654_PWM_VIN, /* Fans will be controlled via V_in analog input pin */
142 + TC654_PWM_3000, /* sets fans to 30% duty cycle */
143 + TC654_PWM_3467,
144 + TC654_PWM_3933, /* default case - if V_in pin is open */
145 + TC654_PWM_4400,
146 + TC654_PWM_4867,
147 + TC654_PWM_5333,
148 + TC654_PWM_5800,
149 + TC654_PWM_6267,
150 + TC654_PWM_6733,
151 + TC654_PWM_7200,
152 + TC654_PWM_7667,
153 + TC654_PWM_8133,
154 + TC654_PWM_8600,
155 + TC654_PWM_9067,
156 + TC654_PWM_9533,
157 + TC654_PWM_10000, /* sets fans to 100% duty cycle */
158 +};
159 +
160 +enum TC654_ALARMS {
161 + TC654_ALARM_FAN1_FAULT,
162 + TC654_ALARM_FAN2_FAULT,
163 + TC654_ALARM_FAN1_COUNTER_OVERFLOW,
164 + TC654_ALARM_FAN2_COUNTER_OVERFLOW,
165 + TC654_ALARM_OVER_TEMPERATURE,
166 +
167 + /* KEEP LAST */
168 + __NUM_TC654_ALARMS,
169 +};
170 +
171 +static const struct pwm_table_entry {
172 + u8 min;
173 + enum TC654_FAN_MODE mode;
174 +} pwm_table[] = {
175 + { 0, TC654_PWM_OFF },
176 + { 1, TC654_PWM_3000 },
177 + { 88, TC654_PWM_3467 },
178 + {101, TC654_PWM_3933 },
179 + {113, TC654_PWM_4400 },
180 + {125, TC654_PWM_4867 },
181 + {137, TC654_PWM_5333 },
182 + {148, TC654_PWM_5800 },
183 + {160, TC654_PWM_6267 },
184 + {172, TC654_PWM_6733 },
185 + {184, TC654_PWM_7200 },
186 + {196, TC654_PWM_7667 },
187 + {208, TC654_PWM_8133 },
188 + {220, TC654_PWM_8600 },
189 + {232, TC654_PWM_9067 },
190 + {244, TC654_PWM_9533 },
191 + {255, TC654_PWM_10000 },
192 +};
193 +
194 +/* driver context */
195 +struct tc654 {
196 + struct i2c_client *client;
197 +
198 + struct mutex update_lock;
199 +
200 + unsigned long last_updated; /* in jiffies */
201 + u8 cached_regs[__TC654_REG_NUM];
202 +
203 + bool valid; /* monitored registers are valid */
204 + u16 fan_input[__NUM_TC654_FAN];
205 + bool alarms[__NUM_TC654_ALARMS];
206 + bool vin_status;
207 + bool pwm_manual;
208 +
209 + /* optional cooling device */
210 + struct thermal_cooling_device *cdev;
211 +};
212 +
213 +/* hardware accessors and functions */
214 +static int read_tc(struct tc654 *tc, u8 reg)
215 +{
216 + s32 status;
217 +
218 + if (reg <= TC654_REG_VER_ID) {
219 + /* Table 6.1 states that all registers are readable */
220 + status = i2c_smbus_read_byte_data(tc->client, reg);
221 + } else
222 + status = -EINVAL;
223 +
224 + if (status < 0) {
225 + dev_warn(&tc->client->dev, "can't read register 0x%02x due to error (%d)",
226 + reg, status);
227 + } else {
228 + tc->cached_regs[reg] = status;
229 + }
230 +
231 + return status;
232 +}
233 +
234 +static int write_tc(struct tc654 *tc, u8 i2c_reg, u8 val)
235 +{
236 + s32 status;
237 +
238 + /*
239 + * Table 6.1 states that both fan threshold registers,
240 + * the Config and Duty Cycle are writeable.
241 + */
242 + switch (i2c_reg) {
243 + case TC654_REG_FAN1_FAULT_THRESH:
244 + case TC654_REG_FAN2_FAULT_THRESH:
245 + case TC654_REG_DUTY_CYCLE:
246 + case TC654_REG_CONFIG:
247 + status = i2c_smbus_write_byte_data(tc->client, i2c_reg, val);
248 + break;
249 +
250 + default:
251 + return -EINVAL;
252 + }
253 +
254 + if (status < 0) {
255 + dev_warn(&tc->client->dev, "can't write register 0x%02x with value 0x%02x due to error (%d)",
256 + i2c_reg, val, status);
257 + } else {
258 + tc->cached_regs[i2c_reg] = val;
259 + }
260 +
261 + return status;
262 +}
263 +
264 +static int mod_config(struct tc654 *tc, u8 set, u8 clear)
265 +{
266 + u8 val = 0;
267 +
268 + /* a bit can't be set and cleared on the same time. */
269 + if (set & clear)
270 + return -EINVAL;
271 +
272 + /* invalidate data to force re-read from hardware */
273 + tc->valid = false;
274 + val = (tc->cached_regs[TC654_REG_CONFIG] | set) & (~clear);
275 + return write_tc(tc, TC654_REG_CONFIG, val);
276 +}
277 +
278 +static int read_fan_rpm(struct tc654 *tc, enum TC654_FAN fan)
279 +{
280 + int ret;
281 +
282 + /* 6.1 RPM-OUTPUT1 and RPM-OUTPUT2 registers */
283 + ret = read_tc(tc, fan == TC654_FAN1 ? TC654_REG_RPM1 : TC654_REG_RPM2);
284 + if (ret < 0)
285 + return ret;
286 +
287 + /*
288 + * The Resolution Selection Bit in 6.3 CONFIGURATION REGISTER
289 + * is needed to convert the raw value to the RPM.
290 + * 0 = RPM1 and RPM2 use (8-Bit) resolution => * 50 RPM
291 + * 1 = RPM1 and RPM2 use (9-Bit) resolution => * 25 RPM
292 + */
293 + return ret * (25 <<
294 + !(tc->cached_regs[TC654_REG_CONFIG] & TC654_CTRL_RES));
295 +}
296 +
297 +static int write_fan_fault_thresh(struct tc654 *tc, enum TC654_FAN fan,
298 + u16 rpm)
299 +{
300 + u8 converted_rpm;
301 +
302 + if (rpm > 12750)
303 + return -EINVAL;
304 +
305 + /*
306 + * 6.2 FAN_FAULT1 and FAN_FAULT2 Threshold registers
307 + *
308 + * Both registers operate in 50 RPM mode exclusively.
309 + */
310 + converted_rpm = rpm / 50;
311 +
312 + /* invalidate data to force re-read from hardware */
313 + tc->valid = false;
314 + return write_tc(tc, fan == TC654_FAN1 ? TC654_REG_FAN1_FAULT_THRESH :
315 + TC654_REG_FAN2_FAULT_THRESH, converted_rpm);
316 +}
317 +
318 +
319 +static int read_fan_fault_thresh(struct tc654 *tc, enum TC654_FAN fan)
320 +{
321 + /*
322 + * 6.2 FAN_FAULT1 and FAN_FAULT2 Threshold registers
323 + *
324 + * Both registers operate in 50 RPM mode exclusively.
325 + */
326 + return read_tc(tc, fan == TC654_FAN1 ? TC654_REG_FAN1_FAULT_THRESH :
327 + TC654_REG_FAN2_FAULT_THRESH) * 50;
328 +}
329 +
330 +static enum TC654_FAN_MODE get_fan_mode(struct tc654 *tc)
331 +{
332 + if (tc->cached_regs[TC654_REG_CONFIG] & TC654_CTRL_SDM) {
333 + return TC654_PWM_OFF;
334 + } else if (tc->cached_regs[TC654_REG_CONFIG] & TC654_CTRL_DUTYC) {
335 + return TC654_PWM_3000 + tc->cached_regs[TC654_REG_DUTY_CYCLE];
336 + } else if (tc->vin_status == 0)
337 + return TC654_PWM_VIN;
338 +
339 + return -EINVAL;
340 +}
341 +
342 +static int write_fan_mode(struct tc654 *tc, enum TC654_FAN_MODE mode)
343 +{
344 + int err;
345 + u8 pwm_mode;
346 + bool in_sdm;
347 +
348 + in_sdm = !!(tc->cached_regs[TC654_REG_CONFIG] &
349 + TC654_CTRL_SDM);
350 +
351 + switch (mode) {
352 + case TC654_PWM_OFF:
353 + if (in_sdm)
354 + return 0;
355 +
356 + /* Enter Shutdown Mode - Switches off all fans */
357 + err = mod_config(tc, TC654_CTRL_SDM, TC654_CTRL_DUTYC);
358 + if (err)
359 + return err;
360 +
361 + return 0;
362 +
363 + case TC654_PWM_VIN:
364 + if (tc->vin_status) {
365 + dev_err(&tc->client->dev,
366 + "V_in pin is open, can't enable automatic mode.");
367 + return -EINVAL;
368 + }
369 +
370 + err = mod_config(tc, 0, TC654_CTRL_SDM | TC654_CTRL_DUTYC);
371 + if (err)
372 + return err;
373 +
374 + tc->pwm_manual = false;
375 + return 0;
376 +
377 + case TC654_PWM_3000:
378 + case TC654_PWM_3467:
379 + case TC654_PWM_3933:
380 + case TC654_PWM_4400:
381 + case TC654_PWM_4867:
382 + case TC654_PWM_5333:
383 + case TC654_PWM_5800:
384 + case TC654_PWM_6267:
385 + case TC654_PWM_6733:
386 + case TC654_PWM_7200:
387 + case TC654_PWM_7667:
388 + case TC654_PWM_8133:
389 + case TC654_PWM_8600:
390 + case TC654_PWM_9067:
391 + case TC654_PWM_9533:
392 + case TC654_PWM_10000:
393 + pwm_mode = mode - TC654_PWM_3000;
394 + if (!in_sdm) {
395 + err = write_tc(tc, TC654_REG_DUTY_CYCLE, pwm_mode);
396 + if (err)
397 + return err;
398 + }
399 +
400 + err = mod_config(tc, TC654_CTRL_DUTYC, TC654_CTRL_SDM);
401 + if (err)
402 + return err;
403 +
404 + tc->pwm_manual = true;
405 +
406 + if (in_sdm) {
407 + /*
408 + * In case the TC654/TC655 was in SDM mode, the write
409 + * above into the TC654_REG_DUTY_CYCLE register will
410 + * have no effect because the chip was switched off.
411 + *
412 + * Note: The TC654/TC655 have a special "power-on"
413 + * feature where the PWM will be forced to 100% for
414 + * one full second in order to spin-up a resting fan.
415 + */
416 + err = write_tc(tc, TC654_REG_DUTY_CYCLE, pwm_mode);
417 + if (err)
418 + return err;
419 + }
420 +
421 + return 0;
422 +
423 + default:
424 + return -EINVAL;
425 + }
426 +}
427 +
428 +static struct tc654 *tc654_update_device(struct device *dev)
429 +{
430 + struct tc654 *tc = dev_get_drvdata(dev);
431 +
432 + mutex_lock(&tc->update_lock);
433 +
434 + /*
435 + * In Chapter "1.0 Electrical Characteristics",
436 + * the "Fault Output Response Time" is specified as 2.4 seconds.
437 + */
438 + if (time_after(jiffies, tc->last_updated + 2 * HZ + (HZ * 2) / 5)
439 + || !tc->valid) {
440 + size_t i;
441 + int ret;
442 + bool alarm_triggered;
443 +
444 + tc->valid = false;
445 +
446 + for (i = 0; i < __NUM_TC654_FAN; i++) {
447 + ret = read_fan_rpm(tc, i);
448 + if (ret < 0)
449 + goto out;
450 +
451 + tc->fan_input[i] = ret;
452 + }
453 +
454 + ret = read_tc(tc, TC654_REG_STATUS);
455 + if (ret < 0)
456 + goto out;
457 +
458 + alarm_triggered = !!(ret & (TC654_STATUS_F1F |
459 + TC654_STATUS_F2F | TC654_STATUS_R1CO |
460 + TC654_STATUS_R2CO | TC654_STATUS_OTF));
461 +
462 + tc->alarms[TC654_ALARM_FAN1_FAULT] = !!(ret & TC654_STATUS_F1F);
463 + tc->alarms[TC654_ALARM_FAN2_FAULT] = !!(ret & TC654_STATUS_F2F);
464 + tc->alarms[TC654_ALARM_FAN1_COUNTER_OVERFLOW] =
465 + !!(ret & TC654_STATUS_R1CO);
466 + tc->alarms[TC654_ALARM_FAN2_COUNTER_OVERFLOW] =
467 + !!(ret & TC654_STATUS_R2CO);
468 + tc->alarms[TC654_ALARM_OVER_TEMPERATURE] =
469 + !!(ret & TC654_STATUS_OTF);
470 + tc->vin_status = !!(ret & TC654_STATUS_VSTAT);
471 +
472 + /*
473 + * From 4.5 and 6.3
474 + *
475 + * ... "If the V_in pin is open when TC654_CTRL_DUTYC is not
476 + * selected, then V_out duty cycle will default to 39.33%.".
477 + *
478 + * and most importantly 6.5:
479 + * ... "V_in pin is open, the duty cycle will go to the default
480 + * setting of this register, which is 0010 (39.33%)."
481 + */
482 + tc->pwm_manual |= tc->vin_status &&
483 + (tc->cached_regs[TC654_REG_CONFIG] &
484 + TC654_CTRL_DUTYC);
485 +
486 + if (alarm_triggered) {
487 + /*
488 + * as the name implies, this FLAG needs to be
489 + * set in order to clear the FAN Fault error.
490 + */
491 + ret = mod_config(tc, TC654_CTRL_FFCLR, 0);
492 + if (ret < 0)
493 + goto out;
494 + }
495 +
496 + tc->last_updated = jiffies;
497 + tc->valid = true;
498 + }
499 +
500 +out:
501 + mutex_unlock(&tc->update_lock);
502 + return tc;
503 +}
504 +
505 +static u8 get_fan_pulse(struct tc654 *tc, enum TC654_FAN fan)
506 +{
507 + u8 fan_pulse_mask = fan == TC654_FAN1 ?
508 + TC654_CTRL_F1PPR_M : TC654_CTRL_F2PPR_M;
509 + u8 fan_pulse_shift = fan == TC654_FAN1 ?
510 + TC654_CTRL_F1PPR_S : TC654_CTRL_F2PPR_S;
511 +
512 + return 1 << ((tc->cached_regs[TC654_REG_CONFIG] & fan_pulse_mask) >>
513 + fan_pulse_shift);
514 +}
515 +
516 +static int
517 +set_fan_pulse(struct tc654 *tc, enum TC654_FAN fan, int pulses)
518 +{
519 + int old_pulses;
520 + int err;
521 + u8 new_pulse_per_rotation;
522 + u8 fan_pulse_mask = fan == TC654_FAN1 ?
523 + TC654_CTRL_F1PPR_M : TC654_CTRL_F2PPR_M;
524 + u8 fan_pulse_shift = fan == TC654_FAN1 ?
525 + TC654_CTRL_F1PPR_S : TC654_CTRL_F2PPR_S;
526 +
527 + switch (pulses) {
528 + case 1:
529 + new_pulse_per_rotation = 0;
530 + break;
531 + case 2:
532 + new_pulse_per_rotation = 1;
533 + break;
534 + case 4:
535 + new_pulse_per_rotation = 2;
536 + break;
537 + case 8:
538 + new_pulse_per_rotation = 3;
539 + break;
540 + default:
541 + return -EINVAL;
542 + }
543 +
544 + new_pulse_per_rotation <<= fan_pulse_shift;
545 + new_pulse_per_rotation &= fan_pulse_mask;
546 +
547 + old_pulses = tc->cached_regs[TC654_REG_CONFIG];
548 + old_pulses &= fan_pulse_mask;
549 +
550 + if (new_pulse_per_rotation == old_pulses)
551 + return 0;
552 +
553 + mutex_lock(&tc->update_lock);
554 + err = mod_config(tc, new_pulse_per_rotation,
555 + old_pulses & (~new_pulse_per_rotation));
556 + mutex_unlock(&tc->update_lock);
557 +
558 + /* invalidate RPM data to force re-read from hardware */
559 + tc->valid = false;
560 +
561 + return err;
562 +}
563 +
564 +static int get_fan_speed(struct tc654 *tc)
565 +{
566 + enum TC654_FAN_MODE mode;
567 + size_t i;
568 +
569 + mode = get_fan_mode(tc);
570 + for (i = 0; i < ARRAY_SIZE(pwm_table); i++) {
571 + if (mode == pwm_table[i].mode)
572 + return pwm_table[i].min;
573 + }
574 +
575 + return -EINVAL;
576 +}
577 +
578 +static int set_fan_speed(struct tc654 *tc, int new_value)
579 +{
580 + int result;
581 + size_t i;
582 +
583 + if (new_value > pwm_table[ARRAY_SIZE(pwm_table) - 1].min ||
584 + new_value < pwm_table[0].min)
585 + return -EINVAL;
586 +
587 + for (i = 0; i < ARRAY_SIZE(pwm_table); i++) {
588 + /* exact match */
589 + if (pwm_table[i].min == new_value)
590 + break;
591 +
592 + /* a little bit too big - go with the previous entry */
593 + if (pwm_table[i].min > new_value) {
594 + --i;
595 + break;
596 + }
597 + }
598 +
599 + mutex_lock(&tc->update_lock);
600 + result = write_fan_mode(tc, pwm_table[i].mode);
601 + mutex_unlock(&tc->update_lock);
602 + if (result < 0)
603 + return result;
604 +
605 + return 0;
606 +}
607 +
608 +/* sysfs */
609 +
610 +static ssize_t
611 +show_fan_input(struct device *dev, struct device_attribute *da, char *buf)
612 +{
613 + struct tc654 *tc = tc654_update_device(dev);
614 + int nr = to_sensor_dev_attr(da)->index;
615 +
616 + return sprintf(buf, "%d\n", tc->fan_input[nr]);
617 +}
618 +
619 +static ssize_t
620 +show_fan_min(struct device *dev, struct device_attribute *da, char *buf)
621 +{
622 + struct tc654 *tc = dev_get_drvdata(dev);
623 + int nr = to_sensor_dev_attr(da)->index;
624 +
625 + return sprintf(buf, "%d\n", read_fan_fault_thresh(tc, nr));
626 +}
627 +
628 +static ssize_t
629 +show_fan_min_alarm(struct device *dev, struct device_attribute *da, char *buf)
630 +{
631 + struct tc654 *tc = tc654_update_device(dev);
632 + int nr = to_sensor_dev_attr(da)->index;
633 +
634 + return sprintf(buf, "%d\n", nr == TC654_FAN1 ?
635 + tc->alarms[TC654_ALARM_FAN1_FAULT] :
636 + tc->alarms[TC654_ALARM_FAN2_FAULT]);
637 +}
638 +
639 +static ssize_t
640 +show_fan_max_alarm(struct device *dev, struct device_attribute *da, char *buf)
641 +{
642 + struct tc654 *tc = tc654_update_device(dev);
643 + int nr = to_sensor_dev_attr(da)->index;
644 +
645 + return sprintf(buf, "%d\n", nr == TC654_FAN1 ?
646 + tc->alarms[TC654_ALARM_FAN1_COUNTER_OVERFLOW] :
647 + tc->alarms[TC654_ALARM_FAN2_COUNTER_OVERFLOW]);
648 +}
649 +
650 +static ssize_t
651 +set_fan_min(struct device *dev, struct device_attribute *da,
652 + const char *buf, size_t count)
653 +{
654 + struct tc654 *tc = dev_get_drvdata(dev);
655 + long new_min;
656 + int nr = to_sensor_dev_attr(da)->index;
657 + int old_min = read_fan_fault_thresh(tc, nr);
658 + int status = kstrtol(buf, 10, &new_min);
659 +
660 + if (status < 0)
661 + return status;
662 +
663 + new_min = (new_min / 50) * 50;
664 + if (new_min == old_min) /* No change */
665 + return count;
666 +
667 + if (new_min < 0 || new_min > 12750)
668 + return -EINVAL;
669 +
670 + mutex_lock(&tc->update_lock);
671 + status = write_fan_fault_thresh(tc, nr, new_min);
672 + mutex_unlock(&tc->update_lock);
673 + return count;
674 +}
675 +
676 +static ssize_t
677 +show_fan_max(struct device *dev, struct device_attribute *da, char *buf)
678 +{
679 + struct tc654 *tc = dev_get_drvdata(dev);
680 + int max_rpm = tc->cached_regs[TC654_REG_CONFIG] & TC654_CTRL_RES ?
681 + (((1 << 9) - 1) * 25) /* ((2**9) - 1) * 25 RPM */:
682 + (((1 << 8) - 1) * 50) /* ((2**8) - 1) * 50 RPM */;
683 +
684 + return sprintf(buf, "%d\n", max_rpm);
685 +}
686 +
687 +static ssize_t
688 +show_fan_fault(struct device *dev, struct device_attribute *da, char *buf)
689 +{
690 + struct tc654 *tc = tc654_update_device(dev);
691 + int nr = to_sensor_dev_attr(da)->index;
692 + u8 fan_fault_mask = nr == TC654_FAN1 ?
693 + TC654_STATUS_F1F : TC654_STATUS_F2F;
694 +
695 + return sprintf(buf, "%d\n",
696 + !!(tc->cached_regs[TC654_REG_STATUS] & fan_fault_mask));
697 +}
698 +
699 +static ssize_t
700 +show_fan_pulses(struct device *dev, struct device_attribute *da, char *buf)
701 +{
702 + struct tc654 *tc = dev_get_drvdata(dev);
703 + int nr = to_sensor_dev_attr(da)->index;
704 +
705 + return sprintf(buf, "%d\n", get_fan_pulse(tc, nr));
706 +}
707 +
708 +static ssize_t
709 +set_fan_pulses(struct device *dev, struct device_attribute *da,
710 + const char *buf, size_t count)
711 +{
712 + struct tc654 *tc = dev_get_drvdata(dev);
713 + long new_pulse;
714 + int nr = to_sensor_dev_attr(da)->index;
715 + int status = kstrtol(buf, 10, &new_pulse);
716 +
717 + if (status < 0)
718 + return status;
719 +
720 + status = set_fan_pulse(tc, nr, new_pulse);
721 + if (status < 0)
722 + return status;
723 +
724 + return count;
725 +}
726 +
727 +static ssize_t
728 +show_pwm_enable(struct device *dev, struct device_attribute *da, char *buf)
729 +{
730 + struct tc654 *tc = tc654_update_device(dev);
731 + int pwm_enabled;
732 +
733 + if ((tc->cached_regs[TC654_REG_CONFIG] & TC654_CTRL_SDM) &&
734 + !tc->pwm_manual) {
735 + pwm_enabled = 0; /* full off */
736 + } else {
737 + if (tc->valid && tc->vin_status == 0)
738 + pwm_enabled = 2; /* automatic fan speed control */
739 +
740 + pwm_enabled = 1; /* PWM Mode */
741 + }
742 +
743 + return sprintf(buf, "%d\n", pwm_enabled);
744 +}
745 +
746 +static ssize_t
747 +set_pwm_enable(struct device *dev, struct device_attribute *da,
748 + const char *buf, size_t count)
749 +{
750 + struct tc654 *tc = dev_get_drvdata(dev);
751 + long new_value;
752 +
753 + int result = kstrtol(buf, 10, &new_value);
754 +
755 + if (result < 0)
756 + return result;
757 +
758 + mutex_lock(&tc->update_lock);
759 + switch (new_value) {
760 + case 0: /* no fan control (i.e. is OFF) */
761 + result = write_fan_mode(tc, TC654_PWM_OFF);
762 + tc->pwm_manual = false;
763 + break;
764 +
765 + case 1: /* manual fan control enabled (using pwm) */
766 + result = write_fan_mode(tc, TC654_PWM_10000);
767 + break;
768 +
769 + case 2: /* automatic fan speed control enabled */
770 + result = write_fan_mode(tc, TC654_PWM_VIN);
771 + break;
772 +
773 + default:
774 + result = -EINVAL;
775 + }
776 +
777 + mutex_unlock(&tc->update_lock);
778 + return result < 0 ? result : count;
779 +}
780 +
781 +static ssize_t
782 +show_pwm(struct device *dev, struct device_attribute *da, char *buf)
783 +{
784 + struct tc654 *tc = tc654_update_device(dev);
785 + int ret;
786 +
787 + ret = get_fan_speed(tc);
788 + if (ret < 0)
789 + return ret;
790 +
791 + return sprintf(buf, "%d\n", ret);
792 +}
793 +
794 +static ssize_t
795 +set_pwm(struct device *dev, struct device_attribute *da,
796 + const char *buf, size_t count)
797 +{
798 + struct tc654 *tc = dev_get_drvdata(dev);
799 + long new_value = -1;
800 + int result = kstrtol(buf, 10, &new_value);
801 +
802 + if (result < 0)
803 + return result;
804 +
805 + if (new_value < 0 || new_value > INT_MAX)
806 + return -EINVAL;
807 +
808 + if (!tc->pwm_manual)
809 + return -EINVAL;
810 +
811 + result = set_fan_speed(tc, new_value);
812 + if (result < 0)
813 + return result;
814 +
815 + return count;
816 +}
817 +
818 +static ssize_t
819 +show_temp_alarm_otf(struct device *dev, struct device_attribute *da, char *buf)
820 +{
821 + struct tc654 *tc = tc654_update_device(dev);
822 +
823 + return sprintf(buf, "%d\n", tc->alarms[TC654_ALARM_OVER_TEMPERATURE]);
824 +}
825 +
826 +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input,
827 + NULL, TC654_FAN1);
828 +static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR, show_fan_min,
829 + set_fan_min, TC654_FAN1);
830 +static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, show_fan_min_alarm,
831 + NULL, TC654_FAN1);
832 +static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, show_fan_max_alarm,
833 + NULL, TC654_FAN1);
834 +static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO, show_fan_max, NULL, TC654_FAN1);
835 +static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault,
836 + NULL, TC654_FAN1);
837 +static SENSOR_DEVICE_ATTR(fan1_pulses, S_IRUGO | S_IWUSR, show_fan_pulses,
838 + set_fan_pulses, TC654_FAN1);
839 +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input,
840 + NULL, TC654_FAN2);
841 +static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR, show_fan_min,
842 + set_fan_min, TC654_FAN2);
843 +static SENSOR_DEVICE_ATTR(fan2_max, S_IRUGO, show_fan_max,
844 + NULL, TC654_FAN2);
845 +static SENSOR_DEVICE_ATTR(fan2_min_alarm, S_IRUGO, show_fan_min_alarm,
846 + NULL, TC654_FAN2);
847 +static SENSOR_DEVICE_ATTR(fan2_max_alarm, S_IRUGO, show_fan_max_alarm,
848 + NULL, TC654_FAN2);
849 +static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_fan_fault,
850 + NULL, TC654_FAN2);
851 +static SENSOR_DEVICE_ATTR(fan2_pulses, S_IRUGO | S_IWUSR, show_fan_pulses,
852 + set_fan_pulses, TC654_FAN2);
853 +
854 +static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
855 + set_pwm_enable);
856 +static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm);
857 +
858 +static DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_temp_alarm_otf, NULL);
859 +
860 +/* sensors present on all models */
861 +static struct attribute *tc654_attrs[] = {
862 + &sensor_dev_attr_fan1_input.dev_attr.attr,
863 + &sensor_dev_attr_fan1_min.dev_attr.attr,
864 + &sensor_dev_attr_fan1_max.dev_attr.attr,
865 + &sensor_dev_attr_fan1_min_alarm.dev_attr.attr,
866 + &sensor_dev_attr_fan1_max_alarm.dev_attr.attr,
867 + &sensor_dev_attr_fan1_fault.dev_attr.attr,
868 + &sensor_dev_attr_fan1_pulses.dev_attr.attr,
869 + &sensor_dev_attr_fan2_input.dev_attr.attr,
870 + &sensor_dev_attr_fan2_min.dev_attr.attr,
871 + &sensor_dev_attr_fan2_max.dev_attr.attr,
872 + &sensor_dev_attr_fan2_min_alarm.dev_attr.attr,
873 + &sensor_dev_attr_fan2_max_alarm.dev_attr.attr,
874 + &sensor_dev_attr_fan2_fault.dev_attr.attr,
875 + &sensor_dev_attr_fan2_pulses.dev_attr.attr,
876 +
877 + &dev_attr_pwm1_enable.attr,
878 + &dev_attr_pwm1.attr,
879 +
880 + &dev_attr_temp1_emergency_alarm.attr,
881 + NULL
882 +};
883 +
884 +ATTRIBUTE_GROUPS(tc654);
885 +
886 +/* cooling device */
887 +
888 +static int tc654_get_max_state(struct thermal_cooling_device *cdev,
889 + unsigned long *state)
890 +{
891 + *state = 255;
892 + return 0;
893 +}
894 +
895 +static int tc654_get_cur_state(struct thermal_cooling_device *cdev,
896 + unsigned long *state)
897 +{
898 + struct tc654 *tc = cdev->devdata;
899 + int ret;
900 +
901 + if (!tc)
902 + return -EINVAL;
903 +
904 + ret = get_fan_speed(tc);
905 + if (ret < 0)
906 + return ret;
907 +
908 + *state = ret;
909 + return 0;
910 +}
911 +
912 +static int tc654_set_cur_state(struct thermal_cooling_device *cdev,
913 + unsigned long state)
914 +{
915 + struct tc654 *tc = cdev->devdata;
916 +
917 + if (!tc)
918 + return -EINVAL;
919 +
920 + if (state > INT_MAX)
921 + return -EINVAL;
922 +
923 + return set_fan_speed(tc, state);
924 +}
925 +
926 +static const struct thermal_cooling_device_ops tc654_fan_cool_ops = {
927 + .get_max_state = tc654_get_max_state,
928 + .get_cur_state = tc654_get_cur_state,
929 + .set_cur_state = tc654_set_cur_state,
930 +};
931 +
932 +
933 +/* hardware probe and detection */
934 +
935 +static int
936 +tc654_probe(struct i2c_client *client, const struct i2c_device_id *id)
937 +{
938 + struct tc654 *tc;
939 + struct device *hwmon_dev;
940 + int ret, i;
941 +
942 + if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
943 + return -EIO;
944 +
945 + tc = devm_kzalloc(&client->dev, sizeof(*tc), GFP_KERNEL);
946 + if (!tc)
947 + return -ENOMEM;
948 +
949 + i2c_set_clientdata(client, tc);
950 + tc->client = client;
951 + mutex_init(&tc->update_lock);
952 +
953 + /* cache all 8 registers */
954 + for (i = 0; i < __TC654_REG_NUM; i++) {
955 + ret = read_tc(tc, i);
956 + if (ret < 0)
957 + return ret;
958 + }
959 +
960 + /* sysfs hooks */
961 + hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
962 + client->name, tc,
963 + tc654_groups);
964 + if (IS_ERR(hwmon_dev))
965 + return PTR_ERR(hwmon_dev);
966 +
967 +#if IS_ENABLED(CONFIG_OF)
968 + /* Optional cooling device register for Device tree platforms */
969 + tc->cdev = thermal_of_cooling_device_register(client->dev.of_node,
970 + "tc654", tc,
971 + &tc654_fan_cool_ops);
972 +#else /* CONFIG_OF */
973 + /* Optional cooling device register for non Device tree platforms */
974 + tc->cdev = thermal_cooling_device_register("tc654", tc,
975 + &tc654_fan_cool_ops);
976 +#endif /* CONFIG_OF */
977 +
978 + dev_info(&client->dev, "%s: sensor '%s'\n",
979 + dev_name(hwmon_dev), client->name);
980 +
981 + return 0;
982 +}
983 +
984 +static const struct i2c_device_id tc654_ids[] = {
985 + { "tc654", 0, },
986 + { }
987 +};
988 +MODULE_DEVICE_TABLE(i2c, tc654_ids);
989 +
990 +/* Return 0 if detection is successful, -ENODEV otherwise */
991 +static int
992 +tc654_detect(struct i2c_client *new_client, struct i2c_board_info *info)
993 +{
994 + struct i2c_adapter *adapter = new_client->adapter;
995 + int manufacturer, product;
996 +
997 + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
998 + return -ENODEV;
999 +
1000 + manufacturer = i2c_smbus_read_byte_data(new_client, TC654_REG_MFR_ID);
1001 + if (manufacturer != TC654_MFR_ID_MICROCHIP)
1002 + return -ENODEV;
1003 +
1004 + product = i2c_smbus_read_byte_data(new_client, TC654_REG_VER_ID);
1005 + if (!((product == TC654_VER_ID) || (product == TC655_VER_ID)))
1006 + return -ENODEV;
1007 +
1008 + strlcpy(info->type, "tc654", I2C_NAME_SIZE);
1009 + return 0;
1010 +}
1011 +
1012 +static struct i2c_driver tc654_driver = {
1013 + .class = I2C_CLASS_HWMON,
1014 + .driver = {
1015 + .name = "tc654",
1016 + },
1017 + .probe = tc654_probe,
1018 + .id_table = tc654_ids,
1019 + .detect = tc654_detect,
1020 + .address_list = normal_i2c,
1021 +};
1022 +
1023 +module_i2c_driver(tc654_driver);
1024 +
1025 +MODULE_AUTHOR("Christian Lamparter <chunkeey@gmail.com>");
1026 +MODULE_DESCRIPTION("Microchip TC654/TC655 hwmon driver");
1027 +MODULE_LICENSE("GPL");