mirror of
https://github.com/torvalds/linux.git
synced 2024-11-15 00:21:59 +00:00
42b2aa86c6
The below patch fixes some typos in various parts of the kernel, as well as fixes some comments. Please let me know if I missed anything, and I will try to get it changed and resent. Signed-off-by: Justin P. Mattock <justinmattock@gmail.com> Acked-by: Randy Dunlap <rdunlap@xenotime.net> Signed-off-by: Jiri Kosina <jkosina@suse.cz>
706 lines
20 KiB
C
706 lines
20 KiB
C
/*
|
|
* ipmi_bt_sm.c
|
|
*
|
|
* The state machine for an Open IPMI BT sub-driver under ipmi_si.c, part
|
|
* of the driver architecture at http://sourceforge.net/projects/openipmi
|
|
*
|
|
* Author: Rocky Craig <first.last@hp.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
|
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
#include <linux/kernel.h> /* For printk. */
|
|
#include <linux/string.h>
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/ipmi_msgdefs.h> /* for completion codes */
|
|
#include "ipmi_si_sm.h"
|
|
|
|
#define BT_DEBUG_OFF 0 /* Used in production */
|
|
#define BT_DEBUG_ENABLE 1 /* Generic messages */
|
|
#define BT_DEBUG_MSG 2 /* Prints all request/response buffers */
|
|
#define BT_DEBUG_STATES 4 /* Verbose look at state changes */
|
|
/*
|
|
* BT_DEBUG_OFF must be zero to correspond to the default uninitialized
|
|
* value
|
|
*/
|
|
|
|
static int bt_debug; /* 0 == BT_DEBUG_OFF */
|
|
|
|
module_param(bt_debug, int, 0644);
|
|
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
|
|
* buffer (with a documented message of 160 bytes) so go for the max.
|
|
* 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_RETRY_LIMIT 2
|
|
#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.
|
|
*/
|
|
|
|
enum bt_states {
|
|
BT_STATE_IDLE = 0, /* Order is critical in this list */
|
|
BT_STATE_XACTION_START,
|
|
BT_STATE_WRITE_BYTES,
|
|
BT_STATE_WRITE_CONSUME,
|
|
BT_STATE_READ_WAIT,
|
|
BT_STATE_CLEAR_B2H,
|
|
BT_STATE_READ_BYTES,
|
|
BT_STATE_RESET1, /* These must come last */
|
|
BT_STATE_RESET2,
|
|
BT_STATE_RESET3,
|
|
BT_STATE_RESTART,
|
|
BT_STATE_PRINTME,
|
|
BT_STATE_CAPABILITIES_BEGIN,
|
|
BT_STATE_CAPABILITIES_END,
|
|
BT_STATE_LONG_BUSY /* BT doesn't get hosed :-) */
|
|
};
|
|
|
|
/*
|
|
* 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_SI_SM_RETURN(Y) { last_printed = BT_STATE_PRINTME; return Y; }
|
|
|
|
struct si_sm_data {
|
|
enum bt_states state;
|
|
unsigned char seq; /* BT sequence number */
|
|
struct si_sm_io *io;
|
|
unsigned char write_data[IPMI_MAX_MSG_LENGTH];
|
|
int write_count;
|
|
unsigned char read_data[IPMI_MAX_MSG_LENGTH];
|
|
int read_count;
|
|
int truncated;
|
|
long timeout; /* microseconds countdown */
|
|
int error_retries; /* end of "common" fields */
|
|
int nonzero_status; /* hung BMCs stay all 0 */
|
|
enum bt_states complete; /* to divert the state machine */
|
|
int BT_CAP_outreqs;
|
|
long BT_CAP_req2rsp;
|
|
int BT_CAP_retries; /* Recommended retries */
|
|
};
|
|
|
|
#define BT_CLR_WR_PTR 0x01 /* See IPMI 1.5 table 11.6.4 */
|
|
#define BT_CLR_RD_PTR 0x02
|
|
#define BT_H2B_ATN 0x04
|
|
#define BT_B2H_ATN 0x08
|
|
#define BT_SMS_ATN 0x10
|
|
#define BT_OEM0 0x20
|
|
#define BT_H_BUSY 0x40
|
|
#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
|
|
* clear it, check its state and write if set. This avoids the "get
|
|
* 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_CONTROL(x) bt->io->outputb(bt->io, 0, x)
|
|
|
|
#define BMC2HOST bt->io->inputb(bt->io, 1)
|
|
#define HOST2BMC(x) bt->io->outputb(bt->io, 1, x)
|
|
|
|
#define BT_INTMASK_R bt->io->inputb(bt->io, 2)
|
|
#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.
|
|
*/
|
|
|
|
static char *state2txt(unsigned char state)
|
|
{
|
|
switch (state) {
|
|
case BT_STATE_IDLE: return("IDLE");
|
|
case BT_STATE_XACTION_START: return("XACTION");
|
|
case BT_STATE_WRITE_BYTES: return("WR_BYTES");
|
|
case BT_STATE_WRITE_CONSUME: return("WR_CONSUME");
|
|
case BT_STATE_READ_WAIT: return("RD_WAIT");
|
|
case BT_STATE_CLEAR_B2H: return("CLEAR_B2H");
|
|
case BT_STATE_READ_BYTES: return("RD_BYTES");
|
|
case BT_STATE_RESET1: return("RESET1");
|
|
case BT_STATE_RESET2: return("RESET2");
|
|
case BT_STATE_RESET3: return("RESET3");
|
|
case BT_STATE_RESTART: return("RESTART");
|
|
case BT_STATE_LONG_BUSY: return("LONG_BUSY");
|
|
case BT_STATE_CAPABILITIES_BEGIN: return("CAP_BEGIN");
|
|
case BT_STATE_CAPABILITIES_END: return("CAP_END");
|
|
}
|
|
return("BAD STATE");
|
|
}
|
|
#define STATE2TXT state2txt(bt->state)
|
|
|
|
static char *status2txt(unsigned char status)
|
|
{
|
|
/*
|
|
* This cannot be called by two threads at the same time and
|
|
* the buffer is always consumed immediately, so the static is
|
|
* safe to use.
|
|
*/
|
|
static char buf[40];
|
|
|
|
strcpy(buf, "[ ");
|
|
if (status & BT_B_BUSY)
|
|
strcat(buf, "B_BUSY ");
|
|
if (status & BT_H_BUSY)
|
|
strcat(buf, "H_BUSY ");
|
|
if (status & BT_OEM0)
|
|
strcat(buf, "OEM0 ");
|
|
if (status & BT_SMS_ATN)
|
|
strcat(buf, "SMS ");
|
|
if (status & BT_B2H_ATN)
|
|
strcat(buf, "B2H ");
|
|
if (status & BT_H2B_ATN)
|
|
strcat(buf, "H2B ");
|
|
strcat(buf, "]");
|
|
return buf;
|
|
}
|
|
#define STATUS2TXT status2txt(status)
|
|
|
|
/* called externally at insmod time, and internally on cleanup */
|
|
|
|
static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io)
|
|
{
|
|
memset(bt, 0, sizeof(struct si_sm_data));
|
|
if (bt->io != io) {
|
|
/* external: one-time only things */
|
|
bt->io = io;
|
|
bt->seq = 0;
|
|
}
|
|
bt->state = BT_STATE_IDLE; /* start here */
|
|
bt->complete = BT_STATE_IDLE; /* end here */
|
|
bt->BT_CAP_req2rsp = BT_NORMAL_TIMEOUT * 1000000;
|
|
bt->BT_CAP_retries = BT_NORMAL_RETRY_LIMIT;
|
|
/* BT_CAP_outreqs == zero is a flag to read BT Capabilities */
|
|
return 3; /* We claim 3 bytes of space; ought to check SPMI table */
|
|
}
|
|
|
|
/* Jam a completion code (probably an error) into a response */
|
|
|
|
static void force_result(struct si_sm_data *bt, unsigned char completion_code)
|
|
{
|
|
bt->read_data[0] = 4; /* # following bytes */
|
|
bt->read_data[1] = bt->write_data[1] | 4; /* Odd NetFn/LUN */
|
|
bt->read_data[2] = bt->write_data[2]; /* seq (ignored) */
|
|
bt->read_data[3] = bt->write_data[3]; /* Command */
|
|
bt->read_data[4] = completion_code;
|
|
bt->read_count = 5;
|
|
}
|
|
|
|
/* The upper state machine starts here */
|
|
|
|
static int bt_start_transaction(struct si_sm_data *bt,
|
|
unsigned char *data,
|
|
unsigned int size)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (size < 2)
|
|
return IPMI_REQ_LEN_INVALID_ERR;
|
|
if (size > IPMI_MAX_MSG_LENGTH)
|
|
return IPMI_REQ_LEN_EXCEEDED_ERR;
|
|
|
|
if (bt->state == BT_STATE_LONG_BUSY)
|
|
return IPMI_NODE_BUSY_ERR;
|
|
|
|
if (bt->state != BT_STATE_IDLE)
|
|
return IPMI_NOT_IN_MY_STATE_ERR;
|
|
|
|
if (bt_debug & BT_DEBUG_MSG) {
|
|
printk(KERN_WARNING "BT: +++++++++++++++++ New command\n");
|
|
printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2);
|
|
for (i = 0; i < size; i ++)
|
|
printk(" %02x", data[i]);
|
|
printk("\n");
|
|
}
|
|
bt->write_data[0] = size + 1; /* all data plus seq byte */
|
|
bt->write_data[1] = *data; /* NetFn/LUN */
|
|
bt->write_data[2] = bt->seq++;
|
|
memcpy(bt->write_data + 3, data + 1, size - 1);
|
|
bt->write_count = size + 2;
|
|
bt->error_retries = 0;
|
|
bt->nonzero_status = 0;
|
|
bt->truncated = 0;
|
|
bt->state = BT_STATE_XACTION_START;
|
|
bt->timeout = bt->BT_CAP_req2rsp;
|
|
force_result(bt, IPMI_ERR_UNSPECIFIED);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 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,
|
|
unsigned char *data,
|
|
unsigned int length)
|
|
{
|
|
int i, msg_len;
|
|
|
|
msg_len = bt->read_count - 2; /* account for length & seq */
|
|
if (msg_len < 3 || msg_len > IPMI_MAX_MSG_LENGTH) {
|
|
force_result(bt, IPMI_ERR_UNSPECIFIED);
|
|
msg_len = 3;
|
|
}
|
|
data[0] = bt->read_data[1];
|
|
data[1] = bt->read_data[3];
|
|
if (length < msg_len || bt->truncated) {
|
|
data[2] = IPMI_ERR_MSG_TRUNCATED;
|
|
msg_len = 3;
|
|
} else
|
|
memcpy(data + 2, bt->read_data + 4, msg_len - 2);
|
|
|
|
if (bt_debug & BT_DEBUG_MSG) {
|
|
printk(KERN_WARNING "BT: result %d bytes:", msg_len);
|
|
for (i = 0; i < msg_len; i++)
|
|
printk(" %02x", data[i]);
|
|
printk("\n");
|
|
}
|
|
return msg_len;
|
|
}
|
|
|
|
/* This bit's functionality is optional */
|
|
#define BT_BMC_HWRST 0x80
|
|
|
|
static void reset_flags(struct si_sm_data *bt)
|
|
{
|
|
if (bt_debug)
|
|
printk(KERN_WARNING "IPMI BT: flag reset %s\n",
|
|
status2txt(BT_STATUS));
|
|
if (BT_STATUS & BT_H_BUSY)
|
|
BT_CONTROL(BT_H_BUSY); /* force clear */
|
|
BT_CONTROL(BT_CLR_WR_PTR); /* always reset */
|
|
BT_CONTROL(BT_SMS_ATN); /* always clear */
|
|
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.
|
|
*/
|
|
|
|
static void drain_BMC2HOST(struct si_sm_data *bt)
|
|
{
|
|
int i, size;
|
|
|
|
if (!(BT_STATUS & BT_B2H_ATN)) /* Not signalling a response */
|
|
return;
|
|
|
|
BT_CONTROL(BT_H_BUSY); /* now set */
|
|
BT_CONTROL(BT_B2H_ATN); /* always clear */
|
|
BT_STATUS; /* pause */
|
|
BT_CONTROL(BT_B2H_ATN); /* some BMCs are stubborn */
|
|
BT_CONTROL(BT_CLR_RD_PTR); /* always reset */
|
|
if (bt_debug)
|
|
printk(KERN_WARNING "IPMI BT: stale response %s; ",
|
|
status2txt(BT_STATUS));
|
|
size = BMC2HOST;
|
|
for (i = 0; i < size ; i++)
|
|
BMC2HOST;
|
|
BT_CONTROL(BT_H_BUSY); /* now clear */
|
|
if (bt_debug)
|
|
printk("drained %d bytes\n", size + 1);
|
|
}
|
|
|
|
static inline void write_all_bytes(struct si_sm_data *bt)
|
|
{
|
|
int i;
|
|
|
|
if (bt_debug & BT_DEBUG_MSG) {
|
|
printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
|
|
bt->write_count, bt->seq);
|
|
for (i = 0; i < bt->write_count; i++)
|
|
printk(" %02x", bt->write_data[i]);
|
|
printk("\n");
|
|
}
|
|
for (i = 0; i < bt->write_count; i++)
|
|
HOST2BMC(bt->write_data[i]);
|
|
}
|
|
|
|
static inline int read_all_bytes(struct si_sm_data *bt)
|
|
{
|
|
unsigned char i;
|
|
|
|
/*
|
|
* 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_count = bt->read_data[0];
|
|
|
|
if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) {
|
|
if (bt_debug & BT_DEBUG_MSG)
|
|
printk(KERN_WARNING "BT: bad raw rsp len=%d\n",
|
|
bt->read_count);
|
|
bt->truncated = 1;
|
|
return 1; /* let next XACTION START clean it up */
|
|
}
|
|
for (i = 1; i <= bt->read_count; i++)
|
|
bt->read_data[i] = BMC2HOST;
|
|
bt->read_count++; /* Account internally for length byte */
|
|
|
|
if (bt_debug & BT_DEBUG_MSG) {
|
|
int max = bt->read_count;
|
|
|
|
printk(KERN_WARNING "BT: got %d bytes seq=0x%02X",
|
|
max, bt->read_data[2]);
|
|
if (max > 16)
|
|
max = 16;
|
|
for (i = 0; i < max; i++)
|
|
printk(KERN_CONT " %02x", bt->read_data[i]);
|
|
printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ...");
|
|
}
|
|
|
|
/* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
|
|
if ((bt->read_data[3] == bt->write_data[3]) &&
|
|
(bt->read_data[2] == bt->write_data[2]) &&
|
|
((bt->read_data[1] & 0xF8) == (bt->write_data[1] & 0xF8)))
|
|
return 1;
|
|
|
|
if (bt_debug & BT_DEBUG_MSG)
|
|
printk(KERN_WARNING "IPMI BT: bad packet: "
|
|
"want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
|
|
bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3],
|
|
bt->read_data[1], bt->read_data[2], bt->read_data[3]);
|
|
return 0;
|
|
}
|
|
|
|
/* Restart if retries are left, or return an error completion code */
|
|
|
|
static enum si_sm_result error_recovery(struct si_sm_data *bt,
|
|
unsigned char status,
|
|
unsigned char cCode)
|
|
{
|
|
char *reason;
|
|
|
|
bt->timeout = bt->BT_CAP_req2rsp;
|
|
|
|
switch (cCode) {
|
|
case IPMI_TIMEOUT_ERR:
|
|
reason = "timeout";
|
|
break;
|
|
default:
|
|
reason = "internal error";
|
|
break;
|
|
}
|
|
|
|
printk(KERN_WARNING "IPMI BT: %s in %s %s ", /* open-ended line */
|
|
reason, STATE2TXT, STATUS2TXT);
|
|
|
|
/*
|
|
* Per the IPMI spec, retries are based on the sequence number
|
|
* known only to this module, so manage a restart here.
|
|
*/
|
|
(bt->error_retries)++;
|
|
if (bt->error_retries < bt->BT_CAP_retries) {
|
|
printk("%d retries left\n",
|
|
bt->BT_CAP_retries - bt->error_retries);
|
|
bt->state = BT_STATE_RESTART;
|
|
return SI_SM_CALL_WITHOUT_DELAY;
|
|
}
|
|
|
|
printk(KERN_WARNING "failed %d retries, sending error response\n",
|
|
bt->BT_CAP_retries);
|
|
if (!bt->nonzero_status)
|
|
printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
|
|
|
|
/* this is most likely during insmod */
|
|
else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) {
|
|
printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n");
|
|
bt->state = BT_STATE_RESET1;
|
|
return SI_SM_CALL_WITHOUT_DELAY;
|
|
}
|
|
|
|
/*
|
|
* Concoct a useful error message, set up the next state, and
|
|
* be done with this sequence.
|
|
*/
|
|
|
|
bt->state = BT_STATE_IDLE;
|
|
switch (cCode) {
|
|
case IPMI_TIMEOUT_ERR:
|
|
if (status & BT_B_BUSY) {
|
|
cCode = IPMI_NODE_BUSY_ERR;
|
|
bt->state = BT_STATE_LONG_BUSY;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
force_result(bt, cCode);
|
|
return SI_SM_TRANSACTION_COMPLETE;
|
|
}
|
|
|
|
/* Check status and (usually) take action and change this state machine. */
|
|
|
|
static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
|
|
{
|
|
unsigned char status, BT_CAP[8];
|
|
static enum bt_states last_printed = BT_STATE_PRINTME;
|
|
int i;
|
|
|
|
status = BT_STATUS;
|
|
bt->nonzero_status |= status;
|
|
if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
|
|
printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
|
|
STATE2TXT,
|
|
STATUS2TXT,
|
|
bt->timeout,
|
|
time);
|
|
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
|
|
* 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)) {
|
|
drain_BMC2HOST(bt);
|
|
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
|
|
}
|
|
|
|
if ((bt->state != BT_STATE_IDLE) &&
|
|
(bt->state < BT_STATE_PRINTME)) {
|
|
/* check timeout */
|
|
bt->timeout -= time;
|
|
if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
|
|
return error_recovery(bt,
|
|
status,
|
|
IPMI_TIMEOUT_ERR);
|
|
}
|
|
|
|
switch (bt->state) {
|
|
|
|
/*
|
|
* Idle state first checks for asynchronous messages from another
|
|
* channel, then does some opportunistic housekeeping.
|
|
*/
|
|
|
|
case BT_STATE_IDLE:
|
|
if (status & BT_SMS_ATN) {
|
|
BT_CONTROL(BT_SMS_ATN); /* clear it */
|
|
return SI_SM_ATTN;
|
|
}
|
|
|
|
if (status & BT_H_BUSY) /* clear a leftover H_BUSY */
|
|
BT_CONTROL(BT_H_BUSY);
|
|
|
|
/* Read BT capabilities if it hasn't been done yet */
|
|
if (!bt->BT_CAP_outreqs)
|
|
BT_STATE_CHANGE(BT_STATE_CAPABILITIES_BEGIN,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
bt->timeout = bt->BT_CAP_req2rsp;
|
|
BT_SI_SM_RETURN(SI_SM_IDLE);
|
|
|
|
case BT_STATE_XACTION_START:
|
|
if (status & (BT_B_BUSY | BT_H2B_ATN))
|
|
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
|
|
if (BT_STATUS & BT_H_BUSY)
|
|
BT_CONTROL(BT_H_BUSY); /* force clear */
|
|
BT_STATE_CHANGE(BT_STATE_WRITE_BYTES,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
|
|
case BT_STATE_WRITE_BYTES:
|
|
if (status & BT_H_BUSY)
|
|
BT_CONTROL(BT_H_BUSY); /* clear */
|
|
BT_CONTROL(BT_CLR_WR_PTR);
|
|
write_all_bytes(bt);
|
|
BT_CONTROL(BT_H2B_ATN); /* can clear too fast to catch */
|
|
BT_STATE_CHANGE(BT_STATE_WRITE_CONSUME,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
|
|
case BT_STATE_WRITE_CONSUME:
|
|
if (status & (BT_B_BUSY | BT_H2B_ATN))
|
|
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
|
|
BT_STATE_CHANGE(BT_STATE_READ_WAIT,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
|
|
/* Spinning hard can suppress B2H_ATN and force a timeout */
|
|
|
|
case BT_STATE_READ_WAIT:
|
|
if (!(status & BT_B2H_ATN))
|
|
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
|
|
BT_CONTROL(BT_H_BUSY); /* set */
|
|
|
|
/*
|
|
* Uncached, ordered writes should just proceed serially but
|
|
* 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_STATE_CHANGE(BT_STATE_CLEAR_B2H,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
|
|
case BT_STATE_CLEAR_B2H:
|
|
if (status & BT_B2H_ATN) {
|
|
/* keep hitting it */
|
|
BT_CONTROL(BT_B2H_ATN);
|
|
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
|
|
}
|
|
BT_STATE_CHANGE(BT_STATE_READ_BYTES,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
|
|
case BT_STATE_READ_BYTES:
|
|
if (!(status & BT_H_BUSY))
|
|
/* check in case of retry */
|
|
BT_CONTROL(BT_H_BUSY);
|
|
BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */
|
|
i = read_all_bytes(bt); /* true == packet seq match */
|
|
BT_CONTROL(BT_H_BUSY); /* NOW clear */
|
|
if (!i) /* Not my message */
|
|
BT_STATE_CHANGE(BT_STATE_READ_WAIT,
|
|
SI_SM_CALL_WITHOUT_DELAY);
|
|
bt->state = bt->complete;
|
|
return bt->state == BT_STATE_IDLE ? /* where to next? */
|
|
SI_SM_TRANSACTION_COMPLETE : /* normal */
|
|
SI_SM_CALL_WITHOUT_DELAY; /* Startup magic */
|
|
|
|
case BT_STATE_LONG_BUSY: /* For example: after FW update */
|
|
if (!(status & BT_B_BUSY)) {
|
|
reset_flags(bt); /* next state is now IDLE */
|
|
bt_init_data(bt, bt->io);
|
|
}
|
|
return SI_SM_CALL_WITH_DELAY; /* No repeat printing */
|
|
|
|
case BT_STATE_RESET1:
|
|
reset_flags(bt);
|
|
drain_BMC2HOST(bt);
|
|
BT_STATE_CHANGE(BT_STATE_RESET2,
|
|
SI_SM_CALL_WITH_DELAY);
|
|
|
|
case BT_STATE_RESET2: /* Send a soft reset */
|
|
BT_CONTROL(BT_CLR_WR_PTR);
|
|
HOST2BMC(3); /* number of bytes following */
|
|
HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */
|
|
HOST2BMC(42); /* Sequence number */
|
|
HOST2BMC(3); /* Cmd == Soft reset */
|
|
BT_CONTROL(BT_H2B_ATN);
|
|
bt->timeout = BT_RESET_DELAY * 1000000;
|
|
BT_STATE_CHANGE(BT_STATE_RESET3,
|
|
SI_SM_CALL_WITH_DELAY);
|
|
|
|
case BT_STATE_RESET3: /* Hold off everything for a bit */
|
|
if (bt->timeout > 0)
|
|
return SI_SM_CALL_WITH_DELAY;
|
|
drain_BMC2HOST(bt);
|
|
BT_STATE_CHANGE(BT_STATE_RESTART,
|
|
SI_SM_CALL_WITH_DELAY);
|
|
|
|
case BT_STATE_RESTART: /* don't reset retries or seq! */
|
|
bt->read_count = 0;
|
|
bt->nonzero_status = 0;
|
|
bt->timeout = bt->BT_CAP_req2rsp;
|
|
BT_STATE_CHANGE(BT_STATE_XACTION_START,
|
|
SI_SM_CALL_WITH_DELAY);
|
|
|
|
/*
|
|
* Get BT Capabilities, using timing of upper level state machine.
|
|
* Set outreqs to prevent infinite loop on timeout.
|
|
*/
|
|
case BT_STATE_CAPABILITIES_BEGIN:
|
|
bt->BT_CAP_outreqs = 1;
|
|
{
|
|
unsigned char GetBT_CAP[] = { 0x18, 0x36 };
|
|
bt->state = BT_STATE_IDLE;
|
|
bt_start_transaction(bt, GetBT_CAP, sizeof(GetBT_CAP));
|
|
}
|
|
bt->complete = BT_STATE_CAPABILITIES_END;
|
|
BT_STATE_CHANGE(BT_STATE_XACTION_START,
|
|
SI_SM_CALL_WITH_DELAY);
|
|
|
|
case BT_STATE_CAPABILITIES_END:
|
|
i = bt_get_result(bt, BT_CAP, sizeof(BT_CAP));
|
|
bt_init_data(bt, bt->io);
|
|
if ((i == 8) && !BT_CAP[2]) {
|
|
bt->BT_CAP_outreqs = BT_CAP[3];
|
|
bt->BT_CAP_req2rsp = BT_CAP[6] * 1000000;
|
|
bt->BT_CAP_retries = BT_CAP[7];
|
|
} else
|
|
printk(KERN_WARNING "IPMI BT: using default values\n");
|
|
if (!bt->BT_CAP_outreqs)
|
|
bt->BT_CAP_outreqs = 1;
|
|
printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n",
|
|
bt->BT_CAP_req2rsp / 1000000L, bt->BT_CAP_retries);
|
|
bt->timeout = bt->BT_CAP_req2rsp;
|
|
return SI_SM_CALL_WITHOUT_DELAY;
|
|
|
|
default: /* should never occur */
|
|
return error_recovery(bt,
|
|
status,
|
|
IPMI_ERR_UNSPECIFIED);
|
|
}
|
|
return SI_SM_CALL_WITH_DELAY;
|
|
}
|
|
|
|
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)
|
|
* 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))
|
|
return 1;
|
|
reset_flags(bt);
|
|
return 0;
|
|
}
|
|
|
|
static void bt_cleanup(struct si_sm_data *bt)
|
|
{
|
|
}
|
|
|
|
static int bt_size(void)
|
|
{
|
|
return sizeof(struct si_sm_data);
|
|
}
|
|
|
|
struct si_sm_handlers bt_smi_handlers = {
|
|
.init_data = bt_init_data,
|
|
.start_transaction = bt_start_transaction,
|
|
.get_result = bt_get_result,
|
|
.event = bt_event,
|
|
.detect = bt_detect,
|
|
.cleanup = bt_cleanup,
|
|
.size = bt_size,
|
|
};
|