HFC_outb_pcimem(struct hfc_multi *hc, u_char reg, u_char val)
 #endif
 {
-       writeb(val, (hc->pci_membase)+reg);
+       writeb(val, hc->pci_membase + reg);
 }
 static u_char
 #ifdef HFC_REGISTER_DEBUG
 HFC_inb_pcimem(struct hfc_multi *hc, u_char reg)
 #endif
 {
-       return readb((hc->pci_membase)+reg);
+       return readb(hc->pci_membase + reg);
 }
 static u_short
 #ifdef HFC_REGISTER_DEBUG
 HFC_inw_pcimem(struct hfc_multi *hc, u_char reg)
 #endif
 {
-       return readw((hc->pci_membase)+reg);
+       return readw(hc->pci_membase + reg);
 }
 static void
 #ifdef HFC_REGISTER_DEBUG
 HFC_wait_pcimem(struct hfc_multi *hc)
 #endif
 {
-       while (readb((hc->pci_membase)+R_STATUS) & V_BUSY);
+       while (readb(hc->pci_membase + R_STATUS) & V_BUSY)
+               cpu_relax();
 }
 
 /* HFC_IO_MODE_REGIO */
 HFC_outb_regio(struct hfc_multi *hc, u_char reg, u_char val)
 #endif
 {
-       outb(reg, (hc->pci_iobase)+4);
+       outb(reg, hc->pci_iobase + 4);
        outb(val, hc->pci_iobase);
 }
 static u_char
 HFC_inb_regio(struct hfc_multi *hc, u_char reg)
 #endif
 {
-       outb(reg, (hc->pci_iobase)+4);
+       outb(reg, hc->pci_iobase + 4);
        return inb(hc->pci_iobase);
 }
 static u_short
 HFC_inw_regio(struct hfc_multi *hc, u_char reg)
 #endif
 {
-       outb(reg, (hc->pci_iobase)+4);
+       outb(reg, hc->pci_iobase + 4);
        return inw(hc->pci_iobase);
 }
 static void
 HFC_wait_regio(struct hfc_multi *hc)
 #endif
 {
-       outb(R_STATUS, (hc->pci_iobase)+4);
-       while (inb(hc->pci_iobase) & V_BUSY);
+       outb(R_STATUS, hc->pci_iobase + 4);
+       while (inb(hc->pci_iobase) & V_BUSY)
+               cpu_relax();
 }
 
 #ifdef HFC_REGISTER_DEBUG
        if (regname[0] == '\0')
                strcpy(regname, "register");
 
-       bits[7] = '0'+(!!(val&1));
-       bits[6] = '0'+(!!(val&2));
-       bits[5] = '0'+(!!(val&4));
-       bits[4] = '0'+(!!(val&8));
-       bits[3] = '0'+(!!(val&16));
-       bits[2] = '0'+(!!(val&32));
-       bits[1] = '0'+(!!(val&64));
-       bits[0] = '0'+(!!(val&128));
+       bits[7] = '0' + (!!(val & 1));
+       bits[6] = '0' + (!!(val & 2));
+       bits[5] = '0' + (!!(val & 4));
+       bits[4] = '0' + (!!(val & 8));
+       bits[3] = '0' + (!!(val & 16));
+       bits[2] = '0' + (!!(val & 32));
+       bits[1] = '0' + (!!(val & 64));
+       bits[0] = '0' + (!!(val & 128));
        printk(KERN_DEBUG
            "HFC_outb(chip %d, %02x=%s, 0x%02x=%s); in %s() line %d\n",
            hc->id, reg, regname, val, bits, function, line);
        if (regname[0] == '\0')
                strcpy(regname, "register");
 
