pg_drvenv.c

一个移植到凌阳单片机spce061a上面的实时操作系统

///////////////////////////////////////////////////////////////
//
//
//   PGOS : A Portable,Configable Embedded System Kernel
//
//             
//
//   This is an open source project under GPL lincence  
//
//        Version 0.9.0 ---- Development Snopshot
//  
//   For Technology Support,please mail [e-mail]
//
//   File name : pg_task.c : Driver Executions  
//   History :
//
//          2005-08-03  First build by X.K. @ PGOS Team 
//          2005-08-09  Fix a bug in pgos_drv_install
//          2005-08-09  Upgrade function pgos_drv_install  
//                 
/////////////////////////////////////////////////////////////////


#include "pgos.h"
#include "stdio.h"
#include "stdlib.h"

#if  PG_DRV_SUPPORT == 1

SYS_DRV_LIST*  Drivers ;       // Driver list
SYS_DRV_LIST*  DrvTail ;       // Driver list tail
BYTE           DrvInstalled ;  // Driver install flag
BYTE           DrvNum ;        // Driver numbers

PGOS_STATUS pgos_drv_initalize( void )
{
	 Drivers = ( SYS_DRV_LIST * )malloc( sizeof( SYS_DRV_LIST ) );
	 if( !Drivers )
	 	 return PGOS_FAIL_MEM ;
	 Drivers->drv = ( DRIVER * )malloc( sizeof( DRIVER ) );
	 if( !Drivers->drv )
	 	 return PGOS_FAIL_MEM ;
	 Drivers -> next = NULL ;	
	 
	 DrvTail = Drivers ;
	 DrvNum = 0 ;
	 DrvInstalled = DRV_NOT_INSTALL ;
	 
	 return PGOS_SUCCESS ;
}

PGOS_STATUS pgos_drv_install( DRIVER_ENTRY Entry, BYTE DrvType, BYTE* DrvID, BYTE* CbkType )
{
	 SYS_DRV_LIST*  NewDrvNode ;
	 DRIVER*  NewDriver ;
	 
	 if( DrvNum == MAX_DRIVERS )
	 	  return PGOS_FAIL_NM ;
	 	   
	 if( !pgos_tk_msg() && DrvType == CALLBACK_DRV 
	 	                       && 
	 	   ( *CbkType == MSG_SEND || *CbkType == MSG_RECV ) )
	 {
	 	  return PGOS_FAIL_NM ;
	 }  
	 	
	 if( DrvInstalled == DRV_NOT_INSTALL )
	 {
	 	  Drivers -> drv -> EntryPoint = Entry ;
	 	  Drivers -> drv -> DrvTypes = DrvType ;
	 	  if( DrvType == CALLBACK_DRV )
	 	  {
	 	  	  if( CbkType )
	 	  	  {
	 	  	  	 Drivers -> drv -> CbkType = *CbkType ;
	 	  	  	 Drivers -> drv -> DrvID = DrvNum ++ ;
	 	  	  }
	 	  	  else
	 	  	  {
	 	  	  	 return PGOS_FAIL_NM ;
	 	  	  }
	 	  }
	 	  DrvInstalled = DRV_INSTALL ;
	 	  *DrvID = DrvNum  ; 
	 	  return PGOS_SUCCESS ;
	 }
	 	   
	 NewDrvNode = ( SYS_DRV_LIST * )malloc( sizeof( SYS_DRV_LIST ) );
	 if( !NewDrvNode )
	 	 return PGOS_FAIL_MEM ;
	 NewDriver = ( DRIVER * )malloc( sizeof( DRIVER ) );
	 if( !NewDriver )
	 	 return PGOS_FAIL_MEM ;
	 NewDrvNode -> next = NULL ;
	 
	 NewDriver -> DrvTypes = DrvType ;
	 NewDriver -> EntryPoint = Entry ;
	 NewDriver -> DrvID = DrvNum ++ ;
	 
	 if( DrvType == CALLBACK_DRV )
	 {
	 	  if( CbkType  )
	 	    NewDriver -> CbkType = *CbkType ;
	 	  else
	 	  	return PGOS_FAIL_NM ;  
	 }
	
	 DrvTail -> next = NewDrvNode ;
	 NewDrvNode -> drv = NewDriver ;
	 DrvTail = NewDrvNode ;
	 
	 if( DrvInstalled != DRV_INSTALL )
	 	  DrvInstalled = DRV_INSTALL ;
	 *DrvID = DrvNum ; 
	 
	 return PGOS_SUCCESS ;
}
	 	  
