ul_hdep.h

linux下的RS485的驱动 值得一看

/*******************************************************************
  uLan Communication - low level and link driver

  ul_hdep.h	- host system dependant driver routines

  (C) Copyright 1996,1997 by Pavel Pisa 

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

  Author reserves right to use and publish sources for embedded 
  applications under different conditions too.
 *******************************************************************/

#ifndef _LINUX_UL_HDEP_H
#define _LINUX_UL_HDEP_H

#include "ul_drv.h"

#define  ULAN_MAJOR 248

#define  ENABLE_UL_MEM_CHECK

#define UL_LOG_ENABLE

#ifdef KERNEL
 #ifndef ENABLE_UL_MEM_CHECK
  #define MALLOC(x) kmalloc(x,GFP_KERNEL)
  #define FREE(x)   kfree(x)
 #else
  #define MALLOC ul_mem_check_malloc
  #define FREE   ul_mem_check_free
  void * ul_mem_check_malloc(size_t size);
  void ul_mem_check_free(void *ptr);
 #endif
 #define UL_CHK_IOS(port,cnt)      check_region(port, cnt)
 #define UL_REQ_IOS(port,cnt,name) (kc_request_region(port, cnt, name)?0:-1)
 #define UL_REL_IOS(port,cnt)      kc_release_region(port, cnt)
 #ifndef FOR_LINUX_KERNEL
  #define FOR_LINUX_KERNEL
 #endif
 #define ULD_HZ HZ
#elif defined(_WIN32)
 #ifndef ENABLE_UL_MEM_CHECK
  #define MALLOC(x) ExAllocatePool(NonPagedPool,x)
  #define FREE(x)   ExFreePool(x)
 #else
  #define MALLOC ul_mem_check_malloc
  #define FREE   ul_mem_check_free
  void * ul_mem_check_malloc(size_t size);
  void ul_mem_check_free(void *ptr);
 #endif
 #define UL_CHK_IOS(port,cnt)      (0)
 #define UL_REQ_IOS(port,cnt,name) (0)
 #define UL_REL_IOS(port,cnt)      (0)
 #define ULD_HZ 1000000 
#elif defined(__DJGPP__)
 #include <malloc.h>
 #include <dpmi.h>
 #ifndef ENABLE_UL_MEM_CHECK
  #define MALLOC(_size) ({void *_p=malloc(_size);\
                        _go32_dpmi_lock_data(_p,_size);\
                        _p;})
  #define FREE   free
 #else
  #define MALLOC ul_mem_check_malloc
  #define FREE   ul_mem_check_free
  void * ul_mem_check_malloc(size_t size);
  void ul_mem_check_free(void *ptr);
 #endif
 #define UL_CHK_IOS(port,cnt)      ({0;})
 #define UL_REQ_IOS(port,cnt,name) ({0;})
 #define UL_REL_IOS(port,cnt)      ({0;})
 #define UL_DRV_IN_LIB
 #define error perror
 #define ULD_HZ UCLOCKS_PER_SEC
 long int uld_jiffies;
 #define jiffies uld_jiffies
 #define JIFFIES_FROM_GETTIMEOFDAY
#elif defined(CONFIG_OC_UL_DRV_SYSLESS)
 #include <malloc.h>
 #include <system_def.h>
 #include <hal_intr.h>
 #ifndef ENABLE_UL_MEM_CHECK
  #define MALLOC(_size) malloc(_size)
  #define FREE   free
 #else
  #define MALLOC ul_mem_check_malloc
  #define FREE   ul_mem_check_free
  void * ul_mem_check_malloc(size_t size);
  void ul_mem_check_free(void *ptr);
 #endif
 #define UL_CHK_IOS(port,cnt)      ({0;})
 #define UL_REQ_IOS(port,cnt,name) ({0;})
 #define UL_REL_IOS(port,cnt)      ({0;})
 #define UL_DRV_IN_LIB
 #define UL_DRV_IN_LIB_WITH_PRINTK
 #define error perror
 #define ULD_HZ SYS_TIMER_HZ
 long int uld_jiffies;
 #define jiffies uld_jiffies
 #define sleep(x) {volatile unsigned int s;for(s=0;s<50000;s++);}
 #define ENABLE_UL_STARTUP_RECEIVE
