/*
 * 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 <sys/note.h>

/*
 * Generic SCSI Host Bus Adapter interface implementation
 */

#include <sys/dada/dada.h>

extern int dcd_options;

static kmutex_t	dcd_hba_mutex;

kmutex_t	dcd_log_mutex;

struct dcd_hba_inst {
	dev_info_t	*inst_dip;
	dcd_hba_tran_t	*inst_hba_tran;
	struct dcd_hba_inst	*inst_next;
	struct	dcd_hba_inst	*inst_prev;
};

static struct dcd_hba_inst	*dcd_hba_list	= NULL;
static struct dcd_hba_inst	*dcd_hba_list_tail = NULL;


_NOTE(READ_ONLY_DATA(dev_ops))

kmutex_t	dcd_flag_nointr_mutex;
kcondvar_t	dcd_flag_nointr_cv;


/*
 * Called from _init when loading the dcd module.
 */
void
dcd_initialize_hba_interface()
{
	mutex_init(&dcd_hba_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&dcd_flag_nointr_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&dcd_flag_nointr_cv, NULL, CV_DRIVER, NULL);
	mutex_init(&dcd_log_mutex, NULL, MUTEX_DRIVER, NULL);
}

/*
 * Called from fini() when unloading the dcd module.
 */

void
dcd_uninitialize_hba_interface()
{
	mutex_destroy(&dcd_hba_mutex);
	cv_destroy(&dcd_flag_nointr_cv);
	mutex_destroy(&dcd_flag_nointr_mutex);
	mutex_destroy(&dcd_log_mutex);
}


/*
 * Called by an HBA from _init()
 */
/* ARGSUSED */
int
dcd_hba_init(struct modlinkage *modlp)
{

	return (0);
}



#ifdef NOTNEEDED
/* ARGSUSED */
int
dcd_hba_attach(dev_info_t *dip,
	ddi_dma_lim_t	*hba_lim,
	dcd_hba_tran_t	*hba_tran,
	int		flags,
	void		*hba_options)
{

	ddi_dma_attr_t		hba_dma_attr;

	bzero(&hba_dma_attr, sizeof (ddi_dma_attr_t));

	hba_dma_attr.dma_attr_burstsizes = hba_lim->dlim_burstsizes;
	hba_dma_attr.dma_attr_minxfer = hba_lim->dlim_minxfer;

	return (dcd_hba_attach_setup(dip, &hba_dma_attr, hba_tran, flags));
}
#endif


int
dcd_hba_attach(
	dev_info_t	*dip,
	ddi_dma_attr_t	*hba_dma_attr,
	dcd_hba_tran_t	*hba_tran,
	int		flags)
{

	struct dcd_hba_inst	*elem;
	int			value;
	int			len;
	char			*prop_name;
	char			*errmsg =
	    "dcd_hba_attach: cannott create property '%s' for %s%d\n";

	/*
	 * Link this instance into the list
	 */
	elem = kmem_alloc(sizeof (struct dcd_hba_inst), KM_SLEEP);

	elem->inst_dip = dip;
	elem->inst_hba_tran = hba_tran;

	mutex_enter(&dcd_hba_mutex);
	elem->inst_next = NULL;
	elem->inst_prev = dcd_hba_list_tail;

	if (dcd_hba_list == NULL) {
		dcd_hba_list = elem;
	}
	if (dcd_hba_list_tail) {
		dcd_hba_list_tail->inst_next = elem;
	}
	dcd_hba_list_tail = elem;
	mutex_exit(&dcd_hba_mutex);


	/*
	 * Save all the improtant HBA information that must be accessed
	 * later.
	 */

	hba_tran->tran_hba_dip = dip;
	hba_tran->tran_hba_flags = flags;

	/*
	 * Note: We only need dma_attr_minxfer and dma_attr_burstsize
	 * from the DMA atrributes
	 */

	hba_tran->tran_min_xfer = hba_dma_attr->dma_attr_minxfer;
	hba_tran->tran_min_burst_size =
	    (1<<(ddi_ffs(hba_dma_attr->dma_attr_burstsizes)-1));
	hba_tran->tran_max_burst_size =
	    (1<<(ddi_fls(hba_dma_attr->dma_attr_burstsizes)-1));



	prop_name = "dcd_options";
	len = 0;
	if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN, 0, prop_name,
	    NULL, &len) == DDI_PROP_NOT_FOUND) {
		value = dcd_options;
		if (ddi_prop_update_int(DDI_MAJOR_T_UNKNOWN, dip,
		    prop_name, value) != DDI_PROP_SUCCESS) {
			cmn_err(CE_CONT, errmsg, prop_name,
			    ddi_get_name(dip), ddi_get_instance(dip));
		}
	}


	/*
	 * XXX : This needs to be removed when code cleanup
	 * ddi_set_driver_private(dip, (caddr_t)hba_tran);
	 */
