Lines Matching defs:ioc
69 static void _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
73 static u8 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid);
121 * @work: work object (ioc->fault_reset_work_q)
123 * @ioc: per adapter object
130 * This object stored on ioc->fw_event_list.
136 struct MPT2SAS_ADAPTER *ioc;
163 * @ioc_status: ioc status
241 * _scsih_set_debug_level - global setting of ioc->logging_level.
249 struct MPT2SAS_ADAPTER *ioc;
255 list_for_each_entry(ioc, &mpt2sas_ioc_list, list)
256 ioc->logging_level = logging_level;
360 _scsih_get_sas_address(struct MPT2SAS_ADAPTER *ioc, u16 handle,
367 if (handle <= ioc->sas_hba.num_phys) {
368 *sas_address = ioc->sas_hba.sas_address;
373 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
376 ioc->name, __FILE__, __LINE__, __func__);
384 "\nfailure at %s:%d/%s()!\n", ioc->name, handle, ioc_status,
395 * @ioc: per adapter object
403 * the corresponding device object and is_raid flag in the ioc object.
407 _scsih_determine_boot_device(struct MPT2SAS_ADAPTER *ioc,
418 if (!ioc->wait_for_port_enable_to_complete)
435 if (!ioc->req_boot_device.device) {
438 (ioc->bios_pg2.ReqBootDeviceForm &
440 &ioc->bios_pg2.RequestedBootDevice)) {
441 dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
443 ioc->name, __func__,
445 ioc->req_boot_device.device = device;
446 ioc->req_boot_device.is_raid = is_raid;
450 if (!ioc->req_alt_boot_device.device) {
453 (ioc->bios_pg2.ReqAltBootDeviceForm &
455 &ioc->bios_pg2.RequestedAltBootDevice)) {
456 dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
458 ioc->name, __func__,
460 ioc->req_alt_boot_device.device = device;
461 ioc->req_alt_boot_device.is_raid = is_raid;
465 if (!ioc->current_boot_device.device) {
468 (ioc->bios_pg2.CurrentBootDeviceForm &
470 &ioc->bios_pg2.CurrentBootDevice)) {
471 dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
473 ioc->name, __func__,
475 ioc->current_boot_device.device = device;
476 ioc->current_boot_device.is_raid = is_raid;
483 * @ioc: per adapter object
485 * Context: Calling function should acquire ioc->sas_device_lock
491 mpt2sas_scsih_sas_device_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
496 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
500 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
509 * @ioc: per adapter object
511 * Context: Calling function should acquire ioc->sas_device_lock
517 _scsih_sas_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
521 list_for_each_entry(sas_device, &ioc->sas_device_list, list)
525 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
534 * @ioc: per adapter object
536 * Context: This function will acquire ioc->sas_device_lock.
538 * Removing object and freeing associated memory from the ioc->sas_device_list.
541 _scsih_sas_device_remove(struct MPT2SAS_ADAPTER *ioc,
549 spin_lock_irqsave(&ioc->sas_device_lock, flags);
550 if (mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
555 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
560 * @ioc: per adapter object
562 * Context: This function will acquire ioc->sas_device_lock.
564 * Adding new object to the ioc->sas_device_list.
567 _scsih_sas_device_add(struct MPT2SAS_ADAPTER *ioc,
572 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
573 "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
576 spin_lock_irqsave(&ioc->sas_device_lock, flags);
577 list_add_tail(&sas_device->list, &ioc->sas_device_list);
578 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
580 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
582 _scsih_sas_device_remove(ioc, sas_device);
587 * @ioc: per adapter object
589 * Context: This function will acquire ioc->sas_device_lock.
591 * Adding new object at driver load time to the ioc->sas_device_init_list.
594 _scsih_sas_device_init_add(struct MPT2SAS_ADAPTER *ioc,
599 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
600 "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
603 spin_lock_irqsave(&ioc->sas_device_lock, flags);
604 list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
605 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
606 _scsih_determine_boot_device(ioc, sas_device, 0);
611 * @ioc: per adapter object
614 * Context: Calling function should acquire ioc->raid_device_lock
620 _scsih_raid_device_find_by_id(struct MPT2SAS_ADAPTER *ioc, int id, int channel)
625 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
638 * @ioc: per adapter object
640 * Context: Calling function should acquire ioc->raid_device_lock
646 _scsih_raid_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
651 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
664 * @ioc: per adapter object
666 * Context: Calling function should acquire ioc->raid_device_lock
672 _scsih_raid_device_find_by_wwid(struct MPT2SAS_ADAPTER *ioc, u64 wwid)
677 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
690 * @ioc: per adapter object
696 _scsih_raid_device_add(struct MPT2SAS_ADAPTER *ioc,
701 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle"
702 "(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
705 spin_lock_irqsave(&ioc->raid_device_lock, flags);
706 list_add_tail(&raid_device->list, &ioc->raid_device_list);
707 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
712 * @ioc: per adapter object
718 _scsih_raid_device_remove(struct MPT2SAS_ADAPTER *ioc,
723 spin_lock_irqsave(&ioc->raid_device_lock, flags);
727 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
732 * @ioc: per adapter object
734 * Context: Calling function should acquire ioc->sas_device_lock
740 mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
745 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
757 * @ioc: per adapter object
759 * Context: Calling function should acquire ioc->sas_node_lock.
765 mpt2sas_scsih_expander_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
771 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
783 * @ioc: per adapter object
785 * Context: This function will acquire ioc->sas_node_lock.
787 * Adding new object to the ioc->sas_expander_list.
792 _scsih_expander_node_add(struct MPT2SAS_ADAPTER *ioc,
797 spin_lock_irqsave(&ioc->sas_node_lock, flags);
798 list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
799 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
823 * @ioc: per adapter object
829 _scsih_scsi_lookup_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
831 return ioc->scsi_lookup[smid - 1].scmd;
836 * @ioc: per adapter object
843 _scsih_scsi_lookup_get_clear(struct MPT2SAS_ADAPTER *ioc, u16 smid)
848 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
849 scmd = ioc->scsi_lookup[smid - 1].scmd;
850 ioc->scsi_lookup[smid - 1].scmd = NULL;
851 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
858 * @ioc: per adapter object
861 * Context: This function will acquire ioc->scsi_lookup_lock.
867 _scsih_scsi_lookup_find_by_scmd(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd
874 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
876 for (i = 0; i < ioc->scsiio_depth; i++) {
877 if (ioc->scsi_lookup[i].scmd == scmd) {
878 smid = ioc->scsi_lookup[i].smid;
883 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
889 * @ioc: per adapter object
892 * Context: This function will acquire ioc->scsi_lookup_lock.
898 _scsih_scsi_lookup_find_by_target(struct MPT2SAS_ADAPTER *ioc, int id,
905 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
907 for (i = 0 ; i < ioc->scsiio_depth; i++) {
908 if (ioc->scsi_lookup[i].scmd &&
909 (ioc->scsi_lookup[i].scmd->device->id == id &&
910 ioc->scsi_lookup[i].scmd->device->channel == channel)) {
916 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
922 * @ioc: per adapter object
926 * Context: This function will acquire ioc->scsi_lookup_lock.
932 _scsih_scsi_lookup_find_by_lun(struct MPT2SAS_ADAPTER *ioc, int id,
939 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
941 for (i = 0 ; i < ioc->scsiio_depth; i++) {
942 if (ioc->scsi_lookup[i].scmd &&
943 (ioc->scsi_lookup[i].scmd->device->id == id &&
944 ioc->scsi_lookup[i].scmd->device->channel == channel &&
945 ioc->scsi_lookup[i].scmd->device->lun == lun)) {
951 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
957 * @ioc: per adapter object
963 _scsih_get_chain_buffer_dma(struct MPT2SAS_ADAPTER *ioc, u16 smid)
965 return ioc->chain_dma + ((smid - 1) * (ioc->request_sz *
966 ioc->chains_needed_per_io));
971 * @ioc: per adapter object
977 _scsih_get_chain_buffer(struct MPT2SAS_ADAPTER *ioc, u16 smid)
979 return (void *)(ioc->chain + ((smid - 1) * (ioc->request_sz *
980 ioc->chains_needed_per_io)));
985 * @ioc: per adapter object
996 _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
1012 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1034 sges_in_segment = ioc->max_sges_in_main_message;
1039 (sges_in_segment * ioc->sge_size))/4;
1044 ioc->base_add_sg_single(sg_local,
1048 ioc->base_add_sg_single(sg_local, sgl_flags |
1051 sg_local += ioc->sge_size;
1058 chain = _scsih_get_chain_buffer(ioc, smid);
1059 chain_dma = _scsih_get_chain_buffer_dma(ioc, smid);
1062 ioc->max_sges_in_chain_message) ? sges_left :
1063 ioc->max_sges_in_chain_message;
1065 0 : (sges_in_segment * ioc->sge_size)/4;
1066 chain_length = sges_in_segment * ioc->sge_size;
1070 chain_length += ioc->sge_size;
1072 ioc->base_add_sg_single(sg_local, chain_flags | chain_offset |
1081 ioc->base_add_sg_single(sg_local,
1086 ioc->base_add_sg_single(sg_local, sgl_flags |
1090 sg_local += ioc->sge_size;
1095 chain_dma += ioc->request_sz;
1096 chain += ioc->request_sz;
1105 ioc->base_add_sg_single(sg_local, sgl_flags_end_buffer |
1108 ioc->base_add_sg_single(sg_local, sgl_flags |
1111 sg_local += ioc->sge_size;
1132 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1152 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1153 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1155 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1212 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1229 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1230 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1238 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1243 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1245 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1254 if (test_bit(sas_device->handle, ioc->pd_handles))
1258 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1273 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1285 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1286 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1292 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1296 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1298 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1305 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1323 struct MPT2SAS_ADAPTER *ioc;
1346 ioc = shost_priv(shost);
1348 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1349 raid_device = _scsih_raid_device_find_by_id(ioc,
1353 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1383 * @ioc: per adapter object
1388 _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
1397 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1400 ioc->name, __FILE__, __LINE__, __func__);
1408 ioc->name, __FILE__, __LINE__, __func__);
1447 struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1455 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1456 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1458 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1463 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1467 ioc->name, __FILE__, __LINE__, __func__);
1486 struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
1494 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1495 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1497 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1502 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1506 ioc->name, __FILE__, __LINE__, __func__);
1563 * @ioc: per adapter object
1567 _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
1577 if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
1580 ioc->name, __FILE__, __LINE__, __func__);
1590 ioc->name, __FILE__, __LINE__, __func__);
1594 if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1597 ioc->name, __FILE__, __LINE__, __func__);
1607 if (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1610 if (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
1623 * @ioc: per adapter object
1631 _scsih_enable_tlr(struct MPT2SAS_ADAPTER *ioc, struct scsi_device *sdev)
1637 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
1658 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
1678 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1679 raid_device = _scsih_raid_device_find_by_handle(ioc,
1681 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1684 ioc->name, __FILE__, __LINE__, __func__);
1688 _scsih_get_volume_capabilities(ioc, raid_device);
1714 if (ioc->manu_pg10.OEMIdentifier &&
1715 (ioc->manu_pg10.GenericFlags0 &
1749 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1750 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
1752 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1756 mpt2sas_config_get_volume_handle(ioc,
1758 mpt2sas_config_get_volume_wwid(ioc,
1788 _scsih_display_sata_capabilities(ioc, sas_device, sdev);
1795 _scsih_enable_tlr(ioc, sdev);
1850 * @ioc: per adapter object
1856 _scsih_response_code(struct MPT2SAS_ADAPTER *ioc, u8 response_code)
1890 ioc->name, response_code, desc);
1895 * @ioc: per adapter object
1907 _scsih_tm_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
1911 if (ioc->tm_cmds.status == MPT2_CMD_NOT_USED)
1913 if (ioc->tm_cmds.smid != smid)
1915 ioc->tm_cmds.status |= MPT2_CMD_COMPLETE;
1916 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
1918 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
1919 ioc->tm_cmds.status |= MPT2_CMD_REPLY_VALID;
1921 ioc->tm_cmds.status &= ~MPT2_CMD_PENDING;
1922 complete(&ioc->tm_cmds.done);
1928 * @ioc: per adapter object
1934 mpt2sas_scsih_set_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
1940 shost_for_each_device(sdev, ioc->shost) {
1949 ioc->ignore_loginfos = 1;
1956 * @ioc: per adapter object
1962 mpt2sas_scsih_clear_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
1968 shost_for_each_device(sdev, ioc->shost) {
1977 ioc->ignore_loginfos = 0;
1985 * @ioc: per adapter struct
1997 * The callback index is set inside `ioc->tm_cb_idx`.
2002 mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle, uint channel,
2014 mutex_lock(&ioc->tm_cmds.mutex);
2015 if (ioc->tm_cmds.status != MPT2_CMD_NOT_USED) {
2017 __func__, ioc->name);
2022 if (ioc->shost_recovery || ioc->remove_host ||
2023 ioc->pci_error_recovery) {
2025 __func__, ioc->name);
2030 ioc_state = mpt2sas_base_get_iocstate(ioc, 0);
2032 dhsprintk(ioc, printk(MPT2SAS_INFO_FMT "unexpected doorbell "
2033 "active!\n", ioc->name));
2034 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2041 mpt2sas_base_fault_info(ioc, ioc_state &
2043 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2049 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2052 ioc->name, __func__);
2057 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "sending tm: handle(0x%04x),"
2058 " task_type(0x%02x), smid(%d)\n", ioc->name, handle, type,
2060 ioc->tm_cmds.status = MPT2_CMD_PENDING;
2061 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2062 ioc->tm_cmds.smid = smid;
2069 mpt2sas_scsih_set_tm_flag(ioc, handle);
2070 init_completion(&ioc->tm_cmds.done);
2071 mpt2sas_base_put_smid_hi_priority(ioc, smid);
2072 timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2073 if (!(ioc->tm_cmds.status & MPT2_CMD_COMPLETE)) {
2075 ioc->name, __func__);
2078 if (!(ioc->tm_cmds.status & MPT2_CMD_RESET)) {
2079 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2082 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2083 mpt2sas_scsih_clear_tm_flag(ioc, handle);
2088 if (ioc->tm_cmds.status & MPT2_CMD_REPLY_VALID) {
2089 mpi_reply = ioc->tm_cmds.reply;
2090 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "complete tm: "
2092 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
2095 if (ioc->logging_level & MPT_DEBUG_TM) {
2096 _scsih_response_code(ioc, mpi_reply->ResponseCode);
2112 scmd_lookup = _scsih_scsi_lookup_get(ioc, smid_task);
2121 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
2128 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
2137 mpt2sas_scsih_clear_tm_flag(ioc, handle);
2138 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
2139 mutex_unlock(&ioc->tm_cmds.mutex);
2144 mutex_unlock(&ioc->tm_cmds.mutex);
2150 * @ioc: per adapter struct
2156 _scsih_tm_display_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2173 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2174 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2195 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2208 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2216 _scsih_tm_display_info(ioc, scmd);
2229 smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
2245 mpt2sas_halt_firmware(ioc);
2248 r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2267 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2278 _scsih_tm_display_info(ioc, scmd);
2294 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2295 sas_device = _scsih_sas_device_find_by_handle(ioc,
2299 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2309 r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2328 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2338 _scsih_tm_display_info(ioc, scmd);
2354 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2355 sas_device = _scsih_sas_device_find_by_handle(ioc,
2359 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2369 r = mpt2sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2388 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2392 ioc->name, scmd);
2395 retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2399 ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2406 * @ioc: per adapter object
2408 * Context: This function will acquire ioc->fw_event_lock.
2416 _scsih_fw_event_add(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
2420 if (ioc->firmware_event_thread == NULL)
2423 spin_lock_irqsave(&ioc->fw_event_lock, flags);
2424 list_add_tail(&fw_event->list, &ioc->fw_event_list);
2426 queue_delayed_work(ioc->firmware_event_thread,
2428 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2433 * @ioc: per adapter object
2435 * Context: This function will acquire ioc->fw_event_lock.
2442 _scsih_fw_event_free(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
2447 spin_lock_irqsave(&ioc->fw_event_lock, flags);
2451 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2457 * @ioc: per adapter object
2462 _scsih_queue_rescan(struct MPT2SAS_ADAPTER *ioc)
2466 if (ioc->wait_for_port_enable_to_complete)
2472 fw_event->ioc = ioc;
2473 _scsih_fw_event_add(ioc, fw_event);
2478 * @ioc: per adapter object
2486 _scsih_fw_event_cleanup_queue(struct MPT2SAS_ADAPTER *ioc)
2490 if (list_empty(&ioc->fw_event_list) ||
2491 !ioc->firmware_event_thread || in_interrupt())
2494 list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
2496 _scsih_fw_event_free(ioc, fw_event);
2505 * @ioc: per adapter object
2511 _scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2516 shost_for_each_device(sdev, ioc->shost) {
2523 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2525 "handle(0x%04x)\n", ioc->name, handle));
2534 * @ioc: per adapter object
2540 _scsih_block_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2545 shost_for_each_device(sdev, ioc->shost) {
2552 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2554 "handle(0x%04x)\n", ioc->name, handle));
2563 * @ioc: per adapter object
2571 _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
2586 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2588 mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
2590 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2593 _scsih_block_io_device(ioc, sas_device->handle);
2605 spin_lock_irqsave(&ioc->sas_node_lock, flags);
2608 ioc, mpt2sas_port->remote_identify.sas_address);
2609 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
2610 _scsih_block_io_to_children_attached_to_ex(ioc,
2618 * @ioc: per adapter object
2625 _scsih_block_io_to_children_attached_directly(struct MPT2SAS_ADAPTER *ioc,
2641 _scsih_block_io_device(ioc, handle);
2647 * @ioc: per adapter object
2661 _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2670 if (ioc->shost_recovery || ioc->remove_host ||
2671 ioc->pci_error_recovery) {
2672 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
2673 "progress!\n", __func__, ioc->name));
2678 if (test_bit(handle, ioc->pd_handles))
2681 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2682 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
2687 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
2689 "sas_addr(0x%016llx)\n", ioc->name, handle,
2692 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2694 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
2701 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
2702 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
2704 ioc->name, handle));
2708 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
2709 "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
2710 ioc->tm_tr_cb_idx));
2711 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2716 mpt2sas_base_put_smid_hi_priority(ioc, smid);
2723 * @ioc: per adapter object
2737 _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
2741 mpt2sas_base_get_reply_virt_addr(ioc, reply);
2743 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
2746 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
2754 * @ioc: per adapter object
2763 _scsih_tm_tr_volume_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
2769 if (ioc->shost_recovery || ioc->remove_host ||
2770 ioc->pci_error_recovery) {
2771 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
2772 "progress!\n", __func__, ioc->name));
2776 smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
2783 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
2784 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
2786 ioc->name, handle));
2790 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "tr_send:handle(0x%04x), "
2791 "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid,
2792 ioc->tm_tr_volume_cb_idx));
2793 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
2798 mpt2sas_base_put_smid_hi_priority(ioc, smid);
2803 * @ioc: per adapter object
2813 _scsih_tm_volume_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
2819 mpt2sas_base_get_reply_virt_addr(ioc, reply);
2821 if (ioc->shost_recovery || ioc->remove_host ||
2822 ioc->pci_error_recovery) {
2823 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
2824 "progress!\n", __func__, ioc->name));
2828 mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
2831 dewtprintk(ioc, printk("spurious interrupt: "
2837 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
2839 "loginfo(0x%08x), completed(%d)\n", ioc->name,
2844 return _scsih_check_for_pending_tm(ioc, smid);
2849 * @ioc: per adapter object
2864 _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
2870 mpt2sas_base_get_reply_virt_addr(ioc, reply);
2874 if (ioc->shost_recovery || ioc->remove_host ||
2875 ioc->pci_error_recovery) {
2876 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: host reset in "
2877 "progress!\n", __func__, ioc->name));
2881 mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
2884 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "spurious interrupt: "
2885 "handle(0x%04x:0x%04x), smid(%d)!!!\n", ioc->name, handle,
2890 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
2892 "loginfo(0x%08x), completed(%d)\n", ioc->name,
2897 smid_sas_ctrl = mpt2sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
2900 ioc->name, __func__);
2904 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "sc_send:handle(0x%04x), "
2905 "(open), smid(%d), cb(%d)\n", ioc->name, handle, smid_sas_ctrl,
2906 ioc->tm_sas_control_cb_idx));
2907 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid_sas_ctrl);
2912 mpt2sas_base_put_smid_default(ioc, smid_sas_ctrl);
2914 return _scsih_check_for_pending_tm(ioc, smid);
2919 * @ioc: per adapter object
2929 _scsih_check_for_pending_tm(struct MPT2SAS_ADAPTER *ioc, u16 smid)
2933 if (!list_empty(&ioc->delayed_tr_volume_list)) {
2934 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
2936 mpt2sas_base_free_smid(ioc, smid);
2937 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
2943 if (!list_empty(&ioc->delayed_tr_list)) {
2944 delayed_tr = list_entry(ioc->delayed_tr_list.next,
2946 mpt2sas_base_free_smid(ioc, smid);
2947 _scsih_tm_tr_send(ioc, delayed_tr->handle);
2958 * @ioc: per adapter object
2970 _scsih_check_topo_delete_events(struct MPT2SAS_ADAPTER *ioc,
2988 _scsih_tm_tr_send(ioc, handle);
2992 if (expander_handle < ioc->sas_hba.num_phys) {
2993 _scsih_block_io_to_children_attached_directly(ioc, event_data);
2999 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3000 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
3002 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3003 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
3005 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3011 spin_lock_irqsave(&ioc->fw_event_lock, flags);
3012 list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
3023 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3024 "setting ignoring flag\n", ioc->name));
3029 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3034 * @ioc: per adapter object
3041 _scsih_set_volume_delete_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3047 spin_lock_irqsave(&ioc->raid_device_lock, flags);
3048 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
3054 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3056 "wwid(0x%016llx)\n", ioc->name, handle,
3059 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
3085 * @ioc: per adapter object
3098 _scsih_check_ir_config_unhide_events(struct MPT2SAS_ADAPTER *ioc,
3117 _scsih_set_volume_delete_flag(ioc, volume_handle);
3135 _scsih_tm_tr_volume_send(ioc, a);
3137 _scsih_tm_tr_volume_send(ioc, b);
3146 clear_bit(handle, ioc->pd_handles);
3148 _scsih_tm_tr_send(ioc, handle);
3154 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3155 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3156 "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
3159 _scsih_tm_tr_send(ioc, handle);
3166 * @ioc: per adapter object
3177 _scsih_check_volume_delete_events(struct MPT2SAS_ADAPTER *ioc,
3187 _scsih_set_volume_delete_flag(ioc,
3193 * @ioc: per adapter object
3201 _scsih_flush_running_cmds(struct MPT2SAS_ADAPTER *ioc)
3207 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3208 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3212 mpt2sas_base_free_smid(ioc, smid);
3214 if (ioc->pci_error_recovery)
3220 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "completing %d cmds\n",
3221 ioc->name, count));
3286 * @ioc_status: ioc status
3330 * The callback index is set inside `ioc->scsi_io_cb_idx`.
3339 struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3354 if (ioc->pci_error_recovery) {
3369 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
3408 smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
3411 ioc->name, __func__);
3414 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3433 mpt2sas_base_get_sense_buffer_dma(ioc, smid);
3444 mpt2sas_base_build_zero_len_sge(ioc, &mpi_request->SGL);
3446 if (_scsih_build_scatter_gather(ioc, scmd, smid)) {
3447 mpt2sas_base_free_smid(ioc, smid);
3453 mpt2sas_base_put_smid_scsi_io(ioc, smid,
3456 mpt2sas_base_put_smid_default(ioc, smid);
3489 * @ioc: per adapter object
3494 * scsi_state - state info associated with SCSI_IO determined by ioc
3495 * ioc_status - ioc supplied status info
3500 _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3511 char *desc_scsi_state = ioc->tmp_string;
3562 desc_ioc_state = "scsi ioc terminated";
3637 printk(MPT2SAS_WARN_FMT "\tvolume wwid(0x%016llx)\n", ioc->name,
3640 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3641 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
3645 "phy(%d)\n", ioc->name, sas_device->sas_address,
3649 ioc->name, sas_device->enclosure_logical_id,
3652 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3656 "smid(%d)\n", ioc->name, le16_to_cpu(mpi_reply->DevHandle),
3659 "resid(%d)\n", ioc->name, scsi_bufflen(scmd), scmd->underflow,
3662 "sc->result(0x%08x)\n", ioc->name, le16_to_cpu(mpi_reply->TaskTag),
3665 "scsi_state(%s)(0x%02x)\n", ioc->name, desc_scsi_status,
3672 "[0x%02x,0x%02x,0x%02x], count(%d)\n", ioc->name, data.skey,
3679 _scsih_response_code(ioc, response_bytes[0]);
3686 * @ioc: per adapter object
3692 _scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3705 spin_lock_irqsave(&ioc->sas_device_lock, flags);
3706 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3708 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3716 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3720 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3722 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) {
3730 if ((mpt2sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
3733 ioc->name, __FILE__, __LINE__, __func__);
3738 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
3740 "loginfo(0x%08x)\n", ioc->name,
3753 ioc->name, __FILE__, __LINE__, __func__);
3769 mpt2sas_ctl_add_to_event_log(ioc, event_reply);
3775 * @ioc: per adapter object
3786 _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
3799 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
3800 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3804 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
3852 const void *sense_data = mpt2sas_base_get_sense_buffer(ioc,
3860 _scsih_smart_predicted_fault(ioc,
3953 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
3954 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
3965 * @ioc: per adapter object
3975 _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
3984 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
3986 ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
3988 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
3993 ioc->name, __FILE__, __LINE__, __func__);
3997 if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4003 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4005 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4007 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4010 mpt2sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4020 * @ioc: per adapter object
4022 * Creating host side data object, stored in ioc->sas_hba
4027 _scsih_sas_host_add(struct MPT2SAS_ADAPTER *ioc)
4040 mpt2sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
4041 if (!ioc->sas_hba.num_phys) {
4043 ioc->name, __FILE__, __LINE__, __func__);
4048 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4053 ioc->name, __FILE__, __LINE__, __func__);
4056 if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4059 ioc->name, __FILE__, __LINE__, __func__);
4066 ioc->name, __FILE__, __LINE__, __func__);
4071 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4076 ioc->name, __FILE__, __LINE__, __func__);
4079 if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4082 ioc->name, __FILE__, __LINE__, __func__);
4089 ioc->name, __FILE__, __LINE__, __func__);
4093 ioc->io_missing_delay =
4098 ioc->device_missing_delay = (device_missing_delay &
4101 ioc->device_missing_delay = device_missing_delay &
4104 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
4105 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
4107 if (!ioc->sas_hba.phy) {
4109 ioc->name, __FILE__, __LINE__, __func__);
4112 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4113 if ((mpt2sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
4116 ioc->name, __FILE__, __LINE__, __func__);
4123 ioc->name, __FILE__, __LINE__, __func__);
4128 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4130 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4131 ioc->sas_hba.phy[i].phy_id = i;
4132 mpt2sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
4133 phy_pg0, ioc->sas_hba.parent_dev);
4135 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4136 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
4138 ioc->name, __FILE__, __LINE__, __func__);
4141 ioc->sas_hba.enclosure_handle =
4143 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4145 "sas_addr(0x%016llx), phys(%d)\n", ioc->name, ioc->sas_hba.handle,
4146 (unsigned long long) ioc->sas_hba.sas_address,
4147 ioc->sas_hba.num_phys) ;
4149 if (ioc->sas_hba.enclosure_handle) {
4150 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4153 ioc->sas_hba.enclosure_handle))) {
4154 ioc->sas_hba.enclosure_logical_id =
4166 * @ioc: per adapter object
4169 * Creating expander object, stored in ioc->sas_expander_list.
4174 _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4192 if (ioc->shost_recovery || ioc->pci_error_recovery)
4195 if ((mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
4198 ioc->name, __FILE__, __LINE__, __func__);
4206 ioc->name, __FILE__, __LINE__, __func__);
4212 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
4215 ioc->name, __FILE__, __LINE__, __func__);
4218 if (sas_address_parent != ioc->sas_hba.sas_address) {
4219 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4220 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4222 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4224 rc = _scsih_expander_add(ioc, parent_handle);
4230 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4232 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4234 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4243 ioc->name, __FILE__, __LINE__, __func__);
4253 " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
4263 ioc->name, __FILE__, __LINE__, __func__);
4269 mpt2sas_port = mpt2sas_transport_port_add(ioc, handle,
4273 ioc->name, __FILE__, __LINE__, __func__);
4280 if ((mpt2sas_config_get_expander_pg1(ioc, &mpi_reply,
4283 ioc->name, __FILE__, __LINE__, __func__);
4290 if ((mpt2sas_transport_add_expander_phy(ioc,
4294 ioc->name, __FILE__, __LINE__, __func__);
4301 if (!(mpt2sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4309 _scsih_expander_node_add(ioc, sas_expander);
4315 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
4323 * @ioc: per adapter object
4329 * The callback index passed is `ioc->scsih_cb_idx`
4335 _scsih_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4339 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
4340 if (ioc->scsih_cmds.status == MPT2_CMD_NOT_USED)
4342 if (ioc->scsih_cmds.smid != smid)
4344 ioc->scsih_cmds.status |= MPT2_CMD_COMPLETE;
4346 memcpy(ioc->scsih_cmds.reply, mpi_reply,
4348 ioc->scsih_cmds.status |= MPT2_CMD_REPLY_VALID;
4350 ioc->scsih_cmds.status &= ~MPT2_CMD_PENDING;
4351 complete(&ioc->scsih_cmds.done);
4357 * @ioc: per adapter object
4363 _scsih_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
4368 if (ioc->shost_recovery)
4371 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4372 sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
4374 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4375 _scsih_expander_node_remove(ioc, sas_expander);
4380 * @ioc: per adapter object
4388 _scsih_check_access_status(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
4437 "handle(0x%04x)\n", ioc->name, desc,
4443 _scsih_check_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
4455 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4468 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4470 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4475 "handle(0x%04x), no sas_device!!!\n", ioc->name, handle);
4476 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4488 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4494 "handle(0x%04x), flags!!!\n", ioc->name, handle);
4499 if (_scsih_check_access_status(ioc, sas_address, handle,
4502 _scsih_ublock_io_device(ioc, handle);
4508 * @ioc: per adapter object
4513 * Creating end device object, stored in ioc->sas_device_list.
4518 _scsih_add_device(struct MPT2SAS_ADAPTER *ioc, u16 handle, u8 phy_num, u8 is_pd)
4529 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4532 ioc->name, __FILE__, __LINE__, __func__);
4540 ioc->name, __FILE__, __LINE__, __func__);
4550 ioc->name, __FILE__, __LINE__, __func__);
4552 ioc->name, le16_to_cpu(sas_device_pg0.Flags));
4557 if (_scsih_check_access_status(ioc, sas_address, handle,
4565 ioc->name, __FILE__, __LINE__, __func__);
4570 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4571 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4573 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4582 ioc->name, __FILE__, __LINE__, __func__);
4587 if (_scsih_get_sas_address(ioc, le16_to_cpu
4591 ioc->name, __FILE__, __LINE__, __func__);
4602 ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4610 if (ioc->wait_for_port_enable_to_complete)
4611 _scsih_sas_device_init_add(ioc, sas_device);
4613 _scsih_sas_device_add(ioc, sas_device);
4620 * @ioc: per adapter object
4626 _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
4636 _scsih_sas_device_remove(ioc, sas_device);
4638 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: "
4639 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
4648 _scsih_ublock_io_device(ioc, sas_device_backup.handle);
4650 mpt2sas_transport_port_remove(ioc, sas_device_backup.sas_address,
4654 "(0x%016llx)\n", ioc->name, sas_device_backup.handle,
4657 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: exit: "
4658 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
4666 * @ioc: per adapter object
4671 _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
4700 ioc->name, status_str);
4745 * @ioc: per adapter object
4751 _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
4766 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4767 _scsih_sas_topology_change_event_debug(ioc, event_data);
4770 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
4773 if (!ioc->sas_hba.num_phys)
4774 _scsih_sas_host_add(ioc);
4776 _scsih_sas_host_refresh(ioc);
4779 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring expander "
4780 "event\n", ioc->name));
4788 if (_scsih_expander_add(ioc, parent_handle) != 0)
4791 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4792 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
4794 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4797 else if (parent_handle < ioc->sas_hba.num_phys)
4798 sas_address = ioc->sas_hba.sas_address;
4805 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "ignoring "
4806 "expander event\n", ioc->name));
4809 if (ioc->shost_recovery || ioc->remove_host ||
4810 ioc->pci_error_recovery)
4830 mpt2sas_transport_update_links(ioc, sas_address,
4836 _scsih_check_device(ioc, handle);
4840 mpt2sas_transport_update_links(ioc, sas_address,
4843 _scsih_add_device(ioc, handle, phy_number, 0);
4847 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4848 sas_device = _scsih_sas_device_find_by_handle(ioc,
4851 spin_unlock_irqrestore(&ioc->sas_device_lock,
4855 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4856 _scsih_remove_device(ioc, sas_device);
4864 _scsih_expander_remove(ioc, sas_address);
4877 _scsih_sas_device_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
4927 "\thandle(0x%04x), sas address(0x%016llx)", ioc->name,
4931 printk(MPT2SAS_INFO_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
4939 * @ioc: per adapter object
4946 _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc,
4957 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4958 _scsih_sas_device_status_change_event_debug(ioc,
4965 if ((ioc->facts.HeaderVersion >> 8) < 0xC)
4974 spin_lock_irqsave(&ioc->sas_device_lock, flags);
4976 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4978 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4997 * @ioc: per adapter object
5004 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5023 " number slots(%d)\n", ioc->name, reason_str,
5032 * @ioc: per adapter object
5039 _scsih_sas_enclosure_dev_status_change_event(struct MPT2SAS_ADAPTER *ioc,
5043 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5044 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
5051 * @ioc: per adapter object
5058 _scsih_sas_broadcast_primative_event(struct MPT2SAS_ADAPTER *ioc,
5076 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "broadcast primative: "
5077 "phy number(%d), width(%d)\n", ioc->name, event_data->PhyNum,
5079 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
5082 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5083 ioc->broadcast_aen_busy = 0;
5086 mpi_reply = ioc->tm_cmds.reply;
5087 for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5088 scmd = _scsih_scsi_lookup_get(ioc, smid);
5108 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5109 mpt2sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
5111 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
5119 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5122 r = mpt2sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
5129 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5131 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5133 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
5135 ioc->name, __func__, query_count, termination_count));
5140 * @ioc: per adapter object
5147 _scsih_sas_discovery_event(struct MPT2SAS_ADAPTER *ioc,
5153 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
5154 printk(MPT2SAS_INFO_FMT "discovery event: (%s)", ioc->name,
5165 !ioc->sas_hba.num_phys)
5166 _scsih_sas_host_add(ioc);
5209 * @ioc: per adapter object
5216 _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
5225 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
5228 "failure at %s:%d/%s()!\n", ioc->name,
5233 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5234 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
5235 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5243 "failure at %s:%d/%s()!\n", ioc->name,
5248 raid_device->id = ioc->sas_id++;
5252 _scsih_raid_device_add(ioc, raid_device);
5253 if (!ioc->wait_for_port_enable_to_complete) {
5254 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
5257 _scsih_raid_device_remove(ioc, raid_device);
5259 _scsih_determine_boot_device(ioc, raid_device, 1);
5264 * @ioc: per adapter object
5271 _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc, u16 handle)
5277 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5278 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
5279 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5288 "(0x%016llx)\n", ioc->name, raid_device->handle,
5290 _scsih_raid_device_remove(ioc, raid_device);
5295 * @ioc: per adapter object
5302 _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
5309 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5310 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5311 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5318 clear_bit(handle, ioc->pd_handles);
5324 * @ioc: per adapter object
5331 _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
5338 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5339 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5340 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5345 mpt2sas_config_get_volume_handle(ioc, handle,
5347 mpt2sas_config_get_volume_wwid(ioc, sas_device->volume_handle,
5349 set_bit(handle, ioc->pd_handles);
5355 * @ioc: per adapter object
5362 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
5369 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5370 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5371 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5374 _scsih_remove_device(ioc, sas_device);
5379 * @ioc: per adapter object
5386 _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
5398 set_bit(handle, ioc->pd_handles);
5400 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5401 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5402 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5406 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5409 ioc->name, __FILE__, __LINE__, __func__);
5417 ioc->name, __FILE__, __LINE__, __func__);
5422 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
5423 mpt2sas_transport_update_links(ioc, sas_address, handle,
5426 _scsih_add_device(ioc, handle, 0, 1);
5432 * @ioc: per adapter object
5439 _scsih_sas_ir_config_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
5450 ioc->name, (le32_to_cpu(event_data->Flags) &
5513 * @ioc: per adapter object
5520 _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
5529 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5530 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
5543 _scsih_sas_volume_add(ioc, element);
5548 _scsih_sas_volume_delete(ioc,
5552 _scsih_sas_pd_hide(ioc, element);
5555 _scsih_sas_pd_expose(ioc, element);
5558 _scsih_sas_pd_add(ioc, element);
5561 _scsih_sas_pd_delete(ioc, element);
5569 * @ioc: per adapter object
5576 _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
5592 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
5593 "old(0x%08x), new(0x%08x)\n", ioc->name, __func__, handle,
5599 _scsih_sas_volume_delete(ioc, handle);
5606 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5607 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
5608 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5613 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
5616 "failure at %s:%d/%s()!\n", ioc->name,
5624 "failure at %s:%d/%s()!\n", ioc->name,
5629 raid_device->id = ioc->sas_id++;
5633 _scsih_raid_device_add(ioc, raid_device);
5634 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
5637 _scsih_raid_device_remove(ioc, raid_device);
5648 * @ioc: per adapter object
5655 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
5674 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
5675 "old(0x%08x), new(0x%08x)\n", ioc->name, __func__, handle,
5685 set_bit(handle, ioc->pd_handles);
5687 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5688 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5689 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5694 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
5698 ioc->name, __FILE__, __LINE__, __func__);
5706 ioc->name, __FILE__, __LINE__, __func__);
5711 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
5712 mpt2sas_transport_update_links(ioc, sas_address, handle,
5715 _scsih_add_device(ioc, handle, 0, 1);
5730 * @ioc: per adapter object
5737 _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
5765 ioc->name, reason_str,
5773 * @ioc: per adapter object
5780 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
5789 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5790 _scsih_sas_ir_operation_status_event_debug(ioc,
5799 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5800 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
5801 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5814 * @ioc: per adapter object
5821 _scsih_task_set_full(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
5837 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5838 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5840 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5843 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5849 if (test_bit(handle, ioc->pd_handles) && sas_device->volume_handle) {
5850 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5852 ioc, sas_device->volume_handle);
5853 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5862 if (ioc->logging_level & MPT_DEBUG_TASK_SET_FULL)
5867 shost_for_each_device(sdev, ioc->shost) {
5870 if (ioc->logging_level &
5888 if (ioc->logging_level &
5898 * @ioc: per adapter object
5904 _scsih_prep_device_scan(struct MPT2SAS_ADAPTER *ioc)
5909 shost_for_each_device(sdev, ioc->shost) {
5918 * @ioc: per adapter object
5929 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5937 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5938 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
5967 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5972 * @ioc: per adapter object
5980 _scsih_search_responding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
5990 printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
5992 if (list_empty(&ioc->sas_device_list))
5996 while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6009 _scsih_mark_responding_sas_device(ioc, sas_address, slot,
6016 * @ioc: per adapter object
6026 _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
6034 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6035 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
6058 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6063 * @ioc: per adapter object
6071 _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
6081 printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
6083 if (list_empty(&ioc->raid_device_list))
6087 while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
6095 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
6103 _scsih_mark_responding_raid_device(ioc,
6109 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
6110 while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
6119 set_bit(handle, ioc->pd_handles);
6125 * @ioc: per adapter object
6135 _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
6142 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6143 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6159 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6164 * @ioc: per adapter object
6172 _scsih_search_responding_expanders(struct MPT2SAS_ADAPTER *ioc)
6180 printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
6182 if (list_empty(&ioc->sas_expander_list))
6186 while (!(mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
6199 _scsih_mark_responding_expander(ioc, sas_address, handle);
6206 * @ioc: per adapter object
6211 _scsih_remove_unresponding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
6219 &ioc->sas_device_list, list) {
6233 _scsih_remove_device(ioc, sas_device);
6237 &ioc->raid_device_list, list) {
6249 _scsih_raid_device_remove(ioc, raid_device);
6254 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
6259 _scsih_expander_remove(ioc, sas_expander->sas_address);
6266 * @ioc: per adapter object
6277 mpt2sas_scsih_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
6281 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
6282 "MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
6285 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
6286 "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
6287 if (ioc->scsih_cmds.status & MPT2_CMD_PENDING) {
6288 ioc->scsih_cmds.status |= MPT2_CMD_RESET;
6289 mpt2sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
6290 complete(&ioc->scsih_cmds.done);
6292 if (ioc->tm_cmds.status & MPT2_CMD_PENDING) {
6293 ioc->tm_cmds.status |= MPT2_CMD_RESET;
6294 mpt2sas_base_free_smid(ioc, ioc->tm_cmds.smid);
6295 complete(&ioc->tm_cmds.done);
6297 _scsih_fw_event_cleanup_queue(ioc);
6298 _scsih_flush_running_cmds(ioc);
6299 _scsih_queue_rescan(ioc);
6302 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
6303 "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
6304 _scsih_sas_host_refresh(ioc);
6305 _scsih_prep_device_scan(ioc);
6306 _scsih_search_responding_sas_devices(ioc);
6307 _scsih_search_responding_raid_devices(ioc);
6308 _scsih_search_responding_expanders(ioc);
6315 * @ioc: per adapter object
6327 struct MPT2SAS_ADAPTER *ioc = fw_event->ioc;
6330 if (ioc->remove_host || fw_event->cancel_pending_work ||
6331 ioc->pci_error_recovery) {
6332 _scsih_fw_event_free(ioc, fw_event);
6337 _scsih_fw_event_free(ioc, fw_event);
6338 spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
6339 if (ioc->shost_recovery) {
6340 init_completion(&ioc->shost_recovery_done);
6341 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock,
6343 wait_for_completion(&ioc->shost_recovery_done);
6345 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock,
6347 _scsih_remove_unresponding_sas_devices(ioc);
6353 _scsih_sas_topology_change_event(ioc, fw_event);
6356 _scsih_sas_device_status_change_event(ioc,
6360 _scsih_sas_discovery_event(ioc,
6364 _scsih_sas_broadcast_primative_event(ioc,
6368 _scsih_sas_enclosure_dev_status_change_event(ioc,
6372 _scsih_sas_ir_config_change_event(ioc, fw_event);
6375 _scsih_sas_ir_volume_event(ioc, fw_event);
6378 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
6381 _scsih_sas_ir_operation_status_event(ioc, fw_event);
6384 _scsih_task_set_full(ioc, fw_event);
6387 _scsih_fw_event_free(ioc, fw_event);
6392 * @ioc: per adapter object
6397 * This function merely adds a new work task into ioc->firmware_event_thread.
6404 mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
6413 if (ioc->remove_host || ioc->pci_error_recovery)
6416 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
6429 ioc->broadcast_aen_busy)
6431 ioc->broadcast_aen_busy = 1;
6436 _scsih_check_topo_delete_events(ioc,
6441 _scsih_check_ir_config_unhide_events(ioc,
6446 _scsih_check_volume_delete_events(ioc,
6465 ioc->name, __FILE__, __LINE__, __func__);
6472 ioc->name, __FILE__, __LINE__, __func__);
6479 fw_event->ioc = ioc;
6483 _scsih_fw_event_add(ioc, fw_event);
6517 * @ioc: per adapter object
6519 * Context: Calling function should acquire ioc->sas_node_lock.
6522 * ioc->sas_expander_list.
6527 _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
6544 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6546 mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
6548 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6551 _scsih_remove_device(ioc, sas_device);
6552 if (ioc->shost_recovery)
6567 spin_lock_irqsave(&ioc->sas_node_lock, flags);
6570 ioc, mpt2sas_port->remote_identify.sas_address);
6571 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6574 _scsih_expander_remove(ioc,
6576 if (ioc->shost_recovery)
6582 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
6586 "(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
6597 * @ioc: per adapter object
6605 _scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
6612 if (!ioc->ir_firmware)
6616 if (list_empty(&ioc->raid_device_list))
6619 mutex_lock(&ioc->scsih_cmds.mutex);
6621 if (ioc->scsih_cmds.status != MPT2_CMD_NOT_USED) {
6623 ioc->name, __func__);
6626 ioc->scsih_cmds.status = MPT2_CMD_PENDING;
6628 smid = mpt2sas_base_get_smid(ioc, ioc->scsih_cb_idx);
6631 ioc->name, __func__);
6632 ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
6636 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
6637 ioc->scsih_cmds.smid = smid;
6643 printk(MPT2SAS_INFO_FMT "IR shutdown (sending)\n", ioc->name);
6644 init_completion(&ioc->scsih_cmds.done);
6645 mpt2sas_base_put_smid_default(ioc, smid);
6646 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
6648 if (!(ioc->scsih_cmds.status & MPT2_CMD_COMPLETE)) {
6650 ioc->name, __func__);
6654 if (ioc->scsih_cmds.status & MPT2_CMD_REPLY_VALID) {
6655 mpi_reply = ioc->scsih_cmds.reply;
6659 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
6664 ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
6665 mutex_unlock(&ioc->scsih_cmds.mutex);
6678 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
6682 ioc->remove_host = 1;
6683 _scsih_fw_event_cleanup_queue(ioc);
6685 spin_lock_irqsave(&ioc->fw_event_lock, flags);
6686 wq = ioc->firmware_event_thread;
6687 ioc->firmware_event_thread = NULL;
6688 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
6692 _scsih_ir_shutdown(ioc);
6693 mpt2sas_base_detach(ioc);
6707 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
6716 ioc->remove_host = 1;
6717 _scsih_fw_event_cleanup_queue(ioc);
6719 spin_lock_irqsave(&ioc->fw_event_lock, flags);
6720 wq = ioc->firmware_event_thread;
6721 ioc->firmware_event_thread = NULL;
6722 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
6727 _scsih_ir_shutdown(ioc);
6728 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
6737 "(0x%016llx)\n", ioc->name, raid_device->handle,
6739 _scsih_raid_device_remove(ioc, raid_device);
6745 &ioc->sas_hba.sas_port_list, port_list) {
6749 mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
6752 _scsih_remove_device(ioc, sas_device);
6757 mpt2sas_scsih_expander_find_by_sas_address(ioc,
6760 _scsih_expander_remove(ioc,
6768 if (ioc->sas_hba.num_phys) {
6769 kfree(ioc->sas_hba.phy);
6770 ioc->sas_hba.phy = NULL;
6771 ioc->sas_hba.num_phys = 0;
6776 list_del(&ioc->list);
6783 * @ioc: per adapter object
6790 _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
6803 if (ioc->req_boot_device.device) {
6804 device = ioc->req_boot_device.device;
6805 is_raid = ioc->req_boot_device.is_raid;
6806 } else if (ioc->req_alt_boot_device.device) {
6807 device = ioc->req_alt_boot_device.device;
6808 is_raid = ioc->req_alt_boot_device.is_raid;
6809 } else if (ioc->current_boot_device.device) {
6810 device = ioc->current_boot_device.device;
6811 is_raid = ioc->current_boot_device.is_raid;
6819 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6822 _scsih_raid_device_remove(ioc, raid_device);
6828 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6829 list_move_tail(&sas_device->list, &ioc->sas_device_list);
6830 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6831 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
6833 _scsih_sas_device_remove(ioc, sas_device);
6835 mpt2sas_transport_port_remove(ioc, sas_address,
6837 _scsih_sas_device_remove(ioc, sas_device);
6844 * @ioc: per adapter object
6849 _scsih_probe_raid(struct MPT2SAS_ADAPTER *ioc)
6855 &ioc->raid_device_list, list) {
6858 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6861 _scsih_raid_device_remove(ioc, raid_device);
6867 * @ioc: per adapter object
6872 _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
6878 list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
6880 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6881 list_move_tail(&sas_device->list, &ioc->sas_device_list);
6882 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6884 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
6886 _scsih_sas_device_remove(ioc, sas_device);
6888 mpt2sas_transport_port_remove(ioc,
6891 _scsih_sas_device_remove(ioc, sas_device);
6898 * @ioc: per adapter object
6903 _scsih_probe_devices(struct MPT2SAS_ADAPTER *ioc)
6906 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
6909 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
6912 _scsih_probe_boot_devices(ioc);
6914 if (ioc->ir_firmware) {
6917 _scsih_probe_sas(ioc);
6918 _scsih_probe_raid(ioc);
6920 _scsih_probe_raid(ioc);
6921 _scsih_probe_sas(ioc);
6924 _scsih_probe_sas(ioc);
6937 struct MPT2SAS_ADAPTER *ioc;
6946 ioc = shost_priv(shost);
6947 memset(ioc, 0, sizeof(struct MPT2SAS_ADAPTER));
6948 INIT_LIST_HEAD(&ioc->list);
6949 list_add_tail(&ioc->list, &mpt2sas_ioc_list);
6950 ioc->shost = shost;
6951 ioc->id = mpt_ids++;
6952 sprintf(ioc->name, "%s%d", MPT2SAS_DRIVER_NAME, ioc->id);
6953 ioc->pdev = pdev;
6954 ioc->scsi_io_cb_idx = scsi_io_cb_idx;
6955 ioc->tm_cb_idx = tm_cb_idx;
6956 ioc->ctl_cb_idx = ctl_cb_idx;
6957 ioc->base_cb_idx = base_cb_idx;
6958 ioc->transport_cb_idx = transport_cb_idx;
6959 ioc->scsih_cb_idx = scsih_cb_idx;
6960 ioc->config_cb_idx = config_cb_idx;
6961 ioc->tm_tr_cb_idx = tm_tr_cb_idx;
6962 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
6963 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
6964 ioc->logging_level = logging_level;
6966 mutex_init(&ioc->reset_in_progress_mutex);
6967 spin_lock_init(&ioc->ioc_reset_in_progress_lock);
6968 spin_lock_init(&ioc->scsi_lookup_lock);
6969 spin_lock_init(&ioc->sas_device_lock);
6970 spin_lock_init(&ioc->sas_node_lock);
6971 spin_lock_init(&ioc->fw_event_lock);
6972 spin_lock_init(&ioc->raid_device_lock);
6974 INIT_LIST_HEAD(&ioc->sas_device_list);
6975 INIT_LIST_HEAD(&ioc->sas_device_init_list);
6976 INIT_LIST_HEAD(&ioc->sas_expander_list);
6977 INIT_LIST_HEAD(&ioc->fw_event_list);
6978 INIT_LIST_HEAD(&ioc->raid_device_list);
6979 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
6980 INIT_LIST_HEAD(&ioc->delayed_tr_list);
6981 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
6987 shost->unique_id = ioc->id;
6991 ioc->name, __FILE__, __LINE__, __func__);
6992 list_del(&ioc->list);
7001 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
7002 "fw_event%d", ioc->id);
7003 ioc->firmware_event_thread = create_singlethread_workqueue(
7004 ioc->firmware_event_name);
7005 if (!ioc->firmware_event_thread) {
7007 ioc->name, __FILE__, __LINE__, __func__);
7011 ioc->wait_for_port_enable_to_complete = 1;
7012 if ((mpt2sas_base_attach(ioc))) {
7014 ioc->name, __FILE__, __LINE__, __func__);
7018 ioc->wait_for_port_enable_to_complete = 0;
7019 _scsih_probe_devices(ioc);
7023 destroy_workqueue(ioc->firmware_event_thread);
7025 list_del(&ioc->list);
7043 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7046 mpt2sas_base_stop_watchdog(ioc);
7051 "operating state [D%d]\n", ioc->name, pdev,
7054 mpt2sas_base_free_resources(ioc);
7071 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7076 "operating state [D%d]\n", ioc->name, pdev,
7082 ioc->pdev = pdev;
7083 r = mpt2sas_base_map_resources(ioc);
7087 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
7089 mpt2sas_base_start_watchdog(ioc);
7108 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7111 ioc->name, state);
7118 ioc->pci_error_recovery = 1;
7119 scsi_block_requests(ioc->shost);
7120 mpt2sas_base_stop_watchdog(ioc);
7121 mpt2sas_base_free_resources(ioc);
7125 ioc->pci_error_recovery = 1;
7126 mpt2sas_base_stop_watchdog(ioc);
7127 _scsih_flush_running_cmds(ioc);
7145 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7149 ioc->name);
7151 ioc->pci_error_recovery = 0;
7152 ioc->pdev = pdev;
7154 rc = mpt2sas_base_map_resources(ioc);
7159 rc = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
7162 printk(MPT2SAS_WARN_FMT "hard reset: %s\n", ioc->name,
7183 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7185 printk(MPT2SAS_INFO_FMT "PCI error: resume callback!!\n", ioc->name);
7188 mpt2sas_base_start_watchdog(ioc);
7189 scsi_unblock_requests(ioc->shost);
7200 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
7203 ioc->name);