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