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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [isdn/] [avmb1/] [c4.c] - Blame information for rev 1275

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1275 phoenix 
/* $Id: c4.c,v 1.1.1.1 2004-04-15 02:04:04 phoenix Exp $
2 
 *
3 
 * Module for AVM C4 & C2 card.
4 
 *
5 
 * Copyright 1999 by Carsten Paeth <calle@calle.de>
6 
 *
7 
 * This software may be used and distributed according to the terms
8 
 * of the GNU General Public License, incorporated herein by reference.
9 
 *
10 
 */
11 
 
12 
#include <linux/config.h>
13 
#include <linux/module.h>
14 
#include <linux/kernel.h>
15 
#include <linux/skbuff.h>
16 
#include <linux/delay.h>
17 
#include <linux/mm.h>
18 
#include <linux/interrupt.h>
19 
#include <linux/ioport.h>
20 
#include <linux/pci.h>
21 
#include <linux/capi.h>
22 
#include <linux/kernelcapi.h>
23 
#include <linux/init.h>
24 
#include <asm/io.h>
25 
#include <asm/uaccess.h>
26 
#include <linux/netdevice.h>
27 
#include "capicmd.h"
28 
#include "capiutil.h"
29 
#include "capilli.h"
30 
#include "avmcard.h"
31 
 
32 
static char *revision = "$Revision: 1.1.1.1 $";
33 
 
34 
#undef CONFIG_C4_DEBUG
35 
#undef CONFIG_C4_POLLDEBUG
36 
 
37 
/* ------------------------------------------------------------- */
38 
 
39 
static int suppress_pollack;
40 
 
41 
static struct pci_device_id c4_pci_tbl[] __initdata = {
42 
        { PCI_VENDOR_ID_DEC,PCI_DEVICE_ID_DEC_21285, PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_C4 },
43 
        { PCI_VENDOR_ID_DEC,PCI_DEVICE_ID_DEC_21285, PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_C2 },
44 
        { }                     /* Terminating entry */
45 
};
46 
 
47 
MODULE_DEVICE_TABLE(pci, c4_pci_tbl);
48 
MODULE_DESCRIPTION("CAPI4Linux: Driver for AVM C2/C4 cards");
49 
MODULE_AUTHOR("Carsten Paeth");
50 
MODULE_LICENSE("GPL");
51 
MODULE_PARM(suppress_pollack, "0-1i");
52 
 
53 
/* ------------------------------------------------------------- */
54 
 
55 
static struct capi_driver_interface *di;
56 
 
57 
/* ------------------------------------------------------------- */
58 
 
59 
static void c4_dispatch_tx(avmcard *card);
60 
 
61 
/* ------------------------------------------------------------- */
62 
 
63 
#define DC21285_DRAM_A0MR       0x40000000
64 
#define DC21285_DRAM_A1MR       0x40004000
65 
#define DC21285_DRAM_A2MR       0x40008000
66 
#define DC21285_DRAM_A3MR       0x4000C000
67 
 
68 
#define CAS_OFFSET      0x88
69 
 
70 
#define DC21285_ARMCSR_BASE     0x42000000
71 
 
72 
#define PCI_OUT_INT_STATUS      0x30
73 
#define PCI_OUT_INT_MASK        0x34
74 
#define MAILBOX_0               0x50
75 
#define MAILBOX_1               0x54
76 
#define MAILBOX_2               0x58
77 
#define MAILBOX_3               0x5C
78 
#define DOORBELL                0x60
79 
#define DOORBELL_SETUP          0x64
80 
 
81 
#define CHAN_1_CONTROL          0x90
82 
#define CHAN_2_CONTROL          0xB0
83 
#define DRAM_TIMING             0x10C
84 
#define DRAM_ADDR_SIZE_0        0x110
85 
#define DRAM_ADDR_SIZE_1        0x114
86 
#define DRAM_ADDR_SIZE_2        0x118
87 
#define DRAM_ADDR_SIZE_3        0x11C
88 
#define SA_CONTROL              0x13C
89 
#define XBUS_CYCLE              0x148
90 
#define XBUS_STROBE             0x14C
91 
#define DBELL_PCI_MASK          0x150
92 
#define DBELL_SA_MASK           0x154
93 
 
94 
#define SDRAM_SIZE              0x1000000
95 
 
96 
/* ------------------------------------------------------------- */
97 
 
98 
#define MBOX_PEEK_POKE          MAILBOX_0
99 
 
100 
#define DBELL_ADDR              0x01
101 
#define DBELL_DATA              0x02
102 
#define DBELL_RNWR              0x40
103 
#define DBELL_INIT              0x80
104 
 
105 
/* ------------------------------------------------------------- */
106 
 
107 
#define MBOX_UP_ADDR            MAILBOX_0
108 
#define MBOX_UP_LEN             MAILBOX_1
109 
#define MBOX_DOWN_ADDR          MAILBOX_2
110 
#define MBOX_DOWN_LEN           MAILBOX_3
111 
 
112 
#define DBELL_UP_HOST           0x00000100
113 
#define DBELL_UP_ARM            0x00000200
114 
#define DBELL_DOWN_HOST         0x00000400
115 
#define DBELL_DOWN_ARM          0x00000800
116 
#define DBELL_RESET_HOST        0x40000000
117 
#define DBELL_RESET_ARM         0x80000000
118 
 
119 
/* ------------------------------------------------------------- */
120 
 
121 
#define DRAM_TIMING_DEF         0x001A01A5
122 
#define DRAM_AD_SZ_DEF0         0x00000045
123 
#define DRAM_AD_SZ_NULL         0x00000000
124 
 
125 
#define SA_CTL_ALLRIGHT         0x64AA0271
126 
 
127 
#define INIT_XBUS_CYCLE         0x100016DB
128 
#define INIT_XBUS_STROBE        0xF1F1F1F1
129 
 
130 
/* ------------------------------------------------------------- */
131 
 
132 
#define RESET_TIMEOUT           (15*HZ) /* 15 sec */
133 
#define PEEK_POKE_TIMEOUT       (HZ/10) /* 0.1 sec */
134 
 
135 
/* ------------------------------------------------------------- */
136 
 
137 
#define c4outmeml(addr, value)  writel(value, addr)
138 
#define c4inmeml(addr)  readl(addr)
139 
#define c4outmemw(addr, value)  writew(value, addr)
140 
#define c4inmemw(addr)  readw(addr)
141 
#define c4outmemb(addr, value)  writeb(value, addr)
142 
#define c4inmemb(addr)  readb(addr)
143 
 
144 
/* ------------------------------------------------------------- */
145 
 
146 
static inline int wait_for_doorbell(avmcard *card, unsigned long t)
147 
{
148 
        unsigned long stop;
149 
 
150 
        stop = jiffies + t;
151 
        while (c4inmeml(card->mbase+DOORBELL) != 0xffffffff) {
152 
                if (!time_before(jiffies, stop))
153 
                        return -1;
154 
        }
155 
        return 0;
156 
}
157 
 
158 
static int c4_poke(avmcard *card,  unsigned long off, unsigned long value)
159 
{
160 
 
161 
        if (wait_for_doorbell(card, HZ/10) < 0)
162 
                return -1;
163 
 
164 
        c4outmeml(card->mbase+MBOX_PEEK_POKE, off);
165 
        c4outmeml(card->mbase+DOORBELL, DBELL_ADDR);
166 
 
167 
        if (wait_for_doorbell(card, HZ/10) < 0)
168 
                return -1;
169 
 
170 
        c4outmeml(card->mbase+MBOX_PEEK_POKE, value);
171 
        c4outmeml(card->mbase+DOORBELL, DBELL_DATA | DBELL_ADDR);
172 
 
173 
        return 0;
174 
}
175 
 
