git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/pcbit/capi.c

   1 /*
   2  * CAPI encoder/decoder for
   3  * Portugal Telecom CAPI 2.0
   4  *
   5  * Copyright (C) 1996 Universidade de Lisboa
   6  *
   7  * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
   8  *
   9  * This software may be used and distributed according to the terms of
  10  * the GNU General Public License, incorporated herein by reference.
  11  *
  12  * Not compatible with the AVM Gmbh. CAPI 2.0
  13  *
  14  */
  15
  16 /*
  17  *        Documentation:
  18  *        - "Common ISDN API - Perfil Português - Versão 2.1",
  19  *           Telecom Portugal, Fev 1992.
  20  *        - "Common ISDN API - Especificação de protocolos para
  21  *           acesso aos canais B", Inesc, Jan 1994.
  22  */
  23
  24 /*
  25  *        TODO: better decoding of Information Elements
  26  *              for debug purposes mainly
  27  *              encode our number in CallerPN and ConnectedPN
  28  */
  29
  30 #include <linux/sched.h>
  31 #include <linux/string.h>
  32 #include <linux/kernel.h>
  33
  34 #include <linux/types.h>
  35 #include <linux/slab.h>
  36 #include <linux/mm.h>
  37
  38 #include <linux/skbuff.h>
  39
  40 #include <asm/io.h>
  41 #include <asm/string.h>
  42
  43 #include <linux/isdnif.h>
  44
  45 #include "pcbit.h"
  46 #include "edss1.h"
  47 #include "capi.h"
  48
  49
  50 /*
  51  *  Encoding of CAPI messages
  52  *
  53  */
  54
  55 int capi_conn_req(const char * calledPN, struct sk_buff **skb, int proto)
  56 {
  57         ushort len;
  58
  59         /*
  60          * length
  61          *   AppInfoMask - 2
  62          *   BC0         - 3
  63          *   BC1         - 1
  64          *   Chan        - 2
  65          *   Keypad      - 1
  66          *   CPN         - 1
  67          *   CPSA        - 1
  68          *   CalledPN    - 2 + strlen
  69          *   CalledPSA   - 1
  70          *   rest...     - 4
  71          *   ----------------
  72          *   Total        18 + strlen
  73          */
  74
  75         len = 18 + strlen(calledPN);
  76
  77         if (proto == ISDN_PROTO_L2_TRANS)
  78                 len++;
  79
  80         if ((*skb = dev_alloc_skb(len)) == NULL) {
  81
  82                 printk(KERN_WARNING "capi_conn_req: alloc_skb failed\n");
  83                 return -1;
  84         }
  85
  86         /* InfoElmMask */
  87         *((ushort*) skb_put(*skb, 2)) = AppInfoMask;
  88
  89         if (proto == ISDN_PROTO_L2_TRANS)
  90         {
  91                 /* Bearer Capability - Mandatory*/
  92                 *(skb_put(*skb, 1)) = 3;        /* BC0.Length           */
  93                 *(skb_put(*skb, 1)) = 0x80;     /* Speech               */
  94                 *(skb_put(*skb, 1)) = 0x10;     /* Circuit Mode         */
  95                 *(skb_put(*skb, 1)) = 0x23;     /* A-law                */
  96         }
  97         else
  98         {
  99                 /* Bearer Capability - Mandatory*/
 100                 *(skb_put(*skb, 1)) = 2;        /* BC0.Length           */
 101                 *(skb_put(*skb, 1)) = 0x88;     /* Digital Information  */
 102                 *(skb_put(*skb, 1)) = 0x90;     /* BC0.Octect4          */
 103         }
 104
 105         /* Bearer Capability - Optional*/
 106         *(skb_put(*skb, 1)) = 0;        /* BC1.Length = 0                    */
 107
 108         *(skb_put(*skb, 1)) = 1;        /* ChannelID.Length = 1              */
 109         *(skb_put(*skb, 1)) = 0x83;     /* Basic Interface - Any Channel     */
 110
 111         *(skb_put(*skb, 1)) = 0;        /* Keypad.Length = 0                 */
 112
 113
 114         *(skb_put(*skb, 1)) = 0;        /* CallingPN.Length = 0              */
 115         *(skb_put(*skb, 1)) = 0;        /* CallingPSA.Length = 0             */
 116
 117         /* Called Party Number */
 118         *(skb_put(*skb, 1)) = strlen(calledPN) + 1;
 119         *(skb_put(*skb, 1)) = 0x81;
 120         memcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));
 121
 122         /* '#' */
 123
 124         *(skb_put(*skb, 1)) = 0;       /* CalledPSA.Length = 0     */
 125
 126         /* LLC.Length  = 0; */
 127         /* HLC0.Length = 0; */
 128         /* HLC1.Length = 0; */
 129         /* UTUS.Length = 0; */
 130         memset(skb_put(*skb, 4), 0, 4);
 131
 132         return len;
 133 }
 134
 135 int capi_conn_resp(struct pcbit_chan* chan, struct sk_buff **skb)
 136 {
 137
 138         if ((*skb = dev_alloc_skb(5)) == NULL) {
 139
 140                 printk(KERN_WARNING "capi_conn_resp: alloc_skb failed\n");
 141                 return -1;
 142         }
 143
 144         *((ushort*) skb_put(*skb, 2) ) = chan->callref;
 145         *(skb_put(*skb, 1)) = 0x01;  /* ACCEPT_CALL */
 146         *(skb_put(*skb, 1)) = 0;
 147         *(skb_put(*skb, 1)) = 0;
 148
 149         return 5;
 150 }
 151
 152 int capi_conn_active_req(struct pcbit_chan* chan, struct sk_buff **skb)
 153 {
 154         /*
 155          * 8 bytes
 156          */
 157
 158         if ((*skb = dev_alloc_skb(8)) == NULL) {
 159
 160                 printk(KERN_WARNING "capi_conn_active_req: alloc_skb failed\n");
 161                 return -1;
 162         }
 163
 164         *((ushort*) skb_put(*skb, 2) ) = chan->callref;
 165
 166 #ifdef DEBUG
 167         printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
 168 #endif
 169
 170         *(skb_put(*skb, 1)) = 0;       /*  BC.Length = 0;          */
 171         *(skb_put(*skb, 1)) = 0;       /*  ConnectedPN.Length = 0  */
 172         *(skb_put(*skb, 1)) = 0;       /*  PSA.Length              */
 173         *(skb_put(*skb, 1)) = 0;       /*  LLC.Length = 0;         */
 174         *(skb_put(*skb, 1)) = 0;       /*  HLC.Length = 0;         */
 175         *(skb_put(*skb, 1)) = 0;       /*  UTUS.Length = 0;        */
 176
 177         return 8;
 178 }
 179
 180 int capi_conn_active_resp(struct pcbit_chan* chan, struct sk_buff **skb)
 181 {
 182         /*
 183          * 2 bytes
 184          */
 185
 186         if ((*skb = dev_alloc_skb(2)) == NULL) {
 187
 188                 printk(KERN_WARNING "capi_conn_active_resp: alloc_skb failed\n");
 189                 return -1;
 190         }
 191
 192         *((ushort*) skb_put(*skb, 2) ) = chan->callref;
 193
 194         return 2;
 195 }
 196
 197
 198 int capi_select_proto_req(struct pcbit_chan *chan, struct sk_buff **skb,
 199                           int outgoing)
 200 {
 201
 202         /*
 203          * 18 bytes
 204          */
 205
 206         if ((*skb = dev_alloc_skb(18)) == NULL) {
 207
 208                 printk(KERN_WARNING "capi_select_proto_req: alloc_skb failed\n");
 209                 return -1;
 210         }
 211
 212         *((ushort*) skb_put(*skb, 2) ) = chan->callref;
 213
 214         /* Layer2 protocol */
 215
 216         switch (chan->proto) {
 217         case ISDN_PROTO_L2_X75I:
 218                 *(skb_put(*skb, 1)) = 0x05;            /* LAPB */
 219                 break;
 220         case ISDN_PROTO_L2_HDLC:
 221                 *(skb_put(*skb, 1)) = 0x02;
 222                 break;
 223         case ISDN_PROTO_L2_TRANS:
 224                 /*
 225                  *      Voice (a-law)
 226                  */
 227                 *(skb_put(*skb, 1)) = 0x06;
 228                 break;
 229         default:
 230 #ifdef DEBUG
 231                 printk(KERN_DEBUG "Transparent\n");
 232 #endif
 233                 *(skb_put(*skb, 1)) = 0x03;
 234                 break;
 235         }
 236
 237         *(skb_put(*skb, 1)) = (outgoing ? 0x02 : 0x42);    /* Don't ask */
 238         *(skb_put(*skb, 1)) = 0x00;
 239
 240         *((ushort *) skb_put(*skb, 2)) = MRU;
 241
 242
 243         *(skb_put(*skb, 1)) = 0x08;           /* Modulo */
 244         *(skb_put(*skb, 1)) = 0x07;           /* Max Window */
 245
 246         *(skb_put(*skb, 1)) = 0x01;           /* No Layer3 Protocol */
 247
 248         /*
 249          * 2 - layer3 MTU       [10]
 250          *   - Modulo           [12]
 251          *   - Window
 252          *   - layer1 proto     [14]
 253          *   - bitrate
 254          *   - sub-channel      [16]
 255          *   - layer1dataformat [17]
 256          */
 257
 258         memset(skb_put(*skb, 8), 0, 8);
 259
 260         return 18;
 261 }
 262
 263
 264 int capi_activate_transp_req(struct pcbit_chan *chan, struct sk_buff **skb)
 265 {
 266
 267         if ((*skb = dev_alloc_skb(7)) == NULL) {
 268
 269                 printk(KERN_WARNING "capi_activate_transp_req: alloc_skb failed\n");
 270                 return -1;
 271         }
 272
 273         *((ushort*) skb_put(*skb, 2) ) = chan->callref;
 274
 275
 276         *(skb_put(*skb, 1)) = chan->layer2link; /* Layer2 id */
 277         *(skb_put(*skb, 1)) = 0x00;             /* Transmit by default */
 278
 279         *((ushort *) skb_put(*skb, 2)) = MRU;
 280
 281         *(skb_put(*skb, 1)) = 0x01;             /* Enables reception*/
 282
 283         return 7;
 284 }
 285
 286 int capi_tdata_req(struct pcbit_chan* chan, struct sk_buff *skb)
 287 {
 288         ushort data_len;
 289
 290
 291         /*
 292          * callref      - 2
 293          * layer2link   - 1
 294          * wBlockLength - 2
 295          * data         - 4
 296          * sernum       - 1
 297          */
 298
 299         data_len = skb->len;
 300
 301         if(skb_headroom(skb) < 10)
 302         {
 303                 printk(KERN_CRIT "No headspace (%u) on headroom %p for capi header\n", skb_headroom(skb), skb);
 304         }
 305         else
 306         {
 307                 skb_push(skb, 10);
 308         }
 309
 310         *((u16 *) (skb->data)) = chan->callref;
 311         skb->data[2] = chan->layer2link;
 312         *((u16 *) (skb->data + 3)) = data_len;
 313
 314         chan->s_refnum = (chan->s_refnum + 1) % 8;
 315         *((u32 *) (skb->data + 5)) = chan->s_refnum;
 316
 317         skb->data[9] = 0;                           /* HDLC frame number */
 318
 319         return 10;
 320 }
 321
 322 int capi_tdata_resp(struct pcbit_chan *chan, struct sk_buff ** skb)
 323
 324 {
 325         if ((*skb = dev_alloc_skb(4)) == NULL) {
 326
 327                 printk(KERN_WARNING "capi_tdata_resp: alloc_skb failed\n");
 328                 return -1;
 329         }
 330
 331         *((ushort*) skb_put(*skb, 2) ) = chan->callref;
 332
 333         *(skb_put(*skb, 1)) = chan->layer2link;
 334         *(skb_put(*skb, 1)) = chan->r_refnum;
 335
 336         return (*skb)->len;
 337 }
 338
 339 int capi_disc_req(ushort callref, struct sk_buff **skb, u_char cause)
 340 {
 341
 342         if ((*skb = dev_alloc_skb(6)) == NULL) {
 343
 344                 printk(KERN_WARNING "capi_disc_req: alloc_skb failed\n");
 345                 return -1;
 346         }
 347
 348         *((ushort*) skb_put(*skb, 2) ) = callref;
 349
 350         *(skb_put(*skb, 1)) = 2;                  /* Cause.Length = 2; */
 351         *(skb_put(*skb, 1)) = 0x80;
 352         *(skb_put(*skb, 1)) = 0x80 | cause;
 353
 354         /*
 355          * Change it: we should send 'Sic transit gloria Mundi' here ;-)
 356          */
 357
 358         *(skb_put(*skb, 1)) = 0;                   /* UTUS.Length = 0;  */
 359
 360         return 6;
 361 }
 362
 363 int capi_disc_resp(struct pcbit_chan *chan, struct sk_buff **skb)
 364 {
 365         if ((*skb = dev_alloc_skb(2)) == NULL) {
 366
 367                 printk(KERN_WARNING "capi_disc_resp: alloc_skb failed\n");
 368                 return -1;
 369         }
 370
 371         *((ushort*) skb_put(*skb, 2)) = chan->callref;
 372
 373         return 2;
 374 }
 375
 376
 377 /*
 378  *  Decoding of CAPI messages
 379  *
 380  */
 381
 382 int capi_decode_conn_ind(struct pcbit_chan * chan,
 383                          struct sk_buff *skb,
 384                          struct callb_data *info)
 385 {
 386         int CIlen, len;
 387
 388         /* Call Reference [CAPI] */
 389         chan->callref = *((ushort*) skb->data);
 390         skb_pull(skb, 2);
 391
 392 #ifdef DEBUG
 393         printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
 394 #endif
 395
 396         /* Channel Identification */
 397
 398         /* Expect
 399            Len = 1
 400            Octect 3 = 0100 10CC - [ 7 Basic, 4 , 2-1 chan ]
 401            */
 402
 403         CIlen = skb->data[0];
 404 #ifdef DEBUG
 405         if (CIlen == 1) {
 406
 407                 if ( ((skb->data[1]) & 0xFC) == 0x48 )
 408                         printk(KERN_DEBUG "decode_conn_ind: chan ok\n");
 409                 printk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03);
 410         }
 411         else
 412                 printk(KERN_DEBUG "conn_ind: CIlen = %d\n", CIlen);
 413 #endif
 414         skb_pull(skb, CIlen + 1);
 415
 416         /* Calling Party Number */
 417         /* An "additional service" as far as Portugal Telecom is concerned */
 418
 419         len = skb->data[0];
 420
 421         if (len > 0) {
 422                 int count = 1;
 423
 424 #ifdef DEBUG
 425                 printk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
 426 #endif
 427                 if ((skb->data[1] & 0x80) == 0)
 428                         count = 2;
 429
 430                 if (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
 431                         return -1;
 432
 433                 memcpy(info->data.setup.CallingPN, skb->data + count + 1,
 434                        len - count);
 435                 info->data.setup.CallingPN[len - count] = 0;
 436
 437         }
 438         else {
 439                 info->data.setup.CallingPN = NULL;
 440                 printk(KERN_DEBUG "NULL CallingPN\n");
 441         }
 442
 443         skb_pull(skb, len + 1);
 444
 445         /* Calling Party Subaddress */
 446         skb_pull(skb, skb->data[0] + 1);
 447
 448         /* Called Party Number */
 449
 450         len = skb->data[0];
 451
 452         if (len > 0) {
 453                 int count = 1;
 454
 455                 if ((skb->data[1] & 0x80) == 0)
 456                         count = 2;
 457
 458                 if (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
 459                         return -1;
 460
 461                 memcpy(info->data.setup.CalledPN, skb->data + count + 1,
 462                        len - count);
 463                 info->data.setup.CalledPN[len - count] = 0;
 464
 465         }
 466         else {
 467                 info->data.setup.CalledPN = NULL;
 468                 printk(KERN_DEBUG "NULL CalledPN\n");
 469         }
 470
 471         skb_pull(skb, len + 1);
 472
 473         /* Called Party Subaddress */
 474         skb_pull(skb, skb->data[0] + 1);
 475
 476         /* LLC */
 477         skb_pull(skb, skb->data[0] + 1);
 478
 479         /* HLC */
 480         skb_pull(skb, skb->data[0] + 1);
 481
 482         /* U2U */
 483         skb_pull(skb, skb->data[0] + 1);
 484
 485         return 0;
 486 }
 487
 488 /*
 489  *  returns errcode
 490  */
 491
 492 int capi_decode_conn_conf(struct pcbit_chan * chan, struct sk_buff *skb,
 493                           int *complete)
 494 {
 495         int errcode;
 496
 497         chan->callref = *((ushort *) skb->data);     /* Update CallReference */
 498         skb_pull(skb, 2);
 499
 500         errcode = *((ushort *) skb->data);   /* read errcode */
 501         skb_pull(skb, 2);
 502
 503         *complete = *(skb->data);
 504         skb_pull(skb, 1);
 505
 506         /* FIX ME */
 507         /* This is actually a firmware bug */
 508         if (!*complete)
 509         {
 510                 printk(KERN_DEBUG "complete=%02x\n", *complete);
 511                 *complete = 1;
 512         }
 513
 514
 515         /* Optional Bearer Capability */
 516         skb_pull(skb, *(skb->data) + 1);
 517
 518         /* Channel Identification */
 519         skb_pull(skb, *(skb->data) + 1);
 520
 521         /* High Layer Compatibility follows */
 522         skb_pull(skb, *(skb->data) + 1);
 523
 524         return errcode;
 525 }
 526
 527 int capi_decode_conn_actv_ind(struct pcbit_chan * chan, struct sk_buff *skb)
 528 {
 529         ushort len;
 530 #ifdef DEBUG
 531         char str[32];
 532 #endif
 533
 534         /* Yet Another Bearer Capability */
 535         skb_pull(skb, *(skb->data) + 1);
 536
 537
 538         /* Connected Party Number */
 539         len=*(skb->data);
 540
 541 #ifdef DEBUG
 542         if (len > 1 && len < 31) {
 543                 memcpy(str, skb->data + 2, len - 1);
 544                 str[len] = 0;
 545                 printk(KERN_DEBUG "Connected Party Number: %s\n", str);
 546         }
 547         else
 548                 printk(KERN_DEBUG "actv_ind CPN len = %d\n", len);
 549 #endif
 550
 551         skb_pull(skb, len + 1);
 552
 553         /* Connected Subaddress */
 554         skb_pull(skb, *(skb->data) + 1);
 555
 556         /* Low Layer Capability */
 557         skb_pull(skb, *(skb->data) + 1);
 558
 559         /* High Layer Capability */
 560         skb_pull(skb, *(skb->data) + 1);
 561
 562         return 0;
 563 }
 564
 565 int capi_decode_conn_actv_conf(struct pcbit_chan * chan, struct sk_buff *skb)
 566 {
 567         ushort errcode;
 568
 569         errcode = *((ushort*) skb->data);
 570         skb_pull(skb, 2);
 571
 572         /* Channel Identification
 573         skb_pull(skb, skb->data[0] + 1);
 574         */
 575         return errcode;
 576 }
 577
 578
 579 int capi_decode_sel_proto_conf(struct pcbit_chan *chan, struct sk_buff *skb)
 580 {
 581         ushort errcode;
 582
 583         chan->layer2link = *(skb->data);
 584         skb_pull(skb, 1);
 585
 586         errcode = *((ushort*) skb->data);
 587         skb_pull(skb, 2);
 588
 589         return errcode;
 590 }
 591
 592 int capi_decode_actv_trans_conf(struct pcbit_chan *chan, struct sk_buff *skb)
 593 {
 594         ushort errcode;
 595
 596         if (chan->layer2link != *(skb->data) )
 597                 printk("capi_decode_actv_trans_conf: layer2link doesn't match\n");
 598
 599         skb_pull(skb, 1);
 600
 601         errcode = *((ushort*) skb->data);
 602         skb_pull(skb, 2);
 603
 604         return errcode;
 605 }
 606
 607 int capi_decode_disc_ind(struct pcbit_chan *chan, struct sk_buff *skb)
 608 {
 609         ushort len;
 610 #ifdef DEBUG
 611         int i;
 612 #endif
 613         /* Cause */
 614
 615         len = *(skb->data);
 616         skb_pull(skb, 1);
 617
 618 #ifdef DEBUG
 619
 620         for (i=0; i<len; i++)
 621                 printk(KERN_DEBUG "Cause Octect %d: %02x\n", i+3,
 622                        *(skb->data + i));
 623 #endif
 624
 625         skb_pull(skb, len);
 626
 627         return 0;
 628 }
 629
 630 #ifdef DEBUG
 631 int capi_decode_debug_188(u_char *hdr, ushort hdrlen)
 632 {
 633         char str[64];
 634         int len;
 635
 636         len = hdr[0];
 637
 638         if (len < 64 && len == hdrlen - 1) {
 639                 memcpy(str, hdr + 1, hdrlen - 1);
 640                 str[hdrlen - 1] = 0;
 641                 printk("%s\n", str);
 642         }
 643         else
 644                 printk("debug message incorrect\n");
 645
 646         return 0;
 647 }
 648 #endif
 649
 650
 651
 652
 653