ISDN: Fix up the introduced spinlocks

The reset routines are not called concurrently with other call paths,
and holding a spinlock over schedule_timeout() is plain wrong anyway.

Unfortunately, there's still quite a lot of cli() etc left, which however
are not so easy to kill since they protect IRQ handlers against filling
the tx queue, but don't even live in the same file.

drivers/isdn/hisax/asuscom.c

@@ -262,14 +262,10 @@ release_io_asuscom(struct IsdnCardState *cs)
 static void
 reset_asuscom(struct IsdnCardState *cs)
 {
-	long flags;
-
 	if (cs->subtyp == ASUS_IPAC)
 		writereg(cs->hw.asus.adr, cs->hw.asus.isac, IPAC_POTA2, 0x20);
 	else
 		byteout(cs->hw.asus.adr, ASUS_RESET);	/* Reset On */
-	save_flags(flags);
-	sti();
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000);
 	if (cs->subtyp == ASUS_IPAC)
@@ -285,7 +281,6 @@ reset_asuscom(struct IsdnCardState *cs)
 		writereg(cs->hw.asus.adr, cs->hw.asus.isac, IPAC_MASK, 0xc0);
 		writereg(cs->hw.asus.adr, cs->hw.asus.isac, IPAC_PCFG, 0x12);
 	}
-	restore_flags(flags);
 }
 
 static int

drivers/isdn/hisax/avm_a1.c

@@ -18,7 +18,6 @@
 
 extern const char *CardType[];
 static const char *avm_revision = "$Revision: 2.13.6.2 $";
-static spinlock_t avm_a1_lock = SPIN_LOCK_UNLOCKED;
 
 #define	 AVM_A1_STAT_ISAC	0x01
 #define	 AVM_A1_STAT_HSCX	0x02
@@ -180,7 +179,6 @@ setup_avm_a1(struct IsdnCard *card)
 {
 	u_char val;
 	struct IsdnCardState *cs = card->cs;
-	unsigned long flags;
 	char tmp[64];
 
 	strcpy(tmp, avm_revision);
@@ -255,7 +253,6 @@ setup_avm_a1(struct IsdnCard *card)
 		release_ioregs(cs, 0x1f);
 		return (0);
 	}
-	spin_lock_irqsave(&avm_a1_lock, flags);
 	byteout(cs->hw.avm.cfg_reg, 0x0);
 	HZDELAY(HZ / 5 + 1);
 	byteout(cs->hw.avm.cfg_reg, 0x1);
@@ -269,7 +266,6 @@ setup_avm_a1(struct IsdnCard *card)
 	HZDELAY(HZ / 5 + 1);
 	byteout(cs->hw.avm.cfg_reg, 0x0);
 	HZDELAY(HZ / 5 + 1);
-	spin_unlock_irqrestore(&avm_a1_lock, flags);
 
 	val = bytein(cs->hw.avm.cfg_reg);
 	printk(KERN_INFO "AVM A1: Byte at %x is %x\n",

drivers/isdn/hisax/avm_a1p.c

@@ -246,7 +246,6 @@ setup_avm_a1_pcmcia(struct IsdnCard *card)
 {
 	u_char model, vers;
 	struct IsdnCardState *cs = card->cs;
-	unsigned long flags;
 	char tmp[64];
 
 
@@ -260,7 +259,6 @@ setup_avm_a1_pcmcia(struct IsdnCard *card)
 	cs->irq = card->para[0];
 
 
-	spin_lock_irqsave(&avm_a1p_lock, flags);
 	outb(cs->hw.avm.cfg_reg+ASL1_OFFSET, ASL1_W_ENABLE_S0);
 
 	byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,0x00);
@@ -271,8 +269,6 @@ setup_avm_a1_pcmcia(struct IsdnCard *card)
 
 	byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET, ASL0_W_TDISABLE|ASL0_W_TRESET);
 
-	spin_unlock_irqrestore(&avm_a1p_lock, flags);
-
 	model = bytein(cs->hw.avm.cfg_reg+MODREG_OFFSET);
 	vers = bytein(cs->hw.avm.cfg_reg+VERREG_OFFSET);
 

drivers/isdn/hisax/avm_pci.c

