Input: HIL - cleanup coding style

Signed-off-by: Helge Deller <deller@gmx.de>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

1 files changed, 272 insertions, 215 deletions

diff --git a/drivers/input/serio/hil_mlc.c b/drivers/input/serio/hil_mlc.c
index 0710704d2fd..485b0742842 100644
--- a/drivers/input/serio/hil_mlc.c
+++ b/drivers/input/serio/hil_mlc.c
@@ -32,11 +32,11 @@
  *
  *      Driver theory of operation:
  *
- *      Some access methods and an ISR is defined by the sub-driver 
- *      (e.g. hp_sdc_mlc.c).  These methods are expected to provide a 
- *      few bits of logic in addition to raw access to the HIL MLC, 
- *      specifically, the ISR, which is entirely registered by the 
- *      sub-driver and invoked directly, must check for record 
+ *      Some access methods and an ISR is defined by the sub-driver
+ *      (e.g. hp_sdc_mlc.c).  These methods are expected to provide a
+ *      few bits of logic in addition to raw access to the HIL MLC,
+ *      specifically, the ISR, which is entirely registered by the
+ *      sub-driver and invoked directly, must check for record
  *      termination or packet match, at which point a semaphore must
  *      be cleared and then the hil_mlcs_tasklet must be scheduled.
  *
@@ -47,7 +47,7 @@
  *      itself if output is pending.  (This rescheduling should be replaced
  *      at some point with a sub-driver-specific mechanism.)
  *
- *      A timer task prods the tasklet once per second to prevent 
+ *      A timer task prods the tasklet once per second to prevent
  *      hangups when attached devices do not return expected data
  *      and to initiate probes of the loop for new devices.
  */
@@ -83,69 +83,85 @@ DECLARE_TASKLET_DISABLED(hil_mlcs_tasklet, hil_mlcs_process, 0);
 
 /********************** Device info/instance management **********************/
 
