1/* 2 * PCBIT-D interface with isdn4linux 3 * 4 * Copyright (C) 1996 Universidade de Lisboa 5 * 6 * Written by Pedro Roque Marques (roque@di.fc.ul.pt) 7 * 8 * This software may be used and distributed according to the terms of 9 * the GNU General Public License, incorporated herein by reference. 10 */ 11 12/* 13 * Fixes: 14 * 15 * Nuno Grilo <l38486@alfa.ist.utl.pt> 16 * fixed msn_list NULL pointer dereference. 17 * 18 */ 19 20#include <linux/module.h> 21 22 23#include <linux/kernel.h> 24 25#include <linux/types.h> 26#include <linux/slab.h> 27#include <linux/mm.h> 28#include <linux/interrupt.h> 29#include <linux/string.h> 30#include <linux/skbuff.h> 31 32#include <linux/isdnif.h> 33#include <asm/string.h> 34#include <asm/io.h> 35#include <linux/ioport.h> 36 37#include "pcbit.h" 38#include "edss1.h" 39#include "layer2.h" 40#include "capi.h" 41 42 43extern ushort last_ref_num; 44 45static int pcbit_ioctl(isdn_ctrl* ctl); 46 47static char* pcbit_devname[MAX_PCBIT_CARDS] = { 48 "pcbit0", 49 "pcbit1", 50 "pcbit2", 51 "pcbit3" 52}; 53 54/* 55 * prototypes 56 */ 57 58static int pcbit_command(isdn_ctrl* ctl); 59static int pcbit_stat(u_char __user * buf, int len, int, int); 60static int pcbit_xmit(int driver, int chan, int ack, struct sk_buff *skb); 61static int pcbit_writecmd(const u_char __user *, int, int, int); 62 63static int set_protocol_running(struct pcbit_dev * dev); 64 65static void pcbit_clear_msn(struct pcbit_dev *dev); 66static void pcbit_set_msn(struct pcbit_dev *dev, char *list); 67static int pcbit_check_msn(struct pcbit_dev *dev, char *msn); 68 69 70int pcbit_init_dev(int board, int mem_base, int irq) 71{ 72 struct pcbit_dev *dev; 73 isdn_if *dev_if; 74 75 if ((dev=kzalloc(sizeof(struct pcbit_dev), GFP_KERNEL)) == NULL) 76 { 77 printk("pcbit_init: couldn't malloc pcbit_dev struct\n"); 78 return -ENOMEM; 79 } 80 81 dev_pcbit[board] = dev; 82 init_waitqueue_head(&dev->set_running_wq); 83 spin_lock_init(&dev->lock); 84 85 if (mem_base >= 0xA0000 && mem_base <= 0xFFFFF ) { 86 dev->ph_mem = mem_base; 87 if (!request_mem_region(dev->ph_mem, 4096, "PCBIT mem")) { 88 printk(KERN_WARNING 89 "PCBIT: memory region %lx-%lx already in use\n", 90 dev->ph_mem, dev->ph_mem + 4096); 91 kfree(dev); 92 dev_pcbit[board] = NULL; 93 return -EACCES; 94 } 95 dev->sh_mem = ioremap(dev->ph_mem, 4096); 96 } 97 else 98 { 99 printk("memory address invalid"); 100 kfree(dev); 101 dev_pcbit[board] = NULL; 102 return -EACCES; 103 } 104 105 dev->b1 = kzalloc(sizeof(struct pcbit_chan), GFP_KERNEL); 106 if (!dev->b1) { 107 printk("pcbit_init: couldn't malloc pcbit_chan struct\n"); 108 iounmap(dev->sh_mem); 109 release_mem_region(dev->ph_mem, 4096); 110 kfree(dev); 111 return -ENOMEM; 112 } 113 114 dev->b2 = kzalloc(sizeof(struct pcbit_chan), GFP_KERNEL); 115 if (!dev->b2) { 116 printk("pcbit_init: couldn't malloc pcbit_chan struct\n"); 117 kfree(dev->b1); 118 iounmap(dev->sh_mem); 119 release_mem_region(dev->ph_mem, 4096); 120 kfree(dev); 121 return -ENOMEM; 122 } 123 124 dev->b2->id = 1; 125 126 INIT_WORK(&dev->qdelivery, pcbit_deliver); 127 128 /* 129 * interrupts 130 */ 131 132 if (request_irq(irq, &pcbit_irq_handler, 0, pcbit_devname[board], dev) != 0) 133 { 134 kfree(dev->b1); 135 kfree(dev->b2); 136 iounmap(dev->sh_mem); 137 release_mem_region(dev->ph_mem, 4096); 138 kfree(dev); 139 dev_pcbit[board] = NULL; 140 return -EIO; 141 } 142 143 dev->irq = irq; 144 145 /* next frame to be received */ 146 dev->rcv_seq = 0; 147 dev->send_seq = 0; 148 dev->unack_seq = 0; 149 150 dev->hl_hdrlen = 16; 151 152 dev_if = kmalloc(sizeof(isdn_if), GFP_KERNEL); 153 154 if (!dev_if) { 155 free_irq(irq, dev); 156 kfree(dev->b1); 157 kfree(dev->b2); 158 iounmap(dev->sh_mem); 159 release_mem_region(dev->ph_mem, 4096); 160 kfree(dev); 161 dev_pcbit[board] = NULL; 162 return -EIO; 163 } 164 165 dev->dev_if = dev_if; 166 167 dev_if->owner = THIS_MODULE; 168 169 dev_if->channels = 2; 170 171 dev_if->features = (ISDN_FEATURE_P_EURO | ISDN_FEATURE_L3_TRANS | 172 ISDN_FEATURE_L2_HDLC | ISDN_FEATURE_L2_TRANS ); 173 174 dev_if->writebuf_skb = pcbit_xmit; 175 dev_if->hl_hdrlen = 16; 176 177 dev_if->maxbufsize = MAXBUFSIZE; 178 dev_if->command = pcbit_command; 179 180 dev_if->writecmd = pcbit_writecmd; 181 dev_if->readstat = pcbit_stat; 182 183 184 strcpy(dev_if->id, pcbit_devname[board]); 185 186 if (!register_isdn(dev_if)) { 187 free_irq(irq, dev); 188 kfree(dev->b1); 189 kfree(dev->b2); 190 iounmap(dev->sh_mem); 191 release_mem_region(dev->ph_mem, 4096); 192 kfree(dev); 193 dev_pcbit[board] = NULL; 194 return -EIO; 195 } 196 197 dev->id = dev_if->channels; 198 199 200 dev->l2_state = L2_DOWN; 201 dev->free = 511; 202 203 /* 204 * set_protocol_running(dev); 205 */ 206 207 return 0; 208} 209 210#ifdef MODULE 211void pcbit_terminate(int board) 212{ 213 struct pcbit_dev * dev; 214 215 dev = dev_pcbit[board]; 216 217 if (dev) { 218 /* unregister_isdn(dev->dev_if); */ 219 free_irq(dev->irq, dev); 220 pcbit_clear_msn(dev); 221 kfree(dev->dev_if); 222 if (dev->b1->fsm_timer.function) 223 del_timer(&dev->b1->fsm_timer); 224 if (dev->b2->fsm_timer.function) 225 del_timer(&dev->b2->fsm_timer); 226 kfree(dev->b1); 227 kfree(dev->b2); 228 iounmap(dev->sh_mem); 229 release_mem_region(dev->ph_mem, 4096); 230 kfree(dev); 231 } 232} 233#endif 234 235static int pcbit_command(isdn_ctrl* ctl) 236{ 237 struct pcbit_dev *dev; 238 struct pcbit_chan *chan; 239 struct callb_data info; 240 241 dev = finddev(ctl->driver); 242 243 if (!dev) 244 { 245 printk("pcbit_command: unknown device\n"); 246 return -1; 247 } 248 249 chan = (ctl->arg & 0x0F) ? dev->b2 : dev->b1; 250 251 252 switch(ctl->command) { 253 case ISDN_CMD_IOCTL: 254 return pcbit_ioctl(ctl); 255 break; 256 case ISDN_CMD_DIAL: 257 info.type = EV_USR_SETUP_REQ; 258 info.data.setup.CalledPN = (char *) &ctl->parm.setup.phone; 259 pcbit_fsm_event(dev, chan, EV_USR_SETUP_REQ, &info); 260 break; 261 case ISDN_CMD_ACCEPTD: 262 pcbit_fsm_event(dev, chan, EV_USR_SETUP_RESP, NULL); 263 break; 264 case ISDN_CMD_ACCEPTB: 265 printk("ISDN_CMD_ACCEPTB - not really needed\n"); 266 break; 267 case ISDN_CMD_HANGUP: 268 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL); 269 break; 270 case ISDN_CMD_SETL2: 271 chan->proto = (ctl->arg >> 8); 272 break; 273 case ISDN_CMD_CLREAZ: 274 pcbit_clear_msn(dev); 275 break; 276 case ISDN_CMD_SETEAZ: 277 pcbit_set_msn(dev, ctl->parm.num); 278 break; 279 case ISDN_CMD_SETL3: 280 if ((ctl->arg >> 8) != ISDN_PROTO_L3_TRANS) 281 printk(KERN_DEBUG "L3 protocol unknown\n"); 282 break; 283 default: 284 printk(KERN_DEBUG "pcbit_command: unknown command\n"); 285 break; 286 }; 287 288 return 0; 289} 290 291/* 292 * Another Hack :-( 293 * on some conditions the board stops sending TDATA_CONFs 294 * let's see if we can turn around the problem 295 */ 296 297#ifdef BLOCK_TIMER 298static void pcbit_block_timer(unsigned long data) 299{ 300 struct pcbit_chan *chan; 301 struct pcbit_dev * dev; 302 isdn_ctrl ictl; 303 304 chan = (struct pcbit_chan *) data; 305 306 dev = chan2dev(chan); 307 308 if (dev == NULL) { 309 printk(KERN_DEBUG "pcbit: chan2dev failed\n"); 310 return; 311 } 312 313 del_timer(&chan->block_timer); 314 chan->block_timer.function = NULL; 315 316#ifdef DEBUG 317 printk(KERN_DEBUG "pcbit_block_timer\n"); 318#endif 319 chan->queued = 0; 320 ictl.driver = dev->id; 321 ictl.command = ISDN_STAT_BSENT; 322 ictl.arg = chan->id; 323 dev->dev_if->statcallb(&ictl); 324} 325#endif 326 327static int pcbit_xmit(int driver, int chnum, int ack, struct sk_buff *skb) 328{ 329 ushort hdrlen; 330 int refnum, len; 331 struct pcbit_chan * chan; 332 struct pcbit_dev *dev; 333 334 dev = finddev(driver); 335 if (dev == NULL) 336 { 337 printk("finddev returned NULL"); 338 return -1; 339 } 340 341 chan = chnum ? dev->b2 : dev->b1; 342 343 344 if (chan->fsm_state != ST_ACTIVE) 345 return -1; 346 347 if (chan->queued >= MAX_QUEUED ) 348 { 349#ifdef DEBUG_QUEUE 350 printk(KERN_DEBUG 351 "pcbit: %d packets already in queue - write fails\n", 352 chan->queued); 353#endif 354 /* 355 * packet stays on the head of the device queue 356 * since dev_start_xmit will fail 357 * see net/core/dev.c 358 */ 359#ifdef BLOCK_TIMER 360 if (chan->block_timer.function == NULL) { 361 init_timer(&chan->block_timer); 362 chan->block_timer.function = &pcbit_block_timer; 363 chan->block_timer.data = (long) chan; 364 chan->block_timer.expires = jiffies + 1 * HZ; 365 add_timer(&chan->block_timer); 366 } 367#endif 368 return 0; 369 } 370 371 372 chan->queued++; 373 374 len = skb->len; 375 376 hdrlen = capi_tdata_req(chan, skb); 377 378 refnum = last_ref_num++ & 0x7fffU; 379 chan->s_refnum = refnum; 380 381 pcbit_l2_write(dev, MSG_TDATA_REQ, refnum, skb, hdrlen); 382 383 return len; 384} 385 386static int pcbit_writecmd(const u_char __user *buf, int len, int driver, int channel) 387{ 388 struct pcbit_dev * dev; 389 int i, j; 390 const u_char * loadbuf; 391 u_char * ptr = NULL; 392 u_char *cbuf; 393 394 int errstat; 395 396 dev = finddev(driver); 397 398 if (!dev) 399 { 400 printk("pcbit_writecmd: couldn't find device"); 401 return -ENODEV; 402 } 403 404 switch(dev->l2_state) { 405 case L2_LWMODE: 406 /* check (size <= rdp_size); write buf into board */ 407 if (len < 0 || len > BANK4 + 1 || len > 1024) 408 { 409 printk("pcbit_writecmd: invalid length %d\n", len); 410 return -EINVAL; 411 } 412 413 cbuf = kmalloc(len, GFP_KERNEL); 414 if (!cbuf) 415 return -ENOMEM; 416 417 if (copy_from_user(cbuf, buf, len)) { 418 kfree(cbuf); 419 return -EFAULT; 420 } 421 memcpy_toio(dev->sh_mem, cbuf, len); 422 kfree(cbuf); 423 return len; 424 case L2_FWMODE: 425 /* this is the hard part */ 426 /* dumb board */ 427 /* get it into kernel space */ 428 if ((ptr = kmalloc(len, GFP_KERNEL))==NULL) 429 return -ENOMEM; 430 if (copy_from_user(ptr, buf, len)) { 431 kfree(ptr); 432 return -EFAULT; 433 } 434 loadbuf = ptr; 435 436 errstat = 0; 437 438 for (i=0; i < len; i++) 439 { 440 for(j=0; j < LOAD_RETRY; j++) 441 if (!(readb(dev->sh_mem + dev->loadptr))) 442 break; 443 444 if (j == LOAD_RETRY) 445 { 446 errstat = -ETIME; 447 printk("TIMEOUT i=%d\n", i); 448 break; 449 } 450 writeb(loadbuf[i], dev->sh_mem + dev->loadptr + 1); 451 writeb(0x01, dev->sh_mem + dev->loadptr); 452 453 dev->loadptr += 2; 454 if (dev->loadptr > LOAD_ZONE_END) 455 dev->loadptr = LOAD_ZONE_START; 456 } 457 kfree(ptr); 458 459 return errstat ? errstat : len; 460 default: 461 return -EBUSY; 462 } 463} 464 465/* 466 * demultiplexing of messages 467 * 468 */ 469 470void pcbit_l3_receive(struct pcbit_dev * dev, ulong msg, 471 struct sk_buff * skb, 472 ushort hdr_len, ushort refnum) 473{ 474 struct pcbit_chan *chan; 475 struct sk_buff *skb2; 476 unsigned short len; 477 struct callb_data cbdata; 478 int complete, err; 479 isdn_ctrl ictl; 480 481 switch(msg) { 482 483 case MSG_TDATA_IND: 484 if (!(chan = capi_channel(dev, skb))) { 485 printk(KERN_WARNING 486 "CAPI header: unknown channel id\n"); 487 break; 488 } 489 chan->r_refnum = skb->data[7]; 490 skb_pull(skb, 8); 491 492 dev->dev_if->rcvcallb_skb(dev->id, chan->id, skb); 493 494 if (capi_tdata_resp(chan, &skb2) > 0) 495 pcbit_l2_write(dev, MSG_TDATA_RESP, refnum, 496 skb2, skb2->len); 497 return; 498 break; 499 case MSG_TDATA_CONF: 500 if (!(chan = capi_channel(dev, skb))) { 501 printk(KERN_WARNING 502 "CAPI header: unknown channel id\n"); 503 break; 504 } 505 506#ifdef DEBUG 507 if ( (*((ushort *) (skb->data + 2) )) != 0) { 508 printk(KERN_DEBUG "TDATA_CONF error\n"); 509 } 510#endif 511#ifdef BLOCK_TIMER 512 if (chan->queued == MAX_QUEUED) { 513 del_timer(&chan->block_timer); 514 chan->block_timer.function = NULL; 515 } 516 517#endif 518 chan->queued--; 519 520 ictl.driver = dev->id; 521 ictl.command = ISDN_STAT_BSENT; 522 ictl.arg = chan->id; 523 dev->dev_if->statcallb(&ictl); 524 break; 525 526 case MSG_CONN_IND: 527 /* 528 * channel: 1st not used will do 529 * if both are used we're in trouble 530 */ 531 532 if (!dev->b1->fsm_state) 533 chan = dev->b1; 534 else if (!dev->b2->fsm_state) 535 chan = dev->b2; 536 else { 537 printk(KERN_INFO 538 "Incoming connection: no channels available"); 539 540 if ((len = capi_disc_req(*(ushort*)(skb->data), &skb2, CAUSE_NOCHAN)) > 0) 541 pcbit_l2_write(dev, MSG_DISC_REQ, refnum, skb2, len); 542 break; 543 } 544 545 cbdata.data.setup.CalledPN = NULL; 546 cbdata.data.setup.CallingPN = NULL; 547 548 capi_decode_conn_ind(chan, skb, &cbdata); 549 cbdata.type = EV_NET_SETUP; 550 551 pcbit_fsm_event(dev, chan, EV_NET_SETUP, NULL); 552 553 if (pcbit_check_msn(dev, cbdata.data.setup.CallingPN)) 554 pcbit_fsm_event(dev, chan, EV_USR_PROCED_REQ, &cbdata); 555 else 556 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL); 557 558 kfree(cbdata.data.setup.CalledPN); 559 kfree(cbdata.data.setup.CallingPN); 560 break; 561 562 case MSG_CONN_CONF: 563 /* 564 * We should be able to find the channel by the message 565 * reference number. The current version of the firmware 566 * doesn't sent the ref number correctly. 567 */ 568#ifdef DEBUG 569 printk(KERN_DEBUG "refnum=%04x b1=%04x b2=%04x\n", refnum, 570 dev->b1->s_refnum, 571 dev->b2->s_refnum); 572#endif 573 /* We just try to find a channel in the right state */ 574 575 if (dev->b1->fsm_state == ST_CALL_INIT) 576 chan = dev->b1; 577 else { 578 if (dev->b2->s_refnum == ST_CALL_INIT) 579 chan = dev->b2; 580 else { 581 chan = NULL; 582 printk(KERN_WARNING "Connection Confirm - no channel in Call Init state\n"); 583 break; 584 } 585 } 586 if (capi_decode_conn_conf(chan, skb, &complete)) { 587 printk(KERN_DEBUG "conn_conf indicates error\n"); 588 pcbit_fsm_event(dev, chan, EV_ERROR, NULL); 589 } 590 else 591 if (complete) 592 pcbit_fsm_event(dev, chan, EV_NET_CALL_PROC, NULL); 593 else 594 pcbit_fsm_event(dev, chan, EV_NET_SETUP_ACK, NULL); 595 break; 596 case MSG_CONN_ACTV_IND: 597 598 if (!(chan = capi_channel(dev, skb))) { 599 printk(KERN_WARNING 600 "CAPI header: unknown channel id\n"); 601 break; 602 } 603 604 if (capi_decode_conn_actv_ind(chan, skb)) { 605 printk("error in capi_decode_conn_actv_ind\n"); 606 /* pcbit_fsm_event(dev, chan, EV_ERROR, NULL); */ 607 break; 608 } 609 chan->r_refnum = refnum; 610 pcbit_fsm_event(dev, chan, EV_NET_CONN, NULL); 611 break; 612 case MSG_CONN_ACTV_CONF: 613 614 if (!(chan = capi_channel(dev, skb))) { 615 printk(KERN_WARNING 616 "CAPI header: unknown channel id\n"); 617 break; 618 } 619 620 if (capi_decode_conn_actv_conf(chan, skb) == 0) 621 pcbit_fsm_event(dev, chan, EV_NET_CONN_ACK, NULL); 622 623 else 624 printk(KERN_DEBUG "decode_conn_actv_conf failed\n"); 625 break; 626 627 case MSG_SELP_CONF: 628 629 if (!(chan = capi_channel(dev, skb))) { 630 printk(KERN_WARNING 631 "CAPI header: unknown channel id\n"); 632 break; 633 } 634 635 if (!(err = capi_decode_sel_proto_conf(chan, skb))) 636 pcbit_fsm_event(dev, chan, EV_NET_SELP_RESP, NULL); 637 else { 638 /* Error */ 639 printk("error %d - capi_decode_sel_proto_conf\n", err); 640 } 641 break; 642 case MSG_ACT_TRANSP_CONF: 643 if (!(chan = capi_channel(dev, skb))) { 644 printk(KERN_WARNING 645 "CAPI header: unknown channel id\n"); 646 break; 647 } 648 649 if (!capi_decode_actv_trans_conf(chan, skb)) 650 pcbit_fsm_event(dev, chan, EV_NET_ACTV_RESP, NULL); 651 break; 652 653 case MSG_DISC_IND: 654 655 if (!(chan = capi_channel(dev, skb))) { 656 printk(KERN_WARNING 657 "CAPI header: unknown channel id\n"); 658 break; 659 } 660 661 if (!capi_decode_disc_ind(chan, skb)) 662 pcbit_fsm_event(dev, chan, EV_NET_DISC, NULL); 663 else 664 printk(KERN_WARNING "capi_decode_disc_ind - error\n"); 665 break; 666 case MSG_DISC_CONF: 667 if (!(chan = capi_channel(dev, skb))) { 668 printk(KERN_WARNING 669 "CAPI header: unknown channel id\n"); 670 break; 671 } 672 673 if (!capi_decode_disc_ind(chan, skb)) 674 pcbit_fsm_event(dev, chan, EV_NET_RELEASE, NULL); 675 else 676 printk(KERN_WARNING "capi_decode_disc_conf - error\n"); 677 break; 678 case MSG_INFO_IND: 679#ifdef DEBUG 680 printk(KERN_DEBUG "received Info Indication - discarded\n"); 681#endif 682 break; 683#ifdef DEBUG 684 case MSG_DEBUG_188: 685 capi_decode_debug_188(skb->data, skb->len); 686 break; 687 688 default: 689 printk(KERN_DEBUG "pcbit_l3_receive: unknown message %08lx\n", 690 msg); 691 break; 692#endif 693 } 694 695 kfree_skb(skb); 696 697} 698 699/* 700 * Single statbuf 701 * should be a statbuf per device 702 */ 703 704static char statbuf[STATBUF_LEN]; 705static int stat_st = 0; 706static int stat_end = 0; 707 708static int pcbit_stat(u_char __user *buf, int len, int driver, int channel) 709{ 710 int stat_count; 711 stat_count = stat_end - stat_st; 712 713 if (stat_count < 0) 714 stat_count = STATBUF_LEN - stat_st + stat_end; 715 716 if (len > stat_count) 717 len = stat_count; 718 719 if (stat_st < stat_end) 720 { 721 if (copy_to_user(buf, statbuf + stat_st, len)) 722 return -EFAULT; 723 stat_st += len; 724 } 725 else 726 { 727 if (len > STATBUF_LEN - stat_st) 728 { 729 if (copy_to_user(buf, statbuf + stat_st, 730 STATBUF_LEN - stat_st)) 731 return -EFAULT; 732 if (copy_to_user(buf, statbuf, 733 len - (STATBUF_LEN - stat_st))) 734 return -EFAULT; 735 736 stat_st = len - (STATBUF_LEN - stat_st); 737 } 738 else 739 { 740 if (copy_to_user(buf, statbuf + stat_st, len)) 741 return -EFAULT; 742 743 stat_st += len; 744 745 if (stat_st == STATBUF_LEN) 746 stat_st = 0; 747 } 748 } 749 750 if (stat_st == stat_end) 751 stat_st = stat_end = 0; 752 753 return len; 754} 755 756static void pcbit_logstat(struct pcbit_dev *dev, char *str) 757{ 758 int i; 759 isdn_ctrl ictl; 760 761 for (i=stat_end; i<strlen(str); i++) 762 { 763 statbuf[i]=str[i]; 764 stat_end = (stat_end + 1) % STATBUF_LEN; 765 if (stat_end == stat_st) 766 stat_st = (stat_st + 1) % STATBUF_LEN; 767 } 768 769 ictl.command=ISDN_STAT_STAVAIL; 770 ictl.driver=dev->id; 771 ictl.arg=strlen(str); 772 dev->dev_if->statcallb(&ictl); 773} 774 775void pcbit_state_change(struct pcbit_dev * dev, struct pcbit_chan * chan, 776 unsigned short i, unsigned short ev, unsigned short f) 777{ 778 char buf[256]; 779 780 sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n", 781 dev->id, chan->id, 782 isdn_state_table[i], strisdnevent(ev), isdn_state_table[f] 783 ); 784 785#ifdef DEBUG 786 printk("%s", buf); 787#endif 788 789 pcbit_logstat(dev, buf); 790} 791 792static void set_running_timeout(unsigned long ptr) 793{ 794 struct pcbit_dev * dev; 795 796#ifdef DEBUG 797 printk(KERN_DEBUG "set_running_timeout\n"); 798#endif 799 dev = (struct pcbit_dev *) ptr; 800 801 wake_up_interruptible(&dev->set_running_wq); 802} 803 804static int set_protocol_running(struct pcbit_dev * dev) 805{ 806 isdn_ctrl ctl; 807 808 init_timer(&dev->set_running_timer); 809 810 dev->set_running_timer.function = &set_running_timeout; 811 dev->set_running_timer.data = (ulong) dev; 812 dev->set_running_timer.expires = jiffies + SET_RUN_TIMEOUT; 813 814 /* kick it */ 815 816 dev->l2_state = L2_STARTING; 817 818 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)), 819 dev->sh_mem + BANK4); 820 821 add_timer(&dev->set_running_timer); 822 823 interruptible_sleep_on(&dev->set_running_wq); 824 825 del_timer(&dev->set_running_timer); 826 827 if (dev->l2_state == L2_RUNNING) 828 { 829 printk(KERN_DEBUG "pcbit: running\n"); 830 831 dev->unack_seq = dev->send_seq; 832 833 dev->writeptr = dev->sh_mem; 834 dev->readptr = dev->sh_mem + BANK2; 835 836 /* tell the good news to the upper layer */ 837 ctl.driver = dev->id; 838 ctl.command = ISDN_STAT_RUN; 839 840 dev->dev_if->statcallb(&ctl); 841 } 842 else 843 { 844 printk(KERN_DEBUG "pcbit: initialization failed\n"); 845 printk(KERN_DEBUG "pcbit: firmware not loaded\n"); 846 847 dev->l2_state = L2_DOWN; 848 849#ifdef DEBUG 850 printk(KERN_DEBUG "Bank3 = %02x\n", 851 readb(dev->sh_mem + BANK3)); 852#endif 853 writeb(0x40, dev->sh_mem + BANK4); 854 855 /* warn the upper layer */ 856 ctl.driver = dev->id; 857 ctl.command = ISDN_STAT_STOP; 858 859 dev->dev_if->statcallb(&ctl); 860 861 return -EL2HLT; /* Level 2 halted */ 862 } 863 864 return 0; 865} 866 867static int pcbit_ioctl(isdn_ctrl* ctl) 868{ 869 struct pcbit_dev * dev; 870 struct pcbit_ioctl *cmd; 871 872 dev = finddev(ctl->driver); 873 874 if (!dev) 875 { 876 printk(KERN_DEBUG "pcbit_ioctl: unknown device\n"); 877 return -ENODEV; 878 } 879 880 cmd = (struct pcbit_ioctl *) ctl->parm.num; 881 882 switch(ctl->arg) { 883 case PCBIT_IOCTL_GETSTAT: 884 cmd->info.l2_status = dev->l2_state; 885 break; 886 887 case PCBIT_IOCTL_STRLOAD: 888 if (dev->l2_state == L2_RUNNING) 889 return -EBUSY; 890 891 dev->unack_seq = dev->send_seq = dev->rcv_seq = 0; 892 893 dev->writeptr = dev->sh_mem; 894 dev->readptr = dev->sh_mem + BANK2; 895 896 dev->l2_state = L2_LOADING; 897 break; 898 899 case PCBIT_IOCTL_LWMODE: 900 if (dev->l2_state != L2_LOADING) 901 return -EINVAL; 902 903 dev->l2_state = L2_LWMODE; 904 break; 905 906 case PCBIT_IOCTL_FWMODE: 907 if (dev->l2_state == L2_RUNNING) 908 return -EBUSY; 909 dev->loadptr = LOAD_ZONE_START; 910 dev->l2_state = L2_FWMODE; 911 912 break; 913 case PCBIT_IOCTL_ENDLOAD: 914 if (dev->l2_state == L2_RUNNING) 915 return -EBUSY; 916 dev->l2_state = L2_DOWN; 917 break; 918 919 case PCBIT_IOCTL_SETBYTE: 920 if (dev->l2_state == L2_RUNNING) 921 return -EBUSY; 922 923 /* check addr */ 924 if (cmd->info.rdp_byte.addr > BANK4) 925 return -EFAULT; 926 927 writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr); 928 break; 929 case PCBIT_IOCTL_GETBYTE: 930 if (dev->l2_state == L2_RUNNING) 931 return -EBUSY; 932 933 /* check addr */ 934 935 if (cmd->info.rdp_byte.addr > BANK4) 936 { 937 printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr); 938 return -EFAULT; 939 } 940 941 cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr); 942 break; 943 case PCBIT_IOCTL_RUNNING: 944 if (dev->l2_state == L2_RUNNING) 945 return -EBUSY; 946 return set_protocol_running(dev); 947 break; 948 case PCBIT_IOCTL_WATCH188: 949 if (dev->l2_state != L2_LOADING) 950 return -EINVAL; 951 pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0); 952 break; 953 case PCBIT_IOCTL_PING188: 954 if (dev->l2_state != L2_LOADING) 955 return -EINVAL; 956 pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0); 957 break; 958 case PCBIT_IOCTL_APION: 959 if (dev->l2_state != L2_LOADING) 960 return -EINVAL; 961 pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0); 962 break; 963 case PCBIT_IOCTL_STOP: 964 dev->l2_state = L2_DOWN; 965 writeb(0x40, dev->sh_mem + BANK4); 966 dev->rcv_seq = 0; 967 dev->send_seq = 0; 968 dev->unack_seq = 0; 969 break; 970 default: 971 printk("error: unknown ioctl\n"); 972 break; 973 }; 974 return 0; 975} 976 977/* 978 * MSN list handling 979 * 980 * if null reject all calls 981 * if first entry has null MSN accept all calls 982 */ 983 984static void pcbit_clear_msn(struct pcbit_dev *dev) 985{ 986 struct msn_entry *ptr, *back; 987 988 for (ptr=dev->msn_list; ptr; ) 989 { 990 back = ptr->next; 991 kfree(ptr); 992 ptr = back; 993 } 994 995 dev->msn_list = NULL; 996} 997 998static void pcbit_set_msn(struct pcbit_dev *dev, char *list) 999{ 1000 struct msn_entry *ptr; 1001 struct msn_entry *back = NULL; 1002 char *cp, *sp; 1003 int len; 1004 1005 if (strlen(list) == 0) { 1006 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC); 1007 if (!ptr) { 1008 printk(KERN_WARNING "kmalloc failed\n"); 1009 return; 1010 } 1011 1012 ptr->msn = NULL; 1013 1014 ptr->next = dev->msn_list; 1015 dev->msn_list = ptr; 1016 1017 return; 1018 } 1019 1020 if (dev->msn_list) 1021 for (back=dev->msn_list; back->next; back=back->next); 1022 1023 sp = list; 1024 1025 do { 1026 cp=strchr(sp, ','); 1027 if (cp) 1028 len = cp - sp; 1029 else 1030 len = strlen(sp); 1031 1032 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC); 1033 1034 if (!ptr) { 1035 printk(KERN_WARNING "kmalloc failed\n"); 1036 return; 1037 } 1038 ptr->next = NULL; 1039 1040 ptr->msn = kmalloc(len, GFP_ATOMIC); 1041 if (!ptr->msn) { 1042 printk(KERN_WARNING "kmalloc failed\n"); 1043 kfree(ptr); 1044 return; 1045 } 1046 1047 memcpy(ptr->msn, sp, len - 1); 1048 ptr->msn[len] = 0; 1049 1050#ifdef DEBUG 1051 printk(KERN_DEBUG "msn: %s\n", ptr->msn); 1052#endif 1053 if (dev->msn_list == NULL) 1054 dev->msn_list = ptr; 1055 else 1056 back->next = ptr; 1057 back = ptr; 1058 sp += len; 1059 } while(cp); 1060} 1061 1062/* 1063 * check if we do signal or reject an incoming call 1064 */ 1065static int pcbit_check_msn(struct pcbit_dev *dev, char *msn) 1066{ 1067 struct msn_entry *ptr; 1068 1069 for (ptr=dev->msn_list; ptr; ptr=ptr->next) { 1070 1071 if (ptr->msn == NULL) 1072 return 1; 1073 1074 if (strcmp(ptr->msn, msn) == 0) 1075 return 1; 1076 } 1077 1078 return 0; 1079} 1080