Lines Matching refs: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;
4277 aac_abort_iocmd(struct aac_softstate *softs, struct aac_cmd *acp,
4280 acp->flags |= AAC_CMD_ABORT;
4282 if (acp->pkt) {
4283 if (acp->slotp) { /* outstanding cmd */
4284 acp->pkt->pkt_state |= STATE_GOT_STATUS;
4289 AACDB_PRINT(softs, CE_NOTE, "CMD_TIMEOUT: acp=0x%p",
4290 acp);
4291 aac_set_pkt_reason(softs, acp, CMD_TIMEOUT,
4296 AACDB_PRINT(softs, CE_NOTE, "CMD_RESET: acp=0x%p", acp);
4297 aac_set_pkt_reason(softs, acp, CMD_RESET,
4301 AACDB_PRINT(softs, CE_NOTE, "CMD_ABORTED: acp=0x%p",
4302 acp);
4303 aac_set_pkt_reason(softs, acp, CMD_ABORTED,
4308 aac_end_io(softs, acp);
4319 struct aac_cmd *ac_arg, *acp;
4336 struct aac_cmd *acp;
4342 while ((acp = softs->q_busy.q_head) != NULL)
4343 aac_abort_iocmd(softs, acp, reason);
4352 while ((acp = softs->q_wait[i].q_head) != NULL)
4353 aac_abort_iocmd(softs, acp, reason);
4715 aac_free_dmamap(struct aac_cmd *acp)
4718 if (acp->flags & AAC_CMD_DMA_VALID) {
4719 ASSERT(acp->buf_dma_handle);
4720 (void) ddi_dma_unbind_handle(acp->buf_dma_handle);
4721 acp->flags &= ~AAC_CMD_DMA_VALID;
4724 if (acp->abp != NULL) { /* free non-aligned buf DMA */
4725 ASSERT(acp->buf_dma_handle);
4726 if ((acp->flags & AAC_CMD_BUF_WRITE) == 0 && acp->bp)
4727 ddi_rep_get8(acp->abh, (uint8_t *)acp->bp->b_un.b_addr,
4728 (uint8_t *)acp->abp, acp->bp->b_bcount,
4730 ddi_dma_mem_free(&acp->abh);
4731 acp->abp = NULL;
4734 if (acp->buf_dma_handle) {
4735 ddi_dma_free_handle(&acp->buf_dma_handle);
4736 acp->buf_dma_handle = NULL;
4741 aac_unknown_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
4744 ((union scsi_cdb *)(void *)acp->pkt->pkt_cdbp)->scc_cmd);
4745 aac_free_dmamap(acp);
4746 aac_set_arq_data(acp->pkt, KEY_ILLEGAL_REQUEST, 0x20, 0x00, 0);
4747 aac_soft_callback(softs, acp);
4754 aac_tran_start_ld(struct aac_softstate *softs, struct aac_cmd *acp)
4762 dvp = (struct aac_container *)acp->dvp;
4763 pkt = acp->pkt;
4765 bp = acp->bp;
4769 aac_free_dmamap(acp);
4771 aac_soft_callback(softs, acp);
4789 aac_free_dmamap(acp);
4795 aac_soft_callback(softs, acp);
4810 aac_free_dmamap(acp);
4817 aac_soft_callback(softs, acp);
4819 aac_unknown_scmd(softs, acp);
4828 acp->blkno = ((uint64_t) \
4834 aac_unknown_scmd(softs, acp);
4840 acp->blkno = GETG0ADDR(cdbp);
4845 acp->blkno = GETG5ADDR(cdbp);
4850 acp->blkno = (uint32_t)GETG1ADDR(cdbp);
4852 if (acp->flags & AAC_CMD_DMA_VALID) {
4861 if ((acp->blkno < cnt_size) &&
4862 ((acp->blkno + acp->bcount /
4864 rval = aac_do_io(softs, acp);
4874 aac_soft_callback(softs, acp);
4877 } else if (acp->bcount == 0) {
4879 aac_soft_callback(softs, acp);
4890 aac_free_dmamap(acp);
4896 aac_soft_callback(softs, acp);
4903 acp->aac_cmd_fib = aac_cmd_fib_startstop;
4904 acp->ac_comp = aac_startstop_complete;
4905 rval = aac_do_io(softs, acp);
4912 aac_free_dmamap(acp);
4914 if (acp->flags & AAC_CMD_BUF_READ) {
4921 aac_soft_callback(softs, acp);
4926 acp->flags |= AAC_CMD_NTAG;
4927 acp->aac_cmd_fib = aac_cmd_fib_sync;
4928 acp->ac_comp = aac_synccache_complete;
4929 rval = aac_do_io(softs, acp);
4933 aac_free_dmamap(acp);
4935 aac_soft_callback(softs, acp);
4940 aac_unknown_scmd(softs, acp);
4952 struct aac_cmd *acp = PKT2AC(pkt);
4953 struct aac_device *dvp = acp->dvp;
4962 acp->flags &= AAC_CMD_CONSISTENT | AAC_CMD_DMA_PARTIAL | \
4964 acp->timeout = acp->pkt->pkt_time;
4966 acp->flags |= AAC_CMD_NO_INTR;
4968 acp->fib_flags = AACDB_FLAGS_FIB_SCMD;
4975 if (acp->flags & AAC_CMD_DMA_VALID) {
4976 pkt->pkt_resid = acp->bcount;
4978 if ((acp->flags & AAC_CMD_CONSISTENT) &&
4979 (acp->flags & AAC_CMD_BUF_WRITE))
4980 if (aac_dma_sync_ac(acp) != AACOK) {
4990 AACDB_PRINT_SCMD(softs, acp);
4995 rval = aac_tran_start_ld(softs, acp);
4999 rval = aac_do_io(softs, acp);
5118 struct aac_cmd *acp = PKT2AC(pkt);
5122 if (acp->sgt) {
5123 kmem_free(acp->sgt, sizeof (struct aac_sge) * \
5124 acp->left_cookien);
5126 aac_free_dmamap(acp);
5127 ASSERT(acp->slotp == NULL);
5132 aac_cmd_dma_alloc(struct aac_softstate *softs, struct aac_cmd *acp,
5140 oldcookiec = acp->left_cookien;
5143 if (acp->total_nwin > 0) {
5144 if (++acp->cur_win < acp->total_nwin) {
5148 rval = ddi_dma_getwin(acp->buf_dma_handle, acp->cur_win,
5149 &off, &len, &acp->cookie, &acp->left_cookien);
5161 if (bp && bp->b_bcount != 0 && !(acp->flags & AAC_CMD_DMA_VALID)) {
5169 acp->bp = bp;
5174 acp->flags |= AAC_CMD_BUF_READ;
5177 acp->flags |= AAC_CMD_BUF_WRITE;
5185 if (!acp->buf_dma_handle) {
5188 &acp->buf_dma_handle);
5199 rval = ddi_dma_buf_bind_handle(acp->buf_dma_handle,
5200 bp, dma_flags, cb, arg, &acp->cookie,
5201 &acp->left_cookien);
5211 rval = ddi_dma_mem_alloc(acp->buf_dma_handle,
5214 cb, arg, &acp->abp, &bufsz, &acp->abh);
5223 if (acp->flags & AAC_CMD_BUF_WRITE)
5224 ddi_rep_put8(acp->abh,
5226 (uint8_t *)acp->abp, bp->b_bcount,
5229 rval = ddi_dma_addr_bind_handle(acp->buf_dma_handle,
5230 NULL, acp->abp, bufsz, dma_flags, cb, arg,
5231 &acp->cookie, &acp->left_cookien);
5236 if (ddi_dma_numwin(acp->buf_dma_handle,
5237 &acp->total_nwin) == DDI_FAILURE) {
5244 acp->left_cookien);
5245 acp->cur_win = 0;
5250 acp->left_cookien);
5251 acp->cur_win = 0;
5252 acp->total_nwin = 1;
5278 acp->flags |= AAC_CMD_DMA_VALID;
5281 ASSERT(acp->left_cookien > 0);
5282 if (acp->left_cookien > softs->aac_sg_tablesize) {
5284 acp->left_cookien);
5288 if (oldcookiec != acp->left_cookien && acp->sgt != NULL) {
5289 kmem_free(acp->sgt, sizeof (struct aac_sge) * \
5291 acp->sgt = NULL;
5293 if (acp->sgt == NULL) {
5294 acp->sgt = kmem_alloc(sizeof (struct aac_sge) * \
5295 acp->left_cookien, kf);
5296 if (acp->sgt == NULL) {
5304 sge = &acp->sgt[0];
5305 sge->bcount = acp->cookie.dmac_size;
5306 sge->addr.ad64.lo = AAC_LS32(acp->cookie.dmac_laddress);
5307 sge->addr.ad64.hi = AAC_MS32(acp->cookie.dmac_laddress);
5308 acp->bcount = acp->cookie.dmac_size;
5309 for (sge++; sge < &acp->sgt[acp->left_cookien]; sge++) {
5310 ddi_dma_nextcookie(acp->buf_dma_handle, &acp->cookie);
5311 sge->bcount = acp->cookie.dmac_size;
5312 sge->addr.ad64.lo = AAC_LS32(acp->cookie.dmac_laddress);
5313 sge->addr.ad64.hi = AAC_MS32(acp->cookie.dmac_laddress);
5314 acp->bcount += acp->cookie.dmac_size;
5322 if (acp->bcount > softs->buf_dma_attr.dma_attr_maxxfer) {
5324 "large xfer size received %d\n", acp->bcount);
5329 acp->total_xfer += acp->bcount;
5331 if (acp->pkt) {
5333 if (acp->total_xfer <= bp->b_bcount) {
5334 acp->pkt->pkt_resid = bp->b_bcount - \
5335 acp->total_xfer;
5343 acp->pkt->pkt_resid = 0;
5347 (void *)bp->b_un.b_addr, (int)acp->total_xfer,
5348 (int)bp->b_bcount, (int)acp->pkt->pkt_resid);
5364 struct aac_cmd *acp, *new_acp;
5380 acp = new_acp = PKT2AC(pkt);
5381 acp->pkt = pkt;
5382 acp->cmdlen = cmdlen;
5385 acp->dvp = &softs->containers[ap->a_target].dev;
5386 acp->aac_cmd_fib = softs->aac_cmd_fib;
5387 acp->ac_comp = aac_ld_complete;
5391 acp->dvp = &softs->nondasds[AAC_PD(ap->a_target)].dev;
5392 acp->aac_cmd_fib = softs->aac_cmd_fib_scsi;
5393 acp->ac_comp = aac_pd_complete;
5396 acp = PKT2AC(pkt);
5400 if (aac_cmd_dma_alloc(softs, acp, bp, flags, callback, arg) == AACOK)
5415 struct aac_cmd *acp = PKT2AC(pkt);
5419 if (aac_dma_sync_ac(acp) != AACOK)
5432 struct aac_cmd *acp = PKT2AC(pkt);
5436 aac_free_dmamap(acp);
5551 aac_cmd_fib_header(struct aac_softstate *softs, struct aac_cmd *acp,
5554 struct aac_slot *slotp = acp->slotp;
5568 if (!(acp->flags & AAC_CMD_SYNC))
5575 ddi_put16(acc, &fibp->Header.Size, acp->fib_size);
5586 aac_cmd_fib_rawio(struct aac_softstate *softs, struct aac_cmd *acp)
5588 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5589 struct aac_raw_io *io = (struct aac_raw_io *)&acp->slotp->fibp->data[0];
5594 acp->fib_size = sizeof (struct aac_fib_header) + \
5595 sizeof (struct aac_raw_io) + (acp->left_cookien - 1) * \
5598 aac_cmd_fib_header(softs, acp, RawIo);
5600 ddi_put16(acc, &io->Flags, (acp->flags & AAC_CMD_BUF_READ) ? 1 : 0);
5604 ddi_put32(acc, AAC_LO32(&io->BlockNumber), AAC_LS32(acp->blkno));
5605 ddi_put32(acc, AAC_HI32(&io->BlockNumber), AAC_MS32(acp->blkno));
5607 ((struct aac_container *)acp->dvp)->cid);
5610 ddi_put32(acc, &io->SgMapRaw.SgCount, acp->left_cookien);
5611 ddi_put32(acc, &io->ByteCount, acp->bcount);
5613 for (sge = &acp->sgt[0], sgp = &io->SgMapRaw.SgEntryRaw[0];
5614 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5626 aac_cmd_fib_brw64(struct aac_softstate *softs, struct aac_cmd *acp)
5628 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5630 &acp->slotp->fibp->data[0];
5634 acp->fib_size = sizeof (struct aac_fib_header) + \
5635 sizeof (struct aac_blockread64) + (acp->left_cookien - 1) * \
5638 aac_cmd_fib_header(softs, acp, ContainerCommand64);
5644 ddi_put32(acc, &br->BlockNumber, (uint32_t)acp->blkno);
5646 ((struct aac_container *)acp->dvp)->cid);
5647 ddi_put32(acc, &br->Command, (acp->flags & AAC_CMD_BUF_READ) ?
5653 ddi_put32(acc, &br->SgMap64.SgCount, acp->left_cookien);
5654 ddi_put16(acc, &br->SectorCount, acp->bcount / AAC_BLK_SIZE);
5656 for (sge = &acp->sgt[0], sgp = &br->SgMap64.SgEntry64[0];
5657 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5666 aac_cmd_fib_brw(struct aac_softstate *softs, struct aac_cmd *acp)
5668 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5670 &acp->slotp->fibp->data[0];
5672 struct aac_sge *sge = &acp->sgt[0];
5674 if (acp->flags & AAC_CMD_BUF_READ) {
5675 acp->fib_size = sizeof (struct aac_fib_header) + \
5676 sizeof (struct aac_blockread) + (acp->left_cookien - 1) * \
5680 ddi_put32(acc, &br->SgMap.SgCount, acp->left_cookien);
5685 acp->fib_size = sizeof (struct aac_fib_header) + \
5686 sizeof (struct aac_blockwrite) + (acp->left_cookien - 1) * \
5691 ddi_put32(acc, &bw->SgMap.SgCount, acp->left_cookien);
5694 aac_cmd_fib_header(softs, acp, ContainerCommand);
5700 ddi_put32(acc, &br->BlockNumber, (uint32_t)acp->blkno);
5702 ((struct aac_container *)acp->dvp)->cid);
5703 ddi_put32(acc, &br->ByteCount, acp->bcount);
5706 for (sge = &acp->sgt[0];
5707 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5715 aac_cmd_fib_copy(struct aac_softstate *softs, struct aac_cmd *acp)
5717 struct aac_slot *slotp = acp->slotp;
5721 ddi_rep_put8(acc, (uint8_t *)acp->fibp, (uint8_t *)fibp,
5722 acp->fib_size, /* only copy data of needed length */
5729 aac_cmd_fib_sync(struct aac_softstate *softs, struct aac_cmd *acp)
5731 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5733 (struct aac_synchronize_command *)&acp->slotp->fibp->data[0];
5735 acp->fib_size = AAC_FIB_SIZEOF(struct aac_synchronize_command);
5737 aac_cmd_fib_header(softs, acp, ContainerCommand);
5740 ddi_put32(acc, &sync->Cid, ((struct aac_container *)acp->dvp)->cid);
5749 aac_cmd_fib_startstop(struct aac_softstate *softs, struct aac_cmd *acp)
5751 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5753 (struct aac_Container *)&acp->slotp->fibp->data[0];
5754 union scsi_cdb *cdbp = (void *)acp->pkt->pkt_cdbp;
5756 acp->fib_size = AAC_FIB_SIZEOF(struct aac_Container);
5758 aac_cmd_fib_header(softs, acp, ContainerCommand);
5765 ((struct aac_container *)acp->dvp)->cid);
5773 aac_cmd_fib_srb(struct aac_cmd *acp)
5775 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5776 struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5781 ddi_put32(acc, &srb->cdb_size, acp->cmdlen);
5783 if (acp->fibp == NULL) {
5784 if (acp->flags & AAC_CMD_BUF_READ)
5786 else if (acp->flags & AAC_CMD_BUF_WRITE)
5789 ((struct aac_nondasd *)acp->dvp)->bus);
5790 ddi_put32(acc, &srb->id, ((struct aac_nondasd *)acp->dvp)->tid);
5792 cdb = acp->pkt->pkt_cdbp;
5794 struct aac_srb *srb0 = (struct aac_srb *)&acp->fibp->data[0];
5802 ddi_rep_put8(acc, cdb, srb->cdb, acp->cmdlen, DDI_DEV_AUTOINCR);
5806 aac_cmd_fib_scsi32(struct aac_softstate *softs, struct aac_cmd *acp)
5808 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5809 struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5813 acp->fib_size = sizeof (struct aac_fib_header) + \
5815 acp->left_cookien * sizeof (struct aac_sg_entry);
5818 aac_cmd_fib_header(softs, acp, ScsiPortCommand);
5819 aac_cmd_fib_srb(acp);
5822 ddi_put32(acc, &srb->sg.SgCount, acp->left_cookien);
5823 ddi_put32(acc, &srb->count, acp->bcount);
5825 for (sge = &acp->sgt[0], sgp = &srb->sg.SgEntry[0];
5826 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5833 aac_cmd_fib_scsi64(struct aac_softstate *softs, struct aac_cmd *acp)
5835 ddi_acc_handle_t acc = acp->slotp->fib_acc_handle;
5836 struct aac_srb *srb = (struct aac_srb *)&acp->slotp->fibp->data[0];
5840 acp->fib_size = sizeof (struct aac_fib_header) + \
5842 acp->left_cookien * sizeof (struct aac_sg_entry64);
5845 aac_cmd_fib_header(softs, acp, ScsiPortCommandU64);
5846 aac_cmd_fib_srb(acp);
5849 ddi_put32(acc, &srb->sg.SgCount, acp->left_cookien);
5850 ddi_put32(acc, &srb->count, acp->bcount);
5852 for (sge = &acp->sgt[0],
5854 sge < &acp->sgt[acp->left_cookien]; sge++, sgp++) {
5862 aac_cmd_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5867 acp->slotp = slotp;
5868 slotp->acp = acp;
5869 acp->aac_cmd_fib(softs, acp);
5878 aac_bind_io(struct aac_softstate *softs, struct aac_cmd *acp)
5880 struct aac_device *dvp = acp->dvp;
5881 int q = AAC_CMDQ(acp);
5886 if (!(acp->flags & AAC_CMD_NTAG) ||
5888 return (aac_cmd_slot_bind(softs, acp));
5895 return (aac_cmd_slot_bind(softs, acp));
5902 aac_sync_fib_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5910 ASSERT(acp->slotp == NULL);
5912 acp->slotp = slotp;
5913 slotp->acp = acp;
5920 aac_sync_fib_slot_release(struct aac_softstate *softs, struct aac_cmd *acp)
5922 ASSERT(acp->slotp);
5924 aac_release_slot(softs, acp->slotp);
5925 acp->slotp->acp = NULL;
5926 acp->slotp = NULL;
5932 aac_start_io(struct aac_softstate *softs, struct aac_cmd *acp)
5934 struct aac_slot *slotp = acp->slotp;
5935 int q = AAC_CMDQ(acp);
5939 if (acp->pkt) { /* ac from ioctl has no pkt */
5940 acp->pkt->pkt_state |=
5943 if (acp->timeout) /* 0 indicates no timeout */
5944 acp->timeout += aac_timebase + aac_tick;
5946 if (acp->dvp)
5947 acp->dvp->ncmds[q]++;
5949 aac_cmd_enqueue(&softs->q_busy, acp);
5961 slotp->fib_phyaddr, acp->fib_size);
5973 if (acp->pkt) {
5974 acp->pkt->pkt_state &= ~STATE_SENT_CMD;
5975 aac_set_pkt_reason(softs, acp, CMD_INCOMPLETE, 0);
5977 aac_end_io(softs, acp);
5978 if (!(acp->flags & (AAC_CMD_NO_INTR | AAC_CMD_NO_CB)))
5986 struct aac_cmd *acp, *next_acp;
5989 for (acp = q->q_head; acp; acp = next_acp) {
5990 next_acp = acp->next;
5991 if (aac_bind_io(softs, acp) == AACOK) {
5992 aac_cmd_delete(q, acp);
5993 aac_start_io(softs, acp);
6016 struct aac_cmd *acp;
6022 acp = aac_cmd_dequeue(&softs->q_comp);
6024 if (acp != NULL) {
6025 ASSERT(acp->pkt != NULL);
6026 pkt = acp->pkt;
6032 if ((acp->flags & AAC_CMD_CONSISTENT) &&
6033 (acp->flags & AAC_CMD_BUF_READ)) {
6034 if (aac_dma_sync_ac(acp) != AACOK) {
6236 slotp->acp = NULL;
6242 aac_do_io(struct aac_softstate *softs, struct aac_cmd *acp)
6244 if (aac_bind_io(softs, acp) == AACOK)
6245 aac_start_io(softs, acp);
6247 aac_cmd_enqueue(&softs->q_wait[AAC_CMDQ(acp)], acp);
6249 if (!(acp->flags & (AAC_CMD_NO_CB | AAC_CMD_NO_INTR)))
6255 if (acp->flags & AAC_CMD_NO_INTR) {
6256 if (aac_do_poll_io(softs, acp) == AACOK)
6259 if (aac_do_sync_io(softs, acp) == AACOK)
6266 aac_do_poll_io(struct aac_softstate *softs, struct aac_cmd *acp)
6275 while (!(acp->flags & (AAC_CMD_CMPLT | AAC_CMD_ABORT))) {
6280 aac_cmd_timeout(softs, acp);
6285 if ((acp->flags & AAC_CMD_CMPLT) && !(acp->flags & AAC_CMD_ERR))
6291 aac_do_sync_io(struct aac_softstate *softs, struct aac_cmd *acp)
6293 ASSERT(softs && acp);
6295 while (!(acp->flags & (AAC_CMD_CMPLT | AAC_CMD_ABORT)))
6298 if (acp->flags & AAC_CMD_CMPLT)
6304 aac_dma_sync_ac(struct aac_cmd *acp)
6306 if (acp->buf_dma_handle) {
6307 if (acp->flags & AAC_CMD_BUF_WRITE) {
6308 if (acp->abp != NULL)
6309 ddi_rep_put8(acp->abh,
6310 (uint8_t *)acp->bp->b_un.b_addr,
6311 (uint8_t *)acp->abp, acp->bp->b_bcount,
6313 (void) ddi_dma_sync(acp->buf_dma_handle, 0, 0,
6316 (void) ddi_dma_sync(acp->buf_dma_handle, 0, 0,
6318 if (aac_check_dma_handle(acp->buf_dma_handle) !=
6321 if (acp->abp != NULL)
6322 ddi_rep_get8(acp->abh,
6323 (uint8_t *)acp->bp->b_un.b_addr,
6324 (uint8_t *)acp->abp, acp->bp->b_bcount,
6582 aac_cmd_timeout(struct aac_softstate *softs, struct aac_cmd *acp)
6585 acp->fib_flags |= AACDB_FLAGS_FIB_TIMEOUT;
6586 AACDB_PRINT(softs, CE_WARN, "acp %p timed out", acp);
6587 AACDB_PRINT_FIB(softs, acp->slotp);
6668 struct aac_cmd *acp;
6671 for (acp = softs->q_busy.q_head; acp; acp = acp->next) {
6672 if (acp->timeout == 0)
6680 acp->timeout += time_adjust;
6684 if (acp->timeout <= softs_timebase) {
6685 aac_cmd_timeout(softs, acp);
8162 aac_print_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
8164 struct scsi_pkt *pkt = acp->pkt;
8176 ctl = ((struct aac_nondasd *)acp->dvp)->bus;
8177 tgt = ((struct aac_nondasd *)acp->dvp)->tid;
8195 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8203 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8212 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8220 (acp->flags & AAC_CMD_NO_INTR) ? "poll" : "intr",
8232 struct aac_cmd *acp = slotp->acp;
8241 if (acp) {
8242 if (!(softs->debug_fib_flags & acp->fib_flags))
8244 if (acp->fib_flags & AACDB_FLAGS_FIB_SCMD)
8246 else if (acp->fib_flags & AACDB_FLAGS_FIB_IOCTL)
8248 else if (acp->fib_flags & AACDB_FLAGS_FIB_SRB)