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,

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

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

   this interface. */

struct si_sm_io

{

/*

 * 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

 * this interface.

 */

struct si_sm_io {

	unsigned char (*inputb)(struct si_sm_io *io, unsigned int offset);

	void (*outputb)(struct si_sm_io *io,

			unsigned int  offset,

			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;

	int  regspacing;

	int  regsize;

};

/* 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_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_IDLE,		/* The SM is in idle state. */

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

struct si_sm_handlers

{

	/* Put the version number of the state machine here so the

           upper layer can print it. */

struct si_sm_handlers {

	/*

	 * Put the version number of the state machine here so the

	 * upper layer can print it.

	 */

	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,

				  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

	   is invalid (to large or too small), or 0 if the transaction

	   is successfully completed. */

	/*

	 * Start a new transaction in the state machine.  This will

	 * return -2 if the state machine is not idle, -1 if the size

	 * is invalid (to large or too small), or 0 if the transaction

	 * is successfully completed.

	 */

	int (*start_transaction)(struct si_sm_data *smi,

				 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

	   present, or the actual length of the result data. */

	/*

	 * Return the results after the transaction.  This will return

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

			  unsigned char *data, unsigned int length);

	/* Call this periodically (for a polled interface) or upon

	   receiving an interrupt (for a interrupt-driven interface).

	   If interrupt driven, you should probably poll this

	   periodically when not in idle state.  This should be called

	   with the time that passed since the last call, if it is

	   significant.  Time is in microseconds. */

	/*

	 * Call this periodically (for a polled interface) or upon

	 * receiving an interrupt (for a interrupt-driven interface).

	 * If interrupt driven, you should probably poll this

	 * periodically when not in idle state.  This should be called

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

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

	/* The interface is shutting down, so clean it up. */

/* SMIC Flags Register Bits */

#define SMIC_RX_DATA_READY	0x80

#define SMIC_TX_DATA_READY	0x40

/*

 * SMIC_SMI and SMIC_EVM_DATA_AVAIL are only used by

 * a few systems, and then only by Systems Management

#define	EC_ILLEGAL_COMMAND	0x04

#define	EC_BUFFER_FULL		0x05

struct si_sm_data

{

struct si_sm_data {

	enum smic_states state;

	struct si_sm_io *io;

	unsigned char	 write_data[MAX_SMIC_WRITE_SIZE];

		return IPMI_NOT_IN_MY_STATE_ERR;

	if (smic_debug & SMIC_DEBUG_MSG) {

		printk(KERN_INFO "start_smic_transaction -");

		for (i = 0; i < size; i ++) {

			printk (" %02x", (unsigned char) (data [i]));

		}

		printk(KERN_DEBUG "start_smic_transaction -");

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

			printk(" %02x", (unsigned char) data[i]);

		printk("\n");

	}

	smic->error_retries = 0;

	int i;

	if (smic_debug & SMIC_DEBUG_MSG) {

		printk (KERN_INFO "smic_get result -");

		for (i = 0; i < smic->read_pos; i ++) {

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

		}

		printk(KERN_DEBUG "smic_get result -");

		for (i = 0; i < smic->read_pos; i++)

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

		printk("\n");

	}

	if (length < smic->read_pos) {

{

	(smic->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

			       "ipmi_smic_drv: smic hosed: %s\n", reason);

		}

		smic->state = SMIC_HOSED;

	} else {

		smic->write_count = smic->orig_write_count;

		smic->truncated = 1;

	} else {

		smic->read_data[smic->read_pos] = read_smic_data(smic);

		(smic->read_pos)++;

		smic->read_pos++;

	}

}

		return SI_SM_HOSED;

	}

	if (smic->state != SMIC_IDLE) {

		if (smic_debug & SMIC_DEBUG_STATES) {

			printk(KERN_INFO

		if (smic_debug & SMIC_DEBUG_STATES)

			printk(KERN_DEBUG

			       "smic_event - smic->smic_timeout = %ld,"

			       " time = %ld\n",

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

			smic->smic_timeout -= time;

			if (smic->smic_timeout < 0) {

	status = read_smic_status(smic);

	if (smic_debug & SMIC_DEBUG_STATES)

		printk(KERN_INFO

		printk(KERN_DEBUG