@@ -708,11 +708,7 @@ avm_pcipnp_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 static void
 reset_avmpcipnp(struct IsdnCardState *cs)
 {
-	long flags;
-
 	printk(KERN_INFO "AVM PCI/PnP: reset\n");
-	save_flags(flags);
-	sti();
 	outb(AVM_STATUS0_RESET | AVM_STATUS0_DIS_TIMER, cs->hw.avm.cfg_reg + 2);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000); /* Timeout 10ms */

drivers/isdn/hisax/bkm_a4t.c

@@ -196,12 +196,8 @@ enable_bkm_int(struct IsdnCardState *cs, unsigned bEnable)
 static void
 reset_bkm(struct IsdnCardState *cs)
 {
-	long flags;
-
 	if (cs->typ == ISDN_CTYPE_BKM_A4T) {
 		I20_REGISTER_FILE *pI20_Regs = (I20_REGISTER_FILE *) (cs->hw.ax.base);
-		save_flags(flags);
-		sti();
 		/* Issue the I20 soft reset     */
 		pI20_Regs->i20SysControl = 0xFF;	/* all in */
 		set_current_state(TASK_UNINTERRUPTIBLE);
@@ -228,7 +224,6 @@ reset_bkm(struct IsdnCardState *cs)
 						g_A4T_ISAR_RES);
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout((10 * HZ) / 1000);
-		restore_flags(flags);
 	}
 }
 

drivers/isdn/hisax/bkm_a8.c

@@ -221,19 +221,14 @@ enable_bkm_int(struct IsdnCardState *cs, unsigned bEnable)
 static void
 reset_bkm(struct IsdnCardState *cs)
 {
-	long flags;
-
 	if (cs->subtyp == SCT_1) {
 		wordout(cs->hw.ax.plx_adr + 0x50, (wordin(cs->hw.ax.plx_adr + 0x50) & ~4));
-		save_flags(flags);
-		sti();
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout((10 * HZ) / 1000);
 		/* Remove the soft reset */
 		wordout(cs->hw.ax.plx_adr + 0x50, (wordin(cs->hw.ax.plx_adr + 0x50) | 4));
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout((10 * HZ) / 1000);
-		restore_flags(flags);
 	}
 }
 

drivers/isdn/hisax/config.c

@@ -787,15 +787,12 @@ void HiSax_putstatus(struct IsdnCardState *cs, char *head, char *fmt, ...)
 
 int ll_run(struct IsdnCardState *cs, int addfeatures)
 {
-	unsigned long flags;
 	isdn_ctrl ic;
 
-	spin_lock_irqsave(&hisax_config_lock, flags);
 	ic.driver = cs->myid;
 	ic.command = ISDN_STAT_RUN;
 	cs->iif.features |= addfeatures;
 	cs->iif.statcallb(&ic);
-	spin_unlock_irqrestore(&hisax_config_lock, flags);
 	return 0;
 }
 
