/* DHL_OSAL.c OS Abstraction Layer Implementation Description: OS Heap/.. implementation Copyright 2006~2010 Digital STREAM Technology, Inc. All Rights Reserved */ #include "DHL_OSAL.h" #include "DHL_OSAL_Priv.h" #include "DHL_DBG.h" #include "DHL_OSAL_Impl.h" #include "bcmmemmgr.h" /* 모든 헤더 파일을 포함하지는 않으며, compile time을 줄이기 위해 각 모듈은 필요한 만큼의 헤더를 선언하도록 함. */ /* DHL 디버그 모듈 이름 정의 룰 참고: DHL 모듈들은 모두 * 로 시작. API는 대문자, Platform 및 기타는 소문자 사용. 디폴트 레벨은 0으로 설정한다. (0: 에러 메시지만 출력) */ //DHL_MODULE("*osal", 0); #if COMMENT ____Config____(){} #endif /* 이 모듈 내부에서 사용되는 각종 configuration 정의. */ /* #define SUPPORT_FAST_SWITCHING_OPTIMIZATION 1 */ /* #define FUNC_MONITOR_TIMER_ID TIMER_ID_FUNC_MONITOR */ /* 1로 설정하면 malloc 버퍼 앞 뒤로 guard 영역을 추가 확보하고, memory overrun 등의 에러 체크 수행. heap debug 옵션을 사용하고 있다면 buf header의 memCheck가 이 역할을 대신하고 있으므로 guard 옵션이 필요하지 않음. */ #if DHL_OS_USE_HEAP_DEBUG #define USE_MEMORY_GUARD 0 #else #define USE_MEMORY_GUARD 1 #endif #if DHL_OS_USE_HEAP_DEBUG #define USE_MEM_FOOTER 1 // 1이면 HEADER 뿐만 아니라 FOOTER까지도 추가한다. // 추가의 메모리가 소요되나 // memory corruption 까지 체크하려면 이 옵션을 사용한다. #define CHECK_MEM_CORRUPTION 1 // memory corruption (overrun) check를 수행한다. // 사용되지 않는 빈 공간에 check pattern을 기록하기 때문에 약간의 성능 감소 예상. #define CHECK_MEM_LEAK 1 // memory 누수를 확인하기 위해 일정 이상 memory가 사용되면 // heap 상태를 출력하도록 한다. #endif static DHL_OS_SEMA_ID semTask; // store BSS storage. /* osi_takemutexsemaphore api는 표준 api가 아니라서 제거. 모든 sem에서 공용으로 사용하는 api 사용하면 됨. */ #define osi_takemutexsemaphore(s) osi_takesemaphore(s) extern int printf(const char *format, ...); #if COMMENT ____Types____(){} #endif #if COMMENT ____Variables____(){} #endif /* global로 적용되는 variable 정의. 각 function 별로 특수한 용도의 variable은 각 functionX block 에서 정의 가능. */ #if COMMENT ____Task____(){} #endif //BKNOTE: 반드시 task 종료시에 DHL_OS_SelfDeleteTask() 호출해줘야 함. (uCOS-II 제약) DHL_OS_TASK_ID DHL_OS_CreateTask(DHL_OS_TASKFUNCTION func, const char *name, int priority, int stackSize, UINT32 arg1) { // UINT32 i; DHL_OS_TASK_ID tid; osi_takemutexsemaphore(semTask); tid = osi_spawntask(func, name, priority, stackSize, arg1); osi_givemutexsemaphore(semTask); if(tid==0) { DHL_OS_Printf("|%s| fail to add task(name:%s).\n", __FUNCTION__, name); return DHL_INVALID_TASK_ID; } DHL_OS_Printf("|%s| func = %x, arg1 = %d(%x), stk_size = %d\n", __FUNCTION__, func, arg1, arg1, stackSize); return (DHL_OS_TASK_ID)tid; } void DHL_OS_SelfDeleteTask(void) { DHL_OS_Printf("|%s| delete Task\n", __FUNCTION__); osi_selfdeletetask(); } void DHL_OS_SetTaskPriority(DHL_OS_TASK_ID tid, UINT32 newPrio, UINT32 *pOldPrio) { if (pOldPrio == NULL) { return; } osi_changetaskpriority(tid, newPrio, pOldPrio); // void osi_changetaskpriority(os_task_id tid, UINT32 newPrio, UINT32 *oldPrioPtr) DHL_OS_Printf("|%s| change priority %d -> %d \n", __FUNCTION__, *pOldPrio, newPrio ); } DHL_RESULT DHL_OS_FindTaskByName(const char *name, DHL_OS_TASK_ID *returnTid) { if(!name || strlen(name)==0) { printf("bad task name !!\n"); *returnTid=0; return DHL_FAIL_INVALID_PARAM; } osi_takemutexsemaphore(semTask); *returnTid=osi_taskidfromname((char *)name); osi_givemutexsemaphore(semTask); return DHL_OK; } DHL_OS_TASK_ID DHL_OS_GetTaskID(void) { DHL_OS_TASK_ID tid; tid = osi_taskid(); return tid; } DHL_RESULT DHL_OS_GetTaskInfo(DHL_OS_TASK_ID tid, DHL_OS_TASK_INFO *pTaskInfo) { b_task_stats *stat; if (pTaskInfo == NULL) { DHL_OS_Printf("|%s| null arg(pTaskInfo).\n", __FUNCTION__); return DHL_FAIL_NULL_POINTER; } stat=bos_get_task_info((b_task_t)tid); if(stat) { pTaskInfo->tid = tid; pTaskInfo->name = stat->name; pTaskInfo->priority= tid; }else { DHL_OS_Printf("|%s| fail to find task(tid:0x%x).\n", __FUNCTION__, tid); return DHL_FAIL_INVALID_HANDLE; } return DHL_OK; } char *DHL_OS_TaskName(DHL_OS_TASK_ID tid) { if(tid==(DHL_OS_TASK_ID)0) { tid=osi_taskid(); } return osi_taskname(tid); } int DHL_OS_TaskPriority() { return osi_taskpriority(); } #if COMMENT ____Semaphore____(){} #endif DHL_OS_SEMA_ID DHL_OS_CreateCountingSemaphore(const char *name, UINT32 options, UINT32 count) { return osi_createcountingsemaphore(name, options, count); } DHL_OS_SEMA_ID DHL_OS_CreateBinarySemaphore(const char *name, UINT32 options, BOOL flag) { return osi_createbinarysemaphore(name, options, flag); } DHL_OS_SEMA_ID DHL_OS_CreateMutexSemaphore(const char *name) { return osi_createmutexsemaphore(name); } void DHL_OS_DeleteSemaphore(DHL_OS_SEMA_ID sem) { printf("delete sem %x\n", sem); osi_deletesemaphore(sem); } DHL_RESULT DHL_OS_TakeSemaphore(DHL_OS_SEMA_ID sem, UINT32 millisec) { int ticks; if (millisec == DHL_TIMEOUT_FOREVER) { if (osi_in_interrupt() || osi_in_tasklock()) { // osi_dbgprint("\a !! take sem in isr or tasklock\n"); return DHL_FAIL_INVALID_STATE; } return osi_takesemaphore(sem); } else if(millisec == 0) { return osi_takesemaphore_nowait(sem); }else { if (osi_in_interrupt() || osi_in_tasklock()) { // osi_dbgprint("\a !! take sem in isr\n"); return DHL_FAIL_INVALID_STATE; } ticks = MS_TO_TICKS(millisec); return osi_takesemaphore_wait(sem, ticks); } return DHL_OK; } DHL_RESULT DHL_OS_GiveSemaphore(DHL_OS_SEMA_ID sem) { return osi_givesemaphore(sem); } #if COMMENT ____OS_MessageQ____(){} #endif void _msg_api_test(void) { #if 0 typedef struct { unsigned char f; unsigned int a; unsigned short int b; unsigned short int c; unsigned int d; } TEST_MSG; MS_S32 qid; TEST_MSG smsg, rmsg; MS_U32 rmsg_size; MS_BOOL ret; int i; // create qid = MsOS_CreateQueue(NULL, 96, E_MSG_FIXED_SIZE, sizeof(TEST_MSG), E_MSOS_FIFO, "Test"); printf("qid=%x\n", qid); // send for (i = 0; i < 100; i++) { printf("<%5d>snd %3d:", DHL_OS_GetMsCount(), i + 1); smsg.f = i; smsg.a = 0x82600628 + (0x08 * i); smsg.b = 0x25099052 + (0x04 * i); smsg.c = 0xcafeefac + (0x10 * i); smsg.d = 0xbeeffeeb + (0x02 * i); ret = MsOS_SendToQueue(qid, (MS_U8 *)&smsg, sizeof(TEST_MSG), 100); printf("ret=%x, f=%x, a=%x, b=%x, c=%x, d=%x\n", ret, smsg.f, smsg.a, smsg.b, smsg.c, smsg.d); } // receive for (i = 0; i < 150; i++) { printf("<%5d>rcv %3d:", DHL_OS_GetMsCount(), i + 1); ret = MsOS_RecvFromQueue(qid, (MS_U8 *)&rmsg, sizeof(TEST_MSG), &rmsg_size, 100); printf("ret=%x, size=%x, f=%x, a=%x, b=%x, c=%x, d=%x\n", ret, rmsg_size, rmsg.f, rmsg.a, rmsg.b, rmsg.c, rmsg.d); } #endif } DHL_OS_MSGQ_ID DHL_OS_CreateMessageQueue(const char *name, UINT32 options, UINT32 maxMessages, UINT32 maxMessageLength) { return osi_createmessagequeue(name, options, maxMessages, maxMessageLength); } void DHL_OS_DeleteMessageQueue(DHL_OS_MSGQ_ID qid) { osi_deletemessagequeue(qid); } DHL_RESULT DHL_OS_SendMessage(DHL_OS_MSGQ_ID qid, void *buffer, int bytes) { return osi_sendmessage(qid, buffer, bytes); } DHL_RESULT DHL_OS_ReceiveMessage(DHL_OS_MSGQ_ID qid, void *msgBuf, UINT32 millisec) { if (millisec == DHL_TIMEOUT_FOREVER) { if (osi_in_interrupt() || osi_in_tasklock()) { osi_dbgprint("\a !! rcv msg in isr or tasklock\n"); return DHL_FAIL_INVALID_STATE; } return osi_receivemessage(qid, msgBuf); } else if(millisec == 0) { return osi_receivemessage_wait(qid, msgBuf, NO_WAIT); }else { if (osi_in_interrupt() || osi_in_tasklock()) { osi_dbgprint("\a !! rcv msg in isr\n"); return DHL_FAIL_INVALID_STATE; } return osi_receivemessage_wait(qid, msgBuf, MS_TO_TICKS(millisec)); } return DHL_OK; } #if COMMENT ____OS_Heap____(){} #endif void *DHL_OS_Malloc(int size) { return OS_Malloc(size); } void DHL_OS_Free(void **pptr) { return OS_Free(pptr); } extern bcm_heap_t *g_p_sdram_heap; void DHL_OS_GetHeapStatus(DHL_OS_HEAP_STATUS *pHeapStatus) { #ifdef BCM_DEBUG struct bcm_heap_status bhs; memset(pHeapStatus, 0, sizeof(dhl_heap_status)); if (mem_status(g_p_sdram_heap, &bhs) == 0) { pHeapStatus->size_heap = bhs.size_heap; pHeapStatus->num_alloc_chunk = bhs.num_alloc_chunk; pHeapStatus->size_alloc = bhs.size_alloc; pHeapStatus->num_free_chunk = bhs.num_free_chunk; pHeapStatus->size_free = bhs.size_free; } #endif } #if COMMENT ____OS_Tick____(){} #endif void DHL_OS_Delay(UINT32 millisec) { if (osi_in_interrupt() || osi_in_tasklock()) { osi_dbgprint("\a !! delay in isr or tasklock\n"); return;; } osi_delay(millisec); } UINT32 DHL_OS_GetMsCount(void) { return TICKS_TO_MS(osi_gettickcount()); } UINT32 DHL_OS_GetTickCount(void) { return osi_gettickcount(); } UINT32 DHL_OS_GetTicksPerSecond(void) { return osi_gettickspersecond(); } #if COMMENT ____OS_Interrupt____(){} #endif BOOL DHL_OS_GetIntState() { return osi_in_interrupt(); } UINT32 DHL_OS_DisableInterrupts() { return osi_disableint(); } void DHL_OS_RestoreInterrupts(UINT32 mask) { osi_enableint(mask); } #if COMMENT ___Task_Enum___(){} #endif void DHL_OS_ShowTaskInfo(int level) { } #if COMMENT ___Task_Priority___(){} #endif /* OS 별로 highest, lowest priority가 다르므로 inversion 작업을 대신해 주는 매크로를 사용. 아래 테이블에서는 각 task의 상대적인 순서만 잡아주면 되도록 함. */ #define PRIO(x) (64-(x)) struct { const char *signiture; int prio; } p_prio_tbl[] = { #if 1//Newcon3 DST { "APP_INIT", 14, }, { "DRV_GPB", 15, }, //x { "DRV_IR", 30, }, //uio_task (x-1) //16->30 { "DRV_GPIO", 18, }, { "DRV_UART", 20, }, { "DRV_TIMER", 21, }, { "DRV_FE", 23, }, { "DRV_BASE", 24, }, { "DHL_PSIPRX", 29, }, //26->29 { "DHL_EVENT", 27, }, { "DHL_AV_EVT", 28, }, //{ "DMW_TUNER", 29, }, // UI 관련 { "DIGIT_KEY", 32, }, { "MENU", 22, }, //19 -> 22 { "COMM", 31, }, //22->31 // Caption 관련 { "DCC_AUX", 34, }, { "AUX_CC", 35, }, { "DCC_DCD", 36, }, { "DCC_DMX", 37, }, { "VBI_DEC", 38, }, { "CC_TIMER", 39, }, { "EA", 44, }, { "DMC_TASK", 45, }, // old channel mw { "DMW_CHM", 46, }, // new channel mw, channel tuning control { "DMW_PSI", 47, }, // new psi mw, psi/psip scan task { "DMW_EPGSCN", 48, }, // old epg mw { "DMW_EPGEVT", 49, }, // old epg mw { "DMW_TIMER", 51, }, // General purpose timer { "APP_TIMER", 53, }, // Sleep timer 용으로 사용되는 것으로 보임. { "SIGMON", 54, }, // signal monitor task { "DHL_SHELL", 56, }, // 디버그 쉘 { "DHL_SHELLX", 57, }, // 디버그 쉘 background 실행 { "DHL_PRINTF", 58, }, // console printf task { "DMW_FLASH", 59, }, // Flash worker task (for NVM) #else { "APP_INIT", PRIO(50), }, { "DRV_GPB", PRIO(49), }, { "DRV_IR", PRIO(48), }, { "DRV_GPIO", PRIO(46), }, { "DRV_UART", PRIO(44), }, { "DRV_TIMER", PRIO(43), }, { "DRV_FE", PRIO(41), }, { "DRV_BASE", PRIO(40), }, { "DHL_PSIPRX", PRIO(38), }, { "DHL_EVENT", PRIO(37), }, { "DHL_AV_EVT", PRIO(36), }, { "DMW_TUNER", PRIO(35), }, // UI 관련 { "DIGIT_KEY", PRIO(32), }, { "MENU", PRIO(45), }, { "COMM", PRIO(42), }, // Caption 관련 { "DCC_AUX", PRIO(30), }, { "AUX_CC", PRIO(29), }, { "DCC_DCD", PRIO(28), }, { "DCC_DMX", PRIO(27), }, { "VBI_DEC", PRIO(26), }, { "CC_TIMER", PRIO(25), }, { "EA", PRIO(20), }, { "DMC_TASK", PRIO(19), }, // old channel mw { "DMW_CHM", PRIO(18), }, // new channel mw, channel tuning control { "DMW_PSI", PRIO(17), }, // new psi mw, psi/psip scan task { "DMW_EPGSCN", PRIO(16), }, // old epg mw { "DMW_EPGEVT", PRIO(15), }, // old epg mw //{ "SCTESI_RX", PRIO(17), }, // scte oob si scan task { "DMW_TIMER", PRIO(13), }, // General purpose timer { "APP_TIMER", PRIO(11), }, // Sleep timer 용으로 사용되는 것으로 보임. { "SIGMON", PRIO(10), }, // signal monitor task { "DHL_SHELL", PRIO(8), }, // 디버그 쉘 { "DHL_SHELLX", PRIO(7), }, // 디버그 쉘 background 실행 { "DHL_PRINTF", PRIO(6), }, // console printf task { "DMW_FLASH", PRIO(5), }, // Flash worker task (for NVM) #endif }; /* task signiture를 task priority로 변환하여 주는 util 함수. */ int os_sig2taskprio(const char *signiture) { int i; for (i=0;(unsigned int)i