drivers/hwmon/max31790.c

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