drivers/scsi/mpt3sas/mpt3sas_scsih.c

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