OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [isdn/] [capi/] [capiutil.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/* $Id: capiutil.c,v 1.13.6.4 2001/09/23 22:24:33 kai Exp $
2
 *
3
 * CAPI 2.0 convert capi message to capi message struct
4
 *
5
 * From CAPI 2.0 Development Kit AVM 1995 (msg.c)
6
 * Rewritten for Linux 1996 by Carsten Paeth <calle@calle.de>
7
 *
8
 * This software may be used and distributed according to the terms
9
 * of the GNU General Public License, incorporated herein by reference.
10
 *
11
 */
12
 
13
#include <linux/module.h>
14
#include <linux/string.h>
15
#include <linux/ctype.h>
16
#include <linux/stddef.h>
17
#include <linux/kernel.h>
18
#include <linux/mm.h>
19
#include <linux/init.h>
20
#include <linux/isdn/capiutil.h>
21
 
22
/* from CAPI2.0 DDK AVM Berlin GmbH */
23
 
24
#ifndef CONFIG_ISDN_DRV_AVMB1_VERBOSE_REASON
25
char *capi_info2str(u16 reason)
26
{
27
    return "..";
28
}
29
#else
30
char *capi_info2str(u16 reason)
31
{
32
    switch (reason) {
33
 
34
/*-- informative values (corresponding message was processed) -----*/
35
        case 0x0001:
36
           return "NCPI not supported by current protocol, NCPI ignored";
37
        case 0x0002:
38
           return "Flags not supported by current protocol, flags ignored";
39
        case 0x0003:
40
           return "Alert already sent by another application";
41
 
42
/*-- error information concerning CAPI_REGISTER -----*/
43
        case 0x1001:
44
           return "Too many applications";
45
        case 0x1002:
46
           return "Logical block size too small, must be at least 128 Bytes";
47
        case 0x1003:
48
           return "Buffer exceeds 64 kByte";
49
        case 0x1004:
50
           return "Message buffer size too small, must be at least 1024 Bytes";
51
        case 0x1005:
52
           return "Max. number of logical connections not supported";
53
        case 0x1006:
54
           return "Reserved";
55
        case 0x1007:
56
           return "The message could not be accepted because of an internal busy condition";
57
        case 0x1008:
58
           return "OS resource error (no memory ?)";
59
        case 0x1009:
60
           return "CAPI not installed";
61
        case 0x100A:
62
           return "Controller does not support external equipment";
63
        case 0x100B:
64
           return "Controller does only support external equipment";
65
 
66
/*-- error information concerning message exchange functions -----*/
67
        case 0x1101:
68
           return "Illegal application number";
69
        case 0x1102:
70
           return "Illegal command or subcommand or message length less than 12 bytes";
71
        case 0x1103:
72
           return "The message could not be accepted because of a queue full condition !! The error code does not imply that CAPI cannot receive messages directed to another controller, PLCI or NCCI";
73
        case 0x1104:
74
           return "Queue is empty";
75
        case 0x1105:
76
           return "Queue overflow, a message was lost !! This indicates a configuration error. The only recovery from this error is to perform a CAPI_RELEASE";
77
        case 0x1106:
78
           return "Unknown notification parameter";
79
        case 0x1107:
80
           return "The Message could not be accepted because of an internal busy condition";
81
        case 0x1108:
82
           return "OS Resource error (no memory ?)";
83
        case 0x1109:
84
           return "CAPI not installed";
85
        case 0x110A:
86
           return "Controller does not support external equipment";
87
        case 0x110B:
88
           return "Controller does only support external equipment";
89
 
90
/*-- error information concerning resource / coding problems -----*/
91
        case 0x2001:
92
           return "Message not supported in current state";
93
        case 0x2002:
94
           return "Illegal Controller / PLCI / NCCI";
95
        case 0x2003:
96
           return "Out of PLCI";
97
        case 0x2004:
98
           return "Out of NCCI";
99
        case 0x2005:
100
           return "Out of LISTEN";
101
        case 0x2006:
102
           return "Out of FAX resources (protocol T.30)";
103
        case 0x2007:
104
           return "Illegal message parameter coding";
105
 
106
/*-- error information concerning requested services  -----*/
107
        case 0x3001:
108
           return "B1 protocol not supported";
109
        case 0x3002:
110
           return "B2 protocol not supported";
111
        case 0x3003:
112
           return "B3 protocol not supported";
113
        case 0x3004:
114
           return "B1 protocol parameter not supported";
115
        case 0x3005:
116
           return "B2 protocol parameter not supported";
117
        case 0x3006:
118
           return "B3 protocol parameter not supported";
119
        case 0x3007:
120
           return "B protocol combination not supported";
121
        case 0x3008:
122
           return "NCPI not supported";
123
        case 0x3009:
124
           return "CIP Value unknown";
125
        case 0x300A:
126
           return "Flags not supported (reserved bits)";
127
        case 0x300B:
128
           return "Facility not supported";
129
        case 0x300C:
130
           return "Data length not supported by current protocol";
131
        case 0x300D:
132
           return "Reset procedure not supported by current protocol";
133
 
134
/*-- informations about the clearing of a physical connection -----*/
135
        case 0x3301:
136
           return "Protocol error layer 1 (broken line or B-channel removed by signalling protocol)";
137
        case 0x3302:
138
           return "Protocol error layer 2";
139
        case 0x3303:
140
           return "Protocol error layer 3";
141
        case 0x3304:
142
           return "Another application got that call";
143
/*-- T.30 specific reasons -----*/
144
        case 0x3311:
145
           return "Connecting not successful (remote station is no FAX G3 machine)";
146
        case 0x3312:
147
           return "Connecting not successful (training error)";
148
        case 0x3313:
149
           return "Disconnected before transfer (remote station does not support transfer mode, e.g. resolution)";
150
        case 0x3314:
151
           return "Disconnected during transfer (remote abort)";
152
        case 0x3315:
153
           return "Disconnected during transfer (remote procedure error, e.g. unsuccessful repetition of T.30 commands)";
154
        case 0x3316:
155
           return "Disconnected during transfer (local tx data underrun)";
156
        case 0x3317:
157
           return "Disconnected during transfer (local rx data overflow)";
158
        case 0x3318:
159
           return "Disconnected during transfer (local abort)";
160
        case 0x3319:
161
           return "Illegal parameter coding (e.g. SFF coding error)";
162
 
163
/*-- disconnect causes from the network according to ETS 300 102-1/Q.931 -----*/
164
        case 0x3481: return "Unallocated (unassigned) number";
165
        case 0x3482: return "No route to specified transit network";
166
        case 0x3483: return "No route to destination";
167
        case 0x3486: return "Channel unacceptable";
168
        case 0x3487:
169
           return "Call awarded and being delivered in an established channel";
170
        case 0x3490: return "Normal call clearing";
171
        case 0x3491: return "User busy";
172
        case 0x3492: return "No user responding";
173
        case 0x3493: return "No answer from user (user alerted)";
174
        case 0x3495: return "Call rejected";
175
        case 0x3496: return "Number changed";
176
        case 0x349A: return "Non-selected user clearing";
177
        case 0x349B: return "Destination out of order";
178
        case 0x349C: return "Invalid number format";
179
        case 0x349D: return "Facility rejected";
180
        case 0x349E: return "Response to STATUS ENQUIRY";
181
        case 0x349F: return "Normal, unspecified";
182
        case 0x34A2: return "No circuit / channel available";
183
        case 0x34A6: return "Network out of order";
184
        case 0x34A9: return "Temporary failure";
185
        case 0x34AA: return "Switching equipment congestion";
186
        case 0x34AB: return "Access information discarded";
187
        case 0x34AC: return "Requested circuit / channel not available";
188
        case 0x34AF: return "Resources unavailable, unspecified";
189
        case 0x34B1: return "Quality of service unavailable";
190
        case 0x34B2: return "Requested facility not subscribed";
191
        case 0x34B9: return "Bearer capability not authorized";
192
        case 0x34BA: return "Bearer capability not presently available";
193
        case 0x34BF: return "Service or option not available, unspecified";
194
        case 0x34C1: return "Bearer capability not implemented";
195
        case 0x34C2: return "Channel type not implemented";
196
        case 0x34C5: return "Requested facility not implemented";
197
        case 0x34C6: return "Only restricted digital information bearer capability is available";
198
        case 0x34CF: return "Service or option not implemented, unspecified";
199
        case 0x34D1: return "Invalid call reference value";
200
        case 0x34D2: return "Identified channel does not exist";
201
        case 0x34D3: return "A suspended call exists, but this call identity does not";
202
        case 0x34D4: return "Call identity in use";
203
        case 0x34D5: return "No call suspended";
204
        case 0x34D6: return "Call having the requested call identity has been cleared";
205
        case 0x34D8: return "Incompatible destination";
206
        case 0x34DB: return "Invalid transit network selection";
207
        case 0x34DF: return "Invalid message, unspecified";
208
        case 0x34E0: return "Mandatory information element is missing";
209
        case 0x34E1: return "Message type non-existent or not implemented";
210
        case 0x34E2: return "Message not compatible with call state or message type non-existent or not implemented";
211
        case 0x34E3: return "Information element non-existent or not implemented";
212
        case 0x34E4: return "Invalid information element contents";
213
        case 0x34E5: return "Message not compatible with call state";
214
        case 0x34E6: return "Recovery on timer expiry";
215
        case 0x34EF: return "Protocol error, unspecified";
216
        case 0x34FF: return "Interworking, unspecified";
217
 
218
        default: return "No additional information";
219
    }
220
}
221
#endif
222
 
223
typedef struct {
224
        int typ;
225
        size_t off;
226
} _cdef;
227
 
228
#define _CBYTE         1
229
#define _CWORD         2
230
#define _CDWORD        3
231
#define _CSTRUCT       4
232
#define _CMSTRUCT      5
233
#define _CEND          6
234
 
235
static _cdef cdef[] =
236
{
237
    /*00 */
238
 {_CEND},
239
    /*01 */
240
 {_CEND},
241
    /*02 */
242
 {_CEND},
243
    /*03 */
244
 {_CDWORD, offsetof(_cmsg, adr.adrController)},
245
    /*04 */
246
 {_CMSTRUCT, offsetof(_cmsg, AdditionalInfo)},
247
    /*05 */
248
 {_CSTRUCT, offsetof(_cmsg, B1configuration)},
249
    /*06 */
250
 {_CWORD, offsetof(_cmsg, B1protocol)},
251
    /*07 */
252
 {_CSTRUCT, offsetof(_cmsg, B2configuration)},
253
    /*08 */
254
 {_CWORD, offsetof(_cmsg, B2protocol)},
255
    /*09 */
256
 {_CSTRUCT, offsetof(_cmsg, B3configuration)},
257
    /*0a */
258
 {_CWORD, offsetof(_cmsg, B3protocol)},
259
    /*0b */
260
 {_CSTRUCT, offsetof(_cmsg, BC)},
261
    /*0c */
262
 {_CSTRUCT, offsetof(_cmsg, BChannelinformation)},
263
    /*0d */
264
 {_CMSTRUCT, offsetof(_cmsg, BProtocol)},
265
    /*0e */
266
 {_CSTRUCT, offsetof(_cmsg, CalledPartyNumber)},
267
    /*0f */
268
 {_CSTRUCT, offsetof(_cmsg, CalledPartySubaddress)},
269
    /*10 */
270
 {_CSTRUCT, offsetof(_cmsg, CallingPartyNumber)},
271
    /*11 */
272
 {_CSTRUCT, offsetof(_cmsg, CallingPartySubaddress)},
273
    /*12 */
274
 {_CDWORD, offsetof(_cmsg, CIPmask)},
275
    /*13 */
276
 {_CDWORD, offsetof(_cmsg, CIPmask2)},
277
    /*14 */
278
 {_CWORD, offsetof(_cmsg, CIPValue)},
279
    /*15 */
280
 {_CDWORD, offsetof(_cmsg, Class)},
281
    /*16 */
282
 {_CSTRUCT, offsetof(_cmsg, ConnectedNumber)},
283
    /*17 */
284
 {_CSTRUCT, offsetof(_cmsg, ConnectedSubaddress)},
285
    /*18 */
286
 {_CDWORD, offsetof(_cmsg, Data)},
287
    /*19 */
288
 {_CWORD, offsetof(_cmsg, DataHandle)},
289
    /*1a */
290
 {_CWORD, offsetof(_cmsg, DataLength)},
291
    /*1b */
292
 {_CSTRUCT, offsetof(_cmsg, FacilityConfirmationParameter)},
293
    /*1c */
294
 {_CSTRUCT, offsetof(_cmsg, Facilitydataarray)},
295
    /*1d */
296
 {_CSTRUCT, offsetof(_cmsg, FacilityIndicationParameter)},
297
    /*1e */
298
 {_CSTRUCT, offsetof(_cmsg, FacilityRequestParameter)},
299
    /*1f */
300
 {_CWORD, offsetof(_cmsg, FacilitySelector)},
301
    /*20 */
302
 {_CWORD, offsetof(_cmsg, Flags)},
303
    /*21 */
304
 {_CDWORD, offsetof(_cmsg, Function)},
305
    /*22 */
306
 {_CSTRUCT, offsetof(_cmsg, HLC)},
307
    /*23 */
308
 {_CWORD, offsetof(_cmsg, Info)},
309
    /*24 */
310
 {_CSTRUCT, offsetof(_cmsg, InfoElement)},
311
    /*25 */
312
 {_CDWORD, offsetof(_cmsg, InfoMask)},
313
    /*26 */
314
 {_CWORD, offsetof(_cmsg, InfoNumber)},
315
    /*27 */
316
 {_CSTRUCT, offsetof(_cmsg, Keypadfacility)},
317
    /*28 */
318
 {_CSTRUCT, offsetof(_cmsg, LLC)},
319
    /*29 */
320
 {_CSTRUCT, offsetof(_cmsg, ManuData)},
321
    /*2a */
322
 {_CDWORD, offsetof(_cmsg, ManuID)},
323
    /*2b */
324
 {_CSTRUCT, offsetof(_cmsg, NCPI)},
325
    /*2c */
326
 {_CWORD, offsetof(_cmsg, Reason)},
327
    /*2d */
328
 {_CWORD, offsetof(_cmsg, Reason_B3)},
329
    /*2e */
330
 {_CWORD, offsetof(_cmsg, Reject)},
331
    /*2f */
332
 {_CSTRUCT, offsetof(_cmsg, Useruserdata)}
333
};
334
 
335
static unsigned char *cpars[] =
336
{
337
    /* ALERT_REQ */ [0x01] = "\x03\x04\x0c\x27\x2f\x1c\x01\x01",
338
    /* CONNECT_REQ */ [0x02] = "\x03\x14\x0e\x10\x0f\x11\x0d\x06\x08\x0a\x05\x07\x09\x01\x0b\x28\x22\x04\x0c\x27\x2f\x1c\x01\x01",
339
    /* DISCONNECT_REQ */ [0x04] = "\x03\x04\x0c\x27\x2f\x1c\x01\x01",
340
    /* LISTEN_REQ */ [0x05] = "\x03\x25\x12\x13\x10\x11\x01",
341
    /* INFO_REQ */ [0x08] = "\x03\x0e\x04\x0c\x27\x2f\x1c\x01\x01",
342
    /* FACILITY_REQ */ [0x09] = "\x03\x1f\x1e\x01",
343
    /* SELECT_B_PROTOCOL_REQ */ [0x0a] = "\x03\x0d\x06\x08\x0a\x05\x07\x09\x01\x01",
344
    /* CONNECT_B3_REQ */ [0x0b] = "\x03\x2b\x01",
345
    /* DISCONNECT_B3_REQ */ [0x0d] = "\x03\x2b\x01",
346
    /* DATA_B3_REQ */ [0x0f] = "\x03\x18\x1a\x19\x20\x01",
347
    /* RESET_B3_REQ */ [0x10] = "\x03\x2b\x01",
348
    /* ALERT_CONF */ [0x13] = "\x03\x23\x01",
349
    /* CONNECT_CONF */ [0x14] = "\x03\x23\x01",
350
    /* DISCONNECT_CONF */ [0x16] = "\x03\x23\x01",
351
    /* LISTEN_CONF */ [0x17] = "\x03\x23\x01",
352
    /* MANUFACTURER_REQ */ [0x18] = "\x03\x2a\x15\x21\x29\x01",
353
    /* INFO_CONF */ [0x1a] = "\x03\x23\x01",
354
    /* FACILITY_CONF */ [0x1b] = "\x03\x23\x1f\x1b\x01",
355
    /* SELECT_B_PROTOCOL_CONF */ [0x1c] = "\x03\x23\x01",
356
    /* CONNECT_B3_CONF */ [0x1d] = "\x03\x23\x01",
357
    /* DISCONNECT_B3_CONF */ [0x1f] = "\x03\x23\x01",
358
    /* DATA_B3_CONF */ [0x21] = "\x03\x19\x23\x01",
359
    /* RESET_B3_CONF */ [0x22] = "\x03\x23\x01",
360
    /* CONNECT_IND */ [0x26] = "\x03\x14\x0e\x10\x0f\x11\x0b\x28\x22\x04\x0c\x27\x2f\x1c\x01\x01",
361
    /* CONNECT_ACTIVE_IND */ [0x27] = "\x03\x16\x17\x28\x01",
362
    /* DISCONNECT_IND */ [0x28] = "\x03\x2c\x01",
363
    /* MANUFACTURER_CONF */ [0x2a] = "\x03\x2a\x15\x21\x29\x01",
364
    /* INFO_IND */ [0x2c] = "\x03\x26\x24\x01",
365
    /* FACILITY_IND */ [0x2d] = "\x03\x1f\x1d\x01",
366
    /* CONNECT_B3_IND */ [0x2f] = "\x03\x2b\x01",
367
    /* CONNECT_B3_ACTIVE_IND */ [0x30] = "\x03\x2b\x01",
368
    /* DISCONNECT_B3_IND */ [0x31] = "\x03\x2d\x2b\x01",
369
    /* DATA_B3_IND */ [0x33] = "\x03\x18\x1a\x19\x20\x01",
370
    /* RESET_B3_IND */ [0x34] = "\x03\x2b\x01",
371
    /* CONNECT_B3_T90_ACTIVE_IND */ [0x35] = "\x03\x2b\x01",
372
    /* CONNECT_RESP */ [0x38] = "\x03\x2e\x0d\x06\x08\x0a\x05\x07\x09\x01\x16\x17\x28\x04\x0c\x27\x2f\x1c\x01\x01",
373
    /* CONNECT_ACTIVE_RESP */ [0x39] = "\x03\x01",
374
    /* DISCONNECT_RESP */ [0x3a] = "\x03\x01",
375
    /* MANUFACTURER_IND */ [0x3c] = "\x03\x2a\x15\x21\x29\x01",
376
    /* INFO_RESP */ [0x3e] = "\x03\x01",
377
    /* FACILITY_RESP */ [0x3f] = "\x03\x1f\x01",
378
    /* CONNECT_B3_RESP */ [0x41] = "\x03\x2e\x2b\x01",
379
    /* CONNECT_B3_ACTIVE_RESP */ [0x42] = "\x03\x01",
380
    /* DISCONNECT_B3_RESP */ [0x43] = "\x03\x01",
381
    /* DATA_B3_RESP */ [0x45] = "\x03\x19\x01",
382
    /* RESET_B3_RESP */ [0x46] = "\x03\x01",
383
    /* CONNECT_B3_T90_ACTIVE_RESP */ [0x47] = "\x03\x01",
384
    /* MANUFACTURER_RESP */ [0x4e] = "\x03\x2a\x15\x21\x29\x01",
385
};
386
 
387
/*-------------------------------------------------------*/
388
 
389
#define byteTLcpy(x,y)        *(u8 *)(x)=*(u8 *)(y);
390
#define wordTLcpy(x,y)        *(u16 *)(x)=*(u16 *)(y);
391
#define dwordTLcpy(x,y)       memcpy(x,y,4);
392
#define structTLcpy(x,y,l)    memcpy (x,y,l)
393
#define structTLcpyovl(x,y,l) memmove (x,y,l)
394
 
395
#define byteTRcpy(x,y)        *(u8 *)(y)=*(u8 *)(x);
396
#define wordTRcpy(x,y)        *(u16 *)(y)=*(u16 *)(x);
397
#define dwordTRcpy(x,y)       memcpy(y,x,4);
398
#define structTRcpy(x,y,l)    memcpy (y,x,l)
399
#define structTRcpyovl(x,y,l) memmove (y,x,l)
400
 
401
/*-------------------------------------------------------*/
402
static unsigned command_2_index(unsigned c, unsigned sc)
403
{
404
        if (c & 0x80)
405
                c = 0x9 + (c & 0x0f);
406
        else if (c <= 0x0f);
407
        else if (c == 0x41)
408
                c = 0x9 + 0x1;
409
        else if (c == 0xff)
410
                c = 0x00;
411
        return (sc & 3) * (0x9 + 0x9) + c;
412
}
413
 
414
/*-------------------------------------------------------*/
415
#define TYP (cdef[cmsg->par[cmsg->p]].typ)
416
#define OFF (((u8 *)cmsg)+cdef[cmsg->par[cmsg->p]].off)
417
 
418
static void jumpcstruct(_cmsg * cmsg)
419
{
420
        unsigned layer;
421
        for (cmsg->p++, layer = 1; layer;) {
422
                /* $$$$$ assert (cmsg->p); */
423
                cmsg->p++;
424
                switch (TYP) {
425
                case _CMSTRUCT:
426
                        layer++;
427
                        break;
428
                case _CEND:
429
                        layer--;
430
                        break;
431
                }
432
        }
433
}
434
/*-------------------------------------------------------*/
435
static void pars_2_message(_cmsg * cmsg)
436
{
437
 
438
        for (; TYP != _CEND; cmsg->p++) {
439
                switch (TYP) {
440
                case _CBYTE:
441
                        byteTLcpy(cmsg->m + cmsg->l, OFF);
442
                        cmsg->l++;
443
                        break;
444
                case _CWORD:
445
                        wordTLcpy(cmsg->m + cmsg->l, OFF);
446
                        cmsg->l += 2;
447
                        break;
448
                case _CDWORD:
449
                        dwordTLcpy(cmsg->m + cmsg->l, OFF);
450
                        cmsg->l += 4;
451
                        break;
452
                case _CSTRUCT:
453
                        if (*(u8 **) OFF == 0) {
454
                                *(cmsg->m + cmsg->l) = '\0';
455
                                cmsg->l++;
456
                        } else if (**(_cstruct *) OFF != 0xff) {
457
                                structTLcpy(cmsg->m + cmsg->l, *(_cstruct *) OFF, 1 + **(_cstruct *) OFF);
458
                                cmsg->l += 1 + **(_cstruct *) OFF;
459
                        } else {
460
                                _cstruct s = *(_cstruct *) OFF;
461
                                structTLcpy(cmsg->m + cmsg->l, s, 3 + *(u16 *) (s + 1));
462
                                cmsg->l += 3 + *(u16 *) (s + 1);
463
                        }
464
                        break;
465
                case _CMSTRUCT:
466
/*----- Metastruktur 0 -----*/
467
                        if (*(_cmstruct *) OFF == CAPI_DEFAULT) {
468
                                *(cmsg->m + cmsg->l) = '\0';
469
                                cmsg->l++;
470
                                jumpcstruct(cmsg);
471
                        }
472
/*----- Metastruktur wird composed -----*/
473
                        else {
474
                                unsigned _l = cmsg->l;
475
                                unsigned _ls;
476
                                cmsg->l++;
477
                                cmsg->p++;
478
                                pars_2_message(cmsg);
479
                                _ls = cmsg->l - _l - 1;
480
                                if (_ls < 255)
481
                                        (cmsg->m + _l)[0] = (u8) _ls;
482
                                else {
483
                                        structTLcpyovl(cmsg->m + _l + 3, cmsg->m + _l + 1, _ls);
484
                                        (cmsg->m + _l)[0] = 0xff;
485
                                        wordTLcpy(cmsg->m + _l + 1, &_ls);
486
                                }
487
                        }
488
                        break;
489
                }
490
        }
491
}
492
 
493
/*-------------------------------------------------------*/
494
unsigned capi_cmsg2message(_cmsg * cmsg, u8 * msg)
495
{
496
        cmsg->m = msg;
497
        cmsg->l = 8;
498
        cmsg->p = 0;
499
        cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)];
