1/* $Id: b1dma.c,v 1.1.1.1 2007/08/03 18:52:34 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 30static char *revision = "$Revision: 1.1.1.1 $"; 31 32#undef AVM_B1DMA_DEBUG 33 34/* ------------------------------------------------------------- */ 35 36MODULE_DESCRIPTION("CAPI4Linux: DMA support for active AVM cards"); 37MODULE_AUTHOR("Carsten Paeth"); 38MODULE_LICENSE("GPL"); 39 40static int suppress_pollack = 0; 41module_param(suppress_pollack, bool, 0); 42 43/* ------------------------------------------------------------- */ 44 45static 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 83static inline void b1dma_writel(avmcard *card, u32 value, int off) 84{ 85 writel(value, card->mbase + off); 86} 87 88static inline u32 b1dma_readl(avmcard *card, int off) 89{ 90 return readl(card->mbase + off); 91} 92 93/* ------------------------------------------------------------- */ 94 95static inline int b1dma_tx_empty(unsigned int port) 96{ 97 return inb(port + 0x03) & 0x1; 98} 99 100static inline int b1dma_rx_full(unsigned int port) 101{ 102 return inb(port + 0x02) & 0x1; 103} 104 105static 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 119static 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 133static 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, ®, 4) == 0) { 138 u32 tmp = val; 139 return b1dma_tolink(card, &tmp, 4); 140 } 141 return -1; 142} 143 144static u8 ReadReg(avmcard *card, u32 reg) 145{ 146 u8 cmd = 0x01; 147 if ( b1dma_tolink(card, &cmd, 1) == 0 148 && b1dma_tolink(card, ®, 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 158static inline void _put_byte(void **pp, u8 val) 159{ 160 u8 *s = *pp; 161 *s++ = val; 162 *pp = s; 163} 164 165static 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 175static 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 183static 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 192static 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 204static 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 215void 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 239static 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 288int 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 324int 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 347static 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 365static 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 422static 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 444static 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 577static 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 632irqreturn_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 642static 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 674static 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 697int 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 746void 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 763void 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 800void 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 828u16 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 848int 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 946EXPORT_SYMBOL(b1dma_reset); 947EXPORT_SYMBOL(t1pci_detect); 948EXPORT_SYMBOL(b1pciv4_detect); 949EXPORT_SYMBOL(b1dma_interrupt); 950 951EXPORT_SYMBOL(b1dma_load_firmware); 952EXPORT_SYMBOL(b1dma_reset_ctr); 953EXPORT_SYMBOL(b1dma_register_appl); 954EXPORT_SYMBOL(b1dma_release_appl); 955EXPORT_SYMBOL(b1dma_send_message); 956EXPORT_SYMBOL(b1dmactl_read_proc); 957 958static 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 975static void __exit b1dma_exit(void) 976{ 977} 978 979module_init(b1dma_init); 980module_exit(b1dma_exit); 981