BMC cleanup

git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@1615 7894878c-1315-0410-8ee3-d5d059ff63e0
This commit is contained in:
Mark D. Studebaker committed 2002-11-16 19:40:06 +00:00
1 parent c023ec3d2f
commit d999488cd1
3 files changed
+125 -143

No files matched your search

+82 -87
View File
@@ -1,5 +1,5 @@
/*
i2c-bmc.c - Part of lm_sensors, Linux kernel modules for hardware
i2c-ipmi.c - Part of lm_sensors, Linux kernel modules for hardware
monitoring
Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
@@ -19,10 +19,10 @@
*/
/*
This implements an
This implements a "dummy" i2c adapter for clients to access the
BMC via IPMI messages. Supports only one BMC and one client for now!
*/
#include <linux/version.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
@@ -30,18 +30,18 @@
#include <linux/ipmi.h>
#include "version.h"
static void bmc_inc_use(struct i2c_adapter *adapter);
static void bmc_dec_use(struct i2c_adapter *adapter);
static u32 bmc_func(struct i2c_adapter *adapter);
static void i2c_ipmi_inc_use(struct i2c_adapter *adapter);
static void i2c_ipmi_dec_use(struct i2c_adapter *adapter);
static u32 i2c_ipmi_func(struct i2c_adapter *adapter);
static int bmcclient_i2c_send_message(struct i2c_adapter *, char *, int);
#ifdef MODULE
static
#else
extern
#endif
int __init i2c_bmc_init(void);
static int __init bmc_cleanup(void);
int __init i2c_ipmi_init(void);
static int __init i2c_ipmi_cleanup(void);
#ifdef MODULE
extern int init_module(void);
@@ -49,31 +49,29 @@ extern int cleanup_module(void);
#endif /* MODULE */
/* I2C Data */
/* This is the actual algorithm we define */
static struct i2c_algorithm bmc_algorithm = {
/* name */ "IPMI algorithm",
/* id */ I2C_ALGO_IPMI,
/* master_xfer */ NULL,
/* smbus_access */ NULL,
/* slave_send */ NULL,
/* slave_rcv */ NULL,
/* algo_control */ NULL,
/* functionality */ &bmc_func,
static struct i2c_algorithm i2c_ipmi_algorithm = {
.name = "IPMI algorithm",
.id = I2C_ALGO_IPMI,
.master_xfer = NULL,
.smbus_xfer = NULL,
.slave_send = &bmcclient_i2c_send_message,
.slave_recv = NULL,
.algo_control = NULL,
.functionality = &i2c_ipmi_func,
};
static struct i2c_adapter bmc_adapter = {
/* name */ "IPMI adapter",
/* id */ I2C_ALGO_IPMI | I2C_HW_IPMI,
/* algorithm */ &bmc_algorithm,
/* algo_data */ NULL,
/* inc_use */ &bmc_inc_use,
/* dec_use */ &bmc_dec_use,
/* data */ NULL,
static struct i2c_adapter i2c_ipmi_adapter = {
.name = "IPMI adapter",
.id = I2C_ALGO_IPMI | I2C_HW_IPMI,
.algo = &i2c_ipmi_algorithm,
.algo_data = NULL,
.inc_use = &i2c_ipmi_inc_use,
.dec_use = &i2c_ipmi_dec_use,
.data = NULL,
/* Other fields not initialized */
};
/* IPMI Data */
static ipmi_user_t i2c_bmc_user;
static ipmi_user_t i2c_ipmi_user;
static unsigned char ipmi_version_major;
static unsigned char ipmi_version_minor;
@@ -81,71 +79,71 @@ static const char msgdata[IPMI_MAX_ADDR_SIZE]; /* ?? */
static struct ipmi_addr address = {
IPMI_SYSTEM_INTERFACE_ADDR_TYPE,
IPMI_BMC_CHANNEL,
NULL
{0}
}; /* send address */
static struct ipmi_msg message; /* send message */
static long msgid; /* message ID */
static int interfaces;
static int (*rcv_callback)(struct i2c_client *client,unsigned int cmd, void *arg);
static int interfaces; /* number of BMC's found */
static int (*rcv_callback)(struct i2c_client *client, unsigned int cmd,
void *arg);
/* Used in bmc_init/cleanup */
/*
static int __initdata bmc_initialized;
*/
void bmc_inc_use(struct i2c_adapter *adapter)
void i2c_ipmi_inc_use(struct i2c_adapter *adapter)
{
#ifdef MODULE
MOD_INC_USE_COUNT;
#endif
}
void bmc_dec_use(struct i2c_adapter *adapter)
void i2c_ipmi_dec_use(struct i2c_adapter *adapter)
{
#ifdef MODULE
MOD_DEC_USE_COUNT;
#endif
}
/* We can't do a thing... */
static u32 bmc_func(struct i2c_adapter *adapter)
/* Dummy adapter... */
static u32 i2c_ipmi_func(struct i2c_adapter *adapter)
{
return 0;
}
/*-----------------------------------*/
/************** Message Sending **************/
void bmc_i2c_send_message(int id, struct ipmi_msg * msg)
static void ipmi_i2c_send_message(int id, struct ipmi_msg * msg)
{
ipmi_request(i2c_bmc_user, &address, id, msg, 0);
ipmi_request(i2c_ipmi_user, &address, id, msg, 0);
}
void bmcclient_i2c_send_message(struct i2c_client *client, int id, struct ipmi_msg * msg)
/* This is the message send function exported to the client
via the i2c_adapter struct.
We use the existing (but unused) slave_send function pointer.
Hence the ugly casts. */
static int bmcclient_i2c_send_message(struct i2c_adapter *clnt,
char * mesg, int id)
{
id = (id & 0xffff) | 0x10000;
struct ipmi_msg *msg = (struct ipmi_msg *) mesg;
struct i2c_client *client = (struct i2c_client *) clnt;
/* todo: keep track of multiple clients and save callback for each */
id = (id & 0xffffff) | 0x1000000;
rcv_callback = client->driver->command;
bmc_i2c_send_message(id, msg);
ipmi_i2c_send_message(id, msg);
return 0;
}
/************** Message Receiving **************/
static void ipmi_i2c_msg_handler(struct ipmi_recv_msg *msg,
void *handler_data)
{
int rcvid = msg->msgid & 0xffff;
int client = (msg->msgid >> 16) & 0xf;
if (msg->msg.data[0] != 0) {
printk(KERN_ERR "IPMI BMC response: Error 0x%x on cmd 0x%x\n",
msg->msg.data[0],
msg->msg.cmd);
} else {
/*
printk(KERN_INFO "IPMI BMC response: No error on cmd 0x%x\n",
msg->msg.cmd);
*/
}
int rcvid = msg->msgid & 0xffffff;
int client = (msg->msgid >> 24) & 0xf;
if (msg->msg.data[0] != 0)
printk(KERN_WARNING "IPMI BMC response: Error 0x%x on cmd 0x%x\n",
msg->msg.data[0], msg->msg.cmd);
/* todo: keep track of multiple clients */
if(client == 1 && rcv_callback != NULL)
(*rcv_callback)(NULL, client, msg);
else
@@ -157,42 +155,41 @@ static struct ipmi_user_hndl ipmi_hndlrs =
.ipmi_recv_hndl = ipmi_i2c_msg_handler,
};
/**************** Initialization ****************/
/* callback for each BMC found */
static void ipmi_register_bmc(int ipmi_intf)
{
unsigned long flags;
int rv = -EBUSY;
int rv;
if(interfaces > 0) { /* 1 max for now */
printk(KERN_INFO
"i2c-bmc.o: Additional IPMI interface %d not supported\n",
"i2c-ipmi.o: Additional IPMI interface %d not supported\n",
ipmi_intf);
return;
}
rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &i2c_bmc_user);
rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &i2c_ipmi_user);
if (rv < 0) {
printk(KERN_ERR "i2c-bmc.o: Unable to register with ipmi\n");
printk(KERN_ERR "i2c-ipmi.o: Unable to register with ipmi\n");
return;
}
ipmi_get_version(i2c_bmc_user,
&ipmi_version_major,
&ipmi_version_minor);
if ((rv = i2c_add_adapter(&bmc_adapter))) {
printk(KERN_ERR "i2c-bmc.o: Adapter registration failed, "
"module i2c-bmc.o is not inserted\n.");
if ((rv = i2c_add_adapter(&i2c_ipmi_adapter))) {
printk(KERN_ERR "i2c-ipmi.o: Adapter registration failed, "
"module i2c-ipmi.o is not inserted\n.");
return;
}
ipmi_get_version(i2c_ipmi_user, &ipmi_version_major,
&ipmi_version_minor);
printk(KERN_INFO
"i2c-bmc.o: Registered IPMI interface %d with version %d.%d\n",
"i2c-ipmi.o: Registered IPMI interface %d with version %d.%d\n",
ipmi_intf, ipmi_version_major, ipmi_version_minor);
interfaces++;
}
static void ipmi_new_smi(int if_num)
{
ipmi_register_bmc(if_num);
@@ -200,7 +197,11 @@ static void ipmi_new_smi(int if_num)
static void ipmi_smi_gone(int if_num)
{
/* TBD */
if (interfaces >= 1) {
i2c_del_adapter(&i2c_ipmi_adapter);
ipmi_destroy_user(i2c_ipmi_user);
interfaces--;
}
}
static struct ipmi_smi_watcher smi_watcher =
@@ -209,11 +210,11 @@ static struct ipmi_smi_watcher smi_watcher =
.smi_gone = ipmi_smi_gone
};
int __init i2c_bmc_init(void)
int __init i2c_ipmi_init(void)
{
int rv;
printk(KERN_INFO "i2c-bmc.o version %s (%s)\n", LM_VERSION, LM_DATE);
printk(KERN_INFO "i2c-ipmi.o version %s (%s)\n", LM_VERSION, LM_DATE);
rv = ipmi_smi_watcher_register(&smi_watcher);
if (rv) {
@@ -222,38 +223,32 @@ int __init i2c_bmc_init(void)
return rv;
}
printk(KERN_INFO "i2c-bmc.o: BMC access for i2c modules initialized.\n");
printk(KERN_INFO "i2c-ipmi.o: BMC access for i2c modules initialized.\n");
return 0;
}
int __init bmc_cleanup(void)
int __init ipmi_cleanup(void)
{
ipmi_smi_watcher_unregister(&smi_watcher);
if (interfaces >= 1) {
i2c_del_adapter(&bmc_adapter);
ipmi_destroy_user(i2c_bmc_user);
interfaces--;
}
ipmi_smi_gone(0);
return 0;
}
#ifdef MODULE
EXPORT_SYMBOL(bmcclient_i2c_send_message);
MODULE_AUTHOR("M. D. Studebaker <mdsxyz123@yahoo.com>");
MODULE_DESCRIPTION("BMC bus access through i2c");
MODULE_DESCRIPTION("IPMI-BMC access through i2c");
#ifdef MODULE_LICENSE
MODULE_LICENSE("GPL");
#endif
int init_module(void)
{
return i2c_bmc_init();
return i2c_ipmi_init();
}
int cleanup_module(void)
{
return bmc_cleanup();
return ipmi_cleanup();
}
#endif /* MODULE */
+40 -50
View File
@@ -129,6 +129,7 @@ struct sdrdata {
u8 number;
u8 capab;
u16 thresh_mask;
u8 format;
u8 linear;
s16 m;
s16 b;
@@ -232,8 +233,8 @@ static const char * threshold_text[] = {
"lower non-recoverable threshold",
"lower critical threshold",
"lower non-critical threshold",
"positive-going hysteresis", /* not used */
"negative-going hysteresis"
"positive-going hysteresis",
"negative-going hysteresis" /* unused */
};
/* select two out of the 8 possible readable thresholds, and place indexes into the limits
@@ -269,8 +270,8 @@ static void bmcsensors_select_thresholds(int i)
/* select lower threshold */
if(((capab & 0x30) == 0x10) || /* readable hysteresis ? */
((capab & 0x30) == 0x20)) /* neg hyst */
sdrd[i].lim2 = 7;
((capab & 0x30) == 0x20)) /* pos hyst */
sdrd[i].lim2 = 6;
else if(mask & 0x02) { /* lower crit */
sdrd[i].lim2 = 4;
if((capab & 0x0c) == 0x08 && (mask & 0x0200))
@@ -358,17 +359,28 @@ static void bmcsensors_build_proc_table()
continue;
}
sdrd[i].sysctl = bmcsensors_dir_table[i].ctl_name;
if(sdrd[i].linear != 0) {
printk(KERN_INFO "bmcsensors.o: sensor %d: (type 0x%x) nonlinear function 0x%.2x unsupported\n",
i, sdrd[i].stype, sdrd[i].linear);
}
ipmi_sprintf(id, sdrd[i].id, sdrd[i].string_type, sdrd[i].id_length);
printk(KERN_INFO "bmcsensors.o: registering sensor %d: '%s' (type 0x%.2x) as %s "
"(m=%d; b=%d; k1=%d; k2=%d; cap=0x%.2x; mask=0x%.4x)\n",
i, id, sdrd[i].stype, bmcsensors_dir_table[i].procname,
printk(KERN_INFO "bmcsensors.o: registering sensor %d: (type 0x%.2x) "
"(fmt=%d; m=%d; b=%d; k1=%d; k2=%d; cap=0x%.2x; mask=0x%.4x)\n",
i, sdrd[i].stype, sdrd[i].format,
sdrd[i].m, sdrd[i].b,sdrd[i].k & 0xf, sdrd[i].k >> 4,
sdrd[i].capab, sdrd[i].thresh_mask);
if(sdrd[i].id_length) {
ipmi_sprintf(id, sdrd[i].id, sdrd[i].string_type, sdrd[i].id_length);
printk(KERN_INFO "bmcsensors.o: sensors.conf: label %s \"%s\"\n",
bmcsensors_dir_table[i].procname, id);
}
bmcsensors_select_thresholds(i);
if(sdrd[i].linear != 0) {
printk(KERN_INFO "bmcsensors.o: sensor %d: nonlinear function 0x%.2x unsupported\n",
i, sdrd[i].linear);
}
if((sdrd[i].format & 0x03) == 0x02) {
printk(KERN_INFO "bmcsensors.o: sensor %d: 1's complement format unsupported\n",
i);
} else if((sdrd[i].format & 0x03) == 0x03) {
printk(KERN_INFO "bmcsensors.o: sensor %d: threshold sensor only, no readings available",
i);
}
if(sdrd[i].lim1_write || sdrd[i].lim2_write)
bmcsensors_dir_table[i].mode = 0644;
else
@@ -494,6 +506,7 @@ static int bmcsensors_rcv_sdr_msg(struct ipmi_msg *msg, int state)
sdrd[sdrd_count].capab = data[14];
sdrd[sdrd_count].thresh_mask = (data[22] << 8) | data[21];
if(type == 1) {
sdrd[sdrd_count].format = data[24] >> 6;
sdrd[sdrd_count].linear = data[26] & 0x7f;
sdrd[sdrd_count].m = data[27];
sdrd[sdrd_count].m |= ((u16) (data[28] & 0xc0)) << 2;
@@ -528,24 +541,6 @@ static int bmcsensors_rcv_sdr_msg(struct ipmi_msg *msg, int state)
}
}
}
/*
} else {
printk(KERN_INFO "bmcsensors.o: Ignoring sensor type 0x%x\n", stype);
}
*/
/*
printk(KERN_INFO "bmcsensors.o: STATE_SDR: record = 0x%x; version = 0x%x, type = 0x%x; length=0x%x\n",
record, version, type, length);
printk(KERN_INFO "bmcsensors.o: STATE_SDR: owner = 0x%x; lun = 0x%x, number = 0x%x; entity=0x%x\n",
owner, lun, number, entity);
printk(KERN_INFO "bmcsensors.o: STATE_SDR: instance = 0x%x; init = 0x%x, capab = 0x%x; stype=0x%x\n",
instance, init, capab, stype);
printk(KERN_INFO "bmcsensors.o: STATE_SDR: code = 0x%x\n",
code);
printk(KERN_INFO "bmcsensors.o: STATE_SDR: next = 0x%x\n", nextrecord);
} else {
printk(KERN_INFO "bmcsensors.o: unknown STATE_SDR type 0x%x\n", type);
*/
}
if(nextrecord == 0xFFFF) {
@@ -615,7 +610,11 @@ static void bmcsensors_send_message(struct ipmi_msg * msg)
printk(KERN_INFO "bmcsensors.o: Send BMC msg, cmd: 0x%x\n",
msg->cmd);
#endif
/*
bmcclient_i2c_send_message(&bmc_client, msgid++, msg);
*/
bmc_client.adapter->algo->slave_send((struct i2c_adapter *) &bmc_client,
(char *) msg, msgid++);
}
@@ -660,18 +659,11 @@ void bmcsensors_get_reading(struct i2c_client *client, int i)
int bmcsensors_attach_adapter(struct i2c_adapter *adapter)
{
/*
not really i2c or isa so i2c_detect not required
*/
printk(KERN_INFO "bmcsensors.o: in bmcsensors_detect() for ID %x\n",
adapter->algo->id);
if(adapter->algo->id != I2C_ALGO_IPMI) {
if(adapter->algo->id != I2C_ALGO_IPMI)
return 0;
}
if(bmcsensors_initialized >= 2) {
printk(KERN_INFO "bmcsensors.o: limit of 1\n");
printk(KERN_INFO "bmcsensors.o: Additional IPMI adapter not supported\n");
return 0;
}
@@ -686,9 +678,6 @@ int bmcsensors_detect(struct i2c_adapter *adapter, int address,
bmc_client.id = 0;
bmc_client.adapter = adapter;
bmc_data.valid = 0;
/*
init_MUTEX(bmc_data.update_lock);
*/
if ((err = i2c_attach_client(&bmc_client))) {
printk(KERN_ERR "attach client error in bmcsensors_detect()\n");
@@ -696,7 +685,6 @@ int bmcsensors_detect(struct i2c_adapter *adapter, int address,
}
bmcsensors_initialized = 2;
/* initialize some key data */
state = STATE_INIT;
sdrd_count = 0;
receive_counter = 0;
@@ -775,7 +763,6 @@ void bmcsensors_update_client(struct i2c_client *client)
/* don't start an update cycle if one already in progress */
if(state != STATE_READING) {
state = STATE_READING;
printk(KERN_DEBUG "bmcsensors.o: Starting update\n");
bmcsensors_get_reading(client, 0);
}
}
@@ -818,10 +805,11 @@ static long convert_value(u8 value, int i)
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 * sdrd[i].m;
if(k1 < 8)
r += sdrd[i].b * exps[k1];
else
@@ -866,11 +854,13 @@ void bmcsensors_all(struct i2c_client *client, int operation, int ctl_name,
results[0] = convert_value(sdrd[i].limits[sdrd[i].lim1], i);
else
results[0] = 0;
if(sdrd[i].lim2 >= 0)
results[1] = convert_value(sdrd[i].limits[sdrd[i].lim2], i);
else
results[1] = 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[2] - results[1];
} else
results[1] = 0;
*nrels_mag = 3;
}
} else if (operation == SENSORS_PROC_REAL_WRITE) {
+3 -6
View File
@@ -3649,7 +3649,7 @@ void print_vt8231(const sensors_chip_name *name)
void print_bmc(const sensors_chip_name *name)
{
char *label = NULL;
double cur,min,max,fdiv;
double cur,min,max;
int alarms, valid, i;
/*
@@ -3682,14 +3682,11 @@ void print_bmc(const sensors_chip_name *name)
for(i = 0; i < BMC_MAX_FANS; i++) {
if (!sensors_get_label_and_valid(*name,SENSORS_BMC_FAN1+i,&label,&valid) &&
!sensors_get_feature(*name,SENSORS_BMC_FAN1+i,&cur) &&
/*
!sensors_get_feature(*name,SENSORS_BMC_FAN1_DIV+i,&fdiv) &&
*/
!sensors_get_feature(*name,SENSORS_BMC_FAN1_MIN+i,&min)) {
if (valid) {
print_label(label,10);
printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
cur,min,fdiv, alarms&BMC_ALARM_FAN1?"ALARM":"");
printf("%4.0f RPM (min = %4.0f RPM) %s\n",
cur,min,alarms&BMC_ALARM_FAN1?"ALARM":"");
}
}
free_the_label(&label);