ISDN/HiSax: Move isac{read,write}{,fifo} into struct dc_hw_ops

Abstract the D-Channel access operations into a struct dc_hw_ops.

drivers/isdn/hisax/amd7930_fn.c

@@ -77,13 +77,13 @@ LOBYTE(u16 w)
 static inline u8
 rByteAMD(struct IsdnCardState *cs, u8 reg)
 {
-	return cs->readisac(cs, reg);
+	return cs->dc_hw_ops->read_reg(cs, reg);
 }
 
 static inline void
 wByteAMD(struct IsdnCardState *cs, u8 reg, u8 val)
 {
-	cs->writeisac(cs, reg, val);
+	cs->dc_hw_ops->write_reg(cs, reg, val);
 }
 
 static void

drivers/isdn/hisax/asuscom.c

@@ -111,6 +111,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.asus.adr, cs->hw.asus.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
 {
@@ -135,6 +142,13 @@ WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.asus.adr, cs->hw.asus.isac, 0x80, data, size);
 }
 
+static struct dc_hw_ops ipac_dc_ops = {
+	.read_reg   = ReadISAC_IPAC,
+	.write_reg  = WriteISAC_IPAC,
+	.read_fifo  = ReadISACfifo_IPAC,
+	.write_fifo = WriteISACfifo_IPAC,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -404,10 +418,7 @@ setup_asuscom(struct IsdnCard *card)
 		cs->hw.asus.isac = cs->hw.asus.cfg_reg + ASUS_IPAC_DATA;
 		cs->hw.asus.hscx = cs->hw.asus.cfg_reg + ASUS_IPAC_DATA;
 		test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-		cs->readisac = &ReadISAC_IPAC;
-		cs->writeisac = &WriteISAC_IPAC;
-		cs->readisacfifo = &ReadISACfifo_IPAC;
-		cs->writeisacfifo = &WriteISACfifo_IPAC;
+		cs->dc_hw_ops = &ipac_dc_ops;
 		cs->irq_func = &asuscom_interrupt_ipac;
 		printk(KERN_INFO "Asus: IPAC version %x\n", val);
 	} else {
@@ -417,10 +428,7 @@ setup_asuscom(struct IsdnCard *card)
 		cs->hw.asus.hscx = cs->hw.asus.cfg_reg + ASUS_HSCX;
 		cs->hw.asus.u7 = cs->hw.asus.cfg_reg + ASUS_CTRL_U7;
 		cs->hw.asus.pots = cs->hw.asus.cfg_reg + ASUS_CTRL_POTS;
-		cs->readisac = &ReadISAC;
-		cs->writeisac = &WriteISAC;
-		cs->readisacfifo = &ReadISACfifo;
-		cs->writeisacfifo = &WriteISACfifo;
+		cs->dc_hw_ops = &isac_ops;
 		cs->irq_func = &asuscom_interrupt;
 		ISACVersion(cs, "ISDNLink:");
 		if (HscxVersion(cs, "ISDNLink:")) {

drivers/isdn/hisax/avm_a1.c

@@ -77,6 +77,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	write_fifo(cs->hw.avm.isacfifo, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -294,10 +301,7 @@ setup_avm_a1(struct IsdnCard *card)
 	       cs->hw.avm.hscx[0] + 32, cs->hw.avm.hscxfifo[0],
 	       cs->hw.avm.hscx[1] + 32, cs->hw.avm.hscxfifo[1]);
 
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &AVM_card_msg;

drivers/isdn/hisax/avm_a1p.c

@@ -108,6 +108,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	spin_unlock_irqrestore(&avm_a1p_lock, flags);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static inline u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -275,10 +282,7 @@ setup_avm_a1_pcmcia(struct IsdnCard *card)
 	printk(KERN_INFO "AVM A1 PCMCIA: io 0x%x irq %d model %d version %d\n",
 				cs->hw.avm.cfg_reg, cs->irq, model, vers);
 
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &AVM_card_msg;

drivers/isdn/hisax/avm_pci.c

@@ -116,6 +116,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	outsb(cs->hw.avm.isac, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static inline u_int
 ReadHDLCPCI(struct IsdnCardState *cs, int chan, u_char offset)
 {
@@ -764,10 +771,7 @@ setup_avm_pcipnp(struct IsdnCard *card)
 		(cs->subtyp == AVM_FRITZ_PCI) ? "AVM Fritz!PCI" : "AVM Fritz!PnP",
 		cs->irq, cs->hw.avm.cfg_reg);
 
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->BC_Send_Data = &hdlc_fill_fifo;
 	cs->cardmsg = &AVM_card_msg;
 	cs->irq_func = &avm_pcipnp_interrupt;

drivers/isdn/hisax/bkm_a4t.c

@@ -104,6 +104,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.ax.isac_ale, cs->hw.ax.isac_adr, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadJADE(struct IsdnCardState *cs, int jade, u_char offset)
 {
@@ -332,10 +339,7 @@ setup_bkm_a4t(struct IsdnCard *card)
 	       CardType[card->typ], cs->hw.ax.base, cs->irq);
 
 	reset_bkm(cs);
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &jade_ops;
 	cs->BC_Send_Data = &jade_fill_fifo;
 	cs->cardmsg = &BKM_card_msg;

drivers/isdn/hisax/bkm_a8.c

@@ -110,6 +110,12 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.ax.base, cs->hw.ax.data_adr, 0x80, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
 
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
@@ -435,11 +441,7 @@ setup_sct_quadro(struct IsdnCard *card)
 
 	test_and_set_bit(HW_IPAC, &cs->HW_Flags);
 
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
-
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &BKM_card_msg;

drivers/isdn/hisax/diva.c

@@ -166,6 +166,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char *data, int size)
 	writefifo(cs->hw.diva.isac_adr, cs->hw.diva.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
 {
@@ -190,6 +197,13 @@ WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.diva.isac_adr, cs->hw.diva.isac, 0x80, data, size);
 }
 
+static struct dc_hw_ops ipac_dc_ops = {
+	.read_reg   = ReadISAC_IPAC,
+	.write_reg  = WriteISAC_IPAC,
+	.read_fifo  = ReadISACfifo_IPAC,
+	.write_fifo = WriteISACfifo_IPAC,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -235,6 +249,13 @@ MemWriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 		memwritereg(cs->hw.diva.cfg_reg, 0x80, *data++);
 }
 
+static struct dc_hw_ops mem_ipac_dc_ops = {
+	.read_reg   = MemReadISAC_IPAC,
+	.write_reg  = MemWriteISAC_IPAC,
+	.read_fifo  = MemReadISACfifo_IPAC,
+	.write_fifo = MemWriteISACfifo_IPAC,
+};
+
 static u_char
 MemReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -279,6 +300,13 @@ MemWriteISACfifo_IPACX(struct IsdnCardState *cs, u_char * data, int size)
 		memwritereg(cs->hw.diva.cfg_reg, 0, *data++);
 }
 
+static struct dc_hw_ops mem_ipacx_dc_ops = {
+	.read_reg   = MemReadISAC_IPACX,
+	.write_reg  = MemWriteISAC_IPACX,
+	.read_fifo  = MemReadISACfifo_IPACX,
+	.write_fifo = MemWriteISACfifo_IPACX,
+};
+
 static u_char
 MemReadHSCX_IPACX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -1083,28 +1111,19 @@ setup_diva(struct IsdnCard *card)
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &Diva_card_msg;
 	if (cs->subtyp == DIVA_IPAC_ISA) {
-		cs->readisac  = &ReadISAC_IPAC;
-		cs->writeisac = &WriteISAC_IPAC;
-		cs->readisacfifo  = &ReadISACfifo_IPAC;
-		cs->writeisacfifo = &WriteISACfifo_IPAC;
+		cs->dc_hw_ops = &ipac_dc_ops;
 		cs->irq_func = &diva_irq_ipac_isa;
 		val = readreg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_ID);
 		printk(KERN_INFO "Diva: IPAC version %x\n", val);
 	} else if (cs->subtyp == DIVA_IPAC_PCI) {
-		cs->readisac  = &MemReadISAC_IPAC;
-		cs->writeisac = &MemWriteISAC_IPAC;
-		cs->readisacfifo  = &MemReadISACfifo_IPAC;
-		cs->writeisacfifo = &MemWriteISACfifo_IPAC;
+		cs->dc_hw_ops = &mem_ipac_dc_ops;
 		cs->bc_hw_ops = &mem_hscx_ops;
 		cs->BC_Send_Data = &Memhscx_fill_fifo;
 		cs->irq_func = &diva_irq_ipac_pci;
 		val = memreadreg(cs->hw.diva.cfg_reg, IPAC_ID);
 		printk(KERN_INFO "Diva: IPAC version %x\n", val);
 	} else if (cs->subtyp == DIVA_IPACX_PCI) {
-		cs->readisac  = &MemReadISAC_IPACX;
-		cs->writeisac = &MemWriteISAC_IPACX;
-		cs->readisacfifo  = &MemReadISACfifo_IPACX;
-		cs->writeisacfifo = &MemWriteISACfifo_IPACX;
+		cs->dc_hw_ops = &mem_ipacx_dc_ops;
 		cs->bc_hw_ops = &mem_ipacx_bc_ops;
 		cs->BC_Send_Data = &ipacx_fill_fifo;
 		cs->irq_func = &diva_irq_ipacx_pci;
@@ -1114,10 +1133,7 @@ setup_diva(struct IsdnCard *card)
 		cs->hw.diva.tl.function = (void *) diva_led_handler;
 		cs->hw.diva.tl.data = (long) cs;
 		init_timer(&cs->hw.diva.tl);
-		cs->readisac  = &ReadISAC;
-		cs->writeisac = &WriteISAC;
-		cs->readisacfifo  = &ReadISACfifo;
-		cs->writeisacfifo = &WriteISACfifo;
+		cs->dc_hw_ops = &isac_ops;
 		cs->irq_func = &diva_interrupt;
 		ISACVersion(cs, "Diva:");
 		if (HscxVersion(cs, "Diva:")) {

drivers/isdn/hisax/elsa.c

@@ -210,6 +210,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
 {
@@ -234,6 +241,13 @@ WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.elsa.ale, cs->hw.elsa.isac, 0x80, data, size);
 }
 
+static struct dc_hw_ops ipac_dc_ops = {
+	.read_reg   = ReadISAC_IPAC,
+	.write_reg  = WriteISAC_IPAC,
+	.read_fifo  = ReadISACfifo_IPAC,
+	.write_fifo = WriteISACfifo_IPAC,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -1169,18 +1183,12 @@ setup_elsa(struct IsdnCard *card)
 	cs->cardmsg = &Elsa_card_msg;
 	reset_elsa(cs);
 	if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
-		cs->readisac = &ReadISAC_IPAC;
-		cs->writeisac = &WriteISAC_IPAC;
-		cs->readisacfifo = &ReadISACfifo_IPAC;
-		cs->writeisacfifo = &WriteISACfifo_IPAC;
+		cs->dc_hw_ops = &ipac_dc_ops;
 		cs->irq_func = &elsa_interrupt_ipac;
 		val = readreg(cs->hw.elsa.ale, cs->hw.elsa.isac, IPAC_ID);
 		printk(KERN_INFO "Elsa: IPAC version %x\n", val);
 	} else {
-		cs->readisac = &ReadISAC;
-		cs->writeisac = &WriteISAC;
-		cs->readisacfifo = &ReadISACfifo;
-		cs->writeisacfifo = &WriteISACfifo;
+		cs->dc_hw_ops = &isac_ops;
 		cs->irq_func = &elsa_interrupt;
 		ISACVersion(cs, "Elsa:");
 		if (HscxVersion(cs, "Elsa:")) {

drivers/isdn/hisax/enternow.h

@@ -40,12 +40,3 @@
  * den TigerJet i/o-Raum gemappt
  * -> 0x01 des AMD bei hw.njet.base + 0C4 */
 #define TJ_AMD_PORT						0xC0
-
-
-
-/* ***************************************************************************************** *
- * *************************************** Prototypen ************************************** *
- * ***************************************************************************************** */
-
-BYTE ReadByteAmd7930(struct IsdnCardState *cs, BYTE offset);
-void WriteByteAmd7930(struct IsdnCardState *cs, BYTE offset, BYTE value);

drivers/isdn/hisax/enternow_pci.c

@@ -80,7 +80,7 @@ const char *enternow_pci_rev = "$Revision: 1.1.2.1 $";
 
 
 /* cs->readisac, macro rByteAMD */
-BYTE
+static BYTE
 ReadByteAmd7930(struct IsdnCardState *cs, BYTE offset)
 {
 	/* direktes Register */
@@ -95,7 +95,7 @@ ReadByteAmd7930(struct IsdnCardState *cs, BYTE offset)
 }
 
 /* cs->writeisac, macro wByteAMD */
-void
+static void
 WriteByteAmd7930(struct IsdnCardState *cs, BYTE offset, BYTE value)
 {
 	/* direktes Register */
@@ -110,6 +110,11 @@ WriteByteAmd7930(struct IsdnCardState *cs, BYTE offset, BYTE value)
 }
 
 
+static struct dc_hw_ops enternow_ops = {
+	.read_reg   = ReadByteAmd7930,
+	.write_reg  = WriteByteAmd7930,
+};
+
 void
 enpci_setIrqMask(struct IsdnCardState *cs, BYTE val) {
         if (!val)
@@ -364,10 +369,7 @@ setup_enternow_pci(struct IsdnCard *card)
 	}
 	reset_enpci(cs);
 	cs->hw.njet.last_is0 = 0;
-        /* macro rByteAMD */
-        cs->readisac = &ReadByteAmd7930;
-        /* macro wByteAMD */
-        cs->writeisac = &WriteByteAmd7930;
+	cs->dc_hw_ops = &enternow_ops;
         cs->dc.amd7930.setIrqMask = &enpci_setIrqMask;
 
 	cs->BC_Send_Data = &netjet_fill_dma;

drivers/isdn/hisax/gazel.c

@@ -175,6 +175,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	}
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static void
 ReadHSCXfifo(struct IsdnCardState *cs, int hscx, u_char * data, int size)
 {
@@ -681,10 +688,7 @@ setup_gazel(struct IsdnCard *card)
 		release_io_gazel(cs);
 		return (0);
 	}
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &Gazel_card_msg;

drivers/isdn/hisax/hfc_2bs0.c

@@ -448,7 +448,7 @@ mode_hfc(struct BCState *bcs, int mode, int bc)
 			break;
 	}
 	hfc_write_reg(cs, HFC_STATUS, cs->hw.hfc.ctmt, cs->hw.hfc.ctmt);
-	cs->writeisac(cs, ISAC_SPCR, cs->hw.hfc.isac_spcr);
+	cs->dc_hw_ops->write_reg(cs, ISAC_SPCR, cs->hw.hfc.isac_spcr);
 	if (mode == L1_MODE_HDLC)
 		hfc_clear_fifo(bcs);
 }

