drivers/scsi/mpt3sas/mpt3sas_scsih.c

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