-       bits[7] = '0'+(!!(val&1));
-       bits[6] = '0'+(!!(val&2));
-       bits[5] = '0'+(!!(val&4));
-       bits[4] = '0'+(!!(val&8));
-       bits[3] = '0'+(!!(val&16));
-       bits[2] = '0'+(!!(val&32));
-       bits[1] = '0'+(!!(val&64));
-       bits[0] = '0'+(!!(val&128));
+       bits[7] = '0' + (!!(val & 1));
+       bits[6] = '0' + (!!(val & 2));
+       bits[5] = '0' + (!!(val & 4));
+       bits[4] = '0' + (!!(val & 8));
+       bits[3] = '0' + (!!(val & 16));
+       bits[2] = '0' + (!!(val & 32));
+       bits[1] = '0' + (!!(val & 64));
+       bits[0] = '0' + (!!(val & 128));
        printk(KERN_DEBUG
            "HFC_inb(chip %d, %02x=%s) = 0x%02x=%s; in %s() line %d\n",
            hc->id, reg, regname, val, bits, function, line);
                len--;
        }
 }
+
 /* read fifo data (REGIO) */
 static void
 read_fifo_regio(struct hfc_multi *hc, u_char *data, int len)
        }
 }
 
-
 static void
 enable_hwirq(struct hfc_multi *hc)
 {
        if (hc->syncronized) {
                if (syncmaster == NULL) {
                        if (debug & DEBUG_HFCMULTI_PLXSD)
-                               printk(KERN_WARNING "%s: GOT sync on card %d"
+                               printk(KERN_DEBUG "%s: GOT sync on card %d"
                                        " (id=%d)\n", __func__, hc->id + 1,
                                        hc->id);
                        hfcmulti_resync(hc, hc, rm);
        } else {
                if (syncmaster == hc) {
                        if (debug & DEBUG_HFCMULTI_PLXSD)
-                               printk(KERN_WARNING "%s: LOST sync on card %d"
+                               printk(KERN_DEBUG "%s: LOST sync on card %d"
                                        " (id=%d)\n", __func__, hc->id + 1,
                                        hc->id);
                        hfcmulti_resync(hc, NULL, rm);
                pv &= ~PLX_DSP_RES_N;
                writel(pv, plx_acc_32);
                if (debug & DEBUG_HFCMULTI_INIT)
-                       printk(KERN_WARNING "%s: PCM off: PLX_GPIO=%x\n",
+                       printk(KERN_DEBUG "%s: PCM off: PLX_GPIO=%x\n",
                                __func__, pv);
                spin_unlock_irqrestore(&plx_lock, plx_flags);
        }
        if (debug & DEBUG_HFCMULTI_INIT)
                printk(KERN_DEBUG "%s: entered\n", __func__);
        val = HFC_inb(hc, R_CHIP_ID);
-       if ((val>>4) != 0x8 && (val>>4) != 0xc && (val>>4) != 0xe
-                       && (val>>1) != 0x31) {
+       if ((val >> 4) != 0x8 && (val >> 4) != 0xc && (val >> 4) != 0xe &&
+           (val >> 1) != 0x31) {
                printk(KERN_INFO "HFC_multi: unknown CHIP_ID:%x\n", (u_int)val);
                err = -EIO;
                goto out;
                writel(pv, plx_acc_32);
                spin_unlock_irqrestore(&plx_lock, plx_flags);
                if (debug & DEBUG_HFCMULTI_INIT)
-                       printk(KERN_WARNING "%s: slave/term: PLX_GPIO=%x\n",
+                       printk(KERN_DEBUG "%s: slave/term: PLX_GPIO=%x\n",
                                __func__, pv);
                /*
                 * If we are the 3rd PLXSD card or higher, we must turn
                        writel(pv, plx_acc_32);
                        spin_unlock_irqrestore(&plx_lock, plx_flags);
                        if (debug & DEBUG_HFCMULTI_INIT)
-                           printk(KERN_WARNING "%s: term off: PLX_GPIO=%x\n",
-                                       __func__, pv);
+                               printk(KERN_DEBUG
+                                   "%s: term off: PLX_GPIO=%x\n",
+                                   __func__, pv);
                }
                spin_unlock_irqrestore(&HFClock, hfc_flags);
                hc->hw.r_pcm_md0 = V_F0_LEN; /* shift clock for DSP */
                        pv |= PLX_MASTER_EN | PLX_SLAVE_EN_N;
                        pv |= PLX_SYNC_O_EN;
                        if (debug & DEBUG_HFCMULTI_INIT)
-                               printk(KERN_WARNING "%s: master: PLX_GPIO=%x\n",
+                               printk(KERN_DEBUG "%s: master: PLX_GPIO=%x\n",
                                        __func__, pv);
                } else {
                        pv &= ~(PLX_MASTER_EN | PLX_SLAVE_EN_N);
                        pv &= ~PLX_SYNC_O_EN;
                        if (debug & DEBUG_HFCMULTI_INIT)
-                               printk(KERN_WARNING "%s: slave: PLX_GPIO=%x\n",
+                               printk(KERN_DEBUG "%s: slave: PLX_GPIO=%x\n",
                                        __func__, pv);
                }
                writel(pv, plx_acc_32);
                                writel(pv, plx_acc_32);
                                spin_unlock_irqrestore(&plx_lock, plx_flags);
                                if (debug & DEBUG_HFCMULTI_INIT)
-                                   printk(KERN_WARNING "%s: master: PLX_GPIO"
-                                       "=%x\n", __func__, pv);
+                                       printk(KERN_DEBUG "%s: master: "
+                                           "PLX_GPIO=%x\n", __func__, pv);
                        }
                        hc->hw.r_pcm_md0 |= V_PCM_MD;
                        HFC_outb(hc, R_PCM_MD0, hc->hw.r_pcm_md0 | 0x00);
                writel(pv, plx_acc_32);
                spin_unlock_irqrestore(&plx_lock, plx_flags);
                if (debug & DEBUG_HFCMULTI_INIT)
-                       printk(KERN_WARNING "%s: reset off: PLX_GPIO=%x\n",
+                       printk(KERN_DEBUG "%s: reset off: PLX_GPIO=%x\n",
                                __func__, pv);
        }
 
                        hc->chan[ch].coeff_count = 0;
                        skb = mI_alloc_skb(512, GFP_ATOMIC);
                        if (!skb) {
-                               printk(KERN_WARNING "%s: No memory for skb\n",
+                               printk(KERN_DEBUG "%s: No memory for skb\n",
                                    __func__);
                                continue;
                        }
                printk(KERN_DEBUG "%s(card %d): fifo(%d) has %d bytes space "
                    "left (z1=%04x, z2=%04x) sending %d of %d bytes %s\n",
                        __func__, hc->id + 1, ch, Zspace, z1, z2, ii-i, len-i,
-                       temp ? "HDLC":"TRANS");
+                       temp ? "HDLC" : "TRANS");
 
        /* Have to prep the audio data */
        hc->write_fifo(hc, d, ii - i);
                        handle_timer_irq(hc);
                }
 
-               if (r_irq_misc & V_DTMF_IRQ) {
+               if (r_irq_misc & V_DTMF_IRQ)
                        hfcmulti_dtmf(hc);
-               }
+
                if (r_irq_misc & V_IRQ_PROC) {
                        static int irq_proc_cnt;
                        if (!irq_proc_cnt++)
-                               printk(KERN_WARNING "%s: got V_IRQ_PROC -"
+                               printk(KERN_DEBUG "%s: got V_IRQ_PROC -"
                                    " this should not happen\n", __func__);
                }
 
                else
                        flow_rx = 0xc0; /* ST->(FIFO,PCM) */
                /* put on slot */
-               routing = bank_rx?0x80:0xc0; /* reversed */
+               routing = bank_rx ? 0x80 : 0xc0; /* reversed */
                if (conf >= 0 || bank_rx > 1)
                        routing = 0x40; /* loop */
                if (debug & DEBUG_HFCMULTI_MODE)
                HFC_wait(hc);
                if (hc->chan[ch].bch && hc->ctype != HFC_TYPE_E1) {
                        hc->hw.a_st_ctrl0[hc->chan[ch].port] &=
-                           ((ch & 0x3) == 0)? ~V_B1_EN: ~V_B2_EN;
+                           ((ch & 0x3) == 0) ? ~V_B1_EN : ~V_B2_EN;
                        HFC_outb(hc, R_ST_SEL, hc->chan[ch].port);
                        /* undocumented: delay after R_ST_SEL */
                        udelay(1);
                switch (hh->id) {
                case HFC_SPL_LOOP_ON: /* set sample loop */
                        if (debug & DEBUG_HFCMULTI_MSG)
-                       printk(KERN_DEBUG
-                           "%s: HFC_SPL_LOOP_ON (len = %d)\n",
-                           __func__, skb->len);
+                               printk(KERN_DEBUG
+                                   "%s: HFC_SPL_LOOP_ON (len = %d)\n",
+                                   __func__, skb->len);
                        ret = 0;
                        break;
                case HFC_SPL_LOOP_OFF: /* set silence */
        int ch, i;
 
        if (!dch) {
-               printk(KERN_WARNING "%s: ERROR given dch is NULL\n",
-                   __func__);
+               printk(KERN_WARNING "%s: ERROR given dch is NULL\n", __func__);
                return;
        }
        hc = dch->hw;
                switch (dch->state) {
                case (1):
                        if (hc->e1_state != 1) {
-                           for (i = 1; i <= 31; i++) {
-                               /* reset fifos on e1 activation */
-                               HFC_outb_nodebug(hc, R_FIFO, (i << 1) | 1);
-                               HFC_wait_nodebug(hc);
-                               HFC_outb_nodebug(hc,
-                                       R_INC_RES_FIFO, V_RES_F);
-                               HFC_wait_nodebug(hc);
-                           }
+                               for (i = 1; i <= 31; i++) {
+                                       /* reset fifos on e1 activation */
+                                       HFC_outb_nodebug(hc, R_FIFO,
+                                               (i << 1) | 1);
+                                       HFC_wait_nodebug(hc);
+                                       HFC_outb_nodebug(hc, R_INC_RES_FIFO,
+                                               V_RES_F);
+                                       HFC_wait_nodebug(hc);
+                               }
                        }
                        test_and_set_bit(FLG_ACTIVE, &dch->Flags);
                        _queue_data(&dch->dev.D, PH_ACTIVATE_IND,
                return -EINVAL;
        if ((dch->dev.D.protocol != ISDN_P_NONE) &&
            (dch->dev.D.protocol != rq->protocol)) {
-           if (debug & DEBUG_HFCMULTI_MODE)
-               printk(KERN_WARNING "%s: change protocol %x to %x\n",
-                   __func__, dch->dev.D.protocol, rq->protocol);
+               if (debug & DEBUG_HFCMULTI_MODE)
+                       printk(KERN_DEBUG "%s: change protocol %x to %x\n",
+                           __func__, dch->dev.D.protocol, rq->protocol);
        }
-       if ((dch->dev.D.protocol == ISDN_P_TE_S0)
-        && (rq->protocol != ISDN_P_TE_S0))
+       if ((dch->dev.D.protocol == ISDN_P_TE_S0) &&
+           (rq->protocol != ISDN_P_TE_S0))
                l1_event(dch->l1, CLOSE_CHANNEL);
        if (dch->dev.D.protocol != rq->protocol) {
                if (rq->protocol == ISDN_P_TE_S0) {
                wd_cnt = cq->p1 & 0xf;
                wd_mode = !!(cq->p1 >> 4);
                if (debug & DEBUG_HFCMULTI_MSG)
-                       printk(KERN_DEBUG
-                           "%s: MISDN_CTRL_HFC_WD_INIT mode %s counter 0x%x\n",
-                           __func__, wd_mode ? "AUTO" : "MANUAL", wd_cnt);
+                       printk(KERN_DEBUG "%s: MISDN_CTRL_HFC_WD_INIT mode %s"
+                           ", counter 0x%x\n", __func__,
+                           wd_mode ? "AUTO" : "MANUAL", wd_cnt);
                /* set the watchdog timer */
                HFC_outb(hc, R_TI_WD, poll_timer | (wd_cnt << 4));
                hc->hw.r_bert_wd_md = (wd_mode ? V_AUTO_WD_RES : 0);
                HFC_outb(hc, R_BERT_WD_MD, hc->hw.r_bert_wd_md | V_WD_RES);
                if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
                        /* enable the watchdog output for Speech-Design */
-                       HFC_outb(hc, R_GPIO_SEL, V_GPIO_SEL7);
-                       HFC_outb(hc, R_GPIO_EN1, V_GPIO_EN15);
+                       HFC_outb(hc, R_GPIO_SEL,  V_GPIO_SEL7);
+                       HFC_outb(hc, R_GPIO_EN1,  V_GPIO_EN15);
                        HFC_outb(hc, R_GPIO_OUT1, 0);
                        HFC_outb(hc, R_GPIO_OUT1, V_GPIO_OUT15);
                }
        }
 
        if (debug & DEBUG_HFCMULTI_INIT)
-               printk(KERN_WARNING "%s: free irq %d\n", __func__, hc->irq);
+               printk(KERN_DEBUG "%s: free irq %d\n", __func__, hc->irq);
        if (hc->irq) {
                free_irq(hc->irq, hc);
                hc->irq = 0;
        int     ch;
 
        if (debug & DEBUG_HFCMULTI_INIT)
-               printk(KERN_WARNING "%s: release card (%d) entered\n",
+               printk(KERN_DEBUG "%s: release card (%d) entered\n",
                    __func__, hc->id);
 
        /* unregister clock source */
        /* release hardware & irq */
        if (hc->irq) {
                if (debug & DEBUG_HFCMULTI_INIT)
-                       printk(KERN_WARNING "%s: free irq %d\n",
+                       printk(KERN_DEBUG "%s: free irq %d\n",
                            __func__, hc->irq);
                free_irq(hc->irq, hc);
                hc->irq = 0;
        release_io_hfcmulti(hc);
 
        if (debug & DEBUG_HFCMULTI_INIT)
-               printk(KERN_WARNING "%s: remove instance from list\n",
+               printk(KERN_DEBUG "%s: remove instance from list\n",
                     __func__);
        list_del(&hc->list);
 
        if (debug & DEBUG_HFCMULTI_INIT)
-               printk(KERN_WARNING "%s: delete instance\n", __func__);
+               printk(KERN_DEBUG "%s: delete instance\n", __func__);
        if (hc == syncmaster)
                syncmaster = NULL;
        kfree(hc);
        if (debug & DEBUG_HFCMULTI_INIT)
-               printk(KERN_WARNING "%s: card successfully removed\n",
+               printk(KERN_DEBUG "%s: card successfully removed\n",
                    __func__);
 }
 
            (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
        dch->dev.D.send = handle_dmsg;
        dch->dev.D.ctrl = hfcm_dctrl;
-       dch->dev.nrbchan = (hc->dslot)?30:31;
+       dch->dev.nrbchan = (hc->dslot) ? 30 : 31;
        dch->slot = hc->dslot;
        hc->chan[hc->dslot].dch = dch;
        hc->chan[hc->dslot].port = 0;
        }
        /* disable E-channel */
        if (port[Port_cnt] & 0x004) {
-       if (debug & DEBUG_HFCMULTI_INIT)
+               if (debug & DEBUG_HFCMULTI_INIT)
                        printk(KERN_DEBUG
                            "%s: PROTOCOL disable E-channel: "
                            "card(%d) port(%d)\n",
                spin_unlock_irqrestore(&HFClock, flags);
        }  else {
                if (debug)
-                       printk(KERN_WARNING "%s: drvdata allready removed\n",
+                       printk(KERN_DEBUG "%s: drvdata allready removed\n",
                            __func__);
        }
 }
 
        Write_hfc(hc, HFCPCI_INT_M1, hc->hw.int_m1);
 
        /* Clear already pending ints */
-       if (Read_hfc(hc, HFCPCI_INT_S1));
+       val = Read_hfc(hc, HFCPCI_INT_S1);
 
        /* set NT/TE mode */
        hfcpci_setmode(hc);
                        df->f2 = ((df->f2 + 1) & MAX_D_FRAMES) |
                            (MAX_D_FRAMES + 1); /* next buffer */
                        df->za[df->f2 & D_FREG_MASK].z2 =
-                           cpu_to_le16((le16_to_cpu(zp->z2) + rcnt) & (D_FIFO_SIZE - 1));
+                           cpu_to_le16((le16_to_cpu(zp->z2) + rcnt) &
+                           (D_FIFO_SIZE - 1));
                } else {
                        dch->rx_skb = mI_alloc_skb(rcnt - 3, GFP_ATOMIC);
                        if (!dch->rx_skb) {
 ph_state_nt(struct dchannel *dch)
 {
        struct hfc_pci  *hc = dch->hw;
+       u_char  val;
 
        if (dch->debug)
                printk(KERN_DEBUG "%s: NT newstate %x\n",
                        hc->hw.int_m1 &= ~HFCPCI_INTS_TIMER;
                        Write_hfc(hc, HFCPCI_INT_M1, hc->hw.int_m1);
                        /* Clear already pending ints */
-                       if (Read_hfc(hc, HFCPCI_INT_S1));
+                       val = Read_hfc(hc, HFCPCI_INT_S1);
                        Write_hfc(hc, HFCPCI_STATES, 4 | HFCPCI_LOAD_STATE);
                        udelay(10);
                        Write_hfc(hc, HFCPCI_STATES, 4);
                rx_slot = (bc>>8) & 0xff;
                tx_slot = (bc>>16) & 0xff;
                bc = bc & 0xff;
-       } else if (test_bit(HFC_CFG_PCM, &hc->cfg) &&
-           (protocol > ISDN_P_NONE))
+       } else if (test_bit(HFC_CFG_PCM, &hc->cfg) && (protocol > ISDN_P_NONE))
                printk(KERN_WARNING "%s: no pcm channel id but HFC_CFG_PCM\n",
                    __func__);
        if (hc->chanlimit > 1) {
        case (ISDN_P_B_RAW):
                bch->state = protocol;
                bch->nr = bc;
-               hfcpci_clear_fifo_rx(hc, (fifo2 & 2)?1:0);
-               hfcpci_clear_fifo_tx(hc, (fifo2 & 2)?1:0);
+               hfcpci_clear_fifo_rx(hc, (fifo2 & 2) ? 1 : 0);
+               hfcpci_clear_fifo_tx(hc, (fifo2 & 2) ? 1 : 0);
                if (bc & 2) {
                        hc->hw.sctrl |= SCTRL_B2_ENA;
                        hc->hw.sctrl_r |= SCTRL_B2_ENA;
        case (ISDN_P_B_HDLC):
                bch->state = protocol;
                bch->nr = bc;
-               hfcpci_clear_fifo_rx(hc, (fifo2 & 2)?1:0);
-               hfcpci_clear_fifo_tx(hc, (fifo2 & 2)?1:0);
+               hfcpci_clear_fifo_rx(hc, (fifo2 & 2) ? 1 : 0);
+               hfcpci_clear_fifo_tx(hc, (fifo2 & 2) ? 1 : 0);
                if (bc & 2) {
                        hc->hw.sctrl |= SCTRL_B2_ENA;
                        hc->hw.sctrl_r |= SCTRL_B2_ENA;
        switch (protocol) {
        case (ISDN_P_B_RAW):
                bch->state = protocol;
-               hfcpci_clear_fifo_rx(hc, (chan & 2)?1:0);
+               hfcpci_clear_fifo_rx(hc, (chan & 2) ? 1 : 0);
                if (chan & 2) {
                        hc->hw.sctrl_r |= SCTRL_B2_ENA;
                        hc->hw.fifo_en |= HFCPCI_FIFOEN_B2RX;
                break;
        case (ISDN_P_B_HDLC):
                bch->state = protocol;
-               hfcpci_clear_fifo_rx(hc, (chan & 2)?1:0);
+               hfcpci_clear_fifo_rx(hc, (chan & 2) ? 1 : 0);
                if (chan & 2) {
                        hc->hw.sctrl_r |= SCTRL_B2_ENA;
                        hc->hw.last_bfifo_cnt[1] = 0;
                printk(KERN_WARNING "HFC-PCI: No IRQ for PCI card found\n");
                return 1;
        }
-       hc->hw.pci_io = (char __iomem *)(unsigned long)hc->pdev->resource[1].start;
+       hc->hw.pci_io =
+               (char __iomem *)(unsigned long)hc->pdev->resource[1].start;
 
        if (!hc->hw.pci_io) {
                printk(KERN_WARNING "HFC-PCI: No IO-Mem for PCI card found\n");
                release_card(card);
        else
                if (debug)
-                       printk(KERN_WARNING "%s: drvdata already removed\n",
+                       printk(KERN_DEBUG "%s: drvdata already removed\n",
                            __func__);
 }
 
 
        {8000, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 
        {TONE_GERMAN_DIALPBX,
-       {DATA_GA, DATA_S, DATA_GA, DATA_S, DATA_GA, DATA_S, NULL, NULL, NULL, NULL},
-       {SIZE_GA, SIZE_S, SIZE_GA, SIZE_S, SIZE_GA, SIZE_S, NULL, NULL, NULL, NULL},
+       {DATA_GA, DATA_S, DATA_GA, DATA_S, DATA_GA, DATA_S, NULL, NULL, NULL,
+               NULL},
+       {SIZE_GA, SIZE_S, SIZE_GA, SIZE_S, SIZE_GA, SIZE_S, NULL, NULL, NULL,
+               NULL},
        {2000, 2000, 2000, 2000, 2000, 12000, 0, 0, 0, 0} },
 
        {TONE_GERMAN_OLDDIALPBX,
-       {DATA_GO, DATA_S, DATA_GO, DATA_S, DATA_GO, DATA_S, NULL, NULL, NULL, NULL},
-       {SIZE_GO, SIZE_S, SIZE_GO, SIZE_S, SIZE_GO, SIZE_S, NULL, NULL, NULL, NULL},
+       {DATA_GO, DATA_S, DATA_GO, DATA_S, DATA_GO, DATA_S, NULL, NULL, NULL,
+               NULL},
+       {SIZE_GO, SIZE_S, SIZE_GO, SIZE_S, SIZE_GO, SIZE_S, NULL, NULL, NULL,
+               NULL},
        {2000, 2000, 2000, 2000, 2000, 12000, 0, 0, 0, 0} },
 
        {TONE_AMERICAN_DIALPBX,
-       {DATA_DT, DATA_S, DATA_DT, DATA_S, DATA_DT, DATA_S, NULL, NULL, NULL, NULL},
-       {SIZE_DT, SIZE_S, SIZE_DT, SIZE_S, SIZE_DT, SIZE_S, NULL, NULL, NULL, NULL},
+       {DATA_DT, DATA_S, DATA_DT, DATA_S, DATA_DT, DATA_S, NULL, NULL, NULL,
+               NULL},
+       {SIZE_DT, SIZE_S, SIZE_DT, SIZE_S, SIZE_DT, SIZE_S, NULL, NULL, NULL,
+               NULL},
        {2000, 2000, 2000, 2000, 2000, 12000, 0, 0, 0, 0} },
 
        {TONE_GERMAN_RINGING,
 
        /* unlocking is not required, because we don't expect a response */
        nskb = _alloc_mISDN_skb(PH_CONTROL_REQ,
-               (len)?HFC_SPL_LOOP_ON:HFC_SPL_LOOP_OFF, len, sample,
+               (len) ? HFC_SPL_LOOP_ON : HFC_SPL_LOOP_OFF, len, sample,
                GFP_ATOMIC);
        if (nskb) {
                if (dsp->ch.peer) {
 
        /* we turn off the tone */
        if (!tone) {
-               if (dsp->features.hfc_loops)
-               if (timer_pending(&tonet->tl))
+               if (dsp->features.hfc_loops && timer_pending(&tonet->tl))
                        del_timer(&tonet->tl);
                if (dsp->features.hfc_loops)
                        dsp_tone_hw_message(dsp, NULL, 0);
 
 
        /* assemble frame */
        *p++ = (L1OIP_VERSION<<6) /* version and coding */
-            | (hc->pri?0x20:0x00) /* type */
-            | (hc->id?0x10:0x00) /* id */
+            | (hc->pri ? 0x20 : 0x00) /* type */
+            | (hc->id ? 0x10 : 0x00) /* id */
             | localcodec;
        if (hc->id) {
                *p++ = hc->id>>24; /* id */
                *p++ = hc->id>>8;
                *p++ = hc->id;
        }
-       *p++ = (multi == 1)?0x80:0x00 + channel; /* m-flag, channel */
+       *p++ = (multi == 1) ? 0x80 : 0x00 + channel; /* m-flag, channel */
        if (multi == 1)
                *p++ = len; /* length */
        *p++ = timebase>>8; /* time base */
        }
 
        /* prepare message */
-       nskb = mI_alloc_skb((remotecodec == 3)?(len<<1):len, GFP_ATOMIC);
+       nskb = mI_alloc_skb((remotecodec == 3) ? (len<<1) : len, GFP_ATOMIC);
        if (!nskb) {
                printk(KERN_ERR "%s: No mem for skb.\n", __func__);
                return;
        }
-       p = skb_put(nskb, (remotecodec == 3)?(len<<1):len);
+       p = skb_put(nskb, (remotecodec == 3) ? (len<<1) : len);
 
        if (remotecodec == 1 && ulaw)
                l1oip_alaw_to_ulaw(buf, len, p);
                hc->chan[channel].disorder_flag ^= 1;
                if (nskb)
 #endif
-               queue_ch_frame(&bch->ch, PH_DATA_IND, rx_counter, nskb);
+                       queue_ch_frame(&bch->ch, PH_DATA_IND, rx_counter, nskb);
        }
 }
 
                        l1oip_socket_parse(hc, &sin_rx, recvbuf, recvlen);
                } else {
                        if (debug & DEBUG_L1OIP_SOCKET)
-                           printk(KERN_WARNING "%s: broken pipe on socket\n",
-                               __func__);
+                               printk(KERN_WARNING
+                                   "%s: broken pipe on socket\n", __func__);
                }
        }
 
                p = skb->data;
                l = skb->len;
                while (l) {
-                       ll = (l < L1OIP_MAX_PERFRAME)?l:L1OIP_MAX_PERFRAME;
+                       ll = (l < L1OIP_MAX_PERFRAME) ? l : L1OIP_MAX_PERFRAME;
                        l1oip_socket_send(hc, 0, dch->slot, 0,
                                hc->chan[dch->slot].tx_counter++, p, ll);
                        p += ll;
                p = skb->data;
                l = skb->len;
                while (l) {
-                       ll = (l < L1OIP_MAX_PERFRAME)?l:L1OIP_MAX_PERFRAME;
+                       ll = (l < L1OIP_MAX_PERFRAME) ? l : L1OIP_MAX_PERFRAME;
                        l1oip_socket_send(hc, hc->codec, bch->slot, 0,
                                hc->chan[bch->slot].tx_counter, p, ll);
                        hc->chan[bch->slot].tx_counter += ll;
        spin_lock_init(&hc->socket_lock);
        hc->idx = l1oip_cnt;
        hc->pri = pri;
-       hc->d_idx = pri?16:3;
-       hc->b_num = pri?30:2;
+       hc->d_idx = pri ? 16 : 3;
+       hc->b_num = pri ? 30 : 2;
        hc->bundle = bundle;
        if (hc->pri)
                sprintf(hc->name, "l1oip-e1.%d", l1oip_cnt + 1);
 
                if (debug & DEBUG_L1OIP_INIT)
                        printk(KERN_DEBUG "%s: interface %d is %s with %s.\n",
-                               __func__, l1oip_cnt, pri?"PRI":"BRI",
-                               bundle?"bundled IP packet for all B-channels"
-                                :"seperate IP packets for every B-channel");
+                           __func__, l1oip_cnt, pri ? "PRI" : "BRI",
+                           bundle ? "bundled IP packet for all B-channels" :
+                           "seperate IP packets for every B-channel");
 
                hc = kzalloc(sizeof(struct l1oip), GFP_ATOMIC);
                if (!hc) {