/*

 * 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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * SCSI (SCSA) midlayer interface for PMC drier.

 */

#include <sys/scsi/adapters/pmcs/pmcs.h>

extern scsi_lun_t scsi_lun64_to_lun(scsi_lun64_t lun64);

static int pmcs_scsa_tran_tgt_init(dev_info_t *, dev_info_t *,

    scsi_hba_tran_t *, struct scsi_device *);

static void pmcs_scsa_tran_tgt_free(dev_info_t *, dev_info_t *,

    scsi_hba_tran_t *, struct scsi_device *);

static int pmcs_scsa_start(struct scsi_address *, struct scsi_pkt *);

static int pmcs_scsa_abort(struct scsi_address *, struct scsi_pkt *);

static int pmcs_scsa_reset(struct scsi_address *, int);

static int pmcs_scsi_reset_notify(struct scsi_address *, int,

    void (*)(caddr_t), caddr_t);

static int pmcs_scsa_getcap(struct scsi_address *, char *, int);

static int pmcs_scsa_setcap(struct scsi_address *, char *, int, int);

static int pmcs_scsa_setup_pkt(struct scsi_pkt *, int (*)(caddr_t), caddr_t);

static void pmcs_scsa_teardown_pkt(struct scsi_pkt *);

static int pmcs_smp_init(dev_info_t *, dev_info_t *, smp_hba_tran_t *,

    smp_device_t *);

static void pmcs_smp_free(dev_info_t *, dev_info_t *, smp_hba_tran_t *,

    smp_device_t *);

static int pmcs_smp_start(struct smp_pkt *);

static int pmcs_scsi_quiesce(dev_info_t *);

static int pmcs_scsi_unquiesce(dev_info_t *);

static int pmcs_cap(struct scsi_address *, char *, int, int, int);

static pmcs_xscsi_t *

    pmcs_addr2xp(struct scsi_address *, uint64_t *, pmcs_cmd_t *);

static int pmcs_SAS_run(pmcs_cmd_t *, pmcwork_t *);

static void pmcs_SAS_done(pmcs_hw_t *, pmcwork_t *, uint32_t *);

static int pmcs_SATA_run(pmcs_cmd_t *, pmcwork_t *);

static void pmcs_SATA_done(pmcs_hw_t *, pmcwork_t *, uint32_t *);

static uint8_t pmcs_SATA_rwparm(uint8_t *, uint32_t *, uint64_t *, uint64_t);

static void pmcs_ioerror(pmcs_hw_t *, pmcs_dtype_t pmcs_dtype,

    pmcwork_t *, uint32_t *, uint32_t);

int

pmcs_scsa_init(pmcs_hw_t *pwp, const ddi_dma_attr_t *ap)

