/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2012 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _RDSV3_IMPL_H
#define _RDSV3_IMPL_H

#include <sys/atomic.h>

/*
 * This file is only present in Solaris
 */

#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

/*
 * RDS Well known service id
 * Format: 0x1h00144Fhhhhhhhh
 *         "00144F" is the Sun OUI
 * 'h' can be any hex-decimal digit.
 */
#define RDS_SERVICE_ID          0x1000144F00000001ULL

/*
 * Atomic operations
 */
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

/*
 * These macros and/or constants are used instead of Linux
 * generic_{test,__{clear,set}}_le_bit().
 */
#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)

extern uint_t   rdsv3_one_sec_in_hz;

#define jiffies 100
#define HZ      (drv_hztousec(1))
/* setting this to PAGESIZE throws build errors */
#define PAGE_SIZE       4096 /* xxx - fix this */
#define BITS_PER_LONG   (sizeof (unsigned long) * 8)

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

/* ERR */
#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)

/* list */
/* copied and modified list_remove_node */
#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)

/* simulate wait_queue_head_t */
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);                             \
        }

/* analogous to cv_wait */
#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);                              \
}

/* analogous to cv_wait_sig */
#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

/* socket */
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;

/* WQ */
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;

/* simulate delayed_work */
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

/* simulate scatterlist */
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)

/* copied from sys/socket.h */
#if defined(__sparc)
/* To maintain backward compatibility, alignment needs to be 8 on sparc. */
#define _CMSG_HDR_ALIGNMENT     8
#else
/* for __i386 (and other future architectures) */
#define _CMSG_HDR_ALIGNMENT     4
#endif  /* defined(__sparc) */

/*
 * The cmsg headers (and macros dealing with them) were made available as
 * part of UNIX95 and hence need to be protected with a _XPG4_2 define.
 */
#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))))

/* Amount of space + padding needed for a message of length l */
#define CMSG_SPACE(l)                                                   \
        ((unsigned int)_CMSG_HDR_ALIGN(sizeof (struct cmsghdr) + (l)))

/* Value to be used in cmsg_len, does not include trailing padding */
#define CMSG_LEN(l)                                                     \
        ((unsigned int)_CMSG_DATA_ALIGN(sizeof (struct cmsghdr)) + (l))

/* OFUV -> IB */
#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;
};

/* rdsv3_impl.c */
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 */