/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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) 1998-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _SYS_RSM_RSMPI_H
#define _SYS_RSM_RSMPI_H

#ifdef  __cplusplus
extern "C" {
#endif

#ifndef _KERNEL
typedef void * ddi_as_handle_t;
#endif

#include <sys/sunddi.h>
#include <sys/rsm/rsm_common.h>

struct __rsm_resource_callback_arg;
typedef struct __rsm_resource_callback_arg *rsm_resource_callback_arg_t;

typedef void (*rsm_resource_callback_t)(rsm_resource_callback_arg_t);

struct __rsm_callback_arg;
typedef struct __rsm_callback_arg *rsm_callback_arg_t;

typedef void (*rsm_callback_t)(rsm_callback_arg_t);

/* Values for resource callback function pointer */
#define RSM_RESOURCE_SLEEP      (rsm_resource_callback_t)0
#define RSM_RESOURCE_DONTWAIT   (rsm_resource_callback_t)-1

/* rsm_seg_create() flags values */
#define RSM_ALLOW_UNBIND_REBIND         0x01

typedef uint_t rsm_intr_t;
typedef rsm_intr_t rsm_intr_service_t;
/* The following definitions used to describe the ranges fro rsm_intr_t */
#define RSM_INTR_T_DRV_BASE             0
#define RSM_INTR_T_DRV_END              0x3F
#define RSM_INTR_T_FRM_BASE             0x40
#define RSM_INTR_T_FRM_END              0x4F
#define RSM_INTR_T_RESERVED_BASE        0x50
#define RSM_INTR_T_RESERVED_END         0x5F
#define RSM_INTR_T_SUN_BASE             0x60
#define RSM_INTR_T_SUN_END              0xDF
#define RSM_INTR_T_USR_BASE             0xE0
#define RSM_INTR_T_USR_END              0xFF
#define RSM_INTR_T_NSVC                 0x100

/* kstat's ks_name for RSMPI controller drivers */
#define RSM_KS_NAME                     "rsmpi_stat"

/* named kstat component names */
#define RSM_KS_CTLR_STATE               "ctlr_state"    /* CHAR */
#define RSM_KS_ADDR                     "addr"          /* UINT64 */
#define RSM_KS_EX_MEMSEGS               "ex_memsegs"    /* UINT32 */
#define RSM_KS_EX_MEMSEGS_PUB           "ex_memsegs_pub"        /* UINT32 */
#define RSM_KS_EX_MEMSEGS_CON           "ex_memsegs_con"        /* UINT32 */
#define RSM_KS_BYTES_BOUND              "bytes_bound"           /* UINT64 */
#define RSM_KS_IM_MEMSEGS_CON           "im_memsegs_con"        /* UINT32 */
#define RSM_KS_SENDQS                   "sendqs"                /* UINT64 */
#define RSM_KS_HANDLERS                 "handlers"              /* UINT64 */

/* The following are the possible values of RSM_KS_CTLR_STATE */
#define RSM_AE_CTLR_DOWN        "rsm_down"
#define RSM_AE_CTLR_UP          "rsm_up"


struct __rsm_send_q_handle;
typedef struct __rsm_send_q_handle *rsm_send_q_handle_t;

/* rsm_intr_send_q_create flags values */
#define RSM_INTR_SEND_Q_NO_FENCE        0x1
#define RSM_INTR_SEND_Q_FULL_FAIL       0x2
#define RSM_INTR_SEND_Q_UNRELIABLE      0x4

typedef struct {
        void    *is_data;
        size_t  is_size;
        int     is_flags;
        clock_t is_wait;
} rsm_send_t;

/* rsm_send_t flags values */
#define RSM_INTR_SEND_QUEUE             0x1
#define RSM_INTR_SEND_DELIVER           0x2
#define RSM_INTR_SEND_POLL              0x4
#define RSM_INTR_SEND_SLEEP             0x8
#define RSM_INTR_SEND_LOWER_FENCE       0x10

typedef enum {
        RSM_INTR_HAND_UNCLAIMED = 0,
        RSM_INTR_HAND_CLAIMED = 1,
        RSM_INTR_HAND_CLAIMED_EXCLUSIVE = 2
} rsm_intr_hand_ret_t;

typedef enum {
        RSM_INTR_Q_OP_CREATE,
        RSM_INTR_Q_OP_CONFIGURE,
        RSM_INTR_Q_OP_DESTROY,
        RSM_INTR_Q_OP_RECEIVE,
        RSM_INTR_Q_OP_DROP
} rsm_intr_q_op_t;

struct __rsm_intr_hand_arg;
typedef struct __rsm_intr_hand_arg *rsm_intr_hand_arg_t;

struct __rsm_registry_item;
typedef struct __rsm_registry_item *rsm_registry_item_t;

typedef int   rsm_intr_pri_t;

typedef struct {
        rsm_addr_t       ae_addr;       /* node hwaddr allowed access */
        rsm_permission_t ae_permission; /* permissions for node */
} rsm_access_entry_t;
/*
 * ae_addr can be set to the following value to mean that the permissions
 * should apply to all nodes accessible through this RSM controller
 */
#define RSM_ACCESS_PUBLIC       0xFFFF

struct __rsm_controller_handle;
typedef struct __rsm_controller_handle *rsm_controller_handle_t;

/*
 * The following typedef is used to represent a controller object.
 */
typedef struct rsm_controller_object {
        struct rsm_ops *ops;
        rsm_controller_handle_t handle;
} rsm_controller_object_t;

typedef rsm_intr_hand_ret_t (*rsm_intr_hand_t)(
    rsm_controller_object_t *controller,
    rsm_intr_q_op_t operation,
    rsm_addr_t sender,
    void *data,
    size_t size,
    rsm_intr_hand_arg_t arg);

typedef struct {
        enum { RSM_MEM_VADDR,
                RSM_MEM_BUF,
                RSM_MEM_HANDLE,
                RSM_MEM_INVALID } ms_type;
        union {
                struct {
                        void *vaddr;
                        size_t length;
                        ddi_as_handle_t as;
                } vr;
                struct buf *bp;
                rsm_memseg_export_handle_t      handle;
        } ms_memory;
#define ms_bp           ms_memory.bp
#define ms_vaddr        ms_memory.vr.vaddr
#define ms_length       ms_memory.vr.length
#define ms_as           ms_memory.vr.as
} rsm_memory_local_t;

typedef struct {
        rsm_memory_local_t              local_mem;
        size_t                          local_offset;
        rsm_memseg_import_handle_t      remote_handle;
        size_t                          remote_offset;
        size_t                          transfer_length;
} rsmpi_iovec_t;

typedef struct {
        ulong_t         io_request_count;       /* size of iovec array */
        ulong_t         io_residual_count;      /* zero for success    */
        uio_seg_t       io_segflg;              /* user/kernel addr    */
        rsmpi_iovec_t   *iovec;                 /* ptr to array         */
} rsmpi_scat_gath_t;

typedef struct {
        char                    *attr_name;
        rsm_addr_t              attr_controller_addr;
        uint_t                  attr_direct_access_sizes;
        uint_t                  attr_atomic_sizes;
        uint_t                  attr_error_sizes;
        uint_t                  attr_error_behavior;
        boolean_t               attr_mmu_protections;
        size_t                  attr_page_size;
        size_t                  attr_max_export_segment_size;
        size_t                  attr_tot_export_segment_size;
        ulong_t                 attr_max_export_segments;
        size_t                  attr_max_import_map_size;
        size_t                  attr_tot_import_map_size;
        ulong_t                 attr_max_import_segments;
        boolean_t               attr_io_space_exportable;
        boolean_t               attr_imported_space_ioable;
        boolean_t               attr_intr_sender_ident;
        size_t                  attr_intr_data_size_max;
        uint_t                  attr_intr_data_align;
        boolean_t               attr_intr_piggyback;
        boolean_t       attr_resource_callbacks;
} rsm_controller_attr_t;

/*
 * The following three defines are possible values for attr_error_behavior
 * field of the rsm_controller_attr_t struct.
 */
#define RSM_ERR_NOCHANGE        0
#define RSM_ERR_ZEROES          0x1
#define RSM_ERR_RANDOM          0x2

typedef struct rsm_ops {

        /*
         * structure revision number:
         */
        uint_t rsm_version;

        /*
         * export side memory segment operations:
         */
        int (*rsm_seg_create)
            (rsm_controller_handle_t controller,
            rsm_memseg_export_handle_t *memseg,
            size_t      size,
            uint_t      flags,
            rsm_memory_local_t *memory,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t callback_arg);
        int (*rsm_seg_destroy)
            (rsm_memseg_export_handle_t handle);
        int (*rsm_bind)
            (rsm_memseg_export_handle_t memseg,
            off_t offset,
            rsm_memory_local_t *memory,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t callback_arg);
        int (*rsm_unbind)
            (rsm_memseg_export_handle_t memseg,
            off_t offset,
            size_t length);
        int (*rsm_rebind)
            (rsm_memseg_export_handle_t memseg,
            off_t offset,
            rsm_memory_local_t *memory,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t callback_arg);
        int (*rsm_publish)
            (rsm_memseg_export_handle_t memseg,
            rsm_access_entry_t access_list[],
            uint_t access_list_length,
            rsm_memseg_id_t segment_id,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t callback_arg);
        int (*rsm_unpublish)
            (rsm_memseg_export_handle_t memseg);
        int (*rsm_republish)
            (rsm_memseg_export_handle_t memseg,
            rsm_access_entry_t access_list[],
            uint_t access_list_length,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t callback_arg);

        /*
         * import side memory segment operations
         */
        int (*rsm_connect)
            (rsm_controller_handle_t controller,
            rsm_addr_t addr,
            rsm_memseg_id_t segment_id,
            rsm_memseg_import_handle_t *im_memseg);

        int (*rsm_disconnect)
            (rsm_memseg_import_handle_t im_memseg);

        /*
         * import side memory segment operations (read access functions):
         */
        int (* rsm_get8)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint8_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_get16)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint16_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_get32)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint32_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_get64)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint64_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_get)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            void *datap,
            size_t length);

        /*
         * import side memory segment operations (write access functions)
         */
        int (* rsm_put8)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint8_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_put16)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint16_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_put32)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint32_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_put64)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            uint64_t *datap,
            ulong_t rep_cnt,
            boolean_t byte_swap);
        int (* rsm_put)
            (rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            void *datap,
            size_t length);

        /*
         * import side memory segment operations (mapping)
         */
        int (*rsm_map)(rsm_memseg_import_handle_t im_memseg,
            off_t offset,
            size_t len,
            size_t *maplen,
            dev_info_t **dipp,
            uint_t *register_number,
            off_t *register_offset,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t callback_arg);

        int (*rsm_unmap)
            (rsm_memseg_import_handle_t im_memseg);

        /*
         * import side memory segment operations (barriers):
         */
        int (* rsm_open_barrier_region)
            (rsm_memseg_import_handle_t region,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_regions)
            (rsm_memseg_import_handle_t regions[],
            uint_t num_regions,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_node)
            (rsm_controller_handle_t controller,
            rsm_addr_t addr,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_ctrl)
            (rsm_controller_handle_t controller,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_region_thr)
            (rsm_memseg_import_handle_t region,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_regions_thr)
            (rsm_memseg_import_handle_t regions[],
            uint_t num_regions,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_node_thr)
            (rsm_controller_handle_t controller,
            rsm_addr_t addr,
            rsm_barrier_t *barrier);
        int (* rsm_open_barrier_ctrl_thr)
            (rsm_controller_handle_t controller,
            rsm_barrier_t *barrier);
        int (* rsm_close_barrier)
            (rsm_barrier_t *barrier);
        int (* rsm_reopen_barrier)
            (rsm_barrier_t *barrier);
        int (* rsm_order_barrier)
            (rsm_barrier_t *barrier);
        int (* rsm_thread_init)
            (rsm_controller_handle_t controller);
        int (* rsm_thread_fini)
            (rsm_controller_handle_t controller);
        int (* rsm_get_barrier_mode)
            (rsm_memseg_import_handle_t im_memseg,
            rsm_barrier_mode_t *mode);
        int (* rsm_set_barrier_mode)
            (rsm_memseg_import_handle_t im_memseg,
            rsm_barrier_mode_t mode);

        /*
         * sending side interrupt operations:
         */
        int (* rsm_sendq_create)
            (rsm_controller_handle_t controller,
            rsm_addr_t addr,
            rsm_intr_service_t service,
            rsm_intr_pri_t pri,
            ulong_t qdepth,
            uint_t flags,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t arg,
            rsm_send_q_handle_t *iqp);
        int (* rsm_sendq_config)
            (rsm_send_q_handle_t iq,
            rsm_intr_pri_t pri,
            ulong_t qdepth,
            uint_t flags,
            rsm_resource_callback_t callback,
            rsm_resource_callback_arg_t arg);
        int (* rsm_sendq_destroy)
            (rsm_send_q_handle_t iq);
        int (* rsm_send)
            (rsm_send_q_handle_t iq,
            rsm_send_t *is,
            rsm_barrier_t *barrier);


        /*
         * receiving side interrupt operations:
         */
        int (* rsm_register_handler)
            (rsm_controller_handle_t controller,
            rsm_controller_object_t *controller_obj,
            rsm_intr_t type,
            rsm_intr_hand_t handler,
            rsm_intr_hand_arg_t handler_arg,
            rsm_addr_t senders_list[],
            uint_t senders_list_length);

        int (* rsm_unregister_handler)
            (rsm_controller_handle_t controller,
            rsm_intr_t type,
            rsm_intr_hand_t handler,
            rsm_intr_hand_arg_t handler_arg);


        /* scatter-gather I/O */
        int (* rsm_memseg_import_getv)
            (rsm_controller_handle_t cp,
            rsmpi_scat_gath_t *sg_io);
        int (* rsm_memseg_import_putv)
            (rsm_controller_handle_t cp,
            rsmpi_scat_gath_t *sg_io);

        /* Management operation */
        int (*rsm_get_peers)
            (rsm_controller_handle_t controller,
            rsm_addr_t *addr_list,
            uint_t count,
            uint_t *num_addrs);

        /* Extension operation */
        int (*rsm_extension)
            (rsm_controller_handle_t controller,
            char *extname,
            void *extobj);

} rsm_ops_t;

