drivers/isdn/act2000/capi.c

   1 /* $Id: capi.c,v 1.9 2000/11/12 16:32:06 kai Exp $
   2  *
   3  * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000.
   4  *        CAPI encoder/decoder
   5  *
   6  * Copyright 1998 by Fritz Elfert (fritz@isdn4linux.de)
   7  * Thanks to Friedemann Baitinger and IBM Germany
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25 #define __NO_VERSION__
  26 #include "act2000.h"
  27 #include "capi.h"
  28
  29 static actcapi_msgdsc valid_msg[] = {
  30         {{ 0x86, 0x02}, "DATA_B3_IND"},       /* DATA_B3_IND/CONF must be first because of speed!!! */
  31         {{ 0x86, 0x01}, "DATA_B3_CONF"},
  32         {{ 0x02, 0x01}, "CONNECT_CONF"},
  33         {{ 0x02, 0x02}, "CONNECT_IND"},
  34         {{ 0x09, 0x01}, "CONNECT_INFO_CONF"},
  35         {{ 0x03, 0x02}, "CONNECT_ACTIVE_IND"},
  36         {{ 0x04, 0x01}, "DISCONNECT_CONF"},
  37         {{ 0x04, 0x02}, "DISCONNECT_IND"},
  38         {{ 0x05, 0x01}, "LISTEN_CONF"},
  39         {{ 0x06, 0x01}, "GET_PARAMS_CONF"},
  40         {{ 0x07, 0x01}, "INFO_CONF"},
  41         {{ 0x07, 0x02}, "INFO_IND"},
  42         {{ 0x08, 0x01}, "DATA_CONF"},
  43         {{ 0x08, 0x02}, "DATA_IND"},
  44         {{ 0x40, 0x01}, "SELECT_B2_PROTOCOL_CONF"},
  45         {{ 0x80, 0x01}, "SELECT_B3_PROTOCOL_CONF"},
  46         {{ 0x81, 0x01}, "LISTEN_B3_CONF"},
  47         {{ 0x82, 0x01}, "CONNECT_B3_CONF"},
  48         {{ 0x82, 0x02}, "CONNECT_B3_IND"},
  49         {{ 0x83, 0x02}, "CONNECT_B3_ACTIVE_IND"},
  50         {{ 0x84, 0x01}, "DISCONNECT_B3_CONF"},
  51         {{ 0x84, 0x02}, "DISCONNECT_B3_IND"},
  52         {{ 0x85, 0x01}, "GET_B3_PARAMS_CONF"},
  53         {{ 0x01, 0x01}, "RESET_B3_CONF"},
  54         {{ 0x01, 0x02}, "RESET_B3_IND"},
  55         /* {{ 0x87, 0x02, "HANDSET_IND"}, not implemented */
  56         {{ 0xff, 0x01}, "MANUFACTURER_CONF"},
  57         {{ 0xff, 0x02}, "MANUFACTURER_IND"},
  58 #ifdef DEBUG_MSG
  59         /* Requests */
  60         {{ 0x01, 0x00}, "RESET_B3_REQ"},
  61         {{ 0x02, 0x00}, "CONNECT_REQ"},
  62         {{ 0x04, 0x00}, "DISCONNECT_REQ"},
  63         {{ 0x05, 0x00}, "LISTEN_REQ"},
  64         {{ 0x06, 0x00}, "GET_PARAMS_REQ"},
  65         {{ 0x07, 0x00}, "INFO_REQ"},
  66         {{ 0x08, 0x00}, "DATA_REQ"},
  67         {{ 0x09, 0x00}, "CONNECT_INFO_REQ"},
  68         {{ 0x40, 0x00}, "SELECT_B2_PROTOCOL_REQ"},
  69         {{ 0x80, 0x00}, "SELECT_B3_PROTOCOL_REQ"},
  70         {{ 0x81, 0x00}, "LISTEN_B3_REQ"},
  71         {{ 0x82, 0x00}, "CONNECT_B3_REQ"},
  72         {{ 0x84, 0x00}, "DISCONNECT_B3_REQ"},
  73         {{ 0x85, 0x00}, "GET_B3_PARAMS_REQ"},
  74         {{ 0x86, 0x00}, "DATA_B3_REQ"},
  75         {{ 0xff, 0x00}, "MANUFACTURER_REQ"},
  76         /* Responses */
  77         {{ 0x01, 0x03}, "RESET_B3_RESP"},
  78         {{ 0x02, 0x03}, "CONNECT_RESP"},
  79         {{ 0x03, 0x03}, "CONNECT_ACTIVE_RESP"},
  80         {{ 0x04, 0x03}, "DISCONNECT_RESP"},
  81         {{ 0x07, 0x03}, "INFO_RESP"},
  82         {{ 0x08, 0x03}, "DATA_RESP"},
  83         {{ 0x82, 0x03}, "CONNECT_B3_RESP"},
  84         {{ 0x83, 0x03}, "CONNECT_B3_ACTIVE_RESP"},
  85         {{ 0x84, 0x03}, "DISCONNECT_B3_RESP"},
  86         {{ 0x86, 0x03}, "DATA_B3_RESP"},
  87         {{ 0xff, 0x03}, "MANUFACTURER_RESP"},
  88 #endif
  89         {{ 0x00, 0x00}, NULL},
  90 };
  91 #define num_valid_msg (sizeof(valid_msg)/sizeof(actcapi_msgdsc))
  92 #define num_valid_imsg 27 /* MANUFACTURER_IND */
  93
  94 /*
  95  * Check for a valid incoming CAPI message.
  96  * Return:
  97  *   0 = Invalid message
  98  *   1 = Valid message, no B-Channel-data
  99  *   2 = Valid message, B-Channel-data
 100  */
 101 int
 102 actcapi_chkhdr(act2000_card * card, actcapi_msghdr *hdr)
 103 {
 104         int i;
 105
 106         if (hdr->applicationID != 1)
 107                 return 0;
 108         if (hdr->len < 9)
 109                 return 0;
 110         for (i = 0; i < num_valid_imsg; i++)
 111                 if ((hdr->cmd.cmd == valid_msg[i].cmd.cmd) &&
 112                     (hdr->cmd.subcmd == valid_msg[i].cmd.subcmd)) {
 113                         return (i?1:2);
 114                 }
 115         return 0;
 116 }
 117
 118 #define ACTCAPI_MKHDR(l, c, s) { \
 119         skb = alloc_skb(l + 8, GFP_ATOMIC); \
 120         if (skb) { \
 121                 m = (actcapi_msg *)skb_put(skb, l + 8); \
 122                 m->hdr.len = l + 8; \
 123                 m->hdr.applicationID = 1; \
 124                 m->hdr.cmd.cmd = c; \
 125                 m->hdr.cmd.subcmd = s; \
 126                 m->hdr.msgnum = actcapi_nextsmsg(card); \
 127         } \
 128 }
 129
 130 #define ACTCAPI_CHKSKB if (!skb) { \
 131         printk(KERN_WARNING "actcapi: alloc_skb failed\n"); \
 132         return; \
 133 }
 134
 135 #define ACTCAPI_QUEUE_TX { \
 136         actcapi_debug_msg(skb, 1); \
 137         skb_queue_tail(&card->sndq, skb); \
 138         act2000_schedule_tx(card); \
 139 }
 140
 141 int
 142 actcapi_listen_req(act2000_card *card)
 143 {
 144         __u16 eazmask = 0;
 145         int i;
 146         actcapi_msg *m;
 147         struct sk_buff *skb;
 148
 149         for (i = 0; i < ACT2000_BCH; i++)
 150                 eazmask |= card->bch[i].eazmask;
 151         ACTCAPI_MKHDR(9, 0x05, 0x00);
 152         if (!skb) {
 153                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 154                 return -ENOMEM;
 155         }
 156         m->msg.listen_req.controller = 0;
 157         m->msg.listen_req.infomask = 0x3f; /* All information */
 158         m->msg.listen_req.eazmask = eazmask;
 159         m->msg.listen_req.simask = (eazmask)?0x86:0; /* All SI's  */
 160         ACTCAPI_QUEUE_TX;
 161         return 0;
 162 }
 163
 164 int
 165 actcapi_connect_req(act2000_card *card, act2000_chan *chan, char *phone,
 166                     char eaz, int si1, int si2)
 167 {
 168         actcapi_msg *m;
 169         struct sk_buff *skb;
 170
 171         ACTCAPI_MKHDR((11 + strlen(phone)), 0x02, 0x00);
 172         if (!skb) {
 173                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 174                 chan->fsm_state = ACT2000_STATE_NULL;
 175                 return -ENOMEM;
 176         }
 177         m->msg.connect_req.controller = 0;
 178         m->msg.connect_req.bchan = 0x83;
 179         m->msg.connect_req.infomask = 0x3f;
 180         m->msg.connect_req.si1 = si1;
 181         m->msg.connect_req.si2 = si2;
 182         m->msg.connect_req.eaz = eaz?eaz:'0';
 183         m->msg.connect_req.addr.len = strlen(phone) + 1;
 184         m->msg.connect_req.addr.tnp = 0x81;
 185         memcpy(m->msg.connect_req.addr.num, phone, strlen(phone));
 186         chan->callref = m->hdr.msgnum;
 187         ACTCAPI_QUEUE_TX;
 188         return 0;
 189 }
 190
 191 static void
 192 actcapi_connect_b3_req(act2000_card *card, act2000_chan *chan)
 193 {
 194         actcapi_msg *m;
 195         struct sk_buff *skb;
 196
 197         ACTCAPI_MKHDR(17, 0x82, 0x00);
 198         ACTCAPI_CHKSKB;
 199         m->msg.connect_b3_req.plci = chan->plci;
 200         memset(&m->msg.connect_b3_req.ncpi, 0,
 201                sizeof(m->msg.connect_b3_req.ncpi));
 202         m->msg.connect_b3_req.ncpi.len = 13;
 203         m->msg.connect_b3_req.ncpi.modulo = 8;
 204         ACTCAPI_QUEUE_TX;
 205 }
 206
 207 /*
 208  * Set net type (1TR6) or (EDSS1)
 209  */
 210 int
 211 actcapi_manufacturer_req_net(act2000_card *card)
 212 {
 213         actcapi_msg *m;
 214         struct sk_buff *skb;
 215
 216         ACTCAPI_MKHDR(5, 0xff, 0x00);
 217         if (!skb) {
 218                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 219                 return -ENOMEM;
 220         }
 221         m->msg.manufacturer_req_net.manuf_msg = 0x11;
 222         m->msg.manufacturer_req_net.controller = 1;
 223         m->msg.manufacturer_req_net.nettype = (card->ptype == ISDN_PTYPE_EURO)?1:0;
 224         ACTCAPI_QUEUE_TX;
 225         printk(KERN_INFO "act2000 %s: D-channel protocol now %s\n",
 226                card->interface.id, (card->ptype == ISDN_PTYPE_EURO)?"euro":"1tr6");
 227         card->interface.features &=
 228                 ~(ISDN_FEATURE_P_UNKNOWN | ISDN_FEATURE_P_EURO | ISDN_FEATURE_P_1TR6);
 229         card->interface.features |=
 230                 ((card->ptype == ISDN_PTYPE_EURO)?ISDN_FEATURE_P_EURO:ISDN_FEATURE_P_1TR6);
 231         return 0;
 232 }
 233
 234 /*
 235  * Switch V.42 on or off
 236  */
 237 int
 238 actcapi_manufacturer_req_v42(act2000_card *card, ulong arg)
 239 {
 240         actcapi_msg *m;
 241         struct sk_buff *skb;
 242
 243         ACTCAPI_MKHDR(8, 0xff, 0x00);
 244         if (!skb) {
 245
 246                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 247                 return -ENOMEM;
 248         }
 249         m->msg.manufacturer_req_v42.manuf_msg = 0x10;
 250         m->msg.manufacturer_req_v42.controller = 0;
 251         m->msg.manufacturer_req_v42.v42control = (arg?1:0);
 252         ACTCAPI_QUEUE_TX;
 253         return 0;
 254 }
 255
 256 /*
 257  * Set error-handler
 258  */
 259 int
 260 actcapi_manufacturer_req_errh(act2000_card *card)
 261 {
 262         actcapi_msg *m;
 263         struct sk_buff *skb;
 264
 265         ACTCAPI_MKHDR(4, 0xff, 0x00);
 266         if (!skb) {
 267
 268                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 269                 return -ENOMEM;
 270         }
 271         m->msg.manufacturer_req_err.manuf_msg = 0x03;
 272         m->msg.manufacturer_req_err.controller = 0;
 273         ACTCAPI_QUEUE_TX;
 274         return 0;
 275 }
 276
 277 /*
 278  * Set MSN-Mapping.
 279  */
 280 int
 281 actcapi_manufacturer_req_msn(act2000_card *card)
 282 {
 283         msn_entry *p = card->msn_list;
 284         actcapi_msg *m;
 285         struct sk_buff *skb;
 286         int len;
 287
 288         while (p) {
 289                 int i;
 290
 291                 len = strlen(p->msn);
 292                 for (i = 0; i < 2; i++) {
 293                         ACTCAPI_MKHDR(6 + len, 0xff, 0x00);
 294                         if (!skb) {
 295                                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 296                                 return -ENOMEM;
 297                         }
 298                         m->msg.manufacturer_req_msn.manuf_msg = 0x13 + i;
 299                         m->msg.manufacturer_req_msn.controller = 0;
 300                         m->msg.manufacturer_req_msn.msnmap.eaz = p->eaz;
 301                         m->msg.manufacturer_req_msn.msnmap.len = len;
 302                         memcpy(m->msg.manufacturer_req_msn.msnmap.msn, p->msn, len);
 303                         ACTCAPI_QUEUE_TX;
 304                 }
 305                 p = p->next;
 306         }
 307         return 0;
 308 }
 309
 310 void
 311 actcapi_select_b2_protocol_req(act2000_card *card, act2000_chan *chan)
 312 {
 313         actcapi_msg *m;
 314         struct sk_buff *skb;
 315
 316         ACTCAPI_MKHDR(10, 0x40, 0x00);
 317         ACTCAPI_CHKSKB;
 318         m->msg.select_b2_protocol_req.plci = chan->plci;
 319         memset(&m->msg.select_b2_protocol_req.dlpd, 0,
 320                sizeof(m->msg.select_b2_protocol_req.dlpd));
 321         m->msg.select_b2_protocol_req.dlpd.len = 6;
 322         switch (chan->l2prot) {
 323                 case ISDN_PROTO_L2_TRANS:
 324                         m->msg.select_b2_protocol_req.protocol = 0x03;
 325                         m->msg.select_b2_protocol_req.dlpd.dlen = 4000;
 326                         break;
 327                 case ISDN_PROTO_L2_HDLC:
 328                         m->msg.select_b2_protocol_req.protocol = 0x02;
 329                         m->msg.select_b2_protocol_req.dlpd.dlen = 4000;
 330                         break;
 331                 case ISDN_PROTO_L2_X75I:
 332                 case ISDN_PROTO_L2_X75UI:
 333                 case ISDN_PROTO_L2_X75BUI:
 334                         m->msg.select_b2_protocol_req.protocol = 0x01;
 335                         m->msg.select_b2_protocol_req.dlpd.dlen = 4000;
 336                         m->msg.select_b2_protocol_req.dlpd.laa = 3;
 337                         m->msg.select_b2_protocol_req.dlpd.lab = 1;
 338                         m->msg.select_b2_protocol_req.dlpd.win = 7;
 339                         m->msg.select_b2_protocol_req.dlpd.modulo = 8;
 340                         break;
 341         }
 342         ACTCAPI_QUEUE_TX;
 343 }
 344
 345 static void
 346 actcapi_select_b3_protocol_req(act2000_card *card, act2000_chan *chan)
 347 {
 348         actcapi_msg *m;
 349         struct sk_buff *skb;
 350
 351         ACTCAPI_MKHDR(17, 0x80, 0x00);
 352         ACTCAPI_CHKSKB;
 353         m->msg.select_b3_protocol_req.plci = chan->plci;
 354         memset(&m->msg.select_b3_protocol_req.ncpd, 0,
 355                sizeof(m->msg.select_b3_protocol_req.ncpd));
 356         switch (chan->l3prot) {
 357                 case ISDN_PROTO_L3_TRANS:
 358                         m->msg.select_b3_protocol_req.protocol = 0x04;
 359                         m->msg.select_b3_protocol_req.ncpd.len = 13;
 360                         m->msg.select_b3_protocol_req.ncpd.modulo = 8;
 361                         break;
 362         }
 363         ACTCAPI_QUEUE_TX;
 364 }
 365
 366 static void
 367 actcapi_listen_b3_req(act2000_card *card, act2000_chan *chan)
 368 {
 369         actcapi_msg *m;
 370         struct sk_buff *skb;
 371
 372         ACTCAPI_MKHDR(2, 0x81, 0x00);
 373         ACTCAPI_CHKSKB;
 374         m->msg.listen_b3_req.plci = chan->plci;
 375         ACTCAPI_QUEUE_TX;
 376 }
 377
 378 static void
 379 actcapi_disconnect_req(act2000_card *card, act2000_chan *chan)
 380 {
 381         actcapi_msg *m;
 382         struct sk_buff *skb;
 383
 384         ACTCAPI_MKHDR(3, 0x04, 0x00);
 385         ACTCAPI_CHKSKB;
 386         m->msg.disconnect_req.plci = chan->plci;
 387         m->msg.disconnect_req.cause = 0;
 388         ACTCAPI_QUEUE_TX;
 389 }
 390
 391 void
 392 actcapi_disconnect_b3_req(act2000_card *card, act2000_chan *chan)
 393 {
 394         actcapi_msg *m;
 395         struct sk_buff *skb;
 396
 397         ACTCAPI_MKHDR(17, 0x84, 0x00);
 398         ACTCAPI_CHKSKB;
 399         m->msg.disconnect_b3_req.ncci = chan->ncci;
 400         memset(&m->msg.disconnect_b3_req.ncpi, 0,
 401                sizeof(m->msg.disconnect_b3_req.ncpi));
 402         m->msg.disconnect_b3_req.ncpi.len = 13;
 403         m->msg.disconnect_b3_req.ncpi.modulo = 8;
 404         chan->fsm_state = ACT2000_STATE_BHWAIT;
 405         ACTCAPI_QUEUE_TX;
 406 }
 407
 408 void
 409 actcapi_connect_resp(act2000_card *card, act2000_chan *chan, __u8 cause)
 410 {
 411         actcapi_msg *m;
 412         struct sk_buff *skb;
 413
 414         ACTCAPI_MKHDR(3, 0x02, 0x03);
 415         ACTCAPI_CHKSKB;
 416         m->msg.connect_resp.plci = chan->plci;
 417         m->msg.connect_resp.rejectcause = cause;
 418         if (cause) {
 419                 chan->fsm_state = ACT2000_STATE_NULL;
 420                 chan->plci = 0x8000;
 421         } else
 422                 chan->fsm_state = ACT2000_STATE_IWAIT;
 423         ACTCAPI_QUEUE_TX;
 424 }
 425
 426 static void
 427 actcapi_connect_active_resp(act2000_card *card, act2000_chan *chan)
 428 {
 429         actcapi_msg *m;
 430         struct sk_buff *skb;
 431
 432         ACTCAPI_MKHDR(2, 0x03, 0x03);
 433         ACTCAPI_CHKSKB;
 434         m->msg.connect_resp.plci = chan->plci;
 435         if (chan->fsm_state == ACT2000_STATE_IWAIT)
 436                 chan->fsm_state = ACT2000_STATE_IBWAIT;
 437         ACTCAPI_QUEUE_TX;
 438 }
 439
 440 static void
 441 actcapi_connect_b3_resp(act2000_card *card, act2000_chan *chan, __u8 rejectcause)
 442 {
 443         actcapi_msg *m;
 444         struct sk_buff *skb;
 445
 446         ACTCAPI_MKHDR((rejectcause?3:17), 0x82, 0x03);
 447         ACTCAPI_CHKSKB;
 448         m->msg.connect_b3_resp.ncci = chan->ncci;
 449         m->msg.connect_b3_resp.rejectcause = rejectcause;
 450         if (!rejectcause) {
 451                 memset(&m->msg.connect_b3_resp.ncpi, 0,
 452                        sizeof(m->msg.connect_b3_resp.ncpi));
 453                 m->msg.connect_b3_resp.ncpi.len = 13;
 454                 m->msg.connect_b3_resp.ncpi.modulo = 8;
 455                 chan->fsm_state = ACT2000_STATE_BWAIT;
 456         }
 457         ACTCAPI_QUEUE_TX;
 458 }
 459
 460 static void
 461 actcapi_connect_b3_active_resp(act2000_card *card, act2000_chan *chan)
 462 {
 463         actcapi_msg *m;
 464         struct sk_buff *skb;
 465
 466         ACTCAPI_MKHDR(2, 0x83, 0x03);
 467         ACTCAPI_CHKSKB;
 468         m->msg.connect_b3_active_resp.ncci = chan->ncci;
 469         chan->fsm_state = ACT2000_STATE_ACTIVE;
 470         ACTCAPI_QUEUE_TX;
 471 }
 472
 473 static void
 474 actcapi_info_resp(act2000_card *card, act2000_chan *chan)
 475 {
 476         actcapi_msg *m;
 477         struct sk_buff *skb;
 478
 479         ACTCAPI_MKHDR(2, 0x07, 0x03);
 480         ACTCAPI_CHKSKB;
 481         m->msg.info_resp.plci = chan->plci;
 482         ACTCAPI_QUEUE_TX;
 483 }
 484
 485 static void
 486 actcapi_disconnect_b3_resp(act2000_card *card, act2000_chan *chan)
 487 {
 488         actcapi_msg *m;
 489         struct sk_buff *skb;
 490
 491         ACTCAPI_MKHDR(2, 0x84, 0x03);
 492         ACTCAPI_CHKSKB;
 493         m->msg.disconnect_b3_resp.ncci = chan->ncci;
 494         chan->ncci = 0x8000;
 495         chan->queued = 0;
 496         ACTCAPI_QUEUE_TX;
 497 }
 498
 499 static void
 500 actcapi_disconnect_resp(act2000_card *card, act2000_chan *chan)
 501 {
 502         actcapi_msg *m;
 503         struct sk_buff *skb;
 504
 505         ACTCAPI_MKHDR(2, 0x04, 0x03);
 506         ACTCAPI_CHKSKB;
 507         m->msg.disconnect_resp.plci = chan->plci;
 508         chan->plci = 0x8000;
 509         ACTCAPI_QUEUE_TX;
 510 }
 511
 512 static int
 513 new_plci(act2000_card *card, __u16 plci)
 514 {
 515         int i;
 516         for (i = 0; i < ACT2000_BCH; i++)
 517                 if (card->bch[i].plci == 0x8000) {
 518                         card->bch[i].plci = plci;
 519                         return i;
 520                 }
 521         return -1;
 522 }
 523
 524 static int
 525 find_plci(act2000_card *card, __u16 plci)
 526 {
 527         int i;
 528         for (i = 0; i < ACT2000_BCH; i++)
 529                 if (card->bch[i].plci == plci)
 530                         return i;
 531         return -1;
 532 }
 533
 534 static int
 535 find_ncci(act2000_card *card, __u16 ncci)
 536 {
 537         int i;
 538         for (i = 0; i < ACT2000_BCH; i++)
 539                 if (card->bch[i].ncci == ncci)
 540                         return i;
 541         return -1;
 542 }
 543
 544 static int
 545 find_dialing(act2000_card *card, __u16 callref)
 546 {
 547         int i;
 548         for (i = 0; i < ACT2000_BCH; i++)
 549                 if ((card->bch[i].callref == callref) &&
 550                     (card->bch[i].fsm_state == ACT2000_STATE_OCALL))
 551                         return i;
 552         return -1;
 553 }
 554
 555 static int
 556 actcapi_data_b3_ind(act2000_card *card, struct sk_buff *skb) {
 557         __u16 plci;
 558         __u16 ncci;
 559         __u16 controller;
 560         __u8  blocknr;
 561         int chan;
 562         actcapi_msg *msg = (actcapi_msg *)skb->data;
 563
 564         EVAL_NCCI(msg->msg.data_b3_ind.fakencci, plci, controller, ncci);
 565         chan = find_ncci(card, ncci);
 566         if (chan < 0)
 567                 return 0;
 568         if (card->bch[chan].fsm_state != ACT2000_STATE_ACTIVE)
 569                 return 0;
 570         if (card->bch[chan].plci != plci)
 571                 return 0;
 572         blocknr = msg->msg.data_b3_ind.blocknr;
 573         skb_pull(skb, 19);
 574         card->interface.rcvcallb_skb(card->myid, chan, skb);
 575         if (!(skb = alloc_skb(11, GFP_ATOMIC))) {
 576                 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
 577                 return 1;
 578         }
 579         msg = (actcapi_msg *)skb_put(skb, 11);
 580         msg->hdr.len = 11;
 581         msg->hdr.applicationID = 1;
 582         msg->hdr.cmd.cmd = 0x86;
 583         msg->hdr.cmd.subcmd = 0x03;
 584         msg->hdr.msgnum = actcapi_nextsmsg(card);
 585         msg->msg.data_b3_resp.ncci = ncci;
 586         msg->msg.data_b3_resp.blocknr = blocknr;
 587         ACTCAPI_QUEUE_TX;
 588         return 1;
 589 }
 590
 591 /*
 592  * Walk over ackq, unlink DATA_B3_REQ from it, if
 593  * ncci and blocknr are matching.
 594  * Decrement queued-bytes counter.
 595  */
 596 static int
 597 handle_ack(act2000_card *card, act2000_chan *chan, __u8 blocknr) {
 598         unsigned long flags;
 599         struct sk_buff *skb;
 600         struct sk_buff *tmp;
 601         struct actcapi_msg *m;
 602         int ret = 0;
 603
 604         save_flags(flags);
 605         cli();
 606         skb = skb_peek(&card->ackq);
 607         restore_flags(flags);
 608         if (!skb) {
 609                 printk(KERN_WARNING "act2000: handle_ack nothing found!\n");
 610                 return 0;
 611         }
 612         tmp = skb;
 613         while (1) {
 614                 m = (actcapi_msg *)tmp->data;
 615                 if ((((m->msg.data_b3_req.fakencci >> 8) & 0xff) == chan->ncci) &&
 616                     (m->msg.data_b3_req.blocknr == blocknr)) {
 617                         /* found corresponding DATA_B3_REQ */
 618                         skb_unlink(tmp);
 619                         chan->queued -= m->msg.data_b3_req.datalen;
 620                         if (m->msg.data_b3_req.flags)
 621                                 ret = m->msg.data_b3_req.datalen;
 622                         dev_kfree_skb(tmp);
 623                         if (chan->queued < 0)
 624                                 chan->queued = 0;
 625                         return ret;
 626                 }
 627                 save_flags(flags);
 628                 cli();
 629                 tmp = skb_peek((struct sk_buff_head *)tmp);
 630                 restore_flags(flags);
 631                 if ((tmp == skb) || (tmp == NULL)) {
 632                         /* reached end of queue */
 633                         printk(KERN_WARNING "act2000: handle_ack nothing found!\n");
 634                         return 0;
 635                 }
 636         }
 637 }
 638
 639 void
 640 actcapi_dispatch(act2000_card *card)
 641 {
 642         struct sk_buff *skb;
 643         actcapi_msg *msg;
 644         __u16 ccmd;
 645         int chan;
 646         int len;
 647         act2000_chan *ctmp;
 648         isdn_ctrl cmd;
 649         char tmp[170];
 650
 651         while ((skb = skb_dequeue(&card->rcvq))) {
 652                 actcapi_debug_msg(skb, 0);
 653                 msg = (actcapi_msg *)skb->data;
 654                 ccmd = ((msg->hdr.cmd.cmd << 8) | msg->hdr.cmd.subcmd);
 655                 switch (ccmd) {
 656                         case 0x8602:
 657                                 /* DATA_B3_IND */
 658                                 if (actcapi_data_b3_ind(card, skb))
 659                                         return;
 660                                 break;
 661                         case 0x8601:
 662                                 /* DATA_B3_CONF */
 663                                 chan = find_ncci(card, msg->msg.data_b3_conf.ncci);
 664                                 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_ACTIVE)) {
 665                                         if (msg->msg.data_b3_conf.info != 0)
 666                                                 printk(KERN_WARNING "act2000: DATA_B3_CONF: %04x\n",
 667                                                        msg->msg.data_b3_conf.info);
 668                                         len = handle_ack(card, &card->bch[chan],
 669                                                          msg->msg.data_b3_conf.blocknr);
 670                                         if (len) {
 671                                                 cmd.driver = card->myid;
 672                                                 cmd.command = ISDN_STAT_BSENT;
 673                                                 cmd.arg = chan;
 674                                                 cmd.parm.length = len;
 675                                                 card->interface.statcallb(&cmd);
 676                                         }
 677                                 }
 678                                 break;
 679                         case 0x0201:
 680                                 /* CONNECT_CONF */
 681                                 chan = find_dialing(card, msg->hdr.msgnum);
 682                                 if (chan >= 0) {
 683                                         if (msg->msg.connect_conf.info) {
 684                                                 card->bch[chan].fsm_state = ACT2000_STATE_NULL;
 685                                                 cmd.driver = card->myid;
 686                                                 cmd.command = ISDN_STAT_DHUP;
 687                                                 cmd.arg = chan;
 688                                                 card->interface.statcallb(&cmd);
 689                                         } else {
 690                                                 card->bch[chan].fsm_state = ACT2000_STATE_OWAIT;
 691                                                 card->bch[chan].plci = msg->msg.connect_conf.plci;
 692                                         }
 693                                 }
 694                                 break;
 695                         case 0x0202:
 696                                 /* CONNECT_IND */
 697                                 chan = new_plci(card, msg->msg.connect_ind.plci);
 698                                 if (chan < 0) {
 699                                         ctmp = (act2000_chan *)tmp;
 700                                         ctmp->plci = msg->msg.connect_ind.plci;
 701                                         actcapi_connect_resp(card, ctmp, 0x11); /* All Card-Cannels busy */
 702                                 } else {
 703                                         card->bch[chan].fsm_state = ACT2000_STATE_ICALL;
 704                                         cmd.driver = card->myid;
 705                                         cmd.command = ISDN_STAT_ICALL;
 706                                         cmd.arg = chan;
 707                                         cmd.parm.setup.si1 = msg->msg.connect_ind.si1;
 708                                         cmd.parm.setup.si2 = msg->msg.connect_ind.si2;
 709                                         if (card->ptype == ISDN_PTYPE_EURO)
 710                                                 strcpy(cmd.parm.setup.eazmsn,
 711                                                        act2000_find_eaz(card, msg->msg.connect_ind.eaz));
 712                                         else {
 713                                                 cmd.parm.setup.eazmsn[0] = msg->msg.connect_ind.eaz;
 714                                                 cmd.parm.setup.eazmsn[1] = 0;
 715                                         }
 716                                         memset(cmd.parm.setup.phone, 0, sizeof(cmd.parm.setup.phone));
 717                                         memcpy(cmd.parm.setup.phone, msg->msg.connect_ind.addr.num,
 718                                                msg->msg.connect_ind.addr.len - 1);
 719                                         cmd.parm.setup.plan = msg->msg.connect_ind.addr.tnp;
 720                                         cmd.parm.setup.screen = 0;
 721                                         if (card->interface.statcallb(&cmd) == 2)
 722                                                 actcapi_connect_resp(card, &card->bch[chan], 0x15); /* Reject Call */
 723                                 }
 724                                 break;
 725                         case 0x0302:
 726                                 /* CONNECT_ACTIVE_IND */
 727                                 chan = find_plci(card, msg->msg.connect_active_ind.plci);
 728                                 if (chan >= 0)
 729                                         switch (card->bch[chan].fsm_state) {
 730                                                 case ACT2000_STATE_IWAIT:
 731                                                         actcapi_connect_active_resp(card, &card->bch[chan]);
 732                                                         break;
 733                                                 case ACT2000_STATE_OWAIT:
 734                                                         actcapi_connect_active_resp(card, &card->bch[chan]);
 735                                                         actcapi_select_b2_protocol_req(card, &card->bch[chan]);
 736                                                         break;
 737                                         }
 738                                 break;
 739                         case 0x8202:
 740                                 /* CONNECT_B3_IND */
 741                                 chan = find_plci(card, msg->msg.connect_b3_ind.plci);
 742                                 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_IBWAIT)) {
 743                                         card->bch[chan].ncci = msg->msg.connect_b3_ind.ncci;
 744                                         actcapi_connect_b3_resp(card, &card->bch[chan], 0);
 745                                 } else {
 746                                         ctmp = (act2000_chan *)tmp;
 747                                         ctmp->ncci = msg->msg.connect_b3_ind.ncci;
 748                                         actcapi_connect_b3_resp(card, ctmp, 0x11); /* All Card-Cannels busy */
 749                                 }
 750                                 break;
 751                         case 0x8302:
 752                                 /* CONNECT_B3_ACTIVE_IND */
 753                                 chan = find_ncci(card, msg->msg.connect_b3_active_ind.ncci);
 754                                 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_BWAIT)) {
 755                                         actcapi_connect_b3_active_resp(card, &card->bch[chan]);
 756                                         cmd.driver = card->myid;
 757                                         cmd.command = ISDN_STAT_BCONN;
 758                                         cmd.arg = chan;
 759                                         card->interface.statcallb(&cmd);
 760                                 }
 761                                 break;
 762                         case 0x8402:
 763                                 /* DISCONNECT_B3_IND */
 764                                 chan = find_ncci(card, msg->msg.disconnect_b3_ind.ncci);
 765                                 if (chan >= 0) {
 766                                         ctmp = &card->bch[chan];
 767                                         actcapi_disconnect_b3_resp(card, ctmp);
 768                                         switch (ctmp->fsm_state) {
 769                                                 case ACT2000_STATE_ACTIVE:
 770                                                         ctmp->fsm_state = ACT2000_STATE_DHWAIT2;
 771                                                         cmd.driver = card->myid;
 772                                                         cmd.command = ISDN_STAT_BHUP;
 773                                                         cmd.arg = chan;
 774                                                         card->interface.statcallb(&cmd);
 775                                                         break;
 776                                                 case ACT2000_STATE_BHWAIT2:
 777                                                         actcapi_disconnect_req(card, ctmp);
 778                                                         ctmp->fsm_state = ACT2000_STATE_DHWAIT;
 779                                                         cmd.driver = card->myid;
 780                                                         cmd.command = ISDN_STAT_BHUP;
 781                                                         cmd.arg = chan;
 782                                                         card->interface.statcallb(&cmd);
 783                                                         break;
 784                                         }
 785                                 }
 786                                 break;
 787                         case 0x0402:
 788                                 /* DISCONNECT_IND */
 789                                 chan = find_plci(card, msg->msg.disconnect_ind.plci);
 790                                 if (chan >= 0) {
 791                                         ctmp = &card->bch[chan];
 792                                         actcapi_disconnect_resp(card, ctmp);
 793                                         ctmp->fsm_state = ACT2000_STATE_NULL;
 794                                         cmd.driver = card->myid;
 795                                         cmd.command = ISDN_STAT_DHUP;
 796                                         cmd.arg = chan;
 797                                         card->interface.statcallb(&cmd);
 798                                 } else {
 799                                         ctmp = (act2000_chan *)tmp;
 800                                         ctmp->plci = msg->msg.disconnect_ind.plci;
 801                                         actcapi_disconnect_resp(card, ctmp);
 802                                 }
 803                                 break;
 804                         case 0x4001:
 805                                 /* SELECT_B2_PROTOCOL_CONF */
 806                                 chan = find_plci(card, msg->msg.select_b2_protocol_conf.plci);
 807                                 if (chan >= 0)
 808                                         switch (card->bch[chan].fsm_state) {
 809                                                 case ACT2000_STATE_ICALL:
 810                                                 case ACT2000_STATE_OWAIT:
 811                                                         ctmp = &card->bch[chan];
 812                                                         if (msg->msg.select_b2_protocol_conf.info == 0)
 813                                                                 actcapi_select_b3_protocol_req(card, ctmp);
 814                                                         else {
 815                                                                 ctmp->fsm_state = ACT2000_STATE_NULL;
 816                                                                 cmd.driver = card->myid;
 817                                                                 cmd.command = ISDN_STAT_DHUP;
 818                                                                 cmd.arg = chan;
 819                                                                 card->interface.statcallb(&cmd);
 820                                                         }
 821                                                         break;
 822                                         }
 823                                 break;
 824                         case 0x8001:
 825                                 /* SELECT_B3_PROTOCOL_CONF */
 826                                 chan = find_plci(card, msg->msg.select_b3_protocol_conf.plci);
 827                                 if (chan >= 0)
 828                                         switch (card->bch[chan].fsm_state) {
 829                                                 case ACT2000_STATE_ICALL:
 830                                                 case ACT2000_STATE_OWAIT:
 831                                                         ctmp = &card->bch[chan];
 832                                                         if (msg->msg.select_b3_protocol_conf.info == 0)
 833                                                                 actcapi_listen_b3_req(card, ctmp);
 834                                                         else {
 835                                                                 ctmp->fsm_state = ACT2000_STATE_NULL;
 836                                                                 cmd.driver = card->myid;
 837                                                                 cmd.command = ISDN_STAT_DHUP;
 838                                                                 cmd.arg = chan;
 839                                                                 card->interface.statcallb(&cmd);
 840                                                         }
 841                                         }
 842                                 break;
 843                         case 0x8101:
 844                                 /* LISTEN_B3_CONF */
 845                                 chan = find_plci(card, msg->msg.listen_b3_conf.plci);
 846                                 if (chan >= 0)
 847                                         switch (card->bch[chan].fsm_state) {
 848                                                 case ACT2000_STATE_ICALL:
 849                                                         ctmp = &card->bch[chan];
 850                                                         if (msg->msg.listen_b3_conf.info == 0)
 851                                                                 actcapi_connect_resp(card, ctmp, 0);
 852                                                         else {
 853                                                                 ctmp->fsm_state = ACT2000_STATE_NULL;
 854                                                                 cmd.driver = card->myid;
 855                                                                 cmd.command = ISDN_STAT_DHUP;
 856                                                                 cmd.arg = chan;
 857                                                                 card->interface.statcallb(&cmd);
 858                                                         }
 859                                                         break;
 860                                                 case ACT2000_STATE_OWAIT:
 861                                                         ctmp = &card->bch[chan];
 862                                                         if (msg->msg.listen_b3_conf.info == 0) {
 863                                                                 actcapi_connect_b3_req(card, ctmp);
 864                                                                 ctmp->fsm_state = ACT2000_STATE_OBWAIT;
 865                                                                 cmd.driver = card->myid;
 866                                                                 cmd.command = ISDN_STAT_DCONN;
 867                                                                 cmd.arg = chan;
 868                                                                 card->interface.statcallb(&cmd);
 869                                                         } else {
 870                                                                 ctmp->fsm_state = ACT2000_STATE_NULL;
 871                                                                 cmd.driver = card->myid;
 872                                                                 cmd.command = ISDN_STAT_DHUP;
 873                                                                 cmd.arg = chan;
 874                                                                 card->interface.statcallb(&cmd);
 875                                                         }
 876                                                         break;
 877                                         }
 878                                 break;
 879                         case 0x8201:
 880                                 /* CONNECT_B3_CONF */
 881                                 chan = find_plci(card, msg->msg.connect_b3_conf.plci);
 882                                 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_OBWAIT)) {
 883                                         ctmp = &card->bch[chan];
 884                                         if (msg->msg.connect_b3_conf.info) {
 885                                                 ctmp->fsm_state = ACT2000_STATE_NULL;
 886                                                 cmd.driver = card->myid;
 887                                                 cmd.command = ISDN_STAT_DHUP;
 888                                                 cmd.arg = chan;
 889                                                 card->interface.statcallb(&cmd);
 890                                         } else {
 891                                                 ctmp->ncci = msg->msg.connect_b3_conf.ncci;
 892                                                 ctmp->fsm_state = ACT2000_STATE_BWAIT;
 893                                         }
 894                                 }
 895                                 break;
 896                         case 0x8401:
 897                                 /* DISCONNECT_B3_CONF */
 898                                 chan = find_ncci(card, msg->msg.disconnect_b3_conf.ncci);
 899                                 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_BHWAIT))
 900                                         card->bch[chan].fsm_state = ACT2000_STATE_BHWAIT2;
 901                                 break;
 902                         case 0x0702:
 903                                 /* INFO_IND */
 904                                 chan = find_plci(card, msg->msg.info_ind.plci);
 905                                 if (chan >= 0)
 906                                         /* TODO: Eval Charging info / cause */
 907                                         actcapi_info_resp(card, &card->bch[chan]);
 908                                 break;
 909                         case 0x0401:
 910                                 /* LISTEN_CONF */
 911                         case 0x0501:
 912                                 /* LISTEN_CONF */
 913                         case 0xff01:
 914                                 /* MANUFACTURER_CONF */
 915                                 break;
 916                         case 0xff02:
 917                                 /* MANUFACTURER_IND */
 918                                 if (msg->msg.manuf_msg == 3) {
 919                                         memset(tmp, 0, sizeof(tmp));
 920                                         strncpy(tmp,
 921                                                 &msg->msg.manufacturer_ind_err.errstring,
 922                                                 msg->hdr.len - 16);
 923                                         if (msg->msg.manufacturer_ind_err.errcode)
 924                                                 printk(KERN_WARNING "act2000: %s\n", tmp);
 925                                         else {
 926                                                 printk(KERN_DEBUG "act2000: %s\n", tmp);
 927                                                 if ((!strncmp(tmp, "INFO: Trace buffer con", 22)) ||
 928                                                     (!strncmp(tmp, "INFO: Compile Date/Tim", 22))) {
 929                                                         card->flags |= ACT2000_FLAGS_RUNNING;
 930                                                         cmd.command = ISDN_STAT_RUN;
 931                                                         cmd.driver = card->myid;
 932                                                         cmd.arg = 0;
 933                                                         actcapi_manufacturer_req_net(card);
 934                                                         actcapi_manufacturer_req_msn(card);
 935                                                         actcapi_listen_req(card);
 936                                                         card->interface.statcallb(&cmd);
 937                                                 }
 938                                         }
 939                                 }
 940                                 break;
 941                         default:
 942                                 printk(KERN_WARNING "act2000: UNHANDLED Message %04x\n", ccmd);
 943                                 break;
 944                 }
 945                 dev_kfree_skb(skb);
 946         }
 947 }
 948
 949 #ifdef DEBUG_MSG
 950 static void
 951 actcapi_debug_caddr(actcapi_addr *addr)
 952 {
 953         char tmp[30];
 954
 955         printk(KERN_DEBUG " Alen  = %d\n", addr->len);
 956         if (addr->len > 0)
 957                 printk(KERN_DEBUG " Atnp  = 0x%02x\n", addr->tnp);
 958         if (addr->len > 1) {
 959                 memset(tmp, 0, 30);
 960                 memcpy(tmp, addr->num, addr->len - 1);
 961                 printk(KERN_DEBUG " Anum  = '%s'\n", tmp);
 962         }
 963 }
 964
 965 static void
 966 actcapi_debug_ncpi(actcapi_ncpi *ncpi)
 967 {
 968         printk(KERN_DEBUG " ncpi.len = %d\n", ncpi->len);
 969         if (ncpi->len >= 2)
 970                 printk(KERN_DEBUG " ncpi.lic = 0x%04x\n", ncpi->lic);
 971         if (ncpi->len >= 4)
 972                 printk(KERN_DEBUG " ncpi.hic = 0x%04x\n", ncpi->hic);
 973         if (ncpi->len >= 6)
 974                 printk(KERN_DEBUG " ncpi.ltc = 0x%04x\n", ncpi->ltc);
 975         if (ncpi->len >= 8)
 976                 printk(KERN_DEBUG " ncpi.htc = 0x%04x\n", ncpi->htc);
 977         if (ncpi->len >= 10)
 978                 printk(KERN_DEBUG " ncpi.loc = 0x%04x\n", ncpi->loc);
 979         if (ncpi->len >= 12)
 980                 printk(KERN_DEBUG " ncpi.hoc = 0x%04x\n", ncpi->hoc);
 981         if (ncpi->len >= 13)
 982                 printk(KERN_DEBUG " ncpi.mod = %d\n", ncpi->modulo);
 983 }
 984
 985 static void
 986 actcapi_debug_dlpd(actcapi_dlpd *dlpd)
 987 {
 988         printk(KERN_DEBUG " dlpd.len = %d\n", dlpd->len);
 989         if (dlpd->len >= 2)
 990                 printk(KERN_DEBUG " dlpd.dlen   = 0x%04x\n", dlpd->dlen);
 991         if (dlpd->len >= 3)
 992                 printk(KERN_DEBUG " dlpd.laa    = 0x%02x\n", dlpd->laa);
 993         if (dlpd->len >= 4)
 994                 printk(KERN_DEBUG " dlpd.lab    = 0x%02x\n", dlpd->lab);
 995         if (dlpd->len >= 5)
 996                 printk(KERN_DEBUG " dlpd.modulo = %d\n", dlpd->modulo);
 997         if (dlpd->len >= 6)
 998                 printk(KERN_DEBUG " dlpd.win    = %d\n", dlpd->win);
 999 }
