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

/*
 * This header file contains definations for utility routines
 * which can be used by all Solaris OFUV related kernel drivers
 * and misc modules. The kernel modules using these APIs, should
 * load sol_ofs using :
 *      ld -r -N misc/sol_ofs
 *
 * The APIs defined are :
 *      1. User Objects
 *      2. Linked Lists
 *      3. Debug Routines
 */
#ifndef _SYS_IB_CLIENTS_OF_SOL_OFS_SOL_OFS_COMMON_H
#define _SYS_IB_CLIENTS_OF_SOL_OFS_SOL_OFS_COMMON_H

#ifdef __cplusplus
extern "C" {
#endif

#include <sys/types.h>
#include <sys/ksynch.h>

/*
 * User Objects functions and structures.
 */
typedef enum {
        /* User objects for sol_uverbs driver */
        SOL_UVERBS_UCTXT_UOBJ_TYPE      = 0,
        SOL_UVERBS_UPD_UOBJ_TYPE,
        SOL_UVERBS_UAH_UOBJ_TYPE,
        SOL_UVERBS_UMR_UOBJ_TYPE,
        SOL_UVERBS_UCQ_UOBJ_TYPE,
        SOL_UVERBS_USRQ_UOBJ_TYPE,
        SOL_UVERBS_UQP_UOBJ_TYPE,
        SOL_UVERBS_UFILE_UOBJ_TYPE,

        /* User Objects for sol_ucma driver */
        SOL_UCMA_EVT_FILE_TYPE,
        SOL_UCMA_CM_ID_TYPE,
        SOL_UCMA_MCAST_TYPE
} sol_ofs_uobj_type_t;

typedef struct {
        uint64_t                uo_user_handle;
        sol_ofs_uobj_type_t     uo_type;
        krwlock_t               uo_lock;
        uint32_t                uo_id;
        kmutex_t                uo_reflock;
        uint32_t                uo_refcnt;
        uint32_t                uo_live;
        size_t                  uo_uobj_sz;
} sol_ofs_uobj_t;

/*
 * Objects are maintained in tables that allow an easy table ID to User Object
 * mapping and can grow as resources are created.
 */
#define SOL_OFS_UO_BLKSZ        16

typedef struct {
        int             ofs_uo_blk_avail;
        sol_ofs_uobj_t  *ofs_uoblk_blks[SOL_OFS_UO_BLKSZ];
} sol_ofs_uobj_blk_t;

typedef struct {
        krwlock_t               uobj_tbl_lock;
        int                     uobj_tbl_used_blks;
        uint_t                  uobj_tbl_num_blks;
        size_t                  uobj_tbl_uo_sz;
        int                     uobj_tbl_uo_cnt;
        sol_ofs_uobj_blk_t      **uobj_tbl_uo_root;
} sol_ofs_uobj_table_t;

/* User object table management routines */
void sol_ofs_uobj_tbl_init(sol_ofs_uobj_table_t *, size_t);
void sol_ofs_uobj_tbl_fini(sol_ofs_uobj_table_t *);

void sol_ofs_uobj_init(sol_ofs_uobj_t *, uint64_t, sol_ofs_uobj_type_t);
void sol_ofs_uobj_ref(sol_ofs_uobj_t *);
void sol_ofs_uobj_deref(sol_ofs_uobj_t *,
void (*free_func)(sol_ofs_uobj_t *));
void sol_ofs_uobj_put(sol_ofs_uobj_t *);
void sol_ofs_uobj_free(sol_ofs_uobj_t *uobj);

int sol_ofs_uobj_add(sol_ofs_uobj_table_t *, sol_ofs_uobj_t *);
sol_ofs_uobj_t  *sol_ofs_uobj_remove(sol_ofs_uobj_table_t *,
    sol_ofs_uobj_t *);
sol_ofs_uobj_t  *sol_ofs_uobj_get_read(sol_ofs_uobj_table_t *, uint32_t);
sol_ofs_uobj_t  *sol_ofs_uobj_get_write(sol_ofs_uobj_table_t *, uint32_t);

/*
 * Generic linked list management functions
 */
typedef uchar_t         bool;
#define FALSE           0
#define TRUE            1
#define INVALID_HANDLE  0xFFFFFFFF
#define MAX_HASH_SIZE   1024

/*
 * Simple doubly linked list for opaque addresses.  Protection must occur
 * outside of the list.  These behavior very much like the linux kernel
 * lists, hence the familiar look of the API; but note there are
 * some signficant differences, mainly the list header is not embedded
 * in the element, so the container (typeof) constructs are not required.
 */
typedef struct llist_head {
        struct llist_head       *prv;
        struct llist_head       *nxt;
        void                    *ptr;
} llist_head_t;


#define LLIST_HEAD_INIT(x) { &(x), &(x), NULL }

static inline void llist_head_init(llist_head_t *list, void *ptr)
{
        list->prv = list->nxt = list;
        list->ptr = ptr;
}

static inline void __llist_add(llist_head_t  *new, llist_head_t  *prv,
                                                        llist_head_t  *nxt)
{
        nxt->prv   = new;
        new->nxt   = nxt;
        new->prv   = prv;
        prv->nxt   = new;
}
static inline void llist_add(llist_head_t *new, llist_head_t *head)
{
        __llist_add(new, head, head->nxt);
}

static inline void llist_add_tail(llist_head_t *new, llist_head_t *head)
{
        __llist_add(new, head->prv, head);
}

static inline void llist_del(llist_head_t *entry)
{
        entry->nxt->prv = entry->prv;
        entry->prv->nxt = entry->nxt;
}

static inline int llist_is_last(llist_head_t *list, llist_head_t *head)
{
        return (list->nxt == head);
}

static inline int llist_empty(llist_head_t *head)
{
        return (head->nxt == head);
}

#define list_for_each(_pos, _head)                 \
        for (_pos = (_head)->nxt; _pos != (_head); _pos = _pos->nxt)
#define list_for_each_safe(_pos, n, _head) \
        for (_pos = (_head)->nxt, n = _pos->nxt; _pos != (_head); \
                _pos = n, n = _pos->nxt)

/*
 * Doubly linked per user context IB resource list definitions
 * Protection must occur * outside of the list.
 */
typedef struct genlist_entry_s {
        uintptr_t               data;
        void                    *data_context;
        struct genlist_entry_s  *next;
        struct genlist_entry_s  *prev;
} genlist_entry_t;

typedef struct genlist_s {
        uint32_t        count;
        genlist_entry_t *head;
        genlist_entry_t *tail;
} genlist_t;


genlist_entry_t *add_genlist(genlist_t *list, uintptr_t data,
    void *data_context);

#define genlist_for_each(_pos, _head)   \
        for (_pos = (_head)->head; _pos; _pos = _pos->next)

void delete_genlist(genlist_t *list, genlist_entry_t *entry);

genlist_entry_t *remove_genlist_head(genlist_t *list);

void insert_genlist_tail(genlist_t *list, genlist_entry_t *entry);

void flush_genlist(genlist_t *list);

bool genlist_empty(genlist_t *list);

static inline void init_genlist(genlist_t *list)
{
        list->head = list->tail = NULL;
        list->count = 0;
}


/*
 * Debug printfs defines
 */
void sol_ofs_dprintf_l5(char *name, char *fmt, ...);
void sol_ofs_dprintf_l4(char *name, char *fmt, ...);
void sol_ofs_dprintf_l3(char *name, char *fmt, ...);
void sol_ofs_dprintf_l2(char *name, char *fmt, ...);
void sol_ofs_dprintf_l1(char *name, char *fmt, ...);
void sol_ofs_dprintf_l0(char *name, char *fmt, ...);

#define SOL_OFS_DPRINTF_L5      sol_ofs_dprintf_l5
#define SOL_OFS_DPRINTF_L4      sol_ofs_dprintf_l4
#define SOL_OFS_DPRINTF_L3      sol_ofs_dprintf_l3
#define SOL_OFS_DPRINTF_L2      sol_ofs_dprintf_l2
#define SOL_OFS_DPRINTF_L1      sol_ofs_dprintf_l1
#define SOL_OFS_DPRINTF_L0      sol_ofs_dprintf_l0

/* Misc */
#define SOL_OFS_DRV_NAME_LEN    64

#ifdef __cplusplus
}
#endif

#endif /* _SYS_IB_CLIENTS_OF_SOL_OFS_SOL_OFS_COMMON_H */