{

	scsi_hba_tran_t *tran;

	ddi_dma_attr_t pmcs_scsa_dattr;

	int flags;

	(void) memcpy(&pmcs_scsa_dattr, ap, sizeof (ddi_dma_attr_t));

	pmcs_scsa_dattr.dma_attr_sgllen =

	    ((PMCS_SGL_NCHUNKS - 1) * (PMCS_MAX_CHUNKS - 1)) + PMCS_SGL_NCHUNKS;

	pmcs_scsa_dattr.dma_attr_flags = DDI_DMA_RELAXED_ORDERING;

	pmcs_scsa_dattr.dma_attr_flags |= DDI_DMA_FLAGERR;

	/*

	 * Allocate a transport structure

	 */

	tran = scsi_hba_tran_alloc(pwp->dip, SCSI_HBA_CANSLEEP);

	if (tran == NULL) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG, NULL, NULL,

		    "scsi_hba_tran_alloc failed");

		return (DDI_FAILURE);

	}

	tran->tran_hba_private		= pwp;

	tran->tran_tgt_init		= pmcs_scsa_tran_tgt_init;

	tran->tran_tgt_free		= pmcs_scsa_tran_tgt_free;

	tran->tran_start		= pmcs_scsa_start;

	tran->tran_abort		= pmcs_scsa_abort;

	tran->tran_reset		= pmcs_scsa_reset;

	tran->tran_reset_notify		= pmcs_scsi_reset_notify;

	tran->tran_getcap		= pmcs_scsa_getcap;

	tran->tran_setcap		= pmcs_scsa_setcap;

	tran->tran_setup_pkt		= pmcs_scsa_setup_pkt;

	tran->tran_teardown_pkt		= pmcs_scsa_teardown_pkt;

	tran->tran_quiesce		= pmcs_scsi_quiesce;

	tran->tran_unquiesce		= pmcs_scsi_unquiesce;

	tran->tran_interconnect_type	= INTERCONNECT_SAS;

	tran->tran_hba_len		= sizeof (pmcs_cmd_t);

	/*

	 * Attach this instance of the hba

	 */

	flags = SCSI_HBA_TRAN_SCB | SCSI_HBA_TRAN_CDB | SCSI_HBA_ADDR_COMPLEX |

	    SCSI_HBA_TRAN_PHCI | SCSI_HBA_HBA;

	if (scsi_hba_attach_setup(pwp->dip, &pmcs_scsa_dattr, tran, flags)) {

		scsi_hba_tran_free(tran);

		pmcs_prt(pwp, PMCS_PRT_DEBUG, NULL, NULL,

		    "scsi_hba_attach failed");

		return (DDI_FAILURE);

	}

	pwp->tran = tran;

	/*

	 * Attach the SMP part of this hba

	 */

	pwp->smp_tran = smp_hba_tran_alloc(pwp->dip);

	ASSERT(pwp->smp_tran != NULL);

	pwp->smp_tran->smp_tran_hba_private = pwp;

	pwp->smp_tran->smp_tran_init = pmcs_smp_init;

	pwp->smp_tran->smp_tran_free = pmcs_smp_free;

	pwp->smp_tran->smp_tran_start = pmcs_smp_start;

	if (smp_hba_attach_setup(pwp->dip, pwp->smp_tran) != DDI_SUCCESS) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG, NULL, NULL,

		    "smp_hba_attach failed");

		smp_hba_tran_free(pwp->smp_tran);

		pwp->smp_tran = NULL;

		scsi_hba_tran_free(tran);

		return (DDI_FAILURE);

	}

	return (DDI_SUCCESS);

}

/*

 * SCSA entry points

 */

static int

pmcs_scsa_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,

    scsi_hba_tran_t *tran, struct scsi_device *sd)

