CTCM_FUNTAIL, dev->name, len);
                priv->stats.rx_dropped++;
                priv->stats.rx_length_errors++;
-                                               goto again;
+               goto again;
        }
        if (len > ch->max_bufsize) {
                CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
                                CTCM_FUNTAIL, dev->name, len, ch->max_bufsize);
                priv->stats.rx_dropped++;
                priv->stats.rx_length_errors++;
-                                               goto again;
+               goto again;
        }
 
        /*
                *((__u16 *)skb->data) = len;
                priv->stats.rx_dropped++;
                priv->stats.rx_length_errors++;
-                                               goto again;
+               goto again;
        }
        if (block_len > 2) {
                *((__u16 *)skb->data) = block_len - 2;
                        use gptr as mpc indicator */
                if (!(gptr && (fsm_getstate(gptr->fsm) != MPCG_STATE_READY)))
                        ctcm_chx_restart(fi, event, arg);
-                               goto done;
+               goto done;
        }
 
        CTCM_DBF_TEXT_(TRACE, CTC_DBF_DEBUG,
                                                CTCM_FUNTAIL, ch->id);
                        fsm_event(priv->fsm, DEV_EVENT_TXDOWN, dev);
                        ctcm_chx_restart(fi, event, arg);
-                               goto done;
+                       goto done;
                }
                fsm_addtimer(&ch->timer, 1000, CTC_EVENT_TIMER, ch);
                if (event == CTC_EVENT_TIMER) /* for TIMER not yet locked */
        if ((ch->collect_len <= 0) || (grp->in_sweep != 0)) {
                spin_unlock(&ch->collect_lock);
                fsm_newstate(fi, CTC_STATE_TXIDLE);
-                               goto done;
+               goto done;
        }
 
        if (ctcm_checkalloc_buffer(ch)) {
                spin_unlock(&ch->collect_lock);
-                               goto done;
+               goto done;
        }
        ch->trans_skb->data = ch->trans_skb_data;
        skb_reset_tail_pointer(ch->trans_skb);
                CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
                        "%s(%s): TRANS_SKB = NULL",
                                CTCM_FUNTAIL, dev->name);
-                       goto again;
+               goto again;
        }
 
        if (len < TH_HEADER_LENGTH) {
                                "%s(%s): skb allocation failed",
                                                CTCM_FUNTAIL, dev->name);
                        fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);
-                                       goto again;
+                       goto again;
                }
                switch (fsm_getstate(grp->fsm)) {
                case MPCG_STATE_RESET:
                skb_reset_tail_pointer(ch->trans_skb);
                ch->trans_skb->len = 0;
                ch->ccw[1].count = ch->max_bufsize;
-                       if (do_debug_ccw)
+               if (do_debug_ccw)
                        ctcmpc_dumpit((char *)&ch->ccw[0],
-                                       sizeof(struct ccw1) * 3);
+                                     sizeof(struct ccw1) * 3);
                dolock = !in_hardirq();
                if (dolock)
                        spin_lock_irqsave(
                if (rc != 0) {
                        fsm_newstate(fi, CTC_STATE_RXINIT);
                        ctcm_ccw_check_rc(ch, rc, "initial RX");
-                               goto done;
+                       goto done;
                }
                break;
        default:
                if (fsm_getstate(ch->fsm) == CH_XID0_INPROGRESS) {
                        fsm_newstate(ch->fsm, CH_XID0_PENDING) ;
                        fsm_deltimer(&grp->timer);
-                               goto done;
+                       goto done;
                }
                fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
-                               goto done;
+               goto done;
        case MPCG_STATE_XID2INITX:
                /* XID2 was received before ATTN Busy for second
                   channel.Send yside xid for second channel.
                /* give the previous IO time to complete */
                fsm_addtimer(&wch->sweep_timer,
                        200, CTC_EVENT_RSWEEP_TIMER, wch);
-                               goto done;
+               goto done;
        }
 
        skb = skb_dequeue(&wch->sweep_queue);
                ctcm_clear_busy_do(dev);
                dev_kfree_skb_any(skb);
                fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