/*
 * service module function templates:
 */

int rsm_get_controller(const char *name, uint_t number,
    rsm_controller_object_t *controller,
    uint_t version);

int rsm_release_controller(const char *name, uint_t number,
    rsm_controller_object_t *controller);

int rsm_get_controller_attr(rsm_controller_handle_t,
    rsm_controller_attr_t **attrp);
/*
 * MACROS for Clients requesting services via RSMPI module
 */

/*
 * Export Side segment operations
 */

#define RSM_SEG_CREATE(controller, memseg, size, flags, memory, callback, \
        callback_arg) \
        (*((controller).ops->rsm_seg_create)) \
        ((controller).handle, (memseg), (size), (flags), (memory), \
        (callback), (callback_arg))
#define RSM_SEG_DESTROY(controller, memseg) \
        (*((controller).ops->rsm_seg_destroy)) \
        ((memseg))
#define RSM_BIND(controller, memseg, offset, memory, callback, \
        callback_arg) \
        (*((controller).ops->rsm_bind)) \
        ((memseg), offset, (memory), (callback), (callback_arg))
#define RSM_UNBIND(controller, memseg, offset, length) \
        (*((controller).ops->rsm_unbind)) \
        ((memseg), (offset), (length))
#define RSM_REBIND(controller, memseg, offset, memory, callback, \
        callback_arg) \
        (*((controller).ops->rsm_rebind)) \
        ((memseg), offset, (memory), (callback), (callback_arg))
