/*
 * 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 2009-2015 QLogic Corporation.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>

#include <sys/stmf_defines.h>
#include <sys/fct_defines.h>
#include <sys/stmf.h>
#include <sys/portif.h>
#include <sys/fct.h>

#include "qlt.h"
#include "qlt_dma.h"

/*
 *  Local Function Prototypes.
 */
static void
qlt_dma_free_handles(qlt_state_t *qlt, qlt_dma_handle_t *first_handle);

#define	BUF_COUNT_2K		2048
#define	BUF_COUNT_8K		512
#define	BUF_COUNT_64K		256
#define	BUF_COUNT_128K		1024
#define	BUF_COUNT_256K		8

#define	QLT_DMEM_MAX_BUF_SIZE	(4 * 65536)
#define	QLT_DMEM_NBUCKETS	5
static qlt_dmem_bucket_t bucket2K	= { 2048, BUF_COUNT_2K },
			bucket8K	= { 8192, BUF_COUNT_8K },
			bucket64K	= { 65536, BUF_COUNT_64K },
			bucket128k	= { (2 * 65536), BUF_COUNT_128K },
			bucket256k	= { (4 * 65536), BUF_COUNT_256K };

static qlt_dmem_bucket_t *dmem_buckets[] = { &bucket2K, &bucket8K,
			&bucket64K, &bucket128k, &bucket256k, NULL };
static ddi_device_acc_attr_t acc;
static ddi_dma_attr_t qlt_scsi_dma_attr = {
	DMA_ATTR_V0,		/* dma_attr_version */
	0,			/* low DMA address range */
	0xffffffffffffffff,	/* high DMA address range */
	0xffffffff,		/* DMA counter register */
	8192,			/* DMA address alignment */
	0xff,			/* DMA burstsizes */
	1,			/* min effective DMA size */
	0xffffffff,		/* max DMA xfer size */
	0xffffffff,		/* segment boundary */
	1,			/* s/g list length */
	1,			/* granularity of device */
	0			/* DMA transfer flags */
};

