wt/lm-sensors
1
0 Fork 0
mirror of https://github.com/lm-sensors/lm-sensors.git synced 2026-11-10 16:30:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

several bmcsensors fixes:

Browse Source 
- fix voltage scaling
	- swap voltage limits
	- use lower critical rather than upper hysteresis
	  for non-temperature sensors
	- increase libsensors support to 20 voltage, 10 fan,
	  10 temperature sensors
	Tickets 1406 and 1407.


git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@2017 7894878c-1315-0410-8ee3-d5d059ff63e0
This commit is contained in:
Mark D. Studebaker committed 2003-10-13 03:01:45 +00:00
1 parent 337ff4d2a9
commit f38dc972e0
3 files changed
+282 -123
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

CHANGES
+2
View File
@@ -17,7 +17,9 @@ ask CVS about it:
-----------------------------------------------------------------------------
2.8.2 (???)
Library: Fix bmcsensors scaling, increase number of sensors
Module i2c-sis630: sync with 2.6.0-X driver version.
Module bmcsensors: Fix voltage scaling, voltage and fan limits
2.8.1 (20031005)
kernel/chips/bmcsensors.c
+94 -80
View File
@@ -63,23 +63,22 @@ static int bmcsensors_command(struct i2c_client *client, unsigned int cmd,
void *arg);
static void bmcsensors_update_client(struct i2c_client *client);
static int bmcsensors_find(int *address);
static void bmcsensors_reserve_sdr(void);
static void bmcsensors_all(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
#if 0
static void bmcsensors_alarms(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void bmcsensors_fan_div(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void bmcsensors_pwm(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
#endif
static void bmcsensors_get_sdr(u16 resid, u16 record, u8 offset);
static void bmcsensors_get_reading(struct i2c_client *client, int i);
static int bmcsensors_id = 0;
static struct i2c_driver bmcsensors_driver = {
.owner = THIS_MODULE,
.name = "BMC Sensors driver",
@@ -102,7 +101,7 @@ struct i2c_client bmc_client = {
0
};
static bmcsensors_initialized;
static int bmcsensors_initialized;
#define MAX_SDR_ENTRIES 50
#define SDR_LIMITS 8
@@ -123,7 +122,7 @@ struct sdrdata {
u8 k;
u8 nominal;
u8 limits[SDR_LIMITS];
int lim1, lim2;
int lim1, lim2; /* index into limits for reported upper and lower limit */
u8 lim1_write, lim2_write;
u8 string_type;
u8 id_length;
@@ -238,69 +237,71 @@ static const char * threshold_text[] = {
/* select two out of the 8 possible readable thresholds, and place indexes into the limits
array into lim1 and lim2. Set writable flags */
static void bmcsensors_select_thresholds(int i)
static void bmcsensors_select_thresholds(struct sdrdata * sd)
{
u8 capab = sdrd[i].capab;
u16 mask = sdrd[i].thresh_mask;
u8 capab = sd->capab;
u16 mask = sd->thresh_mask;
sdrd[i].lim1 = -1;
sdrd[i].lim2 = -1;
sdrd[i].lim1_write = 0;
sdrd[i].lim2_write = 0;
sd->lim1 = -1;
sd->lim2 = -1;
sd->lim1_write = 0;
sd->lim2_write = 0;
if(((capab & 0x0c) == 0x04) || /* readable thresholds ? */
((capab & 0x0c) == 0x08)) {
/* select upper threshold */
if(mask & 0x10) { /* upper crit */
sdrd[i].lim1 = 1;
sd->lim1 = 1;
if((capab & 0x0c) == 0x08 && (mask & 0x1000))
sdrd[i].lim1_write = 1;
sd->lim1_write = 1;
}
else if(mask & 0x20) { /* upper non-recov */
sdrd[i].lim1 = 0;
sd->lim1 = 0;
if((capab & 0x0c) == 0x08 && (mask & 0x2000))
sdrd[i].lim1_write = 1;
sd->lim1_write = 1;
}
else if(mask & 0x08) { /* upper non-crit */
sdrd[i].lim1 = 2;
sd->lim1 = 2;
if((capab & 0x0c) == 0x08 && (mask & 0x0800))
sdrd[i].lim1_write = 1;
sd->lim1_write = 1;
}
/* select lower threshold */
if(((capab & 0x30) == 0x10) || /* readable hysteresis ? */
((capab & 0x30) == 0x20)) /* pos hyst */
sdrd[i].lim2 = 6;
if((((capab & 0x30) == 0x10) || /* readable ? */
((capab & 0x30) == 0x20)) && /* pos hyst */
sd->stype == STYPE_TEMP)
sd->lim2 = 6;
else if(mask & 0x02) { /* lower crit */
sdrd[i].lim2 = 4;
sd->lim2 = 4;
if((capab & 0x0c) == 0x08 && (mask & 0x0200))
sdrd[i].lim2_write = 1;
sd->lim2_write = 1;
}
else if(mask & 0x04) { /* lower non-recov */
sdrd[i].lim2 = 3;
sd->lim2 = 3;
if((capab & 0x0c) == 0x08 && (mask & 0x0400))
sdrd[i].lim2_write = 1;
sd->lim2_write = 1;
}
else if(mask & 0x01) { /* lower non-crit */
sdrd[i].lim2 = 5;
sd->lim2 = 5;
if((capab & 0x0c) == 0x08 && (mask & 0x0100))
sdrd[i].lim2_write = 1;
sd->lim2_write = 1;
}
}
if(sdrd[i].lim1 >= 0)
printk(KERN_INFO "bmcsensors.o: sensor %d: using %s for upper limit\n",
i, threshold_text[sdrd[i].lim1]);
/* fixme swap lim1/lim2 if m < 0 */
if(sd->lim1 >= 0)
printk(KERN_INFO "bmcsensors.o: using %s for upper limit\n",
threshold_text[sd->lim1]);
#ifdef DEBUG
else
printk(KERN_INFO "bmcsensors.o: sensor %d: no readable upper limit\n", i);
printk(KERN_INFO "bmcsensors.o: no readable upper limit\n");
#endif
if(sdrd[i].lim2 >= 0)
printk(KERN_INFO "bmcsensors.o: sensor %d: using %s for lower limit\n",
i, threshold_text[sdrd[i].lim2]);
if(sd->lim2 >= 0)
printk(KERN_INFO "bmcsensors.o: using %s for lower limit\n",
threshold_text[sd->lim2]);
#ifdef DEBUG
else
printk(KERN_INFO "bmcsensors.o: sensor %d: no readable lower limit\n", i);
printk(KERN_INFO "bmcsensors.o: no readable lower limit\n");
#endif
}
@@ -368,7 +369,7 @@ static void bmcsensors_build_proc_table()
printk(KERN_INFO "bmcsensors.o: sensors.conf: label %s \"%s\"\n",
bmcsensors_dir_table[i].procname, id);
}
bmcsensors_select_thresholds(i);
bmcsensors_select_thresholds(sdrd + i);
if(sdrd[i].linear != 0) {
printk(KERN_INFO
"bmcsensors.o: sensor %d: nonlinear function 0x%.2x unsupported, expect bad results\n",
@@ -440,12 +441,11 @@ static int bmcsensors_rcv_reading_msg(struct ipmi_msg *msg)
static int bmcsensors_rcv_sdr_msg(struct ipmi_msg *msg, int state)
{
u16 record;
int type, length, owner, lun, number, entity, instance, init;
int stype, code;
int type;
int stype;
int id_length;
int i;
int rstate = STATE_SDR;
struct ipmi_msg txmsg;
unsigned char * data;
u8 id[SDR_MAX_UNPACKED_ID_LENGTH];
@@ -848,51 +848,55 @@ static void bmcsensors_update_client(struct i2c_client *client)
/************* /proc callback helper functions *********/
/* need better way to map from sysctl to sdrd record number */
static int find_sdrd(int sysctl)
static struct sdrdata * find_sdrd(int sysctl)
{
int i;
for(i = 0; i < sdrd_count; i++)
if(sdrd[i].sysctl == sysctl)
return i;
return -1;
return sdrd + i;
return NULL;
}
/* IPMI V1.5 Section 30 */
static const int exps[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000};
static int decplaces(int i)
/* Return 0 for fan, 2 for temp, 3 for voltage
We could make it variable based on the accuracy (= log10(m * 10**k2));
this would work for /proc output, however libsensors resolution
is statically set in lib/chips.c */
static int decplaces(struct sdrdata *sd)
{
u8 k2;
k2 = sdrd[i].k >> 4;
if(k2 < 8)
switch(sd->stype) {
case STYPE_TEMP:
return 2;
case STYPE_CURR:
case STYPE_VOLT:
return 3;
case STYPE_FAN:
default:
return 0;
else
return 16 - k2;
}
}
static long convert_value(u8 value, int i)
/* convert a raw value to a reading. IMPI V1.5 Section 30 */
static long conv_val(int value, struct sdrdata *sd)
{
u8 k1, k2;
long r;
/* fixme signed/unsigned */
r = value * sdrd[i].m;
k1 = sdrd[i].k & 0x0f;
k2 = sdrd[i].k >> 4;
r = value * sd->m;
k1 = sd->k & 0x0f;
k2 = sd->k >> 4;
if(k1 < 8)
r += sdrd[i].b * exps[k1];
r += sd->b * exps[k1];
else
r += sdrd[i].b / exps[16 - k1];
r += sd->b / exps[16 - k1];
r *= exps[decplaces(sd)];
if(k2 < 8)
r *= exps[k2];
/*
taken care of by nrels_mag
else
r /= exps[16 - k2];
*/
return r;
}
@@ -902,49 +906,59 @@ static long convert_value(u8 value, int i)
static void bmcsensors_all(struct i2c_client *client, int operation, int ctl_name,
int *nrels_mag, long *results)
{
int i;
struct sdrdata *sd;
/*
struct bmcsensors_data *data = client->data;
*/
if((i = find_sdrd(ctl_name)) < 0) {
if((sd = find_sdrd(ctl_name)) == NULL) {
*nrels_mag = 0;
return;
}
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = decplaces(i);
*nrels_mag = decplaces(sd);
else if (operation == SENSORS_PROC_REAL_READ) {
bmcsensors_update_client(client);
if(sdrd[i].stype == STYPE_FAN) { /* lower limit only */
if(sdrd[i].lim2 >= 0)
results[0] = convert_value(sdrd[i].limits[sdrd[i].lim2], i);
else
results[0] = 0;
results[1] = convert_value(sdrd[i].reading, i);
if(sd->lim2 >= 0) {
if(sd->stype == STYPE_TEMP) /* upper limit first */
results[0] =
conv_val(sd->limits[sd->lim1], sd);
else /* lower limit first */
results[0] =
conv_val(sd->limits[sd->lim2], sd);
} else
results[0] = 0;
if(sd->stype == STYPE_FAN) { /* lower limit only */
results[1] = conv_val(sd->reading, sd);
*nrels_mag = 2;
} else {
if(sdrd[i].lim1 >= 0)
results[0] = convert_value(sdrd[i].limits[sdrd[i].lim1], i);
else
results[0] = 0;
results[2] = convert_value(sdrd[i].reading, i);
if(sdrd[i].lim2 >= 0) {
results[1] = convert_value(sdrd[i].limits[sdrd[i].lim2], i);
if(sdrd[i].lim2 == 6) /* pos. threshold */
results[1] = results[0] - results[1];
if(sd->lim1 >= 0) {
if(sd->stype == STYPE_TEMP) { /* lower 2nd */
results[1] =
conv_val(sd->limits[sd->lim2], sd);
if(sd->lim2 == 6) /* pos. thresh. */
results[1] = results[0] -
results[1];
} else /* upper 2nd */
results[1] =
conv_val(sd->limits[sd->lim1], sd);
} else
results[1] = 0;
results[2] = conv_val(sd->reading, sd);
*nrels_mag = 3;
}
} else if (operation == SENSORS_PROC_REAL_WRITE) {
if (*nrels_mag >= 1) {
/* unimplemented */
}
}
}
#if 0
static void bmcsensors_alarms(struct i2c_client *client, int operation, int ctl_name,
int *nrels_mag, long *results)
{
struct bmcsensors_data *data = client->data;
#if 0
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0;
else if (operation == SENSORS_PROC_REAL_READ) {
@@ -952,8 +966,8 @@ static void bmcsensors_alarms(struct i2c_client *client, int operation, int ctl_
results[0] = data->alarms;
*nrels_mag = 1;
}
#endif
}
#endif
static int __init sm_bmcsensors_init(void)
{
lib/chips.c
+186 -43
View File
@@ -4272,61 +4272,166 @@ static sensors_chip_feature vt8231_features[] =
static sensors_chip_feature bmc_features[] =
{
{ SENSORS_BMC_IN1, "in1", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN, "in1_min", SENSORS_BMC_IN1,
SENSORS_BMC_IN1,
SENSORS_MODE_RW, BMC_SYSCTL_IN1, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX, "in1_max", SENSORS_BMC_IN1,
SENSORS_BMC_IN1,
SENSORS_MODE_RW, BMC_SYSCTL_IN1, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1, VALUE(2), 3 },
{ SENSORS_BMC_IN1+1, "in2", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+1, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1+1, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+1, "in2_min", SENSORS_BMC_IN1+1,
SENSORS_BMC_IN1+1,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+1, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+1, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+1, "in2_max", SENSORS_BMC_IN1+1,
SENSORS_BMC_IN1+1,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+1, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+1, VALUE(2), 3 },
{ SENSORS_BMC_IN1+2, "in3", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+2, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1+2, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+2, "in3_min", SENSORS_BMC_IN1+2,
SENSORS_BMC_IN1+2,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+2, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+2, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+2, "in3_max", SENSORS_BMC_IN1+2,
SENSORS_BMC_IN1+2,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+2, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+2, VALUE(2), 3 },
{ SENSORS_BMC_IN1+3, "in4", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+3, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1+3, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+3, "in4_min", SENSORS_BMC_IN1+3,
SENSORS_BMC_IN1+3,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+3, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+3, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+3, "in4_max", SENSORS_BMC_IN1+3,
SENSORS_BMC_IN1+3,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+3, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+3, VALUE(2), 3 },
{ SENSORS_BMC_IN1+4, "in5", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+4, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1+4, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+4, "in5_min", SENSORS_BMC_IN1+4,
SENSORS_BMC_IN1+4,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+4, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+4, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+4, "in5_max", SENSORS_BMC_IN1+4,
SENSORS_BMC_IN1+4,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+4, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+4, VALUE(2), 3 },
{ SENSORS_BMC_IN1+5, "in6", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+5, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1+5, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+5, "in6_min", SENSORS_BMC_IN1+5,
SENSORS_BMC_IN1+5,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+5, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+5, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+5, "in6_max", SENSORS_BMC_IN1+5,
SENSORS_BMC_IN1+5,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+5, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+5, VALUE(2), 3 },
{ SENSORS_BMC_IN1+6, "in7", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+6, VALUE(3), 2 },
SENSORS_MODE_R, BMC_SYSCTL_IN1+6, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+6, "in7_min", SENSORS_BMC_IN1+6,
SENSORS_BMC_IN1+6,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+6, VALUE(1), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+6, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+6, "in7_max", SENSORS_BMC_IN1+6,
SENSORS_BMC_IN1+6,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+6, VALUE(2), 2 },
SENSORS_MODE_RW, BMC_SYSCTL_IN1+6, VALUE(2), 3 },
{ SENSORS_BMC_IN1+7, "in8", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+7, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+7, "in8_min", SENSORS_BMC_IN1+7,
SENSORS_BMC_IN1+7,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+7, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+7, "in8_max", SENSORS_BMC_IN1+7,
SENSORS_BMC_IN1+7,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+7, VALUE(2), 3 },
{ SENSORS_BMC_IN1+8, "in9", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+8, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+8, "in9_min", SENSORS_BMC_IN1+8,
SENSORS_BMC_IN1+8,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+8, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+8, "in9_max", SENSORS_BMC_IN1+8,
SENSORS_BMC_IN1+8,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+8, VALUE(2), 3 },
{ SENSORS_BMC_IN1+9, "in10", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+9, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+9, "in10_min", SENSORS_BMC_IN1+9,
SENSORS_BMC_IN1+9,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+9, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+9, "in10_max", SENSORS_BMC_IN1+9,
SENSORS_BMC_IN1+9,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+9, VALUE(2), 3 },
{ SENSORS_BMC_IN1+10, "in11", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+10, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+10, "in11_min", SENSORS_BMC_IN1+10,
SENSORS_BMC_IN1+10,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+10, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+10, "in11_max", SENSORS_BMC_IN1+10,
SENSORS_BMC_IN1+10,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+10, VALUE(2), 3 },
{ SENSORS_BMC_IN1+11, "in12", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+11, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+11, "in12_min", SENSORS_BMC_IN1+11,
SENSORS_BMC_IN1+11,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+11, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+11, "in12_max", SENSORS_BMC_IN1+11,
SENSORS_BMC_IN1+11,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+11, VALUE(2), 3 },
{ SENSORS_BMC_IN1+12, "in13", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+12, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+12, "in13_min", SENSORS_BMC_IN1+12,
SENSORS_BMC_IN1+12,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+12, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+12, "in13_max", SENSORS_BMC_IN1+12,
SENSORS_BMC_IN1+12,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+12, VALUE(2), 3 },
{ SENSORS_BMC_IN1+13, "in14", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+13, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+13, "in14_min", SENSORS_BMC_IN1+13,
SENSORS_BMC_IN1+13,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+13, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+13, "in14_max", SENSORS_BMC_IN1+13,
SENSORS_BMC_IN1+13,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+13, VALUE(2), 3 },
{ SENSORS_BMC_IN1+14, "in15", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+14, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+14, "in15_min", SENSORS_BMC_IN1+14,
SENSORS_BMC_IN1+14,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+14, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+14, "in15_max", SENSORS_BMC_IN1+14,
SENSORS_BMC_IN1+14,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+14, VALUE(2), 3 },
{ SENSORS_BMC_IN1+15, "in16", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+15, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+15, "in16_min", SENSORS_BMC_IN1+15,
SENSORS_BMC_IN1+15,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+15, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+15, "in16_max", SENSORS_BMC_IN1+15,
SENSORS_BMC_IN1+15,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+15, VALUE(2), 3 },
{ SENSORS_BMC_IN1+16, "in17", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+16, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+16, "in17_min", SENSORS_BMC_IN1+16,
SENSORS_BMC_IN1+16,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+16, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+16, "in17_max", SENSORS_BMC_IN1+16,
SENSORS_BMC_IN1+16,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+16, VALUE(2), 3 },
{ SENSORS_BMC_IN1+17, "in18", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+17, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+17, "in18_min", SENSORS_BMC_IN1+17,
SENSORS_BMC_IN1+17,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+17, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+17, "in18_max", SENSORS_BMC_IN1+17,
SENSORS_BMC_IN1+17,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+17, VALUE(2), 3 },
{ SENSORS_BMC_IN1+18, "in19", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+18, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+18, "in19_min", SENSORS_BMC_IN1+18,
SENSORS_BMC_IN1+18,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+18, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+18, "in19_max", SENSORS_BMC_IN1+18,
SENSORS_BMC_IN1+18,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+18, VALUE(2), 3 },
{ SENSORS_BMC_IN1+19, "in20", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_IN1+19, VALUE(3), 3 },
{ SENSORS_BMC_IN1_MIN+19, "in20_min", SENSORS_BMC_IN1+19,
SENSORS_BMC_IN1+19,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+19, VALUE(1), 3 },
{ SENSORS_BMC_IN1_MAX+19, "in20_max", SENSORS_BMC_IN1+19,
SENSORS_BMC_IN1+19,
SENSORS_MODE_RW, BMC_SYSCTL_IN1+19, VALUE(2), 3 },
{ SENSORS_BMC_FAN1, "fan1", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_FAN1, VALUE(2), 0 },
{ SENSORS_BMC_FAN1+1, "fan2", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
@@ -4341,6 +4446,12 @@ static sensors_chip_feature bmc_features[] =
SENSORS_MODE_R, BMC_SYSCTL_FAN1+5, VALUE(2), 0 },
{ SENSORS_BMC_FAN1+6, "fan7", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_FAN1+6, VALUE(2), 0 },
{ SENSORS_BMC_FAN1+7, "fan8", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_FAN1+7, VALUE(2), 0 },
{ SENSORS_BMC_FAN1+8, "fan9", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_FAN1+8, VALUE(2), 0 },
{ SENSORS_BMC_FAN1+9, "fan10", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_FAN1+9, VALUE(2), 0 },
{ SENSORS_BMC_FAN1_MIN, "fan1_min", SENSORS_BMC_FAN1,
SENSORS_BMC_FAN1,
SENSORS_MODE_RW, BMC_SYSCTL_FAN1, VALUE(1), 0 },
@@ -4362,63 +4473,95 @@ static sensors_chip_feature bmc_features[] =
{ SENSORS_BMC_FAN1_MIN+6, "fan7_min", SENSORS_BMC_FAN1+6,
SENSORS_BMC_FAN1+6,
SENSORS_MODE_RW, BMC_SYSCTL_FAN1+6, VALUE(1), 0 },
{ SENSORS_BMC_FAN1_MIN+7, "fan8_min", SENSORS_BMC_FAN1+7,
SENSORS_BMC_FAN1+7,
SENSORS_MODE_RW, BMC_SYSCTL_FAN1+7, VALUE(1), 0 },
{ SENSORS_BMC_FAN1_MIN+8, "fan9_min", SENSORS_BMC_FAN1+8,
SENSORS_BMC_FAN1+8,
SENSORS_MODE_RW, BMC_SYSCTL_FAN1+8, VALUE(1), 0 },
{ SENSORS_BMC_FAN1_MIN+9, "fan10_min", SENSORS_BMC_FAN1+9,
SENSORS_BMC_FAN1+9,
SENSORS_MODE_RW, BMC_SYSCTL_FAN1+9, VALUE(1), 0 },
{ SENSORS_BMC_TEMP1, "temp1", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1, VALUE(3), 0 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN, "temp1_min", SENSORS_BMC_TEMP1,
SENSORS_BMC_TEMP1, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1, VALUE(2), 0 },
BMC_SYSCTL_TEMP1, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX, "temp1_max", SENSORS_BMC_TEMP1,
SENSORS_BMC_TEMP1, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1, VALUE(1), 0 },
BMC_SYSCTL_TEMP1, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+1, "temp2", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+1, VALUE(3), 0 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+1, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+1, "temp2_min", SENSORS_BMC_TEMP1+1,
SENSORS_BMC_TEMP1+1, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+1, VALUE(2), 0 },
BMC_SYSCTL_TEMP1+1, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+1, "temp2_max", SENSORS_BMC_TEMP1+1,
SENSORS_BMC_TEMP1+1, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+1, VALUE(1), 0 },
BMC_SYSCTL_TEMP1+1, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+2, "temp3", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+2, VALUE(3), 0 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+2, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+2, "temp3_min", SENSORS_BMC_TEMP1+2,
SENSORS_BMC_TEMP1+2, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+2, VALUE(2), 0 },
BMC_SYSCTL_TEMP1+2, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+2, "temp3_max", SENSORS_BMC_TEMP1+2,
SENSORS_BMC_TEMP1+2, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+2, VALUE(1), 0 },
/* scalings from here down */
BMC_SYSCTL_TEMP1+2, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+3, "temp4", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+3, VALUE(3), 1 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+3, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+3, "temp4_min", SENSORS_BMC_TEMP1+3,
SENSORS_BMC_TEMP1+3, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+3, VALUE(2), 1 },
BMC_SYSCTL_TEMP1+3, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+3, "temp4_max", SENSORS_BMC_TEMP1+3,
SENSORS_BMC_TEMP1+3, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+3, VALUE(1), 1 },
BMC_SYSCTL_TEMP1+3, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+4, "temp5", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+4, VALUE(3), 1 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+4, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+4, "temp5_min", SENSORS_BMC_TEMP1+4,
SENSORS_BMC_TEMP1+4, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+4, VALUE(2), 1 },
BMC_SYSCTL_TEMP1+4, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+4, "temp5_max", SENSORS_BMC_TEMP1+4,
SENSORS_BMC_TEMP1+4, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+4, VALUE(1), 1 },
BMC_SYSCTL_TEMP1+4, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+5, "temp6", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+5, VALUE(3), 1 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+5, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+5, "temp6_min", SENSORS_BMC_TEMP1+5,
SENSORS_BMC_TEMP1+5, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+5, VALUE(2), 1 },
BMC_SYSCTL_TEMP1+5, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+5, "temp6_max", SENSORS_BMC_TEMP1+5,
SENSORS_BMC_TEMP1+5, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+5, VALUE(1), 1 },
BMC_SYSCTL_TEMP1+5, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+6, "temp7", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+6, VALUE(3), 1 },
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+6, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+6, "temp7_min", SENSORS_BMC_TEMP1+6,
SENSORS_BMC_TEMP1+6, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+6, VALUE(2), 1 },
BMC_SYSCTL_TEMP1+6, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+6, "temp7_max", SENSORS_BMC_TEMP1+6,
SENSORS_BMC_TEMP1+6, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+6, VALUE(1), 1 },
BMC_SYSCTL_TEMP1+6, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+7, "temp8", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+7, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+7, "temp8_min", SENSORS_BMC_TEMP1+7,
SENSORS_BMC_TEMP1+7, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+7, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+7, "temp8_max", SENSORS_BMC_TEMP1+7,
SENSORS_BMC_TEMP1+7, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+7, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+8, "temp9", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+8, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+8, "temp9_min", SENSORS_BMC_TEMP1+8,
SENSORS_BMC_TEMP1+8, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+8, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+8, "temp9_max", SENSORS_BMC_TEMP1+8,
SENSORS_BMC_TEMP1+8, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+8, VALUE(1), 2 },
{ SENSORS_BMC_TEMP1+9, "temp10", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_TEMP1+9, VALUE(3), 2 },
{ SENSORS_BMC_TEMP1_MIN+9, "temp10_min", SENSORS_BMC_TEMP1+9,
SENSORS_BMC_TEMP1+9, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+9, VALUE(2), 2 },
{ SENSORS_BMC_TEMP1_MAX+9, "temp10_max", SENSORS_BMC_TEMP1+9,
SENSORS_BMC_TEMP1+9, SENSORS_MODE_RW,
BMC_SYSCTL_TEMP1+9, VALUE(1), 2 },
{ SENSORS_BMC_ALARMS, "alarms", SENSORS_NO_MAPPING, SENSORS_NO_MAPPING,
SENSORS_MODE_R, BMC_SYSCTL_ALARMS, VALUE(1), 0 },
{ 0 }