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 fan_show(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 fan_min_show(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 fan_min_store(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 fan_alarm_show(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 fan_pulses_show(struct device *dev,
 279                                struct device_attribute *da, 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 fan_pulses_store(struct device *dev,
 293                                 struct device_attribute *da, const char *buf,
 294                                 size_t count)
 295 {
 296         int nr = to_sensor_dev_attr(da)->index;
 297         struct tc654_data *data = dev_get_drvdata(dev);
 298         struct i2c_client *client = data->client;
 299         u8 config;
 300         unsigned long val;
 301         int ret;
 302
 303         if (kstrtoul(buf, 10, &val))
 304                 return -EINVAL;
 305
 306         switch (val) {
 307         case 1:
 308                 config = 0;
 309                 break;
 310         case 2:
 311                 config = 1;
 312                 break;
 313         case 4:
 314                 config = 2;
 315                 break;
 316         case 8:
 317                 config = 3;
 318                 break;
 319         default:
 320                 return -EINVAL;
 321         }
 322
 323         mutex_lock(&data->update_lock);
 324
 325         data->config &= ~(0x03 << TC654_FAN_PULSE_SHIFT[nr]);
 326         data->config |= (config << TC654_FAN_PULSE_SHIFT[nr]);
 327         ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
 328
 329         mutex_unlock(&data->update_lock);
 330         return ret < 0 ? ret : count;
 331 }
 332
 333 static ssize_t pwm_mode_show(struct device *dev, struct device_attribute *da,
 334                              char *buf)
 335 {
 336         struct tc654_data *data = tc654_update_client(dev);
 337
 338         if (IS_ERR(data))
 339                 return PTR_ERR(data);
 340
 341         return sprintf(buf, "%d\n", !!(data->config & TC654_REG_CONFIG_DUTYC));
 342 }
 343
 344 static ssize_t pwm_mode_store(struct device *dev, 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 pwm_show(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 pwm_store(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_RO(fan1_input, fan, 0);
 427 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
 428 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
 429 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
 430 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0);
 431 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1);
 432 static SENSOR_DEVICE_ATTR_RW(fan1_pulses, fan_pulses, 0);
 433 static SENSOR_DEVICE_ATTR_RW(fan2_pulses, fan_pulses, 1);
 434 static SENSOR_DEVICE_ATTR_RW(pwm1_mode, pwm_mode, 0);
 435 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
 436
 437 /* Driver data */
 438 static struct attribute *tc654_attrs[] = {
 439         &sensor_dev_attr_fan1_input.dev_attr.attr,
 440         &sensor_dev_attr_fan2_input.dev_attr.attr,
 441         &sensor_dev_attr_fan1_min.dev_attr.attr,
 442         &sensor_dev_attr_fan2_min.dev_attr.attr,
 443         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 444         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 445         &sensor_dev_attr_fan1_pulses.dev_attr.attr,
 446         &sensor_dev_attr_fan2_pulses.dev_attr.attr,
 447         &sensor_dev_attr_pwm1_mode.dev_attr.attr,
 448         &sensor_dev_attr_pwm1.dev_attr.attr,
 449         NULL
 450 };
 451
 452 ATTRIBUTE_GROUPS(tc654);
 453
 454 /*
 455  * device probe and removal
 456  */
 457
 458 static int tc654_probe(struct i2c_client *client,
 459                        const struct i2c_device_id *id)
 460 {
 461         struct device *dev = &client->dev;
 462         struct tc654_data *data;
 463         struct device *hwmon_dev;
 464         int ret;
 465
 466         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 467                 return -ENODEV;
 468
 469         data = devm_kzalloc(dev, sizeof(struct tc654_data), GFP_KERNEL);
 470         if (!data)
 471                 return -ENOMEM;
 472
 473         data->client = client;
 474         mutex_init(&data->update_lock);
 475
 476         ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
 477         if (ret < 0)
 478                 return ret;
 479
 480         data->config = ret;
 481
 482         hwmon_dev =
 483             devm_hwmon_device_register_with_groups(dev, client->name, data,
 484                                                    tc654_groups);
 485         return PTR_ERR_OR_ZERO(hwmon_dev);
 486 }
 487
 488 static const struct i2c_device_id tc654_id[] = {
 489         {"tc654", 0},
 490         {"tc655", 0},
 491         {}
 492 };
 493
 494 MODULE_DEVICE_TABLE(i2c, tc654_id);
 495
 496 static struct i2c_driver tc654_driver = {
 497         .driver = {
 498                    .name = "tc654",
 499                    },
 500         .probe = tc654_probe,
 501         .id_table = tc654_id,
 502 };
 503
 504 module_i2c_driver(tc654_driver);
 505
 506 MODULE_AUTHOR("Allied Telesis Labs");
 507 MODULE_DESCRIPTION("Microchip TC654/TC655 driver");
 508 MODULE_LICENSE("GPL");