kernel_cfg.i

免费的OS源代码 符合ITRON4.0规范 http://www.toppers.jp/official_release.html

 



 
#pragma inline current_intmask

UH
current_intmask()
{
	return(current_sr() & 0x7000);
}



 
#pragma inline set_intmask

void
set_intmask(UH intmask)
{
	set_sr((current_sr() & ~0x7000) | intmask);
}



 

#pragma inline sense_context

BOOL
sense_context()
{
	__ASM("	ldc	hl, intnest");
	return __HL;
}

#pragma inline sense_lock

BOOL
sense_lock()
{
	return(current_intmask() == 0x7000);
}

#pragma define t_sense_lock sense_lock
#pragma define i_sense_lock sense_lock






 


extern UH	_kernel_task_intmask;	 


#pragma inline t_lock_cpu

void
t_lock_cpu()
{
	disint();
}

#pragma inline t_unlock_cpu

void
t_unlock_cpu()
{

	


 
	set_intmask(_kernel_task_intmask);

	

}



 

extern UH	_kernel_int_intmask;	 

#pragma inline i_lock_cpu

void
i_lock_cpu()
{
	UH	intmask;

	



 
	intmask = current_intmask();
	disint();
	_kernel_int_intmask = intmask;
}

#pragma inline i_unlock_cpu

void
i_unlock_cpu()
{
	set_intmask(_kernel_int_intmask);
}



 






 
extern void	_kernel_dispatch(void);





 
extern void	_kernel_exit_and_dispatch(void);



 







 

#pragma inline define_inh

void
define_inh(INHNO inhno, FP inthdr)
{
}







 
#pragma inline define_exc

void
define_exc(EXCNO excno, FP exchdr)
{
}




 

















 
















 














 

















 






 



 
#pragma inline exc_sense_context

BOOL
exc_sense_context(VP p_excinf)
{
	__ASM("	ldc	hl, intnest");
	return ( __HL > 1 );
}



 
#pragma inline exc_sense_lock

BOOL
exc_sense_lock(VP p_excinf)
{
	return ((*((UH *) p_excinf) & 0x7000) == 0x7000);
}



 
extern void	_kernel_cpu_initialize(void);



 
extern void	_kernel_cpu_terminate(void);






 




































 






 






 




 




 


#pragma inline call_atexit

 void
call_atexit()
{





}





 






























































































































































































 
#pragma define TMIN_TSKID 1
#pragma define TMIN_SEMID 1
#pragma define TMIN_FLGID 1
#pragma define TMIN_DTQID 1
#pragma define TMIN_MBXID 1
#pragma define TMIN_MPFID 1
#pragma define TMIN_CYCID 1



 
#pragma define TNUM_TPRI (TMAX_TPRI - TMIN_TPRI + 1)
#pragma define TNUM_MPRI (TMAX_MPRI - TMIN_MPRI + 1)



 




 




 
extern void	_kernel_object_initialize(void);



 
extern void	_kernel_call_inirtn(void);



 
extern void	_kernel_call_terrtn(void);



 
extern void	_kernel_print_banner(void);



 
extern void	kernel_exit(void);



 
extern BOOL	_kernel_iniflg;






 





































 



 









































 










 






 
typedef struct queue {
	struct queue *next;		 
	struct queue *prev;		 
} QUEUE;





 
 void
queue_initialize(QUEUE *queue)
{
	queue->prev = queue->next = queue;
}






 
 void
queue_insert_prev(QUEUE *queue, QUEUE *entry)
{
	entry->prev = queue->prev;
	entry->next = queue;
	queue->prev->next = entry;
	queue->prev = entry;
}





 
 void
queue_delete(QUEUE *entry)
{
	entry->prev->next = entry->next;
	entry->next->prev = entry->prev;
}







 
 QUEUE *
queue_delete_next(QUEUE *queue)
{
	QUEUE	*entry;

	((void)(!(queue->next != queue) ? (_syslog_3(0u, 0x0au, (VP_INT)("D:\\jsp141_win\\tools\\TLCS900L1-TOSHIBA\\../../kernel\\queue.h"), (VP_INT)(111), (VP_INT)("queue->next != queue")), kernel_abort(), 0) : 0));
	entry = queue->next;
	queue->next = entry->next;
	entry->next->prev = queue;
	return(entry);
}





 
 BOOL
