drivers/isdn/avmb1/c4.c

   1 /* $Id: c4.c,v 1.1.1.1 2005/04/11 02:50:22 jack 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);