remove initialization of limits by driver

git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@2068 7894878c-1315-0410-8ee3-d5d059ff63e0
This commit is contained in:
Mark D. Studebaker committed 2003-11-18 02:19:41 +00:00
1 parent 27cc3b8bf1
commit b048a1cac9
7 files changed
-378

No files matched your search

-20
View File
@@ -84,17 +84,6 @@ SENSORS_INSMOD_8(adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm, mc1
#define TEMP_FROM_REG(val) (val > 127 ? val-256 : val)
#define TEMP_TO_REG(val) (SENSORS_LIMIT((val < 0 ? val+256 : val),0,255))
/* Initial values */
/* Note: Eventhough I left the low and high limits named os and hyst,
they don't quite work like a thermostat the way the LM75 does. I.e.,
a lower temp than THYST actuall triggers an alarm instead of
clearing it. Weird, ey? --Phil */
#define adm1021_INIT_TOS 60
#define adm1021_INIT_THYST 20
#define adm1021_INIT_REMOTE_TOS 60
#define adm1021_INIT_REMOTE_THYST 20
/* Each client has this additional data */
struct adm1021_data {
int sysctl_id;
@@ -344,15 +333,6 @@ static int adm1021_detect(struct i2c_adapter *adapter, int address,
static void adm1021_init_client(struct i2c_client *client)
{
/* Initialize the adm1021 chip */
adm1021_write_value(client, ADM1021_REG_TOS_W,
TEMP_TO_REG(adm1021_INIT_TOS));
adm1021_write_value(client, ADM1021_REG_THYST_W,
TEMP_TO_REG(adm1021_INIT_THYST));
adm1021_write_value(client, ADM1021_REG_REMOTE_TOS_W,
TEMP_TO_REG(adm1021_INIT_REMOTE_TOS));
adm1021_write_value(client, ADM1021_REG_REMOTE_THYST_W,
TEMP_TO_REG(adm1021_INIT_REMOTE_THYST));
/* Enable ADC and disable suspend mode */
adm1021_write_value(client, ADM1021_REG_CONFIG_W, 0);
/* Set Conversion rate to 1/sec (this can be tinkered with) */
-91
View File
@@ -149,49 +149,6 @@ static inline u8 FAN_TO_REG(long rpm, int div)
#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
205-(val)*5)
/* Initial limits */
#define ADM1024_INIT_IN_0 190
#define ADM1024_INIT_IN_1 190
#define ADM1024_INIT_IN_2 190
#define ADM1024_INIT_IN_3 190
#define ADM1024_INIT_IN_4 190
#define ADM1024_INIT_IN_5 190
#define ADM1024_INIT_IN_PERCENTAGE 10
#define ADM1024_INIT_IN_MIN_0 \
(ADM1024_INIT_IN_0 - ADM1024_INIT_IN_0 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MAX_0 \
(ADM1024_INIT_IN_0 + ADM1024_INIT_IN_0 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MIN_1 \
(ADM1024_INIT_IN_1 - ADM1024_INIT_IN_1 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MAX_1 \
(ADM1024_INIT_IN_1 + ADM1024_INIT_IN_1 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MIN_2 \
(ADM1024_INIT_IN_2 - ADM1024_INIT_IN_2 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MAX_2 \
(ADM1024_INIT_IN_2 + ADM1024_INIT_IN_2 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MIN_3 \
(ADM1024_INIT_IN_3 - ADM1024_INIT_IN_3 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MAX_3 \
(ADM1024_INIT_IN_3 + ADM1024_INIT_IN_3 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MIN_4 \
(ADM1024_INIT_IN_4 - ADM1024_INIT_IN_4 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MAX_4 \
(ADM1024_INIT_IN_4 + ADM1024_INIT_IN_4 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MIN_5 \
(ADM1024_INIT_IN_5 - ADM1024_INIT_IN_5 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_IN_MAX_5 \
(ADM1024_INIT_IN_5 + ADM1024_INIT_IN_5 * ADM1024_INIT_IN_PERCENTAGE / 100)
#define ADM1024_INIT_FAN_MIN_1 3000
#define ADM1024_INIT_FAN_MIN_2 3000
#define ADM1024_INIT_TEMP_OS_MAX 600
#define ADM1024_INIT_TEMP_OS_HYST 500
#define ADM1024_INIT_TEMP_HOT_MAX 700
#define ADM1024_INIT_TEMP_HOT_HYST 600
/* For each registered ADM1024, we need to keep some data in memory. That
data is pointed to by adm1024_list[NR]->data. The structure itself is
dynamically allocated, at the same time when a new adm1024 client is
@@ -490,56 +447,8 @@ static int adm1024_write_value(struct i2c_client *client, u8 reg, u8 value)
return i2c_smbus_write_byte_data(client, reg, value);
}
/* Called when we have found a new ADM1024. It should set limits, etc. */
static void adm1024_init_client(struct i2c_client *client)
{
/* Reset all except Watchdog values and last conversion values
This sets fan-divs to 2, among others. This makes most other
initializations unnecessary */
adm1024_write_value(client, ADM1024_REG_CONFIG, 0x80);
adm1024_write_value(client, ADM1024_REG_IN_MIN(0),
IN_TO_REG(ADM1024_INIT_IN_MIN_0, 0));
adm1024_write_value(client, ADM1024_REG_IN_MAX(0),
IN_TO_REG(ADM1024_INIT_IN_MAX_0, 0));
adm1024_write_value(client, ADM1024_REG_IN_MIN(1),
IN_TO_REG(ADM1024_INIT_IN_MIN_1, 1));
adm1024_write_value(client, ADM1024_REG_IN_MAX(1),
IN_TO_REG(ADM1024_INIT_IN_MAX_1, 1));
adm1024_write_value(client, ADM1024_REG_IN_MIN(2),
IN_TO_REG(ADM1024_INIT_IN_MIN_2, 2));
adm1024_write_value(client, ADM1024_REG_IN_MAX(2),
IN_TO_REG(ADM1024_INIT_IN_MAX_2, 2));
adm1024_write_value(client, ADM1024_REG_IN_MIN(3),
IN_TO_REG(ADM1024_INIT_IN_MIN_3, 3));
adm1024_write_value(client, ADM1024_REG_IN_MAX(3),
IN_TO_REG(ADM1024_INIT_IN_MAX_3, 3));
adm1024_write_value(client, ADM1024_REG_IN_MIN(4),
IN_TO_REG(ADM1024_INIT_IN_MIN_4, 4));
adm1024_write_value(client, ADM1024_REG_IN_MAX(4),
IN_TO_REG(ADM1024_INIT_IN_MAX_4, 4));
adm1024_write_value(client, ADM1024_REG_IN_MIN(5),
IN_TO_REG(ADM1024_INIT_IN_MIN_5, 5));
adm1024_write_value(client, ADM1024_REG_IN_MAX(5),
IN_TO_REG(ADM1024_INIT_IN_MAX_5, 5));
adm1024_write_value(client, ADM1024_REG_FAN1_MIN,
FAN_TO_REG(ADM1024_INIT_FAN_MIN_1, 2));
adm1024_write_value(client, ADM1024_REG_FAN2_MIN,
FAN_TO_REG(ADM1024_INIT_FAN_MIN_2, 2));
adm1024_write_value(client, ADM1024_REG_TOS,
TEMP_LIMIT_TO_REG(ADM1024_INIT_TEMP_OS_MAX));
adm1024_write_value(client, ADM1024_REG_THYST,
TEMP_LIMIT_TO_REG(ADM1024_INIT_TEMP_OS_HYST));
adm1024_write_value(client, ADM1024_REG_EXT_TEMP1_HIGH,
TEMP_LIMIT_TO_REG(ADM1024_INIT_TEMP_OS_MAX));
adm1024_write_value(client, ADM1024_REG_EXT_TEMP1_LOW,
TEMP_LIMIT_TO_REG(ADM1024_INIT_TEMP_OS_HYST));
adm1024_write_value(client, ADM1024_REG_2_5V_HIGH,
TEMP_LIMIT_TO_REG(ADM1024_INIT_TEMP_OS_MAX));
adm1024_write_value(client, ADM1024_REG_2_5V_LOW,
TEMP_LIMIT_TO_REG(ADM1024_INIT_TEMP_OS_HYST));
adm1024_write_value(client, ADM1024_REG_TEMP_CONFIG, 0x00);
/* Enable temperature channel 2 */
adm1024_write_value(client, ADM1024_REG_CHANNEL_MODE, adm1024_read_value(client, ADM1024_REG_CHANNEL_MODE) | 0x04);
-23
View File
@@ -118,14 +118,6 @@ SENSORS_INSMOD_1(adm1025);
#define ALARMS_FROM_REG(val) (val)
/* Initial limits (10% deviation) */
#define ADM1025_INIT_IN 192
#define ADM1025_INIT_IN_MIN ((ADM1025_INIT_IN * 9 + 5) / 10)
#define ADM1025_INIT_IN_MAX ((ADM1025_INIT_IN * 11 + 5) / 10)
#define ADM1025_INIT_TEMP_HIGH 650
#define ADM1025_INIT_TEMP_LOW 50
/* For each registered ADM1025, we need to keep some data in memory. That
data is pointed to by adm1025_list[NR]->data. The structure itself is
dynamically allocated, at the same time when a new adm1025 client is
@@ -395,21 +387,6 @@ static void adm1025_init_client(struct i2c_client *client)
change the bits 1-6 of the configuration register, since
they hold data we want to preserve. */
reg = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
i2c_smbus_write_byte_data(client, ADM1025_REG_CONFIG, 0x80);
for (nr = 0; nr < 6; nr++) {
i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(nr),
data->in_min[nr] = IN_TO_REG(ADM1025_INIT_IN_MIN));
i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(nr),
data->in_max[nr] = IN_TO_REG(ADM1025_INIT_IN_MAX));
}
for (nr = 0; nr < 2; nr++) {
i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(nr),
data->temp_high[nr]=TEMP_TO_REG(ADM1025_INIT_TEMP_HIGH));
i2c_smbus_write_byte_data(client, ADM1025_REG_RTEMP_LOW,
data->temp_low[nr]=TEMP_TO_REG(ADM1025_INIT_TEMP_LOW));
}
/* Restore configuration and start monitoring */
i2c_smbus_write_byte_data(client, ADM1025_REG_CONFIG, (reg|0x01)&0x7F);
-9
View File
@@ -78,10 +78,6 @@ SENSORS_INSMOD_1(ds1621);
#define ITEMP_FROM_REG(val) ((((val & 0x7fff) >> 8)) | \
((val & 0x8000)?-256:0))
/* Initial values */
#define DS1621_INIT_TEMP_OVER 600
#define DS1621_INIT_TEMP_HYST 0 /* 500 would cause an alarm at room temp. */
/* Each client has this additional data */
struct ds1621_data {
int sysctl_id;
@@ -321,11 +317,6 @@ static void ds1621_init_client(struct i2c_client *client)
{
int reg;
/* Initialize the DS1621 chip */
ds1621_write_value(client, DS1621_REG_TEMP_OVER,
TEMP_TO_REG(DS1621_INIT_TEMP_OVER));
ds1621_write_value(client, DS1621_REG_TEMP_HYST,
TEMP_TO_REG(DS1621_INIT_TEMP_HYST));
reg = ds1621_read_value(client, DS1621_REG_CONF);
/* start the continous conversion */
if(reg & 0x01)
-54
View File
@@ -109,38 +109,6 @@ static inline u8 FAN_TO_REG(long rpm, int div)
#define BEEPS_TO_REG(val) ((val) & 0x7f)
#define BEEPS_FROM_REG(val) ((val) & 0x7f)
/* Initial values */
#define GL518_INIT_TEMP_OVER 600
#define GL518_INIT_TEMP_HYST 500
#define GL518_INIT_FAN_MIN_1 3000
#define GL518_INIT_FAN_MIN_2 3000
/* These are somewhat sane */
#define GL518_INIT_VIN_1 330 /* 3.3 V */
#define GL518_INIT_VIN_2 286 /* 12 V */
#define GL518_INIT_VIN_3 260 /* Vcore */
#define GL518_INIT_VDD 500 /* 5 V */
#define GL518_INIT_PERCENTAGE 10
#define GL518_INIT_VIN_MIN_1 \
(GL518_INIT_VIN_1 - GL518_INIT_VIN_1 * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VIN_MAX_1 \
(GL518_INIT_VIN_1 + GL518_INIT_VIN_1 * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VIN_MIN_2 \
(GL518_INIT_VIN_2 - GL518_INIT_VIN_2 * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VIN_MAX_2 \
(GL518_INIT_VIN_2 + GL518_INIT_VIN_2 * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VIN_MIN_3 \
(GL518_INIT_VIN_3 - GL518_INIT_VIN_3 * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VIN_MAX_3 \
(GL518_INIT_VIN_3 + GL518_INIT_VIN_3 * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VDD_MIN \
(GL518_INIT_VDD - GL518_INIT_VDD * GL518_INIT_PERCENTAGE / 100)
#define GL518_INIT_VDD_MAX \
(GL518_INIT_VDD + GL518_INIT_VDD * GL518_INIT_PERCENTAGE / 100)
/* Each client has this additional data */
struct gl518_data {
int sysctl_id;
@@ -440,28 +408,6 @@ static void gl518_init_client(struct i2c_client *client)
/* Never interrupts */
gl518_write_value(client, GL518_REG_MASK, 0x00);
gl518_write_value(client, GL518_REG_TEMP_HYST,
TEMP_TO_REG(GL518_INIT_TEMP_HYST));
gl518_write_value(client, GL518_REG_TEMP_OVER,
TEMP_TO_REG(GL518_INIT_TEMP_OVER));
gl518_write_value(client, GL518_REG_MISC, (DIV_TO_REG(2) << 6) |
(DIV_TO_REG(2) << 4));
gl518_write_value(client, GL518_REG_FAN_LIMIT,
(FAN_TO_REG(GL518_INIT_FAN_MIN_1, 2) << 8) |
FAN_TO_REG(GL518_INIT_FAN_MIN_2, 2));
gl518_write_value(client, GL518_REG_VIN1_LIMIT,
(IN_TO_REG(GL518_INIT_VIN_MAX_1) << 8) |
IN_TO_REG(GL518_INIT_VIN_MIN_1));
gl518_write_value(client, GL518_REG_VIN2_LIMIT,
(IN_TO_REG(GL518_INIT_VIN_MAX_2) << 8) |
IN_TO_REG(GL518_INIT_VIN_MIN_2));
gl518_write_value(client, GL518_REG_VIN3_LIMIT,
(IN_TO_REG(GL518_INIT_VIN_MAX_3) << 8) |
IN_TO_REG(GL518_INIT_VIN_MIN_3));
gl518_write_value(client, GL518_REG_VDD_LIMIT,
(VDD_TO_REG(GL518_INIT_VDD_MAX) << 8) |
VDD_TO_REG(GL518_INIT_VDD_MIN));
/* Clear status register (bit 5=1), start (bit6=1) */
gl518_write_value(client, GL518_REG_CONF, 0x24);
gl518_write_value(client, GL518_REG_CONF, 0x44);
-63
View File
@@ -114,39 +114,6 @@ static inline u8 FAN_TO_REG(long rpm, int div)
#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
205-(val)*5)
/* Initial values */
#define GL520_INIT_TEMP_OVER 600
#define GL520_INIT_TEMP_HYST 500
#define GL520_INIT_FAN_MIN_1 3000
#define GL520_INIT_FAN_MIN_2 3000
/* These are somewhat sane */
#define GL520_INIT_VIN_1 330 /* 3.3 V */
#define GL520_INIT_VIN_2 286 /* 12 V */
#define GL520_INIT_VIN_3 260 /* Vcore */
#define GL520_INIT_VIN_4 160 /* -12 V */
#define GL520_INIT_VDD 500 /* 5 V */
#define GL520_INIT_PERCENTAGE 10
#define GL520_INIT_VIN_MIN_1 \
(GL520_INIT_VIN_1 - GL520_INIT_VIN_1 * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VIN_MAX_1 \
(GL520_INIT_VIN_1 + GL520_INIT_VIN_1 * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VIN_MIN_2 \
(GL520_INIT_VIN_2 - GL520_INIT_VIN_2 * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VIN_MAX_2 \
(GL520_INIT_VIN_2 + GL520_INIT_VIN_2 * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VIN_MIN_3 \
(GL520_INIT_VIN_3 - GL520_INIT_VIN_3 * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VIN_MAX_3 \
(GL520_INIT_VIN_3 + GL520_INIT_VIN_3 * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VDD_MIN \
(GL520_INIT_VDD - GL520_INIT_VDD * GL520_INIT_PERCENTAGE / 100)
#define GL520_INIT_VDD_MAX \
(GL520_INIT_VDD + GL520_INIT_VDD * GL520_INIT_PERCENTAGE / 100)
/* Each client has this additional data */
struct gl520_data {
int sysctl_id;
@@ -410,36 +377,6 @@ static void gl520_init_client(struct i2c_client *client)
/* Never interrupts */
gl520_write_value(client, GL520_REG_MASK, 0x00);
gl520_write_value(client, GL520_REG_TEMP1_HYST,
TEMP_TO_REG(GL520_INIT_TEMP_HYST));
gl520_write_value(client, GL520_REG_TEMP1_OVER,
TEMP_TO_REG(GL520_INIT_TEMP_OVER));
/* We set Temp2, but not Vin4. */
gl520_write_value(client, GL520_REG_TEMP2_HYST,
TEMP_TO_REG(GL520_INIT_TEMP_HYST));
gl520_write_value(client, GL520_REG_TEMP2_OVER,
TEMP_TO_REG(GL520_INIT_TEMP_OVER));
gl520_write_value(client, GL520_REG_MISC, (DIV_TO_REG(2) << 6) |
(DIV_TO_REG(2) << 4));
gl520_write_value(client, GL520_REG_FAN_LIMIT,
(FAN_TO_REG(GL520_INIT_FAN_MIN_1, 2) << 8) |
FAN_TO_REG(GL520_INIT_FAN_MIN_2, 2));
gl520_write_value(client, GL520_REG_VIN1_LIMIT,
(IN_TO_REG(GL520_INIT_VIN_MAX_1) << 8) |
IN_TO_REG(GL520_INIT_VIN_MIN_1));
gl520_write_value(client, GL520_REG_VIN2_LIMIT,
(IN_TO_REG(GL520_INIT_VIN_MAX_2) << 8) |
IN_TO_REG(GL520_INIT_VIN_MIN_2));
gl520_write_value(client, GL520_REG_VIN3_LIMIT,
(IN_TO_REG(GL520_INIT_VIN_MAX_3) << 8) |
IN_TO_REG(GL520_INIT_VIN_MIN_3));
gl520_write_value(client, GL520_REG_VDD_LIMIT,
(VDD_TO_REG(GL520_INIT_VDD_MAX) << 8) |
VDD_TO_REG(GL520_INIT_VDD_MIN));
/* Clear status register (bit 5=1), start (bit6=1) */
gl520_write_value(client, GL520_REG_CONF, 0x24);
gl520_write_value(client, GL520_REG_CONF, 0x44);
-118
View File
@@ -176,73 +176,6 @@ extern inline u8 DIV_TO_REG(long val)
/*#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)*/
#define DIV_FROM_REG(val) (1 << (val))
/* Initial limits. Use the config file to set better limits. */
#define IT87_INIT_IN_0 170
#define IT87_INIT_IN_1 250
#define IT87_INIT_IN_2 (330 / 2)
#define IT87_INIT_IN_3 (((500) * 100)/168)
#define IT87_INIT_IN_4 (((1200) * 10)/38)
#define IT87_INIT_IN_5 (((1200) * 10)/72)
#define IT87_INIT_IN_6 (((500) * 10)/56)
#define IT87_INIT_IN_7 (((500) * 100)/168)
#define IT87_INIT_IN_PERCENTAGE 10
#define IT87_INIT_IN_MIN_0 \
(IT87_INIT_IN_0 - IT87_INIT_IN_0 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_0 \
(IT87_INIT_IN_0 + IT87_INIT_IN_0 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_1 \
(IT87_INIT_IN_1 - IT87_INIT_IN_1 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_1 \
(IT87_INIT_IN_1 + IT87_INIT_IN_1 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_2 \
(IT87_INIT_IN_2 - IT87_INIT_IN_2 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_2 \
(IT87_INIT_IN_2 + IT87_INIT_IN_2 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_3 \
(IT87_INIT_IN_3 - IT87_INIT_IN_3 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_3 \
(IT87_INIT_IN_3 + IT87_INIT_IN_3 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_4 \
(IT87_INIT_IN_4 - IT87_INIT_IN_4 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_4 \
(IT87_INIT_IN_4 + IT87_INIT_IN_4 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_5 \
(IT87_INIT_IN_5 - IT87_INIT_IN_5 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_5 \
(IT87_INIT_IN_5 + IT87_INIT_IN_5 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_6 \
(IT87_INIT_IN_6 - IT87_INIT_IN_6 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_6 \
(IT87_INIT_IN_6 + IT87_INIT_IN_6 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MIN_7 \
(IT87_INIT_IN_7 - IT87_INIT_IN_7 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_IN_MAX_7 \
(IT87_INIT_IN_7 + IT87_INIT_IN_7 * IT87_INIT_IN_PERCENTAGE / 100)
#define IT87_INIT_FAN_MIN_1 3000
#define IT87_INIT_FAN_MIN_2 3000
#define IT87_INIT_FAN_MIN_3 3000
#define IT87_INIT_TEMP_HIGH_1 600
#define IT87_INIT_TEMP_LOW_1 540
#define IT87_INIT_TEMP_HIGH_2 600
#define IT87_INIT_TEMP_LOW_2 200
#define IT87_INIT_TEMP_HIGH_3 600
#define IT87_INIT_TEMP_LOW_3 200
#define IT87_INIT_PWR_TL_OFF 160
#define IT87_INIT_PWR_TL_LOW 160
#define IT87_INIT_PWR_TL_MED 480
#define IT87_INIT_PWR_TL_HI 540
#define IT87_INIT_PWR_TL_OVR 580
#define IT87_INIT_PWR_LOW 3
#define IT87_INIT_PWR_MED 4
#define IT87_INIT_PWR_HI 9
/* For each registered IT87, we need to keep some data in memory. That
data is pointed to by it87_list[NR]->data. The structure itself is
dynamically allocated, at the same time when a new it87 client is
@@ -677,57 +610,6 @@ static void it87_init_client(struct i2c_client *client)
if( reset_it87 ) {
it87_write_value(client, IT87_REG_CONFIG, 0x80);
}
it87_write_value(client, IT87_REG_VIN_MIN(0),
IN_TO_REG(IT87_INIT_IN_MIN_0));
it87_write_value(client, IT87_REG_VIN_MAX(0),
IN_TO_REG(IT87_INIT_IN_MAX_0));
it87_write_value(client, IT87_REG_VIN_MIN(1),
IN_TO_REG(IT87_INIT_IN_MIN_1));
it87_write_value(client, IT87_REG_VIN_MAX(1),
IN_TO_REG(IT87_INIT_IN_MAX_1));
it87_write_value(client, IT87_REG_VIN_MIN(2),
IN_TO_REG(IT87_INIT_IN_MIN_2));
it87_write_value(client, IT87_REG_VIN_MAX(2),
IN_TO_REG(IT87_INIT_IN_MAX_2));
it87_write_value(client, IT87_REG_VIN_MIN(3),
IN_TO_REG(IT87_INIT_IN_MIN_3));
it87_write_value(client, IT87_REG_VIN_MAX(3),
IN_TO_REG(IT87_INIT_IN_MAX_3));
it87_write_value(client, IT87_REG_VIN_MIN(4),
IN_TO_REG(IT87_INIT_IN_MIN_4));
it87_write_value(client, IT87_REG_VIN_MAX(4),
IN_TO_REG(IT87_INIT_IN_MAX_4));
it87_write_value(client, IT87_REG_VIN_MIN(5),
IN_TO_REG(IT87_INIT_IN_MIN_5));
it87_write_value(client, IT87_REG_VIN_MAX(5),
IN_TO_REG(IT87_INIT_IN_MAX_5));
it87_write_value(client, IT87_REG_VIN_MIN(6),
IN_TO_REG(IT87_INIT_IN_MIN_6));
it87_write_value(client, IT87_REG_VIN_MAX(6),
IN_TO_REG(IT87_INIT_IN_MAX_6));
it87_write_value(client, IT87_REG_VIN_MIN(7),
IN_TO_REG(IT87_INIT_IN_MIN_7));
it87_write_value(client, IT87_REG_VIN_MAX(7),
IN_TO_REG(IT87_INIT_IN_MAX_7));
/* Note: Battery voltage does not have limit registers */
it87_write_value(client, IT87_REG_FAN_MIN(1),
FAN_TO_REG(IT87_INIT_FAN_MIN_1, 2));
it87_write_value(client, IT87_REG_FAN_MIN(2),
FAN_TO_REG(IT87_INIT_FAN_MIN_2, 2));
it87_write_value(client, IT87_REG_FAN_MIN(3),
FAN_TO_REG(IT87_INIT_FAN_MIN_3, 2));
it87_write_value(client, IT87_REG_TEMP_HIGH(1),
TEMP_TO_REG(IT87_INIT_TEMP_HIGH_1));
it87_write_value(client, IT87_REG_TEMP_LOW(1),
TEMP_TO_REG(IT87_INIT_TEMP_LOW_1));
it87_write_value(client, IT87_REG_TEMP_HIGH(2),
TEMP_TO_REG(IT87_INIT_TEMP_HIGH_2));
it87_write_value(client, IT87_REG_TEMP_LOW(2),
TEMP_TO_REG(IT87_INIT_TEMP_LOW_2));
it87_write_value(client, IT87_REG_TEMP_HIGH(3),
TEMP_TO_REG(IT87_INIT_TEMP_HIGH_3));
it87_write_value(client, IT87_REG_TEMP_LOW(3),
TEMP_TO_REG(IT87_INIT_TEMP_LOW_3));
/* Enable voltage monitors */
it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);