Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* $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> | |
1da177e4 LT |
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: | |
2f9e9b6d | 453 | if (*(u8 **) OFF == NULL) { |
1da177e4 LT |
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 | ||
4793d15b TS |
493 | /** |
494 | * capi_cmsg2message() - assemble CAPI 2.0 message from _cmsg structure | |
495 | * @cmsg: _cmsg structure | |
496 | * @msg: buffer for assembled message | |
497 | * | |
498 | * Return value: 0 for success | |
499 | */ | |
500 | ||
1da177e4 LT |
501 | unsigned capi_cmsg2message(_cmsg * cmsg, u8 * msg) |
502 | { | |
503 | cmsg->m = msg; | |
504 | cmsg->l = 8; | |
505 | cmsg->p = 0; | |
506 | cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; | |
507 | ||
508 | pars_2_message(cmsg); | |
509 | ||
510 | wordTLcpy(msg + 0, &cmsg->l); | |
511 | byteTLcpy(cmsg->m + 4, &cmsg->Command); | |
512 | byteTLcpy(cmsg->m + 5, &cmsg->Subcommand); | |
513 | wordTLcpy(cmsg->m + 2, &cmsg->ApplId); | |
514 | wordTLcpy(cmsg->m + 6, &cmsg->Messagenumber); | |
515 | ||
516 | return 0; | |
517 | } | |
518 | ||
519 | /*-------------------------------------------------------*/ | |
520 | static void message_2_pars(_cmsg * cmsg) | |
521 | { | |
522 | for (; TYP != _CEND; cmsg->p++) { | |
523 | ||
524 | switch (TYP) { | |
525 | case _CBYTE: | |
526 | byteTRcpy(cmsg->m + cmsg->l, OFF); | |
527 | cmsg->l++; | |
528 | break; | |
529 | case _CWORD: | |
530 | wordTRcpy(cmsg->m + cmsg->l, OFF); | |
531 | cmsg->l += 2; | |
532 | break; | |
533 | case _CDWORD: | |
534 | dwordTRcpy(cmsg->m + cmsg->l, OFF); | |
535 | cmsg->l += 4; | |
536 | break; | |
537 | case _CSTRUCT: | |
538 | *(u8 **) OFF = cmsg->m + cmsg->l; | |
539 | ||
540 | if (cmsg->m[cmsg->l] != 0xff) | |
541 | cmsg->l += 1 + cmsg->m[cmsg->l]; | |
542 | else | |
543 | cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1); | |
544 | break; | |
545 | case _CMSTRUCT: | |
546 | /*----- Metastruktur 0 -----*/ | |
547 | if (cmsg->m[cmsg->l] == '\0') { | |
548 | *(_cmstruct *) OFF = CAPI_DEFAULT; | |
549 | cmsg->l++; | |
550 | jumpcstruct(cmsg); | |
551 | } else { | |
552 | unsigned _l = cmsg->l; | |
553 | *(_cmstruct *) OFF = CAPI_COMPOSE; | |
554 | cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1; | |
555 | cmsg->p++; | |
556 | message_2_pars(cmsg); | |
557 | } | |
558 | break; | |
559 | } | |
560 | } | |
561 | } | |
562 | ||
4793d15b TS |
563 | /** |
564 | * capi_message2cmsg() - disassemble CAPI 2.0 message into _cmsg structure | |
565 | * @cmsg: _cmsg structure | |
566 | * @msg: buffer for assembled message | |
567 | * | |
568 | * Return value: 0 for success | |
569 | */ | |
570 | ||
1da177e4 LT |
571 | unsigned capi_message2cmsg(_cmsg * cmsg, u8 * msg) |
572 | { | |
573 | memset(cmsg, 0, sizeof(_cmsg)); | |
574 | cmsg->m = msg; | |
575 | cmsg->l = 8; | |
576 | cmsg->p = 0; | |
577 | byteTRcpy(cmsg->m + 4, &cmsg->Command); | |
578 | byteTRcpy(cmsg->m + 5, &cmsg->Subcommand); | |
579 | cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; | |
580 | ||
581 | message_2_pars(cmsg); | |
582 | ||
583 | wordTRcpy(msg + 0, &cmsg->l); | |
584 | wordTRcpy(cmsg->m + 2, &cmsg->ApplId); | |
585 | wordTRcpy(cmsg->m + 6, &cmsg->Messagenumber); | |
586 | ||
587 | return 0; | |
588 | } | |
589 | ||
4793d15b TS |
590 | /** |
591 | * capi_cmsg_header() - initialize header part of _cmsg structure | |
592 | * @cmsg: _cmsg structure | |
593 | * @_ApplId: ApplID field value | |
594 | * @_Command: Command field value | |
595 | * @_Subcommand: Subcommand field value | |
596 | * @_Messagenumber: Message Number field value | |
597 | * @_Controller: Controller/PLCI/NCCI field value | |
598 | * | |
599 | * Return value: 0 for success | |
600 | */ | |
601 | ||
1da177e4 LT |
602 | unsigned capi_cmsg_header(_cmsg * cmsg, u16 _ApplId, |
603 | u8 _Command, u8 _Subcommand, | |
604 | u16 _Messagenumber, u32 _Controller) | |
605 | { | |
606 | memset(cmsg, 0, sizeof(_cmsg)); | |
607 | cmsg->ApplId = _ApplId; | |
608 | cmsg->Command = _Command; | |
609 | cmsg->Subcommand = _Subcommand; | |
610 | cmsg->Messagenumber = _Messagenumber; | |
611 | cmsg->adr.adrController = _Controller; | |
612 | return 0; | |
613 | } | |
614 | ||
615 | /*-------------------------------------------------------*/ | |
616 | ||
617 | static char *mnames[] = | |
618 | { | |
619 | [0x01] = "ALERT_REQ", | |
620 | [0x02] = "CONNECT_REQ", | |
621 | [0x04] = "DISCONNECT_REQ", | |
622 | [0x05] = "LISTEN_REQ", | |
623 | [0x08] = "INFO_REQ", | |
624 | [0x09] = "FACILITY_REQ", | |
625 | [0x0a] = "SELECT_B_PROTOCOL_REQ", | |
626 | [0x0b] = "CONNECT_B3_REQ", | |
627 | [0x0d] = "DISCONNECT_B3_REQ", | |
628 | [0x0f] = "DATA_B3_REQ", | |
629 | [0x10] = "RESET_B3_REQ", | |
630 | [0x13] = "ALERT_CONF", | |
631 | [0x14] = "CONNECT_CONF", | |
632 | [0x16] = "DISCONNECT_CONF", | |
633 | [0x17] = "LISTEN_CONF", | |
634 | [0x18] = "MANUFACTURER_REQ", | |
635 | [0x1a] = "INFO_CONF", | |
636 | [0x1b] = "FACILITY_CONF", | |
637 | [0x1c] = "SELECT_B_PROTOCOL_CONF", | |
638 | [0x1d] = "CONNECT_B3_CONF", | |
639 | [0x1f] = "DISCONNECT_B3_CONF", | |
640 | [0x21] = "DATA_B3_CONF", | |
641 | [0x22] = "RESET_B3_CONF", | |
642 | [0x26] = "CONNECT_IND", | |
643 | [0x27] = "CONNECT_ACTIVE_IND", | |
644 | [0x28] = "DISCONNECT_IND", | |
645 | [0x2a] = "MANUFACTURER_CONF", | |
646 | [0x2c] = "INFO_IND", | |
647 | [0x2d] = "FACILITY_IND", | |
648 | [0x2f] = "CONNECT_B3_IND", | |
649 | [0x30] = "CONNECT_B3_ACTIVE_IND", | |
650 | [0x31] = "DISCONNECT_B3_IND", | |
651 | [0x33] = "DATA_B3_IND", | |
652 | [0x34] = "RESET_B3_IND", | |
653 | [0x35] = "CONNECT_B3_T90_ACTIVE_IND", | |
654 | [0x38] = "CONNECT_RESP", | |
655 | [0x39] = "CONNECT_ACTIVE_RESP", | |
656 | [0x3a] = "DISCONNECT_RESP", | |
657 | [0x3c] = "MANUFACTURER_IND", | |
658 | [0x3e] = "INFO_RESP", | |
659 | [0x3f] = "FACILITY_RESP", | |
660 | [0x41] = "CONNECT_B3_RESP", | |
661 | [0x42] = "CONNECT_B3_ACTIVE_RESP", | |
662 | [0x43] = "DISCONNECT_B3_RESP", | |
663 | [0x45] = "DATA_B3_RESP", | |
664 | [0x46] = "RESET_B3_RESP", | |
665 | [0x47] = "CONNECT_B3_T90_ACTIVE_RESP", | |
666 | [0x4e] = "MANUFACTURER_RESP" | |
667 | }; | |
668 | ||
4793d15b TS |
669 | /** |
670 | * capi_cmd2str() - convert CAPI 2.0 command/subcommand number to name | |
671 | * @cmd: command number | |
672 | * @subcmd: subcommand number | |
673 | * | |
674 | * Return value: static string, NULL if command/subcommand unknown | |
675 | */ | |
676 | ||
1da177e4 LT |
677 | char *capi_cmd2str(u8 cmd, u8 subcmd) |
678 | { | |
679 | return mnames[command_2_index(cmd, subcmd)]; | |
680 | } | |
681 | ||
682 | ||
683 | /*-------------------------------------------------------*/ | |
17f0cd2f KK |
684 | |
685 | #ifdef CONFIG_CAPI_TRACE | |
686 | ||
1da177e4 LT |
687 | /*-------------------------------------------------------*/ |
688 | ||
689 | static char *pnames[] = | |
690 | { | |
691 | /*00 */ NULL, | |
692 | /*01 */ NULL, | |
693 | /*02 */ NULL, | |
694 | /*03 */ "Controller/PLCI/NCCI", | |
695 | /*04 */ "AdditionalInfo", | |
696 | /*05 */ "B1configuration", | |
697 | /*06 */ "B1protocol", | |
698 | /*07 */ "B2configuration", | |
699 | /*08 */ "B2protocol", | |
700 | /*09 */ "B3configuration", | |
701 | /*0a */ "B3protocol", | |
702 | /*0b */ "BC", | |
703 | /*0c */ "BChannelinformation", | |
704 | /*0d */ "BProtocol", | |
705 | /*0e */ "CalledPartyNumber", | |
706 | /*0f */ "CalledPartySubaddress", | |
707 | /*10 */ "CallingPartyNumber", | |
708 | /*11 */ "CallingPartySubaddress", | |
709 | /*12 */ "CIPmask", | |
710 | /*13 */ "CIPmask2", | |
711 | /*14 */ "CIPValue", | |
712 | /*15 */ "Class", | |
713 | /*16 */ "ConnectedNumber", | |
714 | /*17 */ "ConnectedSubaddress", | |
715 | /*18 */ "Data32", | |
716 | /*19 */ "DataHandle", | |
717 | /*1a */ "DataLength", | |
718 | /*1b */ "FacilityConfirmationParameter", | |
719 | /*1c */ "Facilitydataarray", | |
720 | /*1d */ "FacilityIndicationParameter", | |
721 | /*1e */ "FacilityRequestParameter", | |
722 | /*1f */ "FacilitySelector", | |
723 | /*20 */ "Flags", | |
724 | /*21 */ "Function", | |
725 | /*22 */ "HLC", | |
726 | /*23 */ "Info", | |
727 | /*24 */ "InfoElement", | |
728 | /*25 */ "InfoMask", | |
729 | /*26 */ "InfoNumber", | |
730 | /*27 */ "Keypadfacility", | |
731 | /*28 */ "LLC", | |
732 | /*29 */ "ManuData", | |
733 | /*2a */ "ManuID", | |
734 | /*2b */ "NCPI", | |
735 | /*2c */ "Reason", | |
736 | /*2d */ "Reason_B3", | |
737 | /*2e */ "Reject", | |
738 | /*2f */ "Useruserdata" | |
739 | }; | |
740 | ||
741 | ||
1da177e4 LT |
742 | |
743 | #include <stdarg.h> | |
744 | ||
745 | /*-------------------------------------------------------*/ | |
17f0cd2f | 746 | static _cdebbuf *bufprint(_cdebbuf *cdb, char *fmt,...) |
1da177e4 LT |
747 | { |
748 | va_list f; | |
17f0cd2f KK |
749 | size_t n,r; |
750 | ||
751 | if (!cdb) | |
752 | return NULL; | |
1da177e4 | 753 | va_start(f, fmt); |
17f0cd2f KK |
754 | r = cdb->size - cdb->pos; |
755 | n = vsnprintf(cdb->p, r, fmt, f); | |
1da177e4 | 756 | va_end(f); |
17f0cd2f KK |
757 | if (n >= r) { |
758 | /* truncated, need bigger buffer */ | |
759 | size_t ns = 2 * cdb->size; | |
760 | u_char *nb; | |
761 | ||
762 | while ((ns - cdb->pos) <= n) | |
763 | ns *= 2; | |
764 | nb = kmalloc(ns, GFP_ATOMIC); | |
765 | if (!nb) { | |
766 | cdebbuf_free(cdb); | |
767 | return NULL; | |
768 | } | |
769 | memcpy(nb, cdb->buf, cdb->pos); | |
770 | kfree(cdb->buf); | |
771 | nb[cdb->pos] = 0; | |
772 | cdb->buf = nb; | |
773 | cdb->p = cdb->buf + cdb->pos; | |
774 | cdb->size = ns; | |
775 | va_start(f, fmt); | |
776 | r = cdb->size - cdb->pos; | |
777 | n = vsnprintf(cdb->p, r, fmt, f); | |
778 | va_end(f); | |
779 | } | |
780 | cdb->p += n; | |
781 | cdb->pos += n; | |
782 | return cdb; | |
1da177e4 LT |
783 | } |
784 | ||
17f0cd2f | 785 | static _cdebbuf *printstructlen(_cdebbuf *cdb, u8 * m, unsigned len) |
1da177e4 LT |
786 | { |
787 | unsigned hex = 0; | |
17f0cd2f KK |
788 | |
789 | if (!cdb) | |
790 | return NULL; | |
1da177e4 LT |
791 | for (; len; len--, m++) |
792 | if (isalnum(*m) || *m == ' ') { | |
793 | if (hex) | |
17f0cd2f KK |
794 | cdb = bufprint(cdb, ">"); |
795 | cdb = bufprint(cdb, "%c", *m); | |
1da177e4 LT |
796 | hex = 0; |
797 | } else { | |
798 | if (!hex) | |
17f0cd2f | 799 | cdb = bufprint(cdb, "<%02x", *m); |
1da177e4 | 800 | else |
17f0cd2f | 801 | cdb = bufprint(cdb, " %02x", *m); |
1da177e4 LT |
802 | hex = 1; |
803 | } | |
804 | if (hex) | |
17f0cd2f KK |
805 | cdb = bufprint(cdb, ">"); |
806 | return cdb; | |
1da177e4 LT |
807 | } |
808 | ||
17f0cd2f | 809 | static _cdebbuf *printstruct(_cdebbuf *cdb, u8 * m) |
1da177e4 LT |
810 | { |
811 | unsigned len; | |
17f0cd2f | 812 | |
1da177e4 LT |
813 | if (m[0] != 0xff) { |
814 | len = m[0]; | |
815 | m += 1; | |
816 | } else { | |
817 | len = ((u16 *) (m + 1))[0]; | |
818 | m += 3; | |
819 | } | |
17f0cd2f KK |
820 | cdb = printstructlen(cdb, m, len); |
821 | return cdb; | |
1da177e4 LT |
822 | } |
823 | ||
824 | /*-------------------------------------------------------*/ | |
825 | #define NAME (pnames[cmsg->par[cmsg->p]]) | |
826 | ||
17f0cd2f | 827 | static _cdebbuf *protocol_message_2_pars(_cdebbuf *cdb, _cmsg *cmsg, int level) |
1da177e4 LT |
828 | { |
829 | for (; TYP != _CEND; cmsg->p++) { | |
830 | int slen = 29 + 3 - level; | |
831 | int i; | |
832 | ||
17f0cd2f KK |
833 | if (!cdb) |
834 | return NULL; | |
835 | cdb = bufprint(cdb, " "); | |
1da177e4 | 836 | for (i = 0; i < level - 1; i++) |
17f0cd2f | 837 | cdb = bufprint(cdb, " "); |
1da177e4 LT |
838 | |
839 | switch (TYP) { | |
840 | case _CBYTE: | |
17f0cd2f | 841 | cdb = bufprint(cdb, "%-*s = 0x%x\n", slen, NAME, *(u8 *) (cmsg->m + cmsg->l)); |
1da177e4 LT |
842 | cmsg->l++; |
843 | break; | |
844 | case _CWORD: | |
17f0cd2f | 845 | cdb = bufprint(cdb, "%-*s = 0x%x\n", slen, NAME, *(u16 *) (cmsg->m + cmsg->l)); |
1da177e4 LT |
846 | cmsg->l += 2; |
847 | break; | |
848 | case _CDWORD: | |
17f0cd2f | 849 | cdb = bufprint(cdb, "%-*s = 0x%lx\n", slen, NAME, *(u32 *) (cmsg->m + cmsg->l)); |
1da177e4 LT |
850 | cmsg->l += 4; |
851 | break; | |
852 | case _CSTRUCT: | |
17f0cd2f | 853 | cdb = bufprint(cdb, "%-*s = ", slen, NAME); |
1da177e4 | 854 | if (cmsg->m[cmsg->l] == '\0') |
17f0cd2f | 855 | cdb = bufprint(cdb, "default"); |
1da177e4 | 856 | else |
17f0cd2f KK |
857 | cdb = printstruct(cdb, cmsg->m + cmsg->l); |
858 | cdb = bufprint(cdb, "\n"); | |
1da177e4 LT |
859 | if (cmsg->m[cmsg->l] != 0xff) |
860 | cmsg->l += 1 + cmsg->m[cmsg->l]; | |
861 | else | |
862 | cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1); | |
863 | ||
864 | break; | |
865 | ||
866 | case _CMSTRUCT: | |
867 | /*----- Metastruktur 0 -----*/ | |
868 | if (cmsg->m[cmsg->l] == '\0') { | |
17f0cd2f | 869 | cdb = bufprint(cdb, "%-*s = default\n", slen, NAME); |
1da177e4 LT |
870 | cmsg->l++; |
871 | jumpcstruct(cmsg); | |
872 | } else { | |
873 | char *name = NAME; | |
874 | unsigned _l = cmsg->l; | |
17f0cd2f | 875 | cdb = bufprint(cdb, "%-*s\n", slen, name); |
1da177e4 LT |
876 | cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1; |
877 | cmsg->p++; | |
17f0cd2f | 878 | cdb = protocol_message_2_pars(cdb, cmsg, level + 1); |
1da177e4 LT |
879 | } |
880 | break; | |
881 | } | |
882 | } | |
17f0cd2f | 883 | return cdb; |
1da177e4 LT |
884 | } |
885 | /*-------------------------------------------------------*/ | |
17f0cd2f KK |
886 | |
887 | static _cdebbuf *g_debbuf; | |
888 | static u_long g_debbuf_lock; | |
889 | static _cmsg *g_cmsg; | |
890 | ||
3a3a51d1 | 891 | static _cdebbuf *cdebbuf_alloc(void) |
1da177e4 | 892 | { |
17f0cd2f KK |
893 | _cdebbuf *cdb; |
894 | ||
895 | if (likely(!test_and_set_bit(1, &g_debbuf_lock))) { | |
896 | cdb = g_debbuf; | |
897 | goto init; | |
898 | } else | |
899 | cdb = kmalloc(sizeof(_cdebbuf), GFP_ATOMIC); | |
900 | if (!cdb) | |
901 | return NULL; | |
902 | cdb->buf = kmalloc(CDEBUG_SIZE, GFP_ATOMIC); | |
903 | if (!cdb->buf) { | |
904 | kfree(cdb); | |
905 | return NULL; | |
906 | } | |
907 | cdb->size = CDEBUG_SIZE; | |
908 | init: | |
909 | cdb->buf[0] = 0; | |
910 | cdb->p = cdb->buf; | |
911 | cdb->pos = 0; | |
912 | return cdb; | |
913 | } | |
1da177e4 | 914 | |
4793d15b TS |
915 | /** |
916 | * cdebbuf_free() - free CAPI debug buffer | |
917 | * @cdb: buffer to free | |
918 | */ | |
919 | ||
17f0cd2f KK |
920 | void cdebbuf_free(_cdebbuf *cdb) |
921 | { | |
922 | if (likely(cdb == g_debbuf)) { | |
923 | test_and_clear_bit(1, &g_debbuf_lock); | |
924 | return; | |
925 | } | |
926 | if (likely(cdb)) | |
927 | kfree(cdb->buf); | |
928 | kfree(cdb); | |
929 | } | |
1da177e4 | 930 | |
1da177e4 | 931 | |
4793d15b TS |
932 | /** |
933 | * capi_message2str() - format CAPI 2.0 message for printing | |
934 | * @msg: CAPI 2.0 message | |
935 | * | |
936 | * Allocates a CAPI debug buffer and fills it with a printable representation | |
937 | * of the CAPI 2.0 message in @msg. | |
938 | * Return value: allocated debug buffer, NULL on error | |
939 | * The returned buffer should be freed by a call to cdebbuf_free() after use. | |
940 | */ | |
941 | ||
17f0cd2f KK |
942 | _cdebbuf *capi_message2str(u8 * msg) |
943 | { | |
944 | _cdebbuf *cdb; | |
945 | _cmsg *cmsg; | |
946 | ||
947 | cdb = cdebbuf_alloc(); | |
948 | if (unlikely(!cdb)) | |
949 | return NULL; | |
950 | if (likely(cdb == g_debbuf)) | |
951 | cmsg = g_cmsg; | |
952 | else | |
953 | cmsg = kmalloc(sizeof(_cmsg), GFP_ATOMIC); | |
954 | if (unlikely(!cmsg)) { | |
955 | cdebbuf_free(cdb); | |
956 | return NULL; | |
957 | } | |
958 | cmsg->m = msg; | |
959 | cmsg->l = 8; | |
960 | cmsg->p = 0; | |
961 | byteTRcpy(cmsg->m + 4, &cmsg->Command); | |
962 | byteTRcpy(cmsg->m + 5, &cmsg->Subcommand); | |
963 | cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; | |
964 | ||
965 | cdb = bufprint(cdb, "%-26s ID=%03d #0x%04x LEN=%04d\n", | |
966 | mnames[command_2_index(cmsg->Command, cmsg->Subcommand)], | |
1da177e4 LT |
967 | ((unsigned short *) msg)[1], |
968 | ((unsigned short *) msg)[3], | |
969 | ((unsigned short *) msg)[0]); | |
970 | ||
17f0cd2f KK |
971 | cdb = protocol_message_2_pars(cdb, cmsg, 1); |
972 | if (unlikely(cmsg != g_cmsg)) | |
973 | kfree(cmsg); | |
974 | return cdb; | |
1da177e4 LT |
975 | } |
976 | ||
4793d15b TS |
977 | /** |
978 | * capi_cmsg2str() - format _cmsg structure for printing | |
979 | * @cmsg: _cmsg structure | |
980 | * | |
981 | * Allocates a CAPI debug buffer and fills it with a printable representation | |
982 | * of the CAPI 2.0 message stored in @cmsg by a previous call to | |
983 | * capi_cmsg2message() or capi_message2cmsg(). | |
984 | * Return value: allocated debug buffer, NULL on error | |
985 | * The returned buffer should be freed by a call to cdebbuf_free() after use. | |
986 | */ | |
987 | ||
17f0cd2f | 988 | _cdebbuf *capi_cmsg2str(_cmsg * cmsg) |
1da177e4 | 989 | { |
17f0cd2f KK |
990 | _cdebbuf *cdb; |
991 | ||
7d31acda TS |
992 | if (!cmsg->m) |
993 | return NULL; /* no message */ | |
17f0cd2f KK |
994 | cdb = cdebbuf_alloc(); |
995 | if (!cdb) | |
996 | return NULL; | |
1da177e4 LT |
997 | cmsg->l = 8; |
998 | cmsg->p = 0; | |
17f0cd2f | 999 | cdb = bufprint(cdb, "%s ID=%03d #0x%04x LEN=%04d\n", |
1da177e4 LT |
1000 | mnames[command_2_index(cmsg->Command, cmsg->Subcommand)], |
1001 | ((u16 *) cmsg->m)[1], | |
1002 | ((u16 *) cmsg->m)[3], | |
1003 | ((u16 *) cmsg->m)[0]); | |
17f0cd2f KK |
1004 | cdb = protocol_message_2_pars(cdb, cmsg, 1); |
1005 | return cdb; | |
1da177e4 LT |
1006 | } |
1007 | ||
17f0cd2f KK |
1008 | int __init cdebug_init(void) |
1009 | { | |
1010 | g_cmsg= kmalloc(sizeof(_cmsg), GFP_KERNEL); | |
1011 | if (!g_cmsg) | |
066b2118 | 1012 | return -ENOMEM; |
17f0cd2f KK |
1013 | g_debbuf = kmalloc(sizeof(_cdebbuf), GFP_KERNEL); |
1014 | if (!g_debbuf) { | |
1015 | kfree(g_cmsg); | |
066b2118 | 1016 | return -ENOMEM; |
17f0cd2f KK |
1017 | } |
1018 | g_debbuf->buf = kmalloc(CDEBUG_GSIZE, GFP_KERNEL); | |
1019 | if (!g_debbuf->buf) { | |
1020 | kfree(g_cmsg); | |
1021 | kfree(g_debbuf); | |
066b2118 | 1022 | return -ENOMEM;; |
17f0cd2f KK |
1023 | } |
1024 | g_debbuf->size = CDEBUG_GSIZE; | |
1025 | g_debbuf->buf[0] = 0; | |
1026 | g_debbuf->p = g_debbuf->buf; | |
1027 | g_debbuf->pos = 0; | |
1028 | return 0; | |
1029 | } | |
1030 | ||
1031 | void __exit cdebug_exit(void) | |
1032 | { | |
1033 | if (g_debbuf) | |
1034 | kfree(g_debbuf->buf); | |
1035 | kfree(g_debbuf); | |
1036 | kfree(g_cmsg); | |
1037 | } | |
1038 | ||
1039 | #else /* !CONFIG_CAPI_TRACE */ | |
1040 | ||
1041 | static _cdebbuf g_debbuf = {"CONFIG_CAPI_TRACE not enabled", NULL, 0, 0}; | |
1042 | ||
1043 | _cdebbuf *capi_message2str(u8 * msg) | |
1044 | { | |
1045 | return &g_debbuf; | |
1046 | } | |
1047 | ||
1048 | _cdebbuf *capi_cmsg2str(_cmsg * cmsg) | |
1049 | { | |
1050 | return &g_debbuf; | |
1051 | } | |
1052 | ||
17f0cd2f KK |
1053 | void cdebbuf_free(_cdebbuf *cdb) |
1054 | { | |
1055 | } | |
1056 | ||
1057 | int __init cdebug_init(void) | |
1058 | { | |
1059 | return 0; | |
1060 | } | |
1061 | ||
1062 | void __exit cdebug_exit(void) | |
1063 | { | |
1064 | } | |
1065 | ||
1066 | #endif | |
1067 | ||
17f0cd2f | 1068 | EXPORT_SYMBOL(cdebbuf_free); |
1da177e4 LT |
1069 | EXPORT_SYMBOL(capi_cmsg2message); |
1070 | EXPORT_SYMBOL(capi_message2cmsg); | |
1071 | EXPORT_SYMBOL(capi_cmsg_header); | |
1072 | EXPORT_SYMBOL(capi_cmd2str); | |
1073 | EXPORT_SYMBOL(capi_cmsg2str); | |
1074 | EXPORT_SYMBOL(capi_message2str); | |
1075 | EXPORT_SYMBOL(capi_info2str); |