drivers/scsi/mpt3sas/mpt3sas_scsih.c

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