xref: /illumos-gate/usr/src/uts/common/io/scsi/adapters/pmcs/pmcs_sata.c (revision 33f457d3)

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * SATA midlayer interface for PMC driver.
 */

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

static void
SATAcopy(pmcs_cmd_t *sp, void *kbuf, uint32_t amt)
{
	struct buf *bp = scsi_pkt2bp(CMD2PKT(sp));

	bp_mapin(scsi_pkt2bp(CMD2PKT(sp)));
	/* There is only one direction currently */
	(void) memcpy(bp->b_un.b_addr, kbuf, amt);
	CMD2PKT(sp)->pkt_resid -= amt;
	CMD2PKT(sp)->pkt_state |= STATE_XFERRED_DATA;
	bp_mapout(scsi_pkt2bp(CMD2PKT(sp)));
}

/*
 * Run a non block-io command. Some commands are interpreted
 * out of extant data. Some imply actually running a SATA command.
 *
 * Returns zero if we were able to run.
 *
 * Returns -1 only if other commands are active, either another
 * command here or regular I/O active.
 *
 * Called with PHY lock and xp statlock held.
 */
#define	SRESPSZ	132
CTASSERT(SRESPSZ == sizeof (struct scsi_inquiry));

static int
pmcs_sata_special_work(pmcs_hw_t *pwp, pmcs_xscsi_t *xp)
{
	int i;
	int saq;
	pmcs_cmd_t *sp;
	struct scsi_pkt *pkt;
	pmcs_phy_t *pptr;
	uint8_t rp[SRESPSZ];
	ata_identify_t *id;
	uint32_t amt = 0;
	uint8_t key = 0x05;	/* illegal command */
	uint8_t asc = 0;
	uint8_t ascq = 0;
	uint8_t status = STATUS_GOOD;

	if (xp->actv_cnt) {
		pmcs_prt(pwp, PMCS_PRT_DEBUG1, NULL, xp,
		    "%s: target %p actv count %u",
		    __func__, (void *)xp, xp->actv_cnt);
		return (-1);
	}
	if (xp->special_running) {
		pmcs_prt(pwp, PMCS_PRT_DEBUG, NULL, xp,
		    "%s: target %p special running already",
		    __func__, (void *)xp);
		return (-1);
	}
	xp->special_needed = 0;

	/*
	 * We're now running special.
	 */
	xp->special_running = 1;
	pptr = xp->phy;

	sp = STAILQ_FIRST(&xp->sq);
	if (sp == NULL) {
		xp->special_running = 0;
		return (0);
	}

	pkt = CMD2PKT(sp);
	pmcs_prt(pwp, PMCS_PRT_DEBUG2, pptr, xp,
	    "%s: target %p cmd %p cdb0 %x with actv_cnt %u",
	    __func__, (void *)xp, (void *)sp, pkt->pkt_cdbp[0], xp->actv_cnt);

	if (pkt->pkt_cdbp[0] == SCMD_INQUIRY ||
	    pkt->pkt_cdbp[0] == SCMD_READ_CAPACITY) {
		int retval;

		if (pmcs_acquire_scratch(pwp, B_FALSE)) {
			xp->special_running = 0;
			return (-1);
		}
		saq = 1;

		mutex_exit(&xp->statlock);
		retval = pmcs_sata_identify(pwp, pptr);
		mutex_enter(&xp->statlock);

		if (retval) {
			pmcs_release_scratch(pwp);
			xp->special_running = 0;

			pmcs_prt(pwp, PMCS_PRT_DEBUG2, pptr, xp,
			    "%s: target %p identify failed %x",
			    __func__, (void *)xp, retval);
			/*
			 * If the failure is due to not being
			 * able to get resources, return such
			 * that we'll try later. Otherwise,
			 * fail current command.
			 */
			if (retval == ENOMEM) {
				pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
				    "%s: sata identify failed (ENOMEM) for "
				    "cmd %p", __func__, (void *)sp);
				return (-1);
			}
			pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
			    STATE_SENT_CMD;
			if (retval == ETIMEDOUT) {
				pkt->pkt_reason = CMD_TIMEOUT;
				pkt->pkt_statistics |= STAT_TIMEOUT;
			} else {
				pkt->pkt_reason = CMD_TRAN_ERR;
			}
			goto out;
		}

		id = pwp->scratch;

		/*
		 * Check to see if this device is an NCQ capable device.
		 * Yes, we'll end up doing this check for every INQUIRY
		 * if indeed we *are* only a pio device, but this is so
		 * infrequent that it's not really worth an extra bitfield.
		 *
		 * Note that PIO mode here means that the PMCS firmware
		 * performs PIO- not us.
		 */
		if (xp->ncq == 0) {
			/*
			 * Reset existing stuff.
			 */
			xp->pio = 0;
			xp->qdepth = 1;
			xp->tagmap = 0;

			if (id->word76 != 0 && id->word76 != 0xffff &&
			    (LE_16(id->word76) & (1 << 8))) {
				xp->ncq = 1;
				xp->qdepth = (LE_16(id->word75) & 0x1f) + 1;
				pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, xp,
				    "%s: device %s supports NCQ %u deep",
				    __func__, xp->phy->path, xp->qdepth);
			} else {
				/*
				 * Default back to PIO.
				 *
				 * Note that non-FPDMA would still be possible,
				 * but for this specific configuration, if it's
				 * not NCQ it's safest to assume PIO.
				 */
				xp->pio = 1;
				pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, xp,
				    "%s: device %s assumed PIO",
				    __func__, xp->phy->path);
			}
		}
	} else {
		saq = 0;
		id = NULL;
	}

	bzero(rp, SRESPSZ);

	switch (pkt->pkt_cdbp[0]) {
	case SCMD_INQUIRY:
	{
		struct scsi_inquiry *inqp;
		uint16_t *a, *b;

		/* Check for illegal bits */
		if ((pkt->pkt_cdbp[1] & 0xfc) || pkt->pkt_cdbp[5]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}
		if (pkt->pkt_cdbp[1] & 0x1) {
			switch (pkt->pkt_cdbp[2]) {
			case 0x0:
				rp[3] = 3;
				rp[5] = 0x80;
				rp[6] = 0x83;
				amt = 7;
				break;
			case 0x80:
				rp[1] = 0x80;
				rp[3] = 0x14;
				a = (void *) &rp[4];
				b = id->model_number;
				for (i = 0; i < 5; i++) {
					*a = ddi_swap16(*b);
					a++;
					b++;
				}
				amt = 24;
				break;
			case 0x83:
				rp[1] = 0x83;
				if ((LE_16(id->word87) & 0x100) &&
				    (LE_16(id->word108) >> 12) == 5)  {
					rp[3] = 12;
					rp[4] = 1;
					rp[5] = 3;
					rp[7] = 8;
					rp[8] = LE_16(id->word108) >> 8;
					rp[9] = LE_16(id->word108);
					rp[10] = LE_16(id->word109) >> 8;
					rp[11] = LE_16(id->word109);
					rp[12] = LE_16(id->word110) >> 8;
					rp[13] = LE_16(id->word110);
					rp[14] = LE_16(id->word111) >> 8;
					rp[15] = LE_16(id->word111);
					amt = 16;
				} else {
					rp[3] = 64;
					rp[4] = 2;
					rp[5] = 1;
					rp[7] = 60;
					rp[8] = 'A';
					rp[9] = 'T';
					rp[10] = 'A';
					rp[11] = ' ';
					rp[12] = ' ';
					rp[13] = ' ';
					rp[14] = ' ';
					rp[15] = ' ';
					a = (void *) &rp[16];
					b = id->model_number;
					for (i = 0; i < 20; i++) {
						*a = ddi_swap16(*b);
						a++;
						b++;
					}
					a = (void *) &rp[40];
					b = id->serial_number;
					for (i = 0; i < 10; i++) {
						*a = ddi_swap16(*b);
						a++;
						b++;
					}
					amt = 68;
				}
				break;
			default:
				status = STATUS_CHECK;
				asc = 0x24;	/* invalid field in cdb */
				break;
			}
		} else {
			inqp = (struct scsi_inquiry *)rp;
			inqp->inq_qual = 0;
			inqp->inq_ansi = 5;	/* spc3 */
			inqp->inq_rdf = 2;	/* response format 2 */
			inqp->inq_len = 32;

			if (xp->ncq && (xp->qdepth > 1)) {
				inqp->inq_cmdque = 1;
			}

			(void) memcpy(inqp->inq_vid, "ATA     ", 8);

			a = (void *)inqp->inq_pid;
			b = id->model_number;
			for (i = 0; i < 8; i++) {
				*a = ddi_swap16(*b);
				a++;
				b++;
			}
			if (id->firmware_revision[2] == 0x2020 &&
			    id->firmware_revision[3] == 0x2020) {
				inqp->inq_revision[0] =
				    ddi_swap16(id->firmware_revision[0]) >> 8;
				inqp->inq_revision[1] =
				    ddi_swap16(id->firmware_revision[0]);
				inqp->inq_revision[2] =
				    ddi_swap16(id->firmware_revision[1]) >> 8;
				inqp->inq_revision[3] =
				    ddi_swap16(id->firmware_revision[1]);
			} else {
				inqp->inq_revision[0] =
				    ddi_swap16(id->firmware_revision[2]) >> 8;
				inqp->inq_revision[1] =
				    ddi_swap16(id->firmware_revision[2]);
				inqp->inq_revision[2] =
				    ddi_swap16(id->firmware_revision[3]) >> 8;
				inqp->inq_revision[3] =
				    ddi_swap16(id->firmware_revision[3]);
			}
			amt = 36;
		}
		amt = pmcs_set_resid(pkt, amt, pkt->pkt_cdbp[4]);
		if (amt) {
			if (xp->actv_cnt) {
				xp->special_needed = 1;
				xp->special_running = 0;
				pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
				    "%s: @ line %d", __func__, __LINE__);
				if (saq) {
					pmcs_release_scratch(pwp);
				}
				return (-1);
			}
			SATAcopy(sp, rp, amt);
		}
		break;
	}
	case SCMD_READ_CAPACITY:
	{
		uint64_t last_block;
		uint32_t block_size = 512;	/* XXXX */

		xp->capacity = LBA_CAPACITY(id);
		last_block = xp->capacity - 1;
		/* Check for illegal bits */
		if ((pkt->pkt_cdbp[1] & 0xfe) || pkt->pkt_cdbp[6] ||
		    (pkt->pkt_cdbp[8] & 0xfe) || pkt->pkt_cdbp[7] ||
		    pkt->pkt_cdbp[9]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}
		for (i = 1; i < 10; i++) {
			if (pkt->pkt_cdbp[i]) {
				status = STATUS_CHECK;
				asc = 0x24;	/* invalid field in cdb */
				break;
			}
		}
		if (status != STATUS_GOOD) {
			break;
		}
		if (last_block > 0xffffffffULL) {
			last_block = 0xffffffffULL;
		}
		rp[0] = (last_block >> 24) & 0xff;
		rp[1] = (last_block >> 16) & 0xff;
		rp[2] = (last_block >>  8) & 0xff;
		rp[3] = (last_block) & 0xff;
		rp[4] = (block_size >> 24) & 0xff;
		rp[5] = (block_size >> 16) & 0xff;
		rp[6] = (block_size >>  8) & 0xff;
		rp[7] = (block_size) & 0xff;
		amt = 8;
		amt = pmcs_set_resid(pkt, amt, 8);
		if (amt) {
			if (xp->actv_cnt) {
				xp->special_needed = 1;
				xp->special_running = 0;
				pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
				    "%s: @ line %d", __func__, __LINE__);
				if (saq) {
					pmcs_release_scratch(pwp);
				}
				return (-1);
			}
			SATAcopy(sp, rp, amt);
		}
		break;
	}
	case SCMD_REPORT_LUNS: {
		int rl_len;

		/* Check for illegal bits */
		if (pkt->pkt_cdbp[1] || pkt->pkt_cdbp[3] || pkt->pkt_cdbp[4] ||
		    pkt->pkt_cdbp[5] || pkt->pkt_cdbp[10] ||
		    pkt->pkt_cdbp[11]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}

		rp[3] = 8;
		rl_len = 16;	/* list length (4) + reserved (4) + 1 LUN (8) */
		amt = rl_len;
		amt = pmcs_set_resid(pkt, amt, rl_len);

		if (amt) {
			if (xp->actv_cnt) {
				xp->special_needed = 1;
				xp->special_running = 0;
				pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
				    "%s: @ line %d", __func__, __LINE__);
				if (saq) {
					pmcs_release_scratch(pwp);
				}
				return (-1);
			}
			SATAcopy(sp, rp, rl_len);
		}
		break;
	}

	case SCMD_REQUEST_SENSE:
		/* Check for illegal bits */
		if ((pkt->pkt_cdbp[1] & 0xfe) || pkt->pkt_cdbp[2] ||
		    pkt->pkt_cdbp[3] || pkt->pkt_cdbp[5]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}
		rp[0] = 0xf0;
		amt = 18;
		amt = pmcs_set_resid(pkt, amt, pkt->pkt_cdbp[4]);
		if (amt) {
			if (xp->actv_cnt) {
				xp->special_needed = 1;
				xp->special_running = 0;
				pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
				    "%s: @ line %d", __func__, __LINE__);
				if (saq) {
					pmcs_release_scratch(pwp);
				}
				return (-1);
			}
			SATAcopy(sp, rp, 18);
		}
		break;
	case SCMD_START_STOP:
		/* Check for illegal bits */
		if ((pkt->pkt_cdbp[1] & 0xfe) || pkt->pkt_cdbp[2] ||
		    (pkt->pkt_cdbp[3] & 0xf0) || (pkt->pkt_cdbp[4] & 0x08) ||
		    pkt->pkt_cdbp[5]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}
		break;
	case SCMD_SYNCHRONIZE_CACHE:
		/* Check for illegal bits */
		if ((pkt->pkt_cdbp[1] & 0xf8) || (pkt->pkt_cdbp[6] & 0xe0) ||
		    pkt->pkt_cdbp[9]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}
		break;
	case SCMD_TEST_UNIT_READY:
		/* Check for illegal bits */
		if (pkt->pkt_cdbp[1] || pkt->pkt_cdbp[2] || pkt->pkt_cdbp[3] ||
		    pkt->pkt_cdbp[4] || pkt->pkt_cdbp[5]) {
			status = STATUS_CHECK;
			asc = 0x24;	/* invalid field in cdb */
			break;
		}
		if (xp->ca) {
			status = STATUS_CHECK;
			key = 0x6;
			asc = 0x28;
			xp->ca = 0;
		}
		break;
	default:
		asc = 0x20;	/* invalid operation command code */
		status = STATUS_CHECK;
		break;
	}
	if (status != STATUS_GOOD) {
		bzero(rp, 18);
		rp[0] = 0xf0;
		rp[2] = key;
		rp[12] = asc;
		rp[13] = ascq;
		pmcs_latch_status(pwp, sp, status, rp, 18, pptr->path);
	} else {
		pmcs_latch_status(pwp, sp, status, NULL, 0, pptr->path);
	}

