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