} else {
                cnt = bchannel_get_rxbuf(bch, count);
                if (cnt < 0) {
-                       pr_warning("%s.B%d: No bufferspace for %d bytes\n",
-                                  fc->name, bch->nr, count);
+                       pr_warn("%s.B%d: No bufferspace for %d bytes\n",
+                               fc->name, bch->nr, count);
                        return;
                }
                p = skb_put(bch->rx_skb, count);
        }
        if (stat & HDLC_INT_RPR) {
                if (stat & HDLC_STAT_RDO) {
-                       pr_warning("%s: ch%d stat %x RDO\n",
-                                  fc->name, bch->nr, stat);
+                       pr_warn("%s: ch%d stat %x RDO\n",
+                               fc->name, bch->nr, stat);
                        hdlc->ctrl.sr.xml = 0;
                        hdlc->ctrl.sr.cmd |= HDLC_CMD_RRS;
                        write_ctrl(bch, 1);
                                    HDLC_STAT_CRCVFR) {
                                        recv_Bchannel(bch, 0, false);
                                } else {
-                                       pr_warning("%s: got invalid frame\n",
-                                                  fc->name);
+                                       pr_warn("%s: got invalid frame\n",
+                                               fc->name);
                                        skb_trim(bch->rx_skb, 0);
                                }
                        }
                 * restart transmitting the whole frame on HDLC
                 * in transparent mode we send the next data
                 */