queue_empty(QUEUE *queue)
{
	if (queue->next == queue) {
		((void)(!(queue->prev == queue) ? (_syslog_3(0u, 0x0au, (VP_INT)("D:\\jsp141_win\\tools\\TLCS900L1-TOSHIBA\\../../kernel\\queue.h"), (VP_INT)(127), (VP_INT)("queue->prev == queue")), kernel_abort(), 0) : 0));
		return(1);
	}
	return(0);
}







































 



 











 
typedef UW	EVTTIM;



 
#pragma define TMAX_RELTIM ((((EVTTIM) 1) << (sizeof(EVTTIM) * CHAR_BIT - 1)) - 1)



 
typedef void	(*CBACK)(VP);	 

typedef struct time_event_block {
	UINT	index;		 
	CBACK	callback;	 
	VP	arg;		 
} TMEVTB;



 
typedef struct time_event_node {
	EVTTIM	time;		 
	TMEVTB	*tmevtb;	 
} TMEVTN;



 
extern TMEVTN	_kernel_tmevt_heap[];



 
extern SYSTIM	_kernel_systim_offset;






 
extern SYSTIM	_kernel_current_time;



 
extern SYSTIM	_kernel_next_time;






 









 

#pragma define base_time ((EVTTIM) next_time)








 
extern UINT	_kernel_last_index;



 
extern void	_kernel_tmevt_initialize(void);



 
extern UINT	_kernel_tmevt_up(UINT index, EVTTIM time);
extern UINT	_kernel_tmevt_down(UINT index, EVTTIM time);



 
extern void	_kernel_tmevtb_insert(TMEVTB *tmevtb, EVTTIM time);
extern void	_kernel_tmevtb_delete(TMEVTB *tmevtb);






 
 void
tmevtb_enqueue(TMEVTB *tmevtb, RELTIM time, CBACK callback, VP arg)
{
	((void)(!(time <= (RELTIM)((((EVTTIM) 1) << (sizeof(EVTTIM) * 8 - 1)) - 1)) ? (_syslog_3(0u, 0x0au, (VP_INT)("D:\\jsp141_win\\tools\\TLCS900L1-TOSHIBA\\../../kernel\\time_event.h"), (VP_INT)(158), (VP_INT)("time <= (RELTIM)TMAX_RELTIM")), kernel_abort(), 0) : 0));

	tmevtb->callback = callback;
	tmevtb->arg = arg;
	_kernel_tmevtb_insert(tmevtb, ((EVTTIM) _kernel_next_time) + time);
}






 
 void
tmevtb_enqueue_evttim(TMEVTB *tmevtb, EVTTIM time, CBACK callback, VP arg)
{
	tmevtb->callback = callback;
	tmevtb->arg = arg;
	_kernel_tmevtb_insert(tmevtb, time);
}



 
 void
tmevtb_dequeue(TMEVTB *tmevtb)
{
	_kernel_tmevtb_delete(tmevtb);
}





 










 
#pragma define TS_DORMANT 0x00u
#pragma define TS_RUNNABLE 0x01u
#pragma define TS_WAITING 0x02u
#pragma define TS_SUSPENDED 0x04u