out:
	STAILQ_REMOVE_HEAD(&xp->sq, cmd_next);
	pmcs_prt(pwp, PMCS_PRT_DEBUG2, pptr, xp,
	    "%s: pkt %p tgt %u done reason=%x state=%x resid=%ld status=%x",
	    __func__, (void *)pkt, xp->target_num, pkt->pkt_reason,
	    pkt->pkt_state, pkt->pkt_resid, status);

	if (saq) {
		pmcs_release_scratch(pwp);
	}

	if (xp->draining) {
		pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
		    "%s: waking up drain waiters", __func__);
		cv_signal(&pwp->drain_cv);
	}

	mutex_exit(&xp->statlock);
	mutex_enter(&pwp->cq_lock);
	STAILQ_INSERT_TAIL(&pwp->cq, sp, cmd_next);
	PMCS_CQ_RUN_LOCKED(pwp);
	mutex_exit(&pwp->cq_lock);
	mutex_enter(&xp->statlock);
	xp->special_running = 0;
	return (0);
}

/*
 * Run all special commands queued up for a SATA device.
 * We're only called if the caller knows we have work to do.
 *
 * We can't run them if things are still active for the device,
 * return saying we didn't run anything.
 *
 * When we finish, wake up anyone waiting for active commands
 * to go to zero.
 *
 * Called with PHY lock and xp statlock held.
 */
