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 int _scsih_set_satl_pending(struct scsi_cmnd *scmd, bool pending)
3903 {
3904         struct MPT3SAS_DEVICE *priv = scmd->device->hostdata;
3905
3906         if (scmd->cmnd[0] != ATA_12 && scmd->cmnd[0] != ATA_16)
3907                 return 0;
3908
3909         if (pending)
3910                 return test_and_set_bit(0, &priv->ata_command_pending);
3911
3912         clear_bit(0, &priv->ata_command_pending);
3913         return 0;
3914 }
3915
3916 /**
3917  * _scsih_flush_running_cmds - completing outstanding commands.
3918  * @ioc: per adapter object
3919  *
3920  * The flushing out of all pending scmd commands following host reset,
3921  * where all IO is dropped to the floor.
3922  *
3923  * Return nothing.
3924  */
3925 static void
3926 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc)
3927 {
3928         struct scsi_cmnd *scmd;
3929         u16 smid;
3930         u16 count = 0;
3931
3932         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
3933                 scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
3934                 if (!scmd)
3935                         continue;
3936                 count++;
3937                 _scsih_set_satl_pending(scmd, false);
3938                 mpt3sas_base_free_smid(ioc, smid);
3939                 scsi_dma_unmap(scmd);
3940                 if (ioc->pci_error_recovery)
3941                         scmd->result = DID_NO_CONNECT << 16;
3942                 else
3943                         scmd->result = DID_RESET << 16;
3944                 scmd->scsi_done(scmd);
3945         }
3946         dtmprintk(ioc, pr_info(MPT3SAS_FMT "completing %d cmds\n",
3947             ioc->name, count));
3948 }
3949
3950 /**
3951  * _scsih_setup_eedp - setup MPI request for EEDP transfer
3952  * @ioc: per adapter object
3953  * @scmd: pointer to scsi command object
3954  * @mpi_request: pointer to the SCSI_IO request message frame
3955  *
3956  * Supporting protection 1 and 3.
3957  *
3958  * Returns nothing
3959  */
3960 static void
3961 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
3962         Mpi2SCSIIORequest_t *mpi_request)
3963 {
3964         u16 eedp_flags;
3965         unsigned char prot_op = scsi_get_prot_op(scmd);
3966         unsigned char prot_type = scsi_get_prot_type(scmd);
3967         Mpi25SCSIIORequest_t *mpi_request_3v =
3968            (Mpi25SCSIIORequest_t *)mpi_request;
3969
3970         if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL)
3971                 return;
3972
3973         if (prot_op ==  SCSI_PROT_READ_STRIP)
3974                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP;
3975         else if (prot_op ==  SCSI_PROT_WRITE_INSERT)
3976                 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
3977         else
3978                 return;
3979
3980         switch (prot_type) {
3981         case SCSI_PROT_DIF_TYPE1:
3982         case SCSI_PROT_DIF_TYPE2:
3983
3984                 /*
3985                 * enable ref/guard checking
3986                 * auto increment ref tag
3987                 */
3988                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
3989                     MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
3990                     MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
3991                 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
3992                     cpu_to_be32(scsi_prot_ref_tag(scmd));
3993                 break;
3994
3995         case SCSI_PROT_DIF_TYPE3:
3996
3997                 /*
3998                 * enable guard checking
3999                 */
4000                 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
4001
4002                 break;
4003         }
4004
4005         mpi_request_3v->EEDPBlockSize =
4006             cpu_to_le16(scmd->device->sector_size);
4007
4008         if (ioc->is_gen35_ioc)
4009                 eedp_flags |= MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE;
4010         mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
4011 }
4012
4013 /**
4014  * _scsih_eedp_error_handling - return sense code for EEDP errors
4015  * @scmd: pointer to scsi command object
4016  * @ioc_status: ioc status
4017  *
4018  * Returns nothing
4019  */
4020 static void
4021 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
4022 {
4023         u8 ascq;
4024
4025         switch (ioc_status) {
4026         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4027                 ascq = 0x01;
4028                 break;
4029         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4030                 ascq = 0x02;
4031                 break;
4032         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4033                 ascq = 0x03;
4034                 break;
4035         default:
4036                 ascq = 0x00;
4037                 break;
4038         }
4039         scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10,
4040             ascq);
4041         scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) |
4042             SAM_STAT_CHECK_CONDITION;
4043 }
4044
4045 /**
4046  * scsih_qcmd - main scsi request entry point
4047  * @scmd: pointer to scsi command object
4048  * @done: function pointer to be invoked on completion
4049  *
4050  * The callback index is set inside `ioc->scsi_io_cb_idx`.
4051  *
4052  * Returns 0 on success.  If there's a failure, return either:
4053  * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
4054  * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
4055  */
4056 static int
4057 scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
4058 {
4059         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
4060         struct MPT3SAS_DEVICE *sas_device_priv_data;
4061         struct MPT3SAS_TARGET *sas_target_priv_data;
4062         struct _raid_device *raid_device;
4063         struct request *rq = scmd->request;
4064         int class;
4065         Mpi2SCSIIORequest_t *mpi_request;
4066         u32 mpi_control;
4067         u16 smid;
4068         u16 handle;
4069
4070         if (ioc->logging_level & MPT_DEBUG_SCSI)
4071                 scsi_print_command(scmd);
4072
4073         sas_device_priv_data = scmd->device->hostdata;
4074         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
4075                 scmd->result = DID_NO_CONNECT << 16;
4076                 scmd->scsi_done(scmd);
4077                 return 0;
4078         }
4079
4080         if (ioc->pci_error_recovery || ioc->remove_host) {
4081                 scmd->result = DID_NO_CONNECT << 16;
4082                 scmd->scsi_done(scmd);
4083                 return 0;
4084         }
4085
4086         /*
4087          * Bug work around for firmware SATL handling.  The loop
4088          * is based on atomic operations and ensures consistency
4089          * since we're lockless at this point
4090          */
4091         do {
4092                 if (test_bit(0, &sas_device_priv_data->ata_command_pending)) {
4093                         scmd->result = SAM_STAT_BUSY;
4094                         scmd->scsi_done(scmd);
4095                         return 0;
4096                 }
4097         } while (_scsih_set_satl_pending(scmd, true));
4098
4099         sas_target_priv_data = sas_device_priv_data->sas_target;
4100
4101         /* invalid device handle */
4102         handle = sas_target_priv_data->handle;
4103         if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) {
4104                 scmd->result = DID_NO_CONNECT << 16;
4105                 scmd->scsi_done(scmd);
4106                 return 0;
4107         }
4108
4109
4110         /* host recovery or link resets sent via IOCTLs */
4111         if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
4112                 return SCSI_MLQUEUE_HOST_BUSY;
4113
4114         /* device has been deleted */
4115         else if (sas_target_priv_data->deleted) {
4116                 scmd->result = DID_NO_CONNECT << 16;
4117                 scmd->scsi_done(scmd);
4118                 return 0;
4119         /* device busy with task management */
4120         } else if (sas_target_priv_data->tm_busy ||
4121             sas_device_priv_data->block)
4122                 return SCSI_MLQUEUE_DEVICE_BUSY;
4123
4124         if (scmd->sc_data_direction == DMA_FROM_DEVICE)
4125                 mpi_control = MPI2_SCSIIO_CONTROL_READ;
4126         else if (scmd->sc_data_direction == DMA_TO_DEVICE)
4127                 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
4128         else
4129                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
4130
4131         /* set tags */
4132         mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
4133         /* NCQ Prio supported, make sure control indicated high priority */
4134         if (sas_device_priv_data->ncq_prio_enable) {
4135                 class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq));
4136                 if (class == IOPRIO_CLASS_RT)
4137                         mpi_control |= 1 << MPI2_SCSIIO_CONTROL_CMDPRI_SHIFT;
4138         }
4139         /* Make sure Device is not raid volume.
4140          * We do not expose raid functionality to upper layer for warpdrive.
4141          */
4142         if (!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev)
4143             && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
4144                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
4145
4146         smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
4147         if (!smid) {
4148                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
4149                     ioc->name, __func__);
4150                 goto out;
4151         }
4152         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4153         memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t));
4154         _scsih_setup_eedp(ioc, scmd, mpi_request);
4155
4156         if (scmd->cmd_len == 32)
4157                 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
4158         mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4159         if (sas_device_priv_data->sas_target->flags &
4160             MPT_TARGET_FLAGS_RAID_COMPONENT)
4161                 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
4162         else
4163                 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
4164         mpi_request->DevHandle = cpu_to_le16(handle);
4165         mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
4166         mpi_request->Control = cpu_to_le32(mpi_control);
4167         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len);
4168         mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
4169         mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
4170         mpi_request->SenseBufferLowAddress =
4171             mpt3sas_base_get_sense_buffer_dma(ioc, smid);
4172         mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
4173         int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *)
4174             mpi_request->LUN);
4175         memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4176
4177         if (mpi_request->DataLength) {
4178                 if (ioc->build_sg_scmd(ioc, scmd, smid)) {
4179                         mpt3sas_base_free_smid(ioc, smid);
4180                         goto out;
4181                 }
4182         } else
4183                 ioc->build_zero_len_sge(ioc, &mpi_request->SGL);
4184
4185         raid_device = sas_target_priv_data->raid_device;
4186         if (raid_device && raid_device->direct_io_enabled)
4187                 mpt3sas_setup_direct_io(ioc, scmd, raid_device, mpi_request,
4188                     smid);
4189
4190         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) {
4191                 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) {
4192                         mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len |
4193                             MPI25_SCSIIO_IOFLAGS_FAST_PATH);
4194                         ioc->put_smid_fast_path(ioc, smid, handle);
4195                 } else
4196                         ioc->put_smid_scsi_io(ioc, smid,
4197                             le16_to_cpu(mpi_request->DevHandle));
4198         } else
4199                 ioc->put_smid_default(ioc, smid);
4200         return 0;
4201
4202  out:
4203         return SCSI_MLQUEUE_HOST_BUSY;
4204 }
4205
4206 /**
4207  * _scsih_normalize_sense - normalize descriptor and fixed format sense data
4208  * @sense_buffer: sense data returned by target
4209  * @data: normalized skey/asc/ascq
4210  *
4211  * Return nothing.
4212  */
4213 static void
4214 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
4215 {
4216         if ((sense_buffer[0] & 0x7F) >= 0x72) {
4217                 /* descriptor format */
4218                 data->skey = sense_buffer[1] & 0x0F;
4219                 data->asc = sense_buffer[2];
4220                 data->ascq = sense_buffer[3];
4221         } else {
4222                 /* fixed format */
4223                 data->skey = sense_buffer[2] & 0x0F;
4224                 data->asc = sense_buffer[12];
4225                 data->ascq = sense_buffer[13];
4226         }
4227 }
4228
4229 /**
4230  * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
4231  * @ioc: per adapter object
4232  * @scmd: pointer to scsi command object
4233  * @mpi_reply: reply mf payload returned from firmware
4234  *
4235  * scsi_status - SCSI Status code returned from target device
4236  * scsi_state - state info associated with SCSI_IO determined by ioc
4237  * ioc_status - ioc supplied status info
4238  *
4239  * Return nothing.
4240  */
4241 static void
4242 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
4243         Mpi2SCSIIOReply_t *mpi_reply, u16 smid)
4244 {
4245         u32 response_info;
4246         u8 *response_bytes;
4247         u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) &
4248             MPI2_IOCSTATUS_MASK;
4249         u8 scsi_state = mpi_reply->SCSIState;
4250         u8 scsi_status = mpi_reply->SCSIStatus;
4251         char *desc_ioc_state = NULL;
4252         char *desc_scsi_status = NULL;
4253         char *desc_scsi_state = ioc->tmp_string;
4254         u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo);
4255         struct _sas_device *sas_device = NULL;
4256         struct scsi_target *starget = scmd->device->sdev_target;
4257         struct MPT3SAS_TARGET *priv_target = starget->hostdata;
4258         char *device_str = NULL;
4259
4260         if (!priv_target)
4261                 return;
4262         if (ioc->hide_ir_msg)
4263                 device_str = "WarpDrive";
4264         else
4265                 device_str = "volume";
4266
4267         if (log_info == 0x31170000)
4268                 return;
4269
4270         switch (ioc_status) {
4271         case MPI2_IOCSTATUS_SUCCESS:
4272                 desc_ioc_state = "success";
4273                 break;
4274         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4275                 desc_ioc_state = "invalid function";
4276                 break;
4277         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4278                 desc_ioc_state = "scsi recovered error";
4279                 break;
4280         case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
4281                 desc_ioc_state = "scsi invalid dev handle";
4282                 break;
4283         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4284                 desc_ioc_state = "scsi device not there";
4285                 break;
4286         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4287                 desc_ioc_state = "scsi data overrun";
4288                 break;
4289         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4290                 desc_ioc_state = "scsi data underrun";
4291                 break;
4292         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4293                 desc_ioc_state = "scsi io data error";
4294                 break;
4295         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4296                 desc_ioc_state = "scsi protocol error";
4297                 break;
4298         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4299                 desc_ioc_state = "scsi task terminated";
4300                 break;
4301         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4302                 desc_ioc_state = "scsi residual mismatch";
4303                 break;
4304         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4305                 desc_ioc_state = "scsi task mgmt failed";
4306                 break;
4307         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4308                 desc_ioc_state = "scsi ioc terminated";
4309                 break;
4310         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4311                 desc_ioc_state = "scsi ext terminated";
4312                 break;
4313         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4314                 desc_ioc_state = "eedp guard error";
4315                 break;
4316         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4317                 desc_ioc_state = "eedp ref tag error";
4318                 break;
4319         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4320                 desc_ioc_state = "eedp app tag error";
4321                 break;
4322         case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
4323                 desc_ioc_state = "insufficient power";
4324                 break;
4325         default:
4326                 desc_ioc_state = "unknown";
4327                 break;
4328         }
4329
4330         switch (scsi_status) {
4331         case MPI2_SCSI_STATUS_GOOD:
4332                 desc_scsi_status = "good";
4333                 break;
4334         case MPI2_SCSI_STATUS_CHECK_CONDITION:
4335                 desc_scsi_status = "check condition";
4336                 break;
4337         case MPI2_SCSI_STATUS_CONDITION_MET:
4338                 desc_scsi_status = "condition met";
4339                 break;
4340         case MPI2_SCSI_STATUS_BUSY:
4341                 desc_scsi_status = "busy";
4342                 break;
4343         case MPI2_SCSI_STATUS_INTERMEDIATE:
4344                 desc_scsi_status = "intermediate";
4345                 break;
4346         case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET:
4347                 desc_scsi_status = "intermediate condmet";
4348                 break;
4349         case MPI2_SCSI_STATUS_RESERVATION_CONFLICT:
4350                 desc_scsi_status = "reservation conflict";
4351                 break;
4352         case MPI2_SCSI_STATUS_COMMAND_TERMINATED:
4353                 desc_scsi_status = "command terminated";
4354                 break;
4355         case MPI2_SCSI_STATUS_TASK_SET_FULL:
4356                 desc_scsi_status = "task set full";
4357                 break;
4358         case MPI2_SCSI_STATUS_ACA_ACTIVE:
4359                 desc_scsi_status = "aca active";
4360                 break;
4361         case MPI2_SCSI_STATUS_TASK_ABORTED:
4362                 desc_scsi_status = "task aborted";
4363                 break;
4364         default:
4365                 desc_scsi_status = "unknown";
4366                 break;
4367         }
4368
4369         desc_scsi_state[0] = '\0';
4370         if (!scsi_state)
4371                 desc_scsi_state = " ";
4372         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4373                 strcat(desc_scsi_state, "response info ");
4374         if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4375                 strcat(desc_scsi_state, "state terminated ");
4376         if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS)
4377                 strcat(desc_scsi_state, "no status ");
4378         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED)
4379                 strcat(desc_scsi_state, "autosense failed ");
4380         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)
4381                 strcat(desc_scsi_state, "autosense valid ");
4382
4383         scsi_print_command(scmd);
4384
4385         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
4386                 pr_warn(MPT3SAS_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
4387                     device_str, (unsigned long long)priv_target->sas_address);
4388         } else {
4389                 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
4390                 if (sas_device) {
4391                         pr_warn(MPT3SAS_FMT
4392                                 "\tsas_address(0x%016llx), phy(%d)\n",
4393                                 ioc->name, (unsigned long long)
4394                             sas_device->sas_address, sas_device->phy);
4395                         if (sas_device->enclosure_handle != 0)
4396                                 pr_warn(MPT3SAS_FMT
4397                                   "\tenclosure_logical_id(0x%016llx),"
4398                                   "slot(%d)\n", ioc->name,
4399                                   (unsigned long long)
4400                                   sas_device->enclosure_logical_id,
4401                                   sas_device->slot);
4402                         if (sas_device->connector_name[0])
4403                                 pr_warn(MPT3SAS_FMT
4404                                   "\tenclosure level(0x%04x),"
4405                                   " connector name( %s)\n", ioc->name,
4406                                   sas_device->enclosure_level,
4407                                   sas_device->connector_name);
4408
4409                         sas_device_put(sas_device);
4410                 }
4411         }
4412
4413         pr_warn(MPT3SAS_FMT
4414                 "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
4415                 ioc->name, le16_to_cpu(mpi_reply->DevHandle),
4416             desc_ioc_state, ioc_status, smid);
4417         pr_warn(MPT3SAS_FMT
4418                 "\trequest_len(%d), underflow(%d), resid(%d)\n",
4419                 ioc->name, scsi_bufflen(scmd), scmd->underflow,
4420             scsi_get_resid(scmd));
4421         pr_warn(MPT3SAS_FMT
4422                 "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
4423                 ioc->name, le16_to_cpu(mpi_reply->TaskTag),
4424             le32_to_cpu(mpi_reply->TransferCount), scmd->result);
4425         pr_warn(MPT3SAS_FMT
4426                 "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
4427                 ioc->name, desc_scsi_status,
4428             scsi_status, desc_scsi_state, scsi_state);
4429
4430         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4431                 struct sense_info data;
4432                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4433                 pr_warn(MPT3SAS_FMT
4434                         "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
4435                         ioc->name, data.skey,
4436                     data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
4437         }
4438
4439         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
4440                 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
4441                 response_bytes = (u8 *)&response_info;
4442                 _scsih_response_code(ioc, response_bytes[0]);
4443         }
4444 }
4445
4446 /**
4447  * _scsih_turn_on_pfa_led - illuminate PFA LED
4448  * @ioc: per adapter object
4449  * @handle: device handle
4450  * Context: process
4451  *
4452  * Return nothing.
4453  */
4454 static void
4455 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4456 {
4457         Mpi2SepReply_t mpi_reply;
4458         Mpi2SepRequest_t mpi_request;
4459         struct _sas_device *sas_device;
4460
4461         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
4462         if (!sas_device)
4463                 return;
4464
4465         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
4466         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
4467         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
4468         mpi_request.SlotStatus =
4469             cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
4470         mpi_request.DevHandle = cpu_to_le16(handle);
4471         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
4472         if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4473             &mpi_request)) != 0) {
4474                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
4475                 __FILE__, __LINE__, __func__);
4476                 goto out;
4477         }
4478         sas_device->pfa_led_on = 1;
4479
4480         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
4481                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
4482                         "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
4483                         ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
4484                     le32_to_cpu(mpi_reply.IOCLogInfo)));
4485                 goto out;
4486         }
4487 out:
4488         sas_device_put(sas_device);
4489 }
4490
4491 /**
4492  * _scsih_turn_off_pfa_led - turn off Fault LED
4493  * @ioc: per adapter object
4494  * @sas_device: sas device whose PFA LED has to turned off
4495  * Context: process
4496  *
4497  * Return nothing.
4498  */
4499 static void
4500 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc,
4501         struct _sas_device *sas_device)
4502 {
4503         Mpi2SepReply_t mpi_reply;
4504         Mpi2SepRequest_t mpi_request;
4505
4506         memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
4507         mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
4508         mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
4509         mpi_request.SlotStatus = 0;
4510         mpi_request.Slot = cpu_to_le16(sas_device->slot);
4511         mpi_request.DevHandle = 0;
4512         mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle);
4513         mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS;
4514         if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
4515                 &mpi_request)) != 0) {
4516                 printk(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
4517                 __FILE__, __LINE__, __func__);
4518                 return;
4519         }
4520
4521         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
4522                 dewtprintk(ioc, printk(MPT3SAS_FMT
4523                  "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
4524                  ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
4525                  le32_to_cpu(mpi_reply.IOCLogInfo)));
4526                 return;
4527         }
4528 }
4529
4530 /**
4531  * _scsih_send_event_to_turn_on_pfa_led - fire delayed event
4532  * @ioc: per adapter object
4533  * @handle: device handle
4534  * Context: interrupt.
4535  *
4536  * Return nothing.
4537  */
4538 static void
4539 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4540 {
4541         struct fw_event_work *fw_event;
4542
4543         fw_event = alloc_fw_event_work(0);
4544         if (!fw_event)
4545                 return;
4546         fw_event->event = MPT3SAS_TURN_ON_PFA_LED;
4547         fw_event->device_handle = handle;
4548         fw_event->ioc = ioc;
4549         _scsih_fw_event_add(ioc, fw_event);
4550         fw_event_work_put(fw_event);
4551 }
4552
4553 /**
4554  * _scsih_smart_predicted_fault - process smart errors
4555  * @ioc: per adapter object
4556  * @handle: device handle
4557  * Context: interrupt.
4558  *
4559  * Return nothing.
4560  */
4561 static void
4562 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
4563 {
4564         struct scsi_target *starget;
4565         struct MPT3SAS_TARGET *sas_target_priv_data;
4566         Mpi2EventNotificationReply_t *event_reply;
4567         Mpi2EventDataSasDeviceStatusChange_t *event_data;
4568         struct _sas_device *sas_device;
4569         ssize_t sz;
4570         unsigned long flags;
4571
4572         /* only handle non-raid devices */
4573         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4574         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
4575         if (!sas_device)
4576                 goto out_unlock;
4577
4578         starget = sas_device->starget;
4579         sas_target_priv_data = starget->hostdata;
4580
4581         if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) ||
4582            ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)))
4583                 goto out_unlock;
4584
4585         if (sas_device->enclosure_handle != 0)
4586                 starget_printk(KERN_INFO, starget, "predicted fault, "
4587                         "enclosure logical id(0x%016llx), slot(%d)\n",
4588                         (unsigned long long)sas_device->enclosure_logical_id,
4589                         sas_device->slot);
4590         if (sas_device->connector_name[0] != '\0')
4591                 starget_printk(KERN_WARNING, starget, "predicted fault, "
4592                         "enclosure level(0x%04x), connector name( %s)\n",
4593                         sas_device->enclosure_level,
4594                         sas_device->connector_name);
4595         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4596
4597         if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
4598                 _scsih_send_event_to_turn_on_pfa_led(ioc, handle);
4599
4600         /* insert into event log */
4601         sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
4602              sizeof(Mpi2EventDataSasDeviceStatusChange_t);
4603         event_reply = kzalloc(sz, GFP_KERNEL);
4604         if (!event_reply) {
4605                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4606                     ioc->name, __FILE__, __LINE__, __func__);
4607                 goto out;
4608         }
4609
4610         event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
4611         event_reply->Event =
4612             cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
4613         event_reply->MsgLength = sz/4;
4614         event_reply->EventDataLength =
4615             cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4);
4616         event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
4617             event_reply->EventData;
4618         event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
4619         event_data->ASC = 0x5D;
4620         event_data->DevHandle = cpu_to_le16(handle);
4621         event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
4622         mpt3sas_ctl_add_to_event_log(ioc, event_reply);
4623         kfree(event_reply);
4624 out:
4625         if (sas_device)
4626                 sas_device_put(sas_device);
4627         return;
4628
4629 out_unlock:
4630         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4631         goto out;
4632 }
4633
4634 /**
4635  * _scsih_io_done - scsi request callback
4636  * @ioc: per adapter object
4637  * @smid: system request message index
4638  * @msix_index: MSIX table index supplied by the OS
4639  * @reply: reply message frame(lower 32bit addr)
4640  *
4641  * Callback handler when using _scsih_qcmd.
4642  *
4643  * Return 1 meaning mf should be freed from _base_interrupt
4644  *        0 means the mf is freed from this function.
4645  */
4646 static u8
4647 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
4648 {
4649         Mpi2SCSIIORequest_t *mpi_request;
4650         Mpi2SCSIIOReply_t *mpi_reply;
4651         struct scsi_cmnd *scmd;
4652         u16 ioc_status;
4653         u32 xfer_cnt;
4654         u8 scsi_state;
4655         u8 scsi_status;
4656         u32 log_info;
4657         struct MPT3SAS_DEVICE *sas_device_priv_data;
4658         u32 response_code = 0;
4659         unsigned long flags;
4660
4661         mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
4662         scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
4663         if (scmd == NULL)
4664                 return 1;
4665
4666         _scsih_set_satl_pending(scmd, false);
4667
4668         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
4669
4670         if (mpi_reply == NULL) {
4671                 scmd->result = DID_OK << 16;
4672                 goto out;
4673         }
4674
4675         sas_device_priv_data = scmd->device->hostdata;
4676         if (!sas_device_priv_data || !sas_device_priv_data->sas_target ||
4677              sas_device_priv_data->sas_target->deleted) {
4678                 scmd->result = DID_NO_CONNECT << 16;
4679                 goto out;
4680         }
4681         ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
4682
4683         /*
4684          * WARPDRIVE: If direct_io is set then it is directIO,
4685          * the failed direct I/O should be redirected to volume
4686          */
4687         if (mpt3sas_scsi_direct_io_get(ioc, smid) &&
4688              ((ioc_status & MPI2_IOCSTATUS_MASK)
4689               != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
4690                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
4691                 ioc->scsi_lookup[smid - 1].scmd = scmd;
4692                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
4693                 mpt3sas_scsi_direct_io_set(ioc, smid, 0);
4694                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
4695                 mpi_request->DevHandle =
4696                     cpu_to_le16(sas_device_priv_data->sas_target->handle);
4697                 ioc->put_smid_scsi_io(ioc, smid,
4698                     sas_device_priv_data->sas_target->handle);
4699                 return 0;
4700         }
4701         /* turning off TLR */
4702         scsi_state = mpi_reply->SCSIState;
4703         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
4704                 response_code =
4705                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
4706         if (!sas_device_priv_data->tlr_snoop_check) {
4707                 sas_device_priv_data->tlr_snoop_check++;
4708                 if (!ioc->is_warpdrive &&
4709                     !scsih_is_raid(&scmd->device->sdev_gendev) &&
4710                     sas_is_tlr_enabled(scmd->device) &&
4711                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
4712                         sas_disable_tlr(scmd->device);
4713                         sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
4714                 }
4715         }
4716
4717         xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
4718         scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt);
4719         if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
4720                 log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
4721         else
4722                 log_info = 0;
4723         ioc_status &= MPI2_IOCSTATUS_MASK;
4724         scsi_status = mpi_reply->SCSIStatus;
4725
4726         if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
4727             (scsi_status == MPI2_SCSI_STATUS_BUSY ||
4728              scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT ||
4729              scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) {
4730                 ioc_status = MPI2_IOCSTATUS_SUCCESS;
4731         }
4732
4733         if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
4734                 struct sense_info data;
4735                 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc,
4736                     smid);
4737                 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
4738                     le32_to_cpu(mpi_reply->SenseCount));
4739                 memcpy(scmd->sense_buffer, sense_data, sz);
4740                 _scsih_normalize_sense(scmd->sense_buffer, &data);
4741                 /* failure prediction threshold exceeded */
4742                 if (data.asc == 0x5D)
4743                         _scsih_smart_predicted_fault(ioc,
4744                             le16_to_cpu(mpi_reply->DevHandle));
4745                 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
4746
4747                 if ((ioc->logging_level & MPT_DEBUG_REPLY) &&
4748                      ((scmd->sense_buffer[2] == UNIT_ATTENTION) ||
4749                      (scmd->sense_buffer[2] == MEDIUM_ERROR) ||
4750                      (scmd->sense_buffer[2] == HARDWARE_ERROR)))
4751                         _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid);
4752         }
4753         switch (ioc_status) {
4754         case MPI2_IOCSTATUS_BUSY:
4755         case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES:
4756                 scmd->result = SAM_STAT_BUSY;
4757                 break;
4758
4759         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
4760                 scmd->result = DID_NO_CONNECT << 16;
4761                 break;
4762
4763         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
4764                 if (sas_device_priv_data->block) {
4765                         scmd->result = DID_TRANSPORT_DISRUPTED << 16;
4766                         goto out;
4767                 }
4768                 if (log_info == 0x31110630) {
4769                         if (scmd->retries > 2) {
4770                                 scmd->result = DID_NO_CONNECT << 16;
4771                                 scsi_device_set_state(scmd->device,
4772                                     SDEV_OFFLINE);
4773                         } else {
4774                                 scmd->result = DID_SOFT_ERROR << 16;
4775                                 scmd->device->expecting_cc_ua = 1;
4776                         }
4777                         break;
4778                 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) {
4779                         scmd->result = DID_RESET << 16;
4780                         break;
4781                 }
4782                 scmd->result = DID_SOFT_ERROR << 16;
4783                 break;
4784         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
4785         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
4786                 scmd->result = DID_RESET << 16;
4787                 break;
4788
4789         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
4790                 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt))
4791                         scmd->result = DID_SOFT_ERROR << 16;
4792                 else
4793                         scmd->result = (DID_OK << 16) | scsi_status;
4794                 break;
4795
4796         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
4797                 scmd->result = (DID_OK << 16) | scsi_status;
4798
4799                 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID))
4800                         break;
4801
4802                 if (xfer_cnt < scmd->underflow) {
4803                         if (scsi_status == SAM_STAT_BUSY)
4804                                 scmd->result = SAM_STAT_BUSY;
4805                         else
4806                                 scmd->result = DID_SOFT_ERROR << 16;
4807                 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4808                      MPI2_SCSI_STATE_NO_SCSI_STATUS))
4809                         scmd->result = DID_SOFT_ERROR << 16;
4810                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4811                         scmd->result = DID_RESET << 16;
4812                 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
4813                         mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
4814                         mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
4815                         scmd->result = (DRIVER_SENSE << 24) |
4816                             SAM_STAT_CHECK_CONDITION;
4817                         scmd->sense_buffer[0] = 0x70;
4818                         scmd->sense_buffer[2] = ILLEGAL_REQUEST;
4819                         scmd->sense_buffer[12] = 0x20;
4820                         scmd->sense_buffer[13] = 0;
4821                 }
4822                 break;
4823
4824         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
4825                 scsi_set_resid(scmd, 0);
4826         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
4827         case MPI2_IOCSTATUS_SUCCESS:
4828                 scmd->result = (DID_OK << 16) | scsi_status;
4829                 if (response_code ==
4830                     MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
4831                     (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
4832                      MPI2_SCSI_STATE_NO_SCSI_STATUS)))
4833                         scmd->result = DID_SOFT_ERROR << 16;
4834                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
4835                         scmd->result = DID_RESET << 16;
4836                 break;
4837
4838         case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
4839         case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
4840         case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
4841                 _scsih_eedp_error_handling(scmd, ioc_status);
4842                 break;
4843
4844         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
4845         case MPI2_IOCSTATUS_INVALID_FUNCTION:
4846         case MPI2_IOCSTATUS_INVALID_SGL:
4847         case MPI2_IOCSTATUS_INTERNAL_ERROR:
4848         case MPI2_IOCSTATUS_INVALID_FIELD:
4849         case MPI2_IOCSTATUS_INVALID_STATE:
4850         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
4851         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
4852         case MPI2_IOCSTATUS_INSUFFICIENT_POWER:
4853         default:
4854                 scmd->result = DID_SOFT_ERROR << 16;
4855                 break;
4856
4857         }
4858
4859         if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY))
4860                 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid);
4861
4862  out:
4863
4864         scsi_dma_unmap(scmd);
4865
4866         scmd->scsi_done(scmd);
4867         return 1;
4868 }
4869
4870 /**
4871  * _scsih_sas_host_refresh - refreshing sas host object contents
4872  * @ioc: per adapter object
4873  * Context: user
4874  *
4875  * During port enable, fw will send topology events for every device. Its
4876  * possible that the handles may change from the previous setting, so this
4877  * code keeping handles updating if changed.
4878  *
4879  * Return nothing.
4880  */
4881 static void
4882 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc)
4883 {
4884         u16 sz;
4885         u16 ioc_status;
4886         int i;
4887         Mpi2ConfigReply_t mpi_reply;
4888         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4889         u16 attached_handle;
4890         u8 link_rate;
4891
4892         dtmprintk(ioc, pr_info(MPT3SAS_FMT
4893             "updating handles for sas_host(0x%016llx)\n",
4894             ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
4895
4896         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
4897             * sizeof(Mpi2SasIOUnit0PhyData_t));
4898         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4899         if (!sas_iounit_pg0) {
4900                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4901                     ioc->name, __FILE__, __LINE__, __func__);
4902                 return;
4903         }
4904
4905         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4906             sas_iounit_pg0, sz)) != 0)
4907                 goto out;
4908         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
4909         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
4910                 goto out;
4911         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
4912                 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
4913                 if (i == 0)
4914                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
4915                             PhyData[0].ControllerDevHandle);
4916                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
4917                 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
4918                     AttachedDevHandle);
4919                 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
4920                         link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
4921                 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
4922                     attached_handle, i, link_rate);
4923         }
4924  out:
4925         kfree(sas_iounit_pg0);
4926 }
4927
4928 /**
4929  * _scsih_sas_host_add - create sas host object
4930  * @ioc: per adapter object
4931  *
4932  * Creating host side data object, stored in ioc->sas_hba
4933  *
4934  * Return nothing.
4935  */
4936 static void
4937 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc)
4938 {
4939         int i;
4940         Mpi2ConfigReply_t mpi_reply;
4941         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
4942         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
4943         Mpi2SasPhyPage0_t phy_pg0;
4944         Mpi2SasDevicePage0_t sas_device_pg0;
4945         Mpi2SasEnclosurePage0_t enclosure_pg0;
4946         u16 ioc_status;
4947         u16 sz;
4948         u8 device_missing_delay;
4949         u8 num_phys;
4950
4951         mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
4952         if (!num_phys) {
4953                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4954                     ioc->name, __FILE__, __LINE__, __func__);
4955                 return;
4956         }
4957         ioc->sas_hba.phy = kcalloc(num_phys,
4958             sizeof(struct _sas_phy), GFP_KERNEL);
4959         if (!ioc->sas_hba.phy) {
4960                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4961                     ioc->name, __FILE__, __LINE__, __func__);
4962                 goto out;
4963         }
4964         ioc->sas_hba.num_phys = num_phys;
4965
4966         /* sas_iounit page 0 */
4967         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
4968             sizeof(Mpi2SasIOUnit0PhyData_t));
4969         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
4970         if (!sas_iounit_pg0) {
4971                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4972                     ioc->name, __FILE__, __LINE__, __func__);
4973                 return;
4974         }
4975         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
4976             sas_iounit_pg0, sz))) {
4977                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4978                     ioc->name, __FILE__, __LINE__, __func__);
4979                 goto out;
4980         }
4981         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4982             MPI2_IOCSTATUS_MASK;
4983         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4984                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4985                     ioc->name, __FILE__, __LINE__, __func__);
4986                 goto out;
4987         }
4988
4989         /* sas_iounit page 1 */
4990         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
4991             sizeof(Mpi2SasIOUnit1PhyData_t));
4992         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
4993         if (!sas_iounit_pg1) {
4994                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
4995                     ioc->name, __FILE__, __LINE__, __func__);
4996                 goto out;
4997         }
4998         if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4999             sas_iounit_pg1, sz))) {
5000                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5001                     ioc->name, __FILE__, __LINE__, __func__);
5002                 goto out;
5003         }
5004         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5005             MPI2_IOCSTATUS_MASK;
5006         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5007                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5008                     ioc->name, __FILE__, __LINE__, __func__);
5009                 goto out;
5010         }
5011
5012         ioc->io_missing_delay =
5013             sas_iounit_pg1->IODeviceMissingDelay;
5014         device_missing_delay =
5015             sas_iounit_pg1->ReportDeviceMissingDelay;
5016         if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
5017                 ioc->device_missing_delay = (device_missing_delay &
5018                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
5019         else
5020                 ioc->device_missing_delay = device_missing_delay &
5021                     MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
5022
5023         ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev;
5024         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
5025                 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
5026                     i))) {
5027                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5028                             ioc->name, __FILE__, __LINE__, __func__);
5029                         goto out;
5030                 }
5031                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5032                     MPI2_IOCSTATUS_MASK;
5033                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5034                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5035                             ioc->name, __FILE__, __LINE__, __func__);
5036                         goto out;
5037                 }
5038
5039                 if (i == 0)
5040                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
5041                             PhyData[0].ControllerDevHandle);
5042                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
5043                 ioc->sas_hba.phy[i].phy_id = i;
5044                 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
5045                     phy_pg0, ioc->sas_hba.parent_dev);
5046         }
5047         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5048             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
5049                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5050                     ioc->name, __FILE__, __LINE__, __func__);
5051                 goto out;
5052         }
5053         ioc->sas_hba.enclosure_handle =
5054             le16_to_cpu(sas_device_pg0.EnclosureHandle);
5055         ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5056         pr_info(MPT3SAS_FMT
5057                 "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
5058                 ioc->name, ioc->sas_hba.handle,
5059             (unsigned long long) ioc->sas_hba.sas_address,
5060             ioc->sas_hba.num_phys) ;
5061
5062         if (ioc->sas_hba.enclosure_handle) {
5063                 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
5064                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5065                    ioc->sas_hba.enclosure_handle)))
5066                         ioc->sas_hba.enclosure_logical_id =
5067                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5068         }
5069
5070  out:
5071         kfree(sas_iounit_pg1);
5072         kfree(sas_iounit_pg0);
5073 }
5074
5075 /**
5076  * _scsih_expander_add -  creating expander object
5077  * @ioc: per adapter object
5078  * @handle: expander handle
5079  *
5080  * Creating expander object, stored in ioc->sas_expander_list.
5081  *
5082  * Return 0 for success, else error.
5083  */
5084 static int
5085 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle)
5086 {
5087         struct _sas_node *sas_expander;
5088         Mpi2ConfigReply_t mpi_reply;
5089         Mpi2ExpanderPage0_t expander_pg0;
5090         Mpi2ExpanderPage1_t expander_pg1;
5091         Mpi2SasEnclosurePage0_t enclosure_pg0;
5092         u32 ioc_status;
5093         u16 parent_handle;
5094         u64 sas_address, sas_address_parent = 0;
5095         int i;
5096         unsigned long flags;
5097         struct _sas_port *mpt3sas_port = NULL;
5098
5099         int rc = 0;
5100
5101         if (!handle)
5102                 return -1;
5103
5104         if (ioc->shost_recovery || ioc->pci_error_recovery)
5105                 return -1;
5106
5107         if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
5108             MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
5109                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5110                     ioc->name, __FILE__, __LINE__, __func__);
5111                 return -1;
5112         }
5113
5114         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5115             MPI2_IOCSTATUS_MASK;
5116         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5117                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5118                     ioc->name, __FILE__, __LINE__, __func__);
5119                 return -1;
5120         }
5121
5122         /* handle out of order topology events */
5123         parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
5124         if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
5125             != 0) {
5126                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5127                     ioc->name, __FILE__, __LINE__, __func__);
5128                 return -1;
5129         }
5130         if (sas_address_parent != ioc->sas_hba.sas_address) {
5131                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
5132                 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5133                     sas_address_parent);
5134                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5135                 if (!sas_expander) {
5136                         rc = _scsih_expander_add(ioc, parent_handle);
5137                         if (rc != 0)
5138                                 return rc;
5139                 }
5140         }
5141
5142         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5143         sas_address = le64_to_cpu(expander_pg0.SASAddress);
5144         sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5145             sas_address);
5146         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5147
5148         if (sas_expander)
5149                 return 0;
5150
5151         sas_expander = kzalloc(sizeof(struct _sas_node),
5152             GFP_KERNEL);
5153         if (!sas_expander) {
5154                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5155                     ioc->name, __FILE__, __LINE__, __func__);
5156                 return -1;
5157         }
5158
5159         sas_expander->handle = handle;
5160         sas_expander->num_phys = expander_pg0.NumPhys;
5161         sas_expander->sas_address_parent = sas_address_parent;
5162         sas_expander->sas_address = sas_address;
5163
5164         pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \
5165             " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
5166             handle, parent_handle, (unsigned long long)
5167             sas_expander->sas_address, sas_expander->num_phys);
5168
5169         if (!sas_expander->num_phys)
5170                 goto out_fail;
5171         sas_expander->phy = kcalloc(sas_expander->num_phys,
5172             sizeof(struct _sas_phy), GFP_KERNEL);
5173         if (!sas_expander->phy) {
5174                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5175                     ioc->name, __FILE__, __LINE__, __func__);
5176                 rc = -1;
5177                 goto out_fail;
5178         }
5179
5180         INIT_LIST_HEAD(&sas_expander->sas_port_list);
5181         mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
5182             sas_address_parent);
5183         if (!mpt3sas_port) {
5184                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5185                     ioc->name, __FILE__, __LINE__, __func__);
5186                 rc = -1;
5187                 goto out_fail;
5188         }
5189         sas_expander->parent_dev = &mpt3sas_port->rphy->dev;
5190
5191         for (i = 0 ; i < sas_expander->num_phys ; i++) {
5192                 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
5193                     &expander_pg1, i, handle))) {
5194                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5195                             ioc->name, __FILE__, __LINE__, __func__);
5196                         rc = -1;
5197                         goto out_fail;
5198                 }
5199                 sas_expander->phy[i].handle = handle;
5200                 sas_expander->phy[i].phy_id = i;
5201
5202                 if ((mpt3sas_transport_add_expander_phy(ioc,
5203                     &sas_expander->phy[i], expander_pg1,
5204                     sas_expander->parent_dev))) {
5205                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5206                             ioc->name, __FILE__, __LINE__, __func__);
5207                         rc = -1;
5208                         goto out_fail;
5209                 }
5210         }
5211
5212         if (sas_expander->enclosure_handle) {
5213                 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
5214                     &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5215                    sas_expander->enclosure_handle)))
5216                         sas_expander->enclosure_logical_id =
5217                             le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5218         }
5219
5220         _scsih_expander_node_add(ioc, sas_expander);
5221          return 0;
5222
5223  out_fail:
5224
5225         if (mpt3sas_port)
5226                 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
5227                     sas_address_parent);
5228         kfree(sas_expander);
5229         return rc;
5230 }
5231
5232 /**
5233  * mpt3sas_expander_remove - removing expander object
5234  * @ioc: per adapter object
5235  * @sas_address: expander sas_address
5236  *
5237  * Return nothing.
5238  */
5239 void
5240 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address)
5241 {
5242         struct _sas_node *sas_expander;
5243         unsigned long flags;
5244
5245         if (ioc->shost_recovery)
5246                 return;
5247
5248         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5249         sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc,
5250             sas_address);
5251         if (sas_expander)
5252                 list_del(&sas_expander->list);
5253         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5254         if (sas_expander)
5255                 _scsih_expander_node_remove(ioc, sas_expander);
5256 }
5257
5258 /**
5259  * _scsih_done -  internal SCSI_IO callback handler.
5260  * @ioc: per adapter object
5261  * @smid: system request message index
5262  * @msix_index: MSIX table index supplied by the OS
5263  * @reply: reply message frame(lower 32bit addr)
5264  *
5265  * Callback handler when sending internal generated SCSI_IO.
5266  * The callback index passed is `ioc->scsih_cb_idx`
5267  *
5268  * Return 1 meaning mf should be freed from _base_interrupt
5269  *        0 means the mf is freed from this function.
5270  */
5271 static u8
5272 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
5273 {
5274         MPI2DefaultReply_t *mpi_reply;
5275
5276         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
5277         if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED)
5278                 return 1;
5279         if (ioc->scsih_cmds.smid != smid)
5280                 return 1;
5281         ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE;
5282         if (mpi_reply) {
5283                 memcpy(ioc->scsih_cmds.reply, mpi_reply,
5284                     mpi_reply->MsgLength*4);
5285                 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID;
5286         }
5287         ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING;
5288         complete(&ioc->scsih_cmds.done);
5289         return 1;
5290 }
5291
5292
5293
5294
5295 #define MPT3_MAX_LUNS (255)
5296
5297
5298 /**
5299  * _scsih_check_access_status - check access flags
5300  * @ioc: per adapter object
5301  * @sas_address: sas address
5302  * @handle: sas device handle
5303  * @access_flags: errors returned during discovery of the device
5304  *
5305  * Return 0 for success, else failure
5306  */
5307 static u8
5308 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
5309         u16 handle, u8 access_status)
5310 {
5311         u8 rc = 1;
5312         char *desc = NULL;
5313
5314         switch (access_status) {
5315         case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS:
5316         case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION:
5317                 rc = 0;
5318                 break;
5319         case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED:
5320                 desc = "sata capability failed";
5321                 break;
5322         case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT:
5323                 desc = "sata affiliation conflict";
5324                 break;
5325         case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE:
5326                 desc = "route not addressable";
5327                 break;
5328         case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE:
5329                 desc = "smp error not addressable";
5330                 break;
5331         case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED:
5332                 desc = "device blocked";
5333                 break;
5334         case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED:
5335         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN:
5336         case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT:
5337         case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG:
5338         case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION:
5339         case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER:
5340         case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN:
5341         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN:
5342         case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN:
5343         case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION:
5344         case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE:
5345         case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX:
5346                 desc = "sata initialization failed";
5347                 break;
5348         default:
5349                 desc = "unknown";
5350                 break;
5351         }
5352
5353         if (!rc)
5354                 return 0;
5355
5356         pr_err(MPT3SAS_FMT
5357                 "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
5358                 ioc->name, desc, (unsigned long long)sas_address, handle);
5359         return rc;
5360 }
5361
5362 /**
5363  * _scsih_check_device - checking device responsiveness
5364  * @ioc: per adapter object
5365  * @parent_sas_address: sas address of parent expander or sas host
5366  * @handle: attached device handle
5367  * @phy_numberv: phy number
5368  * @link_rate: new link rate
5369  *
5370  * Returns nothing.
5371  */
5372 static void
5373 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc,
5374         u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate)
5375 {
5376         Mpi2ConfigReply_t mpi_reply;
5377         Mpi2SasDevicePage0_t sas_device_pg0;
5378         struct _sas_device *sas_device;
5379         u32 ioc_status;
5380         unsigned long flags;
5381         u64 sas_address;
5382         struct scsi_target *starget;
5383         struct MPT3SAS_TARGET *sas_target_priv_data;
5384         u32 device_info;
5385
5386
5387         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5388             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
5389                 return;
5390
5391         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5392         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
5393                 return;
5394
5395         /* wide port handling ~ we need only handle device once for the phy that
5396          * is matched in sas device page zero
5397          */
5398         if (phy_number != sas_device_pg0.PhyNum)
5399                 return;
5400
5401         /* check if this is end device */
5402         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5403         if (!(_scsih_is_end_device(device_info)))
5404                 return;
5405
5406         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5407         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5408         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
5409             sas_address);
5410
5411         if (!sas_device)
5412                 goto out_unlock;
5413
5414         if (unlikely(sas_device->handle != handle)) {
5415                 starget = sas_device->starget;
5416                 sas_target_priv_data = starget->hostdata;
5417                 starget_printk(KERN_INFO, starget,
5418                         "handle changed from(0x%04x) to (0x%04x)!!!\n",
5419                         sas_device->handle, handle);
5420                 sas_target_priv_data->handle = handle;
5421                 sas_device->handle = handle;
5422                 if (le16_to_cpu(sas_device_pg0.Flags) &
5423                      MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
5424                         sas_device->enclosure_level =
5425                                 sas_device_pg0.EnclosureLevel;
5426                         memcpy(sas_device->connector_name,
5427                                 sas_device_pg0.ConnectorName, 4);
5428                         sas_device->connector_name[4] = '\0';
5429                 } else {
5430                         sas_device->enclosure_level = 0;
5431                         sas_device->connector_name[0] = '\0';
5432                 }
5433         }
5434
5435         /* check if device is present */
5436         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5437             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5438                 pr_err(MPT3SAS_FMT
5439                         "device is not present handle(0x%04x), flags!!!\n",
5440                         ioc->name, handle);
5441                 goto out_unlock;
5442         }
5443
5444         /* check if there were any issues with discovery */
5445         if (_scsih_check_access_status(ioc, sas_address, handle,
5446             sas_device_pg0.AccessStatus))
5447                 goto out_unlock;
5448
5449         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5450         _scsih_ublock_io_device(ioc, sas_address);
5451
5452         if (sas_device)
5453                 sas_device_put(sas_device);
5454         return;
5455
5456 out_unlock:
5457         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5458         if (sas_device)
5459                 sas_device_put(sas_device);
5460 }
5461
5462 /**
5463  * _scsih_add_device -  creating sas device object
5464  * @ioc: per adapter object
5465  * @handle: sas device handle
5466  * @phy_num: phy number end device attached to
5467  * @is_pd: is this hidden raid component
5468  *
5469  * Creating end device object, stored in ioc->sas_device_list.
5470  *
5471  * Returns 0 for success, non-zero for failure.
5472  */
5473 static int
5474 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,
5475         u8 is_pd)
5476 {
5477         Mpi2ConfigReply_t mpi_reply;
5478         Mpi2SasDevicePage0_t sas_device_pg0;
5479         Mpi2SasEnclosurePage0_t enclosure_pg0;
5480         struct _sas_device *sas_device;
5481         u32 ioc_status;
5482         u64 sas_address;
5483         u32 device_info;
5484
5485         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
5486             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
5487                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5488                     ioc->name, __FILE__, __LINE__, __func__);
5489                 return -1;
5490         }
5491
5492         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5493             MPI2_IOCSTATUS_MASK;
5494         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5495                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5496                     ioc->name, __FILE__, __LINE__, __func__);
5497                 return -1;
5498         }
5499
5500         /* check if this is end device */
5501         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5502         if (!(_scsih_is_end_device(device_info)))
5503                 return -1;
5504         set_bit(handle, ioc->pend_os_device_add);
5505         sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5506
5507         /* check if device is present */
5508         if (!(le16_to_cpu(sas_device_pg0.Flags) &
5509             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
5510                 pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n",
5511                         ioc->name, handle);
5512                 return -1;
5513         }
5514
5515         /* check if there were any issues with discovery */
5516         if (_scsih_check_access_status(ioc, sas_address, handle,
5517             sas_device_pg0.AccessStatus))
5518                 return -1;
5519
5520         sas_device = mpt3sas_get_sdev_by_addr(ioc,
5521                                         sas_address);
5522         if (sas_device) {
5523                 clear_bit(handle, ioc->pend_os_device_add);
5524                 sas_device_put(sas_device);
5525                 return -1;
5526         }
5527
5528         sas_device = kzalloc(sizeof(struct _sas_device),
5529             GFP_KERNEL);
5530         if (!sas_device) {
5531                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5532                     ioc->name, __FILE__, __LINE__, __func__);
5533                 return 0;
5534         }
5535
5536         kref_init(&sas_device->refcount);
5537         sas_device->handle = handle;
5538         if (_scsih_get_sas_address(ioc,
5539             le16_to_cpu(sas_device_pg0.ParentDevHandle),
5540             &sas_device->sas_address_parent) != 0)
5541                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
5542                     ioc->name, __FILE__, __LINE__, __func__);
5543         sas_device->enclosure_handle =
5544             le16_to_cpu(sas_device_pg0.EnclosureHandle);
5545         if (sas_device->enclosure_handle != 0)
5546                 sas_device->slot =
5547                     le16_to_cpu(sas_device_pg0.Slot);
5548         sas_device->device_info = device_info;
5549         sas_device->sas_address = sas_address;
5550         sas_device->phy = sas_device_pg0.PhyNum;
5551         sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) &
5552             MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0;
5553
5554         if (le16_to_cpu(sas_device_pg0.Flags)
5555                 & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
5556                 sas_device->enclosure_level =
5557                         sas_device_pg0.EnclosureLevel;
5558                 memcpy(sas_device->connector_name,
5559                         sas_device_pg0.ConnectorName, 4);
5560                 sas_device->connector_name[4] = '\0';
5561         } else {
5562                 sas_device->enclosure_level = 0;
5563                 sas_device->connector_name[0] = '\0';
5564         }
5565         /* get enclosure_logical_id */
5566         if (sas_device->enclosure_handle && !(mpt3sas_config_get_enclosure_pg0(
5567            ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE,
5568            sas_device->enclosure_handle)))
5569                 sas_device->enclosure_logical_id =
5570                     le64_to_cpu(enclosure_pg0.EnclosureLogicalID);
5571
5572         /* get device name */
5573         sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
5574
5575         if (ioc->wait_for_discovery_to_complete)
5576                 _scsih_sas_device_init_add(ioc, sas_device);
5577         else
5578                 _scsih_sas_device_add(ioc, sas_device);
5579
5580         sas_device_put(sas_device);
5581         return 0;
5582 }
5583
5584 /**
5585  * _scsih_remove_device -  removing sas device object
5586  * @ioc: per adapter object
5587  * @sas_device_delete: the sas_device object
5588  *
5589  * Return nothing.
5590  */
5591 static void
5592 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,
5593         struct _sas_device *sas_device)
5594 {
5595         struct MPT3SAS_TARGET *sas_target_priv_data;
5596
5597         if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
5598              (sas_device->pfa_led_on)) {
5599                 _scsih_turn_off_pfa_led(ioc, sas_device);
5600                 sas_device->pfa_led_on = 0;
5601         }
5602         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5603                 "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
5604                 ioc->name, __func__,
5605             sas_device->handle, (unsigned long long)
5606             sas_device->sas_address));
5607         if (sas_device->enclosure_handle != 0)
5608                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5609                     "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
5610                     ioc->name, __func__,
5611                     (unsigned long long)sas_device->enclosure_logical_id,
5612                     sas_device->slot));
5613         if (sas_device->connector_name[0] != '\0')
5614                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5615                   "%s: enter: enclosure level(0x%04x), connector name( %s)\n",
5616                   ioc->name, __func__,
5617                   sas_device->enclosure_level,
5618                   sas_device->connector_name));
5619
5620         if (sas_device->starget && sas_device->starget->hostdata) {
5621                 sas_target_priv_data = sas_device->starget->hostdata;
5622                 sas_target_priv_data->deleted = 1;
5623                 _scsih_ublock_io_device(ioc, sas_device->sas_address);
5624                 sas_target_priv_data->handle =
5625                      MPT3SAS_INVALID_DEVICE_HANDLE;
5626         }
5627
5628         if (!ioc->hide_drives)
5629                 mpt3sas_transport_port_remove(ioc,
5630                     sas_device->sas_address,
5631                     sas_device->sas_address_parent);
5632
5633         pr_info(MPT3SAS_FMT
5634                 "removing handle(0x%04x), sas_addr(0x%016llx)\n",
5635                 ioc->name, sas_device->handle,
5636             (unsigned long long) sas_device->sas_address);
5637         if (sas_device->enclosure_handle != 0)
5638                 pr_info(MPT3SAS_FMT
5639                   "removing : enclosure logical id(0x%016llx), slot(%d)\n",
5640                   ioc->name,
5641                   (unsigned long long)sas_device->enclosure_logical_id,
5642                   sas_device->slot);
5643         if (sas_device->connector_name[0] != '\0')
5644                 pr_info(MPT3SAS_FMT
5645                   "removing enclosure level(0x%04x), connector name( %s)\n",
5646                   ioc->name, sas_device->enclosure_level,
5647                   sas_device->connector_name);
5648
5649         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5650                 "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
5651                 ioc->name, __func__,
5652                 sas_device->handle, (unsigned long long)
5653                 sas_device->sas_address));
5654         if (sas_device->enclosure_handle != 0)
5655                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5656                     "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
5657                     ioc->name, __func__,
5658                     (unsigned long long)sas_device->enclosure_logical_id,
5659                     sas_device->slot));
5660         if (sas_device->connector_name[0] != '\0')
5661                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5662                     "%s: exit: enclosure level(0x%04x), connector name(%s)\n",
5663                     ioc->name, __func__, sas_device->enclosure_level,
5664                     sas_device->connector_name));
5665 }
5666
5667 /**
5668  * _scsih_sas_topology_change_event_debug - debug for topology event
5669  * @ioc: per adapter object
5670  * @event_data: event data payload
5671  * Context: user.
5672  */
5673 static void
5674 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5675         Mpi2EventDataSasTopologyChangeList_t *event_data)
5676 {
5677         int i;
5678         u16 handle;
5679         u16 reason_code;
5680         u8 phy_number;
5681         char *status_str = NULL;
5682         u8 link_rate, prev_link_rate;
5683
5684         switch (event_data->ExpStatus) {
5685         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
5686                 status_str = "add";
5687                 break;
5688         case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
5689                 status_str = "remove";
5690                 break;
5691         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
5692         case 0:
5693                 status_str =  "responding";
5694                 break;
5695         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
5696                 status_str = "remove delay";
5697                 break;
5698         default:
5699                 status_str = "unknown status";
5700                 break;
5701         }
5702         pr_info(MPT3SAS_FMT "sas topology change: (%s)\n",
5703             ioc->name, status_str);
5704         pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
5705             "start_phy(%02d), count(%d)\n",
5706             le16_to_cpu(event_data->ExpanderDevHandle),
5707             le16_to_cpu(event_data->EnclosureHandle),
5708             event_data->StartPhyNum, event_data->NumEntries);
5709         for (i = 0; i < event_data->NumEntries; i++) {
5710                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5711                 if (!handle)
5712                         continue;
5713                 phy_number = event_data->StartPhyNum + i;
5714                 reason_code = event_data->PHY[i].PhyStatus &
5715                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5716                 switch (reason_code) {
5717                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5718                         status_str = "target add";
5719                         break;
5720                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5721                         status_str = "target remove";
5722                         break;
5723                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
5724                         status_str = "delay target remove";
5725                         break;
5726                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5727                         status_str = "link rate change";
5728                         break;
5729                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
5730                         status_str = "target responding";
5731                         break;
5732                 default:
5733                         status_str = "unknown";
5734                         break;
5735                 }
5736                 link_rate = event_data->PHY[i].LinkRate >> 4;
5737                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5738                 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \
5739                     " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
5740                     handle, status_str, link_rate, prev_link_rate);
5741
5742         }
5743 }
5744
5745 /**
5746  * _scsih_sas_topology_change_event - handle topology changes
5747  * @ioc: per adapter object
5748  * @fw_event: The fw_event_work object
5749  * Context: user.
5750  *
5751  */
5752 static int
5753 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc,
5754         struct fw_event_work *fw_event)
5755 {
5756         int i;
5757         u16 parent_handle, handle;
5758         u16 reason_code;
5759         u8 phy_number, max_phys;
5760         struct _sas_node *sas_expander;
5761         u64 sas_address;
5762         unsigned long flags;
5763         u8 link_rate, prev_link_rate;
5764         Mpi2EventDataSasTopologyChangeList_t *event_data =
5765                 (Mpi2EventDataSasTopologyChangeList_t *)
5766                 fw_event->event_data;
5767
5768         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5769                 _scsih_sas_topology_change_event_debug(ioc, event_data);
5770
5771         if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery)
5772                 return 0;
5773
5774         if (!ioc->sas_hba.num_phys)
5775                 _scsih_sas_host_add(ioc);
5776         else
5777                 _scsih_sas_host_refresh(ioc);
5778
5779         if (fw_event->ignore) {
5780                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
5781                         "ignoring expander event\n", ioc->name));
5782                 return 0;
5783         }
5784
5785         parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
5786
5787         /* handle expander add */
5788         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
5789                 if (_scsih_expander_add(ioc, parent_handle) != 0)
5790                         return 0;
5791
5792         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5793         sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc,
5794             parent_handle);
5795         if (sas_expander) {
5796                 sas_address = sas_expander->sas_address;
5797                 max_phys = sas_expander->num_phys;
5798         } else if (parent_handle < ioc->sas_hba.num_phys) {
5799                 sas_address = ioc->sas_hba.sas_address;
5800                 max_phys = ioc->sas_hba.num_phys;
5801         } else {
5802                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5803                 return 0;
5804         }
5805         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5806
5807         /* handle siblings events */
5808         for (i = 0; i < event_data->NumEntries; i++) {
5809                 if (fw_event->ignore) {
5810                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
5811                                 "ignoring expander event\n", ioc->name));
5812                         return 0;
5813                 }
5814                 if (ioc->remove_host || ioc->pci_error_recovery)
5815                         return 0;
5816                 phy_number = event_data->StartPhyNum + i;
5817                 if (phy_number >= max_phys)
5818                         continue;
5819                 reason_code = event_data->PHY[i].PhyStatus &
5820                     MPI2_EVENT_SAS_TOPO_RC_MASK;
5821                 if ((event_data->PHY[i].PhyStatus &
5822                     MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code !=
5823                     MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING))
5824                                 continue;
5825                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
5826                 if (!handle)
5827                         continue;
5828                 link_rate = event_data->PHY[i].LinkRate >> 4;
5829                 prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
5830                 switch (reason_code) {
5831                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
5832
5833                         if (ioc->shost_recovery)
5834                                 break;
5835
5836                         if (link_rate == prev_link_rate)
5837                                 break;
5838
5839                         mpt3sas_transport_update_links(ioc, sas_address,
5840                             handle, phy_number, link_rate);
5841
5842                         if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
5843                                 break;
5844
5845                         _scsih_check_device(ioc, sas_address, handle,
5846                             phy_number, link_rate);
5847
5848                         if (!test_bit(handle, ioc->pend_os_device_add))
5849                                 break;
5850
5851
5852                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
5853
5854                         if (ioc->shost_recovery)
5855                                 break;
5856
5857                         mpt3sas_transport_update_links(ioc, sas_address,
5858                             handle, phy_number, link_rate);
5859
5860                         _scsih_add_device(ioc, handle, phy_number, 0);
5861
5862                         break;
5863                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
5864
5865                         _scsih_device_remove_by_handle(ioc, handle);
5866                         break;
5867                 }
5868         }
5869
5870         /* handle expander removal */
5871         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
5872             sas_expander)
5873                 mpt3sas_expander_remove(ioc, sas_address);
5874
5875         return 0;
5876 }
5877
5878 /**
5879  * _scsih_sas_device_status_change_event_debug - debug for device event
5880  * @event_data: event data payload
5881  * Context: user.
5882  *
5883  * Return nothing.
5884  */
5885 static void
5886 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
5887         Mpi2EventDataSasDeviceStatusChange_t *event_data)
5888 {
5889         char *reason_str = NULL;
5890
5891         switch (event_data->ReasonCode) {
5892         case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
5893                 reason_str = "smart data";
5894                 break;
5895         case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
5896                 reason_str = "unsupported device discovered";
5897                 break;
5898         case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
5899                 reason_str = "internal device reset";
5900                 break;
5901         case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
5902                 reason_str = "internal task abort";
5903                 break;
5904         case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
5905                 reason_str = "internal task abort set";
5906                 break;
5907         case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
5908                 reason_str = "internal clear task set";
5909                 break;
5910         case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
5911                 reason_str = "internal query task";
5912                 break;
5913         case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
5914                 reason_str = "sata init failure";
5915                 break;
5916         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
5917                 reason_str = "internal device reset complete";
5918                 break;
5919         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
5920                 reason_str = "internal task abort complete";
5921                 break;
5922         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
5923                 reason_str = "internal async notification";
5924                 break;
5925         case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
5926                 reason_str = "expander reduced functionality";
5927                 break;
5928         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
5929                 reason_str = "expander reduced functionality complete";
5930                 break;
5931         default:
5932                 reason_str = "unknown reason";
5933                 break;
5934         }
5935         pr_info(MPT3SAS_FMT "device status change: (%s)\n"
5936             "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
5937             ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
5938             (unsigned long long)le64_to_cpu(event_data->SASAddress),
5939             le16_to_cpu(event_data->TaskTag));
5940         if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
5941                 pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
5942                     event_data->ASC, event_data->ASCQ);
5943         pr_info("\n");
5944 }
5945
5946 /**
5947  * _scsih_sas_device_status_change_event - handle device status change
5948  * @ioc: per adapter object
5949  * @fw_event: The fw_event_work object
5950  * Context: user.
5951  *
5952  * Return nothing.
5953  */
5954 static void
5955 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc,
5956         struct fw_event_work *fw_event)
5957 {
5958         struct MPT3SAS_TARGET *target_priv_data;
5959         struct _sas_device *sas_device;
5960         u64 sas_address;
5961         unsigned long flags;
5962         Mpi2EventDataSasDeviceStatusChange_t *event_data =
5963                 (Mpi2EventDataSasDeviceStatusChange_t *)
5964                 fw_event->event_data;
5965
5966         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5967                 _scsih_sas_device_status_change_event_debug(ioc,
5968                      event_data);
5969
5970         /* In MPI Revision K (0xC), the internal device reset complete was
5971          * implemented, so avoid setting tm_busy flag for older firmware.
5972          */
5973         if ((ioc->facts.HeaderVersion >> 8) < 0xC)
5974                 return;
5975
5976         if (event_data->ReasonCode !=
5977             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5978            event_data->ReasonCode !=
5979             MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET)
5980                 return;
5981
5982         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5983         sas_address = le64_to_cpu(event_data->SASAddress);
5984         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
5985             sas_address);
5986
5987         if (!sas_device || !sas_device->starget)
5988                 goto out;
5989
5990         target_priv_data = sas_device->starget->hostdata;
5991         if (!target_priv_data)
5992                 goto out;
5993
5994         if (event_data->ReasonCode ==
5995             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
5996                 target_priv_data->tm_busy = 1;
5997         else
5998                 target_priv_data->tm_busy = 0;
5999
6000 out:
6001         if (sas_device)
6002                 sas_device_put(sas_device);
6003
6004         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6005
6006 }
6007
6008 /**
6009  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure
6010  * event
6011  * @ioc: per adapter object
6012  * @event_data: event data payload
6013  * Context: user.
6014  *
6015  * Return nothing.
6016  */
6017 static void
6018 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6019         Mpi2EventDataSasEnclDevStatusChange_t *event_data)
6020 {
6021         char *reason_str = NULL;
6022
6023         switch (event_data->ReasonCode) {
6024         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
6025                 reason_str = "enclosure add";
6026                 break;
6027         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
6028                 reason_str = "enclosure remove";
6029                 break;
6030         default:
6031                 reason_str = "unknown reason";
6032                 break;
6033         }
6034
6035         pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n"
6036             "\thandle(0x%04x), enclosure logical id(0x%016llx)"
6037             " number slots(%d)\n", ioc->name, reason_str,
6038             le16_to_cpu(event_data->EnclosureHandle),
6039             (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
6040             le16_to_cpu(event_data->StartSlot));
6041 }
6042
6043 /**
6044  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
6045  * @ioc: per adapter object
6046  * @fw_event: The fw_event_work object
6047  * Context: user.
6048  *
6049  * Return nothing.
6050  */
6051 static void
6052 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc,
6053         struct fw_event_work *fw_event)
6054 {
6055         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
6056                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
6057                      (Mpi2EventDataSasEnclDevStatusChange_t *)
6058                      fw_event->event_data);
6059 }
6060
6061 /**
6062  * _scsih_sas_broadcast_primitive_event - handle broadcast events
6063  * @ioc: per adapter object
6064  * @fw_event: The fw_event_work object
6065  * Context: user.
6066  *
6067  * Return nothing.
6068  */
6069 static void
6070 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc,
6071         struct fw_event_work *fw_event)
6072 {
6073         struct scsi_cmnd *scmd;
6074         struct scsi_device *sdev;
6075         u16 smid, handle;
6076         u32 lun;
6077         struct MPT3SAS_DEVICE *sas_device_priv_data;
6078         u32 termination_count;
6079         u32 query_count;
6080         Mpi2SCSITaskManagementReply_t *mpi_reply;
6081         Mpi2EventDataSasBroadcastPrimitive_t *event_data =
6082                 (Mpi2EventDataSasBroadcastPrimitive_t *)
6083                 fw_event->event_data;
6084         u16 ioc_status;
6085         unsigned long flags;
6086         int r;
6087         u8 max_retries = 0;
6088         u8 task_abort_retries;
6089
6090         mutex_lock(&ioc->tm_cmds.mutex);
6091         pr_info(MPT3SAS_FMT
6092                 "%s: enter: phy number(%d), width(%d)\n",
6093                 ioc->name, __func__, event_data->PhyNum,
6094              event_data->PortWidth);
6095
6096         _scsih_block_io_all_device(ioc);
6097
6098         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
6099         mpi_reply = ioc->tm_cmds.reply;
6100  broadcast_aen_retry:
6101
6102         /* sanity checks for retrying this loop */
6103         if (max_retries++ == 5) {
6104                 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n",
6105                     ioc->name, __func__));
6106                 goto out;
6107         } else if (max_retries > 1)
6108                 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n",
6109                     ioc->name, __func__, max_retries - 1));
6110
6111         termination_count = 0;
6112         query_count = 0;
6113         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
6114                 if (ioc->shost_recovery)
6115                         goto out;
6116                 scmd = _scsih_scsi_lookup_get(ioc, smid);
6117                 if (!scmd)
6118                         continue;
6119                 sdev = scmd->device;
6120                 sas_device_priv_data = sdev->hostdata;
6121                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
6122                         continue;
6123                  /* skip hidden raid components */
6124                 if (sas_device_priv_data->sas_target->flags &
6125                     MPT_TARGET_FLAGS_RAID_COMPONENT)
6126                         continue;
6127                  /* skip volumes */
6128                 if (sas_device_priv_data->sas_target->flags &
6129                     MPT_TARGET_FLAGS_VOLUME)
6130                         continue;
6131
6132                 handle = sas_device_priv_data->sas_target->handle;
6133                 lun = sas_device_priv_data->lun;
6134                 query_count++;
6135
6136                 if (ioc->shost_recovery)
6137                         goto out;
6138
6139                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
6140                 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun,
6141                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30);
6142                 if (r == FAILED) {
6143                         sdev_printk(KERN_WARNING, sdev,
6144                             "mpt3sas_scsih_issue_tm: FAILED when sending "
6145                             "QUERY_TASK: scmd(%p)\n", scmd);
6146                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
6147                         goto broadcast_aen_retry;
6148                 }
6149                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
6150                     & MPI2_IOCSTATUS_MASK;
6151                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6152                         sdev_printk(KERN_WARNING, sdev,
6153                                 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n",
6154                                 ioc_status, scmd);
6155                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
6156                         goto broadcast_aen_retry;
6157                 }
6158
6159                 /* see if IO is still owned by IOC and target */
6160                 if (mpi_reply->ResponseCode ==
6161                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
6162                      mpi_reply->ResponseCode ==
6163                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) {
6164                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
6165                         continue;
6166                 }
6167                 task_abort_retries = 0;
6168  tm_retry:
6169                 if (task_abort_retries++ == 60) {
6170                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
6171                             "%s: ABORT_TASK: giving up\n", ioc->name,
6172                             __func__));
6173                         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
6174                         goto broadcast_aen_retry;
6175                 }
6176
6177                 if (ioc->shost_recovery)
6178                         goto out_no_lock;
6179
6180                 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id,
6181                     sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid,
6182                     30);
6183                 if (r == FAILED) {
6184                         sdev_printk(KERN_WARNING, sdev,
6185                             "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : "
6186                             "scmd(%p)\n", scmd);
6187                         goto tm_retry;
6188                 }
6189
6190                 if (task_abort_retries > 1)
6191                         sdev_printk(KERN_WARNING, sdev,
6192                             "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):"
6193                             " scmd(%p)\n",
6194                             task_abort_retries - 1, scmd);
6195
6196                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
6197                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
6198         }
6199
6200         if (ioc->broadcast_aen_pending) {
6201                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6202                         "%s: loop back due to pending AEN\n",
6203                         ioc->name, __func__));
6204                  ioc->broadcast_aen_pending = 0;
6205                  goto broadcast_aen_retry;
6206         }
6207
6208  out:
6209         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
6210  out_no_lock:
6211
6212         dewtprintk(ioc, pr_info(MPT3SAS_FMT
6213             "%s - exit, query_count = %d termination_count = %d\n",
6214             ioc->name, __func__, query_count, termination_count));
6215
6216         ioc->broadcast_aen_busy = 0;
6217         if (!ioc->shost_recovery)
6218                 _scsih_ublock_io_all_device(ioc);
6219         mutex_unlock(&ioc->tm_cmds.mutex);
6220 }
6221
6222 /**
6223  * _scsih_sas_discovery_event - handle discovery events
6224  * @ioc: per adapter object
6225  * @fw_event: The fw_event_work object
6226  * Context: user.
6227  *
6228  * Return nothing.
6229  */
6230 static void
6231 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc,
6232         struct fw_event_work *fw_event)
6233 {
6234         Mpi2EventDataSasDiscovery_t *event_data =
6235                 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data;
6236
6237         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
6238                 pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name,
6239                     (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
6240                     "start" : "stop");
6241                 if (event_data->DiscoveryStatus)
6242                         pr_info("discovery_status(0x%08x)",
6243                             le32_to_cpu(event_data->DiscoveryStatus));
6244                 pr_info("\n");
6245         }
6246
6247         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
6248             !ioc->sas_hba.num_phys) {
6249                 if (disable_discovery > 0 && ioc->shost_recovery) {
6250                         /* Wait for the reset to complete */
6251                         while (ioc->shost_recovery)
6252                                 ssleep(1);
6253                 }
6254                 _scsih_sas_host_add(ioc);
6255         }
6256 }
6257
6258 /**
6259  * _scsih_ir_fastpath - turn on fastpath for IR physdisk
6260  * @ioc: per adapter object
6261  * @handle: device handle for physical disk
6262  * @phys_disk_num: physical disk number
6263  *
6264  * Return 0 for success, else failure.
6265  */
6266 static int
6267 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num)
6268 {
6269         Mpi2RaidActionRequest_t *mpi_request;
6270         Mpi2RaidActionReply_t *mpi_reply;
6271         u16 smid;
6272         u8 issue_reset = 0;
6273         int rc = 0;
6274         u16 ioc_status;
6275         u32 log_info;
6276
6277         if (ioc->hba_mpi_version_belonged == MPI2_VERSION)
6278                 return rc;
6279
6280         mutex_lock(&ioc->scsih_cmds.mutex);
6281
6282         if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
6283                 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
6284                     ioc->name, __func__);
6285                 rc = -EAGAIN;
6286                 goto out;
6287         }
6288         ioc->scsih_cmds.status = MPT3_CMD_PENDING;
6289
6290         smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
6291         if (!smid) {
6292                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
6293                     ioc->name, __func__);
6294                 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
6295                 rc = -EAGAIN;
6296                 goto out;
6297         }
6298
6299         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
6300         ioc->scsih_cmds.smid = smid;
6301         memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
6302
6303         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
6304         mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
6305         mpi_request->PhysDiskNum = phys_disk_num;
6306
6307         dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\
6308             "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name,
6309             handle, phys_disk_num));
6310
6311         init_completion(&ioc->scsih_cmds.done);
6312         ioc->put_smid_default(ioc, smid);
6313         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
6314
6315         if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
6316                 pr_err(MPT3SAS_FMT "%s: timeout\n",
6317                     ioc->name, __func__);
6318                 if (!(ioc->scsih_cmds.status & MPT3_CMD_RESET))
6319                         issue_reset = 1;
6320                 rc = -EFAULT;
6321                 goto out;
6322         }
6323
6324         if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
6325
6326                 mpi_reply = ioc->scsih_cmds.reply;
6327                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
6328                 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
6329                         log_info =  le32_to_cpu(mpi_reply->IOCLogInfo);
6330                 else
6331                         log_info = 0;
6332                 ioc_status &= MPI2_IOCSTATUS_MASK;
6333                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6334                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
6335                             "IR RAID_ACTION: failed: ioc_status(0x%04x), "
6336                             "loginfo(0x%08x)!!!\n", ioc->name, ioc_status,
6337                             log_info));
6338                         rc = -EFAULT;
6339                 } else
6340                         dewtprintk(ioc, pr_info(MPT3SAS_FMT
6341                             "IR RAID_ACTION: completed successfully\n",
6342                             ioc->name));
6343         }
6344
6345  out:
6346         ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
6347         mutex_unlock(&ioc->scsih_cmds.mutex);
6348
6349         if (issue_reset)
6350                 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
6351         return rc;
6352 }
6353
6354 /**
6355  * _scsih_reprobe_lun - reprobing lun
6356  * @sdev: scsi device struct
6357  * @no_uld_attach: sdev->no_uld_attach flag setting
6358  *
6359  **/
6360 static void
6361 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
6362 {
6363         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
6364         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
6365             sdev->no_uld_attach ? "hiding" : "exposing");
6366         WARN_ON(scsi_device_reprobe(sdev));
6367 }
6368
6369 /**
6370  * _scsih_sas_volume_add - add new volume
6371  * @ioc: per adapter object
6372  * @element: IR config element data
6373  * Context: user.
6374  *
6375  * Return nothing.
6376  */
6377 static void
6378 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc,
6379         Mpi2EventIrConfigElement_t *element)
6380 {
6381         struct _raid_device *raid_device;
6382         unsigned long flags;
6383         u64 wwid;
6384         u16 handle = le16_to_cpu(element->VolDevHandle);
6385         int rc;
6386
6387         mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
6388         if (!wwid) {
6389                 pr_err(MPT3SAS_FMT
6390                     "failure at %s:%d/%s()!\n", ioc->name,
6391                     __FILE__, __LINE__, __func__);
6392                 return;
6393         }
6394
6395         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6396         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
6397         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6398
6399         if (raid_device)
6400                 return;
6401
6402         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6403         if (!raid_device) {
6404                 pr_err(MPT3SAS_FMT
6405                     "failure at %s:%d/%s()!\n", ioc->name,
6406                     __FILE__, __LINE__, __func__);
6407                 return;
6408         }
6409
6410         raid_device->id = ioc->sas_id++;
6411         raid_device->channel = RAID_CHANNEL;
6412         raid_device->handle = handle;
6413         raid_device->wwid = wwid;
6414         _scsih_raid_device_add(ioc, raid_device);
6415         if (!ioc->wait_for_discovery_to_complete) {
6416                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6417                     raid_device->id, 0);
6418                 if (rc)
6419                         _scsih_raid_device_remove(ioc, raid_device);
6420         } else {
6421                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6422                 _scsih_determine_boot_device(ioc, raid_device, 1);
6423                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6424         }
6425 }
6426
6427 /**
6428  * _scsih_sas_volume_delete - delete volume
6429  * @ioc: per adapter object
6430  * @handle: volume device handle
6431  * Context: user.
6432  *
6433  * Return nothing.
6434  */
6435 static void
6436 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle)
6437 {
6438         struct _raid_device *raid_device;
6439         unsigned long flags;
6440         struct MPT3SAS_TARGET *sas_target_priv_data;
6441         struct scsi_target *starget = NULL;
6442
6443         spin_lock_irqsave(&ioc->raid_device_lock, flags);
6444         raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
6445         if (raid_device) {
6446                 if (raid_device->starget) {
6447                         starget = raid_device->starget;
6448                         sas_target_priv_data = starget->hostdata;
6449                         sas_target_priv_data->deleted = 1;
6450                 }
6451                 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
6452                         ioc->name,  raid_device->handle,
6453                     (unsigned long long) raid_device->wwid);
6454                 list_del(&raid_device->list);
6455                 kfree(raid_device);
6456         }
6457         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6458         if (starget)
6459                 scsi_remove_target(&starget->dev);
6460 }
6461
6462 /**
6463  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
6464  * @ioc: per adapter object
6465  * @element: IR config element data
6466  * Context: user.
6467  *
6468  * Return nothing.
6469  */
6470 static void
6471 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc,
6472         Mpi2EventIrConfigElement_t *element)
6473 {
6474         struct _sas_device *sas_device;
6475         struct scsi_target *starget = NULL;
6476         struct MPT3SAS_TARGET *sas_target_priv_data;
6477         unsigned long flags;
6478         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6479
6480         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6481         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
6482         if (sas_device) {
6483                 sas_device->volume_handle = 0;
6484                 sas_device->volume_wwid = 0;
6485                 clear_bit(handle, ioc->pd_handles);
6486                 if (sas_device->starget && sas_device->starget->hostdata) {
6487                         starget = sas_device->starget;
6488                         sas_target_priv_data = starget->hostdata;
6489                         sas_target_priv_data->flags &=
6490                             ~MPT_TARGET_FLAGS_RAID_COMPONENT;
6491                 }
6492         }
6493         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6494         if (!sas_device)
6495                 return;
6496
6497         /* exposing raid component */
6498         if (starget)
6499                 starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
6500
6501         sas_device_put(sas_device);
6502 }
6503
6504 /**
6505  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
6506  * @ioc: per adapter object
6507  * @element: IR config element data
6508  * Context: user.
6509  *
6510  * Return nothing.
6511  */
6512 static void
6513 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc,
6514         Mpi2EventIrConfigElement_t *element)
6515 {
6516         struct _sas_device *sas_device;
6517         struct scsi_target *starget = NULL;
6518         struct MPT3SAS_TARGET *sas_target_priv_data;
6519         unsigned long flags;
6520         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6521         u16 volume_handle = 0;
6522         u64 volume_wwid = 0;
6523
6524         mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle);
6525         if (volume_handle)
6526                 mpt3sas_config_get_volume_wwid(ioc, volume_handle,
6527                     &volume_wwid);
6528
6529         spin_lock_irqsave(&ioc->sas_device_lock, flags);
6530         sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle);
6531         if (sas_device) {
6532                 set_bit(handle, ioc->pd_handles);
6533                 if (sas_device->starget && sas_device->starget->hostdata) {
6534                         starget = sas_device->starget;
6535                         sas_target_priv_data = starget->hostdata;
6536                         sas_target_priv_data->flags |=
6537                             MPT_TARGET_FLAGS_RAID_COMPONENT;
6538                         sas_device->volume_handle = volume_handle;
6539                         sas_device->volume_wwid = volume_wwid;
6540                 }
6541         }
6542         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6543         if (!sas_device)
6544                 return;
6545
6546         /* hiding raid component */
6547         _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
6548
6549         if (starget)
6550                 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
6551
6552         sas_device_put(sas_device);
6553 }
6554
6555 /**
6556  * _scsih_sas_pd_delete - delete pd component
6557  * @ioc: per adapter object
6558  * @element: IR config element data
6559  * Context: user.
6560  *
6561  * Return nothing.
6562  */
6563 static void
6564 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc,
6565         Mpi2EventIrConfigElement_t *element)
6566 {
6567         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6568
6569         _scsih_device_remove_by_handle(ioc, handle);
6570 }
6571
6572 /**
6573  * _scsih_sas_pd_add - remove pd component
6574  * @ioc: per adapter object
6575  * @element: IR config element data
6576  * Context: user.
6577  *
6578  * Return nothing.
6579  */
6580 static void
6581 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc,
6582         Mpi2EventIrConfigElement_t *element)
6583 {
6584         struct _sas_device *sas_device;
6585         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
6586         Mpi2ConfigReply_t mpi_reply;
6587         Mpi2SasDevicePage0_t sas_device_pg0;
6588         u32 ioc_status;
6589         u64 sas_address;
6590         u16 parent_handle;
6591
6592         set_bit(handle, ioc->pd_handles);
6593
6594         sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
6595         if (sas_device) {
6596                 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
6597                 sas_device_put(sas_device);
6598                 return;
6599         }
6600
6601         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
6602             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
6603                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6604                     ioc->name, __FILE__, __LINE__, __func__);
6605                 return;
6606         }
6607
6608         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6609             MPI2_IOCSTATUS_MASK;
6610         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6611                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6612                     ioc->name, __FILE__, __LINE__, __func__);
6613                 return;
6614         }
6615
6616         parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6617         if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6618                 mpt3sas_transport_update_links(ioc, sas_address, handle,
6619                     sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6620
6621         _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum);
6622         _scsih_add_device(ioc, handle, 0, 1);
6623 }
6624
6625 /**
6626  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
6627  * @ioc: per adapter object
6628  * @event_data: event data payload
6629  * Context: user.
6630  *
6631  * Return nothing.
6632  */
6633 static void
6634 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc,
6635         Mpi2EventDataIrConfigChangeList_t *event_data)
6636 {
6637         Mpi2EventIrConfigElement_t *element;
6638         u8 element_type;
6639         int i;
6640         char *reason_str = NULL, *element_str = NULL;
6641
6642         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6643
6644         pr_info(MPT3SAS_FMT "raid config change: (%s), elements(%d)\n",
6645             ioc->name, (le32_to_cpu(event_data->Flags) &
6646             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
6647             "foreign" : "native", event_data->NumElements);
6648         for (i = 0; i < event_data->NumElements; i++, element++) {
6649                 switch (element->ReasonCode) {
6650                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6651                         reason_str = "add";
6652                         break;
6653                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6654                         reason_str = "remove";
6655                         break;
6656                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
6657                         reason_str = "no change";
6658                         break;
6659                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6660                         reason_str = "hide";
6661                         break;
6662                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6663                         reason_str = "unhide";
6664                         break;
6665                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6666                         reason_str = "volume_created";
6667                         break;
6668                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6669                         reason_str = "volume_deleted";
6670                         break;
6671                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6672                         reason_str = "pd_created";
6673                         break;
6674                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6675                         reason_str = "pd_deleted";
6676                         break;
6677                 default:
6678                         reason_str = "unknown reason";
6679                         break;
6680                 }
6681                 element_type = le16_to_cpu(element->ElementFlags) &
6682                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
6683                 switch (element_type) {
6684                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
6685                         element_str = "volume";
6686                         break;
6687                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
6688                         element_str = "phys disk";
6689                         break;
6690                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
6691                         element_str = "hot spare";
6692                         break;
6693                 default:
6694                         element_str = "unknown element";
6695                         break;
6696                 }
6697                 pr_info("\t(%s:%s), vol handle(0x%04x), " \
6698                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
6699                     reason_str, le16_to_cpu(element->VolDevHandle),
6700                     le16_to_cpu(element->PhysDiskDevHandle),
6701                     element->PhysDiskNum);
6702         }
6703 }
6704
6705 /**
6706  * _scsih_sas_ir_config_change_event - handle ir configuration change events
6707  * @ioc: per adapter object
6708  * @fw_event: The fw_event_work object
6709  * Context: user.
6710  *
6711  * Return nothing.
6712  */
6713 static void
6714 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc,
6715         struct fw_event_work *fw_event)
6716 {
6717         Mpi2EventIrConfigElement_t *element;
6718         int i;
6719         u8 foreign_config;
6720         Mpi2EventDataIrConfigChangeList_t *event_data =
6721                 (Mpi2EventDataIrConfigChangeList_t *)
6722                 fw_event->event_data;
6723
6724         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
6725              (!ioc->hide_ir_msg))
6726                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
6727
6728         foreign_config = (le32_to_cpu(event_data->Flags) &
6729             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
6730
6731         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
6732         if (ioc->shost_recovery &&
6733             ioc->hba_mpi_version_belonged != MPI2_VERSION) {
6734                 for (i = 0; i < event_data->NumElements; i++, element++) {
6735                         if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)
6736                                 _scsih_ir_fastpath(ioc,
6737                                         le16_to_cpu(element->PhysDiskDevHandle),
6738                                         element->PhysDiskNum);
6739                 }
6740                 return;
6741         }
6742
6743         for (i = 0; i < event_data->NumElements; i++, element++) {
6744
6745                 switch (element->ReasonCode) {
6746                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
6747                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
6748                         if (!foreign_config)
6749                                 _scsih_sas_volume_add(ioc, element);
6750                         break;
6751                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
6752                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
6753                         if (!foreign_config)
6754                                 _scsih_sas_volume_delete(ioc,
6755                                     le16_to_cpu(element->VolDevHandle));
6756                         break;
6757                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
6758                         if (!ioc->is_warpdrive)
6759                                 _scsih_sas_pd_hide(ioc, element);
6760                         break;
6761                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
6762                         if (!ioc->is_warpdrive)
6763                                 _scsih_sas_pd_expose(ioc, element);
6764                         break;
6765                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
6766                         if (!ioc->is_warpdrive)
6767                                 _scsih_sas_pd_add(ioc, element);
6768                         break;
6769                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
6770                         if (!ioc->is_warpdrive)
6771                                 _scsih_sas_pd_delete(ioc, element);
6772                         break;
6773                 }
6774         }
6775 }
6776
6777 /**
6778  * _scsih_sas_ir_volume_event - IR volume event
6779  * @ioc: per adapter object
6780  * @fw_event: The fw_event_work object
6781  * Context: user.
6782  *
6783  * Return nothing.
6784  */
6785 static void
6786 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc,
6787         struct fw_event_work *fw_event)
6788 {
6789         u64 wwid;
6790         unsigned long flags;
6791         struct _raid_device *raid_device;
6792         u16 handle;
6793         u32 state;
6794         int rc;
6795         Mpi2EventDataIrVolume_t *event_data =
6796                 (Mpi2EventDataIrVolume_t *) fw_event->event_data;
6797
6798         if (ioc->shost_recovery)
6799                 return;
6800
6801         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
6802                 return;
6803
6804         handle = le16_to_cpu(event_data->VolDevHandle);
6805         state = le32_to_cpu(event_data->NewValue);
6806         if (!ioc->hide_ir_msg)
6807                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6808                     "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
6809                     ioc->name, __func__,  handle,
6810                     le32_to_cpu(event_data->PreviousValue), state));
6811         switch (state) {
6812         case MPI2_RAID_VOL_STATE_MISSING:
6813         case MPI2_RAID_VOL_STATE_FAILED:
6814                 _scsih_sas_volume_delete(ioc, handle);
6815                 break;
6816
6817         case MPI2_RAID_VOL_STATE_ONLINE:
6818         case MPI2_RAID_VOL_STATE_DEGRADED:
6819         case MPI2_RAID_VOL_STATE_OPTIMAL:
6820
6821                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
6822                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
6823                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
6824
6825                 if (raid_device)
6826                         break;
6827
6828                 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
6829                 if (!wwid) {
6830                         pr_err(MPT3SAS_FMT
6831                             "failure at %s:%d/%s()!\n", ioc->name,
6832                             __FILE__, __LINE__, __func__);
6833                         break;
6834                 }
6835
6836                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
6837                 if (!raid_device) {
6838                         pr_err(MPT3SAS_FMT
6839                             "failure at %s:%d/%s()!\n", ioc->name,
6840                             __FILE__, __LINE__, __func__);
6841                         break;
6842                 }
6843
6844                 raid_device->id = ioc->sas_id++;
6845                 raid_device->channel = RAID_CHANNEL;
6846                 raid_device->handle = handle;
6847                 raid_device->wwid = wwid;
6848                 _scsih_raid_device_add(ioc, raid_device);
6849                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6850                     raid_device->id, 0);
6851                 if (rc)
6852                         _scsih_raid_device_remove(ioc, raid_device);
6853                 break;
6854
6855         case MPI2_RAID_VOL_STATE_INITIALIZING:
6856         default:
6857                 break;
6858         }
6859 }
6860
6861 /**
6862  * _scsih_sas_ir_physical_disk_event - PD event
6863  * @ioc: per adapter object
6864  * @fw_event: The fw_event_work object
6865  * Context: user.
6866  *
6867  * Return nothing.
6868  */
6869 static void
6870 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc,
6871         struct fw_event_work *fw_event)
6872 {
6873         u16 handle, parent_handle;
6874         u32 state;
6875         struct _sas_device *sas_device;
6876         Mpi2ConfigReply_t mpi_reply;
6877         Mpi2SasDevicePage0_t sas_device_pg0;
6878         u32 ioc_status;
6879         Mpi2EventDataIrPhysicalDisk_t *event_data =
6880                 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data;
6881         u64 sas_address;
6882
6883         if (ioc->shost_recovery)
6884                 return;
6885
6886         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
6887                 return;
6888
6889         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
6890         state = le32_to_cpu(event_data->NewValue);
6891
6892         if (!ioc->hide_ir_msg)
6893                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
6894                     "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
6895                     ioc->name, __func__,  handle,
6896                     le32_to_cpu(event_data->PreviousValue), state));
6897
6898         switch (state) {
6899         case MPI2_RAID_PD_STATE_ONLINE:
6900         case MPI2_RAID_PD_STATE_DEGRADED:
6901         case MPI2_RAID_PD_STATE_REBUILDING:
6902         case MPI2_RAID_PD_STATE_OPTIMAL:
6903         case MPI2_RAID_PD_STATE_HOT_SPARE:
6904
6905                 if (!ioc->is_warpdrive)
6906                         set_bit(handle, ioc->pd_handles);
6907
6908                 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
6909                 if (sas_device) {
6910                         sas_device_put(sas_device);
6911                         return;
6912                 }
6913
6914                 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
6915                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
6916                     handle))) {
6917                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6918                             ioc->name, __FILE__, __LINE__, __func__);
6919                         return;
6920                 }
6921
6922                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
6923                     MPI2_IOCSTATUS_MASK;
6924                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
6925                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
6926                             ioc->name, __FILE__, __LINE__, __func__);
6927                         return;
6928                 }
6929
6930                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
6931                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
6932                         mpt3sas_transport_update_links(ioc, sas_address, handle,
6933                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
6934
6935                 _scsih_add_device(ioc, handle, 0, 1);
6936
6937                 break;
6938
6939         case MPI2_RAID_PD_STATE_OFFLINE:
6940         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
6941         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
6942         default:
6943                 break;
6944         }
6945 }
6946
6947 /**
6948  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
6949  * @ioc: per adapter object
6950  * @event_data: event data payload
6951  * Context: user.
6952  *
6953  * Return nothing.
6954  */
6955 static void
6956 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc,
6957         Mpi2EventDataIrOperationStatus_t *event_data)
6958 {
6959         char *reason_str = NULL;
6960
6961         switch (event_data->RAIDOperation) {
6962         case MPI2_EVENT_IR_RAIDOP_RESYNC:
6963                 reason_str = "resync";
6964                 break;
6965         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
6966                 reason_str = "online capacity expansion";
6967                 break;
6968         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
6969                 reason_str = "consistency check";
6970                 break;
6971         case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
6972                 reason_str = "background init";
6973                 break;
6974         case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
6975                 reason_str = "make data consistent";
6976                 break;
6977         }
6978
6979         if (!reason_str)
6980                 return;
6981
6982         pr_info(MPT3SAS_FMT "raid operational status: (%s)" \
6983             "\thandle(0x%04x), percent complete(%d)\n",
6984             ioc->name, reason_str,
6985             le16_to_cpu(event_data->VolDevHandle),
6986             event_data->PercentComplete);
6987 }
6988
6989 /**
6990  * _scsih_sas_ir_operation_status_event - handle RAID operation events
6991  * @ioc: per adapter object
6992  * @fw_event: The fw_event_work object
6993  * Context: user.
6994  *
6995  * Return nothing.
6996  */
6997 static void
6998 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc,
6999         struct fw_event_work *fw_event)
7000 {
7001         Mpi2EventDataIrOperationStatus_t *event_data =
7002                 (Mpi2EventDataIrOperationStatus_t *)
7003                 fw_event->event_data;
7004         static struct _raid_device *raid_device;
7005         unsigned long flags;
7006         u16 handle;
7007
7008         if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&
7009             (!ioc->hide_ir_msg))
7010                 _scsih_sas_ir_operation_status_event_debug(ioc,
7011                      event_data);
7012
7013         /* code added for raid transport support */
7014         if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
7015
7016                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
7017                 handle = le16_to_cpu(event_data->VolDevHandle);
7018                 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
7019                 if (raid_device)
7020                         raid_device->percent_complete =
7021                             event_data->PercentComplete;
7022                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7023         }
7024 }
7025
7026 /**
7027  * _scsih_prep_device_scan - initialize parameters prior to device scan
7028  * @ioc: per adapter object
7029  *
7030  * Set the deleted flag prior to device scan.  If the device is found during
7031  * the scan, then we clear the deleted flag.
7032  */
7033 static void
7034 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc)
7035 {
7036         struct MPT3SAS_DEVICE *sas_device_priv_data;
7037         struct scsi_device *sdev;
7038
7039         shost_for_each_device(sdev, ioc->shost) {
7040                 sas_device_priv_data = sdev->hostdata;
7041                 if (sas_device_priv_data && sas_device_priv_data->sas_target)
7042                         sas_device_priv_data->sas_target->deleted = 1;
7043         }
7044 }
7045
7046 /**
7047  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
7048  * @ioc: per adapter object
7049  * @sas_device_pg0: SAS Device page 0
7050  *
7051  * After host reset, find out whether devices are still responding.
7052  * Used in _scsih_remove_unresponsive_sas_devices.
7053  *
7054  * Return nothing.
7055  */
7056 static void
7057 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc,
7058 Mpi2SasDevicePage0_t *sas_device_pg0)
7059 {
7060         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
7061         struct scsi_target *starget;
7062         struct _sas_device *sas_device;
7063         unsigned long flags;
7064
7065         spin_lock_irqsave(&ioc->sas_device_lock, flags);
7066         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
7067                 if ((sas_device->sas_address == sas_device_pg0->SASAddress) &&
7068                         (sas_device->slot == sas_device_pg0->Slot)) {
7069                         sas_device->responding = 1;
7070                         starget = sas_device->starget;
7071                         if (starget && starget->hostdata) {
7072                                 sas_target_priv_data = starget->hostdata;
7073                                 sas_target_priv_data->tm_busy = 0;
7074                                 sas_target_priv_data->deleted = 0;
7075                         } else
7076                                 sas_target_priv_data = NULL;
7077                         if (starget) {
7078                                 starget_printk(KERN_INFO, starget,
7079                                     "handle(0x%04x), sas_addr(0x%016llx)\n",
7080                                     sas_device_pg0->DevHandle,
7081                                     (unsigned long long)
7082                                     sas_device->sas_address);
7083
7084                                 if (sas_device->enclosure_handle != 0)
7085                                         starget_printk(KERN_INFO, starget,
7086                                          "enclosure logical id(0x%016llx),"
7087                                          " slot(%d)\n",
7088                                          (unsigned long long)
7089                                          sas_device->enclosure_logical_id,
7090                                          sas_device->slot);
7091                         }
7092                         if (sas_device_pg0->Flags &
7093                               MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) {
7094                                 sas_device->enclosure_level =
7095                                    sas_device_pg0->EnclosureLevel;
7096                                 memcpy(&sas_device->connector_name[0],
7097                                         &sas_device_pg0->ConnectorName[0], 4);
7098                         } else {
7099                                 sas_device->enclosure_level = 0;
7100                                 sas_device->connector_name[0] = '\0';
7101                         }
7102
7103                         if (sas_device->handle == sas_device_pg0->DevHandle)
7104                                 goto out;
7105                         pr_info("\thandle changed from(0x%04x)!!!\n",
7106                             sas_device->handle);
7107                         sas_device->handle = sas_device_pg0->DevHandle;
7108                         if (sas_target_priv_data)
7109                                 sas_target_priv_data->handle =
7110                                         sas_device_pg0->DevHandle;
7111                         goto out;
7112                 }
7113         }
7114  out:
7115         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7116 }
7117
7118 /**
7119  * _scsih_search_responding_sas_devices -
7120  * @ioc: per adapter object
7121  *
7122  * After host reset, find out whether devices are still responding.
7123  * If not remove.
7124  *
7125  * Return nothing.
7126  */
7127 static void
7128 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
7129 {
7130         Mpi2SasDevicePage0_t sas_device_pg0;
7131         Mpi2ConfigReply_t mpi_reply;
7132         u16 ioc_status;
7133         u16 handle;
7134         u32 device_info;
7135
7136         pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name);
7137
7138         if (list_empty(&ioc->sas_device_list))
7139                 goto out;
7140
7141         handle = 0xFFFF;
7142         while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7143             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
7144             handle))) {
7145                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7146                     MPI2_IOCSTATUS_MASK;
7147                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7148                         break;
7149                 handle = sas_device_pg0.DevHandle =
7150                                 le16_to_cpu(sas_device_pg0.DevHandle);
7151                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
7152                 if (!(_scsih_is_end_device(device_info)))
7153                         continue;
7154                 sas_device_pg0.SASAddress =
7155                                 le64_to_cpu(sas_device_pg0.SASAddress);
7156                 sas_device_pg0.Slot = le16_to_cpu(sas_device_pg0.Slot);
7157                 sas_device_pg0.Flags = le16_to_cpu(sas_device_pg0.Flags);
7158                 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0);
7159         }
7160
7161  out:
7162         pr_info(MPT3SAS_FMT "search for end-devices: complete\n",
7163             ioc->name);
7164 }
7165
7166 /**
7167  * _scsih_mark_responding_raid_device - mark a raid_device as responding
7168  * @ioc: per adapter object
7169  * @wwid: world wide identifier for raid volume
7170  * @handle: device handle
7171  *
7172  * After host reset, find out whether devices are still responding.
7173  * Used in _scsih_remove_unresponsive_raid_devices.
7174  *
7175  * Return nothing.
7176  */
7177 static void
7178 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid,
7179         u16 handle)
7180 {
7181         struct MPT3SAS_TARGET *sas_target_priv_data = NULL;
7182         struct scsi_target *starget;
7183         struct _raid_device *raid_device;
7184         unsigned long flags;
7185
7186         spin_lock_irqsave(&ioc->raid_device_lock, flags);
7187         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
7188                 if (raid_device->wwid == wwid && raid_device->starget) {
7189                         starget = raid_device->starget;
7190                         if (starget && starget->hostdata) {
7191                                 sas_target_priv_data = starget->hostdata;
7192                                 sas_target_priv_data->deleted = 0;
7193                         } else
7194                                 sas_target_priv_data = NULL;
7195                         raid_device->responding = 1;
7196                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7197                         starget_printk(KERN_INFO, raid_device->starget,
7198                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
7199                             (unsigned long long)raid_device->wwid);
7200
7201                         /*
7202                          * WARPDRIVE: The handles of the PDs might have changed
7203                          * across the host reset so re-initialize the
7204                          * required data for Direct IO
7205                          */
7206                         mpt3sas_init_warpdrive_properties(ioc, raid_device);
7207                         spin_lock_irqsave(&ioc->raid_device_lock, flags);
7208                         if (raid_device->handle == handle) {
7209                                 spin_unlock_irqrestore(&ioc->raid_device_lock,
7210                                     flags);
7211                                 return;
7212                         }
7213                         pr_info("\thandle changed from(0x%04x)!!!\n",
7214                             raid_device->handle);
7215                         raid_device->handle = handle;
7216                         if (sas_target_priv_data)
7217                                 sas_target_priv_data->handle = handle;
7218                         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7219                         return;
7220                 }
7221         }
7222         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7223 }
7224
7225 /**
7226  * _scsih_search_responding_raid_devices -
7227  * @ioc: per adapter object
7228  *
7229  * After host reset, find out whether devices are still responding.
7230  * If not remove.
7231  *
7232  * Return nothing.
7233  */
7234 static void
7235 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc)
7236 {
7237         Mpi2RaidVolPage1_t volume_pg1;
7238         Mpi2RaidVolPage0_t volume_pg0;
7239         Mpi2RaidPhysDiskPage0_t pd_pg0;
7240         Mpi2ConfigReply_t mpi_reply;
7241         u16 ioc_status;
7242         u16 handle;
7243         u8 phys_disk_num;
7244
7245         if (!ioc->ir_firmware)
7246                 return;
7247
7248         pr_info(MPT3SAS_FMT "search for raid volumes: start\n",
7249             ioc->name);
7250
7251         if (list_empty(&ioc->raid_device_list))
7252                 goto out;
7253
7254         handle = 0xFFFF;
7255         while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
7256             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
7257                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7258                     MPI2_IOCSTATUS_MASK;
7259                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7260                         break;
7261                 handle = le16_to_cpu(volume_pg1.DevHandle);
7262
7263                 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
7264                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
7265                      sizeof(Mpi2RaidVolPage0_t)))
7266                         continue;
7267
7268                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
7269                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
7270                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED)
7271                         _scsih_mark_responding_raid_device(ioc,
7272                             le64_to_cpu(volume_pg1.WWID), handle);
7273         }
7274
7275         /* refresh the pd_handles */
7276         if (!ioc->is_warpdrive) {
7277                 phys_disk_num = 0xFF;
7278                 memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
7279                 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
7280                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
7281                     phys_disk_num))) {
7282                         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7283                             MPI2_IOCSTATUS_MASK;
7284                         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7285                                 break;
7286                         phys_disk_num = pd_pg0.PhysDiskNum;
7287                         handle = le16_to_cpu(pd_pg0.DevHandle);
7288                         set_bit(handle, ioc->pd_handles);
7289                 }
7290         }
7291  out:
7292         pr_info(MPT3SAS_FMT "search for responding raid volumes: complete\n",
7293                 ioc->name);
7294 }
7295
7296 /**
7297  * _scsih_mark_responding_expander - mark a expander as responding
7298  * @ioc: per adapter object
7299  * @sas_address: sas address
7300  * @handle:
7301  *
7302  * After host reset, find out whether devices are still responding.
7303  * Used in _scsih_remove_unresponsive_expanders.
7304  *
7305  * Return nothing.
7306  */
7307 static void
7308 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
7309         u16 handle)
7310 {
7311         struct _sas_node *sas_expander;
7312         unsigned long flags;
7313         int i;
7314
7315         spin_lock_irqsave(&ioc->sas_node_lock, flags);
7316         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
7317                 if (sas_expander->sas_address != sas_address)
7318                         continue;
7319                 sas_expander->responding = 1;
7320                 if (sas_expander->handle == handle)
7321                         goto out;
7322                 pr_info("\texpander(0x%016llx): handle changed" \
7323                     " from(0x%04x) to (0x%04x)!!!\n",
7324                     (unsigned long long)sas_expander->sas_address,
7325                     sas_expander->handle, handle);
7326                 sas_expander->handle = handle;
7327                 for (i = 0 ; i < sas_expander->num_phys ; i++)
7328                         sas_expander->phy[i].handle = handle;
7329                 goto out;
7330         }
7331  out:
7332         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7333 }
7334
7335 /**
7336  * _scsih_search_responding_expanders -
7337  * @ioc: per adapter object
7338  *
7339  * After host reset, find out whether devices are still responding.
7340  * If not remove.
7341  *
7342  * Return nothing.
7343  */
7344 static void
7345 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc)
7346 {
7347         Mpi2ExpanderPage0_t expander_pg0;
7348         Mpi2ConfigReply_t mpi_reply;
7349         u16 ioc_status;
7350         u64 sas_address;
7351         u16 handle;
7352
7353         pr_info(MPT3SAS_FMT "search for expanders: start\n", ioc->name);
7354
7355         if (list_empty(&ioc->sas_expander_list))
7356                 goto out;
7357
7358         handle = 0xFFFF;
7359         while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
7360             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
7361
7362                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7363                     MPI2_IOCSTATUS_MASK;
7364                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
7365                         break;
7366
7367                 handle = le16_to_cpu(expander_pg0.DevHandle);
7368                 sas_address = le64_to_cpu(expander_pg0.SASAddress);
7369                 pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n",
7370                         handle,
7371                     (unsigned long long)sas_address);
7372                 _scsih_mark_responding_expander(ioc, sas_address, handle);
7373         }
7374
7375  out:
7376         pr_info(MPT3SAS_FMT "search for expanders: complete\n", ioc->name);
7377 }
7378
7379 /**
7380  * _scsih_remove_unresponding_sas_devices - removing unresponding devices
7381  * @ioc: per adapter object
7382  *
7383  * Return nothing.
7384  */
7385 static void
7386 _scsih_remove_unresponding_sas_devices(struct MPT3SAS_ADAPTER *ioc)
7387 {
7388         struct _sas_device *sas_device, *sas_device_next;
7389         struct _sas_node *sas_expander, *sas_expander_next;
7390         struct _raid_device *raid_device, *raid_device_next;
7391         struct list_head tmp_list;
7392         unsigned long flags;
7393         LIST_HEAD(head);
7394
7395         pr_info(MPT3SAS_FMT "removing unresponding devices: start\n",
7396             ioc->name);
7397
7398         /* removing unresponding end devices */
7399         pr_info(MPT3SAS_FMT "removing unresponding devices: end-devices\n",
7400             ioc->name);
7401         /*
7402          * Iterate, pulling off devices marked as non-responding. We become the
7403          * owner for the reference the list had on any object we prune.
7404          */
7405         spin_lock_irqsave(&ioc->sas_device_lock, flags);
7406         list_for_each_entry_safe(sas_device, sas_device_next,
7407             &ioc->sas_device_list, list) {
7408                 if (!sas_device->responding)
7409                         list_move_tail(&sas_device->list, &head);
7410                 else
7411                         sas_device->responding = 0;
7412         }
7413         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
7414
7415         /*
7416          * Now, uninitialize and remove the unresponding devices we pruned.
7417          */
7418         list_for_each_entry_safe(sas_device, sas_device_next, &head, list) {
7419                 _scsih_remove_device(ioc, sas_device);
7420                 list_del_init(&sas_device->list);
7421                 sas_device_put(sas_device);
7422         }
7423
7424         /* removing unresponding volumes */
7425         if (ioc->ir_firmware) {
7426                 pr_info(MPT3SAS_FMT "removing unresponding devices: volumes\n",
7427                         ioc->name);
7428                 list_for_each_entry_safe(raid_device, raid_device_next,
7429                     &ioc->raid_device_list, list) {
7430                         if (!raid_device->responding)
7431                                 _scsih_sas_volume_delete(ioc,
7432                                     raid_device->handle);
7433                         else
7434                                 raid_device->responding = 0;
7435                 }
7436         }
7437
7438         /* removing unresponding expanders */
7439         pr_info(MPT3SAS_FMT "removing unresponding devices: expanders\n",
7440             ioc->name);
7441         spin_lock_irqsave(&ioc->sas_node_lock, flags);
7442         INIT_LIST_HEAD(&tmp_list);
7443         list_for_each_entry_safe(sas_expander, sas_expander_next,
7444             &ioc->sas_expander_list, list) {
7445                 if (!sas_expander->responding)
7446                         list_move_tail(&sas_expander->list, &tmp_list);
7447                 else
7448                         sas_expander->responding = 0;
7449         }
7450         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7451         list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
7452             list) {
7453                 list_del(&sas_expander->list);
7454                 _scsih_expander_node_remove(ioc, sas_expander);
7455         }
7456
7457         pr_info(MPT3SAS_FMT "removing unresponding devices: complete\n",
7458             ioc->name);
7459
7460         /* unblock devices */
7461         _scsih_ublock_io_all_device(ioc);
7462 }
7463
7464 static void
7465 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc,
7466         struct _sas_node *sas_expander, u16 handle)
7467 {
7468         Mpi2ExpanderPage1_t expander_pg1;
7469         Mpi2ConfigReply_t mpi_reply;
7470         int i;
7471
7472         for (i = 0 ; i < sas_expander->num_phys ; i++) {
7473                 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
7474                     &expander_pg1, i, handle))) {
7475                         pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
7476                             ioc->name, __FILE__, __LINE__, __func__);
7477                         return;
7478                 }
7479
7480                 mpt3sas_transport_update_links(ioc, sas_expander->sas_address,
7481                     le16_to_cpu(expander_pg1.AttachedDevHandle), i,
7482                     expander_pg1.NegotiatedLinkRate >> 4);
7483         }
7484 }
7485
7486 /**
7487  * _scsih_scan_for_devices_after_reset - scan for devices after host reset
7488  * @ioc: per adapter object
7489  *
7490  * Return nothing.
7491  */
7492 static void
7493 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc)
7494 {
7495         Mpi2ExpanderPage0_t expander_pg0;
7496         Mpi2SasDevicePage0_t sas_device_pg0;
7497         Mpi2RaidVolPage1_t volume_pg1;
7498         Mpi2RaidVolPage0_t volume_pg0;
7499         Mpi2RaidPhysDiskPage0_t pd_pg0;
7500         Mpi2EventIrConfigElement_t element;
7501         Mpi2ConfigReply_t mpi_reply;
7502         u8 phys_disk_num;
7503         u16 ioc_status;
7504         u16 handle, parent_handle;
7505         u64 sas_address;
7506         struct _sas_device *sas_device;
7507         struct _sas_node *expander_device;
7508         static struct _raid_device *raid_device;
7509         u8 retry_count;
7510         unsigned long flags;
7511
7512         pr_info(MPT3SAS_FMT "scan devices: start\n", ioc->name);
7513
7514         _scsih_sas_host_refresh(ioc);
7515
7516         pr_info(MPT3SAS_FMT "\tscan devices: expanders start\n", ioc->name);
7517
7518         /* expanders */
7519         handle = 0xFFFF;
7520         while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
7521             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
7522                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7523                     MPI2_IOCSTATUS_MASK;
7524                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7525                         pr_info(MPT3SAS_FMT "\tbreak from expander scan: " \
7526                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7527                             ioc->name, ioc_status,
7528                             le32_to_cpu(mpi_reply.IOCLogInfo));
7529                         break;
7530                 }
7531                 handle = le16_to_cpu(expander_pg0.DevHandle);
7532                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
7533                 expander_device = mpt3sas_scsih_expander_find_by_sas_address(
7534                     ioc, le64_to_cpu(expander_pg0.SASAddress));
7535                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
7536                 if (expander_device)
7537                         _scsih_refresh_expander_links(ioc, expander_device,
7538                             handle);
7539                 else {
7540                         pr_info(MPT3SAS_FMT "\tBEFORE adding expander: " \
7541                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7542                             handle, (unsigned long long)
7543                             le64_to_cpu(expander_pg0.SASAddress));
7544                         _scsih_expander_add(ioc, handle);
7545                         pr_info(MPT3SAS_FMT "\tAFTER adding expander: " \
7546                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7547                             handle, (unsigned long long)
7548                             le64_to_cpu(expander_pg0.SASAddress));
7549                 }
7550         }
7551
7552         pr_info(MPT3SAS_FMT "\tscan devices: expanders complete\n",
7553             ioc->name);
7554
7555         if (!ioc->ir_firmware)
7556                 goto skip_to_sas;
7557
7558         pr_info(MPT3SAS_FMT "\tscan devices: phys disk start\n", ioc->name);
7559
7560         /* phys disk */
7561         phys_disk_num = 0xFF;
7562         while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
7563             &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
7564             phys_disk_num))) {
7565                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7566                     MPI2_IOCSTATUS_MASK;
7567                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7568                         pr_info(MPT3SAS_FMT "\tbreak from phys disk scan: "\
7569                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7570                             ioc->name, ioc_status,
7571                             le32_to_cpu(mpi_reply.IOCLogInfo));
7572                         break;
7573                 }
7574                 phys_disk_num = pd_pg0.PhysDiskNum;
7575                 handle = le16_to_cpu(pd_pg0.DevHandle);
7576                 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);
7577                 if (sas_device) {
7578                         sas_device_put(sas_device);
7579                         continue;
7580                 }
7581                 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7582                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
7583                     handle) != 0)
7584                         continue;
7585                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7586                     MPI2_IOCSTATUS_MASK;
7587                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7588                         pr_info(MPT3SAS_FMT "\tbreak from phys disk scan " \
7589                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7590                             ioc->name, ioc_status,
7591                             le32_to_cpu(mpi_reply.IOCLogInfo));
7592                         break;
7593                 }
7594                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
7595                 if (!_scsih_get_sas_address(ioc, parent_handle,
7596                     &sas_address)) {
7597                         pr_info(MPT3SAS_FMT "\tBEFORE adding phys disk: " \
7598                             " handle (0x%04x), sas_addr(0x%016llx)\n",
7599                             ioc->name, handle, (unsigned long long)
7600                             le64_to_cpu(sas_device_pg0.SASAddress));
7601                         mpt3sas_transport_update_links(ioc, sas_address,
7602                             handle, sas_device_pg0.PhyNum,
7603                             MPI2_SAS_NEG_LINK_RATE_1_5);
7604                         set_bit(handle, ioc->pd_handles);
7605                         retry_count = 0;
7606                         /* This will retry adding the end device.
7607                          * _scsih_add_device() will decide on retries and
7608                          * return "1" when it should be retried
7609                          */
7610                         while (_scsih_add_device(ioc, handle, retry_count++,
7611                             1)) {
7612                                 ssleep(1);
7613                         }
7614                         pr_info(MPT3SAS_FMT "\tAFTER adding phys disk: " \
7615                             " handle (0x%04x), sas_addr(0x%016llx)\n",
7616                             ioc->name, handle, (unsigned long long)
7617                             le64_to_cpu(sas_device_pg0.SASAddress));
7618                 }
7619         }
7620
7621         pr_info(MPT3SAS_FMT "\tscan devices: phys disk complete\n",
7622             ioc->name);
7623
7624         pr_info(MPT3SAS_FMT "\tscan devices: volumes start\n", ioc->name);
7625
7626         /* volumes */
7627         handle = 0xFFFF;
7628         while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
7629             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
7630                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7631                     MPI2_IOCSTATUS_MASK;
7632                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7633                         pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
7634                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7635                             ioc->name, ioc_status,
7636                             le32_to_cpu(mpi_reply.IOCLogInfo));
7637                         break;
7638                 }
7639                 handle = le16_to_cpu(volume_pg1.DevHandle);
7640                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
7641                 raid_device = _scsih_raid_device_find_by_wwid(ioc,
7642                     le64_to_cpu(volume_pg1.WWID));
7643                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
7644                 if (raid_device)
7645                         continue;
7646                 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
7647                     &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
7648                      sizeof(Mpi2RaidVolPage0_t)))
7649                         continue;
7650                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7651                     MPI2_IOCSTATUS_MASK;
7652                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7653                         pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
7654                             "ioc_status(0x%04x), loginfo(0x%08x)\n",
7655                             ioc->name, ioc_status,
7656                             le32_to_cpu(mpi_reply.IOCLogInfo));
7657                         break;
7658                 }
7659                 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
7660                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE ||
7661                     volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) {
7662                         memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
7663                         element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
7664                         element.VolDevHandle = volume_pg1.DevHandle;
7665                         pr_info(MPT3SAS_FMT
7666                                 "\tBEFORE adding volume: handle (0x%04x)\n",
7667                                 ioc->name, volume_pg1.DevHandle);
7668                         _scsih_sas_volume_add(ioc, &element);
7669                         pr_info(MPT3SAS_FMT
7670                                 "\tAFTER adding volume: handle (0x%04x)\n",
7671                                 ioc->name, volume_pg1.DevHandle);
7672                 }
7673         }
7674
7675         pr_info(MPT3SAS_FMT "\tscan devices: volumes complete\n",
7676             ioc->name);
7677
7678  skip_to_sas:
7679
7680         pr_info(MPT3SAS_FMT "\tscan devices: end devices start\n",
7681             ioc->name);
7682
7683         /* sas devices */
7684         handle = 0xFFFF;
7685         while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
7686             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
7687             handle))) {
7688                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
7689                     MPI2_IOCSTATUS_MASK;
7690                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
7691                         pr_info(MPT3SAS_FMT "\tbreak from end device scan:"\
7692                             " ioc_status(0x%04x), loginfo(0x%08x)\n",
7693                             ioc->name, ioc_status,
7694                             le32_to_cpu(mpi_reply.IOCLogInfo));
7695                         break;
7696                 }
7697                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
7698                 if (!(_scsih_is_end_device(
7699                     le32_to_cpu(sas_device_pg0.DeviceInfo))))
7700                         continue;
7701                 sas_device = mpt3sas_get_sdev_by_addr(ioc,
7702                     le64_to_cpu(sas_device_pg0.SASAddress));
7703                 if (sas_device) {
7704                         sas_device_put(sas_device);
7705                         continue;
7706                 }
7707                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
7708                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
7709                         pr_info(MPT3SAS_FMT "\tBEFORE adding end device: " \
7710                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7711                             handle, (unsigned long long)
7712                             le64_to_cpu(sas_device_pg0.SASAddress));
7713                         mpt3sas_transport_update_links(ioc, sas_address, handle,
7714                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
7715                         retry_count = 0;
7716                         /* This will retry adding the end device.
7717                          * _scsih_add_device() will decide on retries and
7718                          * return "1" when it should be retried
7719                          */
7720                         while (_scsih_add_device(ioc, handle, retry_count++,
7721                             0)) {
7722                                 ssleep(1);
7723                         }
7724                         pr_info(MPT3SAS_FMT "\tAFTER adding end device: " \
7725                             "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
7726                             handle, (unsigned long long)
7727                             le64_to_cpu(sas_device_pg0.SASAddress));
7728                 }
7729         }
7730         pr_info(MPT3SAS_FMT "\tscan devices: end devices complete\n",
7731             ioc->name);
7732
7733         pr_info(MPT3SAS_FMT "scan devices: complete\n", ioc->name);
7734 }
7735 /**
7736  * mpt3sas_scsih_reset_handler - reset callback handler (for scsih)
7737  * @ioc: per adapter object
7738  * @reset_phase: phase
7739  *
7740  * The handler for doing any required cleanup or initialization.
7741  *
7742  * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
7743  * MPT3_IOC_DONE_RESET
7744  *
7745  * Return nothing.
7746  */
7747 void
7748 mpt3sas_scsih_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase)
7749 {
7750         switch (reset_phase) {
7751         case MPT3_IOC_PRE_RESET:
7752                 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7753                         "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
7754                 break;
7755         case MPT3_IOC_AFTER_RESET:
7756                 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7757                         "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
7758                 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
7759                         ioc->scsih_cmds.status |= MPT3_CMD_RESET;
7760                         mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
7761                         complete(&ioc->scsih_cmds.done);
7762                 }
7763                 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) {
7764                         ioc->tm_cmds.status |= MPT3_CMD_RESET;
7765                         mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid);
7766                         complete(&ioc->tm_cmds.done);
7767                 }
7768
7769                 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz);
7770                 memset(ioc->device_remove_in_progress, 0,
7771                        ioc->device_remove_in_progress_sz);
7772                 _scsih_fw_event_cleanup_queue(ioc);
7773                 _scsih_flush_running_cmds(ioc);
7774                 break;
7775         case MPT3_IOC_DONE_RESET:
7776                 dtmprintk(ioc, pr_info(MPT3SAS_FMT
7777                         "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
7778                 if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
7779                     !ioc->sas_hba.num_phys)) {
7780                         _scsih_prep_device_scan(ioc);
7781                         _scsih_search_responding_sas_devices(ioc);
7782                         _scsih_search_responding_raid_devices(ioc);
7783                         _scsih_search_responding_expanders(ioc);
7784                         _scsih_error_recovery_delete_devices(ioc);
7785                 }
7786                 break;
7787         }
7788 }
7789
7790 /**
7791  * _mpt3sas_fw_work - delayed task for processing firmware events
7792  * @ioc: per adapter object
7793  * @fw_event: The fw_event_work object
7794  * Context: user.
7795  *
7796  * Return nothing.
7797  */
7798 static void
7799 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event)
7800 {
7801         _scsih_fw_event_del_from_list(ioc, fw_event);
7802
7803         /* the queue is being flushed so ignore this event */
7804         if (ioc->remove_host || ioc->pci_error_recovery) {
7805                 fw_event_work_put(fw_event);
7806                 return;
7807         }
7808
7809         switch (fw_event->event) {
7810         case MPT3SAS_PROCESS_TRIGGER_DIAG:
7811                 mpt3sas_process_trigger_data(ioc,
7812                         (struct SL_WH_TRIGGERS_EVENT_DATA_T *)
7813                         fw_event->event_data);
7814                 break;
7815         case MPT3SAS_REMOVE_UNRESPONDING_DEVICES:
7816                 while (scsi_host_in_recovery(ioc->shost) ||
7817                                          ioc->shost_recovery) {
7818                         /*
7819                          * If we're unloading, bail. Otherwise, this can become
7820                          * an infinite loop.
7821                          */
7822                         if (ioc->remove_host)
7823                                 goto out;
7824                         ssleep(1);
7825                 }
7826                 _scsih_remove_unresponding_sas_devices(ioc);
7827                 _scsih_scan_for_devices_after_reset(ioc);
7828                 break;
7829         case MPT3SAS_PORT_ENABLE_COMPLETE:
7830                 ioc->start_scan = 0;
7831         if (missing_delay[0] != -1 && missing_delay[1] != -1)
7832                         mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
7833                             missing_delay[1]);
7834                 dewtprintk(ioc, pr_info(MPT3SAS_FMT
7835                         "port enable: complete from worker thread\n",
7836                         ioc->name));
7837                 break;
7838         case MPT3SAS_TURN_ON_PFA_LED:
7839                 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
7840                 break;
7841         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
7842                 _scsih_sas_topology_change_event(ioc, fw_event);
7843                 break;
7844         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
7845                 _scsih_sas_device_status_change_event(ioc, fw_event);
7846                 break;
7847         case MPI2_EVENT_SAS_DISCOVERY:
7848                 _scsih_sas_discovery_event(ioc, fw_event);
7849                 break;
7850         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
7851                 _scsih_sas_broadcast_primitive_event(ioc, fw_event);
7852                 break;
7853         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
7854                 _scsih_sas_enclosure_dev_status_change_event(ioc,
7855                     fw_event);
7856                 break;
7857         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
7858                 _scsih_sas_ir_config_change_event(ioc, fw_event);
7859                 break;
7860         case MPI2_EVENT_IR_VOLUME:
7861                 _scsih_sas_ir_volume_event(ioc, fw_event);
7862                 break;
7863         case MPI2_EVENT_IR_PHYSICAL_DISK:
7864                 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
7865                 break;
7866         case MPI2_EVENT_IR_OPERATION_STATUS:
7867                 _scsih_sas_ir_operation_status_event(ioc, fw_event);
7868                 break;
7869         }
7870 out:
7871         fw_event_work_put(fw_event);
7872 }
7873
7874 /**
7875  * _firmware_event_work
7876  * @ioc: per adapter object
7877  * @work: The fw_event_work object
7878  * Context: user.
7879  *
7880  * wrappers for the work thread handling firmware events
7881  *
7882  * Return nothing.
7883  */
7884
7885 static void
7886 _firmware_event_work(struct work_struct *work)
7887 {
7888         struct fw_event_work *fw_event = container_of(work,
7889             struct fw_event_work, work);
7890
7891         _mpt3sas_fw_work(fw_event->ioc, fw_event);
7892 }
7893
7894 /**
7895  * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time)
7896  * @ioc: per adapter object
7897  * @msix_index: MSIX table index supplied by the OS
7898  * @reply: reply message frame(lower 32bit addr)
7899  * Context: interrupt.
7900  *
7901  * This function merely adds a new work task into ioc->firmware_event_thread.
7902  * The tasks are worked from _firmware_event_work in user context.
7903  *
7904  * Return 1 meaning mf should be freed from _base_interrupt
7905  *        0 means the mf is freed from this function.
7906  */
7907 u8
7908 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
7909         u32 reply)
7910 {
7911         struct fw_event_work *fw_event;
7912         Mpi2EventNotificationReply_t *mpi_reply;
7913         u16 event;
7914         u16 sz;
7915         Mpi26EventDataActiveCableExcept_t *ActiveCableEventData;
7916
7917         /* events turned off due to host reset or driver unloading */
7918         if (ioc->remove_host || ioc->pci_error_recovery)
7919                 return 1;
7920
7921         mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
7922
7923         if (unlikely(!mpi_reply)) {
7924                 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
7925                     ioc->name, __FILE__, __LINE__, __func__);
7926                 return 1;
7927         }
7928
7929         event = le16_to_cpu(mpi_reply->Event);
7930
7931         if (event != MPI2_EVENT_LOG_ENTRY_ADDED)
7932                 mpt3sas_trigger_event(ioc, event, 0);
7933
7934         switch (event) {
7935         /* handle these */
7936         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
7937         {
7938                 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
7939                     (Mpi2EventDataSasBroadcastPrimitive_t *)
7940                     mpi_reply->EventData;
7941
7942                 if (baen_data->Primitive !=
7943                     MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
7944                         return 1;
7945
7946                 if (ioc->broadcast_aen_busy) {
7947                         ioc->broadcast_aen_pending++;
7948                         return 1;
7949                 } else
7950                         ioc->broadcast_aen_busy = 1;
7951                 break;
7952         }
7953
7954         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
7955                 _scsih_check_topo_delete_events(ioc,
7956                     (Mpi2EventDataSasTopologyChangeList_t *)
7957                     mpi_reply->EventData);
7958                 break;
7959         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
7960                 _scsih_check_ir_config_unhide_events(ioc,
7961                     (Mpi2EventDataIrConfigChangeList_t *)
7962                     mpi_reply->EventData);
7963                 break;
7964         case MPI2_EVENT_IR_VOLUME:
7965                 _scsih_check_volume_delete_events(ioc,
7966                     (Mpi2EventDataIrVolume_t *)
7967                     mpi_reply->EventData);
7968                 break;
7969         case MPI2_EVENT_LOG_ENTRY_ADDED:
7970         {
7971                 Mpi2EventDataLogEntryAdded_t *log_entry;
7972                 u32 *log_code;
7973
7974                 if (!ioc->is_warpdrive)
7975                         break;
7976
7977                 log_entry = (Mpi2EventDataLogEntryAdded_t *)
7978                     mpi_reply->EventData;
7979                 log_code = (u32 *)log_entry->LogData;
7980
7981                 if (le16_to_cpu(log_entry->LogEntryQualifier)
7982                     != MPT2_WARPDRIVE_LOGENTRY)
7983                         break;
7984
7985                 switch (le32_to_cpu(*log_code)) {
7986                 case MPT2_WARPDRIVE_LC_SSDT:
7987                         pr_warn(MPT3SAS_FMT "WarpDrive Warning: "
7988                             "IO Throttling has occurred in the WarpDrive "
7989                             "subsystem. Check WarpDrive documentation for "
7990                             "additional details.\n", ioc->name);
7991                         break;
7992                 case MPT2_WARPDRIVE_LC_SSDLW:
7993                         pr_warn(MPT3SAS_FMT "WarpDrive Warning: "
7994                             "Program/Erase Cycles for the WarpDrive subsystem "
7995                             "in degraded range. Check WarpDrive documentation "
7996                             "for additional details.\n", ioc->name);
7997                         break;
7998                 case MPT2_WARPDRIVE_LC_SSDLF:
7999                         pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: "
8000                             "There are no Program/Erase Cycles for the "
8001                             "WarpDrive subsystem. The storage device will be "
8002                             "in read-only mode. Check WarpDrive documentation "
8003                             "for additional details.\n", ioc->name);
8004                         break;
8005                 case MPT2_WARPDRIVE_LC_BRMF:
8006                         pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: "
8007                             "The Backup Rail Monitor has failed on the "
8008                             "WarpDrive subsystem. Check WarpDrive "
8009                             "documentation for additional details.\n",
8010                             ioc->name);
8011                         break;
8012                 }
8013
8014                 break;
8015         }
8016         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
8017         case MPI2_EVENT_IR_OPERATION_STATUS:
8018         case MPI2_EVENT_SAS_DISCOVERY:
8019         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
8020         case MPI2_EVENT_IR_PHYSICAL_DISK:
8021                 break;
8022
8023         case MPI2_EVENT_TEMP_THRESHOLD:
8024                 _scsih_temp_threshold_events(ioc,
8025                         (Mpi2EventDataTemperature_t *)
8026                         mpi_reply->EventData);
8027                 break;
8028         case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION:
8029                 ActiveCableEventData =
8030                     (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData;
8031                 if (ActiveCableEventData->ReasonCode ==
8032                                 MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER) {
8033                         pr_info(MPT3SAS_FMT "Currently an active cable with ReceptacleID %d",
8034                             ioc->name, ActiveCableEventData->ReceptacleID);
8035                         pr_info("cannot be powered and devices connected to this active cable");
8036                         pr_info("will not be seen. This active cable");
8037                         pr_info("requires %d mW of power",
8038                             ActiveCableEventData->ActiveCablePowerRequirement);
8039                 }
8040                 break;
8041
8042         default: /* ignore the rest */
8043                 return 1;
8044         }
8045
8046         sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
8047         fw_event = alloc_fw_event_work(sz);
8048         if (!fw_event) {
8049                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8050                     ioc->name, __FILE__, __LINE__, __func__);
8051                 return 1;
8052         }
8053
8054         memcpy(fw_event->event_data, mpi_reply->EventData, sz);
8055         fw_event->ioc = ioc;
8056         fw_event->VF_ID = mpi_reply->VF_ID;
8057         fw_event->VP_ID = mpi_reply->VP_ID;
8058         fw_event->event = event;
8059         _scsih_fw_event_add(ioc, fw_event);
8060         fw_event_work_put(fw_event);
8061         return 1;
8062 }
8063
8064 /**
8065  * _scsih_expander_node_remove - removing expander device from list.
8066  * @ioc: per adapter object
8067  * @sas_expander: the sas_device object
8068  * Context: Calling function should acquire ioc->sas_node_lock.
8069  *
8070  * Removing object and freeing associated memory from the
8071  * ioc->sas_expander_list.
8072  *
8073  * Return nothing.
8074  */
8075 static void
8076 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,
8077         struct _sas_node *sas_expander)
8078 {
8079         struct _sas_port *mpt3sas_port, *next;
8080
8081         /* remove sibling ports attached to this expander */
8082         list_for_each_entry_safe(mpt3sas_port, next,
8083            &sas_expander->sas_port_list, port_list) {
8084                 if (ioc->shost_recovery)
8085                         return;
8086                 if (mpt3sas_port->remote_identify.device_type ==
8087                     SAS_END_DEVICE)
8088                         mpt3sas_device_remove_by_sas_address(ioc,
8089                             mpt3sas_port->remote_identify.sas_address);
8090                 else if (mpt3sas_port->remote_identify.device_type ==
8091                     SAS_EDGE_EXPANDER_DEVICE ||
8092                     mpt3sas_port->remote_identify.device_type ==
8093                     SAS_FANOUT_EXPANDER_DEVICE)
8094                         mpt3sas_expander_remove(ioc,
8095                             mpt3sas_port->remote_identify.sas_address);
8096         }
8097
8098         mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
8099             sas_expander->sas_address_parent);
8100
8101         pr_info(MPT3SAS_FMT
8102                 "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
8103                 ioc->name,
8104             sas_expander->handle, (unsigned long long)
8105             sas_expander->sas_address);
8106
8107         kfree(sas_expander->phy);
8108         kfree(sas_expander);
8109 }
8110
8111 /**
8112  * _scsih_ir_shutdown - IR shutdown notification
8113  * @ioc: per adapter object
8114  *
8115  * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
8116  * the host system is shutting down.
8117  *
8118  * Return nothing.
8119  */
8120 static void
8121 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc)
8122 {
8123         Mpi2RaidActionRequest_t *mpi_request;
8124         Mpi2RaidActionReply_t *mpi_reply;
8125         u16 smid;
8126
8127         /* is IR firmware build loaded ? */
8128         if (!ioc->ir_firmware)
8129                 return;
8130
8131         /* are there any volumes ? */
8132         if (list_empty(&ioc->raid_device_list))
8133                 return;
8134
8135         mutex_lock(&ioc->scsih_cmds.mutex);
8136
8137         if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
8138                 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
8139                     ioc->name, __func__);
8140                 goto out;
8141         }
8142         ioc->scsih_cmds.status = MPT3_CMD_PENDING;
8143
8144         smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
8145         if (!smid) {
8146                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
8147                     ioc->name, __func__);
8148                 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
8149                 goto out;
8150         }
8151
8152         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
8153         ioc->scsih_cmds.smid = smid;
8154         memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
8155
8156         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
8157         mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
8158
8159         if (!ioc->hide_ir_msg)
8160                 pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name);
8161         init_completion(&ioc->scsih_cmds.done);
8162         ioc->put_smid_default(ioc, smid);
8163         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
8164
8165         if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
8166                 pr_err(MPT3SAS_FMT "%s: timeout\n",
8167                     ioc->name, __func__);
8168                 goto out;
8169         }
8170
8171         if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
8172                 mpi_reply = ioc->scsih_cmds.reply;
8173                 if (!ioc->hide_ir_msg)
8174                         pr_info(MPT3SAS_FMT "IR shutdown "
8175                            "(complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
8176                             ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
8177                             le32_to_cpu(mpi_reply->IOCLogInfo));
8178         }
8179
8180  out:
8181         ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
8182         mutex_unlock(&ioc->scsih_cmds.mutex);
8183 }
8184
8185 /**
8186  * scsih_remove - detach and remove add host
8187  * @pdev: PCI device struct
8188  *
8189  * Routine called when unloading the driver.
8190  * Return nothing.
8191  */
8192 static void scsih_remove(struct pci_dev *pdev)
8193 {
8194         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8195         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8196         struct _sas_port *mpt3sas_port, *next_port;
8197         struct _raid_device *raid_device, *next;
8198         struct MPT3SAS_TARGET *sas_target_priv_data;
8199         struct workqueue_struct *wq;
8200         unsigned long flags;
8201
8202         ioc->remove_host = 1;
8203         _scsih_fw_event_cleanup_queue(ioc);
8204
8205         spin_lock_irqsave(&ioc->fw_event_lock, flags);
8206         wq = ioc->firmware_event_thread;
8207         ioc->firmware_event_thread = NULL;
8208         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
8209         if (wq)
8210                 destroy_workqueue(wq);
8211
8212         /* release all the volumes */
8213         _scsih_ir_shutdown(ioc);
8214         list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
8215             list) {
8216                 if (raid_device->starget) {
8217                         sas_target_priv_data =
8218                             raid_device->starget->hostdata;
8219                         sas_target_priv_data->deleted = 1;
8220                         scsi_remove_target(&raid_device->starget->dev);
8221                 }
8222                 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
8223                         ioc->name,  raid_device->handle,
8224                     (unsigned long long) raid_device->wwid);
8225                 _scsih_raid_device_remove(ioc, raid_device);
8226         }
8227
8228         /* free ports attached to the sas_host */
8229         list_for_each_entry_safe(mpt3sas_port, next_port,
8230            &ioc->sas_hba.sas_port_list, port_list) {
8231                 if (mpt3sas_port->remote_identify.device_type ==
8232                     SAS_END_DEVICE)
8233                         mpt3sas_device_remove_by_sas_address(ioc,
8234                             mpt3sas_port->remote_identify.sas_address);
8235                 else if (mpt3sas_port->remote_identify.device_type ==
8236                     SAS_EDGE_EXPANDER_DEVICE ||
8237                     mpt3sas_port->remote_identify.device_type ==
8238                     SAS_FANOUT_EXPANDER_DEVICE)
8239                         mpt3sas_expander_remove(ioc,
8240                             mpt3sas_port->remote_identify.sas_address);
8241         }
8242
8243         /* free phys attached to the sas_host */
8244         if (ioc->sas_hba.num_phys) {
8245                 kfree(ioc->sas_hba.phy);
8246                 ioc->sas_hba.phy = NULL;
8247                 ioc->sas_hba.num_phys = 0;
8248         }
8249
8250         sas_remove_host(shost);
8251         scsi_remove_host(shost);
8252         mpt3sas_base_detach(ioc);
8253         spin_lock(&gioc_lock);
8254         list_del(&ioc->list);
8255         spin_unlock(&gioc_lock);
8256         scsi_host_put(shost);
8257 }
8258
8259 /**
8260  * scsih_shutdown - routine call during system shutdown
8261  * @pdev: PCI device struct
8262  *
8263  * Return nothing.
8264  */
8265 static void
8266 scsih_shutdown(struct pci_dev *pdev)
8267 {
8268         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8269         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8270         struct workqueue_struct *wq;
8271         unsigned long flags;
8272
8273         ioc->remove_host = 1;
8274         _scsih_fw_event_cleanup_queue(ioc);
8275
8276         spin_lock_irqsave(&ioc->fw_event_lock, flags);
8277         wq = ioc->firmware_event_thread;
8278         ioc->firmware_event_thread = NULL;
8279         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
8280         if (wq)
8281                 destroy_workqueue(wq);
8282
8283         _scsih_ir_shutdown(ioc);
8284         mpt3sas_base_detach(ioc);
8285 }
8286
8287
8288 /**
8289  * _scsih_probe_boot_devices - reports 1st device
8290  * @ioc: per adapter object
8291  *
8292  * If specified in bios page 2, this routine reports the 1st
8293  * device scsi-ml or sas transport for persistent boot device
8294  * purposes.  Please refer to function _scsih_determine_boot_device()
8295  */
8296 static void
8297 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc)
8298 {
8299         u8 is_raid;
8300         void *device;
8301         struct _sas_device *sas_device;
8302         struct _raid_device *raid_device;
8303         u16 handle;
8304         u64 sas_address_parent;
8305         u64 sas_address;
8306         unsigned long flags;
8307         int rc;
8308
8309          /* no Bios, return immediately */
8310         if (!ioc->bios_pg3.BiosVersion)
8311                 return;
8312
8313         device = NULL;
8314         is_raid = 0;
8315         if (ioc->req_boot_device.device) {
8316                 device =  ioc->req_boot_device.device;
8317                 is_raid = ioc->req_boot_device.is_raid;
8318         } else if (ioc->req_alt_boot_device.device) {
8319                 device =  ioc->req_alt_boot_device.device;
8320                 is_raid = ioc->req_alt_boot_device.is_raid;
8321         } else if (ioc->current_boot_device.device) {
8322                 device =  ioc->current_boot_device.device;
8323                 is_raid = ioc->current_boot_device.is_raid;
8324         }
8325
8326         if (!device)
8327                 return;
8328
8329         if (is_raid) {
8330                 raid_device = device;
8331                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
8332                     raid_device->id, 0);
8333                 if (rc)
8334                         _scsih_raid_device_remove(ioc, raid_device);
8335         } else {
8336                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
8337                 sas_device = device;
8338                 handle = sas_device->handle;
8339                 sas_address_parent = sas_device->sas_address_parent;
8340                 sas_address = sas_device->sas_address;
8341                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
8342                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8343
8344                 if (ioc->hide_drives)
8345                         return;
8346                 if (!mpt3sas_transport_port_add(ioc, handle,
8347                     sas_address_parent)) {
8348                         _scsih_sas_device_remove(ioc, sas_device);
8349                 } else if (!sas_device->starget) {
8350                         if (!ioc->is_driver_loading) {
8351                                 mpt3sas_transport_port_remove(ioc,
8352                                     sas_address,
8353                                     sas_address_parent);
8354                                 _scsih_sas_device_remove(ioc, sas_device);
8355                         }
8356                 }
8357         }
8358 }
8359
8360 /**
8361  * _scsih_probe_raid - reporting raid volumes to scsi-ml
8362  * @ioc: per adapter object
8363  *
8364  * Called during initial loading of the driver.
8365  */
8366 static void
8367 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc)
8368 {
8369         struct _raid_device *raid_device, *raid_next;
8370         int rc;
8371
8372         list_for_each_entry_safe(raid_device, raid_next,
8373             &ioc->raid_device_list, list) {
8374                 if (raid_device->starget)
8375                         continue;
8376                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
8377                     raid_device->id, 0);
8378                 if (rc)
8379                         _scsih_raid_device_remove(ioc, raid_device);
8380         }
8381 }
8382
8383 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc)
8384 {
8385         struct _sas_device *sas_device = NULL;
8386         unsigned long flags;
8387
8388         spin_lock_irqsave(&ioc->sas_device_lock, flags);
8389         if (!list_empty(&ioc->sas_device_init_list)) {
8390                 sas_device = list_first_entry(&ioc->sas_device_init_list,
8391                                 struct _sas_device, list);
8392                 sas_device_get(sas_device);
8393         }
8394         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8395
8396         return sas_device;
8397 }
8398
8399 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc,
8400                 struct _sas_device *sas_device)
8401 {
8402         unsigned long flags;
8403
8404         spin_lock_irqsave(&ioc->sas_device_lock, flags);
8405
8406         /*
8407          * Since we dropped the lock during the call to port_add(), we need to
8408          * be careful here that somebody else didn't move or delete this item
8409          * while we were busy with other things.
8410          *
8411          * If it was on the list, we need a put() for the reference the list
8412          * had. Either way, we need a get() for the destination list.
8413          */
8414         if (!list_empty(&sas_device->list)) {
8415                 list_del_init(&sas_device->list);
8416                 sas_device_put(sas_device);
8417         }
8418
8419         sas_device_get(sas_device);
8420         list_add_tail(&sas_device->list, &ioc->sas_device_list);
8421
8422         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
8423 }
8424
8425 /**
8426  * _scsih_probe_sas - reporting sas devices to sas transport
8427  * @ioc: per adapter object
8428  *
8429  * Called during initial loading of the driver.
8430  */
8431 static void
8432 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc)
8433 {
8434         struct _sas_device *sas_device;
8435
8436         if (ioc->hide_drives)
8437                 return;
8438
8439         while ((sas_device = get_next_sas_device(ioc))) {
8440                 if (!mpt3sas_transport_port_add(ioc, sas_device->handle,
8441                     sas_device->sas_address_parent)) {
8442                         _scsih_sas_device_remove(ioc, sas_device);
8443                         sas_device_put(sas_device);
8444                         continue;
8445                 } else if (!sas_device->starget) {
8446                         /*
8447                          * When asyn scanning is enabled, its not possible to
8448                          * remove devices while scanning is turned on due to an
8449                          * oops in scsi_sysfs_add_sdev()->add_device()->
8450                          * sysfs_addrm_start()
8451                          */
8452                         if (!ioc->is_driver_loading) {
8453                                 mpt3sas_transport_port_remove(ioc,
8454                                     sas_device->sas_address,
8455                                     sas_device->sas_address_parent);
8456                                 _scsih_sas_device_remove(ioc, sas_device);
8457                                 sas_device_put(sas_device);
8458                                 continue;
8459                         }
8460                 }
8461                 sas_device_make_active(ioc, sas_device);
8462                 sas_device_put(sas_device);
8463         }
8464 }
8465
8466 /**
8467  * _scsih_probe_devices - probing for devices
8468  * @ioc: per adapter object
8469  *
8470  * Called during initial loading of the driver.
8471  */
8472 static void
8473 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc)
8474 {
8475         u16 volume_mapping_flags;
8476
8477         if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
8478                 return;  /* return when IOC doesn't support initiator mode */
8479
8480         _scsih_probe_boot_devices(ioc);
8481
8482         if (ioc->ir_firmware) {
8483                 volume_mapping_flags =
8484                     le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
8485                     MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
8486                 if (volume_mapping_flags ==
8487                     MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) {
8488                         _scsih_probe_raid(ioc);
8489                         _scsih_probe_sas(ioc);
8490                 } else {
8491                         _scsih_probe_sas(ioc);
8492                         _scsih_probe_raid(ioc);
8493                 }
8494         } else
8495                 _scsih_probe_sas(ioc);
8496 }
8497
8498 /**
8499  * scsih_scan_start - scsi lld callback for .scan_start
8500  * @shost: SCSI host pointer
8501  *
8502  * The shost has the ability to discover targets on its own instead
8503  * of scanning the entire bus.  In our implemention, we will kick off
8504  * firmware discovery.
8505  */
8506 static void
8507 scsih_scan_start(struct Scsi_Host *shost)
8508 {
8509         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8510         int rc;
8511         if (diag_buffer_enable != -1 && diag_buffer_enable != 0)
8512                 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable);
8513
8514         if (disable_discovery > 0)
8515                 return;
8516
8517         ioc->start_scan = 1;
8518         rc = mpt3sas_port_enable(ioc);
8519
8520         if (rc != 0)
8521                 pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name);
8522 }
8523
8524 /**
8525  * scsih_scan_finished - scsi lld callback for .scan_finished
8526  * @shost: SCSI host pointer
8527  * @time: elapsed time of the scan in jiffies
8528  *
8529  * This function will be called periodicallyn until it returns 1 with the
8530  * scsi_host and the elapsed time of the scan in jiffies. In our implemention,
8531  * we wait for firmware discovery to complete, then return 1.
8532  */
8533 static int
8534 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time)
8535 {
8536         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8537
8538         if (disable_discovery > 0) {
8539                 ioc->is_driver_loading = 0;
8540                 ioc->wait_for_discovery_to_complete = 0;
8541                 return 1;
8542         }
8543
8544         if (time >= (300 * HZ)) {
8545                 ioc->base_cmds.status = MPT3_CMD_NOT_USED;
8546                 pr_info(MPT3SAS_FMT
8547                         "port enable: FAILED with timeout (timeout=300s)\n",
8548                         ioc->name);
8549                 ioc->is_driver_loading = 0;
8550                 return 1;
8551         }
8552
8553         if (ioc->start_scan)
8554                 return 0;
8555
8556         if (ioc->start_scan_failed) {
8557                 pr_info(MPT3SAS_FMT
8558                         "port enable: FAILED with (ioc_status=0x%08x)\n",
8559                         ioc->name, ioc->start_scan_failed);
8560                 ioc->is_driver_loading = 0;
8561                 ioc->wait_for_discovery_to_complete = 0;
8562                 ioc->remove_host = 1;
8563                 return 1;
8564         }
8565
8566         pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name);
8567         ioc->base_cmds.status = MPT3_CMD_NOT_USED;
8568
8569         if (ioc->wait_for_discovery_to_complete) {
8570                 ioc->wait_for_discovery_to_complete = 0;
8571                 _scsih_probe_devices(ioc);
8572         }
8573         mpt3sas_base_start_watchdog(ioc);
8574         ioc->is_driver_loading = 0;
8575         return 1;
8576 }
8577
8578 /* shost template for SAS 2.0 HBA devices */
8579 static struct scsi_host_template mpt2sas_driver_template = {
8580         .module                         = THIS_MODULE,
8581         .name                           = "Fusion MPT SAS Host",
8582         .proc_name                      = MPT2SAS_DRIVER_NAME,
8583         .queuecommand                   = scsih_qcmd,
8584         .target_alloc                   = scsih_target_alloc,
8585         .slave_alloc                    = scsih_slave_alloc,
8586         .slave_configure                = scsih_slave_configure,
8587         .target_destroy                 = scsih_target_destroy,
8588         .slave_destroy                  = scsih_slave_destroy,
8589         .scan_finished                  = scsih_scan_finished,
8590         .scan_start                     = scsih_scan_start,
8591         .change_queue_depth             = scsih_change_queue_depth,
8592         .eh_abort_handler               = scsih_abort,
8593         .eh_device_reset_handler        = scsih_dev_reset,
8594         .eh_target_reset_handler        = scsih_target_reset,
8595         .eh_host_reset_handler          = scsih_host_reset,
8596         .bios_param                     = scsih_bios_param,
8597         .can_queue                      = 1,
8598         .this_id                        = -1,
8599         .sg_tablesize                   = MPT2SAS_SG_DEPTH,
8600         .max_sectors                    = 32767,
8601         .cmd_per_lun                    = 7,
8602         .use_clustering                 = ENABLE_CLUSTERING,
8603         .shost_attrs                    = mpt3sas_host_attrs,
8604         .sdev_attrs                     = mpt3sas_dev_attrs,
8605         .track_queue_depth              = 1,
8606 };
8607
8608 /* raid transport support for SAS 2.0 HBA devices */
8609 static struct raid_function_template mpt2sas_raid_functions = {
8610         .cookie         = &mpt2sas_driver_template,
8611         .is_raid        = scsih_is_raid,
8612         .get_resync     = scsih_get_resync,
8613         .get_state      = scsih_get_state,
8614 };
8615
8616 /* shost template for SAS 3.0 HBA devices */
8617 static struct scsi_host_template mpt3sas_driver_template = {
8618         .module                         = THIS_MODULE,
8619         .name                           = "Fusion MPT SAS Host",
8620         .proc_name                      = MPT3SAS_DRIVER_NAME,
8621         .queuecommand                   = scsih_qcmd,
8622         .target_alloc                   = scsih_target_alloc,
8623         .slave_alloc                    = scsih_slave_alloc,
8624         .slave_configure                = scsih_slave_configure,
8625         .target_destroy                 = scsih_target_destroy,
8626         .slave_destroy                  = scsih_slave_destroy,
8627         .scan_finished                  = scsih_scan_finished,
8628         .scan_start                     = scsih_scan_start,
8629         .change_queue_depth             = scsih_change_queue_depth,
8630         .eh_abort_handler               = scsih_abort,
8631         .eh_device_reset_handler        = scsih_dev_reset,
8632         .eh_target_reset_handler        = scsih_target_reset,
8633         .eh_host_reset_handler          = scsih_host_reset,
8634         .bios_param                     = scsih_bios_param,
8635         .can_queue                      = 1,
8636         .this_id                        = -1,
8637         .sg_tablesize                   = MPT3SAS_SG_DEPTH,
8638         .max_sectors                    = 32767,
8639         .cmd_per_lun                    = 7,
8640         .use_clustering                 = ENABLE_CLUSTERING,
8641         .shost_attrs                    = mpt3sas_host_attrs,
8642         .sdev_attrs                     = mpt3sas_dev_attrs,
8643         .track_queue_depth              = 1,
8644 };
8645
8646 /* raid transport support for SAS 3.0 HBA devices */
8647 static struct raid_function_template mpt3sas_raid_functions = {
8648         .cookie         = &mpt3sas_driver_template,
8649         .is_raid        = scsih_is_raid,
8650         .get_resync     = scsih_get_resync,
8651         .get_state      = scsih_get_state,
8652 };
8653
8654 /**
8655  * _scsih_determine_hba_mpi_version - determine in which MPI version class
8656  *                                      this device belongs to.
8657  * @pdev: PCI device struct
8658  *
8659  * return MPI2_VERSION for SAS 2.0 HBA devices,
8660  *      MPI25_VERSION for SAS 3.0 HBA devices, and
8661  *      MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices
8662  */
8663 static u16
8664 _scsih_determine_hba_mpi_version(struct pci_dev *pdev)
8665 {
8666
8667         switch (pdev->device) {
8668         case MPI2_MFGPAGE_DEVID_SSS6200:
8669         case MPI2_MFGPAGE_DEVID_SAS2004:
8670         case MPI2_MFGPAGE_DEVID_SAS2008:
8671         case MPI2_MFGPAGE_DEVID_SAS2108_1:
8672         case MPI2_MFGPAGE_DEVID_SAS2108_2:
8673         case MPI2_MFGPAGE_DEVID_SAS2108_3:
8674         case MPI2_MFGPAGE_DEVID_SAS2116_1:
8675         case MPI2_MFGPAGE_DEVID_SAS2116_2:
8676         case MPI2_MFGPAGE_DEVID_SAS2208_1:
8677         case MPI2_MFGPAGE_DEVID_SAS2208_2:
8678         case MPI2_MFGPAGE_DEVID_SAS2208_3:
8679         case MPI2_MFGPAGE_DEVID_SAS2208_4:
8680         case MPI2_MFGPAGE_DEVID_SAS2208_5:
8681         case MPI2_MFGPAGE_DEVID_SAS2208_6:
8682         case MPI2_MFGPAGE_DEVID_SAS2308_1:
8683         case MPI2_MFGPAGE_DEVID_SAS2308_2:
8684         case MPI2_MFGPAGE_DEVID_SAS2308_3:
8685                 return MPI2_VERSION;
8686         case MPI25_MFGPAGE_DEVID_SAS3004:
8687         case MPI25_MFGPAGE_DEVID_SAS3008:
8688         case MPI25_MFGPAGE_DEVID_SAS3108_1:
8689         case MPI25_MFGPAGE_DEVID_SAS3108_2:
8690         case MPI25_MFGPAGE_DEVID_SAS3108_5:
8691         case MPI25_MFGPAGE_DEVID_SAS3108_6:
8692                 return MPI25_VERSION;
8693         case MPI26_MFGPAGE_DEVID_SAS3216:
8694         case MPI26_MFGPAGE_DEVID_SAS3224:
8695         case MPI26_MFGPAGE_DEVID_SAS3316_1:
8696         case MPI26_MFGPAGE_DEVID_SAS3316_2:
8697         case MPI26_MFGPAGE_DEVID_SAS3316_3:
8698         case MPI26_MFGPAGE_DEVID_SAS3316_4:
8699         case MPI26_MFGPAGE_DEVID_SAS3324_1:
8700         case MPI26_MFGPAGE_DEVID_SAS3324_2:
8701         case MPI26_MFGPAGE_DEVID_SAS3324_3:
8702         case MPI26_MFGPAGE_DEVID_SAS3324_4:
8703         case MPI26_MFGPAGE_DEVID_SAS3508:
8704         case MPI26_MFGPAGE_DEVID_SAS3508_1:
8705         case MPI26_MFGPAGE_DEVID_SAS3408:
8706         case MPI26_MFGPAGE_DEVID_SAS3516:
8707         case MPI26_MFGPAGE_DEVID_SAS3516_1:
8708         case MPI26_MFGPAGE_DEVID_SAS3416:
8709                 return MPI26_VERSION;
8710         }
8711         return 0;
8712 }
8713
8714 /**
8715  * _scsih_probe - attach and add scsi host
8716  * @pdev: PCI device struct
8717  * @id: pci device id
8718  *
8719  * Returns 0 success, anything else error.
8720  */
8721 static int
8722 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
8723 {
8724         struct MPT3SAS_ADAPTER *ioc;
8725         struct Scsi_Host *shost = NULL;
8726         int rv;
8727         u16 hba_mpi_version;
8728
8729         /* Determine in which MPI version class this pci device belongs */
8730         hba_mpi_version = _scsih_determine_hba_mpi_version(pdev);
8731         if (hba_mpi_version == 0)
8732                 return -ENODEV;
8733
8734         /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one,
8735          * for other generation HBA's return with -ENODEV
8736          */
8737         if ((hbas_to_enumerate == 1) && (hba_mpi_version !=  MPI2_VERSION))
8738                 return -ENODEV;
8739
8740         /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two,
8741          * for other generation HBA's return with -ENODEV
8742          */
8743         if ((hbas_to_enumerate == 2) && (!(hba_mpi_version ==  MPI25_VERSION
8744                 || hba_mpi_version ==  MPI26_VERSION)))
8745                 return -ENODEV;
8746
8747         switch (hba_mpi_version) {
8748         case MPI2_VERSION:
8749                 /* Use mpt2sas driver host template for SAS 2.0 HBA's */
8750                 shost = scsi_host_alloc(&mpt2sas_driver_template,
8751                   sizeof(struct MPT3SAS_ADAPTER));
8752                 if (!shost)
8753                         return -ENODEV;
8754                 ioc = shost_priv(shost);
8755                 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
8756                 ioc->hba_mpi_version_belonged = hba_mpi_version;
8757                 ioc->id = mpt2_ids++;
8758                 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME);
8759                 if (pdev->device == MPI2_MFGPAGE_DEVID_SSS6200) {
8760                         ioc->is_warpdrive = 1;
8761                         ioc->hide_ir_msg = 1;
8762                 } else
8763                         ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
8764                 break;
8765         case MPI25_VERSION:
8766         case MPI26_VERSION:
8767                 /* Use mpt3sas driver host template for SAS 3.0 HBA's */
8768                 shost = scsi_host_alloc(&mpt3sas_driver_template,
8769                   sizeof(struct MPT3SAS_ADAPTER));
8770                 if (!shost)
8771                         return -ENODEV;
8772                 ioc = shost_priv(shost);
8773                 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER));
8774                 ioc->hba_mpi_version_belonged = hba_mpi_version;
8775                 ioc->id = mpt3_ids++;
8776                 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME);
8777                 switch (pdev->device) {
8778                 case MPI26_MFGPAGE_DEVID_SAS3508:
8779                 case MPI26_MFGPAGE_DEVID_SAS3508_1:
8780                 case MPI26_MFGPAGE_DEVID_SAS3408:
8781                 case MPI26_MFGPAGE_DEVID_SAS3516:
8782                 case MPI26_MFGPAGE_DEVID_SAS3516_1:
8783                 case MPI26_MFGPAGE_DEVID_SAS3416:
8784                         ioc->is_gen35_ioc = 1;
8785                         break;
8786                 default:
8787                         ioc->is_gen35_ioc = 0;
8788                 }
8789                 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION &&
8790                         pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) ||
8791                         (ioc->hba_mpi_version_belonged == MPI26_VERSION)) {
8792                         ioc->combined_reply_queue = 1;
8793                         if (ioc->is_gen35_ioc)
8794                                 ioc->combined_reply_index_count =
8795                                  MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G35;
8796                         else
8797                                 ioc->combined_reply_index_count =
8798                                  MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G3;
8799                 }
8800                 break;
8801         default:
8802                 return -ENODEV;
8803         }
8804
8805         INIT_LIST_HEAD(&ioc->list);
8806         spin_lock(&gioc_lock);
8807         list_add_tail(&ioc->list, &mpt3sas_ioc_list);
8808         spin_unlock(&gioc_lock);
8809         ioc->shost = shost;
8810         ioc->pdev = pdev;
8811         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
8812         ioc->tm_cb_idx = tm_cb_idx;
8813         ioc->ctl_cb_idx = ctl_cb_idx;
8814         ioc->base_cb_idx = base_cb_idx;
8815         ioc->port_enable_cb_idx = port_enable_cb_idx;
8816         ioc->transport_cb_idx = transport_cb_idx;
8817         ioc->scsih_cb_idx = scsih_cb_idx;
8818         ioc->config_cb_idx = config_cb_idx;
8819         ioc->tm_tr_cb_idx = tm_tr_cb_idx;
8820         ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx;
8821         ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
8822         ioc->logging_level = logging_level;
8823         ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds;
8824         /* misc semaphores and spin locks */
8825         mutex_init(&ioc->reset_in_progress_mutex);
8826         /* initializing pci_access_mutex lock */
8827         mutex_init(&ioc->pci_access_mutex);
8828         spin_lock_init(&ioc->ioc_reset_in_progress_lock);
8829         spin_lock_init(&ioc->scsi_lookup_lock);
8830         spin_lock_init(&ioc->sas_device_lock);
8831         spin_lock_init(&ioc->sas_node_lock);
8832         spin_lock_init(&ioc->fw_event_lock);
8833         spin_lock_init(&ioc->raid_device_lock);
8834         spin_lock_init(&ioc->diag_trigger_lock);
8835
8836         INIT_LIST_HEAD(&ioc->sas_device_list);
8837         INIT_LIST_HEAD(&ioc->sas_device_init_list);
8838         INIT_LIST_HEAD(&ioc->sas_expander_list);
8839         INIT_LIST_HEAD(&ioc->fw_event_list);
8840         INIT_LIST_HEAD(&ioc->raid_device_list);
8841         INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
8842         INIT_LIST_HEAD(&ioc->delayed_tr_list);
8843         INIT_LIST_HEAD(&ioc->delayed_sc_list);
8844         INIT_LIST_HEAD(&ioc->delayed_event_ack_list);
8845         INIT_LIST_HEAD(&ioc->delayed_tr_volume_list);
8846         INIT_LIST_HEAD(&ioc->reply_queue_list);
8847
8848         sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id);
8849
8850         /* init shost parameters */
8851         shost->max_cmd_len = 32;
8852         shost->max_lun = max_lun;
8853         shost->transportt = mpt3sas_transport_template;
8854         shost->unique_id = ioc->id;
8855
8856         if (max_sectors != 0xFFFF) {
8857                 if (max_sectors < 64) {
8858                         shost->max_sectors = 64;
8859                         pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
8860                             "for max_sectors, range is 64 to 32767. Assigning "
8861                             "value of 64.\n", ioc->name, max_sectors);
8862                 } else if (max_sectors > 32767) {
8863                         shost->max_sectors = 32767;
8864                         pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
8865                             "for max_sectors, range is 64 to 32767. Assigning "
8866                             "default value of 32767.\n", ioc->name,
8867                             max_sectors);
8868                 } else {
8869                         shost->max_sectors = max_sectors & 0xFFFE;
8870                         pr_info(MPT3SAS_FMT
8871                                 "The max_sectors value is set to %d\n",
8872                                 ioc->name, shost->max_sectors);
8873                 }
8874         }
8875
8876         /* register EEDP capabilities with SCSI layer */
8877         if (prot_mask > 0)
8878                 scsi_host_set_prot(shost, prot_mask);
8879         else
8880                 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
8881                                    | SHOST_DIF_TYPE2_PROTECTION
8882                                    | SHOST_DIF_TYPE3_PROTECTION);
8883
8884         scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
8885
8886         /* event thread */
8887         snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
8888             "fw_event_%s%d", ioc->driver_name, ioc->id);
8889         ioc->firmware_event_thread = alloc_ordered_workqueue(
8890             ioc->firmware_event_name, WQ_MEM_RECLAIM);
8891         if (!ioc->firmware_event_thread) {
8892                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8893                     ioc->name, __FILE__, __LINE__, __func__);
8894                 rv = -ENODEV;
8895                 goto out_thread_fail;
8896         }
8897
8898         ioc->is_driver_loading = 1;
8899         if ((mpt3sas_base_attach(ioc))) {
8900                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8901                     ioc->name, __FILE__, __LINE__, __func__);
8902                 rv = -ENODEV;
8903                 goto out_attach_fail;
8904         }
8905
8906         if (ioc->is_warpdrive) {
8907                 if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS)
8908                         ioc->hide_drives = 0;
8909                 else if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_HIDE_ALL_DISKS)
8910                         ioc->hide_drives = 1;
8911                 else {
8912                         if (mpt3sas_get_num_volumes(ioc))
8913                                 ioc->hide_drives = 1;
8914                         else
8915                                 ioc->hide_drives = 0;
8916                 }
8917         } else
8918                 ioc->hide_drives = 0;
8919
8920         rv = scsi_add_host(shost, &pdev->dev);
8921         if (rv) {
8922                 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
8923                     ioc->name, __FILE__, __LINE__, __func__);
8924                 goto out_add_shost_fail;
8925         }
8926
8927         scsi_scan_host(shost);
8928         return 0;
8929 out_add_shost_fail:
8930         mpt3sas_base_detach(ioc);
8931  out_attach_fail:
8932         destroy_workqueue(ioc->firmware_event_thread);
8933  out_thread_fail:
8934         spin_lock(&gioc_lock);
8935         list_del(&ioc->list);
8936         spin_unlock(&gioc_lock);
8937         scsi_host_put(shost);
8938         return rv;
8939 }
8940
8941 #ifdef CONFIG_PM
8942 /**
8943  * scsih_suspend - power management suspend main entry point
8944  * @pdev: PCI device struct
8945  * @state: PM state change to (usually PCI_D3)
8946  *
8947  * Returns 0 success, anything else error.
8948  */
8949 static int
8950 scsih_suspend(struct pci_dev *pdev, pm_message_t state)
8951 {
8952         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8953         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8954         pci_power_t device_state;
8955
8956         mpt3sas_base_stop_watchdog(ioc);
8957         flush_scheduled_work();
8958         scsi_block_requests(shost);
8959         device_state = pci_choose_state(pdev, state);
8960         pr_info(MPT3SAS_FMT
8961                 "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
8962                 ioc->name, pdev, pci_name(pdev), device_state);
8963
8964         pci_save_state(pdev);
8965         mpt3sas_base_free_resources(ioc);
8966         pci_set_power_state(pdev, device_state);
8967         return 0;
8968 }
8969
8970 /**
8971  * scsih_resume - power management resume main entry point
8972  * @pdev: PCI device struct
8973  *
8974  * Returns 0 success, anything else error.
8975  */
8976 static int
8977 scsih_resume(struct pci_dev *pdev)
8978 {
8979         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8980         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
8981         pci_power_t device_state = pdev->current_state;
8982         int r;
8983
8984         pr_info(MPT3SAS_FMT
8985                 "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
8986                 ioc->name, pdev, pci_name(pdev), device_state);
8987
8988         pci_set_power_state(pdev, PCI_D0);
8989         pci_enable_wake(pdev, PCI_D0, 0);
8990         pci_restore_state(pdev);
8991         ioc->pdev = pdev;
8992         r = mpt3sas_base_map_resources(ioc);
8993         if (r)
8994                 return r;
8995
8996         mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET);
8997         scsi_unblock_requests(shost);
8998         mpt3sas_base_start_watchdog(ioc);
8999         return 0;
9000 }
9001 #endif /* CONFIG_PM */
9002
9003 /**
9004  * scsih_pci_error_detected - Called when a PCI error is detected.
9005  * @pdev: PCI device struct
9006  * @state: PCI channel state
9007  *
9008  * Description: Called when a PCI error is detected.
9009  *
9010  * Return value:
9011  *      PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9012  */
9013 static pci_ers_result_t
9014 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
9015 {
9016         struct Scsi_Host *shost = pci_get_drvdata(pdev);
9017         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9018
9019         pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n",
9020             ioc->name, state);
9021
9022         switch (state) {
9023         case pci_channel_io_normal:
9024                 return PCI_ERS_RESULT_CAN_RECOVER;
9025         case pci_channel_io_frozen:
9026                 /* Fatal error, prepare for slot reset */
9027                 ioc->pci_error_recovery = 1;
9028                 scsi_block_requests(ioc->shost);
9029                 mpt3sas_base_stop_watchdog(ioc);
9030                 mpt3sas_base_free_resources(ioc);
9031                 return PCI_ERS_RESULT_NEED_RESET;
9032         case pci_channel_io_perm_failure:
9033                 /* Permanent error, prepare for device removal */
9034                 ioc->pci_error_recovery = 1;
9035                 mpt3sas_base_stop_watchdog(ioc);
9036                 _scsih_flush_running_cmds(ioc);
9037                 return PCI_ERS_RESULT_DISCONNECT;
9038         }
9039         return PCI_ERS_RESULT_NEED_RESET;
9040 }
9041
9042 /**
9043  * scsih_pci_slot_reset - Called when PCI slot has been reset.
9044  * @pdev: PCI device struct
9045  *
9046  * Description: This routine is called by the pci error recovery
9047  * code after the PCI slot has been reset, just before we
9048  * should resume normal operations.
9049  */
9050 static pci_ers_result_t
9051 scsih_pci_slot_reset(struct pci_dev *pdev)
9052 {
9053         struct Scsi_Host *shost = pci_get_drvdata(pdev);
9054         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9055         int rc;
9056
9057         pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n",
9058              ioc->name);
9059
9060         ioc->pci_error_recovery = 0;
9061         ioc->pdev = pdev;
9062         pci_restore_state(pdev);
9063         rc = mpt3sas_base_map_resources(ioc);
9064         if (rc)
9065                 return PCI_ERS_RESULT_DISCONNECT;
9066
9067         rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
9068
9069         pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name,
9070             (rc == 0) ? "success" : "failed");
9071
9072         if (!rc)
9073                 return PCI_ERS_RESULT_RECOVERED;
9074         else
9075                 return PCI_ERS_RESULT_DISCONNECT;
9076 }
9077
9078 /**
9079  * scsih_pci_resume() - resume normal ops after PCI reset
9080  * @pdev: pointer to PCI device
9081  *
9082  * Called when the error recovery driver tells us that its
9083  * OK to resume normal operation. Use completion to allow
9084  * halted scsi ops to resume.
9085  */
9086 static void
9087 scsih_pci_resume(struct pci_dev *pdev)
9088 {
9089         struct Scsi_Host *shost = pci_get_drvdata(pdev);
9090         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9091
9092         pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name);
9093
9094         pci_cleanup_aer_uncorrect_error_status(pdev);
9095         mpt3sas_base_start_watchdog(ioc);
9096         scsi_unblock_requests(ioc->shost);
9097 }
9098
9099 /**
9100  * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers
9101  * @pdev: pointer to PCI device
9102  */
9103 static pci_ers_result_t
9104 scsih_pci_mmio_enabled(struct pci_dev *pdev)
9105 {
9106         struct Scsi_Host *shost = pci_get_drvdata(pdev);
9107         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
9108
9109         pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n",
9110             ioc->name);
9111
9112         /* TODO - dump whatever for debugging purposes */
9113
9114         /* This called only if scsih_pci_error_detected returns
9115          * PCI_ERS_RESULT_CAN_RECOVER. Read/write to the device still
9116          * works, no need to reset slot.
9117          */
9118         return PCI_ERS_RESULT_RECOVERED;
9119 }
9120
9121 /**
9122  * scsih__ncq_prio_supp - Check for NCQ command priority support
9123  * @sdev: scsi device struct
9124  *
9125  * This is called when a user indicates they would like to enable
9126  * ncq command priorities. This works only on SATA devices.
9127  */
9128 bool scsih_ncq_prio_supp(struct scsi_device *sdev)
9129 {
9130         unsigned char *buf;
9131         bool ncq_prio_supp = false;
9132
9133         if (!scsi_device_supports_vpd(sdev))
9134                 return ncq_prio_supp;
9135
9136         buf = kmalloc(SCSI_VPD_PG_LEN, GFP_KERNEL);
9137         if (!buf)
9138                 return ncq_prio_supp;
9139
9140         if (!scsi_get_vpd_page(sdev, 0x89, buf, SCSI_VPD_PG_LEN))
9141                 ncq_prio_supp = (buf[213] >> 4) & 1;
9142
9143         kfree(buf);
9144         return ncq_prio_supp;
9145 }
9146 /*
9147  * The pci device ids are defined in mpi/mpi2_cnfg.h.
9148  */
9149 static const struct pci_device_id mpt3sas_pci_table[] = {
9150         /* Spitfire ~ 2004 */
9151         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004,
9152                 PCI_ANY_ID, PCI_ANY_ID },
9153         /* Falcon ~ 2008 */
9154         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008,
9155                 PCI_ANY_ID, PCI_ANY_ID },
9156         /* Liberator ~ 2108 */
9157         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1,
9158                 PCI_ANY_ID, PCI_ANY_ID },
9159         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2,
9160                 PCI_ANY_ID, PCI_ANY_ID },
9161         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3,
9162                 PCI_ANY_ID, PCI_ANY_ID },
9163         /* Meteor ~ 2116 */
9164         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1,
9165                 PCI_ANY_ID, PCI_ANY_ID },
9166         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2,
9167                 PCI_ANY_ID, PCI_ANY_ID },
9168         /* Thunderbolt ~ 2208 */
9169         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1,
9170                 PCI_ANY_ID, PCI_ANY_ID },
9171         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2,
9172                 PCI_ANY_ID, PCI_ANY_ID },
9173         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3,
9174                 PCI_ANY_ID, PCI_ANY_ID },
9175         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4,
9176                 PCI_ANY_ID, PCI_ANY_ID },
9177         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5,
9178                 PCI_ANY_ID, PCI_ANY_ID },
9179         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6,
9180                 PCI_ANY_ID, PCI_ANY_ID },
9181         /* Mustang ~ 2308 */
9182         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1,
9183                 PCI_ANY_ID, PCI_ANY_ID },
9184         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2,
9185                 PCI_ANY_ID, PCI_ANY_ID },
9186         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
9187                 PCI_ANY_ID, PCI_ANY_ID },
9188         /* SSS6200 */
9189         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
9190                 PCI_ANY_ID, PCI_ANY_ID },
9191         /* Fury ~ 3004 and 3008 */
9192         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004,
9193                 PCI_ANY_ID, PCI_ANY_ID },
9194         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008,
9195                 PCI_ANY_ID, PCI_ANY_ID },
9196         /* Invader ~ 3108 */
9197         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1,
9198                 PCI_ANY_ID, PCI_ANY_ID },
9199         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2,
9200                 PCI_ANY_ID, PCI_ANY_ID },
9201         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5,
9202                 PCI_ANY_ID, PCI_ANY_ID },
9203         { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6,
9204                 PCI_ANY_ID, PCI_ANY_ID },
9205         /* Cutlass ~ 3216 and 3224 */
9206         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216,
9207                 PCI_ANY_ID, PCI_ANY_ID },
9208         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224,
9209                 PCI_ANY_ID, PCI_ANY_ID },
9210         /* Intruder ~ 3316 and 3324 */
9211         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1,
9212                 PCI_ANY_ID, PCI_ANY_ID },
9213         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2,
9214                 PCI_ANY_ID, PCI_ANY_ID },
9215         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3,
9216                 PCI_ANY_ID, PCI_ANY_ID },
9217         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4,
9218                 PCI_ANY_ID, PCI_ANY_ID },
9219         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1,
9220                 PCI_ANY_ID, PCI_ANY_ID },
9221         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2,
9222                 PCI_ANY_ID, PCI_ANY_ID },
9223         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3,
9224                 PCI_ANY_ID, PCI_ANY_ID },
9225         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4,
9226                 PCI_ANY_ID, PCI_ANY_ID },
9227         /* Ventura, Crusader, Harpoon & Tomcat ~ 3516, 3416, 3508 & 3408*/
9228         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508,
9229                 PCI_ANY_ID, PCI_ANY_ID },
9230         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508_1,
9231                 PCI_ANY_ID, PCI_ANY_ID },
9232         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3408,
9233                 PCI_ANY_ID, PCI_ANY_ID },
9234         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516,
9235                 PCI_ANY_ID, PCI_ANY_ID },
9236         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516_1,
9237                 PCI_ANY_ID, PCI_ANY_ID },
9238         { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3416,
9239                 PCI_ANY_ID, PCI_ANY_ID },
9240         {0}     /* Terminating entry */
9241 };
9242 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table);
9243
9244 static struct pci_error_handlers _mpt3sas_err_handler = {
9245         .error_detected = scsih_pci_error_detected,
9246         .mmio_enabled   = scsih_pci_mmio_enabled,
9247         .slot_reset     = scsih_pci_slot_reset,
9248         .resume         = scsih_pci_resume,
9249 };
9250
9251 static struct pci_driver mpt3sas_driver = {
9252         .name           = MPT3SAS_DRIVER_NAME,
9253         .id_table       = mpt3sas_pci_table,
9254         .probe          = _scsih_probe,
9255         .remove         = scsih_remove,
9256         .shutdown       = scsih_shutdown,
9257         .err_handler    = &_mpt3sas_err_handler,
9258 #ifdef CONFIG_PM
9259         .suspend        = scsih_suspend,
9260         .resume         = scsih_resume,
9261 #endif
9262 };
9263
9264 /**
9265  * scsih_init - main entry point for this driver.
9266  *
9267  * Returns 0 success, anything else error.
9268  */
9269 static int
9270 scsih_init(void)
9271 {
9272         mpt2_ids = 0;
9273         mpt3_ids = 0;
9274
9275         mpt3sas_base_initialize_callback_handler();
9276
9277          /* queuecommand callback hander */
9278         scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done);
9279
9280         /* task management callback handler */
9281         tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done);
9282
9283         /* base internal commands callback handler */
9284         base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done);
9285         port_enable_cb_idx = mpt3sas_base_register_callback_handler(
9286             mpt3sas_port_enable_done);
9287
9288         /* transport internal commands callback handler */
9289         transport_cb_idx = mpt3sas_base_register_callback_handler(
9290             mpt3sas_transport_done);
9291
9292         /* scsih internal commands callback handler */
9293         scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done);
9294
9295         /* configuration page API internal commands callback handler */
9296         config_cb_idx = mpt3sas_base_register_callback_handler(
9297             mpt3sas_config_done);
9298
9299         /* ctl module callback handler */
9300         ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done);
9301
9302         tm_tr_cb_idx = mpt3sas_base_register_callback_handler(
9303             _scsih_tm_tr_complete);
9304
9305         tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler(
9306             _scsih_tm_volume_tr_complete);
9307
9308         tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler(
9309             _scsih_sas_control_complete);
9310
9311         return 0;
9312 }
9313
9314 /**
9315  * scsih_exit - exit point for this driver (when it is a module).
9316  *
9317  * Returns 0 success, anything else error.
9318  */
9319 static void
9320 scsih_exit(void)
9321 {
9322
9323         mpt3sas_base_release_callback_handler(scsi_io_cb_idx);
9324         mpt3sas_base_release_callback_handler(tm_cb_idx);
9325         mpt3sas_base_release_callback_handler(base_cb_idx);
9326         mpt3sas_base_release_callback_handler(port_enable_cb_idx);
9327         mpt3sas_base_release_callback_handler(transport_cb_idx);
9328         mpt3sas_base_release_callback_handler(scsih_cb_idx);
9329         mpt3sas_base_release_callback_handler(config_cb_idx);
9330         mpt3sas_base_release_callback_handler(ctl_cb_idx);
9331
9332         mpt3sas_base_release_callback_handler(tm_tr_cb_idx);
9333         mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx);
9334         mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx);
9335
9336 /* raid transport support */
9337         if (hbas_to_enumerate != 1)
9338                 raid_class_release(mpt3sas_raid_template);
9339         if (hbas_to_enumerate != 2)
9340                 raid_class_release(mpt2sas_raid_template);
9341         sas_release_transport(mpt3sas_transport_template);
9342 }
9343
9344 /**
9345  * _mpt3sas_init - main entry point for this driver.
9346  *
9347  * Returns 0 success, anything else error.
9348  */
9349 static int __init
9350 _mpt3sas_init(void)
9351 {
9352         int error;
9353
9354         pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME,
9355                                         MPT3SAS_DRIVER_VERSION);
9356
9357         mpt3sas_transport_template =
9358             sas_attach_transport(&mpt3sas_transport_functions);
9359         if (!mpt3sas_transport_template)
9360                 return -ENODEV;
9361
9362         /* No need attach mpt3sas raid functions template
9363          * if hbas_to_enumarate value is one.
9364          */
9365         if (hbas_to_enumerate != 1) {
9366                 mpt3sas_raid_template =
9367                                 raid_class_attach(&mpt3sas_raid_functions);
9368                 if (!mpt3sas_raid_template) {
9369                         sas_release_transport(mpt3sas_transport_template);
9370                         return -ENODEV;
9371                 }
9372         }
9373
9374         /* No need to attach mpt2sas raid functions template
9375          * if hbas_to_enumarate value is two
9376          */
9377         if (hbas_to_enumerate != 2) {
9378                 mpt2sas_raid_template =
9379                                 raid_class_attach(&mpt2sas_raid_functions);
9380                 if (!mpt2sas_raid_template) {
9381                         sas_release_transport(mpt3sas_transport_template);
9382                         return -ENODEV;
9383                 }
9384         }
9385
9386         error = scsih_init();
9387         if (error) {
9388                 scsih_exit();
9389                 return error;
9390         }
9391
9392         mpt3sas_ctl_init(hbas_to_enumerate);
9393
9394         error = pci_register_driver(&mpt3sas_driver);
9395         if (error)
9396                 scsih_exit();
9397
9398         return error;
9399 }
9400
9401 /**
9402  * _mpt3sas_exit - exit point for this driver (when it is a module).
9403  *
9404  */
9405 static void __exit
9406 _mpt3sas_exit(void)
9407 {
9408         pr_info("mpt3sas version %s unloading\n",
9409                                 MPT3SAS_DRIVER_VERSION);
9410
9411         pci_unregister_driver(&mpt3sas_driver);
9412
9413         mpt3sas_ctl_exit(hbas_to_enumerate);
9414
9415         scsih_exit();
9416 }
9417
9418 module_init(_mpt3sas_init);
9419 module_exit(_mpt3sas_exit);