500
 
501
        pars_2_message(cmsg);
502
 
503
        wordTLcpy(msg + 0, &cmsg->l);
504
        byteTLcpy(cmsg->m + 4, &cmsg->Command);
505
        byteTLcpy(cmsg->m + 5, &cmsg->Subcommand);
506
        wordTLcpy(cmsg->m + 2, &cmsg->ApplId);
507
        wordTLcpy(cmsg->m + 6, &cmsg->Messagenumber);
508
 
509
        return 0;
510
}
511
 
512
/*-------------------------------------------------------*/
513
static void message_2_pars(_cmsg * cmsg)
514
{
515
        for (; TYP != _CEND; cmsg->p++) {
516
 
517
                switch (TYP) {
518
                case _CBYTE:
519
                        byteTRcpy(cmsg->m + cmsg->l, OFF);
520
                        cmsg->l++;
521
                        break;
522
                case _CWORD:
523
                        wordTRcpy(cmsg->m + cmsg->l, OFF);
524
                        cmsg->l += 2;
525
                        break;
526
                case _CDWORD:
527
                        dwordTRcpy(cmsg->m + cmsg->l, OFF);
528
                        cmsg->l += 4;
529
                        break;
530
                case _CSTRUCT:
531
                        *(u8 **) OFF = cmsg->m + cmsg->l;
532
 
533
                        if (cmsg->m[cmsg->l] != 0xff)
534
                                cmsg->l += 1 + cmsg->m[cmsg->l];
535
                        else
536
                                cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1);
537
                        break;
538
                case _CMSTRUCT:
539
/*----- Metastruktur 0 -----*/
540
                        if (cmsg->m[cmsg->l] == '\0') {
541
                                *(_cmstruct *) OFF = CAPI_DEFAULT;
542
                                cmsg->l++;
543
                                jumpcstruct(cmsg);
544
                        } else {
545
                                unsigned _l = cmsg->l;
546
                                *(_cmstruct *) OFF = CAPI_COMPOSE;
547
                                cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1;
548
                                cmsg->p++;
549
                                message_2_pars(cmsg);
550
                        }
551
                        break;
552
                }
553
        }