int
pmcs_run_sata_special(pmcs_hw_t *pwp, pmcs_xscsi_t *xp)
{
	while (!STAILQ_EMPTY(&xp->sq)) {
		if (pmcs_sata_special_work(pwp, xp)) {
			return (-1);
		}
	}
	return (0);
}

/*
 * Search for SATA special commands to run and run them.
 * If we succeed in running the special command(s), kick
 * the normal commands into operation again. Call completion
 * for any commands that were completed while we were here.
 *
 * Called unlocked.
 */
void
pmcs_sata_work(pmcs_hw_t *pwp)
{
	pmcs_xscsi_t *xp;
	int spinagain = 0;
	uint16_t target;

	for (target = 0; target < pwp->max_dev; target++) {
		xp = pwp->targets[target];
		if ((xp == NULL) || (xp->phy == NULL)) {
			continue;
		}
		pmcs_lock_phy(xp->phy);
		mutex_enter(&xp->statlock);
		if (STAILQ_EMPTY(&xp->sq)) {
			mutex_exit(&xp->statlock);
			pmcs_unlock_phy(xp->phy);
			continue;
		}
		if (xp->actv_cnt) {
			xp->special_needed = 1;
			pmcs_prt(pwp, PMCS_PRT_DEBUG1, NULL, xp,
			    "%s: deferring until drained", __func__);
			spinagain++;
		} else {
			if (pmcs_run_sata_special(pwp, xp)) {
				spinagain++;
			}
		}
		mutex_exit(&xp->statlock);
		pmcs_unlock_phy(xp->phy);
	}

	if (spinagain) {
		SCHEDULE_WORK(pwp, PMCS_WORK_SATA_RUN);
	} else {
		SCHEDULE_WORK(pwp, PMCS_WORK_RUN_QUEUES);
	}

	/*
	 * Run completion on any commands ready for it.
	 */
	PMCS_CQ_RUN(pwp);
}