#define RSM_PUBLISH(controller, memseg, access_list, access_list_length, \
        segment_id, callback, callback_arg) \
        (*((controller).ops->rsm_publish)) \
        ((memseg), access_list, access_list_length, segment_id, \
        (callback), (callback_arg))
#define RSM_UNPUBLISH(controller, memseg) \
        (*((controller).ops->rsm_unpublish)) \
        ((memseg))
#define RSM_REPUBLISH(controller, memseg,  access_list, access_list_length, \
        callback, callback_arg) \
        (*((controller).ops->rsm_republish)) \
        ((memseg), (access_list), (access_list_length), (callback), \
        (callback_arg))
#define RSM_CONNECT(controller, addr, segment_id, im_memseg) \
        (*((controller).ops->rsm_connect)) \
        ((controller).handle, (addr), (segment_id), (im_memseg))
#define RSM_DISCONNECT(controller, im_memseg) \
        (*((controller).ops->rsm_disconnect))  \
        ((im_memseg))

        /*
         * import side memory segment operations (read access functions)
         */

#define RSM_GET8(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_get8)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET16(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_get16)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET32(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_get32)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET64(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_get64)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_GET(controller, im_memseg, offset, dst_addr, length) \
        (*((controller).ops->rsm_get)) \
        ((im_memseg), (offset), (dst_addr), (length))

        /*
         * import side memory segment operations (write access functions)
         */