@@ -856,18 +853,16 @@ static void closecard(int cardnr)
 static int __devinit init_card(struct IsdnCardState *cs)
 {
 	int irq_cnt, cnt = 3;
-	unsigned long flags;
 
 	if (!cs->irq)
 		return cs->cardmsg(cs, CARD_INIT, NULL);
-	spin_lock_irqsave(&hisax_config_lock, flags);
+
 	irq_cnt = kstat_irqs(cs->irq);
 	printk(KERN_INFO "%s: IRQ %d count %d\n", CardType[cs->typ],
 	       cs->irq, irq_cnt);
 	if (request_irq(cs->irq, cs->irq_func, cs->irq_flags, "HiSax", cs)) {
 		printk(KERN_WARNING "HiSax: couldn't get interrupt %d\n",
 		       cs->irq);
-		spin_unlock_irqrestore(&hisax_config_lock, flags);
 		return 1;
 	}
 	while (cnt) {
@@ -875,7 +870,6 @@ static int __devinit init_card(struct IsdnCardState *cs)
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		/* Timeout 10ms */
 		schedule_timeout((10 * HZ) / 1000);
-		spin_unlock_irqrestore(&hisax_config_lock, flags);
 		printk(KERN_INFO "%s: IRQ %d count %d\n",
 		       CardType[cs->typ], cs->irq, kstat_irqs(cs->irq));
 		if (kstat_irqs(cs->irq) == irq_cnt) {
@@ -894,18 +888,15 @@ static int __devinit init_card(struct IsdnCardState *cs)
 			return 0;
 		}
 	}
-	spin_unlock_irqrestore(&hisax_config_lock, flags);
 	return 3;
 }
 
 static int __devinit checkcard(int cardnr, char *id, int *busy_flag)
 {
-	unsigned long flags;
 	int ret = 0;
 	struct IsdnCard *card = cards + cardnr;
 	struct IsdnCardState *cs;
 
-	spin_lock_irqsave(&hisax_config_lock, flags);
 	cs = kmalloc(sizeof(struct IsdnCardState), GFP_ATOMIC);
 	if (!cs) {
 		printk(KERN_WARNING
@@ -1212,7 +1203,6 @@ static int __devinit checkcard(int cardnr, char *id, int *busy_flag)
 	kfree(cs);
 	card->cs = NULL;
  out:
-	spin_unlock_irqrestore(&hisax_config_lock, flags);
 	return ret;
 }
 
@@ -1538,9 +1528,7 @@ static int __init HiSax_init(void)
 static void __exit HiSax_exit(void)
 {
 	int cardnr = nrcards - 1;
-	unsigned long flags;
 
-	spin_lock_irqsave(&hisax_config_lock, flags);
 	while (cardnr >= 0)
 		HiSax_closecard(cardnr--);
 	Isdnl1Free();
@@ -1548,7 +1536,6 @@ static void __exit HiSax_exit(void)
 	Isdnl2Free();
 	Isdnl3Free();
 	CallcFree();
-	spin_unlock_irqrestore(&hisax_config_lock, flags);
 	printk(KERN_INFO "HiSax module removed\n");
 }
 

drivers/isdn/hisax/diva.c

@@ -749,10 +749,6 @@ release_io_diva(struct IsdnCardState *cs)
 static void
 reset_diva(struct IsdnCardState *cs)
 {
-	long flags;
-
-	save_flags(flags);
-	sti();
 	if (cs->subtyp == DIVA_IPAC_ISA) {
 		writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_POTA2, 0x20);
 		set_current_state(TASK_UNINTERRUPTIBLE);
@@ -799,7 +795,6 @@ reset_diva(struct IsdnCardState *cs)
 		}
 		byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
 	}
-	restore_flags(flags);
 }
 
 #define DIVA_ASSIGN 1

drivers/isdn/hisax/elsa.c

@@ -483,8 +483,6 @@ release_io_elsa(struct IsdnCardState *cs)
 static void
 reset_elsa(struct IsdnCardState *cs)
 {
-	long flags;
-
 	if (cs->hw.elsa.timer) {
 		/* Wait 1 Timer */
 		byteout(cs->hw.elsa.timer, 0);
@@ -504,8 +502,6 @@ reset_elsa(struct IsdnCardState *cs)
 			byteout(cs->hw.elsa.trig, 0xff);
 	}
 	if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
-		save_flags(flags);
-		sti();
 		writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_POTA2, 0x20);
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
@@ -513,7 +509,6 @@ reset_elsa(struct IsdnCardState *cs)
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_MASK, 0xc0);
 		schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
-		restore_flags(flags);
 		if (cs->subtyp != ELSA_PCMCIA_IPAC) {
 			writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ACFG, 0x0);
 			writereg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_AOE, 0x3c);
@@ -674,7 +669,6 @@ static int
 Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
 	int ret = 0;
