/* * 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. * Copyright (c) 2011 Bayard G. Bell. All rights reserved. */ #include #include "ata_common.h" #include "atapi.h" /* SCSA entry points */ static int atapi_tran_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, scsi_hba_tran_t *hba_tran, struct scsi_device *sd); static int atapi_tran_tgt_probe(struct scsi_device *sd, int (*callback)(void)); static void atapi_tran_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, scsi_hba_tran_t *hba_tran, struct scsi_device *sd); static int atapi_tran_abort(struct scsi_address *ap, struct scsi_pkt *spktp); static int atapi_tran_reset(struct scsi_address *ap, int level); static int atapi_tran_getcap(struct scsi_address *ap, char *capstr, int whom); static int atapi_tran_setcap(struct scsi_address *ap, char *capstr, int value, int whom); static struct scsi_pkt *atapi_tran_init_pkt(struct scsi_address *ap, struct scsi_pkt *spktp, struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, int (*callback)(caddr_t), caddr_t arg); static void atapi_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *spktp); static void atapi_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *spktp); static void atapi_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *spktp); static int atapi_tran_start(struct scsi_address *ap, struct scsi_pkt *spktp); /* * packet callbacks */ static void atapi_complete(ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp, int do_callback); static int atapi_id_update(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp); /* * Local static data */ #if 0 static ddi_dma_lim_t atapi_dma_limits = { 0, /* address low */ 0xffffffffU, /* address high */ 0, /* counter max */ 1, /* burstsize */ DMA_UNIT_8, /* minimum xfer */ 0, /* dma speed */ (uint_t)DMALIM_VER0, /* version */ 0xffffffffU, /* address register */ 0xffffffffU, /* counter register */ 1, /* granular */ 1, /* scatter/gather list length */ 0xffffffffU /* request size */ }; #endif static int atapi_use_static_geometry = TRUE; static int atapi_arq_enable = TRUE; /* * * Call SCSA init to initialize the ATAPI half of the driver * */ int atapi_attach(ata_ctl_t *ata_ctlp) { dev_info_t *dip = ata_ctlp->ac_dip; scsi_hba_tran_t *tran; ADBG_TRACE(("atapi_init entered\n")); /* allocate transport structure */ tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); if (tran == NULL) { ADBG_WARN(("atapi_init: scsi_hba_tran_alloc failed\n")); goto errout; } ata_ctlp->ac_atapi_tran = tran; ata_ctlp->ac_flags |= AC_SCSI_HBA_TRAN_ALLOC; /* initialize transport structure */ tran->tran_hba_private = ata_ctlp; tran->tran_tgt_private = NULL; tran->tran_tgt_init = atapi_tran_tgt_init; tran->tran_tgt_probe = atapi_tran_tgt_probe; tran->tran_tgt_free = atapi_tran_tgt_free; tran->tran_start = atapi_tran_start; tran->tran_reset = atapi_tran_reset; tran->tran_abort = atapi_tran_abort; tran->tran_getcap = atapi_tran_getcap; tran->tran_setcap = atapi_tran_setcap; tran->tran_init_pkt = atapi_tran_init_pkt; tran->tran_destroy_pkt = atapi_tran_destroy_pkt; tran->tran_dmafree = atapi_tran_dmafree; tran->tran_sync_pkt = atapi_tran_sync_pkt; if (scsi_hba_attach_setup(ata_ctlp->ac_dip, &ata_pciide_dma_attr, tran, SCSI_HBA_TRAN_CLONE) != DDI_SUCCESS) { ADBG_WARN(("atapi_init: scsi_hba_attach_setup failed\n")); goto errout; } ata_ctlp->ac_flags |= AC_SCSI_HBA_ATTACH; return (TRUE); errout: atapi_detach(ata_ctlp); return (FALSE); } /* * * destroy the atapi sub-system * */ void atapi_detach( ata_ctl_t *ata_ctlp) { ADBG_TRACE(("atapi_detach entered\n")); if (ata_ctlp->ac_flags & AC_SCSI_HBA_ATTACH) (void) scsi_hba_detach(ata_ctlp->ac_dip); if (ata_ctlp->ac_flags & AC_SCSI_HBA_TRAN_ALLOC) scsi_hba_tran_free(ata_ctlp->ac_atapi_tran); } /* * * initialize the ATAPI drive's soft-state based on the * response to IDENTIFY PACKET DEVICE command * */ int atapi_init_drive( ata_drv_t *ata_drvp) { ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; ADBG_TRACE(("atapi_init_drive entered\n")); /* Determine ATAPI CDB size */ (void) atapi_id_update(ata_ctlp, ata_drvp, NULL); switch (ata_drvp->ad_id.ai_config & ATAPI_ID_CFG_PKT_SZ) { case ATAPI_ID_CFG_PKT_12B: ata_drvp->ad_cdb_len = 12; break; case ATAPI_ID_CFG_PKT_16B: ata_drvp->ad_cdb_len = 16; break; default: ADBG_WARN(("atapi_init_drive: bad pkt size support\n")); return (FALSE); } /* determine if drive gives an intr when it wants the CDB */ if ((ata_drvp->ad_id.ai_config & ATAPI_ID_CFG_DRQ_TYPE) != ATAPI_ID_CFG_DRQ_INTR) ata_drvp->ad_flags |= AD_NO_CDB_INTR; /* * Some devices may have no DMA mode enabled (UDMA or MWDMA) * by default, so here we need check and enable DMA if none * mode is selected. */ if (ata_set_dma_mode(ata_ctlp, ata_drvp) == TRUE) { /* Update the IDENTIFY PACKET DEVICE data */ (void) atapi_id_update(ata_ctlp, ata_drvp, NULL); } return (TRUE); } /* * * destroy an atapi drive * */ /* ARGSUSED */ void atapi_uninit_drive( ata_drv_t *ata_drvp) { ADBG_TRACE(("atapi_uninit_drive entered\n")); } /* * * Issue an IDENTIFY PACKET (ATAPI) DEVICE command * */ int atapi_id( ddi_acc_handle_t io_hdl1, caddr_t ioaddr1, ddi_acc_handle_t io_hdl2, caddr_t ioaddr2, struct ata_id *ata_idp) { int rc; ADBG_TRACE(("atapi_id entered\n")); rc = ata_id_common(ATC_ID_PACKET_DEVICE, FALSE, io_hdl1, ioaddr1, io_hdl2, ioaddr2, ata_idp); if (!rc) return (FALSE); if ((ata_idp->ai_config & ATAC_ATAPI_TYPE_MASK) != ATAC_ATAPI_TYPE) return (FALSE); return (TRUE); } /* * * Check the device's register block for the ATAPI signature. * * Although the spec says the sector count, sector number and device/head * registers are also part of the signature, for some unknown reason, this * routine only checks the cyl hi and cyl low registers. I'm just * guessing, but it might be because ATA and ATAPI devices return * identical values in those registers and we actually rely on the * IDENTIFY DEVICE and IDENTIFY PACKET DEVICE commands to recognize the * device type. * */ int atapi_signature( ddi_acc_handle_t io_hdl, caddr_t ioaddr) { int rc = FALSE; ADBG_TRACE(("atapi_signature entered\n")); if (ddi_get8(io_hdl, (uchar_t *)ioaddr + AT_HCYL) == ATAPI_SIG_HI && ddi_get8(io_hdl, (uchar_t *)ioaddr + AT_LCYL) != ATAPI_SIG_LO) rc = TRUE; /* * The following is a little bit of bullet proofing. * * When some drives are configured on a master-only bus they * "shadow" their registers for the not-present slave drive. * This is bogus and if you're not careful it may cause a * master-only drive to be mistakenly recognized as both * master and slave. By clearing the signature registers here * I can make certain that when ata_drive_type() switches from * the master to slave drive that I'll read back non-signature * values regardless of whether the master-only drive does * the "shadow" register trick. This prevents a bogus * IDENTIFY PACKET DEVICE command from being issued which * a really bogus master-only drive will return "shadow" * data for. */ ddi_put8(io_hdl, (uchar_t *)ioaddr + AT_HCYL, 0); ddi_put8(io_hdl, (uchar_t *)ioaddr + AT_LCYL, 0); return (rc); } /* * * SCSA tran_tgt_init entry point * */ /* ARGSUSED */ static int atapi_tran_tgt_init( dev_info_t *hba_dip, dev_info_t *tgt_dip, scsi_hba_tran_t *hba_tran, struct scsi_device *sd) { gtgt_t *gtgtp; /* GHD's per-target-instance structure */ ata_ctl_t *ata_ctlp; ata_tgt_t *ata_tgtp; ata_drv_t *ata_drvp; struct scsi_address *ap; int rc = DDI_SUCCESS; ADBG_TRACE(("atapi_tran_tgt_init entered\n")); /* * Qualification of targ, lun, and ATAPI device presence * have already been taken care of by ata_bus_ctl */ /* store pointer to drive struct in cloned tran struct */ ata_ctlp = TRAN2CTL(hba_tran); ap = &sd->sd_address; ata_drvp = CTL2DRV(ata_ctlp, ap->a_target, ap->a_lun); /* * Create the "atapi" property so the target driver knows * to use the correct set of SCSI commands */ if (!ata_prop_create(tgt_dip, ata_drvp, "atapi")) { return (DDI_FAILURE); } gtgtp = ghd_target_init(hba_dip, tgt_dip, &ata_ctlp->ac_ccc, sizeof (ata_tgt_t), ata_ctlp, ap->a_target, ap->a_lun); /* tran_tgt_private points to gtgt_t */ hba_tran->tran_tgt_private = gtgtp; /* gt_tgt_private points to ata_tgt_t */ ata_tgtp = GTGTP2ATATGTP(gtgtp); /* initialize the per-target-instance data */ ata_tgtp->at_drvp = ata_drvp; ata_tgtp->at_dma_attr = ata_pciide_dma_attr; ata_tgtp->at_dma_attr.dma_attr_maxxfer = ata_ctlp->ac_max_transfer << SCTRSHFT; return (rc); } /* * * SCSA tran_tgt_probe entry point * */ static int atapi_tran_tgt_probe(struct scsi_device *sd, int (*callback)(void)) { ADBG_TRACE(("atapi_tran_tgt_probe entered\n")); return (scsi_hba_probe(sd, callback)); } /* * * SCSA tran_tgt_free entry point * */ /* ARGSUSED */ static void atapi_tran_tgt_free( dev_info_t *hba_dip, dev_info_t *tgt_dip, scsi_hba_tran_t *hba_tran, struct scsi_device *sd) { ADBG_TRACE(("atapi_tran_tgt_free entered\n")); ghd_target_free(hba_dip, tgt_dip, &TRAN2ATAP(hba_tran)->ac_ccc, TRAN2GTGTP(hba_tran)); hba_tran->tran_tgt_private = NULL; } /* * * SCSA tran_abort entry point * */ /* ARGSUSED */ static int atapi_tran_abort( struct scsi_address *ap, struct scsi_pkt *spktp) { ADBG_TRACE(("atapi_tran_abort entered\n")); if (spktp) { return (ghd_tran_abort(&ADDR2CTL(ap)->ac_ccc, PKTP2GCMDP(spktp), ADDR2GTGTP(ap), NULL)); } return (ghd_tran_abort_lun(&ADDR2CTL(ap)->ac_ccc, ADDR2GTGTP(ap), NULL)); } /* * * SCSA tran_reset entry point * */ /* ARGSUSED */ static int atapi_tran_reset( struct scsi_address *ap, int level) { ADBG_TRACE(("atapi_tran_reset entered\n")); if (level == RESET_TARGET) return (ghd_tran_reset_target(&ADDR2CTL(ap)->ac_ccc, ADDR2GTGTP(ap), NULL)); if (level == RESET_ALL) return (ghd_tran_reset_bus(&ADDR2CTL(ap)->ac_ccc, ADDR2GTGTP(ap), NULL)); return (FALSE); } /* * * SCSA tran_setcap entry point * */ static int atapi_tran_setcap( struct scsi_address *ap, char *capstr, int value, int whom) { gtgt_t *gtgtp = ADDR2GTGTP(ap); ata_tgt_t *tgtp = GTGTP2ATATGTP(gtgtp); ADBG_TRACE(("atapi_tran_setcap entered\n")); switch (scsi_hba_lookup_capstr(capstr)) { case SCSI_CAP_SECTOR_SIZE: tgtp->at_dma_attr.dma_attr_granular = (uint_t)value; return (TRUE); case SCSI_CAP_ARQ: if (whom) { tgtp->at_arq = value; return (TRUE); } break; case SCSI_CAP_TOTAL_SECTORS: tgtp->at_total_sectors = value; return (TRUE); } return (FALSE); } /* * * SCSA tran_getcap entry point * */ static int atapi_tran_getcap( struct scsi_address *ap, char *capstr, int whom) { struct ata_id ata_id; struct ata_id *ata_idp; ata_ctl_t *ata_ctlp; ata_drv_t *ata_drvp; gtgt_t *gtgtp; int rval = -1; ADBG_TRACE(("atapi_tran_getcap entered\n")); if (capstr == NULL || whom == 0) return (-1); ata_ctlp = ADDR2CTL(ap); switch (scsi_hba_lookup_capstr(capstr)) { case SCSI_CAP_ARQ: rval = TRUE; break; case SCSI_CAP_INITIATOR_ID: rval = 7; break; case SCSI_CAP_DMA_MAX: /* XXX - what should the real limit be?? */ /* limit to 64K ??? */ rval = 4096 * (ATA_DMA_NSEGS - 1); break; case SCSI_CAP_GEOMETRY: /* Default geometry */ if (atapi_use_static_geometry) { rval = ATAPI_HEADS << 16 | ATAPI_SECTORS_PER_TRK; break; } /* this code is currently not used */ ata_drvp = CTL2DRV(ata_ctlp, ap->a_target, ap->a_lun); gtgtp = ADDR2GTGTP(ap); /* * retrieve the current IDENTIFY PACKET DEVICE info */ if (!ata_queue_cmd(atapi_id_update, &ata_id, ata_ctlp, ata_drvp, gtgtp)) { ADBG_TRACE(("atapi_tran_getcap geometry failed")); return (0); } /* * save the new response data */ ata_idp = &ata_drvp->ad_id; *ata_idp = ata_id; switch ((ata_idp->ai_config >> 8) & 0xf) { case DTYPE_RODIRECT: rval = ATAPI_HEADS << 16 | ATAPI_SECTORS_PER_TRK; break; case DTYPE_DIRECT: case DTYPE_OPTICAL: rval = (ata_idp->ai_curheads << 16) | ata_idp->ai_cursectrk; break; default: rval = 0; } break; } return (rval); } /* * * SCSA tran_init_pkt entry point * */ static struct scsi_pkt * atapi_tran_init_pkt( struct scsi_address *ap, struct scsi_pkt *spktp, struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, int (*callback)(caddr_t), caddr_t arg) { gtgt_t *gtgtp = ADDR2GTGTP(ap); ata_tgt_t *ata_tgtp = GTGTP2ATATGTP(gtgtp); ata_ctl_t *ata_ctlp = ADDR2CTL(ap); ata_pkt_t *ata_pktp; struct scsi_pkt *new_spktp; ddi_dma_attr_t *sg_attrp; int bytes; ADBG_TRACE(("atapi_tran_init_pkt entered\n")); /* * Determine whether to do PCI-IDE DMA setup, start out by * assuming we're not. */ sg_attrp = NULL; if (bp == NULL) { /* no data to transfer */ goto skip_dma_setup; } if (bp->b_bcount == 0) { /* no data to transfer */ goto skip_dma_setup; } if ((GTGTP2ATADRVP(ADDR2GTGTP(ap))->ad_pciide_dma == ATA_DMA_OFF)) { goto skip_dma_setup; } if (ata_dma_disabled) goto skip_dma_setup; /* * The PCI-IDE DMA engine is brain-damaged and can't * DMA non-aligned buffers. */ if (((bp->b_flags & B_PAGEIO) == 0) && ((uintptr_t)bp->b_un.b_addr) & PCIIDE_PRDE_ADDR_MASK) { /* * if the virtual address isn't aligned, then the * physical address also isn't aligned. */ goto skip_dma_setup; } /* * It also insists that the byte count must be even. */ if (bp->b_bcount & 1) { /* something odd here */ goto skip_dma_setup; } /* * Huzza! We're really going to do it */ sg_attrp = &ata_tgtp->at_dma_attr; skip_dma_setup: /* * Call GHD packet init function */ new_spktp = ghd_tran_init_pkt_attr(&ata_ctlp->ac_ccc, ap, spktp, bp, cmdlen, statuslen, tgtlen, flags, callback, arg, sizeof (ata_pkt_t), sg_attrp); if (new_spktp == NULL) return (NULL); ata_pktp = SPKT2APKT(new_spktp); ata_pktp->ap_cdbp = new_spktp->pkt_cdbp; if (statuslen > 255) { statuslen = sizeof (struct scsi_arq_status); } ata_pktp->ap_statuslen = (uchar_t)statuslen; /* reset data direction flags */ if (spktp) ata_pktp->ap_flags &= ~(AP_READ | AP_WRITE); /* * check for ARQ mode */ if (atapi_arq_enable == TRUE && ata_tgtp->at_arq == TRUE && ata_pktp->ap_statuslen >= sizeof (struct scsi_arq_status)) { ADBG_TRACE(("atapi_tran_init_pkt ARQ\n")); ata_pktp->ap_scbp = (struct scsi_arq_status *)new_spktp->pkt_scbp; ata_pktp->ap_flags |= AP_ARQ_ON_ERROR; } /* * fill these with zeros for ATA/ATAPI-4 compatibility */ ata_pktp->ap_sec = 0; ata_pktp->ap_count = 0; if (ata_pktp->ap_sg_cnt) { ASSERT(bp != NULL); /* determine direction to program the DMA engine later */ if (bp->b_flags & B_READ) { ata_pktp->ap_flags |= AP_READ; } else { ata_pktp->ap_flags |= AP_WRITE; } ata_pktp->ap_pciide_dma = TRUE; ata_pktp->ap_hicyl = 0; ata_pktp->ap_lwcyl = 0; return (new_spktp); } /* * Since we're not using DMA, we need to map the buffer into * kernel address space */ ata_pktp->ap_pciide_dma = FALSE; if (bp && bp->b_bcount) { /* * If this is a fresh request map the buffer and * reset the ap_baddr pointer and the current offset * and byte count. * * The ap_boffset is used to set the ap_v_addr ptr at * the start of each I/O request. * * The ap_bcount is used to update ap_boffset when the * target driver requests the next segment. * */ if (cmdlen) { bp_mapin(bp); ata_pktp->ap_baddr = bp->b_un.b_addr; ata_pktp->ap_bcount = 0; ata_pktp->ap_boffset = 0; } ASSERT(ata_pktp->ap_baddr != NULL); /* determine direction for the PIO FSM */ if (bp->b_flags & B_READ) { ata_pktp->ap_flags |= AP_READ; } else { ata_pktp->ap_flags |= AP_WRITE; } /* * If the drive has the Single Sector bug, limit * the transfer to a single sector. This assumes * ATAPI CD drives always use 2k sectors. */ if (GTGTP2ATADRVP(ADDR2GTGTP(ap))->ad_flags & AD_1SECTOR) { size_t resid; size_t tmp; /* adjust offset based on prior request */ ata_pktp->ap_boffset += ata_pktp->ap_bcount; /* compute number of bytes left to transfer */ resid = bp->b_bcount - ata_pktp->ap_boffset; /* limit the transfer to 2k */ tmp = MIN(2048, resid); ata_pktp->ap_bcount = tmp; /* tell target driver how much is left for next time */ new_spktp->pkt_resid = resid - tmp; } else { /* do the whole request in one swell foop */ ata_pktp->ap_bcount = bp->b_bcount; new_spktp->pkt_resid = 0; } } else { ata_pktp->ap_baddr = NULL; ata_pktp->ap_bcount = 0; ata_pktp->ap_boffset = 0; } /* * determine the size of each partial data transfer * to/from the drive */ bytes = min(ata_pktp->ap_bcount, ATAPI_MAX_BYTES_PER_DRQ); ata_pktp->ap_hicyl = (uchar_t)(bytes >> 8); ata_pktp->ap_lwcyl = (uchar_t)bytes; return (new_spktp); } /* * GHD ccballoc callback * * Initializing the ata_pkt, and return the ptr to the gcmd_t to GHD. * */ /* ARGSUSED */ int atapi_ccballoc( gtgt_t *gtgtp, gcmd_t *gcmdp, int cmdlen, int statuslen, int tgtlen, int ccblen) { ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp); ata_pkt_t *ata_pktp = GCMD2APKT(gcmdp); ADBG_TRACE(("atapi_ccballoc entered\n")); /* set the back ptr from the ata_pkt to the gcmd_t */ ata_pktp->ap_gcmdp = gcmdp; /* check length of SCSI CDB is not larger than drive expects */ if (cmdlen > ata_drvp->ad_cdb_len) { ADBG_WARN(("atapi_ccballoc: SCSI CDB too large!\n")); return (FALSE); } /* * save length of the SCSI CDB, and calculate CDB padding * note that for convenience, padding is expressed in shorts. */ ata_pktp->ap_cdb_len = (uchar_t)cmdlen; ata_pktp->ap_cdb_pad = ((unsigned)(ata_drvp->ad_cdb_len - cmdlen)) >> 1; /* set up callback functions */ ata_pktp->ap_start = atapi_fsm_start; ata_pktp->ap_intr = atapi_fsm_intr; ata_pktp->ap_complete = atapi_complete; /* set-up for start */ ata_pktp->ap_flags = AP_ATAPI; ata_pktp->ap_hd = ata_drvp->ad_drive_bits; ata_pktp->ap_cmd = ATC_PACKET; return (TRUE); } /* * * SCSA tran_destroy_pkt entry point * */ static void atapi_tran_destroy_pkt( struct scsi_address *ap, struct scsi_pkt *spktp) { gcmd_t *gcmdp = PKTP2GCMDP(spktp); ADBG_TRACE(("atapi_tran_destroy_pkt entered\n")); if (gcmdp->cmd_dma_handle != NULL) { ghd_dmafree_attr(gcmdp); } ghd_pktfree(&ADDR2CTL(ap)->ac_ccc, ap, spktp); } /* * * GHD ccbfree callback function * */ /* ARGSUSED */ void atapi_ccbfree( gcmd_t *gcmdp) { ADBG_TRACE(("atapi_ccbfree entered\n")); /* nothing to do */ } /* * * SCSA tran_dmafree entry point * */ /*ARGSUSED*/ static void atapi_tran_dmafree( struct scsi_address *ap, struct scsi_pkt *spktp) { gcmd_t *gcmdp = PKTP2GCMDP(spktp); ADBG_TRACE(("atapi_tran_dmafree entered\n")); if (gcmdp->cmd_dma_handle != NULL) { ghd_dmafree_attr(gcmdp); } } /* * * SCSA tran_sync_pkt entry point * */ /*ARGSUSED*/ static void atapi_tran_sync_pkt( struct scsi_address *ap, struct scsi_pkt *spktp) { ADBG_TRACE(("atapi_tran_sync_pkt entered\n")); if (PKTP2GCMDP(spktp)->cmd_dma_handle != NULL) { ghd_tran_sync_pkt(ap, spktp); } } /* * * SCSA tran_start entry point * */ /* ARGSUSED */ static int atapi_tran_start( struct scsi_address *ap, struct scsi_pkt *spktp) { ata_pkt_t *ata_pktp = SPKT2APKT(spktp); ata_drv_t *ata_drvp = APKT2DRV(ata_pktp); ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; gcmd_t *gcmdp = APKT2GCMD(ata_pktp); int polled = FALSE; int rc; ADBG_TRACE(("atapi_tran_start entered\n")); /* * Basic initialization performed each and every time a * scsi_pkt is submitted. A single scsi_pkt may be submitted * multiple times so this routine has to be idempotent. One * time initializations don't belong here. */ /* * The ap_v_addr pointer is incremented by the PIO data * transfer routine as each word is transferred. Therefore, need * to reset ap_v_addr here (rather than atapi_tran_init_pkt()) * in case the target resubmits the same pkt multiple times * (which is permitted by SCSA). */ ata_pktp->ap_v_addr = ata_pktp->ap_baddr + ata_pktp->ap_boffset; /* ap_resid is decremented as the data transfer progresses */ ata_pktp->ap_resid = ata_pktp->ap_bcount; /* clear error flags */ ata_pktp->ap_flags &= (AP_ATAPI | AP_READ | AP_WRITE | AP_ARQ_ON_ERROR); spktp->pkt_reason = 0; spktp->pkt_state = 0; spktp->pkt_statistics = 0; /* * check for polling pkt */ if (spktp->pkt_flags & FLAG_NOINTR) { polled = TRUE; } #ifdef ___just_ignore_unsupported_flags___ /* driver cannot accept tagged commands */ if (spktp->pkt_flags & (FLAG_HTAG|FLAG_OTAG|FLAG_STAG)) { spktp->pkt_reason = CMD_TRAN_ERR; return (TRAN_BADPKT); } #endif /* call common transport routine */ rc = ghd_transport(&ata_ctlp->ac_ccc, gcmdp, gcmdp->cmd_gtgtp, spktp->pkt_time, polled, NULL); /* see if pkt was not accepted */ if (rc != TRAN_ACCEPT) return (rc); return (rc); } /* * * GHD packet complete callback * */ /* ARGSUSED */ static void atapi_complete( ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp, int do_callback) { struct scsi_pkt *spktp = APKT2SPKT(ata_pktp); struct scsi_status *scsi_stat = (struct scsi_status *)spktp->pkt_scbp; ADBG_TRACE(("atapi_complete entered\n")); ADBG_TRANSPORT(("atapi_complete: pkt = 0x%p\n", ata_pktp)); /* update resid */ spktp->pkt_resid = ata_pktp->ap_resid; if (ata_pktp->ap_flags & AP_SENT_CMD) { spktp->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD; } if (ata_pktp->ap_flags & AP_XFERRED_DATA) { spktp->pkt_state |= STATE_XFERRED_DATA; } if (ata_pktp->ap_flags & AP_GOT_STATUS) { spktp->pkt_state |= STATE_GOT_STATUS; } /* check for fatal errors */ if (ata_pktp->ap_flags & AP_TRAN_ERROR) { spktp->pkt_reason = CMD_TRAN_ERR; } else if (ata_pktp->ap_flags & AP_BUS_RESET) { spktp->pkt_reason = CMD_RESET; spktp->pkt_statistics |= STAT_BUS_RESET; } else if (ata_pktp->ap_flags & AP_DEV_RESET) { spktp->pkt_reason = CMD_RESET; spktp->pkt_statistics |= STAT_DEV_RESET; } else if (ata_pktp->ap_flags & AP_ABORT) { spktp->pkt_reason = CMD_ABORTED; spktp->pkt_statistics |= STAT_ABORTED; } else if (ata_pktp->ap_flags & AP_TIMEOUT) { spktp->pkt_reason = CMD_TIMEOUT; spktp->pkt_statistics |= STAT_TIMEOUT; } else { spktp->pkt_reason = CMD_CMPLT; } /* non-fatal errors */ if (ata_pktp->ap_flags & AP_ERROR) scsi_stat->sts_chk = 1; else scsi_stat->sts_chk = 0; if (ata_pktp->ap_flags & AP_ARQ_ERROR) { ADBG_ARQ(("atapi_complete ARQ error 0x%p\n", ata_pktp)); spktp->pkt_reason = CMD_TRAN_ERR; } else if (ata_pktp->ap_flags & AP_ARQ_OKAY) { static struct scsi_status zero_scsi_status = { 0 }; struct scsi_arq_status *arqp; ADBG_ARQ(("atapi_complete ARQ okay 0x%p\n", ata_pktp)); spktp->pkt_state |= STATE_ARQ_DONE; arqp = ata_pktp->ap_scbp; arqp->sts_rqpkt_reason = CMD_CMPLT; arqp->sts_rqpkt_state = STATE_XFERRED_DATA; arqp->sts_rqpkt_status = zero_scsi_status; arqp->sts_rqpkt_resid = 0; arqp->sts_rqpkt_statistics = 0; } ADBG_TRANSPORT(("atapi_complete: reason = 0x%x stats = 0x%x " "sts_chk = %d\n", spktp->pkt_reason, spktp->pkt_statistics, scsi_stat->sts_chk)); if (do_callback && (spktp->pkt_comp)) (*spktp->pkt_comp)(spktp); } /* * Update the IDENTIFY PACKET DEVICE info */ static int atapi_id_update( ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp) { ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; caddr_t ioaddr1 = ata_ctlp->ac_ioaddr1; ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; caddr_t ioaddr2 = ata_ctlp->ac_ioaddr2; struct ata_id *aidp; int rc; /* * select the appropriate drive and LUN */ ddi_put8(io_hdl1, (uchar_t *)ioaddr1 + AT_DRVHD, ata_drvp->ad_drive_bits); ata_nsecwait(400); /* * make certain the drive is selected, and wait for not busy */ if (!ata_wait(io_hdl2, ioaddr2, ATS_DRDY, ATS_BSY, 5 * 1000000)) { ADBG_ERROR(("atapi_id_update: select failed\n")); if (ata_pktp != NULL) ata_pktp->ap_flags |= AP_ERROR; return (ATA_FSM_RC_FINI); } if (ata_pktp != NULL) aidp = (struct ata_id *)ata_pktp->ap_v_addr; else aidp = &ata_drvp->ad_id; rc = atapi_id(ata_ctlp->ac_iohandle1, ata_ctlp->ac_ioaddr1, ata_ctlp->ac_iohandle2, ata_ctlp->ac_ioaddr2, aidp); if (rc) { swab(aidp->ai_drvser, aidp->ai_drvser, sizeof (aidp->ai_drvser)); swab(aidp->ai_fw, aidp->ai_fw, sizeof (aidp->ai_fw)); swab(aidp->ai_model, aidp->ai_model, sizeof (aidp->ai_model)); } if (ata_pktp == NULL) return (ATA_FSM_RC_FINI); if (!rc) { ata_pktp->ap_flags |= AP_ERROR; } else { ata_pktp->ap_flags |= AP_XFERRED_DATA; } return (ATA_FSM_RC_FINI); } /* * Both drives on the controller share a common pkt to do * ARQ processing. Therefore the pkt is only partially * initialized here. The rest of initialization occurs * just before starting the ARQ pkt when an error is * detected. */ void atapi_init_arq( ata_ctl_t *ata_ctlp) { ata_pkt_t *arq_pktp = ata_ctlp->ac_arq_pktp; arq_pktp->ap_cdbp = ata_ctlp->ac_arq_cdb; arq_pktp->ap_cdb_len = sizeof (ata_ctlp->ac_arq_cdb); arq_pktp->ap_start = atapi_fsm_start; arq_pktp->ap_intr = atapi_fsm_intr; arq_pktp->ap_complete = atapi_complete; arq_pktp->ap_flags = AP_ATAPI; arq_pktp->ap_cmd = ATC_PACKET; ata_ctlp->ac_arq_cdb[0] = SCMD_REQUEST_SENSE; } void atapi_reset_dma_mode(ata_drv_t *ata_drvp, int need_wait) { ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; /* * Some very old CD-ROM need to wait 500mS to * reset the DMA mode, so after reset the DMA * mode when resuming, check whether it was * enabled on the device, if not, delay 500mS * and reset it again. Then for normal DVD/CD-ROM, * no delay will be on resume. */ if (need_wait == TRUE) drv_usecwait(5 * 100000); ata_reset_dma_mode(ata_drvp); (void) atapi_id_update(ata_ctlp, ata_drvp, NULL); }