176 
static int c4_peek(avmcard *card,  unsigned long off, unsigned long *valuep)
177 
{
178 
        if (wait_for_doorbell(card, HZ/10) < 0)
179 
                return -1;
180 
 
181 
        c4outmeml(card->mbase+MBOX_PEEK_POKE, off);
182 
        c4outmeml(card->mbase+DOORBELL, DBELL_RNWR | DBELL_ADDR);
183 
 
184 
        if (wait_for_doorbell(card, HZ/10) < 0)
185 
                return -1;
186 
 
187 
        *valuep = c4inmeml(card->mbase+MBOX_PEEK_POKE);
188 
 
189 
        return 0;
190 
}
191 
 
192 
/* ------------------------------------------------------------- */
193 
 
194 
static int c4_load_t4file(avmcard *card, capiloaddatapart * t4file)
195 
{
196 
        __u32 val;
197 
        unsigned char *dp;
198 
        int left, retval;
199 
        __u32 loadoff = 0;
200 
 
201 
        dp = t4file->data;
202 
        left = t4file->len;
203 
        while (left >= sizeof(__u32)) {
204 
                if (t4file->user) {
205 
                        retval = copy_from_user(&val, dp, sizeof(val));
206 
                        if (retval)
207 
                                return -EFAULT;
208 
                } else {
209 
                        memcpy(&val, dp, sizeof(val));
210 
                }
211 
                if (c4_poke(card, loadoff, val)) {
212 
                        printk(KERN_ERR "%s: corrupted firmware file ?\n",
213 
                                        card->name);
214 
                        return -EIO;
215 
                }
216 
                left -= sizeof(__u32);
217 
                dp += sizeof(__u32);
218 
                loadoff += sizeof(__u32);
219 
        }
220 
        if (left) {
221 
                val = 0;
222 
                if (t4file->user) {
223 
                        retval = copy_from_user(&val, dp, left);
224 
                        if (retval)
225 
                                return -EFAULT;
226 
                } else {
227 
                        memcpy(&val, dp, left);
228 
                }
229 
                if (c4_poke(card, loadoff, val)) {
230 
                        printk(KERN_ERR "%s: corrupted firmware file ?\n",
231 
                                        card->name);
232 
                        return -EIO;
233 
                }
234 
        }
235 
        return 0;
236 
}
237 
 
238 
/* ------------------------------------------------------------- */
239 
 
240 
static inline void _put_byte(void **pp, __u8 val)
241 
{
242 
        __u8 *s = *pp;
243 
        *s++ = val;
244 
        *pp = s;
245 
}
246 
 
247 
static inline void _put_word(void **pp, __u32 val)
248 
{
249 
        __u8 *s = *pp;
250 
        *s++ = val & 0xff;
251 
        *s++ = (val >> 8) & 0xff;
252 
        *s++ = (val >> 16) & 0xff;
253 
        *s++ = (val >> 24) & 0xff;
254 
        *pp = s;
255 
}
256 
 
257 
static inline void _put_slice(void **pp, unsigned char *dp, unsigned int len)
258 
{
259 
        unsigned i = len;
260 
        _put_word(pp, i);
261 
        while (i-- > 0)
262 
                _put_byte(pp, *dp++);
263 
}
264 
 
265 
static inline __u8 _get_byte(void **pp)
266 
{
267 
        __u8 *s = *pp;
268 
        __u8 val;
269 
        val = *s++;
270 
        *pp = s;
271 
        return val;
272 
}
273 
 
274 
static inline __u32 _get_word(void **pp)
275 
{
276 
        __u8 *s = *pp;
277 
        __u32 val;
278 
        val = *s++;
279 
        val |= (*s++ << 8);
280 
        val |= (*s++ << 16);
281 
        val |= (*s++ << 24);
282 
        *pp = s;
283 
        return val;
284 
}
285 
 
286 
static inline __u32 _get_slice(void **pp, unsigned char *dp)
287 
{
288 
        unsigned int len, i;
289 
 
290 
        len = i = _get_word(pp);
291 
        while (i-- > 0) *dp++ = _get_byte(pp);
292 
        return len;
293 
}
294 
 
295 
/* ------------------------------------------------------------- */
296 
 
297 
static void c4_reset(avmcard *card)
298 
{
299 
        unsigned long stop;
300 
 
301 
        c4outmeml(card->mbase+DOORBELL, DBELL_RESET_ARM);
302 
 
303 
        stop = jiffies + HZ*10;
304 
        while (c4inmeml(card->mbase+DOORBELL) != 0xffffffff) {
305 
                if (!time_before(jiffies, stop))
306 
                        return;
307 
                c4outmeml(card->mbase+DOORBELL, DBELL_ADDR);
308 
        }
309 
 
310 
        c4_poke(card, DC21285_ARMCSR_BASE + CHAN_1_CONTROL, 0);
311 
        c4_poke(card, DC21285_ARMCSR_BASE + CHAN_2_CONTROL, 0);
312 
}
313 
 
314 
/* ------------------------------------------------------------- */
315 
 
316 
static int c4_detect(avmcard *card)
317 
{
318 
        unsigned long stop, dummy;
319 
 
320 
        c4outmeml(card->mbase+PCI_OUT_INT_MASK, 0x0c);
321 
        if (c4inmeml(card->mbase+PCI_OUT_INT_MASK) != 0x0c)
322 
                return  1;
323 
 
324 
        c4outmeml(card->mbase+DOORBELL, DBELL_RESET_ARM);
325 
 
326 
        stop = jiffies + HZ*10;
327 
        while (c4inmeml(card->mbase+DOORBELL) != 0xffffffff) {
328 
                if (!time_before(jiffies, stop))
329 
                        return 2;
330 
                c4outmeml(card->mbase+DOORBELL, DBELL_ADDR);
331 
        }
332 
 
333 
        c4_poke(card, DC21285_ARMCSR_BASE + CHAN_1_CONTROL, 0);
334 
        c4_poke(card, DC21285_ARMCSR_BASE + CHAN_2_CONTROL, 0);
335 
 
336 
        c4outmeml(card->mbase+MAILBOX_0, 0x55aa55aa);
337 
        if (c4inmeml(card->mbase+MAILBOX_0) != 0x55aa55aa) return 3;
338 
 
339 
        c4outmeml(card->mbase+MAILBOX_0, 0xaa55aa55);
340 
        if (c4inmeml(card->mbase+MAILBOX_0) != 0xaa55aa55) return 4;
341 
 
342 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DBELL_SA_MASK, 0)) return 5;
343 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DBELL_PCI_MASK, 0)) return 6;
344 
        if (c4_poke(card, DC21285_ARMCSR_BASE+SA_CONTROL, SA_CTL_ALLRIGHT))
345 
                return 7;
346 
        if (c4_poke(card, DC21285_ARMCSR_BASE+XBUS_CYCLE, INIT_XBUS_CYCLE))
347 
                return 8;
348 
        if (c4_poke(card, DC21285_ARMCSR_BASE+XBUS_STROBE, INIT_XBUS_STROBE))
349 
                return 8;
350 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_TIMING, 0)) return 9;
351 
 
352 
        mdelay(1);
353 
 
354 
        if (c4_peek(card, DC21285_DRAM_A0MR, &dummy)) return 10;
