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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [isdn/] [avmb1/] [avmcard.h] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* $Id: avmcard.h,v 1.1.1.1 2004-04-15 02:04:07 phoenix Exp $
 *
 * Copyright 1999 by Carsten Paeth <calle@calle.de>
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */
 
#ifndef _AVMCARD_H_
#define _AVMCARD_H_
 
#define AVMB1_PORTLEN           0x1f
#define AVM_MAXVERSION          8
#define AVM_NCCI_PER_CHANNEL    4
 
/*
 * Versions
 */
 
#define VER_DRIVER      0
#define VER_CARDTYPE    1
#define VER_HWID        2
#define VER_SERIAL      3
#define VER_OPTION      4
#define VER_PROTO       5
#define VER_PROFILE     6
#define VER_CAPI        7
 
enum avmcardtype {
        avm_b1isa,
        avm_b1pci,
        avm_b1pcmcia,
        avm_m1,
        avm_m2,
        avm_t1isa,
        avm_t1pci,
        avm_c4,
        avm_c2
};
 
typedef struct avmcard_dmainfo {
        __u32 recvlen;
        __u8  recvbuf[128+2048];
        struct sk_buff_head send_queue;
        __u8  sendbuf[128+2048];
} avmcard_dmainfo;
 
 
typedef struct avmcard {
        char name[32];
        unsigned int port;
        unsigned irq;
        unsigned long membase;
        enum avmcardtype cardtype;
        unsigned char revision;
        unsigned char class;
        int cardnr; /* for t1isa */
 
        char msgbuf[128];       /* capimsg msg part */
        char databuf[2048];     /* capimsg data part */
 
        int interrupt;
 
        void *mbase;
        volatile __u32 csr;
        avmcard_dmainfo *dma;
 
        struct avmctrl_info {
                char cardname[32];
 
                int versionlen;
                char versionbuf[1024];
                char *version[AVM_MAXVERSION];
 
                char infobuf[128];      /* for function procinfo */
 
                struct avmcard  *card;
                struct capi_ctr *capi_ctrl;
 
        } *ctrlinfo;
 
        int nlogcontr;
} avmcard;
 
typedef struct avmctrl_info avmctrl_info;
 
extern int b1_irq_table[16];
 
/*
 * LLI Messages to the ISDN-ControllerISDN Controller
 */
 
#define SEND_POLL               0x72    /*
                                           * after load <- RECEIVE_POLL
                                         */
#define SEND_INIT               0x11    /*
                                           * first message <- RECEIVE_INIT
                                           * int32 NumApplications  int32
                                           * NumNCCIs int32 BoardNumber
                                         */
#define SEND_REGISTER           0x12    /*
                                           * register an application int32
                                           * ApplIDId int32 NumMessages
                                           * int32 NumB3Connections int32
                                           * NumB3Blocks int32 B3Size
                                           *
                                           * AnzB3Connection != 0 &&
                                           * AnzB3Blocks >= 1 && B3Size >= 1
                                         */
#define SEND_RELEASE            0x14    /*
                                           * deregister an application int32
                                           * ApplID
                                         */
#define SEND_MESSAGE            0x15    /*
                                           * send capi-message int32 length
                                           * capi-data ...
                                         */
#define SEND_DATA_B3_REQ        0x13    /*
                                           * send capi-data-message int32
                                           * MsgLength capi-data ... int32
                                           * B3Length data ....
                                         */
 
#define SEND_CONFIG             0x21    /*
                                         */
 
#define SEND_POLLACK            0x73    /* T1 Watchdog */
 
/*
 * LLI Messages from the ISDN-ControllerISDN Controller
 */
 
#define RECEIVE_POLL            0x32    /*
                                           * <- after SEND_POLL
                                         */
#define RECEIVE_INIT            0x27    /*
                                           * <- after SEND_INIT int32 length
                                           * byte total length b1struct board
                                           * driver revision b1struct card
                                           * type b1struct reserved b1struct
                                           * serial number b1struct driver
                                           * capability b1struct d-channel
                                           * protocol b1struct CAPI-2.0
                                           * profile b1struct capi version
                                         */
#define RECEIVE_MESSAGE         0x21    /*
                                           * <- after SEND_MESSAGE int32
                                           * AppllID int32 Length capi-data
                                           * ....
                                         */
#define RECEIVE_DATA_B3_IND     0x22    /*
                                           * received data int32 AppllID
                                           * int32 Length capi-data ...
                                           * int32 B3Length data ...
                                         */
#define RECEIVE_START           0x23    /*
                                           * Handshake
                                         */
#define RECEIVE_STOP            0x24    /*
                                           * Handshake
                                         */
#define RECEIVE_NEW_NCCI        0x25    /*
                                           * int32 AppllID int32 NCCI int32
                                           * WindowSize
                                         */
#define RECEIVE_FREE_NCCI       0x26    /*
                                           * int32 AppllID int32 NCCI
                                         */
#define RECEIVE_RELEASE         0x26    /*
                                           * int32 AppllID int32 0xffffffff
                                         */
