#ifndef _RDSV3_IMPL_H

#define _RDSV3_IMPL_H

#include <sys/atomic.h>

#ifdef __cplusplus

extern "C" {

#endif

extern dev_info_t *rdsv3_dev_info;

#define uint16_be_t uint16_t

#define uint32_be_t uint32_t

#define uint64_be_t uint64_t

#define RDS_SERVICE_ID 0x1000144F00000001ULL

typedef unsigned int atomic_t;

#define ATOMIC_INIT(a) a

#define atomic_get(p) (*(p))

#define atomic_cmpset_long(p, c, n) \

((c == atomic_cas_uint(p, c, n)) ? c : -1)

#define atomic_dec_and_test(a) \

(atomic_dec_uint_nv((a)) == 0)

#define atomic_cmpxchg(a, o, n) \

atomic_cas_uint(a, o, n)

#ifdef _LP64

#define set_bit(b, p) \

atomic_or_ulong(((volatile ulong_t *)(void *)(p)) + ((b) >> 6), \

1ul << ((b) & 0x3f))

#define clear_bit(b, p) \

atomic_and_ulong(((volatile ulong_t *)(void *)(p)) + ((b) >> 6), \

~(1ul << ((b) & 0x3f)))

#define test_bit(b, p) \

(((volatile ulong_t *)(void *)(p))[(b) >> 6] & (1ul << ((b) & 0x3f)))

#define test_and_set_bit(b, p) \

atomic_set_long_excl(((ulong_t *)(void *)(p)) + \

((b) >> 6), ((b) & 0x3f))

#define test_and_clear_bit(b, p) \

!atomic_clear_long_excl(((ulong_t *)(void *)(p)) + ((b) >> 6), \

((b) & 0x3f))

#else

#define set_bit(b, p) \

atomic_or_uint(((volatile uint_t *)(void *)p) + (b >> 5), \

1ul << (b & 0x1f))

#define clear_bit(b, p) \

atomic_and_uint(((volatile uint_t *)(void *)p) + (b >> 5), \

~(1ul << (b & 0x1f)))

#define test_bit(b, p) \

(((volatile uint_t *)(void *)p)[b >> 5] & (1ul << (b & 0x1f)))

#define test_and_set_bit(b, p) \

atomic_set_long_excl(((ulong_t *)(void *)p) + (b >> 5), (b & 0x1f))

#define test_and_clear_bit(b, p) \

!atomic_clear_long_excl(((ulong_t *)(void *)p) + (b >> 5), (b & 0x1f))

#endif

#if defined(sparc)

#define LE_BIT_XOR ((BITS_PER_LONG-1) & ~0x7)

#else

#define LE_BIT_XOR 0

#endif

#define set_le_bit(b, p) set_bit(b ^ LE_BIT_XOR, p)

#define clear_le_bit(b, p) clear_bit(b ^ LE_BIT_XOR, p)

#define test_le_bit(b, p) test_bit(b ^ LE_BIT_XOR, p)

uint_t rdsv3_one_sec_in_hz;

#define jiffies 100

#define HZ (drv_hztousec(1))

#define PAGE_SIZE 4096 /* xxx - fix this */

#define BITS_PER_LONG (sizeof (unsigned long) * 8)

#define RDSV3_PANIC() cmn_err(CE_PANIC, "Panic forced by RDSV3");

#define MAX_ERRNO 4095

#define ERR_PTR(x) ((void *)(uintptr_t)x)

#define IS_ERR(ptr) (((uintptr_t)ptr) >= (uintptr_t)-MAX_ERRNO)

#define PTR_ERR(ptr) (int)(uintptr_t)ptr

#define MAX_SCHEDULE_TIMEOUT (~0UL>>1)

#define list_remove_node(node) \

if ((node)->list_next != NULL) { \

(node)->list_prev->list_next = (node)->list_next; \

(node)->list_next->list_prev = (node)->list_prev; \

(node)->list_next = (node)->list_prev = NULL; \

}

#define list_splice(src, dst) { \

list_create(dst, (src)->list_size, (src)->list_offset); \

list_move_tail(dst, src); \

}

#define RDSV3_FOR_EACH_LIST_NODE(objp, listp, member) \

for (objp = list_head(listp); objp; objp = list_next(listp, objp))

#define RDSV3_FOR_EACH_LIST_NODE_SAFE(objp, tmp, listp, member) \

for (objp = list_head(listp), tmp = (objp != NULL) ? \

list_next(listp, objp) : NULL; \

objp; \

objp = tmp, tmp = (objp != NULL) ? \

list_next(listp, objp) : NULL)

typedef struct rdsv3_wait_queue_s {

kmutex_t waitq_mutex;

kcondvar_t waitq_cv;

uint_t waitq_waiters;

} rdsv3_wait_queue_t;

#define rdsv3_init_waitqueue(waitqp) \

