/*
 * 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) 1999-2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * hci1394_misc.c
 *    Misc. HBA functions.  These include getinfo, open, close, shutdown, and
 *    overall driver state control functions.
 */

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

#include <sys/1394/adapters/hci1394.h>
#include <sys/1394/adapters/hci1394_extern.h>



/* ARGSUSED */
int
hci1394_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
	dev_t dev;
	hci1394_state_t *soft_state;
	minor_t instance;
	int status;

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		dev = (dev_t)arg;
		instance = getminor(dev);
		soft_state = ddi_get_soft_state(hci1394_statep, instance);
		if (soft_state == NULL) {
			return (DDI_FAILURE);
		}
		*result = (void *)soft_state->drvinfo.di_dip;
		status = DDI_SUCCESS;
		break;

	case DDI_INFO_DEVT2INSTANCE:
		dev = (dev_t)arg;
		instance = getminor(dev);
		*result = (void *)(uintptr_t)instance;
		status = DDI_SUCCESS;
		break;

	default:
		status = DDI_FAILURE;
	}

	return (status);
}


/* ARGSUSED */
int
hci1394_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
	hci1394_state_t *soft_state;

	soft_state = ddi_get_soft_state(hci1394_statep, getminor(*devp));
	if (soft_state == NULL) {
		return (ENXIO);
	}

	return (0);
}


/* ARGSUSED */
int
hci1394_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
	return (0);
}


/*
 * hci1394_shutdown()
 *    Shutdown the HW.  Something bad that we cannot recover from happened.
 */
void
hci1394_shutdown(dev_info_t *dip)
{
	hci1394_state_t *soft_state;


	/*
	 * In the debug version of the driver, we want to do an assert here so
	 * that we don't reset the hardware and can look and see what happened
	 * to cause the shutdown.
	 */
#ifndef	TEST_SHUTDOWN
	ASSERT(0);
#endif

	soft_state = ddi_get_soft_state(hci1394_statep, ddi_get_instance(dip));
	if (soft_state == NULL) {
		return;
	}

	/*
	 * Don't allow the HW to generate any more interrupts. Make sure we
	 * disable interrupts before setting the driver state to shutdown.
	 */
	hci1394_ohci_intr_master_disable(soft_state->ohci);

	/* don't accept anymore commands from services layer */
	(void) hci1394_state_set(&soft_state->drvinfo, HCI1394_SHUTDOWN);

	/* Reset the OHCI HW */
	(void) hci1394_ohci_soft_reset(soft_state->ohci);

	/* Flush out async DMA Q's (cancels pendingQ timeouts too) */
	hci1394_async_flush(soft_state->async);
}


/*
 * hci1394_state()
 *    returns the current state of the driver
 */
hci1394_statevar_t
hci1394_state(hci1394_drvinfo_t *drvinfo)
{
	hci1394_statevar_t hal_state;

	mutex_enter(&drvinfo->di_drvstate.ds_mutex);
	hal_state = drvinfo->di_drvstate.ds_state;
	mutex_exit(&drvinfo->di_drvstate.ds_mutex);

	return (hal_state);
}


/*
 * hci1394_state_set()
 *    Set the current state of the driver. This routine will return failure
 *    if the driver state is currently set to HCI1394_SHUTDOWN.  We do not
 *    allow a transition out of shutdown.
 */
int
hci1394_state_set(hci1394_drvinfo_t *drvinfo, hci1394_statevar_t state)
{
	mutex_enter(&drvinfo->di_drvstate.ds_mutex);

	/* Do not allow a transition out of shutdown */
	if (drvinfo->di_drvstate.ds_state == HCI1394_SHUTDOWN) {
		mutex_exit(&drvinfo->di_drvstate.ds_mutex);
		return (DDI_FAILURE);
	}

	drvinfo->di_drvstate.ds_state = state;
	mutex_exit(&drvinfo->di_drvstate.ds_mutex);

	return (DDI_SUCCESS);
}