kal.c

uCosII是一个小型的多任务调度内核

/*----------------------------------------------------------------
[BASIC]  
{                                                              
	[FILENAME]  KAL.c                                                   
	[CONTENT]   Kenel adapt layder definition
	[AUTHOR]    Wangyf 
	[VERSION]   070704.01
	[COMPANY]   CEC Huada Electronic Design CO.,LTD                                      
}

[MOD]
{
	2007.07.10  Create this file
	
}
----------------------------------------------------------------*/   
#include <string.h>
#include "kal.h"


/*--------------------------------------------------------------
  Thread Management
----------------------------------------------------------------*/
Status KL_CreateThread(KL_thread_t *pthread, 
                       u8_t *name,
                       void (*func)(void*, u32_t),
                       void *argv,
                       u32_t argc,
                       void *stack_address,
                       u32_t stack_size,
                       u32_t priority
                       )
{
	INT8U err;
	OS_STK *top, *bottom;

	#if KL_CHK_ARG_EN
	if (pthread == NULL) return KL_INVALID_TASK;
	if (func == NULL) return KL_INVALID_ENTRY;
	if ((stack_address == NULL)||((u32_t)stack_address%4 != 0)) return KL_INVALID_MEMORY;
	if ((stack_size < 512)||(stack_size%4 != 0)) return KL_INVALID_SIZE;
	if (priority > OS_LOWEST_PRIO) return KL_INVALID_PRIORITY;
	#endif

	*pthread = priority;
	name = name;
	bottom = (OS_STK *)stack_address;
	stack_size /= 4;
	top = bottom + stack_size - 1;

	err = OSTaskCreateExt((void (*)(void *))func, argv, top, priority, priority, \
			bottom, stack_size, NULL, OS_TASK_OPT_STK_CHK);

	return (Status)(-err);
}


Status KL_DelThread(KL_thread_t *pthread)
{
	INT8U err;
	INT8U prio;

	#if KL_CHK_ARG_EN
	if (pthread == NULL) return KL_INVALID_TASK;
	#endif

	prio = (INT8U)(*pthread);
	err = OSTaskDel(prio);
	return (Status)(-err);
}

Status KL_SuspendThread(KL_thread_t *pthread)
{
	INT8U err;
	INT8U prio;

	#if KL_CHK_ARG_EN
	if (pthread == NULL) return KL_INVALID_TASK;
	#endif

	prio = (INT8U)(*pthread);
	err = OSTaskSuspend(prio);
	return (Status)(-err);
}

Status KL_ResumeThread(KL_thread_t *pthread)
{
	INT8U err;
	INT8U prio;

	#if KL_CHK_ARG_EN
	if (pthread == NULL) return KL_INVALID_TASK;
	#endif

	prio = (INT8U)(*pthread);
	err = OSTaskResume(prio);
	return (Status)(-err);
}

Status KL_ChangeThreadPriority(KL_thread_t *pthread, u32_t new_priority, u32_t *old_priority)
{
	INT8U err;
	INT8U prio;

	#if KL_CHK_ARG_EN
	if (pthread == NULL) return KL_INVALID_TASK;
	if (new_priority > OS_LOWEST_PRIO) return KL_INVALID_PRIORITY;
	#endif

	prio = (INT8U)(*pthread);
	err = OSTaskChangePrio(prio, new_priority);
	if (err == OS_NO_ERR){
		if (old_priority != NULL) *old_priority = prio;
		*pthread = new_priority;
	}
	return (Status)(-err);
}
u32_t KL_CheckThreadStack(void)
{
	OS_STK_DATA stk;
	INT8U prio;

	prio = OSTCBCur->OSTCBPrio;
	OSTaskStkChk(prio, &stk);
	return (stk.OSFree);
}

Status KL_QueryThreadInfo(KL_thread_t *pthread)
{
	INT8U err;
	INT8U prio;

	#if KL_CHK_ARG_EN
	if (pthread == NULL) return KL_INVALID_TASK;
	#endif

	prio = (INT8U)(*pthread);
	prio = prio;
	//...
	return (Status)(-err);
}

void KL_Sleep(u32_t ticks)
{
	while(ticks > 0xfffe){
		OSTimeDly(0xfffe);
		ticks -= 0xfffe;
	}
	OSTimeDly(ticks);
}