554
}
555
 
556
/*-------------------------------------------------------*/
557
unsigned capi_message2cmsg(_cmsg * cmsg, u8 * msg)
558
{
559
        memset(cmsg, 0, sizeof(_cmsg));
560
        cmsg->m = msg;
561
        cmsg->l = 8;
562
        cmsg->p = 0;
563
        byteTRcpy(cmsg->m + 4, &cmsg->Command);
564
        byteTRcpy(cmsg->m + 5, &cmsg->Subcommand);
565
        cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)];
566
 
567
        message_2_pars(cmsg);
568
 
569
        wordTRcpy(msg + 0, &cmsg->l);
570
        wordTRcpy(cmsg->m + 2, &cmsg->ApplId);
571
        wordTRcpy(cmsg->m + 6, &cmsg->Messagenumber);
572
 
573
        return 0;
574
}
575
 
576
/*-------------------------------------------------------*/
577
unsigned capi_cmsg_header(_cmsg * cmsg, u16 _ApplId,
578
                          u8 _Command, u8 _Subcommand,
579
                          u16 _Messagenumber, u32 _Controller)
580
{
581
        memset(cmsg, 0, sizeof(_cmsg));
582
        cmsg->ApplId = _ApplId;
583
        cmsg->Command = _Command;
584
        cmsg->Subcommand = _Subcommand;
585
        cmsg->Messagenumber = _Messagenumber;
586
        cmsg->adr.adrController = _Controller;
587
        return 0;
588
}
589
 
