?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CONNECTOR]: Initialize subsystem earlier.
[linux-2.6/verdex.git] / drivers / isdn / act2000 / capi.c
blob6ae6eb32211141a93c299a65f15dd8bd14e20a79
1 /* $Id: capi.c,v 1.9.6.2 2001/09/23 22:24:32 kai 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
19 static 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 */
91 int
92 actcapi_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
131 int
132 actcapi_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
154 int
155 actcapi_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
181 static void
182 actcapi_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 */
200 int
201 actcapi_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 #if 0
228 int
229 actcapi_manufacturer_req_v42(act2000_card *card, ulong arg)
230 {
231 actcapi_msg *m;
232 struct sk_buff *skb;
233
234 ACTCAPI_MKHDR(8, 0xff, 0x00);
235 if (!skb) {
236
237 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
238 return -ENOMEM;
239 }
240 m->msg.manufacturer_req_v42.manuf_msg = 0x10;
241 m->msg.manufacturer_req_v42.controller = 0;
242 m->msg.manufacturer_req_v42.v42control = (arg?1:0);
243 ACTCAPI_QUEUE_TX;
244 return 0;
245 }
246 #endif /* 0 */
247
248 /*
249 * Set error-handler
250 */
251 int
252 actcapi_manufacturer_req_errh(act2000_card *card)
253 {
254 actcapi_msg *m;
255 struct sk_buff *skb;
256
257 ACTCAPI_MKHDR(4, 0xff, 0x00);
258 if (!skb) {
259
260 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
261 return -ENOMEM;
262 }
263 m->msg.manufacturer_req_err.manuf_msg = 0x03;
264 m->msg.manufacturer_req_err.controller = 0;
265 ACTCAPI_QUEUE_TX;
266 return 0;
267 }
268
269 /*
270 * Set MSN-Mapping.
271 */
272 int
273 actcapi_manufacturer_req_msn(act2000_card *card)
274 {
275 msn_entry *p = card->msn_list;
276 actcapi_msg *m;
277 struct sk_buff *skb;
278 int len;
279
280 while (p) {
281 int i;
282
283 len = strlen(p->msn);
284 for (i = 0; i < 2; i++) {
285 ACTCAPI_MKHDR(6 + len, 0xff, 0x00);
286 if (!skb) {
287 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
288 return -ENOMEM;
289 }
290 m->msg.manufacturer_req_msn.manuf_msg = 0x13 + i;
291 m->msg.manufacturer_req_msn.controller = 0;
292 m->msg.manufacturer_req_msn.msnmap.eaz = p->eaz;
293 m->msg.manufacturer_req_msn.msnmap.len = len;
294 memcpy(m->msg.manufacturer_req_msn.msnmap.msn, p->msn, len);
295 ACTCAPI_QUEUE_TX;
296 }
297 p = p->next;
298 }
299 return 0;
300 }
301
302 void
303 actcapi_select_b2_protocol_req(act2000_card *card, act2000_chan *chan)
304 {
305 actcapi_msg *m;
306 struct sk_buff *skb;
307
308 ACTCAPI_MKHDR(10, 0x40, 0x00);
309 ACTCAPI_CHKSKB;
310 m->msg.select_b2_protocol_req.plci = chan->plci;
311 memset(&m->msg.select_b2_protocol_req.dlpd, 0,
312 sizeof(m->msg.select_b2_protocol_req.dlpd));
313 m->msg.select_b2_protocol_req.dlpd.len = 6;
314 switch (chan->l2prot) {
315 case ISDN_PROTO_L2_TRANS:
316 m->msg.select_b2_protocol_req.protocol = 0x03;
317 m->msg.select_b2_protocol_req.dlpd.dlen = 4000;
318 break;
319 case ISDN_PROTO_L2_HDLC:
320 m->msg.select_b2_protocol_req.protocol = 0x02;
321 m->msg.select_b2_protocol_req.dlpd.dlen = 4000;
322 break;
323 case ISDN_PROTO_L2_X75I:
324 case ISDN_PROTO_L2_X75UI:
325 case ISDN_PROTO_L2_X75BUI:
326 m->msg.select_b2_protocol_req.protocol = 0x01;
327 m->msg.select_b2_protocol_req.dlpd.dlen = 4000;
328 m->msg.select_b2_protocol_req.dlpd.laa = 3;
329 m->msg.select_b2_protocol_req.dlpd.lab = 1;
330 m->msg.select_b2_protocol_req.dlpd.win = 7;
331 m->msg.select_b2_protocol_req.dlpd.modulo = 8;
332 break;
333 }
334 ACTCAPI_QUEUE_TX;
335 }
336
337 static void
338 actcapi_select_b3_protocol_req(act2000_card *card, act2000_chan *chan)
339 {
340 actcapi_msg *m;
341 struct sk_buff *skb;
342
343 ACTCAPI_MKHDR(17, 0x80, 0x00);
344 ACTCAPI_CHKSKB;
345 m->msg.select_b3_protocol_req.plci = chan->plci;
346 memset(&m->msg.select_b3_protocol_req.ncpd, 0,
347 sizeof(m->msg.select_b3_protocol_req.ncpd));
348 switch (chan->l3prot) {
349 case ISDN_PROTO_L3_TRANS:
350 m->msg.select_b3_protocol_req.protocol = 0x04;
351 m->msg.select_b3_protocol_req.ncpd.len = 13;
352 m->msg.select_b3_protocol_req.ncpd.modulo = 8;
353 break;
354 }
355 ACTCAPI_QUEUE_TX;
356 }
357
358 static void
359 actcapi_listen_b3_req(act2000_card *card, act2000_chan *chan)
360 {
361 actcapi_msg *m;
362 struct sk_buff *skb;
363
364 ACTCAPI_MKHDR(2, 0x81, 0x00);
365 ACTCAPI_CHKSKB;
366 m->msg.listen_b3_req.plci = chan->plci;
367 ACTCAPI_QUEUE_TX;
368 }
369
370 static void
371 actcapi_disconnect_req(act2000_card *card, act2000_chan *chan)
372 {
373 actcapi_msg *m;
374 struct sk_buff *skb;
375
376 ACTCAPI_MKHDR(3, 0x04, 0x00);
377 ACTCAPI_CHKSKB;
378 m->msg.disconnect_req.plci = chan->plci;
379 m->msg.disconnect_req.cause = 0;
380 ACTCAPI_QUEUE_TX;
381 }
382
383 void
384 actcapi_disconnect_b3_req(act2000_card *card, act2000_chan *chan)
385 {
386 actcapi_msg *m;
387 struct sk_buff *skb;
388
389 ACTCAPI_MKHDR(17, 0x84, 0x00);
390 ACTCAPI_CHKSKB;
391 m->msg.disconnect_b3_req.ncci = chan->ncci;
392 memset(&m->msg.disconnect_b3_req.ncpi, 0,
393 sizeof(m->msg.disconnect_b3_req.ncpi));
394 m->msg.disconnect_b3_req.ncpi.len = 13;
395 m->msg.disconnect_b3_req.ncpi.modulo = 8;
396 chan->fsm_state = ACT2000_STATE_BHWAIT;
397 ACTCAPI_QUEUE_TX;
398 }
399
400 void
401 actcapi_connect_resp(act2000_card *card, act2000_chan *chan, __u8 cause)
402 {
403 actcapi_msg *m;
404 struct sk_buff *skb;
405
406 ACTCAPI_MKHDR(3, 0x02, 0x03);
407 ACTCAPI_CHKSKB;
408 m->msg.connect_resp.plci = chan->plci;
409 m->msg.connect_resp.rejectcause = cause;
410 if (cause) {
411 chan->fsm_state = ACT2000_STATE_NULL;
412 chan->plci = 0x8000;
413 } else
414 chan->fsm_state = ACT2000_STATE_IWAIT;
415 ACTCAPI_QUEUE_TX;
416 }
417
418 static void
419 actcapi_connect_active_resp(act2000_card *card, act2000_chan *chan)
420 {
421 actcapi_msg *m;
422 struct sk_buff *skb;
423
424 ACTCAPI_MKHDR(2, 0x03, 0x03);
425 ACTCAPI_CHKSKB;
426 m->msg.connect_resp.plci = chan->plci;
427 if (chan->fsm_state == ACT2000_STATE_IWAIT)
428 chan->fsm_state = ACT2000_STATE_IBWAIT;
429 ACTCAPI_QUEUE_TX;
430 }
431
432 static void
433 actcapi_connect_b3_resp(act2000_card *card, act2000_chan *chan, __u8 rejectcause)
434 {
435 actcapi_msg *m;
436 struct sk_buff *skb;
437
438 ACTCAPI_MKHDR((rejectcause?3:17), 0x82, 0x03);
439 ACTCAPI_CHKSKB;
440 m->msg.connect_b3_resp.ncci = chan->ncci;
441 m->msg.connect_b3_resp.rejectcause = rejectcause;
442 if (!rejectcause) {
443 memset(&m->msg.connect_b3_resp.ncpi, 0,
444 sizeof(m->msg.connect_b3_resp.ncpi));
445 m->msg.connect_b3_resp.ncpi.len = 13;
446 m->msg.connect_b3_resp.ncpi.modulo = 8;
447 chan->fsm_state = ACT2000_STATE_BWAIT;
448 }
449 ACTCAPI_QUEUE_TX;
450 }
451
452 static void
453 actcapi_connect_b3_active_resp(act2000_card *card, act2000_chan *chan)
454 {
455 actcapi_msg *m;
456 struct sk_buff *skb;
457
458 ACTCAPI_MKHDR(2, 0x83, 0x03);
459 ACTCAPI_CHKSKB;
460 m->msg.connect_b3_active_resp.ncci = chan->ncci;
461 chan->fsm_state = ACT2000_STATE_ACTIVE;
462 ACTCAPI_QUEUE_TX;
463 }
464
465 static void
466 actcapi_info_resp(act2000_card *card, act2000_chan *chan)
467 {
468 actcapi_msg *m;
469 struct sk_buff *skb;
470
471 ACTCAPI_MKHDR(2, 0x07, 0x03);
472 ACTCAPI_CHKSKB;
473 m->msg.info_resp.plci = chan->plci;
474 ACTCAPI_QUEUE_TX;
475 }
476
477 static void
478 actcapi_disconnect_b3_resp(act2000_card *card, act2000_chan *chan)
479 {
480 actcapi_msg *m;
481 struct sk_buff *skb;
482
483 ACTCAPI_MKHDR(2, 0x84, 0x03);
484 ACTCAPI_CHKSKB;
485 m->msg.disconnect_b3_resp.ncci = chan->ncci;
486 chan->ncci = 0x8000;
487 chan->queued = 0;
488 ACTCAPI_QUEUE_TX;
489 }
490
491 static void
492 actcapi_disconnect_resp(act2000_card *card, act2000_chan *chan)
493 {
494 actcapi_msg *m;
495 struct sk_buff *skb;
496
497 ACTCAPI_MKHDR(2, 0x04, 0x03);
498 ACTCAPI_CHKSKB;
499 m->msg.disconnect_resp.plci = chan->plci;
500 chan->plci = 0x8000;
501 ACTCAPI_QUEUE_TX;
502 }
503
504 static int
505 new_plci(act2000_card *card, __u16 plci)
506 {
507 int i;
508 for (i = 0; i < ACT2000_BCH; i++)
509 if (card->bch[i].plci == 0x8000) {
510 card->bch[i].plci = plci;
511 return i;
512 }
513 return -1;
514 }
515
516 static int
517 find_plci(act2000_card *card, __u16 plci)
518 {
519 int i;
520 for (i = 0; i < ACT2000_BCH; i++)
521 if (card->bch[i].plci == plci)
522 return i;
523 return -1;
524 }
525
526 static int
527 find_ncci(act2000_card *card, __u16 ncci)
528 {
529 int i;
530 for (i = 0; i < ACT2000_BCH; i++)
531 if (card->bch[i].ncci == ncci)
532 return i;
533 return -1;
534 }
535
536 static int
537 find_dialing(act2000_card *card, __u16 callref)
538 {
539 int i;
540 for (i = 0; i < ACT2000_BCH; i++)
541 if ((card->bch[i].callref == callref) &&
542 (card->bch[i].fsm_state == ACT2000_STATE_OCALL))
543 return i;
544 return -1;
545 }
546
547 static int
548 actcapi_data_b3_ind(act2000_card *card, struct sk_buff *skb) {
549 __u16 plci;
550 __u16 ncci;
551 __u16 controller;
552 __u8 blocknr;
553 int chan;
554 actcapi_msg *msg = (actcapi_msg *)skb->data;
555
556 EVAL_NCCI(msg->msg.data_b3_ind.fakencci, plci, controller, ncci);
557 chan = find_ncci(card, ncci);
558 if (chan < 0)
559 return 0;
560 if (card->bch[chan].fsm_state != ACT2000_STATE_ACTIVE)
561 return 0;
562 if (card->bch[chan].plci != plci)
563 return 0;
564 blocknr = msg->msg.data_b3_ind.blocknr;
565 skb_pull(skb, 19);
566 card->interface.rcvcallb_skb(card->myid, chan, skb);
567 if (!(skb = alloc_skb(11, GFP_ATOMIC))) {
568 printk(KERN_WARNING "actcapi: alloc_skb failed\n");
569 return 1;
570 }
571 msg = (actcapi_msg *)skb_put(skb, 11);
572 msg->hdr.len = 11;
573 msg->hdr.applicationID = 1;
574 msg->hdr.cmd.cmd = 0x86;
575 msg->hdr.cmd.subcmd = 0x03;
576 msg->hdr.msgnum = actcapi_nextsmsg(card);
577 msg->msg.data_b3_resp.ncci = ncci;
578 msg->msg.data_b3_resp.blocknr = blocknr;
579 ACTCAPI_QUEUE_TX;
580 return 1;
581 }
582
583 /*
584 * Walk over ackq, unlink DATA_B3_REQ from it, if
585 * ncci and blocknr are matching.
586 * Decrement queued-bytes counter.
587 */
588 static int
589 handle_ack(act2000_card *card, act2000_chan *chan, __u8 blocknr) {
590 unsigned long flags;
591 struct sk_buff *skb;
592 struct sk_buff *tmp;
593 struct actcapi_msg *m;
594 int ret = 0;
595
596 spin_lock_irqsave(&card->lock, flags);
597 skb = skb_peek(&card->ackq);
598 spin_unlock_irqrestore(&card->lock, flags);
599 if (!skb) {
600 printk(KERN_WARNING "act2000: handle_ack nothing found!\n");
601 return 0;
602 }
603 tmp = skb;
604 while (1) {
605 m = (actcapi_msg *)tmp->data;
606 if ((((m->msg.data_b3_req.fakencci >> 8) & 0xff) == chan->ncci) &&
607 (m->msg.data_b3_req.blocknr == blocknr)) {
608 /* found corresponding DATA_B3_REQ */
609 skb_unlink(tmp, &card->ackq);
610 chan->queued -= m->msg.data_b3_req.datalen;
611 if (m->msg.data_b3_req.flags)
612 ret = m->msg.data_b3_req.datalen;
613 dev_kfree_skb(tmp);
614 if (chan->queued < 0)
615 chan->queued = 0;
616 return ret;
617 }
618 spin_lock_irqsave(&card->lock, flags);
619 tmp = skb_peek((struct sk_buff_head *)tmp);
620 spin_unlock_irqrestore(&card->lock, flags);
621 if ((tmp == skb) || (tmp == NULL)) {
622 /* reached end of queue */
623 printk(KERN_WARNING "act2000: handle_ack nothing found!\n");
624 return 0;
625 }
626 }
627 }
628
629 void
630 actcapi_dispatch(act2000_card *card)
631 {
632 struct sk_buff *skb;
633 actcapi_msg *msg;
634 __u16 ccmd;
635 int chan;
636 int len;
637 act2000_chan *ctmp;
638 isdn_ctrl cmd;
639 char tmp[170];
640
641 while ((skb = skb_dequeue(&card->rcvq))) {
642 actcapi_debug_msg(skb, 0);
643 msg = (actcapi_msg *)skb->data;
644 ccmd = ((msg->hdr.cmd.cmd << 8) | msg->hdr.cmd.subcmd);
645 switch (ccmd) {
646 case 0x8602:
647 /* DATA_B3_IND */
648 if (actcapi_data_b3_ind(card, skb))
649 return;
650 break;
651 case 0x8601:
652 /* DATA_B3_CONF */
653 chan = find_ncci(card, msg->msg.data_b3_conf.ncci);
654 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_ACTIVE)) {
655 if (msg->msg.data_b3_conf.info != 0)
656 printk(KERN_WARNING "act2000: DATA_B3_CONF: %04x\n",
657 msg->msg.data_b3_conf.info);
658 len = handle_ack(card, &card->bch[chan],
659 msg->msg.data_b3_conf.blocknr);
660 if (len) {
661 cmd.driver = card->myid;
662 cmd.command = ISDN_STAT_BSENT;
663 cmd.arg = chan;
664 cmd.parm.length = len;
665 card->interface.statcallb(&cmd);
666 }
667 }
668 break;
669 case 0x0201:
670 /* CONNECT_CONF */
671 chan = find_dialing(card, msg->hdr.msgnum);
672 if (chan >= 0) {
673 if (msg->msg.connect_conf.info) {
674 card->bch[chan].fsm_state = ACT2000_STATE_NULL;
675 cmd.driver = card->myid;
676 cmd.command = ISDN_STAT_DHUP;
677 cmd.arg = chan;
678 card->interface.statcallb(&cmd);
679 } else {
680 card->bch[chan].fsm_state = ACT2000_STATE_OWAIT;
681 card->bch[chan].plci = msg->msg.connect_conf.plci;
682 }
683 }
684 break;
685 case 0x0202:
686 /* CONNECT_IND */
687 chan = new_plci(card, msg->msg.connect_ind.plci);
688 if (chan < 0) {
689 ctmp = (act2000_chan *)tmp;
690 ctmp->plci = msg->msg.connect_ind.plci;
691 actcapi_connect_resp(card, ctmp, 0x11); /* All Card-Cannels busy */
692 } else {
693 card->bch[chan].fsm_state = ACT2000_STATE_ICALL;
694 cmd.driver = card->myid;
695 cmd.command = ISDN_STAT_ICALL;
696 cmd.arg = chan;
697 cmd.parm.setup.si1 = msg->msg.connect_ind.si1;
698 cmd.parm.setup.si2 = msg->msg.connect_ind.si2;
699 if (card->ptype == ISDN_PTYPE_EURO)
700 strcpy(cmd.parm.setup.eazmsn,
701 act2000_find_eaz(card, msg->msg.connect_ind.eaz));
702 else {
703 cmd.parm.setup.eazmsn[0] = msg->msg.connect_ind.eaz;
704 cmd.parm.setup.eazmsn[1] = 0;
705 }
706 memset(cmd.parm.setup.phone, 0, sizeof(cmd.parm.setup.phone));
707 memcpy(cmd.parm.setup.phone, msg->msg.connect_ind.addr.num,
708 msg->msg.connect_ind.addr.len - 1);
709 cmd.parm.setup.plan = msg->msg.connect_ind.addr.tnp;
710 cmd.parm.setup.screen = 0;
711 if (card->interface.statcallb(&cmd) == 2)
712 actcapi_connect_resp(card, &card->bch[chan], 0x15); /* Reject Call */
713 }
714 break;
715 case 0x0302:
716 /* CONNECT_ACTIVE_IND */
717 chan = find_plci(card, msg->msg.connect_active_ind.plci);
718 if (chan >= 0)
719 switch (card->bch[chan].fsm_state) {
720 case ACT2000_STATE_IWAIT:
721 actcapi_connect_active_resp(card, &card->bch[chan]);
722 break;
723 case ACT2000_STATE_OWAIT:
724 actcapi_connect_active_resp(card, &card->bch[chan]);
725 actcapi_select_b2_protocol_req(card, &card->bch[chan]);
726 break;
727 }
728 break;
729 case 0x8202:
730 /* CONNECT_B3_IND */
731 chan = find_plci(card, msg->msg.connect_b3_ind.plci);
732 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_IBWAIT)) {
733 card->bch[chan].ncci = msg->msg.connect_b3_ind.ncci;
734 actcapi_connect_b3_resp(card, &card->bch[chan], 0);
735 } else {
736 ctmp = (act2000_chan *)tmp;
737 ctmp->ncci = msg->msg.connect_b3_ind.ncci;
738 actcapi_connect_b3_resp(card, ctmp, 0x11); /* All Card-Cannels busy */
739 }
740 break;
741 case 0x8302:
742 /* CONNECT_B3_ACTIVE_IND */
743 chan = find_ncci(card, msg->msg.connect_b3_active_ind.ncci);
744 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_BWAIT)) {
745 actcapi_connect_b3_active_resp(card, &card->bch[chan]);
746 cmd.driver = card->myid;
747 cmd.command = ISDN_STAT_BCONN;
748 cmd.arg = chan;
749 card->interface.statcallb(&cmd);
750 }
751 break;
752 case 0x8402:
753 /* DISCONNECT_B3_IND */
754 chan = find_ncci(card, msg->msg.disconnect_b3_ind.ncci);
755 if (chan >= 0) {
756 ctmp = &card->bch[chan];
757 actcapi_disconnect_b3_resp(card, ctmp);
758 switch (ctmp->fsm_state) {
759 case ACT2000_STATE_ACTIVE:
760 ctmp->fsm_state = ACT2000_STATE_DHWAIT2;
761 cmd.driver = card->myid;
762 cmd.command = ISDN_STAT_BHUP;
763 cmd.arg = chan;
764 card->interface.statcallb(&cmd);
765 break;
766 case ACT2000_STATE_BHWAIT2:
767 actcapi_disconnect_req(card, ctmp);
768 ctmp->fsm_state = ACT2000_STATE_DHWAIT;
769 cmd.driver = card->myid;
770 cmd.command = ISDN_STAT_BHUP;
771 cmd.arg = chan;
772 card->interface.statcallb(&cmd);
773 break;
774 }
775 }
776 break;
777 case 0x0402:
778 /* DISCONNECT_IND */
779 chan = find_plci(card, msg->msg.disconnect_ind.plci);
780 if (chan >= 0) {
781 ctmp = &card->bch[chan];
782 actcapi_disconnect_resp(card, ctmp);
783 ctmp->fsm_state = ACT2000_STATE_NULL;
784 cmd.driver = card->myid;
785 cmd.command = ISDN_STAT_DHUP;
786 cmd.arg = chan;
787 card->interface.statcallb(&cmd);
788 } else {
789 ctmp = (act2000_chan *)tmp;
790 ctmp->plci = msg->msg.disconnect_ind.plci;
791 actcapi_disconnect_resp(card, ctmp);
792 }
793 break;
794 case 0x4001:
795 /* SELECT_B2_PROTOCOL_CONF */
796 chan = find_plci(card, msg->msg.select_b2_protocol_conf.plci);
797 if (chan >= 0)
798 switch (card->bch[chan].fsm_state) {
799 case ACT2000_STATE_ICALL:
800 case ACT2000_STATE_OWAIT:
801 ctmp = &card->bch[chan];
802 if (msg->msg.select_b2_protocol_conf.info == 0)
803 actcapi_select_b3_protocol_req(card, ctmp);
804 else {
805 ctmp->fsm_state = ACT2000_STATE_NULL;
806 cmd.driver = card->myid;
807 cmd.command = ISDN_STAT_DHUP;
808 cmd.arg = chan;
809 card->interface.statcallb(&cmd);
810 }
811 break;
812 }
813 break;
814 case 0x8001:
815 /* SELECT_B3_PROTOCOL_CONF */
816 chan = find_plci(card, msg->msg.select_b3_protocol_conf.plci);
817 if (chan >= 0)
818 switch (card->bch[chan].fsm_state) {
819 case ACT2000_STATE_ICALL:
820 case ACT2000_STATE_OWAIT:
821 ctmp = &card->bch[chan];
822 if (msg->msg.select_b3_protocol_conf.info == 0)
823 actcapi_listen_b3_req(card, ctmp);
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 }
832 break;
833 case 0x8101:
834 /* LISTEN_B3_CONF */
835 chan = find_plci(card, msg->msg.listen_b3_conf.plci);
836 if (chan >= 0)
837 switch (card->bch[chan].fsm_state) {
838 case ACT2000_STATE_ICALL:
839 ctmp = &card->bch[chan];
840 if (msg->msg.listen_b3_conf.info == 0)
841 actcapi_connect_resp(card, ctmp, 0);
842 else {
843 ctmp->fsm_state = ACT2000_STATE_NULL;
844 cmd.driver = card->myid;
845 cmd.command = ISDN_STAT_DHUP;
846 cmd.arg = chan;
847 card->interface.statcallb(&cmd);
848 }
849 break;
850 case ACT2000_STATE_OWAIT:
851 ctmp = &card->bch[chan];
852 if (msg->msg.listen_b3_conf.info == 0) {
853 actcapi_connect_b3_req(card, ctmp);
854 ctmp->fsm_state = ACT2000_STATE_OBWAIT;
855 cmd.driver = card->myid;
856 cmd.command = ISDN_STAT_DCONN;
857 cmd.arg = chan;
858 card->interface.statcallb(&cmd);
859 } else {
860 ctmp->fsm_state = ACT2000_STATE_NULL;
861 cmd.driver = card->myid;
862 cmd.command = ISDN_STAT_DHUP;
863 cmd.arg = chan;
864 card->interface.statcallb(&cmd);
865 }
866 break;
867 }
868 break;
869 case 0x8201:
870 /* CONNECT_B3_CONF */
871 chan = find_plci(card, msg->msg.connect_b3_conf.plci);
872 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_OBWAIT)) {
873 ctmp = &card->bch[chan];
874 if (msg->msg.connect_b3_conf.info) {
875 ctmp->fsm_state = ACT2000_STATE_NULL;
876 cmd.driver = card->myid;
877 cmd.command = ISDN_STAT_DHUP;
878 cmd.arg = chan;
879 card->interface.statcallb(&cmd);
880 } else {
881 ctmp->ncci = msg->msg.connect_b3_conf.ncci;
882 ctmp->fsm_state = ACT2000_STATE_BWAIT;
883 }
884 }
885 break;
886 case 0x8401:
887 /* DISCONNECT_B3_CONF */
888 chan = find_ncci(card, msg->msg.disconnect_b3_conf.ncci);
889 if ((chan >= 0) && (card->bch[chan].fsm_state == ACT2000_STATE_BHWAIT))
890 card->bch[chan].fsm_state = ACT2000_STATE_BHWAIT2;
891 break;
892 case 0x0702:
893 /* INFO_IND */
894 chan = find_plci(card, msg->msg.info_ind.plci);
895 if (chan >= 0)
896 /* TODO: Eval Charging info / cause */
897 actcapi_info_resp(card, &card->bch[chan]);
898 break;
899 case 0x0401:
900 /* LISTEN_CONF */
901 case 0x0501:
902 /* LISTEN_CONF */
903 case 0xff01:
904 /* MANUFACTURER_CONF */
905 break;
906 case 0xff02:
907 /* MANUFACTURER_IND */
908 if (msg->msg.manuf_msg == 3) {
909 memset(tmp, 0, sizeof(tmp));
910 strncpy(tmp,
911 &msg->msg.manufacturer_ind_err.errstring,
912 msg->hdr.len - 16);
913 if (msg->msg.manufacturer_ind_err.errcode)
914 printk(KERN_WARNING "act2000: %s\n", tmp);
915 else {
916 printk(KERN_DEBUG "act2000: %s\n", tmp);
917 if ((!strncmp(tmp, "INFO: Trace buffer con", 22)) ||
918 (!strncmp(tmp, "INFO: Compile Date/Tim", 22))) {
919 card->flags |= ACT2000_FLAGS_RUNNING;
920 cmd.command = ISDN_STAT_RUN;
921 cmd.driver = card->myid;
922 cmd.arg = 0;
923 actcapi_manufacturer_req_net(card);
924 actcapi_manufacturer_req_msn(card);
925 actcapi_listen_req(card);
926 card->interface.statcallb(&cmd);
927 }
928 }
929 }
930 break;
931 default:
932 printk(KERN_WARNING "act2000: UNHANDLED Message %04x\n", ccmd);
933 break;
934 }
935 dev_kfree_skb(skb);
936 }
937 }
938
939 #ifdef DEBUG_MSG
940 static void
941 actcapi_debug_caddr(actcapi_addr *addr)
942 {
943 char tmp[30];
944
945 printk(KERN_DEBUG " Alen = %d\n", addr->len);
946 if (addr->len > 0)
947 printk(KERN_DEBUG " Atnp = 0x%02x\n", addr->tnp);
948 if (addr->len > 1) {
949 memset(tmp, 0, 30);
950 memcpy(tmp, addr->num, addr->len - 1);
951 printk(KERN_DEBUG " Anum = '%s'\n", tmp);
952 }
953 }
954
955 static void
956 actcapi_debug_ncpi(actcapi_ncpi *ncpi)
957 {
958 printk(KERN_DEBUG " ncpi.len = %d\n", ncpi->len);
959 if (ncpi->len >= 2)
960 printk(KERN_DEBUG " ncpi.lic = 0x%04x\n", ncpi->lic);
961 if (ncpi->len >= 4)
962 printk(KERN_DEBUG " ncpi.hic = 0x%04x\n", ncpi->hic);
963 if (ncpi->len >= 6)
964 printk(KERN_DEBUG " ncpi.ltc = 0x%04x\n", ncpi->ltc);
965 if (ncpi->len >= 8)
966 printk(KERN_DEBUG " ncpi.htc = 0x%04x\n", ncpi->htc);
967 if (ncpi->len >= 10)
968 printk(KERN_DEBUG " ncpi.loc = 0x%04x\n", ncpi->loc);
969 if (ncpi->len >= 12)
970 printk(KERN_DEBUG " ncpi.hoc = 0x%04x\n", ncpi->hoc);
971 if (ncpi->len >= 13)
972 printk(KERN_DEBUG " ncpi.mod = %d\n", ncpi->modulo);
973 }
974
975 static void
976 actcapi_debug_dlpd(actcapi_dlpd *dlpd)
977 {
978 printk(KERN_DEBUG " dlpd.len = %d\n", dlpd->len);
979 if (dlpd->len >= 2)
980 printk(KERN_DEBUG " dlpd.dlen = 0x%04x\n", dlpd->dlen);
981 if (dlpd->len >= 3)
982 printk(KERN_DEBUG " dlpd.laa = 0x%02x\n", dlpd->laa);
983 if (dlpd->len >= 4)
984 printk(KERN_DEBUG " dlpd.lab = 0x%02x\n", dlpd->lab);
985 if (dlpd->len >= 5)
986 printk(KERN_DEBUG " dlpd.modulo = %d\n", dlpd->modulo);
987 if (dlpd->len >= 6)
988 printk(KERN_DEBUG " dlpd.win = %d\n", dlpd->win);
989 }
990
991 #ifdef DEBUG_DUMP_SKB
992 static void dump_skb(struct sk_buff *skb) {
993 char tmp[80];
994 char *p = skb->data;
995 char *t = tmp;
996 int i;
997
998 for (i = 0; i < skb->len; i++) {
999 t += sprintf(t, "%02x ", *p++ & 0xff);
1000 if ((i & 0x0f) == 8) {
1001 printk(KERN_DEBUG "dump: %s\n", tmp);
1002 t = tmp;
1003 }
1004 }
1005 if (i & 0x07)
1006 printk(KERN_DEBUG "dump: %s\n", tmp);
1007 }
1008 #endif
1009
1010 void
1011 actcapi_debug_msg(struct sk_buff *skb, int direction)
1012 {
1013 actcapi_msg *msg = (actcapi_msg *)skb->data;
1014 char *descr;
1015 int i;
1016 char tmp[170];
1017
1018 #ifndef DEBUG_DATA_MSG
1019 if (msg->hdr.cmd.cmd == 0x86)
1020 return;
1021 #endif
1022 descr = "INVALID";
1023 #ifdef DEBUG_DUMP_SKB
1024 dump_skb(skb);
1025 #endif
1026 for (i = 0; i < num_valid_msg; i++)
1027 if ((msg->hdr.cmd.cmd == valid_msg[i].cmd.cmd) &&
1028 (msg->hdr.cmd.subcmd == valid_msg[i].cmd.subcmd)) {
1029 descr = valid_msg[i].description;
1030 break;
1031 }
1032 printk(KERN_DEBUG "%s %s msg\n", direction?"Outgoing":"Incoming", descr);
1033 printk(KERN_DEBUG " ApplID = %d\n", msg->hdr.applicationID);
1034 printk(KERN_DEBUG " Len = %d\n", msg->hdr.len);
1035 printk(KERN_DEBUG " MsgNum = 0x%04x\n", msg->hdr.msgnum);
1036 printk(KERN_DEBUG " Cmd = 0x%02x\n", msg->hdr.cmd.cmd);
1037 printk(KERN_DEBUG " SubCmd = 0x%02x\n", msg->hdr.cmd.subcmd);
1038 switch (i) {
1039 case 0:
1040 /* DATA B3 IND */
1041 printk(KERN_DEBUG " BLOCK = 0x%02x\n",
1042 msg->msg.data_b3_ind.blocknr);
1043 break;
1044 case 2:
1045 /* CONNECT CONF */
1046 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1047 msg->msg.connect_conf.plci);
1048 printk(KERN_DEBUG " Info = 0x%04x\n",
1049 msg->msg.connect_conf.info);
1050 break;
1051 case 3:
1052 /* CONNECT IND */
1053 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1054 msg->msg.connect_ind.plci);
1055 printk(KERN_DEBUG " Contr = %d\n",
1056 msg->msg.connect_ind.controller);
1057 printk(KERN_DEBUG " SI1 = %d\n",
1058 msg->msg.connect_ind.si1);
1059 printk(KERN_DEBUG " SI2 = %d\n",
1060 msg->msg.connect_ind.si2);
1061 printk(KERN_DEBUG " EAZ = '%c'\n",
1062 msg->msg.connect_ind.eaz);
1063 actcapi_debug_caddr(&msg->msg.connect_ind.addr);
1064 break;
1065 case 5:
1066 /* CONNECT ACTIVE IND */
1067 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1068 msg->msg.connect_active_ind.plci);
1069 actcapi_debug_caddr(&msg->msg.connect_active_ind.addr);
1070 break;
1071 case 8:
1072 /* LISTEN CONF */
1073 printk(KERN_DEBUG " Contr = %d\n",
1074 msg->msg.listen_conf.controller);
1075 printk(KERN_DEBUG " Info = 0x%04x\n",
1076 msg->msg.listen_conf.info);
1077 break;
1078 case 11:
1079 /* INFO IND */
1080 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1081 msg->msg.info_ind.plci);
1082 printk(KERN_DEBUG " Imsk = 0x%04x\n",
1083 msg->msg.info_ind.nr.mask);
1084 if (msg->hdr.len > 12) {
1085 int l = msg->hdr.len - 12;
1086 int j;
1087 char *p = tmp;
1088 for (j = 0; j < l ; j++)
1089 p += sprintf(p, "%02x ", msg->msg.info_ind.el.display[j]);
1090 printk(KERN_DEBUG " D = '%s'\n", tmp);
1091 }
1092 break;
1093 case 14:
1094 /* SELECT B2 PROTOCOL CONF */
1095 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1096 msg->msg.select_b2_protocol_conf.plci);
1097 printk(KERN_DEBUG " Info = 0x%04x\n",
1098 msg->msg.select_b2_protocol_conf.info);
1099 break;
1100 case 15:
1101 /* SELECT B3 PROTOCOL CONF */
1102 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1103 msg->msg.select_b3_protocol_conf.plci);
1104 printk(KERN_DEBUG " Info = 0x%04x\n",
1105 msg->msg.select_b3_protocol_conf.info);
1106 break;
1107 case 16:
1108 /* LISTEN B3 CONF */
1109 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1110 msg->msg.listen_b3_conf.plci);
1111 printk(KERN_DEBUG " Info = 0x%04x\n",
1112 msg->msg.listen_b3_conf.info);
1113 break;
1114 case 18:
1115 /* CONNECT B3 IND */
1116 printk(KERN_DEBUG " NCCI = 0x%04x\n",
1117 msg->msg.connect_b3_ind.ncci);
1118 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1119 msg->msg.connect_b3_ind.plci);
1120 actcapi_debug_ncpi(&msg->msg.connect_b3_ind.ncpi);
1121 break;
1122 case 19:
1123 /* CONNECT B3 ACTIVE IND */
1124 printk(KERN_DEBUG " NCCI = 0x%04x\n",
1125 msg->msg.connect_b3_active_ind.ncci);
1126 actcapi_debug_ncpi(&msg->msg.connect_b3_active_ind.ncpi);
1127 break;
1128 case 26:
1129 /* MANUFACTURER IND */
1130 printk(KERN_DEBUG " Mmsg = 0x%02x\n",
1131 msg->msg.manufacturer_ind_err.manuf_msg);
1132 switch (msg->msg.manufacturer_ind_err.manuf_msg) {
1133 case 3:
1134 printk(KERN_DEBUG " Contr = %d\n",
1135 msg->msg.manufacturer_ind_err.controller);
1136 printk(KERN_DEBUG " Code = 0x%08x\n",
1137 msg->msg.manufacturer_ind_err.errcode);
1138 memset(tmp, 0, sizeof(tmp));
1139 strncpy(tmp, &msg->msg.manufacturer_ind_err.errstring,
1140 msg->hdr.len - 16);
1141 printk(KERN_DEBUG " Emsg = '%s'\n", tmp);
1142 break;
1143 }
1144 break;
1145 case 30:
1146 /* LISTEN REQ */
1147 printk(KERN_DEBUG " Imsk = 0x%08x\n",
1148 msg->msg.listen_req.infomask);
1149 printk(KERN_DEBUG " Emsk = 0x%04x\n",
1150 msg->msg.listen_req.eazmask);
1151 printk(KERN_DEBUG " Smsk = 0x%04x\n",
1152 msg->msg.listen_req.simask);
1153 break;
1154 case 35:
1155 /* SELECT_B2_PROTOCOL_REQ */
1156 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1157 msg->msg.select_b2_protocol_req.plci);
1158 printk(KERN_DEBUG " prot = 0x%02x\n",
1159 msg->msg.select_b2_protocol_req.protocol);
1160 if (msg->hdr.len >= 11)
1161 printk(KERN_DEBUG "No dlpd\n");
1162 else
1163 actcapi_debug_dlpd(&msg->msg.select_b2_protocol_req.dlpd);
1164 break;
1165 case 44:
1166 /* CONNECT RESP */
1167 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1168 msg->msg.connect_resp.plci);
1169 printk(KERN_DEBUG " CAUSE = 0x%02x\n",
1170 msg->msg.connect_resp.rejectcause);
1171 break;
1172 case 45:
1173 /* CONNECT ACTIVE RESP */
1174 printk(KERN_DEBUG " PLCI = 0x%04x\n",
1175 msg->msg.connect_active_resp.plci);
1176 break;
1177 }
1178 }
1179 #endif
Verdex Pro support