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