?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / hwmon / tc654.c
blob39fe5836f237f2ce61c3f67ba83c3375dd688ace
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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"},
554 {"tc655"},
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");
Kernel DRM miscellaneous fixes and cross-tree changes