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