FreeCalypso > hg > freecalypso-citrine

comparison g23m-gsm/cc/cc_em.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project :
4 | Modul :
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This Module defines the engineering mode (EM) device driver for the
18 | G23 protocol stack. This driver is used to control all engineering
19 | mode related functions.
20 +-----------------------------------------------------------------------------
21 */
22
23 #ifndef CC_EM_C
24 #define CC_EM_C
25
26 #include "config.h"
27 #include "fixedconf.h"
28 #include "condat-features.h"
29
30 #define ENTITY_CC
31
32 /*==== INCLUDES ===================================================*/
33
34 #include <string.h>
35 #include "typedefs.h"
36 #include "pcm.h"
37 #include "vsi.h"
38 #include "custom.h"
39 #include "gsm.h"
40 #include "message.h"
41 #include "ccdapi.h"
42 #include "prim.h"
43 #include "cnf_cc.h"
44 #include "mon_cc.h"
45 #include "pei.h"
46 #include "tok.h"
47 #include "cc.h"
48 #include "cc_em.h"
49
50 /*==== EXPORT =====================================================*/
51
52 /*==== PRIVAT =====================================================*/
53
54 /*==== VARIABLES ==================================================*/
55
56 #ifdef FF_EM_MODE
57 GLOBAL UBYTE em_cc_event_buffer[EM_CC_BUFFER_SIZE];
58 GLOBAL UBYTE em_cc_buffer_write;
59
60 /* Event tracing flags for EM */
61 GLOBAL BOOL cc_v[EM_MAX_CC_EVENTS];
62
63 static UBYTE em_cc_trace_occured;
64 #endif /* FF_EM_MODE */
65
66 /*==== FUNCTIONS ==================================================*/
67
68 #ifdef FF_EM_MODE
69
70 /*
71 +------------------------------------------------------------------------------
72 | Function : em_write_buffer_2
73 +------------------------------------------------------------------------------
74 | Description : Perform buffer check and store corresponding data in it.
75 |
76 | Parameters : Event number
77 |
78 | Return : TRUE/FALSE
79 |
80 +------------------------------------------------------------------------------
81 */
82
83 GLOBAL UBYTE em_write_buffer_2 (UBYTE event_no)
84 {
85 TRACE_FUNCTION ("cc_em_write_buffer_2()");
86 if (check_write_index(2))
87 {
88 em_cc_event_buffer[em_cc_buffer_write++] = event_no; /* Tag: Event number */
89 em_cc_event_buffer[em_cc_buffer_write++] = 0; /* Length: 0 means no value */
90 return FALSE; /* Data is stored inside buffer, reset flag */
91 }
92 else
93 return TRUE; /* No more space inside buffer, serve flag next time */
94 }
95
96 /*
97 +------------------------------------------------------------------------------
98 | Function : em_write_buffer_3
99 +------------------------------------------------------------------------------
100 | Description : Perform buffer check and store corresponding data in it.
101 |
102 | Parameters : Event number, data value
103 |
104 | Return : TRUE/FALSE
105 |
106 +------------------------------------------------------------------------------
107 */
108
109 GLOBAL UBYTE em_write_buffer_3 (UBYTE event_no, UBYTE value)
110 {
111 TRACE_FUNCTION ("cc_em_write_buffer_3()");
112
113 if (check_write_index(3))
114 {
115 em_cc_event_buffer[em_cc_buffer_write++] = event_no; /* Tag: Event number */
116 em_cc_event_buffer[em_cc_buffer_write++] = 1; /* Length: 0 means no value */
117 em_cc_event_buffer[em_cc_buffer_write++] = value; /* Data to be stored */
118 return FALSE; /* Data is stored inside buffer, reset flag */
119 }
120 else
121 return TRUE; /* No more space inside buffer, serve flag next time */
122 }
123
124 /*
125 +------------------------------------------------------------------------------
126 | Function : em_write_buffer_3a
127 +------------------------------------------------------------------------------
128 | Description : Perform buffer check and store corresponding data in it.
129 |
130 | Parameters : Event number, data value (USHORT)
131 |
132 | Return : TRUE/FALSE
133 |
134 +------------------------------------------------------------------------------
135 */
136
137 GLOBAL UBYTE em_write_buffer_3a (UBYTE event_no, USHORT value)
138 {
139 TRACE_FUNCTION ("cc_em_write_buffer_3a()");
140
141 if (check_write_index(4))
142 {
143 em_cc_event_buffer[em_cc_buffer_write++] = event_no; /* Tag: Event number */
144 em_cc_event_buffer[em_cc_buffer_write++] = 2; /* Length: 0 means no value */
145
146 /* Value: Data to be stored. MSB first, LSB second */
147 em_cc_event_buffer[em_cc_buffer_write++] = (UBYTE)(value >> 8);
148 em_cc_event_buffer[em_cc_buffer_write++] = (UBYTE)(value);
149 return FALSE; /* Data is stored inside buffer, reset flag */
150 }
151 else
152 return TRUE; /* No more space inside buffer, serve flag next time */
153 }
154
155 /*
156 +------------------------------------------------------------------------------
157 | Function : em_write_buffer_4
158 +------------------------------------------------------------------------------
159 | Description : Perform buffer check and store corresponding data in it.
160 |
161 | Parameters : Event number, data value1, data value2
162 |
163 | Return : TRUE/FALSE
164 |
165 +------------------------------------------------------------------------------
166 */
167
168 GLOBAL UBYTE em_write_buffer_4 (UBYTE event_no, UBYTE value1, UBYTE value2)
169 {
170 TRACE_FUNCTION ("cc_em_write_buffer_4()");
171
172 if (check_write_index(4))
173 {
174 em_cc_event_buffer[em_cc_buffer_write++] = event_no; /* Tag: Event number */
175 em_cc_event_buffer[em_cc_buffer_write++] = 2; /* Length: 0 means no value */
176 em_cc_event_buffer[em_cc_buffer_write++] = value1; /* Data to be stored, first */
177 em_cc_event_buffer[em_cc_buffer_write++] = value2; /* Data to be stored, second */
178 return FALSE; /* Data is stored inside buffer, reset flag */
179 }
180 else
181 return TRUE; /* No more space inside buffer, serve flag next time */
182 }
183
184
185 /*
186 +------------------------------------------------------------------------------
187 | Function : em_write_buffer_4a
188 +------------------------------------------------------------------------------
189 | Description : Perform buffer check and store corresponding data in it.
190 |
191 | Parameters : Event number, data value1 (UBYTE *), data value2
192 |
193 | Return : TRUE/FALSE
194 |
195 | Purpose : Stores Bearer Capabilitys
196 +------------------------------------------------------------------------------
197 */
198
199 GLOBAL UBYTE em_write_buffer_4a (UBYTE event_no, UBYTE *ptr1, UBYTE value2)
200 {
201
202 UBYTE bc_len;
203 UBYTE i, em_report_len = 3; /* Initial 2 + TI */
204
205 TRACE_FUNCTION ("cc_em_write_buffer_4a()");
206
207 ptr1++; /* Skip message type --> ptr1 shows now to BC-Tag*/
208 if (*ptr1++ EQ 0x04) /* BC tag (0x04) --> ptr1 shows now to length field*/
209 {
210 TRACE_FUNCTION ("EM_CC: BC tag found (0x04)");
211 if(*ptr1 > MNCC_MAX_BC_LEN) /* Field length exceeded */
212 {
213 ; /*better to insert some kind of trace here*/
214 bc_len = MNCC_MAX_BC_LEN; /*Just trace the maximum of BC's - skip the rest*/
215 }
216 else /* Field length not exceeded */
217 {
218 bc_len = *ptr1; /*trace all BC's possible */
219 }
220
221 ptr1++; /* ptr1 shows now the first BC */
222
223 em_report_len += bc_len; /* Length of encoded bearer caps */
224
225 if(check_write_index((UBYTE)(em_report_len))) /* just to ensure no buffer overflow */
226 {
227 em_cc_event_buffer[em_cc_buffer_write++] = event_no;
228 em_cc_event_buffer[em_cc_buffer_write++] = (em_report_len - 2);
229 for (i=0; i<(bc_len); i++) /* Starting with the bearercap IEI */
230 {
231 em_cc_event_buffer[em_cc_buffer_write++] = *ptr1++; /* Bearer caps encoded */
232 }
233 /* Only bearer caps should be recorded, therefore decrement em_cc_buffer_write */
234 em_cc_event_buffer[em_cc_buffer_write++] = value2; /* TI */
235
236 return FALSE; /* Data is stored inside buffer, reset flag */
237 } /* check_write_index */
238 } /* BC tag 0x04*/
239 else
240 {
241 TRACE_FUNCTION ("EM_CC: No BC tag found");
242 }/* no BC tag 0x04*/
243 return TRUE; /* No more space inside buffer or no BC tag, serve flag next time */
244 }
245
246
247 /*
248 +------------------------------------------------------------------------------
249 | Function : check_write_index
250 +------------------------------------------------------------------------------
251 | Description : Checks the write index inside the buffer. No reset when
252 | buffer is full.
253 |
254 | Parameters : Number of bytes to be stored in buffer
255 |
256 | Return : TRUE/FALSE
257 |
258 +------------------------------------------------------------------------------
259 */
260
261 GLOBAL UBYTE check_write_index (UBYTE n)
262 {
263 TRACE_FUNCTION ("cc_check_write_index()");
264
265 if (em_cc_buffer_write + n < EM_CC_BUFFER_SIZE)
266 {
267 /*
268 * ACI is informed about the first event trace,
269 * used for later data processing.
270 */
271 if (em_cc_trace_occured == 0)
272 {
273 PALLOC(data, EM_DATA_IND);
274 data->entity = EM_CC;
275 PSENDX(MMI, data);
276 em_cc_trace_occured++;
277 }
278 return TRUE;
279 }
280 else
281 {
282 TRACE_ERROR("EM_CC: buffer overflow");
283 return FALSE;
284 }
285 }
286
287
288 /*
289 +------------------------------------------------------------------------------
290 | Function : em_init_cc_event_trace
291 +------------------------------------------------------------------------------
292 | Description : Initialize the event tracing flags for SMS
293 |
294 | Parameters :
295 |
296 | Return :
297 |
298 +------------------------------------------------------------------------------
299 */
300
301 GLOBAL void em_init_cc_event_trace(void)
302 {
303 UBYTE i;
304
305 TRACE_FUNCTION ("em_init_cc_event_trace()");
306
307 for (i = 1; i < EM_MAX_CC_EVENTS; i++)
308 cc_v[i] = 0;
309
310 em_cc_buffer_write = 0;
311 }
312
313
314 /*
315 +------------------------------------------------------------------------------
316 | Function : cc_em_cc_event_req
317 +------------------------------------------------------------------------------
318 | Description : Set the event tracing flags according the bitmask
319 |
320 | Parameters : Primitive - Bitmask
321 |
322 | Return :
323 |
324 +------------------------------------------------------------------------------
325 */
326
327 GLOBAL void cc_em_cc_event_req (T_EM_CC_EVENT_REQ *em_cc_event_req)
328 {
329 UBYTE i;
330
331 TRACE_FUNCTION ("cc_em_cc_event_req()");
332
333 /*
334 * The event tracing flags are set according the bitmask. cc_v[i] are
335 * the flags belonging to the event number described in 8443.601
336 */
337 for(i = 1; i < 33; i++)
338 cc_v[i] = ((em_cc_event_req->bitmask_cc_l & (0x01<<(i-1))) > 0) ? TRUE : FALSE;
339
340 for(i = 33; i < EM_MAX_CC_EVENTS; i++)
341 cc_v[i] = ((em_cc_event_req->bitmask_cc_h & (0x01<<(i-1))) > 0) ? TRUE : FALSE;
342
343 /*
344 * A new event trace is generated therefor the flag is reset.
345 */
346 em_cc_trace_occured = 0;
347
348 PFREE(em_cc_event_req);
349 }
350
351 #endif /* FF_EM_MODE */
352
353 #endif /* CC_EM_C */