fct_status_t
qlt_dmem_init(qlt_state_t *qlt)
{
	qlt_dmem_bucket_t	*p;
	qlt_dmem_bctl_t		*bctl, *bc;
	qlt_dmem_bctl_t		*prev;
	int			ndx, i;
	uint32_t		total_mem;
	uint8_t			*addr;
	uint8_t			*host_addr;
	uint64_t		dev_addr;
	ddi_dma_cookie_t	cookie;
	uint32_t		ncookie;
	uint32_t		bsize;
	size_t			len;

	if (qlt->qlt_bucketcnt[0] != 0) {
		bucket2K.dmem_nbufs = qlt->qlt_bucketcnt[0];
	}
	if (qlt->qlt_bucketcnt[1] != 0) {
		bucket8K.dmem_nbufs = qlt->qlt_bucketcnt[1];
	}
	if (qlt->qlt_bucketcnt[2] != 0) {
		bucket64K.dmem_nbufs = qlt->qlt_bucketcnt[2];
	}
	if (qlt->qlt_bucketcnt[3] != 0) {
		bucket128k.dmem_nbufs = qlt->qlt_bucketcnt[3];
	}
	if (qlt->qlt_bucketcnt[4] != 0) {
		bucket256k.dmem_nbufs = qlt->qlt_bucketcnt[4];
	}

	bsize = sizeof (dmem_buckets);
	ndx = (int)(bsize / sizeof (void *));
	/*
	 * The reason it is ndx - 1 everywhere is becasue the last bucket
	 * pointer is NULL.
	 */
	qlt->dmem_buckets = (qlt_dmem_bucket_t **)kmem_zalloc(bsize +
	    ((ndx - 1) * (int)sizeof (qlt_dmem_bucket_t)), KM_SLEEP);
	for (i = 0; i < (ndx - 1); i++) {
		qlt->dmem_buckets[i] = (qlt_dmem_bucket_t *)
		    ((uint8_t *)qlt->dmem_buckets + bsize +
		    (i * (int)sizeof (qlt_dmem_bucket_t)));
		bcopy(dmem_buckets[i], qlt->dmem_buckets[i],
		    sizeof (qlt_dmem_bucket_t));
	}
	bzero(&acc, sizeof (acc));
	acc.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	acc.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
	acc.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
	for (ndx = 0; (p = qlt->dmem_buckets[ndx]) != NULL; ndx++) {
		bctl = (qlt_dmem_bctl_t *)kmem_zalloc(p->dmem_nbufs *
		    sizeof (qlt_dmem_bctl_t), KM_NOSLEEP);
		if (bctl == NULL) {
			EL(qlt, "bctl==NULL\n");
			goto alloc_bctl_failed;
		}
		p->dmem_bctls_mem = bctl;
		mutex_init(&p->dmem_lock, NULL, MUTEX_DRIVER, NULL);
		if ((i = ddi_dma_alloc_handle(qlt->dip, &qlt_scsi_dma_attr,
		    DDI_DMA_SLEEP, 0, &p->dmem_dma_handle)) != DDI_SUCCESS) {
			EL(qlt, "ddi_dma_alloc_handle status=%xh\n", i);
			goto alloc_handle_failed;
		}

		total_mem = p->dmem_buf_size * p->dmem_nbufs;

		if ((i = ddi_dma_mem_alloc(p->dmem_dma_handle, total_mem, &acc,
		    DDI_DMA_STREAMING, DDI_DMA_DONTWAIT, 0, (caddr_t *)&addr,
		    &len, &p->dmem_acc_handle)) != DDI_SUCCESS) {
			EL(qlt, "ddi_dma_mem_alloc status=%xh\n", i);
			goto mem_alloc_failed;
		}

		if ((i = ddi_dma_addr_bind_handle(p->dmem_dma_handle, NULL,
		    (caddr_t)addr, total_mem, DDI_DMA_RDWR | DDI_DMA_STREAMING,
		    DDI_DMA_DONTWAIT, 0, &cookie, &ncookie)) != DDI_SUCCESS) {
			EL(qlt, "ddi_dma_addr_bind_handle status=%xh\n", i);
			goto addr_bind_handle_failed;
		}
		if (ncookie != 1) {
			EL(qlt, "ncookie=%d\n", ncookie);
			goto dmem_init_failed;
		}

		p->dmem_host_addr = host_addr = addr;
		p->dmem_dev_addr = dev_addr = (uint64_t)cookie.dmac_laddress;
		bsize = p->dmem_buf_size;
		p->dmem_bctl_free_list = bctl;
		p->dmem_nbufs_free = p->dmem_nbufs;
		for (i = 0; i < p->dmem_nbufs; i++) {
			stmf_data_buf_t	*db;
			prev = bctl;
			bctl->bctl_bucket = p;
			bctl->bctl_buf = db = stmf_alloc(STMF_STRUCT_DATA_BUF,
			    0, 0);
			db->db_port_private = bctl;
			db->db_sglist[0].seg_addr = host_addr;
			bctl->bctl_dev_addr = dev_addr;
			db->db_sglist[0].seg_length = db->db_buf_size = bsize;
			db->db_sglist_length = 1;
			host_addr += bsize;
			dev_addr += bsize;
			bctl++;
			prev->bctl_next = bctl;
		}
		prev->bctl_next = NULL;
	}

	return (QLT_SUCCESS);

dmem_failure_loop:;
	bc = bctl;
	while (bc) {
		stmf_free(bc->bctl_buf);
		bc = bc->bctl_next;
	}
dmem_init_failed:;
	(void) ddi_dma_unbind_handle(p->dmem_dma_handle);
addr_bind_handle_failed:;
	ddi_dma_mem_free(&p->dmem_acc_handle);
mem_alloc_failed:;
	ddi_dma_free_handle(&p->dmem_dma_handle);
alloc_handle_failed:;
	kmem_free(p->dmem_bctls_mem, p->dmem_nbufs * sizeof (qlt_dmem_bctl_t));
	mutex_destroy(&p->dmem_lock);
alloc_bctl_failed:;
	if (--ndx >= 0) {
		p = qlt->dmem_buckets[ndx];
		bctl = p->dmem_bctl_free_list;
		goto dmem_failure_loop;
	}
	kmem_free(qlt->dmem_buckets, sizeof (dmem_buckets) +
	    (((sizeof (dmem_buckets)/sizeof (void *))-1)*
	    sizeof (qlt_dmem_bucket_t)));
	qlt->dmem_buckets = NULL;

	return (QLT_FAILURE);
}

