Lines Matching defs:softs
78 #define AAC_DEV(softs, t) (((t) < AAC_MAX_LD) ? \
79 &(softs)->containers[(t)].dev : \
80 ((t) < AAC_MAX_DEV(softs)) ? \
81 &(softs)->nondasds[AAC_PD(t)].dev : NULL)
82 #define AAC_DEVCFG_BEGIN(softs, tgt) \
83 aac_devcfg((softs), (tgt), 1)
84 #define AAC_DEVCFG_END(softs, tgt) \
85 aac_devcfg((softs), (tgt), 0)
137 #define AAC_MIR_SIZE(softs, acc, mir) \
138 (((softs)->flags & AAC_FLAGS_LBA_64BIT) ? \
151 #define PCI_MEM_GET32(softs, off) \
152 ddi_get32((softs)->pci_mem_handle, \
153 (void *)((softs)->pci_mem_base_vaddr + (off)))
154 #define PCI_MEM_PUT32(softs, off, val) \
155 ddi_put32((softs)->pci_mem_handle, \
156 (void *)((softs)->pci_mem_base_vaddr + (off)), \
158 #define PCI_MEM_GET16(softs, off) \
159 ddi_get16((softs)->pci_mem_handle, \
160 (void *)((softs)->pci_mem_base_vaddr + (off)))
161 #define PCI_MEM_PUT16(softs, off, val) \
162 ddi_put16((softs)->pci_mem_handle, \
163 (void *)((softs)->pci_mem_base_vaddr + (off)), (uint16_t)(val))
165 #define PCI_MEM_REP_PUT8(softs, off, valp, count) \
166 ddi_rep_put8((softs)->pci_mem_handle, (uint8_t *)(valp), \
167 (uint8_t *)((softs)->pci_mem_base_vaddr + (off)), \
170 #define PCI_MEM_REP_GET8(softs, off, valp, count) \
171 ddi_rep_get8((softs)->pci_mem_handle, (uint8_t *)(valp), \
172 (uint8_t *)((softs)->pci_mem_base_vaddr + (off)), \
187 #define AAC_ENABLE_INTR(softs) { \
188 if (softs->flags & AAC_FLAGS_NEW_COMM) \
189 PCI_MEM_PUT32(softs, AAC_OIMR, ~AAC_DB_INTR_NEW); \
191 PCI_MEM_PUT32(softs, AAC_OIMR, ~AAC_DB_INTR_BITS); \
192 softs->state |= AAC_STATE_INTR; \
195 #define AAC_DISABLE_INTR(softs) { \
196 PCI_MEM_PUT32(softs, AAC_OIMR, ~0); \
197 softs->state &= ~AAC_STATE_INTR; \
199 #define AAC_STATUS_CLR(softs, mask) PCI_MEM_PUT32(softs, AAC_ODBR, mask)
200 #define AAC_STATUS_GET(softs) PCI_MEM_GET32(softs, AAC_ODBR)
201 #define AAC_NOTIFY(softs, val) PCI_MEM_PUT32(softs, AAC_IDBR, val)
202 #define AAC_OUTB_GET(softs) PCI_MEM_GET32(softs, AAC_OQUE)
203 #define AAC_OUTB_SET(softs, val) PCI_MEM_PUT32(softs, AAC_OQUE, val)
204 #define AAC_FWSTATUS_GET(softs) \
205 ((softs)->aac_if.aif_get_fwstatus(softs))
206 #define AAC_MAILBOX_GET(softs, mb) \
207 ((softs)->aac_if.aif_get_mailbox((softs), (mb)))
208 #define AAC_MAILBOX_SET(softs, cmd, arg0, arg1, arg2, arg3) \
209 ((softs)->aac_if.aif_set_mailbox((softs), (cmd), \
332 static int aac_do_quiesce(struct aac_softstate *softs);
333 static int aac_do_unquiesce(struct aac_softstate *softs);
763 struct aac_softstate *softs = NULL;
782 AACDB_PRINT(softs, CE_WARN, "Cannot alloc soft state");
785 softs = ddi_get_soft_state(aac_softstatep, instance);
788 softs->instance = instance;
789 softs->devinfo_p = dip;
790 softs->buf_dma_attr = softs->addr_dma_attr = aac_dma_attr;
791 softs->addr_dma_attr.dma_attr_granular = 1;
792 softs->acc_attr = aac_acc_attr;
793 softs->reg_attr = aac_acc_attr;
794 softs->card = AAC_UNKNOWN_CARD;
796 softs->debug_flags = aac_debug_flags;
797 softs->debug_fib_flags = aac_debug_fib_flags;
801 aac_fm_init(softs);
804 if (aac_check_card_type(softs) == AACERR) {
805 AACDB_PRINT(softs, CE_WARN, "Card not supported");
813 (caddr_t *)&softs->pci_mem_base_vaddr, 0,
814 softs->map_size_min, &softs->reg_attr,
815 &softs->pci_mem_handle) != DDI_SUCCESS)
818 softs->map_size = softs->map_size_min;
821 AAC_DISABLE_INTR(softs);
824 mutex_init(&softs->io_lock, NULL, MUTEX_DRIVER,
825 DDI_INTR_PRI(softs->intr_pri));
826 mutex_init(&softs->q_comp_mutex, NULL, MUTEX_DRIVER,
827 DDI_INTR_PRI(softs->intr_pri));
828 mutex_init(&softs->time_mutex, NULL, MUTEX_DRIVER,
829 DDI_INTR_PRI(softs->intr_pri));
830 mutex_init(&softs->ev_lock, NULL, MUTEX_DRIVER,
831 DDI_INTR_PRI(softs->intr_pri));
832 mutex_init(&softs->aifq_mutex, NULL,
833 MUTEX_DRIVER, DDI_INTR_PRI(softs->intr_pri));
834 cv_init(&softs->event, NULL, CV_DRIVER, NULL);
835 cv_init(&softs->sync_fib_cv, NULL, CV_DRIVER, NULL);
836 cv_init(&softs->drain_cv, NULL, CV_DRIVER, NULL);
837 cv_init(&softs->event_wait_cv, NULL, CV_DRIVER, NULL);
838 cv_init(&softs->event_disp_cv, NULL, CV_DRIVER, NULL);
839 cv_init(&softs->aifq_cv, NULL, CV_DRIVER, NULL);
844 aac_cmd_initq(&softs->q_wait[i]);
845 aac_cmd_initq(&softs->q_busy);
846 aac_cmd_initq(&softs->q_comp);
849 softs->legacy = 1; /* default to use legacy name */
853 AACDB_PRINT(softs, CE_NOTE, "legacy-name disabled");
854 softs->legacy = 0;
863 mutex_enter(&softs->io_lock);
864 if (aac_common_attach(softs) == AACERR) {
865 mutex_exit(&softs->io_lock);
868 mutex_exit(&softs->io_lock);
875 AACDB_PRINT(softs, CE_NOTE, "buf breakup enabled");
876 softs->flags |= AAC_FLAGS_BRKUP;
880 softs->dma_max = softs->buf_dma_attr.dma_attr_maxxfer;
881 if (softs->flags & AAC_FLAGS_BRKUP) {
882 softs->dma_max = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
883 DDI_PROP_DONTPASS, "dma-max", softs->dma_max);
886 if (aac_hba_setup(softs) != AACOK)
893 AACDB_PRINT(softs, CE_WARN, "failed to create devctl node");
900 AACDB_PRINT(softs, CE_WARN, "failed to create scsi node");
908 AACDB_PRINT(softs, CE_WARN, "failed to create aac node");
913 softs->state |= AAC_STATE_RUN;
916 softs->fibctx_p = &softs->aifctx;
917 if ((softs->event_thread = thread_create(NULL, 0, aac_event_thread,
918 softs, 0, &p0, TS_RUN, minclsyspri)) == NULL) {
919 AACDB_PRINT(softs, CE_WARN, "aif thread create failed");
920 softs->state &= ~AAC_STATE_RUN;
924 aac_unhold_bus(softs, AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC);
927 softs->timeout_id = timeout(aac_timer, (void *)softs,
932 AACDB_PRINT(softs, CE_NOTE, "aac attached ok");
941 aac_common_detach(softs);
947 mutex_destroy(&softs->io_lock);
948 mutex_destroy(&softs->q_comp_mutex);
949 mutex_destroy(&softs->time_mutex);
950 mutex_destroy(&softs->ev_lock);
951 mutex_destroy(&softs->aifq_mutex);
952 cv_destroy(&softs->event);
953 cv_destroy(&softs->sync_fib_cv);
954 cv_destroy(&softs->drain_cv);
955 cv_destroy(&softs->event_wait_cv);
956 cv_destroy(&softs->event_disp_cv);
957 cv_destroy(&softs->aifq_cv);
960 ddi_regs_map_free(&softs->pci_mem_handle);
961 aac_fm_fini(softs);
963 softs->card = AACERR;
973 struct aac_softstate *softs = AAC_TRAN2SOFTS(tran);
975 DBCALLED(softs, 1);
986 mutex_enter(&softs->io_lock);
987 AAC_DISABLE_INTR(softs);
988 softs->state = AAC_STATE_STOPPED;
993 mutex_exit(&softs->io_lock);
995 aac_common_detach(softs);
997 mutex_enter(&softs->io_lock);
1000 mutex_exit(&softs->io_lock);
1003 mutex_enter(&softs->time_mutex);
1004 if (softs->timeout_id) {
1005 timeout_id_t tid = softs->timeout_id;
1006 softs->timeout_id = 0;
1008 mutex_exit(&softs->time_mutex);
1010 mutex_enter(&softs->time_mutex);
1012 mutex_exit(&softs->time_mutex);
1015 mutex_enter(&softs->ev_lock);
1016 cv_signal(&softs->event_disp_cv);
1017 cv_wait(&softs->event_wait_cv, &softs->ev_lock);
1018 mutex_exit(&softs->ev_lock);
1020 cv_destroy(&softs->aifq_cv);
1021 cv_destroy(&softs->event_disp_cv);
1022 cv_destroy(&softs->event_wait_cv);
1023 cv_destroy(&softs->drain_cv);
1024 cv_destroy(&softs->sync_fib_cv);
1025 cv_destroy(&softs->event);
1026 mutex_destroy(&softs->aifq_mutex);
1027 mutex_destroy(&softs->ev_lock);
1028 mutex_destroy(&softs->time_mutex);
1029 mutex_destroy(&softs->q_comp_mutex);
1030 mutex_destroy(&softs->io_lock);
1032 ddi_regs_map_free(&softs->pci_mem_handle);
1033 aac_fm_fini(softs);
1034 softs->hwif = AAC_HWIF_UNKNOWN;
1035 softs->card = AAC_UNKNOWN_CARD;
1045 struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
1047 DBCALLED(softs, 1);
1049 mutex_enter(&softs->io_lock);
1050 AAC_DISABLE_INTR(softs);
1051 (void) aac_shutdown(softs);
1052 mutex_exit(&softs->io_lock);
1070 struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
1072 if (softs == NULL)
1075 _NOTE(ASSUMING_PROTECTED(softs->state))
1076 AAC_DISABLE_INTR(softs);
1105 aac_shutdown(struct aac_softstate *softs)
1111 (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
1112 acc = softs->sync_ac.slotp->fib_acc_handle;
1114 cc = (struct aac_close_command *)&softs->sync_ac.slotp->fibp->data[0];
1120 rval = aac_sync_fib(softs, ContainerCommand,
1122 aac_sync_fib_slot_release(softs, &softs->sync_ac);
1124 AACDB_PRINT(softs, CE_NOTE,
1132 struct aac_softstate *softs = (void *)arg;
1134 if (!AAC_IS_Q_EMPTY(&softs->q_comp)) {
1135 aac_drain_comp_q(softs);
1219 aac_send_command(struct aac_softstate *softs, struct aac_slot *slotp)
1223 index = PCI_MEM_GET32(softs, AAC_IQUE);
1225 index = PCI_MEM_GET32(softs, AAC_IQUE);
1231 PCI_MEM_PUT32(softs, device,
1234 PCI_MEM_PUT32(softs, device, (uint32_t)(slotp->fib_phyaddr >> 32));
1236 PCI_MEM_PUT32(softs, device, slotp->acp->fib_size);
1237 PCI_MEM_PUT32(softs, AAC_IQUE, index);
1242 aac_end_io(struct aac_softstate *softs, struct aac_cmd *acp)
1249 aac_release_slot(softs, acp->slotp);
1256 aac_set_throttle(softs, dvp, q,
1257 softs->total_slots);
1271 AACDB_PRINT(softs, CE_NOTE,
1279 softs->bus_ncmds[q]--;
1280 aac_cmd_delete(&softs->q_busy, acp);
1282 aac_cmd_delete(&softs->q_wait[q], acp);
1286 mutex_enter(&softs->q_comp_mutex);
1287 aac_cmd_enqueue(&softs->q_comp, acp);
1288 mutex_exit(&softs->q_comp_mutex);
1290 cv_broadcast(&softs->event);
1295 aac_handle_io(struct aac_softstate *softs, int index)
1305 ASSERT(index >= 0 && index < softs->total_slots);
1306 slotp = &softs->io_slot[index];
1342 acp->ac_comp(softs, acp);
1344 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
1351 aac_end_io(softs, acp);
1361 aac_process_intr_new(struct aac_softstate *softs)
1365 index = AAC_OUTB_GET(softs);
1367 index = AAC_OUTB_GET(softs);
1368 if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
1369 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
1375 aac_handle_io(softs, index);
1387 fibp = (struct aac_fib *)(softs-> \
1389 fib_size = PCI_MEM_GET16(softs, index + \
1392 aac_save_aif(softs, softs->pci_mem_handle,
1399 AAC_OUTB_SET(softs, index);
1400 AAC_STATUS_CLR(softs, AAC_DB_RESPONSE_READY);
1403 index = AAC_OUTB_GET(softs);
1410 aac_start_waiting_io(softs);
1420 struct aac_softstate *softs = (void *)arg;
1423 mutex_enter(&softs->io_lock);
1424 if (aac_process_intr_new(softs))
1428 mutex_exit(&softs->io_lock);
1430 aac_drain_comp_q(softs);
1441 aac_process_intr_old(struct aac_softstate *softs)
1445 status = AAC_STATUS_GET(softs);
1446 if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
1447 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
1454 AAC_STATUS_CLR(softs, AAC_DB_RESPONSE_READY);
1455 (void) AAC_STATUS_GET(softs);
1456 while (aac_fib_dequeue(softs, AAC_HOST_NORM_RESP_Q,
1458 aac_handle_io(softs, slot_idx);
1464 aac_start_waiting_io(softs);
1469 AAC_STATUS_CLR(softs, AAC_DB_COMMAND_READY);
1470 (void) AAC_STATUS_GET(softs);
1471 if (aac_fib_dequeue(softs, AAC_HOST_NORM_CMD_Q, &aif_idx) ==
1473 ddi_acc_handle_t acc = softs->comm_space_acc_handle;
1481 #define AAC_SYNC_AIF(softs, aif_idx, type) \
1482 { (void) ddi_dma_sync((softs)->comm_space_dma_handle, \
1488 AAC_SYNC_AIF(softs, aif_idx, DDI_DMA_SYNC_FORCPU);
1489 fibp = &softs->comm_space->adapter_fibs[aif_idx];
1492 aac_save_aif(softs, acc, fibp, fib_size);
1503 AAC_SYNC_AIF(softs, aif_idx,
1509 &softs->comm_space->adapter_fibs[aif_idx]. \
1512 &softs->comm_space->adapter_fibs[aif_idx]. \
1515 &softs->comm_space->adapter_fibs[aif_idx]. \
1517 if (aac_fib_enqueue(softs, AAC_ADAP_NORM_RESP_Q,
1524 AAC_STATUS_CLR(softs, AAC_DB_PRINTF_READY);
1525 (void) AAC_STATUS_GET(softs);
1526 (void) ddi_dma_sync(softs->comm_space_dma_handle,
1529 if (aac_check_dma_handle(softs->comm_space_dma_handle) ==
1532 softs->comm_space->adapter_print_buf);
1534 ddi_fm_service_impact(softs->devinfo_p,
1536 AAC_NOTIFY(softs, AAC_DB_PRINTF_READY);
1545 AAC_STATUS_CLR(softs, AAC_DB_COMMAND_NOT_FULL);
1548 AAC_STATUS_CLR(softs, AAC_DB_COMMAND_NOT_FULL);
1549 AAC_STATUS_CLR(softs, AAC_DB_RESPONSE_NOT_FULL);
1559 struct aac_softstate *softs = (void *)arg;
1562 mutex_enter(&softs->io_lock);
1563 if (aac_process_intr_old(softs))
1567 mutex_exit(&softs->io_lock);
1569 aac_drain_comp_q(softs);
1577 aac_query_intrs(struct aac_softstate *softs, int intr_type)
1579 dev_info_t *dip = softs->devinfo_p;
1583 AACDB_PRINT(softs, CE_NOTE,
1589 AACDB_PRINT(softs, CE_WARN,
1598 AACDB_PRINT(softs, CE_WARN,
1604 AACDB_PRINT(softs, CE_NOTE,
1609 softs->intr_size = count * sizeof (ddi_intr_handle_t);
1610 softs->htable = kmem_alloc(softs->intr_size, KM_SLEEP);
1620 ret = ddi_intr_alloc(dip, softs->htable, intr_type, 0,
1624 AACDB_PRINT(softs, CE_WARN,
1631 AACDB_PRINT(softs, CE_NOTE,
1636 softs->intr_cnt = actual;
1639 if ((ret = ddi_intr_get_pri(softs->htable[0],
1640 &softs->intr_pri)) != DDI_SUCCESS) {
1641 AACDB_PRINT(softs, CE_WARN,
1647 if (softs->intr_pri >= ddi_intr_get_hilevel_pri()) {
1648 AACDB_PRINT(softs, CE_WARN,
1658 (void) ddi_intr_free(softs->htable[i]);
1660 kmem_free(softs->htable, softs->intr_size);
1669 aac_add_intrs(struct aac_softstate *softs)
1675 actual = softs->intr_cnt;
1676 aac_intr = (ddi_intr_handler_t *)((softs->flags & AAC_FLAGS_NEW_COMM) ?
1681 if ((ret = ddi_intr_add_handler(softs->htable[i],
1682 aac_intr, (caddr_t)softs, NULL)) != DDI_SUCCESS) {
1688 (void) ddi_intr_free(softs->htable[i]);
1690 kmem_free(softs->htable, softs->intr_size);
1695 if ((ret = ddi_intr_get_cap(softs->htable[0], &softs->intr_cap))
1701 (void) ddi_intr_free(softs->htable[i]);
1703 kmem_free(softs->htable, softs->intr_size);
1714 aac_remove_intrs(struct aac_softstate *softs)
1719 (void) aac_disable_intrs(softs);
1721 for (i = 0; i < softs->intr_cnt; i++) {
1722 (void) ddi_intr_remove_handler(softs->htable[i]);
1723 (void) ddi_intr_free(softs->htable[i]);
1726 kmem_free(softs->htable, softs->intr_size);
1730 aac_enable_intrs(struct aac_softstate *softs)
1734 if (softs->intr_cap & DDI_INTR_FLAG_BLOCK) {
1736 if (ddi_intr_block_enable(softs->htable, softs->intr_cnt) !=
1743 for (i = 0; i < softs->intr_cnt; i++) {
1744 if (ddi_intr_enable(softs->htable[i]) != DDI_SUCCESS)
1752 aac_disable_intrs(struct aac_softstate *softs)
1756 if (softs->intr_cap & DDI_INTR_FLAG_BLOCK) {
1758 if (ddi_intr_block_disable(softs->htable, softs->intr_cnt) !=
1764 for (i = 0; i < softs->intr_cnt; i++) {
1765 if (ddi_intr_disable(softs->htable[i]) != DDI_SUCCESS)
1776 aac_set_pkt_reason(struct aac_softstate *softs, struct aac_cmd *acp,
1780 _NOTE(ARGUNUSED(softs))
1791 aac_soft_callback(struct aac_softstate *softs, struct aac_cmd *acp)
1804 mutex_enter(&softs->q_comp_mutex);
1805 aac_cmd_enqueue(&softs->q_comp, acp);
1806 mutex_exit(&softs->q_comp_mutex);
1807 ddi_trigger_softintr(softs->softint_id);
1820 aac_ld_complete(struct aac_softstate *softs, struct aac_cmd *acp)
1849 aac_pd_complete(struct aac_softstate *softs, struct aac_cmd *acp)
1882 AACDB_PRINT(softs, CE_NOTE, "DATA_OVERRUN: " \
1896 aac_set_pkt_reason(softs, acp,
1917 AACDB_PRINT(softs, CE_NOTE,
1920 aac_set_pkt_reason(softs, acp, CMD_ABORTED,
1924 AACDB_PRINT(softs, CE_NOTE,
1928 aac_set_pkt_reason(softs, acp, CMD_ABORT_FAIL,
1932 AACDB_PRINT(softs, CE_NOTE,
1936 aac_set_pkt_reason(softs, acp, CMD_PER_FAIL, 0);
1945 AACDB_PRINT(softs, CE_NOTE,
1952 aac_set_pkt_reason(softs, acp, CMD_DEV_GONE, 0);
1956 AACDB_PRINT(softs, CE_NOTE,
1960 aac_set_pkt_reason(softs, acp, CMD_TIMEOUT,
1964 AACDB_PRINT(softs, CE_NOTE,
1968 aac_set_pkt_reason(softs, acp, CMD_RESET,
1972 AACDB_PRINT(softs, CE_NOTE, "srb_status=%d, " \
1975 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
1999 AACDB_PRINT(softs, CE_NOTE,
2009 AACDB_PRINT(softs, CE_WARN, "invaild scsi status: " \
2012 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2015 AACDB_PRINT(softs, CE_NOTE, "SRB failed: fib status %d",
2017 aac_set_pkt_reason(softs, acp, CMD_TRAN_ERR, 0);
2026 aac_ioctl_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2032 * may wait on softs->event, so use cv_broadcast() instead
2042 ASSERT(acp->fib_size <= softs->aac_max_fib_size);
2052 aac_sync_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2061 aac_synccache_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2080 aac_startstop_complete(struct aac_softstate *softs, struct aac_cmd *acp)
2094 AACDB_PRINT(softs, CE_WARN, "Cannot start/stop a unit");
2103 aac_check_card_type(struct aac_softstate *softs)
2110 if ((pci_config_setup(softs->devinfo_p, &pci_config_handle)) !=
2112 AACDB_PRINT(softs, CE_WARN, "Cannot setup pci config space");
2116 softs->vendid = pci_config_get16(pci_config_handle, PCI_CONF_VENID);
2117 softs->devid = pci_config_get16(pci_config_handle, PCI_CONF_DEVID);
2118 softs->subvendid = pci_config_get16(pci_config_handle,
2120 softs->subsysid = pci_config_get16(pci_config_handle,
2125 if ((aac_cards[card_index].vendor == softs->vendid) &&
2126 (aac_cards[card_index].device == softs->devid) &&
2127 (aac_cards[card_index].subvendor == softs->subvendid) &&
2128 (aac_cards[card_index].subsys == softs->subsysid)) {
2134 softs->card = card_index;
2135 softs->hwif = aac_cards[card_index].hwif;
2143 if (softs->vendid != 0x9005) {
2144 AACDB_PRINT(softs, CE_WARN,
2145 "Unknown vendor 0x%x", softs->vendid);
2148 switch (softs->devid) {
2150 softs->hwif = AAC_HWIF_I960RX;
2153 softs->hwif = AAC_HWIF_RKT;
2156 AACDB_PRINT(softs, CE_WARN,
2157 "Unknown device \"pci9005,%x\"", softs->devid);
2163 switch (softs->hwif) {
2165 softs->aac_if = aac_rx_interface;
2166 softs->map_size_min = AAC_MAP_SIZE_MIN_RX;
2169 softs->aac_if = aac_rkt_interface;
2170 softs->map_size_min = AAC_MAP_SIZE_MIN_RKT;
2173 AACDB_PRINT(softs, CE_WARN,
2174 "Unknown hardware interface %d", softs->hwif);
2179 (void *)strncpy(softs->vendor_name, aac_cards[card_index].vid,
2181 (void *)strncpy(softs->product_name, aac_cards[card_index].desc,
2185 softs->flags = aac_cards[card_index].quirks;
2200 softs->pci_mem_base_paddr = 0xfffffff0UL & \
2215 aac_register_intrs(struct aac_softstate *softs)
2220 ASSERT(softs->devinfo_p);
2221 dip = softs->devinfo_p;
2225 AACDB_PRINT(softs, CE_WARN,
2229 AACDB_PRINT(softs, CE_NOTE,
2234 if (aac_query_intrs(softs, DDI_INTR_TYPE_MSI)
2236 AACDB_PRINT(softs, CE_WARN,
2240 softs->intr_type = DDI_INTR_TYPE_MSI;
2242 if (aac_query_intrs(softs, DDI_INTR_TYPE_FIXED)
2244 AACDB_PRINT(softs, CE_WARN,
2248 softs->intr_type = DDI_INTR_TYPE_FIXED;
2250 AACDB_PRINT(softs, CE_WARN,
2256 if (aac_add_intrs(softs) != DDI_SUCCESS) {
2257 AACDB_PRINT(softs, CE_WARN,
2259 softs->intr_type == DDI_INTR_TYPE_MSI ? "MSI" : "FIXED");
2262 (void) aac_enable_intrs(softs);
2264 if (ddi_add_softintr(dip, DDI_SOFTINT_LOW, &softs->softint_id,
2265 NULL, NULL, aac_softintr, (caddr_t)softs) != DDI_SUCCESS) {
2266 AACDB_PRINT(softs, CE_WARN,
2268 aac_remove_intrs(softs);
2276 aac_unregister_intrs(struct aac_softstate *softs)
2278 aac_remove_intrs(softs);
2279 ddi_remove_softintr(softs->softint_id);
2287 aac_check_firmware(struct aac_softstate *softs)
2300 if ((aac_sync_mbcommand(softs, AAC_MONKER_GETINFO, 0, 0, 0, 0,
2310 options = AAC_MAILBOX_GET(softs, 1);
2311 atu_size = AAC_MAILBOX_GET(softs, 2);
2314 if (softs->state & AAC_STATE_RESET) {
2315 if ((softs->support_opt == options) &&
2316 (softs->atu_size == atu_size))
2328 softs->support_opt = options;
2329 softs->atu_size = atu_size;
2333 (softs->flags & AAC_FLAGS_NO4GB) == 0) {
2334 AACDB_PRINT(softs, CE_NOTE, "!Enable FIB map 4GB window");
2335 softs->flags |= AAC_FLAGS_4GB_WINDOW;
2343 softs->addr_dma_attr.dma_attr_addr_lo = 0x2000ull;
2344 softs->addr_dma_attr.dma_attr_addr_hi = 0x7fffffffull;
2348 AACDB_PRINT(softs, CE_NOTE, "!Enable SG map 64-bit address");
2349 softs->buf_dma_attr.dma_attr_addr_hi = 0xffffffffffffffffull;
2350 softs->buf_dma_attr.dma_attr_seg = 0xffffffffffffffffull;
2351 softs->flags |= AAC_FLAGS_SG_64BIT;
2355 softs->flags |= AAC_FLAGS_ARRAY_64BIT;
2356 AACDB_PRINT(softs, CE_NOTE, "!Enable 64-bit array size");
2360 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, softs->devinfo_p, 0,
2363 AACDB_PRINT(softs, CE_NOTE,
2365 softs->flags |= AAC_FLAGS_NONDASD;
2373 if ((aac_sync_mbcommand(softs, AAC_MONKER_GETCOMMPREF,
2375 options = AAC_MAILBOX_GET(softs, 1);
2378 options = AAC_MAILBOX_GET(softs, 2);
2380 options = AAC_MAILBOX_GET(softs, 3);
2385 if ((softs->support_opt & AAC_SUPPORTED_NEW_COMM) &&
2388 if ((atu_size > softs->map_size) &&
2389 (ddi_regs_map_setup(softs->devinfo_p, 1,
2390 (caddr_t *)&data, 0, atu_size, &softs->reg_attr,
2392 ddi_regs_map_free(&softs->pci_mem_handle);
2393 softs->pci_mem_handle = pci_handle;
2394 softs->pci_mem_base_vaddr = data;
2395 softs->map_size = atu_size;
2397 if (atu_size == softs->map_size) {
2398 softs->flags |= AAC_FLAGS_NEW_COMM;
2399 AACDB_PRINT(softs, CE_NOTE,
2405 if (softs->flags & AAC_FLAGS_NEW_COMM) {
2406 softs->aac_max_fibs = max_fibs;
2407 softs->aac_max_fib_size = max_fib_size;
2408 softs->aac_max_sectors = max_sectors;
2409 softs->aac_sg_tablesize = sg_tablesize;
2411 softs->flags |= AAC_FLAGS_RAW_IO;
2412 AACDB_PRINT(softs, CE_NOTE, "!Enable RawIO");
2414 softs->aac_max_fibs =
2415 (softs->flags & AAC_FLAGS_256FIBS) ? 256 : 512;
2416 softs->aac_max_fib_size = AAC_FIB_SIZE;
2417 softs->aac_max_sectors = 128; /* 64K */
2418 if (softs->flags & AAC_FLAGS_17SG)
2419 softs->aac_sg_tablesize = 17;
2420 else if (softs->flags & AAC_FLAGS_34SG)
2421 softs->aac_sg_tablesize = 34;
2422 else if (softs->flags & AAC_FLAGS_SG_64BIT)
2423 softs->aac_sg_tablesize = (AAC_FIB_DATASIZE -
2428 softs->aac_sg_tablesize = (AAC_FIB_DATASIZE -
2434 if ((softs->flags & AAC_FLAGS_RAW_IO) &&
2435 (softs->flags & AAC_FLAGS_ARRAY_64BIT)) {
2436 softs->flags |= AAC_FLAGS_LBA_64BIT;
2437 AACDB_PRINT(softs, CE_NOTE, "!Enable 64-bit array");
2439 softs->buf_dma_attr.dma_attr_sgllen = softs->aac_sg_tablesize;
2440 softs->buf_dma_attr.dma_attr_maxxfer = softs->aac_max_sectors << 9;
2451 softs->buf_dma_attr.dma_attr_count_max =
2452 softs->buf_dma_attr.dma_attr_maxxfer - 1;
2455 if (softs->flags & AAC_FLAGS_RAW_IO)
2456 softs->aac_cmd_fib = aac_cmd_fib_rawio;
2457 else if (softs->flags & AAC_FLAGS_SG_64BIT)
2458 softs->aac_cmd_fib = aac_cmd_fib_brw64;
2460 softs->aac_cmd_fib = aac_cmd_fib_brw;
2461 softs->aac_cmd_fib_scsi = (softs->flags & AAC_FLAGS_SG_64BIT) ? \
2465 softs->slen = sizeof (struct scsi_arq_status);
2466 if ((softs->flags & AAC_FLAGS_LBA_64BIT) &&
2467 softs->slen < AAC_ARQ64_LENGTH)
2468 softs->slen = AAC_ARQ64_LENGTH;
2470 AACDB_PRINT(softs, CE_NOTE,
2472 softs->aac_max_fibs, softs->aac_max_fib_size,
2473 softs->aac_max_sectors, softs->aac_sg_tablesize);
2479 aac_fsa_rev(struct aac_softstate *softs, struct FsaRev *fsarev0,
2482 ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
2497 aac_get_adapter_info(struct aac_softstate *softs,
2500 struct aac_cmd *acp = &softs->sync_ac;
2507 (void) aac_sync_fib_slot_bind(softs, acp);
2512 if (aac_sync_fib(softs, RequestAdapterInfo,
2514 AACDB_PRINT(softs, CE_WARN, "RequestAdapterInfo failed");
2528 aac_fsa_rev(softs, &ainfp->KernelRevision,
2530 aac_fsa_rev(softs, &ainfp->MonitorRevision,
2532 aac_fsa_rev(softs, &ainfp->HardwareRevision,
2534 aac_fsa_rev(softs, &ainfp->BIOSRevision,
2544 if (!(softs->support_opt &
2546 AACDB_PRINT(softs, CE_WARN,
2552 if (aac_sync_fib(softs, RequestSupplementAdapterInfo,
2555 AACDB_PRINT(softs, CE_WARN,
2574 aac_fsa_rev(softs, &sinfp->FlashFirmwareRevision,
2577 aac_fsa_rev(softs, &sinfp->FlashFirmwareBootRevision,
2595 aac_sync_fib_slot_release(softs, acp);
2600 aac_get_bus_info(struct aac_softstate *softs, uint32_t *bus_max,
2603 struct aac_cmd *acp = &softs->sync_ac;
2613 (void) aac_sync_fib_slot_bind(softs, acp);
2622 rval = aac_sync_fib(softs, ContainerCommand,
2626 AACDB_PRINT(softs, CE_WARN,
2646 rval = aac_sync_fib(softs, ContainerCommand,
2652 AACDB_PRINT(softs, CE_WARN, "GetBusInfo command fail");
2660 aac_sync_fib_slot_release(softs, acp);
2703 aac_handle_adapter_config_issues(struct aac_softstate *softs)
2705 struct aac_cmd *acp = &softs->sync_ac;
2716 (void) aac_sync_fib_slot_bind(softs, acp);
2728 rval = aac_sync_fib(softs, ContainerCommand,
2744 rval = aac_sync_fib(softs, ContainerCommand,
2768 aac_sync_fib_slot_release(softs, acp);
2776 aac_common_attach(struct aac_softstate *softs)
2782 DBCALLED(softs, 1);
2791 while (AAC_OUTB_GET(softs) != 0xfffffffful)
2798 status = AAC_FWSTATUS_GET(softs);
2802 AAC_BUSYWAIT(AAC_FWSTATUS_GET(softs) & AAC_KERNEL_UP_AND_RUNNING, i);
2805 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2806 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2811 if (aac_check_firmware(softs) == AACERR) {
2812 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2813 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2818 if (aac_register_intrs(softs) == AACERR) {
2825 if (softs->comm_space_dma_handle == NULL) {
2826 if (aac_alloc_comm_space(softs) != AACOK)
2829 if (aac_setup_comm_space(softs) != AACOK) {
2831 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2832 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2837 if (aac_get_fw_debug_buffer(softs) != AACOK)
2842 if ((softs->total_slots == 0) && (aac_create_slots(softs) != AACOK)) {
2846 AACDB_PRINT(softs, CE_NOTE, "%d slots allocated", softs->total_slots);
2849 if (softs->total_fibs < softs->total_slots) {
2850 aac_alloc_fibs(softs);
2851 if (softs->total_fibs == 0)
2853 AACDB_PRINT(softs, CE_NOTE, "%d fibs allocated",
2854 softs->total_fibs);
2857 AAC_STATUS_CLR(softs, ~0); /* Clear out all interrupts */
2858 AAC_ENABLE_INTR(softs); /* Enable the interrupts we can handle */
2860 if (aac_get_adapter_info(softs, NULL, &sinf) == AACOK) {
2861 softs->feature_bits = sinf.FeatureBits;
2862 softs->support_opt2 = sinf.SupportedOptions2;
2865 if (CARD_IS_UNKNOWN(softs->card)) {
2873 AACDB_PRINT(softs, CE_NOTE, "sinf.AdapterTypeText = "
2892 (void *)strncpy(softs->vendor_name, p0,
2894 (void *)strncpy(softs->product_name, p1,
2900 (void *)strncpy(softs->product_name,
2916 softs->vendor_name, softs->product_name,
2917 softs->vendid, softs->devid, softs->subvendid, softs->subsysid,
2918 softs->pci_mem_base_paddr);
2921 if (aac_handle_adapter_config_issues(softs) != AACMPE_OK) {
2923 aac_fm_ereport(softs, DDI_FM_DEVICE_NO_RESPONSE);
2924 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2929 if (aac_probe_containers(softs) != AACOK) {
2936 if (softs->feature_bits & AAC_FEATURE_SUPPORTED_JBOD) {
2937 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, softs->devinfo_p,
2940 AACDB_PRINT(softs, CE_NOTE,
2942 softs->flags |= AAC_FLAGS_JBOD;
2949 if (softs->flags & (AAC_FLAGS_NONDASD | AAC_FLAGS_JBOD)) {
2954 if (aac_get_bus_info(softs, &bus_max, &tgt_max) != AACOK) {
2958 AACDB_PRINT(softs, CE_NOTE, "bus_max=%d, tgt_max=%d",
2960 if (bus_max != softs->bus_max || tgt_max != softs->tgt_max) {
2961 if (softs->state & AAC_STATE_RESET) {
2966 softs->bus_max = bus_max;
2967 softs->tgt_max = tgt_max;
2968 if (softs->nondasds) {
2969 kmem_free(softs->nondasds, AAC_MAX_PD(softs) * \
2972 softs->nondasds = kmem_zalloc(AAC_MAX_PD(softs) * \
2976 for (bus = 0; bus < softs->bus_max; bus++) {
2977 for (tgt = 0; tgt < softs->tgt_max; tgt++) {
2979 &softs->nondasds[index++];
2989 if (aac_check_dma_handle(softs->comm_space_dma_handle) != DDI_SUCCESS) {
2990 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2994 if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
2995 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
2999 for (i = 0; i < softs->total_slots; i++) {
3000 if (aac_check_dma_handle(softs->io_slot[i].fib_dma_handle) !=
3002 ddi_fm_service_impact(softs->devinfo_p,
3010 if (softs->state & AAC_STATE_RESET)
3012 if (softs->nondasds) {
3013 kmem_free(softs->nondasds, AAC_MAX_PD(softs) * \
3015 softs->nondasds = NULL;
3017 if (softs->total_fibs > 0)
3018 aac_destroy_fibs(softs);
3019 if (softs->total_slots > 0)
3020 aac_destroy_slots(softs);
3021 if (softs->comm_space_dma_handle)
3022 aac_free_comm_space(softs);
3030 aac_common_detach(struct aac_softstate *softs)
3032 DBCALLED(softs, 1);
3034 aac_unregister_intrs(softs);
3036 mutex_enter(&softs->io_lock);
3037 (void) aac_shutdown(softs);
3039 if (softs->nondasds) {
3040 kmem_free(softs->nondasds, AAC_MAX_PD(softs) * \
3042 softs->nondasds = NULL;
3044 aac_destroy_fibs(softs);
3045 aac_destroy_slots(softs);
3046 aac_free_comm_space(softs);
3047 mutex_exit(&softs->io_lock);
3055 aac_sync_mbcommand(struct aac_softstate *softs, uint32_t cmd,
3066 AAC_MAILBOX_SET(softs, cmd, arg0, arg1, arg2, arg3);
3069 AAC_STATUS_CLR(softs, AAC_DB_SYNC_COMMAND);
3072 AAC_NOTIFY(softs, AAC_DB_SYNC_COMMAND);
3076 AAC_BUSYWAIT(AAC_STATUS_GET(softs) & AAC_DB_SYNC_COMMAND, timeout);
3078 AACDB_PRINT(softs, CE_WARN,
3080 AAC_IMMEDIATE_TIMEOUT, AAC_FWSTATUS_GET(softs));
3085 AAC_STATUS_CLR(softs, AAC_DB_SYNC_COMMAND);
3088 status = AAC_MAILBOX_GET(softs, 0);
3092 AACDB_PRINT(softs, CE_WARN,
3104 aac_sync_fib(struct aac_softstate *softs, uint16_t cmd, uint16_t fibsize)
3106 struct aac_cmd *acp = &softs->sync_ac;
3109 if (softs->state & AAC_STATE_INTR)
3122 aac_cmd_fib_header(softs, acp, cmd);
3127 aac_start_io(softs, acp);
3129 if (softs->state & AAC_STATE_INTR)
3130 return (aac_do_sync_io(softs, acp));
3132 return (aac_do_poll_io(softs, acp));
3202 aac_fib_enqueue(struct aac_softstate *softs, int queue, uint32_t fib_addr,
3205 ddi_dma_handle_t dma = softs->comm_space_dma_handle;
3206 ddi_acc_handle_t acc = softs->comm_space_acc_handle;
3209 DBCALLED(softs, 2);
3214 (void) ddi_dma_sync(dma, (uintptr_t)softs->qtablep->qt_qindex[queue] - \
3215 (uintptr_t)softs->comm_space, sizeof (uint32_t) * 2,
3218 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
3223 &softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX]);
3225 &softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX]);
3239 ddi_put32(acc, &((softs->qentries[queue] + pi)->aq_fib_size), fib_size);
3240 ddi_put32(acc, &((softs->qentries[queue] + pi)->aq_fib_addr), fib_addr);
3241 (void) ddi_dma_sync(dma, (uintptr_t)(softs->qentries[queue] + pi) - \
3242 (uintptr_t)softs->comm_space, sizeof (struct aac_queue_entry),
3246 ddi_put32(acc, &softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX],
3249 (uintptr_t)&softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX] - \
3250 (uintptr_t)softs->comm_space, sizeof (uint32_t),
3254 AAC_NOTIFY(softs, aac_qinfo[queue].notify);
3263 aac_fib_dequeue(struct aac_softstate *softs, int queue, int *idxp)
3265 ddi_acc_handle_t acc = softs->comm_space_acc_handle;
3266 ddi_dma_handle_t dma = softs->comm_space_dma_handle;
3270 DBCALLED(softs, 2);
3275 (void) ddi_dma_sync(dma, (uintptr_t)softs->qtablep->qt_qindex[queue] - \
3276 (uintptr_t)softs->comm_space, sizeof (uint32_t) * 2,
3279 &softs->qtablep->qt_qindex[queue][AAC_PRODUCER_INDEX]);
3281 &softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX]);
3302 (void) ddi_dma_sync(dma, (uintptr_t)(softs->qentries[queue] + pi) - \
3303 (uintptr_t)softs->comm_space, sizeof (struct aac_queue_entry),
3306 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
3314 &(softs->qentries[queue] + ci)->aq_fib_addr);
3320 &(softs->qentries[queue] + ci)->aq_fib_addr) / AAC_FIB_SIZE;
3329 ddi_put32(acc, &softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX],
3332 (uintptr_t)&softs->qtablep->qt_qindex[queue][AAC_CONSUMER_INDEX] - \
3333 (uintptr_t)softs->comm_space, sizeof (uint32_t),
3337 AAC_NOTIFY(softs, aac_qinfo[queue].notify);
3342 aac_get_mntinfo(struct aac_softstate *softs, int cid)
3344 ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
3345 struct aac_fib *fibp = softs->sync_ac.slotp->fibp;
3350 (softs->flags & AAC_FLAGS_LBA_64BIT) ?
3355 if (aac_sync_fib(softs, ContainerCommand,
3357 AACDB_PRINT(softs, CE_WARN, "Error probe container %d", cid);
3368 aac_get_container_count(struct aac_softstate *softs, int *count)
3374 (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
3375 acc = softs->sync_ac.slotp->fib_acc_handle;
3377 if ((mir = aac_get_mntinfo(softs, 0)) == NULL) {
3383 AACDB_PRINT(softs, CE_CONT,
3391 aac_sync_fib_slot_release(softs, &softs->sync_ac);
3396 aac_get_container_uid(struct aac_softstate *softs, uint32_t cid, uint32_t *uid)
3398 ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
3400 &softs->sync_ac.slotp->fibp->data[0];
3407 if (aac_sync_fib(softs, ContainerCommand,
3421 aac_get_container_info(struct aac_softstate *softs, int cid)
3423 ddi_acc_handle_t acc = softs->sync_ac.slotp->fib_acc_handle;
3429 rval_uid = aac_get_container_uid(softs, cid, &uid);
3432 if ((mir = aac_get_mntinfo(softs, cid)) == NULL) {
3433 AACDB_PRINT(softs, CE_CONT,
3440 AACDB_PRINT(softs, CE_CONT,
3450 aac_probe_container(struct aac_softstate *softs, uint32_t cid)
3453 struct aac_container *dvp = &softs->containers[cid];
3457 (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
3458 acc = softs->sync_ac.slotp->fib_acc_handle;
3461 if ((mir = aac_get_container_info(softs, cid)) == NULL) {
3468 AACDB_PRINT(softs, CE_NOTE,
3480 size = AAC_MIR_SIZE(softs, acc, mir);
3484 AACDB_PRINT(softs, CE_WARN,
3491 AACDB_PRINT(softs, CE_NOTE,
3498 AACDB_PRINT(softs, CE_NOTE,
3520 aac_sync_fib_slot_release(softs, &softs->sync_ac);
3529 aac_probe_containers(struct aac_softstate *softs)
3534 count = softs->container_count;
3535 if (aac_get_container_count(softs, &count) == AACERR)
3539 enum aac_cfg_event event = aac_probe_container(softs, i);
3542 (void) aac_handle_dr(softs, i, -1, event);
3547 if (count < softs->container_count) {
3550 for (dvp = &softs->containers[count];
3551 dvp < &softs->containers[softs->container_count]; dvp++) {
3554 AACDB_PRINT(softs, CE_NOTE, ">>> Container %d deleted",
3557 (void) aac_handle_dr(softs, dvp->cid, -1,
3562 softs->container_count = count;
3563 AACDB_PRINT(softs, CE_CONT, "?Total %d container(s) found", total);
3568 aac_probe_jbod(struct aac_softstate *softs, int tgt, int event)
3571 ASSERT(tgt < AAC_MAX_DEV(softs));
3573 dvp = AAC_DEV(softs, tgt);
3577 AACDB_PRINT(softs, CE_NOTE,
3583 AACDB_PRINT(softs, CE_NOTE,
3590 (void) aac_handle_dr(softs, tgt, 0, event);
3595 aac_alloc_comm_space(struct aac_softstate *softs)
3603 softs->devinfo_p,
3604 &softs->addr_dma_attr,
3607 &softs->comm_space_dma_handle) != DDI_SUCCESS) {
3608 AACDB_PRINT(softs, CE_WARN,
3613 softs->comm_space_dma_handle,
3615 &softs->acc_attr,
3619 (caddr_t *)&softs->comm_space,
3621 &softs->comm_space_acc_handle) != DDI_SUCCESS) {
3622 AACDB_PRINT(softs, CE_WARN,
3627 softs->comm_space_dma_handle,
3629 (caddr_t)softs->comm_space,
3636 AACDB_PRINT(softs, CE_WARN,
3640 softs->comm_space_phyaddr = cookie.dmac_address;
3644 if (softs->comm_space_acc_handle) {
3645 ddi_dma_mem_free(&softs->comm_space_acc_handle);
3646 softs->comm_space_acc_handle = NULL;
3648 if (softs->comm_space_dma_handle) {
3649 ddi_dma_free_handle(&softs->comm_space_dma_handle);
3650 softs->comm_space_dma_handle = NULL;
3656 aac_free_comm_space(struct aac_softstate *softs)
3659 (void) ddi_dma_unbind_handle(softs->comm_space_dma_handle);
3660 ddi_dma_mem_free(&softs->comm_space_acc_handle);
3661 softs->comm_space_acc_handle = NULL;
3662 ddi_dma_free_handle(&softs->comm_space_dma_handle);
3663 softs->comm_space_dma_handle = NULL;
3664 softs->comm_space_phyaddr = NULL;
3672 aac_setup_comm_space(struct aac_softstate *softs)
3674 ddi_dma_handle_t dma = softs->comm_space_dma_handle;
3675 ddi_acc_handle_t acc = softs->comm_space_acc_handle;
3680 comm_space_phyaddr = softs->comm_space_phyaddr;
3683 initp = &softs->comm_space->init_data;
3690 if (softs->flags & AAC_FLAGS_RAW_IO) {
3693 if (softs->flags & AAC_FLAGS_NEW_COMM)
3703 ddi_put32(acc, &initp->MaxIoCommands, softs->aac_max_fibs);
3705 (softs->aac_max_sectors << 9));
3706 ddi_put32(acc, &initp->MaxFibSize, softs->aac_max_fib_size);
3733 softs->qtablep = (struct aac_queue_table *) \
3734 ((char *)&softs->comm_space->qtable + qoffset);
3739 ddi_put32(acc, &softs->qtablep-> \
3742 ddi_put32(acc, &softs->qtablep-> \
3745 ddi_put32(acc, &softs->qtablep-> \
3748 ddi_put32(acc, &softs->qtablep-> \
3751 ddi_put32(acc, &softs->qtablep-> \
3754 ddi_put32(acc, &softs->qtablep-> \
3757 ddi_put32(acc, &softs->qtablep-> \
3760 ddi_put32(acc, &softs->qtablep-> \
3763 ddi_put32(acc, &softs->qtablep-> \
3766 ddi_put32(acc, &softs->qtablep-> \
3769 ddi_put32(acc, &softs->qtablep-> \
3772 ddi_put32(acc, &softs->qtablep-> \
3775 ddi_put32(acc, &softs->qtablep-> \
3778 ddi_put32(acc, &softs->qtablep-> \
3781 ddi_put32(acc, &softs->qtablep-> \
3784 ddi_put32(acc, &softs->qtablep-> \
3789 softs->qentries[AAC_HOST_NORM_CMD_Q] =
3790 &softs->qtablep->qt_HostNormCmdQueue[0];
3791 softs->qentries[AAC_HOST_HIGH_CMD_Q] =
3792 &softs->qtablep->qt_HostHighCmdQueue[0];
3793 softs->qentries[AAC_ADAP_NORM_CMD_Q] =
3794 &softs->qtablep->qt_AdapNormCmdQueue[0];
3795 softs->qentries[AAC_ADAP_HIGH_CMD_Q] =
3796 &softs->qtablep->qt_AdapHighCmdQueue[0];
3797 softs->qentries[AAC_HOST_NORM_RESP_Q] =
3798 &softs->qtablep->qt_HostNormRespQueue[0];
3799 softs->qentries[AAC_HOST_HIGH_RESP_Q] =
3800 &softs->qtablep->qt_HostHighRespQueue[0];
3801 softs->qentries[AAC_ADAP_NORM_RESP_Q] =
3802 &softs->qtablep->qt_AdapNormRespQueue[0];
3803 softs->qentries[AAC_ADAP_HIGH_RESP_Q] =
3804 &softs->qtablep->qt_AdapHighRespQueue[0];
3809 if (aac_sync_mbcommand(softs, AAC_MONKER_INITSTRUCT,
3813 AACDB_PRINT(softs, CE_WARN,
3822 aac_vendor_id(struct aac_softstate *softs, uchar_t *buf)
3825 bcopy(softs->vendor_name, buf, strlen(softs->vendor_name));
3830 aac_product_id(struct aac_softstate *softs, uchar_t *buf)
3833 bcopy(softs->product_name, buf, strlen(softs->product_name));
3841 aac_lun_serialno(struct aac_softstate *softs, int tgt, uchar_t *buf)
3848 uid = softs->containers[tgt].uid;
3861 aac_inquiry(struct aac_softstate *softs, struct scsi_pkt *pkt,
3912 (void) aac_lun_serialno(softs, tgt, sp);
3939 sp = aac_vendor_id(softs, sp);
3940 sp = aac_product_id(softs, sp);
3941 sp = aac_lun_serialno(softs, tgt, sp);
3971 (void) aac_vendor_id(softs, (uchar_t *)inqp->inq_vid);
3972 (void) aac_product_id(softs, (uchar_t *)inqp->inq_pid);
3989 aac_mode_sense(struct aac_softstate *softs, struct scsi_pkt *pkt,
4030 if (softs->flags & AAC_FLAGS_LBA_64BIT) {
4038 if (softs->flags & AAC_FLAGS_LBA_64BIT) {
4107 softs->flags & AAC_FLAGS_LBA_64BIT) {
4148 struct aac_softstate *softs = AAC_TRAN2SOFTS(tran);
4150 int ctl = ddi_get_instance(softs->devinfo_p);
4156 DBCALLED(softs, 2);
4163 if (aac_find_child(softs, tgt, lun) != NULL) {
4176 mutex_enter(&softs->io_lock);
4177 if (tgt >= AAC_MAX_DEV(softs)) {
4178 AACDB_PRINT_TRAN(softs,
4180 mutex_exit(&softs->io_lock);
4185 dvp = (struct aac_device *)&softs->containers[tgt];
4187 AACDB_PRINT_TRAN(softs, "aac_tran_tgt_init: c%dt%dL%d",
4189 mutex_exit(&softs->io_lock);
4197 if (softs->containers[tgt].dev.dip == NULL &&
4199 softs->containers[tgt].dev.dip = tgt_dip;
4201 dvp = (struct aac_device *)&softs->nondasds[AAC_PD(tgt)];
4208 if (softs->nondasds[AAC_PD(tgt)].dev.dip == NULL &&
4210 softs->nondasds[AAC_PD(tgt)].dev.dip = tgt_dip;
4213 if (softs->flags & AAC_FLAGS_BRKUP) {
4221 AACDB_PRINT(softs, CE_NOTE,
4224 mutex_exit(&softs->io_lock);
4236 struct aac_softstate *softs = SD2AAC(sd);
4239 mutex_enter(&softs->io_lock);
4241 if (softs->containers[tgt].dev.dip == tgt_dip)
4242 softs->containers[tgt].dev.dip = NULL;
4244 if (softs->nondasds[AAC_PD(tgt)].dev.dip == tgt_dip)
4245 softs->nondasds[AAC_PD(tgt)].dev.dip = NULL;
4246 softs->nondasds[AAC_PD(tgt)].dev.flags &= ~AAC_DFLAG_VALID;
4248 mutex_exit(&softs->io_lock);
4259 aac_check_adapter_health(struct aac_softstate *softs)
4263 rval = PCI_MEM_GET32(softs, AAC_OMR0);
4278 aac_abort_iocmd(struct aac_softstate *softs, struct aac_cmd *acp,
4290 AACDB_PRINT(softs, CE_NOTE, "CMD_TIMEOUT: acp=0x%p",
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",
4304 aac_set_pkt_reason(softs, acp, CMD_ABORTED,
4309 aac_end_io(softs, acp);
4317 aac_abort_iocmds(struct aac_softstate *softs, int iocmd, struct scsi_pkt *pkt,
4340 if (AAC_DEV_IS_VALID(&softs->containers[i].dev))
4341 softs->containers[i].reset = 1;
4343 while ((acp = softs->q_busy.q_head) != NULL)
4344 aac_abort_iocmd(softs, acp, reason);
4351 aac_abort_iocmd(softs, ac_arg, reason);
4353 while ((acp = softs->q_wait[i].q_head) != NULL)
4354 aac_abort_iocmd(softs, acp, reason);
4367 struct aac_softstate *softs = arg;
4369 mutex_enter(&softs->io_lock);
4370 if (softs->ndrains) {
4371 softs->drain_timeid = 0;
4376 if ((softs->bus_throttle[AAC_CMDQ_ASYNC] > 0 ||
4377 softs->bus_ncmds[AAC_CMDQ_ASYNC] == 0) &&
4378 (softs->bus_throttle[AAC_CMDQ_SYNC] > 0 ||
4379 softs->bus_ncmds[AAC_CMDQ_SYNC] == 0))
4380 cv_broadcast(&softs->drain_cv);
4382 softs->drain_timeid = timeout(aac_check_drain, softs,
4385 mutex_exit(&softs->io_lock);
4393 aac_start_drain(struct aac_softstate *softs)
4395 if (softs->ndrains == 0) {
4396 ASSERT(softs->drain_timeid == 0);
4397 softs->drain_timeid = timeout(aac_check_drain, softs,
4400 softs->ndrains++;
4408 aac_stop_drain(struct aac_softstate *softs)
4410 softs->ndrains--;
4411 if (softs->ndrains == 0) {
4412 if (softs->drain_timeid != 0) {
4413 timeout_id_t tid = softs->drain_timeid;
4415 softs->drain_timeid = 0;
4416 mutex_exit(&softs->io_lock);
4418 mutex_enter(&softs->io_lock);
4433 aac_reset_adapter(struct aac_softstate *softs)
4439 DBCALLED(softs, 1);
4441 ASSERT(softs->state & AAC_STATE_RESET);
4443 ddi_fm_acc_err_clear(softs->pci_mem_handle, DDI_FME_VER0);
4445 AAC_DISABLE_INTR(softs);
4447 health = aac_check_adapter_health(softs);
4449 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
4453 (void) aac_shutdown(softs);
4456 if ((aac_sync_mbcommand(softs, AAC_IOP_RESET, 0, 0, 0, 0,
4473 PCI_MEM_PUT32(softs, AAC_IRCSR, AAC_IRCSR_CORES_RST);
4491 (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
4492 acc = softs->sync_ac.slotp->fib_acc_handle;
4494 fibp = softs->sync_ac.slotp->fibp;
4504 (void) aac_sync_fib(softs, ContainerCommand,
4506 aac_sync_fib_slot_release(softs, &softs->sync_ac);
4508 if (aac_check_adapter_health(softs) != 0)
4509 ddi_fm_service_impact(softs->devinfo_p,
4525 if (aac_common_attach(softs) != AACOK)
4531 AAC_ENABLE_INTR(softs);
4536 aac_set_throttle(struct aac_softstate *softs, struct aac_device *dvp, int q,
4543 if ((softs->state & AAC_STATE_QUIESCED) || softs->ndrains)
4549 aac_hold_bus(struct aac_softstate *softs, int iocmds)
4556 softs->bus_throttle[q] = 0;
4558 aac_set_throttle(softs,
4559 &softs->containers[i].dev, q, 0);
4560 for (i = 0; i < AAC_MAX_PD(softs); i++)
4561 aac_set_throttle(softs,
4562 &softs->nondasds[i].dev, q, 0);
4568 aac_unhold_bus(struct aac_softstate *softs, int iocmds)
4579 if (q == AAC_CMDQ_ASYNC && ((softs->state &
4580 AAC_STATE_QUIESCED) || softs->ndrains))
4583 max_throttle = softs->total_slots -
4586 max_throttle = softs->total_slots - 1;
4587 softs->bus_throttle[q] = max_throttle;
4589 aac_set_throttle(softs,
4590 &softs->containers[i].dev,
4592 for (i = 0; i < AAC_MAX_PD(softs); i++)
4593 aac_set_throttle(softs, &softs->nondasds[i].dev,
4600 aac_do_reset(struct aac_softstate *softs)
4605 softs->state |= AAC_STATE_RESET;
4606 health = aac_check_adapter_health(softs);
4613 int sync_cmds = softs->bus_ncmds[AAC_CMDQ_SYNC];
4614 int async_cmds = softs->bus_ncmds[AAC_CMDQ_ASYNC];
4627 aac_hold_bus(softs, AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC);
4632 intr_handler = (softs->flags & AAC_FLAGS_NEW_COMM) ?
4634 while ((softs->bus_ncmds[AAC_CMDQ_SYNC] ||
4635 softs->bus_ncmds[AAC_CMDQ_ASYNC]) && timeout) {
4637 (void) intr_handler(softs);
4640 aac_unhold_bus(softs, AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC);
4642 if (softs->bus_ncmds[AAC_CMDQ_SYNC] == 0 &&
4643 softs->bus_ncmds[AAC_CMDQ_ASYNC] == 0) {
4647 } else if (softs->bus_ncmds[AAC_CMDQ_SYNC] < sync_cmds ||
4648 softs->bus_ncmds[AAC_CMDQ_ASYNC] < async_cmds) {
4659 if ((rval = aac_reset_adapter(softs)) == AAC_IOP_RESET_FAILED)
4660 softs->state |= AAC_STATE_DEAD;
4663 softs->state &= ~AAC_STATE_RESET;
4670 struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
4673 DBCALLED(softs, 1);
4680 mutex_enter(&softs->io_lock);
4681 switch (rval = aac_do_reset(softs)) {
4683 aac_abort_iocmds(softs, AAC_IOCMD_OUTSTANDING | AAC_IOCMD_ASYNC,
4685 aac_start_waiting_io(softs);
4689 aac_abort_iocmds(softs, AAC_IOCMD_ALL, NULL, CMD_RESET);
4692 aac_start_waiting_io(softs);
4694 mutex_exit(&softs->io_lock);
4696 aac_drain_comp_q(softs);
4703 struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
4705 DBCALLED(softs, 1);
4707 mutex_enter(&softs->io_lock);
4708 aac_abort_iocmds(softs, 0, pkt, CMD_ABORTED);
4709 mutex_exit(&softs->io_lock);
4711 aac_drain_comp_q(softs);
4742 aac_unknown_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
4744 AACDB_PRINT(softs, CE_CONT, "SCMD 0x%x not supported",
4748 aac_soft_callback(softs, acp);
4755 aac_tran_start_ld(struct aac_softstate *softs, struct aac_cmd *acp)
4771 aac_inquiry(softs, pkt, cdbp, bp);
4772 aac_soft_callback(softs, acp);
4796 aac_soft_callback(softs, acp);
4818 aac_soft_callback(softs, acp);
4820 aac_unknown_scmd(softs, acp);
4827 if (softs->flags & AAC_FLAGS_RAW_IO) {
4834 AACDB_PRINT(softs, CE_WARN, "64-bit LBA not supported");
4835 aac_unknown_scmd(softs, acp);
4865 rval = aac_do_io(softs, acp);
4875 aac_soft_callback(softs, acp);
4880 aac_soft_callback(softs, acp);
4896 aac_mode_sense(softs, pkt, cdbp, bp, capacity);
4897 aac_soft_callback(softs, acp);
4903 if (softs->support_opt2 & AAC_SUPPORTED_POWER_MANAGEMENT) {
4906 rval = aac_do_io(softs, acp);
4922 aac_soft_callback(softs, acp);
4930 rval = aac_do_io(softs, acp);
4936 aac_soft_callback(softs, acp);
4941 aac_unknown_scmd(softs, acp);
4952 struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
4957 DBCALLED(softs, 2);
4982 ddi_fm_service_impact(softs->devinfo_p,
4990 mutex_enter(&softs->io_lock);
4991 AACDB_PRINT_SCMD(softs, acp);
4993 !(softs->state & AAC_STATE_DEAD)) {
4996 rval = aac_tran_start_ld(softs, acp);
5000 rval = aac_do_io(softs, acp);
5005 if (!(softs->state & AAC_STATE_DEAD)) {
5006 AACDB_PRINT_TRAN(softs,
5011 AACDB_PRINT(softs, CE_WARN,
5019 mutex_exit(&softs->io_lock);
5026 struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
5030 DBCALLED(softs, 2);
5034 AACDB_PRINT(softs, CE_WARN,
5039 mutex_enter(&softs->io_lock);
5040 dvp = AAC_DEV(softs, ap->a_target);
5042 mutex_exit(&softs->io_lock);
5043 AACDB_PRINT_TRAN(softs, "Bad target t%dL%d to getcap",
5057 rval = softs->dma_max;
5063 mutex_exit(&softs->io_lock);
5065 AACDB_PRINT_TRAN(softs, "GetCap> %s t%dL%d: rval=%d",
5074 struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
5078 DBCALLED(softs, 2);
5082 AACDB_PRINT(softs, CE_WARN,
5087 mutex_enter(&softs->io_lock);
5088 dvp = AAC_DEV(softs, ap->a_target);
5090 mutex_exit(&softs->io_lock);
5091 AACDB_PRINT_TRAN(softs, "Bad target t%dL%d to setcap",
5109 mutex_exit(&softs->io_lock);
5111 AACDB_PRINT_TRAN(softs, "SetCap> %s t%dL%d val=%d: rval=%d",
5133 aac_cmd_dma_alloc(struct aac_softstate *softs, struct aac_cmd *acp,
5153 AACDB_PRINT(softs, CE_WARN,
5157 AACDB_PRINT(softs, CE_WARN, "Nothing to transfer");
5187 rval = ddi_dma_alloc_handle(softs->devinfo_p,
5188 &softs->buf_dma_attr, cb, arg,
5191 AACDB_PRINT(softs, CE_WARN,
5206 AACDB_PRINT_TRAN(softs,
5214 &softs->acc_attr, DDI_DMA_STREAMING,
5218 AACDB_PRINT(softs, CE_NOTE,
5239 AACDB_PRINT(softs, CE_WARN,
5244 AACDB_PRINT_TRAN(softs, "buf bind, %d seg(s)",
5250 AACDB_PRINT_TRAN(softs, "buf bind, %d seg(s)",
5258 AACDB_PRINT(softs, CE_WARN,
5264 AACDB_PRINT(softs, CE_WARN,
5269 AACDB_PRINT(softs, CE_WARN,
5275 AACDB_PRINT(softs, CE_WARN,
5283 if (acp->left_cookien > softs->aac_sg_tablesize) {
5284 AACDB_PRINT(softs, CE_NOTE, "large cookiec received %d",
5298 AACDB_PRINT(softs, CE_WARN,
5323 if (acp->bcount > softs->buf_dma_attr.dma_attr_maxxfer) {
5324 AACDB_PRINT(softs, CE_NOTE,
5346 AACDB_PRINT_TRAN(softs,
5364 struct aac_softstate *softs = AAC_TRAN2SOFTS(ap->a_hba_tran);
5367 DBCALLED(softs, 2);
5374 slen = (statuslen > softs->slen) ? statuslen : softs->slen;
5375 pkt = scsi_hba_pkt_alloc(softs->devinfo_p, ap, cmdlen,
5378 AACDB_PRINT(softs, CE_WARN, "Alloc scsi pkt failed");
5386 acp->dvp = &softs->containers[ap->a_target].dev;
5387 acp->aac_cmd_fib = softs->aac_cmd_fib;
5390 _NOTE(ASSUMING_PROTECTED(softs->nondasds))
5392 acp->dvp = &softs->nondasds[AAC_PD(ap->a_target)].dev;
5393 acp->aac_cmd_fib = softs->aac_cmd_fib_scsi;
5401 if (aac_cmd_dma_alloc(softs, acp, bp, flags, callback, arg) == AACOK)
5441 aac_do_quiesce(struct aac_softstate *softs)
5443 aac_hold_bus(softs, AAC_IOCMD_ASYNC);
5444 if (softs->bus_ncmds[AAC_CMDQ_ASYNC]) {
5445 aac_start_drain(softs);
5447 if (cv_wait_sig(&softs->drain_cv,
5448 &softs->io_lock) == 0) {
5450 aac_stop_drain(softs);
5451 aac_unhold_bus(softs, AAC_IOCMD_ASYNC);
5452 aac_start_waiting_io(softs);
5455 } while (softs->bus_ncmds[AAC_CMDQ_ASYNC]);
5456 aac_stop_drain(softs);
5459 softs->state |= AAC_STATE_QUIESCED;
5466 struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
5469 DBCALLED(softs, 1);
5471 mutex_enter(&softs->io_lock);
5472 if (aac_do_quiesce(softs) == AACOK)
5476 mutex_exit(&softs->io_lock);
5481 aac_do_unquiesce(struct aac_softstate *softs)
5483 softs->state &= ~AAC_STATE_QUIESCED;
5484 aac_unhold_bus(softs, AAC_IOCMD_ASYNC);
5486 aac_start_waiting_io(softs);
5493 struct aac_softstate *softs = AAC_DIP2SOFTS(dip);
5496 DBCALLED(softs, 1);
5498 mutex_enter(&softs->io_lock);
5499 if (aac_do_unquiesce(softs) == AACOK)
5503 mutex_exit(&softs->io_lock);
5508 aac_hba_setup(struct aac_softstate *softs)
5513 hba_tran = scsi_hba_tran_alloc(softs->devinfo_p, SCSI_HBA_CANSLEEP);
5516 hba_tran->tran_hba_private = softs;
5532 rval = scsi_hba_attach_setup(softs->devinfo_p, &softs->buf_dma_attr,
5536 AACDB_PRINT(softs, CE_WARN, "aac_hba_setup failed");
5540 softs->hba_tran = hba_tran;
5552 aac_cmd_fib_header(struct aac_softstate *softs, struct aac_cmd *acp,
5577 ddi_put16(acc, &fibp->Header.SenderSize, softs->aac_max_fib_size);
5587 aac_cmd_fib_rawio(struct aac_softstate *softs, struct aac_cmd *acp)
5599 aac_cmd_fib_header(softs, acp, RawIo);
5627 aac_cmd_fib_brw64(struct aac_softstate *softs, struct aac_cmd *acp)
5639 aac_cmd_fib_header(softs, acp, ContainerCommand64);
5667 aac_cmd_fib_brw(struct aac_softstate *softs, struct aac_cmd *acp)
5695 aac_cmd_fib_header(softs, acp, ContainerCommand);
5716 aac_cmd_fib_copy(struct aac_softstate *softs, struct aac_cmd *acp)
5730 aac_cmd_fib_sync(struct aac_softstate *softs, struct aac_cmd *acp)
5738 aac_cmd_fib_header(softs, acp, ContainerCommand);
5750 aac_cmd_fib_startstop(struct aac_softstate *softs, struct aac_cmd *acp)
5759 aac_cmd_fib_header(softs, acp, ContainerCommand);
5807 aac_cmd_fib_scsi32(struct aac_softstate *softs, struct aac_cmd *acp)
5819 aac_cmd_fib_header(softs, acp, ScsiPortCommand);
5834 aac_cmd_fib_scsi64(struct aac_softstate *softs, struct aac_cmd *acp)
5846 aac_cmd_fib_header(softs, acp, ScsiPortCommandU64);
5863 aac_cmd_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5867 if (slotp = aac_get_slot(softs)) {
5870 acp->aac_cmd_fib(softs, acp);
5879 aac_bind_io(struct aac_softstate *softs, struct aac_cmd *acp)
5884 if (softs->bus_ncmds[q] < softs->bus_throttle[q]) {
5889 return (aac_cmd_slot_bind(softs, acp));
5892 aac_set_throttle(softs, dvp, AAC_CMDQ_ASYNC,
5896 return (aac_cmd_slot_bind(softs, acp));
5903 aac_sync_fib_slot_bind(struct aac_softstate *softs, struct aac_cmd *acp)
5907 while (softs->sync_ac.slotp)
5908 cv_wait(&softs->sync_fib_cv, &softs->io_lock);
5910 if (slotp = aac_get_slot(softs)) {
5921 aac_sync_fib_slot_release(struct aac_softstate *softs, struct aac_cmd *acp)
5925 aac_release_slot(softs, acp->slotp);
5929 cv_signal(&softs->sync_fib_cv);
5933 aac_start_io(struct aac_softstate *softs, struct aac_cmd *acp)
5949 softs->bus_ncmds[q]++;
5950 aac_cmd_enqueue(&softs->q_busy, acp);
5952 AACDB_PRINT_FIB(softs, slotp);
5954 if (softs->flags & AAC_FLAGS_NEW_COMM) {
5955 rval = aac_send_command(softs, slotp);
5961 rval = aac_fib_enqueue(softs, AAC_ADAP_NORM_CMD_Q,
5966 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_UNAFFECTED);
5973 AACDB_PRINT(softs, CE_NOTE, "SCMD send failed");
5976 aac_set_pkt_reason(softs, acp, CMD_INCOMPLETE, 0);
5978 aac_end_io(softs, acp);
5980 ddi_trigger_softintr(softs->softint_id);
5985 aac_start_waitq(struct aac_softstate *softs, struct aac_cmd_queue *q)
5992 if (aac_bind_io(softs, acp) == AACOK) {
5994 aac_start_io(softs, acp);
5996 if (softs->free_io_slot_head == NULL)
6002 aac_start_waiting_io(struct aac_softstate *softs)
6008 if (softs->q_wait[AAC_CMDQ_SYNC].q_head)
6009 aac_start_waitq(softs, &softs->q_wait[AAC_CMDQ_SYNC]);
6010 if (softs->q_wait[AAC_CMDQ_ASYNC].q_head)
6011 aac_start_waitq(softs, &softs->q_wait[AAC_CMDQ_ASYNC]);
6015 aac_drain_comp_q(struct aac_softstate *softs)
6022 mutex_enter(&softs->q_comp_mutex);
6023 acp = aac_cmd_dequeue(&softs->q_comp);
6024 mutex_exit(&softs->q_comp_mutex);
6037 softs->devinfo_p,
6043 if ((aac_check_acc_handle(softs-> \
6045 (aac_check_acc_handle(softs-> \
6047 ddi_fm_service_impact(softs->devinfo_p,
6049 ddi_fm_acc_err_clear(softs-> \
6054 if (aac_check_dma_handle(softs-> \
6056 ddi_fm_service_impact(softs->devinfo_p,
6070 aac_alloc_fib(struct aac_softstate *softs, struct aac_slot *slotp)
6078 softs->devinfo_p,
6079 &softs->addr_dma_attr,
6083 AACDB_PRINT(softs, CE_WARN,
6089 softs->aac_max_fib_size,
6090 &softs->acc_attr,
6097 AACDB_PRINT(softs, CE_WARN,
6105 softs->aac_max_fib_size,
6111 AACDB_PRINT(softs, CE_WARN,
6118 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
6124 ddi_fm_service_impact(softs->devinfo_p, DDI_SERVICE_LOST);
6155 aac_alloc_fibs(struct aac_softstate *softs)
6160 for (i = 0; i < softs->total_slots &&
6161 softs->total_fibs < softs->total_slots; i++) {
6162 slotp = &(softs->io_slot[i]);
6165 if (aac_alloc_fib(softs, slotp) != AACOK)
6169 aac_release_slot(softs, slotp);
6170 softs->total_fibs++;
6175 aac_destroy_fibs(struct aac_softstate *softs)
6179 while ((slotp = softs->free_io_slot_head) != NULL) {
6181 softs->free_io_slot_head = slotp->next;
6183 ASSERT(slotp->index == (slotp - softs->io_slot));
6184 softs->total_fibs--;
6186 ASSERT(softs->total_fibs == 0);
6190 aac_create_slots(struct aac_softstate *softs)
6194 softs->total_slots = softs->aac_max_fibs;
6195 softs->io_slot = kmem_zalloc(sizeof (struct aac_slot) * \
6196 softs->total_slots, KM_SLEEP);
6197 if (softs->io_slot == NULL) {
6198 AACDB_PRINT(softs, CE_WARN, "Cannot allocate slot");
6201 for (i = 0; i < softs->total_slots; i++)
6202 softs->io_slot[i].index = i;
6203 softs->free_io_slot_head = NULL;
6204 softs->total_fibs = 0;
6209 aac_destroy_slots(struct aac_softstate *softs)
6211 ASSERT(softs->free_io_slot_head == NULL);
6213 kmem_free(softs->io_slot, sizeof (struct aac_slot) * \
6214 softs->total_slots);
6215 softs->io_slot = NULL;
6216 softs->total_slots = 0;
6220 aac_get_slot(struct aac_softstate *softs)
6224 if ((slotp = softs->free_io_slot_head) != NULL) {
6225 softs->free_io_slot_head = slotp->next;
6232 aac_release_slot(struct aac_softstate *softs, struct aac_slot *slotp)
6234 ASSERT((slotp->index >= 0) && (slotp->index < softs->total_slots));
6235 ASSERT(slotp == &softs->io_slot[slotp->index]);
6238 slotp->next = softs->free_io_slot_head;
6239 softs->free_io_slot_head = slotp;
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);
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)
6274 intr_handler = (softs->flags & AAC_FLAGS_NEW_COMM) ?
6279 AAC_BUSYWAIT((intr_handler(softs) != AAC_DB_RESPONSE_READY), i);
6281 aac_cmd_timeout(softs, acp);
6284 ddi_trigger_softintr(softs->softint_id);
6292 aac_do_sync_io(struct aac_softstate *softs, struct aac_cmd *acp)
6294 ASSERT(softs && acp);
6297 cv_wait(&softs->event, &softs->io_lock);
6336 aac_save_aif(struct aac_softstate *softs, ddi_acc_handle_t acc,
6351 mutex_enter(&softs->aifq_mutex);
6354 fibp = &softs->aifq[softs->aifq_idx].d;
6359 if (aac_check_acc_handle(softs->pci_mem_handle) != DDI_SUCCESS) {
6360 ddi_fm_service_impact(softs->devinfo_p,
6362 mutex_exit(&softs->aifq_mutex);
6366 AACDB_PRINT_AIF(softs, (struct aac_aif_command *)&fibp->data[0]);
6369 current = softs->aifq_idx;
6374 softs->aifq_wrap = 1;
6375 for (ctx_p = softs->fibctx_p; ctx_p; ctx_p = ctx_p->next) {
6385 softs->aifq_idx = next;
6388 cv_broadcast(&softs->aifq_cv);
6389 mutex_exit(&softs->aifq_mutex);
6392 aac_event_disp(softs, AAC_EVENT_AIF);
6396 aac_return_aif_common(struct aac_softstate *softs, struct aac_fib_context *ctx,
6402 if (current == softs->aifq_idx &&
6406 *fibpp = &softs->aifq[current].d;
6414 aac_return_aif(struct aac_softstate *softs, struct aac_fib_context *ctx,
6419 mutex_enter(&softs->aifq_mutex);
6420 rval = aac_return_aif_common(softs, ctx, fibpp);
6421 mutex_exit(&softs->aifq_mutex);
6426 aac_return_aif_wait(struct aac_softstate *softs, struct aac_fib_context *ctx,
6431 mutex_enter(&softs->aifq_mutex);
6432 rval = aac_return_aif_common(softs, ctx, fibpp);
6434 AACDB_PRINT(softs, CE_NOTE, "Waiting for AIF");
6435 rval = cv_wait_sig(&softs->aifq_cv, &softs->aifq_mutex);
6437 mutex_exit(&softs->aifq_mutex);
6452 aac_handle_aif(struct aac_softstate *softs, struct aac_aif_command *aif)
6454 ddi_acc_handle_t acc = softs->comm_space_acc_handle;
6471 if (AAC_DEV_IS_VALID(&softs->containers[cid].dev))
6472 softs->devcfg_wait_on = AifEnConfigChange;
6475 if (softs->devcfg_wait_on == en_type)
6485 softs->devcfg_wait_on = AifEnConfigChange;
6488 if (!softs->devcfg_wait_on)
6489 softs->devcfg_wait_on = AifEnConfigChange;
6497 if (!(softs->flags & AAC_FLAGS_JBOD))
6504 if (!(softs->flags & AAC_FLAGS_JBOD))
6511 if (softs->devcfg_wait_on == en_type)
6526 softs->devcfg_wait_on = AifEnContainerChange;
6529 softs->devcfg_wait_on = AifEnContainerChange;
6535 softs->devcfg_wait_on = 0;
6536 (void) aac_probe_containers(softs);
6541 (void) aac_probe_jbod(softs,
6542 AAC_P2VTGT(softs, bus_id, tgt_id), event);
6552 aac_aif_event(struct aac_softstate *softs)
6558 if (aac_return_aif(softs, &softs->aifctx, &fibp) != 0)
6562 if (softs->aifctx.ctx_overrun) {
6563 softs->aifctx.ctx_overrun = 0;
6574 (void) aac_handle_aif(softs, aifp);
6583 aac_cmd_timeout(struct aac_softstate *softs, struct aac_cmd *acp)
6587 AACDB_PRINT(softs, CE_WARN, "acp %p timed out", acp);
6588 AACDB_PRINT_FIB(softs, acp->slotp);
6600 switch (aac_do_reset(softs)) {
6602 aac_abort_iocmds(softs, AAC_IOCMD_OUTSTANDING, NULL, CMD_RESET);
6603 aac_start_waiting_io(softs);
6607 aac_abort_iocmds(softs, AAC_IOCMD_ALL, NULL, CMD_TIMEOUT);
6610 aac_start_waiting_io(softs);
6621 aac_sync_tick(struct aac_softstate *softs)
6626 mutex_enter(&softs->time_mutex);
6627 ASSERT(softs->time_sync <= softs->timebase);
6628 softs->time_sync = 0;
6629 mutex_exit(&softs->time_mutex);
6632 (void) aac_sync_fib_slot_bind(softs, &softs->sync_ac);
6633 acc = softs->sync_ac.slotp->fib_acc_handle;
6635 ddi_put32(acc, (void *)&softs->sync_ac.slotp->fibp->data[0],
6637 rval = aac_sync_fib(softs, SendHostTime, AAC_FIB_SIZEOF(uint32_t));
6638 aac_sync_fib_slot_release(softs, &softs->sync_ac);
6640 mutex_enter(&softs->time_mutex);
6641 softs->time_sync = softs->timebase;
6644 softs->time_sync += aac_tick << 1;
6646 softs->time_sync += AAC_SYNC_TICK;
6647 mutex_exit(&softs->time_mutex);
6654 aac_daemon(struct aac_softstate *softs)
6660 mutex_enter(&softs->time_mutex);
6661 ASSERT(softs->time_out <= softs->timebase);
6662 softs->time_out = 0;
6663 softs_timebase = softs->timebase;
6664 mutex_exit(&softs->time_mutex);
6672 for (acp = softs->q_busy.q_head; acp; acp = acp->next) {
6686 aac_cmd_timeout(softs, acp);
6696 mutex_enter(&softs->time_mutex);
6697 softs->time_out = softs->timebase + aac_tick;
6698 mutex_exit(&softs->time_mutex);
6706 aac_event_thread(struct aac_softstate *softs)
6710 DBCALLED(softs, 1);
6712 mutex_enter(&softs->ev_lock);
6716 if ((events = softs->events) == 0) {
6717 cv_wait(&softs->event_disp_cv, &softs->ev_lock);
6718 events = softs->events;
6720 softs->events = 0;
6721 mutex_exit(&softs->ev_lock);
6723 mutex_enter(&softs->io_lock);
6724 if ((softs->state & AAC_STATE_RUN) &&
6725 (softs->state & AAC_STATE_DEAD) == 0) {
6727 aac_daemon(softs);
6729 aac_sync_tick(softs);
6731 aac_aif_event(softs);
6735 mutex_exit(&softs->io_lock);
6737 mutex_enter(&softs->ev_lock);
6740 cv_signal(&softs->event_wait_cv);
6741 mutex_exit(&softs->ev_lock);
6752 struct aac_softstate *softs = arg;
6755 mutex_enter(&softs->time_mutex);
6758 if (softs->timeout_id) {
6759 softs->timeout_id = timeout(aac_timer, (void *)softs,
6762 mutex_exit(&softs->time_mutex);
6767 softs->timebase += aac_tick;
6770 if (softs->time_out && softs->time_out <= softs->timebase)
6772 if (softs->time_sync && softs->time_sync <= softs->timebase)
6775 mutex_exit(&softs->time_mutex);
6778 aac_event_disp(softs, events);
6785 aac_event_disp(struct aac_softstate *softs, int events)
6787 mutex_enter(&softs->ev_lock);
6788 softs->events |= events;
6789 cv_broadcast(&softs->event_disp_cv);
6790 mutex_exit(&softs->ev_lock);
6797 aac_rx_get_fwstatus(struct aac_softstate *softs)
6799 return (PCI_MEM_GET32(softs, AAC_OMR0));
6803 aac_rx_get_mailbox(struct aac_softstate *softs, int mb)
6805 return (PCI_MEM_GET32(softs, AAC_RX_MAILBOX + mb * 4));
6809 aac_rx_set_mailbox(struct aac_softstate *softs, uint32_t cmd,
6812 PCI_MEM_PUT32(softs, AAC_RX_MAILBOX, cmd);
6813 PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 4, arg0);
6814 PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 8, arg1);
6815 PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 12, arg2);
6816 PCI_MEM_PUT32(softs, AAC_RX_MAILBOX + 16, arg3);
6820 aac_rkt_get_fwstatus(struct aac_softstate *softs)
6822 return (PCI_MEM_GET32(softs, AAC_OMR0));
6826 aac_rkt_get_mailbox(struct aac_softstate *softs, int mb)
6828 return (PCI_MEM_GET32(softs, AAC_RKT_MAILBOX + mb *4));
6832 aac_rkt_set_mailbox(struct aac_softstate *softs, uint32_t cmd,
6835 PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX, cmd);
6836 PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 4, arg0);
6837 PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 8, arg1);
6838 PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 12, arg2);
6839 PCI_MEM_PUT32(softs, AAC_RKT_MAILBOX + 16, arg3);
6848 struct aac_softstate *softs;
6867 softs = ddi_get_soft_state(aac_softstatep, instance);
6868 if (softs == NULL)
6903 struct aac_softstate *softs;
6920 softs = ddi_get_soft_state(aac_softstatep, instance);
6921 return (aac_do_ioctl(softs, dev, cmd, arg, flag));
6946 aac_fm_init(struct aac_softstate *softs)
6953 softs->fm_capabilities = ddi_getprop(DDI_DEV_T_ANY, softs->devinfo_p,
6959 if (softs->fm_capabilities) {
6961 softs->reg_attr.devacc_attr_access = DDI_FLAGERR_ACC;
6962 softs->addr_dma_attr.dma_attr_flags |= DDI_DMA_FLAGERR;
6963 softs->buf_dma_attr.dma_attr_flags |= DDI_DMA_FLAGERR;
6970 ddi_fm_init(softs->devinfo_p, &softs->fm_capabilities, &fm_ibc);
6976 if (DDI_FM_EREPORT_CAP(softs->fm_capabilities) ||
6977 DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
6978 pci_ereport_setup(softs->devinfo_p);
6984 if (DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
6985 ddi_fm_handler_register(softs->devinfo_p,
6986 aac_fm_error_cb, (void *) softs);
6996 aac_fm_fini(struct aac_softstate *softs)
6999 if (softs->fm_capabilities) {
7003 if (DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
7004 ddi_fm_handler_unregister(softs->devinfo_p);
7010 if (DDI_FM_EREPORT_CAP(softs->fm_capabilities) ||
7011 DDI_FM_ERRCB_CAP(softs->fm_capabilities)) {
7012 pci_ereport_teardown(softs->devinfo_p);
7016 ddi_fm_fini(softs->devinfo_p);
7019 softs->reg_attr.devacc_attr_access = DDI_DEFAULT_ACC;
7020 softs->addr_dma_attr.dma_attr_flags &= ~DDI_DMA_FLAGERR;
7021 softs->buf_dma_attr.dma_attr_flags &= ~DDI_DMA_FLAGERR;
7044 aac_fm_ereport(struct aac_softstate *softs, char *detail)
7051 if (DDI_FM_EREPORT_CAP(softs->fm_capabilities)) {
7052 ddi_fm_ereport_post(softs->devinfo_p, buf, ena, DDI_NOSLEEP,
7103 aac_find_child(struct aac_softstate *softs, uint16_t tgt, uint8_t lun)
7111 struct aac_device *dvp = &softs->containers[tgt].dev;
7117 for (child = ddi_get_child(softs->devinfo_p);
7134 aac_config_child(struct aac_softstate *softs, struct scsi_device *sd,
7147 DBCALLED(softs, 2);
7152 AACDB_PRINT(softs, CE_WARN,
7157 childname = (softs->legacy && dtype == DTYPE_DIRECT) ? "sd" : nodename;
7160 rval = ndi_devi_alloc(softs->devinfo_p, childname, DEVI_SID_NODEID,
7165 AACDB_PRINT(softs, CE_WARN, "unable to create "
7172 AACDB_PRINT(softs, CE_WARN, "unable to create "
7180 AACDB_PRINT(softs, CE_WARN, "unable to create "
7188 AACDB_PRINT(softs, CE_WARN, "unable to online t%dL%d",
7204 aac_probe_lun(struct aac_softstate *softs, struct scsi_device *sd)
7209 DBCALLED(softs, 2);
7215 mutex_enter(&softs->io_lock);
7216 event = aac_probe_container(softs, tgt);
7217 mutex_exit(&softs->io_lock);
7236 AACDB_PRINT(softs, CE_NOTE,
7244 if (!(softs->flags & AAC_FLAGS_NONDASD))
7246 AACDB_PRINT(softs, CE_NOTE, "non-DASD %d found", tgt);
7249 if (!(softs->flags & AAC_FLAGS_JBOD) || qual != 0)
7251 AACDB_PRINT(softs, CE_NOTE, "JBOD DASD %d found", tgt);
7254 mutex_enter(&softs->io_lock);
7255 softs->nondasds[AAC_PD(tgt)].dev.flags |= AAC_DFLAG_VALID;
7256 mutex_exit(&softs->io_lock);
7262 aac_config_lun(struct aac_softstate *softs, uint16_t tgt, uint8_t lun,
7269 DBCALLED(softs, 2);
7271 if ((child = aac_find_child(softs, tgt, lun)) != NULL) {
7278 sd.sd_address.a_hba_tran = softs->hba_tran;
7281 if ((rval = aac_probe_lun(softs, &sd)) == NDI_SUCCESS)
7282 rval = aac_config_child(softs, &sd, ldip);
7292 aac_config_tgt(struct aac_softstate *softs, int tgt)
7302 ap.a_hba_tran = softs->hba_tran;
7374 AACDB_PRINT(softs, CE_WARN,
7378 if (aac_config_lun(softs, tgt, lun, &ldip) ==
7388 if (aac_config_lun(softs, tgt, 0, &ldip) == NDI_SUCCESS)
7396 aac_devcfg(struct aac_softstate *softs, int tgt, int en)
7400 mutex_enter(&softs->io_lock);
7401 dvp = AAC_DEV(softs, tgt);
7406 mutex_exit(&softs->io_lock);
7413 struct aac_softstate *softs;
7417 if ((softs = ddi_get_soft_state(aac_softstatep,
7422 mutex_enter(&softs->io_lock);
7423 if (softs->state & AAC_STATE_QUIESCED) {
7424 AACDB_PRINT(softs, CE_NOTE,
7426 mutex_exit(&softs->io_lock);
7429 mutex_exit(&softs->io_lock);
7431 DBCALLED(softs, 1);
7444 if (tgt >= AAC_MAX_DEV(softs)) {
7450 AAC_DEVCFG_BEGIN(softs, tgt);
7451 rval = aac_config_lun(softs, tgt, lun, childp);
7452 AAC_DEVCFG_END(softs, tgt);
7462 AAC_DEVCFG_BEGIN(softs, tgt);
7463 (void) aac_config_lun(softs, tgt, 0, NULL);
7464 AAC_DEVCFG_END(softs, tgt);
7470 for (bus = 0; bus < softs->bus_max; bus++) {
7471 AACDB_PRINT(softs, CE_NOTE, "bus %d:", bus);
7472 for (tgt = 0; tgt < softs->tgt_max; tgt++, index++) {
7473 AAC_DEVCFG_BEGIN(softs, index);
7474 if (aac_config_tgt(softs, index))
7476 AAC_DEVCFG_END(softs, index);
7479 AACDB_PRINT(softs, CE_CONT,
7494 aac_handle_dr(struct aac_softstate *softs, int tgt, int lun, int event)
7501 DBCALLED(softs, 1);
7504 dvp = AAC_DEV(softs, tgt);
7507 if (!(softs->state & AAC_STATE_RUN))
7509 mutex_exit(&softs->io_lock);
7516 ndi_devi_enter(softs->devinfo_p, &circ1);
7517 (void) aac_config_lun(softs, tgt, 0, NULL);
7518 AACDB_PRINT(softs, CE_NOTE, "c%dt%dL%d onlined",
7519 softs->instance, tgt, lun);
7520 ndi_devi_exit(softs->devinfo_p, circ1);
7524 mutex_enter(&softs->io_lock);
7525 (void) aac_do_reset(softs);
7526 mutex_exit(&softs->io_lock);
7529 AACDB_PRINT(softs, CE_NOTE, "c%dt%dL%d offlined",
7530 softs->instance, tgt, lun);
7535 mutex_enter(&softs->io_lock);
7991 aac_get_fw_debug_buffer(struct aac_softstate *softs)
7993 if (aac_sync_mbcommand(softs, AAC_MONKER_GETDRVPROP,
7995 uint32_t mondrv_buf_paddrl = AAC_MAILBOX_GET(softs, 1);
7996 uint32_t mondrv_buf_paddrh = AAC_MAILBOX_GET(softs, 2);
7997 uint32_t mondrv_buf_size = AAC_MAILBOX_GET(softs, 3);
7998 uint32_t mondrv_hdr_size = AAC_MAILBOX_GET(softs, 4);
8002 softs->pci_mem_base_paddr;
8009 (offset + mondrv_buf_size < softs->map_size)) {
8011 softs->debug_buf_offset = offset;
8012 softs->debug_header_size = mondrv_hdr_size;
8013 softs->debug_buf_size = mondrv_buf_size;
8014 softs->debug_fw_flags = 0;
8015 softs->debug_flags &= ~AACDB_FLAGS_FW_PRINT;
8026 aac_dbflag_on(struct aac_softstate *softs, int flag)
8028 int debug_flags = softs ? softs->debug_flags : aac_debug_flags;
8035 aac_cmn_err(struct aac_softstate *softs, uint_t lev, char sl, int noheader)
8048 softs->vendor_name, softs->instance,
8052 softs->vendor_name, softs->instance,
8065 aac_printf(struct aac_softstate *softs, uint_t lev, const char *fmt, ...)
8082 /* Make sure the softs structure has been passed in for this section */
8083 if (softs) {
8084 if ((softs->debug_flags & AACDB_FLAGS_FW_PRINT) &&
8086 (softs->debug_buf_size)) {
8091 if (count > softs->debug_buf_size)
8092 count = (uint16_t)softs->debug_buf_size;
8099 if (!PCI_MEM_GET32(softs,
8100 softs->debug_buf_offset + \
8113 if (!PCI_MEM_GET32(softs, softs->debug_buf_offset + \
8115 PCI_MEM_REP_PUT8(softs,
8116 softs->debug_buf_offset + \
8117 softs->debug_header_size,
8119 PCI_MEM_PUT32(softs,
8120 softs->debug_buf_offset + \
8122 softs->debug_fw_flags);
8123 PCI_MEM_PUT32(softs,
8124 softs->debug_buf_offset + \
8128 softs->debug_flags &= ~AACDB_FLAGS_FW_PRINT;
8136 if (softs->debug_flags & AACDB_FLAGS_KERNEL_PRINT)
8137 aac_cmn_err(softs, lev, sl,
8138 (softs->debug_flags & AACDB_FLAGS_NO_HEADERS));
8142 aac_cmn_err(softs, lev, sl, 1);
8163 aac_print_scmd(struct aac_softstate *softs, struct aac_cmd *acp)
8168 int ctl = ddi_get_instance(softs->devinfo_p);
8184 aac_printf(softs, CE_NOTE,
8193 aac_printf(softs, CE_NOTE,
8201 aac_printf(softs, CE_NOTE,
8209 aac_printf(softs, CE_NOTE,
8218 aac_printf(softs, CE_NOTE,
8225 aac_printf(softs, CE_NOTE, "SCMD> %s --> c%dt%dL%d %s",
8231 aac_print_fib(struct aac_softstate *softs, struct aac_slot *slotp)
8243 if (!(softs->debug_fib_flags & acp->fib_flags))
8254 if (!(softs->debug_fib_flags & AACDB_FLAGS_FIB_SYNC))
8265 if (softs->debug_fib_flags & AACDB_FLAGS_FIB_HEADER) {
8266 aac_printf(softs, CE_NOTE, "FIB> from %s", caller);
8267 aac_printf(softs, CE_NOTE, " XferState %d",
8269 aac_printf(softs, CE_NOTE, " Command %d",
8271 aac_printf(softs, CE_NOTE, " StructType %d",
8273 aac_printf(softs, CE_NOTE, " Flags 0x%x",
8275 aac_printf(softs, CE_NOTE, " Size %d",
8277 aac_printf(softs, CE_NOTE, " SenderSize %d",
8279 aac_printf(softs, CE_NOTE, " SenderAddr 0x%x",
8281 aac_printf(softs, CE_NOTE, " RcvrAddr 0x%x",
8283 aac_printf(softs, CE_NOTE, " SenderData 0x%x",
8311 aac_printf(softs, CE_NOTE, "FIB> %s (0x%x, 0x%x, 0x%x)",
8337 aac_printf(softs, CE_NOTE,
8343 aac_printf(softs, CE_NOTE,
8369 aac_printf(softs, CE_NOTE,
8377 aac_printf(softs, CE_NOTE,
8392 aac_printf(softs, CE_NOTE,
8400 aac_printf(softs, CE_NOTE, " %d: 0x%08x.%08x/%d", i,
8425 aac_printf(softs, CE_NOTE, "FIB> %s, sz=%d",
8428 aac_printf(softs, CE_NOTE, "FIB> %s, sz=%d",
8431 aac_printf(softs, CE_NOTE, "FIB> %s: Unknown(0x%x), sz=%d",
8434 aac_printf(softs, CE_NOTE, "FIB> Unknown(0x%x), sz=%d",
8439 aac_print_aif(struct aac_softstate *softs, struct aac_aif_command *aif)
8454 aac_printf(softs, CE_NOTE, "AIF! %s", str);
8456 aac_printf(softs, CE_NOTE, "AIF! Unknown(0x%x)",
8477 aac_printf(softs, CE_NOTE,
8485 aac_printf(softs, CE_NOTE, "AIF! APIReport (%d)",
8490 aac_printf(softs, CE_NOTE, "AIF! DriverNotify (%d)",
8495 aac_printf(softs, CE_NOTE, "AIF! AIF %d (%d)",