-                               goto done;
+               goto done;
        } else {
                refcount_inc(&skb->users);
                skb_queue_tail(&wch->io_queue, skb);
 
                        ch->collect_len += l;
                }
                spin_unlock_irqrestore(&ch->collect_lock, saveflags);
-                               goto done;
+               goto done;
        }
        spin_unlock_irqrestore(&ch->collect_lock, saveflags);
        /*
                ch->collect_len += skb->len;
 
                spin_unlock_irqrestore(&ch->collect_lock, saveflags);
-                       goto done;
+               goto done;
        }
 
        /*
                        "%s(%s): NULL sk_buff passed",
                                        CTCM_FUNTAIL, dev->name);
                priv->stats.tx_dropped++;
-                                       goto done;
+               goto done;
        }
        if (skb_headroom(skb) < (TH_HEADER_LENGTH + PDU_HEADER_LENGTH)) {
                CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ERROR,
                        priv->stats.tx_errors++;
                        priv->stats.tx_carrier_errors++;
                        fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
-                                       goto done;
+                       goto done;
                }
                newskb->protocol = skb->protocol;
                skb_reserve(newskb, TH_HEADER_LENGTH + PDU_HEADER_LENGTH);
                priv->stats.tx_dropped++;
                priv->stats.tx_errors++;
                priv->stats.tx_carrier_errors++;
-                                       goto done;
+               goto done;
        }
 
        if (ctcm_test_and_set_busy(dev)) {
                priv->stats.tx_errors++;
                priv->stats.tx_carrier_errors++;
                fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
-                                       goto done;
+               goto done;
        }
 
        netif_trans_update(dev);
                priv->stats.tx_carrier_errors++;
                ctcm_clear_busy(dev);
                fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
-                                       goto done;
+               goto done;
        }
        ctcm_clear_busy(dev);
 done:
                                "%s (%s) already in list, using old entry",
                                __func__, (*c)->id);
 
-                               goto free_return;
+               goto free_return;
        }
 
        spin_lock_init(&ch->collect_lock);
 
                                grp->estconnfunc = NULL;
                        }
                        fsm_deltimer(&grp->timer);
-                               goto done;
+                       goto done;
                }
                if ((wch->in_mpcgroup) &&
                                (fsm_getstate(wch->fsm) == CH_XID0_PENDING))
                                grp->estconnfunc = NULL;
                        }
                        fsm_deltimer(&grp->timer);
-                               goto done;
+                       goto done;
                        }
                break;
        case MPCG_STATE_XID0IOWAIT:
                grp->estconnfunc(grp->port_num, 0,
                                    grp->group_max_buflen);
                grp->estconnfunc = NULL;
-       } else  if (grp->allochanfunc)
+       } else if (grp->allochanfunc) {
                grp->allochanfunc(grp->port_num, grp->group_max_buflen);
+       }
 
        grp->send_qllc_disc = 1;
        grp->changed_side = 0;
 
                                priv->stats.rx_dropped++;
                                priv->stats.rx_length_errors++;
-                                       goto done;
+                               goto done;
                        }
                        skb_reset_mac_header(pskb);
                        new_len = curr_pdu->pdu_offset;
                                                CTCM_FUNTAIL, dev->name);
                                priv->stats.rx_dropped++;
                                fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
-                                               goto done;
+                               goto done;
                        }
                        skb_put_data(skb, pskb->data, new_len);
 
                CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
                        "%s(%s): xid = NULL",
                                CTCM_FUNTAIL, ch->id);
-                       goto done;
+               goto done;
        }
 
        CTCM_D3_DUMP((char *)xid, XID2_LENGTH);
                CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
                        "%s(%s): r/w channel pairing mismatch",
                                CTCM_FUNTAIL, ch->id);
-                       goto done;
+               goto done;
        }
 
        if (xid->xid2_dlc_type == XID2_READ_SIDE) {