asixapp.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

			 
/* every task call this func before its ending*/
STATUS EndofTask(void)
{
	register U8 	i;
	//STATUS			rv;
	ASIX_WINDOW 	*curwin;
	SYSTCB			*curtask;
	
	#ifdef ASIX_DEBUG
	//char	dispstr[20];
	#endif


	curwin =(ASIX_WINDOW *) GetCurWindow();
	curtask = GetCurTask();
	
	while (curwin!=NULL) {
		if (DestroyWindow((U32)curwin)!=ASIX_OK) {
			/* if there has error in this node destroying 
				we just pass it, and destroy the previous */
			#ifdef ASIX_DEBUG
				//pessia
				//sprintf(dispstr,"Kill%h Err", (U32)CurWindow);
				//TextOut(0, dispstr, 1, 30, HZK_16X16_FONT, BLACK, REPLACE_STYLE);
				while(1);
			#endif
			curwin = curwin->next;
			if ( curwin !=NULL ) curwin->prev = NULL;
		}
	}
	//CurTask->status = ASIX_TASK_KILLING;
	
	/* Clear CurTask's SysMenu */
	for (i = 0; i < MAX_SYSMENU && SysMenu_Taskptr[i] != curtask; i++);
	if (SysMenu_Taskptr[i] == curtask )	
	{
		SysMenu_Item[i].item_status = 0;	
		MoveBlock((P_U32)&SysMenu_Taskptr[i+1], (P_U32)&SysMenu_Taskptr[i], (MAX_SYSMENU-i)*sizeof(SYSTCB *));
		MoveBlock((P_U32)&SysMenu_Item[i+1], (P_U32)&SysMenu_Item[i], (MAX_SYSMENU-i)*sizeof(struct MENU_ITEM)); 	
	}

	// longn_qi 2002/09/10 added
	// If this task is dynamic task, unregister this task
	if( curtask->description != NULL && curtask->description->desp->mode == ASIX_DYNAPP )
		TaskUnRegist( curtask->description );
	
	// Delete all the messages of this task. LM 01/05/17 	
	AdvMessageDelete(curtask->id, 0xffff, 0xffffffff);
	
	/* Delete this task */
	TaskTerminate(curtask->id);
	
	return ASIX_OK; //saticfied the lint
}


SYSTCB *TaskLookUp(TASKDESCRIPTION *desptr)
{
	register SYSTCB	*listptr;
//	TASKDESCRIPTIONLIST	*desplst;
	
	if ( desptr==NULL || desptr->entry==NULL )  	return NULL;


	for (listptr=TaskHead; listptr!=NULL; listptr=listptr->next){
		if (listptr->description->desp->entry == desptr->entry )
			break;
	}
	
	if (listptr==NULL) return NULL;
	
	return listptr;
}

STATUS EntryCallBack( U32 prev_taskid)
{
	register SYSTCB 		*task_ptr;
	//register SYSTCB 		*temp_ptr;
	//register ASIX_WINDOW	*wndptr;	
	//U16						padx=0,pady=0;

	/*The first one must be the current window*/
	//CurWindow = CurTask->wnd_ptr;

	/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
	/*Here must has some problems !  By lingming 2002/03/09*/
	//we have no FoucusWindow Now!! LM 2002/03/20
	//FocusWindow = FocusLookUp( GetCurWindow() ); //restore the focus
	/**********************************************************/


	task_ptr= (SYSTCB *)prev_taskid;
	
	if (task_ptr == NULL) {
		 return ASIX_OK;
	} else {
		/*
		if (CurWindow != NULL)
			if (CurWindow->status & WST_HANDWRITE) {
				// reopen the closed inputpad, this operation cross the layer, but 
				// for special control we have to do this
				for (wndptr = CurWindow->child; wndptr!= NULL && wndptr->wndclass->wndclass_id!=WNDCLASS_KEYBD;
					wndptr = wndptr->next);				
				if ( wndptr != NULL ){
					padx = ((struct kb_ctrl *)(wndptr->ctrl_str))->inputpad_x;
					pady = ((struct kb_ctrl *)(wndptr->ctrl_str))->inputpad_y;
					//PenIrptDisable();
					AdvOpenInputPad(padx,pady,1,2,65,75,BLACK,2,800,50,1,2048);
					//PenIrptEnable();
				}	
			}
		*/
	}			
	return ASIX_OK;//test
}

