Lines Matching defs:mpt
136 static void mptsas_setup_cmd_reg(mptsas_t *mpt);
137 static void mptsas_disable_bus_master(mptsas_t *mpt);
138 static void mptsas_hba_fini(mptsas_t *mpt);
140 static int mptsas_hba_setup(mptsas_t *mpt);
141 static void mptsas_hba_teardown(mptsas_t *mpt);
142 static int mptsas_config_space_init(mptsas_t *mpt);
143 static void mptsas_config_space_fini(mptsas_t *mpt);
144 static void mptsas_iport_register(mptsas_t *mpt);
145 static int mptsas_smp_setup(mptsas_t *mpt);
146 static void mptsas_smp_teardown(mptsas_t *mpt);
147 static int mptsas_cache_create(mptsas_t *mpt);
148 static void mptsas_cache_destroy(mptsas_t *mpt);
149 static int mptsas_alloc_request_frames(mptsas_t *mpt);
150 static int mptsas_alloc_sense_bufs(mptsas_t *mpt);
151 static int mptsas_alloc_reply_frames(mptsas_t *mpt);
152 static int mptsas_alloc_free_queue(mptsas_t *mpt);
153 static int mptsas_alloc_post_queue(mptsas_t *mpt);
154 static void mptsas_alloc_reply_args(mptsas_t *mpt);
155 static int mptsas_alloc_extra_sgl_frame(mptsas_t *mpt, mptsas_cmd_t *cmd);
156 static void mptsas_free_extra_sgl_frame(mptsas_t *mpt, mptsas_cmd_t *cmd);
157 static int mptsas_init_chip(mptsas_t *mpt, int first_time);
196 static void mptsas_list_add(mptsas_t *mpt);
197 static void mptsas_list_del(mptsas_t *mpt);
199 static int mptsas_quiesce_bus(mptsas_t *mpt);
200 static int mptsas_unquiesce_bus(mptsas_t *mpt);
202 static int mptsas_alloc_handshake_msg(mptsas_t *mpt, size_t alloc_size);
203 static void mptsas_free_handshake_msg(mptsas_t *mpt);
208 static int mptsas_accept_pkt(mptsas_t *mpt, mptsas_cmd_t *sp);
209 static int mptsas_accept_txwq_and_pkt(mptsas_t *mpt, mptsas_cmd_t *sp);
210 static void mptsas_accept_tx_waitq(mptsas_t *mpt);
213 static int mptsas_do_scsi_reset(mptsas_t *mpt, uint16_t devhdl);
214 static int mptsas_do_scsi_abort(mptsas_t *mpt, int target, int lun,
218 static void mptsas_handle_qfull(mptsas_t *mpt, mptsas_cmd_t *cmd);
227 static void mptsas_flush_hba(mptsas_t *mpt);
228 static void mptsas_flush_target(mptsas_t *mpt, ushort_t target, int lun,
230 static void mptsas_set_pkt_reason(mptsas_t *mpt, mptsas_cmd_t *cmd,
234 static void mptsas_process_intr(mptsas_t *mpt,
236 static void mptsas_handle_scsi_io_success(mptsas_t *mpt,
238 static void mptsas_handle_address_reply(mptsas_t *mpt,
240 static int mptsas_wait_intr(mptsas_t *mpt, int polltime);
241 static void mptsas_sge_setup(mptsas_t *mpt, mptsas_cmd_t *cmd,
245 static void mptsas_watchsubr(mptsas_t *mpt);
246 static void mptsas_cmd_timeout(mptsas_t *mpt, mptsas_target_t *ptgt);
248 static void mptsas_start_passthru(mptsas_t *mpt, mptsas_cmd_t *cmd);
249 static int mptsas_do_passthru(mptsas_t *mpt, uint8_t *request, uint8_t *reply,
253 static int mptsas_free_devhdl(mptsas_t *mpt, uint16_t devhdl);
255 static uint8_t mptsas_get_fw_diag_buffer_number(mptsas_t *mpt,
257 static void mptsas_start_diag(mptsas_t *mpt, mptsas_cmd_t *cmd);
258 static int mptsas_post_fw_diag_buffer(mptsas_t *mpt,
260 static int mptsas_release_fw_diag_buffer(mptsas_t *mpt,
263 static int mptsas_diag_register(mptsas_t *mpt,
265 static int mptsas_diag_unregister(mptsas_t *mpt,
267 static int mptsas_diag_query(mptsas_t *mpt, mptsas_fw_diag_query_t *diag_query,
269 static int mptsas_diag_read_buffer(mptsas_t *mpt,
272 static int mptsas_diag_release(mptsas_t *mpt,
274 static int mptsas_do_diag_action(mptsas_t *mpt, uint32_t action,
277 static int mptsas_diag_action(mptsas_t *mpt, mptsas_diag_action_t *data,
280 static int mptsas_pkt_alloc_extern(mptsas_t *mpt, mptsas_cmd_t *cmd,
282 static void mptsas_pkt_destroy_extern(mptsas_t *mpt, mptsas_cmd_t *cmd);
291 static void mptsas_check_scsi_io_error(mptsas_t *mpt, pMpi2SCSIIOReply_t reply,
293 static void mptsas_check_task_mgt(mptsas_t *mpt,
295 static int mptsas_send_scsi_cmd(mptsas_t *mpt, struct scsi_address *ap,
299 static int mptsas_alloc_active_slots(mptsas_t *mpt, int flag);
300 static void mptsas_free_active_slots(mptsas_t *mpt);
301 static int mptsas_start_cmd(mptsas_t *mpt, mptsas_cmd_t *cmd);
303 static void mptsas_restart_hba(mptsas_t *mpt);
304 static void mptsas_restart_waitq(mptsas_t *mpt);
306 static void mptsas_deliver_doneq_thread(mptsas_t *mpt);
307 static void mptsas_doneq_add(mptsas_t *mpt, mptsas_cmd_t *cmd);
308 static void mptsas_doneq_mv(mptsas_t *mpt, uint64_t t);
310 static mptsas_cmd_t *mptsas_doneq_thread_rm(mptsas_t *mpt, uint64_t t);
311 static void mptsas_doneq_empty(mptsas_t *mpt);
314 static mptsas_cmd_t *mptsas_waitq_rm(mptsas_t *mpt);
315 static void mptsas_waitq_delete(mptsas_t *mpt, mptsas_cmd_t *cmd);
316 static mptsas_cmd_t *mptsas_tx_waitq_rm(mptsas_t *mpt);
317 static void mptsas_tx_waitq_delete(mptsas_t *mpt, mptsas_cmd_t *cmd);
321 static void mptsas_setup_bus_reset_delay(mptsas_t *mpt);
323 static int mptsas_watch_reset_delay_subr(mptsas_t *mpt);
328 static void mptsas_dump_cmd(mptsas_t *mpt, mptsas_cmd_t *cmd);
343 static mptsas_target_t *mptsas_phy_to_tgt(mptsas_t *mpt,
345 static mptsas_target_t *mptsas_wwid_to_ptgt(mptsas_t *mpt,
347 static mptsas_smp_t *mptsas_wwid_to_psmp(mptsas_t *mpt,
350 static int mptsas_inquiry(mptsas_t *mpt, mptsas_target_t *ptgt, int lun,
353 static int mptsas_get_target_device_info(mptsas_t *mpt, uint32_t page_address,
355 static void mptsas_update_phymask(mptsas_t *mpt);
357 static int mptsas_send_sep(mptsas_t *mpt, mptsas_target_t *ptgt,
361 static mptsas_target_t *mptsas_addr_to_ptgt(mptsas_t *mpt, char *addr,
363 static int mptsas_flush_led_status(mptsas_t *mpt, mptsas_target_t *ptgt);
404 static int mptsas_event_query(mptsas_t *mpt, mptsas_event_query_t *data,
406 static int mptsas_event_enable(mptsas_t *mpt, mptsas_event_enable_t *data,
408 static int mptsas_event_report(mptsas_t *mpt, mptsas_event_report_t *data,
411 static int mptsas_reg_access(mptsas_t *mpt, mptsas_reg_access_t *data,
423 static int mptsas_get_pci_cap(mptsas_t *mpt);
424 static int mptsas_init_pm(mptsas_t *mpt);
449 static void mptsas_fm_init(mptsas_t *mpt);
450 static void mptsas_fm_fini(mptsas_t *mpt);
573 #define SAS_PROP "sas-mpt"
816 mptsas_destroy_hashes(mptsas_t *mpt)
821 for (tp = refhash_first(mpt->m_targets); tp != NULL;
822 tp = refhash_next(mpt->m_targets, tp)) {
823 refhash_remove(mpt->m_targets, tp);
825 for (sp = refhash_first(mpt->m_smp_targets); sp != NULL;
826 sp = refhash_next(mpt->m_smp_targets, sp)) {
827 refhash_remove(mpt->m_smp_targets, sp);
829 refhash_destroy(mpt->m_tmp_targets);
830 refhash_destroy(mpt->m_targets);
831 refhash_destroy(mpt->m_smp_targets);
832 mpt->m_targets = NULL;
833 mpt->m_smp_targets = NULL;
840 mptsas_t *mpt;
887 mpt = TRAN2MPT(hba_tran);
888 ASSERT(mpt != NULL);
889 if (mpt == NULL)
894 mptsas_log(mpt, CE_WARN, "Failed attach iport because fail to "
902 hba_tran->tran_hba_private = mpt;
916 mptsas_log(mpt, CE_WARN, "mptsas virtual port "
923 mutex_enter(&mpt->m_mutex);
927 "%x", mpt->m_phy_info[i].phy_mask);
934 mptsas_log(mpt, CE_WARN, "Failed attach port %s because port"
936 mutex_exit(&mpt->m_mutex);
940 phy_mask = mpt->m_phy_info[i].phy_mask;
942 if (mpt->m_phy_info[i].port_flags & AUTO_PORT_CONFIGURATION)
950 if (mptsas_smhba_phy_init(mpt)) {
951 mutex_exit(&mpt->m_mutex);
952 mptsas_log(mpt, CE_WARN, "mptsas phy update "
957 mutex_exit(&mpt->m_mutex);
968 mpt->un.m_base_wwid);
975 mptsas_log(mpt, CE_WARN, "mptsas Initiator port "
990 mptsas_log(mpt, CE_WARN, "mptsas phy mask "
999 mptsas_log(mpt, CE_WARN, "mptsas dynamic port "
1008 mptsas_log(mpt, CE_WARN, "mptsas virtual port "
1012 mptsas_smhba_set_all_phy_props(mpt, dip, numphys, phy_mask,
1015 mutex_enter(&mpt->m_mutex);
1018 rval = mptsas_get_sas_device_page0(mpt, page_address, &dev_hdl,
1022 mptsas_log(mpt, CE_WARN,
1025 mutex_exit(&mpt->m_mutex);
1031 (void) sprintf(phymask, "%x", mpt->m_phy_info[i].phy_mask);
1033 (void) sprintf(&mpt->m_phy_info[i].smhba_info.path[0],
1035 mpt->m_phy_info[i].phy_mask);
1038 mutex_exit(&mpt->m_mutex);
1053 mptsas_create_phy_stats(mpt, iport, dip);
1060 mpt->m_mpxio_enable = TRUE;
1075 mptsas_t *mpt = NULL;
1107 mpt = TRAN2MPT(hba_tran);
1109 if (!mpt) {
1118 mutex_enter(&mpt->m_mutex);
1123 if (mpt->m_options & MPTSAS_OPT_PM) {
1124 mutex_exit(&mpt->m_mutex);
1128 mutex_enter(&mpt->m_mutex);
1149 mpt->m_suspended = 0;
1154 mpt->m_softstate |= MPTSAS_SS_MSG_UNIT_RESET;
1155 if (mptsas_init_chip(mpt, FALSE) == DDI_FAILURE) {
1156 mutex_exit(&mpt->m_mutex);
1157 if (mpt->m_options & MPTSAS_OPT_PM) {
1166 MPTSAS_ENABLE_INTR(mpt);
1167 mptsas_update_driver_data(mpt);
1170 mptsas_restart_hba(mpt);
1172 mutex_exit(&mpt->m_mutex);
1186 if (mpt->m_options & MPTSAS_OPT_PM) {
1208 mpt = ddi_get_soft_state(mptsas_state, instance);
1210 if (mpt == NULL) {
1219 mpt->m_dip = dip;
1220 mpt->m_instance = instance;
1223 mpt->m_io_dma_attr = mptsas_dma_attrs64;
1225 mpt->m_msg_dma_attr = mptsas_dma_attrs64;
1227 mpt->m_msg_dma_attr = mptsas_dma_attrs;
1229 mpt->m_reg_acc_attr = mptsas_dev_attr;
1230 mpt->m_dev_acc_attr = mptsas_dev_attr;
1235 mpt->m_req_sense_size = EXTCMDS_STATUS_SIZE;
1240 mpt->m_fm_capabilities = ddi_getprop(DDI_DEV_T_ANY, mpt->m_dip,
1245 mptsas_fm_init(mpt);
1247 if (mptsas_alloc_handshake_msg(mpt,
1249 mptsas_log(mpt, CE_WARN, "cannot initialize handshake msg.");
1256 if (mptsas_config_space_init(mpt) == FALSE) {
1257 mptsas_log(mpt, CE_WARN, "mptsas_config_space_init failed");
1262 if (ddi_regs_map_setup(dip, mem_bar, (caddr_t *)&mpt->m_reg,
1263 0, 0, &mpt->m_reg_acc_attr, &mpt->m_datap) != DDI_SUCCESS) {
1264 mptsas_log(mpt, CE_WARN, "map setup failed");
1272 if ((mpt->m_event_taskq = ddi_taskq_create(dip, "mptsas_event_taskq",
1274 mptsas_log(mpt, CE_NOTE, "ddi_taskq_create failed");
1282 if ((mpt->m_dr_taskq = ddi_taskq_create(dip,
1285 mptsas_log(mpt, CE_NOTE, "ddi_taskq_create for discovery "
1291 mpt->m_doneq_thread_threshold = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1293 mpt->m_doneq_length_threshold = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1295 mpt->m_doneq_thread_n = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1298 if (mpt->m_doneq_thread_n) {
1299 cv_init(&mpt->m_doneq_thread_cv, NULL, CV_DRIVER, NULL);
1300 mutex_init(&mpt->m_doneq_mutex, NULL, MUTEX_DRIVER, NULL);
1302 mutex_enter(&mpt->m_doneq_mutex);
1303 mpt->m_doneq_thread_id =
1305 * mpt->m_doneq_thread_n, KM_SLEEP);
1307 for (j = 0; j < mpt->m_doneq_thread_n; j++) {
1308 cv_init(&mpt->m_doneq_thread_id[j].cv, NULL,
1310 mutex_init(&mpt->m_doneq_thread_id[j].mutex, NULL,
1312 mutex_enter(&mpt->m_doneq_thread_id[j].mutex);
1313 mpt->m_doneq_thread_id[j].flag |=
1315 mpt->m_doneq_thread_id[j].arg.mpt = mpt;
1316 mpt->m_doneq_thread_id[j].arg.t = j;
1317 mpt->m_doneq_thread_id[j].threadp =
1319 &mpt->m_doneq_thread_id[j].arg,
1321 mpt->m_doneq_thread_id[j].donetail =
1322 &mpt->m_doneq_thread_id[j].doneq;
1323 mutex_exit(&mpt->m_doneq_thread_id[j].mutex);
1325 mutex_exit(&mpt->m_doneq_mutex);
1333 MPTSAS_DISABLE_INTR(mpt);
1334 if (mptsas_register_intrs(mpt) == FALSE)
1339 mutex_init(&mpt->m_mutex, NULL, MUTEX_DRIVER,
1340 DDI_INTR_PRI(mpt->m_intr_pri));
1341 mutex_init(&mpt->m_passthru_mutex, NULL, MUTEX_DRIVER, NULL);
1342 mutex_init(&mpt->m_tx_waitq_mutex, NULL, MUTEX_DRIVER,
1343 DDI_INTR_PRI(mpt->m_intr_pri));
1345 mutex_init(&mpt->m_phy_info[i].smhba_info.phy_mutex,
1347 DDI_INTR_PRI(mpt->m_intr_pri));
1350 cv_init(&mpt->m_cv, NULL, CV_DRIVER, NULL);
1351 cv_init(&mpt->m_passthru_cv, NULL, CV_DRIVER, NULL);
1352 cv_init(&mpt->m_fw_cv, NULL, CV_DRIVER, NULL);
1353 cv_init(&mpt->m_config_cv, NULL, CV_DRIVER, NULL);
1354 cv_init(&mpt->m_fw_diag_cv, NULL, CV_DRIVER, NULL);
1357 mutex_enter(&mpt->m_mutex);
1361 if (mpt->m_options & MPTSAS_OPT_PM) {
1362 if (mptsas_init_pm(mpt)) {
1363 mutex_exit(&mpt->m_mutex);
1364 mptsas_log(mpt, CE_WARN, "mptsas pm initialization "
1373 mpt->m_softstate |= MPTSAS_SS_MSG_UNIT_RESET;
1374 if (mptsas_init_chip(mpt, TRUE) == DDI_FAILURE) {
1375 mutex_exit(&mpt->m_mutex);
1376 mptsas_log(mpt, CE_WARN, "mptsas chip initialization failed");
1380 mpt->m_targets = refhash_create(MPTSAS_TARGET_BUCKET_COUNT,
1391 mpt->m_tmp_targets = refhash_create(MPTSAS_TMP_TARGET_BUCKET_COUNT,
1399 if (mptsas_get_manufacture_page5(mpt) == DDI_FAILURE) {
1400 mptsas_log(mpt, CE_WARN,
1405 if (mptsas_get_sas_io_unit_page_hndshk(mpt)) {
1406 mptsas_log(mpt, CE_WARN,
1411 if (mptsas_get_manufacture_page0(mpt) == DDI_FAILURE) {
1412 mptsas_log(mpt, CE_WARN,
1417 mutex_exit(&mpt->m_mutex);
1422 mptsas_iport_register(mpt);
1427 if (mptsas_hba_setup(mpt) == FALSE)
1431 if (mptsas_smp_setup(mpt) == FALSE)
1435 if (mptsas_cache_create(mpt) == FALSE)
1438 mpt->m_scsi_reset_delay = ddi_prop_get_int(DDI_DEV_T_ANY,
1440 if (mpt->m_scsi_reset_delay == 0) {
1441 mptsas_log(mpt, CE_NOTE,
1444 mpt->m_scsi_reset_delay = SCSI_DEFAULT_RESET_DELAY;
1450 mpt->m_donetail = &mpt->m_doneq;
1451 mpt->m_waitqtail = &mpt->m_waitq;
1452 mpt->m_tx_waitqtail = &mpt->m_tx_waitq;
1453 mpt->m_tx_draining = 0;
1458 mpt->m_ioc_event_cmdtail = &mpt->m_ioc_event_cmdq;
1459 mpt->m_dev_handle = 0xFFFF;
1461 MPTSAS_ENABLE_INTR(mpt);
1466 mutex_enter(&mpt->m_mutex);
1467 if (mptsas_ioc_enable_event_notification(mpt)) {
1468 mutex_exit(&mpt->m_mutex);
1471 mutex_exit(&mpt->m_mutex);
1476 mptsas_list_add(mpt);
1497 if (mptsas_smhba_setup(mpt)) {
1498 mptsas_log(mpt, CE_WARN, "mptsas phy initialization "
1504 if ((mptsas_check_dma_handle(mpt->m_dma_req_frame_hdl)
1506 (mptsas_check_dma_handle(mpt->m_dma_req_sense_hdl)
1508 (mptsas_check_dma_handle(mpt->m_dma_reply_frame_hdl)
1510 (mptsas_check_dma_handle(mpt->m_dma_free_queue_hdl)
1512 (mptsas_check_dma_handle(mpt->m_dma_post_queue_hdl)
1514 (mptsas_check_dma_handle(mpt->m_hshk_dma_hdl)
1520 if ((mptsas_check_acc_handle(mpt->m_datap) != DDI_SUCCESS) ||
1521 (mptsas_check_acc_handle(mpt->m_acc_req_frame_hdl)
1523 (mptsas_check_acc_handle(mpt->m_acc_req_sense_hdl)
1525 (mptsas_check_acc_handle(mpt->m_acc_reply_frame_hdl)
1527 (mptsas_check_acc_handle(mpt->m_acc_free_queue_hdl)
1529 (mptsas_check_acc_handle(mpt->m_acc_post_queue_hdl)
1531 (mptsas_check_acc_handle(mpt->m_hshk_acc_hdl)
1533 (mptsas_check_acc_handle(mpt->m_config_handle)
1546 if (mpt->m_options & MPTSAS_OPT_PM) {
1553 mptsas_log(mpt, CE_WARN, "attach failed");
1554 mptsas_fm_ereport(mpt, DDI_FM_DEVICE_NO_RESPONSE);
1555 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_LOST);
1556 if (mpt) {
1559 mptsas_list_del(mpt);
1573 mptsas_cache_destroy(mpt);
1576 mptsas_smp_teardown(mpt);
1579 mptsas_hba_teardown(mpt);
1582 if (mpt->m_tmp_targets)
1583 refhash_destroy(mpt->m_tmp_targets);
1584 if (mpt->m_targets)
1585 refhash_destroy(mpt->m_targets);
1586 if (mpt->m_smp_targets)
1587 refhash_destroy(mpt->m_smp_targets);
1589 if (mpt->m_active) {
1590 mptsas_free_active_slots(mpt);
1593 mptsas_unregister_intrs(mpt);
1597 mutex_enter(&mpt->m_doneq_mutex);
1598 doneq_thread_num = mpt->m_doneq_thread_n;
1599 for (j = 0; j < mpt->m_doneq_thread_n; j++) {
1600 mutex_enter(&mpt->m_doneq_thread_id[j].mutex);
1601 mpt->m_doneq_thread_id[j].flag &=
1603 cv_signal(&mpt->m_doneq_thread_id[j].cv);
1604 mutex_exit(&mpt->m_doneq_thread_id[j].mutex);
1606 while (mpt->m_doneq_thread_n) {
1607 cv_wait(&mpt->m_doneq_thread_cv,
1608 &mpt->m_doneq_mutex);
1611 cv_destroy(&mpt->m_doneq_thread_id[j].cv);
1612 mutex_destroy(&mpt->m_doneq_thread_id[j].mutex);
1614 kmem_free(mpt->m_doneq_thread_id,
1617 mutex_exit(&mpt->m_doneq_mutex);
1618 cv_destroy(&mpt->m_doneq_thread_cv);
1619 mutex_destroy(&mpt->m_doneq_mutex);
1622 ddi_taskq_destroy(mpt->m_event_taskq);
1625 ddi_taskq_destroy(mpt->m_dr_taskq);
1628 mutex_destroy(&mpt->m_tx_waitq_mutex);
1629 mutex_destroy(&mpt->m_passthru_mutex);
1630 mutex_destroy(&mpt->m_mutex);
1633 &mpt->m_phy_info[i].smhba_info.phy_mutex);
1635 cv_destroy(&mpt->m_cv);
1636 cv_destroy(&mpt->m_passthru_cv);
1637 cv_destroy(&mpt->m_fw_cv);
1638 cv_destroy(&mpt->m_config_cv);
1639 cv_destroy(&mpt->m_fw_diag_cv);
1643 mptsas_cfg_fini(mpt);
1646 mptsas_config_space_fini(mpt);
1648 mptsas_free_handshake_msg(mpt);
1649 mptsas_hba_fini(mpt);
1651 mptsas_fm_fini(mpt);
1661 mptsas_t *mpt, *g;
1671 mpt = TRAN2MPT(tran);
1672 if (!mpt) {
1676 mutex_enter(&mpt->m_mutex);
1678 if (mpt->m_suspended++) {
1679 mutex_exit(&mpt->m_mutex);
1684 * Cancel timeout threads for this mpt
1686 if (mpt->m_quiesce_timeid) {
1687 timeout_id_t tid = mpt->m_quiesce_timeid;
1688 mpt->m_quiesce_timeid = 0;
1689 mutex_exit(&mpt->m_mutex);
1691 mutex_enter(&mpt->m_mutex);
1694 if (mpt->m_restart_cmd_timeid) {
1695 timeout_id_t tid = mpt->m_restart_cmd_timeid;
1696 mpt->m_restart_cmd_timeid = 0;
1697 mutex_exit(&mpt->m_mutex);
1699 mutex_enter(&mpt->m_mutex);
1702 mutex_exit(&mpt->m_mutex);
1704 (void) pm_idle_component(mpt->m_dip, 0);
1738 mutex_enter(&mpt->m_mutex);
1741 * If this mpt is not in full power(PM_LEVEL_D0), just return.
1743 if ((mpt->m_options & MPTSAS_OPT_PM) &&
1744 (mpt->m_power_level != PM_LEVEL_D0)) {
1745 mutex_exit(&mpt->m_mutex);
1750 MPTSAS_DISABLE_INTR(mpt);
1754 mptsas_raid_action_system_shutdown(mpt);
1756 mutex_exit(&mpt->m_mutex);
1759 ddi_taskq_wait(mpt->m_event_taskq);
1760 ddi_taskq_wait(mpt->m_dr_taskq);
1770 mptsas_t *mpt;
1782 if ((mpt = TRAN2MPT(tran)) == NULL)
1789 MPTSAS_DISABLE_INTR(mpt);
1790 mptsas_raid_action_system_shutdown(mpt);
1808 mptsas_t *mpt;
1820 if ((mpt = TRAN2MPT(tran)) == NULL)
1824 MPTSAS_DISABLE_INTR(mpt);
1826 mptsas_raid_action_system_shutdown(mpt);
1860 mptsas_t *mpt;
1873 mpt = TRAN2MPT(tran);
1874 if (!mpt) {
1878 * Still have pathinfo child, should not detach mpt driver
1881 if (mpt->m_mpxio_enable) {
1908 if (mpt->m_options & MPTSAS_OPT_PM) {
1910 if (mpt->m_power_level != PM_LEVEL_D0) {
1913 mptsas_log(mpt, CE_WARN,
1915 mpt->m_instance);
1927 mutex_enter(&mpt->m_mutex);
1928 MPTSAS_DISABLE_INTR(mpt);
1929 mptsas_raid_action_system_shutdown(mpt);
1930 mpt->m_softstate |= MPTSAS_SS_MSG_UNIT_RESET;
1931 (void) mptsas_ioc_reset(mpt, FALSE);
1932 mutex_exit(&mpt->m_mutex);
1933 mptsas_rem_intrs(mpt);
1934 ddi_taskq_destroy(mpt->m_event_taskq);
1935 ddi_taskq_destroy(mpt->m_dr_taskq);
1937 if (mpt->m_doneq_thread_n) {
1938 mutex_enter(&mpt->m_doneq_mutex);
1939 doneq_thread_num = mpt->m_doneq_thread_n;
1940 for (i = 0; i < mpt->m_doneq_thread_n; i++) {
1941 mutex_enter(&mpt->m_doneq_thread_id[i].mutex);
1942 mpt->m_doneq_thread_id[i].flag &=
1944 cv_signal(&mpt->m_doneq_thread_id[i].cv);
1945 mutex_exit(&mpt->m_doneq_thread_id[i].mutex);
1947 while (mpt->m_doneq_thread_n) {
1948 cv_wait(&mpt->m_doneq_thread_cv,
1949 &mpt->m_doneq_mutex);
1952 cv_destroy(&mpt->m_doneq_thread_id[i].cv);
1953 mutex_destroy(&mpt->m_doneq_thread_id[i].mutex);
1955 kmem_free(mpt->m_doneq_thread_id,
1958 mutex_exit(&mpt->m_doneq_mutex);
1959 cv_destroy(&mpt->m_doneq_thread_cv);
1960 mutex_destroy(&mpt->m_doneq_mutex);
1963 scsi_hba_reset_notify_tear_down(mpt->m_reset_notify_listf);
1965 mptsas_list_del(mpt);
1968 * Cancel timeout threads for this mpt
1970 mutex_enter(&mpt->m_mutex);
1971 if (mpt->m_quiesce_timeid) {
1972 timeout_id_t tid = mpt->m_quiesce_timeid;
1973 mpt->m_quiesce_timeid = 0;
1974 mutex_exit(&mpt->m_mutex);
1976 mutex_enter(&mpt->m_mutex);
1979 if (mpt->m_restart_cmd_timeid) {
1980 timeout_id_t tid = mpt->m_restart_cmd_timeid;
1981 mpt->m_restart_cmd_timeid = 0;
1982 mutex_exit(&mpt->m_mutex);
1984 mutex_enter(&mpt->m_mutex);
1987 mutex_exit(&mpt->m_mutex);
1990 * last mpt? ... if active, CANCEL watch threads.
2020 mptsas_destroy_phy_stats(mpt);
2022 mptsas_destroy_hashes(mpt);
2027 mutex_enter(&mpt->m_mutex);
2028 mptsas_free_active_slots(mpt);
2029 mutex_exit(&mpt->m_mutex);
2032 mptsas_cache_destroy(mpt);
2034 mptsas_hba_fini(mpt);
2035 mptsas_cfg_fini(mpt);
2038 if (mpt->m_options & MPTSAS_OPT_PM) {
2040 mptsas_log(mpt, CE_WARN,
2043 mpt->m_instance);
2046 mutex_destroy(&mpt->m_tx_waitq_mutex);
2047 mutex_destroy(&mpt->m_passthru_mutex);
2048 mutex_destroy(&mpt->m_mutex);
2050 mutex_destroy(&mpt->m_phy_info[i].smhba_info.phy_mutex);
2052 cv_destroy(&mpt->m_cv);
2053 cv_destroy(&mpt->m_passthru_cv);
2054 cv_destroy(&mpt->m_fw_cv);
2055 cv_destroy(&mpt->m_config_cv);
2056 cv_destroy(&mpt->m_fw_diag_cv);
2059 mptsas_smp_teardown(mpt);
2060 mptsas_hba_teardown(mpt);
2062 mptsas_config_space_fini(mpt);
2064 mptsas_free_handshake_msg(mpt);
2066 mptsas_fm_fini(mpt);
2074 mptsas_list_add(mptsas_t *mpt)
2079 mptsas_head = mpt;
2081 mptsas_tail->m_next = mpt;
2083 mptsas_tail = mpt;
2088 mptsas_list_del(mptsas_t *mpt)
2095 if (mptsas_head == mpt) {
2096 m = mptsas_head = mpt->m_next;
2099 if (m->m_next == mpt) {
2100 m->m_next = mpt->m_next;
2105 mptsas_log(mpt, CE_PANIC, "Not in softc list!");
2109 if (mptsas_tail == mpt) {
2116 mptsas_alloc_handshake_msg(mptsas_t *mpt, size_t alloc_size)
2120 mpt->m_hshk_dma_size = 0;
2121 task_dma_attrs = mpt->m_msg_dma_attr;
2126 if (mptsas_dma_addr_create(mpt, task_dma_attrs,
2127 &mpt->m_hshk_dma_hdl, &mpt->m_hshk_acc_hdl, &mpt->m_hshk_memp,
2131 mpt->m_hshk_dma_size = alloc_size;
2137 mptsas_free_handshake_msg(mptsas_t *mpt)
2139 if (mpt->m_hshk_dma_size == 0)
2141 mptsas_dma_addr_destroy(&mpt->m_hshk_dma_hdl, &mpt->m_hshk_acc_hdl);
2142 mpt->m_hshk_dma_size = 0;
2146 mptsas_hba_setup(mptsas_t *mpt)
2152 hba_tran = mpt->m_tran = scsi_hba_tran_alloc(mpt->m_dip,
2154 ASSERT(mpt->m_tran != NULL);
2156 hba_tran->tran_hba_private = mpt;
2197 if (scsi_hba_attach_setup(mpt->m_dip, &mpt->m_msg_dma_attr,
2199 mptsas_log(mpt, CE_WARN, "hba attach setup failed");
2201 mpt->m_tran = NULL;
2208 mptsas_hba_teardown(mptsas_t *mpt)
2210 (void) scsi_hba_detach(mpt->m_dip);
2211 if (mpt->m_tran != NULL) {
2212 scsi_hba_tran_free(mpt->m_tran);
2213 mpt->m_tran = NULL;
2218 mptsas_iport_register(mptsas_t *mpt)
2225 mutex_enter(&mpt->m_mutex);
2226 for (i = 0; i < mpt->m_num_phys; i++) {
2231 if (mpt->m_phy_info[i].attached_devhdl == 0)
2236 current_port = mpt->m_phy_info[i].port_num;
2241 for (j = 0; j < mpt->m_num_phys; j++) {
2242 if (mpt->m_phy_info[j].attached_devhdl &&
2243 (mpt->m_phy_info[j].port_num == current_port)) {
2249 for (j = 0; j < mpt->m_num_phys; j++) {
2251 mpt->m_phy_info[j].phy_mask = phy_mask;
2257 mutex_exit(&mpt->m_mutex);
2261 (void) scsi_hba_iport_register(mpt->m_dip, phy_mask_name);
2262 mutex_enter(&mpt->m_mutex);
2264 mutex_exit(&mpt->m_mutex);
2268 (void) scsi_hba_iport_register(mpt->m_dip, "v0");
2273 mptsas_smp_setup(mptsas_t *mpt)
2275 mpt->m_smptran = smp_hba_tran_alloc(mpt->m_dip);
2276 ASSERT(mpt->m_smptran != NULL);
2277 mpt->m_smptran->smp_tran_hba_private = mpt;
2278 mpt->m_smptran->smp_tran_start = mptsas_smp_start;
2279 if (smp_hba_attach_setup(mpt->m_dip, mpt->m_smptran) != DDI_SUCCESS) {
2280 mptsas_log(mpt, CE_WARN, "smp attach setup failed");
2281 smp_hba_tran_free(mpt->m_smptran);
2282 mpt->m_smptran = NULL;
2288 mpt->m_smp_targets = refhash_create(MPTSAS_SMP_BUCKET_COUNT,
2293 mpt->m_smp_devhdl = 0xFFFF;
2299 mptsas_smp_teardown(mptsas_t *mpt)
2301 (void) smp_hba_detach(mpt->m_dip);
2302 if (mpt->m_smptran != NULL) {
2303 smp_hba_tran_free(mpt->m_smptran);
2304 mpt->m_smptran = NULL;
2306 mpt->m_smp_devhdl = 0;
2310 mptsas_cache_create(mptsas_t *mpt)
2312 int instance = mpt->m_instance;
2319 mpt->m_kmem_cache = kmem_cache_create(buf,
2322 NULL, (void *)mpt, NULL, 0);
2324 if (mpt->m_kmem_cache == NULL) {
2325 mptsas_log(mpt, CE_WARN, "creating kmem cache failed");
2334 mpt->m_cache_frames = kmem_cache_create(buf,
2337 NULL, (void *)mpt, NULL, 0);
2339 if (mpt->m_cache_frames == NULL) {
2340 mptsas_log(mpt, CE_WARN, "creating cache for frames failed");
2348 mptsas_cache_destroy(mptsas_t *mpt)
2351 if (mpt->m_cache_frames) {
2352 kmem_cache_destroy(mpt->m_cache_frames);
2353 mpt->m_cache_frames = NULL;
2355 if (mpt->m_kmem_cache) {
2356 kmem_cache_destroy(mpt->m_kmem_cache);
2357 mpt->m_kmem_cache = NULL;
2367 mptsas_t *mpt;
2375 mpt = ddi_get_soft_state(mptsas_state, ddi_get_instance(dip));
2376 if (mpt == NULL) {
2380 mutex_enter(&mpt->m_mutex);
2385 if (mpt->m_busy && (mpt->m_power_level > level)) {
2386 mutex_exit(&mpt->m_mutex);
2391 NDBG11(("mptsas%d: turning power ON.", mpt->m_instance));
2392 MPTSAS_POWER_ON(mpt);
2396 while (((ioc_status = ddi_get32(mpt->m_datap,
2397 &mpt->m_reg->Doorbell)) &
2409 mpt->m_softstate &= ~MPTSAS_SS_MSG_UNIT_RESET;
2410 if (mptsas_restart_ioc(mpt) == DDI_FAILURE) {
2411 mptsas_log(mpt, CE_WARN,
2413 mutex_exit(&mpt->m_mutex);
2417 mpt->m_power_level = PM_LEVEL_D0;
2420 NDBG11(("mptsas%d: turning power OFF.", mpt->m_instance));
2421 MPTSAS_POWER_OFF(mpt);
2424 mptsas_log(mpt, CE_WARN, "mptsas%d: unknown power level <%x>.",
2425 mpt->m_instance, level);
2429 mutex_exit(&mpt->m_mutex);
2435 * chip and revison of the chip the mpt driver is using.
2438 mptsas_config_space_init(mptsas_t *mpt)
2442 if (mpt->m_config_handle != NULL)
2445 if (pci_config_setup(mpt->m_dip,
2446 &mpt->m_config_handle) != DDI_SUCCESS) {
2447 mptsas_log(mpt, CE_WARN, "cannot map configuration space.");
2455 if (pci_config_get16(mpt->m_config_handle, PCI_CONF_STAT) &
2457 pci_config_put16(mpt->m_config_handle, PCI_CONF_STAT,
2461 mptsas_setup_cmd_reg(mpt);
2466 mpt->m_devid = pci_config_get16(mpt->m_config_handle, PCI_CONF_DEVID);
2471 mpt->m_revid = pci_config_get8(mpt->m_config_handle, PCI_CONF_REVID);
2476 mpt->m_svid = pci_config_get16(mpt->m_config_handle, PCI_CONF_SUBVENID);
2477 mpt->m_ssid = pci_config_get16(mpt->m_config_handle, PCI_CONF_SUBSYSID);
2485 pci_config_put8(mpt->m_config_handle, PCI_CONF_LATENCY_TIMER,
2488 (void) mptsas_get_pci_cap(mpt);
2493 mptsas_config_space_fini(mptsas_t *mpt)
2495 if (mpt->m_config_handle != NULL) {
2496 mptsas_disable_bus_master(mpt);
2497 pci_config_teardown(&mpt->m_config_handle);
2498 mpt->m_config_handle = NULL;
2503 mptsas_setup_cmd_reg(mptsas_t *mpt)
2510 cmdreg = pci_config_get16(mpt->m_config_handle, PCI_CONF_COMM);
2514 pci_config_put16(mpt->m_config_handle, PCI_CONF_COMM, cmdreg);
2518 mptsas_disable_bus_master(mptsas_t *mpt)
2526 cmdreg = pci_config_get16(mpt->m_config_handle, PCI_CONF_COMM);
2528 pci_config_put16(mpt->m_config_handle, PCI_CONF_COMM, cmdreg);
2532 mptsas_dma_alloc(mptsas_t *mpt, mptsas_dma_alloc_state_t *dma_statep)
2536 attrs = mpt->m_io_dma_attr;
2541 if (mptsas_dma_addr_create(mpt, attrs, &dma_statep->handle,
2559 mptsas_do_dma(mptsas_t *mpt, uint32_t size, int var, int (*callback)())
2567 ASSERT(mutex_owned(&mpt->m_mutex));
2569 attrs = mpt->m_msg_dma_attr;
2573 if (mptsas_dma_addr_create(mpt, attrs, &dma_handle,
2578 rval = (*callback) (mpt, memp, var, accessp);
2582 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
2592 mptsas_alloc_request_frames(mptsas_t *mpt)
2602 if (mpt->m_dma_req_frame_hdl)
2603 mptsas_dma_addr_destroy(&mpt->m_dma_req_frame_hdl,
2604 &mpt->m_acc_req_frame_hdl);
2610 mem_size = mpt->m_max_requests * mpt->m_req_frame_size;
2616 frame_dma_attrs = mpt->m_msg_dma_attr;
2623 if (mptsas_dma_addr_create(mpt, frame_dma_attrs,
2624 &mpt->m_dma_req_frame_hdl, &mpt->m_acc_req_frame_hdl, &memp,
2632 * address is the address mpt uses to fill in the frame.
2634 mpt->m_req_frame_dma_addr = cookie.dmac_laddress;
2635 mpt->m_req_frame = memp;
2640 bzero(mpt->m_req_frame, mem_size);
2646 mptsas_alloc_sense_bufs(mptsas_t *mpt)
2657 if (mpt->m_dma_req_sense_hdl) {
2658 rmfreemap(mpt->m_erqsense_map);
2659 mptsas_dma_addr_destroy(&mpt->m_dma_req_sense_hdl,
2660 &mpt->m_acc_req_sense_hdl);
2668 mem_size = ((mpt->m_max_requests - 2) * mpt->m_req_sense_size) +
2675 sense_dma_attrs = mpt->m_msg_dma_attr;
2682 if (mptsas_dma_addr_create(mpt, sense_dma_attrs,
2683 &mpt->m_dma_req_sense_hdl, &mpt->m_acc_req_sense_hdl, &memp,
2691 * address is the address mpt uses to access the data.
2694 mpt->m_req_sense_dma_addr = cookie.dmac_laddress;
2695 mpt->m_req_sense = memp;
2696 memp += (mpt->m_max_requests - 2) * mpt->m_req_sense_size;
2697 mpt->m_extreq_sense = memp;
2705 mpt->m_req_sense_size;
2706 mpt->m_erqsense_map = rmallocmap_wait(num_extrqsense_bufs);
2707 rmfree(mpt->m_erqsense_map, num_extrqsense_bufs, 1);
2712 bzero(mpt->m_req_sense, mem_size);
2718 mptsas_alloc_reply_frames(mptsas_t *mpt)
2728 if (mpt->m_dma_reply_frame_hdl) {
2729 mptsas_dma_addr_destroy(&mpt->m_dma_reply_frame_hdl,
2730 &mpt->m_acc_reply_frame_hdl);
2737 mem_size = mpt->m_max_replies * mpt->m_reply_frame_size;
2743 frame_dma_attrs = mpt->m_msg_dma_attr;
2749 if (mptsas_dma_addr_create(mpt, frame_dma_attrs,
2750 &mpt->m_dma_reply_frame_hdl, &mpt->m_acc_reply_frame_hdl, &memp,
2758 * address is the address mpt uses to process the frame.
2760 mpt->m_reply_frame_dma_addr = cookie.dmac_laddress;
2761 mpt->m_reply_frame = memp;
2766 bzero(mpt->m_reply_frame, mem_size);
2772 mptsas_alloc_free_queue(mptsas_t *mpt)
2782 if (mpt->m_dma_free_queue_hdl) {
2783 mptsas_dma_addr_destroy(&mpt->m_dma_free_queue_hdl,
2784 &mpt->m_acc_free_queue_hdl);
2793 mem_size = mpt->m_free_queue_depth * 4;
2799 frame_dma_attrs = mpt->m_msg_dma_attr;
2806 if (mptsas_dma_addr_create(mpt, frame_dma_attrs,
2807 &mpt->m_dma_free_queue_hdl, &mpt->m_acc_free_queue_hdl, &memp,
2815 * is the address mpt uses to manage the queue.
2817 mpt->m_free_queue_dma_addr = cookie.dmac_laddress;
2818 mpt->m_free_queue = memp;
2823 bzero(mpt->m_free_queue, mem_size);
2829 mptsas_alloc_post_queue(mptsas_t *mpt)
2839 if (mpt->m_dma_post_queue_hdl) {
2840 mptsas_dma_addr_destroy(&mpt->m_dma_post_queue_hdl,
2841 &mpt->m_acc_post_queue_hdl);
2849 mem_size = mpt->m_post_queue_depth * 8;
2855 frame_dma_attrs = mpt->m_msg_dma_attr;
2862 if (mptsas_dma_addr_create(mpt, frame_dma_attrs,
2863 &mpt->m_dma_post_queue_hdl, &mpt->m_acc_post_queue_hdl, &memp,
2871 * second address is the address mpt uses to manage the queue.
2873 mpt->m_post_queue_dma_addr = cookie.dmac_laddress;
2874 mpt->m_post_queue = memp;
2879 bzero(mpt->m_post_queue, mem_size);
2885 mptsas_alloc_reply_args(mptsas_t *mpt)
2887 if (mpt->m_replyh_args == NULL) {
2888 mpt->m_replyh_args = kmem_zalloc(sizeof (m_replyh_arg_t) *
2889 mpt->m_max_replies, KM_SLEEP);
2894 mptsas_alloc_extra_sgl_frame(mptsas_t *mpt, mptsas_cmd_t *cmd)
2898 frames = kmem_cache_alloc(mpt->m_cache_frames, KM_NOSLEEP);
2908 mptsas_free_extra_sgl_frame(mptsas_t *mpt, mptsas_cmd_t *cmd)
2911 kmem_cache_free(mpt->m_cache_frames,
2918 mptsas_cfg_fini(mptsas_t *mpt)
2921 ddi_regs_map_free(&mpt->m_datap);
2925 mptsas_hba_fini(mptsas_t *mpt)
2932 if (mpt->m_dma_req_frame_hdl) {
2933 mptsas_dma_addr_destroy(&mpt->m_dma_req_frame_hdl,
2934 &mpt->m_acc_req_frame_hdl);
2937 if (mpt->m_dma_req_sense_hdl) {
2938 rmfreemap(mpt->m_erqsense_map);
2939 mptsas_dma_addr_destroy(&mpt->m_dma_req_sense_hdl,
2940 &mpt->m_acc_req_sense_hdl);
2943 if (mpt->m_dma_reply_frame_hdl) {
2944 mptsas_dma_addr_destroy(&mpt->m_dma_reply_frame_hdl,
2945 &mpt->m_acc_reply_frame_hdl);
2948 if (mpt->m_dma_free_queue_hdl) {
2949 mptsas_dma_addr_destroy(&mpt->m_dma_free_queue_hdl,
2950 &mpt->m_acc_free_queue_hdl);
2953 if (mpt->m_dma_post_queue_hdl) {
2954 mptsas_dma_addr_destroy(&mpt->m_dma_post_queue_hdl,
2955 &mpt->m_acc_post_queue_hdl);
2958 if (mpt->m_replyh_args != NULL) {
2959 kmem_free(mpt->m_replyh_args, sizeof (m_replyh_arg_t)
2960 * mpt->m_max_replies);
3022 mptsas_t *mpt;
3031 mpt = SDEV2MPT(sd);
3059 mptsas_log(mpt, CE_WARN, "Get lun property failed\n");
3088 mutex_enter(&mpt->m_mutex);
3089 ptgt = refhash_lookup(mpt->m_targets, &addr);
3090 mutex_exit(&mpt->m_mutex);
3092 mptsas_log(mpt, CE_WARN, "!tgt_init: target doesn't exist or "
3108 mutex_enter(&mpt->m_mutex);
3122 mutex_exit(&mpt->m_mutex);
3129 rval = mptsas_inquiry(mpt, ptgt, 0, 0x89,
3137 mptsas_log(mpt, CE_WARN, "!mptsas request inquiry page "
3167 mutex_exit(&mpt->m_mutex);
3210 mptsas_t *mpt = PKT2MPT(pkt);
3266 if (mpt->m_doneq_thread_n) {
3267 if (mutex_tryenter(&mpt->m_mutex) != 0) {
3268 rval = mptsas_accept_txwq_and_pkt(mpt, cmd);
3269 mutex_exit(&mpt->m_mutex);
3271 mutex_enter(&mpt->m_mutex);
3272 rval = mptsas_accept_txwq_and_pkt(mpt, cmd);
3273 mutex_exit(&mpt->m_mutex);
3275 mutex_enter(&mpt->m_tx_waitq_mutex);
3290 mutex_exit(&mpt->m_tx_waitq_mutex);
3298 mutex_exit(&mpt->m_tx_waitq_mutex);
3302 if (mpt->m_tx_draining) {
3304 *mpt->m_tx_waitqtail = cmd;
3305 mpt->m_tx_waitqtail = &cmd->cmd_linkp;
3306 mutex_exit(&mpt->m_tx_waitq_mutex);
3308 mpt->m_tx_draining = 1;
3309 mutex_exit(&mpt->m_tx_waitq_mutex);
3310 mutex_enter(&mpt->m_mutex);
3311 rval = mptsas_accept_txwq_and_pkt(mpt, cmd);
3312 mutex_exit(&mpt->m_mutex);
3316 mutex_enter(&mpt->m_mutex);
3329 mutex_exit(&mpt->m_mutex);
3336 mutex_exit(&mpt->m_mutex);
3340 rval = mptsas_accept_pkt(mpt, cmd);
3341 mutex_exit(&mpt->m_mutex);
3351 mptsas_accept_txwq_and_pkt(mptsas_t *mpt, mptsas_cmd_t *cmd)
3356 ASSERT(mutex_owned(&mpt->m_mutex));
3359 * because that is where mpt->m_tx_draining is cleared.
3361 mutex_enter(&mpt->m_tx_waitq_mutex);
3362 mptsas_accept_tx_waitq(mpt);
3363 mutex_exit(&mpt->m_tx_waitq_mutex);
3385 rval = mptsas_accept_pkt(mpt, cmd);
3391 mptsas_accept_pkt(mptsas_t *mpt, mptsas_cmd_t *cmd)
3398 ASSERT(mutex_owned(&mpt->m_mutex));
3415 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
3425 if ((ptgt->m_devhdl == MPTSAS_INVALID_DEVHDL) && mpt->m_in_reset) {
3426 mptsas_set_pkt_reason(mpt, cmd, CMD_RESET, STAT_BUS_RESET);
3428 mptsas_doneq_add(mpt, cmd);
3429 mptsas_doneq_empty(mpt);
3446 mptsas_set_pkt_reason(mpt, cmd, CMD_DEV_GONE, STAT_TERMINATED);
3448 mptsas_doneq_add(mpt, cmd);
3449 mptsas_doneq_empty(mpt);
3456 * The first case is the normal case. mpt gets a command from the
3461 if ((mpt->m_ncmds <= (mpt->m_max_requests - 2)) &&
3467 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
3468 (void) mptsas_start_cmd(mpt, cmd);
3470 mptsas_waitq_add(mpt, cmd);
3476 mptsas_waitq_add(mpt, cmd);
3479 (void) mptsas_poll(mpt, cmd, MPTSAS_POLL_TIME);
3487 mptsas_doneq_empty(mpt);
3495 mptsas_save_cmd(mptsas_t *mpt, mptsas_cmd_t *cmd)
3497 mptsas_slots_t *slots = mpt->m_active;
3501 ASSERT(MUTEX_HELD(&mpt->m_mutex));
3506 ASSERT(slots->m_n_normal == (mpt->m_max_requests - 2));
3533 mpt->m_ncmds++;
3619 mptsas_t *mpt = ADDR2MPT(ap);
3657 cmd = kmem_cache_alloc(mpt->m_kmem_cache, kf);
3687 failure = mptsas_pkt_alloc_extern(mpt, cmd,
3820 mptsas_log(mpt, CE_NOTE, "large cookiec received %d\n",
3832 if ((cmd->cmd_cookiec > MPTSAS_MAX_FRAME_SGES64(mpt)) &&
3834 if (mptsas_alloc_extra_sgl_frame(mpt, cmd) ==
3836 mptsas_log(mpt, CE_WARN, "MPT SGL mem alloc "
3872 mptsas_log(mpt, CE_WARN,
3959 mptsas_t *mpt = ADDR2MPT(ap);
3974 mptsas_free_extra_sgl_frame(mpt, cmd);
3980 kmem_cache_free(mpt->m_kmem_cache, (void *)cmd);
3982 mptsas_pkt_destroy_extern(mpt, cmd);
3995 mptsas_t *mpt = cdrarg;
4005 if ((ddi_dma_alloc_handle(mpt->m_dip, &mpt->m_io_dma_attr, callback,
4033 mptsas_t *mpt = cdrarg;
4041 frame_dma_attr = mpt->m_msg_dma_attr;
4045 if (ddi_dma_alloc_handle(mpt->m_dip, &frame_dma_attr, callback, NULL,
4047 mptsas_log(mpt, CE_WARN, "Unable to allocate dma handle for"
4052 mem_size = (mpt->m_max_request_frames - 1) * mpt->m_req_frame_size;
4054 if (ddi_dma_mem_alloc(p->m_dma_hdl, mem_size, &mpt->m_dev_acc_attr,
4059 mptsas_log(mpt, CE_WARN, "Unable to allocate dma memory for"
4070 mptsas_log(mpt, CE_WARN, "Unable to bind DMA resources for"
4078 * address is the address mpt uses to fill in the SGL.
4109 mptsas_cmdarqsize(mptsas_t *mpt, mptsas_cmd_t *cmd, size_t senselength, int kf)
4111 if (senselength > mpt->m_req_sense_size) {
4118 (mpt->m_req_sense_size - 1))/mpt->m_req_sense_size;
4120 (mpt->m_erqsense_map, cmd->cmd_extrqschunks);
4127 cmd->cmd_arq_buf = mpt->m_extreq_sense +
4128 (cmd->cmd_extrqsidx * mpt->m_req_sense_size);
4143 mptsas_pkt_alloc_extern(mptsas_t *mpt, mptsas_cmd_t *cmd,
4178 if (mptsas_cmdarqsize(mpt, cmd, statuslen -
4185 mptsas_pkt_destroy_extern(mpt, cmd);
4193 mptsas_pkt_destroy_extern(mptsas_t *mpt, mptsas_cmd_t *cmd)
4198 mptsas_log(mpt, CE_PANIC,
4204 rmfree(mpt->m_erqsense_map, cmd->cmd_extrqschunks,
4217 kmem_cache_free(mpt->m_kmem_cache, (void *)cmd);
4247 mptsas_t *mpt = ADDR2MPT(ap);
4257 mptsas_free_extra_sgl_frame(mpt, cmd);
4317 mptsas_sge_chain(mptsas_t *mpt, mptsas_cmd_t *cmd,
4349 * frames go into the mpt SGL buffer allocated on the fly,
4375 sgemax = ((mpt->m_req_frame_size / sizeof (MPI2_SGE_SIMPLE64))
4377 temp = (cookiec - (MPTSAS_MAX_FRAME_SGES64(mpt) - 1)) / sgemax;
4383 if ((cookiec - (MPTSAS_MAX_FRAME_SGES64(mpt) - 1)) - (temp *
4395 j = MPTSAS_MAX_FRAME_SGES64(mpt) - 1;
4434 ASSERT(mpt->m_req_frame_size >= sizeof (MPI2_SGE_SIMPLE64));
4435 chainlength = mpt->m_req_frame_size /
4506 (mpt->m_req_frame_size * k);
4529 mpt->m_req_frame_size /
4551 (int)mpt->m_req_frame_size * k);
4657 mptsas_ieee_sge_chain(mptsas_t *mpt, mptsas_cmd_t *cmd,
4691 * frames go into the mpt SGL buffer allocated on the fly,
4712 sgemax = ((mpt->m_req_frame_size / sizeof (MPI2_IEEE_SGE_SIMPLE64))
4714 temp = (cookiec - (MPTSAS_MAX_FRAME_SGES64(mpt) - 1)) / sgemax;
4720 if ((cookiec - (MPTSAS_MAX_FRAME_SGES64(mpt) - 1)) - (temp *
4733 j = MPTSAS_MAX_FRAME_SGES64(mpt) - 1;
4769 ASSERT(mpt->m_req_frame_size >=
4771 chainlength = mpt->m_req_frame_size /
4841 (mpt->m_req_frame_size * k);
4862 ASSERT(mpt->m_req_frame_size >=
4866 mpt->m_req_frame_size /
4888 (int)mpt->m_req_frame_size * k);
4932 mptsas_sge_setup(mptsas_t *mpt, mptsas_cmd_t *cmd, uint32_t *control,
4960 if (cmd->cmd_cookiec <= MPTSAS_MAX_FRAME_SGES64(mpt)) {
4961 if (mpt->m_MPI25) {
4974 if (mpt->m_MPI25) {
4975 mptsas_ieee_sge_chain(mpt, cmd, frame, acc_hdl);
4977 mptsas_sge_chain(mpt, cmd, frame, acc_hdl);
4988 mptsas_poll(mptsas_t *mpt, mptsas_cmd_t *poll_cmd, int polltime)
4995 mptsas_restart_hba(mpt);
5013 if (mptsas_wait_intr(mpt, polltime) == FALSE) {
5026 mptsas_set_pkt_reason(mpt, poll_cmd, CMD_TIMEOUT,
5039 mptsas_waitq_delete(mpt, poll_cmd);
5043 mptsas_fma_check(mpt, poll_cmd);
5052 mptsas_wait_intr(mptsas_t *mpt, int polltime)
5060 mpt->m_polled_intr = 1;
5066 int_mask = ddi_get32(mpt->m_datap, &mpt->m_reg->HostInterruptMask);
5067 MPTSAS_DISABLE_INTR(mpt);
5073 (void) ddi_dma_sync(mpt->m_dma_post_queue_hdl, 0, 0,
5077 MPTSAS_GET_NEXT_REPLY(mpt, mpt->m_post_index);
5079 if (ddi_get32(mpt->m_acc_post_queue_hdl,
5081 ddi_get32(mpt->m_acc_post_queue_hdl,
5091 mptsas_process_intr(mpt, reply_desc_union);
5093 if (++mpt->m_post_index == mpt->m_post_queue_depth) {
5094 mpt->m_post_index = 0;
5100 ddi_put32(mpt->m_datap,
5101 &mpt->m_reg->ReplyPostHostIndex, mpt->m_post_index);
5102 mpt->m_polled_intr = 0;
5107 ddi_put32(mpt->m_datap, &mpt->m_reg->HostInterruptMask,
5116 mpt->m_polled_intr = 0;
5117 ddi_put32(mpt->m_datap, &mpt->m_reg->HostInterruptMask, int_mask);
5122 mptsas_handle_scsi_io_success(mptsas_t *mpt,
5127 mptsas_slots_t *slots = mpt->m_active;
5131 ASSERT(mutex_owned(&mpt->m_mutex));
5134 SMID = ddi_get16(mpt->m_acc_post_queue_hdl, &scsi_io_success->SMID);
5142 mptsas_log(mpt, CE_WARN, "?Received invalid SMID of %d\n",
5144 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
5154 mptsas_log(mpt, CE_WARN, "?NULL command for successful SCSI IO "
5169 cv_broadcast(&mpt->m_passthru_cv);
5172 mptsas_remove_cmd(mpt, cmd);
5187 mptsas_doneq_add(mpt, cmd);
5192 mptsas_handle_address_reply(mptsas_t *mpt,
5200 mptsas_slots_t *slots = mpt->m_active;
5206 ASSERT(mutex_owned(&mpt->m_mutex));
5209 reply_addr = ddi_get32(mpt->m_acc_post_queue_hdl,
5211 SMID = ddi_get16(mpt->m_acc_post_queue_hdl, &address_reply->SMID);
5217 reply_frame_dma_baseaddr = mpt->m_reply_frame_dma_addr & 0xffffffffu;
5220 (mpt->m_reply_frame_size * mpt->m_max_replies))) ||
5222 mpt->m_reply_frame_size != 0)) {
5223 mptsas_log(mpt, CE_WARN, "?Received invalid reply frame "
5225 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
5229 (void) ddi_dma_sync(mpt->m_dma_reply_frame_hdl, 0, 0,
5231 reply = (pMPI2DefaultReply_t)(mpt->m_reply_frame + (reply_addr -
5233 function = ddi_get8(mpt->m_acc_reply_frame_hdl, &reply->Function);
5249 mptsas_log(mpt, CE_WARN, "?Received invalid SMID of "
5251 ddi_fm_service_impact(mpt->m_dip,
5262 mptsas_log(mpt, CE_WARN, "?NULL command for address "
5270 cv_broadcast(&mpt->m_passthru_cv);
5271 cv_broadcast(&mpt->m_config_cv);
5272 cv_broadcast(&mpt->m_fw_diag_cv);
5275 mptsas_remove_cmd(mpt, cmd);
5285 mptsas_check_scsi_io_error(mpt, (pMpi2SCSIIOReply_t)reply, cmd);
5289 mptsas_check_task_mgt(mpt, (pMpi2SCSIManagementReply_t)reply,
5294 cv_signal(&mpt->m_fw_cv);
5298 mpt->m_reply_frame_size;
5299 args = &mpt->m_replyh_args[reply_frame_no];
5300 args->mpt = (void *)mpt;
5305 * this mpt instance by ioctl.
5322 if (mpt->m_in_reset) {
5327 if ((ddi_taskq_dispatch(mpt->m_event_taskq, mptsas_handle_event,
5329 mptsas_log(mpt, CE_WARN, "No memory available"
5334 ddi_put32(mpt->m_acc_free_queue_hdl,
5336 mpt->m_free_queue)[mpt->m_free_index], reply_addr);
5337 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
5339 if (++mpt->m_free_index == mpt->m_free_queue_depth) {
5340 mpt->m_free_index = 0;
5343 ddi_put32(mpt->m_datap,
5344 &mpt->m_reg->ReplyFreeHostIndex, mpt->m_free_index);
5354 iocstatus = ddi_get16(mpt->m_acc_reply_frame_hdl,
5356 buffer_type = ddi_get8(mpt->m_acc_reply_frame_hdl,
5360 &mpt->m_fw_diag_buffer_list[buffer_type];
5375 mptsas_log(mpt, CE_WARN, "?NULL command for "
5381 cv_broadcast(&mpt->m_fw_diag_cv);
5385 mptsas_log(mpt, CE_WARN, "Unknown function 0x%x ", function);
5392 ddi_put32(mpt->m_acc_free_queue_hdl,
5393 &((uint32_t *)(void *)mpt->m_free_queue)[mpt->m_free_index],
5395 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
5397 if (++mpt->m_free_index == mpt->m_free_queue_depth) {
5398 mpt->m_free_index = 0;
5400 ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyFreeHostIndex,
5401 mpt->m_free_index);
5418 mptsas_doneq_add(mpt, cmd);
5427 mptsas_check_scsi_io_error(mptsas_t *mpt, pMpi2SCSIIOReply_t reply,
5441 scsi_status = ddi_get8(mpt->m_acc_reply_frame_hdl, &reply->SCSIStatus);
5442 ioc_status = ddi_get16(mpt->m_acc_reply_frame_hdl, &reply->IOCStatus);
5443 scsi_state = ddi_get8(mpt->m_acc_reply_frame_hdl, &reply->SCSIState);
5444 xferred = ddi_get32(mpt->m_acc_reply_frame_hdl, &reply->TransferCount);
5445 sensecount = ddi_get32(mpt->m_acc_reply_frame_hdl, &reply->SenseCount);
5446 responsedata = ddi_get32(mpt->m_acc_reply_frame_hdl,
5457 loginfo = ddi_get32(mpt->m_acc_reply_frame_hdl,
5459 mptsas_log(mpt, CE_NOTE,
5488 mptsas_set_throttle(mpt, ptgt,
5497 mptsas_log(mpt, CE_NOTE, "Do not support the TLR\n");
5525 (void) ddi_dma_sync(mpt->m_dma_req_sense_hdl, 0, 0,
5552 mptsas_log(mpt, CE_NOTE, "Aborted_command!");
5571 mptsas_log(mpt, CE_NOTE, "No memory"
5576 topo_node->mpt = mpt;
5583 if ((ddi_taskq_dispatch(mpt->m_dr_taskq,
5589 mptsas_log(mpt, CE_NOTE, "mptsas start taskq"
5601 mptsas_set_throttle(mpt, ptgt, DRAIN_THROTTLE);
5633 mptsas_set_pkt_reason(mpt, cmd, CMD_TIMEOUT,
5636 mptsas_set_pkt_reason(mpt, cmd, CMD_RESET,
5642 mptsas_set_pkt_reason(mpt,
5648 mptsas_set_pkt_reason(mpt,
5656 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
5657 ptgt = refhash_next(mpt->m_targets, ptgt)) {
5658 mptsas_set_throttle(mpt, ptgt, DRAIN_THROTTLE);
5667 (void) mptsas_accept_pkt(mpt, cmd);
5670 mptsas_log(mpt, CE_WARN,
5672 mptsas_log(mpt, CE_CONT, "scsi_state = %x, transfer "
5679 mptsas_handle_qfull(mpt, cmd);
5688 mptsas_log(mpt, CE_WARN, "scsi_status=%x, ioc_status=%x\n",
5690 mptsas_log(mpt, CE_WARN,
5697 mptsas_check_task_mgt(mptsas_t *mpt, pMpi2SCSIManagementReply_t reply,
5706 task_type = ddi_get8(mpt->m_acc_reply_frame_hdl, &reply->TaskType);
5707 ioc_status = ddi_get16(mpt->m_acc_reply_frame_hdl, &reply->IOCStatus);
5708 log_info = ddi_get32(mpt->m_acc_reply_frame_hdl, &reply->IOCLogInfo);
5709 dev_handle = ddi_get16(mpt->m_acc_reply_frame_hdl, &reply->DevHandle);
5712 mptsas_log(mpt, CE_WARN, "mptsas_check_task_mgt: Task 0x%x "
5735 mptsas_log(mpt, CE_WARN, "!Can't flush target with"
5738 mptsas_flush_target(mpt, dev_handle, Lun(cmd),
5743 mptsas_log(mpt, CE_WARN, "Unknown task management type %d.",
5745 mptsas_log(mpt, CE_WARN, "ioc status = %x", ioc_status);
5753 mptsas_t *mpt = arg->mpt;
5757 mptsas_doneq_thread_list_t *item = &mpt->m_doneq_thread_id[t];
5765 if ((cmd = mptsas_doneq_thread_rm(mpt, t)) != NULL) {
5776 mutex_enter(&mpt->m_doneq_mutex);
5777 mpt->m_doneq_thread_n--;
5778 cv_broadcast(&mpt->m_doneq_thread_cv);
5779 mutex_exit(&mpt->m_doneq_mutex);
5784 * mpt interrupt handler.
5789 mptsas_t *mpt = (void *)arg1;
5795 mutex_enter(&mpt->m_mutex);
5802 if ((mpt->m_options & MPTSAS_OPT_PM) &&
5803 (mpt->m_power_level != PM_LEVEL_D0)) {
5804 mutex_exit(&mpt->m_mutex);
5814 if (mpt->m_polled_intr) {
5815 mutex_exit(&mpt->m_mutex);
5816 mptsas_log(mpt, CE_WARN, "mpt_sas: Unclaimed interrupt");
5823 if ((INTPENDING(mpt)) != 0) {
5831 (void) ddi_dma_sync(mpt->m_dma_post_queue_hdl, 0, 0,
5834 MPTSAS_GET_NEXT_REPLY(mpt, mpt->m_post_index);
5836 if (ddi_get32(mpt->m_acc_post_queue_hdl,
5838 ddi_get32(mpt->m_acc_post_queue_hdl,
5850 mptsas_process_intr(mpt, reply_desc_union);
5855 if (++mpt->m_post_index == mpt->m_post_queue_depth) {
5856 mpt->m_post_index = 0;
5865 ddi_put32(mpt->m_datap,
5866 &mpt->m_reg->ReplyPostHostIndex, mpt->m_post_index);
5869 mutex_exit(&mpt->m_mutex);
5882 if (!mpt->m_doneq_thread_n ||
5883 (mpt->m_doneq_len <= mpt->m_doneq_length_threshold)) {
5884 mptsas_doneq_empty(mpt);
5886 mptsas_deliver_doneq_thread(mpt);
5892 if (mpt->m_waitq != NULL) {
5893 mptsas_restart_waitq(mpt);
5896 mutex_exit(&mpt->m_mutex);
5901 mptsas_process_intr(mptsas_t *mpt,
5906 ASSERT(mutex_owned(&mpt->m_mutex));
5913 reply_type = ddi_get8(mpt->m_acc_post_queue_hdl,
5918 mptsas_handle_scsi_io_success(mpt, reply_desc_union);
5920 mptsas_handle_address_reply(mpt, reply_desc_union);
5922 mptsas_log(mpt, CE_WARN, "?Bad reply type %x", reply_type);
5923 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
5930 ddi_put64(mpt->m_acc_post_queue_hdl,
5931 &((uint64_t *)(void *)mpt->m_post_queue)[mpt->m_post_index],
5933 (void) ddi_dma_sync(mpt->m_dma_post_queue_hdl, 0, 0,
5941 mptsas_handle_qfull(mptsas_t *mpt, mptsas_cmd_t *cmd)
5956 mptsas_set_throttle(mpt, ptgt, DRAIN_THROTTLE);
5967 (void) mptsas_accept_pkt(mpt, cmd);
5983 mptsas_set_throttle(mpt, ptgt, QFULL_THROTTLE);
5984 if (mpt->m_restart_cmd_timeid == 0) {
5985 mpt->m_restart_cmd_timeid =
5986 timeout(mptsas_restart_cmd, mpt,
5994 mptsas_physport_to_phymask(mptsas_t *mpt, uint8_t physport)
5999 NDBG20(("mptsas%d physport_to_phymask enter", mpt->m_instance));
6001 ASSERT(mutex_owned(&mpt->m_mutex));
6011 if (mpt->m_phy_info[i].attached_devhdl &&
6012 (mpt->m_phy_info[i].phy_mask != 0) &&
6013 (mpt->m_phy_info[i].port_num == physport)) {
6014 phy_mask = mpt->m_phy_info[i].phy_mask;
6019 mpt->m_instance, physport, phy_mask));
6024 * mpt free device handle after device gone, by use of passthrough
6027 mptsas_free_devhdl(mptsas_t *mpt, uint16_t devhdl)
6033 ASSERT(mutex_owned(&mpt->m_mutex));
6046 ret = mptsas_do_passthru(mpt, (uint8_t *)&req, (uint8_t *)&rep, NULL,
6065 mptsas_update_phymask(mptsas_t *mpt)
6072 NDBG20(("mptsas%d update phymask ", mpt->m_instance));
6074 ASSERT(mutex_owned(&mpt->m_mutex));
6076 (void) mptsas_get_sas_io_unit_page(mpt);
6080 for (i = 0; i < mpt->m_num_phys; i++) {
6083 if (mpt->m_phy_info[i].attached_devhdl == 0)
6088 current_port = mpt->m_phy_info[i].port_num;
6093 for (j = 0; j < mpt->m_num_phys; j++) {
6094 if (mpt->m_phy_info[j].attached_devhdl &&
6095 (mpt->m_phy_info[j].port_num == current_port)) {
6101 for (j = 0; j < mpt->m_num_phys; j++) {
6103 mpt->m_phy_info[j].phy_mask = phy_mask;
6109 mutex_exit(&mpt->m_mutex);
6114 (void) scsi_hba_iport_register(mpt->m_dip, phy_mask_name);
6115 mutex_enter(&mpt->m_mutex);
6118 NDBG20(("mptsas%d update phymask return", mpt->m_instance));
6135 mptsas_t *mpt;
6145 mpt = topo_node->mpt;
6151 NDBG20(("mptsas%d handle_dr enter", mpt->m_instance));
6179 mutex_enter(&mpt->m_mutex);
6180 if (mpt->m_port_chng && port_update) {
6182 * mpt->m_port_chng flag indicates some PHYs of initiator
6188 (void) mptsas_update_phymask(mpt);
6189 mpt->m_port_chng = 0;
6192 mutex_exit(&mpt->m_mutex);
6226 mutex_enter(&mpt->m_mutex);
6234 physport = mpt->m_phy_info[physport].port_num;
6241 phymask = mptsas_physport_to_phymask(mpt,
6243 mutex_exit(&mpt->m_mutex);
6261 mutex_enter(&mpt->m_mutex);
6267 mutex_exit(&mpt->m_mutex);
6274 parent = scsi_hba_iport_find(mpt->m_dip,
6277 mptsas_log(mpt, CE_WARN, "Failed to find an "
6286 mutex_enter(&mpt->m_mutex);
6291 if (!mpt->m_in_reset)
6299 mutex_exit(&mpt->m_mutex);
6323 mptsas_t *mpt = (void *)topo_node->mpt;
6336 "event 0x%x, flags 0x%x", mpt->m_instance, topo_node->devhdl,
6339 ASSERT(mutex_owned(&mpt->m_mutex));
6351 (void) mptsas_get_raid_info(mpt);
6352 ptgt = refhash_linear_search(mpt->m_targets,
6365 (void) mptsas_get_raid_info(mpt);
6375 rval = mptsas_get_target_device_info(mpt, page_address,
6378 mptsas_log(mpt, CE_NOTE,
6383 mptsas_log(mpt, CE_NOTE,
6387 mptsas_log(mpt, CE_NOTE,
6403 mutex_exit(&mpt->m_mutex);
6410 parent = scsi_hba_iport_find(mpt->m_dip,
6414 mptsas_log(mpt, CE_WARN, "Failed to find a "
6416 mutex_enter(&mpt->m_mutex);
6455 mptsas_log(mpt, CE_WARN, "Failed to"
6464 mptsas_log(mpt, CE_WARN, "Failed to"
6472 mutex_enter(&mpt->m_mutex);
6473 if (mptsas_smhba_phy_init(mpt)) {
6474 mutex_exit(&mpt->m_mutex);
6475 mptsas_log(mpt, CE_WARN, "mptsas phy"
6479 mutex_exit(&mpt->m_mutex);
6485 mptsas_smhba_set_one_phy_props(mpt, parent,
6493 mptsas_log(mpt, CE_WARN,
6500 mutex_enter(&mpt->m_mutex);
6503 "phymask:%x.", mpt->m_instance, ptgt->m_devhdl,
6510 ptgt = refhash_linear_search(mpt->m_targets,
6534 (void) mptsas_get_raid_info(mpt);
6539 rval = mptsas_do_scsi_reset(mpt, devhdl);
6543 mpt->m_instance, ptgt->m_devhdl,
6547 mutex_exit(&mpt->m_mutex);
6555 "phymask:%x, rval:%x", mpt->m_instance,
6571 mptsas_log(mpt, CE_WARN, "mptsas attached port "
6580 mptsas_log(mpt, CE_WARN, "mptsas num phys "
6589 mptsas_log(mpt, CE_WARN, "mptsas virtual port "
6595 mutex_enter(&mpt->m_mutex);
6597 (void) mptsas_flush_led_status(mpt, ptgt);
6599 refhash_remove(mpt->m_targets, ptgt);
6609 mutex_enter(&mpt->m_tx_waitq_mutex);
6611 mutex_exit(&mpt->m_tx_waitq_mutex);
6619 rval = mptsas_free_devhdl(mpt, devhdl);
6622 "devhdl:%x, rval:%x", mpt->m_instance, devhdl,
6635 rval = mptsas_do_scsi_reset(mpt, devhdl);
6637 NDBG20(("mpt%d reset target before remove "
6638 "devhdl:%x, rval:%x", mpt->m_instance,
6646 rval = mptsas_free_devhdl(mpt, devhdl);
6648 "devhdl:%x, rval:%x", mpt->m_instance, devhdl,
6661 rval = mptsas_get_sas_expander_page0(mpt, page_address, &smp);
6663 mptsas_log(mpt, CE_WARN, "failed to online smp, "
6668 psmp = mptsas_smp_alloc(mpt, &smp);
6673 mutex_exit(&mpt->m_mutex);
6678 mutex_enter(&mpt->m_mutex);
6686 psmp = refhash_linear_search(mpt->m_smp_targets,
6694 mutex_exit(&mpt->m_mutex);
6708 mptsas_log(mpt, CE_WARN, "mptsas virtual port "
6720 mptsas_log(mpt, CE_WARN, "mptsas num phys"
6733 mptsas_log(mpt, CE_WARN, "mptsas attached port "
6739 mutex_enter(&mpt->m_mutex);
6741 "rval:%x", mpt->m_instance, psmp->m_devhdl, rval));
6743 refhash_remove(mpt->m_smp_targets, psmp);
6758 * Record the event if its type is enabled in mpt instance by ioctl.
6766 mptsas_t *mpt;
6773 mpt = replyh_arg->mpt;
6776 (mpt->m_reply_frame + (rfm -
6777 (mpt->m_reply_frame_dma_addr & 0xffffffffu)));
6778 event = ddi_get16(mpt->m_acc_reply_frame_hdl, &eventreply->Event);
6796 if ((i < 4) && ((1 << j) & mpt->m_event_mask[i])) {
6797 i = mpt->m_event_index;
6798 mpt->m_events[i].Type = event;
6799 mpt->m_events[i].Number = ++mpt->m_event_number;
6800 bzero(mpt->m_events[i].Data, MPTSAS_MAX_EVENT_DATA_LENGTH * 4);
6801 event_data_len = ddi_get16(mpt->m_acc_reply_frame_hdl,
6812 mpt->m_events[i].Data[j] =
6813 ddi_get32(mpt->m_acc_reply_frame_hdl,
6823 mpt->m_event_index = (uint8_t)i;
6837 (void) ddi_log_sysevent(mpt->m_dip, DDI_VENDOR_LSI, "MPT_SAS",
6855 mptsas_t *mpt;
6860 mpt = replyh_arg->mpt;
6862 ASSERT(mutex_owned(&mpt->m_mutex));
6865 (mpt->m_reply_frame + (rfm -
6866 (mpt->m_reply_frame_dma_addr & 0xffffffffu)));
6867 event = ddi_get16(mpt->m_acc_reply_frame_hdl, &eventreply->Event);
6869 if (iocstatus = ddi_get16(mpt->m_acc_reply_frame_hdl,
6872 mptsas_log(mpt, CE_WARN,
6876 ddi_get32(mpt->m_acc_reply_frame_hdl,
6879 mptsas_log(mpt, CE_WARN,
6883 ddi_get32(mpt->m_acc_reply_frame_hdl,
6914 enc_handle = ddi_get16(mpt->m_acc_reply_frame_hdl,
6916 expd_handle = ddi_get16(mpt->m_acc_reply_frame_hdl,
6918 num_entries = ddi_get8(mpt->m_acc_reply_frame_hdl,
6920 start_phy_num = ddi_get8(mpt->m_acc_reply_frame_hdl,
6922 expstatus = ddi_get8(mpt->m_acc_reply_frame_hdl,
6924 physport = ddi_get8(mpt->m_acc_reply_frame_hdl,
6936 mpt->m_port_chng = 1;
6940 topo_node->mpt = mpt;
6956 psmp = refhash_linear_search(mpt->m_smp_targets,
6964 topo_node->mpt = mpt;
6995 phystatus = ddi_get8(mpt->m_acc_reply_frame_hdl,
6997 dev_handle = ddi_get16(mpt->m_acc_reply_frame_hdl,
7018 "dev_handle %d added", mpt->m_instance, phy,
7020 link_rate = ddi_get8(mpt->m_acc_reply_frame_hdl,
7076 topo_node->mpt = mpt;
7087 mpt->m_port_chng = 1;
7104 "dev_handle %d removed", mpt->m_instance,
7121 ptgt = refhash_linear_search(mpt->m_targets,
7140 topo_node->mpt = mpt;
7166 mutex_enter(&mpt->m_tx_waitq_mutex);
7168 mutex_exit(&mpt->m_tx_waitq_mutex);
7173 topo_node->mpt = mpt;
7190 link_rate = ddi_get8(mpt->m_acc_reply_frame_hdl,
7195 pSmhba = &mpt->m_phy_info[i].smhba_info;
7200 mptsas_smhba_log_sysevent(mpt,
7203 &mpt->m_phy_info[i].smhba_info);
7204 mpt->m_phy_info[i].smhba_info.
7211 mptsas_smhba_log_sysevent(mpt,
7214 &mpt->m_phy_info[i].smhba_info);
7229 mpt->m_port_chng = 1;
7231 mptsas_smhba_log_sysevent(mpt,
7234 &mpt->m_phy_info[i].smhba_info);
7241 mpt->m_port_chng = 1;
7243 mptsas_smhba_log_sysevent(mpt,
7246 &mpt->m_phy_info[i].smhba_info);
7253 mpt->m_port_chng = 1;
7255 mptsas_smhba_log_sysevent(mpt,
7258 &mpt->m_phy_info[i].smhba_info);
7265 mpt->m_port_chng = 1;
7267 mptsas_smhba_log_sysevent(mpt,
7270 &mpt->m_phy_info[i].smhba_info);
7328 mpt->m_instance, phy, dev_handle, string, curr,
7335 if ((ddi_taskq_dispatch(mpt->m_dr_taskq,
7344 mptsas_log(mpt, CE_NOTE, "mptsas start taskq "
7362 num_entries = ddi_get8(mpt->m_acc_reply_frame_hdl,
7366 mpt->m_instance));
7369 reason = ddi_get8(mpt->m_acc_reply_frame_hdl,
7371 volhandle = ddi_get16(mpt->m_acc_reply_frame_hdl,
7373 diskhandle = ddi_get16(mpt->m_acc_reply_frame_hdl,
7381 mpt->m_instance));
7387 topo_node->mpt = mpt;
7407 mpt->m_instance));
7408 ptgt = refhash_linear_search(mpt->m_targets,
7416 (void) mptsas_delete_volume(mpt, volhandle);
7421 mutex_enter(&mpt->m_tx_waitq_mutex);
7423 mutex_exit(&mpt->m_tx_waitq_mutex);
7428 topo_node->mpt = mpt;
7448 ptgt = refhash_linear_search(mpt->m_targets,
7456 mutex_enter(&mpt->m_tx_waitq_mutex);
7458 mutex_exit(&mpt->m_tx_waitq_mutex);
7463 topo_node->mpt = mpt;
7493 topo_node->mpt = mpt;
7501 mpt->m_port_chng = 1;
7519 if ((ddi_taskq_dispatch(mpt->m_dr_taskq,
7528 mptsas_log(mpt, CE_NOTE, "mptsas start taskq "
7552 mptsas_t *mpt;
7557 mpt = replyh_arg->mpt;
7559 mutex_enter(&mpt->m_mutex);
7563 if (mpt->m_in_reset) {
7565 mutex_exit(&mpt->m_mutex);
7570 (mpt->m_reply_frame + (rfm -
7571 (mpt->m_reply_frame_dma_addr & 0xffffffffu)));
7572 event = ddi_get16(mpt->m_acc_reply_frame_hdl, &eventreply->Event);
7574 if (iocstatus = ddi_get16(mpt->m_acc_reply_frame_hdl,
7577 mptsas_log(mpt, CE_WARN,
7580 ddi_get32(mpt->m_acc_reply_frame_hdl,
7583 mptsas_log(mpt, CE_WARN,
7586 ddi_get32(mpt->m_acc_reply_frame_hdl,
7598 iocloginfo = ddi_get32(mpt->m_acc_reply_frame_hdl,
7600 NDBG20(("mptsas %d log info %x received.\n", mpt->m_instance,
7604 NDBG20(("mptsas%d state change.", mpt->m_instance));
7607 NDBG20(("mptsas%d event change.", mpt->m_instance));
7618 rc = ddi_get8(mpt->m_acc_reply_frame_hdl,
7620 port = ddi_get8(mpt->m_acc_reply_frame_hdl,
7622 status = ddi_get32(mpt->m_acc_reply_frame_hdl,
7644 NDBG20(("mptsas%d event change.", mpt->m_instance));
7653 mpt->m_instance, ddi_get16(mpt->m_acc_reply_frame_hdl,
7674 rc = ddi_get8(mpt->m_acc_reply_frame_hdl,
7687 "%x%s\n", mpt->m_instance,
7688 ddi_get16(mpt->m_acc_reply_frame_hdl,
7707 rc = ddi_get8(mpt->m_acc_reply_frame_hdl,
7709 wwn_lo = ddi_get32(mpt->m_acc_reply_frame_hdl,
7711 wwn_hi = ddi_get32(mpt->m_acc_reply_frame_hdl,
7714 devhdl = ddi_get16(mpt->m_acc_reply_frame_hdl,
7723 ddi_get8(mpt->m_acc_reply_frame_hdl,
7725 ddi_get8(mpt->m_acc_reply_frame_hdl,
7790 rc = ddi_get8(mpt->m_acc_reply_frame_hdl,
7792 percent = ddi_get8(mpt->m_acc_reply_frame_hdl,
7794 handle = ddi_get16(mpt->m_acc_reply_frame_hdl,
7815 mpt->m_instance, reason_str, handle, percent));
7827 phy_num = ddi_get8(mpt->m_acc_reply_frame_hdl,
7829 primitive = ddi_get8(mpt->m_acc_reply_frame_hdl,
7834 mptsas_smhba_log_sysevent(mpt,
7837 &mpt->m_phy_info[phy_num].smhba_info);
7840 mptsas_smhba_log_sysevent(mpt,
7843 &mpt->m_phy_info[phy_num].smhba_info);
7846 mptsas_smhba_log_sysevent(mpt,
7849 &mpt->m_phy_info[phy_num].smhba_info);
7852 mptsas_smhba_log_sysevent(mpt,
7855 &mpt->m_phy_info[phy_num].smhba_info);
7858 mptsas_smhba_log_sysevent(mpt,
7861 &mpt->m_phy_info[phy_num].smhba_info);
7864 mptsas_smhba_log_sysevent(mpt,
7867 &mpt->m_phy_info[phy_num].smhba_info);
7870 mptsas_smhba_log_sysevent(mpt,
7873 &mpt->m_phy_info[phy_num].smhba_info);
7876 mptsas_smhba_log_sysevent(mpt,
7879 &mpt->m_phy_info[phy_num].smhba_info);
7884 mpt->m_instance, primitive));
7889 mpt->m_instance, primitive, phy_num));
7901 state = ddi_get32(mpt->m_acc_reply_frame_hdl,
7903 devhandle = ddi_get16(mpt->m_acc_reply_frame_hdl,
7913 (void) mptsas_get_raid_info(mpt);
7914 for (config = 0; (config < mpt->m_num_raid_configs) &&
7917 if (mpt->m_raidconfig[config].m_raidvol[vol].
7932 mpt->m_raidconfig[config].m_raidvol[vol].m_settings =
7936 mptsas_log(mpt, CE_NOTE, " Volume %d settings changed"
7955 mpt->m_raidconfig[config].m_raidvol[vol].m_state =
7958 mptsas_log(mpt, CE_NOTE,
7977 mpt->m_raidconfig[config].m_raidvol[vol].
7980 mptsas_log(mpt, CE_NOTE,
8021 physdisknum = ddi_get8(mpt->m_acc_reply_frame_hdl,
8023 devhandle = ddi_get16(mpt->m_acc_reply_frame_hdl,
8025 enchandle = ddi_get16(mpt->m_acc_reply_frame_hdl,
8027 slot = ddi_get16(mpt->m_acc_reply_frame_hdl,
8029 state = ddi_get32(mpt->m_acc_reply_frame_hdl,
8031 reason = ddi_get8(mpt->m_acc_reply_frame_hdl,
8038 mptsas_log(mpt, CE_NOTE,
8048 mptsas_log(mpt, CE_NOTE,
8067 mptsas_log(mpt, CE_NOTE,
8094 mpt->m_instance, event));
8101 ddi_put32(mpt->m_acc_free_queue_hdl,
8102 &((uint32_t *)(void *)mpt->m_free_queue)[mpt->m_free_index], rfm);
8103 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
8105 if (++mpt->m_free_index == mpt->m_free_queue_depth) {
8106 mpt->m_free_index = 0;
8108 ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyFreeHostIndex,
8109 mpt->m_free_index);
8110 mutex_exit(&mpt->m_mutex);
8119 mptsas_t *mpt = arg;
8122 mutex_enter(&mpt->m_mutex);
8124 mpt->m_restart_cmd_timeid = 0;
8126 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
8127 ptgt = refhash_next(mpt->m_targets, ptgt)) {
8130 mptsas_set_throttle(mpt, ptgt,
8135 mptsas_restart_hba(mpt);
8136 mutex_exit(&mpt->m_mutex);
8140 mptsas_remove_cmd(mptsas_t *mpt, mptsas_cmd_t *cmd)
8143 mptsas_slots_t *slots = mpt->m_active;
8166 mpt->m_ncmds--;
8180 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
8198 mptsas_return_to_pool(mpt, cmd);
8215 mptsas_restart_hba(mptsas_t *mpt)
8217 ASSERT(mutex_owned(&mpt->m_mutex));
8219 mutex_enter(&mpt->m_tx_waitq_mutex);
8220 if (mpt->m_tx_waitq) {
8221 mptsas_accept_tx_waitq(mpt);
8223 mutex_exit(&mpt->m_tx_waitq_mutex);
8224 mptsas_restart_waitq(mpt);
8231 mptsas_restart_waitq(mptsas_t *mpt)
8236 NDBG1(("mptsas_restart_waitq: mpt=0x%p", (void *)mpt));
8238 ASSERT(mutex_owned(&mpt->m_mutex));
8246 cmd = mpt->m_waitq;
8251 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
8257 mptsas_waitq_delete(mpt, cmd);
8258 mptsas_start_passthru(mpt, cmd);
8264 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
8270 mptsas_waitq_delete(mpt, cmd);
8271 mptsas_start_config_page_access(mpt, cmd);
8277 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
8283 mptsas_waitq_delete(mpt, cmd);
8284 mptsas_start_diag(mpt, cmd);
8293 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
8295 if ((mpt->m_ncmds <= (mpt->m_max_requests - 2)) &&
8299 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
8300 mptsas_waitq_delete(mpt, cmd);
8301 (void) mptsas_start_cmd(mpt, cmd);
8313 mptsas_accept_tx_waitq(mptsas_t *mpt)
8317 ASSERT(mutex_owned(&mpt->m_mutex));
8318 ASSERT(mutex_owned(&mpt->m_tx_waitq_mutex));
8326 cmd = mpt->m_tx_waitq;
8328 if ((cmd = mpt->m_tx_waitq) == NULL) {
8329 mpt->m_tx_draining = 0;
8332 if ((mpt->m_tx_waitq = cmd->cmd_linkp) == NULL) {
8333 mpt->m_tx_waitqtail = &mpt->m_tx_waitq;
8336 mutex_exit(&mpt->m_tx_waitq_mutex);
8337 if (mptsas_accept_pkt(mpt, cmd) != TRAN_ACCEPT)
8338 cmn_err(CE_WARN, "mpt: mptsas_accept_tx_waitq: failed "
8340 mutex_enter(&mpt->m_tx_waitq_mutex);
8346 * mpt tag type lookup
8352 mptsas_start_cmd(mptsas_t *mpt, mptsas_cmd_t *cmd)
8358 ddi_dma_handle_t dma_hdl = mpt->m_dma_req_frame_hdl;
8359 ddi_acc_handle_t acc_hdl = mpt->m_acc_req_frame_hdl;
8399 mptsas_set_throttle(mpt, ptgt, DRAIN_THROTTLE);
8402 mptsas_remove_cmd(mpt, cmd);
8404 mptsas_waitq_add(mpt, cmd);
8425 mptsas_log(mpt, CE_WARN, "mpt: Invalid tag type\n");
8439 mem = mpt->m_req_frame + (mpt->m_req_frame_size * SMID);
8448 ars_dmaaddrlow = (mpt->m_req_sense_dma_addr +
8449 ((uintptr_t)arsbuf - (uintptr_t)mpt->m_req_sense)) &
8452 arsbuf = mpt->m_req_sense + (mpt->m_req_sense_size * (SMID-1));
8454 ars_size = mpt->m_req_sense_size;
8455 ars_dmaaddrlow = (mpt->m_req_sense_dma_addr +
8456 (mpt->m_req_sense_size * (SMID-1))) &
8483 mptsas_sge_setup(mpt, cmd, &control, io_request, acc_hdl);
8504 (void) ddi_dma_sync(mpt->m_dma_req_sense_hdl, 0, 0,
8512 MPTSAS_START_CMD(mpt, request_desc);
8558 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
8568 mptsas_deliver_doneq_thread(mptsas_t *mpt)
8574 for (i = 0; i < mpt->m_doneq_thread_n; i++) {
8575 item = &mpt->m_doneq_thread_id[i];
8583 if (item->len < mpt->m_doneq_thread_threshold) {
8594 mutex_enter(&mpt->m_doneq_thread_id[t].mutex);
8595 mptsas_doneq_mv(mpt, t);
8596 cv_signal(&mpt->m_doneq_thread_id[t].cv);
8597 mutex_exit(&mpt->m_doneq_thread_id[t].mutex);
8604 mptsas_doneq_mv(mptsas_t *mpt, uint64_t t)
8607 mptsas_doneq_thread_list_t *item = &mpt->m_doneq_thread_id[t];
8610 while ((cmd = mpt->m_doneq) != NULL) {
8611 if ((mpt->m_doneq = cmd->cmd_linkp) == NULL) {
8612 mpt->m_donetail = &mpt->m_doneq;
8617 mpt->m_doneq_len--;
8623 mptsas_fma_check(mptsas_t *mpt, mptsas_cmd_t *cmd)
8628 if ((mptsas_check_acc_handle(mpt->m_datap) !=
8630 (mptsas_check_acc_handle(mpt->m_acc_req_frame_hdl) !=
8632 (mptsas_check_acc_handle(mpt->m_acc_req_sense_hdl) !=
8634 (mptsas_check_acc_handle(mpt->m_acc_reply_frame_hdl) !=
8636 (mptsas_check_acc_handle(mpt->m_acc_free_queue_hdl) !=
8638 (mptsas_check_acc_handle(mpt->m_acc_post_queue_hdl) !=
8640 (mptsas_check_acc_handle(mpt->m_hshk_acc_hdl) !=
8642 (mptsas_check_acc_handle(mpt->m_config_handle) !=
8644 ddi_fm_service_impact(mpt->m_dip,
8646 ddi_fm_acc_err_clear(mpt->m_config_handle,
8651 if ((mptsas_check_dma_handle(mpt->m_dma_req_frame_hdl) !=
8653 (mptsas_check_dma_handle(mpt->m_dma_req_sense_hdl) !=
8655 (mptsas_check_dma_handle(mpt->m_dma_reply_frame_hdl) !=
8657 (mptsas_check_dma_handle(mpt->m_dma_free_queue_hdl) !=
8659 (mptsas_check_dma_handle(mpt->m_dma_post_queue_hdl) !=
8661 (mptsas_check_dma_handle(mpt->m_hshk_dma_hdl) !=
8663 ddi_fm_service_impact(mpt->m_dip,
8670 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
8679 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
8695 mptsas_doneq_add(mptsas_t *mpt, mptsas_cmd_t *cmd)
8706 mptsas_fma_check(mpt, cmd);
8713 *mpt->m_donetail = cmd;
8714 mpt->m_donetail = &cmd->cmd_linkp;
8715 mpt->m_doneq_len++;
8720 mptsas_doneq_thread_rm(mptsas_t *mpt, uint64_t t)
8723 mptsas_doneq_thread_list_t *item = &mpt->m_doneq_thread_id[t];
8739 mptsas_doneq_empty(mptsas_t *mpt)
8741 if (mpt->m_doneq && !mpt->m_in_callback) {
8745 mpt->m_in_callback = 1;
8746 cmd = mpt->m_doneq;
8747 mpt->m_doneq = NULL;
8748 mpt->m_donetail = &mpt->m_doneq;
8749 mpt->m_doneq_len = 0;
8751 mutex_exit(&mpt->m_mutex);
8765 mutex_enter(&mpt->m_mutex);
8766 mpt->m_in_callback = 0;
8774 mptsas_waitq_add(mptsas_t *mpt, mptsas_cmd_t *cmd)
8782 if ((cmd->cmd_linkp = mpt->m_waitq) == NULL) {
8783 mpt->m_waitqtail = &cmd->cmd_linkp;
8785 mpt->m_waitq = cmd;
8788 *(mpt->m_waitqtail) = cmd;
8789 mpt->m_waitqtail = &cmd->cmd_linkp;
8794 mptsas_waitq_rm(mptsas_t *mpt)
8800 MPTSAS_WAITQ_RM(mpt, cmd);
8817 mptsas_waitq_delete(mptsas_t *mpt, mptsas_cmd_t *cmd)
8819 mptsas_cmd_t *prevp = mpt->m_waitq;
8822 NDBG7(("mptsas_waitq_delete: mpt=0x%p cmd=0x%p",
8823 (void *)mpt, (void *)cmd));
8830 if ((mpt->m_waitq = cmd->cmd_linkp) == NULL)
8831 mpt->m_waitqtail = &mpt->m_waitq;
8835 NDBG7(("mptsas_waitq_delete: mpt=0x%p cmd=0x%p",
8836 (void *)mpt, (void *)cmd));
8843 mpt->m_waitqtail = &prevp->cmd_linkp;
8847 NDBG7(("mptsas_waitq_delete: mpt=0x%p cmd=0x%p",
8848 (void *)mpt, (void *)cmd));
8853 cmn_err(CE_PANIC, "mpt: mptsas_waitq_delete: queue botch");
8857 mptsas_tx_waitq_rm(mptsas_t *mpt)
8862 MPTSAS_TX_WAITQ_RM(mpt, cmd);
8873 mptsas_tx_waitq_delete(mptsas_t *mpt, mptsas_cmd_t *cmd)
8875 mptsas_cmd_t *prevp = mpt->m_tx_waitq;
8877 NDBG7(("mptsas_tx_waitq_delete: mpt=0x%p cmd=0x%p",
8878 (void *)mpt, (void *)cmd));
8881 if ((mpt->m_tx_waitq = cmd->cmd_linkp) == NULL)
8882 mpt->m_tx_waitqtail = &mpt->m_tx_waitq;
8886 NDBG7(("mptsas_tx_waitq_delete: mpt=0x%p cmd=0x%p",
8887 (void *)mpt, (void *)cmd));
8894 mpt->m_tx_waitqtail = &prevp->cmd_linkp;
8898 NDBG7(("mptsas_tx_waitq_delete: mpt=0x%p cmd=0x%p",
8899 (void *)mpt, (void *)cmd));
8904 cmn_err(CE_PANIC, "mpt: mptsas_tx_waitq_delete: queue botch");
8917 mptsas_t *mpt = ADDR2MPT(ap);
8930 mutex_enter(&mpt->m_mutex);
8935 mptsas_setup_bus_reset_delay(mpt);
8937 drv_usecwait(mpt->m_scsi_reset_delay * 1000);
8939 rval = mptsas_do_scsi_reset(mpt, ptgt->m_devhdl);
8940 mutex_exit(&mpt->m_mutex);
8953 mptsas_do_scsi_reset(mptsas_t *mpt, uint16_t devhdl)
8958 ASSERT(mutex_owned(&mpt->m_mutex));
8961 mptsas_log(mpt, CE_WARN, "mptsas_do_scsi_reset: target=%d",
8971 for (config = 0; config < mpt->m_num_raid_configs; config++) {
8973 if (devhdl == mpt->m_raidconfig[config].
8980 rval = mptsas_ioc_task_management(mpt,
8983 mptsas_doneq_empty(mpt);
8991 mptsas_t *mpt = ADDR2MPT(ap);
8996 &mpt->m_mutex, &mpt->m_reset_notify_listf));
9023 mptsas_set_throttle(mptsas_t *mpt, mptsas_target_t *ptgt, int what)
9035 if (mpt->m_softstate & (MPTSAS_SS_QUIESCED | MPTSAS_SS_DRAINING)) {
9053 mptsas_flush_target(mptsas_t *mpt, ushort_t target, int lun, uint8_t tasktype)
9055 mptsas_slots_t *slots = mpt->m_active;
9072 for (slot = 0; slot <= mpt->m_active->m_n_normal; slot++) {
9092 mptsas_dump_cmd(mpt, cmd);
9093 mptsas_remove_cmd(mpt, cmd);
9094 mptsas_set_pkt_reason(mpt, cmd, reason, stat);
9095 mptsas_doneq_add(mpt, cmd);
9108 mptsas_dump_cmd(mpt, cmd);
9109 mptsas_remove_cmd(mpt, cmd);
9110 mptsas_set_pkt_reason(mpt, cmd, reason,
9112 mptsas_doneq_add(mpt, cmd);
9123 cmd = mpt->m_waitq;
9133 mptsas_waitq_delete(mpt, cmd);
9134 mptsas_set_pkt_reason(mpt, cmd,
9136 mptsas_doneq_add(mpt, cmd);
9140 mutex_enter(&mpt->m_tx_waitq_mutex);
9141 cmd = mpt->m_tx_waitq;
9145 mptsas_tx_waitq_delete(mpt, cmd);
9146 mutex_exit(&mpt->m_tx_waitq_mutex);
9147 mptsas_set_pkt_reason(mpt, cmd,
9149 mptsas_doneq_add(mpt, cmd);
9150 mutex_enter(&mpt->m_tx_waitq_mutex);
9154 mutex_exit(&mpt->m_tx_waitq_mutex);
9164 mptsas_waitq_delete(mpt, cmd);
9165 mptsas_set_pkt_reason(mpt, cmd,
9167 mptsas_doneq_add(mpt, cmd);
9171 mutex_enter(&mpt->m_tx_waitq_mutex);
9172 cmd = mpt->m_tx_waitq;
9176 mptsas_tx_waitq_delete(mpt, cmd);
9177 mutex_exit(&mpt->m_tx_waitq_mutex);
9178 mptsas_set_pkt_reason(mpt, cmd,
9180 mptsas_doneq_add(mpt, cmd);
9181 mutex_enter(&mpt->m_tx_waitq_mutex);
9185 mutex_exit(&mpt->m_tx_waitq_mutex);
9188 mptsas_log(mpt, CE_WARN, "Unknown task management type %d.",
9199 mptsas_flush_hba(mptsas_t *mpt)
9201 mptsas_slots_t *slots = mpt->m_active;
9213 for (slot = 0; slot <= mpt->m_active->m_n_normal; slot++) {
9226 mptsas_set_pkt_reason(mpt, cmd, CMD_RESET,
9231 cv_broadcast(&mpt->m_passthru_cv);
9232 cv_broadcast(&mpt->m_config_cv);
9233 cv_broadcast(&mpt->m_fw_diag_cv);
9240 mptsas_dump_cmd(mpt, cmd);
9242 mptsas_remove_cmd(mpt, cmd);
9243 mptsas_set_pkt_reason(mpt, cmd, CMD_RESET, STAT_BUS_RESET);
9244 mptsas_doneq_add(mpt, cmd);
9250 while ((cmd = mptsas_waitq_rm(mpt)) != NULL) {
9251 mptsas_set_pkt_reason(mpt, cmd, CMD_RESET, STAT_BUS_RESET);
9256 cv_broadcast(&mpt->m_passthru_cv);
9257 cv_broadcast(&mpt->m_config_cv);
9258 cv_broadcast(&mpt->m_fw_diag_cv);
9260 mptsas_doneq_add(mpt, cmd);
9267 mutex_enter(&mpt->m_tx_waitq_mutex);
9268 while ((cmd = mptsas_tx_waitq_rm(mpt)) != NULL) {
9269 mutex_exit(&mpt->m_tx_waitq_mutex);
9270 mptsas_set_pkt_reason(mpt, cmd, CMD_RESET, STAT_BUS_RESET);
9271 mptsas_doneq_add(mpt, cmd);
9272 mutex_enter(&mpt->m_tx_waitq_mutex);
9274 mutex_exit(&mpt->m_tx_waitq_mutex);
9282 mutex_exit(&mpt->m_mutex);
9283 if (!taskq_member((taskq_t *)mpt->m_event_taskq, curthread))
9284 ddi_taskq_wait(mpt->m_event_taskq);
9285 if (!taskq_member((taskq_t *)mpt->m_dr_taskq, curthread))
9286 ddi_taskq_wait(mpt->m_dr_taskq);
9288 mutex_enter(&mpt->m_mutex);
9295 mptsas_set_pkt_reason(mptsas_t *mpt, mptsas_cmd_t *cmd, uchar_t reason,
9299 _NOTE(ARGUNUSED(mpt))
9329 mptsas_setup_bus_reset_delay(mptsas_t *mpt)
9333 ASSERT(MUTEX_HELD(&mpt->m_mutex));
9336 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
9337 ptgt = refhash_next(mpt->m_targets, ptgt)) {
9338 mptsas_set_throttle(mpt, ptgt, HOLD_THROTTLE);
9339 ptgt->m_reset_delay = mpt->m_scsi_reset_delay;
9347 * mpt instance for active reset delays
9356 mptsas_t *mpt;
9365 for (mpt = mptsas_head; mpt != NULL; mpt = mpt->m_next) {
9366 if (mpt->m_tran == 0) {
9369 mutex_enter(&mpt->m_mutex);
9370 not_done += mptsas_watch_reset_delay_subr(mpt);
9371 mutex_exit(&mpt->m_mutex);
9381 mptsas_watch_reset_delay_subr(mptsas_t *mpt)
9387 NDBG22(("mptsas_watch_reset_delay_subr: mpt=0x%p", (void *)mpt));
9389 ASSERT(mutex_owned(&mpt->m_mutex));
9391 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
9392 ptgt = refhash_next(mpt->m_targets, ptgt)) {
9398 mptsas_set_throttle(mpt, ptgt,
9408 mptsas_restart_hba(mpt);
9415 mptsas_test_reset(mptsas_t *mpt, int target)
9420 if (mptsas_do_scsi_reset(mpt, target) == TRUE) {
9440 mptsas_t *mpt = ADDR2MPT(ap);
9453 mutex_enter(&mpt->m_mutex);
9454 rval = mptsas_do_scsi_abort(mpt, target, lun, pkt);
9455 mutex_exit(&mpt->m_mutex);
9460 mptsas_do_scsi_abort(mptsas_t *mpt, int target, int lun, struct scsi_pkt *pkt)
9463 mptsas_slots_t *slots = mpt->m_active;
9466 ASSERT(mutex_owned(&mpt->m_mutex));
9486 mptsas_waitq_delete(mpt, sp);
9487 mptsas_set_pkt_reason(mpt, sp, CMD_ABORTED,
9489 mptsas_doneq_add(mpt, sp);
9495 * Have mpt firmware abort this command
9499 rval = mptsas_ioc_task_management(mpt,
9517 rval = mptsas_ioc_task_management(mpt,
9535 mptsas_doneq_empty(mpt);
9546 mptsas_t *mpt = ADDR2MPT(ap);
9553 mutex_enter(&mpt->m_mutex);
9556 mutex_exit(&mpt->m_mutex);
9562 rval = (int)mpt->m_msg_dma_attr.dma_attr_maxxfer;
9597 if (mpt->m_ioc_capabilities &
9610 mutex_exit(&mpt->m_mutex);
9620 mptsas_t *mpt = ADDR2MPT(ap);
9631 mutex_enter(&mpt->m_mutex);
9634 mutex_exit(&mpt->m_mutex);
9662 mptsas_set_throttle(mpt, ((mptsas_tgt_private_t *)
9682 mutex_exit(&mpt->m_mutex);
9703 mptsas_alloc_active_slots(mptsas_t *mpt, int flag)
9705 mptsas_slots_t *old_active = mpt->m_active;
9713 ASSERT(mpt->m_ncmds == 0);
9715 size = MPTSAS_SLOTS_SIZE(mpt);
9726 new_active->m_n_normal = (mpt->m_max_requests - 2);
9730 mptsas_free_active_slots(mpt);
9731 mpt->m_active = new_active;
9737 mptsas_free_active_slots(mptsas_t *mpt)
9739 mptsas_slots_t *active = mpt->m_active;
9746 mpt->m_active = NULL;
9756 mptsas_log(mptsas_t *mpt, int level, char *fmt, ...)
9761 if (mpt) {
9762 dev = mpt->m_dip;
9841 mptsas_t *mpt;
9847 for (mpt = mptsas_head; mpt != (mptsas_t *)NULL; mpt = mpt->m_next) {
9849 mutex_enter(&mpt->m_mutex);
9852 if (mpt->m_options & MPTSAS_OPT_PM) {
9853 if (mpt->m_power_level == PM_LEVEL_D0) {
9854 (void) pm_busy_component(mpt->m_dip, 0);
9855 mpt->m_busy = 1;
9857 mutex_exit(&mpt->m_mutex);
9865 doorbell = ddi_get32(mpt->m_datap, &mpt->m_reg->Doorbell);
9868 mptsas_log(mpt, CE_WARN, "MPT Firmware Fault, "
9870 mpt->m_softstate &= ~MPTSAS_SS_MSG_UNIT_RESET;
9871 if ((mptsas_restart_ioc(mpt)) == DDI_FAILURE) {
9872 mptsas_log(mpt, CE_WARN, "Reset failed"
9880 mptsas_watchsubr(mpt);
9882 if (mpt->m_options & MPTSAS_OPT_PM) {
9883 mpt->m_busy = 0;
9884 (void) pm_idle_component(mpt->m_dip, 0);
9887 mutex_exit(&mpt->m_mutex);
9898 mptsas_watchsubr_tgt(mptsas_t *mpt, mptsas_target_t *ptgt, hrtime_t timestamp)
9909 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
9910 mptsas_restart_hba(mpt);
9921 mptsas_set_throttle(mpt, ptgt, DRAIN_THROTTLE);
9939 mptsas_log(mpt, CE_NOTE, "Timeout of %d seconds "
9944 mptsas_cmd_timeout(mpt, ptgt);
9948 mptsas_set_throttle(mpt, ptgt, DRAIN_THROTTLE);
9953 mptsas_watchsubr(mptsas_t *mpt)
9960 ASSERT(MUTEX_HELD(&mpt->m_mutex));
9962 NDBG30(("mptsas_watchsubr: mpt=0x%p", (void *)mpt));
9974 for (i = 0; i <= mpt->m_active->m_n_normal; i++) {
9975 if ((cmd = mpt->m_active->m_slot[i]) != NULL) {
9982 mptsas_set_throttle(mpt,
9993 cv_broadcast(&mpt->m_passthru_cv);
9994 cv_broadcast(&mpt->m_config_cv);
9995 cv_broadcast(&mpt->m_fw_diag_cv);
10001 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
10002 ptgt = refhash_next(mpt->m_targets, ptgt)) {
10003 mptsas_watchsubr_tgt(mpt, ptgt, timestamp);
10006 for (ptgt = refhash_first(mpt->m_tmp_targets); ptgt != NULL;
10007 ptgt = refhash_next(mpt->m_tmp_targets, ptgt)) {
10008 mptsas_watchsubr_tgt(mpt, ptgt, timestamp);
10016 mptsas_cmd_timeout(mptsas_t *mpt, mptsas_target_t *ptgt)
10033 mptsas_log(mpt, CE_WARN, "Disconnected command timeout for "
10041 if (mptsas_do_scsi_reset(mpt, devhdl) != TRUE) {
10042 mptsas_log(mpt, CE_WARN, "Target %d reset for command timeout "
10053 mptsas_t *mpt;
10057 if (tran == NULL || (mpt = TRAN2MPT(tran)) == NULL)
10060 return (mptsas_quiesce_bus(mpt));
10066 mptsas_t *mpt;
10070 if (tran == NULL || (mpt = TRAN2MPT(tran)) == NULL)
10073 return (mptsas_unquiesce_bus(mpt));
10077 mptsas_quiesce_bus(mptsas_t *mpt)
10082 mutex_enter(&mpt->m_mutex);
10085 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
10086 ptgt = refhash_next(mpt->m_targets, ptgt)) {
10087 mptsas_set_throttle(mpt, ptgt, HOLD_THROTTLE);
10091 if (mpt->m_ncmds) {
10092 mpt->m_softstate |= MPTSAS_SS_DRAINING;
10093 mpt->m_quiesce_timeid = timeout(mptsas_ncmds_checkdrain,
10094 mpt, (MPTSAS_QUIESCE_TIMEOUT * drv_usectohz(1000000)));
10095 if (cv_wait_sig(&mpt->m_cv, &mpt->m_mutex) == 0) {
10099 mpt->m_softstate &= ~MPTSAS_SS_DRAINING;
10100 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
10101 ptgt = refhash_next(mpt->m_targets, ptgt)) {
10102 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
10104 mptsas_restart_hba(mpt);
10105 if (mpt->m_quiesce_timeid != 0) {
10106 timeout_id_t tid = mpt->m_quiesce_timeid;
10107 mpt->m_quiesce_timeid = 0;
10108 mutex_exit(&mpt->m_mutex);
10112 mutex_exit(&mpt->m_mutex);
10116 ASSERT(mpt->m_quiesce_timeid == 0);
10117 mpt->m_softstate &= ~MPTSAS_SS_DRAINING;
10118 mpt->m_softstate |= MPTSAS_SS_QUIESCED;
10119 mutex_exit(&mpt->m_mutex);
10124 mutex_exit(&mpt->m_mutex);
10130 mptsas_unquiesce_bus(mptsas_t *mpt)
10135 mutex_enter(&mpt->m_mutex);
10136 mpt->m_softstate &= ~MPTSAS_SS_QUIESCED;
10137 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
10138 ptgt = refhash_next(mpt->m_targets, ptgt)) {
10139 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
10141 mptsas_restart_hba(mpt);
10142 mutex_exit(&mpt->m_mutex);
10149 mptsas_t *mpt = arg;
10152 mutex_enter(&mpt->m_mutex);
10153 if (mpt->m_softstate & MPTSAS_SS_DRAINING) {
10154 mpt->m_quiesce_timeid = 0;
10155 if (mpt->m_ncmds == 0) {
10157 cv_signal(&mpt->m_cv);
10163 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
10164 ptgt = refhash_next(mpt->m_targets, ptgt)) {
10165 mptsas_set_throttle(mpt, ptgt, HOLD_THROTTLE);
10168 mpt->m_quiesce_timeid = timeout(mptsas_ncmds_checkdrain,
10169 mpt, (MPTSAS_QUIESCE_TIMEOUT *
10173 mutex_exit(&mpt->m_mutex);
10178 mptsas_dump_cmd(mptsas_t *mpt, mptsas_cmd_t *cmd)
10289 mptsas_start_passthru(mptsas_t *mpt, mptsas_cmd_t *cmd)
10301 ddi_dma_handle_t dma_hdl = mpt->m_dma_req_frame_hdl;
10302 ddi_acc_handle_t acc_hdl = mpt->m_acc_req_frame_hdl;
10315 memp = mpt->m_req_frame + (mpt->m_req_frame_size * SMID);
10317 bzero(memp, mpt->m_req_frame_size);
10331 if (mpt->m_MPI25 && pt->simple == 0) {
10360 ars_dmaaddrlow = (mpt->m_req_sense_dma_addr +
10361 ((uintptr_t)arsbuf - (uintptr_t)mpt->m_req_sense)) &
10364 arsbuf = mpt->m_req_sense +
10365 (mpt->m_req_sense_size * (SMID-1));
10367 ars_size = mpt->m_req_sense_size;
10368 ars_dmaaddrlow = (mpt->m_req_sense_dma_addr +
10369 (mpt->m_req_sense_size * (SMID-1))) &
10396 (void) ddi_dma_sync(mpt->m_dma_req_sense_hdl, 0, 0,
10408 MPTSAS_START_CMD(mpt, request_desc);
10411 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
10432 mpi_pre_fw_download(mptsas_t *mpt, mptsas_pt_request_t *pt)
10440 if (mpt->m_MPI25) {
10441 mpi_pre_fw_25_download(mpt, pt);
10456 mptsas_log(mpt, CE_WARN, "FW Download tce invalid!");
10476 mpi_pre_fw_25_download(mptsas_t *mpt, mptsas_pt_request_t *pt)
10493 mptsas_log(mpt, CE_WARN, "FW Download tce invalid!");
10514 mpi_pre_fw_upload(mptsas_t *mpt, mptsas_pt_request_t *pt)
10522 if (mpt->m_MPI25) {
10523 mpi_pre_fw_25_upload(mpt, pt);
10538 mptsas_log(mpt, CE_WARN, "FW Upload tce invalid!");
10558 mpi_pre_fw_25_upload(mptsas_t *mpt, mptsas_pt_request_t *pt)
10575 mptsas_log(mpt, CE_WARN, "FW Upload tce invalid!");
10596 mpi_pre_ioc_facts(mptsas_t *mpt, mptsas_pt_request_t *pt)
10599 _NOTE(ARGUNUSED(mpt))
10618 mpi_pre_port_facts(mptsas_t *mpt, mptsas_pt_request_t *pt)
10621 _NOTE(ARGUNUSED(mpt))
10640 mpi_pre_sata_passthrough(mptsas_t *mpt, mptsas_pt_request_t *pt)
10643 _NOTE(ARGUNUSED(mpt))
10658 mpi_pre_smp_passthrough(mptsas_t *mpt, mptsas_pt_request_t *pt)
10661 _NOTE(ARGUNUSED(mpt))
10679 mpi_pre_config(mptsas_t *mpt, mptsas_pt_request_t *pt)
10682 _NOTE(ARGUNUSED(mpt))
10700 mpi_pre_scsi_io_req(mptsas_t *mpt, mptsas_pt_request_t *pt)
10703 _NOTE(ARGUNUSED(mpt))
10721 mpi_pre_sas_io_unit_control(mptsas_t *mpt, mptsas_pt_request_t *pt)
10724 _NOTE(ARGUNUSED(mpt))
10755 mptsas_prep_sgl_offset(mptsas_t *mpt, mptsas_pt_request_t *pt)
10764 f->f_pre(mpt, pt);
10779 mptsas_do_passthru(mptsas_t *mpt, uint8_t *request, uint8_t *reply,
10799 ASSERT(mutex_owned(&mpt->m_mutex));
10805 mutex_exit(&mpt->m_mutex);
10811 mutex_enter(&mpt->m_mutex);
10813 mptsas_log(mpt, CE_WARN, "failed to copy request data");
10818 mutex_enter(&mpt->m_mutex);
10824 mptsas_setup_bus_reset_delay(mpt);
10825 rv = mptsas_ioc_task_management(mpt, task->TaskType,
10831 mptsas_log(mpt, CE_WARN, "task management failed");
10838 if (mptsas_dma_alloc(mpt, &data_dma_state) != DDI_SUCCESS) {
10840 mptsas_log(mpt, CE_WARN, "failed to alloc DMA "
10846 mutex_exit(&mpt->m_mutex);
10850 mutex_enter(&mpt->m_mutex);
10852 mptsas_log(mpt, CE_WARN, "failed to "
10857 mutex_enter(&mpt->m_mutex);
10865 if (mptsas_dma_alloc(mpt, &dataout_dma_state) != DDI_SUCCESS) {
10867 mptsas_log(mpt, CE_WARN, "failed to alloc DMA "
10872 mutex_exit(&mpt->m_mutex);
10876 mutex_enter(&mpt->m_mutex);
10877 mptsas_log(mpt, CE_WARN, "failed to copy out"
10883 mutex_enter(&mpt->m_mutex);
10888 if ((rvalue = (mptsas_request_from_pool(mpt, &cmd, &pkt))) == -1) {
10890 mptsas_log(mpt, CE_NOTE, "event ack command pool is full");
10909 mptsas_prep_sgl_offset(mpt, &pt);
10944 ret = mptsas_cmdarqsize(mpt, cmd, sense_len, KM_SLEEP);
10959 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
10965 mptsas_start_passthru(mpt, cmd);
10967 mptsas_waitq_add(mpt, cmd);
10971 cv_wait(&mpt->m_passthru_cv, &mpt->m_mutex);
10979 memp = mpt->m_req_frame + (mpt->m_req_frame_size *
10986 mptsas_log(mpt, CE_WARN, "passthrough command timeout");
11000 (void) ddi_dma_sync(mpt->m_dma_reply_frame_hdl, 0, 0,
11003 (mpt->m_reply_frame + (cmd->cmd_rfm -
11004 (mpt->m_reply_frame_dma_addr & 0xffffffffu)));
11007 mptsas_fma_check(mpt, cmd);
11010 mptsas_log(mpt, CE_WARN, "passthru fma error");
11015 mptsas_log(mpt, CE_WARN, "ioc reset abort passthru");
11021 mptsas_log(mpt, CE_WARN, "passthrough command incomplete");
11025 mutex_exit(&mpt->m_mutex);
11042 mutex_enter(&mpt->m_mutex);
11044 mptsas_log(mpt, CE_WARN, "failed to copy out "
11052 mutex_enter(&mpt->m_mutex);
11054 mptsas_log(mpt, CE_WARN, "failed to copy out "
11069 mutex_enter(&mpt->m_mutex);
11071 mptsas_log(mpt, CE_WARN, "failed to "
11078 mutex_enter(&mpt->m_mutex);
11086 ddi_put32(mpt->m_acc_free_queue_hdl,
11087 &((uint32_t *)(void *)mpt->m_free_queue)[mpt->m_free_index],
11089 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
11091 if (++mpt->m_free_index == mpt->m_free_queue_depth) {
11092 mpt->m_free_index = 0;
11094 ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyFreeHostIndex,
11095 mpt->m_free_index);
11099 rmfree(mpt->m_erqsense_map, cmd->cmd_extrqschunks,
11103 mptsas_remove_cmd(mpt, cmd);
11108 mptsas_return_to_pool(mpt, cmd);
11112 ddi_fm_service_impact(mpt->m_dip,
11121 ddi_fm_service_impact(mpt->m_dip,
11128 if ((mptsas_restart_ioc(mpt)) == DDI_FAILURE) {
11129 mptsas_log(mpt, CE_WARN, "mptsas_restart_ioc failed");
11140 mptsas_pass_thru(mptsas_t *mpt, mptsas_pass_thru_t *data, int mode)
11164 return (mptsas_do_passthru(mpt,
11178 mptsas_get_fw_diag_buffer_number(mptsas_t *mpt, uint32_t unique_id)
11183 if (mpt->m_fw_diag_buffer_list[index].unique_id == unique_id) {
11192 mptsas_start_diag(mptsas_t *mpt, mptsas_cmd_t *cmd)
11201 ASSERT(mutex_owned(&mpt->m_mutex));
11208 (mpt->m_req_frame + (mpt->m_req_frame_size *
11210 bzero(pDiag_post_msg, mpt->m_req_frame_size);
11211 ddi_put8(mpt->m_acc_req_frame_hdl, &pDiag_post_msg->Function,
11213 ddi_put8(mpt->m_acc_req_frame_hdl, &pDiag_post_msg->BufferType,
11215 ddi_put8(mpt->m_acc_req_frame_hdl,
11218 ddi_put32(mpt->m_acc_req_frame_hdl,
11223 ddi_put32(mpt->m_acc_req_frame_hdl,
11227 ddi_put32(mpt->m_acc_req_frame_hdl,
11231 ddi_put32(mpt->m_acc_req_frame_hdl,
11237 (mpt->m_req_frame + (mpt->m_req_frame_size *
11239 bzero(pDiag_release_msg, mpt->m_req_frame_size);
11240 ddi_put8(mpt->m_acc_req_frame_hdl,
11242 ddi_put8(mpt->m_acc_req_frame_hdl,
11250 (void) ddi_dma_sync(mpt->m_dma_req_frame_hdl, 0, 0,
11255 MPTSAS_START_CMD(mpt, request_desc);
11256 if ((mptsas_check_dma_handle(mpt->m_dma_req_frame_hdl) !=
11258 (mptsas_check_acc_handle(mpt->m_acc_req_frame_hdl) !=
11260 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
11265 mptsas_post_fw_diag_buffer(mptsas_t *mpt,
11295 if ((slot_num = (mptsas_request_from_pool(mpt, &cmd, &pkt))) == -1) {
11297 mptsas_log(mpt, CE_NOTE, "command pool is full: Post FW Diag");
11322 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
11328 mptsas_start_diag(mpt, cmd);
11330 mptsas_waitq_add(mpt, cmd);
11334 cv_wait(&mpt->m_fw_diag_cv, &mpt->m_mutex);
11339 mptsas_log(mpt, CE_WARN, "Post FW Diag command timeout");
11350 (void) ddi_dma_sync(mpt->m_dma_reply_frame_hdl, 0, 0,
11352 reply = (pMpi2DiagBufferPostReply_t)(mpt->m_reply_frame +
11354 (mpt->m_reply_frame_dma_addr & 0xffffffffu)));
11359 iocstatus = ddi_get16(mpt->m_acc_reply_frame_hdl,
11361 iocloginfo = ddi_get32(mpt->m_acc_reply_frame_hdl,
11363 transfer_length = ddi_get32(mpt->m_acc_reply_frame_hdl,
11393 ddi_put32(mpt->m_acc_free_queue_hdl,
11394 &((uint32_t *)(void *)mpt->m_free_queue)[mpt->m_free_index],
11396 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
11398 if (++mpt->m_free_index == mpt->m_free_queue_depth) {
11399 mpt->m_free_index = 0;
11401 ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyFreeHostIndex,
11402 mpt->m_free_index);
11405 mptsas_remove_cmd(mpt, cmd);
11409 mptsas_return_to_pool(mpt, cmd);
11416 mptsas_release_fw_diag_buffer(mptsas_t *mpt,
11433 mptsas_log(mpt, CE_NOTE, "This buffer type is not supported "
11449 if ((slot_num = (mptsas_request_from_pool(mpt, &cmd, &pkt))) == -1) {
11451 mptsas_log(mpt, CE_NOTE, "command pool is full: Release FW "
11477 if (mptsas_save_cmd(mpt, cmd) == TRUE) {
11483 mptsas_start_diag(mpt, cmd);
11485 mptsas_waitq_add(mpt, cmd);
11489 cv_wait(&mpt->m_fw_diag_cv, &mpt->m_mutex);
11494 mptsas_log(mpt, CE_WARN, "Release FW Diag command timeout");
11505 (void) ddi_dma_sync(mpt->m_dma_reply_frame_hdl, 0, 0,
11507 reply = (pMpi2DiagReleaseReply_t)(mpt->m_reply_frame +
11509 (mpt->m_reply_frame_dma_addr & 0xffffffffu)));
11514 iocstatus = ddi_get16(mpt->m_acc_reply_frame_hdl,
11516 iocloginfo = ddi_get32(mpt->m_acc_reply_frame_hdl,
11553 ddi_put32(mpt->m_acc_free_queue_hdl,
11554 &((uint32_t *)(void *)mpt->m_free_queue)[mpt->m_free_index],
11556 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
11558 if (++mpt->m_free_index == mpt->m_free_queue_depth) {
11559 mpt->m_free_index = 0;
11561 ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyFreeHostIndex,
11562 mpt->m_free_index);
11565 mptsas_remove_cmd(mpt, cmd);
11569 mptsas_return_to_pool(mpt, cmd);
11576 mptsas_diag_register(mptsas_t *mpt, mptsas_fw_diag_register_t *diag_register,
11585 ASSERT(mutex_owned(&mpt->m_mutex));
11604 i = mptsas_get_fw_diag_buffer_number(mpt, unique_id);
11605 pBuffer = &mpt->m_fw_diag_buffer_list[buffer_type];
11641 if (mptsas_dma_alloc(mpt, &pBuffer->buffer_data) != DDI_SUCCESS) {
11642 mptsas_log(mpt, CE_WARN, "failed to alloc DMA resource for "
11662 status = mptsas_post_fw_diag_buffer(mpt, pBuffer, return_code);
11666 mptsas_log(mpt, CE_WARN, "Check of DMA handle failed in "
11668 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
11683 mptsas_diag_unregister(mptsas_t *mpt,
11691 ASSERT(mutex_owned(&mpt->m_mutex));
11699 i = mptsas_get_fw_diag_buffer_number(mpt, unique_id);
11705 pBuffer = &mpt->m_fw_diag_buffer_list[i];
11715 status = mptsas_release_fw_diag_buffer(mpt, pBuffer,
11727 mptsas_log(mpt, CE_WARN, "Check of DMA handle failed "
11729 ddi_fm_service_impact(mpt->m_dip,
11739 mptsas_diag_query(mptsas_t *mpt, mptsas_fw_diag_query_t *diag_query,
11746 ASSERT(mutex_owned(&mpt->m_mutex));
11761 i = mptsas_get_fw_diag_buffer_number(mpt, unique_id);
11771 pBuffer = &mpt->m_fw_diag_buffer_list[i];
11814 mptsas_diag_read_buffer(mptsas_t *mpt,
11823 ASSERT(mutex_owned(&mpt->m_mutex));
11831 i = mptsas_get_fw_diag_buffer_number(mpt, unique_id);
11837 pBuffer = &mpt->m_fw_diag_buffer_list[i];
11880 status = mptsas_post_fw_diag_buffer(mpt, pBuffer,
11889 mptsas_diag_release(mptsas_t *mpt, mptsas_fw_diag_release_t *diag_release,
11897 ASSERT(mutex_owned(&mpt->m_mutex));
11905 i = mptsas_get_fw_diag_buffer_number(mpt, unique_id);
11911 pBuffer = &mpt->m_fw_diag_buffer_list[i];
11924 status = mptsas_release_fw_diag_buffer(mpt, pBuffer, return_code,
11930 mptsas_do_diag_action(mptsas_t *mpt, uint32_t action, uint8_t *diag_action,
11941 ASSERT(mutex_owned(&mpt->m_mutex));
11958 status = mptsas_diag_register(mpt, &diag_register,
11973 status = mptsas_diag_unregister(mpt, &diag_unregister,
11988 status = mptsas_diag_query(mpt, &diag_query,
12012 status = mptsas_diag_read_buffer(mpt,
12036 status = mptsas_diag_release(mpt, &diag_release,
12056 mptsas_diag_action(mptsas_t *mpt, mptsas_diag_action_t *user_data, int mode)
12061 ASSERT(mutex_owned(&mpt->m_mutex));
12076 status = mptsas_do_diag_action(mpt, driver_data.Action,
12106 mptsas_event_query(mptsas_t *mpt, mptsas_event_query_t *data, int mode,
12115 mutex_enter(&mpt->m_mutex);
12117 driverdata.Types[i] = mpt->m_event_mask[i];
12119 mutex_exit(&mpt->m_mutex);
12135 mptsas_event_enable(mptsas_t *mpt, mptsas_event_enable_t *data, int mode,
12143 mutex_enter(&mpt->m_mutex);
12145 mpt->m_event_mask[i] = driverdata.Types[i];
12147 mutex_exit(&mpt->m_mutex);
12161 mptsas_event_report(mptsas_t *mpt, mptsas_event_report_t *data, int mode,
12167 mutex_enter(&mpt->m_mutex);
12171 if (driverdata.Size >= sizeof (mpt->m_events)) {
12172 if (ddi_copyout(mpt->m_events, data->Events,
12173 sizeof (mpt->m_events), mode) != 0) {
12176 if (driverdata.Size > sizeof (mpt->m_events)) {
12178 sizeof (mpt->m_events);
12201 mutex_exit(&mpt->m_mutex);
12206 mptsas_lookup_pci_data(mptsas_t *mpt, mptsas_adapter_data_t *adapter_data)
12214 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, mpt->m_dip,
12246 * Saved in the mpt->m_fwversion
12248 adapter_data->MpiFirmwareVersion = mpt->m_fwversion;
12252 mptsas_read_adapter_data(mptsas_t *mpt, mptsas_adapter_data_t *adapter_data)
12256 mptsas_lookup_pci_data(mpt, adapter_data);
12257 adapter_data->AdapterType = mpt->m_MPI25 ?
12260 adapter_data->PCIDeviceHwId = (uint32_t)mpt->m_devid;
12261 adapter_data->PCIDeviceHwRev = (uint32_t)mpt->m_revid;
12262 adapter_data->SubSystemId = (uint32_t)mpt->m_ssid;
12263 adapter_data->SubsystemVendorId = (uint32_t)mpt->m_svid;
12266 (void) mptsas_get_bios_page3(mpt, &adapter_data->BiosVersion);
12270 mptsas_read_pci_info(mptsas_t *mpt, mptsas_pci_info_t *pci_info)
12278 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, mpt->m_dip,
12310 pci_info->PciHeader[i] = pci_config_get8(mpt->m_config_handle,
12316 mptsas_reg_access(mptsas_t *mpt, mptsas_reg_access_t *data, int mode)
12321 mutex_enter(&mpt->m_mutex);
12329 mptsas_log(mpt, CE_WARN, "IO access is not "
12335 driverdata.RegData = ddi_get32(mpt->m_datap,
12336 (uint32_t *)(void *)mpt->m_reg +
12341 mptsas_log(mpt, CE_WARN, "Register "
12348 ddi_put32(mpt->m_datap,
12349 (uint32_t *)(void *)mpt->m_reg +
12362 mutex_exit(&mpt->m_mutex);
12367 led_control(mptsas_t *mpt, intptr_t data, int mode)
12391 mutex_enter(&mpt->m_mutex);
12392 ptgt = refhash_linear_search(mpt->m_targets,
12396 mutex_exit(&mpt->m_mutex);
12406 ret = mptsas_flush_led_status(mpt, ptgt);
12407 mutex_exit(&mpt->m_mutex);
12413 mutex_exit(&mpt->m_mutex);
12423 get_disk_info(mptsas_t *mpt, intptr_t data, int mode)
12443 mutex_enter(&mpt->m_mutex);
12444 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
12445 ptgt = refhash_next(mpt->m_targets, ptgt)) {
12448 mutex_exit(&mpt->m_mutex);
12470 mutex_enter(&mpt->m_mutex);
12471 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
12472 ptgt = refhash_next(mpt->m_targets, ptgt)) {
12478 refhash_rele(mpt->m_targets, ptgt);
12479 mutex_exit(&mpt->m_mutex);
12483 di[i].Instance = mpt->m_instance;
12489 mutex_exit(&mpt->m_mutex);
12514 mptsas_t *mpt;
12533 mpt = ddi_get_soft_state(mptsas_state, MINOR2INST(getminor(dev)));
12534 if (mpt == NULL) {
12543 mpt = DIP2MPT(dip);
12546 mutex_enter(&mpt->m_mutex);
12547 if (mpt->m_options & MPTSAS_OPT_PM) {
12548 (void) pm_busy_component(mpt->m_dip, 0);
12549 if (mpt->m_power_level != PM_LEVEL_D0) {
12550 mutex_exit(&mpt->m_mutex);
12551 if (pm_raise_power(mpt->m_dip, 0, PM_LEVEL_D0) !=
12553 mptsas_log(mpt, CE_WARN,
12555 "request failed.", mpt->m_instance);
12556 (void) pm_idle_component(mpt->m_dip, 0);
12560 mutex_exit(&mpt->m_mutex);
12563 mutex_exit(&mpt->m_mutex);
12582 ptgt = mptsas_addr_to_ptgt(mpt, addr, phymask);
12589 mutex_enter(&mpt->m_mutex);
12602 (void) mptsas_flush_led_status(mpt, ptgt);
12603 mutex_exit(&mpt->m_mutex);
12610 status = get_disk_info(mpt, data, mode);
12613 status = led_control(mpt, data, mode);
12622 mutex_enter(&mpt->m_mutex);
12623 if (mptsas_update_flash(mpt,
12633 mpt->m_softstate &= ~MPTSAS_SS_MSG_UNIT_RESET;
12634 if (mptsas_restart_ioc(mpt) == DDI_FAILURE) {
12637 mutex_exit(&mpt->m_mutex);
12652 mutex_enter(&mpt->m_passthru_mutex);
12653 mutex_enter(&mpt->m_mutex);
12654 status = mptsas_pass_thru(mpt, &passthru_data, mode);
12655 mutex_exit(&mpt->m_mutex);
12656 mutex_exit(&mpt->m_passthru_mutex);
12675 mutex_enter(&mpt->m_mutex);
12676 mptsas_read_adapter_data(mpt, &adapter_data);
12677 mutex_exit(&mpt->m_mutex);
12695 mutex_enter(&mpt->m_mutex);
12696 mptsas_read_pci_info(mpt, &pci_info);
12697 mutex_exit(&mpt->m_mutex);
12704 mutex_enter(&mpt->m_mutex);
12705 mpt->m_softstate &= ~MPTSAS_SS_MSG_UNIT_RESET;
12706 if ((mptsas_restart_ioc(mpt)) == DDI_FAILURE) {
12707 mptsas_log(mpt, CE_WARN, "reset adapter IOCTL "
12711 mutex_exit(&mpt->m_mutex);
12719 mutex_enter(&mpt->m_mutex);
12720 if (mpt->m_diag_action_in_progress) {
12721 mutex_exit(&mpt->m_mutex);
12724 mpt->m_diag_action_in_progress = 1;
12725 status = mptsas_diag_action(mpt,
12727 mpt->m_diag_action_in_progress = 0;
12728 mutex_exit(&mpt->m_mutex);
12735 status = mptsas_event_query(mpt,
12743 status = mptsas_event_enable(mpt,
12751 status = mptsas_event_report(mpt,
12759 status = mptsas_reg_access(mpt,
12773 mptsas_restart_ioc(mptsas_t *mpt)
12778 ASSERT(mutex_owned(&mpt->m_mutex));
12787 mpt->m_in_reset = TRUE;
12792 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
12793 ptgt = refhash_next(mpt->m_targets, ptgt)) {
12794 mptsas_set_throttle(mpt, ptgt, HOLD_THROTTLE);
12800 MPTSAS_DISABLE_INTR(mpt);
12806 mptsas_flush_hba(mpt);
12811 if (mptsas_init_chip(mpt, FALSE) == DDI_FAILURE) {
12818 MPTSAS_ENABLE_INTR(mpt);
12824 mptsas_update_driver_data(mpt);
12830 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
12831 ptgt = refhash_next(mpt->m_targets, ptgt)) {
12832 mptsas_set_throttle(mpt, ptgt, MAX_THROTTLE);
12835 mptsas_doneq_empty(mpt);
12836 mptsas_restart_hba(mpt);
12839 mptsas_fm_ereport(mpt, DDI_FM_DEVICE_NO_RESPONSE);
12840 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_LOST);
12846 mpt->m_in_reset = FALSE;
12852 mptsas_init_chip(mptsas_t *mpt, int first_time)
12861 if (ddi_get32(mpt->m_datap, &mpt->m_reg->HostDiagnostic) &
12863 mptsas_log(mpt, CE_WARN, "mptsas bad flash signature!");
12870 rval = mptsas_ioc_reset(mpt, first_time);
12872 mptsas_log(mpt, CE_WARN, "hard reset failed!");
12882 if (mptsas_config_space_init(mpt) == FALSE) {
12883 mptsas_log(mpt, CE_WARN, "mptsas_config_space_init "
12893 if (mptsas_ioc_get_facts(mpt) == DDI_FAILURE) {
12894 mptsas_log(mpt, CE_WARN, "mptsas_ioc_get_facts failed");
12898 if (mptsas_alloc_active_slots(mpt, KM_SLEEP)) {
12905 if (mptsas_alloc_request_frames(mpt) == DDI_FAILURE) {
12906 mptsas_log(mpt, CE_WARN, "mptsas_alloc_request_frames failed");
12909 if (mptsas_alloc_sense_bufs(mpt) == DDI_FAILURE) {
12910 mptsas_log(mpt, CE_WARN, "mptsas_alloc_sense_bufs failed");
12913 if (mptsas_alloc_free_queue(mpt) == DDI_FAILURE) {
12914 mptsas_log(mpt, CE_WARN, "mptsas_alloc_free_queue failed!");
12917 if (mptsas_alloc_post_queue(mpt) == DDI_FAILURE) {
12918 mptsas_log(mpt, CE_WARN, "mptsas_alloc_post_queue failed!");
12921 if (mptsas_alloc_reply_frames(mpt) == DDI_FAILURE) {
12922 mptsas_log(mpt, CE_WARN, "mptsas_alloc_reply_frames failed!");
12930 if (mptsas_ioc_init(mpt) == DDI_FAILURE) {
12931 mptsas_log(mpt, CE_WARN, "mptsas_ioc_init failed");
12935 mptsas_alloc_reply_args(mpt);
12941 mpt->m_post_index = 0;
12947 cookie.dmac_address = mpt->m_reply_frame_dma_addr & 0xffffffffu;
12948 for (i = 0; i < mpt->m_max_replies; i++) {
12949 ddi_put32(mpt->m_acc_free_queue_hdl,
12950 &((uint32_t *)(void *)mpt->m_free_queue)[i],
12952 cookie.dmac_address += mpt->m_reply_frame_size;
12954 (void) ddi_dma_sync(mpt->m_dma_free_queue_hdl, 0, 0,
12961 mpt->m_free_index = i;
12962 ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyFreeHostIndex, i);
12967 for (i = 0; i < mpt->m_post_queue_depth; i++) {
12968 ddi_put64(mpt->m_acc_post_queue_hdl,
12969 &((uint64_t *)(void *)mpt->m_post_queue)[i],
12972 (void) ddi_dma_sync(mpt->m_dma_post_queue_hdl, 0, 0,
12978 if (mptsas_ioc_enable_port(mpt) == DDI_FAILURE) {
12979 mptsas_log(mpt, CE_WARN, "mptsas_ioc_enable_port failed");
12986 if (mptsas_ioc_enable_event_notification(mpt)) {
12987 mptsas_log(mpt, CE_WARN,
12997 if ((mptsas_check_dma_handle(mpt->m_dma_req_frame_hdl) !=
12999 (mptsas_check_dma_handle(mpt->m_dma_req_sense_hdl) !=
13001 (mptsas_check_dma_handle(mpt->m_dma_reply_frame_hdl) !=
13003 (mptsas_check_dma_handle(mpt->m_dma_free_queue_hdl) !=
13005 (mptsas_check_dma_handle(mpt->m_dma_post_queue_hdl) !=
13007 (mptsas_check_dma_handle(mpt->m_hshk_dma_hdl) !=
13009 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
13014 if ((mptsas_check_acc_handle(mpt->m_datap) != DDI_SUCCESS) ||
13015 (mptsas_check_acc_handle(mpt->m_acc_req_frame_hdl) !=
13017 (mptsas_check_acc_handle(mpt->m_acc_req_sense_hdl) !=
13019 (mptsas_check_acc_handle(mpt->m_acc_reply_frame_hdl) !=
13021 (mptsas_check_acc_handle(mpt->m_acc_free_queue_hdl) !=
13023 (mptsas_check_acc_handle(mpt->m_acc_post_queue_hdl) !=
13025 (mptsas_check_acc_handle(mpt->m_hshk_acc_hdl) !=
13027 (mptsas_check_acc_handle(mpt->m_config_handle) !=
13029 ddi_fm_service_impact(mpt->m_dip, DDI_SERVICE_UNAFFECTED);
13040 mptsas_get_pci_cap(mptsas_t *mpt)
13044 if (mpt->m_config_handle == NULL)
13050 if (pci_config_get16(mpt->m_config_handle, PCI_CONF_STAT)
13052 caps_ptr = P2ALIGN(pci_config_get8(mpt->m_config_handle,
13068 mptsas_log(mpt, CE_WARN,
13073 mptsas_log(mpt, CE_WARN,
13083 cap = pci_config_get8(mpt->m_config_handle, caps_ptr);
13086 mptsas_log(mpt, CE_NOTE,
13088 mpt->m_instance);
13089 mpt->m_options |= MPTSAS_OPT_PM;
13092 mpt->m_pmcsr_offset = caps_ptr + PCI_PMCSR;
13105 mptsas_log(mpt, CE_NOTE,
13107 "0x%x.\n", mpt->m_instance, cap);
13114 caps_ptr = P2ALIGN(pci_config_get8(mpt->m_config_handle,
13121 mptsas_init_pm(mptsas_t *mpt)
13132 if (mptsas_get_pci_cap(mpt) == FALSE) {
13139 if (!(mpt->m_options & MPTSAS_OPT_PM))
13145 (void) sprintf(pmc_name, "NAME=mptsas%d", mpt->m_instance);
13147 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, mpt->m_dip,
13149 mpt->m_options &= ~MPTSAS_OPT_PM;
13150 mptsas_log(mpt, CE_WARN,
13152 mpt->m_instance);
13159 (void) pm_busy_component(mpt->m_dip, 0);
13160 pmcsr_stat = pci_config_get16(mpt->m_config_handle,
13161 mpt->m_pmcsr_offset);
13163 mptsas_log(mpt, CE_WARN, "mptsas%d: Power up the device",
13164 mpt->m_instance);
13165 pci_config_put16(mpt->m_config_handle, mpt->m_pmcsr_offset,
13168 if (pm_power_has_changed(mpt->m_dip, 0, PM_LEVEL_D0) != DDI_SUCCESS) {
13169 mptsas_log(mpt, CE_WARN, "pm_power_has_changed failed");
13172 mpt->m_power_level = PM_LEVEL_D0;
13176 mpt->m_pm_idle_delay = ddi_prop_get_int(DDI_DEV_T_ANY,
13177 mpt->m_dip, 0, "mptsas-pm-idle-delay", MPTSAS_PM_IDLE_TIMEOUT);
13183 mptsas_register_intrs(mptsas_t *mpt)
13188 dip = mpt->m_dip;
13192 mptsas_log(mpt, CE_WARN, "ddi_intr_get_supported_types "
13203 if (mptsas_add_intrs(mpt, DDI_INTR_TYPE_MSI) == DDI_SUCCESS) {
13205 mpt->m_intr_type = DDI_INTR_TYPE_MSI;
13210 if (mptsas_add_intrs(mpt, DDI_INTR_TYPE_FIXED) == DDI_SUCCESS) {
13212 mpt->m_intr_type = DDI_INTR_TYPE_FIXED;
13224 mptsas_unregister_intrs(mptsas_t *mpt)
13226 mptsas_rem_intrs(mpt);
13235 mptsas_add_intrs(mptsas_t *mpt, int intr_type)
13237 dev_info_t *dip = mpt->m_dip;
13246 mptsas_log(mpt, CE_WARN, "ddi_intr_get_nintrs() failed, "
13255 mptsas_log(mpt, CE_WARN, "ddi_intr_get_navail() failed, "
13262 mptsas_log(mpt, CE_NOTE, "ddi_intr_get_nvail returned %d, "
13272 mpt->m_intr_size = count * sizeof (ddi_intr_handle_t);
13273 mpt->m_htable = kmem_alloc(mpt->m_intr_size, KM_SLEEP);
13278 ret = ddi_intr_alloc(dip, mpt->m_htable, intr_type, 0,
13282 mptsas_log(mpt, CE_WARN, "ddi_intr_alloc() failed, ret %d\n",
13284 kmem_free(mpt->m_htable, mpt->m_intr_size);
13290 mptsas_log(mpt, CE_NOTE, "Requested: %d, Received: %d\n",
13294 mpt->m_intr_cnt = actual;
13299 if ((ret = ddi_intr_get_pri(mpt->m_htable[0],
13300 &mpt->m_intr_pri)) != DDI_SUCCESS) {
13301 mptsas_log(mpt, CE_WARN, "ddi_intr_get_pri() failed %d\n", ret);
13305 (void) ddi_intr_free(mpt->m_htable[i]);
13308 kmem_free(mpt->m_htable, mpt->m_intr_size);
13313 if (mpt->m_intr_pri >= ddi_intr_get_hilevel_pri()) {
13314 mptsas_log(mpt, CE_WARN, "mptsas_add_intrs: "
13319 (void) ddi_intr_free(mpt->m_htable[i]);
13322 kmem_free(mpt->m_htable, mpt->m_intr_size);
13328 if ((ret = ddi_intr_add_handler(mpt->m_htable[i], mptsas_intr,
13329 (caddr_t)mpt, (caddr_t)(uintptr_t)i)) != DDI_SUCCESS) {
13330 mptsas_log(mpt, CE_WARN, "ddi_intr_add_handler() "
13335 (void) ddi_intr_free(mpt->m_htable[i]);
13338 kmem_free(mpt->m_htable, mpt->m_intr_size);
13343 if ((ret = ddi_intr_get_cap(mpt->m_htable[0], &mpt->m_intr_cap))
13345 mptsas_log(mpt, CE_WARN, "ddi_intr_get_cap() failed %d\n", ret);
13349 (void) ddi_intr_free(mpt->m_htable[i]);
13352 kmem_free(mpt->m_htable, mpt->m_intr_size);
13359 if (mpt->m_intr_cap & DDI_INTR_FLAG_BLOCK) {
13361 (void) ddi_intr_block_enable(mpt->m_htable, mpt->m_intr_cnt);
13364 for (i = 0; i < mpt->m_intr_cnt; i++) {
13365 (void) ddi_intr_enable(mpt->m_htable[i]);
13377 mptsas_rem_intrs(mptsas_t *mpt)
13384 if (mpt->m_intr_cap & DDI_INTR_FLAG_BLOCK) {
13386 (void) ddi_intr_block_disable(mpt->m_htable, mpt->m_intr_cnt);
13388 for (i = 0; i < mpt->m_intr_cnt; i++) {
13389 (void) ddi_intr_disable(mpt->m_htable[i]);
13394 for (i = 0; i < mpt->m_intr_cnt; i++) {
13395 (void) ddi_intr_remove_handler(mpt->m_htable[i]);
13396 (void) ddi_intr_free(mpt->m_htable[i]);
13399 kmem_free(mpt->m_htable, mpt->m_intr_size);
13422 mptsas_fm_init(mptsas_t *mpt)
13430 if (mpt->m_fm_capabilities) {
13432 mpt->m_reg_acc_attr.devacc_attr_access = DDI_FLAGERR_ACC;
13433 mpt->m_msg_dma_attr.dma_attr_flags |= DDI_DMA_FLAGERR;
13434 mpt->m_io_dma_attr.dma_attr_flags |= DDI_DMA_FLAGERR;
13438 * mpt->m_fm_capabilities will be updated to indicate
13441 ddi_fm_init(mpt->m_dip, &mpt->m_fm_capabilities, &fm_ibc);
13447 if (DDI_FM_EREPORT_CAP(mpt->m_fm_capabilities) ||
13448 DDI_FM_ERRCB_CAP(mpt->m_fm_capabilities)) {
13449 pci_ereport_setup(mpt->m_dip);
13455 if (DDI_FM_ERRCB_CAP(mpt->m_fm_capabilities)) {
13456 ddi_fm_handler_register(mpt->m_dip,
13457 mptsas_fm_error_cb, (void *) mpt);
13468 mptsas_fm_fini(mptsas_t *mpt)
13471 if (mpt->m_fm_capabilities) {
13477 if (DDI_FM_ERRCB_CAP(mpt->m_fm_capabilities)) {
13478 ddi_fm_handler_unregister(mpt->m_dip);
13485 if (DDI_FM_EREPORT_CAP(mpt->m_fm_capabilities) ||
13486 DDI_FM_ERRCB_CAP(mpt->m_fm_capabilities)) {
13487 pci_ereport_teardown(mpt->m_dip);
13491 ddi_fm_fini(mpt->m_dip);
13494 mpt->m_reg_acc_attr.devacc_attr_access = DDI_DEFAULT_ACC;
13495 mpt->m_msg_dma_attr.dma_attr_flags &= ~DDI_DMA_FLAGERR;
13496 mpt->m_io_dma_attr.dma_attr_flags &= ~DDI_DMA_FLAGERR;
13524 mptsas_fm_ereport(mptsas_t *mpt, char *detail)
13531 if (DDI_FM_EREPORT_CAP(mpt->m_fm_capabilities)) {
13532 ddi_fm_ereport_post(mpt->m_dip, buf, ena, DDI_NOSLEEP,
13538 mptsas_get_target_device_info(mptsas_t *mpt, uint32_t page_address,
13553 rval = mptsas_get_sas_device_page0(mpt, page_address, dev_handle,
13572 for (config = 0; config < mpt->m_num_raid_configs; config++) {
13574 if (*dev_handle == mpt->m_raidconfig[config].
13591 tmp_tgt = mptsas_tgt_alloc(mpt->m_tmp_targets, *dev_handle,
13593 mutex_exit(&mpt->m_mutex);
13595 devicename = mptsas_get_sata_guid(mpt, tmp_tgt, 0);
13598 mutex_enter(&mpt->m_mutex);
13599 refhash_remove(mpt->m_tmp_targets, tmp_tgt);
13610 mutex_enter(&mpt->m_mutex);
13611 refhash_remove(mpt->m_tmp_targets, tmp_tgt);
13614 phymask = mptsas_physport_to_phymask(mpt, physport);
13615 *pptgt = mptsas_tgt_alloc(mpt->m_targets, *dev_handle, sas_wwn,
13618 mptsas_log(mpt, CE_WARN, "Failed to allocated target"
13630 mptsas_get_sata_guid(mptsas_t *mpt, mptsas_target_t *ptgt, int lun)
13643 rval = mptsas_inquiry(mpt, ptgt, lun, 0x83, inq83,
13646 mptsas_log(mpt, CE_WARN, "!mptsas request inquiry page "
13654 mptsas_log(mpt, CE_WARN, "!Descriptor is not lun associated.");
13680 mptsas_inquiry(mptsas_t *mpt, mptsas_target_t *ptgt, int lun, uchar_t page,
13693 ap.a_hba_tran = mpt->m_tran;
13708 ret = mptsas_send_scsi_cmd(mpt, &ap, ptgt, &cdb[0], CDB_GROUP0, data_bp,
13723 mptsas_send_scsi_cmd(mptsas_t *mpt, struct scsi_address *ap,
13742 bcopy((caddr_t)mpt->m_tran,
13875 mptsas_t *mpt;
13888 mpt = DIP2MPT(pdip);
13889 if (!mpt) {
13992 mptsas_t *mpt = DIP2MPT(pdip);
13996 rval = mptsas_inquiry(mpt, ptgt, lun, 0, (uchar_t *)sd_inq,
14014 mptsas_t *mpt = DIP2MPT(pdip);
14024 ptgt = mptsas_wwid_to_ptgt(mpt, phymask, sasaddr);
14075 mptsas_t *mpt = DIP2MPT(pdip);
14085 ptgt = mptsas_phy_to_tgt(mpt, phymask, phy);
14163 mptsas_t *mpt = DIP2MPT(pdip);
14168 mutex_enter(&mpt->m_mutex);
14172 mutex_exit(&mpt->m_mutex);
14208 ap.a_hba_tran = mpt->m_tran;
14222 ret = mptsas_send_scsi_cmd(mpt, &ap, ptgt, &cdb[0], CDB_GROUP5,
14280 mptsas_t *mpt = DIP2MPT(pdip);
14283 mutex_enter(&mpt->m_mutex);
14284 ptgt = refhash_linear_search(mpt->m_targets,
14286 mutex_exit(&mpt->m_mutex);
14288 mptsas_log(mpt, CE_WARN, "Volume with VolDevHandle of 0x%x "
14294 rval = mptsas_inquiry(mpt, ptgt, 0, 0, (uchar_t *)sd_inq,
14314 mptsas_t *mpt = DIP2MPT(pdip);
14323 mutex_enter(&mpt->m_mutex);
14324 for (config = 0; config < mpt->m_num_raid_configs; config++) {
14326 if (mpt->m_raidconfig[config].m_raidvol[vol].m_israid
14328 target = mpt->m_raidconfig[config].
14330 mutex_exit(&mpt->m_mutex);
14333 mutex_enter(&mpt->m_mutex);
14337 mutex_exit(&mpt->m_mutex);
14353 mptsas_t *mpt = DIP2MPT(pdip);
14355 mutex_enter(&mpt->m_mutex);
14357 mutex_exit(&mpt->m_mutex);
14438 mptsas_update_hashtab(struct mptsas *mpt)
14449 (void) mptsas_get_raid_info(mpt);
14451 dev_handle = mpt->m_smp_devhdl;
14452 for (; mpt->m_done_traverse_smp == 0; ) {
14455 if (mptsas_get_sas_expander_page0(mpt, page_address, &smp_node)
14459 mpt->m_smp_devhdl = dev_handle = smp_node.m_devhdl;
14460 (void) mptsas_smp_alloc(mpt, &smp_node);
14466 dev_handle = mpt->m_dev_handle;
14473 for (; mpt->m_done_traverse_dev == 0; ) {
14479 rval = mptsas_get_target_device_info(mpt, page_address,
14487 mpt->m_dev_handle = dev_handle;
14493 mptsas_update_driver_data(struct mptsas *mpt)
14498 ASSERT(MUTEX_HELD(&mpt->m_mutex));
14502 * 1. update port/phymask mapping table mpt->m_phy_info
14507 mptsas_update_phymask(mpt);
14517 for (tp = refhash_first(mpt->m_targets); tp != NULL;
14518 tp = refhash_next(mpt->m_targets, tp)) {
14523 for (sp = refhash_first(mpt->m_smp_targets); sp != NULL;
14524 sp = refhash_next(mpt->m_smp_targets, sp)) {
14528 mpt->m_done_traverse_dev = 0;
14529 mpt->m_done_traverse_smp = 0;
14530 mpt->m_dev_handle = mpt->m_smp_devhdl = MPTSAS_INVALID_DEVHDL;
14531 mptsas_update_hashtab(mpt);
14538 mptsas_t *mpt = DIP2MPT(pdip);
14558 mutex_enter(&mpt->m_mutex);
14560 if (!mpt->m_done_traverse_dev || !mpt->m_done_traverse_smp) {
14561 mptsas_update_hashtab(mpt);
14564 for (psmp = refhash_first(mpt->m_smp_targets); psmp != NULL;
14565 psmp = refhash_next(mpt->m_smp_targets, psmp)) {
14569 mutex_exit(&mpt->m_mutex);
14571 mutex_enter(&mpt->m_mutex);
14575 for (ptgt = refhash_first(mpt->m_targets); ptgt != NULL;
14576 ptgt = refhash_next(mpt->m_targets, ptgt)) {
14579 mutex_exit(&mpt->m_mutex);
14581 mutex_enter(&mpt->m_mutex);
14584 mutex_exit(&mpt->m_mutex);
14618 mptsas_t *mpt = DIP2MPT(pdip);
14646 mptsas_log(mpt, CE_WARN, "mptsas driver "
14899 mptsas_t *mpt = DIP2MPT(pdip);
14922 rval = mptsas_inquiry(mpt, ptgt, lun, 0x83, inq83,
14925 mptsas_log(mpt, CE_WARN, "!mptsas request inquiry page "
14951 if (mpt->m_mpxio_enable == TRUE) {
14952 mptsas_log(mpt, CE_NOTE, "!Target:%x, "
14974 mptsas_log(mpt, CE_WARN, "!Encode devid failed for "
14982 mptsas_log(mpt, CE_WARN, "!Repeated page83 requests timeout "
14989 if ((guid != NULL) && (mpt->m_mpxio_enable == TRUE)) {
15021 mptsas_t *mpt = DIP2MPT(pdip);
15042 mutex_enter(&mpt->m_mutex);
15047 mutex_exit(&mpt->m_mutex);
15070 mutex_enter(&mpt->m_mutex);
15072 (void) mptsas_flush_led_status(mpt,
15074 mutex_exit(&mpt->m_mutex);
15079 mptsas_log(mpt, CE_WARN, "path:target: "
15092 mptsas_log(mpt, CE_WARN, "The GUID of the "
15100 mptsas_log(mpt, CE_WARN, "path:"
15109 mptsas_log(mpt, CE_WARN, "path:target:"
15118 mptsas_log(mpt, CE_WARN, "Can't get client-guid "
15132 mptsas_log(mpt, CE_WARN, "mptsas driver found no compatible "
15158 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15167 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15176 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15185 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15193 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15203 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15209 mutex_enter(&mpt->m_mutex);
15214 rval = mptsas_get_sas_device_page0(mpt, page_address,
15218 mutex_exit(&mpt->m_mutex);
15219 mptsas_log(mpt, CE_WARN, "mptsas unable to get "
15227 rval = mptsas_get_sas_device_page0(mpt, page_address,
15231 mutex_exit(&mpt->m_mutex);
15232 mptsas_log(mpt, CE_WARN, "mptsas unable to get"
15238 mutex_exit(&mpt->m_mutex);
15260 mptsas_log(mpt, CE_WARN,
15270 mpt->un.m_base_wwid);
15276 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15294 mptsas_log(mpt, CE_WARN, "mpt_sas driver "
15308 mptsas_log(mpt, CE_WARN, "mptsas driver"
15320 mptsas_log(mpt, CE_WARN, "mptsas driver unable to "
15329 mutex_enter(&mpt->m_mutex);
15331 (void) mptsas_flush_led_status(mpt, ptgt);
15332 mutex_exit(&mpt->m_mutex);
15371 mptsas_t *mpt = DIP2MPT(pdip);
15391 mutex_enter(&mpt->m_mutex);
15396 mutex_exit(&mpt->m_mutex);
15399 * generate compatible property with binding-set "mpt"
15408 mptsas_log(mpt, CE_WARN, "mptsas found no compatible driver "
15424 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15435 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15444 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15462 mptsas_log(mpt, CE_WARN, "mptsas unable to "
15473 mptsas_log(mpt, CE_WARN, "mptsas unable to "
15484 mptsas_log(mpt, CE_WARN, "mptsas unable to "
15493 mptsas_log(mpt, CE_WARN, "mptsas unable to"
15501 mptsas_log(mpt, CE_WARN, "mptsas unable "
15515 mutex_enter(&mpt->m_mutex);
15520 rval = mptsas_get_sas_device_page0(mpt, page_address,
15525 mutex_exit(&mpt->m_mutex);
15526 mptsas_log(mpt, CE_WARN, "mptsas unable to get"
15534 rval = mptsas_get_sas_device_page0(mpt, page_address,
15538 mutex_exit(&mpt->m_mutex);
15539 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15545 mutex_exit(&mpt->m_mutex);
15567 mptsas_log(mpt, CE_WARN,
15577 mpt->un.m_base_wwid);
15583 mptsas_log(mpt, CE_WARN,
15595 mptsas_log(mpt, CE_WARN,
15607 mptsas_log(mpt, CE_WARN,
15622 instance = ddi_get_instance(mpt->m_dip);
15631 mptsas_log(mpt, CE_WARN, "mptsas "
15656 mptsas_log(mpt, CE_WARN, "mpt_sas driver "
15670 mptsas_log(mpt, CE_WARN, "mptsas driver "
15688 mutex_enter(&mpt->m_mutex);
15690 (void) mptsas_flush_led_status(mpt, ptgt);
15691 mutex_exit(&mpt->m_mutex);
15722 mptsas_t *mpt = DIP2MPT(pdip);
15727 smp_sd.smp_sd_address.smp_a_hba_tran = mpt->m_smptran;
15738 mptsas_t *mpt = DIP2MPT(pdip);
15753 psmp = mptsas_wwid_to_psmp(mpt, phymask, sas_wwn);
15773 mptsas_t *mpt = DIP2MPT(pdip);
15816 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15826 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15833 mutex_enter(&mpt->m_mutex);
15837 rval = mptsas_get_sas_expander_page0(mpt, page_address,
15840 mutex_exit(&mpt->m_mutex);
15841 mptsas_log(mpt, CE_WARN,
15852 rval = mptsas_get_sas_device_page0(mpt, page_address,
15856 mutex_exit(&mpt->m_mutex);
15857 mptsas_log(mpt, CE_WARN, "mptsas unable to get "
15866 rval = mptsas_get_sas_device_page0(mpt, page_address,
15871 mutex_exit(&mpt->m_mutex);
15872 mptsas_log(mpt, CE_WARN, "mptsas unable to get "
15877 mutex_exit(&mpt->m_mutex);
15889 mpt->un.m_base_wwid);
15895 mptsas_log(mpt, CE_WARN, "mptsas unable to create "
15904 mptsas_log(mpt, CE_WARN, "mptsas unable to "
15933 mptsas_log(mpt, CE_WARN, "mptsas virtual port "
15938 mutex_enter(&mpt->m_mutex);
15944 "%x", mpt->m_phy_info[i].phy_mask);
15946 phy_mask = mpt->m_phy_info[i].phy_mask;
15959 if (mptsas_smhba_phy_init(mpt)) {
15960 mutex_exit(&mpt->m_mutex);
15961 mptsas_log(mpt, CE_WARN, "mptsas phy update "
15965 mutex_exit(&mpt->m_mutex);
15967 mptsas_smhba_set_all_phy_props(mpt, pdip, numphys, phy_mask,
15975 mptsas_log(mpt, CE_WARN, "mptsas update "
15987 mptsas_log(mpt, CE_WARN, "mptsas update iport"
16024 mptsas_t *mpt;
16028 mpt = (mptsas_t *)smp_pkt->smp_pkt_address->
16059 mutex_enter(&mpt->m_mutex);
16060 ret = mptsas_do_passthru(mpt, (uint8_t *)&req, (uint8_t *)&rep,
16066 mutex_exit(&mpt->m_mutex);
16085 mptsas_log(mpt, CE_NOTE, "smp_start: get unknown ioc"
16093 mptsas_log(mpt, CE_NOTE, "smp_start: get error SAS status:%x",
16107 mptsas_phy_to_tgt(mptsas_t *mpt, mptsas_phymask_t phymask, uint8_t phy)
16134 if (mpt->m_phy_info[phy].phy_mask != phymask)
16137 mutex_enter(&mpt->m_mutex);
16139 ptgt = refhash_linear_search(mpt->m_targets, mptsas_target_eval_nowwn,
16142 mutex_exit(&mpt->m_mutex);
16146 if (mpt->m_done_traverse_dev) {
16147 mutex_exit(&mpt->m_mutex);
16152 cur_handle = mpt->m_dev_handle;
16157 rval = mptsas_get_target_device_info(mpt, page_address,
16168 mpt->m_dev_handle = cur_handle;
16175 mutex_exit(&mpt->m_mutex);
16187 mptsas_wwid_to_ptgt(mptsas_t *mpt, mptsas_phymask_t phymask, uint64_t wwid)
16197 mutex_enter(&mpt->m_mutex);
16198 tmp_tgt = refhash_lookup(mpt->m_targets, &addr);
16200 mutex_exit(&mpt->m_mutex);
16208 rval = mptsas_get_raid_info(mpt);
16210 tmp_tgt = refhash_lookup(mpt->m_targets, &addr);
16212 mutex_exit(&mpt->m_mutex);
16216 if (mpt->m_done_traverse_dev) {
16217 mutex_exit(&mpt->m_mutex);
16222 cur_handle = mpt->m_dev_handle;
16227 rval = mptsas_get_target_device_info(mpt, page_address,
16239 mpt->m_dev_handle = cur_handle;
16247 mutex_exit(&mpt->m_mutex);
16252 mptsas_wwid_to_psmp(mptsas_t *mpt, mptsas_phymask_t phymask, uint64_t wwid)
16262 mutex_enter(&mpt->m_mutex);
16263 psmp = refhash_lookup(mpt->m_smp_targets, &addr);
16265 mutex_exit(&mpt->m_mutex);
16269 if (mpt->m_done_traverse_smp) {
16270 mutex_exit(&mpt->m_mutex);
16275 cur_handle = mpt->m_smp_devhdl;
16280 rval = mptsas_get_sas_expander_page0(mpt, page_address,
16285 mpt->m_smp_devhdl = cur_handle = smp_node.m_devhdl;
16286 psmp = mptsas_smp_alloc(mpt, &smp_node);
16294 mutex_exit(&mpt->m_mutex);
16346 mptsas_smp_alloc(mptsas_t *mpt, mptsas_smp_t *data)
16353 ret_data = refhash_lookup(mpt->m_smp_targets, &addr);
16367 refhash_insert(mpt->m_smp_targets, ret_data);
16389 mptsas_addr_to_ptgt(mptsas_t *mpt, char *addr, mptsas_phymask_t phymask)
16400 ptgt = mptsas_wwid_to_ptgt(mpt, (int)phymask, wwn);
16402 ptgt = mptsas_phy_to_tgt(mpt, (int)phymask, phynum);
16408 mptsas_flush_led_status(mptsas_t *mpt, mptsas_target_t *ptgt)
16423 return (mptsas_send_sep(mpt, ptgt, &slotstatus,
16431 mptsas_send_sep(mptsas_t *mpt, mptsas_target_t *ptgt,
16438 ASSERT(mutex_owned(&mpt->m_mutex));
16469 ret = mptsas_do_passthru(mpt, (uint8_t *)&req, (uint8_t *)&rep, NULL,
16472 mptsas_log(mpt, CE_NOTE, "mptsas_send_sep: passthru SEP "
16478 mptsas_log(mpt, CE_NOTE, "send_sep act %x: ioc "
16512 mptsas_dma_addr_create(mptsas_t *mpt, ddi_dma_attr_t dma_attr,
16523 if (ddi_dma_alloc_handle(mpt->m_dip, &dma_attr, DDI_DMA_SLEEP,
16528 if (ddi_dma_mem_alloc(*dma_hdp, alloc_size, &mpt->m_dev_acc_attr,