590
/*-------------------------------------------------------*/
591
 
592
static char *mnames[] =
593
{
594
        [0x01] = "ALERT_REQ",
595
        [0x02] = "CONNECT_REQ",
596
        [0x04] = "DISCONNECT_REQ",
597
        [0x05] = "LISTEN_REQ",
598
        [0x08] = "INFO_REQ",
599
        [0x09] = "FACILITY_REQ",
600
        [0x0a] = "SELECT_B_PROTOCOL_REQ",
601
        [0x0b] = "CONNECT_B3_REQ",
602
        [0x0d] = "DISCONNECT_B3_REQ",
603
        [0x0f] = "DATA_B3_REQ",
604
        [0x10] = "RESET_B3_REQ",
605
        [0x13] = "ALERT_CONF",
606
        [0x14] = "CONNECT_CONF",
607
        [0x16] = "DISCONNECT_CONF",
608
        [0x17] = "LISTEN_CONF",
609
        [0x18] = "MANUFACTURER_REQ",
610
        [0x1a] = "INFO_CONF",
611
        [0x1b] = "FACILITY_CONF",
612
        [0x1c] = "SELECT_B_PROTOCOL_CONF",
613
        [0x1d] = "CONNECT_B3_CONF",
614
        [0x1f] = "DISCONNECT_B3_CONF",
615
        [0x21] = "DATA_B3_CONF",
616
        [0x22] = "RESET_B3_CONF",
617
        [0x26] = "CONNECT_IND",
618
        [0x27] = "CONNECT_ACTIVE_IND",
619
        [0x28] = "DISCONNECT_IND",
620
        [0x2a] = "MANUFACTURER_CONF",
621
        [0x2c] = "INFO_IND",
622
        [0x2d] = "FACILITY_IND",
623
        [0x2f] = "CONNECT_B3_IND",
624
        [0x30] = "CONNECT_B3_ACTIVE_IND",
625
        [0x31] = "DISCONNECT_B3_IND",
626
        [0x33] = "DATA_B3_IND",
627
        [0x34] = "RESET_B3_IND",
628
        [0x35] = "CONNECT_B3_T90_ACTIVE_IND",
629
        [0x38] = "CONNECT_RESP",
630
        [0x39] = "CONNECT_ACTIVE_RESP",
631
        [0x3a] = "DISCONNECT_RESP",
632
        [0x3c] = "MANUFACTURER_IND",
633
        [0x3e] = "INFO_RESP",
634
        [0x3f] = "FACILITY_RESP",
635
        [0x41] = "CONNECT_B3_RESP",
636
        [0x42] = "CONNECT_B3_ACTIVE_RESP",
637
        [0x43] = "DISCONNECT_B3_RESP",
638
        [0x45] = "DATA_B3_RESP",
639
        [0x46] = "RESET_B3_RESP",
640
        [0x47] = "CONNECT_B3_T90_ACTIVE_RESP",
641
        [0x4e] = "MANUFACTURER_RESP"
642
};
643
 
