/* * Copyright (c) 2002 * Alex Feldman . All rights reserved. * * $Id: wanpipe_common.h,v 1.175 2007/02/24 00:17:14 sangoma Exp $ */ /**************************************************************************** * wanpipe_common.h WANPIPE(tm) Multiprotocol WAN Link Driver. * * Author: Alex Feldman * * ========================================================================== * July 17, 2002 Alex Feldman Initial Version **************************************************************************** */ #ifndef __WANPIPE_COMMON_H # define __WANPIPE_COMMON_H #ifdef __LINUX__ # include #else # include #endif #ifdef WAN_DEBUG_MEM extern atomic_t wan_debug_mem; #endif /**************************************************************************** ** D E F I N E S ****************************************************************************/ #ifndef NIPQUAD # define NIPQUAD(addr) \ ((unsigned char *)&addr)[0], \ ((unsigned char *)&addr)[1], \ ((unsigned char *)&addr)[2], \ ((unsigned char *)&addr)[3] #endif #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) # define WAN_LIST_HEAD(name, type) LIST_HEAD(name, type) # define WAN_LIST_HEAD_INITIALIZER(head) LIST_HEAD_INITIALIZER(head) # define WAN_LIST_ENTRY(type) LIST_ENTRY(type) # define WAN_LIST_EMPTY(head) LIST_EMPTY(head) # define WAN_LIST_FIRST(head) LIST_FIRST(head) # define WAN_LIST_FOREACH(var, head, field) LIST_FOREACH(var, head, field) # define WAN_LIST_INIT(head) LIST_INIT(head) # define WAN_LIST_INSERT_AFTER(listelm, elm, field) LIST_INSERT_AFTER(listelm, elm, field) /*# define WAN_LIST_INSERT_BEFORE(listelm, elm, field) LIST_INSERT_BEFORE(listelm, elm, field)*/ # define WAN_LIST_INSERT_HEAD(head, elm, field) LIST_INSERT_HEAD(head, elm, field) # define WAN_LIST_NEXT(elm, field) LIST_NEXT(elm, field) # define WAN_LIST_REMOVE(elm, field) LIST_REMOVE(elm, field) #elif defined(__SOLARIS__) /* ********* S O L A R I S *****************/ # define WAN_LIST_HEAD(name, type) struct name { struct type * lh_first; } # define WAN_LIST_HEAD_INITIALIZER(head) { NULL } # define WAN_LIST_ENTRY(type) struct { struct type *le_next; struct type **le_prev; } # define WAN_LIST_FIRST(head) ((head)->lh_first) # define WAN_LIST_END(head) NULL # define WAN_LIST_EMPTY(head) (WAN_LIST_FIRST(head) == WAN_LIST_END(head)) # define WAN_LIST_NEXT(elm, field) ((elm)->field.le_next) # define WAN_LIST_FOREACH(var, head, field) for((var) = WAN_LIST_FIRST(head); \ (var); \ (var) = WAN_LIST_NEXT(var, field)) # define WAN_LIST_INIT(head) do { WAN_LIST_FIRST(head) = NULL;}\ while(0) #define WAN_LIST_INSERT_HEAD(head, elm, field) do { \ if ((WAN_LIST_NEXT((elm), field) = WAN_LIST_FIRST((head))) != NULL) \ WAN_LIST_FIRST((head))->field.le_prev = &WAN_LIST_NEXT((elm), field);\ WAN_LIST_FIRST((head)) = (elm); \ (elm)->field.le_prev = &WAN_LIST_FIRST((head)); \ } while (0) #define WAN_LIST_INSERT_AFTER(listelm, elm, field) do { \ if ((WAN_LIST_NEXT((elm), field) = WAN_LIST_NEXT((listelm), field)) != NULL)\ WAN_LIST_NEXT((listelm), field)->field.le_prev = \ &WAN_LIST_NEXT((elm), field); \ WAN_LIST_NEXT((listelm), field) = (elm); \ (elm)->field.le_prev = &WAN_LIST_NEXT((listelm), field); \ } while (0) #define WAN_LIST_REMOVE(elm, field) do { \ if (WAN_LIST_NEXT((elm), field) != NULL) \ WAN_LIST_NEXT((elm), field)->field.le_prev = \ (elm)->field.le_prev; \ *(elm)->field.le_prev = WAN_LIST_NEXT((elm), field); \ } while (0) #elif defined(__LINUX__) /* ********* L I N U X *****************/ # define WAN_LIST_HEAD(name, type) struct name { struct type * lh_first; } # define WAN_LIST_HEAD_INITIALIZER(head) { NULL } # define WAN_LIST_ENTRY(type) struct { struct type *le_next; struct type **le_prev; } # define WAN_LIST_FIRST(head) ((head)->lh_first) # define WAN_LIST_END(head) NULL # define WAN_LIST_EMPTY(head) (WAN_LIST_FIRST(head) == WAN_LIST_END(head)) # define WAN_LIST_NEXT(elm, field) ((elm)->field.le_next) # define WAN_LIST_FOREACH(var, head, field) for((var) = WAN_LIST_FIRST(head); \ (var); \ (var) = WAN_LIST_NEXT(var, field)) # define WAN_LIST_INIT(head) do { WAN_LIST_FIRST(head) = NULL;}\ while(0) #define WAN_LIST_INSERT_HEAD(head, elm, field) do { \ if ((WAN_LIST_NEXT((elm), field) = WAN_LIST_FIRST((head))) != NULL) \ WAN_LIST_FIRST((head))->field.le_prev = &WAN_LIST_NEXT((elm), field);\ WAN_LIST_FIRST((head)) = (elm); \ (elm)->field.le_prev = &WAN_LIST_FIRST((head)); \ } while (0) #define WAN_LIST_INSERT_AFTER(listelm, elm, field) do { \ if ((WAN_LIST_NEXT((elm), field) = WAN_LIST_NEXT((listelm), field)) != NULL)\ WAN_LIST_NEXT((listelm), field)->field.le_prev = \ &WAN_LIST_NEXT((elm), field); \ WAN_LIST_NEXT((listelm), field) = (elm); \ (elm)->field.le_prev = &WAN_LIST_NEXT((listelm), field); \ } while (0) #define WAN_LIST_REMOVE(elm, field) do { \ if (WAN_LIST_NEXT((elm), field) != NULL) \ WAN_LIST_NEXT((elm), field)->field.le_prev = \ (elm)->field.le_prev; \ *(elm)->field.le_prev = WAN_LIST_NEXT((elm), field); \ } while (0) #else # error "WAN_LISTx macros not supported yet!" #endif #if defined(WAN_KERNEL) #if defined(__FreeBSD__) # define WAN_TAILQ_FIRST(ifp) TAILQ_FIRST(&ifp->if_addrhead) # define WAN_TAILQ_NEXT(ifa) TAILQ_NEXT(ifa, ifa_link) #elif defined (__OpenBSD__) # define WAN_TAILQ_FIRST(ifp) TAILQ_FIRST(&ifp->if_addrlist) # define WAN_TAILQ_NEXT(ifa) TAILQ_NEXT(ifa, ifa_list) #elif defined (__NetBSD__) # define WAN_TAILQ_FIRST(ifp) TAILQ_FIRST(&ifp->if_addrlist) # define WAN_TAILQ_NEXT(ifa) TAILQ_NEXT(ifa, ifa_list) #elif defined(__LINUX__) #elif defined(__SOLARIS__) #elif defined(__WINDOWS__) #else # error "WAN_TAILQ_x macros doesn't supported yet!" #endif #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) # if defined(__FreeBSD__) # define WAN_PKTATTR_DECL(pktattr) # else # define WAN_PKTATTR_DECL(pktattr) struct altq_pktattr pktattr # endif # define WAN_IFQ_SET_READY IFQ_SET_READY # define WAN_IFQ_IS_EMPTY IFQ_IS_EMPTY # define WAN_IFQ_INC_LEN IFQ_INC_LEN # define WAN_IFQ_DEC_LEN IFQ_DEC_LEN # define WAN_IFQ_INC_DROPS IFQ_INC_DROPS # define WAN_IFQ_SET_MAXLEN IFQ_SET_MAXLEN # define WAN_IFQ_PURGE IFQ_PURGE # if (__FreeBSD_version > 503000) # define WAN_IFQ_ENQUEUE(ifq, m, pattr, err) IFQ_ENQUEUE((ifq),(m),(err)) # else # define WAN_IFQ_ENQUEUE IFQ_ENQUEUE # endif # define WAN_IFQ_DEQUEUE IFQ_DEQUEUE # define WAN_IFQ_POLL IFQ_POLL # define WAN_IFQ_CLASSIFY IFQ_CLASSIFY # define WAN_IFQ_INIT IFQ_INIT # define WAN_IFQ_LEN IFQ_LEN #elif defined(__LINUX__) # define WAN_IFQ_INIT(ifq, max_pkt) skb_queue_head_init((ifq)) # define WAN_IFQ_PURGE(ifq) skb_queue_purge((ifq)) # define WAN_IFQ_ENQUEUE(ifq, skb, arg, err) skb_queue_tail((ifq), (skb)) # define WAN_IFQ_LEN(ifq) skb_queue_len((ifq)) #elif defined(__WINDOWS__) #else # error "Undefined IFQ_x macros!" #endif #if defined(__FreeBSD__) # if (__FreeBSD_version < 410000) # define WAN_TASKLET_INIT(task, priority, func, arg) \ (task)->running = 0; \ (task)->task_func = func; (task)->data = arg # define WAN_TASKLET_SCHEDULE(task) \ if (!wan_test_bit(0, &(task)->running)){ \ wan_set_bit(0, &(task)->running); \ (task)->task_func((task)->data, 0); \ } # define __WAN_TASKLET_SCHEDULE(task) WAN_TASKLET_SCHEDULE(task) # define WAN_TASKLET_RUNNING(task) \ wan_test_bit(0, &(task)->running) # define WAN_TASKLET_END(task) wan_clear_bit(0, &(task)->running) # define WAN_TASKLET_RUNNING(task) \ wan_test_bit(0, &(task)->running) # define WAN_TASKLET_KILL(task) # else # define WAN_TASKLET_INIT(task, priority, func, arg) \ (task)->running = 0; \ TASK_INIT(&(task)->task_id, priority, func, (void*)arg) # define WAN_TASKLET_SCHEDULE(task) \ if (!wan_test_bit(0, &(task)->running)){ \ wan_set_bit(0, &(task)->running); \ taskqueue_enqueue(taskqueue_swi, &(task)->task_id); \ } # define __WAN_TASKLET_SCHEDULE(task) WAN_TASKLET_SCHEDULE(task) # define WAN_TASKLET_RUNNING(task) \ wan_test_bit(0, &(task)->running) /* taskqueue_run(taskqueue_swi); \*/ # define WAN_TASKLET_END(task) wan_clear_bit(0, &(task)->running) # define WAN_TASKLET_KILL(task) # endif #elif defined(__OpenBSD__) || defined(__NetBSD__) # define WAN_TASKLET_INIT(task, priority, func, arg) \ (task)->running = 0; \ (task)->task_func = func; (task)->data = arg # define WAN_TASKLET_SCHEDULE(task) \ if (!wan_test_bit(0, &(task)->running)){ \ wan_set_bit(0, &(task)->running); \ (task)->task_func((task)->data, 0); \ } # define __WAN_TASKLET_SCHEDULE(task) WAN_TASKLET_SCHEDULE(task) # define WAN_TASKLET_RUNNING(task) \ wan_test_bit(0, &(task)->running) # define WAN_TASKLET_END(task) wan_clear_bit(0, &(task)->running) # define WAN_TASKLET_KILL(task) #elif defined(__LINUX__) # define WAN_TASKLET_INIT(task, priority, func, arg) \ (task)->running = 0; \ tasklet_init(&(task)->task_id,func,(unsigned long)arg) # define WAN_TASKLET_SCHEDULE(task) \ wan_set_bit(0, &(task)->running); \ tasklet_schedule(&(task)->task_id); #if 0 # define WAN_WP_TASKLET_SCHEDULE_PER_CPU(task,cpu) \ wan_set_bit(0, &(task)->running); \ wp_tasklet_hi_schedule_per_cpu(&(task)->task_id,cpu); #endif # define WAN_TASKLET_RUNNING(task) \ wan_test_bit(0, &(task)->running) # define WAN_TASKLET_END(task) wan_clear_bit(0, &(task)->running) # define WAN_TASKLET_KILL(task) tasklet_kill(&(task)->task_id) #elif defined(__WINDOWS__) #else # error "Undefined WAN_TASKLET_x macro!" #endif #if defined(__FreeBSD__) # if (__FreeBSD_version < 410000) # define WAN_TASKQ_INIT(task, priority, func, arg) \ (task)->tfunc = func; task->data = arg # else # define WAN_TASKQ_INIT(task, priority, func, arg) \ TASK_INIT(&task->tqueue, priority, func, arg) # endif #elif defined(__OpenBSD__) # define WAN_TASKQ_INIT(task, priority, func, arg) \ (task)->tfunc = func; task->data = arg #elif defined(__NetBSD__) # define WAN_TASKQ_INIT(task, priority, func, arg) \ (task)->tfunc = func; task->data = arg #elif defined(__LINUX__) /* Due to 2.6.20 kernel the wan_taskq_t is now a direct * workqueue struct not an abstracted structure */ # if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)) # define WAN_TASKQ_INIT(task, priority, func, arg) \ INIT_WORK((task),func,arg) # else # define WAN_TASKQ_INIT(task, priority, func, arg) \ INIT_WORK((task),func) # endif #elif defined(__WINDOWS__) #else # error "Undefined WAN_TASKQ_INIT macro!" #endif #if defined(__FreeBSD__) && (__FreeBSD_version >= 410000) # define WAN_IS_TASKQ_SCHEDULE # define WAN_TASKQ_SCHEDULE(task) \ taskqueue_enqueue(taskqueue_swi, &task->tqueue);\ taskqueue_run(taskqueue_swi) #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) # define WAN_IS_TASKQ_SCHEDULE # define WAN_TASKQ_SCHEDULE(task) \ task->tfunc(task->data, 0) #elif defined(__LINUX__) # define WAN_IS_TASKQ_SCHEDULE # define WAN_TASKQ_SCHEDULE(task) \ wan_schedule_task(task) #elif defined(__WINDOWS__) #else # error "Undefined WAN_TASKQ_SCHEDULE macro!" #endif #if defined(__LINUX__) # define WAN_COPY_FROM_USER(k,u,l) copy_from_user(k,u,l) # define WAN_COPY_TO_USER(u,k,l) copy_to_user(u,k,l) #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) # define WAN_COPY_FROM_USER(k,u,l) copyin(u,k,l) # define WAN_COPY_TO_USER(u,k,l) copyout(k,u,l) #elif defined(__WINDOWS__) #else # error "Undefined WAN_COPY_FROM_USER/WAN_COPY_TO_USER macros!" #endif #if defined(__LINUX__) # if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,43)) # define WAN_NETIF_WAKE_QUEUE(dev) do { \ clear_bit(0, &dev->tbusy); \ mark_bh(NET_BH); \ } while(0) # define WAN_NETIF_START_QUEUE(dev) do { \ dev->tbusy = 0; \ dev->interrupt = 0; \ dev->start = 1; \ } while(0); # define WAN_NETIF_STOP_QUEUE(dev) set_bit(0, &dev->tbusy) # define WAN_NETIF_RUNNING(dev) dev->start # define WAN_NETDEVICE_START(dev) dev->start = 1 # define WAN_NETDEVICE_STOP(dev) dev->start = 0 # define WAN_NETIF_QUEUE_STOPPED(dev) test_bit(0,&dev->tbusy) # define WAN_NETIF_CARRIER_OFF(dev) # define WAN_NETIF_CARRIER_ON(dev) # define WAN_NETIF_CARRIER_OK(dev) 1 # else #if 0 # define WAN_NETIF_WAKE_QUEUE(dev) do{ \ if (((wanpipe_common_t *)dev->priv)->usedby == TDM_VOICE){ \ DEBUG_EVENT("%s: TDM VOICE not waking but starting!!!!\n",dev->name); \ netif_start_queue(dev); \ }else{ \ netif_wake_queue(dev); \ } \ }while(0) #endif # define WAN_NETIF_WAKE_QUEUE(dev) netif_wake_queue(dev); # define WAN_NETIF_START_QUEUE(dev) netif_start_queue(dev) # define WAN_NETIF_STOP_QUEUE(dev) netif_stop_queue(dev) # define WAN_NETIF_RUNNING(dev) netif_running(dev) # define WAN_NETDEVICE_START(dev) # define WAN_NETDEVICE_STOP(dev) # define WAN_NETIF_QUEUE_STOPPED(dev) netif_queue_stopped(dev) # define WAN_NETIF_CARRIER_OFF(dev) netif_carrier_off(dev) # define WAN_NETIF_CARRIER_ON(dev) netif_carrier_on(dev) # define WAN_NETIF_CARRIER_OK(dev) netif_carrier_ok(dev) # endif # define WAN_NETIF_UP(dev) ((dev)->flags&IFF_UP) # define WAN_NET_RATELIMIT net_ratelimit #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) # define WAN_NETIF_QUEUE_STOPPED(dev) (dev)->if_flags & IFF_DRV_OACTIVE # define WAN_NETIF_WAKE_QUEUE(dev) (dev)->if_flags &= ~IFF_DRV_OACTIVE #if 0 # define WAN_NETIF_STOP_QUEUE(dev) # define WAN_NETIF_START_QUEUE(dev) #endif # define WAN_NETIF_STOP_QUEUE(dev) (dev)->if_flags |= IFF_DRV_OACTIVE # define WAN_NETIF_START_QUEUE(dev) (dev)->if_flags &= ~IFF_DRV_OACTIVE # define WAN_NETIF_RUNNING(dev) 1 # define WAN_NETIF_UP(dev) ((dev)->if_flags&IFF_UP) # define WAN_NETDEVICE_STOP(dev) # define WAN_NETDEVICE_START(dev) # define NET_ADMIN_CHECK() # define WAN_NET_RATELIMIT() 1 # define MOD_INC_USE_COUNT # define MOD_DEC_USE_COUNT # define WAN_NETIF_CARRIER_OFF(dev) # define WAN_NETIF_CARRIER_ON(dev) # define WAN_NETIF_CARRIER_OK(dev) 1 #elif defined(__WINDOWS__) #else # error "Undefined WAN_NETIF_x macros!" #endif #if defined(__LINUX__) # define WAN_BPF_DIR_IN (1<<0) # define WAN_BPF_DIR_OUT (1<<1) # define WAN_BPF_REPORT(dev,m) #elif defined(__FreeBSD__) # define WAN_BPF_DIR_IN (1<<0) # define WAN_BPF_DIR_OUT (1<<1) # if (__FreeBSD_version > 500000) # define WAN_BPF_REPORT(dev,m,d) bpf_mtap((dev)->if_bpf, (m)) # else # define WAN_BPF_REPORT(dev,m,d) bpf_mtap((dev), (m)) # endif #elif defined(__OpenBSD__) # if (OpenBSD < 200611) # define WAN_BPF_DIR_IN (1<<0) # define WAN_BPF_DIR_OUT (1<<1) # define WAN_BPF_REPORT(dev,m,d) bpf_mtap((dev)->if_bpf, (m)); # else # define WAN_BPF_DIR_IN BPF_DIRECTION_IN # define WAN_BPF_DIR_OUT BPF_DIRECTION_OUT # define WAN_BPF_REPORT(dev,m,d) \ if (dir == WAN_BPF_DIR_IN){ \ bpf_mtap((dev)->if_bpf, (m), BPF_DIRECTION_IN); \ }else{ \ bpf_mtap((dev)->if_bpf, (m), BPF_DIRECTION_OUT); \ } # endif #elif defined(__NetBSD__) # define WAN_BPF_DIR_IN (1<<0) # define WAN_BPF_DIR_OUT (1<<1) # define WAN_BPF_REPORT(dev,m,d) bpf_mtap((dev)->if_bpf, (m)); #elif defined(__WINDOWS__) #else # error "Undefined WAN_BPF_REPORT macro!" #endif #if defined (__LINUX__) # define WAN_DEV_PUT(dev) wan_atomic_dec(&(dev)->refcnt) # define WAN_DEV_HOLD(dev) wan_atomic_inc(&(dev)->refcnt) # define __WAN_PUT(str) wan_atomic_dec(&(str)->refcnt) # define WAN_PUT(str) if (atomic_dec_and_test(&(str)->refcnt)){ \ wan_kfree(str); \ } # define WAN_HOLD(str) wan_atomic_inc(&(str)->refcnt) #elif defined(__FreeBSD__) # define WAN_DEV_PUT(dev) # define WAN_DEV_HOLD(dev) # define __WAN_PUT(str) wan_atomic_dec(&(str)->refcnt) # define WAN_PUT(str) wan_atomic_dec(&str->refcnt); \ if (str->refcnt){ \ WAN_FREE(str); \ } # define WAN_HOLD(str) wan_atomic_inc(&(str)->refcnt) #elif defined(__NetBSD__) || defined(__OpenBSD__) # define WAN_DEV_PUT(dev) # define WAN_DEV_HOLD(dev) # define __WAN_PUT(str) str->refcnt-- # define WAN_PUT(str) str->refcnt--; \ if (str->refcnt){ \ WAN_FREE(str); \ } # define WAN_HOLD(str) str->refcnt++ #elif defined(__WINDOWS__) #else # warning "Undefined WAN_HOLD/WAN_PUT macro!" #endif #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) # ifdef ENABLE_SPPP # define WAN_SPPP_ENABLED 1 # define WAN_SPPP_ATTACH(ifp) sppp_attach(ifp) # define WAN_SPPP_DETACH(ifp) sppp_detach(ifp) # define WAN_SPPP_FLUSH(ifp) sppp_flush(ifp) # define WAN_SPPP_PICK(ifp) sppp_pick(ifp) # define WAN_SPPP_DEQUEUE(ifp) sppp_dequeue(ifp) # define WAN_SPPP_ISEMPTY(ifp) sppp_isempty(ifp) # define WAN_SPPP_INPUT(ifp,skb) sppp_input(ifp,skb) # define WAN_SPPP_IOCTL(ifp,cmd,data) sppp_ioctl(ifp,cmd,data); # else # define WAN_SPPP_ENABLED 0 # define WAN_SPPP_ATTACH(ifp) # define WAN_SPPP_DETACH(ifp) # define WAN_SPPP_FLUSH(ifp) # define WAN_SPPP_PICK(ifp) NULL # define WAN_SPPP_DEQUEUE(ifp) NULL # define WAN_SPPP_ISEMPTY(ifp) 0 # define WAN_SPPP_INPUT(ifp,skb) # define WAN_SPPP_IOCTL(ifp,cmd,data) -EOPNOTSUPP # endif #elif defined(__LINUX__) # define WAN_SPPP_ENABLED 1 # define WAN_SPPP_IOCTL(ifp,cmd,data) -EOPNOTSUPP #elif defined(__WINDOWS__) #else # error "Undefined WAN_SPPP_x macros!" #endif #define WAN_MAX_TRACE_TIMEOUT (5*HZ) #if 0 /* * Variable argument list macro definitions */ #ifndef _VALIST #define _VALIST typedef char *va_list; #endif /* _VALIST */ #define _WAN_VA_SIZE(type) (((sizeof(type) + sizeof(long) - 1) / sizeof(long)) * sizeof(long)) #define WAN_VA_START(ap, A) ((ap) = (va_list) &(A) + _WAN_VA_SIZE(A)) #define WAN_VA_ARG(ap, T) (*(T *)((ap) += _WAN_VA_SIZE(T),(ap) - _WAN_VA_SIZE (T))) #define WAN_VA_END(ap) (void) 0 #endif /**************************************************************************** ** T Y P E D E F S ****************************************************************************/ # if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) /* * Ethernet statistics collection data */ struct net_device_stats { unsigned long rx_packets; /* total packets received */ unsigned long tx_packets; /* total packets transmited */ unsigned long rx_bytes; /* total bytes received */ unsigned long tx_bytes; /* total bytes transmited */ unsigned long rx_errors; /* bad packet received */ unsigned long tx_errors; /* packet transmit problems */ unsigned long rx_dropped; /* no space in buffers */ unsigned long tx_dropped; /* no space available */ unsigned long multicast; /* multicast packet received */ unsigned long collisions; /* detailed rx_errors */ unsigned long rx_length_errors; unsigned long rx_over_errors; /* receiver ring off buff overflow */ unsigned long rx_crc_errors; /* recv'd pkt with crc error */ unsigned long rx_frame_errors; /* recv'd frame alignment error */ unsigned long rx_fifo_errors; /* recv'r fifo overrun */ unsigned long rx_missed_errors; /* receiver missed packet */ /* detailed tx_errors */ unsigned long tx_aborted_errors; unsigned long tx_carrier_errors; unsigned long tx_fifo_errors; unsigned long tx_heartbeat_errors; unsigned long tx_window_errors; /* for cslip etc */ unsigned long rx_compressed; unsigned long tx_compressed; }; #endif /**************************************************************************** ** F U N C T I O N P R O T O T Y P E S ****************************************************************************/ unsigned int wan_dec2uint (unsigned char* str, int len); char* wanpipe_get_state_string (void*); void wanpipe_set_state (void*, int); char wanpipe_get_state (void*); void wanpipe_card_lock_irq (void *,unsigned long *); void wanpipe_card_unlock_irq (void *,unsigned long *); void wanpipe_set_baud(void*card,unsigned int baud); unsigned long wan_get_ip_addr (void*, int); int wan_udp_pkt_type (void*, caddr_t); int wan_reply_udp (void*, unsigned char*, unsigned int); unsigned short wan_calc_checksum(char *data, int len); void wanpipe_debug_timer_init(void*); void wan_trace_info_init(wan_trace_t *trace, int max_trace_queue); int wan_trace_purge (wan_trace_t *trace); int wan_trace_enqueue(wan_trace_t *trace, void *skb_ptr); int wan_tracing_enabled(wan_trace_t *trace_info); #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) void wanpipe_debugging (void* data, int pending); #else void wanpipe_debugging (unsigned long data); #endif static __inline int wan_skb_tailroom(void* skb); /**************************************************************************** ** I N L I N E F U N C T I O N S ****************************************************************************/ /******************* WANPIPE MALLOC/FREE FUNCTION ******************/ /* ** wan_malloc - */ static __inline void* wan_malloc(int size) { void* ptr = NULL; #if defined(__LINUX__) ptr = kmalloc(size, GFP_ATOMIC); if (ptr){ DEBUG_ADD_MEM(size); } #elif defined(__SOLARIS__) ptr=kmem_alloc(size,KM_NOSLEEP); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) ptr = malloc(size, M_DEVBUF, M_NOWAIT); #elif defined(__WINDOWS__) ptr = ExAllocatePool(NonPagedPool, size); #else # error "wan_malloc() function is not supported yet!" #endif if (ptr){ memset(ptr, 0, size); DEBUG_ADD_MEM(size); } return ptr; } static __inline void* wan_kmalloc(int size) { void* ptr = NULL; #if defined(__LINUX__) ptr = kmalloc(size, GFP_KERNEL); if (ptr){ DEBUG_ADD_MEM(size); } #elif defined(__SOLARIS__) ptr=kmem_alloc(size,KM_NOSLEEP); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) ptr = malloc(size, M_DEVBUF, M_NOWAIT); #elif defined(__WINDOWS__) ptr = ExAllocatePool(NonPagedPool, size); #else # error "wan_malloc() function is not supported yet!" #endif if (ptr){ memset(ptr, 0, size); DEBUG_ADD_MEM(size); } return ptr; } /* ** wan_free - */ static __inline void wan_free(void* ptr) { if (!ptr){ DEBUG_EVENT("wan_free: NULL PTR !!!!!\n"); return; } #if defined(__LINUX__) kfree(ptr); #elif defined(__SOLARIS__) kmem_free(ptr,sizeof(*ptr)); DEBUG_EVENT("%s: Feeing Size %i\n",__FUNCTION__,sizeof(*ptr)); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return free(ptr, M_DEVBUF); #elif defined(__WINDOWS__) ExFreePool(ptr); #else # error "wan_free() function is not supported yet!" #endif } static __inline void* wan_vmalloc(int size) { void* ptr = NULL; #if defined(__LINUX__) ptr = vmalloc(size); if (ptr){ DEBUG_ADD_MEM(size); } #elif defined(__FreeBSD__) ptr = (caddr_t)kmem_alloc(kernel_map, size + sizeof(vm_size_t)); if (ptr){ vm_size_t *ptr1 = (vm_size_t*)ptr; bzero(ptr, size); *ptr1 = size + sizeof(vm_size_t); ptr = ptr1++; } #elif defined(__OpenBSD__) || defined(__NetBSD__) ptr = (caddr_t)uvm_km_alloc(kernel_map, size + sizeof(vsize_t)); if (ptr){ vsize_t *ptr1 = (vsize_t*)ptr; bzero(ptr, size); *ptr1 = size + sizeof(vsize_t); ptr = ptr1++; } #elif defined(__SOLARIS__) #elif defined(__WINDOWS__) #else # error "wan_vmalloc() function is not supported yet!" #endif if (ptr){ memset(ptr, 0, size); DEBUG_ADD_MEM(size); } return ptr; } /* ** wan_vfree - */ static __inline void wan_vfree(void* ptr) { if (!ptr){ DEBUG_EVENT("wan_vfree: NULL PTR !!!!!\n"); return; } #if defined(__LINUX__) vfree(ptr); #elif defined(__FreeBSD__) { vm_size_t *ptr1 = (vm_size_t*)ptr; ptr1 --; kmem_free(kernel_map, (vm_offset_t)ptr1, (vm_size_t)*ptr1); } #elif defined(__OpenBSD__) || defined(__NetBSD__) { vsize_t *ptr1 = (vsize_t*)ptr; ptr1 --; uvm_km_free(kernel_map, (vaddr_t)ptr1, (vsize_t)*ptr1); } #elif defined(__SOLARIS__) #elif defined(__WINDOWS__) #else # error "wan_free() function is not supported yet!" #endif return; } /******************* WANPIPE VIRT<->BUS SPACE FUNCTION ******************/ /* ** wan_virt2bus */ static __inline unsigned long wan_virt2bus(unsigned long* ptr) { #if defined(__LINUX__) return virt_to_bus(ptr); #elif defined(__FreeBSD__) return vtophys((vm_offset_t)ptr); #elif defined(__OpenBSD__) || defined(__NetBSD__) return vtophys((vaddr_t)ptr); #elif defined(__WINDOWS__) #else # error "wan_virt2bus() function is not supported yet!" #endif } /* ** wan_bus2virt */ static __inline unsigned long* wan_bus2virt(unsigned long virt_addr) { #if defined(__LINUX__) return bus_to_virt(virt_addr); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return (unsigned long*)virt_addr; #elif defined(__WINDOWS__) #else # error "wan_bus2virt() function is not supported yet!" #endif } /******************* WANPIPE DMA FUNCTION ******************/ /* ** wan_dma_alloc */ static __inline int wan_dma_alloc(void* hw, wan_dma_descr_t* dma_descr) { int err = 0; #if defined(__FreeBSD__) err = bus_dma_tag_create(/*parent*/NULL, /*alignemnt*/1, /*boundary*/0, /*lowaddr*/BUS_SPACE_MAXADDR_32BIT, /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL, /*filterarg*/NULL, /*maxsize*/dma_descr->max_length, # if (__FreeBSD_version >= 502000) /*nsegments*/1, # else /*nsegments*/BUS_SPACE_UNRESTRICTED, # endif /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT, /*flags*/0, # if (__FreeBSD_version >= 502000) /*lockfunc*/NULL, /*lockfuncarg*/NULL, # endif &dma_descr->dmat); if (err){ DEBUG_EVENT("Failed create DMA tag (size=%ld)!\n", dma_descr->max_length); dma_descr->max_length = 0; return err; } err = bus_dmamem_alloc(dma_descr->dmat, (void**)&dma_descr->vAddr, BUS_DMA_NOWAIT, &dma_descr->dmamap); if (err){ DEBUG_EVENT("Failed allocate DMA (size=%ld)!\n", dma_descr->max_length); bus_dma_tag_destroy(dma_descr->dmat); dma_descr->max_length = 0; return err; } #elif defined(__OpenBSD__) || defined(__NetBSD__) err = bus_dmamem_alloc(dma_descr->dmat, /* dma tag */ dma_descr->max_length, /* size */ PAGE_SIZE, /* alignment */ 0, /* boundary */ &dma_descr->dmaseg, /* serments */ 1, /* num of segments */ &dma_descr->rsegs, /* R num of segments */ BUS_DMA_NOWAIT); if (err){ DEBUG_EVENT("Failed allocate DMA segment (size=%ld)!\n", dma_descr->max_length); dma_descr->max_length = 0; return err; } err = bus_dmamem_map(dma_descr->dmat, /* dma tag */ &dma_descr->dmaseg, /* segments */ dma_descr->rsegs, /* return num of segments */ dma_descr->max_length, /* size */ (caddr_t*)&dma_descr->vAddr, /* kernel virtual address */ BUS_DMA_NOWAIT); if (err){ DEBUG_EVENT("Failed map DMA segment (size=%ld)!\n", dma_descr->max_length); dma_descr->max_length = 0; bus_dmamem_free(dma_descr->dmat, &dma_descr->dmaseg, dma_descr->rsegs); return err; } #elif defined(__LINUX__) dma_descr->vAddr = pci_alloc_consistent(NULL, dma_descr->max_length, (dma_addr_t *)&dma_descr->pAddr); if (dma_descr->vAddr == NULL){ err = -ENOMEM; } #elif defined(__WINDOWS__) return -EINVAL; #else # error "wan_dma_alloc() function is not supported yet!" #endif return err; } /* ** wan_dma_free */ static __inline int wan_dma_free(void* hw, wan_dma_descr_t* dma_descr) { #if defined(__FreeBSD__) bus_dmamem_free(dma_descr->dmat, dma_descr->vAddr, dma_descr->dmamap); return bus_dma_tag_destroy(dma_descr->dmat); #elif defined(__OpenBSD__) || defined(__NetBSD__) bus_dmamem_unmap(dma_descr->dmat, (caddr_t)dma_descr->vAddr, dma_descr->max_length); bus_dmamem_free(dma_descr->dmat, &dma_descr->dmaseg, dma_descr->rsegs); #elif defined(__LINUX__) DEBUG_TEST("Freeing Pages 0x%p len=%li order=%i\n", dma_descr->vAddr, dma_descr->max_length, get_order(dma_descr->max_length)); pci_free_consistent(NULL, dma_descr->max_length,dma_descr->vAddr,dma_descr->pAddr); dma_descr->vAddr = NULL; dma_descr->pAddr = 0; #elif defined(__WINDOWS__) return -EINVAL; #else # error "wan_dma_free() function is not supported yet!" #endif return 0; } static __inline unsigned long* wan_dma_get_vaddr(void* card, wan_dma_descr_t* dma) { return dma->vAddr; } static __inline unsigned long wan_dma_get_paddr(void* card, wan_dma_descr_t* dma) { return wan_virt2bus(dma->vAddr); } /********************** WANPIPE TIMER FUNCTION **************************/ static __inline int wan_getcurrenttime(unsigned long *sec, unsigned long *usec) { #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct timeval tv; microtime(&tv); if (sec) *sec = tv.tv_sec; if (usec) *usec = tv.tv_usec; return 0; #elif defined(__WINDOWS__) LARGE_INTEGER tv; NdisGetCurrentSystemTime(&tv); if (sec) *sec = (unsigned long)tv.QuadPart; return 0; #elif defined(__LINUX__) struct timeval tv; do_gettimeofday(&tv); if (sec) *sec = tv.tv_sec; if (usec) *usec = tv.tv_usec; return 0; #else # error "wan_getcurrenttime() function is not supported yet!" #endif } /* ** wan_init_timer */ static __inline void wan_init_timer(wan_timer_t* wan_timer, wan_timer_func_t timer_func, wan_timer_arg_t arg) { #if defined(__LINUX__) init_timer(&wan_timer->timer_info); wan_timer->timer_info.function = timer_func; wan_timer->timer_info.data = arg; #elif defined(__FreeBSD__) /* FIXME_ADSL_TIMER */ callout_handle_init(&wan_timer->timer_info); wan_timer->timer_func = timer_func; wan_timer->timer_arg = arg; #elif defined(__OpenBSD__) timeout_set(&wan_timer->timer_info, timer_func, (void*)arg); wan_timer->timer_func = timer_func; wan_timer->timer_arg = arg; #elif defined(__NetBSD__) callout_init(&wan_timer->timer_info); wan_timer->timer_func = timer_func; wan_timer->timer_arg = arg; #elif defined(__WINDOWS__) #else # error "wan_init_timer() function is not supported yet!" #endif /* linux */ } /* ** wan_del_timer */ static __inline void wan_del_timer(wan_timer_t* wan_timer) { #if defined(__LINUX__) if (!wan_timer->timer_info.function){ if (WAN_NET_RATELIMIT()){ DEBUG_EVENT("%s:%d Warning: WAN Timer del error: func=%p\n", __FUNCTION__,__LINE__, wan_timer->timer_info.function); } return; } del_timer(&wan_timer->timer_info); #elif defined(__FreeBSD__) untimeout(wan_timer->timer_func, (void*)wan_timer->timer_arg, wan_timer->timer_info); callout_handle_init(&wan_timer->timer_info); #elif defined(__OpenBSD__) timeout_del(&wan_timer->timer_info); #elif defined(__NetBSD__) callout_stop(&wan_timer->timer_info); #else # error "wan_del_timer() function is not supported yet!" #endif /* linux */ } /* ** wan_add_timer */ static __inline int wan_add_timer(wan_timer_t* wan_timer, unsigned long delay) { #if defined(__LINUX__) if (timer_pending(&wan_timer->timer_info) || !wan_timer->timer_info.function){ if (WAN_NET_RATELIMIT()){ DEBUG_EVENT("%s:%d Warning: WAN Timer add error: pending or func=%p\n", __FUNCTION__,__LINE__, wan_timer->timer_info.function); } return -EINVAL; } wan_timer->timer_info.expires = SYSTEM_TICKS + delay; add_timer(&wan_timer->timer_info); #elif defined(__FreeBSD__) wan_timer->timer_info = timeout(wan_timer->timer_func, (void*)wan_timer->timer_arg, delay); WAN_ASSERT1(wan_timer->timer_info.callout == NULL); #elif defined(__OpenBSD__) timeout_add(&wan_timer->timer_info, delay); #elif defined(__NetBSD__) wan_timer->timer_info.c_time = delay; callout_reset(&wan_timer->timer_info, delay, wan_timer->timer_func, wan_timer->timer_arg); #else # error "wan_add_timer() function is not supported yet!" #endif /* linux */ return 0; } /********************** WANPIPE KERNEL BUFFER **************************/ /* ** wan_skb_data() - ** Returns pointer to data. */ static __inline unsigned char* wan_skb_data(void* skb) { #if defined(__LINUX__) return ((struct sk_buff*)skb)->data; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return mtod((struct mbuf*)skb, caddr_t); #elif defined(__SOLARIS__) return ((netskb_t*)mp)->b_rptr; #else # error "wan_skb_data() function is not supported yet!" #endif } /* ** wan_skb_tail() - ** Returns pointer to data. */ static __inline unsigned char* wan_skb_tail(void* skb) { #if defined(__LINUX__) return wan_skb_tail_pointer((struct sk_buff*)skb); #elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) return mtod((struct mbuf*)skb, caddr_t) + ((struct mbuf*)skb)->m_len; #elif defined(__SOLARIS__) return ((netskb_t*)mp)->b_wptr; #else # error "wan_skb_tail() function is not supported yet!" #endif } /* ** wan_skb_append() - ** Returns pointer to data. */ static __inline void wan_skb_append(void* skbprev, void *skb, void *list) { #if defined(__LINUX__) # if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)) skb_append(skbprev,skb); # else skb_append(skbprev,skb,list); # endif #elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) m_cat (skbprev, skb); #else # error "wan_skb_append() function is not supported yet!" #endif } /* ** wan_skb_len() - ** Returns current kernel buffer length. */ static __inline int wan_skb_len(void* skb) { #if defined(__LINUX__) return ((struct sk_buff*)skb)->len; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return ((struct mbuf*)skb)->m_len; #elif defined(__SOLARIS__) mblk_t* tmp = skb; int len = 0; while(tmp) { len += (tmp->b_wptr - tmp->b_rptr); tmp = tmp->b_cont; } return len; #else # error "wan_skb_len() function is not supported yet!" #endif } /* ** wan_skb_free() - ** Free kernel memory buffer. */ static __inline void wan_skb_free(void* skb) { #if defined(__LINUX__) #if defined(WAN_DEBUG_MEM) DEBUG_SUB_MEM(((struct sk_buff*)skb)->truesize); #endif dev_kfree_skb_any(skb); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) m_freem(skb); #elif defined(__SOLARIS__) freemsg(skb); #else # error "wan_skb_free() function is not supported yet!" #endif } /* ** wan_skb_set_mark() - ** Set mark for skb. */ static __inline void wan_skb_set_mark(void* pskb) { #if defined(__LINUX__) return; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) ((netskb_t*)pskb)->m_flags |= WAN_MFLAG_PRV; #endif return; } /* ** wan_skb_clear_mark() - ** Clear mark from skb. */ static __inline void wan_skb_clear_mark(void* pskb) { #if defined(__LINUX__) return; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) ((netskb_t*)pskb)->m_flags &= ~WAN_MFLAG_PRV; #endif return; } /* ** wan_skb_mark() - ** Return 1 if mark is set, otherwise 0. */ static __inline int wan_skb_mark(void* pskb) { #if defined(__LINUX__) return 0; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return (((netskb_t*)pskb)->m_flags & WAN_MFLAG_PRV); #endif return 0; } /* ** wan_skb_alloc() - ** Allocate kernel buffer with len. */ static __inline void* wan_skb_alloc(unsigned int len) { #if defined(__LINUX__) #if defined(WAN_DEBUG_MEM) struct sk_buff *skb=dev_alloc_skb(len); if (skb){ DEBUG_ADD_MEM(skb->truesize); } return (void*)skb; #else return (void*)dev_alloc_skb(len); #endif #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf *new = NULL; if (len){ MGETHDR(new, M_DONTWAIT, MT_DATA); }else{ MGET(new, M_DONTWAIT, MT_DATA); } if (new){ if (new->m_flags & M_PKTHDR){ new->m_pkthdr.len = 0; } new->m_len = 0; MCLGET(new, M_DONTWAIT); if ((new->m_flags & M_EXT) == 0){ wan_skb_free(new); return NULL; } /* Always reserve extra 16 bytes (as Linux) ** for the header */ new->m_data += 16; wan_skb_set_mark(new); return (void*)new; } return NULL; #elif defined (__SOLARIS__) mblk_t *mp=allocb(ROUNDUP(len+16, IOC_LINESIZE), BPRI_MED); if (mp){ caddr_t ptr= (caddr_t) ROUNDUP((long)mp->b_rptr, 1); mp->b_rptr=(uchar_t *)ptr+16; } return mp; #else # error "wan_skb_alloc() function is not supported yet!" #endif } static __inline void* wan_skb_kalloc(unsigned int len) { #if defined(__LINUX__) #if defined(WAN_DEBUG_MEM) struct sk_buff *skb=__dev_alloc_skb(len,GFP_KERNEL); if (skb){ DEBUG_ADD_MEM(skb->truesize); } return (void*)skb; #else return (void*)__dev_alloc_skb(len,GFP_KERNEL); #endif #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf *new = NULL; if (len){ MGETHDR(new, M_DONTWAIT, MT_DATA); }else{ MGET(new, M_DONTWAIT, MT_DATA); } if (new){ if (new->m_flags & M_PKTHDR){ new->m_pkthdr.len = 0; } new->m_len = 0; MCLGET(new, M_DONTWAIT); if ((new->m_flags & M_EXT) == 0){ wan_skb_free(new); return NULL; } /* Always reserve extra 16 bytes (as Linux) ** for the header */ new->m_data += 16; wan_skb_set_mark(new); return (void*)new; } return NULL; #elif defined (__SOLARIS__) mblk_t *mp=allocb(ROUNDUP(len+16, IOC_LINESIZE), BPRI_MED); if (mp){ caddr_t ptr= (caddr_t) ROUNDUP((long)mp->b_rptr, 1); mp->b_rptr=(uchar_t *)ptr+16; } return mp; #else # error "wan_skb_kalloc() function is not supported yet!" #endif } /* ** wan_skb_set_dev() - ** Set device point. */ static __inline void wan_skb_set_dev(void* pskb, void* dev) { #if defined(__LINUX__) struct sk_buff *skb = (struct sk_buff*)pskb; if (skb){ skb->dev = dev; } #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) netskb_t* m = (netskb_t*)pskb; if (m){ m->m_pkthdr.rcvif = dev; } #else # error "wan_skb_set_dev() function is not supported yet!" #endif } static __inline void wan_skb_set_protocol(void* pskb, unsigned int protocol) { #if defined(__LINUX__) struct sk_buff *skb = (struct sk_buff*)pskb; if (skb){ skb->protocol = htons(protocol); } #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf *mbuf = (struct mbuf*)pskb; if (protocol == ETH_P_IPX){ mbuf->m_flags |= M_PROTO1; } #else # warning "wan_skb_set_protocol() function is not supported yet!" #endif } static __inline void wan_skb_set_raw(void* pskb) { #if defined(__LINUX__) struct sk_buff *skb = (struct sk_buff*)pskb; if (skb){ wan_skb_reset_mac_header(skb); wan_skb_reset_network_header(skb); } #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) #else # warning "wan_skb_set_raw() function is not supported yet!" #endif } /* ** wan_skb_set_csum() - ** Set checksum. */ static __inline void wan_skb_set_csum(void* skb, unsigned int csum) { #if defined(__LINUX__) struct sk_buff *sk = (struct sk_buff*)skb; if (sk){ sk->csum = csum; } #elif defined(__OpenBSD__) netskb_t* m = (netskb_t*)skb; if (m){ # if (OpenBSD >= 200511) m->m_pkthdr.csum_flags = csum; # else m->m_pkthdr.csum = csum; # endif } #elif defined(__NetBSD__) || defined(__FreeBSD__) netskb_t* m = (netskb_t*)skb; if (m){ m->m_pkthdr.csum_data = csum; } #else # error "wan_skb_set_csum() function is not supported yet!" #endif } /* ** wan_skb_csum() - ** Return checksum value. */ static __inline unsigned int wan_skb_csum(void* skb) { #if defined(__LINUX__) struct sk_buff *sk = (struct sk_buff*)skb; return (sk) ? sk->csum : 0; #elif defined(__NetBSD__) || defined(__FreeBSD__) netskb_t* m = (netskb_t*)skb; return (m) ? m->m_pkthdr.csum_data : 0; #elif defined(__OpenBSD__) netskb_t* m = (netskb_t*)skb; # if (OpenBSD >= 200511) return (m) ? m->m_pkthdr.csum_flags : 0; # else return (m) ? m->m_pkthdr.csum : 0; # endif #else # error "wan_skb_set_dev() function is not supported yet!" #endif } /* ** wan_skb_check() - ** Check if packet consists from one skb block. */ static __inline int wan_skb_check(void* skb) { #if defined(__LINUX__) return 0; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) netskb_t* m = (netskb_t*)skb; if (m->m_pkthdr.len != m->m_len){ return 1; } return 0; #else # error "wan_skb_check() function is not supported yet!" #endif } /* ** wan_skb_reserve() - ** Reserve extra bytes before data */ static __inline void wan_skb_reserve(void* skb, unsigned int len) { #if defined(__LINUX__) skb_reserve(skb, len); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf *m = (struct mbuf*)skb; m->m_data += len; #else # error "wan_skb_free() function is not supported yet!" #endif } /* ** wan_skb_copyback() - ** Copy data from a buffer back into the indicated mbuf chain, ** starting "off" bytes from the beginning, extending the mbuf ** chain if necessary. */ static __inline void wan_skb_copyback(void* skb, int off, int len, caddr_t cp) { #if defined(__LINUX__) struct sk_buff* sk = (struct sk_buff*)skb; unsigned char* data = NULL; if (off == wan_skb_len(skb)){ if (len > wan_skb_tailroom(sk)){ DEBUG_EVENT("wan_skb_copyback: Internal Error (off=%d,len=%d,skb_len=%d)!\n", off, len, wan_skb_len(skb)); return; }else{ data = skb_put(skb, len); memcpy(data, cp, len); } }else{ if (off + len > wan_skb_len(skb)){ data = skb_put(skb, len); memcpy(data + off, cp, len); skb_trim(skb, off + len); } } #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)skb; caddr_t data = mtod(m, caddr_t); bcopy(cp, &data[off], len); m->m_len = off + len; m->m_pkthdr.len = off + len; #else # error "wan_skb_copyback() function is not supported yet!" #endif } /* ** wan_skb_copyback_user() - ** Copy data from a buffer back into the indicated mbuf chain, ** starting "off" bytes from the beginning, extending the mbuf ** chain if necessary. ** Data being copied is coming from user space, thus we must ** use a special function to copy it into kernel space. */ static __inline int wan_skb_copyback_user(void* skb, int off, int len, caddr_t cp) { #if defined(__LINUX__) struct sk_buff* sk = (struct sk_buff*)skb; unsigned char* data = NULL; if (off == wan_skb_len(skb)){ if (len > wan_skb_tailroom(sk)) { DEBUG_EVENT("wan_skb_copyback_user: Internal Error (off=%d,len=%d,skb_len=%d)!\n", off, len, wan_skb_len(skb)); return -EINVAL; }else{ data = skb_put(skb, len); if (WAN_COPY_FROM_USER(data, cp, len)){ DEBUG_EVENT("wan_skb_copyback_user: Internal Error (off=%d,len=%d,skb_len=%d)!\n", off, len, wan_skb_len(skb)); return -EFAULT; } } }else{ if (off + len > wan_skb_len(skb)){ data = skb_put(skb, len); if (WAN_COPY_FROM_USER(data+off, cp, len)){ DEBUG_EVENT("wan_skb_copyback_user: Internal Error (off=%d,len=%d,skb_len=%d)!\n", off, len, wan_skb_len(skb)); return -EFAULT; } skb_trim(skb, off + len); } } return 0; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)skb; caddr_t data = mtod(m, caddr_t); WAN_COPY_FROM_USER(cp, &data[off], len); m->m_len = off + len; m->m_pkthdr.len = off + len; #else # error "wan_skb_copyback_user() function is not supported yet!" #endif return 0; } /* ** wan_skb_copyback() - ** Copy data from an mbuf chain starting "off" bytes from the beginning, ** continuing for "len" bytes, into the indicated buffer. */ static __inline void wan_skb_copydata(void* skb, int off, int len, caddr_t cp) { #if defined(__LINUX__) if (off + len > wan_skb_len(skb)){ DEBUG_EVENT("wan_skb_copydata: Internal error (off=%d, len=%d, skb_len=%d)!\n", off, len, wan_skb_len(skb)); return; } memcpy(cp, wan_skb_data(skb), len); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) caddr_t data = mtod((struct mbuf*)skb, caddr_t); bcopy(cp, &data[off], len); #elif defined(__SOLARIS__) mblk_t* tmp = (mblk_t*)skb; unsigned char* ptr = NULL; unsigned i = 0, num = 0; while(tmp != NULL) { ptr = tmp->b_rptr; num = tmp->b_wptr - tmp->b_rptr; bcopy(ptr, &cp[i], num); i += num; tmp = tmp->b_cont; } #else # error "wan_skb_copydata() function is not supported yet!" #endif } /* ** wan_skb_copy() */ static __inline void * wan_skb_copy(void *skb) { #if defined(__LINUX__) return skb_copy(skb,GFP_ATOMIC); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return m_copym(skb, 0, wan_skb_len(skb), M_DONTWAIT); #else # error "wan_skb_copy() function is not supported yet" #endif } /* ** wan_skb_clone() */ static __inline void * wan_skb_clone(void *skb) { #if defined(__LINUX__) return skb_clone(skb,GFP_ATOMIC); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return m_copym(skb, 0, wan_skb_len(skb), M_DONTWAIT); #else # error "wan_skb_clone() function is not supported yet" #endif } /* ** wan_skb2buffer() - ** Correct skb block. */ static __inline int wan_skb2buffer(void** skb) { #if defined(__LINUX__) return 0; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) netskb_t *m = (netskb_t*)(*skb); netskb_t *new = NULL; new = wan_skb_alloc(0); if (new){ struct mbuf *tmp = m; char *buffer = new->m_data; for( ; tmp; tmp = tmp->m_next) { bcopy(mtod(tmp, caddr_t), buffer, tmp->m_len); buffer += tmp->m_len; new->m_len += tmp->m_len; } wan_skb_free(m); *skb = new; return 0; } return -EINVAL; #else # error "wan_skb_correct() function is not supported yet!" #endif } /* ** wan_skb_pull() - ** */ static __inline unsigned char* wan_skb_pull(void* skb, int len) { #if defined(__LINUX__) return skb_pull((struct sk_buff*)skb, len); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) m_adj(skb, len); #if 0 struct mbuf* m = (struct mbuf*)skb; m->m_data += len; m->m_pkthdr.len -= len; m->m_len = m->m_pkthdr.len; #endif return wan_skb_data(skb); #else # error "wan_skb_pull() function is not supported yet!" #endif } /* ** wan_skb_put() - ** */ static __inline unsigned char* wan_skb_put(void* skb, int len) { #if defined(__LINUX__) return skb_put((struct sk_buff*)skb, len); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)skb; int org_len = wan_skb_len(skb); unsigned char* data = wan_skb_data(skb); m->m_len = org_len + len; m->m_pkthdr.len = org_len + len; /*Alex Sep27,2004 last tail but not data pointer return wan_skb_data(skb);*/ return data + org_len; #elif defined(__SOLARIS__) mblk_t mp=(mblk_t*)skb; unsigned char *wptr=mp->b_wptr; mp->b_wptr += len; return mp->b_wptr; #else # error "wan_skb_put() function is not supported yet!" #endif } /* ** wan_skb_push() - ** */ static __inline unsigned char* wan_skb_push(void* skb, int len) { #if defined(__LINUX__) return skb_push((struct sk_buff*)skb, len); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf *m = (struct mbuf*)skb; int org_len = wan_skb_len(skb); if (m->m_flags & M_EXT){ if ((m->m_data - len) < m->m_ext.ext_buf){ DEBUG_EVENT("Can't push %d bytes!\n", len); return wan_skb_data(skb); } }else{ if ((m->m_data - len) < m->m_pktdat){ DEBUG_EVENT("Can't push %d bytes!\n", len); return wan_skb_data(skb); } } m->m_data -= len; m->m_len = org_len + len; m->m_pkthdr.len = org_len + len; return wan_skb_data(skb); #else # error "wan_skb_push() function is not supported yet!" #endif } /* ** wan_skb_tailroom() - Tail room ** ** */ static __inline int wan_skb_tailroom(void* skb) { #if defined(__LINUX__) return skb_tailroom(skb); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)skb; if (m->m_flags & M_EXT){ return (MCLBYTES - m->m_len); } return (MHLEN - m->m_len); #else # error "wan_skb_tailroom() function is not supported yet!" #endif } /* ** wan_skb_tailroom() - Head room ** ** */ static __inline int wan_skb_headroom(void* skb) { #if defined(__LINUX__) return skb_headroom(skb); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)skb; if (m->m_flags & M_EXT){ return (m->m_data - m->m_ext.ext_buf); } return (m->m_data - m->m_pktdat); #else # error "wan_skb_headroom() function is not supported yet!" #endif } /* ** wan_skb_trim() - Trim from tail ** ** */ static __inline void wan_skb_trim(void* skb, unsigned int len) { #if defined(__LINUX__) skb_trim(skb, len); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)skb; #if 0 /* Trim only moves tail to head+len (Oct13) */ if (len == 0){ m->m_data = m->m_ext.ext_buf; } #endif m->m_pkthdr.len = len; m->m_len = m->m_pkthdr.len; #else # error "wan_skb_trim() function is not supported yet!" #endif } /* ** wan_skb_init() - Setup skb data ptr ** ** */ static __inline void wan_skb_init(void* pskb, unsigned int len) { #if defined(__LINUX__) struct sk_buff* skb = (struct sk_buff*)pskb; skb->data = skb->head + len; wan_skb_reset_tail_pointer(skb); skb->len = 0; skb->data_len = 0; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct mbuf* m = (struct mbuf*)pskb; m->m_data = m->m_ext.ext_buf + len; #else # error "wan_skb_init() function is not supported yet!" #endif } static __inline int wan_skb_print(void* skb) { #if defined(__LINUX__) int len = wan_skb_len(skb); unsigned char *data = wan_skb_data(skb); int i; DEBUG_EVENT("DBG Packet %d bytes: ",len); for(i=0;im_pkthdr.len, i; unsigned char *data = wan_skb_data(skb); if (m->m_type & M_PKTHDR) DEBUG_EVENT("M_PKTHDR flag set (%d)!\n", m->m_pkthdr.len); if (m->m_type & M_EXT) DEBUG_EVENT("M_EXT flag set (%d)!\n", m->m_pkthdr.len); DEBUG_EVENT("Packet %d bytes: ", len); for(i=0;i= '0') && (ifname[len] <= '9')){ if (!base){ int i=0; base = 1; for(i=0;i= 502000) if_initname(dev, ifname, IF_DUNIT_NONE); # else dev->if_unit = ifunit; if (dev->if_name == NULL){ dev->if_name = wan_malloc(prefix_len+1); if (dev->if_name == NULL){ return -ENOMEM; } } memcpy(dev->if_name, ifname, prefix_len); dev->if_name[prefix_len] = '\0'; # endif WAN_IFQ_SET_MAXLEN(&dev->if_snd, ifqmaxlen); #elif defined(__OpenBSD__) || defined(__NetBSD__) if (strlen(ifname) >= IFNAMSIZ){ return -ENOMEM; } bcopy(ifname, dev->if_xname, strlen(ifname)); WAN_IFQ_SET_MAXLEN(&dev->if_snd, IFQ_MAXLEN); #elif defined(__LINUX__) # if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,43)) dev->name = ifname; # else strcpy(dev->name, ifname); # endif #else # error "wan_netif_init() function is not supported yet!" #endif return 0; } static __inline int wan_netif_del(netdevice_t* dev) { WAN_ASSERT(dev == NULL); #if defined(__FreeBSD__) dev->if_init = NULL; # if (__FreeBSD_version >= 502000) dev->if_dname = NULL; # elif (__FreeBSD_version > 400000) /* Free interface name (only for FreeBSD-4.0) */ free(dev->if_name, M_DEVBUF); # endif #elif defined(__OpenBSD__) || defined(__NetBSD__) /* Do nothing */ #elif defined(__LINUX__) /* Do nothing */ #else # error "wan_netif_del() function is not supported yet!" #endif return 0; } #if defined(__LINUX__) static __inline void wan_netif_fake_init(netdevice_t *d) { return; } #endif static __inline void* wan_netif_alloc(unsigned char *devname, int ifType, int *err) { #if defined(__LINUX__) # if defined(LINUX_2_6) # if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4)) return __dev_alloc(devname, err); # else return alloc_netdev(0,devname,wan_netif_fake_init); # endif # elif defined(LINUX_2_4) netdevice_t *dev=wan_malloc(sizeof(netdevice_t)); *err=0; if (!dev){ *err=-ENOMEM; } memset(dev, 0, sizeof(netdevice_t)); strncpy(dev->name,devname,30); return dev; # else netdevice_t *dev=wan_malloc(sizeof(netdevice_t)); *err=0; if (!dev){ *err=-ENOMEM; } memset(dev, 0, sizeof(netdevice_t)); dev->name=wan_malloc(35); if (!dev->name){ wan_free(dev); dev=NULL; *err=-ENOMEM; return NULL; } strncpy(dev->name,devname,30); return dev; # endif #elif defined(__FreeBSD__) && (__FreeBSD_version > 600000) struct ifnet* ifp; ifp = IFALLOC(ifType); /*ifp = wan_malloc(sizeof(struct ifnet));*/ if (ifp == NULL){ *err = -ENOMEM; return NULL; } if (devname){ *err = wan_netif_init(ifp, devname); if (*err){ wan_netif_del(ifp); return NULL; } } return ifp; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct ifnet* ifp; switch(ifType){ case WAN_IFT_PPP: ifp = (struct ifnet*)wan_malloc(sizeof(struct sppp)); if (ifp) bzero((struct sppp*)ifp, sizeof(struct sppp)); break; case WAN_IFT_ETHER: ifp = (struct ifnet*)wan_malloc(sizeof(wan_ethercom_t)); if (ifp) bzero(WAN_IFP2AC(ifp), sizeof(wan_ethercom_t)); break; case WAN_IFT_OTHER: default: ifp = wan_malloc(sizeof(struct ifnet)); if (ifp) bzero(ifp, sizeof(struct ifnet)); break; } /*ifp = IFALLOC(ifType);*/ /*ifp = wan_malloc(sizeof(struct ifnet));*/ if (ifp == NULL){ *err = -ENOMEM; return NULL; } if (devname){ *err = wan_netif_init(ifp, devname); if (*err){ wan_netif_del(ifp); return NULL; } } return ifp; #else # error "wan_netif_alloc() unsupported" #endif } static __inline void wan_netif_free(netdevice_t *dev) { #if defined(__LINUX__) # if defined(LINUX_2_6) free_netdev(dev); # elif defined(LINUX_2_4) wan_free(dev); # else if (dev->name){ wan_free(dev->name); dev->name=NULL; } wan_free(dev); # endif #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) wan_netif_del(dev); IFFREE(dev); /*wan_free(dev);*/ #else #error "wan_netif_free() not supported!" #endif } static __inline char* wan_netif_name(netdevice_t* dev) { static char ifname[IFNAMSIZ+1]; WAN_ASSERT2(dev == NULL, NULL); #if defined(__LINUX__) strcpy(ifname, dev->name); #elif defined(__FreeBSD__) # if (__FreeBSD_version >= 502000) strcpy(ifname, dev->if_xname); # else sprintf(ifname, "%s%d", dev->if_name, dev->if_unit); # endif #elif defined(__OpenBSD__) || defined(__NetBSD__) sprintf(ifname, "%s", dev->if_xname); #else # error "wan_get_ifname() function is not supported yet!" #endif return ifname; } static __inline void* wan_netif_priv(netdevice_t* dev) { WAN_ASSERT2(dev == NULL, NULL); #if defined(__LINUX__) return dev->priv; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return dev->if_softc; #else # error "wan_netif_priv() function is not supported yet!" #endif } static __inline int wan_netif_up(netdevice_t* dev) { WAN_ASSERT2(dev == NULL, -EINVAL); #if defined(__LINUX__) return WAN_NETIF_UP(dev); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return WAN_NETIF_UP(dev); #else # error "wan_netif_up() function is not supported yet!" #endif } static __inline void wan_netif_set_priv(netdevice_t* dev, void* priv) { WAN_ASSERT1(dev == NULL); #if defined(__LINUX__) dev->priv = priv; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) dev->if_softc = priv; #else # error "wan_netif_priv() function is not supported yet!" #endif return; } static __inline short wan_netif_flags(netdevice_t* dev) { WAN_ASSERT(dev == NULL); #if defined(__LINUX__) return dev->flags; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) return dev->if_flags; #else # error "wan_netif_flags() function is not supported yet!" #endif } static __inline int wan_netif_mcount(netdevice_t* dev) { #if defined(__LINUX__) return dev->mc_count; #elif defined(__FreeBSD__) return dev->if_amcount; #elif defined(__OpenBSD__) || defined(__NetBSD__) return 0; #else # error "wan_netif_mcount() function is not supported yet!" #endif } static __inline int wan_netif_set_ticks(netdevice_t* dev, unsigned long ticks) { #if defined(__LINUX__) dev->trans_start = ticks; #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) #else # error "wan_netif_set_ticks() function is not supported yet!" #endif return 0; } static __inline int wan_netif_set_mtu(netdevice_t* dev, unsigned long mtu) { #if defined(__LINUX__) #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) dev->if_mtu = mtu; #else # error "wan_netif_set_mtu() function is not supported yet!" #endif return 0; } static __inline void wan_bpf_report(netdevice_t* dev, void* pkt, int flag, int dir) { #if defined(__LINUX__) /* Do nothing */ #elif defined(__FreeBSD__) if (dev->if_bpf != NULL){ /* BF-0002 */ WAN_BPF_REPORT(dev, pkt); } #elif defined(__OpenBSD__) || defined(__NetBSD__) if (dev->if_bpf != NULL){ /* BF-0002 */ if (flag){ struct mbuf m0; u_int32_t af = AF_INET; m0.m_next = pkt; m0.m_len = 4; m0.m_data = (char*)⁡ WAN_BPF_REPORT(dev, &m0, dir); }else{ WAN_BPF_REPORT(dev, pkt, dir); } } #else # error "wan_bpf_report() function is not supported yet!" #endif } static __inline void wan_spin_lock_init(void *lock) { #if defined(__LINUX__) spin_lock_init(((spinlock_t*)lock)); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) /*(*(wan_smp_flag_t*)flag) = 0;*/ #else # warning "wan_spin_lock_init() function is not supported yet!" #endif } static __inline int wan_spin_is_locked(void *lock) { #if defined(__LINUX__) return spin_is_locked((spinlock_t*)lock); #elif defined(__NetBSD__) || defined(__OpenBSD__) return 0;/*((*(wan_smp_flag_t*)flag) & imask[IPL_NET]);*/ #elif defined(__FreeBSD__) # if (__FreeBSD_version > 500000) return 0; # else return 0;/*((*(wan_smp_flag_t*)flag) & net_imask);*/ # endif #else # warning "wan_spin_is_lock() function is not supported yet!" #endif } static __inline void wan_spin_lock_irq(void *lock, wan_smp_flag_t *flag) { #if defined(__LINUX__) spin_lock_irqsave(((spinlock_t*)lock),*flag); #elif defined(__FreeBSD__) /* Feb 10, 2005 Change splnet to splimp ** (i think it was cause to system crash) */ *flag = splimp(); #elif defined(__OpenBSD__) *flag = splnet(); #elif defined(__NetBSD__) # if (__NetBSD_Version__ >= 106000200) *flag = splvm(); # else *flag = splimp(); # endif #else # warning "wan_spin_lock_irq() function is not supported yet!" #endif } static __inline void wan_spin_unlock_irq(void *lock, wan_smp_flag_t *flag) { #if defined(__LINUX__) spin_unlock_irqrestore(((spinlock_t*)lock),*flag); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) splx(*flag); #else # warning "wan_spin_unlock_irq() function is not supported yet!" #endif } static __inline void wan_spin_lock(void *lock) { #if defined(__LINUX__) spin_lock(((spinlock_t*)lock)); #elif defined(__FreeBSD__) /* Feb 10, 2005 Change splnet to splimp ** (i think it was cause to system crash) */ *((wan_spinlock_t*)lock) = splimp(); #elif defined(__OpenBSD__) *((wan_spinlock_t*)lock) = splnet(); #elif defined(__NetBSD__) # if (__NetBSD_Version__ >= 106000200) *((wan_spinlock_t*)lock) = splvm(); # else *((wan_spinlock_t*)lock) = splimp(); # endif #else # warning "wan_spin_lock() function is not supported yet!" #endif } static __inline void wan_spin_unlock(void *lock) { #if defined(__LINUX__) spin_unlock(((spinlock_t*)lock)); #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) splx(*(wan_spinlock_t*)lock); #else # warning "wan_spin_unlock() function is not supported yet!" #endif } #if 0 static __inline void wan_read_rw_lock(void *lock) { #if defined(__LINUX__) read_lock(((rwlock_t*)lock)); #else # warning "wan_read_rw_lock() function is not supported yet!" #endif } static __inline void wan_read_rw_unlock(void *lock) { #if defined(__LINUX__) read_unlock(((rwlock_t*)lock)); #else # warning "wan_read_rw_unlock() function is not supported yet!" #endif } static __inline void wan_write_rw_lock_irq(void *lock, unsigned long *flag) { #if defined(__LINUX__) write_lock_irqsave(((rwlock_t*)lock),flag); #else # warning "wan_read_rw_lock() function is not supported yet!" #endif } static __inline void wan_write_rw_unlock_irq(void *lock, unsigned long *flag) { #if defined(__LINUX__) write_unlock_irqrestore(((rwlock_t*)lock),flag); #else # warning "wan_read_rw_unlock() function is not supported yet!" #endif } #endif #if 0 static __inline void wan_read_bus_4(void *phw, void *virt, int offset, unsigned int *value) { #if defined(__LINUX__) *value = wp_readl((unsigned char*)virt + offset); #else sdla_bus_read_4(phw,offset,value); #endif } static __inline void wan_write_bus_4(void *phw, void *virt, int offset, unsigned int value) { #if defined(__LINUX__) wp_writel(value,(u8*)virt + offset); #else sdla_bus_write_4(phw,offset,value); #endif } #endif #endif /* WAN_KERNEL */ #endif /* __WANPIPE_COMMON_H */