{

	pmcs_hw_t	*pwp = NULL;

	int		rval;

	char		*variant_prop = "sata";

	char		*tgt_port = NULL, *ua = NULL;

	pmcs_xscsi_t	*tgt = NULL;

	pmcs_iport_t	*iport;

	pmcs_lun_t	*lun = NULL;

	pmcs_phy_t	*phyp = NULL;

	uint64_t	lun_num;

	boolean_t	got_scratch = B_FALSE;

	/*

	 * First, make sure we're an iport and get the pointer to the HBA

	 * node's softstate

	 */

	if (scsi_hba_iport_unit_address(hba_dip) == NULL) {

		pmcs_prt(TRAN2PMC(tran), PMCS_PRT_DEBUG_CONFIG, NULL, NULL,

		    "%s: We don't enumerate devices on the HBA node", __func__);

		goto tgt_init_fail;

	}

	pwp = ITRAN2PMC(tran);

	iport = ITRAN2IPORT(tran);

	/*

	 * Get the unit-address

	 */

	ua = scsi_device_unit_address(sd);

	if (ua == NULL) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, NULL, NULL,

		    "%s: Couldn't get UA", __func__);

		pwp = NULL;

		goto tgt_init_fail;

	}

	pmcs_prt(pwp, PMCS_PRT_DEBUG3, NULL, NULL,

	    "got ua '%s'", ua);

	/*

	 * Get the target address

	 */

	rval = scsi_device_prop_lookup_string(sd, SCSI_DEVICE_PROP_PATH,

	    SCSI_ADDR_PROP_TARGET_PORT, &tgt_port);

	if (rval != DDI_PROP_SUCCESS) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, NULL, NULL,

		    "Couldn't get target UA");

		pwp = NULL;

		goto tgt_init_fail;

	}

	pmcs_prt(pwp, PMCS_PRT_DEBUG3, NULL, NULL,

	    "got tgt_port '%s'", tgt_port);

	/*

	 * Validate that this tran_tgt_init is for an active iport.

	 */

	if (iport->ua_state == UA_INACTIVE) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG, NULL, NULL,

		    "%s: Got tran_tgt_init on inactive iport for '%s'",

		    __func__, tgt_port);

		pwp = NULL;

		goto tgt_init_fail;

	}

	/*

	 * Since we're going to wait for scratch, be sure to acquire it while

	 * we're not holding any other locks

	 */

	(void) pmcs_acquire_scratch(pwp, B_TRUE);

	got_scratch = B_TRUE;

	mutex_enter(&pwp->lock);

	/*

	 * See if there's already a target softstate.  If not, allocate one.

	 */

	tgt = pmcs_get_target(iport, tgt_port, B_TRUE);

	if (tgt == NULL) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG2, NULL, NULL, "%s: "

		    "No tgt for tgt_port (%s)", __func__, tgt_port);

		goto tgt_init_fail;

	}

	phyp = tgt->phy;

	if (!IS_ROOT_PHY(phyp)) {

		pmcs_inc_phy_ref_count(phyp);

	}

	ASSERT(mutex_owned(&phyp->phy_lock));

	pmcs_prt(pwp, PMCS_PRT_DEBUG2, phyp, tgt, "@%s tgt = 0x%p, dip = 0x%p",

	    ua, (void *)tgt, (void *)tgt_dip);

	/* Now get the lun */

	lun_num = scsi_device_prop_get_int64(sd, SCSI_DEVICE_PROP_PATH,

	    SCSI_ADDR_PROP_LUN64, SCSI_LUN64_ILLEGAL);

	if (lun_num == SCSI_LUN64_ILLEGAL) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt,

		    "No LUN for tgt %p", (void *)tgt);

		goto tgt_init_fail;

	}

	pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt, "%s: @%s tgt 0x%p phy "

	    "0x%p (%s)", __func__, ua, (void *)tgt, (void *)phyp, phyp->path);

	mutex_enter(&tgt->statlock);

	tgt->dtype = phyp->dtype;

	if (tgt->dtype != SAS && tgt->dtype != SATA) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt,

		    "PHY 0x%p went away?", (void *)phyp);

		goto tgt_init_fail;

	}

	/* We don't support SATA devices at LUN > 0. */

	if ((tgt->dtype == SATA) && (lun_num > 0)) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt,

		    "%s: No support for SATA devices at LUN > 0 "

		    "(target = 0x%p)", __func__, (void *)tgt);

		goto tgt_init_fail;

	}

	/*

	 * Allocate LU soft state. We use ddi_soft_state_bystr_zalloc instead

	 * of kmem_alloc because ddi_soft_state_bystr_zalloc allows us to

	 * verify that the framework never tries to initialize two scsi_device

	 * structures with the same unit-address at the same time.

	 */

	if (ddi_soft_state_bystr_zalloc(tgt->lun_sstate, ua) != DDI_SUCCESS) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG2, phyp, tgt,

		    "Couldn't allocate LU soft state");

		goto tgt_init_fail;

	}

	lun = ddi_soft_state_bystr_get(tgt->lun_sstate, ua);

	if (lun == NULL) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG2, phyp, tgt,

		    "Couldn't get LU soft state");

		goto tgt_init_fail;

	}

	scsi_device_hba_private_set(sd, lun);

	lun->lun_num = lun_num;

	/* convert the scsi_lun64_t value to SCSI standard form */

	lun->scsi_lun = scsi_lun64_to_lun(lun_num);

	ASSERT(strlen(ua) < (PMCS_MAX_UA_SIZE - 1));

	bcopy(ua, lun->unit_address, strnlen(ua, PMCS_MAX_UA_SIZE - 1));

	lun->target = tgt;

	/*

	 * If this is the first tran_tgt_init, add this target to our list

	 */

	if (tgt->target_num == PMCS_INVALID_TARGET_NUM) {

		int target;

		for (target = 0; target < pwp->max_dev; target++) {

			if (pwp->targets[target] != NULL) {

				continue;

			}

			pwp->targets[target] = tgt;

			tgt->target_num = (uint16_t)target;

			break;

		}

		if (target == pwp->max_dev) {

			pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt,

			    "Target list full.");

			goto tgt_init_fail;

		}

	}

	tgt->dip = sd->sd_dev;

	lun->sd = sd;

	list_insert_tail(&tgt->lun_list, lun);

	if (!pmcs_assign_device(pwp, tgt)) {

		pmcs_release_scratch(pwp);

		pwp->targets[tgt->target_num] = NULL;

		tgt->target_num = PMCS_INVALID_TARGET_NUM;

		tgt->phy = NULL;

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt,

		    "%s: pmcs_assign_device failed for target 0x%p",

		    __func__, (void *)tgt);

		goto tgt_init_fail;

	}

	pmcs_release_scratch(pwp);

	tgt->ref_count++;

	(void) scsi_device_prop_update_int(sd, SCSI_DEVICE_PROP_PATH,

	    SCSI_ADDR_PROP_TARGET, (uint32_t)(tgt->target_num));

	/* SM-HBA */

	if (tgt->dtype == SATA) {

		/* TCR in PSARC/1997/281 opinion */

		(void) scsi_device_prop_update_string(sd,

		    SCSI_DEVICE_PROP_PATH, "variant", variant_prop);

	}

	tgt->phy_addressable = PMCS_PHY_ADDRESSABLE(phyp);

	if (tgt->phy_addressable) {

		(void) scsi_device_prop_update_int(sd, SCSI_DEVICE_PROP_PATH,

		    SCSI_ADDR_PROP_SATA_PHY, phyp->phynum);

	}

	/* SM-HBA */

	(void) pmcs_smhba_set_scsi_device_props(pwp, phyp, sd);

	/*

	 * Make sure attached port and target port pm props are updated

	 * By passing in 0s, we're not actually updating any values, but

	 * the properties should now get updated on the node.

	 */

	mutex_exit(&tgt->statlock);

	pmcs_update_phy_pm_props(phyp, 0, 0, B_TRUE);

	pmcs_unlock_phy(phyp);

	mutex_exit(&pwp->lock);

	scsi_device_prop_free(sd, SCSI_DEVICE_PROP_PATH, tgt_port);

	return (DDI_SUCCESS);