drivers/isdn/hisax/hfc_pci.c

@@ -1473,10 +1473,6 @@ setup_hfcpci(struct IsdnCard *card)
 		return (0);	/* no valid card type */
 
 
-	cs->readisac = NULL;
-	cs->writeisac = NULL;
-	cs->readisacfifo = NULL;
-	cs->writeisacfifo = NULL;
 	cs->irq_func = &hfcpci_interrupt;
 	cs->irq_flags |= SA_SHIRQ;
 

drivers/isdn/hisax/hfc_sx.c

@@ -1285,10 +1285,6 @@ setup_hfcsx(struct IsdnCard *card)
 	} else
 		return (0);	/* no valid card type */
 
-	cs->readisac = NULL;
-	cs->writeisac = NULL;
-	cs->readisacfifo = NULL;
-	cs->writeisacfifo = NULL;
 	cs->irq_func = &hfcsx_interrupt;
 
 	cs->hw.hfcsx.timer.function = (void *) hfcsx_Timer;

drivers/isdn/hisax/hisax.h

@@ -866,6 +866,13 @@ struct icc_chip {
 	u_char adf2;
 };
 
+struct dc_hw_ops {
+	u8     (*read_reg)   (struct IsdnCardState *, u8);
+	void   (*write_reg)  (struct IsdnCardState *, u8, u8);
+	void   (*read_fifo)  (struct IsdnCardState *, u8 *, int);
+	void   (*write_fifo) (struct IsdnCardState *, u8 *, int);
+};
+
 #define HW_IOM1			0
 #define HW_IPAC			1
 #define HW_ISAR			2