644
char *capi_cmd2str(u8 cmd, u8 subcmd)
645
{
646
        return mnames[command_2_index(cmd, subcmd)];
647
}
648
 
649
 
650
/*-------------------------------------------------------*/
651
 
652
#ifdef CONFIG_CAPI_TRACE
653
 
654
/*-------------------------------------------------------*/
655
 
656
static char *pnames[] =
657
{
658
    /*00 */ NULL,
659
    /*01 */ NULL,
660
    /*02 */ NULL,
661
    /*03 */ "Controller/PLCI/NCCI",
662
    /*04 */ "AdditionalInfo",
663
    /*05 */ "B1configuration",
664
    /*06 */ "B1protocol",
665
    /*07 */ "B2configuration",
666
    /*08 */ "B2protocol",
667
    /*09 */ "B3configuration",
668
    /*0a */ "B3protocol",
669
    /*0b */ "BC",
670
    /*0c */ "BChannelinformation",
671
    /*0d */ "BProtocol",
672
    /*0e */ "CalledPartyNumber",
673
    /*0f */ "CalledPartySubaddress",
674
    /*10 */ "CallingPartyNumber",
675
    /*11 */ "CallingPartySubaddress",
676
    /*12 */ "CIPmask",
677
    /*13 */ "CIPmask2",
678
    /*14 */ "CIPValue",
679
    /*15 */ "Class",
680
    /*16 */ "ConnectedNumber",
681
    /*17 */ "ConnectedSubaddress",
682
    /*18 */ "Data32",
683
    /*19 */ "DataHandle",
684
    /*1a */ "DataLength",
685
    /*1b */ "FacilityConfirmationParameter",
686
    /*1c */ "Facilitydataarray",
687
    /*1d */ "FacilityIndicationParameter",
688
    /*1e */ "FacilityRequestParameter",
689
    /*1f */ "FacilitySelector",
690
    /*20 */ "Flags",
691
    /*21 */ "Function",
692
    /*22 */ "HLC",
693
    /*23 */ "Info",
694
    /*24 */ "InfoElement",
695
    /*25 */ "InfoMask",
696
    /*26 */ "InfoNumber",
697
    /*27 */ "Keypadfacility",
698
    /*28 */ "LLC",
699
    /*29 */ "ManuData",
700
    /*2a */ "ManuID",
701
    /*2b */ "NCPI",
702
    /*2c */ "Reason",
703
    /*2d */ "Reason_B3",
704
    /*2e */ "Reject",
705
    /*2f */ "Useruserdata"
706
};
707
 