tgt_init_fail:

	scsi_device_hba_private_set(sd, NULL);

	if (got_scratch) {

		pmcs_release_scratch(pwp);

	}

	if (lun) {

		list_remove(&tgt->lun_list, lun);

		ddi_soft_state_bystr_free(tgt->lun_sstate, ua);

	}

	if (phyp) {

		mutex_exit(&tgt->statlock);

		pmcs_unlock_phy(phyp);

		/*

		 * phyp's ref count was incremented in pmcs_new_tport.

		 * We're failing configuration, we now need to decrement it.

		 */

		if (!IS_ROOT_PHY(phyp)) {

			pmcs_dec_phy_ref_count(phyp);

		}

		phyp->target = NULL;

	}

	if (tgt && tgt->ref_count == 0) {

		ddi_soft_state_bystr_free(iport->tgt_sstate, tgt_port);

	}

	if (pwp) {

		mutex_exit(&pwp->lock);

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, tgt,

		    "%s: failed for @%s tgt 0x%p phy 0x%p", __func__, ua,

		    (void *)tgt, (void *)phyp);

	}

	if (tgt_port) {

		scsi_device_prop_free(sd, SCSI_DEVICE_PROP_PATH, tgt_port);

	}

	return (DDI_FAILURE);

}

static void

pmcs_scsa_tran_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,

    scsi_hba_tran_t *tran, struct scsi_device *sd)