#define RSM_PUT8(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_put8)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT16(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_put16)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT32(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_put32)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT64(controller, im_memseg, offset, datap, rep_cnt, byte_swap) \
        (*((controller).ops->rsm_put64)) \
        ((im_memseg), (offset), (datap), (rep_cnt), (byte_swap))
#define RSM_PUT(controller, im_memseg, offset, datap, length) \
        (*((controller).ops->rsm_put)) \
        ((im_memseg), (offset), (datap), (length))

        /*
         * import side memory segment operations (mapping):
         */

#define RSM_MAP(controller, im_memseg, offset, length, maplen, dipp, \
        dev_register, dev_offset, callback, arg) \
        (*((controller).ops->rsm_map)) \
        ((im_memseg), (offset), (length), (maplen), (dipp), (dev_register), \
        (dev_offset), (callback), (arg))
#define RSM_UNMAP(controller, im_memseg) \
        (*((controller).ops->rsm_unmap)) \
        ((im_memseg))

        /*
         * import side memory segment operations (barriers):
         */

#define RSM_OPEN_BARRIER_REGION(controller, region, barrier) \
        (*((controller).ops->rsm_open_barrier_region)) \
        ((region), (barrier))
#define RSM_OPEN_BARRIER_REGIONS(controller, regions, num_regions, barrier) \
        (*((controller).ops->rsm_open_barrier_regions)) \
        ((regions), (num_regions), (barrier))