708
 
709
 
710
#include <stdarg.h>
711
 
712
/*-------------------------------------------------------*/
713
static _cdebbuf *bufprint(_cdebbuf *cdb, char *fmt,...)
714
{
715
        va_list f;
716
        size_t n,r;
717
 
718
        if (!cdb)
719
                return NULL;
720
        va_start(f, fmt);
721
        r = cdb->size - cdb->pos;
722
        n = vsnprintf(cdb->p, r, fmt, f);
723
        va_end(f);
724
        if (n >= r) {
725
                /* truncated, need bigger buffer */
726
                size_t ns = 2 * cdb->size;
727
                u_char *nb;
728
 
729
                while ((ns - cdb->pos) <= n)
730
                        ns *= 2;
731
                nb = kmalloc(ns, GFP_ATOMIC);
732
                if (!nb) {
733
                        cdebbuf_free(cdb);
734
                        return NULL;
735
                }
736
                memcpy(nb, cdb->buf, cdb->pos);
737
                kfree(cdb->buf);
738
                nb[cdb->pos] = 0;
739
                cdb->buf = nb;
740
                cdb->p = cdb->buf + cdb->pos;
741
                cdb->size = ns;
742
                va_start(f, fmt);
743
                r = cdb->size - cdb->pos;
744
                n = vsnprintf(cdb->p, r, fmt, f);
745
                va_end(f);
746
        }
747
        cdb->p += n;
748
        cdb->pos += n;
749
        return cdb;
750
}
751
 
