1321 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * A hwmon driver for the Analog Devices ADT74704 * Copyright (C) 2007 IBM5 *6 * Author: Darrick J. Wong <darrick.wong@oracle.com>7 */8 9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt10 11#include <linux/module.h>12#include <linux/jiffies.h>13#include <linux/i2c.h>14#include <linux/hwmon.h>15#include <linux/hwmon-sysfs.h>16#include <linux/err.h>17#include <linux/mutex.h>18#include <linux/delay.h>19#include <linux/log2.h>20#include <linux/kthread.h>21#include <linux/regmap.h>22#include <linux/sched.h>23#include <linux/slab.h>24#include <linux/util_macros.h>25 26/* Addresses to scan */27static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };28 29/* ADT7470 registers */30#define ADT7470_REG_BASE_ADDR 0x2031#define ADT7470_REG_TEMP_BASE_ADDR 0x2032#define ADT7470_REG_TEMP_MAX_ADDR 0x2933#define ADT7470_REG_FAN_BASE_ADDR 0x2A34#define ADT7470_REG_FAN_MAX_ADDR 0x3135#define ADT7470_REG_PWM_BASE_ADDR 0x3236#define ADT7470_REG_PWM_MAX_ADDR 0x3537#define ADT7470_REG_PWM_MAX_BASE_ADDR 0x3838#define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B39#define ADT7470_REG_CFG 0x4040#define ADT7470_STRT_MASK 0x0141#define ADT7470_TEST_MASK 0x0242#define ADT7470_FSPD_MASK 0x0443#define ADT7470_T05_STB_MASK 0x8044#define ADT7470_REG_ALARM1 0x4145#define ADT7470_R1T_ALARM 0x0146#define ADT7470_R2T_ALARM 0x0247#define ADT7470_R3T_ALARM 0x0448#define ADT7470_R4T_ALARM 0x0849#define ADT7470_R5T_ALARM 0x1050#define ADT7470_R6T_ALARM 0x2051#define ADT7470_R7T_ALARM 0x4052#define ADT7470_OOL_ALARM 0x8053#define ADT7470_REG_ALARM2 0x4254#define ADT7470_R8T_ALARM 0x0155#define ADT7470_R9T_ALARM 0x0256#define ADT7470_R10T_ALARM 0x0457#define ADT7470_FAN1_ALARM 0x1058#define ADT7470_FAN2_ALARM 0x2059#define ADT7470_FAN3_ALARM 0x4060#define ADT7470_FAN4_ALARM 0x8061#define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x4462#define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x5763#define ADT7470_REG_FAN_MIN_BASE_ADDR 0x5864#define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F65#define ADT7470_REG_FAN_MAX_BASE_ADDR 0x6066#define ADT7470_REG_FAN_MAX_MAX_ADDR 0x6767#define ADT7470_REG_PWM_CFG_BASE_ADDR 0x6868#define ADT7470_REG_PWM12_CFG 0x6869#define ADT7470_PWM2_AUTO_MASK 0x4070#define ADT7470_PWM1_AUTO_MASK 0x8071#define ADT7470_PWM_AUTO_MASK 0xC072#define ADT7470_REG_PWM34_CFG 0x6973#define ADT7470_PWM3_AUTO_MASK 0x4074#define ADT7470_PWM4_AUTO_MASK 0x8075#define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A76#define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D77#define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E78#define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x7179#define ADT7470_REG_CFG_2 0x7480#define ADT7470_REG_ACOUSTICS12 0x7581#define ADT7470_REG_ACOUSTICS34 0x7682#define ADT7470_REG_DEVICE 0x3D83#define ADT7470_REG_VENDOR 0x3E84#define ADT7470_REG_REVISION 0x3F85#define ADT7470_REG_ALARM1_MASK 0x7286#define ADT7470_REG_ALARM2_MASK 0x7387#define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C88#define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D89#define ADT7470_REG_MAX_ADDR 0x8190 91#define ADT7470_TEMP_COUNT 1092#define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))93#define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))94#define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \95 ((x) * 2) + 1)96 97#define ADT7470_FAN_COUNT 498#define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))99#define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))100#define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))101 102#define ADT7470_PWM_COUNT 4103#define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x))104#define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))105#define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))106#define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))107#define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))108#define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \109 ((x) / 2))110 111#define ALARM2(x) ((x) << 8)112 113#define ADT7470_VENDOR 0x41114#define ADT7470_DEVICE 0x70115/* datasheet only mentions a revision 2 */116#define ADT7470_REVISION 0x02117 118/* "all temps" according to hwmon sysfs interface spec */119#define ADT7470_PWM_ALL_TEMPS 0x3FF120 121/* How often do we reread sensors values? (In jiffies) */122#define SENSOR_REFRESH_INTERVAL (5 * HZ)123 124/* How often do we reread sensor limit values? (In jiffies) */125#define LIMIT_REFRESH_INTERVAL (60 * HZ)126 127/* Wait at least 200ms per sensor for 10 sensors */128#define TEMP_COLLECTION_TIME 2000129 130/* auto update thing won't fire more than every 2s */131#define AUTO_UPDATE_INTERVAL 2000132 133/* datasheet says to divide this number by the fan reading to get fan rpm */134#define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))135#define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM136#define FAN_PERIOD_INVALID 65535137#define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)138 139/* Config registers 1 and 2 include fields for selecting the PWM frequency */140#define ADT7470_CFG_LF 0x40141#define ADT7470_FREQ_MASK 0x70142#define ADT7470_FREQ_SHIFT 4143 144struct adt7470_data {145 struct regmap *regmap;146 struct mutex lock;147 char sensors_valid;148 char limits_valid;149 unsigned long sensors_last_updated; /* In jiffies */150 unsigned long limits_last_updated; /* In jiffies */151 152 int num_temp_sensors; /* -1 = probe */153 int temperatures_probed;154 155 s8 temp[ADT7470_TEMP_COUNT];156 s8 temp_min[ADT7470_TEMP_COUNT];157 s8 temp_max[ADT7470_TEMP_COUNT];158 u16 fan[ADT7470_FAN_COUNT];159 u16 fan_min[ADT7470_FAN_COUNT];160 u16 fan_max[ADT7470_FAN_COUNT];161 u16 alarm;162 u16 alarms_mask;163 u8 force_pwm_max;164 u8 pwm[ADT7470_PWM_COUNT];165 u8 pwm_max[ADT7470_PWM_COUNT];166 u8 pwm_automatic[ADT7470_PWM_COUNT];167 u8 pwm_min[ADT7470_PWM_COUNT];168 s8 pwm_tmin[ADT7470_PWM_COUNT];169 u8 pwm_auto_temp[ADT7470_PWM_COUNT];170 171 struct task_struct *auto_update;172 unsigned int auto_update_interval;173};174 175/*176 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says177 * that the low byte must be read before the high byte.178 */179static inline int adt7470_read_word_data(struct adt7470_data *data, unsigned int reg,180 unsigned int *val)181{182 u8 regval[2];183 int err;184 185 err = regmap_bulk_read(data->regmap, reg, ®val, 2);186 if (err < 0)187 return err;188 189 *val = regval[0] | (regval[1] << 8);190 191 return 0;192}193 194static inline int adt7470_write_word_data(struct adt7470_data *data, unsigned int reg,195 unsigned int val)196{197 u8 regval[2];198 199 regval[0] = val & 0xFF;200 regval[1] = val >> 8;201 202 return regmap_bulk_write(data->regmap, reg, ®val, 2);203}204 205/* Probe for temperature sensors. Assumes lock is held */206static int adt7470_read_temperatures(struct adt7470_data *data)207{208 unsigned long res;209 unsigned int pwm_cfg[2];210 int err;211 int i;212 u8 pwm[ADT7470_FAN_COUNT];213 214 /* save pwm[1-4] config register */215 err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(0), &pwm_cfg[0]);216 if (err < 0)217 return err;218 err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(2), &pwm_cfg[1]);219 if (err < 0)220 return err;221 222 /* set manual pwm to whatever it is set to now */223 err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &pwm[0],224 ADT7470_PWM_COUNT);225 if (err < 0)226 return err;227 228 /* put pwm in manual mode */229 err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(0),230 ADT7470_PWM_AUTO_MASK, 0);231 if (err < 0)232 return err;233 err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(2),234 ADT7470_PWM_AUTO_MASK, 0);235 if (err < 0)236 return err;237 238 /* write pwm control to whatever it was */239 err = regmap_bulk_write(data->regmap, ADT7470_REG_PWM(0), &pwm[0],240 ADT7470_PWM_COUNT);241 if (err < 0)242 return err;243 244 /* start reading temperature sensors */245 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,246 ADT7470_T05_STB_MASK, ADT7470_T05_STB_MASK);247 if (err < 0)248 return err;249 250 /* Delay is 200ms * number of temp sensors. */251 res = msleep_interruptible((data->num_temp_sensors >= 0 ?252 data->num_temp_sensors * 200 :253 TEMP_COLLECTION_TIME));254 255 /* done reading temperature sensors */256 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,257 ADT7470_T05_STB_MASK, 0);258 if (err < 0)259 return err;260 261 /* restore pwm[1-4] config registers */262 err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);263 if (err < 0)264 return err;265 err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);266 if (err < 0)267 return err;268 269 if (res)270 return -EAGAIN;271 272 /* Only count fans if we have to */273 if (data->num_temp_sensors >= 0)274 return 0;275 276 err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],277 ADT7470_TEMP_COUNT);278 if (err < 0)279 return err;280 for (i = 0; i < ADT7470_TEMP_COUNT; i++) {281 if (data->temp[i])282 data->num_temp_sensors = i + 1;283 }284 data->temperatures_probed = 1;285 return 0;286}287 288static int adt7470_update_thread(void *p)289{290 struct i2c_client *client = p;291 struct adt7470_data *data = i2c_get_clientdata(client);292 293 while (!kthread_should_stop()) {294 mutex_lock(&data->lock);295 adt7470_read_temperatures(data);296 mutex_unlock(&data->lock);297 298 if (kthread_should_stop())299 break;300 301 schedule_timeout_interruptible(msecs_to_jiffies(data->auto_update_interval));302 }303 304 return 0;305}306 307static int adt7470_update_sensors(struct adt7470_data *data)308{309 unsigned int val;310 int err;311 int i;312 313 if (!data->temperatures_probed)314 err = adt7470_read_temperatures(data);315 else316 err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],317 ADT7470_TEMP_COUNT);318 if (err < 0)319 return err;320 321 for (i = 0; i < ADT7470_FAN_COUNT; i++) {322 err = adt7470_read_word_data(data, ADT7470_REG_FAN(i), &val);323 if (err < 0)324 return err;325 data->fan[i] = val;326 }327 328 err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &data->pwm[0], ADT7470_PWM_COUNT);329 if (err < 0)330 return err;331 332 for (i = 0; i < ADT7470_PWM_COUNT; i++) {333 unsigned int mask;334 335 if (i % 2)336 mask = ADT7470_PWM2_AUTO_MASK;337 else338 mask = ADT7470_PWM1_AUTO_MASK;339 340 err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(i), &val);341 if (err < 0)342 return err;343 data->pwm_automatic[i] = !!(val & mask);344 345 err = regmap_read(data->regmap, ADT7470_REG_PWM_AUTO_TEMP(i), &val);346 if (err < 0)347 return err;348 if (!(i % 2))349 data->pwm_auto_temp[i] = val >> 4;350 else351 data->pwm_auto_temp[i] = val & 0xF;352 }353 354 err = regmap_read(data->regmap, ADT7470_REG_CFG, &val);355 if (err < 0)356 return err;357 data->force_pwm_max = !!(val & ADT7470_FSPD_MASK);358 359 err = regmap_read(data->regmap, ADT7470_REG_ALARM1, &val);360 if (err < 0)361 return err;362 data->alarm = val;363 if (data->alarm & ADT7470_OOL_ALARM) {364 err = regmap_read(data->regmap, ADT7470_REG_ALARM2, &val);365 if (err < 0)366 return err;367 data->alarm |= ALARM2(val);368 }369 370 err = adt7470_read_word_data(data, ADT7470_REG_ALARM1_MASK, &val);371 if (err < 0)372 return err;373 data->alarms_mask = val;374 375 return 0;376}377 378static int adt7470_update_limits(struct adt7470_data *data)379{380 unsigned int val;381 int err;382 int i;383 384 for (i = 0; i < ADT7470_TEMP_COUNT; i++) {385 err = regmap_read(data->regmap, ADT7470_TEMP_MIN_REG(i), &val);386 if (err < 0)387 return err;388 data->temp_min[i] = (s8)val;389 err = regmap_read(data->regmap, ADT7470_TEMP_MAX_REG(i), &val);390 if (err < 0)391 return err;392 data->temp_max[i] = (s8)val;393 }394 395 for (i = 0; i < ADT7470_FAN_COUNT; i++) {396 err = adt7470_read_word_data(data, ADT7470_REG_FAN_MIN(i), &val);397 if (err < 0)398 return err;399 data->fan_min[i] = val;400 err = adt7470_read_word_data(data, ADT7470_REG_FAN_MAX(i), &val);401 if (err < 0)402 return err;403 data->fan_max[i] = val;404 }405 406 for (i = 0; i < ADT7470_PWM_COUNT; i++) {407 err = regmap_read(data->regmap, ADT7470_REG_PWM_MAX(i), &val);408 if (err < 0)409 return err;410 data->pwm_max[i] = val;411 err = regmap_read(data->regmap, ADT7470_REG_PWM_MIN(i), &val);412 if (err < 0)413 return err;414 data->pwm_min[i] = val;415 err = regmap_read(data->regmap, ADT7470_REG_PWM_TMIN(i), &val);416 if (err < 0)417 return err;418 data->pwm_tmin[i] = (s8)val;419 }420 421 return 0;422}423 424static struct adt7470_data *adt7470_update_device(struct device *dev)425{426 struct adt7470_data *data = dev_get_drvdata(dev);427 unsigned long local_jiffies = jiffies;428 int need_sensors = 1;429 int need_limits = 1;430 int err;431 432 /*433 * Figure out if we need to update the shadow registers.434 * Lockless means that we may occasionally report out of435 * date data.436 */437 if (time_before(local_jiffies, data->sensors_last_updated +438 SENSOR_REFRESH_INTERVAL) &&439 data->sensors_valid)440 need_sensors = 0;441 442 if (time_before(local_jiffies, data->limits_last_updated +443 LIMIT_REFRESH_INTERVAL) &&444 data->limits_valid)445 need_limits = 0;446 447 if (!need_sensors && !need_limits)448 return data;449 450 mutex_lock(&data->lock);451 if (need_sensors) {452 err = adt7470_update_sensors(data);453 if (err < 0)454 goto out;455 data->sensors_last_updated = local_jiffies;456 data->sensors_valid = 1;457 }458 459 if (need_limits) {460 err = adt7470_update_limits(data);461 if (err < 0)462 goto out;463 data->limits_last_updated = local_jiffies;464 data->limits_valid = 1;465 }466out:467 mutex_unlock(&data->lock);468 469 return err < 0 ? ERR_PTR(err) : data;470}471 472static ssize_t auto_update_interval_show(struct device *dev,473 struct device_attribute *devattr,474 char *buf)475{476 struct adt7470_data *data = adt7470_update_device(dev);477 478 if (IS_ERR(data))479 return PTR_ERR(data);480 481 return sprintf(buf, "%d\n", data->auto_update_interval);482}483 484static ssize_t auto_update_interval_store(struct device *dev,485 struct device_attribute *devattr,486 const char *buf, size_t count)487{488 struct adt7470_data *data = dev_get_drvdata(dev);489 long temp;490 491 if (kstrtol(buf, 10, &temp))492 return -EINVAL;493 494 temp = clamp_val(temp, 0, 60000);495 496 mutex_lock(&data->lock);497 data->auto_update_interval = temp;498 mutex_unlock(&data->lock);499 500 return count;501}502 503static ssize_t num_temp_sensors_show(struct device *dev,504 struct device_attribute *devattr,505 char *buf)506{507 struct adt7470_data *data = adt7470_update_device(dev);508 509 if (IS_ERR(data))510 return PTR_ERR(data);511 512 return sprintf(buf, "%d\n", data->num_temp_sensors);513}514 515static ssize_t num_temp_sensors_store(struct device *dev,516 struct device_attribute *devattr,517 const char *buf, size_t count)518{519 struct adt7470_data *data = dev_get_drvdata(dev);520 long temp;521 522 if (kstrtol(buf, 10, &temp))523 return -EINVAL;524 525 temp = clamp_val(temp, -1, 10);526 527 mutex_lock(&data->lock);528 data->num_temp_sensors = temp;529 if (temp < 0)530 data->temperatures_probed = 0;531 mutex_unlock(&data->lock);532 533 return count;534}535 536static int adt7470_temp_read(struct device *dev, u32 attr, int channel, long *val)537{538 struct adt7470_data *data = adt7470_update_device(dev);539 540 if (IS_ERR(data))541 return PTR_ERR(data);542 543 switch (attr) {544 case hwmon_temp_input:545 *val = 1000 * data->temp[channel];546 break;547 case hwmon_temp_min:548 *val = 1000 * data->temp_min[channel];549 break;550 case hwmon_temp_max:551 *val = 1000 * data->temp_max[channel];552 break;553 case hwmon_temp_alarm:554 *val = !!(data->alarm & channel);555 break;556 default:557 return -EOPNOTSUPP;558 }559 560 return 0;561}562 563static int adt7470_temp_write(struct device *dev, u32 attr, int channel, long val)564{565 struct adt7470_data *data = dev_get_drvdata(dev);566 int err;567 568 val = clamp_val(val, -128000, 127000);569 val = DIV_ROUND_CLOSEST(val, 1000);570 571 switch (attr) {572 case hwmon_temp_min:573 mutex_lock(&data->lock);574 data->temp_min[channel] = val;575 err = regmap_write(data->regmap, ADT7470_TEMP_MIN_REG(channel), val);576 mutex_unlock(&data->lock);577 break;578 case hwmon_temp_max:579 mutex_lock(&data->lock);580 data->temp_max[channel] = val;581 err = regmap_write(data->regmap, ADT7470_TEMP_MAX_REG(channel), val);582 mutex_unlock(&data->lock);583 break;584 default:585 return -EOPNOTSUPP;586 }587 588 return err;589}590 591static ssize_t alarm_mask_show(struct device *dev,592 struct device_attribute *devattr, char *buf)593{594 struct adt7470_data *data = adt7470_update_device(dev);595 596 if (IS_ERR(data))597 return PTR_ERR(data);598 599 return sprintf(buf, "%x\n", data->alarms_mask);600}601 602static ssize_t alarm_mask_store(struct device *dev,603 struct device_attribute *devattr,604 const char *buf, size_t count)605{606 struct adt7470_data *data = dev_get_drvdata(dev);607 long mask;608 int err;609 610 if (kstrtoul(buf, 0, &mask))611 return -EINVAL;612 613 if (mask & ~0xffff)614 return -EINVAL;615 616 mutex_lock(&data->lock);617 data->alarms_mask = mask;618 err = adt7470_write_word_data(data, ADT7470_REG_ALARM1_MASK, mask);619 mutex_unlock(&data->lock);620 621 return err < 0 ? err : count;622}623 624static int adt7470_fan_read(struct device *dev, u32 attr, int channel, long *val)625{626 struct adt7470_data *data = adt7470_update_device(dev);627 628 if (IS_ERR(data))629 return PTR_ERR(data);630 631 switch (attr) {632 case hwmon_fan_input:633 if (FAN_DATA_VALID(data->fan[channel]))634 *val = FAN_PERIOD_TO_RPM(data->fan[channel]);635 else636 *val = 0;637 break;638 case hwmon_fan_min:639 if (FAN_DATA_VALID(data->fan_min[channel]))640 *val = FAN_PERIOD_TO_RPM(data->fan_min[channel]);641 else642 *val = 0;643 break;644 case hwmon_fan_max:645 if (FAN_DATA_VALID(data->fan_max[channel]))646 *val = FAN_PERIOD_TO_RPM(data->fan_max[channel]);647 else648 *val = 0;649 break;650 case hwmon_fan_alarm:651 *val = !!(data->alarm & (1 << (12 + channel)));652 break;653 default:654 return -EOPNOTSUPP;655 }656 657 return 0;658}659 660static int adt7470_fan_write(struct device *dev, u32 attr, int channel, long val)661{662 struct adt7470_data *data = dev_get_drvdata(dev);663 int err;664 665 if (val <= 0)666 return -EINVAL;667 668 val = FAN_RPM_TO_PERIOD(val);669 val = clamp_val(val, 1, 65534);670 671 switch (attr) {672 case hwmon_fan_min:673 mutex_lock(&data->lock);674 data->fan_min[channel] = val;675 err = adt7470_write_word_data(data, ADT7470_REG_FAN_MIN(channel), val);676 mutex_unlock(&data->lock);677 break;678 case hwmon_fan_max:679 mutex_lock(&data->lock);680 data->fan_max[channel] = val;681 err = adt7470_write_word_data(data, ADT7470_REG_FAN_MAX(channel), val);682 mutex_unlock(&data->lock);683 break;684 default:685 return -EOPNOTSUPP;686 }687 688 return err;689}690 691static ssize_t force_pwm_max_show(struct device *dev,692 struct device_attribute *devattr, char *buf)693{694 struct adt7470_data *data = adt7470_update_device(dev);695 696 if (IS_ERR(data))697 return PTR_ERR(data);698 699 return sprintf(buf, "%d\n", data->force_pwm_max);700}701 702static ssize_t force_pwm_max_store(struct device *dev,703 struct device_attribute *devattr,704 const char *buf, size_t count)705{706 struct adt7470_data *data = dev_get_drvdata(dev);707 long temp;708 int err;709 710 if (kstrtol(buf, 10, &temp))711 return -EINVAL;712 713 mutex_lock(&data->lock);714 data->force_pwm_max = temp;715 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,716 ADT7470_FSPD_MASK,717 temp ? ADT7470_FSPD_MASK : 0);718 mutex_unlock(&data->lock);719 720 return err < 0 ? err : count;721}722 723/* These are the valid PWM frequencies to the nearest Hz */724static const int adt7470_freq_map[] = {725 11, 15, 22, 29, 35, 44, 59, 88, 1400, 22500726};727 728static int pwm1_freq_get(struct device *dev)729{730 struct adt7470_data *data = dev_get_drvdata(dev);731 unsigned int regs[2] = {ADT7470_REG_CFG, ADT7470_REG_CFG_2};732 u8 cfg_reg[2];733 int index;734 int err;735 736 err = regmap_multi_reg_read(data->regmap, regs, cfg_reg, 2);737 if (err)738 return err;739 740 index = (cfg_reg[1] & ADT7470_FREQ_MASK) >> ADT7470_FREQ_SHIFT;741 if (!(cfg_reg[0] & ADT7470_CFG_LF))742 index += 8;743 if (index >= ARRAY_SIZE(adt7470_freq_map))744 index = ARRAY_SIZE(adt7470_freq_map) - 1;745 746 return adt7470_freq_map[index];747}748 749static int adt7470_pwm_read(struct device *dev, u32 attr, int channel, long *val)750{751 struct adt7470_data *data = adt7470_update_device(dev);752 753 if (IS_ERR(data))754 return PTR_ERR(data);755 756 switch (attr) {757 case hwmon_pwm_input:758 *val = data->pwm[channel];759 break;760 case hwmon_pwm_enable:761 *val = 1 + data->pwm_automatic[channel];762 break;763 case hwmon_pwm_freq:764 *val = pwm1_freq_get(dev);765 break;766 default:767 return -EOPNOTSUPP;768 }769 770 return 0;771}772 773static int pwm1_freq_set(struct device *dev, long freq)774{775 struct adt7470_data *data = dev_get_drvdata(dev);776 unsigned int low_freq = ADT7470_CFG_LF;777 int index;778 int err;779 780 /* Round the user value given to the closest available frequency */781 index = find_closest(freq, adt7470_freq_map,782 ARRAY_SIZE(adt7470_freq_map));783 784 if (index >= 8) {785 index -= 8;786 low_freq = 0;787 }788 789 mutex_lock(&data->lock);790 /* Configuration Register 1 */791 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,792 ADT7470_CFG_LF, low_freq);793 if (err < 0)794 goto out;795 796 /* Configuration Register 2 */797 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG_2,798 ADT7470_FREQ_MASK,799 index << ADT7470_FREQ_SHIFT);800out:801 mutex_unlock(&data->lock);802 803 return err;804}805 806static int adt7470_pwm_write(struct device *dev, u32 attr, int channel, long val)807{808 struct adt7470_data *data = dev_get_drvdata(dev);809 unsigned int pwm_auto_reg_mask;810 int err;811 812 switch (attr) {813 case hwmon_pwm_input:814 val = clamp_val(val, 0, 255);815 mutex_lock(&data->lock);816 data->pwm[channel] = val;817 err = regmap_write(data->regmap, ADT7470_REG_PWM(channel),818 data->pwm[channel]);819 mutex_unlock(&data->lock);820 break;821 case hwmon_pwm_enable:822 if (channel % 2)823 pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;824 else825 pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;826 827 if (val != 2 && val != 1)828 return -EINVAL;829 val--;830 831 mutex_lock(&data->lock);832 data->pwm_automatic[channel] = val;833 err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(channel),834 pwm_auto_reg_mask,835 val ? pwm_auto_reg_mask : 0);836 mutex_unlock(&data->lock);837 break;838 case hwmon_pwm_freq:839 err = pwm1_freq_set(dev, val);840 break;841 default:842 return -EOPNOTSUPP;843 }844 845 return err;846}847 848static ssize_t pwm_max_show(struct device *dev,849 struct device_attribute *devattr, char *buf)850{851 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);852 struct adt7470_data *data = adt7470_update_device(dev);853 854 if (IS_ERR(data))855 return PTR_ERR(data);856 857 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);858}859 860static ssize_t pwm_max_store(struct device *dev,861 struct device_attribute *devattr,862 const char *buf, size_t count)863{864 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);865 struct adt7470_data *data = dev_get_drvdata(dev);866 long temp;867 int err;868 869 if (kstrtol(buf, 10, &temp))870 return -EINVAL;871 872 temp = clamp_val(temp, 0, 255);873 874 mutex_lock(&data->lock);875 data->pwm_max[attr->index] = temp;876 err = regmap_write(data->regmap, ADT7470_REG_PWM_MAX(attr->index),877 temp);878 mutex_unlock(&data->lock);879 880 return err < 0 ? err : count;881}882 883static ssize_t pwm_min_show(struct device *dev,884 struct device_attribute *devattr, char *buf)885{886 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);887 struct adt7470_data *data = adt7470_update_device(dev);888 889 if (IS_ERR(data))890 return PTR_ERR(data);891 892 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);893}894 895static ssize_t pwm_min_store(struct device *dev,896 struct device_attribute *devattr,897 const char *buf, size_t count)898{899 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);900 struct adt7470_data *data = dev_get_drvdata(dev);901 long temp;902 int err;903 904 if (kstrtol(buf, 10, &temp))905 return -EINVAL;906 907 temp = clamp_val(temp, 0, 255);908 909 mutex_lock(&data->lock);910 data->pwm_min[attr->index] = temp;911 err = regmap_write(data->regmap, ADT7470_REG_PWM_MIN(attr->index),912 temp);913 mutex_unlock(&data->lock);914 915 return err < 0 ? err : count;916}917 918static ssize_t pwm_tmax_show(struct device *dev,919 struct device_attribute *devattr, char *buf)920{921 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);922 struct adt7470_data *data = adt7470_update_device(dev);923 924 if (IS_ERR(data))925 return PTR_ERR(data);926 927 /* the datasheet says that tmax = tmin + 20C */928 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));929}930 931static ssize_t pwm_tmin_show(struct device *dev,932 struct device_attribute *devattr, char *buf)933{934 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);935 struct adt7470_data *data = adt7470_update_device(dev);936 937 if (IS_ERR(data))938 return PTR_ERR(data);939 940 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);941}942 943static ssize_t pwm_tmin_store(struct device *dev,944 struct device_attribute *devattr,945 const char *buf, size_t count)946{947 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);948 struct adt7470_data *data = dev_get_drvdata(dev);949 long temp;950 int err;951 952 if (kstrtol(buf, 10, &temp))953 return -EINVAL;954 955 temp = clamp_val(temp, -128000, 127000);956 temp = DIV_ROUND_CLOSEST(temp, 1000);957 958 mutex_lock(&data->lock);959 data->pwm_tmin[attr->index] = temp;960 err = regmap_write(data->regmap, ADT7470_REG_PWM_TMIN(attr->index),961 temp);962 mutex_unlock(&data->lock);963 964 return err < 0 ? err : count;965}966 967static ssize_t pwm_auto_temp_show(struct device *dev,968 struct device_attribute *devattr, char *buf)969{970 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);971 struct adt7470_data *data = adt7470_update_device(dev);972 u8 ctrl;973 974 if (IS_ERR(data))975 return PTR_ERR(data);976 977 ctrl = data->pwm_auto_temp[attr->index];978 if (ctrl)979 return sprintf(buf, "%d\n", 1 << (ctrl - 1));980 else981 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);982}983 984static int cvt_auto_temp(int input)985{986 if (input == ADT7470_PWM_ALL_TEMPS)987 return 0;988 if (input < 1 || !is_power_of_2(input))989 return -EINVAL;990 return ilog2(input) + 1;991}992 993static ssize_t pwm_auto_temp_store(struct device *dev,994 struct device_attribute *devattr,995 const char *buf, size_t count)996{997 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);998 struct adt7470_data *data = dev_get_drvdata(dev);999 int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);1000 unsigned int mask, val;1001 long temp;1002 int err;1003 1004 if (kstrtol(buf, 10, &temp))1005 return -EINVAL;1006 1007 temp = cvt_auto_temp(temp);1008 if (temp < 0)1009 return temp;1010 1011 mutex_lock(&data->lock);1012 data->pwm_automatic[attr->index] = temp;1013 1014 if (!(attr->index % 2)) {1015 mask = 0xF0;1016 val = (temp << 4) & 0xF0;1017 } else {1018 mask = 0x0F;1019 val = temp & 0x0F;1020 }1021 1022 err = regmap_update_bits(data->regmap, pwm_auto_reg, mask, val);1023 mutex_unlock(&data->lock);1024 1025 return err < 0 ? err : count;1026}1027 1028static DEVICE_ATTR_RW(alarm_mask);1029static DEVICE_ATTR_RW(num_temp_sensors);1030static DEVICE_ATTR_RW(auto_update_interval);1031 1032static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);1033 1034static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);1035static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);1036static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);1037static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);1038 1039static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);1040static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);1041static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);1042static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);1043 1044static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp, pwm_tmin, 0);1045static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_temp, pwm_tmin, 1);1046static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_temp, pwm_tmin, 2);1047static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_temp, pwm_tmin, 3);1048 1049static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_temp, pwm_tmax, 0);1050static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point2_temp, pwm_tmax, 1);1051static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point2_temp, pwm_tmax, 2);1052static SENSOR_DEVICE_ATTR_RO(pwm4_auto_point2_temp, pwm_tmax, 3);1053 1054static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);1055static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);1056static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);1057static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);1058 1059static struct attribute *adt7470_attrs[] = {1060 &dev_attr_alarm_mask.attr,1061 &dev_attr_num_temp_sensors.attr,1062 &dev_attr_auto_update_interval.attr,1063 &sensor_dev_attr_force_pwm_max.dev_attr.attr,1064 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,1065 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,1066 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,1067 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,1068 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,1069 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,1070 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,1071 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,1072 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,1073 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,1074 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,1075 &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,1076 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,1077 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,1078 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,1079 &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,1080 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,1081 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,1082 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,1083 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,1084 NULL1085};1086 1087ATTRIBUTE_GROUPS(adt7470);1088 1089static int adt7470_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,1090 int channel, long *val)1091{1092 switch (type) {1093 case hwmon_temp:1094 return adt7470_temp_read(dev, attr, channel, val);1095 case hwmon_fan:1096 return adt7470_fan_read(dev, attr, channel, val);1097 case hwmon_pwm:1098 return adt7470_pwm_read(dev, attr, channel, val);1099 default:1100 return -EOPNOTSUPP;1101 }1102}1103 1104static int adt7470_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,1105 int channel, long val)1106{1107 switch (type) {1108 case hwmon_temp:1109 return adt7470_temp_write(dev, attr, channel, val);1110 case hwmon_fan:1111 return adt7470_fan_write(dev, attr, channel, val);1112 case hwmon_pwm:1113 return adt7470_pwm_write(dev, attr, channel, val);1114 default:1115 return -EOPNOTSUPP;1116 }1117}1118 1119static umode_t adt7470_is_visible(const void *_data, enum hwmon_sensor_types type,1120 u32 attr, int channel)1121{1122 umode_t mode = 0;1123 1124 switch (type) {1125 case hwmon_temp:1126 switch (attr) {1127 case hwmon_temp:1128 case hwmon_temp_alarm:1129 mode = 0444;1130 break;1131 case hwmon_temp_min:1132 case hwmon_temp_max:1133 mode = 0644;1134 break;1135 default:1136 break;1137 }1138 break;1139 case hwmon_fan:1140 switch (attr) {1141 case hwmon_fan_input:1142 case hwmon_fan_alarm:1143 mode = 0444;1144 break;1145 case hwmon_fan_min:1146 case hwmon_fan_max:1147 mode = 0644;1148 break;1149 default:1150 break;1151 }1152 break;1153 case hwmon_pwm:1154 switch (attr) {1155 case hwmon_pwm_input:1156 case hwmon_pwm_enable:1157 mode = 0644;1158 break;1159 case hwmon_pwm_freq:1160 if (channel == 0)1161 mode = 0644;1162 else1163 mode = 0;1164 break;1165 default:1166 break;1167 }1168 break;1169 default:1170 break;1171 }1172 1173 return mode;1174}1175 1176static const struct hwmon_ops adt7470_hwmon_ops = {1177 .is_visible = adt7470_is_visible,1178 .read = adt7470_read,1179 .write = adt7470_write,1180};1181 1182static const struct hwmon_channel_info * const adt7470_info[] = {1183 HWMON_CHANNEL_INFO(temp,1184 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1185 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1186 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1187 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1188 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1189 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1190 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1191 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1192 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,1193 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM),1194 HWMON_CHANNEL_INFO(fan,1195 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,1196 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,1197 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,1198 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM),1199 HWMON_CHANNEL_INFO(pwm,1200 HWMON_PWM_INPUT | HWMON_PWM_ENABLE | HWMON_PWM_FREQ,1201 HWMON_PWM_INPUT | HWMON_PWM_ENABLE,1202 HWMON_PWM_INPUT | HWMON_PWM_ENABLE,1203 HWMON_PWM_INPUT | HWMON_PWM_ENABLE),1204 NULL1205};1206 1207static const struct hwmon_chip_info adt7470_chip_info = {1208 .ops = &adt7470_hwmon_ops,1209 .info = adt7470_info,1210};1211 1212/* Return 0 if detection is successful, -ENODEV otherwise */1213static int adt7470_detect(struct i2c_client *client,1214 struct i2c_board_info *info)1215{1216 struct i2c_adapter *adapter = client->adapter;1217 int vendor, device, revision;1218 1219 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))1220 return -ENODEV;1221 1222 vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);1223 if (vendor != ADT7470_VENDOR)1224 return -ENODEV;1225 1226 device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);1227 if (device != ADT7470_DEVICE)1228 return -ENODEV;1229 1230 revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION);1231 if (revision != ADT7470_REVISION)1232 return -ENODEV;1233 1234 strscpy(info->type, "adt7470", I2C_NAME_SIZE);1235 1236 return 0;1237}1238 1239static const struct regmap_config adt7470_regmap_config = {1240 .reg_bits = 8,1241 .val_bits = 8,1242 .use_single_read = true,1243 .use_single_write = true,1244};1245 1246static int adt7470_probe(struct i2c_client *client)1247{1248 struct device *dev = &client->dev;1249 struct adt7470_data *data;1250 struct device *hwmon_dev;1251 int err;1252 1253 data = devm_kzalloc(dev, sizeof(struct adt7470_data), GFP_KERNEL);1254 if (!data)1255 return -ENOMEM;1256 1257 data->num_temp_sensors = -1;1258 data->auto_update_interval = AUTO_UPDATE_INTERVAL;1259 data->regmap = devm_regmap_init_i2c(client, &adt7470_regmap_config);1260 if (IS_ERR(data->regmap))1261 return PTR_ERR(data->regmap);1262 1263 i2c_set_clientdata(client, data);1264 mutex_init(&data->lock);1265 1266 dev_info(&client->dev, "%s chip found\n", client->name);1267 1268 /* Initialize the ADT7470 chip */1269 err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,1270 ADT7470_STRT_MASK | ADT7470_TEST_MASK,1271 ADT7470_STRT_MASK | ADT7470_TEST_MASK);1272 if (err < 0)1273 return err;1274 1275 /* Register sysfs hooks */1276 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,1277 &adt7470_chip_info,1278 adt7470_groups);1279 1280 if (IS_ERR(hwmon_dev))1281 return PTR_ERR(hwmon_dev);1282 1283 data->auto_update = kthread_run(adt7470_update_thread, client, "%s",1284 dev_name(hwmon_dev));1285 if (IS_ERR(data->auto_update))1286 return PTR_ERR(data->auto_update);1287 1288 return 0;1289}1290 1291static void adt7470_remove(struct i2c_client *client)1292{1293 struct adt7470_data *data = i2c_get_clientdata(client);1294 1295 kthread_stop(data->auto_update);1296}1297 1298static const struct i2c_device_id adt7470_id[] = {1299 { "adt7470" },1300 { }1301};1302MODULE_DEVICE_TABLE(i2c, adt7470_id);1303 1304static struct i2c_driver adt7470_driver = {1305 .class = I2C_CLASS_HWMON,1306 .driver = {1307 .name = "adt7470",1308 },1309 .probe = adt7470_probe,1310 .remove = adt7470_remove,1311 .id_table = adt7470_id,1312 .detect = adt7470_detect,1313 .address_list = normal_i2c,1314};1315 1316module_i2c_driver(adt7470_driver);1317 1318MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");1319MODULE_DESCRIPTION("ADT7470 driver");1320MODULE_LICENSE("GPL");1321