void
qlt_dma_handle_pool_init(qlt_state_t *qlt)
{
	qlt_dma_handle_pool_t *pool;

	pool = kmem_zalloc(sizeof (*pool), KM_SLEEP);
	mutex_init(&pool->pool_lock, NULL, MUTEX_DRIVER, NULL);
	qlt->qlt_dma_handle_pool = pool;
}

void
qlt_dma_handle_pool_fini(qlt_state_t *qlt)
{
	qlt_dma_handle_pool_t	*pool;
	qlt_dma_handle_t	*handle, *next_handle;

	pool = qlt->qlt_dma_handle_pool;
	mutex_enter(&pool->pool_lock);
	/*
	 * XXX Need to wait for free == total elements
	 * XXX Not sure how other driver shutdown stuff is done.
	 */
	ASSERT(pool->num_free == pool->num_total);
	if (pool->num_free != pool->num_total)
		cmn_err(CE_WARN,
		    "num_free %d != num_total %d\n",
		    pool->num_free, pool->num_total);
	handle = pool->free_list;
	while (handle) {
		next_handle = handle->next;
		kmem_free(handle, sizeof (*handle));
		handle = next_handle;
	}
	qlt->qlt_dma_handle_pool = NULL;
	mutex_destroy(&pool->pool_lock);
	kmem_free(pool, sizeof (*pool));
}

void
qlt_dmem_fini(qlt_state_t *qlt)
{
	qlt_dmem_bucket_t *p;
	qlt_dmem_bctl_t *bctl;
	int ndx;

	for (ndx = 0; (p = qlt->dmem_buckets[ndx]) != NULL; ndx++) {
		bctl = p->dmem_bctl_free_list;
		while (bctl) {
			stmf_free(bctl->bctl_buf);
			bctl = bctl->bctl_next;
		}
		bctl = p->dmem_bctl_free_list;
		(void) ddi_dma_unbind_handle(p->dmem_dma_handle);
		ddi_dma_mem_free(&p->dmem_acc_handle);
		ddi_dma_free_handle(&p->dmem_dma_handle);
		kmem_free(p->dmem_bctls_mem,
		    p->dmem_nbufs * sizeof (qlt_dmem_bctl_t));
		mutex_destroy(&p->dmem_lock);
	}
	kmem_free(qlt->dmem_buckets, sizeof (dmem_buckets) +
	    (((sizeof (dmem_buckets)/sizeof (void *))-1)*
	    sizeof (qlt_dmem_bucket_t)));
	qlt->dmem_buckets = NULL;
}

stmf_data_buf_t *
qlt_dmem_alloc(fct_local_port_t *port, uint32_t size, uint32_t *pminsize,
    uint32_t flags)
{
	return (qlt_i_dmem_alloc((qlt_state_t *)
	    port->port_fca_private, size, pminsize,
	    flags));
}

