IPMI: Style fixes in the system interface code

#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 */

/*

 * 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. */

/*

 * 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. */

/*

 * 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_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_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. */

/*

 * 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 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. */

/*

 * 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 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 */

	if (bt->io != io) {

		/* external: one-time only things */

		bt->io = io;

		bt->seq = 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,

			 unsigned char *data,

	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)

{

{

	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_count = bt->read_data[0];

		if (max > 16)

			max = 16;

		for (i = 0; i < max; i++)

			printk (" %02x", bt->read_data[i]);

		printk ("%s\n", bt->read_count == max ? "" : " ...");

			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 */

	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. */

	/*

	 * 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",

		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);

	if (!bt->nonzero_status)

		printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");

		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;

	switch (cCode) {

		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. */

	/*

	 * 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);

	}

	if ((bt->state != BT_STATE_IDLE) &&

	    (bt->state <  BT_STATE_PRINTME)) {		/* check timeout */

	    (bt->state <  BT_STATE_PRINTME)) {

		/* check timeout */

		bt->timeout -= time;

		if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))

			return error_recovery(bt,

	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:

		if (status & BT_SMS_ATN) {

			BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);

		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

		   workaround without too much penalty to the general case. */

		/*

		 * Uncached, ordered writes should just proceeed 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 */

		if (status & BT_B2H_ATN) {

			/* keep hitting it */

			BT_CONTROL(BT_B2H_ATN);

			BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);

		}

				SI_SM_CALL_WITHOUT_DELAY);

	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_CLR_RD_PTR);	/* start of BMC2HOST buffer */

		i = read_all_bytes(bt);		/* true == packet seq match */

		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. */

	/*

	 * 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;

		{

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. */

	/*

	 * 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;

	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,

	.start_transaction	= bt_start_transaction,

	.get_result		= bt_get_result,

/* The states the KCS driver may be in. */

enum kcs_states {

	KCS_IDLE,		/* The KCS interface is currently

                                   doing nothing. */

	KCS_START_OP,		/* We are starting an operation.  The

				   data is in the output buffer, but

				   nothing has been done to the

				   interface yet.  This was added to

				   the state machine in the spec to

				   wait for the initial IBF. */

	KCS_WAIT_WRITE_START,	/* We have written a write cmd to the

				   interface. */

	KCS_WAIT_WRITE,		/* We are writing bytes to the

                                   interface. */

	KCS_WAIT_WRITE_END,	/* We have written the write end cmd

                                   to the interface, and still need to

                                   write the last byte. */

	KCS_WAIT_READ,		/* We are waiting to read data from

				   the interface. */

	KCS_ERROR0,		/* State to transition to the error

				   handler, this was added to the

				   state machine in the spec to be

				   sure IBF was there. */

	KCS_ERROR1,		/* First stage error handler, wait for

                                   the interface to respond. */

	KCS_ERROR2,		/* The abort cmd has been written,

				   wait for the interface to

				   respond. */

	KCS_ERROR3,		/* We wrote some data to the

				   interface, wait for it to switch to

				   read mode. */

	KCS_HOSED		/* The hardware failed to follow the

				   state machine. */

	/* The KCS interface is currently doing nothing. */

	KCS_IDLE,

	/*

	 * We are starting an operation.  The data is in the output

	 * buffer, but nothing has been done to the interface yet.  This

	 * was added to the state machine in the spec to wait for the

	 * initial IBF.

	 */

	KCS_START_OP,

	/* We have written a write cmd to the interface. */

	KCS_WAIT_WRITE_START,

	/* We are writing bytes to the interface. */

	KCS_WAIT_WRITE,

	/*

	 * We have written the write end cmd to the interface, and

	 * still need to write the last byte.

	 */

	KCS_WAIT_WRITE_END,

	/* We are waiting to read data from the interface. */

	KCS_WAIT_READ,

	/*

	 * State to transition to the error handler, this was added to

	 * the state machine in the spec to be sure IBF was there.

	 */

	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_ERROR_RETRIES 10

#define ERROR0_OBF_WAIT_JIFFIES (2*HZ)

struct si_sm_data

{

struct si_sm_data {

	enum kcs_states  state;

	struct si_sm_io *io;

	unsigned char    write_data[MAX_KCS_WRITE_SIZE];

	(kcs->error_retries)++;

	if (kcs->error_retries > MAX_ERROR_RETRIES) {

		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;

	} else {

		kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;

	if (kcs_debug & KCS_DEBUG_MSG) {

		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("\n");

	}

	kcs->error_retries = 0;

		kcs->read_pos = 3;

	}

	if (kcs->truncated) {

		/* Report a truncated error.  We might overwrite

		   another error, but that's too bad, the user needs

		   to know it was truncated. */

		/*

		 * Report a truncated error.  We might overwrite

		 * another error, but that's too bad, the user needs

		 * to know it was truncated.

		 */

		data[2] = IPMI_ERR_MSG_TRUNCATED;

		kcs->truncated = 0;

	}

	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

   sections delimited by "Wait for IBF" and this will become clear. */

/*

 * This implements the state machine defined in the IPMI manual, see

 * 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)

{

	unsigned char status;

	case KCS_WAIT_WRITE_END:

		if (state != KCS_WRITE_STATE) {

			start_error_recovery(kcs,

					     "Not in write state for write end");

					     "Not in write state"

					     " for write end");

			break;

		}

		clear_obf(kcs, status);

				return SI_SM_CALL_WITH_DELAY;

			read_next_byte(kcs);

		} else {

			/* We don't implement this exactly like the state

			   machine in the spec.  Some broken hardware

			   does not write the final dummy byte to the

			   read register.  Thus obf will never go high

			   here.  We just go straight to idle, and we

			   handle clearing out obf in idle state if it

			   happens to come in. */

			/*

			 * We don't implement this exactly like the state

			 * machine in the spec.  Some broken hardware

			 * does not write the final dummy byte to the

			 * read register.  Thus obf will never go high

			 * here.  We just go straight to idle, and we

			 * handle clearing out obf in idle state if it

			 * happens to come in.

			 */

			clear_obf(kcs, status);

			kcs->orig_write_count = 0;

			kcs->state = KCS_IDLE;

	case KCS_ERROR0:

		clear_obf(kcs, status);

		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))

				return SI_SM_CALL_WITH_TICK_DELAY;

		write_cmd(kcs, KCS_GET_STATUS_ABORT);

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)

	   but that's what you get from reading a bogus address, so we

	   test that first. */

	/*

	 * It's impossible for the KCS status register 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.

	 */

	if (read_status(kcs) == 0xff)

		return 1;

{

}

struct si_sm_handlers kcs_smi_handlers =

{

struct si_sm_handlers kcs_smi_handlers = {

	.init_data         = init_kcs_data,

	.start_transaction = start_kcs_transaction,

	.get_result        = get_kcs_result,