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