355 
        if (c4_peek(card, DC21285_DRAM_A1MR, &dummy)) return 11;
356 
        if (c4_peek(card, DC21285_DRAM_A2MR, &dummy)) return 12;
357 
        if (c4_peek(card, DC21285_DRAM_A3MR, &dummy)) return 13;
358 
 
359 
        if (c4_poke(card, DC21285_DRAM_A0MR+CAS_OFFSET, 0)) return 14;
360 
        if (c4_poke(card, DC21285_DRAM_A1MR+CAS_OFFSET, 0)) return 15;
361 
        if (c4_poke(card, DC21285_DRAM_A2MR+CAS_OFFSET, 0)) return 16;
362 
        if (c4_poke(card, DC21285_DRAM_A3MR+CAS_OFFSET, 0)) return 17;
363 
 
364 
        mdelay(1);
365 
 
366 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_TIMING, DRAM_TIMING_DEF))
367 
                return 18;
368 
 
369 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_0,DRAM_AD_SZ_DEF0))
370 
                return 19;
371 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_1,DRAM_AD_SZ_NULL))
372 
                return 20;
373 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_2,DRAM_AD_SZ_NULL))
374 
                return 21;
375 
        if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_3,DRAM_AD_SZ_NULL))
376 
                return 22;
377 
 
378 
        /* Transputer test */
379 
 
380 
        if (   c4_poke(card, 0x000000, 0x11111111)
381 
            || c4_poke(card, 0x400000, 0x22222222)
382 
            || c4_poke(card, 0x800000, 0x33333333)
383 
            || c4_poke(card, 0xC00000, 0x44444444))
384 
                return 23;
385 
 
386 
        if (   c4_peek(card, 0x000000, &dummy) || dummy != 0x11111111
387 
            || c4_peek(card, 0x400000, &dummy) || dummy != 0x22222222
388 
            || c4_peek(card, 0x800000, &dummy) || dummy != 0x33333333
389 
            || c4_peek(card, 0xC00000, &dummy) || dummy != 0x44444444)
390 
                return 24;
391 
 
392 
        if (   c4_poke(card, 0x000000, 0x55555555)
393 
            || c4_poke(card, 0x400000, 0x66666666)
394 
            || c4_poke(card, 0x800000, 0x77777777)
395 
            || c4_poke(card, 0xC00000, 0x88888888))
396 
                return 25;
397 
 
398 
        if (   c4_peek(card, 0x000000, &dummy) || dummy != 0x55555555
399 
            || c4_peek(card, 0x400000, &dummy) || dummy != 0x66666666
400 
            || c4_peek(card, 0x800000, &dummy) || dummy != 0x77777777
401 
            || c4_peek(card, 0xC00000, &dummy) || dummy != 0x88888888)
402 
                return 26;
403 
 
404 
        return 0;
405 
}
406 
 
407 
/* ------------------------------------------------------------- */
408 
 
409 
static void c4_dispatch_tx(avmcard *card)
410 
{
411 
        avmcard_dmainfo *dma = card->dma;
412 
        unsigned long flags;
413 
        struct sk_buff *skb;
414 
        __u8 cmd, subcmd;
415 
        __u16 len;
416 
        __u32 txlen;
417 
        void *p;
418 
 
419 
        save_flags(flags);
420 
        cli();
421 
 
422 
        if (card->csr & DBELL_DOWN_ARM) { /* tx busy */
423 
                restore_flags(flags);
424 
                return;
425 
        }
426 
 
427 
        skb = skb_dequeue(&dma->send_queue);
428 
        if (!skb) {
429 
#ifdef CONFIG_C4_DEBUG
430 
                printk(KERN_DEBUG "%s: tx underrun\n", card->name);
431 
#endif
432 
                restore_flags(flags);
433 
                return;
434 
        }
435 
 
436 
        len = CAPIMSG_LEN(skb->data);
437 
 
438 
        if (len) {
439 
                cmd = CAPIMSG_COMMAND(skb->data);
440 
                subcmd = CAPIMSG_SUBCOMMAND(skb->data);
441 
 
442 
                p = dma->sendbuf;
443 
 
444 
                if (CAPICMD(cmd, subcmd) == CAPI_DATA_B3_REQ) {
445 
                        __u16 dlen = CAPIMSG_DATALEN(skb->data);
446 
                        _put_byte(&p, SEND_DATA_B3_REQ);
447 
                        _put_slice(&p, skb->data, len);
448 
                        _put_slice(&p, skb->data + len, dlen);
449 
                } else {
450 
                        _put_byte(&p, SEND_MESSAGE);
451 
                        _put_slice(&p, skb->data, len);
452 
                }
453 
                txlen = (__u8 *)p - (__u8 *)dma->sendbuf;
454 
#ifdef CONFIG_C4_DEBUG
455 
                printk(KERN_DEBUG "%s: tx put msg len=%d\n", card->name, txlen);
456 
#endif
457 
        } else {
458 
                txlen = skb->len-2;
459 
#ifdef CONFIG_C4_POLLDEBUG
460 
                if (skb->data[2] == SEND_POLLACK)
461 
                        printk(KERN_INFO "%s: ack to c4\n", card->name);
462 
#endif
463 
#ifdef CONFIG_C4_DEBUG
464 
                printk(KERN_DEBUG "%s: tx put 0x%x len=%d\n",
465 
                                card->name, skb->data[2], txlen);
466 
#endif
467 
                memcpy(dma->sendbuf, skb->data+2, skb->len-2);
468 
        }
469 
        txlen = (txlen + 3) & ~3;
470 
 
471 
        c4outmeml(card->mbase+MBOX_DOWN_ADDR, virt_to_phys(dma->sendbuf));
472 
        c4outmeml(card->mbase+MBOX_DOWN_LEN, txlen);
473 
 
474 
        card->csr |= DBELL_DOWN_ARM;
475 
 
476 
        c4outmeml(card->mbase+DOORBELL, DBELL_DOWN_ARM);
477 
 
478 
        restore_flags(flags);
479 
        dev_kfree_skb_any(skb);
480 
}
481 
 
482 
/* ------------------------------------------------------------- */
483 
 
484 
static void queue_pollack(avmcard *card)
485 
{
486 
        struct sk_buff *skb;
487 
        void *p;
488 
 
489 
        skb = alloc_skb(3, GFP_ATOMIC);
490 
        if (!skb) {
491 
                printk(KERN_CRIT "%s: no memory, lost poll ack\n",
492 
                                        card->name);
493 
                return;
494 
        }
495 
        p = skb->data;
496 
        _put_byte(&p, 0);
497 
        _put_byte(&p, 0);
498 
        _put_byte(&p, SEND_POLLACK);
499 
        skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
500 
 
501 
        skb_queue_tail(&card->dma->send_queue, skb);
502 
        c4_dispatch_tx(card);
503 
}
504 
 
505 
/* ------------------------------------------------------------- */
506 
 
