port bkm_a4t hfc_2bds0hfc_sx gazel hfc_2bs0 teleint

drivers/isdn/hisax/Kconfig

@@ -402,13 +402,6 @@ config HISAX_FRITZ_PCIPNP
 	  (the latter also needs you to select "ISA Plug and Play support"
 	  from the menu "Plug and Play configuration")
 
-config HISAX_FRITZ_CLASSIC
-	tristate "AVM Fritz!Card classic support (EXPERIMENTAL)"
-	depends on ISA && EXPERIMENTAL
-	help
-	  This enables the driver for the AVM Fritz!Card classic, formerly
-	  known as AVM A1.
-
 endif
 
 endmenu

drivers/isdn/hisax/Makefile

@@ -12,8 +12,6 @@ obj-$(CONFIG_HISAX_ELSA_CS)		+= elsa_cs.o
 obj-$(CONFIG_HISAX_AVM_A1_CS)		+= avma1_cs.o
 obj-$(CONFIG_HISAX_ST5481)		+= hisax_st5481.o
 obj-$(CONFIG_HISAX_FRITZ_PCIPNP)        += hisax_isac.o hisax_fcpcipnp.o
-obj-$(CONFIG_HISAX_FRITZ_CLASSIC)       += hisax_isac.o hisax_hscx.o hisax_fcclassic.o
-obj-$(CONFIG_HISAX_FRITZ_PCIPNP)        += hisax_hfcpci.o
 
 
 # Multipart objects.

drivers/isdn/hisax/bkm_a4t.c

@@ -30,16 +30,13 @@ static inline u_char
 readreg(unsigned int ale, unsigned long adr, u_char off)
 {
 	register u_int ret;
-	long flags;
 	unsigned int *po = (unsigned int *) adr;	/* Postoffice */
-	save_flags(flags);
+
-	cli();
 	*po = (GCS_2 | PO_WRITE | off);
 	__WAITI20__(po);
 	*po = (ale | PO_READ);
 	__WAITI20__(po);
 	ret = *po;
-	restore_flags(flags);
 	return ((unsigned char) ret);
 }
 
