int             fifon = fifo->fifonum;
        int             i;
        int             hdlc = 0;
+       unsigned long   flags;
 
        if (debug & DBG_HFC_CALL_TRACE)
                printk(KERN_DEBUG "%s: %s: fifo(%i) len(%i) "
                return;
        }
 
-       spin_lock(&hw->lock);
+       spin_lock_irqsave(&hw->lock, flags);
        if (fifo->dch) {
                rx_skb = fifo->dch->rx_skb;
                maxlen = fifo->dch->maxlen;
        if (fifo->bch) {
                if (test_bit(FLG_RX_OFF, &fifo->bch->Flags)) {
                        fifo->bch->dropcnt += len;
-                       spin_unlock(&hw->lock);
+                       spin_unlock_irqrestore(&hw->lock, flags);
                        return;
                }
                maxlen = bchannel_get_rxbuf(fifo->bch, len);
                                skb_trim(rx_skb, 0);
                        pr_warning("%s.B%d: No bufferspace for %d bytes\n",
                                   hw->name, fifo->bch->nr, len);
-                       spin_unlock(&hw->lock);
+                       spin_unlock_irqrestore(&hw->lock, flags);
                        return;
                }
                maxlen = fifo->bch->maxlen;
                        } else {
                                printk(KERN_DEBUG "%s: %s: No mem for rx_skb\n",
                                       hw->name, __func__);
-                               spin_unlock(&hw->lock);
+                               spin_unlock_irqrestore(&hw->lock, flags);
                                return;
                        }
                }
                               "for fifo(%d) HFCUSB_D_RX\n",
                               hw->name, __func__, fifon);
                        skb_trim(rx_skb, 0);
-                       spin_unlock(&hw->lock);
+                       spin_unlock_irqrestore(&hw->lock, flags);
                        return;
                }
        }
                /* deliver transparent data to layer2 */
                recv_Bchannel(fifo->bch, MISDN_ID_ANY, false);
        }
-       spin_unlock(&hw->lock);
+       spin_unlock_irqrestore(&hw->lock, flags);
 }
 
 static void
        __u8 *buf;
        static __u8 eof[8];
        __u8 s0_state;
+       unsigned long flags;
 
        fifon = fifo->fifonum;
        status = urb->status;
 
-       spin_lock(&hw->lock);
+       spin_lock_irqsave(&hw->lock, flags);
        if (fifo->stop_gracefull) {
                fifo->stop_gracefull = 0;
                fifo->active = 0;
-               spin_unlock(&hw->lock);
+               spin_unlock_irqrestore(&hw->lock, flags);
                return;
        }
-       spin_unlock(&hw->lock);
+       spin_unlock_irqrestore(&hw->lock, flags);
 
        /*
         * ISO transfer only partially completed,
        struct usb_fifo *fifo = (struct usb_fifo *) urb->context;
        struct hfcsusb *hw = fifo->hw;
        static __u8 eof[8];
+       unsigned long flags;
 
-       spin_lock(&hw->lock);
+       spin_lock_irqsave(&hw->lock, flags);
        if (fifo->stop_gracefull) {
                fifo->stop_gracefull = 0;
                fifo->active = 0;
-               spin_unlock(&hw->lock);
+               spin_unlock_irqrestore(&hw->lock, flags);
                return;
        }
-       spin_unlock(&hw->lock);
+       spin_unlock_irqrestore(&hw->lock, flags);
 
        fifon = fifo->fifonum;
        if ((!fifo->active) || (urb->status)) {
        int *tx_idx;
        int frame_complete, fifon, status, fillempty = 0;
        __u8 threshbit, *p;
+       unsigned long flags;
 
-       spin_lock(&hw->lock);
+       spin_lock_irqsave(&hw->lock, flags);
        if (fifo->stop_gracefull) {
                fifo->stop_gracefull = 0;
                fifo->active = 0;
-               spin_unlock(&hw->lock);
+               spin_unlock_irqrestore(&hw->lock, flags);
                return;
        }
 
        } else {
                printk(KERN_DEBUG "%s: %s: neither BCH nor DCH\n",
                       hw->name, __func__);
-               spin_unlock(&hw->lock);
+               spin_unlock_irqrestore(&hw->lock, flags);
                return;
        }
 
                               hw->name, __func__,
                               symbolic(urb_errlist, status), status, fifon);
        }
-       spin_unlock(&hw->lock);
+       spin_unlock_irqrestore(&hw->lock, flags);
 }
 
 /*