root/drivers/scsi/mpt3sas/mpt3sas_scsih.c

DEFINITIONS

1. fw_event_work_free
2. fw_event_work_get
3. fw_event_work_put
4. alloc_fw_event_work
5. _scsih_set_debug_level
6. _scsih_srch_boot_sas_address
7. _scsih_srch_boot_device_name
8. _scsih_srch_boot_encl_slot
9. _scsih_is_boot_device
10. _scsih_get_sas_address
11. _scsih_determine_boot_device
12. __mpt3sas_get_sdev_from_target
13. mpt3sas_get_sdev_from_target
14. __mpt3sas_get_pdev_from_target
15. mpt3sas_get_pdev_from_target
16. __mpt3sas_get_sdev_by_addr
17. mpt3sas_get_sdev_by_addr
18. __mpt3sas_get_sdev_by_handle
19. mpt3sas_get_sdev_by_handle
20. _scsih_display_enclosure_chassis_info
21. _scsih_sas_device_remove
22. _scsih_device_remove_by_handle
23. mpt3sas_device_remove_by_sas_address
24. _scsih_sas_device_add
25. _scsih_sas_device_init_add
26. __mpt3sas_get_pdev_by_wwid
27. mpt3sas_get_pdev_by_wwid
28. __mpt3sas_get_pdev_by_idchannel
29. __mpt3sas_get_pdev_by_handle
30. mpt3sas_get_pdev_by_handle
31. _scsih_pcie_device_remove
32. _scsih_pcie_device_remove_by_handle
33. _scsih_pcie_device_add
34. _scsih_pcie_device_init_add
35. _scsih_raid_device_find_by_id
36. mpt3sas_raid_device_find_by_handle
37. _scsih_raid_device_find_by_wwid
38. _scsih_raid_device_add
39. _scsih_raid_device_remove
40. mpt3sas_scsih_expander_find_by_handle
41. mpt3sas_scsih_enclosure_find_by_handle
42. mpt3sas_scsih_expander_find_by_sas_address
43. _scsih_expander_node_add
44. _scsih_is_end_device
45. _scsih_is_nvme_pciescsi_device
46. mpt3sas_scsih_scsi_lookup_get
47. scsih_change_queue_depth
48. mpt3sas_scsih_change_queue_depth
49. scsih_target_alloc
50. scsih_target_destroy
51. scsih_slave_alloc
52. scsih_slave_destroy
53. _scsih_display_sata_capabilities
54. scsih_is_raid
55. scsih_is_nvme
56. scsih_get_resync
57. scsih_get_state
58. _scsih_set_level
59. _scsih_get_volume_capabilities
60. _scsih_enable_tlr
61. scsih_slave_configure
62. scsih_bios_param
63. _scsih_response_code
64. _scsih_tm_done
65. mpt3sas_scsih_set_tm_flag
66. mpt3sas_scsih_clear_tm_flag
67. mpt3sas_scsih_issue_tm
68. mpt3sas_scsih_issue_locked_tm
69. _scsih_tm_display_info
70. scsih_abort
71. scsih_dev_reset
72. scsih_target_reset
73. scsih_host_reset
74. _scsih_fw_event_add
75. _scsih_fw_event_del_from_list
76. mpt3sas_send_trigger_data_event
77. _scsih_error_recovery_delete_devices
78. mpt3sas_port_enable_complete
79. dequeue_next_fw_event
80. _scsih_fw_event_cleanup_queue
81. _scsih_internal_device_block
82. _scsih_internal_device_unblock
83. _scsih_ublock_io_all_device
84. _scsih_ublock_io_device
85. _scsih_block_io_all_device
86. _scsih_block_io_device
87. _scsih_block_io_to_children_attached_to_ex
88. _scsih_block_io_to_children_attached_directly
89. _scsih_block_io_to_pcie_children_attached_directly
90. _scsih_tm_tr_send
91. _scsih_tm_tr_complete
92. _scsih_allow_scmd_to_device
93. _scsih_sas_control_complete
94. _scsih_tm_tr_volume_send
95. _scsih_tm_volume_tr_complete
96. _scsih_issue_delayed_event_ack
97. _scsih_issue_delayed_sas_io_unit_ctrl
98. mpt3sas_check_for_pending_internal_cmds
99. _scsih_check_for_pending_tm
100. _scsih_check_topo_delete_events
101. _scsih_check_pcie_topo_remove_events
102. _scsih_set_volume_delete_flag
103. _scsih_set_volume_handle_for_tr
104. _scsih_check_ir_config_unhide_events
105. _scsih_check_volume_delete_events
106. _scsih_temp_threshold_events
107. _scsih_set_satl_pending
108. _scsih_flush_running_cmds
109. _scsih_setup_eedp
110. _scsih_eedp_error_handling
111. scsih_qcmd
112. _scsih_normalize_sense
113. _scsih_scsi_ioc_info
114. _scsih_turn_on_pfa_led
115. _scsih_turn_off_pfa_led
116. _scsih_send_event_to_turn_on_pfa_led
117. _scsih_smart_predicted_fault
118. _scsih_io_done
119. _scsih_sas_host_refresh
120. _scsih_sas_host_add
121. _scsih_expander_add
122. mpt3sas_expander_remove
123. _scsih_done
124. _scsih_check_access_status
125. _scsih_check_device
126. _scsih_add_device
127. _scsih_remove_device
128. _scsih_sas_topology_change_event_debug
129. _scsih_sas_topology_change_event
130. _scsih_sas_device_status_change_event_debug
131. _scsih_sas_device_status_change_event
132. _scsih_check_pcie_access_status
133. _scsih_pcie_device_remove_from_sml
134. _scsih_pcie_check_device
135. _scsih_pcie_add_device
136. _scsih_pcie_topology_change_event_debug
137. _scsih_pcie_topology_change_event
138. _scsih_pcie_device_status_change_event_debug
139. _scsih_pcie_device_status_change_event
140. _scsih_sas_enclosure_dev_status_change_event_debug
141. _scsih_sas_enclosure_dev_status_change_event
142. _scsih_sas_broadcast_primitive_event
143. _scsih_sas_discovery_event
144. _scsih_sas_device_discovery_error_event
145. _scsih_pcie_enumeration_event
146. _scsih_ir_fastpath
147. _scsih_reprobe_lun
148. _scsih_sas_volume_add
149. _scsih_sas_volume_delete
150. _scsih_sas_pd_expose
151. _scsih_sas_pd_hide
152. _scsih_sas_pd_delete
153. _scsih_sas_pd_add
154. _scsih_sas_ir_config_change_event_debug
155. _scsih_sas_ir_config_change_event
156. _scsih_sas_ir_volume_event
157. _scsih_sas_ir_physical_disk_event
158. _scsih_sas_ir_operation_status_event_debug
159. _scsih_sas_ir_operation_status_event
160. _scsih_prep_device_scan
161. _scsih_mark_responding_sas_device
162. _scsih_create_enclosure_list_after_reset
163. _scsih_search_responding_sas_devices
164. _scsih_mark_responding_pcie_device
165. _scsih_search_responding_pcie_devices
166. _scsih_mark_responding_raid_device
167. _scsih_search_responding_raid_devices
168. _scsih_mark_responding_expander
169. _scsih_search_responding_expanders
170. _scsih_remove_unresponding_devices
171. _scsih_refresh_expander_links
172. _scsih_scan_for_devices_after_reset
173. mpt3sas_scsih_pre_reset_handler
174. mpt3sas_scsih_after_reset_handler
175. mpt3sas_scsih_reset_done_handler
176. _mpt3sas_fw_work
177. _firmware_event_work
178. mpt3sas_scsih_event_callback
179. _scsih_expander_node_remove
180. _scsih_ir_shutdown
181. scsih_remove
182. scsih_shutdown
183. _scsih_probe_boot_devices
184. _scsih_probe_raid
185. get_next_sas_device
186. sas_device_make_active
187. _scsih_probe_sas
188. get_next_pcie_device
189. pcie_device_make_active
190. _scsih_probe_pcie
191. _scsih_probe_devices
192. scsih_scan_start
193. scsih_scan_finished
194. _scsih_determine_hba_mpi_version
195. _scsih_probe
196. scsih_suspend
197. scsih_resume
198. scsih_pci_error_detected
199. scsih_pci_slot_reset
200. scsih_pci_resume
201. scsih_pci_mmio_enabled
202. scsih_ncq_prio_supp
203. scsih_init
204. scsih_exit
205. _mpt3sas_init
206. _mpt3sas_exit

   1 /*
   2  * Scsi Host Layer for MPT (Message Passing Technology) based controllers
   3  *
   4  * This code is based on drivers/scsi/mpt3sas/mpt3sas_scsih.c
   5  * Copyright (C) 2012-2014  LSI Corporation
   6  * Copyright (C) 2013-2014 Avago Technologies
   7  *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * NO WARRANTY
  20  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  21  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  22  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  23  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  24  * solely responsible for determining the appropriateness of using and
  25  * distributing the Program and assumes all risks associated with its
  26  * exercise of rights under this Agreement, including but not limited to
  27  * the risks and costs of program errors, damage to or loss of data,
  28  * programs or equipment, and unavailability or interruption of operations.
  29 
  30  * DISCLAIMER OF LIABILITY
  31  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  32  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  34  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  35  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  36  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  37  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  38 
  39  * You should have received a copy of the GNU General Public License
  40  * along with this program; if not, write to the Free Software
  41  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  42  * USA.
  43  */
  44 
  45 #include <linux/module.h>
  46 #include <linux/kernel.h>
  47 #include <linux/init.h>
  48 #include <linux/errno.h>
  49 #include <linux/blkdev.h>
  50 #include <linux/sched.h>
  51 #include <linux/workqueue.h>
  52 #include <linux/delay.h>
  53 #include <linux/pci.h>
  54 #include <linux/interrupt.h>
  55 #include <linux/aer.h>
  56 #include <linux/raid_class.h>
  57 #include <asm/unaligned.h>
  58 
  59 #include "mpt3sas_base.h"
  60 
  61 #define RAID_CHANNEL 1
  62 
  63 #define PCIE_CHANNEL 2
  64 
  65 /* forward proto's */
  66 static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
  67         struct _sas_node *sas_expander);
  68 static void _firmware_event_work(struct work_struct *work);
  69 
  70 static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
  71         struct _sas_device *sas_device);
  72 static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
  73         u8 retry_count, u8 is_pd);
  74 static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
  75 static void _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
  76         struct _pcie_device *pcie_device);
  77 static void
  78 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);
  79 static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
  80 
  81 /* global parameters */
  82 LIST_HEAD(mpt3sas_ioc_list);
  83 /* global ioc lock for list operations */
  84 DEFINE_SPINLOCK(gioc_lock);
  85 
  86 MODULE_AUTHOR(MPT3SAS_AUTHOR);
  87 MODULE_DESCRIPTION(MPT3SAS_DESCRIPTION);
  88 MODULE_LICENSE("GPL");
  89 MODULE_VERSION(MPT3SAS_DRIVER_VERSION);
  90 MODULE_ALIAS("mpt2sas");
  91 
  92 /* local parameters */
  93 static u8 scsi_io_cb_idx = -1;
  94 static u8 tm_cb_idx = -1;
  95 static u8 ctl_cb_idx = -1;
  96 static u8 base_cb_idx = -1;
  97 static u8 port_enable_cb_idx = -1;
  98 static u8 transport_cb_idx = -1;
  99 static u8 scsih_cb_idx = -1;
 100 static u8 config_cb_idx = -1;
 101 static int mpt2_ids;
 102 static int mpt3_ids;
 103 
 104 static u8 tm_tr_cb_idx = -1 ;
 105 static u8 tm_tr_volume_cb_idx = -1 ;
 106 static u8 tm_sas_control_cb_idx = -1;
 107 
 108 /* command line options */
 109 static u32 logging_level;
 110 MODULE_PARM_DESC(logging_level,
 111         " bits for enabling additional logging info (default=0)");
 112 
 113 
 114 static ushort max_sectors = 0xFFFF;
 115 module_param(max_sectors, ushort, 0444);
 116 MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767  default=32767");
 117 
 118 
 119 static int missing_delay[2] = {-1, -1};
 120 module_param_array(missing_delay, int, NULL, 0444);
 121 MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
 122 
 123 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
 124 #define MPT3SAS_MAX_LUN (16895)
 125 static u64 max_lun = MPT3SAS_MAX_LUN;
 126 module_param(max_lun, ullong, 0444);
 127 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
 128 
 129 static ushort hbas_to_enumerate;
 130 module_param(hbas_to_enumerate, ushort, 0444);
 131 MODULE_PARM_DESC(hbas_to_enumerate,
 132                 " 0 - enumerates both SAS 2.0 & SAS 3.0 generation HBAs\n \
 133                   1 - enumerates only SAS 2.0 generation HBAs\n \
 134                   2 - enumerates only SAS 3.0 generation HBAs (default=0)");
 135 
 136 /* diag_buffer_enable is bitwise
 137  * bit 0 set = TRACE
 138  * bit 1 set = SNAPSHOT
 139  * bit 2 set = EXTENDED
 140  *
 141  * Either bit can be set, or both
 142  */
 143 static int diag_buffer_enable = -1;
 144 module_param(diag_buffer_enable, int, 0444);
 145 MODULE_PARM_DESC(diag_buffer_enable,
 146         " post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
 147 static int disable_discovery = -1;
 148 module_param(disable_discovery, int, 0444);
 149 MODULE_PARM_DESC(disable_discovery, " disable discovery ");
 150 
 151 
 152 /* permit overriding the host protection capabilities mask (EEDP/T10 PI) */
 153 static int prot_mask = -1;
 154 module_param(prot_mask, int, 0444);
 155 MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 ");
 156 
 157 static bool enable_sdev_max_qd;
 158 module_param(enable_sdev_max_qd, bool, 0444);
 159 MODULE_PARM_DESC(enable_sdev_max_qd,
 160         "Enable sdev max qd as can_queue, def=disabled(0)");
 161 
 162 /* raid transport support */
 163 static struct raid_template *mpt3sas_raid_template;
 164 static struct raid_template *mpt2sas_raid_template;
 165 
 166 
 167 /**
 168  * struct sense_info - common structure for obtaining sense keys
 169  * @skey: sense key
 170  * @asc: additional sense code
 171  * @ascq: additional sense code qualifier
 172  */
 173 struct sense_info {
 174         u8 skey;
 175         u8 asc;
 176         u8 ascq;
 177 };
 178 
 179 #define MPT3SAS_PROCESS_TRIGGER_DIAG (0xFFFB)
 180 #define MPT3SAS_TURN_ON_PFA_LED (0xFFFC)
 181 #define MPT3SAS_PORT_ENABLE_COMPLETE (0xFFFD)
 182 #define MPT3SAS_ABRT_TASK_SET (0xFFFE)
 183 #define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF)
 184 /**
 185  * struct fw_event_work - firmware event struct
 186  * @list: link list framework
 187  * @work: work object (ioc->fault_reset_work_q)
 188  * @ioc: per adapter object
 189  * @device_handle: device handle
 190  * @VF_ID: virtual function id
 191  * @VP_ID: virtual port id
 192  * @ignore: flag meaning this event has been marked to ignore
 193  * @event: firmware event MPI2_EVENT_XXX defined in mpi2_ioc.h
 194  * @refcount: kref for this event
 195  * @event_data: reply event data payload follows
 196  *
 197  * This object stored on ioc->fw_event_list.
 198  */
 199 struct fw_event_work {
 200         struct list_head        list;
 201         struct work_struct      work;
 202 
 203         struct MPT3SAS_ADAPTER *ioc;
 204         u16                     device_handle;
 205         u8                      VF_ID;
 206         u8                      VP_ID;
 207         u8                      ignore;
 208         u16                     event;
 209         struct kref             refcount;
 210         char                    event_data[0] __aligned(4);
 211 };
 212 
 213 static void fw_event_work_free(struct kref *r)
 214 {
 215         kfree(container_of(r, struct fw_event_work, refcount));
 216 }
 217 
 218 static void fw_event_work_get(struct fw_event_work *fw_work)
 219 {
 220         kref_get(&fw_work->refcount);
 221 }
 222 
 223 static void fw_event_work_put(struct fw_event_work *fw_work)
 224 {
 225         kref_put(&fw_work->refcount, fw_event_work_free);
 226 }
 227 
 228 static struct fw_event_work *alloc_fw_event_work(int len)
 229 {
 230         struct fw_event_work *fw_event;
 231 
 232         fw_event = kzalloc(sizeof(*fw_event) + len, GFP_ATOMIC);
 233         if (!fw_event)
 234                 return NULL;
 235 
 236         kref_init(&fw_event->refcount);
 237         return fw_event;
 238 }
 239 
 240 /**
 241  * struct _scsi_io_transfer - scsi io transfer
 242  * @handle: sas device handle (assigned by firmware)
 243  * @is_raid: flag set for hidden raid components
 244  * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE,
 245  * @data_length: data transfer length
 246  * @data_dma: dma pointer to data
 247  * @sense: sense data
 248  * @lun: lun number
 249  * @cdb_length: cdb length
 250  * @cdb: cdb contents
 251  * @timeout: timeout for this command
 252  * @VF_ID: virtual function id
 253  * @VP_ID: virtual port id
 254  * @valid_reply: flag set for reply message
 255  * @sense_length: sense length
 256  * @ioc_status: ioc status
 257  * @scsi_state: scsi state
 258  * @scsi_status: scsi staus
 259  * @log_info: log information
 260  * @transfer_length: data length transfer when there is a reply message
 261  *
 262  * Used for sending internal scsi commands to devices within this module.
 263  * Refer to _scsi_send_scsi_io().
 264  */
 265 struct _scsi_io_transfer {
 266         u16     handle;
 267         u8      is_raid;
 268         enum dma_data_direction dir;
 269         u32     data_length;
 270         dma_addr_t data_dma;
 271         u8      sense[SCSI_SENSE_BUFFERSIZE];
 272         u32     lun;
 273         u8      cdb_length;
 274         u8      cdb[32];
 275         u8      timeout;
 276         u8      VF_ID;
 277         u8      VP_ID;
 278         u8      valid_reply;
 279   /* the following bits are only valid when 'valid_reply = 1' */
 280         u32     sense_length;
 281         u16     ioc_status;
 282         u8      scsi_state;
 283         u8      scsi_status;
 284         u32     log_info;
 285         u32     transfer_length;
 286 };
 287 
 288 /**
 289  * _scsih_set_debug_level - global setting of ioc->logging_level.
 290  * @val: ?
 291  * @kp: ?
 292  *
 293  * Note: The logging levels are defined in mpt3sas_debug.h.
 294  */
 295 static int
 296 _scsih_set_debug_level(const char *val, const struct kernel_param *kp)
 297 {
 298         int ret = param_set_int(val, kp);
 299         struct MPT3SAS_ADAPTER *ioc;
 300 
 301         if (ret)
 302                 return ret;
 303 
 304         pr_info("setting logging_level(0x%08x)\n", logging_level);
 305         spin_lock(&gioc_lock);
 306         list_for_each_entry(ioc, &mpt3sas_ioc_list, list)
 307                 ioc->logging_level = logging_level;
 308         spin_unlock(&gioc_lock);
 309         return 0;
 310 }
 311 module_param_call(logging_level, _scsih_set_debug_level, param_get_int,
 312         &logging_level, 0644);
 313 
 314 /**
 315  * _scsih_srch_boot_sas_address - search based on sas_address
 316  * @sas_address: sas address
 317  * @boot_device: boot device object from bios page 2
 318  *
 319  * Return: 1 when there's a match, 0 means no match.
 320  */
 321 static inline int
 322 _scsih_srch_boot_sas_address(u64 sas_address,
 323         Mpi2BootDeviceSasWwid_t *boot_device)
 324 {
 325         return (sas_address == le64_to_cpu(boot_device->SASAddress)) ?  1 : 0;
 326 }
 327 
 328 /**
 329  * _scsih_srch_boot_device_name - search based on device name
 330  * @device_name: device name specified in INDENTIFY fram
 331  * @boot_device: boot device object from bios page 2
 332  *
 333  * Return: 1 when there's a match, 0 means no match.
 334  */
 335 static inline int
 336 _scsih_srch_boot_device_name(u64 device_name,
 337         Mpi2BootDeviceDeviceName_t *boot_device)
 338 {
 339         return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0;
 340 }
 341 
 342 /**
 343  * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot
 344  * @enclosure_logical_id: enclosure logical id
 345  * @slot_number: slot number
 346  * @boot_device: boot device object from bios page 2
 347  *
 348  * Return: 1 when there's a match, 0 means no match.
 349  */
 350 static inline int
 351 _scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number,
 352         Mpi2BootDeviceEnclosureSlot_t *boot_device)
 353 {
 354         return (enclosure_logical_id == le64_to_cpu(boot_device->
 355             EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device->
 356             SlotNumber)) ? 1 : 0;
 357 }
 358 
 359 /**
 360  * _scsih_is_boot_device - search for matching boot device.
 361  * @sas_address: sas address
 362  * @device_name: device name specified in INDENTIFY fram
 363  * @enclosure_logical_id: enclosure logical id
 364  * @slot: slot number
 365  * @form: specifies boot device form
 366  * @boot_device: boot device object from bios page 2
 367  *
 368  * Return: 1 when there's a match, 0 means no match.
 369  */
 370 static int
 371 _scsih_is_boot_device(u64 sas_address, u64 device_name,
 372         u64 enclosure_logical_id, u16 slot, u8 form,
 373         Mpi2BiosPage2BootDevice_t *boot_device)
 374 {
 375         int rc = 0;
 376 
 377         switch (form) {
 378         case MPI2_BIOSPAGE2_FORM_SAS_WWID:
 379                 if (!sas_address)
 380                         break;
 381                 rc = _scsih_srch_boot_sas_address(
 382                     sas_address, &boot_device->SasWwid);
 383                 break;
 384         case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:
 385                 if (!enclosure_logical_id)
 386                         break;
 387                 rc = _scsih_srch_boot_encl_slot(
 388                     enclosure_logical_id,
 389                     slot, &boot_device->EnclosureSlot);
 390                 break;
 391         case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:
 392                 if (!device_name)
 393                         break;
 394                 rc = _scsih_srch_boot_device_name(
 395                     device_name, &boot_device->DeviceName);
 396                 break;
 397         case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:
 398                 break;
 399         }
 400 
 401         return rc;
 402 }
 403 
 404 /**
 405  * _scsih_get_sas_address - set the sas_address for given device handle
 406  * @ioc: ?
 407  * @handle: device handle
 408  * @sas_address: sas address
 409  *
 410  * Return: 0 success, non-zero when failure
 411  */
 412 static int
 413 _scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle,
 414         u64 *sas_address)
 415 {
 416         Mpi2SasDevicePage0_t sas_device_pg0;
 417         Mpi2ConfigReply_t mpi_reply;
 418         u32 ioc_status;
 419 
 420         *sas_address = 0;
 421 
 422         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 423             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
 424                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 425                         __FILE__, __LINE__, __func__);
 426                 return -ENXIO;
 427         }
 428 
 429         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
 430         if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
 431                 /* For HBA, vSES doesn't return HBA SAS address. Instead return
 432                  * vSES's sas address.
 433                  */
 434                 if ((handle <= ioc->sas_hba.num_phys) &&
 435                    (!(le32_to_cpu(sas_device_pg0.DeviceInfo) &
 436                    MPI2_SAS_DEVICE_INFO_SEP)))
 437                         *sas_address = ioc->sas_hba.sas_address;
 438                 else
 439                         *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
 440                 return 0;
 441         }
 442 
 443         /* we hit this because the given parent handle doesn't exist */
 444         if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
 445                 return -ENXIO;
 446 
 447         /* else error case */
 448         ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
 449                 handle, ioc_status, __FILE__, __LINE__, __func__);
 450         return -EIO;
 451 }
 452 
 453 /**
 454  * _scsih_determine_boot_device - determine boot device.
 455  * @ioc: per adapter object
 456  * @device: sas_device or pcie_device object
 457  * @channel: SAS or PCIe channel
 458  *
 459  * Determines whether this device should be first reported device to
 460  * to scsi-ml or sas transport, this purpose is for persistent boot device.
 461  * There are primary, alternate, and current entries in bios page 2. The order
 462  * priority is primary, alternate, then current.  This routine saves
 463  * the corresponding device object.
 464  * The saved data to be used later in _scsih_probe_boot_devices().
 465  */
 466 static void
 467 _scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc, void *device,
 468         u32 channel)
 469 {
 470         struct _sas_device *sas_device;
 471         struct _pcie_device *pcie_device;
 472         struct _raid_device *raid_device;
 473         u64 sas_address;
 474         u64 device_name;
 475         u64 enclosure_logical_id;
 476         u16 slot;
 477 
 478          /* only process this function when driver loads */
 479         if (!ioc->is_driver_loading)
 480                 return;
 481 
 482          /* no Bios, return immediately */
 483         if (!ioc->bios_pg3.BiosVersion)
 484                 return;
 485 
 486         if (channel == RAID_CHANNEL) {
 487                 raid_device = device;
 488                 sas_address = raid_device->wwid;
 489                 device_name = 0;
 490                 enclosure_logical_id = 0;
 491                 slot = 0;
 492         } else if (channel == PCIE_CHANNEL) {
 493                 pcie_device = device;
 494                 sas_address = pcie_device->wwid;
 495                 device_name = 0;
 496                 enclosure_logical_id = 0;
 497                 slot = 0;
 498         } else {
 499                 sas_device = device;
 500                 sas_address = sas_device->sas_address;
 501                 device_name = sas_device->device_name;
 502                 enclosure_logical_id = sas_device->enclosure_logical_id;
 503                 slot = sas_device->slot;
 504         }
 505 
 506         if (!ioc->req_boot_device.device) {
 507                 if (_scsih_is_boot_device(sas_address, device_name,
 508                     enclosure_logical_id, slot,
 509                     (ioc->bios_pg2.ReqBootDeviceForm &
 510                     MPI2_BIOSPAGE2_FORM_MASK),
 511                     &ioc->bios_pg2.RequestedBootDevice)) {
 512                         dinitprintk(ioc,
 513                                     ioc_info(ioc, "%s: req_boot_device(0x%016llx)\n",
 514                                              __func__, (u64)sas_address));
 515                         ioc->req_boot_device.device = device;
 516                         ioc->req_boot_device.channel = channel;
 517                 }
 518         }
 519 
 520         if (!ioc->req_alt_boot_device.device) {
 521                 if (_scsih_is_boot_device(sas_address, device_name,
 522                     enclosure_logical_id, slot,
 523                     (ioc->bios_pg2.ReqAltBootDeviceForm &
 524                     MPI2_BIOSPAGE2_FORM_MASK),
 525                     &ioc->bios_pg2.RequestedAltBootDevice)) {
 526                         dinitprintk(ioc,
 527                                     ioc_info(ioc, "%s: req_alt_boot_device(0x%016llx)\n",
 528                                              __func__, (u64)sas_address));
 529                         ioc->req_alt_boot_device.device = device;
 530                         ioc->req_alt_boot_device.channel = channel;
 531                 }
 532         }
 533 
 534         if (!ioc->current_boot_device.device) {
 535                 if (_scsih_is_boot_device(sas_address, device_name,
 536                     enclosure_logical_id, slot,
 537                     (ioc->bios_pg2.CurrentBootDeviceForm &
 538                     MPI2_BIOSPAGE2_FORM_MASK),
 539                     &ioc->bios_pg2.CurrentBootDevice)) {
 540                         dinitprintk(ioc,
 541                                     ioc_info(ioc, "%s: current_boot_device(0x%016llx)\n",
 542                                              __func__, (u64)sas_address));
 543                         ioc->current_boot_device.device = device;
 544                         ioc->current_boot_device.channel = channel;
 545                 }
 546         }
 547 }
 548 
 549 static struct _sas_device *
 550 __mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
 551                 struct MPT3SAS_TARGET *tgt_priv)
 552 {
 553         struct _sas_device *ret;
 554 
 555         assert_spin_locked(&ioc->sas_device_lock);
 556 
 557         ret = tgt_priv->sas_dev;
 558         if (ret)
 559                 sas_device_get(ret);
 560 
 561         return ret;
 562 }
 563 
 564 static struct _sas_device *
 565 mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
 566                 struct MPT3SAS_TARGET *tgt_priv)
 567 {
 568         struct _sas_device *ret;
 569         unsigned long flags;
 570 
 571         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 572         ret = __mpt3sas_get_sdev_from_target(ioc, tgt_priv);
 573         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 574 
 575         return ret;
 576 }
 577 
 578 static struct _pcie_device *
 579 __mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc,
 580         struct MPT3SAS_TARGET *tgt_priv)
 581 {
 582         struct _pcie_device *ret;
 583 
 584         assert_spin_locked(&ioc->pcie_device_lock);
 585 
 586         ret = tgt_priv->pcie_dev;
 587         if (ret)
 588                 pcie_device_get(ret);
 589 
 590         return ret;
 591 }
 592 
 593 /**
 594  * mpt3sas_get_pdev_from_target - pcie device search
 595  * @ioc: per adapter object
 596  * @tgt_priv: starget private object
 597  *
 598  * Context: This function will acquire ioc->pcie_device_lock and will release
 599  * before returning the pcie_device object.
 600  *
 601  * This searches for pcie_device from target, then return pcie_device object.
 602  */
 603 static struct _pcie_device *
 604 mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc,
 605         struct MPT3SAS_TARGET *tgt_priv)
 606 {
 607         struct _pcie_device *ret;
 608         unsigned long flags;
 609 
 610         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
 611         ret = __mpt3sas_get_pdev_from_target(ioc, tgt_priv);
 612         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
 613 
 614         return ret;
 615 }
 616 
 617 struct _sas_device *
 618 __mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
 619                                         u64 sas_address)
 620 {
 621         struct _sas_device *sas_device;
 622 
 623         assert_spin_locked(&ioc->sas_device_lock);
 624 
 625         list_for_each_entry(sas_device, &ioc->sas_device_list, list)
 626                 if (sas_device->sas_address == sas_address)
 627                         goto found_device;
 628 
 629         list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
 630                 if (sas_device->sas_address == sas_address)
 631                         goto found_device;
 632 
 633         return NULL;
 634 
 635 found_device:
 636         sas_device_get(sas_device);
 637         return sas_device;
 638 }
 639 
 640 /**
 641  * mpt3sas_get_sdev_by_addr - sas device search
 642  * @ioc: per adapter object
 643  * @sas_address: sas address
 644  * Context: Calling function should acquire ioc->sas_device_lock
 645  *
 646  * This searches for sas_device based on sas_address, then return sas_device
 647  * object.
 648  */
 649 struct _sas_device *
 650 mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
 651         u64 sas_address)
 652 {
 653         struct _sas_device *sas_device;
 654         unsigned long flags;
 655 
 656         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 657         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
 658                         sas_address);
 659         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 660 
 661         return sas_device;
 662 }
 663 
 664 static struct _sas_device *
 665 __mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 666 {
 667         struct _sas_device *sas_device;
 668 
 669         assert_spin_locked(&ioc->sas_device_lock);
 670 
 671         list_for_each_entry(sas_device, &ioc->sas_device_list, list)
 672                 if (sas_device->handle == handle)
 673                         goto found_device;
 674 
 675         list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
 676                 if (sas_device->handle == handle)
 677                         goto found_device;
 678 
 679         return NULL;
 680 
 681 found_device:
 682         sas_device_get(sas_device);
 683         return sas_device;
 684 }
 685 
 686 /**
 687  * mpt3sas_get_sdev_by_handle - sas device search
 688  * @ioc: per adapter object
 689  * @handle: sas device handle (assigned by firmware)
 690  * Context: Calling function should acquire ioc->sas_device_lock
 691  *
 692  * This searches for sas_device based on sas_address, then return sas_device
 693  * object.
 694  */
 695 struct _sas_device *
 696 mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 697 {
 698         struct _sas_device *sas_device;
 699         unsigned long flags;
 700 
 701         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 702         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
 703         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 704 
 705         return sas_device;
 706 }
 707 
 708 /**
 709  * _scsih_display_enclosure_chassis_info - display device location info
 710  * @ioc: per adapter object
 711  * @sas_device: per sas device object
 712  * @sdev: scsi device struct
 713  * @starget: scsi target struct
 714  */
 715 static void
 716 _scsih_display_enclosure_chassis_info(struct MPT3SAS_ADAPTER *ioc,
 717         struct _sas_device *sas_device, struct scsi_device *sdev,
 718         struct scsi_target *starget)
 719 {
 720         if (sdev) {
 721                 if (sas_device->enclosure_handle != 0)
 722                         sdev_printk(KERN_INFO, sdev,
 723                             "enclosure logical id (0x%016llx), slot(%d) \n",
 724                             (unsigned long long)
 725                             sas_device->enclosure_logical_id,
 726                             sas_device->slot);
 727                 if (sas_device->connector_name[0] != '\0')
 728                         sdev_printk(KERN_INFO, sdev,
 729                             "enclosure level(0x%04x), connector name( %s)\n",
 730                             sas_device->enclosure_level,
 731                             sas_device->connector_name);
 732                 if (sas_device->is_chassis_slot_valid)
 733                         sdev_printk(KERN_INFO, sdev, "chassis slot(0x%04x)\n",
 734                             sas_device->chassis_slot);
 735         } else if (starget) {
 736                 if (sas_device->enclosure_handle != 0)
 737                         starget_printk(KERN_INFO, starget,
 738                             "enclosure logical id(0x%016llx), slot(%d) \n",
 739                             (unsigned long long)
 740                             sas_device->enclosure_logical_id,
 741                             sas_device->slot);
 742                 if (sas_device->connector_name[0] != '\0')
 743                         starget_printk(KERN_INFO, starget,
 744                             "enclosure level(0x%04x), connector name( %s)\n",
 745                             sas_device->enclosure_level,
 746                             sas_device->connector_name);
 747                 if (sas_device->is_chassis_slot_valid)
 748                         starget_printk(KERN_INFO, starget,
 749                             "chassis slot(0x%04x)\n",
 750                             sas_device->chassis_slot);
 751         } else {
 752                 if (sas_device->enclosure_handle != 0)
 753                         ioc_info(ioc, "enclosure logical id(0x%016llx), slot(%d)\n",
 754                                  (u64)sas_device->enclosure_logical_id,
 755                                  sas_device->slot);
 756                 if (sas_device->connector_name[0] != '\0')
 757                         ioc_info(ioc, "enclosure level(0x%04x), connector name( %s)\n",
 758                                  sas_device->enclosure_level,
 759                                  sas_device->connector_name);
 760                 if (sas_device->is_chassis_slot_valid)
 761                         ioc_info(ioc, "chassis slot(0x%04x)\n",
 762                                  sas_device->chassis_slot);
 763         }
 764 }
 765 
 766 /**
 767  * _scsih_sas_device_remove - remove sas_device from list.
 768  * @ioc: per adapter object
 769  * @sas_device: the sas_device object
 770  * Context: This function will acquire ioc->sas_device_lock.
 771  *
 772  * If sas_device is on the list, remove it and decrement its reference count.
 773  */
 774 static void
 775 _scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc,
 776         struct _sas_device *sas_device)
 777 {
 778         unsigned long flags;
 779 
 780         if (!sas_device)
 781                 return;
 782         ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
 783                  sas_device->handle, (u64)sas_device->sas_address);
 784 
 785         _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
 786 
 787         /*
 788          * The lock serializes access to the list, but we still need to verify
 789          * that nobody removed the entry while we were waiting on the lock.
 790          */
 791         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 792         if (!list_empty(&sas_device->list)) {
 793                 list_del_init(&sas_device->list);
 794                 sas_device_put(sas_device);
 795         }
 796         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 797 }
 798 
 799 /**
 800  * _scsih_device_remove_by_handle - removing device object by handle
 801  * @ioc: per adapter object
 802  * @handle: device handle
 803  */
 804 static void
 805 _scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 806 {
 807         struct _sas_device *sas_device;
 808         unsigned long flags;
 809 
 810         if (ioc->shost_recovery)
 811                 return;
 812 
 813         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 814         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
 815         if (sas_device) {
 816                 list_del_init(&sas_device->list);
 817                 sas_device_put(sas_device);
 818         }
 819         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 820         if (sas_device) {
 821                 _scsih_remove_device(ioc, sas_device);
 822                 sas_device_put(sas_device);
 823         }
 824 }
 825 
 826 /**
 827  * mpt3sas_device_remove_by_sas_address - removing device object by sas address
 828  * @ioc: per adapter object
 829  * @sas_address: device sas_address
 830  */
 831 void
 832 mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
 833         u64 sas_address)
 834 {
 835         struct _sas_device *sas_device;
 836         unsigned long flags;
 837 
 838         if (ioc->shost_recovery)
 839                 return;
 840 
 841         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 842         sas_device = __mpt3sas_get_sdev_by_addr(ioc, sas_address);
 843         if (sas_device) {
 844                 list_del_init(&sas_device->list);
 845                 sas_device_put(sas_device);
 846         }
 847         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 848         if (sas_device) {
 849                 _scsih_remove_device(ioc, sas_device);
 850                 sas_device_put(sas_device);
 851         }
 852 }
 853 
 854 /**
 855  * _scsih_sas_device_add - insert sas_device to the list.
 856  * @ioc: per adapter object
 857  * @sas_device: the sas_device object
 858  * Context: This function will acquire ioc->sas_device_lock.
 859  *
 860  * Adding new object to the ioc->sas_device_list.
 861  */
 862 static void
 863 _scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc,
 864         struct _sas_device *sas_device)
 865 {
 866         unsigned long flags;
 867 
 868         dewtprintk(ioc,
 869                    ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
 870                             __func__, sas_device->handle,
 871                             (u64)sas_device->sas_address));
 872 
 873         dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
 874             NULL, NULL));
 875 
 876         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 877         sas_device_get(sas_device);
 878         list_add_tail(&sas_device->list, &ioc->sas_device_list);
 879         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 880 
 881         if (ioc->hide_drives) {
 882                 clear_bit(sas_device->handle, ioc->pend_os_device_add);
 883                 return;
 884         }
 885 
 886         if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
 887              sas_device->sas_address_parent)) {
 888                 _scsih_sas_device_remove(ioc, sas_device);
 889         } else if (!sas_device->starget) {
 890                 /*
 891                  * When asyn scanning is enabled, its not possible to remove
 892                  * devices while scanning is turned on due to an oops in
 893                  * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start()
 894                  */
 895                 if (!ioc->is_driver_loading) {
 896                         mpt3sas_transport_port_remove(ioc,
 897                             sas_device->sas_address,
 898                             sas_device->sas_address_parent);
 899                         _scsih_sas_device_remove(ioc, sas_device);
 900                 }
 901         } else
 902                 clear_bit(sas_device->handle, ioc->pend_os_device_add);
 903 }
 904 
 905 /**
 906  * _scsih_sas_device_init_add - insert sas_device to the list.
 907  * @ioc: per adapter object
 908  * @sas_device: the sas_device object
 909  * Context: This function will acquire ioc->sas_device_lock.
 910  *
 911  * Adding new object at driver load time to the ioc->sas_device_init_list.
 912  */
 913 static void
 914 _scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc,
 915         struct _sas_device *sas_device)
 916 {
 917         unsigned long flags;
 918 
 919         dewtprintk(ioc,
 920                    ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
 921                             __func__, sas_device->handle,
 922                             (u64)sas_device->sas_address));
 923 
 924         dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
 925             NULL, NULL));
 926 
 927         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 928         sas_device_get(sas_device);
 929         list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
 930         _scsih_determine_boot_device(ioc, sas_device, 0);
 931         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 932 }
 933 
 934 
 935 static struct _pcie_device *
 936 __mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
 937 {
 938         struct _pcie_device *pcie_device;
 939 
 940         assert_spin_locked(&ioc->pcie_device_lock);
 941 
 942         list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
 943                 if (pcie_device->wwid == wwid)
 944                         goto found_device;
 945 
 946         list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
 947                 if (pcie_device->wwid == wwid)
 948                         goto found_device;
 949 
 950         return NULL;
 951 
 952 found_device:
 953         pcie_device_get(pcie_device);
 954         return pcie_device;
 955 }
 956 
 957 
 958 /**
 959  * mpt3sas_get_pdev_by_wwid - pcie device search
 960  * @ioc: per adapter object
 961  * @wwid: wwid
 962  *
 963  * Context: This function will acquire ioc->pcie_device_lock and will release
 964  * before returning the pcie_device object.
 965  *
 966  * This searches for pcie_device based on wwid, then return pcie_device object.
 967  */
 968 static struct _pcie_device *
 969 mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
 970 {
 971         struct _pcie_device *pcie_device;
 972         unsigned long flags;
 973 
 974         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
 975         pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
 976         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
 977 
 978         return pcie_device;
 979 }
 980 
 981 
 982 static struct _pcie_device *
 983 __mpt3sas_get_pdev_by_idchannel(struct MPT3SAS_ADAPTER *ioc, int id,
 984         int channel)
 985 {
 986         struct _pcie_device *pcie_device;
 987 
 988         assert_spin_locked(&ioc->pcie_device_lock);
 989 
 990         list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
 991                 if (pcie_device->id == id && pcie_device->channel == channel)
 992                         goto found_device;
 993 
 994         list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
 995                 if (pcie_device->id == id && pcie_device->channel == channel)
 996                         goto found_device;
 997 
 998         return NULL;
 999 
1000 found_device:
1001         pcie_device_get(pcie_device);
1002         return pcie_device;
1003 }
1004 
1005 static struct _pcie_device *
1006 __mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1007 {
1008         struct _pcie_device *pcie_device;
1009 
1010         assert_spin_locked(&ioc->pcie_device_lock);
1011 
1012         list_for_each_entry(pcie_device, &ioc->pcie_device_list, list)
1013                 if (pcie_device->handle == handle)
1014                         goto found_device;
1015 
1016         list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list)
1017                 if (pcie_device->handle == handle)
1018                         goto found_device;
1019 
1020         return NULL;
1021 
1022 found_device:
1023         pcie_device_get(pcie_device);
1024         return pcie_device;
1025 }
1026 
1027 
1028 /**
1029  * mpt3sas_get_pdev_by_handle - pcie device search
1030  * @ioc: per adapter object
1031  * @handle: Firmware device handle
1032  *
1033  * Context: This function will acquire ioc->pcie_device_lock and will release
1034  * before returning the pcie_device object.
1035  *
1036  * This searches for pcie_device based on handle, then return pcie_device
1037  * object.
1038  */
1039 struct _pcie_device *
1040 mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1041 {
1042         struct _pcie_device *pcie_device;
1043         unsigned long flags;
1044 
1045         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1046         pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
1047         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1048 
1049         return pcie_device;
1050 }
1051 
1052 /**
1053  * _scsih_pcie_device_remove - remove pcie_device from list.
1054  * @ioc: per adapter object
1055  * @pcie_device: the pcie_device object
1056  * Context: This function will acquire ioc->pcie_device_lock.
1057  *
1058  * If pcie_device is on the list, remove it and decrement its reference count.
1059  */
1060 static void
1061 _scsih_pcie_device_remove(struct MPT3SAS_ADAPTER *ioc,
1062         struct _pcie_device *pcie_device)
1063 {
1064         unsigned long flags;
1065         int was_on_pcie_device_list = 0;
1066 
1067         if (!pcie_device)
1068                 return;
1069         ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
1070                  pcie_device->handle, (u64)pcie_device->wwid);
1071         if (pcie_device->enclosure_handle != 0)
1072                 ioc_info(ioc, "removing enclosure logical id(0x%016llx), slot(%d)\n",
1073                          (u64)pcie_device->enclosure_logical_id,
1074                          pcie_device->slot);
1075         if (pcie_device->connector_name[0] != '\0')
1076                 ioc_info(ioc, "removing enclosure level(0x%04x), connector name( %s)\n",
1077                          pcie_device->enclosure_level,
1078                          pcie_device->connector_name);
1079 
1080         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1081         if (!list_empty(&pcie_device->list)) {
1082                 list_del_init(&pcie_device->list);
1083                 was_on_pcie_device_list = 1;
1084         }
1085         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1086         if (was_on_pcie_device_list) {
1087                 kfree(pcie_device->serial_number);
1088                 pcie_device_put(pcie_device);
1089         }
1090 }
1091 
1092 
1093 /**
1094  * _scsih_pcie_device_remove_by_handle - removing pcie device object by handle
1095  * @ioc: per adapter object
1096  * @handle: device handle
1097  */
1098 static void
1099 _scsih_pcie_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1100 {
1101         struct _pcie_device *pcie_device;
1102         unsigned long flags;
1103         int was_on_pcie_device_list = 0;
1104 
1105         if (ioc->shost_recovery)
1106                 return;
1107 
1108         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1109         pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
1110         if (pcie_device) {
1111                 if (!list_empty(&pcie_device->list)) {
1112                         list_del_init(&pcie_device->list);
1113                         was_on_pcie_device_list = 1;
1114                         pcie_device_put(pcie_device);
1115                 }
1116         }
1117         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1118         if (was_on_pcie_device_list) {
1119                 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
1120                 pcie_device_put(pcie_device);
1121         }
1122 }
1123 
1124 /**
1125  * _scsih_pcie_device_add - add pcie_device object
1126  * @ioc: per adapter object
1127  * @pcie_device: pcie_device object
1128  *
1129  * This is added to the pcie_device_list link list.
1130  */
1131 static void
1132 _scsih_pcie_device_add(struct MPT3SAS_ADAPTER *ioc,
1133         struct _pcie_device *pcie_device)
1134 {
1135         unsigned long flags;
1136 
1137         dewtprintk(ioc,
1138                    ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
1139                             __func__,
1140                             pcie_device->handle, (u64)pcie_device->wwid));
1141         if (pcie_device->enclosure_handle != 0)
1142                 dewtprintk(ioc,
1143                            ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
1144                                     __func__,
1145                                     (u64)pcie_device->enclosure_logical_id,
1146                                     pcie_device->slot));
1147         if (pcie_device->connector_name[0] != '\0')
1148                 dewtprintk(ioc,
1149                            ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
1150                                     __func__, pcie_device->enclosure_level,
1151                                     pcie_device->connector_name));
1152 
1153         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1154         pcie_device_get(pcie_device);
1155         list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
1156         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1157 
1158         if (pcie_device->access_status ==
1159             MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED) {
1160                 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1161                 return;
1162         }
1163         if (scsi_add_device(ioc->shost, PCIE_CHANNEL, pcie_device->id, 0)) {
1164                 _scsih_pcie_device_remove(ioc, pcie_device);
1165         } else if (!pcie_device->starget) {
1166                 if (!ioc->is_driver_loading) {
1167 /*TODO-- Need to find out whether this condition will occur or not*/
1168                         clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1169                 }
1170         } else
1171                 clear_bit(pcie_device->handle, ioc->pend_os_device_add);
1172 }
1173 
1174 /*
1175  * _scsih_pcie_device_init_add - insert pcie_device to the init list.
1176  * @ioc: per adapter object
1177  * @pcie_device: the pcie_device object
1178  * Context: This function will acquire ioc->pcie_device_lock.
1179  *
1180  * Adding new object at driver load time to the ioc->pcie_device_init_list.
1181  */
1182 static void
1183 _scsih_pcie_device_init_add(struct MPT3SAS_ADAPTER *ioc,
1184                                 struct _pcie_device *pcie_device)
1185 {
1186         unsigned long flags;
1187 
1188         dewtprintk(ioc,
1189                    ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
1190                             __func__,
1191                             pcie_device->handle, (u64)pcie_device->wwid));
1192         if (pcie_device->enclosure_handle != 0)
1193                 dewtprintk(ioc,
1194                            ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
1195                                     __func__,
1196                                     (u64)pcie_device->enclosure_logical_id,
1197                                     pcie_device->slot));
1198         if (pcie_device->connector_name[0] != '\0')
1199                 dewtprintk(ioc,
1200                            ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
1201                                     __func__, pcie_device->enclosure_level,
1202                                     pcie_device->connector_name));
1203 
1204         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1205         pcie_device_get(pcie_device);
1206         list_add_tail(&pcie_device->list, &ioc->pcie_device_init_list);
1207         if (pcie_device->access_status !=
1208             MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED)
1209                 _scsih_determine_boot_device(ioc, pcie_device, PCIE_CHANNEL);
1210         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1211 }
1212 /**
1213  * _scsih_raid_device_find_by_id - raid device search
1214  * @ioc: per adapter object
1215  * @id: sas device target id
1216  * @channel: sas device channel
1217  * Context: Calling function should acquire ioc->raid_device_lock
1218  *
1219  * This searches for raid_device based on target id, then return raid_device
1220  * object.
1221  */
1222 static struct _raid_device *
1223 _scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel)
1224 {
1225         struct _raid_device *raid_device, *r;
1226 
1227         r = NULL;
1228         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1229                 if (raid_device->id == id && raid_device->channel == channel) {
1230                         r = raid_device;
1231                         goto out;
1232                 }
1233         }
1234 
1235  out:
1236         return r;
1237 }
1238 
1239 /**
1240  * mpt3sas_raid_device_find_by_handle - raid device search
1241  * @ioc: per adapter object
1242  * @handle: sas device handle (assigned by firmware)
1243  * Context: Calling function should acquire ioc->raid_device_lock
1244  *
1245  * This searches for raid_device based on handle, then return raid_device
1246  * object.
1247  */
1248 struct _raid_device *
1249 mpt3sas_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1250 {
1251         struct _raid_device *raid_device, *r;
1252 
1253         r = NULL;
1254         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1255                 if (raid_device->handle != handle)
1256                         continue;
1257                 r = raid_device;
1258                 goto out;
1259         }
1260 
1261  out:
1262         return r;
1263 }
1264 
1265 /**
1266  * _scsih_raid_device_find_by_wwid - raid device search
1267  * @ioc: per adapter object
1268  * @wwid: ?
1269  * Context: Calling function should acquire ioc->raid_device_lock
1270  *
1271  * This searches for raid_device based on wwid, then return raid_device
1272  * object.
1273  */
1274 static struct _raid_device *
1275 _scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
1276 {
1277         struct _raid_device *raid_device, *r;
1278 
1279         r = NULL;
1280         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1281                 if (raid_device->wwid != wwid)
1282                         continue;
1283                 r = raid_device;
1284                 goto out;
1285         }
1286 
1287  out:
1288         return r;
1289 }
1290 
1291 /**
1292  * _scsih_raid_device_add - add raid_device object
1293  * @ioc: per adapter object
1294  * @raid_device: raid_device object
1295  *
1296  * This is added to the raid_device_list link list.
1297  */
1298 static void
1299 _scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc,
1300         struct _raid_device *raid_device)
1301 {
1302         unsigned long flags;
1303 
1304         dewtprintk(ioc,
1305                    ioc_info(ioc, "%s: handle(0x%04x), wwid(0x%016llx)\n",
1306                             __func__,
1307                             raid_device->handle, (u64)raid_device->wwid));
1308 
1309         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1310         list_add_tail(&raid_device->list, &ioc->raid_device_list);
1311         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1312 }
1313 
1314 /**
1315  * _scsih_raid_device_remove - delete raid_device object
1316  * @ioc: per adapter object
1317  * @raid_device: raid_device object
1318  *
1319  */
1320 static void
1321 _scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc,
1322         struct _raid_device *raid_device)
1323 {
1324         unsigned long flags;
1325 
1326         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1327         list_del(&raid_device->list);
1328         kfree(raid_device);
1329         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1330 }
1331 
1332 /**
1333  * mpt3sas_scsih_expander_find_by_handle - expander device search
1334  * @ioc: per adapter object
1335  * @handle: expander handle (assigned by firmware)
1336  * Context: Calling function should acquire ioc->sas_device_lock
1337  *
1338  * This searches for expander device based on handle, then returns the
1339  * sas_node object.
1340  */
1341 struct _sas_node *
1342 mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1343 {
1344         struct _sas_node *sas_expander, *r;
1345 
1346         r = NULL;
1347         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1348                 if (sas_expander->handle != handle)
1349                         continue;
1350                 r = sas_expander;
1351                 goto out;
1352         }
1353  out:
1354         return r;
1355 }
1356 
1357 /**
1358  * mpt3sas_scsih_enclosure_find_by_handle - exclosure device search
1359  * @ioc: per adapter object
1360  * @handle: enclosure handle (assigned by firmware)
1361  * Context: Calling function should acquire ioc->sas_device_lock
1362  *
1363  * This searches for enclosure device based on handle, then returns the
1364  * enclosure object.
1365  */
1366 static struct _enclosure_node *
1367 mpt3sas_scsih_enclosure_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
1368 {
1369         struct _enclosure_node *enclosure_dev, *r;
1370 
1371         r = NULL;
1372         list_for_each_entry(enclosure_dev, &ioc->enclosure_list, list) {
1373                 if (le16_to_cpu(enclosure_dev->pg0.EnclosureHandle) != handle)
1374                         continue;
1375                 r = enclosure_dev;
1376                 goto out;
1377         }
1378 out:
1379         return r;
1380 }
1381 /**
1382  * mpt3sas_scsih_expander_find_by_sas_address - expander device search
1383  * @ioc: per adapter object
1384  * @sas_address: sas address
1385  * Context: Calling function should acquire ioc->sas_node_lock.
1386  *
1387  * This searches for expander device based on sas_address, then returns the
1388  * sas_node object.
1389  */
1390 struct _sas_node *
1391 mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
1392         u64 sas_address)
1393 {
1394         struct _sas_node *sas_expander, *r;
1395 
1396         r = NULL;
1397         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1398                 if (sas_expander->sas_address != sas_address)
1399                         continue;
1400                 r = sas_expander;
1401                 goto out;
1402         }
1403  out:
1404         return r;
1405 }
1406 
1407 /**
1408  * _scsih_expander_node_add - insert expander device to the list.
1409  * @ioc: per adapter object
1410  * @sas_expander: the sas_device object
1411  * Context: This function will acquire ioc->sas_node_lock.
1412  *
1413  * Adding new object to the ioc->sas_expander_list.
1414  */
1415 static void
1416 _scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc,
1417         struct _sas_node *sas_expander)
1418 {
1419         unsigned long flags;
1420 
1421         spin_lock_irqsave(&ioc->sas_node_lock, flags);
1422         list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
1423         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1424 }
1425 
1426 /**
1427  * _scsih_is_end_device - determines if device is an end device
1428  * @device_info: bitfield providing information about the device.
1429  * Context: none
1430  *
1431  * Return: 1 if end device.
1432  */
1433 static int
1434 _scsih_is_end_device(u32 device_info)
1435 {
1436         if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&
1437                 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) |
1438                 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) |
1439                 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)))
1440                 return 1;
1441         else
1442                 return 0;
1443 }
1444 
1445 /**
1446  * _scsih_is_nvme_pciescsi_device - determines if
1447  *                      device is an pcie nvme/scsi device
1448  * @device_info: bitfield providing information about the device.
1449  * Context: none
1450  *
1451  * Returns 1 if device is pcie device type nvme/scsi.
1452  */
1453 static int
1454 _scsih_is_nvme_pciescsi_device(u32 device_info)
1455 {
1456         if (((device_info & MPI26_PCIE_DEVINFO_MASK_DEVICE_TYPE)
1457             == MPI26_PCIE_DEVINFO_NVME) ||
1458             ((device_info & MPI26_PCIE_DEVINFO_MASK_DEVICE_TYPE)
1459             == MPI26_PCIE_DEVINFO_SCSI))
1460                 return 1;
1461         else
1462                 return 0;
1463 }
1464 
1465 /**
1466  * mpt3sas_scsih_scsi_lookup_get - returns scmd entry
1467  * @ioc: per adapter object
1468  * @smid: system request message index
1469  *
1470  * Return: the smid stored scmd pointer.
1471  * Then will dereference the stored scmd pointer.
1472  */
1473 struct scsi_cmnd *
1474 mpt3sas_scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
1475 {
1476         struct scsi_cmnd *scmd = NULL;
1477         struct scsiio_tracker *st;
1478         Mpi25SCSIIORequest_t *mpi_request;
1479 
1480         if (smid > 0  &&
1481             smid <= ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT) {
1482                 u32 unique_tag = smid - 1;
1483 
1484                 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1485 
1486                 /*
1487                  * If SCSI IO request is outstanding at driver level then
1488                  * DevHandle filed must be non-zero. If DevHandle is zero
1489                  * then it means that this smid is free at driver level,
1490                  * so return NULL.
1491                  */
1492                 if (!mpi_request->DevHandle)
1493                         return scmd;
1494 
1495                 scmd = scsi_host_find_tag(ioc->shost, unique_tag);
1496                 if (scmd) {
1497                         st = scsi_cmd_priv(scmd);
1498                         if (st->cb_idx == 0xFF || st->smid == 0)
1499                                 scmd = NULL;
1500                 }
1501         }
1502         return scmd;
1503 }
1504 
1505 /**
1506  * scsih_change_queue_depth - setting device queue depth
1507  * @sdev: scsi device struct
1508  * @qdepth: requested queue depth
1509  *
1510  * Return: queue depth.
1511  */
1512 static int
1513 scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
1514 {
1515         struct Scsi_Host *shost = sdev->host;
1516         int max_depth;
1517         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1518         struct MPT3SAS_DEVICE *sas_device_priv_data;
1519         struct MPT3SAS_TARGET *sas_target_priv_data;
1520         struct _sas_device *sas_device;
1521         unsigned long flags;
1522 
1523         max_depth = shost->can_queue;
1524 
1525         /*
1526          * limit max device queue for SATA to 32 if enable_sdev_max_qd
1527          * is disabled.
1528          */
1529         if (ioc->enable_sdev_max_qd)
1530                 goto not_sata;
1531 
1532         sas_device_priv_data = sdev->hostdata;
1533         if (!sas_device_priv_data)
1534                 goto not_sata;
1535         sas_target_priv_data = sas_device_priv_data->sas_target;
1536         if (!sas_target_priv_data)
1537                 goto not_sata;
1538         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
1539                 goto not_sata;
1540 
1541         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1542         sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
1543         if (sas_device) {
1544                 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1545                         max_depth = MPT3SAS_SATA_QUEUE_DEPTH;
1546 
1547                 sas_device_put(sas_device);
1548         }
1549         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1550 
1551  not_sata:
1552 
1553         if (!sdev->tagged_supported)
1554                 max_depth = 1;
1555         if (qdepth > max_depth)
1556                 qdepth = max_depth;
1557         return scsi_change_queue_depth(sdev, qdepth);
1558 }
1559 
1560 /**
1561  * mpt3sas_scsih_change_queue_depth - setting device queue depth
1562  * @sdev: scsi device struct
1563  * @qdepth: requested queue depth
1564  *
1565  * Returns nothing.
1566  */
1567 void
1568 mpt3sas_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
1569 {
1570         struct Scsi_Host *shost = sdev->host;
1571         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1572 
1573         if (ioc->enable_sdev_max_qd)
1574                 qdepth = shost->can_queue;
1575 
1576         scsih_change_queue_depth(sdev, qdepth);
1577 }
1578 
1579 /**
1580  * scsih_target_alloc - target add routine
1581  * @starget: scsi target struct
1582  *
1583  * Return: 0 if ok. Any other return is assumed to be an error and
1584  * the device is ignored.
1585  */
1586 static int
1587 scsih_target_alloc(struct scsi_target *starget)
1588 {
1589         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1590         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1591         struct MPT3SAS_TARGET *sas_target_priv_data;
1592         struct _sas_device *sas_device;
1593         struct _raid_device *raid_device;
1594         struct _pcie_device *pcie_device;
1595         unsigned long flags;
1596         struct sas_rphy *rphy;
1597 
1598         sas_target_priv_data = kzalloc(sizeof(*sas_target_priv_data),
1599                                        GFP_KERNEL);
1600         if (!sas_target_priv_data)
1601                 return -ENOMEM;
1602 
1603         starget->hostdata = sas_target_priv_data;
1604         sas_target_priv_data->starget = starget;
1605         sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
1606 
1607         /* RAID volumes */
1608         if (starget->channel == RAID_CHANNEL) {
1609                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1610                 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1611                     starget->channel);
1612                 if (raid_device) {
1613                         sas_target_priv_data->handle = raid_device->handle;
1614                         sas_target_priv_data->sas_address = raid_device->wwid;
1615                         sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
1616                         if (ioc->is_warpdrive)
1617                                 sas_target_priv_data->raid_device = raid_device;
1618                         raid_device->starget = starget;
1619                 }
1620                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1621                 return 0;
1622         }
1623 
1624         /* PCIe devices */
1625         if (starget->channel == PCIE_CHANNEL) {
1626                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1627                 pcie_device = __mpt3sas_get_pdev_by_idchannel(ioc, starget->id,
1628                         starget->channel);
1629                 if (pcie_device) {
1630                         sas_target_priv_data->handle = pcie_device->handle;
1631                         sas_target_priv_data->sas_address = pcie_device->wwid;
1632                         sas_target_priv_data->pcie_dev = pcie_device;
1633                         pcie_device->starget = starget;
1634                         pcie_device->id = starget->id;
1635                         pcie_device->channel = starget->channel;
1636                         sas_target_priv_data->flags |=
1637                                 MPT_TARGET_FLAGS_PCIE_DEVICE;
1638                         if (pcie_device->fast_path)
1639                                 sas_target_priv_data->flags |=
1640                                         MPT_TARGET_FASTPATH_IO;
1641                 }
1642                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1643                 return 0;
1644         }
1645 
1646         /* sas/sata devices */
1647         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1648         rphy = dev_to_rphy(starget->dev.parent);
1649         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1650            rphy->identify.sas_address);
1651 
1652         if (sas_device) {
1653                 sas_target_priv_data->handle = sas_device->handle;
1654                 sas_target_priv_data->sas_address = sas_device->sas_address;
1655                 sas_target_priv_data->sas_dev = sas_device;
1656                 sas_device->starget = starget;
1657                 sas_device->id = starget->id;
1658                 sas_device->channel = starget->channel;
1659                 if (test_bit(sas_device->handle, ioc->pd_handles))
1660                         sas_target_priv_data->flags |=
1661                             MPT_TARGET_FLAGS_RAID_COMPONENT;
1662                 if (sas_device->fast_path)
1663                         sas_target_priv_data->flags |=
1664                                         MPT_TARGET_FASTPATH_IO;
1665         }
1666         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1667 
1668         return 0;
1669 }
1670 
1671 /**
1672  * scsih_target_destroy - target destroy routine
1673  * @starget: scsi target struct
1674  */
1675 static void
1676 scsih_target_destroy(struct scsi_target *starget)
1677 {
1678         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1679         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1680         struct MPT3SAS_TARGET *sas_target_priv_data;
1681         struct _sas_device *sas_device;
1682         struct _raid_device *raid_device;
1683         struct _pcie_device *pcie_device;
1684         unsigned long flags;
1685 
1686         sas_target_priv_data = starget->hostdata;
1687         if (!sas_target_priv_data)
1688                 return;
1689 
1690         if (starget->channel == RAID_CHANNEL) {
1691                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1692                 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1693                     starget->channel);
1694                 if (raid_device) {
1695                         raid_device->starget = NULL;
1696                         raid_device->sdev = NULL;
1697                 }
1698                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1699                 goto out;
1700         }
1701 
1702         if (starget->channel == PCIE_CHANNEL) {
1703                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1704                 pcie_device = __mpt3sas_get_pdev_from_target(ioc,
1705                                                         sas_target_priv_data);
1706                 if (pcie_device && (pcie_device->starget == starget) &&
1707                         (pcie_device->id == starget->id) &&
1708                         (pcie_device->channel == starget->channel))
1709                         pcie_device->starget = NULL;
1710 
1711                 if (pcie_device) {
1712                         /*
1713                          * Corresponding get() is in _scsih_target_alloc()
1714                          */
1715                         sas_target_priv_data->pcie_dev = NULL;
1716                         pcie_device_put(pcie_device);
1717                         pcie_device_put(pcie_device);
1718                 }
1719                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1720                 goto out;
1721         }
1722 
1723         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1724         sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
1725         if (sas_device && (sas_device->starget == starget) &&
1726             (sas_device->id == starget->id) &&
1727             (sas_device->channel == starget->channel))
1728                 sas_device->starget = NULL;
1729 
1730         if (sas_device) {
1731                 /*
1732                  * Corresponding get() is in _scsih_target_alloc()
1733                  */
1734                 sas_target_priv_data->sas_dev = NULL;
1735                 sas_device_put(sas_device);
1736 
1737                 sas_device_put(sas_device);
1738         }
1739         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1740 
1741  out:
1742         kfree(sas_target_priv_data);
1743         starget->hostdata = NULL;
1744 }
1745 
1746 /**
1747  * scsih_slave_alloc - device add routine
1748  * @sdev: scsi device struct
1749  *
1750  * Return: 0 if ok. Any other return is assumed to be an error and
1751  * the device is ignored.
1752  */
1753 static int
1754 scsih_slave_alloc(struct scsi_device *sdev)
1755 {
1756         struct Scsi_Host *shost;
1757         struct MPT3SAS_ADAPTER *ioc;
1758         struct MPT3SAS_TARGET *sas_target_priv_data;
1759         struct MPT3SAS_DEVICE *sas_device_priv_data;
1760         struct scsi_target *starget;
1761         struct _raid_device *raid_device;
1762         struct _sas_device *sas_device;
1763         struct _pcie_device *pcie_device;
1764         unsigned long flags;
1765 
1766         sas_device_priv_data = kzalloc(sizeof(*sas_device_priv_data),
1767                                        GFP_KERNEL);
1768         if (!sas_device_priv_data)
1769                 return -ENOMEM;
1770 
1771         sas_device_priv_data->lun = sdev->lun;
1772         sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT;
1773 
1774         starget = scsi_target(sdev);
1775         sas_target_priv_data = starget->hostdata;
1776         sas_target_priv_data->num_luns++;
1777         sas_device_priv_data->sas_target = sas_target_priv_data;
1778         sdev->hostdata = sas_device_priv_data;
1779         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
1780                 sdev->no_uld_attach = 1;
1781 
1782         shost = dev_to_shost(&starget->dev);
1783         ioc = shost_priv(shost);
1784         if (starget->channel == RAID_CHANNEL) {
1785                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1786                 raid_device = _scsih_raid_device_find_by_id(ioc,
1787                     starget->id, starget->channel);
1788                 if (raid_device)
1789                         raid_device->sdev = sdev; /* raid is single lun */
1790                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1791         }
1792         if (starget->channel == PCIE_CHANNEL) {
1793                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1794                 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc,
1795                                 sas_target_priv_data->sas_address);
1796                 if (pcie_device && (pcie_device->starget == NULL)) {
1797                         sdev_printk(KERN_INFO, sdev,
1798                             "%s : pcie_device->starget set to starget @ %d\n",
1799                             __func__, __LINE__);
1800                         pcie_device->starget = starget;
1801                 }
1802 
1803                 if (pcie_device)
1804                         pcie_device_put(pcie_device);
1805                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1806 
1807         } else  if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1808                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1809                 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1810                                         sas_target_priv_data->sas_address);
1811                 if (sas_device && (sas_device->starget == NULL)) {
1812                         sdev_printk(KERN_INFO, sdev,
1813                         "%s : sas_device->starget set to starget @ %d\n",
1814                              __func__, __LINE__);
1815                         sas_device->starget = starget;
1816                 }
1817 
1818                 if (sas_device)
1819                         sas_device_put(sas_device);
1820 
1821                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1822         }
1823 
1824         return 0;
1825 }
1826 
1827 /**
1828  * scsih_slave_destroy - device destroy routine
1829  * @sdev: scsi device struct
1830  */
1831 static void
1832 scsih_slave_destroy(struct scsi_device *sdev)
1833 {
1834         struct MPT3SAS_TARGET *sas_target_priv_data;
1835         struct scsi_target *starget;
1836         struct Scsi_Host *shost;
1837         struct MPT3SAS_ADAPTER *ioc;
1838         struct _sas_device *sas_device;
1839         struct _pcie_device *pcie_device;
1840         unsigned long flags;
1841 
1842         if (!sdev->hostdata)
1843                 return;
1844 
1845         starget = scsi_target(sdev);
1846         sas_target_priv_data = starget->hostdata;
1847         sas_target_priv_data->num_luns--;
1848 
1849         shost = dev_to_shost(&starget->dev);
1850         ioc = shost_priv(shost);
1851 
1852         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
1853                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1854                 pcie_device = __mpt3sas_get_pdev_from_target(ioc,
1855                                 sas_target_priv_data);
1856                 if (pcie_device && !sas_target_priv_data->num_luns)
1857                         pcie_device->starget = NULL;
1858 
1859                 if (pcie_device)
1860                         pcie_device_put(pcie_device);
1861 
1862                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
1863 
1864         } else if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1865                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1866                 sas_device = __mpt3sas_get_sdev_from_target(ioc,
1867                                 sas_target_priv_data);
1868                 if (sas_device && !sas_target_priv_data->num_luns)
1869                         sas_device->starget = NULL;
1870 
1871                 if (sas_device)
1872                         sas_device_put(sas_device);
1873                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1874         }
1875 
1876         kfree(sdev->hostdata);
1877         sdev->hostdata = NULL;
1878 }
1879 
1880 /**
1881  * _scsih_display_sata_capabilities - sata capabilities
1882  * @ioc: per adapter object
1883  * @handle: device handle
1884  * @sdev: scsi device struct
1885  */
1886 static void
1887 _scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc,
1888         u16 handle, struct scsi_device *sdev)
1889 {
1890         Mpi2ConfigReply_t mpi_reply;
1891         Mpi2SasDevicePage0_t sas_device_pg0;
1892         u32 ioc_status;
1893         u16 flags;
1894         u32 device_info;
1895 
1896         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1897             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
1898                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1899                         __FILE__, __LINE__, __func__);
1900                 return;
1901         }
1902 
1903         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1904             MPI2_IOCSTATUS_MASK;
1905         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1906                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1907                         __FILE__, __LINE__, __func__);
1908                 return;
1909         }
1910 
1911         flags = le16_to_cpu(sas_device_pg0.Flags);
1912         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
1913 
1914         sdev_printk(KERN_INFO, sdev,
1915             "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), "
1916             "sw_preserve(%s)\n",
1917             (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n",
1918             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n",
1919             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" :
1920             "n",
1921             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n",
1922             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n",
1923             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n");
1924 }
1925 
1926 /*
1927  * raid transport support -
1928  * Enabled for SLES11 and newer, in older kernels the driver will panic when
1929  * unloading the driver followed by a load - I believe that the subroutine
1930  * raid_class_release() is not cleaning up properly.
1931  */
1932 
1933 /**
1934  * scsih_is_raid - return boolean indicating device is raid volume
1935  * @dev: the device struct object
1936  */
1937 static int
1938 scsih_is_raid(struct device *dev)
1939 {
1940         struct scsi_device *sdev = to_scsi_device(dev);
1941         struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1942 
1943         if (ioc->is_warpdrive)
1944                 return 0;
1945         return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
1946 }
1947 
1948 static int
1949 scsih_is_nvme(struct device *dev)
1950 {
1951         struct scsi_device *sdev = to_scsi_device(dev);
1952 
1953         return (sdev->channel == PCIE_CHANNEL) ? 1 : 0;
1954 }
1955 
1956 /**
1957  * scsih_get_resync - get raid volume resync percent complete
1958  * @dev: the device struct object
1959  */
1960 static void
1961 scsih_get_resync(struct device *dev)
1962 {
1963         struct scsi_device *sdev = to_scsi_device(dev);
1964         struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1965         static struct _raid_device *raid_device;
1966         unsigned long flags;
1967         Mpi2RaidVolPage0_t vol_pg0;
1968         Mpi2ConfigReply_t mpi_reply;
1969         u32 volume_status_flags;
1970         u8 percent_complete;
1971         u16 handle;
1972 
1973         percent_complete = 0;
1974         handle = 0;
1975         if (ioc->is_warpdrive)
1976                 goto out;
1977 
1978         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1979         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1980             sdev->channel);
1981         if (raid_device) {
1982                 handle = raid_device->handle;
1983                 percent_complete = raid_device->percent_complete;
1984         }
1985         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1986 
1987         if (!handle)
1988                 goto out;
1989 
1990         if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1991              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1992              sizeof(Mpi2RaidVolPage0_t))) {
1993                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1994                         __FILE__, __LINE__, __func__);
1995                 percent_complete = 0;
1996                 goto out;
1997         }
1998 
1999         volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
2000         if (!(volume_status_flags &
2001             MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
2002                 percent_complete = 0;
2003 
2004  out:
2005 
2006         switch (ioc->hba_mpi_version_belonged) {
2007         case MPI2_VERSION:
2008                 raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
2009                 break;
2010         case MPI25_VERSION:
2011         case MPI26_VERSION:
2012                 raid_set_resync(mpt3sas_raid_template, dev, percent_complete);
2013                 break;
2014         }
2015 }
2016 
2017 /**
2018  * scsih_get_state - get raid volume level
2019  * @dev: the device struct object
2020  */
2021 static void
2022 scsih_get_state(struct device *dev)
2023 {
2024         struct scsi_device *sdev = to_scsi_device(dev);
2025         struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
2026         static struct _raid_device *raid_device;
2027         unsigned long flags;
2028         Mpi2RaidVolPage0_t vol_pg0;
2029         Mpi2ConfigReply_t mpi_reply;
2030         u32 volstate;
2031         enum raid_state state = RAID_STATE_UNKNOWN;
2032         u16 handle = 0;
2033 
2034         spin_lock_irqsave(&ioc->raid_device_lock, flags);
2035         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
2036             sdev->channel);
2037         if (raid_device)
2038                 handle = raid_device->handle;
2039         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2040 
2041         if (!raid_device)
2042                 goto out;
2043 
2044         if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
2045              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
2046              sizeof(Mpi2RaidVolPage0_t))) {
2047                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
2048                         __FILE__, __LINE__, __func__);
2049                 goto out;
2050         }
2051 
2052         volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
2053         if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
2054                 state = RAID_STATE_RESYNCING;
2055                 goto out;
2056         }
2057 
2058         switch (vol_pg0.VolumeState) {
2059         case MPI2_RAID_VOL_STATE_OPTIMAL:
2060         case MPI2_RAID_VOL_STATE_ONLINE:
2061                 state = RAID_STATE_ACTIVE;
2062                 break;
2063         case  MPI2_RAID_VOL_STATE_DEGRADED:
2064                 state = RAID_STATE_DEGRADED;
2065                 break;
2066         case MPI2_RAID_VOL_STATE_FAILED:
2067         case MPI2_RAID_VOL_STATE_MISSING:
2068                 state = RAID_STATE_OFFLINE;
2069                 break;
2070         }
2071  out:
2072         switch (ioc->hba_mpi_version_belonged) {
2073         case MPI2_VERSION:
2074                 raid_set_state(mpt2sas_raid_template, dev, state);
2075                 break;
2076         case MPI25_VERSION:
2077         case MPI26_VERSION:
2078                 raid_set_state(mpt3sas_raid_template, dev, state);
2079                 break;
2080         }
2081 }
2082 
2083 /**
2084  * _scsih_set_level - set raid level
2085  * @ioc: ?
2086  * @sdev: scsi device struct
2087  * @volume_type: volume type
2088  */
2089 static void
2090 _scsih_set_level(struct MPT3SAS_ADAPTER *ioc,
2091         struct scsi_device *sdev, u8 volume_type)
2092 {
2093         enum raid_level level = RAID_LEVEL_UNKNOWN;
2094 
2095         switch (volume_type) {
2096         case MPI2_RAID_VOL_TYPE_RAID0:
2097                 level = RAID_LEVEL_0;
2098                 break;
2099         case MPI2_RAID_VOL_TYPE_RAID10:
2100                 level = RAID_LEVEL_10;
2101                 break;
2102         case MPI2_RAID_VOL_TYPE_RAID1E:
2103                 level = RAID_LEVEL_1E;
2104                 break;
2105         case MPI2_RAID_VOL_TYPE_RAID1:
2106                 level = RAID_LEVEL_1;
2107                 break;
2108         }
2109 
2110         switch (ioc->hba_mpi_version_belonged) {
2111         case MPI2_VERSION:
2112                 raid_set_level(mpt2sas_raid_template,
2113                         &sdev->sdev_gendev, level);
2114                 break;
2115         case MPI25_VERSION:
2116         case MPI26_VERSION:
2117                 raid_set_level(mpt3sas_raid_template,
2118                         &sdev->sdev_gendev, level);
2119                 break;
2120         }
2121 }
2122 
2123 
2124 /**
2125  * _scsih_get_volume_capabilities - volume capabilities
2126  * @ioc: per adapter object
2127  * @raid_device: the raid_device object
2128  *
2129  * Return: 0 for success, else 1
2130  */
2131 static int
2132 _scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc,
2133         struct _raid_device *raid_device)
2134 {
2135         Mpi2RaidVolPage0_t *vol_pg0;
2136         Mpi2RaidPhysDiskPage0_t pd_pg0;
2137         Mpi2SasDevicePage0_t sas_device_pg0;
2138         Mpi2ConfigReply_t mpi_reply;
2139         u16 sz;
2140         u8 num_pds;
2141 
2142         if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
2143             &num_pds)) || !num_pds) {
2144                 dfailprintk(ioc,
2145                             ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2146                                      __FILE__, __LINE__, __func__));
2147                 return 1;
2148         }
2149 
2150         raid_device->num_pds = num_pds;
2151         sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
2152             sizeof(Mpi2RaidVol0PhysDisk_t));
2153         vol_pg0 = kzalloc(sz, GFP_KERNEL);
2154         if (!vol_pg0) {
2155                 dfailprintk(ioc,
2156                             ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2157                                      __FILE__, __LINE__, __func__));
2158                 return 1;
2159         }
2160 
2161         if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
2162              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
2163                 dfailprintk(ioc,
2164                             ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2165                                      __FILE__, __LINE__, __func__));
2166                 kfree(vol_pg0);
2167                 return 1;
2168         }
2169 
2170         raid_device->volume_type = vol_pg0->VolumeType;
2171 
2172         /* figure out what the underlying devices are by
2173          * obtaining the device_info bits for the 1st device
2174          */
2175         if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
2176             &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
2177             vol_pg0->PhysDisk[0].PhysDiskNum))) {
2178                 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
2179                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
2180                     le16_to_cpu(pd_pg0.DevHandle)))) {
2181                         raid_device->device_info =
2182                             le32_to_cpu(sas_device_pg0.DeviceInfo);
2183                 }
2184         }
2185 
2186         kfree(vol_pg0);
2187         return 0;
2188 }
2189 
2190 /**
2191  * _scsih_enable_tlr - setting TLR flags
2192  * @ioc: per adapter object
2193  * @sdev: scsi device struct
2194  *
2195  * Enabling Transaction Layer Retries for tape devices when
2196  * vpd page 0x90 is present
2197  *
2198  */
2199 static void
2200 _scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev)
2201 {
2202 
2203         /* only for TAPE */
2204         if (sdev->type != TYPE_TAPE)
2205                 return;
2206 
2207         if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
2208                 return;
2209 
2210         sas_enable_tlr(sdev);
2211         sdev_printk(KERN_INFO, sdev, "TLR %s\n",
2212             sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
2213         return;
2214 
2215 }
2216 
2217 /**
2218  * scsih_slave_configure - device configure routine.
2219  * @sdev: scsi device struct
2220  *
2221  * Return: 0 if ok. Any other return is assumed to be an error and
2222  * the device is ignored.
2223  */
2224 static int
2225 scsih_slave_configure(struct scsi_device *sdev)
2226 {
2227         struct Scsi_Host *shost = sdev->host;
2228         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2229         struct MPT3SAS_DEVICE *sas_device_priv_data;
2230         struct MPT3SAS_TARGET *sas_target_priv_data;
2231         struct _sas_device *sas_device;
2232         struct _pcie_device *pcie_device;
2233         struct _raid_device *raid_device;
2234         unsigned long flags;
2235         int qdepth;
2236         u8 ssp_target = 0;
2237         char *ds = "";
2238         char *r_level = "";
2239         u16 handle, volume_handle = 0;
2240         u64 volume_wwid = 0;
2241 
2242         qdepth = 1;
2243         sas_device_priv_data = sdev->hostdata;
2244         sas_device_priv_data->configured_lun = 1;
2245         sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
2246         sas_target_priv_data = sas_device_priv_data->sas_target;
2247         handle = sas_target_priv_data->handle;
2248 
2249         /* raid volume handling */
2250         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
2251 
2252                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
2253                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
2254                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
2255                 if (!raid_device) {
2256                         dfailprintk(ioc,
2257                                     ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2258                                              __FILE__, __LINE__, __func__));
2259                         return 1;
2260                 }
2261 
2262                 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
2263                         dfailprintk(ioc,
2264                                     ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2265                                              __FILE__, __LINE__, __func__));
2266                         return 1;
2267                 }
2268 
2269                 /*
2270                  * WARPDRIVE: Initialize the required data for Direct IO
2271                  */
2272                 mpt3sas_init_warpdrive_properties(ioc, raid_device);
2273 
2274                 /* RAID Queue Depth Support
2275                  * IS volume = underlying qdepth of drive type, either
2276                  *    MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH
2277                  * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH)
2278                  */
2279                 if (raid_device->device_info &
2280                     MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
2281                         qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
2282                         ds = "SSP";
2283                 } else {
2284                         qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
2285                         if (raid_device->device_info &
2286                             MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
2287                                 ds = "SATA";
2288                         else
2289                                 ds = "STP";
2290                 }
2291 
2292                 switch (raid_device->volume_type) {
2293                 case MPI2_RAID_VOL_TYPE_RAID0:
2294                         r_level = "RAID0";
2295                         break;
2296                 case MPI2_RAID_VOL_TYPE_RAID1E:
2297                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2298                         if (ioc->manu_pg10.OEMIdentifier &&
2299                             (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
2300                             MFG10_GF0_R10_DISPLAY) &&
2301                             !(raid_device->num_pds % 2))
2302                                 r_level = "RAID10";
2303                         else
2304                                 r_level = "RAID1E";
2305                         break;
2306                 case MPI2_RAID_VOL_TYPE_RAID1:
2307                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2308                         r_level = "RAID1";
2309                         break;
2310                 case MPI2_RAID_VOL_TYPE_RAID10:
2311                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2312                         r_level = "RAID10";
2313                         break;
2314                 case MPI2_RAID_VOL_TYPE_UNKNOWN:
2315                 default:
2316                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
2317                         r_level = "RAIDX";
2318                         break;
2319                 }
2320 
2321                 if (!ioc->hide_ir_msg)
2322                         sdev_printk(KERN_INFO, sdev,
2323                            "%s: handle(0x%04x), wwid(0x%016llx),"
2324                             " pd_count(%d), type(%s)\n",
2325                             r_level, raid_device->handle,
2326                             (unsigned long long)raid_device->wwid,
2327                             raid_device->num_pds, ds);
2328 
2329                 if (shost->max_sectors > MPT3SAS_RAID_MAX_SECTORS) {
2330                         blk_queue_max_hw_sectors(sdev->request_queue,
2331                                                 MPT3SAS_RAID_MAX_SECTORS);
2332                         sdev_printk(KERN_INFO, sdev,
2333                                         "Set queue's max_sector to: %u\n",
2334                                                 MPT3SAS_RAID_MAX_SECTORS);
2335                 }
2336 
2337                 mpt3sas_scsih_change_queue_depth(sdev, qdepth);
2338 
2339                 /* raid transport support */
2340                 if (!ioc->is_warpdrive)
2341                         _scsih_set_level(ioc, sdev, raid_device->volume_type);
2342                 return 0;
2343         }
2344 
2345         /* non-raid handling */
2346         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
2347                 if (mpt3sas_config_get_volume_handle(ioc, handle,
2348                     &volume_handle)) {
2349                         dfailprintk(ioc,
2350                                     ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2351                                              __FILE__, __LINE__, __func__));
2352                         return 1;
2353                 }
2354                 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
2355                     volume_handle, &volume_wwid)) {
2356                         dfailprintk(ioc,
2357                                     ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2358                                              __FILE__, __LINE__, __func__));
2359                         return 1;
2360                 }
2361         }
2362 
2363         /* PCIe handling */
2364         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
2365                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2366                 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc,
2367                                 sas_device_priv_data->sas_target->sas_address);
2368                 if (!pcie_device) {
2369                         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2370                         dfailprintk(ioc,
2371                                     ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2372                                              __FILE__, __LINE__, __func__));
2373                         return 1;
2374                 }
2375 
2376                 qdepth = MPT3SAS_NVME_QUEUE_DEPTH;
2377                 ds = "NVMe";
2378                 sdev_printk(KERN_INFO, sdev,
2379                         "%s: handle(0x%04x), wwid(0x%016llx), port(%d)\n",
2380                         ds, handle, (unsigned long long)pcie_device->wwid,
2381                         pcie_device->port_num);
2382                 if (pcie_device->enclosure_handle != 0)
2383                         sdev_printk(KERN_INFO, sdev,
2384                         "%s: enclosure logical id(0x%016llx), slot(%d)\n",
2385                         ds,
2386                         (unsigned long long)pcie_device->enclosure_logical_id,
2387                         pcie_device->slot);
2388                 if (pcie_device->connector_name[0] != '\0')
2389                         sdev_printk(KERN_INFO, sdev,
2390                                 "%s: enclosure level(0x%04x),"
2391                                 "connector name( %s)\n", ds,
2392                                 pcie_device->enclosure_level,
2393                                 pcie_device->connector_name);
2394 
2395                 if (pcie_device->nvme_mdts)
2396                         blk_queue_max_hw_sectors(sdev->request_queue,
2397                                         pcie_device->nvme_mdts/512);
2398 
2399                 pcie_device_put(pcie_device);
2400                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2401                 mpt3sas_scsih_change_queue_depth(sdev, qdepth);
2402                 /* Enable QUEUE_FLAG_NOMERGES flag, so that IOs won't be
2403                  ** merged and can eliminate holes created during merging
2404                  ** operation.
2405                  **/
2406                 blk_queue_flag_set(QUEUE_FLAG_NOMERGES,
2407                                 sdev->request_queue);
2408                 blk_queue_virt_boundary(sdev->request_queue,
2409                                 ioc->page_size - 1);
2410                 return 0;
2411         }
2412 
2413         spin_lock_irqsave(&ioc->sas_device_lock, flags);
2414         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
2415            sas_device_priv_data->sas_target->sas_address);
2416         if (!sas_device) {
2417                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2418                 dfailprintk(ioc,
2419                             ioc_warn(ioc, "failure at %s:%d/%s()!\n",
2420                                      __FILE__, __LINE__, __func__));
2421                 return 1;
2422         }
2423 
2424         sas_device->volume_handle = volume_handle;
2425         sas_device->volume_wwid = volume_wwid;
2426         if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
2427                 qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
2428                 ssp_target = 1;
2429                 if (sas_device->device_info &
2430                                 MPI2_SAS_DEVICE_INFO_SEP) {
2431                         sdev_printk(KERN_WARNING, sdev,
2432                         "set ignore_delay_remove for handle(0x%04x)\n",
2433                         sas_device_priv_data->sas_target->handle);
2434                         sas_device_priv_data->ignore_delay_remove = 1;
2435                         ds = "SES";
2436                 } else
2437                         ds = "SSP";
2438         } else {
2439                 qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
2440                 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
2441                         ds = "STP";
2442                 else if (sas_device->device_info &
2443                     MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
2444                         ds = "SATA";
2445         }
2446 
2447         sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \
2448             "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
2449             ds, handle, (unsigned long long)sas_device->sas_address,
2450             sas_device->phy, (unsigned long long)sas_device->device_name);
2451 
2452         _scsih_display_enclosure_chassis_info(NULL, sas_device, sdev, NULL);
2453 
2454         sas_device_put(sas_device);
2455         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2456 
2457         if (!ssp_target)
2458                 _scsih_display_sata_capabilities(ioc, handle, sdev);
2459 
2460 
2461         mpt3sas_scsih_change_queue_depth(sdev, qdepth);
2462 
2463         if (ssp_target) {
2464                 sas_read_port_mode_page(sdev);
2465                 _scsih_enable_tlr(ioc, sdev);
2466         }
2467 
2468         return 0;
2469 }
2470 
2471 /**
2472  * scsih_bios_param - fetch head, sector, cylinder info for a disk
2473  * @sdev: scsi device struct
2474  * @bdev: pointer to block device context
2475  * @capacity: device size (in 512 byte sectors)
2476  * @params: three element array to place output:
2477  *              params[0] number of heads (max 255)
2478  *              params[1] number of sectors (max 63)
2479  *              params[2] number of cylinders
2480  */
2481 static int
2482 scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2483         sector_t capacity, int params[])
2484 {
2485         int             heads;
2486         int             sectors;
2487         sector_t        cylinders;
2488         ulong           dummy;
2489 
2490         heads = 64;
2491         sectors = 32;
2492 
2493         dummy = heads * sectors;
2494         cylinders = capacity;
2495         sector_div(cylinders, dummy);
2496 
2497         /*
2498          * Handle extended translation size for logical drives
2499          * > 1Gb
2500          */
2501         if ((ulong)capacity >= 0x200000) {
2502                 heads = 255;
2503                 sectors = 63;
2504                 dummy = heads * sectors;
2505                 cylinders = capacity;
2506                 sector_div(cylinders, dummy);
2507         }
2508 
2509         /* return result */
2510         params[0] = heads;
2511         params[1] = sectors;
2512         params[2] = cylinders;
2513 
2514         return 0;
2515 }
2516 
2517 /**
2518  * _scsih_response_code - translation of device response code
2519  * @ioc: per adapter object
2520  * @response_code: response code returned by the device
2521  */
2522 static void
2523 _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
2524 {
2525         char *desc;
2526 
2527         switch (response_code) {
2528         case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
2529                 desc = "task management request completed";
2530                 break;
2531         case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
2532                 desc = "invalid frame";
2533                 break;
2534         case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2535                 desc = "task management request not supported";
2536                 break;
2537         case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
2538                 desc = "task management request failed";
2539                 break;
2540         case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2541                 desc = "task management request succeeded";
2542                 break;
2543         case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2544                 desc = "invalid lun";
2545                 break;
2546         case 0xA:
2547                 desc = "overlapped tag attempted";
2548                 break;
2549         case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2550                 desc = "task queued, however not sent to target";
2551                 break;
2552         default:
2553                 desc = "unknown";
2554                 break;
2555         }
2556         ioc_warn(ioc, "response_code(0x%01x): %s\n", response_code, desc);
2557 }
2558 
2559 /**
2560  * _scsih_tm_done - tm completion routine
2561  * @ioc: per adapter object
2562  * @smid: system request message index
2563  * @msix_index: MSIX table index supplied by the OS
2564  * @reply: reply message frame(lower 32bit addr)
2565  * Context: none.
2566  *
2567  * The callback handler when using scsih_issue_tm.
2568  *
2569  * Return: 1 meaning mf should be freed from _base_interrupt
2570  *         0 means the mf is freed from this function.
2571  */
2572 static u8
2573 _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2574 {
2575         MPI2DefaultReply_t *mpi_reply;
2576 
2577         if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
2578                 return 1;
2579         if (ioc->tm_cmds.smid != smid)
2580                 return 1;
2581         ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
2582         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
2583         if (mpi_reply) {
2584                 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2585                 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
2586         }
2587         ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
2588         complete(&ioc->tm_cmds.done);
2589         return 1;
2590 }
2591 
2592 /**
2593  * mpt3sas_scsih_set_tm_flag - set per target tm_busy
2594  * @ioc: per adapter object
2595  * @handle: device handle
2596  *
2597  * During taskmangement request, we need to freeze the device queue.
2598  */
2599 void
2600 mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2601 {
2602         struct MPT3SAS_DEVICE *sas_device_priv_data;
2603         struct scsi_device *sdev;
2604         u8 skip = 0;
2605 
2606         shost_for_each_device(sdev, ioc->shost) {
2607                 if (skip)
2608                         continue;
2609                 sas_device_priv_data = sdev->hostdata;
2610                 if (!sas_device_priv_data)
2611                         continue;
2612                 if (sas_device_priv_data->sas_target->handle == handle) {
2613                         sas_device_priv_data->sas_target->tm_busy = 1;
2614                         skip = 1;
2615                         ioc->ignore_loginfos = 1;
2616                 }
2617         }
2618 }
2619 
2620 /**
2621  * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy
2622  * @ioc: per adapter object
2623  * @handle: device handle
2624  *
2625  * During taskmangement request, we need to freeze the device queue.
2626  */
2627 void
2628 mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2629 {
2630         struct MPT3SAS_DEVICE *sas_device_priv_data;
2631         struct scsi_device *sdev;
2632         u8 skip = 0;
2633 
2634         shost_for_each_device(sdev, ioc->shost) {
2635                 if (skip)
2636                         continue;
2637                 sas_device_priv_data = sdev->hostdata;
2638                 if (!sas_device_priv_data)
2639                         continue;
2640                 if (sas_device_priv_data->sas_target->handle == handle) {
2641                         sas_device_priv_data->sas_target->tm_busy = 0;
2642                         skip = 1;
2643                         ioc->ignore_loginfos = 0;
2644                 }
2645         }
2646 }
2647 
2648 /**
2649  * mpt3sas_scsih_issue_tm - main routine for sending tm requests
2650  * @ioc: per adapter struct
2651  * @handle: device handle
2652  * @lun: lun number
2653  * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h)
2654  * @smid_task: smid assigned to the task
2655  * @msix_task: MSIX table index supplied by the OS
2656  * @timeout: timeout in seconds
2657  * @tr_method: Target Reset Method
2658  * Context: user
2659  *
2660  * A generic API for sending task management requests to firmware.
2661  *
2662  * The callback index is set inside `ioc->tm_cb_idx`.
2663  * The caller is responsible to check for outstanding commands.
2664  *
2665  * Return: SUCCESS or FAILED.
2666  */
2667 int
2668 mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, u64 lun,
2669         u8 type, u16 smid_task, u16 msix_task, u8 timeout, u8 tr_method)
2670 {
2671         Mpi2SCSITaskManagementRequest_t *mpi_request;
2672         Mpi2SCSITaskManagementReply_t *mpi_reply;
2673         u16 smid = 0;
2674         u32 ioc_state;
2675         int rc;
2676 
2677         lockdep_assert_held(&ioc->tm_cmds.mutex);
2678 
2679         if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
2680                 ioc_info(ioc, "%s: tm_cmd busy!!!\n", __func__);
2681                 return FAILED;
2682         }
2683 
2684         if (ioc->shost_recovery || ioc->remove_host ||
2685             ioc->pci_error_recovery) {
2686                 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
2687                 return FAILED;
2688         }
2689 
2690         ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
2691         if (ioc_state & MPI2_DOORBELL_USED) {
2692                 dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
2693                 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
2694                 return (!rc) ? SUCCESS : FAILED;
2695         }
2696 
2697         if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
2698                 mpt3sas_base_fault_info(ioc, ioc_state &
2699                     MPI2_DOORBELL_DATA_MASK);
2700                 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
2701                 return (!rc) ? SUCCESS : FAILED;
2702         }
2703 
2704         smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2705         if (!smid) {
2706                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
2707                 return FAILED;
2708         }
2709 
2710         dtmprintk(ioc,
2711                   ioc_info(ioc, "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n",
2712                            handle, type, smid_task, timeout, tr_method));
2713         ioc->tm_cmds.status = MPT3_CMD_PENDING;
2714         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2715         ioc->tm_cmds.smid = smid;
2716         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2717         memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2718         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2719         mpi_request->DevHandle = cpu_to_le16(handle);
2720         mpi_request->TaskType = type;
2721         mpi_request->MsgFlags = tr_method;
2722         mpi_request->TaskMID = cpu_to_le16(smid_task);
2723         int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
2724         mpt3sas_scsih_set_tm_flag(ioc, handle);
2725         init_completion(&ioc->tm_cmds.done);
2726         ioc->put_smid_hi_priority(ioc, smid, msix_task);
2727         wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2728         if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
2729                 if (mpt3sas_base_check_cmd_timeout(ioc,
2730                         ioc->tm_cmds.status, mpi_request,
2731                         sizeof(Mpi2SCSITaskManagementRequest_t)/4)) {
2732                         rc = mpt3sas_base_hard_reset_handler(ioc,
2733                                         FORCE_BIG_HAMMER);
2734                         rc = (!rc) ? SUCCESS : FAILED;
2735                         goto out;
2736                 }
2737         }
2738 
2739         /* sync IRQs in case those were busy during flush. */
2740         mpt3sas_base_sync_reply_irqs(ioc);
2741 
2742         if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
2743                 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
2744                 mpi_reply = ioc->tm_cmds.reply;
2745                 dtmprintk(ioc,
2746                           ioc_info(ioc, "complete tm: ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
2747                                    le16_to_cpu(mpi_reply->IOCStatus),
2748                                    le32_to_cpu(mpi_reply->IOCLogInfo),
2749                                    le32_to_cpu(mpi_reply->TerminationCount)));
2750                 if (ioc->logging_level & MPT_DEBUG_TM) {
2751                         _scsih_response_code(ioc, mpi_reply->ResponseCode);
2752                         if (mpi_reply->IOCStatus)
2753                                 _debug_dump_mf(mpi_request,
2754                                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2755                 }
2756         }
2757         rc = SUCCESS;
2758 
2759 out:
2760         mpt3sas_scsih_clear_tm_flag(ioc, handle);
2761         ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
2762         return rc;
2763 }
2764 
2765 int mpt3sas_scsih_issue_locked_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle,
2766                 u64 lun, u8 type, u16 smid_task, u16 msix_task,
2767                 u8 timeout, u8 tr_method)
2768 {
2769         int ret;
2770 
2771         mutex_lock(&ioc->tm_cmds.mutex);
2772         ret = mpt3sas_scsih_issue_tm(ioc, handle, lun, type, smid_task,
2773                         msix_task, timeout, tr_method);
2774         mutex_unlock(&ioc->tm_cmds.mutex);
2775 
2776         return ret;
2777 }
2778 
2779 /**
2780  * _scsih_tm_display_info - displays info about the device
2781  * @ioc: per adapter struct
2782  * @scmd: pointer to scsi command object
2783  *
2784  * Called by task management callback handlers.
2785  */
2786 static void
2787 _scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2788 {
2789         struct scsi_target *starget = scmd->device->sdev_target;
2790         struct MPT3SAS_TARGET *priv_target = starget->hostdata;
2791         struct _sas_device *sas_device = NULL;
2792         struct _pcie_device *pcie_device = NULL;
2793         unsigned long flags;
2794         char *device_str = NULL;
2795 
2796         if (!priv_target)
2797                 return;
2798         if (ioc->hide_ir_msg)
2799                 device_str = "WarpDrive";
2800         else
2801                 device_str = "volume";
2802 
2803         scsi_print_command(scmd);
2804         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2805                 starget_printk(KERN_INFO, starget,
2806                         "%s handle(0x%04x), %s wwid(0x%016llx)\n",
2807                         device_str, priv_target->handle,
2808                     device_str, (unsigned long long)priv_target->sas_address);
2809 
2810         } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
2811                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
2812                 pcie_device = __mpt3sas_get_pdev_from_target(ioc, priv_target);
2813                 if (pcie_device) {
2814                         starget_printk(KERN_INFO, starget,
2815                                 "handle(0x%04x), wwid(0x%016llx), port(%d)\n",
2816                                 pcie_device->handle,
2817                                 (unsigned long long)pcie_device->wwid,
2818                                 pcie_device->port_num);
2819                         if (pcie_device->enclosure_handle != 0)
2820                                 starget_printk(KERN_INFO, starget,
2821                                         "enclosure logical id(0x%016llx), slot(%d)\n",
2822                                         (unsigned long long)
2823                                         pcie_device->enclosure_logical_id,
2824                                         pcie_device->slot);
2825                         if (pcie_device->connector_name[0] != '\0')
2826                                 starget_printk(KERN_INFO, starget,
2827                                         "enclosure level(0x%04x), connector name( %s)\n",
2828                                         pcie_device->enclosure_level,
2829                                         pcie_device->connector_name);
2830                         pcie_device_put(pcie_device);
2831                 }
2832                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
2833 
2834         } else {
2835                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2836                 sas_device = __mpt3sas_get_sdev_from_target(ioc, priv_target);
2837                 if (sas_device) {
2838                         if (priv_target->flags &
2839                             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2840                                 starget_printk(KERN_INFO, starget,
2841                                     "volume handle(0x%04x), "
2842                                     "volume wwid(0x%016llx)\n",
2843                                     sas_device->volume_handle,
2844                                    (unsigned long long)sas_device->volume_wwid);
2845                         }
2846                         starget_printk(KERN_INFO, starget,
2847                             "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
2848                             sas_device->handle,
2849                             (unsigned long long)sas_device->sas_address,
2850                             sas_device->phy);
2851 
2852                         _scsih_display_enclosure_chassis_info(NULL, sas_device,
2853                             NULL, starget);
2854 
2855                         sas_device_put(sas_device);
2856                 }
2857                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2858         }
2859 }
2860 
2861 /**
2862  * scsih_abort - eh threads main abort routine
2863  * @scmd: pointer to scsi command object
2864  *
2865  * Return: SUCCESS if command aborted else FAILED
2866  */
2867 static int
2868 scsih_abort(struct scsi_cmnd *scmd)
2869 {
2870         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2871         struct MPT3SAS_DEVICE *sas_device_priv_data;
2872         struct scsiio_tracker *st = scsi_cmd_priv(scmd);
2873         u16 handle;
2874         int r;
2875 
2876         u8 timeout = 30;
2877         struct _pcie_device *pcie_device = NULL;
2878         sdev_printk(KERN_INFO, scmd->device,
2879                 "attempting task abort! scmd(%p)\n", scmd);
2880         _scsih_tm_display_info(ioc, scmd);
2881 
2882         sas_device_priv_data = scmd->device->hostdata;
2883         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
2884             ioc->remove_host) {
2885                 sdev_printk(KERN_INFO, scmd->device,
2886                         "device been deleted! scmd(%p)\n", scmd);
2887                 scmd->result = DID_NO_CONNECT << 16;
2888                 scmd->scsi_done(scmd);
2889                 r = SUCCESS;
2890                 goto out;
2891         }
2892 
2893         /* check for completed command */
2894         if (st == NULL || st->cb_idx == 0xFF) {
2895                 scmd->result = DID_RESET << 16;
2896                 r = SUCCESS;
2897                 goto out;
2898         }
2899 
2900         /* for hidden raid components and volumes this is not supported */
2901         if (sas_device_priv_data->sas_target->flags &
2902             MPT_TARGET_FLAGS_RAID_COMPONENT ||
2903             sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2904                 scmd->result = DID_RESET << 16;
2905                 r = FAILED;
2906                 goto out;
2907         }
2908 
2909         mpt3sas_halt_firmware(ioc);
2910 
2911         handle = sas_device_priv_data->sas_target->handle;
2912         pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
2913         if (pcie_device && (!ioc->tm_custom_handling) &&
2914             (!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info))))
2915                 timeout = ioc->nvme_abort_timeout;
2916         r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->lun,
2917                 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
2918                 st->smid, st->msix_io, timeout, 0);
2919         /* Command must be cleared after abort */
2920         if (r == SUCCESS && st->cb_idx != 0xFF)
2921                 r = FAILED;
2922  out:
2923         sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
2924             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2925         if (pcie_device)
2926                 pcie_device_put(pcie_device);
2927         return r;
2928 }
2929 
2930 /**
2931  * scsih_dev_reset - eh threads main device reset routine
2932  * @scmd: pointer to scsi command object
2933  *
2934  * Return: SUCCESS if command aborted else FAILED
2935  */
2936 static int
2937 scsih_dev_reset(struct scsi_cmnd *scmd)
2938 {
2939         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2940         struct MPT3SAS_DEVICE *sas_device_priv_data;
2941         struct _sas_device *sas_device = NULL;
2942         struct _pcie_device *pcie_device = NULL;
2943         u16     handle;
2944         u8      tr_method = 0;
2945         u8      tr_timeout = 30;
2946         int r;
2947 
2948         struct scsi_target *starget = scmd->device->sdev_target;
2949         struct MPT3SAS_TARGET *target_priv_data = starget->hostdata;
2950 
2951         sdev_printk(KERN_INFO, scmd->device,
2952                 "attempting device reset! scmd(%p)\n", scmd);
2953         _scsih_tm_display_info(ioc, scmd);
2954 
2955         sas_device_priv_data = scmd->device->hostdata;
2956         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
2957             ioc->remove_host) {
2958                 sdev_printk(KERN_INFO, scmd->device,
2959                         "device been deleted! scmd(%p)\n", scmd);
2960                 scmd->result = DID_NO_CONNECT << 16;
2961                 scmd->scsi_done(scmd);
2962                 r = SUCCESS;
2963                 goto out;
2964         }
2965 
2966         /* for hidden raid components obtain the volume_handle */
2967         handle = 0;
2968         if (sas_device_priv_data->sas_target->flags &
2969             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2970                 sas_device = mpt3sas_get_sdev_from_target(ioc,
2971                                 target_priv_data);
2972                 if (sas_device)
2973                         handle = sas_device->volume_handle;
2974         } else
2975                 handle = sas_device_priv_data->sas_target->handle;
2976 
2977         if (!handle) {
2978                 scmd->result = DID_RESET << 16;
2979                 r = FAILED;
2980                 goto out;
2981         }
2982 
2983         pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
2984 
2985         if (pcie_device && (!ioc->tm_custom_handling) &&
2986             (!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) {
2987                 tr_timeout = pcie_device->reset_timeout;
2988                 tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
2989         } else
2990                 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
2991 
2992         r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->lun,
2993                 MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 0,
2994                 tr_timeout, tr_method);
2995         /* Check for busy commands after reset */
2996         if (r == SUCCESS && atomic_read(&scmd->device->device_busy))
2997                 r = FAILED;
2998  out:
2999         sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
3000             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
3001 
3002         if (sas_device)
3003                 sas_device_put(sas_device);
3004         if (pcie_device)
3005                 pcie_device_put(pcie_device);
3006 
3007         return r;
3008 }
3009 
3010 /**
3011  * scsih_target_reset - eh threads main target reset routine
3012  * @scmd: pointer to scsi command object
3013  *
3014  * Return: SUCCESS if command aborted else FAILED
3015  */
3016 static int
3017 scsih_target_reset(struct scsi_cmnd *scmd)
3018 {
3019         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3020         struct MPT3SAS_DEVICE *sas_device_priv_data;
3021         struct _sas_device *sas_device = NULL;
3022         struct _pcie_device *pcie_device = NULL;
3023         u16     handle;
3024         u8      tr_method = 0;
3025         u8      tr_timeout = 30;
3026         int r;
3027         struct scsi_target *starget = scmd->device->sdev_target;
3028         struct MPT3SAS_TARGET *target_priv_data = starget->hostdata;
3029 
3030         starget_printk(KERN_INFO, starget, "attempting target reset! scmd(%p)\n",
3031                 scmd);
3032         _scsih_tm_display_info(ioc, scmd);
3033 
3034         sas_device_priv_data = scmd->device->hostdata;
3035         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
3036             ioc->remove_host) {
3037                 starget_printk(KERN_INFO, starget, "target been deleted! scmd(%p)\n",
3038                         scmd);
3039                 scmd->result = DID_NO_CONNECT << 16;
3040                 scmd->scsi_done(scmd);
3041                 r = SUCCESS;
3042                 goto out;
3043         }
3044 
3045         /* for hidden raid components obtain the volume_handle */
3046         handle = 0;
3047         if (sas_device_priv_data->sas_target->flags &
3048             MPT_TARGET_FLAGS_RAID_COMPONENT) {
3049                 sas_device = mpt3sas_get_sdev_from_target(ioc,
3050                                 target_priv_data);
3051                 if (sas_device)
3052                         handle = sas_device->volume_handle;
3053         } else
3054                 handle = sas_device_priv_data->sas_target->handle;
3055 
3056         if (!handle) {
3057                 scmd->result = DID_RESET << 16;
3058                 r = FAILED;
3059                 goto out;
3060         }
3061 
3062         pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle);
3063 
3064         if (pcie_device && (!ioc->tm_custom_handling) &&
3065             (!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) {
3066                 tr_timeout = pcie_device->reset_timeout;
3067                 tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
3068         } else
3069                 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
3070         r = mpt3sas_scsih_issue_locked_tm(ioc, handle, 0,
3071                 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 0,
3072             tr_timeout, tr_method);
3073         /* Check for busy commands after reset */
3074         if (r == SUCCESS && atomic_read(&starget->target_busy))
3075                 r = FAILED;
3076  out:
3077         starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
3078             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
3079 
3080         if (sas_device)
3081                 sas_device_put(sas_device);
3082         if (pcie_device)
3083                 pcie_device_put(pcie_device);
3084         return r;
3085 }
3086 
3087 
3088 /**
3089  * scsih_host_reset - eh threads main host reset routine
3090  * @scmd: pointer to scsi command object
3091  *
3092  * Return: SUCCESS if command aborted else FAILED
3093  */
3094 static int
3095 scsih_host_reset(struct scsi_cmnd *scmd)
3096 {
3097         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
3098         int r, retval;
3099 
3100         ioc_info(ioc, "attempting host reset! scmd(%p)\n", scmd);
3101         scsi_print_command(scmd);
3102 
3103         if (ioc->is_driver_loading || ioc->remove_host) {
3104                 ioc_info(ioc, "Blocking the host reset\n");
3105                 r = FAILED;
3106                 goto out;
3107         }
3108 
3109         retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
3110         r = (retval < 0) ? FAILED : SUCCESS;
3111 out:
3112         ioc_info(ioc, "host reset: %s scmd(%p)\n",
3113                  r == SUCCESS ? "SUCCESS" : "FAILED", scmd);
3114 
3115         return r;
3116 }
3117 
3118 /**
3119  * _scsih_fw_event_add - insert and queue up fw_event
3120  * @ioc: per adapter object
3121  * @fw_event: object describing the event
3122  * Context: This function will acquire ioc->fw_event_lock.
3123  *
3124  * This adds the firmware event object into link list, then queues it up to
3125  * be processed from user context.
3126  */
3127 static void
3128 _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
3129 {
3130         unsigned long flags;
3131 
3132         if (ioc->firmware_event_thread == NULL)
3133                 return;
3134 
3135         spin_lock_irqsave(&ioc->fw_event_lock, flags);
3136         fw_event_work_get(fw_event);
3137         INIT_LIST_HEAD(&fw_event->list);
3138         list_add_tail(&fw_event->list, &ioc->fw_event_list);
3139         INIT_WORK(&fw_event->work, _firmware_event_work);
3140         fw_event_work_get(fw_event);
3141         queue_work(ioc->firmware_event_thread, &fw_event->work);
3142         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3143 }
3144 
3145 /**
3146  * _scsih_fw_event_del_from_list - delete fw_event from the list
3147  * @ioc: per adapter object
3148  * @fw_event: object describing the event
3149  * Context: This function will acquire ioc->fw_event_lock.
3150  *
3151  * If the fw_event is on the fw_event_list, remove it and do a put.
3152  */
3153 static void
3154 _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
3155         *fw_event)
3156 {
3157         unsigned long flags;
3158 
3159         spin_lock_irqsave(&ioc->fw_event_lock, flags);
3160         if (!list_empty(&fw_event->list)) {
3161                 list_del_init(&fw_event->list);
3162                 fw_event_work_put(fw_event);
3163         }
3164         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3165 }
3166 
3167 
3168  /**
3169  * mpt3sas_send_trigger_data_event - send event for processing trigger data
3170  * @ioc: per adapter object
3171  * @event_data: trigger event data
3172  */
3173 void
3174 mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
3175         struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data)
3176 {
3177         struct fw_event_work *fw_event;
3178         u16 sz;
3179 
3180         if (ioc->is_driver_loading)
3181                 return;
3182         sz = sizeof(*event_data);
3183         fw_event = alloc_fw_event_work(sz);
3184         if (!fw_event)
3185                 return;
3186         fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG;
3187         fw_event->ioc = ioc;
3188         memcpy(fw_event->event_data, event_data, sizeof(*event_data));
3189         _scsih_fw_event_add(ioc, fw_event);
3190         fw_event_work_put(fw_event);
3191 }
3192 
3193 /**
3194  * _scsih_error_recovery_delete_devices - remove devices not responding
3195  * @ioc: per adapter object
3196  */
3197 static void
3198 _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
3199 {
3200         struct fw_event_work *fw_event;
3201 
3202         if (ioc->is_driver_loading)
3203                 return;
3204         fw_event = alloc_fw_event_work(0);
3205         if (!fw_event)
3206                 return;
3207         fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES;
3208         fw_event->ioc = ioc;
3209         _scsih_fw_event_add(ioc, fw_event);
3210         fw_event_work_put(fw_event);
3211 }
3212 
3213 /**
3214  * mpt3sas_port_enable_complete - port enable completed (fake event)
3215  * @ioc: per adapter object
3216  */
3217 void
3218 mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
3219 {
3220         struct fw_event_work *fw_event;
3221 
3222         fw_event = alloc_fw_event_work(0);
3223         if (!fw_event)
3224                 return;
3225         fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE;
3226         fw_event->ioc = ioc;
3227         _scsih_fw_event_add(ioc, fw_event);
3228         fw_event_work_put(fw_event);
3229 }
3230 
3231 static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc)
3232 {
3233         unsigned long flags;
3234         struct fw_event_work *fw_event = NULL;
3235 
3236         spin_lock_irqsave(&ioc->fw_event_lock, flags);
3237         if (!list_empty(&ioc->fw_event_list)) {
3238                 fw_event = list_first_entry(&ioc->fw_event_list,
3239                                 struct fw_event_work, list);
3240                 list_del_init(&fw_event->list);
3241         }
3242         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3243 
3244         return fw_event;
3245 }
3246 
3247 /**
3248  * _scsih_fw_event_cleanup_queue - cleanup event queue
3249  * @ioc: per adapter object
3250  *
3251  * Walk the firmware event queue, either killing timers, or waiting
3252  * for outstanding events to complete
3253  */
3254 static void
3255 _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
3256 {
3257         struct fw_event_work *fw_event;
3258 
3259         if (list_empty(&ioc->fw_event_list) ||
3260              !ioc->firmware_event_thread || in_interrupt())
3261                 return;
3262 
3263         while ((fw_event = dequeue_next_fw_event(ioc))) {
3264                 /*
3265                  * Wait on the fw_event to complete. If this returns 1, then
3266                  * the event was never executed, and we need a put for the
3267                  * reference the work had on the fw_event.
3268                  *
3269                  * If it did execute, we wait for it to finish, and the put will
3270                  * happen from _firmware_event_work()
3271                  */
3272                 if (cancel_work_sync(&fw_event->work))
3273                         fw_event_work_put(fw_event);
3274 
3275                 fw_event_work_put(fw_event);
3276         }
3277 }
3278 
3279 /**
3280  * _scsih_internal_device_block - block the sdev device
3281  * @sdev: per device object
3282  * @sas_device_priv_data : per device driver private data
3283  *
3284  * make sure device is blocked without error, if not
3285  * print an error
3286  */
3287 static void
3288 _scsih_internal_device_block(struct scsi_device *sdev,
3289                         struct MPT3SAS_DEVICE *sas_device_priv_data)
3290 {
3291         int r = 0;
3292 
3293         sdev_printk(KERN_INFO, sdev, "device_block, handle(0x%04x)\n",
3294             sas_device_priv_data->sas_target->handle);
3295         sas_device_priv_data->block = 1;
3296 
3297         r = scsi_internal_device_block_nowait(sdev);
3298         if (r == -EINVAL)
3299                 sdev_printk(KERN_WARNING, sdev,
3300                     "device_block failed with return(%d) for handle(0x%04x)\n",
3301                     r, sas_device_priv_data->sas_target->handle);
3302 }
3303 
3304 /**
3305  * _scsih_internal_device_unblock - unblock the sdev device
3306  * @sdev: per device object
3307  * @sas_device_priv_data : per device driver private data
3308  * make sure device is unblocked without error, if not retry
3309  * by blocking and then unblocking
3310  */
3311 
3312 static void
3313 _scsih_internal_device_unblock(struct scsi_device *sdev,
3314                         struct MPT3SAS_DEVICE *sas_device_priv_data)
3315 {
3316         int r = 0;
3317 
3318         sdev_printk(KERN_WARNING, sdev, "device_unblock and setting to running, "
3319             "handle(0x%04x)\n", sas_device_priv_data->sas_target->handle);
3320         sas_device_priv_data->block = 0;
3321         r = scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING);
3322         if (r == -EINVAL) {
3323                 /* The device has been set to SDEV_RUNNING by SD layer during
3324                  * device addition but the request queue is still stopped by
3325                  * our earlier block call. We need to perform a block again
3326                  * to get the device to SDEV_BLOCK and then to SDEV_RUNNING */
3327 
3328                 sdev_printk(KERN_WARNING, sdev,
3329                     "device_unblock failed with return(%d) for handle(0x%04x) "
3330                     "performing a block followed by an unblock\n",
3331                     r, sas_device_priv_data->sas_target->handle);
3332                 sas_device_priv_data->block = 1;
3333                 r = scsi_internal_device_block_nowait(sdev);
3334                 if (r)
3335                         sdev_printk(KERN_WARNING, sdev, "retried device_block "
3336                             "failed with return(%d) for handle(0x%04x)\n",
3337                             r, sas_device_priv_data->sas_target->handle);
3338 
3339                 sas_device_priv_data->block = 0;
3340                 r = scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING);
3341                 if (r)
3342                         sdev_printk(KERN_WARNING, sdev, "retried device_unblock"
3343                             " failed with return(%d) for handle(0x%04x)\n",
3344                             r, sas_device_priv_data->sas_target->handle);
3345         }
3346 }
3347 
3348 /**
3349  * _scsih_ublock_io_all_device - unblock every device
3350  * @ioc: per adapter object
3351  *
3352  * change the device state from block to running
3353  */
3354 static void
3355 _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3356 {
3357         struct MPT3SAS_DEVICE *sas_device_priv_data;
3358         struct scsi_device *sdev;
3359 
3360         shost_for_each_device(sdev, ioc->shost) {
3361                 sas_device_priv_data = sdev->hostdata;
3362                 if (!sas_device_priv_data)
3363                         continue;
3364                 if (!sas_device_priv_data->block)
3365                         continue;
3366 
3367                 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
3368                         "device_running, handle(0x%04x)\n",
3369                     sas_device_priv_data->sas_target->handle));
3370                 _scsih_internal_device_unblock(sdev, sas_device_priv_data);
3371         }
3372 }
3373 
3374 
3375 /**
3376  * _scsih_ublock_io_device - prepare device to be deleted
3377  * @ioc: per adapter object
3378  * @sas_address: sas address
3379  *
3380  * unblock then put device in offline state
3381  */
3382 static void
3383 _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
3384 {
3385         struct MPT3SAS_DEVICE *sas_device_priv_data;
3386         struct scsi_device *sdev;
3387 
3388         shost_for_each_device(sdev, ioc->shost) {
3389                 sas_device_priv_data = sdev->hostdata;
3390                 if (!sas_device_priv_data)
3391                         continue;
3392                 if (sas_device_priv_data->sas_target->sas_address
3393                     != sas_address)
3394                         continue;
3395                 if (sas_device_priv_data->block)
3396                         _scsih_internal_device_unblock(sdev,
3397                                 sas_device_priv_data);
3398         }
3399 }
3400 
3401 /**
3402  * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
3403  * @ioc: per adapter object
3404  *
3405  * During device pull we need to appropriately set the sdev state.
3406  */
3407 static void
3408 _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
3409 {
3410         struct MPT3SAS_DEVICE *sas_device_priv_data;
3411         struct scsi_device *sdev;
3412 
3413         shost_for_each_device(sdev, ioc->shost) {
3414                 sas_device_priv_data = sdev->hostdata;
3415                 if (!sas_device_priv_data)
3416                         continue;
3417                 if (sas_device_priv_data->block)
3418                         continue;
3419                 if (sas_device_priv_data->ignore_delay_remove) {
3420                         sdev_printk(KERN_INFO, sdev,
3421                         "%s skip device_block for SES handle(0x%04x)\n",
3422                         __func__, sas_device_priv_data->sas_target->handle);
3423                         continue;
3424                 }
3425                 _scsih_internal_device_block(sdev, sas_device_priv_data);
3426         }
3427 }
3428 
3429 /**
3430  * _scsih_block_io_device - set the device state to SDEV_BLOCK
3431  * @ioc: per adapter object
3432  * @handle: device handle
3433  *
3434  * During device pull we need to appropriately set the sdev state.
3435  */
3436 static void
3437 _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3438 {
3439         struct MPT3SAS_DEVICE *sas_device_priv_data;
3440         struct scsi_device *sdev;
3441         struct _sas_device *sas_device;
3442 
3443         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
3444 
3445         shost_for_each_device(sdev, ioc->shost) {
3446                 sas_device_priv_data = sdev->hostdata;
3447                 if (!sas_device_priv_data)
3448                         continue;
3449                 if (sas_device_priv_data->sas_target->handle != handle)
3450                         continue;
3451                 if (sas_device_priv_data->block)
3452                         continue;
3453                 if (sas_device && sas_device->pend_sas_rphy_add)
3454                         continue;
3455                 if (sas_device_priv_data->ignore_delay_remove) {
3456                         sdev_printk(KERN_INFO, sdev,
3457                         "%s skip device_block for SES handle(0x%04x)\n",
3458                         __func__, sas_device_priv_data->sas_target->handle);
3459                         continue;
3460                 }
3461                 _scsih_internal_device_block(sdev, sas_device_priv_data);
3462         }
3463 
3464         if (sas_device)
3465                 sas_device_put(sas_device);
3466 }
3467 
3468 /**
3469  * _scsih_block_io_to_children_attached_to_ex
3470  * @ioc: per adapter object
3471  * @sas_expander: the sas_device object
3472  *
3473  * This routine set sdev state to SDEV_BLOCK for all devices
3474  * attached to this expander. This function called when expander is
3475  * pulled.
3476  */
3477 static void
3478 _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
3479         struct _sas_node *sas_expander)
3480 {
3481         struct _sas_port *mpt3sas_port;
3482         struct _sas_device *sas_device;
3483         struct _sas_node *expander_sibling;
3484         unsigned long flags;
3485 
3486         if (!sas_expander)
3487                 return;
3488 
3489         list_for_each_entry(mpt3sas_port,
3490            &sas_expander->sas_port_list, port_list) {
3491                 if (mpt3sas_port->remote_identify.device_type ==
3492                     SAS_END_DEVICE) {
3493                         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3494                         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
3495                             mpt3sas_port->remote_identify.sas_address);
3496                         if (sas_device) {
3497                                 set_bit(sas_device->handle,
3498                                                 ioc->blocking_handles);
3499                                 sas_device_put(sas_device);
3500                         }
3501                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3502                 }
3503         }
3504 
3505         list_for_each_entry(mpt3sas_port,
3506            &sas_expander->sas_port_list, port_list) {
3507 
3508                 if (mpt3sas_port->remote_identify.device_type ==
3509                     SAS_EDGE_EXPANDER_DEVICE ||
3510                     mpt3sas_port->remote_identify.device_type ==
3511                     SAS_FANOUT_EXPANDER_DEVICE) {
3512                         expander_sibling =
3513                             mpt3sas_scsih_expander_find_by_sas_address(
3514                             ioc, mpt3sas_port->remote_identify.sas_address);
3515                         _scsih_block_io_to_children_attached_to_ex(ioc,
3516                             expander_sibling);
3517                 }
3518         }
3519 }
3520 
3521 /**
3522  * _scsih_block_io_to_children_attached_directly
3523  * @ioc: per adapter object
3524  * @event_data: topology change event data
3525  *
3526  * This routine set sdev state to SDEV_BLOCK for all devices
3527  * direct attached during device pull.
3528  */
3529 static void
3530 _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
3531         Mpi2EventDataSasTopologyChangeList_t *event_data)
3532 {
3533         int i;
3534         u16 handle;
3535         u16 reason_code;
3536 
3537         for (i = 0; i < event_data->NumEntries; i++) {
3538                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3539                 if (!handle)
3540                         continue;
3541                 reason_code = event_data->PHY[i].PhyStatus &
3542                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3543                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
3544                         _scsih_block_io_device(ioc, handle);
3545         }
3546 }
3547 
3548 /**
3549  * _scsih_block_io_to_pcie_children_attached_directly
3550  * @ioc: per adapter object
3551  * @event_data: topology change event data
3552  *
3553  * This routine set sdev state to SDEV_BLOCK for all devices
3554  * direct attached during device pull/reconnect.
3555  */
3556 static void
3557 _scsih_block_io_to_pcie_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
3558                 Mpi26EventDataPCIeTopologyChangeList_t *event_data)
3559 {
3560         int i;
3561         u16 handle;
3562         u16 reason_code;
3563 
3564         for (i = 0; i < event_data->NumEntries; i++) {
3565                 handle =
3566                         le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
3567                 if (!handle)
3568                         continue;
3569                 reason_code = event_data->PortEntry[i].PortStatus;
3570                 if (reason_code ==
3571                                 MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING)
3572                         _scsih_block_io_device(ioc, handle);
3573         }
3574 }
3575 /**
3576  * _scsih_tm_tr_send - send task management request
3577  * @ioc: per adapter object
3578  * @handle: device handle
3579  * Context: interrupt time.
3580  *
3581  * This code is to initiate the device removal handshake protocol
3582  * with controller firmware.  This function will issue target reset
3583  * using high priority request queue.  It will send a sas iounit
3584  * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
3585  *
3586  * This is designed to send muliple task management request at the same
3587  * time to the fifo. If the fifo is full, we will append the request,
3588  * and process it in a future completion.
3589  */
3590 static void
3591 _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3592 {
3593         Mpi2SCSITaskManagementRequest_t *mpi_request;
3594         u16 smid;
3595         struct _sas_device *sas_device = NULL;
3596         struct _pcie_device *pcie_device = NULL;
3597         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
3598         u64 sas_address = 0;
3599         unsigned long flags;
3600         struct _tr_list *delayed_tr;
3601         u32 ioc_state;
3602         u8 tr_method = 0;
3603 
3604         if (ioc->pci_error_recovery) {
3605                 dewtprintk(ioc,
3606                            ioc_info(ioc, "%s: host in pci error recovery: handle(0x%04x)\n",
3607                                     __func__, handle));
3608                 return;
3609         }
3610         ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
3611         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3612                 dewtprintk(ioc,
3613                            ioc_info(ioc, "%s: host is not operational: handle(0x%04x)\n",
3614                                     __func__, handle));
3615                 return;
3616         }
3617 
3618         /* if PD, then return */
3619         if (test_bit(handle, ioc->pd_handles))
3620                 return;
3621 
3622         clear_bit(handle, ioc->pend_os_device_add);
3623 
3624         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3625         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
3626         if (sas_device && sas_device->starget &&
3627             sas_device->starget->hostdata) {
3628                 sas_target_priv_data = sas_device->starget->hostdata;
3629                 sas_target_priv_data->deleted = 1;
3630                 sas_address = sas_device->sas_address;
3631         }
3632         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3633         if (!sas_device) {
3634                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
3635                 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
3636                 if (pcie_device && pcie_device->starget &&
3637                         pcie_device->starget->hostdata) {
3638                         sas_target_priv_data = pcie_device->starget->hostdata;
3639                         sas_target_priv_data->deleted = 1;
3640                         sas_address = pcie_device->wwid;
3641                 }
3642                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
3643                 if (pcie_device && (!ioc->tm_custom_handling) &&
3644                     (!(mpt3sas_scsih_is_pcie_scsi_device(
3645                     pcie_device->device_info))))
3646                         tr_method =
3647                             MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE;
3648                 else
3649                         tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
3650         }
3651         if (sas_target_priv_data) {
3652                 dewtprintk(ioc,
3653                            ioc_info(ioc, "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
3654                                     handle, (u64)sas_address));
3655                 if (sas_device) {
3656                         if (sas_device->enclosure_handle != 0)
3657                                 dewtprintk(ioc,
3658                                            ioc_info(ioc, "setting delete flag:enclosure logical id(0x%016llx), slot(%d)\n",
3659                                                     (u64)sas_device->enclosure_logical_id,
3660                                                     sas_device->slot));
3661                         if (sas_device->connector_name[0] != '\0')
3662                                 dewtprintk(ioc,
3663                                            ioc_info(ioc, "setting delete flag: enclosure level(0x%04x), connector name( %s)\n",
3664                                                     sas_device->enclosure_level,
3665                                                     sas_device->connector_name));
3666                 } else if (pcie_device) {
3667                         if (pcie_device->enclosure_handle != 0)
3668                                 dewtprintk(ioc,
3669                                            ioc_info(ioc, "setting delete flag: logical id(0x%016llx), slot(%d)\n",
3670                                                     (u64)pcie_device->enclosure_logical_id,
3671                                                     pcie_device->slot));
3672                         if (pcie_device->connector_name[0] != '\0')
3673                                 dewtprintk(ioc,
3674                                            ioc_info(ioc, "setting delete flag:, enclosure level(0x%04x), connector name( %s)\n",
3675                                                     pcie_device->enclosure_level,
3676                                                     pcie_device->connector_name));
3677                 }
3678                 _scsih_ublock_io_device(ioc, sas_address);
3679                 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
3680         }
3681 
3682         smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
3683         if (!smid) {
3684                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3685                 if (!delayed_tr)
3686                         goto out;
3687                 INIT_LIST_HEAD(&delayed_tr->list);
3688                 delayed_tr->handle = handle;
3689                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3690                 dewtprintk(ioc,
3691                            ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
3692                                     handle));
3693                 goto out;
3694         }
3695 
3696         dewtprintk(ioc,
3697                    ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3698                             handle, smid, ioc->tm_tr_cb_idx));
3699         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3700         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3701         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3702         mpi_request->DevHandle = cpu_to_le16(handle);
3703         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3704         mpi_request->MsgFlags = tr_method;
3705         set_bit(handle, ioc->device_remove_in_progress);
3706         ioc->put_smid_hi_priority(ioc, smid, 0);
3707         mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
3708 
3709 out:
3710         if (sas_device)
3711                 sas_device_put(sas_device);
3712         if (pcie_device)
3713                 pcie_device_put(pcie_device);
3714 }
3715 
3716 /**
3717  * _scsih_tm_tr_complete -
3718  * @ioc: per adapter object
3719  * @smid: system request message index
3720  * @msix_index: MSIX table index supplied by the OS
3721  * @reply: reply message frame(lower 32bit addr)
3722  * Context: interrupt time.
3723  *
3724  * This is the target reset completion routine.
3725  * This code is part of the code to initiate the device removal
3726  * handshake protocol with controller firmware.
3727  * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
3728  *
3729  * Return: 1 meaning mf should be freed from _base_interrupt
3730  *         0 means the mf is freed from this function.
3731  */
3732 static u8
3733 _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
3734         u32 reply)
3735 {
3736         u16 handle;
3737         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3738         Mpi2SCSITaskManagementReply_t *mpi_reply =
3739             mpt3sas_base_get_reply_virt_addr(ioc, reply);
3740         Mpi2SasIoUnitControlRequest_t *mpi_request;
3741         u16 smid_sas_ctrl;
3742         u32 ioc_state;
3743         struct _sc_list *delayed_sc;
3744 
3745         if (ioc->pci_error_recovery) {
3746                 dewtprintk(ioc,
3747                            ioc_info(ioc, "%s: host in pci error recovery\n",
3748                                     __func__));
3749                 return 1;
3750         }
3751         ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
3752         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3753                 dewtprintk(ioc,
3754                            ioc_info(ioc, "%s: host is not operational\n",
3755                                     __func__));
3756                 return 1;
3757         }
3758         if (unlikely(!mpi_reply)) {
3759                 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
3760                         __FILE__, __LINE__, __func__);
3761                 return 1;
3762         }
3763         mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3764         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3765         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3766                 dewtprintk(ioc,
3767                            ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3768                                    handle,
3769                                    le16_to_cpu(mpi_reply->DevHandle), smid));
3770                 return 0;
3771         }
3772 
3773         mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
3774         dewtprintk(ioc,
3775                    ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
3776                             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3777                             le32_to_cpu(mpi_reply->IOCLogInfo),
3778                             le32_to_cpu(mpi_reply->TerminationCount)));
3779 
3780         smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
3781         if (!smid_sas_ctrl) {
3782                 delayed_sc = kzalloc(sizeof(*delayed_sc), GFP_ATOMIC);
3783                 if (!delayed_sc)
3784                         return _scsih_check_for_pending_tm(ioc, smid);
3785                 INIT_LIST_HEAD(&delayed_sc->list);
3786                 delayed_sc->handle = le16_to_cpu(mpi_request_tm->DevHandle);
3787                 list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list);
3788                 dewtprintk(ioc,
3789                            ioc_info(ioc, "DELAYED:sc:handle(0x%04x), (open)\n",
3790                                     handle));
3791                 return _scsih_check_for_pending_tm(ioc, smid);
3792         }
3793 
3794         dewtprintk(ioc,
3795                    ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3796                             handle, smid_sas_ctrl, ioc->tm_sas_control_cb_idx));
3797         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
3798         memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
3799         mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
3800         mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
3801         mpi_request->DevHandle = mpi_request_tm->DevHandle;
3802         ioc->put_smid_default(ioc, smid_sas_ctrl);
3803 
3804         return _scsih_check_for_pending_tm(ioc, smid);
3805 }
3806 
3807 /** _scsih_allow_scmd_to_device - check whether scmd needs to
3808  *                               issue to IOC or not.
3809  * @ioc: per adapter object
3810  * @scmd: pointer to scsi command object
3811  *
3812  * Returns true if scmd can be issued to IOC otherwise returns false.
3813  */
3814 inline bool _scsih_allow_scmd_to_device(struct MPT3SAS_ADAPTER *ioc,
3815         struct scsi_cmnd *scmd)
3816 {
3817 
3818         if (ioc->pci_error_recovery)
3819                 return false;
3820 
3821         if (ioc->hba_mpi_version_belonged == MPI2_VERSION) {
3822                 if (ioc->remove_host)
3823                         return false;
3824 
3825                 return true;
3826         }
3827 
3828         if (ioc->remove_host) {
3829 
3830                 switch (scmd->cmnd[0]) {
3831                 case SYNCHRONIZE_CACHE:
3832                 case START_STOP:
3833                         return true;
3834                 default:
3835                         return false;
3836                 }
3837         }
3838 
3839         return true;
3840 }
3841 
3842 /**
3843  * _scsih_sas_control_complete - completion routine
3844  * @ioc: per adapter object
3845  * @smid: system request message index
3846  * @msix_index: MSIX table index supplied by the OS
3847  * @reply: reply message frame(lower 32bit addr)
3848  * Context: interrupt time.
3849  *
3850  * This is the sas iounit control completion routine.
3851  * This code is part of the code to initiate the device removal
3852  * handshake protocol with controller firmware.
3853  *
3854  * Return: 1 meaning mf should be freed from _base_interrupt
3855  *         0 means the mf is freed from this function.
3856  */
3857 static u8
3858 _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3859         u8 msix_index, u32 reply)
3860 {
3861         Mpi2SasIoUnitControlReply_t *mpi_reply =
3862             mpt3sas_base_get_reply_virt_addr(ioc, reply);
3863 
3864         if (likely(mpi_reply)) {
3865                 dewtprintk(ioc,
3866                            ioc_info(ioc, "sc_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
3867                                     le16_to_cpu(mpi_reply->DevHandle), smid,
3868                                     le16_to_cpu(mpi_reply->IOCStatus),
3869                                     le32_to_cpu(mpi_reply->IOCLogInfo)));
3870                 if (le16_to_cpu(mpi_reply->IOCStatus) ==
3871                      MPI2_IOCSTATUS_SUCCESS) {
3872                         clear_bit(le16_to_cpu(mpi_reply->DevHandle),
3873                             ioc->device_remove_in_progress);
3874                 }
3875         } else {
3876                 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
3877                         __FILE__, __LINE__, __func__);
3878         }
3879         return mpt3sas_check_for_pending_internal_cmds(ioc, smid);
3880 }
3881 
3882 /**
3883  * _scsih_tm_tr_volume_send - send target reset request for volumes
3884  * @ioc: per adapter object
3885  * @handle: device handle
3886  * Context: interrupt time.
3887  *
3888  * This is designed to send muliple task management request at the same
3889  * time to the fifo. If the fifo is full, we will append the request,
3890  * and process it in a future completion.
3891  */
3892 static void
3893 _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3894 {
3895         Mpi2SCSITaskManagementRequest_t *mpi_request;
3896         u16 smid;
3897         struct _tr_list *delayed_tr;
3898 
3899         if (ioc->pci_error_recovery) {
3900                 dewtprintk(ioc,
3901                            ioc_info(ioc, "%s: host reset in progress!\n",
3902                                     __func__));
3903                 return;
3904         }
3905 
3906         smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
3907         if (!smid) {
3908                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3909                 if (!delayed_tr)
3910                         return;
3911                 INIT_LIST_HEAD(&delayed_tr->list);
3912                 delayed_tr->handle = handle;
3913                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
3914                 dewtprintk(ioc,
3915                            ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
3916                                     handle));
3917                 return;
3918         }
3919 
3920         dewtprintk(ioc,
3921                    ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3922                             handle, smid, ioc->tm_tr_volume_cb_idx));
3923         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3924         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3925         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3926         mpi_request->DevHandle = cpu_to_le16(handle);
3927         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3928         ioc->put_smid_hi_priority(ioc, smid, 0);
3929 }
3930 
3931 /**
3932  * _scsih_tm_volume_tr_complete - target reset completion
3933  * @ioc: per adapter object
3934  * @smid: system request message index
3935  * @msix_index: MSIX table index supplied by the OS
3936  * @reply: reply message frame(lower 32bit addr)
3937  * Context: interrupt time.
3938  *
3939  * Return: 1 meaning mf should be freed from _base_interrupt
3940  *         0 means the mf is freed from this function.
3941  */
3942 static u8
3943 _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3944         u8 msix_index, u32 reply)
3945 {
3946         u16 handle;
3947         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3948         Mpi2SCSITaskManagementReply_t *mpi_reply =
3949             mpt3sas_base_get_reply_virt_addr(ioc, reply);
3950 
3951         if (ioc->shost_recovery || ioc->pci_error_recovery) {
3952                 dewtprintk(ioc,
3953                            ioc_info(ioc, "%s: host reset in progress!\n",
3954                                     __func__));
3955                 return 1;
3956         }
3957         if (unlikely(!mpi_reply)) {
3958                 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
3959                         __FILE__, __LINE__, __func__);
3960                 return 1;
3961         }
3962 
3963         mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3964         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3965         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3966                 dewtprintk(ioc,
3967                            ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3968                                    handle, le16_to_cpu(mpi_reply->DevHandle),
3969                                    smid));
3970                 return 0;
3971         }
3972 
3973         dewtprintk(ioc,
3974                    ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
3975                             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3976                             le32_to_cpu(mpi_reply->IOCLogInfo),
3977                             le32_to_cpu(mpi_reply->TerminationCount)));
3978 
3979         return _scsih_check_for_pending_tm(ioc, smid);
3980 }
3981 
3982 /**
3983  * _scsih_issue_delayed_event_ack - issue delayed Event ACK messages
3984  * @ioc: per adapter object
3985  * @smid: system request message index
3986  * @event: Event ID
3987  * @event_context: used to track events uniquely
3988  *
3989  * Context - processed in interrupt context.
3990  */
3991 static void
3992 _scsih_issue_delayed_event_ack(struct MPT3SAS_ADAPTER *ioc, u16 smid, U16 event,
3993                                 U32 event_context)
3994 {
3995         Mpi2EventAckRequest_t *ack_request;
3996         int i = smid - ioc->internal_smid;
3997         unsigned long flags;
3998 
3999         /* Without releasing the smid just update the
4000          * call back index and reuse the same smid for
4001          * processing this delayed request
4002          */
4003         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4004         ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx;
4005         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4006 
4007         dewtprintk(ioc,
4008                    ioc_info(ioc, "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n",
4009                             le16_to_cpu(event), smid, ioc->base_cb_idx));
4010         ack_request = mpt3sas_base_get_msg_frame(ioc, smid);
4011         memset(ack_request, 0, sizeof(Mpi2EventAckRequest_t));
4012         ack_request->Function = MPI2_FUNCTION_EVENT_ACK;
4013         ack_request->Event = event;
4014         ack_request->EventContext = event_context;
4015         ack_request->VF_ID = 0;  /* TODO */
4016         ack_request->VP_ID = 0;
4017         ioc->put_smid_default(ioc, smid);
4018 }
4019 
4020 /**
4021  * _scsih_issue_delayed_sas_io_unit_ctrl - issue delayed
4022  *                              sas_io_unit_ctrl messages
4023  * @ioc: per adapter object
4024  * @smid: system request message index
4025  * @handle: device handle
4026  *
4027  * Context - processed in interrupt context.
4028  */
4029 static void
4030 _scsih_issue_delayed_sas_io_unit_ctrl(struct MPT3SAS_ADAPTER *ioc,
4031                                         u16 smid, u16 handle)
4032 {
4033         Mpi2SasIoUnitControlRequest_t *mpi_request;
4034         u32 ioc_state;
4035         int i = smid - ioc->internal_smid;
4036         unsigned long flags;
4037 
4038         if (ioc->remove_host) {
4039                 dewtprintk(ioc,
4040                            ioc_info(ioc, "%s: host has been removed\n",
4041                                     __func__));
4042                 return;
4043         } else if (ioc->pci_error_recovery) {
4044                 dewtprintk(ioc,
4045                            ioc_info(ioc, "%s: host in pci error recovery\n",
4046                                     __func__));
4047                 return;
4048         }
4049         ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
4050         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
4051                 dewtprintk(ioc,
4052                            ioc_info(ioc, "%s: host is not operational\n",
4053                                     __func__));
4054                 return;
4055         }
4056 
4057         /* Without releasing the smid just update the
4058          * call back index and reuse the same smid for
4059          * processing this delayed request
4060          */
4061         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4062         ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx;
4063         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4064 
4065         dewtprintk(ioc,
4066                    ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
4067                             handle, smid, ioc->tm_sas_control_cb_idx));
4068         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4069         memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
4070         mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
4071         mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
4072         mpi_request->DevHandle = cpu_to_le16(handle);
4073         ioc->put_smid_default(ioc, smid);
4074 }
4075 
4076 /**
4077  * _scsih_check_for_pending_internal_cmds - check for pending internal messages
4078  * @ioc: per adapter object
4079  * @smid: system request message index
4080  *
4081  * Context: Executed in interrupt context
4082  *
4083  * This will check delayed internal messages list, and process the
4084  * next request.
4085  *
4086  * Return: 1 meaning mf should be freed from _base_interrupt
4087  *         0 means the mf is freed from this function.
4088  */
4089 u8
4090 mpt3sas_check_for_pending_internal_cmds(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4091 {
4092         struct _sc_list *delayed_sc;
4093         struct _event_ack_list *delayed_event_ack;
4094 
4095         if (!list_empty(&ioc->delayed_event_ack_list)) {
4096                 delayed_event_ack = list_entry(ioc->delayed_event_ack_list.next,
4097                                                 struct _event_ack_list, list);
4098                 _scsih_issue_delayed_event_ack(ioc, smid,
4099                   delayed_event_ack->Event, delayed_event_ack->EventContext);
4100                 list_del(&delayed_event_ack->list);
4101                 kfree(delayed_event_ack);
4102                 return 0;
4103         }
4104 
4105         if (!list_empty(&ioc->delayed_sc_list)) {
4106                 delayed_sc = list_entry(ioc->delayed_sc_list.next,
4107                                                 struct _sc_list, list);
4108                 _scsih_issue_delayed_sas_io_unit_ctrl(ioc, smid,
4109                                                  delayed_sc->handle);
4110                 list_del(&delayed_sc->list);
4111                 kfree(delayed_sc);
4112                 return 0;
4113         }
4114         return 1;
4115 }
4116 
4117 /**
4118  * _scsih_check_for_pending_tm - check for pending task management
4119  * @ioc: per adapter object
4120  * @smid: system request message index
4121  *
4122  * This will check delayed target reset list, and feed the
4123  * next reqeust.
4124  *
4125  * Return: 1 meaning mf should be freed from _base_interrupt
4126  *         0 means the mf is freed from this function.
4127  */
4128 static u8
4129 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
4130 {
4131         struct _tr_list *delayed_tr;
4132 
4133         if (!list_empty(&ioc->delayed_tr_volume_list)) {
4134                 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
4135                     struct _tr_list, list);
4136                 mpt3sas_base_free_smid(ioc, smid);
4137                 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
4138                 list_del(&delayed_tr->list);
4139                 kfree(delayed_tr);
4140                 return 0;
4141         }
4142 
4143         if (!list_empty(&ioc->delayed_tr_list)) {
4144                 delayed_tr = list_entry(ioc->delayed_tr_list.next,
4145                     struct _tr_list, list);
4146                 mpt3sas_base_free_smid(ioc, smid);
4147                 _scsih_tm_tr_send(ioc, delayed_tr->handle);
4148                 list_del(&delayed_tr->list);
4149                 kfree(delayed_tr);
4150                 return 0;
4151         }
4152 
4153         return 1;
4154 }
4155 
4156 /**
4157  * _scsih_check_topo_delete_events - sanity check on topo events
4158  * @ioc: per adapter object
4159  * @event_data: the event data payload
4160  *
4161  * This routine added to better handle cable breaker.
4162  *
4163  * This handles the case where driver receives multiple expander
4164  * add and delete events in a single shot.  When there is a delete event
4165  * the routine will void any pending add events waiting in the event queue.
4166  */
4167 static void
4168 _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
4169         Mpi2EventDataSasTopologyChangeList_t *event_data)
4170 {
4171         struct fw_event_work *fw_event;
4172         Mpi2EventDataSasTopologyChangeList_t *local_event_data;
4173         u16 expander_handle;
4174         struct _sas_node *sas_expander;
4175         unsigned long flags;
4176         int i, reason_code;
4177         u16 handle;
4178 
4179         for (i = 0 ; i < event_data->NumEntries; i++) {
4180                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
4181                 if (!handle)
4182                         continue;
4183                 reason_code = event_data->PHY[i].PhyStatus &
4184                     MPI2_EVENT_SAS_TOPO_RC_MASK;
4185                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
4186                         _scsih_tm_tr_send(ioc, handle);
4187         }
4188 
4189         expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
4190         if (expander_handle < ioc->sas_hba.num_phys) {
4191                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4192                 return;
4193         }
4194         if (event_data->ExpStatus ==
4195             MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
4196                 /* put expander attached devices into blocking state */
4197                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4198                 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
4199                     expander_handle);
4200                 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
4201                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4202                 do {
4203                         handle = find_first_bit(ioc->blocking_handles,
4204                             ioc->facts.MaxDevHandle);
4205                         if (handle < ioc->facts.MaxDevHandle)
4206                                 _scsih_block_io_device(ioc, handle);
4207                 } while (test_and_clear_bit(handle, ioc->blocking_handles));
4208         } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
4209                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
4210 
4211         if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
4212                 return;
4213 
4214         /* mark ignore flag for pending events */
4215         spin_lock_irqsave(&ioc->fw_event_lock, flags);
4216         list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4217                 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
4218                     fw_event->ignore)
4219                         continue;
4220                 local_event_data = (Mpi2EventDataSasTopologyChangeList_t *)
4221                                    fw_event->event_data;
4222                 if (local_event_data->ExpStatus ==
4223                     MPI2_EVENT_SAS_TOPO_ES_ADDED ||
4224                     local_event_data->ExpStatus ==
4225                     MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
4226                         if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
4227                             expander_handle) {
4228                                 dewtprintk(ioc,
4229                                            ioc_info(ioc, "setting ignoring flag\n"));
4230                                 fw_event->ignore = 1;
4231                         }
4232                 }
4233         }
4234         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4235 }
4236 
4237 /**
4238  * _scsih_check_pcie_topo_remove_events - sanity check on topo
4239  * events
4240  * @ioc: per adapter object
4241  * @event_data: the event data payload
4242  *
4243  * This handles the case where driver receives multiple switch
4244  * or device add and delete events in a single shot.  When there
4245  * is a delete event the routine will void any pending add
4246  * events waiting in the event queue.
4247  */
4248 static void
4249 _scsih_check_pcie_topo_remove_events(struct MPT3SAS_ADAPTER *ioc,
4250         Mpi26EventDataPCIeTopologyChangeList_t *event_data)
4251 {
4252         struct fw_event_work *fw_event;
4253         Mpi26EventDataPCIeTopologyChangeList_t *local_event_data;
4254         unsigned long flags;
4255         int i, reason_code;
4256         u16 handle, switch_handle;
4257 
4258         for (i = 0; i < event_data->NumEntries; i++) {
4259                 handle =
4260                         le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
4261                 if (!handle)
4262                         continue;
4263                 reason_code = event_data->PortEntry[i].PortStatus;
4264                 if (reason_code == MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING)
4265                         _scsih_tm_tr_send(ioc, handle);
4266         }
4267 
4268         switch_handle = le16_to_cpu(event_data->SwitchDevHandle);
4269         if (!switch_handle) {
4270                 _scsih_block_io_to_pcie_children_attached_directly(
4271                                                         ioc, event_data);
4272                 return;
4273         }
4274     /* TODO We are not supporting cascaded PCIe Switch removal yet*/
4275         if ((event_data->SwitchStatus
4276                 == MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING) ||
4277                 (event_data->SwitchStatus ==
4278                                         MPI26_EVENT_PCIE_TOPO_SS_RESPONDING))
4279                 _scsih_block_io_to_pcie_children_attached_directly(
4280                                                         ioc, event_data);
4281 
4282         if (event_data->SwitchStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
4283                 return;
4284 
4285         /* mark ignore flag for pending events */
4286         spin_lock_irqsave(&ioc->fw_event_lock, flags);
4287         list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
4288                 if (fw_event->event != MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST ||
4289                         fw_event->ignore)
4290                         continue;
4291                 local_event_data =
4292                         (Mpi26EventDataPCIeTopologyChangeList_t *)
4293                         fw_event->event_data;
4294                 if (local_event_data->SwitchStatus ==
4295                     MPI2_EVENT_SAS_TOPO_ES_ADDED ||
4296                     local_event_data->SwitchStatus ==
4297                     MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
4298                         if (le16_to_cpu(local_event_data->SwitchDevHandle) ==
4299                                 switch_handle) {
4300                                 dewtprintk(ioc,
4301                                            ioc_info(ioc, "setting ignoring flag for switch event\n"));
4302                                 fw_event->ignore = 1;
4303                         }
4304                 }
4305         }
4306         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
4307 }
4308 
4309 /**
4310  * _scsih_set_volume_delete_flag - setting volume delete flag
4311  * @ioc: per adapter object
4312  * @handle: device handle
4313  *
4314  * This returns nothing.
4315  */
4316 static void
4317 _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4318 {
4319         struct _raid_device *raid_device;
4320         struct MPT3SAS_TARGET *sas_target_priv_data;
4321         unsigned long flags;
4322 
4323         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4324         raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
4325         if (raid_device && raid_device->starget &&
4326             raid_device->starget->hostdata) {
4327                 sas_target_priv_data =
4328                     raid_device->starget->hostdata;
4329                 sas_target_priv_data->deleted = 1;
4330                 dewtprintk(ioc,
4331                            ioc_info(ioc, "setting delete flag: handle(0x%04x), wwid(0x%016llx)\n",
4332                                     handle, (u64)raid_device->wwid));
4333         }
4334         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4335 }
4336 
4337 /**
4338  * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
4339  * @handle: input handle
4340  * @a: handle for volume a
4341  * @b: handle for volume b
4342  *
4343  * IR firmware only supports two raid volumes.  The purpose of this
4344  * routine is to set the volume handle in either a or b. When the given
4345  * input handle is non-zero, or when a and b have not been set before.
4346  */
4347 static void
4348 _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
4349 {
4350         if (!handle || handle == *a || handle == *b)
4351                 return;
4352         if (!*a)
4353                 *a = handle;
4354         else if (!*b)
4355                 *b = handle;
4356 }
4357 
4358 /**
4359  * _scsih_check_ir_config_unhide_events - check for UNHIDE events
4360  * @ioc: per adapter object
4361  * @event_data: the event data payload
4362  * Context: interrupt time.
4363  *
4364  * This routine will send target reset to volume, followed by target
4365  * resets to the PDs. This is called when a PD has been removed, or
4366  * volume has been deleted or removed. When the target reset is sent
4367  * to volume, the PD target resets need to be queued to start upon
4368  * completion of the volume target reset.
4369  */
4370 static void
4371 _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
4372         Mpi2EventDataIrConfigChangeList_t *event_data)
4373 {
4374         Mpi2EventIrConfigElement_t *element;
4375         int i;
4376         u16 handle, volume_handle, a, b;
4377         struct _tr_list *delayed_tr;
4378 
4379         a = 0;
4380         b = 0;
4381 
4382         if (ioc->is_warpdrive)
4383                 return;
4384 
4385         /* Volume Resets for Deleted or Removed */
4386         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4387         for (i = 0; i < event_data->NumElements; i++, element++) {
4388                 if (le32_to_cpu(event_data->Flags) &
4389                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
4390                         continue;
4391                 if (element->ReasonCode ==
4392                     MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
4393                     element->ReasonCode ==
4394                     MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
4395                         volume_handle = le16_to_cpu(element->VolDevHandle);
4396                         _scsih_set_volume_delete_flag(ioc, volume_handle);
4397                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
4398                 }
4399         }
4400 
4401         /* Volume Resets for UNHIDE events */
4402         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4403         for (i = 0; i < event_data->NumElements; i++, element++) {
4404                 if (le32_to_cpu(event_data->Flags) &
4405                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
4406                         continue;
4407                 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
4408                         volume_handle = le16_to_cpu(element->VolDevHandle);
4409                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
4410                 }
4411         }
4412 
4413         if (a)
4414                 _scsih_tm_tr_volume_send(ioc, a);
4415         if (b)
4416                 _scsih_tm_tr_volume_send(ioc, b);
4417 
4418         /* PD target resets */
4419         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4420         for (i = 0; i < event_data->NumElements; i++, element++) {
4421                 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
4422                         continue;
4423                 handle = le16_to_cpu(element->PhysDiskDevHandle);
4424                 volume_handle = le16_to_cpu(element->VolDevHandle);
4425                 clear_bit(handle, ioc->pd_handles);
4426                 if (!volume_handle)
4427                         _scsih_tm_tr_send(ioc, handle);
4428                 else if (volume_handle == a || volume_handle == b) {
4429                         delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
4430                         BUG_ON(!delayed_tr);
4431                         INIT_LIST_HEAD(&delayed_tr->list);
4432                         delayed_tr->handle = handle;
4433                         list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
4434                         dewtprintk(ioc,
4435                                    ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
4436                                             handle));
4437                 } else
4438                         _scsih_tm_tr_send(ioc, handle);
4439         }
4440 }
4441 
4442 
4443 /**
4444  * _scsih_check_volume_delete_events - set delete flag for volumes
4445  * @ioc: per adapter object
4446  * @event_data: the event data payload
4447  * Context: interrupt time.
4448  *
4449  * This will handle the case when the cable connected to entire volume is
4450  * pulled. We will take care of setting the deleted flag so normal IO will
4451  * not be sent.
4452  */
4453 static void
4454 _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
4455         Mpi2EventDataIrVolume_t *event_data)
4456 {
4457         u32 state;
4458 
4459         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
4460                 return;
4461         state = le32_to_cpu(event_data->NewValue);
4462         if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
4463             MPI2_RAID_VOL_STATE_FAILED)
4464                 _scsih_set_volume_delete_flag(ioc,
4465                     le16_to_cpu(event_data->VolDevHandle));
4466 }
4467 
4468 /**
4469  * _scsih_temp_threshold_events - display temperature threshold exceeded events
4470  * @ioc: per adapter object
4471  * @event_data: the temp threshold event data
4472  * Context: interrupt time.
4473  */
4474 static void
4475 _scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
4476         Mpi2EventDataTemperature_t *event_data)
4477 {
4478         if (ioc->temp_sensors_count >= event_data->SensorNum) {
4479                 ioc_err(ioc, "Temperature Threshold flags %s%s%s%s exceeded for Sensor: %d !!!\n",
4480                         le16_to_cpu(event_data->Status) & 0x1 ? "0 " : " ",
4481                         le16_to_cpu(event_data->Status) & 0x2 ? "1 " : " ",
4482                         le16_to_cpu(event_data->Status) & 0x4 ? "2 " : " ",
4483                         le16_to_cpu(event_data->Status) & 0x8 ? "3 " : " ",
4484                         event_data->SensorNum);
4485                 ioc_err(ioc, "Current Temp In Celsius: %d\n",
4486                         event_data->CurrentTemperature);
4487         }
4488 }
4489 
4490 static int _scsih_set_satl_pending(struct scsi_cmnd *scmd, bool pending)
4491 {
4492         struct MPT3SAS_DEVICE *priv = scmd->device->hostdata;
4493 
4494         if (scmd->cmnd[0] != ATA_12 && scmd->cmnd[0] != ATA_16)
4495                 return 0;
4496 
4497         if (pending)
4498                 return test_and_set_bit(0, &priv->ata_command_pending);
4499 
4500         clear_bit(0, &priv->ata_command_pending);
4501         return 0;
4502 }
4503 
4504 /**
4505  * _scsih_flush_running_cmds - completing outstanding commands.
4506  * @ioc: per adapter object
4507  *
4508  * The flushing out of all pending scmd commands following host reset,
4509  * where all IO is dropped to the floor.
4510  */
4511 static void
4512 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
4513 {
4514         struct scsi_cmnd *scmd;
4515         struct scsiio_tracker *st;
4516         u16 smid;
4517         int count = 0;
4518 
4519         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
4520                 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
4521                 if (!scmd)
4522                         continue;
4523                 count++;
4524                 _scsih_set_satl_pending(scmd, false);
4525                 st = scsi_cmd_priv(scmd);
4526                 mpt3sas_base_clear_st(ioc, st);
4527                 scsi_dma_unmap(scmd);
4528                 if (ioc->pci_error_recovery || ioc->remove_host)
4529                         scmd->result = DID_NO_CONNECT << 16;
4530                 else
4531                         scmd->result = DID_RESET << 16;
4532                 scmd->scsi_done(scmd);
4533         }
4534         dtmprintk(ioc, ioc_info(ioc, "completing %d cmds\n", count));
4535 }
4536 
4537 /**
4538  * _scsih_setup_eedp - setup MPI request for EEDP transfer
4539  * @ioc: per adapter object
4540  * @scmd: pointer to scsi command object
4541  * @mpi_request: pointer to the SCSI_IO request message frame
4542  *
4543  * Supporting protection 1 and 3.
4544  */
4545 static void
4546 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4547         Mpi25SCSIIORequest_t *mpi_request)
4548 {
4549         u16 eedp_flags;
4550         unsigned char prot_op = scsi_get_prot_op(scmd);
4551         unsigned char prot_type = scsi_get_prot_type(scmd);
4552         Mpi25SCSIIORequest_t *mpi_request_3v =
4553            (Mpi25SCSIIORequest_t *)mpi_request;
4554 
4555         if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
4556                 return;
4557 
4558         if (prot_op ==  SCSI_PROT_READ_STRIP)
4559                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
4560         else if (prot_op ==  SCSI_PROT_WRITE_INSERT)
4561                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
4562         else
4563                 return;
4564 
4565         switch (prot_type) {
4566         case SCSI_PROT_DIF_TYPE1:
4567         case SCSI_PROT_DIF_TYPE2:
4568 
4569                 /*
4570                 * enable ref/guard checking
4571                 * auto increment ref tag
4572                 */
4573                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
4574                     MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
4575                     MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
4576                 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
4577                     cpu_to_be32(t10_pi_ref_tag(scmd->request));
4578                 break;
4579 
4580         case SCSI_PROT_DIF_TYPE3:
4581 
4582                 /*
4583                 * enable guard checking
4584                 */
4585                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
4586 
4587                 break;
4588         }
4589 
4590         mpi_request_3v->EEDPBlockSize =
4591             cpu_to_le16(scmd->device->sector_size);
4592 
4593         if (ioc->is_gen35_ioc)
4594                 eedp_flags |= MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE;
4595         mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
4596 }
4597 
4598 /**
4599  * _scsih_eedp_error_handling - return sense code for EEDP errors
4600  * @scmd: pointer to scsi command object
4601  * @ioc_status: ioc status
4602  */
4603 static void
4604 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
4605 {
4606         u8 ascq;
4607 
4608         switch (ioc_status) {
4609         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4610                 ascq = 0x01;
4611                 break;
4612         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4613                 ascq = 0x02;
4614                 break;
4615         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4616                 ascq = 0x03;
4617                 break;
4618         default:
4619                 ascq = 0x00;
4620                 break;
4621         }
4622         scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10,
4623             ascq);
4624         scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
4625             SAM_STAT_CHECK_CONDITION;
4626 }
4627 
4628 /**
4629  * scsih_qcmd - main scsi request entry point
4630  * @shost: SCSI host pointer
4631  * @scmd: pointer to scsi command object
4632  *
4633  * The callback index is set inside `ioc->scsi_io_cb_idx`.
4634  *
4635  * Return: 0 on success.  If there's a failure, return either:
4636  * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
4637  * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
4638  */
4639 static int
4640 scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
4641 {
4642         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
4643         struct MPT3SAS_DEVICE *sas_device_priv_data;
4644         struct MPT3SAS_TARGET *sas_target_priv_data;
4645         struct _raid_device *raid_device;
4646         struct request *rq = scmd->request;
4647         int class;
4648         Mpi25SCSIIORequest_t *mpi_request;
4649         struct _pcie_device *pcie_device = NULL;
4650         u32 mpi_control;
4651         u16 smid;
4652         u16 handle;
4653 
4654         if (ioc->logging_level & MPT_DEBUG_SCSI)
4655                 scsi_print_command(scmd);
4656 
4657         sas_device_priv_data = scmd->device->hostdata;
4658         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
4659                 scmd->result = DID_NO_CONNECT << 16;
4660                 scmd->scsi_done(scmd);
4661                 return 0;
4662         }
4663 
4664         if (!(_scsih_allow_scmd_to_device(ioc, scmd))) {
4665                 scmd->result = DID_NO_CONNECT << 16;
4666                 scmd->scsi_done(scmd);
4667                 return 0;
4668         }
4669 
4670         sas_target_priv_data = sas_device_priv_data->sas_target;
4671 
4672         /* invalid device handle */
4673         handle = sas_target_priv_data->handle;
4674         if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
4675                 scmd->result = DID_NO_CONNECT << 16;
4676                 scmd->scsi_done(scmd);
4677                 return 0;
4678         }
4679 
4680 
4681         if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) {
4682                 /* host recovery or link resets sent via IOCTLs */
4683                 return SCSI_MLQUEUE_HOST_BUSY;
4684         } else if (sas_target_priv_data->deleted) {
4685                 /* device has been deleted */
4686                 scmd->result = DID_NO_CONNECT << 16;
4687                 scmd->scsi_done(scmd);
4688                 return 0;
4689         } else if (sas_target_priv_data->tm_busy ||
4690                    sas_device_priv_data->block) {
4691                 /* device busy with task management */
4692                 return SCSI_MLQUEUE_DEVICE_BUSY;
4693         }
4694 
4695         /*
4696          * Bug work around for firmware SATL handling.  The loop
4697          * is based on atomic operations and ensures consistency
4698          * since we're lockless at this point
4699          */
4700         do {
4701                 if (test_bit(0, &sas_device_priv_data->ata_command_pending))
4702                         return SCSI_MLQUEUE_DEVICE_BUSY;
4703         } while (_scsih_set_satl_pending(scmd, true));
4704 
4705         if (scmd->sc_data_direction == DMA_FROM_DEVICE)
4706                 mpi_control = MPI2_SCSIIO_CONTROL_READ;
4707         else if (scmd->sc_data_direction == DMA_TO_DEVICE)
4708                 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
4709         else
4710                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
4711 
4712         /* set tags */
4713         mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4714         /* NCQ Prio supported, make sure control indicated high priority */
4715         if (sas_device_priv_data->ncq_prio_enable) {
4716                 class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq));
4717                 if (class == IOPRIO_CLASS_RT)
4718                         mpi_control |= 1 << MPI2_SCSIIO_CONTROL_CMDPRI_SHIFT;
4719         }
4720         /* Make sure Device is not raid volume.
4721          * We do not expose raid functionality to upper layer for warpdrive.
4722          */
4723         if (((!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev))
4724                 && !scsih_is_nvme(&scmd->device->sdev_gendev))
4725                 && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
4726                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
4727 
4728         smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
4729         if (!smid) {
4730                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
4731                 _scsih_set_satl_pending(scmd, false);
4732                 goto out;
4733         }
4734         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4735         memset(mpi_request, 0, ioc->request_sz);
4736         _scsih_setup_eedp(ioc, scmd, mpi_request);
4737 
4738         if (scmd->cmd_len == 32)
4739                 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
4740         mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4741         if (sas_device_priv_data->sas_target->flags &
4742             MPT_TARGET_FLAGS_RAID_COMPONENT)
4743                 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
4744         else
4745                 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4746         mpi_request->DevHandle = cpu_to_le16(handle);
4747         mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
4748         mpi_request->Control = cpu_to_le32(mpi_control);
4749         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
4750         mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
4751         mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
4752         mpi_request->SenseBufferLowAddress =
4753             mpt3sas_base_get_sense_buffer_dma(ioc, smid);
4754         mpi_request->SGLOffset0 = offsetof(Mpi25SCSIIORequest_t, SGL) / 4;
4755         int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
4756             mpi_request->LUN);
4757         memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4758 
4759         if (mpi_request->DataLength) {
4760                 pcie_device = sas_target_priv_data->pcie_dev;
4761                 if (ioc->build_sg_scmd(ioc, scmd, smid, pcie_device)) {
4762                         mpt3sas_base_free_smid(ioc, smid);
4763                         _scsih_set_satl_pending(scmd, false);
4764                         goto out;
4765                 }
4766         } else
4767                 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
4768 
4769         raid_device = sas_target_priv_data->raid_device;
4770         if (raid_device && raid_device->direct_io_enabled)
4771                 mpt3sas_setup_direct_io(ioc, scmd,
4772                         raid_device, mpi_request);
4773 
4774         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) {
4775                 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) {
4776                         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len |
4777                             MPI25_SCSIIO_IOFLAGS_FAST_PATH);
4778                         ioc->put_smid_fast_path(ioc, smid, handle);
4779                 } else
4780                         ioc->put_smid_scsi_io(ioc, smid,
4781                             le16_to_cpu(mpi_request->DevHandle));
4782         } else
4783                 ioc->put_smid_default(ioc, smid);
4784         return 0;
4785 
4786  out:
4787         return SCSI_MLQUEUE_HOST_BUSY;
4788 }
4789 
4790 /**
4791  * _scsih_normalize_sense - normalize descriptor and fixed format sense data
4792  * @sense_buffer: sense data returned by target
4793  * @data: normalized skey/asc/ascq
4794  */
4795 static void
4796 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
4797 {
4798         if ((sense_buffer[0] & 0x7F) >= 0x72) {
4799                 /* descriptor format */
4800                 data->skey = sense_buffer[1] & 0x0F;
4801                 data->asc = sense_buffer[2];
4802                 data->ascq = sense_buffer[3];
4803         } else {
4804                 /* fixed format */
4805                 data->skey = sense_buffer[2] & 0x0F;
4806                 data->asc = sense_buffer[12];
4807                 data->ascq = sense_buffer[13];
4808         }
4809 }
4810 
4811 /**
4812  * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
4813  * @ioc: per adapter object
4814  * @scmd: pointer to scsi command object
4815  * @mpi_reply: reply mf payload returned from firmware
4816  * @smid: ?
4817  *
4818  * scsi_status - SCSI Status code returned from target device
4819  * scsi_state - state info associated with SCSI_IO determined by ioc
4820  * ioc_status - ioc supplied status info
4821  */
4822 static void
4823 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4824         Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
4825 {
4826         u32 response_info;
4827         u8 *response_bytes;
4828         u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
4829             MPI2_IOCSTATUS_MASK;
4830         u8 scsi_state = mpi_reply->SCSIState;
4831         u8 scsi_status = mpi_reply->SCSIStatus;
4832         char *desc_ioc_state = NULL;
4833         char *desc_scsi_status = NULL;
4834         char *desc_scsi_state = ioc->tmp_string;
4835         u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4836         struct _sas_device *sas_device = NULL;
4837         struct _pcie_device *pcie_device = NULL;
4838         struct scsi_target *starget = scmd->device->sdev_target;
4839         struct MPT3SAS_TARGET *priv_target = starget->hostdata;
4840         char *device_str = NULL;
4841 
4842         if (!priv_target)
4843                 return;
4844         if (ioc->hide_ir_msg)
4845                 device_str = "WarpDrive";
4846         else
4847                 device_str = "volume";
4848 
4849         if (log_info == 0x31170000)
4850                 return;
4851 
4852         switch (ioc_status) {
4853         case MPI2_IOCSTATUS_SUCCESS:
4854                 desc_ioc_state = "success";
4855                 break;
4856         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4857                 desc_ioc_state = "invalid function";
4858                 break;
4859         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4860                 desc_ioc_state = "scsi recovered error";
4861                 break;
4862         case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
4863                 desc_ioc_state = "scsi invalid dev handle";
4864                 break;
4865         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4866                 desc_ioc_state = "scsi device not there";
4867                 break;
4868         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4869                 desc_ioc_state = "scsi data overrun";
4870                 break;
4871         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4872                 desc_ioc_state = "scsi data underrun";
4873                 break;
4874         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4875                 desc_ioc_state = "scsi io data error";
4876                 break;
4877         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4878                 desc_ioc_state = "scsi protocol error";
4879                 break;
4880         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4881                 desc_ioc_state = "scsi task terminated";
4882                 break;
4883         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4884                 desc_ioc_state = "scsi residual mismatch";
4885                 break;
4886         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4887                 desc_ioc_state = "scsi task mgmt failed";
4888                 break;
4889         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4890                 desc_ioc_state = "scsi ioc terminated";
4891                 break;
4892         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4893                 desc_ioc_state = "scsi ext terminated";
4894                 break;
4895         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4896                 desc_ioc_state = "eedp guard error";
4897                 break;
4898         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4899                 desc_ioc_state = "eedp ref tag error";
4900                 break;
4901         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4902                 desc_ioc_state = "eedp app tag error";
4903                 break;
4904         case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
4905                 desc_ioc_state = "insufficient power";
4906                 break;
4907         default:
4908                 desc_ioc_state = "unknown";
4909                 break;
4910         }
4911 
4912         switch (scsi_status) {
4913         case MPI2_SCSI_STATUS_GOOD:
4914                 desc_scsi_status = "good";
4915                 break;
4916         case MPI2_SCSI_STATUS_CHECK_CONDITION:
4917                 desc_scsi_status = "check condition";
4918                 break;
4919         case MPI2_SCSI_STATUS_CONDITION_MET:
4920                 desc_scsi_status = "condition met";
4921                 break;
4922         case MPI2_SCSI_STATUS_BUSY:
4923                 desc_scsi_status = "busy";
4924                 break;
4925         case MPI2_SCSI_STATUS_INTERMEDIATE:
4926                 desc_scsi_status = "intermediate";
4927                 break;
4928         case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
4929                 desc_scsi_status = "intermediate condmet";
4930                 break;
4931         case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
4932                 desc_scsi_status = "reservation conflict";
4933                 break;
4934         case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
4935                 desc_scsi_status = "command terminated";
4936                 break;
4937         case MPI2_SCSI_STATUS_TASK_SET_FULL:
4938                 desc_scsi_status = "task set full";
4939                 break;
4940         case MPI2_SCSI_STATUS_ACA_ACTIVE:
4941                 desc_scsi_status = "aca active";
4942                 break;
4943         case MPI2_SCSI_STATUS_TASK_ABORTED:
4944                 desc_scsi_status = "task aborted";
4945                 break;
4946         default:
4947                 desc_scsi_status = "unknown";
4948                 break;
4949         }
4950 
4951         desc_scsi_state[0] = '\0';
4952         if (!scsi_state)
4953                 desc_scsi_state = " ";
4954         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4955                 strcat(desc_scsi_state, "response info ");
4956         if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4957                 strcat(desc_scsi_state, "state terminated ");
4958         if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
4959                 strcat(desc_scsi_state, "no status ");
4960         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
4961                 strcat(desc_scsi_state, "autosense failed ");
4962         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
4963                 strcat(desc_scsi_state, "autosense valid ");
4964 
4965         scsi_print_command(scmd);
4966 
4967         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
4968                 ioc_warn(ioc, "\t%s wwid(0x%016llx)\n",
4969                          device_str, (u64)priv_target->sas_address);
4970         } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
4971                 pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target);
4972                 if (pcie_device) {
4973                         ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n",
4974                                  (u64)pcie_device->wwid, pcie_device->port_num);
4975                         if (pcie_device->enclosure_handle != 0)
4976                                 ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n",
4977                                          (u64)pcie_device->enclosure_logical_id,
4978                                          pcie_device->slot);
4979                         if (pcie_device->connector_name[0])
4980                                 ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n",
4981                                          pcie_device->enclosure_level,
4982                                          pcie_device->connector_name);
4983                         pcie_device_put(pcie_device);
4984                 }
4985         } else {
4986                 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
4987                 if (sas_device) {
4988                         ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
4989                                  (u64)sas_device->sas_address, sas_device->phy);
4990 
4991                         _scsih_display_enclosure_chassis_info(ioc, sas_device,
4992                             NULL, NULL);
4993 
4994                         sas_device_put(sas_device);
4995                 }
4996         }
4997 
4998         ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
4999                  le16_to_cpu(mpi_reply->DevHandle),
5000                  desc_ioc_state, ioc_status, smid);
5001         ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n",
5002                  scsi_bufflen(scmd), scmd->underflow, scsi_get_resid(scmd));
5003         ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
5004                  le16_to_cpu(mpi_reply->TaskTag),
5005                  le32_to_cpu(mpi_reply->TransferCount), scmd->result);
5006         ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
5007                  desc_scsi_status, scsi_status, desc_scsi_state, scsi_state);
5008 
5009         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
5010                 struct sense_info data;
5011                 _scsih_normalize_sense(scmd->sense_buffer, &data);
5012                 ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
5013                          data.skey, data.asc, data.ascq,
5014                          le32_to_cpu(mpi_reply->SenseCount));
5015         }
5016         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
5017                 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
5018                 response_bytes = (u8 *)&response_info;
5019                 _scsih_response_code(ioc, response_bytes[0]);
5020         }
5021 }
5022 
5023 /**
5024  * _scsih_turn_on_pfa_led - illuminate PFA LED
5025  * @ioc: per adapter object
5026  * @handle: device handle
5027  * Context: process
5028  */
5029 static void
5030 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5031 {
5032         Mpi2SepReply_t mpi_reply;
5033         Mpi2SepRequest_t mpi_request;
5034         struct _sas_device *sas_device;
5035 
5036         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
5037         if (!sas_device)
5038                 return;
5039 
5040         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
5041         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
5042         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
5043         mpi_request.SlotStatus =
5044             cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
5045         mpi_request.DevHandle = cpu_to_le16(handle);
5046         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
5047         if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5048             &mpi_request)) != 0) {
5049                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5050                         __FILE__, __LINE__, __func__);
5051                 goto out;
5052         }
5053         sas_device->pfa_led_on = 1;
5054 
5055         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
5056                 dewtprintk(ioc,
5057                            ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5058                                     le16_to_cpu(mpi_reply.IOCStatus),
5059                                     le32_to_cpu(mpi_reply.IOCLogInfo)));
5060                 goto out;
5061         }
5062 out:
5063         sas_device_put(sas_device);
5064 }
5065 
5066 /**
5067  * _scsih_turn_off_pfa_led - turn off Fault LED
5068  * @ioc: per adapter object
5069  * @sas_device: sas device whose PFA LED has to turned off
5070  * Context: process
5071  */
5072 static void
5073 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
5074         struct _sas_device *sas_device)
5075 {
5076         Mpi2SepReply_t mpi_reply;
5077         Mpi2SepRequest_t mpi_request;
5078 
5079         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
5080         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
5081         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
5082         mpi_request.SlotStatus = 0;
5083         mpi_request.Slot = cpu_to_le16(sas_device->slot);
5084         mpi_request.DevHandle = 0;
5085         mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle);
5086         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS;
5087         if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
5088                 &mpi_request)) != 0) {
5089                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5090                         __FILE__, __LINE__, __func__);
5091                 return;
5092         }
5093 
5094         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
5095                 dewtprintk(ioc,
5096                            ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
5097                                     le16_to_cpu(mpi_reply.IOCStatus),
5098                                     le32_to_cpu(mpi_reply.IOCLogInfo)));
5099                 return;
5100         }
5101 }
5102 
5103 /**
5104  * _scsih_send_event_to_turn_on_pfa_led - fire delayed event
5105  * @ioc: per adapter object
5106  * @handle: device handle
5107  * Context: interrupt.
5108  */
5109 static void
5110 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5111 {
5112         struct fw_event_work *fw_event;
5113 
5114         fw_event = alloc_fw_event_work(0);
5115         if (!fw_event)
5116                 return;
5117         fw_event->event = MPT3SAS_TURN_ON_PFA_LED;
5118         fw_event->device_handle = handle;
5119         fw_event->ioc = ioc;
5120         _scsih_fw_event_add(ioc, fw_event);
5121         fw_event_work_put(fw_event);
5122 }
5123 
5124 /**
5125  * _scsih_smart_predicted_fault - process smart errors
5126  * @ioc: per adapter object
5127  * @handle: device handle
5128  * Context: interrupt.
5129  */
5130 static void
5131 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5132 {
5133         struct scsi_target *starget;
5134         struct MPT3SAS_TARGET *sas_target_priv_data;
5135         Mpi2EventNotificationReply_t *event_reply;
5136         Mpi2EventDataSasDeviceStatusChange_t *event_data;
5137         struct _sas_device *sas_device;
5138         ssize_t sz;
5139         unsigned long flags;
5140 
5141         /* only handle non-raid devices */
5142         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5143         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
5144         if (!sas_device)
5145                 goto out_unlock;
5146 
5147         starget = sas_device->starget;
5148         sas_target_priv_data = starget->hostdata;
5149 
5150         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
5151            ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)))
5152                 goto out_unlock;
5153 
5154         _scsih_display_enclosure_chassis_info(NULL, sas_device, NULL, starget);
5155 
5156         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5157 
5158         if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
5159                 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
5160 
5161         /* insert into event log */
5162         sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
5163              sizeof(Mpi2EventDataSasDeviceStatusChange_t);
5164         event_reply = kzalloc(sz, GFP_KERNEL);
5165         if (!event_reply) {
5166                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5167                         __FILE__, __LINE__, __func__);
5168                 goto out;
5169         }
5170 
5171         event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
5172         event_reply->Event =
5173             cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
5174         event_reply->MsgLength = sz/4;
5175         event_reply->EventDataLength =
5176             cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
5177         event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
5178             event_reply->EventData;
5179         event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
5180         event_data->ASC = 0x5D;
5181         event_data->DevHandle = cpu_to_le16(handle);
5182         event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
5183         mpt3sas_ctl_add_to_event_log(ioc, event_reply);
5184         kfree(event_reply);
5185 out:
5186         if (sas_device)
5187                 sas_device_put(sas_device);
5188         return;
5189 
5190 out_unlock:
5191         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5192         goto out;
5193 }
5194 
5195 /**
5196  * _scsih_io_done - scsi request callback
5197  * @ioc: per adapter object
5198  * @smid: system request message index
5199  * @msix_index: MSIX table index supplied by the OS
5200  * @reply: reply message frame(lower 32bit addr)
5201  *
5202  * Callback handler when using _scsih_qcmd.
5203  *
5204  * Return: 1 meaning mf should be freed from _base_interrupt
5205  *         0 means the mf is freed from this function.
5206  */
5207 static u8
5208 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5209 {
5210         Mpi25SCSIIORequest_t *mpi_request;
5211         Mpi2SCSIIOReply_t *mpi_reply;
5212         struct scsi_cmnd *scmd;
5213         struct scsiio_tracker *st;
5214         u16 ioc_status;
5215         u32 xfer_cnt;
5216         u8 scsi_state;
5217         u8 scsi_status;
5218         u32 log_info;
5219         struct MPT3SAS_DEVICE *sas_device_priv_data;
5220         u32 response_code = 0;
5221 
5222         mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
5223 
5224         scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
5225         if (scmd == NULL)
5226                 return 1;
5227 
5228         _scsih_set_satl_pending(scmd, false);
5229 
5230         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
5231 
5232         if (mpi_reply == NULL) {
5233                 scmd->result = DID_OK << 16;
5234                 goto out;
5235         }
5236 
5237         sas_device_priv_data = scmd->device->hostdata;
5238         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
5239              sas_device_priv_data->sas_target->deleted) {
5240                 scmd->result = DID_NO_CONNECT << 16;
5241                 goto out;
5242         }
5243         ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
5244 
5245         /*
5246          * WARPDRIVE: If direct_io is set then it is directIO,
5247          * the failed direct I/O should be redirected to volume
5248          */
5249         st = scsi_cmd_priv(scmd);
5250         if (st->direct_io &&
5251              ((ioc_status & MPI2_IOCSTATUS_MASK)
5252               != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
5253                 st->direct_io = 0;
5254                 st->scmd = scmd;
5255                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
5256                 mpi_request->DevHandle =
5257                     cpu_to_le16(sas_device_priv_data->sas_target->handle);
5258                 ioc->put_smid_scsi_io(ioc, smid,
5259                     sas_device_priv_data->sas_target->handle);
5260                 return 0;
5261         }
5262         /* turning off TLR */
5263         scsi_state = mpi_reply->SCSIState;
5264         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
5265                 response_code =
5266                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
5267         if (!sas_device_priv_data->tlr_snoop_check) {
5268                 sas_device_priv_data->tlr_snoop_check++;
5269                 if ((!ioc->is_warpdrive &&
5270                     !scsih_is_raid(&scmd->device->sdev_gendev) &&
5271                     !scsih_is_nvme(&scmd->device->sdev_gendev))
5272                     && sas_is_tlr_enabled(scmd->device) &&
5273                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
5274                         sas_disable_tlr(scmd->device);
5275                         sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
5276                 }
5277         }
5278 
5279         xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
5280         scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
5281         if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
5282                 log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
5283         else
5284                 log_info = 0;
5285         ioc_status &= MPI2_IOCSTATUS_MASK;
5286         scsi_status = mpi_reply->SCSIStatus;
5287 
5288         if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
5289             (scsi_status == MPI2_SCSI_STATUS_BUSY ||
5290              scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
5291              scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
5292                 ioc_status = MPI2_IOCSTATUS_SUCCESS;
5293         }
5294 
5295         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
5296                 struct sense_info data;
5297                 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
5298                     smid);
5299                 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
5300                     le32_to_cpu(mpi_reply->SenseCount));
5301                 memcpy(scmd->sense_buffer, sense_data, sz);
5302                 _scsih_normalize_sense(scmd->sense_buffer, &data);
5303                 /* failure prediction threshold exceeded */
5304                 if (data.asc == 0x5D)
5305                         _scsih_smart_predicted_fault(ioc,
5306                             le16_to_cpu(mpi_reply->DevHandle));
5307                 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
5308 
5309                 if ((ioc->logging_level & MPT_DEBUG_REPLY) &&
5310                      ((scmd->sense_buffer[2] == UNIT_ATTENTION) ||
5311                      (scmd->sense_buffer[2] == MEDIUM_ERROR) ||
5312                      (scmd->sense_buffer[2] == HARDWARE_ERROR)))
5313                         _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid);
5314         }
5315         switch (ioc_status) {
5316         case MPI2_IOCSTATUS_BUSY:
5317         case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
5318                 scmd->result = SAM_STAT_BUSY;
5319                 break;
5320 
5321         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
5322                 scmd->result = DID_NO_CONNECT << 16;
5323                 break;
5324 
5325         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
5326                 if (sas_device_priv_data->block) {
5327                         scmd->result = DID_TRANSPORT_DISRUPTED << 16;
5328                         goto out;
5329                 }
5330                 if (log_info == 0x31110630) {
5331                         if (scmd->retries > 2) {
5332                                 scmd->result = DID_NO_CONNECT << 16;
5333                                 scsi_device_set_state(scmd->device,
5334                                     SDEV_OFFLINE);
5335                         } else {
5336                                 scmd->result = DID_SOFT_ERROR << 16;
5337                                 scmd->device->expecting_cc_ua = 1;
5338                         }
5339                         break;
5340                 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) {
5341                         scmd->result = DID_RESET << 16;
5342                         break;
5343                 } else if ((scmd->device->channel == RAID_CHANNEL) &&
5344                    (scsi_state == (MPI2_SCSI_STATE_TERMINATED |
5345                    MPI2_SCSI_STATE_NO_SCSI_STATUS))) {
5346                         scmd->result = DID_RESET << 16;
5347                         break;
5348                 }
5349                 scmd->result = DID_SOFT_ERROR << 16;
5350                 break;
5351         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
5352         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
5353                 scmd->result = DID_RESET << 16;
5354                 break;
5355 
5356         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
5357                 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
5358                         scmd->result = DID_SOFT_ERROR << 16;
5359                 else
5360                         scmd->result = (DID_OK << 16) | scsi_status;
5361                 break;
5362 
5363         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
5364                 scmd->result = (DID_OK << 16) | scsi_status;
5365 
5366                 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
5367                         break;
5368 
5369                 if (xfer_cnt < scmd->underflow) {
5370                         if (scsi_status == SAM_STAT_BUSY)
5371                                 scmd->result = SAM_STAT_BUSY;
5372                         else
5373                                 scmd->result = DID_SOFT_ERROR << 16;
5374                 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
5375                      MPI2_SCSI_STATE_NO_SCSI_STATUS))
5376                         scmd->result = DID_SOFT_ERROR << 16;
5377                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
5378                         scmd->result = DID_RESET << 16;
5379                 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
5380                         mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
5381                         mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
5382                         scmd->result = (DRIVER_SENSE << 24) |
5383                             SAM_STAT_CHECK_CONDITION;
5384                         scmd->sense_buffer[0] = 0x70;
5385                         scmd->sense_buffer[2] = ILLEGAL_REQUEST;
5386                         scmd->sense_buffer[12] = 0x20;
5387                         scmd->sense_buffer[13] = 0;
5388                 }
5389                 break;
5390 
5391         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
5392                 scsi_set_resid(scmd, 0);
5393                 /* fall through */
5394         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
5395         case MPI2_IOCSTATUS_SUCCESS:
5396                 scmd->result = (DID_OK << 16) | scsi_status;
5397                 if (response_code ==
5398                     MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
5399                     (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
5400                      MPI2_SCSI_STATE_NO_SCSI_STATUS)))
5401                         scmd->result = DID_SOFT_ERROR << 16;
5402                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
5403                         scmd->result = DID_RESET << 16;
5404                 break;
5405 
5406         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
5407         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
5408         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
5409                 _scsih_eedp_error_handling(scmd, ioc_status);
5410                 break;
5411 
5412         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
5413         case MPI2_IOCSTATUS_INVALID_FUNCTION:
5414         case MPI2_IOCSTATUS_INVALID_SGL:
5415         case MPI2_IOCSTATUS_INTERNAL_ERROR:
5416         case MPI2_IOCSTATUS_INVALID_FIELD:
5417         case MPI2_IOCSTATUS_INVALID_STATE:
5418         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
5419         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
5420         case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
5421         default:
5422                 scmd->result = DID_SOFT_ERROR << 16;
5423                 break;
5424 
5425         }
5426 
5427         if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
5428                 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
5429 
5430  out:
5431 
5432         scsi_dma_unmap(scmd);
5433         mpt3sas_base_free_smid(ioc, smid);
5434         scmd->scsi_done(scmd);
5435         return 0;
5436 }
5437 
5438 /**
5439  * _scsih_sas_host_refresh - refreshing sas host object contents
5440  * @ioc: per adapter object
5441  * Context: user
5442  *
5443  * During port enable, fw will send topology events for every device. Its
5444  * possible that the handles may change from the previous setting, so this
5445  * code keeping handles updating if changed.
5446  */
5447 static void
5448 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
5449 {
5450         u16 sz;
5451         u16 ioc_status;
5452         int i;
5453         Mpi2ConfigReply_t mpi_reply;
5454         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
5455         u16 attached_handle;
5456         u8 link_rate;
5457 
5458         dtmprintk(ioc,
5459                   ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n",
5460                            (u64)ioc->sas_hba.sas_address));
5461 
5462         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
5463             * sizeof(Mpi2SasIOUnit0PhyData_t));
5464         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
5465         if (!sas_iounit_pg0) {
5466                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5467                         __FILE__, __LINE__, __func__);
5468                 return;
5469         }
5470 
5471         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
5472             sas_iounit_pg0, sz)) != 0)
5473                 goto out;
5474         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5475         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5476                 goto out;
5477         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
5478                 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
5479                 if (i == 0)
5480                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
5481                             PhyData[0].ControllerDevHandle);
5482                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
5483                 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
5484                     AttachedDevHandle);
5485                 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5486                         link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
5487                 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
5488                     attached_handle, i, link_rate);
5489         }
5490  out:
5491         kfree(sas_iounit_pg0);
5492 }
5493 
5494 /**
5495  * _scsih_sas_host_add - create sas host object
5496  * @ioc: per adapter object
5497  *
5498  * Creating host side data object, stored in ioc->sas_hba
5499  */
5500 static void
5501 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
5502 {
5503         int i;
5504         Mpi2ConfigReply_t mpi_reply;
5505         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
5506         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
5507         Mpi2SasPhyPage0_t phy_pg0;
5508         Mpi2SasDevicePage0_t sas_device_pg0;
5509         Mpi2SasEnclosurePage0_t enclosure_pg0;
5510         u16 ioc_status;
5511         u16 sz;
5512         u8 device_missing_delay;
5513         u8 num_phys;
5514 
5515         mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
5516         if (!num_phys) {
5517                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5518                         __FILE__, __LINE__, __func__);
5519                 return;
5520         }
5521         ioc->sas_hba.phy = kcalloc(num_phys,
5522             sizeof(struct _sas_phy), GFP_KERNEL);
5523         if (!ioc->sas_hba.phy) {
5524                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5525                         __FILE__, __LINE__, __func__);
5526                 goto out;
5527         }
5528         ioc->sas_hba.num_phys = num_phys;
5529 
5530         /* sas_iounit page 0 */
5531         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
5532             sizeof(Mpi2SasIOUnit0PhyData_t));
5533         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
5534         if (!sas_iounit_pg0) {
5535                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5536                         __FILE__, __LINE__, __func__);
5537                 return;
5538         }
5539         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
5540             sas_iounit_pg0, sz))) {
5541                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5542                         __FILE__, __LINE__, __func__);
5543                 goto out;
5544         }
5545         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5546             MPI2_IOCSTATUS_MASK;
5547         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5548                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5549                         __FILE__, __LINE__, __func__);
5550                 goto out;
5551         }
5552 
5553         /* sas_iounit page 1 */
5554         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
5555             sizeof(Mpi2SasIOUnit1PhyData_t));
5556         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
5557         if (!sas_iounit_pg1) {
5558                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5559                         __FILE__, __LINE__, __func__);
5560                 goto out;
5561         }
5562         if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
5563             sas_iounit_pg1, sz))) {
5564                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5565                         __FILE__, __LINE__, __func__);
5566                 goto out;
5567         }
5568         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5569             MPI2_IOCSTATUS_MASK;
5570         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5571                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5572                         __FILE__, __LINE__, __func__);
5573                 goto out;
5574         }
5575 
5576         ioc->io_missing_delay =
5577             sas_iounit_pg1->IODeviceMissingDelay;
5578         device_missing_delay =
5579             sas_iounit_pg1->ReportDeviceMissingDelay;
5580         if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
5581                 ioc->device_missing_delay = (device_missing_delay &
5582                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
5583         else
5584                 ioc->device_missing_delay = device_missing_delay &
5585                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
5586 
5587         ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
5588         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
5589                 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
5590                     i))) {
5591                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
5592                                 __FILE__, __LINE__, __func__);
5593                         goto out;
5594                 }
5595                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5596                     MPI2_IOCSTATUS_MASK;
5597                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5598                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
5599                                 __FILE__, __LINE__, __func__);
5600                         goto out;
5601                 }
5602 
5603                 if (i == 0)
5604                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
5605                             PhyData[0].ControllerDevHandle);
5606                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
5607                 ioc->sas_hba.phy[i].phy_id = i;
5608                 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
5609                     phy_pg0, ioc->sas_hba.parent_dev);
5610         }
5611         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5612             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
5613                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5614                         __FILE__, __LINE__, __func__);
5615                 goto out;
5616         }
5617         ioc->sas_hba.enclosure_handle =
5618             le16_to_cpu(sas_device_pg0.EnclosureHandle);
5619         ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5620         ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
5621                  ioc->sas_hba.handle,
5622                  (u64)ioc->sas_hba.sas_address,
5623                  ioc->sas_hba.num_phys);
5624 
5625         if (ioc->sas_hba.enclosure_handle) {
5626                 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
5627                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5628                    ioc->sas_hba.enclosure_handle)))
5629                         ioc->sas_hba.enclosure_logical_id =
5630                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5631         }
5632 
5633  out:
5634         kfree(sas_iounit_pg1);
5635         kfree(sas_iounit_pg0);
5636 }
5637 
5638 /**
5639  * _scsih_expander_add -  creating expander object
5640  * @ioc: per adapter object
5641  * @handle: expander handle
5642  *
5643  * Creating expander object, stored in ioc->sas_expander_list.
5644  *
5645  * Return: 0 for success, else error.
5646  */
5647 static int
5648 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5649 {
5650         struct _sas_node *sas_expander;
5651         struct _enclosure_node *enclosure_dev;
5652         Mpi2ConfigReply_t mpi_reply;
5653         Mpi2ExpanderPage0_t expander_pg0;
5654         Mpi2ExpanderPage1_t expander_pg1;
5655         u32 ioc_status;
5656         u16 parent_handle;
5657         u64 sas_address, sas_address_parent = 0;
5658         int i;
5659         unsigned long flags;
5660         struct _sas_port *mpt3sas_port = NULL;
5661 
5662         int rc = 0;
5663 
5664         if (!handle)
5665                 return -1;
5666 
5667         if (ioc->shost_recovery || ioc->pci_error_recovery)
5668                 return -1;
5669 
5670         if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
5671             MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
5672                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5673                         __FILE__, __LINE__, __func__);
5674                 return -1;
5675         }
5676 
5677         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5678             MPI2_IOCSTATUS_MASK;
5679         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5680                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5681                         __FILE__, __LINE__, __func__);
5682                 return -1;
5683         }
5684 
5685         /* handle out of order topology events */
5686         parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
5687         if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
5688             != 0) {
5689                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5690                         __FILE__, __LINE__, __func__);
5691                 return -1;
5692         }
5693         if (sas_address_parent != ioc->sas_hba.sas_address) {
5694                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5695                 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5696                     sas_address_parent);
5697                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5698                 if (!sas_expander) {
5699                         rc = _scsih_expander_add(ioc, parent_handle);
5700                         if (rc != 0)
5701                                 return rc;
5702                 }
5703         }
5704 
5705         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5706         sas_address = le64_to_cpu(expander_pg0.SASAddress);
5707         sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5708             sas_address);
5709         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5710 
5711         if (sas_expander)
5712                 return 0;
5713 
5714         sas_expander = kzalloc(sizeof(struct _sas_node),
5715             GFP_KERNEL);
5716         if (!sas_expander) {
5717                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5718                         __FILE__, __LINE__, __func__);
5719                 return -1;
5720         }
5721 
5722         sas_expander->handle = handle;
5723         sas_expander->num_phys = expander_pg0.NumPhys;
5724         sas_expander->sas_address_parent = sas_address_parent;
5725         sas_expander->sas_address = sas_address;
5726 
5727         ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
5728                  handle, parent_handle,
5729                  (u64)sas_expander->sas_address, sas_expander->num_phys);
5730 
5731         if (!sas_expander->num_phys)
5732                 goto out_fail;
5733         sas_expander->phy = kcalloc(sas_expander->num_phys,
5734             sizeof(struct _sas_phy), GFP_KERNEL);
5735         if (!sas_expander->phy) {
5736                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5737                         __FILE__, __LINE__, __func__);
5738                 rc = -1;
5739                 goto out_fail;
5740         }
5741 
5742         INIT_LIST_HEAD(&sas_expander->sas_port_list);
5743         mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
5744             sas_address_parent);
5745         if (!mpt3sas_port) {
5746                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
5747                         __FILE__, __LINE__, __func__);
5748                 rc = -1;
5749                 goto out_fail;
5750         }
5751         sas_expander->parent_dev = &mpt3sas_port->rphy->dev;
5752 
5753         for (i = 0 ; i < sas_expander->num_phys ; i++) {
5754                 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
5755                     &expander_pg1, i, handle))) {
5756                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
5757                                 __FILE__, __LINE__, __func__);
5758                         rc = -1;
5759                         goto out_fail;
5760                 }
5761                 sas_expander->phy[i].handle = handle;
5762                 sas_expander->phy[i].phy_id = i;
5763 
5764                 if ((mpt3sas_transport_add_expander_phy(ioc,
5765                     &sas_expander->phy[i], expander_pg1,
5766                     sas_expander->parent_dev))) {
5767                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
5768                                 __FILE__, __LINE__, __func__);
5769                         rc = -1;
5770                         goto out_fail;
5771                 }
5772         }
5773 
5774         if (sas_expander->enclosure_handle) {
5775                 enclosure_dev =
5776                         mpt3sas_scsih_enclosure_find_by_handle(ioc,
5777                                                 sas_expander->enclosure_handle);
5778                 if (enclosure_dev)
5779                         sas_expander->enclosure_logical_id =
5780                             le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
5781         }
5782 
5783         _scsih_expander_node_add(ioc, sas_expander);
5784         return 0;
5785 
5786  out_fail:
5787 
5788         if (mpt3sas_port)
5789                 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
5790                     sas_address_parent);
5791         kfree(sas_expander);
5792         return rc;
5793 }
5794 
5795 /**
5796  * mpt3sas_expander_remove - removing expander object
5797  * @ioc: per adapter object
5798  * @sas_address: expander sas_address
5799  */
5800 void
5801 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
5802 {
5803         struct _sas_node *sas_expander;
5804         unsigned long flags;
5805 
5806         if (ioc->shost_recovery)
5807                 return;
5808 
5809         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5810         sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5811             sas_address);
5812         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5813         if (sas_expander)
5814                 _scsih_expander_node_remove(ioc, sas_expander);
5815 }
5816 
5817 /**
5818  * _scsih_done -  internal SCSI_IO callback handler.
5819  * @ioc: per adapter object
5820  * @smid: system request message index
5821  * @msix_index: MSIX table index supplied by the OS
5822  * @reply: reply message frame(lower 32bit addr)
5823  *
5824  * Callback handler when sending internal generated SCSI_IO.
5825  * The callback index passed is `ioc->scsih_cb_idx`
5826  *
5827  * Return: 1 meaning mf should be freed from _base_interrupt
5828  *         0 means the mf is freed from this function.
5829  */
5830 static u8
5831 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5832 {
5833         MPI2DefaultReply_t *mpi_reply;
5834 
5835         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
5836         if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
5837                 return 1;
5838         if (ioc->scsih_cmds.smid != smid)
5839                 return 1;
5840         ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
5841         if (mpi_reply) {
5842                 memcpy(ioc->scsih_cmds.reply, mpi_reply,
5843                     mpi_reply->MsgLength*4);
5844                 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
5845         }
5846         ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
5847         complete(&ioc->scsih_cmds.done);
5848         return 1;
5849 }
5850 
5851 
5852 
5853 
5854 #define MPT3_MAX_LUNS (255)
5855 
5856 
5857 /**
5858  * _scsih_check_access_status - check access flags
5859  * @ioc: per adapter object
5860  * @sas_address: sas address
5861  * @handle: sas device handle
5862  * @access_status: errors returned during discovery of the device
5863  *
5864  * Return: 0 for success, else failure
5865  */
5866 static u8
5867 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
5868         u16 handle, u8 access_status)
5869 {
5870         u8 rc = 1;
5871         char *desc = NULL;
5872 
5873         switch (access_status) {
5874         case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
5875         case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
5876                 rc = 0;
5877                 break;
5878         case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
5879                 desc = "sata capability failed";
5880                 break;
5881         case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
5882                 desc = "sata affiliation conflict";
5883                 break;
5884         case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
5885                 desc = "route not addressable";
5886                 break;
5887         case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
5888                 desc = "smp error not addressable";
5889                 break;
5890         case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
5891                 desc = "device blocked";
5892                 break;
5893         case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
5894         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
5895         case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
5896         case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
5897         case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
5898         case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
5899         case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
5900         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
5901         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
5902         case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
5903         case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
5904         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
5905                 desc = "sata initialization failed";
5906                 break;
5907         default:
5908                 desc = "unknown";
5909                 break;
5910         }
5911 
5912         if (!rc)
5913                 return 0;
5914 
5915         ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
5916                 desc, (u64)sas_address, handle);
5917         return rc;
5918 }
5919 
5920 /**
5921  * _scsih_check_device - checking device responsiveness
5922  * @ioc: per adapter object
5923  * @parent_sas_address: sas address of parent expander or sas host
5924  * @handle: attached device handle
5925  * @phy_number: phy number
5926  * @link_rate: new link rate
5927  */
5928 static void
5929 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
5930         u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate)
5931 {
5932         Mpi2ConfigReply_t mpi_reply;
5933         Mpi2SasDevicePage0_t sas_device_pg0;
5934         struct _sas_device *sas_device;
5935         struct _enclosure_node *enclosure_dev = NULL;
5936         u32 ioc_status;
5937         unsigned long flags;
5938         u64 sas_address;
5939         struct scsi_target *starget;
5940         struct MPT3SAS_TARGET *sas_target_priv_data;
5941         u32 device_info;
5942 
5943         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5944             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
5945                 return;
5946 
5947         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5948         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5949                 return;
5950 
5951         /* wide port handling ~ we need only handle device once for the phy that
5952          * is matched in sas device page zero
5953          */
5954         if (phy_number != sas_device_pg0.PhyNum)
5955                 return;
5956 
5957         /* check if this is end device */
5958         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5959         if (!(_scsih_is_end_device(device_info)))
5960                 return;
5961 
5962         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5963         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5964         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
5965             sas_address);
5966 
5967         if (!sas_device)
5968                 goto out_unlock;
5969 
5970         if (unlikely(sas_device->handle != handle)) {
5971                 starget = sas_device->starget;
5972                 sas_target_priv_data = starget->hostdata;
5973                 starget_printk(KERN_INFO, starget,
5974                         "handle changed from(0x%04x) to (0x%04x)!!!\n",
5975                         sas_device->handle, handle);
5976                 sas_target_priv_data->handle = handle;
5977                 sas_device->handle = handle;
5978                 if (le16_to_cpu(sas_device_pg0.Flags) &
5979                      MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
5980                         sas_device->enclosure_level =
5981                                 sas_device_pg0.EnclosureLevel;
5982                         memcpy(sas_device->connector_name,
5983                                 sas_device_pg0.ConnectorName, 4);
5984                         sas_device->connector_name[4] = '\0';
5985                 } else {
5986                         sas_device->enclosure_level = 0;
5987                         sas_device->connector_name[0] = '\0';
5988                 }
5989 
5990                 sas_device->enclosure_handle =
5991                                 le16_to_cpu(sas_device_pg0.EnclosureHandle);
5992                 sas_device->is_chassis_slot_valid = 0;
5993                 enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle(ioc,
5994                                                 sas_device->enclosure_handle);
5995                 if (enclosure_dev) {
5996                         sas_device->enclosure_logical_id =
5997                             le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
5998                         if (le16_to_cpu(enclosure_dev->pg0.Flags) &
5999                             MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) {
6000                                 sas_device->is_chassis_slot_valid = 1;
6001                                 sas_device->chassis_slot =
6002                                         enclosure_dev->pg0.ChassisSlot;
6003                         }
6004                 }
6005         }
6006 
6007         /* check if device is present */
6008         if (!(le16_to_cpu(sas_device_pg0.Flags) &
6009             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
6010                 ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n",
6011                         handle);
6012                 goto out_unlock;
6013         }
6014 
6015         /* check if there were any issues with discovery */
6016         if (_scsih_check_access_status(ioc, sas_address, handle,
6017             sas_device_pg0.AccessStatus))
6018                 goto out_unlock;
6019 
6020         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6021         _scsih_ublock_io_device(ioc, sas_address);
6022 
6023         if (sas_device)
6024                 sas_device_put(sas_device);
6025         return;
6026 
6027 out_unlock:
6028         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6029         if (sas_device)
6030                 sas_device_put(sas_device);
6031 }
6032 
6033 /**
6034  * _scsih_add_device -  creating sas device object
6035  * @ioc: per adapter object
6036  * @handle: sas device handle
6037  * @phy_num: phy number end device attached to
6038  * @is_pd: is this hidden raid component
6039  *
6040  * Creating end device object, stored in ioc->sas_device_list.
6041  *
6042  * Return: 0 for success, non-zero for failure.
6043  */
6044 static int
6045 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
6046         u8 is_pd)
6047 {
6048         Mpi2ConfigReply_t mpi_reply;
6049         Mpi2SasDevicePage0_t sas_device_pg0;
6050         struct _sas_device *sas_device;
6051         struct _enclosure_node *enclosure_dev = NULL;
6052         u32 ioc_status;
6053         u64 sas_address;
6054         u32 device_info;
6055 
6056         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6057             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
6058                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6059                         __FILE__, __LINE__, __func__);
6060                 return -1;
6061         }
6062 
6063         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6064             MPI2_IOCSTATUS_MASK;
6065         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6066                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6067                         __FILE__, __LINE__, __func__);
6068                 return -1;
6069         }
6070 
6071         /* check if this is end device */
6072         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
6073         if (!(_scsih_is_end_device(device_info)))
6074                 return -1;
6075         set_bit(handle, ioc->pend_os_device_add);
6076         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
6077 
6078         /* check if device is present */
6079         if (!(le16_to_cpu(sas_device_pg0.Flags) &
6080             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
6081                 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
6082                         handle);
6083                 return -1;
6084         }
6085 
6086         /* check if there were any issues with discovery */
6087         if (_scsih_check_access_status(ioc, sas_address, handle,
6088             sas_device_pg0.AccessStatus))
6089                 return -1;
6090 
6091         sas_device = mpt3sas_get_sdev_by_addr(ioc,
6092                                         sas_address);
6093         if (sas_device) {
6094                 clear_bit(handle, ioc->pend_os_device_add);
6095                 sas_device_put(sas_device);
6096                 return -1;
6097         }
6098 
6099         if (sas_device_pg0.EnclosureHandle) {
6100                 enclosure_dev =
6101                         mpt3sas_scsih_enclosure_find_by_handle(ioc,
6102                             le16_to_cpu(sas_device_pg0.EnclosureHandle));
6103                 if (enclosure_dev == NULL)
6104                         ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
6105                                  sas_device_pg0.EnclosureHandle);
6106         }
6107 
6108         sas_device = kzalloc(sizeof(struct _sas_device),
6109             GFP_KERNEL);
6110         if (!sas_device) {
6111                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6112                         __FILE__, __LINE__, __func__);
6113                 return 0;
6114         }
6115 
6116         kref_init(&sas_device->refcount);
6117         sas_device->handle = handle;
6118         if (_scsih_get_sas_address(ioc,
6119             le16_to_cpu(sas_device_pg0.ParentDevHandle),
6120             &sas_device->sas_address_parent) != 0)
6121                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6122                         __FILE__, __LINE__, __func__);
6123         sas_device->enclosure_handle =
6124             le16_to_cpu(sas_device_pg0.EnclosureHandle);
6125         if (sas_device->enclosure_handle != 0)
6126                 sas_device->slot =
6127                     le16_to_cpu(sas_device_pg0.Slot);
6128         sas_device->device_info = device_info;
6129         sas_device->sas_address = sas_address;
6130         sas_device->phy = sas_device_pg0.PhyNum;
6131         sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) &
6132             MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
6133 
6134         if (le16_to_cpu(sas_device_pg0.Flags)
6135                 & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
6136                 sas_device->enclosure_level =
6137                         sas_device_pg0.EnclosureLevel;
6138                 memcpy(sas_device->connector_name,
6139                         sas_device_pg0.ConnectorName, 4);
6140                 sas_device->connector_name[4] = '\0';
6141         } else {
6142                 sas_device->enclosure_level = 0;
6143                 sas_device->connector_name[0] = '\0';
6144         }
6145         /* get enclosure_logical_id & chassis_slot*/
6146         sas_device->is_chassis_slot_valid = 0;
6147         if (enclosure_dev) {
6148                 sas_device->enclosure_logical_id =
6149                     le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
6150                 if (le16_to_cpu(enclosure_dev->pg0.Flags) &
6151                     MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) {
6152                         sas_device->is_chassis_slot_valid = 1;
6153                         sas_device->chassis_slot =
6154                                         enclosure_dev->pg0.ChassisSlot;
6155                 }
6156         }
6157 
6158         /* get device name */
6159         sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
6160 
6161         if (ioc->wait_for_discovery_to_complete)
6162                 _scsih_sas_device_init_add(ioc, sas_device);
6163         else
6164                 _scsih_sas_device_add(ioc, sas_device);
6165 
6166         sas_device_put(sas_device);
6167         return 0;
6168 }
6169 
6170 /**
6171  * _scsih_remove_device -  removing sas device object
6172  * @ioc: per adapter object
6173  * @sas_device: the sas_device object
6174  */
6175 static void
6176 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
6177         struct _sas_device *sas_device)
6178 {
6179         struct MPT3SAS_TARGET *sas_target_priv_data;
6180 
6181         if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
6182              (sas_device->pfa_led_on)) {
6183                 _scsih_turn_off_pfa_led(ioc, sas_device);
6184                 sas_device->pfa_led_on = 0;
6185         }
6186 
6187         dewtprintk(ioc,
6188                    ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
6189                             __func__,
6190                             sas_device->handle, (u64)sas_device->sas_address));
6191 
6192         dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
6193             NULL, NULL));
6194 
6195         if (sas_device->starget && sas_device->starget->hostdata) {
6196                 sas_target_priv_data = sas_device->starget->hostdata;
6197                 sas_target_priv_data->deleted = 1;
6198                 _scsih_ublock_io_device(ioc, sas_device->sas_address);
6199                 sas_target_priv_data->handle =
6200                      MPT3SAS_INVALID_DEVICE_HANDLE;
6201         }
6202 
6203         if (!ioc->hide_drives)
6204                 mpt3sas_transport_port_remove(ioc,
6205                     sas_device->sas_address,
6206                     sas_device->sas_address_parent);
6207 
6208         ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
6209                  sas_device->handle, (u64)sas_device->sas_address);
6210 
6211         _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
6212 
6213         dewtprintk(ioc,
6214                    ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
6215                             __func__,
6216                             sas_device->handle, (u64)sas_device->sas_address));
6217         dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
6218             NULL, NULL));
6219 }
6220 
6221 /**
6222  * _scsih_sas_topology_change_event_debug - debug for topology event
6223  * @ioc: per adapter object
6224  * @event_data: event data payload
6225  * Context: user.
6226  */
6227 static void
6228 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6229         Mpi2EventDataSasTopologyChangeList_t *event_data)
6230 {
6231         int i;
6232         u16 handle;
6233         u16 reason_code;
6234         u8 phy_number;
6235         char *status_str = NULL;
6236         u8 link_rate, prev_link_rate;
6237 
6238         switch (event_data->ExpStatus) {
6239         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
6240                 status_str = "add";
6241                 break;
6242         case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
6243                 status_str = "remove";
6244                 break;
6245         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
6246         case 0:
6247                 status_str =  "responding";
6248                 break;
6249         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
6250                 status_str = "remove delay";
6251                 break;
6252         default:
6253                 status_str = "unknown status";
6254                 break;
6255         }
6256         ioc_info(ioc, "sas topology change: (%s)\n", status_str);
6257         pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
6258             "start_phy(%02d), count(%d)\n",
6259             le16_to_cpu(event_data->ExpanderDevHandle),
6260             le16_to_cpu(event_data->EnclosureHandle),
6261             event_data->StartPhyNum, event_data->NumEntries);
6262         for (i = 0; i < event_data->NumEntries; i++) {
6263                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
6264                 if (!handle)
6265                         continue;
6266                 phy_number = event_data->StartPhyNum + i;
6267                 reason_code = event_data->PHY[i].PhyStatus &
6268                     MPI2_EVENT_SAS_TOPO_RC_MASK;
6269                 switch (reason_code) {
6270                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
6271                         status_str = "target add";
6272                         break;
6273                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
6274                         status_str = "target remove";
6275                         break;
6276                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
6277                         status_str = "delay target remove";
6278                         break;
6279                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
6280                         status_str = "link rate change";
6281                         break;
6282                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
6283                         status_str = "target responding";
6284                         break;
6285                 default:
6286                         status_str = "unknown";
6287                         break;
6288                 }
6289                 link_rate = event_data->PHY[i].LinkRate >> 4;
6290                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
6291                 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \
6292                     " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
6293                     handle, status_str, link_rate, prev_link_rate);
6294 
6295         }
6296 }
6297 
6298 /**
6299  * _scsih_sas_topology_change_event - handle topology changes
6300  * @ioc: per adapter object
6301  * @fw_event: The fw_event_work object
6302  * Context: user.
6303  *
6304  */
6305 static int
6306 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
6307         struct fw_event_work *fw_event)
6308 {
6309         int i;
6310         u16 parent_handle, handle;
6311         u16 reason_code;
6312         u8 phy_number, max_phys;
6313         struct _sas_node *sas_expander;
6314         u64 sas_address;
6315         unsigned long flags;
6316         u8 link_rate, prev_link_rate;
6317         Mpi2EventDataSasTopologyChangeList_t *event_data =
6318                 (Mpi2EventDataSasTopologyChangeList_t *)
6319                 fw_event->event_data;
6320 
6321         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6322                 _scsih_sas_topology_change_event_debug(ioc, event_data);
6323 
6324         if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
6325                 return 0;
6326 
6327         if (!ioc->sas_hba.num_phys)
6328                 _scsih_sas_host_add(ioc);
6329         else
6330                 _scsih_sas_host_refresh(ioc);
6331 
6332         if (fw_event->ignore) {
6333                 dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n"));
6334                 return 0;
6335         }
6336 
6337         parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
6338 
6339         /* handle expander add */
6340         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
6341                 if (_scsih_expander_add(ioc, parent_handle) != 0)
6342                         return 0;
6343 
6344         spin_lock_irqsave(&ioc->sas_node_lock, flags);
6345         sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
6346             parent_handle);
6347         if (sas_expander) {
6348                 sas_address = sas_expander->sas_address;
6349                 max_phys = sas_expander->num_phys;
6350         } else if (parent_handle < ioc->sas_hba.num_phys) {
6351                 sas_address = ioc->sas_hba.sas_address;
6352                 max_phys = ioc->sas_hba.num_phys;
6353         } else {
6354                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6355                 return 0;
6356         }
6357         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
6358 
6359         /* handle siblings events */
6360         for (i = 0; i < event_data->NumEntries; i++) {
6361                 if (fw_event->ignore) {
6362                         dewtprintk(ioc,
6363                                    ioc_info(ioc, "ignoring expander event\n"));
6364                         return 0;
6365                 }
6366                 if (ioc->remove_host || ioc->pci_error_recovery)
6367                         return 0;
6368                 phy_number = event_data->StartPhyNum + i;
6369                 if (phy_number >= max_phys)
6370                         continue;
6371                 reason_code = event_data->PHY[i].PhyStatus &
6372                     MPI2_EVENT_SAS_TOPO_RC_MASK;
6373                 if ((event_data->PHY[i].PhyStatus &
6374                     MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
6375                     MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
6376                                 continue;
6377                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
6378                 if (!handle)
6379                         continue;
6380                 link_rate = event_data->PHY[i].LinkRate >> 4;
6381                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
6382                 switch (reason_code) {
6383                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
6384 
6385                         if (ioc->shost_recovery)
6386                                 break;
6387 
6388                         if (link_rate == prev_link_rate)
6389                                 break;
6390 
6391                         mpt3sas_transport_update_links(ioc, sas_address,
6392                             handle, phy_number, link_rate);
6393 
6394                         if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
6395                                 break;
6396 
6397                         _scsih_check_device(ioc, sas_address, handle,
6398                             phy_number, link_rate);
6399 
6400                         if (!test_bit(handle, ioc->pend_os_device_add))
6401                                 break;
6402 
6403                         /* fall through */
6404 
6405                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
6406 
6407                         if (ioc->shost_recovery)
6408                                 break;
6409 
6410                         mpt3sas_transport_update_links(ioc, sas_address,
6411                             handle, phy_number, link_rate);
6412 
6413                         _scsih_add_device(ioc, handle, phy_number, 0);
6414 
6415                         break;
6416                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
6417 
6418                         _scsih_device_remove_by_handle(ioc, handle);
6419                         break;
6420                 }
6421         }
6422 
6423         /* handle expander removal */
6424         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
6425             sas_expander)
6426                 mpt3sas_expander_remove(ioc, sas_address);
6427 
6428         return 0;
6429 }
6430 
6431 /**
6432  * _scsih_sas_device_status_change_event_debug - debug for device event
6433  * @ioc: ?
6434  * @event_data: event data payload
6435  * Context: user.
6436  */
6437 static void
6438 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6439         Mpi2EventDataSasDeviceStatusChange_t *event_data)
6440 {
6441         char *reason_str = NULL;
6442 
6443         switch (event_data->ReasonCode) {
6444         case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
6445                 reason_str = "smart data";
6446                 break;
6447         case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
6448                 reason_str = "unsupported device discovered";
6449                 break;
6450         case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
6451                 reason_str = "internal device reset";
6452                 break;
6453         case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
6454                 reason_str = "internal task abort";
6455                 break;
6456         case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
6457                 reason_str = "internal task abort set";
6458                 break;
6459         case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
6460                 reason_str = "internal clear task set";
6461                 break;
6462         case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
6463                 reason_str = "internal query task";
6464                 break;
6465         case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
6466                 reason_str = "sata init failure";
6467                 break;
6468         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
6469                 reason_str = "internal device reset complete";
6470                 break;
6471         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
6472                 reason_str = "internal task abort complete";
6473                 break;
6474         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
6475                 reason_str = "internal async notification";
6476                 break;
6477         case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
6478                 reason_str = "expander reduced functionality";
6479                 break;
6480         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
6481                 reason_str = "expander reduced functionality complete";
6482                 break;
6483         default:
6484                 reason_str = "unknown reason";
6485                 break;
6486         }
6487         ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
6488                  reason_str, le16_to_cpu(event_data->DevHandle),
6489                  (u64)le64_to_cpu(event_data->SASAddress),
6490                  le16_to_cpu(event_data->TaskTag));
6491         if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
6492                 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n",
6493                         event_data->ASC, event_data->ASCQ);
6494         pr_cont("\n");
6495 }
6496 
6497 /**
6498  * _scsih_sas_device_status_change_event - handle device status change
6499  * @ioc: per adapter object
6500  * @event_data: The fw event
6501  * Context: user.
6502  */
6503 static void
6504 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
6505         Mpi2EventDataSasDeviceStatusChange_t *event_data)
6506 {
6507         struct MPT3SAS_TARGET *target_priv_data;
6508         struct _sas_device *sas_device;
6509         u64 sas_address;
6510         unsigned long flags;
6511 
6512         /* In MPI Revision K (0xC), the internal device reset complete was
6513          * implemented, so avoid setting tm_busy flag for older firmware.
6514          */
6515         if ((ioc->facts.HeaderVersion >> 8) < 0xC)
6516                 return;
6517 
6518         if (event_data->ReasonCode !=
6519             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
6520            event_data->ReasonCode !=
6521             MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
6522                 return;
6523 
6524         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6525         sas_address = le64_to_cpu(event_data->SASAddress);
6526         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
6527             sas_address);
6528 
6529         if (!sas_device || !sas_device->starget)
6530                 goto out;
6531 
6532         target_priv_data = sas_device->starget->hostdata;
6533         if (!target_priv_data)
6534                 goto out;
6535 
6536         if (event_data->ReasonCode ==
6537             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
6538                 target_priv_data->tm_busy = 1;
6539         else
6540                 target_priv_data->tm_busy = 0;
6541 
6542         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6543                 ioc_info(ioc,
6544                     "%s tm_busy flag for handle(0x%04x)\n",
6545                     (target_priv_data->tm_busy == 1) ? "Enable" : "Disable",
6546                     target_priv_data->handle);
6547 
6548 out:
6549         if (sas_device)
6550                 sas_device_put(sas_device);
6551 
6552         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6553 }
6554 
6555 
6556 /**
6557  * _scsih_check_pcie_access_status - check access flags
6558  * @ioc: per adapter object
6559  * @wwid: wwid
6560  * @handle: sas device handle
6561  * @access_status: errors returned during discovery of the device
6562  *
6563  * Return: 0 for success, else failure
6564  */
6565 static u8
6566 _scsih_check_pcie_access_status(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
6567         u16 handle, u8 access_status)
6568 {
6569         u8 rc = 1;
6570         char *desc = NULL;
6571 
6572         switch (access_status) {
6573         case MPI26_PCIEDEV0_ASTATUS_NO_ERRORS:
6574         case MPI26_PCIEDEV0_ASTATUS_NEEDS_INITIALIZATION:
6575                 rc = 0;
6576                 break;
6577         case MPI26_PCIEDEV0_ASTATUS_CAPABILITY_FAILED:
6578                 desc = "PCIe device capability failed";
6579                 break;
6580         case MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED:
6581                 desc = "PCIe device blocked";
6582                 ioc_info(ioc,
6583                     "Device with Access Status (%s): wwid(0x%016llx), "
6584                     "handle(0x%04x)\n ll only be added to the internal list",
6585                     desc, (u64)wwid, handle);
6586                 rc = 0;
6587                 break;
6588         case MPI26_PCIEDEV0_ASTATUS_MEMORY_SPACE_ACCESS_FAILED:
6589                 desc = "PCIe device mem space access failed";
6590                 break;
6591         case MPI26_PCIEDEV0_ASTATUS_UNSUPPORTED_DEVICE:
6592                 desc = "PCIe device unsupported";
6593                 break;
6594         case MPI26_PCIEDEV0_ASTATUS_MSIX_REQUIRED:
6595                 desc = "PCIe device MSIx Required";
6596                 break;
6597         case MPI26_PCIEDEV0_ASTATUS_INIT_FAIL_MAX:
6598                 desc = "PCIe device init fail max";
6599                 break;
6600         case MPI26_PCIEDEV0_ASTATUS_UNKNOWN:
6601                 desc = "PCIe device status unknown";
6602                 break;
6603         case MPI26_PCIEDEV0_ASTATUS_NVME_READY_TIMEOUT:
6604                 desc = "nvme ready timeout";
6605                 break;
6606         case MPI26_PCIEDEV0_ASTATUS_NVME_DEVCFG_UNSUPPORTED:
6607                 desc = "nvme device configuration unsupported";
6608                 break;
6609         case MPI26_PCIEDEV0_ASTATUS_NVME_IDENTIFY_FAILED:
6610                 desc = "nvme identify failed";
6611                 break;
6612         case MPI26_PCIEDEV0_ASTATUS_NVME_QCONFIG_FAILED:
6613                 desc = "nvme qconfig failed";
6614                 break;
6615         case MPI26_PCIEDEV0_ASTATUS_NVME_QCREATION_FAILED:
6616                 desc = "nvme qcreation failed";
6617                 break;
6618         case MPI26_PCIEDEV0_ASTATUS_NVME_EVENTCFG_FAILED:
6619                 desc = "nvme eventcfg failed";
6620                 break;
6621         case MPI26_PCIEDEV0_ASTATUS_NVME_GET_FEATURE_STAT_FAILED:
6622                 desc = "nvme get feature stat failed";
6623                 break;
6624         case MPI26_PCIEDEV0_ASTATUS_NVME_IDLE_TIMEOUT:
6625                 desc = "nvme idle timeout";
6626                 break;
6627         case MPI26_PCIEDEV0_ASTATUS_NVME_FAILURE_STATUS:
6628                 desc = "nvme failure status";
6629                 break;
6630         default:
6631                 ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n",
6632                         access_status, (u64)wwid, handle);
6633                 return rc;
6634         }
6635 
6636         if (!rc)
6637                 return rc;
6638 
6639         ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n",
6640                  desc, (u64)wwid, handle);
6641         return rc;
6642 }
6643 
6644 /**
6645  * _scsih_pcie_device_remove_from_sml -  removing pcie device
6646  * from SML and free up associated memory
6647  * @ioc: per adapter object
6648  * @pcie_device: the pcie_device object
6649  */
6650 static void
6651 _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,
6652         struct _pcie_device *pcie_device)
6653 {
6654         struct MPT3SAS_TARGET *sas_target_priv_data;
6655 
6656         dewtprintk(ioc,
6657                    ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n",
6658                             __func__,
6659                             pcie_device->handle, (u64)pcie_device->wwid));
6660         if (pcie_device->enclosure_handle != 0)
6661                 dewtprintk(ioc,
6662                            ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
6663                                     __func__,
6664                                     (u64)pcie_device->enclosure_logical_id,
6665                                     pcie_device->slot));
6666         if (pcie_device->connector_name[0] != '\0')
6667                 dewtprintk(ioc,
6668                            ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n",
6669                                     __func__,
6670                                     pcie_device->enclosure_level,
6671                                     pcie_device->connector_name));
6672 
6673         if (pcie_device->starget && pcie_device->starget->hostdata) {
6674                 sas_target_priv_data = pcie_device->starget->hostdata;
6675                 sas_target_priv_data->deleted = 1;
6676                 _scsih_ublock_io_device(ioc, pcie_device->wwid);
6677                 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
6678         }
6679 
6680         ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
6681                  pcie_device->handle, (u64)pcie_device->wwid);
6682         if (pcie_device->enclosure_handle != 0)
6683                 ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n",
6684                          (u64)pcie_device->enclosure_logical_id,
6685                          pcie_device->slot);
6686         if (pcie_device->connector_name[0] != '\0')
6687                 ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n",
6688                          pcie_device->enclosure_level,
6689                          pcie_device->connector_name);
6690 
6691         if (pcie_device->starget && (pcie_device->access_status !=
6692                                 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED))
6693                 scsi_remove_target(&pcie_device->starget->dev);
6694         dewtprintk(ioc,
6695                    ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n",
6696                             __func__,
6697                             pcie_device->handle, (u64)pcie_device->wwid));
6698         if (pcie_device->enclosure_handle != 0)
6699                 dewtprintk(ioc,
6700                            ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
6701                                     __func__,
6702                                     (u64)pcie_device->enclosure_logical_id,
6703                                     pcie_device->slot));
6704         if (pcie_device->connector_name[0] != '\0')
6705                 dewtprintk(ioc,
6706                            ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n",
6707                                     __func__,
6708                                     pcie_device->enclosure_level,
6709                                     pcie_device->connector_name));
6710 
6711         kfree(pcie_device->serial_number);
6712 }
6713 
6714 
6715 /**
6716  * _scsih_pcie_check_device - checking device responsiveness
6717  * @ioc: per adapter object
6718  * @handle: attached device handle
6719  */
6720 static void
6721 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6722 {
6723         Mpi2ConfigReply_t mpi_reply;
6724         Mpi26PCIeDevicePage0_t pcie_device_pg0;
6725         u32 ioc_status;
6726         struct _pcie_device *pcie_device;
6727         u64 wwid;
6728         unsigned long flags;
6729         struct scsi_target *starget;
6730         struct MPT3SAS_TARGET *sas_target_priv_data;
6731         u32 device_info;
6732 
6733         if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
6734                 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle)))
6735                 return;
6736 
6737         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
6738         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6739                 return;
6740 
6741         /* check if this is end device */
6742         device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo);
6743         if (!(_scsih_is_nvme_pciescsi_device(device_info)))
6744                 return;
6745 
6746         wwid = le64_to_cpu(pcie_device_pg0.WWID);
6747         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
6748         pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
6749 
6750         if (!pcie_device) {
6751                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6752                 return;
6753         }
6754 
6755         if (unlikely(pcie_device->handle != handle)) {
6756                 starget = pcie_device->starget;
6757                 sas_target_priv_data = starget->hostdata;
6758                 pcie_device->access_status = pcie_device_pg0.AccessStatus;
6759                 starget_printk(KERN_INFO, starget,
6760                     "handle changed from(0x%04x) to (0x%04x)!!!\n",
6761                     pcie_device->handle, handle);
6762                 sas_target_priv_data->handle = handle;
6763                 pcie_device->handle = handle;
6764 
6765                 if (le32_to_cpu(pcie_device_pg0.Flags) &
6766                     MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) {
6767                         pcie_device->enclosure_level =
6768                             pcie_device_pg0.EnclosureLevel;
6769                         memcpy(&pcie_device->connector_name[0],
6770                             &pcie_device_pg0.ConnectorName[0], 4);
6771                 } else {
6772                         pcie_device->enclosure_level = 0;
6773                         pcie_device->connector_name[0] = '\0';
6774                 }
6775         }
6776 
6777         /* check if device is present */
6778         if (!(le32_to_cpu(pcie_device_pg0.Flags) &
6779             MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) {
6780                 ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n",
6781                          handle);
6782                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6783                 pcie_device_put(pcie_device);
6784                 return;
6785         }
6786 
6787         /* check if there were any issues with discovery */
6788         if (_scsih_check_pcie_access_status(ioc, wwid, handle,
6789             pcie_device_pg0.AccessStatus)) {
6790                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6791                 pcie_device_put(pcie_device);
6792                 return;
6793         }
6794 
6795         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
6796         pcie_device_put(pcie_device);
6797 
6798         _scsih_ublock_io_device(ioc, wwid);
6799 
6800         return;
6801 }
6802 
6803 /**
6804  * _scsih_pcie_add_device -  creating pcie device object
6805  * @ioc: per adapter object
6806  * @handle: pcie device handle
6807  *
6808  * Creating end device object, stored in ioc->pcie_device_list.
6809  *
6810  * Return: 1 means queue the event later, 0 means complete the event
6811  */
6812 static int
6813 _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6814 {
6815         Mpi26PCIeDevicePage0_t pcie_device_pg0;
6816         Mpi26PCIeDevicePage2_t pcie_device_pg2;
6817         Mpi2ConfigReply_t mpi_reply;
6818         struct _pcie_device *pcie_device;
6819         struct _enclosure_node *enclosure_dev;
6820         u32 ioc_status;
6821         u64 wwid;
6822 
6823         if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
6824             &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) {
6825                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6826                         __FILE__, __LINE__, __func__);
6827                 return 0;
6828         }
6829         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6830             MPI2_IOCSTATUS_MASK;
6831         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6832                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6833                         __FILE__, __LINE__, __func__);
6834                 return 0;
6835         }
6836 
6837         set_bit(handle, ioc->pend_os_device_add);
6838         wwid = le64_to_cpu(pcie_device_pg0.WWID);
6839 
6840         /* check if device is present */
6841         if (!(le32_to_cpu(pcie_device_pg0.Flags) &
6842                 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) {
6843                 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
6844                         handle);
6845                 return 0;
6846         }
6847 
6848         /* check if there were any issues with discovery */
6849         if (_scsih_check_pcie_access_status(ioc, wwid, handle,
6850             pcie_device_pg0.AccessStatus))
6851                 return 0;
6852 
6853         if (!(_scsih_is_nvme_pciescsi_device(le32_to_cpu
6854             (pcie_device_pg0.DeviceInfo))))
6855                 return 0;
6856 
6857         pcie_device = mpt3sas_get_pdev_by_wwid(ioc, wwid);
6858         if (pcie_device) {
6859                 clear_bit(handle, ioc->pend_os_device_add);
6860                 pcie_device_put(pcie_device);
6861                 return 0;
6862         }
6863 
6864         /* PCIe Device Page 2 contains read-only information about a
6865          * specific NVMe device; therefore, this page is only
6866          * valid for NVMe devices and skip for pcie devices of type scsi.
6867          */
6868         if (!(mpt3sas_scsih_is_pcie_scsi_device(
6869                 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) {
6870                 if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply,
6871                     &pcie_device_pg2, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6872                     handle)) {
6873                         ioc_err(ioc,
6874                             "failure at %s:%d/%s()!\n", __FILE__,
6875                             __LINE__, __func__);
6876                         return 0;
6877                 }
6878 
6879                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6880                                         MPI2_IOCSTATUS_MASK;
6881                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6882                         ioc_err(ioc,
6883                             "failure at %s:%d/%s()!\n", __FILE__,
6884                             __LINE__, __func__);
6885                         return 0;
6886                 }
6887         }
6888 
6889         pcie_device = kzalloc(sizeof(struct _pcie_device), GFP_KERNEL);
6890         if (!pcie_device) {
6891                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
6892                         __FILE__, __LINE__, __func__);
6893                 return 0;
6894         }
6895 
6896         kref_init(&pcie_device->refcount);
6897         pcie_device->id = ioc->pcie_target_id++;
6898         pcie_device->channel = PCIE_CHANNEL;
6899         pcie_device->handle = handle;
6900         pcie_device->access_status = pcie_device_pg0.AccessStatus;
6901         pcie_device->device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo);
6902         pcie_device->wwid = wwid;
6903         pcie_device->port_num = pcie_device_pg0.PortNum;
6904         pcie_device->fast_path = (le32_to_cpu(pcie_device_pg0.Flags) &
6905             MPI26_PCIEDEV0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
6906 
6907         pcie_device->enclosure_handle =
6908             le16_to_cpu(pcie_device_pg0.EnclosureHandle);
6909         if (pcie_device->enclosure_handle != 0)
6910                 pcie_device->slot = le16_to_cpu(pcie_device_pg0.Slot);
6911 
6912         if (le32_to_cpu(pcie_device_pg0.Flags) &
6913             MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) {
6914                 pcie_device->enclosure_level = pcie_device_pg0.EnclosureLevel;
6915                 memcpy(&pcie_device->connector_name[0],
6916                     &pcie_device_pg0.ConnectorName[0], 4);
6917         } else {
6918                 pcie_device->enclosure_level = 0;
6919                 pcie_device->connector_name[0] = '\0';
6920         }
6921 
6922         /* get enclosure_logical_id */
6923         if (pcie_device->enclosure_handle) {
6924                 enclosure_dev =
6925                         mpt3sas_scsih_enclosure_find_by_handle(ioc,
6926                                                 pcie_device->enclosure_handle);
6927                 if (enclosure_dev)
6928                         pcie_device->enclosure_logical_id =
6929                             le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
6930         }
6931         /* TODO -- Add device name once FW supports it */
6932         if (!(mpt3sas_scsih_is_pcie_scsi_device(
6933             le32_to_cpu(pcie_device_pg0.DeviceInfo)))) {
6934                 pcie_device->nvme_mdts =
6935                     le32_to_cpu(pcie_device_pg2.MaximumDataTransferSize);
6936                 if (pcie_device_pg2.ControllerResetTO)
6937                         pcie_device->reset_timeout =
6938                             pcie_device_pg2.ControllerResetTO;
6939                 else
6940                         pcie_device->reset_timeout = 30;
6941         } else
6942                 pcie_device->reset_timeout = 30;
6943 
6944         if (ioc->wait_for_discovery_to_complete)
6945                 _scsih_pcie_device_init_add(ioc, pcie_device);
6946         else
6947                 _scsih_pcie_device_add(ioc, pcie_device);
6948 
6949         pcie_device_put(pcie_device);
6950         return 0;
6951 }
6952 
6953 /**
6954  * _scsih_pcie_topology_change_event_debug - debug for topology
6955  * event
6956  * @ioc: per adapter object
6957  * @event_data: event data payload
6958  * Context: user.
6959  */
6960 static void
6961 _scsih_pcie_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6962         Mpi26EventDataPCIeTopologyChangeList_t *event_data)
6963 {
6964         int i;
6965         u16 handle;
6966         u16 reason_code;
6967         u8 port_number;
6968         char *status_str = NULL;
6969         u8 link_rate, prev_link_rate;
6970 
6971         switch (event_data->SwitchStatus) {
6972         case MPI26_EVENT_PCIE_TOPO_SS_ADDED:
6973                 status_str = "add";
6974                 break;
6975         case MPI26_EVENT_PCIE_TOPO_SS_NOT_RESPONDING:
6976                 status_str = "remove";
6977                 break;
6978         case MPI26_EVENT_PCIE_TOPO_SS_RESPONDING:
6979         case 0:
6980                 status_str =  "responding";
6981                 break;
6982         case MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING:
6983                 status_str = "remove delay";
6984                 break;
6985         default:
6986                 status_str = "unknown status";
6987                 break;
6988         }
6989         ioc_info(ioc, "pcie topology change: (%s)\n", status_str);
6990         pr_info("\tswitch_handle(0x%04x), enclosure_handle(0x%04x)"
6991                 "start_port(%02d), count(%d)\n",
6992                 le16_to_cpu(event_data->SwitchDevHandle),
6993                 le16_to_cpu(event_data->EnclosureHandle),
6994                 event_data->StartPortNum, event_data->NumEntries);
6995         for (i = 0; i < event_data->NumEntries; i++) {
6996                 handle =
6997                         le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
6998                 if (!handle)
6999                         continue;
7000                 port_number = event_data->StartPortNum + i;
7001                 reason_code = event_data->PortEntry[i].PortStatus;
7002                 switch (reason_code) {
7003                 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED:
7004                         status_str = "target add";
7005                         break;
7006                 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING:
7007                         status_str = "target remove";
7008                         break;
7009                 case MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING:
7010                         status_str = "delay target remove";
7011                         break;
7012                 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED:
7013                         status_str = "link rate change";
7014                         break;
7015                 case MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE:
7016                         status_str = "target responding";
7017                         break;
7018                 default:
7019                         status_str = "unknown";
7020                         break;
7021                 }
7022                 link_rate = event_data->PortEntry[i].CurrentPortInfo &
7023                         MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
7024                 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo &
7025                         MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
7026                 pr_info("\tport(%02d), attached_handle(0x%04x): %s:"
7027                         " link rate: new(0x%02x), old(0x%02x)\n", port_number,
7028                         handle, status_str, link_rate, prev_link_rate);
7029         }
7030 }
7031 
7032 /**
7033  * _scsih_pcie_topology_change_event - handle PCIe topology
7034  *  changes
7035  * @ioc: per adapter object
7036  * @fw_event: The fw_event_work object
7037  * Context: user.
7038  *
7039  */
7040 static void
7041 _scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
7042         struct fw_event_work *fw_event)
7043 {
7044         int i;
7045         u16 handle;
7046         u16 reason_code;
7047         u8 link_rate, prev_link_rate;
7048         unsigned long flags;
7049         int rc;
7050         Mpi26EventDataPCIeTopologyChangeList_t *event_data =
7051                 (Mpi26EventDataPCIeTopologyChangeList_t *) fw_event->event_data;
7052         struct _pcie_device *pcie_device;
7053 
7054         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7055                 _scsih_pcie_topology_change_event_debug(ioc, event_data);
7056 
7057         if (ioc->shost_recovery || ioc->remove_host ||
7058                 ioc->pci_error_recovery)
7059                 return;
7060 
7061         if (fw_event->ignore) {
7062                 dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n"));
7063                 return;
7064         }
7065 
7066         /* handle siblings events */
7067         for (i = 0; i < event_data->NumEntries; i++) {
7068                 if (fw_event->ignore) {
7069                         dewtprintk(ioc,
7070                                    ioc_info(ioc, "ignoring switch event\n"));
7071                         return;
7072                 }
7073                 if (ioc->remove_host || ioc->pci_error_recovery)
7074                         return;
7075                 reason_code = event_data->PortEntry[i].PortStatus;
7076                 handle =
7077                         le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle);
7078                 if (!handle)
7079                         continue;
7080 
7081                 link_rate = event_data->PortEntry[i].CurrentPortInfo
7082                         & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
7083                 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo
7084                         & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK;
7085 
7086                 switch (reason_code) {
7087                 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED:
7088                         if (ioc->shost_recovery)
7089                                 break;
7090                         if (link_rate == prev_link_rate)
7091                                 break;
7092                         if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5)
7093                                 break;
7094 
7095                         _scsih_pcie_check_device(ioc, handle);
7096 
7097                         /* This code after this point handles the test case
7098                          * where a device has been added, however its returning
7099                          * BUSY for sometime.  Then before the Device Missing
7100                          * Delay expires and the device becomes READY, the
7101                          * device is removed and added back.
7102                          */
7103                         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
7104                         pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle);
7105                         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
7106 
7107                         if (pcie_device) {
7108                                 pcie_device_put(pcie_device);
7109                                 break;
7110                         }
7111 
7112                         if (!test_bit(handle, ioc->pend_os_device_add))
7113                                 break;
7114 
7115                         dewtprintk(ioc,
7116                                    ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n",
7117                                             handle));
7118                         event_data->PortEntry[i].PortStatus &= 0xF0;
7119                         event_data->PortEntry[i].PortStatus |=
7120                                 MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED;
7121                         /* fall through */
7122                 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED:
7123                         if (ioc->shost_recovery)
7124                                 break;
7125                         if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5)
7126                                 break;
7127 
7128                         rc = _scsih_pcie_add_device(ioc, handle);
7129                         if (!rc) {
7130                                 /* mark entry vacant */
7131                                 /* TODO This needs to be reviewed and fixed,
7132                                  * we dont have an entry
7133                                  * to make an event void like vacant
7134                                  */
7135                                 event_data->PortEntry[i].PortStatus |=
7136                                         MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE;
7137                         }
7138                         break;
7139                 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING:
7140                         _scsih_pcie_device_remove_by_handle(ioc, handle);
7141                         break;
7142                 }
7143         }
7144 }
7145 
7146 /**
7147  * _scsih_pcie_device_status_change_event_debug - debug for device event
7148  * @ioc: ?
7149  * @event_data: event data payload
7150  * Context: user.
7151  */
7152 static void
7153 _scsih_pcie_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7154         Mpi26EventDataPCIeDeviceStatusChange_t *event_data)
7155 {
7156         char *reason_str = NULL;
7157 
7158         switch (event_data->ReasonCode) {
7159         case MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA:
7160                 reason_str = "smart data";
7161                 break;
7162         case MPI26_EVENT_PCIDEV_STAT_RC_UNSUPPORTED:
7163                 reason_str = "unsupported device discovered";
7164                 break;
7165         case MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET:
7166                 reason_str = "internal device reset";
7167                 break;
7168         case MPI26_EVENT_PCIDEV_STAT_RC_TASK_ABORT_INTERNAL:
7169                 reason_str = "internal task abort";
7170                 break;
7171         case MPI26_EVENT_PCIDEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
7172                 reason_str = "internal task abort set";
7173                 break;
7174         case MPI26_EVENT_PCIDEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
7175                 reason_str = "internal clear task set";
7176                 break;
7177         case MPI26_EVENT_PCIDEV_STAT_RC_QUERY_TASK_INTERNAL:
7178                 reason_str = "internal query task";
7179                 break;
7180         case MPI26_EVENT_PCIDEV_STAT_RC_DEV_INIT_FAILURE:
7181                 reason_str = "device init failure";
7182                 break;
7183         case MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
7184                 reason_str = "internal device reset complete";
7185                 break;
7186         case MPI26_EVENT_PCIDEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
7187                 reason_str = "internal task abort complete";
7188                 break;
7189         case MPI26_EVENT_PCIDEV_STAT_RC_ASYNC_NOTIFICATION:
7190                 reason_str = "internal async notification";
7191                 break;
7192         case MPI26_EVENT_PCIDEV_STAT_RC_PCIE_HOT_RESET_FAILED:
7193                 reason_str = "pcie hot reset failed";
7194                 break;
7195         default:
7196                 reason_str = "unknown reason";
7197                 break;
7198         }
7199 
7200         ioc_info(ioc, "PCIE device status change: (%s)\n"
7201                  "\thandle(0x%04x), WWID(0x%016llx), tag(%d)",
7202                  reason_str, le16_to_cpu(event_data->DevHandle),
7203                  (u64)le64_to_cpu(event_data->WWID),
7204                  le16_to_cpu(event_data->TaskTag));
7205         if (event_data->ReasonCode == MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA)
7206                 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n",
7207                         event_data->ASC, event_data->ASCQ);
7208         pr_cont("\n");
7209 }
7210 
7211 /**
7212  * _scsih_pcie_device_status_change_event - handle device status
7213  * change
7214  * @ioc: per adapter object
7215  * @fw_event: The fw_event_work object
7216  * Context: user.
7217  */
7218 static void
7219 _scsih_pcie_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
7220         struct fw_event_work *fw_event)
7221 {
7222         struct MPT3SAS_TARGET *target_priv_data;
7223         struct _pcie_device *pcie_device;
7224         u64 wwid;
7225         unsigned long flags;
7226         Mpi26EventDataPCIeDeviceStatusChange_t *event_data =
7227                 (Mpi26EventDataPCIeDeviceStatusChange_t *)fw_event->event_data;
7228         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7229                 _scsih_pcie_device_status_change_event_debug(ioc,
7230                         event_data);
7231 
7232         if (event_data->ReasonCode !=
7233                 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET &&
7234                 event_data->ReasonCode !=
7235                 MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
7236                 return;
7237 
7238         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
7239         wwid = le64_to_cpu(event_data->WWID);
7240         pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid);
7241 
7242         if (!pcie_device || !pcie_device->starget)
7243                 goto out;
7244 
7245         target_priv_data = pcie_device->starget->hostdata;
7246         if (!target_priv_data)
7247                 goto out;
7248 
7249         if (event_data->ReasonCode ==
7250                 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET)
7251                 target_priv_data->tm_busy = 1;
7252         else
7253                 target_priv_data->tm_busy = 0;
7254 out:
7255         if (pcie_device)
7256                 pcie_device_put(pcie_device);
7257 
7258         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
7259 }
7260 
7261 /**
7262  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure
7263  * event
7264  * @ioc: per adapter object
7265  * @event_data: event data payload
7266  * Context: user.
7267  */
7268 static void
7269 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7270         Mpi2EventDataSasEnclDevStatusChange_t *event_data)
7271 {
7272         char *reason_str = NULL;
7273 
7274         switch (event_data->ReasonCode) {
7275         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
7276                 reason_str = "enclosure add";
7277                 break;
7278         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
7279                 reason_str = "enclosure remove";
7280                 break;
7281         default:
7282                 reason_str = "unknown reason";
7283                 break;
7284         }
7285 
7286         ioc_info(ioc, "enclosure status change: (%s)\n"
7287                  "\thandle(0x%04x), enclosure logical id(0x%016llx) number slots(%d)\n",
7288                  reason_str,
7289                  le16_to_cpu(event_data->EnclosureHandle),
7290                  (u64)le64_to_cpu(event_data->EnclosureLogicalID),
7291                  le16_to_cpu(event_data->StartSlot));
7292 }
7293 
7294 /**
7295  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
7296  * @ioc: per adapter object
7297  * @fw_event: The fw_event_work object
7298  * Context: user.
7299  */
7300 static void
7301 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
7302         struct fw_event_work *fw_event)
7303 {
7304         Mpi2ConfigReply_t mpi_reply;
7305         struct _enclosure_node *enclosure_dev = NULL;
7306         Mpi2EventDataSasEnclDevStatusChange_t *event_data =
7307                 (Mpi2EventDataSasEnclDevStatusChange_t *)fw_event->event_data;
7308         int rc;
7309         u16 enclosure_handle = le16_to_cpu(event_data->EnclosureHandle);
7310 
7311         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
7312                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
7313                      (Mpi2EventDataSasEnclDevStatusChange_t *)
7314                      fw_event->event_data);
7315         if (ioc->shost_recovery)
7316                 return;
7317 
7318         if (enclosure_handle)
7319                 enclosure_dev =
7320                         mpt3sas_scsih_enclosure_find_by_handle(ioc,
7321                                                 enclosure_handle);
7322         switch (event_data->ReasonCode) {
7323         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
7324                 if (!enclosure_dev) {
7325                         enclosure_dev =
7326                                 kzalloc(sizeof(struct _enclosure_node),
7327                                         GFP_KERNEL);
7328                         if (!enclosure_dev) {
7329                                 ioc_info(ioc, "failure at %s:%d/%s()!\n",
7330                                          __FILE__, __LINE__, __func__);
7331                                 return;
7332                         }
7333                         rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
7334                                 &enclosure_dev->pg0,
7335                                 MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
7336                                 enclosure_handle);
7337 
7338                         if (rc || (le16_to_cpu(mpi_reply.IOCStatus) &
7339                                                 MPI2_IOCSTATUS_MASK)) {
7340                                 kfree(enclosure_dev);
7341                                 return;
7342                         }
7343 
7344                         list_add_tail(&enclosure_dev->list,
7345                                                         &ioc->enclosure_list);
7346                 }
7347                 break;
7348         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
7349                 if (enclosure_dev) {
7350                         list_del(&enclosure_dev->list);
7351                         kfree(enclosure_dev);
7352                 }
7353                 break;
7354         default:
7355                 break;
7356         }
7357 }
7358 
7359 /**
7360  * _scsih_sas_broadcast_primitive_event - handle broadcast events
7361  * @ioc: per adapter object
7362  * @fw_event: The fw_event_work object
7363  * Context: user.
7364  */
7365 static void
7366 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
7367         struct fw_event_work *fw_event)
7368 {
7369         struct scsi_cmnd *scmd;
7370         struct scsi_device *sdev;
7371         struct scsiio_tracker *st;
7372         u16 smid, handle;
7373         u32 lun;
7374         struct MPT3SAS_DEVICE *sas_device_priv_data;
7375         u32 termination_count;
7376         u32 query_count;
7377         Mpi2SCSITaskManagementReply_t *mpi_reply;
7378         Mpi2EventDataSasBroadcastPrimitive_t *event_data =
7379                 (Mpi2EventDataSasBroadcastPrimitive_t *)
7380                 fw_event->event_data;
7381         u16 ioc_status;
7382         unsigned long flags;
7383         int r;
7384         u8 max_retries = 0;
7385         u8 task_abort_retries;
7386 
7387         mutex_lock(&ioc->tm_cmds.mutex);
7388         ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n",
7389                  __func__, event_data->PhyNum, event_data->PortWidth);
7390 
7391         _scsih_block_io_all_device(ioc);
7392 
7393         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7394         mpi_reply = ioc->tm_cmds.reply;
7395  broadcast_aen_retry:
7396 
7397         /* sanity checks for retrying this loop */
7398         if (max_retries++ == 5) {
7399                 dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__));
7400                 goto out;
7401         } else if (max_retries > 1)
7402                 dewtprintk(ioc,
7403                            ioc_info(ioc, "%s: %d retry\n",
7404                                     __func__, max_retries - 1));
7405 
7406         termination_count = 0;
7407         query_count = 0;
7408         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
7409                 if (ioc->shost_recovery)
7410                         goto out;
7411                 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
7412                 if (!scmd)
7413                         continue;
7414                 st = scsi_cmd_priv(scmd);
7415                 sdev = scmd->device;
7416                 sas_device_priv_data = sdev->hostdata;
7417                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
7418                         continue;
7419                  /* skip hidden raid components */
7420                 if (sas_device_priv_data->sas_target->flags &
7421                     MPT_TARGET_FLAGS_RAID_COMPONENT)
7422                         continue;
7423                  /* skip volumes */
7424                 if (sas_device_priv_data->sas_target->flags &
7425                     MPT_TARGET_FLAGS_VOLUME)
7426                         continue;
7427                  /* skip PCIe devices */
7428                 if (sas_device_priv_data->sas_target->flags &
7429                     MPT_TARGET_FLAGS_PCIE_DEVICE)
7430                         continue;
7431 
7432                 handle = sas_device_priv_data->sas_target->handle;
7433                 lun = sas_device_priv_data->lun;
7434                 query_count++;
7435 
7436                 if (ioc->shost_recovery)
7437                         goto out;
7438 
7439                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
7440                 r = mpt3sas_scsih_issue_tm(ioc, handle, lun,
7441                         MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, st->smid,
7442                         st->msix_io, 30, 0);
7443                 if (r == FAILED) {
7444                         sdev_printk(KERN_WARNING, sdev,
7445                             "mpt3sas_scsih_issue_tm: FAILED when sending "
7446                             "QUERY_TASK: scmd(%p)\n", scmd);
7447                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7448                         goto broadcast_aen_retry;
7449                 }
7450                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
7451                     & MPI2_IOCSTATUS_MASK;
7452                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7453                         sdev_printk(KERN_WARNING, sdev,
7454                                 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n",
7455                                 ioc_status, scmd);
7456                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7457                         goto broadcast_aen_retry;
7458                 }
7459 
7460                 /* see if IO is still owned by IOC and target */
7461                 if (mpi_reply->ResponseCode ==
7462                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
7463                      mpi_reply->ResponseCode ==
7464                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
7465                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7466                         continue;
7467                 }
7468                 task_abort_retries = 0;
7469  tm_retry:
7470                 if (task_abort_retries++ == 60) {
7471                         dewtprintk(ioc,
7472                                    ioc_info(ioc, "%s: ABORT_TASK: giving up\n",
7473                                             __func__));
7474                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7475                         goto broadcast_aen_retry;
7476                 }
7477 
7478                 if (ioc->shost_recovery)
7479                         goto out_no_lock;
7480 
7481                 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->lun,
7482                         MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, st->smid,
7483                         st->msix_io, 30, 0);
7484                 if (r == FAILED || st->cb_idx != 0xFF) {
7485                         sdev_printk(KERN_WARNING, sdev,
7486                             "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : "
7487                             "scmd(%p)\n", scmd);
7488                         goto tm_retry;
7489                 }
7490 
7491                 if (task_abort_retries > 1)
7492                         sdev_printk(KERN_WARNING, sdev,
7493                             "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
7494                             " scmd(%p)\n",
7495                             task_abort_retries - 1, scmd);
7496 
7497                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
7498                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
7499         }
7500 
7501         if (ioc->broadcast_aen_pending) {
7502                 dewtprintk(ioc,
7503                            ioc_info(ioc,
7504                                     "%s: loop back due to pending AEN\n",
7505                                     __func__));
7506                  ioc->broadcast_aen_pending = 0;
7507                  goto broadcast_aen_retry;
7508         }
7509 
7510  out:
7511         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
7512  out_no_lock:
7513 
7514         dewtprintk(ioc,
7515                    ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n",
7516                             __func__, query_count, termination_count));
7517 
7518         ioc->broadcast_aen_busy = 0;
7519         if (!ioc->shost_recovery)
7520                 _scsih_ublock_io_all_device(ioc);
7521         mutex_unlock(&ioc->tm_cmds.mutex);
7522 }
7523 
7524 /**
7525  * _scsih_sas_discovery_event - handle discovery events
7526  * @ioc: per adapter object
7527  * @fw_event: The fw_event_work object
7528  * Context: user.
7529  */
7530 static void
7531 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
7532         struct fw_event_work *fw_event)
7533 {
7534         Mpi2EventDataSasDiscovery_t *event_data =
7535                 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data;
7536 
7537         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
7538                 ioc_info(ioc, "discovery event: (%s)",
7539                          event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED ?
7540                          "start" : "stop");
7541                 if (event_data->DiscoveryStatus)
7542                         pr_cont("discovery_status(0x%08x)",
7543                                 le32_to_cpu(event_data->DiscoveryStatus));
7544                 pr_cont("\n");
7545         }
7546 
7547         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
7548             !ioc->sas_hba.num_phys) {
7549                 if (disable_discovery > 0 && ioc->shost_recovery) {
7550                         /* Wait for the reset to complete */
7551                         while (ioc->shost_recovery)
7552                                 ssleep(1);
7553                 }
7554                 _scsih_sas_host_add(ioc);
7555         }
7556 }
7557 
7558 /**
7559  * _scsih_sas_device_discovery_error_event - display SAS device discovery error
7560  *                                              events
7561  * @ioc: per adapter object
7562  * @fw_event: The fw_event_work object
7563  * Context: user.
7564  */
7565 static void
7566 _scsih_sas_device_discovery_error_event(struct MPT3SAS_ADAPTER *ioc,
7567         struct fw_event_work *fw_event)
7568 {
7569         Mpi25EventDataSasDeviceDiscoveryError_t *event_data =
7570                 (Mpi25EventDataSasDeviceDiscoveryError_t *)fw_event->event_data;
7571 
7572         switch (event_data->ReasonCode) {
7573         case MPI25_EVENT_SAS_DISC_ERR_SMP_FAILED:
7574                 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n",
7575                          le16_to_cpu(event_data->DevHandle),
7576                          (u64)le64_to_cpu(event_data->SASAddress),
7577                          event_data->PhysicalPort);
7578                 break;
7579         case MPI25_EVENT_SAS_DISC_ERR_SMP_TIMEOUT:
7580                 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n",
7581                          le16_to_cpu(event_data->DevHandle),
7582                          (u64)le64_to_cpu(event_data->SASAddress),
7583                          event_data->PhysicalPort);
7584                 break;
7585         default:
7586                 break;
7587         }
7588 }
7589 
7590 /**
7591  * _scsih_pcie_enumeration_event - handle enumeration events
7592  * @ioc: per adapter object
7593  * @fw_event: The fw_event_work object
7594  * Context: user.
7595  */
7596 static void
7597 _scsih_pcie_enumeration_event(struct MPT3SAS_ADAPTER *ioc,
7598         struct fw_event_work *fw_event)
7599 {
7600         Mpi26EventDataPCIeEnumeration_t *event_data =
7601                 (Mpi26EventDataPCIeEnumeration_t *)fw_event->event_data;
7602 
7603         if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK))
7604                 return;
7605 
7606         ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x",
7607                  (event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED) ?
7608                  "started" : "completed",
7609                  event_data->Flags);
7610         if (event_data->EnumerationStatus)
7611                 pr_cont("enumeration_status(0x%08x)",
7612                         le32_to_cpu(event_data->EnumerationStatus));
7613         pr_cont("\n");
7614 }
7615 
7616 /**
7617  * _scsih_ir_fastpath - turn on fastpath for IR physdisk
7618  * @ioc: per adapter object
7619  * @handle: device handle for physical disk
7620  * @phys_disk_num: physical disk number
7621  *
7622  * Return: 0 for success, else failure.
7623  */
7624 static int
7625 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
7626 {
7627         Mpi2RaidActionRequest_t *mpi_request;
7628         Mpi2RaidActionReply_t *mpi_reply;
7629         u16 smid;
7630         u8 issue_reset = 0;
7631         int rc = 0;
7632         u16 ioc_status;
7633         u32 log_info;
7634 
7635         if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
7636                 return rc;
7637 
7638         mutex_lock(&ioc->scsih_cmds.mutex);
7639 
7640         if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
7641                 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
7642                 rc = -EAGAIN;
7643                 goto out;
7644         }
7645         ioc->scsih_cmds.status = MPT3_CMD_PENDING;
7646 
7647         smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
7648         if (!smid) {
7649                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
7650                 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7651                 rc = -EAGAIN;
7652                 goto out;
7653         }
7654 
7655         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
7656         ioc->scsih_cmds.smid = smid;
7657         memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
7658 
7659         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
7660         mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
7661         mpi_request->PhysDiskNum = phys_disk_num;
7662 
7663         dewtprintk(ioc,
7664                    ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n",
7665                             handle, phys_disk_num));
7666 
7667         init_completion(&ioc->scsih_cmds.done);
7668         ioc->put_smid_default(ioc, smid);
7669         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
7670 
7671         if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
7672                 issue_reset =
7673                         mpt3sas_base_check_cmd_timeout(ioc,
7674                                 ioc->scsih_cmds.status, mpi_request,
7675                                 sizeof(Mpi2RaidActionRequest_t)/4);
7676                 rc = -EFAULT;
7677                 goto out;
7678         }
7679 
7680         if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
7681 
7682                 mpi_reply = ioc->scsih_cmds.reply;
7683                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
7684                 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
7685                         log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
7686                 else
7687                         log_info = 0;
7688                 ioc_status &= MPI2_IOCSTATUS_MASK;
7689                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7690                         dewtprintk(ioc,
7691                                    ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n",
7692                                             ioc_status, log_info));
7693                         rc = -EFAULT;
7694                 } else
7695                         dewtprintk(ioc,
7696                                    ioc_info(ioc, "IR RAID_ACTION: completed successfully\n"));
7697         }
7698 
7699  out:
7700         ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7701         mutex_unlock(&ioc->scsih_cmds.mutex);
7702 
7703         if (issue_reset)
7704                 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
7705         return rc;
7706 }
7707 
7708 /**
7709  * _scsih_reprobe_lun - reprobing lun
7710  * @sdev: scsi device struct
7711  * @no_uld_attach: sdev->no_uld_attach flag setting
7712  *
7713  **/
7714 static void
7715 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
7716 {
7717         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
7718         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
7719             sdev->no_uld_attach ? "hiding" : "exposing");
7720         WARN_ON(scsi_device_reprobe(sdev));
7721 }
7722 
7723 /**
7724  * _scsih_sas_volume_add - add new volume
7725  * @ioc: per adapter object
7726  * @element: IR config element data
7727  * Context: user.
7728  */
7729 static void
7730 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
7731         Mpi2EventIrConfigElement_t *element)
7732 {
7733         struct _raid_device *raid_device;
7734         unsigned long flags;
7735         u64 wwid;
7736         u16 handle = le16_to_cpu(element->VolDevHandle);
7737         int rc;
7738 
7739         mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
7740         if (!wwid) {
7741                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7742                         __FILE__, __LINE__, __func__);
7743                 return;
7744         }
7745 
7746         spin_lock_irqsave(&ioc->raid_device_lock, flags);
7747         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
7748         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7749 
7750         if (raid_device)
7751                 return;
7752 
7753         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
7754         if (!raid_device) {
7755                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7756                         __FILE__, __LINE__, __func__);
7757                 return;
7758         }
7759 
7760         raid_device->id = ioc->sas_id++;
7761         raid_device->channel = RAID_CHANNEL;
7762         raid_device->handle = handle;
7763         raid_device->wwid = wwid;
7764         _scsih_raid_device_add(ioc, raid_device);
7765         if (!ioc->wait_for_discovery_to_complete) {
7766                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
7767                     raid_device->id, 0);
7768                 if (rc)
7769                         _scsih_raid_device_remove(ioc, raid_device);
7770         } else {
7771                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
7772                 _scsih_determine_boot_device(ioc, raid_device, 1);
7773                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7774         }
7775 }
7776 
7777 /**
7778  * _scsih_sas_volume_delete - delete volume
7779  * @ioc: per adapter object
7780  * @handle: volume device handle
7781  * Context: user.
7782  */
7783 static void
7784 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
7785 {
7786         struct _raid_device *raid_device;
7787         unsigned long flags;
7788         struct MPT3SAS_TARGET *sas_target_priv_data;
7789         struct scsi_target *starget = NULL;
7790 
7791         spin_lock_irqsave(&ioc->raid_device_lock, flags);
7792         raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
7793         if (raid_device) {
7794                 if (raid_device->starget) {
7795                         starget = raid_device->starget;
7796                         sas_target_priv_data = starget->hostdata;
7797                         sas_target_priv_data->deleted = 1;
7798                 }
7799                 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
7800                          raid_device->handle, (u64)raid_device->wwid);
7801                 list_del(&raid_device->list);
7802                 kfree(raid_device);
7803         }
7804         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7805         if (starget)
7806                 scsi_remove_target(&starget->dev);
7807 }
7808 
7809 /**
7810  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
7811  * @ioc: per adapter object
7812  * @element: IR config element data
7813  * Context: user.
7814  */
7815 static void
7816 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
7817         Mpi2EventIrConfigElement_t *element)
7818 {
7819         struct _sas_device *sas_device;
7820         struct scsi_target *starget = NULL;
7821         struct MPT3SAS_TARGET *sas_target_priv_data;
7822         unsigned long flags;
7823         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7824 
7825         spin_lock_irqsave(&ioc->sas_device_lock, flags);
7826         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
7827         if (sas_device) {
7828                 sas_device->volume_handle = 0;
7829                 sas_device->volume_wwid = 0;
7830                 clear_bit(handle, ioc->pd_handles);
7831                 if (sas_device->starget && sas_device->starget->hostdata) {
7832                         starget = sas_device->starget;
7833                         sas_target_priv_data = starget->hostdata;
7834                         sas_target_priv_data->flags &=
7835                             ~MPT_TARGET_FLAGS_RAID_COMPONENT;
7836                 }
7837         }
7838         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7839         if (!sas_device)
7840                 return;
7841 
7842         /* exposing raid component */
7843         if (starget)
7844                 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
7845 
7846         sas_device_put(sas_device);
7847 }
7848 
7849 /**
7850  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
7851  * @ioc: per adapter object
7852  * @element: IR config element data
7853  * Context: user.
7854  */
7855 static void
7856 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
7857         Mpi2EventIrConfigElement_t *element)
7858 {
7859         struct _sas_device *sas_device;
7860         struct scsi_target *starget = NULL;
7861         struct MPT3SAS_TARGET *sas_target_priv_data;
7862         unsigned long flags;
7863         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7864         u16 volume_handle = 0;
7865         u64 volume_wwid = 0;
7866 
7867         mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
7868         if (volume_handle)
7869                 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
7870                     &volume_wwid);
7871 
7872         spin_lock_irqsave(&ioc->sas_device_lock, flags);
7873         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
7874         if (sas_device) {
7875                 set_bit(handle, ioc->pd_handles);
7876                 if (sas_device->starget && sas_device->starget->hostdata) {
7877                         starget = sas_device->starget;
7878                         sas_target_priv_data = starget->hostdata;
7879                         sas_target_priv_data->flags |=
7880                             MPT_TARGET_FLAGS_RAID_COMPONENT;
7881                         sas_device->volume_handle = volume_handle;
7882                         sas_device->volume_wwid = volume_wwid;
7883                 }
7884         }
7885         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7886         if (!sas_device)
7887                 return;
7888 
7889         /* hiding raid component */
7890         _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
7891 
7892         if (starget)
7893                 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
7894 
7895         sas_device_put(sas_device);
7896 }
7897 
7898 /**
7899  * _scsih_sas_pd_delete - delete pd component
7900  * @ioc: per adapter object
7901  * @element: IR config element data
7902  * Context: user.
7903  */
7904 static void
7905 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
7906         Mpi2EventIrConfigElement_t *element)
7907 {
7908         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7909 
7910         _scsih_device_remove_by_handle(ioc, handle);
7911 }
7912 
7913 /**
7914  * _scsih_sas_pd_add - remove pd component
7915  * @ioc: per adapter object
7916  * @element: IR config element data
7917  * Context: user.
7918  */
7919 static void
7920 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
7921         Mpi2EventIrConfigElement_t *element)
7922 {
7923         struct _sas_device *sas_device;
7924         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
7925         Mpi2ConfigReply_t mpi_reply;
7926         Mpi2SasDevicePage0_t sas_device_pg0;
7927         u32 ioc_status;
7928         u64 sas_address;
7929         u16 parent_handle;
7930 
7931         set_bit(handle, ioc->pd_handles);
7932 
7933         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
7934         if (sas_device) {
7935                 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
7936                 sas_device_put(sas_device);
7937                 return;
7938         }
7939 
7940         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
7941             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
7942                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7943                         __FILE__, __LINE__, __func__);
7944                 return;
7945         }
7946 
7947         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7948             MPI2_IOCSTATUS_MASK;
7949         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7950                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
7951                         __FILE__, __LINE__, __func__);
7952                 return;
7953         }
7954 
7955         parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
7956         if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
7957                 mpt3sas_transport_update_links(ioc, sas_address, handle,
7958                     sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
7959 
7960         _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
7961         _scsih_add_device(ioc, handle, 0, 1);
7962 }
7963 
7964 /**
7965  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
7966  * @ioc: per adapter object
7967  * @event_data: event data payload
7968  * Context: user.
7969  */
7970 static void
7971 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
7972         Mpi2EventDataIrConfigChangeList_t *event_data)
7973 {
7974         Mpi2EventIrConfigElement_t *element;
7975         u8 element_type;
7976         int i;
7977         char *reason_str = NULL, *element_str = NULL;
7978 
7979         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
7980 
7981         ioc_info(ioc, "raid config change: (%s), elements(%d)\n",
7982                  le32_to_cpu(event_data->Flags) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ?
7983                  "foreign" : "native",
7984                  event_data->NumElements);
7985         for (i = 0; i < event_data->NumElements; i++, element++) {
7986                 switch (element->ReasonCode) {
7987                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
7988                         reason_str = "add";
7989                         break;
7990                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
7991                         reason_str = "remove";
7992                         break;
7993                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
7994                         reason_str = "no change";
7995                         break;
7996                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
7997                         reason_str = "hide";
7998                         break;
7999                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
8000                         reason_str = "unhide";
8001                         break;
8002                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
8003                         reason_str = "volume_created";
8004                         break;
8005                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
8006                         reason_str = "volume_deleted";
8007                         break;
8008                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
8009                         reason_str = "pd_created";
8010                         break;
8011                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
8012                         reason_str = "pd_deleted";
8013                         break;
8014                 default:
8015                         reason_str = "unknown reason";
8016                         break;
8017                 }
8018                 element_type = le16_to_cpu(element->ElementFlags) &
8019                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
8020                 switch (element_type) {
8021                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
8022                         element_str = "volume";
8023                         break;
8024                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
8025                         element_str = "phys disk";
8026                         break;
8027                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
8028                         element_str = "hot spare";
8029                         break;
8030                 default:
8031                         element_str = "unknown element";
8032                         break;
8033                 }
8034                 pr_info("\t(%s:%s), vol handle(0x%04x), " \
8035                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
8036                     reason_str, le16_to_cpu(element->VolDevHandle),
8037                     le16_to_cpu(element->PhysDiskDevHandle),
8038                     element->PhysDiskNum);
8039         }
8040 }
8041 
8042 /**
8043  * _scsih_sas_ir_config_change_event - handle ir configuration change events
8044  * @ioc: per adapter object
8045  * @fw_event: The fw_event_work object
8046  * Context: user.
8047  */
8048 static void
8049 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
8050         struct fw_event_work *fw_event)
8051 {
8052         Mpi2EventIrConfigElement_t *element;
8053         int i;
8054         u8 foreign_config;
8055         Mpi2EventDataIrConfigChangeList_t *event_data =
8056                 (Mpi2EventDataIrConfigChangeList_t *)
8057                 fw_event->event_data;
8058 
8059         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
8060              (!ioc->hide_ir_msg))
8061                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
8062 
8063         foreign_config = (le32_to_cpu(event_data->Flags) &
8064             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
8065 
8066         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
8067         if (ioc->shost_recovery &&
8068             ioc->hba_mpi_version_belonged != MPI2_VERSION) {
8069                 for (i = 0; i < event_data->NumElements; i++, element++) {
8070                         if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)
8071                                 _scsih_ir_fastpath(ioc,
8072                                         le16_to_cpu(element->PhysDiskDevHandle),
8073                                         element->PhysDiskNum);
8074                 }
8075                 return;
8076         }
8077 
8078         for (i = 0; i < event_data->NumElements; i++, element++) {
8079 
8080                 switch (element->ReasonCode) {
8081                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
8082                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
8083                         if (!foreign_config)
8084                                 _scsih_sas_volume_add(ioc, element);
8085                         break;
8086                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
8087                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
8088                         if (!foreign_config)
8089                                 _scsih_sas_volume_delete(ioc,
8090                                     le16_to_cpu(element->VolDevHandle));
8091                         break;
8092                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
8093                         if (!ioc->is_warpdrive)
8094                                 _scsih_sas_pd_hide(ioc, element);
8095                         break;
8096                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
8097                         if (!ioc->is_warpdrive)
8098                                 _scsih_sas_pd_expose(ioc, element);
8099                         break;
8100                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
8101                         if (!ioc->is_warpdrive)
8102                                 _scsih_sas_pd_add(ioc, element);
8103                         break;
8104                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
8105                         if (!ioc->is_warpdrive)
8106                                 _scsih_sas_pd_delete(ioc, element);
8107                         break;
8108                 }
8109         }
8110 }
8111 
8112 /**
8113  * _scsih_sas_ir_volume_event - IR volume event
8114  * @ioc: per adapter object
8115  * @fw_event: The fw_event_work object
8116  * Context: user.
8117  */
8118 static void
8119 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
8120         struct fw_event_work *fw_event)
8121 {
8122         u64 wwid;
8123         unsigned long flags;
8124         struct _raid_device *raid_device;
8125         u16 handle;
8126         u32 state;
8127         int rc;
8128         Mpi2EventDataIrVolume_t *event_data =
8129                 (Mpi2EventDataIrVolume_t *) fw_event->event_data;
8130 
8131         if (ioc->shost_recovery)
8132                 return;
8133 
8134         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
8135                 return;
8136 
8137         handle = le16_to_cpu(event_data->VolDevHandle);
8138         state = le32_to_cpu(event_data->NewValue);
8139         if (!ioc->hide_ir_msg)
8140                 dewtprintk(ioc,
8141                            ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
8142                                     __func__, handle,
8143                                     le32_to_cpu(event_data->PreviousValue),
8144                                     state));
8145         switch (state) {
8146         case MPI2_RAID_VOL_STATE_MISSING:
8147         case MPI2_RAID_VOL_STATE_FAILED:
8148                 _scsih_sas_volume_delete(ioc, handle);
8149                 break;
8150 
8151         case MPI2_RAID_VOL_STATE_ONLINE:
8152         case MPI2_RAID_VOL_STATE_DEGRADED:
8153         case MPI2_RAID_VOL_STATE_OPTIMAL:
8154 
8155                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
8156                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
8157                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8158 
8159                 if (raid_device)
8160                         break;
8161 
8162                 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
8163                 if (!wwid) {
8164                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
8165                                 __FILE__, __LINE__, __func__);
8166                         break;
8167                 }
8168 
8169                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
8170                 if (!raid_device) {
8171                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
8172                                 __FILE__, __LINE__, __func__);
8173                         break;
8174                 }
8175 
8176                 raid_device->id = ioc->sas_id++;
8177                 raid_device->channel = RAID_CHANNEL;
8178                 raid_device->handle = handle;
8179                 raid_device->wwid = wwid;
8180                 _scsih_raid_device_add(ioc, raid_device);
8181                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
8182                     raid_device->id, 0);
8183                 if (rc)
8184                         _scsih_raid_device_remove(ioc, raid_device);
8185                 break;
8186 
8187         case MPI2_RAID_VOL_STATE_INITIALIZING:
8188         default:
8189                 break;
8190         }
8191 }
8192 
8193 /**
8194  * _scsih_sas_ir_physical_disk_event - PD event
8195  * @ioc: per adapter object
8196  * @fw_event: The fw_event_work object
8197  * Context: user.
8198  */
8199 static void
8200 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
8201         struct fw_event_work *fw_event)
8202 {
8203         u16 handle, parent_handle;
8204         u32 state;
8205         struct _sas_device *sas_device;
8206         Mpi2ConfigReply_t mpi_reply;
8207         Mpi2SasDevicePage0_t sas_device_pg0;
8208         u32 ioc_status;
8209         Mpi2EventDataIrPhysicalDisk_t *event_data =
8210                 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data;
8211         u64 sas_address;
8212 
8213         if (ioc->shost_recovery)
8214                 return;
8215 
8216         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
8217                 return;
8218 
8219         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
8220         state = le32_to_cpu(event_data->NewValue);
8221 
8222         if (!ioc->hide_ir_msg)
8223                 dewtprintk(ioc,
8224                            ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
8225                                     __func__, handle,
8226                                     le32_to_cpu(event_data->PreviousValue),
8227                                     state));
8228 
8229         switch (state) {
8230         case MPI2_RAID_PD_STATE_ONLINE:
8231         case MPI2_RAID_PD_STATE_DEGRADED:
8232         case MPI2_RAID_PD_STATE_REBUILDING:
8233         case MPI2_RAID_PD_STATE_OPTIMAL:
8234         case MPI2_RAID_PD_STATE_HOT_SPARE:
8235 
8236                 if (!ioc->is_warpdrive)
8237                         set_bit(handle, ioc->pd_handles);
8238 
8239                 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
8240                 if (sas_device) {
8241                         sas_device_put(sas_device);
8242                         return;
8243                 }
8244 
8245                 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
8246                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
8247                     handle))) {
8248                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
8249                                 __FILE__, __LINE__, __func__);
8250                         return;
8251                 }
8252 
8253                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8254                     MPI2_IOCSTATUS_MASK;
8255                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
8256                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
8257                                 __FILE__, __LINE__, __func__);
8258                         return;
8259                 }
8260 
8261                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
8262                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
8263                         mpt3sas_transport_update_links(ioc, sas_address, handle,
8264                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
8265 
8266                 _scsih_add_device(ioc, handle, 0, 1);
8267 
8268                 break;
8269 
8270         case MPI2_RAID_PD_STATE_OFFLINE:
8271         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
8272         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
8273         default:
8274                 break;
8275         }
8276 }
8277 
8278 /**
8279  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
8280  * @ioc: per adapter object
8281  * @event_data: event data payload
8282  * Context: user.
8283  */
8284 static void
8285 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
8286         Mpi2EventDataIrOperationStatus_t *event_data)
8287 {
8288         char *reason_str = NULL;
8289 
8290         switch (event_data->RAIDOperation) {
8291         case MPI2_EVENT_IR_RAIDOP_RESYNC:
8292                 reason_str = "resync";
8293                 break;
8294         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
8295                 reason_str = "online capacity expansion";
8296                 break;
8297         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
8298                 reason_str = "consistency check";
8299                 break;
8300         case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
8301                 reason_str = "background init";
8302                 break;
8303         case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
8304                 reason_str = "make data consistent";
8305                 break;
8306         }
8307 
8308         if (!reason_str)
8309                 return;
8310 
8311         ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n",
8312                  reason_str,
8313                  le16_to_cpu(event_data->VolDevHandle),
8314                  event_data->PercentComplete);
8315 }
8316 
8317 /**
8318  * _scsih_sas_ir_operation_status_event - handle RAID operation events
8319  * @ioc: per adapter object
8320  * @fw_event: The fw_event_work object
8321  * Context: user.
8322  */
8323 static void
8324 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
8325         struct fw_event_work *fw_event)
8326 {
8327         Mpi2EventDataIrOperationStatus_t *event_data =
8328                 (Mpi2EventDataIrOperationStatus_t *)
8329                 fw_event->event_data;
8330         static struct _raid_device *raid_device;
8331         unsigned long flags;
8332         u16 handle;
8333 
8334         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
8335             (!ioc->hide_ir_msg))
8336                 _scsih_sas_ir_operation_status_event_debug(ioc,
8337                      event_data);
8338 
8339         /* code added for raid transport support */
8340         if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
8341 
8342                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
8343                 handle = le16_to_cpu(event_data->VolDevHandle);
8344                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
8345                 if (raid_device)
8346                         raid_device->percent_complete =
8347                             event_data->PercentComplete;
8348                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8349         }
8350 }
8351 
8352 /**
8353  * _scsih_prep_device_scan - initialize parameters prior to device scan
8354  * @ioc: per adapter object
8355  *
8356  * Set the deleted flag prior to device scan.  If the device is found during
8357  * the scan, then we clear the deleted flag.
8358  */
8359 static void
8360 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
8361 {
8362         struct MPT3SAS_DEVICE *sas_device_priv_data;
8363         struct scsi_device *sdev;
8364 
8365         shost_for_each_device(sdev, ioc->shost) {
8366                 sas_device_priv_data = sdev->hostdata;
8367                 if (sas_device_priv_data && sas_device_priv_data->sas_target)
8368                         sas_device_priv_data->sas_target->deleted = 1;
8369         }
8370 }
8371 
8372 /**
8373  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
8374  * @ioc: per adapter object
8375  * @sas_device_pg0: SAS Device page 0
8376  *
8377  * After host reset, find out whether devices are still responding.
8378  * Used in _scsih_remove_unresponsive_sas_devices.
8379  */
8380 static void
8381 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc,
8382 Mpi2SasDevicePage0_t *sas_device_pg0)
8383 {
8384         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
8385         struct scsi_target *starget;
8386         struct _sas_device *sas_device = NULL;
8387         struct _enclosure_node *enclosure_dev = NULL;
8388         unsigned long flags;
8389 
8390         if (sas_device_pg0->EnclosureHandle) {
8391                 enclosure_dev =
8392                         mpt3sas_scsih_enclosure_find_by_handle(ioc,
8393                                 le16_to_cpu(sas_device_pg0->EnclosureHandle));
8394                 if (enclosure_dev == NULL)
8395                         ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
8396                                  sas_device_pg0->EnclosureHandle);
8397         }
8398         spin_lock_irqsave(&ioc->sas_device_lock, flags);
8399         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
8400                 if ((sas_device->sas_address == le64_to_cpu(
8401                     sas_device_pg0->SASAddress)) && (sas_device->slot ==
8402                     le16_to_cpu(sas_device_pg0->Slot))) {
8403                         sas_device->responding = 1;
8404                         starget = sas_device->starget;
8405                         if (starget && starget->hostdata) {
8406                                 sas_target_priv_data = starget->hostdata;
8407                                 sas_target_priv_data->tm_busy = 0;
8408                                 sas_target_priv_data->deleted = 0;
8409                         } else
8410                                 sas_target_priv_data = NULL;
8411                         if (starget) {
8412                                 starget_printk(KERN_INFO, starget,
8413                                     "handle(0x%04x), sas_addr(0x%016llx)\n",
8414                                     le16_to_cpu(sas_device_pg0->DevHandle),
8415                                     (unsigned long long)
8416                                     sas_device->sas_address);
8417 
8418                                 if (sas_device->enclosure_handle != 0)
8419                                         starget_printk(KERN_INFO, starget,
8420                                          "enclosure logical id(0x%016llx),"
8421                                          " slot(%d)\n",
8422                                          (unsigned long long)
8423                                          sas_device->enclosure_logical_id,
8424                                          sas_device->slot);
8425                         }
8426                         if (le16_to_cpu(sas_device_pg0->Flags) &
8427                               MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
8428                                 sas_device->enclosure_level =
8429                                    sas_device_pg0->EnclosureLevel;
8430                                 memcpy(&sas_device->connector_name[0],
8431                                         &sas_device_pg0->ConnectorName[0], 4);
8432                         } else {
8433                                 sas_device->enclosure_level = 0;
8434                                 sas_device->connector_name[0] = '\0';
8435                         }
8436 
8437                         sas_device->enclosure_handle =
8438                                 le16_to_cpu(sas_device_pg0->EnclosureHandle);
8439                         sas_device->is_chassis_slot_valid = 0;
8440                         if (enclosure_dev) {
8441                                 sas_device->enclosure_logical_id = le64_to_cpu(
8442                                         enclosure_dev->pg0.EnclosureLogicalID);
8443                                 if (le16_to_cpu(enclosure_dev->pg0.Flags) &
8444                                     MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) {
8445                                         sas_device->is_chassis_slot_valid = 1;
8446                                         sas_device->chassis_slot =
8447                                                 enclosure_dev->pg0.ChassisSlot;
8448                                 }
8449                         }
8450 
8451                         if (sas_device->handle == le16_to_cpu(
8452                             sas_device_pg0->DevHandle))
8453                                 goto out;
8454                         pr_info("\thandle changed from(0x%04x)!!!\n",
8455                             sas_device->handle);
8456                         sas_device->handle = le16_to_cpu(
8457                             sas_device_pg0->DevHandle);
8458                         if (sas_target_priv_data)
8459                                 sas_target_priv_data->handle =
8460                                     le16_to_cpu(sas_device_pg0->DevHandle);
8461                         goto out;
8462                 }
8463         }
8464  out:
8465         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8466 }
8467 
8468 /**
8469  * _scsih_create_enclosure_list_after_reset - Free Existing list,
8470  *      And create enclosure list by scanning all Enclosure Page(0)s
8471  * @ioc: per adapter object
8472  */
8473 static void
8474 _scsih_create_enclosure_list_after_reset(struct MPT3SAS_ADAPTER *ioc)
8475 {
8476         struct _enclosure_node *enclosure_dev;
8477         Mpi2ConfigReply_t mpi_reply;
8478         u16 enclosure_handle;
8479         int rc;
8480 
8481         /* Free existing enclosure list */
8482         mpt3sas_free_enclosure_list(ioc);
8483 
8484         /* Re constructing enclosure list after reset*/
8485         enclosure_handle = 0xFFFF;
8486         do {
8487                 enclosure_dev =
8488                         kzalloc(sizeof(struct _enclosure_node), GFP_KERNEL);
8489                 if (!enclosure_dev) {
8490                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
8491                                 __FILE__, __LINE__, __func__);
8492                         return;
8493                 }
8494                 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
8495                                 &enclosure_dev->pg0,
8496                                 MPI2_SAS_ENCLOS_PGAD_FORM_GET_NEXT_HANDLE,
8497                                 enclosure_handle);
8498 
8499                 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) &
8500                                                 MPI2_IOCSTATUS_MASK)) {
8501                         kfree(enclosure_dev);
8502                         return;
8503                 }
8504                 list_add_tail(&enclosure_dev->list,
8505                                                 &ioc->enclosure_list);
8506                 enclosure_handle =
8507                         le16_to_cpu(enclosure_dev->pg0.EnclosureHandle);
8508         } while (1);
8509 }
8510 
8511 /**
8512  * _scsih_search_responding_sas_devices -
8513  * @ioc: per adapter object
8514  *
8515  * After host reset, find out whether devices are still responding.
8516  * If not remove.
8517  */
8518 static void
8519 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
8520 {
8521         Mpi2SasDevicePage0_t sas_device_pg0;
8522         Mpi2ConfigReply_t mpi_reply;
8523         u16 ioc_status;
8524         u16 handle;
8525         u32 device_info;
8526 
8527         ioc_info(ioc, "search for end-devices: start\n");
8528 
8529         if (list_empty(&ioc->sas_device_list))
8530                 goto out;
8531 
8532         handle = 0xFFFF;
8533         while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
8534             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
8535             handle))) {
8536                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8537                     MPI2_IOCSTATUS_MASK;
8538                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
8539                         break;
8540                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
8541                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
8542                 if (!(_scsih_is_end_device(device_info)))
8543                         continue;
8544                 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0);
8545         }
8546 
8547  out:
8548         ioc_info(ioc, "search for end-devices: complete\n");
8549 }
8550 
8551 /**
8552  * _scsih_mark_responding_pcie_device - mark a pcie_device as responding
8553  * @ioc: per adapter object
8554  * @pcie_device_pg0: PCIe Device page 0
8555  *
8556  * After host reset, find out whether devices are still responding.
8557  * Used in _scsih_remove_unresponding_devices.
8558  */
8559 static void
8560 _scsih_mark_responding_pcie_device(struct MPT3SAS_ADAPTER *ioc,
8561         Mpi26PCIeDevicePage0_t *pcie_device_pg0)
8562 {
8563         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
8564         struct scsi_target *starget;
8565         struct _pcie_device *pcie_device;
8566         unsigned long flags;
8567 
8568         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8569         list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) {
8570                 if ((pcie_device->wwid == le64_to_cpu(pcie_device_pg0->WWID))
8571                     && (pcie_device->slot == le16_to_cpu(
8572                     pcie_device_pg0->Slot))) {
8573                         pcie_device->access_status =
8574                                         pcie_device_pg0->AccessStatus;
8575                         pcie_device->responding = 1;
8576                         starget = pcie_device->starget;
8577                         if (starget && starget->hostdata) {
8578                                 sas_target_priv_data = starget->hostdata;
8579                                 sas_target_priv_data->tm_busy = 0;
8580                                 sas_target_priv_data->deleted = 0;
8581                         } else
8582                                 sas_target_priv_data = NULL;
8583                         if (starget) {
8584                                 starget_printk(KERN_INFO, starget,
8585                                     "handle(0x%04x), wwid(0x%016llx) ",
8586                                     pcie_device->handle,
8587                                     (unsigned long long)pcie_device->wwid);
8588                                 if (pcie_device->enclosure_handle != 0)
8589                                         starget_printk(KERN_INFO, starget,
8590                                             "enclosure logical id(0x%016llx), "
8591                                             "slot(%d)\n",
8592                                             (unsigned long long)
8593                                             pcie_device->enclosure_logical_id,
8594                                             pcie_device->slot);
8595                         }
8596 
8597                         if (((le32_to_cpu(pcie_device_pg0->Flags)) &
8598                             MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) &&
8599                             (ioc->hba_mpi_version_belonged != MPI2_VERSION)) {
8600                                 pcie_device->enclosure_level =
8601                                     pcie_device_pg0->EnclosureLevel;
8602                                 memcpy(&pcie_device->connector_name[0],
8603                                     &pcie_device_pg0->ConnectorName[0], 4);
8604                         } else {
8605                                 pcie_device->enclosure_level = 0;
8606                                 pcie_device->connector_name[0] = '\0';
8607                         }
8608 
8609                         if (pcie_device->handle == le16_to_cpu(
8610                             pcie_device_pg0->DevHandle))
8611                                 goto out;
8612                         pr_info("\thandle changed from(0x%04x)!!!\n",
8613                             pcie_device->handle);
8614                         pcie_device->handle = le16_to_cpu(
8615                             pcie_device_pg0->DevHandle);
8616                         if (sas_target_priv_data)
8617                                 sas_target_priv_data->handle =
8618                                     le16_to_cpu(pcie_device_pg0->DevHandle);
8619                         goto out;
8620                 }
8621         }
8622 
8623  out:
8624         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8625 }
8626 
8627 /**
8628  * _scsih_search_responding_pcie_devices -
8629  * @ioc: per adapter object
8630  *
8631  * After host reset, find out whether devices are still responding.
8632  * If not remove.
8633  */
8634 static void
8635 _scsih_search_responding_pcie_devices(struct MPT3SAS_ADAPTER *ioc)
8636 {
8637         Mpi26PCIeDevicePage0_t pcie_device_pg0;
8638         Mpi2ConfigReply_t mpi_reply;
8639         u16 ioc_status;
8640         u16 handle;
8641         u32 device_info;
8642 
8643         ioc_info(ioc, "search for end-devices: start\n");
8644 
8645         if (list_empty(&ioc->pcie_device_list))
8646                 goto out;
8647 
8648         handle = 0xFFFF;
8649         while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
8650                 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
8651                 handle))) {
8652                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8653                     MPI2_IOCSTATUS_MASK;
8654                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
8655                         ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n",
8656                                  __func__, ioc_status,
8657                                  le32_to_cpu(mpi_reply.IOCLogInfo));
8658                         break;
8659                 }
8660                 handle = le16_to_cpu(pcie_device_pg0.DevHandle);
8661                 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo);
8662                 if (!(_scsih_is_nvme_pciescsi_device(device_info)))
8663                         continue;
8664                 _scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0);
8665         }
8666 out:
8667         ioc_info(ioc, "search for PCIe end-devices: complete\n");
8668 }
8669 
8670 /**
8671  * _scsih_mark_responding_raid_device - mark a raid_device as responding
8672  * @ioc: per adapter object
8673  * @wwid: world wide identifier for raid volume
8674  * @handle: device handle
8675  *
8676  * After host reset, find out whether devices are still responding.
8677  * Used in _scsih_remove_unresponsive_raid_devices.
8678  */
8679 static void
8680 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
8681         u16 handle)
8682 {
8683         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
8684         struct scsi_target *starget;
8685         struct _raid_device *raid_device;
8686         unsigned long flags;
8687 
8688         spin_lock_irqsave(&ioc->raid_device_lock, flags);
8689         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
8690                 if (raid_device->wwid == wwid && raid_device->starget) {
8691                         starget = raid_device->starget;
8692                         if (starget && starget->hostdata) {
8693                                 sas_target_priv_data = starget->hostdata;
8694                                 sas_target_priv_data->deleted = 0;
8695                         } else
8696                                 sas_target_priv_data = NULL;
8697                         raid_device->responding = 1;
8698                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8699                         starget_printk(KERN_INFO, raid_device->starget,
8700                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
8701                             (unsigned long long)raid_device->wwid);
8702 
8703                         /*
8704                          * WARPDRIVE: The handles of the PDs might have changed
8705                          * across the host reset so re-initialize the
8706                          * required data for Direct IO
8707                          */
8708                         mpt3sas_init_warpdrive_properties(ioc, raid_device);
8709                         spin_lock_irqsave(&ioc->raid_device_lock, flags);
8710                         if (raid_device->handle == handle) {
8711                                 spin_unlock_irqrestore(&ioc->raid_device_lock,
8712                                     flags);
8713                                 return;
8714                         }
8715                         pr_info("\thandle changed from(0x%04x)!!!\n",
8716                             raid_device->handle);
8717                         raid_device->handle = handle;
8718                         if (sas_target_priv_data)
8719                                 sas_target_priv_data->handle = handle;
8720                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8721                         return;
8722                 }
8723         }
8724         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
8725 }
8726 
8727 /**
8728  * _scsih_search_responding_raid_devices -
8729  * @ioc: per adapter object
8730  *
8731  * After host reset, find out whether devices are still responding.
8732  * If not remove.
8733  */
8734 static void
8735 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
8736 {
8737         Mpi2RaidVolPage1_t volume_pg1;
8738         Mpi2RaidVolPage0_t volume_pg0;
8739         Mpi2RaidPhysDiskPage0_t pd_pg0;
8740         Mpi2ConfigReply_t mpi_reply;
8741         u16 ioc_status;
8742         u16 handle;
8743         u8 phys_disk_num;
8744 
8745         if (!ioc->ir_firmware)
8746                 return;
8747 
8748         ioc_info(ioc, "search for raid volumes: start\n");
8749 
8750         if (list_empty(&ioc->raid_device_list))
8751                 goto out;
8752 
8753         handle = 0xFFFF;
8754         while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
8755             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
8756                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8757                     MPI2_IOCSTATUS_MASK;
8758                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
8759                         break;
8760                 handle = le16_to_cpu(volume_pg1.DevHandle);
8761 
8762                 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
8763                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
8764                      sizeof(Mpi2RaidVolPage0_t)))
8765                         continue;
8766 
8767                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
8768                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
8769                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
8770                         _scsih_mark_responding_raid_device(ioc,
8771                             le64_to_cpu(volume_pg1.WWID), handle);
8772         }
8773 
8774         /* refresh the pd_handles */
8775         if (!ioc->is_warpdrive) {
8776                 phys_disk_num = 0xFF;
8777                 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
8778                 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
8779                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
8780                     phys_disk_num))) {
8781                         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8782                             MPI2_IOCSTATUS_MASK;
8783                         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
8784                                 break;
8785                         phys_disk_num = pd_pg0.PhysDiskNum;
8786                         handle = le16_to_cpu(pd_pg0.DevHandle);
8787                         set_bit(handle, ioc->pd_handles);
8788                 }
8789         }
8790  out:
8791         ioc_info(ioc, "search for responding raid volumes: complete\n");
8792 }
8793 
8794 /**
8795  * _scsih_mark_responding_expander - mark a expander as responding
8796  * @ioc: per adapter object
8797  * @expander_pg0:SAS Expander Config Page0
8798  *
8799  * After host reset, find out whether devices are still responding.
8800  * Used in _scsih_remove_unresponsive_expanders.
8801  */
8802 static void
8803 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc,
8804         Mpi2ExpanderPage0_t *expander_pg0)
8805 {
8806         struct _sas_node *sas_expander = NULL;
8807         unsigned long flags;
8808         int i;
8809         struct _enclosure_node *enclosure_dev = NULL;
8810         u16 handle = le16_to_cpu(expander_pg0->DevHandle);
8811         u16 enclosure_handle = le16_to_cpu(expander_pg0->EnclosureHandle);
8812         u64 sas_address = le64_to_cpu(expander_pg0->SASAddress);
8813 
8814         if (enclosure_handle)
8815                 enclosure_dev =
8816                         mpt3sas_scsih_enclosure_find_by_handle(ioc,
8817                                                         enclosure_handle);
8818 
8819         spin_lock_irqsave(&ioc->sas_node_lock, flags);
8820         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
8821                 if (sas_expander->sas_address != sas_address)
8822                         continue;
8823                 sas_expander->responding = 1;
8824 
8825                 if (enclosure_dev) {
8826                         sas_expander->enclosure_logical_id =
8827                             le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID);
8828                         sas_expander->enclosure_handle =
8829                             le16_to_cpu(expander_pg0->EnclosureHandle);
8830                 }
8831 
8832                 if (sas_expander->handle == handle)
8833                         goto out;
8834                 pr_info("\texpander(0x%016llx): handle changed" \
8835                     " from(0x%04x) to (0x%04x)!!!\n",
8836                     (unsigned long long)sas_expander->sas_address,
8837                     sas_expander->handle, handle);
8838                 sas_expander->handle = handle;
8839                 for (i = 0 ; i < sas_expander->num_phys ; i++)
8840                         sas_expander->phy[i].handle = handle;
8841                 goto out;
8842         }
8843  out:
8844         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
8845 }
8846 
8847 /**
8848  * _scsih_search_responding_expanders -
8849  * @ioc: per adapter object
8850  *
8851  * After host reset, find out whether devices are still responding.
8852  * If not remove.
8853  */
8854 static void
8855 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
8856 {
8857         Mpi2ExpanderPage0_t expander_pg0;
8858         Mpi2ConfigReply_t mpi_reply;
8859         u16 ioc_status;
8860         u64 sas_address;
8861         u16 handle;
8862 
8863         ioc_info(ioc, "search for expanders: start\n");
8864 
8865         if (list_empty(&ioc->sas_expander_list))
8866                 goto out;
8867 
8868         handle = 0xFFFF;
8869         while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
8870             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
8871 
8872                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
8873                     MPI2_IOCSTATUS_MASK;
8874                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
8875                         break;
8876 
8877                 handle = le16_to_cpu(expander_pg0.DevHandle);
8878                 sas_address = le64_to_cpu(expander_pg0.SASAddress);
8879                 pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n",
8880                         handle,
8881                     (unsigned long long)sas_address);
8882                 _scsih_mark_responding_expander(ioc, &expander_pg0);
8883         }
8884 
8885  out:
8886         ioc_info(ioc, "search for expanders: complete\n");
8887 }
8888 
8889 /**
8890  * _scsih_remove_unresponding_devices - removing unresponding devices
8891  * @ioc: per adapter object
8892  */
8893 static void
8894 _scsih_remove_unresponding_devices(struct MPT3SAS_ADAPTER *ioc)
8895 {
8896         struct _sas_device *sas_device, *sas_device_next;
8897         struct _sas_node *sas_expander, *sas_expander_next;
8898         struct _raid_device *raid_device, *raid_device_next;
8899         struct _pcie_device *pcie_device, *pcie_device_next;
8900         struct list_head tmp_list;
8901         unsigned long flags;
8902         LIST_HEAD(head);
8903 
8904         ioc_info(ioc, "removing unresponding devices: start\n");
8905 
8906         /* removing unresponding end devices */
8907         ioc_info(ioc, "removing unresponding devices: end-devices\n");
8908         /*
8909          * Iterate, pulling off devices marked as non-responding. We become the
8910          * owner for the reference the list had on any object we prune.
8911          */
8912         spin_lock_irqsave(&ioc->sas_device_lock, flags);
8913         list_for_each_entry_safe(sas_device, sas_device_next,
8914             &ioc->sas_device_list, list) {
8915                 if (!sas_device->responding)
8916                         list_move_tail(&sas_device->list, &head);
8917                 else
8918                         sas_device->responding = 0;
8919         }
8920         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8921 
8922         /*
8923          * Now, uninitialize and remove the unresponding devices we pruned.
8924          */
8925         list_for_each_entry_safe(sas_device, sas_device_next, &head, list) {
8926                 _scsih_remove_device(ioc, sas_device);
8927                 list_del_init(&sas_device->list);
8928                 sas_device_put(sas_device);
8929         }
8930 
8931         ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n");
8932         INIT_LIST_HEAD(&head);
8933         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
8934         list_for_each_entry_safe(pcie_device, pcie_device_next,
8935             &ioc->pcie_device_list, list) {
8936                 if (!pcie_device->responding)
8937                         list_move_tail(&pcie_device->list, &head);
8938                 else
8939                         pcie_device->responding = 0;
8940         }
8941         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
8942 
8943         list_for_each_entry_safe(pcie_device, pcie_device_next, &head, list) {
8944                 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
8945                 list_del_init(&pcie_device->list);
8946                 pcie_device_put(pcie_device);
8947         }
8948 
8949         /* removing unresponding volumes */
8950         if (ioc->ir_firmware) {
8951                 ioc_info(ioc, "removing unresponding devices: volumes\n");
8952                 list_for_each_entry_safe(raid_device, raid_device_next,
8953                     &ioc->raid_device_list, list) {
8954                         if (!raid_device->responding)
8955                                 _scsih_sas_volume_delete(ioc,
8956                                     raid_device->handle);
8957                         else
8958                                 raid_device->responding = 0;
8959                 }
8960         }
8961 
8962         /* removing unresponding expanders */
8963         ioc_info(ioc, "removing unresponding devices: expanders\n");
8964         spin_lock_irqsave(&ioc->sas_node_lock, flags);
8965         INIT_LIST_HEAD(&tmp_list);
8966         list_for_each_entry_safe(sas_expander, sas_expander_next,
8967             &ioc->sas_expander_list, list) {
8968                 if (!sas_expander->responding)
8969                         list_move_tail(&sas_expander->list, &tmp_list);
8970                 else
8971                         sas_expander->responding = 0;
8972         }
8973         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
8974         list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
8975             list) {
8976                 _scsih_expander_node_remove(ioc, sas_expander);
8977         }
8978 
8979         ioc_info(ioc, "removing unresponding devices: complete\n");
8980 
8981         /* unblock devices */
8982         _scsih_ublock_io_all_device(ioc);
8983 }
8984 
8985 static void
8986 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
8987         struct _sas_node *sas_expander, u16 handle)
8988 {
8989         Mpi2ExpanderPage1_t expander_pg1;
8990         Mpi2ConfigReply_t mpi_reply;
8991         int i;
8992 
8993         for (i = 0 ; i < sas_expander->num_phys ; i++) {
8994                 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
8995                     &expander_pg1, i, handle))) {
8996                         ioc_err(ioc, "failure at %s:%d/%s()!\n",
8997                                 __FILE__, __LINE__, __func__);
8998                         return;
8999                 }
9000 
9001                 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
9002                     le16_to_cpu(expander_pg1.AttachedDevHandle), i,
9003                     expander_pg1.NegotiatedLinkRate >> 4);
9004         }
9005 }
9006 
9007 /**
9008  * _scsih_scan_for_devices_after_reset - scan for devices after host reset
9009  * @ioc: per adapter object
9010  */
9011 static void
9012 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
9013 {
9014         Mpi2ExpanderPage0_t expander_pg0;
9015         Mpi2SasDevicePage0_t sas_device_pg0;
9016         Mpi26PCIeDevicePage0_t pcie_device_pg0;
9017         Mpi2RaidVolPage1_t volume_pg1;
9018         Mpi2RaidVolPage0_t volume_pg0;
9019         Mpi2RaidPhysDiskPage0_t pd_pg0;
9020         Mpi2EventIrConfigElement_t element;
9021         Mpi2ConfigReply_t mpi_reply;
9022         u8 phys_disk_num;
9023         u16 ioc_status;
9024         u16 handle, parent_handle;
9025         u64 sas_address;
9026         struct _sas_device *sas_device;
9027         struct _pcie_device *pcie_device;
9028         struct _sas_node *expander_device;
9029         static struct _raid_device *raid_device;
9030         u8 retry_count;
9031         unsigned long flags;
9032 
9033         ioc_info(ioc, "scan devices: start\n");
9034 
9035         _scsih_sas_host_refresh(ioc);
9036 
9037         ioc_info(ioc, "\tscan devices: expanders start\n");
9038 
9039         /* expanders */
9040         handle = 0xFFFF;
9041         while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
9042             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
9043                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9044                     MPI2_IOCSTATUS_MASK;
9045                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9046                         ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9047                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9048                         break;
9049                 }
9050                 handle = le16_to_cpu(expander_pg0.DevHandle);
9051                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
9052                 expander_device = mpt3sas_scsih_expander_find_by_sas_address(
9053                     ioc, le64_to_cpu(expander_pg0.SASAddress));
9054                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
9055                 if (expander_device)
9056                         _scsih_refresh_expander_links(ioc, expander_device,
9057                             handle);
9058                 else {
9059                         ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
9060                                  handle,
9061                                  (u64)le64_to_cpu(expander_pg0.SASAddress));
9062                         _scsih_expander_add(ioc, handle);
9063                         ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
9064                                  handle,
9065                                  (u64)le64_to_cpu(expander_pg0.SASAddress));
9066                 }
9067         }
9068 
9069         ioc_info(ioc, "\tscan devices: expanders complete\n");
9070 
9071         if (!ioc->ir_firmware)
9072                 goto skip_to_sas;
9073 
9074         ioc_info(ioc, "\tscan devices: phys disk start\n");
9075 
9076         /* phys disk */
9077         phys_disk_num = 0xFF;
9078         while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
9079             &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
9080             phys_disk_num))) {
9081                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9082                     MPI2_IOCSTATUS_MASK;
9083                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9084                         ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9085                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9086                         break;
9087                 }
9088                 phys_disk_num = pd_pg0.PhysDiskNum;
9089                 handle = le16_to_cpu(pd_pg0.DevHandle);
9090                 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
9091                 if (sas_device) {
9092                         sas_device_put(sas_device);
9093                         continue;
9094                 }
9095                 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9096                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
9097                     handle) != 0)
9098                         continue;
9099                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9100                     MPI2_IOCSTATUS_MASK;
9101                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9102                         ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n",
9103                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9104                         break;
9105                 }
9106                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
9107                 if (!_scsih_get_sas_address(ioc, parent_handle,
9108                     &sas_address)) {
9109                         ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
9110                                  handle,
9111                                  (u64)le64_to_cpu(sas_device_pg0.SASAddress));
9112                         mpt3sas_transport_update_links(ioc, sas_address,
9113                             handle, sas_device_pg0.PhyNum,
9114                             MPI2_SAS_NEG_LINK_RATE_1_5);
9115                         set_bit(handle, ioc->pd_handles);
9116                         retry_count = 0;
9117                         /* This will retry adding the end device.
9118                          * _scsih_add_device() will decide on retries and
9119                          * return "1" when it should be retried
9120                          */
9121                         while (_scsih_add_device(ioc, handle, retry_count++,
9122                             1)) {
9123                                 ssleep(1);
9124                         }
9125                         ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
9126                                  handle,
9127                                  (u64)le64_to_cpu(sas_device_pg0.SASAddress));
9128                 }
9129         }
9130 
9131         ioc_info(ioc, "\tscan devices: phys disk complete\n");
9132 
9133         ioc_info(ioc, "\tscan devices: volumes start\n");
9134 
9135         /* volumes */
9136         handle = 0xFFFF;
9137         while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
9138             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
9139                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9140                     MPI2_IOCSTATUS_MASK;
9141                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9142                         ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9143                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9144                         break;
9145                 }
9146                 handle = le16_to_cpu(volume_pg1.DevHandle);
9147                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
9148                 raid_device = _scsih_raid_device_find_by_wwid(ioc,
9149                     le64_to_cpu(volume_pg1.WWID));
9150                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
9151                 if (raid_device)
9152                         continue;
9153                 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
9154                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
9155                      sizeof(Mpi2RaidVolPage0_t)))
9156                         continue;
9157                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9158                     MPI2_IOCSTATUS_MASK;
9159                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9160                         ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9161                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9162                         break;
9163                 }
9164                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
9165                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
9166                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) {
9167                         memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
9168                         element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
9169                         element.VolDevHandle = volume_pg1.DevHandle;
9170                         ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n",
9171                                  volume_pg1.DevHandle);
9172                         _scsih_sas_volume_add(ioc, &element);
9173                         ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n",
9174                                  volume_pg1.DevHandle);
9175                 }
9176         }
9177 
9178         ioc_info(ioc, "\tscan devices: volumes complete\n");
9179 
9180  skip_to_sas:
9181 
9182         ioc_info(ioc, "\tscan devices: end devices start\n");
9183 
9184         /* sas devices */
9185         handle = 0xFFFF;
9186         while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
9187             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
9188             handle))) {
9189                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
9190                     MPI2_IOCSTATUS_MASK;
9191                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9192                         ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9193                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9194                         break;
9195                 }
9196                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
9197                 if (!(_scsih_is_end_device(
9198                     le32_to_cpu(sas_device_pg0.DeviceInfo))))
9199                         continue;
9200                 sas_device = mpt3sas_get_sdev_by_addr(ioc,
9201                     le64_to_cpu(sas_device_pg0.SASAddress));
9202                 if (sas_device) {
9203                         sas_device_put(sas_device);
9204                         continue;
9205                 }
9206                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
9207                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
9208                         ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
9209                                  handle,
9210                                  (u64)le64_to_cpu(sas_device_pg0.SASAddress));
9211                         mpt3sas_transport_update_links(ioc, sas_address, handle,
9212                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
9213                         retry_count = 0;
9214                         /* This will retry adding the end device.
9215                          * _scsih_add_device() will decide on retries and
9216                          * return "1" when it should be retried
9217                          */
9218                         while (_scsih_add_device(ioc, handle, retry_count++,
9219                             0)) {
9220                                 ssleep(1);
9221                         }
9222                         ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
9223                                  handle,
9224                                  (u64)le64_to_cpu(sas_device_pg0.SASAddress));
9225                 }
9226         }
9227         ioc_info(ioc, "\tscan devices: end devices complete\n");
9228         ioc_info(ioc, "\tscan devices: pcie end devices start\n");
9229 
9230         /* pcie devices */
9231         handle = 0xFFFF;
9232         while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
9233                 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
9234                 handle))) {
9235                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus)
9236                                 & MPI2_IOCSTATUS_MASK;
9237                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
9238                         ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
9239                                  ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
9240                         break;
9241                 }
9242                 handle = le16_to_cpu(pcie_device_pg0.DevHandle);
9243                 if (!(_scsih_is_nvme_pciescsi_device(
9244                         le32_to_cpu(pcie_device_pg0.DeviceInfo))))
9245                         continue;
9246                 pcie_device = mpt3sas_get_pdev_by_wwid(ioc,
9247                                 le64_to_cpu(pcie_device_pg0.WWID));
9248                 if (pcie_device) {
9249                         pcie_device_put(pcie_device);
9250                         continue;
9251                 }
9252                 retry_count = 0;
9253                 parent_handle = le16_to_cpu(pcie_device_pg0.ParentDevHandle);
9254                 _scsih_pcie_add_device(ioc, handle);
9255 
9256                 ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n",
9257                          handle, (u64)le64_to_cpu(pcie_device_pg0.WWID));
9258         }
9259         ioc_info(ioc, "\tpcie devices: pcie end devices complete\n");
9260         ioc_info(ioc, "scan devices: complete\n");
9261 }
9262 
9263 /**
9264  * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
9265  * @ioc: per adapter object
9266  *
9267  * The handler for doing any required cleanup or initialization.
9268  */
9269 void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
9270 {
9271         dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
9272 }
9273 
9274 /**
9275  * mpt3sas_scsih_after_reset_handler - reset callback handler (for scsih)
9276  * @ioc: per adapter object
9277  *
9278  * The handler for doing any required cleanup or initialization.
9279  */
9280 void
9281 mpt3sas_scsih_after_reset_handler(struct MPT3SAS_ADAPTER *ioc)
9282 {
9283         dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_AFTER_RESET\n", __func__));
9284         if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
9285                 ioc->scsih_cmds.status |= MPT3_CMD_RESET;
9286                 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
9287                 complete(&ioc->scsih_cmds.done);
9288         }
9289         if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
9290                 ioc->tm_cmds.status |= MPT3_CMD_RESET;
9291                 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
9292                 complete(&ioc->tm_cmds.done);
9293         }
9294 
9295         memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz);
9296         memset(ioc->device_remove_in_progress, 0,
9297                ioc->device_remove_in_progress_sz);
9298         _scsih_fw_event_cleanup_queue(ioc);
9299         _scsih_flush_running_cmds(ioc);
9300 }
9301 
9302 /**
9303  * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
9304  * @ioc: per adapter object
9305  *
9306  * The handler for doing any required cleanup or initialization.
9307  */
9308 void
9309 mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
9310 {
9311         dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
9312         if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
9313                                            !ioc->sas_hba.num_phys)) {
9314                 _scsih_prep_device_scan(ioc);
9315                 _scsih_create_enclosure_list_after_reset(ioc);
9316                 _scsih_search_responding_sas_devices(ioc);
9317                 _scsih_search_responding_pcie_devices(ioc);
9318                 _scsih_search_responding_raid_devices(ioc);
9319                 _scsih_search_responding_expanders(ioc);
9320                 _scsih_error_recovery_delete_devices(ioc);
9321         }
9322 }
9323 
9324 /**
9325  * _mpt3sas_fw_work - delayed task for processing firmware events
9326  * @ioc: per adapter object
9327  * @fw_event: The fw_event_work object
9328  * Context: user.
9329  */
9330 static void
9331 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
9332 {
9333         _scsih_fw_event_del_from_list(ioc, fw_event);
9334 
9335         /* the queue is being flushed so ignore this event */
9336         if (ioc->remove_host || ioc->pci_error_recovery) {
9337                 fw_event_work_put(fw_event);
9338                 return;
9339         }
9340 
9341         switch (fw_event->event) {
9342         case MPT3SAS_PROCESS_TRIGGER_DIAG:
9343                 mpt3sas_process_trigger_data(ioc,
9344                         (struct SL_WH_TRIGGERS_EVENT_DATA_T *)
9345                         fw_event->event_data);
9346                 break;
9347         case MPT3SAS_REMOVE_UNRESPONDING_DEVICES:
9348                 while (scsi_host_in_recovery(ioc->shost) ||
9349                                          ioc->shost_recovery) {
9350                         /*
9351                          * If we're unloading, bail. Otherwise, this can become
9352                          * an infinite loop.
9353                          */
9354                         if (ioc->remove_host)
9355                                 goto out;
9356                         ssleep(1);
9357                 }
9358                 _scsih_remove_unresponding_devices(ioc);
9359                 _scsih_scan_for_devices_after_reset(ioc);
9360                 break;
9361         case MPT3SAS_PORT_ENABLE_COMPLETE:
9362                 ioc->start_scan = 0;
9363                 if (missing_delay[0] != -1 && missing_delay[1] != -1)
9364                         mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
9365                             missing_delay[1]);
9366                 dewtprintk(ioc,
9367                            ioc_info(ioc, "port enable: complete from worker thread\n"));
9368                 break;
9369         case MPT3SAS_TURN_ON_PFA_LED:
9370                 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
9371                 break;
9372         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
9373                 _scsih_sas_topology_change_event(ioc, fw_event);
9374                 break;
9375         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
9376                 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
9377                         _scsih_sas_device_status_change_event_debug(ioc,
9378                             (Mpi2EventDataSasDeviceStatusChange_t *)
9379                             fw_event->event_data);
9380                 break;
9381         case MPI2_EVENT_SAS_DISCOVERY:
9382                 _scsih_sas_discovery_event(ioc, fw_event);
9383                 break;
9384         case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR:
9385                 _scsih_sas_device_discovery_error_event(ioc, fw_event);
9386                 break;
9387         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
9388                 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
9389                 break;
9390         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
9391                 _scsih_sas_enclosure_dev_status_change_event(ioc,
9392                     fw_event);
9393                 break;
9394         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
9395                 _scsih_sas_ir_config_change_event(ioc, fw_event);
9396                 break;
9397         case MPI2_EVENT_IR_VOLUME:
9398                 _scsih_sas_ir_volume_event(ioc, fw_event);
9399                 break;
9400         case MPI2_EVENT_IR_PHYSICAL_DISK:
9401                 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
9402                 break;
9403         case MPI2_EVENT_IR_OPERATION_STATUS:
9404                 _scsih_sas_ir_operation_status_event(ioc, fw_event);
9405                 break;
9406         case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE:
9407                 _scsih_pcie_device_status_change_event(ioc, fw_event);
9408                 break;
9409         case MPI2_EVENT_PCIE_ENUMERATION:
9410                 _scsih_pcie_enumeration_event(ioc, fw_event);
9411                 break;
9412         case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
9413                 _scsih_pcie_topology_change_event(ioc, fw_event);
9414                         return;
9415         break;
9416         }
9417 out:
9418         fw_event_work_put(fw_event);
9419 }
9420 
9421 /**
9422  * _firmware_event_work
9423  * @work: The fw_event_work object
9424  * Context: user.
9425  *
9426  * wrappers for the work thread handling firmware events
9427  */
9428 
9429 static void
9430 _firmware_event_work(struct work_struct *work)
9431 {
9432         struct fw_event_work *fw_event = container_of(work,
9433             struct fw_event_work, work);
9434 
9435         _mpt3sas_fw_work(fw_event->ioc, fw_event);
9436 }
9437 
9438 /**
9439  * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time)
9440  * @ioc: per adapter object
9441  * @msix_index: MSIX table index supplied by the OS
9442  * @reply: reply message frame(lower 32bit addr)
9443  * Context: interrupt.
9444  *
9445  * This function merely adds a new work task into ioc->firmware_event_thread.
9446  * The tasks are worked from _firmware_event_work in user context.
9447  *
9448  * Return: 1 meaning mf should be freed from _base_interrupt
9449  *         0 means the mf is freed from this function.
9450  */
9451 u8
9452 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
9453         u32 reply)
9454 {
9455         struct fw_event_work *fw_event;
9456         Mpi2EventNotificationReply_t *mpi_reply;
9457         u16 event;
9458         u16 sz;
9459         Mpi26EventDataActiveCableExcept_t *ActiveCableEventData;
9460 
9461         /* events turned off due to host reset */
9462         if (ioc->pci_error_recovery)
9463                 return 1;
9464 
9465         mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
9466 
9467         if (unlikely(!mpi_reply)) {
9468                 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
9469                         __FILE__, __LINE__, __func__);
9470                 return 1;
9471         }
9472 
9473         event = le16_to_cpu(mpi_reply->Event);
9474 
9475         if (event != MPI2_EVENT_LOG_ENTRY_ADDED)
9476                 mpt3sas_trigger_event(ioc, event, 0);
9477 
9478         switch (event) {
9479         /* handle these */
9480         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
9481         {
9482                 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
9483                     (Mpi2EventDataSasBroadcastPrimitive_t *)
9484                     mpi_reply->EventData;
9485 
9486                 if (baen_data->Primitive !=
9487                     MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
9488                         return 1;
9489 
9490                 if (ioc->broadcast_aen_busy) {
9491                         ioc->broadcast_aen_pending++;
9492                         return 1;
9493                 } else
9494                         ioc->broadcast_aen_busy = 1;
9495                 break;
9496         }
9497 
9498         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
9499                 _scsih_check_topo_delete_events(ioc,
9500                     (Mpi2EventDataSasTopologyChangeList_t *)
9501                     mpi_reply->EventData);
9502                 break;
9503         case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
9504         _scsih_check_pcie_topo_remove_events(ioc,
9505                     (Mpi26EventDataPCIeTopologyChangeList_t *)
9506                     mpi_reply->EventData);
9507                 break;
9508         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
9509                 _scsih_check_ir_config_unhide_events(ioc,
9510                     (Mpi2EventDataIrConfigChangeList_t *)
9511                     mpi_reply->EventData);
9512                 break;
9513         case MPI2_EVENT_IR_VOLUME:
9514                 _scsih_check_volume_delete_events(ioc,
9515                     (Mpi2EventDataIrVolume_t *)
9516                     mpi_reply->EventData);
9517                 break;
9518         case MPI2_EVENT_LOG_ENTRY_ADDED:
9519         {
9520                 Mpi2EventDataLogEntryAdded_t *log_entry;
9521                 u32 *log_code;
9522 
9523                 if (!ioc->is_warpdrive)
9524                         break;
9525 
9526                 log_entry = (Mpi2EventDataLogEntryAdded_t *)
9527                     mpi_reply->EventData;
9528                 log_code = (u32 *)log_entry->LogData;
9529 
9530                 if (le16_to_cpu(log_entry->LogEntryQualifier)
9531                     != MPT2_WARPDRIVE_LOGENTRY)
9532                         break;
9533 
9534                 switch (le32_to_cpu(*log_code)) {
9535                 case MPT2_WARPDRIVE_LC_SSDT:
9536                         ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
9537                         break;
9538                 case MPT2_WARPDRIVE_LC_SSDLW:
9539                         ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n");
9540                         break;
9541                 case MPT2_WARPDRIVE_LC_SSDLF:
9542                         ioc_err(ioc, "WarpDrive Fatal Error: There are no Program/Erase Cycles for the WarpDrive subsystem. The storage device will be in read-only mode. Check WarpDrive documentation for additional details.\n");
9543                         break;
9544                 case MPT2_WARPDRIVE_LC_BRMF:
9545                         ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
9546                         break;
9547                 }
9548 
9549                 break;
9550         }
9551         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
9552                 _scsih_sas_device_status_change_event(ioc,
9553                     (Mpi2EventDataSasDeviceStatusChange_t *)
9554                     mpi_reply->EventData);
9555                 break;
9556         case MPI2_EVENT_IR_OPERATION_STATUS:
9557         case MPI2_EVENT_SAS_DISCOVERY:
9558         case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR:
9559         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
9560         case MPI2_EVENT_IR_PHYSICAL_DISK:
9561         case MPI2_EVENT_PCIE_ENUMERATION:
9562         case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE:
9563                 break;
9564 
9565         case MPI2_EVENT_TEMP_THRESHOLD:
9566                 _scsih_temp_threshold_events(ioc,
9567                         (Mpi2EventDataTemperature_t *)
9568                         mpi_reply->EventData);
9569                 break;
9570         case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION:
9571                 ActiveCableEventData =
9572                     (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData;
9573                 switch (ActiveCableEventData->ReasonCode) {
9574                 case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER:
9575                         ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n",
9576                                    ActiveCableEventData->ReceptacleID);
9577                         pr_notice("cannot be powered and devices connected\n");
9578                         pr_notice("to this active cable will not be seen\n");
9579                         pr_notice("This active cable requires %d mW of power\n",
9580                              ActiveCableEventData->ActiveCablePowerRequirement);
9581                         break;
9582 
9583                 case MPI26_EVENT_ACTIVE_CABLE_DEGRADED:
9584                         ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n",
9585                                    ActiveCableEventData->ReceptacleID);
9586                         pr_notice(
9587                             "is not running at optimal speed(12 Gb/s rate)\n");
9588                         break;
9589                 }
9590 
9591                 break;
9592 
9593         default: /* ignore the rest */
9594                 return 1;
9595         }
9596 
9597         sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
9598         fw_event = alloc_fw_event_work(sz);
9599         if (!fw_event) {
9600                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
9601                         __FILE__, __LINE__, __func__);
9602                 return 1;
9603         }
9604 
9605         memcpy(fw_event->event_data, mpi_reply->EventData, sz);
9606         fw_event->ioc = ioc;
9607         fw_event->VF_ID = mpi_reply->VF_ID;
9608         fw_event->VP_ID = mpi_reply->VP_ID;
9609         fw_event->event = event;
9610         _scsih_fw_event_add(ioc, fw_event);
9611         fw_event_work_put(fw_event);
9612         return 1;
9613 }
9614 
9615 /**
9616  * _scsih_expander_node_remove - removing expander device from list.
9617  * @ioc: per adapter object
9618  * @sas_expander: the sas_device object
9619  *
9620  * Removing object and freeing associated memory from the
9621  * ioc->sas_expander_list.
9622  */
9623 static void
9624 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
9625         struct _sas_node *sas_expander)
9626 {
9627         struct _sas_port *mpt3sas_port, *next;
9628         unsigned long flags;
9629 
9630         /* remove sibling ports attached to this expander */
9631         list_for_each_entry_safe(mpt3sas_port, next,
9632            &sas_expander->sas_port_list, port_list) {
9633                 if (ioc->shost_recovery)
9634                         return;
9635                 if (mpt3sas_port->remote_identify.device_type ==
9636                     SAS_END_DEVICE)
9637                         mpt3sas_device_remove_by_sas_address(ioc,
9638                             mpt3sas_port->remote_identify.sas_address);
9639                 else if (mpt3sas_port->remote_identify.device_type ==
9640                     SAS_EDGE_EXPANDER_DEVICE ||
9641                     mpt3sas_port->remote_identify.device_type ==
9642                     SAS_FANOUT_EXPANDER_DEVICE)
9643                         mpt3sas_expander_remove(ioc,
9644                             mpt3sas_port->remote_identify.sas_address);
9645         }
9646 
9647         mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
9648             sas_expander->sas_address_parent);
9649 
9650         ioc_info(ioc, "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
9651                  sas_expander->handle, (unsigned long long)
9652                  sas_expander->sas_address);
9653 
9654         spin_lock_irqsave(&ioc->sas_node_lock, flags);
9655         list_del(&sas_expander->list);
9656         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
9657 
9658         kfree(sas_expander->phy);
9659         kfree(sas_expander);
9660 }
9661 
9662 /**
9663  * _scsih_ir_shutdown - IR shutdown notification
9664  * @ioc: per adapter object
9665  *
9666  * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
9667  * the host system is shutting down.
9668  */
9669 static void
9670 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
9671 {
9672         Mpi2RaidActionRequest_t *mpi_request;
9673         Mpi2RaidActionReply_t *mpi_reply;
9674         u16 smid;
9675 
9676         /* is IR firmware build loaded ? */
9677         if (!ioc->ir_firmware)
9678                 return;
9679 
9680         /* are there any volumes ? */
9681         if (list_empty(&ioc->raid_device_list))
9682                 return;
9683 
9684         mutex_lock(&ioc->scsih_cmds.mutex);
9685 
9686         if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
9687                 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
9688                 goto out;
9689         }
9690         ioc->scsih_cmds.status = MPT3_CMD_PENDING;
9691 
9692         smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
9693         if (!smid) {
9694                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
9695                 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
9696                 goto out;
9697         }
9698 
9699         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
9700         ioc->scsih_cmds.smid = smid;
9701         memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
9702 
9703         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
9704         mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
9705 
9706         if (!ioc->hide_ir_msg)
9707                 ioc_info(ioc, "IR shutdown (sending)\n");
9708         init_completion(&ioc->scsih_cmds.done);
9709         ioc->put_smid_default(ioc, smid);
9710         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
9711 
9712         if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
9713                 ioc_err(ioc, "%s: timeout\n", __func__);
9714                 goto out;
9715         }
9716 
9717         if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
9718                 mpi_reply = ioc->scsih_cmds.reply;
9719                 if (!ioc->hide_ir_msg)
9720                         ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
9721                                  le16_to_cpu(mpi_reply->IOCStatus),
9722                                  le32_to_cpu(mpi_reply->IOCLogInfo));
9723         }
9724 
9725  out:
9726         ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
9727         mutex_unlock(&ioc->scsih_cmds.mutex);
9728 }
9729 
9730 /**
9731  * scsih_remove - detach and remove add host
9732  * @pdev: PCI device struct
9733  *
9734  * Routine called when unloading the driver.
9735  */
9736 static void scsih_remove(struct pci_dev *pdev)
9737 {
9738         struct Scsi_Host *shost = pci_get_drvdata(pdev);
9739         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9740         struct _sas_port *mpt3sas_port, *next_port;
9741         struct _raid_device *raid_device, *next;
9742         struct MPT3SAS_TARGET *sas_target_priv_data;
9743         struct _pcie_device *pcie_device, *pcienext;
9744         struct workqueue_struct *wq;
9745         unsigned long flags;
9746         Mpi2ConfigReply_t mpi_reply;
9747 
9748         ioc->remove_host = 1;
9749 
9750         if (!pci_device_is_present(pdev))
9751                 _scsih_flush_running_cmds(ioc);
9752 
9753         _scsih_fw_event_cleanup_queue(ioc);
9754 
9755         spin_lock_irqsave(&ioc->fw_event_lock, flags);
9756         wq = ioc->firmware_event_thread;
9757         ioc->firmware_event_thread = NULL;
9758         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
9759         if (wq)
9760                 destroy_workqueue(wq);
9761         /*
9762          * Copy back the unmodified ioc page1. so that on next driver load,
9763          * current modified changes on ioc page1 won't take effect.
9764          */
9765         if (ioc->is_aero_ioc)
9766                 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply,
9767                                 &ioc->ioc_pg1_copy);
9768         /* release all the volumes */
9769         _scsih_ir_shutdown(ioc);
9770         sas_remove_host(shost);
9771         list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
9772             list) {
9773                 if (raid_device->starget) {
9774                         sas_target_priv_data =
9775                             raid_device->starget->hostdata;
9776                         sas_target_priv_data->deleted = 1;
9777                         scsi_remove_target(&raid_device->starget->dev);
9778                 }
9779                 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
9780                          raid_device->handle, (u64)raid_device->wwid);
9781                 _scsih_raid_device_remove(ioc, raid_device);
9782         }
9783         list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list,
9784                 list) {
9785                 _scsih_pcie_device_remove_from_sml(ioc, pcie_device);
9786                 list_del_init(&pcie_device->list);
9787                 pcie_device_put(pcie_device);
9788         }
9789 
9790         /* free ports attached to the sas_host */
9791         list_for_each_entry_safe(mpt3sas_port, next_port,
9792            &ioc->sas_hba.sas_port_list, port_list) {
9793                 if (mpt3sas_port->remote_identify.device_type ==
9794                     SAS_END_DEVICE)
9795                         mpt3sas_device_remove_by_sas_address(ioc,
9796                             mpt3sas_port->remote_identify.sas_address);
9797                 else if (mpt3sas_port->remote_identify.device_type ==
9798                     SAS_EDGE_EXPANDER_DEVICE ||
9799                     mpt3sas_port->remote_identify.device_type ==
9800                     SAS_FANOUT_EXPANDER_DEVICE)
9801                         mpt3sas_expander_remove(ioc,
9802                             mpt3sas_port->remote_identify.sas_address);
9803         }
9804 
9805         /* free phys attached to the sas_host */
9806         if (ioc->sas_hba.num_phys) {
9807                 kfree(ioc->sas_hba.phy);
9808                 ioc->sas_hba.phy = NULL;
9809                 ioc->sas_hba.num_phys = 0;
9810         }
9811 
9812         mpt3sas_base_detach(ioc);
9813         spin_lock(&gioc_lock);
9814         list_del(&ioc->list);
9815         spin_unlock(&gioc_lock);
9816         scsi_host_put(shost);
9817 }
9818 
9819 /**
9820  * scsih_shutdown - routine call during system shutdown
9821  * @pdev: PCI device struct
9822  */
9823 static void
9824 scsih_shutdown(struct pci_dev *pdev)
9825 {
9826         struct Scsi_Host *shost = pci_get_drvdata(pdev);
9827         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9828         struct workqueue_struct *wq;
9829         unsigned long flags;
9830         Mpi2ConfigReply_t mpi_reply;
9831 
9832         ioc->remove_host = 1;
9833 
9834         if (!pci_device_is_present(pdev))
9835                 _scsih_flush_running_cmds(ioc);
9836 
9837         _scsih_fw_event_cleanup_queue(ioc);
9838 
9839         spin_lock_irqsave(&ioc->fw_event_lock, flags);
9840         wq = ioc->firmware_event_thread;
9841         ioc->firmware_event_thread = NULL;
9842         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
9843         if (wq)
9844                 destroy_workqueue(wq);
9845         /*
9846          * Copy back the unmodified ioc page1 so that on next driver load,
9847          * current modified changes on ioc page1 won't take effect.
9848          */
9849         if (ioc->is_aero_ioc)
9850                 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply,
9851                                 &ioc->ioc_pg1_copy);
9852 
9853         _scsih_ir_shutdown(ioc);
9854         mpt3sas_base_detach(ioc);
9855 }
9856 
9857 
9858 /**
9859  * _scsih_probe_boot_devices - reports 1st device
9860  * @ioc: per adapter object
9861  *
9862  * If specified in bios page 2, this routine reports the 1st
9863  * device scsi-ml or sas transport for persistent boot device
9864  * purposes.  Please refer to function _scsih_determine_boot_device()
9865  */
9866 static void
9867 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
9868 {
9869         u32 channel;
9870         void *device;
9871         struct _sas_device *sas_device;
9872         struct _raid_device *raid_device;
9873         struct _pcie_device *pcie_device;
9874         u16 handle;
9875         u64 sas_address_parent;
9876         u64 sas_address;
9877         unsigned long flags;
9878         int rc;
9879         int tid;
9880 
9881          /* no Bios, return immediately */
9882         if (!ioc->bios_pg3.BiosVersion)
9883                 return;
9884 
9885         device = NULL;
9886         if (ioc->req_boot_device.device) {
9887                 device =  ioc->req_boot_device.device;
9888                 channel = ioc->req_boot_device.channel;
9889         } else if (ioc->req_alt_boot_device.device) {
9890                 device =  ioc->req_alt_boot_device.device;
9891                 channel = ioc->req_alt_boot_device.channel;
9892         } else if (ioc->current_boot_device.device) {
9893                 device =  ioc->current_boot_device.device;
9894                 channel = ioc->current_boot_device.channel;
9895         }
9896 
9897         if (!device)
9898                 return;
9899 
9900         if (channel == RAID_CHANNEL) {
9901                 raid_device = device;
9902                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9903                     raid_device->id, 0);
9904                 if (rc)
9905                         _scsih_raid_device_remove(ioc, raid_device);
9906         } else if (channel == PCIE_CHANNEL) {
9907                 spin_lock_irqsave(&ioc->pcie_device_lock, flags);
9908                 pcie_device = device;
9909                 tid = pcie_device->id;
9910                 list_move_tail(&pcie_device->list, &ioc->pcie_device_list);
9911                 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
9912                 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, tid, 0);
9913                 if (rc)
9914                         _scsih_pcie_device_remove(ioc, pcie_device);
9915         } else {
9916                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
9917                 sas_device = device;
9918                 handle = sas_device->handle;
9919                 sas_address_parent = sas_device->sas_address_parent;
9920                 sas_address = sas_device->sas_address;
9921                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
9922                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9923 
9924                 if (ioc->hide_drives)
9925                         return;
9926                 if (!mpt3sas_transport_port_add(ioc, handle,
9927                     sas_address_parent)) {
9928                         _scsih_sas_device_remove(ioc, sas_device);
9929                 } else if (!sas_device->starget) {
9930                         if (!ioc->is_driver_loading) {
9931                                 mpt3sas_transport_port_remove(ioc,
9932                                     sas_address,
9933                                     sas_address_parent);
9934                                 _scsih_sas_device_remove(ioc, sas_device);
9935                         }
9936                 }
9937         }
9938 }
9939 
9940 /**
9941  * _scsih_probe_raid - reporting raid volumes to scsi-ml
9942  * @ioc: per adapter object
9943  *
9944  * Called during initial loading of the driver.
9945  */
9946 static void
9947 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
9948 {
9949         struct _raid_device *raid_device, *raid_next;
9950         int rc;
9951 
9952         list_for_each_entry_safe(raid_device, raid_next,
9953             &ioc->raid_device_list, list) {
9954                 if (raid_device->starget)
9955                         continue;
9956                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
9957                     raid_device->id, 0);
9958                 if (rc)
9959                         _scsih_raid_device_remove(ioc, raid_device);
9960         }
9961 }
9962 
9963 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc)
9964 {
9965         struct _sas_device *sas_device = NULL;
9966         unsigned long flags;
9967 
9968         spin_lock_irqsave(&ioc->sas_device_lock, flags);
9969         if (!list_empty(&ioc->sas_device_init_list)) {
9970                 sas_device = list_first_entry(&ioc->sas_device_init_list,
9971                                 struct _sas_device, list);
9972                 sas_device_get(sas_device);
9973         }
9974         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
9975 
9976         return sas_device;
9977 }
9978 
9979 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc,
9980                 struct _sas_device *sas_device)
9981 {
9982         unsigned long flags;
9983 
9984         spin_lock_irqsave(&ioc->sas_device_lock, flags);
9985 
9986         /*
9987          * Since we dropped the lock during the call to port_add(), we need to
9988          * be careful here that somebody else didn't move or delete this item
9989          * while we were busy with other things.
9990          *
9991          * If it was on the list, we need a put() for the reference the list
9992          * had. Either way, we need a get() for the destination list.
9993          */
9994         if (!list_empty(&sas_device->list)) {
9995                 list_del_init(&sas_device->list);
9996                 sas_device_put(sas_device);
9997         }
9998 
9999         sas_device_get(sas_device);
10000         list_add_tail(&sas_device->list, &ioc->sas_device_list);
10001 
10002         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
10003 }
10004 
10005 /**
10006  * _scsih_probe_sas - reporting sas devices to sas transport
10007  * @ioc: per adapter object
10008  *
10009  * Called during initial loading of the driver.
10010  */
10011 static void
10012 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
10013 {
10014         struct _sas_device *sas_device;
10015 
10016         if (ioc->hide_drives)
10017                 return;
10018 
10019         while ((sas_device = get_next_sas_device(ioc))) {
10020                 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
10021                     sas_device->sas_address_parent)) {
10022                         _scsih_sas_device_remove(ioc, sas_device);
10023                         sas_device_put(sas_device);
10024                         continue;
10025                 } else if (!sas_device->starget) {
10026                         /*
10027                          * When asyn scanning is enabled, its not possible to
10028                          * remove devices while scanning is turned on due to an
10029                          * oops in scsi_sysfs_add_sdev()->add_device()->
10030                          * sysfs_addrm_start()
10031                          */
10032                         if (!ioc->is_driver_loading) {
10033                                 mpt3sas_transport_port_remove(ioc,
10034                                     sas_device->sas_address,
10035                                     sas_device->sas_address_parent);
10036                                 _scsih_sas_device_remove(ioc, sas_device);
10037                                 sas_device_put(sas_device);
10038                                 continue;
10039                         }
10040                 }
10041                 sas_device_make_active(ioc, sas_device);
10042                 sas_device_put(sas_device);
10043         }
10044 }
10045 
10046 /**
10047  * get_next_pcie_device - Get the next pcie device
10048  * @ioc: per adapter object
10049  *
10050  * Get the next pcie device from pcie_device_init_list list.
10051  *
10052  * Return: pcie device structure if pcie_device_init_list list is not empty
10053  * otherwise returns NULL
10054  */
10055 static struct _pcie_device *get_next_pcie_device(struct MPT3SAS_ADAPTER *ioc)
10056 {
10057         struct _pcie_device *pcie_device = NULL;
10058         unsigned long flags;
10059 
10060         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
10061         if (!list_empty(&ioc->pcie_device_init_list)) {
10062                 pcie_device = list_first_entry(&ioc->pcie_device_init_list,
10063                                 struct _pcie_device, list);
10064                 pcie_device_get(pcie_device);
10065         }
10066         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
10067 
10068         return pcie_device;
10069 }
10070 
10071 /**
10072  * pcie_device_make_active - Add pcie device to pcie_device_list list
10073  * @ioc: per adapter object
10074  * @pcie_device: pcie device object
10075  *
10076  * Add the pcie device which has registered with SCSI Transport Later to
10077  * pcie_device_list list
10078  */
10079 static void pcie_device_make_active(struct MPT3SAS_ADAPTER *ioc,
10080                 struct _pcie_device *pcie_device)
10081 {
10082         unsigned long flags;
10083 
10084         spin_lock_irqsave(&ioc->pcie_device_lock, flags);
10085 
10086         if (!list_empty(&pcie_device->list)) {
10087                 list_del_init(&pcie_device->list);
10088                 pcie_device_put(pcie_device);
10089         }
10090         pcie_device_get(pcie_device);
10091         list_add_tail(&pcie_device->list, &ioc->pcie_device_list);
10092 
10093         spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
10094 }
10095 
10096 /**
10097  * _scsih_probe_pcie - reporting PCIe devices to scsi-ml
10098  * @ioc: per adapter object
10099  *
10100  * Called during initial loading of the driver.
10101  */
10102 static void
10103 _scsih_probe_pcie(struct MPT3SAS_ADAPTER *ioc)
10104 {
10105         struct _pcie_device *pcie_device;
10106         int rc;
10107 
10108         /* PCIe Device List */
10109         while ((pcie_device = get_next_pcie_device(ioc))) {
10110                 if (pcie_device->starget) {
10111                         pcie_device_put(pcie_device);
10112                         continue;
10113                 }
10114                 if (pcie_device->access_status ==
10115                     MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED) {
10116                         pcie_device_make_active(ioc, pcie_device);
10117                         pcie_device_put(pcie_device);
10118                         continue;
10119                 }
10120                 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL,
10121                         pcie_device->id, 0);
10122                 if (rc) {
10123                         _scsih_pcie_device_remove(ioc, pcie_device);
10124                         pcie_device_put(pcie_device);
10125                         continue;
10126                 } else if (!pcie_device->starget) {
10127                         /*
10128                          * When async scanning is enabled, its not possible to
10129                          * remove devices while scanning is turned on due to an
10130                          * oops in scsi_sysfs_add_sdev()->add_device()->
10131                          * sysfs_addrm_start()
10132                          */
10133                         if (!ioc->is_driver_loading) {
10134                         /* TODO-- Need to find out whether this condition will
10135                          * occur or not
10136                          */
10137                                 _scsih_pcie_device_remove(ioc, pcie_device);
10138                                 pcie_device_put(pcie_device);
10139                                 continue;
10140                         }
10141                 }
10142                 pcie_device_make_active(ioc, pcie_device);
10143                 pcie_device_put(pcie_device);
10144         }
10145 }
10146 
10147 /**
10148  * _scsih_probe_devices - probing for devices
10149  * @ioc: per adapter object
10150  *
10151  * Called during initial loading of the driver.
10152  */
10153 static void
10154 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
10155 {
10156         u16 volume_mapping_flags;
10157 
10158         if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
10159                 return;  /* return when IOC doesn't support initiator mode */
10160 
10161         _scsih_probe_boot_devices(ioc);
10162 
10163         if (ioc->ir_firmware) {
10164                 volume_mapping_flags =
10165                     le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
10166                     MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
10167                 if (volume_mapping_flags ==
10168                     MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
10169                         _scsih_probe_raid(ioc);
10170                         _scsih_probe_sas(ioc);
10171                 } else {
10172                         _scsih_probe_sas(ioc);
10173                         _scsih_probe_raid(ioc);
10174                 }
10175         } else {
10176                 _scsih_probe_sas(ioc);
10177                 _scsih_probe_pcie(ioc);
10178         }
10179 }
10180 
10181 /**
10182  * scsih_scan_start - scsi lld callback for .scan_start
10183  * @shost: SCSI host pointer
10184  *
10185  * The shost has the ability to discover targets on its own instead
10186  * of scanning the entire bus.  In our implemention, we will kick off
10187  * firmware discovery.
10188  */
10189 static void
10190 scsih_scan_start(struct Scsi_Host *shost)
10191 {
10192         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10193         int rc;
10194         if (diag_buffer_enable != -1 && diag_buffer_enable != 0)
10195                 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
10196 
10197         if (disable_discovery > 0)
10198                 return;
10199 
10200         ioc->start_scan = 1;
10201         rc = mpt3sas_port_enable(ioc);
10202 
10203         if (rc != 0)
10204                 ioc_info(ioc, "port enable: FAILED\n");
10205 }
10206 
10207 /**
10208  * scsih_scan_finished - scsi lld callback for .scan_finished
10209  * @shost: SCSI host pointer
10210  * @time: elapsed time of the scan in jiffies
10211  *
10212  * This function will be called periodicallyn until it returns 1 with the
10213  * scsi_host and the elapsed time of the scan in jiffies. In our implemention,
10214  * we wait for firmware discovery to complete, then return 1.
10215  */
10216 static int
10217 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time)
10218 {
10219         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10220 
10221         if (disable_discovery > 0) {
10222                 ioc->is_driver_loading = 0;
10223                 ioc->wait_for_discovery_to_complete = 0;
10224                 return 1;
10225         }
10226 
10227         if (time >= (300 * HZ)) {
10228                 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
10229                 ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n");
10230                 ioc->is_driver_loading = 0;
10231                 return 1;
10232         }
10233 
10234         if (ioc->start_scan)
10235                 return 0;
10236 
10237         if (ioc->start_scan_failed) {
10238                 ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n",
10239                          ioc->start_scan_failed);
10240                 ioc->is_driver_loading = 0;
10241                 ioc->wait_for_discovery_to_complete = 0;
10242                 ioc->remove_host = 1;
10243                 return 1;
10244         }
10245 
10246         ioc_info(ioc, "port enable: SUCCESS\n");
10247         ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
10248 
10249         if (ioc->wait_for_discovery_to_complete) {
10250                 ioc->wait_for_discovery_to_complete = 0;
10251                 _scsih_probe_devices(ioc);
10252         }
10253         mpt3sas_base_start_watchdog(ioc);
10254         ioc->is_driver_loading = 0;
10255         return 1;
10256 }
10257 
10258 /* shost template for SAS 2.0 HBA devices */
10259 static struct scsi_host_template mpt2sas_driver_template = {
10260         .module                         = THIS_MODULE,
10261         .name                           = "Fusion MPT SAS Host",
10262         .proc_name                      = MPT2SAS_DRIVER_NAME,
10263         .queuecommand                   = scsih_qcmd,
10264         .target_alloc                   = scsih_target_alloc,
10265         .slave_alloc                    = scsih_slave_alloc,
10266         .slave_configure                = scsih_slave_configure,
10267         .target_destroy                 = scsih_target_destroy,
10268         .slave_destroy                  = scsih_slave_destroy,
10269         .scan_finished                  = scsih_scan_finished,
10270         .scan_start                     = scsih_scan_start,
10271         .change_queue_depth             = scsih_change_queue_depth,
10272         .eh_abort_handler               = scsih_abort,
10273         .eh_device_reset_handler        = scsih_dev_reset,
10274         .eh_target_reset_handler        = scsih_target_reset,
10275         .eh_host_reset_handler          = scsih_host_reset,
10276         .bios_param                     = scsih_bios_param,
10277         .can_queue                      = 1,
10278         .this_id                        = -1,
10279         .sg_tablesize                   = MPT2SAS_SG_DEPTH,
10280         .max_sectors                    = 32767,
10281         .cmd_per_lun                    = 7,
10282         .shost_attrs                    = mpt3sas_host_attrs,
10283         .sdev_attrs                     = mpt3sas_dev_attrs,
10284         .track_queue_depth              = 1,
10285         .cmd_size                       = sizeof(struct scsiio_tracker),
10286 };
10287 
10288 /* raid transport support for SAS 2.0 HBA devices */
10289 static struct raid_function_template mpt2sas_raid_functions = {
10290         .cookie         = &mpt2sas_driver_template,
10291         .is_raid        = scsih_is_raid,
10292         .get_resync     = scsih_get_resync,
10293         .get_state      = scsih_get_state,
10294 };
10295 
10296 /* shost template for SAS 3.0 HBA devices */
10297 static struct scsi_host_template mpt3sas_driver_template = {
10298         .module                         = THIS_MODULE,
10299         .name                           = "Fusion MPT SAS Host",
10300         .proc_name                      = MPT3SAS_DRIVER_NAME,
10301         .queuecommand                   = scsih_qcmd,
10302         .target_alloc                   = scsih_target_alloc,
10303         .slave_alloc                    = scsih_slave_alloc,
10304         .slave_configure                = scsih_slave_configure,
10305         .target_destroy                 = scsih_target_destroy,
10306         .slave_destroy                  = scsih_slave_destroy,
10307         .scan_finished                  = scsih_scan_finished,
10308         .scan_start                     = scsih_scan_start,
10309         .change_queue_depth             = scsih_change_queue_depth,
10310         .eh_abort_handler               = scsih_abort,
10311         .eh_device_reset_handler        = scsih_dev_reset,
10312         .eh_target_reset_handler        = scsih_target_reset,
10313         .eh_host_reset_handler          = scsih_host_reset,
10314         .bios_param                     = scsih_bios_param,
10315         .can_queue                      = 1,
10316         .this_id                        = -1,
10317         .sg_tablesize                   = MPT3SAS_SG_DEPTH,
10318         .max_sectors                    = 32767,
10319         .max_segment_size               = 0xffffffff,
10320         .cmd_per_lun                    = 7,
10321         .shost_attrs                    = mpt3sas_host_attrs,
10322         .sdev_attrs                     = mpt3sas_dev_attrs,
10323         .track_queue_depth              = 1,
10324         .cmd_size                       = sizeof(struct scsiio_tracker),
10325 };
10326 
10327 /* raid transport support for SAS 3.0 HBA devices */
10328 static struct raid_function_template mpt3sas_raid_functions = {
10329         .cookie         = &mpt3sas_driver_template,
10330         .is_raid        = scsih_is_raid,
10331         .get_resync     = scsih_get_resync,
10332         .get_state      = scsih_get_state,
10333 };
10334 
10335 /**
10336  * _scsih_determine_hba_mpi_version - determine in which MPI version class
10337  *                                      this device belongs to.
10338  * @pdev: PCI device struct
10339  *
10340  * return MPI2_VERSION for SAS 2.0 HBA devices,
10341  *      MPI25_VERSION for SAS 3.0 HBA devices, and
10342  *      MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices
10343  */
10344 static u16
10345 _scsih_determine_hba_mpi_version(struct pci_dev *pdev)
10346 {
10347 
10348         switch (pdev->device) {
10349         case MPI2_MFGPAGE_DEVID_SSS6200:
10350         case MPI2_MFGPAGE_DEVID_SAS2004:
10351         case MPI2_MFGPAGE_DEVID_SAS2008:
10352         case MPI2_MFGPAGE_DEVID_SAS2108_1:
10353         case MPI2_MFGPAGE_DEVID_SAS2108_2:
10354         case MPI2_MFGPAGE_DEVID_SAS2108_3:
10355         case MPI2_MFGPAGE_DEVID_SAS2116_1:
10356         case MPI2_MFGPAGE_DEVID_SAS2116_2:
10357         case MPI2_MFGPAGE_DEVID_SAS2208_1:
10358         case MPI2_MFGPAGE_DEVID_SAS2208_2:
10359         case MPI2_MFGPAGE_DEVID_SAS2208_3:
10360         case MPI2_MFGPAGE_DEVID_SAS2208_4:
10361         case MPI2_MFGPAGE_DEVID_SAS2208_5:
10362         case MPI2_MFGPAGE_DEVID_SAS2208_6:
10363         case MPI2_MFGPAGE_DEVID_SAS2308_1:
10364         case MPI2_MFGPAGE_DEVID_SAS2308_2:
10365         case MPI2_MFGPAGE_DEVID_SAS2308_3:
10366         case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP:
10367         case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1:
10368                 return MPI2_VERSION;
10369         case MPI25_MFGPAGE_DEVID_SAS3004:
10370         case MPI25_MFGPAGE_DEVID_SAS3008:
10371         case MPI25_MFGPAGE_DEVID_SAS3108_1:
10372         case MPI25_MFGPAGE_DEVID_SAS3108_2:
10373         case MPI25_MFGPAGE_DEVID_SAS3108_5:
10374         case MPI25_MFGPAGE_DEVID_SAS3108_6:
10375                 return MPI25_VERSION;
10376         case MPI26_MFGPAGE_DEVID_SAS3216:
10377         case MPI26_MFGPAGE_DEVID_SAS3224:
10378         case MPI26_MFGPAGE_DEVID_SAS3316_1:
10379         case MPI26_MFGPAGE_DEVID_SAS3316_2:
10380         case MPI26_MFGPAGE_DEVID_SAS3316_3:
10381         case MPI26_MFGPAGE_DEVID_SAS3316_4:
10382         case MPI26_MFGPAGE_DEVID_SAS3324_1:
10383         case MPI26_MFGPAGE_DEVID_SAS3324_2:
10384         case MPI26_MFGPAGE_DEVID_SAS3324_3:
10385         case MPI26_MFGPAGE_DEVID_SAS3324_4:
10386         case MPI26_MFGPAGE_DEVID_SAS3508:
10387         case MPI26_MFGPAGE_DEVID_SAS3508_1:
10388         case MPI26_MFGPAGE_DEVID_SAS3408:
10389         case MPI26_MFGPAGE_DEVID_SAS3516:
10390         case MPI26_MFGPAGE_DEVID_SAS3516_1:
10391         case MPI26_MFGPAGE_DEVID_SAS3416:
10392         case MPI26_MFGPAGE_DEVID_SAS3616:
10393         case MPI26_ATLAS_PCIe_SWITCH_DEVID:
10394         case MPI26_MFGPAGE_DEVID_CFG_SEC_3916:
10395         case MPI26_MFGPAGE_DEVID_HARD_SEC_3916:
10396         case MPI26_MFGPAGE_DEVID_CFG_SEC_3816:
10397         case MPI26_MFGPAGE_DEVID_HARD_SEC_3816:
10398                 return MPI26_VERSION;
10399         }
10400         return 0;
10401 }
10402 
10403 /**
10404  * _scsih_probe - attach and add scsi host
10405  * @pdev: PCI device struct
10406  * @id: pci device id
10407  *
10408  * Return: 0 success, anything else error.
10409  */
10410 static int
10411 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
10412 {
10413         struct MPT3SAS_ADAPTER *ioc;
10414         struct Scsi_Host *shost = NULL;
10415         int rv;
10416         u16 hba_mpi_version;
10417 
10418         /* Determine in which MPI version class this pci device belongs */
10419         hba_mpi_version = _scsih_determine_hba_mpi_version(pdev);
10420         if (hba_mpi_version == 0)
10421                 return -ENODEV;
10422 
10423         /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one,
10424          * for other generation HBA's return with -ENODEV
10425          */
10426         if ((hbas_to_enumerate == 1) && (hba_mpi_version !=  MPI2_VERSION))
10427                 return -ENODEV;
10428 
10429         /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two,
10430          * for other generation HBA's return with -ENODEV
10431          */
10432         if ((hbas_to_enumerate == 2) && (!(hba_mpi_version ==  MPI25_VERSION
10433                 || hba_mpi_version ==  MPI26_VERSION)))
10434                 return -ENODEV;
10435 
10436         switch (hba_mpi_version) {
10437         case MPI2_VERSION:
10438                 pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S |
10439                         PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM);
10440                 /* Use mpt2sas driver host template for SAS 2.0 HBA's */
10441                 shost = scsi_host_alloc(&mpt2sas_driver_template,
10442                   sizeof(struct MPT3SAS_ADAPTER));
10443                 if (!shost)
10444                         return -ENODEV;
10445                 ioc = shost_priv(shost);
10446                 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
10447                 ioc->hba_mpi_version_belonged = hba_mpi_version;
10448                 ioc->id = mpt2_ids++;
10449                 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME);
10450                 switch (pdev->device) {
10451                 case MPI2_MFGPAGE_DEVID_SSS6200:
10452                         ioc->is_warpdrive = 1;
10453                         ioc->hide_ir_msg = 1;
10454                         break;
10455                 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP:
10456                 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1:
10457                         ioc->is_mcpu_endpoint = 1;
10458                         break;
10459                 default:
10460                         ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
10461                         break;
10462                 }
10463                 break;
10464         case MPI25_VERSION:
10465         case MPI26_VERSION:
10466                 /* Use mpt3sas driver host template for SAS 3.0 HBA's */
10467                 shost = scsi_host_alloc(&mpt3sas_driver_template,
10468                   sizeof(struct MPT3SAS_ADAPTER));
10469                 if (!shost)
10470                         return -ENODEV;
10471                 ioc = shost_priv(shost);
10472                 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
10473                 ioc->hba_mpi_version_belonged = hba_mpi_version;
10474                 ioc->id = mpt3_ids++;
10475                 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME);
10476                 switch (pdev->device) {
10477                 case MPI26_MFGPAGE_DEVID_SAS3508:
10478                 case MPI26_MFGPAGE_DEVID_SAS3508_1:
10479                 case MPI26_MFGPAGE_DEVID_SAS3408:
10480                 case MPI26_MFGPAGE_DEVID_SAS3516:
10481                 case MPI26_MFGPAGE_DEVID_SAS3516_1:
10482                 case MPI26_MFGPAGE_DEVID_SAS3416:
10483                 case MPI26_MFGPAGE_DEVID_SAS3616:
10484                 case MPI26_ATLAS_PCIe_SWITCH_DEVID:
10485                         ioc->is_gen35_ioc = 1;
10486                         break;
10487                 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816:
10488                 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916:
10489                         dev_info(&pdev->dev,
10490                             "HBA is in Configurable Secure mode\n");
10491                         /* fall through */
10492                 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816:
10493                 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916:
10494                         ioc->is_aero_ioc = ioc->is_gen35_ioc = 1;
10495                         break;
10496                 default:
10497                         ioc->is_gen35_ioc = ioc->is_aero_ioc = 0;
10498                 }
10499                 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION &&
10500                         pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) ||
10501                         (ioc->hba_mpi_version_belonged == MPI26_VERSION)) {
10502                         ioc->combined_reply_queue = 1;
10503                         if (ioc->is_gen35_ioc)
10504                                 ioc->combined_reply_index_count =
10505                                  MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G35;
10506                         else
10507                                 ioc->combined_reply_index_count =
10508                                  MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G3;
10509                 }
10510                 break;
10511         default:
10512                 return -ENODEV;
10513         }
10514 
10515         INIT_LIST_HEAD(&ioc->list);
10516         spin_lock(&gioc_lock);
10517         list_add_tail(&ioc->list, &mpt3sas_ioc_list);
10518         spin_unlock(&gioc_lock);
10519         ioc->shost = shost;
10520         ioc->pdev = pdev;
10521         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
10522         ioc->tm_cb_idx = tm_cb_idx;
10523         ioc->ctl_cb_idx = ctl_cb_idx;
10524         ioc->base_cb_idx = base_cb_idx;
10525         ioc->port_enable_cb_idx = port_enable_cb_idx;
10526         ioc->transport_cb_idx = transport_cb_idx;
10527         ioc->scsih_cb_idx = scsih_cb_idx;
10528         ioc->config_cb_idx = config_cb_idx;
10529         ioc->tm_tr_cb_idx = tm_tr_cb_idx;
10530         ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
10531         ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
10532         ioc->logging_level = logging_level;
10533         ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
10534         /*
10535          * Enable MEMORY MOVE support flag.
10536          */
10537         ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_MEMMOVE;
10538 
10539         ioc->enable_sdev_max_qd = enable_sdev_max_qd;
10540 
10541         /* misc semaphores and spin locks */
10542         mutex_init(&ioc->reset_in_progress_mutex);
10543         /* initializing pci_access_mutex lock */
10544         mutex_init(&ioc->pci_access_mutex);
10545         spin_lock_init(&ioc->ioc_reset_in_progress_lock);
10546         spin_lock_init(&ioc->scsi_lookup_lock);
10547         spin_lock_init(&ioc->sas_device_lock);
10548         spin_lock_init(&ioc->sas_node_lock);
10549         spin_lock_init(&ioc->fw_event_lock);
10550         spin_lock_init(&ioc->raid_device_lock);
10551         spin_lock_init(&ioc->pcie_device_lock);
10552         spin_lock_init(&ioc->diag_trigger_lock);
10553 
10554         INIT_LIST_HEAD(&ioc->sas_device_list);
10555         INIT_LIST_HEAD(&ioc->sas_device_init_list);
10556         INIT_LIST_HEAD(&ioc->sas_expander_list);
10557         INIT_LIST_HEAD(&ioc->enclosure_list);
10558         INIT_LIST_HEAD(&ioc->pcie_device_list);
10559         INIT_LIST_HEAD(&ioc->pcie_device_init_list);
10560         INIT_LIST_HEAD(&ioc->fw_event_list);
10561         INIT_LIST_HEAD(&ioc->raid_device_list);
10562         INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
10563         INIT_LIST_HEAD(&ioc->delayed_tr_list);
10564         INIT_LIST_HEAD(&ioc->delayed_sc_list);
10565         INIT_LIST_HEAD(&ioc->delayed_event_ack_list);
10566         INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
10567         INIT_LIST_HEAD(&ioc->reply_queue_list);
10568 
10569         sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id);
10570 
10571         /* init shost parameters */
10572         shost->max_cmd_len = 32;
10573         shost->max_lun = max_lun;
10574         shost->transportt = mpt3sas_transport_template;
10575         shost->unique_id = ioc->id;
10576 
10577         if (ioc->is_mcpu_endpoint) {
10578                 /* mCPU MPI support 64K max IO */
10579                 shost->max_sectors = 128;
10580                 ioc_info(ioc, "The max_sectors value is set to %d\n",
10581                          shost->max_sectors);
10582         } else {
10583                 if (max_sectors != 0xFFFF) {
10584                         if (max_sectors < 64) {
10585                                 shost->max_sectors = 64;
10586                                 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n",
10587                                          max_sectors);
10588                         } else if (max_sectors > 32767) {
10589                                 shost->max_sectors = 32767;
10590                                 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n",
10591                                          max_sectors);
10592                         } else {
10593                                 shost->max_sectors = max_sectors & 0xFFFE;
10594                                 ioc_info(ioc, "The max_sectors value is set to %d\n",
10595                                          shost->max_sectors);
10596                         }
10597                 }
10598         }
10599         /* register EEDP capabilities with SCSI layer */
10600         if (prot_mask > 0)
10601                 scsi_host_set_prot(shost, prot_mask);
10602         else
10603                 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
10604                                    | SHOST_DIF_TYPE2_PROTECTION
10605                                    | SHOST_DIF_TYPE3_PROTECTION);
10606 
10607         scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
10608 
10609         /* event thread */
10610         snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
10611             "fw_event_%s%d", ioc->driver_name, ioc->id);
10612         ioc->firmware_event_thread = alloc_ordered_workqueue(
10613             ioc->firmware_event_name, 0);
10614         if (!ioc->firmware_event_thread) {
10615                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10616                         __FILE__, __LINE__, __func__);
10617                 rv = -ENODEV;
10618                 goto out_thread_fail;
10619         }
10620 
10621         ioc->is_driver_loading = 1;
10622         if ((mpt3sas_base_attach(ioc))) {
10623                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10624                         __FILE__, __LINE__, __func__);
10625                 rv = -ENODEV;
10626                 goto out_attach_fail;
10627         }
10628 
10629         if (ioc->is_warpdrive) {
10630                 if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS)
10631                         ioc->hide_drives = 0;
10632                 else if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_HIDE_ALL_DISKS)
10633                         ioc->hide_drives = 1;
10634                 else {
10635                         if (mpt3sas_get_num_volumes(ioc))
10636                                 ioc->hide_drives = 1;
10637                         else
10638                                 ioc->hide_drives = 0;
10639                 }
10640         } else
10641                 ioc->hide_drives = 0;
10642 
10643         rv = scsi_add_host(shost, &pdev->dev);
10644         if (rv) {
10645                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
10646                         __FILE__, __LINE__, __func__);
10647                 goto out_add_shost_fail;
10648         }
10649 
10650         scsi_scan_host(shost);
10651         return 0;
10652 out_add_shost_fail:
10653         mpt3sas_base_detach(ioc);
10654  out_attach_fail:
10655         destroy_workqueue(ioc->firmware_event_thread);
10656  out_thread_fail:
10657         spin_lock(&gioc_lock);
10658         list_del(&ioc->list);
10659         spin_unlock(&gioc_lock);
10660         scsi_host_put(shost);
10661         return rv;
10662 }
10663 
10664 #ifdef CONFIG_PM
10665 /**
10666  * scsih_suspend - power management suspend main entry point
10667  * @pdev: PCI device struct
10668  * @state: PM state change to (usually PCI_D3)
10669  *
10670  * Return: 0 success, anything else error.
10671  */
10672 static int
10673 scsih_suspend(struct pci_dev *pdev, pm_message_t state)
10674 {
10675         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10676         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10677         pci_power_t device_state;
10678 
10679         mpt3sas_base_stop_watchdog(ioc);
10680         flush_scheduled_work();
10681         scsi_block_requests(shost);
10682         device_state = pci_choose_state(pdev, state);
10683         ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
10684                  pdev, pci_name(pdev), device_state);
10685 
10686         pci_save_state(pdev);
10687         mpt3sas_base_free_resources(ioc);
10688         pci_set_power_state(pdev, device_state);
10689         return 0;
10690 }
10691 
10692 /**
10693  * scsih_resume - power management resume main entry point
10694  * @pdev: PCI device struct
10695  *
10696  * Return: 0 success, anything else error.
10697  */
10698 static int
10699 scsih_resume(struct pci_dev *pdev)
10700 {
10701         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10702         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10703         pci_power_t device_state = pdev->current_state;
10704         int r;
10705 
10706         ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
10707                  pdev, pci_name(pdev), device_state);
10708 
10709         pci_set_power_state(pdev, PCI_D0);
10710         pci_enable_wake(pdev, PCI_D0, 0);
10711         pci_restore_state(pdev);
10712         ioc->pdev = pdev;
10713         r = mpt3sas_base_map_resources(ioc);
10714         if (r)
10715                 return r;
10716 
10717         mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET);
10718         scsi_unblock_requests(shost);
10719         mpt3sas_base_start_watchdog(ioc);
10720         return 0;
10721 }
10722 #endif /* CONFIG_PM */
10723 
10724 /**
10725  * scsih_pci_error_detected - Called when a PCI error is detected.
10726  * @pdev: PCI device struct
10727  * @state: PCI channel state
10728  *
10729  * Description: Called when a PCI error is detected.
10730  *
10731  * Return: PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT.
10732  */
10733 static pci_ers_result_t
10734 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
10735 {
10736         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10737         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10738 
10739         ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state);
10740 
10741         switch (state) {
10742         case pci_channel_io_normal:
10743                 return PCI_ERS_RESULT_CAN_RECOVER;
10744         case pci_channel_io_frozen:
10745                 /* Fatal error, prepare for slot reset */
10746                 ioc->pci_error_recovery = 1;
10747                 scsi_block_requests(ioc->shost);
10748                 mpt3sas_base_stop_watchdog(ioc);
10749                 mpt3sas_base_free_resources(ioc);
10750                 return PCI_ERS_RESULT_NEED_RESET;
10751         case pci_channel_io_perm_failure:
10752                 /* Permanent error, prepare for device removal */
10753                 ioc->pci_error_recovery = 1;
10754                 mpt3sas_base_stop_watchdog(ioc);
10755                 _scsih_flush_running_cmds(ioc);
10756                 return PCI_ERS_RESULT_DISCONNECT;
10757         }
10758         return PCI_ERS_RESULT_NEED_RESET;
10759 }
10760 
10761 /**
10762  * scsih_pci_slot_reset - Called when PCI slot has been reset.
10763  * @pdev: PCI device struct
10764  *
10765  * Description: This routine is called by the pci error recovery
10766  * code after the PCI slot has been reset, just before we
10767  * should resume normal operations.
10768  */
10769 static pci_ers_result_t
10770 scsih_pci_slot_reset(struct pci_dev *pdev)
10771 {
10772         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10773         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10774         int rc;
10775 
10776         ioc_info(ioc, "PCI error: slot reset callback!!\n");
10777 
10778         ioc->pci_error_recovery = 0;
10779         ioc->pdev = pdev;
10780         pci_restore_state(pdev);
10781         rc = mpt3sas_base_map_resources(ioc);
10782         if (rc)
10783                 return PCI_ERS_RESULT_DISCONNECT;
10784 
10785         rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
10786 
10787         ioc_warn(ioc, "hard reset: %s\n",
10788                  (rc == 0) ? "success" : "failed");
10789 
10790         if (!rc)
10791                 return PCI_ERS_RESULT_RECOVERED;
10792         else
10793                 return PCI_ERS_RESULT_DISCONNECT;
10794 }
10795 
10796 /**
10797  * scsih_pci_resume() - resume normal ops after PCI reset
10798  * @pdev: pointer to PCI device
10799  *
10800  * Called when the error recovery driver tells us that its
10801  * OK to resume normal operation. Use completion to allow
10802  * halted scsi ops to resume.
10803  */
10804 static void
10805 scsih_pci_resume(struct pci_dev *pdev)
10806 {
10807         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10808         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10809 
10810         ioc_info(ioc, "PCI error: resume callback!!\n");
10811 
10812         mpt3sas_base_start_watchdog(ioc);
10813         scsi_unblock_requests(ioc->shost);
10814 }
10815 
10816 /**
10817  * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers
10818  * @pdev: pointer to PCI device
10819  */
10820 static pci_ers_result_t
10821 scsih_pci_mmio_enabled(struct pci_dev *pdev)
10822 {
10823         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10824         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
10825 
10826         ioc_info(ioc, "PCI error: mmio enabled callback!!\n");
10827 
10828         /* TODO - dump whatever for debugging purposes */
10829 
10830         /* This called only if scsih_pci_error_detected returns
10831          * PCI_ERS_RESULT_CAN_RECOVER. Read/write to the device still
10832          * works, no need to reset slot.
10833          */
10834         return PCI_ERS_RESULT_RECOVERED;
10835 }
10836 
10837 /**
10838  * scsih__ncq_prio_supp - Check for NCQ command priority support
10839  * @sdev: scsi device struct
10840  *
10841  * This is called when a user indicates they would like to enable
10842  * ncq command priorities. This works only on SATA devices.
10843  */
10844 bool scsih_ncq_prio_supp(struct scsi_device *sdev)
10845 {
10846         unsigned char *buf;
10847         bool ncq_prio_supp = false;
10848 
10849         if (!scsi_device_supports_vpd(sdev))
10850                 return ncq_prio_supp;
10851 
10852         buf = kmalloc(SCSI_VPD_PG_LEN, GFP_KERNEL);
10853         if (!buf)
10854                 return ncq_prio_supp;
10855 
10856         if (!scsi_get_vpd_page(sdev, 0x89, buf, SCSI_VPD_PG_LEN))
10857                 ncq_prio_supp = (buf[213] >> 4) & 1;
10858 
10859         kfree(buf);
10860         return ncq_prio_supp;
10861 }
10862 /*
10863  * The pci device ids are defined in mpi/mpi2_cnfg.h.
10864  */
10865 static const struct pci_device_id mpt3sas_pci_table[] = {
10866         /* Spitfire ~ 2004 */
10867         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004,
10868                 PCI_ANY_ID, PCI_ANY_ID },
10869         /* Falcon ~ 2008 */
10870         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008,
10871                 PCI_ANY_ID, PCI_ANY_ID },
10872         /* Liberator ~ 2108 */
10873         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1,
10874                 PCI_ANY_ID, PCI_ANY_ID },
10875         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2,
10876                 PCI_ANY_ID, PCI_ANY_ID },
10877         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3,
10878                 PCI_ANY_ID, PCI_ANY_ID },
10879         /* Meteor ~ 2116 */
10880         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1,
10881                 PCI_ANY_ID, PCI_ANY_ID },
10882         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2,
10883                 PCI_ANY_ID, PCI_ANY_ID },
10884         /* Thunderbolt ~ 2208 */
10885         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1,
10886                 PCI_ANY_ID, PCI_ANY_ID },
10887         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2,
10888                 PCI_ANY_ID, PCI_ANY_ID },
10889         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3,
10890                 PCI_ANY_ID, PCI_ANY_ID },
10891         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4,
10892                 PCI_ANY_ID, PCI_ANY_ID },
10893         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5,
10894                 PCI_ANY_ID, PCI_ANY_ID },
10895         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6,
10896                 PCI_ANY_ID, PCI_ANY_ID },
10897         /* Mustang ~ 2308 */
10898         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1,
10899                 PCI_ANY_ID, PCI_ANY_ID },
10900         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2,
10901                 PCI_ANY_ID, PCI_ANY_ID },
10902         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
10903                 PCI_ANY_ID, PCI_ANY_ID },
10904         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP,
10905                 PCI_ANY_ID, PCI_ANY_ID },
10906         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1,
10907                 PCI_ANY_ID, PCI_ANY_ID },
10908         /* SSS6200 */
10909         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
10910                 PCI_ANY_ID, PCI_ANY_ID },
10911         /* Fury ~ 3004 and 3008 */
10912         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004,
10913                 PCI_ANY_ID, PCI_ANY_ID },
10914         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008,
10915                 PCI_ANY_ID, PCI_ANY_ID },
10916         /* Invader ~ 3108 */
10917         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1,
10918                 PCI_ANY_ID, PCI_ANY_ID },
10919         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2,
10920                 PCI_ANY_ID, PCI_ANY_ID },
10921         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5,
10922                 PCI_ANY_ID, PCI_ANY_ID },
10923         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6,
10924                 PCI_ANY_ID, PCI_ANY_ID },
10925         /* Cutlass ~ 3216 and 3224 */
10926         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216,
10927                 PCI_ANY_ID, PCI_ANY_ID },
10928         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224,
10929                 PCI_ANY_ID, PCI_ANY_ID },
10930         /* Intruder ~ 3316 and 3324 */
10931         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1,
10932                 PCI_ANY_ID, PCI_ANY_ID },
10933         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2,
10934                 PCI_ANY_ID, PCI_ANY_ID },
10935         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3,
10936                 PCI_ANY_ID, PCI_ANY_ID },
10937         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4,
10938                 PCI_ANY_ID, PCI_ANY_ID },
10939         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1,
10940                 PCI_ANY_ID, PCI_ANY_ID },
10941         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2,
10942                 PCI_ANY_ID, PCI_ANY_ID },
10943         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3,
10944                 PCI_ANY_ID, PCI_ANY_ID },
10945         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4,
10946                 PCI_ANY_ID, PCI_ANY_ID },
10947         /* Ventura, Crusader, Harpoon & Tomcat ~ 3516, 3416, 3508 & 3408*/
10948         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508,
10949                 PCI_ANY_ID, PCI_ANY_ID },
10950         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508_1,
10951                 PCI_ANY_ID, PCI_ANY_ID },
10952         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3408,
10953                 PCI_ANY_ID, PCI_ANY_ID },
10954         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516,
10955                 PCI_ANY_ID, PCI_ANY_ID },
10956         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516_1,
10957                 PCI_ANY_ID, PCI_ANY_ID },
10958         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3416,
10959                 PCI_ANY_ID, PCI_ANY_ID },
10960         /* Mercator ~ 3616*/
10961         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3616,
10962                 PCI_ANY_ID, PCI_ANY_ID },
10963 
10964         /* Aero SI 0x00E1 Configurable Secure
10965          * 0x00E2 Hard Secure
10966          */
10967         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3916,
10968                 PCI_ANY_ID, PCI_ANY_ID },
10969         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3916,
10970                 PCI_ANY_ID, PCI_ANY_ID },
10971 
10972         /* Atlas PCIe Switch Management Port */
10973         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_ATLAS_PCIe_SWITCH_DEVID,
10974                 PCI_ANY_ID, PCI_ANY_ID },
10975 
10976         /* Sea SI 0x00E5 Configurable Secure
10977          * 0x00E6 Hard Secure
10978          */
10979         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3816,
10980                 PCI_ANY_ID, PCI_ANY_ID },
10981         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3816,
10982                 PCI_ANY_ID, PCI_ANY_ID },
10983 
10984         {0}     /* Terminating entry */
10985 };
10986 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table);
10987 
10988 static struct pci_error_handlers _mpt3sas_err_handler = {
10989         .error_detected = scsih_pci_error_detected,
10990         .mmio_enabled   = scsih_pci_mmio_enabled,
10991         .slot_reset     = scsih_pci_slot_reset,
10992         .resume         = scsih_pci_resume,
10993 };
10994 
10995 static struct pci_driver mpt3sas_driver = {
10996         .name           = MPT3SAS_DRIVER_NAME,
10997         .id_table       = mpt3sas_pci_table,
10998         .probe          = _scsih_probe,
10999         .remove         = scsih_remove,
11000         .shutdown       = scsih_shutdown,
11001         .err_handler    = &_mpt3sas_err_handler,
11002 #ifdef CONFIG_PM
11003         .suspend        = scsih_suspend,
11004         .resume         = scsih_resume,
11005 #endif
11006 };
11007 
11008 /**
11009  * scsih_init - main entry point for this driver.
11010  *
11011  * Return: 0 success, anything else error.
11012  */
11013 static int
11014 scsih_init(void)
11015 {
11016         mpt2_ids = 0;
11017         mpt3_ids = 0;
11018 
11019         mpt3sas_base_initialize_callback_handler();
11020 
11021          /* queuecommand callback hander */
11022         scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done);
11023 
11024         /* task management callback handler */
11025         tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done);
11026 
11027         /* base internal commands callback handler */
11028         base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done);
11029         port_enable_cb_idx = mpt3sas_base_register_callback_handler(
11030             mpt3sas_port_enable_done);
11031 
11032         /* transport internal commands callback handler */
11033         transport_cb_idx = mpt3sas_base_register_callback_handler(
11034             mpt3sas_transport_done);
11035 
11036         /* scsih internal commands callback handler */
11037         scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done);
11038 
11039         /* configuration page API internal commands callback handler */
11040         config_cb_idx = mpt3sas_base_register_callback_handler(
11041             mpt3sas_config_done);
11042 
11043         /* ctl module callback handler */
11044         ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done);
11045 
11046         tm_tr_cb_idx = mpt3sas_base_register_callback_handler(
11047             _scsih_tm_tr_complete);
11048 
11049         tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler(
11050             _scsih_tm_volume_tr_complete);
11051 
11052         tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler(
11053             _scsih_sas_control_complete);
11054 
11055         return 0;
11056 }
11057 
11058 /**
11059  * scsih_exit - exit point for this driver (when it is a module).
11060  *
11061  * Return: 0 success, anything else error.
11062  */
11063 static void
11064 scsih_exit(void)
11065 {
11066 
11067         mpt3sas_base_release_callback_handler(scsi_io_cb_idx);
11068         mpt3sas_base_release_callback_handler(tm_cb_idx);
11069         mpt3sas_base_release_callback_handler(base_cb_idx);
11070         mpt3sas_base_release_callback_handler(port_enable_cb_idx);
11071         mpt3sas_base_release_callback_handler(transport_cb_idx);
11072         mpt3sas_base_release_callback_handler(scsih_cb_idx);
11073         mpt3sas_base_release_callback_handler(config_cb_idx);
11074         mpt3sas_base_release_callback_handler(ctl_cb_idx);
11075 
11076         mpt3sas_base_release_callback_handler(tm_tr_cb_idx);
11077         mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx);
11078         mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx);
11079 
11080 /* raid transport support */
11081         if (hbas_to_enumerate != 1)
11082                 raid_class_release(mpt3sas_raid_template);
11083         if (hbas_to_enumerate != 2)
11084                 raid_class_release(mpt2sas_raid_template);
11085         sas_release_transport(mpt3sas_transport_template);
11086 }
11087 
11088 /**
11089  * _mpt3sas_init - main entry point for this driver.
11090  *
11091  * Return: 0 success, anything else error.
11092  */
11093 static int __init
11094 _mpt3sas_init(void)
11095 {
11096         int error;
11097 
11098         pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME,
11099                                         MPT3SAS_DRIVER_VERSION);
11100 
11101         mpt3sas_transport_template =
11102             sas_attach_transport(&mpt3sas_transport_functions);
11103         if (!mpt3sas_transport_template)
11104                 return -ENODEV;
11105 
11106         /* No need attach mpt3sas raid functions template
11107          * if hbas_to_enumarate value is one.
11108          */
11109         if (hbas_to_enumerate != 1) {
11110                 mpt3sas_raid_template =
11111                                 raid_class_attach(&mpt3sas_raid_functions);
11112                 if (!mpt3sas_raid_template) {
11113                         sas_release_transport(mpt3sas_transport_template);
11114                         return -ENODEV;
11115                 }
11116         }
11117 
11118         /* No need to attach mpt2sas raid functions template
11119          * if hbas_to_enumarate value is two
11120          */
11121         if (hbas_to_enumerate != 2) {
11122                 mpt2sas_raid_template =
11123                                 raid_class_attach(&mpt2sas_raid_functions);
11124                 if (!mpt2sas_raid_template) {
11125                         sas_release_transport(mpt3sas_transport_template);
11126                         return -ENODEV;
11127                 }
11128         }
11129 
11130         error = scsih_init();
11131         if (error) {
11132                 scsih_exit();
11133                 return error;
11134         }
11135 
11136         mpt3sas_ctl_init(hbas_to_enumerate);
11137 
11138         error = pci_register_driver(&mpt3sas_driver);
11139         if (error)
11140                 scsih_exit();
11141 
11142         return error;
11143 }
11144 
11145 /**
11146  * _mpt3sas_exit - exit point for this driver (when it is a module).
11147  *
11148  */
11149 static void __exit
11150 _mpt3sas_exit(void)
11151 {
11152         pr_info("mpt3sas version %s unloading\n",
11153                                 MPT3SAS_DRIVER_VERSION);
11154 
11155         mpt3sas_ctl_exit(hbas_to_enumerate);
11156 
11157         pci_unregister_driver(&mpt3sas_driver);
11158 
11159         scsih_exit();
11160 }
11161 
11162 module_init(_mpt3sas_init);
11163 module_exit(_mpt3sas_exit);