vxworks2linux.c

ks8695的ide硬盘程序

    struct msqid_ds msg_info;
        
    if (msgctl(msgQId,IPC_STAT,&msg_info) == ERROR)
    {
        return ERROR;
    }
    else
    {
        return msg_info.msg_qnum;
    }
}

void VxSemLibInit(void)
{
  int i;
  for(i=0;i<MAXSEM;i++)
  {
    VxSem[i].Used = 0;
  }
}
/******************************************************
  函数名：semBCreate
  
  功能：创建二进制信号量
  
  返回值说明：成功将返回信号量ID, 失败将返回0
*******************************************************/
SEM_ID semBCreate(int options,int initialState)
{
  int i;
  /*
  SemID = semget(IPC_PRIVATE, 1, IPC_CREAT|IPC_EXCL|0666);
  if(SemID < 0)
  {
    return(NULL);
  }
 
  if(
   */
  if(initialState > 1)
    return(NULL);
  for(i=0;i<MAXSEM;i++)
  {
    if(0 == VxSem[i].Used)
      break;
  }
  if(i >= MAXSEM)
    return(NULL);
  if(sem_init(&VxSem[i].Sem,0,initialState)< 0 )
  {
    return(NULL);
  }
  else
  {
    VxSem[i].Used = 1;
    if(initialState == 1)
      sem_post(&VxSem[i].Sem);
    return(&VxSem[i]);
  }
}

/******************************************************
  函数名：semBCreate
  
  功能：创建二进制信号量
  
  返回值说明：成功将返回信号量ID, 失败将返回0
*******************************************************/
SEM_ID semMCreate(int options)
{
  int i;
  int initialState=1;
  
  if(initialState > 1)
    return(NULL);
  for(i=0;i<MAXSEM;i++)
  {
    if(0 == VxSem[i].Used)
      break;
  }
  if(i >= MAXSEM)
    return(NULL);
  if(sem_init(&VxSem[i].Sem,0,1)< 0 )
  {
    return(NULL);
  }
  else
  {
    VxSem[i].Used = 1;
    if(initialState == 1)
      sem_post(&VxSem[i].Sem);
    return(&VxSem[i]);
  }
}

/******************************************************
  函数名：semTake
  
  功能：获取信号量
  SEM_ID semId,      信号id 
  int      timeout  NO_WAIT(立即返回),WAIT_FOREVER(阻塞，直到队列信号量有效) 
  
  返回值说明：成功返回OK, 失败将返回ERROR(-1)
*******************************************************/
int semTake(SEM_ID semId,int timeout)
{
  if (timeout == NO_WAIT)
    return(sem_trywait(&semId->Sem));
  else
    return(sem_wait(&semId->Sem));
}
/******************************************************
  函数名：semGive
  
  功能：释放信号量
  SEM_ID semId,      信号id 
  
  返回值说明：成功返回OK, 失败将返回ERROR(-1)
*******************************************************/
int semGive(SEM_ID semId)
{
  return(sem_post(&semId->Sem));
}
/******************************************************
  函数名：semDelete
  
  功能：删除信号量
  SEM_ID semId,      信号id 
  
  返回值说明：成功返回OK, 失败将返回ERROR(-1)
*******************************************************/
int semDelete(SEM_ID semId)
{
  semId->Used = 0;
  return(sem_destroy(&semId->Sem));
}

/******************************************************
  函数名：WdSigRoutine
  
  功能：看门狗信号处理
  int signo，    信号NO.
*******************************************************/
static void WdSigRoutine(int signo)
{
  int i;

  for(i=0;i<MAXWATCHDOG;i++)
  {
    if(VxWatchD[i].Used)
    {
      if(VxWatchD[i].WDStart)
      {
        VxWatchD[i].ElapseDleay--;
        if(!VxWatchD[i].ElapseDleay)
        {
          VxWatchD[i].WDStart = 0;
          (*(VxWatchD[i].pRoute))(VxWatchD[i].dwPara);
        }
      }
    }
  }
  signal(SIGALRM, WdSigRoutine);
}

void VxWdLibInit(void)
{
  int i;
  struct itimerval value, ovalue, value2;
  
  memset(&VxWatchD[0],0,MAXWATCHDOG*sizeof(VXWATCHDOG));
  signal(SIGALRM, WdSigRoutine);
  value.it_value.tv_sec = 0;
  value.it_value.tv_usec = 10000; /*10 ms固定定时*/
  value.it_interval.tv_sec = 0;
  value.it_interval.tv_usec = 10000; /*10 ms固定定时*/
  setitimer(ITIMER_REAL, &value, &ovalue);
  return;
}