mutex_init(&(waitqp)->waitq_mutex, NULL, MUTEX_DRIVER, NULL); \

cv_init(&(waitqp)->waitq_cv, NULL, CV_DRIVER, NULL); \

(waitqp)->waitq_waiters = 0

#define rdsv3_exit_waitqueue(waitqp) \

ASSERT((waitqp)->waitq_waiters == 0); \

mutex_destroy(&(waitqp)->waitq_mutex); \

cv_destroy(&(waitqp)->waitq_cv)

#define rdsv3_wake_up(waitqp) { \

mutex_enter(&(waitqp)->waitq_mutex); \

if ((waitqp)->waitq_waiters) \

cv_signal(&(waitqp)->waitq_cv); \

mutex_exit(&(waitqp)->waitq_mutex); \

}

#define rdsv3_wake_up_all(waitqp) { \

mutex_enter(&(waitqp)->waitq_mutex); \

if ((waitqp)->waitq_waiters) \

cv_broadcast(&(waitqp)->waitq_cv); \

mutex_exit(&(waitqp)->waitq_mutex); \

}

#define rdsv3_wait_event(waitq, condition) \

{ \

mutex_enter(&(waitq)->waitq_mutex); \

(waitq)->waitq_waiters++; \

while (!(condition)) { \

cv_wait(&(waitq)->waitq_cv, &(waitq)->waitq_mutex); \

} \

(waitq)->waitq_waiters--; \

mutex_exit(&(waitq)->waitq_mutex); \

}

#define rdsv3_wait_sig(waitqp, condition) \

( \

{ \

int cv_return = 1; \

mutex_enter(&(waitqp)->waitq_mutex); \

(waitqp)->waitq_waiters++; \

while (!(condition)) { \

cv_return = cv_wait_sig(&(waitqp)->waitq_cv, \

&(waitqp)->waitq_mutex); \

if (cv_return == 0) { \

break; \

} \

} \

(waitqp)->waitq_waiters--; \

mutex_exit(&(waitqp)->waitq_mutex); \

cv_return; \

} \

)

#define SOCK_DEAD 1ul

typedef struct rsock {

sock_upper_handle_t sk_upper_handle;

sock_upcalls_t *sk_upcalls;

kmutex_t sk_lock;

ulong_t sk_flag;

rdsv3_wait_queue_t *sk_sleep; /* Also protected by rs_recv_lock */

int sk_sndbuf;

int sk_rcvbuf;

atomic_t sk_refcount;

struct rdsv3_sock *sk_protinfo;

} rsock_t;

typedef struct rdsv3_conn_info_s {

uint32_be_t c_laddr;

uint32_be_t c_faddr;

} rdsv3_conn_info_t;

typedef struct rdsv3_workqueue_struct_s {

kmutex_t wq_lock;

uint_t wq_state;

int wq_pending;

list_t wq_queue;

} rdsv3_workqueue_struct_t;

struct rdsv3_work_s;

typedef void (*rdsv3_work_func_t)(struct rdsv3_work_s *);

typedef struct rdsv3_work_s {

list_node_t work_item;

rdsv3_work_func_t func;

} rdsv3_work_t;

typedef struct rdsv3_delayed_work_s {

kmutex_t lock;

rdsv3_work_t work;

timeout_id_t timeid;

rdsv3_workqueue_struct_t *wq;

} rdsv3_delayed_work_t;

#define RDSV3_INIT_WORK(wp, f) (wp)->func = f

#define RDSV3_INIT_DELAYED_WORK(dwp, f) \

(dwp)->work.func = f; \

mutex_init(&(dwp)->lock, NULL, MUTEX_DRIVER, NULL); \

(dwp)->timeid = 0

struct rdsv3_scatterlist {

caddr_t vaddr;

uint_t length;

ibt_wr_ds_t *sgl;

ibt_mi_hdl_t mihdl;

};

#define rdsv3_sg_page(scat) (scat)->vaddr

#define rdsv3_sg_len(scat) (scat)->length

#define rdsv3_sg_set_page(scat, pg, len, off) \

(scat)->vaddr = (caddr_t)(pg + off); \

(scat)->length = len

#define rdsv3_ib_sg_dma_len(dev, scat) rdsv3_sg_len(scat)

#if defined(__sparc)

#define _CMSG_HDR_ALIGNMENT 8

#else

#define _CMSG_HDR_ALIGNMENT 4

#endif /* defined(__sparc) */

#define _CMSG_DATA_ALIGNMENT (sizeof (int))

#define _CMSG_HDR_ALIGN(x) (((uintptr_t)(x) + _CMSG_HDR_ALIGNMENT - 1) & \

~(_CMSG_HDR_ALIGNMENT - 1))

#define _CMSG_DATA_ALIGN(x) (((uintptr_t)(x) + _CMSG_DATA_ALIGNMENT - 1) & \

~(_CMSG_DATA_ALIGNMENT - 1))

