URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [before_ORP/] [uclinux/] [uClinux-2.0.x/] [drivers/] [isdn/] [hisax/] [avm_a1.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* $Id: avm_a1.c,v 1.1.1.1 2001-09-10 07:44:18 simons Exp $
 
 * avm_a1.c     low level stuff for AVM A1 (Fritz) isdn cards
 *
 * Author       Karsten Keil (keil@isdn4linux.de)
 *
 *
 * $Log: not supported by cvs2svn $
 * Revision 1.1.1.1  2001/07/02 17:58:32  simons
 * Initial revision
 *
 * Revision 1.6.2.12  1998/11/03 00:05:44  keil
 * certification related changes
 * fixed logging for smaller stack use
 *
 * Revision 1.6.2.11  1998/09/27 13:05:30  keil
 * Apply most changes from 2.1.X (HiSax 3.1)
 *
 * Revision 1.6.2.10  1998/05/27 18:04:50  keil
 * HiSax 3.0
 *
 * Revision 1.6.2.9  1998/04/08 21:58:39  keil
 * New init code
 *
 * Revision 1.6.2.8  1998/01/27 22:37:49  keil
 * fast io
 *
 * Revision 1.6.2.7  1998/01/13 23:06:11  keil
 * really disable internal timer
 *
 * Revision 1.6.2.6  1998/01/02 06:49:01  calle
 * Perodic timer of A1 now disabled, no need for linux driver.
 *
 * Revision 1.6.2.5  1997/11/15 18:50:41  keil
 * new common init function
 *
 * Revision 1.6.2.4  1997/10/17 22:13:29  keil
 * update to last hisax version
 *
 * Revision 2.1  1997/07/27 21:47:13  keil
 * new interface structures
 *
 * Revision 2.0  1997/06/26 11:02:48  keil
 * New Layer and card interface
 *
 * Revision 1.6  1997/04/13 19:54:07  keil
 * Change in IRQ check delay for SMP
 *
 * Revision 1.5  1997/04/06 22:54:10  keil
 * Using SKB's
 *
 * Revision 1.4  1997/01/27 15:50:21  keil
 * SMP proof,cosmetics
 *
 * Revision 1.3  1997/01/21 22:14:20  keil
 * cleanups
 *
 * Revision 1.2  1996/10/27 22:07:31  keil
 * cosmetic changes
 *
 * Revision 1.1  1996/10/13 20:04:49  keil
 * Initial revision
 *
 *
 */
#define __NO_VERSION__
#include "hisax.h"
#include "isac.h"
#include "hscx.h"
#include "isdnl1.h"
 
extern const char *CardType[];
static const char *avm_revision = "$Revision: 1.1.1.1 $";
 
#define  AVM_A1_STAT_ISAC       0x01
#define  AVM_A1_STAT_HSCX       0x02
#define  AVM_A1_STAT_TIMER      0x04
 
#define byteout(addr,val) outb(val,addr)
#define bytein(addr) inb(addr)
 
static inline u_char
readreg(unsigned int adr, u_char off)
{
        return (bytein(adr + off));
}
 
static inline void
writereg(unsigned int adr, u_char off, u_char data)
{
        byteout(adr + off, data);
}
 
 
static inline void
read_fifo(unsigned int adr, u_char * data, int size)
{
        insb(adr, data, size);
}
 
static void
write_fifo(unsigned int adr, u_char * data, int size)
{
        outsb(adr, data, size);
}
 
/* Interface functions */
 
static u_char
ReadISAC(struct IsdnCardState *cs, u_char offset)
{
        return (readreg(cs->hw.avm.isac, offset));
}
 
static void
WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
{
        writereg(cs->hw.avm.isac, offset, value);
}
 
static void
ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
{
        read_fifo(cs->hw.avm.isacfifo, data, size);
}
 
static void
WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
{
        write_fifo(cs->hw.avm.isacfifo, data, size);
}
 
static u_char
ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
{
        return (readreg(cs->hw.avm.hscx[hscx], offset));
}
 
static void
WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
{
        writereg(cs->hw.avm.hscx[hscx], offset, value);
}
 
/*
 * fast interrupt HSCX stuff goes here
 */
 
#define READHSCX(cs, nr, reg) readreg(cs->hw.avm.hscx[nr], reg)
#define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.avm.hscx[nr], reg, data)
#define READHSCXFIFO(cs, nr, ptr, cnt) read_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
#define WRITEHSCXFIFO(cs, nr, ptr, cnt) write_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
 
#include "hscx_irq.c"
 
static void
avm_a1_interrupt(int intno, void *dev_id, struct pt_regs *regs)
{
        struct IsdnCardState *cs = dev_id;
        u_char val, sval, stat = 0;
 
        if (!cs) {
                printk(KERN_WARNING "AVM A1: Spurious interrupt!\n");
                return;
        }
        while (((sval = bytein(cs->hw.avm.cfg_reg)) & 0xf) != 0x7) {
                if (!(sval & AVM_A1_STAT_TIMER)) {
                        byteout(cs->hw.avm.cfg_reg, 0x1E);
                        sval = bytein(cs->hw.avm.cfg_reg);
                } else if (cs->debug & L1_DEB_INTSTAT)
                        debugl1(cs, "avm IntStatus %x", sval);
                if (!(sval & AVM_A1_STAT_HSCX)) {
                        val = readreg(cs->hw.avm.hscx[1], HSCX_ISTA);
                        if (val) {
                                hscx_int_main(cs, val);
                                stat |= 1;
                        }
                }
                if (!(sval & AVM_A1_STAT_ISAC)) {
                        val = readreg(cs->hw.avm.isac, ISAC_ISTA);
                        if (val) {
                                isac_interrupt(cs, val);
                                stat |= 2;
                        }
                }
        }
        if (stat & 1) {
                writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0xFF);
                writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0xFF);
                writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0x0);
                writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0x0);
        }
        if (stat & 2) {
                writereg(cs->hw.avm.isac, ISAC_MASK, 0xFF);
                writereg(cs->hw.avm.isac, ISAC_MASK, 0x0);
        }
}
 
