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