507 
static void c4_handle_rx(avmcard *card)
508 
{
509 
        avmcard_dmainfo *dma = card->dma;
510 
        struct capi_ctr *ctrl;
511 
        avmctrl_info *cinfo;
512 
        struct sk_buff *skb;
513 
        void *p = dma->recvbuf;
514 
        __u32 ApplId, MsgLen, DataB3Len, NCCI, WindowSize;
515 
        __u8 b1cmd =  _get_byte(&p);
516 
        __u32 cidx;
517 
 
518 
 
519 
#ifdef CONFIG_C4_DEBUG
520 
        printk(KERN_DEBUG "%s: rx 0x%x len=%lu\n", card->name,
521 
                                b1cmd, (unsigned long)dma->recvlen);
522 
#endif
523 
 
524 
        switch (b1cmd) {
525 
        case RECEIVE_DATA_B3_IND:
526 
 
527 
                ApplId = (unsigned) _get_word(&p);
528 
                MsgLen = _get_slice(&p, card->msgbuf);
529 
                DataB3Len = _get_slice(&p, card->databuf);
530 
                cidx = CAPIMSG_CONTROLLER(card->msgbuf)-card->cardnr;
531 
                if (cidx >= card->nlogcontr) cidx = 0;
532 
                ctrl = card->ctrlinfo[cidx].capi_ctrl;
533 
 
534 
                if (MsgLen < 30) { /* not CAPI 64Bit */
535 
                        memset(card->msgbuf+MsgLen, 0, 30-MsgLen);
536 
                        MsgLen = 30;
537 
                        CAPIMSG_SETLEN(card->msgbuf, 30);
538 
                }
539 
                if (!(skb = alloc_skb(DataB3Len+MsgLen, GFP_ATOMIC))) {
540 
                        printk(KERN_ERR "%s: incoming packet dropped\n",
541 
                                        card->name);
542 
                } else {
543 
                        memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
544 
                        memcpy(skb_put(skb, DataB3Len), card->databuf, DataB3Len);
545 
                        ctrl->handle_capimsg(ctrl, ApplId, skb);
546 
                }
547 
                break;
548 
 
549 
        case RECEIVE_MESSAGE:
550 
 
551 
                ApplId = (unsigned) _get_word(&p);
552 
                MsgLen = _get_slice(&p, card->msgbuf);
553 
                cidx = CAPIMSG_CONTROLLER(card->msgbuf)-card->cardnr;
554 
                if (cidx >= card->nlogcontr) cidx = 0;
555 
                ctrl = card->ctrlinfo[cidx].capi_ctrl;
556 
 
557 
                if (!(skb = alloc_skb(MsgLen, GFP_ATOMIC))) {
558 
                        printk(KERN_ERR "%s: incoming packet dropped\n",
559 
                                        card->name);
560 
                } else {
561 
                        memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
562 
                        ctrl->handle_capimsg(ctrl, ApplId, skb);
563 
                }
564 
                break;
565 
 
566 
        case RECEIVE_NEW_NCCI:
567 
 
568 
                ApplId = _get_word(&p);
569 
                NCCI = _get_word(&p);
570 
                WindowSize = _get_word(&p);
571 
                cidx = (NCCI&0x7f) - card->cardnr;
572 
                if (cidx >= card->nlogcontr) cidx = 0;
573 
                ctrl = card->ctrlinfo[cidx].capi_ctrl;
574 
 
575 
                ctrl->new_ncci(ctrl, ApplId, NCCI, WindowSize);
576 
 
577 
                break;
578 
 
579 
        case RECEIVE_FREE_NCCI:
580 
 
581 
                ApplId = _get_word(&p);
582 
                NCCI = _get_word(&p);
583 
 
584 
                if (NCCI != 0xffffffff) {
585 
                        cidx = (NCCI&0x7f) - card->cardnr;
586 
                        if (cidx >= card->nlogcontr) cidx = 0;
587 
                        ctrl = card->ctrlinfo[cidx].capi_ctrl;
588 
                        if (ctrl)
589 
                                ctrl->free_ncci(ctrl, ApplId, NCCI);
590 
                } else {
591 
                        for (cidx=0; cidx < 4; cidx++) {
592 
                                ctrl = card->ctrlinfo[cidx].capi_ctrl;
593 
                                if (ctrl)
594 
                                        ctrl->appl_released(ctrl, ApplId);
595 
                        }
596 
                }
597 
                break;
598 
 
599 
        case RECEIVE_START:
600 
#ifdef CONFIG_C4_POLLDEBUG
601 
                printk(KERN_INFO "%s: poll from c4\n", card->name);
602 
#endif
603 
                if (!suppress_pollack)
604 
                        queue_pollack(card);
605 
                for (cidx=0; cidx < 4; cidx++) {
606 
                        ctrl = card->ctrlinfo[cidx].capi_ctrl;
607 
                        if (ctrl)
608 
                                ctrl->resume_output(ctrl);
609 
                }
610 
                break;
611 
 
612 
        case RECEIVE_STOP:
613 
                for (cidx=0; cidx < 4; cidx++) {
614 
                        ctrl = card->ctrlinfo[cidx].capi_ctrl;
615 
                        if (ctrl)
616 
                                ctrl->suspend_output(ctrl);
617 
                }
618 
                break;
619 
 
620 
        case RECEIVE_INIT:
621 
 
622 
                cidx = card->nlogcontr;
623 
                if (cidx >= 4 || !card->ctrlinfo[cidx].capi_ctrl) {
624 
                        printk(KERN_ERR "%s: card with %d controllers ??\n",
625 
                                        card->name, cidx+1);
626 
                        break;
627 
                }
628 
                card->nlogcontr++;
629 
                cinfo = &card->ctrlinfo[cidx];
630 
                ctrl = cinfo->capi_ctrl;
631 
                cinfo->versionlen = _get_slice(&p, cinfo->versionbuf);
632 
                b1_parse_version(cinfo);
633 
                printk(KERN_INFO "%s: %s-card (%s) now active\n",
634 
                       card->name,
635 
                       cinfo->version[VER_CARDTYPE],
636 
                       cinfo->version[VER_DRIVER]);
637 
                ctrl->ready(cinfo->capi_ctrl);
638 
                break;
639 
 
640 
        case RECEIVE_TASK_READY:
641 
                ApplId = (unsigned) _get_word(&p);
642 
                MsgLen = _get_slice(&p, card->msgbuf);
643 
                card->msgbuf[MsgLen] = 0;
644 
                while (    MsgLen > 0
645 
                       && (   card->msgbuf[MsgLen-1] == '\n'
646 
                           || card->msgbuf[MsgLen-1] == '\r')) {
647 
                        card->msgbuf[MsgLen-1] = 0;
648 
                        MsgLen--;
649 
                }
650 
                printk(KERN_INFO "%s: task %d \"%s\" ready.\n",
651 
                                card->name, ApplId, card->msgbuf);
652 
                break;
653 
 
654 
        case RECEIVE_DEBUGMSG:
655 
                MsgLen = _get_slice(&p, card->msgbuf);
656 
                card->msgbuf[MsgLen] = 0;
657 
                while (    MsgLen > 0
658 
                       && (   card->msgbuf[MsgLen-1] == '\n'
659 
                           || card->msgbuf[MsgLen-1] == '\r')) {
660 
                        card->msgbuf[MsgLen-1] = 0;
661 
                        MsgLen--;
662 
                }
663 
                printk(KERN_INFO "%s: DEBUG: %s\n", card->name, card->msgbuf);
664 
                break;
665 
 
666 
        default:
667 
                printk(KERN_ERR "%s: c4_interrupt: 0x%x ???\n",
668 
                                card->name, b1cmd);
669 
                return;
670 
        }
671 
}
672 
 
673 
/* ------------------------------------------------------------- */
674 
 