#define RECEIVE_TASK_READY      0x31    /*
                                           * int32 tasknr
                                           * int32 Length Taskname ...
                                         */
#define RECEIVE_DEBUGMSG        0x71    /*
                                           * int32 Length message
                                           *
                                         */
#define RECEIVE_POLLDWORD       0x75    /* t1pci in dword mode */
 
#define WRITE_REGISTER          0x00
#define READ_REGISTER           0x01
 
/*
 * port offsets
 */
 
#define B1_READ                 0x00
#define B1_WRITE                0x01
#define B1_INSTAT               0x02
#define B1_OUTSTAT              0x03
#define B1_ANALYSE              0x04
#define B1_REVISION             0x05
#define B1_RESET                0x10
 
 
#define B1_STAT0(cardtype)  ((cardtype) == avm_m1 ? 0x81200000l : 0x80A00000l)
#define B1_STAT1(cardtype)  (0x80E00000l)
 
/* ---------------------------------------------------------------- */
 
static inline unsigned char b1outp(unsigned int base,
                                   unsigned short offset,
                                   unsigned char value)
{
        outb(value, base + offset);
        return inb(base + B1_ANALYSE);
}
 
 
static inline int b1_rx_full(unsigned int base)
{
        return inb(base + B1_INSTAT) & 0x1;
}
 
static inline unsigned char b1_get_byte(unsigned int base)
{
        unsigned long stop = jiffies + 1 * HZ;  /* maximum wait time 1 sec */
        while (!b1_rx_full(base) && time_before(jiffies, stop));
        if (b1_rx_full(base))
                return inb(base + B1_READ);
        printk(KERN_CRIT "b1lli(0x%x): rx not full after 1 second\n", base);
        return 0;
}
 
static inline unsigned int b1_get_word(unsigned int base)
{
        unsigned int val = 0;
        val |= b1_get_byte(base);
        val |= (b1_get_byte(base) << 8);
        val |= (b1_get_byte(base) << 16);
        val |= (b1_get_byte(base) << 24);
        return val;
}
 
static inline int b1_tx_empty(unsigned int base)
{
        return inb(base + B1_OUTSTAT) & 0x1;
}
 
static inline void b1_put_byte(unsigned int base, unsigned char val)
{
        while (!b1_tx_empty(base));
        b1outp(base, B1_WRITE, val);
}
 
static inline int b1_save_put_byte(unsigned int base, unsigned char val)
{
        unsigned long stop = jiffies + 2 * HZ;
        while (!b1_tx_empty(base) && time_before(jiffies,stop));
        if (!b1_tx_empty(base)) return -1;
        b1outp(base, B1_WRITE, val);
        return 0;
}
 
static inline void b1_put_word(unsigned int base, unsigned int val)
{
        b1_put_byte(base, val & 0xff);
        b1_put_byte(base, (val >> 8) & 0xff);
        b1_put_byte(base, (val >> 16) & 0xff);
        b1_put_byte(base, (val >> 24) & 0xff);
}
 
static inline unsigned int b1_get_slice(unsigned int base,
                                        unsigned char *dp)
{
        unsigned int len, i;
 
        len = i = b1_get_word(base);
        while (i-- > 0) *dp++ = b1_get_byte(base);
        return len;
}
 
static inline void b1_put_slice(unsigned int base,
                                unsigned char *dp, unsigned int len)
{
        unsigned i = len;
        b1_put_word(base, i);
        while (i-- > 0)
                b1_put_byte(base, *dp++);
}
 
static void b1_wr_reg(unsigned int base,
                      unsigned int reg,
                      unsigned int value)
{
        b1_put_byte(base, WRITE_REGISTER);
        b1_put_word(base, reg);
        b1_put_word(base, value);
}
 
static inline unsigned int b1_rd_reg(unsigned int base,
                                     unsigned int reg)
{
        b1_put_byte(base, READ_REGISTER);
        b1_put_word(base, reg);
        return b1_get_word(base);
 
}
 
static inline void b1_reset(unsigned int base)
{
        b1outp(base, B1_RESET, 0);
        mdelay(55 * 2); /* 2 TIC's */
 
        b1outp(base, B1_RESET, 1);
        mdelay(55 * 2); /* 2 TIC's */
 
        b1outp(base, B1_RESET, 0);
        mdelay(55 * 2); /* 2 TIC's */
}
 
static inline unsigned char b1_disable_irq(unsigned int base)
{
        return b1outp(base, B1_INSTAT, 0x00);
}
 
/* ---------------------------------------------------------------- */
 
static inline void b1_set_test_bit(unsigned int base,
                                   enum avmcardtype cardtype,
                                   int onoff)
{
    b1_wr_reg(base, B1_STAT0(cardtype), onoff ? 0x21 : 0x20);
}
 
static inline int b1_get_test_bit(unsigned int base,
                                  enum avmcardtype cardtype)
{
    return (b1_rd_reg(base, B1_STAT0(cardtype)) & 0x01) != 0;
}
 
