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