/*
 * 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 © 2003-2011 Emulex. All rights reserved.  */

/*
 * Source file containing the implementation of the driver
 * helper functions
 */

#include <oce_impl.h>

static void oce_list_del_node(OCE_LIST_NODE_T *prev_node,
    OCE_LIST_NODE_T *next_node);
static void oce_list_remove(OCE_LIST_NODE_T *list_node);
static void oce_list_insert_node(OCE_LIST_NODE_T  *list_node,
    OCE_LIST_NODE_T *prev_node, OCE_LIST_NODE_T *next_node);
/*
 * function to breakup a block of memory into pages and return the address
 * in an array
 *
 * dbuf - pointer to structure describing DMA-able memory
 * pa_list - [OUT] pointer to an array to return the PA of pages
 * list_size - number of entries in pa_list
 */
void
oce_page_list(oce_dma_buf_t *dbuf,
    struct phys_addr *pa_list, int list_size)
{
        int i = 0;
        uint64_t paddr = 0;

        ASSERT(dbuf != NULL);
        ASSERT(pa_list != NULL);

        paddr = DBUF_PA(dbuf);
        for (i = 0; i < list_size; i++) {
                pa_list[i].lo = ADDR_LO(paddr);
                pa_list[i].hi = ADDR_HI(paddr);
                paddr += PAGE_4K;
        }
} /* oce_page_list */

void
oce_list_link_init(OCE_LIST_NODE_T  *list_node)
{
        list_node->next = NULL;
        list_node->prev = NULL;
}

static inline void
oce_list_insert_node(OCE_LIST_NODE_T  *list_node, OCE_LIST_NODE_T *prev_node,
    OCE_LIST_NODE_T *next_node)
{
        next_node->prev = list_node;
        list_node->next = next_node;
        list_node->prev = prev_node;
        prev_node->next = list_node;
}

static inline void
oce_list_del_node(OCE_LIST_NODE_T *prev_node, OCE_LIST_NODE_T *next_node)
{
        next_node->prev = prev_node;
        prev_node->next = next_node;
}

static inline void
oce_list_remove(OCE_LIST_NODE_T *list_node)
{
        oce_list_del_node(list_node->prev, list_node->next);
        list_node->next = list_node->prev = NULL;
}

void
oce_list_create(OCE_LIST_T  *list_hdr, void *arg)
{
        list_hdr->head.next = list_hdr->head.prev = &list_hdr->head;
        mutex_init(&list_hdr->list_lock, NULL, MUTEX_DRIVER, arg);
        list_hdr->nitems = 0;
}

void
oce_list_destroy(OCE_LIST_T *list_hdr)
{
        ASSERT(list_hdr->nitems == 0);
        list_hdr->head.next = list_hdr->head.prev = NULL;
        mutex_destroy(&list_hdr->list_lock);

}

void
oce_list_insert_tail(OCE_LIST_T *list_hdr, OCE_LIST_NODE_T *list_node)
{
        OCE_LIST_NODE_T *head = &list_hdr->head;

        ASSERT(list_hdr != NULL);
        ASSERT(list_node != NULL);

        mutex_enter(&list_hdr->list_lock);
        oce_list_insert_node(list_node, head->prev, head);
        list_hdr->nitems++;
        mutex_exit(&list_hdr->list_lock);
}

void
oce_list_insert_head(OCE_LIST_T *list_hdr, OCE_LIST_NODE_T *list_node)
{
        OCE_LIST_NODE_T *head = &list_hdr->head;

        ASSERT(list_hdr != NULL);
        ASSERT(list_node != NULL);

        mutex_enter(&list_hdr->list_lock);
        oce_list_insert_node(list_node, head, head->next);
        list_hdr->nitems++;
        mutex_exit(&list_hdr->list_lock);
}

void *
oce_list_remove_tail(OCE_LIST_T *list_hdr)
{
        OCE_LIST_NODE_T *list_node;

        if (list_hdr == NULL) {
                return (NULL);
        }

        mutex_enter(&list_hdr->list_lock);

        if (list_hdr->nitems <= 0) {
                mutex_exit(&list_hdr->list_lock);
                return (NULL);
        }

        list_node = list_hdr->head.prev;
        oce_list_remove(list_node);
        list_hdr->nitems--;
        mutex_exit(&list_hdr->list_lock);
        return (list_node);
}

void *
oce_list_remove_head(OCE_LIST_T  *list_hdr)
{
        OCE_LIST_NODE_T *list_node;

        if (list_hdr == NULL) {
                return (NULL);
        }

        mutex_enter(&list_hdr->list_lock);

        if (list_hdr->nitems <= 0) {
                mutex_exit(&list_hdr->list_lock);
                return (NULL);
        }

        list_node = list_hdr->head.next;

        if (list_node != NULL) {
                oce_list_remove(list_node);
                list_hdr->nitems--;
        }

        mutex_exit(&list_hdr->list_lock);
        return (list_node);
}

boolean_t
oce_list_is_empty(OCE_LIST_T *list_hdr)
{
        if (list_hdr == NULL)
                return (B_TRUE);
        else
                return (list_hdr->nitems <= 0);
}

int
oce_list_items_avail(OCE_LIST_T *list_hdr)
{
        if (list_hdr == NULL)
                return (0);
        else
                return (list_hdr->nitems);
}

void
oce_list_remove_node(OCE_LIST_T  *list_hdr, OCE_LIST_NODE_T *list_node)
{
        mutex_enter(&list_hdr->list_lock);
        oce_list_remove(list_node);
        mutex_exit(&list_hdr->list_lock);
}

void
oce_gen_hkey(char *hkey, int key_size)
{
        int i;
        int nkeys = key_size/sizeof (uint32_t);
        for (i = 0; i < nkeys; i++) {
                (void) random_get_pseudo_bytes(
                    (uint8_t *)&hkey[i * sizeof (uint32_t)],
                    sizeof (uint32_t));
        }
}

int
oce_atomic_reserve(uint32_t *count_p, uint32_t n)
{
        uint32_t oldval;
        uint32_t newval;

        /*
         * ATOMICALLY
         */
        do {
                oldval = *count_p;
                if (oldval < n)
                        return (-1);
                newval = oldval - n;

        } while (atomic_cas_32(count_p, oldval, newval) != oldval);

        return (newval);
}