Lines Matching defs:acp
149 #define AAC_CMDQ(acp) (!((acp)->flags & AAC_CMD_SYNC))
1205 aac_set_arq_data_hwerr(struct aac_cmd *acp)
1210 cdbp = (void *)acp->pkt->pkt_cdbp;
1211 err_blkno = AAC_GETGXADDR(acp->cmdlen, cdbp);
1212 aac_set_arq_data(acp->pkt, KEY_HARDWARE_ERROR, 0x00, 0x00, err_blkno);
1236 PCI_MEM_PUT32(softs, device, slotp->acp->fib_size);
1242 aac_end_io(struct aac_softstate *softs, struct aac_cmd *acp)
1244 struct aac_device *dvp = acp->dvp;
1245 int q = AAC_CMDQ(acp);
1247 if (acp->slotp) { /* outstanding cmd */
1248 if (!(acp->flags & AAC_CMD_IN_SYNC_SLOT)) {
1249 aac_release_slot(softs, acp->slotp);
1250 acp->slotp = NULL;
1274 aac_set_arq_data(acp->pkt, KEY_UNIT_ATTENTION,
1280 aac_cmd_delete(&softs->q_busy, acp);
1282 aac_cmd_delete(&softs->q_wait[q], acp);
1285 if (!(acp->flags & (AAC_CMD_NO_CB | AAC_CMD_NO_INTR))) { /* async IO */
1287 aac_cmd_enqueue(&softs->q_comp, acp);
1289 } else if (acp->flags & AAC_CMD_NO_CB) { /* sync IO */
1298 struct aac_cmd *acp;
1308 acp = slotp->acp;
1310 if (acp == NULL || acp->slotp != slotp) {
1316 acp->flags |= AAC_CMD_CMPLT;
1342 acp->ac_comp(softs, acp);
1345 acp->flags |= AAC_CMD_ERR;
1346 if (acp->pkt) {
1347 acp->pkt->pkt_reason = CMD_TRAN_ERR;
1348 acp->pkt->pkt_statistics = 0;
1351 aac_end_io(softs, acp);
1776 aac_set_pkt_reason(struct aac_softstate *softs, struct aac_cmd *acp,
1782 if (acp->pkt->pkt_reason == CMD_CMPLT)
1783 acp->pkt->pkt_reason = reason;
1784 acp->pkt->pkt_statistics |= stat;
1791 aac_soft_callback(struct aac_softstate *softs, struct aac_cmd *acp)
1793 ASSERT(acp->pkt);
1795 acp->flags |= AAC_CMD_CMPLT;
1797 acp->pkt->pkt_state |= STATE_GOT_BUS | STATE_GOT_TARGET | \
1799 if (acp->pkt->pkt_state & STATE_XFERRED_DATA)
1800 acp->pkt->pkt_resid = 0;
1803 if (!(acp->flags & AAC_CMD_NO_INTR)) {
1805 aac_cmd_enqueue(&softs->q_comp, acp);
1820 aac_ld_complete(struct aac_softstate *softs, struct aac_cmd *acp)
1822 struct aac_slot *slotp = acp->slotp;
1826 ASSERT(!(acp->flags & AAC_CMD_SYNC));
1827 ASSERT(!(acp->flags & AAC_CMD_NO_CB));
1829 acp->pkt->pkt_state |= STATE_GOT_STATUS;
1838 acp->pkt->pkt_resid = 0;
1839 acp->pkt->pkt_state |= STATE_XFERRED_DATA;
1841 aac_set_arq_data_hwerr(acp);
1849 aac_pd_complete(struct aac_softstate *softs, struct aac_cmd *acp)
1851 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
1852 struct aac_fib *fibp = acp->slotp->fibp;
1853 struct scsi_pkt *pkt = acp->pkt;
1857 ASSERT(!(acp->flags & AAC_CMD_SYNC));
1858 ASSERT(!(acp->flags & AAC_CMD_NO_CB));
1885 acp->bcount);
1896 aac_set_pkt_reason(softs, acp,
1911 pkt->pkt_resid = acp->bcount - \
1920 aac_set_pkt_reason(softs, acp, CMD_ABORTED,
1928 aac_set_pkt_reason(softs, acp, CMD_ABORT_FAIL,
1936 aac_set_pkt_reason(softs, acp, CMD_PER_FAIL, 0);
1944 if (AAC_DEV_IS_VALID(acp->dvp)) {
1952 aac_set_pkt_reason(softs, acp, CMD_DEV_GONE, 0);
1960 aac_set_pkt_reason(softs, acp, CMD_TIMEOUT,
1968 aac_set_pkt_reason(softs, acp, CMD_RESET,
1975 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2012 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2017 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2026 aac_ioctl_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2028 struct aac_slot *slotp = acp->slotp;
2035 ASSERT(acp->flags & AAC_CMD_SYNC);
2036 ASSERT(acp->flags & AAC_CMD_NO_CB);
2039 acp->fib_size = ddi_get16(slotp->fib_acc_handle,
2042 ASSERT(acp->fib_size <= softs->aac_max_fib_size);
2043 ddi_rep_get8(slotp->fib_acc_handle, (uint8_t *)acp->fibp,
2044 (uint8_t *)slotp->fibp, acp->fib_size, DDI_DEV_AUTOINCR);
2052 aac_sync_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2061 aac_synccache_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2063 struct aac_slot *slotp = acp->slotp;
2068 ASSERT(!(acp->flags & AAC_CMD_SYNC));
2070 acp->pkt->pkt_state |= STATE_GOT_STATUS;
2075 aac_set_arq_data_hwerr(acp);
2080 aac_startstop_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2082 struct aac_slot *slotp = acp->slotp;
2087 ASSERT(!(acp->flags & AAC_CMD_SYNC));
2089 acp->pkt->pkt_state |= STATE_GOT_STATUS;
2095 aac_set_arq_data_hwerr(acp);
2500 struct aac_cmd *acp = &softs->sync_ac;
2507 (void) aac_sync_fib_slot_bind(softs, acp);
2508 acc = acp->slotp->fib_acc_handle;
2509 fibp = acp->slotp->fibp;
2595 aac_sync_fib_slot_release(softs, acp);
2603 struct aac_cmd *acp = &softs->sync_ac;
2613 (void) aac_sync_fib_slot_bind(softs, acp);
2614 acc = acp->slotp->fib_acc_handle;
2615 fibp = acp->slotp->fibp;
2660 aac_sync_fib_slot_release(softs, acp);
2705 struct aac_cmd *acp = &softs->sync_ac;
2716 (void) aac_sync_fib_slot_bind(softs, acp);
2717 acc = acp->slotp->fib_acc_handle;
2718 fibp = acp->slotp->fibp;
2768 aac_sync_fib_slot_release(softs, acp);
3106 struct aac_cmd *acp = &softs->sync_ac;
3108 acp->flags = AAC_CMD_SYNC | AAC_CMD_IN_SYNC_SLOT;
3110 acp->flags |= AAC_CMD_NO_CB;
3112 acp->flags |= AAC_CMD_NO_INTR;
3114 acp->ac_comp = aac_sync_complete;
3115 acp->timeout = AAC_SYNC_TIMEOUT;
3116 acp->fib_size = fibsize;
3122 aac_cmd_fib_header(softs, acp, cmd);
3124 (void) ddi_dma_sync(acp->slotp->fib_dma_handle, 0, fibsize,
3127 aac_start_io(softs, acp);
3130 return (aac_do_sync_io(softs, acp));
3132 return (aac_do_poll_io(softs, acp));
3148 struct aac_cmd *acp;
3152 if ((acp = q->q_head) != NULL) {
3153 if ((q->q_head = acp->next) != NULL)
3154 acp->next = NULL;
3157 acp->prev = NULL;
3159 return (acp);
3166 aac_cmd_enqueue(struct aac_cmd_queue *q, struct aac_cmd *acp)
3168 ASSERT(acp->next == NULL);
3169 acp->prev = q->q_tail;
3170 q->q_tail->next = acp;
3171 q->q_tail = acp;
3178 aac_cmd_delete(struct aac_cmd_queue *q, struct aac_cmd *acp)
3180 if (acp->prev) {
3181 if ((acp->prev->next = acp->next) != NULL) {
3182 acp->next->prev = acp->prev;
3183 acp->next = NULL;
3185 q->q_tail = acp->prev;
3187 acp->prev = NULL;
4278 aac_abort_iocmd(struct aac_softstate *softs, struct aac_cmd *acp,
4281 acp->flags |= AAC_CMD_ABORT;
4283 if (acp->pkt) {
4284 if (acp->slotp) { /* outstanding cmd */
4285 acp->pkt->pkt_state |= STATE_GOT_STATUS;
4290 AACDB_PRINT(softs, CE_NOTE, "CMD_TIMEOUT: acp=0x%p",
4291 acp);
4292 aac_set_pkt_reason(softs, acp, CMD_TIMEOUT,
4297 AACDB_PRINT(softs, CE_NOTE, "CMD_RESET: acp=0x%p", acp);
4298 aac_set_pkt_reason(softs, acp, CMD_RESET,
4302 AACDB_PRINT(softs, CE_NOTE, "CMD_ABORTED: acp=0x%p",
4303 acp);
4304 aac_set_pkt_reason(softs, acp, CMD_ABORTED,
4309 aac_end_io(softs, acp);
4320 struct aac_cmd *ac_arg, *acp;
4337 struct aac_cmd *acp;
4343 while ((acp = softs->q_busy.q_head) != NULL)
4344 aac_abort_iocmd(softs, acp, reason);
4353 while ((acp = softs->q_wait[i].q_head) != NULL)
4354 aac_abort_iocmd(softs, acp, reason);
4716 aac_free_dmamap(struct aac_cmd *acp)
4719 if (acp->flags & AAC_CMD_DMA_VALID) {
4720 ASSERT(acp->buf_dma_handle);
4721 (void) ddi_dma_unbind_handle(acp->buf_dma_handle);
4722 acp->flags &= ~AAC_CMD_DMA_VALID;
4725 if (acp->abp != NULL) { /* free non-aligned buf DMA */
4726 ASSERT(acp->buf_dma_handle);
4727 if ((acp->flags & AAC_CMD_BUF_WRITE) == 0 && acp->bp)
4728 ddi_rep_get8(acp->abh, (uint8_t *)acp->bp->b_un.b_addr,
4729 (uint8_t *)acp->abp, acp->bp->b_bcount,
4731 ddi_dma_mem_free(&acp->abh);
4732 acp->abp = NULL;
4735 if (acp->buf_dma_handle) {
4736 ddi_dma_free_handle(&acp->buf_dma_handle);
4737 acp->buf_dma_handle = NULL;
4742 aac_unknown_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
4745 ((union scsi_cdb *)(void *)acp->pkt->pkt_cdbp)->scc_cmd);
4746 aac_free_dmamap(acp);
4747 aac_set_arq_data(acp->pkt, KEY_ILLEGAL_REQUEST, 0x20, 0x00, 0);
4748 aac_soft_callback(softs, acp);
4755 aac_tran_start_ld(struct aac_softstate *softs, struct aac_cmd *acp)
4763 dvp = (struct aac_container *)acp->dvp;
4764 pkt = acp->pkt;
4766 bp = acp->bp;
4770 aac_free_dmamap(acp);
4772 aac_soft_callback(softs, acp);
4790 aac_free_dmamap(acp);
4796 aac_soft_callback(softs, acp);
4811 aac_free_dmamap(acp);
4818 aac_soft_callback(softs, acp);
4820 aac_unknown_scmd(softs, acp);
4829 acp->blkno = ((uint64_t) \
4835 aac_unknown_scmd(softs, acp);
4841 acp->blkno = GETG0ADDR(cdbp);
4846 acp->blkno = GETG5ADDR(cdbp);
4851 acp->blkno = (uint32_t)GETG1ADDR(cdbp);
4853 if (acp->flags & AAC_CMD_DMA_VALID) {
4862 if ((acp->blkno < cnt_size) &&
4863 ((acp->blkno + acp->bcount /
4865 rval = aac_do_io(softs, acp);
4875 aac_soft_callback(softs, acp);
4878 } else if (acp->bcount == 0) {
4880 aac_soft_callback(softs, acp);
4891 aac_free_dmamap(acp);
4897 aac_soft_callback(softs, acp);
4904 acp->aac_cmd_fib = aac_cmd_fib_startstop;
4905 acp->ac_comp = aac_startstop_complete;
4906 rval = aac_do_io(softs, acp);
4913 aac_free_dmamap(acp);
4915 if (acp->flags & AAC_CMD_BUF_READ) {
4922 aac_soft_callback(softs, acp);
4927 acp->flags |= AAC_CMD_NTAG;
4928 acp->aac_cmd_fib = aac_cmd_fib_sync;
4929 acp->ac_comp = aac_synccache_complete;
4930 rval = aac_do_io(softs, acp);
4934 aac_free_dmamap(acp);
4936 aac_soft_callback(softs, acp);
4941 aac_unknown_scmd(softs, acp);
4953 struct aac_cmd *acp = PKT2AC(pkt);
4954 struct aac_device *dvp = acp->dvp;
4963 acp->flags &= AAC_CMD_CONSISTENT | AAC_CMD_DMA_PARTIAL | \
4965 acp->timeout = acp->pkt->pkt_time;
4967 acp->flags |= AAC_CMD_NO_INTR;
4969 acp->fib_flags = AACDB_FLAGS_FIB_SCMD;
4976 if (acp->flags & AAC_CMD_DMA_VALID) {
4977 pkt->pkt_resid = acp->bcount;
4979 if ((acp->flags & AAC_CMD_CONSISTENT) &&
4980 (acp->flags & AAC_CMD_BUF_WRITE))
4981 if (aac_dma_sync_ac(acp) != AACOK) {
4991 AACDB_PRINT_SCMD(softs, acp);
4996 rval = aac_tran_start_ld(softs, acp);
5000 rval = aac_do_io(softs, acp);
5119 struct aac_cmd *acp = PKT2AC(pkt);
5123 if (acp->sgt) {
5124 kmem_free(acp->sgt, sizeof (struct aac_sge) * \
5125 acp->left_cookien);
5127 aac_free_dmamap(acp);
5128 ASSERT(acp->slotp == NULL);
5133 aac_cmd_dma_alloc(struct aac_softstate *softs, struct aac_cmd *acp,
5141 oldcookiec = acp->left_cookien;
5144 if (acp->total_nwin > 0) {
5145 if (++acp->cur_win < acp->total_nwin) {
5149 rval = ddi_dma_getwin(acp->buf_dma_handle, acp->cur_win,
5150 &off, &len, &acp->cookie, &acp->left_cookien);
5162 if (bp && bp->b_bcount != 0 && !(acp->flags & AAC_CMD_DMA_VALID)) {
5170 acp->bp = bp;
5175 acp->flags |= AAC_CMD_BUF_READ;
5178 acp->flags |= AAC_CMD_BUF_WRITE;
5186 if (!acp->buf_dma_handle) {
5189 &acp->buf_dma_handle);
5200 rval = ddi_dma_buf_bind_handle(acp->buf_dma_handle,
5201 bp, dma_flags, cb, arg, &acp->cookie,
5202 &acp->left_cookien);
5212 rval = ddi_dma_mem_alloc(acp->buf_dma_handle,
5215 cb, arg, &acp->abp, &bufsz, &acp->abh);
5224 if (acp->flags & AAC_CMD_BUF_WRITE)
5225 ddi_rep_put8(acp->abh,
5227 (uint8_t *)acp->abp, bp->b_bcount,
5230 rval = ddi_dma_addr_bind_handle(acp->buf_dma_handle,
5231 NULL, acp->abp, bufsz, dma_flags, cb, arg,
5232 &acp->cookie, &acp->left_cookien);
5237 if (ddi_dma_numwin(acp->buf_dma_handle,
5238 &acp->total_nwin) == DDI_FAILURE) {
5245 acp->left_cookien);
5246 acp->cur_win = 0;
5251 acp->left_cookien);
5252 acp->cur_win = 0;
5253 acp->total_nwin = 1;
5279 acp->flags |= AAC_CMD_DMA_VALID;
5282 ASSERT(acp->left_cookien > 0);
5283 if (acp->left_cookien > softs->aac_sg_tablesize) {
5285 acp->left_cookien);
5289 if (oldcookiec != acp->left_cookien && acp->sgt != NULL) {
5290 kmem_free(acp->sgt, sizeof (struct aac_sge) * \
5292 acp->sgt = NULL;
5294 if (acp->sgt == NULL) {
5295 acp->sgt = kmem_alloc(sizeof (struct aac_sge) * \
5296 acp->left_cookien, kf);
5297 if (acp->sgt == NULL) {
5305 sge = &acp->sgt[0];
5306 sge->bcount = acp->cookie.dmac_size;
5307 sge->addr.ad64.lo = AAC_LS32(acp->cookie.dmac_laddress);
5308 sge->addr.ad64.hi = AAC_MS32(acp->cookie.dmac_laddress);
5309 acp->bcount = acp->cookie.dmac_size;
5310 for (sge++; sge < &acp->sgt[acp->left_cookien]; sge++) {
5311 ddi_dma_nextcookie(acp->buf_dma_handle, &acp->cookie);
5312 sge->bcount = acp->cookie.dmac_size;
5313 sge->addr.ad64.lo = AAC_LS32(acp->cookie.dmac_laddress);
5314 sge->addr.ad64.hi = AAC_MS32(acp->cookie.dmac_laddress);
5315 acp->bcount += acp->cookie.dmac_size;
5323 if (acp->bcount > softs->buf_dma_attr.dma_attr_maxxfer) {
5325 "large xfer size received %d\n", acp->bcount);
5330 acp->total_xfer += acp->bcount;
5332 if (acp->pkt) {
5334 if (acp->total_xfer <= bp->b_bcount) {
5335 acp->pkt->pkt_resid = bp->b_bcount - \
5336 acp->total_xfer;
5344 acp->pkt->pkt_resid = 0;
5348 (void *)bp->b_un.b_addr, (int)acp->total_xfer,
5349 (int)bp->b_bcount, (int)acp->pkt->pkt_resid);
5365 struct aac_cmd *acp, *new_acp;
5381 acp = new_acp = PKT2AC(pkt);
5382 acp->pkt = pkt;
5383 acp->cmdlen = cmdlen;
5386 acp->dvp = &softs->containers[ap->a_target].dev;
5387 acp->aac_cmd_fib = softs->aac_cmd_fib;
5388 acp->ac_comp = aac_ld_complete;
5392 acp->dvp = &softs->nondasds[AAC_PD(ap->a_target)].dev;
5393 acp->aac_cmd_fib = softs->aac_cmd_fib_scsi;
5394 acp->ac_comp = aac_pd_complete;
5397 acp = PKT2AC(pkt);
5401 if (aac_cmd_dma_alloc(softs, acp, bp, flags, callback, arg) == AACOK)
5416 struct aac_cmd *acp = PKT2AC(pkt);
5420 if (aac_dma_sync_ac(acp) != AACOK)
5433 struct aac_cmd *acp = PKT2AC(pkt);
5437 aac_free_dmamap(acp);
5552 aac_cmd_fib_header(struct aac_softstate *softs, struct aac_cmd *acp,
5555 struct aac_slot *slotp = acp->slotp;
5569 if (!(acp->flags & AAC_CMD_SYNC))
5576 ddi_put16(acc, &fibp->Header.Size, acp->fib_size);
5587 aac_cmd_fib_rawio(struct aac_softstate *softs, struct aac_cmd *acp)
5589 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5590 struct aac_raw_io *io = (struct aac_raw_io *)&acp->slotp->fibp->data[0];
5595 acp->fib_size = sizeof (struct aac_fib_header) + \
5596 sizeof (struct aac_raw_io) + (acp->left_cookien - 1) * \
5599 aac_cmd_fib_header(softs, acp, RawIo);
5601 ddi_put16(acc, &io->Flags, (acp->flags & AAC_CMD_BUF_READ) ? 1 : 0);
5605 ddi_put32(acc, AAC_LO32(&io->BlockNumber), AAC_LS32(acp->blkno));
5606 ddi_put32(acc, AAC_HI32(&io->BlockNumber), AAC_MS32(acp->blkno));
5608 ((struct aac_container *)acp->dvp)->cid);
5611 ddi_put32(acc, &io->SgMapRaw.SgCount, acp->left_cookien);
5612 ddi_put32(acc, &io->ByteCount, acp->bcount);
5614 for (sge = &acp->sgt[0], sgp = &io->SgMapRaw.SgEntryRaw[0];
5615 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5627 aac_cmd_fib_brw64(struct aac_softstate *softs, struct aac_cmd *acp)
5629 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5631 &acp->slotp->fibp->data[0];
5635 acp->fib_size = sizeof (struct aac_fib_header) + \
5636 sizeof (struct aac_blockread64) + (acp->left_cookien - 1) * \
5639 aac_cmd_fib_header(softs, acp, ContainerCommand64);
5645 ddi_put32(acc, &br->BlockNumber, (uint32_t)acp->blkno);
5647 ((struct aac_container *)acp->dvp)->cid);
5648 ddi_put32(acc, &br->Command, (acp->flags & AAC_CMD_BUF_READ) ?
5654 ddi_put32(acc, &br->SgMap64.SgCount, acp->left_cookien);
5655 ddi_put16(acc, &br->SectorCount, acp->bcount / AAC_BLK_SIZE);
5657 for (sge = &acp->sgt[0], sgp = &br->SgMap64.SgEntry64[0];
5658 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5667 aac_cmd_fib_brw(struct aac_softstate *softs, struct aac_cmd *acp)
5669 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5671 &acp->slotp->fibp->data[0];
5673 struct aac_sge *sge = &acp->sgt[0];
5675 if (acp->flags & AAC_CMD_BUF_READ) {
5676 acp->fib_size = sizeof (struct aac_fib_header) + \
5677 sizeof (struct aac_blockread) + (acp->left_cookien - 1) * \
5681 ddi_put32(acc, &br->SgMap.SgCount, acp->left_cookien);
5686 acp->fib_size = sizeof (struct aac_fib_header) + \
5687 sizeof (struct aac_blockwrite) + (acp->left_cookien - 1) * \
5692 ddi_put32(acc, &bw->SgMap.SgCount, acp->left_cookien);
5695 aac_cmd_fib_header(softs, acp, ContainerCommand);
5701 ddi_put32(acc, &br->BlockNumber, (uint32_t)acp->blkno);
5703 ((struct aac_container *)acp->dvp)->cid);
5704 ddi_put32(acc, &br->ByteCount, acp->bcount);
5707 for (sge = &acp->sgt[0];
5708 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5716 aac_cmd_fib_copy(struct aac_softstate *softs, struct aac_cmd *acp)
5718 struct aac_slot *slotp = acp->slotp;
5722 ddi_rep_put8(acc, (uint8_t *)acp->fibp, (uint8_t *)fibp,
5723 acp->fib_size, /* only copy data of needed length */
5730 aac_cmd_fib_sync(struct aac_softstate *softs, struct aac_cmd *acp)
5732 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5734 (struct aac_synchronize_command *)&acp->slotp->fibp->data[0];
5736 acp->fib_size = AAC_FIB_SIZEOF(struct aac_synchronize_command);
5738 aac_cmd_fib_header(softs, acp, ContainerCommand);
5741 ddi_put32(acc, &sync->Cid, ((struct aac_container *)acp->dvp)->cid);
5750 aac_cmd_fib_startstop(struct aac_softstate *softs, struct aac_cmd *acp)
5752 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5754 (struct aac_Container *)&acp->slotp->fibp->data[0];
5755 union scsi_cdb *cdbp = (void *)acp->pkt->pkt_cdbp;
5757 acp->fib_size = AAC_FIB_SIZEOF(struct aac_Container);
5759 aac_cmd_fib_header(softs, acp, ContainerCommand);
5766 ((struct aac_container *)acp->dvp)->cid);
5774 aac_cmd_fib_srb(struct aac_cmd *acp)
5776 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5777 struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5782 ddi_put32(acc, &srb->cdb_size, acp->cmdlen);
5784 if (acp->fibp == NULL) {
5785 if (acp->flags & AAC_CMD_BUF_READ)
5787 else if (acp->flags & AAC_CMD_BUF_WRITE)
5790 ((struct aac_nondasd *)acp->dvp)->bus);
5791 ddi_put32(acc, &srb->id, ((struct aac_nondasd *)acp->dvp)->tid);
5793 cdb = acp->pkt->pkt_cdbp;
5795 struct aac_srb *srb0 = (struct aac_srb *)&acp->fibp->data[0];
5803 ddi_rep_put8(acc, cdb, srb->cdb, acp->cmdlen, DDI_DEV_AUTOINCR);
5807 aac_cmd_fib_scsi32(struct aac_softstate *softs, struct aac_cmd *acp)
5809 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5810 struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5814 acp->fib_size = sizeof (struct aac_fib_header) + \
5816 acp->left_cookien * sizeof (struct aac_sg_entry);
5819 aac_cmd_fib_header(softs, acp, ScsiPortCommand);
5820 aac_cmd_fib_srb(acp);
5823 ddi_put32(acc, &srb->sg.SgCount, acp->left_cookien);
5824 ddi_put32(acc, &srb->count, acp->bcount);
5826 for (sge = &acp->sgt[0], sgp = &srb->sg.SgEntry[0];
5827 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5834 aac_cmd_fib_scsi64(struct aac_softstate *softs, struct aac_cmd *acp)
5836 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5837 struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5841 acp->fib_size = sizeof (struct aac_fib_header) + \
5843 acp->left_cookien * sizeof (struct aac_sg_entry64);
5846 aac_cmd_fib_header(softs, acp, ScsiPortCommandU64);
5847 aac_cmd_fib_srb(acp);
5850 ddi_put32(acc, &srb->sg.SgCount, acp->left_cookien);
5851 ddi_put32(acc, &srb->count, acp->bcount);
5853 for (sge = &acp->sgt[0],
5855 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5863 aac_cmd_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5868 acp->slotp = slotp;
5869 slotp->acp = acp;
5870 acp->aac_cmd_fib(softs, acp);
5879 aac_bind_io(struct aac_softstate *softs, struct aac_cmd *acp)
5881 struct aac_device *dvp = acp->dvp;
5882 int q = AAC_CMDQ(acp);
5887 if (!(acp->flags & AAC_CMD_NTAG) ||
5889 return (aac_cmd_slot_bind(softs, acp));
5896 return (aac_cmd_slot_bind(softs, acp));
5903 aac_sync_fib_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5911 ASSERT(acp->slotp == NULL);
5913 acp->slotp = slotp;
5914 slotp->acp = acp;
5921 aac_sync_fib_slot_release(struct aac_softstate *softs, struct aac_cmd *acp)
5923 ASSERT(acp->slotp);
5925 aac_release_slot(softs, acp->slotp);
5926 acp->slotp->acp = NULL;
5927 acp->slotp = NULL;
5933 aac_start_io(struct aac_softstate *softs, struct aac_cmd *acp)
5935 struct aac_slot *slotp = acp->slotp;
5936 int q = AAC_CMDQ(acp);
5940 if (acp->pkt) { /* ac from ioctl has no pkt */
5941 acp->pkt->pkt_state |=
5944 if (acp->timeout) /* 0 indicates no timeout */
5945 acp->timeout += aac_timebase + aac_tick;
5947 if (acp->dvp)
5948 acp->dvp->ncmds[q]++;
5950 aac_cmd_enqueue(&softs->q_busy, acp);
5962 slotp->fib_phyaddr, acp->fib_size);
5974 if (acp->pkt) {
5975 acp->pkt->pkt_state &= ~STATE_SENT_CMD;
5976 aac_set_pkt_reason(softs, acp, CMD_INCOMPLETE, 0);
5978 aac_end_io(softs, acp);
5979 if (!(acp->flags & (AAC_CMD_NO_INTR | AAC_CMD_NO_CB)))
5987 struct aac_cmd *acp, *next_acp;
5990 for (acp = q->q_head; acp; acp = next_acp) {
5991 next_acp = acp->next;
5992 if (aac_bind_io(softs, acp) == AACOK) {
5993 aac_cmd_delete(q, acp);
5994 aac_start_io(softs, acp);
6017 struct aac_cmd *acp;
6023 acp = aac_cmd_dequeue(&softs->q_comp);
6025 if (acp != NULL) {
6026 ASSERT(acp->pkt != NULL);
6027 pkt = acp->pkt;
6033 if ((acp->flags & AAC_CMD_CONSISTENT) &&
6034 (acp->flags & AAC_CMD_BUF_READ)) {
6035 if (aac_dma_sync_ac(acp) != AACOK) {
6237 slotp->acp = NULL;
6243 aac_do_io(struct aac_softstate *softs, struct aac_cmd *acp)
6245 if (aac_bind_io(softs, acp) == AACOK)
6246 aac_start_io(softs, acp);
6248 aac_cmd_enqueue(&softs->q_wait[AAC_CMDQ(acp)], acp);
6250 if (!(acp->flags & (AAC_CMD_NO_CB | AAC_CMD_NO_INTR)))
6256 if (acp->flags & AAC_CMD_NO_INTR) {
6257 if (aac_do_poll_io(softs, acp) == AACOK)
6260 if (aac_do_sync_io(softs, acp) == AACOK)
6267 aac_do_poll_io(struct aac_softstate *softs, struct aac_cmd *acp)
6276 while (!(acp->flags & (AAC_CMD_CMPLT | AAC_CMD_ABORT))) {
6281 aac_cmd_timeout(softs, acp);
6286 if ((acp->flags & AAC_CMD_CMPLT) && !(acp->flags & AAC_CMD_ERR))
6292 aac_do_sync_io(struct aac_softstate *softs, struct aac_cmd *acp)
6294 ASSERT(softs && acp);
6296 while (!(acp->flags & (AAC_CMD_CMPLT | AAC_CMD_ABORT)))
6299 if (acp->flags & AAC_CMD_CMPLT)
6305 aac_dma_sync_ac(struct aac_cmd *acp)
6307 if (acp->buf_dma_handle) {
6308 if (acp->flags & AAC_CMD_BUF_WRITE) {
6309 if (acp->abp != NULL)
6310 ddi_rep_put8(acp->abh,
6311 (uint8_t *)acp->bp->b_un.b_addr,
6312 (uint8_t *)acp->abp, acp->bp->b_bcount,
6314 (void) ddi_dma_sync(acp->buf_dma_handle, 0, 0,
6317 (void) ddi_dma_sync(acp->buf_dma_handle, 0, 0,
6319 if (aac_check_dma_handle(acp->buf_dma_handle) !=
6322 if (acp->abp != NULL)
6323 ddi_rep_get8(acp->abh,
6324 (uint8_t *)acp->bp->b_un.b_addr,
6325 (uint8_t *)acp->abp, acp->bp->b_bcount,
6583 aac_cmd_timeout(struct aac_softstate *softs, struct aac_cmd *acp)
6586 acp->fib_flags |= AACDB_FLAGS_FIB_TIMEOUT;
6587 AACDB_PRINT(softs, CE_WARN, "acp %p timed out", acp);
6588 AACDB_PRINT_FIB(softs, acp->slotp);
6669 struct aac_cmd *acp;
6672 for (acp = softs->q_busy.q_head; acp; acp = acp->next) {
6673 if (acp->timeout == 0)
6681 acp->timeout += time_adjust;
6685 if (acp->timeout <= softs_timebase) {
6686 aac_cmd_timeout(softs, acp);
8163 aac_print_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
8165 struct scsi_pkt *pkt = acp->pkt;
8177 ctl = ((struct aac_nondasd *)acp->dvp)->bus;
8178 tgt = ((struct aac_nondasd *)acp->dvp)->tid;
8196 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8204 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8213 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8221 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8233 struct aac_cmd *acp = slotp->acp;
8242 if (acp) {
8243 if (!(softs->debug_fib_flags & acp->fib_flags))
8245 if (acp->fib_flags & AACDB_FLAGS_FIB_SCMD)
8247 else if (acp->fib_flags & AACDB_FLAGS_FIB_IOCTL)
8249 else if (acp->fib_flags & AACDB_FLAGS_FIB_SRB)