1/*
2 * CAPI encoder/decoder for
3 * Portugal Telecom CAPI 2.0
4 *
5 * Copyright (C) 1996 Universidade de Lisboa
6 *
7 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
8 *
9 * This software may be used and distributed according to the terms of
10 * the GNU General Public License, incorporated herein by reference.
11 *
12 * Not compatible with the AVM Gmbh. CAPI 2.0
13 *
14 */
15
16/*
17 *        Documentation:
18 *        - "Common ISDN API - Perfil Português - Versão 2.1",
19 *           Telecom Portugal, Fev 1992.
20 *        - "Common ISDN API - Especificação de protocolos para
21 *           acesso aos canais B", Inesc, Jan 1994.
22 */
23
24/*
25 *        TODO: better decoding of Information Elements
26 *              for debug purposes mainly
27 *              encode our number in CallerPN and ConnectedPN
28 */
29
30#include <linux/string.h>
31#include <linux/kernel.h>
32
33#include <linux/types.h>
34#include <linux/slab.h>
35#include <linux/mm.h>
36
37#include <linux/skbuff.h>
38
39#include <asm/io.h>
40#include <asm/string.h>
41
42#include <linux/isdnif.h>
43
44#include "pcbit.h"
45#include "edss1.h"
46#include "capi.h"
47
48
49/*
50 *  Encoding of CAPI messages
51 *
52 */
53
54int capi_conn_req(const char * calledPN, struct sk_buff **skb, int proto)
55{
56        ushort len;
57
58        /*
59         * length
60         *   AppInfoMask - 2
61         *   BC0         - 3
62         *   BC1         - 1
63         *   Chan        - 2
64         *   Keypad      - 1
65         *   CPN         - 1
66         *   CPSA        - 1
67         *   CalledPN    - 2 + strlen
68         *   CalledPSA   - 1
69         *   rest...     - 4
70         *   ----------------
71         *   Total        18 + strlen
72         */
73
74        len = 18 + strlen(calledPN);
75
76	if (proto == ISDN_PROTO_L2_TRANS)
77		len++;
78
79	if ((*skb = dev_alloc_skb(len)) == NULL) {
80
81	        printk(KERN_WARNING "capi_conn_req: alloc_skb failed\n");
82		return -1;
83	}
84
85        /* InfoElmMask */
86        *((ushort*) skb_put(*skb, 2)) = AppInfoMask;
87
88	if (proto == ISDN_PROTO_L2_TRANS)
89	{
90		/* Bearer Capability - Mandatory*/
91		*(skb_put(*skb, 1)) = 3;        /* BC0.Length		*/
92		*(skb_put(*skb, 1)) = 0x80;     /* Speech		*/
93		*(skb_put(*skb, 1)) = 0x10;     /* Circuit Mode		*/
94		*(skb_put(*skb, 1)) = 0x23;     /* A-law		*/
95	}
96	else
97	{
98		/* Bearer Capability - Mandatory*/
99		*(skb_put(*skb, 1)) = 2;        /* BC0.Length		*/
100		*(skb_put(*skb, 1)) = 0x88;     /* Digital Information	*/
101		*(skb_put(*skb, 1)) = 0x90;     /* BC0.Octect4		*/
102	}
103
104        /* Bearer Capability - Optional*/
105        *(skb_put(*skb, 1)) = 0;        /* BC1.Length = 0                    */
106
107        *(skb_put(*skb, 1)) = 1;        /* ChannelID.Length = 1              */
108        *(skb_put(*skb, 1)) = 0x83;     /* Basic Interface - Any Channel     */
109
110        *(skb_put(*skb, 1)) = 0;        /* Keypad.Length = 0                 */
111
112
113        *(skb_put(*skb, 1)) = 0;        /* CallingPN.Length = 0              */
114        *(skb_put(*skb, 1)) = 0;        /* CallingPSA.Length = 0             */
115
116        /* Called Party Number */
117        *(skb_put(*skb, 1)) = strlen(calledPN) + 1;
118        *(skb_put(*skb, 1)) = 0x81;
119        memcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));
120
121        /* '#' */
122
123        *(skb_put(*skb, 1)) = 0;       /* CalledPSA.Length = 0     */
124
125        /* LLC.Length  = 0; */
126        /* HLC0.Length = 0; */
127        /* HLC1.Length = 0; */
128        /* UTUS.Length = 0; */
129        memset(skb_put(*skb, 4), 0, 4);
130
131        return len;
132}
133
134int capi_conn_resp(struct pcbit_chan* chan, struct sk_buff **skb)
135{
136
137	if ((*skb = dev_alloc_skb(5)) == NULL) {
138
139		printk(KERN_WARNING "capi_conn_resp: alloc_skb failed\n");
140		return -1;
141	}
142
143        *((ushort*) skb_put(*skb, 2) ) = chan->callref;
144        *(skb_put(*skb, 1)) = 0x01;  /* ACCEPT_CALL */
145        *(skb_put(*skb, 1)) = 0;
146        *(skb_put(*skb, 1)) = 0;
147
148        return 5;
149}
150
151int capi_conn_active_req(struct pcbit_chan* chan, struct sk_buff **skb)
152{
153        /*
154         * 8 bytes
155         */
156
157	if ((*skb = dev_alloc_skb(8)) == NULL) {
158
159		printk(KERN_WARNING "capi_conn_active_req: alloc_skb failed\n");
160		return -1;
161	}
162
163        *((ushort*) skb_put(*skb, 2) ) = chan->callref;
164
165#ifdef DEBUG
166	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
167#endif
168
169        *(skb_put(*skb, 1)) = 0;       /*  BC.Length = 0;          */
170        *(skb_put(*skb, 1)) = 0;       /*  ConnectedPN.Length = 0  */
171        *(skb_put(*skb, 1)) = 0;       /*  PSA.Length              */
172        *(skb_put(*skb, 1)) = 0;       /*  LLC.Length = 0;         */
173        *(skb_put(*skb, 1)) = 0;       /*  HLC.Length = 0;         */
174        *(skb_put(*skb, 1)) = 0;       /*  UTUS.Length = 0;        */
175
176	return 8;
177}
178
179int capi_conn_active_resp(struct pcbit_chan* chan, struct sk_buff **skb)
180{
181        /*
182         * 2 bytes
183         */
184
185	if ((*skb = dev_alloc_skb(2)) == NULL) {
186
187		printk(KERN_WARNING "capi_conn_active_resp: alloc_skb failed\n");
188		return -1;
189	}
190
191        *((ushort*) skb_put(*skb, 2) ) = chan->callref;
192
193        return 2;
194}
195
196
197int capi_select_proto_req(struct pcbit_chan *chan, struct sk_buff **skb,
198                          int outgoing)
199{
200
201        /*
202         * 18 bytes
203         */
204
205	if ((*skb = dev_alloc_skb(18)) == NULL) {
206
207		printk(KERN_WARNING "capi_select_proto_req: alloc_skb failed\n");
208		return -1;
209	}
210
211        *((ushort*) skb_put(*skb, 2) ) = chan->callref;
212
213        /* Layer2 protocol */
214
215        switch (chan->proto) {
216        case ISDN_PROTO_L2_X75I:
217                *(skb_put(*skb, 1)) = 0x05;            /* LAPB */
218                break;
219        case ISDN_PROTO_L2_HDLC:
220                *(skb_put(*skb, 1)) = 0x02;
221                break;
222	case ISDN_PROTO_L2_TRANS:
223		/*
224		 *	Voice (a-law)
225		 */
226		*(skb_put(*skb, 1)) = 0x06;
227		break;
228        default:
229#ifdef DEBUG
230                printk(KERN_DEBUG "Transparent\n");
231#endif
232                *(skb_put(*skb, 1)) = 0x03;
233                break;
234        }
235
236        *(skb_put(*skb, 1)) = (outgoing ? 0x02 : 0x42);    /* Don't ask */
237        *(skb_put(*skb, 1)) = 0x00;
238
239        *((ushort *) skb_put(*skb, 2)) = MRU;
240
241
242        *(skb_put(*skb, 1)) = 0x08;           /* Modulo */
243        *(skb_put(*skb, 1)) = 0x07;           /* Max Window */
244
245        *(skb_put(*skb, 1)) = 0x01;           /* No Layer3 Protocol */
246
247        /*
248         * 2 - layer3 MTU       [10]
249         *   - Modulo           [12]
250         *   - Window
251         *   - layer1 proto     [14]
252         *   - bitrate
253         *   - sub-channel      [16]
254         *   - layer1dataformat [17]
255         */
256
257        memset(skb_put(*skb, 8), 0, 8);
258
259        return 18;
260}
261
262
263int capi_activate_transp_req(struct pcbit_chan *chan, struct sk_buff **skb)
264{
265
266	if ((*skb = dev_alloc_skb(7)) == NULL) {
267
268		printk(KERN_WARNING "capi_activate_transp_req: alloc_skb failed\n");
269		return -1;
270	}
271
272        *((ushort*) skb_put(*skb, 2) ) = chan->callref;
273
274
275        *(skb_put(*skb, 1)) = chan->layer2link; /* Layer2 id */
276        *(skb_put(*skb, 1)) = 0x00;             /* Transmit by default */
277
278        *((ushort *) skb_put(*skb, 2)) = MRU;
279
280        *(skb_put(*skb, 1)) = 0x01;             /* Enables reception*/
281
282        return 7;
283}
284
285int capi_tdata_req(struct pcbit_chan* chan, struct sk_buff *skb)
286{
287	ushort data_len;
288
289
290	/*
291	 * callref      - 2
292	 * layer2link   - 1
293	 * wBlockLength - 2
294	 * data         - 4
295	 * sernum       - 1
296	 */
297
298	data_len = skb->len;
299
300	if(skb_headroom(skb) < 10)
301	{
302		printk(KERN_CRIT "No headspace (%u) on headroom %p for capi header\n", skb_headroom(skb), skb);
303	}
304	else
305	{
306		skb_push(skb, 10);
307	}
308
309	*((u16 *) (skb->data)) = chan->callref;
310	skb->data[2] = chan->layer2link;
311	*((u16 *) (skb->data + 3)) = data_len;
312
313	chan->s_refnum = (chan->s_refnum + 1) % 8;
314	*((u32 *) (skb->data + 5)) = chan->s_refnum;
315
316	skb->data[9] = 0;                           /* HDLC frame number */
317
318	return 10;
319}
320
321int capi_tdata_resp(struct pcbit_chan *chan, struct sk_buff ** skb)
322
323{
324	if ((*skb = dev_alloc_skb(4)) == NULL) {
325
326		printk(KERN_WARNING "capi_tdata_resp: alloc_skb failed\n");
327		return -1;
328	}
329
330        *((ushort*) skb_put(*skb, 2) ) = chan->callref;
331
332        *(skb_put(*skb, 1)) = chan->layer2link;
333        *(skb_put(*skb, 1)) = chan->r_refnum;
334
335        return (*skb)->len;
336}
337
338int capi_disc_req(ushort callref, struct sk_buff **skb, u_char cause)
339{
340
341	if ((*skb = dev_alloc_skb(6)) == NULL) {
342
343		printk(KERN_WARNING "capi_disc_req: alloc_skb failed\n");
344		return -1;
345	}
346
347        *((ushort*) skb_put(*skb, 2) ) = callref;
348
349        *(skb_put(*skb, 1)) = 2;                  /* Cause.Length = 2; */
350        *(skb_put(*skb, 1)) = 0x80;
351        *(skb_put(*skb, 1)) = 0x80 | cause;
352
353        /*
354         * Change it: we should send 'Sic transit gloria Mundi' here ;-)
355         */
356
357        *(skb_put(*skb, 1)) = 0;                   /* UTUS.Length = 0;  */
358
359        return 6;
360}
361
362int capi_disc_resp(struct pcbit_chan *chan, struct sk_buff **skb)
363{
364	if ((*skb = dev_alloc_skb(2)) == NULL) {
365
366		printk(KERN_WARNING "capi_disc_resp: alloc_skb failed\n");
367		return -1;
368	}
369
370        *((ushort*) skb_put(*skb, 2)) = chan->callref;
371
372        return 2;
373}
374
375
376/*
377 *  Decoding of CAPI messages
378 *
379 */
380
381int capi_decode_conn_ind(struct pcbit_chan * chan,
382                         struct sk_buff *skb,
383                         struct callb_data *info)
384{
385        int CIlen, len;
386
387        /* Call Reference [CAPI] */
388        chan->callref = *((ushort*) skb->data);
389        skb_pull(skb, 2);
390
391#ifdef DEBUG
392	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
393#endif
394
395        /* Channel Identification */
396
397        /* Expect
398           Len = 1
399           Octect 3 = 0100 10CC - [ 7 Basic, 4 , 2-1 chan ]
400           */
401
402        CIlen = skb->data[0];
403#ifdef DEBUG
404        if (CIlen == 1) {
405
406                if ( ((skb->data[1]) & 0xFC) == 0x48 )
407                        printk(KERN_DEBUG "decode_conn_ind: chan ok\n");
408                printk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03);
409        }
410	else
411		printk(KERN_DEBUG "conn_ind: CIlen = %d\n", CIlen);
412#endif
413        skb_pull(skb, CIlen + 1);
414
415        /* Calling Party Number */
416        /* An "additional service" as far as Portugal Telecom is concerned */
417
418        len = skb->data[0];
419
420	if (len > 0) {
421		int count = 1;
422
423#ifdef DEBUG
424		printk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
425#endif
426		if ((skb->data[1] & 0x80) == 0)
427			count = 2;
428
429		if (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
430			return -1;
431
432		skb_copy_from_linear_data_offset(skb, count + 1,
433						 info->data.setup.CallingPN,
434						 len - count);
435		info->data.setup.CallingPN[len - count] = 0;
436
437	}
438	else {
439		info->data.setup.CallingPN = NULL;
440		printk(KERN_DEBUG "NULL CallingPN\n");
441	}
442
443	skb_pull(skb, len + 1);
444
445        /* Calling Party Subaddress */
446        skb_pull(skb, skb->data[0] + 1);
447
448        /* Called Party Number */
449
450        len = skb->data[0];
451
452	if (len > 0) {
453		int count = 1;
454
455		if ((skb->data[1] & 0x80) == 0)
456			count = 2;
457
458		if (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
459			return -1;
460
461		skb_copy_from_linear_data_offset(skb, count + 1,
462						 info->data.setup.CalledPN,
463						 len - count);
464		info->data.setup.CalledPN[len - count] = 0;
465
466	}
467	else {
468		info->data.setup.CalledPN = NULL;
469		printk(KERN_DEBUG "NULL CalledPN\n");
470	}
471
472	skb_pull(skb, len + 1);
473
474        /* Called Party Subaddress */
475        skb_pull(skb, skb->data[0] + 1);
476
477        /* LLC */
478        skb_pull(skb, skb->data[0] + 1);
479
480        /* HLC */
481        skb_pull(skb, skb->data[0] + 1);
482
483        /* U2U */
484        skb_pull(skb, skb->data[0] + 1);
485
486        return 0;
487}
488
489/*
490 *  returns errcode
491 */
492
493int capi_decode_conn_conf(struct pcbit_chan * chan, struct sk_buff *skb,
494			  int *complete)
495{
496        int errcode;
497
498        chan->callref = *((ushort *) skb->data);     /* Update CallReference */
499        skb_pull(skb, 2);
500
501        errcode = *((ushort *) skb->data);   /* read errcode */
502        skb_pull(skb, 2);
503
504        *complete = *(skb->data);
505        skb_pull(skb, 1);
506
507        /* FIX ME */
508        /* This is actually a firmware bug */
509        if (!*complete)
510        {
511                printk(KERN_DEBUG "complete=%02x\n", *complete);
512                *complete = 1;
513        }
514
515
516        /* Optional Bearer Capability */
517        skb_pull(skb, *(skb->data) + 1);
518
519        /* Channel Identification */
520        skb_pull(skb, *(skb->data) + 1);
521
522        /* High Layer Compatibility follows */
523        skb_pull(skb, *(skb->data) + 1);
524
525        return errcode;
526}
527
528int capi_decode_conn_actv_ind(struct pcbit_chan * chan, struct sk_buff *skb)
529{
530        ushort len;
531#ifdef DEBUG
532        char str[32];
533#endif
534
535        /* Yet Another Bearer Capability */
536        skb_pull(skb, *(skb->data) + 1);
537
538
539        /* Connected Party Number */
540        len=*(skb->data);
541
542#ifdef DEBUG
543	if (len > 1 && len < 31) {
544		skb_copy_from_linear_data_offset(skb, 2, str, len - 1);
545		str[len] = 0;
546		printk(KERN_DEBUG "Connected Party Number: %s\n", str);
547	}
548	else
549		printk(KERN_DEBUG "actv_ind CPN len = %d\n", len);
550#endif
551
552        skb_pull(skb, len + 1);
553
554        /* Connected Subaddress */
555        skb_pull(skb, *(skb->data) + 1);
556
557        /* Low Layer Capability */
558        skb_pull(skb, *(skb->data) + 1);
559
560        /* High Layer Capability */
561        skb_pull(skb, *(skb->data) + 1);
562
563        return 0;
564}
565
566int capi_decode_conn_actv_conf(struct pcbit_chan * chan, struct sk_buff *skb)
567{
568        ushort errcode;
569
570        errcode = *((ushort*) skb->data);
571        skb_pull(skb, 2);
572
573        /* Channel Identification
574        skb_pull(skb, skb->data[0] + 1);
575        */
576        return errcode;
577}
578
579
580int capi_decode_sel_proto_conf(struct pcbit_chan *chan, struct sk_buff *skb)
581{
582        ushort errcode;
583
584        chan->layer2link = *(skb->data);
585        skb_pull(skb, 1);
586
587        errcode = *((ushort*) skb->data);
588        skb_pull(skb, 2);
589
590        return errcode;
591}
592
593int capi_decode_actv_trans_conf(struct pcbit_chan *chan, struct sk_buff *skb)
594{
595        ushort errcode;
596
597        if (chan->layer2link != *(skb->data) )
598                printk("capi_decode_actv_trans_conf: layer2link doesn't match\n");
599
600        skb_pull(skb, 1);
601
602        errcode = *((ushort*) skb->data);
603        skb_pull(skb, 2);
604
605        return errcode;
606}
607
608int capi_decode_disc_ind(struct pcbit_chan *chan, struct sk_buff *skb)
609{
610        ushort len;
611#ifdef DEBUG
612        int i;
613#endif
614        /* Cause */
615
616        len = *(skb->data);
617        skb_pull(skb, 1);
618
619#ifdef DEBUG
620
621        for (i=0; i<len; i++)
622                printk(KERN_DEBUG "Cause Octect %d: %02x\n", i+3,
623                       *(skb->data + i));
624#endif
625
626        skb_pull(skb, len);
627
628        return 0;
629}
630
631#ifdef DEBUG
632int capi_decode_debug_188(u_char *hdr, ushort hdrlen)
633{
634        char str[64];
635        int len;
636
637        len = hdr[0];
638
639        if (len < 64 && len == hdrlen - 1) {
640                memcpy(str, hdr + 1, hdrlen - 1);
641                str[hdrlen - 1] = 0;
642                printk("%s\n", str);
643        }
644        else
645                printk("debug message incorrect\n");
646
647        return 0;
648}
649#endif
650
651
652
653
654
655