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