treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / hwmon / max31790.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * max31790.c - Part of lm_sensors, Linux kernel modules for hardware
4  *             monitoring.
5  *
6  * (C) 2015 by Il Han <corone.il.han@gmail.com>
7  */
8
9 #include <linux/err.h>
10 #include <linux/hwmon.h>
11 #include <linux/i2c.h>
12 #include <linux/init.h>
13 #include <linux/jiffies.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16
17 /* MAX31790 registers */
18 #define MAX31790_REG_GLOBAL_CONFIG      0x00
19 #define MAX31790_REG_FAN_CONFIG(ch)     (0x02 + (ch))
20 #define MAX31790_REG_FAN_DYNAMICS(ch)   (0x08 + (ch))
21 #define MAX31790_REG_FAN_FAULT_STATUS2  0x10
22 #define MAX31790_REG_FAN_FAULT_STATUS1  0x11
23 #define MAX31790_REG_TACH_COUNT(ch)     (0x18 + (ch) * 2)
24 #define MAX31790_REG_PWM_DUTY_CYCLE(ch) (0x30 + (ch) * 2)
25 #define MAX31790_REG_PWMOUT(ch)         (0x40 + (ch) * 2)
26 #define MAX31790_REG_TARGET_COUNT(ch)   (0x50 + (ch) * 2)
27
28 /* Fan Config register bits */
29 #define MAX31790_FAN_CFG_RPM_MODE       0x80
30 #define MAX31790_FAN_CFG_TACH_INPUT_EN  0x08
31 #define MAX31790_FAN_CFG_TACH_INPUT     0x01
32
33 /* Fan Dynamics register bits */
34 #define MAX31790_FAN_DYN_SR_SHIFT       5
35 #define MAX31790_FAN_DYN_SR_MASK        0xE0
36 #define SR_FROM_REG(reg)                (((reg) & MAX31790_FAN_DYN_SR_MASK) \
37                                          >> MAX31790_FAN_DYN_SR_SHIFT)
38
39 #define FAN_RPM_MIN                     120
40 #define FAN_RPM_MAX                     7864320
41
42 #define RPM_FROM_REG(reg, sr)           (((reg) >> 4) ? \
43                                          ((60 * (sr) * 8192) / ((reg) >> 4)) : \
44                                          FAN_RPM_MAX)
45 #define RPM_TO_REG(rpm, sr)             ((60 * (sr) * 8192) / ((rpm) * 2))
46
47 #define NR_CHANNEL                      6
48
49 /*
50  * Client data (each client gets its own)
51  */
52 struct max31790_data {
53         struct i2c_client *client;
54         struct mutex update_lock;
55         bool valid; /* zero until following fields are valid */
56         unsigned long last_updated; /* in jiffies */
57
58         /* register values */
59         u8 fan_config[NR_CHANNEL];
60         u8 fan_dynamics[NR_CHANNEL];
61         u16 fault_status;
62         u16 tach[NR_CHANNEL * 2];
63         u16 pwm[NR_CHANNEL];
64         u16 target_count[NR_CHANNEL];
65 };
66
67 static struct max31790_data *max31790_update_device(struct device *dev)
68 {
69         struct max31790_data *data = dev_get_drvdata(dev);
70         struct i2c_client *client = data->client;
71         struct max31790_data *ret = data;
72         int i;
73         int rv;
74
75         mutex_lock(&data->update_lock);
76
77         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
78                 rv = i2c_smbus_read_byte_data(client,
79                                 MAX31790_REG_FAN_FAULT_STATUS1);
80                 if (rv < 0)
81                         goto abort;
82                 data->fault_status = rv & 0x3F;
83
84                 rv = i2c_smbus_read_byte_data(client,
85                                 MAX31790_REG_FAN_FAULT_STATUS2);
86                 if (rv < 0)
87                         goto abort;
88                 data->fault_status |= (rv & 0x3F) << 6;
89
90                 for (i = 0; i < NR_CHANNEL; i++) {
91                         rv = i2c_smbus_read_word_swapped(client,
92                                         MAX31790_REG_TACH_COUNT(i));
93                         if (rv < 0)
94                                 goto abort;
95                         data->tach[i] = rv;
96
97                         if (data->fan_config[i]
98                             & MAX31790_FAN_CFG_TACH_INPUT) {
99                                 rv = i2c_smbus_read_word_swapped(client,
100                                         MAX31790_REG_TACH_COUNT(NR_CHANNEL
101                                                                 + i));
102                                 if (rv < 0)
103                                         goto abort;
104                                 data->tach[NR_CHANNEL + i] = rv;
105                         } else {
106                                 rv = i2c_smbus_read_word_swapped(client,
107                                                 MAX31790_REG_PWMOUT(i));
108                                 if (rv < 0)
109                                         goto abort;
110                                 data->pwm[i] = rv;
111
112                                 rv = i2c_smbus_read_word_swapped(client,
113                                                 MAX31790_REG_TARGET_COUNT(i));
114                                 if (rv < 0)
115                                         goto abort;
116                                 data->target_count[i] = rv;
117                         }
118                 }
119
120                 data->last_updated = jiffies;
121                 data->valid = true;
122         }
123         goto done;
124
125 abort:
126         data->valid = false;
127         ret = ERR_PTR(rv);
128
129 done:
130         mutex_unlock(&data->update_lock);
131
132         return ret;
133 }
134
135 static const u8 tach_period[8] = { 1, 2, 4, 8, 16, 32, 32, 32 };
136
137 static u8 get_tach_period(u8 fan_dynamics)
138 {
139         return tach_period[SR_FROM_REG(fan_dynamics)];
140 }
141
142 static u8 bits_for_tach_period(int rpm)
143 {
144         u8 bits;
145
146         if (rpm < 500)
147                 bits = 0x0;
148         else if (rpm < 1000)
149                 bits = 0x1;
150         else if (rpm < 2000)
151                 bits = 0x2;
152         else if (rpm < 4000)
153                 bits = 0x3;
154         else if (rpm < 8000)
155                 bits = 0x4;
156         else
157                 bits = 0x5;
158
159         return bits;
160 }
161
162 static int max31790_read_fan(struct device *dev, u32 attr, int channel,
163                              long *val)
164 {
165         struct max31790_data *data = max31790_update_device(dev);
166         int sr, rpm;
167
168         if (IS_ERR(data))
169                 return PTR_ERR(data);
170
171         switch (attr) {
172         case hwmon_fan_input:
173                 sr = get_tach_period(data->fan_dynamics[channel]);
174                 rpm = RPM_FROM_REG(data->tach[channel], sr);
175                 *val = rpm;
176                 return 0;
177         case hwmon_fan_target:
178                 sr = get_tach_period(data->fan_dynamics[channel]);
179                 rpm = RPM_FROM_REG(data->target_count[channel], sr);
180                 *val = rpm;
181                 return 0;
182         case hwmon_fan_fault:
183                 *val = !!(data->fault_status & (1 << channel));
184                 return 0;
185         default:
186                 return -EOPNOTSUPP;
187         }
188 }
189
190 static int max31790_write_fan(struct device *dev, u32 attr, int channel,
191                               long val)
192 {
193         struct max31790_data *data = dev_get_drvdata(dev);
194         struct i2c_client *client = data->client;
195         int target_count;
196         int err = 0;
197         u8 bits;
198         int sr;
199
200         mutex_lock(&data->update_lock);
201
202         switch (attr) {
203         case hwmon_fan_target:
204                 val = clamp_val(val, FAN_RPM_MIN, FAN_RPM_MAX);
205                 bits = bits_for_tach_period(val);
206                 data->fan_dynamics[channel] =
207                         ((data->fan_dynamics[channel] &
208                           ~MAX31790_FAN_DYN_SR_MASK) |
209                          (bits << MAX31790_FAN_DYN_SR_SHIFT));
210                 err = i2c_smbus_write_byte_data(client,
211                                         MAX31790_REG_FAN_DYNAMICS(channel),
212                                         data->fan_dynamics[channel]);
213                 if (err < 0)
214                         break;
215
216                 sr = get_tach_period(data->fan_dynamics[channel]);
217                 target_count = RPM_TO_REG(val, sr);
218                 target_count = clamp_val(target_count, 0x1, 0x7FF);
219
220                 data->target_count[channel] = target_count << 5;
221
222                 err = i2c_smbus_write_word_swapped(client,
223                                         MAX31790_REG_TARGET_COUNT(channel),
224                                         data->target_count[channel]);
225                 break;
226         default:
227                 err = -EOPNOTSUPP;
228                 break;
229         }
230
231         mutex_unlock(&data->update_lock);
232
233         return err;
234 }
235
236 static umode_t max31790_fan_is_visible(const void *_data, u32 attr, int channel)
237 {
238         const struct max31790_data *data = _data;
239         u8 fan_config = data->fan_config[channel % NR_CHANNEL];
240
241         switch (attr) {
242         case hwmon_fan_input:
243         case hwmon_fan_fault:
244                 if (channel < NR_CHANNEL ||
245                     (fan_config & MAX31790_FAN_CFG_TACH_INPUT))
246                         return 0444;
247                 return 0;
248         case hwmon_fan_target:
249                 if (channel < NR_CHANNEL &&
250                     !(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
251                         return 0644;
252                 return 0;
253         default:
254                 return 0;
255         }
256 }
257
258 static int max31790_read_pwm(struct device *dev, u32 attr, int channel,
259                              long *val)
260 {
261         struct max31790_data *data = max31790_update_device(dev);
262         u8 fan_config;
263
264         if (IS_ERR(data))
265                 return PTR_ERR(data);
266
267         fan_config = data->fan_config[channel];
268
269         switch (attr) {
270         case hwmon_pwm_input:
271                 *val = data->pwm[channel] >> 8;
272                 return 0;
273         case hwmon_pwm_enable:
274                 if (fan_config & MAX31790_FAN_CFG_RPM_MODE)
275                         *val = 2;
276                 else if (fan_config & MAX31790_FAN_CFG_TACH_INPUT_EN)
277                         *val = 1;
278                 else
279                         *val = 0;
280                 return 0;
281         default:
282                 return -EOPNOTSUPP;
283         }
284 }
285
286 static int max31790_write_pwm(struct device *dev, u32 attr, int channel,
287                               long val)
288 {
289         struct max31790_data *data = dev_get_drvdata(dev);
290         struct i2c_client *client = data->client;
291         u8 fan_config;
292         int err = 0;
293
294         mutex_lock(&data->update_lock);
295
296         switch (attr) {
297         case hwmon_pwm_input:
298                 if (val < 0 || val > 255) {
299                         err = -EINVAL;
300                         break;
301                 }
302                 data->pwm[channel] = val << 8;
303                 err = i2c_smbus_write_word_swapped(client,
304                                                    MAX31790_REG_PWMOUT(channel),
305                                                    data->pwm[channel]);
306                 break;
307         case hwmon_pwm_enable:
308                 fan_config = data->fan_config[channel];
309                 if (val == 0) {
310                         fan_config &= ~(MAX31790_FAN_CFG_TACH_INPUT_EN |
311                                         MAX31790_FAN_CFG_RPM_MODE);
312                 } else if (val == 1) {
313                         fan_config = (fan_config |
314                                       MAX31790_FAN_CFG_TACH_INPUT_EN) &
315                                      ~MAX31790_FAN_CFG_RPM_MODE;
316                 } else if (val == 2) {
317                         fan_config |= MAX31790_FAN_CFG_TACH_INPUT_EN |
318                                       MAX31790_FAN_CFG_RPM_MODE;
319                 } else {
320                         err = -EINVAL;
321                         break;
322                 }
323                 data->fan_config[channel] = fan_config;
324                 err = i2c_smbus_write_byte_data(client,
325                                         MAX31790_REG_FAN_CONFIG(channel),
326                                         fan_config);
327                 break;
328         default:
329                 err = -EOPNOTSUPP;
330                 break;
331         }
332
333         mutex_unlock(&data->update_lock);
334
335         return err;
336 }
337
338 static umode_t max31790_pwm_is_visible(const void *_data, u32 attr, int channel)
339 {
340         const struct max31790_data *data = _data;
341         u8 fan_config = data->fan_config[channel];
342
343         switch (attr) {
344         case hwmon_pwm_input:
345         case hwmon_pwm_enable:
346                 if (!(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
347                         return 0644;
348                 return 0;
349         default:
350                 return 0;
351         }
352 }
353
354 static int max31790_read(struct device *dev, enum hwmon_sensor_types type,
355                          u32 attr, int channel, long *val)
356 {
357         switch (type) {
358         case hwmon_fan:
359                 return max31790_read_fan(dev, attr, channel, val);
360         case hwmon_pwm:
361                 return max31790_read_pwm(dev, attr, channel, val);
362         default:
363                 return -EOPNOTSUPP;
364         }
365 }
366
367 static int max31790_write(struct device *dev, enum hwmon_sensor_types type,
368                           u32 attr, int channel, long val)
369 {
370         switch (type) {
371         case hwmon_fan:
372                 return max31790_write_fan(dev, attr, channel, val);
373         case hwmon_pwm:
374                 return max31790_write_pwm(dev, attr, channel, val);
375         default:
376                 return -EOPNOTSUPP;
377         }
378 }
379
380 static umode_t max31790_is_visible(const void *data,
381                                    enum hwmon_sensor_types type,
382                                    u32 attr, int channel)
383 {
384         switch (type) {
385         case hwmon_fan:
386                 return max31790_fan_is_visible(data, attr, channel);
387         case hwmon_pwm:
388                 return max31790_pwm_is_visible(data, attr, channel);
389         default:
390                 return 0;
391         }
392 }
393
394 static const struct hwmon_channel_info *max31790_info[] = {
395         HWMON_CHANNEL_INFO(fan,
396                            HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
397                            HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
398                            HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
399                            HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
400                            HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
401                            HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
402                            HWMON_F_INPUT | HWMON_F_FAULT,
403                            HWMON_F_INPUT | HWMON_F_FAULT,
404                            HWMON_F_INPUT | HWMON_F_FAULT,
405                            HWMON_F_INPUT | HWMON_F_FAULT,
406                            HWMON_F_INPUT | HWMON_F_FAULT,
407                            HWMON_F_INPUT | HWMON_F_FAULT),
408         HWMON_CHANNEL_INFO(pwm,
409                            HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
410                            HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
411                            HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
412                            HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
413                            HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
414                            HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
415         NULL
416 };
417
418 static const struct hwmon_ops max31790_hwmon_ops = {
419         .is_visible = max31790_is_visible,
420         .read = max31790_read,
421         .write = max31790_write,
422 };
423
424 static const struct hwmon_chip_info max31790_chip_info = {
425         .ops = &max31790_hwmon_ops,
426         .info = max31790_info,
427 };
428
429 static int max31790_init_client(struct i2c_client *client,
430                                 struct max31790_data *data)
431 {
432         int i, rv;
433
434         for (i = 0; i < NR_CHANNEL; i++) {
435                 rv = i2c_smbus_read_byte_data(client,
436                                 MAX31790_REG_FAN_CONFIG(i));
437                 if (rv < 0)
438                         return rv;
439                 data->fan_config[i] = rv;
440
441                 rv = i2c_smbus_read_byte_data(client,
442                                 MAX31790_REG_FAN_DYNAMICS(i));
443                 if (rv < 0)
444                         return rv;
445                 data->fan_dynamics[i] = rv;
446         }
447
448         return 0;
449 }
450
451 static int max31790_probe(struct i2c_client *client,
452                           const struct i2c_device_id *id)
453 {
454         struct i2c_adapter *adapter = client->adapter;
455         struct device *dev = &client->dev;
456         struct max31790_data *data;
457         struct device *hwmon_dev;
458         int err;
459
460         if (!i2c_check_functionality(adapter,
461                         I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
462                 return -ENODEV;
463
464         data = devm_kzalloc(dev, sizeof(struct max31790_data), GFP_KERNEL);
465         if (!data)
466                 return -ENOMEM;
467
468         data->client = client;
469         mutex_init(&data->update_lock);
470
471         /*
472          * Initialize the max31790 chip
473          */
474         err = max31790_init_client(client, data);
475         if (err)
476                 return err;
477
478         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
479                                                          data,
480                                                          &max31790_chip_info,
481                                                          NULL);
482
483         return PTR_ERR_OR_ZERO(hwmon_dev);
484 }
485
486 static const struct i2c_device_id max31790_id[] = {
487         { "max31790", 0 },
488         { }
489 };
490 MODULE_DEVICE_TABLE(i2c, max31790_id);
491
492 static struct i2c_driver max31790_driver = {
493         .class          = I2C_CLASS_HWMON,
494         .probe          = max31790_probe,
495         .driver = {
496                 .name   = "max31790",
497         },
498         .id_table       = max31790_id,
499 };
500
501 module_i2c_driver(max31790_driver);
502
503 MODULE_AUTHOR("Il Han <corone.il.han@gmail.com>");
504 MODULE_DESCRIPTION("MAX31790 sensor driver");
505 MODULE_LICENSE("GPL");