/* ARGSUSED */
stmf_data_buf_t *
qlt_i_dmem_alloc(qlt_state_t *qlt, uint32_t size, uint32_t *pminsize,
    uint32_t flags)
{
	qlt_dmem_bucket_t	*p;
	qlt_dmem_bctl_t 	*bctl;
	int			i;
	uint32_t		size_possible = 0;

	if (size > QLT_DMEM_MAX_BUF_SIZE) {
		goto qlt_try_partial_alloc;
	}

	/* 1st try to do a full allocation */
	for (i = 0; (p = qlt->dmem_buckets[i]) != NULL; i++) {
		if (p->dmem_buf_size >= size) {
			if (p->dmem_nbufs_free) {
				mutex_enter(&p->dmem_lock);
				bctl = p->dmem_bctl_free_list;
				if (bctl == NULL) {
					mutex_exit(&p->dmem_lock);
					continue;
				}
				p->dmem_bctl_free_list =
				    bctl->bctl_next;
				p->dmem_nbufs_free--;
				qlt->qlt_bufref[i]++;
				mutex_exit(&p->dmem_lock);
				bctl->bctl_buf->db_data_size = size;
				return (bctl->bctl_buf);
			} else {
				qlt->qlt_bumpbucket++;
			}
		}
	}

qlt_try_partial_alloc:

	qlt->qlt_pmintry++;

	/* Now go from high to low */
	for (i = QLT_DMEM_NBUCKETS - 1; i >= 0; i--) {
		p = qlt->dmem_buckets[i];
		if (p->dmem_nbufs_free == 0)
			continue;
		if (!size_possible) {
			size_possible = p->dmem_buf_size;
		}
		if (*pminsize > p->dmem_buf_size) {
			/* At this point we know the request is failing. */
			if (size_possible) {
				/*
				 * This caller is asking too much. We already
				 * know what we can give, so get out.
				 */
				break;
			} else {
				/*
				 * Lets continue to find out and tell what
				 * we can give.
				 */
				continue;
			}
		}
		mutex_enter(&p->dmem_lock);
		if (*pminsize <= p->dmem_buf_size) {
			bctl = p->dmem_bctl_free_list;
			if (bctl == NULL) {
				/* Someone took it. */
				size_possible = 0;
				mutex_exit(&p->dmem_lock);
				continue;
			}
			p->dmem_bctl_free_list = bctl->bctl_next;
			p->dmem_nbufs_free--;
			mutex_exit(&p->dmem_lock);
			bctl->bctl_buf->db_data_size = p->dmem_buf_size;
			qlt->qlt_pmin_ok++;
			return (bctl->bctl_buf);
		}
	}

	*pminsize = size_possible;

	return (NULL);
}

/* ARGSUSED */
void
qlt_i_dmem_free(qlt_state_t *qlt, stmf_data_buf_t *dbuf)
{
	qlt_dmem_free(0, dbuf);
}

/* ARGSUSED */
void
qlt_dmem_free(fct_dbuf_store_t *fds, stmf_data_buf_t *dbuf)
{
	qlt_dmem_bctl_t		*bctl;
	qlt_dmem_bucket_t	*p;

	ASSERT((dbuf->db_flags & DB_LU_DATA_BUF) == 0);

	bctl = (qlt_dmem_bctl_t *)dbuf->db_port_private;
	p = bctl->bctl_bucket;
	mutex_enter(&p->dmem_lock);
	bctl->bctl_next = p->dmem_bctl_free_list;
	p->dmem_bctl_free_list = bctl;
	p->dmem_nbufs_free++;
	mutex_exit(&p->dmem_lock);
}

void
qlt_dmem_dma_sync(stmf_data_buf_t *dbuf, uint_t sync_type)
{
	qlt_dmem_bctl_t		*bctl;
	qlt_dma_sgl_t		*qsgl;
	qlt_dmem_bucket_t	*p;
	qlt_dma_handle_t	*th;
	int			rv;

	if (dbuf->db_flags & DB_LU_DATA_BUF) {
		/*
		 * go through ddi handle list
		 */
		qsgl = (qlt_dma_sgl_t *)dbuf->db_port_private;
		th = qsgl->handle_list;
		while (th) {
			rv = ddi_dma_sync(th->dma_handle,
			    0, 0, sync_type);
			if (rv != DDI_SUCCESS) {
				cmn_err(CE_WARN, "ddi_dma_sync FAILED\n");
			}
			th = th->next;
		}
	} else {
		bctl = (qlt_dmem_bctl_t *)dbuf->db_port_private;
		p = bctl->bctl_bucket;
		(void) ddi_dma_sync(p->dmem_dma_handle, (off_t)
		    (bctl->bctl_dev_addr - p->dmem_dev_addr),
		    dbuf->db_data_size, sync_type);
	}
}

/*
 * A very lite version of ddi_dma_addr_bind_handle()
 */
uint64_t
qlt_ddi_vtop(caddr_t vaddr)
{
	uint64_t offset, paddr;
	pfn_t pfn;

	pfn = hat_getpfnum(kas.a_hat, vaddr);
	ASSERT(pfn != PFN_INVALID && pfn != PFN_SUSPENDED);
	offset = ((uintptr_t)vaddr) & MMU_PAGEOFFSET;
	paddr = mmu_ptob(pfn);
	return (paddr+offset);
}

