IPMI: Style fixes in the system interface code

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>

5 files changed, 574 insertions, 436 deletions

diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index e736119b6497..7b98c067190a 100644
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -37,26 +37,32 @@
 #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 */
@@ -76,10 +82,12 @@ enum bt_states {
         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; }
 
 #define BT_SI_SM_RETURN(Y)   { last_printed = BT_STATE_PRINTME; return Y; }
 
@@ -110,11 +118,13 @@ struct si_sm_data {
 #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)
@@ -125,8 +135,10 @@ struct si_sm_data {
 #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)
 {
@@ -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)
 {
         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;
         }
@@ -229,7 +242,7 @@ static int bt_start_transaction(struct si_sm_data *bt,
                 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(" %02x", data[i]);
                 printk("\n");
         }
         bt->write_data[0] = size + 1;   /* all data plus seq byte */
@@ -246,8 +259,10 @@ static int bt_start_transaction(struct si_sm_data *bt,
         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,
@@ -269,10 +284,10 @@ static int bt_get_result(struct si_sm_data *bt,
                 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);
+                printk(KERN_WARNING "BT: result %d bytes:", msg_len);
                 for (i = 0; i < msg_len; i++)
                         printk(" %02x", data[i]);
-                printk ("\n");
+                printk("\n");
         }
         return msg_len;
 }
@@ -292,8 +307,10 @@ static void reset_flags(struct si_sm_data *bt)
         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)
 {
@@ -326,8 +343,8 @@ static inline void write_all_bytes(struct si_sm_data *bt)
                 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");
+                        printk(" %02x", bt->write_data[i]);
+                printk("\n");
         }
         for (i = 0; i < bt->write_count; i++)
                 HOST2BMC(bt->write_data[i]);
@@ -337,8 +354,10 @@ 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[] */
+        /*
+         * 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];
@@ -362,8 +381,8 @@ static inline int read_all_bytes(struct si_sm_data *bt)
                 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 */
@@ -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 */
                 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",
@@ -412,8 +433,8 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
                 return SI_SM_CALL_WITHOUT_DELAY;
         }
 
-        printk("failed %d retries, sending error response\n",
-                bt->BT_CAP_retries);
+        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");
 
@@ -424,8 +445,10 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
                 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) {
@@ -461,10 +484,12 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long 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. */
+        /*
+         * 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);
@@ -472,7 +497,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
         }
 
         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,
@@ -482,8 +508,10 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 
         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) {
@@ -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_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);
                 }
@@ -548,7 +579,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                                 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 */
@@ -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,
                                 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;
                 {
@@ -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)
 {
-        /* 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;
@@ -658,8 +694,7 @@ static int bt_size(void)
         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,
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index c1b8228cb7b6..80704875794c 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -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. */
 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
@@ -102,8 +123,7 @@ enum kcs_states {
 #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];
@@ -187,7 +207,8 @@ static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
         (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;
@@ -271,10 +292,9 @@ static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
 
         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");
+                printk("\n");
         }
         kcs->error_retries = 0;
         memcpy(kcs->write_data, data, size);
@@ -305,9 +325,11 @@ static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
                 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;
         }
@@ -315,9 +337,11 @@ static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
         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;
@@ -388,11 +412,12 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                         write_next_byte(kcs);
                 }
                 break;
-                
+
         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);
@@ -413,13 +438,15 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                                 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;
@@ -430,7 +457,8 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
         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);
@@ -442,7 +470,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                 write_data(kcs, 0);
                 kcs->state = KCS_ERROR2;
                 break;
