#define _POSIX_C_SOURCE 199309L
#endif
/* mt003.301 moved env files to use the __USE_UNIX98 flag in sys includes */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
#include <fcntl.h>
#include <pthread.h>
/* header include files (.h) */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system services */
-
-#include "cm5.h" /* common timers */
-
+#include "common_def.h"
#include "mt_ss.h" /* MTSS specific */
#include "mt_err.h" /* MTSS error defines */
/* mt003.301 Additions - Task deregistration */
#include "ss_err.h" /* error */
#include "cm_mem.h" /* common memory manager */
-#include "cm_lte.h" /* common lte param */
/* mt001.301 : Additions */
#ifdef SS_THREAD_PROFILE
#include "ss_err.h"
void *(*start_routine) (void *); /* function from which pthread starts */
}SPThreadCreateArg;
-PUBLIC void *pthreadCreateHdlr(void* arg);
+void *pthreadCreateHdlr(void* arg);
#ifdef SS_LOCKLESS_MEMORY
-PUBLIC Buffer *mtTskBuffer1;
-PUBLIC Buffer *mtTskBuffer2;
+Buffer *mtTskBuffer1;
+Buffer *mtTskBuffer2;
EXTERN pthread_t tmpRegTidMap[20];
EXTERN U8 stopBtInfo;
/* forward references */
/* mt003.301 Modifications - Moved to ss_gen.x */
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
-PUBLIC Void *mtTskHdlrT2kL2 ARGS((Void*));
-PUBLIC void mtSigSegvHndlr ARGS((void));
-PUBLIC void mtSigUsr2Hndlr ARGS((void));
+Void *mtTskHdlrT2kL2 ARGS((Void*));
+ void mtSigSegvHndlr ARGS((void));
+ void mtSigUsr2Hndlr ARGS((void));
#endif
PRIVATE S16 ssdSetPthreadAttr ARGS ((S32 tskPrior, pthread_attr_t *attr));
#endif /* SS_SEUM_CAVIUM */
#ifdef SS_THR_REG_MAP
-PUBLIC S32 ssCheckAndAddMemoryRegionMap ARGS((pthread_t threadId,
+S32 ssCheckAndAddMemoryRegionMap ARGS((pthread_t threadId,
Region region));
-PUBLIC S32 ssCheckAndDelMemoryRegionMap ARGS((pthread_t threadId));
+S32 ssCheckAndDelMemoryRegionMap ARGS((pthread_t threadId));
#endif /* SS_THR_REG_MAP */
\f
/* type declarations */
\f
/* public variable declarations */
-PUBLIC Cntr cfgNumRegs = SS_MAX_REGS;
+Cntr cfgNumRegs = SS_MAX_REGS;
/* Set memory configuration as false.
* Set to true if memory configuration through file is successfull.
*/
-PUBLIC Bool memConfigured = FALSE;
+Bool memConfigured = FALSE;
/* mt022.201 - Modification for shared memory relay region and memcal tool */
-PUBLIC SsRegCfg cfgRegInfo[SS_MAX_REGS] =
+SsRegCfg cfgRegInfo[SS_MAX_REGS] =
{
{
SS_DFLT_REGION, SS_MAX_POOLS_PER_REG - 1,
*/
#ifdef SS_LOCKLESS_MEMORY
-PUBLIC MtDynMemCfg mtDynMemoCfg =
+MtDynMemCfg mtDynMemoCfg =
{
SS_MAX_REGS, /* number of regions */
{
};
-PUBLIC MtGlobMemCfg mtGlobMemoCfg =
+MtGlobMemCfg mtGlobMemoCfg =
{
MT_MAX_BKTS, /* number of buckets */
{
/* mt022.201 - Modification for memory calculator tool */
/* mt018.201 - added memory configuration matrix */
-PUBLIC MtMemCfg mtMemoCfg =
+MtMemCfg mtMemoCfg =
{
#ifdef RY_ENBS5SHM
SS_MAX_REGS - 1, /* number of regions */
* bucket info, as different regions may request for different no.
* of blocks
*/
-PUBLIC MtBktCfg mtBktInfo[MT_MAX_BKTS];
-PUBLIC S16 msArgc; /* argc */
-PUBLIC Txt **msArgv; /* argv */
-PUBLIC S16 msOptInd; /* SGetOpt vars */
-PUBLIC S8 *msOptArg; /* SGetOpt vars */
+MtBktCfg mtBktInfo[MT_MAX_BKTS];
+S16 msArgc; /* argc */
+Txt **msArgv; /* argv */
+S16 msOptInd; /* SGetOpt vars */
+S8 *msOptArg; /* SGetOpt vars */
#ifdef INTEL_WLS
*
*/
#ifdef ANSI
-PUBLIC int main
+int main
(
int argc, /* argument count */
char **argv /* argument vector */
)
#else
-PUBLIC int main(argc, argv)
+int main(argc, argv)
int argc; /* argument count */
char **argv; /* argument vector */
#endif
{
- TRC0(main);
#ifdef XEON_MULTIPLE_CELL_CHANGES
/* Read the WLS parameters from the file and copy into global control block */
*
*/
#ifdef ANSI
-PUBLIC int ssMain
+int ssMain
(
int argc, /* argument count */
char **argv /* argument vector */
)
#else
-PUBLIC int ssMain(argc, argv)
+int ssMain(argc, argv)
int argc; /* argument count */
char **argv; /* argument vector */
#endif
{
- TRC0(ssMain);
msArgc = argc;
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitGen
+S16 ssdInitGen
(
void
)
#else
-PUBLIC S16 ssdInitGen()
+S16 ssdInitGen()
#endif
{
struct sigaction act;
struct sigaction sa;
#endif
- TRC0(ssdInitGen);
/*mt014.301 : 4GMX release related changes*/
#ifdef SS_4GMX_UCORE
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitGen
+Void ssdDeinitGen
(
void
)
#else
-PUBLIC Void ssdDeinitGen()
+Void ssdDeinitGen()
#endif
{
- TRC0(ssdDeinitGen);
sem_destroy(&osCp.dep.ssStarted);
*
*/
#ifdef ANSI
-PUBLIC S16 ssPutDynMemBlkSet
+S16 ssPutDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem /* Memory set element which is needs to be
added to global region */
)
#else
-PUBLIC S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is needs to be
added to global region */
*
*/
#ifdef ANSI
-PUBLIC S16 ssGetDynMemBlkSet
+S16 ssGetDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem /* Memory set element which is updated
with new set values */
)
#else
-PUBLIC S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is updated
with new set values */
*
*/
#ifdef ANSI
-PUBLIC S16 ssPutDynMemBlkSet
+S16 ssPutDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem, /* Memory set element which is needs to be
U32 doNotBlockForLock /* Boolean whether to block for lock or not */
)
#else
-PUBLIC S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is needs to be
added to global region */
CmMmBlkSetElement *globMemNode;
S16 lockRet = 0;
- TRC1(ssPutDynMemBlkSet);
globReg = osCp.globRegCb;
*
*/
#ifdef ANSI
-PUBLIC S16 ssGetDynMemBlkSet
+S16 ssGetDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem, /* Memory set element which is updated
U32 doNotBlockForLock /* Boolean whether to block for lock or not */
)
#else
-PUBLIC S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is updated
with new set values */
CmMmBlkSetElement *globMemNode;
S16 lockRet = 0;
- TRC1(ssGetDynMemBlkSet);
globReg = osCp.globRegCb;
PRIVATE U32 memoryCheckCounter;
#ifdef ANSI
-PUBLIC U32 isMemThreshReached(
+U32 isMemThreshReached(
Region reg
)
#else
-PUBLIC U32 isMemThreshReached(reg)
+U32 isMemThreshReached(reg)
Region reg;
#endif
{
CmMmGlobRegCb *globReg;
CmMmGlobalBktCb *bktCb;
U8 bktIdx= reg;
- TRC3(isMemThreshReached)
globReg = osCp.globRegCb;
*
*/
#ifdef ANSI
-PUBLIC Void * ssGetIccHdl
+Void * ssGetIccHdl
(
Region region
)
#else
-PUBLIC Void * ssGetIccHdl()
+Void * ssGetIccHdl()
Region region;
#endif
{
#ifdef INTEL_WLS
-PUBLIC S16 SPartitionWlsMemory()
+S16 SPartitionWlsMemory()
{
U32 i;
#ifndef ALIGN_64BIT
}
#ifdef SS_MEM_WL_DEBUG
-PUBLIC Void SChkAddrValid(int type, int region, PTR ptr)
+Void SChkAddrValid(int type, int region, PTR ptr)
{
char *tryPtr = NULL;
if(type == 0) //Global
}
#endif /* SS_MEM_WL_DEBUG */
-PUBLIC S16 SPartitionStaticMemory(U8 *startAddr)
+S16 SPartitionStaticMemory(U8 *startAddr)
{
int i;
U32 reqdSz;
}
return ROK;
}
-PUBLIC S16 SAllocateWlsMem()
+S16 SAllocateWlsMem()
{
U32 reqdMemSz;
SPartitionWlsMemory();
return ROK;
}
-PUBLIC S16 SAllocateStaticMem()
+S16 SAllocateStaticMem()
{
U32 reqdMemSz;
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitMem
+S16 ssdInitMem
(
void
)
#else
-PUBLIC S16 ssdInitMem()
+S16 ssdInitMem()
#endif
{
/* mt018.201 - added local variable */
#endif
#endif /* SS_LOCKLESS_MEMORY */
- TRC0(ssdInitMem);
/* Use the default SSI memory manager if the ICC memory manager is not
* avilable. If ICC memory manager is avilable, it will be used for
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitMem
+Void ssdDeinitMem
(
void
)
#else
-PUBLIC Void ssdDeinitMem()
+Void ssdDeinitMem()
#endif
{
/* mt018.201 - added local variables */
U8 i;
- TRC0(ssdDeinitMem);
/* mt008.301 Additions */
#ifdef SS_MEM_LEAK_STS
cmDeinitMemLeakMdl();
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitTsk
+S16 ssdInitTsk
(
void
)
#else
-PUBLIC S16 ssdInitTsk()
+S16 ssdInitTsk()
#endif
{
/* mt001.301 : Additions */
U32 tskInd = 0;
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
- TRC0(ssdInitTsk);
/*mt013.301 :Added SS_AFFINITY_SUPPORT */
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitTsk
+Void ssdDeinitTsk
(
void
)
#else
-PUBLIC Void ssdDeinitTsk()
+Void ssdDeinitTsk()
#endif
{
- TRC0(ssdDeinitTsk);
RETVOID;
}
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitDrvr
+S16 ssdInitDrvr
(
void
)
#else
-PUBLIC S16 ssdInitDrvr()
+S16 ssdInitDrvr()
#endif
{
S16 i;
pthread_attr_t attr;
#endif
- TRC0(ssdInitDrvr);
/* initialize the dependent portion of the driver task entries */
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitDrvr
+Void ssdDeinitDrvr
(
void
)
#else
-PUBLIC Void ssdDeinitDrvr()
+Void ssdDeinitDrvr()
#endif
{
- TRC0(ssdDeinitDrvr);
/* mt008.301: Terminate the Driver Task on exit */
while(pthread_cancel(osCp.dep.isTskHdlrTID));
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitTmr
+S16 ssdInitTmr
(
void
)
#else
-PUBLIC S16 ssdInitTmr()
+S16 ssdInitTmr()
#endif
{
pthread_attr_t attr;
U32 threadCreated = FALSE;
#endif /* SS_THR_REG_MAP */
- TRC0(ssdInitTmr);
osCp.dep.tmrTqCp.tmrLen = SS_MAX_TMRS;
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitTmr
+Void ssdDeinitTmr
(
void
)
#else
-PUBLIC Void ssdDeinitTmr()
+Void ssdDeinitTmr()
#endif
{
#ifdef SS_MULTICORE_SUPPORT
S16 ret;
#endif /* SS_MULTICORE_SUPPORT */
- TRC0(ssdDeinitTmr);
#ifdef SS_MULTICORE_SUPPORT
ret = SLock(&osCp.sTskTblLock);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitLog
+S16 ssdInitLog
(
void
)
#else
-PUBLIC S16 ssdInitLog()
+S16 ssdInitLog()
#endif
{
/* mt027.201 - Modification to fix warnings with no STDIN and STDOUT */
#endif /* CONAVL */
/* mt008.301: ssdInitFinal changed to ssdInitLog */
- TRC0(ssdInitLog);
#ifdef CONAVL
*/
/* mt008.301: ssdDeinitFinal changed to ssdDeinitLog */
#ifdef ANSI
-PUBLIC Void ssdDeinitLog
+Void ssdDeinitLog
(
void
)
#else
-PUBLIC Void ssdDeinitLog()
+Void ssdDeinitLog()
#endif
{
/* mt008.301: ssdDeinitFinal changed to ssdDeinitLog */
- TRC0(ssdDeinitLog);
#ifdef CONAVL
#ifndef CONRD
/* mt008.301: Terminate the console reader on exit */
#ifdef ANSI
-PUBLIC S16 ssdInitWatchDog
+S16 ssdInitWatchDog
(
U16 port
)
#else
-PUBLIC S16 ssdInitWatchDog(port)
+S16 ssdInitWatchDog(port)
U16 port;
#endif
{
}
#endif /* SS_MULTIPLE_PROCS */
- TRC0(ssdInitWatchDog);
SInitLock(&osCp.wdCp.wdLock, SS_LOCK_MUTEX);
}
#ifdef ANSI
-PUBLIC S16 ssdInitWatchDgPst
+S16 ssdInitWatchDgPst
(
Pst *pst
)
#else
-PUBLIC S16 ssdInitWatchDgPst(pst)
+S16 ssdInitWatchDgPst(pst)
Pst *pst;
#endif
{
- TRC1(ssInitWatchDgPst);
pst->selector = SS_LOOSE_COUPLING;
#ifdef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 ssdWatchDgActvTmr
+S16 ssdWatchDgActvTmr
(
ProcId proc,
Ent ent,
Inst inst
)
#else
-PUBLIC S16 ssdWatchDgActvTmr(proc, ent, inst)
+S16 ssdWatchDgActvTmr(proc, ent, inst)
#endif
#else
#ifdef ANSI
-PUBLIC S16 ssdWatchDgActvTmr
+S16 ssdWatchDgActvTmr
(
Void
)
#else
-PUBLIC S16 ssdWatchDgActvTmr()
+S16 ssdWatchDgActvTmr()
#endif
#endif /* SS_MULTIPLE_PROCS */
{
- TRC3(ssWatchDgActvTmr);
cmPrcTmr(&osCp.wdCp.watchDgTqCp, osCp.wdCp.watchDgTs, (PFV)ssdWatchDgTmrEvt);
}
#ifdef ANSI
-PUBLIC Void ssdWatchDgTmrEvt
+Void ssdWatchDgTmrEvt
(
PTR cb, /* control block */
S16 event /* timer number */
)
#else
-PUBLIC Void ssdWatchDgTmrEvt(cb, event)
+Void ssdWatchDgTmrEvt(cb, event)
PTR cb; /* control block */
S16 event; /* timer number */
#endif
Bool restartTmr;
int i;
- TRC2(ssWatchDgTmrEvt);
switch(event)
{
}
#ifdef ANSI
-PUBLIC Void ssdStartWatchDgTmr
+Void ssdStartWatchDgTmr
(
void *cb,
S16 event,
U16 wait
)
#else
-PUBLIC Void ssdStartWatchDgTmr(cb, event, wait)
+Void ssdStartWatchDgTmr(cb, event, wait)
void *cb;
S16 event;
U16 wait;
#endif
- TRC2(ssStartWatchDgTmr)
/* mt003.301 Modifications */
#ifdef DEBUGP
SGetDateTime(&dt);
}
#ifdef ANSI
-PUBLIC Void ssdStopWatchDgTmr
+Void ssdStopWatchDgTmr
(
void *cb,
S16 event
)
#else
-PUBLIC Void ssdStopWatchDgTmr(cb, event)
+Void ssdStopWatchDgTmr(cb, event)
void *cb;
S16 event;
#endif
int i;
#endif
- TRC2(ssStopWatchDgTmr)
/* mt003.301 Modifications */
#ifdef DEBUGP
SGetDateTime(&dt);
}
#ifdef ANSI
-PUBLIC S16 ssdSndHrtBtMsg
+S16 ssdSndHrtBtMsg
(
Bool restart,
U32 type
)
#else
-PUBLIC S16 ssdSndHrtBtMsg(restart, type)
+S16 ssdSndHrtBtMsg(restart, type)
Bool restart;
U32 type;
#endif
int n;
int err;
- TRC2(ssdSndHrtBtReq)
#ifdef DEBUGP
SGetDateTime(&dt);
Cntr idx=0;
#endif
- TRC0(mtGetOpts);
msOptInd = 1;
*
*/
#ifdef ANSI
-PUBLIC S16 SGetOpt
+S16 SGetOpt
(
int argc, /* argument count */
char **argv, /* argument value */
char *opts /* options */
)
#else
-PUBLIC S16 SGetOpt(argc, argv, opts)
+S16 SGetOpt(argc, argv, opts)
int argc; /* argument count */
char **argv; /* argument value */
char *opts; /* options */
S8 *cp;
#endif
- TRC1(SGetOpt);
/* mt020.201 - Addition for no command line */
#ifdef NOCMDLINE
*
*/
#ifdef ANSI
-PUBLIC Void ssdStart
+Void ssdStart
(
void
)
#else
-PUBLIC Void ssdStart()
+Void ssdStart()
#endif
{
S16 i;
- TRC0(ssdStart);
/* mt025.201 - Modification for adding lock to timer handler */
*
*/
#ifdef ANSI
-PUBLIC S16 ssdAttachTTsk
+S16 ssdAttachTTsk
(
SsTTskEntry *tTsk /* pointer to TAPA task entry */
)
#else
-PUBLIC S16 ssdAttachTTsk(tTsk)
+S16 ssdAttachTTsk(tTsk)
SsTTskEntry *tTsk; /* pointer to TAPA task entry */
#endif
{
SsMsgInfo *mInfo;
S16 ret;
-
- TRC0(ssdAttachTTsk);
-
-
if (tTsk->tskType == SS_TSK_PERMANENT)
{
/* Send a permanent tick message to this task, to start
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDetachTTsk
+S16 ssdDetachTTsk
(
SsTTskEntry *tTsk /* pointer to TAPA task entry */
)
#else
-PUBLIC S16 ssdDetachTTsk(tTsk)
+S16 ssdDetachTTsk(tTsk)
SsTTskEntry *tTsk; /* pointer to TAPA task entry */
#endif
{
- TRC0(ssdDetachTTsk);
-
return ROK;
}
*
*/
#ifdef ANSI
-PUBLIC S16 ssdCreateSTsk
+S16 ssdCreateSTsk
(
SsSTskEntry *sTsk /* pointer to system task entry */
)
#else
-PUBLIC S16 ssdCreateSTsk(sTsk)
+S16 ssdCreateSTsk(sTsk)
SsSTskEntry *sTsk; /* pointer to system task entry */
#endif
{
+ S16 ret;
pthread_attr_t attr;
/* struct sched_param param_sched;*/
U32 threadCreated = FALSE;
#endif
- TRC0(ssdCreateSTsk);
#ifdef SS_SINGLE_THREADED
while(threadCreated == FALSE)
{
#endif
- if ((pthread_create(&sTsk->dep.tId, &attr, mtTskHdlrT2kL2, (Ptr)sTsk)) != 0)
+ ret = pthread_create(&sTsk->dep.tId, &attr, mtTskHdlr, (Ptr)sTsk);
+ if (ret != 0)
{
-
+ DU_LOG("\nDU APP : Failed to create thread. Cause[%d]",ret);
pthread_attr_destroy(&attr);
#if (ERRCLASS & ERRCLS_DEBUG)
while(threadCreated == FALSE)
{
#endif
- if ((pthread_create(&sTsk->dep.tId, &attr, mtTskHdlr, (Ptr)sTsk)) != 0)
+ ret = pthread_create(&sTsk->dep.tId, &attr, mtTskHdlr, (Ptr)sTsk);
+ if (ret != 0)
{
/* mt020.201 - Addition for destroying thread attribute object attr */
#ifdef ANSI
-PUBLIC int SCreatePThread
+int SCreatePThread
(
pthread_t* tid,
pthread_attr_t* attr,
void* arg
)
#else
-PUBLIC int SCreatePThread(tid, attr, start_routine, arg)
+int SCreatePThread(tid, attr, start_routine, arg)
pthread_t* tid;
pthread_attr_t* attr;
void *(*start_routine) (void *);
threadArg->argument = arg;
threadArg->start_routine = start_routine;
- TRC0(SCreatePThread);
printf("Creating thread here %s %d\n", __FILE__, __LINE__);
{
{
struct sched_param param;
- TRC0 (ssdSetPthreadAttr)
SMemSet(¶m, 0, sizeof(param));
*
*/
#ifdef ANSI
-PUBLIC S16 ssdGetAffinity
+S16 ssdGetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
U32 *coreId /* the core/processor id to which the affinity is set */
)
#else
-PUBLIC S16 ssdGetAffinity(tskId, coreId)
+S16 ssdGetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
U32 *coreId; /* the core/processor id to which the affinity is set */
#endif
U32 lwpId = *tskId;
#endif /*SUNOS*/
#endif /*SS_LINUX*/
- TRC0(ssdGetAffinity);
#ifdef SS_LINUX
for (tskInd = 0; tskInd < SS_MAX_STSKS; tskInd++)
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdSetAffinity
+S16 ssdSetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
U32 coreId /* the core/processor id to which the affinity has to be set */
)
#else
-PUBLIC S16 ssdSetAffinity(tskId, coreId)
+S16 ssdSetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
U32 coreId; /* the core/processor id to which the affinity has to be set */
#endif
#endif /*SUNOS*/
#endif /*SS_LINUX*/
- TRC0(ssdSetAffinity)
#ifdef SS_LINUX
for (tskInd = 0; tskInd < SS_MAX_STSKS; tskInd++)
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDestroySTsk
+S16 ssdDestroySTsk
(
SsSTskEntry *sTsk /* pointer to system task entry */
)
#else
-PUBLIC S16 ssdDestroySTsk(sTsk)
+S16 ssdDestroySTsk(sTsk)
SsSTskEntry *sTsk; /* pointer to system task entry */
#endif
{
SsMsgInfo *mInfo;
- TRC0(ssdDestroySTsk);
/* we send a message to this system task to tell it to die */
*
*/
#ifdef ANSI
-PUBLIC S16 SThreadYield
+S16 SThreadYield
(
void
)
#else
-PUBLIC S16 SThreadYield()
+S16 SThreadYield()
#endif
{
- TRC0(SThreadYield);
/* mt024.201 - seperated Linux and other UNIX implementations
*/
*
*/
#ifdef ANSI
-PUBLIC S16 ssdRegTmr
+S16 ssdRegTmr
(
SsTmrEntry *tmr /* pointer to timer entry */
)
#else
-PUBLIC S16 ssdRegTmr(tmr)
+S16 ssdRegTmr(tmr)
SsTmrEntry *tmr; /* pointer to timer entry */
#endif
{
CmTmrArg arg;
- TRC0(ssdRegTmr);
/* initialize common timers */
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDeregTmr
+S16 ssdDeregTmr
(
SsTmrEntry *tmr /* pointer to timer entry */
)
#else
-PUBLIC S16 ssdDeregTmr(tmr)
+S16 ssdDeregTmr(tmr)
SsTmrEntry *tmr; /* pointer to timer entry */
#endif
{
CmTmrArg arg;
- TRC0(ssdDeregTmr);
/* stop the timer */
*
*/
#ifdef ANSI
-PUBLIC S16 ssdError
+S16 ssdError
(
Seq seq, /* sequence number */
Reason reason /* reset reason */
)
#else
-PUBLIC S16 ssdError(seq, reason)
+S16 ssdError(seq, reason)
Seq seq; /* sequence number */
Reason reason; /* reset reason */
#endif
Txt errBuf[256];
- TRC0(ssdError);
/* get calling task ID */
*
*/
#ifdef ANSI
-PUBLIC Void ssdLogError
+Void ssdLogError
(
Ent ent, /* Calling layer's entity id */
Inst inst, /* Calling layer's instance id */
Txt *errDesc /* description of error */
)
#else
-PUBLIC Void ssdLogError(ent, inst, procId, file, line,
+Void ssdLogError(ent, inst, procId, file, line,
errCls, errCode, errVal, errDesc)
Ent ent; /* Calling layer's entity id */
Inst inst; /* Calling layer's instance id */
Txt errBuf[512];
- TRC0(ssdLogError);
/* get calling task ID */
*
*/
#ifdef ANSI
-PUBLIC S16 ssdRegDrvrTsk
+S16 ssdRegDrvrTsk
(
SsDrvrTskEntry *drvrTsk /* driver task entry */
)
#else
-PUBLIC S16 ssdRegDrvrTsk(drvrTsk)
+S16 ssdRegDrvrTsk(drvrTsk)
SsDrvrTskEntry *drvrTsk; /* driver task entry */
#endif
{
- TRC0(ssdRegDrvrTsk);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDeregDrvrTsk
+S16 ssdDeregDrvrTsk
(
SsDrvrTskEntry *drvrTsk /* driver task entry */
)
#else
-PUBLIC S16 ssdDeregDrvrTsk(drvrTsk)
+S16 ssdDeregDrvrTsk(drvrTsk)
SsDrvrTskEntry *drvrTsk; /* driver task entry */
#endif
{
- TRC0(ssdDeregDrvrTsk);
return ROK;
*/
#ifdef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 ssdProcTTskTerm
+S16 ssdProcTTskTerm
(
ProcId procIdx,
SsTTskEntry *tTsk,
SsIdx idx
)
#else
-PUBLIC S16 ssdProcTTskTerm(procIdx, tTsk, idx)
+S16 ssdProcTTskTerm(procIdx, tTsk, idx)
ProcId procIdx;
SsTTskEntry *tTsk;
SsIdx idx;
#endif
#else /*SS_MULTIPLE_PROCS*/
#ifdef ANSI
-PUBLIC S16 ssdProcTTskTerm
+S16 ssdProcTTskTerm
(
SsTTskEntry *tTsk,
SsIdx idx
)
#else
-PUBLIC S16 ssdProcTTskTerm(tTsk, idx)
+S16 ssdProcTTskTerm(tTsk, idx)
SsTTskEntry *tTsk;
SsIdx idx;
#endif
S16 n;
S16 ret;
- TRC0(ssdProcTTskTerm);
ent = tTsk->ent;
EXTERN Void ysMtPollPhyMsg(U8 region);
EXTERN Void ysMtRcvPhyMsg(Void);
#ifdef ANSI
-PUBLIC Void *mtTskHdlrT2kL2
+Void *mtTskHdlrT2kL2
(
Ptr tskPtr /* pointer to task entry */
)
#else
-PUBLIC Void *mtTskHdlrT2kL2(tskPtr)
+Void *mtTskHdlrT2kL2(tskPtr)
Ptr tskPtr; /* pointer to task entry */
#endif
{
EXTERN Void ysMtTskHdlr(Void);
EXTERN Void YsPhyRecvMsg();
#ifdef ANSI
-PUBLIC Void *mtTskHdlrT2kL2
+Void *mtTskHdlrT2kL2
(
Ptr tskPtr /* pointer to task entry */
)
#else
-PUBLIC Void *mtTskHdlrT2kL2(tskPtr)
+Void *mtTskHdlrT2kL2(tskPtr)
Ptr tskPtr; /* pointer to task entry */
#endif
{
#endif
#ifdef ANSI
-PUBLIC void *pthreadCreateHdlr
+void *pthreadCreateHdlr
(
void * arg
)
#else
-PUBLIC void *pthreadCreateHdlr(pthreadCreateArg)
+void *pthreadCreateHdlr(pthreadCreateArg)
void *arg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void *mtTskHdlr
+Void *mtTskHdlr
(
Ptr tskPtr /* pointer to task entry */
)
#else
-PUBLIC Void *mtTskHdlr(tskPtr)
+Void *mtTskHdlr(tskPtr)
Ptr tskPtr; /* pointer to task entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 mtTskHdlMsg
+S16 mtTskHdlMsg
(
SsSTskEntry *sTsk
)
#else
-PUBLIC S16 mtTskHdlMsg(sTsk)
+S16 mtTskHdlMsg(sTsk)
SsSTskEntry *sTsk
#endif
{
* Fun: mtTmrHdlrPublic
*/
#ifdef ANSI
-PUBLIC Void mtTmrHdlrPublic
+Void mtTmrHdlrPublic
(
)
#else
-PUBLIC Void mtTmrHdlrPublic()
+Void mtTmrHdlrPublic()
#endif
{
if (SLock(&osCp.tmrTblLock) != ROK)
*
*/
#ifdef ANSI
-PUBLIC Void mtTimeout
+Void mtTimeout
(
PTR tCb, /* control block */
S16 evnt /* event */
)
#else
-PUBLIC Void mtTimeout(tCb, evnt)
+Void mtTimeout(tCb, evnt)
PTR tCb; /* control block */
S16 evnt; /* event */
#endif
#endif
#endif
- TRC0(mtTimeout);
/* get the timer entry */
#endif
MtIsFlag isFlag;
-
- TRC0(mtIsTskHdlr);
-
-
for (; ;)
{
if (read(osCp.dep.isFildes[0], &isFlag, sizeof(isFlag)) != sizeof(isFlag))
*
*/
#ifdef ANSI
-PUBLIC Void mtIntSigHndlr
+Void mtIntSigHndlr
(
int arg
)
#else
-PUBLIC Void mtIntSigHndlr(arg)
+Void mtIntSigHndlr(arg)
int arg;
#endif
{
- TRC0(mtIntSigHndlr);
-
osCp.dep.sigEvnt=TRUE;
#ifdef MSPD
*
*/
#ifdef ANSI
-PUBLIC Void mtExitClnup
+Void mtExitClnup
(
void
)
#else
-PUBLIC Void mtExitClnup()
+Void mtExitClnup()
#endif
{
Ticks ticks;
S8 buf[128];
- TRC0(mtExitClnup);
-
SGetSysTime(&ticks);
#ifdef ALIGN_64BIT
sprintf(buf, "\n\nmtss(posix) ends\nticks: %u\n", ticks);
*
*/
#ifdef ANSI
-PUBLIC S16 SDisplay
+S16 SDisplay
(
S16 chan, /* channel */
Txt *buf /* buffer */
)
#else
-PUBLIC S16 SDisplay(chan, buf)
+S16 SDisplay(chan, buf)
S16 chan; /* channel */
Txt *buf; /* buffer */
#endif
{
- TRC1(SDisplay);
/* mt020.201 - Fixed typo */
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 SFini
+S16 SFini
(
void
)
#else
-PUBLIC S16 SFini()
+S16 SFini()
#endif
{
- TRC1(SFini);
/* mt030.201 added under compilet time flag SS_LINUX and SLES9_PLUS
a loop to overcome the child processes being killed upon exiting the
*
*/
#ifdef ANSI
-PUBLIC S16 SSetDateTime
+S16 SSetDateTime
(
REG1 DateTime *dt /* date and time */
)
#else
-PUBLIC S16 SSetDateTime(dt)
+S16 SSetDateTime(dt)
REG1 DateTime *dt; /* date and time */
#endif
{
- TRC1(SSetDateTime);
-
UNUSED(dt);
*
*/
#ifdef ANSI
-PUBLIC S16 SGetDateTime
+S16 SGetDateTime
(
REG1 DateTime *dt /* date and time */
)
#else
-PUBLIC S16 SGetDateTime(dt)
+S16 SGetDateTime(dt)
REG1 DateTime *dt; /* date and time */
#endif
{
struct tm tme;
- TRC1(SGetDateTime);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (dt == NULLP)
*/
/* mt003.301 Modifications */
#ifdef ANSI
-PUBLIC S16 SGetEpcTime
+S16 SGetEpcTime
(
EpcTime *et /* date and time */
)
#else
-PUBLIC S16 SGetEpcTime(et)
+S16 SGetEpcTime(et)
EpcTime *et; /* date and time */
#endif
{
struct timeval ptime;
#endif
- TRC1(SEpcTime);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 SGetSysTime
+S16 SGetSysTime
(
Ticks *sysTime /* system time */
)
#else
-PUBLIC S16 SGetSysTime(sysTime)
+S16 SGetSysTime(sysTime)
Ticks *sysTime; /* system time */
#endif
{
- TRC1(SGetSysTime);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 SGetRefTime
+S16 SGetRefTime
(
U32 refTime, /* reference time */
U32 *sec,
U32 *usec
)
#else
-PUBLIC S16 SGetRefTime(refTime, sec, usec)
+S16 SGetRefTime(refTime, sec, usec)
U32 refTime; /* reference time */
U32 *sec;
U32 *usec;
struct timeval ptime;
#endif
- TRC1(SGetSysTime);
#ifndef SS_LINUX
clock_gettime(CLOCK_REALTIME, &ptime);
*
*/
#ifdef ANSI
-PUBLIC S16 SRandom
+S16 SRandom
(
Random *value /* random number */
)
#else
-PUBLIC S16 SRandom(value)
+S16 SRandom(value)
Random *value; /* random number */
#endif
{
- TRC1(SRandom);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 SExitTsk
+S16 SExitTsk
(
void
)
#else
-PUBLIC S16 SExitTsk()
+S16 SExitTsk()
#endif
{
- TRC1(SExitTsk);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC S16 SExitInt
+S16 SExitInt
(
void
)
#else
-PUBLIC S16 SExitInt()
+S16 SExitInt()
#endif
{
- TRC1(SExitInt);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC S16 SHoldInt
+S16 SHoldInt
(
void
)
#else
-PUBLIC S16 SHoldInt()
+S16 SHoldInt()
#endif
{
- TRC1(SHoldInt);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC S16 SRelInt
+S16 SRelInt
(
void
)
#else
-PUBLIC S16 SRelInt()
+S16 SRelInt()
#endif
{
- TRC1(SRelInt);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SEnbInt
+INLINE S16 SEnbInt
(
void
)
#else
-PUBLIC INLINE S16 SEnbInt()
+INLINE S16 SEnbInt()
#endif
{
- TRC1(SEnbInt);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SDisInt
+INLINE S16 SDisInt
(
void
)
#else
-PUBLIC INLINE S16 SDisInt()
+INLINE S16 SDisInt()
#endif
{
- TRC1(SDisInt);
return ROK;
*
*/
#ifdef ANSI
-PUBLIC S16 SGetVect
+S16 SGetVect
(
VectNmb vectNmb, /* vector number */
PIF *vectFnct /* vector function */
)
#else
-PUBLIC S16 SGetVect(vectNmb, vectFnct)
+S16 SGetVect(vectNmb, vectFnct)
VectNmb vectNmb; /* vector number */
PIF *vectFnct; /* vector function */
#endif
{
- TRC1(SGetVect);
UNUSED(vectNmb);
*
*/
#ifdef ANSI
-PUBLIC S16 SPutVect
+S16 SPutVect
(
VectNmb vectNmb, /* vector number */
PIF vectFnct /* vector function */
)
#else
-PUBLIC S16 SPutVect(vectNmb, vectFnct)
+S16 SPutVect(vectNmb, vectFnct)
VectNmb vectNmb; /* vector number */
PIF vectFnct; /* vector function */
#endif
{
- TRC1(SPutVect);
UNUSED(vectNmb);
*
*/
#ifdef ANSI
-PUBLIC S16 SGetEntInst
+S16 SGetEntInst
(
Ent *ent, /* entity */
Inst *inst /* instance */
)
#else
-PUBLIC S16 SGetEntInst(ent, inst)
+S16 SGetEntInst(ent, inst)
Ent *ent; /* entity */
Inst *inst; /* instance */
#endif
SsSTskEntry *sTsk;
- TRC1(SGetEntInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 SSetEntInst
+S16 SSetEntInst
(
Ent ent, /* entity */
Inst inst /* instance */
)
#else
-PUBLIC S16 SSetEntInst(ent, inst)
+S16 SSetEntInst(ent, inst)
Ent ent; /* entity */
Inst inst; /* instance */
#endif
SsSTskEntry *sTsk;
- TRC1(SSetEntInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SSetIntPend
+INLINE S16 SSetIntPend
(
U16 id, /* driver task identifier */
Bool flag /* flag */
)
#else
-PUBLIC INLINE S16 SSetIntPend(id, flag)
+INLINE S16 SSetIntPend(id, flag)
U16 id; /* driver task identifier */
Bool flag; /* flag */
#endif
MtIsFlag isFlag;
- TRC1(SSetIntPend);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 SGlobMemInfoShow
+S16 SGlobMemInfoShow
(
Void
)
#else
-PUBLIC S16 SGlobMemInfoShow()
+S16 SGlobMemInfoShow()
#endif
{
U16 idx;
Txt prntBuf[100];
CmMmGlobRegCb *globReg;
- TRC1(SGlobMemInfoShow);
globReg = osCp.globRegCb;
*
*/
#ifdef ANSI
-PUBLIC S16 SRegInfoShow
+S16 SRegInfoShow
(
Region region,
U32 *availmem
)
#else
-PUBLIC S16 SRegInfoShow(region, availmem)
+S16 SRegInfoShow(region, availmem)
Region region;
U32 *availmem;
#endif
U16 idx;
Txt prntBuf[100];
- TRC1(SRegInfoShow);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region > (SS_MAX_REGS-1) )
}
#ifdef ANSI
-PUBLIC S16 SRegReachedMemThreshold
+S16 SRegReachedMemThreshold
(
Region region,
U8 maxBkt
)
#else
-PUBLIC S16 SRegReachedMemThreshold(region, maxBkt)
+S16 SRegReachedMemThreshold(region, maxBkt)
Region region;
U8 maxBkt;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetRegInfo
+S16 SGetRegInfo
(
Region region,
SsMemDbgInfo *dbgInfo
)
#else
-PUBLIC S16 SGetRegInfo(region, dbgInfo)
+S16 SGetRegInfo(region, dbgInfo)
Region region;
SsMemDbgInfo *dbgInfo;
#endif
{
U32 idx;
- TRC1(SGetRegInfo);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region >= mtMemoCfg.numRegions )
}
#ifdef ANSI
-PUBLIC S16 SGetRegPoolInfo
+S16 SGetRegPoolInfo
(
U8 *numRegion,
U8 *numPool
)
#else
-PUBLIC S16 SGetRegPoolInfo(numRegion, numPool)
+S16 SGetRegPoolInfo(numRegion, numPool)
U8 *numRegion;
U8 *numPool;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SPrintRegMemStatusInfo
+S16 SPrintRegMemStatusInfo
(
Region region,
U8 typeFlag
)
#else
-PUBLIC S16 SPrintRegMemStatusInfo(region, typeFlag)
+S16 SPrintRegMemStatusInfo(region, typeFlag)
Region region;
U8 typeFlag;
#endif
U32 statMemSize;
U32 dynMemSize;
- TRC1(SPrintRegMemStatusInfo);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region >= mtMemoCfg.numRegions )
U32 idx;
U32 cntEnt;
- TRC1(SPrintRegMemStats);
hashListCp = &mtCMMRegCb[region]->hashListCp;
*
*/
#ifdef ANSI
-PUBLIC Void SRegMemErrHdlr
+Void SRegMemErrHdlr
(
Region region,
Data *ptr,
S16 errCode
)
#else
-PUBLIC Void SRegMemErrHdlr(region, ptr, errCode)
+Void SRegMemErrHdlr(region, ptr, errCode)
Region region;
Data *ptr;
S16 errCode;
{
Txt prntBuf[150];
- TRC1(SRegMemErrHdlr);
if (errCode == RDBLFREE)
{
*
*/
#ifdef ANSI
-PUBLIC S16 SPrintRegMemProfile
+S16 SPrintRegMemProfile
(
Region region
)
#else
-PUBLIC S16 SPrintRegMemProfile(region)
+S16 SPrintRegMemProfile(region)
Region region;
#endif
{
U32 blkCnt;
- TRC1(SPrintRegMemProfile);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region >= mtMemoCfg.numRegions )
*
--*/
#ifdef ANSI
-PUBLIC S16 SGetTimeStamp
+S16 SGetTimeStamp
(
S8 *ts
)
#else
-PUBLIC S16 SGetTimeStamp(ts)
+S16 SGetTimeStamp(ts)
S8 *ts;
#endif
{
S8 time_string[40];
S32 microseconds;
- TRC1(SGetTimeStamp);
#ifndef SS_LINUX
clock_gettime(CLOCK_REALTIME, &ptime);
*
--*/
#ifdef ANSI
-PUBLIC U32 SGetSystemTsk
+U32 SGetSystemTsk
(
Void
)
#else
-PUBLIC U32 SGetSystemTsk()
+U32 SGetSystemTsk()
#endif
{
- TRC1(SGetSystemTskS);
return (pthread_self());
SsSTskEntry *sTsk;
S16 ret;
- TRC1(ssdAddTmrSTsk);
sTsk = NULLP;
/* lock the system task table */
ret = SLock(&osCp.sTskTblLock);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitLockNew
+S16 ssdInitLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdInitLockNew(lockId, lockType)
+S16 ssdInitLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdInitLockNew);
switch(lockType)
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdLockNew
+S16 ssdLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdLockNew(lockId, lockType)
+S16 ssdLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdLockNew);
switch(lockType)
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdUnlockNew
+S16 ssdUnlockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdUnlockNew(lockId, lockType)
+S16 ssdUnlockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdUnlockNew);
switch(lockType)
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDestroyLockNew
+S16 ssdDestroyLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdDestroyLockNew(lockId, lockType)
+S16 ssdDestroyLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdDestroyLockNew);
switch(lockType)
{
*
**/
#ifdef ANSI
-PUBLIC S16 ssInitRcvWork
+S16 ssInitRcvWork
(
void
)
#else
-PUBLIC S16 ssInitRcvWork()
+S16 ssInitRcvWork()
#endif
{
pthread_attr_t attr;
pthread_t thread;
- TRC1(ssInitRcvWork);
/* set the required attributes */
pthread_attr_init(&attr);
struct timespec ts;
Pst pst;
- TRC1(workRcvTsk);
for (;;)
#endif /* SS_SEUM_CAVIUM */
#ifdef TENB_RTLIN_CHANGES
-PUBLIC S16 SInitLock(SLockId *l, U8 t)
+S16 SInitLock(SLockId *l, U8 t)
{
S16 r = 0;
pthread_mutexattr_t prior;
*
*/
-PUBLIC Void ssRegMainThread(Void)
+Void ssRegMainThread(Void)
{
if(SS_INVALID_THREAD_REG_MAP != SS_GET_THREAD_MEM_REGION())
* File: mt_ss.c
*
*/
-PUBLIC S32 ssCheckAndAddMemoryRegionMap
+S32 ssCheckAndAddMemoryRegionMap
(
pthread_t threadId, /* Thread Id of system task */
Region region /* Region associated with thread */
PRIVATE pthread_t createdThreadIds[SS_MAX_THREAD_CREATE_RETRY];
U32 indx;
- TRC1(ssCheckAndAddMemoryRegionMap);
/* Here 0xFF is considered as invalid region and if the mapping table
* contains 0xFF, that mapping entry is free
* File: mt_ss.c
*
*/
-PUBLIC S32 ssCheckAndDelMemoryRegionMap
+S32 ssCheckAndDelMemoryRegionMap
(
pthread_t threadId /* Thread Id of system task */
)
{
- TRC1(ssCheckAndDelMemoryRegionMap);
/* Raghu To-Do Check with team, is it necessary to acquire lock
* as del and add may go parallel */
*
*/
#ifdef ANSI
-PUBLIC S16 SStartTask
+S16 SStartTask
(
VOLATILE U32 *startTime,
U32 taskId
)
#else
-PUBLIC S16 SStartTask(startTime, taskId)
+S16 SStartTask(startTime, taskId)
VOLATILE U32 *startTime;
U32 taskId;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SStopTask
+S16 SStopTask
(
VOLATILE U32 startTime,
U32 taskId
)
#else
-PUBLIC S16 SStopTask(startTime, taskId)
+S16 SStopTask(startTime, taskId)
VOLATILE U32 startTime;
U32 taskId;
#endif
}
#else
#ifdef ANSI
-PUBLIC S16 SStartTask
+S16 SStartTask
(
VOLATILE U32 * startTime,
U32 taskId
)
#else
-PUBLIC S16 SStartTask(startTime, taskId)
+S16 SStartTask(startTime, taskId)
VOLATILE U32 * startTime;
U32 taskId;
#endif
}
#ifdef ANSI
-PUBLIC S16 SStopTask
+S16 SStopTask
(
VOLATILE U32 startTime,
U32 taskId
)
#else
-PUBLIC S16 SStopTask(startTime, taskId)
+S16 SStopTask(startTime, taskId)
VOLATILE U32 startTime;
U32 taskId;
#endif
* @return Void - function is always success
*/
#ifdef ANSI
-PUBLIC Void UpdateSocCpuInfo
+Void UpdateSocCpuInfo
(
CmCpuStatsInfo *cpuInfo,
U8 idx
)
#else
-PUBLIC Void UpdateSocCpuInfo(*cpuInfo, idx)
+Void UpdateSocCpuInfo(*cpuInfo, idx)
CmCpuStatsInfo *cpuInfo;
U8 idx;
#endif
SsSTskEntry *sTsk;
S16 ret;
- TRC1(ssdReAddTmrSTsk);
sTsk = NULLP;
/* lock the system task table */
ret = SLock(&osCp.sTskTblLock);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdReInitTmr
+S16 ssdReInitTmr
(
void
)
#else
-PUBLIC S16 ssdReInitTmr()
+S16 ssdReInitTmr()
#endif
{
pthread_attr_t attr;
U32 threadCreated = FALSE;
#endif /* SS_THR_REG_MAP */
- TRC0(ssdReInitTmr);
#ifndef XEON_SPECIFIC_CHANGES
ret = ssCheckAndDelMemoryRegionMap(osCp.dep.tmrHdlrTID);
Code Review / o-du / l2.git / blobdiff