kernel/drivers/scsi/mpt3sas/mpt3sas_scsih.c

   1 /*
   2  * Scsi Host Layer for MPT (Message Passing Technology) based controllers
   3  *
   4  * This code is based on drivers/scsi/mpt3sas/mpt3sas_scsih.c
   5  * Copyright (C) 2012-2014  LSI Corporation
   6  * Copyright (C) 2013-2014 Avago Technologies
   7  *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * NO WARRANTY
  20  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  21  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  22  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  23  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  24  * solely responsible for determining the appropriateness of using and
  25  * distributing the Program and assumes all risks associated with its
  26  * exercise of rights under this Agreement, including but not limited to
  27  * the risks and costs of program errors, damage to or loss of data,
  28  * programs or equipment, and unavailability or interruption of operations.
  29
  30  * DISCLAIMER OF LIABILITY
  31  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  32  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  34  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  35  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  36  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  37  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  38
  39  * You should have received a copy of the GNU General Public License
  40  * along with this program; if not, write to the Free Software
  41  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  42  * USA.
  43  */
  44
  45 #include <linux/module.h>
  46 #include <linux/kernel.h>
  47 #include <linux/init.h>
  48 #include <linux/errno.h>
  49 #include <linux/blkdev.h>
  50 #include <linux/sched.h>
  51 #include <linux/workqueue.h>
  52 #include <linux/delay.h>
  53 #include <linux/pci.h>
  54 #include <linux/interrupt.h>
  55 #include <linux/aer.h>
  56 #include <linux/raid_class.h>
  57 #include <asm/unaligned.h>
  58
  59 #include "mpt3sas_base.h"
  60
  61 #define RAID_CHANNEL 1
  62 /* forward proto's */
  63 static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
  64         struct _sas_node *sas_expander);
  65 static void _firmware_event_work(struct work_struct *work);
  66
  67 static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
  68         struct _sas_device *sas_device);
  69 static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,
  70         u8 retry_count, u8 is_pd);
  71
  72 static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);
  73
  74 /* global parameters */
  75 LIST_HEAD(mpt3sas_ioc_list);
  76 /* global ioc lock for list operations */
  77 DEFINE_SPINLOCK(gioc_lock);
  78
  79 MODULE_AUTHOR(MPT3SAS_AUTHOR);
  80 MODULE_DESCRIPTION(MPT3SAS_DESCRIPTION);
  81 MODULE_LICENSE("GPL");
  82 MODULE_VERSION(MPT3SAS_DRIVER_VERSION);
  83 MODULE_ALIAS("mpt2sas");
  84
  85 /* local parameters */
  86 static u8 scsi_io_cb_idx = -1;
  87 static u8 tm_cb_idx = -1;
  88 static u8 ctl_cb_idx = -1;
  89 static u8 base_cb_idx = -1;
  90 static u8 port_enable_cb_idx = -1;
  91 static u8 transport_cb_idx = -1;
  92 static u8 scsih_cb_idx = -1;
  93 static u8 config_cb_idx = -1;
  94 static int mpt2_ids;
  95 static int mpt3_ids;
  96
  97 static u8 tm_tr_cb_idx = -1 ;
  98 static u8 tm_tr_volume_cb_idx = -1 ;
  99 static u8 tm_sas_control_cb_idx = -1;
 100
 101 /* command line options */
 102 static u32 logging_level;
 103 MODULE_PARM_DESC(logging_level,
 104         " bits for enabling additional logging info (default=0)");
 105
 106
 107 static ushort max_sectors = 0xFFFF;
 108 module_param(max_sectors, ushort, 0);
 109 MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767  default=32767");
 110
 111
 112 static int missing_delay[2] = {-1, -1};
 113 module_param_array(missing_delay, int, NULL, 0);
 114 MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
 115
 116 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
 117 #define MPT3SAS_MAX_LUN (16895)
 118 static u64 max_lun = MPT3SAS_MAX_LUN;
 119 module_param(max_lun, ullong, 0);
 120 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
 121
 122 static ushort hbas_to_enumerate;
 123 module_param(hbas_to_enumerate, ushort, 0);
 124 MODULE_PARM_DESC(hbas_to_enumerate,
 125                 " 0 - enumerates both SAS 2.0 & SAS 3.0 generation HBAs\n \
 126                   1 - enumerates only SAS 2.0 generation HBAs\n \
 127                   2 - enumerates only SAS 3.0 generation HBAs (default=0)");
 128
 129 /* diag_buffer_enable is bitwise
 130  * bit 0 set = TRACE
 131  * bit 1 set = SNAPSHOT
 132  * bit 2 set = EXTENDED
 133  *
 134  * Either bit can be set, or both
 135  */
 136 static int diag_buffer_enable = -1;
 137 module_param(diag_buffer_enable, int, 0);
 138 MODULE_PARM_DESC(diag_buffer_enable,
 139         " post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
 140 static int disable_discovery = -1;
 141 module_param(disable_discovery, int, 0);
 142 MODULE_PARM_DESC(disable_discovery, " disable discovery ");
 143
 144
 145 /* permit overriding the host protection capabilities mask (EEDP/T10 PI) */
 146 static int prot_mask = -1;
 147 module_param(prot_mask, int, 0);
 148 MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 ");
 149
 150
 151 /* raid transport support */
 152 struct raid_template *mpt3sas_raid_template;
 153 struct raid_template *mpt2sas_raid_template;
 154
 155
 156 /**
 157  * struct sense_info - common structure for obtaining sense keys
 158  * @skey: sense key
 159  * @asc: additional sense code
 160  * @ascq: additional sense code qualifier
 161  */
 162 struct sense_info {
 163         u8 skey;
 164         u8 asc;
 165         u8 ascq;
 166 };
 167
 168 #define MPT3SAS_PROCESS_TRIGGER_DIAG (0xFFFB)
 169 #define MPT3SAS_TURN_ON_PFA_LED (0xFFFC)
 170 #define MPT3SAS_PORT_ENABLE_COMPLETE (0xFFFD)
 171 #define MPT3SAS_ABRT_TASK_SET (0xFFFE)
 172 #define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF)
 173 /**
 174  * struct fw_event_work - firmware event struct
 175  * @list: link list framework
 176  * @work: work object (ioc->fault_reset_work_q)
 177  * @cancel_pending_work: flag set during reset handling
 178  * @ioc: per adapter object
 179  * @device_handle: device handle
 180  * @VF_ID: virtual function id
 181  * @VP_ID: virtual port id
 182  * @ignore: flag meaning this event has been marked to ignore
 183  * @event: firmware event MPI2_EVENT_XXX defined in mpt2_ioc.h
 184  * @event_data: reply event data payload follows
 185  *
 186  * This object stored on ioc->fw_event_list.
 187  */
 188 struct fw_event_work {
 189         struct list_head        list;
 190         struct work_struct      work;
 191         u8                      cancel_pending_work;
 192         struct delayed_work     delayed_work;
 193
 194         struct MPT3SAS_ADAPTER *ioc;
 195         u16                     device_handle;
 196         u8                      VF_ID;
 197         u8                      VP_ID;
 198         u8                      ignore;
 199         u16                     event;
 200         struct kref             refcount;
 201         char                    event_data[0] __aligned(4);
 202 };
 203
 204 static void fw_event_work_free(struct kref *r)
 205 {
 206         kfree(container_of(r, struct fw_event_work, refcount));
 207 }
 208
 209 static void fw_event_work_get(struct fw_event_work *fw_work)
 210 {
 211         kref_get(&fw_work->refcount);
 212 }
 213
 214 static void fw_event_work_put(struct fw_event_work *fw_work)
 215 {
 216         kref_put(&fw_work->refcount, fw_event_work_free);
 217 }
 218
 219 static struct fw_event_work *alloc_fw_event_work(int len)
 220 {
 221         struct fw_event_work *fw_event;
 222
 223         fw_event = kzalloc(sizeof(*fw_event) + len, GFP_ATOMIC);
 224         if (!fw_event)
 225                 return NULL;
 226
 227         kref_init(&fw_event->refcount);
 228         return fw_event;
 229 }
 230
 231 /**
 232  * struct _scsi_io_transfer - scsi io transfer
 233  * @handle: sas device handle (assigned by firmware)
 234  * @is_raid: flag set for hidden raid components
 235  * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE,
 236  * @data_length: data transfer length
 237  * @data_dma: dma pointer to data
 238  * @sense: sense data
 239  * @lun: lun number
 240  * @cdb_length: cdb length
 241  * @cdb: cdb contents
 242  * @timeout: timeout for this command
 243  * @VF_ID: virtual function id
 244  * @VP_ID: virtual port id
 245  * @valid_reply: flag set for reply message
 246  * @sense_length: sense length
 247  * @ioc_status: ioc status
 248  * @scsi_state: scsi state
 249  * @scsi_status: scsi staus
 250  * @log_info: log information
 251  * @transfer_length: data length transfer when there is a reply message
 252  *
 253  * Used for sending internal scsi commands to devices within this module.
 254  * Refer to _scsi_send_scsi_io().
 255  */
 256 struct _scsi_io_transfer {
 257         u16     handle;
 258         u8      is_raid;
 259         enum dma_data_direction dir;
 260         u32     data_length;
 261         dma_addr_t data_dma;
 262         u8      sense[SCSI_SENSE_BUFFERSIZE];
 263         u32     lun;
 264         u8      cdb_length;
 265         u8      cdb[32];
 266         u8      timeout;
 267         u8      VF_ID;
 268         u8      VP_ID;
 269         u8      valid_reply;
 270   /* the following bits are only valid when 'valid_reply = 1' */
 271         u32     sense_length;
 272         u16     ioc_status;
 273         u8      scsi_state;
 274         u8      scsi_status;
 275         u32     log_info;
 276         u32     transfer_length;
 277 };
 278
 279 /**
 280  * _scsih_set_debug_level - global setting of ioc->logging_level.
 281  *
 282  * Note: The logging levels are defined in mpt3sas_debug.h.
 283  */
 284 static int
 285 _scsih_set_debug_level(const char *val, struct kernel_param *kp)
 286 {
 287         int ret = param_set_int(val, kp);
 288         struct MPT3SAS_ADAPTER *ioc;
 289
 290         if (ret)
 291                 return ret;
 292
 293         pr_info("setting logging_level(0x%08x)\n", logging_level);
 294         spin_lock(&gioc_lock);
 295         list_for_each_entry(ioc, &mpt3sas_ioc_list, list)
 296                 ioc->logging_level = logging_level;
 297         spin_unlock(&gioc_lock);
 298         return 0;
 299 }
 300 module_param_call(logging_level, _scsih_set_debug_level, param_get_int,
 301         &logging_level, 0644);
 302
 303 /**
 304  * _scsih_srch_boot_sas_address - search based on sas_address
 305  * @sas_address: sas address
 306  * @boot_device: boot device object from bios page 2
 307  *
 308  * Returns 1 when there's a match, 0 means no match.
 309  */
 310 static inline int
 311 _scsih_srch_boot_sas_address(u64 sas_address,
 312         Mpi2BootDeviceSasWwid_t *boot_device)
 313 {
 314         return (sas_address == le64_to_cpu(boot_device->SASAddress)) ?  1 : 0;
 315 }
 316
 317 /**
 318  * _scsih_srch_boot_device_name - search based on device name
 319  * @device_name: device name specified in INDENTIFY fram
 320  * @boot_device: boot device object from bios page 2
 321  *
 322  * Returns 1 when there's a match, 0 means no match.
 323  */
 324 static inline int
 325 _scsih_srch_boot_device_name(u64 device_name,
 326         Mpi2BootDeviceDeviceName_t *boot_device)
 327 {
 328         return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0;
 329 }
 330
 331 /**
 332  * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot
 333  * @enclosure_logical_id: enclosure logical id
 334  * @slot_number: slot number
 335  * @boot_device: boot device object from bios page 2
 336  *
 337  * Returns 1 when there's a match, 0 means no match.
 338  */
 339 static inline int
 340 _scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number,
 341         Mpi2BootDeviceEnclosureSlot_t *boot_device)
 342 {
 343         return (enclosure_logical_id == le64_to_cpu(boot_device->
 344             EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device->
 345             SlotNumber)) ? 1 : 0;
 346 }
 347
 348 /**
 349  * _scsih_is_boot_device - search for matching boot device.
 350  * @sas_address: sas address
 351  * @device_name: device name specified in INDENTIFY fram
 352  * @enclosure_logical_id: enclosure logical id
 353  * @slot_number: slot number
 354  * @form: specifies boot device form
 355  * @boot_device: boot device object from bios page 2
 356  *
 357  * Returns 1 when there's a match, 0 means no match.
 358  */
 359 static int
 360 _scsih_is_boot_device(u64 sas_address, u64 device_name,
 361         u64 enclosure_logical_id, u16 slot, u8 form,
 362         Mpi2BiosPage2BootDevice_t *boot_device)
 363 {
 364         int rc = 0;
 365
 366         switch (form) {
 367         case MPI2_BIOSPAGE2_FORM_SAS_WWID:
 368                 if (!sas_address)
 369                         break;
 370                 rc = _scsih_srch_boot_sas_address(
 371                     sas_address, &boot_device->SasWwid);
 372                 break;
 373         case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:
 374                 if (!enclosure_logical_id)
 375                         break;
 376                 rc = _scsih_srch_boot_encl_slot(
 377                     enclosure_logical_id,
 378                     slot, &boot_device->EnclosureSlot);
 379                 break;
 380         case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:
 381                 if (!device_name)
 382                         break;
 383                 rc = _scsih_srch_boot_device_name(
 384                     device_name, &boot_device->DeviceName);
 385                 break;
 386         case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:
 387                 break;
 388         }
 389
 390         return rc;
 391 }
 392
 393 /**
 394  * _scsih_get_sas_address - set the sas_address for given device handle
 395  * @handle: device handle
 396  * @sas_address: sas address
 397  *
 398  * Returns 0 success, non-zero when failure
 399  */
 400 static int
 401 _scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle,
 402         u64 *sas_address)
 403 {
 404         Mpi2SasDevicePage0_t sas_device_pg0;
 405         Mpi2ConfigReply_t mpi_reply;
 406         u32 ioc_status;
 407
 408         *sas_address = 0;
 409
 410         if (handle <= ioc->sas_hba.num_phys) {
 411                 *sas_address = ioc->sas_hba.sas_address;
 412                 return 0;
 413         }
 414
 415         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 416             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
 417                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
 418                 __FILE__, __LINE__, __func__);
 419                 return -ENXIO;
 420         }
 421
 422         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
 423         if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
 424                 *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
 425                 return 0;
 426         }
 427
 428         /* we hit this becuase the given parent handle doesn't exist */
 429         if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
 430                 return -ENXIO;
 431
 432         /* else error case */
 433         pr_err(MPT3SAS_FMT
 434                 "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
 435                 ioc->name, handle, ioc_status,
 436              __FILE__, __LINE__, __func__);
 437         return -EIO;
 438 }
 439
 440 /**
 441  * _scsih_determine_boot_device - determine boot device.
 442  * @ioc: per adapter object
 443  * @device: either sas_device or raid_device object
 444  * @is_raid: [flag] 1 = raid object, 0 = sas object
 445  *
 446  * Determines whether this device should be first reported device to
 447  * to scsi-ml or sas transport, this purpose is for persistent boot device.
 448  * There are primary, alternate, and current entries in bios page 2. The order
 449  * priority is primary, alternate, then current.  This routine saves
 450  * the corresponding device object and is_raid flag in the ioc object.
 451  * The saved data to be used later in _scsih_probe_boot_devices().
 452  */
 453 static void
 454 _scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc,
 455         void *device, u8 is_raid)
 456 {
 457         struct _sas_device *sas_device;
 458         struct _raid_device *raid_device;
 459         u64 sas_address;
 460         u64 device_name;
 461         u64 enclosure_logical_id;
 462         u16 slot;
 463
 464          /* only process this function when driver loads */
 465         if (!ioc->is_driver_loading)
 466                 return;
 467
 468          /* no Bios, return immediately */
 469         if (!ioc->bios_pg3.BiosVersion)
 470                 return;
 471
 472         if (!is_raid) {
 473                 sas_device = device;
 474                 sas_address = sas_device->sas_address;
 475                 device_name = sas_device->device_name;
 476                 enclosure_logical_id = sas_device->enclosure_logical_id;
 477                 slot = sas_device->slot;
 478         } else {
 479                 raid_device = device;
 480                 sas_address = raid_device->wwid;
 481                 device_name = 0;
 482                 enclosure_logical_id = 0;
 483                 slot = 0;
 484         }
 485
 486         if (!ioc->req_boot_device.device) {
 487                 if (_scsih_is_boot_device(sas_address, device_name,
 488                     enclosure_logical_id, slot,
 489                     (ioc->bios_pg2.ReqBootDeviceForm &
 490                     MPI2_BIOSPAGE2_FORM_MASK),
 491                     &ioc->bios_pg2.RequestedBootDevice)) {
 492                         dinitprintk(ioc, pr_info(MPT3SAS_FMT
 493                            "%s: req_boot_device(0x%016llx)\n",
 494                             ioc->name, __func__,
 495                             (unsigned long long)sas_address));
 496                         ioc->req_boot_device.device = device;
 497                         ioc->req_boot_device.is_raid = is_raid;
 498                 }
 499         }
 500
 501         if (!ioc->req_alt_boot_device.device) {
 502                 if (_scsih_is_boot_device(sas_address, device_name,
 503                     enclosure_logical_id, slot,
 504                     (ioc->bios_pg2.ReqAltBootDeviceForm &
 505                     MPI2_BIOSPAGE2_FORM_MASK),
 506                     &ioc->bios_pg2.RequestedAltBootDevice)) {
 507                         dinitprintk(ioc, pr_info(MPT3SAS_FMT
 508                            "%s: req_alt_boot_device(0x%016llx)\n",
 509                             ioc->name, __func__,
 510                             (unsigned long long)sas_address));
 511                         ioc->req_alt_boot_device.device = device;
 512                         ioc->req_alt_boot_device.is_raid = is_raid;
 513                 }
 514         }
 515
 516         if (!ioc->current_boot_device.device) {
 517                 if (_scsih_is_boot_device(sas_address, device_name,
 518                     enclosure_logical_id, slot,
 519                     (ioc->bios_pg2.CurrentBootDeviceForm &
 520                     MPI2_BIOSPAGE2_FORM_MASK),
 521                     &ioc->bios_pg2.CurrentBootDevice)) {
 522                         dinitprintk(ioc, pr_info(MPT3SAS_FMT
 523                            "%s: current_boot_device(0x%016llx)\n",
 524                             ioc->name, __func__,
 525                             (unsigned long long)sas_address));
 526                         ioc->current_boot_device.device = device;
 527                         ioc->current_boot_device.is_raid = is_raid;
 528                 }
 529         }
 530 }
 531
 532 static struct _sas_device *
 533 __mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
 534                 struct MPT3SAS_TARGET *tgt_priv)
 535 {
 536         struct _sas_device *ret;
 537
 538         assert_spin_locked(&ioc->sas_device_lock);
 539
 540         ret = tgt_priv->sdev;
 541         if (ret)
 542                 sas_device_get(ret);
 543
 544         return ret;
 545 }
 546
 547 static struct _sas_device *
 548 mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc,
 549                 struct MPT3SAS_TARGET *tgt_priv)
 550 {
 551         struct _sas_device *ret;
 552         unsigned long flags;
 553
 554         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 555         ret = __mpt3sas_get_sdev_from_target(ioc, tgt_priv);
 556         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 557
 558         return ret;
 559 }
 560
 561
 562 struct _sas_device *
 563 __mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
 564                                         u64 sas_address)
 565 {
 566         struct _sas_device *sas_device;
 567
 568         assert_spin_locked(&ioc->sas_device_lock);
 569
 570         list_for_each_entry(sas_device, &ioc->sas_device_list, list)
 571                 if (sas_device->sas_address == sas_address)
 572                         goto found_device;
 573
 574         list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
 575                 if (sas_device->sas_address == sas_address)
 576                         goto found_device;
 577
 578         return NULL;
 579
 580 found_device:
 581         sas_device_get(sas_device);
 582         return sas_device;
 583 }
 584
 585 /**
 586  * mpt3sas_get_sdev_by_addr - sas device search
 587  * @ioc: per adapter object
 588  * @sas_address: sas address
 589  * Context: Calling function should acquire ioc->sas_device_lock
 590  *
 591  * This searches for sas_device based on sas_address, then return sas_device
 592  * object.
 593  */
 594 struct _sas_device *
 595 mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc,
 596         u64 sas_address)
 597 {
 598         struct _sas_device *sas_device;
 599         unsigned long flags;
 600
 601         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 602         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
 603                         sas_address);
 604         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 605
 606         return sas_device;
 607 }
 608
 609 static struct _sas_device *
 610 __mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 611 {
 612         struct _sas_device *sas_device;
 613
 614         assert_spin_locked(&ioc->sas_device_lock);
 615
 616         list_for_each_entry(sas_device, &ioc->sas_device_list, list)
 617                 if (sas_device->handle == handle)
 618                         goto found_device;
 619
 620         list_for_each_entry(sas_device, &ioc->sas_device_init_list, list)
 621                 if (sas_device->handle == handle)
 622                         goto found_device;
 623
 624         return NULL;
 625
 626 found_device:
 627         sas_device_get(sas_device);
 628         return sas_device;
 629 }
 630
 631 /**
 632  * mpt3sas_get_sdev_by_handle - sas device search
 633  * @ioc: per adapter object
 634  * @handle: sas device handle (assigned by firmware)
 635  * Context: Calling function should acquire ioc->sas_device_lock
 636  *
 637  * This searches for sas_device based on sas_address, then return sas_device
 638  * object.
 639  */
 640 static struct _sas_device *
 641 mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 642 {
 643         struct _sas_device *sas_device;
 644         unsigned long flags;
 645
 646         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 647         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
 648         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 649
 650         return sas_device;
 651 }
 652
 653 /**
 654  * _scsih_sas_device_remove - remove sas_device from list.
 655  * @ioc: per adapter object
 656  * @sas_device: the sas_device object
 657  * Context: This function will acquire ioc->sas_device_lock.
 658  *
 659  * If sas_device is on the list, remove it and decrement its reference count.
 660  */
 661 static void
 662 _scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc,
 663         struct _sas_device *sas_device)
 664 {
 665         unsigned long flags;
 666
 667         if (!sas_device)
 668                 return;
 669         pr_info(MPT3SAS_FMT
 670             "removing handle(0x%04x), sas_addr(0x%016llx)\n",
 671             ioc->name, sas_device->handle,
 672             (unsigned long long) sas_device->sas_address);
 673
 674         if (sas_device->enclosure_handle != 0)
 675                 pr_info(MPT3SAS_FMT
 676                    "removing enclosure logical id(0x%016llx), slot(%d)\n",
 677                    ioc->name, (unsigned long long)
 678                    sas_device->enclosure_logical_id, sas_device->slot);
 679
 680         if (sas_device->connector_name[0] != '\0')
 681                 pr_info(MPT3SAS_FMT
 682                    "removing enclosure level(0x%04x), connector name( %s)\n",
 683                    ioc->name, sas_device->enclosure_level,
 684                    sas_device->connector_name);
 685
 686         /*
 687          * The lock serializes access to the list, but we still need to verify
 688          * that nobody removed the entry while we were waiting on the lock.
 689          */
 690         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 691         if (!list_empty(&sas_device->list)) {
 692                 list_del_init(&sas_device->list);
 693                 sas_device_put(sas_device);
 694         }
 695         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 696 }
 697
 698 /**
 699  * _scsih_device_remove_by_handle - removing device object by handle
 700  * @ioc: per adapter object
 701  * @handle: device handle
 702  *
 703  * Return nothing.
 704  */
 705 static void
 706 _scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 707 {
 708         struct _sas_device *sas_device;
 709         unsigned long flags;
 710
 711         if (ioc->shost_recovery)
 712                 return;
 713
 714         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 715         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
 716         if (sas_device) {
 717                 list_del_init(&sas_device->list);
 718                 sas_device_put(sas_device);
 719         }
 720         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 721         if (sas_device) {
 722                 _scsih_remove_device(ioc, sas_device);
 723                 sas_device_put(sas_device);
 724         }
 725 }
 726
 727 /**
 728  * mpt3sas_device_remove_by_sas_address - removing device object by sas address
 729  * @ioc: per adapter object
 730  * @sas_address: device sas_address
 731  *
 732  * Return nothing.
 733  */
 734 void
 735 mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
 736         u64 sas_address)
 737 {
 738         struct _sas_device *sas_device;
 739         unsigned long flags;
 740
 741         if (ioc->shost_recovery)
 742                 return;
 743
 744         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 745         sas_device = __mpt3sas_get_sdev_by_addr(ioc, sas_address);
 746         if (sas_device) {
 747                 list_del_init(&sas_device->list);
 748                 sas_device_put(sas_device);
 749         }
 750         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 751         if (sas_device) {
 752                 _scsih_remove_device(ioc, sas_device);
 753                 sas_device_put(sas_device);
 754         }
 755 }
 756
 757 /**
 758  * _scsih_sas_device_add - insert sas_device to the list.
 759  * @ioc: per adapter object
 760  * @sas_device: the sas_device object
 761  * Context: This function will acquire ioc->sas_device_lock.
 762  *
 763  * Adding new object to the ioc->sas_device_list.
 764  */
 765 static void
 766 _scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc,
 767         struct _sas_device *sas_device)
 768 {
 769         unsigned long flags;
 770
 771         dewtprintk(ioc, pr_info(MPT3SAS_FMT
 772                 "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
 773                 ioc->name, __func__, sas_device->handle,
 774                 (unsigned long long)sas_device->sas_address));
 775
 776         if (sas_device->enclosure_handle != 0)
 777                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
 778                     "%s: enclosure logical id(0x%016llx), slot( %d)\n",
 779                     ioc->name, __func__, (unsigned long long)
 780                     sas_device->enclosure_logical_id, sas_device->slot));
 781
 782         if (sas_device->connector_name[0] != '\0')
 783                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
 784                     "%s: enclosure level(0x%04x), connector name( %s)\n",
 785                     ioc->name, __func__,
 786                     sas_device->enclosure_level, sas_device->connector_name));
 787
 788         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 789         sas_device_get(sas_device);
 790         list_add_tail(&sas_device->list, &ioc->sas_device_list);
 791         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 792
 793         if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
 794              sas_device->sas_address_parent)) {
 795                 _scsih_sas_device_remove(ioc, sas_device);
 796         } else if (!sas_device->starget) {
 797                 /*
 798                  * When asyn scanning is enabled, its not possible to remove
 799                  * devices while scanning is turned on due to an oops in
 800                  * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start()
 801                  */
 802                 if (!ioc->is_driver_loading) {
 803                         mpt3sas_transport_port_remove(ioc,
 804                             sas_device->sas_address,
 805                             sas_device->sas_address_parent);
 806                         _scsih_sas_device_remove(ioc, sas_device);
 807                 }
 808         }
 809 }
 810
 811 /**
 812  * _scsih_sas_device_init_add - insert sas_device to the list.
 813  * @ioc: per adapter object
 814  * @sas_device: the sas_device object
 815  * Context: This function will acquire ioc->sas_device_lock.
 816  *
 817  * Adding new object at driver load time to the ioc->sas_device_init_list.
 818  */
 819 static void
 820 _scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc,
 821         struct _sas_device *sas_device)
 822 {
 823         unsigned long flags;
 824
 825         dewtprintk(ioc, pr_info(MPT3SAS_FMT
 826                 "%s: handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
 827                 __func__, sas_device->handle,
 828                 (unsigned long long)sas_device->sas_address));
 829
 830         if (sas_device->enclosure_handle != 0)
 831                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
 832                     "%s: enclosure logical id(0x%016llx), slot( %d)\n",
 833                     ioc->name, __func__, (unsigned long long)
 834                     sas_device->enclosure_logical_id, sas_device->slot));
 835
 836         if (sas_device->connector_name[0] != '\0')
 837                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
 838                     "%s: enclosure level(0x%04x), connector name( %s)\n",
 839                     ioc->name, __func__, sas_device->enclosure_level,
 840                     sas_device->connector_name));
 841
 842         spin_lock_irqsave(&ioc->sas_device_lock, flags);
 843         sas_device_get(sas_device);
 844         list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
 845         _scsih_determine_boot_device(ioc, sas_device, 0);
 846         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 847 }
 848
 849 /**
 850  * _scsih_raid_device_find_by_id - raid device search
 851  * @ioc: per adapter object
 852  * @id: sas device target id
 853  * @channel: sas device channel
 854  * Context: Calling function should acquire ioc->raid_device_lock
 855  *
 856  * This searches for raid_device based on target id, then return raid_device
 857  * object.
 858  */
 859 static struct _raid_device *
 860 _scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel)
 861 {
 862         struct _raid_device *raid_device, *r;
 863
 864         r = NULL;
 865         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
 866                 if (raid_device->id == id && raid_device->channel == channel) {
 867                         r = raid_device;
 868                         goto out;
 869                 }
 870         }
 871
 872  out:
 873         return r;
 874 }
 875
 876 /**
 877  * mpt3sas_raid_device_find_by_handle - raid device search
 878  * @ioc: per adapter object
 879  * @handle: sas device handle (assigned by firmware)
 880  * Context: Calling function should acquire ioc->raid_device_lock
 881  *
 882  * This searches for raid_device based on handle, then return raid_device
 883  * object.
 884  */
 885 struct _raid_device *
 886 mpt3sas_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 887 {
 888         struct _raid_device *raid_device, *r;
 889
 890         r = NULL;
 891         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
 892                 if (raid_device->handle != handle)
 893                         continue;
 894                 r = raid_device;
 895                 goto out;
 896         }
 897
 898  out:
 899         return r;
 900 }
 901
 902 /**
 903  * _scsih_raid_device_find_by_wwid - raid device search
 904  * @ioc: per adapter object
 905  * @handle: sas device handle (assigned by firmware)
 906  * Context: Calling function should acquire ioc->raid_device_lock
 907  *
 908  * This searches for raid_device based on wwid, then return raid_device
 909  * object.
 910  */
 911 static struct _raid_device *
 912 _scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid)
 913 {
 914         struct _raid_device *raid_device, *r;
 915
 916         r = NULL;
 917         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
 918                 if (raid_device->wwid != wwid)
 919                         continue;
 920                 r = raid_device;
 921                 goto out;
 922         }
 923
 924  out:
 925         return r;
 926 }
 927
 928 /**
 929  * _scsih_raid_device_add - add raid_device object
 930  * @ioc: per adapter object
 931  * @raid_device: raid_device object
 932  *
 933  * This is added to the raid_device_list link list.
 934  */
 935 static void
 936 _scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc,
 937         struct _raid_device *raid_device)
 938 {
 939         unsigned long flags;
 940
 941         dewtprintk(ioc, pr_info(MPT3SAS_FMT
 942                 "%s: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
 943             raid_device->handle, (unsigned long long)raid_device->wwid));
 944
 945         spin_lock_irqsave(&ioc->raid_device_lock, flags);
 946         list_add_tail(&raid_device->list, &ioc->raid_device_list);
 947         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 948 }
 949
 950 /**
 951  * _scsih_raid_device_remove - delete raid_device object
 952  * @ioc: per adapter object
 953  * @raid_device: raid_device object
 954  *
 955  */
 956 static void
 957 _scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc,
 958         struct _raid_device *raid_device)
 959 {
 960         unsigned long flags;
 961
 962         spin_lock_irqsave(&ioc->raid_device_lock, flags);
 963         list_del(&raid_device->list);
 964         kfree(raid_device);
 965         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 966 }
 967
 968 /**
 969  * mpt3sas_scsih_expander_find_by_handle - expander device search
 970  * @ioc: per adapter object
 971  * @handle: expander handle (assigned by firmware)
 972  * Context: Calling function should acquire ioc->sas_device_lock
 973  *
 974  * This searches for expander device based on handle, then returns the
 975  * sas_node object.
 976  */
 977 struct _sas_node *
 978 mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
 979 {
 980         struct _sas_node *sas_expander, *r;
 981
 982         r = NULL;
 983         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
 984                 if (sas_expander->handle != handle)
 985                         continue;
 986                 r = sas_expander;
 987                 goto out;
 988         }
 989  out:
 990         return r;
 991 }
 992
 993 /**
 994  * mpt3sas_scsih_expander_find_by_sas_address - expander device search
 995  * @ioc: per adapter object
 996  * @sas_address: sas address
 997  * Context: Calling function should acquire ioc->sas_node_lock.
 998  *
 999  * This searches for expander device based on sas_address, then returns the
1000  * sas_node object.
1001  */
1002 struct _sas_node *
1003 mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
1004         u64 sas_address)
1005 {
1006         struct _sas_node *sas_expander, *r;
1007
1008         r = NULL;
1009         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
1010                 if (sas_expander->sas_address != sas_address)
1011                         continue;
1012                 r = sas_expander;
1013                 goto out;
1014         }
1015  out:
1016         return r;
1017 }
1018
1019 /**
1020  * _scsih_expander_node_add - insert expander device to the list.
1021  * @ioc: per adapter object
1022  * @sas_expander: the sas_device object
1023  * Context: This function will acquire ioc->sas_node_lock.
1024  *
1025  * Adding new object to the ioc->sas_expander_list.
1026  *
1027  * Return nothing.
1028  */
1029 static void
1030 _scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc,
1031         struct _sas_node *sas_expander)
1032 {
1033         unsigned long flags;
1034
1035         spin_lock_irqsave(&ioc->sas_node_lock, flags);
1036         list_add_tail(&sas_expander->list, &ioc->sas_expander_list);
1037         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1038 }
1039
1040 /**
1041  * _scsih_is_end_device - determines if device is an end device
1042  * @device_info: bitfield providing information about the device.
1043  * Context: none
1044  *
1045  * Returns 1 if end device.
1046  */
1047 static int
1048 _scsih_is_end_device(u32 device_info)
1049 {
1050         if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&
1051                 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) |
1052                 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) |
1053                 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)))
1054                 return 1;
1055         else
1056                 return 0;
1057 }
1058
1059 /**
1060  * _scsih_scsi_lookup_get - returns scmd entry
1061  * @ioc: per adapter object
1062  * @smid: system request message index
1063  *
1064  * Returns the smid stored scmd pointer.
1065  */
1066 static struct scsi_cmnd *
1067 _scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
1068 {
1069         return ioc->scsi_lookup[smid - 1].scmd;
1070 }
1071
1072 /**
1073  * _scsih_scsi_lookup_get_clear - returns scmd entry
1074  * @ioc: per adapter object
1075  * @smid: system request message index
1076  *
1077  * Returns the smid stored scmd pointer.
1078  * Then will derefrence the stored scmd pointer.
1079  */
1080 static inline struct scsi_cmnd *
1081 _scsih_scsi_lookup_get_clear(struct MPT3SAS_ADAPTER *ioc, u16 smid)
1082 {
1083         unsigned long flags;
1084         struct scsi_cmnd *scmd;
1085
1086         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1087         scmd = ioc->scsi_lookup[smid - 1].scmd;
1088         ioc->scsi_lookup[smid - 1].scmd = NULL;
1089         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1090
1091         return scmd;
1092 }
1093
1094 /**
1095  * _scsih_scsi_lookup_find_by_scmd - scmd lookup
1096  * @ioc: per adapter object
1097  * @smid: system request message index
1098  * @scmd: pointer to scsi command object
1099  * Context: This function will acquire ioc->scsi_lookup_lock.
1100  *
1101  * This will search for a scmd pointer in the scsi_lookup array,
1102  * returning the revelent smid.  A returned value of zero means invalid.
1103  */
1104 static u16
1105 _scsih_scsi_lookup_find_by_scmd(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd
1106         *scmd)
1107 {
1108         u16 smid;
1109         unsigned long   flags;
1110         int i;
1111
1112         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1113         smid = 0;
1114         for (i = 0; i < ioc->scsiio_depth; i++) {
1115                 if (ioc->scsi_lookup[i].scmd == scmd) {
1116                         smid = ioc->scsi_lookup[i].smid;
1117                         goto out;
1118                 }
1119         }
1120  out:
1121         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1122         return smid;
1123 }
1124
1125 /**
1126  * _scsih_scsi_lookup_find_by_target - search for matching channel:id
1127  * @ioc: per adapter object
1128  * @id: target id
1129  * @channel: channel
1130  * Context: This function will acquire ioc->scsi_lookup_lock.
1131  *
1132  * This will search for a matching channel:id in the scsi_lookup array,
1133  * returning 1 if found.
1134  */
1135 static u8
1136 _scsih_scsi_lookup_find_by_target(struct MPT3SAS_ADAPTER *ioc, int id,
1137         int channel)
1138 {
1139         u8 found;
1140         unsigned long   flags;
1141         int i;
1142
1143         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1144         found = 0;
1145         for (i = 0 ; i < ioc->scsiio_depth; i++) {
1146                 if (ioc->scsi_lookup[i].scmd &&
1147                     (ioc->scsi_lookup[i].scmd->device->id == id &&
1148                     ioc->scsi_lookup[i].scmd->device->channel == channel)) {
1149                         found = 1;
1150                         goto out;
1151                 }
1152         }
1153  out:
1154         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1155         return found;
1156 }
1157
1158 /**
1159  * _scsih_scsi_lookup_find_by_lun - search for matching channel:id:lun
1160  * @ioc: per adapter object
1161  * @id: target id
1162  * @lun: lun number
1163  * @channel: channel
1164  * Context: This function will acquire ioc->scsi_lookup_lock.
1165  *
1166  * This will search for a matching channel:id:lun in the scsi_lookup array,
1167  * returning 1 if found.
1168  */
1169 static u8
1170 _scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id,
1171         unsigned int lun, int channel)
1172 {
1173         u8 found;
1174         unsigned long   flags;
1175         int i;
1176
1177         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1178         found = 0;
1179         for (i = 0 ; i < ioc->scsiio_depth; i++) {
1180                 if (ioc->scsi_lookup[i].scmd &&
1181                     (ioc->scsi_lookup[i].scmd->device->id == id &&
1182                     ioc->scsi_lookup[i].scmd->device->channel == channel &&
1183                     ioc->scsi_lookup[i].scmd->device->lun == lun)) {
1184                         found = 1;
1185                         goto out;
1186                 }
1187         }
1188  out:
1189         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1190         return found;
1191 }
1192
1193 /**
1194  * scsih_change_queue_depth - setting device queue depth
1195  * @sdev: scsi device struct
1196  * @qdepth: requested queue depth
1197  *
1198  * Returns queue depth.
1199  */
1200 int
1201 scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
1202 {
1203         struct Scsi_Host *shost = sdev->host;
1204         int max_depth;
1205         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1206         struct MPT3SAS_DEVICE *sas_device_priv_data;
1207         struct MPT3SAS_TARGET *sas_target_priv_data;
1208         struct _sas_device *sas_device;
1209         unsigned long flags;
1210
1211         max_depth = shost->can_queue;
1212
1213         /* limit max device queue for SATA to 32 */
1214         sas_device_priv_data = sdev->hostdata;
1215         if (!sas_device_priv_data)
1216                 goto not_sata;
1217         sas_target_priv_data = sas_device_priv_data->sas_target;
1218         if (!sas_target_priv_data)
1219                 goto not_sata;
1220         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
1221                 goto not_sata;
1222
1223         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1224         sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
1225         if (sas_device) {
1226                 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1227                         max_depth = MPT3SAS_SATA_QUEUE_DEPTH;
1228
1229                 sas_device_put(sas_device);
1230         }
1231         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1232
1233  not_sata:
1234
1235         if (!sdev->tagged_supported)
1236                 max_depth = 1;
1237         if (qdepth > max_depth)
1238                 qdepth = max_depth;
1239         return scsi_change_queue_depth(sdev, qdepth);
1240 }
1241
1242 /**
1243  * scsih_target_alloc - target add routine
1244  * @starget: scsi target struct
1245  *
1246  * Returns 0 if ok. Any other return is assumed to be an error and
1247  * the device is ignored.
1248  */
1249 int
1250 scsih_target_alloc(struct scsi_target *starget)
1251 {
1252         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1253         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1254         struct MPT3SAS_TARGET *sas_target_priv_data;
1255         struct _sas_device *sas_device;
1256         struct _raid_device *raid_device;
1257         unsigned long flags;
1258         struct sas_rphy *rphy;
1259
1260         sas_target_priv_data = kzalloc(sizeof(*sas_target_priv_data),
1261                                        GFP_KERNEL);
1262         if (!sas_target_priv_data)
1263                 return -ENOMEM;
1264
1265         starget->hostdata = sas_target_priv_data;
1266         sas_target_priv_data->starget = starget;
1267         sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
1268
1269         /* RAID volumes */
1270         if (starget->channel == RAID_CHANNEL) {
1271                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1272                 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1273                     starget->channel);
1274                 if (raid_device) {
1275                         sas_target_priv_data->handle = raid_device->handle;
1276                         sas_target_priv_data->sas_address = raid_device->wwid;
1277                         sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
1278                         sas_target_priv_data->raid_device = raid_device;
1279                         if (ioc->is_warpdrive)
1280                                 raid_device->starget = starget;
1281                 }
1282                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1283                 return 0;
1284         }
1285
1286         /* sas/sata devices */
1287         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1288         rphy = dev_to_rphy(starget->dev.parent);
1289         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1290            rphy->identify.sas_address);
1291
1292         if (sas_device) {
1293                 sas_target_priv_data->handle = sas_device->handle;
1294                 sas_target_priv_data->sas_address = sas_device->sas_address;
1295                 sas_target_priv_data->sdev = sas_device;
1296                 sas_device->starget = starget;
1297                 sas_device->id = starget->id;
1298                 sas_device->channel = starget->channel;
1299                 if (test_bit(sas_device->handle, ioc->pd_handles))
1300                         sas_target_priv_data->flags |=
1301                             MPT_TARGET_FLAGS_RAID_COMPONENT;
1302                 if (sas_device->fast_path)
1303                         sas_target_priv_data->flags |= MPT_TARGET_FASTPATH_IO;
1304         }
1305         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1306
1307         return 0;
1308 }
1309
1310 /**
1311  * scsih_target_destroy - target destroy routine
1312  * @starget: scsi target struct
1313  *
1314  * Returns nothing.
1315  */
1316 void
1317 scsih_target_destroy(struct scsi_target *starget)
1318 {
1319         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1320         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1321         struct MPT3SAS_TARGET *sas_target_priv_data;
1322         struct _sas_device *sas_device;
1323         struct _raid_device *raid_device;
1324         unsigned long flags;
1325         struct sas_rphy *rphy;
1326
1327         sas_target_priv_data = starget->hostdata;
1328         if (!sas_target_priv_data)
1329                 return;
1330
1331         if (starget->channel == RAID_CHANNEL) {
1332                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1333                 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id,
1334                     starget->channel);
1335                 if (raid_device) {
1336                         raid_device->starget = NULL;
1337                         raid_device->sdev = NULL;
1338                 }
1339                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1340                 goto out;
1341         }
1342
1343         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1344         rphy = dev_to_rphy(starget->dev.parent);
1345         sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data);
1346         if (sas_device && (sas_device->starget == starget) &&
1347             (sas_device->id == starget->id) &&
1348             (sas_device->channel == starget->channel))
1349                 sas_device->starget = NULL;
1350
1351         if (sas_device) {
1352                 /*
1353                  * Corresponding get() is in _scsih_target_alloc()
1354                  */
1355                 sas_target_priv_data->sdev = NULL;
1356                 sas_device_put(sas_device);
1357
1358                 sas_device_put(sas_device);
1359         }
1360         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1361
1362  out:
1363         kfree(sas_target_priv_data);
1364         starget->hostdata = NULL;
1365 }
1366
1367 /**
1368  * scsih_slave_alloc - device add routine
1369  * @sdev: scsi device struct
1370  *
1371  * Returns 0 if ok. Any other return is assumed to be an error and
1372  * the device is ignored.
1373  */
1374 int
1375 scsih_slave_alloc(struct scsi_device *sdev)
1376 {
1377         struct Scsi_Host *shost;
1378         struct MPT3SAS_ADAPTER *ioc;
1379         struct MPT3SAS_TARGET *sas_target_priv_data;
1380         struct MPT3SAS_DEVICE *sas_device_priv_data;
1381         struct scsi_target *starget;
1382         struct _raid_device *raid_device;
1383         struct _sas_device *sas_device;
1384         unsigned long flags;
1385
1386         sas_device_priv_data = kzalloc(sizeof(*sas_device_priv_data),
1387                                        GFP_KERNEL);
1388         if (!sas_device_priv_data)
1389                 return -ENOMEM;
1390
1391         sas_device_priv_data->lun = sdev->lun;
1392         sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT;
1393
1394         starget = scsi_target(sdev);
1395         sas_target_priv_data = starget->hostdata;
1396         sas_target_priv_data->num_luns++;
1397         sas_device_priv_data->sas_target = sas_target_priv_data;
1398         sdev->hostdata = sas_device_priv_data;
1399         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
1400                 sdev->no_uld_attach = 1;
1401
1402         shost = dev_to_shost(&starget->dev);
1403         ioc = shost_priv(shost);
1404         if (starget->channel == RAID_CHANNEL) {
1405                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1406                 raid_device = _scsih_raid_device_find_by_id(ioc,
1407                     starget->id, starget->channel);
1408                 if (raid_device)
1409                         raid_device->sdev = sdev; /* raid is single lun */
1410                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1411         }
1412
1413         if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1414                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1415                 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1416                                         sas_target_priv_data->sas_address);
1417                 if (sas_device && (sas_device->starget == NULL)) {
1418                         sdev_printk(KERN_INFO, sdev,
1419                         "%s : sas_device->starget set to starget @ %d\n",
1420                              __func__, __LINE__);
1421                         sas_device->starget = starget;
1422                 }
1423
1424                 if (sas_device)
1425                         sas_device_put(sas_device);
1426
1427                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1428         }
1429
1430         return 0;
1431 }
1432
1433 /**
1434  * scsih_slave_destroy - device destroy routine
1435  * @sdev: scsi device struct
1436  *
1437  * Returns nothing.
1438  */
1439 void
1440 scsih_slave_destroy(struct scsi_device *sdev)
1441 {
1442         struct MPT3SAS_TARGET *sas_target_priv_data;
1443         struct scsi_target *starget;
1444         struct Scsi_Host *shost;
1445         struct MPT3SAS_ADAPTER *ioc;
1446         struct _sas_device *sas_device;
1447         unsigned long flags;
1448
1449         if (!sdev->hostdata)
1450                 return;
1451
1452         starget = scsi_target(sdev);
1453         sas_target_priv_data = starget->hostdata;
1454         sas_target_priv_data->num_luns--;
1455
1456         shost = dev_to_shost(&starget->dev);
1457         ioc = shost_priv(shost);
1458
1459         if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) {
1460                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1461                 sas_device = __mpt3sas_get_sdev_from_target(ioc,
1462                                 sas_target_priv_data);
1463                 if (sas_device && !sas_target_priv_data->num_luns)
1464                         sas_device->starget = NULL;
1465
1466                 if (sas_device)
1467                         sas_device_put(sas_device);
1468                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1469         }
1470
1471         kfree(sdev->hostdata);
1472         sdev->hostdata = NULL;
1473 }
1474
1475 /**
1476  * _scsih_display_sata_capabilities - sata capabilities
1477  * @ioc: per adapter object
1478  * @handle: device handle
1479  * @sdev: scsi device struct
1480  */
1481 static void
1482 _scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc,
1483         u16 handle, struct scsi_device *sdev)
1484 {
1485         Mpi2ConfigReply_t mpi_reply;
1486         Mpi2SasDevicePage0_t sas_device_pg0;
1487         u32 ioc_status;
1488         u16 flags;
1489         u32 device_info;
1490
1491         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
1492             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
1493                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1494                     ioc->name, __FILE__, __LINE__, __func__);
1495                 return;
1496         }
1497
1498         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1499             MPI2_IOCSTATUS_MASK;
1500         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1501                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1502                     ioc->name, __FILE__, __LINE__, __func__);
1503                 return;
1504         }
1505
1506         flags = le16_to_cpu(sas_device_pg0.Flags);
1507         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
1508
1509         sdev_printk(KERN_INFO, sdev,
1510             "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), "
1511             "sw_preserve(%s)\n",
1512             (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n",
1513             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n",
1514             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" :
1515             "n",
1516             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n",
1517             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n",
1518             (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n");
1519 }
1520
1521 /*
1522  * raid transport support -
1523  * Enabled for SLES11 and newer, in older kernels the driver will panic when
1524  * unloading the driver followed by a load - I beleive that the subroutine
1525  * raid_class_release() is not cleaning up properly.
1526  */
1527
1528 /**
1529  * scsih_is_raid - return boolean indicating device is raid volume
1530  * @dev the device struct object
1531  */
1532 int
1533 scsih_is_raid(struct device *dev)
1534 {
1535         struct scsi_device *sdev = to_scsi_device(dev);
1536         struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1537
1538         if (ioc->is_warpdrive)
1539                 return 0;
1540         return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
1541 }
1542
1543 /**
1544  * scsih_get_resync - get raid volume resync percent complete
1545  * @dev the device struct object
1546  */
1547 void
1548 scsih_get_resync(struct device *dev)
1549 {
1550         struct scsi_device *sdev = to_scsi_device(dev);
1551         struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1552         static struct _raid_device *raid_device;
1553         unsigned long flags;
1554         Mpi2RaidVolPage0_t vol_pg0;
1555         Mpi2ConfigReply_t mpi_reply;
1556         u32 volume_status_flags;
1557         u8 percent_complete;
1558         u16 handle;
1559
1560         percent_complete = 0;
1561         handle = 0;
1562         if (ioc->is_warpdrive)
1563                 goto out;
1564
1565         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1566         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1567             sdev->channel);
1568         if (raid_device) {
1569                 handle = raid_device->handle;
1570                 percent_complete = raid_device->percent_complete;
1571         }
1572         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1573
1574         if (!handle)
1575                 goto out;
1576
1577         if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1578              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1579              sizeof(Mpi2RaidVolPage0_t))) {
1580                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1581                     ioc->name, __FILE__, __LINE__, __func__);
1582                 percent_complete = 0;
1583                 goto out;
1584         }
1585
1586         volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1587         if (!(volume_status_flags &
1588             MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
1589                 percent_complete = 0;
1590
1591  out:
1592         if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
1593                 raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
1594         if (ioc->hba_mpi_version_belonged == MPI25_VERSION)
1595                 raid_set_resync(mpt3sas_raid_template, dev, percent_complete);
1596 }
1597
1598 /**
1599  * scsih_get_state - get raid volume level
1600  * @dev the device struct object
1601  */
1602 void
1603 scsih_get_state(struct device *dev)
1604 {
1605         struct scsi_device *sdev = to_scsi_device(dev);
1606         struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host);
1607         static struct _raid_device *raid_device;
1608         unsigned long flags;
1609         Mpi2RaidVolPage0_t vol_pg0;
1610         Mpi2ConfigReply_t mpi_reply;
1611         u32 volstate;
1612         enum raid_state state = RAID_STATE_UNKNOWN;
1613         u16 handle = 0;
1614
1615         spin_lock_irqsave(&ioc->raid_device_lock, flags);
1616         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
1617             sdev->channel);
1618         if (raid_device)
1619                 handle = raid_device->handle;
1620         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1621
1622         if (!raid_device)
1623                 goto out;
1624
1625         if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
1626              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
1627              sizeof(Mpi2RaidVolPage0_t))) {
1628                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1629                     ioc->name, __FILE__, __LINE__, __func__);
1630                 goto out;
1631         }
1632
1633         volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
1634         if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
1635                 state = RAID_STATE_RESYNCING;
1636                 goto out;
1637         }
1638
1639         switch (vol_pg0.VolumeState) {
1640         case MPI2_RAID_VOL_STATE_OPTIMAL:
1641         case MPI2_RAID_VOL_STATE_ONLINE:
1642                 state = RAID_STATE_ACTIVE;
1643                 break;
1644         case  MPI2_RAID_VOL_STATE_DEGRADED:
1645                 state = RAID_STATE_DEGRADED;
1646                 break;
1647         case MPI2_RAID_VOL_STATE_FAILED:
1648         case MPI2_RAID_VOL_STATE_MISSING:
1649                 state = RAID_STATE_OFFLINE;
1650                 break;
1651         }
1652  out:
1653         if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
1654                 raid_set_state(mpt2sas_raid_template, dev, state);
1655         if (ioc->hba_mpi_version_belonged == MPI25_VERSION)
1656                 raid_set_state(mpt3sas_raid_template, dev, state);
1657 }
1658
1659 /**
1660  * _scsih_set_level - set raid level
1661  * @sdev: scsi device struct
1662  * @volume_type: volume type
1663  */
1664 static void
1665 _scsih_set_level(struct MPT3SAS_ADAPTER *ioc,
1666         struct scsi_device *sdev, u8 volume_type)
1667 {
1668         enum raid_level level = RAID_LEVEL_UNKNOWN;
1669
1670         switch (volume_type) {
1671         case MPI2_RAID_VOL_TYPE_RAID0:
1672                 level = RAID_LEVEL_0;
1673                 break;
1674         case MPI2_RAID_VOL_TYPE_RAID10:
1675                 level = RAID_LEVEL_10;
1676                 break;
1677         case MPI2_RAID_VOL_TYPE_RAID1E:
1678                 level = RAID_LEVEL_1E;
1679                 break;
1680         case MPI2_RAID_VOL_TYPE_RAID1:
1681                 level = RAID_LEVEL_1;
1682                 break;
1683         }
1684
1685         if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
1686                 raid_set_level(mpt2sas_raid_template,
1687                                &sdev->sdev_gendev, level);
1688         if (ioc->hba_mpi_version_belonged == MPI25_VERSION)
1689                 raid_set_level(mpt3sas_raid_template,
1690                                &sdev->sdev_gendev, level);
1691 }
1692
1693
1694 /**
1695  * _scsih_get_volume_capabilities - volume capabilities
1696  * @ioc: per adapter object
1697  * @sas_device: the raid_device object
1698  *
1699  * Returns 0 for success, else 1
1700  */
1701 static int
1702 _scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc,
1703         struct _raid_device *raid_device)
1704 {
1705         Mpi2RaidVolPage0_t *vol_pg0;
1706         Mpi2RaidPhysDiskPage0_t pd_pg0;
1707         Mpi2SasDevicePage0_t sas_device_pg0;
1708         Mpi2ConfigReply_t mpi_reply;
1709         u16 sz;
1710         u8 num_pds;
1711
1712         if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
1713             &num_pds)) || !num_pds) {
1714                 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1715                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1716                     __func__));
1717                 return 1;
1718         }
1719
1720         raid_device->num_pds = num_pds;
1721         sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
1722             sizeof(Mpi2RaidVol0PhysDisk_t));
1723         vol_pg0 = kzalloc(sz, GFP_KERNEL);
1724         if (!vol_pg0) {
1725                 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1726                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1727                     __func__));
1728                 return 1;
1729         }
1730
1731         if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
1732              MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
1733                 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1734                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1735                     __func__));
1736                 kfree(vol_pg0);
1737                 return 1;
1738         }
1739
1740         raid_device->volume_type = vol_pg0->VolumeType;
1741
1742         /* figure out what the underlying devices are by
1743          * obtaining the device_info bits for the 1st device
1744          */
1745         if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
1746             &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
1747             vol_pg0->PhysDisk[0].PhysDiskNum))) {
1748                 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
1749                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
1750                     le16_to_cpu(pd_pg0.DevHandle)))) {
1751                         raid_device->device_info =
1752                             le32_to_cpu(sas_device_pg0.DeviceInfo);
1753                 }
1754         }
1755
1756         kfree(vol_pg0);
1757         return 0;
1758 }
1759
1760 /**
1761  * _scsih_enable_tlr - setting TLR flags
1762  * @ioc: per adapter object
1763  * @sdev: scsi device struct
1764  *
1765  * Enabling Transaction Layer Retries for tape devices when
1766  * vpd page 0x90 is present
1767  *
1768  */
1769 static void
1770 _scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev)
1771 {
1772
1773         /* only for TAPE */
1774         if (sdev->type != TYPE_TAPE)
1775                 return;
1776
1777         if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
1778                 return;
1779
1780         sas_enable_tlr(sdev);
1781         sdev_printk(KERN_INFO, sdev, "TLR %s\n",
1782             sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
1783         return;
1784
1785 }
1786
1787 /**
1788  * scsih_slave_configure - device configure routine.
1789  * @sdev: scsi device struct
1790  *
1791  * Returns 0 if ok. Any other return is assumed to be an error and
1792  * the device is ignored.
1793  */
1794 int
1795 scsih_slave_configure(struct scsi_device *sdev)
1796 {
1797         struct Scsi_Host *shost = sdev->host;
1798         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1799         struct MPT3SAS_DEVICE *sas_device_priv_data;
1800         struct MPT3SAS_TARGET *sas_target_priv_data;
1801         struct _sas_device *sas_device;
1802         struct _raid_device *raid_device;
1803         unsigned long flags;
1804         int qdepth;
1805         u8 ssp_target = 0;
1806         char *ds = "";
1807         char *r_level = "";
1808         u16 handle, volume_handle = 0;
1809         u64 volume_wwid = 0;
1810
1811         qdepth = 1;
1812         sas_device_priv_data = sdev->hostdata;
1813         sas_device_priv_data->configured_lun = 1;
1814         sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
1815         sas_target_priv_data = sas_device_priv_data->sas_target;
1816         handle = sas_target_priv_data->handle;
1817
1818         /* raid volume handling */
1819         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
1820
1821                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1822                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
1823                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1824                 if (!raid_device) {
1825                         dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1826                             "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
1827                             __LINE__, __func__));
1828                         return 1;
1829                 }
1830
1831                 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
1832                         dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1833                             "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
1834                             __LINE__, __func__));
1835                         return 1;
1836                 }
1837
1838                 /*
1839                  * WARPDRIVE: Initialize the required data for Direct IO
1840                  */
1841                 mpt3sas_init_warpdrive_properties(ioc, raid_device);
1842
1843                 /* RAID Queue Depth Support
1844                  * IS volume = underlying qdepth of drive type, either
1845                  *    MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH
1846                  * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH)
1847                  */
1848                 if (raid_device->device_info &
1849                     MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
1850                         qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
1851                         ds = "SSP";
1852                 } else {
1853                         qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
1854                          if (raid_device->device_info &
1855                             MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1856                                 ds = "SATA";
1857                         else
1858                                 ds = "STP";
1859                 }
1860
1861                 switch (raid_device->volume_type) {
1862                 case MPI2_RAID_VOL_TYPE_RAID0:
1863                         r_level = "RAID0";
1864                         break;
1865                 case MPI2_RAID_VOL_TYPE_RAID1E:
1866                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1867                         if (ioc->manu_pg10.OEMIdentifier &&
1868                             (le32_to_cpu(ioc->manu_pg10.GenericFlags0) &
1869                             MFG10_GF0_R10_DISPLAY) &&
1870                             !(raid_device->num_pds % 2))
1871                                 r_level = "RAID10";
1872                         else
1873                                 r_level = "RAID1E";
1874                         break;
1875                 case MPI2_RAID_VOL_TYPE_RAID1:
1876                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1877                         r_level = "RAID1";
1878                         break;
1879                 case MPI2_RAID_VOL_TYPE_RAID10:
1880                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1881                         r_level = "RAID10";
1882                         break;
1883                 case MPI2_RAID_VOL_TYPE_UNKNOWN:
1884                 default:
1885                         qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
1886                         r_level = "RAIDX";
1887                         break;
1888                 }
1889
1890                 if (!ioc->hide_ir_msg)
1891                         sdev_printk(KERN_INFO, sdev,
1892                            "%s: handle(0x%04x), wwid(0x%016llx),"
1893                             " pd_count(%d), type(%s)\n",
1894                             r_level, raid_device->handle,
1895                             (unsigned long long)raid_device->wwid,
1896                             raid_device->num_pds, ds);
1897
1898                 scsih_change_queue_depth(sdev, qdepth);
1899
1900                 /* raid transport support */
1901                 if (!ioc->is_warpdrive)
1902                         _scsih_set_level(ioc, sdev, raid_device->volume_type);
1903                 return 0;
1904         }
1905
1906         /* non-raid handling */
1907         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1908                 if (mpt3sas_config_get_volume_handle(ioc, handle,
1909                     &volume_handle)) {
1910                         dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1911                             "failure at %s:%d/%s()!\n", ioc->name,
1912                             __FILE__, __LINE__, __func__));
1913                         return 1;
1914                 }
1915                 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
1916                     volume_handle, &volume_wwid)) {
1917                         dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1918                             "failure at %s:%d/%s()!\n", ioc->name,
1919                             __FILE__, __LINE__, __func__));
1920                         return 1;
1921                 }
1922         }
1923
1924         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1925         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1926            sas_device_priv_data->sas_target->sas_address);
1927         if (!sas_device) {
1928                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1929                 dfailprintk(ioc, pr_warn(MPT3SAS_FMT
1930                     "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
1931                     __func__));
1932                 return 1;
1933         }
1934
1935         sas_device->volume_handle = volume_handle;
1936         sas_device->volume_wwid = volume_wwid;
1937         if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
1938                 qdepth = MPT3SAS_SAS_QUEUE_DEPTH;
1939                 ssp_target = 1;
1940                 ds = "SSP";
1941         } else {
1942                 qdepth = MPT3SAS_SATA_QUEUE_DEPTH;
1943                 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
1944                         ds = "STP";
1945                 else if (sas_device->device_info &
1946                     MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
1947                         ds = "SATA";
1948         }
1949
1950         sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \
1951             "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
1952             ds, handle, (unsigned long long)sas_device->sas_address,
1953             sas_device->phy, (unsigned long long)sas_device->device_name);
1954         if (sas_device->enclosure_handle != 0)
1955                 sdev_printk(KERN_INFO, sdev,
1956                      "%s: enclosure_logical_id(0x%016llx), slot(%d)\n",
1957                      ds, (unsigned long long)
1958                      sas_device->enclosure_logical_id, sas_device->slot);
1959         if (sas_device->connector_name[0] != '\0')
1960                 sdev_printk(KERN_INFO, sdev,
1961                      "%s: enclosure level(0x%04x), connector name( %s)\n",
1962                      ds, sas_device->enclosure_level,
1963                      sas_device->connector_name);
1964
1965         sas_device_put(sas_device);
1966         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1967
1968         if (!ssp_target)
1969                 _scsih_display_sata_capabilities(ioc, handle, sdev);
1970
1971
1972         scsih_change_queue_depth(sdev, qdepth);
1973
1974         if (ssp_target) {
1975                 sas_read_port_mode_page(sdev);
1976                 _scsih_enable_tlr(ioc, sdev);
1977         }
1978
1979         return 0;
1980 }
1981
1982 /**
1983  * scsih_bios_param - fetch head, sector, cylinder info for a disk
1984  * @sdev: scsi device struct
1985  * @bdev: pointer to block device context
1986  * @capacity: device size (in 512 byte sectors)
1987  * @params: three element array to place output:
1988  *              params[0] number of heads (max 255)
1989  *              params[1] number of sectors (max 63)
1990  *              params[2] number of cylinders
1991  *
1992  * Return nothing.
1993  */
1994 int
1995 scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
1996         sector_t capacity, int params[])
1997 {
1998         int             heads;
1999         int             sectors;
2000         sector_t        cylinders;
2001         ulong           dummy;
2002
2003         heads = 64;
2004         sectors = 32;
2005
2006         dummy = heads * sectors;
2007         cylinders = capacity;
2008         sector_div(cylinders, dummy);
2009
2010         /*
2011          * Handle extended translation size for logical drives
2012          * > 1Gb
2013          */
2014         if ((ulong)capacity >= 0x200000) {
2015                 heads = 255;
2016                 sectors = 63;
2017                 dummy = heads * sectors;
2018                 cylinders = capacity;
2019                 sector_div(cylinders, dummy);
2020         }
2021
2022         /* return result */
2023         params[0] = heads;
2024         params[1] = sectors;
2025         params[2] = cylinders;
2026
2027         return 0;
2028 }
2029
2030 /**
2031  * _scsih_response_code - translation of device response code
2032  * @ioc: per adapter object
2033  * @response_code: response code returned by the device
2034  *
2035  * Return nothing.
2036  */
2037 static void
2038 _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code)
2039 {
2040         char *desc;
2041
2042         switch (response_code) {
2043         case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
2044                 desc = "task management request completed";
2045                 break;
2046         case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
2047                 desc = "invalid frame";
2048                 break;
2049         case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2050                 desc = "task management request not supported";
2051                 break;
2052         case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
2053                 desc = "task management request failed";
2054                 break;
2055         case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2056                 desc = "task management request succeeded";
2057                 break;
2058         case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2059                 desc = "invalid lun";
2060                 break;
2061         case 0xA:
2062                 desc = "overlapped tag attempted";
2063                 break;
2064         case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2065                 desc = "task queued, however not sent to target";
2066                 break;
2067         default:
2068                 desc = "unknown";
2069                 break;
2070         }
2071         pr_warn(MPT3SAS_FMT "response_code(0x%01x): %s\n",
2072                 ioc->name, response_code, desc);
2073 }
2074
2075 /**
2076  * _scsih_tm_done - tm completion routine
2077  * @ioc: per adapter object
2078  * @smid: system request message index
2079  * @msix_index: MSIX table index supplied by the OS
2080  * @reply: reply message frame(lower 32bit addr)
2081  * Context: none.
2082  *
2083  * The callback handler when using scsih_issue_tm.
2084  *
2085  * Return 1 meaning mf should be freed from _base_interrupt
2086  *        0 means the mf is freed from this function.
2087  */
2088 static u8
2089 _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
2090 {
2091         MPI2DefaultReply_t *mpi_reply;
2092
2093         if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED)
2094                 return 1;
2095         if (ioc->tm_cmds.smid != smid)
2096                 return 1;
2097         mpt3sas_base_flush_reply_queues(ioc);
2098         ioc->tm_cmds.status |= MPT3_CMD_COMPLETE;
2099         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
2100         if (mpi_reply) {
2101                 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
2102                 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID;
2103         }
2104         ioc->tm_cmds.status &= ~MPT3_CMD_PENDING;
2105         complete(&ioc->tm_cmds.done);
2106         return 1;
2107 }
2108
2109 /**
2110  * mpt3sas_scsih_set_tm_flag - set per target tm_busy
2111  * @ioc: per adapter object
2112  * @handle: device handle
2113  *
2114  * During taskmangement request, we need to freeze the device queue.
2115  */
2116 void
2117 mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2118 {
2119         struct MPT3SAS_DEVICE *sas_device_priv_data;
2120         struct scsi_device *sdev;
2121         u8 skip = 0;
2122
2123         shost_for_each_device(sdev, ioc->shost) {
2124                 if (skip)
2125                         continue;
2126                 sas_device_priv_data = sdev->hostdata;
2127                 if (!sas_device_priv_data)
2128                         continue;
2129                 if (sas_device_priv_data->sas_target->handle == handle) {
2130                         sas_device_priv_data->sas_target->tm_busy = 1;
2131                         skip = 1;
2132                         ioc->ignore_loginfos = 1;
2133                 }
2134         }
2135 }
2136
2137 /**
2138  * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy
2139  * @ioc: per adapter object
2140  * @handle: device handle
2141  *
2142  * During taskmangement request, we need to freeze the device queue.
2143  */
2144 void
2145 mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2146 {
2147         struct MPT3SAS_DEVICE *sas_device_priv_data;
2148         struct scsi_device *sdev;
2149         u8 skip = 0;
2150
2151         shost_for_each_device(sdev, ioc->shost) {
2152                 if (skip)
2153                         continue;
2154                 sas_device_priv_data = sdev->hostdata;
2155                 if (!sas_device_priv_data)
2156                         continue;
2157                 if (sas_device_priv_data->sas_target->handle == handle) {
2158                         sas_device_priv_data->sas_target->tm_busy = 0;
2159                         skip = 1;
2160                         ioc->ignore_loginfos = 0;
2161                 }
2162         }
2163 }
2164
2165 /**
2166  * mpt3sas_scsih_issue_tm - main routine for sending tm requests
2167  * @ioc: per adapter struct
2168  * @device_handle: device handle
2169  * @channel: the channel assigned by the OS
2170  * @id: the id assigned by the OS
2171  * @lun: lun number
2172  * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h)
2173  * @smid_task: smid assigned to the task
2174  * @timeout: timeout in seconds
2175  * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
2176  * Context: user
2177  *
2178  * A generic API for sending task management requests to firmware.
2179  *
2180  * The callback index is set inside `ioc->tm_cb_idx`.
2181  *
2182  * Return SUCCESS or FAILED.
2183  */
2184 int
2185 mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel,
2186         uint id, uint lun, u8 type, u16 smid_task, ulong timeout,
2187         enum mutex_type m_type)
2188 {
2189         Mpi2SCSITaskManagementRequest_t *mpi_request;
2190         Mpi2SCSITaskManagementReply_t *mpi_reply;
2191         u16 smid = 0;
2192         u32 ioc_state;
2193         unsigned long timeleft;
2194         struct scsiio_tracker *scsi_lookup = NULL;
2195         int rc;
2196
2197         if (m_type == TM_MUTEX_ON)
2198                 mutex_lock(&ioc->tm_cmds.mutex);
2199         if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
2200                 pr_info(MPT3SAS_FMT "%s: tm_cmd busy!!!\n",
2201                     __func__, ioc->name);
2202                 rc = FAILED;
2203                 goto err_out;
2204         }
2205
2206         if (ioc->shost_recovery || ioc->remove_host ||
2207             ioc->pci_error_recovery) {
2208                 pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
2209                     __func__, ioc->name);
2210                 rc = FAILED;
2211                 goto err_out;
2212         }
2213
2214         ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
2215         if (ioc_state & MPI2_DOORBELL_USED) {
2216                 dhsprintk(ioc, pr_info(MPT3SAS_FMT
2217                         "unexpected doorbell active!\n", ioc->name));
2218                 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2219                     FORCE_BIG_HAMMER);
2220                 rc = (!rc) ? SUCCESS : FAILED;
2221                 goto err_out;
2222         }
2223
2224         if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) {
2225                 mpt3sas_base_fault_info(ioc, ioc_state &
2226                     MPI2_DOORBELL_DATA_MASK);
2227                 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2228                     FORCE_BIG_HAMMER);
2229                 rc = (!rc) ? SUCCESS : FAILED;
2230                 goto err_out;
2231         }
2232
2233         smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
2234         if (!smid) {
2235                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
2236                     ioc->name, __func__);
2237                 rc = FAILED;
2238                 goto err_out;
2239         }
2240
2241         if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
2242                 scsi_lookup = &ioc->scsi_lookup[smid_task - 1];
2243
2244         dtmprintk(ioc, pr_info(MPT3SAS_FMT
2245                 "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d)\n",
2246                 ioc->name, handle, type, smid_task));
2247         ioc->tm_cmds.status = MPT3_CMD_PENDING;
2248         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2249         ioc->tm_cmds.smid = smid;
2250         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
2251         memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t));
2252         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
2253         mpi_request->DevHandle = cpu_to_le16(handle);
2254         mpi_request->TaskType = type;
2255         mpi_request->TaskMID = cpu_to_le16(smid_task);
2256         int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN);
2257         mpt3sas_scsih_set_tm_flag(ioc, handle);
2258         init_completion(&ioc->tm_cmds.done);
2259         mpt3sas_base_put_smid_hi_priority(ioc, smid);
2260         timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ);
2261         if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) {
2262                 pr_err(MPT3SAS_FMT "%s: timeout\n",
2263                     ioc->name, __func__);
2264                 _debug_dump_mf(mpi_request,
2265                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2266                 if (!(ioc->tm_cmds.status & MPT3_CMD_RESET)) {
2267                         rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2268                             FORCE_BIG_HAMMER);
2269                         rc = (!rc) ? SUCCESS : FAILED;
2270                         ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
2271                         mpt3sas_scsih_clear_tm_flag(ioc, handle);
2272                         goto err_out;
2273                 }
2274         }
2275
2276         if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
2277                 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
2278                 mpi_reply = ioc->tm_cmds.reply;
2279                 dtmprintk(ioc, pr_info(MPT3SAS_FMT "complete tm: " \
2280                     "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
2281                     ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
2282                     le32_to_cpu(mpi_reply->IOCLogInfo),
2283                     le32_to_cpu(mpi_reply->TerminationCount)));
2284                 if (ioc->logging_level & MPT_DEBUG_TM) {
2285                         _scsih_response_code(ioc, mpi_reply->ResponseCode);
2286                         if (mpi_reply->IOCStatus)
2287                                 _debug_dump_mf(mpi_request,
2288                                     sizeof(Mpi2SCSITaskManagementRequest_t)/4);
2289                 }
2290         }
2291
2292         switch (type) {
2293         case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
2294                 rc = SUCCESS;
2295                 if (scsi_lookup->scmd == NULL)
2296                         break;
2297                 rc = FAILED;
2298                 break;
2299
2300         case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
2301                 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel))
2302                         rc = FAILED;
2303                 else
2304                         rc = SUCCESS;
2305                 break;
2306         case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
2307         case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
2308                 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel))
2309                         rc = FAILED;
2310                 else
2311                         rc = SUCCESS;
2312                 break;
2313         case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
2314                 rc = SUCCESS;
2315                 break;
2316         default:
2317                 rc = FAILED;
2318                 break;
2319         }
2320
2321         mpt3sas_scsih_clear_tm_flag(ioc, handle);
2322         ioc->tm_cmds.status = MPT3_CMD_NOT_USED;
2323         if (m_type == TM_MUTEX_ON)
2324                 mutex_unlock(&ioc->tm_cmds.mutex);
2325
2326         return rc;
2327
2328  err_out:
2329         if (m_type == TM_MUTEX_ON)
2330                 mutex_unlock(&ioc->tm_cmds.mutex);
2331         return rc;
2332 }
2333
2334 /**
2335  * _scsih_tm_display_info - displays info about the device
2336  * @ioc: per adapter struct
2337  * @scmd: pointer to scsi command object
2338  *
2339  * Called by task management callback handlers.
2340  */
2341 static void
2342 _scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
2343 {
2344         struct scsi_target *starget = scmd->device->sdev_target;
2345         struct MPT3SAS_TARGET *priv_target = starget->hostdata;
2346         struct _sas_device *sas_device = NULL;
2347         unsigned long flags;
2348         char *device_str = NULL;
2349
2350         if (!priv_target)
2351                 return;
2352         if (ioc->hide_ir_msg)
2353                 device_str = "WarpDrive";
2354         else
2355                 device_str = "volume";
2356
2357         scsi_print_command(scmd);
2358         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2359                 starget_printk(KERN_INFO, starget,
2360                         "%s handle(0x%04x), %s wwid(0x%016llx)\n",
2361                         device_str, priv_target->handle,
2362                     device_str, (unsigned long long)priv_target->sas_address);
2363         } else {
2364                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
2365                 sas_device = __mpt3sas_get_sdev_from_target(ioc, priv_target);
2366                 if (sas_device) {
2367                         if (priv_target->flags &
2368                             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2369                                 starget_printk(KERN_INFO, starget,
2370                                     "volume handle(0x%04x), "
2371                                     "volume wwid(0x%016llx)\n",
2372                                     sas_device->volume_handle,
2373                                    (unsigned long long)sas_device->volume_wwid);
2374                         }
2375                         starget_printk(KERN_INFO, starget,
2376                             "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n",
2377                             sas_device->handle,
2378                             (unsigned long long)sas_device->sas_address,
2379                             sas_device->phy);
2380                         if (sas_device->enclosure_handle != 0)
2381                                 starget_printk(KERN_INFO, starget,
2382                                  "enclosure_logical_id(0x%016llx), slot(%d)\n",
2383                                  (unsigned long long)
2384                                  sas_device->enclosure_logical_id,
2385                                  sas_device->slot);
2386                         if (sas_device->connector_name)
2387                                 starget_printk(KERN_INFO, starget,
2388                                 "enclosure level(0x%04x),connector name(%s)\n",
2389                                  sas_device->enclosure_level,
2390                                  sas_device->connector_name);
2391
2392                         sas_device_put(sas_device);
2393                 }
2394                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
2395         }
2396 }
2397
2398 /**
2399  * scsih_abort - eh threads main abort routine
2400  * @scmd: pointer to scsi command object
2401  *
2402  * Returns SUCCESS if command aborted else FAILED
2403  */
2404 int
2405 scsih_abort(struct scsi_cmnd *scmd)
2406 {
2407         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2408         struct MPT3SAS_DEVICE *sas_device_priv_data;
2409         u16 smid;
2410         u16 handle;
2411         int r;
2412
2413         sdev_printk(KERN_INFO, scmd->device,
2414                 "attempting task abort! scmd(%p)\n", scmd);
2415         _scsih_tm_display_info(ioc, scmd);
2416
2417         sas_device_priv_data = scmd->device->hostdata;
2418         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2419                 sdev_printk(KERN_INFO, scmd->device,
2420                         "device been deleted! scmd(%p)\n", scmd);
2421                 scmd->result = DID_NO_CONNECT << 16;
2422                 scmd->scsi_done(scmd);
2423                 r = SUCCESS;
2424                 goto out;
2425         }
2426
2427         /* search for the command */
2428         smid = _scsih_scsi_lookup_find_by_scmd(ioc, scmd);
2429         if (!smid) {
2430                 scmd->result = DID_RESET << 16;
2431                 r = SUCCESS;
2432                 goto out;
2433         }
2434
2435         /* for hidden raid components and volumes this is not supported */
2436         if (sas_device_priv_data->sas_target->flags &
2437             MPT_TARGET_FLAGS_RAID_COMPONENT ||
2438             sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) {
2439                 scmd->result = DID_RESET << 16;
2440                 r = FAILED;
2441                 goto out;
2442         }
2443
2444         mpt3sas_halt_firmware(ioc);
2445
2446         handle = sas_device_priv_data->sas_target->handle;
2447         r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2448             scmd->device->id, scmd->device->lun,
2449             MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30, TM_MUTEX_ON);
2450
2451  out:
2452         sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
2453             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2454         return r;
2455 }
2456
2457 /**
2458  * scsih_dev_reset - eh threads main device reset routine
2459  * @scmd: pointer to scsi command object
2460  *
2461  * Returns SUCCESS if command aborted else FAILED
2462  */
2463 int
2464 scsih_dev_reset(struct scsi_cmnd *scmd)
2465 {
2466         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2467         struct MPT3SAS_DEVICE *sas_device_priv_data;
2468         struct _sas_device *sas_device = NULL;
2469         u16     handle;
2470         int r;
2471
2472         struct scsi_target *starget = scmd->device->sdev_target;
2473         struct MPT3SAS_TARGET *target_priv_data = starget->hostdata;
2474
2475         sdev_printk(KERN_INFO, scmd->device,
2476                 "attempting device reset! scmd(%p)\n", scmd);
2477         _scsih_tm_display_info(ioc, scmd);
2478
2479         sas_device_priv_data = scmd->device->hostdata;
2480         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2481                 sdev_printk(KERN_INFO, scmd->device,
2482                         "device been deleted! scmd(%p)\n", scmd);
2483                 scmd->result = DID_NO_CONNECT << 16;
2484                 scmd->scsi_done(scmd);
2485                 r = SUCCESS;
2486                 goto out;
2487         }
2488
2489         /* for hidden raid components obtain the volume_handle */
2490         handle = 0;
2491         if (sas_device_priv_data->sas_target->flags &
2492             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2493                 sas_device = mpt3sas_get_sdev_from_target(ioc,
2494                                 target_priv_data);
2495                 if (sas_device)
2496                         handle = sas_device->volume_handle;
2497         } else
2498                 handle = sas_device_priv_data->sas_target->handle;
2499
2500         if (!handle) {
2501                 scmd->result = DID_RESET << 16;
2502                 r = FAILED;
2503                 goto out;
2504         }
2505
2506         r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2507             scmd->device->id, scmd->device->lun,
2508             MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 30, TM_MUTEX_ON);
2509
2510  out:
2511         sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(%p)\n",
2512             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2513
2514         if (sas_device)
2515                 sas_device_put(sas_device);
2516
2517         return r;
2518 }
2519
2520 /**
2521  * scsih_target_reset - eh threads main target reset routine
2522  * @scmd: pointer to scsi command object
2523  *
2524  * Returns SUCCESS if command aborted else FAILED
2525  */
2526 int
2527 scsih_target_reset(struct scsi_cmnd *scmd)
2528 {
2529         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2530         struct MPT3SAS_DEVICE *sas_device_priv_data;
2531         struct _sas_device *sas_device = NULL;
2532         u16     handle;
2533         int r;
2534         struct scsi_target *starget = scmd->device->sdev_target;
2535         struct MPT3SAS_TARGET *target_priv_data = starget->hostdata;
2536
2537         starget_printk(KERN_INFO, starget, "attempting target reset! scmd(%p)\n",
2538                 scmd);
2539         _scsih_tm_display_info(ioc, scmd);
2540
2541         sas_device_priv_data = scmd->device->hostdata;
2542         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
2543                 starget_printk(KERN_INFO, starget, "target been deleted! scmd(%p)\n",
2544                         scmd);
2545                 scmd->result = DID_NO_CONNECT << 16;
2546                 scmd->scsi_done(scmd);
2547                 r = SUCCESS;
2548                 goto out;
2549         }
2550
2551         /* for hidden raid components obtain the volume_handle */
2552         handle = 0;
2553         if (sas_device_priv_data->sas_target->flags &
2554             MPT_TARGET_FLAGS_RAID_COMPONENT) {
2555                 sas_device = mpt3sas_get_sdev_from_target(ioc,
2556                                 target_priv_data);
2557                 if (sas_device)
2558                         handle = sas_device->volume_handle;
2559         } else
2560                 handle = sas_device_priv_data->sas_target->handle;
2561
2562         if (!handle) {
2563                 scmd->result = DID_RESET << 16;
2564                 r = FAILED;
2565                 goto out;
2566         }
2567
2568         r = mpt3sas_scsih_issue_tm(ioc, handle, scmd->device->channel,
2569             scmd->device->id, 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0,
2570             30, TM_MUTEX_ON);
2571
2572  out:
2573         starget_printk(KERN_INFO, starget, "target reset: %s scmd(%p)\n",
2574             ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2575
2576         if (sas_device)
2577                 sas_device_put(sas_device);
2578
2579         return r;
2580 }
2581
2582
2583 /**
2584  * scsih_host_reset - eh threads main host reset routine
2585  * @scmd: pointer to scsi command object
2586  *
2587  * Returns SUCCESS if command aborted else FAILED
2588  */
2589 int
2590 scsih_host_reset(struct scsi_cmnd *scmd)
2591 {
2592         struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
2593         int r, retval;
2594
2595         pr_info(MPT3SAS_FMT "attempting host reset! scmd(%p)\n",
2596             ioc->name, scmd);
2597         scsi_print_command(scmd);
2598
2599         if (ioc->is_driver_loading) {
2600                 pr_info(MPT3SAS_FMT "Blocking the host reset\n",
2601                     ioc->name);
2602                 r = FAILED;
2603                 goto out;
2604         }
2605
2606         retval = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2607             FORCE_BIG_HAMMER);
2608         r = (retval < 0) ? FAILED : SUCCESS;
2609 out:
2610         pr_info(MPT3SAS_FMT "host reset: %s scmd(%p)\n",
2611             ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
2612
2613         return r;
2614 }
2615
2616 /**
2617  * _scsih_fw_event_add - insert and queue up fw_event
2618  * @ioc: per adapter object
2619  * @fw_event: object describing the event
2620  * Context: This function will acquire ioc->fw_event_lock.
2621  *
2622  * This adds the firmware event object into link list, then queues it up to
2623  * be processed from user context.
2624  *
2625  * Return nothing.
2626  */
2627 static void
2628 _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
2629 {
2630         unsigned long flags;
2631
2632         if (ioc->firmware_event_thread == NULL)
2633                 return;
2634
2635         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2636         fw_event_work_get(fw_event);
2637         INIT_LIST_HEAD(&fw_event->list);
2638         list_add_tail(&fw_event->list, &ioc->fw_event_list);
2639         INIT_WORK(&fw_event->work, _firmware_event_work);
2640         fw_event_work_get(fw_event);
2641         queue_work(ioc->firmware_event_thread, &fw_event->work);
2642         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2643 }
2644
2645 /**
2646  * _scsih_fw_event_del_from_list - delete fw_event from the list
2647  * @ioc: per adapter object
2648  * @fw_event: object describing the event
2649  * Context: This function will acquire ioc->fw_event_lock.
2650  *
2651  * If the fw_event is on the fw_event_list, remove it and do a put.
2652  *
2653  * Return nothing.
2654  */
2655 static void
2656 _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
2657         *fw_event)
2658 {
2659         unsigned long flags;
2660
2661         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2662         if (!list_empty(&fw_event->list)) {
2663                 list_del_init(&fw_event->list);
2664                 fw_event_work_put(fw_event);
2665         }
2666         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2667 }
2668
2669
2670  /**
2671  * mpt3sas_send_trigger_data_event - send event for processing trigger data
2672  * @ioc: per adapter object
2673  * @event_data: trigger event data
2674  *
2675  * Return nothing.
2676  */
2677 void
2678 mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc,
2679         struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data)
2680 {
2681         struct fw_event_work *fw_event;
2682         u16 sz;
2683
2684         if (ioc->is_driver_loading)
2685                 return;
2686         sz = sizeof(*event_data);
2687         fw_event = alloc_fw_event_work(sz);
2688         if (!fw_event)
2689                 return;
2690         fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG;
2691         fw_event->ioc = ioc;
2692         memcpy(fw_event->event_data, event_data, sizeof(*event_data));
2693         _scsih_fw_event_add(ioc, fw_event);
2694         fw_event_work_put(fw_event);
2695 }
2696
2697 /**
2698  * _scsih_error_recovery_delete_devices - remove devices not responding
2699  * @ioc: per adapter object
2700  *
2701  * Return nothing.
2702  */
2703 static void
2704 _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc)
2705 {
2706         struct fw_event_work *fw_event;
2707
2708         if (ioc->is_driver_loading)
2709                 return;
2710         fw_event = alloc_fw_event_work(0);
2711         if (!fw_event)
2712                 return;
2713         fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES;
2714         fw_event->ioc = ioc;
2715         _scsih_fw_event_add(ioc, fw_event);
2716         fw_event_work_put(fw_event);
2717 }
2718
2719 /**
2720  * mpt3sas_port_enable_complete - port enable completed (fake event)
2721  * @ioc: per adapter object
2722  *
2723  * Return nothing.
2724  */
2725 void
2726 mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc)
2727 {
2728         struct fw_event_work *fw_event;
2729
2730         fw_event = alloc_fw_event_work(0);
2731         if (!fw_event)
2732                 return;
2733         fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE;
2734         fw_event->ioc = ioc;
2735         _scsih_fw_event_add(ioc, fw_event);
2736         fw_event_work_put(fw_event);
2737 }
2738
2739 static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc)
2740 {
2741         unsigned long flags;
2742         struct fw_event_work *fw_event = NULL;
2743
2744         spin_lock_irqsave(&ioc->fw_event_lock, flags);
2745         if (!list_empty(&ioc->fw_event_list)) {
2746                 fw_event = list_first_entry(&ioc->fw_event_list,
2747                                 struct fw_event_work, list);
2748                 list_del_init(&fw_event->list);
2749         }
2750         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
2751
2752         return fw_event;
2753 }
2754
2755 /**
2756  * _scsih_fw_event_cleanup_queue - cleanup event queue
2757  * @ioc: per adapter object
2758  *
2759  * Walk the firmware event queue, either killing timers, or waiting
2760  * for outstanding events to complete
2761  *
2762  * Return nothing.
2763  */
2764 static void
2765 _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
2766 {
2767         struct fw_event_work *fw_event;
2768
2769         if (list_empty(&ioc->fw_event_list) ||
2770              !ioc->firmware_event_thread || in_interrupt())
2771                 return;
2772
2773         while ((fw_event = dequeue_next_fw_event(ioc))) {
2774                 /*
2775                  * Wait on the fw_event to complete. If this returns 1, then
2776                  * the event was never executed, and we need a put for the
2777                  * reference the delayed_work had on the fw_event.
2778                  *
2779                  * If it did execute, we wait for it to finish, and the put will
2780                  * happen from _firmware_event_work()
2781                  */
2782                 if (cancel_delayed_work_sync(&fw_event->delayed_work))
2783                         fw_event_work_put(fw_event);
2784
2785                 fw_event_work_put(fw_event);
2786         }
2787 }
2788
2789 /**
2790  * _scsih_internal_device_block - block the sdev device
2791  * @sdev: per device object
2792  * @sas_device_priv_data : per device driver private data
2793  *
2794  * make sure device is blocked without error, if not
2795  * print an error
2796  */
2797 static void
2798 _scsih_internal_device_block(struct scsi_device *sdev,
2799                         struct MPT3SAS_DEVICE *sas_device_priv_data)
2800 {
2801         int r = 0;
2802
2803         sdev_printk(KERN_INFO, sdev, "device_block, handle(0x%04x)\n",
2804             sas_device_priv_data->sas_target->handle);
2805         sas_device_priv_data->block = 1;
2806
2807         r = scsi_internal_device_block(sdev);
2808         if (r == -EINVAL)
2809                 sdev_printk(KERN_WARNING, sdev,
2810                     "device_block failed with return(%d) for handle(0x%04x)\n",
2811                     sas_device_priv_data->sas_target->handle, r);
2812 }
2813
2814 /**
2815  * _scsih_internal_device_unblock - unblock the sdev device
2816  * @sdev: per device object
2817  * @sas_device_priv_data : per device driver private data
2818  * make sure device is unblocked without error, if not retry
2819  * by blocking and then unblocking
2820  */
2821
2822 static void
2823 _scsih_internal_device_unblock(struct scsi_device *sdev,
2824                         struct MPT3SAS_DEVICE *sas_device_priv_data)
2825 {
2826         int r = 0;
2827
2828         sdev_printk(KERN_WARNING, sdev, "device_unblock and setting to running, "
2829             "handle(0x%04x)\n", sas_device_priv_data->sas_target->handle);
2830         sas_device_priv_data->block = 0;
2831         r = scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2832         if (r == -EINVAL) {
2833                 /* The device has been set to SDEV_RUNNING by SD layer during
2834                  * device addition but the request queue is still stopped by
2835                  * our earlier block call. We need to perform a block again
2836                  * to get the device to SDEV_BLOCK and then to SDEV_RUNNING */
2837
2838                 sdev_printk(KERN_WARNING, sdev,
2839                     "device_unblock failed with return(%d) for handle(0x%04x) "
2840                     "performing a block followed by an unblock\n",
2841                     sas_device_priv_data->sas_target->handle, r);
2842                 sas_device_priv_data->block = 1;
2843                 r = scsi_internal_device_block(sdev);
2844                 if (r)
2845                         sdev_printk(KERN_WARNING, sdev, "retried device_block "
2846                             "failed with return(%d) for handle(0x%04x)\n",
2847                             sas_device_priv_data->sas_target->handle, r);
2848
2849                 sas_device_priv_data->block = 0;
2850                 r = scsi_internal_device_unblock(sdev, SDEV_RUNNING);
2851                 if (r)
2852                         sdev_printk(KERN_WARNING, sdev, "retried device_unblock"
2853                             " failed with return(%d) for handle(0x%04x)\n",
2854                             sas_device_priv_data->sas_target->handle, r);
2855         }
2856 }
2857
2858 /**
2859  * _scsih_ublock_io_all_device - unblock every device
2860  * @ioc: per adapter object
2861  *
2862  * change the device state from block to running
2863  */
2864 static void
2865 _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc)
2866 {
2867         struct MPT3SAS_DEVICE *sas_device_priv_data;
2868         struct scsi_device *sdev;
2869
2870         shost_for_each_device(sdev, ioc->shost) {
2871                 sas_device_priv_data = sdev->hostdata;
2872                 if (!sas_device_priv_data)
2873                         continue;
2874                 if (!sas_device_priv_data->block)
2875                         continue;
2876
2877                 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
2878                         "device_running, handle(0x%04x)\n",
2879                     sas_device_priv_data->sas_target->handle));
2880                 _scsih_internal_device_unblock(sdev, sas_device_priv_data);
2881         }
2882 }
2883
2884
2885 /**
2886  * _scsih_ublock_io_device - prepare device to be deleted
2887  * @ioc: per adapter object
2888  * @sas_addr: sas address
2889  *
2890  * unblock then put device in offline state
2891  */
2892 static void
2893 _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
2894 {
2895         struct MPT3SAS_DEVICE *sas_device_priv_data;
2896         struct scsi_device *sdev;
2897
2898         shost_for_each_device(sdev, ioc->shost) {
2899                 sas_device_priv_data = sdev->hostdata;
2900                 if (!sas_device_priv_data)
2901                         continue;
2902                 if (sas_device_priv_data->sas_target->sas_address
2903                     != sas_address)
2904                         continue;
2905                 if (sas_device_priv_data->block)
2906                         _scsih_internal_device_unblock(sdev,
2907                                 sas_device_priv_data);
2908         }
2909 }
2910
2911 /**
2912  * _scsih_block_io_all_device - set the device state to SDEV_BLOCK
2913  * @ioc: per adapter object
2914  * @handle: device handle
2915  *
2916  * During device pull we need to appropiately set the sdev state.
2917  */
2918 static void
2919 _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc)
2920 {
2921         struct MPT3SAS_DEVICE *sas_device_priv_data;
2922         struct scsi_device *sdev;
2923
2924         shost_for_each_device(sdev, ioc->shost) {
2925                 sas_device_priv_data = sdev->hostdata;
2926                 if (!sas_device_priv_data)
2927                         continue;
2928                 if (sas_device_priv_data->block)
2929                         continue;
2930                 _scsih_internal_device_block(sdev, sas_device_priv_data);
2931         }
2932 }
2933
2934 /**
2935  * _scsih_block_io_device - set the device state to SDEV_BLOCK
2936  * @ioc: per adapter object
2937  * @handle: device handle
2938  *
2939  * During device pull we need to appropiately set the sdev state.
2940  */
2941 static void
2942 _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
2943 {
2944         struct MPT3SAS_DEVICE *sas_device_priv_data;
2945         struct scsi_device *sdev;
2946         struct _sas_device *sas_device;
2947
2948         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
2949         if (!sas_device)
2950                 return;
2951
2952         shost_for_each_device(sdev, ioc->shost) {
2953                 sas_device_priv_data = sdev->hostdata;
2954                 if (!sas_device_priv_data)
2955                         continue;
2956                 if (sas_device_priv_data->sas_target->handle != handle)
2957                         continue;
2958                 if (sas_device_priv_data->block)
2959                         continue;
2960                 if (sas_device->pend_sas_rphy_add)
2961                         continue;
2962                 _scsih_internal_device_block(sdev, sas_device_priv_data);
2963         }
2964
2965         sas_device_put(sas_device);
2966 }
2967
2968 /**
2969  * _scsih_block_io_to_children_attached_to_ex
2970  * @ioc: per adapter object
2971  * @sas_expander: the sas_device object
2972  *
2973  * This routine set sdev state to SDEV_BLOCK for all devices
2974  * attached to this expander. This function called when expander is
2975  * pulled.
2976  */
2977 static void
2978 _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc,
2979         struct _sas_node *sas_expander)
2980 {
2981         struct _sas_port *mpt3sas_port;
2982         struct _sas_device *sas_device;
2983         struct _sas_node *expander_sibling;
2984         unsigned long flags;
2985
2986         if (!sas_expander)
2987                 return;
2988
2989         list_for_each_entry(mpt3sas_port,
2990            &sas_expander->sas_port_list, port_list) {
2991                 if (mpt3sas_port->remote_identify.device_type ==
2992                     SAS_END_DEVICE) {
2993                         spin_lock_irqsave(&ioc->sas_device_lock, flags);
2994                         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
2995                             mpt3sas_port->remote_identify.sas_address);
2996                         if (sas_device) {
2997                                 set_bit(sas_device->handle,
2998                                                 ioc->blocking_handles);
2999                                 sas_device_put(sas_device);
3000                         }
3001                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3002                 }
3003         }
3004
3005         list_for_each_entry(mpt3sas_port,
3006            &sas_expander->sas_port_list, port_list) {
3007
3008                 if (mpt3sas_port->remote_identify.device_type ==
3009                     SAS_EDGE_EXPANDER_DEVICE ||
3010                     mpt3sas_port->remote_identify.device_type ==
3011                     SAS_FANOUT_EXPANDER_DEVICE) {
3012                         expander_sibling =
3013                             mpt3sas_scsih_expander_find_by_sas_address(
3014                             ioc, mpt3sas_port->remote_identify.sas_address);
3015                         _scsih_block_io_to_children_attached_to_ex(ioc,
3016                             expander_sibling);
3017                 }
3018         }
3019 }
3020
3021 /**
3022  * _scsih_block_io_to_children_attached_directly
3023  * @ioc: per adapter object
3024  * @event_data: topology change event data
3025  *
3026  * This routine set sdev state to SDEV_BLOCK for all devices
3027  * direct attached during device pull.
3028  */
3029 static void
3030 _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc,
3031         Mpi2EventDataSasTopologyChangeList_t *event_data)
3032 {
3033         int i;
3034         u16 handle;
3035         u16 reason_code;
3036
3037         for (i = 0; i < event_data->NumEntries; i++) {
3038                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3039                 if (!handle)
3040                         continue;
3041                 reason_code = event_data->PHY[i].PhyStatus &
3042                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3043                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
3044                         _scsih_block_io_device(ioc, handle);
3045         }
3046 }
3047
3048 /**
3049  * _scsih_tm_tr_send - send task management request
3050  * @ioc: per adapter object
3051  * @handle: device handle
3052  * Context: interrupt time.
3053  *
3054  * This code is to initiate the device removal handshake protocol
3055  * with controller firmware.  This function will issue target reset
3056  * using high priority request queue.  It will send a sas iounit
3057  * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion.
3058  *
3059  * This is designed to send muliple task management request at the same
3060  * time to the fifo. If the fifo is full, we will append the request,
3061  * and process it in a future completion.
3062  */
3063 static void
3064 _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3065 {
3066         Mpi2SCSITaskManagementRequest_t *mpi_request;
3067         u16 smid;
3068         struct _sas_device *sas_device = NULL;
3069         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
3070         u64 sas_address = 0;
3071         unsigned long flags;
3072         struct _tr_list *delayed_tr;
3073         u32 ioc_state;
3074
3075         if (ioc->remove_host) {
3076                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3077                         "%s: host has been removed: handle(0x%04x)\n",
3078                         __func__, ioc->name, handle));
3079                 return;
3080         } else if (ioc->pci_error_recovery) {
3081                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3082                         "%s: host in pci error recovery: handle(0x%04x)\n",
3083                         __func__, ioc->name,
3084                     handle));
3085                 return;
3086         }
3087         ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
3088         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3089                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3090                         "%s: host is not operational: handle(0x%04x)\n",
3091                         __func__, ioc->name,
3092                    handle));
3093                 return;
3094         }
3095
3096         /* if PD, then return */
3097         if (test_bit(handle, ioc->pd_handles))
3098                 return;
3099
3100         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3101         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
3102         if (sas_device && sas_device->starget &&
3103             sas_device->starget->hostdata) {
3104                 sas_target_priv_data = sas_device->starget->hostdata;
3105                 sas_target_priv_data->deleted = 1;
3106                 sas_address = sas_device->sas_address;
3107         }
3108         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3109
3110         if (sas_target_priv_data) {
3111                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3112                         "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
3113                         ioc->name, handle,
3114                     (unsigned long long)sas_address));
3115                 if (sas_device->enclosure_handle != 0)
3116                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3117                          "setting delete flag:enclosure logical id(0x%016llx),"
3118                          " slot(%d)\n", ioc->name, (unsigned long long)
3119                           sas_device->enclosure_logical_id,
3120                           sas_device->slot));
3121                 if (sas_device->connector_name)
3122                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3123                          "setting delete flag: enclosure level(0x%04x),"
3124                          " connector name( %s)\n", ioc->name,
3125                           sas_device->enclosure_level,
3126                           sas_device->connector_name));
3127                 _scsih_ublock_io_device(ioc, sas_address);
3128                 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
3129         }
3130
3131         smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
3132         if (!smid) {
3133                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3134                 if (!delayed_tr)
3135                         goto out;
3136                 INIT_LIST_HEAD(&delayed_tr->list);
3137                 delayed_tr->handle = handle;
3138                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3139                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3140                     "DELAYED:tr:handle(0x%04x), (open)\n",
3141                     ioc->name, handle));
3142                 goto out;
3143         }
3144
3145         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3146                 "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3147                 ioc->name, handle, smid,
3148             ioc->tm_tr_cb_idx));
3149         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3150         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3151         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3152         mpi_request->DevHandle = cpu_to_le16(handle);
3153         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3154         mpt3sas_base_put_smid_hi_priority(ioc, smid);
3155         mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL);
3156
3157 out:
3158         if (sas_device)
3159                 sas_device_put(sas_device);
3160 }
3161
3162 /**
3163  * _scsih_tm_tr_complete -
3164  * @ioc: per adapter object
3165  * @smid: system request message index
3166  * @msix_index: MSIX table index supplied by the OS
3167  * @reply: reply message frame(lower 32bit addr)
3168  * Context: interrupt time.
3169  *
3170  * This is the target reset completion routine.
3171  * This code is part of the code to initiate the device removal
3172  * handshake protocol with controller firmware.
3173  * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE)
3174  *
3175  * Return 1 meaning mf should be freed from _base_interrupt
3176  *        0 means the mf is freed from this function.
3177  */
3178 static u8
3179 _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
3180         u32 reply)
3181 {
3182         u16 handle;
3183         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3184         Mpi2SCSITaskManagementReply_t *mpi_reply =
3185             mpt3sas_base_get_reply_virt_addr(ioc, reply);
3186         Mpi2SasIoUnitControlRequest_t *mpi_request;
3187         u16 smid_sas_ctrl;
3188         u32 ioc_state;
3189
3190         if (ioc->remove_host) {
3191                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3192                         "%s: host has been removed\n", __func__, ioc->name));
3193                 return 1;
3194         } else if (ioc->pci_error_recovery) {
3195                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3196                         "%s: host in pci error recovery\n", __func__,
3197                         ioc->name));
3198                 return 1;
3199         }
3200         ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
3201         if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
3202                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3203                         "%s: host is not operational\n", __func__, ioc->name));
3204                 return 1;
3205         }
3206         if (unlikely(!mpi_reply)) {
3207                 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3208                     ioc->name, __FILE__, __LINE__, __func__);
3209                 return 1;
3210         }
3211         mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3212         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3213         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3214                 dewtprintk(ioc, pr_err(MPT3SAS_FMT
3215                         "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3216                         ioc->name, handle,
3217                     le16_to_cpu(mpi_reply->DevHandle), smid));
3218                 return 0;
3219         }
3220
3221         mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
3222         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3223             "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3224             "loginfo(0x%08x), completed(%d)\n", ioc->name,
3225             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3226             le32_to_cpu(mpi_reply->IOCLogInfo),
3227             le32_to_cpu(mpi_reply->TerminationCount)));
3228
3229         smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
3230         if (!smid_sas_ctrl) {
3231                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
3232                     ioc->name, __func__);
3233                 return 1;
3234         }
3235
3236         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3237                 "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3238                 ioc->name, handle, smid_sas_ctrl,
3239             ioc->tm_sas_control_cb_idx));
3240         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
3241         memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
3242         mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
3243         mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
3244         mpi_request->DevHandle = mpi_request_tm->DevHandle;
3245         mpt3sas_base_put_smid_default(ioc, smid_sas_ctrl);
3246
3247         return _scsih_check_for_pending_tm(ioc, smid);
3248 }
3249
3250
3251 /**
3252  * _scsih_sas_control_complete - completion routine
3253  * @ioc: per adapter object
3254  * @smid: system request message index
3255  * @msix_index: MSIX table index supplied by the OS
3256  * @reply: reply message frame(lower 32bit addr)
3257  * Context: interrupt time.
3258  *
3259  * This is the sas iounit control completion routine.
3260  * This code is part of the code to initiate the device removal
3261  * handshake protocol with controller firmware.
3262  *
3263  * Return 1 meaning mf should be freed from _base_interrupt
3264  *        0 means the mf is freed from this function.
3265  */
3266 static u8
3267 _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3268         u8 msix_index, u32 reply)
3269 {
3270         Mpi2SasIoUnitControlReply_t *mpi_reply =
3271             mpt3sas_base_get_reply_virt_addr(ioc, reply);
3272
3273         if (likely(mpi_reply)) {
3274                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3275                 "sc_complete:handle(0x%04x), (open) "
3276                 "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
3277                 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
3278                 le16_to_cpu(mpi_reply->IOCStatus),
3279                 le32_to_cpu(mpi_reply->IOCLogInfo)));
3280         } else {
3281                 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3282                     ioc->name, __FILE__, __LINE__, __func__);
3283         }
3284         return 1;
3285 }
3286
3287 /**
3288  * _scsih_tm_tr_volume_send - send target reset request for volumes
3289  * @ioc: per adapter object
3290  * @handle: device handle
3291  * Context: interrupt time.
3292  *
3293  * This is designed to send muliple task management request at the same
3294  * time to the fifo. If the fifo is full, we will append the request,
3295  * and process it in a future completion.
3296  */
3297 static void
3298 _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3299 {
3300         Mpi2SCSITaskManagementRequest_t *mpi_request;
3301         u16 smid;
3302         struct _tr_list *delayed_tr;
3303
3304         if (ioc->shost_recovery || ioc->remove_host ||
3305             ioc->pci_error_recovery) {
3306                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3307                         "%s: host reset in progress!\n",
3308                         __func__, ioc->name));
3309                 return;
3310         }
3311
3312         smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx);
3313         if (!smid) {
3314                 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3315                 if (!delayed_tr)
3316                         return;
3317                 INIT_LIST_HEAD(&delayed_tr->list);
3318                 delayed_tr->handle = handle;
3319                 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
3320                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3321                     "DELAYED:tr:handle(0x%04x), (open)\n",
3322                     ioc->name, handle));
3323                 return;
3324         }
3325
3326         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3327                 "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
3328                 ioc->name, handle, smid,
3329             ioc->tm_tr_volume_cb_idx));
3330         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3331         memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
3332         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3333         mpi_request->DevHandle = cpu_to_le16(handle);
3334         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3335         mpt3sas_base_put_smid_hi_priority(ioc, smid);
3336 }
3337
3338 /**
3339  * _scsih_tm_volume_tr_complete - target reset completion
3340  * @ioc: per adapter object
3341  * @smid: system request message index
3342  * @msix_index: MSIX table index supplied by the OS
3343  * @reply: reply message frame(lower 32bit addr)
3344  * Context: interrupt time.
3345  *
3346  * Return 1 meaning mf should be freed from _base_interrupt
3347  *        0 means the mf is freed from this function.
3348  */
3349 static u8
3350 _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid,
3351         u8 msix_index, u32 reply)
3352 {
3353         u16 handle;
3354         Mpi2SCSITaskManagementRequest_t *mpi_request_tm;
3355         Mpi2SCSITaskManagementReply_t *mpi_reply =
3356             mpt3sas_base_get_reply_virt_addr(ioc, reply);
3357
3358         if (ioc->shost_recovery || ioc->remove_host ||
3359             ioc->pci_error_recovery) {
3360                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3361                         "%s: host reset in progress!\n",
3362                         __func__, ioc->name));
3363                 return 1;
3364         }
3365         if (unlikely(!mpi_reply)) {
3366                 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
3367                     ioc->name, __FILE__, __LINE__, __func__);
3368                 return 1;
3369         }
3370
3371         mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
3372         handle = le16_to_cpu(mpi_request_tm->DevHandle);
3373         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
3374                 dewtprintk(ioc, pr_err(MPT3SAS_FMT
3375                         "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
3376                         ioc->name, handle,
3377                     le16_to_cpu(mpi_reply->DevHandle), smid));
3378                 return 0;
3379         }
3380
3381         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3382             "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
3383             "loginfo(0x%08x), completed(%d)\n", ioc->name,
3384             handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
3385             le32_to_cpu(mpi_reply->IOCLogInfo),
3386             le32_to_cpu(mpi_reply->TerminationCount)));
3387
3388         return _scsih_check_for_pending_tm(ioc, smid);
3389 }
3390
3391
3392 /**
3393  * _scsih_check_for_pending_tm - check for pending task management
3394  * @ioc: per adapter object
3395  * @smid: system request message index
3396  *
3397  * This will check delayed target reset list, and feed the
3398  * next reqeust.
3399  *
3400  * Return 1 meaning mf should be freed from _base_interrupt
3401  *        0 means the mf is freed from this function.
3402  */
3403 static u8
3404 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid)
3405 {
3406         struct _tr_list *delayed_tr;
3407
3408         if (!list_empty(&ioc->delayed_tr_volume_list)) {
3409                 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next,
3410                     struct _tr_list, list);
3411                 mpt3sas_base_free_smid(ioc, smid);
3412                 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle);
3413                 list_del(&delayed_tr->list);
3414                 kfree(delayed_tr);
3415                 return 0;
3416         }
3417
3418         if (!list_empty(&ioc->delayed_tr_list)) {
3419                 delayed_tr = list_entry(ioc->delayed_tr_list.next,
3420                     struct _tr_list, list);
3421                 mpt3sas_base_free_smid(ioc, smid);
3422                 _scsih_tm_tr_send(ioc, delayed_tr->handle);
3423                 list_del(&delayed_tr->list);
3424                 kfree(delayed_tr);
3425                 return 0;
3426         }
3427
3428         return 1;
3429 }
3430
3431 /**
3432  * _scsih_check_topo_delete_events - sanity check on topo events
3433  * @ioc: per adapter object
3434  * @event_data: the event data payload
3435  *
3436  * This routine added to better handle cable breaker.
3437  *
3438  * This handles the case where driver receives multiple expander
3439  * add and delete events in a single shot.  When there is a delete event
3440  * the routine will void any pending add events waiting in the event queue.
3441  *
3442  * Return nothing.
3443  */
3444 static void
3445 _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc,
3446         Mpi2EventDataSasTopologyChangeList_t *event_data)
3447 {
3448         struct fw_event_work *fw_event;
3449         Mpi2EventDataSasTopologyChangeList_t *local_event_data;
3450         u16 expander_handle;
3451         struct _sas_node *sas_expander;
3452         unsigned long flags;
3453         int i, reason_code;
3454         u16 handle;
3455
3456         for (i = 0 ; i < event_data->NumEntries; i++) {
3457                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3458                 if (!handle)
3459                         continue;
3460                 reason_code = event_data->PHY[i].PhyStatus &
3461                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3462                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)
3463                         _scsih_tm_tr_send(ioc, handle);
3464         }
3465
3466         expander_handle = le16_to_cpu(event_data->ExpanderDevHandle);
3467         if (expander_handle < ioc->sas_hba.num_phys) {
3468                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3469                 return;
3470         }
3471         if (event_data->ExpStatus ==
3472             MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
3473                 /* put expander attached devices into blocking state */
3474                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3475                 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
3476                     expander_handle);
3477                 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
3478                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
3479                 do {
3480                         handle = find_first_bit(ioc->blocking_handles,
3481                             ioc->facts.MaxDevHandle);
3482                         if (handle < ioc->facts.MaxDevHandle)
3483                                 _scsih_block_io_device(ioc, handle);
3484                 } while (test_and_clear_bit(handle, ioc->blocking_handles));
3485         } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
3486                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
3487
3488         if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
3489                 return;
3490
3491         /* mark ignore flag for pending events */
3492         spin_lock_irqsave(&ioc->fw_event_lock, flags);
3493         list_for_each_entry(fw_event, &ioc->fw_event_list, list) {
3494                 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST ||
3495                     fw_event->ignore)
3496                         continue;
3497                 local_event_data = (Mpi2EventDataSasTopologyChangeList_t *)
3498                                    fw_event->event_data;
3499                 if (local_event_data->ExpStatus ==
3500                     MPI2_EVENT_SAS_TOPO_ES_ADDED ||
3501                     local_event_data->ExpStatus ==
3502                     MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
3503                         if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
3504                             expander_handle) {
3505                                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3506                                     "setting ignoring flag\n", ioc->name));
3507                                 fw_event->ignore = 1;
3508                         }
3509                 }
3510         }
3511         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
3512 }
3513
3514 /**
3515  * _scsih_set_volume_delete_flag - setting volume delete flag
3516  * @ioc: per adapter object
3517  * @handle: device handle
3518  *
3519  * This returns nothing.
3520  */
3521 static void
3522 _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle)
3523 {
3524         struct _raid_device *raid_device;
3525         struct MPT3SAS_TARGET *sas_target_priv_data;
3526         unsigned long flags;
3527
3528         spin_lock_irqsave(&ioc->raid_device_lock, flags);
3529         raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
3530         if (raid_device && raid_device->starget &&
3531             raid_device->starget->hostdata) {
3532                 sas_target_priv_data =
3533                     raid_device->starget->hostdata;
3534                 sas_target_priv_data->deleted = 1;
3535                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
3536                     "setting delete flag: handle(0x%04x), "
3537                     "wwid(0x%016llx)\n", ioc->name, handle,
3538                     (unsigned long long) raid_device->wwid));
3539         }
3540         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
3541 }
3542
3543 /**
3544  * _scsih_set_volume_handle_for_tr - set handle for target reset to volume
3545  * @handle: input handle
3546  * @a: handle for volume a
3547  * @b: handle for volume b
3548  *
3549  * IR firmware only supports two raid volumes.  The purpose of this
3550  * routine is to set the volume handle in either a or b. When the given
3551  * input handle is non-zero, or when a and b have not been set before.
3552  */
3553 static void
3554 _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b)
3555 {
3556         if (!handle || handle == *a || handle == *b)
3557                 return;
3558         if (!*a)
3559                 *a = handle;
3560         else if (!*b)
3561                 *b = handle;
3562 }
3563
3564 /**
3565  * _scsih_check_ir_config_unhide_events - check for UNHIDE events
3566  * @ioc: per adapter object
3567  * @event_data: the event data payload
3568  * Context: interrupt time.
3569  *
3570  * This routine will send target reset to volume, followed by target
3571  * resets to the PDs. This is called when a PD has been removed, or
3572  * volume has been deleted or removed. When the target reset is sent
3573  * to volume, the PD target resets need to be queued to start upon
3574  * completion of the volume target reset.
3575  *
3576  * Return nothing.
3577  */
3578 static void
3579 _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc,
3580         Mpi2EventDataIrConfigChangeList_t *event_data)
3581 {
3582         Mpi2EventIrConfigElement_t *element;
3583         int i;
3584         u16 handle, volume_handle, a, b;
3585         struct _tr_list *delayed_tr;
3586
3587         a = 0;
3588         b = 0;
3589
3590         if (ioc->is_warpdrive)
3591                 return;
3592
3593         /* Volume Resets for Deleted or Removed */
3594         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3595         for (i = 0; i < event_data->NumElements; i++, element++) {
3596                 if (le32_to_cpu(event_data->Flags) &
3597                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
3598                         continue;
3599                 if (element->ReasonCode ==
3600                     MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED ||
3601                     element->ReasonCode ==
3602                     MPI2_EVENT_IR_CHANGE_RC_REMOVED) {
3603                         volume_handle = le16_to_cpu(element->VolDevHandle);
3604                         _scsih_set_volume_delete_flag(ioc, volume_handle);
3605                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3606                 }
3607         }
3608
3609         /* Volume Resets for UNHIDE events */
3610         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3611         for (i = 0; i < event_data->NumElements; i++, element++) {
3612                 if (le32_to_cpu(event_data->Flags) &
3613                     MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
3614                         continue;
3615                 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) {
3616                         volume_handle = le16_to_cpu(element->VolDevHandle);
3617                         _scsih_set_volume_handle_for_tr(volume_handle, &a, &b);
3618                 }
3619         }
3620
3621         if (a)
3622                 _scsih_tm_tr_volume_send(ioc, a);
3623         if (b)
3624                 _scsih_tm_tr_volume_send(ioc, b);
3625
3626         /* PD target resets */
3627         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
3628         for (i = 0; i < event_data->NumElements; i++, element++) {
3629                 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE)
3630                         continue;
3631                 handle = le16_to_cpu(element->PhysDiskDevHandle);
3632                 volume_handle = le16_to_cpu(element->VolDevHandle);
3633                 clear_bit(handle, ioc->pd_handles);
3634                 if (!volume_handle)
3635                         _scsih_tm_tr_send(ioc, handle);
3636                 else if (volume_handle == a || volume_handle == b) {
3637                         delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC);
3638                         BUG_ON(!delayed_tr);
3639                         INIT_LIST_HEAD(&delayed_tr->list);
3640                         delayed_tr->handle = handle;
3641                         list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
3642                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
3643                             "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
3644                             handle));
3645                 } else
3646                         _scsih_tm_tr_send(ioc, handle);
3647         }
3648 }
3649
3650
3651 /**
3652  * _scsih_check_volume_delete_events - set delete flag for volumes
3653  * @ioc: per adapter object
3654  * @event_data: the event data payload
3655  * Context: interrupt time.
3656  *
3657  * This will handle the case when the cable connected to entire volume is
3658  * pulled. We will take care of setting the deleted flag so normal IO will
3659  * not be sent.
3660  *
3661  * Return nothing.
3662  */
3663 static void
3664 _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
3665         Mpi2EventDataIrVolume_t *event_data)
3666 {
3667         u32 state;
3668
3669         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
3670                 return;
3671         state = le32_to_cpu(event_data->NewValue);
3672         if (state == MPI2_RAID_VOL_STATE_MISSING || state ==
3673             MPI2_RAID_VOL_STATE_FAILED)
3674                 _scsih_set_volume_delete_flag(ioc,
3675                     le16_to_cpu(event_data->VolDevHandle));
3676 }
3677
3678 /**
3679  * _scsih_temp_threshold_events - display temperature threshold exceeded events
3680  * @ioc: per adapter object
3681  * @event_data: the temp threshold event data
3682  * Context: interrupt time.
3683  *
3684  * Return nothing.
3685  */
3686 static void
3687 _scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
3688         Mpi2EventDataTemperature_t *event_data)
3689 {
3690         if (ioc->temp_sensors_count >= event_data->SensorNum) {
3691                 pr_err(MPT3SAS_FMT "Temperature Threshold flags %s%s%s%s"
3692                   " exceeded for Sensor: %d !!!\n", ioc->name,
3693                   ((le16_to_cpu(event_data->Status) & 0x1) == 1) ? "0 " : " ",
3694                   ((le16_to_cpu(event_data->Status) & 0x2) == 2) ? "1 " : " ",
3695                   ((le16_to_cpu(event_data->Status) & 0x4) == 4) ? "2 " : " ",
3696                   ((le16_to_cpu(event_data->Status) & 0x8) == 8) ? "3 " : " ",
3697                   event_data->SensorNum);
3698                 pr_err(MPT3SAS_FMT "Current Temp In Celsius: %d\n",
3699                         ioc->name, event_data->CurrentTemperature);
3700         }
3701 }
3702
3703 /**
3704  * _scsih_flush_running_cmds - completing outstanding commands.
3705  * @ioc: per adapter object
3706  *
3707  * The flushing out of all pending scmd commands following host reset,
3708  * where all IO is dropped to the floor.
3709  *
3710  * Return nothing.
3711  */
3712 static void
3713 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
3714 {
3715         struct scsi_cmnd *scmd;
3716         u16 smid;
3717         u16 count = 0;
3718
3719         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3720                 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3721                 if (!scmd)
3722                         continue;
3723                 count++;
3724                 mpt3sas_base_free_smid(ioc, smid);
3725                 scsi_dma_unmap(scmd);
3726                 if (ioc->pci_error_recovery)
3727                         scmd->result = DID_NO_CONNECT << 16;
3728                 else
3729                         scmd->result = DID_RESET << 16;
3730                 scmd->scsi_done(scmd);
3731         }
3732         dtmprintk(ioc, pr_info(MPT3SAS_FMT "completing %d cmds\n",
3733             ioc->name, count));
3734 }
3735
3736 /**
3737  * _scsih_setup_eedp - setup MPI request for EEDP transfer
3738  * @ioc: per adapter object
3739  * @scmd: pointer to scsi command object
3740  * @mpi_request: pointer to the SCSI_IO reqest message frame
3741  *
3742  * Supporting protection 1 and 3.
3743  *
3744  * Returns nothing
3745  */
3746 static void
3747 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3748         Mpi2SCSIIORequest_t *mpi_request)
3749 {
3750         u16 eedp_flags;
3751         unsigned char prot_op = scsi_get_prot_op(scmd);
3752         unsigned char prot_type = scsi_get_prot_type(scmd);
3753         Mpi25SCSIIORequest_t *mpi_request_3v =
3754            (Mpi25SCSIIORequest_t *)mpi_request;
3755
3756         if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
3757                 return;
3758
3759         if (prot_op ==  SCSI_PROT_READ_STRIP)
3760                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
3761         else if (prot_op ==  SCSI_PROT_WRITE_INSERT)
3762                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
3763         else
3764                 return;
3765
3766         switch (prot_type) {
3767         case SCSI_PROT_DIF_TYPE1:
3768         case SCSI_PROT_DIF_TYPE2:
3769
3770                 /*
3771                 * enable ref/guard checking
3772                 * auto increment ref tag
3773                 */
3774                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
3775                     MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
3776                     MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3777                 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
3778                     cpu_to_be32(scsi_get_lba(scmd));
3779                 break;
3780
3781         case SCSI_PROT_DIF_TYPE3:
3782
3783                 /*
3784                 * enable guard checking
3785                 */
3786                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3787
3788                 break;
3789         }
3790
3791         mpi_request_3v->EEDPBlockSize =
3792             cpu_to_le16(scmd->device->sector_size);
3793         mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
3794 }
3795
3796 /**
3797  * _scsih_eedp_error_handling - return sense code for EEDP errors
3798  * @scmd: pointer to scsi command object
3799  * @ioc_status: ioc status
3800  *
3801  * Returns nothing
3802  */
3803 static void
3804 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
3805 {
3806         u8 ascq;
3807
3808         switch (ioc_status) {
3809         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
3810                 ascq = 0x01;
3811                 break;
3812         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
3813                 ascq = 0x02;
3814                 break;
3815         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
3816                 ascq = 0x03;
3817                 break;
3818         default:
3819                 ascq = 0x00;
3820                 break;
3821         }
3822         scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10,
3823             ascq);
3824         scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
3825             SAM_STAT_CHECK_CONDITION;
3826 }
3827
3828
3829
3830 /**
3831  * scsih_qcmd - main scsi request entry point
3832  * @scmd: pointer to scsi command object
3833  * @done: function pointer to be invoked on completion
3834  *
3835  * The callback index is set inside `ioc->scsi_io_cb_idx`.
3836  *
3837  * Returns 0 on success.  If there's a failure, return either:
3838  * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
3839  * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
3840  */
3841 int
3842 scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
3843 {
3844         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3845         struct MPT3SAS_DEVICE *sas_device_priv_data;
3846         struct MPT3SAS_TARGET *sas_target_priv_data;
3847         struct _raid_device *raid_device;
3848         Mpi2SCSIIORequest_t *mpi_request;
3849         u32 mpi_control;
3850         u16 smid;
3851         u16 handle;
3852
3853         if (ioc->logging_level & MPT_DEBUG_SCSI)
3854                 scsi_print_command(scmd);
3855
3856         sas_device_priv_data = scmd->device->hostdata;
3857         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
3858                 scmd->result = DID_NO_CONNECT << 16;
3859                 scmd->scsi_done(scmd);
3860                 return 0;
3861         }
3862
3863         if (ioc->pci_error_recovery || ioc->remove_host) {
3864                 scmd->result = DID_NO_CONNECT << 16;
3865                 scmd->scsi_done(scmd);
3866                 return 0;
3867         }
3868
3869         sas_target_priv_data = sas_device_priv_data->sas_target;
3870
3871         /* invalid device handle */
3872         handle = sas_target_priv_data->handle;
3873         if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
3874                 scmd->result = DID_NO_CONNECT << 16;
3875                 scmd->scsi_done(scmd);
3876                 return 0;
3877         }
3878
3879
3880         /* host recovery or link resets sent via IOCTLs */
3881         if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
3882                 return SCSI_MLQUEUE_HOST_BUSY;
3883
3884         /* device has been deleted */
3885         else if (sas_target_priv_data->deleted) {
3886                 scmd->result = DID_NO_CONNECT << 16;
3887                 scmd->scsi_done(scmd);
3888                 return 0;
3889         /* device busy with task managment */
3890         } else if (sas_target_priv_data->tm_busy ||
3891             sas_device_priv_data->block)
3892                 return SCSI_MLQUEUE_DEVICE_BUSY;
3893
3894         if (scmd->sc_data_direction == DMA_FROM_DEVICE)
3895                 mpi_control = MPI2_SCSIIO_CONTROL_READ;
3896         else if (scmd->sc_data_direction == DMA_TO_DEVICE)
3897                 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
3898         else
3899                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
3900
3901         /* set tags */
3902         mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
3903
3904         /* Make sure Device is not raid volume.
3905          * We do not expose raid functionality to upper layer for warpdrive.
3906          */
3907         if (!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev)
3908             && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
3909                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
3910
3911         smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
3912         if (!smid) {
3913                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
3914                     ioc->name, __func__);
3915                 goto out;
3916         }
3917         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
3918         memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
3919         _scsih_setup_eedp(ioc, scmd, mpi_request);
3920
3921         if (scmd->cmd_len == 32)
3922                 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
3923         mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
3924         if (sas_device_priv_data->sas_target->flags &
3925             MPT_TARGET_FLAGS_RAID_COMPONENT)
3926                 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
3927         else
3928                 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
3929         mpi_request->DevHandle = cpu_to_le16(handle);
3930         mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
3931         mpi_request->Control = cpu_to_le32(mpi_control);
3932         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
3933         mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
3934         mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
3935         mpi_request->SenseBufferLowAddress =
3936             mpt3sas_base_get_sense_buffer_dma(ioc, smid);
3937         mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
3938         int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
3939             mpi_request->LUN);
3940         memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
3941
3942         if (mpi_request->DataLength) {
3943                 if (ioc->build_sg_scmd(ioc, scmd, smid)) {
3944                         mpt3sas_base_free_smid(ioc, smid);
3945                         goto out;
3946                 }
3947         } else
3948                 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
3949
3950         raid_device = sas_target_priv_data->raid_device;
3951         if (raid_device && raid_device->direct_io_enabled)
3952                 mpt3sas_setup_direct_io(ioc, scmd, raid_device, mpi_request,
3953                     smid);
3954
3955         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) {
3956                 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) {
3957                         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len |
3958                             MPI25_SCSIIO_IOFLAGS_FAST_PATH);
3959                         mpt3sas_base_put_smid_fast_path(ioc, smid, handle);
3960                 } else
3961                         mpt3sas_base_put_smid_scsi_io(ioc, smid,
3962                             le16_to_cpu(mpi_request->DevHandle));
3963         } else
3964                 mpt3sas_base_put_smid_default(ioc, smid);
3965         return 0;
3966
3967  out:
3968         return SCSI_MLQUEUE_HOST_BUSY;
3969 }
3970
3971 /**
3972  * _scsih_normalize_sense - normalize descriptor and fixed format sense data
3973  * @sense_buffer: sense data returned by target
3974  * @data: normalized skey/asc/ascq
3975  *
3976  * Return nothing.
3977  */
3978 static void
3979 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
3980 {
3981         if ((sense_buffer[0] & 0x7F) >= 0x72) {
3982                 /* descriptor format */
3983                 data->skey = sense_buffer[1] & 0x0F;
3984                 data->asc = sense_buffer[2];
3985                 data->ascq = sense_buffer[3];
3986         } else {
3987                 /* fixed format */
3988                 data->skey = sense_buffer[2] & 0x0F;
3989                 data->asc = sense_buffer[12];
3990                 data->ascq = sense_buffer[13];
3991         }
3992 }
3993
3994 /**
3995  * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
3996  * @ioc: per adapter object
3997  * @scmd: pointer to scsi command object
3998  * @mpi_reply: reply mf payload returned from firmware
3999  *
4000  * scsi_status - SCSI Status code returned from target device
4001  * scsi_state - state info associated with SCSI_IO determined by ioc
4002  * ioc_status - ioc supplied status info
4003  *
4004  * Return nothing.
4005  */
4006 static void
4007 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4008         Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
4009 {
4010         u32 response_info;
4011         u8 *response_bytes;
4012         u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
4013             MPI2_IOCSTATUS_MASK;
4014         u8 scsi_state = mpi_reply->SCSIState;
4015         u8 scsi_status = mpi_reply->SCSIStatus;
4016         char *desc_ioc_state = NULL;
4017         char *desc_scsi_status = NULL;
4018         char *desc_scsi_state = ioc->tmp_string;
4019         u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4020         struct _sas_device *sas_device = NULL;
4021         struct scsi_target *starget = scmd->device->sdev_target;
4022         struct MPT3SAS_TARGET *priv_target = starget->hostdata;
4023         char *device_str = NULL;
4024
4025         if (!priv_target)
4026                 return;
4027         if (ioc->hide_ir_msg)
4028                 device_str = "WarpDrive";
4029         else
4030                 device_str = "volume";
4031
4032         if (log_info == 0x31170000)
4033                 return;
4034
4035         switch (ioc_status) {
4036         case MPI2_IOCSTATUS_SUCCESS:
4037                 desc_ioc_state = "success";
4038                 break;
4039         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4040                 desc_ioc_state = "invalid function";
4041                 break;
4042         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4043                 desc_ioc_state = "scsi recovered error";
4044                 break;
4045         case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
4046                 desc_ioc_state = "scsi invalid dev handle";
4047                 break;
4048         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4049                 desc_ioc_state = "scsi device not there";
4050                 break;
4051         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4052                 desc_ioc_state = "scsi data overrun";
4053                 break;
4054         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4055                 desc_ioc_state = "scsi data underrun";
4056                 break;
4057         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4058                 desc_ioc_state = "scsi io data error";
4059                 break;
4060         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4061                 desc_ioc_state = "scsi protocol error";
4062                 break;
4063         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4064                 desc_ioc_state = "scsi task terminated";
4065                 break;
4066         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4067                 desc_ioc_state = "scsi residual mismatch";
4068                 break;
4069         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4070                 desc_ioc_state = "scsi task mgmt failed";
4071                 break;
4072         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4073                 desc_ioc_state = "scsi ioc terminated";
4074                 break;
4075         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4076                 desc_ioc_state = "scsi ext terminated";
4077                 break;
4078         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4079                 desc_ioc_state = "eedp guard error";
4080                 break;
4081         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4082                 desc_ioc_state = "eedp ref tag error";
4083                 break;
4084         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4085                 desc_ioc_state = "eedp app tag error";
4086                 break;
4087         default:
4088                 desc_ioc_state = "unknown";
4089                 break;
4090         }
4091
4092         switch (scsi_status) {
4093         case MPI2_SCSI_STATUS_GOOD:
4094                 desc_scsi_status = "good";
4095                 break;
4096         case MPI2_SCSI_STATUS_CHECK_CONDITION:
4097                 desc_scsi_status = "check condition";
4098                 break;
4099         case MPI2_SCSI_STATUS_CONDITION_MET:
4100                 desc_scsi_status = "condition met";
4101                 break;
4102         case MPI2_SCSI_STATUS_BUSY:
4103                 desc_scsi_status = "busy";
4104                 break;
4105         case MPI2_SCSI_STATUS_INTERMEDIATE:
4106                 desc_scsi_status = "intermediate";
4107                 break;
4108         case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
4109                 desc_scsi_status = "intermediate condmet";
4110                 break;
4111         case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
4112                 desc_scsi_status = "reservation conflict";
4113                 break;
4114         case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
4115                 desc_scsi_status = "command terminated";
4116                 break;
4117         case MPI2_SCSI_STATUS_TASK_SET_FULL:
4118                 desc_scsi_status = "task set full";
4119                 break;
4120         case MPI2_SCSI_STATUS_ACA_ACTIVE:
4121                 desc_scsi_status = "aca active";
4122                 break;
4123         case MPI2_SCSI_STATUS_TASK_ABORTED:
4124                 desc_scsi_status = "task aborted";
4125                 break;
4126         default:
4127                 desc_scsi_status = "unknown";
4128                 break;
4129         }
4130
4131         desc_scsi_state[0] = '\0';
4132         if (!scsi_state)
4133                 desc_scsi_state = " ";
4134         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4135                 strcat(desc_scsi_state, "response info ");
4136         if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4137                 strcat(desc_scsi_state, "state terminated ");
4138         if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
4139                 strcat(desc_scsi_state, "no status ");
4140         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
4141                 strcat(desc_scsi_state, "autosense failed ");
4142         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
4143                 strcat(desc_scsi_state, "autosense valid ");
4144
4145         scsi_print_command(scmd);
4146
4147         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
4148                 pr_warn(MPT3SAS_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
4149                     device_str, (unsigned long long)priv_target->sas_address);
4150         } else {
4151                 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
4152                 if (sas_device) {
4153                         pr_warn(MPT3SAS_FMT
4154                                 "\tsas_address(0x%016llx), phy(%d)\n",
4155                                 ioc->name, (unsigned long long)
4156                             sas_device->sas_address, sas_device->phy);
4157                         if (sas_device->enclosure_handle != 0)
4158                                 pr_warn(MPT3SAS_FMT
4159                                   "\tenclosure_logical_id(0x%016llx),"
4160                                   "slot(%d)\n", ioc->name,
4161                                   (unsigned long long)
4162                                   sas_device->enclosure_logical_id,
4163                                   sas_device->slot);
4164                         if (sas_device->connector_name[0])
4165                                 pr_warn(MPT3SAS_FMT
4166                                   "\tenclosure level(0x%04x),"
4167                                   " connector name( %s)\n", ioc->name,
4168                                   sas_device->enclosure_level,
4169                                   sas_device->connector_name);
4170
4171                         sas_device_put(sas_device);
4172                 }
4173         }
4174
4175         pr_warn(MPT3SAS_FMT
4176                 "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
4177                 ioc->name, le16_to_cpu(mpi_reply->DevHandle),
4178             desc_ioc_state, ioc_status, smid);
4179         pr_warn(MPT3SAS_FMT
4180                 "\trequest_len(%d), underflow(%d), resid(%d)\n",
4181                 ioc->name, scsi_bufflen(scmd), scmd->underflow,
4182             scsi_get_resid(scmd));
4183         pr_warn(MPT3SAS_FMT
4184                 "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
4185                 ioc->name, le16_to_cpu(mpi_reply->TaskTag),
4186             le32_to_cpu(mpi_reply->TransferCount), scmd->result);
4187         pr_warn(MPT3SAS_FMT
4188                 "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
4189                 ioc->name, desc_scsi_status,
4190             scsi_status, desc_scsi_state, scsi_state);
4191
4192         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4193                 struct sense_info data;
4194                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4195                 pr_warn(MPT3SAS_FMT
4196                         "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
4197                         ioc->name, data.skey,
4198                     data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
4199         }
4200
4201         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
4202                 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
4203                 response_bytes = (u8 *)&response_info;
4204                 _scsih_response_code(ioc, response_bytes[0]);
4205         }
4206 }
4207
4208 /**
4209  * _scsih_turn_on_pfa_led - illuminate PFA LED
4210  * @ioc: per adapter object
4211  * @handle: device handle
4212  * Context: process
4213  *
4214  * Return nothing.
4215  */
4216 static void
4217 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4218 {
4219         Mpi2SepReply_t mpi_reply;
4220         Mpi2SepRequest_t mpi_request;
4221         struct _sas_device *sas_device;
4222
4223         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
4224         if (!sas_device)
4225                 return;
4226
4227         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
4228         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
4229         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
4230         mpi_request.SlotStatus =
4231             cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
4232         mpi_request.DevHandle = cpu_to_le16(handle);
4233         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
4234         if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4235             &mpi_request)) != 0) {
4236                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
4237                 __FILE__, __LINE__, __func__);
4238                 goto out;
4239         }
4240         sas_device->pfa_led_on = 1;
4241
4242         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
4243                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
4244                         "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
4245                         ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
4246                     le32_to_cpu(mpi_reply.IOCLogInfo)));
4247                 goto out;
4248         }
4249 out:
4250         sas_device_put(sas_device);
4251 }
4252
4253 /**
4254  * _scsih_turn_off_pfa_led - turn off Fault LED
4255  * @ioc: per adapter object
4256  * @sas_device: sas device whose PFA LED has to turned off
4257  * Context: process
4258  *
4259  * Return nothing.
4260  */
4261 static void
4262 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
4263         struct _sas_device *sas_device)
4264 {
4265         Mpi2SepReply_t mpi_reply;
4266         Mpi2SepRequest_t mpi_request;
4267
4268         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
4269         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
4270         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
4271         mpi_request.SlotStatus = 0;
4272         mpi_request.Slot = cpu_to_le16(sas_device->slot);
4273         mpi_request.DevHandle = 0;
4274         mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle);
4275         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS;
4276         if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4277                 &mpi_request)) != 0) {
4278                 printk(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
4279                 __FILE__, __LINE__, __func__);
4280                 return;
4281         }
4282
4283         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
4284                 dewtprintk(ioc, printk(MPT3SAS_FMT
4285                  "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
4286                  ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
4287                  le32_to_cpu(mpi_reply.IOCLogInfo)));
4288                 return;
4289         }
4290 }
4291
4292 /**
4293  * _scsih_send_event_to_turn_on_pfa_led - fire delayed event
4294  * @ioc: per adapter object
4295  * @handle: device handle
4296  * Context: interrupt.
4297  *
4298  * Return nothing.
4299  */
4300 static void
4301 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4302 {
4303         struct fw_event_work *fw_event;
4304
4305         fw_event = alloc_fw_event_work(0);
4306         if (!fw_event)
4307                 return;
4308         fw_event->event = MPT3SAS_TURN_ON_PFA_LED;
4309         fw_event->device_handle = handle;
4310         fw_event->ioc = ioc;
4311         _scsih_fw_event_add(ioc, fw_event);
4312         fw_event_work_put(fw_event);
4313 }
4314
4315 /**
4316  * _scsih_smart_predicted_fault - process smart errors
4317  * @ioc: per adapter object
4318  * @handle: device handle
4319  * Context: interrupt.
4320  *
4321  * Return nothing.
4322  */
4323 static void
4324 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4325 {
4326         struct scsi_target *starget;
4327         struct MPT3SAS_TARGET *sas_target_priv_data;
4328         Mpi2EventNotificationReply_t *event_reply;
4329         Mpi2EventDataSasDeviceStatusChange_t *event_data;
4330         struct _sas_device *sas_device;
4331         ssize_t sz;
4332         unsigned long flags;
4333
4334         /* only handle non-raid devices */
4335         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4336         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
4337         if (!sas_device)
4338                 goto out_unlock;
4339
4340         starget = sas_device->starget;
4341         sas_target_priv_data = starget->hostdata;
4342
4343         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
4344            ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)))
4345                 goto out_unlock;
4346
4347         if (sas_device->enclosure_handle != 0)
4348                 starget_printk(KERN_INFO, starget, "predicted fault, "
4349                         "enclosure logical id(0x%016llx), slot(%d)\n",
4350                         (unsigned long long)sas_device->enclosure_logical_id,
4351                         sas_device->slot);
4352         if (sas_device->connector_name[0] != '\0')
4353                 starget_printk(KERN_WARNING, starget, "predicted fault, "
4354                         "enclosure level(0x%04x), connector name( %s)\n",
4355                         sas_device->enclosure_level,
4356                         sas_device->connector_name);
4357         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4358
4359         if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
4360                 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
4361
4362         /* insert into event log */
4363         sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
4364              sizeof(Mpi2EventDataSasDeviceStatusChange_t);
4365         event_reply = kzalloc(sz, GFP_KERNEL);
4366         if (!event_reply) {
4367                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4368                     ioc->name, __FILE__, __LINE__, __func__);
4369                 goto out;
4370         }
4371
4372         event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
4373         event_reply->Event =
4374             cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
4375         event_reply->MsgLength = sz/4;
4376         event_reply->EventDataLength =
4377             cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
4378         event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
4379             event_reply->EventData;
4380         event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
4381         event_data->ASC = 0x5D;
4382         event_data->DevHandle = cpu_to_le16(handle);
4383         event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
4384         mpt3sas_ctl_add_to_event_log(ioc, event_reply);
4385         kfree(event_reply);
4386 out:
4387         if (sas_device)
4388                 sas_device_put(sas_device);
4389         return;
4390
4391 out_unlock:
4392         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4393         goto out;
4394 }
4395
4396 /**
4397  * _scsih_io_done - scsi request callback
4398  * @ioc: per adapter object
4399  * @smid: system request message index
4400  * @msix_index: MSIX table index supplied by the OS
4401  * @reply: reply message frame(lower 32bit addr)
4402  *
4403  * Callback handler when using _scsih_qcmd.
4404  *
4405  * Return 1 meaning mf should be freed from _base_interrupt
4406  *        0 means the mf is freed from this function.
4407  */
4408 static u8
4409 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4410 {
4411         Mpi2SCSIIORequest_t *mpi_request;
4412         Mpi2SCSIIOReply_t *mpi_reply;
4413         struct scsi_cmnd *scmd;
4414         u16 ioc_status;
4415         u32 xfer_cnt;
4416         u8 scsi_state;
4417         u8 scsi_status;
4418         u32 log_info;
4419         struct MPT3SAS_DEVICE *sas_device_priv_data;
4420         u32 response_code = 0;
4421         unsigned long flags;
4422
4423         mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
4424         scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
4425         if (scmd == NULL)
4426                 return 1;
4427
4428         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4429
4430         if (mpi_reply == NULL) {
4431                 scmd->result = DID_OK << 16;
4432                 goto out;
4433         }
4434
4435         sas_device_priv_data = scmd->device->hostdata;
4436         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
4437              sas_device_priv_data->sas_target->deleted) {
4438                 scmd->result = DID_NO_CONNECT << 16;
4439                 goto out;
4440         }
4441         ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
4442
4443         /*
4444          * WARPDRIVE: If direct_io is set then it is directIO,
4445          * the failed direct I/O should be redirected to volume
4446          */
4447         if (mpt3sas_scsi_direct_io_get(ioc, smid) &&
4448              ((ioc_status & MPI2_IOCSTATUS_MASK)
4449               != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
4450                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4451                 ioc->scsi_lookup[smid - 1].scmd = scmd;
4452                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4453                 mpt3sas_scsi_direct_io_set(ioc, smid, 0);
4454                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4455                 mpi_request->DevHandle =
4456                     cpu_to_le16(sas_device_priv_data->sas_target->handle);
4457                 mpt3sas_base_put_smid_scsi_io(ioc, smid,
4458                     sas_device_priv_data->sas_target->handle);
4459                 return 0;
4460         }
4461         /* turning off TLR */
4462         scsi_state = mpi_reply->SCSIState;
4463         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4464                 response_code =
4465                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
4466         if (!sas_device_priv_data->tlr_snoop_check) {
4467                 sas_device_priv_data->tlr_snoop_check++;
4468                 if (!ioc->is_warpdrive &&
4469                     !scsih_is_raid(&scmd->device->sdev_gendev) &&
4470                     sas_is_tlr_enabled(scmd->device) &&
4471                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
4472                         sas_disable_tlr(scmd->device);
4473                         sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
4474                 }
4475         }
4476
4477         xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
4478         scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
4479         if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
4480                 log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
4481         else
4482                 log_info = 0;
4483         ioc_status &= MPI2_IOCSTATUS_MASK;
4484         scsi_status = mpi_reply->SCSIStatus;
4485
4486         if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
4487             (scsi_status == MPI2_SCSI_STATUS_BUSY ||
4488              scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
4489              scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
4490                 ioc_status = MPI2_IOCSTATUS_SUCCESS;
4491         }
4492
4493         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4494                 struct sense_info data;
4495                 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
4496                     smid);
4497                 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
4498                     le32_to_cpu(mpi_reply->SenseCount));
4499                 memcpy(scmd->sense_buffer, sense_data, sz);
4500                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4501                 /* failure prediction threshold exceeded */
4502                 if (data.asc == 0x5D)
4503                         _scsih_smart_predicted_fault(ioc,
4504                             le16_to_cpu(mpi_reply->DevHandle));
4505                 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
4506
4507                 if (!(ioc->logging_level & MPT_DEBUG_REPLY) &&
4508                      ((scmd->sense_buffer[2] == UNIT_ATTENTION) ||
4509                      (scmd->sense_buffer[2] == MEDIUM_ERROR) ||
4510                      (scmd->sense_buffer[2] == HARDWARE_ERROR)))
4511                         _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid);
4512         }
4513         switch (ioc_status) {
4514         case MPI2_IOCSTATUS_BUSY:
4515         case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
4516                 scmd->result = SAM_STAT_BUSY;
4517                 break;
4518
4519         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4520                 scmd->result = DID_NO_CONNECT << 16;
4521                 break;
4522
4523         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4524                 if (sas_device_priv_data->block) {
4525                         scmd->result = DID_TRANSPORT_DISRUPTED << 16;
4526                         goto out;
4527                 }
4528                 if (log_info == 0x31110630) {
4529                         if (scmd->retries > 2) {
4530                                 scmd->result = DID_NO_CONNECT << 16;
4531                                 scsi_device_set_state(scmd->device,
4532                                     SDEV_OFFLINE);
4533                         } else {
4534                                 scmd->result = DID_SOFT_ERROR << 16;
4535                                 scmd->device->expecting_cc_ua = 1;
4536                         }
4537                         break;
4538                 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) {
4539                         scmd->result = DID_RESET << 16;
4540                         break;
4541                 }
4542                 scmd->result = DID_SOFT_ERROR << 16;
4543                 break;
4544         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4545         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4546                 scmd->result = DID_RESET << 16;
4547                 break;
4548
4549         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4550                 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
4551                         scmd->result = DID_SOFT_ERROR << 16;
4552                 else
4553                         scmd->result = (DID_OK << 16) | scsi_status;
4554                 break;
4555
4556         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4557                 scmd->result = (DID_OK << 16) | scsi_status;
4558
4559                 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
4560                         break;
4561
4562                 if (xfer_cnt < scmd->underflow) {
4563                         if (scsi_status == SAM_STAT_BUSY)
4564                                 scmd->result = SAM_STAT_BUSY;
4565                         else
4566                                 scmd->result = DID_SOFT_ERROR << 16;
4567                 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4568                      MPI2_SCSI_STATE_NO_SCSI_STATUS))
4569                         scmd->result = DID_SOFT_ERROR << 16;
4570                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4571                         scmd->result = DID_RESET << 16;
4572                 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
4573                         mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
4574                         mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
4575                         scmd->result = (DRIVER_SENSE << 24) |
4576                             SAM_STAT_CHECK_CONDITION;
4577                         scmd->sense_buffer[0] = 0x70;
4578                         scmd->sense_buffer[2] = ILLEGAL_REQUEST;
4579                         scmd->sense_buffer[12] = 0x20;
4580                         scmd->sense_buffer[13] = 0;
4581                 }
4582                 break;
4583
4584         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4585                 scsi_set_resid(scmd, 0);
4586         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4587         case MPI2_IOCSTATUS_SUCCESS:
4588                 scmd->result = (DID_OK << 16) | scsi_status;
4589                 if (response_code ==
4590                     MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
4591                     (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4592                      MPI2_SCSI_STATE_NO_SCSI_STATUS)))
4593                         scmd->result = DID_SOFT_ERROR << 16;
4594                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4595                         scmd->result = DID_RESET << 16;
4596                 break;
4597
4598         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4599         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4600         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4601                 _scsih_eedp_error_handling(scmd, ioc_status);
4602                 break;
4603
4604         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4605         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4606         case MPI2_IOCSTATUS_INVALID_SGL:
4607         case MPI2_IOCSTATUS_INTERNAL_ERROR:
4608         case MPI2_IOCSTATUS_INVALID_FIELD:
4609         case MPI2_IOCSTATUS_INVALID_STATE:
4610         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4611         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4612         default:
4613                 scmd->result = DID_SOFT_ERROR << 16;
4614                 break;
4615
4616         }
4617
4618         if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
4619                 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
4620
4621  out:
4622
4623         scsi_dma_unmap(scmd);
4624
4625         scmd->scsi_done(scmd);
4626         return 1;
4627 }
4628
4629 /**
4630  * _scsih_sas_host_refresh - refreshing sas host object contents
4631  * @ioc: per adapter object
4632  * Context: user
4633  *
4634  * During port enable, fw will send topology events for every device. Its
4635  * possible that the handles may change from the previous setting, so this
4636  * code keeping handles updating if changed.
4637  *
4638  * Return nothing.
4639  */
4640 static void
4641 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
4642 {
4643         u16 sz;
4644         u16 ioc_status;
4645         int i;
4646         Mpi2ConfigReply_t mpi_reply;
4647         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4648         u16 attached_handle;
4649         u8 link_rate;
4650
4651         dtmprintk(ioc, pr_info(MPT3SAS_FMT
4652             "updating handles for sas_host(0x%016llx)\n",
4653             ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
4654
4655         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
4656             * sizeof(Mpi2SasIOUnit0PhyData_t));
4657         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4658         if (!sas_iounit_pg0) {
4659                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4660                     ioc->name, __FILE__, __LINE__, __func__);
4661                 return;
4662         }
4663
4664         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4665             sas_iounit_pg0, sz)) != 0)
4666                 goto out;
4667         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
4668         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
4669                 goto out;
4670         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4671                 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
4672                 if (i == 0)
4673                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4674                             PhyData[0].ControllerDevHandle);
4675                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4676                 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
4677                     AttachedDevHandle);
4678                 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
4679                         link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
4680                 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4681                     attached_handle, i, link_rate);
4682         }
4683  out:
4684         kfree(sas_iounit_pg0);
4685 }
4686
4687 /**
4688  * _scsih_sas_host_add - create sas host object
4689  * @ioc: per adapter object
4690  *
4691  * Creating host side data object, stored in ioc->sas_hba
4692  *
4693  * Return nothing.
4694  */
4695 static void
4696 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
4697 {
4698         int i;
4699         Mpi2ConfigReply_t mpi_reply;
4700         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4701         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
4702         Mpi2SasPhyPage0_t phy_pg0;
4703         Mpi2SasDevicePage0_t sas_device_pg0;
4704         Mpi2SasEnclosurePage0_t enclosure_pg0;
4705         u16 ioc_status;
4706         u16 sz;
4707         u8 device_missing_delay;
4708
4709         mpt3sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys);
4710         if (!ioc->sas_hba.num_phys) {
4711                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4712                     ioc->name, __FILE__, __LINE__, __func__);
4713                 return;
4714         }
4715
4716         /* sas_iounit page 0 */
4717         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4718             sizeof(Mpi2SasIOUnit0PhyData_t));
4719         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4720         if (!sas_iounit_pg0) {
4721                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4722                     ioc->name, __FILE__, __LINE__, __func__);
4723                 return;
4724         }
4725         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4726             sas_iounit_pg0, sz))) {
4727                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4728                     ioc->name, __FILE__, __LINE__, __func__);
4729                 goto out;
4730         }
4731         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4732             MPI2_IOCSTATUS_MASK;
4733         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4734                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4735                     ioc->name, __FILE__, __LINE__, __func__);
4736                 goto out;
4737         }
4738
4739         /* sas_iounit page 1 */
4740         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4741             sizeof(Mpi2SasIOUnit1PhyData_t));
4742         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
4743         if (!sas_iounit_pg1) {
4744                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4745                     ioc->name, __FILE__, __LINE__, __func__);
4746                 goto out;
4747         }
4748         if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4749             sas_iounit_pg1, sz))) {
4750                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4751                     ioc->name, __FILE__, __LINE__, __func__);
4752                 goto out;
4753         }
4754         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4755             MPI2_IOCSTATUS_MASK;
4756         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4757                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4758                     ioc->name, __FILE__, __LINE__, __func__);
4759                 goto out;
4760         }
4761
4762         ioc->io_missing_delay =
4763             sas_iounit_pg1->IODeviceMissingDelay;
4764         device_missing_delay =
4765             sas_iounit_pg1->ReportDeviceMissingDelay;
4766         if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
4767                 ioc->device_missing_delay = (device_missing_delay &
4768                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
4769         else
4770                 ioc->device_missing_delay = device_missing_delay &
4771                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
4772
4773         ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
4774         ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys,
4775             sizeof(struct _sas_phy), GFP_KERNEL);
4776         if (!ioc->sas_hba.phy) {
4777                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4778                     ioc->name, __FILE__, __LINE__, __func__);
4779                 goto out;
4780         }
4781         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4782                 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
4783                     i))) {
4784                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4785                             ioc->name, __FILE__, __LINE__, __func__);
4786                         goto out;
4787                 }
4788                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4789                     MPI2_IOCSTATUS_MASK;
4790                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4791                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4792                             ioc->name, __FILE__, __LINE__, __func__);
4793                         goto out;
4794                 }
4795
4796                 if (i == 0)
4797                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4798                             PhyData[0].ControllerDevHandle);
4799                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4800                 ioc->sas_hba.phy[i].phy_id = i;
4801                 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
4802                     phy_pg0, ioc->sas_hba.parent_dev);
4803         }
4804         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4805             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
4806                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4807                     ioc->name, __FILE__, __LINE__, __func__);
4808                 goto out;
4809         }
4810         ioc->sas_hba.enclosure_handle =
4811             le16_to_cpu(sas_device_pg0.EnclosureHandle);
4812         ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4813         pr_info(MPT3SAS_FMT
4814                 "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
4815                 ioc->name, ioc->sas_hba.handle,
4816             (unsigned long long) ioc->sas_hba.sas_address,
4817             ioc->sas_hba.num_phys) ;
4818
4819         if (ioc->sas_hba.enclosure_handle) {
4820                 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4821                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4822                    ioc->sas_hba.enclosure_handle)))
4823                         ioc->sas_hba.enclosure_logical_id =
4824                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4825         }
4826
4827  out:
4828         kfree(sas_iounit_pg1);
4829         kfree(sas_iounit_pg0);
4830 }
4831
4832 /**
4833  * _scsih_expander_add -  creating expander object
4834  * @ioc: per adapter object
4835  * @handle: expander handle
4836  *
4837  * Creating expander object, stored in ioc->sas_expander_list.
4838  *
4839  * Return 0 for success, else error.
4840  */
4841 static int
4842 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4843 {
4844         struct _sas_node *sas_expander;
4845         Mpi2ConfigReply_t mpi_reply;
4846         Mpi2ExpanderPage0_t expander_pg0;
4847         Mpi2ExpanderPage1_t expander_pg1;
4848         Mpi2SasEnclosurePage0_t enclosure_pg0;
4849         u32 ioc_status;
4850         u16 parent_handle;
4851         u64 sas_address, sas_address_parent = 0;
4852         int i;
4853         unsigned long flags;
4854         struct _sas_port *mpt3sas_port = NULL;
4855
4856         int rc = 0;
4857
4858         if (!handle)
4859                 return -1;
4860
4861         if (ioc->shost_recovery || ioc->pci_error_recovery)
4862                 return -1;
4863
4864         if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
4865             MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
4866                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4867                     ioc->name, __FILE__, __LINE__, __func__);
4868                 return -1;
4869         }
4870
4871         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4872             MPI2_IOCSTATUS_MASK;
4873         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4874                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4875                     ioc->name, __FILE__, __LINE__, __func__);
4876                 return -1;
4877         }
4878
4879         /* handle out of order topology events */
4880         parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
4881         if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
4882             != 0) {
4883                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4884                     ioc->name, __FILE__, __LINE__, __func__);
4885                 return -1;
4886         }
4887         if (sas_address_parent != ioc->sas_hba.sas_address) {
4888                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
4889                 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
4890                     sas_address_parent);
4891                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4892                 if (!sas_expander) {
4893                         rc = _scsih_expander_add(ioc, parent_handle);
4894                         if (rc != 0)
4895                                 return rc;
4896                 }
4897         }
4898
4899         spin_lock_irqsave(&ioc->sas_node_lock, flags);
4900         sas_address = le64_to_cpu(expander_pg0.SASAddress);
4901         sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
4902             sas_address);
4903         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
4904
4905         if (sas_expander)
4906                 return 0;
4907
4908         sas_expander = kzalloc(sizeof(struct _sas_node),
4909             GFP_KERNEL);
4910         if (!sas_expander) {
4911                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4912                     ioc->name, __FILE__, __LINE__, __func__);
4913                 return -1;
4914         }
4915
4916         sas_expander->handle = handle;
4917         sas_expander->num_phys = expander_pg0.NumPhys;
4918         sas_expander->sas_address_parent = sas_address_parent;
4919         sas_expander->sas_address = sas_address;
4920
4921         pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \
4922             " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
4923             handle, parent_handle, (unsigned long long)
4924             sas_expander->sas_address, sas_expander->num_phys);
4925
4926         if (!sas_expander->num_phys)
4927                 goto out_fail;
4928         sas_expander->phy = kcalloc(sas_expander->num_phys,
4929             sizeof(struct _sas_phy), GFP_KERNEL);
4930         if (!sas_expander->phy) {
4931                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4932                     ioc->name, __FILE__, __LINE__, __func__);
4933                 rc = -1;
4934                 goto out_fail;
4935         }
4936
4937         INIT_LIST_HEAD(&sas_expander->sas_port_list);
4938         mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
4939             sas_address_parent);
4940         if (!mpt3sas_port) {
4941                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4942                     ioc->name, __FILE__, __LINE__, __func__);
4943                 rc = -1;
4944                 goto out_fail;
4945         }
4946         sas_expander->parent_dev = &mpt3sas_port->rphy->dev;
4947
4948         for (i = 0 ; i < sas_expander->num_phys ; i++) {
4949                 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
4950                     &expander_pg1, i, handle))) {
4951                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4952                             ioc->name, __FILE__, __LINE__, __func__);
4953                         rc = -1;
4954                         goto out_fail;
4955                 }
4956                 sas_expander->phy[i].handle = handle;
4957                 sas_expander->phy[i].phy_id = i;
4958
4959                 if ((mpt3sas_transport_add_expander_phy(ioc,
4960                     &sas_expander->phy[i], expander_pg1,
4961                     sas_expander->parent_dev))) {
4962                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4963                             ioc->name, __FILE__, __LINE__, __func__);
4964                         rc = -1;
4965                         goto out_fail;
4966                 }
4967         }
4968
4969         if (sas_expander->enclosure_handle) {
4970                 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
4971                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
4972                    sas_expander->enclosure_handle)))
4973                         sas_expander->enclosure_logical_id =
4974                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
4975         }
4976
4977         _scsih_expander_node_add(ioc, sas_expander);
4978          return 0;
4979
4980  out_fail:
4981
4982         if (mpt3sas_port)
4983                 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
4984                     sas_address_parent);
4985         kfree(sas_expander);
4986         return rc;
4987 }
4988
4989 /**
4990  * mpt3sas_expander_remove - removing expander object
4991  * @ioc: per adapter object
4992  * @sas_address: expander sas_address
4993  *
4994  * Return nothing.
4995  */
4996 void
4997 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
4998 {
4999         struct _sas_node *sas_expander;
5000         unsigned long flags;
5001
5002         if (ioc->shost_recovery)
5003                 return;
5004
5005         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5006         sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5007             sas_address);
5008         if (sas_expander)
5009                 list_del(&sas_expander->list);
5010         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5011         if (sas_expander)
5012                 _scsih_expander_node_remove(ioc, sas_expander);
5013 }
5014
5015 /**
5016  * _scsih_done -  internal SCSI_IO callback handler.
5017  * @ioc: per adapter object
5018  * @smid: system request message index
5019  * @msix_index: MSIX table index supplied by the OS
5020  * @reply: reply message frame(lower 32bit addr)
5021  *
5022  * Callback handler when sending internal generated SCSI_IO.
5023  * The callback index passed is `ioc->scsih_cb_idx`
5024  *
5025  * Return 1 meaning mf should be freed from _base_interrupt
5026  *        0 means the mf is freed from this function.
5027  */
5028 static u8
5029 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5030 {
5031         MPI2DefaultReply_t *mpi_reply;
5032
5033         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
5034         if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
5035                 return 1;
5036         if (ioc->scsih_cmds.smid != smid)
5037                 return 1;
5038         ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
5039         if (mpi_reply) {
5040                 memcpy(ioc->scsih_cmds.reply, mpi_reply,
5041                     mpi_reply->MsgLength*4);
5042                 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
5043         }
5044         ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
5045         complete(&ioc->scsih_cmds.done);
5046         return 1;
5047 }
5048
5049
5050
5051
5052 #define MPT3_MAX_LUNS (255)
5053
5054
5055 /**
5056  * _scsih_check_access_status - check access flags
5057  * @ioc: per adapter object
5058  * @sas_address: sas address
5059  * @handle: sas device handle
5060  * @access_flags: errors returned during discovery of the device
5061  *
5062  * Return 0 for success, else failure
5063  */
5064 static u8
5065 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
5066         u16 handle, u8 access_status)
5067 {
5068         u8 rc = 1;
5069         char *desc = NULL;
5070
5071         switch (access_status) {
5072         case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
5073         case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
5074                 rc = 0;
5075                 break;
5076         case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
5077                 desc = "sata capability failed";
5078                 break;
5079         case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
5080                 desc = "sata affiliation conflict";
5081                 break;
5082         case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
5083                 desc = "route not addressable";
5084                 break;
5085         case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
5086                 desc = "smp error not addressable";
5087                 break;
5088         case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
5089                 desc = "device blocked";
5090                 break;
5091         case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
5092         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
5093         case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
5094         case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
5095         case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
5096         case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
5097         case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
5098         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
5099         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
5100         case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
5101         case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
5102         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
5103                 desc = "sata initialization failed";
5104                 break;
5105         default:
5106                 desc = "unknown";
5107                 break;
5108         }
5109
5110         if (!rc)
5111                 return 0;
5112
5113         pr_err(MPT3SAS_FMT
5114                 "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
5115                 ioc->name, desc, (unsigned long long)sas_address, handle);
5116         return rc;
5117 }
5118
5119 /**
5120  * _scsih_check_device - checking device responsiveness
5121  * @ioc: per adapter object
5122  * @parent_sas_address: sas address of parent expander or sas host
5123  * @handle: attached device handle
5124  * @phy_numberv: phy number
5125  * @link_rate: new link rate
5126  *
5127  * Returns nothing.
5128  */
5129 static void
5130 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
5131         u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate)
5132 {
5133         Mpi2ConfigReply_t mpi_reply;
5134         Mpi2SasDevicePage0_t sas_device_pg0;
5135         struct _sas_device *sas_device;
5136         u32 ioc_status;
5137         unsigned long flags;
5138         u64 sas_address;
5139         struct scsi_target *starget;
5140         struct MPT3SAS_TARGET *sas_target_priv_data;
5141         u32 device_info;
5142
5143
5144         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5145             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
5146                 return;
5147
5148         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5149         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5150                 return;
5151
5152         /* wide port handling ~ we need only handle device once for the phy that
5153          * is matched in sas device page zero
5154          */
5155         if (phy_number != sas_device_pg0.PhyNum)
5156                 return;
5157
5158         /* check if this is end device */
5159         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5160         if (!(_scsih_is_end_device(device_info)))
5161                 return;
5162
5163         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5164         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5165         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
5166             sas_address);
5167
5168         if (!sas_device)
5169                 goto out_unlock;
5170
5171         if (unlikely(sas_device->handle != handle)) {
5172                 starget = sas_device->starget;
5173                 sas_target_priv_data = starget->hostdata;
5174                 starget_printk(KERN_INFO, starget,
5175                         "handle changed from(0x%04x) to (0x%04x)!!!\n",
5176                         sas_device->handle, handle);
5177                 sas_target_priv_data->handle = handle;
5178                 sas_device->handle = handle;
5179                 if (sas_device_pg0.Flags &
5180                      MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
5181                         sas_device->enclosure_level =
5182                                 le16_to_cpu(sas_device_pg0.EnclosureLevel);
5183                         memcpy(&sas_device->connector_name[0],
5184                                 &sas_device_pg0.ConnectorName[0], 4);
5185                 } else {
5186                         sas_device->enclosure_level = 0;
5187                         sas_device->connector_name[0] = '\0';
5188                 }
5189         }
5190
5191         /* check if device is present */
5192         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5193             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5194                 pr_err(MPT3SAS_FMT
5195                         "device is not present handle(0x%04x), flags!!!\n",
5196                         ioc->name, handle);
5197                 goto out_unlock;
5198         }
5199
5200         /* check if there were any issues with discovery */
5201         if (_scsih_check_access_status(ioc, sas_address, handle,
5202             sas_device_pg0.AccessStatus))
5203                 goto out_unlock;
5204
5205         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5206         _scsih_ublock_io_device(ioc, sas_address);
5207
5208         if (sas_device)
5209                 sas_device_put(sas_device);
5210         return;
5211
5212 out_unlock:
5213         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5214         if (sas_device)
5215                 sas_device_put(sas_device);
5216 }
5217
5218 /**
5219  * _scsih_add_device -  creating sas device object
5220  * @ioc: per adapter object
5221  * @handle: sas device handle
5222  * @phy_num: phy number end device attached to
5223  * @is_pd: is this hidden raid component
5224  *
5225  * Creating end device object, stored in ioc->sas_device_list.
5226  *
5227  * Returns 0 for success, non-zero for failure.
5228  */
5229 static int
5230 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
5231         u8 is_pd)
5232 {
5233         Mpi2ConfigReply_t mpi_reply;
5234         Mpi2SasDevicePage0_t sas_device_pg0;
5235         Mpi2SasEnclosurePage0_t enclosure_pg0;
5236         struct _sas_device *sas_device;
5237         u32 ioc_status;
5238         u64 sas_address;
5239         u32 device_info;
5240
5241         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5242             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
5243                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5244                     ioc->name, __FILE__, __LINE__, __func__);
5245                 return -1;
5246         }
5247
5248         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5249             MPI2_IOCSTATUS_MASK;
5250         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5251                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5252                     ioc->name, __FILE__, __LINE__, __func__);
5253                 return -1;
5254         }
5255
5256         /* check if this is end device */
5257         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5258         if (!(_scsih_is_end_device(device_info)))
5259                 return -1;
5260         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5261
5262         /* check if device is present */
5263         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5264             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5265                 pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n",
5266                         ioc->name, handle);
5267                 return -1;
5268         }
5269
5270         /* check if there were any issues with discovery */
5271         if (_scsih_check_access_status(ioc, sas_address, handle,
5272             sas_device_pg0.AccessStatus))
5273                 return -1;
5274
5275         sas_device = mpt3sas_get_sdev_by_addr(ioc,
5276                                         sas_address);
5277         if (sas_device) {
5278                 sas_device_put(sas_device);
5279                 return -1;
5280         }
5281
5282         sas_device = kzalloc(sizeof(struct _sas_device),
5283             GFP_KERNEL);
5284         if (!sas_device) {
5285                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5286                     ioc->name, __FILE__, __LINE__, __func__);
5287                 return 0;
5288         }
5289
5290         kref_init(&sas_device->refcount);
5291         sas_device->handle = handle;
5292         if (_scsih_get_sas_address(ioc,
5293             le16_to_cpu(sas_device_pg0.ParentDevHandle),
5294             &sas_device->sas_address_parent) != 0)
5295                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5296                     ioc->name, __FILE__, __LINE__, __func__);
5297         sas_device->enclosure_handle =
5298             le16_to_cpu(sas_device_pg0.EnclosureHandle);
5299         if (sas_device->enclosure_handle != 0)
5300                 sas_device->slot =
5301                     le16_to_cpu(sas_device_pg0.Slot);
5302         sas_device->device_info = device_info;
5303         sas_device->sas_address = sas_address;
5304         sas_device->phy = sas_device_pg0.PhyNum;
5305         sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) &
5306             MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
5307
5308         if (sas_device_pg0.Flags & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
5309                 sas_device->enclosure_level =
5310                         le16_to_cpu(sas_device_pg0.EnclosureLevel);
5311                 memcpy(&sas_device->connector_name[0],
5312                         &sas_device_pg0.ConnectorName[0], 4);
5313         } else {
5314                 sas_device->enclosure_level = 0;
5315                 sas_device->connector_name[0] = '\0';
5316         }
5317         /* get enclosure_logical_id */
5318         if (sas_device->enclosure_handle && !(mpt3sas_config_get_enclosure_pg0(
5319            ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5320            sas_device->enclosure_handle)))
5321                 sas_device->enclosure_logical_id =
5322                     le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5323
5324         /* get device name */
5325         sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
5326
5327         if (ioc->wait_for_discovery_to_complete)
5328                 _scsih_sas_device_init_add(ioc, sas_device);
5329         else
5330                 _scsih_sas_device_add(ioc, sas_device);
5331
5332         sas_device_put(sas_device);
5333         return 0;
5334 }
5335
5336 /**
5337  * _scsih_remove_device -  removing sas device object
5338  * @ioc: per adapter object
5339  * @sas_device_delete: the sas_device object
5340  *
5341  * Return nothing.
5342  */
5343 static void
5344 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
5345         struct _sas_device *sas_device)
5346 {
5347         struct MPT3SAS_TARGET *sas_target_priv_data;
5348
5349         if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
5350              (sas_device->pfa_led_on)) {
5351                 _scsih_turn_off_pfa_led(ioc, sas_device);
5352                 sas_device->pfa_led_on = 0;
5353         }
5354         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5355                 "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
5356                 ioc->name, __func__,
5357             sas_device->handle, (unsigned long long)
5358             sas_device->sas_address));
5359         if (sas_device->enclosure_handle != 0)
5360                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5361                     "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
5362                     ioc->name, __func__,
5363                     (unsigned long long)sas_device->enclosure_logical_id,
5364                     sas_device->slot));
5365         if (sas_device->connector_name[0] != '\0')
5366                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5367                   "%s: enter: enclosure level(0x%04x), connector name( %s)\n",
5368                   ioc->name, __func__,
5369                   sas_device->enclosure_level,
5370                   sas_device->connector_name));
5371
5372         if (sas_device->starget && sas_device->starget->hostdata) {
5373                 sas_target_priv_data = sas_device->starget->hostdata;
5374                 sas_target_priv_data->deleted = 1;
5375                 _scsih_ublock_io_device(ioc, sas_device->sas_address);
5376                 sas_target_priv_data->handle =
5377                      MPT3SAS_INVALID_DEVICE_HANDLE;
5378         }
5379
5380         if (!ioc->hide_drives)
5381                 mpt3sas_transport_port_remove(ioc,
5382                     sas_device->sas_address,
5383                     sas_device->sas_address_parent);
5384
5385         pr_info(MPT3SAS_FMT
5386                 "removing handle(0x%04x), sas_addr(0x%016llx)\n",
5387                 ioc->name, sas_device->handle,
5388             (unsigned long long) sas_device->sas_address);
5389         if (sas_device->enclosure_handle != 0)
5390                 pr_info(MPT3SAS_FMT
5391                   "removing : enclosure logical id(0x%016llx), slot(%d)\n",
5392                   ioc->name,
5393                   (unsigned long long)sas_device->enclosure_logical_id,
5394                   sas_device->slot);
5395         if (sas_device->connector_name[0] != '\0')
5396                 pr_info(MPT3SAS_FMT
5397                   "removing enclosure level(0x%04x), connector name( %s)\n",
5398                   ioc->name, sas_device->enclosure_level,
5399                   sas_device->connector_name);
5400
5401         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5402                 "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
5403                 ioc->name, __func__,
5404                 sas_device->handle, (unsigned long long)
5405                 sas_device->sas_address));
5406         if (sas_device->enclosure_handle != 0)
5407                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5408                     "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
5409                     ioc->name, __func__,
5410                     (unsigned long long)sas_device->enclosure_logical_id,
5411                     sas_device->slot));
5412         if (sas_device->connector_name[0] != '\0')
5413                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5414                     "%s: exit: enclosure level(0x%04x), connector name(%s)\n",
5415                     ioc->name, __func__, sas_device->enclosure_level,
5416                     sas_device->connector_name));
5417 }
5418
5419 /**
5420  * _scsih_sas_topology_change_event_debug - debug for topology event
5421  * @ioc: per adapter object
5422  * @event_data: event data payload
5423  * Context: user.
5424  */
5425 static void
5426 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5427         Mpi2EventDataSasTopologyChangeList_t *event_data)
5428 {
5429         int i;
5430         u16 handle;
5431         u16 reason_code;
5432         u8 phy_number;
5433         char *status_str = NULL;
5434         u8 link_rate, prev_link_rate;
5435
5436         switch (event_data->ExpStatus) {
5437         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
5438                 status_str = "add";
5439                 break;
5440         case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
5441                 status_str = "remove";
5442                 break;
5443         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
5444         case 0:
5445                 status_str =  "responding";
5446                 break;
5447         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
5448                 status_str = "remove delay";
5449                 break;
5450         default:
5451                 status_str = "unknown status";
5452                 break;
5453         }
5454         pr_info(MPT3SAS_FMT "sas topology change: (%s)\n",
5455             ioc->name, status_str);
5456         pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
5457             "start_phy(%02d), count(%d)\n",
5458             le16_to_cpu(event_data->ExpanderDevHandle),
5459             le16_to_cpu(event_data->EnclosureHandle),
5460             event_data->StartPhyNum, event_data->NumEntries);
5461         for (i = 0; i < event_data->NumEntries; i++) {
5462                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5463                 if (!handle)
5464                         continue;
5465                 phy_number = event_data->StartPhyNum + i;
5466                 reason_code = event_data->PHY[i].PhyStatus &
5467                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5468                 switch (reason_code) {
5469                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5470                         status_str = "target add";
5471                         break;
5472                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5473                         status_str = "target remove";
5474                         break;
5475                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
5476                         status_str = "delay target remove";
5477                         break;
5478                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5479                         status_str = "link rate change";
5480                         break;
5481                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
5482                         status_str = "target responding";
5483                         break;
5484                 default:
5485                         status_str = "unknown";
5486                         break;
5487                 }
5488                 link_rate = event_data->PHY[i].LinkRate >> 4;
5489                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5490                 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \
5491                     " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
5492                     handle, status_str, link_rate, prev_link_rate);
5493
5494         }
5495 }
5496
5497 /**
5498  * _scsih_sas_topology_change_event - handle topology changes
5499  * @ioc: per adapter object
5500  * @fw_event: The fw_event_work object
5501  * Context: user.
5502  *
5503  */
5504 static int
5505 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
5506         struct fw_event_work *fw_event)
5507 {
5508         int i;
5509         u16 parent_handle, handle;
5510         u16 reason_code;
5511         u8 phy_number, max_phys;
5512         struct _sas_node *sas_expander;
5513         u64 sas_address;
5514         unsigned long flags;
5515         u8 link_rate, prev_link_rate;
5516         Mpi2EventDataSasTopologyChangeList_t *event_data =
5517                 (Mpi2EventDataSasTopologyChangeList_t *)
5518                 fw_event->event_data;
5519
5520         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5521                 _scsih_sas_topology_change_event_debug(ioc, event_data);
5522
5523         if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
5524                 return 0;
5525
5526         if (!ioc->sas_hba.num_phys)
5527                 _scsih_sas_host_add(ioc);
5528         else
5529                 _scsih_sas_host_refresh(ioc);
5530
5531         if (fw_event->ignore) {
5532                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5533                         "ignoring expander event\n", ioc->name));
5534                 return 0;
5535         }
5536
5537         parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
5538
5539         /* handle expander add */
5540         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
5541                 if (_scsih_expander_add(ioc, parent_handle) != 0)
5542                         return 0;
5543
5544         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5545         sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
5546             parent_handle);
5547         if (sas_expander) {
5548                 sas_address = sas_expander->sas_address;
5549                 max_phys = sas_expander->num_phys;
5550         } else if (parent_handle < ioc->sas_hba.num_phys) {
5551                 sas_address = ioc->sas_hba.sas_address;
5552                 max_phys = ioc->sas_hba.num_phys;
5553         } else {
5554                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5555                 return 0;
5556         }
5557         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5558
5559         /* handle siblings events */
5560         for (i = 0; i < event_data->NumEntries; i++) {
5561                 if (fw_event->ignore) {
5562                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5563                                 "ignoring expander event\n", ioc->name));
5564                         return 0;
5565                 }
5566                 if (ioc->remove_host || ioc->pci_error_recovery)
5567                         return 0;
5568                 phy_number = event_data->StartPhyNum + i;
5569                 if (phy_number >= max_phys)
5570                         continue;
5571                 reason_code = event_data->PHY[i].PhyStatus &
5572                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5573                 if ((event_data->PHY[i].PhyStatus &
5574                     MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
5575                     MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
5576                                 continue;
5577                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5578                 if (!handle)
5579                         continue;
5580                 link_rate = event_data->PHY[i].LinkRate >> 4;
5581                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5582                 switch (reason_code) {
5583                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5584
5585                         if (ioc->shost_recovery)
5586                                 break;
5587
5588                         if (link_rate == prev_link_rate)
5589                                 break;
5590
5591                         mpt3sas_transport_update_links(ioc, sas_address,
5592                             handle, phy_number, link_rate);
5593
5594                         if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5595                                 break;
5596
5597                         _scsih_check_device(ioc, sas_address, handle,
5598                             phy_number, link_rate);
5599
5600
5601                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5602
5603                         if (ioc->shost_recovery)
5604                                 break;
5605
5606                         mpt3sas_transport_update_links(ioc, sas_address,
5607                             handle, phy_number, link_rate);
5608
5609                         _scsih_add_device(ioc, handle, phy_number, 0);
5610
5611                         break;
5612                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5613
5614                         _scsih_device_remove_by_handle(ioc, handle);
5615                         break;
5616                 }
5617         }
5618
5619         /* handle expander removal */
5620         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
5621             sas_expander)
5622                 mpt3sas_expander_remove(ioc, sas_address);
5623
5624         return 0;
5625 }
5626
5627 /**
5628  * _scsih_sas_device_status_change_event_debug - debug for device event
5629  * @event_data: event data payload
5630  * Context: user.
5631  *
5632  * Return nothing.
5633  */
5634 static void
5635 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5636         Mpi2EventDataSasDeviceStatusChange_t *event_data)
5637 {
5638         char *reason_str = NULL;
5639
5640         switch (event_data->ReasonCode) {
5641         case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
5642                 reason_str = "smart data";
5643                 break;
5644         case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
5645                 reason_str = "unsupported device discovered";
5646                 break;
5647         case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
5648                 reason_str = "internal device reset";
5649                 break;
5650         case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
5651                 reason_str = "internal task abort";
5652                 break;
5653         case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
5654                 reason_str = "internal task abort set";
5655                 break;
5656         case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
5657                 reason_str = "internal clear task set";
5658                 break;
5659         case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
5660                 reason_str = "internal query task";
5661                 break;
5662         case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
5663                 reason_str = "sata init failure";
5664                 break;
5665         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
5666                 reason_str = "internal device reset complete";
5667                 break;
5668         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
5669                 reason_str = "internal task abort complete";
5670                 break;
5671         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
5672                 reason_str = "internal async notification";
5673                 break;
5674         case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
5675                 reason_str = "expander reduced functionality";
5676                 break;
5677         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
5678                 reason_str = "expander reduced functionality complete";
5679                 break;
5680         default:
5681                 reason_str = "unknown reason";
5682                 break;
5683         }
5684         pr_info(MPT3SAS_FMT "device status change: (%s)\n"
5685             "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
5686             ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
5687             (unsigned long long)le64_to_cpu(event_data->SASAddress),
5688             le16_to_cpu(event_data->TaskTag));
5689         if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
5690                 pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
5691                     event_data->ASC, event_data->ASCQ);
5692         pr_info("\n");
5693 }
5694
5695 /**
5696  * _scsih_sas_device_status_change_event - handle device status change
5697  * @ioc: per adapter object
5698  * @fw_event: The fw_event_work object
5699  * Context: user.
5700  *
5701  * Return nothing.
5702  */
5703 static void
5704 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
5705         struct fw_event_work *fw_event)
5706 {
5707         struct MPT3SAS_TARGET *target_priv_data;
5708         struct _sas_device *sas_device;
5709         u64 sas_address;
5710         unsigned long flags;
5711         Mpi2EventDataSasDeviceStatusChange_t *event_data =
5712                 (Mpi2EventDataSasDeviceStatusChange_t *)
5713                 fw_event->event_data;
5714
5715         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5716                 _scsih_sas_device_status_change_event_debug(ioc,
5717                      event_data);
5718
5719         /* In MPI Revision K (0xC), the internal device reset complete was
5720          * implemented, so avoid setting tm_busy flag for older firmware.
5721          */
5722         if ((ioc->facts.HeaderVersion >> 8) < 0xC)
5723                 return;
5724
5725         if (event_data->ReasonCode !=
5726             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5727            event_data->ReasonCode !=
5728             MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
5729                 return;
5730
5731         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5732         sas_address = le64_to_cpu(event_data->SASAddress);
5733         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
5734             sas_address);
5735
5736         if (!sas_device || !sas_device->starget)
5737                 goto out;
5738
5739         target_priv_data = sas_device->starget->hostdata;
5740         if (!target_priv_data)
5741                 goto out;
5742
5743         if (event_data->ReasonCode ==
5744             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
5745                 target_priv_data->tm_busy = 1;
5746         else
5747                 target_priv_data->tm_busy = 0;
5748
5749 out:
5750         if (sas_device)
5751                 sas_device_put(sas_device);
5752
5753         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5754
5755 }
5756
5757 /**
5758  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure
5759  * event
5760  * @ioc: per adapter object
5761  * @event_data: event data payload
5762  * Context: user.
5763  *
5764  * Return nothing.
5765  */
5766 static void
5767 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5768         Mpi2EventDataSasEnclDevStatusChange_t *event_data)
5769 {
5770         char *reason_str = NULL;
5771
5772         switch (event_data->ReasonCode) {
5773         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
5774                 reason_str = "enclosure add";
5775                 break;
5776         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
5777                 reason_str = "enclosure remove";
5778                 break;
5779         default:
5780                 reason_str = "unknown reason";
5781                 break;
5782         }
5783
5784         pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n"
5785             "\thandle(0x%04x), enclosure logical id(0x%016llx)"
5786             " number slots(%d)\n", ioc->name, reason_str,
5787             le16_to_cpu(event_data->EnclosureHandle),
5788             (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
5789             le16_to_cpu(event_data->StartSlot));
5790 }
5791
5792 /**
5793  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
5794  * @ioc: per adapter object
5795  * @fw_event: The fw_event_work object
5796  * Context: user.
5797  *
5798  * Return nothing.
5799  */
5800 static void
5801 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
5802         struct fw_event_work *fw_event)
5803 {
5804         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5805                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
5806                      (Mpi2EventDataSasEnclDevStatusChange_t *)
5807                      fw_event->event_data);
5808 }
5809
5810 /**
5811  * _scsih_sas_broadcast_primitive_event - handle broadcast events
5812  * @ioc: per adapter object
5813  * @fw_event: The fw_event_work object
5814  * Context: user.
5815  *
5816  * Return nothing.
5817  */
5818 static void
5819 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
5820         struct fw_event_work *fw_event)
5821 {
5822         struct scsi_cmnd *scmd;
5823         struct scsi_device *sdev;
5824         u16 smid, handle;
5825         u32 lun;
5826         struct MPT3SAS_DEVICE *sas_device_priv_data;
5827         u32 termination_count;
5828         u32 query_count;
5829         Mpi2SCSITaskManagementReply_t *mpi_reply;
5830         Mpi2EventDataSasBroadcastPrimitive_t *event_data =
5831                 (Mpi2EventDataSasBroadcastPrimitive_t *)
5832                 fw_event->event_data;
5833         u16 ioc_status;
5834         unsigned long flags;
5835         int r;
5836         u8 max_retries = 0;
5837         u8 task_abort_retries;
5838
5839         mutex_lock(&ioc->tm_cmds.mutex);
5840         pr_info(MPT3SAS_FMT
5841                 "%s: enter: phy number(%d), width(%d)\n",
5842                 ioc->name, __func__, event_data->PhyNum,
5843              event_data->PortWidth);
5844
5845         _scsih_block_io_all_device(ioc);
5846
5847         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5848         mpi_reply = ioc->tm_cmds.reply;
5849  broadcast_aen_retry:
5850
5851         /* sanity checks for retrying this loop */
5852         if (max_retries++ == 5) {
5853                 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n",
5854                     ioc->name, __func__));
5855                 goto out;
5856         } else if (max_retries > 1)
5857                 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n",
5858                     ioc->name, __func__, max_retries - 1));
5859
5860         termination_count = 0;
5861         query_count = 0;
5862         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
5863                 if (ioc->shost_recovery)
5864                         goto out;
5865                 scmd = _scsih_scsi_lookup_get(ioc, smid);
5866                 if (!scmd)
5867                         continue;
5868                 sdev = scmd->device;
5869                 sas_device_priv_data = sdev->hostdata;
5870                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
5871                         continue;
5872                  /* skip hidden raid components */
5873                 if (sas_device_priv_data->sas_target->flags &
5874                     MPT_TARGET_FLAGS_RAID_COMPONENT)
5875                         continue;
5876                  /* skip volumes */
5877                 if (sas_device_priv_data->sas_target->flags &
5878                     MPT_TARGET_FLAGS_VOLUME)
5879                         continue;
5880
5881                 handle = sas_device_priv_data->sas_target->handle;
5882                 lun = sas_device_priv_data->lun;
5883                 query_count++;
5884
5885                 if (ioc->shost_recovery)
5886                         goto out;
5887
5888                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5889                 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
5890                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30,
5891                     TM_MUTEX_OFF);
5892                 if (r == FAILED) {
5893                         sdev_printk(KERN_WARNING, sdev,
5894                             "mpt3sas_scsih_issue_tm: FAILED when sending "
5895                             "QUERY_TASK: scmd(%p)\n", scmd);
5896                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5897                         goto broadcast_aen_retry;
5898                 }
5899                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
5900                     & MPI2_IOCSTATUS_MASK;
5901                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5902                         sdev_printk(KERN_WARNING, sdev,
5903                                 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n",
5904                                 ioc_status, scmd);
5905                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5906                         goto broadcast_aen_retry;
5907                 }
5908
5909                 /* see if IO is still owned by IOC and target */
5910                 if (mpi_reply->ResponseCode ==
5911                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
5912                      mpi_reply->ResponseCode ==
5913                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
5914                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5915                         continue;
5916                 }
5917                 task_abort_retries = 0;
5918  tm_retry:
5919                 if (task_abort_retries++ == 60) {
5920                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5921                             "%s: ABORT_TASK: giving up\n", ioc->name,
5922                             __func__));
5923                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5924                         goto broadcast_aen_retry;
5925                 }
5926
5927                 if (ioc->shost_recovery)
5928                         goto out_no_lock;
5929
5930                 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
5931                     sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30,
5932                     TM_MUTEX_OFF);
5933                 if (r == FAILED) {
5934                         sdev_printk(KERN_WARNING, sdev,
5935                             "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : "
5936                             "scmd(%p)\n", scmd);
5937                         goto tm_retry;
5938                 }
5939
5940                 if (task_abort_retries > 1)
5941                         sdev_printk(KERN_WARNING, sdev,
5942                             "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
5943                             " scmd(%p)\n",
5944                             task_abort_retries - 1, scmd);
5945
5946                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
5947                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
5948         }
5949
5950         if (ioc->broadcast_aen_pending) {
5951                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5952                         "%s: loop back due to pending AEN\n",
5953                         ioc->name, __func__));
5954                  ioc->broadcast_aen_pending = 0;
5955                  goto broadcast_aen_retry;
5956         }
5957
5958  out:
5959         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
5960  out_no_lock:
5961
5962         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5963             "%s - exit, query_count = %d termination_count = %d\n",
5964             ioc->name, __func__, query_count, termination_count));
5965
5966         ioc->broadcast_aen_busy = 0;
5967         if (!ioc->shost_recovery)
5968                 _scsih_ublock_io_all_device(ioc);
5969         mutex_unlock(&ioc->tm_cmds.mutex);
5970 }
5971
5972 /**
5973  * _scsih_sas_discovery_event - handle discovery events
5974  * @ioc: per adapter object
5975  * @fw_event: The fw_event_work object
5976  * Context: user.
5977  *
5978  * Return nothing.
5979  */
5980 static void
5981 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
5982         struct fw_event_work *fw_event)
5983 {
5984         Mpi2EventDataSasDiscovery_t *event_data =
5985                 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data;
5986
5987         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
5988                 pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name,
5989                     (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
5990                     "start" : "stop");
5991                 if (event_data->DiscoveryStatus)
5992                         pr_info("discovery_status(0x%08x)",
5993                             le32_to_cpu(event_data->DiscoveryStatus));
5994                 pr_info("\n");
5995         }
5996
5997         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
5998             !ioc->sas_hba.num_phys) {
5999                 if (disable_discovery > 0 && ioc->shost_recovery) {
6000                         /* Wait for the reset to complete */
6001                         while (ioc->shost_recovery)
6002                                 ssleep(1);
6003                 }
6004                 _scsih_sas_host_add(ioc);
6005         }
6006 }
6007
6008 /**
6009  * _scsih_ir_fastpath - turn on fastpath for IR physdisk
6010  * @ioc: per adapter object
6011  * @handle: device handle for physical disk
6012  * @phys_disk_num: physical disk number
6013  *
6014  * Return 0 for success, else failure.
6015  */
6016 static int
6017 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
6018 {
6019         Mpi2RaidActionRequest_t *mpi_request;
6020         Mpi2RaidActionReply_t *mpi_reply;
6021         u16 smid;
6022         u8 issue_reset = 0;
6023         int rc = 0;
6024         u16 ioc_status;
6025         u32 log_info;
6026
6027         if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
6028                 return rc;
6029
6030         mutex_lock(&ioc->scsih_cmds.mutex);
6031
6032         if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
6033                 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
6034                     ioc->name, __func__);
6035                 rc = -EAGAIN;
6036                 goto out;
6037         }
6038         ioc->scsih_cmds.status = MPT3_CMD_PENDING;
6039
6040         smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
6041         if (!smid) {
6042                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
6043                     ioc->name, __func__);
6044                 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
6045                 rc = -EAGAIN;
6046                 goto out;
6047         }
6048
6049         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
6050         ioc->scsih_cmds.smid = smid;
6051         memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
6052
6053         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
6054         mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
6055         mpi_request->PhysDiskNum = phys_disk_num;
6056
6057         dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\
6058             "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name,
6059             handle, phys_disk_num));
6060
6061         init_completion(&ioc->scsih_cmds.done);
6062         mpt3sas_base_put_smid_default(ioc, smid);
6063         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
6064
6065         if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
6066                 pr_err(MPT3SAS_FMT "%s: timeout\n",
6067                     ioc->name, __func__);
6068                 if (!(ioc->scsih_cmds.status & MPT3_CMD_RESET))
6069                         issue_reset = 1;
6070                 rc = -EFAULT;
6071                 goto out;
6072         }
6073
6074         if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
6075
6076                 mpi_reply = ioc->scsih_cmds.reply;
6077                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
6078                 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
6079                         log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
6080                 else
6081                         log_info = 0;
6082                 ioc_status &= MPI2_IOCSTATUS_MASK;
6083                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6084                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
6085                             "IR RAID_ACTION: failed: ioc_status(0x%04x), "
6086                             "loginfo(0x%08x)!!!\n", ioc->name, ioc_status,
6087                             log_info));
6088                         rc = -EFAULT;
6089                 } else
6090                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
6091                             "IR RAID_ACTION: completed successfully\n",
6092                             ioc->name));
6093         }
6094
6095  out:
6096         ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
6097         mutex_unlock(&ioc->scsih_cmds.mutex);
6098
6099         if (issue_reset)
6100                 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
6101                     FORCE_BIG_HAMMER);
6102         return rc;
6103 }
6104
6105 /**
6106  * _scsih_reprobe_lun - reprobing lun
6107  * @sdev: scsi device struct
6108  * @no_uld_attach: sdev->no_uld_attach flag setting
6109  *
6110  **/
6111 static void
6112 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
6113 {
6114         int rc;
6115         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
6116         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
6117             sdev->no_uld_attach ? "hidding" : "exposing");
6118         rc = scsi_device_reprobe(sdev);
6119 }
6120
6121 /**
6122  * _scsih_sas_volume_add - add new volume
6123  * @ioc: per adapter object
6124  * @element: IR config element data
6125  * Context: user.
6126  *
6127  * Return nothing.
6128  */
6129 static void
6130 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
6131         Mpi2EventIrConfigElement_t *element)
6132 {
6133         struct _raid_device *raid_device;
6134         unsigned long flags;
6135         u64 wwid;
6136         u16 handle = le16_to_cpu(element->VolDevHandle);
6137         int rc;
6138
6139         mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
6140         if (!wwid) {
6141                 pr_err(MPT3SAS_FMT
6142                     "failure at %s:%d/%s()!\n", ioc->name,
6143                     __FILE__, __LINE__, __func__);
6144                 return;
6145         }
6146
6147         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6148         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
6149         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6150
6151         if (raid_device)
6152                 return;
6153
6154         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6155         if (!raid_device) {
6156                 pr_err(MPT3SAS_FMT
6157                     "failure at %s:%d/%s()!\n", ioc->name,
6158                     __FILE__, __LINE__, __func__);
6159                 return;
6160         }
6161
6162         raid_device->id = ioc->sas_id++;
6163         raid_device->channel = RAID_CHANNEL;
6164         raid_device->handle = handle;
6165         raid_device->wwid = wwid;
6166         _scsih_raid_device_add(ioc, raid_device);
6167         if (!ioc->wait_for_discovery_to_complete) {
6168                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6169                     raid_device->id, 0);
6170                 if (rc)
6171                         _scsih_raid_device_remove(ioc, raid_device);
6172         } else {
6173                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6174                 _scsih_determine_boot_device(ioc, raid_device, 1);
6175                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6176         }
6177 }
6178
6179 /**
6180  * _scsih_sas_volume_delete - delete volume
6181  * @ioc: per adapter object
6182  * @handle: volume device handle
6183  * Context: user.
6184  *
6185  * Return nothing.
6186  */
6187 static void
6188 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6189 {
6190         struct _raid_device *raid_device;
6191         unsigned long flags;
6192         struct MPT3SAS_TARGET *sas_target_priv_data;
6193         struct scsi_target *starget = NULL;
6194
6195         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6196         raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
6197         if (raid_device) {
6198                 if (raid_device->starget) {
6199                         starget = raid_device->starget;
6200                         sas_target_priv_data = starget->hostdata;
6201                         sas_target_priv_data->deleted = 1;
6202                 }
6203                 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
6204                         ioc->name,  raid_device->handle,
6205                     (unsigned long long) raid_device->wwid);
6206                 list_del(&raid_device->list);
6207                 kfree(raid_device);
6208         }
6209         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6210         if (starget)
6211                 scsi_remove_target(&starget->dev);
6212 }
6213
6214 /**
6215  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
6216  * @ioc: per adapter object
6217  * @element: IR config element data
6218  * Context: user.
6219  *
6220  * Return nothing.
6221  */
6222 static void
6223 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
6224         Mpi2EventIrConfigElement_t *element)
6225 {
6226         struct _sas_device *sas_device;
6227         struct scsi_target *starget = NULL;
6228         struct MPT3SAS_TARGET *sas_target_priv_data;
6229         unsigned long flags;
6230         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6231
6232         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6233         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
6234         if (sas_device) {
6235                 sas_device->volume_handle = 0;
6236                 sas_device->volume_wwid = 0;
6237                 clear_bit(handle, ioc->pd_handles);
6238                 if (sas_device->starget && sas_device->starget->hostdata) {
6239                         starget = sas_device->starget;
6240                         sas_target_priv_data = starget->hostdata;
6241                         sas_target_priv_data->flags &=
6242                             ~MPT_TARGET_FLAGS_RAID_COMPONENT;
6243                 }
6244         }
6245         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6246         if (!sas_device)
6247                 return;
6248
6249         /* exposing raid component */
6250         if (starget)
6251                 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
6252
6253         sas_device_put(sas_device);
6254 }
6255
6256 /**
6257  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
6258  * @ioc: per adapter object
6259  * @element: IR config element data
6260  * Context: user.
6261  *
6262  * Return nothing.
6263  */
6264 static void
6265 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
6266         Mpi2EventIrConfigElement_t *element)
6267 {
6268         struct _sas_device *sas_device;
6269         struct scsi_target *starget = NULL;
6270         struct MPT3SAS_TARGET *sas_target_priv_data;
6271         unsigned long flags;
6272         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6273         u16 volume_handle = 0;
6274         u64 volume_wwid = 0;
6275
6276         mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
6277         if (volume_handle)
6278                 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
6279                     &volume_wwid);
6280
6281         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6282         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
6283         if (sas_device) {
6284                 set_bit(handle, ioc->pd_handles);
6285                 if (sas_device->starget && sas_device->starget->hostdata) {
6286                         starget = sas_device->starget;
6287                         sas_target_priv_data = starget->hostdata;
6288                         sas_target_priv_data->flags |=
6289                             MPT_TARGET_FLAGS_RAID_COMPONENT;
6290                         sas_device->volume_handle = volume_handle;
6291                         sas_device->volume_wwid = volume_wwid;
6292                 }
6293         }
6294         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6295         if (!sas_device)
6296                 return;
6297
6298         /* hiding raid component */
6299         _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
6300
6301         if (starget)
6302                 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
6303
6304         sas_device_put(sas_device);
6305 }
6306
6307 /**
6308  * _scsih_sas_pd_delete - delete pd component
6309  * @ioc: per adapter object
6310  * @element: IR config element data
6311  * Context: user.
6312  *
6313  * Return nothing.
6314  */
6315 static void
6316 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
6317         Mpi2EventIrConfigElement_t *element)
6318 {
6319         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6320
6321         _scsih_device_remove_by_handle(ioc, handle);
6322 }
6323
6324 /**
6325  * _scsih_sas_pd_add - remove pd component
6326  * @ioc: per adapter object
6327  * @element: IR config element data
6328  * Context: user.
6329  *
6330  * Return nothing.
6331  */
6332 static void
6333 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
6334         Mpi2EventIrConfigElement_t *element)
6335 {
6336         struct _sas_device *sas_device;
6337         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6338         Mpi2ConfigReply_t mpi_reply;
6339         Mpi2SasDevicePage0_t sas_device_pg0;
6340         u32 ioc_status;
6341         u64 sas_address;
6342         u16 parent_handle;
6343
6344         set_bit(handle, ioc->pd_handles);
6345
6346         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
6347         if (sas_device) {
6348                 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
6349                 sas_device_put(sas_device);
6350                 return;
6351         }
6352
6353         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6354             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
6355                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6356                     ioc->name, __FILE__, __LINE__, __func__);
6357                 return;
6358         }
6359
6360         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6361             MPI2_IOCSTATUS_MASK;
6362         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6363                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6364                     ioc->name, __FILE__, __LINE__, __func__);
6365                 return;
6366         }
6367
6368         parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6369         if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6370                 mpt3sas_transport_update_links(ioc, sas_address, handle,
6371                     sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6372
6373         _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
6374         _scsih_add_device(ioc, handle, 0, 1);
6375 }
6376
6377 /**
6378  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
6379  * @ioc: per adapter object
6380  * @event_data: event data payload
6381  * Context: user.
6382  *
6383  * Return nothing.
6384  */
6385 static void
6386 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6387         Mpi2EventDataIrConfigChangeList_t *event_data)
6388 {
6389         Mpi2EventIrConfigElement_t *element;
6390         u8 element_type;
6391         int i;
6392         char *reason_str = NULL, *element_str = NULL;
6393
6394         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6395
6396         pr_info(MPT3SAS_FMT "raid config change: (%s), elements(%d)\n",
6397             ioc->name, (le32_to_cpu(event_data->Flags) &
6398             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
6399             "foreign" : "native", event_data->NumElements);
6400         for (i = 0; i < event_data->NumElements; i++, element++) {
6401                 switch (element->ReasonCode) {
6402                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6403                         reason_str = "add";
6404                         break;
6405                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6406                         reason_str = "remove";
6407                         break;
6408                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
6409                         reason_str = "no change";
6410                         break;
6411                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6412                         reason_str = "hide";
6413                         break;
6414                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6415                         reason_str = "unhide";
6416                         break;
6417                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6418                         reason_str = "volume_created";
6419                         break;
6420                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6421                         reason_str = "volume_deleted";
6422                         break;
6423                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6424                         reason_str = "pd_created";
6425                         break;
6426                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6427                         reason_str = "pd_deleted";
6428                         break;
6429                 default:
6430                         reason_str = "unknown reason";
6431                         break;
6432                 }
6433                 element_type = le16_to_cpu(element->ElementFlags) &
6434                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
6435                 switch (element_type) {
6436                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
6437                         element_str = "volume";
6438                         break;
6439                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
6440                         element_str = "phys disk";
6441                         break;
6442                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
6443                         element_str = "hot spare";
6444                         break;
6445                 default:
6446                         element_str = "unknown element";
6447                         break;
6448                 }
6449                 pr_info("\t(%s:%s), vol handle(0x%04x), " \
6450                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
6451                     reason_str, le16_to_cpu(element->VolDevHandle),
6452                     le16_to_cpu(element->PhysDiskDevHandle),
6453                     element->PhysDiskNum);
6454         }
6455 }
6456
6457 /**
6458  * _scsih_sas_ir_config_change_event - handle ir configuration change events
6459  * @ioc: per adapter object
6460  * @fw_event: The fw_event_work object
6461  * Context: user.
6462  *
6463  * Return nothing.
6464  */
6465 static void
6466 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
6467         struct fw_event_work *fw_event)
6468 {
6469         Mpi2EventIrConfigElement_t *element;
6470         int i;
6471         u8 foreign_config;
6472         Mpi2EventDataIrConfigChangeList_t *event_data =
6473                 (Mpi2EventDataIrConfigChangeList_t *)
6474                 fw_event->event_data;
6475
6476         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
6477              (!ioc->hide_ir_msg))
6478                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
6479
6480         foreign_config = (le32_to_cpu(event_data->Flags) &
6481             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
6482
6483         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6484         if (ioc->shost_recovery &&
6485             ioc->hba_mpi_version_belonged != MPI2_VERSION) {
6486                 for (i = 0; i < event_data->NumElements; i++, element++) {
6487                         if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)
6488                                 _scsih_ir_fastpath(ioc,
6489                                         le16_to_cpu(element->PhysDiskDevHandle),
6490                                         element->PhysDiskNum);
6491                 }
6492                 return;
6493         }
6494
6495         for (i = 0; i < event_data->NumElements; i++, element++) {
6496
6497                 switch (element->ReasonCode) {
6498                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6499                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6500                         if (!foreign_config)
6501                                 _scsih_sas_volume_add(ioc, element);
6502                         break;
6503                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6504                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6505                         if (!foreign_config)
6506                                 _scsih_sas_volume_delete(ioc,
6507                                     le16_to_cpu(element->VolDevHandle));
6508                         break;
6509                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6510                         if (!ioc->is_warpdrive)
6511                                 _scsih_sas_pd_hide(ioc, element);
6512                         break;
6513                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6514                         if (!ioc->is_warpdrive)
6515                                 _scsih_sas_pd_expose(ioc, element);
6516                         break;
6517                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6518                         if (!ioc->is_warpdrive)
6519                                 _scsih_sas_pd_add(ioc, element);
6520                         break;
6521                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6522                         if (!ioc->is_warpdrive)
6523                                 _scsih_sas_pd_delete(ioc, element);
6524                         break;
6525                 }
6526         }
6527 }
6528
6529 /**
6530  * _scsih_sas_ir_volume_event - IR volume event
6531  * @ioc: per adapter object
6532  * @fw_event: The fw_event_work object
6533  * Context: user.
6534  *
6535  * Return nothing.
6536  */
6537 static void
6538 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
6539         struct fw_event_work *fw_event)
6540 {
6541         u64 wwid;
6542         unsigned long flags;
6543         struct _raid_device *raid_device;
6544         u16 handle;
6545         u32 state;
6546         int rc;
6547         Mpi2EventDataIrVolume_t *event_data =
6548                 (Mpi2EventDataIrVolume_t *) fw_event->event_data;
6549
6550         if (ioc->shost_recovery)
6551                 return;
6552
6553         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
6554                 return;
6555
6556         handle = le16_to_cpu(event_data->VolDevHandle);
6557         state = le32_to_cpu(event_data->NewValue);
6558         if (!ioc->hide_ir_msg)
6559                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6560                     "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
6561                     ioc->name, __func__,  handle,
6562                     le32_to_cpu(event_data->PreviousValue), state));
6563         switch (state) {
6564         case MPI2_RAID_VOL_STATE_MISSING:
6565         case MPI2_RAID_VOL_STATE_FAILED:
6566                 _scsih_sas_volume_delete(ioc, handle);
6567                 break;
6568
6569         case MPI2_RAID_VOL_STATE_ONLINE:
6570         case MPI2_RAID_VOL_STATE_DEGRADED:
6571         case MPI2_RAID_VOL_STATE_OPTIMAL:
6572
6573                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6574                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
6575                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6576
6577                 if (raid_device)
6578                         break;
6579
6580                 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
6581                 if (!wwid) {
6582                         pr_err(MPT3SAS_FMT
6583                             "failure at %s:%d/%s()!\n", ioc->name,
6584                             __FILE__, __LINE__, __func__);
6585                         break;
6586                 }
6587
6588                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6589                 if (!raid_device) {
6590                         pr_err(MPT3SAS_FMT
6591                             "failure at %s:%d/%s()!\n", ioc->name,
6592                             __FILE__, __LINE__, __func__);
6593                         break;
6594                 }
6595
6596                 raid_device->id = ioc->sas_id++;
6597                 raid_device->channel = RAID_CHANNEL;
6598                 raid_device->handle = handle;
6599                 raid_device->wwid = wwid;
6600                 _scsih_raid_device_add(ioc, raid_device);
6601                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6602                     raid_device->id, 0);
6603                 if (rc)
6604                         _scsih_raid_device_remove(ioc, raid_device);
6605                 break;
6606
6607         case MPI2_RAID_VOL_STATE_INITIALIZING:
6608         default:
6609                 break;
6610         }
6611 }
6612
6613 /**
6614  * _scsih_sas_ir_physical_disk_event - PD event
6615  * @ioc: per adapter object
6616  * @fw_event: The fw_event_work object
6617  * Context: user.
6618  *
6619  * Return nothing.
6620  */
6621 static void
6622 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
6623         struct fw_event_work *fw_event)
6624 {
6625         u16 handle, parent_handle;
6626         u32 state;
6627         struct _sas_device *sas_device;
6628         Mpi2ConfigReply_t mpi_reply;
6629         Mpi2SasDevicePage0_t sas_device_pg0;
6630         u32 ioc_status;
6631         Mpi2EventDataIrPhysicalDisk_t *event_data =
6632                 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data;
6633         u64 sas_address;
6634
6635         if (ioc->shost_recovery)
6636                 return;
6637
6638         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
6639                 return;
6640
6641         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
6642         state = le32_to_cpu(event_data->NewValue);
6643
6644         if (!ioc->hide_ir_msg)
6645                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6646                     "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
6647                     ioc->name, __func__,  handle,
6648                     le32_to_cpu(event_data->PreviousValue), state));
6649
6650         switch (state) {
6651         case MPI2_RAID_PD_STATE_ONLINE:
6652         case MPI2_RAID_PD_STATE_DEGRADED:
6653         case MPI2_RAID_PD_STATE_REBUILDING:
6654         case MPI2_RAID_PD_STATE_OPTIMAL:
6655         case MPI2_RAID_PD_STATE_HOT_SPARE:
6656
6657                 if (!ioc->is_warpdrive)
6658                         set_bit(handle, ioc->pd_handles);
6659
6660                 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
6661                 if (sas_device) {
6662                         sas_device_put(sas_device);
6663                         return;
6664                 }
6665
6666                 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6667                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6668                     handle))) {
6669                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6670                             ioc->name, __FILE__, __LINE__, __func__);
6671                         return;
6672                 }
6673
6674                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6675                     MPI2_IOCSTATUS_MASK;
6676                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6677                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6678                             ioc->name, __FILE__, __LINE__, __func__);
6679                         return;
6680                 }
6681
6682                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6683                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6684                         mpt3sas_transport_update_links(ioc, sas_address, handle,
6685                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6686
6687                 _scsih_add_device(ioc, handle, 0, 1);
6688
6689                 break;
6690
6691         case MPI2_RAID_PD_STATE_OFFLINE:
6692         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
6693         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
6694         default:
6695                 break;
6696         }
6697 }
6698
6699 /**
6700  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
6701  * @ioc: per adapter object
6702  * @event_data: event data payload
6703  * Context: user.
6704  *
6705  * Return nothing.
6706  */
6707 static void
6708 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
6709         Mpi2EventDataIrOperationStatus_t *event_data)
6710 {
6711         char *reason_str = NULL;
6712
6713         switch (event_data->RAIDOperation) {
6714         case MPI2_EVENT_IR_RAIDOP_RESYNC:
6715                 reason_str = "resync";
6716                 break;
6717         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
6718                 reason_str = "online capacity expansion";
6719                 break;
6720         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
6721                 reason_str = "consistency check";
6722                 break;
6723         case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
6724                 reason_str = "background init";
6725                 break;
6726         case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
6727                 reason_str = "make data consistent";
6728                 break;
6729         }
6730
6731         if (!reason_str)
6732                 return;
6733
6734         pr_info(MPT3SAS_FMT "raid operational status: (%s)" \
6735             "\thandle(0x%04x), percent complete(%d)\n",
6736             ioc->name, reason_str,
6737             le16_to_cpu(event_data->VolDevHandle),
6738             event_data->PercentComplete);
6739 }
6740
6741 /**
6742  * _scsih_sas_ir_operation_status_event - handle RAID operation events
6743  * @ioc: per adapter object
6744  * @fw_event: The fw_event_work object
6745  * Context: user.
6746  *
6747  * Return nothing.
6748  */
6749 static void
6750 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
6751         struct fw_event_work *fw_event)
6752 {
6753         Mpi2EventDataIrOperationStatus_t *event_data =
6754                 (Mpi2EventDataIrOperationStatus_t *)
6755                 fw_event->event_data;
6756         static struct _raid_device *raid_device;
6757         unsigned long flags;
6758         u16 handle;
6759
6760         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
6761             (!ioc->hide_ir_msg))
6762                 _scsih_sas_ir_operation_status_event_debug(ioc,
6763                      event_data);
6764
6765         /* code added for raid transport support */
6766         if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
6767
6768                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6769                 handle = le16_to_cpu(event_data->VolDevHandle);
6770                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
6771                 if (raid_device)
6772                         raid_device->percent_complete =
6773                             event_data->PercentComplete;
6774                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6775         }
6776 }
6777
6778 /**
6779  * _scsih_prep_device_scan - initialize parameters prior to device scan
6780  * @ioc: per adapter object
6781  *
6782  * Set the deleted flag prior to device scan.  If the device is found during
6783  * the scan, then we clear the deleted flag.
6784  */
6785 static void
6786 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
6787 {
6788         struct MPT3SAS_DEVICE *sas_device_priv_data;
6789         struct scsi_device *sdev;
6790
6791         shost_for_each_device(sdev, ioc->shost) {
6792                 sas_device_priv_data = sdev->hostdata;
6793                 if (sas_device_priv_data && sas_device_priv_data->sas_target)
6794                         sas_device_priv_data->sas_target->deleted = 1;
6795         }
6796 }
6797
6798 /**
6799  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
6800  * @ioc: per adapter object
6801  * @sas_device_pg0: SAS Device page 0
6802  *
6803  * After host reset, find out whether devices are still responding.
6804  * Used in _scsih_remove_unresponsive_sas_devices.
6805  *
6806  * Return nothing.
6807  */
6808 static void
6809 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc,
6810 Mpi2SasDevicePage0_t *sas_device_pg0)
6811 {
6812         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
6813         struct scsi_target *starget;
6814         struct _sas_device *sas_device;
6815         unsigned long flags;
6816
6817         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6818         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
6819                 if ((sas_device->sas_address == sas_device_pg0->SASAddress) &&
6820                         (sas_device->slot == sas_device_pg0->Slot)) {
6821                         sas_device->responding = 1;
6822                         starget = sas_device->starget;
6823                         if (starget && starget->hostdata) {
6824                                 sas_target_priv_data = starget->hostdata;
6825                                 sas_target_priv_data->tm_busy = 0;
6826                                 sas_target_priv_data->deleted = 0;
6827                         } else
6828                                 sas_target_priv_data = NULL;
6829                         if (starget) {
6830                                 starget_printk(KERN_INFO, starget,
6831                                     "handle(0x%04x), sas_addr(0x%016llx)\n",
6832                                     sas_device_pg0->DevHandle,
6833                                     (unsigned long long)
6834                                     sas_device->sas_address);
6835
6836                                 if (sas_device->enclosure_handle != 0)
6837                                         starget_printk(KERN_INFO, starget,
6838                                          "enclosure logical id(0x%016llx),"
6839                                          " slot(%d)\n",
6840                                          (unsigned long long)
6841                                          sas_device->enclosure_logical_id,
6842                                          sas_device->slot);
6843                         }
6844                         if (sas_device_pg0->Flags &
6845                               MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
6846                                 sas_device->enclosure_level =
6847                                    le16_to_cpu(sas_device_pg0->EnclosureLevel);
6848                                 memcpy(&sas_device->connector_name[0],
6849                                         &sas_device_pg0->ConnectorName[0], 4);
6850                         } else {
6851                                 sas_device->enclosure_level = 0;
6852                                 sas_device->connector_name[0] = '\0';
6853                         }
6854
6855                         if (sas_device->handle == sas_device_pg0->DevHandle)
6856                                 goto out;
6857                         pr_info("\thandle changed from(0x%04x)!!!\n",
6858                             sas_device->handle);
6859                         sas_device->handle = sas_device_pg0->DevHandle;
6860                         if (sas_target_priv_data)
6861                                 sas_target_priv_data->handle =
6862                                         sas_device_pg0->DevHandle;
6863                         goto out;
6864                 }
6865         }
6866  out:
6867         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6868 }
6869
6870 /**
6871  * _scsih_search_responding_sas_devices -
6872  * @ioc: per adapter object
6873  *
6874  * After host reset, find out whether devices are still responding.
6875  * If not remove.
6876  *
6877  * Return nothing.
6878  */
6879 static void
6880 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
6881 {
6882         Mpi2SasDevicePage0_t sas_device_pg0;
6883         Mpi2ConfigReply_t mpi_reply;
6884         u16 ioc_status;
6885         u16 handle;
6886         u32 device_info;
6887
6888         pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name);
6889
6890         if (list_empty(&ioc->sas_device_list))
6891                 goto out;
6892
6893         handle = 0xFFFF;
6894         while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6895             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
6896             handle))) {
6897                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6898                     MPI2_IOCSTATUS_MASK;
6899                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
6900                         break;
6901                 handle = sas_device_pg0.DevHandle =
6902                                 le16_to_cpu(sas_device_pg0.DevHandle);
6903                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
6904                 if (!(_scsih_is_end_device(device_info)))
6905                         continue;
6906                 sas_device_pg0.SASAddress =
6907                                 le64_to_cpu(sas_device_pg0.SASAddress);
6908                 sas_device_pg0.Slot = le16_to_cpu(sas_device_pg0.Slot);
6909                 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0);
6910         }
6911
6912  out:
6913         pr_info(MPT3SAS_FMT "search for end-devices: complete\n",
6914             ioc->name);
6915 }
6916
6917 /**
6918  * _scsih_mark_responding_raid_device - mark a raid_device as responding
6919  * @ioc: per adapter object
6920  * @wwid: world wide identifier for raid volume
6921  * @handle: device handle
6922  *
6923  * After host reset, find out whether devices are still responding.
6924  * Used in _scsih_remove_unresponsive_raid_devices.
6925  *
6926  * Return nothing.
6927  */
6928 static void
6929 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
6930         u16 handle)
6931 {
6932         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
6933         struct scsi_target *starget;
6934         struct _raid_device *raid_device;
6935         unsigned long flags;
6936
6937         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6938         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
6939                 if (raid_device->wwid == wwid && raid_device->starget) {
6940                         starget = raid_device->starget;
6941                         if (starget && starget->hostdata) {
6942                                 sas_target_priv_data = starget->hostdata;
6943                                 sas_target_priv_data->deleted = 0;
6944                         } else
6945                                 sas_target_priv_data = NULL;
6946                         raid_device->responding = 1;
6947                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6948                         starget_printk(KERN_INFO, raid_device->starget,
6949                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
6950                             (unsigned long long)raid_device->wwid);
6951
6952                         /*
6953                          * WARPDRIVE: The handles of the PDs might have changed
6954                          * across the host reset so re-initialize the
6955                          * required data for Direct IO
6956                          */
6957                         mpt3sas_init_warpdrive_properties(ioc, raid_device);
6958                         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6959                         if (raid_device->handle == handle) {
6960                                 spin_unlock_irqrestore(&ioc->raid_device_lock,
6961                                     flags);
6962                                 return;
6963                         }
6964                         pr_info("\thandle changed from(0x%04x)!!!\n",
6965                             raid_device->handle);
6966                         raid_device->handle = handle;
6967                         if (sas_target_priv_data)
6968                                 sas_target_priv_data->handle = handle;
6969                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6970                         return;
6971                 }
6972         }
6973         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6974 }
6975
6976 /**
6977  * _scsih_search_responding_raid_devices -
6978  * @ioc: per adapter object
6979  *
6980  * After host reset, find out whether devices are still responding.
6981  * If not remove.
6982  *
6983  * Return nothing.
6984  */
6985 static void
6986 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
6987 {
6988         Mpi2RaidVolPage1_t volume_pg1;
6989         Mpi2RaidVolPage0_t volume_pg0;
6990         Mpi2RaidPhysDiskPage0_t pd_pg0;
6991         Mpi2ConfigReply_t mpi_reply;
6992         u16 ioc_status;
6993         u16 handle;
6994         u8 phys_disk_num;
6995
6996         if (!ioc->ir_firmware)
6997                 return;
6998
6999         pr_info(MPT3SAS_FMT "search for raid volumes: start\n",
7000             ioc->name);
7001
7002         if (list_empty(&ioc->raid_device_list))
7003                 goto out;
7004
7005         handle = 0xFFFF;
7006         while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
7007             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
7008                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7009                     MPI2_IOCSTATUS_MASK;
7010                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7011                         break;
7012                 handle = le16_to_cpu(volume_pg1.DevHandle);
7013
7014                 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
7015                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
7016                      sizeof(Mpi2RaidVolPage0_t)))
7017                         continue;
7018
7019                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
7020                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
7021                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
7022                         _scsih_mark_responding_raid_device(ioc,
7023                             le64_to_cpu(volume_pg1.WWID), handle);
7024         }
7025
7026         /* refresh the pd_handles */
7027         if (!ioc->is_warpdrive) {
7028                 phys_disk_num = 0xFF;
7029                 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
7030                 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
7031                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
7032                     phys_disk_num))) {
7033                         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7034                             MPI2_IOCSTATUS_MASK;
7035                         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7036                                 break;
7037                         phys_disk_num = pd_pg0.PhysDiskNum;
7038                         handle = le16_to_cpu(pd_pg0.DevHandle);
7039                         set_bit(handle, ioc->pd_handles);
7040                 }
7041         }
7042  out:
7043         pr_info(MPT3SAS_FMT "search for responding raid volumes: complete\n",
7044                 ioc->name);
7045 }
7046
7047 /**
7048  * _scsih_mark_responding_expander - mark a expander as responding
7049  * @ioc: per adapter object
7050  * @sas_address: sas address
7051  * @handle:
7052  *
7053  * After host reset, find out whether devices are still responding.
7054  * Used in _scsih_remove_unresponsive_expanders.
7055  *
7056  * Return nothing.
7057  */
7058 static void
7059 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
7060         u16 handle)
7061 {
7062         struct _sas_node *sas_expander;
7063         unsigned long flags;
7064         int i;
7065
7066         spin_lock_irqsave(&ioc->sas_node_lock, flags);
7067         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
7068                 if (sas_expander->sas_address != sas_address)
7069                         continue;
7070                 sas_expander->responding = 1;
7071                 if (sas_expander->handle == handle)
7072                         goto out;
7073                 pr_info("\texpander(0x%016llx): handle changed" \
7074                     " from(0x%04x) to (0x%04x)!!!\n",
7075                     (unsigned long long)sas_expander->sas_address,
7076                     sas_expander->handle, handle);
7077                 sas_expander->handle = handle;
7078                 for (i = 0 ; i < sas_expander->num_phys ; i++)
7079                         sas_expander->phy[i].handle = handle;
7080                 goto out;
7081         }
7082  out:
7083         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7084 }
7085
7086 /**
7087  * _scsih_search_responding_expanders -
7088  * @ioc: per adapter object
7089  *
7090  * After host reset, find out whether devices are still responding.
7091  * If not remove.
7092  *
7093  * Return nothing.
7094  */
7095 static void
7096 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
7097 {
7098         Mpi2ExpanderPage0_t expander_pg0;
7099         Mpi2ConfigReply_t mpi_reply;
7100         u16 ioc_status;
7101         u64 sas_address;
7102         u16 handle;
7103
7104         pr_info(MPT3SAS_FMT "search for expanders: start\n", ioc->name);
7105
7106         if (list_empty(&ioc->sas_expander_list))
7107                 goto out;
7108
7109         handle = 0xFFFF;
7110         while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
7111             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
7112
7113                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7114                     MPI2_IOCSTATUS_MASK;
7115                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7116                         break;
7117
7118                 handle = le16_to_cpu(expander_pg0.DevHandle);
7119                 sas_address = le64_to_cpu(expander_pg0.SASAddress);
7120                 pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n",
7121                         handle,
7122                     (unsigned long long)sas_address);
7123                 _scsih_mark_responding_expander(ioc, sas_address, handle);
7124         }
7125
7126  out:
7127         pr_info(MPT3SAS_FMT "search for expanders: complete\n", ioc->name);
7128 }
7129
7130 /**
7131  * _scsih_remove_unresponding_sas_devices - removing unresponding devices
7132  * @ioc: per adapter object
7133  *
7134  * Return nothing.
7135  */
7136 static void
7137 _scsih_remove_unresponding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
7138 {
7139         struct _sas_device *sas_device, *sas_device_next;
7140         struct _sas_node *sas_expander, *sas_expander_next;
7141         struct _raid_device *raid_device, *raid_device_next;
7142         struct list_head tmp_list;
7143         unsigned long flags;
7144         LIST_HEAD(head);
7145
7146         pr_info(MPT3SAS_FMT "removing unresponding devices: start\n",
7147             ioc->name);
7148
7149         /* removing unresponding end devices */
7150         pr_info(MPT3SAS_FMT "removing unresponding devices: end-devices\n",
7151             ioc->name);
7152         /*
7153          * Iterate, pulling off devices marked as non-responding. We become the
7154          * owner for the reference the list had on any object we prune.
7155          */
7156         spin_lock_irqsave(&ioc->sas_device_lock, flags);
7157         list_for_each_entry_safe(sas_device, sas_device_next,
7158             &ioc->sas_device_list, list) {
7159                 if (!sas_device->responding)
7160                         list_move_tail(&sas_device->list, &head);
7161                 else
7162                         sas_device->responding = 0;
7163         }
7164         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7165
7166         /*
7167          * Now, uninitialize and remove the unresponding devices we pruned.
7168          */
7169         list_for_each_entry_safe(sas_device, sas_device_next, &head, list) {
7170                 _scsih_remove_device(ioc, sas_device);
7171                 list_del_init(&sas_device->list);
7172                 sas_device_put(sas_device);
7173         }
7174
7175         /* removing unresponding volumes */
7176         if (ioc->ir_firmware) {
7177                 pr_info(MPT3SAS_FMT "removing unresponding devices: volumes\n",
7178                         ioc->name);
7179                 list_for_each_entry_safe(raid_device, raid_device_next,
7180                     &ioc->raid_device_list, list) {
7181                         if (!raid_device->responding)
7182                                 _scsih_sas_volume_delete(ioc,
7183                                     raid_device->handle);
7184                         else
7185                                 raid_device->responding = 0;
7186                 }
7187         }
7188
7189         /* removing unresponding expanders */
7190         pr_info(MPT3SAS_FMT "removing unresponding devices: expanders\n",
7191             ioc->name);
7192         spin_lock_irqsave(&ioc->sas_node_lock, flags);
7193         INIT_LIST_HEAD(&tmp_list);
7194         list_for_each_entry_safe(sas_expander, sas_expander_next,
7195             &ioc->sas_expander_list, list) {
7196                 if (!sas_expander->responding)
7197                         list_move_tail(&sas_expander->list, &tmp_list);
7198                 else
7199                         sas_expander->responding = 0;
7200         }
7201         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7202         list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
7203             list) {
7204                 list_del(&sas_expander->list);
7205                 _scsih_expander_node_remove(ioc, sas_expander);
7206         }
7207
7208         pr_info(MPT3SAS_FMT "removing unresponding devices: complete\n",
7209             ioc->name);
7210
7211         /* unblock devices */
7212         _scsih_ublock_io_all_device(ioc);
7213 }
7214
7215 static void
7216 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
7217         struct _sas_node *sas_expander, u16 handle)
7218 {
7219         Mpi2ExpanderPage1_t expander_pg1;
7220         Mpi2ConfigReply_t mpi_reply;
7221         int i;
7222
7223         for (i = 0 ; i < sas_expander->num_phys ; i++) {
7224                 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
7225                     &expander_pg1, i, handle))) {
7226                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7227                             ioc->name, __FILE__, __LINE__, __func__);
7228                         return;
7229                 }
7230
7231                 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
7232                     le16_to_cpu(expander_pg1.AttachedDevHandle), i,
7233                     expander_pg1.NegotiatedLinkRate >> 4);
7234         }
7235 }
7236
7237 /**
7238  * _scsih_scan_for_devices_after_reset - scan for devices after host reset
7239  * @ioc: per adapter object
7240  *
7241  * Return nothing.
7242  */
7243 static void
7244 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
7245 {
7246         Mpi2ExpanderPage0_t expander_pg0;
7247         Mpi2SasDevicePage0_t sas_device_pg0;
7248         Mpi2RaidVolPage1_t volume_pg1;
7249         Mpi2RaidVolPage0_t volume_pg0;
7250         Mpi2RaidPhysDiskPage0_t pd_pg0;
7251         Mpi2EventIrConfigElement_t element;
7252         Mpi2ConfigReply_t mpi_reply;
7253         u8 phys_disk_num;
7254         u16 ioc_status;
7255         u16 handle, parent_handle;
7256         u64 sas_address;
7257         struct _sas_device *sas_device;
7258         struct _sas_node *expander_device;
7259         static struct _raid_device *raid_device;
7260         u8 retry_count;
7261         unsigned long flags;
7262
7263         pr_info(MPT3SAS_FMT "scan devices: start\n", ioc->name);
7264
7265         _scsih_sas_host_refresh(ioc);
7266
7267         pr_info(MPT3SAS_FMT "\tscan devices: expanders start\n", ioc->name);
7268
7269         /* expanders */
7270         handle = 0xFFFF;
7271         while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
7272             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
7273                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7274                     MPI2_IOCSTATUS_MASK;
7275                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7276                         pr_info(MPT3SAS_FMT "\tbreak from expander scan: " \
7277                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7278                             ioc->name, ioc_status,
7279                             le32_to_cpu(mpi_reply.IOCLogInfo));
7280                         break;
7281                 }
7282                 handle = le16_to_cpu(expander_pg0.DevHandle);
7283                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
7284                 expander_device = mpt3sas_scsih_expander_find_by_sas_address(
7285                     ioc, le64_to_cpu(expander_pg0.SASAddress));
7286                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7287                 if (expander_device)
7288                         _scsih_refresh_expander_links(ioc, expander_device,
7289                             handle);
7290                 else {
7291                         pr_info(MPT3SAS_FMT "\tBEFORE adding expander: " \
7292                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7293                             handle, (unsigned long long)
7294                             le64_to_cpu(expander_pg0.SASAddress));
7295                         _scsih_expander_add(ioc, handle);
7296                         pr_info(MPT3SAS_FMT "\tAFTER adding expander: " \
7297                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7298                             handle, (unsigned long long)
7299                             le64_to_cpu(expander_pg0.SASAddress));
7300                 }
7301         }
7302
7303         pr_info(MPT3SAS_FMT "\tscan devices: expanders complete\n",
7304             ioc->name);
7305
7306         if (!ioc->ir_firmware)
7307                 goto skip_to_sas;
7308
7309         pr_info(MPT3SAS_FMT "\tscan devices: phys disk start\n", ioc->name);
7310
7311         /* phys disk */
7312         phys_disk_num = 0xFF;
7313         while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
7314             &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
7315             phys_disk_num))) {
7316                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7317                     MPI2_IOCSTATUS_MASK;
7318                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7319                         pr_info(MPT3SAS_FMT "\tbreak from phys disk scan: "\
7320                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7321                             ioc->name, ioc_status,
7322                             le32_to_cpu(mpi_reply.IOCLogInfo));
7323                         break;
7324                 }
7325                 phys_disk_num = pd_pg0.PhysDiskNum;
7326                 handle = le16_to_cpu(pd_pg0.DevHandle);
7327                 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
7328                 if (sas_device) {
7329                         sas_device_put(sas_device);
7330                         continue;
7331                 }
7332                 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7333                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
7334                     handle) != 0)
7335                         continue;
7336                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7337                     MPI2_IOCSTATUS_MASK;
7338                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7339                         pr_info(MPT3SAS_FMT "\tbreak from phys disk scan " \
7340                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7341                             ioc->name, ioc_status,
7342                             le32_to_cpu(mpi_reply.IOCLogInfo));
7343                         break;
7344                 }
7345                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
7346                 if (!_scsih_get_sas_address(ioc, parent_handle,
7347                     &sas_address)) {
7348                         pr_info(MPT3SAS_FMT "\tBEFORE adding phys disk: " \
7349                             " handle (0x%04x), sas_addr(0x%016llx)\n",
7350                             ioc->name, handle, (unsigned long long)
7351                             le64_to_cpu(sas_device_pg0.SASAddress));
7352                         mpt3sas_transport_update_links(ioc, sas_address,
7353                             handle, sas_device_pg0.PhyNum,
7354                             MPI2_SAS_NEG_LINK_RATE_1_5);
7355                         set_bit(handle, ioc->pd_handles);
7356                         retry_count = 0;
7357                         /* This will retry adding the end device.
7358                          * _scsih_add_device() will decide on retries and
7359                          * return "1" when it should be retried
7360                          */
7361                         while (_scsih_add_device(ioc, handle, retry_count++,
7362                             1)) {
7363                                 ssleep(1);
7364                         }
7365                         pr_info(MPT3SAS_FMT "\tAFTER adding phys disk: " \
7366                             " handle (0x%04x), sas_addr(0x%016llx)\n",
7367                             ioc->name, handle, (unsigned long long)
7368                             le64_to_cpu(sas_device_pg0.SASAddress));
7369                 }
7370         }
7371
7372         pr_info(MPT3SAS_FMT "\tscan devices: phys disk complete\n",
7373             ioc->name);
7374
7375         pr_info(MPT3SAS_FMT "\tscan devices: volumes start\n", ioc->name);
7376
7377         /* volumes */
7378         handle = 0xFFFF;
7379         while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
7380             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
7381                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7382                     MPI2_IOCSTATUS_MASK;
7383                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7384                         pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
7385                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7386                             ioc->name, ioc_status,
7387                             le32_to_cpu(mpi_reply.IOCLogInfo));
7388                         break;
7389                 }
7390                 handle = le16_to_cpu(volume_pg1.DevHandle);
7391                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
7392                 raid_device = _scsih_raid_device_find_by_wwid(ioc,
7393                     le64_to_cpu(volume_pg1.WWID));
7394                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7395                 if (raid_device)
7396                         continue;
7397                 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
7398                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
7399                      sizeof(Mpi2RaidVolPage0_t)))
7400                         continue;
7401                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7402                     MPI2_IOCSTATUS_MASK;
7403                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7404                         pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
7405                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7406                             ioc->name, ioc_status,
7407                             le32_to_cpu(mpi_reply.IOCLogInfo));
7408                         break;
7409                 }
7410                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
7411                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
7412                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) {
7413                         memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
7414                         element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
7415                         element.VolDevHandle = volume_pg1.DevHandle;
7416                         pr_info(MPT3SAS_FMT
7417                                 "\tBEFORE adding volume: handle (0x%04x)\n",
7418                                 ioc->name, volume_pg1.DevHandle);
7419                         _scsih_sas_volume_add(ioc, &element);
7420                         pr_info(MPT3SAS_FMT
7421                                 "\tAFTER adding volume: handle (0x%04x)\n",
7422                                 ioc->name, volume_pg1.DevHandle);
7423                 }
7424         }
7425
7426         pr_info(MPT3SAS_FMT "\tscan devices: volumes complete\n",
7427             ioc->name);
7428
7429  skip_to_sas:
7430
7431         pr_info(MPT3SAS_FMT "\tscan devices: end devices start\n",
7432             ioc->name);
7433
7434         /* sas devices */
7435         handle = 0xFFFF;
7436         while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7437             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
7438             handle))) {
7439                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7440                     MPI2_IOCSTATUS_MASK;
7441                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7442                         pr_info(MPT3SAS_FMT "\tbreak from end device scan:"\
7443                             " ioc_status(0x%04x), loginfo(0x%08x)\n",
7444                             ioc->name, ioc_status,
7445                             le32_to_cpu(mpi_reply.IOCLogInfo));
7446                         break;
7447                 }
7448                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
7449                 if (!(_scsih_is_end_device(
7450                     le32_to_cpu(sas_device_pg0.DeviceInfo))))
7451                         continue;
7452                 sas_device = mpt3sas_get_sdev_by_addr(ioc,
7453                     le64_to_cpu(sas_device_pg0.SASAddress));
7454                 if (sas_device) {
7455                         sas_device_put(sas_device);
7456                         continue;
7457                 }
7458                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
7459                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
7460                         pr_info(MPT3SAS_FMT "\tBEFORE adding end device: " \
7461                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7462                             handle, (unsigned long long)
7463                             le64_to_cpu(sas_device_pg0.SASAddress));
7464                         mpt3sas_transport_update_links(ioc, sas_address, handle,
7465                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
7466                         retry_count = 0;
7467                         /* This will retry adding the end device.
7468                          * _scsih_add_device() will decide on retries and
7469                          * return "1" when it should be retried
7470                          */
7471                         while (_scsih_add_device(ioc, handle, retry_count++,
7472                             0)) {
7473                                 ssleep(1);
7474                         }
7475                         pr_info(MPT3SAS_FMT "\tAFTER adding end device: " \
7476                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7477                             handle, (unsigned long long)
7478                             le64_to_cpu(sas_device_pg0.SASAddress));
7479                 }
7480         }
7481         pr_info(MPT3SAS_FMT "\tscan devices: end devices complete\n",
7482             ioc->name);
7483
7484         pr_info(MPT3SAS_FMT "scan devices: complete\n", ioc->name);
7485 }
7486 /**
7487  * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
7488  * @ioc: per adapter object
7489  * @reset_phase: phase
7490  *
7491  * The handler for doing any required cleanup or initialization.
7492  *
7493  * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
7494  * MPT3_IOC_DONE_RESET
7495  *
7496  * Return nothing.
7497  */
7498 void
7499 mpt3sas_scsih_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase)
7500 {
7501         switch (reset_phase) {
7502         case MPT3_IOC_PRE_RESET:
7503                 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7504                         "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
7505                 break;
7506         case MPT3_IOC_AFTER_RESET:
7507                 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7508                         "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
7509                 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
7510                         ioc->scsih_cmds.status |= MPT3_CMD_RESET;
7511                         mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
7512                         complete(&ioc->scsih_cmds.done);
7513                 }
7514                 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
7515                         ioc->tm_cmds.status |= MPT3_CMD_RESET;
7516                         mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
7517                         complete(&ioc->tm_cmds.done);
7518                 }
7519
7520                 _scsih_fw_event_cleanup_queue(ioc);
7521                 _scsih_flush_running_cmds(ioc);
7522                 break;
7523         case MPT3_IOC_DONE_RESET:
7524                 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7525                         "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
7526                 if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
7527                     !ioc->sas_hba.num_phys)) {
7528                         _scsih_prep_device_scan(ioc);
7529                         _scsih_search_responding_sas_devices(ioc);
7530                         _scsih_search_responding_raid_devices(ioc);
7531                         _scsih_search_responding_expanders(ioc);
7532                         _scsih_error_recovery_delete_devices(ioc);
7533                 }
7534                 break;
7535         }
7536 }
7537
7538 /**
7539  * _mpt3sas_fw_work - delayed task for processing firmware events
7540  * @ioc: per adapter object
7541  * @fw_event: The fw_event_work object
7542  * Context: user.
7543  *
7544  * Return nothing.
7545  */
7546 static void
7547 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
7548 {
7549         _scsih_fw_event_del_from_list(ioc, fw_event);
7550
7551         /* the queue is being flushed so ignore this event */
7552         if (ioc->remove_host || ioc->pci_error_recovery) {
7553                 fw_event_work_put(fw_event);
7554                 return;
7555         }
7556
7557         switch (fw_event->event) {
7558         case MPT3SAS_PROCESS_TRIGGER_DIAG:
7559                 mpt3sas_process_trigger_data(ioc,
7560                         (struct SL_WH_TRIGGERS_EVENT_DATA_T *)
7561                         fw_event->event_data);
7562                 break;
7563         case MPT3SAS_REMOVE_UNRESPONDING_DEVICES:
7564                 while (scsi_host_in_recovery(ioc->shost) ||
7565                                          ioc->shost_recovery) {
7566                         /*
7567                          * If we're unloading, bail. Otherwise, this can become
7568                          * an infinite loop.
7569                          */
7570                         if (ioc->remove_host)
7571                                 goto out;
7572                         ssleep(1);
7573                 }
7574                 _scsih_remove_unresponding_sas_devices(ioc);
7575                 _scsih_scan_for_devices_after_reset(ioc);
7576                 break;
7577         case MPT3SAS_PORT_ENABLE_COMPLETE:
7578                 ioc->start_scan = 0;
7579         if (missing_delay[0] != -1 && missing_delay[1] != -1)
7580                         mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
7581                             missing_delay[1]);
7582                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
7583                         "port enable: complete from worker thread\n",
7584                         ioc->name));
7585                 break;
7586         case MPT3SAS_TURN_ON_PFA_LED:
7587                 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
7588                 break;
7589         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
7590                 _scsih_sas_topology_change_event(ioc, fw_event);
7591                 break;
7592         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
7593                 _scsih_sas_device_status_change_event(ioc, fw_event);
7594                 break;
7595         case MPI2_EVENT_SAS_DISCOVERY:
7596                 _scsih_sas_discovery_event(ioc, fw_event);
7597                 break;
7598         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
7599                 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
7600                 break;
7601         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
7602                 _scsih_sas_enclosure_dev_status_change_event(ioc,
7603                     fw_event);
7604                 break;
7605         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
7606                 _scsih_sas_ir_config_change_event(ioc, fw_event);
7607                 break;
7608         case MPI2_EVENT_IR_VOLUME:
7609                 _scsih_sas_ir_volume_event(ioc, fw_event);
7610                 break;
7611         case MPI2_EVENT_IR_PHYSICAL_DISK:
7612                 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
7613                 break;
7614         case MPI2_EVENT_IR_OPERATION_STATUS:
7615                 _scsih_sas_ir_operation_status_event(ioc, fw_event);
7616                 break;
7617         }
7618 out:
7619         fw_event_work_put(fw_event);
7620 }
7621
7622 /**
7623  * _firmware_event_work
7624  * @ioc: per adapter object
7625  * @work: The fw_event_work object
7626  * Context: user.
7627  *
7628  * wrappers for the work thread handling firmware events
7629  *
7630  * Return nothing.
7631  */
7632
7633 static void
7634 _firmware_event_work(struct work_struct *work)
7635 {
7636         struct fw_event_work *fw_event = container_of(work,
7637             struct fw_event_work, work);
7638
7639         _mpt3sas_fw_work(fw_event->ioc, fw_event);
7640 }
7641
7642 /**
7643  * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time)
7644  * @ioc: per adapter object
7645  * @msix_index: MSIX table index supplied by the OS
7646  * @reply: reply message frame(lower 32bit addr)
7647  * Context: interrupt.
7648  *
7649  * This function merely adds a new work task into ioc->firmware_event_thread.
7650  * The tasks are worked from _firmware_event_work in user context.
7651  *
7652  * Return 1 meaning mf should be freed from _base_interrupt
7653  *        0 means the mf is freed from this function.
7654  */
7655 u8
7656 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
7657         u32 reply)
7658 {
7659         struct fw_event_work *fw_event;
7660         Mpi2EventNotificationReply_t *mpi_reply;
7661         u16 event;
7662         u16 sz;
7663
7664         /* events turned off due to host reset or driver unloading */
7665         if (ioc->remove_host || ioc->pci_error_recovery)
7666                 return 1;
7667
7668         mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
7669
7670         if (unlikely(!mpi_reply)) {
7671                 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
7672                     ioc->name, __FILE__, __LINE__, __func__);
7673                 return 1;
7674         }
7675
7676         event = le16_to_cpu(mpi_reply->Event);
7677
7678         if (event != MPI2_EVENT_LOG_ENTRY_ADDED)
7679                 mpt3sas_trigger_event(ioc, event, 0);
7680
7681         switch (event) {
7682         /* handle these */
7683         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
7684         {
7685                 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
7686                     (Mpi2EventDataSasBroadcastPrimitive_t *)
7687                     mpi_reply->EventData;
7688
7689                 if (baen_data->Primitive !=
7690                     MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
7691                         return 1;
7692
7693                 if (ioc->broadcast_aen_busy) {
7694                         ioc->broadcast_aen_pending++;
7695                         return 1;
7696                 } else
7697                         ioc->broadcast_aen_busy = 1;
7698                 break;
7699         }
7700
7701         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
7702                 _scsih_check_topo_delete_events(ioc,
7703                     (Mpi2EventDataSasTopologyChangeList_t *)
7704                     mpi_reply->EventData);
7705                 break;
7706         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
7707                 _scsih_check_ir_config_unhide_events(ioc,
7708                     (Mpi2EventDataIrConfigChangeList_t *)
7709                     mpi_reply->EventData);
7710                 break;
7711         case MPI2_EVENT_IR_VOLUME:
7712                 _scsih_check_volume_delete_events(ioc,
7713                     (Mpi2EventDataIrVolume_t *)
7714                     mpi_reply->EventData);
7715                 break;
7716         case MPI2_EVENT_LOG_ENTRY_ADDED:
7717         {
7718                 Mpi2EventDataLogEntryAdded_t *log_entry;
7719                 u32 *log_code;
7720
7721                 if (!ioc->is_warpdrive)
7722                         break;
7723
7724                 log_entry = (Mpi2EventDataLogEntryAdded_t *)
7725                     mpi_reply->EventData;
7726                 log_code = (u32 *)log_entry->LogData;
7727
7728                 if (le16_to_cpu(log_entry->LogEntryQualifier)
7729                     != MPT2_WARPDRIVE_LOGENTRY)
7730                         break;
7731
7732                 switch (le32_to_cpu(*log_code)) {
7733                 case MPT2_WARPDRIVE_LC_SSDT:
7734                         pr_warn(MPT3SAS_FMT "WarpDrive Warning: "
7735                             "IO Throttling has occurred in the WarpDrive "
7736                             "subsystem. Check WarpDrive documentation for "
7737                             "additional details.\n", ioc->name);
7738                         break;
7739                 case MPT2_WARPDRIVE_LC_SSDLW:
7740                         pr_warn(MPT3SAS_FMT "WarpDrive Warning: "
7741                             "Program/Erase Cycles for the WarpDrive subsystem "
7742                             "in degraded range. Check WarpDrive documentation "
7743                             "for additional details.\n", ioc->name);
7744                         break;
7745                 case MPT2_WARPDRIVE_LC_SSDLF:
7746                         pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: "
7747                             "There are no Program/Erase Cycles for the "
7748                             "WarpDrive subsystem. The storage device will be "
7749                             "in read-only mode. Check WarpDrive documentation "
7750                             "for additional details.\n", ioc->name);
7751                         break;
7752                 case MPT2_WARPDRIVE_LC_BRMF:
7753                         pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: "
7754                             "The Backup Rail Monitor has failed on the "
7755                             "WarpDrive subsystem. Check WarpDrive "
7756                             "documentation for additional details.\n",
7757                             ioc->name);
7758                         break;
7759                 }
7760
7761                 break;
7762         }
7763         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
7764         case MPI2_EVENT_IR_OPERATION_STATUS:
7765         case MPI2_EVENT_SAS_DISCOVERY:
7766         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
7767         case MPI2_EVENT_IR_PHYSICAL_DISK:
7768                 break;
7769
7770         case MPI2_EVENT_TEMP_THRESHOLD:
7771                 _scsih_temp_threshold_events(ioc,
7772                         (Mpi2EventDataTemperature_t *)
7773                         mpi_reply->EventData);
7774                 break;
7775
7776         default: /* ignore the rest */
7777                 return 1;
7778         }
7779
7780         sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
7781         fw_event = alloc_fw_event_work(sz);
7782         if (!fw_event) {
7783                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7784                     ioc->name, __FILE__, __LINE__, __func__);
7785                 return 1;
7786         }
7787
7788         memcpy(fw_event->event_data, mpi_reply->EventData, sz);
7789         fw_event->ioc = ioc;
7790         fw_event->VF_ID = mpi_reply->VF_ID;
7791         fw_event->VP_ID = mpi_reply->VP_ID;
7792         fw_event->event = event;
7793         _scsih_fw_event_add(ioc, fw_event);
7794         fw_event_work_put(fw_event);
7795         return 1;
7796 }
7797
7798 /**
7799  * _scsih_expander_node_remove - removing expander device from list.
7800  * @ioc: per adapter object
7801  * @sas_expander: the sas_device object
7802  * Context: Calling function should acquire ioc->sas_node_lock.
7803  *
7804  * Removing object and freeing associated memory from the
7805  * ioc->sas_expander_list.
7806  *
7807  * Return nothing.
7808  */
7809 static void
7810 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
7811         struct _sas_node *sas_expander)
7812 {
7813         struct _sas_port *mpt3sas_port, *next;
7814
7815         /* remove sibling ports attached to this expander */
7816         list_for_each_entry_safe(mpt3sas_port, next,
7817            &sas_expander->sas_port_list, port_list) {
7818                 if (ioc->shost_recovery)
7819                         return;
7820                 if (mpt3sas_port->remote_identify.device_type ==
7821                     SAS_END_DEVICE)
7822                         mpt3sas_device_remove_by_sas_address(ioc,
7823                             mpt3sas_port->remote_identify.sas_address);
7824                 else if (mpt3sas_port->remote_identify.device_type ==
7825                     SAS_EDGE_EXPANDER_DEVICE ||
7826                     mpt3sas_port->remote_identify.device_type ==
7827                     SAS_FANOUT_EXPANDER_DEVICE)
7828                         mpt3sas_expander_remove(ioc,
7829                             mpt3sas_port->remote_identify.sas_address);
7830         }
7831
7832         mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
7833             sas_expander->sas_address_parent);
7834
7835         pr_info(MPT3SAS_FMT
7836                 "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
7837                 ioc->name,
7838             sas_expander->handle, (unsigned long long)
7839             sas_expander->sas_address);
7840
7841         kfree(sas_expander->phy);
7842         kfree(sas_expander);
7843 }
7844
7845 /**
7846  * _scsih_ir_shutdown - IR shutdown notification
7847  * @ioc: per adapter object
7848  *
7849  * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
7850  * the host system is shutting down.
7851  *
7852  * Return nothing.
7853  */
7854 static void
7855 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
7856 {
7857         Mpi2RaidActionRequest_t *mpi_request;
7858         Mpi2RaidActionReply_t *mpi_reply;
7859         u16 smid;
7860
7861         /* is IR firmware build loaded ? */
7862         if (!ioc->ir_firmware)
7863                 return;
7864
7865         /* are there any volumes ? */
7866         if (list_empty(&ioc->raid_device_list))
7867                 return;
7868
7869         mutex_lock(&ioc->scsih_cmds.mutex);
7870
7871         if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
7872                 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
7873                     ioc->name, __func__);
7874                 goto out;
7875         }
7876         ioc->scsih_cmds.status = MPT3_CMD_PENDING;
7877
7878         smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
7879         if (!smid) {
7880                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
7881                     ioc->name, __func__);
7882                 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7883                 goto out;
7884         }
7885
7886         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
7887         ioc->scsih_cmds.smid = smid;
7888         memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
7889
7890         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
7891         mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
7892
7893         if (!ioc->hide_ir_msg)
7894                 pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name);
7895         init_completion(&ioc->scsih_cmds.done);
7896         mpt3sas_base_put_smid_default(ioc, smid);
7897         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
7898
7899         if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
7900                 pr_err(MPT3SAS_FMT "%s: timeout\n",
7901                     ioc->name, __func__);
7902                 goto out;
7903         }
7904
7905         if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
7906                 mpi_reply = ioc->scsih_cmds.reply;
7907                 if (!ioc->hide_ir_msg)
7908                         pr_info(MPT3SAS_FMT "IR shutdown "
7909                            "(complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
7910                             ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
7911                             le32_to_cpu(mpi_reply->IOCLogInfo));
7912         }
7913
7914  out:
7915         ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
7916         mutex_unlock(&ioc->scsih_cmds.mutex);
7917 }
7918
7919 /**
7920  * scsih_remove - detach and remove add host
7921  * @pdev: PCI device struct
7922  *
7923  * Routine called when unloading the driver.
7924  * Return nothing.
7925  */
7926 void scsih_remove(struct pci_dev *pdev)
7927 {
7928         struct Scsi_Host *shost = pci_get_drvdata(pdev);
7929         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
7930         struct _sas_port *mpt3sas_port, *next_port;
7931         struct _raid_device *raid_device, *next;
7932         struct MPT3SAS_TARGET *sas_target_priv_data;
7933         struct workqueue_struct *wq;
7934         unsigned long flags;
7935
7936         ioc->remove_host = 1;
7937         _scsih_fw_event_cleanup_queue(ioc);
7938
7939         spin_lock_irqsave(&ioc->fw_event_lock, flags);
7940         wq = ioc->firmware_event_thread;
7941         ioc->firmware_event_thread = NULL;
7942         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
7943         if (wq)
7944                 destroy_workqueue(wq);
7945
7946         /* release all the volumes */
7947         _scsih_ir_shutdown(ioc);
7948         list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
7949             list) {
7950                 if (raid_device->starget) {
7951                         sas_target_priv_data =
7952                             raid_device->starget->hostdata;
7953                         sas_target_priv_data->deleted = 1;
7954                         scsi_remove_target(&raid_device->starget->dev);
7955                 }
7956                 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
7957                         ioc->name,  raid_device->handle,
7958                     (unsigned long long) raid_device->wwid);
7959                 _scsih_raid_device_remove(ioc, raid_device);
7960         }
7961
7962         /* free ports attached to the sas_host */
7963         list_for_each_entry_safe(mpt3sas_port, next_port,
7964            &ioc->sas_hba.sas_port_list, port_list) {
7965                 if (mpt3sas_port->remote_identify.device_type ==
7966                     SAS_END_DEVICE)
7967                         mpt3sas_device_remove_by_sas_address(ioc,
7968                             mpt3sas_port->remote_identify.sas_address);
7969                 else if (mpt3sas_port->remote_identify.device_type ==
7970                     SAS_EDGE_EXPANDER_DEVICE ||
7971                     mpt3sas_port->remote_identify.device_type ==
7972                     SAS_FANOUT_EXPANDER_DEVICE)
7973                         mpt3sas_expander_remove(ioc,
7974                             mpt3sas_port->remote_identify.sas_address);
7975         }
7976
7977         /* free phys attached to the sas_host */
7978         if (ioc->sas_hba.num_phys) {
7979                 kfree(ioc->sas_hba.phy);
7980                 ioc->sas_hba.phy = NULL;
7981                 ioc->sas_hba.num_phys = 0;
7982         }
7983
7984         sas_remove_host(shost);
7985         scsi_remove_host(shost);
7986         mpt3sas_base_detach(ioc);
7987         spin_lock(&gioc_lock);
7988         list_del(&ioc->list);
7989         spin_unlock(&gioc_lock);
7990         scsi_host_put(shost);
7991 }
7992
7993 /**
7994  * scsih_shutdown - routine call during system shutdown
7995  * @pdev: PCI device struct
7996  *
7997  * Return nothing.
7998  */
7999 void
8000 scsih_shutdown(struct pci_dev *pdev)
8001 {
8002         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8003         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8004         struct workqueue_struct *wq;
8005         unsigned long flags;
8006
8007         ioc->remove_host = 1;
8008         _scsih_fw_event_cleanup_queue(ioc);
8009
8010         spin_lock_irqsave(&ioc->fw_event_lock, flags);
8011         wq = ioc->firmware_event_thread;
8012         ioc->firmware_event_thread = NULL;
8013         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
8014         if (wq)
8015                 destroy_workqueue(wq);
8016
8017         _scsih_ir_shutdown(ioc);
8018         mpt3sas_base_detach(ioc);
8019 }
8020
8021
8022 /**
8023  * _scsih_probe_boot_devices - reports 1st device
8024  * @ioc: per adapter object
8025  *
8026  * If specified in bios page 2, this routine reports the 1st
8027  * device scsi-ml or sas transport for persistent boot device
8028  * purposes.  Please refer to function _scsih_determine_boot_device()
8029  */
8030 static void
8031 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
8032 {
8033         u8 is_raid;
8034         void *device;
8035         struct _sas_device *sas_device;
8036         struct _raid_device *raid_device;
8037         u16 handle;
8038         u64 sas_address_parent;
8039         u64 sas_address;
8040         unsigned long flags;
8041         int rc;
8042
8043          /* no Bios, return immediately */
8044         if (!ioc->bios_pg3.BiosVersion)
8045                 return;
8046
8047         device = NULL;
8048         is_raid = 0;
8049         if (ioc->req_boot_device.device) {
8050                 device =  ioc->req_boot_device.device;
8051                 is_raid = ioc->req_boot_device.is_raid;
8052         } else if (ioc->req_alt_boot_device.device) {
8053                 device =  ioc->req_alt_boot_device.device;
8054                 is_raid = ioc->req_alt_boot_device.is_raid;
8055         } else if (ioc->current_boot_device.device) {
8056                 device =  ioc->current_boot_device.device;
8057                 is_raid = ioc->current_boot_device.is_raid;
8058         }
8059
8060         if (!device)
8061                 return;
8062
8063         if (is_raid) {
8064                 raid_device = device;
8065                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
8066                     raid_device->id, 0);
8067                 if (rc)
8068                         _scsih_raid_device_remove(ioc, raid_device);
8069         } else {
8070                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
8071                 sas_device = device;
8072                 handle = sas_device->handle;
8073                 sas_address_parent = sas_device->sas_address_parent;
8074                 sas_address = sas_device->sas_address;
8075                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
8076                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8077
8078                 if (ioc->hide_drives)
8079                         return;
8080                 if (!mpt3sas_transport_port_add(ioc, handle,
8081                     sas_address_parent)) {
8082                         _scsih_sas_device_remove(ioc, sas_device);
8083                 } else if (!sas_device->starget) {
8084                         if (!ioc->is_driver_loading) {
8085                                 mpt3sas_transport_port_remove(ioc,
8086                                     sas_address,
8087                                     sas_address_parent);
8088                                 _scsih_sas_device_remove(ioc, sas_device);
8089                         }
8090                 }
8091         }
8092 }
8093
8094 /**
8095  * _scsih_probe_raid - reporting raid volumes to scsi-ml
8096  * @ioc: per adapter object
8097  *
8098  * Called during initial loading of the driver.
8099  */
8100 static void
8101 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
8102 {
8103         struct _raid_device *raid_device, *raid_next;
8104         int rc;
8105
8106         list_for_each_entry_safe(raid_device, raid_next,
8107             &ioc->raid_device_list, list) {
8108                 if (raid_device->starget)
8109                         continue;
8110                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
8111                     raid_device->id, 0);
8112                 if (rc)
8113                         _scsih_raid_device_remove(ioc, raid_device);
8114         }
8115 }
8116
8117 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc)
8118 {
8119         struct _sas_device *sas_device = NULL;
8120         unsigned long flags;
8121
8122         spin_lock_irqsave(&ioc->sas_device_lock, flags);
8123         if (!list_empty(&ioc->sas_device_init_list)) {
8124                 sas_device = list_first_entry(&ioc->sas_device_init_list,
8125                                 struct _sas_device, list);
8126                 sas_device_get(sas_device);
8127         }
8128         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8129
8130         return sas_device;
8131 }
8132
8133 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc,
8134                 struct _sas_device *sas_device)
8135 {
8136         unsigned long flags;
8137
8138         spin_lock_irqsave(&ioc->sas_device_lock, flags);
8139
8140         /*
8141          * Since we dropped the lock during the call to port_add(), we need to
8142          * be careful here that somebody else didn't move or delete this item
8143          * while we were busy with other things.
8144          *
8145          * If it was on the list, we need a put() for the reference the list
8146          * had. Either way, we need a get() for the destination list.
8147          */
8148         if (!list_empty(&sas_device->list)) {
8149                 list_del_init(&sas_device->list);
8150                 sas_device_put(sas_device);
8151         }
8152
8153         sas_device_get(sas_device);
8154         list_add_tail(&sas_device->list, &ioc->sas_device_list);
8155
8156         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8157 }
8158
8159 /**
8160  * _scsih_probe_sas - reporting sas devices to sas transport
8161  * @ioc: per adapter object
8162  *
8163  * Called during initial loading of the driver.
8164  */
8165 static void
8166 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
8167 {
8168         struct _sas_device *sas_device;
8169
8170         if (ioc->hide_drives)
8171                 return;
8172
8173         while ((sas_device = get_next_sas_device(ioc))) {
8174                 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
8175                     sas_device->sas_address_parent)) {
8176                         _scsih_sas_device_remove(ioc, sas_device);
8177                         sas_device_put(sas_device);
8178                         continue;
8179                 } else if (!sas_device->starget) {
8180                         /*
8181                          * When asyn scanning is enabled, its not possible to
8182                          * remove devices while scanning is turned on due to an
8183                          * oops in scsi_sysfs_add_sdev()->add_device()->
8184                          * sysfs_addrm_start()
8185                          */
8186                         if (!ioc->is_driver_loading) {
8187                                 mpt3sas_transport_port_remove(ioc,
8188                                     sas_device->sas_address,
8189                                     sas_device->sas_address_parent);
8190                                 _scsih_sas_device_remove(ioc, sas_device);
8191                                 sas_device_put(sas_device);
8192                                 continue;
8193                         }
8194                 }
8195                 sas_device_make_active(ioc, sas_device);
8196                 sas_device_put(sas_device);
8197         }
8198 }
8199
8200 /**
8201  * _scsih_probe_devices - probing for devices
8202  * @ioc: per adapter object
8203  *
8204  * Called during initial loading of the driver.
8205  */
8206 static void
8207 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
8208 {
8209         u16 volume_mapping_flags;
8210
8211         if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
8212                 return;  /* return when IOC doesn't support initiator mode */
8213
8214         _scsih_probe_boot_devices(ioc);
8215
8216         if (ioc->ir_firmware) {
8217                 volume_mapping_flags =
8218                     le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
8219                     MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
8220                 if (volume_mapping_flags ==
8221                     MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
8222                         _scsih_probe_raid(ioc);
8223                         _scsih_probe_sas(ioc);
8224                 } else {
8225                         _scsih_probe_sas(ioc);
8226                         _scsih_probe_raid(ioc);
8227                 }
8228         } else
8229                 _scsih_probe_sas(ioc);
8230 }
8231
8232 /**
8233  * scsih_scan_start - scsi lld callback for .scan_start
8234  * @shost: SCSI host pointer
8235  *
8236  * The shost has the ability to discover targets on its own instead
8237  * of scanning the entire bus.  In our implemention, we will kick off
8238  * firmware discovery.
8239  */
8240 void
8241 scsih_scan_start(struct Scsi_Host *shost)
8242 {
8243         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8244         int rc;
8245         if (diag_buffer_enable != -1 && diag_buffer_enable != 0)
8246                 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
8247
8248         if (disable_discovery > 0)
8249                 return;
8250
8251         ioc->start_scan = 1;
8252         rc = mpt3sas_port_enable(ioc);
8253
8254         if (rc != 0)
8255                 pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name);
8256 }
8257
8258 /**
8259  * scsih_scan_finished - scsi lld callback for .scan_finished
8260  * @shost: SCSI host pointer
8261  * @time: elapsed time of the scan in jiffies
8262  *
8263  * This function will be called periodicallyn until it returns 1 with the
8264  * scsi_host and the elapsed time of the scan in jiffies. In our implemention,
8265  * we wait for firmware discovery to complete, then return 1.
8266  */
8267 int
8268 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time)
8269 {
8270         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8271
8272         if (disable_discovery > 0) {
8273                 ioc->is_driver_loading = 0;
8274                 ioc->wait_for_discovery_to_complete = 0;
8275                 return 1;
8276         }
8277
8278         if (time >= (300 * HZ)) {
8279                 ioc->base_cmds.status = MPT3_CMD_NOT_USED;
8280                 pr_info(MPT3SAS_FMT
8281                         "port enable: FAILED with timeout (timeout=300s)\n",
8282                         ioc->name);
8283                 ioc->is_driver_loading = 0;
8284                 return 1;
8285         }
8286
8287         if (ioc->start_scan)
8288                 return 0;
8289
8290         if (ioc->start_scan_failed) {
8291                 pr_info(MPT3SAS_FMT
8292                         "port enable: FAILED with (ioc_status=0x%08x)\n",
8293                         ioc->name, ioc->start_scan_failed);
8294                 ioc->is_driver_loading = 0;
8295                 ioc->wait_for_discovery_to_complete = 0;
8296                 ioc->remove_host = 1;
8297                 return 1;
8298         }
8299
8300         pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name);
8301         ioc->base_cmds.status = MPT3_CMD_NOT_USED;
8302
8303         if (ioc->wait_for_discovery_to_complete) {
8304                 ioc->wait_for_discovery_to_complete = 0;
8305                 _scsih_probe_devices(ioc);
8306         }
8307         mpt3sas_base_start_watchdog(ioc);
8308         ioc->is_driver_loading = 0;
8309         return 1;
8310 }
8311
8312 /* shost template for SAS 2.0 HBA devices */
8313 static struct scsi_host_template mpt2sas_driver_template = {
8314         .module                         = THIS_MODULE,
8315         .name                           = "Fusion MPT SAS Host",
8316         .proc_name                      = MPT2SAS_DRIVER_NAME,
8317         .queuecommand                   = scsih_qcmd,
8318         .target_alloc                   = scsih_target_alloc,
8319         .slave_alloc                    = scsih_slave_alloc,
8320         .slave_configure                = scsih_slave_configure,
8321         .target_destroy                 = scsih_target_destroy,
8322         .slave_destroy                  = scsih_slave_destroy,
8323         .scan_finished                  = scsih_scan_finished,
8324         .scan_start                     = scsih_scan_start,
8325         .change_queue_depth             = scsih_change_queue_depth,
8326         .eh_abort_handler               = scsih_abort,
8327         .eh_device_reset_handler        = scsih_dev_reset,
8328         .eh_target_reset_handler        = scsih_target_reset,
8329         .eh_host_reset_handler          = scsih_host_reset,
8330         .bios_param                     = scsih_bios_param,
8331         .can_queue                      = 1,
8332         .this_id                        = -1,
8333         .sg_tablesize                   = MPT2SAS_SG_DEPTH,
8334         .max_sectors                    = 32767,
8335         .cmd_per_lun                    = 7,
8336         .use_clustering                 = ENABLE_CLUSTERING,
8337         .shost_attrs                    = mpt3sas_host_attrs,
8338         .sdev_attrs                     = mpt3sas_dev_attrs,
8339         .track_queue_depth              = 1,
8340 };
8341
8342 /* raid transport support for SAS 2.0 HBA devices */
8343 static struct raid_function_template mpt2sas_raid_functions = {
8344         .cookie         = &mpt2sas_driver_template,
8345         .is_raid        = scsih_is_raid,
8346         .get_resync     = scsih_get_resync,
8347         .get_state      = scsih_get_state,
8348 };
8349
8350 /* shost template for SAS 3.0 HBA devices */
8351 static struct scsi_host_template mpt3sas_driver_template = {
8352         .module                         = THIS_MODULE,
8353         .name                           = "Fusion MPT SAS Host",
8354         .proc_name                      = MPT3SAS_DRIVER_NAME,
8355         .queuecommand                   = scsih_qcmd,
8356         .target_alloc                   = scsih_target_alloc,
8357         .slave_alloc                    = scsih_slave_alloc,
8358         .slave_configure                = scsih_slave_configure,
8359         .target_destroy                 = scsih_target_destroy,
8360         .slave_destroy                  = scsih_slave_destroy,
8361         .scan_finished                  = scsih_scan_finished,
8362         .scan_start                     = scsih_scan_start,
8363         .change_queue_depth             = scsih_change_queue_depth,
8364         .eh_abort_handler               = scsih_abort,
8365         .eh_device_reset_handler        = scsih_dev_reset,
8366         .eh_target_reset_handler        = scsih_target_reset,
8367         .eh_host_reset_handler          = scsih_host_reset,
8368         .bios_param                     = scsih_bios_param,
8369         .can_queue                      = 1,
8370         .this_id                        = -1,
8371         .sg_tablesize                   = MPT3SAS_SG_DEPTH,
8372         .max_sectors                    = 32767,
8373         .cmd_per_lun                    = 7,
8374         .use_clustering                 = ENABLE_CLUSTERING,
8375         .shost_attrs                    = mpt3sas_host_attrs,
8376         .sdev_attrs                     = mpt3sas_dev_attrs,
8377         .track_queue_depth              = 1,
8378 };
8379
8380 /* raid transport support for SAS 3.0 HBA devices */
8381 static struct raid_function_template mpt3sas_raid_functions = {
8382         .cookie         = &mpt3sas_driver_template,
8383         .is_raid        = scsih_is_raid,
8384         .get_resync     = scsih_get_resync,
8385         .get_state      = scsih_get_state,
8386 };
8387
8388 /**
8389  * _scsih_determine_hba_mpi_version - determine in which MPI version class
8390  *                                      this device belongs to.
8391  * @pdev: PCI device struct
8392  *
8393  * return MPI2_VERSION for SAS 2.0 HBA devices,
8394  *      MPI25_VERSION for SAS 3.0 HBA devices.
8395  */
8396 u16
8397 _scsih_determine_hba_mpi_version(struct pci_dev *pdev)
8398 {
8399
8400         switch (pdev->device) {
8401         case MPI2_MFGPAGE_DEVID_SSS6200:
8402         case MPI2_MFGPAGE_DEVID_SAS2004:
8403         case MPI2_MFGPAGE_DEVID_SAS2008:
8404         case MPI2_MFGPAGE_DEVID_SAS2108_1:
8405         case MPI2_MFGPAGE_DEVID_SAS2108_2:
8406         case MPI2_MFGPAGE_DEVID_SAS2108_3:
8407         case MPI2_MFGPAGE_DEVID_SAS2116_1:
8408         case MPI2_MFGPAGE_DEVID_SAS2116_2:
8409         case MPI2_MFGPAGE_DEVID_SAS2208_1:
8410         case MPI2_MFGPAGE_DEVID_SAS2208_2:
8411         case MPI2_MFGPAGE_DEVID_SAS2208_3:
8412         case MPI2_MFGPAGE_DEVID_SAS2208_4:
8413         case MPI2_MFGPAGE_DEVID_SAS2208_5:
8414         case MPI2_MFGPAGE_DEVID_SAS2208_6:
8415         case MPI2_MFGPAGE_DEVID_SAS2308_1:
8416         case MPI2_MFGPAGE_DEVID_SAS2308_2:
8417         case MPI2_MFGPAGE_DEVID_SAS2308_3:
8418                 return MPI2_VERSION;
8419         case MPI25_MFGPAGE_DEVID_SAS3004:
8420         case MPI25_MFGPAGE_DEVID_SAS3008:
8421         case MPI25_MFGPAGE_DEVID_SAS3108_1:
8422         case MPI25_MFGPAGE_DEVID_SAS3108_2:
8423         case MPI25_MFGPAGE_DEVID_SAS3108_5:
8424         case MPI25_MFGPAGE_DEVID_SAS3108_6:
8425                 return MPI25_VERSION;
8426         }
8427         return 0;
8428 }
8429
8430 /**
8431  * _scsih_probe - attach and add scsi host
8432  * @pdev: PCI device struct
8433  * @id: pci device id
8434  *
8435  * Returns 0 success, anything else error.
8436  */
8437 int
8438 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
8439 {
8440         struct MPT3SAS_ADAPTER *ioc;
8441         struct Scsi_Host *shost = NULL;
8442         int rv;
8443         u16 hba_mpi_version;
8444
8445         /* Determine in which MPI version class this pci device belongs */
8446         hba_mpi_version = _scsih_determine_hba_mpi_version(pdev);
8447         if (hba_mpi_version == 0)
8448                 return -ENODEV;
8449
8450         /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one,
8451          * for other generation HBA's return with -ENODEV
8452          */
8453         if ((hbas_to_enumerate == 1) && (hba_mpi_version !=  MPI2_VERSION))
8454                 return -ENODEV;
8455
8456         /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two,
8457          * for other generation HBA's return with -ENODEV
8458          */
8459         if ((hbas_to_enumerate == 2) && (hba_mpi_version !=  MPI25_VERSION))
8460                 return -ENODEV;
8461
8462         switch (hba_mpi_version) {
8463         case MPI2_VERSION:
8464                 /* Use mpt2sas driver host template for SAS 2.0 HBA's */
8465                 shost = scsi_host_alloc(&mpt2sas_driver_template,
8466                   sizeof(struct MPT3SAS_ADAPTER));
8467                 if (!shost)
8468                         return -ENODEV;
8469                 ioc = shost_priv(shost);
8470                 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
8471                 ioc->hba_mpi_version_belonged = hba_mpi_version;
8472                 ioc->id = mpt2_ids++;
8473                 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME);
8474                 if (pdev->device == MPI2_MFGPAGE_DEVID_SSS6200) {
8475                         ioc->is_warpdrive = 1;
8476                         ioc->hide_ir_msg = 1;
8477                 } else
8478                         ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
8479                 break;
8480         case MPI25_VERSION:
8481                 /* Use mpt3sas driver host template for SAS 3.0 HBA's */
8482                 shost = scsi_host_alloc(&mpt3sas_driver_template,
8483                   sizeof(struct MPT3SAS_ADAPTER));
8484                 if (!shost)
8485                         return -ENODEV;
8486                 ioc = shost_priv(shost);
8487                 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
8488                 ioc->hba_mpi_version_belonged = hba_mpi_version;
8489                 ioc->id = mpt3_ids++;
8490                 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME);
8491                 if (pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION)
8492                         ioc->msix96_vector = 1;
8493                 break;
8494         default:
8495                 return -ENODEV;
8496         }
8497
8498         INIT_LIST_HEAD(&ioc->list);
8499         spin_lock(&gioc_lock);
8500         list_add_tail(&ioc->list, &mpt3sas_ioc_list);
8501         spin_unlock(&gioc_lock);
8502         ioc->shost = shost;
8503         ioc->pdev = pdev;
8504         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
8505         ioc->tm_cb_idx = tm_cb_idx;
8506         ioc->ctl_cb_idx = ctl_cb_idx;
8507         ioc->base_cb_idx = base_cb_idx;
8508         ioc->port_enable_cb_idx = port_enable_cb_idx;
8509         ioc->transport_cb_idx = transport_cb_idx;
8510         ioc->scsih_cb_idx = scsih_cb_idx;
8511         ioc->config_cb_idx = config_cb_idx;
8512         ioc->tm_tr_cb_idx = tm_tr_cb_idx;
8513         ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
8514         ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
8515         ioc->logging_level = logging_level;
8516         ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
8517         /* misc semaphores and spin locks */
8518         mutex_init(&ioc->reset_in_progress_mutex);
8519         /* initializing pci_access_mutex lock */
8520         mutex_init(&ioc->pci_access_mutex);
8521         spin_lock_init(&ioc->ioc_reset_in_progress_lock);
8522         spin_lock_init(&ioc->scsi_lookup_lock);
8523         spin_lock_init(&ioc->sas_device_lock);
8524         spin_lock_init(&ioc->sas_node_lock);
8525         spin_lock_init(&ioc->fw_event_lock);
8526         spin_lock_init(&ioc->raid_device_lock);
8527         spin_lock_init(&ioc->diag_trigger_lock);
8528
8529         INIT_LIST_HEAD(&ioc->sas_device_list);
8530         INIT_LIST_HEAD(&ioc->sas_device_init_list);
8531         INIT_LIST_HEAD(&ioc->sas_expander_list);
8532         INIT_LIST_HEAD(&ioc->fw_event_list);
8533         INIT_LIST_HEAD(&ioc->raid_device_list);
8534         INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
8535         INIT_LIST_HEAD(&ioc->delayed_tr_list);
8536         INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
8537         INIT_LIST_HEAD(&ioc->reply_queue_list);
8538
8539         sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id);
8540
8541         /* init shost parameters */
8542         shost->max_cmd_len = 32;
8543         shost->max_lun = max_lun;
8544         shost->transportt = mpt3sas_transport_template;
8545         shost->unique_id = ioc->id;
8546
8547         if (max_sectors != 0xFFFF) {
8548                 if (max_sectors < 64) {
8549                         shost->max_sectors = 64;
8550                         pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
8551                             "for max_sectors, range is 64 to 32767. Assigning "
8552                             "value of 64.\n", ioc->name, max_sectors);
8553                 } else if (max_sectors > 32767) {
8554                         shost->max_sectors = 32767;
8555                         pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
8556                             "for max_sectors, range is 64 to 32767. Assigning "
8557                             "default value of 32767.\n", ioc->name,
8558                             max_sectors);
8559                 } else {
8560                         shost->max_sectors = max_sectors & 0xFFFE;
8561                         pr_info(MPT3SAS_FMT
8562                                 "The max_sectors value is set to %d\n",
8563                                 ioc->name, shost->max_sectors);
8564                 }
8565         }
8566
8567         /* register EEDP capabilities with SCSI layer */
8568         if (prot_mask > 0)
8569                 scsi_host_set_prot(shost, prot_mask);
8570         else
8571                 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
8572                                    | SHOST_DIF_TYPE2_PROTECTION
8573                                    | SHOST_DIF_TYPE3_PROTECTION);
8574
8575         scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
8576
8577         /* event thread */
8578         snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
8579             "fw_event_%s%d", ioc->driver_name, ioc->id);
8580         ioc->firmware_event_thread = alloc_ordered_workqueue(
8581             ioc->firmware_event_name, WQ_MEM_RECLAIM);
8582         if (!ioc->firmware_event_thread) {
8583                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8584                     ioc->name, __FILE__, __LINE__, __func__);
8585                 rv = -ENODEV;
8586                 goto out_thread_fail;
8587         }
8588
8589         ioc->is_driver_loading = 1;
8590         if ((mpt3sas_base_attach(ioc))) {
8591                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8592                     ioc->name, __FILE__, __LINE__, __func__);
8593                 rv = -ENODEV;
8594                 goto out_attach_fail;
8595         }
8596
8597         if (ioc->is_warpdrive) {
8598                 if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS)
8599                         ioc->hide_drives = 0;
8600                 else if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_HIDE_ALL_DISKS)
8601                         ioc->hide_drives = 1;
8602                 else {
8603                         if (mpt3sas_get_num_volumes(ioc))
8604                                 ioc->hide_drives = 1;
8605                         else
8606                                 ioc->hide_drives = 0;
8607                 }
8608         } else
8609                 ioc->hide_drives = 0;
8610
8611         rv = scsi_add_host(shost, &pdev->dev);
8612         if (rv) {
8613                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8614                     ioc->name, __FILE__, __LINE__, __func__);
8615                 goto out_add_shost_fail;
8616         }
8617
8618         scsi_scan_host(shost);
8619         return 0;
8620 out_add_shost_fail:
8621         mpt3sas_base_detach(ioc);
8622  out_attach_fail:
8623         destroy_workqueue(ioc->firmware_event_thread);
8624  out_thread_fail:
8625         spin_lock(&gioc_lock);
8626         list_del(&ioc->list);
8627         spin_unlock(&gioc_lock);
8628         scsi_host_put(shost);
8629         return rv;
8630 }
8631
8632 #ifdef CONFIG_PM
8633 /**
8634  * scsih_suspend - power management suspend main entry point
8635  * @pdev: PCI device struct
8636  * @state: PM state change to (usually PCI_D3)
8637  *
8638  * Returns 0 success, anything else error.
8639  */
8640 int
8641 scsih_suspend(struct pci_dev *pdev, pm_message_t state)
8642 {
8643         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8644         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8645         pci_power_t device_state;
8646
8647         mpt3sas_base_stop_watchdog(ioc);
8648         flush_scheduled_work();
8649         scsi_block_requests(shost);
8650         device_state = pci_choose_state(pdev, state);
8651         pr_info(MPT3SAS_FMT
8652                 "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
8653                 ioc->name, pdev, pci_name(pdev), device_state);
8654
8655         pci_save_state(pdev);
8656         mpt3sas_base_free_resources(ioc);
8657         pci_set_power_state(pdev, device_state);
8658         return 0;
8659 }
8660
8661 /**
8662  * scsih_resume - power management resume main entry point
8663  * @pdev: PCI device struct
8664  *
8665  * Returns 0 success, anything else error.
8666  */
8667 int
8668 scsih_resume(struct pci_dev *pdev)
8669 {
8670         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8671         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8672         pci_power_t device_state = pdev->current_state;
8673         int r;
8674
8675         pr_info(MPT3SAS_FMT
8676                 "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
8677                 ioc->name, pdev, pci_name(pdev), device_state);
8678
8679         pci_set_power_state(pdev, PCI_D0);
8680         pci_enable_wake(pdev, PCI_D0, 0);
8681         pci_restore_state(pdev);
8682         ioc->pdev = pdev;
8683         r = mpt3sas_base_map_resources(ioc);
8684         if (r)
8685                 return r;
8686
8687         mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
8688         scsi_unblock_requests(shost);
8689         mpt3sas_base_start_watchdog(ioc);
8690         return 0;
8691 }
8692 #endif /* CONFIG_PM */
8693
8694 /**
8695  * scsih_pci_error_detected - Called when a PCI error is detected.
8696  * @pdev: PCI device struct
8697  * @state: PCI channel state
8698  *
8699  * Description: Called when a PCI error is detected.
8700  *
8701  * Return value:
8702  *      PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
8703  */
8704 pci_ers_result_t
8705 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
8706 {
8707         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8708         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8709
8710         pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n",
8711             ioc->name, state);
8712
8713         switch (state) {
8714         case pci_channel_io_normal:
8715                 return PCI_ERS_RESULT_CAN_RECOVER;
8716         case pci_channel_io_frozen:
8717                 /* Fatal error, prepare for slot reset */
8718                 ioc->pci_error_recovery = 1;
8719                 scsi_block_requests(ioc->shost);
8720                 mpt3sas_base_stop_watchdog(ioc);
8721                 mpt3sas_base_free_resources(ioc);
8722                 return PCI_ERS_RESULT_NEED_RESET;
8723         case pci_channel_io_perm_failure:
8724                 /* Permanent error, prepare for device removal */
8725                 ioc->pci_error_recovery = 1;
8726                 mpt3sas_base_stop_watchdog(ioc);
8727                 _scsih_flush_running_cmds(ioc);
8728                 return PCI_ERS_RESULT_DISCONNECT;
8729         }
8730         return PCI_ERS_RESULT_NEED_RESET;
8731 }
8732
8733 /**
8734  * scsih_pci_slot_reset - Called when PCI slot has been reset.
8735  * @pdev: PCI device struct
8736  *
8737  * Description: This routine is called by the pci error recovery
8738  * code after the PCI slot has been reset, just before we
8739  * should resume normal operations.
8740  */
8741 pci_ers_result_t
8742 scsih_pci_slot_reset(struct pci_dev *pdev)
8743 {
8744         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8745         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8746         int rc;
8747
8748         pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n",
8749              ioc->name);
8750
8751         ioc->pci_error_recovery = 0;
8752         ioc->pdev = pdev;
8753         pci_restore_state(pdev);
8754         rc = mpt3sas_base_map_resources(ioc);
8755         if (rc)
8756                 return PCI_ERS_RESULT_DISCONNECT;
8757
8758         rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
8759             FORCE_BIG_HAMMER);
8760
8761         pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name,
8762             (rc == 0) ? "success" : "failed");
8763
8764         if (!rc)
8765                 return PCI_ERS_RESULT_RECOVERED;
8766         else
8767                 return PCI_ERS_RESULT_DISCONNECT;
8768 }
8769
8770 /**
8771  * scsih_pci_resume() - resume normal ops after PCI reset
8772  * @pdev: pointer to PCI device
8773  *
8774  * Called when the error recovery driver tells us that its
8775  * OK to resume normal operation. Use completion to allow
8776  * halted scsi ops to resume.
8777  */
8778 void
8779 scsih_pci_resume(struct pci_dev *pdev)
8780 {
8781         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8782         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8783
8784         pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name);
8785
8786         pci_cleanup_aer_uncorrect_error_status(pdev);
8787         mpt3sas_base_start_watchdog(ioc);
8788         scsi_unblock_requests(ioc->shost);
8789 }
8790
8791 /**
8792  * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers
8793  * @pdev: pointer to PCI device
8794  */
8795 pci_ers_result_t
8796 scsih_pci_mmio_enabled(struct pci_dev *pdev)
8797 {
8798         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8799         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8800
8801         pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n",
8802             ioc->name);
8803
8804         /* TODO - dump whatever for debugging purposes */
8805
8806         /* Request a slot reset. */
8807         return PCI_ERS_RESULT_NEED_RESET;
8808 }
8809
8810 /*
8811  * The pci device ids are defined in mpi/mpi2_cnfg.h.
8812  */
8813 static const struct pci_device_id mpt3sas_pci_table[] = {
8814         /* Spitfire ~ 2004 */
8815         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004,
8816                 PCI_ANY_ID, PCI_ANY_ID },
8817         /* Falcon ~ 2008 */
8818         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008,
8819                 PCI_ANY_ID, PCI_ANY_ID },
8820         /* Liberator ~ 2108 */
8821         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1,
8822                 PCI_ANY_ID, PCI_ANY_ID },
8823         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2,
8824                 PCI_ANY_ID, PCI_ANY_ID },
8825         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3,
8826                 PCI_ANY_ID, PCI_ANY_ID },
8827         /* Meteor ~ 2116 */
8828         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1,
8829                 PCI_ANY_ID, PCI_ANY_ID },
8830         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2,
8831                 PCI_ANY_ID, PCI_ANY_ID },
8832         /* Thunderbolt ~ 2208 */
8833         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1,
8834                 PCI_ANY_ID, PCI_ANY_ID },
8835         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2,
8836                 PCI_ANY_ID, PCI_ANY_ID },
8837         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3,
8838                 PCI_ANY_ID, PCI_ANY_ID },
8839         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4,
8840                 PCI_ANY_ID, PCI_ANY_ID },
8841         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5,
8842                 PCI_ANY_ID, PCI_ANY_ID },
8843         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6,
8844                 PCI_ANY_ID, PCI_ANY_ID },
8845         /* Mustang ~ 2308 */
8846         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1,
8847                 PCI_ANY_ID, PCI_ANY_ID },
8848         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2,
8849                 PCI_ANY_ID, PCI_ANY_ID },
8850         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
8851                 PCI_ANY_ID, PCI_ANY_ID },
8852         /* SSS6200 */
8853         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
8854                 PCI_ANY_ID, PCI_ANY_ID },
8855         /* Fury ~ 3004 and 3008 */
8856         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004,
8857                 PCI_ANY_ID, PCI_ANY_ID },
8858         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008,
8859                 PCI_ANY_ID, PCI_ANY_ID },
8860         /* Invader ~ 3108 */
8861         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1,
8862                 PCI_ANY_ID, PCI_ANY_ID },
8863         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2,
8864                 PCI_ANY_ID, PCI_ANY_ID },
8865         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5,
8866                 PCI_ANY_ID, PCI_ANY_ID },
8867         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6,
8868                 PCI_ANY_ID, PCI_ANY_ID },
8869         {0}     /* Terminating entry */
8870 };
8871 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table);
8872
8873 static struct pci_error_handlers _mpt3sas_err_handler = {
8874         .error_detected = scsih_pci_error_detected,
8875         .mmio_enabled   = scsih_pci_mmio_enabled,
8876         .slot_reset     = scsih_pci_slot_reset,
8877         .resume         = scsih_pci_resume,
8878 };
8879
8880 static struct pci_driver mpt3sas_driver = {
8881         .name           = MPT3SAS_DRIVER_NAME,
8882         .id_table       = mpt3sas_pci_table,
8883         .probe          = _scsih_probe,
8884         .remove         = scsih_remove,
8885         .shutdown       = scsih_shutdown,
8886         .err_handler    = &_mpt3sas_err_handler,
8887 #ifdef CONFIG_PM
8888         .suspend        = scsih_suspend,
8889         .resume         = scsih_resume,
8890 #endif
8891 };
8892
8893 /**
8894  * scsih_init - main entry point for this driver.
8895  *
8896  * Returns 0 success, anything else error.
8897  */
8898 int
8899 scsih_init(void)
8900 {
8901         mpt2_ids = 0;
8902         mpt3_ids = 0;
8903
8904         mpt3sas_base_initialize_callback_handler();
8905
8906          /* queuecommand callback hander */
8907         scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done);
8908
8909         /* task managment callback handler */
8910         tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done);
8911
8912         /* base internal commands callback handler */
8913         base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done);
8914         port_enable_cb_idx = mpt3sas_base_register_callback_handler(
8915             mpt3sas_port_enable_done);
8916
8917         /* transport internal commands callback handler */
8918         transport_cb_idx = mpt3sas_base_register_callback_handler(
8919             mpt3sas_transport_done);
8920
8921         /* scsih internal commands callback handler */
8922         scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done);
8923
8924         /* configuration page API internal commands callback handler */
8925         config_cb_idx = mpt3sas_base_register_callback_handler(
8926             mpt3sas_config_done);
8927
8928         /* ctl module callback handler */
8929         ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done);
8930
8931         tm_tr_cb_idx = mpt3sas_base_register_callback_handler(
8932             _scsih_tm_tr_complete);
8933
8934         tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler(
8935             _scsih_tm_volume_tr_complete);
8936
8937         tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler(
8938             _scsih_sas_control_complete);
8939
8940         return 0;
8941 }
8942
8943 /**
8944  * scsih_exit - exit point for this driver (when it is a module).
8945  *
8946  * Returns 0 success, anything else error.
8947  */
8948 void
8949 scsih_exit(void)
8950 {
8951
8952         mpt3sas_base_release_callback_handler(scsi_io_cb_idx);
8953         mpt3sas_base_release_callback_handler(tm_cb_idx);
8954         mpt3sas_base_release_callback_handler(base_cb_idx);
8955         mpt3sas_base_release_callback_handler(port_enable_cb_idx);
8956         mpt3sas_base_release_callback_handler(transport_cb_idx);
8957         mpt3sas_base_release_callback_handler(scsih_cb_idx);
8958         mpt3sas_base_release_callback_handler(config_cb_idx);
8959         mpt3sas_base_release_callback_handler(ctl_cb_idx);
8960
8961         mpt3sas_base_release_callback_handler(tm_tr_cb_idx);
8962         mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx);
8963         mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx);
8964
8965 /* raid transport support */
8966         if (hbas_to_enumerate != 1)
8967                 raid_class_release(mpt3sas_raid_template);
8968         if (hbas_to_enumerate != 2)
8969                 raid_class_release(mpt2sas_raid_template);
8970         sas_release_transport(mpt3sas_transport_template);
8971 }
8972
8973 /**
8974  * _mpt3sas_init - main entry point for this driver.
8975  *
8976  * Returns 0 success, anything else error.
8977  */
8978 static int __init
8979 _mpt3sas_init(void)
8980 {
8981         int error;
8982
8983         pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME,
8984                                         MPT3SAS_DRIVER_VERSION);
8985
8986         mpt3sas_transport_template =
8987             sas_attach_transport(&mpt3sas_transport_functions);
8988         if (!mpt3sas_transport_template)
8989                 return -ENODEV;
8990
8991         /* No need attach mpt3sas raid functions template
8992          * if hbas_to_enumarate value is one.
8993          */
8994         if (hbas_to_enumerate != 1) {
8995                 mpt3sas_raid_template =
8996                                 raid_class_attach(&mpt3sas_raid_functions);
8997                 if (!mpt3sas_raid_template) {
8998                         sas_release_transport(mpt3sas_transport_template);
8999                         return -ENODEV;
9000                 }
9001         }
9002
9003         /* No need to attach mpt2sas raid functions template
9004          * if hbas_to_enumarate value is two
9005          */
9006         if (hbas_to_enumerate != 2) {
9007                 mpt2sas_raid_template =
9008                                 raid_class_attach(&mpt2sas_raid_functions);
9009                 if (!mpt2sas_raid_template) {
9010                         sas_release_transport(mpt3sas_transport_template);
9011                         return -ENODEV;
9012                 }
9013         }
9014
9015         error = scsih_init();
9016         if (error) {
9017                 scsih_exit();
9018                 return error;
9019         }
9020
9021         mpt3sas_ctl_init(hbas_to_enumerate);
9022
9023         error = pci_register_driver(&mpt3sas_driver);
9024         if (error)
9025                 scsih_exit();
9026
9027         return error;
9028 }
9029
9030 /**
9031  * _mpt3sas_exit - exit point for this driver (when it is a module).
9032  *
9033  */
9034 static void __exit
9035 _mpt3sas_exit(void)
9036 {
9037         pr_info("mpt3sas version %s unloading\n",
9038                                 MPT3SAS_DRIVER_VERSION);
9039
9040         pci_unregister_driver(&mpt3sas_driver);
9041
9042         mpt3sas_ctl_exit(hbas_to_enumerate);
9043
9044         scsih_exit();
9045 }
9046
9047 module_init(_mpt3sas_init);
9048 module_exit(_mpt3sas_exit);