-                
+
         case KCS_ERROR2:
                 if (state != KCS_READ_STATE) {
                         start_error_recovery(kcs,
@@ -456,7 +484,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                 write_data(kcs, KCS_READ_BYTE);
                 kcs->state = KCS_ERROR3;
                 break;
-                
+
         case KCS_ERROR3:
                 if (state != KCS_IDLE_STATE) {
                         start_error_recovery(kcs,
@@ -475,7 +503,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                         return SI_SM_TRANSACTION_COMPLETE;
                 }
                 break;
-                        
+
         case KCS_HOSED:
                 break;
         }
@@ -495,10 +523,12 @@ static int kcs_size(void)
 
 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;
 
@@ -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,
         .start_transaction = start_kcs_transaction,
         .get_result        = get_kcs_result,
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index ba7e75b731c6..97b6225c070b 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -80,7 +80,7 @@
 #define SI_USEC_PER_JIFFY       (1000000/HZ)
 #define SI_TIMEOUT_JIFFIES      (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
-                                       short timeout */
+                                      short timeout */
 
 /* Bit for BMC global enables. */
 #define IPMI_BMC_RCV_MSG_INTR     0x01
@@ -114,8 +114,7 @@ static char *si_to_str[] = { "kcs", "smic", "bt" };
 
 #define DEVICE_NAME "ipmi_si"
 
-static struct device_driver ipmi_driver =
-{
+static struct device_driver ipmi_driver = {
         .name = DEVICE_NAME,
         .bus = &platform_bus_type
 };
@@ -169,8 +168,7 @@ enum si_stat_indexes {
         SI_NUM_STATS
 };
 
-struct smi_info
-{
+struct smi_info {
         int                    intf_num;
         ipmi_smi_t             intf;
         struct si_sm_data      *si_sm;
@@ -183,8 +181,10 @@ struct smi_info
         struct ipmi_smi_msg    *curr_msg;
         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;
         int (*io_setup)(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_data;
 
-        /* Per-OEM handler, called from handle_flags().
-           Returns 1 when handle_flags() needs to be re-run
-           or 0 indicating it set si_state itself.
-        */
+        /*
+         * Per-OEM handler, called from handle_flags().  Returns 1
+         * 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);
 
-        /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
-           is set to hold the flags until we are done handling everything
-           from the flags. */
+        /*
+         * Flags from the last GET_MSG_FLAGS command, used when an ATTN
+         * is set to hold the flags until we are done handling everything
+         * from the flags.
+         */
 #define RECEIVE_MSG_AVAIL       0x01
 #define EVENT_MSG_BUFFER_FULL   0x02
 #define WDT_PRE_TIMEOUT_INT     0x08
@@ -211,25 +214,31 @@ struct smi_info
 #define OEM1_DATA_AVAIL     0x40
 #define OEM2_DATA_AVAIL     0x80
 #define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
-                             OEM1_DATA_AVAIL | \
-                             OEM2_DATA_AVAIL)
+                             OEM1_DATA_AVAIL | \
+                             OEM2_DATA_AVAIL)
         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;
 
-        /* If true, run the state machine to completion on every send
-           call.  Generally used after a panic to make sure stuff goes
-           out. */
+        /*
+         * If true, run the state machine to completion on every send
+         * call.  Generally used after a panic to make sure stuff goes
+         * out.
+         */
         int                 run_to_completion;
 
         /* The I/O port of an SI interface. */
         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 second port is 0xca6. */
+        /*
+         * The space between start addresses of the two ports.  For
+         * instance, if the first port is 0xca2 and the spacing is 4, then
+         * the second port is 0xca6.
+         */
         unsigned int        spacing;
 
         /* zero if no irq; */
@@ -244,10 +253,12 @@ struct smi_info
         /* Used to gracefully stop the timer without race conditions. */
         atomic_t            stop_operation;
 
-        /* The driver will disable interrupts when it gets into a
-           situation where it cannot handle messages due to lack of
-           memory.  Once that situation clears up, it will re-enable
-           interrupts. */
+        /*
+         * The driver will disable interrupts when it gets into a
+         * situation where it cannot handle messages due to lack of
+         * memory.  Once that situation clears up, it will re-enable
+         * interrupts.
+         */
         int interrupt_disabled;
 
         /* From the get device id response... */
@@ -257,8 +268,10 @@ struct smi_info
         struct device *dev;
         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;
 
         /* Slave address, could be reported from DMI. */
@@ -267,7 +280,7 @@ struct smi_info
         /* Counters and things for the proc filesystem. */
         atomic_t stats[SI_NUM_STATS];
 
-        struct task_struct *thread;
+        struct task_struct *thread;
 
         struct list_head link;
 };
@@ -288,7 +301,7 @@ static int try_smi_init(struct smi_info *smi);
 static void cleanup_one_si(struct smi_info *to_clean);
 
 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
-static int register_xaction_notifier(struct notifier_block * nb)
+static int register_xaction_notifier(struct notifier_block *nb)
 {
         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 }
@@ -297,7 +310,7 @@ static void deliver_recv_msg(struct smi_info *smi_info,
                              struct ipmi_smi_msg *msg)
 {
         /* Deliver the message to the upper layer with the lock
-           released. */
+           released. */
         spin_unlock(&(smi_info->si_lock));
         ipmi_smi_msg_received(smi_info->intf, msg);
         spin_lock(&(smi_info->si_lock));
@@ -329,8 +342,10 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
         struct timeval t;
 #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)
                 spin_lock(&(smi_info->msg_lock));
 
@@ -353,7 +368,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                                                 link);
 #ifdef DEBUG_TIMING
                 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
                 err = atomic_notifier_call_chain(&xaction_notifier_list,
                                 0, smi_info);
@@ -365,13 +380,12 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                         smi_info->si_sm,
                         smi_info->curr_msg->data,
                         smi_info->curr_msg->data_size);
-                if (err) {
+                if (err)
                         return_hosed_msg(smi_info, err);
-                }
 
                 rv = SI_SM_CALL_WITHOUT_DELAY;
         }
-        out:
+ out:
         if (!smi_info->run_to_completion)
                 spin_unlock(&(smi_info->msg_lock));
 
@@ -382,8 +396,10 @@ static void start_enable_irq(struct smi_info *smi_info)
 {
         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[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;
 }
 
-/* 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
-   polled until we can allocate some memory.  Once we have some
-   memory, we will re-enable the interrupt. */
+/*
+ * 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
+ * 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)
 {
         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
@@ -486,12 +504,11 @@ static void handle_flags(struct smi_info *smi_info)
                         smi_info->curr_msg->data_size);
                 smi_info->si_state = SI_GETTING_EVENTS;
         } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
-                   smi_info->oem_data_avail_handler) {
+                   smi_info->oem_data_avail_handler) {
                 if (smi_info->oem_data_avail_handler(smi_info))
                         goto retry;
-        } else {
+        } else
                 smi_info->si_state = SI_NORMAL;
-        }
 }
 
 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;
 
         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
         switch (smi_info->si_state) {
         case SI_NORMAL:
@@ -514,9 +531,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
                                 smi_info->curr_msg->rsp,
                                 IPMI_MAX_MSG_LENGTH);
 
-                /* Do this here becase deliver_recv_msg() releases the
-                   lock, and a new message can be put in during the
-                   time the lock is released. */
+                /*
+                 * Do this here becase deliver_recv_msg() releases the
+                 * lock, and a new message can be put in during the
+                 * time the lock is released.
+                 */
                 msg = smi_info->curr_msg;
                 smi_info->curr_msg = NULL;
                 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. */
                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
                 if (msg[2] != 0) {
-                        /* Error fetching flags, just give up for
-                           now. */
+                        /* Error fetching flags, just give up for now. */
                         smi_info->si_state = SI_NORMAL;
                 } 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;
                 } else {
                         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,
                                 IPMI_MAX_MSG_LENGTH);
 
-                /* Do this here becase deliver_recv_msg() releases the
-                   lock, and a new message can be put in during the
-                   time the lock is released. */
+                /*
+                 * Do this here becase deliver_recv_msg() releases the
+                 * lock, and a new message can be put in during the
+                 * time the lock is released.
+                 */
                 msg = smi_info->curr_msg;
                 smi_info->curr_msg = NULL;
                 if (msg->rsp[2] != 0) {
@@ -587,10 +609,12 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 } else {
                         smi_inc_stat(smi_info, events);
 
-                        /* Do this before we deliver the message
-                           because delivering the message releases the
-                           lock and something else can mess with the
-                           state. */
+                        /*
+                         * Do this before we deliver the message
+                         * because delivering the message releases the
+                         * lock and something else can mess with the
+                         * state.
+                         */
                         handle_flags(smi_info);
 
                         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,
                                 IPMI_MAX_MSG_LENGTH);
 
-                /* Do this here becase deliver_recv_msg() releases the
-                   lock, and a new message can be put in during the
-                   time the lock is released. */
+                /*
+                 * Do this here becase deliver_recv_msg() releases the
+                 * lock, and a new message can be put in during the
+                 * time the lock is released.
+                 */
                 msg = smi_info->curr_msg;
                 smi_info->curr_msg = NULL;
                 if (msg->rsp[2] != 0) {
@@ -621,10 +647,12 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 } else {
                         smi_inc_stat(smi_info, incoming_messages);
 
-                        /* Do this before we deliver the message
-                           because delivering the message releases the
-                           lock and something else can mess with the
-                           state. */
+                        /*
+                         * Do this before we deliver the message
+                         * because delivering the message releases the
+                         * lock and something else can mess with the
+                         * state.
+                         */
                         handle_flags(smi_info);
 
                         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
-   si_lock held and interrupts disabled. */
+/*
+ * Called on timeouts and events.  Timeouts should pass the elapsed
+ * 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,
                                            int time)
 {
         enum si_sm_result si_sm_result;
 
  restart:
-        /* There used to be a loop here that waited a little while
-           (around 25us) before giving up.  That turned out to be
-           pointless, the minimum delays I was seeing were in the 300us
-           range, which is far too long to wait in an interrupt.  So
-           we just run until the state machine tells us something
-           happened or it needs a delay. */
+        /*
+         * There used to be a loop here that waited a little while
+         * (around 25us) before giving up.  That turned out to be
+         * pointless, the minimum delays I was seeing were in the 300us
+         * range, which is far too long to wait in an interrupt.  So
+         * 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);
         time = 0;
         while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
-        {
                 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);
 
                 handle_transaction_done(smi_info);
                 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);
 
-                /* 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;
                 if (smi_info->curr_msg != NULL) {
-                        /* If we were handling a user message, format
-                           a response to send to the upper layer to
-                           tell it about the error. */
+                        /*
+                         * If we were handling a user message, format
+                         * a response to send to the upper layer to
+                         * tell it about the error.
+                         */
                         return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
                 }
                 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
          * 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];
 
                 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
