Lines Matching refs:mrioc
44 static void mpi3mr_send_event_ack(struct mpi3mr_ioc *mrioc, u8 event,
53 * @mrioc: Adapter instance reference
60 static u16 mpi3mr_host_tag_for_scmd(struct mpi3mr_ioc *mrioc,
70 if (hw_queue >= mrioc->num_op_reply_q)
74 if (WARN_ON(host_tag >= mrioc->max_host_ios))
91 * @mrioc: Adapter instance reference
101 struct mpi3mr_ioc *mrioc, u16 host_tag, u16 qidx)
107 if (WARN_ON(host_tag > mrioc->max_host_ios))
112 scmd = scsi_host_find_tag(mrioc->shost, unique_tag);
124 * @mrioc: Adapter instance reference
132 static void mpi3mr_clear_scmd_priv(struct mpi3mr_ioc *mrioc,
147 clear_bit(priv->chain_idx, mrioc->chain_bitmap);
151 clear_bit(priv->meta_chain_idx, mrioc->chain_bitmap);
156 static void mpi3mr_dev_rmhs_send_tm(struct mpi3mr_ioc *mrioc, u16 handle,
216 * @mrioc: Adapter instance reference
223 static void mpi3mr_fwevt_add_to_list(struct mpi3mr_ioc *mrioc,
228 if (!mrioc->fwevt_worker_thread)
231 spin_lock_irqsave(&mrioc->fwevt_lock, flags);
235 list_add_tail(&fwevt->list, &mrioc->fwevt_list);
239 queue_work(mrioc->fwevt_worker_thread, &fwevt->work);
240 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
245 * @mrioc: Adapter instance reference
252 static void mpi3mr_fwevt_del_from_list(struct mpi3mr_ioc *mrioc,
257 spin_lock_irqsave(&mrioc->fwevt_lock, flags);
266 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
271 * @mrioc: Adapter instance reference
278 struct mpi3mr_ioc *mrioc)
283 spin_lock_irqsave(&mrioc->fwevt_lock, flags);
284 if (!list_empty(&mrioc->fwevt_list)) {
285 fwevt = list_first_entry(&mrioc->fwevt_list,
294 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
330 * @mrioc: Adapter instance reference
337 void mpi3mr_cleanup_fwevt_list(struct mpi3mr_ioc *mrioc)
341 if ((list_empty(&mrioc->fwevt_list) && !mrioc->current_event) ||
342 !mrioc->fwevt_worker_thread)
345 while ((fwevt = mpi3mr_dequeue_fwevt(mrioc)))
348 if (mrioc->current_event) {
349 fwevt = mrioc->current_event;
369 * @mrioc: Adapter instance reference
378 static void mpi3mr_queue_qd_reduction_event(struct mpi3mr_ioc *mrioc,
394 ioc_warn(mrioc, "failed to queue TG QD reduction event\n");
398 fwevt->mrioc = mrioc;
406 dprint_event_bh(mrioc, "qd reduction event queued for tg_id(%d)\n",
408 mpi3mr_fwevt_add_to_list(mrioc, fwevt);
413 * @mrioc: Adapter instance reference
420 void mpi3mr_invalidate_devhandles(struct mpi3mr_ioc *mrioc)
425 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
451 struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data;
460 ioc_info(mrioc, "%s :Host Tag = %d, qid = %d\n",
482 struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data;
492 dma_unmap_sg(&mrioc->pdev->dev, scsi_prot_sglist(scmd),
494 mpi3mr_clear_scmd_priv(mrioc, scmd);
499 mrioc->flush_io_count++;
572 * @mrioc: Adapter instance reference
580 void mpi3mr_flush_host_io(struct mpi3mr_ioc *mrioc)
582 struct Scsi_Host *shost = mrioc->shost;
584 mrioc->flush_io_count = 0;
585 ioc_info(mrioc, "%s :Flushing Host I/O cmds post reset\n", __func__);
587 mpi3mr_flush_scmd, (void *)mrioc);
588 ioc_info(mrioc, "%s :Flushed %d Host I/O cmds\n", __func__,
589 mrioc->flush_io_count);
594 * @mrioc: Adapter instance reference
603 void mpi3mr_flush_cmds_for_unrecovered_controller(struct mpi3mr_ioc *mrioc)
605 struct Scsi_Host *shost = mrioc->shost;
608 if (!mrioc->unrecoverable)
611 if (mrioc->op_reply_qinfo) {
612 for (i = 0; i < mrioc->num_queues; i++) {
613 while (atomic_read(&mrioc->op_reply_qinfo[i].in_use))
615 atomic_set(&mrioc->op_reply_qinfo[i].pend_ios, 0);
618 mrioc->flush_io_count = 0;
620 mpi3mr_flush_scmd, (void *)mrioc);
621 mpi3mr_flush_delayed_cmd_lists(mrioc);
622 mpi3mr_flush_drv_cmds(mrioc);
646 * @mrioc: Adapter instance reference
653 static void mpi3mr_tgtdev_add_to_list(struct mpi3mr_ioc *mrioc,
658 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
661 list_add_tail(&tgtdev->list, &mrioc->tgtdev_list);
663 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
668 * @mrioc: Adapter instance reference
677 static void mpi3mr_tgtdev_del_from_list(struct mpi3mr_ioc *mrioc,
682 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
690 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
695 * @mrioc: Adapter instance reference
704 struct mpi3mr_ioc *mrioc, u16 handle)
708 assert_spin_locked(&mrioc->tgtdev_lock);
709 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list)
721 * @mrioc: Adapter instance reference
730 struct mpi3mr_ioc *mrioc, u16 handle)
735 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
736 tgtdev = __mpi3mr_get_tgtdev_by_handle(mrioc, handle);
737 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
743 * @mrioc: Adapter instance reference
752 struct mpi3mr_ioc *mrioc, u16 persist_id)
756 assert_spin_locked(&mrioc->tgtdev_lock);
757 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list)
769 * @mrioc: Adapter instance reference
778 struct mpi3mr_ioc *mrioc, u16 persist_id)
783 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
784 tgtdev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, persist_id);
785 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
791 * @mrioc: Adapter instance reference
800 struct mpi3mr_ioc *mrioc, struct mpi3mr_stgt_priv_data *tgt_priv)
804 assert_spin_locked(&mrioc->tgtdev_lock);
813 * @mrioc: Adapter instance reference
822 static void mpi3mr_set_io_divert_for_all_vd_in_tg(struct mpi3mr_ioc *mrioc,
829 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
830 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
837 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
844 * @mrioc: Adapter instance reference
849 void mpi3mr_print_device_event_notice(struct mpi3mr_ioc *mrioc,
852 ioc_notice(mrioc, "Device %s was in progress before the reset and\n",
854 ioc_notice(mrioc, "completed after reset, verify whether the exposed devices\n");
855 ioc_notice(mrioc, "are matched with attached devices for correctness\n");
860 * @mrioc: Adapter instance reference
869 void mpi3mr_remove_tgtdev_from_host(struct mpi3mr_ioc *mrioc,
874 ioc_info(mrioc, "%s :Removing handle(0x%04x), wwid(0x%016llx)\n",
882 if (!mrioc->sas_transport_enabled || (tgtdev->dev_type !=
885 if (mrioc->current_event)
886 mrioc->current_event->pending_at_sml = 1;
889 if (mrioc->current_event) {
890 mrioc->current_event->pending_at_sml = 0;
891 if (mrioc->current_event->discard) {
892 mpi3mr_print_device_event_notice(mrioc,
899 mpi3mr_remove_tgtdev_from_sas_transport(mrioc, tgtdev);
901 ioc_info(mrioc, "%s :Removed handle(0x%04x), wwid(0x%016llx)\n",
907 * @mrioc: Adapter instance reference
916 static int mpi3mr_report_tgtdev_to_host(struct mpi3mr_ioc *mrioc,
922 if (mrioc->reset_in_progress)
925 tgtdev = mpi3mr_get_tgtdev_by_perst_id(mrioc, perst_id);
934 if (!mrioc->sas_transport_enabled || (tgtdev->dev_type !=
937 if (mrioc->current_event)
938 mrioc->current_event->pending_at_sml = 1;
939 scsi_scan_target(&mrioc->shost->shost_gendev,
940 mrioc->scsi_device_channel, tgtdev->perst_id,
944 if (mrioc->current_event) {
945 mrioc->current_event->pending_at_sml = 0;
946 if (mrioc->current_event->discard) {
947 mpi3mr_print_device_event_notice(mrioc, true);
952 mpi3mr_report_tgtdev_to_sas_transport(mrioc, tgtdev);
1032 * @mrioc: Adapter instance reference
1041 void mpi3mr_rfresh_tgtdevs(struct mpi3mr_ioc *mrioc)
1046 dprint_reset(mrioc, "refresh target devices: check for removals\n");
1047 list_for_each_entry_safe(tgtdev, tgtdev_next, &mrioc->tgtdev_list,
1059 list_for_each_entry_safe(tgtdev, tgtdev_next, &mrioc->tgtdev_list,
1062 dprint_reset(mrioc, "removing target device with perst_id(%d)\n",
1065 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
1066 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, true);
1069 dprint_reset(mrioc, "hiding target device with perst_id(%d)\n",
1071 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
1076 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
1080 mpi3mr_report_tgtdev_to_host(mrioc,
1091 * @mrioc: Adapter instance reference
1101 static void mpi3mr_update_tgtdev(struct mpi3mr_ioc *mrioc,
1122 enclosure_dev = mpi3mr_enclosure_find_by_handle(mrioc,
1235 if (!mrioc->shost)
1237 prot_mask = scsi_host_get_prot(mrioc->shost);
1239 scsi_host_set_prot(mrioc->shost, prot_mask & 0x77);
1240 ioc_info(mrioc,
1242 ioc_info(mrioc,
1264 if (vdinf_io_throttle_group < mrioc->num_io_throttle_group) {
1265 tg = mrioc->throttle_groups + vdinf_io_throttle_group;
1287 * @mrioc: Adapter instance reference
1296 static void mpi3mr_devstatuschg_evt_bh(struct mpi3mr_ioc *mrioc,
1306 ioc_info(mrioc,
1321 ioc_info(mrioc, "%s :Unhandled reason code(0x%x)\n", __func__,
1326 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
1332 mpi3mr_report_tgtdev_to_host(mrioc, tgtdev->perst_id);
1336 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
1339 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, false);
1350 * @mrioc: Adapter instance reference
1360 static void mpi3mr_devinfochg_evt_bh(struct mpi3mr_ioc *mrioc,
1368 ioc_info(mrioc,
1371 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
1374 mpi3mr_update_tgtdev(mrioc, tgtdev, dev_pg0, false);
1376 mpi3mr_report_tgtdev_to_host(mrioc, perst_id);
1378 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
1389 * @mrioc: Adapter instance reference
1395 void mpi3mr_free_enclosure_list(struct mpi3mr_ioc *mrioc)
1400 enclosure_dev_next, &mrioc->enclosure_list, list) {
1408 * @mrioc: Adapter instance reference
1417 struct mpi3mr_ioc *mrioc, u16 handle)
1421 list_for_each_entry(enclosure_dev, &mrioc->enclosure_list, list) {
1433 * @mrioc: Adapter instance reference
1439 static void mpi3mr_encldev_add_chg_evt_debug(struct mpi3mr_ioc *mrioc,
1444 if (!(mrioc->logging_level & MPI3_DEBUG_EVENT_WORK_TASK))
1452 ioc_info(mrioc,
1456 ioc_info(mrioc,
1466 * @mrioc: Adapter instance reference
1476 static void mpi3mr_encldev_add_chg_evt_bh(struct mpi3mr_ioc *mrioc,
1486 mpi3mr_encldev_add_chg_evt_debug(mrioc, encl_pg0, added);
1494 enclosure_dev = mpi3mr_enclosure_find_by_handle(mrioc,
1503 &mrioc->enclosure_list);
1518 * @mrioc: Adapter instance reference
1526 mpi3mr_sastopochg_evt_debug(struct mpi3mr_ioc *mrioc,
1552 ioc_info(mrioc, "%s :sas topology change: (%s)\n",
1554 ioc_info(mrioc,
1589 ioc_info(mrioc,
1598 * @mrioc: Adapter instance reference
1607 static void mpi3mr_sastopochg_evt_bh(struct mpi3mr_ioc *mrioc,
1622 mpi3mr_sastopochg_evt_debug(mrioc, event_data);
1623 if (mrioc->sas_transport_enabled) {
1624 hba_port = mpi3mr_get_hba_port_by_id(mrioc,
1627 spin_lock_irqsave(&mrioc->sas_node_lock, flags);
1628 sas_expander = __mpi3mr_expander_find_by_handle(mrioc,
1634 spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
1637 parent_sas_address = mrioc->sas_hba.sas_address;
1646 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle);
1656 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
1657 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, false);
1664 if (!mrioc->sas_transport_enabled || tgtdev->non_stl
1674 mpi3mr_update_links(mrioc, parent_sas_address, handle,
1685 if (mrioc->sas_transport_enabled && (event_data->exp_status ==
1688 mpi3mr_expander_remove(mrioc, exp_sas_address,
1695 * @mrioc: Adapter instance reference
1703 mpi3mr_pcietopochg_evt_debug(struct mpi3mr_ioc *mrioc,
1730 ioc_info(mrioc, "%s :pcie topology change: (%s)\n",
1732 ioc_info(mrioc,
1768 ioc_info(mrioc,
1777 * @mrioc: Adapter instance reference
1786 static void mpi3mr_pcietopochg_evt_bh(struct mpi3mr_ioc *mrioc,
1796 mpi3mr_pcietopochg_evt_debug(mrioc, event_data);
1805 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle);
1814 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
1815 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, false);
1828 * @mrioc: Adapter instance reference
1836 static void mpi3mr_logdata_evt_bh(struct mpi3mr_ioc *mrioc,
1839 mpi3mr_app_save_logdata(mrioc, fwevt->event_data,
1863 * @mrioc: Adapter instance reference
1871 static void mpi3mr_set_qd_for_all_vd_in_tg(struct mpi3mr_ioc *mrioc,
1879 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
1880 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
1884 dprint_event_bh(mrioc,
1894 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
1899 * @mrioc: Adapter instance reference
1907 static void mpi3mr_fwevt_bh(struct mpi3mr_ioc *mrioc,
1914 mpi3mr_fwevt_del_from_list(mrioc, fwevt);
1915 mrioc->current_event = fwevt;
1917 if (mrioc->stop_drv_processing)
1920 if (mrioc->unrecoverable) {
1921 dprint_event_bh(mrioc,
1937 mpi3mr_report_tgtdev_to_host(mrioc, perst_id);
1938 else if (mrioc->sas_transport_enabled &&
1942 if (!mrioc->sas_hba.num_phys)
1943 mpi3mr_sas_host_add(mrioc);
1945 mpi3mr_sas_host_refresh(mrioc);
1948 mpi3mr_expander_add(mrioc, handle);
1957 mpi3mr_devinfochg_evt_bh(mrioc, dev_pg0);
1962 mpi3mr_devstatuschg_evt_bh(mrioc, fwevt);
1968 mpi3mr_encldev_add_chg_evt_bh(mrioc, fwevt);
1974 mpi3mr_sastopochg_evt_bh(mrioc, fwevt);
1979 mpi3mr_pcietopochg_evt_bh(mrioc, fwevt);
1984 mpi3mr_logdata_evt_bh(mrioc, fwevt);
1992 dprint_event_bh(mrioc,
1996 mpi3mr_set_qd_for_all_vd_in_tg(mrioc, tg);
2003 while (mrioc->device_refresh_on)
2006 dprint_event_bh(mrioc,
2008 if (mrioc->sas_transport_enabled) {
2009 mpi3mr_refresh_sas_ports(mrioc);
2010 mpi3mr_refresh_expanders(mrioc);
2012 mpi3mr_rfresh_tgtdevs(mrioc);
2013 ioc_info(mrioc,
2023 mpi3mr_process_event_ack(mrioc, fwevt->event_id,
2028 mrioc->current_event = NULL;
2043 mpi3mr_fwevt_bh(fwevt->mrioc, fwevt);
2053 * @mrioc: Adapter instance reference
2063 static int mpi3mr_create_tgtdev(struct mpi3mr_ioc *mrioc,
2075 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
2076 tgtdev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, perst_id);
2079 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
2082 mpi3mr_update_tgtdev(mrioc, tgtdev, dev_pg0, true);
2088 mpi3mr_update_tgtdev(mrioc, tgtdev, dev_pg0, true);
2089 mpi3mr_tgtdev_add_to_list(mrioc, tgtdev);
2097 * @mrioc: Adapter instance reference
2104 void mpi3mr_flush_delayed_cmd_lists(struct mpi3mr_ioc *mrioc)
2109 dprint_reset(mrioc, "flushing delayed dev_remove_hs commands\n");
2110 while (!list_empty(&mrioc->delayed_rmhs_list)) {
2111 _rmhs_node = list_entry(mrioc->delayed_rmhs_list.next,
2116 dprint_reset(mrioc, "flushing delayed event ack commands\n");
2117 while (!list_empty(&mrioc->delayed_evtack_cmds_list)) {
2118 _evtack_node = list_entry(mrioc->delayed_evtack_cmds_list.next,
2127 * @mrioc: Adapter instance reference
2136 static void mpi3mr_dev_rmhs_complete_iou(struct mpi3mr_ioc *mrioc,
2145 ioc_info(mrioc,
2152 ioc_info(mrioc,
2156 mpi3mr_dev_rmhs_send_tm(mrioc, drv_cmd->dev_handle,
2160 ioc_err(mrioc,
2164 ioc_info(mrioc,
2167 clear_bit(drv_cmd->dev_handle, mrioc->removepend_bitmap);
2170 if (!list_empty(&mrioc->delayed_rmhs_list)) {
2171 delayed_dev_rmhs = list_entry(mrioc->delayed_rmhs_list.next,
2176 ioc_info(mrioc,
2179 mpi3mr_dev_rmhs_send_tm(mrioc, drv_cmd->dev_handle, drv_cmd,
2191 clear_bit(cmd_idx, mrioc->devrem_bitmap);
2196 * @mrioc: Adapter instance reference
2205 static void mpi3mr_dev_rmhs_complete_tm(struct mpi3mr_ioc *mrioc,
2222 mrioc->name, drv_cmd->dev_handle, drv_cmd->ioc_status,
2227 mrioc->name, drv_cmd->dev_handle, cmd_idx);
2239 retval = mpi3mr_admin_request_post(mrioc, &iou_ctrl, sizeof(iou_ctrl),
2243 mrioc->name);
2253 clear_bit(cmd_idx, mrioc->devrem_bitmap);
2258 * @mrioc: Adapter instance reference
2269 static void mpi3mr_dev_rmhs_send_tm(struct mpi3mr_ioc *mrioc, u16 handle,
2281 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
2282 tgtdev = __mpi3mr_get_tgtdev_by_handle(mrioc, handle);
2285 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
2290 cmd_idx = find_first_zero_bit(mrioc->devrem_bitmap,
2293 if (!test_and_set_bit(cmd_idx, mrioc->devrem_bitmap))
2308 &mrioc->delayed_rmhs_list);
2309 ioc_info(mrioc, "%s :DevRmHs: tr:handle(0x%04x) is postponed\n",
2313 drv_cmd = &mrioc->dev_rmhs_cmds[cmd_idx];
2317 ioc_info(mrioc,
2323 ioc_err(mrioc, "%s :Issue TM: Command is in use\n", __func__);
2337 set_bit(handle, mrioc->removepend_bitmap);
2338 retval = mpi3mr_admin_request_post(mrioc, &tm_req, sizeof(tm_req), 1);
2340 ioc_err(mrioc, "%s :Issue DevRmHsTM: Admin Post failed\n",
2351 clear_bit(cmd_idx, mrioc->devrem_bitmap);
2356 * @mrioc: Adapter instance reference
2365 static void mpi3mr_complete_evt_ack(struct mpi3mr_ioc *mrioc,
2375 dprint_event_th(mrioc,
2381 if (!list_empty(&mrioc->delayed_evtack_cmds_list)) {
2383 list_entry(mrioc->delayed_evtack_cmds_list.next,
2385 mpi3mr_send_event_ack(mrioc, delayed_evtack->event, drv_cmd,
2394 clear_bit(cmd_idx, mrioc->evtack_cmds_bitmap);
2399 * @mrioc: Adapter instance reference
2411 static void mpi3mr_send_event_ack(struct mpi3mr_ioc *mrioc, u8 event,
2422 dprint_event_th(mrioc,
2427 dprint_event_th(mrioc,
2431 cmd_idx = find_first_zero_bit(mrioc->evtack_cmds_bitmap,
2435 mrioc->evtack_cmds_bitmap))
2450 &mrioc->delayed_evtack_cmds_list);
2451 dprint_event_th(mrioc,
2456 drv_cmd = &mrioc->evtack_cmds[cmd_idx];
2463 dprint_event_th(mrioc,
2474 retval = mpi3mr_admin_request_post(mrioc, &evtack_req,
2477 dprint_event_th(mrioc,
2482 dprint_event_th(mrioc,
2490 clear_bit(cmd_idx, mrioc->evtack_cmds_bitmap);
2495 * @mrioc: Adapter instance reference
2505 static void mpi3mr_pcietopochg_evt_th(struct mpi3mr_ioc *mrioc,
2522 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle);
2533 mpi3mr_dev_rmhs_send_tm(mrioc, handle, NULL,
2561 * @mrioc: Adapter instance reference
2571 static void mpi3mr_sastopochg_evt_th(struct mpi3mr_ioc *mrioc,
2589 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle);
2600 mpi3mr_dev_rmhs_send_tm(mrioc, handle, NULL,
2628 * @mrioc: Adapter instance reference
2638 static void mpi3mr_devstatuschg_evt_th(struct mpi3mr_ioc *mrioc,
2648 if (mrioc->stop_drv_processing)
2674 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
2690 mpi3mr_dev_rmhs_send_tm(mrioc, dev_handle, NULL,
2693 mpi3mr_dev_rmhs_send_tm(mrioc, dev_handle, NULL,
2703 * @mrioc: Adapter instance reference
2710 static void mpi3mr_preparereset_evt_th(struct mpi3mr_ioc *mrioc,
2717 dprint_event_th(mrioc,
2719 if (mrioc->prepare_for_reset)
2721 mrioc->prepare_for_reset = 1;
2722 mrioc->prepare_for_reset_timeout_counter = 0;
2724 dprint_event_th(mrioc,
2726 mrioc->prepare_for_reset = 0;
2727 mrioc->prepare_for_reset_timeout_counter = 0;
2731 mpi3mr_send_event_ack(mrioc, event_reply->event, NULL,
2737 * @mrioc: Adapter instance reference
2744 static void mpi3mr_energypackchg_evt_th(struct mpi3mr_ioc *mrioc,
2752 ioc_warn(mrioc,
2758 ioc_info(mrioc,
2760 __func__, mrioc->facts.shutdown_timeout, shutdown_timeout);
2761 mrioc->facts.shutdown_timeout = shutdown_timeout;
2766 * @mrioc: Adapter instance reference
2773 static void mpi3mr_cablemgmt_evt_th(struct mpi3mr_ioc *mrioc,
2782 ioc_info(mrioc, "An active cable with receptacle_id %d cannot be powered.\n"
2791 ioc_info(mrioc, "A cable with receptacle_id %d is not running at optimal speed\n",
2802 * @mrioc: Adapter instance reference
2809 void mpi3mr_add_event_wait_for_device_refresh(struct mpi3mr_ioc *mrioc)
2815 dprint_event_th(mrioc,
2820 fwevt->mrioc = mrioc;
2826 mpi3mr_fwevt_add_to_list(mrioc, fwevt);
2831 * @mrioc: Adapter instance reference
2840 void mpi3mr_os_handle_events(struct mpi3mr_ioc *mrioc,
2847 if (mrioc->stop_drv_processing)
2861 if (mpi3mr_create_tgtdev(mrioc, dev_pg0))
2862 ioc_err(mrioc,
2872 mpi3mr_devstatuschg_evt_th(mrioc, event_reply);
2878 mpi3mr_sastopochg_evt_th(mrioc, event_reply);
2884 mpi3mr_pcietopochg_evt_th(mrioc, event_reply);
2889 mpi3mr_preparereset_evt_th(mrioc, event_reply);
2903 mpi3mr_energypackchg_evt_th(mrioc, event_reply);
2908 mpi3mr_cablemgmt_evt_th(mrioc, event_reply);
2917 ioc_info(mrioc, "%s :event 0x%02x is not handled\n",
2925 ioc_info(mrioc, "%s :failure at %s:%d/%s()!\n",
2931 fwevt->mrioc = mrioc;
2936 mpi3mr_fwevt_add_to_list(mrioc, fwevt);
2942 * @mrioc: Adapter instance reference
2952 static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
3109 * @mrioc: Adapter instance reference
3121 void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
3160 scsi_reply = mpi3mr_get_reply_virt_addr(mrioc,
3164 mrioc->name);
3176 sense_buf = mpi3mr_get_sensebuf_virt_addr(mrioc,
3183 panic("%s: Ran out of sense buffers\n", mrioc->name);
3192 scmd = mpi3mr_scmd_from_host_tag(mrioc, host_tag, qidx);
3195 mrioc->name, host_tag);
3210 if (unlikely((data_len_blks >= mrioc->io_throttle_data_length) &&
3213 &mrioc->pend_large_data_sz);
3218 mrioc->io_throttle_low) &&
3222 mrioc, tg, 0);
3225 if (ioc_pend_data_len <= mrioc->io_throttle_low)
3229 ioc_pend_data_len = atomic_read(&mrioc->pend_large_data_sz);
3231 if (ioc_pend_data_len <= mrioc->io_throttle_low)
3234 } else if (ioc_pend_data_len <= mrioc->io_throttle_low) {
3239 mrioc, tg, 0);
3333 mrioc->logging_level & MPI3_DEBUG_SCSI_ERROR) {
3334 ioc_info(mrioc, "%s :scmd->result 0x%x\n", __func__,
3337 ioc_info(mrioc,
3341 ioc_info(mrioc,
3346 ioc_info(mrioc,
3354 dma_unmap_sg(&mrioc->pdev->dev, scsi_prot_sglist(scmd),
3357 mpi3mr_clear_scmd_priv(mrioc, scmd);
3362 mpi3mr_repost_sense_buf(mrioc,
3368 * @mrioc: Adapter instance reference
3374 static int mpi3mr_get_chain_idx(struct mpi3mr_ioc *mrioc)
3380 spin_lock_irqsave(&mrioc->chain_buf_lock, flags);
3382 cmd_idx = find_first_zero_bit(mrioc->chain_bitmap,
3383 mrioc->chain_buf_count);
3384 if (cmd_idx < mrioc->chain_buf_count) {
3385 set_bit(cmd_idx, mrioc->chain_bitmap);
3390 spin_unlock_irqrestore(&mrioc->chain_buf_lock, flags);
3396 * @mrioc: Adapter instance reference
3406 static int mpi3mr_prepare_sg_scmd(struct mpi3mr_ioc *mrioc,
3444 sges_left = dma_map_sg(&mrioc->pdev->dev,
3460 if (sges_left > mrioc->max_sgl_entries) {
3467 sges_in_segment = (mrioc->facts.op_req_sz -
3499 chain_idx = mpi3mr_get_chain_idx(mrioc);
3502 chain_req = &mrioc->chain_sgl_list[chain_idx];
3537 * @mrioc: Adapter instance reference
3547 static int mpi3mr_build_sg_scmd(struct mpi3mr_ioc *mrioc,
3552 ret = mpi3mr_prepare_sg_scmd(mrioc, scmd, scsiio_req);
3560 ret = mpi3mr_prepare_sg_scmd(mrioc, scmd, scsiio_req);
3615 inline void mpi3mr_poll_pend_io_completions(struct mpi3mr_ioc *mrioc)
3619 mrioc->num_op_reply_q + mrioc->op_reply_q_offset;
3621 for (i = mrioc->op_reply_q_offset; i < num_of_reply_queues; i++)
3622 mpi3mr_process_op_reply_q(mrioc,
3623 mrioc->intr_info[i].op_reply_q);
3628 * @mrioc: Adapter instance reference
3645 int mpi3mr_issue_tm(struct mpi3mr_ioc *mrioc, u8 tm_type,
3659 ioc_info(mrioc, "%s :Issue TM: TM type (0x%x) for devhandle 0x%04x\n",
3661 if (mrioc->unrecoverable) {
3663 ioc_err(mrioc, "%s :Issue TM: Unrecoverable controller\n",
3672 ioc_err(mrioc, "%s :Issue TM: Command is in use\n", __func__);
3676 if (mrioc->reset_in_progress) {
3678 ioc_err(mrioc, "%s :Issue TM: Reset in progress\n", __func__);
3693 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle);
3717 retval = mpi3mr_admin_request_post(mrioc, &tm_req, sizeof(tm_req), 1);
3719 ioc_err(mrioc, "%s :Issue TM: Admin Post failed\n", __func__);
3728 dprint_tm(mrioc,
3731 if (mrioc->logging_level & MPI3_DEBUG_TM)
3733 mpi3mr_soft_reset_handler(mrioc,
3740 dprint_tm(mrioc, "invalid task management reply message\n");
3756 dprint_tm(mrioc,
3776 dprint_tm(mrioc,
3783 mpi3mr_ioc_disable_intr(mrioc);
3784 mpi3mr_poll_pend_io_completions(mrioc);
3785 mpi3mr_ioc_enable_intr(mrioc);
3786 mpi3mr_poll_pend_io_completions(mrioc);
3787 mpi3mr_process_admin_reply_q(mrioc);
3794 blk_mq_tagset_busy_iter(&mrioc->shost->tag_set,
3802 blk_mq_tagset_busy_iter(&mrioc->shost->tag_set,
3870 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3874 offset = mrioc->op_reply_q_offset;
3882 map->nr_queues = mrioc->default_qcount;
3884 map->nr_queues = mrioc->active_poll_qcount;
3897 blk_mq_pci_map_queues(map, mrioc->pdev, offset);
3908 * @mrioc: Adapter instance reference
3914 static inline int mpi3mr_get_fw_pending_ios(struct mpi3mr_ioc *mrioc)
3919 for (i = 0; i < mrioc->num_op_reply_q; i++)
3920 pend_ios += atomic_read(&mrioc->op_reply_qinfo[i].pend_ios);
3926 * @mrioc: Adapter instance reference
3933 static void mpi3mr_print_pending_host_io(struct mpi3mr_ioc *mrioc)
3935 struct Scsi_Host *shost = mrioc->shost;
3937 ioc_info(mrioc, "%s :Pending commands prior to reset: %d\n",
3938 __func__, mpi3mr_get_fw_pending_ios(mrioc));
3940 mpi3mr_print_scmd, (void *)mrioc);
3945 * @mrioc: Adapter instance reference
3952 void mpi3mr_wait_for_host_io(struct mpi3mr_ioc *mrioc, u32 timeout)
3957 iocstate = mpi3mr_get_iocstate(mrioc);
3961 if (!mpi3mr_get_fw_pending_ios(mrioc))
3963 ioc_info(mrioc,
3965 __func__, timeout, mpi3mr_get_fw_pending_ios(mrioc));
3968 if (!mpi3mr_get_fw_pending_ios(mrioc))
3970 iocstate = mpi3mr_get_iocstate(mrioc);
3976 ioc_info(mrioc, "%s :Pending I/Os after wait is: %d\n", __func__,
3977 mpi3mr_get_fw_pending_ios(mrioc));
3982 * @mrioc: Adapter instance reference
3994 static inline void mpi3mr_setup_divert_ws(struct mpi3mr_ioc *mrioc,
4035 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host);
4048 mpi3mr_wait_for_host_io(mrioc,
4050 if (!mpi3mr_get_fw_pending_ios(mrioc)) {
4056 mpi3mr_print_pending_host_io(mrioc);
4057 ret = mpi3mr_soft_reset_handler(mrioc,
4083 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host);
4108 mrioc->name, dev_handle);
4119 ret = mpi3mr_issue_tm(mrioc,
4122 MPI3MR_RESETTM_TIMEOUT, &mrioc->host_tm_cmds, &resp_code, scmd);
4130 mrioc->name, stgt_priv_data->pend_count);
4137 "%s: target reset is %s for scmd(%p)\n", mrioc->name,
4155 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host);
4180 mrioc->name, dev_handle);
4190 ret = mpi3mr_issue_tm(mrioc,
4193 MPI3MR_RESETTM_TIMEOUT, &mrioc->host_tm_cmds, &resp_code, scmd);
4201 mrioc->name, sdev_priv_data->pend_count);
4207 "%s: device(LUN) reset is %s for scmd(%p)\n", mrioc->name,
4223 struct mpi3mr_ioc *mrioc = shost_priv(shost);
4225 mrioc->scan_started = 1;
4226 ioc_info(mrioc, "%s :Issuing Port Enable\n", __func__);
4227 if (mpi3mr_issue_port_enable(mrioc, 1)) {
4228 ioc_err(mrioc, "%s :Issuing port enable failed\n", __func__);
4229 mrioc->scan_started = 0;
4230 mrioc->scan_failed = MPI3_IOCSTATUS_INTERNAL_ERROR;
4248 struct mpi3mr_ioc *mrioc = shost_priv(shost);
4250 u32 ioc_status = readl(&mrioc->sysif_regs->ioc_status);
4254 ioc_err(mrioc, "port enable failed due to fault or reset\n");
4255 mpi3mr_print_fault_info(mrioc);
4256 mrioc->scan_failed = MPI3_IOCSTATUS_INTERNAL_ERROR;
4257 mrioc->scan_started = 0;
4258 mrioc->init_cmds.is_waiting = 0;
4259 mrioc->init_cmds.callback = NULL;
4260 mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED;
4264 ioc_err(mrioc, "port enable failed due to time out\n");
4265 mpi3mr_check_rh_fault_ioc(mrioc,
4267 mrioc->scan_failed = MPI3_IOCSTATUS_INTERNAL_ERROR;
4268 mrioc->scan_started = 0;
4269 mrioc->init_cmds.is_waiting = 0;
4270 mrioc->init_cmds.callback = NULL;
4271 mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED;
4274 if (mrioc->scan_started)
4277 if (mrioc->scan_failed) {
4278 ioc_err(mrioc,
4280 mrioc->scan_failed);
4282 ioc_info(mrioc, "port enable is successfully completed\n");
4284 mpi3mr_start_watchdog(mrioc);
4285 mrioc->is_driver_loading = 0;
4286 mrioc->stop_bsgs = 0;
4301 struct mpi3mr_ioc *mrioc;
4313 mrioc = shost_priv(shost);
4318 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
4319 if (starget->channel == mrioc->scsi_device_channel)
4320 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id);
4321 else if (mrioc->sas_transport_enabled && !starget->channel) {
4323 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc,
4331 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
4348 struct mpi3mr_ioc *mrioc;
4357 mrioc = shost_priv(shost);
4360 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
4361 tgt_dev = __mpi3mr_get_tgtdev_from_tgtpriv(mrioc, scsi_tgt_priv_data);
4371 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
4390 struct mpi3mr_ioc *mrioc;
4398 mrioc = shost_priv(shost);
4400 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
4401 if (starget->channel == mrioc->scsi_device_channel)
4402 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id);
4403 else if (mrioc->sas_transport_enabled && !starget->channel) {
4405 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc,
4408 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
4453 struct mpi3mr_ioc *mrioc;
4464 mrioc = shost_priv(shost);
4467 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
4469 if (starget->channel == mrioc->scsi_device_channel)
4470 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id);
4471 else if (mrioc->sas_transport_enabled && !starget->channel) {
4473 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc,
4483 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
4487 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
4513 struct mpi3mr_ioc *mrioc = shost_priv(shost);
4526 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
4527 if (starget->channel == mrioc->scsi_device_channel) {
4528 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id);
4552 } else if (mrioc->sas_transport_enabled && !starget->channel) {
4554 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc,
4571 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
4578 * @mrioc: Adapter instance reference
4588 static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
4596 if (mrioc->pdev->revision) {
4599 dprint_scsi_command(mrioc, scmd, MPI3_DEBUG_SCSI_ERROR);
4600 dprint_scsi_err(mrioc,
4604 dprint_scsi_command(mrioc, scmd, MPI3_DEBUG_SCSI_ERROR);
4610 ioc_warn(mrioc,
4620 ioc_warn(mrioc,
4631 ioc_warn(mrioc,
4654 ioc_warn(mrioc,
4669 dprint_scsi_err(mrioc,
4715 struct mpi3mr_ioc *mrioc = shost_priv(shost);
4732 if (mrioc->unrecoverable) {
4745 if (mrioc->stop_drv_processing &&
4765 if (mrioc->reset_in_progress) {
4771 if (mrioc->stop_drv_processing) {
4794 (mrioc->pdev->device == MPI3_MFGPAGE_DEVID_SAS4116) &&
4795 mpi3mr_check_return_unmap(mrioc, scmd))
4798 host_tag = mpi3mr_host_tag_for_scmd(mrioc, scmd);
4829 mpi3mr_setup_eedp(mrioc, scmd, scsiio_req);
4832 mpi3mr_setup_divert_ws(mrioc, scmd, scsiio_req, &scsiio_flags,
4842 if (mpi3mr_build_sg_scmd(mrioc, scmd, scsiio_req)) {
4843 mpi3mr_clear_scmd_priv(mrioc, scmd);
4847 op_req_q = &mrioc->req_qinfo[scmd_priv_data->req_q_idx];
4849 if ((data_len_blks >= mrioc->io_throttle_data_length) &&
4855 &mrioc->pend_large_data_sz);
4859 mrioc->io_throttle_high) ||
4863 mpi3mr_set_io_divert_for_all_vd_in_tg(mrioc,
4865 mpi3mr_queue_qd_reduction_event(mrioc, tg);
4869 &mrioc->pend_large_data_sz);
4870 if (ioc_pend_data_len >= mrioc->io_throttle_high)
4882 if (mpi3mr_op_request_post(mrioc, op_req_q,
4884 mpi3mr_clear_scmd_priv(mrioc, scmd);
4887 atomic_sub(tracked_io_sz, &mrioc->pend_large_data_sz);
5040 struct mpi3mr_ioc *mrioc = NULL;
5056 mrioc = shost_priv(shost);
5057 mrioc->id = mrioc_ids++;
5058 sprintf(mrioc->driver_name, "%s", MPI3MR_DRIVER_NAME);
5059 sprintf(mrioc->name, "%s%d", mrioc->driver_name, mrioc->id);
5060 INIT_LIST_HEAD(&mrioc->list);
5062 list_add_tail(&mrioc->list, &mrioc_list);
5065 spin_lock_init(&mrioc->admin_req_lock);
5066 spin_lock_init(&mrioc->reply_free_queue_lock);
5067 spin_lock_init(&mrioc->sbq_lock);
5068 spin_lock_init(&mrioc->fwevt_lock);
5069 spin_lock_init(&mrioc->tgtdev_lock);
5070 spin_lock_init(&mrioc->watchdog_lock);
5071 spin_lock_init(&mrioc->chain_buf_lock);
5072 spin_lock_init(&mrioc->sas_node_lock);
5074 INIT_LIST_HEAD(&mrioc->fwevt_list);
5075 INIT_LIST_HEAD(&mrioc->tgtdev_list);
5076 INIT_LIST_HEAD(&mrioc->delayed_rmhs_list);
5077 INIT_LIST_HEAD(&mrioc->delayed_evtack_cmds_list);
5078 INIT_LIST_HEAD(&mrioc->sas_expander_list);
5079 INIT_LIST_HEAD(&mrioc->hba_port_table_list);
5080 INIT_LIST_HEAD(&mrioc->enclosure_list);
5082 mutex_init(&mrioc->reset_mutex);
5083 mpi3mr_init_drv_cmd(&mrioc->init_cmds, MPI3MR_HOSTTAG_INITCMDS);
5084 mpi3mr_init_drv_cmd(&mrioc->host_tm_cmds, MPI3MR_HOSTTAG_BLK_TMS);
5085 mpi3mr_init_drv_cmd(&mrioc->bsg_cmds, MPI3MR_HOSTTAG_BSG_CMDS);
5086 mpi3mr_init_drv_cmd(&mrioc->cfg_cmds, MPI3MR_HOSTTAG_CFG_CMDS);
5087 mpi3mr_init_drv_cmd(&mrioc->transport_cmds,
5091 mpi3mr_init_drv_cmd(&mrioc->dev_rmhs_cmds[i],
5095 mpi3mr_init_drv_cmd(&mrioc->evtack_cmds[i],
5100 mrioc->enable_segqueue = false;
5102 mrioc->enable_segqueue = true;
5104 init_waitqueue_head(&mrioc->reset_waitq);
5105 mrioc->logging_level = logging_level;
5106 mrioc->shost = shost;
5107 mrioc->pdev = pdev;
5108 mrioc->stop_bsgs = 1;
5110 mrioc->max_sgl_entries = max_sgl_entries;
5112 mrioc->max_sgl_entries = MPI3MR_MAX_SGL_ENTRIES;
5114 mrioc->max_sgl_entries = MPI3MR_DEFAULT_SGL_ENTRIES;
5116 mrioc->max_sgl_entries /= MPI3MR_DEFAULT_SGL_ENTRIES;
5117 mrioc->max_sgl_entries *= MPI3MR_DEFAULT_SGL_ENTRIES;
5123 shost->unique_id = mrioc->id;
5139 ioc_info(mrioc,
5155 snprintf(mrioc->fwevt_worker_name, sizeof(mrioc->fwevt_worker_name),
5156 "%s%d_fwevt_wrkr", mrioc->driver_name, mrioc->id);
5157 mrioc->fwevt_worker_thread = alloc_ordered_workqueue(
5158 mrioc->fwevt_worker_name, 0);
5159 if (!mrioc->fwevt_worker_thread) {
5160 ioc_err(mrioc, "failure at %s:%d/%s()!\n",
5166 mrioc->is_driver_loading = 1;
5167 mrioc->cpu_count = num_online_cpus();
5168 if (mpi3mr_setup_resources(mrioc)) {
5169 ioc_err(mrioc, "setup resources failed\n");
5173 if (mpi3mr_init_ioc(mrioc)) {
5174 ioc_err(mrioc, "initializing IOC failed\n");
5179 shost->nr_hw_queues = mrioc->num_op_reply_q;
5180 if (mrioc->active_poll_qcount)
5183 shost->can_queue = mrioc->max_host_ios;
5184 shost->sg_tablesize = mrioc->max_sgl_entries;
5185 shost->max_id = mrioc->facts.max_perids + 1;
5189 ioc_err(mrioc, "failure at %s:%d/%s()!\n",
5195 mpi3mr_bsg_init(mrioc);
5199 mpi3mr_stop_watchdog(mrioc);
5200 mpi3mr_cleanup_ioc(mrioc);
5202 mpi3mr_free_mem(mrioc);
5203 mpi3mr_cleanup_resources(mrioc);
5205 destroy_workqueue(mrioc->fwevt_worker_thread);
5208 list_del(&mrioc->list);
5228 struct mpi3mr_ioc *mrioc;
5238 mrioc = shost_priv(shost);
5239 while (mrioc->reset_in_progress || mrioc->is_driver_loading)
5242 if (!pci_device_is_present(mrioc->pdev)) {
5243 mrioc->unrecoverable = 1;
5244 mpi3mr_flush_cmds_for_unrecovered_controller(mrioc);
5247 mpi3mr_bsg_exit(mrioc);
5248 mrioc->stop_drv_processing = 1;
5249 mpi3mr_cleanup_fwevt_list(mrioc);
5250 spin_lock_irqsave(&mrioc->fwevt_lock, flags);
5251 wq = mrioc->fwevt_worker_thread;
5252 mrioc->fwevt_worker_thread = NULL;
5253 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
5257 if (mrioc->sas_transport_enabled)
5262 list_for_each_entry_safe(tgtdev, tgtdev_next, &mrioc->tgtdev_list,
5264 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev);
5265 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, true);
5268 mpi3mr_stop_watchdog(mrioc);
5269 mpi3mr_cleanup_ioc(mrioc);
5270 mpi3mr_free_mem(mrioc);
5271 mpi3mr_cleanup_resources(mrioc);
5273 spin_lock_irqsave(&mrioc->sas_node_lock, flags);
5275 &mrioc->sas_expander_list, list) {
5276 spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
5277 mpi3mr_expander_node_remove(mrioc, sas_expander);
5278 spin_lock_irqsave(&mrioc->sas_node_lock, flags);
5280 list_for_each_entry_safe(port, hba_port_next, &mrioc->hba_port_table_list, list) {
5281 ioc_info(mrioc,
5287 spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
5289 if (mrioc->sas_hba.num_phys) {
5290 kfree(mrioc->sas_hba.phy);
5291 mrioc->sas_hba.phy = NULL;
5292 mrioc->sas_hba.num_phys = 0;
5296 list_del(&mrioc->list);
5314 struct mpi3mr_ioc *mrioc;
5321 mrioc = shost_priv(shost);
5322 while (mrioc->reset_in_progress || mrioc->is_driver_loading)
5325 mrioc->stop_drv_processing = 1;
5326 mpi3mr_cleanup_fwevt_list(mrioc);
5327 spin_lock_irqsave(&mrioc->fwevt_lock, flags);
5328 wq = mrioc->fwevt_worker_thread;
5329 mrioc->fwevt_worker_thread = NULL;
5330 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
5334 mpi3mr_stop_watchdog(mrioc);
5335 mpi3mr_cleanup_ioc(mrioc);
5336 mpi3mr_cleanup_resources(mrioc);
5353 struct mpi3mr_ioc *mrioc;
5358 mrioc = shost_priv(shost);
5359 while (mrioc->reset_in_progress || mrioc->is_driver_loading)
5361 mrioc->stop_drv_processing = 1;
5362 mpi3mr_cleanup_fwevt_list(mrioc);
5364 mpi3mr_stop_watchdog(mrioc);
5365 mpi3mr_cleanup_ioc(mrioc);
5367 ioc_info(mrioc, "pdev=0x%p, slot=%s, entering operating state\n",
5369 mpi3mr_cleanup_resources(mrioc);
5388 struct mpi3mr_ioc *mrioc;
5395 mrioc = shost_priv(shost);
5397 ioc_info(mrioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
5399 mrioc->pdev = pdev;
5400 mrioc->cpu_count = num_online_cpus();
5401 r = mpi3mr_setup_resources(mrioc);
5403 ioc_info(mrioc, "%s: Setup resources failed[%d]\n",
5408 mrioc->stop_drv_processing = 0;
5409 mpi3mr_invalidate_devhandles(mrioc);
5410 mpi3mr_free_enclosure_list(mrioc);
5411 mpi3mr_memset_buffers(mrioc);
5412 r = mpi3mr_reinit_ioc(mrioc, 1);
5414 ioc_err(mrioc, "resuming controller failed[%d]\n", r);
5419 mrioc->device_refresh_on = 0;
5420 mpi3mr_start_watchdog(mrioc);