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_setbaudrate ul_setbaudrate
#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)
{
}

#define ul_direct_overlapped_wait(x,y,z) -1 
#define WIN32_FILE_OVERLAPPED_FINI

#else /*WITH_UL_FD_INDIRECT*/

typedef struct ul_fd_direct_context_t {
  ul_fd_context_t context;
  ul_fd_direct_t sys_fd;
#ifdef _WIN32
  OVERLAPPED cOverlapped;
#endif /* WIN32 */  
} 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;
#ifdef WIN32_FILE_OVERLAPPED
  ul_direct_ctx->cOverlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  ul_direct_ctx->cOverlapped.Offset = 0;
  ul_direct_ctx->cOverlapped.OffsetHigh = 0;
  if (!ul_direct_ctx->cOverlapped.hEvent) {
    free(ul_direct_ctx);
    return UL_FD_INVALID;
  }
#endif /* WIN32_FILE_OVERLAPPED */
  return &ul_direct_ctx->context;
}

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

  ul_direct_ctx=UL_CONTAINEROF(ul_fd, ul_fd_direct_context_t, context);
#ifdef WIN32_FILE_OVERLAPPED
  CloseHandle(ul_direct_ctx->cOverlapped.hEvent);
  ul_direct_ctx->cOverlapped.hEvent=NULL;
#endif /* WIN32_FILE_OVERLAPPED */
  free(ul_direct_ctx);
}

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

#ifdef WIN32_FILE_OVERLAPPED
int ul_direct_overlapped_wait(ul_fd_direct_context_t *ul_direct_ctx, DWORD *bytes_ret, int ms_timeout)
{
  int ret=-1;
  if (GetLastError() != ERROR_IO_PENDING) return -1;
  if (WaitForSingleObject(ul_direct_ctx->cOverlapped.hEvent, ms_timeout) == WAIT_OBJECT_0) {
    ret=GetOverlappedResult(ul_direct_ctx->sys_fd,&ul_direct_ctx->cOverlapped,
                            bytes_ret, FALSE);
  }
  CancelIo(ul_direct_ctx->sys_fd);
  return ret;  
}

#define WIN32_FILE_OVERLAPPED_FINI                                     \
 ul_fd_direct_context_t *ul_direct_ctx;                                \
 ul_direct_ctx=UL_CONTAINEROF(ul_fd, ul_fd_direct_context_t, context); \
 pOverlapped=&ul_direct_ctx->cOverlapped;                              

#else /* WIN32_FILE_OVERLAPPED */

 #define ul_direct_overlapped_wait(x,y,z) -1 
 #define WIN32_FILE_OVERLAPPED_FINI

#endif /* WIN32_FILE_OVERLAPPED */

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

inline int ul_direct_setbaudrate(ul_fd_t ul_fd, int baudrate)
{
  return ioctl(ul_fd2sys_fd(ul_fd),UL_SETBAUDRATE,baudrate);
}

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

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

#ifdef WIN32_FILE_OVERLAPPED 
  attr=FILE_FLAG_OVERLAPPED; 
#endif /* WIN32_FILE_OVERLAPPED */
  
  return ul_direct_fd2ul_fd(CreateFile(dev_name,GENERIC_READ | GENERIC_WRITE,
                    0, 0, OPEN_EXISTING, attr, 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;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!DeviceIoControl(ul_fd2sys_fd(ul_fd),UL_DRV_VER,
                      NULL,0,&ret,sizeof(ret),
                      &bytes_ret,pOverlapped)) 
    ret=ul_direct_overlapped_wait(ul_direct_ctx,&bytes_ret,INFINITE);  
  return ret;
}

ssize_t ul_direct_read(ul_fd_t ul_fd, void *buffer, size_t size)
{
  DWORD ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;
  if(!ReadFile(ul_fd2sys_fd(ul_fd),buffer,size,&ret,pOverlapped)) 
    ul_direct_overlapped_wait(ul_direct_ctx,&ret,INFINITE);  
  return ret;
}

ssize_t ul_direct_write(ul_fd_t ul_fd, const void *buffer, size_t size)
{
  DWORD ret;
  LPOVERLAPPED pOverlapped=NULL;
  WIN32_FILE_OVERLAPPED_FINI;