752
static _cdebbuf *printstructlen(_cdebbuf *cdb, u8 * m, unsigned len)
753
{
754
        unsigned hex = 0;
755
 
756
        if (!cdb)
757
                return NULL;
758
        for (; len; len--, m++)
759
                if (isalnum(*m) || *m == ' ') {
760
                        if (hex)
761
                                cdb = bufprint(cdb, ">");
762
                        cdb = bufprint(cdb, "%c", *m);
763
                        hex = 0;
764
                } else {
765
                        if (!hex)
766
                                cdb = bufprint(cdb, "<%02x", *m);
767
                        else
768
                                cdb = bufprint(cdb, " %02x", *m);
769
                        hex = 1;
770
                }
771
        if (hex)
772
                cdb = bufprint(cdb, ">");
773
        return cdb;
774
}
775
 
776
static _cdebbuf *printstruct(_cdebbuf *cdb, u8 * m)
777
{
778
        unsigned len;
779
 
780
        if (m[0] != 0xff) {
781
                len = m[0];
782
                m += 1;
783
        } else {
784
                len = ((u16 *) (m + 1))[0];
785
                m += 3;
786
        }
787
        cdb = printstructlen(cdb, m, len);
788
        return cdb;
789
}
790
 
791
/*-------------------------------------------------------*/
792
#define NAME (pnames[cmsg->par[cmsg->p]])
793
 
794
static _cdebbuf *protocol_message_2_pars(_cdebbuf *cdb, _cmsg *cmsg, int level)
795
{
796
        for (; TYP != _CEND; cmsg->p++) {
797
                int slen = 29 + 3 - level;
798
                int i;
799
 
800
                if (!cdb)
801
                        return NULL;
802
                cdb = bufprint(cdb, "  ");
803
                for (i = 0; i < level - 1; i++)
804
                        cdb = bufprint(cdb, " ");
805
 
806
                switch (TYP) {
807
                case _CBYTE:
808
                        cdb = bufprint(cdb, "%-*s = 0x%x\n", slen, NAME, *(u8 *) (cmsg->m + cmsg->l));
809
                        cmsg->l++;
810
                        break;
811
                case _CWORD:
812
                        cdb = bufprint(cdb, "%-*s = 0x%x\n", slen, NAME, *(u16 *) (cmsg->m + cmsg->l));
813
                        cmsg->l += 2;
814
                        break;
815
                case _CDWORD:
816
                        cdb = bufprint(cdb, "%-*s = 0x%lx\n", slen, NAME, *(u32 *) (cmsg->m + cmsg->l));
817
                        cmsg->l += 4;
818
                        break;
819
                case _CSTRUCT:
820
                        cdb = bufprint(cdb, "%-*s = ", slen, NAME);
821
                        if (cmsg->m[cmsg->l] == '\0')
822
                                cdb = bufprint(cdb, "default");
823
                        else
824
                                cdb = printstruct(cdb, cmsg->m + cmsg->l);
825
                        cdb = bufprint(cdb, "\n");
826
                        if (cmsg->m[cmsg->l] != 0xff)
827
                                cmsg->l += 1 + cmsg->m[cmsg->l];
828
                        else
829
                                cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1);
830
 
831
                        break;
832
 
833
                case _CMSTRUCT:
834
/*----- Metastruktur 0 -----*/
835
                        if (cmsg->m[cmsg->l] == '\0') {
836
                                cdb = bufprint(cdb, "%-*s = default\n", slen, NAME);
837
                                cmsg->l++;
838
                                jumpcstruct(cmsg);
839
                        } else {
840
                                char *name = NAME;
841
                                unsigned _l = cmsg->l;
842
                                cdb = bufprint(cdb, "%-*s\n", slen, name);
843
                                cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1;
844
                                cmsg->p++;
845
                                cdb = protocol_message_2_pars(cdb, cmsg, level + 1);
846
                        }
847
                        break;
848
                }
849
        }
850
        return cdb;
851
}
852
/*-------------------------------------------------------*/
853
 
854
static _cdebbuf *g_debbuf;
855
static u_long g_debbuf_lock;
856
static _cmsg *g_cmsg;
857
 