/*--------------------------------------------------------------
  Interrupt Management
----------------------------------------------------------------*/
Status KL_RegisterISR(u32_t vector, void(*isr)(u32_t))
{
	INT8U err;
	#if KL_CHK_ARG_EN
	if (isr == NULL) return KL_INVALID_ENTRY;
	#endif
	err = OS_RegisterISR(vector, isr);
	return (Status)(-err);
}

void KL_EnableInt(void)
{
	u32_t r;
	__asm{
        MRS     r,CPSR 
        BIC     r,r,#0x80 
        MSR     CPSR_cxsf,r 
	}
}

void KL_DisableInt(void)
{
	u32_t r;
	__asm{
        MRS     r,CPSR 
        ORR     r,r,#0x80 
        MSR     CPSR_cxsf,r 
	}
}

reg_t  KL_BeginCriticalSec(void)
{
	return OS_CPU_SR_Save();
}
void   KL_EndCriticalSec(reg_t reg)
{
	OS_CPU_SR_Restore(reg);
}
s32_t  KL_CheckIntStatus(void)
{
	return 0;
}

/*--------------------------------------------------------------
  Timer Management
----------------------------------------------------------------*/
Status KL_CreateTimer(KL_timer_t *ptimer,
                      u8_t *name,
                      void (*func)(u32_t),
                      u32_t arg,
                      u32_t initial,
                      u32_t period,
                      u32_t type
                      )
{
	OS_TMR *pt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (ptimer == NULL) return KL_INVALID_TIMER;
	if (func == NULL) return KL_INVALID_ENTRY;
	#endif

	pt = OSTmrCreate (initial, period, type, (OS_TMR_CALLBACK)func, (void *)arg, name, &err);
	*ptimer = (KL_timer_t)pt;

	return (Status)(-err);
}

Status KL_DelTimer(KL_timer_t *ptimer)
{
	OS_TMR *pt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (ptimer == NULL) return KL_INVALID_TIMER;
	#endif

	pt = (OS_TMR *)(*ptimer);

	OSTmrDel(pt, &err);

	return (Status)(-err);
}

Status KL_StartTimer(KL_timer_t *ptimer)
{
	OS_TMR *pt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (ptimer == NULL) return KL_INVALID_TIMER;
	#endif

	pt = (OS_TMR *)(*ptimer);

	OSTmrStart(pt, &err);

	return (Status)(-err);
}

Status KL_StopTimer(KL_timer_t *ptimer)
{
	OS_TMR *pt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (ptimer == NULL) return KL_INVALID_TIMER;
	#endif

	pt = (OS_TMR *)(*ptimer);

	OSTmrStop(pt, OS_TMR_OPT_NONE, NULL, &err);

	return (Status)(-err);
}

Status KL_GetTimerRemain(KL_timer_t *ptimer, u32_t *left)
{
	OS_TMR *pt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (ptimer == NULL) return KL_INVALID_TIMER;
	if (left == NULL) return KL_INVALID_MEMORY;
	#endif

	pt = (OS_TMR *)(*ptimer);

	*left = OSTmrRemainGet(pt, &err);

	return (Status)(-err);
}

Status KL_QueryTimerInfo(KL_timer_t *ptimer)
{
	return KL_SUCCESS;
}

u32_t  KL_GetSysClock(void)
{
	return OSTimeGet();
}

void KL_SetSysClock(u32_t newclock)
{
	OSTimeSet(newclock);
}