#else
 #include <malloc.h>
 #include <sys/time.h>
 #define MALLOC malloc
 #define FREE   free
 #define UL_CHK_IOS(port,cnt) \
	({int i=ioperm((long)port, (long)cnt, 1);\
 	  ioperm((long)port, (long)cnt, 0);\
 	  i<0?i:0;\
	})
 #define UL_REQ_IOS(port,cnt,name) ioperm((long)port, (long)cnt, 1)
 #define UL_REL_IOS(port,cnt)      ioperm((long)port, (long)cnt, 0)
 #define error perror
 #define ULD_HZ 1000000
 #define jiffies ({struct timeval tv;gettimeofday(&tv,NULL);\
                  tv.tv_usec+tv.tv_sec*1000000;})
#endif


#ifndef INLINE
  #define INLINE extern inline
#endif

#ifndef uchar
 #define uchar unsigned char
#endif

#if defined(__DJGPP__)
  /* Taken from Linux kernel - Copyright 1992, Linus Torvalds. */
  #define __sti() __asm__ __volatile__ ("sti": : :"memory")
  #define __cli() __asm__ __volatile__ ("cli": : :"memory")
  #define __save_flags(x) \
  __asm__ __volatile__("pushfl ; popl %0":"=g" (x): /* no input */ :"memory")
  #define __restore_flags(x) \
  __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"g" (x):"memory")
  INLINE void set_bit(int nr, volatile int * addr)
    { __asm__ __volatile__("btsl %1,%0":"=m" (*addr):"Ir" (nr));}
  INLINE void clear_bit(int nr, volatile int * addr)
    { __asm__ __volatile__("btrl %1,%0":"=m" (*addr):"Ir" (nr));}
  INLINE int test_and_set_bit(int nr, volatile int * addr)
    {int oldbit;__asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
      :"=r" (oldbit),"=m" (*addr):"Ir" (nr));return oldbit;}
  INLINE int test_bit(int nr, volatile int * addr)
    {int oldbit;__asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
      :"=r" (oldbit):"m" (*addr),"Ir" (nr));return oldbit;}
  #define udelay usleep
  INLINE void schedule(void) {;}
  int request_irq(int irq,void *handler,int flags,char *name,void *dev_id);
  int free_irq(int irq,void *ctx);
  INLINE void synchronize_irq() {asm volatile ("":::"memory");}
#elif defined(USER_SPACE_EMU_IRQ)
  INLINE void schedule(void) {;}
  #define request_irq request_emu_irq
  #define free_irq release_emu_irq
  INLINE void synchronize_irq() {asm volatile ("":::"memory");}
#elif defined(CONFIG_OC_UL_DRV_SYSLESS)
  #define __cli(x) cli(x)
  #define __restore_flags(x)  restore_flags(x)
  #define __save_flags(x) save_flags(x)
  inline void schedule(void) {;}
  int request_irq(int irq,void *handler,int flags,char *name,void *dev_id);
  int free_irq(int irq,void *ctx);
  inline void synchronize_irq() {asm volatile ("":::"memory");}
#endif /* USER_SPACE_EMU_IRQ */

#if defined(CONFIG_OC_UL_DRV_SYSLESS)
  #define U450_BYTES_PER_REGS 4
  #define U450_BAUD_BASE_DEFAULT ((FOSC*PLL_MUL/PBSD+8)/16)
#else
  #define U450_BYTES_PER_REGS 1
  #define U450_BAUD_BASE_DEFAULT 0x1C200
#endif /* CONFIG_OC_UL_DRV_SYSLESS */

/*******************************************************************/
/* locking, irq and memory management */

/* disables another IRQ on same CPU when uLan IRQ is handled */
#ifdef FOR_LINUX_KERNEL
 #if 1
  #define UL_SA_IRQ_FLAGS (SA_SHIRQ|SA_INTERRUPT)
 #else
  #define UL_SA_IRQ_FLAGS SA_SHIRQ
 #endif
#else
 #define UL_SA_IRQ_FLAGS 0
#endif

#ifdef USER_SPACE_EMU_IRQ
 #define UL_IRQ_LOCK_FINI
 #define ul_synchronize_irq(irqnum) synchronize_irq()
 int INLINE irq_lock_cnt(int i)
 {static int lock_counter=0;
  return lock_counter+=i;
 };
 #define UL_IRQ_LOCK   {if(irq_lock_cnt(1)==1) emu_irq_cli();}
 #define UL_IRQ_UNLOCK {if(irq_lock_cnt(-1)==0)emu_irq_sti();}
 #define UL_MB()       {asm volatile ("":::"memory");}
 #define UL_IRQ_HANDLER_ARGS(intno, dev_id) \
       int intno, void *dev_id, struct pt_regs *regs
 #define ul_irqreturn_t void
 #define UL_IRQ_RETVAL(retval)
 #define UL_IRQ_NONE
 #define UL_IRQ_HANDLED