#define RSM_OPEN_BARRIER_NODE(controller, addr, barrier) \
        (*((controller).ops-> rsm_open_barrier_node)) \
        ((controller).handle, (addr), (barrier))
#define RSM_OPEN_BARRIER_CTRL(controller, barrier) \
        (*((controller).ops->rsm_open_barrier_ctrl)) \
        ((controller).handle, (barrier))
#define RSM_OPEN_BARRIER_REGION_THR(controller, region, barrier) \
        (*((controller).ops->rsm_open_barrier_region_thr)) \
        ((region), (barrier))
#define RSM_OPEN_BARRIER_REGIONS_THR(controller, regions, num_regions, barrier)\
        (*((controller).ops->rsm_open_barrier_regions_thr)) \
        ((regions), (num_regions), (barrier))
#define RSM_OPEN_BARRIER_NODE_THR(controller, addr, barrier) \
        (*((controller).ops->rsm_open_barrier_node_thr)) \
        ((controller).handle, (addr), (barrier))
#define RSM_OPEN_BARRIER_CTRL_THR(controller, barrier) \
        (*((controller).ops->rsm_open_barrier_ctrl_thr)) \
        ((controller).handle, (barrier));
#define RSM_CLOSE_BARRIER(controller, barrier) \
        (*((controller).ops->rsm_close_barrier)) \
        ((barrier))
