drivers/hwmon/tc654.c

   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", 0},
 554         {"tc655", 0},
 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");