#elif defined(FOR_LINUX_KERNEL)
 #define ul_synchronize_irq kc_synchronize_irq
 #if 1
  spinlock_t ul_irq_lock_spinlock;
  #define UL_IRQ_LOCK_GINI \
    spinlock_t ul_irq_lock_spinlock=SPIN_LOCK_UNLOCKED;
  #define UL_IRQ_LOCK_FINI unsigned long ul_irq_lock_flags;
  #define UL_IRQ_LOCK \
    {spin_lock_irqsave(&ul_irq_lock_spinlock,ul_irq_lock_flags);}
  #define UL_IRQ_UNLOCK \
    {spin_unlock_irqrestore(&ul_irq_lock_spinlock,ul_irq_lock_flags);}
 #else
  #define UL_IRQ_LOCK_FINI
  #define UL_IRQ_LOCK   {cli();}
  #define UL_IRQ_UNLOCK {sti();}
 #endif
 #define UL_MB()       mb()
 #define UL_IRQ_HANDLER_ARGS KC_IRQ_HANDLER_ARGS
 #define ul_irqreturn_t irqreturn_t
 #define UL_IRQ_RETVAL  IRQ_RETVAL
 #define UL_IRQ_NONE    IRQ_NONE
 #define UL_IRQ_HANDLED IRQ_HANDLED
#elif defined(_WIN32)
 typedef LONG atomic_t;
 KIRQL  uL_SpinLock_Irql;
 LONG   uL_SpinLock_Flag;
 #define UL_IRQ_LOCK_GINI \
     KIRQL  uL_SpinLock_Irql=0; \
     LONG   uL_SpinLock_Flag=0;
 #define UL_IRQ_LOCK_FINI \
	 KIRQL uL_IRQ_OldIrql;
 #define UL_IRQ_LOCK \
    {KeRaiseIrql (uL_SpinLock_Irql,&uL_IRQ_OldIrql); \
     while(InterlockedExchange(&uL_SpinLock_Flag,1)); \
    }
 #define UL_IRQ_UNLOCK \
    {InterlockedExchange(&uL_SpinLock_Flag,0); \
     KeLowerIrql(uL_IRQ_OldIrql); \
    }
 #define UL_MB()       {/* Flush cache here */;}
 #define UL_IRQ_HANDLER_ARGS(intno, dev_id) \
       IN PKINTERRUPT intno, IN PVOID dev_id
 #define ul_irqreturn_t BOOLEAN
 #define UL_IRQ_RETVAL(retval)  ((retval)?TRUE:FALSE)
 #define UL_IRQ_NONE    FALSE
 #define UL_IRQ_HANDLED TRUE
#elif defined(__DJGPP__)
  typedef long atomic_t;
  #define UL_IRQ_LOCK_FINI unsigned long ul_irq_lock_flags;
  #define UL_IRQ_LOCK \
    {__save_flags(ul_irq_lock_flags);__cli();}
  #define UL_IRQ_UNLOCK \
    {__restore_flags(ul_irq_lock_flags);}
  #define UL_MB()       {asm volatile ("":::"memory");}
  #define ul_synchronize_irq(irqnum) synchronize_irq()
  #define UL_IRQ_HANDLER_ARGS(intno, dev_id) \
       int intno, void *dev_id, struct pt_regs *regs
  #define ul_irqreturn_t void
  #define UL_IRQ_RETVAL(retval)
  #define UL_IRQ_NONE
  #define UL_IRQ_HANDLED
#elif defined(CONFIG_OC_UL_DRV_SYSLESS)
  typedef long atomic_t;
  #define UL_IRQ_LOCK_FINI unsigned long ul_irq_lock_flags=0;
  #define UL_IRQ_LOCK \
    {__save_flags(ul_irq_lock_flags);__cli();}
  #define UL_IRQ_UNLOCK \
    {__restore_flags(ul_irq_lock_flags);}
  #define UL_MB()       {asm volatile ("":::"memory");}
  #define ul_synchronize_irq(irqnum) synchronize_irq()
  #define UL_IRQ_HANDLER_ARGS(intno, dev_id) \
       int intno, void *dev_id
  #define ul_irqreturn_t void
  #define UL_IRQ_RETVAL(retval)
  #define UL_IRQ_NONE
  #define UL_IRQ_HANDLED
#endif

#ifndef ATOMIC_INIT
  #define ATOMIC_INIT(i) (i)
#endif
#ifndef atomic_read
  #define atomic_read(v) (*(v))