inline static void
release_ioregs(struct IsdnCardState *cs, int mask)
{
        release_region(cs->hw.avm.cfg_reg, 8);
        if (mask & 1)
                release_region(cs->hw.avm.isac + 32, 32);
        if (mask & 2)
                release_region(cs->hw.avm.isacfifo, 1);
        if (mask & 4)
                release_region(cs->hw.avm.hscx[0] + 32, 32);
        if (mask & 8)
                release_region(cs->hw.avm.hscxfifo[0], 1);
        if (mask & 0x10)
                release_region(cs->hw.avm.hscx[1] + 32, 32);
        if (mask & 0x20)
                release_region(cs->hw.avm.hscxfifo[1], 1);
}
 
static int
AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
        switch (mt) {
                case CARD_RESET:
                        return(0);
                case CARD_RELEASE:
                        release_ioregs(cs, 0x3f);
                        return(0);
                case CARD_SETIRQ:
                        return(request_irq(cs->irq, &avm_a1_interrupt,
                                        I4L_IRQ_FLAG, "HiSax", cs));
                case CARD_INIT:
                        inithscxisac(cs, 1);
                        byteout(cs->hw.avm.cfg_reg, 0x16);
                        byteout(cs->hw.avm.cfg_reg, 0x1E);
                        inithscxisac(cs, 2);
                        return(0);
                case CARD_TEST:
                        return(0);
        }
        return(0);
}
 