-                   this in the upper layer, but due to the way
-                   interrupts work with the SMI, that's not really
-                   possible. */
+                /*
+                 * Got a attn, send down a get message flags to see
+                 * what's causing it.  It would be better to handle
+                 * this in the upper layer, but due to the way
+                 * interrupts work with the SMI, that's not really
+                 * possible.
+                 */
                 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
                 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 
@@ -788,13 +820,14 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
                 si_sm_result = start_next_msg(smi_info);
                 if (si_sm_result != SI_SM_IDLE)
                         goto restart;
-        }
+        }
 
         if ((si_sm_result == SI_SM_IDLE)
-            && (atomic_read(&smi_info->req_events)))
-        {
-                /* We are idle and the upper layer requested that I fetch
-                   events, so do so. */
+            && (atomic_read(&smi_info->req_events))) {
+                /*
+                 * We are idle and the upper layer requested that I fetch
+                 * events, so do so.
+                 */
                 atomic_set(&smi_info->req_events, 0);
 
                 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_lock_irqsave(&smi_info->si_lock, flags);
-        if ((smi_info->si_state == SI_NORMAL)
-            && (smi_info->curr_msg == NULL))
-        {
+        if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL)
                 start_next_msg(smi_info);
-        }
         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);
                 smi_result = smi_event_handler(smi_info, 0);
                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