-static void hil_mlc_clear_di_map (hil_mlc *mlc, int val) {
+static void hil_mlc_clear_di_map(hil_mlc *mlc, int val)
+{
         int j;
-        for (j = val; j < 7 ; j++) {
+
+        for (j = val; j < 7 ; j++)
                 mlc->di_map[j] = -1;
-        }
 }
 
-static void hil_mlc_clear_di_scratch (hil_mlc *mlc) {
-        memset(&(mlc->di_scratch), 0, sizeof(mlc->di_scratch));
+static void hil_mlc_clear_di_scratch(hil_mlc *mlc)
+{
+        memset(&mlc->di_scratch, 0, sizeof(mlc->di_scratch));
 }
 
-static void hil_mlc_copy_di_scratch (hil_mlc *mlc, int idx) {
-        memcpy(&(mlc->di[idx]), &(mlc->di_scratch), sizeof(mlc->di_scratch));
+static void hil_mlc_copy_di_scratch(hil_mlc *mlc, int idx)
+{
+        memcpy(&mlc->di[idx], &mlc->di_scratch, sizeof(mlc->di_scratch));
 }
 
-static int hil_mlc_match_di_scratch (hil_mlc *mlc) {
+static int hil_mlc_match_di_scratch(hil_mlc *mlc)
+{
         int idx;
 
         for (idx = 0; idx < HIL_MLC_DEVMEM; idx++) {
-                int j, found;
+                int j, found = 0;
 
                 /* In-use slots are not eligible. */
-                found = 0;
-                for (j = 0; j < 7 ; j++) {
-                        if (mlc->di_map[j] == idx) found++;
-                }
-                if (found) continue;
-                if (!memcmp(mlc->di + idx, 
-                            &(mlc->di_scratch), 
-                            sizeof(mlc->di_scratch))) break;
+                for (j = 0; j < 7 ; j++)
+                        if (mlc->di_map[j] == idx)
+                                found++;
+
+                if (found)
+                        continue;
+
+                if (!memcmp(mlc->di + idx, &mlc->di_scratch,
+                                sizeof(mlc->di_scratch)))
+                        break;
         }
-        return((idx >= HIL_MLC_DEVMEM) ? -1 : idx);
+        return idx >= HIL_MLC_DEVMEM ? -1 : idx;
 }
 
-static int hil_mlc_find_free_di(hil_mlc *mlc) {
+static int hil_mlc_find_free_di(hil_mlc *mlc)
+{
         int idx;
-        /* TODO: Pick all-zero slots first, failing that, 
-         * randomize the slot picked among those eligible. 
+
+        /* TODO: Pick all-zero slots first, failing that,
+         * randomize the slot picked among those eligible.
          */
         for (idx = 0; idx < HIL_MLC_DEVMEM; idx++) {
-                int j, found;
-                found = 0;
-                for (j = 0; j < 7 ; j++) {
-                        if (mlc->di_map[j] == idx) found++;
-                }
-                if (!found) break;
+                int j, found = 0;
+
+                for (j = 0; j < 7 ; j++)
+                        if (mlc->di_map[j] == idx)
+                                found++;
+
+                if (!found)
+                        break;
         }
-        return(idx); /* Note: It is guaranteed at least one above will match */
+
+        return idx; /* Note: It is guaranteed at least one above will match */
 }
 
-static inline void hil_mlc_clean_serio_map(hil_mlc *mlc) {
+static inline void hil_mlc_clean_serio_map(hil_mlc *mlc)
+{
         int idx;
+
         for (idx = 0; idx < HIL_MLC_DEVMEM; idx++) {
-                int j, found;
-                found = 0;
-                for (j = 0; j < 7 ; j++) {
-                        if (mlc->di_map[j] == idx) found++;
-                }
-                if (!found) mlc->serio_map[idx].di_revmap = -1;
+                int j, found = 0;
+
+                for (j = 0; j < 7 ; j++)
+                        if (mlc->di_map[j] == idx)
+                                found++;
+
+                if (!found)
+                        mlc->serio_map[idx].di_revmap = -1;
         }
 }
 
-static void hil_mlc_send_polls(hil_mlc *mlc) {
+static void hil_mlc_send_polls(hil_mlc *mlc)
+{
         int did, i, cnt;
         struct serio *serio;
         struct serio_driver *drv;
@@ -157,26 +173,31 @@ static void hil_mlc_send_polls(hil_mlc *mlc) {
 
         while (mlc->icount < 15 - i) {
                 hil_packet p;
+
                 p = mlc->ipacket[i];
                 if (did != (p & HIL_PKT_ADDR_MASK) >> 8) {
-                        if (drv == NULL || drv->interrupt == NULL) goto skip;
+                        if (drv && drv->interrupt) {
+                                drv->interrupt(serio, 0, 0);
+                                drv->interrupt(serio, HIL_ERR_INT >> 16, 0);
+                                drv->interrupt(serio, HIL_PKT_CMD >> 8,  0);
+                                drv->interrupt(serio, HIL_CMD_POL + cnt, 0);
+                        }
 
-                        drv->interrupt(serio, 0, 0);
-                        drv->interrupt(serio, HIL_ERR_INT >> 16, 0);
-                        drv->interrupt(serio, HIL_PKT_CMD >> 8,  0);
-                        drv->interrupt(serio, HIL_CMD_POL + cnt, 0);
-                skip:
                         did = (p & HIL_PKT_ADDR_MASK) >> 8;
                         serio = did ? mlc->serio[mlc->di_map[did-1]] : NULL;
                         drv = (serio != NULL) ? serio->drv : NULL;
                         cnt = 0;
                 }
-                cnt++; i++;
-                if (drv == NULL || drv->interrupt == NULL) continue;
-                drv->interrupt(serio, (p >> 24), 0);
-                drv->interrupt(serio, (p >> 16) & 0xff, 0);
-                drv->interrupt(serio, (p >> 8) & ~HIL_PKT_ADDR_MASK, 0);
-                drv->interrupt(serio, p & 0xff, 0);
+
+                cnt++;
+                i++;
+
+                if (drv && drv->interrupt) {
+                        drv->interrupt(serio, (p >> 24), 0);
+                        drv->interrupt(serio, (p >> 16) & 0xff, 0);
+                        drv->interrupt(serio, (p >> 8) & ~HIL_PKT_ADDR_MASK, 0);
+                        drv->interrupt(serio, p & 0xff, 0);
+                }
         }
 }
 
@@ -215,12 +236,16 @@ static void hil_mlc_send_polls(hil_mlc *mlc) {
 #define HILSEN_DOZE     (HILSEN_SAME | HILSEN_SCHED | HILSEN_BREAK)
 #define HILSEN_SLEEP    (HILSEN_SAME | HILSEN_BREAK)
 
-static int hilse_match(hil_mlc *mlc, int unused) {
+static int hilse_match(hil_mlc *mlc, int unused)
+{
         int rc;
+
         rc = hil_mlc_match_di_scratch(mlc);
         if (rc == -1) {
                 rc = hil_mlc_find_free_di(mlc);
-                if (rc == -1) goto err;
+                if (rc == -1)
+                        goto err;
+
 #ifdef HIL_MLC_DEBUG
                 printk(KERN_DEBUG PREFIX "new in slot %i\n", rc);
 #endif
@@ -231,6 +256,7 @@ static int hilse_match(hil_mlc *mlc, int unused) {
                 serio_rescan(mlc->serio[rc]);
                 return -1;
         }
+
         mlc->di_map[mlc->ddi] = rc;
 #ifdef HIL_MLC_DEBUG
         printk(KERN_DEBUG PREFIX "same in slot %i\n", rc);
@@ -238,152 +264,177 @@ static int hilse_match(hil_mlc *mlc, int unused) {
         mlc->serio_map[rc].di_revmap = mlc->ddi;
         hil_mlc_clean_serio_map(mlc);
         return 0;
+
  err:
         printk(KERN_ERR PREFIX "Residual device slots exhausted, close some serios!\n");
         return 1;
 }
 
 /* An LCV used to prevent runaway loops, forces 5 second sleep when reset. */
-static int hilse_init_lcv(hil_mlc *mlc, int unused) {
+static int hilse_init_lcv(hil_mlc *mlc, int unused)
+{
         struct timeval tv;
 
         do_gettimeofday(&tv);
 
-        if(mlc->lcv == 0) goto restart;  /* First init, no need to dally */
-        if(tv.tv_sec - mlc->lcv_tv.tv_sec < 5) return -1;
- restart:
+        if (mlc->lcv && (tv.tv_sec - mlc->lcv_tv.tv_sec) < 5)
+                return -1;
+
         mlc->lcv_tv = tv;
         mlc->lcv = 0;
+
         return 0;
 }
 
-static int hilse_inc_lcv(hil_mlc *mlc, int lim) {
-        if (mlc->lcv++ >= lim) return -1;
-        return 0;
+static int hilse_inc_lcv(hil_mlc *mlc, int lim)
+{
+        return mlc->lcv++ >= lim ? -1 : 0;
 }
 
 #if 0
-static int hilse_set_lcv(hil_mlc *mlc, int val) {
+static int hilse_set_lcv(hil_mlc *mlc, int val)
+{
         mlc->lcv = val;
+
         return 0;
 }
 #endif
 
 /* Management of the discovered device index (zero based, -1 means no devs) */
-static int hilse_set_ddi(hil_mlc *mlc, int val) {
+static int hilse_set_ddi(hil_mlc *mlc, int val)
+{
         mlc->ddi = val;
         hil_mlc_clear_di_map(mlc, val + 1);
+
         return 0;
 }
 
-static int hilse_dec_ddi(hil_mlc *mlc, int unused) {
+static int hilse_dec_ddi(hil_mlc *mlc, int unused)
+{
         mlc->ddi--;
-        if (mlc->ddi <= -1) { 
+        if (mlc->ddi <= -1) {
                 mlc->ddi = -1;
                 hil_mlc_clear_di_map(mlc, 0);
                 return -1;
         }
         hil_mlc_clear_di_map(mlc, mlc->ddi + 1);
+
         return 0;
 }
 
-static int hilse_inc_ddi(hil_mlc *mlc, int unused) {
-        if (mlc->ddi >= 6) {
-                BUG();
-                return -1;
-        }
+static int hilse_inc_ddi(hil_mlc *mlc, int unused)
+{
+        BUG_ON(mlc->ddi >= 6);
         mlc->ddi++;
+
         return 0;
 }
 
-static int hilse_take_idd(hil_mlc *mlc, int unused) {
+static int hilse_take_idd(hil_mlc *mlc, int unused)
+{
         int i;
 
-        /* Help the state engine: 
-         * Is this a real IDD response or just an echo? 
+        /* Help the state engine:
+         * Is this a real IDD response or just an echo?
          *
-         * Real IDD response does not start with a command. 
+         * Real IDD response does not start with a command.
          */
-        if (mlc->ipacket[0] & HIL_PKT_CMD) goto bail;
+        if (mlc->ipacket[0] & HIL_PKT_CMD)
+                goto bail;
+
         /* Should have the command echoed further down. */
         for (i = 1; i < 16; i++) {
-                if (((mlc->ipacket[i] & HIL_PKT_ADDR_MASK) == 
+                if (((mlc->ipacket[i] & HIL_PKT_ADDR_MASK) ==
                      (mlc->ipacket[0] & HIL_PKT_ADDR_MASK)) &&
-                    (mlc->ipacket[i] & HIL_PKT_CMD) && 
+                    (mlc->ipacket[i] & HIL_PKT_CMD) &&
                     ((mlc->ipacket[i] & HIL_PKT_DATA_MASK) == HIL_CMD_IDD))
                         break;
         }
-        if (i > 15) goto bail;
+        if (i > 15)
+                goto bail;
+
         /* And the rest of the packets should still be clear. */
-        while (++i < 16) {
-                if (mlc->ipacket[i]) break;
-        }
-        if (i < 16) goto bail;
-        for (i = 0; i < 16; i++) {
-                mlc->di_scratch.idd[i] = 
+        while (++i < 16)
+                if (mlc->ipacket[i])
+                        break;
+
+        if (i < 16)
+                goto bail;
+
+        for (i = 0; i < 16; i++)
+                mlc->di_scratch.idd[i] =
                         mlc->ipacket[i] & HIL_PKT_DATA_MASK;
-        }
+
         /* Next step is to see if RSC supported */
-        if (mlc->di_scratch.idd[1] & HIL_IDD_HEADER_RSC) 
+        if (mlc->di_scratch.idd[1] & HIL_IDD_HEADER_RSC)
                 return HILSEN_NEXT;
-        if (mlc->di_scratch.idd[1] & HIL_IDD_HEADER_EXD) 
+
+        if (mlc->di_scratch.idd[1] & HIL_IDD_HEADER_EXD)
                 return HILSEN_DOWN | 4;
+
         return 0;
+
  bail:
         mlc->ddi--;
+
         return -1; /* This should send us off to ACF */
 }
 
-static int hilse_take_rsc(hil_mlc *mlc, int unused) {
+static int hilse_take_rsc(hil_mlc *mlc, int unused)
+{
         int i;
 
-        for (i = 0; i < 16; i++) {
-                mlc->di_scratch.rsc[i] = 
+        for (i = 0; i < 16; i++)
+                mlc->di_scratch.rsc[i] =
                         mlc->ipacket[i] & HIL_PKT_DATA_MASK;
-        }
+
         /* Next step is to see if EXD supported (IDD has already been read) */
-        if (mlc->di_scratch.idd[1] & HIL_IDD_HEADER_EXD) 
+        if (mlc->di_scratch.idd[1] & HIL_IDD_HEADER_EXD)
                 return HILSEN_NEXT;
+
         return 0;
 }
 
-static int hilse_take_exd(hil_mlc *mlc, int unused) {
+static int hilse_take_exd(hil_mlc *mlc, int unused)
+{
         int i;
 
-        for (i = 0; i < 16; i++) {
-                mlc->di_scratch.exd[i] = 
+        for (i = 0; i < 16; i++)
+                mlc->di_scratch.exd[i] =
                         mlc->ipacket[i] & HIL_PKT_DATA_MASK;
-        }
+
         /* Next step is to see if RNM supported. */
-        if (mlc->di_scratch.exd[0] & HIL_EXD_HEADER_RNM) 
+        if (mlc->di_scratch.exd[0] & HIL_EXD_HEADER_RNM)
                 return HILSEN_NEXT;
+
         return 0;
 }
 
-static int hilse_take_rnm(hil_mlc *mlc, int unused) {
+static int hilse_take_rnm(hil_mlc *mlc, int unused)
+{
         int i;
 
-        for (i = 0; i < 16; i++) {
-                mlc->di_scratch.rnm[i] = 
+        for (i = 0; i < 16; i++)
+                mlc->di_scratch.rnm[i] =
                         mlc->ipacket[i] & HIL_PKT_DATA_MASK;
-        }
-        do {
-          char nam[17];
-          snprintf(nam, 16, "%s", mlc->di_scratch.rnm);
-          nam[16] = '\0';
-          printk(KERN_INFO PREFIX "Device name gotten: %s\n", nam);
-        } while (0);
+
+        printk(KERN_INFO PREFIX "Device name gotten: %16s\n",
+                        mlc->di_scratch.rnm);
+
         return 0;
 }
 
-static int hilse_operate(hil_mlc *mlc, int repoll) { 
+static int hilse_operate(hil_mlc *mlc, int repoll)
+{
 
-        if (mlc->opercnt == 0) hil_mlcs_probe = 0;
+        if (mlc->opercnt == 0)
+                hil_mlcs_probe = 0;
         mlc->opercnt = 1;
 
         hil_mlc_send_polls(mlc);
 
-        if (!hil_mlcs_probe) return 0;
+        if (!hil_mlcs_probe)
+                return 0;
         hil_mlcs_probe = 0;
         mlc->opercnt = 0;
         return 1;
@@ -428,7 +479,7 @@ const struct hilse_node hil_mlc_se[HILSEN_END] = {
         EXPECT(HIL_ERR_INT | TEST_PACKET(0xa),
                2000,            HILSEN_NEXT,    HILSEN_RESTART, HILSEN_RESTART)
         OUT(HIL_CTRL_ONLY | 0)                  /* Disable test mode */
-        
+
         /* 9  HILSEN_DHR */
         FUNC(hilse_init_lcv, 0, HILSEN_NEXT,    HILSEN_SLEEP,   0)
 
@@ -439,7 +490,7 @@ const struct hilse_node hil_mlc_se[HILSEN_END] = {
         IN(300000,              HILSEN_DHR2,    HILSEN_DHR2,    HILSEN_NEXT)
 
         /* 14 HILSEN_IFC */
-        OUT(HIL_PKT_CMD | HIL_CMD_IFC)
+        OUT(HIL_PKT_CMD | HIL_CMD_IFC)
         EXPECT(HIL_PKT_CMD | HIL_CMD_IFC | HIL_ERR_INT,
                20000,           HILSEN_DISC,    HILSEN_DHR2,    HILSEN_NEXT )
 
@@ -455,7 +506,7 @@ const struct hilse_node hil_mlc_se[HILSEN_END] = {
 
         /* 18 HILSEN_HEAL */
         OUT_LAST(HIL_CMD_ELB)
-        EXPECT_LAST(HIL_CMD_ELB | HIL_ERR_INT, 
+        EXPECT_LAST(HIL_CMD_ELB | HIL_ERR_INT,
                     20000,      HILSEN_REPOLL,  HILSEN_DSR,     HILSEN_NEXT)
         FUNC(hilse_dec_ddi, 0,  HILSEN_HEAL,    HILSEN_NEXT,    0)
 
@@ -503,7 +554,7 @@ const struct hilse_node hil_mlc_se[HILSEN_END] = {
 
         /* 44 HILSEN_PROBE */
         OUT_LAST(HIL_PKT_CMD | HIL_CMD_EPT)
-        IN(10000,               HILSEN_DISC,    HILSEN_DSR,     HILSEN_NEXT)
+        IN(10000,               HILSEN_DISC,    HILSEN_DSR,     HILSEN_NEXT)
         OUT_DISC(HIL_PKT_CMD | HIL_CMD_ELB)
         IN(10000,               HILSEN_DISC,    HILSEN_DSR,     HILSEN_NEXT)
         OUT(HIL_PKT_CMD | HIL_CMD_ACF | 1)
@@ -514,7 +565,7 @@ const struct hilse_node hil_mlc_se[HILSEN_END] = {
         /* 52 HILSEN_DSR */
         FUNC(hilse_set_ddi, -1, HILSEN_NEXT,    0,              0)
         OUT(HIL_PKT_CMD | HIL_CMD_DSR)
-        IN(20000,               HILSEN_DHR,     HILSEN_DHR,     HILSEN_IFC)
+        IN(20000,               HILSEN_DHR,     HILSEN_DHR,     HILSEN_IFC)
 
         /* 55 HILSEN_REPOLL */
         OUT(HIL_PKT_CMD | HIL_CMD_RPL)
@@ -523,14 +574,15 @@ const struct hilse_node hil_mlc_se[HILSEN_END] = {
         FUNC(hilse_operate, 1,  HILSEN_OPERATE, HILSEN_IFC,     HILSEN_PROBE)
 
         /* 58 HILSEN_IFCACF */
-        OUT(HIL_PKT_CMD | HIL_CMD_IFC)
+        OUT(HIL_PKT_CMD | HIL_CMD_IFC)
         EXPECT(HIL_PKT_CMD | HIL_CMD_IFC | HIL_ERR_INT,
                20000,           HILSEN_ACF2,    HILSEN_DHR2,    HILSEN_HEAL)
 
         /* 60 HILSEN_END */
 };
 
-static inline void hilse_setup_input(hil_mlc *mlc, const struct hilse_node *node) {
+static inline void hilse_setup_input(hil_mlc *mlc, const struct hilse_node *node)
+{
 
         switch (node->act) {
         case HILSE_EXPECT_DISC:
@@ -555,25 +607,25 @@ static inline void hilse_setup_input(hil_mlc *mlc, const struct hilse_node *node
         do_gettimeofday(&(mlc->instart));
         mlc->icount = 15;
         memset(mlc->ipacket, 0, 16 * sizeof(hil_packet));
-        BUG_ON(down_trylock(&(mlc->isem)));
-
-        return;
+        BUG_ON(down_trylock(&mlc->isem));
 }
 
 #ifdef HIL_MLC_DEBUG
-static int doze = 0;
+static int doze;
 static int seidx; /* For debug */
 #endif
 
-static int hilse_donode (hil_mlc *mlc) {
+static int hilse_donode(hil_mlc *mlc)
+{
         const struct hilse_node *node;
         int nextidx = 0;
         int sched_long = 0;
         unsigned long flags;
 
 #ifdef HIL_MLC_DEBUG
-        if (mlc->seidx && (mlc->seidx != seidx)  && mlc->seidx != 41 && mlc->seidx != 42 && mlc->seidx != 43) {
-          printk(KERN_DEBUG PREFIX "z%i \n {%i}", doze, mlc->seidx);
+        if (mlc->seidx && mlc->seidx != seidx &&
+            mlc->seidx != 41 && mlc->seidx != 42 && mlc->seidx != 43) {
+                printk(KERN_DEBUG PREFIX "z%i \n {%i}", doze, mlc->seidx);
                 doze = 0;
         }
 
@@ -588,50 +640,59 @@ static int hilse_donode (hil_mlc *mlc) {
         case HILSE_FUNC:
                 BUG_ON(node->object.func == NULL);
                 rc = node->object.func(mlc, node->arg);
-                nextidx = (rc > 0) ? node->ugly : 
+                nextidx = (rc > 0) ? node->ugly :
                         ((rc < 0) ? node->bad : node->good);
-                if (nextidx == HILSEN_FOLLOW) nextidx = rc;
+                if (nextidx == HILSEN_FOLLOW)
+                        nextidx = rc;
                 break;
+
         case HILSE_EXPECT_LAST:
         case HILSE_EXPECT_DISC:
         case HILSE_EXPECT:
         case HILSE_IN:
                 /* Already set up from previous HILSE_OUT_* */
-                write_lock_irqsave(&(mlc->lock), flags);
+                write_lock_irqsave(&mlc->lock, flags);
                 rc = mlc->in(mlc, node->arg);
                 if (rc == 2)  {
                         nextidx = HILSEN_DOZE;
                         sched_long = 1;
-                        write_unlock_irqrestore(&(mlc->lock), flags);
+                        write_unlock_irqrestore(&mlc->lock, flags);
                         break;
                 }
-                if (rc == 1)            nextidx = node->ugly;
-                else if (rc == 0)       nextidx = node->good;
-                else                    nextidx = node->bad;
+                if (rc == 1)
+                        nextidx = node->ugly;
+                else if (rc == 0)
+                        nextidx = node->good;
+                else
+                        nextidx = node->bad;
                 mlc->istarted = 0;
-                write_unlock_irqrestore(&(mlc->lock), flags);
+                write_unlock_irqrestore(&mlc->lock, flags);
                 break;
+
         case HILSE_OUT_LAST:
-                write_lock_irqsave(&(mlc->lock), flags);
+                write_lock_irqsave(&mlc->lock, flags);
                 pack = node->object.packet;
                 pack |= ((mlc->ddi + 1) << HIL_PKT_ADDR_SHIFT);
                 goto out;
+
         case HILSE_OUT_DISC:
-                write_lock_irqsave(&(mlc->lock), flags);
+                write_lock_irqsave(&mlc->lock, flags);
                 pack = node->object.packet;
                 pack |= ((mlc->ddi + 2) << HIL_PKT_ADDR_SHIFT);
                 goto out;
+
         case HILSE_OUT:
-                write_lock_irqsave(&(mlc->lock), flags);
+                write_lock_irqsave(&mlc->lock, flags);
                 pack = node->object.packet;
         out:
-                if (mlc->istarted) goto out2;
+                if (mlc->istarted)
+                        goto out2;
                 /* Prepare to receive input */
                 if ((node + 1)->act & HILSE_IN)
                         hilse_setup_input(mlc, node + 1);
 
         out2:
-                write_unlock_irqrestore(&(mlc->lock), flags);
+                write_unlock_irqrestore(&mlc->lock, flags);
 
                 if (down_trylock(&mlc->osem)) {
                         nextidx = HILSEN_DOZE;
@@ -639,37 +700,39 @@ static int hilse_donode (hil_mlc *mlc) {
                 }
                 up(&mlc->osem);
 
-                write_lock_irqsave(&(mlc->lock), flags);
-                if (!(mlc->ostarted)) {
+                write_lock_irqsave(&mlc->lock, flags);
+                if (!mlc->ostarted) {
                         mlc->ostarted = 1;
                         mlc->opacket = pack;
                         mlc->out(mlc);
                         nextidx = HILSEN_DOZE;
-                        write_unlock_irqrestore(&(mlc->lock), flags);
+                        write_unlock_irqrestore(&mlc->lock, flags);
                         break;
                 }
                 mlc->ostarted = 0;
                 do_gettimeofday(&(mlc->instart));
-                write_unlock_irqrestore(&(mlc->lock), flags);
+                write_unlock_irqrestore(&mlc->lock, flags);
                 nextidx = HILSEN_NEXT;
                 break;
+
         case HILSE_CTS:
                 nextidx = mlc->cts(mlc) ? node->bad : node->good;
                 break;
+
         default:
                 BUG();
-                nextidx = 0;
-                break;
         }
 
 #ifdef HIL_MLC_DEBUG
-        if (nextidx == HILSEN_DOZE) doze++;
+        if (nextidx == HILSEN_DOZE)
+                doze++;
 #endif
 
         while (nextidx & HILSEN_SCHED) {
                 struct timeval tv;
 
-                if (!sched_long) goto sched;
+                if (!sched_long)
+                        goto sched;
 
                 do_gettimeofday(&tv);
                 tv.tv_usec += USEC_PER_SEC * (tv.tv_sec - mlc->instart.tv_sec);
@@ -682,17 +745,24 @@ static int hilse_donode (hil_mlc *mlc) {
         sched:
                 tasklet_schedule(&hil_mlcs_tasklet);
                 break;
-        } 
-        if (nextidx & HILSEN_DOWN) mlc->seidx += nextidx & HILSEN_MASK;
-        else if (nextidx & HILSEN_UP) mlc->seidx -= nextidx & HILSEN_MASK;
-        else mlc->seidx = nextidx & HILSEN_MASK;
+        }
+
+        if (nextidx & HILSEN_DOWN)
+                mlc->seidx += nextidx & HILSEN_MASK;
+        else if (nextidx & HILSEN_UP)
+                mlc->seidx -= nextidx & HILSEN_MASK;
+        else
+                mlc->seidx = nextidx & HILSEN_MASK;
+
+        if (nextidx & HILSEN_BREAK)
+                return 1;
 
-        if (nextidx & HILSEN_BREAK)     return 1;
         return 0;
 }
 
 /******************** tasklet context functions **************************/
-static void hil_mlcs_process(unsigned long unused) {
+static void hil_mlcs_process(unsigned long unused)
+{
         struct list_head *tmp;
 
         read_lock(&hil_mlcs_lock);
@@ -700,19 +770,20 @@ static void hil_mlcs_process(unsigned long unused) {
                 struct hil_mlc *mlc = list_entry(tmp, hil_mlc, list);
                 while (hilse_donode(mlc) == 0) {
 #ifdef HIL_MLC_DEBUG
-                  if (mlc->seidx != 41 && 
-                      mlc->seidx != 42 && 
-                      mlc->seidx != 43) 
-                    printk(KERN_DEBUG PREFIX " + ");
+                        if (mlc->seidx != 41 &&
+                            mlc->seidx != 42 &&
+                            mlc->seidx != 43)
+                                printk(KERN_DEBUG PREFIX " + ");
 #endif
-                };
+                }
         }
         read_unlock(&hil_mlcs_lock);
 }
 
 /************************* Keepalive timer task *********************/
 
-void hil_mlcs_timer (unsigned long data) {
+void hil_mlcs_timer(unsigned long data)
+{
         hil_mlcs_probe = 1;
         tasklet_schedule(&hil_mlcs_tasklet);
         /* Re-insert the periodic task. */
@@ -722,28 +793,25 @@ void hil_mlcs_timer (unsigned long data) {
 
 /******************** user/kernel context functions **********************/
 
-static int hil_mlc_serio_write(struct serio *serio, unsigned char c) {
+static int hil_mlc_serio_write(struct serio *serio, unsigned char c)
+{
         struct hil_mlc_serio_map *map;
         struct hil_mlc *mlc;
         struct serio_driver *drv;
         uint8_t *idx, *last;
 
         map = serio->port_data;
-        if (map == NULL) {
-                BUG();
-                return -EIO;
-        }
+        BUG_ON(map == NULL);
+
         mlc = map->mlc;
-        if (mlc == NULL) {
-                BUG();
-                return -EIO;
-        }
-        mlc->serio_opacket[map->didx] |= 
+        BUG_ON(mlc == NULL);
+
+        mlc->serio_opacket[map->didx] |=
                 ((hil_packet)c) << (8 * (3 - mlc->serio_oidx[map->didx]));
 
         if (mlc->serio_oidx[map->didx] >= 3) {
                 /* for now only commands */
-                if (!(mlc->serio_opacket[map->didx] & HIL_PKT_CMD)) 
+                if (!(mlc->serio_opacket[map->didx] & HIL_PKT_CMD))
                         return -EIO;
                 switch (mlc->serio_opacket[map->didx] & HIL_PKT_DATA_MASK) {
                 case HIL_CMD_IDD:
@@ -769,12 +837,11 @@ static int hil_mlc_serio_write(struct serio *serio, unsigned char c) {
         return -EIO;
  emu:
         drv = serio->drv;
-        if (drv == NULL) {
-                BUG();
-                return -EIO;
-        }
+        BUG_ON(drv == NULL);
+
         last = idx + 15;
-        while ((last != idx) && (*last == 0)) last--;
+        while ((last != idx) && (*last == 0))
+                last--;
 
         while (idx != last) {
                 drv->interrupt(serio, 0, 0);
@@ -787,14 +854,15 @@ static int hil_mlc_serio_write(struct serio *serio, unsigned char c) {
         drv->interrupt(serio, HIL_ERR_INT >> 16, 0);
         drv->interrupt(serio, HIL_PKT_CMD >> 8, 0);
         drv->interrupt(serio, *idx, 0);
-        
+
         mlc->serio_oidx[map->didx] = 0;
         mlc->serio_opacket[map->didx] = 0;
 
         return 0;
 }
 
-static int hil_mlc_serio_open(struct serio *serio) {
+static int hil_mlc_serio_open(struct serio *serio)
+{
         struct hil_mlc_serio_map *map;
         struct hil_mlc *mlc;
 
@@ -802,33 +870,24 @@ static int hil_mlc_serio_open(struct serio *serio) {
                 return -EBUSY;
 
         map = serio->port_data;
-        if (map == NULL) {
-                BUG();
-                return -ENODEV;
-        }
+        BUG_ON(map == NULL);
+
         mlc = map->mlc;
-        if (mlc == NULL) {
-                BUG();
-                return -ENODEV;
-        }
+        BUG_ON(mlc == NULL);
 
         return 0;
 }
 
-static void hil_mlc_serio_close(struct serio *serio) {
+static void hil_mlc_serio_close(struct serio *serio)
+{
         struct hil_mlc_serio_map *map;
         struct hil_mlc *mlc;
 
         map = serio->port_data;
-        if (map == NULL) {
-                BUG();
-                return;
-        }
+        BUG_ON(map == NULL);
+
         mlc = map->mlc;
-        if (mlc == NULL) {
-                BUG();
-                return;
-        }
+        BUG_ON(mlc == NULL);
 
         serio_set_drvdata(serio, NULL);
         serio->drv = NULL;
@@ -842,27 +901,26 @@ static const struct serio_device_id hil_mlc_serio_id = {
         .id = SERIO_ANY,
 };
 
-int hil_mlc_register(hil_mlc *mlc) {
+int hil_mlc_register(hil_mlc *mlc)
+{
         int i;
-        unsigned long flags;
+        unsigned long flags;
 
-        if (mlc == NULL) {
-                return -EINVAL;
-        }
+        BUG_ON(mlc == NULL);
 
         mlc->istarted = 0;
-        mlc->ostarted = 0;
+        mlc->ostarted = 0;
 
-        rwlock_init(&mlc->lock);
-        init_MUTEX(&(mlc->osem));
+        rwlock_init(&mlc->lock);
+        init_MUTEX(&mlc->osem);
 
-        init_MUTEX(&(mlc->isem));
-        mlc->icount = -1;
-        mlc->imatch = 0;
+        init_MUTEX(&mlc->isem);
+        mlc->icount = -1;
+        mlc->imatch = 0;
 
         mlc->opercnt = 0;
 
-        init_MUTEX_LOCKED(&(mlc->csem));
+        init_MUTEX_LOCKED(&(mlc->csem));
 
         hil_mlc_clear_di_scratch(mlc);
         hil_mlc_clear_di_map(mlc, 0);
@@ -897,19 +955,18 @@ int hil_mlc_register(hil_mlc *mlc) {
         return 0;
 }
 
-int hil_mlc_unregister(hil_mlc *mlc) {
+int hil_mlc_unregister(hil_mlc *mlc)
+{
         struct list_head *tmp;
-        unsigned long flags;
+        unsigned long flags;
         int i;
 
-        if (mlc == NULL)
-                return -EINVAL;
+        BUG_ON(mlc == NULL);
 
         write_lock_irqsave(&hil_mlcs_lock, flags);
-        list_for_each(tmp, &hil_mlcs) {
+        list_for_each(tmp, &hil_mlcs)
                 if (list_entry(tmp, hil_mlc, list) == mlc)
                         goto found;
-        }
 
         /* not found in list */
         write_unlock_irqrestore(&hil_mlcs_lock, flags);
@@ -918,7 +975,7 @@ int hil_mlc_unregister(hil_mlc *mlc) {
 
  found:
         list_del(tmp);
-        write_unlock_irqrestore(&hil_mlcs_lock, flags);
+        write_unlock_irqrestore(&hil_mlcs_lock, flags);
 
         for (i = 0; i < HIL_MLC_DEVMEM; i++) {
                 serio_unregister_port(mlc->serio[i]);
@@ -942,7 +999,7 @@ static int __init hil_mlc_init(void)
 
         return 0;
 }
-                
+
 static void __exit hil_mlc_exit(void)
 {
         del_timer(&hil_mlcs_kicker);
@@ -950,6 +1007,6 @@ static void __exit hil_mlc_exit(void)
         tasklet_disable(&hil_mlcs_tasklet);
         tasklet_kill(&hil_mlcs_tasklet);
 }
-                        
+
 module_init(hil_mlc_init);
 module_exit(hil_mlc_exit);