#ifdef DEBUG1
	printf("Called Set driver private with dip %x, tran %x\n",
	    dip, hba_tran);
#endif

	return (DDI_SUCCESS);
}


/*
 * called by an HBA to detach an instance of the driver
 */

int
dcd_hba_detach(dev_info_t *dip)
{

	dcd_hba_tran_t	*hba;
	struct dcd_hba_inst 	*elem;

	hba = ddi_get_driver_private(dip);
	ddi_set_driver_private(dip, NULL);
	ASSERT(hba != NULL);

	hba->tran_hba_dip = (dev_info_t *)NULL;
	hba->tran_hba_flags = 0;
	hba->tran_min_burst_size = (uchar_t)0;
	hba->tran_max_burst_size = (uchar_t)0;


	/*
	 * Remove HBA instance from dcd_hba_list
	 */

	mutex_enter(&dcd_hba_mutex);

	for (elem = dcd_hba_list; elem != (struct dcd_hba_inst *)NULL;
	    elem = elem->inst_next) {
		if (elem->inst_dip == dip)
			break;
	}

	if (elem == (struct dcd_hba_inst *)NULL) {
		cmn_err(CE_NOTE, "dcd_hba_attach: Unknown HBA instance\n");
		mutex_exit(&dcd_hba_mutex);
	}

	if (elem == dcd_hba_list) {
		dcd_hba_list = elem->inst_next;
		dcd_hba_list->inst_prev = (struct dcd_hba_inst *)NULL;
	} else if (elem == dcd_hba_list_tail) {
		dcd_hba_list_tail = elem->inst_prev;
		dcd_hba_list_tail->inst_next = (struct dcd_hba_inst *)NULL;
	} else {
		elem->inst_prev->inst_next = elem->inst_next;
		elem->inst_next->inst_prev = elem->inst_prev;
	}
	mutex_exit(&dcd_hba_mutex);

	kmem_free(elem, sizeof (struct dcd_hba_inst));

	return (DDI_SUCCESS);
}

void
dcd_hba_fini()
{

}

/* ARGSUSED */
dcd_hba_tran_t *
dcd_hba_tran_alloc(
	dev_info_t	*dip,
	int		flags)
{

	return (kmem_zalloc(sizeof (dcd_hba_tran_t),
	    (flags & DCD_HBA_CANSLEEP) ? KM_SLEEP: KM_NOSLEEP));
}


void
dcd_hba_tran_free(dcd_hba_tran_t	*hba_tran)
{

	kmem_free(hba_tran, sizeof (dcd_hba_tran_t));
}


/*
 * XXX: Do we really need the following routines.
 */

/*
 * private wrapper for dcd_pkt's allocated via scsi_hba_pkt_alloc
 */

struct dcd_pkt_wrapper {
	struct dcd_pkt	dcd_pkt;
	int		pkt_wrapper_len;
};

_NOTE(SCHEME_PROTECTS_DATA("unique per thread", dcd_pkt_wrapper))

/*
 * Round up all allocations so that we can gurentee
 * long-long alignment. This is the same alignment
 * provided by kmem_alloc().
 */

#define	ROUNDUP(x)	(((x) + 0x07) & ~0x07)

/*
 * Called by an HBA to allocate a dcd_pkt
 */