675 
static void c4_handle_interrupt(avmcard *card)
676 
{
677 
        __u32 status = c4inmeml(card->mbase+DOORBELL);
678 
 
679 
        if (status & DBELL_RESET_HOST) {
680 
                int i;
681 
                c4outmeml(card->mbase+PCI_OUT_INT_MASK, 0x0c);
682 
                if (card->nlogcontr == 0)
683 
                        return;
684 
                printk(KERN_ERR "%s: unexpected reset\n", card->name);
685 
                for (i=0; i < 4; i++) {
686 
                        avmctrl_info *cinfo = &card->ctrlinfo[i];
687 
                        memset(cinfo->version, 0, sizeof(cinfo->version));
688 
                        if (cinfo->capi_ctrl)
689 
                                cinfo->capi_ctrl->reseted(cinfo->capi_ctrl);
690 
                }
691 
                card->nlogcontr = 0;
692 
                return;
693 
        }
694 
 
695 
        status &= (DBELL_UP_HOST | DBELL_DOWN_HOST);
696 
        if (!status)
697 
                return;
698 
        c4outmeml(card->mbase+DOORBELL, status);
699 
 
700 
        if ((status & DBELL_UP_HOST) != 0) {
701 
                card->dma->recvlen = c4inmeml(card->mbase+MBOX_UP_LEN);
702 
                c4outmeml(card->mbase+MBOX_UP_LEN, 0);
703 
                c4_handle_rx(card);
704 
                card->dma->recvlen = 0;
705 
                c4outmeml(card->mbase+MBOX_UP_LEN, sizeof(card->dma->recvbuf));
706 
                c4outmeml(card->mbase+DOORBELL, DBELL_UP_ARM);
707 
        }
708 
 
709 
        if ((status & DBELL_DOWN_HOST) != 0) {
710 
                card->csr &= ~DBELL_DOWN_ARM;
711 
                c4_dispatch_tx(card);
712 
        } else if (card->csr & DBELL_DOWN_HOST) {
713 
                if (c4inmeml(card->mbase+MBOX_DOWN_LEN) == 0) {
714 
                        card->csr &= ~DBELL_DOWN_ARM;
715 
                        c4_dispatch_tx(card);
716 
                }
717 
        }
718 
}
719 
 
720 
static void c4_interrupt(int interrupt, void *devptr, struct pt_regs *regs)
721 
{
722 
        avmcard *card;
723 
 
724 
        card = (avmcard *) devptr;
725 
 
726 
        if (!card) {
727 
                printk(KERN_WARNING "%s: interrupt: wrong device\n", card->name);
728 
                return;
729 
        }
730 
        if (card->interrupt) {
731 
                printk(KERN_ERR "%s: reentering interrupt hander\n",
732 
                                card->name);
733 
                return;
734 
        }
735 
 
736 
        card->interrupt = 1;
737 
 
738 
        c4_handle_interrupt(card);
739 
 
740 
        card->interrupt = 0;
741 
}
742 
 
743 
/* ------------------------------------------------------------- */
744 
 
745 
static void c4_send_init(avmcard *card)
746 
{
747 
        struct sk_buff *skb;
748 
        void *p;
749 
 
750 
        skb = alloc_skb(15, GFP_ATOMIC);
751 
        if (!skb) {
752 
                printk(KERN_CRIT "%s: no memory, lost register appl.\n",
753 
                                        card->name);
754 
                return;
755 
        }
756 
        p = skb->data;
757 
        _put_byte(&p, 0);
758 
        _put_byte(&p, 0);
759 
        _put_byte(&p, SEND_INIT);
760 
        _put_word(&p, CAPI_MAXAPPL);
761 
        _put_word(&p, AVM_NCCI_PER_CHANNEL*30);
762 
        _put_word(&p, card->cardnr - 1);
763 
        skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
764 
 
765 
        skb_queue_tail(&card->dma->send_queue, skb);
766 
        c4_dispatch_tx(card);
767 
}
768 
 
769 
static int queue_sendconfigword(avmcard *card, __u32 val)
770 
{
771 
        struct sk_buff *skb;
772 
        void *p;
773 
 
774 
        skb = alloc_skb(3+4, GFP_ATOMIC);
775 
        if (!skb) {
776 
                printk(KERN_CRIT "%s: no memory, send config\n",
777 
                                        card->name);
778 
                return -ENOMEM;
779 
        }
780 
        p = skb->data;
781 
        _put_byte(&p, 0);
782 
        _put_byte(&p, 0);
783 
        _put_byte(&p, SEND_CONFIG);
784 
        _put_word(&p, val);
785 
        skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
786 
 
787 
        skb_queue_tail(&card->dma->send_queue, skb);
788 
        c4_dispatch_tx(card);
789 
        return 0;
790 
}
791 
 
792 
static int queue_sendconfig(avmcard *card, char cval[4])
793 
{
794 
        struct sk_buff *skb;
795 
        void *p;
796 
 
797 
        skb = alloc_skb(3+4, GFP_ATOMIC);
798 
        if (!skb) {
799 
                printk(KERN_CRIT "%s: no memory, send config\n",
800 
                                        card->name);
801 
                return -ENOMEM;
802 
        }
803 
        p = skb->data;
804 
        _put_byte(&p, 0);
805 
        _put_byte(&p, 0);
806 
        _put_byte(&p, SEND_CONFIG);
807 
        _put_byte(&p, cval[0]);
808 
        _put_byte(&p, cval[1]);
809 
        _put_byte(&p, cval[2]);
810 
        _put_byte(&p, cval[3]);
811 
        skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
812 
 
813 
        skb_queue_tail(&card->dma->send_queue, skb);
814 
        c4_dispatch_tx(card);
815 
        return 0;
816 
}
817 
 
818 
static int c4_send_config(avmcard *card, capiloaddatapart * config)
819 
{
820 
        __u8 val[4];
821 
        unsigned char *dp;
822 
        int left, retval;
823 
 
824 
        if ((retval = queue_sendconfigword(card, 1)) != 0)
825 
                return retval;
826 
        if ((retval = queue_sendconfigword(card, config->len)) != 0)
827 
                return retval;
828 
 
829 
        dp = config->data;
830 
        left = config->len;
831 
        while (left >= sizeof(__u32)) {
832 
                if (config->user) {
833 
                        retval = copy_from_user(val, dp, sizeof(val));
834 
                        if (retval)
835 
                                return -EFAULT;
836 
                } else {
837 
                        memcpy(val, dp, sizeof(val));
838 
                }
839 
                if ((retval = queue_sendconfig(card, val)) != 0)
840 
                        return retval;
841 
                left -= sizeof(val);
842 
                dp += sizeof(val);
843 
        }
844 
        if (left) {
845 
                memset(val, 0, sizeof(val));
846 
                if (config->user) {
847 
                        retval = copy_from_user(&val, dp, left);
848 
                        if (retval)
849 
                                return -EFAULT;
850 
                } else {
851 
                        memcpy(&val, dp, left);
852 
                }
853 
                if ((retval = queue_sendconfig(card, val)) != 0)
854 
                        return retval;
855 
        }
856 
 
857 
        return 0;
858 
}
859 
 