-	long flags;
 
 	switch (mt) {
 		case CARD_RESET:
@@ -703,16 +697,13 @@ Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 			} else if (cs->subtyp == ELSA_QS3000PCI) {
 				ret = 0;
 			} else {
-				save_flags(flags);
 				cs->hw.elsa.counter = 0;
-				sti();
 				cs->hw.elsa.ctrl_reg |= ELSA_ENA_TIMER_INT;
 				cs->hw.elsa.status |= ELSA_TIMER_AKTIV;
 				byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 				byteout(cs->hw.elsa.timer, 0);
 				set_current_state(TASK_UNINTERRUPTIBLE);
 				schedule_timeout((110*HZ)/1000);
-				restore_flags(flags);
 				cs->hw.elsa.ctrl_reg &= ~ELSA_ENA_TIMER_INT;
 				byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
 				cs->hw.elsa.status &= ~ELSA_TIMER_AKTIV;
@@ -795,7 +786,6 @@ probe_elsa_adr(unsigned int adr, int typ)
 {
 	int i, in1, in2, p16_1 = 0, p16_2 = 0, p8_1 = 0, p8_2 = 0, pc_1 = 0,
 	 pc_2 = 0, pfp_1 = 0, pfp_2 = 0;
-	unsigned long flags;
 
 	/* In case of the elsa pcmcia card, this region is in use,
 	   reserved for us by the card manager. So we do not check it
@@ -806,7 +796,6 @@ probe_elsa_adr(unsigned int adr, int typ)
 		       adr);
 		return (0);
 	}
-	spin_lock_irqsave(&elsa_lock, flags);
 	for (i = 0; i < 16; i++) {
 		in1 = inb(adr + ELSA_CONFIG);	/* 'toggelt' bei */
 		in2 = inb(adr + ELSA_CONFIG);	/* jedem Zugriff */
@@ -819,7 +808,6 @@ probe_elsa_adr(unsigned int adr, int typ)
 		pfp_1 += 0x40 & in1;
 		pfp_2 += 0x40 & in2;
 	}
-	spin_unlock_irqrestore(&elsa_lock, flags);
 	printk(KERN_INFO "Elsa: Probing IO 0x%x", adr);
 	if (65 == ++p16_1 * ++p16_2) {
 		printk(" PCC-16/PCF found\n");
@@ -874,7 +862,6 @@ static struct pci_bus *pnp_c __devinitdata = NULL;
 int __devinit
 setup_elsa(struct IsdnCard *card)
 {
-	unsigned long flags;
 	int bytecnt;
 	u_char val, pci_rev;
 	struct IsdnCardState *cs = card->cs;
@@ -1166,9 +1153,7 @@ setup_elsa(struct IsdnCard *card)
 				return (0);
 			}
 		}
-		spin_lock_irqsave(&elsa_lock, flags);
 		HZDELAY(1);	/* wait >=10 ms */
-		spin_unlock_irqrestore(&elsa_lock, flags);
 		if (TimerRun(cs)) {
 			printk(KERN_WARNING "Elsa: timer do not run down\n");
 			release_io_elsa(cs);

drivers/isdn/hisax/enternow_pci.c

@@ -137,13 +137,9 @@ static void dummywr(struct IsdnCardState *cs, int chan, BYTE off, BYTE value)
 static void
 reset_enpci(struct IsdnCardState *cs)
 {
-	long flags;
-
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "enter:now PCI: reset");
 
-	save_flags(flags);
-	sti();
 	/* Reset on, (also for AMD) */
 	cs->hw.njet.ctrl_reg = 0x07;
 	OutByte(cs->hw.njet.base + NETJET_CTRL, cs->hw.njet.ctrl_reg);
@@ -156,13 +152,11 @@ reset_enpci(struct IsdnCardState *cs)
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	/* 80ms delay */
 	schedule_timeout((80*HZ)/1000);
-	restore_flags(flags);
 	cs->hw.njet.auxd = 0;  // LED-status
 	cs->hw.njet.dmactrl = 0;
 	OutByte(cs->hw.njet.base + NETJET_AUXCTRL, ~TJ_AMD_IRQ);
 	OutByte(cs->hw.njet.base + NETJET_IRQMASK1, TJ_AMD_IRQ);
 	OutByte(cs->hw.njet.auxa, cs->hw.njet.auxd); // LED off
-
 }
 
 

drivers/isdn/hisax/gazel.c

@@ -356,17 +356,14 @@ release_io_gazel(struct IsdnCardState *cs)
 static int
 reset_gazel(struct IsdnCardState *cs)
 {
-	unsigned long flags;
 	unsigned long plxcntrl, addr = cs->hw.gazel.cfg_reg;
 
 	switch (cs->subtyp) {
 		case R647:
-			spin_lock_irqsave(&gazel_lock, flags);
 			writereg(addr, 0, 0);
 			HZDELAY(10);
 			writereg(addr, 0, 1);
 			HZDELAY(2);
-			spin_unlock_irqrestore(&gazel_lock, flags);
 			break;
 		case R685:
 			plxcntrl = inl(addr + PLX_CNTRL);

drivers/isdn/hisax/hfcscard.c

@@ -64,15 +64,11 @@ release_io_hfcs(struct IsdnCardState *cs)
 static void
 reset_hfcs(struct IsdnCardState *cs)
 {
-	long flags;
-
 	printk(KERN_INFO "HFCS: resetting card\n");
 	cs->hw.hfcD.cirm = HFCD_RESET;
 	if (cs->typ == ISDN_CTYPE_TELES3C)
 		cs->hw.hfcD.cirm |= HFCD_MEM8K;
 	cs->BC_Write_Reg(cs, HFCD_DATA, HFCD_CIRM, cs->hw.hfcD.cirm);	/* Reset On */
-	save_flags(flags);
-	sti();
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((30*HZ)/1000);
 	cs->hw.hfcD.cirm = 0;
@@ -103,14 +99,11 @@ reset_hfcs(struct IsdnCardState *cs)
 	cs->BC_Write_Reg(cs, HFCD_DATA, HFCD_MST_MODE, cs->hw.hfcD.mst_m); /* HFC Master */
 	cs->hw.hfcD.sctrl = 0;
 	cs->BC_Write_Reg(cs, HFCD_DATA, HFCD_SCTRL, cs->hw.hfcD.sctrl);
-	restore_flags(flags);
 }
 
 static int
 hfcs_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
-	long flags;
-
 	if (cs->debug & L1_DEB_ISAC)
 		debugl1(cs, "HFCS: card_msg %x", mt);
 	switch (mt) {
@@ -124,14 +117,11 @@ hfcs_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 			cs->hw.hfcD.timer.expires = jiffies + 75;
 			add_timer(&cs->hw.hfcD.timer);
 			init2bds0(cs);
-			save_flags(flags);
-			sti();
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout((80*HZ)/1000);
 			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);
 			return(0);
 		case CARD_TEST:
 			return(0);

drivers/isdn/hisax/isurf.c

@@ -20,7 +20,6 @@
 extern const char *CardType[];
 
 static const char *ISurf_revision = "$Revision: 1.10.6.2 $";
-static spinlock_t isurf_lock = SPIN_LOCK_UNLOCKED;
 
 #define byteout(addr,val) outb(val,addr)
 #define bytein(addr) inb(addr)
@@ -135,19 +134,14 @@ release_io_isurf(struct IsdnCardState *cs)
 static void
 reset_isurf(struct IsdnCardState *cs, u_char chips)
 {
-	long flags;
-
 	printk(KERN_INFO "ISurf: resetting card\n");
 
 	byteout(cs->hw.isurf.reset, chips); /* Reset On */
-	save_flags(flags);
-	sti();
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000);
 	byteout(cs->hw.isurf.reset, ISURF_ISAR_EA); /* Reset Off */
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000);
-	restore_flags(flags);
 }
 
 static int

drivers/isdn/hisax/ix1_micro.c

@@ -183,18 +183,15 @@ release_io_ix1micro(struct IsdnCardState *cs)
 static void
 ix1_reset(struct IsdnCardState *cs)
 {
-	unsigned long flags;
 	int cnt;
 
 	/* reset isac */
-	spin_lock_irqsave(&ix1_micro_lock, flags);
 	cnt = 3 * (HZ / 10) + 1;
 	while (cnt--) {
 		byteout(cs->hw.ix1.cfg_reg + SPECIAL_PORT_OFFSET, 1);
 		HZDELAY(1);	/* wait >=10 ms */
 	}
 	byteout(cs->hw.ix1.cfg_reg + SPECIAL_PORT_OFFSET, 0);
-	spin_unlock_irqrestore(&ix1_micro_lock, flags);
 }
 
 static int

drivers/isdn/hisax/saphir.c

@@ -181,13 +181,9 @@ SaphirWatchDog(struct IsdnCardState *cs)
 void
 release_io_saphir(struct IsdnCardState *cs)
 {
-	unsigned long flags;
-	
-	spin_lock_irqsave(&saphir_lock, flags);
 	byteout(cs->hw.saphir.cfg_reg + IRQ_REG, 0xff);
-	del_timer(&cs->hw.saphir.timer);
+	del_timer_sync(&cs->hw.saphir.timer);
 	cs->hw.saphir.timer.function = NULL;
-	spin_unlock_irqrestore(&saphir_lock, flags);
 	if (cs->hw.saphir.cfg_reg)
 		release_region(cs->hw.saphir.cfg_reg, 6);
 }
@@ -195,7 +191,6 @@ release_io_saphir(struct IsdnCardState *cs)
 static int
 saphir_reset(struct IsdnCardState *cs)
 {
-	long flags;
 	u_char irq_val;
 
 	switch(cs->irq) {
@@ -218,15 +213,12 @@ saphir_reset(struct IsdnCardState *cs)
 			return (1);
 	}
 	byteout(cs->hw.saphir.cfg_reg + IRQ_REG, irq_val);
-	save_flags(flags);
-	sti();
 	byteout(cs->hw.saphir.cfg_reg + RESET_REG, 1);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((30*HZ)/1000);	/* Timeout 30ms */
 	byteout(cs->hw.saphir.cfg_reg + RESET_REG, 0);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((30*HZ)/1000);	/* Timeout 30ms */
-	restore_flags(flags);
 	byteout(cs->hw.saphir.cfg_reg + IRQ_REG, irq_val);
 	byteout(cs->hw.saphir.cfg_reg + SPARE_REG, 0x02);
 	return (0);

drivers/isdn/hisax/sedlbauer.c

@@ -421,16 +421,12 @@ release_io_sedlbauer(struct IsdnCardState *cs)
 static void
 reset_sedlbauer(struct IsdnCardState *cs)
 {
-	long flags;
-
 	printk(KERN_INFO "Sedlbauer: resetting card\n");
 
 	if (!((cs->hw.sedl.bus == SEDL_BUS_PCMCIA) &&
 	   (cs->hw.sedl.chip == SEDL_CHIP_ISAC_HSCX))) {
 		if (cs->hw.sedl.chip == SEDL_CHIP_IPAC) {
 			writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_POTA2, 0x20);
-			save_flags(flags);
-			sti();
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout((10*HZ)/1000);
 			writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_POTA2, 0x0);
@@ -441,28 +437,21 @@ reset_sedlbauer(struct IsdnCardState *cs)
 			writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_AOE, 0x0);
 			writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_MASK, 0xc0);
 			writereg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_PCFG, 0x12);