@@ -922,10 +929,7 @@ struct IsdnCardState {
 	u_char *status_read;
 	u_char *status_write;
 	u_char *status_end;
-	u_char (*readisac) (struct IsdnCardState *, u_char);
-	void   (*writeisac) (struct IsdnCardState *, u_char, u_char);
-	void   (*readisacfifo) (struct IsdnCardState *, u_char *, int);
-	void   (*writeisacfifo) (struct IsdnCardState *, u_char *, int);
+	struct dc_hw_ops *dc_hw_ops;
 	struct bc_hw_ops *bc_hw_ops;
 	void   (*BC_Send_Data) (struct BCState *);
 	int    (*cardmsg) (struct IsdnCardState *, int, void *);

drivers/isdn/hisax/icc.c

@@ -28,25 +28,25 @@ static spinlock_t icc_lock = SPIN_LOCK_UNLOCKED;
 static inline u8
 icc_read_reg(struct IsdnCardState *cs, u8 addr)
 {
-	return cs->readisac(cs, addr);
+	return cs->dc_hw_ops->read_reg(cs, addr);
 }
 
 static inline void
 icc_write_reg(struct IsdnCardState *cs, u8 addr, u8 val)
 {
-	cs->writeisac(cs, addr, val);
+	cs->dc_hw_ops->write_reg(cs, addr, val);
 }
 
 static inline void
 icc_read_fifo(struct IsdnCardState *cs, u8 *p, int len)
 {
-	return cs->readisacfifo(cs, p, len);
+	return cs->dc_hw_ops->read_fifo(cs, p, len);
 }
 
 static inline void
 icc_write_fifo(struct IsdnCardState *cs, u8 *p, int len)
 {
-	return cs->writeisacfifo(cs, p, len);
+	return cs->dc_hw_ops->write_fifo(cs, p, len);
 }
 
 static char *ICCVer[] __initdata =

drivers/isdn/hisax/ipacx.c

@@ -74,25 +74,25 @@ ipacx_bc_write_reg(struct BCState *bcs, u8 addr, u8 val)
 static inline u8
 ipacx_read_reg(struct IsdnCardState *cs, u8 addr)
 {
-	return cs->readisac(cs, addr);
+	return cs->dc_hw_ops->read_reg(cs, addr);
 }
 
 static inline void
 ipacx_write_reg(struct IsdnCardState *cs, u8 addr, u8 val)
 {
-	cs->writeisac(cs, addr, val);
+	cs->dc_hw_ops->write_reg(cs, addr, val);
 }
 
 static inline void
 ipacx_read_fifo(struct IsdnCardState *cs, u8 *p, int len)
 {
-	return cs->readisacfifo(cs, p, len);
+	return cs->dc_hw_ops->read_fifo(cs, p, len);
 }
 
 static inline void
 ipacx_write_fifo(struct IsdnCardState *cs, u8 *p, int len)
 {
-	return cs->writeisacfifo(cs, p, len);
+	return cs->dc_hw_ops->write_fifo(cs, p, len);
 }
 //----------------------------------------------------------
 // Issue Layer 1 command to chip

drivers/isdn/hisax/isac.h

@@ -70,23 +70,23 @@ extern void isac_interrupt(struct IsdnCardState *cs, u_char val);
 static inline u8
 isac_read_reg(struct IsdnCardState *cs, u8 addr)
 {
-	return cs->readisac(cs, addr);
+	return cs->dc_hw_ops->read_reg(cs, addr);
 }
 
 static inline void
 isac_write_reg(struct IsdnCardState *cs, u8 addr, u8 val)
 {
-	cs->writeisac(cs, addr, val);
+	cs->dc_hw_ops->write_reg(cs, addr, val);
 }
 
 static inline void
 isac_read_fifo(struct IsdnCardState *cs, u8 *p, int len)
 {
-	return cs->readisacfifo(cs, p, len);
+	return cs->dc_hw_ops->read_fifo(cs, p, len);
 }
 
 static inline void
 isac_write_fifo(struct IsdnCardState *cs, u8 *p, int len)
 {
-	return cs->writeisacfifo(cs, p, len);
+	return cs->dc_hw_ops->write_fifo(cs, p, len);
 }

drivers/isdn/hisax/isurf.c

@@ -64,6 +64,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	}
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 /* ISAR access routines
  * mode = 0 access with IRQ on
  * mode = 1 access with IRQ off
@@ -278,10 +285,7 @@ setup_isurf(struct IsdnCard *card)
 	cs->cardmsg = &ISurf_card_msg;
 	cs->irq_func = &isurf_interrupt;
 	cs->auxcmd = &isurf_auxcmd;
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bcs[0].hw.isar.reg = &cs->hw.isurf.isar_r;
 	cs->bcs[1].hw.isar.reg = &cs->hw.isurf.isar_r;
 	reset_isurf(cs, ISURF_RESET);

drivers/isdn/hisax/ix1_micro.c

@@ -108,6 +108,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.ix1.isac_ale, cs->hw.ix1.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -305,10 +312,7 @@ setup_ix1micro(struct IsdnCard *card)
 	       CardType[cs->typ], cs->irq,
 	       cs->hw.ix1.cfg_reg);
 	ix1_reset(cs);
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &ix1_card_msg;

drivers/isdn/hisax/mic.c

@@ -100,6 +100,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.mic.adr, cs->hw.mic.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -233,10 +240,7 @@ setup_mic(struct IsdnCard *card)
 	       "mic: defined at 0x%x IRQ %d\n",
 	       cs->hw.mic.cfg_reg,
 	       cs->irq);
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &mic_card_msg;

drivers/isdn/hisax/netjet.c

@@ -66,7 +66,22 @@ NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size)
 	insb(cs->hw.njet.isac, data, size);
 }
 
-__u16 fcstab[256] =
+void 
+NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
+{
+	cs->hw.njet.auxd &= 0xfc;
+	byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
+	outsb(cs->hw.njet.isac, data, size);
+}
+
+struct dc_hw_ops netjet_dc_ops = {
+	.read_reg   = NETjet_ReadIC,
+	.write_reg  = NETjet_WriteIC,
+	.read_fifo  = NETjet_ReadICfifo,
+	.write_fifo = NETjet_WriteICfifo,
+};
+
+static u16 fcstab[256] =
 {
 	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
@@ -102,14 +117,6 @@ __u16 fcstab[256] =
 	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 };
 
-void 
-NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
-{
-	cs->hw.njet.auxd &= 0xfc;
-	byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
-	outsb(cs->hw.njet.isac, data, size);
-}
-
 void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill)
 {
 	u_int mask=0x000000ff, val = 0, *p=pos;

drivers/isdn/hisax/netjet.h

@@ -57,6 +57,8 @@ extern const char *CardType[];
 
 #define HDLC_FLAG_VALUE	0x7e
 
+extern struct dc_hw_ops netjet_dc_ops;
+
 u_char NETjet_ReadIC(struct IsdnCardState *cs, u_char offset);
 void NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value);
 void NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size);

drivers/isdn/hisax/niccy.c

@@ -115,6 +115,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -377,10 +384,7 @@ setup_niccy(struct IsdnCard *card)
 		"HiSax: %s %s config irq:%d data:0x%X ale:0x%X\n",
 		CardType[cs->typ], (cs->subtyp==1) ? "PnP":"PCI",
 		cs->irq, cs->hw.niccy.isac, cs->hw.niccy.isac_ale);
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &niccy_card_msg;

drivers/isdn/hisax/nj_s.c

@@ -226,10 +226,7 @@ setup_netjet_s(struct IsdnCard *card)
 		request_region(cs->hw.njet.base, bytecnt, "netjet-s isdn");
 	}
 	reset_netjet_s(cs);
-	cs->readisac  = &NETjet_ReadIC;
-	cs->writeisac = &NETjet_WriteIC;
-	cs->readisacfifo  = &NETjet_ReadICfifo;
-	cs->writeisacfifo = &NETjet_WriteICfifo;
+	cs->dc_hw_ops = &netjet_dc_ops;
 	cs->BC_Send_Data = &netjet_fill_dma;
 	cs->cardmsg = &NETjet_S_card_msg;
 	cs->irq_func = &netjet_s_interrupt;

drivers/isdn/hisax/nj_u.c

@@ -107,7 +107,7 @@ NETjet_U_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 			inittiger(cs);
 			initicc(cs);
 			/* Reenable all IRQ */