860 
static int c4_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
861 
{
862 
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
863 
        avmcard *card = cinfo->card;
864 
        unsigned long flags;
865 
        int retval;
866 
 
867 
        if ((retval = c4_load_t4file(card, &data->firmware))) {
868 
                printk(KERN_ERR "%s: failed to load t4file!!\n",
869 
                                        card->name);
870 
                c4_reset(card);
871 
                return retval;
872 
        }
873 
 
874 
        save_flags(flags);
875 
        cli();
876 
 
877 
        card->csr = 0;
878 
        c4outmeml(card->mbase+MBOX_UP_LEN, 0);
879 
        c4outmeml(card->mbase+MBOX_DOWN_LEN, 0);
880 
        c4outmeml(card->mbase+DOORBELL, DBELL_INIT);
881 
        mdelay(1);
882 
        c4outmeml(card->mbase+DOORBELL,
883 
                        DBELL_UP_HOST | DBELL_DOWN_HOST | DBELL_RESET_HOST);
884 
 
885 
        c4outmeml(card->mbase+PCI_OUT_INT_MASK, 0x08);
886 
 
887 
        card->dma->recvlen = 0;
888 
        c4outmeml(card->mbase+MBOX_UP_ADDR, virt_to_phys(card->dma->recvbuf));
889 
        c4outmeml(card->mbase+MBOX_UP_LEN, sizeof(card->dma->recvbuf));
890 
        c4outmeml(card->mbase+DOORBELL, DBELL_UP_ARM);
891 
        restore_flags(flags);
892 
 
893 
        if (data->configuration.len > 0 && data->configuration.data) {
894 
                retval = c4_send_config(card, &data->configuration);
895 
                if (retval) {
896 
                        printk(KERN_ERR "%s: failed to set config!!\n",
897 
                                        card->name);
898 
                        c4_reset(card);
899 
                        return retval;
900 
                }
901 
        }
902 
 
903 
        c4_send_init(card);
904 
 
905 
        return 0;
906 
}
907 
 
908 
 
909 
void c4_reset_ctr(struct capi_ctr *ctrl)
910 
{
911 
        avmcard *card = ((avmctrl_info *)(ctrl->driverdata))->card;
912 
        avmctrl_info *cinfo;
913 
        int i;
914 
 
915 
        c4_reset(card);
916 
 
917 
        for (i=0; i < 4; i++) {
918 
                cinfo = &card->ctrlinfo[i];
919 
                memset(cinfo->version, 0, sizeof(cinfo->version));
920 
                if (cinfo->capi_ctrl)
921 
                        cinfo->capi_ctrl->reseted(cinfo->capi_ctrl);
922 
        }
923 
        card->nlogcontr = 0;
924 
}
925 
 
926 
static void c4_remove_ctr(struct capi_ctr *ctrl)
927 
{
928 
        avmcard *card = ((avmctrl_info *)(ctrl->driverdata))->card;
929 
        avmctrl_info *cinfo;
930 
        int i;
931 
 
932 
        c4_reset(card);
933 
 
934 
        for (i=0; i < 4; i++) {
935 
                cinfo = &card->ctrlinfo[i];
936 
                if (cinfo->capi_ctrl) {
937 
                        di->detach_ctr(cinfo->capi_ctrl);
938 
                        cinfo->capi_ctrl = NULL;
939 
                }
940 
        }
941 
 
942 
        free_irq(card->irq, card);
943 
        iounmap(card->mbase);
944 
        release_region(card->port, AVMB1_PORTLEN);
945 
        ctrl->driverdata = 0;
946 
        kfree(card->ctrlinfo);
947 
        kfree(card->dma);
948 
        kfree(card);
949 
 
950 
        MOD_DEC_USE_COUNT;
951 
}
952 
 
953 
/* ------------------------------------------------------------- */
954 
 
955 
 
956 
void c4_register_appl(struct capi_ctr *ctrl,
957 
                                __u16 appl,
958 
                                capi_register_params *rp)
959 
{
960 
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
961 
        avmcard *card = cinfo->card;
962 
        struct sk_buff *skb;
963 
        int want = rp->level3cnt;
964 
        int nconn;
965 
        void *p;
966 
 
967 
        if (ctrl->cnr == card->cardnr) {
968 
 
969 
                if (want > 0) nconn = want;
970 
                else nconn = ctrl->profile.nbchannel * 4 * -want;
971 
                if (nconn == 0) nconn = ctrl->profile.nbchannel * 4;
972 
 
973 
                skb = alloc_skb(23, GFP_ATOMIC);
974 
                if (!skb) {
975 
                        printk(KERN_CRIT "%s: no memory, lost register appl.\n",
976 
                                                card->name);
977 
                        return;
978 
                }
979 
                p = skb->data;
980 
                _put_byte(&p, 0);
981 
                _put_byte(&p, 0);
982 
                _put_byte(&p, SEND_REGISTER);
983 
                _put_word(&p, appl);
984 
                _put_word(&p, 1024 * (nconn+1));
985 
                _put_word(&p, nconn);
986 
                _put_word(&p, rp->datablkcnt);
987 
                _put_word(&p, rp->datablklen);
988 
                skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
989 
 
990 
                skb_queue_tail(&card->dma->send_queue, skb);
991 
                c4_dispatch_tx(card);
992 
        }
993 
 
994 
        ctrl->appl_registered(ctrl, appl);
995 
}
996 
 
997 
/* ------------------------------------------------------------- */
998 
 
999 
void c4_release_appl(struct capi_ctr *ctrl, __u16 appl)
1000 
{
1001 
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1002 
        avmcard *card = cinfo->card;
1003 
        struct sk_buff *skb;
1004 
        void *p;
1005 
 
1006 
        if (ctrl->cnr == card->cardnr) {
1007 
                skb = alloc_skb(7, GFP_ATOMIC);
1008 
                if (!skb) {
1009 
                        printk(KERN_CRIT "%s: no memory, lost release appl.\n",
1010 
                                                card->name);
1011 
                        return;
1012 
                }
1013 
                p = skb->data;
1014 
                _put_byte(&p, 0);
1015 
                _put_byte(&p, 0);
1016 
                _put_byte(&p, SEND_RELEASE);
1017 
                _put_word(&p, appl);
1018 
 
1019 
                skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
1020 
                skb_queue_tail(&card->dma->send_queue, skb);
1021 
                c4_dispatch_tx(card);
1022 
        }
1023 
}
1024 
 
1025 
/* ------------------------------------------------------------- */
1026 
 
1027 
 
1028 
static void c4_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
1029 
{
1030 
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1031 
        avmcard *card = cinfo->card;
1032 
        skb_queue_tail(&card->dma->send_queue, skb);
1033 
        c4_dispatch_tx(card);
1034 
}
1035 
 
1036 
/* ------------------------------------------------------------- */
1037 
 
1038 
static char *c4_procinfo(struct capi_ctr *ctrl)
1039 
{
1040 
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1041 
 
1042 
        if (!cinfo)
1043 
                return "";
1044 
        sprintf(cinfo->infobuf, "%s %s 0x%x %d 0x%lx",
1045 
                cinfo->cardname[0] ? cinfo->cardname : "-",
1046 
                cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
1047 
                cinfo->card ? cinfo->card->port : 0x0,
1048 
                cinfo->card ? cinfo->card->irq : 0,
1049 
                cinfo->card ? cinfo->card->membase : 0
1050 
                );
1051 
        return cinfo->infobuf;
1052 
}
1053 
 
1054 
static int c4_read_proc(char *page, char **start, off_t off,
1055 
                        int count, int *eof, struct capi_ctr *ctrl)