-			restore_flags(flags);
 		} else if ((cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) &&
 			(cs->hw.sedl.bus == SEDL_BUS_PCI)) {
 			byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
-			save_flags(flags);
-			sti();
 			current->state = TASK_UNINTERRUPTIBLE;
 			schedule_timeout((20*HZ)/1000);
 			byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
 			current->state = TASK_UNINTERRUPTIBLE;
 			schedule_timeout((20*HZ)/1000);
-			restore_flags(flags);
 		} else {		
 			byteout(cs->hw.sedl.reset_on, SEDL_RESET);	/* Reset On */
-			save_flags(flags);
-			sti();
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout((10*HZ)/1000);
 			byteout(cs->hw.sedl.reset_off, 0);	/* Reset Off */
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout((10*HZ)/1000);
-			restore_flags(flags);
 		}
 	}
 }
@@ -551,7 +540,6 @@ setup_sedlbauer(struct IsdnCard *card)
 	struct IsdnCardState *cs = card->cs;
 	char tmp[64];
 	u16 sub_vendor_id, sub_id;
-	unsigned long flags;
 
 	strcpy(tmp, Sedlbauer_revision);
 	printk(KERN_INFO "HiSax: Sedlbauer driver Rev. %s\n", HiSax_getrev(tmp));
@@ -684,12 +672,9 @@ setup_sedlbauer(struct IsdnCard *card)
 		byteout(cs->hw.sedl.cfg_reg+ 2, 0xdd);
 		byteout(cs->hw.sedl.cfg_reg+ 5, 0x02);
 		byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
