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