-                if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
-                        /* do nothing */
-                }
+                if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
+                        ; /* do nothing */
                 else if (smi_result == SI_SM_CALL_WITH_DELAY)
                         schedule();
                 else
@@ -959,7 +988,7 @@ static void smi_timeout(unsigned long data)
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 #ifdef DEBUG_TIMING
         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
         jiffies_now = 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;
         }
 
-        /* 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) {
                 smi_inc_stat(smi_info, short_timeouts);
                 smi_info->si_timer.expires = jiffies + 1;
@@ -1005,7 +1036,7 @@ static irqreturn_t si_irq_handler(int irq, void *data)
 
 #ifdef DEBUG_TIMING
         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
         smi_event_handler(smi_info, 0);
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
@@ -1048,7 +1079,7 @@ static int smi_start_processing(void       *send_info,
          * The BT interface is efficient enough to not need a thread,
          * and there is no need for a thread if we have interrupts.
          */
-        else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
+        else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
                 enable = 1;
 
         if (enable) {
@@ -1074,8 +1105,7 @@ static void set_maintenance_mode(void *send_info, int enable)
                 atomic_set(&smi_info->req_events, 0);
 }
 
-static struct ipmi_smi_handlers handlers =
-{
+static struct ipmi_smi_handlers handlers = {
         .owner                  = THIS_MODULE,
         .start_processing       = smi_start_processing,
         .sender                 = sender,
@@ -1085,8 +1115,10 @@ static struct ipmi_smi_handlers handlers =
         .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 DEFINE_MUTEX(smi_infos_lock);
@@ -1277,10 +1309,9 @@ static void port_cleanup(struct smi_info *info)
         int          idx;
 
         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,
                                        info->io.regsize);
-                }
         }
 }
 
