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