Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-12 07:01:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

IPMI: Style fixes in the system interface code

Browse Source 
Lots of style fixes for the IPMI system interface driver.  No functional
changes.  Basically fixes everything reported by checkpatch and fixes the
comment style.

[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Corey Minyard <cminyard@mvista.com>
Cc: Rocky Craig <rocky.craig@hp.com>
Cc: Hannes Schulz <schulz@schwaar.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Corey Minyard 2008-04-29 01:01:10 -07:00 committed by Linus Torvalds
parent c70d749986
commit c305e3d38e
5 changed files with 574 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
drivers/char/ipmi/ipmi_bt_sm.c
View File

@ -37,26 +37,32 @@
#define BT_DEBUG_ENABLE 1 /* Generic messages */ #define BT_DEBUG_ENABLE 1 /* Generic messages */
#define BT_DEBUG_MSG 2 /* Prints all request/response buffers */ #define BT_DEBUG_MSG 2 /* Prints all request/response buffers */
#define BT_DEBUG_STATES 4 /* Verbose look at state changes */ #define BT_DEBUG_STATES 4 /* Verbose look at state changes */
/* BT_DEBUG_OFF must be zero to correspond to the default uninitialized /*
value */ * BT_DEBUG_OFF must be zero to correspond to the default uninitialized
* value
*/
static int bt_debug; /* 0 == BT_DEBUG_OFF */ static int bt_debug; /* 0 == BT_DEBUG_OFF */
module_param(bt_debug, int, 0644); module_param(bt_debug, int, 0644);
MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states"); MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
/* Typical "Get BT Capabilities" values are 2-3 retries, 5-10 seconds, /*
and 64 byte buffers. However, one HP implementation wants 255 bytes of * Typical "Get BT Capabilities" values are 2-3 retries, 5-10 seconds,
buffer (with a documented message of 160 bytes) so go for the max. * and 64 byte buffers. However, one HP implementation wants 255 bytes of
Since the Open IPMI architecture is single-message oriented at this * buffer (with a documented message of 160 bytes) so go for the max.
stage, the queue depth of BT is of no concern. */ * Since the Open IPMI architecture is single-message oriented at this
* stage, the queue depth of BT is of no concern.
*/
#define BT_NORMAL_TIMEOUT 5 /* seconds */ #define BT_NORMAL_TIMEOUT 5 /* seconds */
#define BT_NORMAL_RETRY_LIMIT 2 #define BT_NORMAL_RETRY_LIMIT 2
#define BT_RESET_DELAY 6 /* seconds after warm reset */ #define BT_RESET_DELAY 6 /* seconds after warm reset */
/* States are written in chronological order and usually cover /*
multiple rows of the state table discussion in the IPMI spec. */ * States are written in chronological order and usually cover
* multiple rows of the state table discussion in the IPMI spec.
*/
enum bt_states { enum bt_states {
BT_STATE_IDLE = 0, /* Order is critical in this list */ BT_STATE_IDLE = 0, /* Order is critical in this list */
@ -76,8 +82,10 @@ enum bt_states {
BT_STATE_LONG_BUSY /* BT doesn't get hosed :-) */ BT_STATE_LONG_BUSY /* BT doesn't get hosed :-) */
}; };
/* Macros seen at the end of state "case" blocks. They help with legibility /*
and debugging. */ * Macros seen at the end of state "case" blocks. They help with legibility
* and debugging.
*/
#define BT_STATE_CHANGE(X, Y) { bt->state = X; return Y; } #define BT_STATE_CHANGE(X, Y) { bt->state = X; return Y; }
@ -110,11 +118,13 @@ struct si_sm_data {
#define BT_H_BUSY 0x40 #define BT_H_BUSY 0x40
#define BT_B_BUSY 0x80 #define BT_B_BUSY 0x80
/* Some bits are toggled on each write: write once to set it, once /*
more to clear it; writing a zero does nothing. To absolutely * Some bits are toggled on each write: write once to set it, once
clear it, check its state and write if set. This avoids the "get * more to clear it; writing a zero does nothing. To absolutely
current then use as mask" scheme to modify one bit. Note that the * clear it, check its state and write if set. This avoids the "get
variable "bt" is hardcoded into these macros. */ * current then use as mask" scheme to modify one bit. Note that the
* variable "bt" is hardcoded into these macros.
*/
#define BT_STATUS bt->io->inputb(bt->io, 0) #define BT_STATUS bt->io->inputb(bt->io, 0)
#define BT_CONTROL(x) bt->io->outputb(bt->io, 0, x) #define BT_CONTROL(x) bt->io->outputb(bt->io, 0, x)
@ -125,8 +135,10 @@ struct si_sm_data {
#define BT_INTMASK_R bt->io->inputb(bt->io, 2) #define BT_INTMASK_R bt->io->inputb(bt->io, 2)
#define BT_INTMASK_W(x) bt->io->outputb(bt->io, 2, x) #define BT_INTMASK_W(x) bt->io->outputb(bt->io, 2, x)
/* Convenience routines for debugging. These are not multi-open safe! /*
Note the macros have hardcoded variables in them. */ * Convenience routines for debugging. These are not multi-open safe!
* Note the macros have hardcoded variables in them.
*/
static char *state2txt(unsigned char state) static char *state2txt(unsigned char state)
{ {
@ -182,7 +194,8 @@ static char *status2txt(unsigned char status)
static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io) static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io)
{ {
memset(bt, 0, sizeof(struct si_sm_data)); memset(bt, 0, sizeof(struct si_sm_data));
if (bt->io != io) { /* external: one-time only things */ if (bt->io != io) {
/* external: one-time only things */
bt->io = io; bt->io = io;
bt->seq = 0; bt->seq = 0;
} }
@ -246,8 +259,10 @@ static int bt_start_transaction(struct si_sm_data *bt,
return 0; return 0;
} }
/* After the upper state machine has been told SI_SM_TRANSACTION_COMPLETE /*
it calls this. Strip out the length and seq bytes. */ * After the upper state machine has been told SI_SM_TRANSACTION_COMPLETE
* it calls this. Strip out the length and seq bytes.
*/
static int bt_get_result(struct si_sm_data *bt, static int bt_get_result(struct si_sm_data *bt,
unsigned char *data, unsigned char *data,
@ -292,8 +307,10 @@ static void reset_flags(struct si_sm_data *bt)
BT_INTMASK_W(BT_BMC_HWRST); BT_INTMASK_W(BT_BMC_HWRST);
} }
/* Get rid of an unwanted/stale response. This should only be needed for /*
BMCs that support multiple outstanding requests. */ * Get rid of an unwanted/stale response. This should only be needed for
* BMCs that support multiple outstanding requests.
*/
static void drain_BMC2HOST(struct si_sm_data *bt) static void drain_BMC2HOST(struct si_sm_data *bt)
{ {
@ -337,8 +354,10 @@ static inline int read_all_bytes(struct si_sm_data *bt)
{ {
unsigned char i; unsigned char i;
/* length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode. /*
Keep layout of first four bytes aligned with write_data[] */ * length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode.
* Keep layout of first four bytes aligned with write_data[]
*/
bt->read_data[0] = BMC2HOST; bt->read_data[0] = BMC2HOST;
bt->read_count = bt->read_data[0]; bt->read_count = bt->read_data[0];
@ -362,8 +381,8 @@ static inline int read_all_bytes(struct si_sm_data *bt)
if (max > 16) if (max > 16)
max = 16; max = 16;
for (i = 0; i < max; i++) for (i = 0; i < max; i++)
printk (" %02x", bt->read_data[i]); printk(KERN_CONT " %02x", bt->read_data[i]);
printk ("%s\n", bt->read_count == max ? "" : " ..."); printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ...");
} }
/* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */ /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
@ -402,8 +421,10 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
printk(KERN_WARNING "IPMI BT: %s in %s %s ", /* open-ended line */ printk(KERN_WARNING "IPMI BT: %s in %s %s ", /* open-ended line */
reason, STATE2TXT, STATUS2TXT); reason, STATE2TXT, STATUS2TXT);
/* Per the IPMI spec, retries are based on the sequence number /*
known only to this module, so manage a restart here. */ * Per the IPMI spec, retries are based on the sequence number
* known only to this module, so manage a restart here.
*/
(bt->error_retries)++; (bt->error_retries)++;
if (bt->error_retries < bt->BT_CAP_retries) { if (bt->error_retries < bt->BT_CAP_retries) {
printk("%d retries left\n", printk("%d retries left\n",
@ -412,7 +433,7 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
return SI_SM_CALL_WITHOUT_DELAY; return SI_SM_CALL_WITHOUT_DELAY;
} }
printk("failed %d retries, sending error response\n", printk(KERN_WARNING "failed %d retries, sending error response\n",
bt->BT_CAP_retries); bt->BT_CAP_retries);
if (!bt->nonzero_status) if (!bt->nonzero_status)
printk(KERN_ERR "IPMI BT: stuck, try power cycle\n"); printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
@ -424,8 +445,10 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
return SI_SM_CALL_WITHOUT_DELAY; return SI_SM_CALL_WITHOUT_DELAY;
} }
/* Concoct a useful error message, set up the next state, and /*
be done with this sequence. */ * Concoct a useful error message, set up the next state, and
* be done with this sequence.
*/
bt->state = BT_STATE_IDLE; bt->state = BT_STATE_IDLE;
switch (cCode) { switch (cCode) {
@ -461,10 +484,12 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
last_printed = bt->state; last_printed = bt->state;
} }
/* Commands that time out may still (eventually) provide a response. /*
This stale response will get in the way of a new response so remove * Commands that time out may still (eventually) provide a response.
it if possible (hopefully during IDLE). Even if it comes up later * This stale response will get in the way of a new response so remove
it will be rejected by its (now-forgotten) seq number. */ * it if possible (hopefully during IDLE). Even if it comes up later
* it will be rejected by its (now-forgotten) seq number.
*/
if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) { if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) {
drain_BMC2HOST(bt); drain_BMC2HOST(bt);
@ -472,7 +497,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
} }
if ((bt->state != BT_STATE_IDLE) && if ((bt->state != BT_STATE_IDLE) &&
(bt->state < BT_STATE_PRINTME)) { /* check timeout */ (bt->state < BT_STATE_PRINTME)) {
/* check timeout */
bt->timeout -= time; bt->timeout -= time;
if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1)) if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
return error_recovery(bt, return error_recovery(bt,
@ -482,8 +508,10 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
switch (bt->state) { switch (bt->state) {
/* Idle state first checks for asynchronous messages from another /*
channel, then does some opportunistic housekeeping. */ * Idle state first checks for asynchronous messages from another
* channel, then does some opportunistic housekeeping.
*/
case BT_STATE_IDLE: case BT_STATE_IDLE:
if (status & BT_SMS_ATN) { if (status & BT_SMS_ATN) {
@ -531,16 +559,19 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
BT_CONTROL(BT_H_BUSY); /* set */ BT_CONTROL(BT_H_BUSY); /* set */
/* Uncached, ordered writes should just proceeed serially but /*
some BMCs don't clear B2H_ATN with one hit. Fast-path a * Uncached, ordered writes should just proceeed serially but
workaround without too much penalty to the general case. */ * some BMCs don't clear B2H_ATN with one hit. Fast-path a
* workaround without too much penalty to the general case.
*/
BT_CONTROL(BT_B2H_ATN); /* clear it to ACK the BMC */ BT_CONTROL(BT_B2H_ATN); /* clear it to ACK the BMC */
BT_STATE_CHANGE(BT_STATE_CLEAR_B2H, BT_STATE_CHANGE(BT_STATE_CLEAR_B2H,
SI_SM_CALL_WITHOUT_DELAY); SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_CLEAR_B2H: case BT_STATE_CLEAR_B2H:
if (status & BT_B2H_ATN) { /* keep hitting it */ if (status & BT_B2H_ATN) {
/* keep hitting it */
BT_CONTROL(BT_B2H_ATN); BT_CONTROL(BT_B2H_ATN);
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
} }
@ -548,7 +579,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
SI_SM_CALL_WITHOUT_DELAY); SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_READ_BYTES: case BT_STATE_READ_BYTES:
if (!(status & BT_H_BUSY)) /* check in case of retry */ if (!(status & BT_H_BUSY))
/* check in case of retry */
BT_CONTROL(BT_H_BUSY); BT_CONTROL(BT_H_BUSY);
BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */ BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */
i = read_all_bytes(bt); /* true == packet seq match */ i = read_all_bytes(bt); /* true == packet seq match */
@ -599,8 +631,10 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
BT_STATE_CHANGE(BT_STATE_XACTION_START, BT_STATE_CHANGE(BT_STATE_XACTION_START,
SI_SM_CALL_WITH_DELAY); SI_SM_CALL_WITH_DELAY);
/* Get BT Capabilities, using timing of upper level state machine. /*
Set outreqs to prevent infinite loop on timeout. */ * Get BT Capabilities, using timing of upper level state machine.
* Set outreqs to prevent infinite loop on timeout.
*/
case BT_STATE_CAPABILITIES_BEGIN: case BT_STATE_CAPABILITIES_BEGIN:
bt->BT_CAP_outreqs = 1; bt->BT_CAP_outreqs = 1;
{ {
@ -638,10 +672,12 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
static int bt_detect(struct si_sm_data *bt) static int bt_detect(struct si_sm_data *bt)
{ {
/* It's impossible for the BT status and interrupt registers to be /*
all 1's, (assuming a properly functioning, self-initialized BMC) * It's impossible for the BT status and interrupt registers to be
but that's what you get from reading a bogus address, so we * all 1's, (assuming a properly functioning, self-initialized BMC)
test that first. The calling routine uses negative logic. */ * but that's what you get from reading a bogus address, so we
* test that first. The calling routine uses negative logic.
*/
if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF)) if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF))
return 1; return 1;
@ -658,8 +694,7 @@ static int bt_size(void)
return sizeof(struct si_sm_data); return sizeof(struct si_sm_data);
} }
struct si_sm_handlers bt_smi_handlers = struct si_sm_handlers bt_smi_handlers = {
{
.init_data = bt_init_data, .init_data = bt_init_data,
.start_transaction = bt_start_transaction, .start_transaction = bt_start_transaction,
.get_result = bt_get_result, .get_result = bt_get_result,

143
drivers/char/ipmi/ipmi_kcs_sm.c
View File

@ -60,37 +60,58 @@ MODULE_PARM_DESC(kcs_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
/* The states the KCS driver may be in. */ /* The states the KCS driver may be in. */
enum kcs_states { enum kcs_states {
KCS_IDLE, /* The KCS interface is currently /* The KCS interface is currently doing nothing. */
doing nothing. */ KCS_IDLE,
KCS_START_OP, /* We are starting an operation. The
data is in the output buffer, but /*
nothing has been done to the * We are starting an operation. The data is in the output
interface yet. This was added to * buffer, but nothing has been done to the interface yet. This
the state machine in the spec to * was added to the state machine in the spec to wait for the
wait for the initial IBF. */ * initial IBF.
KCS_WAIT_WRITE_START, /* We have written a write cmd to the */
interface. */ KCS_START_OP,
KCS_WAIT_WRITE, /* We are writing bytes to the
interface. */ /* We have written a write cmd to the interface. */
KCS_WAIT_WRITE_END, /* We have written the write end cmd KCS_WAIT_WRITE_START,
to the interface, and still need to
write the last byte. */ /* We are writing bytes to the interface. */
KCS_WAIT_READ, /* We are waiting to read data from KCS_WAIT_WRITE,
the interface. */
KCS_ERROR0, /* State to transition to the error /*
handler, this was added to the * We have written the write end cmd to the interface, and
state machine in the spec to be * still need to write the last byte.
sure IBF was there. */ */
KCS_ERROR1, /* First stage error handler, wait for KCS_WAIT_WRITE_END,
the interface to respond. */
KCS_ERROR2, /* The abort cmd has been written, /* We are waiting to read data from the interface. */
wait for the interface to KCS_WAIT_READ,
respond. */
KCS_ERROR3, /* We wrote some data to the /*
interface, wait for it to switch to * State to transition to the error handler, this was added to
read mode. */ * the state machine in the spec to be sure IBF was there.
KCS_HOSED /* The hardware failed to follow the */
state machine. */ KCS_ERROR0,
/*
* First stage error handler, wait for the interface to
* respond.
*/
KCS_ERROR1,
/*
* The abort cmd has been written, wait for the interface to
* respond.
*/
KCS_ERROR2,
/*
* We wrote some data to the interface, wait for it to switch
* to read mode.
*/
KCS_ERROR3,
/* The hardware failed to follow the state machine. */
KCS_HOSED
}; };
#define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
@ -102,8 +123,7 @@ enum kcs_states {
#define MAX_ERROR_RETRIES 10 #define MAX_ERROR_RETRIES 10
#define ERROR0_OBF_WAIT_JIFFIES (2*HZ) #define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
struct si_sm_data struct si_sm_data {
{
enum kcs_states state; enum kcs_states state;
struct si_sm_io *io; struct si_sm_io *io;
unsigned char write_data[MAX_KCS_WRITE_SIZE]; unsigned char write_data[MAX_KCS_WRITE_SIZE];
@ -187,7 +207,8 @@ static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
(kcs->error_retries)++; (kcs->error_retries)++;
if (kcs->error_retries > MAX_ERROR_RETRIES) { if (kcs->error_retries > MAX_ERROR_RETRIES) {
if (kcs_debug & KCS_DEBUG_ENABLE) if (kcs_debug & KCS_DEBUG_ENABLE)
printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n", reason); printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n",
reason);
kcs->state = KCS_HOSED; kcs->state = KCS_HOSED;
} else { } else {
kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES; kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;
@ -271,9 +292,8 @@ static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
if (kcs_debug & KCS_DEBUG_MSG) { if (kcs_debug & KCS_DEBUG_MSG) {
printk(KERN_DEBUG "start_kcs_transaction -"); printk(KERN_DEBUG "start_kcs_transaction -");
for (i = 0; i < size; i ++) { for (i = 0; i < size; i++)
printk(" %02x", (unsigned char) (data [i])); printk(" %02x", (unsigned char) (data [i]));
}
printk("\n"); printk("\n");
} }
kcs->error_retries = 0; kcs->error_retries = 0;
@ -305,9 +325,11 @@ static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
kcs->read_pos = 3; kcs->read_pos = 3;
} }
if (kcs->truncated) { if (kcs->truncated) {
/* Report a truncated error. We might overwrite /*
another error, but that's too bad, the user needs * Report a truncated error. We might overwrite
to know it was truncated. */ * another error, but that's too bad, the user needs
* to know it was truncated.
*/
data[2] = IPMI_ERR_MSG_TRUNCATED; data[2] = IPMI_ERR_MSG_TRUNCATED;
kcs->truncated = 0; kcs->truncated = 0;
} }
@ -315,9 +337,11 @@ static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
return kcs->read_pos; return kcs->read_pos;
} }
/* This implements the state machine defined in the IPMI manual, see /*
that for details on how this works. Divide that flowchart into * This implements the state machine defined in the IPMI manual, see
sections delimited by "Wait for IBF" and this will become clear. */ * that for details on how this works. Divide that flowchart into
* sections delimited by "Wait for IBF" and this will become clear.
*/
static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time) static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
{ {
unsigned char status; unsigned char status;
@ -392,7 +416,8 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
case KCS_WAIT_WRITE_END: case KCS_WAIT_WRITE_END:
if (state != KCS_WRITE_STATE) { if (state != KCS_WRITE_STATE) {
start_error_recovery(kcs, start_error_recovery(kcs,
"Not in write state for write end"); "Not in write state"
" for write end");
break; break;
} }
clear_obf(kcs, status); clear_obf(kcs, status);
@ -413,13 +438,15 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
read_next_byte(kcs); read_next_byte(kcs);
} else { } else {
/* We don't implement this exactly like the state /*
machine in the spec. Some broken hardware * We don't implement this exactly like the state
does not write the final dummy byte to the * machine in the spec. Some broken hardware
read register. Thus obf will never go high * does not write the final dummy byte to the
here. We just go straight to idle, and we * read register. Thus obf will never go high
handle clearing out obf in idle state if it * here. We just go straight to idle, and we
happens to come in. */ * handle clearing out obf in idle state if it
* happens to come in.
*/
clear_obf(kcs, status); clear_obf(kcs, status);
kcs->orig_write_count = 0; kcs->orig_write_count = 0;
kcs->state = KCS_IDLE; kcs->state = KCS_IDLE;
@ -430,7 +457,8 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
case KCS_ERROR0: case KCS_ERROR0:
clear_obf(kcs, status); clear_obf(kcs, status);
status = read_status(kcs); status = read_status(kcs);
if (GET_STATUS_OBF(status)) /* controller isn't responding */ if (GET_STATUS_OBF(status))
/* controller isn't responding */
if (time_before(jiffies, kcs->error0_timeout)) if (time_before(jiffies, kcs->error0_timeout))
return SI_SM_CALL_WITH_TICK_DELAY; return SI_SM_CALL_WITH_TICK_DELAY;
write_cmd(kcs, KCS_GET_STATUS_ABORT); write_cmd(kcs, KCS_GET_STATUS_ABORT);
@ -495,10 +523,12 @@ static int kcs_size(void)
static int kcs_detect(struct si_sm_data *kcs) static int kcs_detect(struct si_sm_data *kcs)
{ {
/* It's impossible for the KCS status register to be all 1's, /*
(assuming a properly functioning, self-initialized BMC) * It's impossible for the KCS status register to be all 1's,
but that's what you get from reading a bogus address, so we * (assuming a properly functioning, self-initialized BMC)
test that first. */ * but that's what you get from reading a bogus address, so we
* test that first.
*/
if (read_status(kcs) == 0xff) if (read_status(kcs) == 0xff)
return 1; return 1;
@ -509,8 +539,7 @@ static void kcs_cleanup(struct si_sm_data *kcs)
{ {
} }
struct si_sm_handlers kcs_smi_handlers = struct si_sm_handlers kcs_smi_handlers = {
{
.init_data = init_kcs_data, .init_data = init_kcs_data,
.start_transaction = start_kcs_transaction, .start_transaction = start_kcs_transaction,
.get_result = get_kcs_result, .get_result = get_kcs_result,

418
drivers/char/ipmi/ipmi_si_intf.c
View File

@ -114,8 +114,7 @@ static char *si_to_str[] = { "kcs", "smic", "bt" };
#define DEVICE_NAME "ipmi_si" #define DEVICE_NAME "ipmi_si"
static struct device_driver ipmi_driver = static struct device_driver ipmi_driver = {
{
.name = DEVICE_NAME, .name = DEVICE_NAME,
.bus = &platform_bus_type .bus = &platform_bus_type
}; };
@ -169,8 +168,7 @@ enum si_stat_indexes {
SI_NUM_STATS SI_NUM_STATS
}; };
struct smi_info struct smi_info {
{
int intf_num; int intf_num;
ipmi_smi_t intf; ipmi_smi_t intf;
struct si_sm_data *si_sm; struct si_sm_data *si_sm;
@ -183,8 +181,10 @@ struct smi_info
struct ipmi_smi_msg *curr_msg; struct ipmi_smi_msg *curr_msg;
enum si_intf_state si_state; enum si_intf_state si_state;
/* Used to handle the various types of I/O that can occur with /*
IPMI */ * Used to handle the various types of I/O that can occur with
* IPMI
*/
struct si_sm_io io; struct si_sm_io io;
int (*io_setup)(struct smi_info *info); int (*io_setup)(struct smi_info *info);
void (*io_cleanup)(struct smi_info *info); void (*io_cleanup)(struct smi_info *info);
@ -195,15 +195,18 @@ struct smi_info
void (*addr_source_cleanup)(struct smi_info *info); void (*addr_source_cleanup)(struct smi_info *info);
void *addr_source_data; void *addr_source_data;
/* Per-OEM handler, called from handle_flags(). /*
Returns 1 when handle_flags() needs to be re-run * Per-OEM handler, called from handle_flags(). Returns 1
or 0 indicating it set si_state itself. * when handle_flags() needs to be re-run or 0 indicating it
* set si_state itself.
*/ */
int (*oem_data_avail_handler)(struct smi_info *smi_info); int (*oem_data_avail_handler)(struct smi_info *smi_info);
/* Flags from the last GET_MSG_FLAGS command, used when an ATTN /*
is set to hold the flags until we are done handling everything * Flags from the last GET_MSG_FLAGS command, used when an ATTN
from the flags. */ * is set to hold the flags until we are done handling everything
* from the flags.
*/
#define RECEIVE_MSG_AVAIL 0x01 #define RECEIVE_MSG_AVAIL 0x01
#define EVENT_MSG_BUFFER_FULL 0x02 #define EVENT_MSG_BUFFER_FULL 0x02
#define WDT_PRE_TIMEOUT_INT 0x08 #define WDT_PRE_TIMEOUT_INT 0x08
@ -215,21 +218,27 @@ struct smi_info
OEM2_DATA_AVAIL) OEM2_DATA_AVAIL)
unsigned char msg_flags; unsigned char msg_flags;
/* If set to true, this will request events the next time the /*
state machine is idle. */ * If set to true, this will request events the next time the
* state machine is idle.
*/
atomic_t req_events; atomic_t req_events;
/* If true, run the state machine to completion on every send /*
call. Generally used after a panic to make sure stuff goes * If true, run the state machine to completion on every send
out. */ * call. Generally used after a panic to make sure stuff goes
* out.
*/
int run_to_completion; int run_to_completion;
/* The I/O port of an SI interface. */ /* The I/O port of an SI interface. */
int port; int port;
/* The space between start addresses of the two ports. For /*
instance, if the first port is 0xca2 and the spacing is 4, then * The space between start addresses of the two ports. For
the second port is 0xca6. */ * instance, if the first port is 0xca2 and the spacing is 4, then
* the second port is 0xca6.
*/
unsigned int spacing; unsigned int spacing;
/* zero if no irq; */ /* zero if no irq; */
@ -244,10 +253,12 @@ struct smi_info
/* Used to gracefully stop the timer without race conditions. */ /* Used to gracefully stop the timer without race conditions. */
atomic_t stop_operation; atomic_t stop_operation;
/* The driver will disable interrupts when it gets into a /*
situation where it cannot handle messages due to lack of * The driver will disable interrupts when it gets into a
memory. Once that situation clears up, it will re-enable * situation where it cannot handle messages due to lack of
interrupts. */ * memory. Once that situation clears up, it will re-enable
* interrupts.
*/
int interrupt_disabled; int interrupt_disabled;
/* From the get device id response... */ /* From the get device id response... */
@ -257,8 +268,10 @@ struct smi_info
struct device *dev; struct device *dev;
struct platform_device *pdev; struct platform_device *pdev;
/* True if we allocated the device, false if it came from /*
* someplace else (like PCI). */ * True if we allocated the device, false if it came from
* someplace else (like PCI).
*/
int dev_registered; int dev_registered;
/* Slave address, could be reported from DMI. */ /* Slave address, could be reported from DMI. */
@ -329,8 +342,10 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
struct timeval t; struct timeval t;
#endif #endif
/* No need to save flags, we aleady have interrupts off and we /*
already hold the SMI lock. */ * No need to save flags, we aleady have interrupts off and we
* already hold the SMI lock.
*/
if (!smi_info->run_to_completion) if (!smi_info->run_to_completion)
spin_lock(&(smi_info->msg_lock)); spin_lock(&(smi_info->msg_lock));
@ -353,7 +368,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
link); link);
#ifdef DEBUG_TIMING #ifdef DEBUG_TIMING
do_gettimeofday(&t); do_gettimeofday(&t);
printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec); printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif #endif
err = atomic_notifier_call_chain(&xaction_notifier_list, err = atomic_notifier_call_chain(&xaction_notifier_list,
0, smi_info); 0, smi_info);
@ -365,9 +380,8 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
smi_info->si_sm, smi_info->si_sm,
smi_info->curr_msg->data, smi_info->curr_msg->data,
smi_info->curr_msg->data_size); smi_info->curr_msg->data_size);
if (err) { if (err)
return_hosed_msg(smi_info, err); return_hosed_msg(smi_info, err);
}
rv = SI_SM_CALL_WITHOUT_DELAY; rv = SI_SM_CALL_WITHOUT_DELAY;
} }
@ -382,8 +396,10 @@ static void start_enable_irq(struct smi_info *smi_info)
{ {
unsigned char msg[2]; unsigned char msg[2];
/* If we are enabling interrupts, we have to tell the /*
BMC to use them. */ * If we are enabling interrupts, we have to tell the
* BMC to use them.
*/
msg[0] = (IPMI_NETFN_APP_REQUEST << 2); msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD; msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
@ -415,10 +431,12 @@ static void start_clear_flags(struct smi_info *smi_info)
smi_info->si_state = SI_CLEARING_FLAGS; smi_info->si_state = SI_CLEARING_FLAGS;
} }
/* When we have a situtaion where we run out of memory and cannot /*
allocate messages, we just leave them in the BMC and run the system * When we have a situtaion where we run out of memory and cannot
polled until we can allocate some memory. Once we have some * allocate messages, we just leave them in the BMC and run the system
memory, we will re-enable the interrupt. */ * polled until we can allocate some memory. Once we have some
* memory, we will re-enable the interrupt.
*/
static inline void disable_si_irq(struct smi_info *smi_info) static inline void disable_si_irq(struct smi_info *smi_info)
{ {
if ((smi_info->irq) && (!smi_info->interrupt_disabled)) { if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
@ -489,10 +507,9 @@ static void handle_flags(struct smi_info *smi_info)
smi_info->oem_data_avail_handler) { smi_info->oem_data_avail_handler) {
if (smi_info->oem_data_avail_handler(smi_info)) if (smi_info->oem_data_avail_handler(smi_info))
goto retry; goto retry;
} else { } else
smi_info->si_state = SI_NORMAL; smi_info->si_state = SI_NORMAL;
} }
}
static void handle_transaction_done(struct smi_info *smi_info) static void handle_transaction_done(struct smi_info *smi_info)
{ {
@ -501,7 +518,7 @@ static void handle_transaction_done(struct smi_info *smi_info)
struct timeval t; struct timeval t;
do_gettimeofday(&t); do_gettimeofday(&t);
printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec); printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif #endif
switch (smi_info->si_state) { switch (smi_info->si_state) {
case SI_NORMAL: case SI_NORMAL:
@ -514,9 +531,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
smi_info->curr_msg->rsp, smi_info->curr_msg->rsp,
IPMI_MAX_MSG_LENGTH); IPMI_MAX_MSG_LENGTH);
/* Do this here becase deliver_recv_msg() releases the /*
lock, and a new message can be put in during the * Do this here becase deliver_recv_msg() releases the
time the lock is released. */ * lock, and a new message can be put in during the
* time the lock is released.
*/
msg = smi_info->curr_msg; msg = smi_info->curr_msg;
smi_info->curr_msg = NULL; smi_info->curr_msg = NULL;
deliver_recv_msg(smi_info, msg); deliver_recv_msg(smi_info, msg);
@ -530,12 +549,13 @@ static void handle_transaction_done(struct smi_info *smi_info)
/* We got the flags from the SMI, now handle them. */ /* We got the flags from the SMI, now handle them. */
len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4); len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
if (msg[2] != 0) { if (msg[2] != 0) {
/* Error fetching flags, just give up for /* Error fetching flags, just give up for now. */
now. */
smi_info->si_state = SI_NORMAL; smi_info->si_state = SI_NORMAL;
} else if (len < 4) { } else if (len < 4) {
/* Hmm, no flags. That's technically illegal, but /*
don't use uninitialized data. */ * Hmm, no flags. That's technically illegal, but
* don't use uninitialized data.
*/
smi_info->si_state = SI_NORMAL; smi_info->si_state = SI_NORMAL;
} else { } else {
smi_info->msg_flags = msg[3]; smi_info->msg_flags = msg[3];
@ -572,9 +592,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
smi_info->curr_msg->rsp, smi_info->curr_msg->rsp,
IPMI_MAX_MSG_LENGTH); IPMI_MAX_MSG_LENGTH);
/* Do this here becase deliver_recv_msg() releases the /*
lock, and a new message can be put in during the * Do this here becase deliver_recv_msg() releases the
time the lock is released. */ * lock, and a new message can be put in during the
* time the lock is released.
*/
msg = smi_info->curr_msg; msg = smi_info->curr_msg;
smi_info->curr_msg = NULL; smi_info->curr_msg = NULL;
if (msg->rsp[2] != 0) { if (msg->rsp[2] != 0) {
@ -587,10 +609,12 @@ static void handle_transaction_done(struct smi_info *smi_info)
} else { } else {
smi_inc_stat(smi_info, events); smi_inc_stat(smi_info, events);
/* Do this before we deliver the message /*
because delivering the message releases the * Do this before we deliver the message
lock and something else can mess with the * because delivering the message releases the
state. */ * lock and something else can mess with the
* state.
*/
handle_flags(smi_info); handle_flags(smi_info);
deliver_recv_msg(smi_info, msg); deliver_recv_msg(smi_info, msg);
@ -606,9 +630,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
smi_info->curr_msg->rsp, smi_info->curr_msg->rsp,
IPMI_MAX_MSG_LENGTH); IPMI_MAX_MSG_LENGTH);
/* Do this here becase deliver_recv_msg() releases the /*
lock, and a new message can be put in during the * Do this here becase deliver_recv_msg() releases the
time the lock is released. */ * lock, and a new message can be put in during the
* time the lock is released.
*/
msg = smi_info->curr_msg; msg = smi_info->curr_msg;
smi_info->curr_msg = NULL; smi_info->curr_msg = NULL;
if (msg->rsp[2] != 0) { if (msg->rsp[2] != 0) {
@ -621,10 +647,12 @@ static void handle_transaction_done(struct smi_info *smi_info)
} else { } else {
smi_inc_stat(smi_info, incoming_messages); smi_inc_stat(smi_info, incoming_messages);
/* Do this before we deliver the message /*
because delivering the message releases the * Do this before we deliver the message
lock and something else can mess with the * because delivering the message releases the
state. */ * lock and something else can mess with the
* state.
*/
handle_flags(smi_info); handle_flags(smi_info);
deliver_recv_msg(smi_info, msg); deliver_recv_msg(smi_info, msg);
@ -712,46 +740,49 @@ static void handle_transaction_done(struct smi_info *smi_info)
} }
} }
/* Called on timeouts and events. Timeouts should pass the elapsed /*
time, interrupts should pass in zero. Must be called with * Called on timeouts and events. Timeouts should pass the elapsed
si_lock held and interrupts disabled. */ * time, interrupts should pass in zero. Must be called with
* si_lock held and interrupts disabled.
*/
static enum si_sm_result smi_event_handler(struct smi_info *smi_info, static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
int time) int time)
{ {
enum si_sm_result si_sm_result; enum si_sm_result si_sm_result;
restart: restart:
/* There used to be a loop here that waited a little while /*
(around 25us) before giving up. That turned out to be * There used to be a loop here that waited a little while
pointless, the minimum delays I was seeing were in the 300us * (around 25us) before giving up. That turned out to be
range, which is far too long to wait in an interrupt. So * pointless, the minimum delays I was seeing were in the 300us
we just run until the state machine tells us something * range, which is far too long to wait in an interrupt. So
happened or it needs a delay. */ * we just run until the state machine tells us something
* happened or it needs a delay.
*/
si_sm_result = smi_info->handlers->event(smi_info->si_sm, time); si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
time = 0; time = 0;
while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY) while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
{
si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0); si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
}
if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
{
smi_inc_stat(smi_info, complete_transactions); smi_inc_stat(smi_info, complete_transactions);
handle_transaction_done(smi_info); handle_transaction_done(smi_info);
si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0); si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
} } else if (si_sm_result == SI_SM_HOSED) {
else if (si_sm_result == SI_SM_HOSED)
{
smi_inc_stat(smi_info, hosed_count); smi_inc_stat(smi_info, hosed_count);
/* Do the before return_hosed_msg, because that /*
releases the lock. */ * Do the before return_hosed_msg, because that
* releases the lock.
*/
smi_info->si_state = SI_NORMAL; smi_info->si_state = SI_NORMAL;
if (smi_info->curr_msg != NULL) { if (smi_info->curr_msg != NULL) {
/* If we were handling a user message, format /*
a response to send to the upper layer to * If we were handling a user message, format
tell it about the error. */ * a response to send to the upper layer to
* tell it about the error.
*/
return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED); return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
} }
si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0); si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
@ -761,17 +792,18 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
* We prefer handling attn over new messages. But don't do * We prefer handling attn over new messages. But don't do
* this if there is not yet an upper layer to handle anything. * this if there is not yet an upper layer to handle anything.
*/ */
if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN) if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN) {
{
unsigned char msg[2]; unsigned char msg[2];
smi_inc_stat(smi_info, attentions); smi_inc_stat(smi_info, attentions);
/* Got a attn, send down a get message flags to see /*
what's causing it. It would be better to handle * Got a attn, send down a get message flags to see
this in the upper layer, but due to the way * what's causing it. It would be better to handle
interrupts work with the SMI, that's not really * this in the upper layer, but due to the way
possible. */ * interrupts work with the SMI, that's not really
* possible.
*/
msg[0] = (IPMI_NETFN_APP_REQUEST << 2); msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
msg[1] = IPMI_GET_MSG_FLAGS_CMD; msg[1] = IPMI_GET_MSG_FLAGS_CMD;
@ -791,10 +823,11 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
} }
if ((si_sm_result == SI_SM_IDLE) if ((si_sm_result == SI_SM_IDLE)
&& (atomic_read(&smi_info->req_events))) && (atomic_read(&smi_info->req_events))) {
{ /*
/* We are idle and the upper layer requested that I fetch * We are idle and the upper layer requested that I fetch
events, so do so. */ * events, so do so.
*/
atomic_set(&smi_info->req_events, 0); atomic_set(&smi_info->req_events, 0);
smi_info->curr_msg = ipmi_alloc_smi_msg(); smi_info->curr_msg = ipmi_alloc_smi_msg();
@ -871,11 +904,8 @@ static void sender(void *send_info,
spin_unlock_irqrestore(&smi_info->msg_lock, flags); spin_unlock_irqrestore(&smi_info->msg_lock, flags);
spin_lock_irqsave(&smi_info->si_lock, flags); spin_lock_irqsave(&smi_info->si_lock, flags);
if ((smi_info->si_state == SI_NORMAL) if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL)
&& (smi_info->curr_msg == NULL))
{
start_next_msg(smi_info); start_next_msg(smi_info);
}
spin_unlock_irqrestore(&smi_info->si_lock, flags); spin_unlock_irqrestore(&smi_info->si_lock, flags);
} }
@ -906,9 +936,8 @@ static int ipmi_thread(void *data)
spin_lock_irqsave(&(smi_info->si_lock), flags); spin_lock_irqsave(&(smi_info->si_lock), flags);
smi_result = smi_event_handler(smi_info, 0); smi_result = smi_event_handler(smi_info, 0);
spin_unlock_irqrestore(&(smi_info->si_lock), flags); spin_unlock_irqrestore(&(smi_info->si_lock), flags);
if (smi_result == SI_SM_CALL_WITHOUT_DELAY) { if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
/* do nothing */ ; /* do nothing */
}
else if (smi_result == SI_SM_CALL_WITH_DELAY) else if (smi_result == SI_SM_CALL_WITH_DELAY)
schedule(); schedule();
else else
@ -959,7 +988,7 @@ static void smi_timeout(unsigned long data)
spin_lock_irqsave(&(smi_info->si_lock), flags); spin_lock_irqsave(&(smi_info->si_lock), flags);
#ifdef DEBUG_TIMING #ifdef DEBUG_TIMING
do_gettimeofday(&t); do_gettimeofday(&t);
printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec); printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif #endif
jiffies_now = jiffies; jiffies_now = jiffies;
time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies) time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
@ -977,8 +1006,10 @@ static void smi_timeout(unsigned long data)
goto do_add_timer; goto do_add_timer;
} }
/* If the state machine asks for a short delay, then shorten /*
the timer timeout. */ * If the state machine asks for a short delay, then shorten
* the timer timeout.
*/
if (smi_result == SI_SM_CALL_WITH_DELAY) { if (smi_result == SI_SM_CALL_WITH_DELAY) {
smi_inc_stat(smi_info, short_timeouts); smi_inc_stat(smi_info, short_timeouts);
smi_info->si_timer.expires = jiffies + 1; smi_info->si_timer.expires = jiffies + 1;
@ -1005,7 +1036,7 @@ static irqreturn_t si_irq_handler(int irq, void *data)
#ifdef DEBUG_TIMING #ifdef DEBUG_TIMING
do_gettimeofday(&t); do_gettimeofday(&t);
printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec); printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
#endif #endif
smi_event_handler(smi_info, 0); smi_event_handler(smi_info, 0);
spin_unlock_irqrestore(&(smi_info->si_lock), flags); spin_unlock_irqrestore(&(smi_info->si_lock), flags);
@ -1074,8 +1105,7 @@ static void set_maintenance_mode(void *send_info, int enable)
atomic_set(&smi_info->req_events, 0); atomic_set(&smi_info->req_events, 0);
} }
static struct ipmi_smi_handlers handlers = static struct ipmi_smi_handlers handlers = {
{
.owner = THIS_MODULE, .owner = THIS_MODULE,
.start_processing = smi_start_processing, .start_processing = smi_start_processing,
.sender = sender, .sender = sender,
@ -1085,8 +1115,10 @@ static struct ipmi_smi_handlers handlers =
.poll = poll, .poll = poll,
}; };
/* There can be 4 IO ports passed in (with or without IRQs), 4 addresses, /*
a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS */ * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
* a default IO port, and 1 ACPI/SPMI address. That sets SI_MAX_DRIVERS.
*/
static LIST_HEAD(smi_infos); static LIST_HEAD(smi_infos);
static DEFINE_MUTEX(smi_infos_lock); static DEFINE_MUTEX(smi_infos_lock);
@ -1277,12 +1309,11 @@ static void port_cleanup(struct smi_info *info)
int idx; int idx;
if (addr) { if (addr) {
for (idx = 0; idx < info->io_size; idx++) { for (idx = 0; idx < info->io_size; idx++)
release_region(addr + idx * info->io.regspacing, release_region(addr + idx * info->io.regspacing,
info->io.regsize); info->io.regsize);
} }
} }
}
static int port_setup(struct smi_info *info) static int port_setup(struct smi_info *info)
{ {
@ -1294,8 +1325,10 @@ static int port_setup(struct smi_info *info)
info->io_cleanup = port_cleanup; info->io_cleanup = port_cleanup;
/* Figure out the actual inb/inw/inl/etc routine to use based /*
upon the register size. */ * Figure out the actual inb/inw/inl/etc routine to use based
* upon the register size.
*/
switch (info->io.regsize) { switch (info->io.regsize) {
case 1: case 1:
info->io.inputb = port_inb; info->io.inputb = port_inb;
@ -1310,12 +1343,13 @@ static int port_setup(struct smi_info *info)
info->io.outputb = port_outl; info->io.outputb = port_outl;
break; break;
default: default:
printk("ipmi_si: Invalid register size: %d\n", printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
info->io.regsize); info->io.regsize);
return -EINVAL; return -EINVAL;
} }
/* Some BIOSes reserve disjoint I/O regions in their ACPI /*
* Some BIOSes reserve disjoint I/O regions in their ACPI
* tables. This causes problems when trying to register the * tables. This causes problems when trying to register the
* entire I/O region. Therefore we must register each I/O * entire I/O region. Therefore we must register each I/O
* port separately. * port separately.
@ -1408,8 +1442,10 @@ static int mem_setup(struct smi_info *info)
info->io_cleanup = mem_cleanup; info->io_cleanup = mem_cleanup;
/* Figure out the actual readb/readw/readl/etc routine to use based /*
upon the register size. */ * Figure out the actual readb/readw/readl/etc routine to use based
* upon the register size.
*/
switch (info->io.regsize) { switch (info->io.regsize) {
case 1: case 1:
info->io.inputb = intf_mem_inb; info->io.inputb = intf_mem_inb;
@ -1430,16 +1466,18 @@ static int mem_setup(struct smi_info *info)
break; break;
#endif #endif
default: default:
printk("ipmi_si: Invalid register size: %d\n", printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
info->io.regsize); info->io.regsize);
return -EINVAL; return -EINVAL;
} }
/* Calculate the total amount of memory to claim. This is an /*
* Calculate the total amount of memory to claim. This is an
* unusual looking calculation, but it avoids claiming any * unusual looking calculation, but it avoids claiming any
* more memory than it has to. It will claim everything * more memory than it has to. It will claim everything
* between the first address to the end of the last full * between the first address to the end of the last full
* register. */ * register.
*/
mapsize = ((info->io_size * info->io.regspacing) mapsize = ((info->io_size * info->io.regspacing)
- (info->io.regspacing - info->io.regsize)); - (info->io.regspacing - info->io.regsize));
@ -1769,9 +1807,11 @@ static __devinit void hardcode_find_bmc(void)
#include <linux/acpi.h> #include <linux/acpi.h>
/* Once we get an ACPI failure, we don't try any more, because we go /*
through the tables sequentially. Once we don't find a table, there * Once we get an ACPI failure, we don't try any more, because we go
are no more. */ * through the tables sequentially. Once we don't find a table, there
* are no more.
*/
static int acpi_failure; static int acpi_failure;
/* For GPE-type interrupts. */ /* For GPE-type interrupts. */
@ -1834,7 +1874,8 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
/* /*
* Defined at * Defined at
* http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/
* Docs/TechPapers/IA64/hpspmi.pdf
*/ */
struct SPMITable { struct SPMITable {
s8 Signature[4]; s8 Signature[4];
@ -1856,14 +1897,18 @@ struct SPMITable {
*/ */
u8 InterruptType; u8 InterruptType;
/* If bit 0 of InterruptType is set, then this is the SCI /*
interrupt in the GPEx_STS register. */ * If bit 0 of InterruptType is set, then this is the SCI
* interrupt in the GPEx_STS register.
*/
u8 GPE; u8 GPE;
s16 Reserved; s16 Reserved;
/* If bit 1 of InterruptType is set, then this is the I/O /*
APIC/SAPIC interrupt. */ * If bit 1 of InterruptType is set, then this is the I/O
* APIC/SAPIC interrupt.
*/
u32 GlobalSystemInterrupt; u32 GlobalSystemInterrupt;
/* The actual register address. */ /* The actual register address. */
@ -1898,8 +1943,7 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
info->addr_source = "ACPI"; info->addr_source = "ACPI";
/* Figure out the interface type. */ /* Figure out the interface type. */
switch (spmi->InterfaceType) switch (spmi->InterfaceType) {
{
case 1: /* KCS */ case 1: /* KCS */
info->si_type = SI_KCS; info->si_type = SI_KCS;
break; break;
@ -1947,7 +1991,8 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
info->io.addr_type = IPMI_IO_ADDR_SPACE; info->io.addr_type = IPMI_IO_ADDR_SPACE;
} else { } else {
kfree(info); kfree(info);
printk("ipmi_si: Unknown ACPI I/O Address type\n"); printk(KERN_WARNING
"ipmi_si: Unknown ACPI I/O Address type\n");
return -EIO; return -EIO;
} }
info->io.addr_data = spmi->addr.address; info->io.addr_data = spmi->addr.address;
@ -1981,8 +2026,7 @@ static __devinit void acpi_find_bmc(void)
#endif #endif
#ifdef CONFIG_DMI #ifdef CONFIG_DMI
struct dmi_ipmi_data struct dmi_ipmi_data {
{
u8 type; u8 type;
u8 addr_space; u8 addr_space;
unsigned long base_addr; unsigned long base_addr;
@ -2007,11 +2051,10 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
/* I/O */ /* I/O */
base_addr &= 0xFFFE; base_addr &= 0xFFFE;
dmi->addr_space = IPMI_IO_ADDR_SPACE; dmi->addr_space = IPMI_IO_ADDR_SPACE;
} } else
else {
/* Memory */ /* Memory */
dmi->addr_space = IPMI_MEM_ADDR_SPACE; dmi->addr_space = IPMI_MEM_ADDR_SPACE;
}
/* If bit 4 of byte 0x10 is set, then the lsb for the address /* If bit 4 of byte 0x10 is set, then the lsb for the address
is odd. */ is odd. */
dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4); dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
@ -2036,12 +2079,14 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
} }
} else { } else {
/* Old DMI spec. */ /* Old DMI spec. */
/* Note that technically, the lower bit of the base /*
* Note that technically, the lower bit of the base
* address should be 1 if the address is I/O and 0 if * address should be 1 if the address is I/O and 0 if
* the address is in memory. So many systems get that * the address is in memory. So many systems get that
* wrong (and all that I have seen are I/O) so we just * wrong (and all that I have seen are I/O) so we just
* ignore that bit and assume I/O. Systems that use * ignore that bit and assume I/O. Systems that use
* memory should use the newer spec, anyway. */ * memory should use the newer spec, anyway.
*/
dmi->base_addr = base_addr & 0xfffe; dmi->base_addr = base_addr & 0xfffe;
dmi->addr_space = IPMI_IO_ADDR_SPACE; dmi->addr_space = IPMI_IO_ADDR_SPACE;
dmi->offset = 1; dmi->offset = 1;
@ -2337,14 +2382,16 @@ static int __devexit ipmi_of_remove(struct of_device *dev)
static struct of_device_id ipmi_match[] = static struct of_device_id ipmi_match[] =
{ {
{ .type = "ipmi", .compatible = "ipmi-kcs", .data = (void *)(unsigned long) SI_KCS }, { .type = "ipmi", .compatible = "ipmi-kcs",
{ .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC }, .data = (void *)(unsigned long) SI_KCS },
{ .type = "ipmi", .compatible = "ipmi-bt", .data = (void *)(unsigned long) SI_BT }, { .type = "ipmi", .compatible = "ipmi-smic",
.data = (void *)(unsigned long) SI_SMIC },
{ .type = "ipmi", .compatible = "ipmi-bt",
.data = (void *)(unsigned long) SI_BT },
{}, {},
}; };
static struct of_platform_driver ipmi_of_platform_driver = static struct of_platform_driver ipmi_of_platform_driver = {
{
.name = "ipmi", .name = "ipmi",
.match_table = ipmi_match, .match_table = ipmi_match,
.probe = ipmi_of_probe, .probe = ipmi_of_probe,
@ -2365,32 +2412,32 @@ static int try_get_dev_id(struct smi_info *smi_info)
if (!resp) if (!resp)
return -ENOMEM; return -ENOMEM;
/* Do a Get Device ID command, since it comes back with some /*
useful info. */ * Do a Get Device ID command, since it comes back with some
* useful info.
*/
msg[0] = IPMI_NETFN_APP_REQUEST << 2; msg[0] = IPMI_NETFN_APP_REQUEST << 2;
msg[1] = IPMI_GET_DEVICE_ID_CMD; msg[1] = IPMI_GET_DEVICE_ID_CMD;
smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2); smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
smi_result = smi_info->handlers->event(smi_info->si_sm, 0); smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
for (;;) for (;;) {
{
if (smi_result == SI_SM_CALL_WITH_DELAY || if (smi_result == SI_SM_CALL_WITH_DELAY ||
smi_result == SI_SM_CALL_WITH_TICK_DELAY) { smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
schedule_timeout_uninterruptible(1); schedule_timeout_uninterruptible(1);
smi_result = smi_info->handlers->event( smi_result = smi_info->handlers->event(
smi_info->si_sm, 100); smi_info->si_sm, 100);
} } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
{
smi_result = smi_info->handlers->event( smi_result = smi_info->handlers->event(
smi_info->si_sm, 0); smi_info->si_sm, 0);
} } else
else
break; break;
} }
if (smi_result == SI_SM_HOSED) { if (smi_result == SI_SM_HOSED) {
/* We couldn't get the state machine to run, so whatever's at /*
the port is probably not an IPMI SMI interface. */ * We couldn't get the state machine to run, so whatever's at
* the port is probably not an IPMI SMI interface.
*/
rv = -ENODEV; rv = -ENODEV;
goto out; goto out;
} }
@ -2518,8 +2565,7 @@ static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) { id->ipmi_version == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
smi_info->oem_data_avail_handler = smi_info->oem_data_avail_handler =
oem_data_avail_to_receive_msg_avail; oem_data_avail_to_receive_msg_avail;
} } else if (ipmi_version_major(id) < 1 ||
else if (ipmi_version_major(id) < 1 ||
(ipmi_version_major(id) == 1 && (ipmi_version_major(id) == 1 &&
ipmi_version_minor(id) < 5)) { ipmi_version_minor(id) < 5)) {
smi_info->oem_data_avail_handler = smi_info->oem_data_avail_handler =
@ -2613,8 +2659,10 @@ static void setup_xaction_handlers(struct smi_info *smi_info)
static inline void wait_for_timer_and_thread(struct smi_info *smi_info) static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
{ {
if (smi_info->intf) { if (smi_info->intf) {
/* The timer and thread are only running if the /*
interface has been started up and registered. */ * The timer and thread are only running if the
* interface has been started up and registered.
*/
if (smi_info->thread != NULL) if (smi_info->thread != NULL)
kthread_stop(smi_info->thread); kthread_stop(smi_info->thread);
del_timer_sync(&smi_info->si_timer); del_timer_sync(&smi_info->si_timer);
@ -2739,7 +2787,7 @@ static int try_smi_init(struct smi_info *new_smi)
/* Allocate the state machine's data and initialize it. */ /* Allocate the state machine's data and initialize it. */
new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL); new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
if (!new_smi->si_sm) { if (!new_smi->si_sm) {
printk(" Could not allocate state machine memory\n"); printk(KERN_ERR "Could not allocate state machine memory\n");
rv = -ENOMEM; rv = -ENOMEM;
goto out_err; goto out_err;
} }
@ -2749,7 +2797,7 @@ static int try_smi_init(struct smi_info *new_smi)
/* Now that we know the I/O size, we can set up the I/O. */ /* Now that we know the I/O size, we can set up the I/O. */
rv = new_smi->io_setup(new_smi); rv = new_smi->io_setup(new_smi);
if (rv) { if (rv) {
printk(" Could not set up I/O space\n"); printk(KERN_ERR "Could not set up I/O space\n");
goto out_err; goto out_err;
} }
@ -2765,8 +2813,10 @@ static int try_smi_init(struct smi_info *new_smi)
goto out_err; goto out_err;
} }
/* Attempt a get device id command. If it fails, we probably /*
don't have a BMC here. */ * Attempt a get device id command. If it fails, we probably
* don't have a BMC here.
*/
rv = try_get_dev_id(new_smi); rv = try_get_dev_id(new_smi);
if (rv) { if (rv) {
if (new_smi->addr_source) if (new_smi->addr_source)
@ -2791,16 +2841,20 @@ static int try_smi_init(struct smi_info *new_smi)
new_smi->intf_num = smi_num; new_smi->intf_num = smi_num;
smi_num++; smi_num++;
/* Start clearing the flags before we enable interrupts or the /*
timer to avoid racing with the timer. */ * Start clearing the flags before we enable interrupts or the
* timer to avoid racing with the timer.
*/
start_clear_flags(new_smi); start_clear_flags(new_smi);
/* IRQ is defined to be set when non-zero. */ /* IRQ is defined to be set when non-zero. */
if (new_smi->irq) if (new_smi->irq)
new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ; new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
if (!new_smi->dev) { if (!new_smi->dev) {
/* If we don't already have a device from something /*
* else (like PCI), then register a new one. */ * If we don't already have a device from something
* else (like PCI), then register a new one.
*/
new_smi->pdev = platform_device_alloc("ipmi_si", new_smi->pdev = platform_device_alloc("ipmi_si",
new_smi->intf_num); new_smi->intf_num);
if (rv) { if (rv) {
@ -2871,7 +2925,8 @@ static int try_smi_init(struct smi_info *new_smi)
mutex_unlock(&smi_infos_lock); mutex_unlock(&smi_infos_lock);
printk(KERN_INFO "IPMI %s interface initialized\n",si_to_str[new_smi->si_type]); printk(KERN_INFO "IPMI %s interface initialized\n",
si_to_str[new_smi->si_type]);
return 0; return 0;
@ -2886,9 +2941,11 @@ static int try_smi_init(struct smi_info *new_smi)
if (new_smi->irq_cleanup) if (new_smi->irq_cleanup)
new_smi->irq_cleanup(new_smi); new_smi->irq_cleanup(new_smi);
/* Wait until we know that we are out of any interrupt /*
handlers might have been running before we freed the * Wait until we know that we are out of any interrupt
interrupt. */ * handlers might have been running before we freed the
* interrupt.
*/
synchronize_sched(); synchronize_sched();
if (new_smi->si_sm) { if (new_smi->si_sm) {
@ -2960,11 +3017,10 @@ static __devinit int init_ipmi_si(void)
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
rv = pci_register_driver(&ipmi_pci_driver); rv = pci_register_driver(&ipmi_pci_driver);
if (rv){ if (rv)
printk(KERN_ERR printk(KERN_ERR
"init_ipmi_si: Unable to register PCI driver: %d\n", "init_ipmi_si: Unable to register PCI driver: %d\n",
rv); rv);
}
#endif #endif
#ifdef CONFIG_PPC_OF #ifdef CONFIG_PPC_OF
@ -2993,7 +3049,8 @@ static __devinit int init_ipmi_si(void)
of_unregister_platform_driver(&ipmi_of_platform_driver); of_unregister_platform_driver(&ipmi_of_platform_driver);
#endif #endif
driver_unregister(&ipmi_driver); driver_unregister(&ipmi_driver);
printk("ipmi_si: Unable to find any System Interface(s)\n"); printk(KERN_WARNING
"ipmi_si: Unable to find any System Interface(s)\n");
return -ENODEV; return -ENODEV;
} else { } else {
mutex_unlock(&smi_infos_lock); mutex_unlock(&smi_infos_lock);
@ -3015,13 +3072,17 @@ static void cleanup_one_si(struct smi_info *to_clean)
/* Tell the driver that we are shutting down. */ /* Tell the driver that we are shutting down. */
atomic_inc(&to_clean->stop_operation); atomic_inc(&to_clean->stop_operation);
/* Make sure the timer and thread are stopped and will not run /*
again. */ * Make sure the timer and thread are stopped and will not run
* again.
*/
wait_for_timer_and_thread(to_clean); wait_for_timer_and_thread(to_clean);
/* Timeouts are stopped, now make sure the interrupts are off /*
for the device. A little tricky with locks to make sure * Timeouts are stopped, now make sure the interrupts are off
there are no races. */ * for the device. A little tricky with locks to make sure
* there are no races.
*/
spin_lock_irqsave(&to_clean->si_lock, flags); spin_lock_irqsave(&to_clean->si_lock, flags);
while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) { while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
spin_unlock_irqrestore(&to_clean->si_lock, flags); spin_unlock_irqrestore(&to_clean->si_lock, flags);
@ -3092,4 +3153,5 @@ module_exit(cleanup_ipmi_si);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces."); MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
" system interfaces.");

89
drivers/char/ipmi/ipmi_si_sm.h
View File

@ -34,22 +34,27 @@
* 675 Mass Ave, Cambridge, MA 02139, USA. * 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* This is defined by the state machines themselves, it is an opaque /*
data type for them to use. */ * This is defined by the state machines themselves, it is an opaque
* data type for them to use.
*/
struct si_sm_data; struct si_sm_data;
/* The structure for doing I/O in the state machine. The state /*
machine doesn't have the actual I/O routines, they are done through * The structure for doing I/O in the state machine. The state
this interface. */ * machine doesn't have the actual I/O routines, they are done through
struct si_sm_io * this interface.
{ */
struct si_sm_io {
unsigned char (*inputb)(struct si_sm_io *io, unsigned int offset); unsigned char (*inputb)(struct si_sm_io *io, unsigned int offset);
void (*outputb)(struct si_sm_io *io, void (*outputb)(struct si_sm_io *io,
unsigned int offset, unsigned int offset,
unsigned char b); unsigned char b);
/* Generic info used by the actual handling routines, the /*
state machine shouldn't touch these. */ * Generic info used by the actual handling routines, the
* state machine shouldn't touch these.
*/
void __iomem *addr; void __iomem *addr;
int regspacing; int regspacing;
int regsize; int regsize;
@ -59,53 +64,67 @@ struct si_sm_io
}; };
/* Results of SMI events. */ /* Results of SMI events. */
enum si_sm_result enum si_sm_result {
{
SI_SM_CALL_WITHOUT_DELAY, /* Call the driver again immediately */ SI_SM_CALL_WITHOUT_DELAY, /* Call the driver again immediately */
SI_SM_CALL_WITH_DELAY, /* Delay some before calling again. */ SI_SM_CALL_WITH_DELAY, /* Delay some before calling again. */
SI_SM_CALL_WITH_TICK_DELAY, /* Delay at least 1 tick before calling again. */ SI_SM_CALL_WITH_TICK_DELAY,/* Delay >=1 tick before calling again. */
SI_SM_TRANSACTION_COMPLETE, /* A transaction is finished. */ SI_SM_TRANSACTION_COMPLETE, /* A transaction is finished. */
SI_SM_IDLE, /* The SM is in idle state. */ SI_SM_IDLE, /* The SM is in idle state. */
SI_SM_HOSED, /* The hardware violated the state machine. */ SI_SM_HOSED, /* The hardware violated the state machine. */
SI_SM_ATTN /* The hardware is asserting attn and the
state machine is idle. */ /*
* The hardware is asserting attn and the state machine is
* idle.
*/
SI_SM_ATTN
}; };
/* Handlers for the SMI state machine. */ /* Handlers for the SMI state machine. */
struct si_sm_handlers struct si_sm_handlers {
{ /*
/* Put the version number of the state machine here so the * Put the version number of the state machine here so the
upper layer can print it. */ * upper layer can print it.
*/
char *version; char *version;
/* Initialize the data and return the amount of I/O space to /*
reserve for the space. */ * Initialize the data and return the amount of I/O space to
* reserve for the space.
*/
unsigned int (*init_data)(struct si_sm_data *smi, unsigned int (*init_data)(struct si_sm_data *smi,
struct si_sm_io *io); struct si_sm_io *io);
/* Start a new transaction in the state machine. This will /*
return -2 if the state machine is not idle, -1 if the size * Start a new transaction in the state machine. This will
is invalid (to large or too small), or 0 if the transaction * return -2 if the state machine is not idle, -1 if the size
is successfully completed. */ * is invalid (to large or too small), or 0 if the transaction
* is successfully completed.
*/
int (*start_transaction)(struct si_sm_data *smi, int (*start_transaction)(struct si_sm_data *smi,
unsigned char *data, unsigned int size); unsigned char *data, unsigned int size);
/* Return the results after the transaction. This will return /*
-1 if the buffer is too small, zero if no transaction is * Return the results after the transaction. This will return
present, or the actual length of the result data. */ * -1 if the buffer is too small, zero if no transaction is
* present, or the actual length of the result data.
*/
int (*get_result)(struct si_sm_data *smi, int (*get_result)(struct si_sm_data *smi,
unsigned char *data, unsigned int length); unsigned char *data, unsigned int length);
/* Call this periodically (for a polled interface) or upon /*
receiving an interrupt (for a interrupt-driven interface). * Call this periodically (for a polled interface) or upon
If interrupt driven, you should probably poll this * receiving an interrupt (for a interrupt-driven interface).
periodically when not in idle state. This should be called * If interrupt driven, you should probably poll this
with the time that passed since the last call, if it is * periodically when not in idle state. This should be called
significant. Time is in microseconds. */ * with the time that passed since the last call, if it is
* significant. Time is in microseconds.
*/
enum si_sm_result (*event)(struct si_sm_data *smi, long time); enum si_sm_result (*event)(struct si_sm_data *smi, long time);
/* Attempt to detect an SMI. Returns 0 on success or nonzero /*
on failure. */ * Attempt to detect an SMI. Returns 0 on success or nonzero
* on failure.
*/
int (*detect)(struct si_sm_data *smi); int (*detect)(struct si_sm_data *smi);
/* The interface is shutting down, so clean it up. */ /* The interface is shutting down, so clean it up. */

103
drivers/char/ipmi/ipmi_smic_sm.c
View File

@ -85,6 +85,7 @@ enum smic_states {
/* SMIC Flags Register Bits */ /* SMIC Flags Register Bits */
#define SMIC_RX_DATA_READY 0x80 #define SMIC_RX_DATA_READY 0x80
#define SMIC_TX_DATA_READY 0x40 #define SMIC_TX_DATA_READY 0x40
/* /*
* SMIC_SMI and SMIC_EVM_DATA_AVAIL are only used by * SMIC_SMI and SMIC_EVM_DATA_AVAIL are only used by
* a few systems, and then only by Systems Management * a few systems, and then only by Systems Management
@ -104,8 +105,7 @@ enum smic_states {
#define EC_ILLEGAL_COMMAND 0x04 #define EC_ILLEGAL_COMMAND 0x04
#define EC_BUFFER_FULL 0x05 #define EC_BUFFER_FULL 0x05
struct si_sm_data struct si_sm_data {
{
enum smic_states state; enum smic_states state;
struct si_sm_io *io; struct si_sm_io *io;
unsigned char write_data[MAX_SMIC_WRITE_SIZE]; unsigned char write_data[MAX_SMIC_WRITE_SIZE];
@ -150,10 +150,9 @@ static int start_smic_transaction(struct si_sm_data *smic,
return IPMI_NOT_IN_MY_STATE_ERR; return IPMI_NOT_IN_MY_STATE_ERR;
if (smic_debug & SMIC_DEBUG_MSG) { if (smic_debug & SMIC_DEBUG_MSG) {
printk(KERN_INFO "start_smic_transaction -"); printk(KERN_DEBUG "start_smic_transaction -");
for (i = 0; i < size; i ++) { for (i = 0; i < size; i++)
printk (" %02x", (unsigned char) (data [i])); printk(" %02x", (unsigned char) data[i]);
}
printk("\n"); printk("\n");
} }
smic->error_retries = 0; smic->error_retries = 0;
@ -173,10 +172,9 @@ static int smic_get_result(struct si_sm_data *smic,
int i; int i;
if (smic_debug & SMIC_DEBUG_MSG) { if (smic_debug & SMIC_DEBUG_MSG) {
printk (KERN_INFO "smic_get result -"); printk(KERN_DEBUG "smic_get result -");
for (i = 0; i < smic->read_pos; i ++) { for (i = 0; i < smic->read_pos; i++)
printk (" %02x", (smic->read_data [i])); printk(" %02x", smic->read_data[i]);
}
printk("\n"); printk("\n");
} }
if (length < smic->read_pos) { if (length < smic->read_pos) {
@ -233,10 +231,9 @@ static inline void start_error_recovery(struct si_sm_data *smic, char *reason)
{ {
(smic->error_retries)++; (smic->error_retries)++;
if (smic->error_retries > SMIC_MAX_ERROR_RETRIES) { if (smic->error_retries > SMIC_MAX_ERROR_RETRIES) {
if (smic_debug & SMIC_DEBUG_ENABLE) { if (smic_debug & SMIC_DEBUG_ENABLE)
printk(KERN_WARNING printk(KERN_WARNING
"ipmi_smic_drv: smic hosed: %s\n", reason); "ipmi_smic_drv: smic hosed: %s\n", reason);
}
smic->state = SMIC_HOSED; smic->state = SMIC_HOSED;
} else { } else {
smic->write_count = smic->orig_write_count; smic->write_count = smic->orig_write_count;
@ -261,7 +258,7 @@ static inline void read_next_byte (struct si_sm_data *smic)
smic->truncated = 1; smic->truncated = 1;
} else { } else {
smic->read_data[smic->read_pos] = read_smic_data(smic); smic->read_data[smic->read_pos] = read_smic_data(smic);
(smic->read_pos)++; smic->read_pos++;
} }
} }
@ -347,13 +344,15 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
return SI_SM_HOSED; return SI_SM_HOSED;
} }
if (smic->state != SMIC_IDLE) { if (smic->state != SMIC_IDLE) {
if (smic_debug & SMIC_DEBUG_STATES) { if (smic_debug & SMIC_DEBUG_STATES)
printk(KERN_INFO printk(KERN_DEBUG
"smic_event - smic->smic_timeout = %ld," "smic_event - smic->smic_timeout = %ld,"
" time = %ld\n", " time = %ld\n",
smic->smic_timeout, time); smic->smic_timeout, time);
} /*
/* FIXME: smic_event is sometimes called with time > SMIC_RETRY_TIMEOUT */ * FIXME: smic_event is sometimes called with time >
* SMIC_RETRY_TIMEOUT
*/
if (time < SMIC_RETRY_TIMEOUT) { if (time < SMIC_RETRY_TIMEOUT) {
smic->smic_timeout -= time; smic->smic_timeout -= time;
if (smic->smic_timeout < 0) { if (smic->smic_timeout < 0) {
@ -368,7 +367,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
status = read_smic_status(smic); status = read_smic_status(smic);
if (smic_debug & SMIC_DEBUG_STATES) if (smic_debug & SMIC_DEBUG_STATES)
printk(KERN_INFO printk(KERN_DEBUG
"smic_event - state = %d, flags = 0x%02x," "smic_event - state = %d, flags = 0x%02x,"
" status = 0x%02x\n", " status = 0x%02x\n",
smic->state, flags, status); smic->state, flags, status);
@ -377,9 +376,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
case SMIC_IDLE: case SMIC_IDLE:
/* in IDLE we check for available messages */ /* in IDLE we check for available messages */
if (flags & SMIC_SMS_DATA_AVAIL) if (flags & SMIC_SMS_DATA_AVAIL)
{
return SI_SM_ATTN; return SI_SM_ATTN;
}
return SI_SM_IDLE; return SI_SM_IDLE;
case SMIC_START_OP: case SMIC_START_OP:
@ -411,8 +408,10 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
"status != SMIC_SC_SMS_WR_START"); "status != SMIC_SC_SMS_WR_START");
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
} }
/* we must not issue WR_(NEXT|END) unless /*
TX_DATA_READY is set */ * we must not issue WR_(NEXT|END) unless
* TX_DATA_READY is set
* */
if (flags & SMIC_TX_DATA_READY) { if (flags & SMIC_TX_DATA_READY) {
if (smic->write_count == 1) { if (smic->write_count == 1) {
/* last byte */ /* last byte */
@ -424,10 +423,8 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
} }
write_next_byte(smic); write_next_byte(smic);
write_smic_flags(smic, flags | SMIC_FLAG_BSY); write_smic_flags(smic, flags | SMIC_FLAG_BSY);
} } else
else {
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
}
break; break;
case SMIC_WRITE_NEXT: case SMIC_WRITE_NEXT:
@ -442,17 +439,14 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
if (smic->write_count == 1) { if (smic->write_count == 1) {
write_smic_control(smic, SMIC_CC_SMS_WR_END); write_smic_control(smic, SMIC_CC_SMS_WR_END);
smic->state = SMIC_WRITE_END; smic->state = SMIC_WRITE_END;
} } else {
else {
write_smic_control(smic, SMIC_CC_SMS_WR_NEXT); write_smic_control(smic, SMIC_CC_SMS_WR_NEXT);
smic->state = SMIC_WRITE_NEXT; smic->state = SMIC_WRITE_NEXT;
} }
write_next_byte(smic); write_next_byte(smic);
write_smic_flags(smic, flags | SMIC_FLAG_BSY); write_smic_flags(smic, flags | SMIC_FLAG_BSY);
} } else
else {
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
}
break; break;
case SMIC_WRITE_END: case SMIC_WRITE_END:
@ -465,29 +459,28 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
/* data register holds an error code */ /* data register holds an error code */
data = read_smic_data(smic); data = read_smic_data(smic);
if (data != 0) { if (data != 0) {
if (smic_debug & SMIC_DEBUG_ENABLE) { if (smic_debug & SMIC_DEBUG_ENABLE)
printk(KERN_INFO printk(KERN_DEBUG
"SMIC_WRITE_END: data = %02x\n", data); "SMIC_WRITE_END: data = %02x\n", data);
}
start_error_recovery(smic, start_error_recovery(smic,
"state = SMIC_WRITE_END, " "state = SMIC_WRITE_END, "
"data != SUCCESS"); "data != SUCCESS");
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
} else { } else
smic->state = SMIC_WRITE2READ; smic->state = SMIC_WRITE2READ;
}
break; break;
case SMIC_WRITE2READ: case SMIC_WRITE2READ:
/* we must wait for RX_DATA_READY to be set before we /*
can continue */ * we must wait for RX_DATA_READY to be set before we
* can continue
*/
if (flags & SMIC_RX_DATA_READY) { if (flags & SMIC_RX_DATA_READY) {
write_smic_control(smic, SMIC_CC_SMS_RD_START); write_smic_control(smic, SMIC_CC_SMS_RD_START);
write_smic_flags(smic, flags | SMIC_FLAG_BSY); write_smic_flags(smic, flags | SMIC_FLAG_BSY);
smic->state = SMIC_READ_START; smic->state = SMIC_READ_START;
} else { } else
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
}
break; break;
case SMIC_READ_START: case SMIC_READ_START:
@ -502,15 +495,16 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
write_smic_control(smic, SMIC_CC_SMS_RD_NEXT); write_smic_control(smic, SMIC_CC_SMS_RD_NEXT);
write_smic_flags(smic, flags | SMIC_FLAG_BSY); write_smic_flags(smic, flags | SMIC_FLAG_BSY);
smic->state = SMIC_READ_NEXT; smic->state = SMIC_READ_NEXT;
} else { } else
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
}
break; break;
case SMIC_READ_NEXT: case SMIC_READ_NEXT:
switch (status) { switch (status) {
/* smic tells us that this is the last byte to be read /*
--> clean up */ * smic tells us that this is the last byte to be read
* --> clean up
*/
case SMIC_SC_SMS_RD_END: case SMIC_SC_SMS_RD_END:
read_next_byte(smic); read_next_byte(smic);
write_smic_control(smic, SMIC_CC_SMS_RD_END); write_smic_control(smic, SMIC_CC_SMS_RD_END);
@ -523,9 +517,8 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
write_smic_control(smic, SMIC_CC_SMS_RD_NEXT); write_smic_control(smic, SMIC_CC_SMS_RD_NEXT);
write_smic_flags(smic, flags | SMIC_FLAG_BSY); write_smic_flags(smic, flags | SMIC_FLAG_BSY);
smic->state = SMIC_READ_NEXT; smic->state = SMIC_READ_NEXT;
} else { } else
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
}
break; break;
default: default:
start_error_recovery( start_error_recovery(
@ -546,10 +539,9 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
data = read_smic_data(smic); data = read_smic_data(smic);
/* data register holds an error code */ /* data register holds an error code */
if (data != 0) { if (data != 0) {
if (smic_debug & SMIC_DEBUG_ENABLE) { if (smic_debug & SMIC_DEBUG_ENABLE)
printk(KERN_INFO printk(KERN_DEBUG
"SMIC_READ_END: data = %02x\n", data); "SMIC_READ_END: data = %02x\n", data);
}
start_error_recovery(smic, start_error_recovery(smic,
"state = SMIC_READ_END, " "state = SMIC_READ_END, "
"data != SUCCESS"); "data != SUCCESS");
@ -565,7 +557,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
default: default:
if (smic_debug & SMIC_DEBUG_ENABLE) { if (smic_debug & SMIC_DEBUG_ENABLE) {
printk(KERN_WARNING "smic->state = %d\n", smic->state); printk(KERN_DEBUG "smic->state = %d\n", smic->state);
start_error_recovery(smic, "state = UNKNOWN"); start_error_recovery(smic, "state = UNKNOWN");
return SI_SM_CALL_WITH_DELAY; return SI_SM_CALL_WITH_DELAY;
} }
@ -576,10 +568,12 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
static int smic_detect(struct si_sm_data *smic) static int smic_detect(struct si_sm_data *smic)
{ {
/* It's impossible for the SMIC fnags register to be all 1's, /*
(assuming a properly functioning, self-initialized BMC) * It's impossible for the SMIC fnags register to be all 1's,
but that's what you get from reading a bogus address, so we * (assuming a properly functioning, self-initialized BMC)
test that first. */ * but that's what you get from reading a bogus address, so we
* test that first.
*/
if (read_smic_flags(smic) == 0xff) if (read_smic_flags(smic) == 0xff)
return 1; return 1;
@ -595,8 +589,7 @@ static int smic_size(void)
return sizeof(struct si_sm_data); return sizeof(struct si_sm_data);
} }
struct si_sm_handlers smic_smi_handlers = struct si_sm_handlers smic_smi_handlers = {
{
.init_data = init_smic_data, .init_data = init_smic_data,
.start_transaction = start_smic_transaction, .start_transaction = start_smic_transaction,
.get_result = smic_get_result, .get_result = smic_get_result,