/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include "ghd.h"

void
ghd_dmafree_attr(gcmd_t *gcmdp)
{
	GDBG_DMA(("ghd_dma_attr_free: gcmdp 0x%p\n", (void *)gcmdp));

	if (gcmdp->cmd_dma_handle != NULL) {
		if (ddi_dma_unbind_handle(gcmdp->cmd_dma_handle) !=
		    DDI_SUCCESS)
			cmn_err(CE_WARN, "ghd dma free attr: "
			    "unbind handle failed");
		ddi_dma_free_handle(&gcmdp->cmd_dma_handle);
		GDBG_DMA(("ghd_dma_attr_free: ddi_dma_free 0x%p\n",
		    (void *)gcmdp));
		gcmdp->cmd_dma_handle = NULL;
		gcmdp->cmd_ccount = 0;
		gcmdp->cmd_totxfer = 0;
	}
}


int
ghd_dma_buf_bind_attr(ccc_t		*cccp,
			gcmd_t		*gcmdp,
			struct buf	*bp,
			int		 dma_flags,
			int		(*callback)(),
			caddr_t		 arg,
			ddi_dma_attr_t	*sg_attrp)
{
	int	 status;

	GDBG_DMA(("ghd_dma_attr_get: start: gcmdp 0x%p sg_attrp 0x%p\n",
	    (void *)gcmdp, (void *)sg_attrp));


	/*
	 * First time, need to establish the handle.
	 */

	ASSERT(gcmdp->cmd_dma_handle == NULL);

	status = ddi_dma_alloc_handle(cccp->ccc_hba_dip, sg_attrp, callback,
	    arg, &gcmdp->cmd_dma_handle);

	if (status != DDI_SUCCESS) {
		bp->b_error = 0;
		return (FALSE);
	}

	status = ddi_dma_buf_bind_handle(gcmdp->cmd_dma_handle, bp, dma_flags,
	    callback, arg, &gcmdp->cmd_first_cookie, &gcmdp->cmd_ccount);

	GDBG_DMA(("ghd_dma_attr_get: setup: gcmdp 0x%p status %d h 0x%p "
	    "c 0x%d\n", (void *)gcmdp, status, (void *)gcmdp->cmd_dma_handle,
	    gcmdp->cmd_ccount));

	switch (status) {
	case DDI_DMA_MAPPED:
		/* enable first (and only) call to ddi_dma_getwin */
		gcmdp->cmd_wcount = 1;
		break;

	case DDI_DMA_PARTIAL_MAP:
		/* enable first call to ddi_dma_getwin */
		if (ddi_dma_numwin(gcmdp->cmd_dma_handle, &gcmdp->cmd_wcount) !=
		    DDI_SUCCESS) {
			bp->b_error = 0;
			ddi_dma_free_handle(&gcmdp->cmd_dma_handle);
			gcmdp->cmd_dma_handle = NULL;
			return (FALSE);
		}
		break;

	case DDI_DMA_NORESOURCES:
		bp->b_error = 0;
		ddi_dma_free_handle(&gcmdp->cmd_dma_handle);
		gcmdp->cmd_dma_handle = NULL;
		return (FALSE);

	case DDI_DMA_TOOBIG:
		bioerror(bp, EINVAL);
		ddi_dma_free_handle(&gcmdp->cmd_dma_handle);
		gcmdp->cmd_dma_handle = NULL;
		return (FALSE);

	case DDI_DMA_NOMAPPING:
	case DDI_DMA_INUSE:
	default:
		bioerror(bp, EFAULT);
		ddi_dma_free_handle(&gcmdp->cmd_dma_handle);
		gcmdp->cmd_dma_handle = NULL;
		return (FALSE);
	}

	/* initialize the loop controls for ghd_dmaget_next_attr() */
	gcmdp->cmd_windex = 0;
	gcmdp->cmd_cindex = 0;
	gcmdp->cmd_totxfer = 0;
	gcmdp->cmd_dma_flags = dma_flags;
	gcmdp->use_first = 1;
	return (TRUE);
}


uint_t
ghd_dmaget_next_attr(ccc_t *cccp, gcmd_t *gcmdp, long max_transfer_cnt,
    int sg_size, ddi_dma_cookie_t cookie)
{
	ulong_t	toxfer = 0;
	int	num_segs = 0;
	int	single_seg;

	GDBG_DMA(("ghd_dma_attr_get: start: gcmdp 0x%p h 0x%p c 0x%x\n",
	    (void *)gcmdp, (void *)gcmdp->cmd_dma_handle, gcmdp->cmd_ccount));

	/*
	 * Disable single-segment Scatter/Gather option
	 * if can't do this transfer in a single segment,
	 */
	if (gcmdp->cmd_cindex + 1 < gcmdp->cmd_ccount) {
		single_seg = FALSE;
	} else {
		single_seg = TRUE;
	}


	for (;;) {
		/*
		 * call the controller specific S/G function
		 */
		(*cccp->ccc_sg_func)(gcmdp, &cookie, single_seg, num_segs);

		/* take care of the loop-bookkeeping */
		toxfer += cookie.dmac_size;
		num_segs++;
		gcmdp->cmd_cindex++;

		/*
		 * if this was the last cookie in the current window
		 * set the loop controls start the next window and
		 * exit so the HBA can do this partial transfer
		 */
		if (gcmdp->cmd_cindex >= gcmdp->cmd_ccount) {
			gcmdp->cmd_windex++;
			gcmdp->cmd_cindex = 0;
			break;
		}
		ASSERT(single_seg == FALSE);

		if (toxfer >= max_transfer_cnt)
			break;

		if (num_segs >= sg_size)
			break;

		ddi_dma_nextcookie(gcmdp->cmd_dma_handle, &cookie);
	}

	gcmdp->cmd_totxfer += toxfer;

	return ((uint_t)toxfer);
}



int
ghd_dmaget_attr(ccc_t		*cccp,
		gcmd_t		*gcmdp,
		long		count,
		int		sg_size,
		uint_t		*xfer)
{
	int	status;
	ddi_dma_cookie_t cookie;

	*xfer = 0;


	if (gcmdp->use_first == 1) {
		cookie = gcmdp->cmd_first_cookie;
		gcmdp->use_first = 0;
	} else if (gcmdp->cmd_windex >= gcmdp->cmd_wcount) {
		/*
		 * reached the end of buffer. This should not happen.
		 */
		ASSERT(gcmdp->cmd_windex < gcmdp->cmd_wcount);
		return (FALSE);

	} else if (gcmdp->cmd_cindex == 0) {
		off_t	offset;
		size_t	length;

		/*
		 * start the next window, and get its first cookie
		 */
		status = ddi_dma_getwin(gcmdp->cmd_dma_handle,
		    gcmdp->cmd_windex, &offset, &length,
		    &cookie, &gcmdp->cmd_ccount);
		if (status != DDI_SUCCESS)
			return (FALSE);

	} else {
		/*
		 * get the next cookie in the current window
		 */
		ddi_dma_nextcookie(gcmdp->cmd_dma_handle, &cookie);
	}

	/*
	 * start the Scatter/Gather loop passing in the first
	 * cookie obtained above
	 */
	*xfer = ghd_dmaget_next_attr(cccp, gcmdp, count, sg_size, cookie);
	return (TRUE);
}