ul_l_drv.c

一个linux下rs485驱动程序的源代码

  if(!WriteFile(ul_fd2sys_fd(ul_fd),buffer,size,&ret,pOverlapped)) 
    ul_direct_overlapped_wait(ul_direct_ctx,&ret,INFINITE);  
  return ret;
}

int ul_direct_newmsg(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_NEWMSG,
                      (void *)msginfo,sizeof(ul_msginfo),NULL,0,
                      &bytes_ret,pOverlapped)) 
    return(ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE));  
  return 0;
}

int ul_direct_tailmsg(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_TAILMSG,
                      (void *)msginfo,sizeof(ul_msginfo),NULL,0,
                      &bytes_ret,pOverlapped)) 
    return(ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE));  
  return 0;
}

int ul_direct_freemsg(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  int ret=0;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_FREEMSG,NULL,0,&ret,sizeof(ret),
                      &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  if(bytes_ret!=sizeof(ret)) return -1;
  return ret;
}

int ul_direct_acceptmsg(ul_fd_t ul_fd,ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ACCEPTMSG,
                      NULL,0,msginfo,sizeof(ul_msginfo),
                      &bytes_ret,pOverlapped))
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  if(bytes_ret!=sizeof(ul_msginfo)) return -1;
  return 0;
}

int ul_direct_actailmsg(ul_fd_t ul_fd,ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ACTAILMSG,
                      NULL,0,msginfo,sizeof(ul_msginfo),
                      &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  if(bytes_ret!=sizeof(ul_msginfo)) return -1;
  return 0;
}

int ul_direct_addfilt(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ADDFILT,
                      (void *)msginfo,sizeof(ul_msginfo),NULL,0,
                      &bytes_ret,pOverlapped)) return -1;
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

int ul_direct_abortmsg(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ABORTMSG,NULL,0,NULL,0,
                      &bytes_ret,pOverlapped))
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

int ul_direct_rewmsg(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_REWMSG,NULL,0,NULL,0,
                      &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

int ul_direct_inepoll(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  int ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_INEPOLL,NULL,0,&ret,sizeof(ret),
                      &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  if(bytes_ret!=sizeof(ret)) return -1;
  return ret;
}

int ul_direct_drv_debflg(ul_fd_t ul_fd,int debug_msk)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_DEBFLG,
		  &debug_msk,sizeof(debug_msk),NULL,0,
		  &bytes_ret,pOverlapped))
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

#ifndef WITHOUT_SYS_SELECT

int ul_direct_fd_wait(ul_fd_t ul_fd, int wait_sec)
{
  int ret;
  struct timeval timeout;
  fd_set set;

  FD_ZERO (&set);
  FD_SET (ul_fd2sys_fd(ul_fd), &set);
  timeout.tv_sec = wait_sec;
  timeout.tv_usec = 0;
  while ((ret=select(FD_SETSIZE,&set, NULL, NULL,&timeout))==-1
          &&errno==-EINTR);
  return ret;
}

#else /* WITHOUT_SYS_SELECT */

#ifndef WIN32_FILE_OVERLAPPED
int ul_direct_fd_wait(ul_fd_t ul_fd, int wait_sec)
{
  int ret;
  long loops=0;
  do
  { ret=ul_inepoll(ul_fd);
    if(ret) return ret;
    Sleep(100);
  }while(loops++<(wait_sec*10));
 
  return 0;
}
#else /* WIN32_FILE_OVERLAPPED */
int ul_direct_fd_wait(ul_fd_t ul_fd, int wait_sec)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_WAITREC,
		  NULL,0,NULL,0,
		  &bytes_ret,pOverlapped))
    return ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,wait_sec*1000);
  return 1;
}
#endif  /* WIN32_FILE_OVERLAPPED */

#endif /* WITHOUT_SYS_SELECT */

inline int ul_direct_setmyadr(ul_fd_t ul_fd, int newadr)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_SETMYADR,
		  &newadr,sizeof(newadr),NULL,0,
		  &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

inline int ul_direct_setidstr(ul_fd_t ul_fd, const char *idstr)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_DEBFLG,
		  &idstr,strlen(idstr),NULL,0,
		  &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

inline int ul_direct_setbaudrate(ul_fd_t ul_fd, int baudrate)
{
  DWORD bytes_ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_SETBAUDRATE,
		  &baudrate,sizeof(baudrate),NULL,0,
		  &bytes_ret,pOverlapped)) 
    if (!ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE)) 
      return -1;
  return 0;
}

#elif defined(__DJGPP__)

int ul_direct_fd_wait(ul_fd_t ul_fd, int wait_sec)
{
  int ret;
  long loops=0;
  long int starttime;
  struct timeval actual;
  gettimeofday(&actual,NULL);
  starttime=actual.tv_sec+1;
  do
  { ret=ul_inepoll(ul_fd);
    if(ret) return ret;
    /* uld_djgpp_call_irq(); */
    gettimeofday(&actual,NULL);
    loops++;
  }while((wait_sec+starttime-(long)actual.tv_sec)>0);
 
  return 0;
}

#elif defined(UL_DRV_IN_LIB)

int ul_direct_fd_wait(ul_fd_t ul_fd, int wait_sec)
{
  int ret;
  long loops=0;
  do
  { ret=ul_inepoll(ul_fd);
    if(ret) return ret;
    #ifndef CONFIG_OC_UL_DRV_SYSLESS
     usleep(100*1000);
    #endif 
    /* uld_djgpp_call_irq(); */
  }while(loops++<(wait_sec*10));
 
  return 0;
}

#else
  #error Interface to driver not defined for target
#endif

#ifdef WITH_UL_FD_INDIRECT

int ul_direct_namematch(const char *dev_name)
{
  int ret=0;
  if(!dev_name) ret=1;
  else if(!strncmp(dev_name,"drv:",4))
    ret=100; /* 100% name match for driver */
  else if(!strchr(dev_name,':'))
    ret=5;   /* no transport selected, direct driver is reasonable for this name */
  return ret;
}

ul_fd_ops_t ul_fd_direct_ops={
  "direct",
  ul_direct_namematch,
  ul_direct_open,
  ul_direct_close,
  ul_direct_drv_version,
  ul_direct_read,
  ul_direct_write,
  ul_direct_newmsg,
  ul_direct_tailmsg,
  ul_direct_freemsg,
  ul_direct_acceptmsg,
  ul_direct_actailmsg,
  ul_direct_addfilt,
  ul_direct_abortmsg,
  ul_direct_rewmsg,
  ul_direct_inepoll,
  ul_direct_drv_debflg,
  ul_direct_fd_wait,
  ul_direct_fd2sys_fd,
  ul_direct_setmyadr,
  ul_direct_setidstr,
  ul_direct_setbaudrate
};

#endif /*WITH_UL_FD_INDIRECT*/