#define CMSG_DATA(c) \

((unsigned char *)_CMSG_DATA_ALIGN((struct cmsghdr *)(c) + 1))

#define CMSG_FIRSTHDR(m) \

(((m)->msg_controllen < sizeof (struct cmsghdr)) ? \

(struct cmsghdr *)0 : (struct cmsghdr *)((m)->msg_control))

#define CMSG_NXTHDR(m, c) \

(((c) == 0) ? CMSG_FIRSTHDR(m) : \

((((uintptr_t)_CMSG_HDR_ALIGN((char *)(c) + \

((struct cmsghdr *)(c))->cmsg_len) + sizeof (struct cmsghdr)) > \

(((uintptr_t)((struct msghdr *)(m))->msg_control) + \

((uintptr_t)((struct msghdr *)(m))->msg_controllen))) ? \

((struct cmsghdr *)0) : \

((struct cmsghdr *)_CMSG_HDR_ALIGN((char *)(c) + \

((struct cmsghdr *)(c))->cmsg_len))))

#define CMSG_SPACE(l) \

((unsigned int)_CMSG_HDR_ALIGN(sizeof (struct cmsghdr) + (l)))

#define CMSG_LEN(l) \

((unsigned int)_CMSG_DATA_ALIGN(sizeof (struct cmsghdr)) + (l))

#define RDSV3_IBDEV2HCAHDL(device) (device)->hca_hdl

#define RDSV3_QP2CHANHDL(qp) (qp)->ibt_qp

#define RDSV3_PD2PDHDL(pd) (pd)->ibt_pd

#define RDSV3_CQ2CQHDL(cq) (cq)->ibt_cq

struct rdsv3_hdrs_mr {

ibt_lkey_t lkey;

caddr_t addr;

size_t size;

ibt_mr_hdl_t hdl;

};

void rdsv3_trans_init();

boolean_t rdsv3_capable_interface(struct lifreq *lifrp);

int rdsv3_do_ip_ioctl(ksocket_t so4, void **ipaddrs, int *size, int *nifs);

int rdsv3_do_ip_ioctl_old(ksocket_t so4, void **ipaddrs, int *size, int *nifs);

boolean_t rdsv3_isloopback(ipaddr_t addr);

void rdsv3_cancel_delayed_work(rdsv3_delayed_work_t *dwp);

void rdsv3_flush_workqueue(rdsv3_workqueue_struct_t *wq);

void rdsv3_queue_work(rdsv3_workqueue_struct_t *wq, rdsv3_work_t *wp);

void rdsv3_queue_delayed_work(rdsv3_workqueue_struct_t *wq,

rdsv3_delayed_work_t *dwp, uint_t delay);

struct rsock *rdsv3_sk_alloc();

void rdsv3_sock_init_data(struct rsock *sk);

void rdsv3_sock_exit_data(struct rsock *sk);

void rdsv3_destroy_task_workqueue(rdsv3_workqueue_struct_t *wq);

rdsv3_workqueue_struct_t *rdsv3_create_task_workqueue(char *name);

int rdsv3_conn_constructor(void *buf, void *arg, int kmflags);

void rdsv3_conn_destructor(void *buf, void *arg);

int rdsv3_conn_compare(const void *conn1, const void *conn2);

void rdsv3_loop_init();

int rdsv3_mr_compare(const void *mr1, const void *mr2);

int rdsv3_put_cmsg(struct nmsghdr *msg, int level, int type, size_t size,

void *payload);

int rdsv3_verify_bind_address(ipaddr_t addr);

uint16_t rdsv3_ip_fast_csum(void *buffer, size_t length);

uint_t rdsv3_ib_dma_map_sg(struct ib_device *dev, struct rdsv3_scatterlist

*scat, uint_t num);

void rdsv3_ib_dma_unmap_sg(ib_device_t *dev, struct rdsv3_scatterlist *scat,

uint_t num);

static inline void

rdsv3_sk_sock_hold(struct rsock *sk)

{

atomic_inc_32(&sk->sk_refcount);

}

static inline void

rdsv3_sk_sock_put(struct rsock *sk)

{

if (atomic_dec_and_test(&sk->sk_refcount))

rdsv3_sock_exit_data(sk);

}

static inline int

rdsv3_sk_sock_flag(struct rsock *sk, uint_t flag)

{

return (test_bit(flag, &sk->sk_flag));

}

static inline void

rdsv3_sk_sock_orphan(struct rsock *sk)

{

set_bit(SOCK_DEAD, &sk->sk_flag);

}

#define rdsv3_sndtimeo(a, b) b ? 0 : 3600 /* check this value on linux */

#define rdsv3_rcvtimeo(a, b) b ? 0 : 3600 /* check this value on linux */

void rdsv3_ib_free_conn(void *arg);

#ifdef __cplusplus

}

#endif

#endif /* _RDSV3_IMPL_H */