2019-05-20 10:19:02 +03:00
// SPDX-License-Identifier: GPL-2.0-or-later
2005-04-30 15:41:29 +04:00
/*
* adm9240 . c Part of lm_sensors , Linux kernel modules for hardware
2012-01-15 01:12:38 +04:00
* monitoring
2005-04-30 15:41:29 +04:00
*
* Copyright ( C ) 1999 Frodo Looijaard < frodol @ dds . nl >
* Philip Edelbrock < phil @ netroedge . com >
* Copyright ( C ) 2003 Michiel Rook < michiel @ grendelproject . nl >
2006-10-08 23:57:41 +04:00
* Copyright ( C ) 2005 Grant Coady < gcoady . lk @ gmail . com > with valuable
2012-01-15 01:12:38 +04:00
* guidance from Jean Delvare
2005-04-30 15:41:29 +04:00
*
* Driver supports Analog Devices ADM9240
* Dallas Semiconductor DS1780
* National Semiconductor LM81
*
* ADM9240 is the reference , DS1780 and LM81 are register compatibles
*
* Voltage Six inputs are scaled by chip , VID also reported
* Temperature Chip temperature to 0.5 ' C , maximum and max_hysteris
* Fans 2 fans , low speed alarm , automatic fan clock divider
* Alarms 16 - bit map of active alarms
* Analog Out 0. .1250 mV output
*
2011-01-12 23:55:09 +03:00
* Chassis Intrusion : clear CI latch with ' echo 0 > intrusion0_alarm '
2005-04-30 15:41:29 +04:00
*
* Test hardware : Intel SE440BX - 2 desktop motherboard - - Grant
*
* LM81 extended temp reading not implemented
*/
# include <linux/init.h>
# include <linux/module.h>
# include <linux/slab.h>
# include <linux/i2c.h>
2005-09-16 23:32:57 +04:00
# include <linux/hwmon-sysfs.h>
2005-07-16 05:39:18 +04:00
# include <linux/hwmon.h>
2005-07-31 23:52:01 +04:00
# include <linux/hwmon-vid.h>
2005-07-16 05:39:18 +04:00
# include <linux/err.h>
2006-01-19 01:19:26 +03:00
# include <linux/mutex.h>
2012-10-10 17:25:56 +04:00
# include <linux/jiffies.h>
2005-04-30 15:41:29 +04:00
/* Addresses to scan */
2008-02-18 06:28:03 +03:00
static const unsigned short normal_i2c [ ] = { 0x2c , 0x2d , 0x2e , 0x2f ,
2005-04-30 15:41:29 +04:00
I2C_CLIENT_END } ;
2009-12-14 23:17:27 +03:00
enum chips { adm9240 , ds1780 , lm81 } ;
2005-04-30 15:41:29 +04:00
/* ADM9240 registers */
# define ADM9240_REG_MAN_ID 0x3e
# define ADM9240_REG_DIE_REV 0x3f
# define ADM9240_REG_CONFIG 0x40
# define ADM9240_REG_IN(nr) (0x20 + (nr)) /* 0..5 */
# define ADM9240_REG_IN_MAX(nr) (0x2b + (nr) * 2)
# define ADM9240_REG_IN_MIN(nr) (0x2c + (nr) * 2)
# define ADM9240_REG_FAN(nr) (0x28 + (nr)) /* 0..1 */
# define ADM9240_REG_FAN_MIN(nr) (0x3b + (nr))
# define ADM9240_REG_INT(nr) (0x41 + (nr))
# define ADM9240_REG_INT_MASK(nr) (0x43 + (nr))
# define ADM9240_REG_TEMP 0x27
2005-09-16 23:32:57 +04:00
# define ADM9240_REG_TEMP_MAX(nr) (0x39 + (nr)) /* 0, 1 = high, hyst */
2005-04-30 15:41:29 +04:00
# define ADM9240_REG_ANALOG_OUT 0x19
# define ADM9240_REG_CHASSIS_CLEAR 0x46
# define ADM9240_REG_VID_FAN_DIV 0x47
# define ADM9240_REG_I2C_ADDR 0x48
# define ADM9240_REG_VID4 0x49
# define ADM9240_REG_TEMP_CONF 0x4b
/* generalised scaling with integer rounding */
static inline int SCALE ( long val , int mul , int div )
{
if ( val < 0 )
return ( val * mul - div / 2 ) / div ;
else
return ( val * mul + div / 2 ) / div ;
}
/* adm9240 internally scales voltage measurements */
static const u16 nom_mv [ ] = { 2500 , 2700 , 3300 , 5000 , 12000 , 2700 } ;
static inline unsigned int IN_FROM_REG ( u8 reg , int n )
{
return SCALE ( reg , nom_mv [ n ] , 192 ) ;
}
static inline u8 IN_TO_REG ( unsigned long val , int n )
{
2016-11-20 21:14:09 +03:00
val = clamp_val ( val , 0 , nom_mv [ n ] * 255 / 192 ) ;
return SCALE ( val , 192 , nom_mv [ n ] ) ;
2005-04-30 15:41:29 +04:00
}
/* temperature range: -40..125, 127 disables temperature alarm */
static inline s8 TEMP_TO_REG ( long val )
{
2016-11-20 21:14:09 +03:00
val = clamp_val ( val , - 40000 , 127000 ) ;
return SCALE ( val , 1 , 1000 ) ;
2005-04-30 15:41:29 +04:00
}
/* two fans, each with low fan speed limit */
static inline unsigned int FAN_FROM_REG ( u8 reg , u8 div )
{
if ( ! reg ) /* error */
return - 1 ;
if ( reg = = 255 )
return 0 ;
return SCALE ( 1350000 , 1 , reg * div ) ;
}
/* analog out 0..1250mV */
static inline u8 AOUT_TO_REG ( unsigned long val )
{
2016-11-20 21:14:09 +03:00
val = clamp_val ( val , 0 , 1250 ) ;
return SCALE ( val , 255 , 1250 ) ;
2005-04-30 15:41:29 +04:00
}
static inline unsigned int AOUT_FROM_REG ( u8 reg )
{
return SCALE ( reg , 1250 , 255 ) ;
}
/* per client data */
struct adm9240_data {
2014-07-03 18:01:48 +04:00
struct i2c_client * client ;
2006-01-19 01:19:26 +03:00
struct mutex update_lock ;
2005-04-30 15:41:29 +04:00
char valid ;
unsigned long last_updated_measure ;
unsigned long last_updated_config ;
u8 in [ 6 ] ; /* ro in0_input */
u8 in_max [ 6 ] ; /* rw in0_max */
u8 in_min [ 6 ] ; /* rw in0_min */
u8 fan [ 2 ] ; /* ro fan1_input */
u8 fan_min [ 2 ] ; /* rw fan1_min */
u8 fan_div [ 2 ] ; /* rw fan1_div, read-only accessor */
s16 temp ; /* ro temp1_input, 9-bit sign-extended */
2005-09-16 23:32:57 +04:00
s8 temp_max [ 2 ] ; /* rw 0 -> temp_max, 1 -> temp_max_hyst */
2005-04-30 15:41:29 +04:00
u16 alarms ; /* ro alarms */
2005-05-13 14:26:10 +04:00
u8 aout ; /* rw aout_output */
2005-04-30 15:41:29 +04:00
u8 vid ; /* ro vid */
u8 vrm ; /* -- vrm set on startup, no accessor */
} ;
2014-07-03 17:59:49 +04:00
/* write new fan div, callers must hold data->update_lock */
static void adm9240_write_fan_div ( struct i2c_client * client , int nr ,
u8 fan_div )
{
u8 reg , old , shift = ( nr + 2 ) * 2 ;
reg = i2c_smbus_read_byte_data ( client , ADM9240_REG_VID_FAN_DIV ) ;
old = ( reg > > shift ) & 3 ;
reg & = ~ ( 3 < < shift ) ;
reg | = ( fan_div < < shift ) ;
i2c_smbus_write_byte_data ( client , ADM9240_REG_VID_FAN_DIV , reg ) ;
dev_dbg ( & client - > dev ,
" fan%d clock divider changed from %u to %u \n " ,
nr + 1 , 1 < < old , 1 < < fan_div ) ;
}
static struct adm9240_data * adm9240_update_device ( struct device * dev )
{
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2014-07-03 17:59:49 +04:00
int i ;
mutex_lock ( & data - > update_lock ) ;
/* minimum measurement cycle: 1.75 seconds */
if ( time_after ( jiffies , data - > last_updated_measure + ( HZ * 7 / 4 ) )
| | ! data - > valid ) {
for ( i = 0 ; i < 6 ; i + + ) { /* read voltages */
data - > in [ i ] = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_IN ( i ) ) ;
}
data - > alarms = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_INT ( 0 ) ) |
i2c_smbus_read_byte_data ( client ,
ADM9240_REG_INT ( 1 ) ) < < 8 ;
/*
* read temperature : assume temperature changes less than
* 0.5 ' C per two measurement cycles thus ignore possible
* but unlikely aliasing error on lsb reading . - - Grant
*/
2016-10-05 00:40:54 +03:00
data - > temp = ( i2c_smbus_read_byte_data ( client ,
2014-07-03 17:59:49 +04:00
ADM9240_REG_TEMP ) < < 8 ) |
i2c_smbus_read_byte_data ( client ,
2016-10-05 00:40:54 +03:00
ADM9240_REG_TEMP_CONF ) ;
2014-07-03 17:59:49 +04:00
for ( i = 0 ; i < 2 ; i + + ) { /* read fans */
data - > fan [ i ] = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_FAN ( i ) ) ;
/* adjust fan clock divider on overflow */
if ( data - > valid & & data - > fan [ i ] = = 255 & &
data - > fan_div [ i ] < 3 ) {
adm9240_write_fan_div ( client , i ,
+ + data - > fan_div [ i ] ) ;
/* adjust fan_min if active, but not to 0 */
if ( data - > fan_min [ i ] < 255 & &
data - > fan_min [ i ] > = 2 )
data - > fan_min [ i ] / = 2 ;
}
}
data - > last_updated_measure = jiffies ;
}
/* minimum config reading cycle: 300 seconds */
if ( time_after ( jiffies , data - > last_updated_config + ( HZ * 300 ) )
| | ! data - > valid ) {
for ( i = 0 ; i < 6 ; i + + ) {
data - > in_min [ i ] = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_IN_MIN ( i ) ) ;
data - > in_max [ i ] = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_IN_MAX ( i ) ) ;
}
for ( i = 0 ; i < 2 ; i + + ) {
data - > fan_min [ i ] = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_FAN_MIN ( i ) ) ;
}
2020-09-24 11:51:00 +03:00
for ( i = 0 ; i < 2 ; i + + ) {
data - > temp_max [ i ] = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_TEMP_MAX ( i ) ) ;
}
2014-07-03 17:59:49 +04:00
/* read fan divs and 5-bit VID */
i = i2c_smbus_read_byte_data ( client , ADM9240_REG_VID_FAN_DIV ) ;
data - > fan_div [ 0 ] = ( i > > 4 ) & 3 ;
data - > fan_div [ 1 ] = ( i > > 6 ) & 3 ;
data - > vid = i & 0x0f ;
data - > vid | = ( i2c_smbus_read_byte_data ( client ,
ADM9240_REG_VID4 ) & 1 ) < < 4 ;
/* read analog out */
data - > aout = i2c_smbus_read_byte_data ( client ,
ADM9240_REG_ANALOG_OUT ) ;
data - > last_updated_config = jiffies ;
data - > valid = 1 ;
}
mutex_unlock ( & data - > update_lock ) ;
return data ;
}
2005-04-30 15:41:29 +04:00
/*** sysfs accessors ***/
/* temperature */
2016-12-22 15:04:33 +03:00
static ssize_t temp1_input_show ( struct device * dev ,
struct device_attribute * dummy , char * buf )
2005-09-16 23:32:57 +04:00
{
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2016-10-05 00:40:54 +03:00
return sprintf ( buf , " %d \n " , data - > temp / 128 * 500 ) ; /* 9-bit value */
2005-09-16 23:32:57 +04:00
}
2019-01-22 07:18:52 +03:00
static ssize_t max_show ( struct device * dev , struct device_attribute * devattr ,
char * buf )
2005-09-16 23:32:57 +04:00
{
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
struct adm9240_data * data = adm9240_update_device ( dev ) ;
return sprintf ( buf , " %d \n " , data - > temp_max [ attr - > index ] * 1000 ) ;
}
2019-01-22 07:18:52 +03:00
static ssize_t max_store ( struct device * dev , struct device_attribute * devattr ,
const char * buf , size_t count )
2005-09-16 23:32:57 +04:00
{
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2012-01-15 01:12:38 +04:00
long val ;
int err ;
err = kstrtol ( buf , 10 , & val ) ;
if ( err )
return err ;
2005-09-16 23:32:57 +04:00
2006-01-19 01:19:26 +03:00
mutex_lock ( & data - > update_lock ) ;
2005-09-16 23:32:57 +04:00
data - > temp_max [ attr - > index ] = TEMP_TO_REG ( val ) ;
i2c_smbus_write_byte_data ( client , ADM9240_REG_TEMP_MAX ( attr - > index ) ,
data - > temp_max [ attr - > index ] ) ;
2006-01-19 01:19:26 +03:00
mutex_unlock ( & data - > update_lock ) ;
2005-09-16 23:32:57 +04:00
return count ;
}
2016-12-22 15:04:33 +03:00
static DEVICE_ATTR_RO ( temp1_input ) ;
2019-01-22 07:18:52 +03:00
static SENSOR_DEVICE_ATTR_RW ( temp1_max , max , 0 ) ;
static SENSOR_DEVICE_ATTR_RW ( temp1_max_hyst , max , 1 ) ;
2005-04-30 15:41:29 +04:00
/* voltage */
2019-01-22 07:18:52 +03:00
static ssize_t in_show ( struct device * dev , struct device_attribute * devattr ,
char * buf )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2005-04-30 15:41:29 +04:00
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2005-09-16 23:32:57 +04:00
return sprintf ( buf , " %d \n " , IN_FROM_REG ( data - > in [ attr - > index ] ,
attr - > index ) ) ;
2005-04-30 15:41:29 +04:00
}
2019-01-22 07:18:52 +03:00
static ssize_t in_min_show ( struct device * dev ,
struct device_attribute * devattr , char * buf )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2005-04-30 15:41:29 +04:00
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2005-09-16 23:32:57 +04:00
return sprintf ( buf , " %d \n " , IN_FROM_REG ( data - > in_min [ attr - > index ] ,
attr - > index ) ) ;
2005-04-30 15:41:29 +04:00
}
2019-01-22 07:18:52 +03:00
static ssize_t in_max_show ( struct device * dev ,
struct device_attribute * devattr , char * buf )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2005-04-30 15:41:29 +04:00
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2005-09-16 23:32:57 +04:00
return sprintf ( buf , " %d \n " , IN_FROM_REG ( data - > in_max [ attr - > index ] ,
attr - > index ) ) ;
2005-04-30 15:41:29 +04:00
}
2019-01-22 07:18:52 +03:00
static ssize_t in_min_store ( struct device * dev ,
struct device_attribute * devattr , const char * buf ,
size_t count )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2012-01-15 01:12:38 +04:00
unsigned long val ;
int err ;
err = kstrtoul ( buf , 10 , & val ) ;
if ( err )
return err ;
2005-04-30 15:41:29 +04:00
2006-01-19 01:19:26 +03:00
mutex_lock ( & data - > update_lock ) ;
2005-09-16 23:32:57 +04:00
data - > in_min [ attr - > index ] = IN_TO_REG ( val , attr - > index ) ;
i2c_smbus_write_byte_data ( client , ADM9240_REG_IN_MIN ( attr - > index ) ,
data - > in_min [ attr - > index ] ) ;
2006-01-19 01:19:26 +03:00
mutex_unlock ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
return count ;
}
2019-01-22 07:18:52 +03:00
static ssize_t in_max_store ( struct device * dev ,
struct device_attribute * devattr , const char * buf ,
size_t count )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2012-01-15 01:12:38 +04:00
unsigned long val ;
int err ;
err = kstrtoul ( buf , 10 , & val ) ;
if ( err )
return err ;
2005-04-30 15:41:29 +04:00
2006-01-19 01:19:26 +03:00
mutex_lock ( & data - > update_lock ) ;
2005-09-16 23:32:57 +04:00
data - > in_max [ attr - > index ] = IN_TO_REG ( val , attr - > index ) ;
i2c_smbus_write_byte_data ( client , ADM9240_REG_IN_MAX ( attr - > index ) ,
data - > in_max [ attr - > index ] ) ;
2006-01-19 01:19:26 +03:00
mutex_unlock ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
return count ;
}
2019-01-22 07:18:52 +03:00
static SENSOR_DEVICE_ATTR_RO ( in0_input , in , 0 ) ;
static SENSOR_DEVICE_ATTR_RW ( in0_min , in_min , 0 ) ;
static SENSOR_DEVICE_ATTR_RW ( in0_max , in_max , 0 ) ;
static SENSOR_DEVICE_ATTR_RO ( in1_input , in , 1 ) ;
static SENSOR_DEVICE_ATTR_RW ( in1_min , in_min , 1 ) ;
static SENSOR_DEVICE_ATTR_RW ( in1_max , in_max , 1 ) ;
static SENSOR_DEVICE_ATTR_RO ( in2_input , in , 2 ) ;
static SENSOR_DEVICE_ATTR_RW ( in2_min , in_min , 2 ) ;
static SENSOR_DEVICE_ATTR_RW ( in2_max , in_max , 2 ) ;
static SENSOR_DEVICE_ATTR_RO ( in3_input , in , 3 ) ;
static SENSOR_DEVICE_ATTR_RW ( in3_min , in_min , 3 ) ;
static SENSOR_DEVICE_ATTR_RW ( in3_max , in_max , 3 ) ;
static SENSOR_DEVICE_ATTR_RO ( in4_input , in , 4 ) ;
static SENSOR_DEVICE_ATTR_RW ( in4_min , in_min , 4 ) ;
static SENSOR_DEVICE_ATTR_RW ( in4_max , in_max , 4 ) ;
static SENSOR_DEVICE_ATTR_RO ( in5_input , in , 5 ) ;
static SENSOR_DEVICE_ATTR_RW ( in5_min , in_min , 5 ) ;
static SENSOR_DEVICE_ATTR_RW ( in5_max , in_max , 5 ) ;
2005-04-30 15:41:29 +04:00
/* fans */
2019-01-22 07:18:52 +03:00
static ssize_t fan_show ( struct device * dev , struct device_attribute * devattr ,
char * buf )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2005-04-30 15:41:29 +04:00
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2005-09-16 23:32:57 +04:00
return sprintf ( buf , " %d \n " , FAN_FROM_REG ( data - > fan [ attr - > index ] ,
1 < < data - > fan_div [ attr - > index ] ) ) ;
2005-04-30 15:41:29 +04:00
}
2019-01-22 07:18:52 +03:00
static ssize_t fan_min_show ( struct device * dev ,
struct device_attribute * devattr , char * buf )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2005-04-30 15:41:29 +04:00
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2005-09-16 23:32:57 +04:00
return sprintf ( buf , " %d \n " , FAN_FROM_REG ( data - > fan_min [ attr - > index ] ,
1 < < data - > fan_div [ attr - > index ] ) ) ;
2005-04-30 15:41:29 +04:00
}
2019-01-22 07:18:52 +03:00
static ssize_t fan_div_show ( struct device * dev ,
struct device_attribute * devattr , char * buf )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2005-04-30 15:41:29 +04:00
struct adm9240_data * data = adm9240_update_device ( dev ) ;
2005-09-16 23:32:57 +04:00
return sprintf ( buf , " %d \n " , 1 < < data - > fan_div [ attr - > index ] ) ;
2005-04-30 15:41:29 +04:00
}
2005-09-25 18:14:18 +04:00
/*
2005-04-30 15:41:29 +04:00
* set fan speed low limit :
*
* - value is zero : disable fan speed low limit alarm
*
* - value is below fan speed measurement range : enable fan speed low
* limit alarm to be asserted while fan speed too slow to measure
*
* - otherwise : select fan clock divider to suit fan speed low limit ,
* measurement code may adjust registers to ensure fan speed reading
*/
2019-01-22 07:18:52 +03:00
static ssize_t fan_min_store ( struct device * dev ,
struct device_attribute * devattr ,
const char * buf , size_t count )
2005-04-30 15:41:29 +04:00
{
2005-09-16 23:32:57 +04:00
struct sensor_device_attribute * attr = to_sensor_dev_attr ( devattr ) ;
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2005-09-16 23:32:57 +04:00
int nr = attr - > index ;
2005-04-30 15:41:29 +04:00
u8 new_div ;
2012-01-15 01:12:38 +04:00
unsigned long val ;
int err ;
err = kstrtoul ( buf , 10 , & val ) ;
if ( err )
return err ;
2005-04-30 15:41:29 +04:00
2006-01-19 01:19:26 +03:00
mutex_lock ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
if ( ! val ) {
data - > fan_min [ nr ] = 255 ;
new_div = data - > fan_div [ nr ] ;
dev_dbg ( & client - > dev , " fan%u low limit set disabled \n " ,
nr + 1 ) ;
} else if ( val < 1350000 / ( 8 * 254 ) ) {
new_div = 3 ;
data - > fan_min [ nr ] = 254 ;
dev_dbg ( & client - > dev , " fan%u low limit set minimum %u \n " ,
nr + 1 , FAN_FROM_REG ( 254 , 1 < < new_div ) ) ;
} else {
unsigned int new_min = 1350000 / val ;
new_div = 0 ;
while ( new_min > 192 & & new_div < 3 ) {
new_div + + ;
new_min / = 2 ;
}
if ( ! new_min ) /* keep > 0 */
new_min + + ;
data - > fan_min [ nr ] = new_min ;
dev_dbg ( & client - > dev , " fan%u low limit set fan speed %u \n " ,
nr + 1 , FAN_FROM_REG ( new_min , 1 < < new_div ) ) ;
}
if ( new_div ! = data - > fan_div [ nr ] ) {
data - > fan_div [ nr ] = new_div ;
adm9240_write_fan_div ( client , nr , new_div ) ;
}
2005-09-16 23:32:55 +04:00
i2c_smbus_write_byte_data ( client , ADM9240_REG_FAN_MIN ( nr ) ,
2005-04-30 15:41:29 +04:00
data - > fan_min [ nr ] ) ;
2006-01-19 01:19:26 +03:00
mutex_unlock ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
return count ;
}
2019-01-22 07:18:52 +03:00
static SENSOR_DEVICE_ATTR_RO ( fan1_input , fan , 0 ) ;
static SENSOR_DEVICE_ATTR_RW ( fan1_min , fan_min , 0 ) ;
static SENSOR_DEVICE_ATTR_RO ( fan1_div , fan_div , 0 ) ;
static SENSOR_DEVICE_ATTR_RO ( fan2_input , fan , 1 ) ;
static SENSOR_DEVICE_ATTR_RW ( fan2_min , fan_min , 1 ) ;
static SENSOR_DEVICE_ATTR_RO ( fan2_div , fan_div , 1 ) ;
2005-04-30 15:41:29 +04:00
/* alarms */
2016-12-22 15:04:33 +03:00
static ssize_t alarms_show ( struct device * dev ,
2005-09-25 18:14:18 +04:00
struct device_attribute * attr , char * buf )
2005-04-30 15:41:29 +04:00
{
struct adm9240_data * data = adm9240_update_device ( dev ) ;
return sprintf ( buf , " %u \n " , data - > alarms ) ;
}
2016-12-22 15:04:33 +03:00
static DEVICE_ATTR_RO ( alarms ) ;
2005-04-30 15:41:29 +04:00
2019-01-22 07:18:52 +03:00
static ssize_t alarm_show ( struct device * dev , struct device_attribute * attr ,
char * buf )
2008-01-06 17:49:19 +03:00
{
int bitnr = to_sensor_dev_attr ( attr ) - > index ;
struct adm9240_data * data = adm9240_update_device ( dev ) ;
return sprintf ( buf , " %u \n " , ( data - > alarms > > bitnr ) & 1 ) ;
}
2019-01-22 07:18:52 +03:00
static SENSOR_DEVICE_ATTR_RO ( in0_alarm , alarm , 0 ) ;
static SENSOR_DEVICE_ATTR_RO ( in1_alarm , alarm , 1 ) ;
static SENSOR_DEVICE_ATTR_RO ( in2_alarm , alarm , 2 ) ;
static SENSOR_DEVICE_ATTR_RO ( in3_alarm , alarm , 3 ) ;
static SENSOR_DEVICE_ATTR_RO ( in4_alarm , alarm , 8 ) ;
static SENSOR_DEVICE_ATTR_RO ( in5_alarm , alarm , 9 ) ;
static SENSOR_DEVICE_ATTR_RO ( temp1_alarm , alarm , 4 ) ;
static SENSOR_DEVICE_ATTR_RO ( fan1_alarm , alarm , 6 ) ;
static SENSOR_DEVICE_ATTR_RO ( fan2_alarm , alarm , 7 ) ;
2008-01-06 17:49:19 +03:00
2005-04-30 15:41:29 +04:00
/* vid */
2016-12-22 15:04:33 +03:00
static ssize_t cpu0_vid_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
2005-04-30 15:41:29 +04:00
{
struct adm9240_data * data = adm9240_update_device ( dev ) ;
return sprintf ( buf , " %d \n " , vid_from_reg ( data - > vid , data - > vrm ) ) ;
}
2016-12-22 15:04:33 +03:00
static DEVICE_ATTR_RO ( cpu0_vid ) ;
2005-04-30 15:41:29 +04:00
/* analog output */
2016-12-22 15:04:33 +03:00
static ssize_t aout_output_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
2005-04-30 15:41:29 +04:00
{
struct adm9240_data * data = adm9240_update_device ( dev ) ;
return sprintf ( buf , " %d \n " , AOUT_FROM_REG ( data - > aout ) ) ;
}
2016-12-22 15:04:33 +03:00
static ssize_t aout_output_store ( struct device * dev ,
struct device_attribute * attr ,
const char * buf , size_t count )
2005-04-30 15:41:29 +04:00
{
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2012-01-15 01:12:38 +04:00
long val ;
int err ;
err = kstrtol ( buf , 10 , & val ) ;
if ( err )
return err ;
2005-04-30 15:41:29 +04:00
2006-01-19 01:19:26 +03:00
mutex_lock ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
data - > aout = AOUT_TO_REG ( val ) ;
2005-09-16 23:32:55 +04:00
i2c_smbus_write_byte_data ( client , ADM9240_REG_ANALOG_OUT , data - > aout ) ;
2006-01-19 01:19:26 +03:00
mutex_unlock ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
return count ;
}
2016-12-22 15:04:33 +03:00
static DEVICE_ATTR_RW ( aout_output ) ;
2005-04-30 15:41:29 +04:00
2019-01-22 07:18:52 +03:00
static ssize_t alarm_store ( struct device * dev , struct device_attribute * attr ,
const char * buf , size_t count )
2011-01-12 23:55:09 +03:00
{
2014-07-03 18:01:48 +04:00
struct adm9240_data * data = dev_get_drvdata ( dev ) ;
struct i2c_client * client = data - > client ;
2011-01-12 23:55:09 +03:00
unsigned long val ;
2012-01-04 23:58:52 +04:00
if ( kstrtoul ( buf , 10 , & val ) | | val ! = 0 )
2011-01-12 23:55:09 +03:00
return - EINVAL ;
mutex_lock ( & data - > update_lock ) ;
i2c_smbus_write_byte_data ( client , ADM9240_REG_CHASSIS_CLEAR , 0x80 ) ;
data - > valid = 0 ; /* Force cache refresh */
mutex_unlock ( & data - > update_lock ) ;
dev_dbg ( & client - > dev , " chassis intrusion latch cleared \n " ) ;
return count ;
}
2019-01-22 07:18:52 +03:00
static SENSOR_DEVICE_ATTR_RW ( intrusion0_alarm , alarm , 12 ) ;
2005-04-30 15:41:29 +04:00
2014-07-03 18:01:48 +04:00
static struct attribute * adm9240_attrs [ ] = {
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_in0_input . dev_attr . attr ,
& sensor_dev_attr_in0_min . dev_attr . attr ,
& sensor_dev_attr_in0_max . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_in0_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_in1_input . dev_attr . attr ,
& sensor_dev_attr_in1_min . dev_attr . attr ,
& sensor_dev_attr_in1_max . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_in1_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_in2_input . dev_attr . attr ,
& sensor_dev_attr_in2_min . dev_attr . attr ,
& sensor_dev_attr_in2_max . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_in2_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_in3_input . dev_attr . attr ,
& sensor_dev_attr_in3_min . dev_attr . attr ,
& sensor_dev_attr_in3_max . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_in3_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_in4_input . dev_attr . attr ,
& sensor_dev_attr_in4_min . dev_attr . attr ,
& sensor_dev_attr_in4_max . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_in4_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_in5_input . dev_attr . attr ,
& sensor_dev_attr_in5_min . dev_attr . attr ,
& sensor_dev_attr_in5_max . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_in5_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& dev_attr_temp1_input . attr ,
& sensor_dev_attr_temp1_max . dev_attr . attr ,
& sensor_dev_attr_temp1_max_hyst . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_temp1_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_fan1_input . dev_attr . attr ,
& sensor_dev_attr_fan1_div . dev_attr . attr ,
& sensor_dev_attr_fan1_min . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_fan1_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& sensor_dev_attr_fan2_input . dev_attr . attr ,
& sensor_dev_attr_fan2_div . dev_attr . attr ,
& sensor_dev_attr_fan2_min . dev_attr . attr ,
2008-01-06 17:49:19 +03:00
& sensor_dev_attr_fan2_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& dev_attr_alarms . attr ,
& dev_attr_aout_output . attr ,
2011-01-12 23:55:09 +03:00
& sensor_dev_attr_intrusion0_alarm . dev_attr . attr ,
2006-09-24 23:15:35 +04:00
& dev_attr_cpu0_vid . attr ,
NULL
} ;
2014-07-03 18:01:48 +04:00
ATTRIBUTE_GROUPS ( adm9240 ) ;
2006-09-24 23:15:35 +04:00
2005-04-30 15:41:29 +04:00
/*** sensor chip detect and driver install ***/
2008-07-16 21:30:09 +04:00
/* Return 0 if detection is successful, -ENODEV otherwise */
2009-12-14 23:17:23 +03:00
static int adm9240_detect ( struct i2c_client * new_client ,
2008-07-16 21:30:09 +04:00
struct i2c_board_info * info )
2005-04-30 15:41:29 +04:00
{
2008-07-16 21:30:09 +04:00
struct i2c_adapter * adapter = new_client - > adapter ;
2005-04-30 15:41:29 +04:00
const char * name = " " ;
2008-07-16 21:30:09 +04:00
int address = new_client - > addr ;
2005-04-30 15:41:29 +04:00
u8 man_id , die_rev ;
if ( ! i2c_check_functionality ( adapter , I2C_FUNC_SMBUS_BYTE_DATA ) )
2008-07-16 21:30:09 +04:00
return - ENODEV ;
2005-04-30 15:41:29 +04:00
2009-12-09 22:35:57 +03:00
/* verify chip: reg address should match i2c address */
if ( i2c_smbus_read_byte_data ( new_client , ADM9240_REG_I2C_ADDR )
! = address ) {
dev_err ( & adapter - > dev , " detect fail: address match, 0x%02x \n " ,
address ) ;
return - ENODEV ;
2005-04-30 15:41:29 +04:00
}
2009-12-09 22:35:57 +03:00
/* check known chip manufacturer */
man_id = i2c_smbus_read_byte_data ( new_client , ADM9240_REG_MAN_ID ) ;
if ( man_id = = 0x23 ) {
2005-04-30 15:41:29 +04:00
name = " adm9240 " ;
2009-12-09 22:35:57 +03:00
} else if ( man_id = = 0xda ) {
2005-04-30 15:41:29 +04:00
name = " ds1780 " ;
2009-12-09 22:35:57 +03:00
} else if ( man_id = = 0x01 ) {
2005-04-30 15:41:29 +04:00
name = " lm81 " ;
2009-12-09 22:35:57 +03:00
} else {
dev_err ( & adapter - > dev , " detect fail: unknown manuf, 0x%02x \n " ,
man_id ) ;
return - ENODEV ;
2005-04-30 15:41:29 +04:00
}
2009-12-09 22:35:57 +03:00
/* successful detect, print chip info */
die_rev = i2c_smbus_read_byte_data ( new_client , ADM9240_REG_DIE_REV ) ;
dev_info ( & adapter - > dev , " found %s revision %u \n " ,
man_id = = 0x23 ? " ADM9240 " :
man_id = = 0xda ? " DS1780 " : " LM81 " , die_rev ) ;
2008-07-16 21:30:09 +04:00
strlcpy ( info - > type , name , I2C_NAME_SIZE ) ;
2005-04-30 15:41:29 +04:00
2008-07-16 21:30:09 +04:00
return 0 ;
}
2005-04-30 15:41:29 +04:00
static void adm9240_init_client ( struct i2c_client * client )
{
struct adm9240_data * data = i2c_get_clientdata ( client ) ;
2005-09-16 23:32:55 +04:00
u8 conf = i2c_smbus_read_byte_data ( client , ADM9240_REG_CONFIG ) ;
u8 mode = i2c_smbus_read_byte_data ( client , ADM9240_REG_TEMP_CONF ) & 3 ;
2005-04-30 15:41:29 +04:00
2005-07-31 23:52:01 +04:00
data - > vrm = vid_which_vrm ( ) ; /* need this to report vid as mV */
2005-04-30 15:41:29 +04:00
2005-05-13 14:26:10 +04:00
dev_info ( & client - > dev , " Using VRM: %d.%d \n " , data - > vrm / 10 ,
data - > vrm % 10 ) ;
2005-04-30 15:41:29 +04:00
if ( conf & 1 ) { /* measurement cycle running: report state */
dev_info ( & client - > dev , " status: config 0x%02x mode %u \n " ,
conf , mode ) ;
} else { /* cold start: open limits before starting chip */
int i ;
2012-01-15 01:12:38 +04:00
for ( i = 0 ; i < 6 ; i + + ) {
2005-09-16 23:32:55 +04:00
i2c_smbus_write_byte_data ( client ,
2005-04-30 15:41:29 +04:00
ADM9240_REG_IN_MIN ( i ) , 0 ) ;
2005-09-16 23:32:55 +04:00
i2c_smbus_write_byte_data ( client ,
2005-04-30 15:41:29 +04:00
ADM9240_REG_IN_MAX ( i ) , 255 ) ;
}
2020-09-24 11:51:00 +03:00
for ( i = 0 ; i < 2 ; i + + ) {
i2c_smbus_write_byte_data ( client ,
ADM9240_REG_FAN_MIN ( i ) , 255 ) ;
}
for ( i = 0 ; i < 2 ; i + + ) {
i2c_smbus_write_byte_data ( client ,
ADM9240_REG_TEMP_MAX ( i ) , 127 ) ;
}
2005-04-30 15:41:29 +04:00
/* start measurement cycle */
2005-09-16 23:32:55 +04:00
i2c_smbus_write_byte_data ( client , ADM9240_REG_CONFIG , 1 ) ;
2005-04-30 15:41:29 +04:00
2013-01-10 22:01:24 +04:00
dev_info ( & client - > dev ,
" cold start: config was 0x%02x mode %u \n " , conf , mode ) ;
2005-04-30 15:41:29 +04:00
}
}
2020-08-13 19:02:22 +03:00
static int adm9240_probe ( struct i2c_client * new_client )
2005-04-30 15:41:29 +04:00
{
2014-07-03 18:01:48 +04:00
struct device * dev = & new_client - > dev ;
struct device * hwmon_dev ;
2014-07-03 17:59:49 +04:00
struct adm9240_data * data ;
2005-04-30 15:41:29 +04:00
2014-07-03 18:01:48 +04:00
data = devm_kzalloc ( dev , sizeof ( * data ) , GFP_KERNEL ) ;
2014-07-03 17:59:49 +04:00
if ( ! data )
return - ENOMEM ;
2005-04-30 15:41:29 +04:00
2014-07-03 17:59:49 +04:00
i2c_set_clientdata ( new_client , data ) ;
2014-07-03 18:01:48 +04:00
data - > client = new_client ;
2014-07-03 17:59:49 +04:00
mutex_init ( & data - > update_lock ) ;
2005-04-30 15:41:29 +04:00
2014-07-03 17:59:49 +04:00
adm9240_init_client ( new_client ) ;
2005-04-30 15:41:29 +04:00
2014-07-03 18:01:48 +04:00
hwmon_dev = devm_hwmon_device_register_with_groups ( dev ,
new_client - > name ,
data ,
adm9240_groups ) ;
return PTR_ERR_OR_ZERO ( hwmon_dev ) ;
2014-07-03 17:59:49 +04:00
}
2005-04-30 15:41:29 +04:00
2014-07-03 17:59:49 +04:00
static const struct i2c_device_id adm9240_id [ ] = {
{ " adm9240 " , adm9240 } ,
{ " ds1780 " , ds1780 } ,
{ " lm81 " , lm81 } ,
{ }
} ;
MODULE_DEVICE_TABLE ( i2c , adm9240_id ) ;
2005-04-30 15:41:29 +04:00
2014-07-03 17:59:49 +04:00
static struct i2c_driver adm9240_driver = {
. class = I2C_CLASS_HWMON ,
. driver = {
. name = " adm9240 " ,
} ,
2020-08-13 19:02:22 +03:00
. probe_new = adm9240_probe ,
2014-07-03 17:59:49 +04:00
. id_table = adm9240_id ,
. detect = adm9240_detect ,
. address_list = normal_i2c ,
} ;
2005-04-30 15:41:29 +04:00
2012-01-20 11:38:18 +04:00
module_i2c_driver ( adm9240_driver ) ;
2005-04-30 15:41:29 +04:00
MODULE_AUTHOR ( " Michiel Rook <michiel@grendelproject.nl>, "
2006-10-08 23:57:41 +04:00
" Grant Coady <gcoady.lk@gmail.com> and others " ) ;
2005-04-30 15:41:29 +04:00
MODULE_DESCRIPTION ( " ADM9240/DS1780/LM81 driver " ) ;
MODULE_LICENSE ( " GPL " ) ;