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