Lines Matching refs:ioc
68 static void _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
72 static u8 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid);
141 * @work: work object (ioc->fault_reset_work_q)
143 * @ioc: per adapter object
151 * This object stored on ioc->fw_event_list.
157 struct MPT2SAS_ADAPTER *ioc;
185 * @ioc_status: ioc status
266 * _scsih_set_debug_level - global setting of ioc->logging_level.
274 struct MPT2SAS_ADAPTER *ioc;
280 list_for_each_entry(ioc, &mpt2sas_ioc_list, list)
281 ioc->logging_level = logging_level;
385 _scsih_get_sas_address(struct MPT2SAS_ADAPTER *ioc, u16 handle,
393 if (handle <= ioc->sas_hba.num_phys) {
394 *sas_address = ioc->sas_hba.sas_address;
398 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
400 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n", ioc->name,
416 "failure at %s:%d/%s()!\n", ioc->name, handle, ioc_status,
423 * @ioc: per adapter object
431 * the corresponding device object and is_raid flag in the ioc object.
435 _scsih_determine_boot_device(struct MPT2SAS_ADAPTER *ioc,
446 if (!ioc->is_driver_loading)
450 if (!ioc->bios_pg3.BiosVersion)
467 if (!ioc->req_boot_device.device) {
470 (ioc->bios_pg2.ReqBootDeviceForm &
472 &ioc->bios_pg2.RequestedBootDevice)) {
473 dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
475 ioc->name, __func__,
477 ioc->req_boot_device.device = device;
478 ioc->req_boot_device.is_raid = is_raid;
482 if (!ioc->req_alt_boot_device.device) {
485 (ioc->bios_pg2.ReqAltBootDeviceForm &
487 &ioc->bios_pg2.RequestedAltBootDevice)) {
488 dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
490 ioc->name, __func__,
492 ioc->req_alt_boot_device.device = device;
493 ioc->req_alt_boot_device.is_raid = is_raid;
497 if (!ioc->current_boot_device.device) {
500 (ioc->bios_pg2.CurrentBootDeviceForm &
502 &ioc->bios_pg2.CurrentBootDevice)) {
503 dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
505 ioc->name, __func__,
507 ioc->current_boot_device.device = device;
508 ioc->current_boot_device.is_raid = is_raid;
515 * @ioc: per adapter object
517 * Context: Calling function should acquire ioc->sas_device_lock
523 mpt2sas_scsih_sas_device_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
528 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
532 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
541 * @ioc: per adapter object
543 * Context: Calling function should acquire ioc->sas_device_lock
549 _scsih_sas_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
553 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
557 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
566 * @ioc: per adapter object
568 * Context: This function will acquire ioc->sas_device_lock.
570 * Removing object and freeing associated memory from the ioc->sas_device_list.
573 _scsih_sas_device_remove(struct MPT2SAS_ADAPTER *ioc,
581 spin_lock_irqsave(&ioc->sas_device_lock, flags);
582 if (mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
587 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
592 * @ioc: per adapter object
594 * Context: This function will acquire ioc->sas_device_lock.
596 * Adding new object to the ioc->sas_device_list.
599 _scsih_sas_device_add(struct MPT2SAS_ADAPTER *ioc,
604 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
605 "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
608 spin_lock_irqsave(&ioc->sas_device_lock, flags);
609 list_add_tail(&sas_device->list, &ioc->sas_device_list);
610 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
612 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
614 _scsih_sas_device_remove(ioc, sas_device);
620 if (!ioc->is_driver_loading)
621 mpt2sas_transport_port_remove(ioc,
624 _scsih_sas_device_remove(ioc, sas_device);
630 * @ioc: per adapter object
632 * Context: This function will acquire ioc->sas_device_lock.
634 * Adding new object at driver load time to the ioc->sas_device_init_list.
637 _scsih_sas_device_init_add(struct MPT2SAS_ADAPTER *ioc,
642 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
643 "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
646 spin_lock_irqsave(&ioc->sas_device_lock, flags);
647 list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
648 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
649 _scsih_determine_boot_device(ioc, sas_device, 0);
654 * @ioc: per adapter object
657 * Context: Calling function should acquire ioc->raid_device_lock
663 _scsih_raid_device_find_by_id(struct MPT2SAS_ADAPTER *ioc, int id, int channel)
668 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
681 * @ioc: per adapter object
683 * Context: Calling function should acquire ioc->raid_device_lock
689 _scsih_raid_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
694 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
707 * @ioc: per adapter object
709 * Context: Calling function should acquire ioc->raid_device_lock
715 _scsih_raid_device_find_by_wwid(struct MPT2SAS_ADAPTER *ioc, u64 wwid)
720 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
733 * @ioc: per adapter object
739 _scsih_raid_device_add(struct MPT2SAS_ADAPTER *ioc,
744 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
745 "(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
748 spin_lock_irqsave(&ioc->raid_device_lock, flags);
749 list_add_tail(&raid_device->list, &ioc->raid_device_list);
750 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
755 * @ioc: per adapter object
761 _scsih_raid_device_remove(struct MPT2SAS_ADAPTER *ioc,
766 spin_lock_irqsave(&ioc->raid_device_lock, flags);
770 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
775 * @ioc: per adapter object
777 * Context: Calling function should acquire ioc->sas_device_lock
783 mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
788 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
800 * @ioc: per adapter object
802 * Context: Calling function should acquire ioc->sas_node_lock.
808 mpt2sas_scsih_expander_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
814 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
826 * @ioc: per adapter object
828 * Context: This function will acquire ioc->sas_node_lock.
830 * Adding new object to the ioc->sas_expander_list.
835 _scsih_expander_node_add(struct MPT2SAS_ADAPTER *ioc,
840 spin_lock_irqsave(&ioc->sas_node_lock, flags);
841 list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
842 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
866 * @ioc: per adapter object
872 _scsih_scsi_lookup_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
874 return ioc->scsi_lookup[smid - 1].scmd;
879 * @ioc: per adapter object
886 _scsih_scsi_lookup_get_clear(struct MPT2SAS_ADAPTER *ioc, u16 smid)
891 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
892 scmd = ioc->scsi_lookup[smid - 1].scmd;
893 ioc->scsi_lookup[smid - 1].scmd = NULL;
894 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
901 * @ioc: per adapter object
904 * Context: This function will acquire ioc->scsi_lookup_lock.
910 _scsih_scsi_lookup_find_by_scmd(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd
917 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
919 for (i = 0; i < ioc->scsiio_depth; i++) {
920 if (ioc->scsi_lookup[i].scmd == scmd) {
921 smid = ioc->scsi_lookup[i].smid;
926 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
932 * @ioc: per adapter object
935 * Context: This function will acquire ioc->scsi_lookup_lock.
941 _scsih_scsi_lookup_find_by_target(struct MPT2SAS_ADAPTER *ioc, int id,
948 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
950 for (i = 0 ; i < ioc->scsiio_depth; i++) {
951 if (ioc->scsi_lookup[i].scmd &&
952 (ioc->scsi_lookup[i].scmd->device->id == id &&
953 ioc->scsi_lookup[i].scmd->device->channel == channel)) {
959 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
965 * @ioc: per adapter object
969 * Context: This function will acquire ioc->scsi_lookup_lock.
975 _scsih_scsi_lookup_find_by_lun(struct MPT2SAS_ADAPTER *ioc, int id,
982 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
984 for (i = 0 ; i < ioc->scsiio_depth; i++) {
985 if (ioc->scsi_lookup[i].scmd &&
986 (ioc->scsi_lookup[i].scmd->device->id == id &&
987 ioc->scsi_lookup[i].scmd->device->channel == channel &&
988 ioc->scsi_lookup[i].scmd->device->lun == lun)) {
994 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1000 * @ioc: per adapter object
1003 * Returns chain tracker(from ioc->free_chain_list)
1006 _scsih_get_chain_buffer_tracker(struct MPT2SAS_ADAPTER *ioc, u16 smid)
1011 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1012 if (list_empty(&ioc->free_chain_list)) {
1013 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1014 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT "chain buffers not "
1015 "available\n", ioc->name));
1018 chain_req = list_entry(ioc->free_chain_list.next,
1022 &ioc->scsi_lookup[smid - 1].chain_list);
1023 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1029 * @ioc: per adapter object
1040 _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
1057 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1079 sges_in_segment = ioc->max_sges_in_main_message;
1084 (sges_in_segment * ioc->sge_size))/4;
1089 ioc->base_add_sg_single(sg_local,
1093 ioc->base_add_sg_single(sg_local, sgl_flags |
1096 sg_local += ioc->sge_size;
1103 chain_req = _scsih_get_chain_buffer_tracker(ioc, smid);
1110 ioc->max_sges_in_chain_message) ? sges_left :
1111 ioc->max_sges_in_chain_message;
1113 0 : (sges_in_segment * ioc->sge_size)/4;
1114 chain_length = sges_in_segment * ioc->sge_size;
1118 chain_length += ioc->sge_size;
1120 ioc->base_add_sg_single(sg_local, chain_flags | chain_offset |
1129 ioc->base_add_sg_single(sg_local,
1134 ioc->base_add_sg_single(sg_local, sgl_flags |
1138 sg_local += ioc->sge_size;
1143 chain_req = _scsih_get_chain_buffer_tracker(ioc, smid);
1156 ioc->base_add_sg_single(sg_local, sgl_flags_end_buffer |
1159 ioc->base_add_sg_single(sg_local, sgl_flags |
1162 sg_local += ioc->sge_size;
1182 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1199 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1200 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1202 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1278 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1295 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1296 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1305 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1310 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1312 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1321 if (test_bit(sas_device->handle, ioc->pd_handles))
1325 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1340 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1352 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1353 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1359 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1363 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1365 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1372 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1390 struct MPT2SAS_ADAPTER *ioc;
1413 ioc = shost_priv(shost);
1415 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1416 raid_device = _scsih_raid_device_find_by_id(ioc,
1420 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1438 struct MPT2SAS_ADAPTER *ioc;
1450 ioc = shost_priv(shost);
1453 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1454 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1458 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1467 * @ioc: per adapter object
1472 _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
1481 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1484 ioc->name, __FILE__, __LINE__, __func__);
1492 ioc->name, __FILE__, __LINE__, __func__);
1519 struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1521 if (ioc->is_warpdrive)
1534 struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1542 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1543 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1545 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1547 if (!raid_device || ioc->is_warpdrive)
1550 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1554 ioc->name, __FILE__, __LINE__, __func__);
1573 struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1581 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1582 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1584 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1589 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1593 ioc->name, __FILE__, __LINE__, __func__);
1650 * @ioc: per adapter object
1656 _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
1666 if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
1668 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1669 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1679 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1680 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1685 if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1687 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1688 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1699 if (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1702 if (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
1715 * @ioc: per adapter object
1718 _scsih_disable_ddio(struct MPT2SAS_ADAPTER *ioc)
1727 while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1734 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
1743 * _scsih_get_num_volumes - Get number of volumes in the ioc
1744 * @ioc: per adapter object
1747 _scsih_get_num_volumes(struct MPT2SAS_ADAPTER *ioc)
1756 while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1771 * @ioc: per adapter object
1775 _scsih_init_warpdrive_properties(struct MPT2SAS_ADAPTER *ioc,
1787 if (!ioc->is_warpdrive)
1790 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS) {
1792 "globally as drives are exposed\n", ioc->name);
1795 if (_scsih_get_num_volumes(ioc) > 1) {
1796 _scsih_disable_ddio(ioc);
1798 "globally as number of drives > 1\n", ioc->name);
1801 if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
1804 "Failure in computing number of drives\n", ioc->name);
1813 "Memory allocation failure for RVPG0\n", ioc->name);
1817 if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1820 "Failure in retrieving RVPG0\n", ioc->name);
1832 "max_mem_allowed=%d\n", ioc->name, raid_device->handle,
1838 if (mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1845 ioc->name, raid_device->handle,
1855 ioc->name, raid_device->handle,
1871 "s_sz=%uK, blk_size=%u\n", ioc->name,
1884 ioc->name, raid_device->handle,
1895 ioc->name, raid_device->handle,
1903 " with handle(0x%04x)\n", ioc->name, raid_device->handle);
1926 * @ioc: per adapter object
1934 _scsih_enable_tlr(struct MPT2SAS_ADAPTER *ioc, struct scsi_device *sdev)
1940 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
1961 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1981 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1982 raid_device = _scsih_raid_device_find_by_handle(ioc,
1984 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1986 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1987 "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
1992 _scsih_get_volume_capabilities(ioc, raid_device);
1994 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
1995 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
1996 "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
2003 _scsih_init_warpdrive_properties(ioc, raid_device);
2029 if (ioc->manu_pg10.OEMIdentifier &&
2030 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
2052 if (!ioc->hide_ir_msg)
2060 if (!ioc->is_warpdrive)
2066 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2067 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2069 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2073 if (mpt2sas_config_get_volume_handle(ioc,
2075 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2076 "failure at %s:%d/%s()!\n", ioc->name,
2081 mpt2sas_config_get_volume_wwid(ioc,
2084 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2085 "failure at %s:%d/%s()!\n", ioc->name,
2116 _scsih_display_sata_capabilities(ioc, sas_device, sdev);
2118 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
2119 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
2128 _scsih_enable_tlr(ioc, sdev);
2183 * @ioc: per adapter object
2189 _scsih_response_code(struct MPT2SAS_ADAPTER *ioc, u8 response_code)
2223 ioc->name, response_code, desc);
2228 * @ioc: per adapter object
2240 _scsih_tm_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2244 if (ioc->tm_cmds.status == MPT2_CMD_NOT_USED)
2246 if (ioc->tm_cmds.smid != smid)
2248 mpt2sas_base_flush_reply_queues(ioc);
2249 ioc->tm_cmds.status |= MPT2_CMD_COMPLETE;
2250 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
2252 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2253 ioc->tm_cmds.status |= MPT2_CMD_REPLY_VALID;
2255 ioc->tm_cmds.status &= ~MPT2_CMD_PENDING;
2256 complete(&ioc->tm_cmds.done);
2262 * @ioc: per adapter object
2268 mpt2sas_scsih_set_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2274 shost_for_each_device(sdev, ioc->shost) {
2283 ioc->ignore_loginfos = 1;
2290 * @ioc: per adapter object
2296 mpt2sas_scsih_clear_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2302 shost_for_each_device(sdev, ioc->shost) {
2311 ioc->ignore_loginfos = 0;
2319 * @ioc: per adapter struct
2333 * The callback index is set inside `ioc->tm_cb_idx`.
2338 mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle, uint channel,
2351 mutex_lock(&ioc->tm_cmds.mutex);
2352 if (ioc->tm_cmds.status != MPT2_CMD_NOT_USED) {
2354 __func__, ioc->name);
2359 if (ioc->shost_recovery || ioc->remove_host ||
2360 ioc->pci_error_recovery) {
2362 __func__, ioc->name);
2367 ioc_state = mpt2sas_base_get_iocstate(ioc, 0);
2369 dhsprintk(ioc, printk(MPT2SAS_INFO_FMT "unexpected doorbell "
2370 "active!\n", ioc->name));
2371 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2378 mpt2sas_base_fault_info(ioc, ioc_state &
2380 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2386 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2389 ioc->name, __func__);
2395 scsi_lookup = &ioc->scsi_lookup[smid_task - 1];
2397 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "sending tm: handle(0x%04x),"
2398 " task_type(0x%02x), smid(%d)\n", ioc->name, handle, type,
2400 ioc->tm_cmds.status = MPT2_CMD_PENDING;
2401 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2402 ioc->tm_cmds.smid = smid;
2404 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2410 mpt2sas_scsih_set_tm_flag(ioc, handle);
2411 init_completion(&ioc->tm_cmds.done);
2412 mpt2sas_base_put_smid_hi_priority(ioc, smid);
2413 timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2414 if (!(ioc->tm_cmds.status & MPT2_CMD_COMPLETE)) {
2416 ioc->name, __func__);
2419 if (!(ioc->tm_cmds.status & MPT2_CMD_RESET)) {
2420 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2423 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2424 mpt2sas_scsih_clear_tm_flag(ioc, handle);
2429 if (ioc->tm_cmds.status & MPT2_CMD_REPLY_VALID) {
2430 mpi_reply = ioc->tm_cmds.reply;
2431 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "complete tm: "
2433 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
2436 if (ioc->logging_level & MPT_DEBUG_TM) {
2437 _scsih_response_code(ioc, mpi_reply->ResponseCode);
2453 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
2461 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
2474 mpt2sas_scsih_clear_tm_flag(ioc, handle);
2475 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2477 mutex_unlock(&ioc->tm_cmds.mutex);
2483 mutex_unlock(&ioc->tm_cmds.mutex);
2489 * @ioc: per adapter struct
2495 _scsih_tm_display_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2505 if (ioc->hide_ir_msg)
2516 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2517 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2538 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2551 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2559 _scsih_tm_display_info(ioc, scmd);
2572 smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
2588 mpt2sas_halt_firmware(ioc);
2591 r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2611 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2622 _scsih_tm_display_info(ioc, scmd);
2638 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2639 sas_device = _scsih_sas_device_find_by_handle(ioc,
2643 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2653 r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2673 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2683 _scsih_tm_display_info(ioc, scmd);
2699 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2700 sas_device = _scsih_sas_device_find_by_handle(ioc,
2704 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2714 r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2733 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2737 ioc->name, scmd);
2740 retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2744 ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2751 * @ioc: per adapter object
2753 * Context: This function will acquire ioc->fw_event_lock.
2761 _scsih_fw_event_add(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
2765 if (ioc->firmware_event_thread == NULL)
2768 spin_lock_irqsave(&ioc->fw_event_lock, flags);
2769 list_add_tail(&fw_event->list, &ioc->fw_event_list);
2771 queue_delayed_work(ioc->firmware_event_thread,
2773 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2778 * @ioc: per adapter object
2780 * Context: This function will acquire ioc->fw_event_lock.
2787 _scsih_fw_event_free(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
2792 spin_lock_irqsave(&ioc->fw_event_lock, flags);
2796 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2802 * @ioc: per adapter object
2807 _scsih_error_recovery_delete_devices(struct MPT2SAS_ADAPTER *ioc)
2811 if (ioc->is_driver_loading)
2819 fw_event->ioc = ioc;
2820 _scsih_fw_event_add(ioc, fw_event);
2825 * @ioc: per adapter object
2830 mpt2sas_port_enable_complete(struct MPT2SAS_ADAPTER *ioc)
2838 fw_event->ioc = ioc;
2839 _scsih_fw_event_add(ioc, fw_event);
2844 * @ioc: per adapter object
2852 _scsih_fw_event_cleanup_queue(struct MPT2SAS_ADAPTER *ioc)
2856 if (list_empty(&ioc->fw_event_list) ||
2857 !ioc->firmware_event_thread || in_interrupt())
2860 list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
2862 _scsih_fw_event_free(ioc, fw_event);
2871 * @ioc: per adapter object
2876 _scsih_ublock_io_all_device(struct MPT2SAS_ADAPTER *ioc)
2881 shost_for_each_device(sdev, ioc->shost) {
2888 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, "device_running, "
2896 * @ioc: per adapter object
2902 _scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2907 shost_for_each_device(sdev, ioc->shost) {
2914 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2916 "handle(0x%04x)\n", ioc->name, handle));
2925 * @ioc: per adapter object
2931 _scsih_block_io_all_device(struct MPT2SAS_ADAPTER *ioc)
2936 shost_for_each_device(sdev, ioc->shost) {
2943 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, "device_blocked, "
2953 * @ioc: per adapter object
2959 _scsih_block_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2964 shost_for_each_device(sdev, ioc->shost) {
2971 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2973 "handle(0x%04x)\n", ioc->name, handle));
2982 * @ioc: per adapter object
2990 _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
3005 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3007 mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
3009 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3012 _scsih_block_io_device(ioc, sas_device->handle);
3024 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3027 ioc, mpt2sas_port->remote_identify.sas_address);
3028 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3029 _scsih_block_io_to_children_attached_to_ex(ioc,
3037 * @ioc: per adapter object
3044 _scsih_block_io_to_children_attached_directly(struct MPT2SAS_ADAPTER *ioc,
3060 _scsih_block_io_device(ioc, handle);
3066 * @ioc: per adapter object
3080 _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3091 if (ioc->remove_host) {
3092 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host has been "
3093 "removed: handle(0x%04x)\n", __func__, ioc->name, handle));
3095 } else if (ioc->pci_error_recovery) {
3096 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host in pci "
3097 "error recovery: handle(0x%04x)\n", __func__, ioc->name,
3101 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
3103 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host is not "
3104 "operational: handle(0x%04x)\n", __func__, ioc->name,
3110 if (test_bit(handle, ioc->pd_handles))
3113 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3114 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3121 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3124 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "setting delete flag: "
3125 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, handle,
3127 _scsih_ublock_io_device(ioc, handle);
3131 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
3138 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3139 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3141 ioc->name, handle));
3145 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
3146 "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
3147 ioc->tm_tr_cb_idx));
3148 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3153 mpt2sas_base_put_smid_hi_priority(ioc, smid);
3160 * @ioc: per adapter object
3174 _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
3179 mpt2sas_base_get_reply_virt_addr(ioc, reply);
3181 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3184 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
3192 * @ioc: per adapter object
3201 _scsih_tm_tr_volume_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3207 if (ioc->shost_recovery || ioc->remove_host ||
3208 ioc->pci_error_recovery) {
3209 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
3210 "progress!\n", __func__, ioc->name));
3214 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
3221 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
3222 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3224 ioc->name, handle));
3228 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
3229 "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
3230 ioc->tm_tr_volume_cb_idx));
3231 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3236 mpt2sas_base_put_smid_hi_priority(ioc, smid);
3241 * @ioc: per adapter object
3251 _scsih_tm_volume_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
3257 mpt2sas_base_get_reply_virt_addr(ioc, reply);
3259 if (ioc->shost_recovery || ioc->remove_host ||
3260 ioc->pci_error_recovery) {
3261 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
3262 "progress!\n", __func__, ioc->name));
3266 mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
3269 dewtprintk(ioc, printk("spurious interrupt: "
3275 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3277 "loginfo(0x%08x), completed(%d)\n", ioc->name,
3282 return _scsih_check_for_pending_tm(ioc, smid);
3287 * @ioc: per adapter object
3302 _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
3308 mpt2sas_base_get_reply_virt_addr(ioc, reply);
3313 if (ioc->remove_host) {
3314 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host has been "
3315 "removed\n", __func__, ioc->name));
3317 } else if (ioc->pci_error_recovery) {
3318 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host in pci "
3319 "error recovery\n", __func__, ioc->name));
3322 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
3324 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host is not "
3325 "operational\n", __func__, ioc->name));
3329 mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
3332 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "spurious interrupt: "
3333 "handle(0x%04x:0x%04x), smid(%d)!!!\n", ioc->name, handle,
3338 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3340 "loginfo(0x%08x), completed(%d)\n", ioc->name,
3345 smid_sas_ctrl = mpt2sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
3348 ioc->name, __func__);
3352 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "sc_send:handle(0x%04x), "
3353 "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid_sas_ctrl,
3354 ioc->tm_sas_control_cb_idx));
3355 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid_sas_ctrl);
3360 mpt2sas_base_put_smid_default(ioc, smid_sas_ctrl);
3362 return _scsih_check_for_pending_tm(ioc, smid);
3367 * @ioc: per adapter object
3377 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid)
3381 if (!list_empty(&ioc->delayed_tr_volume_list)) {
3382 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
3384 mpt2sas_base_free_smid(ioc, smid);
3385 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
3391 if (!list_empty(&ioc->delayed_tr_list)) {
3392 delayed_tr = list_entry(ioc->delayed_tr_list.next,
3394 mpt2sas_base_free_smid(ioc, smid);
3395 _scsih_tm_tr_send(ioc, delayed_tr->handle);
3406 * @ioc: per adapter object
3418 _scsih_check_topo_delete_events(struct MPT2SAS_ADAPTER *ioc,
3436 _scsih_tm_tr_send(ioc, handle);
3440 if (expander_handle < ioc->sas_hba.num_phys) {
3441 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3447 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3448 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
3450 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3451 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
3453 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3459 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3460 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
3471 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3472 "setting ignoring flag\n", ioc->name));
3477 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3482 * @ioc: per adapter object
3489 _scsih_set_volume_delete_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3495 spin_lock_irqsave(&ioc->raid_device_lock, flags);
3496 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
3502 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3504 "wwid(0x%016llx)\n", ioc->name, handle,
3507 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
3533 * @ioc: per adapter object
3546 _scsih_check_ir_config_unhide_events(struct MPT2SAS_ADAPTER *ioc,
3557 if (ioc->is_warpdrive)
3568 _scsih_set_volume_delete_flag(ioc, volume_handle);
3586 _scsih_tm_tr_volume_send(ioc, a);
3588 _scsih_tm_tr_volume_send(ioc, b);
3597 clear_bit(handle, ioc->pd_handles);
3599 _scsih_tm_tr_send(ioc, handle);
3605 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3606 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3607 "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
3610 _scsih_tm_tr_send(ioc, handle);
3617 * @ioc: per adapter object
3628 _scsih_check_volume_delete_events(struct MPT2SAS_ADAPTER *ioc,
3638 _scsih_set_volume_delete_flag(ioc,
3644 * @ioc: per adapter object
3652 _scsih_flush_running_cmds(struct MPT2SAS_ADAPTER *ioc)
3658 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3659 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3663 mpt2sas_base_free_smid(ioc, smid);
3665 if (ioc->pci_error_recovery)
3671 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "completing %d cmds\n",
3672 ioc->name, count));
3731 * @ioc_status: ioc status
3772 * @ioc: per adapter object
3778 _scsih_scsi_direct_io_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
3780 return ioc->scsi_lookup[smid - 1].direct_io;
3785 * @ioc: per adapter object
3792 _scsih_scsi_direct_io_set(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 direct_io)
3794 ioc->scsi_lookup[smid - 1].direct_io = direct_io;
3800 * @ioc: per adapter object
3809 _scsih_setup_direct_io(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3856 _scsih_scsi_direct_io_set(ioc, smid, 1);
3887 _scsih_scsi_direct_io_set(ioc, smid, 1);
3899 * The callback index is set inside `ioc->scsi_io_cb_idx`.
3908 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3924 if (ioc->pci_error_recovery || ioc->remove_host) {
3939 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
3976 if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
3980 smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
3983 ioc->name, __func__);
3986 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
4005 mpt2sas_base_get_sense_buffer_dma(ioc, smid);
4016 mpt2sas_base_build_zero_len_sge(ioc, &mpi_request->SGL);
4018 if (_scsih_build_scatter_gather(ioc, scmd, smid)) {
4019 mpt2sas_base_free_smid(ioc, smid);
4026 _scsih_setup_direct_io(ioc, scmd, raid_device, mpi_request,
4030 mpt2sas_base_put_smid_scsi_io(ioc, smid,
4033 mpt2sas_base_put_smid_default(ioc, smid);
4068 * @ioc: per adapter object
4073 * scsi_state - state info associated with SCSI_IO determined by ioc
4074 * ioc_status - ioc supplied status info
4079 _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4090 char *desc_scsi_state = ioc->tmp_string;
4101 if (ioc->hide_ir_msg)
4147 desc_ioc_state = "scsi ioc terminated";
4222 printk(MPT2SAS_WARN_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
4225 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4226 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4230 "phy(%d)\n", ioc->name, sas_device->sas_address,
4234 ioc->name, sas_device->enclosure_logical_id,
4237 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4241 "smid(%d)\n", ioc->name, le16_to_cpu(mpi_reply->DevHandle),
4244 "resid(%d)\n", ioc->name, scsi_bufflen(scmd), scmd->underflow,
4247 "sc->result(0x%08x)\n", ioc->name, le16_to_cpu(mpi_reply->TaskTag),
4250 "scsi_state(%s)(0x%02x)\n", ioc->name, desc_scsi_status,
4257 "[0x%02x,0x%02x,0x%02x], count(%d)\n", ioc->name, data.skey,
4264 _scsih_response_code(ioc, response_bytes[0]);
4271 * @ioc: per adapter object
4278 _scsih_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4290 if ((mpt2sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4292 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n", ioc->name,
4298 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "enclosure_processor: "
4299 "ioc_status (0x%04x), loginfo(0x%08x)\n", ioc->name,
4308 * @ioc: per adapter object
4315 _scsih_send_event_to_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4324 fw_event->ioc = ioc;
4325 _scsih_fw_event_add(ioc, fw_event);
4330 * @ioc: per adapter object
4337 _scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4348 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4349 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4351 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4359 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4363 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4365 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
4366 _scsih_send_event_to_turn_on_fault_led(ioc, handle);
4374 ioc->name, __FILE__, __LINE__, __func__);
4390 mpt2sas_ctl_add_to_event_log(ioc, event_reply);
4396 * @ioc: per adapter object
4407 _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4421 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
4422 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
4426 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
4444 if (_scsih_scsi_direct_io_get(ioc, smid) &&
4447 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4448 ioc->scsi_lookup[smid - 1].scmd = scmd;
4449 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4450 _scsih_scsi_direct_io_set(ioc, smid, 0);
4454 mpt2sas_base_put_smid_scsi_io(ioc, smid,
4470 if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
4496 const void *sense_data = mpt2sas_base_get_sense_buffer(ioc,
4504 _scsih_smart_predicted_fault(ioc,
4599 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
4600 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
4611 * @ioc: per adapter object
4621 _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
4631 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
4633 ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
4635 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
4640 ioc->name, __FILE__, __LINE__, __func__);
4644 if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4650 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4653 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4655 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4660 mpt2sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4669 * @ioc: per adapter object
4671 * Creating host side data object, stored in ioc->sas_hba
4676 _scsih_sas_host_add(struct MPT2SAS_ADAPTER *ioc)
4689 mpt2sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
4690 if (!ioc->sas_hba.num_phys) {
4692 ioc->name, __FILE__, __LINE__, __func__);
4697 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4702 ioc->name, __FILE__, __LINE__, __func__);
4705 if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4708 ioc->name, __FILE__, __LINE__, __func__);
4715 ioc->name, __FILE__, __LINE__, __func__);
4720 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4725 ioc->name, __FILE__, __LINE__, __func__);
4728 if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4731 ioc->name, __FILE__, __LINE__, __func__);
4738 ioc->name, __FILE__, __LINE__, __func__);
4742 ioc->io_missing_delay =
4747 ioc->device_missing_delay = (device_missing_delay &
4750 ioc->device_missing_delay = device_missing_delay &
4753 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
4754 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
4756 if (!ioc->sas_hba.phy) {
4758 ioc->name, __FILE__, __LINE__, __func__);
4761 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4762 if ((mpt2sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
4765 ioc->name, __FILE__, __LINE__, __func__);
4772 ioc->name, __FILE__, __LINE__, __func__);
4777 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4779 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4780 ioc->sas_hba.phy[i].phy_id = i;
4781 mpt2sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
4782 phy_pg0, ioc->sas_hba.parent_dev);
4784 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4785 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
4787 ioc->name, __FILE__, __LINE__, __func__);
4790 ioc->sas_hba.enclosure_handle =
4792 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4794 "sas_addr(0x%016llx), phys(%d)\n", ioc->name, ioc->sas_hba.handle,
4795 (unsigned long long) ioc->sas_hba.sas_address,
4796 ioc->sas_hba.num_phys) ;
4798 if (ioc->sas_hba.enclosure_handle) {
4799 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4802 ioc->sas_hba.enclosure_handle))) {
4803 ioc->sas_hba.enclosure_logical_id =
4815 * @ioc: per adapter object
4818 * Creating expander object, stored in ioc->sas_expander_list.
4823 _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4841 if (ioc->shost_recovery || ioc->pci_error_recovery)
4844 if ((mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
4847 ioc->name, __FILE__, __LINE__, __func__);
4855 ioc->name, __FILE__, __LINE__, __func__);
4861 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
4864 ioc->name, __FILE__, __LINE__, __func__);
4867 if (sas_address_parent != ioc->sas_hba.sas_address) {
4868 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4869 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4871 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4873 rc = _scsih_expander_add(ioc, parent_handle);
4879 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4881 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4883 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4892 ioc->name, __FILE__, __LINE__, __func__);
4902 " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
4912 ioc->name, __FILE__, __LINE__, __func__);
4918 mpt2sas_port = mpt2sas_transport_port_add(ioc, handle,
4922 ioc->name, __FILE__, __LINE__, __func__);
4929 if ((mpt2sas_config_get_expander_pg1(ioc, &mpi_reply,
4932 ioc->name, __FILE__, __LINE__, __func__);
4939 if ((mpt2sas_transport_add_expander_phy(ioc,
4943 ioc->name, __FILE__, __LINE__, __func__);
4950 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4958 _scsih_expander_node_add(ioc, sas_expander);
4964 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
4972 * @ioc: per adapter object
4978 * The callback index passed is `ioc->scsih_cb_idx`
4984 _scsih_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4988 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
4989 if (ioc->scsih_cmds.status == MPT2_CMD_NOT_USED)
4991 if (ioc->scsih_cmds.smid != smid)
4993 ioc->scsih_cmds.status |= MPT2_CMD_COMPLETE;
4995 memcpy(ioc->scsih_cmds.reply, mpi_reply,
4997 ioc->scsih_cmds.status |= MPT2_CMD_REPLY_VALID;
4999 ioc->scsih_cmds.status &= ~MPT2_CMD_PENDING;
5000 complete(&ioc->scsih_cmds.done);
5006 * @ioc: per adapter object
5012 mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
5017 if (ioc->shost_recovery)
5020 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5021 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
5024 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5028 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5029 _scsih_expander_node_remove(ioc, sas_expander);
5034 * @ioc: per adapter object
5042 _scsih_check_access_status(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5091 "handle(0x%04x)\n", ioc->name, desc,
5097 _scsih_check_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
5109 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5122 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5124 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5129 "handle(0x%04x), no sas_device!!!\n", ioc->name, handle);
5130 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5142 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5148 "handle(0x%04x), flags!!!\n", ioc->name, handle);
5153 if (_scsih_check_access_status(ioc, sas_address, handle,
5156 _scsih_ublock_io_device(ioc, handle);
5162 * @ioc: per adapter object
5167 * Creating end device object, stored in ioc->sas_device_list.
5172 _scsih_add_device(struct MPT2SAS_ADAPTER *ioc, u16 handle, u8 phy_num, u8 is_pd)
5183 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5186 ioc->name, __FILE__, __LINE__, __func__);
5194 ioc->name, __FILE__, __LINE__, __func__);
5204 ioc->name, __FILE__, __LINE__, __func__);
5206 ioc->name, le16_to_cpu(sas_device_pg0.Flags));
5211 if (_scsih_check_access_status(ioc, sas_address, handle,
5219 ioc->name, __FILE__, __LINE__, __func__);
5224 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5225 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5227 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5236 ioc->name, __FILE__, __LINE__, __func__);
5241 if (_scsih_get_sas_address(ioc, le16_to_cpu
5245 ioc->name, __FILE__, __LINE__, __func__);
5256 ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5264 if (ioc->wait_for_discovery_to_complete)
5265 _scsih_sas_device_init_add(ioc, sas_device);
5267 _scsih_sas_device_add(ioc, sas_device);
5274 * @ioc: per adapter object
5280 _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
5290 _scsih_sas_device_remove(ioc, sas_device);
5292 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: "
5293 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
5300 _scsih_ublock_io_device(ioc, sas_device_backup.handle);
5305 _scsih_ublock_io_device(ioc, sas_device_backup.handle);
5307 if (!ioc->hide_drives)
5308 mpt2sas_transport_port_remove(ioc,
5313 "(0x%016llx)\n", ioc->name, sas_device_backup.handle,
5316 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: exit: "
5317 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
5324 * @ioc: per adapter object
5330 mpt2sas_device_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
5335 if (ioc->shost_recovery)
5338 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5339 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5342 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5345 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5346 _scsih_remove_device(ioc, sas_device);
5352 * @ioc: per adapter object
5357 _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5386 ioc->name, status_str);
5431 * @ioc: per adapter object
5437 _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
5452 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5453 _scsih_sas_topology_change_event_debug(ioc, event_data);
5456 if (ioc->remove_host || ioc->pci_error_recovery)
5459 if (!ioc->sas_hba.num_phys)
5460 _scsih_sas_host_add(ioc);
5462 _scsih_sas_host_refresh(ioc);
5465 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring expander "
5466 "event\n", ioc->name));
5474 if (_scsih_expander_add(ioc, parent_handle) != 0)
5477 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5478 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
5480 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5484 } else if (parent_handle < ioc->sas_hba.num_phys) {
5485 sas_address = ioc->sas_hba.sas_address;
5486 max_phys = ioc->sas_hba.num_phys;
5493 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring "
5494 "expander event\n", ioc->name));
5497 if (ioc->shost_recovery || ioc->remove_host ||
5498 ioc->pci_error_recovery)
5517 if (ioc->shost_recovery)
5523 mpt2sas_transport_update_links(ioc, sas_address,
5529 _scsih_check_device(ioc, handle);
5533 if (ioc->shost_recovery)
5536 mpt2sas_transport_update_links(ioc, sas_address,
5539 _scsih_add_device(ioc, handle, phy_number, 0);
5543 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5544 sas_device = _scsih_sas_device_find_by_handle(ioc,
5547 spin_unlock_irqrestore(&ioc->sas_device_lock,
5551 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5552 _scsih_remove_device(ioc, sas_device);
5560 mpt2sas_expander_remove(ioc, sas_address);
5573 _scsih_sas_device_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5624 ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
5628 printk(MPT2SAS_INFO_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
5636 * @ioc: per adapter object
5643 _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5654 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5655 _scsih_sas_device_status_change_event_debug(ioc,
5662 if ((ioc->facts.HeaderVersion >> 8) < 0xC)
5671 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5673 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5675 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5694 * @ioc: per adapter object
5701 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5720 " number slots(%d)\n", ioc->name, reason_str,
5729 * @ioc: per adapter object
5736 _scsih_sas_enclosure_dev_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5740 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5741 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
5748 * @ioc: per adapter object
5755 _scsih_sas_broadcast_primitive_event(struct MPT2SAS_ADAPTER *ioc,
5773 mutex_lock(&ioc->tm_cmds.mutex);
5774 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: phy number(%d), "
5775 "width(%d)\n", ioc->name, __func__, event_data->PhyNum,
5778 _scsih_block_io_all_device(ioc);
5780 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5781 mpi_reply = ioc->tm_cmds.reply;
5786 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: giving up\n",
5787 ioc->name, __func__));
5790 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: %d retry\n",
5791 ioc->name, __func__, max_retries - 1));
5795 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5796 if (ioc->shost_recovery)
5798 scmd = _scsih_scsi_lookup_get(ioc, smid);
5818 if (ioc->shost_recovery)
5821 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5822 r = mpt2sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
5829 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5838 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5847 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5853 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
5854 "%s: ABORT_TASK: giving up\n", ioc->name,
5856 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5860 if (ioc->shost_recovery)
5863 r = mpt2sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
5880 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5883 if (ioc->broadcast_aen_pending) {
5884 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: loop back due to"
5885 " pending AEN\n", ioc->name, __func__));
5886 ioc->broadcast_aen_pending = 0;
5891 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5894 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
5896 ioc->name, __func__, query_count, termination_count));
5898 ioc->broadcast_aen_busy = 0;
5899 if (!ioc->shost_recovery)
5900 _scsih_ublock_io_all_device(ioc);
5901 mutex_unlock(&ioc->tm_cmds.mutex);
5906 * @ioc: per adapter object
5913 _scsih_sas_discovery_event(struct MPT2SAS_ADAPTER *ioc,
5919 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
5920 printk(MPT2SAS_INFO_FMT "discovery event: (%s)", ioc->name,
5931 !ioc->sas_hba.num_phys)
5932 _scsih_sas_host_add(ioc);
5978 * @ioc: per adapter object
5985 _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
5994 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
5997 "failure at %s:%d/%s()!\n", ioc->name,
6002 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6003 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
6004 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6012 "failure at %s:%d/%s()!\n", ioc->name,
6017 raid_device->id = ioc->sas_id++;
6021 _scsih_raid_device_add(ioc, raid_device);
6022 if (!ioc->wait_for_discovery_to_complete) {
6023 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6026 _scsih_raid_device_remove(ioc, raid_device);
6028 _scsih_determine_boot_device(ioc, raid_device, 1);
6033 * @ioc: per adapter object
6040 _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc, u16 handle)
6046 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6047 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6048 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6057 "(0x%016llx)\n", ioc->name, raid_device->handle,
6059 _scsih_raid_device_remove(ioc, raid_device);
6064 * @ioc: per adapter object
6071 _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
6078 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6079 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6080 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6087 clear_bit(handle, ioc->pd_handles);
6093 * @ioc: per adapter object
6100 _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
6107 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6108 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6109 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6114 mpt2sas_config_get_volume_handle(ioc, handle,
6116 mpt2sas_config_get_volume_wwid(ioc, sas_device->volume_handle,
6118 set_bit(handle, ioc->pd_handles);
6125 * @ioc: per adapter object
6132 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
6139 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6140 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6141 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6144 _scsih_remove_device(ioc, sas_device);
6149 * @ioc: per adapter object
6156 _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
6168 set_bit(handle, ioc->pd_handles);
6170 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6171 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6172 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6176 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6179 ioc->name, __FILE__, __LINE__, __func__);
6187 ioc->name, __FILE__, __LINE__, __func__);
6192 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6193 mpt2sas_transport_update_links(ioc, sas_address, handle,
6196 _scsih_add_device(ioc, handle, 0, 1);
6202 * @ioc: per adapter object
6209 _scsih_sas_ir_config_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
6220 ioc->name, (le32_to_cpu(event_data->Flags) &
6283 * @ioc: per adapter object
6290 _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
6299 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6300 && !ioc->hide_ir_msg)
6301 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
6305 if (ioc->shost_recovery)
6318 _scsih_sas_volume_add(ioc, element);
6323 _scsih_sas_volume_delete(ioc,
6327 if (!ioc->is_warpdrive)
6328 _scsih_sas_pd_hide(ioc, element);
6331 if (!ioc->is_warpdrive)
6332 _scsih_sas_pd_expose(ioc, element);
6335 if (!ioc->is_warpdrive)
6336 _scsih_sas_pd_add(ioc, element);
6339 if (!ioc->is_warpdrive)
6340 _scsih_sas_pd_delete(ioc, element);
6348 * @ioc: per adapter object
6355 _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
6366 if (ioc->shost_recovery)
6374 if (!ioc->hide_ir_msg)
6375 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
6376 "old(0x%08x), new(0x%08x)\n", ioc->name, __func__, handle,
6382 _scsih_sas_volume_delete(ioc, handle);
6389 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6390 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6391 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6396 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
6399 "failure at %s:%d/%s()!\n", ioc->name,
6407 "failure at %s:%d/%s()!\n", ioc->name,
6412 raid_device->id = ioc->sas_id++;
6416 _scsih_raid_device_add(ioc, raid_device);
6417 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6420 _scsih_raid_device_remove(ioc, raid_device);
6431 * @ioc: per adapter object
6438 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
6451 if (ioc->shost_recovery)
6460 if (!ioc->hide_ir_msg)
6461 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
6462 "old(0x%08x), new(0x%08x)\n", ioc->name, __func__, handle,
6472 if (!ioc->is_warpdrive)
6473 set_bit(handle, ioc->pd_handles);
6475 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6476 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
6477 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6482 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6486 ioc->name, __FILE__, __LINE__, __func__);
6494 ioc->name, __FILE__, __LINE__, __func__);
6499 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6500 mpt2sas_transport_update_links(ioc, sas_address, handle,
6503 _scsih_add_device(ioc, handle, 0, 1);
6518 * @ioc: per adapter object
6525 _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
6553 ioc->name, reason_str,
6561 * @ioc: per adapter object
6568 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
6577 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6578 && !ioc->hide_ir_msg)
6579 _scsih_sas_ir_operation_status_event_debug(ioc,
6588 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6589 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
6590 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6603 * @ioc: per adapter object
6609 _scsih_prep_device_scan(struct MPT2SAS_ADAPTER *ioc)
6614 shost_for_each_device(sdev, ioc->shost) {
6623 * @ioc: per adapter object
6634 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6642 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6643 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
6674 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6679 * @ioc: per adapter object
6687 _scsih_search_responding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
6697 printk(MPT2SAS_INFO_FMT "search for end-devices: start\n", ioc->name);
6699 if (list_empty(&ioc->sas_device_list))
6703 while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6716 _scsih_mark_responding_sas_device(ioc, sas_address, slot,
6721 ioc->name);
6726 * @ioc: per adapter object
6736 _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
6744 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6745 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
6754 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6763 _scsih_init_warpdrive_properties(ioc, raid_device);
6775 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6780 * @ioc: per adapter object
6788 _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
6798 if (!ioc->ir_firmware)
6802 ioc->name);
6804 if (list_empty(&ioc->raid_device_list))
6808 while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
6816 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
6824 _scsih_mark_responding_raid_device(ioc,
6829 if (!ioc->is_warpdrive) {
6831 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
6832 while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
6841 set_bit(handle, ioc->pd_handles);
6846 "complete\n", ioc->name);
6851 * @ioc: per adapter object
6861 _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6868 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6869 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6885 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6890 * @ioc: per adapter object
6898 _scsih_search_responding_expanders(struct MPT2SAS_ADAPTER *ioc)
6906 printk(MPT2SAS_INFO_FMT "search for expanders: start\n", ioc->name);
6908 if (list_empty(&ioc->sas_expander_list))
6912 while (!(mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
6925 _scsih_mark_responding_expander(ioc, sas_address, handle);
6929 printk(MPT2SAS_INFO_FMT "search for expanders: complete\n", ioc->name);
6934 * @ioc: per adapter object
6939 _scsih_remove_unresponding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
6946 ioc->name);
6949 &ioc->sas_device_list, list) {
6963 _scsih_remove_device(ioc, sas_device);
6966 if (!ioc->ir_firmware)
6970 &ioc->raid_device_list, list) {
6982 _scsih_raid_device_remove(ioc, raid_device);
6987 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6992 mpt2sas_expander_remove(ioc, sas_expander->sas_address);
6996 ioc->name);
6998 _scsih_ublock_io_all_device(ioc);
7002 _scsih_refresh_expander_links(struct MPT2SAS_ADAPTER *ioc,
7010 if ((mpt2sas_config_get_expander_pg1(ioc, &mpi_reply,
7013 ioc->name, __FILE__, __LINE__, __func__);
7017 mpt2sas_transport_update_links(ioc, sas_expander->sas_address,
7025 * @ioc: per adapter object
7030 _scsih_scan_for_devices_after_reset(struct MPT2SAS_ADAPTER *ioc)
7047 printk(MPT2SAS_INFO_FMT "scan devices: start\n", ioc->name);
7049 _scsih_sas_host_refresh(ioc);
7053 while (!(mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
7061 ioc, le64_to_cpu(expander_pg0.SASAddress));
7063 _scsih_refresh_expander_links(ioc, expander_device,
7066 _scsih_expander_add(ioc, handle);
7069 if (!ioc->ir_firmware)
7074 while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
7083 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
7086 if (mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7091 if (!_scsih_get_sas_address(ioc, parent_handle,
7093 mpt2sas_transport_update_links(ioc, sas_address,
7096 set_bit(handle, ioc->pd_handles);
7097 _scsih_add_device(ioc, handle, 0, 1);
7103 while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
7110 raid_device = _scsih_raid_device_find_by_wwid(ioc,
7114 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
7124 _scsih_sas_volume_add(ioc, &element);
7132 while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7143 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
7148 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
7149 mpt2sas_transport_update_links(ioc, sas_address, handle,
7151 _scsih_add_device(ioc, handle, 0, 0);
7155 printk(MPT2SAS_INFO_FMT "scan devices: complete\n", ioc->name);
7161 * @ioc: per adapter object
7172 mpt2sas_scsih_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
7176 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
7177 "MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
7180 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
7181 "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
7182 if (ioc->scsih_cmds.status & MPT2_CMD_PENDING) {
7183 ioc->scsih_cmds.status |= MPT2_CMD_RESET;
7184 mpt2sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
7185 complete(&ioc->scsih_cmds.done);
7187 if (ioc->tm_cmds.status & MPT2_CMD_PENDING) {
7188 ioc->tm_cmds.status |= MPT2_CMD_RESET;
7189 mpt2sas_base_free_smid(ioc, ioc->tm_cmds.smid);
7190 complete(&ioc->tm_cmds.done);
7192 _scsih_fw_event_cleanup_queue(ioc);
7193 _scsih_flush_running_cmds(ioc);
7196 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
7197 "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
7198 _scsih_sas_host_refresh(ioc);
7199 _scsih_prep_device_scan(ioc);
7200 _scsih_search_responding_sas_devices(ioc);
7201 _scsih_search_responding_raid_devices(ioc);
7202 _scsih_search_responding_expanders(ioc);
7203 if (!ioc->is_driver_loading) {
7204 _scsih_prep_device_scan(ioc);
7205 _scsih_search_responding_sas_devices(ioc);
7206 _scsih_search_responding_raid_devices(ioc);
7207 _scsih_search_responding_expanders(ioc);
7208 _scsih_error_recovery_delete_devices(ioc);
7216 * @ioc: per adapter object
7227 struct MPT2SAS_ADAPTER *ioc = fw_event->ioc;
7230 if (ioc->remove_host || fw_event->cancel_pending_work ||
7231 ioc->pci_error_recovery) {
7232 _scsih_fw_event_free(ioc, fw_event);
7238 while (scsi_host_in_recovery(ioc->shost))
7240 _scsih_remove_unresponding_sas_devices(ioc);
7241 _scsih_scan_for_devices_after_reset(ioc);
7244 ioc->start_scan = 0;
7248 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "port enable: complete "
7249 "from worker thread\n", ioc->name));
7252 _scsih_turn_on_fault_led(ioc, fw_event->device_handle);
7255 _scsih_sas_topology_change_event(ioc, fw_event);
7258 _scsih_sas_device_status_change_event(ioc,
7262 _scsih_sas_discovery_event(ioc,
7266 _scsih_sas_broadcast_primitive_event(ioc,
7270 _scsih_sas_enclosure_dev_status_change_event(ioc,
7274 _scsih_sas_ir_config_change_event(ioc, fw_event);
7277 _scsih_sas_ir_volume_event(ioc, fw_event);
7280 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
7283 _scsih_sas_ir_operation_status_event(ioc, fw_event);
7286 _scsih_fw_event_free(ioc, fw_event);
7291 * @ioc: per adapter object
7296 * This function merely adds a new work task into ioc->firmware_event_thread.
7303 mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
7312 if (ioc->remove_host || ioc->pci_error_recovery)
7315 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
7330 if (ioc->broadcast_aen_busy) {
7331 ioc->broadcast_aen_pending++;
7334 ioc->broadcast_aen_busy = 1;
7339 _scsih_check_topo_delete_events(ioc,
7344 _scsih_check_ir_config_unhide_events(ioc,
7349 _scsih_check_volume_delete_events(ioc,
7358 if (!ioc->is_warpdrive)
7374 "additional details.\n", ioc->name);
7380 "for additional details.\n", ioc->name);
7387 "for additional details.\n", ioc->name);
7394 ioc->name);
7414 ioc->name, __FILE__, __LINE__, __func__);
7421 ioc->name, __FILE__, __LINE__, __func__);
7428 fw_event->ioc = ioc;
7432 _scsih_fw_event_add(ioc, fw_event);
7468 * @ioc: per adapter object
7470 * Context: Calling function should acquire ioc->sas_node_lock.
7473 * ioc->sas_expander_list.
7478 _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
7486 if (ioc->shost_recovery)
7490 mpt2sas_device_remove(ioc,
7496 mpt2sas_expander_remove(ioc,
7500 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
7504 "(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7514 * @ioc: per adapter object
7522 _scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
7529 if (!ioc->ir_firmware)
7533 if (list_empty(&ioc->raid_device_list))
7536 mutex_lock(&ioc->scsih_cmds.mutex);
7538 if (ioc->scsih_cmds.status != MPT2_CMD_NOT_USED) {
7540 ioc->name, __func__);
7543 ioc->scsih_cmds.status = MPT2_CMD_PENDING;
7545 smid = mpt2sas_base_get_smid(ioc, ioc->scsih_cb_idx);
7548 ioc->name, __func__);
7549 ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
7553 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
7554 ioc->scsih_cmds.smid = smid;
7560 if (!ioc->hide_ir_msg)
7561 printk(MPT2SAS_INFO_FMT "IR shutdown (sending)\n", ioc->name);
7562 init_completion(&ioc->scsih_cmds.done);
7563 mpt2sas_base_put_smid_default(ioc, smid);
7564 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
7566 if (!(ioc->scsih_cmds.status & MPT2_CMD_COMPLETE)) {
7568 ioc->name, __func__);
7572 if (ioc->scsih_cmds.status & MPT2_CMD_REPLY_VALID) {
7573 mpi_reply = ioc->scsih_cmds.reply;
7575 if (!ioc->hide_ir_msg)
7578 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
7583 ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
7584 mutex_unlock(&ioc->scsih_cmds.mutex);
7597 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7601 ioc->remove_host = 1;
7602 _scsih_fw_event_cleanup_queue(ioc);
7604 spin_lock_irqsave(&ioc->fw_event_lock, flags);
7605 wq = ioc->firmware_event_thread;
7606 ioc->firmware_event_thread = NULL;
7607 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
7611 _scsih_ir_shutdown(ioc);
7612 mpt2sas_base_detach(ioc);
7626 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7633 ioc->remove_host = 1;
7634 _scsih_fw_event_cleanup_queue(ioc);
7636 spin_lock_irqsave(&ioc->fw_event_lock, flags);
7637 wq = ioc->firmware_event_thread;
7638 ioc->firmware_event_thread = NULL;
7639 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
7644 _scsih_ir_shutdown(ioc);
7645 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
7654 "(0x%016llx)\n", ioc->name, raid_device->handle,
7656 _scsih_raid_device_remove(ioc, raid_device);
7661 &ioc->sas_hba.sas_port_list, port_list) {
7664 mpt2sas_device_remove(ioc,
7670 mpt2sas_expander_remove(ioc,
7675 if (ioc->sas_hba.num_phys) {
7676 kfree(ioc->sas_hba.phy);
7677 ioc->sas_hba.phy = NULL;
7678 ioc->sas_hba.num_phys = 0;
7682 mpt2sas_base_detach(ioc);
7683 list_del(&ioc->list);
7690 * @ioc: per adapter object
7697 _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
7710 if (!ioc->bios_pg3.BiosVersion)
7715 if (ioc->req_boot_device.device) {
7716 device = ioc->req_boot_device.device;
7717 is_raid = ioc->req_boot_device.is_raid;
7718 } else if (ioc->req_alt_boot_device.device) {
7719 device = ioc->req_alt_boot_device.device;
7720 is_raid = ioc->req_alt_boot_device.is_raid;
7721 } else if (ioc->current_boot_device.device) {
7722 device = ioc->current_boot_device.device;
7723 is_raid = ioc->current_boot_device.is_raid;
7731 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
7734 _scsih_raid_device_remove(ioc, raid_device);
7740 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7741 list_move_tail(&sas_device->list, &ioc->sas_device_list);
7742 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7744 if (ioc->hide_drives)
7746 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
7748 _scsih_sas_device_remove(ioc, sas_device);
7750 if (!ioc->is_driver_loading)
7751 mpt2sas_transport_port_remove(ioc, sas_address,
7753 _scsih_sas_device_remove(ioc, sas_device);
7760 * @ioc: per adapter object
7765 _scsih_probe_raid(struct MPT2SAS_ADAPTER *ioc)
7771 &ioc->raid_device_list, list) {
7774 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
7777 _scsih_raid_device_remove(ioc, raid_device);
7783 * @ioc: per adapter object
7788 _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
7794 list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
7797 if (ioc->hide_drives)
7800 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
7806 if (!ioc->is_driver_loading)
7807 mpt2sas_transport_port_remove(ioc,
7815 spin_lock_irqsave(&ioc->sas_device_lock, flags);
7816 list_move_tail(&sas_device->list, &ioc->sas_device_list);
7817 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7823 * @ioc: per adapter object
7828 _scsih_probe_devices(struct MPT2SAS_ADAPTER *ioc)
7832 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
7835 _scsih_probe_boot_devices(ioc);
7837 if (ioc->ir_firmware) {
7839 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
7843 _scsih_probe_raid(ioc);
7844 _scsih_probe_sas(ioc);
7846 _scsih_probe_sas(ioc);
7847 _scsih_probe_raid(ioc);
7850 _scsih_probe_sas(ioc);
7865 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7869 mpt2sas_enable_diag_buffer(ioc, diag_buffer_enable);
7871 ioc->start_scan = 1;
7872 rc = mpt2sas_port_enable(ioc);
7875 printk(MPT2SAS_INFO_FMT "port enable: FAILED\n", ioc->name);
7890 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7893 ioc->base_cmds.status = MPT2_CMD_NOT_USED;
7895 "(timeout=300s)\n", ioc->name);
7896 ioc->is_driver_loading = 0;
7900 if (ioc->start_scan)
7903 if (ioc->start_scan_failed) {
7905 "(ioc_status=0x%08x)\n", ioc->name, ioc->start_scan_failed);
7906 ioc->is_driver_loading = 0;
7907 ioc->wait_for_discovery_to_complete = 0;
7908 ioc->remove_host = 1;
7912 printk(MPT2SAS_INFO_FMT "port enable: SUCCESS\n", ioc->name);
7913 ioc->base_cmds.status = MPT2_CMD_NOT_USED;
7915 if (ioc->wait_for_discovery_to_complete) {
7916 ioc->wait_for_discovery_to_complete = 0;
7917 _scsih_probe_devices(ioc);
7919 mpt2sas_base_start_watchdog(ioc);
7920 ioc->is_driver_loading = 0;
7935 struct MPT2SAS_ADAPTER *ioc;
7944 ioc = shost_priv(shost);
7945 memset(ioc, 0, sizeof(struct MPT2SAS_ADAPTER));
7946 INIT_LIST_HEAD(&ioc->list);
7947 list_add_tail(&ioc->list, &mpt2sas_ioc_list);
7948 ioc->shost = shost;
7949 ioc->id = mpt_ids++;
7950 sprintf(ioc->name, "%s%d", MPT2SAS_DRIVER_NAME, ioc->id);
7951 ioc->pdev = pdev;
7953 ioc->is_warpdrive = 1;
7954 ioc->hide_ir_msg = 1;
7956 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
7957 ioc->scsi_io_cb_idx = scsi_io_cb_idx;
7958 ioc->tm_cb_idx = tm_cb_idx;
7959 ioc->ctl_cb_idx = ctl_cb_idx;
7960 ioc->base_cb_idx = base_cb_idx;
7961 ioc->port_enable_cb_idx = port_enable_cb_idx;
7962 ioc->transport_cb_idx = transport_cb_idx;
7963 ioc->scsih_cb_idx = scsih_cb_idx;
7964 ioc->config_cb_idx = config_cb_idx;
7965 ioc->tm_tr_cb_idx = tm_tr_cb_idx;
7966 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
7967 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
7968 ioc->logging_level = logging_level;
7969 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
7971 mutex_init(&ioc->reset_in_progress_mutex);
7972 spin_lock_init(&ioc->ioc_reset_in_progress_lock);
7973 spin_lock_init(&ioc->scsi_lookup_lock);
7974 spin_lock_init(&ioc->sas_device_lock);
7975 spin_lock_init(&ioc->sas_node_lock);
7976 spin_lock_init(&ioc->fw_event_lock);
7977 spin_lock_init(&ioc->raid_device_lock);
7979 INIT_LIST_HEAD(&ioc->sas_device_list);
7980 INIT_LIST_HEAD(&ioc->sas_device_init_list);
7981 INIT_LIST_HEAD(&ioc->sas_expander_list);
7982 INIT_LIST_HEAD(&ioc->fw_event_list);
7983 INIT_LIST_HEAD(&ioc->raid_device_list);
7984 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
7985 INIT_LIST_HEAD(&ioc->delayed_tr_list);
7986 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
7992 shost->unique_id = ioc->id;
7999 "value of 64.\n", ioc->name, max_sectors);
8004 "default value of 32767.\n", ioc->name,
8009 "set to %d\n", ioc->name, shost->max_sectors);
8015 ioc->name, __FILE__, __LINE__, __func__);
8016 list_del(&ioc->list);
8025 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
8026 "fw_event%d", ioc->id);
8027 ioc->firmware_event_thread = create_singlethread_workqueue(
8028 ioc->firmware_event_name);
8029 if (!ioc->firmware_event_thread) {
8031 ioc->name, __FILE__, __LINE__, __func__);
8035 ioc->is_driver_loading = 1;
8036 if ((mpt2sas_base_attach(ioc))) {
8038 ioc->name, __FILE__, __LINE__, __func__);
8042 if (ioc->is_warpdrive) {
8043 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS)
8044 ioc->hide_drives = 0;
8045 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS)
8046 ioc->hide_drives = 1;
8048 if (_scsih_get_num_volumes(ioc))
8049 ioc->hide_drives = 1;
8051 ioc->hide_drives = 0;
8054 ioc->hide_drives = 0;
8060 destroy_workqueue(ioc->firmware_event_thread);
8062 list_del(&ioc->list);
8081 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
8084 mpt2sas_base_stop_watchdog(ioc);
8088 "operating state [D%d]\n", ioc->name, pdev,
8091 mpt2sas_base_free_resources(ioc);
8108 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
8113 "operating state [D%d]\n", ioc->name, pdev,
8119 ioc->pdev = pdev;
8120 r = mpt2sas_base_map_resources(ioc);
8124 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
8126 mpt2sas_base_start_watchdog(ioc);
8145 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
8148 ioc->name, state);
8155 ioc->pci_error_recovery = 1;
8156 scsi_block_requests(ioc->shost);
8157 mpt2sas_base_stop_watchdog(ioc);
8158 mpt2sas_base_free_resources(ioc);
8162 ioc->pci_error_recovery = 1;
8163 mpt2sas_base_stop_watchdog(ioc);
8164 _scsih_flush_running_cmds(ioc);
8182 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
8186 ioc->name);
8188 ioc->pci_error_recovery = 0;
8189 ioc->pdev = pdev;
8191 rc = mpt2sas_base_map_resources(ioc);
8196 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
8199 printk(MPT2SAS_WARN_FMT "hard reset: %s\n", ioc->name,
8220 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
8222 printk(MPT2SAS_INFO_FMT "PCI error: resume callback!!\n", ioc->name);
8225 mpt2sas_base_start_watchdog(ioc);
8226 scsi_unblock_requests(ioc->shost);
8237 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
8240 ioc->name);