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