Lines Matching refs:ioc
66 static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
70 static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
72 static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
74 static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
75 static void _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
78 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
79 static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
80 static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc);
84 /* global ioc lock for list operations */
202 * @work: work object (ioc->fault_reset_work_q)
203 * @ioc: per adapter object
212 * This object stored on ioc->fw_event_list.
218 struct MPT3SAS_ADAPTER *ioc;
271 * @ioc_status: ioc status
304 * _scsih_set_debug_level - global setting of ioc->logging_level.
314 struct MPT3SAS_ADAPTER *ioc;
321 list_for_each_entry(ioc, &mpt3sas_ioc_list, list)
322 ioc->logging_level = logging_level;
377 * @ioc: per adapter object
386 mpt3sas_get_port_by_id(struct MPT3SAS_ADAPTER *ioc,
396 if (!ioc->multipath_on_hba)
400 &ioc->port_table_list, list) {
415 if (!ioc->multipath_on_hba) {
421 ioc_info(ioc,
425 &ioc->port_table_list);
433 * @ioc: per adapter object
440 mpt3sas_get_vphy_by_phy(struct MPT3SAS_ADAPTER *ioc,
502 * @ioc: ?
509 _scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle,
518 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
520 ioc_err(ioc, "failure at %s:%d/%s()!\n",
530 if ((handle <= ioc->sas_hba.num_phys) &&
533 *sas_address = ioc->sas_hba.sas_address;
544 ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
551 * @ioc: per adapter object
563 _scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc, void *device,
575 if (!ioc->is_driver_loading)
579 if (!ioc->bios_pg3.BiosVersion)
602 if (!ioc->req_boot_device.device) {
605 (ioc->bios_pg2.ReqBootDeviceForm &
607 &ioc->bios_pg2.RequestedBootDevice)) {
608 dinitprintk(ioc,
609 ioc_info(ioc, "%s: req_boot_device(0x%016llx)\n",
611 ioc->req_boot_device.device = device;
612 ioc->req_boot_device.channel = channel;
616 if (!ioc->req_alt_boot_device.device) {
619 (ioc->bios_pg2.ReqAltBootDeviceForm &
621 &ioc->bios_pg2.RequestedAltBootDevice)) {
622 dinitprintk(ioc,
623 ioc_info(ioc, "%s: req_alt_boot_device(0x%016llx)\n",
625 ioc->req_alt_boot_device.device = device;
626 ioc->req_alt_boot_device.channel = channel;
630 if (!ioc->current_boot_device.device) {
633 (ioc->bios_pg2.CurrentBootDeviceForm &
635 &ioc->bios_pg2.CurrentBootDevice)) {
636 dinitprintk(ioc,
637 ioc_info(ioc, "%s: current_boot_device(0x%016llx)\n",
639 ioc->current_boot_device.device = device;
640 ioc->current_boot_device.channel = channel;
646 __mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
651 assert_spin_locked(&ioc->sas_device_lock);
661 mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
667 spin_lock_irqsave(&ioc->sas_device_lock, flags);
668 ret = __mpt3sas_get_sdev_from_target(ioc, tgt_priv);
669 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
675 __mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc,
680 assert_spin_locked(&ioc->pcie_device_lock);
691 * @ioc: per adapter object
694 * Context: This function will acquire ioc->pcie_device_lock and will release
700 mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc,
706 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
707 ret = __mpt3sas_get_pdev_from_target(ioc, tgt_priv);
708 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
716 * @ioc: per adapter object
719 * Context: This function will acquire ioc->sas_device_lock and will release
726 __mpt3sas_get_sdev_by_rphy(struct MPT3SAS_ADAPTER *ioc,
731 assert_spin_locked(&ioc->sas_device_lock);
733 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
741 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) {
754 * @ioc: per adapter object
762 __mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
770 assert_spin_locked(&ioc->sas_device_lock);
772 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
781 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) {
795 * @ioc: per adapter object
798 * Context: Calling function should acquire ioc->sas_device_lock
804 mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
810 spin_lock_irqsave(&ioc->sas_device_lock, flags);
811 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
813 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
819 __mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
823 assert_spin_locked(&ioc->sas_device_lock);
825 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
829 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
842 * @ioc: per adapter object
844 * Context: Calling function should acquire ioc->sas_device_lock
850 mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
855 spin_lock_irqsave(&ioc->sas_device_lock, flags);
856 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
857 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
864 * @ioc: per adapter object
870 _scsih_display_enclosure_chassis_info(struct MPT3SAS_ADAPTER *ioc,
907 ioc_info(ioc, "enclosure logical id(0x%016llx), slot(%d)\n",
911 ioc_info(ioc, "enclosure level(0x%04x), connector name( %s)\n",
915 ioc_info(ioc, "chassis slot(0x%04x)\n",
922 * @ioc: per adapter object
924 * Context: This function will acquire ioc->sas_device_lock.
929 _scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc,
936 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
939 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
945 spin_lock_irqsave(&ioc->sas_device_lock, flags);
950 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
955 * @ioc: per adapter object
959 _scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
964 if (ioc->shost_recovery)
967 spin_lock_irqsave(&ioc->sas_device_lock, flags);
968 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
973 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
975 _scsih_remove_device(ioc, sas_device);
983 * @ioc: per adapter object
990 mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
996 if (ioc->shost_recovery)
999 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1000 sas_device = __mpt3sas_get_sdev_by_addr(ioc, sas_address, port);
1005 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1007 _scsih_remove_device(ioc, sas_device);
1014 * @ioc: per adapter object
1016 * Context: This function will acquire ioc->sas_device_lock.
1018 * Adding new object to the ioc->sas_device_list.
1021 _scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc,
1026 dewtprintk(ioc,
1027 ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
1031 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
1034 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1036 list_add_tail(&sas_device->list, &ioc->sas_device_list);
1037 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1039 if (ioc->hide_drives) {
1040 clear_bit(sas_device->handle, ioc->pend_os_device_add);
1044 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
1046 _scsih_sas_device_remove(ioc, sas_device);
1053 if (!ioc->is_driver_loading) {
1054 mpt3sas_transport_port_remove(ioc,
1058 _scsih_sas_device_remove(ioc, sas_device);
1061 clear_bit(sas_device->handle, ioc->pend_os_device_add);
1066 * @ioc: per adapter object
1068 * Context: This function will acquire ioc->sas_device_lock.
1070 * Adding new object at driver load time to the ioc->sas_device_init_list.
1073 _scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc,
1078 dewtprintk(ioc,
1079 ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
1083 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
1086 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1088 list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
1089 _scsih_determine_boot_device(ioc, sas_device, 0);
1090 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1095 __mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
1099 assert_spin_locked(&ioc->pcie_device_lock);
1101 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
1105 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
1119 * @ioc: per adapter object
1122 * Context: This function will acquire ioc->pcie_device_lock and will release
1128 mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
1133 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1134 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
1135 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1142 __mpt3sas_get_pdev_by_idchannel(struct MPT3SAS_ADAPTER *ioc, int id,
1147 assert_spin_locked(&ioc->pcie_device_lock);
1149 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
1153 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
1165 __mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1169 assert_spin_locked(&ioc->pcie_device_lock);
1171 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
1175 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
1189 * @ioc: per adapter object
1192 * Context: This function will acquire ioc->pcie_device_lock and will release
1199 mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1204 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1205 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
1206 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1213 * @ioc: per adapter object
1214 * Context: This function will acquire ioc->pcie_device_lock
1216 * Update ioc->max_shutdown_latency to that NVMe drives RTD3 Entry Latency
1221 _scsih_set_nvme_max_shutdown_latency(struct MPT3SAS_ADAPTER *ioc)
1227 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1228 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) {
1235 ioc->max_shutdown_latency = shutdown_latency;
1236 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1241 * @ioc: per adapter object
1243 * Context: This function will acquire ioc->pcie_device_lock.
1248 _scsih_pcie_device_remove(struct MPT3SAS_ADAPTER *ioc,
1257 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
1260 ioc_info(ioc, "removing enclosure logical id(0x%016llx), slot(%d)\n",
1264 ioc_info(ioc, "removing enclosure level(0x%04x), connector name( %s)\n",
1268 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1273 if (pcie_device->shutdown_latency == ioc->max_shutdown_latency)
1275 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1287 _scsih_set_nvme_max_shutdown_latency(ioc);
1293 * @ioc: per adapter object
1297 _scsih_pcie_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1304 if (ioc->shost_recovery)
1307 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1308 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
1315 if (pcie_device->shutdown_latency == ioc->max_shutdown_latency)
1318 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1320 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
1330 _scsih_set_nvme_max_shutdown_latency(ioc);
1335 * @ioc: per adapter object
1341 _scsih_pcie_device_add(struct MPT3SAS_ADAPTER *ioc,
1346 dewtprintk(ioc,
1347 ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
1351 dewtprintk(ioc,
1352 ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
1357 dewtprintk(ioc,
1358 ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
1362 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1364 list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
1365 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1369 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1372 if (scsi_add_device(ioc->shost, PCIE_CHANNEL, pcie_device->id, 0)) {
1373 _scsih_pcie_device_remove(ioc, pcie_device);
1375 if (!ioc->is_driver_loading) {
1377 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1380 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1385 * @ioc: per adapter object
1387 * Context: This function will acquire ioc->pcie_device_lock.
1389 * Adding new object at driver load time to the ioc->pcie_device_init_list.
1392 _scsih_pcie_device_init_add(struct MPT3SAS_ADAPTER *ioc,
1397 dewtprintk(ioc,
1398 ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
1402 dewtprintk(ioc,
1403 ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
1408 dewtprintk(ioc,
1409 ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
1413 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1415 list_add_tail(&pcie_device->list, &ioc->pcie_device_init_list);
1418 _scsih_determine_boot_device(ioc, pcie_device, PCIE_CHANNEL);
1419 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1423 * @ioc: per adapter object
1426 * Context: Calling function should acquire ioc->raid_device_lock
1432 _scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel)
1437 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1450 * @ioc: per adapter object
1452 * Context: Calling function should acquire ioc->raid_device_lock
1458 mpt3sas_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1463 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1476 * @ioc: per adapter object
1478 * Context: Calling function should acquire ioc->raid_device_lock
1484 _scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
1489 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1502 * @ioc: per adapter object
1508 _scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc,
1513 dewtprintk(ioc,
1514 ioc_info(ioc, "%s: handle(0x%04x), wwid(0x%016llx)\n",
1518 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1519 list_add_tail(&raid_device->list, &ioc->raid_device_list);
1520 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1525 * @ioc: per adapter object
1530 _scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc,
1535 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1538 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1543 * @ioc: per adapter object
1545 * Context: Calling function should acquire ioc->sas_device_lock
1551 mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1556 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1568 * @ioc: per adapter object
1570 * Context: Calling function should acquire ioc->sas_device_lock
1576 mpt3sas_scsih_enclosure_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1581 list_for_each_entry(enclosure_dev, &ioc->enclosure_list, list) {
1592 * @ioc: per adapter object
1595 * Context: Calling function should acquire ioc->sas_node_lock.
1601 mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
1609 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1623 * @ioc: per adapter object
1625 * Context: This function will acquire ioc->sas_node_lock.
1627 * Adding new object to the ioc->sas_expander_list.
1630 _scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc,
1635 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1636 list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
1637 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1681 * @ioc: per adapter object
1684 * Context: This function will acquire ioc->scsi_lookup_lock.
1690 _scsih_scsi_lookup_find_by_target(struct MPT3SAS_ADAPTER *ioc, int id,
1697 smid <= ioc->shost->can_queue; smid++) {
1698 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
1710 * @ioc: per adapter object
1714 * Context: This function will acquire ioc->scsi_lookup_lock.
1720 _scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id,
1726 for (smid = 1; smid <= ioc->shost->can_queue; smid++) {
1728 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
1741 * @ioc: per adapter object
1748 mpt3sas_scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
1756 smid <= ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT) {
1758 ioc->io_queue_num[tag] << BLK_MQ_UNIQUE_TAG_BITS | tag;
1760 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1771 scmd = scsi_host_find_tag(ioc->shost, unique_tag);
1793 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1805 if (ioc->enable_sdev_max_qd || ioc->is_gen35_ioc)
1817 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1818 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
1825 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1852 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1854 if (ioc->enable_sdev_max_qd)
1871 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1890 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1891 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1897 if (ioc->is_warpdrive)
1901 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1907 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1908 pcie_device = __mpt3sas_get_pdev_by_idchannel(ioc, starget->id,
1924 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1929 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1931 sas_device = __mpt3sas_get_sdev_by_rphy(ioc, rphy);
1941 if (test_bit(sas_device->handle, ioc->pd_handles))
1948 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1961 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1973 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1974 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1980 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1985 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1986 pcie_device = __mpt3sas_get_pdev_from_target(ioc,
2001 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2005 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2006 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
2021 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2039 struct MPT3SAS_ADAPTER *ioc;
2065 ioc = shost_priv(shost);
2067 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2068 raid_device = _scsih_raid_device_find_by_id(ioc,
2072 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2075 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2076 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc,
2087 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2090 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2091 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
2104 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2120 struct MPT3SAS_ADAPTER *ioc;
2133 ioc = shost_priv(shost);
2136 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2137 pcie_device = __mpt3sas_get_pdev_from_target(ioc,
2145 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2148 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2149 sas_device = __mpt3sas_get_sdev_from_target(ioc,
2156 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2165 * @ioc: per adapter object
2170 _scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc,
2179 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
2181 ioc_err(ioc, "failure at %s:%d/%s()!\n",
2189 ioc_err(ioc, "failure at %s:%d/%s()!\n",
2224 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
2226 if (ioc->is_warpdrive)
2247 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
2258 if (ioc->is_warpdrive)
2261 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2262 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
2268 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2273 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
2276 ioc_err(ioc, "failure at %s:%d/%s()!\n",
2289 switch (ioc->hba_mpi_version_belonged) {
2308 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
2317 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2318 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
2322 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2327 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
2330 ioc_err(ioc, "failure at %s:%d/%s()!\n",
2355 switch (ioc->hba_mpi_version_belonged) {
2368 * @ioc: ?
2373 _scsih_set_level(struct MPT3SAS_ADAPTER *ioc,
2393 switch (ioc->hba_mpi_version_belonged) {
2409 * @ioc: per adapter object
2415 _scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc,
2425 if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
2427 dfailprintk(ioc,
2428 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2437 dfailprintk(ioc,
2438 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2443 if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
2445 dfailprintk(ioc,
2446 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2457 if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
2460 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
2474 * @ioc: per adapter object
2482 _scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev)
2489 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
2511 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2535 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2536 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
2537 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2539 dfailprintk(ioc,
2540 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2545 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
2546 dfailprintk(ioc,
2547 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2555 mpt3sas_init_warpdrive_properties(ioc, raid_device);
2581 if (ioc->manu_pg10.OEMIdentifier &&
2582 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
2604 if (!ioc->hide_ir_msg)
2622 if (!ioc->is_warpdrive)
2623 _scsih_set_level(ioc, sdev, raid_device->volume_type);
2629 if (mpt3sas_config_get_volume_handle(ioc, handle,
2631 dfailprintk(ioc,
2632 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2636 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
2638 dfailprintk(ioc,
2639 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2647 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2648 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc,
2651 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2652 dfailprintk(ioc,
2653 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2658 qdepth = ioc->max_nvme_qd;
2681 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2689 lim->virt_boundary_mask = ioc->page_size - 1;
2693 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2694 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
2698 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2699 dfailprintk(ioc,
2700 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2709 ioc->max_wideport_qd : ioc->max_narrowport_qd;
2721 qdepth = ioc->max_sata_qd;
2737 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2740 _scsih_display_sata_capabilities(ioc, handle, sdev);
2747 _scsih_enable_tlr(ioc, sdev);
2801 * @ioc: per adapter object
2805 _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
2838 ioc_warn(ioc, "response_code(0x%01x): %s\n", response_code, desc);
2843 * @ioc: per adapter object
2855 _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2859 if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
2861 if (ioc->tm_cmds.smid != smid)
2863 ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
2864 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
2866 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2867 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
2869 ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
2870 complete(&ioc->tm_cmds.done);
2876 * @ioc: per adapter object
2882 mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2888 shost_for_each_device(sdev, ioc->shost) {
2897 ioc->ignore_loginfos = 1;
2904 * @ioc: per adapter object
2910 mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2916 shost_for_each_device(sdev, ioc->shost) {
2925 ioc->ignore_loginfos = 0;
2932 * @ioc: per adapter object
2943 scsih_tm_cmd_map_status(struct MPT3SAS_ADAPTER *ioc, uint channel,
2947 if (smid_task <= ioc->shost->can_queue) {
2950 if (!(_scsih_scsi_lookup_find_by_target(ioc,
2956 if (!(_scsih_scsi_lookup_find_by_lun(ioc, id,
2963 } else if (smid_task == ioc->scsih_cmds.smid) {
2964 if ((ioc->scsih_cmds.status & MPT3_CMD_COMPLETE) ||
2965 (ioc->scsih_cmds.status & MPT3_CMD_NOT_USED))
2967 } else if (smid_task == ioc->ctl_cmds.smid) {
2968 if ((ioc->ctl_cmds.status & MPT3_CMD_COMPLETE) ||
2969 (ioc->ctl_cmds.status & MPT3_CMD_NOT_USED))
2978 * @ioc: per adapter object
2994 scsih_tm_post_processing(struct MPT3SAS_ADAPTER *ioc, u16 handle,
2999 rc = scsih_tm_cmd_map_status(ioc, channel, id, lun, type, smid_task);
3003 ioc_info(ioc,
3013 mpt3sas_base_mask_interrupts(ioc);
3014 mpt3sas_base_sync_reply_irqs(ioc, 1);
3015 mpt3sas_base_unmask_interrupts(ioc);
3017 return scsih_tm_cmd_map_status(ioc, channel, id, lun, type, smid_task);
3022 * @ioc: per adapter struct
3036 * The callback index is set inside `ioc->tm_cb_idx`.
3042 mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel,
3054 lockdep_assert_held(&ioc->tm_cmds.mutex);
3056 if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
3057 ioc_info(ioc, "%s: tm_cmd busy!!!\n", __func__);
3061 if (ioc->shost_recovery || ioc->remove_host ||
3062 ioc->pci_error_recovery) {
3063 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
3067 ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
3069 dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
3070 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3075 mpt3sas_print_fault_code(ioc, ioc_state &
3077 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3081 mpt3sas_print_coredump_info(ioc, ioc_state &
3083 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3087 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
3089 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
3093 dtmprintk(ioc,
3094 ioc_info(ioc, "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n",
3096 ioc->tm_cmds.status = MPT3_CMD_PENDING;
3097 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3098 ioc->tm_cmds.smid = smid;
3100 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
3109 mpt3sas_scsih_set_tm_flag(ioc, handle);
3110 init_completion(&ioc->tm_cmds.done);
3111 ioc->put_smid_hi_priority(ioc, smid, msix_task);
3112 wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
3113 if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
3114 mpt3sas_check_cmd_timeout(ioc,
3115 ioc->tm_cmds.status, mpi_request,
3118 rc = mpt3sas_base_hard_reset_handler(ioc,
3126 mpt3sas_base_sync_reply_irqs(ioc, 0);
3128 if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
3129 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
3130 mpi_reply = ioc->tm_cmds.reply;
3131 dtmprintk(ioc,
3132 ioc_info(ioc, "complete tm: ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
3136 if (ioc->logging_level & MPT_DEBUG_TM) {
3137 _scsih_response_code(ioc, mpi_reply->ResponseCode);
3158 request = mpt3sas_base_get_msg_frame(ioc, smid_task);
3162 ioc_info(ioc, "Task abort tm failed: handle(0x%04x),"
3171 rc = scsih_tm_post_processing(ioc, handle, channel, id, lun,
3183 mpt3sas_scsih_clear_tm_flag(ioc, handle);
3184 ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
3188 int mpt3sas_scsih_issue_locked_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle,
3194 mutex_lock(&ioc->tm_cmds.mutex);
3195 ret = mpt3sas_scsih_issue_tm(ioc, handle, channel, id, lun, type,
3197 mutex_unlock(&ioc->tm_cmds.mutex);
3204 * @ioc: per adapter struct
3210 _scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
3221 if (ioc->hide_ir_msg)
3234 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
3235 pcie_device = __mpt3sas_get_pdev_from_target(ioc, priv_target);
3255 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
3258 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3259 sas_device = __mpt3sas_get_sdev_from_target(ioc, priv_target);
3280 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3293 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3305 _scsih_tm_display_info(ioc, scmd);
3309 ioc->remove_host) {
3336 mpt3sas_halt_firmware(ioc);
3339 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3340 if (pcie_device && (!ioc->tm_custom_handling) &&
3342 timeout = ioc->nvme_abort_timeout;
3343 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel,
3367 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3381 _scsih_tm_display_info(ioc, scmd);
3385 ioc->remove_host) {
3398 sas_device = mpt3sas_get_sdev_from_target(ioc,
3411 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3413 if (pcie_device && (!ioc->tm_custom_handling) &&
3420 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel,
3448 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3461 _scsih_tm_display_info(ioc, scmd);
3465 ioc->remove_host) {
3478 sas_device = mpt3sas_get_sdev_from_target(ioc,
3491 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3493 if (pcie_device && (!ioc->tm_custom_handling) &&
3499 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel,
3527 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3530 ioc_info(ioc, "attempting host reset! scmd(0x%p)\n", scmd);
3533 if (ioc->is_driver_loading || ioc->remove_host) {
3534 ioc_info(ioc, "Blocking the host reset\n");
3539 retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3542 ioc_info(ioc, "host reset: %s scmd(0x%p)\n",
3550 * @ioc: per adapter object
3552 * Context: This function will acquire ioc->fw_event_lock.
3558 _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
3562 if (ioc->firmware_event_thread == NULL)
3565 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3568 list_add_tail(&fw_event->list, &ioc->fw_event_list);
3571 queue_work(ioc->firmware_event_thread, &fw_event->work);
3572 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3577 * @ioc: per adapter object
3579 * Context: This function will acquire ioc->fw_event_lock.
3584 _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
3589 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3594 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3600 * @ioc: per adapter object
3604 mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
3610 if (ioc->is_driver_loading)
3617 fw_event->ioc = ioc;
3619 _scsih_fw_event_add(ioc, fw_event);
3625 * @ioc: per adapter object
3628 _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
3636 fw_event->ioc = ioc;
3637 _scsih_fw_event_add(ioc, fw_event);
3643 * @ioc: per adapter object
3646 mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
3654 fw_event->ioc = ioc;
3655 _scsih_fw_event_add(ioc, fw_event);
3659 static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc)
3664 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3665 if (!list_empty(&ioc->fw_event_list)) {
3666 fw_event = list_first_entry(&ioc->fw_event_list,
3671 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3678 * @ioc: per adapter object
3686 _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
3690 if ((list_empty(&ioc->fw_event_list) && !ioc->current_event) ||
3691 !ioc->firmware_event_thread)
3699 if (ioc->shost_recovery && ioc->current_event)
3700 ioc->current_event->ignore = 1;
3702 ioc->fw_events_cleanup = 1;
3703 while ((fw_event = dequeue_next_fw_event(ioc)) ||
3704 (fw_event = ioc->current_event)) {
3720 if (fw_event == ioc->current_event &&
3721 ioc->current_event->event !=
3723 ioc->current_event = NULL;
3728 * Driver has to clear ioc->start_scan flag when
3736 ioc->port_enable_cmds.status |= MPT3_CMD_RESET;
3737 ioc->start_scan = 0;
3752 ioc->fw_events_cleanup = 0;
3826 * @ioc: per adapter object
3831 _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3836 shost_for_each_device(sdev, ioc->shost) {
3843 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3853 * @ioc: per adapter object
3860 _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc,
3866 shost_for_each_device(sdev, ioc->shost) {
3883 * @ioc: per adapter object
3888 _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3893 shost_for_each_device(sdev, ioc->shost) {
3911 * @ioc: per adapter object
3917 _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3923 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
3925 shost_for_each_device(sdev, ioc->shost) {
3950 * @ioc: per adapter object
3958 _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
3973 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3974 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
3979 ioc->blocking_handles);
3982 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3995 ioc, mpt3sas_port->remote_identify.sas_address,
3997 _scsih_block_io_to_children_attached_to_ex(ioc,
4005 * @ioc: per adapter object
4012 _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
4026 _scsih_block_io_device(ioc, handle);
4032 * @ioc: per adapter object
4039 _scsih_block_io_to_pcie_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
4054 _scsih_block_io_device(ioc, handle);
4059 * @ioc: per adapter object
4073 _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4087 if (ioc->pci_error_recovery) {
4088 dewtprintk(ioc,
4089 ioc_info(ioc, "%s: host in pci error recovery: handle(0x%04x)\n",
4093 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4095 dewtprintk(ioc,
4096 ioc_info(ioc, "%s: host is not operational: handle(0x%04x)\n",
4102 if (test_bit(handle, ioc->pd_handles))
4105 clear_bit(handle, ioc->pend_os_device_add);
4107 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4108 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
4116 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4118 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
4119 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
4126 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
4127 if (pcie_device && (!ioc->tm_custom_handling) &&
4136 dewtprintk(ioc,
4137 ioc_info(ioc, "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
4141 dewtprintk(ioc,
4142 ioc_info(ioc, "setting delete flag:enclosure logical id(0x%016llx), slot(%d)\n",
4146 dewtprintk(ioc,
4147 ioc_info(ioc, "setting delete flag: enclosure level(0x%04x), connector name( %s)\n",
4152 dewtprintk(ioc,
4153 ioc_info(ioc, "setting delete flag: logical id(0x%016llx), slot(%d)\n",
4157 dewtprintk(ioc,
4158 ioc_info(ioc, "setting delete flag:, enclosure level(0x%04x), connector name( %s)\n",
4162 _scsih_ublock_io_device(ioc, sas_address, port);
4166 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
4173 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
4174 dewtprintk(ioc,
4175 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4180 dewtprintk(ioc,
4181 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4182 handle, smid, ioc->tm_tr_cb_idx));
4183 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4189 set_bit(handle, ioc->device_remove_in_progress);
4190 ioc->put_smid_hi_priority(ioc, smid, 0);
4191 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
4202 * @ioc: per adapter object
4217 _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
4223 mpt3sas_base_get_reply_virt_addr(ioc, reply);
4229 if (ioc->pci_error_recovery) {
4230 dewtprintk(ioc,
4231 ioc_info(ioc, "%s: host in pci error recovery\n",
4235 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4237 dewtprintk(ioc,
4238 ioc_info(ioc, "%s: host is not operational\n",
4243 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
4247 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
4250 dewtprintk(ioc,
4251 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
4257 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
4258 dewtprintk(ioc,
4259 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
4264 smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
4268 return _scsih_check_for_pending_tm(ioc, smid);
4271 list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list);
4272 dewtprintk(ioc,
4273 ioc_info(ioc, "DELAYED:sc:handle(0x%04x), (open)\n",
4275 return _scsih_check_for_pending_tm(ioc, smid);
4278 dewtprintk(ioc,
4279 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4280 handle, smid_sas_ctrl, ioc->tm_sas_control_cb_idx));
4281 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
4286 ioc->put_smid_default(ioc, smid_sas_ctrl);
4288 return _scsih_check_for_pending_tm(ioc, smid);
4293 * @ioc: per adapter object
4298 inline bool _scsih_allow_scmd_to_device(struct MPT3SAS_ADAPTER *ioc,
4302 if (ioc->pci_error_recovery)
4305 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) {
4306 if (ioc->remove_host)
4312 if (ioc->remove_host) {
4328 * @ioc: per adapter object
4342 _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
4346 mpt3sas_base_get_reply_virt_addr(ioc, reply);
4349 dewtprintk(ioc,
4350 ioc_info(ioc, "sc_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
4357 ioc->device_remove_in_progress);
4360 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
4363 return mpt3sas_check_for_pending_internal_cmds(ioc, smid);
4368 * @ioc: per adapter object
4377 _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4383 if (ioc->pci_error_recovery) {
4384 dewtprintk(ioc,
4385 ioc_info(ioc, "%s: host reset in progress!\n",
4390 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
4397 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
4398 dewtprintk(ioc,
4399 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4404 dewtprintk(ioc,
4405 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4406 handle, smid, ioc->tm_tr_volume_cb_idx));
4407 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4412 ioc->put_smid_hi_priority(ioc, smid, 0);
4417 * @ioc: per adapter object
4427 _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
4433 mpt3sas_base_get_reply_virt_addr(ioc, reply);
4435 if (ioc->shost_recovery || ioc->pci_error_recovery) {
4436 dewtprintk(ioc,
4437 ioc_info(ioc, "%s: host reset in progress!\n",
4442 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
4447 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
4450 dewtprintk(ioc,
4451 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
4457 dewtprintk(ioc,
4458 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
4463 return _scsih_check_for_pending_tm(ioc, smid);
4468 * @ioc: per adapter object
4476 _scsih_issue_delayed_event_ack(struct MPT3SAS_ADAPTER *ioc, u16 smid, U16 event,
4480 int i = smid - ioc->internal_smid;
4487 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4488 ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx;
4489 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4491 dewtprintk(ioc,
4492 ioc_info(ioc, "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n",
4493 le16_to_cpu(event), smid, ioc->base_cb_idx));
4494 ack_request = mpt3sas_base_get_msg_frame(ioc, smid);
4501 ioc->put_smid_default(ioc, smid);
4507 * @ioc: per adapter object
4514 _scsih_issue_delayed_sas_io_unit_ctrl(struct MPT3SAS_ADAPTER *ioc,
4519 int i = smid - ioc->internal_smid;
4522 if (ioc->remove_host) {
4523 dewtprintk(ioc,
4524 ioc_info(ioc, "%s: host has been removed\n",
4527 } else if (ioc->pci_error_recovery) {
4528 dewtprintk(ioc,
4529 ioc_info(ioc, "%s: host in pci error recovery\n",
4533 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4535 dewtprintk(ioc,
4536 ioc_info(ioc, "%s: host is not operational\n",
4545 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4546 ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx;
4547 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4549 dewtprintk(ioc,
4550 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4551 handle, smid, ioc->tm_sas_control_cb_idx));
4552 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4557 ioc->put_smid_default(ioc, smid);
4562 * @ioc: per adapter object
4574 mpt3sas_check_for_pending_internal_cmds(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4579 if (!list_empty(&ioc->delayed_event_ack_list)) {
4580 delayed_event_ack = list_entry(ioc->delayed_event_ack_list.next,
4582 _scsih_issue_delayed_event_ack(ioc, smid,
4589 if (!list_empty(&ioc->delayed_sc_list)) {
4590 delayed_sc = list_entry(ioc->delayed_sc_list.next,
4592 _scsih_issue_delayed_sas_io_unit_ctrl(ioc, smid,
4603 * @ioc: per adapter object
4613 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4617 if (!list_empty(&ioc->delayed_tr_volume_list)) {
4618 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
4620 mpt3sas_base_free_smid(ioc, smid);
4621 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
4627 if (!list_empty(&ioc->delayed_tr_list)) {
4628 delayed_tr = list_entry(ioc->delayed_tr_list.next,
4630 mpt3sas_base_free_smid(ioc, smid);
4631 _scsih_tm_tr_send(ioc, delayed_tr->handle);
4642 * @ioc: per adapter object
4652 _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
4670 _scsih_tm_tr_send(ioc, handle);
4674 if (expander_handle < ioc->sas_hba.num_phys) {
4675 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4681 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4682 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
4684 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
4685 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4687 handle = find_first_bit(ioc->blocking_handles,
4688 ioc->facts.MaxDevHandle);
4689 if (handle < ioc->facts.MaxDevHandle)
4690 _scsih_block_io_device(ioc, handle);
4691 } while (test_and_clear_bit(handle, ioc->blocking_handles));
4693 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4699 spin_lock_irqsave(&ioc->fw_event_lock, flags);
4700 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4712 dewtprintk(ioc,
4713 ioc_info(ioc, "setting ignoring flag\n"));
4718 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4724 * @ioc: per adapter object
4733 _scsih_check_pcie_topo_remove_events(struct MPT3SAS_ADAPTER *ioc,
4749 _scsih_tm_tr_send(ioc, handle);
4755 ioc, event_data);
4764 ioc, event_data);
4770 spin_lock_irqsave(&ioc->fw_event_lock, flags);
4771 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4784 dewtprintk(ioc,
4785 ioc_info(ioc, "setting ignoring flag for switch event\n"));
4790 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4795 * @ioc: per adapter object
4801 _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4807 spin_lock_irqsave(&ioc->raid_device_lock, flags);
4808 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
4814 dewtprintk(ioc,
4815 ioc_info(ioc, "setting delete flag: handle(0x%04x), wwid(0x%016llx)\n",
4818 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4844 * @ioc: per adapter object
4855 _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
4866 if (ioc->is_warpdrive)
4880 _scsih_set_volume_delete_flag(ioc, volume_handle);
4898 _scsih_tm_tr_volume_send(ioc, a);
4900 _scsih_tm_tr_volume_send(ioc, b);
4909 clear_bit(handle, ioc->pd_handles);
4911 _scsih_tm_tr_send(ioc, handle);
4917 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
4918 dewtprintk(ioc,
4919 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4922 _scsih_tm_tr_send(ioc, handle);
4929 * @ioc: per adapter object
4938 _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
4948 _scsih_set_volume_delete_flag(ioc,
4954 * @ioc: per adapter object
4959 _scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
4963 if (ioc->temp_sensors_count >= event_data->SensorNum) {
4964 ioc_err(ioc, "Temperature Threshold flags %s%s%s%s exceeded for Sensor: %d !!!\n",
4970 ioc_err(ioc, "Current Temp In Celsius: %d\n",
4972 if (ioc->hba_mpi_version_belonged != MPI2_VERSION) {
4973 doorbell = mpt3sas_base_get_iocstate(ioc, 0);
4976 mpt3sas_print_fault_code(ioc,
4980 mpt3sas_print_coredump_info(ioc,
5003 * @ioc: per adapter object
5009 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
5016 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5017 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
5023 mpt3sas_base_clear_st(ioc, st);
5025 if (ioc->pci_error_recovery || ioc->remove_host)
5031 dtmprintk(ioc, ioc_info(ioc, "completing %d cmds\n", count));
5036 * @ioc: per adapter object
5043 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
5076 if (ioc->is_gen35_ioc)
5084 * @ioc_status: ioc status
5114 * The callback index is set inside `ioc->scsi_io_cb_idx`.
5123 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
5135 if (ioc->logging_level & MPT_DEBUG_SCSI)
5145 if (!(_scsih_allow_scmd_to_device(ioc, scmd))) {
5175 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) {
5217 if (((!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev))
5222 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
5224 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
5228 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5229 memset(mpi_request, 0, ioc->request_sz);
5230 _scsih_setup_eedp(ioc, scmd, mpi_request);
5247 mpt3sas_base_get_sense_buffer_dma(ioc, smid);
5255 if (ioc->build_sg_scmd(ioc, scmd, smid, pcie_device)) {
5256 mpt3sas_base_free_smid(ioc, smid);
5261 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
5265 mpt3sas_setup_direct_io(ioc, scmd,
5272 ioc->put_smid_fast_path(ioc, smid, handle);
5274 ioc->put_smid_scsi_io(ioc, smid,
5277 ioc->put_smid_default(ioc, smid);
5307 * @ioc: per adapter object
5313 * scsi_state - state info associated with SCSI_IO determined by ioc
5314 * ioc_status - ioc supplied status info
5317 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
5328 char *desc_scsi_state = ioc->tmp_string;
5338 if (ioc->hide_ir_msg)
5384 desc_ioc_state = "scsi ioc terminated";
5462 ioc_warn(ioc, "\t%s wwid(0x%016llx)\n",
5465 pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target);
5467 ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n",
5470 ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n",
5474 ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n",
5480 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
5482 ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
5485 _scsih_display_enclosure_chassis_info(ioc, sas_device,
5492 ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
5495 ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n",
5497 ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
5500 ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
5506 ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
5513 _scsih_response_code(ioc, response_bytes[0]);
5519 * @ioc: per adapter object
5524 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5530 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
5541 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5543 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5550 dewtprintk(ioc,
5551 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5562 * @ioc: per adapter object
5567 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
5581 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5583 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5589 dewtprintk(ioc,
5590 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5599 * @ioc: per adapter object
5604 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5613 fw_event->ioc = ioc;
5614 _scsih_fw_event_add(ioc, fw_event);
5620 * @ioc: per adapter object
5625 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5636 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5637 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
5650 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5652 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
5653 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
5660 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5677 mpt3sas_ctl_add_to_event_log(ioc, event_reply);
5685 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5691 * @ioc: per adapter object
5702 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5716 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
5718 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
5724 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5752 ioc->put_smid_scsi_io(ioc, smid,
5763 if ((!ioc->is_warpdrive &&
5791 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
5799 _scsih_smart_predicted_fault(ioc,
5801 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
5803 if ((ioc->logging_level & MPT_DEBUG_REPLY) &&
5807 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid);
5917 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
5918 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
5923 mpt3sas_base_free_smid(ioc, smid);
5931 * @ioc: per adapter object
5936 _scsih_update_vphys_after_reset(struct MPT3SAS_ADAPTER *ioc)
5954 &ioc->port_table_list, list) {
5966 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
5969 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5973 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
5982 for (i = 0; i < ioc->sas_hba.num_phys; i++) {
6001 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
6003 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6016 if (_scsih_get_sas_address(ioc, attached_handle,
6018 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6030 port_next, &ioc->port_table_list, list) {
6063 mport = mpt3sas_get_port_by_id(ioc, port_id, 1);
6070 ioc_info(ioc,
6074 &ioc->port_table_list);
6092 ioc, attached_sas_addr, port);
6127 * @ioc: per adapter object
6133 _scsih_get_port_table_after_reset(struct MPT3SAS_ADAPTER *ioc,
6144 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
6147 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6152 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
6158 for (i = 0; i < ioc->sas_hba.num_phys; i++) {
6166 ioc, attached_handle, &attached_sas_addr) != 0) {
6167 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6207 * @ioc: per adapter object
6216 _scsih_look_and_get_matched_port_entry(struct MPT3SAS_ADAPTER *ioc,
6225 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) {
6275 *@ioc: per adapter object
6283 _scsih_del_phy_part_of_anther_port(struct MPT3SAS_ADAPTER *ioc,
6287 struct _sas_node *sas_node = &ioc->sas_hba;
6296 ioc, sas_node, &sas_node->phy[offset]);
6308 *@ioc: per adapter object
6316 _scsih_add_or_del_phys_from_existing_port(struct MPT3SAS_ADAPTER *ioc,
6321 struct _sas_node *sas_node = &ioc->sas_hba;
6325 for (offset = 0; offset < ioc->sas_hba.num_phys; offset++) {
6329 ioc, port_table, index, port_count,
6335 ioc, sas_node, &sas_node->phy[offset]);
6337 ioc, sas_node, &sas_node->phy[offset],
6346 * @ioc: per adapter object
6351 _scsih_del_dirty_vphy(struct MPT3SAS_ADAPTER *ioc)
6357 &ioc->port_table_list, list) {
6363 drsprintk(ioc, ioc_info(ioc,
6380 *@ioc: per adapter object
6384 _scsih_del_dirty_port_entries(struct MPT3SAS_ADAPTER *ioc)
6389 &ioc->port_table_list, list) {
6394 drsprintk(ioc, ioc_info(ioc,
6404 * @ioc: per adapter object
6407 _scsih_sas_port_refresh(struct MPT3SAS_ADAPTER *ioc)
6418 drsprintk(ioc, ioc_info(ioc,
6420 (unsigned long long)ioc->sas_hba.sas_address));
6422 mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
6424 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6429 if (num_phys > ioc->sas_hba.nr_phys_allocated) {
6430 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6434 ioc->sas_hba.num_phys = num_phys;
6436 port_table = kcalloc(ioc->sas_hba.num_phys,
6441 port_count = _scsih_get_port_table_after_reset(ioc, port_table);
6445 drsprintk(ioc, ioc_info(ioc, "New Port table\n"));
6447 drsprintk(ioc, ioc_info(ioc,
6452 list_for_each_entry(port_table_entry, &ioc->port_table_list, list)
6455 drsprintk(ioc, ioc_info(ioc, "Old Port table\n"));
6457 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) {
6458 drsprintk(ioc, ioc_info(ioc,
6466 ret = _scsih_look_and_get_matched_port_entry(ioc,
6469 drsprintk(ioc, ioc_info(ioc,
6479 _scsih_add_or_del_phys_from_existing_port(ioc,
6492 _scsih_add_or_del_phys_from_existing_port(ioc,
6510 * @ioc: per adapter object
6517 _scsih_alloc_vphy(struct MPT3SAS_ADAPTER *ioc, u8 port_id, u8 phy_num)
6522 port = mpt3sas_get_port_by_id(ioc, port_id, 0);
6526 vphy = mpt3sas_get_vphy_by_phy(ioc, port, phy_num);
6544 ioc_info(ioc,
6553 * @ioc: per adapter object
6561 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
6573 dtmprintk(ioc,
6574 ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n",
6575 (u64)ioc->sas_hba.sas_address));
6577 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
6580 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6585 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
6591 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
6594 ioc->sas_hba.handle = le16_to_cpu(
6597 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) {
6603 ioc_info(ioc,
6606 if (ioc->shost_recovery)
6608 list_add_tail(&port->list, &ioc->port_table_list);
6616 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply,
6618 ioc_err(ioc,
6630 if (!_scsih_alloc_vphy(ioc, port_id, i))
6632 ioc->sas_hba.phy[i].hba_vphy = 1;
6639 if (!ioc->sas_hba.phy[i].phy) {
6640 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply,
6642 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6649 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6653 ioc->sas_hba.phy[i].phy_id = i;
6654 mpt3sas_transport_add_host_phy(ioc,
6655 &ioc->sas_hba.phy[i], phy_pg0,
6656 ioc->sas_hba.parent_dev);
6659 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
6664 ioc->sas_hba.phy[i].port =
6665 mpt3sas_get_port_by_id(ioc, port_id, 0);
6666 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
6668 ioc->sas_hba.phy[i].port);
6674 for (i = ioc->sas_hba.num_phys;
6675 i < ioc->sas_hba.nr_phys_allocated; i++) {
6676 if (ioc->sas_hba.phy[i].phy &&
6677 ioc->sas_hba.phy[i].phy->negotiated_linkrate >=
6679 mpt3sas_transport_update_links(ioc,
6680 ioc->sas_hba.sas_address, 0, i,
6689 * @ioc: per adapter object
6691 * Creating host side data object, stored in ioc->sas_hba
6694 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
6709 mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
6711 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6716 ioc->sas_hba.nr_phys_allocated = max_t(u8,
6718 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.nr_phys_allocated,
6720 if (!ioc->sas_hba.phy) {
6721 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6725 ioc->sas_hba.num_phys = num_phys;
6728 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
6731 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6735 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
6737 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6744 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6750 sz = struct_size(sas_iounit_pg1, PhyData, ioc->sas_hba.num_phys);
6753 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6757 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
6759 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6766 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6771 ioc->io_missing_delay =
6776 ioc->device_missing_delay = (device_missing_delay &
6779 ioc->device_missing_delay = device_missing_delay &
6782 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
6783 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
6784 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
6786 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6793 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6799 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
6803 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) {
6809 ioc_info(ioc,
6813 &ioc->port_table_list);
6826 if (!_scsih_alloc_vphy(ioc, port_id, i))
6828 ioc->sas_hba.phy[i].hba_vphy = 1;
6831 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
6832 ioc->sas_hba.phy[i].phy_id = i;
6833 ioc->sas_hba.phy[i].port =
6834 mpt3sas_get_port_by_id(ioc, port_id, 0);
6835 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
6836 phy_pg0, ioc->sas_hba.parent_dev);
6838 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6839 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
6840 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6844 ioc->sas_hba.enclosure_handle =
6846 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
6847 ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
6848 ioc->sas_hba.handle,
6849 (u64)ioc->sas_hba.sas_address,
6850 ioc->sas_hba.num_phys);
6852 if (ioc->sas_hba.enclosure_handle) {
6853 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
6855 ioc->sas_hba.enclosure_handle)))
6856 ioc->sas_hba.enclosure_logical_id =
6867 * @ioc: per adapter object
6870 * Creating expander object, stored in ioc->sas_expander_list.
6875 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6895 if (ioc->shost_recovery || ioc->pci_error_recovery)
6898 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
6900 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6908 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6915 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
6917 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6923 if (sas_address_parent != ioc->sas_hba.sas_address) {
6924 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6925 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
6927 mpt3sas_get_port_by_id(ioc, port_id, 0));
6928 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6930 rc = _scsih_expander_add(ioc, parent_handle);
6936 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6938 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
6939 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0));
6940 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6948 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6957 sas_expander->port = mpt3sas_get_port_by_id(ioc, port_id, 0);
6959 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6965 ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
6976 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6983 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
6986 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6995 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
6997 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7005 mpt3sas_get_port_by_id(ioc, port_id, 0);
7007 if ((mpt3sas_transport_add_expander_phy(ioc,
7010 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7019 mpt3sas_scsih_enclosure_find_by_handle(ioc,
7026 _scsih_expander_node_add(ioc, sas_expander);
7032 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
7040 * @ioc: per adapter object
7045 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
7051 if (ioc->shost_recovery)
7057 spin_lock_irqsave(&ioc->sas_node_lock, flags);
7058 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
7060 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7062 _scsih_expander_node_remove(ioc, sas_expander);
7067 * @ioc: per adapter object
7073 * The callback index passed is `ioc->scsih_cb_idx`
7079 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
7083 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
7084 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
7086 if (ioc->scsih_cmds.smid != smid)
7088 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
7090 memcpy(ioc->scsih_cmds.reply, mpi_reply,
7092 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
7094 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
7095 complete(&ioc->scsih_cmds.done);
7107 * @ioc: per adapter object
7115 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
7163 ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
7170 * @ioc: per adapter object
7177 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
7192 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
7211 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7213 port = mpt3sas_get_port_by_id(ioc, sas_device_pg0.PhysicalPort, 0);
7216 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
7245 enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle(ioc,
7262 ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n",
7268 if (_scsih_check_access_status(ioc, sas_address, handle,
7272 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7273 _scsih_ublock_io_device(ioc, sas_address, port);
7280 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7287 * @ioc: per adapter object
7292 * Creating end device object, stored in ioc->sas_device_list.
7297 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
7309 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
7311 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7319 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7328 set_bit(handle, ioc->pend_os_device_add);
7334 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
7340 if (_scsih_check_access_status(ioc, sas_address, handle,
7345 sas_device = mpt3sas_get_sdev_by_addr(ioc,
7346 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0));
7348 clear_bit(handle, ioc->pend_os_device_add);
7355 mpt3sas_scsih_enclosure_find_by_handle(ioc,
7358 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
7365 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7372 if (_scsih_get_sas_address(ioc,
7375 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7387 sas_device->port = mpt3sas_get_port_by_id(ioc, port_id, 0);
7389 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7421 ioc_info(ioc,
7425 if (ioc->wait_for_discovery_to_complete)
7426 _scsih_sas_device_init_add(ioc, sas_device);
7428 _scsih_sas_device_add(ioc, sas_device);
7437 * @ioc: per adapter object
7441 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
7446 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
7448 _scsih_turn_off_pfa_led(ioc, sas_device);
7452 dewtprintk(ioc,
7453 ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
7457 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
7463 _scsih_ublock_io_device(ioc, sas_device->sas_address,
7469 if (!ioc->hide_drives)
7470 mpt3sas_transport_port_remove(ioc,
7475 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
7478 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
7480 dewtprintk(ioc,
7481 ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
7484 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
7490 * @ioc: per adapter object
7495 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7523 ioc_info(ioc, "sas topology change: (%s)\n", status_str);
7567 * @ioc: per adapter object
7573 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
7589 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7590 _scsih_sas_topology_change_event_debug(ioc, event_data);
7592 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
7595 if (!ioc->sas_hba.num_phys)
7596 _scsih_sas_host_add(ioc);
7598 _scsih_sas_host_refresh(ioc);
7601 dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n"));
7606 port = mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0);
7610 if (_scsih_expander_add(ioc, parent_handle) != 0)
7613 spin_lock_irqsave(&ioc->sas_node_lock, flags);
7614 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
7620 } else if (parent_handle < ioc->sas_hba.num_phys) {
7621 sas_address = ioc->sas_hba.sas_address;
7622 max_phys = ioc->sas_hba.num_phys;
7624 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7627 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7632 dewtprintk(ioc,
7633 ioc_info(ioc, "ignoring expander event\n"));
7636 if (ioc->remove_host || ioc->pci_error_recovery)
7655 if (ioc->shost_recovery)
7661 mpt3sas_transport_update_links(ioc, sas_address,
7667 _scsih_check_device(ioc, sas_address, handle,
7670 if (!test_bit(handle, ioc->pend_os_device_add))
7677 if (ioc->shost_recovery)
7680 mpt3sas_transport_update_links(ioc, sas_address,
7683 _scsih_add_device(ioc, handle, phy_number, 0);
7688 _scsih_device_remove_by_handle(ioc, handle);
7696 mpt3sas_expander_remove(ioc, sas_address, port);
7703 * @ioc: ?
7708 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7757 ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
7769 * @ioc: per adapter object
7774 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
7785 if ((ioc->facts.HeaderVersion >> 8) < 0xC)
7794 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7796 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
7798 mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0));
7813 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7814 ioc_info(ioc,
7823 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7829 * @ioc: per adapter object
7837 _scsih_check_pcie_access_status(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
7853 ioc_info(ioc,
7902 ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n",
7910 ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n",
7918 * @ioc: per adapter object
7922 _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
7927 dewtprintk(ioc,
7928 ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n",
7932 dewtprintk(ioc,
7933 ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
7938 dewtprintk(ioc,
7939 ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n",
7947 _scsih_ublock_io_device(ioc, pcie_device->wwid, NULL);
7951 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
7954 ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n",
7958 ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n",
7965 dewtprintk(ioc,
7966 ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n",
7970 dewtprintk(ioc,
7971 ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
7976 dewtprintk(ioc,
7977 ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n",
7988 * @ioc: per adapter object
7992 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
8004 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
8018 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8019 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
8022 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8051 ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n",
8053 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8059 if (_scsih_check_pcie_access_status(ioc, wwid, handle,
8061 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8066 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8069 _scsih_ublock_io_device(ioc, wwid, NULL);
8076 * @ioc: per adapter object
8079 * Creating end device object, stored in ioc->pcie_device_list.
8084 _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
8094 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
8096 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8103 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8108 set_bit(handle, ioc->pend_os_device_add);
8114 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
8120 if (_scsih_check_pcie_access_status(ioc, wwid, handle,
8128 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, wwid);
8130 clear_bit(handle, ioc->pend_os_device_add);
8141 if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply,
8144 ioc_err(ioc,
8153 ioc_err(ioc,
8162 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8168 pcie_device->id = ioc->pcie_target_id++;
8196 mpt3sas_scsih_enclosure_find_by_handle(ioc,
8214 if (pcie_device->shutdown_latency > ioc->max_shutdown_latency)
8215 ioc->max_shutdown_latency =
8225 if (ioc->wait_for_discovery_to_complete)
8226 _scsih_pcie_device_init_add(ioc, pcie_device);
8228 _scsih_pcie_device_add(ioc, pcie_device);
8237 * @ioc: per adapter object
8242 _scsih_pcie_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
8270 ioc_info(ioc, "pcie topology change: (%s)\n", status_str);
8316 * @ioc: per adapter object
8322 _scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
8335 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
8336 _scsih_pcie_topology_change_event_debug(ioc, event_data);
8338 if (ioc->shost_recovery || ioc->remove_host ||
8339 ioc->pci_error_recovery)
8343 dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n"));
8350 dewtprintk(ioc,
8351 ioc_info(ioc, "ignoring switch event\n"));
8354 if (ioc->remove_host || ioc->pci_error_recovery)
8369 if (ioc->shost_recovery)
8376 _scsih_pcie_check_device(ioc, handle);
8384 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8385 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
8386 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8393 if (!test_bit(handle, ioc->pend_os_device_add))
8396 dewtprintk(ioc,
8397 ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n",
8404 if (ioc->shost_recovery)
8409 rc = _scsih_pcie_add_device(ioc, handle);
8421 _scsih_pcie_device_remove_by_handle(ioc, handle);
8429 * @ioc: ?
8434 _scsih_pcie_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
8481 ioc_info(ioc, "PCIE device status change: (%s)\n"
8495 * @ioc: per adapter object
8500 _scsih_pcie_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
8509 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
8510 _scsih_pcie_device_status_change_event_debug(ioc,
8519 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8521 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
8539 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8545 * @ioc: per adapter object
8550 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
8567 ioc_info(ioc, "enclosure status change: (%s)\n"
8577 * @ioc: per adapter object
8582 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
8592 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
8593 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
8596 if (ioc->shost_recovery)
8601 mpt3sas_scsih_enclosure_find_by_handle(ioc,
8610 ioc_info(ioc, "failure at %s:%d/%s()!\n",
8614 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
8626 &ioc->enclosure_list);
8642 * @ioc: per adapter object
8647 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
8668 mutex_lock(&ioc->tm_cmds.mutex);
8669 ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n",
8672 _scsih_block_io_all_device(ioc);
8674 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8675 mpi_reply = ioc->tm_cmds.reply;
8680 dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__));
8683 dewtprintk(ioc,
8684 ioc_info(ioc, "%s: %d retry\n",
8689 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
8690 if (ioc->shost_recovery)
8692 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
8717 if (ioc->shost_recovery)
8720 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
8721 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
8728 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8737 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8746 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8752 dewtprintk(ioc,
8753 ioc_info(ioc, "%s: ABORT_TASK: giving up\n",
8755 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8759 if (ioc->shost_recovery)
8762 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
8779 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8782 if (ioc->broadcast_aen_pending) {
8783 dewtprintk(ioc,
8784 ioc_info(ioc,
8787 ioc->broadcast_aen_pending = 0;
8792 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
8795 dewtprintk(ioc,
8796 ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n",
8799 ioc->broadcast_aen_busy = 0;
8800 if (!ioc->shost_recovery)
8801 _scsih_ublock_io_all_device(ioc);
8802 mutex_unlock(&ioc->tm_cmds.mutex);
8807 * @ioc: per adapter object
8812 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
8818 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
8819 ioc_info(ioc, "discovery event: (%s)",
8829 !ioc->sas_hba.num_phys) {
8830 if (disable_discovery > 0 && ioc->shost_recovery) {
8832 while (ioc->shost_recovery)
8835 _scsih_sas_host_add(ioc);
8842 * @ioc: per adapter object
8847 _scsih_sas_device_discovery_error_event(struct MPT3SAS_ADAPTER *ioc,
8855 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n",
8861 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n",
8873 * @ioc: per adapter object
8878 _scsih_pcie_enumeration_event(struct MPT3SAS_ADAPTER *ioc,
8884 if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK))
8887 ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x",
8899 * @ioc: per adapter object
8906 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
8916 if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
8919 mutex_lock(&ioc->scsih_cmds.mutex);
8921 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
8922 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
8926 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
8928 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
8930 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
8931 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
8936 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
8937 ioc->scsih_cmds.smid = smid;
8944 dewtprintk(ioc,
8945 ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n",
8948 init_completion(&ioc->scsih_cmds.done);
8949 ioc->put_smid_default(ioc, smid);
8950 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
8952 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
8953 mpt3sas_check_cmd_timeout(ioc,
8954 ioc->scsih_cmds.status, mpi_request,
8960 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
8962 mpi_reply = ioc->scsih_cmds.reply;
8970 dewtprintk(ioc,
8971 ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n",
8975 dewtprintk(ioc,
8976 ioc_info(ioc, "IR RAID_ACTION: completed successfully\n"));
8980 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
8981 mutex_unlock(&ioc->scsih_cmds.mutex);
8984 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
9005 * @ioc: per adapter object
9010 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
9019 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
9021 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9026 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9027 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
9028 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9035 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9040 raid_device->id = ioc->sas_id++;
9044 _scsih_raid_device_add(ioc, raid_device);
9045 if (!ioc->wait_for_discovery_to_complete) {
9046 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9049 _scsih_raid_device_remove(ioc, raid_device);
9051 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9052 _scsih_determine_boot_device(ioc, raid_device, 1);
9053 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9059 * @ioc: per adapter object
9064 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
9071 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9072 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
9079 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
9084 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9091 * @ioc: per adapter object
9096 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
9105 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9106 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
9110 clear_bit(handle, ioc->pd_handles);
9118 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9131 * @ioc: per adapter object
9136 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
9147 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
9149 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
9152 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9153 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
9155 set_bit(handle, ioc->pd_handles);
9165 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9170 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
9180 * @ioc: per adapter object
9185 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
9190 _scsih_device_remove_by_handle(ioc, handle);
9195 * @ioc: per adapter object
9200 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
9211 set_bit(handle, ioc->pd_handles);
9213 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
9215 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
9220 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
9222 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9230 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9236 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
9237 mpt3sas_transport_update_links(ioc, sas_address, handle,
9239 mpt3sas_get_port_by_id(ioc,
9242 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
9243 _scsih_add_device(ioc, handle, 0, 1);
9248 * @ioc: per adapter object
9253 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
9263 ioc_info(ioc, "raid config change: (%s), elements(%d)\n",
9326 * @ioc: per adapter object
9331 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
9341 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
9342 (!ioc->hide_ir_msg))
9343 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
9349 if (ioc->shost_recovery &&
9350 ioc->hba_mpi_version_belonged != MPI2_VERSION) {
9353 _scsih_ir_fastpath(ioc,
9366 _scsih_sas_volume_add(ioc, element);
9371 _scsih_sas_volume_delete(ioc,
9375 if (!ioc->is_warpdrive)
9376 _scsih_sas_pd_hide(ioc, element);
9379 if (!ioc->is_warpdrive)
9380 _scsih_sas_pd_expose(ioc, element);
9383 if (!ioc->is_warpdrive)
9384 _scsih_sas_pd_add(ioc, element);
9387 if (!ioc->is_warpdrive)
9388 _scsih_sas_pd_delete(ioc, element);
9396 * @ioc: per adapter object
9401 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
9413 if (ioc->shost_recovery)
9421 if (!ioc->hide_ir_msg)
9422 dewtprintk(ioc,
9423 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
9430 _scsih_sas_volume_delete(ioc, handle);
9437 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9438 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
9439 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9444 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
9446 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9453 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9458 raid_device->id = ioc->sas_id++;
9462 _scsih_raid_device_add(ioc, raid_device);
9463 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9466 _scsih_raid_device_remove(ioc, raid_device);
9477 * @ioc: per adapter object
9482 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
9495 if (ioc->shost_recovery)
9504 if (!ioc->hide_ir_msg)
9505 dewtprintk(ioc,
9506 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
9518 if (!ioc->is_warpdrive)
9519 set_bit(handle, ioc->pd_handles);
9521 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
9527 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9530 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9538 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9544 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
9545 mpt3sas_transport_update_links(ioc, sas_address, handle,
9547 mpt3sas_get_port_by_id(ioc,
9550 _scsih_add_device(ioc, handle, 0, 1);
9564 * @ioc: per adapter object
9569 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
9595 ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n",
9603 * @ioc: per adapter object
9608 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
9618 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
9619 (!ioc->hide_ir_msg))
9620 _scsih_sas_ir_operation_status_event_debug(ioc,
9626 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9628 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
9632 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9638 * @ioc: per adapter object
9644 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
9649 shost_for_each_device(sdev, ioc->shost) {
9658 * @ioc: per adapter object
9662 _scsih_update_device_qdepth(struct MPT3SAS_ADAPTER *ioc)
9670 ioc_info(ioc, "Update devices with firmware reported queue depth\n");
9671 shost_for_each_device(sdev, ioc->shost) {
9677 qdepth = ioc->max_nvme_qd;
9681 ioc->max_wideport_qd : ioc->max_narrowport_qd;
9684 qdepth = ioc->max_sata_qd;
9694 * @ioc: per adapter object
9701 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc,
9710 ioc, sas_device_pg0->PhysicalPort, 0);
9714 mpt3sas_scsih_enclosure_find_by_handle(ioc,
9717 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
9720 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9721 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
9789 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9795 * @ioc: per adapter object
9798 _scsih_create_enclosure_list_after_reset(struct MPT3SAS_ADAPTER *ioc)
9806 mpt3sas_free_enclosure_list(ioc);
9814 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9818 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
9829 &ioc->enclosure_list);
9837 * @ioc: per adapter object
9843 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
9851 ioc_info(ioc, "search for end-devices: start\n");
9853 if (list_empty(&ioc->sas_device_list))
9857 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9868 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0);
9872 ioc_info(ioc, "search for end-devices: complete\n");
9877 * @ioc: per adapter object
9884 _scsih_mark_responding_pcie_device(struct MPT3SAS_ADAPTER *ioc,
9892 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
9893 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) {
9923 (ioc->hba_mpi_version_belonged != MPI2_VERSION)) {
9948 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
9953 * @ioc: per adapter object
9959 _scsih_search_responding_pcie_devices(struct MPT3SAS_ADAPTER *ioc)
9967 ioc_info(ioc, "search for end-devices: start\n");
9969 if (list_empty(&ioc->pcie_device_list))
9973 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
9979 ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n",
9988 _scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0);
9991 ioc_info(ioc, "search for PCIe end-devices: complete\n");
9996 * @ioc: per adapter object
10004 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
10012 spin_lock_irqsave(&ioc->raid_device_lock, flags);
10013 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
10022 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10032 mpt3sas_init_warpdrive_properties(ioc, raid_device);
10033 spin_lock_irqsave(&ioc->raid_device_lock, flags);
10035 spin_unlock_irqrestore(&ioc->raid_device_lock,
10044 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10048 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10053 * @ioc: per adapter object
10059 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
10069 if (!ioc->ir_firmware)
10072 ioc_info(ioc, "search for raid volumes: start\n");
10074 if (list_empty(&ioc->raid_device_list))
10078 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
10086 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
10094 _scsih_mark_responding_raid_device(ioc,
10099 if (!ioc->is_warpdrive) {
10101 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
10102 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
10111 set_bit(handle, ioc->pd_handles);
10115 ioc_info(ioc, "search for responding raid volumes: complete\n");
10120 * @ioc: per adapter object
10127 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc,
10138 ioc, expander_pg0->PhysicalPort, 0);
10142 mpt3sas_scsih_enclosure_find_by_handle(ioc,
10145 spin_lock_irqsave(&ioc->sas_node_lock, flags);
10146 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
10172 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
10177 * @ioc: per adapter object
10183 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
10192 ioc_info(ioc, "search for expanders: start\n");
10194 if (list_empty(&ioc->sas_expander_list))
10198 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
10212 (ioc->multipath_on_hba ?
10214 _scsih_mark_responding_expander(ioc, &expander_pg0);
10218 ioc_info(ioc, "search for expanders: complete\n");
10223 * @ioc: per adapter object
10226 _scsih_remove_unresponding_devices(struct MPT3SAS_ADAPTER *ioc)
10236 ioc_info(ioc, "removing unresponding devices: start\n");
10239 ioc_info(ioc, "removing unresponding devices: end-devices\n");
10244 spin_lock_irqsave(&ioc->sas_device_lock, flags);
10251 &ioc->sas_device_init_list, list) {
10257 &ioc->sas_device_list, list) {
10263 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
10269 _scsih_remove_device(ioc, sas_device);
10274 ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n");
10276 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
10282 &ioc->pcie_device_init_list, list) {
10288 &ioc->pcie_device_list, list) {
10294 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
10297 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
10303 if (ioc->ir_firmware) {
10304 ioc_info(ioc, "removing unresponding devices: volumes\n");
10306 &ioc->raid_device_list, list) {
10308 _scsih_sas_volume_delete(ioc,
10316 ioc_info(ioc, "removing unresponding devices: expanders\n");
10317 spin_lock_irqsave(&ioc->sas_node_lock, flags);
10320 &ioc->sas_expander_list, list) {
10326 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
10329 _scsih_expander_node_remove(ioc, sas_expander);
10332 ioc_info(ioc, "removing unresponding devices: complete\n");
10335 _scsih_ublock_io_all_device(ioc);
10339 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
10347 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
10349 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10354 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
10363 * @ioc: per adapter object
10366 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
10387 ioc_info(ioc, "scan devices: start\n");
10389 _scsih_sas_host_refresh(ioc);
10391 ioc_info(ioc, "\tscan devices: expanders start\n");
10395 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
10400 ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10405 spin_lock_irqsave(&ioc->sas_node_lock, flags);
10408 ioc, le64_to_cpu(expander_pg0.SASAddress),
10409 mpt3sas_get_port_by_id(ioc, port_id, 0));
10410 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
10412 _scsih_refresh_expander_links(ioc, expander_device,
10415 ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
10418 _scsih_expander_add(ioc, handle);
10419 ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
10425 ioc_info(ioc, "\tscan devices: expanders complete\n");
10427 if (!ioc->ir_firmware)
10430 ioc_info(ioc, "\tscan devices: phys disk start\n");
10434 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
10440 ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10446 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
10451 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
10458 ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n",
10463 if (!_scsih_get_sas_address(ioc, parent_handle,
10465 ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
10469 mpt3sas_transport_update_links(ioc, sas_address,
10472 mpt3sas_get_port_by_id(ioc, port_id, 0));
10473 set_bit(handle, ioc->pd_handles);
10479 while (_scsih_add_device(ioc, handle, retry_count++,
10483 ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
10489 ioc_info(ioc, "\tscan devices: phys disk complete\n");
10491 ioc_info(ioc, "\tscan devices: volumes start\n");
10495 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
10500 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10505 spin_lock_irqsave(&ioc->raid_device_lock, flags);
10506 raid_device = _scsih_raid_device_find_by_wwid(ioc,
10508 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10511 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
10518 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10528 ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n",
10530 _scsih_sas_volume_add(ioc, &element);
10531 ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n",
10536 ioc_info(ioc, "\tscan devices: volumes complete\n");
10540 ioc_info(ioc, "\tscan devices: end devices start\n");
10544 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
10550 ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10559 sas_device = mpt3sas_get_sdev_by_addr(ioc,
10561 mpt3sas_get_port_by_id(ioc, port_id, 0));
10567 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
10568 ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
10571 mpt3sas_transport_update_links(ioc, sas_address, handle,
10573 mpt3sas_get_port_by_id(ioc, port_id, 0));
10579 while (_scsih_add_device(ioc, handle, retry_count++,
10583 ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
10588 ioc_info(ioc, "\tscan devices: end devices complete\n");
10589 ioc_info(ioc, "\tscan devices: pcie end devices start\n");
10593 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
10599 ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10607 pcie_device = mpt3sas_get_pdev_by_wwid(ioc,
10615 _scsih_pcie_add_device(ioc, handle);
10617 ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n",
10621 ioc_info(ioc, "\tpcie devices: pcie end devices complete\n");
10622 ioc_info(ioc, "scan devices: complete\n");
10627 * @ioc: per adapter object
10631 void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
10633 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
10639 * @ioc: per adapter object
10644 mpt3sas_scsih_clear_outstanding_scsi_tm_commands(struct MPT3SAS_ADAPTER *ioc)
10646 dtmprintk(ioc,
10647 ioc_info(ioc, "%s: clear outstanding scsi & tm cmds\n", __func__));
10648 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
10649 ioc->scsih_cmds.status |= MPT3_CMD_RESET;
10650 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
10651 complete(&ioc->scsih_cmds.done);
10653 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
10654 ioc->tm_cmds.status |= MPT3_CMD_RESET;
10655 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
10656 complete(&ioc->tm_cmds.done);
10659 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz);
10660 memset(ioc->device_remove_in_progress, 0,
10661 ioc->device_remove_in_progress_sz);
10662 _scsih_fw_event_cleanup_queue(ioc);
10663 _scsih_flush_running_cmds(ioc);
10668 * @ioc: per adapter object
10673 mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
10675 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
10676 if (!(disable_discovery > 0 && !ioc->sas_hba.num_phys)) {
10677 if (ioc->multipath_on_hba) {
10678 _scsih_sas_port_refresh(ioc);
10679 _scsih_update_vphys_after_reset(ioc);
10681 _scsih_prep_device_scan(ioc);
10682 _scsih_create_enclosure_list_after_reset(ioc);
10683 _scsih_search_responding_sas_devices(ioc);
10684 _scsih_search_responding_pcie_devices(ioc);
10685 _scsih_search_responding_raid_devices(ioc);
10686 _scsih_search_responding_expanders(ioc);
10687 _scsih_error_recovery_delete_devices(ioc);
10693 * @ioc: per adapter object
10698 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
10700 ioc->current_event = fw_event;
10701 _scsih_fw_event_del_from_list(ioc, fw_event);
10704 if (ioc->remove_host || ioc->pci_error_recovery) {
10706 ioc->current_event = NULL;
10712 mpt3sas_process_trigger_data(ioc,
10717 while (scsi_host_in_recovery(ioc->shost) ||
10718 ioc->shost_recovery) {
10723 if (ioc->remove_host || ioc->fw_events_cleanup)
10727 _scsih_remove_unresponding_devices(ioc);
10728 _scsih_del_dirty_vphy(ioc);
10729 _scsih_del_dirty_port_entries(ioc);
10730 if (ioc->is_gen35_ioc)
10731 _scsih_update_device_qdepth(ioc);
10732 _scsih_scan_for_devices_after_reset(ioc);
10743 if (ioc->is_driver_loading)
10744 _scsih_complete_devices_scanning(ioc);
10745 _scsih_set_nvme_max_shutdown_latency(ioc);
10748 ioc->start_scan = 0;
10750 mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
10752 dewtprintk(ioc,
10753 ioc_info(ioc, "port enable: complete from worker thread\n"));
10756 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
10759 _scsih_sas_topology_change_event(ioc, fw_event);
10762 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
10763 _scsih_sas_device_status_change_event_debug(ioc,
10768 _scsih_sas_discovery_event(ioc, fw_event);
10771 _scsih_sas_device_discovery_error_event(ioc, fw_event);
10774 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
10777 _scsih_sas_enclosure_dev_status_change_event(ioc,
10781 _scsih_sas_ir_config_change_event(ioc, fw_event);
10784 _scsih_sas_ir_volume_event(ioc, fw_event);
10787 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
10790 _scsih_sas_ir_operation_status_event(ioc, fw_event);
10793 _scsih_pcie_device_status_change_event(ioc, fw_event);
10796 _scsih_pcie_enumeration_event(ioc, fw_event);
10799 _scsih_pcie_topology_change_event(ioc, fw_event);
10800 ioc->current_event = NULL;
10805 ioc->current_event = NULL;
10822 _mpt3sas_fw_work(fw_event->ioc, fw_event);
10827 * @ioc: per adapter object
10832 * This function merely adds a new work task into ioc->firmware_event_thread.
10839 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
10849 if (ioc->pci_error_recovery)
10852 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
10855 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
10863 mpt3sas_trigger_event(ioc, event, 0);
10877 if (ioc->broadcast_aen_busy) {
10878 ioc->broadcast_aen_pending++;
10881 ioc->broadcast_aen_busy = 1;
10886 _scsih_check_topo_delete_events(ioc,
10897 if (ioc->shost_recovery)
10901 _scsih_check_pcie_topo_remove_events(ioc,
10904 if (ioc->shost_recovery)
10908 _scsih_check_ir_config_unhide_events(ioc,
10913 _scsih_check_volume_delete_events(ioc,
10922 if (!ioc->is_warpdrive)
10935 ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
10938 ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n");
10941 ioc_err(ioc, "WarpDrive Fatal Error: There are no Program/Erase Cycles for the WarpDrive subsystem. The storage device will be in read-only mode. Check WarpDrive documentation for additional details.\n");
10944 ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
10951 _scsih_sas_device_status_change_event(ioc,
10965 _scsih_temp_threshold_events(ioc,
10974 ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n",
10984 ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n",
11000 ioc_err(ioc, "failure at %s:%d/%s()!\n",
11006 fw_event->ioc = ioc;
11010 _scsih_fw_event_add(ioc, fw_event);
11017 * @ioc: per adapter object
11021 * ioc->sas_expander_list.
11024 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
11034 if (ioc->shost_recovery)
11038 mpt3sas_device_remove_by_sas_address(ioc,
11045 mpt3sas_expander_remove(ioc,
11052 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
11055 ioc_info(ioc,
11061 spin_lock_irqsave(&ioc->sas_node_lock, flags);
11063 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
11071 * @ioc: per adapter object
11078 _scsih_nvme_shutdown(struct MPT3SAS_ADAPTER *ioc)
11085 if (list_empty(&ioc->pcie_device_list))
11088 mutex_lock(&ioc->scsih_cmds.mutex);
11090 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
11091 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
11095 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
11097 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
11099 ioc_err(ioc,
11101 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11105 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
11106 ioc->scsih_cmds.smid = smid;
11111 init_completion(&ioc->scsih_cmds.done);
11112 ioc->put_smid_default(ioc, smid);
11114 ioc_info(ioc,
11116 ioc->max_shutdown_latency);
11117 wait_for_completion_timeout(&ioc->scsih_cmds.done,
11118 ioc->max_shutdown_latency*HZ);
11120 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
11121 ioc_err(ioc, "%s: timeout\n", __func__);
11125 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
11126 mpi_reply = ioc->scsih_cmds.reply;
11127 ioc_info(ioc, "Io Unit Control shutdown (complete):"
11133 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11134 mutex_unlock(&ioc->scsih_cmds.mutex);
11140 * @ioc: per adapter object
11146 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
11153 if (!ioc->ir_firmware)
11157 if (list_empty(&ioc->raid_device_list))
11160 mutex_lock(&ioc->scsih_cmds.mutex);
11162 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
11163 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
11166 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
11168 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
11170 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
11171 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11175 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
11176 ioc->scsih_cmds.smid = smid;
11182 if (!ioc->hide_ir_msg)
11183 ioc_info(ioc, "IR shutdown (sending)\n");
11184 init_completion(&ioc->scsih_cmds.done);
11185 ioc->put_smid_default(ioc, smid);
11186 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
11188 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
11189 ioc_err(ioc, "%s: timeout\n", __func__);
11193 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
11194 mpi_reply = ioc->scsih_cmds.reply;
11195 if (!ioc->hide_ir_msg)
11196 ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
11202 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11203 mutex_unlock(&ioc->scsih_cmds.mutex);
11207 * _scsih_get_shost_and_ioc - get shost and ioc
11211 * @ioc: address of HBA adapter pointer
11213 * Return zero if *shost and *ioc are not NULL otherwise return error number.
11217 struct Scsi_Host **shost, struct MPT3SAS_ADAPTER **ioc)
11225 *ioc = shost_priv(*shost);
11226 if (*ioc == NULL) {
11243 struct MPT3SAS_ADAPTER *ioc;
11253 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
11256 ioc->remove_host = 1;
11259 mpt3sas_base_pause_mq_polling(ioc);
11260 _scsih_flush_running_cmds(ioc);
11263 _scsih_fw_event_cleanup_queue(ioc);
11265 spin_lock_irqsave(&ioc->fw_event_lock, flags);
11266 wq = ioc->firmware_event_thread;
11267 ioc->firmware_event_thread = NULL;
11268 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
11272 * Copy back the unmodified ioc page1. so that on next driver load,
11273 * current modified changes on ioc page1 won't take effect.
11275 if (ioc->is_aero_ioc)
11276 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply,
11277 &ioc->ioc_pg1_copy);
11279 _scsih_ir_shutdown(ioc);
11280 mpt3sas_destroy_debugfs(ioc);
11282 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
11290 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
11292 _scsih_raid_device_remove(ioc, raid_device);
11294 list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list,
11296 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
11303 &ioc->sas_hba.sas_port_list, port_list) {
11306 mpt3sas_device_remove_by_sas_address(ioc,
11313 mpt3sas_expander_remove(ioc,
11319 &ioc->port_table_list, list) {
11325 if (ioc->sas_hba.num_phys) {
11326 kfree(ioc->sas_hba.phy);
11327 ioc->sas_hba.phy = NULL;
11328 ioc->sas_hba.num_phys = 0;
11331 mpt3sas_base_detach(ioc);
11332 mpt3sas_ctl_release(ioc);
11334 list_del(&ioc->list);
11347 struct MPT3SAS_ADAPTER *ioc;
11352 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
11355 ioc->remove_host = 1;
11358 mpt3sas_base_pause_mq_polling(ioc);
11359 _scsih_flush_running_cmds(ioc);
11362 _scsih_fw_event_cleanup_queue(ioc);
11364 spin_lock_irqsave(&ioc->fw_event_lock, flags);
11365 wq = ioc->firmware_event_thread;
11366 ioc->firmware_event_thread = NULL;
11367 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
11371 * Copy back the unmodified ioc page1 so that on next driver load,
11372 * current modified changes on ioc page1 won't take effect.
11374 if (ioc->is_aero_ioc)
11375 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply,
11376 &ioc->ioc_pg1_copy);
11378 _scsih_ir_shutdown(ioc);
11379 _scsih_nvme_shutdown(ioc);
11380 mpt3sas_base_mask_interrupts(ioc);
11381 mpt3sas_base_stop_watchdog(ioc);
11382 ioc->shost_recovery = 1;
11383 mpt3sas_base_make_ioc_ready(ioc, SOFT_RESET);
11384 ioc->shost_recovery = 0;
11385 mpt3sas_base_free_irq(ioc);
11386 mpt3sas_base_disable_msix(ioc);
11392 * @ioc: per adapter object
11399 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
11415 if (!ioc->bios_pg3.BiosVersion)
11419 if (ioc->req_boot_device.device) {
11420 device = ioc->req_boot_device.device;
11421 channel = ioc->req_boot_device.channel;
11422 } else if (ioc->req_alt_boot_device.device) {
11423 device = ioc->req_alt_boot_device.device;
11424 channel = ioc->req_alt_boot_device.channel;
11425 } else if (ioc->current_boot_device.device) {
11426 device = ioc->current_boot_device.device;
11427 channel = ioc->current_boot_device.channel;
11442 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
11445 _scsih_raid_device_remove(ioc, raid_device);
11455 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
11457 list_move_tail(&pcie_device->list, &ioc->pcie_device_list);
11458 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
11459 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, tid, 0);
11461 _scsih_pcie_device_remove(ioc, pcie_device);
11471 spin_lock_irqsave(&ioc->sas_device_lock, flags);
11476 list_move_tail(&sas_device->list, &ioc->sas_device_list);
11477 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
11479 if (ioc->hide_drives)
11485 if (!mpt3sas_transport_port_add(ioc, handle,
11487 _scsih_sas_device_remove(ioc, sas_device);
11489 if (!ioc->is_driver_loading) {
11490 mpt3sas_transport_port_remove(ioc,
11493 _scsih_sas_device_remove(ioc, sas_device);
11501 * @ioc: per adapter object
11506 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
11512 &ioc->raid_device_list, list) {
11515 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
11518 _scsih_raid_device_remove(ioc, raid_device);
11522 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc)
11527 spin_lock_irqsave(&ioc->sas_device_lock, flags);
11528 if (!list_empty(&ioc->sas_device_init_list)) {
11529 sas_device = list_first_entry(&ioc->sas_device_init_list,
11533 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
11538 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc,
11543 spin_lock_irqsave(&ioc->sas_device_lock, flags);
11559 list_add_tail(&sas_device->list, &ioc->sas_device_list);
11561 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
11566 * @ioc: per adapter object
11571 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
11575 if (ioc->hide_drives)
11578 while ((sas_device = get_next_sas_device(ioc))) {
11579 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
11581 _scsih_sas_device_remove(ioc, sas_device);
11591 if (!ioc->is_driver_loading) {
11592 mpt3sas_transport_port_remove(ioc,
11596 _scsih_sas_device_remove(ioc, sas_device);
11601 sas_device_make_active(ioc, sas_device);
11608 * @ioc: per adapter object
11615 static struct _pcie_device *get_next_pcie_device(struct MPT3SAS_ADAPTER *ioc)
11620 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
11621 if (!list_empty(&ioc->pcie_device_init_list)) {
11622 pcie_device = list_first_entry(&ioc->pcie_device_init_list,
11626 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
11633 * @ioc: per adapter object
11639 static void pcie_device_make_active(struct MPT3SAS_ADAPTER *ioc,
11644 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
11651 list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
11653 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
11658 * @ioc: per adapter object
11663 _scsih_probe_pcie(struct MPT3SAS_ADAPTER *ioc)
11669 while ((pcie_device = get_next_pcie_device(ioc))) {
11676 pcie_device_make_active(ioc, pcie_device);
11680 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL,
11683 _scsih_pcie_device_remove(ioc, pcie_device);
11693 if (!ioc->is_driver_loading) {
11697 _scsih_pcie_device_remove(ioc, pcie_device);
11702 pcie_device_make_active(ioc, pcie_device);
11709 * @ioc: per adapter object
11714 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
11718 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
11721 _scsih_probe_boot_devices(ioc);
11723 if (ioc->ir_firmware) {
11725 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
11729 _scsih_probe_raid(ioc);
11730 _scsih_probe_sas(ioc);
11732 _scsih_probe_sas(ioc);
11733 _scsih_probe_raid(ioc);
11736 _scsih_probe_sas(ioc);
11737 _scsih_probe_pcie(ioc);
11752 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
11755 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
11756 else if (ioc->manu_pg11.HostTraceBufferMaxSizeKB != 0)
11757 mpt3sas_enable_diag_buffer(ioc, 1);
11762 ioc->start_scan = 1;
11763 rc = mpt3sas_port_enable(ioc);
11766 ioc_info(ioc, "port enable: FAILED\n");
11771 * complete ioc initialization.
11772 * @ioc: per adapter object
11776 static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc)
11779 if (ioc->wait_for_discovery_to_complete) {
11780 ioc->wait_for_discovery_to_complete = 0;
11781 _scsih_probe_devices(ioc);
11784 mpt3sas_base_start_watchdog(ioc);
11785 ioc->is_driver_loading = 0;
11800 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
11805 ioc->is_driver_loading = 0;
11806 ioc->wait_for_discovery_to_complete = 0;
11811 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11812 ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n");
11813 ioc->is_driver_loading = 0;
11817 if (ioc->start_scan) {
11818 ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
11820 mpt3sas_print_fault_code(ioc, ioc_state &
11826 mpt3sas_base_coredump_info(ioc, ioc_state &
11828 mpt3sas_base_wait_for_coredump_completion(ioc, __func__);
11835 if (ioc->port_enable_cmds.status & MPT3_CMD_RESET) {
11836 ioc_info(ioc,
11838 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11841 if (ioc->start_scan_failed) {
11842 ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n",
11843 ioc->start_scan_failed);
11844 ioc->is_driver_loading = 0;
11845 ioc->wait_for_discovery_to_complete = 0;
11846 ioc->remove_host = 1;
11850 ioc_info(ioc, "port enable: SUCCESS\n");
11851 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11852 _scsih_complete_devices_scanning(ioc);
11856 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11857 if (mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET))
11858 ioc->is_driver_loading = 0;
11869 struct MPT3SAS_ADAPTER *ioc =
11873 int nr_msix_vectors = ioc->iopoll_q_start_index;
11874 int iopoll_q_count = ioc->reply_queue_count - nr_msix_vectors;
11885 nr_msix_vectors - ioc->high_iops_queues;
11886 offset = ioc->high_iops_queues;
11899 blk_mq_pci_map_queues(map, ioc->pdev, offset);
12068 struct MPT3SAS_ADAPTER *ioc;
12101 ioc = shost_priv(shost);
12102 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
12103 ioc->hba_mpi_version_belonged = hba_mpi_version;
12104 ioc->id = mpt2_ids++;
12105 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME);
12108 ioc->is_warpdrive = 1;
12109 ioc->hide_ir_msg = 1;
12113 ioc->is_mcpu_endpoint = 1;
12116 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
12121 ioc->multipath_on_hba = 0;
12123 ioc->multipath_on_hba = 1;
12133 ioc = shost_priv(shost);
12134 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
12135 ioc->hba_mpi_version_belonged = hba_mpi_version;
12136 ioc->id = mpt3_ids++;
12137 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME);
12147 ioc->is_gen35_ioc = 1;
12170 ioc->is_aero_ioc = ioc->is_gen35_ioc = 1;
12173 ioc->is_gen35_ioc = ioc->is_aero_ioc = 0;
12175 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION &&
12177 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) {
12178 ioc->combined_reply_queue = 1;
12179 if (ioc->is_gen35_ioc)
12180 ioc->combined_reply_index_count =
12183 ioc->combined_reply_index_count =
12187 switch (ioc->is_gen35_ioc) {
12190 ioc->multipath_on_hba = 0;
12192 ioc->multipath_on_hba = 1;
12196 ioc->multipath_on_hba = 1;
12198 ioc->multipath_on_hba = 0;
12209 INIT_LIST_HEAD(&ioc->list);
12211 list_add_tail(&ioc->list, &mpt3sas_ioc_list);
12213 ioc->shost = shost;
12214 ioc->pdev = pdev;
12215 ioc->scsi_io_cb_idx = scsi_io_cb_idx;
12216 ioc->tm_cb_idx = tm_cb_idx;
12217 ioc->ctl_cb_idx = ctl_cb_idx;
12218 ioc->base_cb_idx = base_cb_idx;
12219 ioc->port_enable_cb_idx = port_enable_cb_idx;
12220 ioc->transport_cb_idx = transport_cb_idx;
12221 ioc->scsih_cb_idx = scsih_cb_idx;
12222 ioc->config_cb_idx = config_cb_idx;
12223 ioc->tm_tr_cb_idx = tm_tr_cb_idx;
12224 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
12225 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
12226 ioc->logging_level = logging_level;
12227 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
12229 ioc->max_shutdown_latency = IO_UNIT_CONTROL_SHUTDOWN_TIMEOUT;
12233 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_MEMMOVE;
12235 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_ADDNLQUERY;
12237 ioc->enable_sdev_max_qd = enable_sdev_max_qd;
12240 mutex_init(&ioc->reset_in_progress_mutex);
12241 mutex_init(&ioc->hostdiag_unlock_mutex);
12243 mutex_init(&ioc->pci_access_mutex);
12244 spin_lock_init(&ioc->ioc_reset_in_progress_lock);
12245 spin_lock_init(&ioc->scsi_lookup_lock);
12246 spin_lock_init(&ioc->sas_device_lock);
12247 spin_lock_init(&ioc->sas_node_lock);
12248 spin_lock_init(&ioc->fw_event_lock);
12249 spin_lock_init(&ioc->raid_device_lock);
12250 spin_lock_init(&ioc->pcie_device_lock);
12251 spin_lock_init(&ioc->diag_trigger_lock);
12253 INIT_LIST_HEAD(&ioc->sas_device_list);
12254 INIT_LIST_HEAD(&ioc->sas_device_init_list);
12255 INIT_LIST_HEAD(&ioc->sas_expander_list);
12256 INIT_LIST_HEAD(&ioc->enclosure_list);
12257 INIT_LIST_HEAD(&ioc->pcie_device_list);
12258 INIT_LIST_HEAD(&ioc->pcie_device_init_list);
12259 INIT_LIST_HEAD(&ioc->fw_event_list);
12260 INIT_LIST_HEAD(&ioc->raid_device_list);
12261 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
12262 INIT_LIST_HEAD(&ioc->delayed_tr_list);
12263 INIT_LIST_HEAD(&ioc->delayed_sc_list);
12264 INIT_LIST_HEAD(&ioc->delayed_event_ack_list);
12265 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
12266 INIT_LIST_HEAD(&ioc->reply_queue_list);
12267 INIT_LIST_HEAD(&ioc->port_table_list);
12269 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id);
12275 shost->unique_id = ioc->id;
12277 if (ioc->is_mcpu_endpoint) {
12280 ioc_info(ioc, "The max_sectors value is set to %d\n",
12286 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n",
12290 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n",
12294 ioc_info(ioc, "The max_sectors value is set to %d\n",
12310 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
12311 "fw_event_%s%d", ioc->driver_name, ioc->id);
12312 ioc->firmware_event_thread = alloc_ordered_workqueue(
12313 ioc->firmware_event_name, 0);
12314 if (!ioc->firmware_event_thread) {
12315 ioc_err(ioc, "failure at %s:%d/%s()!\n",
12323 if (ioc->is_gen35_ioc && host_tagset_enable)
12326 ioc->is_driver_loading = 1;
12327 if ((mpt3sas_base_attach(ioc))) {
12328 ioc_err(ioc, "failure at %s:%d/%s()!\n",
12334 if (ioc->is_warpdrive) {
12335 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS)
12336 ioc->hide_drives = 0;
12337 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS)
12338 ioc->hide_drives = 1;
12340 if (mpt3sas_get_num_volumes(ioc))
12341 ioc->hide_drives = 1;
12343 ioc->hide_drives = 0;
12346 ioc->hide_drives = 0;
12352 ioc->reply_queue_count - ioc->high_iops_queues;
12355 ioc->reply_queue_count - ioc->iopoll_q_start_index;
12359 dev_info(&ioc->pdev->dev,
12366 ioc_err(ioc, "failure at %s:%d/%s()!\n",
12372 mpt3sas_setup_debugfs(ioc);
12375 mpt3sas_base_detach(ioc);
12377 destroy_workqueue(ioc->firmware_event_thread);
12380 list_del(&ioc->list);
12397 struct MPT3SAS_ADAPTER *ioc;
12400 rc = _scsih_get_shost_and_ioc(pdev, &shost, &ioc);
12404 mpt3sas_base_stop_watchdog(ioc);
12406 _scsih_nvme_shutdown(ioc);
12407 ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state\n",
12410 mpt3sas_base_free_resources(ioc);
12425 struct MPT3SAS_ADAPTER *ioc;
12429 r = _scsih_get_shost_and_ioc(pdev, &shost, &ioc);
12433 ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
12436 ioc->pdev = pdev;
12437 r = mpt3sas_base_map_resources(ioc);
12440 ioc_info(ioc, "Issuing Hard Reset as part of OS Resume\n");
12441 mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET);
12443 mpt3sas_base_start_watchdog(ioc);
12460 struct MPT3SAS_ADAPTER *ioc;
12462 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12465 ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state);
12472 ioc->pci_error_recovery = 1;
12473 scsi_block_requests(ioc->shost);
12474 mpt3sas_base_stop_watchdog(ioc);
12475 mpt3sas_base_free_resources(ioc);
12479 ioc->pci_error_recovery = 1;
12480 mpt3sas_base_stop_watchdog(ioc);
12481 mpt3sas_base_pause_mq_polling(ioc);
12482 _scsih_flush_running_cmds(ioc);
12500 struct MPT3SAS_ADAPTER *ioc;
12503 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12506 ioc_info(ioc, "PCI error: slot reset callback!!\n");
12508 ioc->pci_error_recovery = 0;
12509 ioc->pdev = pdev;
12511 rc = mpt3sas_base_map_resources(ioc);
12515 ioc_info(ioc, "Issuing Hard Reset as part of PCI Slot Reset\n");
12516 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
12518 ioc_warn(ioc, "hard reset: %s\n",
12539 struct MPT3SAS_ADAPTER *ioc;
12541 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12544 ioc_info(ioc, "PCI error: resume callback!!\n");
12546 mpt3sas_base_start_watchdog(ioc);
12547 scsi_unblock_requests(ioc->shost);
12558 struct MPT3SAS_ADAPTER *ioc;
12560 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12563 ioc_info(ioc, "PCI error: mmio enabled callback!!\n");