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