drivers/isdn/avmb1/c4.c

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