#endif
#ifndef atomic_set
  #define atomic_set(v,i) (*(v)=(i))
#endif

#define UL_DRV_LOCK_FINI UL_IRQ_LOCK_FINI
#define UL_DRV_LOCK {\
  UL_IRQ_LOCK;\
 }
#define UL_DRV_UNLOCK {\
  UL_IRQ_UNLOCK;\
 }

/* enable to globaly lock CPU through uLan events handling, bad
   use only for special test purposes */
#if 0
  spinlock_t ul_global_irq_lock_spinlock;
  #define UL_GLOBAL_IRQ_LOCK_GINI \
    spinlock_t ul_global_irq_lock_spinlock=SPIN_LOCK_UNLOCKED;
  #define UL_GLOBAL_IRQ_LOCK_FINI unsigned long ul_global_irq_lock_flags;
  #define UL_GLOBAL_IRQ_LOCK \
    {spin_lock_irqsave(&ul_global_irq_lock_spinlock,ul_global_irq_lock_flags);}
  #define UL_GLOBAL_IRQ_UNLOCK \
    {spin_unlock_irqrestore(&ul_global_irq_lock_spinlock,ul_global_irq_lock_flags);}
#endif


#ifdef CONFIG_OC_UL_DRV_SYSLESS
  #define UL_GLOBAL_IRQ_LOCK_GINI 
  #define UL_GLOBAL_IRQ_LOCK_FINI UL_IRQ_LOCK_FINI;
  #define UL_GLOBAL_IRQ_LOCK UL_IRQ_LOCK
  #define UL_GLOBAL_IRQ_UNLOCK UL_IRQ_UNLOCK
#endif

/* get one free block or NULL */
INLINE ul_mem_blk *ul_alloc_blk(ul_drv *udrv)
{
  UL_DRV_LOCK_FINI
  ul_mem_blk *p;
  UL_DRV_LOCK;
  if((p=udrv->free_blk)!=NULL)
  {
    udrv->free_blk_cnt--;
    udrv->free_blk=p->next;
    p->next=NULL;
  };
  UL_DRV_UNLOCK;
  return p;
};

/* free one block */
INLINE void ul_free_blk(ul_drv *udrv, ul_mem_blk *blk)
{
  UL_DRV_LOCK_FINI
  UL_DRV_LOCK;
  blk->next=udrv->free_blk;
  udrv->free_blk=blk;
  udrv->free_blk_cnt++;
  UL_DRV_UNLOCK;
};

/* bottom half definitions */
#ifdef FOR_LINUX_KERNEL
  void ulan_do_bh(kc_tasklet_data_type data);
  typedef kc_tasklet_data_type ulan_do_bh_data_type;
  #define SCHEDULE_BH(udrv) \
        kc_tasklet_schedule(&(udrv)->bottom)
  #define INIT_UDRV_BH(udrv) \
	kc_tasklet_init(&(udrv)->bottom,ulan_do_bh,(long)udrv)
  #define KILL_UDRV_BH(udrv) \
	kc_tasklet_kill(&(udrv)->bottom)
  #define DECLARE_UDRV_BH struct kc_tasklet_struct bottom;
  #define uld_test_dfl(udrv,_DFL_flag) \
	test_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
  #define uld_set_dfl(udrv,_DFL_flag) \
	set_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
  #define uld_clear_dfl(udrv,_DFL_flag) \
	clear_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
  #define uld_test_and_set_dfl(udrv,_DFL_flag) \
	test_and_set_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
  #define uld_atomic_test_dfl(udrv,_DFL_flag) \
	test_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
  #define uld_atomic_clear_dfl(udrv,_DFL_flag) \
	clear_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
  #define uld_atomic_set_dfl(udrv,_DFL_flag) \
	set_bit(UL_DFLB_##_DFL_flag,&(udrv)->flags)
    
  #define uld_kwt_wq_init(udrv) \
	do { init_waitqueue_head(&(udrv)->kwt_wq); \
	     uld_atomic_clear_dfl(udrv,KWTKILL); \
	     uld_atomic_clear_dfl(udrv,KWTRUN); \
	     uld_atomic_clear_dfl(udrv,ASK_ISR); } while(0)
  #define uld_kwt_wake(udrv) \
	do { uld_atomic_set_dfl(udrv,ASK_ISR); wake_up(&(udrv)->kwt_wq); } while(0)
  #define uld_kwt_wait(udrv) \
	wait_event(udrv->kwt_wq, uld_test_dfl(udrv,ASK_ISR))