static ddi_dma_attr_t 	qlt_sgl_dma_attr = {
	DMA_ATTR_V0,		/* dma_attr_version */
	0,				/* low DMA address range */
	0xffffffffffffffff,		/* high DMA address range */
	0xffffffff,			/* DMA counter register */
	64,				/* DMA address alignment */
	0xff,			/* DMA burstsizes */
	1,				/* min effective DMA size */
	0xffffffff,			/* max DMA xfer size */
	0xffffffff,			/* segment boundary */
	QLT_DMA_SG_LIST_LENGTH,	/* s/g list length */
	1,				/* granularity of device */
	0				/* DMA transfer flags */
};

/*
 * Allocate a qlt_dma_handle container and fill it with a ddi_dma_handle
 */
static qlt_dma_handle_t *
qlt_dma_alloc_handle(qlt_state_t *qlt)
{
	ddi_dma_handle_t ddi_handle;
	qlt_dma_handle_t *qlt_handle;
	int rv;

	rv = ddi_dma_alloc_handle(qlt->dip, &qlt_sgl_dma_attr,
	    DDI_DMA_SLEEP, 0, &ddi_handle);
	if (rv != DDI_SUCCESS) {
		EL(qlt, "ddi_dma_alloc_handle status=%xh\n", rv);
		return (NULL);
	}
	qlt_handle = kmem_zalloc(sizeof (qlt_dma_handle_t), KM_SLEEP);
	qlt_handle->dma_handle = ddi_handle;
	return (qlt_handle);
}

/*
 * Allocate a list of qlt_dma_handle containers from the free list
 */
static qlt_dma_handle_t *
qlt_dma_alloc_handle_list(qlt_state_t *qlt, int handle_count)
{
	qlt_dma_handle_pool_t	*pool;
	qlt_dma_handle_t	*tmp_handle, *first_handle, *last_handle;
	int i;

	/*
	 * Make sure the free list can satisfy the request.
	 * Once the free list is primed, it should satisfy most requests.
	 * XXX Should there be a limit on pool size?
	 */
	pool = qlt->qlt_dma_handle_pool;
	mutex_enter(&pool->pool_lock);
	while (handle_count > pool->num_free) {
		mutex_exit(&pool->pool_lock);
		if ((tmp_handle = qlt_dma_alloc_handle(qlt)) == NULL)
			return (NULL);
		mutex_enter(&pool->pool_lock);
		tmp_handle->next = pool->free_list;
		pool->free_list = tmp_handle;
		pool->num_free++;
		pool->num_total++;
	}

	/*
	 * The free list lock is held and the list is large enough to
	 * satisfy this request. Run down the freelist and snip off
	 * the number of elements needed for this request.
	 */
	first_handle = pool->free_list;
	tmp_handle = first_handle;
	for (i = 0; i < handle_count; i++) {
		last_handle = tmp_handle;
		tmp_handle = tmp_handle->next;
	}
	pool->free_list = tmp_handle;
	pool->num_free -= handle_count;
	mutex_exit(&pool->pool_lock);
	last_handle->next = NULL;	/* sanity */
	return (first_handle);
}

/*
 * Return a list of qlt_dma_handle containers to the free list.
 */
static void
qlt_dma_free_handles(qlt_state_t *qlt, qlt_dma_handle_t *first_handle)
{
	qlt_dma_handle_pool_t *pool;
	qlt_dma_handle_t *tmp_handle, *last_handle;
	int rv, handle_count;

	/*
	 * Traverse the list and unbind the handles
	 */
	ASSERT(first_handle);
	tmp_handle = first_handle;
	handle_count = 0;
	while (tmp_handle != NULL) {
		last_handle = tmp_handle;
		/*
		 * If the handle is bound, unbind the handle so it can be
		 * reused. It may not be bound if there was a bind failure.
		 */
		if (tmp_handle->num_cookies != 0) {
			rv = ddi_dma_unbind_handle(tmp_handle->dma_handle);
			ASSERT(rv == DDI_SUCCESS);
			if (rv == DDI_SUCCESS) {
				tmp_handle->num_cookies = 0;
				tmp_handle->num_cookies_fetched = 0;
			}
		}
		tmp_handle = tmp_handle->next;
		handle_count++;
	}
	/*
	 * Insert this list into the free list
	 */
	pool = qlt->qlt_dma_handle_pool;
	mutex_enter(&pool->pool_lock);
	last_handle->next = pool->free_list;
	pool->free_list = first_handle;
	pool->num_free += handle_count;
	mutex_exit(&pool->pool_lock);
}