-		save_flags(flags);
-		sti();
 		current->state = TASK_UNINTERRUPTIBLE;
 		schedule_timeout((10*HZ)/1000);
 		byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
-		restore_flags(flags);
 #else
 		printk(KERN_WARNING "Sedlbauer: NO_PCI_BIOS\n");
 		return (0);

drivers/isdn/hisax/sportster.c

@@ -20,7 +20,6 @@
 
 extern const char *CardType[];
 const char *sportster_revision = "$Revision: 1.14.6.2 $";
-static spinlock_t sportster_lock = SPIN_LOCK_UNLOCKED;
 
 #define byteout(addr,val) outb(val,addr)
 #define bytein(addr) inb(addr)
@@ -148,19 +147,14 @@ release_io_sportster(struct IsdnCardState *cs)
 void
 reset_sportster(struct IsdnCardState *cs)
 {
-	long flags;
-
 	cs->hw.spt.res_irq |= SPORTSTER_RESET; /* Reset On */
 	byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
-	save_flags(flags);
-	sti();
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000);
 	cs->hw.spt.res_irq &= ~SPORTSTER_RESET; /* Reset Off */
 	byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000);
-	restore_flags(flags);
 }
 
 static int

drivers/isdn/hisax/teleint.c

@@ -219,20 +219,15 @@ release_io_TeleInt(struct IsdnCardState *cs)
 static void
 reset_TeleInt(struct IsdnCardState *cs)
 {
-	long flags;
-
 	printk(KERN_INFO "TeleInt: resetting card\n");
 	cs->hw.hfc.cirm |= HFC_RESET;
 	byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);	/* Reset On */