858
static _cdebbuf *cdebbuf_alloc(void)
859
{
860
        _cdebbuf *cdb;
861
 
862
        if (likely(!test_and_set_bit(1, &g_debbuf_lock))) {
863
                cdb = g_debbuf;
864
                goto init;
865
        } else
866
                cdb = kmalloc(sizeof(_cdebbuf), GFP_ATOMIC);
867
        if (!cdb)
868
                return NULL;
869
        cdb->buf = kmalloc(CDEBUG_SIZE, GFP_ATOMIC);
870
        if (!cdb->buf) {
871
                kfree(cdb);
872
                return NULL;
873
        }
874
        cdb->size = CDEBUG_SIZE;
875
init:
876
        cdb->buf[0] = 0;
877
        cdb->p = cdb->buf;
878
        cdb->pos = 0;
879
        return cdb;
880
}
881
 
882
void cdebbuf_free(_cdebbuf *cdb)
883
{
884
        if (likely(cdb == g_debbuf)) {
885
                test_and_clear_bit(1, &g_debbuf_lock);
886
                return;
887
        }
888
        if (likely(cdb))
889
                kfree(cdb->buf);
890
        kfree(cdb);
891
}
892
 
893
 
894
_cdebbuf *capi_message2str(u8 * msg)
895
{
896
        _cdebbuf *cdb;
897
        _cmsg   *cmsg;
898
 
899
        cdb = cdebbuf_alloc();
900
        if (unlikely(!cdb))
901
                return NULL;
902
        if (likely(cdb == g_debbuf))
903
                cmsg = g_cmsg;
904
        else
905
                cmsg = kmalloc(sizeof(_cmsg), GFP_ATOMIC);
906
        if (unlikely(!cmsg)) {
907
                cdebbuf_free(cdb);
908
                return NULL;
909
        }
910
        cmsg->m = msg;
911
        cmsg->l = 8;
912
        cmsg->p = 0;
913
        byteTRcpy(cmsg->m + 4, &cmsg->Command);
914
        byteTRcpy(cmsg->m + 5, &cmsg->Subcommand);
915
        cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)];
916
 
917
        cdb = bufprint(cdb, "%-26s ID=%03d #0x%04x LEN=%04d\n",
918
                 mnames[command_2_index(cmsg->Command, cmsg->Subcommand)],
919
                 ((unsigned short *) msg)[1],
920
                 ((unsigned short *) msg)[3],
921
                 ((unsigned short *) msg)[0]);
922
 
923
        cdb = protocol_message_2_pars(cdb, cmsg, 1);
924
        if (unlikely(cmsg != g_cmsg))
925
                kfree(cmsg);
926
        return cdb;
927
}
928
 
929
_cdebbuf *capi_cmsg2str(_cmsg * cmsg)
930
{
931
        _cdebbuf *cdb;
932
 
933
        cdb = cdebbuf_alloc();
934
        if (!cdb)
935
                return NULL;
936
        cmsg->l = 8;
937
        cmsg->p = 0;
938
        cdb = bufprint(cdb, "%s ID=%03d #0x%04x LEN=%04d\n",
939
                 mnames[command_2_index(cmsg->Command, cmsg->Subcommand)],
940
                 ((u16 *) cmsg->m)[1],
941
                 ((u16 *) cmsg->m)[3],
942
                 ((u16 *) cmsg->m)[0]);
943
        cdb = protocol_message_2_pars(cdb, cmsg, 1);
944
        return cdb;
945
}
946
 
947
int __init cdebug_init(void)
948
{
949
        g_cmsg= kmalloc(sizeof(_cmsg), GFP_KERNEL);
950
        if (!g_cmsg)
951
                return ENOMEM;
952
        g_debbuf = kmalloc(sizeof(_cdebbuf), GFP_KERNEL);
953
        if (!g_debbuf) {
954
                kfree(g_cmsg);
955
                return ENOMEM;
956
        }
957
        g_debbuf->buf = kmalloc(CDEBUG_GSIZE, GFP_KERNEL);
958
        if (!g_debbuf->buf) {
959
                kfree(g_cmsg);
960
                kfree(g_debbuf);
961
                return ENOMEM;;
962
        }
963
        g_debbuf->size = CDEBUG_GSIZE;
964
        g_debbuf->buf[0] = 0;
965
        g_debbuf->p = g_debbuf->buf;
966
        g_debbuf->pos = 0;
967
        return 0;
968
}
969
 
970
void __exit cdebug_exit(void)
971
{
972
        if (g_debbuf)
973
                kfree(g_debbuf->buf);
974
        kfree(g_debbuf);
975
        kfree(g_cmsg);
976
}
977
 
978
#else /* !CONFIG_CAPI_TRACE */
979
 
980
static _cdebbuf g_debbuf = {"CONFIG_CAPI_TRACE not enabled", NULL, 0, 0};
981
 
982
_cdebbuf *capi_message2str(u8 * msg)
983
{
984
        return &g_debbuf;
985
}
986
 
987
_cdebbuf *capi_cmsg2str(_cmsg * cmsg)
988
{
989
        return &g_debbuf;
990
}
991
 
992
void cdebbuf_free(_cdebbuf *cdb)
993
{
994
}
995
 
996
int __init cdebug_init(void)
997
{
998
        return 0;
999
}
1000
 
1001
void __exit cdebug_exit(void)
1002
{
1003
}
1004
 
1005
#endif
1006
 
1007
EXPORT_SYMBOL(cdebbuf_free);
1008
EXPORT_SYMBOL(capi_cmsg2message);
1009
EXPORT_SYMBOL(capi_message2cmsg);
1010
EXPORT_SYMBOL(capi_cmsg_header);
1011
EXPORT_SYMBOL(capi_cmd2str);
1012
EXPORT_SYMBOL(capi_cmsg2str);
1013
EXPORT_SYMBOL(capi_message2str);
1014
EXPORT_SYMBOL(capi_info2str);

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.