/* ---------------------------------------------------------------- */
 
#define T1_FASTLINK             0x00
#define T1_SLOWLINK             0x08
 
#define T1_READ                 B1_READ
#define T1_WRITE                B1_WRITE
#define T1_INSTAT               B1_INSTAT
#define T1_OUTSTAT              B1_OUTSTAT
#define T1_IRQENABLE            0x05
#define T1_FIFOSTAT             0x06
#define T1_RESETLINK            0x10
#define T1_ANALYSE              0x11
#define T1_IRQMASTER            0x12
#define T1_IDENT                0x17
#define T1_RESETBOARD           0x1f
 
#define T1F_IREADY              0x01
#define T1F_IHALF               0x02
#define T1F_IFULL               0x04
#define T1F_IEMPTY              0x08
#define T1F_IFLAGS              0xF0
 
#define T1F_OREADY              0x10
#define T1F_OHALF               0x20
#define T1F_OEMPTY              0x40
#define T1F_OFULL               0x80
#define T1F_OFLAGS              0xF0
 
/* there are HEMA cards with 1k and 4k FIFO out */
#define FIFO_OUTBSIZE           256
#define FIFO_INPBSIZE           512
 
#define HEMA_VERSION_ID         0
#define HEMA_PAL_ID             0
 
static inline void t1outp(unsigned int base,
                          unsigned short offset,
                          unsigned char value)
{
        outb(value, base + offset);
}
 
static inline unsigned char t1inp(unsigned int base,
                                  unsigned short offset)
{
        return inb(base + offset);
}
 
static inline int t1_isfastlink(unsigned int base)
{
        return (inb(base + T1_IDENT) & ~0x82) == 1;
}
 
static inline unsigned char t1_fifostatus(unsigned int base)
{
        return inb(base + T1_FIFOSTAT);
}
 
static inline unsigned int t1_get_slice(unsigned int base,
                                        unsigned char *dp)
{
        unsigned int len, i;
#ifdef FASTLINK_DEBUG
        unsigned wcnt = 0, bcnt = 0;
#endif
 
        len = i = b1_get_word(base);
        if (t1_isfastlink(base)) {
                int status;
                while (i > 0) {
                        status = t1_fifostatus(base) & (T1F_IREADY|T1F_IHALF);
                        if (i >= FIFO_INPBSIZE) status |= T1F_IFULL;
 
                        switch (status) {
                                case T1F_IREADY|T1F_IHALF|T1F_IFULL:
                                        insb(base+B1_READ, dp, FIFO_INPBSIZE);
                                        dp += FIFO_INPBSIZE;
                                        i -= FIFO_INPBSIZE;
#ifdef FASTLINK_DEBUG
                                        wcnt += FIFO_INPBSIZE;
#endif
                                        break;
                                case T1F_IREADY|T1F_IHALF:
                                        insb(base+B1_READ,dp, i);
#ifdef FASTLINK_DEBUG
                                        wcnt += i;
#endif
                                        dp += i;
                                        i = 0;
                                        if (i == 0)
                                                break;
                                        /* fall through */
                                default:
                                        *dp++ = b1_get_byte(base);
                                        i--;
#ifdef FASTLINK_DEBUG
                                        bcnt++;
#endif
                                        break;
                        }
            }
#ifdef FASTLINK_DEBUG
            if (wcnt)
            printk(KERN_DEBUG "b1lli(0x%x): get_slice l=%d w=%d b=%d\n",
                                base, len, wcnt, bcnt);
#endif
        } else {
                while (i-- > 0)
                        *dp++ = b1_get_byte(base);
        }
        return len;
}
 
static inline void t1_put_slice(unsigned int base,
                                unsigned char *dp, unsigned int len)
{
        unsigned i = len;
        b1_put_word(base, i);
        if (t1_isfastlink(base)) {
                int status;
                while (i > 0) {
                        status = t1_fifostatus(base) & (T1F_OREADY|T1F_OHALF);
                        if (i >= FIFO_OUTBSIZE) status |= T1F_OEMPTY;
                        switch (status) {
                                case T1F_OREADY|T1F_OHALF|T1F_OEMPTY:
                                        outsb(base+B1_WRITE, dp, FIFO_OUTBSIZE);
                                        dp += FIFO_OUTBSIZE;
                                        i -= FIFO_OUTBSIZE;
                                        break;
                                case T1F_OREADY|T1F_OHALF:
                                        outsb(base+B1_WRITE, dp, i);
                                        dp += i;
                                        i = 0;
                                        break;
                                default:
                                        b1_put_byte(base, *dp++);
                                        i--;
                                        break;
                        }
                }
        } else {
                while (i-- > 0)
                        b1_put_byte(base, *dp++);
        }
}
 
static inline void t1_disable_irq(unsigned int base)
{
      t1outp(base, T1_IRQMASTER, 0x00);
}
 