/*
 * cookies produced by mapping this dbuf
 */
uint16_t
qlt_get_cookie_count(stmf_data_buf_t *dbuf)
{
	qlt_dma_sgl_t *qsgl = dbuf->db_port_private;

	ASSERT(dbuf->db_flags & DB_LU_DATA_BUF);
	return (qsgl->cookie_count);
}

ddi_dma_cookie_t
*qlt_get_cookie_array(stmf_data_buf_t *dbuf)
{
	qlt_dma_sgl_t *qsgl = dbuf->db_port_private;

	ASSERT(dbuf->db_flags & DB_LU_DATA_BUF);

	if (qsgl->cookie_prefetched)
		return (&qsgl->cookie[0]);
	else
		return (NULL);
}

/*
 * Wrapper around ddi_dma_nextcookie that hides the ddi_dma_handle usage.
 */
void
qlt_ddi_dma_nextcookie(stmf_data_buf_t *dbuf, ddi_dma_cookie_t *cookiep)
{
	qlt_dma_sgl_t *qsgl = dbuf->db_port_private;

	ASSERT(dbuf->db_flags & DB_LU_DATA_BUF);

	if (qsgl->cookie_prefetched) {
		ASSERT(qsgl->cookie_next_fetch < qsgl->cookie_count);
		*cookiep = qsgl->cookie[qsgl->cookie_next_fetch++];
	} else {
		qlt_dma_handle_t *fetch;
		qlt_dma_handle_t *FETCH_DONE = (qlt_dma_handle_t *)0xbad;

		ASSERT(qsgl->handle_list != NULL);
		ASSERT(qsgl->handle_next_fetch != FETCH_DONE);

		fetch = qsgl->handle_next_fetch;
		if (fetch->num_cookies_fetched == 0) {
			*cookiep = fetch->first_cookie;
		} else {
			ddi_dma_nextcookie(fetch->dma_handle, cookiep);
		}
		if (++fetch->num_cookies_fetched == fetch->num_cookies) {
			if (fetch->next == NULL)
				qsgl->handle_next_fetch = FETCH_DONE;
			else
				qsgl->handle_next_fetch = fetch->next;
		}
	}
}

/*
 * Set this flag to fetch the DDI dma cookies from the handles here and
 * store them in the port private area of the dbuf. This will allow
 * faster access to the cookies in qlt_xfer_scsi_data() at the expense of
 * an extra copy. If the qlt->req_lock is hot, this may help.
 */
uint16_t qlt_sgl_prefetch = 0;