-			cs->writeisac(cs, ICC_MASK, 0);
+			NETjet_WriteIC(cs, ICC_MASK, 0);
 			return(0);
 		case CARD_TEST:
 			return(0);
@@ -224,10 +224,7 @@ setup_netjet_u(struct IsdnCard *card)
 		request_region(cs->hw.njet.base, bytecnt, "netspider-u isdn");
 	}
 	reset_netjet_u(cs);
-	cs->readisac  = &NETjet_ReadIC;
-	cs->writeisac = &NETjet_WriteIC;
-	cs->readisacfifo  = &NETjet_ReadICfifo;
-	cs->writeisacfifo = &NETjet_WriteICfifo;
+	cs->dc_hw_ops = &netjet_dc_ops;
 	cs->BC_Send_Data = &netjet_fill_dma;
 	cs->cardmsg = &NETjet_U_card_msg;
 	cs->irq_func = &netjet_u_interrupt;

drivers/isdn/hisax/s0box.c

@@ -125,6 +125,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	write_fifo(cs->hw.teles3.cfg_reg, cs->hw.teles3.isacfifo, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -253,10 +260,7 @@ setup_s0box(struct IsdnCard *card)
 	printk(KERN_INFO
 	       "HiSax: hscx A:0x%x  hscx B:0x%x\n",
 	       cs->hw.teles3.hscx[0], cs->hw.teles3.hscx[1]);
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &S0Box_card_msg;

drivers/isdn/hisax/saphir.c

@@ -100,6 +100,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.saphir.ale, cs->hw.saphir.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -177,7 +184,7 @@ static void
 SaphirWatchDog(struct IsdnCardState *cs)
 {
         /* 5 sec WatchDog, so read at least every 4 sec */
-	cs->readisac(cs, ISAC_RBCH);
+	ReadISAC(cs, ISAC_RBCH);
 	mod_timer(&cs->hw.saphir.timer, jiffies+1*HZ);
 }
 
@@ -288,10 +295,7 @@ setup_saphir(struct IsdnCard *card)
 		release_io_saphir(cs);
 		return (0);
 	}
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &saphir_card_msg;

