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