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