/* ARGSUSED */
struct dcd_pkt *
dcd_hba_pkt_alloc(
	struct dcd_address	*ap,
	int			cmdlen,
	int			statuslen,
	int			tgtlen,
	int			hbalen,
	int			(*callback)(caddr_t arg),
	caddr_t			arg)
{

	struct dcd_pkt	*pkt;
	struct dcd_pkt_wrapper	*hba_pkt;
	caddr_t		p;
	int		pktlen;


	/*
	 * Sanity check
	 */
	if (callback != SLEEP_FUNC && callback != NULL_FUNC) {
		cmn_err(CE_PANIC, " dcd_hba_pkt_alloc: callback must be"
		    " either SLEEP or NULL\n");
	}


	/*
	 * Round up so everything gets allocated on long-word boundaries.
	 */

	cmdlen = ROUNDUP(cmdlen);
	tgtlen = ROUNDUP(tgtlen);
	hbalen = ROUNDUP(hbalen);
	statuslen = ROUNDUP(statuslen);
	pktlen = sizeof (struct dcd_pkt_wrapper) +
	    cmdlen + tgtlen +hbalen + statuslen;

	hba_pkt = kmem_zalloc(pktlen,
	    (callback = SLEEP_FUNC) ? KM_SLEEP: KM_NOSLEEP);

	if (hba_pkt == NULL) {
		ASSERT(callback == NULL_FUNC);
		return (NULL);
	}

	/*
	 * Set up or private info on this pkt
	 */
	hba_pkt->pkt_wrapper_len = pktlen;
	pkt = &hba_pkt->dcd_pkt;
	p = (caddr_t)(hba_pkt + 1);

	/*
	 * set up pointers to private data areas, cdb and status.
	 */
	if (hbalen > 0) {
		pkt->pkt_ha_private = (ataopaque_t)p;
		p += hbalen;
	}

	if (tgtlen > 0) {
		pkt->pkt_private = (ataopaque_t)p;
		p += tgtlen;
	}

	if (statuslen > 0) {
		pkt->pkt_scbp = (uchar_t *)p;
		p += statuslen;
	}

	if (cmdlen > 0) {
		pkt->pkt_cdbp = (void *)p;
	}

	/*
	 * Initialize the pkt's dcd_address
	 */
	pkt->pkt_address = *ap;
#ifdef DEBUG1
	printf("da_target %x, da_lun %x, a_hba_tran %x\n",
	    pkt->pkt_address.da_target, pkt->pkt_address.da_lun,
	    pkt->pkt_address.a_hba_tran);
	printf("From address : da_target %x, da_lun %x, a_hba_tran %x\n",
	    ap->da_target, ap->da_lun, ap->a_hba_tran);
	printf("Pkt %x\n", pkt);

#endif
	return (pkt);
}


/* ARGSUSED */
void
dcd_hba_pkt_free(
	struct dcd_address *ap,
	struct dcd_pkt	   *pkt)
{

	kmem_free((struct dcd_pkt_wrapper *)pkt,
	    ((struct dcd_pkt_wrapper *)pkt)->pkt_wrapper_len);
}


/*
 * Called by an HBA to map strings to capability indices
 */

int
dcd_hba_lookup_capstr(char		*capstr)
{

	/*
	 * Capability strings, masking the '-' vs '_'.
	 */
	static struct cap_strings {
		char *cap_string;
		int   cap_index;
	} cap_string[] = {
		{ "dma-max",		DCD_CAP_DMA_MAX		},
		{ "dma_max",		DCD_CAP_DMA_MAX		},
		{ "ultraata",		DCD_CAP_ULTRA_ATA	},
		{ "busmaster",		DCD_CAP_BUS_MASTER	},
		{ "overlap",		DCD_CAP_OVERLAP		},
		{ "parity",		DCD_CAP_PARITY		},
		{ "sector-size",	DCD_CAP_SECTOR_SIZE	},
		{ "total-sectors",	DCD_CAP_TOTAL_SECTORS	},
		{ "geometry",		DCD_CAP_GEOMETRY	},
		{ "block-mode",		DCD_CAP_BLOCKMODE	},
		{ "block-factor",	DCD_CAP_BLOCKFACTOR	},
		{ "dma-support",		DCD_CAP_DMA_SUPPORT	},
		{ "pio-support", 	DCD_CAP_PIO_SUPPORT	},
		{ "lba-addressing",	DCD_CAP_LBA_ADDRESSING  },
		{ NULL, 0					}
	};
	struct cap_strings *cp;

	for (cp = cap_string; cp->cap_string != NULL; cp++) {
		if (strcmp(cp->cap_string, capstr) == 0) {
			return (cp->cap_index);
		}
	}

	return (-1);
}