@@ -47,7 +44,6 @@ readreg(unsigned int ale, unsigned long adr, u_char off)
 static inline void
 readfifo(unsigned int ale, unsigned long adr, u_char off, u_char * data, int size)
 {
-	/* fifo read without cli because it's allready done  */
 	int i;
 	for (i = 0; i < size; i++)
 		*data++ = readreg(ale, adr, off);
@@ -57,22 +53,17 @@ readfifo(unsigned int ale, unsigned long adr, u_char off, u_char * data, int siz
 static inline void
 writereg(unsigned int ale, unsigned long adr, u_char off, u_char data)
 {
-	long flags;
 	unsigned int *po = (unsigned int *) adr;	/* Postoffice */
-	save_flags(flags);
-	cli();
 	*po = (GCS_2 | PO_WRITE | off);
 	__WAITI20__(po);
 	*po = (ale | PO_WRITE | data);
 	__WAITI20__(po);
-	restore_flags(flags);
 }
 
 
 static inline void
 writefifo(unsigned int ale, unsigned long adr, u_char off, u_char * data, int size)
 {
-	/* fifo write without cli because it's allready done  */
 	int i;
 
 	for (i = 0; i < size; i++)
@@ -134,17 +125,15 @@ WriteJADE(struct IsdnCardState *cs, int jade, u_char offset, u_char value)
 
 #include "jade_irq.c"
 
-static void
+static irqreturn_t
 bkm_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 {
 	struct IsdnCardState *cs = dev_id;
 	u_char val = 0;
+	u_long flags;
 	I20_REGISTER_FILE *pI20_Regs;
 
-	if (!cs) {
+	spin_lock_irqsave(&cs->lock, flags);
-		printk(KERN_WARNING "HiSax: Telekom A4T: Spurious interrupt!\n");
-		return;
-	}
 	pI20_Regs = (I20_REGISTER_FILE *) (cs->hw.ax.base);
 
 	/* ISDN interrupt pending? */
@@ -170,6 +159,11 @@ bkm_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 		}
 		/* Reenable ISDN interrupt */
 		pI20_Regs->i20IntCtrl |= intISDN;
+		spin_unlock_irqrestore(&cs->lock, flags);
+		return IRQ_HANDLED;
+	} else {
+		spin_unlock_irqrestore(&cs->lock, flags);
+		return IRQ_NONE;
 	}
 }
 
@@ -228,25 +222,33 @@ reset_bkm(struct IsdnCardState *cs)
 static int
 BKM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
+	u_long flags;
+
 	switch (mt) {
 		case CARD_RESET:
 			/* Disable ints */
+			spin_lock_irqsave(&cs->lock, flags);
 			enable_bkm_int(cs, 0);
 			reset_bkm(cs);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return (0);
 		case CARD_RELEASE:
 			/* Sanity */
+			spin_lock_irqsave(&cs->lock, flags);
 			enable_bkm_int(cs, 0);
 			reset_bkm(cs);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			release_io_bkm(cs);
 			return (0);
 		case CARD_INIT:
+			spin_lock_irqsave(&cs->lock, flags);
 			clear_pending_isac_ints(cs);
 			clear_pending_jade_ints(cs);
 			initisac(cs);
 			initjade(cs);
 			/* Enable ints */
 			enable_bkm_int(cs, 1);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return (0);
 		case CARD_TEST:
 			return (0);
@@ -274,10 +276,6 @@ setup_bkm_a4t(struct IsdnCard *card)
 		return (0);
 
 #if CONFIG_PCI
-	if (!pci_present()) {
-		printk(KERN_ERR "bkm_a4t: no PCI bus present\n");
-		return (0);
-	}
 	while ((dev_a4t = pci_find_device(PCI_VENDOR_ID_ZORAN,
 		PCI_DEVICE_ID_ZORAN_36120, dev_a4t))) {
 		u16 sub_sys;
@@ -328,7 +326,7 @@ setup_bkm_a4t(struct IsdnCard *card)
 	printk(KERN_INFO "HiSax: %s: Card configured at 0x%lX IRQ %d\n",
 	       CardType[card->typ], cs->hw.ax.base, cs->irq);
 
-	reset_bkm(cs);
+	setup_isac(cs);
 	cs->readisac = &ReadISAC;
 	cs->writeisac = &WriteISAC;
 	cs->readisacfifo = &ReadISACfifo;

drivers/isdn/hisax/gazel.c

@@ -72,26 +72,17 @@ static inline u_char
 readreg_ipac(unsigned int adr, u_short off)
 {
 	register u_char ret;
-	long flags;
 
-	save_flags(flags);
-	cli();
 	byteout(adr, off);
 	ret = bytein(adr + 4);
-	restore_flags(flags);
 	return ret;
 }
 
 static inline void
 writereg_ipac(unsigned int adr, u_short off, u_char data)
 {
-	long flags;
-
-	save_flags(flags);
-	cli();
 	byteout(adr, off);
 	byteout(adr + 4, data);
-	restore_flags(flags);
 }
 
 
@@ -252,18 +243,16 @@ WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
 
 #include "hscx_irq.c"
 
-static void
+static irqreturn_t
 gazel_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 {
 #define MAXCOUNT 5
 	struct IsdnCardState *cs = dev_id;
 	u_char valisac, valhscx;
 	int count = 0;
+	u_long flags;
 
-	if (!cs) {
+	spin_lock_irqsave(&cs->lock, flags);
-		printk(KERN_WARNING "Gazel: Spurious interrupt!\n");
-		return;
-	}
 	do {
 		valhscx = ReadHSCX(cs, 1, HSCX_ISTA);
 		if (valhscx)
@@ -280,20 +269,20 @@ gazel_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 	WriteISAC(cs, ISAC_MASK, 0x0);
 	WriteHSCX(cs, 0, HSCX_MASK, 0x0);
 	WriteHSCX(cs, 1, HSCX_MASK, 0x0);
+	spin_unlock_irqrestore(&cs->lock, flags);
+	return IRQ_HANDLED;
 }
 
 
-static void
+static irqreturn_t
 gazel_interrupt_ipac(int intno, void *dev_id, struct pt_regs *regs)
 {
 	struct IsdnCardState *cs = dev_id;
 	u_char ista, val;
 	int count = 0;
-
+	u_long flags;
-	if (!cs) {
+	
-		printk(KERN_WARNING "Gazel: Spurious interrupt!\n");
+	spin_lock_irqsave(&cs->lock, flags);
-		return;
-	}
 	ista = ReadISAC(cs, IPAC_ISTA - 0x80);
 	do {
 		if (ista & 0x0f) {
@@ -325,6 +314,8 @@ gazel_interrupt_ipac(int intno, void *dev_id, struct pt_regs *regs)
 
 	WriteISAC(cs, IPAC_MASK - 0x80, 0xFF);
 	WriteISAC(cs, IPAC_MASK - 0x80, 0xC0);
+	spin_unlock_irqrestore(&cs->lock, flags);
+	return IRQ_HANDLED;
 }
 void
 release_io_gazel(struct IsdnCardState *cs)
@@ -357,18 +348,14 @@ release_io_gazel(struct IsdnCardState *cs)
 static int
 reset_gazel(struct IsdnCardState *cs)
 {
-	long flags;
 	unsigned long plxcntrl, addr = cs->hw.gazel.cfg_reg;
 
 	switch (cs->subtyp) {
 		case R647:
-			save_flags(flags);
-			cli();
 			writereg(addr, 0, 0);
 			HZDELAY(10);
 			writereg(addr, 0, 1);
 			HZDELAY(2);
-			restore_flags(flags);
 			break;
 		case R685:
 			plxcntrl = inl(addr + PLX_CNTRL);
@@ -414,14 +401,19 @@ reset_gazel(struct IsdnCardState *cs)
 static int
 Gazel_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
+	u_long flags;
+
 	switch (mt) {
 		case CARD_RESET:
+			spin_lock_irqsave(&cs->lock, flags);
 			reset_gazel(cs);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return (0);
 		case CARD_RELEASE:
 			release_io_gazel(cs);
 			return (0);
 		case CARD_INIT:
+			spin_lock_irqsave(&cs->lock, flags);
 			inithscxisac(cs, 1);
 			if ((cs->subtyp==R647)||(cs->subtyp==R685)) {
 				int i;
@@ -430,6 +422,7 @@ Gazel_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 					cs->bcs[i].hw.hscx.tsaxr1 = 0x23;
 				}
 			}
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return (0);
 		case CARD_TEST:
 			return (0);
@@ -440,48 +433,46 @@ Gazel_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 static int
 reserve_regions(struct IsdnCard *card, struct IsdnCardState *cs)
 {
-	unsigned int i, base = 0, adr = 0, len = 0;
+	unsigned int i, j, base = 0, adr = 0, len = 0;
 
 	switch (cs->subtyp) {
 		case R647:
 			base = cs->hw.gazel.hscx[0];
+			if (!request_region(adr = (0xC000 + base), len = 1, "gazel"))
+				goto error;
 			for (i = 0x0000; i < 0xC000; i += 0x1000) {
-				if (check_region(adr = (i + base), len = 16))
+				if (!request_region(adr = (i + base), len = 16, "gazel"))
 					goto error;
 			}
-			if (check_region(adr = (0xC000 + base), len = 1))
+			if (i != 0xC000) {
+				for (j = 0; j < i; j+= 0x1000)
+					release_region(j + base, 16);
+				release_region(0xC000 + base, 1);
 				goto error;
-
+			}
-			for (i = 0x0000; i < 0xC000; i += 0x1000)
-				request_region(i + base, 16, "gazel");
-			request_region(0xC000 + base, 1, "gazel");
-
 			break;
 
 		case R685:
-			if (check_region(adr = cs->hw.gazel.hscx[0], len = 0x100))
+			if (!request_region(adr = cs->hw.gazel.hscx[0], len = 0x100, "gazel"))
 				goto error;
-			if (check_region(adr = cs->hw.gazel.cfg_reg, len = 0x80))
+			if (!request_region(adr = cs->hw.gazel.cfg_reg, len = 0x80, "gazel")) {
+				release_region(cs->hw.gazel.hscx[0],0x100);
 				goto error;
-
+			}
-			request_region(cs->hw.gazel.hscx[0], 0x100, "gazel");
-			request_region(cs->hw.gazel.cfg_reg, 0x80, "gazel");
 			break;
 
 		case R753:
-			if (check_region(adr = cs->hw.gazel.ipac, len = 0x8))
+			if (!request_region(adr = cs->hw.gazel.ipac, len = 0x8, "gazel"))
 				goto error;
-			if (check_region(adr = cs->hw.gazel.cfg_reg, len = 0x80))
+			if (!request_region(adr = cs->hw.gazel.cfg_reg, len = 0x80, "gazel")) {
+				release_region(cs->hw.gazel.ipac, 8);
 				goto error;
-
+			}
-			request_region(cs->hw.gazel.ipac, 0x8, "gazel");
-			request_region(cs->hw.gazel.cfg_reg, 0x80, "gazel");
 			break;
 
 		case R742:
-			if (check_region(adr = cs->hw.gazel.ipac, len = 0x8))
+			if (!request_region(adr = cs->hw.gazel.ipac, len = 0x8, "gazel"))
 				goto error;
-			request_region(cs->hw.gazel.ipac, 0x8, "gazel");
 			break;
 	}
 
@@ -506,6 +497,7 @@ setup_gazelisa(struct IsdnCard *card, struct IsdnCardState *cs)
 	else
 		cs->subtyp = R647;
 
+	setup_isac(cs);
 	cs->hw.gazel.cfg_reg = card->para[1] + 0xC000;
 	cs->hw.gazel.ipac = card->para[1];
 	cs->hw.gazel.isac = card->para[1] + 0x8000;
@@ -552,10 +544,6 @@ setup_gazelpci(struct IsdnCardState *cs)
 	printk(KERN_WARNING "Gazel: PCI card automatic recognition\n");
 
 	found = 0;
-	if (!pci_present()) {
-		printk(KERN_WARNING "Gazel: No PCI bus present\n");
-		return 1;
-	}
 	seekcard = PCI_DEVICE_ID_PLX_R685;
 	for (nbseek = 0; nbseek < 3; nbseek++) {
 		if ((dev_tel = pci_find_device(PCI_VENDOR_ID_PLX, seekcard, dev_tel))) {
@@ -589,7 +577,7 @@ setup_gazelpci(struct IsdnCardState *cs)
 	}
 	cs->hw.gazel.pciaddr[0] = pci_ioaddr0;
 	cs->hw.gazel.pciaddr[1] = pci_ioaddr1;
-
+	setup_isac(cs);
 	pci_ioaddr1 &= 0xfffe;
 	cs->hw.gazel.cfg_reg = pci_ioaddr0 & 0xfffe;
 	cs->hw.gazel.ipac = pci_ioaddr1;

drivers/isdn/hisax/hfc_2bds0.c

@@ -78,17 +78,6 @@ writereghfcd(struct IsdnCardState *cs, u_char offset, u_char value)
 	WriteReg(cs, HFCD_DATA, offset, value);
 }
 
-void
-set_cs_func(struct IsdnCardState *cs)
-{
-	cs->readisac = &readreghfcd;
-	cs->writeisac = &writereghfcd;
-	cs->readisacfifo = &dummyf;
-	cs->writeisacfifo = &dummyf;
-	cs->BC_Read_Reg = &ReadReg;
-	cs->BC_Write_Reg = &WriteReg;
-}
-
 static inline int
 WaitForBusy(struct IsdnCardState *cs)
 {
@@ -106,15 +95,11 @@ WaitForBusy(struct IsdnCardState *cs)
 static inline int
 WaitNoBusy(struct IsdnCardState *cs)
 {
-	long flags;
 	int to = 130;
 
 	while ((ReadReg(cs, HFCD_STATUS, HFCD_STATUS) & HFCD_BUSY) && to) {
-		save_flags(flags);
-		sti();
 		udelay(1);
 		to--;
-		restore_flags(flags);
 	}
 	if (!to) 
 		printk(KERN_WARNING "HiSax: WaitNoBusy timeout\n");
@@ -125,13 +110,9 @@ static int
 SelFiFo(struct IsdnCardState *cs, u_char FiFo)
 {
 	u_char cip;
-	long flags;
-
 
 	if (cs->hw.hfcD.fifo == FiFo)
 		return(1);
-	save_flags(flags);
-	cli();
 	switch(FiFo) {
 		case 0: cip = HFCB_FIFO | HFCB_Z1 | HFCB_SEND | HFCB_B1;
 			break;
@@ -146,18 +127,16 @@ SelFiFo(struct IsdnCardState *cs, u_char FiFo)
 		case 5: cip = HFCD_FIFO | HFCD_Z1 | HFCD_REC;
 			break;
 		default:
-			restore_flags(flags);
 			debugl1(cs, "SelFiFo Error");
 			return(0);
 	}
 	cs->hw.hfcD.fifo = FiFo;
 	WaitNoBusy(cs);
 	cs->BC_Write_Reg(cs, HFCD_DATA, cip, 0);
-	sti();
 	WaitForBusy(cs);
-	restore_flags(flags);
 	return(2);
 }
+
 static int
 GetFreeFifoBytes_B(struct BCState *bcs)
 {
@@ -198,14 +177,6 @@ ReadZReg(struct IsdnCardState *cs, u_char reg)
 	return (val);
 }
 
-static void
-hfc_sched_event(struct BCState *bcs, int event)
-{
-	bcs->event |= 1 << event;
-	queue_task(&bcs->tqueue, &tq_immediate);
-	mark_bh(IMMEDIATE_BH);
-}
-
 static struct sk_buff
 *hfc_empty_fifo(struct BCState *bcs, int count)
 {
@@ -214,22 +185,18 @@ static struct sk_buff
 	struct IsdnCardState *cs = bcs->cs;
 	int idx;
 	int chksum;
-	long flags;
 	u_char stat, cip;
 	
 	if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
 		debugl1(cs, "hfc_empty_fifo");
 	idx = 0;
-	save_flags(flags);
 	if (count > HSCX_BUFMAX + 3) {
 		if (cs->debug & L1_DEB_WARN)
 			debugl1(cs, "hfc_empty_fifo: incoming packet too large");
 		cip = HFCB_FIFO | HFCB_FIFO_OUT | HFCB_REC | HFCB_CHANNEL(bcs->channel);
 		while (idx++ < count) {
-			cli();
 			WaitNoBusy(cs);
 			ReadReg(cs, HFCD_DATA_NODEB, cip);
-			sti();
 		}
 		skb = NULL;
 	} else if (count < 4) {
@@ -239,7 +206,6 @@ static struct sk_buff
 #ifdef ERROR_STATISTIC
 		bcs->err_inv++;
 #endif
-		cli();
 		while ((idx++ < count) && WaitNoBusy(cs))
 			ReadReg(cs, HFCD_DATA_NODEB, cip);
 		skb = NULL;
@@ -249,31 +215,25 @@ static struct sk_buff
 		ptr = skb_put(skb, count - 3);
 		idx = 0;
 		cip = HFCB_FIFO | HFCB_FIFO_OUT | HFCB_REC | HFCB_CHANNEL(bcs->channel);
-		cli();
 		while (idx < (count - 3)) {
-			cli();
 			if (!WaitNoBusy(cs))
 				break;
 			*ptr = ReadReg(cs,  HFCD_DATA_NODEB, cip);
-			sti();
 			ptr++;
 			idx++;
 		}
 		if (idx != count - 3) {
-			sti();
 			debugl1(cs, "RFIFO BUSY error");
 			printk(KERN_WARNING "HFC FIFO channel %d BUSY Error\n", bcs->channel);
 			dev_kfree_skb_irq(skb);
 			skb = NULL;
 		} else {
-			cli();
 			WaitNoBusy(cs);
 			chksum = (ReadReg(cs, HFCD_DATA, cip) << 8);
 			WaitNoBusy(cs);
 			chksum += ReadReg(cs, HFCD_DATA, cip);
 			WaitNoBusy(cs);
 			stat = ReadReg(cs, HFCD_DATA, cip);
-			sti();
 			if (cs->debug & L1_DEB_HSCX)
 				debugl1(cs, "hfc_empty_fifo %d chksum %x stat %x",
 					bcs->channel, chksum, stat);
@@ -287,15 +247,11 @@ static struct sk_buff
 			}
 		}
 	}
-	sti();
 	WaitForBusy(cs);
-	cli();
 	WaitNoBusy(cs);
 	stat = ReadReg(cs, HFCD_DATA, HFCB_FIFO | HFCB_F2_INC |
 		HFCB_REC | HFCB_CHANNEL(bcs->channel));
-	sti();
 	WaitForBusy(cs);
-	restore_flags(flags);
 	return (skb);
 }
 
@@ -303,7 +259,6 @@ static void
 hfc_fill_fifo(struct BCState *bcs)
 {
 	struct IsdnCardState *cs = bcs->cs;
-	long flags;
 	int idx, fcnt;
 	int count;
 	u_char cip;
@@ -312,8 +267,6 @@ hfc_fill_fifo(struct BCState *bcs)
 		return;
 	if (bcs->tx_skb->len <= 0)
 		return;
-	save_flags(flags);
-	cli();
 	SelFiFo(cs, HFCB_SEND | HFCB_CHANNEL(bcs->channel)); 
 	cip = HFCB_FIFO | HFCB_F1 | HFCB_SEND | HFCB_CHANNEL(bcs->channel);
 	WaitNoBusy(cs);
@@ -323,7 +276,6 @@ hfc_fill_fifo(struct BCState *bcs)
 	WaitNoBusy(cs);
 	bcs->hw.hfc.f2 = ReadReg(cs, HFCD_DATA, cip);
 	bcs->hw.hfc.send[bcs->hw.hfc.f1] = ReadZReg(cs, HFCB_FIFO | HFCB_Z1 | HFCB_SEND | HFCB_CHANNEL(bcs->channel));
-	sti();
  	if (cs->debug & L1_DEB_HSCX)
 		debugl1(cs, "hfc_fill_fifo %d f1(%d) f2(%d) z1(%x)",
 			bcs->channel, bcs->hw.hfc.f1, bcs->hw.hfc.f2,
@@ -334,7 +286,6 @@ hfc_fill_fifo(struct BCState *bcs)
 	if (fcnt > 30) {
 		if (cs->debug & L1_DEB_HSCX)
 			debugl1(cs, "hfc_fill_fifo more as 30 frames");
-		restore_flags(flags);
 		return;
 	}
 	count = GetFreeFifoBytes_B(bcs);
@@ -345,25 +296,20 @@ hfc_fill_fifo(struct BCState *bcs)
 	if (count < bcs->tx_skb->len) {
 		if (cs->debug & L1_DEB_HSCX)
 			debugl1(cs, "hfc_fill_fifo no fifo mem");
-		restore_flags(flags);
 		return;
 	}
 	cip = HFCB_FIFO | HFCB_FIFO_IN | HFCB_SEND | HFCB_CHANNEL(bcs->channel);
 	idx = 0;
-	cli();
 	WaitForBusy(cs);
 	WaitNoBusy(cs);
 	WriteReg(cs, HFCD_DATA_NODEB, cip, bcs->tx_skb->data[idx++]);
 	while (idx < bcs->tx_skb->len) {
-		cli();
 		if (!WaitNoBusy(cs))
 			break;
 		WriteReg(cs, HFCD_DATA_NODEB, cip, bcs->tx_skb->data[idx]);
-		sti();
 		idx++;
 	}
 	if (idx != bcs->tx_skb->len) {
-		sti();
 		debugl1(cs, "FIFO Send BUSY error");
 		printk(KERN_WARNING "HFC S FIFO channel %d BUSY Error\n", bcs->channel);
 	} else {
@@ -375,13 +321,10 @@ hfc_fill_fifo(struct BCState *bcs)
 		bcs->tx_skb = NULL;
 	}
 	WaitForBusy(cs);
-	cli();
 	WaitNoBusy(cs);
 	ReadReg(cs, HFCD_DATA, HFCB_FIFO | HFCB_F1_INC | HFCB_SEND | HFCB_CHANNEL(bcs->channel));
-	sti();
 	WaitForBusy(cs);
 	test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
-	restore_flags(flags);
 	return;
 }
 
@@ -400,20 +343,16 @@ hfc_send_data(struct BCState *bcs)
 void
 main_rec_2bds0(struct BCState *bcs)
 {
-	long flags;
 	struct IsdnCardState *cs = bcs->cs;
 	int z1, z2, rcnt;
 	u_char f1, f2, cip;
 	int receive, count = 5;
 	struct sk_buff *skb;
 
-	save_flags(flags);
     Begin:
 	count--;
-	cli();
 	if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
 		debugl1(cs,"rec_data %d blocked", bcs->channel);
-		restore_flags(flags);
 		return;
 	}
 	SelFiFo(cs, HFCB_REC | HFCB_CHANNEL(bcs->channel));
@@ -423,15 +362,12 @@ main_rec_2bds0(struct BCState *bcs)
 	cip = HFCB_FIFO | HFCB_F2 | HFCB_REC | HFCB_CHANNEL(bcs->channel);
 	WaitNoBusy(cs);
 	f2 = ReadReg(cs, HFCD_DATA, cip);
-	sti();
 	if (f1 != f2) {
 		if (cs->debug & L1_DEB_HSCX)
 			debugl1(cs, "hfc rec %d f1(%d) f2(%d)",
 				bcs->channel, f1, f2);
-		cli();
 		z1 = ReadZReg(cs, HFCB_FIFO | HFCB_Z1 | HFCB_REC | HFCB_CHANNEL(bcs->channel));
 		z2 = ReadZReg(cs, HFCB_FIFO | HFCB_Z2 | HFCB_REC | HFCB_CHANNEL(bcs->channel));
-		sti();
 		rcnt = z1 - z2;
 		if (rcnt < 0)
 			rcnt += cs->hw.hfcD.bfifosize;
@@ -440,10 +376,8 @@ main_rec_2bds0(struct BCState *bcs)
 			debugl1(cs, "hfc rec %d z1(%x) z2(%x) cnt(%d)",
 				bcs->channel, z1, z2, rcnt);
 		if ((skb = hfc_empty_fifo(bcs, rcnt))) {
-			cli();
 			skb_queue_tail(&bcs->rqueue, skb);
-			sti();
+			schedule_event(bcs, B_RCVBUFREADY);
-			hfc_sched_event(bcs, B_RCVBUFREADY);
 		}
 		rcnt = f1 -f2;
 		if (rcnt<0)
@@ -457,7 +391,6 @@ main_rec_2bds0(struct BCState *bcs)
 	test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
 	if (count && receive)
 		goto Begin;	
-	restore_flags(flags);
 	return;
 }
 
@@ -512,54 +445,56 @@ mode_2bs0(struct BCState *bcs, int mode, int bc)
 static void
 hfc_l2l1(struct PStack *st, int pr, void *arg)
 {
+	struct BCState *bcs = st->l1.bcs;
 	struct sk_buff *skb = arg;
-	long flags;
+	u_long flags;
 
 	switch (pr) {
 		case (PH_DATA | REQUEST):
-			save_flags(flags);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			cli();
+			if (bcs->tx_skb) {
-			if (st->l1.bcs->tx_skb) {
+				skb_queue_tail(&bcs->squeue, skb);
-				skb_queue_tail(&st->l1.bcs->squeue, skb);
-				restore_flags(flags);
 			} else {
-				st->l1.bcs->tx_skb = skb;
+				bcs->tx_skb = skb;
-/*				test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+//				test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
-*/				st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
+				bcs->cs->BC_Send_Data(bcs);
-				restore_flags(flags);
 			}
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			break;
 		case (PH_PULL | INDICATION):
-			if (st->l1.bcs->tx_skb) {
+			spin_lock_irqsave(&bcs->cs->lock, flags);
+			if (bcs->tx_skb) {
 				printk(KERN_WARNING "hfc_l2l1: this shouldn't happen\n");
-				break;
+			} else {
+//				test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
+				bcs->tx_skb = skb;
+				bcs->cs->BC_Send_Data(bcs);
 			}
-			save_flags(flags);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
-			cli();
-/*			test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
-*/			st->l1.bcs->tx_skb = skb;
-			st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
-			restore_flags(flags);
 			break;
 		case (PH_PULL | REQUEST):
-			if (!st->l1.bcs->tx_skb) {
+			if (!bcs->tx_skb) {
 				test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 				st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 			} else
 				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 			break;
 		case (PH_ACTIVATE | REQUEST):
-			test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			mode_2bs0(st->l1.bcs, st->l1.mode, st->l1.bc);
+			test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
+			mode_2bs0(bcs, st->l1.mode, st->l1.bc);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			l1_msg_b(st, pr, arg);
 			break;
 		case (PH_DEACTIVATE | REQUEST):
 			l1_msg_b(st, pr, arg);
 			break;
 		case (PH_DEACTIVATE | CONFIRM):
-			test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+			test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
-			mode_2bs0(st->l1.bcs, 0, st->l1.bc);
+			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
+			mode_2bs0(bcs, 0, st->l1.bc);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
 			break;
 	}
@@ -611,8 +546,6 @@ setstack_2b(struct PStack *st, struct BCState *bcs)
 static void
 hfcd_bh(struct IsdnCardState *cs)
 {
-/*	struct PStack *stptr;
-*/
 	if (!cs)
 		return;
 	if (test_and_clear_bit(D_L1STATECHANGE, &cs->event)) {
@@ -642,19 +575,10 @@ hfcd_bh(struct IsdnCardState *cs)
 		DChannel_proc_xmt(cs);
 }
 
-void
-sched_event_D(struct IsdnCardState *cs, int event)
-{
-	test_and_set_bit(event, &cs->event);
-	queue_task(&cs->tqueue, &tq_immediate);
-	mark_bh(IMMEDIATE_BH);
-}
-
 static
 int receive_dmsg(struct IsdnCardState *cs)
 {
 	struct sk_buff *skb;
-	long flags;
 	int idx;
 	int rcnt, z1, z2;
 	u_char stat, cip, f1, f2;
@@ -662,11 +586,8 @@ int receive_dmsg(struct IsdnCardState *cs)
 	int count=5;
 	u_char *ptr;
 
-	save_flags(flags);
-	cli();
 	if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
 		debugl1(cs, "rec_dmsg blocked");
-		restore_flags(flags);
 		return(1);
 	}
 	SelFiFo(cs, 4 | HFCD_REC);
@@ -686,7 +607,6 @@ int receive_dmsg(struct IsdnCardState *cs)
 		if (cs->debug & L1_DEB_ISAC)
 			debugl1(cs, "hfcd recd f1(%d) f2(%d) z1(%x) z2(%x) cnt(%d)",
 				f1, f2, z1, z2, rcnt);
-		sti();
 		idx = 0;
 		cip = HFCD_FIFO | HFCD_FIFO_OUT | HFCD_REC;
 		if (rcnt > MAX_DFRAME_LEN + 3) {
@@ -697,28 +617,23 @@ int receive_dmsg(struct IsdnCardState *cs)
 				if (!(WaitNoBusy(cs)))
 					break;
 				ReadReg(cs, HFCD_DATA_NODEB, cip);
-				sti();
 				idx++;
 			}
 		} else if (rcnt < 4) {
 			if (cs->debug & L1_DEB_WARN)
 				debugl1(cs, "empty_fifo d: incoming packet too small");
-			cli();
 			while ((idx++ < rcnt) && WaitNoBusy(cs))
 				ReadReg(cs, HFCD_DATA_NODEB, cip);
 		} else if ((skb = dev_alloc_skb(rcnt - 3))) {
 			ptr = skb_put(skb, rcnt - 3);
 			while (idx < (rcnt - 3)) {
-				cli();
 				if (!(WaitNoBusy(cs)))
 					break;
 				*ptr = ReadReg(cs, HFCD_DATA_NODEB, cip);
-				sti();
 				idx++;
 				ptr++;
 			}
 			if (idx != (rcnt - 3)) {
-				sti();
 				debugl1(cs, "RFIFO D BUSY error");
 				printk(KERN_WARNING "HFC DFIFO channel BUSY Error\n");
 				dev_kfree_skb_irq(skb);
@@ -727,14 +642,12 @@ int receive_dmsg(struct IsdnCardState *cs)
 				cs->err_rx++;
 #endif
 			} else {
-				cli();
 				WaitNoBusy(cs);
 				chksum = (ReadReg(cs, HFCD_DATA, cip) << 8);
 				WaitNoBusy(cs);
 				chksum += ReadReg(cs, HFCD_DATA, cip);
 				WaitNoBusy(cs);
 				stat = ReadReg(cs, HFCD_DATA, cip);
-				sti();
 				if (cs->debug & L1_DEB_ISAC)
 					debugl1(cs, "empty_dfifo chksum %x stat %x",
 						chksum, stat);
@@ -747,33 +660,27 @@ int receive_dmsg(struct IsdnCardState *cs)
 #endif
 				} else {
 					skb_queue_tail(&cs->rq, skb);
-					sched_event_D(cs, D_RCVBUFREADY);
+					schedule_event(cs, D_RCVBUFREADY);
 				}
 			}
 		} else
 			printk(KERN_WARNING "HFC: D receive out of memory\n");
-		sti();
 		WaitForBusy(cs);
 		cip = HFCD_FIFO | HFCD_F2_INC | HFCD_REC;
-		cli();
 		WaitNoBusy(cs);
 		stat = ReadReg(cs, HFCD_DATA, cip);
-		sti();
 		WaitForBusy(cs);
 		cip = HFCD_FIFO | HFCD_F2 | HFCD_REC;
-		cli();
 		WaitNoBusy(cs);
 		f2 = cs->readisac(cs, cip) & 0xf;
 	}
 	test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
-	restore_flags(flags);
 	return(1);
 } 
 
 static void
 hfc_fill_dfifo(struct IsdnCardState *cs)
 {
-	long flags;
 	int idx, fcnt;
 	int count;
 	u_char cip;
@@ -783,8 +690,6 @@ hfc_fill_dfifo(struct IsdnCardState *cs)
 	if (cs->tx_skb->len <= 0)
 		return;
 
-	save_flags(flags);
-	cli();
 	SelFiFo(cs, 4 | HFCD_SEND);
 	cip = HFCD_FIFO | HFCD_F1 | HFCD_SEND;
 	WaitNoBusy(cs);
@@ -793,7 +698,6 @@ hfc_fill_dfifo(struct IsdnCardState *cs)
 	cip = HFCD_FIFO | HFCD_F2 | HFCD_SEND;
 	cs->hw.hfcD.f2 = ReadReg(cs, HFCD_DATA, cip) & 0xf;
 	cs->hw.hfcD.send[cs->hw.hfcD.f1] = ReadZReg(cs, HFCD_FIFO | HFCD_Z1 | HFCD_SEND);
-	sti();
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "hfc_fill_Dfifo f1(%d) f2(%d) z1(%x)",
 			cs->hw.hfcD.f1, cs->hw.hfcD.f2,
@@ -804,7 +708,6 @@ hfc_fill_dfifo(struct IsdnCardState *cs)
 	if (fcnt > 14) {
 		if (cs->debug & L1_DEB_HSCX)
 			debugl1(cs, "hfc_fill_Dfifo more as 14 frames");
-		restore_flags(flags);
 		return;
 	}
 	count = GetFreeFifoBytes_D(cs);
@@ -814,37 +717,29 @@ hfc_fill_dfifo(struct IsdnCardState *cs)
 	if (count < cs->tx_skb->len) {
 		if (cs->debug & L1_DEB_ISAC)
 			debugl1(cs, "hfc_fill_Dfifo no fifo mem");
-		restore_flags(flags);
 		return;
 	}
 	cip = HFCD_FIFO | HFCD_FIFO_IN | HFCD_SEND;
 	idx = 0;
-	cli();
 	WaitForBusy(cs);
 	WaitNoBusy(cs);
 	WriteReg(cs, HFCD_DATA_NODEB, cip, cs->tx_skb->data[idx++]);
 	while (idx < cs->tx_skb->len) {
-		cli();
 		if (!(WaitNoBusy(cs)))
 			break;
 		WriteReg(cs, HFCD_DATA_NODEB, cip, cs->tx_skb->data[idx]);
-		sti();
 		idx++;
 	}
 	if (idx != cs->tx_skb->len) {
-		sti();
 		debugl1(cs, "DFIFO Send BUSY error");
 		printk(KERN_WARNING "HFC S DFIFO channel BUSY Error\n");
 	}
 	WaitForBusy(cs);
-	cli();
 	WaitNoBusy(cs);
 	ReadReg(cs, HFCD_DATA, HFCD_FIFO | HFCD_F1_INC | HFCD_SEND);
 	dev_kfree_skb_any(cs->tx_skb);
 	cs->tx_skb = NULL;
-	sti();
 	WaitForBusy(cs);
-	restore_flags(flags);
 	return;
 }
 
@@ -865,7 +760,6 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
        	u_char exval;
        	struct BCState *bcs;
 	int count=15;
-	long flags;
 
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "HFCD irq %x %s", val,
@@ -878,15 +772,12 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
 			debugl1(cs, "ph_state chg %d->%d", cs->dc.hfcd.ph_state,
 				exval);
 		cs->dc.hfcd.ph_state = exval;
-		sched_event_D(cs, D_L1STATECHANGE);
+		schedule_event(cs, D_L1STATECHANGE);
 		val &= ~0x40;
 	}
 	while (val) {
-		save_flags(flags);
-		cli();
 		if (test_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
 			cs->hw.hfcD.int_s1 |= val;
-			restore_flags(flags);
 			return;
 		}
 		if (cs->hw.hfcD.int_s1 & 0x18) {
@@ -927,7 +818,7 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
 						} else
 							debugl1(cs,"fill_data %d blocked", bcs->channel);
 					} else {
-						hfc_sched_event(bcs, B_XMTBUFREADY);
+						schedule_event(bcs, B_XMTBUFREADY);
 					}
 				}
 			}
@@ -951,7 +842,7 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
 						} else
 							debugl1(cs,"fill_data %d blocked", bcs->channel);
 					} else {
-						hfc_sched_event(bcs, B_XMTBUFREADY);
+						schedule_event(bcs, B_XMTBUFREADY);
 					}
 				}
 			}
@@ -963,7 +854,7 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
 			if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
 				del_timer(&cs->dbusytimer);
 			if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
-				sched_event_D(cs, D_CLEARBUSY);
+				schedule_event(cs, D_CLEARBUSY);
 			if (cs->tx_skb) {
 				if (cs->tx_skb->len) {
 					if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
@@ -988,7 +879,7 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
 					debugl1(cs, "hfc_fill_dfifo irq blocked");
 				}
 			} else
-				sched_event_D(cs, D_XMTBUFREADY);
+				schedule_event(cs, D_XMTBUFREADY);
 		}
       afterXPR:
 		if (cs->hw.hfcD.int_s1 && count--) {
@@ -998,7 +889,6 @@ hfc2bds0_interrupt(struct IsdnCardState *cs, u_char val)
 				debugl1(cs, "HFCD irq %x loop %d", val, 15-count);
 		} else
 			val = 0;
-		restore_flags(flags);
 	}
 }
 
@@ -1007,6 +897,7 @@ HFCD_l1hw(struct PStack *st, int pr, void *arg)
 {
 	struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
 	struct sk_buff *skb = arg;
+	u_long flags;
 	
 	switch (pr) {
 		case (PH_DATA | REQUEST):
@@ -1014,6 +905,7 @@ HFCD_l1hw(struct PStack *st, int pr, void *arg)
 				LogFrame(cs, skb->data, skb->len);
 			if (cs->debug & DEB_DLOG_VERBOSE)
 				dlogframe(cs, skb, 0);
+			spin_lock_irqsave(&cs->lock, flags);
 			if (cs->tx_skb) {
 				skb_queue_tail(&cs->sq, skb);
 #ifdef L2FRAME_DEBUG		/* psa */
@@ -1034,12 +926,15 @@ HFCD_l1hw(struct PStack *st, int pr, void *arg)
 					debugl1(cs, "hfc_fill_dfifo blocked");
 
 			}
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (PH_PULL | INDICATION):
+			spin_lock_irqsave(&cs->lock, flags);
 			if (cs->tx_skb) {
 				if (cs->debug & L1_DEB_WARN)
 					debugl1(cs, " l2l1 tx_skb exist this shouldn't happen");
 				skb_queue_tail(&cs->sq, skb);
+				spin_unlock_irqrestore(&cs->lock, flags);
 				break;
 			}
 			if (cs->debug & DEB_DLOG_HEX)
@@ -1057,6 +952,7 @@ HFCD_l1hw(struct PStack *st, int pr, void *arg)
 				test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
 			} else
 				debugl1(cs, "hfc_fill_dfifo blocked");
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (PH_PULL | REQUEST):
 #ifdef L2FRAME_DEBUG		/* psa */
@@ -1070,24 +966,32 @@ HFCD_l1hw(struct PStack *st, int pr, void *arg)
 				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 			break;
 		case (HW_RESET | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->writeisac(cs, HFCD_STATES, HFCD_LOAD_STATE | 3); /* HFC ST 3 */
 			udelay(6);
 			cs->writeisac(cs, HFCD_STATES, 3); /* HFC ST 2 */
 			cs->hw.hfcD.mst_m |= HFCD_MASTER;
 			cs->writeisac(cs, HFCD_MST_MODE, cs->hw.hfcD.mst_m);
 			cs->writeisac(cs, HFCD_STATES, HFCD_ACTIVATE | HFCD_DO_ACTION);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			l1_msg(cs, HW_POWERUP | CONFIRM, NULL);
 			break;
 		case (HW_ENABLE | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->writeisac(cs, HFCD_STATES, HFCD_ACTIVATE | HFCD_DO_ACTION);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (HW_DEACTIVATE | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->hw.hfcD.mst_m &= ~HFCD_MASTER;
 			cs->writeisac(cs, HFCD_MST_MODE, cs->hw.hfcD.mst_m);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (HW_INFO3 | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->hw.hfcD.mst_m |= HFCD_MASTER;
 			cs->writeisac(cs, HFCD_MST_MODE, cs->hw.hfcD.mst_m);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		default:
 			if (cs->debug & L1_DEB_WARN)
@@ -1126,10 +1030,6 @@ void __init
 init2bds0(struct IsdnCardState *cs)
 {
 	cs->setstack_d = setstack_hfcd;
-	cs->dbusytimer.function = (void *) hfc_dbusy_timer;
-	cs->dbusytimer.data = (long) cs;
-	init_timer(&cs->dbusytimer);
-	cs->tqueue.routine = (void *) (void *) hfcd_bh;
 	if (!cs->hw.hfcD.send)
 		cs->hw.hfcD.send = init_send_hfcd(16);
 	if (!cs->bcs[0].hw.hfc.send)
@@ -1161,3 +1061,18 @@ release2bds0(struct IsdnCardState *cs)
 		cs->hw.hfcD.send = NULL;
 	}
 }
+
+void
+set_cs_func(struct IsdnCardState *cs)
+{
+	cs->readisac = &readreghfcd;
+	cs->writeisac = &writereghfcd;
+	cs->readisacfifo = &dummyf;
+	cs->writeisacfifo = &dummyf;
+	cs->BC_Read_Reg = &ReadReg;
+	cs->BC_Write_Reg = &WriteReg;
+	cs->dbusytimer.function = (void *) hfc_dbusy_timer;
+	cs->dbusytimer.data = (long) cs;
+	init_timer(&cs->dbusytimer);
+	INIT_WORK(&cs->tqueue, (void *)(void *) hfcd_bh, cs);
+}

drivers/isdn/hisax/hfc_2bs0.c

@@ -21,18 +21,14 @@ static inline int
 WaitForBusy(struct IsdnCardState *cs)
 {
 	int to = 130;
-	long flags;
 	u_char val;
 
-	save_flags(flags);
-	cli();
 	while (!(cs->BC_Read_Reg(cs, HFC_STATUS, 0) & HFC_BUSY) && to) {
 		val = cs->BC_Read_Reg(cs, HFC_DATA, HFC_CIP | HFC_F2 |
 				      (cs->hw.hfc.cip & 3));
 		udelay(1);
 		to--;
 	}
-	restore_flags(flags);
 	if (!to) {
 		printk(KERN_WARNING "HiSax: waitforBusy timeout\n");
 		return (0);
@@ -82,27 +78,16 @@ ReadZReg(struct BCState *bcs, u_char reg)
 	return (val);
 }
 
-void
-hfc_sched_event(struct BCState *bcs, int event)
-{
-	bcs->event |= 1 << event;
-	queue_task(&bcs->tqueue, &tq_immediate);
-	mark_bh(IMMEDIATE_BH);
-}
-
 static void
 hfc_clear_fifo(struct BCState *bcs)
 {
 	struct IsdnCardState *cs = bcs->cs;
-	long flags;
 	int idx, cnt;
 	int rcnt, z1, z2;
 	u_char cip, f1, f2;
 
 	if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
 		debugl1(cs, "hfc_clear_fifo");
-	save_flags(flags);
-	cli();
 	cip = HFC_CIP | HFC_F1 | HFC_REC | HFC_CHANNEL(bcs->channel);
 	if ((cip & 0xc3) != (cs->hw.hfc.cip & 0xc3)) {
 		cs->BC_Write_Reg(cs, HFC_STATUS, cip, cip);
@@ -149,7 +134,6 @@ hfc_clear_fifo(struct BCState *bcs)
 		z1 = ReadZReg(bcs, HFC_Z1 | HFC_REC | HFC_CHANNEL(bcs->channel));
 		z2 = ReadZReg(bcs, HFC_Z2 | HFC_REC | HFC_CHANNEL(bcs->channel));
 	}
-	restore_flags(flags);
 	return;
 }
 
@@ -252,7 +236,6 @@ static void
 hfc_fill_fifo(struct BCState *bcs)
 {
 	struct IsdnCardState *cs = bcs->cs;
-	long flags;
 	int idx, fcnt;
 	int count;
 	int z1, z2;
@@ -263,8 +246,6 @@ hfc_fill_fifo(struct BCState *bcs)
 	if (bcs->tx_skb->len <= 0)
 		return;
 
-	save_flags(flags);
-	cli();
 	cip = HFC_CIP | HFC_F1 | HFC_SEND | HFC_CHANNEL(bcs->channel);
 	if ((cip & 0xc3) != (cs->hw.hfc.cip & 0xc3)) {
 	  cs->BC_Write_Reg(cs, HFC_STATUS, cip, cip);
@@ -287,7 +268,6 @@ hfc_fill_fifo(struct BCState *bcs)
 	  if (fcnt > 30) {
 	    if (cs->debug & L1_DEB_HSCX)
 	      debugl1(cs, "hfc_fill_fifo more as 30 frames");
-	    restore_flags(flags);
 	    return;
 	  }
 	  count = GetFreeFifoBytes(bcs);
@@ -307,7 +287,6 @@ hfc_fill_fifo(struct BCState *bcs)
 	if (count < bcs->tx_skb->len) {
 		if (cs->debug & L1_DEB_HSCX)
 			debugl1(cs, "hfc_fill_fifo no fifo mem");
-		restore_flags(flags);
 		return;
 	}
 	cip = HFC_CIP | HFC_FIFO_IN | HFC_SEND | HFC_CHANNEL(bcs->channel);
@@ -333,23 +312,19 @@ hfc_fill_fifo(struct BCState *bcs)
 			bcs->st->lli.l1writewakeup(bcs->st, count);
 		test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 	}
-	restore_flags(flags);
 	return;
 }
 
 void
 main_irq_hfc(struct BCState *bcs)
 {
-	long flags;
 	struct IsdnCardState *cs = bcs->cs;
 	int z1, z2, rcnt;
 	u_char f1, f2, cip;
 	int receive, transmit, count = 5;
 	struct sk_buff *skb;
 
-	save_flags(flags);
       Begin:
-	cli();
 	count--;
 	cip = HFC_CIP | HFC_F1 | HFC_REC | HFC_CHANNEL(bcs->channel);
 	if ((cip & 0xc3) != (cs->hw.hfc.cip & 0xc3)) {
@@ -385,14 +360,11 @@ main_irq_hfc(struct BCState *bcs)
 			/*              sti(); */
 			if ((skb = hfc_empty_fifo(bcs, rcnt))) {
 				skb_queue_tail(&bcs->rqueue, skb);
-				hfc_sched_event(bcs, B_RCVBUFREADY);
+				schedule_event(bcs, B_RCVBUFREADY);
 			}
 		}
 		receive = 1;
 	}
-	restore_flags(flags);
-	udelay(1);
-	cli();
 	if (bcs->tx_skb) {
 		transmit = 1;
 		test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
@@ -408,10 +380,9 @@ main_irq_hfc(struct BCState *bcs)
 				transmit = 0;
 		} else {
 			transmit = 0;
-			hfc_sched_event(bcs, B_XMTBUFREADY);
+			schedule_event(bcs, B_XMTBUFREADY);
 		}
 	}
-	restore_flags(flags);
 	if ((receive || transmit) && count)
 		goto Begin;
 	return;
@@ -474,54 +445,57 @@ mode_hfc(struct BCState *bcs, int mode, int bc)
 static void
 hfc_l2l1(struct PStack *st, int pr, void *arg)
 {
-	struct sk_buff *skb = arg;
+	struct BCState	*bcs = st->l1.bcs;
-	long flags;
+	struct sk_buff	*skb = arg;
+	u_long		flags;
 
 	switch (pr) {
 		case (PH_DATA | REQUEST):
-			save_flags(flags);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			cli();
+			if (bcs->tx_skb) {
-			if (st->l1.bcs->tx_skb) {
+				skb_queue_tail(&bcs->squeue, skb);
-				skb_queue_tail(&st->l1.bcs->squeue, skb);
-				restore_flags(flags);
 			} else {
-				st->l1.bcs->tx_skb = skb;
+				bcs->tx_skb = skb;
-				test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+				test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
-				st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
+				bcs->cs->BC_Send_Data(bcs);
 				restore_flags(flags);
 			}
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			break;
 		case (PH_PULL | INDICATION):
-			if (st->l1.bcs->tx_skb) {
+			spin_lock_irqsave(&bcs->cs->lock, flags);
+			if (bcs->tx_skb) {
 				printk(KERN_WARNING "hfc_l2l1: this shouldn't happen\n");
-				break;
+			} else {
+				test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
+				bcs->tx_skb = skb;
+				bcs->cs->BC_Send_Data(bcs);
 			}
-			save_flags(flags);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
-			cli();
-			test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
-			st->l1.bcs->tx_skb = skb;
-			st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
-			restore_flags(flags);
 			break;
 		case (PH_PULL | REQUEST):
-			if (!st->l1.bcs->tx_skb) {
+			if (!bcs->tx_skb) {
 				test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 				st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 			} else
 				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 			break;
 		case (PH_ACTIVATE | REQUEST):
-			test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			mode_hfc(st->l1.bcs, st->l1.mode, st->l1.bc);
+			test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
+			mode_hfc(bcs, st->l1.mode, st->l1.bc);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			l1_msg_b(st, pr, arg);
 			break;
 		case (PH_DEACTIVATE | REQUEST):
 			l1_msg_b(st, pr, arg);
 			break;
 		case (PH_DEACTIVATE | CONFIRM):
-			test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+			test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
-			mode_hfc(st->l1.bcs, 0, st->l1.bc);
+			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
+			mode_hfc(bcs, 0, st->l1.bc);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
 			break;
 	}

drivers/isdn/hisax/hfc_sx.c

@@ -1,6 +1,6 @@
 /* $Id$
  *
- * level driver for CCD´s hfc-s+/sp based cards
+ * level driver for Cologne Chip Designs hfc-s+/sp based cards
  *
  * Author       Werner Cornelius
  *              based on existing driver for CCD HFC PCI cards
@@ -61,25 +61,18 @@ static u_char ccd_sp_irqtab[16] = {
 /******************************/
 static inline void
 Write_hfc(struct IsdnCardState *cs, u_char regnum, u_char val)
-{       unsigned long flags;
+{
-
-        save_flags(flags);
-	cli();
         byteout(cs->hw.hfcsx.base+1, regnum);
 	byteout(cs->hw.hfcsx.base, val);
-	restore_flags(flags);
 } 
 
 static inline u_char
 Read_hfc(struct IsdnCardState *cs, u_char regnum)
-{       unsigned long flags;
+{
         u_char ret; 
 
-        save_flags(flags);
-	cli();
         byteout(cs->hw.hfcsx.base+1, regnum);
 	ret = bytein(cs->hw.hfcsx.base);
-	restore_flags(flags);
 	return(ret);
 } 
 
@@ -89,20 +82,16 @@ Read_hfc(struct IsdnCardState *cs, u_char regnum)
 /**************************************************/
 static void
 fifo_select(struct IsdnCardState *cs, u_char fifo)
-{       unsigned long flags;
+{
-
         if (fifo == cs->hw.hfcsx.last_fifo) 
 	  return; /* still valid */
 
-	save_flags(flags);
-	cli();
         byteout(cs->hw.hfcsx.base+1, HFCSX_FIF_SEL);
 	byteout(cs->hw.hfcsx.base, fifo);
 	while (bytein(cs->hw.hfcsx.base+1) & 1); /* wait for busy */
 	udelay(4);
 	byteout(cs->hw.hfcsx.base, fifo);
 	while (bytein(cs->hw.hfcsx.base+1) & 1); /* wait for busy */
-	restore_flags(flags);
 }
 
 /******************************************/
@@ -111,16 +100,12 @@ fifo_select(struct IsdnCardState *cs, u_char fifo)
 /******************************************/
 static void
 reset_fifo(struct IsdnCardState *cs, u_char fifo)
-{       unsigned long flags;
+{
-
-        save_flags(flags); 
-	cli();
 	fifo_select(cs, fifo); /* first select the fifo */
 	byteout(cs->hw.hfcsx.base+1, HFCSX_CIRM);
 	byteout(cs->hw.hfcsx.base, cs->hw.hfcsx.cirm | 0x80); /* reset cmd */
 	udelay(1);
 	while (bytein(cs->hw.hfcsx.base+1) & 1); /* wait for busy */
-	restore_flags(flags);
 } 
 
 
@@ -131,7 +116,8 @@ reset_fifo(struct IsdnCardState *cs, u_char fifo)
 /*************************************************************/
 static int
 write_fifo(struct IsdnCardState *cs, struct sk_buff *skb, u_char fifo, int trans_max)
-{       unsigned short *msp;
+{
+       unsigned short *msp;
         int fifo_size, count, z1, z2;
 	u_char f_msk, f1, f2, *src;
 
@@ -325,17 +311,11 @@ read_fifo(struct IsdnCardState *cs, u_char fifo, int trans_max)
 void
 release_io_hfcsx(struct IsdnCardState *cs)
 {
-	unsigned long flags;
-
-	save_flags(flags);
-	cli();
 	cs->hw.hfcsx.int_m2 = 0;	/* interrupt output off ! */
 	Write_hfc(cs, HFCSX_INT_M2, cs->hw.hfcsx.int_m2);
 	Write_hfc(cs, HFCSX_CIRM, HFCSX_RESET);	/* Reset On */
-	sti();
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((30 * HZ) / 1000);	/* Timeout 30ms */
-	restore_flags(flags);
 	Write_hfc(cs, HFCSX_CIRM, 0);	/* Reset Off */
 	del_timer(&cs->hw.hfcsx.timer);
 	release_region(cs->hw.hfcsx.base, 2); /* release IO-Block */
@@ -370,22 +350,15 @@ static int set_fifo_size(struct IsdnCardState *cs)
 static void
 reset_hfcsx(struct IsdnCardState *cs)
 {
-	long flags;
-
-	save_flags(flags);
-	cli();
 	cs->hw.hfcsx.int_m2 = 0;	/* interrupt output off ! */
 	Write_hfc(cs, HFCSX_INT_M2, cs->hw.hfcsx.int_m2);
 
 	printk(KERN_INFO "HFC_SX: resetting card\n");
 	while (1) {
 	  Write_hfc(cs, HFCSX_CIRM, HFCSX_RESET | cs->hw.hfcsx.cirm ); /* Reset */
-	  sti();
+	  mdelay(30);
-	  set_current_state(TASK_UNINTERRUPTIBLE);
-	  schedule_timeout((30 * HZ) / 1000);	/* Timeout 30ms */
 	  Write_hfc(cs, HFCSX_CIRM, cs->hw.hfcsx.cirm); /* Reset Off */
-	  set_current_state(TASK_UNINTERRUPTIBLE);
+	  mdelay(20);
-	  schedule_timeout((20 * HZ) / 1000);	/* Timeout 20ms */
 	  if (Read_hfc(cs, HFCSX_STATUS) & 2)
 	    printk(KERN_WARNING "HFC-SX init bit busy\n");
 	  cs->hw.hfcsx.last_fifo = 0xff; /* invalidate */
@@ -440,7 +413,6 @@ reset_hfcsx(struct IsdnCardState *cs)
 	cs->hw.hfcsx.int_m2 = HFCSX_IRQ_ENABLE;
 	Write_hfc(cs, HFCSX_INT_M2, cs->hw.hfcsx.int_m2);
 	if (Read_hfc(cs, HFCSX_INT_S2));
-	restore_flags(flags);
 }
 
 /***************************************************/
@@ -456,29 +428,6 @@ hfcsx_Timer(struct IsdnCardState *cs)
  */
 }
 
-
-/*********************************/
-/* schedule a new D-channel task */
-/*********************************/
-static void
-sched_event_D_sx(struct IsdnCardState *cs, int event)
-{
-	test_and_set_bit(event, &cs->event);
-	queue_task(&cs->tqueue, &tq_immediate);
-	mark_bh(IMMEDIATE_BH);
-}
-
-/*********************************/
-/* schedule a new b_channel task */
-/*********************************/
-static void
-hfcsx_sched_event(struct BCState *bcs, int event)
-{
-	bcs->event |= 1 << event;
-	queue_task(&bcs->tqueue, &tq_immediate);
-	mark_bh(IMMEDIATE_BH);
-}
-
 /************************************************/
 /* select a b-channel entry matching and active */
 /************************************************/
@@ -513,7 +462,7 @@ receive_dmsg(struct IsdnCardState *cs)
 	  skb = read_fifo(cs, HFCSX_SEL_D_RX, 0);
 	  if (skb) {
 	    skb_queue_tail(&cs->rq, skb);
-	    sched_event_D_sx(cs, D_RCVBUFREADY);
+	    schedule_event(cs, D_RCVBUFREADY);
 	  }
 	} while (--count && skb);
 
@@ -527,38 +476,29 @@ receive_dmsg(struct IsdnCardState *cs)
 void
 main_rec_hfcsx(struct BCState *bcs)
 {
-	long flags;
 	struct IsdnCardState *cs = bcs->cs;
 	int count = 5;
 	struct sk_buff *skb;
 
-	save_flags(flags);
-	  
       Begin:
 	count--;
-	cli();
 	if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
 		debugl1(cs, "rec_data %d blocked", bcs->channel);
-		restore_flags(flags);
 		return;
 	}
-	sti();
 	skb = read_fifo(cs, ((bcs->channel) && (!cs->hw.hfcsx.bswapped)) ? 
 			HFCSX_SEL_B2_RX : HFCSX_SEL_B1_RX,
 			(bcs->mode == L1_MODE_TRANS) ? 
 			HFCSX_BTRANS_THRESHOLD : 0);
 
 	if (skb) {
-	  cli();
 	  skb_queue_tail(&bcs->rqueue, skb);
-	  sti();
+	  schedule_event(bcs, B_RCVBUFREADY);
-	  hfcsx_sched_event(bcs, B_RCVBUFREADY);
 	}
 
 	test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
 	if (count && skb)
 		goto Begin;
-	restore_flags(flags);
 	return;
 }
 
@@ -587,16 +527,12 @@ static void
 hfcsx_fill_fifo(struct BCState *bcs)
 {
 	struct IsdnCardState *cs = bcs->cs;
-	unsigned long flags;
 
 	if (!bcs->tx_skb)
 		return;
 	if (bcs->tx_skb->len <= 0)
 		return;
 
-	save_flags(flags);
-	sti();
-
 	if (write_fifo(cs, bcs->tx_skb, 
 		       ((bcs->channel) && (!cs->hw.hfcsx.bswapped)) ? 
 		       HFCSX_SEL_B2_TX : HFCSX_SEL_B1_TX,
@@ -611,10 +547,6 @@ hfcsx_fill_fifo(struct BCState *bcs)
 	  bcs->tx_skb = NULL;
 	  test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 	}
-
-	cli();
-	restore_flags(flags);
-	return;
 }
 
 /**********************************************/
@@ -663,8 +595,7 @@ hfcsx_auxcmd(struct IsdnCardState *cs, isdn_ctrl * ic)
 
 	if ((ic->arg == 98) &&
 	    (!(cs->hw.hfcsx.int_m1 & (HFCSX_INTS_B2TRANS + HFCSX_INTS_B2REC + HFCSX_INTS_B1TRANS + HFCSX_INTS_B1REC)))) {
-		save_flags(flags);
+	    	spin_lock_irqsave(&cs->lock, flags);
-		cli();
 		Write_hfc(cs, HFCSX_STATES, HFCSX_LOAD_STATE | 0);	/* HFC ST G0 */
 		udelay(10);
 		cs->hw.hfcsx.sctrl |= SCTRL_MODE_NT;
@@ -676,8 +607,8 @@ hfcsx_auxcmd(struct IsdnCardState *cs, isdn_ctrl * ic)
 		cs->dc.hfcsx.ph_state = 1;
 		cs->hw.hfcsx.nt_mode = 1;
 		cs->hw.hfcsx.nt_timer = 0;
+		spin_unlock_irqrestore(&cs->lock, flags);
 		cs->stlist->l2.l2l1 = dch_nt_l2l1;
-		restore_flags(flags);
 		debugl1(cs, "NT mode activated");
 		return (0);
 	}
@@ -685,8 +616,6 @@ hfcsx_auxcmd(struct IsdnCardState *cs, isdn_ctrl * ic)
 	    (cs->hw.hfcsx.nt_mode) || (ic->arg != 12))
 		return (-EINVAL);
 
-	save_flags(flags);
-	cli();
 	if (i) {
 		cs->logecho = 1;
 		cs->hw.hfcsx.trm |= 0x20;	/* enable echo chan */
@@ -701,13 +630,14 @@ hfcsx_auxcmd(struct IsdnCardState *cs, isdn_ctrl * ic)
 	cs->hw.hfcsx.sctrl &= ~SCTRL_B2_ENA;
 	cs->hw.hfcsx.conn |= 0x10;	/* B2-IOM -> B2-ST */
 	cs->hw.hfcsx.ctmt &= ~2;
+	spin_lock_irqsave(&cs->lock, flags);
 	Write_hfc(cs, HFCSX_CTMT, cs->hw.hfcsx.ctmt);
 	Write_hfc(cs, HFCSX_SCTRL_R, cs->hw.hfcsx.sctrl_r);
 	Write_hfc(cs, HFCSX_SCTRL, cs->hw.hfcsx.sctrl);
 	Write_hfc(cs, HFCSX_CONNECT, cs->hw.hfcsx.conn);
 	Write_hfc(cs, HFCSX_TRM, cs->hw.hfcsx.trm);
 	Write_hfc(cs, HFCSX_INT_M1, cs->hw.hfcsx.int_m1);
-	restore_flags(flags);
+	spin_unlock_irqrestore(&cs->lock, flags);
 	return (0);
 }				/* hfcsx_auxcmd */
 
@@ -717,21 +647,14 @@ hfcsx_auxcmd(struct IsdnCardState *cs, isdn_ctrl * ic)
 static void
 receive_emsg(struct IsdnCardState *cs)
 {
-	unsigned long flags;
 	int count = 5;
 	u_char *ptr;
 	struct sk_buff *skb;
 
-
-	save_flags(flags);
-	cli();
 	if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
 		debugl1(cs, "echo_rec_data blocked");
-		restore_flags(flags);
 		return;
 	}
-	sti();
-
 	do {
 	  skb = read_fifo(cs, HFCSX_SEL_B2_RX, 0);
 	  if (skb) {
@@ -756,7 +679,6 @@ receive_emsg(struct IsdnCardState *cs)
 	} while (--count && skb);
 
 	test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
-	restore_flags(flags);
 	return;
 }				/* receive_emsg */
 
@@ -764,30 +686,28 @@ receive_emsg(struct IsdnCardState *cs)
 /*********************/
 /* Interrupt handler */
 /*********************/
-static void
+static irqreturn_t
 hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 {
 	struct IsdnCardState *cs = dev_id;
 	u_char exval;
 	struct BCState *bcs;
 	int count = 15;
-	long flags;
+	u_long flags;
 	u_char val, stat;
 
-	if (!cs) {
-		printk(KERN_WARNING "HFC-SX: Spurious interrupt!\n");
-		return;
-	}
 	if (!(cs->hw.hfcsx.int_m2 & 0x08))
-		return;		/* not initialised */
+		return IRQ_NONE;		/* not initialised */
 
+	spin_lock_irqsave(&cs->lock, flags);
 	if (HFCSX_ANYINT & (stat = Read_hfc(cs, HFCSX_STATUS))) {
 		val = Read_hfc(cs, HFCSX_INT_S1);
 		if (cs->debug & L1_DEB_ISAC)
 			debugl1(cs, "HFC-SX: stat(%02x) s1(%02x)", stat, val);
-	} else
+	} else {
-		return;
+		spin_unlock_irqrestore(&cs->lock, flags);
-
+		return IRQ_NONE;
+	}
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "HFC-SX irq %x %s", val,
 			test_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags) ?
@@ -799,24 +719,22 @@ hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 			debugl1(cs, "ph_state chg %d->%d", cs->dc.hfcsx.ph_state,
 				exval);
 		cs->dc.hfcsx.ph_state = exval;
-		sched_event_D_sx(cs, D_L1STATECHANGE);
+		schedule_event(cs, D_L1STATECHANGE);
 		val &= ~0x40;
 	}
 	if (val & 0x80) {	/* timer irq */
 		if (cs->hw.hfcsx.nt_mode) {
 			if ((--cs->hw.hfcsx.nt_timer) < 0)
-				sched_event_D_sx(cs, D_L1STATECHANGE);
+				schedule_event(cs, D_L1STATECHANGE);
 		}
 		val &= ~0x80;
 		Write_hfc(cs, HFCSX_CTMT, cs->hw.hfcsx.ctmt | HFCSX_CLTIMER);
 	}
 	while (val) {
-		save_flags(flags);
-		cli();
 		if (test_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
 			cs->hw.hfcsx.int_s1 |= val;
-			restore_flags(flags);
+			spin_unlock_irqrestore(&cs->lock, flags);
-			return;
+			return IRQ_HANDLED;
 		}
 		if (cs->hw.hfcsx.int_s1 & 0x18) {
 			exval = val;
@@ -858,7 +776,7 @@ hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 						} else
 							debugl1(cs, "fill_data %d blocked", bcs->channel);
 					} else {
-						hfcsx_sched_event(bcs, B_XMTBUFREADY);
+						schedule_event(bcs, B_XMTBUFREADY);
 					}
 				}
 			}
@@ -882,7 +800,7 @@ hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 						} else
 							debugl1(cs, "fill_data %d blocked", bcs->channel);
 					} else {
-						hfcsx_sched_event(bcs, B_XMTBUFREADY);
+						schedule_event(bcs, B_XMTBUFREADY);
 					}
 				}
 			}
@@ -894,7 +812,7 @@ hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 			if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
 				del_timer(&cs->dbusytimer);
 			if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
-				sched_event_D_sx(cs, D_CLEARBUSY);
+				schedule_event(cs, D_CLEARBUSY);
 			if (cs->tx_skb) {
 				if (cs->tx_skb->len) {
 					if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
@@ -919,7 +837,7 @@ hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 					debugl1(cs, "hfcsx_fill_dfifo irq blocked");
 				}
 			} else
-				sched_event_D_sx(cs, D_XMTBUFREADY);
+				schedule_event(cs, D_XMTBUFREADY);
 		}
 	      afterXPR:
 		if (cs->hw.hfcsx.int_s1 && count--) {
@@ -929,8 +847,9 @@ hfcsx_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 				debugl1(cs, "HFC-SX irq %x loop %d", val, 15 - count);
 		} else
 			val = 0;
-		restore_flags(flags);
 	}
+	spin_unlock_irqrestore(&cs->lock, flags);
+	return IRQ_HANDLED;
 }
 
 /********************************************************************/
@@ -949,7 +868,7 @@ HFCSX_l1hw(struct PStack *st, int pr, void *arg)
 {
 	struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
 	struct sk_buff *skb = arg;
-	unsigned long flags;
+	u_long flags;
 
 	switch (pr) {
 		case (PH_DATA | REQUEST):
@@ -957,6 +876,7 @@ HFCSX_l1hw(struct PStack *st, int pr, void *arg)
 				LogFrame(cs, skb->data, skb->len);
 			if (cs->debug & DEB_DLOG_VERBOSE)
 				dlogframe(cs, skb, 0);
+			spin_lock_irqsave(&cs->lock, flags);
 			if (cs->tx_skb) {
 				skb_queue_tail(&cs->sq, skb);
 #ifdef L2FRAME_DEBUG		/* psa */
@@ -977,12 +897,15 @@ HFCSX_l1hw(struct PStack *st, int pr, void *arg)
 					debugl1(cs, "hfcsx_fill_dfifo blocked");
 
 			}
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (PH_PULL | INDICATION):
+			spin_lock_irqsave(&cs->lock, flags);
 			if (cs->tx_skb) {
 				if (cs->debug & L1_DEB_WARN)
 					debugl1(cs, " l2l1 tx_skb exist this shouldn't happen");
 				skb_queue_tail(&cs->sq, skb);
+				spin_unlock_irqrestore(&cs->lock, flags);
 				break;
 			}
 			if (cs->debug & DEB_DLOG_HEX)
@@ -1000,6 +923,7 @@ HFCSX_l1hw(struct PStack *st, int pr, void *arg)
 				test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
 			} else
 				debugl1(cs, "hfcsx_fill_dfifo blocked");
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (PH_PULL | REQUEST):
 #ifdef L2FRAME_DEBUG		/* psa */
@@ -1013,57 +937,57 @@ HFCSX_l1hw(struct PStack *st, int pr, void *arg)
 				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 			break;
 		case (HW_RESET | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			Write_hfc(cs, HFCSX_STATES, HFCSX_LOAD_STATE | 3);	/* HFC ST 3 */
 			udelay(6);
 			Write_hfc(cs, HFCSX_STATES, 3);	/* HFC ST 2 */
 			cs->hw.hfcsx.mst_m |= HFCSX_MASTER;
 			Write_hfc(cs, HFCSX_MST_MODE, cs->hw.hfcsx.mst_m);
 			Write_hfc(cs, HFCSX_STATES, HFCSX_ACTIVATE | HFCSX_DO_ACTION);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			l1_msg(cs, HW_POWERUP | CONFIRM, NULL);
 			break;
 		case (HW_ENABLE | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			Write_hfc(cs, HFCSX_STATES, HFCSX_ACTIVATE | HFCSX_DO_ACTION);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (HW_DEACTIVATE | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->hw.hfcsx.mst_m &= ~HFCSX_MASTER;
 			Write_hfc(cs, HFCSX_MST_MODE, cs->hw.hfcsx.mst_m);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (HW_INFO3 | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->hw.hfcsx.mst_m |= HFCSX_MASTER;
 			Write_hfc(cs, HFCSX_MST_MODE, cs->hw.hfcsx.mst_m);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		case (HW_TESTLOOP | REQUEST):
+			spin_lock_irqsave(&cs->lock, flags);
 			switch ((int) arg) {
 				case (1):
 					Write_hfc(cs, HFCSX_B1_SSL, 0x80);	/* tx slot */
 					Write_hfc(cs, HFCSX_B1_RSL, 0x80);	/* rx slot */
-					save_flags(flags);
-					cli();
 					cs->hw.hfcsx.conn = (cs->hw.hfcsx.conn & ~7) | 1;
 					Write_hfc(cs, HFCSX_CONNECT, cs->hw.hfcsx.conn);
-					restore_flags(flags);
 					break;
-
 				case (2):
 					Write_hfc(cs, HFCSX_B2_SSL, 0x81);	/* tx slot */
 					Write_hfc(cs, HFCSX_B2_RSL, 0x81);	/* rx slot */
-					save_flags(flags);
-					cli();
 					cs->hw.hfcsx.conn = (cs->hw.hfcsx.conn & ~0x38) | 0x08;
 					Write_hfc(cs, HFCSX_CONNECT, cs->hw.hfcsx.conn);
-					restore_flags(flags);
 					break;
-
 				default:
+					spin_unlock_irqrestore(&cs->lock, flags);
 					if (cs->debug & L1_DEB_WARN)
 						debugl1(cs, "hfcsx_l1hw loop invalid %4x", (int) arg);
 					return;
 			}
-			save_flags(flags);
-			cli();
 			cs->hw.hfcsx.trm |= 0x80;	/* enable IOM-loop */
 			Write_hfc(cs, HFCSX_TRM, cs->hw.hfcsx.trm);
-			restore_flags(flags);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			break;
 		default:
 			if (cs->debug & L1_DEB_WARN)
@@ -1103,7 +1027,6 @@ void
 mode_hfcsx(struct BCState *bcs, int mode, int bc)
 {
 	struct IsdnCardState *cs = bcs->cs;
-	unsigned long flags;
 	int fifo2;
 
 	if (cs->debug & L1_DEB_HSCX)
@@ -1112,8 +1035,6 @@ mode_hfcsx(struct BCState *bcs, int mode, int bc)
 	bcs->mode = mode;
 	bcs->channel = bc;
 	fifo2 = bc;
-	save_flags(flags);
-	cli();
 	if (cs->chanlimit > 1) {
 		cs->hw.hfcsx.bswapped = 0;	/* B1 and B2 normal mode */
 		cs->hw.hfcsx.sctrl_e &= ~0x80;
@@ -1207,7 +1128,6 @@ mode_hfcsx(struct BCState *bcs, int mode, int bc)
 	  reset_fifo(cs, fifo2 ? HFCSX_SEL_B2_RX : HFCSX_SEL_B1_RX);
 	  reset_fifo(cs, fifo2 ? HFCSX_SEL_B2_TX : HFCSX_SEL_B1_TX);
 	}
-	restore_flags(flags);
 }
 
 /******************************/
@@ -1216,54 +1136,56 @@ mode_hfcsx(struct BCState *bcs, int mode, int bc)
 static void
 hfcsx_l2l1(struct PStack *st, int pr, void *arg)
 {
+	struct BCState *bcs = st->l1.bcs;
 	struct sk_buff *skb = arg;
-	long flags;
+	u_long flags;
 
 	switch (pr) {
 		case (PH_DATA | REQUEST):
-			save_flags(flags);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			cli();
+			if (bcs->tx_skb) {
-			if (st->l1.bcs->tx_skb) {
+				skb_queue_tail(&bcs->squeue, skb);
-				skb_queue_tail(&st->l1.bcs->squeue, skb);
-				restore_flags(flags);
 			} else {
-				st->l1.bcs->tx_skb = skb;
+				bcs->tx_skb = skb;
-/*                              test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+//                              test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
- */ st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
+				bcs->cs->BC_Send_Data(bcs);
-				restore_flags(flags);
 			}
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			break;
 		case (PH_PULL | INDICATION):
-			if (st->l1.bcs->tx_skb) {
+			spin_lock_irqsave(&bcs->cs->lock, flags);
+			if (bcs->tx_skb) {
 				printk(KERN_WARNING "hfc_l2l1: this shouldn't happen\n");
-				break;
+			} else {
+//				test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
+				bcs->tx_skb = skb;
+				bcs->cs->BC_Send_Data(bcs);
 			}
-			save_flags(flags);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
-			cli();
-/*                      test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
- */ st->l1.bcs->tx_skb = skb;
-			st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
-			restore_flags(flags);
 			break;
 		case (PH_PULL | REQUEST):
-			if (!st->l1.bcs->tx_skb) {
+			if (!bcs->tx_skb) {
 				test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 				st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 			} else
 				test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 			break;
 		case (PH_ACTIVATE | REQUEST):
-			test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			mode_hfcsx(st->l1.bcs, st->l1.mode, st->l1.bc);
+			test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
+			mode_hfcsx(bcs, st->l1.mode, st->l1.bc);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			l1_msg_b(st, pr, arg);
 			break;
 		case (PH_DEACTIVATE | REQUEST):
 			l1_msg_b(st, pr, arg);
 			break;
 		case (PH_DEACTIVATE | CONFIRM):
-			test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+			spin_lock_irqsave(&bcs->cs->lock, flags);
-			test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+			test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
-			mode_hfcsx(st->l1.bcs, 0, st->l1.bc);
+			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
+			mode_hfcsx(bcs, 0, st->l1.bc);
+			spin_unlock_irqrestore(&bcs->cs->lock, flags);
 			st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
 			break;
 	}
@@ -1327,9 +1249,8 @@ setstack_2b(struct PStack *st, struct BCState *bcs)
 static void
 hfcsx_bh(struct IsdnCardState *cs)
 {
-	unsigned long flags;
+	u_long flags;
-/*      struct PStack *stptr;
+
- */
 	if (!cs)
 		return;
 	if (test_and_clear_bit(D_L1STATECHANGE, &cs->event)) {
@@ -1355,8 +1276,7 @@ hfcsx_bh(struct IsdnCardState *cs)
 		} else {
 			switch (cs->dc.hfcsx.ph_state) {
 				case (2):
-					save_flags(flags);
+					spin_lock_irqsave(&cs->lock, flags);
-					cli();
 					if (cs->hw.hfcsx.nt_timer < 0) {
 						cs->hw.hfcsx.nt_timer = 0;
 						cs->hw.hfcsx.int_m1 &= ~HFCSX_INTS_TIMER;
@@ -1378,17 +1298,16 @@ hfcsx_bh(struct IsdnCardState *cs)
 						cs->hw.hfcsx.nt_timer = NT_T1_COUNT;
 						Write_hfc(cs, HFCSX_STATES, 2 | HFCSX_NT_G2_G3);	/* allow G2 -> G3 transition */
 					}
-					restore_flags(flags);
+					spin_unlock_irqrestore(&cs->lock, flags);
 					break;
 				case (1):
 				case (3):
 				case (4):
-					save_flags(flags);
+					spin_lock_irqsave(&cs->lock, flags);
-					cli();
 					cs->hw.hfcsx.nt_timer = 0;
 					cs->hw.hfcsx.int_m1 &= ~HFCSX_INTS_TIMER;
 					Write_hfc(cs, HFCSX_INT_M1, cs->hw.hfcsx.int_m1);
-					restore_flags(flags);
+					spin_unlock_irqrestore(&cs->lock, flags);
 					break;
 				default:
 					break;
@@ -1409,10 +1328,6 @@ void __devinit
 inithfcsx(struct IsdnCardState *cs)
 {
 	cs->setstack_d = setstack_hfcsx;
-	cs->dbusytimer.function = (void *) hfcsx_dbusy_timer;
-	cs->dbusytimer.data = (long) cs;
-	init_timer(&cs->dbusytimer);
-	cs->tqueue.routine = (void *) (void *) hfcsx_bh;
 	cs->BC_Send_Data = &hfcsx_send_data;
 	cs->bcs[0].BC_SetStack = setstack_2b;
 	cs->bcs[1].BC_SetStack = setstack_2b;
@@ -1430,29 +1345,32 @@ inithfcsx(struct IsdnCardState *cs)
 static int
 hfcsx_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
-	long flags;
+	u_long flags;
 
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "HFCSX: card_msg %x", mt);
 	switch (mt) {
 		case CARD_RESET:
+			spin_lock_irqsave(&cs->lock, flags);
 			reset_hfcsx(cs);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return (0);
 		case CARD_RELEASE:
 			release_io_hfcsx(cs);
 			return (0);
 		case CARD_INIT:
+			spin_lock_irqsave(&cs->lock, flags);
 			inithfcsx(cs);
-			save_flags(flags);
+			spin_unlock_irqrestore(&cs->lock, flags);
-			sti();
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout((80 * HZ) / 1000);	/* Timeout 80ms */
 			/* now switch timer interrupt off */
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->hw.hfcsx.int_m1 &= ~HFCSX_INTS_TIMER;
 			Write_hfc(cs, HFCSX_INT_M1, cs->hw.hfcsx.int_m1);
 			/* reinit mode reg */
 			Write_hfc(cs, HFCSX_MST_MODE, cs->hw.hfcsx.mst_m);
-			restore_flags(flags);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return (0);
 		case CARD_TEST:
 			return (0);
@@ -1468,8 +1386,8 @@ static struct isapnp_device_id hfc_ids[] __initdata = {
 	{ 0, }
 };
 
-static struct isapnp_device_id *hdev = &hfc_ids[0];
+static struct isapnp_device_id *ipid __initdata = &hfc_ids[0];
-static struct pci_bus *pnp_c __devinitdata = NULL;
+static struct pnp_card *pnp_c __devinitdata = NULL;
 #endif
 
 int __devinit
@@ -1477,33 +1395,35 @@ setup_hfcsx(struct IsdnCard *card)
 {
 	struct IsdnCardState *cs = card->cs;
 	char tmp[64];
-	unsigned long flags;
 
 	strcpy(tmp, hfcsx_revision);
 	printk(KERN_INFO "HiSax: HFC-SX driver Rev. %s\n", HiSax_getrev(tmp));
 #ifdef __ISAPNP__
 	if (!card->para[1] && isapnp_present()) {
-		struct pci_bus *pb;
+		struct pnp_dev *pnp_d;
-		struct pci_dev *pd;
+		while(ipid->card_vendor) {
+			if ((pnp_c = pnp_find_card(ipid->card_vendor,
+				ipid->card_device, pnp_c))) {
+				pnp_d = NULL;
+				if ((pnp_d = pnp_find_dev(pnp_c,
+					ipid->vendor, ipid->function, pnp_d))) {
+					int err;
 
-		while(hdev->card_vendor) {
-			if ((pb = isapnp_find_card(hdev->card_vendor,
-				hdev->card_device, pnp_c))) {
-				pnp_c = pb;
-				pd = NULL;
-				if ((pd = isapnp_find_dev(pnp_c,
-					hdev->vendor, hdev->function, pd))) {
 					printk(KERN_INFO "HiSax: %s detected\n",
-						(char *)hdev->driver_data);
+						(char *)ipid->driver_data);
-					pd->prepare(pd);
+					pnp_disable_dev(pnp_d);
-					pd->deactivate(pd);
+					err = pnp_activate_dev(pnp_d);
-					pd->activate(pd);
+					if (err<0) {
-					card->para[1] = pd->resource[0].start;
+						printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
-					card->para[0] = pd->irq_resource[0].start;
+							__FUNCTION__, err);
+						return(0);
+					}
+					card->para[1] = pnp_port_start(pnp_d, 0);
+					card->para[0] = pnp_irq(pnp_d, 0);
 					if (!card->para[0] || !card->para[1]) {
 						printk(KERN_ERR "HFC PnP:some resources are missing %ld/%lx\n",
-						card->para[0], card->para[1]);
+							card->para[0], card->para[1]);
-						pd->deactivate(pd);
+						pnp_disable_dev(pnp_d);
 						return(0);
 					}
 					break;
@@ -1511,10 +1431,10 @@ setup_hfcsx(struct IsdnCard *card)
 					printk(KERN_ERR "HFC PnP: PnP error card found, no device\n");
 				}
 			}
-			hdev++;
+			ipid++;
-			pnp_c=NULL;
+			pnp_c = NULL;
 		} 
-		if (!hdev->card_vendor) {
+		if (!ipid->card_vendor) {
 			printk(KERN_INFO "HFC PnP: no ISAPnP card found\n");
 			return(0);
 		}
@@ -1527,14 +1447,11 @@ setup_hfcsx(struct IsdnCard *card)
 	cs->hw.hfcsx.fifo = 255;
 	if ((cs->typ == ISDN_CTYPE_HFC_SX) || 
 	    (cs->typ == ISDN_CTYPE_HFC_SP_PCMCIA)) {
-	        if ((!cs->hw.hfcsx.base) || 
+	        if ((!cs->hw.hfcsx.base) || !request_region(cs->hw.hfcsx.base, 2, "HFCSX isdn")) {
-		    check_region((cs->hw.hfcsx.base), 2)) {
 		  printk(KERN_WARNING
 			 "HiSax: HFC-SX io-base %#lx already in use\n",
 		          cs->hw.hfcsx.base);
 		  return(0);
-		} else {
-		  request_region(cs->hw.hfcsx.base, 2, "HFCSX isdn");
 		}
 		byteout(cs->hw.hfcsx.base, cs->hw.hfcsx.base & 0xFF);
 		byteout(cs->hw.hfcsx.base + 1,
@@ -1561,21 +1478,14 @@ setup_hfcsx(struct IsdnCard *card)
 		  release_region(cs->hw.hfcsx.base, 2);
 		  return(0);
 		}  
-		save_flags(flags);
-		cli();
 		if (!(cs->hw.hfcsx.extra = (void *)
 		      kmalloc(sizeof(struct hfcsx_extra), GFP_ATOMIC))) {
-		  restore_flags(flags);
 		  release_region(cs->hw.hfcsx.base, 2);
 		  printk(KERN_WARNING "HFC-SX: unable to allocate memory\n");
 		  return(0);
 		}
-		restore_flags(flags);
+		printk(KERN_INFO "HFC-S%c chip detected at base 0x%x IRQ %d HZ %d\n",
-
+			tmp[0], (u_int) cs->hw.hfcsx.base, cs->irq, HZ);
-		printk(KERN_INFO
-		       "HFC-S%c chip detected at base 0x%x IRQ %d HZ %d\n",
-		       tmp[0], (u_int) cs->hw.hfcsx.base,
-		       cs->irq, HZ);
 		cs->hw.hfcsx.int_m2 = 0;	/* disable alle interrupts */
 		cs->hw.hfcsx.int_m1 = 0;
 		Write_hfc(cs, HFCSX_INT_M1, cs->hw.hfcsx.int_m1);
@@ -1583,6 +1493,10 @@ setup_hfcsx(struct IsdnCard *card)
 	} else
 		return (0);	/* no valid card type */
 
+	cs->dbusytimer.function = (void *) hfcsx_dbusy_timer;
+	cs->dbusytimer.data = (long) cs;
+	init_timer(&cs->dbusytimer);
+	INIT_WORK(&cs->tqueue, (void *)(void *) hfcsx_bh, cs);
 	cs->readisac = NULL;
 	cs->writeisac = NULL;
 	cs->readisacfifo = NULL;

drivers/isdn/hisax/hfcscard.c

@@ -20,16 +20,14 @@ extern const char *CardType[];
 
 static const char *hfcs_revision = "$Revision$";
 
-static void
+static irqreturn_t
 hfcs_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 {
 	struct IsdnCardState *cs = dev_id;
 	u_char val, stat;
+	u_long flags;
 
-	if (!cs) {
+	spin_lock_irqsave(&cs->lock, flags);
-		printk(KERN_WARNING "HFCS: Spurious interrupt!\n");
-		return;
-	}
 	if ((HFCD_ANYINT | HFCD_BUSY_NBUSY) & 
 		(stat = cs->BC_Read_Reg(cs, HFCD_DATA, HFCD_STAT))) {
 		val = cs->BC_Read_Reg(cs, HFCD_DATA, HFCD_INT_S1);
@@ -40,6 +38,8 @@ hfcs_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 		if (cs->debug & L1_DEB_ISAC)
 			debugl1(cs, "HFCS: irq_no_irq stat(%02x)", stat);
 	}
+	spin_unlock_irqrestore(&cs->lock, flags);
+	return IRQ_HANDLED;
 }
 
 static void
@@ -102,29 +102,36 @@ reset_hfcs(struct IsdnCardState *cs)
 static int
 hfcs_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
-	long flags;
+	u_long flags;
+	int delay;
 
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "HFCS: card_msg %x", mt);
 	switch (mt) {
 		case CARD_RESET:
+			spin_lock_irqsave(&cs->lock, flags);
 			reset_hfcs(cs);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return(0);
 		case CARD_RELEASE:
 			release_io_hfcs(cs);
 			return(0);
 		case CARD_INIT:
-			cs->hw.hfcD.timer.expires = jiffies + 75;
+			delay = (75*HZ)/100 +1;
+			cs->hw.hfcD.timer.expires = jiffies + delay;
 			add_timer(&cs->hw.hfcD.timer);
+			spin_lock_irqsave(&cs->lock, flags);
+			reset_hfcs(cs);
 			init2bds0(cs);
-			save_flags(flags);
+			spin_unlock_irqrestore(&cs->lock, flags);
-			sti();
+			delay = (80*HZ)/1000 +1;
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout((80*HZ)/1000);
+			spin_lock_irqsave(&cs->lock, flags);
 			cs->hw.hfcD.ctmt |= HFCD_TIM800;
 			cs->BC_Write_Reg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcD.ctmt); 
 			cs->BC_Write_Reg(cs, HFCD_DATA, HFCD_MST_MODE, cs->hw.hfcD.mst_m);
-			restore_flags(flags);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return(0);
 		case CARD_TEST:
 			return(0);
@@ -158,8 +165,8 @@ static struct isapnp_device_id hfc_ids[] __initdata = {
 	{ 0, }
 };
 
-static struct isapnp_device_id *hdev = &hfc_ids[0];
+static struct isapnp_device_id *ipid __initdata = &hfc_ids[0];
-static struct pci_bus *pnp_c __devinitdata = NULL;
+static struct pnp_card *pnp_c __devinitdata = NULL;
 #endif
 
 int __init
@@ -173,27 +180,30 @@ setup_hfcs(struct IsdnCard *card)
 
 #ifdef __ISAPNP__
 	if (!card->para[1] && isapnp_present()) {
-		struct pci_bus *pb;
+		struct pnp_dev *pnp_d;
-		struct pci_dev *pd;
+		while(ipid->card_vendor) {
+			if ((pnp_c = pnp_find_card(ipid->card_vendor,
+				ipid->card_device, pnp_c))) {
+				pnp_d = NULL;
+				if ((pnp_d = pnp_find_dev(pnp_c,
+					ipid->vendor, ipid->function, pnp_d))) {
+					int err;
 
-		while(hdev->card_vendor) {
-			if ((pb = isapnp_find_card(hdev->card_vendor,
-				hdev->card_device, pnp_c))) {
-				pnp_c = pb;
-				pd = NULL;
-				if ((pd = isapnp_find_dev(pnp_c,
-					hdev->vendor, hdev->function, pd))) {
 					printk(KERN_INFO "HiSax: %s detected\n",
-						(char *)hdev->driver_data);
+						(char *)ipid->driver_data);
-					pd->prepare(pd);
+					pnp_disable_dev(pnp_d);
-					pd->deactivate(pd);
+					err = pnp_activate_dev(pnp_d);
-					pd->activate(pd);
+					if (err<0) {
-					card->para[1] = pd->resource[0].start;
+						printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
-					card->para[0] = pd->irq_resource[0].start;
+							__FUNCTION__, err);
+						return(0);
+					}
+					card->para[1] = pnp_port_start(pnp_d, 0);
+					card->para[0] = pnp_irq(pnp_d, 0);
 					if (!card->para[0] || !card->para[1]) {
 						printk(KERN_ERR "HFC PnP:some resources are missing %ld/%lx\n",
-						card->para[0], card->para[1]);
+							card->para[0], card->para[1]);
-						pd->deactivate(pd);
+						pnp_disable_dev(pnp_d);
 						return(0);
 					}
 					break;
@@ -201,10 +211,10 @@ setup_hfcs(struct IsdnCard *card)
 					printk(KERN_ERR "HFC PnP: PnP error card found, no device\n");
 				}
 			}
-			hdev++;
+			ipid++;
-			pnp_c=NULL;
+			pnp_c = NULL;
 		} 
-		if (!hdev->card_vendor) {
+		if (!ipid->card_vendor) {
 			printk(KERN_INFO "HFC PnP: no ISAPnP card found\n");
 			return(0);
 		}
@@ -226,15 +236,13 @@ setup_hfcs(struct IsdnCard *card)
 		cs->hw.hfcD.bfifosize = 7*1024 + 512;
 	} else
 		return (0);
-	if (check_region((cs->hw.hfcD.addr), 2)) {
+	if (!request_region(cs->hw.hfcD.addr, 2, "HFCS isdn")) {
 		printk(KERN_WARNING
 		       "HiSax: %s config port %x-%x already in use\n",
 		       CardType[card->typ],
 		       cs->hw.hfcD.addr,
 		       cs->hw.hfcD.addr + 2);
 		return (0);
-	} else {
-		request_region(cs->hw.hfcD.addr, 2, "HFCS isdn");
 	}
 	printk(KERN_INFO
 	       "HFCS: defined at 0x%x IRQ %d HZ %d\n",
@@ -253,7 +261,6 @@ setup_hfcs(struct IsdnCard *card)
 	cs->hw.hfcD.timer.function = (void *) hfcs_Timer;
 	cs->hw.hfcD.timer.data = (long) cs;
 	init_timer(&cs->hw.hfcD.timer);
-	reset_hfcs(cs);
 	cs->cardmsg = &hfcs_card_msg;
 	cs->irq_func = &hfcs_interrupt;
 	return (1);

drivers/isdn/hisax/hisax_fcpcipnp.c

@@ -50,22 +50,33 @@ MODULE_PARM(debug, "i");
 MODULE_AUTHOR("Kai Germaschewski <kai.germaschewski@gmx.de>/Karsten Keil <kkeil@suse.de>");
 MODULE_DESCRIPTION("AVM Fritz!PCI/PnP ISDN driver");
 
-static struct pci_device_id fcpci_ids[] __devinitdata = {
+static struct pci_device_id fcpci_ids[] = {
-	{ PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_A1   , PCI_ANY_ID, PCI_ANY_ID,
+	{ .vendor      = PCI_VENDOR_ID_AVM,
-	  0, 0, (unsigned long) "Fritz!Card PCI" },
+	  .device      = PCI_DEVICE_ID_AVM_A1,
-	{ PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_A1_V2, PCI_ANY_ID, PCI_ANY_ID,
+	  .subvendor   = PCI_ANY_ID,
-	  0, 0, (unsigned long) "Fritz!Card PCI v2" },
+	  .subdevice   = PCI_ANY_ID,
-	{ }
+	  .driver_data = (unsigned long) "Fritz!Card PCI",
+	},
+	{ .vendor      = PCI_VENDOR_ID_AVM,
+	  .device      = PCI_DEVICE_ID_AVM_A1_V2,
+	  .subvendor   = PCI_ANY_ID,
+	  .subdevice   = PCI_ANY_ID,
+	  .driver_data = (unsigned long) "Fritz!Card PCI v2" },
+	{}
 };
+
 MODULE_DEVICE_TABLE(pci, fcpci_ids);
 
-static struct isapnp_device_id fcpnp_ids[] __devinitdata = {
+#ifdef __ISAPNP__
-	{ ISAPNP_VENDOR('A', 'V', 'M'), ISAPNP_FUNCTION(0x0900),
+static struct pnp_device_id fcpnp_ids[] __devinitdata = {
-	  ISAPNP_VENDOR('A', 'V', 'M'), ISAPNP_FUNCTION(0x0900), 
+	{ 
-	  (unsigned long) "Fritz!Card PnP" },
+		.id		= "AVM0900",
-	{ }
+		.driver_data	= (unsigned long) "Fritz!Card PnP",
+	},
 };
+
 MODULE_DEVICE_TABLE(isapnp, fcpnp_ids);
+#endif
 
 static int protocol = 2;       /* EURO-ISDN Default */
 MODULE_PARM(protocol, "i");
@@ -634,7 +645,8 @@ static void fritz_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
 
 // ----------------------------------------------------------------------
 
-static void fcpci2_irq(int intno, void *dev, struct pt_regs *regs)
+static irqreturn_t
+fcpci2_irq(int intno, void *dev, struct pt_regs *regs)
 {
 	struct fritz_adapter *adapter = dev;
 	unsigned char val;
@@ -642,16 +654,18 @@ static void fcpci2_irq(int intno, void *dev, struct pt_regs *regs)
 	val = inb(adapter->io + AVM_STATUS0);
 	if (!(val & AVM_STATUS0_IRQ_MASK))
 		/* hopefully a shared  IRQ reqest */
-		return;
+		return IRQ_NONE;
 	DBG(2, "STATUS0 %#x", val);
 	if (val & AVM_STATUS0_IRQ_ISAC)
 		isacsx_irq(&adapter->isac);
 
 	if (val & AVM_STATUS0_IRQ_HDLC)
 		hdlc_irq(adapter);
+	return IRQ_HANDLED;
 }
 
-static void fcpci_irq(int intno, void *dev, struct pt_regs *regs)
+static irqreturn_t
+fcpci_irq(int intno, void *dev, struct pt_regs *regs)
 {
 	struct fritz_adapter *adapter = dev;
 	unsigned char sval;
@@ -659,13 +673,14 @@ static void fcpci_irq(int intno, void *dev, struct pt_regs *regs)
 	sval = inb(adapter->io + 2);
 	if ((sval & AVM_STATUS0_IRQ_MASK) == AVM_STATUS0_IRQ_MASK)
 		/* possibly a shared  IRQ reqest */
-		return;
+		return IRQ_NONE;
 	DBG(2, "sval %#x", sval);
 	if (!(sval & AVM_STATUS0_IRQ_ISAC))
 		isac_irq(&adapter->isac);
 
 	if (!(sval & AVM_STATUS0_IRQ_HDLC))
 		hdlc_irq(adapter);
+	return IRQ_HANDLED;
 }
 
 // ----------------------------------------------------------------------
@@ -814,7 +829,7 @@ static void __devexit fcpcipnp_release(struct fritz_adapter *adapter)
 // ----------------------------------------------------------------------
 
 static struct fritz_adapter * __devinit 
-new_adapter(struct pci_dev *pdev)
+new_adapter(void)
 {
 	struct fritz_adapter *adapter;
 	struct hisax_b_if *b_if[2];
@@ -837,8 +852,6 @@ new_adapter(struct pci_dev *pdev)
 		adapter->bcs[i].b_if.ifc.l2l1 = fritz_b_l2l1;
 	}
 
-	pci_set_drvdata(pdev, adapter);
-
 	for (i = 0; i < 2; i++)
 		b_if[i] = &adapter->bcs[i].b_if;
 
@@ -860,10 +873,12 @@ static int __devinit fcpci_probe(struct pci_dev *pdev,
 	int retval;
 
 	retval = -ENOMEM;
-	adapter = new_adapter(pdev);
+	adapter = new_adapter();
 	if (!adapter)
 		goto err;
 
+	pci_set_drvdata(pdev, adapter);
+
 	if (pdev->device == PCI_DEVICE_ID_AVM_A1_V2) 
 		adapter->type = AVM_FRITZ_PCIV2;
 	else
@@ -891,27 +906,36 @@ static int __devinit fcpci_probe(struct pci_dev *pdev,
 	return retval;
 }
 
-static int __devinit fcpnp_probe(struct pci_dev *pdev,
+#ifdef __ISAPNP__
-				 const struct isapnp_device_id *ent)
+static int __devinit fcpnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
 {
 	struct fritz_adapter *adapter;
 	int retval;
 
+	if (!pdev)
+		return(-ENODEV);
+
 	retval = -ENOMEM;
-	adapter = new_adapter(pdev);
+	adapter = new_adapter();
 	if (!adapter)
 		goto err;
 
+	pnp_set_drvdata(pdev, adapter);
+
 	adapter->type = AVM_FRITZ_PNP;
 
-	pdev->prepare(pdev);
+	pnp_disable_dev(pdev);
-	pdev->deactivate(pdev); // why?
+	retval = pnp_activate_dev(pdev);
-	pdev->activate(pdev);
+	if (retval < 0) {
-	adapter->io = pdev->resource[0].start;
+		printk(KERN_WARNING "%s: pnp_activate_dev(%s) ret(%d)\n", __FUNCTION__,
-	adapter->irq = pdev->irq_resource[0].start;
+			(char *)dev_id->driver_data, retval);
+		goto err_free;
+	}
+	adapter->io = pnp_port_start(pdev, 0);
+	adapter->irq = pnp_irq(pdev, 0);
 
 	printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at IO %#x irq %d\n",
-	       (char *) ent->driver_data, adapter->io, adapter->irq);
+	       (char *) dev_id->driver_data, adapter->io, adapter->irq);
 
 	retval = fcpcipnp_setup(adapter);
 	if (retval)
@@ -925,6 +949,25 @@ static int __devinit fcpnp_probe(struct pci_dev *pdev,
 	return retval;
 }
 
+static void __devexit fcpnp_remove(struct pnp_dev *pdev)
+{
+	struct fritz_adapter *adapter = pnp_get_drvdata(pdev);
+
+	if (adapter) {
+		fcpcipnp_release(adapter);
+		delete_adapter(adapter);
+	}
+	pnp_disable_dev(pdev);
+}
+
+static struct pnp_driver fcpnp_driver = {
+	name:     "fcpnp",
+	probe:    fcpnp_probe,
+	remove:   __devexit_p(fcpnp_remove),
+	id_table: fcpnp_ids,
+};
+#endif
+
 static void __devexit fcpci_remove(struct pci_dev *pdev)
 {
 	struct fritz_adapter *adapter = pci_get_drvdata(pdev);
@@ -934,15 +977,6 @@ static void __devexit fcpci_remove(struct pci_dev *pdev)
 	delete_adapter(adapter);
 }
 
-static void __devexit fcpnp_remove(struct pci_dev *pdev)
-{
-	struct fritz_adapter *adapter = pci_get_drvdata(pdev);
-
-	fcpcipnp_release(adapter);
-	pdev->deactivate(pdev);
-	delete_adapter(adapter);
-}
-
 static struct pci_driver fcpci_driver = {
 	name:     "fcpci",
 	probe:    fcpci_probe,
@@ -950,13 +984,6 @@ static struct pci_driver fcpci_driver = {
 	id_table: fcpci_ids,
 };
 
-static struct isapnp_driver fcpnp_driver = {
-	name:     "fcpnp",
-	probe:    fcpnp_probe,
-	remove:   __devexit_p(fcpnp_remove),
-	id_table: fcpnp_ids,
-};
-
 static int __init hisax_fcpcipnp_init(void)
 {
 	int retval, pci_nr_found;
@@ -967,10 +994,13 @@ static int __init hisax_fcpcipnp_init(void)
 	if (retval < 0)
 		goto out;
 	pci_nr_found = retval;
+	retval = 0;
 
-	retval = isapnp_register_driver(&fcpnp_driver);
+#ifdef __ISAPNP__
+	retval = pnp_register_driver(&fcpnp_driver);
 	if (retval < 0)
 		goto out_unregister_pci;
+#endif
 
 #if !defined(CONFIG_HOTPLUG) || defined(MODULE)
 	if (pci_nr_found + retval == 0) {
@@ -982,7 +1012,9 @@ static int __init hisax_fcpcipnp_init(void)
 
 #if !defined(CONFIG_HOTPLUG) || defined(MODULE)
  out_unregister_isapnp:
-	isapnp_unregister_driver(&fcpnp_driver);
+#ifdef __ISAPNP__
+	pnp_unregister_driver(&fcpnp_driver);
+#endif
 #endif
  out_unregister_pci:
 	pci_unregister_driver(&fcpci_driver);
@@ -992,7 +1024,9 @@ static int __init hisax_fcpcipnp_init(void)
 
 static void __exit hisax_fcpcipnp_exit(void)
 {
-	isapnp_unregister_driver(&fcpnp_driver);
+#ifdef __ISAPNP__
+	pnp_unregister_driver(&fcpnp_driver);
+#endif
 	pci_unregister_driver(&fcpci_driver);
 }
 

drivers/isdn/hisax/jade.c

@@ -50,10 +50,8 @@ static void
 jade_write_indirect(struct IsdnCardState *cs, u_char reg, u_char value)
 {
     int to = 50;
-    long flags;
     u_char ret;
-    save_flags(flags);
+
-    cli();
     /* Write the data */
     cs->BC_Write_Reg(cs, -1, COMM_JADE+1, value);
     /* Say JADE we wanna write indirect reg 'reg' */
@@ -68,12 +66,10 @@ jade_write_indirect(struct IsdnCardState *cs, u_char reg, u_char value)
 	    /* Got acknowledge */
 	    break;
 	if (!to) {
-	    restore_flags(flags);
     	    printk(KERN_INFO "Can not see ready bit from JADE DSP (reg=0x%X, value=0x%X)\n", reg, value);
 	    return;
 	}
     }
-    restore_flags(flags);
 }
 
 
@@ -134,64 +130,61 @@ modejade(struct BCState *bcs, int mode, int bc)
 	cs->BC_Write_Reg(cs, jade, jade_HDLC_IMR, 0x00);
 }
 
-void
-jade_sched_event(struct BCState *bcs, int event)
-{
-    bcs->event |= 1 << event;
-    queue_task(&bcs->tqueue, &tq_immediate);
-    mark_bh(IMMEDIATE_BH);
-}
-
 static void
 jade_l2l1(struct PStack *st, int pr, void *arg)
 {
+    struct BCState *bcs = st->l1.bcs;
     struct sk_buff *skb = arg;
-    long flags;
+    u_long flags;
 
     switch (pr) {
 	case (PH_DATA | REQUEST):
-		save_flags(flags);
+		spin_lock_irqsave(&bcs->cs->lock, flags);
-		cli();
+		if (bcs->tx_skb) {
-		if (st->l1.bcs->tx_skb) {
+			skb_queue_tail(&bcs->squeue, skb);
-			skb_queue_tail(&st->l1.bcs->squeue, skb);
-			restore_flags(flags);
 		} else {
-			st->l1.bcs->tx_skb = skb;
+			bcs->tx_skb = skb;
-			test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+			test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
-			st->l1.bcs->hw.hscx.count = 0;
+			bcs->hw.hscx.count = 0;
-			restore_flags(flags);
+			bcs->cs->BC_Send_Data(bcs);
-			st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
 		}
+		spin_unlock_irqrestore(&bcs->cs->lock, flags);
 		break;
 	case (PH_PULL | INDICATION):
-		if (st->l1.bcs->tx_skb) {
+		spin_lock_irqsave(&bcs->cs->lock, flags);
+		if (bcs->tx_skb) {
 			printk(KERN_WARNING "jade_l2l1: this shouldn't happen\n");
-			break;
+		} else {
+			test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
+			bcs->tx_skb = skb;
+			bcs->hw.hscx.count = 0;
+			bcs->cs->BC_Send_Data(bcs);
 		}
-		test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+		spin_unlock_irqrestore(&bcs->cs->lock, flags);
-		st->l1.bcs->tx_skb = skb;
-		st->l1.bcs->hw.hscx.count = 0;
-		st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
 		break;
 	case (PH_PULL | REQUEST):
-		if (!st->l1.bcs->tx_skb) {
+		if (!bcs->tx_skb) {
 		    test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 		    st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 		} else
 		    test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 		break;
 	case (PH_ACTIVATE | REQUEST):
-		test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+		spin_lock_irqsave(&bcs->cs->lock, flags);
-		modejade(st->l1.bcs, st->l1.mode, st->l1.bc);
+		test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
+		modejade(bcs, st->l1.mode, st->l1.bc);
+		spin_unlock_irqrestore(&bcs->cs->lock, flags);
 		l1_msg_b(st, pr, arg);
 		break;
 	case (PH_DEACTIVATE | REQUEST):
 		l1_msg_b(st, pr, arg);
 		break;
 	case (PH_DEACTIVATE | CONFIRM):
-		test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
+		spin_lock_irqsave(&bcs->cs->lock, flags);
-		test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
+		test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
-		modejade(st->l1.bcs, 0, st->l1.bc);
+		test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
+		modejade(bcs, 0, st->l1.bc);
+		spin_unlock_irqrestore(&bcs->cs->lock, flags);
 		st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
 		break;
     }

drivers/isdn/hisax/jade.h

@@ -128,7 +128,6 @@
 #define	jade_TXAUDIOCH2CFG				0x1A
 
 extern int JadeVersion(struct IsdnCardState *cs, char *s);
-extern void jade_sched_event(struct BCState *bcs, int event);
 extern void modejade(struct BCState *bcs, int mode, int bc);
 extern void clear_pending_jade_ints(struct IsdnCardState *cs);
 extern void initjade(struct IsdnCardState *cs);

drivers/isdn/hisax/jade_irq.c

@@ -33,13 +33,8 @@ waitforXFW(struct IsdnCardState *cs, int jade)
 static inline void
 WriteJADECMDR(struct IsdnCardState *cs, int jade, int reg, u_char data)
 {
-	long flags;
-
-	save_flags(flags);
-	cli();
 	waitforCEC(cs, jade, reg);
 	WRITEJADE(cs, jade, reg, data);
-	restore_flags(flags);
 }
 
 
@@ -49,7 +44,6 @@ jade_empty_fifo(struct BCState *bcs, int count)
 {
 	u_char *ptr;
 	struct IsdnCardState *cs = bcs->cs;
-	long flags;
 
 	if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
 		debugl1(cs, "jade_empty_fifo");
@@ -63,11 +57,8 @@ jade_empty_fifo(struct BCState *bcs, int count)
 	}
 	ptr = bcs->hw.hscx.rcvbuf + bcs->hw.hscx.rcvidx;
 	bcs->hw.hscx.rcvidx += count;
-	save_flags(flags);
-	cli();
 	READJADEFIFO(cs, bcs->hw.hscx.hscx, ptr, count);
 	WriteJADECMDR(cs, bcs->hw.hscx.hscx, jade_HDLC_RCMD, jadeRCMD_RMC);
-	restore_flags(flags);
 	if (cs->debug & L1_DEB_HSCX_FIFO) {
 		char *t = bcs->blog;
 
@@ -85,7 +76,6 @@ jade_fill_fifo(struct BCState *bcs)
 	int more, count;
 	int fifo_size = 32;
 	u_char *ptr;
-	long flags;
 
 	if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
 		debugl1(cs, "jade_fill_fifo");
@@ -103,15 +93,12 @@ jade_fill_fifo(struct BCState *bcs)
 		count = bcs->tx_skb->len;
 
 	waitforXFW(cs, bcs->hw.hscx.hscx);
-	save_flags(flags);
-	cli();
 	ptr = bcs->tx_skb->data;
 	skb_pull(bcs->tx_skb, count);
 	bcs->tx_cnt -= count;
 	bcs->hw.hscx.count += count;
 	WRITEJADEFIFO(cs, bcs->hw.hscx.hscx, ptr, count);
 	WriteJADECMDR(cs, bcs->hw.hscx.hscx, jade_HDLC_XCMD, more ? jadeXCMD_XF : (jadeXCMD_XF|jadeXCMD_XME));
-	restore_flags(flags);
 	if (cs->debug & L1_DEB_HSCX_FIFO) {
 		char *t = bcs->blog;
 
@@ -166,7 +153,7 @@ jade_interrupt(struct IsdnCardState *cs, u_char val, u_char jade)
 			}
 		}
 		bcs->hw.hscx.rcvidx = 0;
-		jade_sched_event(bcs, B_RCVBUFREADY);
+		schedule_event(bcs, B_RCVBUFREADY);
 	}
 	if (val & 0x40) {	/* RPF */
 		jade_empty_fifo(bcs, fifo_size);
@@ -179,7 +166,7 @@ jade_interrupt(struct IsdnCardState *cs, u_char val, u_char jade)
 				skb_queue_tail(&bcs->rqueue, skb);
 			}
 			bcs->hw.hscx.rcvidx = 0;
-			jade_sched_event(bcs, B_RCVBUFREADY);
+			schedule_event(bcs, B_RCVBUFREADY);
 		}
 	}
 	if (val & 0x10) {	/* XPR */
@@ -202,7 +189,7 @@ jade_interrupt(struct IsdnCardState *cs, u_char val, u_char jade)
 			jade_fill_fifo(bcs);
 		} else {
 			test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
-			jade_sched_event(bcs, B_XMTBUFREADY);
+			schedule_event(bcs, B_XMTBUFREADY);
 		}
 	}
 }

drivers/isdn/hisax/sedlbauer.c

@@ -796,6 +796,7 @@ ready:
 						"Sedlbauer: wrong ISAR version (ret = %d)\n", ver);
 				else
 					break;
+				reset_sedlbauer(cs);
 				bytecnt--;
 			}
 			if (!bytecnt) {

drivers/isdn/hisax/teleint.c

@@ -28,21 +28,16 @@ readreg(unsigned int ale, unsigned int adr, u_char off)
 {
 	register u_char ret;
 	int max_delay = 2000;
-	long flags;
 
-	save_flags(flags);
-	cli();
 	byteout(ale, off);
 	ret = HFC_BUSY & bytein(ale);
 	while (ret && --max_delay)
 		ret = HFC_BUSY & bytein(ale);
 	if (!max_delay) {
 		printk(KERN_WARNING "TeleInt Busy not inactive\n");
-		restore_flags(flags);
 		return (0);
 	}
 	ret = bytein(adr);
-	restore_flags(flags);
 	return (ret);
 }
 
@@ -72,21 +67,16 @@ writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
 {
 	register u_char ret;
 	int max_delay = 2000;
-	long flags;
 
-	save_flags(flags);
-	cli();
 	byteout(ale, off);
 	ret = HFC_BUSY & bytein(ale);
 	while (ret && --max_delay)
 		ret = HFC_BUSY & bytein(ale);
 	if (!max_delay) {
 		printk(KERN_WARNING "TeleInt Busy not inactive\n");
-		restore_flags(flags);
 		return;
 	}
 	byteout(adr, data);
-	restore_flags(flags);
 }
 
 static inline void
@@ -167,16 +157,14 @@ WriteHFC(struct IsdnCardState *cs, int data, u_char reg, u_char value)
 		debugl1(cs, "hfc W%c %02x %02x", data ? 'D' : 'C', reg, value);
 }
 
-static void
+static irqreturn_t
 TeleInt_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 {
 	struct IsdnCardState *cs = dev_id;
 	u_char val;
+	u_long flags;
 
-	if (!cs) {
+	spin_lock_irqsave(&cs->lock, flags);
-		printk(KERN_WARNING "TeleInt: Spurious interrupt!\n");
-		return;
-	}
 	val = readreg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_ISTA);
       Start_ISAC:
 	if (val)
@@ -189,13 +177,17 @@ TeleInt_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 	}
 	writereg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_MASK, 0xFF);
 	writereg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_MASK, 0x0);
+	spin_unlock_irqrestore(&cs->lock, flags);
+	return IRQ_HANDLED;
 }
 
 static void
 TeleInt_Timer(struct IsdnCardState *cs)
 {
 	int stat = 0;
-
+	u_long flags;
+	
+	spin_lock_irqsave(&cs->lock, flags);
 	if (cs->bcs[0].mode) {
 		stat |= 1;
 		main_irq_hfc(&cs->bcs[0]);
@@ -204,7 +196,11 @@ TeleInt_Timer(struct IsdnCardState *cs)
 		stat |= 2;
 		main_irq_hfc(&cs->bcs[1]);
 	}
-	cs->hw.hfc.timer.expires = jiffies + 1;
+	spin_unlock_irqrestore(&cs->lock, flags);
+	stat = HZ/100;
+	if (!stat)
+		stat = 1;
+	cs->hw.hfc.timer.expires = jiffies + stat;
 	add_timer(&cs->hw.hfc.timer);
 }
 
@@ -232,21 +228,32 @@ reset_TeleInt(struct IsdnCardState *cs)
 static int
 TeleInt_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
+	u_long flags;
+	int delay;
+
 	switch (mt) {
 		case CARD_RESET:
+			spin_lock_irqsave(&cs->lock, flags);
 			reset_TeleInt(cs);
+			spin_unlock_irqrestore(&cs->lock, flags);
 			return(0);
 		case CARD_RELEASE:
 			release_io_TeleInt(cs);
 			return(0);
 		case CARD_INIT:
+			spin_lock_irqsave(&cs->lock, flags);
+			reset_TeleInt(cs);
 			inithfc(cs);
 			clear_pending_isac_ints(cs);
 			initisac(cs);
 			/* Reenable all IRQ */
 			cs->writeisac(cs, ISAC_MASK, 0);
 			cs->writeisac(cs, ISAC_CMDR, 0x41);
-			cs->hw.hfc.timer.expires = jiffies + 1;
+			spin_unlock_irqrestore(&cs->lock, flags);
+			delay = HZ/100;
+			if (!delay)
+				delay = 1;
+			cs->hw.hfc.timer.expires = jiffies + delay;
 			add_timer(&cs->hw.hfc.timer);
 			return(0);
 		case CARD_TEST:
@@ -278,15 +285,13 @@ setup_TeleInt(struct IsdnCard *card)
 	cs->hw.hfc.timer.function = (void *) TeleInt_Timer;
 	cs->hw.hfc.timer.data = (long) cs;
 	init_timer(&cs->hw.hfc.timer);
-	if (check_region((cs->hw.hfc.addr), 2)) {
+	if (!request_region(cs->hw.hfc.addr, 2, "TeleInt isdn")) {
 		printk(KERN_WARNING
 		       "HiSax: %s config port %x-%x already in use\n",
 		       CardType[card->typ],
 		       cs->hw.hfc.addr,
 		       cs->hw.hfc.addr + 2);
 		return (0);
-	} else {
-		request_region(cs->hw.hfc.addr, 2, "TeleInt isdn");
 	}
 	/* HW IO = IO */
 	byteout(cs->hw.hfc.addr, cs->hw.hfc.addr & 0xff);
@@ -318,12 +323,10 @@ setup_TeleInt(struct IsdnCard *card)
 	byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);
 	byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.ctmt);
 
-	printk(KERN_INFO
+	printk(KERN_INFO "TeleInt: defined at 0x%x IRQ %d\n",
-	       "TeleInt: defined at 0x%x IRQ %d\n",
+		cs->hw.hfc.addr, cs->irq);
-	       cs->hw.hfc.addr,
-	       cs->irq);
 
-	reset_TeleInt(cs);
+	setup_isac(cs);
 	cs->readisac = &ReadISAC;
 	cs->writeisac = &WriteISAC;
 	cs->readisacfifo = &ReadISACfifo;