-	save_flags(flags);
-	sti();
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((30*HZ)/1000);
 	cs->hw.hfc.cirm &= ~HFC_RESET;
 	byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);	/* Reset Off */
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout((10*HZ)/1000);
-	restore_flags(flags);
 }
 
 static int

drivers/isdn/hisax/teles0.c

@@ -24,7 +24,6 @@
 extern const char *CardType[];
 
 const char *teles0_revision = "$Revision: 2.13.6.2 $";
-static spinlock_t teles0_lock = SPIN_LOCK_UNLOCKED;
 
 #define TELES_IOMEM_SIZE	0x400
 #define byteout(addr,val) outb(val,addr)
@@ -197,9 +196,7 @@ static int
 reset_teles0(struct IsdnCardState *cs)
 {
 	u_char cfval;
-	unsigned long flags;
 
-	spin_lock_irqsave(&teles0_lock, flags);
 	if (cs->hw.teles0.cfg_reg) {
 		switch (cs->irq) {
 			case 2:
@@ -228,7 +225,6 @@ reset_teles0(struct IsdnCardState *cs)
 				cfval = 0x0E;
 				break;
 			default:
-				spin_unlock_irqrestore(&teles0_lock, flags);
 				return(1);
 		}
 		cfval |= ((cs->hw.teles0.phymem >> 9) & 0xF0);
@@ -241,7 +237,6 @@ reset_teles0(struct IsdnCardState *cs)
 	HZDELAY(HZ / 5 + 1);
 	writeb(1, cs->hw.teles0.membase + 0x80); mb();
 	HZDELAY(HZ / 5 + 1);
-	spin_unlock_irqrestore(&teles0_lock, flags);
 	return(0);
 }
 

drivers/isdn/hisax/teles3.c

@@ -22,7 +22,6 @@
 
 extern const char *CardType[];
 const char *teles3_revision = "$Revision: 2.17.6.2 $";
-static spinlock_t teles3_lock = SPIN_LOCK_UNLOCKED;
 
 #define byteout(addr,val) outb(val,addr)
 #define bytein(addr) inb(addr)
@@ -175,7 +174,6 @@ release_io_teles3(struct IsdnCardState *cs)
 static int
 reset_teles3(struct IsdnCardState *cs)
 {
-	unsigned long flags;
 	u_char irqcfg;
 
 	if (cs->typ != ISDN_CTYPE_TELESPCMCIA) {
@@ -209,27 +207,21 @@ reset_teles3(struct IsdnCardState *cs)
 				default:
 					return(1);
 			}
-			spin_lock_irqsave(&teles3_lock, flags);
 			byteout(cs->hw.teles3.cfg_reg + 4, irqcfg);
 			HZDELAY(HZ / 10 + 1);
 			byteout(cs->hw.teles3.cfg_reg + 4, irqcfg | 1);
 			HZDELAY(HZ / 10 + 1);
-			spin_unlock_irqrestore(&teles3_lock, flags);
 		} else if (cs->typ == ISDN_CTYPE_COMPAQ_ISA) {
-			spin_lock_irqsave(&teles3_lock, flags);
 			byteout(cs->hw.teles3.cfg_reg, 0xff);
 			HZDELAY(2);
 			byteout(cs->hw.teles3.cfg_reg, 0x00);
 			HZDELAY(2);
-			spin_unlock_irqrestore(&teles3_lock, flags);
 		} else {
 			/* Reset off for 16.3 PnP , thanks to Georg Acher */
-			spin_lock_irqsave(&teles3_lock, flags);
 			byteout(cs->hw.teles3.isac + 0x3c, 0);
 			HZDELAY(2);
 			byteout(cs->hw.teles3.isac + 0x3c, 1);
 			HZDELAY(2);
-			spin_unlock_irqrestore(&teles3_lock, flags);
 		}
 	}
 	return(0);