drivers/isdn/hisax/sedlbauer.c

@@ -186,6 +186,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadISAC_IPAC(struct IsdnCardState *cs, u_char offset)
 {
@@ -210,6 +217,13 @@ WriteISACfifo_IPAC(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.sedl.adr, cs->hw.sedl.isac, 0x80, data, size);
 }
 
+static struct dc_hw_ops ipac_dc_ops = {
+	.read_reg   = ReadISAC_IPAC,
+	.write_reg  = WriteISAC_IPAC,
+	.read_fifo  = ReadISACfifo_IPAC,
+	.write_fifo = WriteISACfifo_IPAC,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -751,10 +765,7 @@ setup_sedlbauer(struct IsdnCard *card)
 			cs->hw.sedl.hscx = cs->hw.sedl.cfg_reg + SEDL_IPAC_ANY_IPAC;
 		}
 		test_and_set_bit(HW_IPAC, &cs->HW_Flags);
-		cs->readisac = &ReadISAC_IPAC;
-		cs->writeisac = &WriteISAC_IPAC;
-		cs->readisacfifo = &ReadISACfifo_IPAC;
-		cs->writeisacfifo = &WriteISACfifo_IPAC;
+		cs->dc_hw_ops = &ipac_dc_ops;
 		cs->irq_func = &sedlbauer_interrupt_ipac;
 
 		val = readreg(cs->hw.sedl.adr, cs->hw.sedl.isac, IPAC_ID);
