/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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) 1996,1999-2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Main Transport Routine for DADA.
 *
 */

#include <sys/dada/dada.h>
#include <sys/thread.h>


#define	A_TO_TRAN(ap)	((ap)->a_hba_tran)
#define	P_TO_TRAN(pkt) 	((pkt)->pkt_address.a_hba_tran)
#define	P_TO_ADDR(pkt)	(&((pkt)->pkt_address))


extern	kmutex_t	dcd_flag_nointr_mutex;
extern	kcondvar_t	dcd_flag_nointr_cv;

static void
dcd_flag_nointr_comp(struct dcd_pkt *pkt)
{

	mutex_enter(&dcd_flag_nointr_mutex);

	pkt->pkt_comp = NULL;

	/*
	 * We need cv_broadcast, because there can be more than
	 * one thread sleeping on the cv. We will wake all of them.
	 * The correct one will continue and the reset will again go to
	 * sleep.
	 */
	cv_broadcast(&dcd_flag_nointr_cv);
	mutex_exit(&dcd_flag_nointr_mutex);
}


int
dcd_transport(struct dcd_pkt *pkt)
{

	struct dcd_address *ap = P_TO_ADDR(pkt);
	extern int do_polled_io;
	int rval;

	/*
	 * Check if we are required to do polled I/O. We can
	 * get dcd_pkts that don't have the FLAG_NOINTR bit
	 * set in the pkt_flags. When do_polled_io is set
	 * we will probably be at a high IPL and not get any
	 * command completion interrupts. We force polled I/Os
	 * for such packets and do a callback of the completion
	 * routine ourselves.
	 */
	if (!do_polled_io && ((pkt->pkt_flags & FLAG_NOINTR) == 0)) {
		return ((*A_TO_TRAN(ap)->tran_start)(ap, pkt));
	} else if ((curthread->t_flag & T_INTR_THREAD) || (do_polled_io) ||
			(pkt->pkt_flags & FLAG_FORCENOINTR)) {

		if (pkt->pkt_flags & FLAG_FORCENOINTR) {
			/*
			 * FLAG_FORCENOINTR means we do not want to rely on
			 * device interrupts. Set the FLAG_NOINTR
			 * so the command gets completed in polled mode.
			 */
			pkt->pkt_flags &= ~FLAG_FORCENOINTR;
			pkt->pkt_flags |= FLAG_NOINTR;
		}

		/*
		 * If its an interrupt thread or we already have the
		 * the FLAG_NOINTR flag set, we go ahead and call the
		 * the hba's start routine directly. We force polling
		 * only if we have do_polled_io set and FLAG_NOINTR
		 * not set.
		 */
		if (!do_polled_io || (pkt->pkt_flags & FLAG_NOINTR)) {
			return ((*A_TO_TRAN(ap)->tran_start)(ap, pkt));
		} else {
			uint_t	savef;
			void	(*savec)();
			/*
			 * save the completion routine and pkt_flags
			 */
			savef = pkt->pkt_flags;
			savec = pkt->pkt_comp;
			pkt->pkt_flags |= FLAG_NOINTR;
			pkt->pkt_comp = 0;

			rval = (*A_TO_TRAN(ap)->tran_start)(ap, pkt);

			/*
			 * Restore the pkt_completion routine
			 * and pkt flags and call the completion
			 * routine.
			 */
			pkt->pkt_comp = savec;
			pkt->pkt_flags = savef;
			(*pkt->pkt_comp)(pkt);
			return (rval);
		}
	} else {
		uint_t	savef;
		void	(*savec)();
		int	status;

		savef = pkt->pkt_flags;
		savec = pkt->pkt_comp;

		pkt->pkt_comp = dcd_flag_nointr_comp;
		pkt->pkt_flags &= ~FLAG_NOINTR;
		pkt->pkt_flags |= FLAG_IMMEDIATE_CB;

		if ((status = (*A_TO_TRAN(ap)->tran_start)(ap, pkt)) ==
			TRAN_ACCEPT) {
			mutex_enter(& dcd_flag_nointr_mutex);
			while (pkt->pkt_comp != NULL) {
				cv_wait(&dcd_flag_nointr_cv,
					&dcd_flag_nointr_mutex);
			}
			mutex_exit(&dcd_flag_nointr_mutex);
		}
		pkt->pkt_flags = savef;
		pkt->pkt_comp = savec;
		return (status);
	}
}