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))
2510 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2534 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2535 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
2536 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2538 dfailprintk(ioc,
2539 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2544 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
2545 dfailprintk(ioc,
2546 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2554 mpt3sas_init_warpdrive_properties(ioc, raid_device);
2580 if (ioc->manu_pg10.OEMIdentifier &&
2581 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
2603 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;
2682 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2691 ioc->page_size - 1);
2695 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2696 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
2700 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2701 dfailprintk(ioc,
2702 ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2711 ioc->max_wideport_qd : ioc->max_narrowport_qd;
2723 qdepth = ioc->max_sata_qd;
2739 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2742 _scsih_display_sata_capabilities(ioc, handle, sdev);
2749 _scsih_enable_tlr(ioc, sdev);
2803 * @ioc: per adapter object
2807 _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
2840 ioc_warn(ioc, "response_code(0x%01x): %s\n", response_code, desc);
2845 * @ioc: per adapter object
2857 _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2861 if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
2863 if (ioc->tm_cmds.smid != smid)
2865 ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
2866 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
2868 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2869 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
2871 ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
2872 complete(&ioc->tm_cmds.done);
2878 * @ioc: per adapter object
2884 mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2890 shost_for_each_device(sdev, ioc->shost) {
2899 ioc->ignore_loginfos = 1;
2906 * @ioc: per adapter object
2912 mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2918 shost_for_each_device(sdev, ioc->shost) {
2927 ioc->ignore_loginfos = 0;
2934 * @ioc: per adapter object
2945 scsih_tm_cmd_map_status(struct MPT3SAS_ADAPTER *ioc, uint channel,
2949 if (smid_task <= ioc->shost->can_queue) {
2952 if (!(_scsih_scsi_lookup_find_by_target(ioc,
2958 if (!(_scsih_scsi_lookup_find_by_lun(ioc, id,
2965 } else if (smid_task == ioc->scsih_cmds.smid) {
2966 if ((ioc->scsih_cmds.status & MPT3_CMD_COMPLETE) ||
2967 (ioc->scsih_cmds.status & MPT3_CMD_NOT_USED))
2969 } else if (smid_task == ioc->ctl_cmds.smid) {
2970 if ((ioc->ctl_cmds.status & MPT3_CMD_COMPLETE) ||
2971 (ioc->ctl_cmds.status & MPT3_CMD_NOT_USED))
2980 * @ioc: per adapter object
2996 scsih_tm_post_processing(struct MPT3SAS_ADAPTER *ioc, u16 handle,
3001 rc = scsih_tm_cmd_map_status(ioc, channel, id, lun, type, smid_task);
3005 ioc_info(ioc,
3015 mpt3sas_base_mask_interrupts(ioc);
3016 mpt3sas_base_sync_reply_irqs(ioc, 1);
3017 mpt3sas_base_unmask_interrupts(ioc);
3019 return scsih_tm_cmd_map_status(ioc, channel, id, lun, type, smid_task);
3024 * @ioc: per adapter struct
3038 * The callback index is set inside `ioc->tm_cb_idx`.
3044 mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel,
3056 lockdep_assert_held(&ioc->tm_cmds.mutex);
3058 if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
3059 ioc_info(ioc, "%s: tm_cmd busy!!!\n", __func__);
3063 if (ioc->shost_recovery || ioc->remove_host ||
3064 ioc->pci_error_recovery) {
3065 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
3069 ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
3071 dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
3072 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3077 mpt3sas_print_fault_code(ioc, ioc_state &
3079 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3083 mpt3sas_print_coredump_info(ioc, ioc_state &
3085 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3089 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
3091 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
3095 dtmprintk(ioc,
3096 ioc_info(ioc, "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n",
3098 ioc->tm_cmds.status = MPT3_CMD_PENDING;
3099 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3100 ioc->tm_cmds.smid = smid;
3102 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
3111 mpt3sas_scsih_set_tm_flag(ioc, handle);
3112 init_completion(&ioc->tm_cmds.done);
3113 ioc->put_smid_hi_priority(ioc, smid, msix_task);
3114 wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
3115 if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
3116 mpt3sas_check_cmd_timeout(ioc,
3117 ioc->tm_cmds.status, mpi_request,
3120 rc = mpt3sas_base_hard_reset_handler(ioc,
3128 mpt3sas_base_sync_reply_irqs(ioc, 0);
3130 if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
3131 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
3132 mpi_reply = ioc->tm_cmds.reply;
3133 dtmprintk(ioc,
3134 ioc_info(ioc, "complete tm: ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
3138 if (ioc->logging_level & MPT_DEBUG_TM) {
3139 _scsih_response_code(ioc, mpi_reply->ResponseCode);
3160 request = mpt3sas_base_get_msg_frame(ioc, smid_task);
3164 ioc_info(ioc, "Task abort tm failed: handle(0x%04x),"
3173 rc = scsih_tm_post_processing(ioc, handle, channel, id, lun,
3185 mpt3sas_scsih_clear_tm_flag(ioc, handle);
3186 ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
3190 int mpt3sas_scsih_issue_locked_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle,
3196 mutex_lock(&ioc->tm_cmds.mutex);
3197 ret = mpt3sas_scsih_issue_tm(ioc, handle, channel, id, lun, type,
3199 mutex_unlock(&ioc->tm_cmds.mutex);
3206 * @ioc: per adapter struct
3212 _scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
3223 if (ioc->hide_ir_msg)
3236 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
3237 pcie_device = __mpt3sas_get_pdev_from_target(ioc, priv_target);
3257 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
3260 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3261 sas_device = __mpt3sas_get_sdev_from_target(ioc, priv_target);
3282 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3295 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3307 _scsih_tm_display_info(ioc, scmd);
3311 ioc->remove_host) {
3338 mpt3sas_halt_firmware(ioc);
3341 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3342 if (pcie_device && (!ioc->tm_custom_handling) &&
3344 timeout = ioc->nvme_abort_timeout;
3345 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel,
3369 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3383 _scsih_tm_display_info(ioc, scmd);
3387 ioc->remove_host) {
3400 sas_device = mpt3sas_get_sdev_from_target(ioc,
3413 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3415 if (pcie_device && (!ioc->tm_custom_handling) &&
3422 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel,
3450 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3463 _scsih_tm_display_info(ioc, scmd);
3467 ioc->remove_host) {
3480 sas_device = mpt3sas_get_sdev_from_target(ioc,
3493 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3495 if (pcie_device && (!ioc->tm_custom_handling) &&
3501 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel,
3529 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3532 ioc_info(ioc, "attempting host reset! scmd(0x%p)\n", scmd);
3535 if (ioc->is_driver_loading || ioc->remove_host) {
3536 ioc_info(ioc, "Blocking the host reset\n");
3541 retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3544 ioc_info(ioc, "host reset: %s scmd(0x%p)\n",
3552 * @ioc: per adapter object
3554 * Context: This function will acquire ioc->fw_event_lock.
3560 _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
3564 if (ioc->firmware_event_thread == NULL)
3567 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3570 list_add_tail(&fw_event->list, &ioc->fw_event_list);
3573 queue_work(ioc->firmware_event_thread, &fw_event->work);
3574 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3579 * @ioc: per adapter object
3581 * Context: This function will acquire ioc->fw_event_lock.
3586 _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
3591 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3596 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3602 * @ioc: per adapter object
3606 mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
3612 if (ioc->is_driver_loading)
3619 fw_event->ioc = ioc;
3621 _scsih_fw_event_add(ioc, fw_event);
3627 * @ioc: per adapter object
3630 _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
3638 fw_event->ioc = ioc;
3639 _scsih_fw_event_add(ioc, fw_event);
3645 * @ioc: per adapter object
3648 mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
3656 fw_event->ioc = ioc;
3657 _scsih_fw_event_add(ioc, fw_event);
3661 static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc)
3666 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3667 if (!list_empty(&ioc->fw_event_list)) {
3668 fw_event = list_first_entry(&ioc->fw_event_list,
3673 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3680 * @ioc: per adapter object
3688 _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
3692 if ((list_empty(&ioc->fw_event_list) && !ioc->current_event) ||
3693 !ioc->firmware_event_thread)
3701 if (ioc->shost_recovery && ioc->current_event)
3702 ioc->current_event->ignore = 1;
3704 ioc->fw_events_cleanup = 1;
3705 while ((fw_event = dequeue_next_fw_event(ioc)) ||
3706 (fw_event = ioc->current_event)) {
3722 if (fw_event == ioc->current_event &&
3723 ioc->current_event->event !=
3725 ioc->current_event = NULL;
3730 * Driver has to clear ioc->start_scan flag when
3738 ioc->port_enable_cmds.status |= MPT3_CMD_RESET;
3739 ioc->start_scan = 0;
3754 ioc->fw_events_cleanup = 0;
3828 * @ioc: per adapter object
3833 _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3838 shost_for_each_device(sdev, ioc->shost) {
3845 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3855 * @ioc: per adapter object
3862 _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc,
3868 shost_for_each_device(sdev, ioc->shost) {
3885 * @ioc: per adapter object
3890 _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3895 shost_for_each_device(sdev, ioc->shost) {
3913 * @ioc: per adapter object
3919 _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3925 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
3927 shost_for_each_device(sdev, ioc->shost) {
3952 * @ioc: per adapter object
3960 _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
3975 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3976 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
3981 ioc->blocking_handles);
3984 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3997 ioc, mpt3sas_port->remote_identify.sas_address,
3999 _scsih_block_io_to_children_attached_to_ex(ioc,
4007 * @ioc: per adapter object
4014 _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
4028 _scsih_block_io_device(ioc, handle);
4034 * @ioc: per adapter object
4041 _scsih_block_io_to_pcie_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
4056 _scsih_block_io_device(ioc, handle);
4061 * @ioc: per adapter object
4075 _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4089 if (ioc->pci_error_recovery) {
4090 dewtprintk(ioc,
4091 ioc_info(ioc, "%s: host in pci error recovery: handle(0x%04x)\n",
4095 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4097 dewtprintk(ioc,
4098 ioc_info(ioc, "%s: host is not operational: handle(0x%04x)\n",
4104 if (test_bit(handle, ioc->pd_handles))
4107 clear_bit(handle, ioc->pend_os_device_add);
4109 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4110 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
4118 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4120 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
4121 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
4128 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
4129 if (pcie_device && (!ioc->tm_custom_handling) &&
4138 dewtprintk(ioc,
4139 ioc_info(ioc, "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
4143 dewtprintk(ioc,
4144 ioc_info(ioc, "setting delete flag:enclosure logical id(0x%016llx), slot(%d)\n",
4148 dewtprintk(ioc,
4149 ioc_info(ioc, "setting delete flag: enclosure level(0x%04x), connector name( %s)\n",
4154 dewtprintk(ioc,
4155 ioc_info(ioc, "setting delete flag: logical id(0x%016llx), slot(%d)\n",
4159 dewtprintk(ioc,
4160 ioc_info(ioc, "setting delete flag:, enclosure level(0x%04x), connector name( %s)\n",
4164 _scsih_ublock_io_device(ioc, sas_address, port);
4168 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
4175 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
4176 dewtprintk(ioc,
4177 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4182 dewtprintk(ioc,
4183 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4184 handle, smid, ioc->tm_tr_cb_idx));
4185 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4191 set_bit(handle, ioc->device_remove_in_progress);
4192 ioc->put_smid_hi_priority(ioc, smid, 0);
4193 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
4204 * @ioc: per adapter object
4219 _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
4225 mpt3sas_base_get_reply_virt_addr(ioc, reply);
4231 if (ioc->pci_error_recovery) {
4232 dewtprintk(ioc,
4233 ioc_info(ioc, "%s: host in pci error recovery\n",
4237 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4239 dewtprintk(ioc,
4240 ioc_info(ioc, "%s: host is not operational\n",
4245 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
4249 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
4252 dewtprintk(ioc,
4253 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
4259 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
4260 dewtprintk(ioc,
4261 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
4266 smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
4270 return _scsih_check_for_pending_tm(ioc, smid);
4273 list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list);
4274 dewtprintk(ioc,
4275 ioc_info(ioc, "DELAYED:sc:handle(0x%04x), (open)\n",
4277 return _scsih_check_for_pending_tm(ioc, smid);
4280 dewtprintk(ioc,
4281 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4282 handle, smid_sas_ctrl, ioc->tm_sas_control_cb_idx));
4283 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
4288 ioc->put_smid_default(ioc, smid_sas_ctrl);
4290 return _scsih_check_for_pending_tm(ioc, smid);
4295 * @ioc: per adapter object
4300 inline bool _scsih_allow_scmd_to_device(struct MPT3SAS_ADAPTER *ioc,
4304 if (ioc->pci_error_recovery)
4307 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) {
4308 if (ioc->remove_host)
4314 if (ioc->remove_host) {
4330 * @ioc: per adapter object
4344 _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
4348 mpt3sas_base_get_reply_virt_addr(ioc, reply);
4351 dewtprintk(ioc,
4352 ioc_info(ioc, "sc_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
4359 ioc->device_remove_in_progress);
4362 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
4365 return mpt3sas_check_for_pending_internal_cmds(ioc, smid);
4370 * @ioc: per adapter object
4379 _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4385 if (ioc->pci_error_recovery) {
4386 dewtprintk(ioc,
4387 ioc_info(ioc, "%s: host reset in progress!\n",
4392 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
4399 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
4400 dewtprintk(ioc,
4401 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4406 dewtprintk(ioc,
4407 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4408 handle, smid, ioc->tm_tr_volume_cb_idx));
4409 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4414 ioc->put_smid_hi_priority(ioc, smid, 0);
4419 * @ioc: per adapter object
4429 _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
4435 mpt3sas_base_get_reply_virt_addr(ioc, reply);
4437 if (ioc->shost_recovery || ioc->pci_error_recovery) {
4438 dewtprintk(ioc,
4439 ioc_info(ioc, "%s: host reset in progress!\n",
4444 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
4449 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
4452 dewtprintk(ioc,
4453 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
4459 dewtprintk(ioc,
4460 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
4465 return _scsih_check_for_pending_tm(ioc, smid);
4470 * @ioc: per adapter object
4478 _scsih_issue_delayed_event_ack(struct MPT3SAS_ADAPTER *ioc, u16 smid, U16 event,
4482 int i = smid - ioc->internal_smid;
4489 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4490 ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx;
4491 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4493 dewtprintk(ioc,
4494 ioc_info(ioc, "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n",
4495 le16_to_cpu(event), smid, ioc->base_cb_idx));
4496 ack_request = mpt3sas_base_get_msg_frame(ioc, smid);
4503 ioc->put_smid_default(ioc, smid);
4509 * @ioc: per adapter object
4516 _scsih_issue_delayed_sas_io_unit_ctrl(struct MPT3SAS_ADAPTER *ioc,
4521 int i = smid - ioc->internal_smid;
4524 if (ioc->remove_host) {
4525 dewtprintk(ioc,
4526 ioc_info(ioc, "%s: host has been removed\n",
4529 } else if (ioc->pci_error_recovery) {
4530 dewtprintk(ioc,
4531 ioc_info(ioc, "%s: host in pci error recovery\n",
4535 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4537 dewtprintk(ioc,
4538 ioc_info(ioc, "%s: host is not operational\n",
4547 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4548 ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx;
4549 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4551 dewtprintk(ioc,
4552 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4553 handle, smid, ioc->tm_sas_control_cb_idx));
4554 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4559 ioc->put_smid_default(ioc, smid);
4564 * @ioc: per adapter object
4576 mpt3sas_check_for_pending_internal_cmds(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4581 if (!list_empty(&ioc->delayed_event_ack_list)) {
4582 delayed_event_ack = list_entry(ioc->delayed_event_ack_list.next,
4584 _scsih_issue_delayed_event_ack(ioc, smid,
4591 if (!list_empty(&ioc->delayed_sc_list)) {
4592 delayed_sc = list_entry(ioc->delayed_sc_list.next,
4594 _scsih_issue_delayed_sas_io_unit_ctrl(ioc, smid,
4605 * @ioc: per adapter object
4615 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4619 if (!list_empty(&ioc->delayed_tr_volume_list)) {
4620 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
4622 mpt3sas_base_free_smid(ioc, smid);
4623 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
4629 if (!list_empty(&ioc->delayed_tr_list)) {
4630 delayed_tr = list_entry(ioc->delayed_tr_list.next,
4632 mpt3sas_base_free_smid(ioc, smid);
4633 _scsih_tm_tr_send(ioc, delayed_tr->handle);
4644 * @ioc: per adapter object
4654 _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
4672 _scsih_tm_tr_send(ioc, handle);
4676 if (expander_handle < ioc->sas_hba.num_phys) {
4677 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4683 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4684 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
4686 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
4687 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4689 handle = find_first_bit(ioc->blocking_handles,
4690 ioc->facts.MaxDevHandle);
4691 if (handle < ioc->facts.MaxDevHandle)
4692 _scsih_block_io_device(ioc, handle);
4693 } while (test_and_clear_bit(handle, ioc->blocking_handles));
4695 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4701 spin_lock_irqsave(&ioc->fw_event_lock, flags);
4702 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4714 dewtprintk(ioc,
4715 ioc_info(ioc, "setting ignoring flag\n"));
4720 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4726 * @ioc: per adapter object
4735 _scsih_check_pcie_topo_remove_events(struct MPT3SAS_ADAPTER *ioc,
4751 _scsih_tm_tr_send(ioc, handle);
4757 ioc, event_data);
4766 ioc, event_data);
4772 spin_lock_irqsave(&ioc->fw_event_lock, flags);
4773 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4786 dewtprintk(ioc,
4787 ioc_info(ioc, "setting ignoring flag for switch event\n"));
4792 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4797 * @ioc: per adapter object
4803 _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4809 spin_lock_irqsave(&ioc->raid_device_lock, flags);
4810 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
4816 dewtprintk(ioc,
4817 ioc_info(ioc, "setting delete flag: handle(0x%04x), wwid(0x%016llx)\n",
4820 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4846 * @ioc: per adapter object
4857 _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
4868 if (ioc->is_warpdrive)
4882 _scsih_set_volume_delete_flag(ioc, volume_handle);
4900 _scsih_tm_tr_volume_send(ioc, a);
4902 _scsih_tm_tr_volume_send(ioc, b);
4911 clear_bit(handle, ioc->pd_handles);
4913 _scsih_tm_tr_send(ioc, handle);
4919 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
4920 dewtprintk(ioc,
4921 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4924 _scsih_tm_tr_send(ioc, handle);
4931 * @ioc: per adapter object
4940 _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
4950 _scsih_set_volume_delete_flag(ioc,
4956 * @ioc: per adapter object
4961 _scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
4965 if (ioc->temp_sensors_count >= event_data->SensorNum) {
4966 ioc_err(ioc, "Temperature Threshold flags %s%s%s%s exceeded for Sensor: %d !!!\n",
4972 ioc_err(ioc, "Current Temp In Celsius: %d\n",
4974 if (ioc->hba_mpi_version_belonged != MPI2_VERSION) {
4975 doorbell = mpt3sas_base_get_iocstate(ioc, 0);
4978 mpt3sas_print_fault_code(ioc,
4982 mpt3sas_print_coredump_info(ioc,
5005 * @ioc: per adapter object
5011 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
5018 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5019 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
5025 mpt3sas_base_clear_st(ioc, st);
5027 if (ioc->pci_error_recovery || ioc->remove_host)
5033 dtmprintk(ioc, ioc_info(ioc, "completing %d cmds\n", count));
5038 * @ioc: per adapter object
5045 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
5078 if (ioc->is_gen35_ioc)
5086 * @ioc_status: ioc status
5116 * The callback index is set inside `ioc->scsi_io_cb_idx`.
5125 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
5137 if (ioc->logging_level & MPT_DEBUG_SCSI)
5147 if (!(_scsih_allow_scmd_to_device(ioc, scmd))) {
5177 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) {
5219 if (((!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev))
5224 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
5226 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
5230 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5231 memset(mpi_request, 0, ioc->request_sz);
5232 _scsih_setup_eedp(ioc, scmd, mpi_request);
5249 mpt3sas_base_get_sense_buffer_dma(ioc, smid);
5257 if (ioc->build_sg_scmd(ioc, scmd, smid, pcie_device)) {
5258 mpt3sas_base_free_smid(ioc, smid);
5263 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
5267 mpt3sas_setup_direct_io(ioc, scmd,
5274 ioc->put_smid_fast_path(ioc, smid, handle);
5276 ioc->put_smid_scsi_io(ioc, smid,
5279 ioc->put_smid_default(ioc, smid);
5309 * @ioc: per adapter object
5315 * scsi_state - state info associated with SCSI_IO determined by ioc
5316 * ioc_status - ioc supplied status info
5319 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
5330 char *desc_scsi_state = ioc->tmp_string;
5340 if (ioc->hide_ir_msg)
5386 desc_ioc_state = "scsi ioc terminated";
5464 ioc_warn(ioc, "\t%s wwid(0x%016llx)\n",
5467 pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target);
5469 ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n",
5472 ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n",
5476 ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n",
5482 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
5484 ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
5487 _scsih_display_enclosure_chassis_info(ioc, sas_device,
5494 ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
5497 ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n",
5499 ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
5502 ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
5508 ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
5515 _scsih_response_code(ioc, response_bytes[0]);
5521 * @ioc: per adapter object
5526 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5532 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
5543 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5545 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5552 dewtprintk(ioc,
5553 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5564 * @ioc: per adapter object
5569 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
5583 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5585 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5591 dewtprintk(ioc,
5592 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5601 * @ioc: per adapter object
5606 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5615 fw_event->ioc = ioc;
5616 _scsih_fw_event_add(ioc, fw_event);
5622 * @ioc: per adapter object
5627 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5638 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5639 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
5652 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5654 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
5655 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
5662 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5679 mpt3sas_ctl_add_to_event_log(ioc, event_reply);
5687 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5693 * @ioc: per adapter object
5704 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5718 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
5720 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
5726 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5754 ioc->put_smid_scsi_io(ioc, smid,
5765 if ((!ioc->is_warpdrive &&
5793 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
5801 _scsih_smart_predicted_fault(ioc,
5803 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
5805 if ((ioc->logging_level & MPT_DEBUG_REPLY) &&
5809 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid);
5919 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
5920 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
5925 mpt3sas_base_free_smid(ioc, smid);
5933 * @ioc: per adapter object
5938 _scsih_update_vphys_after_reset(struct MPT3SAS_ADAPTER *ioc)
5956 &ioc->port_table_list, list) {
5968 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
5971 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5975 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
5984 for (i = 0; i < ioc->sas_hba.num_phys; i++) {
6003 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
6005 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6018 if (_scsih_get_sas_address(ioc, attached_handle,
6020 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6032 port_next, &ioc->port_table_list, list) {
6065 mport = mpt3sas_get_port_by_id(ioc, port_id, 1);
6072 ioc_info(ioc,
6076 &ioc->port_table_list);
6094 ioc, attached_sas_addr, port);
6129 * @ioc: per adapter object
6135 _scsih_get_port_table_after_reset(struct MPT3SAS_ADAPTER *ioc,
6146 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
6149 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6154 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
6160 for (i = 0; i < ioc->sas_hba.num_phys; i++) {
6168 ioc, attached_handle, &attached_sas_addr) != 0) {
6169 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6209 * @ioc: per adapter object
6218 _scsih_look_and_get_matched_port_entry(struct MPT3SAS_ADAPTER *ioc,
6227 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) {
6277 *@ioc: per adapter object
6285 _scsih_del_phy_part_of_anther_port(struct MPT3SAS_ADAPTER *ioc,
6289 struct _sas_node *sas_node = &ioc->sas_hba;
6298 ioc, sas_node, &sas_node->phy[offset]);
6310 *@ioc: per adapter object
6318 _scsih_add_or_del_phys_from_existing_port(struct MPT3SAS_ADAPTER *ioc,
6323 struct _sas_node *sas_node = &ioc->sas_hba;
6327 for (offset = 0; offset < ioc->sas_hba.num_phys; offset++) {
6331 ioc, port_table, index, port_count,
6337 ioc, sas_node, &sas_node->phy[offset]);
6339 ioc, sas_node, &sas_node->phy[offset],
6348 * @ioc: per adapter object
6353 _scsih_del_dirty_vphy(struct MPT3SAS_ADAPTER *ioc)
6359 &ioc->port_table_list, list) {
6365 drsprintk(ioc, ioc_info(ioc,
6382 *@ioc: per adapter object
6386 _scsih_del_dirty_port_entries(struct MPT3SAS_ADAPTER *ioc)
6391 &ioc->port_table_list, list) {
6396 drsprintk(ioc, ioc_info(ioc,
6406 * @ioc: per adapter object
6409 _scsih_sas_port_refresh(struct MPT3SAS_ADAPTER *ioc)
6420 drsprintk(ioc, ioc_info(ioc,
6422 (unsigned long long)ioc->sas_hba.sas_address));
6424 mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
6426 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6431 if (num_phys > ioc->sas_hba.nr_phys_allocated) {
6432 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6436 ioc->sas_hba.num_phys = num_phys;
6438 port_table = kcalloc(ioc->sas_hba.num_phys,
6443 port_count = _scsih_get_port_table_after_reset(ioc, port_table);
6447 drsprintk(ioc, ioc_info(ioc, "New Port table\n"));
6449 drsprintk(ioc, ioc_info(ioc,
6454 list_for_each_entry(port_table_entry, &ioc->port_table_list, list)
6457 drsprintk(ioc, ioc_info(ioc, "Old Port table\n"));
6459 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) {
6460 drsprintk(ioc, ioc_info(ioc,
6468 ret = _scsih_look_and_get_matched_port_entry(ioc,
6471 drsprintk(ioc, ioc_info(ioc,
6481 _scsih_add_or_del_phys_from_existing_port(ioc,
6494 _scsih_add_or_del_phys_from_existing_port(ioc,
6512 * @ioc: per adapter object
6519 _scsih_alloc_vphy(struct MPT3SAS_ADAPTER *ioc, u8 port_id, u8 phy_num)
6524 port = mpt3sas_get_port_by_id(ioc, port_id, 0);
6528 vphy = mpt3sas_get_vphy_by_phy(ioc, port, phy_num);
6546 ioc_info(ioc,
6555 * @ioc: per adapter object
6563 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
6575 dtmprintk(ioc,
6576 ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n",
6577 (u64)ioc->sas_hba.sas_address));
6579 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
6582 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6587 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
6593 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
6596 ioc->sas_hba.handle = le16_to_cpu(
6599 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) {
6605 ioc_info(ioc,
6608 if (ioc->shost_recovery)
6610 list_add_tail(&port->list, &ioc->port_table_list);
6618 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply,
6620 ioc_err(ioc,
6632 if (!_scsih_alloc_vphy(ioc, port_id, i))
6634 ioc->sas_hba.phy[i].hba_vphy = 1;
6641 if (!ioc->sas_hba.phy[i].phy) {
6642 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply,
6644 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6651 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6655 ioc->sas_hba.phy[i].phy_id = i;
6656 mpt3sas_transport_add_host_phy(ioc,
6657 &ioc->sas_hba.phy[i], phy_pg0,
6658 ioc->sas_hba.parent_dev);
6661 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
6666 ioc->sas_hba.phy[i].port =
6667 mpt3sas_get_port_by_id(ioc, port_id, 0);
6668 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
6670 ioc->sas_hba.phy[i].port);
6676 for (i = ioc->sas_hba.num_phys;
6677 i < ioc->sas_hba.nr_phys_allocated; i++) {
6678 if (ioc->sas_hba.phy[i].phy &&
6679 ioc->sas_hba.phy[i].phy->negotiated_linkrate >=
6681 mpt3sas_transport_update_links(ioc,
6682 ioc->sas_hba.sas_address, 0, i,
6691 * @ioc: per adapter object
6693 * Creating host side data object, stored in ioc->sas_hba
6696 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
6711 mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
6713 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6718 ioc->sas_hba.nr_phys_allocated = max_t(u8,
6720 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.nr_phys_allocated,
6722 if (!ioc->sas_hba.phy) {
6723 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6727 ioc->sas_hba.num_phys = num_phys;
6730 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys);
6733 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6737 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
6739 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6746 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6752 sz = struct_size(sas_iounit_pg1, PhyData, ioc->sas_hba.num_phys);
6755 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6759 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
6761 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6768 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6773 ioc->io_missing_delay =
6778 ioc->device_missing_delay = (device_missing_delay &
6781 ioc->device_missing_delay = device_missing_delay &
6784 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
6785 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
6786 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
6788 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6795 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6801 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
6805 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) {
6811 ioc_info(ioc,
6815 &ioc->port_table_list);
6828 if (!_scsih_alloc_vphy(ioc, port_id, i))
6830 ioc->sas_hba.phy[i].hba_vphy = 1;
6833 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
6834 ioc->sas_hba.phy[i].phy_id = i;
6835 ioc->sas_hba.phy[i].port =
6836 mpt3sas_get_port_by_id(ioc, port_id, 0);
6837 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
6838 phy_pg0, ioc->sas_hba.parent_dev);
6840 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6841 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
6842 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6846 ioc->sas_hba.enclosure_handle =
6848 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
6849 ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
6850 ioc->sas_hba.handle,
6851 (u64)ioc->sas_hba.sas_address,
6852 ioc->sas_hba.num_phys);
6854 if (ioc->sas_hba.enclosure_handle) {
6855 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
6857 ioc->sas_hba.enclosure_handle)))
6858 ioc->sas_hba.enclosure_logical_id =
6869 * @ioc: per adapter object
6872 * Creating expander object, stored in ioc->sas_expander_list.
6877 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6897 if (ioc->shost_recovery || ioc->pci_error_recovery)
6900 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
6902 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6910 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6917 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
6919 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6925 if (sas_address_parent != ioc->sas_hba.sas_address) {
6926 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6927 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
6929 mpt3sas_get_port_by_id(ioc, port_id, 0));
6930 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6932 rc = _scsih_expander_add(ioc, parent_handle);
6938 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6940 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
6941 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0));
6942 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6950 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6959 sas_expander->port = mpt3sas_get_port_by_id(ioc, port_id, 0);
6961 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6967 ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
6978 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6985 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
6988 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6997 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
6999 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7007 mpt3sas_get_port_by_id(ioc, port_id, 0);
7009 if ((mpt3sas_transport_add_expander_phy(ioc,
7012 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7021 mpt3sas_scsih_enclosure_find_by_handle(ioc,
7028 _scsih_expander_node_add(ioc, sas_expander);
7034 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
7042 * @ioc: per adapter object
7047 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
7053 if (ioc->shost_recovery)
7059 spin_lock_irqsave(&ioc->sas_node_lock, flags);
7060 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
7062 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7064 _scsih_expander_node_remove(ioc, sas_expander);
7069 * @ioc: per adapter object
7075 * The callback index passed is `ioc->scsih_cb_idx`
7081 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
7085 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
7086 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
7088 if (ioc->scsih_cmds.smid != smid)
7090 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
7092 memcpy(ioc->scsih_cmds.reply, mpi_reply,
7094 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
7096 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
7097 complete(&ioc->scsih_cmds.done);
7109 * @ioc: per adapter object
7117 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
7165 ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
7172 * @ioc: per adapter object
7179 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
7194 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
7213 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7215 port = mpt3sas_get_port_by_id(ioc, sas_device_pg0.PhysicalPort, 0);
7218 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
7247 enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle(ioc,
7264 ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n",
7270 if (_scsih_check_access_status(ioc, sas_address, handle,
7274 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7275 _scsih_ublock_io_device(ioc, sas_address, port);
7282 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7289 * @ioc: per adapter object
7294 * Creating end device object, stored in ioc->sas_device_list.
7299 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
7311 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
7313 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7321 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7330 set_bit(handle, ioc->pend_os_device_add);
7336 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
7342 if (_scsih_check_access_status(ioc, sas_address, handle,
7347 sas_device = mpt3sas_get_sdev_by_addr(ioc,
7348 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0));
7350 clear_bit(handle, ioc->pend_os_device_add);
7357 mpt3sas_scsih_enclosure_find_by_handle(ioc,
7360 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
7367 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7374 if (_scsih_get_sas_address(ioc,
7377 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7389 sas_device->port = mpt3sas_get_port_by_id(ioc, port_id, 0);
7391 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7423 ioc_info(ioc,
7427 if (ioc->wait_for_discovery_to_complete)
7428 _scsih_sas_device_init_add(ioc, sas_device);
7430 _scsih_sas_device_add(ioc, sas_device);
7439 * @ioc: per adapter object
7443 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
7448 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
7450 _scsih_turn_off_pfa_led(ioc, sas_device);
7454 dewtprintk(ioc,
7455 ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
7459 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
7465 _scsih_ublock_io_device(ioc, sas_device->sas_address,
7471 if (!ioc->hide_drives)
7472 mpt3sas_transport_port_remove(ioc,
7477 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
7480 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
7482 dewtprintk(ioc,
7483 ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
7486 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
7492 * @ioc: per adapter object
7497 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7525 ioc_info(ioc, "sas topology change: (%s)\n", status_str);
7569 * @ioc: per adapter object
7575 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
7591 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7592 _scsih_sas_topology_change_event_debug(ioc, event_data);
7594 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
7597 if (!ioc->sas_hba.num_phys)
7598 _scsih_sas_host_add(ioc);
7600 _scsih_sas_host_refresh(ioc);
7603 dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n"));
7608 port = mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0);
7612 if (_scsih_expander_add(ioc, parent_handle) != 0)
7615 spin_lock_irqsave(&ioc->sas_node_lock, flags);
7616 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
7622 } else if (parent_handle < ioc->sas_hba.num_phys) {
7623 sas_address = ioc->sas_hba.sas_address;
7624 max_phys = ioc->sas_hba.num_phys;
7626 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7629 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7634 dewtprintk(ioc,
7635 ioc_info(ioc, "ignoring expander event\n"));
7638 if (ioc->remove_host || ioc->pci_error_recovery)
7657 if (ioc->shost_recovery)
7663 mpt3sas_transport_update_links(ioc, sas_address,
7669 _scsih_check_device(ioc, sas_address, handle,
7672 if (!test_bit(handle, ioc->pend_os_device_add))
7679 if (ioc->shost_recovery)
7682 mpt3sas_transport_update_links(ioc, sas_address,
7685 _scsih_add_device(ioc, handle, phy_number, 0);
7690 _scsih_device_remove_by_handle(ioc, handle);
7698 mpt3sas_expander_remove(ioc, sas_address, port);
7705 * @ioc: ?
7710 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7759 ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
7771 * @ioc: per adapter object
7776 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
7787 if ((ioc->facts.HeaderVersion >> 8) < 0xC)
7796 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7798 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
7800 mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0));
7815 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7816 ioc_info(ioc,
7825 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7831 * @ioc: per adapter object
7839 _scsih_check_pcie_access_status(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
7855 ioc_info(ioc,
7904 ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n",
7912 ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n",
7920 * @ioc: per adapter object
7924 _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
7929 dewtprintk(ioc,
7930 ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n",
7934 dewtprintk(ioc,
7935 ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
7940 dewtprintk(ioc,
7941 ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n",
7949 _scsih_ublock_io_device(ioc, pcie_device->wwid, NULL);
7953 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
7956 ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n",
7960 ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n",
7967 dewtprintk(ioc,
7968 ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n",
7972 dewtprintk(ioc,
7973 ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
7978 dewtprintk(ioc,
7979 ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n",
7990 * @ioc: per adapter object
7994 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
8006 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
8020 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8021 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
8024 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8053 ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n",
8055 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8061 if (_scsih_check_pcie_access_status(ioc, wwid, handle,
8063 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8068 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8071 _scsih_ublock_io_device(ioc, wwid, NULL);
8078 * @ioc: per adapter object
8081 * Creating end device object, stored in ioc->pcie_device_list.
8086 _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
8096 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
8098 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8105 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8110 set_bit(handle, ioc->pend_os_device_add);
8116 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
8122 if (_scsih_check_pcie_access_status(ioc, wwid, handle,
8130 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, wwid);
8132 clear_bit(handle, ioc->pend_os_device_add);
8143 if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply,
8146 ioc_err(ioc,
8155 ioc_err(ioc,
8164 ioc_err(ioc, "failure at %s:%d/%s()!\n",
8170 pcie_device->id = ioc->pcie_target_id++;
8198 mpt3sas_scsih_enclosure_find_by_handle(ioc,
8216 if (pcie_device->shutdown_latency > ioc->max_shutdown_latency)
8217 ioc->max_shutdown_latency =
8227 if (ioc->wait_for_discovery_to_complete)
8228 _scsih_pcie_device_init_add(ioc, pcie_device);
8230 _scsih_pcie_device_add(ioc, pcie_device);
8239 * @ioc: per adapter object
8244 _scsih_pcie_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
8272 ioc_info(ioc, "pcie topology change: (%s)\n", status_str);
8318 * @ioc: per adapter object
8324 _scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
8337 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
8338 _scsih_pcie_topology_change_event_debug(ioc, event_data);
8340 if (ioc->shost_recovery || ioc->remove_host ||
8341 ioc->pci_error_recovery)
8345 dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n"));
8352 dewtprintk(ioc,
8353 ioc_info(ioc, "ignoring switch event\n"));
8356 if (ioc->remove_host || ioc->pci_error_recovery)
8371 if (ioc->shost_recovery)
8378 _scsih_pcie_check_device(ioc, handle);
8386 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8387 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
8388 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8395 if (!test_bit(handle, ioc->pend_os_device_add))
8398 dewtprintk(ioc,
8399 ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n",
8406 if (ioc->shost_recovery)
8411 rc = _scsih_pcie_add_device(ioc, handle);
8423 _scsih_pcie_device_remove_by_handle(ioc, handle);
8431 * @ioc: ?
8436 _scsih_pcie_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
8483 ioc_info(ioc, "PCIE device status change: (%s)\n"
8497 * @ioc: per adapter object
8502 _scsih_pcie_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
8511 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
8512 _scsih_pcie_device_status_change_event_debug(ioc,
8521 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8523 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
8541 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8547 * @ioc: per adapter object
8552 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
8569 ioc_info(ioc, "enclosure status change: (%s)\n"
8579 * @ioc: per adapter object
8584 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
8594 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
8595 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
8598 if (ioc->shost_recovery)
8603 mpt3sas_scsih_enclosure_find_by_handle(ioc,
8612 ioc_info(ioc, "failure at %s:%d/%s()!\n",
8616 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
8628 &ioc->enclosure_list);
8644 * @ioc: per adapter object
8649 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
8670 mutex_lock(&ioc->tm_cmds.mutex);
8671 ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n",
8674 _scsih_block_io_all_device(ioc);
8676 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8677 mpi_reply = ioc->tm_cmds.reply;
8682 dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__));
8685 dewtprintk(ioc,
8686 ioc_info(ioc, "%s: %d retry\n",
8691 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
8692 if (ioc->shost_recovery)
8694 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
8719 if (ioc->shost_recovery)
8722 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
8723 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
8730 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8739 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8748 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8754 dewtprintk(ioc,
8755 ioc_info(ioc, "%s: ABORT_TASK: giving up\n",
8757 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8761 if (ioc->shost_recovery)
8764 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
8781 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
8784 if (ioc->broadcast_aen_pending) {
8785 dewtprintk(ioc,
8786 ioc_info(ioc,
8789 ioc->broadcast_aen_pending = 0;
8794 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
8797 dewtprintk(ioc,
8798 ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n",
8801 ioc->broadcast_aen_busy = 0;
8802 if (!ioc->shost_recovery)
8803 _scsih_ublock_io_all_device(ioc);
8804 mutex_unlock(&ioc->tm_cmds.mutex);
8809 * @ioc: per adapter object
8814 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
8820 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
8821 ioc_info(ioc, "discovery event: (%s)",
8831 !ioc->sas_hba.num_phys) {
8832 if (disable_discovery > 0 && ioc->shost_recovery) {
8834 while (ioc->shost_recovery)
8837 _scsih_sas_host_add(ioc);
8844 * @ioc: per adapter object
8849 _scsih_sas_device_discovery_error_event(struct MPT3SAS_ADAPTER *ioc,
8857 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n",
8863 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n",
8875 * @ioc: per adapter object
8880 _scsih_pcie_enumeration_event(struct MPT3SAS_ADAPTER *ioc,
8886 if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK))
8889 ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x",
8901 * @ioc: per adapter object
8908 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
8918 if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
8921 mutex_lock(&ioc->scsih_cmds.mutex);
8923 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
8924 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
8928 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
8930 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
8932 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
8933 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
8938 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
8939 ioc->scsih_cmds.smid = smid;
8946 dewtprintk(ioc,
8947 ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n",
8950 init_completion(&ioc->scsih_cmds.done);
8951 ioc->put_smid_default(ioc, smid);
8952 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
8954 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
8955 mpt3sas_check_cmd_timeout(ioc,
8956 ioc->scsih_cmds.status, mpi_request,
8962 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
8964 mpi_reply = ioc->scsih_cmds.reply;
8972 dewtprintk(ioc,
8973 ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n",
8977 dewtprintk(ioc,
8978 ioc_info(ioc, "IR RAID_ACTION: completed successfully\n"));
8982 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
8983 mutex_unlock(&ioc->scsih_cmds.mutex);
8986 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
9007 * @ioc: per adapter object
9012 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
9021 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
9023 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9028 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9029 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
9030 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9037 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9042 raid_device->id = ioc->sas_id++;
9046 _scsih_raid_device_add(ioc, raid_device);
9047 if (!ioc->wait_for_discovery_to_complete) {
9048 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9051 _scsih_raid_device_remove(ioc, raid_device);
9053 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9054 _scsih_determine_boot_device(ioc, raid_device, 1);
9055 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9061 * @ioc: per adapter object
9066 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
9073 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9074 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
9081 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
9086 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9093 * @ioc: per adapter object
9098 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
9107 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9108 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
9112 clear_bit(handle, ioc->pd_handles);
9120 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9133 * @ioc: per adapter object
9138 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
9149 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
9151 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
9154 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9155 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
9157 set_bit(handle, ioc->pd_handles);
9167 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9172 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
9182 * @ioc: per adapter object
9187 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
9192 _scsih_device_remove_by_handle(ioc, handle);
9197 * @ioc: per adapter object
9202 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
9213 set_bit(handle, ioc->pd_handles);
9215 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
9217 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
9222 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
9224 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9232 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9238 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
9239 mpt3sas_transport_update_links(ioc, sas_address, handle,
9241 mpt3sas_get_port_by_id(ioc,
9244 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
9245 _scsih_add_device(ioc, handle, 0, 1);
9250 * @ioc: per adapter object
9255 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
9265 ioc_info(ioc, "raid config change: (%s), elements(%d)\n",
9328 * @ioc: per adapter object
9333 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
9343 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
9344 (!ioc->hide_ir_msg))
9345 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
9351 if (ioc->shost_recovery &&
9352 ioc->hba_mpi_version_belonged != MPI2_VERSION) {
9355 _scsih_ir_fastpath(ioc,
9368 _scsih_sas_volume_add(ioc, element);
9373 _scsih_sas_volume_delete(ioc,
9377 if (!ioc->is_warpdrive)
9378 _scsih_sas_pd_hide(ioc, element);
9381 if (!ioc->is_warpdrive)
9382 _scsih_sas_pd_expose(ioc, element);
9385 if (!ioc->is_warpdrive)
9386 _scsih_sas_pd_add(ioc, element);
9389 if (!ioc->is_warpdrive)
9390 _scsih_sas_pd_delete(ioc, element);
9398 * @ioc: per adapter object
9403 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
9415 if (ioc->shost_recovery)
9423 if (!ioc->hide_ir_msg)
9424 dewtprintk(ioc,
9425 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
9432 _scsih_sas_volume_delete(ioc, handle);
9439 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9440 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
9441 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9446 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
9448 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9455 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9460 raid_device->id = ioc->sas_id++;
9464 _scsih_raid_device_add(ioc, raid_device);
9465 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9468 _scsih_raid_device_remove(ioc, raid_device);
9479 * @ioc: per adapter object
9484 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
9497 if (ioc->shost_recovery)
9506 if (!ioc->hide_ir_msg)
9507 dewtprintk(ioc,
9508 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
9520 if (!ioc->is_warpdrive)
9521 set_bit(handle, ioc->pd_handles);
9523 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
9529 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9532 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9540 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9546 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
9547 mpt3sas_transport_update_links(ioc, sas_address, handle,
9549 mpt3sas_get_port_by_id(ioc,
9552 _scsih_add_device(ioc, handle, 0, 1);
9566 * @ioc: per adapter object
9571 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
9597 ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n",
9605 * @ioc: per adapter object
9610 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
9620 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
9621 (!ioc->hide_ir_msg))
9622 _scsih_sas_ir_operation_status_event_debug(ioc,
9628 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9630 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
9634 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9640 * @ioc: per adapter object
9646 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
9651 shost_for_each_device(sdev, ioc->shost) {
9660 * @ioc: per adapter object
9664 _scsih_update_device_qdepth(struct MPT3SAS_ADAPTER *ioc)
9672 ioc_info(ioc, "Update devices with firmware reported queue depth\n");
9673 shost_for_each_device(sdev, ioc->shost) {
9679 qdepth = ioc->max_nvme_qd;
9683 ioc->max_wideport_qd : ioc->max_narrowport_qd;
9686 qdepth = ioc->max_sata_qd;
9696 * @ioc: per adapter object
9703 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc,
9712 ioc, sas_device_pg0->PhysicalPort, 0);
9716 mpt3sas_scsih_enclosure_find_by_handle(ioc,
9719 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
9722 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9723 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
9791 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9797 * @ioc: per adapter object
9800 _scsih_create_enclosure_list_after_reset(struct MPT3SAS_ADAPTER *ioc)
9808 mpt3sas_free_enclosure_list(ioc);
9816 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9820 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
9831 &ioc->enclosure_list);
9839 * @ioc: per adapter object
9845 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
9853 ioc_info(ioc, "search for end-devices: start\n");
9855 if (list_empty(&ioc->sas_device_list))
9859 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9870 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0);
9874 ioc_info(ioc, "search for end-devices: complete\n");
9879 * @ioc: per adapter object
9886 _scsih_mark_responding_pcie_device(struct MPT3SAS_ADAPTER *ioc,
9894 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
9895 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) {
9925 (ioc->hba_mpi_version_belonged != MPI2_VERSION)) {
9950 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
9955 * @ioc: per adapter object
9961 _scsih_search_responding_pcie_devices(struct MPT3SAS_ADAPTER *ioc)
9969 ioc_info(ioc, "search for end-devices: start\n");
9971 if (list_empty(&ioc->pcie_device_list))
9975 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
9981 ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n",
9990 _scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0);
9993 ioc_info(ioc, "search for PCIe end-devices: complete\n");
9998 * @ioc: per adapter object
10006 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
10014 spin_lock_irqsave(&ioc->raid_device_lock, flags);
10015 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
10024 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10034 mpt3sas_init_warpdrive_properties(ioc, raid_device);
10035 spin_lock_irqsave(&ioc->raid_device_lock, flags);
10037 spin_unlock_irqrestore(&ioc->raid_device_lock,
10046 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10050 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10055 * @ioc: per adapter object
10061 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
10071 if (!ioc->ir_firmware)
10074 ioc_info(ioc, "search for raid volumes: start\n");
10076 if (list_empty(&ioc->raid_device_list))
10080 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
10088 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
10096 _scsih_mark_responding_raid_device(ioc,
10101 if (!ioc->is_warpdrive) {
10103 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
10104 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
10113 set_bit(handle, ioc->pd_handles);
10117 ioc_info(ioc, "search for responding raid volumes: complete\n");
10122 * @ioc: per adapter object
10129 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc,
10140 ioc, expander_pg0->PhysicalPort, 0);
10144 mpt3sas_scsih_enclosure_find_by_handle(ioc,
10147 spin_lock_irqsave(&ioc->sas_node_lock, flags);
10148 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
10174 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
10179 * @ioc: per adapter object
10185 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
10194 ioc_info(ioc, "search for expanders: start\n");
10196 if (list_empty(&ioc->sas_expander_list))
10200 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
10214 (ioc->multipath_on_hba ?
10216 _scsih_mark_responding_expander(ioc, &expander_pg0);
10220 ioc_info(ioc, "search for expanders: complete\n");
10225 * @ioc: per adapter object
10228 _scsih_remove_unresponding_devices(struct MPT3SAS_ADAPTER *ioc)
10238 ioc_info(ioc, "removing unresponding devices: start\n");
10241 ioc_info(ioc, "removing unresponding devices: end-devices\n");
10246 spin_lock_irqsave(&ioc->sas_device_lock, flags);
10253 &ioc->sas_device_init_list, list) {
10259 &ioc->sas_device_list, list) {
10265 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
10271 _scsih_remove_device(ioc, sas_device);
10276 ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n");
10278 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
10284 &ioc->pcie_device_init_list, list) {
10290 &ioc->pcie_device_list, list) {
10296 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
10299 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
10305 if (ioc->ir_firmware) {
10306 ioc_info(ioc, "removing unresponding devices: volumes\n");
10308 &ioc->raid_device_list, list) {
10310 _scsih_sas_volume_delete(ioc,
10318 ioc_info(ioc, "removing unresponding devices: expanders\n");
10319 spin_lock_irqsave(&ioc->sas_node_lock, flags);
10322 &ioc->sas_expander_list, list) {
10328 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
10331 _scsih_expander_node_remove(ioc, sas_expander);
10334 ioc_info(ioc, "removing unresponding devices: complete\n");
10337 _scsih_ublock_io_all_device(ioc);
10341 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
10349 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
10351 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10356 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
10365 * @ioc: per adapter object
10368 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
10389 ioc_info(ioc, "scan devices: start\n");
10391 _scsih_sas_host_refresh(ioc);
10393 ioc_info(ioc, "\tscan devices: expanders start\n");
10397 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
10402 ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10407 spin_lock_irqsave(&ioc->sas_node_lock, flags);
10410 ioc, le64_to_cpu(expander_pg0.SASAddress),
10411 mpt3sas_get_port_by_id(ioc, port_id, 0));
10412 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
10414 _scsih_refresh_expander_links(ioc, expander_device,
10417 ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
10420 _scsih_expander_add(ioc, handle);
10421 ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
10427 ioc_info(ioc, "\tscan devices: expanders complete\n");
10429 if (!ioc->ir_firmware)
10432 ioc_info(ioc, "\tscan devices: phys disk start\n");
10436 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
10442 ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10448 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
10453 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
10460 ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n",
10465 if (!_scsih_get_sas_address(ioc, parent_handle,
10467 ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
10471 mpt3sas_transport_update_links(ioc, sas_address,
10474 mpt3sas_get_port_by_id(ioc, port_id, 0));
10475 set_bit(handle, ioc->pd_handles);
10481 while (_scsih_add_device(ioc, handle, retry_count++,
10485 ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
10491 ioc_info(ioc, "\tscan devices: phys disk complete\n");
10493 ioc_info(ioc, "\tscan devices: volumes start\n");
10497 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
10502 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10507 spin_lock_irqsave(&ioc->raid_device_lock, flags);
10508 raid_device = _scsih_raid_device_find_by_wwid(ioc,
10510 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
10513 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
10520 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10530 ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n",
10532 _scsih_sas_volume_add(ioc, &element);
10533 ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n",
10538 ioc_info(ioc, "\tscan devices: volumes complete\n");
10542 ioc_info(ioc, "\tscan devices: end devices start\n");
10546 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
10552 ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10561 sas_device = mpt3sas_get_sdev_by_addr(ioc,
10563 mpt3sas_get_port_by_id(ioc, port_id, 0));
10569 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
10570 ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
10573 mpt3sas_transport_update_links(ioc, sas_address, handle,
10575 mpt3sas_get_port_by_id(ioc, port_id, 0));
10581 while (_scsih_add_device(ioc, handle, retry_count++,
10585 ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
10590 ioc_info(ioc, "\tscan devices: end devices complete\n");
10591 ioc_info(ioc, "\tscan devices: pcie end devices start\n");
10595 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
10601 ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
10609 pcie_device = mpt3sas_get_pdev_by_wwid(ioc,
10617 _scsih_pcie_add_device(ioc, handle);
10619 ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n",
10623 ioc_info(ioc, "\tpcie devices: pcie end devices complete\n");
10624 ioc_info(ioc, "scan devices: complete\n");
10629 * @ioc: per adapter object
10633 void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
10635 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
10641 * @ioc: per adapter object
10646 mpt3sas_scsih_clear_outstanding_scsi_tm_commands(struct MPT3SAS_ADAPTER *ioc)
10648 dtmprintk(ioc,
10649 ioc_info(ioc, "%s: clear outstanding scsi & tm cmds\n", __func__));
10650 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
10651 ioc->scsih_cmds.status |= MPT3_CMD_RESET;
10652 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
10653 complete(&ioc->scsih_cmds.done);
10655 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
10656 ioc->tm_cmds.status |= MPT3_CMD_RESET;
10657 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
10658 complete(&ioc->tm_cmds.done);
10661 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz);
10662 memset(ioc->device_remove_in_progress, 0,
10663 ioc->device_remove_in_progress_sz);
10664 _scsih_fw_event_cleanup_queue(ioc);
10665 _scsih_flush_running_cmds(ioc);
10670 * @ioc: per adapter object
10675 mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
10677 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
10678 if (!(disable_discovery > 0 && !ioc->sas_hba.num_phys)) {
10679 if (ioc->multipath_on_hba) {
10680 _scsih_sas_port_refresh(ioc);
10681 _scsih_update_vphys_after_reset(ioc);
10683 _scsih_prep_device_scan(ioc);
10684 _scsih_create_enclosure_list_after_reset(ioc);
10685 _scsih_search_responding_sas_devices(ioc);
10686 _scsih_search_responding_pcie_devices(ioc);
10687 _scsih_search_responding_raid_devices(ioc);
10688 _scsih_search_responding_expanders(ioc);
10689 _scsih_error_recovery_delete_devices(ioc);
10695 * @ioc: per adapter object
10700 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
10702 ioc->current_event = fw_event;
10703 _scsih_fw_event_del_from_list(ioc, fw_event);
10706 if (ioc->remove_host || ioc->pci_error_recovery) {
10708 ioc->current_event = NULL;
10714 mpt3sas_process_trigger_data(ioc,
10719 while (scsi_host_in_recovery(ioc->shost) ||
10720 ioc->shost_recovery) {
10725 if (ioc->remove_host || ioc->fw_events_cleanup)
10729 _scsih_remove_unresponding_devices(ioc);
10730 _scsih_del_dirty_vphy(ioc);
10731 _scsih_del_dirty_port_entries(ioc);
10732 if (ioc->is_gen35_ioc)
10733 _scsih_update_device_qdepth(ioc);
10734 _scsih_scan_for_devices_after_reset(ioc);
10745 if (ioc->is_driver_loading)
10746 _scsih_complete_devices_scanning(ioc);
10747 _scsih_set_nvme_max_shutdown_latency(ioc);
10750 ioc->start_scan = 0;
10752 mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
10754 dewtprintk(ioc,
10755 ioc_info(ioc, "port enable: complete from worker thread\n"));
10758 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
10761 _scsih_sas_topology_change_event(ioc, fw_event);
10764 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
10765 _scsih_sas_device_status_change_event_debug(ioc,
10770 _scsih_sas_discovery_event(ioc, fw_event);
10773 _scsih_sas_device_discovery_error_event(ioc, fw_event);
10776 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
10779 _scsih_sas_enclosure_dev_status_change_event(ioc,
10783 _scsih_sas_ir_config_change_event(ioc, fw_event);
10786 _scsih_sas_ir_volume_event(ioc, fw_event);
10789 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
10792 _scsih_sas_ir_operation_status_event(ioc, fw_event);
10795 _scsih_pcie_device_status_change_event(ioc, fw_event);
10798 _scsih_pcie_enumeration_event(ioc, fw_event);
10801 _scsih_pcie_topology_change_event(ioc, fw_event);
10802 ioc->current_event = NULL;
10807 ioc->current_event = NULL;
10824 _mpt3sas_fw_work(fw_event->ioc, fw_event);
10829 * @ioc: per adapter object
10834 * This function merely adds a new work task into ioc->firmware_event_thread.
10841 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
10851 if (ioc->pci_error_recovery)
10854 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
10857 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
10865 mpt3sas_trigger_event(ioc, event, 0);
10879 if (ioc->broadcast_aen_busy) {
10880 ioc->broadcast_aen_pending++;
10883 ioc->broadcast_aen_busy = 1;
10888 _scsih_check_topo_delete_events(ioc,
10899 if (ioc->shost_recovery)
10903 _scsih_check_pcie_topo_remove_events(ioc,
10906 if (ioc->shost_recovery)
10910 _scsih_check_ir_config_unhide_events(ioc,
10915 _scsih_check_volume_delete_events(ioc,
10924 if (!ioc->is_warpdrive)
10937 ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
10940 ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n");
10943 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");
10946 ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
10953 _scsih_sas_device_status_change_event(ioc,
10967 _scsih_temp_threshold_events(ioc,
10976 ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n",
10986 ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n",
11002 ioc_err(ioc, "failure at %s:%d/%s()!\n",
11008 fw_event->ioc = ioc;
11012 _scsih_fw_event_add(ioc, fw_event);
11019 * @ioc: per adapter object
11023 * ioc->sas_expander_list.
11026 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
11036 if (ioc->shost_recovery)
11040 mpt3sas_device_remove_by_sas_address(ioc,
11047 mpt3sas_expander_remove(ioc,
11054 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
11057 ioc_info(ioc,
11063 spin_lock_irqsave(&ioc->sas_node_lock, flags);
11065 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
11073 * @ioc: per adapter object
11080 _scsih_nvme_shutdown(struct MPT3SAS_ADAPTER *ioc)
11087 if (list_empty(&ioc->pcie_device_list))
11090 mutex_lock(&ioc->scsih_cmds.mutex);
11092 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
11093 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
11097 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
11099 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
11101 ioc_err(ioc,
11103 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11107 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
11108 ioc->scsih_cmds.smid = smid;
11113 init_completion(&ioc->scsih_cmds.done);
11114 ioc->put_smid_default(ioc, smid);
11116 ioc_info(ioc,
11118 ioc->max_shutdown_latency);
11119 wait_for_completion_timeout(&ioc->scsih_cmds.done,
11120 ioc->max_shutdown_latency*HZ);
11122 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
11123 ioc_err(ioc, "%s: timeout\n", __func__);
11127 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
11128 mpi_reply = ioc->scsih_cmds.reply;
11129 ioc_info(ioc, "Io Unit Control shutdown (complete):"
11135 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11136 mutex_unlock(&ioc->scsih_cmds.mutex);
11142 * @ioc: per adapter object
11148 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
11155 if (!ioc->ir_firmware)
11159 if (list_empty(&ioc->raid_device_list))
11162 mutex_lock(&ioc->scsih_cmds.mutex);
11164 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
11165 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
11168 ioc->scsih_cmds.status = MPT3_CMD_PENDING;
11170 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
11172 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
11173 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11177 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
11178 ioc->scsih_cmds.smid = smid;
11184 if (!ioc->hide_ir_msg)
11185 ioc_info(ioc, "IR shutdown (sending)\n");
11186 init_completion(&ioc->scsih_cmds.done);
11187 ioc->put_smid_default(ioc, smid);
11188 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
11190 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
11191 ioc_err(ioc, "%s: timeout\n", __func__);
11195 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
11196 mpi_reply = ioc->scsih_cmds.reply;
11197 if (!ioc->hide_ir_msg)
11198 ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
11204 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
11205 mutex_unlock(&ioc->scsih_cmds.mutex);
11209 * _scsih_get_shost_and_ioc - get shost and ioc
11213 * @ioc: address of HBA adapter pointer
11215 * Return zero if *shost and *ioc are not NULL otherwise return error number.
11219 struct Scsi_Host **shost, struct MPT3SAS_ADAPTER **ioc)
11227 *ioc = shost_priv(*shost);
11228 if (*ioc == NULL) {
11245 struct MPT3SAS_ADAPTER *ioc;
11255 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
11258 ioc->remove_host = 1;
11261 mpt3sas_base_pause_mq_polling(ioc);
11262 _scsih_flush_running_cmds(ioc);
11265 _scsih_fw_event_cleanup_queue(ioc);
11267 spin_lock_irqsave(&ioc->fw_event_lock, flags);
11268 wq = ioc->firmware_event_thread;
11269 ioc->firmware_event_thread = NULL;
11270 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
11274 * Copy back the unmodified ioc page1. so that on next driver load,
11275 * current modified changes on ioc page1 won't take effect.
11277 if (ioc->is_aero_ioc)
11278 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply,
11279 &ioc->ioc_pg1_copy);
11281 _scsih_ir_shutdown(ioc);
11282 mpt3sas_destroy_debugfs(ioc);
11284 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
11292 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
11294 _scsih_raid_device_remove(ioc, raid_device);
11296 list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list,
11298 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
11305 &ioc->sas_hba.sas_port_list, port_list) {
11308 mpt3sas_device_remove_by_sas_address(ioc,
11315 mpt3sas_expander_remove(ioc,
11321 &ioc->port_table_list, list) {
11327 if (ioc->sas_hba.num_phys) {
11328 kfree(ioc->sas_hba.phy);
11329 ioc->sas_hba.phy = NULL;
11330 ioc->sas_hba.num_phys = 0;
11333 mpt3sas_base_detach(ioc);
11334 mpt3sas_ctl_release(ioc);
11336 list_del(&ioc->list);
11349 struct MPT3SAS_ADAPTER *ioc;
11354 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
11357 ioc->remove_host = 1;
11360 mpt3sas_base_pause_mq_polling(ioc);
11361 _scsih_flush_running_cmds(ioc);
11364 _scsih_fw_event_cleanup_queue(ioc);
11366 spin_lock_irqsave(&ioc->fw_event_lock, flags);
11367 wq = ioc->firmware_event_thread;
11368 ioc->firmware_event_thread = NULL;
11369 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
11373 * Copy back the unmodified ioc page1 so that on next driver load,
11374 * current modified changes on ioc page1 won't take effect.
11376 if (ioc->is_aero_ioc)
11377 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply,
11378 &ioc->ioc_pg1_copy);
11380 _scsih_ir_shutdown(ioc);
11381 _scsih_nvme_shutdown(ioc);
11382 mpt3sas_base_mask_interrupts(ioc);
11383 mpt3sas_base_stop_watchdog(ioc);
11384 ioc->shost_recovery = 1;
11385 mpt3sas_base_make_ioc_ready(ioc, SOFT_RESET);
11386 ioc->shost_recovery = 0;
11387 mpt3sas_base_free_irq(ioc);
11388 mpt3sas_base_disable_msix(ioc);
11394 * @ioc: per adapter object
11401 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
11417 if (!ioc->bios_pg3.BiosVersion)
11421 if (ioc->req_boot_device.device) {
11422 device = ioc->req_boot_device.device;
11423 channel = ioc->req_boot_device.channel;
11424 } else if (ioc->req_alt_boot_device.device) {
11425 device = ioc->req_alt_boot_device.device;
11426 channel = ioc->req_alt_boot_device.channel;
11427 } else if (ioc->current_boot_device.device) {
11428 device = ioc->current_boot_device.device;
11429 channel = ioc->current_boot_device.channel;
11444 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
11447 _scsih_raid_device_remove(ioc, raid_device);
11457 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
11459 list_move_tail(&pcie_device->list, &ioc->pcie_device_list);
11460 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
11461 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, tid, 0);
11463 _scsih_pcie_device_remove(ioc, pcie_device);
11473 spin_lock_irqsave(&ioc->sas_device_lock, flags);
11478 list_move_tail(&sas_device->list, &ioc->sas_device_list);
11479 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
11481 if (ioc->hide_drives)
11487 if (!mpt3sas_transport_port_add(ioc, handle,
11489 _scsih_sas_device_remove(ioc, sas_device);
11491 if (!ioc->is_driver_loading) {
11492 mpt3sas_transport_port_remove(ioc,
11495 _scsih_sas_device_remove(ioc, sas_device);
11503 * @ioc: per adapter object
11508 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
11514 &ioc->raid_device_list, list) {
11517 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
11520 _scsih_raid_device_remove(ioc, raid_device);
11524 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc)
11529 spin_lock_irqsave(&ioc->sas_device_lock, flags);
11530 if (!list_empty(&ioc->sas_device_init_list)) {
11531 sas_device = list_first_entry(&ioc->sas_device_init_list,
11535 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
11540 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc,
11545 spin_lock_irqsave(&ioc->sas_device_lock, flags);
11561 list_add_tail(&sas_device->list, &ioc->sas_device_list);
11563 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
11568 * @ioc: per adapter object
11573 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
11577 if (ioc->hide_drives)
11580 while ((sas_device = get_next_sas_device(ioc))) {
11581 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
11583 _scsih_sas_device_remove(ioc, sas_device);
11593 if (!ioc->is_driver_loading) {
11594 mpt3sas_transport_port_remove(ioc,
11598 _scsih_sas_device_remove(ioc, sas_device);
11603 sas_device_make_active(ioc, sas_device);
11610 * @ioc: per adapter object
11617 static struct _pcie_device *get_next_pcie_device(struct MPT3SAS_ADAPTER *ioc)
11622 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
11623 if (!list_empty(&ioc->pcie_device_init_list)) {
11624 pcie_device = list_first_entry(&ioc->pcie_device_init_list,
11628 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
11635 * @ioc: per adapter object
11641 static void pcie_device_make_active(struct MPT3SAS_ADAPTER *ioc,
11646 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
11653 list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
11655 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
11660 * @ioc: per adapter object
11665 _scsih_probe_pcie(struct MPT3SAS_ADAPTER *ioc)
11671 while ((pcie_device = get_next_pcie_device(ioc))) {
11678 pcie_device_make_active(ioc, pcie_device);
11682 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL,
11685 _scsih_pcie_device_remove(ioc, pcie_device);
11695 if (!ioc->is_driver_loading) {
11699 _scsih_pcie_device_remove(ioc, pcie_device);
11704 pcie_device_make_active(ioc, pcie_device);
11711 * @ioc: per adapter object
11716 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
11720 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
11723 _scsih_probe_boot_devices(ioc);
11725 if (ioc->ir_firmware) {
11727 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
11731 _scsih_probe_raid(ioc);
11732 _scsih_probe_sas(ioc);
11734 _scsih_probe_sas(ioc);
11735 _scsih_probe_raid(ioc);
11738 _scsih_probe_sas(ioc);
11739 _scsih_probe_pcie(ioc);
11754 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
11757 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
11758 else if (ioc->manu_pg11.HostTraceBufferMaxSizeKB != 0)
11759 mpt3sas_enable_diag_buffer(ioc, 1);
11764 ioc->start_scan = 1;
11765 rc = mpt3sas_port_enable(ioc);
11768 ioc_info(ioc, "port enable: FAILED\n");
11773 * complete ioc initialization.
11774 * @ioc: per adapter object
11778 static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc)
11781 if (ioc->wait_for_discovery_to_complete) {
11782 ioc->wait_for_discovery_to_complete = 0;
11783 _scsih_probe_devices(ioc);
11786 mpt3sas_base_start_watchdog(ioc);
11787 ioc->is_driver_loading = 0;
11802 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
11807 ioc->is_driver_loading = 0;
11808 ioc->wait_for_discovery_to_complete = 0;
11813 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11814 ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n");
11815 ioc->is_driver_loading = 0;
11819 if (ioc->start_scan) {
11820 ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
11822 mpt3sas_print_fault_code(ioc, ioc_state &
11828 mpt3sas_base_coredump_info(ioc, ioc_state &
11830 mpt3sas_base_wait_for_coredump_completion(ioc, __func__);
11837 if (ioc->port_enable_cmds.status & MPT3_CMD_RESET) {
11838 ioc_info(ioc,
11840 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11843 if (ioc->start_scan_failed) {
11844 ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n",
11845 ioc->start_scan_failed);
11846 ioc->is_driver_loading = 0;
11847 ioc->wait_for_discovery_to_complete = 0;
11848 ioc->remove_host = 1;
11852 ioc_info(ioc, "port enable: SUCCESS\n");
11853 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11854 _scsih_complete_devices_scanning(ioc);
11858 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
11859 if (mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET))
11860 ioc->is_driver_loading = 0;
11871 struct MPT3SAS_ADAPTER *ioc =
11875 int nr_msix_vectors = ioc->iopoll_q_start_index;
11876 int iopoll_q_count = ioc->reply_queue_count - nr_msix_vectors;
11887 nr_msix_vectors - ioc->high_iops_queues;
11888 offset = ioc->high_iops_queues;
11901 blk_mq_pci_map_queues(map, ioc->pdev, offset);
12070 struct MPT3SAS_ADAPTER *ioc;
12103 ioc = shost_priv(shost);
12104 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
12105 ioc->hba_mpi_version_belonged = hba_mpi_version;
12106 ioc->id = mpt2_ids++;
12107 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME);
12110 ioc->is_warpdrive = 1;
12111 ioc->hide_ir_msg = 1;
12115 ioc->is_mcpu_endpoint = 1;
12118 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
12123 ioc->multipath_on_hba = 0;
12125 ioc->multipath_on_hba = 1;
12135 ioc = shost_priv(shost);
12136 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
12137 ioc->hba_mpi_version_belonged = hba_mpi_version;
12138 ioc->id = mpt3_ids++;
12139 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME);
12149 ioc->is_gen35_ioc = 1;
12172 ioc->is_aero_ioc = ioc->is_gen35_ioc = 1;
12175 ioc->is_gen35_ioc = ioc->is_aero_ioc = 0;
12177 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION &&
12179 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) {
12180 ioc->combined_reply_queue = 1;
12181 if (ioc->is_gen35_ioc)
12182 ioc->combined_reply_index_count =
12185 ioc->combined_reply_index_count =
12189 switch (ioc->is_gen35_ioc) {
12192 ioc->multipath_on_hba = 0;
12194 ioc->multipath_on_hba = 1;
12198 ioc->multipath_on_hba = 1;
12200 ioc->multipath_on_hba = 0;
12211 INIT_LIST_HEAD(&ioc->list);
12213 list_add_tail(&ioc->list, &mpt3sas_ioc_list);
12215 ioc->shost = shost;
12216 ioc->pdev = pdev;
12217 ioc->scsi_io_cb_idx = scsi_io_cb_idx;
12218 ioc->tm_cb_idx = tm_cb_idx;
12219 ioc->ctl_cb_idx = ctl_cb_idx;
12220 ioc->base_cb_idx = base_cb_idx;
12221 ioc->port_enable_cb_idx = port_enable_cb_idx;
12222 ioc->transport_cb_idx = transport_cb_idx;
12223 ioc->scsih_cb_idx = scsih_cb_idx;
12224 ioc->config_cb_idx = config_cb_idx;
12225 ioc->tm_tr_cb_idx = tm_tr_cb_idx;
12226 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
12227 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
12228 ioc->logging_level = logging_level;
12229 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
12231 ioc->max_shutdown_latency = IO_UNIT_CONTROL_SHUTDOWN_TIMEOUT;
12235 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_MEMMOVE;
12237 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_ADDNLQUERY;
12239 ioc->enable_sdev_max_qd = enable_sdev_max_qd;
12242 mutex_init(&ioc->reset_in_progress_mutex);
12243 mutex_init(&ioc->hostdiag_unlock_mutex);
12245 mutex_init(&ioc->pci_access_mutex);
12246 spin_lock_init(&ioc->ioc_reset_in_progress_lock);
12247 spin_lock_init(&ioc->scsi_lookup_lock);
12248 spin_lock_init(&ioc->sas_device_lock);
12249 spin_lock_init(&ioc->sas_node_lock);
12250 spin_lock_init(&ioc->fw_event_lock);
12251 spin_lock_init(&ioc->raid_device_lock);
12252 spin_lock_init(&ioc->pcie_device_lock);
12253 spin_lock_init(&ioc->diag_trigger_lock);
12255 INIT_LIST_HEAD(&ioc->sas_device_list);
12256 INIT_LIST_HEAD(&ioc->sas_device_init_list);
12257 INIT_LIST_HEAD(&ioc->sas_expander_list);
12258 INIT_LIST_HEAD(&ioc->enclosure_list);
12259 INIT_LIST_HEAD(&ioc->pcie_device_list);
12260 INIT_LIST_HEAD(&ioc->pcie_device_init_list);
12261 INIT_LIST_HEAD(&ioc->fw_event_list);
12262 INIT_LIST_HEAD(&ioc->raid_device_list);
12263 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
12264 INIT_LIST_HEAD(&ioc->delayed_tr_list);
12265 INIT_LIST_HEAD(&ioc->delayed_sc_list);
12266 INIT_LIST_HEAD(&ioc->delayed_event_ack_list);
12267 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
12268 INIT_LIST_HEAD(&ioc->reply_queue_list);
12269 INIT_LIST_HEAD(&ioc->port_table_list);
12271 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id);
12277 shost->unique_id = ioc->id;
12279 if (ioc->is_mcpu_endpoint) {
12282 ioc_info(ioc, "The max_sectors value is set to %d\n",
12288 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n",
12292 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n",
12296 ioc_info(ioc, "The max_sectors value is set to %d\n",
12312 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
12313 "fw_event_%s%d", ioc->driver_name, ioc->id);
12314 ioc->firmware_event_thread = alloc_ordered_workqueue(
12315 ioc->firmware_event_name, 0);
12316 if (!ioc->firmware_event_thread) {
12317 ioc_err(ioc, "failure at %s:%d/%s()!\n",
12325 if (ioc->is_gen35_ioc && host_tagset_enable)
12328 ioc->is_driver_loading = 1;
12329 if ((mpt3sas_base_attach(ioc))) {
12330 ioc_err(ioc, "failure at %s:%d/%s()!\n",
12336 if (ioc->is_warpdrive) {
12337 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS)
12338 ioc->hide_drives = 0;
12339 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS)
12340 ioc->hide_drives = 1;
12342 if (mpt3sas_get_num_volumes(ioc))
12343 ioc->hide_drives = 1;
12345 ioc->hide_drives = 0;
12348 ioc->hide_drives = 0;
12354 ioc->reply_queue_count - ioc->high_iops_queues;
12357 ioc->reply_queue_count - ioc->iopoll_q_start_index;
12361 dev_info(&ioc->pdev->dev,
12368 ioc_err(ioc, "failure at %s:%d/%s()!\n",
12374 mpt3sas_setup_debugfs(ioc);
12377 mpt3sas_base_detach(ioc);
12379 destroy_workqueue(ioc->firmware_event_thread);
12382 list_del(&ioc->list);
12399 struct MPT3SAS_ADAPTER *ioc;
12402 rc = _scsih_get_shost_and_ioc(pdev, &shost, &ioc);
12406 mpt3sas_base_stop_watchdog(ioc);
12408 _scsih_nvme_shutdown(ioc);
12409 ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state\n",
12412 mpt3sas_base_free_resources(ioc);
12427 struct MPT3SAS_ADAPTER *ioc;
12431 r = _scsih_get_shost_and_ioc(pdev, &shost, &ioc);
12435 ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
12438 ioc->pdev = pdev;
12439 r = mpt3sas_base_map_resources(ioc);
12442 ioc_info(ioc, "Issuing Hard Reset as part of OS Resume\n");
12443 mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET);
12445 mpt3sas_base_start_watchdog(ioc);
12462 struct MPT3SAS_ADAPTER *ioc;
12464 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12467 ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state);
12474 ioc->pci_error_recovery = 1;
12475 scsi_block_requests(ioc->shost);
12476 mpt3sas_base_stop_watchdog(ioc);
12477 mpt3sas_base_free_resources(ioc);
12481 ioc->pci_error_recovery = 1;
12482 mpt3sas_base_stop_watchdog(ioc);
12483 mpt3sas_base_pause_mq_polling(ioc);
12484 _scsih_flush_running_cmds(ioc);
12502 struct MPT3SAS_ADAPTER *ioc;
12505 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12508 ioc_info(ioc, "PCI error: slot reset callback!!\n");
12510 ioc->pci_error_recovery = 0;
12511 ioc->pdev = pdev;
12513 rc = mpt3sas_base_map_resources(ioc);
12517 ioc_info(ioc, "Issuing Hard Reset as part of PCI Slot Reset\n");
12518 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
12520 ioc_warn(ioc, "hard reset: %s\n",
12541 struct MPT3SAS_ADAPTER *ioc;
12543 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12546 ioc_info(ioc, "PCI error: resume callback!!\n");
12548 mpt3sas_base_start_watchdog(ioc);
12549 scsi_unblock_requests(ioc->shost);
12560 struct MPT3SAS_ADAPTER *ioc;
12562 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))
12565 ioc_info(ioc, "PCI error: mmio enabled callback!!\n");