1056 
{
1057 
        avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1058 
        avmcard *card = cinfo->card;
1059 
        __u8 flag;
1060 
        int len = 0;
1061 
        char *s;
1062 
 
1063 
        len += sprintf(page+len, "%-16s %s\n", "name", card->name);
1064 
        len += sprintf(page+len, "%-16s 0x%x\n", "io", card->port);
1065 
        len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
1066 
        len += sprintf(page+len, "%-16s 0x%lx\n", "membase", card->membase);
1067 
        switch (card->cardtype) {
1068 
        case avm_b1isa: s = "B1 ISA"; break;
1069 
        case avm_b1pci: s = "B1 PCI"; break;
1070 
        case avm_b1pcmcia: s = "B1 PCMCIA"; break;
1071 
        case avm_m1: s = "M1"; break;
1072 
        case avm_m2: s = "M2"; break;
1073 
        case avm_t1isa: s = "T1 ISA (HEMA)"; break;
1074 
        case avm_t1pci: s = "T1 PCI"; break;
1075 
        case avm_c4: s = "C4"; break;
1076 
        case avm_c2: s = "C2"; break;
1077 
        default: s = "???"; break;
1078 
        }
1079 
        len += sprintf(page+len, "%-16s %s\n", "type", s);
1080 
        if ((s = cinfo->version[VER_DRIVER]) != 0)
1081 
           len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
1082 
        if ((s = cinfo->version[VER_CARDTYPE]) != 0)
1083 
           len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
1084 
        if ((s = cinfo->version[VER_SERIAL]) != 0)
1085 
           len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
1086 
 
1087 
        if (card->cardtype != avm_m1) {
1088 
                flag = ((__u8 *)(ctrl->profile.manu))[3];
1089 
                if (flag)
1090 
                        len += sprintf(page+len, "%-16s%s%s%s%s%s%s%s\n",
1091 
                        "protocol",
1092 
                        (flag & 0x01) ? " DSS1" : "",
1093 
                        (flag & 0x02) ? " CT1" : "",
1094 
                        (flag & 0x04) ? " VN3" : "",
1095 
                        (flag & 0x08) ? " NI1" : "",
1096 
                        (flag & 0x10) ? " AUSTEL" : "",
1097 
                        (flag & 0x20) ? " ESS" : "",
1098 
                        (flag & 0x40) ? " 1TR6" : ""
1099 
                        );
1100 
        }
1101 
        if (card->cardtype != avm_m1) {
1102 
                flag = ((__u8 *)(ctrl->profile.manu))[5];
1103 
                if (flag)
1104 
                        len += sprintf(page+len, "%-16s%s%s%s%s\n",
1105 
                        "linetype",
1106 
                        (flag & 0x01) ? " point to point" : "",
1107 
                        (flag & 0x02) ? " point to multipoint" : "",
1108 
                        (flag & 0x08) ? " leased line without D-channel" : "",
1109 
                        (flag & 0x04) ? " leased line with D-channel" : ""
1110 
                        );
1111 
        }
1112 
        len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
1113 
 
1114 
        if (off+count >= len)
1115 
           *eof = 1;
1116 
        if (len < off)
1117 
           return 0;
1118 
        *start = page + off;
1119 
        return ((count < len-off) ? count : len-off);
1120 
}
1121 
 
1122 
/* ------------------------------------------------------------- */
1123 
 
1124 
static int c4_add_card(struct capi_driver *driver,
1125 
                       struct capicardparams *p,
1126 
                       int nr)
1127 
{
1128 
        avmctrl_info *cinfo;
1129 
        avmcard *card;
1130 
        int retval;
1131 
        int i;
1132 
 
1133 
        MOD_INC_USE_COUNT;
1134 
 
1135 
        card = (avmcard *) kmalloc(sizeof(avmcard), GFP_ATOMIC);
1136 
 
1137 
        if (!card) {
1138 
                printk(KERN_WARNING "%s: no memory.\n", driver->name);
1139 
                MOD_DEC_USE_COUNT;
1140 
                return -ENOMEM;
1141 
        }
1142 
        memset(card, 0, sizeof(avmcard));
1143 
        card->dma = (avmcard_dmainfo *) kmalloc(sizeof(avmcard_dmainfo), GFP_ATOMIC);
1144 
        if (!card->dma) {
1145 
                printk(KERN_WARNING "%s: no memory.\n", driver->name);
1146 
                kfree(card);
1147 
                MOD_DEC_USE_COUNT;
1148 
                return -ENOMEM;
1149 
        }
1150 
        memset(card->dma, 0, sizeof(avmcard_dmainfo));
1151 
        cinfo = (avmctrl_info *) kmalloc(sizeof(avmctrl_info)*4, GFP_ATOMIC);
1152 
        if (!cinfo) {
1153 
                printk(KERN_WARNING "%s: no memory.\n", driver->name);
1154 
                kfree(card->dma);
1155 
                kfree(card);
1156 
                MOD_DEC_USE_COUNT;
1157 
                return -ENOMEM;
1158 
        }
1159 
        memset(cinfo, 0, sizeof(avmctrl_info)*4);
1160 
        card->ctrlinfo = cinfo;
1161 
        for (i=0; i < 4; i++) {
1162 
                cinfo = &card->ctrlinfo[i];
1163 
                cinfo->card = card;
1164 
        }
1165 
        sprintf(card->name, "%s-%x", driver->name, p->port);
1166 
        card->port = p->port;
1167 
        card->irq = p->irq;
1168 
        card->membase = p->membase;
1169 
        card->cardtype = nr == 4 ? avm_c4 : avm_c2;
1170 
 
1171 
        if (check_region(card->port, AVMB1_PORTLEN)) {
1172 
                printk(KERN_WARNING
1173 
                       "%s: ports 0x%03x-0x%03x in use.\n",
1174 
                       driver->name, card->port, card->port + AVMB1_PORTLEN);
1175 
                kfree(card->ctrlinfo);
1176 
                kfree(card->dma);
1177 
                kfree(card);
1178 
                MOD_DEC_USE_COUNT;
1179 
                return -EBUSY;
1180 
        }
1181 
 
1182 
        card->mbase = ioremap_nocache(card->membase, 128);
1183 
        if (card->mbase == 0) {
1184 
                printk(KERN_NOTICE "%s: can't remap memory at 0x%lx\n",
1185 
                                        driver->name, card->membase);
1186 
                kfree(card->ctrlinfo);
1187 
                kfree(card->dma);
1188 
                kfree(card);
1189 
                MOD_DEC_USE_COUNT;
1190 
                return -EIO;
1191 
        }
1192 
 
1193 
        if ((retval = c4_detect(card)) != 0) {
1194 
                printk(KERN_NOTICE "%s: NO card at 0x%x (%d)\n",
1195 
                                        driver->name, card->port, retval);
1196 
                iounmap(card->mbase);
1197 
                kfree(card->ctrlinfo);
1198 
                kfree(card->dma);
1199 
                kfree(card);
1200 
                MOD_DEC_USE_COUNT;
1201 
                return -EIO;
1202 
        }
1203 
        c4_reset(card);
1204 
 
1205 
        request_region(p->port, AVMB1_PORTLEN, card->name);
1206 
 
1207 
        retval = request_irq(card->irq, c4_interrupt, SA_SHIRQ, card->name, card);
1208 
        if (retval) {
1209 
                printk(KERN_ERR "%s: unable to get IRQ %d.\n",
1210 
                                driver->name, card->irq);
1211 
                iounmap(card->mbase);
1212 
                release_region(card->port, AVMB1_PORTLEN);
1213 
                kfree(card->ctrlinfo);
1214 
                kfree(card->dma);
1215 
                kfree(card);
1216 
                MOD_DEC_USE_COUNT;
1217 
                return -EBUSY;
1218 
        }
1219 
 
1220 
        for (i=0; i < nr ; i++) {
1221 
                cinfo = &card->ctrlinfo[i];
1222 
                cinfo->card = card;
1223 
                cinfo->capi_ctrl = di->attach_ctr(driver, card->name, cinfo);
1224 
                if (!cinfo->capi_ctrl) {
1225 
                        printk(KERN_ERR "%s: attach controller failed (%d).\n",
1226 
                                        driver->name, i);
1227 
                        for (i--; i >= 0; i--) {
1228 
                                cinfo = &card->ctrlinfo[i];
1229 
                                di->detach_ctr(cinfo->capi_ctrl);
1230 
                        }
1231 
                        iounmap(card->mbase);
1232 
                        free_irq(card->irq, card);
1233 
                        release_region(card->port, AVMB1_PORTLEN);
1234 
                        kfree(card->dma);
1235 
                        kfree(card->ctrlinfo);
1236 
                        kfree(card);
1237 
                        MOD_DEC_USE_COUNT;
1238 
                        return -EBUSY;
1239 
                }
1240 
                if (i == 0)
1241 
                        card->cardnr = cinfo->capi_ctrl->cnr;
1242 
        }
1243 
 
1244 
        skb_queue_head_init(&card->dma->send_queue);
1245 
 
1246 
        printk(KERN_INFO
1247 
                "%s: AVM C%d at i/o %#x, irq %d, mem %#lx\n",
1248 
                driver->name, nr, card->port, card->irq, card->membase);
1249 
 
1250 
        return 0;
1251 
}
1252 
 