STATUS ExitCallBack ( U32 next_taskid)
{
	register SYSTCB *task_ptr;
	
	task_ptr= (SYSTCB *)next_taskid;
	
	if (task_ptr == NULL) {
		 return ASIX_OK;
	} else {
		
		/*//pessia
		if ( next_taskid == SysDeamonTask->id ) {
			DeamonInfor[ASIX_SYSDEAMON].from_where = CurTask->id;
			DeamonInfor[ASIX_SYSDEAMON].cnt++;
		} else if ( next_taskid == SysSleepTask->id ) {
			DeamonInfor[ASIX_SLEEP].from_where = CurTask->id;
			DeamonInfor[ASIX_SLEEP].cnt++;;
		}
		*/
		//CurTask = task_ptr; /*we will swap to it *///pessia
		//task_ptr->status = ASIX_TASK_RUNNING;//pessia
		
		/*//pessia
		if (CurWindow != NULL)
			if (CurWindow->status & WST_HANDWRITE){
				PenIrptDisable();
				CloseInputPad();
				PenIrptEnable();
			}
		*/
	}

	//Get the new task's font size. By Lingming 2001/11/28
	GetFontSize((U32)(task_ptr->gc), &ENGLISH_CHAR_WIDTH, &ENGLISH_CHAR_HEIGHT,\
	&CHINESE_CHAR_WIDTH, &CHINESE_CHAR_HEIGHT);

	return ASIX_OK;//test
}

/*
TASKDESCRIPTION *TaskRegist(TASKDESCRIPTION *tasktemp)
{

	TASKDESCRIPTION 	*taskptr, *listptr;
	
	if (tasktemp == NULL || tasktemp->entry==NULL) return NULL;
	
	taskptr = (TASKDESCRIPTION *)Lcalloc(sizeof(TASKDESCRIPTION));
	if ( taskptr == NULL) return NULL;
	
	memcpy(taskptr, tasktemp, sizeof(TASKDESCRIPTION));//pessia
	
	if ( TaskDescription == NULL ) {
		TaskDescription = taskptr;
		return TaskDescription;
	}
	
	//looking for the correct point
	for (listptr = TaskDescription; listptr->next != NULL; listptr = listptr->next );
	 
	listptr->next = taskptr;
	taskptr->prev = listptr;
		
	return taskptr;

}

STATUS TaskUnRegist(TASKDESCRIPTION *taskptr)
{
	TASKDESCRIPTION 	*listptr;
	
	if (taskptr == NULL || taskptr->entry==NULL) return ASIX_ERROR;
	
	//looking for the correct point
	for (listptr = TaskDescription; listptr!=NULL && listptr!=taskptr ; listptr = listptr->next );
	
	if (listptr == NULL) return ASIX_ERROR; //not found!
	
	if (listptr->prev != NULL )
		listptr->prev->next = listptr->next;
	if (listptr->next != NULL )
		listptr->next->prev = listptr->prev;
	
	Lfree(taskptr);
	
	return ASIX_OK;

}
*/
TASKDESCRIPTIONLIST *TaskRegist(TASKDESCRIPTION *tasktemp)
{
	DWORD	*stack, stksize;
	TASKDESCRIPTIONLIST 	*desplst, *listptr;
	ID		id;
	
	if( tasktemp == NULL )	// parameter error
		return NULL;
	
	desplst = IsRegistered( tasktemp );
	if( desplst != NULL )	// already registered
		return desplst;
	
	id = DynAllocateTskID();
	if( id == 0 )	// reach to limitation
		return NULL;

	desplst = (TASKDESCRIPTIONLIST *)Lcalloc(sizeof(TASKDESCRIPTIONLIST));
	if( desplst == NULL )
		goto ERROR_HANDLE;
	
	stksize = (tasktemp->stksize+3) / 4;
	stack = (DWORD *)SysLmalloc( sizeof(DWORD) * stksize ); 
	if( stack == NULL )
		goto ERROR_HANDLE;
	
	{
		DWORD	i;

		for( i = 0; i < stksize; i += 4 )
			memcpy( &stack[i], "STK_WATER_MARKER", 16 );
	}

	desplst->desp = tasktemp;
	desplst->taskid = id;
	desplst->stack = stack;

	// create task
	vcre_tsk( id,  tasktemp->entry,  tasktemp->pri, (U32)(stack + stksize-1) );
	gSysTcbTbl[id-1].status = DORMANT;
	gSysTcbTbl[id-1].description = desplst;
//	gSysTcbTbl[id-1].group = tasktemp->group;
//	gSysTcbTbl[id-1].icon = (char *)tasktemp->icon;
	
	// register task
	if ( TaskDescription == NULL ) {
		TaskDescription = desplst;
		return TaskDescription;
	}
	
	// looking for the correct point
	for (listptr = TaskDescription; listptr->next != NULL; listptr = listptr->next );
	 
	listptr->next = desplst;
	desplst->prev = listptr;
		
	return desplst;

ERROR_HANDLE:
	Lfree( desplst );
	Lfree( stack );
	DynFreeTskID( id );

	return NULL;
}

