1709 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * lm85.c - Part of lm_sensors, Linux kernel modules for hardware4 * monitoring5 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>6 * Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com>7 * Copyright (c) 2003 Margit Schubert-While <margitsw@t-online.de>8 * Copyright (c) 2004 Justin Thiessen <jthiessen@penguincomputing.com>9 * Copyright (C) 2007--2014 Jean Delvare <jdelvare@suse.de>10 *11 * Chip details at <http://www.national.com/ds/LM/LM85.pdf>12 */13 14#include <linux/module.h>15#include <linux/of.h>16#include <linux/init.h>17#include <linux/slab.h>18#include <linux/jiffies.h>19#include <linux/i2c.h>20#include <linux/hwmon.h>21#include <linux/hwmon-vid.h>22#include <linux/hwmon-sysfs.h>23#include <linux/err.h>24#include <linux/mutex.h>25#include <linux/util_macros.h>26 27/* Addresses to scan */28static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };29 30enum chips {31 lm85, lm96000,32 adm1027, adt7463, adt7468,33 emc6d100, emc6d102, emc6d103, emc6d103s34};35 36/* The LM85 registers */37 38#define LM85_REG_IN(nr) (0x20 + (nr))39#define LM85_REG_IN_MIN(nr) (0x44 + (nr) * 2)40#define LM85_REG_IN_MAX(nr) (0x45 + (nr) * 2)41 42#define LM85_REG_TEMP(nr) (0x25 + (nr))43#define LM85_REG_TEMP_MIN(nr) (0x4e + (nr) * 2)44#define LM85_REG_TEMP_MAX(nr) (0x4f + (nr) * 2)45 46/* Fan speeds are LSB, MSB (2 bytes) */47#define LM85_REG_FAN(nr) (0x28 + (nr) * 2)48#define LM85_REG_FAN_MIN(nr) (0x54 + (nr) * 2)49 50#define LM85_REG_PWM(nr) (0x30 + (nr))51 52#define LM85_REG_COMPANY 0x3e53#define LM85_REG_VERSTEP 0x3f54 55#define ADT7468_REG_CFG5 0x7c56#define ADT7468_OFF64 (1 << 0)57#define ADT7468_HFPWM (1 << 1)58#define IS_ADT7468_OFF64(data) \59 ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_OFF64))60#define IS_ADT7468_HFPWM(data) \61 ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_HFPWM))62 63/* These are the recognized values for the above regs */64#define LM85_COMPANY_NATIONAL 0x0165#define LM85_COMPANY_ANALOG_DEV 0x4166#define LM85_COMPANY_SMSC 0x5c67#define LM85_VERSTEP_LM85C 0x6068#define LM85_VERSTEP_LM85B 0x6269#define LM85_VERSTEP_LM96000_1 0x6870#define LM85_VERSTEP_LM96000_2 0x6971#define LM85_VERSTEP_ADM1027 0x6072#define LM85_VERSTEP_ADT7463 0x6273#define LM85_VERSTEP_ADT7463C 0x6A74#define LM85_VERSTEP_ADT7468_1 0x7175#define LM85_VERSTEP_ADT7468_2 0x7276#define LM85_VERSTEP_EMC6D100_A0 0x6077#define LM85_VERSTEP_EMC6D100_A1 0x6178#define LM85_VERSTEP_EMC6D102 0x6579#define LM85_VERSTEP_EMC6D103_A0 0x6880#define LM85_VERSTEP_EMC6D103_A1 0x6981#define LM85_VERSTEP_EMC6D103S 0x6A /* Also known as EMC6D103:A2 */82 83#define LM85_REG_CONFIG 0x4084 85#define LM85_REG_ALARM1 0x4186#define LM85_REG_ALARM2 0x4287 88#define LM85_REG_VID 0x4389 90/* Automated FAN control */91#define LM85_REG_AFAN_CONFIG(nr) (0x5c + (nr))92#define LM85_REG_AFAN_RANGE(nr) (0x5f + (nr))93#define LM85_REG_AFAN_SPIKE1 0x6294#define LM85_REG_AFAN_MINPWM(nr) (0x64 + (nr))95#define LM85_REG_AFAN_LIMIT(nr) (0x67 + (nr))96#define LM85_REG_AFAN_CRITICAL(nr) (0x6a + (nr))97#define LM85_REG_AFAN_HYST1 0x6d98#define LM85_REG_AFAN_HYST2 0x6e99 100#define ADM1027_REG_EXTEND_ADC1 0x76101#define ADM1027_REG_EXTEND_ADC2 0x77102 103#define EMC6D100_REG_ALARM3 0x7d104/* IN5, IN6 and IN7 */105#define EMC6D100_REG_IN(nr) (0x70 + ((nr) - 5))106#define EMC6D100_REG_IN_MIN(nr) (0x73 + ((nr) - 5) * 2)107#define EMC6D100_REG_IN_MAX(nr) (0x74 + ((nr) - 5) * 2)108#define EMC6D102_REG_EXTEND_ADC1 0x85109#define EMC6D102_REG_EXTEND_ADC2 0x86110#define EMC6D102_REG_EXTEND_ADC3 0x87111#define EMC6D102_REG_EXTEND_ADC4 0x88112 113/*114 * Conversions. Rounding and limit checking is only done on the TO_REG115 * variants. Note that you should be a bit careful with which arguments116 * these macros are called: arguments may be evaluated more than once.117 */118 119/* IN are scaled according to built-in resistors */120static const int lm85_scaling[] = { /* .001 Volts */121 2500, 2250, 3300, 5000, 12000,122 3300, 1500, 1800 /*EMC6D100*/123};124#define SCALE(val, from, to) (((val) * (to) + ((from) / 2)) / (from))125 126#define INS_TO_REG(n, val) \127 SCALE(clamp_val(val, 0, 255 * lm85_scaling[n] / 192), \128 lm85_scaling[n], 192)129 130#define INSEXT_FROM_REG(n, val, ext) \131 SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n])132 133#define INS_FROM_REG(n, val) SCALE((val), 192, lm85_scaling[n])134 135/* FAN speed is measured using 90kHz clock */136static inline u16 FAN_TO_REG(unsigned long val)137{138 if (!val)139 return 0xffff;140 return clamp_val(5400000 / val, 1, 0xfffe);141}142#define FAN_FROM_REG(val) ((val) == 0 ? -1 : (val) == 0xffff ? 0 : \143 5400000 / (val))144 145/* Temperature is reported in .001 degC increments */146#define TEMP_TO_REG(val) \147 DIV_ROUND_CLOSEST(clamp_val((val), -127000, 127000), 1000)148#define TEMPEXT_FROM_REG(val, ext) \149 SCALE(((val) << 4) + (ext), 16, 1000)150#define TEMP_FROM_REG(val) ((val) * 1000)151 152#define PWM_TO_REG(val) clamp_val(val, 0, 255)153#define PWM_FROM_REG(val) (val)154 155/*156 * ZONEs have the following parameters:157 * Limit (low) temp, 1. degC158 * Hysteresis (below limit), 1. degC (0-15)159 * Range of speed control, .1 degC (2-80)160 * Critical (high) temp, 1. degC161 *162 * FAN PWMs have the following parameters:163 * Reference Zone, 1, 2, 3, etc.164 * Spinup time, .05 sec165 * PWM value at limit/low temp, 1 count166 * PWM Frequency, 1. Hz167 * PWM is Min or OFF below limit, flag168 * Invert PWM output, flag169 *170 * Some chips filter the temp, others the fan.171 * Filter constant (or disabled) .1 seconds172 */173 174/* These are the zone temperature range encodings in .001 degree C */175static const int lm85_range_map[] = {176 2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000,177 13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000178};179 180static int RANGE_TO_REG(long range)181{182 return find_closest(range, lm85_range_map, ARRAY_SIZE(lm85_range_map));183}184#define RANGE_FROM_REG(val) lm85_range_map[(val) & 0x0f]185 186/* These are the PWM frequency encodings */187static const int lm85_freq_map[] = { /* 1 Hz */188 10, 15, 23, 30, 38, 47, 61, 94189};190 191static const int lm96000_freq_map[] = { /* 1 Hz */192 10, 15, 23, 30, 38, 47, 61, 94,193 22500, 24000, 25700, 25700, 27700, 27700, 30000, 30000194};195 196static const int adm1027_freq_map[] = { /* 1 Hz */197 11, 15, 22, 29, 35, 44, 59, 88198};199 200static int FREQ_TO_REG(const int *map,201 unsigned int map_size, unsigned long freq)202{203 return find_closest(freq, map, map_size);204}205 206static int FREQ_FROM_REG(const int *map, unsigned int map_size, u8 reg)207{208 return map[reg % map_size];209}210 211/*212 * Since we can't use strings, I'm abusing these numbers213 * to stand in for the following meanings:214 * 1 -- PWM responds to Zone 1215 * 2 -- PWM responds to Zone 2216 * 3 -- PWM responds to Zone 3217 * 23 -- PWM responds to the higher temp of Zone 2 or 3218 * 123 -- PWM responds to highest of Zone 1, 2, or 3219 * 0 -- PWM is always at 0% (ie, off)220 * -1 -- PWM is always at 100%221 * -2 -- PWM responds to manual control222 */223 224static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };225#define ZONE_FROM_REG(val) lm85_zone_map[(val) >> 5]226 227static int ZONE_TO_REG(int zone)228{229 int i;230 231 for (i = 0; i <= 7; ++i)232 if (zone == lm85_zone_map[i])233 break;234 if (i > 7) /* Not found. */235 i = 3; /* Always 100% */236 return i << 5;237}238 239#define HYST_TO_REG(val) clamp_val(((val) + 500) / 1000, 0, 15)240#define HYST_FROM_REG(val) ((val) * 1000)241 242/*243 * Chip sampling rates244 *245 * Some sensors are not updated more frequently than once per second246 * so it doesn't make sense to read them more often than that.247 * We cache the results and return the saved data if the driver248 * is called again before a second has elapsed.249 *250 * Also, there is significant configuration data for this chip251 * given the automatic PWM fan control that is possible. There252 * are about 47 bytes of config data to only 22 bytes of actual253 * readings. So, we keep the config data up to date in the cache254 * when it is written and only sample it once every 1 *minute*255 */256#define LM85_DATA_INTERVAL (HZ + HZ / 2)257#define LM85_CONFIG_INTERVAL (1 * 60 * HZ)258 259/*260 * LM85 can automatically adjust fan speeds based on temperature261 * This structure encapsulates an entire Zone config. There are262 * three zones (one for each temperature input) on the lm85263 */264struct lm85_zone {265 s8 limit; /* Low temp limit */266 u8 hyst; /* Low limit hysteresis. (0-15) */267 u8 range; /* Temp range, encoded */268 s8 critical; /* "All fans ON" temp limit */269 u8 max_desired; /*270 * Actual "max" temperature specified. Preserved271 * to prevent "drift" as other autofan control272 * values change.273 */274};275 276struct lm85_autofan {277 u8 config; /* Register value */278 u8 min_pwm; /* Minimum PWM value, encoded */279 u8 min_off; /* Min PWM or OFF below "limit", flag */280};281 282/*283 * For each registered chip, we need to keep some data in memory.284 * The structure is dynamically allocated.285 */286struct lm85_data {287 struct i2c_client *client;288 const struct attribute_group *groups[6];289 const int *freq_map;290 unsigned int freq_map_size;291 292 enum chips type;293 294 bool has_vid5; /* true if VID5 is configured for ADT7463 or ADT7468 */295 296 struct mutex update_lock;297 bool valid; /* true if following fields are valid */298 unsigned long last_reading; /* In jiffies */299 unsigned long last_config; /* In jiffies */300 301 u8 in[8]; /* Register value */302 u8 in_max[8]; /* Register value */303 u8 in_min[8]; /* Register value */304 s8 temp[3]; /* Register value */305 s8 temp_min[3]; /* Register value */306 s8 temp_max[3]; /* Register value */307 u16 fan[4]; /* Register value */308 u16 fan_min[4]; /* Register value */309 u8 pwm[3]; /* Register value */310 u8 pwm_freq[3]; /* Register encoding */311 u8 temp_ext[3]; /* Decoded values */312 u8 in_ext[8]; /* Decoded values */313 u8 vid; /* Register value */314 u8 vrm; /* VRM version */315 u32 alarms; /* Register encoding, combined */316 u8 cfg5; /* Config Register 5 on ADT7468 */317 struct lm85_autofan autofan[3];318 struct lm85_zone zone[3];319};320 321static int lm85_read_value(struct i2c_client *client, u8 reg)322{323 int res;324 325 /* What size location is it? */326 switch (reg) {327 case LM85_REG_FAN(0): /* Read WORD data */328 case LM85_REG_FAN(1):329 case LM85_REG_FAN(2):330 case LM85_REG_FAN(3):331 case LM85_REG_FAN_MIN(0):332 case LM85_REG_FAN_MIN(1):333 case LM85_REG_FAN_MIN(2):334 case LM85_REG_FAN_MIN(3):335 case LM85_REG_ALARM1: /* Read both bytes at once */336 res = i2c_smbus_read_byte_data(client, reg) & 0xff;337 res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;338 break;339 default: /* Read BYTE data */340 res = i2c_smbus_read_byte_data(client, reg);341 break;342 }343 344 return res;345}346 347static void lm85_write_value(struct i2c_client *client, u8 reg, int value)348{349 switch (reg) {350 case LM85_REG_FAN(0): /* Write WORD data */351 case LM85_REG_FAN(1):352 case LM85_REG_FAN(2):353 case LM85_REG_FAN(3):354 case LM85_REG_FAN_MIN(0):355 case LM85_REG_FAN_MIN(1):356 case LM85_REG_FAN_MIN(2):357 case LM85_REG_FAN_MIN(3):358 /* NOTE: ALARM is read only, so not included here */359 i2c_smbus_write_byte_data(client, reg, value & 0xff);360 i2c_smbus_write_byte_data(client, reg + 1, value >> 8);361 break;362 default: /* Write BYTE data */363 i2c_smbus_write_byte_data(client, reg, value);364 break;365 }366}367 368static struct lm85_data *lm85_update_device(struct device *dev)369{370 struct lm85_data *data = dev_get_drvdata(dev);371 struct i2c_client *client = data->client;372 int i;373 374 mutex_lock(&data->update_lock);375 376 if (!data->valid ||377 time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {378 /* Things that change quickly */379 dev_dbg(&client->dev, "Reading sensor values\n");380 381 /*382 * Have to read extended bits first to "freeze" the383 * more significant bits that are read later.384 * There are 2 additional resolution bits per channel and we385 * have room for 4, so we shift them to the left.386 */387 if (data->type == adm1027 || data->type == adt7463 ||388 data->type == adt7468) {389 int ext1 = lm85_read_value(client,390 ADM1027_REG_EXTEND_ADC1);391 int ext2 = lm85_read_value(client,392 ADM1027_REG_EXTEND_ADC2);393 int val = (ext1 << 8) + ext2;394 395 for (i = 0; i <= 4; i++)396 data->in_ext[i] =397 ((val >> (i * 2)) & 0x03) << 2;398 399 for (i = 0; i <= 2; i++)400 data->temp_ext[i] =401 (val >> ((i + 4) * 2)) & 0x0c;402 }403 404 data->vid = lm85_read_value(client, LM85_REG_VID);405 406 for (i = 0; i <= 3; ++i) {407 data->in[i] =408 lm85_read_value(client, LM85_REG_IN(i));409 data->fan[i] =410 lm85_read_value(client, LM85_REG_FAN(i));411 }412 413 if (!data->has_vid5)414 data->in[4] = lm85_read_value(client, LM85_REG_IN(4));415 416 if (data->type == adt7468)417 data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5);418 419 for (i = 0; i <= 2; ++i) {420 data->temp[i] =421 lm85_read_value(client, LM85_REG_TEMP(i));422 data->pwm[i] =423 lm85_read_value(client, LM85_REG_PWM(i));424 425 if (IS_ADT7468_OFF64(data))426 data->temp[i] -= 64;427 }428 429 data->alarms = lm85_read_value(client, LM85_REG_ALARM1);430 431 if (data->type == emc6d100) {432 /* Three more voltage sensors */433 for (i = 5; i <= 7; ++i) {434 data->in[i] = lm85_read_value(client,435 EMC6D100_REG_IN(i));436 }437 /* More alarm bits */438 data->alarms |= lm85_read_value(client,439 EMC6D100_REG_ALARM3) << 16;440 } else if (data->type == emc6d102 || data->type == emc6d103 ||441 data->type == emc6d103s) {442 /*443 * Have to read LSB bits after the MSB ones because444 * the reading of the MSB bits has frozen the445 * LSBs (backward from the ADM1027).446 */447 int ext1 = lm85_read_value(client,448 EMC6D102_REG_EXTEND_ADC1);449 int ext2 = lm85_read_value(client,450 EMC6D102_REG_EXTEND_ADC2);451 int ext3 = lm85_read_value(client,452 EMC6D102_REG_EXTEND_ADC3);453 int ext4 = lm85_read_value(client,454 EMC6D102_REG_EXTEND_ADC4);455 data->in_ext[0] = ext3 & 0x0f;456 data->in_ext[1] = ext4 & 0x0f;457 data->in_ext[2] = ext4 >> 4;458 data->in_ext[3] = ext3 >> 4;459 data->in_ext[4] = ext2 >> 4;460 461 data->temp_ext[0] = ext1 & 0x0f;462 data->temp_ext[1] = ext2 & 0x0f;463 data->temp_ext[2] = ext1 >> 4;464 }465 466 data->last_reading = jiffies;467 } /* last_reading */468 469 if (!data->valid ||470 time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {471 /* Things that don't change often */472 dev_dbg(&client->dev, "Reading config values\n");473 474 for (i = 0; i <= 3; ++i) {475 data->in_min[i] =476 lm85_read_value(client, LM85_REG_IN_MIN(i));477 data->in_max[i] =478 lm85_read_value(client, LM85_REG_IN_MAX(i));479 data->fan_min[i] =480 lm85_read_value(client, LM85_REG_FAN_MIN(i));481 }482 483 if (!data->has_vid5) {484 data->in_min[4] = lm85_read_value(client,485 LM85_REG_IN_MIN(4));486 data->in_max[4] = lm85_read_value(client,487 LM85_REG_IN_MAX(4));488 }489 490 if (data->type == emc6d100) {491 for (i = 5; i <= 7; ++i) {492 data->in_min[i] = lm85_read_value(client,493 EMC6D100_REG_IN_MIN(i));494 data->in_max[i] = lm85_read_value(client,495 EMC6D100_REG_IN_MAX(i));496 }497 }498 499 for (i = 0; i <= 2; ++i) {500 int val;501 502 data->temp_min[i] =503 lm85_read_value(client, LM85_REG_TEMP_MIN(i));504 data->temp_max[i] =505 lm85_read_value(client, LM85_REG_TEMP_MAX(i));506 507 data->autofan[i].config =508 lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));509 val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));510 data->pwm_freq[i] = val % data->freq_map_size;511 data->zone[i].range = val >> 4;512 data->autofan[i].min_pwm =513 lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));514 data->zone[i].limit =515 lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));516 data->zone[i].critical =517 lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));518 519 if (IS_ADT7468_OFF64(data)) {520 data->temp_min[i] -= 64;521 data->temp_max[i] -= 64;522 data->zone[i].limit -= 64;523 data->zone[i].critical -= 64;524 }525 }526 527 if (data->type != emc6d103s) {528 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);529 data->autofan[0].min_off = (i & 0x20) != 0;530 data->autofan[1].min_off = (i & 0x40) != 0;531 data->autofan[2].min_off = (i & 0x80) != 0;532 533 i = lm85_read_value(client, LM85_REG_AFAN_HYST1);534 data->zone[0].hyst = i >> 4;535 data->zone[1].hyst = i & 0x0f;536 537 i = lm85_read_value(client, LM85_REG_AFAN_HYST2);538 data->zone[2].hyst = i >> 4;539 }540 541 data->last_config = jiffies;542 } /* last_config */543 544 data->valid = true;545 546 mutex_unlock(&data->update_lock);547 548 return data;549}550 551/* 4 Fans */552static ssize_t fan_show(struct device *dev, struct device_attribute *attr,553 char *buf)554{555 int nr = to_sensor_dev_attr(attr)->index;556 struct lm85_data *data = lm85_update_device(dev);557 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr]));558}559 560static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,561 char *buf)562{563 int nr = to_sensor_dev_attr(attr)->index;564 struct lm85_data *data = lm85_update_device(dev);565 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr]));566}567 568static ssize_t fan_min_store(struct device *dev,569 struct device_attribute *attr, const char *buf,570 size_t count)571{572 int nr = to_sensor_dev_attr(attr)->index;573 struct lm85_data *data = dev_get_drvdata(dev);574 struct i2c_client *client = data->client;575 unsigned long val;576 int err;577 578 err = kstrtoul(buf, 10, &val);579 if (err)580 return err;581 582 mutex_lock(&data->update_lock);583 data->fan_min[nr] = FAN_TO_REG(val);584 lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]);585 mutex_unlock(&data->update_lock);586 return count;587}588 589static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);590static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);591static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);592static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);593static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);594static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);595static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);596static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);597 598/* vid, vrm, alarms */599 600static ssize_t cpu0_vid_show(struct device *dev,601 struct device_attribute *attr, char *buf)602{603 struct lm85_data *data = lm85_update_device(dev);604 int vid;605 606 if (data->has_vid5) {607 /* 6-pin VID (VRM 10) */608 vid = vid_from_reg(data->vid & 0x3f, data->vrm);609 } else {610 /* 5-pin VID (VRM 9) */611 vid = vid_from_reg(data->vid & 0x1f, data->vrm);612 }613 614 return sprintf(buf, "%d\n", vid);615}616 617static DEVICE_ATTR_RO(cpu0_vid);618 619static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,620 char *buf)621{622 struct lm85_data *data = dev_get_drvdata(dev);623 return sprintf(buf, "%ld\n", (long) data->vrm);624}625 626static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,627 const char *buf, size_t count)628{629 struct lm85_data *data = dev_get_drvdata(dev);630 unsigned long val;631 int err;632 633 err = kstrtoul(buf, 10, &val);634 if (err)635 return err;636 637 if (val > 255)638 return -EINVAL;639 640 data->vrm = val;641 return count;642}643 644static DEVICE_ATTR_RW(vrm);645 646static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,647 char *buf)648{649 struct lm85_data *data = lm85_update_device(dev);650 return sprintf(buf, "%u\n", data->alarms);651}652 653static DEVICE_ATTR_RO(alarms);654 655static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,656 char *buf)657{658 int nr = to_sensor_dev_attr(attr)->index;659 struct lm85_data *data = lm85_update_device(dev);660 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);661}662 663static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);664static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);665static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);666static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);667static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);668static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 18);669static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 16);670static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 17);671static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);672static SENSOR_DEVICE_ATTR_RO(temp1_fault, alarm, 14);673static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);674static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 6);675static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 15);676static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 10);677static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 11);678static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 12);679static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, 13);680 681/* pwm */682 683static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,684 char *buf)685{686 int nr = to_sensor_dev_attr(attr)->index;687 struct lm85_data *data = lm85_update_device(dev);688 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));689}690 691static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,692 const char *buf, size_t count)693{694 int nr = to_sensor_dev_attr(attr)->index;695 struct lm85_data *data = dev_get_drvdata(dev);696 struct i2c_client *client = data->client;697 unsigned long val;698 int err;699 700 err = kstrtoul(buf, 10, &val);701 if (err)702 return err;703 704 mutex_lock(&data->update_lock);705 data->pwm[nr] = PWM_TO_REG(val);706 lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);707 mutex_unlock(&data->update_lock);708 return count;709}710 711static ssize_t pwm_enable_show(struct device *dev,712 struct device_attribute *attr, char *buf)713{714 int nr = to_sensor_dev_attr(attr)->index;715 struct lm85_data *data = lm85_update_device(dev);716 int pwm_zone, enable;717 718 pwm_zone = ZONE_FROM_REG(data->autofan[nr].config);719 switch (pwm_zone) {720 case -1: /* PWM is always at 100% */721 enable = 0;722 break;723 case 0: /* PWM is always at 0% */724 case -2: /* PWM responds to manual control */725 enable = 1;726 break;727 default: /* PWM in automatic mode */728 enable = 2;729 }730 return sprintf(buf, "%d\n", enable);731}732 733static ssize_t pwm_enable_store(struct device *dev,734 struct device_attribute *attr,735 const char *buf, size_t count)736{737 int nr = to_sensor_dev_attr(attr)->index;738 struct lm85_data *data = dev_get_drvdata(dev);739 struct i2c_client *client = data->client;740 u8 config;741 unsigned long val;742 int err;743 744 err = kstrtoul(buf, 10, &val);745 if (err)746 return err;747 748 switch (val) {749 case 0:750 config = 3;751 break;752 case 1:753 config = 7;754 break;755 case 2:756 /*757 * Here we have to choose arbitrarily one of the 5 possible758 * configurations; I go for the safest759 */760 config = 6;761 break;762 default:763 return -EINVAL;764 }765 766 mutex_lock(&data->update_lock);767 data->autofan[nr].config = lm85_read_value(client,768 LM85_REG_AFAN_CONFIG(nr));769 data->autofan[nr].config = (data->autofan[nr].config & ~0xe0)770 | (config << 5);771 lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),772 data->autofan[nr].config);773 mutex_unlock(&data->update_lock);774 return count;775}776 777static ssize_t pwm_freq_show(struct device *dev,778 struct device_attribute *attr, char *buf)779{780 int nr = to_sensor_dev_attr(attr)->index;781 struct lm85_data *data = lm85_update_device(dev);782 int freq;783 784 if (IS_ADT7468_HFPWM(data))785 freq = 22500;786 else787 freq = FREQ_FROM_REG(data->freq_map, data->freq_map_size,788 data->pwm_freq[nr]);789 790 return sprintf(buf, "%d\n", freq);791}792 793static ssize_t pwm_freq_store(struct device *dev,794 struct device_attribute *attr, const char *buf,795 size_t count)796{797 int nr = to_sensor_dev_attr(attr)->index;798 struct lm85_data *data = dev_get_drvdata(dev);799 struct i2c_client *client = data->client;800 unsigned long val;801 int err;802 803 err = kstrtoul(buf, 10, &val);804 if (err)805 return err;806 807 mutex_lock(&data->update_lock);808 /*809 * The ADT7468 has a special high-frequency PWM output mode,810 * where all PWM outputs are driven by a 22.5 kHz clock.811 * This might confuse the user, but there's not much we can do.812 */813 if (data->type == adt7468 && val >= 11300) { /* High freq. mode */814 data->cfg5 &= ~ADT7468_HFPWM;815 lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);816 } else { /* Low freq. mode */817 data->pwm_freq[nr] = FREQ_TO_REG(data->freq_map,818 data->freq_map_size, val);819 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),820 (data->zone[nr].range << 4)821 | data->pwm_freq[nr]);822 if (data->type == adt7468) {823 data->cfg5 |= ADT7468_HFPWM;824 lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);825 }826 }827 mutex_unlock(&data->update_lock);828 return count;829}830 831static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);832static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_enable, 0);833static SENSOR_DEVICE_ATTR_RW(pwm1_freq, pwm_freq, 0);834static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);835static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_enable, 1);836static SENSOR_DEVICE_ATTR_RW(pwm2_freq, pwm_freq, 1);837static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);838static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_enable, 2);839static SENSOR_DEVICE_ATTR_RW(pwm3_freq, pwm_freq, 2);840 841/* Voltages */842 843static ssize_t in_show(struct device *dev, struct device_attribute *attr,844 char *buf)845{846 int nr = to_sensor_dev_attr(attr)->index;847 struct lm85_data *data = lm85_update_device(dev);848 return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr],849 data->in_ext[nr]));850}851 852static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,853 char *buf)854{855 int nr = to_sensor_dev_attr(attr)->index;856 struct lm85_data *data = lm85_update_device(dev);857 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));858}859 860static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,861 const char *buf, size_t count)862{863 int nr = to_sensor_dev_attr(attr)->index;864 struct lm85_data *data = dev_get_drvdata(dev);865 struct i2c_client *client = data->client;866 long val;867 int err;868 869 err = kstrtol(buf, 10, &val);870 if (err)871 return err;872 873 mutex_lock(&data->update_lock);874 data->in_min[nr] = INS_TO_REG(nr, val);875 lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]);876 mutex_unlock(&data->update_lock);877 return count;878}879 880static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,881 char *buf)882{883 int nr = to_sensor_dev_attr(attr)->index;884 struct lm85_data *data = lm85_update_device(dev);885 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));886}887 888static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,889 const char *buf, size_t count)890{891 int nr = to_sensor_dev_attr(attr)->index;892 struct lm85_data *data = dev_get_drvdata(dev);893 struct i2c_client *client = data->client;894 long val;895 int err;896 897 err = kstrtol(buf, 10, &val);898 if (err)899 return err;900 901 mutex_lock(&data->update_lock);902 data->in_max[nr] = INS_TO_REG(nr, val);903 lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]);904 mutex_unlock(&data->update_lock);905 return count;906}907 908static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);909static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);910static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);911static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);912static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);913static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);914static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);915static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);916static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);917static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);918static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);919static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);920static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);921static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);922static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);923static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);924static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);925static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);926static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);927static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);928static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);929static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);930static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);931static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);932 933/* Temps */934 935static ssize_t temp_show(struct device *dev, struct device_attribute *attr,936 char *buf)937{938 int nr = to_sensor_dev_attr(attr)->index;939 struct lm85_data *data = lm85_update_device(dev);940 return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr],941 data->temp_ext[nr]));942}943 944static ssize_t temp_min_show(struct device *dev,945 struct device_attribute *attr, char *buf)946{947 int nr = to_sensor_dev_attr(attr)->index;948 struct lm85_data *data = lm85_update_device(dev);949 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));950}951 952static ssize_t temp_min_store(struct device *dev,953 struct device_attribute *attr, const char *buf,954 size_t count)955{956 int nr = to_sensor_dev_attr(attr)->index;957 struct lm85_data *data = dev_get_drvdata(dev);958 struct i2c_client *client = data->client;959 long val;960 int err;961 962 err = kstrtol(buf, 10, &val);963 if (err)964 return err;965 966 if (IS_ADT7468_OFF64(data))967 val += 64;968 969 mutex_lock(&data->update_lock);970 data->temp_min[nr] = TEMP_TO_REG(val);971 lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]);972 mutex_unlock(&data->update_lock);973 return count;974}975 976static ssize_t temp_max_show(struct device *dev,977 struct device_attribute *attr, char *buf)978{979 int nr = to_sensor_dev_attr(attr)->index;980 struct lm85_data *data = lm85_update_device(dev);981 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));982}983 984static ssize_t temp_max_store(struct device *dev,985 struct device_attribute *attr, const char *buf,986 size_t count)987{988 int nr = to_sensor_dev_attr(attr)->index;989 struct lm85_data *data = dev_get_drvdata(dev);990 struct i2c_client *client = data->client;991 long val;992 int err;993 994 err = kstrtol(buf, 10, &val);995 if (err)996 return err;997 998 if (IS_ADT7468_OFF64(data))999 val += 64;1000 1001 mutex_lock(&data->update_lock);1002 data->temp_max[nr] = TEMP_TO_REG(val);1003 lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]);1004 mutex_unlock(&data->update_lock);1005 return count;1006}1007 1008static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);1009static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);1010static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);1011static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);1012static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);1013static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);1014static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);1015static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);1016static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);1017 1018/* Automatic PWM control */1019 1020static ssize_t pwm_auto_channels_show(struct device *dev,1021 struct device_attribute *attr,1022 char *buf)1023{1024 int nr = to_sensor_dev_attr(attr)->index;1025 struct lm85_data *data = lm85_update_device(dev);1026 return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config));1027}1028 1029static ssize_t pwm_auto_channels_store(struct device *dev,1030 struct device_attribute *attr,1031 const char *buf, size_t count)1032{1033 int nr = to_sensor_dev_attr(attr)->index;1034 struct lm85_data *data = dev_get_drvdata(dev);1035 struct i2c_client *client = data->client;1036 long val;1037 int err;1038 1039 err = kstrtol(buf, 10, &val);1040 if (err)1041 return err;1042 1043 mutex_lock(&data->update_lock);1044 data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))1045 | ZONE_TO_REG(val);1046 lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),1047 data->autofan[nr].config);1048 mutex_unlock(&data->update_lock);1049 return count;1050}1051 1052static ssize_t pwm_auto_pwm_min_show(struct device *dev,1053 struct device_attribute *attr, char *buf)1054{1055 int nr = to_sensor_dev_attr(attr)->index;1056 struct lm85_data *data = lm85_update_device(dev);1057 return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));1058}1059 1060static ssize_t pwm_auto_pwm_min_store(struct device *dev,1061 struct device_attribute *attr,1062 const char *buf, size_t count)1063{1064 int nr = to_sensor_dev_attr(attr)->index;1065 struct lm85_data *data = dev_get_drvdata(dev);1066 struct i2c_client *client = data->client;1067 unsigned long val;1068 int err;1069 1070 err = kstrtoul(buf, 10, &val);1071 if (err)1072 return err;1073 1074 mutex_lock(&data->update_lock);1075 data->autofan[nr].min_pwm = PWM_TO_REG(val);1076 lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),1077 data->autofan[nr].min_pwm);1078 mutex_unlock(&data->update_lock);1079 return count;1080}1081 1082static ssize_t pwm_auto_pwm_minctl_show(struct device *dev,1083 struct device_attribute *attr,1084 char *buf)1085{1086 int nr = to_sensor_dev_attr(attr)->index;1087 struct lm85_data *data = lm85_update_device(dev);1088 return sprintf(buf, "%d\n", data->autofan[nr].min_off);1089}1090 1091static ssize_t pwm_auto_pwm_minctl_store(struct device *dev,1092 struct device_attribute *attr,1093 const char *buf, size_t count)1094{1095 int nr = to_sensor_dev_attr(attr)->index;1096 struct lm85_data *data = dev_get_drvdata(dev);1097 struct i2c_client *client = data->client;1098 u8 tmp;1099 long val;1100 int err;1101 1102 err = kstrtol(buf, 10, &val);1103 if (err)1104 return err;1105 1106 mutex_lock(&data->update_lock);1107 data->autofan[nr].min_off = val;1108 tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);1109 tmp &= ~(0x20 << nr);1110 if (data->autofan[nr].min_off)1111 tmp |= 0x20 << nr;1112 lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp);1113 mutex_unlock(&data->update_lock);1114 return count;1115}1116 1117static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels, pwm_auto_channels, 0);1118static SENSOR_DEVICE_ATTR_RW(pwm1_auto_pwm_min, pwm_auto_pwm_min, 0);1119static SENSOR_DEVICE_ATTR_RW(pwm1_auto_pwm_minctl, pwm_auto_pwm_minctl, 0);1120static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels, pwm_auto_channels, 1);1121static SENSOR_DEVICE_ATTR_RW(pwm2_auto_pwm_min, pwm_auto_pwm_min, 1);1122static SENSOR_DEVICE_ATTR_RW(pwm2_auto_pwm_minctl, pwm_auto_pwm_minctl, 1);1123static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels, pwm_auto_channels, 2);1124static SENSOR_DEVICE_ATTR_RW(pwm3_auto_pwm_min, pwm_auto_pwm_min, 2);1125static SENSOR_DEVICE_ATTR_RW(pwm3_auto_pwm_minctl, pwm_auto_pwm_minctl, 2);1126 1127/* Temperature settings for automatic PWM control */1128 1129static ssize_t temp_auto_temp_off_show(struct device *dev,1130 struct device_attribute *attr,1131 char *buf)1132{1133 int nr = to_sensor_dev_attr(attr)->index;1134 struct lm85_data *data = lm85_update_device(dev);1135 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -1136 HYST_FROM_REG(data->zone[nr].hyst));1137}1138 1139static ssize_t temp_auto_temp_off_store(struct device *dev,1140 struct device_attribute *attr,1141 const char *buf, size_t count)1142{1143 int nr = to_sensor_dev_attr(attr)->index;1144 struct lm85_data *data = dev_get_drvdata(dev);1145 struct i2c_client *client = data->client;1146 int min;1147 long val;1148 int err;1149 1150 err = kstrtol(buf, 10, &val);1151 if (err)1152 return err;1153 1154 mutex_lock(&data->update_lock);1155 min = TEMP_FROM_REG(data->zone[nr].limit);1156 data->zone[nr].hyst = HYST_TO_REG(min - val);1157 if (nr == 0 || nr == 1) {1158 lm85_write_value(client, LM85_REG_AFAN_HYST1,1159 (data->zone[0].hyst << 4)1160 | data->zone[1].hyst);1161 } else {1162 lm85_write_value(client, LM85_REG_AFAN_HYST2,1163 (data->zone[2].hyst << 4));1164 }1165 mutex_unlock(&data->update_lock);1166 return count;1167}1168 1169static ssize_t temp_auto_temp_min_show(struct device *dev,1170 struct device_attribute *attr,1171 char *buf)1172{1173 int nr = to_sensor_dev_attr(attr)->index;1174 struct lm85_data *data = lm85_update_device(dev);1175 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));1176}1177 1178static ssize_t temp_auto_temp_min_store(struct device *dev,1179 struct device_attribute *attr,1180 const char *buf, size_t count)1181{1182 int nr = to_sensor_dev_attr(attr)->index;1183 struct lm85_data *data = dev_get_drvdata(dev);1184 struct i2c_client *client = data->client;1185 long val;1186 int err;1187 1188 err = kstrtol(buf, 10, &val);1189 if (err)1190 return err;1191 1192 mutex_lock(&data->update_lock);1193 data->zone[nr].limit = TEMP_TO_REG(val);1194 lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),1195 data->zone[nr].limit);1196 1197/* Update temp_auto_max and temp_auto_range */1198 data->zone[nr].range = RANGE_TO_REG(1199 TEMP_FROM_REG(data->zone[nr].max_desired) -1200 TEMP_FROM_REG(data->zone[nr].limit));1201 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),1202 ((data->zone[nr].range & 0x0f) << 4)1203 | data->pwm_freq[nr]);1204 1205 mutex_unlock(&data->update_lock);1206 return count;1207}1208 1209static ssize_t temp_auto_temp_max_show(struct device *dev,1210 struct device_attribute *attr,1211 char *buf)1212{1213 int nr = to_sensor_dev_attr(attr)->index;1214 struct lm85_data *data = lm85_update_device(dev);1215 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +1216 RANGE_FROM_REG(data->zone[nr].range));1217}1218 1219static ssize_t temp_auto_temp_max_store(struct device *dev,1220 struct device_attribute *attr,1221 const char *buf, size_t count)1222{1223 int nr = to_sensor_dev_attr(attr)->index;1224 struct lm85_data *data = dev_get_drvdata(dev);1225 struct i2c_client *client = data->client;1226 int min;1227 long val;1228 int err;1229 1230 err = kstrtol(buf, 10, &val);1231 if (err)1232 return err;1233 1234 mutex_lock(&data->update_lock);1235 min = TEMP_FROM_REG(data->zone[nr].limit);1236 data->zone[nr].max_desired = TEMP_TO_REG(val);1237 data->zone[nr].range = RANGE_TO_REG(1238 val - min);1239 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),1240 ((data->zone[nr].range & 0x0f) << 4)1241 | data->pwm_freq[nr]);1242 mutex_unlock(&data->update_lock);1243 return count;1244}1245 1246static ssize_t temp_auto_temp_crit_show(struct device *dev,1247 struct device_attribute *attr,1248 char *buf)1249{1250 int nr = to_sensor_dev_attr(attr)->index;1251 struct lm85_data *data = lm85_update_device(dev);1252 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical));1253}1254 1255static ssize_t temp_auto_temp_crit_store(struct device *dev,1256 struct device_attribute *attr,1257 const char *buf, size_t count)1258{1259 int nr = to_sensor_dev_attr(attr)->index;1260 struct lm85_data *data = dev_get_drvdata(dev);1261 struct i2c_client *client = data->client;1262 long val;1263 int err;1264 1265 err = kstrtol(buf, 10, &val);1266 if (err)1267 return err;1268 1269 mutex_lock(&data->update_lock);1270 data->zone[nr].critical = TEMP_TO_REG(val);1271 lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),1272 data->zone[nr].critical);1273 mutex_unlock(&data->update_lock);1274 return count;1275}1276 1277static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_off, temp_auto_temp_off, 0);1278static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_min, temp_auto_temp_min, 0);1279static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_max, temp_auto_temp_max, 0);1280static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_crit, temp_auto_temp_crit, 0);1281static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_off, temp_auto_temp_off, 1);1282static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_min, temp_auto_temp_min, 1);1283static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_max, temp_auto_temp_max, 1);1284static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_crit, temp_auto_temp_crit, 1);1285static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_off, temp_auto_temp_off, 2);1286static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_min, temp_auto_temp_min, 2);1287static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_max, temp_auto_temp_max, 2);1288static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_crit, temp_auto_temp_crit, 2);1289 1290static struct attribute *lm85_attributes[] = {1291 &sensor_dev_attr_fan1_input.dev_attr.attr,1292 &sensor_dev_attr_fan2_input.dev_attr.attr,1293 &sensor_dev_attr_fan3_input.dev_attr.attr,1294 &sensor_dev_attr_fan4_input.dev_attr.attr,1295 &sensor_dev_attr_fan1_min.dev_attr.attr,1296 &sensor_dev_attr_fan2_min.dev_attr.attr,1297 &sensor_dev_attr_fan3_min.dev_attr.attr,1298 &sensor_dev_attr_fan4_min.dev_attr.attr,1299 &sensor_dev_attr_fan1_alarm.dev_attr.attr,1300 &sensor_dev_attr_fan2_alarm.dev_attr.attr,1301 &sensor_dev_attr_fan3_alarm.dev_attr.attr,1302 &sensor_dev_attr_fan4_alarm.dev_attr.attr,1303 1304 &sensor_dev_attr_pwm1.dev_attr.attr,1305 &sensor_dev_attr_pwm2.dev_attr.attr,1306 &sensor_dev_attr_pwm3.dev_attr.attr,1307 &sensor_dev_attr_pwm1_enable.dev_attr.attr,1308 &sensor_dev_attr_pwm2_enable.dev_attr.attr,1309 &sensor_dev_attr_pwm3_enable.dev_attr.attr,1310 &sensor_dev_attr_pwm1_freq.dev_attr.attr,1311 &sensor_dev_attr_pwm2_freq.dev_attr.attr,1312 &sensor_dev_attr_pwm3_freq.dev_attr.attr,1313 1314 &sensor_dev_attr_in0_input.dev_attr.attr,1315 &sensor_dev_attr_in1_input.dev_attr.attr,1316 &sensor_dev_attr_in2_input.dev_attr.attr,1317 &sensor_dev_attr_in3_input.dev_attr.attr,1318 &sensor_dev_attr_in0_min.dev_attr.attr,1319 &sensor_dev_attr_in1_min.dev_attr.attr,1320 &sensor_dev_attr_in2_min.dev_attr.attr,1321 &sensor_dev_attr_in3_min.dev_attr.attr,1322 &sensor_dev_attr_in0_max.dev_attr.attr,1323 &sensor_dev_attr_in1_max.dev_attr.attr,1324 &sensor_dev_attr_in2_max.dev_attr.attr,1325 &sensor_dev_attr_in3_max.dev_attr.attr,1326 &sensor_dev_attr_in0_alarm.dev_attr.attr,1327 &sensor_dev_attr_in1_alarm.dev_attr.attr,1328 &sensor_dev_attr_in2_alarm.dev_attr.attr,1329 &sensor_dev_attr_in3_alarm.dev_attr.attr,1330 1331 &sensor_dev_attr_temp1_input.dev_attr.attr,1332 &sensor_dev_attr_temp2_input.dev_attr.attr,1333 &sensor_dev_attr_temp3_input.dev_attr.attr,1334 &sensor_dev_attr_temp1_min.dev_attr.attr,1335 &sensor_dev_attr_temp2_min.dev_attr.attr,1336 &sensor_dev_attr_temp3_min.dev_attr.attr,1337 &sensor_dev_attr_temp1_max.dev_attr.attr,1338 &sensor_dev_attr_temp2_max.dev_attr.attr,1339 &sensor_dev_attr_temp3_max.dev_attr.attr,1340 &sensor_dev_attr_temp1_alarm.dev_attr.attr,1341 &sensor_dev_attr_temp2_alarm.dev_attr.attr,1342 &sensor_dev_attr_temp3_alarm.dev_attr.attr,1343 &sensor_dev_attr_temp1_fault.dev_attr.attr,1344 &sensor_dev_attr_temp3_fault.dev_attr.attr,1345 1346 &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,1347 &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,1348 &sensor_dev_attr_pwm3_auto_channels.dev_attr.attr,1349 &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,1350 &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,1351 &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,1352 1353 &sensor_dev_attr_temp1_auto_temp_min.dev_attr.attr,1354 &sensor_dev_attr_temp2_auto_temp_min.dev_attr.attr,1355 &sensor_dev_attr_temp3_auto_temp_min.dev_attr.attr,1356 &sensor_dev_attr_temp1_auto_temp_max.dev_attr.attr,1357 &sensor_dev_attr_temp2_auto_temp_max.dev_attr.attr,1358 &sensor_dev_attr_temp3_auto_temp_max.dev_attr.attr,1359 &sensor_dev_attr_temp1_auto_temp_crit.dev_attr.attr,1360 &sensor_dev_attr_temp2_auto_temp_crit.dev_attr.attr,1361 &sensor_dev_attr_temp3_auto_temp_crit.dev_attr.attr,1362 1363 &dev_attr_vrm.attr,1364 &dev_attr_cpu0_vid.attr,1365 &dev_attr_alarms.attr,1366 NULL1367};1368 1369static const struct attribute_group lm85_group = {1370 .attrs = lm85_attributes,1371};1372 1373static struct attribute *lm85_attributes_minctl[] = {1374 &sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr,1375 &sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr,1376 &sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr,1377 NULL1378};1379 1380static const struct attribute_group lm85_group_minctl = {1381 .attrs = lm85_attributes_minctl,1382};1383 1384static struct attribute *lm85_attributes_temp_off[] = {1385 &sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr,1386 &sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr,1387 &sensor_dev_attr_temp3_auto_temp_off.dev_attr.attr,1388 NULL1389};1390 1391static const struct attribute_group lm85_group_temp_off = {1392 .attrs = lm85_attributes_temp_off,1393};1394 1395static struct attribute *lm85_attributes_in4[] = {1396 &sensor_dev_attr_in4_input.dev_attr.attr,1397 &sensor_dev_attr_in4_min.dev_attr.attr,1398 &sensor_dev_attr_in4_max.dev_attr.attr,1399 &sensor_dev_attr_in4_alarm.dev_attr.attr,1400 NULL1401};1402 1403static const struct attribute_group lm85_group_in4 = {1404 .attrs = lm85_attributes_in4,1405};1406 1407static struct attribute *lm85_attributes_in567[] = {1408 &sensor_dev_attr_in5_input.dev_attr.attr,1409 &sensor_dev_attr_in6_input.dev_attr.attr,1410 &sensor_dev_attr_in7_input.dev_attr.attr,1411 &sensor_dev_attr_in5_min.dev_attr.attr,1412 &sensor_dev_attr_in6_min.dev_attr.attr,1413 &sensor_dev_attr_in7_min.dev_attr.attr,1414 &sensor_dev_attr_in5_max.dev_attr.attr,1415 &sensor_dev_attr_in6_max.dev_attr.attr,1416 &sensor_dev_attr_in7_max.dev_attr.attr,1417 &sensor_dev_attr_in5_alarm.dev_attr.attr,1418 &sensor_dev_attr_in6_alarm.dev_attr.attr,1419 &sensor_dev_attr_in7_alarm.dev_attr.attr,1420 NULL1421};1422 1423static const struct attribute_group lm85_group_in567 = {1424 .attrs = lm85_attributes_in567,1425};1426 1427static void lm85_init_client(struct i2c_client *client)1428{1429 int value;1430 1431 /* Start monitoring if needed */1432 value = lm85_read_value(client, LM85_REG_CONFIG);1433 if (!(value & 0x01)) {1434 dev_info(&client->dev, "Starting monitoring\n");1435 lm85_write_value(client, LM85_REG_CONFIG, value | 0x01);1436 }1437 1438 /* Warn about unusual configuration bits */1439 if (value & 0x02)1440 dev_warn(&client->dev, "Device configuration is locked\n");1441 if (!(value & 0x04))1442 dev_warn(&client->dev, "Device is not ready\n");1443}1444 1445static int lm85_is_fake(struct i2c_client *client)1446{1447 /*1448 * Differenciate between real LM96000 and Winbond WPCD377I. The latter1449 * emulate the former except that it has no hardware monitoring function1450 * so the readings are always 0.1451 */1452 int i;1453 u8 in_temp, fan;1454 1455 for (i = 0; i < 8; i++) {1456 in_temp = i2c_smbus_read_byte_data(client, 0x20 + i);1457 fan = i2c_smbus_read_byte_data(client, 0x28 + i);1458 if (in_temp != 0x00 || fan != 0xff)1459 return 0;1460 }1461 1462 return 1;1463}1464 1465/* Return 0 if detection is successful, -ENODEV otherwise */1466static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info)1467{1468 struct i2c_adapter *adapter = client->adapter;1469 int address = client->addr;1470 const char *type_name = NULL;1471 int company, verstep;1472 1473 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {1474 /* We need to be able to do byte I/O */1475 return -ENODEV;1476 }1477 1478 /* Determine the chip type */1479 company = lm85_read_value(client, LM85_REG_COMPANY);1480 verstep = lm85_read_value(client, LM85_REG_VERSTEP);1481 1482 dev_dbg(&adapter->dev,1483 "Detecting device at 0x%02x with COMPANY: 0x%02x and VERSTEP: 0x%02x\n",1484 address, company, verstep);1485 1486 if (company == LM85_COMPANY_NATIONAL) {1487 switch (verstep) {1488 case LM85_VERSTEP_LM85C:1489 type_name = "lm85c";1490 break;1491 case LM85_VERSTEP_LM85B:1492 type_name = "lm85b";1493 break;1494 case LM85_VERSTEP_LM96000_1:1495 case LM85_VERSTEP_LM96000_2:1496 /* Check for Winbond WPCD377I */1497 if (lm85_is_fake(client)) {1498 dev_dbg(&adapter->dev,1499 "Found Winbond WPCD377I, ignoring\n");1500 return -ENODEV;1501 }1502 type_name = "lm96000";1503 break;1504 }1505 } else if (company == LM85_COMPANY_ANALOG_DEV) {1506 switch (verstep) {1507 case LM85_VERSTEP_ADM1027:1508 type_name = "adm1027";1509 break;1510 case LM85_VERSTEP_ADT7463:1511 case LM85_VERSTEP_ADT7463C:1512 type_name = "adt7463";1513 break;1514 case LM85_VERSTEP_ADT7468_1:1515 case LM85_VERSTEP_ADT7468_2:1516 type_name = "adt7468";1517 break;1518 }1519 } else if (company == LM85_COMPANY_SMSC) {1520 switch (verstep) {1521 case LM85_VERSTEP_EMC6D100_A0:1522 case LM85_VERSTEP_EMC6D100_A1:1523 /* Note: we can't tell a '100 from a '101 */1524 type_name = "emc6d100";1525 break;1526 case LM85_VERSTEP_EMC6D102:1527 type_name = "emc6d102";1528 break;1529 case LM85_VERSTEP_EMC6D103_A0:1530 case LM85_VERSTEP_EMC6D103_A1:1531 type_name = "emc6d103";1532 break;1533 case LM85_VERSTEP_EMC6D103S:1534 type_name = "emc6d103s";1535 break;1536 }1537 }1538 1539 if (!type_name)1540 return -ENODEV;1541 1542 strscpy(info->type, type_name, I2C_NAME_SIZE);1543 1544 return 0;1545}1546 1547static int lm85_probe(struct i2c_client *client)1548{1549 struct device *dev = &client->dev;1550 struct device *hwmon_dev;1551 struct lm85_data *data;1552 int idx = 0;1553 1554 data = devm_kzalloc(dev, sizeof(struct lm85_data), GFP_KERNEL);1555 if (!data)1556 return -ENOMEM;1557 1558 data->client = client;1559 data->type = (uintptr_t)i2c_get_match_data(client);1560 mutex_init(&data->update_lock);1561 1562 /* Fill in the chip specific driver values */1563 switch (data->type) {1564 case adm1027:1565 case adt7463:1566 case adt7468:1567 case emc6d100:1568 case emc6d102:1569 case emc6d103:1570 case emc6d103s:1571 data->freq_map = adm1027_freq_map;1572 data->freq_map_size = ARRAY_SIZE(adm1027_freq_map);1573 break;1574 case lm96000:1575 data->freq_map = lm96000_freq_map;1576 data->freq_map_size = ARRAY_SIZE(lm96000_freq_map);1577 break;1578 default:1579 data->freq_map = lm85_freq_map;1580 data->freq_map_size = ARRAY_SIZE(lm85_freq_map);1581 }1582 1583 /* Set the VRM version */1584 data->vrm = vid_which_vrm();1585 1586 /* Initialize the LM85 chip */1587 lm85_init_client(client);1588 1589 /* sysfs hooks */1590 data->groups[idx++] = &lm85_group;1591 1592 /* minctl and temp_off exist on all chips except emc6d103s */1593 if (data->type != emc6d103s) {1594 data->groups[idx++] = &lm85_group_minctl;1595 data->groups[idx++] = &lm85_group_temp_off;1596 }1597 1598 /*1599 * The ADT7463/68 have an optional VRM 10 mode where pin 21 is used1600 * as a sixth digital VID input rather than an analog input.1601 */1602 if (data->type == adt7463 || data->type == adt7468) {1603 u8 vid = lm85_read_value(client, LM85_REG_VID);1604 if (vid & 0x80)1605 data->has_vid5 = true;1606 }1607 1608 if (!data->has_vid5)1609 data->groups[idx++] = &lm85_group_in4;1610 1611 /* The EMC6D100 has 3 additional voltage inputs */1612 if (data->type == emc6d100)1613 data->groups[idx++] = &lm85_group_in567;1614 1615 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,1616 data, data->groups);1617 return PTR_ERR_OR_ZERO(hwmon_dev);1618}1619 1620static const struct i2c_device_id lm85_id[] = {1621 { "adm1027", adm1027 },1622 { "adt7463", adt7463 },1623 { "adt7468", adt7468 },1624 { "lm85", lm85 },1625 { "lm85b", lm85 },1626 { "lm85c", lm85 },1627 { "lm96000", lm96000 },1628 { "emc6d100", emc6d100 },1629 { "emc6d101", emc6d100 },1630 { "emc6d102", emc6d102 },1631 { "emc6d103", emc6d103 },1632 { "emc6d103s", emc6d103s },1633 { }1634};1635MODULE_DEVICE_TABLE(i2c, lm85_id);1636 1637static const struct of_device_id __maybe_unused lm85_of_match[] = {1638 {1639 .compatible = "adi,adm1027",1640 .data = (void *)adm10271641 },1642 {1643 .compatible = "adi,adt7463",1644 .data = (void *)adt74631645 },1646 {1647 .compatible = "adi,adt7468",1648 .data = (void *)adt74681649 },1650 {1651 .compatible = "national,lm85",1652 .data = (void *)lm851653 },1654 {1655 .compatible = "national,lm85b",1656 .data = (void *)lm851657 },1658 {1659 .compatible = "national,lm85c",1660 .data = (void *)lm851661 },1662 {1663 .compatible = "ti,lm96000",1664 .data = (void *)lm960001665 },1666 {1667 .compatible = "smsc,emc6d100",1668 .data = (void *)emc6d1001669 },1670 {1671 .compatible = "smsc,emc6d101",1672 .data = (void *)emc6d1001673 },1674 {1675 .compatible = "smsc,emc6d102",1676 .data = (void *)emc6d1021677 },1678 {1679 .compatible = "smsc,emc6d103",1680 .data = (void *)emc6d1031681 },1682 {1683 .compatible = "smsc,emc6d103s",1684 .data = (void *)emc6d103s1685 },1686 { },1687};1688MODULE_DEVICE_TABLE(of, lm85_of_match);1689 1690static struct i2c_driver lm85_driver = {1691 .class = I2C_CLASS_HWMON,1692 .driver = {1693 .name = "lm85",1694 .of_match_table = of_match_ptr(lm85_of_match),1695 },1696 .probe = lm85_probe,1697 .id_table = lm85_id,1698 .detect = lm85_detect,1699 .address_list = normal_i2c,1700};1701 1702module_i2c_driver(lm85_driver);1703 1704MODULE_LICENSE("GPL");1705MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "1706 "Margit Schubert-While <margitsw@t-online.de>, "1707 "Justin Thiessen <jthiessen@penguincomputing.com>");1708MODULE_DESCRIPTION("LM85-B, LM85-C driver");1709