@@ -762,10 +773,7 @@ setup_sedlbauer(struct IsdnCard *card)
 		reset_sedlbauer(cs);
 	} else {
 		/* ISAC_HSCX oder ISAC_ISAR */
-		cs->readisac = &ReadISAC;
-		cs->writeisac = &WriteISAC;
-		cs->readisacfifo = &ReadISACfifo;
-		cs->writeisacfifo = &WriteISACfifo;
+		cs->dc_hw_ops = &isac_ops;
 		if (cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) {
 			if (cs->hw.sedl.bus == SEDL_BUS_PCI) {
 				cs->hw.sedl.adr = cs->hw.sedl.cfg_reg +

drivers/isdn/hisax/sportster.c

@@ -75,6 +75,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	write_fifo(cs->hw.spt.isac, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -251,10 +258,7 @@ setup_sportster(struct IsdnCard *card)
 	       CardType[cs->typ], cs->irq,
 	       cs->hw.spt.cfg_reg);
 
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &Sportster_card_msg;

drivers/isdn/hisax/teleint.c

@@ -139,6 +139,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	writefifo(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, 0, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHFC(struct IsdnCardState *cs, int data, u_char reg)
 {
@@ -324,10 +331,7 @@ setup_TeleInt(struct IsdnCard *card)
 	       cs->irq);
 
 	reset_TeleInt(cs);
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hfc_ops;
 	cs->cardmsg = &TeleInt_card_msg;
 	cs->irq_func = &TeleInt_interrupt;

drivers/isdn/hisax/teles0.c

@@ -120,6 +120,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	write_fifo_isac(cs->hw.teles0.membase, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -349,10 +356,7 @@ setup_teles0(struct IsdnCard *card)
 		release_io_teles0(cs);
 		return (0);
 	}
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &Teles_card_msg;

drivers/isdn/hisax/teles3.c

@@ -77,6 +77,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	write_fifo(cs->hw.teles3.isacfifo, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -471,10 +478,7 @@ setup_teles3(struct IsdnCard *card)
 		release_io_teles3(cs);
 		return (0);
 	}
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &Teles_card_msg;

drivers/isdn/hisax/telespci.c

@@ -203,6 +203,13 @@ WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 	write_fifo_isac(cs->hw.teles0.membase, data, size);
 }
 
+static struct dc_hw_ops isac_ops = {
+	.read_reg   = ReadISAC,
+	.write_reg  = WriteISAC,
+	.read_fifo  = ReadISACfifo,
+	.write_fifo = WriteISACfifo,
+};
+
 static u_char
 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
@@ -337,10 +344,7 @@ setup_telespci(struct IsdnCard *card)
 	       CardType[cs->typ], cs->irq,
 	       cs->hw.teles0.membase);
 
-	cs->readisac = &ReadISAC;
-	cs->writeisac = &WriteISAC;
-	cs->readisacfifo = &ReadISACfifo;
-	cs->writeisacfifo = &WriteISACfifo;
+	cs->dc_hw_ops = &isac_ops;
 	cs->bc_hw_ops = &hscx_ops;
 	cs->BC_Send_Data = &hscx_fill_fifo;
 	cs->cardmsg = &TelesPCI_card_msg;