ul_l_drv.c

linux下的RS485的驱动 值得一看

/*******************************************************************
  uLan Communication - basic library

  ul_l_drv.c	- driver interface

  (C) Copyright 1996,1999 by Pavel Pisa 

  The uLan driver is distributed under the Gnu General Public Licence. 
  See file COPYING for details.
 *******************************************************************/

#include <sys/types.h>
#ifndef _MSC_VER
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#endif /*_MSC_VER*/
#include <string.h>
#include <stdlib.h>
#include <ul_lib/ulan.h>

#ifndef WITH_UL_FD_INDIRECT

#define ul_direct_open ul_open
#define ul_direct_close ul_close
#define ul_direct_drv_version ul_drv_version
#define ul_direct_read ul_read
#define ul_direct_write ul_write
#define ul_direct_newmsg ul_newmsg
#define ul_direct_tailmsg ul_tailmsg
#define ul_direct_freemsg ul_freemsg
#define ul_direct_acceptmsg ul_acceptmsg
#define ul_direct_actailmsg ul_actailmsg
#define ul_direct_addfilt ul_addfilt
#define ul_direct_abortmsg ul_abortmsg
#define ul_direct_rewmsg ul_rewmsg
#define ul_direct_inepoll ul_inepoll
#define ul_direct_drv_debflg ul_drv_debflg
#define ul_direct_fd_wait ul_fd_wait
#define ul_direct_setmyadr ul_setmyadr
#define ul_direct_setidstr ul_setidstr

static inline ul_fd_t ul_direct_fd2ul_fd(ul_fd_t fd)
{
  return fd;
}

static inline void ul_direct_fd_free(ul_fd_t ul_fd)
{
}

#else /*WITH_UL_FD_INDIRECT*/

typedef struct ul_fd_direct_context_t {
  ul_fd_context_t context;
  ul_fd_direct_t sys_fd;
} ul_fd_direct_context_t;

ul_fd_ops_t ul_fd_direct_ops;

static inline ul_fd_t ul_direct_fd2ul_fd(ul_fd_direct_t fd)
{
  ul_fd_direct_context_t *ul_direct_ctx;
  if (fd==UL_FD_DIRECT_INVALID)
    return UL_FD_INVALID;
  ul_direct_ctx=malloc(sizeof(ul_fd_direct_context_t));
  if(!ul_direct_ctx)
    return UL_FD_INVALID;
  memset(ul_direct_ctx,0,sizeof(ul_fd_direct_context_t));
  ul_direct_ctx->sys_fd=fd;
  ul_direct_ctx->context.fd_ops=&ul_fd_direct_ops;
  return &ul_direct_ctx->context;
}

static inline void ul_direct_fd_free(ul_fd_t ul_fd)
{
  if(ul_fd==UL_FD_INVALID)
    return;

  free(UL_CONTAINEROF(ul_fd, ul_fd_direct_context_t, context));
}

ul_fd_direct_t ul_direct_fd2sys_fd(ul_fd_t ul_fd)
{
  if(ul_fd==UL_FD_INVALID)
    return UL_FD_DIRECT_INVALID;
  else
    return UL_CONTAINEROF(ul_fd, ul_fd_direct_context_t, context)->sys_fd;
}

#endif /*WITH_UL_FD_INDIRECT*/



#if !defined(_WIN32) && !defined(UL_DRV_IN_LIB)

inline ul_fd_t ul_direct_open(const char *dev_name, const char *options)
{
  if(dev_name==NULL) dev_name=UL_DEV_NAME;
  else if(!strncmp(dev_name,"drv:",4)) dev_name+=4;
  return ul_direct_fd2ul_fd(open(dev_name,O_RDWR, S_IWRITE | S_IREAD));
}

inline int ul_direct_close(ul_fd_t ul_fd)
{
  int res;
  res=close(ul_fd2sys_fd(ul_fd));
  ul_direct_fd_free(ul_fd);
  return res;
}

inline int ul_direct_drv_version(ul_fd_t ul_fd)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_DRV_VER);
}


inline ssize_t ul_direct_read(ul_fd_t ul_fd, void *buffer, size_t size)
{
  return read(ul_fd2sys_fd(ul_fd),buffer,size);
}

inline ssize_t ul_direct_write(ul_fd_t ul_fd, const void *buffer, size_t size)
{
  return write(ul_fd2sys_fd(ul_fd),buffer,size);
}

inline int ul_direct_newmsg(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_NEWMSG,msginfo);
}

inline int ul_direct_tailmsg(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_TAILMSG,msginfo);
}

inline int ul_direct_freemsg(ul_fd_t ul_fd)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_FREEMSG);
}

inline int ul_direct_acceptmsg(ul_fd_t ul_fd,ul_msginfo *msginfo)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_ACCEPTMSG,msginfo);
}