/*ARGSUSED*/
stmf_status_t
qlt_dma_setup_dbuf(fct_local_port_t *port, stmf_data_buf_t *dbuf,
    uint32_t flags)
{
	qlt_state_t		*qlt = port->port_fca_private;
	qlt_dma_sgl_t		*qsgl;
	struct stmf_sglist_ent	*sglp;
	qlt_dma_handle_t	*handle_list, *th;
	int			i, rv;
	ddi_dma_cookie_t	*cookie_p;
	int			numbufs;
	uint16_t		cookie_count;
	uint16_t		prefetch;
	size_t			qsize;

	/*
	 * psuedo code:
	 * get dma handle list from cache - one per sglist entry
	 * foreach sglist entry
	 *	bind dma handle to sglist vaddr
	 * allocate space for DMA state to store in db_port_private
	 * fill in port private object
	 * if prefetching
	 *	move all dma cookies into db_port_private
	 */
	dbuf->db_port_private = NULL;
	numbufs = dbuf->db_sglist_length;
	handle_list = qlt_dma_alloc_handle_list(qlt, numbufs);
	if (handle_list == NULL) {
		EL(qlt, "handle_list==NULL\n");
		return (STMF_FAILURE);
	}
	/*
	 * Loop through sglist and bind each entry to a handle
	 */
	th = handle_list;
	sglp = &dbuf->db_sglist[0];
	cookie_count = 0;
	for (i = 0; i < numbufs; i++, sglp++) {

		/*
		 * Bind this sgl entry to a DDI dma handle
		 */
		if ((rv = ddi_dma_addr_bind_handle(
		    th->dma_handle,
		    NULL,
		    (caddr_t)(sglp->seg_addr),
		    (size_t)sglp->seg_length,
		    DDI_DMA_RDWR | DDI_DMA_STREAMING,
		    DDI_DMA_DONTWAIT,
		    NULL,
		    &th->first_cookie,
		    &th->num_cookies)) != DDI_DMA_MAPPED) {
			cmn_err(CE_NOTE, "ddi_dma_addr_bind_handle %d", rv);
			qlt_dma_free_handles(qlt, handle_list);
			return (STMF_FAILURE);
		}

		/*
		 * Add to total cookie count
		 */
		cookie_count += th->num_cookies;
		if (cookie_count > QLT_DMA_SG_LIST_LENGTH) {
			/*
			 * Request exceeds HBA limit
			 */
			qlt_dma_free_handles(qlt, handle_list);
			return (STMF_FAILURE);
		}
		/* move to next ddi_dma_handle */
		th = th->next;
	}

	/*
	 * Allocate our port private object for DMA mapping state.
	 */
	prefetch =  qlt_sgl_prefetch;
	qsize = sizeof (qlt_dma_sgl_t);
	if (prefetch) {
		/* one extra ddi_dma_cookie allocated for alignment padding */
		qsize += cookie_count * sizeof (ddi_dma_cookie_t);
	}
	qsgl = kmem_alloc(qsize, KM_SLEEP);
	/*
	 * Fill in the sgl
	 */
	dbuf->db_port_private = qsgl;
	qsgl->qsize = qsize;
	qsgl->handle_count = dbuf->db_sglist_length;
	qsgl->cookie_prefetched = prefetch;
	qsgl->cookie_count = cookie_count;
	qsgl->cookie_next_fetch = 0;
	qsgl->handle_list = handle_list;
	qsgl->handle_next_fetch = handle_list;
	if (prefetch) {
		/*
		 * traverse handle list and move cookies to db_port_private
		 */
		th = handle_list;
		cookie_p = &qsgl->cookie[0];
		for (i = 0; i < numbufs; i++) {
			uint_t cc = th->num_cookies;

			*cookie_p++ = th->first_cookie;
			while (--cc > 0) {
				ddi_dma_nextcookie(th->dma_handle, cookie_p++);
			}
			th->num_cookies_fetched = th->num_cookies;
			th = th->next;
		}
	}

	return (STMF_SUCCESS);
}

void
qlt_dma_teardown_dbuf(fct_dbuf_store_t *fds, stmf_data_buf_t *dbuf)
{
	qlt_state_t		*qlt = fds->fds_fca_private;
	qlt_dma_sgl_t		*qsgl = dbuf->db_port_private;

	ASSERT(qlt);
	ASSERT(qsgl);
	ASSERT(dbuf->db_flags & DB_LU_DATA_BUF);

	/*
	 * unbind and free the dma handles
	 */
	if (qsgl->handle_list) {
		/* go through ddi handle list */
		qlt_dma_free_handles(qlt, qsgl->handle_list);
	}
	kmem_free(qsgl, qsgl->qsize);
}

uint8_t
qlt_get_iocb_count(uint32_t cookie_count)
{
	uint32_t	cnt, cont_segs;
	uint8_t		iocb_count;

	iocb_count = 1;
	cnt = CMD7_2400_DATA_SEGMENTS;
	cont_segs = CONT_A64_DATA_SEGMENTS;

	if (cookie_count > cnt) {
		cnt = cookie_count - cnt;
		iocb_count = (uint8_t)(iocb_count + cnt / cont_segs);
		if (cnt % cont_segs) {
			iocb_count++;
		}
	}
	return (iocb_count);
}