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