drivers/scsi/mpt2sas/mpt2sas_scsih.c

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