git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/hardware/avm/b1dma.c

   1 /* $Id: b1dma.c,v 1.1.2.3 2004/02/10 01:07:12 keil Exp $
   2  *
   3  * Common module for AVM B1 cards that support dma with AMCC
   4  *
   5  * Copyright 2000 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/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/delay.h>
  16 #include <linux/mm.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/ioport.h>
  19 #include <linux/capi.h>
  20 #include <linux/kernelcapi.h>
  21 #include <asm/io.h>
  22 #include <linux/init.h>
  23 #include <asm/uaccess.h>
  24 #include <linux/netdevice.h>
  25 #include <linux/isdn/capilli.h>
  26 #include "avmcard.h"
  27 #include <linux/isdn/capicmd.h>
  28 #include <linux/isdn/capiutil.h>
  29
  30 static char *revision = "$Revision: 1.1.2.3 $";
  31
  32 #undef AVM_B1DMA_DEBUG
  33
  34 /* ------------------------------------------------------------- */
  35
  36 MODULE_DESCRIPTION("CAPI4Linux: DMA support for active AVM cards");
  37 MODULE_AUTHOR("Carsten Paeth");
  38 MODULE_LICENSE("GPL");
  39
  40 static int suppress_pollack = 0;
  41 module_param(suppress_pollack, bool, 0);
  42
  43 /* ------------------------------------------------------------- */
  44
  45 static void b1dma_dispatch_tx(avmcard *card);
  46
  47 /* ------------------------------------------------------------- */
  48
  49 /* S5933 */
  50
  51 #define AMCC_RXPTR      0x24
  52 #define AMCC_RXLEN      0x28
  53 #define AMCC_TXPTR      0x2c
  54 #define AMCC_TXLEN      0x30
  55
  56 #define AMCC_INTCSR     0x38
  57 #       define EN_READ_TC_INT           0x00008000L
  58 #       define EN_WRITE_TC_INT          0x00004000L
  59 #       define EN_TX_TC_INT             EN_READ_TC_INT
  60 #       define EN_RX_TC_INT             EN_WRITE_TC_INT
  61 #       define AVM_FLAG                 0x30000000L
  62
  63 #       define ANY_S5933_INT            0x00800000L
  64 #       define READ_TC_INT              0x00080000L
  65 #       define WRITE_TC_INT             0x00040000L
  66 #       define  TX_TC_INT               READ_TC_INT
  67 #       define  RX_TC_INT               WRITE_TC_INT
  68 #       define MASTER_ABORT_INT         0x00100000L
  69 #       define TARGET_ABORT_INT         0x00200000L
  70 #       define BUS_MASTER_INT           0x00200000L
  71 #       define ALL_INT                  0x000C0000L
  72
  73 #define AMCC_MCSR       0x3c
  74 #       define A2P_HI_PRIORITY          0x00000100L
  75 #       define EN_A2P_TRANSFERS         0x00000400L
  76 #       define P2A_HI_PRIORITY          0x00001000L
  77 #       define EN_P2A_TRANSFERS         0x00004000L
  78 #       define RESET_A2P_FLAGS          0x04000000L
  79 #       define RESET_P2A_FLAGS          0x02000000L
  80
  81 /* ------------------------------------------------------------- */
  82
  83 static inline void b1dma_writel(avmcard *card, u32 value, int off)
  84 {
  85         writel(value, card->mbase + off);
  86 }
  87
  88 static inline u32 b1dma_readl(avmcard *card, int off)
  89 {
  90         return readl(card->mbase + off);
  91 }
  92
  93 /* ------------------------------------------------------------- */
  94
  95 static inline int b1dma_tx_empty(unsigned int port)
  96 {
  97         return inb(port + 0x03) & 0x1;
  98 }
  99
 100 static inline int b1dma_rx_full(unsigned int port)
 101 {
 102         return inb(port + 0x02) & 0x1;
 103 }
 104
 105 static int b1dma_tolink(avmcard *card, void *buf, unsigned int len)
 106 {
 107         unsigned long stop = jiffies + 1 * HZ;  /* maximum wait time 1 sec */
 108         unsigned char *s = (unsigned char *)buf;
 109         while (len--) {
 110                 while (   !b1dma_tx_empty(card->port)
 111                        && time_before(jiffies, stop));
 112                 if (!b1dma_tx_empty(card->port))
 113                         return -1;
 114                 t1outp(card->port, 0x01, *s++);
 115         }
 116         return 0;
 117 }
 118
 119 static int b1dma_fromlink(avmcard *card, void *buf, unsigned int len)
 120 {
 121         unsigned long stop = jiffies + 1 * HZ;  /* maximum wait time 1 sec */
 122         unsigned char *s = (unsigned char *)buf;
 123         while (len--) {
 124                 while (   !b1dma_rx_full(card->port)
 125                        && time_before(jiffies, stop));
 126                 if (!b1dma_rx_full(card->port))
 127                         return -1;
 128                 *s++ = t1inp(card->port, 0x00);
 129         }
 130         return 0;
 131 }
 132
 133 static int WriteReg(avmcard *card, u32 reg, u8 val)
 134 {
 135         u8 cmd = 0x00;
 136         if (   b1dma_tolink(card, &cmd, 1) == 0
 137             && b1dma_tolink(card, &reg, 4) == 0) {
 138                 u32 tmp = val;
 139                 return b1dma_tolink(card, &tmp, 4);
 140         }
 141         return -1;
 142 }
 143
 144 static u8 ReadReg(avmcard *card, u32 reg)
 145 {
 146         u8 cmd = 0x01;
 147         if (   b1dma_tolink(card, &cmd, 1) == 0
 148             && b1dma_tolink(card, &reg, 4) == 0) {
 149                 u32 tmp;
 150                 if (b1dma_fromlink(card, &tmp, 4) == 0)
 151                         return (u8)tmp;
 152         }
 153         return 0xff;
 154 }
 155
 156 /* ------------------------------------------------------------- */
 157
 158 static inline void _put_byte(void **pp, u8 val)
 159 {
 160         u8 *s = *pp;
 161         *s++ = val;
 162         *pp = s;
 163 }
 164
 165 static inline void _put_word(void **pp, u32 val)
 166 {
 167         u8 *s = *pp;
 168         *s++ = val & 0xff;
 169         *s++ = (val >> 8) & 0xff;
 170         *s++ = (val >> 16) & 0xff;
 171         *s++ = (val >> 24) & 0xff;
 172         *pp = s;
 173 }
 174
 175 static inline void _put_slice(void **pp, unsigned char *dp, unsigned int len)
 176 {
 177         unsigned i = len;
 178         _put_word(pp, i);
 179         while (i-- > 0)
 180                 _put_byte(pp, *dp++);
 181 }
 182
 183 static inline u8 _get_byte(void **pp)
 184 {
 185         u8 *s = *pp;
 186         u8 val;
 187         val = *s++;
 188         *pp = s;
 189         return val;
 190 }
 191
 192 static inline u32 _get_word(void **pp)
 193 {
 194         u8 *s = *pp;
 195         u32 val;
 196         val = *s++;
 197         val |= (*s++ << 8);
 198         val |= (*s++ << 16);
 199         val |= (*s++ << 24);
 200         *pp = s;
 201         return val;
 202 }
 203
 204 static inline u32 _get_slice(void **pp, unsigned char *dp)
 205 {
 206         unsigned int len, i;
 207
 208         len = i = _get_word(pp);
 209         while (i-- > 0) *dp++ = _get_byte(pp);
 210         return len;
 211 }
 212
 213 /* ------------------------------------------------------------- */
 214
 215 void b1dma_reset(avmcard *card)
 216 {
 217         card->csr = 0x0;
 218         b1dma_writel(card, card->csr, AMCC_INTCSR);
 219         b1dma_writel(card, 0, AMCC_MCSR);
 220         b1dma_writel(card, 0, AMCC_RXLEN);
 221         b1dma_writel(card, 0, AMCC_TXLEN);
 222
 223         t1outp(card->port, 0x10, 0x00);
 224         t1outp(card->port, 0x07, 0x00);
 225
 226         b1dma_writel(card, 0, AMCC_MCSR);
 227         mdelay(10);
 228         b1dma_writel(card, 0x0f000000, AMCC_MCSR); /* reset all */
 229         mdelay(10);
 230         b1dma_writel(card, 0, AMCC_MCSR);
 231         if (card->cardtype == avm_t1pci)
 232                 mdelay(42);
 233         else
 234                 mdelay(10);
 235 }
 236
 237 /* ------------------------------------------------------------- */
 238
 239 static int b1dma_detect(avmcard *card)
 240 {
 241         b1dma_writel(card, 0, AMCC_MCSR);
 242         mdelay(10);
 243         b1dma_writel(card, 0x0f000000, AMCC_MCSR); /* reset all */
 244         mdelay(10);
 245         b1dma_writel(card, 0, AMCC_MCSR);
 246         mdelay(42);
 247
 248         b1dma_writel(card, 0, AMCC_RXLEN);
 249         b1dma_writel(card, 0, AMCC_TXLEN);
 250         card->csr = 0x0;
 251         b1dma_writel(card, card->csr, AMCC_INTCSR);
 252
 253         if (b1dma_readl(card, AMCC_MCSR) != 0x000000E6)
 254                 return 1;
 255
 256         b1dma_writel(card, 0xffffffff, AMCC_RXPTR);
 257         b1dma_writel(card, 0xffffffff, AMCC_TXPTR);
 258         if (   b1dma_readl(card, AMCC_RXPTR) != 0xfffffffc
 259             || b1dma_readl(card, AMCC_TXPTR) != 0xfffffffc)
 260                 return 2;
 261
 262         b1dma_writel(card, 0x0, AMCC_RXPTR);
 263         b1dma_writel(card, 0x0, AMCC_TXPTR);
 264         if (   b1dma_readl(card, AMCC_RXPTR) != 0x0
 265             || b1dma_readl(card, AMCC_TXPTR) != 0x0)
 266                 return 3;
 267
 268         t1outp(card->port, 0x10, 0x00);
 269         t1outp(card->port, 0x07, 0x00);
 270
 271         t1outp(card->port, 0x02, 0x02);
 272         t1outp(card->port, 0x03, 0x02);
 273
 274         if (   (t1inp(card->port, 0x02) & 0xFE) != 0x02
 275             || t1inp(card->port, 0x3) != 0x03)
 276                 return 4;
 277
 278         t1outp(card->port, 0x02, 0x00);
 279         t1outp(card->port, 0x03, 0x00);
 280
 281         if (   (t1inp(card->port, 0x02) & 0xFE) != 0x00
 282             || t1inp(card->port, 0x3) != 0x01)
 283                 return 5;
 284
 285         return 0;
 286 }
 287
 288 int t1pci_detect(avmcard *card)
 289 {
 290         int ret;
 291
 292         if ((ret = b1dma_detect(card)) != 0)
 293                 return ret;
 294
 295         /* Transputer test */
 296
 297         if (   WriteReg(card, 0x80001000, 0x11) != 0
 298             || WriteReg(card, 0x80101000, 0x22) != 0
 299             || WriteReg(card, 0x80201000, 0x33) != 0
 300             || WriteReg(card, 0x80301000, 0x44) != 0)
 301                 return 6;
 302
 303         if (   ReadReg(card, 0x80001000) != 0x11
 304             || ReadReg(card, 0x80101000) != 0x22
 305             || ReadReg(card, 0x80201000) != 0x33
 306             || ReadReg(card, 0x80301000) != 0x44)
 307                 return 7;
 308
 309         if (   WriteReg(card, 0x80001000, 0x55) != 0
 310             || WriteReg(card, 0x80101000, 0x66) != 0
 311             || WriteReg(card, 0x80201000, 0x77) != 0
 312             || WriteReg(card, 0x80301000, 0x88) != 0)
 313                 return 8;
 314
 315         if (   ReadReg(card, 0x80001000) != 0x55
 316             || ReadReg(card, 0x80101000) != 0x66
 317             || ReadReg(card, 0x80201000) != 0x77
 318             || ReadReg(card, 0x80301000) != 0x88)
 319                 return 9;
 320
 321         return 0;
 322 }
 323
 324 int b1pciv4_detect(avmcard *card)
 325 {
 326         int ret, i;
 327
 328         if ((ret = b1dma_detect(card)) != 0)
 329                 return ret;
 330
 331         for (i=0; i < 5 ; i++) {
 332                 if (WriteReg(card, 0x80A00000, 0x21) != 0)
 333                         return 6;
 334                 if ((ReadReg(card, 0x80A00000) & 0x01) != 0x01)
 335                         return 7;
 336         }
 337         for (i=0; i < 5 ; i++) {
 338                 if (WriteReg(card, 0x80A00000, 0x20) != 0)
 339                         return 8;
 340                 if ((ReadReg(card, 0x80A00000) & 0x01) != 0x00)
 341                         return 9;
 342         }
 343
 344         return 0;
 345 }
 346
 347 static void b1dma_queue_tx(avmcard *card, struct sk_buff *skb)
 348 {
 349         unsigned long flags;
 350
 351         spin_lock_irqsave(&card->lock, flags);
 352
 353         skb_queue_tail(&card->dma->send_queue, skb);
 354
 355         if (!(card->csr & EN_TX_TC_INT)) {
 356                 b1dma_dispatch_tx(card);
 357                 b1dma_writel(card, card->csr, AMCC_INTCSR);
 358         }
 359
 360         spin_unlock_irqrestore(&card->lock, flags);
 361 }
 362
 363 /* ------------------------------------------------------------- */
 364
 365 static void b1dma_dispatch_tx(avmcard *card)
 366 {
 367         avmcard_dmainfo *dma = card->dma;
 368         struct sk_buff *skb;
 369         u8 cmd, subcmd;
 370         u16 len;
 371         u32 txlen;
 372         void *p;
 373
 374         skb = skb_dequeue(&dma->send_queue);
 375
 376         len = CAPIMSG_LEN(skb->data);
 377
 378         if (len) {
 379                 cmd = CAPIMSG_COMMAND(skb->data);
 380                 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 381
 382                 p = dma->sendbuf.dmabuf;
 383
 384                 if (CAPICMD(cmd, subcmd) == CAPI_DATA_B3_REQ) {
 385                         u16 dlen = CAPIMSG_DATALEN(skb->data);
 386                         _put_byte(&p, SEND_DATA_B3_REQ);
 387                         _put_slice(&p, skb->data, len);
 388                         _put_slice(&p, skb->data + len, dlen);
 389                 } else {
 390                         _put_byte(&p, SEND_MESSAGE);
 391                         _put_slice(&p, skb->data, len);
 392                 }
 393                 txlen = (u8 *)p - (u8 *)dma->sendbuf.dmabuf;
 394 #ifdef AVM_B1DMA_DEBUG
 395                 printk(KERN_DEBUG "tx: put msg len=%d\n", txlen);
 396 #endif
 397         } else {
 398                 txlen = skb->len-2;
 399 #ifdef AVM_B1DMA_POLLDEBUG
 400                 if (skb->data[2] == SEND_POLLACK)
 401                         printk(KERN_INFO "%s: send ack\n", card->name);
 402 #endif
 403 #ifdef AVM_B1DMA_DEBUG
 404                 printk(KERN_DEBUG "tx: put 0x%x len=%d\n",
 405                        skb->data[2], txlen);
 406 #endif
 407                 skb_copy_from_linear_data_offset(skb, 2, dma->sendbuf.dmabuf,
 408                                                  skb->len - 2);
 409         }
 410         txlen = (txlen + 3) & ~3;
 411
 412         b1dma_writel(card, dma->sendbuf.dmaaddr, AMCC_TXPTR);
 413         b1dma_writel(card, txlen, AMCC_TXLEN);
 414
 415         card->csr |= EN_TX_TC_INT;
 416
 417         dev_kfree_skb_any(skb);
 418 }
 419
 420 /* ------------------------------------------------------------- */
 421
 422 static void queue_pollack(avmcard *card)
 423 {
 424         struct sk_buff *skb;
 425         void *p;
 426
 427         skb = alloc_skb(3, GFP_ATOMIC);
 428         if (!skb) {
 429                 printk(KERN_CRIT "%s: no memory, lost poll ack\n",
 430                                         card->name);
 431                 return;
 432         }
 433         p = skb->data;
 434         _put_byte(&p, 0);
 435         _put_byte(&p, 0);
 436         _put_byte(&p, SEND_POLLACK);
 437         skb_put(skb, (u8 *)p - (u8 *)skb->data);
 438
 439         b1dma_queue_tx(card, skb);
 440 }
 441
 442 /* ------------------------------------------------------------- */
 443
 444 static void b1dma_handle_rx(avmcard *card)
 445 {
 446         avmctrl_info *cinfo = &card->ctrlinfo[0];
 447         avmcard_dmainfo *dma = card->dma;
 448         struct capi_ctr *ctrl = &cinfo->capi_ctrl;
 449         struct sk_buff *skb;
 450         void *p = dma->recvbuf.dmabuf+4;
 451         u32 ApplId, MsgLen, DataB3Len, NCCI, WindowSize;
 452         u8 b1cmd =  _get_byte(&p);
 453
 454 #ifdef AVM_B1DMA_DEBUG
 455         printk(KERN_DEBUG "rx: 0x%x %lu\n", b1cmd, (unsigned long)dma->recvlen);
 456 #endif
 457
 458         switch (b1cmd) {
 459         case RECEIVE_DATA_B3_IND:
 460
 461                 ApplId = (unsigned) _get_word(&p);
 462                 MsgLen = _get_slice(&p, card->msgbuf);
 463                 DataB3Len = _get_slice(&p, card->databuf);
 464
 465                 if (MsgLen < 30) { /* not CAPI 64Bit */
 466                         memset(card->msgbuf+MsgLen, 0, 30-MsgLen);
 467                         MsgLen = 30;
 468                         CAPIMSG_SETLEN(card->msgbuf, 30);
 469                 }
 470                 if (!(skb = alloc_skb(DataB3Len+MsgLen, GFP_ATOMIC))) {
 471                         printk(KERN_ERR "%s: incoming packet dropped\n",
 472                                         card->name);
 473                 } else {
 474                         memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
 475                         memcpy(skb_put(skb, DataB3Len), card->databuf, DataB3Len);
 476                         capi_ctr_handle_message(ctrl, ApplId, skb);
 477                 }
 478                 break;
 479
 480         case RECEIVE_MESSAGE:
 481
 482                 ApplId = (unsigned) _get_word(&p);
 483                 MsgLen = _get_slice(&p, card->msgbuf);
 484                 if (!(skb = alloc_skb(MsgLen, GFP_ATOMIC))) {
 485                         printk(KERN_ERR "%s: incoming packet dropped\n",
 486                                         card->name);
 487                 } else {
 488                         memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
 489                         if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_CONF)
 490                                 capilib_data_b3_conf(&cinfo->ncci_head, ApplId,
 491                                                      CAPIMSG_NCCI(skb->data),
 492                                                      CAPIMSG_MSGID(skb->data));
 493
 494                         capi_ctr_handle_message(ctrl, ApplId, skb);
 495                 }
 496                 break;
 497
 498         case RECEIVE_NEW_NCCI:
 499
 500                 ApplId = _get_word(&p);
 501                 NCCI = _get_word(&p);
 502                 WindowSize = _get_word(&p);
 503
 504                 capilib_new_ncci(&cinfo->ncci_head, ApplId, NCCI, WindowSize);
 505
 506                 break;
 507
 508         case RECEIVE_FREE_NCCI:
 509
 510                 ApplId = _get_word(&p);
 511                 NCCI = _get_word(&p);
 512
 513                 if (NCCI != 0xffffffff)
 514                         capilib_free_ncci(&cinfo->ncci_head, ApplId, NCCI);
 515
 516                 break;
 517
 518         case RECEIVE_START:
 519 #ifdef AVM_B1DMA_POLLDEBUG
 520                 printk(KERN_INFO "%s: receive poll\n", card->name);
 521 #endif
 522                 if (!suppress_pollack)
 523                         queue_pollack(card);
 524                 capi_ctr_resume_output(ctrl);
 525                 break;
 526
 527         case RECEIVE_STOP:
 528                 capi_ctr_suspend_output(ctrl);
 529                 break;
 530
 531         case RECEIVE_INIT:
 532
 533                 cinfo->versionlen = _get_slice(&p, cinfo->versionbuf);
 534                 b1_parse_version(cinfo);
 535                 printk(KERN_INFO "%s: %s-card (%s) now active\n",
 536                        card->name,
 537                        cinfo->version[VER_CARDTYPE],
 538                        cinfo->version[VER_DRIVER]);
 539                 capi_ctr_ready(ctrl);
 540                 break;
 541
 542         case RECEIVE_TASK_READY:
 543                 ApplId = (unsigned) _get_word(&p);
 544                 MsgLen = _get_slice(&p, card->msgbuf);
 545                 card->msgbuf[MsgLen] = 0;
 546                 while (    MsgLen > 0
 547                        && (   card->msgbuf[MsgLen-1] == '\n'
 548                            || card->msgbuf[MsgLen-1] == '\r')) {
 549                         card->msgbuf[MsgLen-1] = 0;
 550                         MsgLen--;
 551                 }
 552                 printk(KERN_INFO "%s: task %d \"%s\" ready.\n",
 553                                 card->name, ApplId, card->msgbuf);
 554                 break;
 555
 556         case RECEIVE_DEBUGMSG:
 557                 MsgLen = _get_slice(&p, card->msgbuf);
 558                 card->msgbuf[MsgLen] = 0;
 559                 while (    MsgLen > 0
 560                        && (   card->msgbuf[MsgLen-1] == '\n'
 561                            || card->msgbuf[MsgLen-1] == '\r')) {
 562                         card->msgbuf[MsgLen-1] = 0;
 563                         MsgLen--;
 564                 }
 565                 printk(KERN_INFO "%s: DEBUG: %s\n", card->name, card->msgbuf);
 566                 break;
 567
 568         default:
 569                 printk(KERN_ERR "%s: b1dma_interrupt: 0x%x ???\n",
 570                                 card->name, b1cmd);
 571                 return;
 572         }
 573 }
 574
 575 /* ------------------------------------------------------------- */
 576
 577 static void b1dma_handle_interrupt(avmcard *card)
 578 {
 579         u32 status;
 580         u32 newcsr;
 581
 582         spin_lock(&card->lock);
 583
 584         status = b1dma_readl(card, AMCC_INTCSR);
 585         if ((status & ANY_S5933_INT) == 0) {
 586                 spin_unlock(&card->lock);
 587                 return;
 588         }
 589
 590         newcsr = card->csr | (status & ALL_INT);
 591         if (status & TX_TC_INT) newcsr &= ~EN_TX_TC_INT;
 592         if (status & RX_TC_INT) newcsr &= ~EN_RX_TC_INT;
 593         b1dma_writel(card, newcsr, AMCC_INTCSR);
 594
 595         if ((status & RX_TC_INT) != 0) {
 596                 struct avmcard_dmainfo *dma = card->dma;
 597                 u32 rxlen;
 598                 if (card->dma->recvlen == 0) {
 599                         rxlen = b1dma_readl(card, AMCC_RXLEN);
 600                         if (rxlen == 0) {
 601                                 dma->recvlen = *((u32 *)dma->recvbuf.dmabuf);
 602                                 rxlen = (dma->recvlen + 3) & ~3;
 603                                 b1dma_writel(card, dma->recvbuf.dmaaddr+4, AMCC_RXPTR);
 604                                 b1dma_writel(card, rxlen, AMCC_RXLEN);
 605 #ifdef AVM_B1DMA_DEBUG
 606                         } else {
 607                                 printk(KERN_ERR "%s: rx not complete (%d).\n",
 608                                         card->name, rxlen);
 609 #endif
 610                         }
 611                 } else {
 612                         spin_unlock(&card->lock);
 613                         b1dma_handle_rx(card);
 614                         dma->recvlen = 0;
 615                         spin_lock(&card->lock);
 616                         b1dma_writel(card, dma->recvbuf.dmaaddr, AMCC_RXPTR);
 617                         b1dma_writel(card, 4, AMCC_RXLEN);
 618                 }
 619         }
 620
 621         if ((status & TX_TC_INT) != 0) {
 622                 if (skb_queue_empty(&card->dma->send_queue))
 623                         card->csr &= ~EN_TX_TC_INT;
 624                 else
 625                         b1dma_dispatch_tx(card);
 626         }
 627         b1dma_writel(card, card->csr, AMCC_INTCSR);
 628
 629         spin_unlock(&card->lock);
 630 }
 631
 632 irqreturn_t b1dma_interrupt(int interrupt, void *devptr)
 633 {
 634         avmcard *card = devptr;
 635
 636         b1dma_handle_interrupt(card);
 637         return IRQ_HANDLED;
 638 }
 639
 640 /* ------------------------------------------------------------- */
 641
 642 static int b1dma_loaded(avmcard *card)
 643 {
 644         unsigned long stop;
 645         unsigned char ans;
 646         unsigned long tout = 2;
 647         unsigned int base = card->port;
 648
 649         for (stop = jiffies + tout * HZ; time_before(jiffies, stop);) {
 650                 if (b1_tx_empty(base))
 651                         break;
 652         }
 653         if (!b1_tx_empty(base)) {
 654                 printk(KERN_ERR "%s: b1dma_loaded: tx err, corrupted t4 file ?\n",
 655                                 card->name);
 656                 return 0;
 657         }
 658         b1_put_byte(base, SEND_POLLACK);
 659         for (stop = jiffies + tout * HZ; time_before(jiffies, stop);) {
 660                 if (b1_rx_full(base)) {
 661                         if ((ans = b1_get_byte(base)) == RECEIVE_POLLDWORD) {
 662                                 return 1;
 663                         }
 664                         printk(KERN_ERR "%s: b1dma_loaded: got 0x%x, firmware not running in dword mode\n", card->name, ans);
 665                         return 0;
 666                 }
 667         }
 668         printk(KERN_ERR "%s: b1dma_loaded: firmware not running\n", card->name);
 669         return 0;
 670 }
 671
 672 /* ------------------------------------------------------------- */
 673
 674 static void b1dma_send_init(avmcard *card)
 675 {
 676         struct sk_buff *skb;
 677         void *p;
 678
 679         skb = alloc_skb(15, GFP_ATOMIC);
 680         if (!skb) {
 681                 printk(KERN_CRIT "%s: no memory, lost register appl.\n",
 682                                         card->name);
 683                 return;
 684         }
 685         p = skb->data;
 686         _put_byte(&p, 0);
 687         _put_byte(&p, 0);
 688         _put_byte(&p, SEND_INIT);
 689         _put_word(&p, CAPI_MAXAPPL);
 690         _put_word(&p, AVM_NCCI_PER_CHANNEL*30);
 691         _put_word(&p, card->cardnr - 1);
 692         skb_put(skb, (u8 *)p - (u8 *)skb->data);
 693
 694         b1dma_queue_tx(card, skb);
 695 }
 696
 697 int b1dma_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
 698 {
 699         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 700         avmcard *card = cinfo->card;
 701         int retval;
 702
 703         b1dma_reset(card);
 704
 705         if ((retval = b1_load_t4file(card, &data->firmware))) {
 706                 b1dma_reset(card);
 707                 printk(KERN_ERR "%s: failed to load t4file!!\n",
 708                                         card->name);
 709                 return retval;
 710         }
 711
 712         if (data->configuration.len > 0 && data->configuration.data) {
 713                 if ((retval = b1_load_config(card, &data->configuration))) {
 714                         b1dma_reset(card);
 715                         printk(KERN_ERR "%s: failed to load config!!\n",
 716                                         card->name);
 717                         return retval;
 718                 }
 719         }
 720
 721         if (!b1dma_loaded(card)) {
 722                 b1dma_reset(card);
 723                 printk(KERN_ERR "%s: failed to load t4file.\n", card->name);
 724                 return -EIO;
 725         }
 726
 727         card->csr = AVM_FLAG;
 728         b1dma_writel(card, card->csr, AMCC_INTCSR);
 729         b1dma_writel(card, EN_A2P_TRANSFERS|EN_P2A_TRANSFERS|A2P_HI_PRIORITY|
 730                      P2A_HI_PRIORITY|RESET_A2P_FLAGS|RESET_P2A_FLAGS,
 731                      AMCC_MCSR);
 732         t1outp(card->port, 0x07, 0x30);
 733         t1outp(card->port, 0x10, 0xF0);
 734
 735         card->dma->recvlen = 0;
 736         b1dma_writel(card, card->dma->recvbuf.dmaaddr, AMCC_RXPTR);
 737         b1dma_writel(card, 4, AMCC_RXLEN);
 738         card->csr |= EN_RX_TC_INT;
 739         b1dma_writel(card, card->csr, AMCC_INTCSR);
 740
 741         b1dma_send_init(card);
 742
 743         return 0;
 744 }
 745
 746 void b1dma_reset_ctr(struct capi_ctr *ctrl)
 747 {
 748         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 749         avmcard *card = cinfo->card;
 750         unsigned long flags;
 751
 752         spin_lock_irqsave(&card->lock, flags);
 753         b1dma_reset(card);
 754         spin_unlock_irqrestore(&card->lock, flags);
 755
 756         memset(cinfo->version, 0, sizeof(cinfo->version));
 757         capilib_release(&cinfo->ncci_head);
 758         capi_ctr_reseted(ctrl);
 759 }
 760
 761 /* ------------------------------------------------------------- */
 762
 763 void b1dma_register_appl(struct capi_ctr *ctrl,
 764                                 u16 appl,
 765                                 capi_register_params *rp)
 766 {
 767         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 768         avmcard *card = cinfo->card;
 769         struct sk_buff *skb;
 770         int want = rp->level3cnt;
 771         int nconn;
 772         void *p;
 773
 774         if (want > 0) nconn = want;
 775         else nconn = ctrl->profile.nbchannel * -want;
 776         if (nconn == 0) nconn = ctrl->profile.nbchannel;
 777
 778         skb = alloc_skb(23, GFP_ATOMIC);
 779         if (!skb) {
 780                 printk(KERN_CRIT "%s: no memory, lost register appl.\n",
 781                                         card->name);
 782                 return;
 783         }
 784         p = skb->data;
 785         _put_byte(&p, 0);
 786         _put_byte(&p, 0);
 787         _put_byte(&p, SEND_REGISTER);
 788         _put_word(&p, appl);
 789         _put_word(&p, 1024 * (nconn+1));
 790         _put_word(&p, nconn);
 791         _put_word(&p, rp->datablkcnt);
 792         _put_word(&p, rp->datablklen);
 793         skb_put(skb, (u8 *)p - (u8 *)skb->data);
 794
 795         b1dma_queue_tx(card, skb);
 796 }
 797
 798 /* ------------------------------------------------------------- */
 799
 800 void b1dma_release_appl(struct capi_ctr *ctrl, u16 appl)
 801 {
 802         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 803         avmcard *card = cinfo->card;
 804         struct sk_buff *skb;
 805         void *p;
 806
 807         capilib_release_appl(&cinfo->ncci_head, appl);
 808
 809         skb = alloc_skb(7, GFP_ATOMIC);
 810         if (!skb) {
 811                 printk(KERN_CRIT "%s: no memory, lost release appl.\n",
 812                                         card->name);
 813                 return;
 814         }
 815         p = skb->data;
 816         _put_byte(&p, 0);
 817         _put_byte(&p, 0);
 818         _put_byte(&p, SEND_RELEASE);
 819         _put_word(&p, appl);
 820
 821         skb_put(skb, (u8 *)p - (u8 *)skb->data);
 822
 823         b1dma_queue_tx(card, skb);
 824 }
 825
 826 /* ------------------------------------------------------------- */
 827
 828 u16 b1dma_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
 829 {
 830         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 831         avmcard *card = cinfo->card;
 832         u16 retval = CAPI_NOERROR;
 833
 834         if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_REQ) {
 835                 retval = capilib_data_b3_req(&cinfo->ncci_head,
 836                                              CAPIMSG_APPID(skb->data),
 837                                              CAPIMSG_NCCI(skb->data),
 838                                              CAPIMSG_MSGID(skb->data));
 839         }
 840         if (retval == CAPI_NOERROR)
 841                 b1dma_queue_tx(card, skb);
 842
 843         return retval;
 844 }
 845
 846 /* ------------------------------------------------------------- */
 847
 848 int b1dmactl_read_proc(char *page, char **start, off_t off,
 849                         int count, int *eof, struct capi_ctr *ctrl)
 850 {
 851         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 852         avmcard *card = cinfo->card;
 853         u8 flag;
 854         int len = 0;
 855         char *s;
 856         u32 txoff, txlen, rxoff, rxlen, csr;
 857         unsigned long flags;
 858
 859         len += sprintf(page+len, "%-16s %s\n", "name", card->name);
 860         len += sprintf(page+len, "%-16s 0x%x\n", "io", card->port);
 861         len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
 862         len += sprintf(page+len, "%-16s 0x%lx\n", "membase", card->membase);
 863         switch (card->cardtype) {
 864         case avm_b1isa: s = "B1 ISA"; break;
 865         case avm_b1pci: s = "B1 PCI"; break;
 866         case avm_b1pcmcia: s = "B1 PCMCIA"; break;
 867         case avm_m1: s = "M1"; break;
 868         case avm_m2: s = "M2"; break;
 869         case avm_t1isa: s = "T1 ISA (HEMA)"; break;
 870         case avm_t1pci: s = "T1 PCI"; break;
 871         case avm_c4: s = "C4"; break;
 872         case avm_c2: s = "C2"; break;
 873         default: s = "???"; break;
 874         }
 875         len += sprintf(page+len, "%-16s %s\n", "type", s);
 876         if ((s = cinfo->version[VER_DRIVER]) != 0)
 877            len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
 878         if ((s = cinfo->version[VER_CARDTYPE]) != 0)
 879            len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
 880         if ((s = cinfo->version[VER_SERIAL]) != 0)
 881            len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
 882
 883         if (card->cardtype != avm_m1) {
 884                 flag = ((u8 *)(ctrl->profile.manu))[3];
 885                 if (flag)
 886                         len += sprintf(page+len, "%-16s%s%s%s%s%s%s%s\n",
 887                         "protocol",
 888                         (flag & 0x01) ? " DSS1" : "",
 889                         (flag & 0x02) ? " CT1" : "",
 890                         (flag & 0x04) ? " VN3" : "",
 891                         (flag & 0x08) ? " NI1" : "",
 892                         (flag & 0x10) ? " AUSTEL" : "",
 893                         (flag & 0x20) ? " ESS" : "",
 894                         (flag & 0x40) ? " 1TR6" : ""
 895                         );
 896         }
 897         if (card->cardtype != avm_m1) {
 898                 flag = ((u8 *)(ctrl->profile.manu))[5];
 899                 if (flag)
 900                         len += sprintf(page+len, "%-16s%s%s%s%s\n",
 901                         "linetype",
 902                         (flag & 0x01) ? " point to point" : "",
 903                         (flag & 0x02) ? " point to multipoint" : "",
 904                         (flag & 0x08) ? " leased line without D-channel" : "",
 905                         (flag & 0x04) ? " leased line with D-channel" : ""
 906                         );
 907         }
 908         len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
 909
 910
 911         spin_lock_irqsave(&card->lock, flags);
 912
 913         txoff = (dma_addr_t)b1dma_readl(card, AMCC_TXPTR)-card->dma->sendbuf.dmaaddr;
 914         txlen = b1dma_readl(card, AMCC_TXLEN);
 915
 916         rxoff = (dma_addr_t)b1dma_readl(card, AMCC_RXPTR)-card->dma->recvbuf.dmaaddr;
 917         rxlen = b1dma_readl(card, AMCC_RXLEN);
 918
 919         csr  = b1dma_readl(card, AMCC_INTCSR);
 920
 921         spin_unlock_irqrestore(&card->lock, flags);
 922
 923         len += sprintf(page+len, "%-16s 0x%lx\n",
 924                                 "csr (cached)", (unsigned long)card->csr);
 925         len += sprintf(page+len, "%-16s 0x%lx\n",
 926                                 "csr", (unsigned long)csr);
 927         len += sprintf(page+len, "%-16s %lu\n",
 928                                 "txoff", (unsigned long)txoff);
 929         len += sprintf(page+len, "%-16s %lu\n",
 930                                 "txlen", (unsigned long)txlen);
 931         len += sprintf(page+len, "%-16s %lu\n",
 932                                 "rxoff", (unsigned long)rxoff);
 933         len += sprintf(page+len, "%-16s %lu\n",
 934                                 "rxlen", (unsigned long)rxlen);
 935
 936         if (off+count >= len)
 937            *eof = 1;
 938         if (len < off)
 939            return 0;
 940         *start = page + off;
 941         return ((count < len-off) ? count : len-off);
 942 }
 943
 944 /* ------------------------------------------------------------- */
 945
 946 EXPORT_SYMBOL(b1dma_reset);
 947 EXPORT_SYMBOL(t1pci_detect);
 948 EXPORT_SYMBOL(b1pciv4_detect);
 949 EXPORT_SYMBOL(b1dma_interrupt);
 950
 951 EXPORT_SYMBOL(b1dma_load_firmware);
 952 EXPORT_SYMBOL(b1dma_reset_ctr);
 953 EXPORT_SYMBOL(b1dma_register_appl);
 954 EXPORT_SYMBOL(b1dma_release_appl);
 955 EXPORT_SYMBOL(b1dma_send_message);
 956 EXPORT_SYMBOL(b1dmactl_read_proc);
 957
 958 static int __init b1dma_init(void)
 959 {
 960         char *p;
 961         char rev[32];
 962
 963         if ((p = strchr(revision, ':')) != 0 && p[1]) {
 964                 strlcpy(rev, p + 2, sizeof(rev));
 965                 if ((p = strchr(rev, '$')) != 0 && p > rev)
 966                    *(p-1) = 0;
 967         } else
 968                 strcpy(rev, "1.0");
 969
 970         printk(KERN_INFO "b1dma: revision %s\n", rev);
 971
 972         return 0;
 973 }
 974
 975 static void __exit b1dma_exit(void)
 976 {
 977 }
 978
 979 module_init(b1dma_init);
 980 module_exit(b1dma_exit);