1253 
/* ------------------------------------------------------------- */
1254 
 
1255 
static struct capi_driver c2_driver = {
1256 
    name: "c2",
1257 
    revision: "0.0",
1258 
    load_firmware: c4_load_firmware,
1259 
    reset_ctr: c4_reset_ctr,
1260 
    remove_ctr: c4_remove_ctr,
1261 
    register_appl: c4_register_appl,
1262 
    release_appl: c4_release_appl,
1263 
    send_message: c4_send_message,
1264 
 
1265 
    procinfo: c4_procinfo,
1266 
    ctr_read_proc: c4_read_proc,
1267 
    driver_read_proc: 0, /* use standard driver_read_proc */
1268 
 
1269 
    add_card: 0, /* no add_card function */
1270 
};
1271 
 
1272 
static struct capi_driver c4_driver = {
1273 
    name: "c4",
1274 
    revision: "0.0",
1275 
    load_firmware: c4_load_firmware,
1276 
    reset_ctr: c4_reset_ctr,
1277 
    remove_ctr: c4_remove_ctr,
1278 
    register_appl: c4_register_appl,
1279 
    release_appl: c4_release_appl,
1280 
    send_message: c4_send_message,
1281 
 
1282 
    procinfo: c4_procinfo,
1283 
    ctr_read_proc: c4_read_proc,
1284 
    driver_read_proc: 0, /* use standard driver_read_proc */
1285 
 
1286 
    add_card: 0, /* no add_card function */
1287 
};
1288 
 
1289 
static int ncards = 0;
1290 
 
1291 
static int c4_attach_driver (struct capi_driver * driver)
1292 
{
1293 
        char *p;
1294 
        if ((p = strchr(revision, ':')) != 0 && p[1]) {
1295 
                strncpy(driver->revision, p + 2, sizeof(driver->revision));
1296 
                driver->revision[sizeof(driver->revision)-1] = 0;
1297 
                if ((p = strchr(driver->revision, '$')) != 0 && p > driver->revision)
1298 
                        *(p-1) = 0;
1299 
        }
1300 
 
1301 
        printk(KERN_INFO "%s: revision %s\n", driver->name, driver->revision);
1302 
 
1303 
        di = attach_capi_driver(driver);
1304 
        if (!di) {
1305 
                printk(KERN_ERR "%s: failed to attach capi_driver\n",
1306 
                                driver->name);
1307 
                MOD_DEC_USE_COUNT;
1308 
                return -ENODEV;
1309 
        }
1310 
        return 0;
1311 
}
1312 
 
1313 
static int __init search_cards(struct capi_driver * driver,
1314 
                                int pci_id, int nr)
1315 
{
1316 
        struct pci_dev *        dev     = NULL;
1317 
        int                     retval  = 0;
1318 
 
1319 
        while ((dev = pci_find_subsys(
1320 
                        PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21285,
1321 
                        PCI_VENDOR_ID_AVM, pci_id, dev))) {
1322 
                struct capicardparams param;
1323 
 
1324 
                if (pci_enable_device(dev) < 0) {
1325 
                        printk(KERN_ERR "%s: failed to enable AVM-C%d\n",
1326 
                               driver->name, nr);
1327 
                        continue;
1328 
                }
1329 
                pci_set_master(dev);
1330 
 
1331 
                param.port = pci_resource_start(dev, 1);
1332 
                param.irq = dev->irq;
1333 
                param.membase = pci_resource_start(dev, 0);
1334 
 
1335 
                printk(KERN_INFO
1336 
                        "%s: PCI BIOS reports AVM-C%d at i/o %#x, irq %d, mem %#x\n",
1337 
                        driver->name, nr, param.port, param.irq, param.membase);
1338 
                retval = c4_add_card(driver, &param, nr);
1339 
                if (retval != 0) {
1340 
                        printk(KERN_ERR
1341 
                        "%s: no AVM-C%d at i/o %#x, irq %d detected, mem %#x\n",
1342 
                        driver->name, nr, param.port, param.irq, param.membase);
1343 
                        continue;
1344 
                }
1345 
                ncards++;
1346 
        }
1347 
        return retval;
1348 
}
1349 
 
1350 
static int __init c4_init(void)
1351 
{
1352 
        int retval;
1353 
 
1354 
        MOD_INC_USE_COUNT;
1355 
 
1356 
        retval = c4_attach_driver (&c4_driver);
1357 
        if (retval) {
1358 
                MOD_DEC_USE_COUNT;
1359 
                return retval;
1360 
        }
1361 
 
1362 
        retval = c4_attach_driver (&c2_driver);
1363 
        if (retval) {
1364 
                MOD_DEC_USE_COUNT;
1365 
                return retval;
1366 
        }
1367 
 
1368 
        retval = search_cards(&c4_driver, PCI_DEVICE_ID_AVM_C4, 4);
1369 
        if (retval && ncards == 0) {
1370 
                detach_capi_driver(&c2_driver);
1371 
                detach_capi_driver(&c4_driver);
1372 
                MOD_DEC_USE_COUNT;
1373 
                return retval;
1374 
        }
1375 
        retval = search_cards(&c2_driver, PCI_DEVICE_ID_AVM_C2, 2);
1376 
        if (retval && ncards == 0) {
1377 
                detach_capi_driver(&c2_driver);
1378 
                detach_capi_driver(&c4_driver);
1379 
                MOD_DEC_USE_COUNT;
1380 
                return retval;
1381 
        }
1382 
 
1383 
        if (ncards) {
1384 
                printk(KERN_INFO "%s: %d C4/C2 card(s) detected\n",
1385 
                                c4_driver.name, ncards);
1386 
                MOD_DEC_USE_COUNT;
1387 
                return 0;
1388 
        }
1389 
        printk(KERN_ERR "%s: NO C4/C2 card detected\n", c4_driver.name);
1390 
        detach_capi_driver(&c4_driver);
1391 
        detach_capi_driver(&c2_driver);
1392 
        MOD_DEC_USE_COUNT;
1393 
        return -ENODEV;
1394 
}
1395 
 
1396 
static void __exit c4_exit(void)
1397 
{
1398 
    detach_capi_driver(&c2_driver);
1399 
    detach_capi_driver(&c4_driver);
1400 
}
1401 
 
1402 
module_init(c4_init);
1403 
module_exit(c4_exit);

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.