root/drivers/isdn/pcbit/drv.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. pcbit_init_dev
  2. pcbit_terminate
  3. pcbit_command
  4. pcbit_block_timer
  5. pcbit_xmit
  6. pcbit_writecmd
  7. pcbit_l3_receive
  8. pcbit_stat
  9. pcbit_logstat
  10. pcbit_state_change
  11. set_running_timeout
  12. set_protocol_running
  13. pcbit_ioctl
  14. pcbit_clear_msn
  15. pcbit_set_msn
  16. pcbit_check_msn

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

/* [previous][next][first][last][top][bottom][index][help] */