1000
1001 #ifdef DEBUG_DUMP_SKB
1002 static void dump_skb(struct sk_buff *skb) {
1003         char tmp[80];
1004         char *p = skb->data;
1005         char *t = tmp;
1006         int i;
1007
1008         for (i = 0; i < skb->len; i++) {
1009                 t += sprintf(t, "%02x ", *p++ & 0xff);
1010                 if ((i & 0x0f) == 8) {
1011                         printk(KERN_DEBUG "dump: %s\n", tmp);
1012                         t = tmp;
1013                 }
1014         }
1015         if (i & 0x07)
1016                 printk(KERN_DEBUG "dump: %s\n", tmp);
1017 }
1018 #endif
1019
1020 void
1021 actcapi_debug_msg(struct sk_buff *skb, int direction)
1022 {
1023         actcapi_msg *msg = (actcapi_msg *)skb->data;
1024         char *descr;
1025         int i;
1026         char tmp[170];
1027
1028 #ifndef DEBUG_DATA_MSG
1029         if (msg->hdr.cmd.cmd == 0x86)
1030                 return;
1031 #endif
1032         descr = "INVALID";
1033 #ifdef DEBUG_DUMP_SKB
1034         dump_skb(skb);
1035 #endif
1036         for (i = 0; i < num_valid_msg; i++)
1037                 if ((msg->hdr.cmd.cmd == valid_msg[i].cmd.cmd) &&
1038                     (msg->hdr.cmd.subcmd == valid_msg[i].cmd.subcmd)) {
1039                         descr = valid_msg[i].description;
1040                         break;
1041                 }
1042         printk(KERN_DEBUG "%s %s msg\n", direction?"Outgoing":"Incoming", descr);
1043         printk(KERN_DEBUG " ApplID = %d\n", msg->hdr.applicationID);
1044         printk(KERN_DEBUG " Len    = %d\n", msg->hdr.len);
1045         printk(KERN_DEBUG " MsgNum = 0x%04x\n", msg->hdr.msgnum);
1046         printk(KERN_DEBUG " Cmd    = 0x%02x\n", msg->hdr.cmd.cmd);
1047         printk(KERN_DEBUG " SubCmd = 0x%02x\n", msg->hdr.cmd.subcmd);
1048         switch (i) {
1049                 case 0:
1050                         /* DATA B3 IND */
1051                         printk(KERN_DEBUG " BLOCK = 0x%02x\n",
1052                                msg->msg.data_b3_ind.blocknr);
1053                         break;
1054                 case 2:
1055                         /* CONNECT CONF */
1056                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1057                                msg->msg.connect_conf.plci);
1058                         printk(KERN_DEBUG " Info = 0x%04x\n",
1059                                msg->msg.connect_conf.info);
1060                         break;
1061                 case 3:
1062                         /* CONNECT IND */
1063                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1064                                msg->msg.connect_ind.plci);
1065                         printk(KERN_DEBUG " Contr = %d\n",
1066                                msg->msg.connect_ind.controller);
1067                         printk(KERN_DEBUG " SI1   = %d\n",
1068                                msg->msg.connect_ind.si1);
1069                         printk(KERN_DEBUG " SI2   = %d\n",
1070                                msg->msg.connect_ind.si2);
1071                         printk(KERN_DEBUG " EAZ   = '%c'\n",
1072                                msg->msg.connect_ind.eaz);
1073                         actcapi_debug_caddr(&msg->msg.connect_ind.addr);
1074                         break;
1075                 case 5:
1076                         /* CONNECT ACTIVE IND */
1077                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1078                                msg->msg.connect_active_ind.plci);
1079                         actcapi_debug_caddr(&msg->msg.connect_active_ind.addr);
1080                         break;
1081                 case 8:
1082                         /* LISTEN CONF */
1083                         printk(KERN_DEBUG " Contr = %d\n",
1084                                msg->msg.listen_conf.controller);
1085                         printk(KERN_DEBUG " Info = 0x%04x\n",
1086                                msg->msg.listen_conf.info);
1087                         break;
1088                 case 11:
1089                         /* INFO IND */
1090                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1091                                msg->msg.info_ind.plci);
1092                         printk(KERN_DEBUG " Imsk = 0x%04x\n",
1093                                msg->msg.info_ind.nr.mask);
1094                         if (msg->hdr.len > 12) {
1095                                 int l = msg->hdr.len - 12;
1096                                 int j;
1097                                 char *p = tmp;
1098                                 for (j = 0; j < l ; j++)
1099                                         p += sprintf(p, "%02x ", msg->msg.info_ind.el.display[j]);
1100                                 printk(KERN_DEBUG " D = '%s'\n", tmp);
1101                         }
1102                         break;
1103                 case 14:
1104                         /* SELECT B2 PROTOCOL CONF */
1105                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1106                                msg->msg.select_b2_protocol_conf.plci);
1107                         printk(KERN_DEBUG " Info = 0x%04x\n",
1108                                msg->msg.select_b2_protocol_conf.info);
1109                         break;
1110                 case 15:
1111                         /* SELECT B3 PROTOCOL CONF */
1112                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1113                                msg->msg.select_b3_protocol_conf.plci);
1114                         printk(KERN_DEBUG " Info = 0x%04x\n",
1115                                msg->msg.select_b3_protocol_conf.info);
1116                         break;
1117                 case 16:
1118                         /* LISTEN B3 CONF */
1119                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1120                                msg->msg.listen_b3_conf.plci);
1121                         printk(KERN_DEBUG " Info = 0x%04x\n",
1122                                msg->msg.listen_b3_conf.info);
1123                         break;
1124                 case 18:
1125                         /* CONNECT B3 IND */
1126                         printk(KERN_DEBUG " NCCI = 0x%04x\n",
1127                                msg->msg.connect_b3_ind.ncci);
1128                         printk(KERN_DEBUG " PLCI = 0x%04x\n",
1129                                msg->msg.connect_b3_ind.plci);
1130                         actcapi_debug_ncpi(&msg->msg.connect_b3_ind.ncpi);
1131                         break;
1132                 case 19:
1133                         /* CONNECT B3 ACTIVE IND */
1134                         printk(KERN_DEBUG " NCCI = 0x%04x\n",
1135                                msg->msg.connect_b3_active_ind.ncci);
1136                         actcapi_debug_ncpi(&msg->msg.connect_b3_active_ind.ncpi);
1137                         break;
1138                 case 26:
1139                         /* MANUFACTURER IND */
1140                         printk(KERN_DEBUG " Mmsg = 0x%02x\n",
1141                                msg->msg.manufacturer_ind_err.manuf_msg);
1142                         switch (msg->msg.manufacturer_ind_err.manuf_msg) {
1143                                 case 3:
1144                                         printk(KERN_DEBUG " Contr = %d\n",
1145                                                msg->msg.manufacturer_ind_err.controller);
1146                                         printk(KERN_DEBUG " Code = 0x%08x\n",
1147                                                msg->msg.manufacturer_ind_err.errcode);
1148                                         memset(tmp, 0, sizeof(tmp));
1149                                         strncpy(tmp, &msg->msg.manufacturer_ind_err.errstring,
1150                                                 msg->hdr.len - 16);
1151                                         printk(KERN_DEBUG " Emsg = '%s'\n", tmp);
1152                                         break;
1153                         }
1154                         break;
1155                 case 30:
1156                         /* LISTEN REQ */
1157                         printk(KERN_DEBUG " Imsk = 0x%08x\n",
1158                                msg->msg.listen_req.infomask);
1159                         printk(KERN_DEBUG " Emsk = 0x%04x\n",
1160                                msg->msg.listen_req.eazmask);
1161                         printk(KERN_DEBUG " Smsk = 0x%04x\n",
1162                                msg->msg.listen_req.simask);
1163                         break;
1164                 case 35:
1165                         /* SELECT_B2_PROTOCOL_REQ */
1166                         printk(KERN_DEBUG " PLCI  = 0x%04x\n",
1167                                msg->msg.select_b2_protocol_req.plci);
1168                         printk(KERN_DEBUG " prot  = 0x%02x\n",
1169                                msg->msg.select_b2_protocol_req.protocol);
1170                         if (msg->hdr.len >= 11)
1171                                 printk(KERN_DEBUG "No dlpd\n");
1172                         else
1173                                 actcapi_debug_dlpd(&msg->msg.select_b2_protocol_req.dlpd);
1174                         break;
1175                 case 44:
1176                         /* CONNECT RESP */
1177                         printk(KERN_DEBUG " PLCI  = 0x%04x\n",
1178                                msg->msg.connect_resp.plci);
1179                         printk(KERN_DEBUG " CAUSE = 0x%02x\n",
1180                                msg->msg.connect_resp.rejectcause);
1181                         break;
1182                 case 45:
1183                         /* CONNECT ACTIVE RESP */
1184                         printk(KERN_DEBUG " PLCI  = 0x%04x\n",
1185                                msg->msg.connect_active_resp.plci);
1186                         break;
1187         }
1188 }
1189 #endif