STATUS TaskUnRegist( TASKDESCRIPTIONLIST *taskptr )
{
	TASKDESCRIPTIONLIST 	*listptr;
	
	if( taskptr == NULL )
		return ASIX_ERROR;

	if( taskptr->taskid < APP_ID_BEGIN )	// only application can be unregistered
		return ASIX_ERROR;
	
	/*looking for the correct point*/
	for( listptr = TaskDescription; listptr!=NULL && listptr!=taskptr ; listptr = listptr->next );
	
	if( listptr == NULL ) //not found!
		return ASIX_ERROR;
	
	if( taskptr->desp->group != ASIX_DYNAPP )	// only dynamic application can be unregistered
		return ASIX_OK;
	
	if (listptr->prev != NULL )
		listptr->prev->next = listptr->next;
	if (listptr->next != NULL )
		listptr->next->prev = listptr->prev;

	DynFreeTskID( taskptr->taskid );

	Lfree(taskptr);
	
	return ASIX_OK;

}

TASKDESCRIPTIONLIST *IsRegistered( TASKDESCRIPTION *taskdes )
{
	TASKDESCRIPTIONLIST *p;

	p = TaskDescription;
	while( p != NULL )
	{
		if( p->desp == taskdes )
			break;
		p = p->next;
	}
	
	return p;
}

DWORD DynAllocateTskID( void )
{
	DWORD	id;

	if( DynTaskHead == NULL )
		return 0;

	id = (DWORD)(DynTaskHead - gSysTcbTbl +1);
	DynTaskHead = DynTaskHead->next;

	return id;
}

void DynFreeTskID( DWORD id )
{
	if( id < APP_ID_BEGIN || id > TASKNUM )
		return;

	if( gSysTcbTbl[id-1].status != DORMANT )
		return;

	//if( gSysTcbTbl[id-1].description->desp->mode != ASIX_DYNAPP )
	//	return;
	
	gSysTcbTbl[id-1].next = DynTaskHead;
	DynTaskHead = &gSysTcbTbl[id-1];

	return;
}

DWORD GetDynTaskID( TASKDESCRIPTION *taskdes )
{
	SYSTCB	*pHead;

	if( taskdes == NULL || taskdes->mode != ASIX_DYNAPP )
		return 0;
	
	pHead = DynTaskHead;
	
	while( pHead != NULL )
	{
		if( pHead->description->desp == taskdes )
			break;
		pHead = pHead->next;
	}

	if( pHead == NULL )
		return 0;
	else
		return pHead->description->taskid;
}

SYSTCB *GetCurTask(void)
{
 	ID		id;

	get_tid( &id );
	return  (SYSTCB *)&gSysTcbTbl[id-1];

}

U32 GetCurTaskID(void)
{
 	ID		id;

	get_tid( &id );
	return  id;

}

/* The Backend System service */
void SysDeamon(void)
{
	while(1){};	
}

/* The Backend System Power saving */
void SysSleep(void)
{
	while(1){};
}