inline int ul_direct_actailmsg(ul_fd_t ul_fd,ul_msginfo *msginfo)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_ACTAILMSG,msginfo);
}

inline int ul_direct_addfilt(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_ADDFILT,msginfo);
}

inline int ul_direct_abortmsg(ul_fd_t ul_fd)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_ABORTMSG);
}

inline int ul_direct_rewmsg(ul_fd_t ul_fd)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_REWMSG);
}

inline int ul_direct_inepoll(ul_fd_t ul_fd)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_INEPOLL);
}

inline int ul_direct_drv_debflg(ul_fd_t ul_fd,int debug_msk)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_DEBFLG,debug_msk);
}

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;
}

inline int ul_direct_setmyadr(ul_fd_t ul_fd, int newadr)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_SETMYADR,newadr);
}

inline int ul_direct_setidstr(ul_fd_t ul_fd, const char *idstr)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_SETIDSTR,idstr);
}

/*******************************************************************/
#elif defined(_WIN32)

ul_fd_t ul_direct_open(const char *dev_name, const char *options)
{
  if(dev_name==NULL) dev_name=UL_DEV_NAME;
  else if(!strncmp(dev_name,"drv:",4)) dev_name+=4;

  return ul_direct_fd2ul_fd(CreateFile(dev_name,GENERIC_READ | GENERIC_WRITE,
                    0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0));
}

int ul_direct_close(ul_fd_t ul_fd)
{
  int res=0;
  if(!CloseHandle(ul_fd2sys_fd(ul_fd))) res=-1;
  ul_direct_fd_free(ul_fd);
  return res;
}


int ul_direct_drv_version(ul_fd_t ul_fd)
{
  DWORD ret,bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_DRV_VER,
                      NULL,0,&ret,sizeof(ret),
                      &bytes_ret,NULL)) return -1;
  return ret;
}

ssize_t ul_direct_read(ul_fd_t ul_fd, void *buffer, size_t size)
{
  DWORD ret;
  if(!ReadFile(ul_fd2sys_fd(ul_fd),buffer,size,&ret,NULL)) return -1;
  return ret;
}

ssize_t ul_direct_write(ul_fd_t ul_fd, const void *buffer, size_t size)
{
  DWORD ret;
  if(!WriteFile(ul_fd2sys_fd(ul_fd),buffer,size,&ret,NULL)) return -1;
  return ret;
}

int ul_direct_newmsg(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_NEWMSG,
                      (void *)msginfo,sizeof(ul_msginfo),NULL,0,
                      &bytes_ret,NULL)) return -1;
  return 0;
}

int ul_direct_tailmsg(ul_fd_t ul_fd,const ul_msginfo *msginfo)
{
  DWORD bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_TAILMSG,
                      (void *)msginfo,sizeof(ul_msginfo),NULL,0,
                      &bytes_ret,NULL)) return -1;
  return 0;
}

int ul_direct_freemsg(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  int ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_FREEMSG,NULL,0,&ret,sizeof(ret),
                      &bytes_ret,NULL)) 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;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ACCEPTMSG,
                      NULL,0,msginfo,sizeof(ul_msginfo),
                      &bytes_ret,NULL)) 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;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ACTAILMSG,
                      NULL,0,msginfo,sizeof(ul_msginfo),
                      &bytes_ret,NULL)) 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;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ADDFILT,
                      (void *)msginfo,sizeof(ul_msginfo),NULL,0,
                      &bytes_ret,NULL)) return -1;
  return 0;
}

int ul_direct_abortmsg(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_ABORTMSG,NULL,0,NULL,0,
                      &bytes_ret,NULL)) return -1;
  return 0;
}

int ul_direct_rewmsg(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_REWMSG,NULL,0,NULL,0,
                      &bytes_ret,NULL)) return -1;
  return 0;
}

int ul_direct_inepoll(ul_fd_t ul_fd)
{
  DWORD bytes_ret;
  int ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_INEPOLL,NULL,0,&ret,sizeof(ret),
                      &bytes_ret,NULL)) 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;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_DEBFLG,
		  &debug_msk,sizeof(debug_msk),NULL,0,
		  &bytes_ret,NULL)) 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 */

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;
}

#endif /* WITHOUT_SYS_SELECT */

inline int ul_direct_setmyadr(ul_fd_t ul_fd, int newadr)
{
  DWORD bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_SETMYADR,
		  &newadr,sizeof(newadr),NULL,0,
		  &bytes_ret,NULL)) return -1;
  return 0;
}

inline int ul_direct_setidstr(ul_fd_t ul_fd, const char *idstr)
{
  DWORD bytes_ret;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_DEBFLG,
		  &idstr,strlen(idstr),NULL,0,
		  &bytes_ret,NULL)) 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
};

#endif /*WITH_UL_FD_INDIRECT*/