/*--------------------------------------------------------------
  Dynamic Memory Management
----------------------------------------------------------------*/
Status KL_CreateMemPool(KL_mempool_t *pool,
                        u8_t *name,
                        void *startaddress,
                        u32_t poolsize,
                        u32_t min_allocation
                        )
{
	INT8U err;
	#if KL_CHK_ARG_EN
	if (pool == NULL) return KL_INVALID_MEMPOOL;
	if (startaddress == NULL) return KL_INVALID_MEMORY;
	if (poolsize <= min_allocation) return KL_INVALID_SIZE;
	#endif

	err = OS_Create_Memory_Pool(pool, name, startaddress, poolsize, min_allocation);
	return (Status)(-err);
}
Status KL_DelMemPool(KL_mempool_t *pool)
{
	INT8U err;
	err = OS_DelMemPool(pool);
	return (Status)(-err);
}
void  *KL_GetMem(KL_mempool_t *pool, u32_t size)
{
	void *pointer = NULL;
	OS_GetMem(pool, &pointer, size);
	return pointer;
}
void  *KL_GetMemZ(KL_mempool_t *pool, u32_t size)
{
	void *pointer;
	OS_GetMem(pool, &pointer, size);
	if (pointer){
		memset(pointer, 0, size);
	}
	return pointer;
}
void  *KL_ReGetMem(KL_mempool_t *pool, void *ptr, u32_t newsize)
{
	void *newptr = NULL;
	OS_GetMem(pool, &newptr, newsize);
	if (newptr){
		memcpy(newptr, ptr, newsize);
		OS_FreeMem(ptr);
	}
	return newptr;
}
Status KL_FreeMem(void *ptr)
{
	INT8U err;
	err = OS_FreeMem(ptr);
	return (Status)(-err);
}
Status KL_QueryMemPoolInfo(KL_mempool_t *pool)
{
	return KL_SUCCESS;
}

void *KL_calloc(u32_t num, u32_t size)
{
	return OS_calloc(num, size);
}
void *KL_malloc(u32_t size)
{
	return OS_malloc(size);
}
void *KL_realloc(void *ptr, u32_t newsize)
{
	return OS_realloc(ptr, newsize);
}
void  KL_free(void *ptr)
{
	OS_free(ptr);
}

/*--------------------------------------------------------------
  Mailbox , only can hold one mail of fixed size (4 bytes)
----------------------------------------------------------------*/
Status KL_CreateMailbox(KL_mailbox_t *mailbox, u8_t *name)
{
	OS_EVENT  *p;
	
	#if KL_CHK_ARG_EN
	if (mailbox == NULL) return KL_INVALID_MAILBOX;
	#endif

	name = name;

	p = OSMboxCreate(NULL);

	if (p != NULL){
		*mailbox = (KL_mailbox_t)p;
		return KL_SUCCESS;
	}
	return KL_UNKNOWN_ERROR;
}

Status KL_DelMailbox(KL_mailbox_t *mailbox)
{
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (mailbox == NULL) return KL_INVALID_MAILBOX;
	#endif

	OSMboxDel((OS_EVENT *)(*mailbox), OS_DEL_ALWAYS, &err);

	return (Status)(-err);
}

Status KL_SendMail(KL_mailbox_t *mailbox, void *msg, u32_t timeout)
{
	OS_EVENT  *p;
	u32_t cnt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (mailbox == NULL) return KL_INVALID_MAILBOX;
	#endif

	p = (OS_EVENT *)(*mailbox);
	cnt = timeout;
	
	err = OSMboxPostOpt(p, msg, OS_POST_OPT_NONE);

	while((err == OS_MBOX_FULL)&&(cnt--)){
		if (timeout == KL_SUSPEND_FOREVER) cnt++;
		OSTimeDly(1);
		err = OSMboxPostOpt(p, msg, OS_POST_OPT_NONE);
	}
	
	if ((timeout > 0)&&(err == OS_MBOX_FULL)&&(cnt == 0)) 
		return KL_TIMEOUT;
	return (Status)(-err);
}

Status KL_BroadcastMail(KL_mailbox_t *mailbox, void *msg, u32_t timeout)
{
	OS_EVENT  *p;
	u32_t cnt;
	INT8U err;
	
	#if KL_CHK_ARG_EN
	if (mailbox == NULL) return KL_INVALID_MAILBOX;
	#endif

	p = (OS_EVENT *)(*mailbox);
	cnt = timeout;

	err = OSMboxPostOpt(p, msg, OS_POST_OPT_BROADCAST);
	
	while((err == OS_MBOX_FULL)&&(cnt--)){
		if (timeout == KL_SUSPEND_FOREVER) cnt++;
		OSTimeDly(1);
		err = OSMboxPostOpt(p, msg, OS_POST_OPT_NONE);
	}
	
	if ((timeout > 0)&&(err == OS_MBOX_FULL)&&(cnt == 0)) 
		return KL_TIMEOUT;
	return (Status)(-err);
}