drivers/isdn/hisax/l3_1tr6.c

   1 /* $Id: l3_1tr6.c,v 2.15.2.3 2004/01/13 14:31:25 keil Exp $
   2  *
   3  * German 1TR6 D-channel protocol
   4  *
   5  * Author       Karsten Keil
   6  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
   7  *
   8  * This software may be used and distributed according to the terms
   9  * of the GNU General Public License, incorporated herein by reference.
  10  *
  11  * For changes and modifications please read
  12  * Documentation/isdn/HiSax.cert
  13  *
  14  */
  15
  16 #include "hisax.h"
  17 #include "l3_1tr6.h"
  18 #include "isdnl3.h"
  19 #include <linux/ctype.h>
  20
  21 extern char *HiSax_getrev(const char *revision);
  22 static const char *l3_1tr6_revision = "$Revision: 2.15.2.3 $";
  23
  24 #define MsgHead(ptr, cref, mty, dis) \
  25         *ptr++ = dis; \
  26         *ptr++ = 0x1; \
  27         *ptr++ = cref ^ 0x80; \
  28         *ptr++ = mty
  29
  30 static void
  31 l3_1TR6_message(struct l3_process *pc, u_char mt, u_char pd)
  32 {
  33         struct sk_buff *skb;
  34         u_char *p;
  35
  36         if (!(skb = l3_alloc_skb(4)))
  37                 return;
  38         p = skb_put(skb, 4);
  39         MsgHead(p, pc->callref, mt, pd);
  40         l3_msg(pc->st, DL_DATA | REQUEST, skb);
  41 }
  42
  43 static void
  44 l3_1tr6_release_req(struct l3_process *pc, u_char pr, void *arg)
  45 {
  46         StopAllL3Timer(pc);
  47         newl3state(pc, 19);
  48         l3_1TR6_message(pc, MT_N1_REL, PROTO_DIS_N1);
  49         L3AddTimer(&pc->timer, T308, CC_T308_1);
  50 }
  51
  52 static void
  53 l3_1tr6_invalid(struct l3_process *pc, u_char pr, void *arg)
  54 {
  55         struct sk_buff *skb = arg;
  56
  57         dev_kfree_skb(skb);
  58         l3_1tr6_release_req(pc, 0, NULL);
  59 }
  60
  61 static void
  62 l3_1tr6_error(struct l3_process *pc, u_char *msg, struct sk_buff *skb)
  63 {
  64         dev_kfree_skb(skb);
  65         if (pc->st->l3.debug & L3_DEB_WARN)
  66                 l3_debug(pc->st, msg);
  67         l3_1tr6_release_req(pc, 0, NULL);
  68 }
  69
  70 static void
  71 l3_1tr6_setup_req(struct l3_process *pc, u_char pr, void *arg)
  72 {
  73         struct sk_buff *skb;
  74         u_char tmp[128];
  75         u_char *p = tmp;
  76         u_char *teln;
  77         u_char *eaz;
  78         u_char channel = 0;
  79         int l;
  80
  81         MsgHead(p, pc->callref, MT_N1_SETUP, PROTO_DIS_N1);
  82         teln = pc->para.setup.phone;
  83         pc->para.spv = 0;
  84         if (!isdigit(*teln)) {
  85                 switch (0x5f & *teln) {
  86                         case 'S':
  87                                 pc->para.spv = 1;
  88                                 break;
  89                         case 'C':
  90                                 channel = 0x08;
  91                         case 'P':
  92                                 channel |= 0x80;
  93                                 teln++;
  94                                 if (*teln == '1')
  95                                         channel |= 0x01;
  96                                 else
  97                                         channel |= 0x02;
  98                                 break;
  99                         default:
 100                                 if (pc->st->l3.debug & L3_DEB_WARN)
 101                                         l3_debug(pc->st, "Wrong MSN Code");
 102                                 break;
 103                 }
 104                 teln++;
 105         }
 106         if (channel) {
 107                 *p++ = 0x18;    /* channel indicator */
 108                 *p++ = 1;
 109                 *p++ = channel;
 110         }
 111         if (pc->para.spv) {     /* SPV ? */
 112                 /* NSF SPV */
 113                 *p++ = WE0_netSpecFac;
 114                 *p++ = 4;       /* Laenge */
 115                 *p++ = 0;
 116                 *p++ = FAC_SPV; /* SPV */
 117                 *p++ = pc->para.setup.si1;      /* 0 for all Services */
 118                 *p++ = pc->para.setup.si2;      /* 0 for all Services */
 119                 *p++ = WE0_netSpecFac;
 120                 *p++ = 4;       /* Laenge */
 121                 *p++ = 0;
 122                 *p++ = FAC_Activate;    /* aktiviere SPV (default) */
 123                 *p++ = pc->para.setup.si1;      /* 0 for all Services */
 124                 *p++ = pc->para.setup.si2;      /* 0 for all Services */
 125         }
 126         eaz = pc->para.setup.eazmsn;
 127         if (*eaz) {
 128                 *p++ = WE0_origAddr;
 129                 *p++ = strlen(eaz) + 1;
 130                 /* Classify as AnyPref. */
 131                 *p++ = 0x81;    /* Ext = '1'B, Type = '000'B, Plan = '0001'B. */
 132                 while (*eaz)
 133                         *p++ = *eaz++ & 0x7f;
 134         }
 135         *p++ = WE0_destAddr;
 136         *p++ = strlen(teln) + 1;
 137         /* Classify as AnyPref. */
 138         *p++ = 0x81;            /* Ext = '1'B, Type = '000'B, Plan = '0001'B. */
 139         while (*teln)
 140                 *p++ = *teln++ & 0x7f;
 141
 142         *p++ = WE_Shift_F6;
 143         /* Codesatz 6 fuer Service */
 144         *p++ = WE6_serviceInd;
 145         *p++ = 2;               /* len=2 info,info2 */
 146         *p++ = pc->para.setup.si1;
 147         *p++ = pc->para.setup.si2;
 148
 149         l = p - tmp;
 150         if (!(skb = l3_alloc_skb(l)))
 151                 return;
 152         memcpy(skb_put(skb, l), tmp, l);
 153         L3DelTimer(&pc->timer);
 154         L3AddTimer(&pc->timer, T303, CC_T303);
 155         newl3state(pc, 1);
 156         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 157 }
 158
 159 static void
 160 l3_1tr6_setup(struct l3_process *pc, u_char pr, void *arg)
 161 {
 162         u_char *p;
 163         int bcfound = 0;
 164         char tmp[80];
 165         struct sk_buff *skb = arg;
 166
 167         p = skb->data;
 168
 169         /* Channel Identification */
 170         p = skb->data;
 171         if ((p = findie(p, skb->len, WE0_chanID, 0))) {
 172                 if (p[1] != 1) {
 173                         l3_1tr6_error(pc, "setup wrong chanID len", skb);
 174                         return;
 175                 }
 176                 if ((p[2] & 0xf4) != 0x80) {
 177                         l3_1tr6_error(pc, "setup wrong WE0_chanID", skb);
 178                         return;
 179                 }
 180                 if ((pc->para.bchannel = p[2] & 0x3))
 181                                 bcfound++;
 182         } else {
 183                 l3_1tr6_error(pc, "missing setup chanID", skb);
 184                 return;
 185         }
 186
 187         p = skb->data;
 188         if ((p = findie(p, skb->len, WE6_serviceInd, 6))) {
 189                 pc->para.setup.si1 = p[2];
 190                 pc->para.setup.si2 = p[3];
 191         } else {
 192                 l3_1tr6_error(pc, "missing setup SI", skb);
 193                 return;
 194         }
 195
 196         p = skb->data;
 197         if ((p = findie(p, skb->len, WE0_destAddr, 0)))
 198                 iecpy(pc->para.setup.eazmsn, p, 1);
 199         else
 200                 pc->para.setup.eazmsn[0] = 0;
 201
 202         p = skb->data;
 203         if ((p = findie(p, skb->len, WE0_origAddr, 0))) {
 204                 iecpy(pc->para.setup.phone, p, 1);
 205         } else
 206                 pc->para.setup.phone[0] = 0;
 207
 208         p = skb->data;
 209         pc->para.spv = 0;
 210         if ((p = findie(p, skb->len, WE0_netSpecFac, 0))) {
 211                 if ((FAC_SPV == p[3]) || (FAC_Activate == p[3]))
 212                         pc->para.spv = 1;
 213         }
 214         dev_kfree_skb(skb);
 215
 216         /* Signal all services, linklevel takes care of Service-Indicator */
 217         if (bcfound) {
 218                 if ((pc->para.setup.si1 != 7) && (pc->st->l3.debug & L3_DEB_WARN)) {
 219                         sprintf(tmp, "non-digital call: %s -> %s",
 220                                 pc->para.setup.phone,
 221                                 pc->para.setup.eazmsn);
 222                         l3_debug(pc->st, tmp);
 223                 }
 224                 newl3state(pc, 6);
 225                 pc->st->l3.l3l4(pc->st, CC_SETUP | INDICATION, pc);
 226         } else
 227                 release_l3_process(pc);
 228 }
 229
 230 static void
 231 l3_1tr6_setup_ack(struct l3_process *pc, u_char pr, void *arg)
 232 {
 233         u_char *p;
 234         struct sk_buff *skb = arg;
 235
 236         L3DelTimer(&pc->timer);
 237         p = skb->data;
 238         newl3state(pc, 2);
 239         if ((p = findie(p, skb->len, WE0_chanID, 0))) {
 240                 if (p[1] != 1) {
 241                         l3_1tr6_error(pc, "setup_ack wrong chanID len", skb);
 242                         return;
 243                 }
 244                 if ((p[2] & 0xf4) != 0x80) {
 245                         l3_1tr6_error(pc, "setup_ack wrong WE0_chanID", skb);
 246                         return;
 247                 }
 248                 pc->para.bchannel = p[2] & 0x3;
 249         } else {
 250                 l3_1tr6_error(pc, "missing setup_ack WE0_chanID", skb);
 251                 return;
 252         }
 253         dev_kfree_skb(skb);
 254         L3AddTimer(&pc->timer, T304, CC_T304);
 255         pc->st->l3.l3l4(pc->st, CC_MORE_INFO | INDICATION, pc);
 256 }
 257
 258 static void
 259 l3_1tr6_call_sent(struct l3_process *pc, u_char pr, void *arg)
 260 {
 261         u_char *p;
 262         struct sk_buff *skb = arg;
 263
 264         L3DelTimer(&pc->timer);
 265         p = skb->data;
 266         if ((p = findie(p, skb->len, WE0_chanID, 0))) {
 267                 if (p[1] != 1) {
 268                         l3_1tr6_error(pc, "call sent wrong chanID len", skb);
 269                         return;
 270                 }
 271                 if ((p[2] & 0xf4) != 0x80) {
 272                         l3_1tr6_error(pc, "call sent wrong WE0_chanID", skb);
 273                         return;
 274                 }
 275                 if ((pc->state == 2) && (pc->para.bchannel != (p[2] & 0x3))) {
 276                         l3_1tr6_error(pc, "call sent wrong chanID value", skb);
 277                         return;
 278                 }
 279                 pc->para.bchannel = p[2] & 0x3;
 280         } else {
 281                 l3_1tr6_error(pc, "missing call sent WE0_chanID", skb);
 282                 return;
 283         }
 284         dev_kfree_skb(skb);
 285         L3AddTimer(&pc->timer, T310, CC_T310);
 286         newl3state(pc, 3);
 287         pc->st->l3.l3l4(pc->st, CC_PROCEEDING | INDICATION, pc);
 288 }
 289
 290 static void
 291 l3_1tr6_alert(struct l3_process *pc, u_char pr, void *arg)
 292 {
 293         struct sk_buff *skb = arg;
 294
 295         dev_kfree_skb(skb);
 296         L3DelTimer(&pc->timer); /* T304 */
 297         newl3state(pc, 4);
 298         pc->st->l3.l3l4(pc->st, CC_ALERTING | INDICATION, pc);
 299 }
 300
 301 static void
 302 l3_1tr6_info(struct l3_process *pc, u_char pr, void *arg)
 303 {
 304         u_char *p;
 305         int i, tmpcharge = 0;
 306         char a_charge[8], tmp[32];
 307         struct sk_buff *skb = arg;
 308
 309         p = skb->data;
 310         if ((p = findie(p, skb->len, WE6_chargingInfo, 6))) {
 311                 iecpy(a_charge, p, 1);
 312                 for (i = 0; i < strlen(a_charge); i++) {
 313                         tmpcharge *= 10;
 314                         tmpcharge += a_charge[i] & 0xf;
 315                 }
 316                 if (tmpcharge > pc->para.chargeinfo) {
 317                         pc->para.chargeinfo = tmpcharge;
 318                         pc->st->l3.l3l4(pc->st, CC_CHARGE | INDICATION, pc);
 319                 }
 320                 if (pc->st->l3.debug & L3_DEB_CHARGE) {
 321                         sprintf(tmp, "charging info %d", pc->para.chargeinfo);
 322                         l3_debug(pc->st, tmp);
 323                 }
 324         } else if (pc->st->l3.debug & L3_DEB_CHARGE)
 325                 l3_debug(pc->st, "charging info not found");
 326         dev_kfree_skb(skb);
 327
 328 }
 329
 330 static void
 331 l3_1tr6_info_s2(struct l3_process *pc, u_char pr, void *arg)
 332 {
 333         struct sk_buff *skb = arg;
 334
 335         dev_kfree_skb(skb);
 336 }
 337
 338 static void
 339 l3_1tr6_connect(struct l3_process *pc, u_char pr, void *arg)
 340 {
 341         struct sk_buff *skb = arg;
 342
 343         L3DelTimer(&pc->timer); /* T310 */
 344         if (!findie(skb->data, skb->len, WE6_date, 6)) {
 345                 l3_1tr6_error(pc, "missing connect date", skb);
 346                 return;
 347         }
 348         newl3state(pc, 10);
 349         dev_kfree_skb(skb);
 350         pc->para.chargeinfo = 0;
 351         pc->st->l3.l3l4(pc->st, CC_SETUP | CONFIRM, pc);
 352 }
 353
 354 static void
 355 l3_1tr6_rel(struct l3_process *pc, u_char pr, void *arg)
 356 {
 357         struct sk_buff *skb = arg;
 358         u_char *p;
 359
 360         p = skb->data;
 361         if ((p = findie(p, skb->len, WE0_cause, 0))) {
 362                 if (p[1] > 0) {
 363                         pc->para.cause = p[2];
 364                         if (p[1] > 1)
 365                                 pc->para.loc = p[3];
 366                         else
 367                                 pc->para.loc = 0;
 368                 } else {
 369                         pc->para.cause = 0;
 370                         pc->para.loc = 0;
 371                 }
 372         } else {
 373                 pc->para.cause = NO_CAUSE;
 374                 l3_1tr6_error(pc, "missing REL cause", skb);
 375                 return;
 376         }
 377         dev_kfree_skb(skb);
 378         StopAllL3Timer(pc);
 379         newl3state(pc, 0);
 380         l3_1TR6_message(pc, MT_N1_REL_ACK, PROTO_DIS_N1);
 381         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
 382         release_l3_process(pc);
 383 }
 384
 385 static void
 386 l3_1tr6_rel_ack(struct l3_process *pc, u_char pr, void *arg)
 387 {
 388         struct sk_buff *skb = arg;
 389
 390         dev_kfree_skb(skb);
 391         StopAllL3Timer(pc);
 392         newl3state(pc, 0);
 393         pc->para.cause = NO_CAUSE;
 394         pc->st->l3.l3l4(pc->st, CC_RELEASE | CONFIRM, pc);
 395         release_l3_process(pc);
 396 }
 397
 398 static void
 399 l3_1tr6_disc(struct l3_process *pc, u_char pr, void *arg)
 400 {
 401         struct sk_buff *skb = arg;
 402         u_char *p;
 403         int i, tmpcharge = 0;
 404         char a_charge[8], tmp[32];
 405
 406         StopAllL3Timer(pc);
 407         p = skb->data;
 408         if ((p = findie(p, skb->len, WE6_chargingInfo, 6))) {
 409                 iecpy(a_charge, p, 1);
 410                 for (i = 0; i < strlen(a_charge); i++) {
 411                         tmpcharge *= 10;
 412                         tmpcharge += a_charge[i] & 0xf;
 413                 }
 414                 if (tmpcharge > pc->para.chargeinfo) {
 415                         pc->para.chargeinfo = tmpcharge;
 416                         pc->st->l3.l3l4(pc->st, CC_CHARGE | INDICATION, pc);
 417                 }
 418                 if (pc->st->l3.debug & L3_DEB_CHARGE) {
 419                         sprintf(tmp, "charging info %d", pc->para.chargeinfo);
 420                         l3_debug(pc->st, tmp);
 421                 }
 422         } else if (pc->st->l3.debug & L3_DEB_CHARGE)
 423                 l3_debug(pc->st, "charging info not found");
 424
 425
 426         p = skb->data;
 427         if ((p = findie(p, skb->len, WE0_cause, 0))) {
 428                 if (p[1] > 0) {
 429                         pc->para.cause = p[2];
 430                         if (p[1] > 1)
 431                                 pc->para.loc = p[3];
 432                         else
 433                                 pc->para.loc = 0;
 434                 } else {
 435                         pc->para.cause = 0;
 436                         pc->para.loc = 0;
 437                 }
 438         } else {
 439                 if (pc->st->l3.debug & L3_DEB_WARN)
 440                         l3_debug(pc->st, "cause not found");
 441                 pc->para.cause = NO_CAUSE;
 442         }
 443         if (!findie(skb->data, skb->len, WE6_date, 6)) {
 444                 l3_1tr6_error(pc, "missing connack date", skb);
 445                 return;
 446         }
 447         dev_kfree_skb(skb);
 448         newl3state(pc, 12);
 449         pc->st->l3.l3l4(pc->st, CC_DISCONNECT | INDICATION, pc);
 450 }
 451
 452
 453 static void
 454 l3_1tr6_connect_ack(struct l3_process *pc, u_char pr, void *arg)
 455 {
 456         struct sk_buff *skb = arg;
 457
 458         if (!findie(skb->data, skb->len, WE6_date, 6)) {
 459                 l3_1tr6_error(pc, "missing connack date", skb);
 460                 return;
 461         }
 462         dev_kfree_skb(skb);
 463         newl3state(pc, 10);
 464         pc->para.chargeinfo = 0;
 465         L3DelTimer(&pc->timer);
 466         pc->st->l3.l3l4(pc->st, CC_SETUP_COMPL | INDICATION, pc);
 467 }
 468
 469 static void
 470 l3_1tr6_alert_req(struct l3_process *pc, u_char pr, void *arg)
 471 {
 472         newl3state(pc, 7);
 473         l3_1TR6_message(pc, MT_N1_ALERT, PROTO_DIS_N1);
 474 }
 475
 476 static void
 477 l3_1tr6_setup_rsp(struct l3_process *pc, u_char pr, void *arg)
 478 {
 479         struct sk_buff *skb;
 480         u_char tmp[24];
 481         u_char *p = tmp;
 482         int l;
 483
 484         MsgHead(p, pc->callref, MT_N1_CONN, PROTO_DIS_N1);
 485         if (pc->para.spv) {     /* SPV ? */
 486                 /* NSF SPV */
 487                 *p++ = WE0_netSpecFac;
 488                 *p++ = 4;       /* Laenge */
 489                 *p++ = 0;
 490                 *p++ = FAC_SPV; /* SPV */
 491                 *p++ = pc->para.setup.si1;
 492                 *p++ = pc->para.setup.si2;
 493                 *p++ = WE0_netSpecFac;
 494                 *p++ = 4;       /* Laenge */
 495                 *p++ = 0;
 496                 *p++ = FAC_Activate;    /* aktiviere SPV */
 497                 *p++ = pc->para.setup.si1;
 498                 *p++ = pc->para.setup.si2;
 499         }
 500         newl3state(pc, 8);
 501         l = p - tmp;
 502         if (!(skb = l3_alloc_skb(l)))
 503                 return;
 504         memcpy(skb_put(skb, l), tmp, l);
 505         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 506         L3DelTimer(&pc->timer);
 507         L3AddTimer(&pc->timer, T313, CC_T313);
 508 }
 509
 510 static void
 511 l3_1tr6_reset(struct l3_process *pc, u_char pr, void *arg)
 512 {
 513         release_l3_process(pc);
 514 }
 515
 516 static void
 517 l3_1tr6_disconnect_req(struct l3_process *pc, u_char pr, void *arg)
 518 {
 519         struct sk_buff *skb;
 520         u_char tmp[16];
 521         u_char *p = tmp;
 522         int l;
 523         u_char cause = 0x10;
 524         u_char clen = 1;
 525
 526         if (pc->para.cause > 0)
 527                 cause = pc->para.cause;
 528         /* Map DSS1 causes */
 529         switch (cause & 0x7f) {
 530                 case 0x10:
 531                         clen = 0;
 532                         break;
 533                 case 0x11:
 534                         cause = CAUSE_UserBusy;
 535                         break;
 536                 case 0x15:
 537                         cause = CAUSE_CallRejected;
 538                         break;
 539         }
 540         StopAllL3Timer(pc);
 541         MsgHead(p, pc->callref, MT_N1_DISC, PROTO_DIS_N1);
 542         *p++ = WE0_cause;
 543         *p++ = clen;            /* Laenge */
 544         if (clen)
 545                 *p++ = cause | 0x80;
 546         newl3state(pc, 11);
 547         l = p - tmp;
 548         if (!(skb = l3_alloc_skb(l)))
 549                 return;
 550         memcpy(skb_put(skb, l), tmp, l);
 551         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 552         L3AddTimer(&pc->timer, T305, CC_T305);
 553 }
 554
 555 static void
 556 l3_1tr6_t303(struct l3_process *pc, u_char pr, void *arg)
 557 {
 558         if (pc->N303 > 0) {
 559                 pc->N303--;
 560                 L3DelTimer(&pc->timer);
 561                 l3_1tr6_setup_req(pc, pr, arg);
 562         } else {
 563                 L3DelTimer(&pc->timer);
 564                 pc->para.cause = 0;
 565                 l3_1tr6_disconnect_req(pc, 0, NULL);
 566         }
 567 }
 568
 569 static void
 570 l3_1tr6_t304(struct l3_process *pc, u_char pr, void *arg)
 571 {
 572         L3DelTimer(&pc->timer);
 573         pc->para.cause = 0xE6;
 574         l3_1tr6_disconnect_req(pc, pr, NULL);
 575         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
 576 }
 577
 578 static void
 579 l3_1tr6_t305(struct l3_process *pc, u_char pr, void *arg)
 580 {
 581         struct sk_buff *skb;
 582         u_char tmp[16];
 583         u_char *p = tmp;
 584         int l;
 585         u_char cause = 0x90;
 586         u_char clen = 1;
 587
 588         L3DelTimer(&pc->timer);
 589         if (pc->para.cause != NO_CAUSE)
 590                 cause = pc->para.cause;
 591         /* Map DSS1 causes */
 592         switch (cause & 0x7f) {
 593                 case 0x10:
 594                         clen = 0;
 595                         break;
 596                 case 0x15:
 597                         cause = CAUSE_CallRejected;
 598                         break;
 599         }
 600         MsgHead(p, pc->callref, MT_N1_REL, PROTO_DIS_N1);
 601         *p++ = WE0_cause;
 602         *p++ = clen;            /* Laenge */
 603         if (clen)
 604                 *p++ = cause;
 605         newl3state(pc, 19);
 606         l = p - tmp;
 607         if (!(skb = l3_alloc_skb(l)))
 608                 return;
 609         memcpy(skb_put(skb, l), tmp, l);
 610         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 611         L3AddTimer(&pc->timer, T308, CC_T308_1);
 612 }
 613
 614 static void
 615 l3_1tr6_t310(struct l3_process *pc, u_char pr, void *arg)
 616 {
 617         L3DelTimer(&pc->timer);
 618         pc->para.cause = 0xE6;
 619         l3_1tr6_disconnect_req(pc, pr, NULL);
 620         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
 621 }
 622
 623 static void
 624 l3_1tr6_t313(struct l3_process *pc, u_char pr, void *arg)
 625 {
 626         L3DelTimer(&pc->timer);
 627         pc->para.cause = 0xE6;
 628         l3_1tr6_disconnect_req(pc, pr, NULL);
 629         pc->st->l3.l3l4(pc->st, CC_CONNECT_ERR, pc);
 630 }
 631
 632 static void
 633 l3_1tr6_t308_1(struct l3_process *pc, u_char pr, void *arg)
 634 {
 635         L3DelTimer(&pc->timer);
 636         l3_1TR6_message(pc, MT_N1_REL, PROTO_DIS_N1);
 637         L3AddTimer(&pc->timer, T308, CC_T308_2);
 638         newl3state(pc, 19);
 639 }
 640
 641 static void
 642 l3_1tr6_t308_2(struct l3_process *pc, u_char pr, void *arg)
 643 {
 644         L3DelTimer(&pc->timer);
 645         pc->st->l3.l3l4(pc->st, CC_RELEASE_ERR, pc);
 646         release_l3_process(pc);
 647 }
 648
 649 static void
 650 l3_1tr6_dl_reset(struct l3_process *pc, u_char pr, void *arg)
 651 {
 652         pc->para.cause = CAUSE_LocalProcErr;
 653         l3_1tr6_disconnect_req(pc, pr, NULL);
 654         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
 655 }
 656
 657 static void
 658 l3_1tr6_dl_release(struct l3_process *pc, u_char pr, void *arg)
 659 {
 660         newl3state(pc, 0);
 661         pc->para.cause = 0x1b;          /* Destination out of order */
 662         pc->para.loc = 0;
 663         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
 664         release_l3_process(pc);
 665 }
 666
 667 /* *INDENT-OFF* */
 668 static struct stateentry downstl[] =
 669 {
 670         {SBIT(0),
 671          CC_SETUP | REQUEST, l3_1tr6_setup_req},
 672         {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(6) | SBIT(7) | SBIT(8) |
 673          SBIT(10),
 674          CC_DISCONNECT | REQUEST, l3_1tr6_disconnect_req},
 675         {SBIT(12),
 676          CC_RELEASE | REQUEST, l3_1tr6_release_req},
 677         {SBIT(6),
 678          CC_IGNORE | REQUEST, l3_1tr6_reset},
 679         {SBIT(6),
 680          CC_REJECT | REQUEST, l3_1tr6_disconnect_req},
 681         {SBIT(6),
 682          CC_ALERTING | REQUEST, l3_1tr6_alert_req},
 683         {SBIT(6) | SBIT(7),
 684          CC_SETUP | RESPONSE, l3_1tr6_setup_rsp},
 685         {SBIT(1),
 686          CC_T303, l3_1tr6_t303},
 687         {SBIT(2),
 688          CC_T304, l3_1tr6_t304},
 689         {SBIT(3),
 690          CC_T310, l3_1tr6_t310},
 691         {SBIT(8),
 692          CC_T313, l3_1tr6_t313},
 693         {SBIT(11),
 694          CC_T305, l3_1tr6_t305},
 695         {SBIT(19),
 696          CC_T308_1, l3_1tr6_t308_1},
 697         {SBIT(19),
 698          CC_T308_2, l3_1tr6_t308_2},
 699 };
 700
 701 #define DOWNSTL_LEN \
 702         (sizeof(downstl) / sizeof(struct stateentry))
 703
 704 static struct stateentry datastln1[] =
 705 {
 706         {SBIT(0),
 707          MT_N1_INVALID, l3_1tr6_invalid},
 708         {SBIT(0),
 709          MT_N1_SETUP, l3_1tr6_setup},
 710         {SBIT(1),
 711          MT_N1_SETUP_ACK, l3_1tr6_setup_ack},
 712         {SBIT(1) | SBIT(2),
 713          MT_N1_CALL_SENT, l3_1tr6_call_sent},
 714         {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(10),
 715          MT_N1_DISC, l3_1tr6_disc},
 716         {SBIT(2) | SBIT(3) | SBIT(4),
 717          MT_N1_ALERT, l3_1tr6_alert},
 718         {SBIT(2) | SBIT(3) | SBIT(4),
 719          MT_N1_CONN, l3_1tr6_connect},
 720         {SBIT(2),
 721          MT_N1_INFO, l3_1tr6_info_s2},
 722         {SBIT(8),
 723          MT_N1_CONN_ACK, l3_1tr6_connect_ack},
 724         {SBIT(10),
 725          MT_N1_INFO, l3_1tr6_info},
 726         {SBIT(0) | SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) |
 727          SBIT(10) | SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17),
 728          MT_N1_REL, l3_1tr6_rel},
 729         {SBIT(19),
 730          MT_N1_REL, l3_1tr6_rel_ack},
 731         {SBIT(0) | SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) |
 732          SBIT(10) | SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17),
 733          MT_N1_REL_ACK, l3_1tr6_invalid},
 734         {SBIT(19),
 735          MT_N1_REL_ACK, l3_1tr6_rel_ack}
 736 };
 737
 738 #define DATASTLN1_LEN \
 739         (sizeof(datastln1) / sizeof(struct stateentry))
 740
 741 static struct stateentry manstatelist[] =
 742 {
 743         {SBIT(2),
 744          DL_ESTABLISH | INDICATION, l3_1tr6_dl_reset},
 745         {ALL_STATES,
 746          DL_RELEASE | INDICATION, l3_1tr6_dl_release},
 747 };
 748
 749 #define MANSLLEN \
 750         (sizeof(manstatelist) / sizeof(struct stateentry))
 751 /* *INDENT-ON* */
 752
 753 static void
 754 up1tr6(struct PStack *st, int pr, void *arg)
 755 {
 756         int i, mt, cr;
 757         struct l3_process *proc;
 758         struct sk_buff *skb = arg;
 759         char tmp[80];
 760
 761         switch (pr) {
 762                 case (DL_DATA | INDICATION):
 763                 case (DL_UNIT_DATA | INDICATION):
 764                         break;
 765                 case (DL_ESTABLISH | CONFIRM):
 766                 case (DL_ESTABLISH | INDICATION):
 767                 case (DL_RELEASE | INDICATION):
 768                 case (DL_RELEASE | CONFIRM):
 769                         l3_msg(st, pr, arg);
 770                         return;
 771                         break;
 772         }
 773         if (skb->len < 4) {
 774                 if (st->l3.debug & L3_DEB_PROTERR) {
 775                         sprintf(tmp, "up1tr6 len only %d", skb->len);
 776                         l3_debug(st, tmp);
 777                 }
 778                 dev_kfree_skb(skb);
 779                 return;
 780         }
 781         if ((skb->data[0] & 0xfe) != PROTO_DIS_N0) {
 782                 if (st->l3.debug & L3_DEB_PROTERR) {
 783                         sprintf(tmp, "up1tr6%sunexpected discriminator %x message len %d",
 784                                 (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
 785                                 skb->data[0], skb->len);
 786                         l3_debug(st, tmp);
 787                 }
 788                 dev_kfree_skb(skb);
 789                 return;
 790         }
 791         if (skb->data[1] != 1) {
 792                 if (st->l3.debug & L3_DEB_PROTERR) {
 793                         sprintf(tmp, "up1tr6 CR len not 1");
 794                         l3_debug(st, tmp);
 795                 }
 796                 dev_kfree_skb(skb);
 797                 return;
 798         }
 799         cr = skb->data[2];
 800         mt = skb->data[3];
 801         if (skb->data[0] == PROTO_DIS_N0) {
 802                 dev_kfree_skb(skb);
 803                 if (st->l3.debug & L3_DEB_STATE) {
 804                         sprintf(tmp, "up1tr6%s N0 mt %x unhandled",
 805                              (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ", mt);
 806                         l3_debug(st, tmp);
 807                 }
 808         } else if (skb->data[0] == PROTO_DIS_N1) {
 809                 if (!(proc = getl3proc(st, cr))) {
 810                         if (mt == MT_N1_SETUP) {
 811                                 if (cr < 128) {
 812                                         if (!(proc = new_l3_process(st, cr))) {
 813                                                 if (st->l3.debug & L3_DEB_PROTERR) {
 814                                                         sprintf(tmp, "up1tr6 no roc mem");
 815                                                         l3_debug(st, tmp);
 816                                                 }
 817                                                 dev_kfree_skb(skb);
 818                                                 return;
 819                                         }
 820                                 } else {
 821                                         dev_kfree_skb(skb);
 822                                         return;
 823                                 }
 824                         } else if ((mt == MT_N1_REL) || (mt == MT_N1_REL_ACK) ||
 825                                 (mt == MT_N1_CANC_ACK) || (mt == MT_N1_CANC_REJ) ||
 826                                 (mt == MT_N1_REG_ACK) || (mt == MT_N1_REG_REJ) ||
 827                                 (mt == MT_N1_SUSP_ACK) || (mt == MT_N1_RES_REJ) ||
 828                                 (mt == MT_N1_INFO)) {
 829                                 dev_kfree_skb(skb);
 830                                 return;
 831                         } else {
 832                                 if (!(proc = new_l3_process(st, cr))) {
 833                                         if (st->l3.debug & L3_DEB_PROTERR) {
 834                                                 sprintf(tmp, "up1tr6 no roc mem");
 835                                                 l3_debug(st, tmp);
 836                                         }
 837                                         dev_kfree_skb(skb);
 838                                         return;
 839                                 }
 840                                 mt = MT_N1_INVALID;
 841                         }
 842                 }
 843                 for (i = 0; i < DATASTLN1_LEN; i++)
 844                         if ((mt == datastln1[i].primitive) &&
 845                             ((1 << proc->state) & datastln1[i].state))
 846                                 break;
 847                 if (i == DATASTLN1_LEN) {
 848                         dev_kfree_skb(skb);
 849                         if (st->l3.debug & L3_DEB_STATE) {
 850                                 sprintf(tmp, "up1tr6%sstate %d mt %x unhandled",
 851                                   (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
 852                                         proc->state, mt);
 853                                 l3_debug(st, tmp);
 854                         }
 855                         return;
 856                 } else {
 857                         if (st->l3.debug & L3_DEB_STATE) {
 858                                 sprintf(tmp, "up1tr6%sstate %d mt %x",
 859                                   (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
 860                                         proc->state, mt);
 861                                 l3_debug(st, tmp);
 862                         }
 863                         datastln1[i].rout(proc, pr, skb);
 864                 }
 865         }
 866 }
 867
 868 static void
 869 down1tr6(struct PStack *st, int pr, void *arg)
 870 {
 871         int i, cr;
 872         struct l3_process *proc;
 873         struct Channel *chan;
 874         char tmp[80];
 875
 876         if ((DL_ESTABLISH | REQUEST)== pr) {
 877                 l3_msg(st, pr, NULL);
 878                 return;
 879         } else if ((CC_SETUP | REQUEST) == pr) {
 880                 chan = arg;
 881                 cr = newcallref();
 882                 cr |= 0x80;
 883                 if (!(proc = new_l3_process(st, cr))) {
 884                         return;
 885                 } else {
 886                         proc->chan = chan;
 887                         chan->proc = proc;
 888                         memcpy(&proc->para.setup, &chan->setup, sizeof(setup_parm));
 889                         proc->callref = cr;
 890                 }
 891         } else {
 892                 proc = arg;
 893         }
 894
 895         for (i = 0; i < DOWNSTL_LEN; i++)
 896                 if ((pr == downstl[i].primitive) &&
 897                     ((1 << proc->state) & downstl[i].state))
 898                         break;
 899         if (i == DOWNSTL_LEN) {
 900                 if (st->l3.debug & L3_DEB_STATE) {
 901                         sprintf(tmp, "down1tr6 state %d prim %d unhandled",
 902                                 proc->state, pr);
 903                         l3_debug(st, tmp);
 904                 }
 905         } else {
 906                 if (st->l3.debug & L3_DEB_STATE) {
 907                         sprintf(tmp, "down1tr6 state %d prim %d",
 908                                 proc->state, pr);
 909                         l3_debug(st, tmp);
 910                 }
 911                 downstl[i].rout(proc, pr, arg);
 912         }
 913 }
 914
 915 static void
 916 man1tr6(struct PStack *st, int pr, void *arg)
 917 {
 918         int i;
 919         struct l3_process *proc = arg;
 920
 921         if (!proc) {
 922                 printk(KERN_ERR "HiSax man1tr6 without proc pr=%04x\n", pr);
 923                 return;
 924         }
 925         for (i = 0; i < MANSLLEN; i++)
 926                 if ((pr == manstatelist[i].primitive) &&
 927                     ((1 << proc->state) & manstatelist[i].state))
 928                         break;
 929         if (i == MANSLLEN) {
 930                 if (st->l3.debug & L3_DEB_STATE) {
 931                         l3_debug(st, "cr %d man1tr6 state %d prim %d unhandled",
 932                                 proc->callref & 0x7f, proc->state, pr);
 933                 }
 934         } else {
 935                 if (st->l3.debug & L3_DEB_STATE) {
 936                         l3_debug(st, "cr %d man1tr6 state %d prim %d",
 937                                 proc->callref & 0x7f, proc->state, pr);
 938                 }
 939                 manstatelist[i].rout(proc, pr, arg);
 940         }
 941 }
 942
 943 void
 944 setstack_1tr6(struct PStack *st)
 945 {
 946         char tmp[64];
 947
 948         st->lli.l4l3 = down1tr6;
 949         st->l2.l2l3 = up1tr6;
 950         st->l3.l3ml3 = man1tr6;
 951         st->l3.N303 = 0;
 952
 953         strcpy(tmp, l3_1tr6_revision);
 954         printk(KERN_INFO "HiSax: 1TR6 Rev. %s\n", HiSax_getrev(tmp));
 955 }