/******************************************************
  函数名：wdCreate
  
  功能：创建一个看门狗
  int signo，    信号NO.
  
  返回值说明：成功返回WDOG_ID, 失败将返回NULL（空）
*******************************************************/
WDOG_ID wdCreate(void)
{
  int i;
  
  for(i=0;i<MAXWATCHDOG;i++)
  {
    if(!VxWatchD[i].Used)
      break;
  }
  if(i < MAXWATCHDOG)
  {
    VxWatchD[i].Used = 1;
    return (&VxWatchD[i]);
  }
  else
    return(NULL);
}


/******************************************************
  函数名：wdStart
  
  功能：启动watchdog的运行
  参数：delay：以10MS为单位的时间
  
  
  返回值说明：成功将返回信号量－1, 失败将返回0
*******************************************************/
int wdStart(WDOG_ID wdId,int delay,FUNCPTR pRoutine,int parameter)
{

  if(!pRoutine)
    return (ERROR);
  wdId->pRoute = pRoutine;
  wdId->dwDelay = delay;
  wdId->ElapseDleay = delay;
  wdId->dwPara = parameter;
  wdId->WDStart = 1;
  return(OK);
}
/******************************************************
  函数名：wdStart
  
  功能：取消watchdog的运行
  参数：WDOG_ID wdId 看门狗ID号
  
  
  返回值说明：成功将返回信号量－1, 失败将返回0
*******************************************************/
int wdCancel(WDOG_ID wdId)
{
  wdId->WDStart = 0;
  return(OK);  
}

void VxEventLibInit(void)
{
  int i;
  for(i=0;i<MAXTHREADS;i++)
  {
    Vxevent[i].nThreadId = 0;
  }
  return;
}

/*不支持VXWORSK的user options 选择*/

int eventReceive(
    UINT32   events,          /* events task is waiting to occur */
    UINT8    options,         /* user options */
    int      timeout,         /* ticks to wait */
    UINT32 * pEventsReceived  /* events occured are returned through this */
    )
{
  pthread_t pid;
  int i;
  VXEVENT *pEvent;
  
  if((!events) || (!pEventsReceived))
  {
     printf("Id Error\n");
    return(ERROR);
  }
  pid  = pthread_self();
  pEvent = &Vxevent[0];
  for(i = 0; i< MAXTHREADS; i++)
  {
    if(pid == pEvent->nThreadId)
      break;
    pEvent++;
  }
  if( i >= MAXTHREADS)
  {
     printf("No found PId \n");
    return(ERROR);
  }
    
  if(timeout == WAIT_FOREVER)
  {
    while(1)
    {
      sem_wait(&pEvent->Sem);
      if(events & pEvent->nEvent)
      {
        *pEventsReceived = pEvent->nEvent;
        pEvent->nEvent = 0;
        pEvent->Flag = 0;
        return(OK);
      }
      else
        pEvent->Flag = 0;
    }
  }
  else if(timeout == NO_WAIT)
  {
    if(sem_trywait(&pEvent->Sem)== OK)
    {
      if(events & pEvent->nEvent)
      {
        *pEventsReceived = pEvent->nEvent;
        pEvent->nEvent = 0;
        pEvent->Flag = 0;
        return(OK);
      }
      else
      {
        pEvent->nEvent = 0;
        pEvent->Flag = 0;
        return(ERROR);
      }
    }
    else
      return(ERROR);
  }
  else
    return(ERROR);
}


int eventSend(int taskId,unsigned int events)
{
  pthread_t pid;
  int i;
  VXEVENT* pEvent;
  
  if((!taskId) || (!events))
  {
    printf("Id Error\n");
    return(ERROR);
  }
  pid = (pthread_t)taskId;
  pEvent = &Vxevent[0];
  for(i = 0; i< MAXTHREADS; i++)
  {
    if(pid == pEvent->nThreadId)
      break;
    pEvent++;
  }
  if( i >= MAXTHREADS)
  {
     printf("No find Id\n");
    return(ERROR);
  }
  pEvent->nEvent |= events;
  if(!pEvent->Flag)
  {
    sem_post(&pEvent->Sem); 
    pEvent->Flag = 1;
  }
  return(OK);
}

int sysClkRateGet (void)
{
	return 100;
}

STATUS sysClkRateSet
(
  int ticksPerSecond        /* number of clock interrupts per second */
)
{
	return 0;
}

UINT32 tickGet (void)/*quy added 2006-3-1 8:59 !!!*/
{
	return 100;/*jiffies;*/
}

int errnoGet (void)/*quy added 2006-3-1 8:59 !!!*/
{
	return EISCONN;
}