FreeCalypso > hg > freecalypso-citrine

comparison gpf/frame/vsi_com.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 | File: vsi_com.c
4 +------------------------------------------------------------------------------
5 | Copyright 2002 Texas Instruments Berlin, AG
6 | All rights reserved.
7 |
8 | This file is confidential and a trade secret of Texas
9 | Instruments Berlin, AG
10 | The receipt of or possession of this file does not convey
11 | any rights to reproduce or disclose its contents or to
12 | manufacture, use, or sell anything it may describe, in
13 | whole, or in part, without the specific written consent of
14 | Texas Instruments Berlin, AG.
15 +-----------------------------------------------------------------------------
16 | Purpose : This Module defines the virtual system interface part
17 | about communication via primitives and signals.
18 +-----------------------------------------------------------------------------
19 */
20
21 #undef TEST_PCHECK
22
23 #ifndef __VSI_COM_C__
24 #define __VSI_COM_C__
25 #endif
26
27 /*==== INCLUDES ===================================================*/
28
29 #include "gpfconf.h"
30 #include "typedefs.h"
31 #include "string.h"
32 #include "os.h"
33 #include "vsi.h"
34 #include "frame.h"
35 #include "vsi.h"
36 #include "frm_defs.h"
37 #include "frm_types.h"
38 #include "frm_glob.h"
39 #include "route.h"
40
41 #ifdef MEMORY_SUPERVISION
42 #include "tools.h"
43 #endif
44
45 #ifdef _TOOLS_
46 #include "stdlib.h"
47 #endif
48
49 /*==== CONSTANTS ==================================================*/
50
51 #ifndef RUN_INT_RAM
52 char const *waited_queue_str= "Waited for space in queue";
53 char const *freed_sent_str = "Freed partition sent";
54 char const *disc_str = "Signal discarded";
55 char const *freed_str = "Partition already freed";
56 char const *trunc_str = "Allocation request truncated";
57 char const *guard_str = "Partition guard pattern destroyed";
58 char const *unknown_str = "unknown";
59 #else
60 extern char const *waited_queue_str;
61 extern char const *freed_sent_str;
62 extern char const *disc_str;
63 extern char const *freed_str;
64 extern char const *trunc_str;
65 extern char const *guard_str;
66 extern char const *unknown_str;
67 #endif
68
69 #if !defined _TARGET_ && !defined _TOOLS_
70 char const *pcheck_str = "pcon_check() returned error";
71 #define PCHECK_INITIALIZED 0xaffedead
72 #endif
73
74
75 #define MAX_DRP_BOUND 12
76
77 /*==== TYPES ======================================================*/
78
79 #if !defined _TARGET_ && !defined _TOOLS_
80 typedef struct
81 {
82 unsigned int magic_nr;
83 ULONG ret_ok;
84 ULONG (*pcheck)(ULONG opc, void * decoded_prim);
85 } T_PCHECK;
86 #endif
87
88 /*==== EXTERNALS ==================================================*/
89
90 /* -------------- S H A R E D - BEGIN ---------------- */
91 #ifdef _TOOLS_
92 #pragma data_seg("FRAME_SHARED")
93 #endif
94
95
96 #ifdef _TOOLS_
97 extern char FRM_TST_NAME[];
98 __declspec (dllimport) T_HANDLE TST_Handle;
99 #else
100 extern T_HANDLE TST_Handle;
101 #endif
102
103 extern T_HANDLE vsi_m_sem_handle;
104 extern char TaskName [];
105 //extern OS_HANDLE ext_data_pool_handle;
106 #if defined _NUCLEUS_ && defined NU_DEBUG
107 extern char check_desclist;
108 #endif
109
110 /*==== VARIABLES ==================================================*/
111
112 #if !defined _TARGET_ && !defined _TOOLS_
113 T_PCHECK pcheck_func;
114 #endif /* _TARGET_ */
115
116 #ifndef RUN_INT_RAM
117 char QueueName [ RESOURCE_NAMELEN ];
118 //char *pf_com_matrix = NULL;
119 #else
120 extern char QueueName [];
121 #endif
122
123 #ifdef _TOOLS_
124 #pragma data_seg()
125 #endif
126 /* -------------- S H A R E D - END ---------------- */
127
128 /*==== PROTOTYPES =================================================*/
129
130 #if !defined _TARGET_ && !defined _TOOLS_
131 #ifdef TEST_PCHECK
132 ULONG test_pcheck ( ULONG opc, void * decoded_prim );
133 #endif
134 #endif /* _TARGET_ */
135
136
137 #if defined _NUCLEUS_ && defined NU_DEBUG
138 int check_descriptor_list ( T_HANDLE caller, T_PRIM_HEADER *prim FILE_LINE_TYPE );
139 #endif
140
141 int int_vsi_c_pattach (T_VOID_STRUCT *prim FILE_LINE_TYPE);
142
143
144 /*==== FUNCTIONS ==================================================*/
145
146 #if 0
147 not needed -> temporarily removed
148 #ifndef RUN_INT_RAM
149 /*
150 +--------------------------------------------------------------------+
151 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
152 | STATE : code ROUTINE : vsi_c_open |
153 +--------------------------------------------------------------------+
154
155 PURPOSE : get the handle of a queue
156
157 */
158
159 char * vsi_c_init_com_matrix ( int max_entities )
160 {
161 int size;
162
163 size = (max_entities+1)*(max_entities+1);
164 if ( os_AllocateMemory ( NO_TASK, (T_VOID_STRUCT**)&pf_com_matrix, size, OS_NO_SUSPEND, ext_data_pool_handle ) != OS_OK )
165 {
166 vsi_o_assert ( NO_TASK, OS_SYST_ERR_NO_MEMORY, __FILE__, __LINE__, "No memory available for com matrix");
167 }
168 return pf_com_matrix;
169 }
170 #endif
171
172
173 #ifndef RUN_INT_RAM
174 /*
175 +--------------------------------------------------------------------------+
176 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
177 | STATE : code ROUTINE : vsi_c_get_com_matrix_entry|
178 +--------------------------------------------------------------------------+
179
180 PURPOSE : get an entry of the com matrix
181
182 */
183
184 int vsi_c_get_com_matrix_entry ( int entry, char *dst )
185 {
186 T_HANDLE snd, rcv;
187 static int cnt;
188 int size_of_matrix = (MaxEntities+1)*(MaxEntities+1);
189 int snd_len;
190
191 if ( entry == FIRST_ENTRY )
192 {
193 cnt = 0;
194 }
195 while ( cnt <= size_of_matrix )
196 {
197 if ( pf_com_matrix[cnt] != 0 )
198 {
199 snd = cnt/(MaxEntities+1);
200 vsi_e_name (NO_TASK, snd, &dst[0]);
201 snd_len = strlen(&dst[0]);
202 dst[snd_len]=' ';
203 rcv = cnt%(MaxEntities+1);
204 vsi_e_name (NO_TASK, rcv, &dst[snd_len+1]);
205 cnt++;
206 return VSI_OK;
207 }
208 cnt++;
209 }
210 return VSI_ERROR;
211 }
212 #endif
213
214 #ifndef RUN_INT_RAM
215 /*
216 +--------------------------------------------------------------------------+
217 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
218 | STATE : code ROUTINE : vsi_c_get_entity_com_entry|
219 +--------------------------------------------------------------------------+
220
221 PURPOSE : get a entity handle the is used by an entity to send primitives
222
223 */
224
225 int vsi_c_get_entity_com_entry ( int entry, T_HANDLE rcv, T_HANDLE *snd )
226 {
227 static int cnt;
228 int size_of_matrix = (MaxEntities+1)*(MaxEntities+1);
229
230 if ( entry == FIRST_ENTRY )
231 {
232 cnt = rcv;
233 }
234 while ( cnt <= size_of_matrix )
235 {
236 if ( pf_com_matrix[cnt] != 0 )
237 {
238 *snd = cnt / (MaxEntities + 1);
239 cnt = cnt + MaxEntities + 1;
240 return VSI_OK;
241 }
242 cnt = cnt + MaxEntities + 1;
243 }
244 return VSI_ERROR;
245 }
246 #endif
247 #endif
248
249 #ifndef RUN_INT_RAM
250 /*
251 +--------------------------------------------------------------------+
252 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
253 | STATE : code ROUTINE : vsi_c_open |
254 +--------------------------------------------------------------------+
255
256 PURPOSE : get the handle of a queue
257
258 */
259
260 T_HANDLE vsi_c_open (T_HANDLE Caller, char *Name)
261 {
262 #ifdef _TOOLS_
263 OS_HANDLE ComHandle;
264
265 if ( os_OpenQueue ( Caller, Name, &ComHandle ) != OS_ERROR )
266 return ComHandle;
267 #else
268 T_HANDLE e_handle;
269
270 for ( e_handle = MaxEntities; e_handle > 0; e_handle-- )
271 {
272 if ( pf_TaskTable[e_handle].Name[0] != 0
273 && pf_TaskTable[e_handle].QueueHandle != 0
274 && !strncmp (pf_TaskTable[e_handle].Name, Name, RESOURCE_NAMELEN-1) )
275 {
276 /*
277 not needed -> temporarily removed
278 pf_com_matrix[Caller*(MaxEntities+1)+e_handle] = 1;
279 */
280 return e_handle;
281 }
282 }
283 #endif
284 return VSI_ERROR;
285 }
286 #endif
287
288 #ifndef RUN_INT_RAM
289 /*
290 +--------------------------------------------------------------------+
291 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
292 | STATE : code ROUTINE : vsi_c_close |
293 +--------------------------------------------------------------------+
294
295 PURPOSE : return the handle of a queue
296
297 */
298
299 int vsi_c_close (T_HANDLE Caller, T_HANDLE ComHandle)
300 {
301
302 if ( os_CloseQueue ( Caller, ComHandle ) != OS_ERROR )
303 return VSI_OK;
304
305 return VSI_ERROR;
306 }
307 #endif
308
309 #ifndef RUN_INT_RAM
310 /*
311 +--------------------------------------------------------------------+
312 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
313 | STATE : code ROUTINE : vsi_c_clear |
314 +--------------------------------------------------------------------+
315
316 PURPOSE : read all messages from a queue
317
318 */
319
320 int vsi_c_clear (T_HANDLE Caller, T_HANDLE ComHandle)
321 {
322 OS_QDATA Msg;
323
324 while ( os_ReceiveFromQueue ( NO_TASK, ComHandle, &Msg, OS_NO_SUSPEND ) == OS_OK )
325 {
326 ;
327 }
328
329 return VSI_OK;
330 }
331 #endif
332
333 #ifndef RUN_FLASH
334 /*
335 +--------------------------------------------------------------------+
336 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
337 | STATE : code ROUTINE : vsi_c_send |
338 +--------------------------------------------------------------------+
339
340 PURPOSE : write a message to a queue
341
342 */
343
344 int vsi_c_send (T_HANDLE Caller, T_HANDLE ComHandle, T_QMSG *Msg FILE_LINE_TYPE)
345 {
346 OS_QDATA OS_Msg = { 0 };
347 LONG Status;
348 USHORT Prio;
349 #ifdef NU_DEBUG
350 T_PRIM_HEADER *prim;
351 #ifdef _TARGET_
352 T_HANDLE t_handle;
353 #endif
354 #endif
355
356 OS_Msg.data16 = Msg->MsgType;
357 OS_Msg.e_id = ComHandle;
358 switch ( Msg->MsgType )
359 {
360 case MSG_PRIMITIVE:
361 OS_Msg.ptr = Msg->Msg.Primitive.Prim;
362 OS_Msg.data32 = P_OPC(Msg->Msg.Primitive.Prim);
363 #ifdef _TOOLS_
364 OS_Msg.len = Msg->Msg.Primitive.PrimLen;
365 #endif
366 os_GetTime ( 0, &OS_Msg.time );
367 Prio = MSG_PRIMITIVE_PRIO;
368 break;
369 case MSG_SIGNAL:
370 OS_Msg.ptr = Msg->Msg.Signal.SigBuffer;
371 OS_Msg.data32 = Msg->Msg.Signal.SigOPC;
372 #ifdef _TOOLS_
373 OS_Msg.len = Msg->Msg.Signal.SigLen;
374 #endif
375 os_GetTime ( 0, &OS_Msg.time );
376 Prio = MSG_SIGNAL_PRIO;
377 break;
378 default: return VSI_ERROR;
379 /*lint -e527 suppress Warning -- Unreachable */
380 break;
381 /*lint +e527 */
382 }
383
384 #ifdef _NUCLEUS_
385 #ifdef NU_DEBUG
386 /* PARTITION GUARD PATTERN CHECK */
387 if ( Msg->MsgType == MSG_PRIMITIVE )
388 {
389 prim = (T_PRIM_HEADER*)Msg->Msg.Primitive.Prim;
390 if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)prim )) == OS_OK )
391 {
392 if ( check_desclist == TRUE && prim->dph_offset != 0 )
393 {
394 check_descriptor_list ( Caller, prim FILE_LINE );
395 }
396 }
397 else
398 {
399 switch ( Status )
400 {
401 case OS_PARTITION_FREE:
402 vsi_o_assert ( Caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
403 "%s (PSEND),entity %s, partition 0x%x, opc 0x%x",
404 freed_sent_str, pf_TaskTable[Caller].Name, prim, prim->opc );
405 break;
406 case OS_PARTITION_GUARD_PATTERN_DESTROYED:
407 vsi_o_assert ( Caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED,
408 "%s (PSEND), entity %s, partition 0x%x, opc 0x%x",
409 guard_str, pf_TaskTable[Caller].Name, prim, prim->opc );
410 break;
411 default:
412 break;
413 }
414 }
415 #ifdef MEMORY_SUPERVISION
416 vsi_ppm_send ( Caller, ComHandle, (T_PRIM_HEADER*)Msg->Msg.Primitive.Prim, file, line );
417 #endif /* MEMORY_SUPERVISION */
418 }
419 #ifdef _TARGET_
420 if ( (t_handle = os_MyHandle()) != 0 )
421 {
422 int opc;
423 switch ( os_CheckTaskStack ( t_handle ) )
424 {
425 case OS_ERROR:
426 if ( Msg->MsgType == MSG_PRIMITIVE )
427 {
428 opc = ((T_PRIM_HEADER*)Msg->Msg.Primitive.Prim)->opc;
429 }
430 else
431 {
432 opc = Msg->Msg.Signal.SigOPC;
433 }
434 vsi_o_assert ( Caller, OS_SYST_ERR_STACK_OVERFLOW FILE_LINE_MACRO_PASSED,
435 "%s Stack overflow, 0x%x", pf_TaskTable[Caller].Name, opc );
436 break;
437 default:
438 break;
439 }
440 }
441 #endif /* _TARGET_ */
442 #endif /* NU_DEBUG */
443 #endif /* _NUCLEUS_ */
444
445 Status = rt_Route ( Caller, ComHandle, Prio, OS_SUSPEND, &OS_Msg );
446
447 switch ( Status )
448 {
449 case OS_WAITED:
450 #ifdef NU_DEBUG
451 pf_handle_warning ( OS_SYST_WRN_WAIT_QUEUE, "%s %s, entity %s, queue %s, %s(%d)",
452 syst_wrn, waited_queue_str, pf_TaskTable[Caller].Name, pf_TaskTable[ComHandle].Name FILE_LINE_MACRO_PASSED );
453 #endif
454 return VSI_OK;
455 /*lint -e527 suppress Warning -- Unreachable */
456 break;
457 /*lint +e527 */
458 case OS_TIMEOUT:
459 case OS_ERROR:
460 case OS_INVALID_QUEUE:
461 Caller = e_running[os_MyHandle()];
462 if ( Msg->MsgType == MSG_SIGNAL )
463 {
464 #ifdef NU_DEBUG
465 pf_handle_warning ( OS_SYST_WRN_WAIT_QUEUE, "%s %s from %s to %s, opc 0x%x, %s(%d)",
466 syst_wrn, disc_str, pf_TaskTable[Caller].Name, pf_TaskTable[ComHandle].Name, Msg->Msg.Signal.SigOPC FILE_LINE_MACRO_PASSED );
467 #endif
468 return VSI_OK;
469 }
470 else
471 {
472 char const *p_queue_name;
473 if ( Status == OS_INVALID_QUEUE )
474 {
475 p_queue_name = unknown_str;
476 }
477 else
478 {
479 #ifdef _TOOLS_
480 os_GetQueueName ( Caller, ComHandle, QueueName );
481 p_queue_name = QueueName;
482 #else
483 p_queue_name = pf_TaskTable[ComHandle].Name;
484 #endif
485 }
486 vsi_o_assert ( Caller, OS_SYST_ERR_QUEUE_FULL FILE_LINE_MACRO_PASSED,
487 "%s write attempt to %s queue failed",
488 pf_TaskTable[Caller].Name, p_queue_name );
489 #ifdef MEMORY_SUPERVISION
490 vsi_ppm_free ( Caller, (T_PRIM_HEADER*)(OS_Msg.ptr-PPM_OFFSET), file, line);
491 #endif
492 os_DeallocatePartition (Caller, OS_Msg.ptr-PPM_OFFSET );
493 return VSI_ERROR;
494 }
495 /*lint -e527 suppress Warning -- Unreachable */
496 break;
497 /*lint +e527 */
498 case OS_OK:
499 return VSI_OK;
500 /*lint -e527 suppress Warning -- Unreachable */
501 break;
502 /*lint +e527 */
503 default:
504 return VSI_ERROR;
505 /*lint -e527 suppress Warning -- Unreachable */
506 break;
507 /*lint +e527 */
508 }
509
510 }
511 #endif
512
513 #ifndef RUN_FLASH
514 /*
515 +--------------------------------------------------------------------+
516 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
517 | STATE : code ROUTINE : vsi_c_psend |
518 +--------------------------------------------------------------------+
519
520 PURPOSE : wrapper for vsi_c_send to avoid code wasting macro
521
522 */
523 int vsi_c_psend_caller ( T_HANDLE Caller, T_HANDLE ComHandle, T_VOID_STRUCT *ptr FILE_LINE_TYPE )
524 {
525 T_QMSG QMsg;
526 T_VOID_STRUCT *snd_ptr = (T_VOID_STRUCT*)D2P(ptr);
527
528 QMsg.Msg.Primitive.Prim = snd_ptr;
529 #ifdef _TOOLS_
530 if ( ((T_PRIM_HEADER*)snd_ptr)->sh_offset != 0 )
531 QMsg.Msg.Primitive.PrimLen = ALIGN(PSIZE(ptr)) + sizeof(T_S_HEADER);
532 else
533 #endif
534 QMsg.Msg.Primitive.PrimLen = PSIZE(ptr);
535 QMsg.MsgType = MSG_PRIMITIVE;
536 if ( Caller != TST_Handle && !(P_OPC(QMsg.Msg.Primitive.Prim) & SYS_MASK ) )
537 vsi_o_ptrace (Caller, P_OPC(QMsg.Msg.Primitive.Prim), 1);
538
539 #if !defined _TARGET_ && !defined _TOOLS_
540 if ( (pcheck_active[Caller] == 1) && (pcheck_func.pcheck != NULL) )
541 {
542 ULONG ret;
543 if ( (ret = pcheck_func.pcheck ( D_OPC(ptr), ptr )) != pcheck_func.ret_ok )
544 {
545 pf_handle_warning ( OS_SYST_WRN, "%s %s %d in %s, opc 0x%x, %s(%d)",
546 syst_wrn, pcheck_str, ret, pf_TaskTable[Caller].Name, D_OPC(ptr) FILE_LINE_MACRO_PASSED );
547 }
548 }
549 #endif
550 return ( vsi_c_send ( Caller, ComHandle, &QMsg FILE_LINE) );
551 }
552 #endif
553
554 #ifndef RUN_FLASH
555 /*
556 +--------------------------------------------------------------------+
557 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
558 | STATE : code ROUTINE : vsi_c_psend |
559 +--------------------------------------------------------------------+
560
561 PURPOSE : wrapper for vsi_c_send to avoid code wasting macro
562
563 */
564 int vsi_c_psend ( T_HANDLE ComHandle, T_VOID_STRUCT *ptr FILE_LINE_TYPE )
565 {
566 T_HANDLE Caller;
567
568 Caller = e_running[os_MyHandle()];
569
570 return ( vsi_c_psend_caller ( Caller, ComHandle, ptr FILE_LINE) );
571 }
572 #endif
573
574 #ifndef RUN_FLASH
575 /*
576 +--------------------------------------------------------------------+
577 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
578 | STATE : code ROUTINE : vsi_c_ssend |
579 +--------------------------------------------------------------------+
580
581 PURPOSE : wrapper for vsi_c_send to avoid code wasting macro
582
583 */
584 int vsi_c_ssend ( T_HANDLE ComHandle, ULONG opc, T_VOID_STRUCT *ptr,
585 ULONG MsgLen FILE_LINE_TYPE )
586 {
587 T_QMSG QMsg;
588 T_HANDLE Caller;
589
590 Caller = e_running[os_MyHandle()];
591
592 QMsg.Msg.Signal.SigBuffer = (T_VOID_STRUCT*)ptr;
593 QMsg.Msg.Signal.SigOPC = opc;
594 QMsg.Msg.Signal.SigLen = MsgLen;
595 QMsg.MsgType = MSG_SIGNAL;
596
597 return ( vsi_c_send ( Caller, ComHandle, &QMsg FILE_LINE ) );
598
599 }
600 #endif
601
602 #ifndef RUN_FLASH
603 /*
604 +--------------------------------------------------------------------+
605 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
606 | STATE : code ROUTINE : vsi_c_new |
607 +--------------------------------------------------------------------+
608
609 PURPOSE : allocate a partition to send a primitive
610
611 */
612
613 T_VOID_STRUCT * vsi_c_new (T_HANDLE Caller, ULONG Size, ULONG opc FILE_LINE_TYPE)
614 {
615 T_VOID_STRUCT *prim;
616 ULONG flags;
617
618 /* VSI_MEM_NON_BLOCKING not set, blocking allocation for backwards compatibility */
619 flags = PrimGroupHandle;
620 prim = (T_VOID_STRUCT*)D2P(vsi_c_pnew_generic (Caller, Size, opc, flags FILE_LINE));
621 return prim;
622
623 }
624 #endif
625
626 #ifndef RUN_FLASH
627 /*
628 +--------------------------------------------------------------------+
629 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
630 | STATE : code ROUTINE : vsi_c_new |
631 +--------------------------------------------------------------------+
632
633 PURPOSE : allocate a partition to send a primitive
634
635 */
636
637 T_VOID_STRUCT * vsi_c_pnew_generic (T_HANDLE Caller, ULONG Size, ULONG opc, ULONG flags FILE_LINE_TYPE)
638 {
639 T_VOID_STRUCT *prim;
640
641 if ( Size < sizeof(T_PRIM_HEADER) )
642 Size = sizeof(T_PRIM_HEADER);
643
644 if ( (prim = vsi_m_new ( Size, flags FILE_LINE )) != NULL )
645 {
646 P_OPC(prim) = opc;
647 P_LEN(prim) = Size;
648 P_SDU(prim) = NULL;
649 P_CNT(prim) = 1;
650 P_SHO(prim) = 0;
651 P_DPHO(prim) = 0;
652 #ifdef MEMORY_SUPERVISION
653 Caller = e_running[os_MyHandle()];
654 vsi_ppm_new ( Caller, Size, (T_PRIM_HEADER*)prim, file, line );
655 #endif
656
657 #ifndef _TOOLS_
658 if (opc & MEMHANDLE_OPC)
659 {
660 P_MEMHANDLE_SDU(prim)=0x00000000;
661 }
662 #endif
663
664 return (T_VOID_STRUCT*)P2D(prim);
665 }
666 return NULL;
667
668 }
669 #endif
670 #ifndef RUN_FLASH
671 /*
672 +--------------------------------------------------------------------+
673 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
674 | STATE : code ROUTINE : vsi_c_pnew |
675 +--------------------------------------------------------------------+
676
677 PURPOSE : allocate a partition to send a primitive
678
679 */
680
681 T_VOID_STRUCT * vsi_c_pnew (ULONG Size, ULONG opc FILE_LINE_TYPE)
682 {
683 T_HANDLE Caller;
684
685 Caller = 0;
686
687 Size += sizeof(T_PRIM_HEADER);
688
689 return ( (T_VOID_STRUCT*)vsi_c_pnew_generic ( Caller, Size, opc, PrimGroupHandle FILE_LINE ));
690 }
691 #endif
692
693 #ifndef RUN_FLASH
694 /*
695 +--------------------------------------------------------------------+
696 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
697 | STATE : code ROUTINE : vsi_c_pnew |
698 +--------------------------------------------------------------------+
699
700 PURPOSE : allocate a partition to send a primitive
701
702 */
703
704 T_VOID_STRUCT * vsi_c_pnew_nb (ULONG Size, ULONG opc FILE_LINE_TYPE)
705 {
706 T_HANDLE Caller;
707
708 Caller = 0;
709
710 Size += sizeof(T_PRIM_HEADER);
711
712 return ( (T_VOID_STRUCT*)vsi_c_pnew_generic ( Caller, Size, opc, VSI_MEM_NON_BLOCKING|PrimGroupHandle FILE_LINE ));
713 }
714 #endif
715
716 #ifndef RUN_FLASH
717 /*
718 +---------------------------------------------------------------------+
719 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
720 | STATE : code ROUTINE : vsi_c_new_sdu_generic|
721 +---------------------------------------------------------------------+
722
723 PURPOSE : allow pool selection and flags for blocking bahavior
724
725 */
726 T_VOID_STRUCT * vsi_c_new_sdu_generic (ULONG Size, ULONG opc, USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset, ULONG flags FILE_LINE_TYPE )
727 {
728 T_PRIM_HEADER *prim;
729 ULONG alloc_size;
730 T_HANDLE Caller;
731
732 Caller = 0;
733 alloc_size = Size + sizeof(T_PRIM_HEADER) + BYTELEN((SHORT)sdu_len + (SHORT)encode_offset);
734 if ( (prim = (T_PRIM_HEADER*)vsi_c_pnew_generic (Caller, alloc_size, opc, flags FILE_LINE)) != NULL )
735 {
736 D_SDU(prim) = (T_sdu*)(((char*)prim) + sdu_offset);
737 D_SDU_LEN(prim) = sdu_len;
738 D_SDU_OFF(prim) = encode_offset;
739 return ( (T_VOID_STRUCT*)prim );
740 }
741 else
742 {
743 return NULL;
744 }
745 }
746 #endif
747
748 #ifndef RUN_FLASH
749 /*
750 +--------------------------------------------------------------------+
751 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
752 | STATE : code ROUTINE : vsi_c_new_sdu |
753 +--------------------------------------------------------------------+
754
755 PURPOSE : wrapper for vsi_c_new to avoid code wasting macro
756
757 */
758 T_VOID_STRUCT * vsi_c_new_sdu (ULONG Size, ULONG opc, USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset FILE_LINE_TYPE )
759 {
760 ULONG flags;
761
762 flags = PrimGroupHandle;
763
764 return vsi_c_new_sdu_generic (Size, opc, sdu_len, sdu_offset, encode_offset, flags FILE_LINE);
765 }
766 #endif
767
768 #ifndef RUN_INT_RAM
769 /*
770 +--------------------------------------------------------------------+
771 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
772 | STATE : code ROUTINE : vsi_c_ppass |
773 +--------------------------------------------------------------------+
774
775 PURPOSE : pass a partition from one primitive to another
776
777 */
778 T_VOID_STRUCT * vsi_c_ppass (T_VOID_STRUCT *prim, ULONG opc FILE_LINE_TYPE )
779 {
780 T_VOID_STRUCT *ptr;
781 ULONG len;
782 T_HANDLE Caller;
783
784 Caller = e_running[os_MyHandle()];
785 if ( D_CNT(prim) > 1 )
786 {
787 /*
788 * This does not work for dynamic primitive containing pointers, PDUP needed !!!!
789 * The sdu pointer is currently not set correctly because it is never used !!!
790 */
791 len = D_LEN(prim);
792 ptr = vsi_c_pnew ( len, opc FILE_LINE );
793 memcpy ( ptr, prim, len - sizeof(T_PRIM_HEADER) );
794 #ifdef PRIM_AUTO_FREE
795 if ( !(pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE) )
796 #endif
797 vsi_c_pfree ( &prim FILE_LINE );
798 return ptr;
799 }
800 else
801 {
802 D_OPC(prim) = opc;
803 #ifdef PRIM_AUTO_FREE
804 if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE )
805 {
806 D_CNT(prim)++;
807 }
808 #endif
809 #ifdef MEMORY_SUPERVISION
810 vsi_ppm_reuse ( Caller, D2P(prim), file, line);
811 #endif
812 return prim;
813 }
814
815 }
816 #endif
817
818 #ifndef RUN_INT_RAM
819 /*
820 +--------------------------------------------------------------------+
821 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
822 | STATE : code ROUTINE : vsi_c_pstore |
823 +--------------------------------------------------------------------+
824
825 PURPOSE : store a partition (increment the reference counter)
826 consider PARTITION_AUTO_FREE
827
828 */
829 void vsi_c_pstore ( T_VOID_STRUCT *prim FILE_LINE_TYPE )
830 {
831 #ifdef PRIM_AUTO_FREE
832 T_PRIM_HEADER *ptr;
833 T_DP_HEADER *dp_hdr;
834 T_HANDLE Caller;
835
836 Caller = e_running[os_MyHandle()];
837 if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE )
838 {
839 ptr = D2P(prim);
840 /* take control -> enable entity to free the prim */
841 processed_prim[Caller] = NULL;
842 /* increment reference counter */
843 D_CNT(prim)++;
844 #ifdef MEMORY_SUPERVISION
845 vsi_ppm_store ( Caller, ptr, file, line );
846 #endif
847 if ( P_DPHO(ptr) != 0 )
848 {
849 dp_hdr = (T_DP_HEADER*)((ULONG*)ptr + ptr->dph_offset);
850 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
851 while ( (ptr = (T_PRIM_HEADER*)dp_hdr) != NULL )
852 {
853 #ifdef MEMORY_SUPERVISION
854 vsi_ppm_store ( Caller, ptr, file, line );
855 #endif
856 P_CNT(ptr)++;
857 if ( dp_hdr->magic_nr != GUARD_PATTERN )
858 {
859 vsi_o_assert ( Caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
860 "Magic number in dp_header destroyed (PSTORE) %s , opc: 0x%lx, partition 0x%lx",
861 pf_TaskTable[Caller].Name, ptr->opc, ptr );
862 }
863 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
864 }
865 }
866 }
867 #endif /* PRIM_AUTO_FREE */
868 }
869 #endif
870
871 #ifndef RUN_INT_RAM
872 /*
873 +--------------------------------------------------------------------+
874 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
875 | STATE : code ROUTINE : vsi_c_pattach |
876 +--------------------------------------------------------------------+
877
878 PURPOSE : call internal function to store a partition (increment the reference counter)
879
880 */
881 int vsi_c_pattach ( T_VOID_STRUCT *prim FILE_LINE_TYPE )
882 {
883 T_HANDLE Caller = 0;
884 LONG sts;
885 int ret;
886
887 sts = os_ObtainSemaphore (Caller, vsi_m_sem_handle, OS_SUSPEND);
888 if ( sts == OS_ERROR || sts == OS_TIMEOUT )
889 {
890 /* Semaphore invalid or overrun */
891 Caller = e_running[os_MyHandle()];
892 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
893 "Ref Cnt Semaphore overrun, entity %s", pf_TaskTable[Caller].Name );
894 }
895
896 ret=int_vsi_c_pattach(prim FILE_LINE_MACRO);
897
898 os_ReleaseSemaphore (Caller, vsi_m_sem_handle);
899
900 return ret;
901 }
902
903 /*
904 +--------------------------------------------------------------------+
905 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
906 | STATE : code ROUTINE : int_vsi_c_pattach |
907 +--------------------------------------------------------------------+
908
909 PURPOSE : actually store a partition (increment the reference counter)
910
911 */
912 int int_vsi_c_pattach ( T_VOID_STRUCT *prim FILE_LINE_TYPE)
913 {
914 T_PRIM_HEADER *ptr;
915 T_DP_HEADER *dp_hdr;
916 T_HANDLE Caller = 0;
917 int pos;
918
919 ptr = D2P(prim);
920
921 #ifdef NU_DEBUG
922 if ( os_is_valid_partition ((T_VOID_STRUCT*)ptr) )
923 {
924 /* attach to non-partition memory */
925 Caller = e_running[os_MyHandle()];
926 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
927 "PATTACH to non-partition memory, entity %s, ptr 0x%x", pf_TaskTable[Caller].Name, ptr );
928 }
929 #endif
930
931 if ( ptr->use_cnt <= 0 )
932 {
933 /* attach to non allocated memory */
934 Caller = e_running[os_MyHandle()];
935 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
936 "PATTACH to free memory, entity %s, ptr 0x%x", pf_TaskTable[Caller].Name, ptr );
937 }
938
939 dp_hdr=NULL;
940
941 /* check if we have a primitive pointer */
942 if ( ((T_DP_HEADER*)ptr)->magic_nr != GUARD_PATTERN )
943 {
944 /* increment reference counter */
945 P_CNT(ptr)++;
946 #ifdef MEMORY_SUPERVISION
947 vsi_ppm_store ( Caller, ptr, file, line );
948 #endif
949
950 /* look for dynamic partition header */
951 if ( P_DPHO(ptr) != 0 )
952 {
953 dp_hdr = (T_DP_HEADER*)((ULONG*)ptr + ptr->dph_offset);
954 if (dp_hdr->drp_bound_list)
955 {
956 /* call attach for bound root pointers */
957 pos=0;
958 while(pos<MAX_DRP_BOUND && dp_hdr->drp_bound_list[pos])
959 {
960 int_vsi_c_pattach(dp_hdr->drp_bound_list[pos] FILE_LINE_MACRO);
961 pos++;
962 }
963 }
964
965 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
966 }
967 }
968 else
969 {
970 dp_hdr=(T_DP_HEADER*)ptr;
971 }
972
973 if ( dp_hdr )
974 {
975 if ( dp_hdr->magic_nr != GUARD_PATTERN )
976 {
977 /* primitive with T_desc_list element, use MATTACH */
978 os_ReleaseSemaphore (Caller, vsi_m_sem_handle);
979 return VSI_OK;
980 }
981 else
982 {
983 while ( (ptr = (T_PRIM_HEADER*)dp_hdr) != NULL )
984 {
985 #ifdef MEMORY_SUPERVISION
986 vsi_ppm_store ( Caller, ptr, file, line );
987 #endif
988 P_CNT(ptr)++;
989 if ( dp_hdr->magic_nr != GUARD_PATTERN )
990 {
991 vsi_o_assert ( Caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
992 "Magic number in dp_header destroyed (PATTACH), %s, opc: 0x%lx, partition 0x%lx",
993 pf_TaskTable[Caller].Name, ptr->opc, ptr );
994 }
995
996 if (dp_hdr->drp_bound_list)
997 {
998 /* call attach for bound root pointers */
999 pos=0;
1000 while(pos<MAX_DRP_BOUND && dp_hdr->drp_bound_list[pos])
1001 {
1002 int_vsi_c_pattach(dp_hdr->drp_bound_list[pos] FILE_LINE_MACRO);
1003 pos++;
1004 }
1005 }
1006 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
1007 }
1008 }
1009 }
1010 return VSI_OK;
1011 }
1012 #endif
1013
1014 #ifndef RUN_INT_RAM
1015 /*
1016 +--------------------------------------------------------------------+
1017 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1018 | STATE : code ROUTINE : vsi_c_reuse |
1019 +--------------------------------------------------------------------+
1020
1021 PURPOSE : function to avoid code wasting macro
1022
1023 */
1024 T_VOID_STRUCT *vsi_c_reuse ( T_PRIM_HEADER *ptr, ULONG Size, ULONG opc,
1025 USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset FILE_LINE_TYPE )
1026 {
1027 T_HANDLE Caller;
1028
1029 D_OPC(ptr) = opc;
1030 D_LEN(ptr) = Size;
1031 if ( sdu_offset != NO_SDU )
1032 {
1033 D_SDU(ptr) = (T_sdu*)((char*)(ptr) + sdu_offset);
1034 D_SDU_LEN(ptr) = sdu_len;
1035 D_SDU_OFF(ptr) = encode_offset;
1036 }
1037 else
1038 D_SDU(ptr) = NULL;
1039
1040 Caller = e_running[os_MyHandle()];
1041 #ifdef MEMORY_SUPERVISION
1042 vsi_ppm_reuse ( Caller, D2P(ptr), file, line);
1043 #endif
1044 #ifdef PRIM_AUTO_FREE
1045 if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE )
1046 {
1047 D_CNT(ptr)++;
1048 }
1049 #endif
1050 return ( (T_VOID_STRUCT*)ptr );
1051 }
1052 #endif
1053
1054 #ifndef RUN_FLASH
1055 /*
1056 +--------------------------------------------------------------------+
1057 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1058 | STATE : code ROUTINE : vsi_c_free |
1059 +--------------------------------------------------------------------+
1060
1061 PURPOSE : deallocate a partition that was used to send a primitive
1062
1063 */
1064
1065 int vsi_c_free (T_HANDLE Caller, T_VOID_STRUCT **Msg FILE_LINE_TYPE)
1066 {
1067 static T_VOID_STRUCT *protected_prim_to_free = NULL;
1068 #if defined (NU_DEBUG) || defined (OSL_DEBUG)
1069 LONG count;
1070 #endif
1071
1072 //LONG sts;
1073
1074 #if 0
1075 sts = os_ObtainSemaphore (Caller, vsi_m_sem_handle, OS_SUSPEND);
1076 if ( sts == OS_ERROR || sts == OS_TIMEOUT )
1077 {
1078 /* Semaphore invalid or overrun */
1079 if ( *Msg == protected_prim_to_free )
1080 {
1081 /* fatal error only if semaphore overrun on same primitive */
1082 Caller = e_running[os_MyHandle()];
1083 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
1084 "Ref Cnt Semaphore overrun, entity %s", pf_TaskTable[Caller].Name );
1085 return VSI_ERROR;
1086 }
1087 }
1088 else
1089 #endif
1090 {
1091 protected_prim_to_free = *Msg;
1092 }
1093 #if defined (NU_DEBUG) || defined (OSL_DEBUG)
1094 count = (LONG)((T_PRIM_HEADER*)*Msg)->use_cnt;
1095 if ( count <= 0 )
1096 {
1097 pf_handle_warning ( OS_SYST_WRN_MULTIPLE_FREE, "%s %s in %s, 0x%x, %s(%d)",
1098 syst_wrn, freed_str, pf_TaskTable[Caller].Name, P_OPC(*Msg) FILE_LINE_MACRO_PASSED );
1099 protected_prim_to_free = NULL;
1100 // os_ReleaseSemaphore (Caller, vsi_m_sem_handle);
1101 return VSI_OK;
1102 }
1103 #endif
1104 if ( --((T_PRIM_HEADER*)*Msg)->use_cnt == 0 )
1105 {
1106 #ifdef PRIM_AUTO_FREE
1107 if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE )
1108 freed_prim[Caller] = *Msg;
1109 #endif
1110 #ifdef _NUCLEUS_
1111 #ifdef NU_DEBUG
1112
1113 if ( os_PartitionCheck( (ULONG*)*Msg ) == OS_PARTITION_GUARD_PATTERN_DESTROYED )
1114 {
1115 // os_ReleaseSemaphore (Caller, vsi_m_sem_handle);
1116 vsi_o_assert ( Caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED,
1117 "%s (PFREE), entity %s,Partition 0x%x",
1118 guard_str, pf_TaskTable[Caller].Name, *Msg );
1119 return VSI_ERROR;
1120 }
1121 #endif
1122 #endif
1123 protected_prim_to_free = NULL;
1124 // os_ReleaseSemaphore (Caller, vsi_m_sem_handle);
1125 return ( vsi_m_free ( Msg FILE_LINE ) );
1126 }
1127
1128 protected_prim_to_free = NULL;
1129 // os_ReleaseSemaphore (Caller, vsi_m_sem_handle);
1130 return VSI_OK;
1131 }
1132 #endif
1133
1134 #ifndef RUN_FLASH
1135 /*
1136 +--------------------------------------------------------------------+
1137 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1138 | STATE : code ROUTINE : vsi_c_pfree |
1139 +--------------------------------------------------------------------+
1140
1141 PURPOSE : deallocate a partition that was used to send a primitive
1142
1143 */
1144
1145 int vsi_c_pfree (T_VOID_STRUCT **Msg FILE_LINE_TYPE)
1146 {
1147 T_VOID_STRUCT *free_ptr;
1148 T_HANDLE Caller;
1149
1150 /*
1151 * PFREE is disabled if the primitive to be freed is the currently
1152 * processed one and the auto free is enabled for the calling entity
1153 */
1154
1155 Caller = e_running[os_MyHandle()];
1156 free_ptr = (T_VOID_STRUCT*)D2P(*Msg);
1157 #ifdef NU_DEBUG
1158 if ( os_is_valid_partition ((T_VOID_STRUCT*)free_ptr) )
1159 {
1160 /* free to non-partition memory */
1161 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
1162 "PFREE to non-partition memory, entity %s, prim 0x%x", pf_TaskTable[Caller].Name, *Msg );
1163 }
1164 #endif
1165 #ifdef PRIM_AUTO_FREE
1166 if ( free_ptr == processed_prim[Caller] && pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE )
1167 {
1168 return VSI_OK;
1169 }
1170 #endif /* PRIM_AUTO_FREE */
1171 return ( vsi_c_free ( Caller, &free_ptr FILE_LINE ) );
1172 }
1173 #endif
1174
1175 #ifndef RUN_FLASH
1176 /*
1177 +--------------------------------------------------------------------+
1178 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1179 | STATE : code ROUTINE : vsi_c_await |
1180 +--------------------------------------------------------------------+
1181
1182 PURPOSE : receive a primitive
1183
1184 */
1185
1186 int vsi_c_await (T_HANDLE Caller, T_HANDLE ComHandle, T_QMSG *Msg, ULONG Timeout)
1187 {
1188 OS_QDATA OS_Msg;
1189 LONG ret;
1190 OS_HANDLE q_handle;
1191
1192
1193 #ifdef _TOOLS_
1194 q_handle = ComHandle;
1195 #else
1196 q_handle = pf_TaskTable[ComHandle].QueueHandle;
1197 #endif
1198 e_running[os_MyHandle()] = 0;
1199
1200 if ( (ret = os_ReceiveFromQueue ( Caller, q_handle, &OS_Msg, Timeout)) == OS_OK )
1201 {
1202 Msg->MsgType = OS_Msg.data16;
1203 switch ( Msg->MsgType )
1204 {
1205 case MSG_PRIMITIVE:
1206 Msg->Msg.Primitive.Prim = OS_Msg.ptr;
1207 #ifdef _TOOLS_
1208 Msg->Msg.Primitive.PrimLen = OS_Msg.len;
1209 #endif
1210 vsi_o_ptrace (Caller, ((T_PRIM_HEADER*)Msg->Msg.Primitive.Prim)->opc, 0);
1211 break;
1212 case MSG_SIGNAL:
1213 Msg->Msg.Signal.SigBuffer = OS_Msg.ptr;
1214 Msg->Msg.Signal.SigOPC = OS_Msg.data32;
1215 #ifdef _TOOLS_
1216 Msg->Msg.Signal.SigLen = OS_Msg.len;
1217 #endif
1218 break;
1219 case MSG_TIMEOUT:
1220 if ( *(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) & TIMEOUT_OCCURRED )
1221 {
1222 if ( !(*(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) & PERIODIC_TIMER) )
1223 {
1224 os_DestroyTimer ( Caller, (OS_HANDLE)(*(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) & TIMER_HANDLE_MASK) );
1225 *(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) = 0;
1226 }
1227 else
1228 {
1229 *(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) &= ~TIMEOUT_OCCURRED;
1230 }
1231 Msg->Msg.Timer.Index = OS_Msg.data32;
1232 }
1233 break;
1234 default: return VSI_ERROR;
1235 /*lint -e527 suppress Warning -- Unreachable */
1236 break;
1237 /*lint +e527 */
1238 }
1239 e_running[os_MyHandle()] = Caller;
1240 prf_log_entity_activate ((void*)Caller);
1241 return VSI_OK;
1242 }
1243 else
1244 {
1245 if ( ret == OS_TIMEOUT )
1246 {
1247 e_running[os_MyHandle()] = Caller;
1248 return VSI_TIMEOUT;
1249 }
1250 }
1251 return VSI_ERROR;
1252 }
1253 #endif
1254
1255 #ifndef RUN_INT_RAM
1256 /*
1257 +--------------------------------------------------------------------+
1258 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1259 | STATE : code ROUTINE : vsi_c_primitive |
1260 +--------------------------------------------------------------------+
1261
1262 PURPOSE : send a non GSM primitive to the frame
1263
1264 */
1265
1266 int vsi_c_primitive (T_HANDLE Caller, void *Msg)
1267 {
1268 /*
1269 * the following line of code causes a warning on tms470 compiler, that cannot be avoided
1270 * without changing all entities PEI modules. Warning will not cause a problem
1271 */
1272 pf_ProcessSystemPrim ( Caller, Msg );
1273 return VSI_OK;
1274
1275 }
1276 #endif
1277
1278 #ifndef RUN_INT_RAM
1279 /*
1280 +--------------------------------------------------------------------+
1281 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1282 | STATE : code ROUTINE : vsi_c_awake |
1283 +--------------------------------------------------------------------+
1284
1285 PURPOSE : send NULL primitive to itself
1286
1287 */
1288 GLOBAL int vsi_c_awake ( T_HANDLE caller )
1289 {
1290 OS_QDATA QMsg = { 0 };
1291
1292 QMsg.data16 = MSG_PRIMITIVE;
1293 QMsg.ptr = NULL;
1294 os_SendToQueue ( caller, caller, OS_URGENT, OS_NO_SUSPEND, &QMsg );
1295 return VSI_OK;
1296 }
1297 #endif
1298
1299 #ifndef RUN_INT_RAM
1300 /*
1301 +--------------------------------------------------------------------+
1302 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1303 | STATE : code ROUTINE : vsi_c_status |
1304 +--------------------------------------------------------------------+
1305
1306 PURPOSE : allocate root of dynamic sized primitive
1307
1308 */
1309 int vsi_c_status (T_HANDLE handle, unsigned int *used, unsigned int *free)
1310 {
1311 #ifdef _NUCLEUS_
1312 int status;
1313
1314 if ( (status = os_GetQueueState (0, pf_TaskTable[handle].QueueHandle, (ULONG*)used, (ULONG*)free)) == OS_OK )
1315 return OS_OK;
1316 else
1317 #endif
1318 return OS_ERROR;
1319
1320 }
1321 #endif
1322
1323 #ifndef RUN_INT_RAM
1324 /*
1325 +--------------------------------------------------------------------+
1326 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1327 | STATE : code ROUTINE : vsi_drpo_new |
1328 +--------------------------------------------------------------------+
1329
1330 PURPOSE : allocate root of dynamic sized primitive
1331
1332 */
1333 GLOBAL T_VOID_STRUCT *vsi_drpo_new ( ULONG size, ULONG opc, ULONG guess FILE_LINE_TYPE )
1334 {
1335 T_PRIM_HEADER *prim;
1336 T_DP_HEADER *dp_hdr;
1337 T_S_HEADER *s_hdr;
1338 ULONG alloc_size;
1339 ULONG partition_size;
1340 ULONG header_size;
1341 T_HANDLE caller;
1342
1343 caller = e_running[os_MyHandle()];
1344
1345 header_size = sizeof(T_PRIM_HEADER) + sizeof(T_DP_HEADER);
1346
1347 if ( ALIGN(header_size + size) > MaxPrimPartSize )
1348 {
1349 os_GetTaskName ( caller, caller, TaskName );
1350 vsi_o_assert ( NO_TASK, OS_SYST_ERR_BIG_PARTITION FILE_LINE_MACRO_PASSED,
1351 "No Partition available, entity %s, size %d", pf_TaskTable[caller].Name, size );
1352 return NULL;
1353 }
1354
1355 if ( guess == DP_NO_FRAME_GUESS )
1356 alloc_size = ALIGN(header_size + size);
1357 else if ( guess == DP_FRAME_GUESS )
1358 alloc_size = ALIGN(header_size + size * 3);
1359 else
1360 alloc_size = ALIGN(header_size + guess + size);
1361
1362 if ( caller != 0 && caller == TST_Handle )
1363 {
1364 /*
1365 if called by PCON in the test interface while decoding we need to reserve
1366 space for the S_HEADER
1367 */
1368 alloc_size += sizeof(T_S_HEADER);
1369 }
1370
1371 if ( alloc_size > MaxPrimPartSize )
1372 {
1373 #ifdef NU_DEBUG
1374 pf_handle_warning ( OS_SYST_WRN_REQ_TRUNCATED, "%s %s (%d->%d), entity %s, opc 0x%x, %s(%d)",
1375 syst_wrn, trunc_str, alloc_size, MaxPrimPartSize, pf_TaskTable[caller].Name, opc FILE_LINE_MACRO_PASSED );
1376 #endif
1377 alloc_size = MaxPrimPartSize;
1378 }
1379 if ( ( prim = (T_PRIM_HEADER*)vsi_m_new_size ( alloc_size, PrimGroupHandle,
1380 &partition_size FILE_LINE ) ) != NULL )
1381 {
1382 #ifdef MEMORY_SUPERVISION
1383 vsi_ppm_new ( caller, alloc_size, (T_PRIM_HEADER*)prim, file, line );
1384 #endif
1385 prim->len = partition_size; /* complete partition because header is at the end */
1386 prim->opc = opc;
1387 prim->sdu = NULL;
1388 prim->use_cnt = 1;
1389 prim->sh_offset = 0;
1390 prim->dph_offset = D_HDR_OFFSET(partition_size);
1391 dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset);
1392 dp_hdr->magic_nr = GUARD_PATTERN;
1393 dp_hdr->drp_bound_list = NULL;
1394 dp_hdr->next = NULL;
1395 dp_hdr->offset = sizeof(T_PRIM_HEADER) + ALIGN(size);
1396 dp_hdr->size = partition_size - sizeof(T_DP_HEADER);
1397 if ( dp_hdr->offset > dp_hdr->size )
1398 {
1399 dp_hdr->offset = dp_hdr->size;
1400 }
1401 /*
1402 * The following code does not work since the 'caller' parameter has been removed from the function
1403 * prototype. The code was needed for the case where the function was called by PCON when decoding a
1404 * received primitive in the test interface. The caller in this case is 0 because it is either the
1405 * RCV_HISR on the target or the EXTR task in the simulation which is not running in the context of
1406 * the frame. Currently the sh_offset is set in the TIF driver tif.c although the guard pattern is not
1407 * set there. This is working fine so there is no reason to modify the code here. This comment
1408 * is just the result of some brainstorming and can be used for future modifications
1409 */
1410 if ( caller != 0 && caller == TST_Handle ) /* called by PCON */
1411 {
1412 prim->sh_offset = prim->dph_offset - sizeof(T_S_HEADER);
1413 dp_hdr->size = dp_hdr->size - sizeof(T_S_HEADER);
1414 s_hdr = (T_S_HEADER*)((ULONG*)prim + prim->sh_offset);
1415 s_hdr->magic_nr = GUARD_PATTERN;
1416 }
1417 else
1418 prim->sh_offset = 0;
1419 return ((T_VOID_STRUCT*)P2D(prim));
1420 }
1421 return NULL;
1422 }
1423 #endif
1424
1425 #ifndef RUN_INT_RAM
1426 /*
1427 +--------------------------------------------------------------------+
1428 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1429 | STATE : code ROUTINE : vsi_drpo_new_sdu |
1430 +--------------------------------------------------------------------+
1431
1432 PURPOSE : allocate dynamic sized partition root
1433
1434 */
1435
1436 T_VOID_STRUCT * vsi_drpo_new_sdu (ULONG Size, ULONG opc, USHORT sdu_len,
1437 USHORT sdu_offset, USHORT encode_offset, ULONG guess FILE_LINE_TYPE )
1438 {
1439 T_VOID_STRUCT *ptr;
1440 ULONG alloc_size;
1441 T_HANDLE Caller;
1442
1443 Caller = 0;
1444 alloc_size = Size + BYTELEN((SHORT)sdu_len + (SHORT)encode_offset);
1445 ptr = vsi_drpo_new ( alloc_size, opc, guess FILE_LINE );
1446 /*
1447 * the following line of code causes a warning on tms470 compiler,
1448 * that cannot be avoided. Warning will not cause a problem because due to the
1449 * arm7 alignment it is guaranteed that the sdu will start at an address divisable
1450 * by 4.
1451 */
1452 D_SDU(ptr) = (T_sdu*)((char*)ptr + sdu_offset);
1453 D_SDU_LEN(ptr) = sdu_len;
1454 D_SDU_OFF(ptr) = encode_offset;
1455
1456 return ( (T_VOID_STRUCT*)ptr );
1457 }
1458 #endif
1459
1460 #ifndef RUN_INT_RAM
1461 /*
1462 +--------------------------------------------------------------------+
1463 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1464 | STATE : code ROUTINE : vsi_drp_bind |
1465 +--------------------------------------------------------------------+
1466
1467 PURPOSE : bind child root pointer to a given parent root pointer
1468
1469 */
1470 GLOBAL int vsi_drp_bind (T_VOID_STRUCT *child, T_VOID_STRUCT *parent FILE_LINE_TYPE)
1471 {
1472 T_PRIM_HEADER *prim;
1473 T_DP_HEADER *dp_hdr;
1474 T_VOID_STRUCT **new_drp_bound_list;
1475 ULONG alloc_size;
1476 T_HANDLE caller;
1477 int pos;
1478
1479 caller = e_running[os_MyHandle()];
1480
1481 prim = D2P(parent);
1482 if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN )
1483 {
1484 dp_hdr = (T_DP_HEADER*)prim;
1485 }
1486 else
1487 {
1488 dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset);
1489 }
1490
1491 if (dp_hdr->drp_bound_list == NULL)
1492 {
1493 /* no partitions bound so far */
1494 alloc_size=MAX_DRP_BOUND*sizeof(T_DP_HEADER*);
1495 if ( ( new_drp_bound_list = (T_VOID_STRUCT**)M_ALLOC (alloc_size) ) == NULL )
1496 {
1497 /* no more memory */
1498 return VSI_ERROR;
1499 }
1500
1501 memset(new_drp_bound_list,0x00,alloc_size);
1502 dp_hdr->drp_bound_list=new_drp_bound_list;
1503 }
1504
1505 /* find free bind pointer */
1506 pos=0;
1507 while(pos<MAX_DRP_BOUND && dp_hdr->drp_bound_list[pos])
1508 {
1509 pos++;
1510 }
1511 if (pos == MAX_DRP_BOUND)
1512 {
1513 /* no more free bound pointers */
1514 return VSI_ERROR;
1515 }
1516
1517 /* actually bind */
1518 P_ATTACH(child);
1519 dp_hdr->drp_bound_list[pos]=child;
1520
1521 return VSI_OK;
1522 }
1523
1524 /*
1525 +--------------------------------------------------------------------+
1526 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1527 | STATE : code ROUTINE : vsi_dp_new |
1528 +--------------------------------------------------------------------+
1529
1530 PURPOSE : allocate dynamic sized partition root
1531
1532 */
1533 GLOBAL T_VOID_STRUCT *vsi_dp_new ( ULONG size, T_VOID_STRUCT *addr, ULONG guess FILE_LINE_TYPE )
1534 {
1535 T_PRIM_HEADER *prim;
1536 T_PRIM_HEADER *last_in_chain;
1537 T_PRIM_HEADER *dyn_ptr;
1538 T_DP_HEADER *dp_hdr;
1539 T_DP_HEADER *new_prim;
1540 T_VOID_STRUCT *ptr;
1541 ULONG partition_size;
1542 ULONG alloc_size;
1543 //ULONG estimated_size;
1544 T_HANDLE caller;
1545 char is_opc_root;
1546
1547 if ( size + sizeof(T_DP_HEADER) > MaxPrimPartSize )
1548 {
1549 caller = e_running[os_MyHandle()];
1550 vsi_o_assert ( NO_TASK, OS_SYST_ERR_BIG_PARTITION FILE_LINE_MACRO_PASSED,
1551 "No Partition available, entity %s, size %d", pf_TaskTable[caller].Name, size );
1552 return NULL;
1553 }
1554 prim = D2P(addr);
1555 dyn_ptr = prim;
1556 if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN )
1557 {
1558 dp_hdr = (T_DP_HEADER*)prim;
1559 is_opc_root = 0;
1560 }
1561 else
1562 {
1563 dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset);
1564 is_opc_root = 1;
1565 }
1566
1567 if ( guess == DP_NO_FRAME_GUESS )
1568 alloc_size = size + sizeof(T_DP_HEADER);
1569 else if ( guess == DP_FRAME_GUESS )
1570 alloc_size = size * 3 + sizeof(T_DP_HEADER);
1571 else
1572 alloc_size = size + guess + sizeof(T_DP_HEADER);
1573
1574 #if 0
1575 /*
1576 * update estimated size
1577 */
1578 estimated_size = dp_hdr->est_size;
1579
1580 if ( guess != DP_NO_FRAME_GUESS && guess != DP_FRAME_GUESS )
1581 {
1582 estimated_size = size + guess;
1583 alloc_size = estimated_size + sizeof(T_DP_HEADER);
1584 estimated_size -= size;
1585 }
1586 else
1587 {
1588 if ( size > estimated_size )
1589 {
1590 if ( guess == DP_FRAME_GUESS )
1591 estimated_size = size * 3;
1592 else
1593 estimated_size = size;
1594 }
1595 estimated_size -= size;
1596 if ( size > estimated_size )
1597 estimated_size = size * 2;
1598 alloc_size = estimated_size + sizeof(T_DP_HEADER);
1599 }
1600
1601 if ( estimated_size > MaxPrimPartSize )
1602 estimated_size = MaxPrimPartSize;
1603
1604 dp_hdr->est_size = estimated_size;
1605 #endif
1606 /*
1607 * check if free space in already allocated blocks (first fit)
1608 */
1609 do
1610 {
1611 if ( dp_hdr->magic_nr != GUARD_PATTERN )
1612 {
1613 caller = e_running[os_MyHandle()];
1614 vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
1615 "Magic number in dp_header destroyed (DP_ALLOC), %s opc: 0x%lx, partition 0x%lx",
1616 pf_TaskTable[caller].Name, ((T_PRIM_HEADER*)prim)->opc, prim );
1617 }
1618 if ( dp_hdr->size - dp_hdr->offset > size )
1619 {
1620 /*
1621 * if root was allocated with drpo_alloc then dp header is at the end,
1622 * the dph offset is not 0 and a primitive header is present.
1623 */
1624 if ( is_opc_root && dyn_ptr == prim )
1625 ptr = (T_VOID_STRUCT*)(((ULONG*)prim) + (dp_hdr->offset>>2));
1626 else
1627 ptr = (T_VOID_STRUCT*)(((ULONG*)dp_hdr) + (dp_hdr->offset>>2));
1628 dp_hdr->offset += ALIGN(size);
1629 return ( ptr );
1630 }
1631 if ( is_opc_root && dyn_ptr == prim )
1632 last_in_chain = prim;
1633 else
1634 last_in_chain = (T_PRIM_HEADER*)dp_hdr;
1635 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
1636 dyn_ptr = (T_PRIM_HEADER*)dp_hdr;
1637 } while ( dp_hdr );
1638
1639 /*
1640 * not enough free space -> additional allocation needed
1641 */
1642 if ( alloc_size > MaxPrimPartSize )
1643 {
1644 #ifdef NU_DEBUG
1645 caller = e_running[os_MyHandle()];
1646 pf_handle_warning ( OS_SYST_WRN_REQ_TRUNCATED, "%s %s (%d->%d), entity %s, %s(%d)",
1647 syst_wrn, trunc_str, alloc_size, MaxPrimPartSize, pf_TaskTable[caller].Name FILE_LINE_MACRO_PASSED );
1648 #endif
1649 alloc_size = MaxPrimPartSize;
1650 }
1651
1652 if ( ( new_prim = (T_DP_HEADER*)vsi_m_new_size ( alloc_size, PrimGroupHandle,
1653 &partition_size FILE_LINE ) ) != NULL )
1654 {
1655 #ifdef MEMORY_SUPERVISION
1656 caller = e_running[os_MyHandle()];
1657 vsi_ppm_new ( caller, alloc_size, (T_PRIM_HEADER*)new_prim, file, line );
1658 #endif
1659 if ( ((T_DP_HEADER*)last_in_chain)->magic_nr == GUARD_PATTERN )
1660 dp_hdr = (T_DP_HEADER*)last_in_chain;
1661 else
1662 dp_hdr = (T_DP_HEADER*)((ULONG*)last_in_chain + last_in_chain->dph_offset);
1663 dp_hdr->next = new_prim;
1664 new_prim->magic_nr = GUARD_PATTERN;
1665 new_prim->drp_bound_list = NULL;
1666 new_prim->use_cnt = 1;
1667 new_prim->next = NULL;
1668 new_prim->size = partition_size;
1669 new_prim->offset = sizeof(T_DP_HEADER) + ALIGN(size);
1670 if ( new_prim->offset > new_prim->size )
1671 {
1672 new_prim->offset = new_prim->size;
1673 }
1674 return (T_VOID_STRUCT*)(new_prim + 1);
1675 }
1676
1677 return NULL;
1678 }
1679 #endif
1680
1681 #ifndef RUN_INT_RAM
1682 /*
1683 +--------------------------------------------------------------------+
1684 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1685 | STATE : code ROUTINE : vsi_c_drp_new |
1686 +--------------------------------------------------------------------+
1687
1688 PURPOSE : allocate dynamic sized partition except root
1689
1690 */
1691 GLOBAL T_VOID_STRUCT *vsi_drp_new ( ULONG size, ULONG guess FILE_LINE_TYPE )
1692 {
1693 T_PRIM_HEADER *prim;
1694 T_DP_HEADER *dp_hdr;
1695 ULONG alloc_size;
1696 ULONG header_size;
1697 ULONG partition_size;
1698 T_HANDLE caller;
1699
1700 header_size = sizeof(T_DP_HEADER);
1701
1702 if ( ALIGN(header_size + size) > MaxPrimPartSize )
1703 {
1704 caller = e_running[os_MyHandle()];
1705 os_GetTaskName ( caller, caller, TaskName );
1706 vsi_o_assert ( NO_TASK, OS_SYST_ERR_BIG_PARTITION FILE_LINE_MACRO_PASSED,
1707 "No Partition available, entity %s, size %d", pf_TaskTable[caller].Name, size );
1708 return NULL;
1709 }
1710
1711 if ( guess == DP_NO_FRAME_GUESS )
1712 alloc_size = header_size + size;
1713 else if ( guess == DP_FRAME_GUESS )
1714 alloc_size = header_size + size * 3;
1715 else
1716 alloc_size = header_size + guess + size;
1717
1718 if ( alloc_size > MaxPrimPartSize )
1719 {
1720 #ifdef NU_DEBUG
1721 caller = e_running[os_MyHandle()];
1722 pf_handle_warning ( OS_SYST_WRN_REQ_TRUNCATED, "%s %s (%d->%d), entity %s, %s(%d)",
1723 syst_wrn, trunc_str, alloc_size, MaxPrimPartSize, pf_TaskTable[caller].Name FILE_LINE_MACRO_PASSED );
1724 #endif
1725 alloc_size = MaxPrimPartSize;
1726 }
1727
1728 if ( ( prim = (T_PRIM_HEADER*)vsi_m_new_size ( alloc_size, PrimGroupHandle,
1729 &partition_size FILE_LINE ) ) != NULL )
1730 {
1731 #ifdef MEMORY_SUPERVISION
1732 caller = e_running[os_MyHandle()];
1733 vsi_ppm_new ( caller, alloc_size, (T_PRIM_HEADER*)prim, file, line );
1734 #endif
1735 dp_hdr = (T_DP_HEADER*)prim;
1736 dp_hdr->next = NULL;
1737 dp_hdr->magic_nr = GUARD_PATTERN;
1738 dp_hdr->drp_bound_list = NULL;
1739 dp_hdr->use_cnt = 1;
1740 dp_hdr->offset = sizeof(T_DP_HEADER) + ALIGN(size);
1741 dp_hdr->size = partition_size;
1742 if ( dp_hdr->offset > dp_hdr->size )
1743 {
1744 dp_hdr->offset = dp_hdr->size;
1745 }
1746 return (T_VOID_STRUCT*)(dp_hdr+1);
1747 }
1748
1749 return NULL;
1750 }
1751 #endif
1752
1753 #ifndef RUN_INT_RAM
1754 /*
1755 +--------------------------------------------------------------------+
1756 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1757 | STATE : code ROUTINE : vsi_free |
1758 +--------------------------------------------------------------------+
1759
1760 PURPOSE : deallocate a chain of linked partitions
1761
1762 */
1763
1764 int vsi_free ( T_VOID_STRUCT **Msg FILE_LINE_TYPE )
1765 {
1766 T_PRIM_HEADER *prim;
1767 T_DP_HEADER *dp_hdr;
1768 T_VOID_STRUCT** drp_bound_list;
1769 T_HANDLE Caller = 0;
1770 int pos;
1771
1772 /*
1773 * PFREE is disabled if the primitive to be freed is the currently
1774 * processed one and the auto free is enabled for the calling entity
1775 */
1776
1777 Caller = e_running[os_MyHandle()];
1778
1779 prim = D2P(*Msg);
1780
1781 #ifdef NU_DEBUG
1782 if ( os_is_valid_partition ((T_VOID_STRUCT*)prim) )
1783 {
1784 /* free to non-partition memory */
1785 Caller = e_running[os_MyHandle()];
1786 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
1787 "FREE to non-partition memory, entity %s, prim 0x%x", pf_TaskTable[Caller].Name, *Msg );
1788 }
1789 #endif
1790
1791 #ifdef PRIM_AUTO_FREE
1792 if ( prim == (T_PRIM_HEADER*)processed_prim[Caller] && pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE )
1793 {
1794 return VSI_OK;
1795 }
1796 #endif /* PRIM_AUTO_FREE */
1797
1798 /* check if we have dynamic partition or primitive */
1799 if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN )
1800 {
1801 dp_hdr = (T_DP_HEADER*)prim;
1802 }
1803 else if ( prim->dph_offset != 0 )
1804 {
1805 dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset);
1806 }
1807 else
1808 {
1809 return ( vsi_c_free ( Caller, (T_VOID_STRUCT**)&prim FILE_LINE ) );
1810 }
1811
1812 if ( dp_hdr->magic_nr != GUARD_PATTERN )
1813 {
1814 /* primitive with T_desc_list element */
1815 vsi_c_free ( Caller, (T_VOID_STRUCT**)&prim FILE_LINE );
1816 return VSI_OK;
1817 }
1818 else
1819 {
1820 do
1821 {
1822 drp_bound_list=dp_hdr->drp_bound_list;
1823 if (drp_bound_list)
1824 {
1825 /* call free for bound root pointers */
1826 pos=0;
1827 while(pos<MAX_DRP_BOUND && drp_bound_list[pos])
1828 {
1829 FREE(drp_bound_list[pos]);
1830 pos++;
1831 }
1832 }
1833
1834 /* free linked memory */
1835 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
1836 vsi_c_free ( Caller, (T_VOID_STRUCT**)&prim FILE_LINE );
1837
1838 if (prim == NULL && drp_bound_list)
1839 {
1840 /* free drp_bound_list */
1841 M_FREE(drp_bound_list);
1842 }
1843 } while ( (prim = (T_PRIM_HEADER*)dp_hdr) != NULL );
1844 }
1845 return VSI_OK;
1846 }
1847 #endif
1848
1849 #ifndef RUN_INT_RAM
1850 /*
1851 +--------------------------------------------------------------------+
1852 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1853 | STATE : code ROUTINE : vsi_d_sum |
1854 +--------------------------------------------------------------------+
1855
1856 PURPOSE : get number of bytes in dynamic sized primitive
1857
1858 */
1859 GLOBAL int vsi_dp_sum ( T_VOID_STRUCT *addr, ULONG *bytes )
1860 {
1861 T_PRIM_HEADER *prim;
1862 T_DP_HEADER *dp_hdr;
1863 ULONG size;
1864 T_HANDLE caller;
1865
1866 prim = D2P(addr);
1867 if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN )
1868 dp_hdr = (T_DP_HEADER*)prim;
1869 else if ( prim->dph_offset != 0 )
1870 dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset);
1871 else
1872 {
1873 caller = e_running[os_MyHandle()];
1874 vsi_o_ttrace ( NO_TASK, TC_SYSTEM, "SYSTEM WARNING: No root of linked memory in %s",
1875 pf_TaskTable[caller].Name );
1876 return VSI_ERROR;
1877 }
1878
1879 size = 0;
1880 do
1881 {
1882 if ( dp_hdr->magic_nr != GUARD_PATTERN )
1883 {
1884 caller = e_running[os_MyHandle()];
1885 vsi_o_assert ( caller, OS_SYST_ERR, __FILE__, __LINE__,
1886 "Magic number in dp_header destroyed, opc: 0x%lx, partition 0x%lx",
1887 prim->opc, prim );
1888 }
1889 size += (dp_hdr->offset-sizeof(T_DP_HEADER));
1890 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
1891 } while ( (prim = (T_PRIM_HEADER*)dp_hdr) != NULL );
1892
1893 *bytes = size;
1894 return VSI_OK;
1895 }
1896 #endif
1897
1898 #ifndef RUN_INT_RAM
1899 /*
1900 +--------------------------------------------------------------------+
1901 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1902 | STATE : code ROUTINE : vsi_dp_max_size |
1903 +--------------------------------------------------------------------+
1904
1905 PURPOSE : get maximum number of bytes available for user data
1906 in dynamic primitive
1907
1908 */
1909 GLOBAL int vsi_dp_max_size ( void )
1910 {
1911 return ( (int)(MaxPrimPartSize - sizeof(T_PRIM_HEADER) - sizeof(T_DP_HEADER)) );
1912 }
1913 #endif
1914
1915
1916 #ifndef RUN_INT_RAM
1917 /*
1918 +--------------------------------------------------------------------+
1919 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1920 | STATE : code ROUTINE : vsi_c_pmax_size |
1921 +--------------------------------------------------------------------+
1922
1923 PURPOSE : get maximum number of bytes available for user data
1924 in dynamic primitive
1925
1926 */
1927 GLOBAL int vsi_c_pmax_size ( void )
1928 {
1929 return ( (int)(MaxPrimPartSize - sizeof(T_DP_HEADER)) );
1930 }
1931 #endif
1932
1933 #ifdef _TOOLS_
1934 /*
1935 +--------------------------------------------------------------------+
1936 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
1937 | STATE : code ROUTINE : vsi_c_sync |
1938 +--------------------------------------------------------------------+
1939
1940 PURPOSE : check if PS already started
1941
1942 */
1943 GLOBAL int vsi_c_sync ( T_HANDLE caller, T_TIME timeout )
1944 {
1945 T_VOID_STRUCT *prim;
1946 T_QMSG Msg;
1947 T_HANDLE tst_q_handle;
1948 char sync_req_name[RESOURCE_NAMELEN];
1949 char sync_req_time[8];
1950 static int sync_active = 0;
1951
1952
1953 if ( sync_active == FALSE )
1954 {
1955 sync_active = TRUE;
1956 os_GetTaskName(caller, caller, sync_req_name);
1957 itoa(timeout, sync_req_time,10);
1958
1959 prim = vsi_c_pnew ( sizeof(T_PRIM_HEADER)+strlen(SYSPRIM_CONFIG_TOKEN)+1
1960 +strlen(SYSPRIM_TST_SYNC_REQ)+1
1961 +strlen(sync_req_name)+1
1962 +strlen(sync_req_time)+1, 0x8000 FILE_LINE );
1963 strcpy ( (char*)prim, SYSPRIM_CONFIG_TOKEN );
1964 strcat ( (char*)prim, " " );
1965 strcat ( (char*)prim, SYSPRIM_TST_SYNC_REQ );
1966 strcat ( (char*)prim, " " );
1967 strcat ( (char*)prim, sync_req_name );
1968 strcat ( (char*)prim, " " );
1969 strcat ( (char*)prim, sync_req_time );
1970
1971 tst_q_handle = vsi_c_open ( caller, FRM_TST_NAME );
1972 vsi_c_psend ( tst_q_handle, prim );
1973
1974 if ( vsi_c_await ( caller, pf_TaskTable[caller].QueueHandle, &Msg, timeout ) == VSI_TIMEOUT )
1975 {
1976 vsi_o_ttrace (caller, TC_SYSTEM, "timeout - Synchronization with Stack failed" );
1977 sync_active = FALSE;
1978 return VSI_ERROR;
1979 }
1980 else
1981 {
1982 sync_active = FALSE;
1983 if ( strcmp ((char*)P2D(Msg.Msg.Primitive.Prim), SYSPRIM_TST_SYNC_CNF ) == 0 )
1984 {
1985 vsi_o_ttrace (caller, TC_SYSTEM, "TST_SYNC_CNF - Synchronization with Stack succeeded" );
1986 vsi_c_free (caller, &Msg.Msg.Primitive.Prim);
1987 return VSI_OK;
1988 }
1989 else
1990 {
1991 vsi_o_ttrace (caller, TC_SYSTEM, "TST_SYNC_REJ - Synchronization with Stack failed" );
1992 vsi_c_free (caller, &Msg.Msg.Primitive.Prim);
1993 return VSI_ERROR;
1994 }
1995 }
1996 }
1997 return VSI_OK;
1998 }
1999 #endif
2000
2001 #ifdef _TOOLS_
2002 /*
2003 +--------------------------------------------------------------------+
2004 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
2005 | STATE : code ROUTINE : vsi_c_generic_send |
2006 +--------------------------------------------------------------------+
2007
2008 PURPOSE : check if PS already started
2009
2010 */
2011 int vsi_c_alloc_send ( T_HANDLE com_handle, char* dst, char* src, void *prim, char *string )
2012 {
2013 int alloc_size;
2014 T_PRIM_HEADER *ptr;
2015 T_S_HEADER *s_hdr;
2016 unsigned int i;
2017 unsigned int size;
2018 int opc;
2019 int s_header_added = 0;
2020 int sh_offset;
2021
2022 if ( string != NULL )
2023 {
2024 size = strlen(string);
2025 alloc_size = size + sizeof(T_PRIM_HEADER);
2026 if ( dst != NULL || src != NULL )
2027 {
2028 sh_offset = ALIGN(alloc_size) / (int)sizeof(ULONG);
2029 alloc_size = ALIGN(alloc_size) + sizeof(T_S_HEADER);
2030 if ( dst != 0 )
2031 opc = 0; /* to stack -> set to SYS_MASK in tst_pei_primitive() when sh_offset != 0 */
2032 else
2033 opc = SYS_MASK; /* to tools */
2034 s_header_added = 1;
2035 }
2036 else
2037 {
2038 opc = SYS_MASK;
2039 sh_offset = 0;
2040 }
2041 ptr = (T_PRIM_HEADER*)vsi_c_new ( 0, alloc_size, opc );
2042 memcpy ( (char*)P2D(ptr), string, size );
2043 if ( s_header_added == 1 )
2044 {
2045 ptr->sh_offset = sh_offset;
2046 s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset);
2047 ptr->len = size + sizeof(T_PRIM_HEADER); /* exclude S_HEADER */
2048 }
2049 }
2050 else
2051 {
2052 ptr = D2P(prim); /* work on passed primitive */
2053 }
2054 if ( dst != NULL )
2055 {
2056 if ( s_header_added == 0 )
2057 {
2058 alloc_size = ALIGN(ptr->len) + sizeof(T_S_HEADER);
2059 ptr = (T_PRIM_HEADER*)vsi_c_new ( 0, alloc_size, 0 );
2060 memcpy((char*)ptr, (char*)D2P(prim), D_LEN(prim));
2061 ptr->sh_offset = ALIGN(D_LEN(prim)) / sizeof(ULONG);
2062 s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset);
2063 FREE(prim);
2064 }
2065 else
2066 {
2067 s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset);
2068 }
2069 /* set org_rcv and rcv */
2070 for (i = 0; dst[i] && i < sizeof (s_hdr->rcv) && dst[i]!= ';'; i++)
2071 s_hdr->org_rcv[i] = s_hdr->rcv[i] = dst[i];
2072 if (i < sizeof s_hdr->rcv)
2073 s_hdr->org_rcv[i] = s_hdr->rcv[i] = 0;
2074
2075 s_hdr->time = 0;
2076 s_header_added = 1;
2077 }
2078
2079 if ( src != NULL )
2080 {
2081 if ( s_header_added == 0 )
2082 {
2083 alloc_size = ALIGN(ptr->len) + sizeof(T_S_HEADER);
2084 ptr = (T_PRIM_HEADER*)vsi_c_new ( 0, alloc_size, 0 );
2085 memcpy((char*)ptr, (char*)D2P(prim), D_LEN(prim));
2086 ptr->sh_offset = ALIGN(D_LEN(prim)) / sizeof(ULONG);
2087 s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset);
2088 FREE(prim);
2089 }
2090 else
2091 {
2092 s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset);
2093 }
2094
2095 s_hdr->time = 0;
2096
2097 /* set snd */
2098 for (i = 0; src[i] && i < sizeof (s_hdr->snd) && src[i]!= ';'; i++)
2099 s_hdr->snd[i] = src[i];
2100 if (i < sizeof s_hdr->snd)
2101 s_hdr->snd[i] = 0;
2102 }
2103
2104 return ( vsi_c_psend (com_handle, (T_VOID_STRUCT*)P2D(ptr)) );
2105 }
2106 #endif
2107
2108 #ifdef NU_DEBUG
2109 #ifndef RUN_FLASH
2110 /*
2111 +----------------------------------------------------------------------+
2112 | PROJECT : GSM-Frame (8415) MODULE : VSI_COM |
2113 | STATE : code ROUTINE : check_descriptor_list |
2114 +----------------------------------------------------------------------+
2115
2116 PURPOSE : check partitions in descriptor list
2117
2118 */
2119 int check_descriptor_list ( T_HANDLE caller, T_PRIM_HEADER *prim FILE_LINE_TYPE )
2120 {
2121 T_DP_HEADER *dp_hdr;
2122 T_M_HEADER *mem;
2123 T_desc *desc;
2124 LONG Status;
2125
2126 dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset);
2127 /* the presence of the guard pattern at dph_offset is used to distinguish between dynamic primitives
2128 and primitives with descriptor list. If the guard pattern is destroyed, the primitive looks like
2129 having a descriptor list and the frame will probably crash during checking the integrity of the
2130 partitions in the list. This bahavior is prefered to non checking the partitions */
2131
2132 if ( *((ULONG*)dp_hdr) == GUARD_PATTERN )
2133 {
2134 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
2135 while (dp_hdr != NULL)
2136 {
2137 if ( dp_hdr->magic_nr != GUARD_PATTERN )
2138 {
2139 prim = (T_PRIM_HEADER*)dp_hdr;
2140 vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
2141 "Magic number in dp_header destroyed (PSEND) %s , opc: 0x%lx, partition 0x%lx",
2142 pf_TaskTable[caller].Name, prim->opc, prim );
2143 }
2144 if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)dp_hdr)) == OS_PARTITION_GUARD_PATTERN_DESTROYED )
2145 {
2146 vsi_o_assert ( caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED,
2147 "%s in dynamic primitive (PSEND),entity %s, prim 0x%x, opc 0x%x, bad partition 0x%x",
2148 guard_str, pf_TaskTable[caller].Name, prim, prim->opc, dp_hdr );
2149 break;
2150 }
2151 dp_hdr = (T_DP_HEADER*)dp_hdr->next;
2152 }
2153 }
2154 else
2155 {
2156 if ( caller != TST_Handle )
2157 {
2158 /* do not check and update the states of the primitives in descriptor lists when called by TST, because
2159 descriptor lists are not routed to TST and will result in the warning generated below */
2160 desc = (T_desc*)(((T_desc_list*)dp_hdr)->first);
2161 while (desc != NULL)
2162 {
2163 mem = (T_M_HEADER*)(((char*)desc)-sizeof(T_M_HEADER));
2164 if ( os_is_valid_partition ((T_VOID_STRUCT*)mem) )
2165 {
2166 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
2167 "pointer to non-partition memory in desc list(PSEND), entity %s, prim 0x%x, opc 0x%x",
2168 pf_TaskTable[caller].Name, prim, prim->opc );
2169 return VSI_ERROR;
2170 }
2171 if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)mem)) != OS_OK )
2172 {
2173 switch ( Status )
2174 {
2175 case OS_PARTITION_GUARD_PATTERN_DESTROYED:
2176 vsi_o_assert ( caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED,
2177 "%s in desclist (PSEND), entity %s, prim 0x%x, opc 0x%x, bad partition 0x%x",
2178 guard_str, pf_TaskTable[caller].Name, prim, prim->opc, mem );
2179 break;
2180 case OS_PARTITION_FREE:
2181 vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
2182 "%s in desclist (PSEND), entity %s, prim 0x%x, opc 0x%x, freed partition 0x%x",
2183 freed_sent_str, pf_TaskTable[caller].Name, prim, prim->opc, mem );
2184 break;
2185 default:
2186 break;
2187 }
2188 }
2189 if ( mem->desc_type == (VSI_DESC_TYPE3 >> 16) )
2190 {
2191 mem = ((T_M_HEADER*)(((T_desc3*)desc)->buffer)) - 1;
2192 if ( os_is_valid_partition ( (T_VOID_STRUCT*)mem ) )
2193 {
2194 vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
2195 "pointer to non-partition memory in desc list type 3 (PSEND), entity %s, prim 0x%x, opc 0x%x, invalid partition 0x%x",
2196 pf_TaskTable[caller].Name, prim, prim->opc, mem );
2197 return VSI_ERROR;
2198 }
2199 if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)mem )) != OS_OK )
2200 {
2201 switch ( Status )
2202 {
2203 case OS_PARTITION_GUARD_PATTERN_DESTROYED:
2204 vsi_o_assert ( caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED,
2205 "%s in desclist type 3 (PSEND), entity %s, prim 0x%x, opc 0x%x, bad partition 0x%x",
2206 guard_str, pf_TaskTable[caller].Name, prim, prim->opc, mem );
2207 break;
2208 case OS_PARTITION_FREE:
2209 vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED,
2210 "%s in desclist type 3 (PSEND), entity %s, prim 0x%x, opc 0x%x, freed partition 0x%x",
2211 freed_sent_str, pf_TaskTable[caller].Name, prim, prim->opc, mem );
2212 break;
2213 default:
2214 break;
2215 }
2216 }
2217 }
2218
2219 desc = (T_desc *)desc->next;
2220 }
2221 }
2222 }
2223 return VSI_OK;
2224 }
2225 #endif
2226 #endif
2227
2228 #if !defined _TARGET_ && !defined _TOOLS_
2229
2230 /* -------------------------------------------------------------------------
2231 check functions
2232 ----------------------------------------------------------------------------*/
2233
2234 #ifdef TEST_PCHECK
2235
2236 #ifndef RUN_INT_RAM
2237 ULONG test_pcheck ( ULONG opc, void * decoded_prim )
2238 {
2239 vsi_o_ttrace ( NO_TASK, TC_SYSTEM, "test_pcheck() called for opc %8x", D_OPC(decoded_prim) );
2240 return pcheck_func.ret_ok+1;
2241 }
2242 #endif
2243
2244 #endif /* TEST_PCHECK */
2245
2246 #ifndef RUN_INT_RAM
2247 /*
2248 +------------------------------------------------------------------------------
2249 | Function : pcheck_register
2250 +------------------------------------------------------------------------------
2251 | Description : register the pcheck function.
2252 |
2253 | Parameters : func - pointer to API function pointer table
2254 |
2255 | Return : void
2256 +------------------------------------------------------------------------------
2257 */
2258 void vsi_pcheck_register ( ULONG (*func)(ULONG, void*), ULONG ret_ok )
2259 {
2260 pcheck_func.ret_ok = ret_ok;
2261 pcheck_func.pcheck = func;
2262 pcheck_func.magic_nr = PCHECK_INITIALIZED;
2263 }
2264 #endif
2265
2266 #ifndef RUN_INT_RAM
2267 /*
2268 +------------------------------------------------------------------------------
2269 | Function : ext_trace_init
2270 +------------------------------------------------------------------------------
2271 | Description : initialize external trace function pointer table.
2272 |
2273 | Parameters : void
2274 |
2275 | Return : void
2276 +------------------------------------------------------------------------------
2277 */
2278 void vsi_pcheck_init ( void )
2279 {
2280 #ifdef TEST_PCHECK
2281 vsi_pcheck_register ( test_pcheck, 0 );
2282 #endif
2283 if ( pcheck_func.magic_nr != PCHECK_INITIALIZED )
2284 {
2285 pcheck_func.ret_ok = 0;
2286 pcheck_func.pcheck = NULL;
2287 pcheck_func.magic_nr = 0;
2288 }
2289 }
2290 #endif
2291
2292 #endif /* !_TARGET_ && !_TOOLS_*/
2293
2294
2295
2296