/*
 * Called with PHY lock held and scratch acquired
 */
int
pmcs_sata_identify(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
{
	fis_t fis;
	fis[0] = (IDENTIFY_DEVICE << 16) | (1 << 15) | FIS_REG_H2DEV;
	fis[1] = 0;
	fis[2] = 0;
	fis[3] = 0;
	fis[4] = 0;
	return (pmcs_run_sata_cmd(pwp, pptr, fis, SATA_PROTOCOL_PIO,
	    PMCIN_DATADIR_2_INI, sizeof (ata_identify_t)));
}

/*
 * Called with PHY lock held and scratch held
 */
int
pmcs_run_sata_cmd(pmcs_hw_t *pwp, pmcs_phy_t *pptr, fis_t fis, uint32_t mode,
    uint32_t ddir, uint32_t dlen)
{
	struct pmcwork *pwrk;
	uint32_t *ptr, msg[PMCS_MSG_SIZE];
	uint32_t iq, htag, status;
	int i, result = 0;

	pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
	if (pwrk == NULL) {
		return (ENOMEM);
	}

	msg[0] = LE_32(PMCS_IOMB_IN_SAS(PMCS_OQ_IODONE,
	    PMCIN_SATA_HOST_IO_START));
	htag = pwrk->htag;
	pwrk->arg = msg;
	pwrk->dtype = SATA;
	msg[1] = LE_32(pwrk->htag);
	msg[2] = LE_32(pptr->device_id);
	msg[3] = LE_32(dlen);
	msg[4] = LE_32(mode | ddir);
	if (dlen) {
		if (ddir == PMCIN_DATADIR_2_DEV) {
			if (ddi_dma_sync(pwp->cip_handles, 0, 0,
			    DDI_DMA_SYNC_FORDEV) != DDI_SUCCESS) {
				pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
				    "Condition check failed at %s():%d",
				    __func__, __LINE__);
			}
		}
		msg[12] = LE_32(DWORD0(pwp->scratch_dma));
		msg[13] = LE_32(DWORD1(pwp->scratch_dma));
		msg[14] = LE_32(dlen);
		msg[15] = 0;
	} else {
		msg[12] = 0;
		msg[13] = 0;
		msg[14] = 0;
		msg[15] = 0;
	}
	for (i = 0; i < 5; i++) {
		msg[5+i] = LE_32(fis[i]);
	}
	msg[10] = 0;
	msg[11] = 0;
	GET_IO_IQ_ENTRY(pwp, ptr, pptr->device_id, iq);
	if (ptr == NULL) {
		pmcs_pwork(pwp, pwrk);
		return (ENOMEM);
	}
	COPY_MESSAGE(ptr, msg, PMCS_MSG_SIZE);
	pwrk->state = PMCS_WORK_STATE_ONCHIP;
	INC_IQ_ENTRY(pwp, iq);

	pmcs_unlock_phy(pptr);
	WAIT_FOR(pwrk, 1000, result);
	pmcs_pwork(pwp, pwrk);
	pmcs_lock_phy(pptr);

	if (result) {
		pmcs_timed_out(pwp, htag, __func__);
		if (pmcs_abort(pwp, pptr, htag, 0, 1)) {
			pptr->abort_pending = 1;
			SCHEDULE_WORK(pwp, PMCS_WORK_ABORT_HANDLE);
		}
		return (ETIMEDOUT);
	}

	status = LE_32(msg[2]);

	if (status != PMCOUT_STATUS_OK) {
		if (status == PMCOUT_STATUS_OPEN_CNX_ERROR_STP_RESOURCES_BUSY) {
			pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, pptr->target,
			    "%s: Potential affiliation active on 0x%" PRIx64,
			    __func__, pmcs_barray2wwn(pptr->sas_address));
		} else {
			pmcs_prt(pwp, PMCS_PRT_DEBUG2, pptr, pptr->target,
			    "%s: SATA I/O returned with IOMB status 0x%x",
			    __func__, status);
		}
		return (EIO);
	}

	if (LE_32(ptr[3]) != 0) {
		size_t j, amt = LE_32(ptr[3]);
		if (amt > sizeof (fis_t)) {
			amt = sizeof (fis_t);
		}
		amt >>= 2;
		for (j = 0; j < amt; j++) {
			fis[j] = LE_32(msg[4 + j]);
		}
	}
	if (dlen && ddir == PMCIN_DATADIR_2_INI) {
		if (ddi_dma_sync(pwp->cip_handles, 0, 0,
		    DDI_DMA_SYNC_FORKERNEL) != DDI_SUCCESS) {
			pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
			    "Condition check failed at %s():%d",
			    __func__, __LINE__);
		}
	}
	return (0);
}