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

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

#include <sys/dada/dada.h>


/*
 * Utility DADA routines
 */


/*
 * Polling support routines
 */

extern uintptr_t	dcd_callback_id;


#ifdef NOT_NEEDED
static int	dcd_poll_busycnt = DCD_POLL_TIMEOUT;
#endif


/*
 * Common buffer for dcd_lod
 */

extern kmutex_t  dcd_log_mutex;
static char dcd_log_buffer[256];


#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))


#ifdef NOT_NEEDED
int
dcd_poll(struct dcd_pkt *pkt)
{

	register	busy_count, rval = -1, savef;
	clock_t	savet;
	void	(*savec)();


	/*
	 * Save old flags
	 */
	savef = pkt->pkt_flags;
	savec = pkt->pkt_comp;
	savet = pkt->pkt_time;

	pkt->pkt_flags |= FLAG_NOINTR;


	/*
	 * Set the Pkt_comp to NULL
	 */

	pkt->pkt_comp = 0;

	/*
	 * Set the Pkt time for the polled command
	 */
	if (pkt->pkt_time == 0) {
		pkt->pkt_time = DCD_POLL_TIMEOUT;
	}


	/* Now transport the command */
	for (busy_count = 0; busy_count < dcd_poll_busycnt; busy_count++) {
		if (dcd_transport(pkt) != TRAN_ACCEPT) {
			break;
		}
		if (pkt->pkt_reason == CMD_INCOMPLETE && pkt->pkt_state == 0) {
			drv_usecwait(1000000);
		} else if (pkt->pkt_reason  != CMD_CMPLT) {
			break;
		} else if (((*pkt->pkt_scbp) & STATUS_ATA_MASK)
			    == STATUS_ATA_BUSY) {
			drv_usecwait(1000000);
		} else {
			rval = 0;
			break;
		}
	}

	pkt->pkt_flags = savef;
	pkt->pkt_comp = savec;
	pkt->pkt_time = savet;
	return (rval);
}
#endif


/*PRINTFLIKE4*/
void
dcd_log(dev_info_t *dev, char *label, uint_t level, const char *fmt, ...)
{

	auto char name[256];
	va_list	ap;
	int	log_only = 0;
	int	boot_only = 0;
	int	console_only = 0;


	mutex_enter(&dcd_log_mutex);


	if (dev) {

		if (level == CE_PANIC || level == CE_WARN) {
			(void) sprintf(name, "%s (%s%d):\n",
				ddi_pathname(dev, dcd_log_buffer), label,
				ddi_get_instance(dev));
		} else if (level == CE_NOTE ||
			level >= (uint_t)DCD_DEBUG) {
			(void) sprintf(name, "%s%d:", label,
						ddi_get_instance(dev));
		} else if (level == CE_CONT) {
			name[0] = '\0';
		}
	} else {
		(void) sprintf(name, "%s:", label);
	}


	va_start(ap, fmt);
	(void) vsprintf(dcd_log_buffer, fmt, ap);
	va_end(ap);


	switch (dcd_log_buffer[0]) {
	case '!':
		log_only = 1;
		break;
	case '?':
		boot_only = 1;
		break;
	case '^':
		console_only = 1;
		break;
	}

	switch (level) {

	case CE_NOTE:
		level = CE_CONT;
		/* FALLTHROUGH */
	case CE_CONT:
	case CE_WARN:
	case CE_PANIC:
		if (boot_only) {
			cmn_err(level, "?%s\t%s", name,
				&dcd_log_buffer[1]);
		} else if (console_only) {
			cmn_err(level, "^%s\t%s", name,
				&dcd_log_buffer[1]);
		} else if (log_only) {
			cmn_err(level, "!%s\t%s", name,
				&dcd_log_buffer[1]);
		} else {
			cmn_err(level, "%s\t%s", name,
				dcd_log_buffer);
		}
		break;
	case (uint_t)DCD_DEBUG:
	default:
		cmn_err(CE_CONT, "^DEBUG: %s\t%s\n", name,
				dcd_log_buffer);
		break;
	}

	mutex_exit(&dcd_log_mutex);
}