@@ -1294,8 +1325,10 @@ static int port_setup(struct smi_info *info)
 
         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) {
         case 1:
                 info->io.inputb = port_inb;
@@ -1310,17 +1343,18 @@ static int port_setup(struct smi_info *info)
                 info->io.outputb = port_outl;
                 break;
         default:
-                printk("ipmi_si: Invalid register size: %d\n",
+                printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
                        info->io.regsize);
                 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
          * entire I/O region.  Therefore we must register each I/O
          * port separately.
          */
-        for (idx = 0; idx < info->io_size; idx++) {
+        for (idx = 0; idx < info->io_size; idx++) {
                 if (request_region(addr + idx * info->io.regspacing,
                                    info->io.regsize, DEVICE_NAME) == NULL) {
                         /* Undo allocations */
@@ -1408,8 +1442,10 @@ static int mem_setup(struct smi_info *info)
 
         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) {
         case 1:
                 info->io.inputb = intf_mem_inb;
@@ -1430,16 +1466,18 @@ static int mem_setup(struct smi_info *info)
                 break;
 #endif
         default:
-                printk("ipmi_si: Invalid register size: %d\n",
+                printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
                        info->io.regsize);
                 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
          * more memory than it has to.  It will claim everything
          * between the first address to the end of the last full
-         * register. */
+         * register.
+         */
         mapsize = ((info->io_size * info->io.regspacing)
                    - (info->io.regspacing - info->io.regsize));
 
@@ -1769,9 +1807,11 @@ static __devinit void hardcode_find_bmc(void)
 
 #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
-   are no more. */
+/*
+ * 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
+ * are no more.
+ */
 static int acpi_failure;
 
 /* For GPE-type interrupts. */
@@ -1834,7 +1874,8 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
 
 /*
  * 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 {
         s8      Signature[4];
@@ -1856,14 +1897,18 @@ struct SPMITable {
          */
         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;
 
         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;
 
         /* The actual register address. */
@@ -1881,7 +1926,7 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
 
         if (spmi->IPMIlegacy != 1) {
             printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
-            return -ENODEV;
+            return -ENODEV;
         }
 
         if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
@@ -1898,8 +1943,7 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
         info->addr_source = "ACPI";
 
         /* Figure out the interface type. */
-        switch (spmi->InterfaceType)
-        {
+        switch (spmi->InterfaceType) {
         case 1: /* KCS */
                 info->si_type = SI_KCS;
                 break;
@@ -1947,7 +1991,8 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
         } else {
                 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;
         }
         info->io.addr_data = spmi->addr.address;
@@ -1981,8 +2026,7 @@ static __devinit void acpi_find_bmc(void)
 #endif
 
 #ifdef CONFIG_DMI
-struct dmi_ipmi_data
-{
+struct dmi_ipmi_data {
         u8              type;
         u8              addr_space;
         unsigned long   base_addr;
@@ -2007,11 +2051,10 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
                         /* I/O */
                         base_addr &= 0xFFFE;
                         dmi->addr_space = IPMI_IO_ADDR_SPACE;
-                }
-                else {
+                } else
                         /* Memory */
                         dmi->addr_space = IPMI_MEM_ADDR_SPACE;
-                }
+
                 /* If bit 4 of byte 0x10 is set, then the lsb for the address
                    is odd. */
                 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
@@ -2020,7 +2063,7 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
 
                 /* The top two bits of byte 0x10 hold the register spacing. */
                 reg_spacing = (data[0x10] & 0xC0) >> 6;
-                switch(reg_spacing){
+                switch (reg_spacing) {
                 case 0x00: /* Byte boundaries */
                     dmi->offset = 1;
                     break;
@@ -2036,12 +2079,14 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
                 }
         } else {
                 /* 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
                  * the address is in memory.  So many systems get that
                  * wrong (and all that I have seen are I/O) so we just
                  * 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->addr_space = IPMI_IO_ADDR_SPACE;
                 dmi->offset = 1;
@@ -2248,13 +2293,13 @@ static struct pci_device_id ipmi_pci_devices[] = {
 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
 
 static struct pci_driver ipmi_pci_driver = {
-        .name =         DEVICE_NAME,
-        .id_table =     ipmi_pci_devices,
-        .probe =        ipmi_pci_probe,
-        .remove =       __devexit_p(ipmi_pci_remove),
+        .name =         DEVICE_NAME,
+        .id_table =     ipmi_pci_devices,
+        .probe =        ipmi_pci_probe,
+        .remove =       __devexit_p(ipmi_pci_remove),
 #ifdef CONFIG_PM
-        .suspend =      ipmi_pci_suspend,
-        .resume =       ipmi_pci_resume,
+        .suspend =      ipmi_pci_suspend,
+        .resume =       ipmi_pci_resume,
 #endif
 };
 #endif /* CONFIG_PCI */
@@ -2324,7 +2369,7 @@ static int __devinit ipmi_of_probe(struct of_device *dev,
                 info->io.addr_data, info->io.regsize, info->io.regspacing,
                 info->irq);
 
-        dev->dev.driver_data = (void*) info;
+        dev->dev.driver_data = (void *) info;
 
         return try_smi_init(info);
 }
@@ -2337,14 +2382,16 @@ static int __devexit ipmi_of_remove(struct of_device *dev)
 
 static struct of_device_id ipmi_match[] =
 {
-        { .type = "ipmi", .compatible = "ipmi-kcs",  .data = (void *)(unsigned long) SI_KCS },
-        { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
-        { .type = "ipmi", .compatible = "ipmi-bt",   .data = (void *)(unsigned long) SI_BT },
+        { .type = "ipmi", .compatible = "ipmi-kcs",
+          .data = (void *)(unsigned long) SI_KCS },
+        { .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",
         .match_table    = ipmi_match,
         .probe          = ipmi_of_probe,
@@ -2365,32 +2412,32 @@ static int try_get_dev_id(struct smi_info *smi_info)
         if (!resp)
                 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[1] = IPMI_GET_DEVICE_ID_CMD;
         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
 
         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
-        for (;;)
-        {
+        for (;;) {
                 if (smi_result == SI_SM_CALL_WITH_DELAY ||
                     smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
                         schedule_timeout_uninterruptible(1);
                         smi_result = smi_info->handlers->event(
                                 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_info->si_sm, 0);
-                }
-                else
+                } else
                         break;
         }
         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;
                 goto out;
         }
@@ -2476,7 +2523,7 @@ static int param_read_proc(char *page, char **start, off_t off,
 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
 {
         smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
-                                RECEIVE_MSG_AVAIL);
+                               RECEIVE_MSG_AVAIL);
         return 1;
 }
 
@@ -2518,10 +2565,9 @@ static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
                     id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
                         smi_info->oem_data_avail_handler =
                                 oem_data_avail_to_receive_msg_avail;
-                }
-                else if (ipmi_version_major(id) < 1 ||
-                         (ipmi_version_major(id) == 1 &&
-                          ipmi_version_minor(id) < 5)) {
+                } else if (ipmi_version_major(id) < 1 ||
+                           (ipmi_version_major(id) == 1 &&
+                            ipmi_version_minor(id) < 5)) {
                         smi_info->oem_data_avail_handler =
                                 oem_data_avail_to_receive_msg_avail;
                 }
@@ -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)
 {
         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)
                         kthread_stop(smi_info->thread);
                 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. */
         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
         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;
                 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. */
         rv = new_smi->io_setup(new_smi);
         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;
         }
 
@@ -2765,8 +2813,10 @@ static int try_smi_init(struct smi_info *new_smi)
                 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);
         if (rv) {
                 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;
         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);
         /* IRQ is defined to be set when non-zero. */
         if (new_smi->irq)
                 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
 
         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->intf_num);
                 if (rv) {
@@ -2871,7 +2925,8 @@ static int try_smi_init(struct smi_info *new_smi)
 
         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;
 
@@ -2886,9 +2941,11 @@ static int try_smi_init(struct smi_info *new_smi)
         if (new_smi->irq_cleanup)
                 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
-           interrupt. */
+        /*
+         * Wait until we know that we are out of any interrupt
+         * handlers might have been running before we freed the
+         * interrupt.
+         */
         synchronize_sched();
 
         if (new_smi->si_sm) {
@@ -2960,11 +3017,10 @@ static __devinit int init_ipmi_si(void)
 
 #ifdef CONFIG_PCI
         rv = pci_register_driver(&ipmi_pci_driver);
-        if (rv){
+        if (rv)
                 printk(KERN_ERR
                        "init_ipmi_si: Unable to register PCI driver: %d\n",
                        rv);
-        }
 #endif
 
 #ifdef CONFIG_PPC_OF
@@ -2993,7 +3049,8 @@ static __devinit int init_ipmi_si(void)
                 of_unregister_platform_driver(&ipmi_of_platform_driver);
 #endif
                 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;
         } else {
                 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. */
         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);
 
-        /* Timeouts are stopped, now make sure the interrupts are off
-           for the device.  A little tricky with locks to make sure
-           there are no races. */
+        /*
+         * Timeouts are stopped, now make sure the interrupts are off
+         * for the device.  A little tricky with locks to make sure
+         * there are no races.
+         */
         spin_lock_irqsave(&to_clean->si_lock, flags);
         while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
                 spin_unlock_irqrestore(&to_clean->si_lock, flags);
@@ -3092,4 +3153,5 @@ module_exit(cleanup_ipmi_si);
 
 MODULE_LICENSE("GPL");
 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.");
diff --git a/drivers/char/ipmi/ipmi_si_sm.h b/drivers/char/ipmi/ipmi_si_sm.h
index 4b731b24dc16..df89f73475fb 100644
--- a/drivers/char/ipmi/ipmi_si_sm.h
+++ b/drivers/char/ipmi/ipmi_si_sm.h
@@ -34,22 +34,27 @@
  *  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;
@@ -59,53 +64,67 @@ struct si_sm_io
 };
 
 /* 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. */
diff --git a/drivers/char/ipmi/ipmi_smic_sm.c b/drivers/char/ipmi/ipmi_smic_sm.c
index e64ea7d25d24..faed92971907 100644
--- a/drivers/char/ipmi/ipmi_smic_sm.c
+++ b/drivers/char/ipmi/ipmi_smic_sm.c
@@ -85,6 +85,7 @@ enum smic_states {
 /* 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
@@ -104,23 +105,22 @@ enum smic_states {
 #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];
-        int              write_pos;
-        int              write_count;
-        int              orig_write_count;
-        unsigned char    read_data[MAX_SMIC_READ_SIZE];
-        int              read_pos;
-        int              truncated;
-        unsigned int     error_retries;
-        long             smic_timeout;
+        unsigned char    write_data[MAX_SMIC_WRITE_SIZE];
+        int              write_pos;
+        int              write_count;
+        int              orig_write_count;
+        unsigned char    read_data[MAX_SMIC_READ_SIZE];
+        int              read_pos;
+        int              truncated;
+        unsigned int     error_retries;
+        long             smic_timeout;
 };
 
-static unsigned int init_smic_data (struct si_sm_data *smic,
-                                    struct si_sm_io *io)
+static unsigned int init_smic_data(struct si_sm_data *smic,
+                                   struct si_sm_io *io)
 {
         smic->state = SMIC_IDLE;
         smic->io = io;
@@ -150,11 +150,10 @@ static int start_smic_transaction(struct si_sm_data *smic,
                 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 ("\n");
+                printk(KERN_DEBUG "start_smic_transaction -");
+                for (i = 0; i < size; i++)
+                        printk(" %02x", (unsigned char) data[i]);
+                printk("\n");
         }
         smic->error_retries = 0;
         memcpy(smic->write_data, data, size);
@@ -173,11 +172,10 @@ static int smic_get_result(struct si_sm_data *smic,
         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 ("\n");
+                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->read_pos = length;
@@ -223,8 +221,8 @@ static inline void write_smic_control(struct si_sm_data *smic,
         smic->io->outputb(smic->io, 1, control);
 }
 
-static inline void write_si_sm_data (struct si_sm_data *smic,
-                                   unsigned char   data)
+static inline void write_si_sm_data(struct si_sm_data *smic,
+                                    unsigned char   data)
 {
         smic->io->outputb(smic->io, 0, data);
 }
@@ -233,10 +231,9 @@ static inline void start_error_recovery(struct si_sm_data *smic, char *reason)
 {
         (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;
@@ -254,14 +251,14 @@ static inline void write_next_byte(struct si_sm_data *smic)
         (smic->write_count)--;
 }
 
-static inline void read_next_byte (struct si_sm_data *smic)
+static inline void read_next_byte(struct si_sm_data *smic)
 {
         if (smic->read_pos >= MAX_SMIC_READ_SIZE) {
-                read_smic_data (smic);
+                read_smic_data(smic);
                 smic->truncated = 1;
         } else {
                 smic->read_data[smic->read_pos] = read_smic_data(smic);
-                (smic->read_pos)++;
+                smic->read_pos++;
         }
 }
 
@@ -336,7 +333,7 @@ static inline void read_next_byte (struct si_sm_data *smic)
         SMIC_SC_SMS_RD_END      0xC6
 */
 
-static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
+static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 {
         unsigned char status;
         unsigned char flags;
@@ -347,13 +344,15 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                 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) {
@@ -366,9 +365,9 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
         if (flags & SMIC_FLAG_BSY)
                 return SI_SM_CALL_WITH_DELAY;
 
-        status = read_smic_status (smic);
+        status = read_smic_status(smic);
         if (smic_debug & SMIC_DEBUG_STATES)
-                printk(KERN_INFO
+                printk(KERN_DEBUG
                        "smic_event - state = %d, flags = 0x%02x,"
                        " status = 0x%02x\n",
                        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:
                 /* in IDLE we check for available messages */
                 if (flags & SMIC_SMS_DATA_AVAIL)
-                {
                         return SI_SM_ATTN;
-                }
                 return SI_SM_IDLE;
 
         case SMIC_START_OP:
@@ -391,7 +388,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
 
         case SMIC_OP_OK:
                 if (status != SMIC_SC_SMS_READY) {
-                                /* this should not happen */
+                        /* this should not happen */
                         start_error_recovery(smic,
                                              "state = SMIC_OP_OK,"
                                              " status != SMIC_SC_SMS_READY");
@@ -411,8 +408,10 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                                              "status != SMIC_SC_SMS_WR_START");
                         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 (smic->write_count == 1) {
                                 /* 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_smic_flags(smic, flags | SMIC_FLAG_BSY);
-                }
-                else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_WRITE_NEXT:
@@ -442,52 +439,48 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                         if (smic->write_count == 1) {
                                 write_smic_control(smic, SMIC_CC_SMS_WR_END);
                                 smic->state = SMIC_WRITE_END;
-                        }
-                        else {
+                        } else {
                                 write_smic_control(smic, SMIC_CC_SMS_WR_NEXT);
                                 smic->state = SMIC_WRITE_NEXT;
                         }
                         write_next_byte(smic);
                         write_smic_flags(smic, flags | SMIC_FLAG_BSY);
-                }
-                else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_WRITE_END:
                 if (status != SMIC_SC_SMS_WR_END) {
-                        start_error_recovery (smic,
-                                              "state = SMIC_WRITE_END, "
-                                              "status != SMIC_SC_SMS_WR_END");
+                        start_error_recovery(smic,
+                                             "state = SMIC_WRITE_END, "
+                                             "status != SMIC_SC_SMS_WR_END");
                         return SI_SM_CALL_WITH_DELAY;
                 }
                 /* data register holds an error code */
                 data = read_smic_data(smic);
                 if (data != 0) {
-                        if (smic_debug & SMIC_DEBUG_ENABLE) {
-                                printk(KERN_INFO
+                        if (smic_debug & SMIC_DEBUG_ENABLE)
+                                printk(KERN_DEBUG
                                        "SMIC_WRITE_END: data = %02x\n", data);
-                        }
                         start_error_recovery(smic,
                                              "state = SMIC_WRITE_END, "
                                              "data != SUCCESS");
                         return SI_SM_CALL_WITH_DELAY;
-                } else {
+                } else
                         smic->state = SMIC_WRITE2READ;
-                }
                 break;
 
         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) {
                         write_smic_control(smic, SMIC_CC_SMS_RD_START);
                         write_smic_flags(smic, flags | SMIC_FLAG_BSY);
                         smic->state = SMIC_READ_START;
-                } else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         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_flags(smic, flags | SMIC_FLAG_BSY);
                         smic->state = SMIC_READ_NEXT;
-                } else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_READ_NEXT:
                 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:
                         read_next_byte(smic);
                         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_flags(smic, flags | SMIC_FLAG_BSY);
                                 smic->state = SMIC_READ_NEXT;
-                        } else {
+                        } else
                                 return SI_SM_CALL_WITH_DELAY;
-                        }
                         break;
                 default:
                         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 register holds an error code */
                 if (data != 0) {
-                        if (smic_debug & SMIC_DEBUG_ENABLE) {
-                                printk(KERN_INFO
+                        if (smic_debug & SMIC_DEBUG_ENABLE)
+                                printk(KERN_DEBUG
                                        "SMIC_READ_END: data = %02x\n", data);
-                        }
                         start_error_recovery(smic,
                                              "state = SMIC_READ_END, "
                                              "data != SUCCESS");
@@ -565,7 +557,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
 
         default:
                 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");
                         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)
 {
-        /* It's impossible for the SMIC fnags 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 SMIC fnags 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_smic_flags(smic) == 0xff)
                 return 1;
 
@@ -595,8 +589,7 @@ static int smic_size(void)
         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,
         .start_transaction = start_smic_transaction,
         .get_result        = smic_get_result,