{

	_NOTE(ARGUNUSED(hba_dip, tgt_dip));

	pmcs_hw_t	*pwp;

	pmcs_lun_t	*lun;

	pmcs_xscsi_t	*target;

	char		*unit_address;

	pmcs_phy_t	*phyp;

	if (scsi_hba_iport_unit_address(hba_dip) == NULL) {

		pwp = TRAN2PMC(tran);

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, NULL, NULL,

		    "%s: We don't enumerate devices on the HBA node", __func__);

		return;

	}

	lun = (pmcs_lun_t *)scsi_device_hba_private_get(sd);

	ASSERT((lun != NULL) && (lun->target != NULL));

	ASSERT(lun->target->ref_count > 0);

	target = lun->target;

	unit_address = lun->unit_address;

	list_remove(&target->lun_list, lun);

	pwp = ITRAN2PMC(tran);

	mutex_enter(&pwp->lock);

	phyp = target->phy;

	if (phyp) {

		mutex_enter(&phyp->phy_lock);

	}

	mutex_enter(&target->statlock);

	pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, target,

	    "%s: for @%s tgt 0x%p phy 0x%p", __func__, unit_address,

	    (void *)target, (void *)phyp);

	ddi_soft_state_bystr_free(lun->target->lun_sstate, unit_address);

	if (target->recover_wait) {

		mutex_exit(&target->statlock);

		if (phyp) {

			mutex_exit(&phyp->phy_lock);

		}

		mutex_exit(&pwp->lock);

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, target, "%s: "

		    "Target 0x%p in device state recovery, fail tran_tgt_free",

		    __func__, (void *)target);

		return;

	}

	/*

	 * If this target still has a PHY pointer and that PHY's target pointer

	 * has been cleared, then that PHY has been reaped. In that case, there

	 * would be no need to decrement the reference count

	 */

	if (phyp && !IS_ROOT_PHY(phyp) && phyp->target) {

		pmcs_dec_phy_ref_count(phyp);

	}

	if (--target->ref_count == 0) {

		/*

		 * Remove this target from our list.  The target soft

		 * state will remain, and the device will remain registered

		 * with the hardware unless/until we're told the device

		 * physically went away.

		 */

		pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, phyp, target,

		    "%s: Free target 0x%p (vtgt %d)", __func__, (void *)target,

		    target->target_num);

		pwp->targets[target->target_num] = NULL;

		target->target_num = PMCS_INVALID_TARGET_NUM;

		/* If the PHY has a pointer to this target, clear it */

		if (phyp && (phyp->target == target)) {

			phyp->target = NULL;

		}

		target->phy = NULL;

		if (phyp) {

			mutex_exit(&phyp->phy_lock);

		}

		pmcs_destroy_target(target);

	} else {

		mutex_exit(&target->statlock);

		if (phyp) {

			mutex_exit(&phyp->phy_lock);

		}

	}

	mutex_exit(&pwp->lock);

}

static int

pmcs_scsa_start(struct scsi_address *ap, struct scsi_pkt *pkt)

{

	pmcs_cmd_t *sp = PKT2CMD(pkt);

	pmcs_hw_t *pwp = ADDR2PMC(ap);

	pmcs_xscsi_t *xp;

	boolean_t blocked;

	uint32_t hba_state;

	pmcs_prt(pwp, PMCS_PRT_DEBUG2, NULL, NULL,

	    "%s: pkt %p sd %p cdb0=0x%02x dl=%lu", __func__, (void *)pkt,

	    (void *)scsi_address_device(&pkt->pkt_address),

	    pkt->pkt_cdbp[0] & 0xff, pkt->pkt_dma_len);

	if (pkt->pkt_flags & FLAG_NOINTR) {

		pmcs_prt(pwp, PMCS_PRT_DEBUG3, NULL, NULL,