-               pr_warning("%s: ch%d stat %x XDU %s\n", fc->name, bch->nr,
-                          stat, bch->tx_skb ? "tx_skb" : "no tx_skb");
+               pr_warn("%s: ch%d stat %x XDU %s\n", fc->name, bch->nr,
+                       stat, bch->tx_skb ? "tx_skb" : "no tx_skb");
                if (bch->tx_skb && bch->tx_skb->len) {
                        if (!test_bit(FLG_TRANSPARENT, &bch->Flags))
                                bch->tx_idx = 0;
 
        if (bch) {
                maxlen = bchannel_get_rxbuf(bch, Zsize);
                if (maxlen < 0) {
-                       pr_warning("card%d.B%d: No bufferspace for %d bytes\n",
-                                  hc->id + 1, bch->nr, Zsize);
+                       pr_warn("card%d.B%d: No bufferspace for %d bytes\n",
+                               hc->id + 1, bch->nr, Zsize);
                        return;
                }
                sp = &bch->rx_skb;
                if (*sp == NULL) {
                        *sp = mI_alloc_skb(maxlen, GFP_ATOMIC);
                        if (*sp == NULL) {
-                               pr_warning("card%d: No mem for dch rx_skb\n",
-                                          hc->id + 1);
+                               pr_warn("card%d: No mem for dch rx_skb\n",
+                                       hc->id + 1);
                                return;
                        }
                }
 
        }
        maxlen = bchannel_get_rxbuf(bch, fcnt_rx);
        if (maxlen < 0) {
-               pr_warning("B%d: No bufferspace for %d bytes\n",
-                          bch->nr, fcnt_rx);
+               pr_warn("B%d: No bufferspace for %d bytes\n", bch->nr, fcnt_rx);
        } else {
                ptr = skb_put(bch->rx_skb, fcnt_rx);
                if (le16_to_cpu(*z2r) + fcnt_rx <= B_FIFO_SIZE + B_SUB_VAL)
 
                if (maxlen < 0) {
                        if (rx_skb)
                                skb_trim(rx_skb, 0);
-                       pr_warning("%s.B%d: No bufferspace for %d bytes\n",
-                                  hw->name, fifo->bch->nr, len);
+                       pr_warn("%s.B%d: No bufferspace for %d bytes\n",
+                               hw->name, fifo->bch->nr, len);
                        spin_unlock_irqrestore(&hw->lock, flags);
                        return;
                }
 
                hscx_cmdr(hscx, 0x80); /* RMC */
                if (hscx->bch.rx_skb)
                        skb_trim(hscx->bch.rx_skb, 0);
-               pr_warning("%s.B%d: No bufferspace for %d bytes\n",
-                          hscx->ip->name, hscx->bch.nr, count);
+               pr_warn("%s.B%d: No bufferspace for %d bytes\n",
+                       hscx->ip->name, hscx->bch.nr, count);
                return;
        }
        p = skb_put(hscx->bch.rx_skb, count);
 
                        goto reterror;
                }
                if (!poll_mbox(isar, 1000)) {
-                       pr_warning("ISAR poll_mbox dkey failed\n");
+                       pr_warn("ISAR poll_mbox dkey failed\n");
                        ret = -ETIME;
                        goto reterror;
                }
        case ISDN_P_B_MODEM_ASYNC:
                maxlen = bchannel_get_rxbuf(&ch->bch, ch->is->clsb);
                if (maxlen < 0) {
-                       pr_warning("%s.B%d: No bufferspace for %d bytes\n",
-                                  ch->is->name, ch->bch.nr, ch->is->clsb);
+                       pr_warn("%s.B%d: No bufferspace for %d bytes\n",
+                               ch->is->name, ch->bch.nr, ch->is->clsb);
                        ch->is->write_reg(ch->is->hw, ISAR_IIA, 0);
                        break;
                }
        case ISDN_P_B_HDLC:
                maxlen = bchannel_get_rxbuf(&ch->bch, ch->is->clsb);
                if (maxlen < 0) {
-                       pr_warning("%s.B%d: No bufferspace for %d bytes\n",
-                                  ch->is->name, ch->bch.nr, ch->is->clsb);
+                       pr_warn("%s.B%d: No bufferspace for %d bytes\n",
+                               ch->is->name, ch->bch.nr, ch->is->clsb);
                        ch->is->write_reg(ch->is->hw, ISAR_IIA, 0);
                        break;
                }
 
        stat = bchannel_get_rxbuf(&bc->bch, cnt);
        /* only transparent use the count here, HDLC overun is detected later */
        if (stat == -ENOMEM) {
-               pr_warning("%s.B%d: No memory for %d bytes\n",
-                          card->name, bc->bch.nr, cnt);
+               pr_warn("%s.B%d: No memory for %d bytes\n",
+                       card->name, bc->bch.nr, cnt);
                return;
        }
        if (test_bit(FLG_TRANSPARENT, &bc->bch.Flags))
                        recv_Bchannel(&bc->bch, 0, false);
                        stat = bchannel_get_rxbuf(&bc->bch, bc->bch.maxlen);
                        if (stat < 0) {
-                               pr_warning("%s.B%d: No memory for %d bytes\n",
-                                          card->name, bc->bch.nr, cnt);
+                               pr_warn("%s.B%d: No memory for %d bytes\n",
+                                       card->name, bc->bch.nr, cnt);
                                return;
                        }
                } else if (stat == -HDLC_CRC_ERROR) {
 
                WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
                if (wch->bch.rx_skb)
                        skb_trim(wch->bch.rx_skb, 0);
-               pr_warning("%s.B%d: No bufferspace for %d bytes\n",
-                          card->name, wch->bch.nr, count);
+               pr_warn("%s.B%d: No bufferspace for %d bytes\n",
+                       card->name, wch->bch.nr, count);
                return;
        }
        ptr = skb_put(wch->bch.rx_skb, count);
                                 wch->bch.nr, star);
                }
                if (star & W_B_STAR_XDOW) {
-                       pr_warning("%s: B%d XDOW proto=%x\n", card->name,
-                                  wch->bch.nr, wch->bch.state);
+                       pr_warn("%s: B%d XDOW proto=%x\n", card->name,
+                               wch->bch.nr, wch->bch.state);
 #ifdef ERROR_STATISTIC
                        wch->bch.err_xdu++;
 #endif
                        return; /* handle XDOW only once */
        }
        if (stat & W_B_EXI_XDUN) {
-               pr_warning("%s: B%d XDUN proto=%x\n", card->name,
-                          wch->bch.nr, wch->bch.state);
+               pr_warn("%s: B%d XDUN proto=%x\n", card->name,
+                       wch->bch.nr, wch->bch.state);
 #ifdef ERROR_STATISTIC
                wch->bch.err_xdu++;
 #endif
 
        if (bch->rx_skb) {
                len = skb_tailroom(bch->rx_skb);
                if (len < reqlen) {
-                       pr_warning("B%d no space for %d (only %d) bytes\n",
-                                  bch->nr, reqlen, len);
+                       pr_warn("B%d no space for %d (only %d) bytes\n",
+                               bch->nr, reqlen, len);
                        if (test_bit(FLG_TRANSPARENT, &bch->Flags)) {
                                /* send what we have now and try a new buffer */
                                recv_Bchannel(bch, 0, true);
        }
        bch->rx_skb = mI_alloc_skb(len, GFP_ATOMIC);
        if (!bch->rx_skb) {
-               pr_warning("B%d receive no memory for %d bytes\n",
-                          bch->nr, len);
+               pr_warn("B%d receive no memory for %d bytes\n", bch->nr, len);
                len = -ENOMEM;
        }
        return len;