static inline void t1_reset(unsigned int base)
{
        /* reset T1 Controller */
        b1_reset(base);
        /* disable irq on HEMA */
        t1outp(base, B1_INSTAT, 0x00);
        t1outp(base, B1_OUTSTAT, 0x00);
        t1outp(base, T1_IRQMASTER, 0x00);
        /* reset HEMA board configuration */
        t1outp(base, T1_RESETBOARD, 0xf);
}
 
static inline void b1_setinterrupt(unsigned int base, unsigned irq,
                                   enum avmcardtype cardtype)
{
        switch (cardtype) {
           case avm_t1isa:
              t1outp(base, B1_INSTAT, 0x00);
              t1outp(base, B1_INSTAT, 0x02);
              t1outp(base, T1_IRQMASTER, 0x08);
              break;
           case avm_b1isa:
              b1outp(base, B1_INSTAT, 0x00);
              b1outp(base, B1_RESET, b1_irq_table[irq]);
              b1outp(base, B1_INSTAT, 0x02);
              break;
           default:
           case avm_m1:
           case avm_m2:
           case avm_b1pci:
              b1outp(base, B1_INSTAT, 0x00);
              b1outp(base, B1_RESET, 0xf0);
              b1outp(base, B1_INSTAT, 0x02);
              break;
           case avm_c4:
           case avm_t1pci:
              b1outp(base, B1_RESET, 0xf0);
              break;
         }
}
 
/* b1.c */
int b1_detect(unsigned int base, enum avmcardtype cardtype);
void b1_getrevision(avmcard *card);
int b1_load_t4file(avmcard *card, capiloaddatapart * t4file);
int b1_load_config(avmcard *card, capiloaddatapart * config);
int b1_loaded(avmcard *card);
 
int b1_load_firmware(struct capi_ctr *ctrl, capiloaddata *data);
void b1_reset_ctr(struct capi_ctr *ctrl);
void b1_register_appl(struct capi_ctr *ctrl, __u16 appl,
                                capi_register_params *rp);
void b1_release_appl(struct capi_ctr *ctrl, __u16 appl);
void b1_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
void b1_parse_version(avmctrl_info *card);
void b1_handle_interrupt(avmcard * card);
 
int b1ctl_read_proc(char *page, char **start, off_t off,
                        int count, int *eof, struct capi_ctr *ctrl);
 
/* b1dma.c */
int b1pciv4_detect(avmcard *card);
int t1pci_detect(avmcard *card);
void b1dma_reset(avmcard *card);
void b1dma_interrupt(int interrupt, void *devptr, struct pt_regs *regs);
 
int b1dma_load_firmware(struct capi_ctr *ctrl, capiloaddata *data);
void b1dma_reset_ctr(struct capi_ctr *ctrl);
void b1dma_remove_ctr(struct capi_ctr *ctrl);
void b1dma_register_appl(struct capi_ctr *ctrl,
                                __u16 appl,
                                capi_register_params *rp);
void b1dma_release_appl(struct capi_ctr *ctrl, __u16 appl);
void b1dma_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
int b1dmactl_read_proc(char *page, char **start, off_t off,
                        int count, int *eof, struct capi_ctr *ctrl);
 
