cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

lm87.c (29814B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * lm87.c
      4 *
      5 * Copyright (C) 2000       Frodo Looijaard <frodol@dds.nl>
      6 *                          Philip Edelbrock <phil@netroedge.com>
      7 *                          Stephen Rousset <stephen.rousset@rocketlogix.com>
      8 *                          Dan Eaton <dan.eaton@rocketlogix.com>
      9 * Copyright (C) 2004-2008  Jean Delvare <jdelvare@suse.de>
     10 *
     11 * Original port to Linux 2.6 by Jeff Oliver.
     12 *
     13 * The LM87 is a sensor chip made by National Semiconductor. It monitors up
     14 * to 8 voltages (including its own power source), up to three temperatures
     15 * (its own plus up to two external ones) and up to two fans. The default
     16 * configuration is 6 voltages, two temperatures and two fans (see below).
     17 * Voltages are scaled internally with ratios such that the nominal value of
     18 * each voltage correspond to a register value of 192 (which means a
     19 * resolution of about 0.5% of the nominal value). Temperature values are
     20 * reported with a 1 deg resolution and a 3-4 deg accuracy. Complete
     21 * datasheet can be obtained from National's website at:
     22 *   http://www.national.com/pf/LM/LM87.html
     23 *
     24 * Some functions share pins, so not all functions are available at the same
     25 * time. Which are depends on the hardware setup. This driver normally
     26 * assumes that firmware configured the chip correctly. Where this is not
     27 * the case, platform code must set the I2C client's platform_data to point
     28 * to a u8 value to be written to the channel register.
     29 * For reference, here is the list of exclusive functions:
     30 *  - in0+in5 (default) or temp3
     31 *  - fan1 (default) or in6
     32 *  - fan2 (default) or in7
     33 *  - VID lines (default) or IRQ lines (not handled by this driver)
     34 *
     35 * The LM87 additionally features an analog output, supposedly usable to
     36 * control the speed of a fan. All new chips use pulse width modulation
     37 * instead. The LM87 is the only hardware monitoring chipset I know of
     38 * which uses amplitude modulation. Be careful when using this feature.
     39 *
     40 * This driver also supports the ADM1024, a sensor chip made by Analog
     41 * Devices. That chip is fully compatible with the LM87. Complete
     42 * datasheet can be obtained from Analog's website at:
     43 *   https://www.analog.com/en/prod/0,2877,ADM1024,00.html
     44 */
     45
     46#include <linux/module.h>
     47#include <linux/init.h>
     48#include <linux/slab.h>
     49#include <linux/jiffies.h>
     50#include <linux/i2c.h>
     51#include <linux/hwmon.h>
     52#include <linux/hwmon-sysfs.h>
     53#include <linux/hwmon-vid.h>
     54#include <linux/err.h>
     55#include <linux/mutex.h>
     56#include <linux/regulator/consumer.h>
     57
     58/*
     59 * Addresses to scan
     60 * LM87 has three possible addresses: 0x2c, 0x2d and 0x2e.
     61 */
     62
     63static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
     64
     65/*
     66 * The LM87 registers
     67 */
     68
     69/* nr in 0..5 */
     70#define LM87_REG_IN(nr)			(0x20 + (nr))
     71#define LM87_REG_IN_MAX(nr)		(0x2B + (nr) * 2)
     72#define LM87_REG_IN_MIN(nr)		(0x2C + (nr) * 2)
     73/* nr in 0..1 */
     74#define LM87_REG_AIN(nr)		(0x28 + (nr))
     75#define LM87_REG_AIN_MIN(nr)		(0x1A + (nr))
     76#define LM87_REG_AIN_MAX(nr)		(0x3B + (nr))
     77
     78static u8 LM87_REG_TEMP[3] = { 0x27, 0x26, 0x20 };
     79static u8 LM87_REG_TEMP_HIGH[3] = { 0x39, 0x37, 0x2B };
     80static u8 LM87_REG_TEMP_LOW[3] = { 0x3A, 0x38, 0x2C };
     81
     82#define LM87_REG_TEMP_HW_INT_LOCK	0x13
     83#define LM87_REG_TEMP_HW_EXT_LOCK	0x14
     84#define LM87_REG_TEMP_HW_INT		0x17
     85#define LM87_REG_TEMP_HW_EXT		0x18
     86
     87/* nr in 0..1 */
     88#define LM87_REG_FAN(nr)		(0x28 + (nr))
     89#define LM87_REG_FAN_MIN(nr)		(0x3B + (nr))
     90#define LM87_REG_AOUT			0x19
     91
     92#define LM87_REG_CONFIG			0x40
     93#define LM87_REG_CHANNEL_MODE		0x16
     94#define LM87_REG_VID_FAN_DIV		0x47
     95#define LM87_REG_VID4			0x49
     96
     97#define LM87_REG_ALARMS1		0x41
     98#define LM87_REG_ALARMS2		0x42
     99
    100#define LM87_REG_COMPANY_ID		0x3E
    101#define LM87_REG_REVISION		0x3F
    102
    103/*
    104 * Conversions and various macros
    105 * The LM87 uses signed 8-bit values for temperatures.
    106 */
    107
    108#define IN_FROM_REG(reg, scale)	(((reg) * (scale) + 96) / 192)
    109#define IN_TO_REG(val, scale)	((val) <= 0 ? 0 : \
    110				 (val) >= (scale) * 255 / 192 ? 255 : \
    111				 ((val) * 192 + (scale) / 2) / (scale))
    112
    113#define TEMP_FROM_REG(reg)	((reg) * 1000)
    114#define TEMP_TO_REG(val)	((val) <= -127500 ? -128 : \
    115				 (val) >= 126500 ? 127 : \
    116				 (((val) < 0 ? (val) - 500 : \
    117				   (val) + 500) / 1000))
    118
    119#define FAN_FROM_REG(reg, div)	((reg) == 255 || (reg) == 0 ? 0 : \
    120				 (1350000 + (reg)*(div) / 2) / ((reg) * (div)))
    121#define FAN_TO_REG(val, div)	((val) * (div) * 255 <= 1350000 ? 255 : \
    122				 (1350000 + (val)*(div) / 2) / ((val) * (div)))
    123
    124#define FAN_DIV_FROM_REG(reg)	(1 << (reg))
    125
    126/* analog out is 9.80mV/LSB */
    127#define AOUT_FROM_REG(reg)	(((reg) * 98 + 5) / 10)
    128#define AOUT_TO_REG(val)	((val) <= 0 ? 0 : \
    129				 (val) >= 2500 ? 255 : \
    130				 ((val) * 10 + 49) / 98)
    131
    132/* nr in 0..1 */
    133#define CHAN_NO_FAN(nr)		(1 << (nr))
    134#define CHAN_TEMP3		(1 << 2)
    135#define CHAN_VCC_5V		(1 << 3)
    136#define CHAN_NO_VID		(1 << 7)
    137
    138/*
    139 * Client data (each client gets its own)
    140 */
    141
    142struct lm87_data {
    143	struct mutex update_lock;
    144	bool valid; /* false until following fields are valid */
    145	unsigned long last_updated; /* In jiffies */
    146
    147	u8 channel;		/* register value */
    148	u8 config;		/* original register value */
    149
    150	u8 in[8];		/* register value */
    151	u8 in_max[8];		/* register value */
    152	u8 in_min[8];		/* register value */
    153	u16 in_scale[8];
    154
    155	s8 temp[3];		/* register value */
    156	s8 temp_high[3];	/* register value */
    157	s8 temp_low[3];		/* register value */
    158	s8 temp_crit_int;	/* min of two register values */
    159	s8 temp_crit_ext;	/* min of two register values */
    160
    161	u8 fan[2];		/* register value */
    162	u8 fan_min[2];		/* register value */
    163	u8 fan_div[2];		/* register value, shifted right */
    164	u8 aout;		/* register value */
    165
    166	u16 alarms;		/* register values, combined */
    167	u8 vid;			/* register values, combined */
    168	u8 vrm;
    169
    170	const struct attribute_group *attr_groups[6];
    171};
    172
    173static inline int lm87_read_value(struct i2c_client *client, u8 reg)
    174{
    175	return i2c_smbus_read_byte_data(client, reg);
    176}
    177
    178static inline int lm87_write_value(struct i2c_client *client, u8 reg, u8 value)
    179{
    180	return i2c_smbus_write_byte_data(client, reg, value);
    181}
    182
    183static struct lm87_data *lm87_update_device(struct device *dev)
    184{
    185	struct i2c_client *client = dev_get_drvdata(dev);
    186	struct lm87_data *data = i2c_get_clientdata(client);
    187
    188	mutex_lock(&data->update_lock);
    189
    190	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
    191		int i, j;
    192
    193		dev_dbg(&client->dev, "Updating data.\n");
    194
    195		i = (data->channel & CHAN_TEMP3) ? 1 : 0;
    196		j = (data->channel & CHAN_TEMP3) ? 5 : 6;
    197		for (; i < j; i++) {
    198			data->in[i] = lm87_read_value(client,
    199				      LM87_REG_IN(i));
    200			data->in_min[i] = lm87_read_value(client,
    201					  LM87_REG_IN_MIN(i));
    202			data->in_max[i] = lm87_read_value(client,
    203					  LM87_REG_IN_MAX(i));
    204		}
    205
    206		for (i = 0; i < 2; i++) {
    207			if (data->channel & CHAN_NO_FAN(i)) {
    208				data->in[6+i] = lm87_read_value(client,
    209						LM87_REG_AIN(i));
    210				data->in_max[6+i] = lm87_read_value(client,
    211						    LM87_REG_AIN_MAX(i));
    212				data->in_min[6+i] = lm87_read_value(client,
    213						    LM87_REG_AIN_MIN(i));
    214
    215			} else {
    216				data->fan[i] = lm87_read_value(client,
    217					       LM87_REG_FAN(i));
    218				data->fan_min[i] = lm87_read_value(client,
    219						   LM87_REG_FAN_MIN(i));
    220			}
    221		}
    222
    223		j = (data->channel & CHAN_TEMP3) ? 3 : 2;
    224		for (i = 0 ; i < j; i++) {
    225			data->temp[i] = lm87_read_value(client,
    226					LM87_REG_TEMP[i]);
    227			data->temp_high[i] = lm87_read_value(client,
    228					     LM87_REG_TEMP_HIGH[i]);
    229			data->temp_low[i] = lm87_read_value(client,
    230					    LM87_REG_TEMP_LOW[i]);
    231		}
    232
    233		i = lm87_read_value(client, LM87_REG_TEMP_HW_INT_LOCK);
    234		j = lm87_read_value(client, LM87_REG_TEMP_HW_INT);
    235		data->temp_crit_int = min(i, j);
    236
    237		i = lm87_read_value(client, LM87_REG_TEMP_HW_EXT_LOCK);
    238		j = lm87_read_value(client, LM87_REG_TEMP_HW_EXT);
    239		data->temp_crit_ext = min(i, j);
    240
    241		i = lm87_read_value(client, LM87_REG_VID_FAN_DIV);
    242		data->fan_div[0] = (i >> 4) & 0x03;
    243		data->fan_div[1] = (i >> 6) & 0x03;
    244		data->vid = (i & 0x0F)
    245			  | (lm87_read_value(client, LM87_REG_VID4) & 0x01)
    246			     << 4;
    247
    248		data->alarms = lm87_read_value(client, LM87_REG_ALARMS1)
    249			     | (lm87_read_value(client, LM87_REG_ALARMS2)
    250				<< 8);
    251		data->aout = lm87_read_value(client, LM87_REG_AOUT);
    252
    253		data->last_updated = jiffies;
    254		data->valid = true;
    255	}
    256
    257	mutex_unlock(&data->update_lock);
    258
    259	return data;
    260}
    261
    262/*
    263 * Sysfs stuff
    264 */
    265
    266static ssize_t in_input_show(struct device *dev,
    267			     struct device_attribute *attr, char *buf)
    268{
    269	struct lm87_data *data = lm87_update_device(dev);
    270	int nr = to_sensor_dev_attr(attr)->index;
    271
    272	return sprintf(buf, "%u\n", IN_FROM_REG(data->in[nr],
    273		       data->in_scale[nr]));
    274}
    275
    276static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
    277			   char *buf)
    278{
    279	struct lm87_data *data = lm87_update_device(dev);
    280	int nr = to_sensor_dev_attr(attr)->index;
    281
    282	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[nr],
    283		       data->in_scale[nr]));
    284}
    285
    286static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
    287			   char *buf)
    288{
    289	struct lm87_data *data = lm87_update_device(dev);
    290	int nr = to_sensor_dev_attr(attr)->index;
    291
    292	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[nr],
    293		       data->in_scale[nr]));
    294}
    295
    296static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
    297			    const char *buf, size_t count)
    298{
    299	struct i2c_client *client = dev_get_drvdata(dev);
    300	struct lm87_data *data = i2c_get_clientdata(client);
    301	int nr = to_sensor_dev_attr(attr)->index;
    302	long val;
    303	int err;
    304
    305	err = kstrtol(buf, 10, &val);
    306	if (err)
    307		return err;
    308
    309	mutex_lock(&data->update_lock);
    310	data->in_min[nr] = IN_TO_REG(val, data->in_scale[nr]);
    311	lm87_write_value(client, nr < 6 ? LM87_REG_IN_MIN(nr) :
    312			 LM87_REG_AIN_MIN(nr - 6), data->in_min[nr]);
    313	mutex_unlock(&data->update_lock);
    314	return count;
    315}
    316
    317static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
    318			    const char *buf, size_t count)
    319{
    320	struct i2c_client *client = dev_get_drvdata(dev);
    321	struct lm87_data *data = i2c_get_clientdata(client);
    322	int nr = to_sensor_dev_attr(attr)->index;
    323	long val;
    324	int err;
    325
    326	err = kstrtol(buf, 10, &val);
    327	if (err)
    328		return err;
    329
    330	mutex_lock(&data->update_lock);
    331	data->in_max[nr] = IN_TO_REG(val, data->in_scale[nr]);
    332	lm87_write_value(client, nr < 6 ? LM87_REG_IN_MAX(nr) :
    333			 LM87_REG_AIN_MAX(nr - 6), data->in_max[nr]);
    334	mutex_unlock(&data->update_lock);
    335	return count;
    336}
    337
    338static SENSOR_DEVICE_ATTR_RO(in0_input, in_input, 0);
    339static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
    340static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
    341static SENSOR_DEVICE_ATTR_RO(in1_input, in_input, 1);
    342static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
    343static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
    344static SENSOR_DEVICE_ATTR_RO(in2_input, in_input, 2);
    345static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
    346static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
    347static SENSOR_DEVICE_ATTR_RO(in3_input, in_input, 3);
    348static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
    349static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
    350static SENSOR_DEVICE_ATTR_RO(in4_input, in_input, 4);
    351static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
    352static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
    353static SENSOR_DEVICE_ATTR_RO(in5_input, in_input, 5);
    354static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
    355static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
    356static SENSOR_DEVICE_ATTR_RO(in6_input, in_input, 6);
    357static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
    358static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
    359static SENSOR_DEVICE_ATTR_RO(in7_input, in_input, 7);
    360static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
    361static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
    362
    363static ssize_t temp_input_show(struct device *dev,
    364			       struct device_attribute *attr, char *buf)
    365{
    366	struct lm87_data *data = lm87_update_device(dev);
    367	int nr = to_sensor_dev_attr(attr)->index;
    368
    369	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
    370}
    371
    372static ssize_t temp_low_show(struct device *dev,
    373			     struct device_attribute *attr, char *buf)
    374{
    375	struct lm87_data *data = lm87_update_device(dev);
    376	int nr = to_sensor_dev_attr(attr)->index;
    377
    378	return sprintf(buf, "%d\n",
    379		       TEMP_FROM_REG(data->temp_low[nr]));
    380}
    381
    382static ssize_t temp_high_show(struct device *dev,
    383			      struct device_attribute *attr, char *buf)
    384{
    385	struct lm87_data *data = lm87_update_device(dev);
    386	int nr = to_sensor_dev_attr(attr)->index;
    387
    388	return sprintf(buf, "%d\n",
    389		       TEMP_FROM_REG(data->temp_high[nr]));
    390}
    391
    392static ssize_t temp_low_store(struct device *dev,
    393			      struct device_attribute *attr, const char *buf,
    394			      size_t count)
    395{
    396	struct i2c_client *client = dev_get_drvdata(dev);
    397	struct lm87_data *data = i2c_get_clientdata(client);
    398	int nr = to_sensor_dev_attr(attr)->index;
    399	long val;
    400	int err;
    401
    402	err = kstrtol(buf, 10, &val);
    403	if (err)
    404		return err;
    405
    406	mutex_lock(&data->update_lock);
    407	data->temp_low[nr] = TEMP_TO_REG(val);
    408	lm87_write_value(client, LM87_REG_TEMP_LOW[nr], data->temp_low[nr]);
    409	mutex_unlock(&data->update_lock);
    410	return count;
    411}
    412
    413static ssize_t temp_high_store(struct device *dev,
    414			       struct device_attribute *attr, const char *buf,
    415			       size_t count)
    416{
    417	struct i2c_client *client = dev_get_drvdata(dev);
    418	struct lm87_data *data = i2c_get_clientdata(client);
    419	int nr = to_sensor_dev_attr(attr)->index;
    420	long val;
    421	int err;
    422
    423	err = kstrtol(buf, 10, &val);
    424	if (err)
    425		return err;
    426
    427	mutex_lock(&data->update_lock);
    428	data->temp_high[nr] = TEMP_TO_REG(val);
    429	lm87_write_value(client, LM87_REG_TEMP_HIGH[nr], data->temp_high[nr]);
    430	mutex_unlock(&data->update_lock);
    431	return count;
    432}
    433
    434static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
    435static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_low, 0);
    436static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_high, 0);
    437static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
    438static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_low, 1);
    439static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_high, 1);
    440static SENSOR_DEVICE_ATTR_RO(temp3_input, temp_input, 2);
    441static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_low, 2);
    442static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_high, 2);
    443
    444static ssize_t temp1_crit_show(struct device *dev,
    445			       struct device_attribute *attr, char *buf)
    446{
    447	struct lm87_data *data = lm87_update_device(dev);
    448	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit_int));
    449}
    450
    451static ssize_t temp2_crit_show(struct device *dev,
    452			       struct device_attribute *attr, char *buf)
    453{
    454	struct lm87_data *data = lm87_update_device(dev);
    455	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit_ext));
    456}
    457
    458static DEVICE_ATTR_RO(temp1_crit);
    459static DEVICE_ATTR_RO(temp2_crit);
    460static DEVICE_ATTR(temp3_crit, 0444, temp2_crit_show, NULL);
    461
    462static ssize_t fan_input_show(struct device *dev,
    463			      struct device_attribute *attr, char *buf)
    464{
    465	struct lm87_data *data = lm87_update_device(dev);
    466	int nr = to_sensor_dev_attr(attr)->index;
    467
    468	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
    469		       FAN_DIV_FROM_REG(data->fan_div[nr])));
    470}
    471
    472static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
    473			    char *buf)
    474{
    475	struct lm87_data *data = lm87_update_device(dev);
    476	int nr = to_sensor_dev_attr(attr)->index;
    477
    478	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
    479		       FAN_DIV_FROM_REG(data->fan_div[nr])));
    480}
    481
    482static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
    483			    char *buf)
    484{
    485	struct lm87_data *data = lm87_update_device(dev);
    486	int nr = to_sensor_dev_attr(attr)->index;
    487
    488	return sprintf(buf, "%d\n",
    489		       FAN_DIV_FROM_REG(data->fan_div[nr]));
    490}
    491
    492static ssize_t fan_min_store(struct device *dev,
    493			     struct device_attribute *attr, const char *buf,
    494			     size_t count)
    495{
    496	struct i2c_client *client = dev_get_drvdata(dev);
    497	struct lm87_data *data = i2c_get_clientdata(client);
    498	int nr = to_sensor_dev_attr(attr)->index;
    499	long val;
    500	int err;
    501
    502	err = kstrtol(buf, 10, &val);
    503	if (err)
    504		return err;
    505
    506	mutex_lock(&data->update_lock);
    507	data->fan_min[nr] = FAN_TO_REG(val,
    508			    FAN_DIV_FROM_REG(data->fan_div[nr]));
    509	lm87_write_value(client, LM87_REG_FAN_MIN(nr), data->fan_min[nr]);
    510	mutex_unlock(&data->update_lock);
    511	return count;
    512}
    513
    514/*
    515 * Note: we save and restore the fan minimum here, because its value is
    516 * determined in part by the fan clock divider.  This follows the principle
    517 * of least surprise; the user doesn't expect the fan minimum to change just
    518 * because the divider changed.
    519 */
    520static ssize_t fan_div_store(struct device *dev,
    521			     struct device_attribute *attr, const char *buf,
    522			     size_t count)
    523{
    524	struct i2c_client *client = dev_get_drvdata(dev);
    525	struct lm87_data *data = i2c_get_clientdata(client);
    526	int nr = to_sensor_dev_attr(attr)->index;
    527	long val;
    528	int err;
    529	unsigned long min;
    530	u8 reg;
    531
    532	err = kstrtol(buf, 10, &val);
    533	if (err)
    534		return err;
    535
    536	mutex_lock(&data->update_lock);
    537	min = FAN_FROM_REG(data->fan_min[nr],
    538			   FAN_DIV_FROM_REG(data->fan_div[nr]));
    539
    540	switch (val) {
    541	case 1:
    542		data->fan_div[nr] = 0;
    543		break;
    544	case 2:
    545		data->fan_div[nr] = 1;
    546		break;
    547	case 4:
    548		data->fan_div[nr] = 2;
    549		break;
    550	case 8:
    551		data->fan_div[nr] = 3;
    552		break;
    553	default:
    554		mutex_unlock(&data->update_lock);
    555		return -EINVAL;
    556	}
    557
    558	reg = lm87_read_value(client, LM87_REG_VID_FAN_DIV);
    559	switch (nr) {
    560	case 0:
    561	    reg = (reg & 0xCF) | (data->fan_div[0] << 4);
    562	    break;
    563	case 1:
    564	    reg = (reg & 0x3F) | (data->fan_div[1] << 6);
    565	    break;
    566	}
    567	lm87_write_value(client, LM87_REG_VID_FAN_DIV, reg);
    568
    569	data->fan_min[nr] = FAN_TO_REG(min, val);
    570	lm87_write_value(client, LM87_REG_FAN_MIN(nr),
    571			 data->fan_min[nr]);
    572	mutex_unlock(&data->update_lock);
    573
    574	return count;
    575}
    576
    577static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
    578static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
    579static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
    580static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
    581static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
    582static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
    583
    584static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
    585			   char *buf)
    586{
    587	struct lm87_data *data = lm87_update_device(dev);
    588	return sprintf(buf, "%d\n", data->alarms);
    589}
    590static DEVICE_ATTR_RO(alarms);
    591
    592static ssize_t cpu0_vid_show(struct device *dev,
    593			     struct device_attribute *attr, char *buf)
    594{
    595	struct lm87_data *data = lm87_update_device(dev);
    596	return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
    597}
    598static DEVICE_ATTR_RO(cpu0_vid);
    599
    600static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
    601			char *buf)
    602{
    603	struct lm87_data *data = dev_get_drvdata(dev);
    604	return sprintf(buf, "%d\n", data->vrm);
    605}
    606static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
    607			 const char *buf, size_t count)
    608{
    609	struct lm87_data *data = dev_get_drvdata(dev);
    610	unsigned long val;
    611	int err;
    612
    613	err = kstrtoul(buf, 10, &val);
    614	if (err)
    615		return err;
    616
    617	if (val > 255)
    618		return -EINVAL;
    619
    620	data->vrm = val;
    621	return count;
    622}
    623static DEVICE_ATTR_RW(vrm);
    624
    625static ssize_t aout_output_show(struct device *dev,
    626				struct device_attribute *attr, char *buf)
    627{
    628	struct lm87_data *data = lm87_update_device(dev);
    629	return sprintf(buf, "%d\n", AOUT_FROM_REG(data->aout));
    630}
    631static ssize_t aout_output_store(struct device *dev,
    632				 struct device_attribute *attr,
    633				 const char *buf, size_t count)
    634{
    635	struct i2c_client *client = dev_get_drvdata(dev);
    636	struct lm87_data *data = i2c_get_clientdata(client);
    637	long val;
    638	int err;
    639
    640	err = kstrtol(buf, 10, &val);
    641	if (err)
    642		return err;
    643
    644	mutex_lock(&data->update_lock);
    645	data->aout = AOUT_TO_REG(val);
    646	lm87_write_value(client, LM87_REG_AOUT, data->aout);
    647	mutex_unlock(&data->update_lock);
    648	return count;
    649}
    650static DEVICE_ATTR_RW(aout_output);
    651
    652static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
    653			  char *buf)
    654{
    655	struct lm87_data *data = lm87_update_device(dev);
    656	int bitnr = to_sensor_dev_attr(attr)->index;
    657	return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
    658}
    659static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
    660static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
    661static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
    662static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
    663static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
    664static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9);
    665static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 6);
    666static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 7);
    667static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
    668static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);
    669static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 5);
    670static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
    671static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
    672static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 14);
    673static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 15);
    674
    675/*
    676 * Real code
    677 */
    678
    679static struct attribute *lm87_attributes[] = {
    680	&sensor_dev_attr_in1_input.dev_attr.attr,
    681	&sensor_dev_attr_in1_min.dev_attr.attr,
    682	&sensor_dev_attr_in1_max.dev_attr.attr,
    683	&sensor_dev_attr_in1_alarm.dev_attr.attr,
    684	&sensor_dev_attr_in2_input.dev_attr.attr,
    685	&sensor_dev_attr_in2_min.dev_attr.attr,
    686	&sensor_dev_attr_in2_max.dev_attr.attr,
    687	&sensor_dev_attr_in2_alarm.dev_attr.attr,
    688	&sensor_dev_attr_in3_input.dev_attr.attr,
    689	&sensor_dev_attr_in3_min.dev_attr.attr,
    690	&sensor_dev_attr_in3_max.dev_attr.attr,
    691	&sensor_dev_attr_in3_alarm.dev_attr.attr,
    692	&sensor_dev_attr_in4_input.dev_attr.attr,
    693	&sensor_dev_attr_in4_min.dev_attr.attr,
    694	&sensor_dev_attr_in4_max.dev_attr.attr,
    695	&sensor_dev_attr_in4_alarm.dev_attr.attr,
    696
    697	&sensor_dev_attr_temp1_input.dev_attr.attr,
    698	&sensor_dev_attr_temp1_max.dev_attr.attr,
    699	&sensor_dev_attr_temp1_min.dev_attr.attr,
    700	&dev_attr_temp1_crit.attr,
    701	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
    702	&sensor_dev_attr_temp2_input.dev_attr.attr,
    703	&sensor_dev_attr_temp2_max.dev_attr.attr,
    704	&sensor_dev_attr_temp2_min.dev_attr.attr,
    705	&dev_attr_temp2_crit.attr,
    706	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
    707	&sensor_dev_attr_temp2_fault.dev_attr.attr,
    708
    709	&dev_attr_alarms.attr,
    710	&dev_attr_aout_output.attr,
    711
    712	NULL
    713};
    714
    715static const struct attribute_group lm87_group = {
    716	.attrs = lm87_attributes,
    717};
    718
    719static struct attribute *lm87_attributes_in6[] = {
    720	&sensor_dev_attr_in6_input.dev_attr.attr,
    721	&sensor_dev_attr_in6_min.dev_attr.attr,
    722	&sensor_dev_attr_in6_max.dev_attr.attr,
    723	&sensor_dev_attr_in6_alarm.dev_attr.attr,
    724	NULL
    725};
    726
    727static const struct attribute_group lm87_group_in6 = {
    728	.attrs = lm87_attributes_in6,
    729};
    730
    731static struct attribute *lm87_attributes_fan1[] = {
    732	&sensor_dev_attr_fan1_input.dev_attr.attr,
    733	&sensor_dev_attr_fan1_min.dev_attr.attr,
    734	&sensor_dev_attr_fan1_div.dev_attr.attr,
    735	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
    736	NULL
    737};
    738
    739static const struct attribute_group lm87_group_fan1 = {
    740	.attrs = lm87_attributes_fan1,
    741};
    742
    743static struct attribute *lm87_attributes_in7[] = {
    744	&sensor_dev_attr_in7_input.dev_attr.attr,
    745	&sensor_dev_attr_in7_min.dev_attr.attr,
    746	&sensor_dev_attr_in7_max.dev_attr.attr,
    747	&sensor_dev_attr_in7_alarm.dev_attr.attr,
    748	NULL
    749};
    750
    751static const struct attribute_group lm87_group_in7 = {
    752	.attrs = lm87_attributes_in7,
    753};
    754
    755static struct attribute *lm87_attributes_fan2[] = {
    756	&sensor_dev_attr_fan2_input.dev_attr.attr,
    757	&sensor_dev_attr_fan2_min.dev_attr.attr,
    758	&sensor_dev_attr_fan2_div.dev_attr.attr,
    759	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
    760	NULL
    761};
    762
    763static const struct attribute_group lm87_group_fan2 = {
    764	.attrs = lm87_attributes_fan2,
    765};
    766
    767static struct attribute *lm87_attributes_temp3[] = {
    768	&sensor_dev_attr_temp3_input.dev_attr.attr,
    769	&sensor_dev_attr_temp3_max.dev_attr.attr,
    770	&sensor_dev_attr_temp3_min.dev_attr.attr,
    771	&dev_attr_temp3_crit.attr,
    772	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
    773	&sensor_dev_attr_temp3_fault.dev_attr.attr,
    774	NULL
    775};
    776
    777static const struct attribute_group lm87_group_temp3 = {
    778	.attrs = lm87_attributes_temp3,
    779};
    780
    781static struct attribute *lm87_attributes_in0_5[] = {
    782	&sensor_dev_attr_in0_input.dev_attr.attr,
    783	&sensor_dev_attr_in0_min.dev_attr.attr,
    784	&sensor_dev_attr_in0_max.dev_attr.attr,
    785	&sensor_dev_attr_in0_alarm.dev_attr.attr,
    786	&sensor_dev_attr_in5_input.dev_attr.attr,
    787	&sensor_dev_attr_in5_min.dev_attr.attr,
    788	&sensor_dev_attr_in5_max.dev_attr.attr,
    789	&sensor_dev_attr_in5_alarm.dev_attr.attr,
    790	NULL
    791};
    792
    793static const struct attribute_group lm87_group_in0_5 = {
    794	.attrs = lm87_attributes_in0_5,
    795};
    796
    797static struct attribute *lm87_attributes_vid[] = {
    798	&dev_attr_cpu0_vid.attr,
    799	&dev_attr_vrm.attr,
    800	NULL
    801};
    802
    803static const struct attribute_group lm87_group_vid = {
    804	.attrs = lm87_attributes_vid,
    805};
    806
    807/* Return 0 if detection is successful, -ENODEV otherwise */
    808static int lm87_detect(struct i2c_client *client, struct i2c_board_info *info)
    809{
    810	struct i2c_adapter *adapter = client->adapter;
    811	const char *name;
    812	u8 cid, rev;
    813
    814	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
    815		return -ENODEV;
    816
    817	if (lm87_read_value(client, LM87_REG_CONFIG) & 0x80)
    818		return -ENODEV;
    819
    820	/* Now, we do the remaining detection. */
    821	cid = lm87_read_value(client, LM87_REG_COMPANY_ID);
    822	rev = lm87_read_value(client, LM87_REG_REVISION);
    823
    824	if (cid == 0x02			/* National Semiconductor */
    825	 && (rev >= 0x01 && rev <= 0x08))
    826		name = "lm87";
    827	else if (cid == 0x41		/* Analog Devices */
    828	      && (rev & 0xf0) == 0x10)
    829		name = "adm1024";
    830	else {
    831		dev_dbg(&adapter->dev, "LM87 detection failed at 0x%02x\n",
    832			client->addr);
    833		return -ENODEV;
    834	}
    835
    836	strlcpy(info->type, name, I2C_NAME_SIZE);
    837
    838	return 0;
    839}
    840
    841static void lm87_restore_config(void *arg)
    842{
    843	struct i2c_client *client = arg;
    844	struct lm87_data *data = i2c_get_clientdata(client);
    845
    846	lm87_write_value(client, LM87_REG_CONFIG, data->config);
    847}
    848
    849static int lm87_init_client(struct i2c_client *client)
    850{
    851	struct lm87_data *data = i2c_get_clientdata(client);
    852	int rc;
    853	struct device_node *of_node = client->dev.of_node;
    854	u8 val = 0;
    855	struct regulator *vcc = NULL;
    856
    857	if (of_node) {
    858		if (of_property_read_bool(of_node, "has-temp3"))
    859			val |= CHAN_TEMP3;
    860		if (of_property_read_bool(of_node, "has-in6"))
    861			val |= CHAN_NO_FAN(0);
    862		if (of_property_read_bool(of_node, "has-in7"))
    863			val |= CHAN_NO_FAN(1);
    864		vcc = devm_regulator_get_optional(&client->dev, "vcc");
    865		if (!IS_ERR(vcc)) {
    866			if (regulator_get_voltage(vcc) == 5000000)
    867				val |= CHAN_VCC_5V;
    868		}
    869		data->channel = val;
    870		lm87_write_value(client,
    871				LM87_REG_CHANNEL_MODE, data->channel);
    872	} else if (dev_get_platdata(&client->dev)) {
    873		data->channel = *(u8 *)dev_get_platdata(&client->dev);
    874		lm87_write_value(client,
    875				 LM87_REG_CHANNEL_MODE, data->channel);
    876	} else {
    877		data->channel = lm87_read_value(client, LM87_REG_CHANNEL_MODE);
    878	}
    879	data->config = lm87_read_value(client, LM87_REG_CONFIG) & 0x6F;
    880
    881	rc = devm_add_action(&client->dev, lm87_restore_config, client);
    882	if (rc)
    883		return rc;
    884
    885	if (!(data->config & 0x01)) {
    886		int i;
    887
    888		/* Limits are left uninitialized after power-up */
    889		for (i = 1; i < 6; i++) {
    890			lm87_write_value(client, LM87_REG_IN_MIN(i), 0x00);
    891			lm87_write_value(client, LM87_REG_IN_MAX(i), 0xFF);
    892		}
    893		for (i = 0; i < 2; i++) {
    894			lm87_write_value(client, LM87_REG_TEMP_HIGH[i], 0x7F);
    895			lm87_write_value(client, LM87_REG_TEMP_LOW[i], 0x00);
    896			lm87_write_value(client, LM87_REG_AIN_MIN(i), 0x00);
    897			lm87_write_value(client, LM87_REG_AIN_MAX(i), 0xFF);
    898		}
    899		if (data->channel & CHAN_TEMP3) {
    900			lm87_write_value(client, LM87_REG_TEMP_HIGH[2], 0x7F);
    901			lm87_write_value(client, LM87_REG_TEMP_LOW[2], 0x00);
    902		} else {
    903			lm87_write_value(client, LM87_REG_IN_MIN(0), 0x00);
    904			lm87_write_value(client, LM87_REG_IN_MAX(0), 0xFF);
    905		}
    906	}
    907
    908	/* Make sure Start is set and INT#_Clear is clear */
    909	if ((data->config & 0x09) != 0x01)
    910		lm87_write_value(client, LM87_REG_CONFIG,
    911				 (data->config & 0x77) | 0x01);
    912	return 0;
    913}
    914
    915static int lm87_probe(struct i2c_client *client)
    916{
    917	struct lm87_data *data;
    918	struct device *hwmon_dev;
    919	int err;
    920	unsigned int group_tail = 0;
    921
    922	data = devm_kzalloc(&client->dev, sizeof(struct lm87_data), GFP_KERNEL);
    923	if (!data)
    924		return -ENOMEM;
    925
    926	i2c_set_clientdata(client, data);
    927	mutex_init(&data->update_lock);
    928
    929	/* Initialize the LM87 chip */
    930	err = lm87_init_client(client);
    931	if (err)
    932		return err;
    933
    934	data->in_scale[0] = 2500;
    935	data->in_scale[1] = 2700;
    936	data->in_scale[2] = (data->channel & CHAN_VCC_5V) ? 5000 : 3300;
    937	data->in_scale[3] = 5000;
    938	data->in_scale[4] = 12000;
    939	data->in_scale[5] = 2700;
    940	data->in_scale[6] = 1875;
    941	data->in_scale[7] = 1875;
    942
    943	/*
    944	 * Construct the list of attributes, the list depends on the
    945	 * configuration of the chip
    946	 */
    947	data->attr_groups[group_tail++] = &lm87_group;
    948	if (data->channel & CHAN_NO_FAN(0))
    949		data->attr_groups[group_tail++] = &lm87_group_in6;
    950	else
    951		data->attr_groups[group_tail++] = &lm87_group_fan1;
    952
    953	if (data->channel & CHAN_NO_FAN(1))
    954		data->attr_groups[group_tail++] = &lm87_group_in7;
    955	else
    956		data->attr_groups[group_tail++] = &lm87_group_fan2;
    957
    958	if (data->channel & CHAN_TEMP3)
    959		data->attr_groups[group_tail++] = &lm87_group_temp3;
    960	else
    961		data->attr_groups[group_tail++] = &lm87_group_in0_5;
    962
    963	if (!(data->channel & CHAN_NO_VID)) {
    964		data->vrm = vid_which_vrm();
    965		data->attr_groups[group_tail++] = &lm87_group_vid;
    966	}
    967
    968	hwmon_dev = devm_hwmon_device_register_with_groups(
    969	    &client->dev, client->name, client, data->attr_groups);
    970	return PTR_ERR_OR_ZERO(hwmon_dev);
    971}
    972
    973/*
    974 * Driver data (common to all clients)
    975 */
    976
    977static const struct i2c_device_id lm87_id[] = {
    978	{ "lm87", 0 },
    979	{ "adm1024", 0 },
    980	{ }
    981};
    982MODULE_DEVICE_TABLE(i2c, lm87_id);
    983
    984static const struct of_device_id lm87_of_match[] = {
    985	{ .compatible = "ti,lm87" },
    986	{ .compatible = "adi,adm1024" },
    987	{ },
    988};
    989MODULE_DEVICE_TABLE(of, lm87_of_match);
    990
    991static struct i2c_driver lm87_driver = {
    992	.class		= I2C_CLASS_HWMON,
    993	.driver = {
    994		.name	= "lm87",
    995		.of_match_table = lm87_of_match,
    996	},
    997	.probe_new	= lm87_probe,
    998	.id_table	= lm87_id,
    999	.detect		= lm87_detect,
   1000	.address_list	= normal_i2c,
   1001};
   1002
   1003module_i2c_driver(lm87_driver);
   1004
   1005MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de> and others");
   1006MODULE_DESCRIPTION("LM87 driver");
   1007MODULE_LICENSE("GPL");