__initfunc(int
setup_avm_a1(struct IsdnCard *card))
{
        u_char val;
        struct IsdnCardState *cs = card->cs;
        long flags;
        char tmp[64];
 
        strcpy(tmp, avm_revision);
        printk(KERN_INFO "HiSax: AVM driver Rev. %s\n", HiSax_getrev(tmp));
        if (cs->typ != ISDN_CTYPE_A1)
                return (0);
 
        cs->hw.avm.cfg_reg = card->para[1] + 0x1800;
        cs->hw.avm.isac = card->para[1] + 0x1400 - 0x20;
        cs->hw.avm.hscx[0] = card->para[1] + 0x400 - 0x20;
        cs->hw.avm.hscx[1] = card->para[1] + 0xc00 - 0x20;
        cs->hw.avm.isacfifo = card->para[1] + 0x1000;
        cs->hw.avm.hscxfifo[0] = card->para[1];
        cs->hw.avm.hscxfifo[1] = card->para[1] + 0x800;
        cs->irq = card->para[0];
        if (check_region((cs->hw.avm.cfg_reg), 8)) {
                printk(KERN_WARNING
                       "HiSax: %s config port %x-%x already in use\n",
                       CardType[card->typ],
                       cs->hw.avm.cfg_reg,
                       cs->hw.avm.cfg_reg + 8);
                return (0);
        } else {
                request_region(cs->hw.avm.cfg_reg, 8, "avm cfg");
        }
        if (check_region((cs->hw.avm.isac + 32), 32)) {
                printk(KERN_WARNING
                       "HiSax: %s isac ports %x-%x already in use\n",
                       CardType[cs->typ],
                       cs->hw.avm.isac + 32,
                       cs->hw.avm.isac + 64);
                release_ioregs(cs, 0);
                return (0);
        } else {
                request_region(cs->hw.avm.isac + 32, 32, "HiSax isac");
        }
        if (check_region((cs->hw.avm.isacfifo), 1)) {
                printk(KERN_WARNING
                       "HiSax: %s isac fifo port %x already in use\n",
                       CardType[cs->typ],
                       cs->hw.avm.isacfifo);
                release_ioregs(cs, 1);
                return (0);
        } else {
                request_region(cs->hw.avm.isacfifo, 1, "HiSax isac fifo");
        }
        if (check_region((cs->hw.avm.hscx[0]) + 32, 32)) {
                printk(KERN_WARNING
                       "HiSax: %s hscx A ports %x-%x already in use\n",
                       CardType[cs->typ],
                       cs->hw.avm.hscx[0] + 32,
                       cs->hw.avm.hscx[0] + 64);
                release_ioregs(cs, 3);
                return (0);
        } else {
                request_region(cs->hw.avm.hscx[0] + 32, 32, "HiSax hscx A");
        }
        if (check_region(cs->hw.avm.hscxfifo[0], 1)) {
                printk(KERN_WARNING
                       "HiSax: %s hscx A fifo port %x already in use\n",
                       CardType[cs->typ],
                       cs->hw.avm.hscxfifo[0]);
                release_ioregs(cs, 7);
                return (0);
        } else {
                request_region(cs->hw.avm.hscxfifo[0], 1, "HiSax hscx A fifo");
        }
        if (check_region(cs->hw.avm.hscx[1] + 32, 32)) {
                printk(KERN_WARNING
                       "HiSax: %s hscx B ports %x-%x already in use\n",
                       CardType[cs->typ],
                       cs->hw.avm.hscx[1] + 32,
                       cs->hw.avm.hscx[1] + 64);
                release_ioregs(cs, 0xf);
                return (0);
        } else {
                request_region(cs->hw.avm.hscx[1] + 32, 32, "HiSax hscx B");
        }
        if (check_region(cs->hw.avm.hscxfifo[1], 1)) {
                printk(KERN_WARNING
                       "HiSax: %s hscx B fifo port %x already in use\n",
                       CardType[cs->typ],
                       cs->hw.avm.hscxfifo[1]);
                release_ioregs(cs, 0x1f);
                return (0);
        } else {
                request_region(cs->hw.avm.hscxfifo[1], 1, "HiSax hscx B fifo");
        }
        save_flags(flags);
        byteout(cs->hw.avm.cfg_reg, 0x0);
        sti();
        HZDELAY(HZ / 5 + 1);
        byteout(cs->hw.avm.cfg_reg, 0x1);
        HZDELAY(HZ / 5 + 1);
        byteout(cs->hw.avm.cfg_reg, 0x0);
        HZDELAY(HZ / 5 + 1);
        val = cs->irq;
        if (val == 9)
                val = 2;
        byteout(cs->hw.avm.cfg_reg + 1, val);
        HZDELAY(HZ / 5 + 1);
        byteout(cs->hw.avm.cfg_reg, 0x0);
        HZDELAY(HZ / 5 + 1);
        restore_flags(flags);
 
        val = bytein(cs->hw.avm.cfg_reg);
        printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
               cs->hw.avm.cfg_reg, val);
        val = bytein(cs->hw.avm.cfg_reg + 3);
        printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
               cs->hw.avm.cfg_reg + 3, val);
        val = bytein(cs->hw.avm.cfg_reg + 2);
        printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
               cs->hw.avm.cfg_reg + 2, val);
        val = bytein(cs->hw.avm.cfg_reg);
        printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
               cs->hw.avm.cfg_reg, val);
 
        printk(KERN_INFO
               "HiSax: %s config irq:%d cfg:0x%X\n",
               CardType[cs->typ], cs->irq,
               cs->hw.avm.cfg_reg);
        printk(KERN_INFO
               "HiSax: isac:0x%X/0x%X\n",
               cs->hw.avm.isac + 32, cs->hw.avm.isacfifo);
        printk(KERN_INFO
               "HiSax: hscx A:0x%X/0x%X  hscx B:0x%X/0x%X\n",
               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->BC_Read_Reg = &ReadHSCX;
        cs->BC_Write_Reg = &WriteHSCX;
        cs->BC_Send_Data = &hscx_fill_fifo;
        cs->cardmsg = &AVM_card_msg;
        ISACVersion(cs, "AVM A1:");
        if (HscxVersion(cs, "AVM A1:")) {
                printk(KERN_WARNING
                       "AVM A1: wrong HSCX versions check IO address\n");
                release_ioregs(cs, 0x3f);
                return (0);
        }
        return (1);
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [before_ORP/] [uclinux/] [uClinux-2.0.x/] [drivers/] [isdn/] [hisax/] [avm_a1.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	199	simons	`/* $Id: avm_a1.c,v 1.1.1.1 2001-09-10 07:44:18 simons Exp $`
2
3			`* avm_a1.c low level stuff for AVM A1 (Fritz) isdn cards`
4			`*`
5			`* Author Karsten Keil (keil@isdn4linux.de)`
6			`*`
7			`*`
8			`* $Log: not supported by cvs2svn $`
9			`* Revision 1.1.1.1 2001/07/02 17:58:32 simons`
10			`* Initial revision`
11			`*`
12			`* Revision 1.6.2.12 1998/11/03 00:05:44 keil`
13			`* certification related changes`
14			`* fixed logging for smaller stack use`
15			`*`
16			`* Revision 1.6.2.11 1998/09/27 13:05:30 keil`
17			`* Apply most changes from 2.1.X (HiSax 3.1)`
18			`*`
19			`* Revision 1.6.2.10 1998/05/27 18:04:50 keil`
20			`* HiSax 3.0`
21			`*`
22			`* Revision 1.6.2.9 1998/04/08 21:58:39 keil`
23			`* New init code`
24			`*`
25			`* Revision 1.6.2.8 1998/01/27 22:37:49 keil`
26			`* fast io`
27			`*`
28			`* Revision 1.6.2.7 1998/01/13 23:06:11 keil`
29			`* really disable internal timer`
30			`*`
31			`* Revision 1.6.2.6 1998/01/02 06:49:01 calle`
32			`* Perodic timer of A1 now disabled, no need for linux driver.`
33			`*`
34			`* Revision 1.6.2.5 1997/11/15 18:50:41 keil`
35			`* new common init function`
36			`*`
37			`* Revision 1.6.2.4 1997/10/17 22:13:29 keil`
38			`* update to last hisax version`
39			`*`
40			`* Revision 2.1 1997/07/27 21:47:13 keil`
41			`* new interface structures`
42			`*`
43			`* Revision 2.0 1997/06/26 11:02:48 keil`
44			`* New Layer and card interface`
45			`*`
46			`* Revision 1.6 1997/04/13 19:54:07 keil`
47			`* Change in IRQ check delay for SMP`
48			`*`
49			`* Revision 1.5 1997/04/06 22:54:10 keil`
50			`* Using SKB's`
51			`*`
52			`* Revision 1.4 1997/01/27 15:50:21 keil`
53			`* SMP proof,cosmetics`
54			`*`
55			`* Revision 1.3 1997/01/21 22:14:20 keil`
56			`* cleanups`
57			`*`
58			`* Revision 1.2 1996/10/27 22:07:31 keil`
59			`* cosmetic changes`
60			`*`
61			`* Revision 1.1 1996/10/13 20:04:49 keil`
62			`* Initial revision`
63			`*`
64			`*`
65			`*/`
66			`#define __NO_VERSION__`
67			`#include "hisax.h"`
68			`#include "isac.h"`
69			`#include "hscx.h"`
70			`#include "isdnl1.h"`
71
72			`extern const char *CardType[];`
73			`static const char *avm_revision = "$Revision: 1.1.1.1 $";`
74
75			`#define AVM_A1_STAT_ISAC 0x01`
76			`#define AVM_A1_STAT_HSCX 0x02`
77			`#define AVM_A1_STAT_TIMER 0x04`
78
79			`#define byteout(addr,val) outb(val,addr)`
80			`#define bytein(addr) inb(addr)`
81
82			`static inline u_char`
83			`readreg(unsigned int adr, u_char off)`
84			`{`
85			`return (bytein(adr + off));`
86			`}`
87
88			`static inline void`
89			`writereg(unsigned int adr, u_char off, u_char data)`
90			`{`
91			`byteout(adr + off, data);`
92			`}`
93
94
95			`static inline void`
96			`read_fifo(unsigned int adr, u_char * data, int size)`
97			`{`
98			`insb(adr, data, size);`
99			`}`
100
101			`static void`
102			`write_fifo(unsigned int adr, u_char * data, int size)`
103			`{`
104			`outsb(adr, data, size);`
105			`}`
106
107			`/* Interface functions */`
108
109			`static u_char`
110			`ReadISAC(struct IsdnCardState *cs, u_char offset)`
111			`{`
112			`return (readreg(cs->hw.avm.isac, offset));`
113			`}`
114
115			`static void`
116			`WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)`
117			`{`
118			`writereg(cs->hw.avm.isac, offset, value);`
119			`}`
120
121			`static void`
122			`ReadISACfifo(struct IsdnCardState cs, u_char data, int size)`
123			`{`
124			`read_fifo(cs->hw.avm.isacfifo, data, size);`
125			`}`
126
127			`static void`
128			`WriteISACfifo(struct IsdnCardState cs, u_char data, int size)`
129			`{`
130			`write_fifo(cs->hw.avm.isacfifo, data, size);`
131			`}`
132
133			`static u_char`
134			`ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)`
135			`{`
136			`return (readreg(cs->hw.avm.hscx[hscx], offset));`
137			`}`
138
139			`static void`
140			`WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)`
141			`{`
142			`writereg(cs->hw.avm.hscx[hscx], offset, value);`
143			`}`
144
145			`/*`
146			`* fast interrupt HSCX stuff goes here`
147			`*/`
148
149			`#define READHSCX(cs, nr, reg) readreg(cs->hw.avm.hscx[nr], reg)`
150			`#define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.avm.hscx[nr], reg, data)`
151			`#define READHSCXFIFO(cs, nr, ptr, cnt) read_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)`
152			`#define WRITEHSCXFIFO(cs, nr, ptr, cnt) write_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)`
153
154			`#include "hscx_irq.c"`
155
156			`static void`
157			`avm_a1_interrupt(int intno, void dev_id, struct pt_regs regs)`
158			`{`
159			`struct IsdnCardState *cs = dev_id;`
160			`u_char val, sval, stat = 0;`
161
162			`if (!cs) {`
163			`printk(KERN_WARNING "AVM A1: Spurious interrupt!\n");`
164			`return;`
165			`}`
166			`while (((sval = bytein(cs->hw.avm.cfg_reg)) & 0xf) != 0x7) {`
167			`if (!(sval & AVM_A1_STAT_TIMER)) {`
168			`byteout(cs->hw.avm.cfg_reg, 0x1E);`
169			`sval = bytein(cs->hw.avm.cfg_reg);`
170			`} else if (cs->debug & L1_DEB_INTSTAT)`
171			`debugl1(cs, "avm IntStatus %x", sval);`
172			`if (!(sval & AVM_A1_STAT_HSCX)) {`
173			`val = readreg(cs->hw.avm.hscx[1], HSCX_ISTA);`
174			`if (val) {`
175			`hscx_int_main(cs, val);`
176			`stat \|= 1;`
177			`}`
178			`}`
179			`if (!(sval & AVM_A1_STAT_ISAC)) {`
180			`val = readreg(cs->hw.avm.isac, ISAC_ISTA);`
181			`if (val) {`
182			`isac_interrupt(cs, val);`
183			`stat \|= 2;`
184			`}`
185			`}`
186			`}`
187			`if (stat & 1) {`
188			`writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0xFF);`
189			`writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0xFF);`
190			`writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0x0);`
191			`writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0x0);`
192			`}`
193			`if (stat & 2) {`
194			`writereg(cs->hw.avm.isac, ISAC_MASK, 0xFF);`
195			`writereg(cs->hw.avm.isac, ISAC_MASK, 0x0);`
196			`}`
197			`}`
198
199			`inline static void`
200			`release_ioregs(struct IsdnCardState *cs, int mask)`
201			`{`
202			`release_region(cs->hw.avm.cfg_reg, 8);`
203			`if (mask & 1)`
204			`release_region(cs->hw.avm.isac + 32, 32);`
205			`if (mask & 2)`
206			`release_region(cs->hw.avm.isacfifo, 1);`
207			`if (mask & 4)`
208			`release_region(cs->hw.avm.hscx[0] + 32, 32);`
209			`if (mask & 8)`
210			`release_region(cs->hw.avm.hscxfifo[0], 1);`
211			`if (mask & 0x10)`
212			`release_region(cs->hw.avm.hscx[1] + 32, 32);`
213			`if (mask & 0x20)`
214			`release_region(cs->hw.avm.hscxfifo[1], 1);`
215			`}`
216
217			`static int`
218			`AVM_card_msg(struct IsdnCardState cs, int mt, void arg)`
219			`{`
220			`switch (mt) {`
221			`case CARD_RESET:`
222			`return(0);`
223			`case CARD_RELEASE:`
224			`release_ioregs(cs, 0x3f);`
225			`return(0);`
226			`case CARD_SETIRQ:`
227			`return(request_irq(cs->irq, &avm_a1_interrupt,`
228			`I4L_IRQ_FLAG, "HiSax", cs));`
229			`case CARD_INIT:`
230			`inithscxisac(cs, 1);`
231			`byteout(cs->hw.avm.cfg_reg, 0x16);`
232			`byteout(cs->hw.avm.cfg_reg, 0x1E);`
233			`inithscxisac(cs, 2);`
234			`return(0);`
235			`case CARD_TEST:`
236			`return(0);`
237			`}`
238			`return(0);`
239			`}`
240
241			`__initfunc(int`
242			`setup_avm_a1(struct IsdnCard *card))`
243			`{`
244			`u_char val;`
245			`struct IsdnCardState *cs = card->cs;`
246			`long flags;`
247			`char tmp[64];`
248
249			`strcpy(tmp, avm_revision);`
250			`printk(KERN_INFO "HiSax: AVM driver Rev. %s\n", HiSax_getrev(tmp));`
251			`if (cs->typ != ISDN_CTYPE_A1)`
252			`return (0);`
253
254			`cs->hw.avm.cfg_reg = card->para[1] + 0x1800;`
255			`cs->hw.avm.isac = card->para[1] + 0x1400 - 0x20;`
256			`cs->hw.avm.hscx[0] = card->para[1] + 0x400 - 0x20;`
257			`cs->hw.avm.hscx[1] = card->para[1] + 0xc00 - 0x20;`
258			`cs->hw.avm.isacfifo = card->para[1] + 0x1000;`
259			`cs->hw.avm.hscxfifo[0] = card->para[1];`
260			`cs->hw.avm.hscxfifo[1] = card->para[1] + 0x800;`
261			`cs->irq = card->para[0];`
262			`if (check_region((cs->hw.avm.cfg_reg), 8)) {`
263			`printk(KERN_WARNING`
264			`"HiSax: %s config port %x-%x already in use\n",`
265			`CardType[card->typ],`
266			`cs->hw.avm.cfg_reg,`
267			`cs->hw.avm.cfg_reg + 8);`
268			`return (0);`
269			`} else {`
270			`request_region(cs->hw.avm.cfg_reg, 8, "avm cfg");`
271			`}`
272			`if (check_region((cs->hw.avm.isac + 32), 32)) {`
273			`printk(KERN_WARNING`
274			`"HiSax: %s isac ports %x-%x already in use\n",`
275			`CardType[cs->typ],`
276			`cs->hw.avm.isac + 32,`
277			`cs->hw.avm.isac + 64);`
278			`release_ioregs(cs, 0);`
279			`return (0);`
280			`} else {`
281			`request_region(cs->hw.avm.isac + 32, 32, "HiSax isac");`
282			`}`
283			`if (check_region((cs->hw.avm.isacfifo), 1)) {`
284			`printk(KERN_WARNING`
285			`"HiSax: %s isac fifo port %x already in use\n",`
286			`CardType[cs->typ],`
287			`cs->hw.avm.isacfifo);`
288			`release_ioregs(cs, 1);`
289			`return (0);`
290			`} else {`
291			`request_region(cs->hw.avm.isacfifo, 1, "HiSax isac fifo");`
292			`}`
293			`if (check_region((cs->hw.avm.hscx[0]) + 32, 32)) {`
294			`printk(KERN_WARNING`
295			`"HiSax: %s hscx A ports %x-%x already in use\n",`
296			`CardType[cs->typ],`
297			`cs->hw.avm.hscx[0] + 32,`
298			`cs->hw.avm.hscx[0] + 64);`
299			`release_ioregs(cs, 3);`
300			`return (0);`
301			`} else {`
302			`request_region(cs->hw.avm.hscx[0] + 32, 32, "HiSax hscx A");`
303			`}`
304			`if (check_region(cs->hw.avm.hscxfifo[0], 1)) {`
305			`printk(KERN_WARNING`
306			`"HiSax: %s hscx A fifo port %x already in use\n",`
307			`CardType[cs->typ],`
308			`cs->hw.avm.hscxfifo[0]);`
309			`release_ioregs(cs, 7);`
310			`return (0);`
311			`} else {`
312			`request_region(cs->hw.avm.hscxfifo[0], 1, "HiSax hscx A fifo");`
313			`}`
314			`if (check_region(cs->hw.avm.hscx[1] + 32, 32)) {`
315			`printk(KERN_WARNING`
316			`"HiSax: %s hscx B ports %x-%x already in use\n",`
317			`CardType[cs->typ],`
318			`cs->hw.avm.hscx[1] + 32,`
319			`cs->hw.avm.hscx[1] + 64);`
320			`release_ioregs(cs, 0xf);`
321			`return (0);`
322			`} else {`
323			`request_region(cs->hw.avm.hscx[1] + 32, 32, "HiSax hscx B");`
324			`}`
325			`if (check_region(cs->hw.avm.hscxfifo[1], 1)) {`
326			`printk(KERN_WARNING`
327			`"HiSax: %s hscx B fifo port %x already in use\n",`
328			`CardType[cs->typ],`
329			`cs->hw.avm.hscxfifo[1]);`
330			`release_ioregs(cs, 0x1f);`
331			`return (0);`
332			`} else {`
333			`request_region(cs->hw.avm.hscxfifo[1], 1, "HiSax hscx B fifo");`
334			`}`
335			`save_flags(flags);`
336			`byteout(cs->hw.avm.cfg_reg, 0x0);`
337			`sti();`
338			`HZDELAY(HZ / 5 + 1);`
339			`byteout(cs->hw.avm.cfg_reg, 0x1);`
340			`HZDELAY(HZ / 5 + 1);`
341			`byteout(cs->hw.avm.cfg_reg, 0x0);`
342			`HZDELAY(HZ / 5 + 1);`
343			`val = cs->irq;`
344			`if (val == 9)`
345			`val = 2;`
346			`byteout(cs->hw.avm.cfg_reg + 1, val);`
347			`HZDELAY(HZ / 5 + 1);`
348			`byteout(cs->hw.avm.cfg_reg, 0x0);`
349			`HZDELAY(HZ / 5 + 1);`
350			`restore_flags(flags);`
351
352			`val = bytein(cs->hw.avm.cfg_reg);`
353			`printk(KERN_INFO "AVM A1: Byte at %x is %x\n",`
354			`cs->hw.avm.cfg_reg, val);`
355			`val = bytein(cs->hw.avm.cfg_reg + 3);`
356			`printk(KERN_INFO "AVM A1: Byte at %x is %x\n",`
357			`cs->hw.avm.cfg_reg + 3, val);`
358			`val = bytein(cs->hw.avm.cfg_reg + 2);`
359			`printk(KERN_INFO "AVM A1: Byte at %x is %x\n",`
360			`cs->hw.avm.cfg_reg + 2, val);`
361			`val = bytein(cs->hw.avm.cfg_reg);`
362			`printk(KERN_INFO "AVM A1: Byte at %x is %x\n",`
363			`cs->hw.avm.cfg_reg, val);`
364
365			`printk(KERN_INFO`
366			`"HiSax: %s config irq:%d cfg:0x%X\n",`
367			`CardType[cs->typ], cs->irq,`
368			`cs->hw.avm.cfg_reg);`
369			`printk(KERN_INFO`
370			`"HiSax: isac:0x%X/0x%X\n",`
371			`cs->hw.avm.isac + 32, cs->hw.avm.isacfifo);`
372			`printk(KERN_INFO`
373			`"HiSax: hscx A:0x%X/0x%X hscx B:0x%X/0x%X\n",`
374			`cs->hw.avm.hscx[0] + 32, cs->hw.avm.hscxfifo[0],`
375			`cs->hw.avm.hscx[1] + 32, cs->hw.avm.hscxfifo[1]);`
376
377			`cs->readisac = &ReadISAC;`
378			`cs->writeisac = &WriteISAC;`
379			`cs->readisacfifo = &ReadISACfifo;`
380			`cs->writeisacfifo = &WriteISACfifo;`
381			`cs->BC_Read_Reg = &ReadHSCX;`
382			`cs->BC_Write_Reg = &WriteHSCX;`
383			`cs->BC_Send_Data = &hscx_fill_fifo;`
384			`cs->cardmsg = &AVM_card_msg;`
385			`ISACVersion(cs, "AVM A1:");`
386			`if (HscxVersion(cs, "AVM A1:")) {`
387			`printk(KERN_WARNING`
388			`"AVM A1: wrong HSCX versions check IO address\n");`
389			`release_ioregs(cs, 0x3f);`
390			`return (0);`
391			`}`
392			`return (1);`
393			`}`