drivers/scsi/mpt2sas/mpt2sas_scsih.c

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