drivers/hwmon/emc2305.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Hardware monitoring driver for EMC2305 fan controller
   4  *
   5  * Copyright (C) 2022 Nvidia Technologies Ltd.
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/hwmon.h>
  10 #include <linux/i2c.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_data/emc2305.h>
  13 #include <linux/thermal.h>
  14
  15 static const unsigned short
  16 emc2305_normal_i2c[] = { 0x27, 0x2c, 0x2d, 0x2e, 0x2f, 0x4c, 0x4d, I2C_CLIENT_END };
  17
  18 #define EMC2305_REG_DRIVE_FAIL_STATUS   0x27
  19 #define EMC2305_REG_DEVICE              0xfd
  20 #define EMC2305_REG_VENDOR              0xfe
  21 #define EMC2305_FAN_MAX                 0xff
  22 #define EMC2305_FAN_MIN                 0x00
  23 #define EMC2305_FAN_MAX_STATE           10
  24 #define EMC2305_DEVICE                  0x34
  25 #define EMC2305_VENDOR                  0x5d
  26 #define EMC2305_REG_PRODUCT_ID          0xfd
  27 #define EMC2305_TACH_REGS_UNUSE_BITS    3
  28 #define EMC2305_TACH_CNT_MULTIPLIER     0x02
  29 #define EMC2305_TACH_RANGE_MIN          480
  30
  31 #define EMC2305_PWM_DUTY2STATE(duty, max_state, pwm_max) \
  32         DIV_ROUND_CLOSEST((duty) * (max_state), (pwm_max))
  33 #define EMC2305_PWM_STATE2DUTY(state, max_state, pwm_max) \
  34         DIV_ROUND_CLOSEST((state) * (pwm_max), (max_state))
  35
  36 /*
  37  * Factor by equations [2] and [3] from data sheet; valid for fans where the number of edges
  38  * equal (poles * 2 + 1).
  39  */
  40 #define EMC2305_RPM_FACTOR              3932160
  41
  42 #define EMC2305_REG_FAN_DRIVE(n)        (0x30 + 0x10 * (n))
  43 #define EMC2305_REG_FAN_MIN_DRIVE(n)    (0x38 + 0x10 * (n))
  44 #define EMC2305_REG_FAN_TACH(n)         (0x3e + 0x10 * (n))
  45
  46 enum emc230x_product_id {
  47         EMC2305 = 0x34,
  48         EMC2303 = 0x35,
  49         EMC2302 = 0x36,
  50         EMC2301 = 0x37,
  51 };
  52
  53 static const struct i2c_device_id emc2305_ids[] = {
  54         { "emc2305", 0 },
  55         { "emc2303", 0 },
  56         { "emc2302", 0 },
  57         { "emc2301", 0 },
  58         { }
  59 };
  60 MODULE_DEVICE_TABLE(i2c, emc2305_ids);
  61
  62 /**
  63  * @cdev: cooling device;
  64  * @curr_state: cooling current state;
  65  * @last_hwmon_state: last cooling state updated by hwmon subsystem;
  66  * @last_thermal_state: last cooling state updated by thermal subsystem;
  67  *
  68  * The 'last_hwmon_state' and 'last_thermal_state' fields are provided to support fan low limit
  69  * speed feature. The purpose of this feature is to provides ability to limit fan speed
  70  * according to some system wise considerations, like absence of some replaceable units (PSU or
  71  * line cards), high system ambient temperature, unreliable transceivers temperature sensing or
  72  * some other factors which indirectly impacts system's airflow
  73  * Fan low limit feature is supported through 'hwmon' interface: 'hwmon' 'pwm' attribute is
  74  * used for setting low limit for fan speed in case 'thermal' subsystem is configured in
  75  * kernel. In this case setting fan speed through 'hwmon' will never let the 'thermal'
  76  * subsystem to select a lower duty cycle than the duty cycle selected with the 'pwm'
  77  * attribute.
  78  * From other side, fan speed is to be updated in hardware through 'pwm' only in case the
  79  * requested fan speed is above last speed set by 'thermal' subsystem, otherwise requested fan
  80  * speed will be just stored with no PWM update.
  81  */
  82 struct emc2305_cdev_data {
  83         struct thermal_cooling_device *cdev;
  84         unsigned int cur_state;
  85         unsigned long last_hwmon_state;
  86         unsigned long last_thermal_state;
  87 };
  88
  89 /**
  90  * @client: i2c client;
  91  * @hwmon_dev: hwmon device;
  92  * @max_state: maximum cooling state of the cooling device;
  93  * @pwm_num: number of PWM channels;
  94  * @pwm_separate: separate PWM settings for every channel;
  95  * @pwm_min: array of minimum PWM per channel;
  96  * @cdev_data: array of cooling devices data;
  97  */
  98 struct emc2305_data {
  99         struct i2c_client *client;
 100         struct device *hwmon_dev;
 101         u8 max_state;
 102         u8 pwm_num;
 103         bool pwm_separate;
 104         u8 pwm_min[EMC2305_PWM_MAX];
 105         struct emc2305_cdev_data cdev_data[EMC2305_PWM_MAX];
 106 };
 107
 108 static char *emc2305_fan_name[] = {
 109         "emc2305_fan",
 110         "emc2305_fan1",
 111         "emc2305_fan2",
 112         "emc2305_fan3",
 113         "emc2305_fan4",
 114         "emc2305_fan5",
 115 };
 116
 117 static void emc2305_unset_tz(struct device *dev);
 118
 119 static int emc2305_get_max_channel(const struct emc2305_data *data)
 120 {
 121         return data->pwm_num;
 122 }
 123
 124 static int emc2305_get_cdev_idx(struct thermal_cooling_device *cdev)
 125 {
 126         struct emc2305_data *data = cdev->devdata;
 127         size_t len = strlen(cdev->type);
 128         int ret;
 129
 130         if (len <= 0)
 131                 return -EINVAL;
 132
 133         /*
 134          * Returns index of cooling device 0..4 in case of separate PWM setting.
 135          * Zero index is used in case of one common PWM setting.
 136          * If the mode is not set as pwm_separate, all PWMs are to be bound
 137          * to the common thermal zone and should work at the same speed
 138          * to perform cooling for the same thermal junction.
 139          * Otherwise, return specific channel that will be used in bound
 140          * related PWM to the thermal zone.
 141          */
 142         if (!data->pwm_separate)
 143                 return 0;
 144
 145         ret = cdev->type[len - 1];
 146         switch (ret) {
 147         case '1' ... '5':
 148                 return ret - '1';
 149         default:
 150                 break;
 151         }
 152         return -EINVAL;
 153 }
 154
 155 static int emc2305_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state)
 156 {
 157         int cdev_idx;
 158         struct emc2305_data *data = cdev->devdata;
 159
 160         cdev_idx = emc2305_get_cdev_idx(cdev);
 161         if (cdev_idx < 0)
 162                 return cdev_idx;
 163
 164         *state = data->cdev_data[cdev_idx].cur_state;
 165         return 0;
 166 }
 167
 168 static int emc2305_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state)
 169 {
 170         struct emc2305_data *data = cdev->devdata;
 171         *state = data->max_state;
 172         return 0;
 173 }
 174
 175 static int emc2305_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
 176 {
 177         int cdev_idx, ret;
 178         struct emc2305_data *data = cdev->devdata;
 179         struct i2c_client *client = data->client;
 180         u8 val, i;
 181
 182         if (state > data->max_state)
 183                 return -EINVAL;
 184
 185         cdev_idx =  emc2305_get_cdev_idx(cdev);
 186         if (cdev_idx < 0)
 187                 return cdev_idx;
 188
 189         /* Save thermal state. */
 190         data->cdev_data[cdev_idx].last_thermal_state = state;
 191         state = max_t(unsigned long, state, data->cdev_data[cdev_idx].last_hwmon_state);
 192
 193         val = EMC2305_PWM_STATE2DUTY(state, data->max_state, EMC2305_FAN_MAX);
 194
 195         data->cdev_data[cdev_idx].cur_state = state;
 196         if (data->pwm_separate) {
 197                 ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_DRIVE(cdev_idx), val);
 198                 if (ret < 0)
 199                         return ret;
 200         } else {
 201                 /*
 202                  * Set the same PWM value in all channels
 203                  * if common PWM channel is used.
 204                  */
 205                 for (i = 0; i < data->pwm_num; i++) {
 206                         ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_DRIVE(i), val);
 207                         if (ret < 0)
 208                                 return ret;
 209                 }
 210         }
 211
 212         return 0;
 213 }
 214
 215 static const struct thermal_cooling_device_ops emc2305_cooling_ops = {
 216         .get_max_state = emc2305_get_max_state,
 217         .get_cur_state = emc2305_get_cur_state,
 218         .set_cur_state = emc2305_set_cur_state,
 219 };
 220
 221 static int emc2305_show_fault(struct device *dev, int channel)
 222 {
 223         struct emc2305_data *data = dev_get_drvdata(dev);
 224         struct i2c_client *client = data->client;
 225         int status_reg;
 226
 227         status_reg = i2c_smbus_read_byte_data(client, EMC2305_REG_DRIVE_FAIL_STATUS);
 228         if (status_reg < 0)
 229                 return status_reg;
 230
 231         return status_reg & (1 << channel) ? 1 : 0;
 232 }
 233
 234 static int emc2305_show_fan(struct device *dev, int channel)
 235 {
 236         struct emc2305_data *data = dev_get_drvdata(dev);
 237         struct i2c_client *client = data->client;
 238         int ret;
 239
 240         ret = i2c_smbus_read_word_swapped(client, EMC2305_REG_FAN_TACH(channel));
 241         if (ret <= 0)
 242                 return ret;
 243
 244         ret = ret >> EMC2305_TACH_REGS_UNUSE_BITS;
 245         ret = EMC2305_RPM_FACTOR / ret;
 246         if (ret <= EMC2305_TACH_RANGE_MIN)
 247                 return 0;
 248
 249         return ret * EMC2305_TACH_CNT_MULTIPLIER;
 250 }
 251
 252 static int emc2305_show_pwm(struct device *dev, int channel)
 253 {
 254         struct emc2305_data *data = dev_get_drvdata(dev);
 255         struct i2c_client *client = data->client;
 256
 257         return i2c_smbus_read_byte_data(client, EMC2305_REG_FAN_DRIVE(channel));
 258 }
 259
 260 static int emc2305_set_pwm(struct device *dev, long val, int channel)
 261 {
 262         struct emc2305_data *data = dev_get_drvdata(dev);
 263         struct i2c_client *client = data->client;
 264         int ret;
 265
 266         if (val < data->pwm_min[channel] || val > EMC2305_FAN_MAX)
 267                 return -EINVAL;
 268
 269         ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_DRIVE(channel), val);
 270         if (ret < 0)
 271                 return ret;
 272         data->cdev_data[channel].cur_state = EMC2305_PWM_DUTY2STATE(val, data->max_state,
 273                                                                     EMC2305_FAN_MAX);
 274         return 0;
 275 }
 276
 277 static int emc2305_set_single_tz(struct device *dev, int idx)
 278 {
 279         struct emc2305_data *data = dev_get_drvdata(dev);
 280         long pwm;
 281         int i, cdev_idx, ret;
 282
 283         cdev_idx = (idx) ? idx - 1 : 0;
 284         pwm = data->pwm_min[cdev_idx];
 285
 286         data->cdev_data[cdev_idx].cdev =
 287                 thermal_cooling_device_register(emc2305_fan_name[idx], data,
 288                                                 &emc2305_cooling_ops);
 289
 290         if (IS_ERR(data->cdev_data[cdev_idx].cdev)) {
 291                 dev_err(dev, "Failed to register cooling device %s\n", emc2305_fan_name[idx]);
 292                 return PTR_ERR(data->cdev_data[cdev_idx].cdev);
 293         }
 294         /* Set minimal PWM speed. */
 295         if (data->pwm_separate) {
 296                 ret = emc2305_set_pwm(dev, pwm, cdev_idx);
 297                 if (ret < 0)
 298                         return ret;
 299         } else {
 300                 for (i = 0; i < data->pwm_num; i++) {
 301                         ret = emc2305_set_pwm(dev, pwm, i);
 302                         if (ret < 0)
 303                                 return ret;
 304                 }
 305         }
 306         data->cdev_data[cdev_idx].cur_state =
 307                 EMC2305_PWM_DUTY2STATE(data->pwm_min[cdev_idx], data->max_state,
 308                                        EMC2305_FAN_MAX);
 309         data->cdev_data[cdev_idx].last_hwmon_state =
 310                 EMC2305_PWM_DUTY2STATE(data->pwm_min[cdev_idx], data->max_state,
 311                                        EMC2305_FAN_MAX);
 312         return 0;
 313 }
 314
 315 static int emc2305_set_tz(struct device *dev)
 316 {
 317         struct emc2305_data *data = dev_get_drvdata(dev);
 318         int i, ret;
 319
 320         if (!data->pwm_separate)
 321                 return emc2305_set_single_tz(dev, 0);
 322
 323         for (i = 0; i < data->pwm_num; i++) {
 324                 ret = emc2305_set_single_tz(dev, i + 1);
 325                 if (ret)
 326                         goto thermal_cooling_device_register_fail;
 327         }
 328         return 0;
 329
 330 thermal_cooling_device_register_fail:
 331         emc2305_unset_tz(dev);
 332         return ret;
 333 }
 334
 335 static void emc2305_unset_tz(struct device *dev)
 336 {
 337         struct emc2305_data *data = dev_get_drvdata(dev);
 338         int i;
 339
 340         /* Unregister cooling device. */
 341         for (i = 0; i < EMC2305_PWM_MAX; i++)
 342                 if (data->cdev_data[i].cdev)
 343                         thermal_cooling_device_unregister(data->cdev_data[i].cdev);
 344 }
 345
 346 static umode_t
 347 emc2305_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel)
 348 {
 349         int max_channel = emc2305_get_max_channel(data);
 350
 351         /* Don't show channels which are not physically connected. */
 352         if (channel >= max_channel)
 353                 return 0;
 354         switch (type) {
 355         case hwmon_fan:
 356                 switch (attr) {
 357                 case hwmon_fan_input:
 358                         return 0444;
 359                 case hwmon_fan_fault:
 360                         return 0444;
 361                 default:
 362                         break;
 363                 }
 364                 break;
 365         case hwmon_pwm:
 366                 switch (attr) {
 367                 case hwmon_pwm_input:
 368                         return 0644;
 369                 default:
 370                         break;
 371                 }
 372                 break;
 373         default:
 374                 break;
 375         }
 376
 377         return 0;
 378 };
 379
 380 static int
 381 emc2305_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, long val)
 382 {
 383         struct emc2305_data *data = dev_get_drvdata(dev);
 384         int cdev_idx;
 385
 386         switch (type) {
 387         case hwmon_pwm:
 388                 switch (attr) {
 389                 case hwmon_pwm_input:
 390                         /* If thermal is configured - handle PWM limit setting. */
 391                         if (IS_REACHABLE(CONFIG_THERMAL)) {
 392                                 if (data->pwm_separate)
 393                                         cdev_idx = channel;
 394                                 else
 395                                         cdev_idx = 0;
 396                                 data->cdev_data[cdev_idx].last_hwmon_state =
 397                                         EMC2305_PWM_DUTY2STATE(val, data->max_state,
 398                                                                EMC2305_FAN_MAX);
 399                                 /*
 400                                  * Update PWM only in case requested state is not less than the
 401                                  * last thermal state.
 402                                  */
 403                                 if (data->cdev_data[cdev_idx].last_hwmon_state >=
 404                                     data->cdev_data[cdev_idx].last_thermal_state)
 405                                         return emc2305_set_cur_state(data->cdev_data[cdev_idx].cdev,
 406                                                         data->cdev_data[cdev_idx].last_hwmon_state);
 407                                 return 0;
 408                         }
 409                         return emc2305_set_pwm(dev, val, channel);
 410                 default:
 411                         break;
 412                 }
 413                 break;
 414         default:
 415                 break;
 416         }
 417
 418         return -EOPNOTSUPP;
 419 };
 420
 421 static int
 422 emc2305_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, long *val)
 423 {
 424         int ret;
 425
 426         switch (type) {
 427         case hwmon_fan:
 428                 switch (attr) {
 429                 case hwmon_fan_input:
 430                         ret = emc2305_show_fan(dev, channel);
 431                         if (ret < 0)
 432                                 return ret;
 433                         *val = ret;
 434                         return 0;
 435                 case hwmon_fan_fault:
 436                         ret = emc2305_show_fault(dev, channel);
 437                         if (ret < 0)
 438                                 return ret;
 439                         *val = ret;
 440                         return 0;
 441                 default:
 442                         break;
 443                 }
 444                 break;
 445         case hwmon_pwm:
 446                 switch (attr) {
 447                 case hwmon_pwm_input:
 448                         ret = emc2305_show_pwm(dev, channel);
 449                         if (ret < 0)
 450                                 return ret;
 451                         *val = ret;
 452                         return 0;
 453                 default:
 454                         break;
 455                 }
 456                 break;
 457         default:
 458                 break;
 459         }
 460
 461         return -EOPNOTSUPP;
 462 };
 463
 464 static const struct hwmon_ops emc2305_ops = {
 465         .is_visible = emc2305_is_visible,
 466         .read = emc2305_read,
 467         .write = emc2305_write,
 468 };
 469
 470 static const struct hwmon_channel_info *emc2305_info[] = {
 471         HWMON_CHANNEL_INFO(fan,
 472                            HWMON_F_INPUT | HWMON_F_FAULT,
 473                            HWMON_F_INPUT | HWMON_F_FAULT,
 474                            HWMON_F_INPUT | HWMON_F_FAULT,
 475                            HWMON_F_INPUT | HWMON_F_FAULT,
 476                            HWMON_F_INPUT | HWMON_F_FAULT),
 477         HWMON_CHANNEL_INFO(pwm,
 478                            HWMON_PWM_INPUT,
 479                            HWMON_PWM_INPUT,
 480                            HWMON_PWM_INPUT,
 481                            HWMON_PWM_INPUT,
 482                            HWMON_PWM_INPUT),
 483         NULL
 484 };
 485
 486 static const struct hwmon_chip_info emc2305_chip_info = {
 487         .ops = &emc2305_ops,
 488         .info = emc2305_info,
 489 };
 490
 491 static int emc2305_identify(struct device *dev)
 492 {
 493         struct i2c_client *client = to_i2c_client(dev);
 494         struct emc2305_data *data = i2c_get_clientdata(client);
 495         int ret;
 496
 497         ret = i2c_smbus_read_byte_data(client, EMC2305_REG_PRODUCT_ID);
 498         if (ret < 0)
 499                 return ret;
 500
 501         switch (ret) {
 502         case EMC2305:
 503                 data->pwm_num = 5;
 504                 break;
 505         case EMC2303:
 506                 data->pwm_num = 3;
 507                 break;
 508         case EMC2302:
 509                 data->pwm_num = 2;
 510                 break;
 511         case EMC2301:
 512                 data->pwm_num = 1;
 513                 break;
 514         default:
 515                 return -ENODEV;
 516         }
 517
 518         return 0;
 519 }
 520
 521 static int emc2305_probe(struct i2c_client *client, const struct i2c_device_id *id)
 522 {
 523         struct i2c_adapter *adapter = client->adapter;
 524         struct device *dev = &client->dev;
 525         struct emc2305_data *data;
 526         struct emc2305_platform_data *pdata;
 527         int vendor, device;
 528         int ret;
 529         int i;
 530
 531         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
 532                 return -ENODEV;
 533
 534         vendor = i2c_smbus_read_byte_data(client, EMC2305_REG_VENDOR);
 535         if (vendor != EMC2305_VENDOR)
 536                 return -ENODEV;
 537
 538         device = i2c_smbus_read_byte_data(client, EMC2305_REG_DEVICE);
 539         if (device != EMC2305_DEVICE)
 540                 return -ENODEV;
 541
 542         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 543         if (!data)
 544                 return -ENOMEM;
 545
 546         i2c_set_clientdata(client, data);
 547         data->client = client;
 548
 549         ret = emc2305_identify(dev);
 550         if (ret)
 551                 return ret;
 552
 553         pdata = dev_get_platdata(&client->dev);
 554         if (pdata) {
 555                 if (!pdata->max_state || pdata->max_state > EMC2305_FAN_MAX_STATE)
 556                         return -EINVAL;
 557                 data->max_state = pdata->max_state;
 558                 /*
 559                  * Validate a number of active PWM channels. Note that
 560                  * configured number can be less than the actual maximum
 561                  * supported by the device.
 562                  */
 563                 if (!pdata->pwm_num || pdata->pwm_num > EMC2305_PWM_MAX)
 564                         return -EINVAL;
 565                 data->pwm_num = pdata->pwm_num;
 566                 data->pwm_separate = pdata->pwm_separate;
 567                 for (i = 0; i < EMC2305_PWM_MAX; i++)
 568                         data->pwm_min[i] = pdata->pwm_min[i];
 569         } else {
 570                 data->max_state = EMC2305_FAN_MAX_STATE;
 571                 data->pwm_separate = false;
 572                 for (i = 0; i < EMC2305_PWM_MAX; i++)
 573                         data->pwm_min[i] = EMC2305_FAN_MIN;
 574         }
 575
 576         data->hwmon_dev = devm_hwmon_device_register_with_info(dev, "emc2305", data,
 577                                                                &emc2305_chip_info, NULL);
 578         if (IS_ERR(data->hwmon_dev))
 579                 return PTR_ERR(data->hwmon_dev);
 580
 581         if (IS_REACHABLE(CONFIG_THERMAL)) {
 582                 ret = emc2305_set_tz(dev);
 583                 if (ret != 0)
 584                         return ret;
 585         }
 586
 587         for (i = 0; i < data->pwm_num; i++) {
 588                 ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_MIN_DRIVE(i),
 589                                                 data->pwm_min[i]);
 590                 if (ret < 0)
 591                         return ret;
 592         }
 593
 594         return 0;
 595 }
 596
 597 static void emc2305_remove(struct i2c_client *client)
 598 {
 599         struct device *dev = &client->dev;
 600
 601         if (IS_REACHABLE(CONFIG_THERMAL))
 602                 emc2305_unset_tz(dev);
 603 }
 604
 605 static struct i2c_driver emc2305_driver = {
 606         .class  = I2C_CLASS_HWMON,
 607         .driver = {
 608                 .name = "emc2305",
 609         },
 610         .probe    = emc2305_probe,
 611         .remove   = emc2305_remove,
 612         .id_table = emc2305_ids,
 613         .address_list = emc2305_normal_i2c,
 614 };
 615
 616 module_i2c_driver(emc2305_driver);
 617
 618 MODULE_AUTHOR("Nvidia");
 619 MODULE_DESCRIPTION("Microchip EMC2305 fan controller driver");
 620 MODULE_LICENSE("GPL");