igb: this patch addes the sr-iov enablement option via num_vfs parameter
[linux-2.6] / drivers / isdn / pcbit / capi.c
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
54 int 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
134 int 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
151 int 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
179 int 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
197 int 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
263 int 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
285 int 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
321 int 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
338 int 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
362 int 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
381 int 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
493 int 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
528 int 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
566 int 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
580 int 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
593 int 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
608 int 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
632 int 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