#endif /* _AVMCARD_H_ */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [isdn/] [avmb1/] [avmcard.h] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/* $Id: avmcard.h,v 1.1.1.1 2004-04-15 02:04:07 phoenix Exp $`
2			`*`
3			`* Copyright 1999 by Carsten Paeth <calle@calle.de>`
4			`*`
5			`* This software may be used and distributed according to the terms`
6			`* of the GNU General Public License, incorporated herein by reference.`
7			`*`
8			`*/`
9
10			`#ifndef _AVMCARD_H_`
11			`#define _AVMCARD_H_`
12
13			`#define AVMB1_PORTLEN 0x1f`
14			`#define AVM_MAXVERSION 8`
15			`#define AVM_NCCI_PER_CHANNEL 4`
16
17			`/*`
18			`* Versions`
19			`*/`
20
21			`#define VER_DRIVER 0`
22			`#define VER_CARDTYPE 1`
23			`#define VER_HWID 2`
24			`#define VER_SERIAL 3`
25			`#define VER_OPTION 4`
26			`#define VER_PROTO 5`
27			`#define VER_PROFILE 6`
28			`#define VER_CAPI 7`
29
30			`enum avmcardtype {`
31			`avm_b1isa,`
32			`avm_b1pci,`
33			`avm_b1pcmcia,`
34			`avm_m1,`
35			`avm_m2,`
36			`avm_t1isa,`
37			`avm_t1pci,`
38			`avm_c4,`
39			`avm_c2`
40			`};`
41
42			`typedef struct avmcard_dmainfo {`
43			`__u32 recvlen;`
44			`__u8 recvbuf[128+2048];`
45			`struct sk_buff_head send_queue;`
46			`__u8 sendbuf[128+2048];`
47			`} avmcard_dmainfo;`
48
49
50			`typedef struct avmcard {`
51			`char name[32];`
52			`unsigned int port;`
53			`unsigned irq;`
54			`unsigned long membase;`
55			`enum avmcardtype cardtype;`
56			`unsigned char revision;`
57			`unsigned char class;`
58			`int cardnr; /* for t1isa */`
59
60			`char msgbuf[128]; /* capimsg msg part */`
61			`char databuf[2048]; /* capimsg data part */`
62
63			`int interrupt;`
64
65			`void *mbase;`
66			`volatile __u32 csr;`
67			`avmcard_dmainfo *dma;`
68
69			`struct avmctrl_info {`
70			`char cardname[32];`
71
72			`int versionlen;`
73			`char versionbuf[1024];`
74			`char *version[AVM_MAXVERSION];`
75
76			`char infobuf[128]; /* for function procinfo */`
77
78			`struct avmcard *card;`
79			`struct capi_ctr *capi_ctrl;`
80
81			`} *ctrlinfo;`
82
83			`int nlogcontr;`
84			`} avmcard;`
85
86			`typedef struct avmctrl_info avmctrl_info;`
87
88			`extern int b1_irq_table[16];`
89
90			`/*`
91			`* LLI Messages to the ISDN-ControllerISDN Controller`
92			`*/`
93
94			`#define SEND_POLL 0x72 /*`
95			`* after load <- RECEIVE_POLL`
96			`*/`
97			`#define SEND_INIT 0x11 /*`
98			`* first message <- RECEIVE_INIT`
99			`* int32 NumApplications int32`
100			`* NumNCCIs int32 BoardNumber`
101			`*/`
102			`#define SEND_REGISTER 0x12 /*`
103			`* register an application int32`
104			`* ApplIDId int32 NumMessages`
105			`* int32 NumB3Connections int32`
106			`* NumB3Blocks int32 B3Size`
107			`*`
108			`* AnzB3Connection != 0 &&`
109			`* AnzB3Blocks >= 1 && B3Size >= 1`
110			`*/`
111			`#define SEND_RELEASE 0x14 /*`
112			`* deregister an application int32`
113			`* ApplID`
114			`*/`
115			`#define SEND_MESSAGE 0x15 /*`
116			`* send capi-message int32 length`
117			`* capi-data ...`
118			`*/`
119			`#define SEND_DATA_B3_REQ 0x13 /*`
120			`* send capi-data-message int32`
121			`* MsgLength capi-data ... int32`
122			`* B3Length data ....`
123			`*/`
124
125			`#define SEND_CONFIG 0x21 /*`
126			`*/`
127
128			`#define SEND_POLLACK 0x73 /* T1 Watchdog */`
129
130			`/*`
131			`* LLI Messages from the ISDN-ControllerISDN Controller`
132			`*/`
133
134			`#define RECEIVE_POLL 0x32 /*`
135			`* <- after SEND_POLL`
136			`*/`
137			`#define RECEIVE_INIT 0x27 /*`
138			`* <- after SEND_INIT int32 length`
139			`* byte total length b1struct board`
140			`* driver revision b1struct card`
141			`* type b1struct reserved b1struct`
142			`* serial number b1struct driver`
143			`* capability b1struct d-channel`
144			`* protocol b1struct CAPI-2.0`
145			`* profile b1struct capi version`
146			`*/`
147			`#define RECEIVE_MESSAGE 0x21 /*`
148			`* <- after SEND_MESSAGE int32`
149			`* AppllID int32 Length capi-data`
150			`* ....`
151			`*/`
152			`#define RECEIVE_DATA_B3_IND 0x22 /*`
153			`* received data int32 AppllID`
154			`* int32 Length capi-data ...`
155			`* int32 B3Length data ...`
156			`*/`
157			`#define RECEIVE_START 0x23 /*`
158			`* Handshake`
159			`*/`
160			`#define RECEIVE_STOP 0x24 /*`
161			`* Handshake`
162			`*/`
163			`#define RECEIVE_NEW_NCCI 0x25 /*`
164			`* int32 AppllID int32 NCCI int32`
165			`* WindowSize`
166			`*/`
167			`#define RECEIVE_FREE_NCCI 0x26 /*`
168			`* int32 AppllID int32 NCCI`
169			`*/`
170			`#define RECEIVE_RELEASE 0x26 /*`
171			`* int32 AppllID int32 0xffffffff`
172			`*/`
173			`#define RECEIVE_TASK_READY 0x31 /*`
174			`* int32 tasknr`
175			`* int32 Length Taskname ...`
176			`*/`
177			`#define RECEIVE_DEBUGMSG 0x71 /*`
178			`* int32 Length message`
179			`*`
180			`*/`
181			`#define RECEIVE_POLLDWORD 0x75 /* t1pci in dword mode */`
182
183			`#define WRITE_REGISTER 0x00`
184			`#define READ_REGISTER 0x01`
185
186			`/*`
187			`* port offsets`
188			`*/`
189
190			`#define B1_READ 0x00`
191			`#define B1_WRITE 0x01`
192			`#define B1_INSTAT 0x02`
193			`#define B1_OUTSTAT 0x03`
194			`#define B1_ANALYSE 0x04`
195			`#define B1_REVISION 0x05`
196			`#define B1_RESET 0x10`
197
198
199			`#define B1_STAT0(cardtype) ((cardtype) == avm_m1 ? 0x81200000l : 0x80A00000l)`
200			`#define B1_STAT1(cardtype) (0x80E00000l)`
201
202			`/* ---------------------------------------------------------------- */`
203
204			`static inline unsigned char b1outp(unsigned int base,`
205			`unsigned short offset,`
206			`unsigned char value)`
207			`{`
208			`outb(value, base + offset);`
209			`return inb(base + B1_ANALYSE);`
210			`}`
211
212
213			`static inline int b1_rx_full(unsigned int base)`
214			`{`
215			`return inb(base + B1_INSTAT) & 0x1;`
216			`}`
217
218			`static inline unsigned char b1_get_byte(unsigned int base)`
219			`{`
220			`unsigned long stop = jiffies + 1 * HZ; /* maximum wait time 1 sec */`
221			`while (!b1_rx_full(base) && time_before(jiffies, stop));`
222			`if (b1_rx_full(base))`
223			`return inb(base + B1_READ);`
224			`printk(KERN_CRIT "b1lli(0x%x): rx not full after 1 second\n", base);`
225			`return 0;`
226			`}`
227
228			`static inline unsigned int b1_get_word(unsigned int base)`
229			`{`
230			`unsigned int val = 0;`
231			`val \|= b1_get_byte(base);`
232			`val \|= (b1_get_byte(base) << 8);`
233			`val \|= (b1_get_byte(base) << 16);`
234			`val \|= (b1_get_byte(base) << 24);`
235			`return val;`
236			`}`
237
238			`static inline int b1_tx_empty(unsigned int base)`
239			`{`
240			`return inb(base + B1_OUTSTAT) & 0x1;`
241			`}`
242
243			`static inline void b1_put_byte(unsigned int base, unsigned char val)`
244			`{`
245			`while (!b1_tx_empty(base));`
246			`b1outp(base, B1_WRITE, val);`
247			`}`
248
249			`static inline int b1_save_put_byte(unsigned int base, unsigned char val)`
250			`{`
251			`unsigned long stop = jiffies + 2 * HZ;`
252			`while (!b1_tx_empty(base) && time_before(jiffies,stop));`
253			`if (!b1_tx_empty(base)) return -1;`
254			`b1outp(base, B1_WRITE, val);`
255			`return 0;`
256			`}`
257
258			`static inline void b1_put_word(unsigned int base, unsigned int val)`
259			`{`
260			`b1_put_byte(base, val & 0xff);`
261			`b1_put_byte(base, (val >> 8) & 0xff);`
262			`b1_put_byte(base, (val >> 16) & 0xff);`
263			`b1_put_byte(base, (val >> 24) & 0xff);`
264			`}`
265
266			`static inline unsigned int b1_get_slice(unsigned int base,`
267			`unsigned char *dp)`
268			`{`
269			`unsigned int len, i;`
270
271			`len = i = b1_get_word(base);`
272			`while (i-- > 0) *dp++ = b1_get_byte(base);`
273			`return len;`
274			`}`
275
276			`static inline void b1_put_slice(unsigned int base,`
277			`unsigned char *dp, unsigned int len)`
278			`{`
279			`unsigned i = len;`
280			`b1_put_word(base, i);`
281			`while (i-- > 0)`
282			`b1_put_byte(base, *dp++);`
283			`}`
284
285			`static void b1_wr_reg(unsigned int base,`
286			`unsigned int reg,`
287			`unsigned int value)`
288			`{`
289			`b1_put_byte(base, WRITE_REGISTER);`
290			`b1_put_word(base, reg);`
291			`b1_put_word(base, value);`
292			`}`
293
294			`static inline unsigned int b1_rd_reg(unsigned int base,`
295			`unsigned int reg)`
296			`{`
297			`b1_put_byte(base, READ_REGISTER);`
298			`b1_put_word(base, reg);`
299			`return b1_get_word(base);`
300
301			`}`
302
303			`static inline void b1_reset(unsigned int base)`
304			`{`
305			`b1outp(base, B1_RESET, 0);`
306			`mdelay(55 * 2); /* 2 TIC's */`
307
308			`b1outp(base, B1_RESET, 1);`
309			`mdelay(55 * 2); /* 2 TIC's */`
310
311			`b1outp(base, B1_RESET, 0);`
312			`mdelay(55 * 2); /* 2 TIC's */`
313			`}`
314
315			`static inline unsigned char b1_disable_irq(unsigned int base)`
316			`{`
317			`return b1outp(base, B1_INSTAT, 0x00);`
318			`}`
319
320			`/* ---------------------------------------------------------------- */`
321
322			`static inline void b1_set_test_bit(unsigned int base,`
323			`enum avmcardtype cardtype,`
324			`int onoff)`
325			`{`
326			`b1_wr_reg(base, B1_STAT0(cardtype), onoff ? 0x21 : 0x20);`
327			`}`
328
329			`static inline int b1_get_test_bit(unsigned int base,`
330			`enum avmcardtype cardtype)`
331			`{`
332			`return (b1_rd_reg(base, B1_STAT0(cardtype)) & 0x01) != 0;`
333			`}`
334
335			`/* ---------------------------------------------------------------- */`
336
337			`#define T1_FASTLINK 0x00`
338			`#define T1_SLOWLINK 0x08`
339
340			`#define T1_READ B1_READ`
341			`#define T1_WRITE B1_WRITE`
342			`#define T1_INSTAT B1_INSTAT`
343			`#define T1_OUTSTAT B1_OUTSTAT`
344			`#define T1_IRQENABLE 0x05`
345			`#define T1_FIFOSTAT 0x06`
346			`#define T1_RESETLINK 0x10`
347			`#define T1_ANALYSE 0x11`
348			`#define T1_IRQMASTER 0x12`
349			`#define T1_IDENT 0x17`
350			`#define T1_RESETBOARD 0x1f`
351
352			`#define T1F_IREADY 0x01`
353			`#define T1F_IHALF 0x02`
354			`#define T1F_IFULL 0x04`
355			`#define T1F_IEMPTY 0x08`
356			`#define T1F_IFLAGS 0xF0`
357
358			`#define T1F_OREADY 0x10`
359			`#define T1F_OHALF 0x20`
360			`#define T1F_OEMPTY 0x40`
361			`#define T1F_OFULL 0x80`
362			`#define T1F_OFLAGS 0xF0`
363
364			`/* there are HEMA cards with 1k and 4k FIFO out */`
365			`#define FIFO_OUTBSIZE 256`
366			`#define FIFO_INPBSIZE 512`
367
368			`#define HEMA_VERSION_ID 0`
369			`#define HEMA_PAL_ID 0`
370
371			`static inline void t1outp(unsigned int base,`
372			`unsigned short offset,`
373			`unsigned char value)`
374			`{`
375			`outb(value, base + offset);`
376			`}`
377
378			`static inline unsigned char t1inp(unsigned int base,`
379			`unsigned short offset)`
380			`{`
381			`return inb(base + offset);`
382			`}`
383
384			`static inline int t1_isfastlink(unsigned int base)`
385			`{`
386			`return (inb(base + T1_IDENT) & ~0x82) == 1;`
387			`}`
388
389			`static inline unsigned char t1_fifostatus(unsigned int base)`
390			`{`
391			`return inb(base + T1_FIFOSTAT);`
392			`}`
393
394			`static inline unsigned int t1_get_slice(unsigned int base,`
395			`unsigned char *dp)`
396			`{`
397			`unsigned int len, i;`
398			`#ifdef FASTLINK_DEBUG`
399			`unsigned wcnt = 0, bcnt = 0;`
400			`#endif`
401
402			`len = i = b1_get_word(base);`
403			`if (t1_isfastlink(base)) {`
404			`int status;`
405			`while (i > 0) {`
406			`status = t1_fifostatus(base) & (T1F_IREADY\|T1F_IHALF);`
407			`if (i >= FIFO_INPBSIZE) status \|= T1F_IFULL;`
408
409			`switch (status) {`
410			`case T1F_IREADY\|T1F_IHALF\|T1F_IFULL:`
411			`insb(base+B1_READ, dp, FIFO_INPBSIZE);`
412			`dp += FIFO_INPBSIZE;`
413			`i -= FIFO_INPBSIZE;`
414			`#ifdef FASTLINK_DEBUG`
415			`wcnt += FIFO_INPBSIZE;`
416			`#endif`
417			`break;`
418			`case T1F_IREADY\|T1F_IHALF:`
419			`insb(base+B1_READ,dp, i);`
420			`#ifdef FASTLINK_DEBUG`
421			`wcnt += i;`
422			`#endif`
423			`dp += i;`
424			`i = 0;`
425			`if (i == 0)`
426			`break;`
427			`/* fall through */`
428			`default:`
429			`*dp++ = b1_get_byte(base);`
430			`i--;`
431			`#ifdef FASTLINK_DEBUG`
432			`bcnt++;`
433			`#endif`
434			`break;`
435			`}`
436			`}`
437			`#ifdef FASTLINK_DEBUG`
438			`if (wcnt)`
439			`printk(KERN_DEBUG "b1lli(0x%x): get_slice l=%d w=%d b=%d\n",`
440			`base, len, wcnt, bcnt);`
441			`#endif`
442			`} else {`
443			`while (i-- > 0)`
444			`*dp++ = b1_get_byte(base);`
445			`}`
446			`return len;`
447			`}`
448
449			`static inline void t1_put_slice(unsigned int base,`
450			`unsigned char *dp, unsigned int len)`
451			`{`
452			`unsigned i = len;`
453			`b1_put_word(base, i);`
454			`if (t1_isfastlink(base)) {`
455			`int status;`
456			`while (i > 0) {`
457			`status = t1_fifostatus(base) & (T1F_OREADY\|T1F_OHALF);`
458			`if (i >= FIFO_OUTBSIZE) status \|= T1F_OEMPTY;`
459			`switch (status) {`
460			`case T1F_OREADY\|T1F_OHALF\|T1F_OEMPTY:`
461			`outsb(base+B1_WRITE, dp, FIFO_OUTBSIZE);`
462			`dp += FIFO_OUTBSIZE;`
463			`i -= FIFO_OUTBSIZE;`
464			`break;`
465			`case T1F_OREADY\|T1F_OHALF:`
466			`outsb(base+B1_WRITE, dp, i);`
467			`dp += i;`
468			`i = 0;`
469			`break;`
470			`default:`
471			`b1_put_byte(base, *dp++);`
472			`i--;`
473			`break;`
474			`}`
475			`}`
476			`} else {`
477			`while (i-- > 0)`
478			`b1_put_byte(base, *dp++);`
479			`}`
480			`}`
481
482			`static inline void t1_disable_irq(unsigned int base)`
483			`{`
484			`t1outp(base, T1_IRQMASTER, 0x00);`
485			`}`
486
487			`static inline void t1_reset(unsigned int base)`
488			`{`
489			`/* reset T1 Controller */`
490			`b1_reset(base);`
491			`/* disable irq on HEMA */`
492			`t1outp(base, B1_INSTAT, 0x00);`
493			`t1outp(base, B1_OUTSTAT, 0x00);`
494			`t1outp(base, T1_IRQMASTER, 0x00);`
495			`/* reset HEMA board configuration */`
496			`t1outp(base, T1_RESETBOARD, 0xf);`
497			`}`
498
499			`static inline void b1_setinterrupt(unsigned int base, unsigned irq,`
500			`enum avmcardtype cardtype)`
501			`{`
502			`switch (cardtype) {`
503			`case avm_t1isa:`
504			`t1outp(base, B1_INSTAT, 0x00);`
505			`t1outp(base, B1_INSTAT, 0x02);`
506			`t1outp(base, T1_IRQMASTER, 0x08);`
507			`break;`
508			`case avm_b1isa:`
509			`b1outp(base, B1_INSTAT, 0x00);`
510			`b1outp(base, B1_RESET, b1_irq_table[irq]);`
511			`b1outp(base, B1_INSTAT, 0x02);`
512			`break;`
513			`default:`
514			`case avm_m1:`
515			`case avm_m2:`
516			`case avm_b1pci:`
517			`b1outp(base, B1_INSTAT, 0x00);`
518			`b1outp(base, B1_RESET, 0xf0);`
519			`b1outp(base, B1_INSTAT, 0x02);`
520			`break;`
521			`case avm_c4:`
522			`case avm_t1pci:`
523			`b1outp(base, B1_RESET, 0xf0);`
524			`break;`
525			`}`
526			`}`
527
528			`/* b1.c */`
529			`int b1_detect(unsigned int base, enum avmcardtype cardtype);`
530			`void b1_getrevision(avmcard *card);`
531			`int b1_load_t4file(avmcard card, capiloaddatapart t4file);`
532			`int b1_load_config(avmcard card, capiloaddatapart config);`
533			`int b1_loaded(avmcard *card);`
534
535			`int b1_load_firmware(struct capi_ctr ctrl, capiloaddata data);`
536			`void b1_reset_ctr(struct capi_ctr *ctrl);`
537			`void b1_register_appl(struct capi_ctr *ctrl, __u16 appl,`
538			`capi_register_params *rp);`
539			`void b1_release_appl(struct capi_ctr *ctrl, __u16 appl);`
540			`void b1_send_message(struct capi_ctr ctrl, struct sk_buff skb);`
541			`void b1_parse_version(avmctrl_info *card);`
542			`void b1_handle_interrupt(avmcard * card);`
543
544			`int b1ctl_read_proc(char page, char *start, off_t off,`
545			`int count, int eof, struct capi_ctr ctrl);`
546
547			`/* b1dma.c */`
548			`int b1pciv4_detect(avmcard *card);`
549			`int t1pci_detect(avmcard *card);`
550			`void b1dma_reset(avmcard *card);`
551			`void b1dma_interrupt(int interrupt, void devptr, struct pt_regs regs);`
552
553			`int b1dma_load_firmware(struct capi_ctr ctrl, capiloaddata data);`
554			`void b1dma_reset_ctr(struct capi_ctr *ctrl);`
555			`void b1dma_remove_ctr(struct capi_ctr *ctrl);`
556			`void b1dma_register_appl(struct capi_ctr *ctrl,`
557			`__u16 appl,`
558			`capi_register_params *rp);`
559			`void b1dma_release_appl(struct capi_ctr *ctrl, __u16 appl);`
560			`void b1dma_send_message(struct capi_ctr ctrl, struct sk_buff skb);`
561			`int b1dmactl_read_proc(char page, char *start, off_t off,`
562			`int count, int eof, struct capi_ctr ctrl);`
563
564			`#endif /* _AVMCARD_H_ */`