drivers/isdn/hisax/l3_1tr6.c

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