#pragma define TS_WAIT_SLEEP 0x08u
#pragma define TS_WAIT_WOBJ 0x10u
#pragma define TS_WAIT_WOBJCB 0x20u








 














































 
typedef union waiting_information {
	ER	wercd;		 
	TMEVTB	*tmevtb;	 
} WINFO;













 
typedef struct task_initialization_block {
	ATR	tskatr;		 
	VP_INT	exinf;		 
	FP	task;		 
	UINT	ipriority;	 
	SIZE	stksz;		 
	VP	stk;		 

	ATR	texatr;		 
	FP	texrtn;		 
} TINIB;






 
















 
typedef struct task_control_block {
	QUEUE	task_queue;	 
	const TINIB *tinib;	 

	UINT	tstat : 8;		 
	UINT	priority : 4;	 
	unsigned int	actcnt : 1;		 
	unsigned int	wupcnt : 1;		 
	unsigned int	enatex : 1;		 

	TEXPTN	texptn;		 
	WINFO	*winfo;		 
	CTXB	tskctxb;	 
} TCB;









 
extern TCB	*_kernel_runtsk;








 
extern TCB	*_kernel_schedtsk;






 
extern BOOL	_kernel_reqflg;






 
extern BOOL	_kernel_enadsp;







 
extern QUEUE	_kernel_ready_queue[(16 - 1 + 1)];










 
extern UINT	_kernel_ready_primap;



 
extern const ID	_kernel_tmax_tskid;



 
extern const TINIB	_kernel_tinib_table[];



 
extern const ID	_kernel_torder_table[];



 
extern TCB	_kernel_tcb_table[];



 
#pragma define TNUM_TSK ((UINT)(tmax_tskid - TMIN_TSKID + 1))



 






 




 
extern void	_kernel_task_initialize(void);






 
extern TCB	*_kernel_search_schedtsk(void);








 
extern BOOL	_kernel_make_runnable(TCB *tcb);








 
extern BOOL	_kernel_make_non_runnable(TCB *tcb);







 
extern void	_kernel_make_dormant(TCB *tcb);







 
extern BOOL	_kernel_make_active(TCB *tcb);










 
extern void	_kernel_exit_task(void);








 
extern BOOL	_kernel_change_priority(TCB *tcb, UINT newpri);







 
extern BOOL	_kernel_rotate_ready_queue(UINT pri);















 
extern void	_kernel_call_texrtn(void);











 
extern void	_kernel_calltex(void);







































 


 









































 










 






 

	
	






 



	







 



	
	
	
	






 



	
	








 



	

	
	
	
	
	






 



	
		
		
	
	






 
typedef struct semaphore_initialization_block {
	ATR	sematr;		 
	UINT	isemcnt;	 
	UINT	maxsem;		 
} SEMINIB;



 
typedef struct semaphore_control_block {
	QUEUE	wait_queue;	 
	const SEMINIB *seminib;	 
	UINT	semcnt;		 
} SEMCB;



 
extern void	_kernel_semaphore_initialize(void);







































 


 









































 










 






 

	
	






 



	







 



	
	
	
	






 



	
	








 



	

	
	
	
	
	






 



	
		
		
	
	






 
typedef struct eventflag_initialization_block {
	ATR	flgatr;		 
	FLGPTN	iflgptn;	 
} FLGINIB;



 
typedef struct eventflag_control_block {
	QUEUE	wait_queue;	 
	const FLGINIB *flginib;	 
	FLGPTN	flgptn;		 
} FLGCB;



 
extern void	_kernel_eventflag_initialize(void);



 
extern BOOL	_kernel_eventflag_cond(FLGCB *flgcb, FLGPTN waiptn,
					MODE wfmode, FLGPTN *p_flgptn);







































 


 









































 










 






 

	
	






 



	







 



	
	
	
	






 



	
	








 



	

	
	
	
	
	






 



	
		
		
	
	






 
typedef struct dataqueue_initialization_block {
	ATR	dtqatr;		 
	UINT	dtqcnt;		 
	VP	dtq;		 
} DTQINIB;



 
typedef struct dataqueue_control_block {
	QUEUE	swait_queue;	 
	const DTQINIB *dtqinib;	 
	QUEUE	rwait_queue;	 
	UINT	count;		 
	UINT	head;		 
	UINT	tail;		 
} DTQCB;



 
extern void	_kernel_dataqueue_initialize(void);



 
extern BOOL	_kernel_enqueue_data(DTQCB *dtqcb, VP_INT data);



 
extern void	_kernel_force_enqueue_data(DTQCB *dtqcb, VP_INT data);



 
extern BOOL	_kernel_dequeue_data(DTQCB *dtqcb, VP_INT *p_data);



 
extern TCB	*_kernel_send_data_rwait(DTQCB *dtqcb, VP_INT data);



 
extern TCB	*_kernel_receive_data_swait(DTQCB *dtqcb, VP_INT *p_data);







































 


 









































 










 






 

	
	






 



	







 



	
	
	
	






 



	
	








 



	

	
	
	
	
	






 



	
		
		
	
	






 
typedef struct mailbox_initialization_block {
	ATR	mbxatr;		 
	PRI	maxmpri;	 
} MBXINIB;





 
typedef struct mailbox_control_block {
	QUEUE	wait_queue;	 
	const MBXINIB *mbxinib;	 
	T_MSG	*head;		 
	T_MSG	*last;		 
} MBXCB;



 
extern void	_kernel_mailbox_initialize(void);







































 


 









































 










 






 

	
	






 



	







 



	
	
	
	






 



	
	








 



	

	
	
	
	
	






 



	
		
		
	
	






 
typedef struct fixed_memorypool_initialization_block {
	ATR	mpfatr;		 
	UINT	blksz;		 
	VP	mpf;		 
	VP	limit;		 
} MPFINIB;



 
typedef struct free_list {
	struct free_list *next;
} FREEL;



 
typedef struct fixed_memorypool_control_block {
	QUEUE	wait_queue;	 
	const MPFINIB *mpfinib;	 
	VP	unused;		 
	FREEL	*freelist;	 
} MPFCB;



 
extern void	_kernel_mempfix_initialize(void);



 
extern BOOL	_kernel_mempfix_get_block(MPFCB *mpfcb, VP *p_blk);