void pgos_call_drv( BYTE CallEnv, void* info )
{
	  SYS_DRV_LIST* DriverNode = Drivers ;
	  DRIVER*  CallDrv = NULL ;
	  BYTE     Type = 0 ;
	  	  
	  if( DrvInstalled == DRV_NOT_INSTALL )
	  	return ;
	  
	  pgos_int_disable();
	  
	  for( ; DriverNode ; )
	  {
	  	CallDrv = DriverNode -> drv ;
	  	Type = CallDrv -> CbkType ;
	  	switch( CallEnv )
	  	{
	  		 case SYS_KERNEL :
	  		 	  if( 
	  		 	  	  CallDrv -> DrvTypes != CALLBACK_DRV
	  		 	  	               &&
	  		 	  	  CallDrv -> DrvTypes != HARDWARE_DRV      
	  		 	  	)
	  	      {
	  	      	 // Run user driver entry functions 
	  	      	 CallDrv -> EntryPoint . ServiceDriver( ) ;
	  	      }
	  	      else
	  	      {
	  	      	  // Run Kernel Call Back 
	  	      	  if( ( Type & KERNEL ) == KERNEL )
	  	      	      CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	      }
	  	      break ;
	  	   ///////////////////////////////////////////
	  	   // Because we has already process the timer,
	  	   // task sw/cre/remove
	  	   //////////////////////////////////////////   
	  	   case SYS_INT :
	  	   	  if( CallDrv -> DrvTypes == HARDWARE_DRV )
	  	   	  {
	  	   	  	 CallDrv -> EntryPoint . HardwareDriver( 0 ) ;
	  	   	  }
            break ;    
	  	   case SYS_TK_SW :
	  	   	  if( CallDrv -> DrvTypes == CALLBACK_DRV )
	  	   		{
	  	   			 if( ( Type & TASK_SCH ) == TASK_SCH )
	  	   			 {
	  	   			 	  CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	   			 }
	  	   	  }
	  	   	  break ;
	  	   case SYS_TK_C :
	  	   	  if( CallDrv -> DrvTypes == CALLBACK_DRV )
	  	   		{
	  	   			 if( ( Type & TASK_CREATE ) == TASK_CREATE )
	  	   			 {
	  	   			 	  CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	   			 }
	  	   	  }
	  	   	  break ;
	  	   case SYS_TK_R :
	  	   		if( CallDrv -> DrvTypes == CALLBACK_DRV )
	  	   		{
	  	   			 if( ( Type & TASK_REMOVE ) == TASK_REMOVE )
	  	   			 {
	  	   			 	  CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	   			 }
	  	   	  }
	  	   	  break ;	
	  	   case SYS_TIMER :
	  	   	  if( CallDrv -> DrvTypes == CALLBACK_DRV )
	  	   		{
	  	   			 if( ( Type & TIME_BASED ) == TIME_BASED )
	  	   			 {
	  	   			 	  CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	   			 }
	  	   	  }
	  	   	  break ;
	  	   case SYS_MSG_R :
	  	   	  if( CallDrv -> DrvTypes == CALLBACK_DRV )
	  	   		{
	  	   			 if( ( Type & MSG_RECV ) == MSG_RECV )
	  	   			 {
	  	   			 	  CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	   			 }
	  	   	  }
	  	   	  break ;
	  	   case SYS_MSG_S :
	  	   	  if( CallDrv -> DrvTypes == CALLBACK_DRV )
	  	   		{
	  	   			 if( ( Type & MSG_SEND ) == MSG_SEND )
	  	   			 {
	  	   			 	  CallDrv -> EntryPoint . CallBackDriver( info ) ;
	  	   			 }
	  	   	  }
	  	   	  break ;
	  	   default :
	  	   	  break ;
	  	}     	                     
	  	DriverNode = DriverNode -> next ;
	  }
	  
	  pgos_int_enable() ;  
}


#endif