#define RSM_REOPEN_BARRIER(controller, barrier) \
        (*((controller).ops->rsm_reopen_barrier)) \
        ((barrier));
#define RSM_ORDER_BARRIER(controller, barrier) \
        (*((controller).ops->rsm_order_barrier)) \
        ((barrier))
#define RSM_THREAD_INIT(controller) \
        (*((controller).ops->rsm_thread_init)) \
        ((controller).handle)
#define RSM_THREAD_FINI(controller) \
        (*((controller).ops->rsm_thread_fini)) \
        ((controller).handle)
#define RSM_GET_BARRIER_MODE(controller, im_memseg, mode) \
        (*((controller).ops->rsm_get_barrier_mode)) \
        ((im_memseg), (mode))
#define RSM_SET_BARRIER_MODE(controller, im_memseg, mode) \
        (*((controller).ops->rsm_set_barrier_mode)) \
        ((im_memseg), (mode))
        /*
         * sending side interrupt operations:
         */

#define RSM_SENDQ_CREATE(controller, addr, service, pri, qdepth, flags, \
        callback, arg, iqp) \
        (*((controller).ops->rsm_sendq_create)) \
        ((controller).handle, (addr), (service), (pri), (qdepth), (flags), \
        (callback), (arg),  (iqp))
#define RSM_SENDQ_CONFIG(controller, iq, pri, qdepth, flags, callback, arg) \
        (*((controller).ops->rsm_sendq_config)) \
        ((iq),  (pri),  (qdepth), (flags), \
        (callback), (arg))
#define RSM_SENDQ_DESTROY(controller, iq) \
        (*((controller).ops->rsm_sendq_destroy)) \
        ((iq))
#define RSM_SEND(controller, iq, is, barrier) \
        (*((controller).ops->rsm_send)) \
        ((iq), (is), (barrier))

        /*
         * receiving side interrupt operations:
         */
#define RSM_REGISTER_HANDLER(controller, type, handler, handler_arg, \
        senders_list, senders_list_length) \
        (*((controller).ops->rsm_register_handler)) \
        ((controller).handle, &(controller), (type), (handler), (handler_arg), \
        (senders_list), (senders_list_length))
#define RSM_UNREGISTER_HANDLER(controller, type, handler, handler_arg) \
        (*((controller).ops->rsm_unregister_handler))  \
        ((controller).handle, (type), (handler), (handler_arg))
#define RSM_GETV(controller, sg_io) \
        (*((controller).ops->rsm_memseg_import_getv)) \
        ((controller).handle, (sg_io))
#define RSM_PUTV(controller, sg_io) \
        (*((controller).ops->rsm_memseg_import_putv)) \
        ((controller).handle, (sg_io))
#define RSM_GET_PEERS(controller, addr_list, count, num_addrs) \
        (*((controller).ops->rsm_get_peers)) \
        ((controller).handle, (addr_list), (count), (num_addrs))
#define RSM_EXTENSION(controller, extname, extobj) \
        (*((controller).ops->rsm_extension)) \
        ((controller).handle, (extname), (extobj))

#ifdef  __cplusplus
}
#endif


#endif  /* _SYS_RSM_RSMPI_H */