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         struct MPT2SAS_TARGET *target_priv_data;
4312         struct _sas_device *sas_device;
4313         __le64 sas_address;
4314         unsigned long flags;
4315         Mpi2EventDataSasDeviceStatusChange_t *event_data =
4316             fw_event->event_data;
4317
4318 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4319         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4320                 _scsih_sas_device_status_change_event_debug(ioc,
4321                      event_data);
4322 #endif
4323
4324         if (!(event_data->ReasonCode ==
4325             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
4326            event_data->ReasonCode ==
4327             MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET))
4328                 return;
4329
4330         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4331         sas_address = le64_to_cpu(event_data->SASAddress);
4332         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
4333             sas_address);
4334         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4335
4336         if (!sas_device || !sas_device->starget)
4337                 return;
4338
4339         target_priv_data = sas_device->starget->hostdata;
4340         if (!target_priv_data)
4341                 return;
4342
4343         if (event_data->ReasonCode ==
4344             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
4345                 target_priv_data->tm_busy = 1;
4346         else
4347                 target_priv_data->tm_busy = 0;
4348 }
4349
4350 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4351 /**
4352  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure event
4353  * @ioc: per adapter object
4354  * @event_data: event data payload
4355  * Context: user.
4356  *
4357  * Return nothing.
4358  */
4359 static void
4360 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
4361     Mpi2EventDataSasEnclDevStatusChange_t *event_data)
4362 {
4363         char *reason_str = NULL;
4364
4365         switch (event_data->ReasonCode) {
4366         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
4367                 reason_str = "enclosure add";
4368                 break;
4369         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
4370                 reason_str = "enclosure remove";
4371                 break;
4372         default:
4373                 reason_str = "unknown reason";
4374                 break;
4375         }
4376
4377         printk(MPT2SAS_DEBUG_FMT "enclosure status change: (%s)\n"
4378             "\thandle(0x%04x), enclosure logical id(0x%016llx)"
4379             " number slots(%d)\n", ioc->name, reason_str,
4380             le16_to_cpu(event_data->EnclosureHandle),
4381             (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
4382             le16_to_cpu(event_data->StartSlot));
4383 }
4384 #endif
4385
4386 /**
4387  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
4388  * @ioc: per adapter object
4389  * @fw_event: The fw_event_work object
4390  * Context: user.
4391  *
4392  * Return nothing.
4393  */
4394 static void
4395 _scsih_sas_enclosure_dev_status_change_event(struct MPT2SAS_ADAPTER *ioc,
4396     struct fw_event_work *fw_event)
4397 {
4398 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4399         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4400                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
4401                      fw_event->event_data);
4402 #endif
4403 }
4404
4405 /**
4406  * _scsih_sas_broadcast_primative_event - handle broadcast events
4407  * @ioc: per adapter object
4408  * @fw_event: The fw_event_work object
4409  * Context: user.
4410  *
4411  * Return nothing.
4412  */
4413 static void
4414 _scsih_sas_broadcast_primative_event(struct MPT2SAS_ADAPTER *ioc,
4415     struct fw_event_work *fw_event)
4416 {
4417         struct scsi_cmnd *scmd;
4418         u16 smid, handle;
4419         u32 lun;
4420         struct MPT2SAS_DEVICE *sas_device_priv_data;
4421         u32 termination_count;
4422         u32 query_count;
4423         Mpi2SCSITaskManagementReply_t *mpi_reply;
4424 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4425         Mpi2EventDataSasBroadcastPrimitive_t *event_data = fw_event->event_data;
4426 #endif
4427         u16 ioc_status;
4428         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "broadcast primative: "
4429             "phy number(%d), width(%d)\n", ioc->name, event_data->PhyNum,
4430             event_data->PortWidth));
4431         dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
4432             __func__));
4433
4434         mutex_lock(&ioc->tm_cmds.mutex);
4435         termination_count = 0;
4436         query_count = 0;
4437         mpi_reply = ioc->tm_cmds.reply;
4438         for (smid = 1; smid <= ioc->scsiio_depth; smid++) {
4439                 scmd = _scsih_scsi_lookup_get(ioc, smid);
4440                 if (!scmd)
4441                         continue;
4442                 sas_device_priv_data = scmd->device->hostdata;
4443                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
4444                         continue;
4445                  /* skip hidden raid components */
4446                 if (sas_device_priv_data->sas_target->flags &
4447                     MPT_TARGET_FLAGS_RAID_COMPONENT)
4448                         continue;
4449                  /* skip volumes */
4450                 if (sas_device_priv_data->sas_target->flags &
4451                     MPT_TARGET_FLAGS_VOLUME)
4452                         continue;
4453
4454                 handle = sas_device_priv_data->sas_target->handle;
4455                 lun = sas_device_priv_data->lun;
4456                 query_count++;
4457
4458                 mpt2sas_scsih_issue_tm(ioc, handle, lun,
4459                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30);
4460                 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
4461                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
4462                     & MPI2_IOCSTATUS_MASK;
4463                 if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
4464                     (mpi_reply->ResponseCode ==
4465                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4466                      mpi_reply->ResponseCode ==
4467                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4468                         continue;
4469
4470                 mpt2sas_scsih_issue_tm(ioc, handle, lun,
4471                     MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET, 0, 30);
4472                 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
4473                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
4474         }
4475         ioc->broadcast_aen_busy = 0;
4476         mutex_unlock(&ioc->tm_cmds.mutex);
4477
4478         dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT
4479             "%s - exit, query_count = %d termination_count = %d\n",
4480             ioc->name, __func__, query_count, termination_count));
4481 }
4482
4483 /**
4484  * _scsih_sas_discovery_event - handle discovery events
4485  * @ioc: per adapter object
4486  * @fw_event: The fw_event_work object
4487  * Context: user.
4488  *
4489  * Return nothing.
4490  */
4491 static void
4492 _scsih_sas_discovery_event(struct MPT2SAS_ADAPTER *ioc,
4493     struct fw_event_work *fw_event)
4494 {
4495         Mpi2EventDataSasDiscovery_t *event_data = fw_event->event_data;
4496
4497 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4498         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
4499                 printk(MPT2SAS_DEBUG_FMT "discovery event: (%s)", ioc->name,
4500                     (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
4501                     "start" : "stop");
4502         if (event_data->DiscoveryStatus)
4503                 printk("discovery_status(0x%08x)",
4504                     le32_to_cpu(event_data->DiscoveryStatus));
4505         printk("\n");
4506         }
4507 #endif
4508
4509         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
4510             !ioc->sas_hba.num_phys)
4511                 _scsih_sas_host_add(ioc);
4512 }
4513
4514 /**
4515  * _scsih_reprobe_lun - reprobing lun
4516  * @sdev: scsi device struct
4517  * @no_uld_attach: sdev->no_uld_attach flag setting
4518  *
4519  **/
4520 static void
4521 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
4522 {
4523         int rc;
4524
4525         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
4526         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
4527             sdev->no_uld_attach ? "hidding" : "exposing");
4528         rc = scsi_device_reprobe(sdev);
4529 }
4530
4531 /**
4532  * _scsih_reprobe_target - reprobing target
4533  * @starget: scsi target struct
4534  * @no_uld_attach: sdev->no_uld_attach flag setting
4535  *
4536  * Note: no_uld_attach flag determines whether the disk device is attached
4537  * to block layer. A value of `1` means to not attach.
4538  **/
4539 static void
4540 _scsih_reprobe_target(struct scsi_target *starget, int no_uld_attach)
4541 {
4542         struct MPT2SAS_TARGET *sas_target_priv_data = starget->hostdata;
4543
4544         if (no_uld_attach)
4545                 sas_target_priv_data->flags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4546         else
4547                 sas_target_priv_data->flags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4548
4549         starget_for_each_device(starget, no_uld_attach ? (void *)1 : NULL,
4550             _scsih_reprobe_lun);
4551 }
4552 /**
4553  * _scsih_sas_volume_add - add new volume
4554  * @ioc: per adapter object
4555  * @element: IR config element data
4556  * Context: user.
4557  *
4558  * Return nothing.
4559  */
4560 static void
4561 _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
4562     Mpi2EventIrConfigElement_t *element)
4563 {
4564         struct _raid_device *raid_device;
4565         unsigned long flags;
4566         u64 wwid;
4567         u16 handle = le16_to_cpu(element->VolDevHandle);
4568         int rc;
4569
4570         mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
4571         if (!wwid) {
4572                 printk(MPT2SAS_ERR_FMT
4573                     "failure at %s:%d/%s()!\n", ioc->name,
4574                     __FILE__, __LINE__, __func__);
4575                 return;
4576         }
4577
4578         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4579         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
4580         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4581
4582         if (raid_device)
4583                 return;
4584
4585         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
4586         if (!raid_device) {
4587                 printk(MPT2SAS_ERR_FMT
4588                     "failure at %s:%d/%s()!\n", ioc->name,
4589                     __FILE__, __LINE__, __func__);
4590                 return;
4591         }
4592
4593         raid_device->id = ioc->sas_id++;
4594         raid_device->channel = RAID_CHANNEL;
4595         raid_device->handle = handle;
4596         raid_device->wwid = wwid;
4597         _scsih_raid_device_add(ioc, raid_device);
4598         if (!ioc->wait_for_port_enable_to_complete) {
4599                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
4600                     raid_device->id, 0);
4601                 if (rc)
4602                         _scsih_raid_device_remove(ioc, raid_device);
4603         } else
4604                 _scsih_determine_boot_device(ioc, raid_device, 1);
4605 }
4606
4607 /**
4608  * _scsih_sas_volume_delete - delete volume
4609  * @ioc: per adapter object
4610  * @element: IR config element data
4611  * Context: user.
4612  *
4613  * Return nothing.
4614  */
4615 static void
4616 _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc,
4617     Mpi2EventIrConfigElement_t *element)
4618 {
4619         struct _raid_device *raid_device;
4620         u16 handle = le16_to_cpu(element->VolDevHandle);
4621         unsigned long flags;
4622         struct MPT2SAS_TARGET *sas_target_priv_data;
4623
4624         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4625         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
4626         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4627         if (!raid_device)
4628                 return;
4629         if (raid_device->starget) {
4630                 sas_target_priv_data = raid_device->starget->hostdata;
4631                 sas_target_priv_data->deleted = 1;
4632                 scsi_remove_target(&raid_device->starget->dev);
4633         }
4634         _scsih_raid_device_remove(ioc, raid_device);
4635 }
4636
4637 /**
4638  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
4639  * @ioc: per adapter object
4640  * @element: IR config element data
4641  * Context: user.
4642  *
4643  * Return nothing.
4644  */
4645 static void
4646 _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
4647     Mpi2EventIrConfigElement_t *element)
4648 {
4649         struct _sas_device *sas_device;
4650         unsigned long flags;
4651         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4652
4653         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4654         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4655         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4656         if (!sas_device)
4657                 return;
4658
4659         /* exposing raid component */
4660         sas_device->volume_handle = 0;
4661         sas_device->volume_wwid = 0;
4662         sas_device->hidden_raid_component = 0;
4663         _scsih_reprobe_target(sas_device->starget, 0);
4664 }
4665
4666 /**
4667  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
4668  * @ioc: per adapter object
4669  * @element: IR config element data
4670  * Context: user.
4671  *
4672  * Return nothing.
4673  */
4674 static void
4675 _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
4676     Mpi2EventIrConfigElement_t *element)
4677 {
4678         struct _sas_device *sas_device;
4679         unsigned long flags;
4680         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4681
4682         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4683         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4684         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4685         if (!sas_device)
4686                 return;
4687
4688         /* hiding raid component */
4689         mpt2sas_config_get_volume_handle(ioc, handle,
4690             &sas_device->volume_handle);
4691         mpt2sas_config_get_volume_wwid(ioc, sas_device->volume_handle,
4692             &sas_device->volume_wwid);
4693         sas_device->hidden_raid_component = 1;
4694         _scsih_reprobe_target(sas_device->starget, 1);
4695 }
4696
4697 /**
4698  * _scsih_sas_pd_delete - delete pd component
4699  * @ioc: per adapter object
4700  * @element: IR config element data
4701  * Context: user.
4702  *
4703  * Return nothing.
4704  */
4705 static void
4706 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
4707     Mpi2EventIrConfigElement_t *element)
4708 {
4709         struct _sas_device *sas_device;
4710         unsigned long flags;
4711         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4712
4713         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4714         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4715         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4716         if (!sas_device)
4717                 return;
4718         _scsih_remove_device(ioc, sas_device);
4719 }
4720
4721 /**
4722  * _scsih_sas_pd_add - remove pd component
4723  * @ioc: per adapter object
4724  * @element: IR config element data
4725  * Context: user.
4726  *
4727  * Return nothing.
4728  */
4729 static void
4730 _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
4731     Mpi2EventIrConfigElement_t *element)
4732 {
4733         struct _sas_device *sas_device;
4734         unsigned long flags;
4735         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4736         Mpi2ConfigReply_t mpi_reply;
4737         Mpi2SasDevicePage0_t sas_device_pg0;
4738         u32 ioc_status;
4739         u64 sas_address;
4740         u16 parent_handle;
4741
4742         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4743         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4744         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4745         if (sas_device) {
4746                 sas_device->hidden_raid_component = 1;
4747                 return;
4748         }
4749
4750         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
4751             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
4752                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4753                     ioc->name, __FILE__, __LINE__, __func__);
4754                 return;
4755         }
4756
4757         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4758             MPI2_IOCSTATUS_MASK;
4759         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4760                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
4761                     ioc->name, __FILE__, __LINE__, __func__);
4762                 return;
4763         }
4764
4765         parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
4766         if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
4767                 mpt2sas_transport_update_links(ioc, sas_address, handle,
4768                     sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
4769
4770         _scsih_add_device(ioc, handle, 0, 1);
4771 }
4772
4773 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4774 /**
4775  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
4776  * @ioc: per adapter object
4777  * @event_data: event data payload
4778  * Context: user.
4779  *
4780  * Return nothing.
4781  */
4782 static void
4783 _scsih_sas_ir_config_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
4784     Mpi2EventDataIrConfigChangeList_t *event_data)
4785 {
4786         Mpi2EventIrConfigElement_t *element;
4787         u8 element_type;
4788         int i;
4789         char *reason_str = NULL, *element_str = NULL;
4790
4791         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4792
4793         printk(MPT2SAS_DEBUG_FMT "raid config change: (%s), elements(%d)\n",
4794             ioc->name, (le32_to_cpu(event_data->Flags) &
4795             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
4796             "foreign" : "native", event_data->NumElements);
4797         for (i = 0; i < event_data->NumElements; i++, element++) {
4798                 switch (element->ReasonCode) {
4799                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
4800                         reason_str = "add";
4801                         break;
4802                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
4803                         reason_str = "remove";
4804                         break;
4805                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
4806                         reason_str = "no change";
4807                         break;
4808                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
4809                         reason_str = "hide";
4810                         break;
4811                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
4812                         reason_str = "unhide";
4813                         break;
4814                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
4815                         reason_str = "volume_created";
4816                         break;
4817                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
4818                         reason_str = "volume_deleted";
4819                         break;
4820                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
4821                         reason_str = "pd_created";
4822                         break;
4823                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
4824                         reason_str = "pd_deleted";
4825                         break;
4826                 default:
4827                         reason_str = "unknown reason";
4828                         break;
4829                 }
4830                 element_type = le16_to_cpu(element->ElementFlags) &
4831                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
4832                 switch (element_type) {
4833                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
4834                         element_str = "volume";
4835                         break;
4836                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
4837                         element_str = "phys disk";
4838                         break;
4839                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
4840                         element_str = "hot spare";
4841                         break;
4842                 default:
4843                         element_str = "unknown element";
4844                         break;
4845                 }
4846                 printk(KERN_DEBUG "\t(%s:%s), vol handle(0x%04x), "
4847                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
4848                     reason_str, le16_to_cpu(element->VolDevHandle),
4849                     le16_to_cpu(element->PhysDiskDevHandle),
4850                     element->PhysDiskNum);
4851         }
4852 }
4853 #endif
4854
4855 /**
4856  * _scsih_sas_ir_config_change_event - handle ir configuration change events
4857  * @ioc: per adapter object
4858  * @fw_event: The fw_event_work object
4859  * Context: user.
4860  *
4861  * Return nothing.
4862  */
4863 static void
4864 _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
4865     struct fw_event_work *fw_event)
4866 {
4867         Mpi2EventIrConfigElement_t *element;
4868         int i;
4869         u8 foreign_config;
4870         Mpi2EventDataIrConfigChangeList_t *event_data = fw_event->event_data;
4871
4872 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4873         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4874                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
4875
4876 #endif
4877         foreign_config = (le32_to_cpu(event_data->Flags) &
4878             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0;
4879
4880         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4881         for (i = 0; i < event_data->NumElements; i++, element++) {
4882
4883                 switch (element->ReasonCode) {
4884                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
4885                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
4886                         if (!foreign_config)
4887                                 _scsih_sas_volume_add(ioc, element);
4888                         break;
4889                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
4890                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
4891                         if (!foreign_config)
4892                                 _scsih_sas_volume_delete(ioc, element);
4893                         break;
4894                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
4895                         _scsih_sas_pd_hide(ioc, element);
4896                         break;
4897                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
4898                         _scsih_sas_pd_expose(ioc, element);
4899                         break;
4900                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
4901                         _scsih_sas_pd_add(ioc, element);
4902                         break;
4903                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
4904                         _scsih_sas_pd_delete(ioc, element);
4905                         break;
4906                 }
4907         }
4908 }
4909
4910 /**
4911  * _scsih_sas_ir_volume_event - IR volume event
4912  * @ioc: per adapter object
4913  * @fw_event: The fw_event_work object
4914  * Context: user.
4915  *
4916  * Return nothing.
4917  */
4918 static void
4919 _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
4920     struct fw_event_work *fw_event)
4921 {
4922         u64 wwid;
4923         unsigned long flags;
4924         struct _raid_device *raid_device;
4925         u16 handle;
4926         u32 state;
4927         int rc;
4928         struct MPT2SAS_TARGET *sas_target_priv_data;
4929         Mpi2EventDataIrVolume_t *event_data = fw_event->event_data;
4930
4931         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
4932                 return;
4933
4934         handle = le16_to_cpu(event_data->VolDevHandle);
4935         state = le32_to_cpu(event_data->NewValue);
4936         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: handle(0x%04x), "
4937             "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
4938             le32_to_cpu(event_data->PreviousValue), state));
4939
4940         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4941         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
4942         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4943
4944         switch (state) {
4945         case MPI2_RAID_VOL_STATE_MISSING:
4946         case MPI2_RAID_VOL_STATE_FAILED:
4947                 if (!raid_device)
4948                         break;
4949                 if (raid_device->starget) {
4950                         sas_target_priv_data = raid_device->starget->hostdata;
4951                         sas_target_priv_data->deleted = 1;
4952                         scsi_remove_target(&raid_device->starget->dev);
4953                 }
4954                 _scsih_raid_device_remove(ioc, raid_device);
4955                 break;
4956
4957         case MPI2_RAID_VOL_STATE_ONLINE:
4958         case MPI2_RAID_VOL_STATE_DEGRADED:
4959         case MPI2_RAID_VOL_STATE_OPTIMAL:
4960                 if (raid_device)
4961                         break;
4962
4963                 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
4964                 if (!wwid) {
4965                         printk(MPT2SAS_ERR_FMT
4966                             "failure at %s:%d/%s()!\n", ioc->name,
4967                             __FILE__, __LINE__, __func__);
4968                         break;
4969                 }
4970
4971                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
4972                 if (!raid_device) {
4973                         printk(MPT2SAS_ERR_FMT
4974                             "failure at %s:%d/%s()!\n", ioc->name,
4975                             __FILE__, __LINE__, __func__);
4976                         break;
4977                 }
4978
4979                 raid_device->id = ioc->sas_id++;
4980                 raid_device->channel = RAID_CHANNEL;
4981                 raid_device->handle = handle;
4982                 raid_device->wwid = wwid;
4983                 _scsih_raid_device_add(ioc, raid_device);
4984                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
4985                     raid_device->id, 0);
4986                 if (rc)
4987                         _scsih_raid_device_remove(ioc, raid_device);
4988                 break;
4989
4990         case MPI2_RAID_VOL_STATE_INITIALIZING:
4991         default:
4992                 break;
4993         }
4994 }
4995
4996 /**
4997  * _scsih_sas_ir_physical_disk_event - PD event
4998  * @ioc: per adapter object
4999  * @fw_event: The fw_event_work object
5000  * Context: user.
5001  *
5002  * Return nothing.
5003  */
5004 static void
5005 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
5006     struct fw_event_work *fw_event)
5007 {
5008         u16 handle, parent_handle;
5009         u32 state;
5010         struct _sas_device *sas_device;
5011         unsigned long flags;
5012         Mpi2ConfigReply_t mpi_reply;
5013         Mpi2SasDevicePage0_t sas_device_pg0;
5014         u32 ioc_status;
5015         Mpi2EventDataIrPhysicalDisk_t *event_data = fw_event->event_data;
5016         u64 sas_address;
5017
5018         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
5019                 return;
5020
5021         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
5022         state = le32_to_cpu(event_data->NewValue);
5023
5024         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: handle(0x%04x), "
5025             "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
5026             le32_to_cpu(event_data->PreviousValue), state));
5027
5028         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5029         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5030         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5031
5032         switch (state) {
5033         case MPI2_RAID_PD_STATE_ONLINE:
5034         case MPI2_RAID_PD_STATE_DEGRADED:
5035         case MPI2_RAID_PD_STATE_REBUILDING:
5036         case MPI2_RAID_PD_STATE_OPTIMAL:
5037                 if (sas_device) {
5038                         sas_device->hidden_raid_component = 1;
5039                         return;
5040                 }
5041
5042                 if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
5043                     &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
5044                     handle))) {
5045                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5046                             ioc->name, __FILE__, __LINE__, __func__);
5047                         return;
5048                 }
5049
5050                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5051                     MPI2_IOCSTATUS_MASK;
5052                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5053                         printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5054                             ioc->name, __FILE__, __LINE__, __func__);
5055                         return;
5056                 }
5057
5058                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
5059                 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
5060                         mpt2sas_transport_update_links(ioc, sas_address, handle,
5061                             sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
5062
5063                 _scsih_add_device(ioc, handle, 0, 1);
5064
5065                 break;
5066
5067         case MPI2_RAID_PD_STATE_OFFLINE:
5068         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
5069         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
5070         case MPI2_RAID_PD_STATE_HOT_SPARE:
5071         default:
5072                 break;
5073         }
5074 }
5075
5076 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5077 /**
5078  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
5079  * @ioc: per adapter object
5080  * @event_data: event data payload
5081  * Context: user.
5082  *
5083  * Return nothing.
5084  */
5085 static void
5086 _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
5087     Mpi2EventDataIrOperationStatus_t *event_data)
5088 {
5089         char *reason_str = NULL;
5090
5091         switch (event_data->RAIDOperation) {
5092         case MPI2_EVENT_IR_RAIDOP_RESYNC:
5093                 reason_str = "resync";
5094                 break;
5095         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
5096                 reason_str = "online capacity expansion";
5097                 break;
5098         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
5099                 reason_str = "consistency check";
5100                 break;
5101         case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
5102                 reason_str = "background init";
5103                 break;
5104         case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
5105                 reason_str = "make data consistent";
5106                 break;
5107         }
5108
5109         if (!reason_str)
5110                 return;
5111
5112         printk(MPT2SAS_INFO_FMT "raid operational status: (%s)"
5113             "\thandle(0x%04x), percent complete(%d)\n",
5114             ioc->name, reason_str,
5115             le16_to_cpu(event_data->VolDevHandle),
5116             event_data->PercentComplete);
5117 }
5118 #endif
5119
5120 /**
5121  * _scsih_sas_ir_operation_status_event - handle RAID operation events
5122  * @ioc: per adapter object
5123  * @fw_event: The fw_event_work object
5124  * Context: user.
5125  *
5126  * Return nothing.
5127  */
5128 static void
5129 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
5130     struct fw_event_work *fw_event)
5131 {
5132 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
5133         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
5134                 _scsih_sas_ir_operation_status_event_debug(ioc,
5135                      fw_event->event_data);
5136 #endif
5137 }
5138
5139 /**
5140  * _scsih_task_set_full - handle task set full
5141  * @ioc: per adapter object
5142  * @fw_event: The fw_event_work object
5143  * Context: user.
5144  *
5145  * Throttle back qdepth.
5146  */
5147 static void
5148 _scsih_task_set_full(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
5149         *fw_event)
5150 {
5151         unsigned long flags;
5152         struct _sas_device *sas_device;
5153         static struct _raid_device *raid_device;
5154         struct scsi_device *sdev;
5155         int depth;
5156         u16 current_depth;
5157         u16 handle;
5158         int id, channel;
5159         u64 sas_address;
5160         Mpi2EventDataTaskSetFull_t *event_data = fw_event->event_data;
5161
5162         current_depth = le16_to_cpu(event_data->CurrentDepth);
5163         handle = le16_to_cpu(event_data->DevHandle);
5164         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5165         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
5166         if (!sas_device) {
5167                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5168                 return;
5169         }
5170         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5171         id = sas_device->id;
5172         channel = sas_device->channel;
5173         sas_address = sas_device->sas_address;
5174
5175         /* if hidden raid component, then change to volume characteristics */
5176         if (sas_device->hidden_raid_component && sas_device->volume_handle) {
5177                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
5178                 raid_device = _scsih_raid_device_find_by_handle(
5179                     ioc, sas_device->volume_handle);
5180                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5181                 if (raid_device) {
5182                         id = raid_device->id;
5183                         channel = raid_device->channel;
5184                         handle = raid_device->handle;
5185                         sas_address = raid_device->wwid;
5186                 }
5187         }
5188
5189         if (ioc->logging_level & MPT_DEBUG_TASK_SET_FULL)
5190                 starget_printk(KERN_DEBUG, sas_device->starget, "task set "
5191                     "full: handle(0x%04x), sas_addr(0x%016llx), depth(%d)\n",
5192                     handle, (unsigned long long)sas_address, current_depth);
5193
5194         shost_for_each_device(sdev, ioc->shost) {
5195                 if (sdev->id == id && sdev->channel == channel) {
5196                         if (current_depth > sdev->queue_depth) {
5197                                 if (ioc->logging_level &
5198                                     MPT_DEBUG_TASK_SET_FULL)
5199                                         sdev_printk(KERN_INFO, sdev, "strange "
5200                                             "observation, the queue depth is"
5201                                             " (%d) meanwhile fw queue depth "
5202                                             "is (%d)\n", sdev->queue_depth,
5203                                             current_depth);
5204                                 continue;
5205                         }
5206                         depth = scsi_track_queue_full(sdev,
5207                             current_depth - 1);
5208                         if (depth > 0)
5209                                 sdev_printk(KERN_INFO, sdev, "Queue depth "
5210                                     "reduced to (%d)\n", depth);
5211                         else if (depth < 0)
5212                                 sdev_printk(KERN_INFO, sdev, "Tagged Command "
5213                                     "Queueing is being disabled\n");
5214                         else if (depth == 0)
5215                                 if (ioc->logging_level &
5216                                      MPT_DEBUG_TASK_SET_FULL)
5217                                         sdev_printk(KERN_INFO, sdev,
5218                                              "Queue depth not changed yet\n");
5219                 }
5220         }
5221 }
5222
5223 /**
5224  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
5225  * @ioc: per adapter object
5226  * @sas_address: sas address
5227  * @slot: enclosure slot id
5228  * @handle: device handle
5229  *
5230  * After host reset, find out whether devices are still responding.
5231  * Used in _scsi_remove_unresponsive_sas_devices.
5232  *
5233  * Return nothing.
5234  */
5235 static void
5236 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5237     u16 slot, u16 handle)
5238 {
5239         struct MPT2SAS_TARGET *sas_target_priv_data;
5240         struct scsi_target *starget;
5241         struct _sas_device *sas_device;
5242         unsigned long flags;
5243
5244         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5245         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
5246                 if (sas_device->sas_address == sas_address &&
5247                     sas_device->slot == slot && sas_device->starget) {
5248                         sas_device->responding = 1;
5249                         sas_device->state = 0;
5250                         starget = sas_device->starget;
5251                         sas_target_priv_data = starget->hostdata;
5252                         sas_target_priv_data->tm_busy = 0;
5253                         starget_printk(KERN_INFO, sas_device->starget,
5254                             "handle(0x%04x), sas_addr(0x%016llx), enclosure "
5255                             "logical id(0x%016llx), slot(%d)\n", handle,
5256                             (unsigned long long)sas_device->sas_address,
5257                             (unsigned long long)
5258                             sas_device->enclosure_logical_id,
5259                             sas_device->slot);
5260                         if (sas_device->handle == handle)
5261                                 goto out;
5262                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
5263                             sas_device->handle);
5264                         sas_device->handle = handle;
5265                         sas_target_priv_data->handle = handle;
5266                         goto out;
5267                 }
5268         }
5269  out:
5270         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5271 }
5272
5273 /**
5274  * _scsih_search_responding_sas_devices -
5275  * @ioc: per adapter object
5276  *
5277  * After host reset, find out whether devices are still responding.
5278  * If not remove.
5279  *
5280  * Return nothing.
5281  */
5282 static void
5283 _scsih_search_responding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
5284 {
5285         Mpi2SasDevicePage0_t sas_device_pg0;
5286         Mpi2ConfigReply_t mpi_reply;
5287         u16 ioc_status;
5288         __le64 sas_address;
5289         u16 handle;
5290         u32 device_info;
5291         u16 slot;
5292
5293         printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
5294
5295         if (list_empty(&ioc->sas_device_list))
5296                 return;
5297
5298         handle = 0xFFFF;
5299         while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
5300             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
5301             handle))) {
5302                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5303                     MPI2_IOCSTATUS_MASK;
5304                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
5305                         break;
5306                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
5307                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
5308                 if (!(_scsih_is_end_device(device_info)))
5309                         continue;
5310                 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
5311                 slot = le16_to_cpu(sas_device_pg0.Slot);
5312                 _scsih_mark_responding_sas_device(ioc, sas_address, slot,
5313                     handle);
5314         }
5315 }
5316
5317 /**
5318  * _scsih_mark_responding_raid_device - mark a raid_device as responding
5319  * @ioc: per adapter object
5320  * @wwid: world wide identifier for raid volume
5321  * @handle: device handle
5322  *
5323  * After host reset, find out whether devices are still responding.
5324  * Used in _scsi_remove_unresponsive_raid_devices.
5325  *
5326  * Return nothing.
5327  */
5328 static void
5329 _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
5330     u16 handle)
5331 {
5332         struct MPT2SAS_TARGET *sas_target_priv_data;
5333         struct scsi_target *starget;
5334         struct _raid_device *raid_device;
5335         unsigned long flags;
5336
5337         spin_lock_irqsave(&ioc->raid_device_lock, flags);
5338         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
5339                 if (raid_device->wwid == wwid && raid_device->starget) {
5340                         raid_device->responding = 1;
5341                         starget_printk(KERN_INFO, raid_device->starget,
5342                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
5343                             (unsigned long long)raid_device->wwid);
5344                         if (raid_device->handle == handle)
5345                                 goto out;
5346                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
5347                             raid_device->handle);
5348                         raid_device->handle = handle;
5349                         starget = raid_device->starget;
5350                         sas_target_priv_data = starget->hostdata;
5351                         sas_target_priv_data->handle = handle;
5352                         goto out;
5353                 }
5354         }
5355  out:
5356         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
5357 }
5358
5359 /**
5360  * _scsih_search_responding_raid_devices -
5361  * @ioc: per adapter object
5362  *
5363  * After host reset, find out whether devices are still responding.
5364  * If not remove.
5365  *
5366  * Return nothing.
5367  */
5368 static void
5369 _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
5370 {
5371         Mpi2RaidVolPage1_t volume_pg1;
5372         Mpi2ConfigReply_t mpi_reply;
5373         u16 ioc_status;
5374         u16 handle;
5375
5376         printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
5377
5378         if (list_empty(&ioc->raid_device_list))
5379                 return;
5380
5381         handle = 0xFFFF;
5382         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
5383             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
5384                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5385                     MPI2_IOCSTATUS_MASK;
5386                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
5387                         break;
5388                 handle = le16_to_cpu(volume_pg1.DevHandle);
5389                 _scsih_mark_responding_raid_device(ioc,
5390                     le64_to_cpu(volume_pg1.WWID), handle);
5391         }
5392 }
5393
5394 /**
5395  * _scsih_mark_responding_expander - mark a expander as responding
5396  * @ioc: per adapter object
5397  * @sas_address: sas address
5398  * @handle:
5399  *
5400  * After host reset, find out whether devices are still responding.
5401  * Used in _scsi_remove_unresponsive_expanders.
5402  *
5403  * Return nothing.
5404  */
5405 static void
5406 _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5407      u16 handle)
5408 {
5409         struct _sas_node *sas_expander;
5410         unsigned long flags;
5411         int i;
5412
5413         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5414         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
5415                 if (sas_expander->sas_address != sas_address)
5416                         continue;
5417                 sas_expander->responding = 1;
5418                 if (sas_expander->handle == handle)
5419                         goto out;
5420                 printk(KERN_INFO "\texpander(0x%016llx): handle changed"
5421                     " from(0x%04x) to (0x%04x)!!!\n",
5422                     (unsigned long long)sas_expander->sas_address,
5423                     sas_expander->handle, handle);
5424                 sas_expander->handle = handle;
5425                 for (i = 0 ; i < sas_expander->num_phys ; i++)
5426                         sas_expander->phy[i].handle = handle;
5427                 goto out;
5428         }
5429  out:
5430         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5431 }
5432
5433 /**
5434  * _scsih_search_responding_expanders -
5435  * @ioc: per adapter object
5436  *
5437  * After host reset, find out whether devices are still responding.
5438  * If not remove.
5439  *
5440  * Return nothing.
5441  */
5442 static void
5443 _scsih_search_responding_expanders(struct MPT2SAS_ADAPTER *ioc)
5444 {
5445         Mpi2ExpanderPage0_t expander_pg0;
5446         Mpi2ConfigReply_t mpi_reply;
5447         u16 ioc_status;
5448         __le64 sas_address;
5449         u16 handle;
5450
5451         printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
5452
5453         if (list_empty(&ioc->sas_expander_list))
5454                 return;
5455
5456         handle = 0xFFFF;
5457         while (!(mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
5458             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
5459
5460                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5461                     MPI2_IOCSTATUS_MASK;
5462                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
5463                         break;
5464
5465                 handle = le16_to_cpu(expander_pg0.DevHandle);
5466                 sas_address = le64_to_cpu(expander_pg0.SASAddress);
5467                 printk(KERN_INFO "\texpander present: handle(0x%04x), "
5468                     "sas_addr(0x%016llx)\n", handle,
5469                     (unsigned long long)sas_address);
5470                 _scsih_mark_responding_expander(ioc, sas_address, handle);
5471         }
5472
5473 }
5474
5475 /**
5476  * _scsih_remove_unresponding_devices - removing unresponding devices
5477  * @ioc: per adapter object
5478  *
5479  * Return nothing.
5480  */
5481 static void
5482 _scsih_remove_unresponding_devices(struct MPT2SAS_ADAPTER *ioc)
5483 {
5484         struct _sas_device *sas_device, *sas_device_next;
5485         struct _sas_node *sas_expander;
5486         struct _raid_device *raid_device, *raid_device_next;
5487
5488
5489         list_for_each_entry_safe(sas_device, sas_device_next,
5490             &ioc->sas_device_list, list) {
5491                 if (sas_device->responding) {
5492                         sas_device->responding = 0;
5493                         continue;
5494                 }
5495                 if (sas_device->starget)
5496                         starget_printk(KERN_INFO, sas_device->starget,
5497                             "removing: handle(0x%04x), sas_addr(0x%016llx), "
5498                             "enclosure logical id(0x%016llx), slot(%d)\n",
5499                             sas_device->handle,
5500                             (unsigned long long)sas_device->sas_address,
5501                             (unsigned long long)
5502                             sas_device->enclosure_logical_id,
5503                             sas_device->slot);
5504                 /* invalidate the device handle */
5505                 sas_device->handle = 0;
5506                 _scsih_remove_device(ioc, sas_device);
5507         }
5508
5509         list_for_each_entry_safe(raid_device, raid_device_next,
5510             &ioc->raid_device_list, list) {
5511                 if (raid_device->responding) {
5512                         raid_device->responding = 0;
5513                         continue;
5514                 }
5515                 if (raid_device->starget) {
5516                         starget_printk(KERN_INFO, raid_device->starget,
5517                             "removing: handle(0x%04x), wwid(0x%016llx)\n",
5518                               raid_device->handle,
5519                             (unsigned long long)raid_device->wwid);
5520                         scsi_remove_target(&raid_device->starget->dev);
5521                 }
5522                 _scsih_raid_device_remove(ioc, raid_device);
5523         }
5524
5525  retry_expander_search:
5526         sas_expander = NULL;
5527         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
5528                 if (sas_expander->responding) {
5529                         sas_expander->responding = 0;
5530                         continue;
5531                 }
5532                 _scsih_expander_remove(ioc, sas_expander->sas_address);
5533                 goto retry_expander_search;
5534         }
5535 }
5536
5537 /**
5538  * mpt2sas_scsih_reset_handler - reset callback handler (for scsih)
5539  * @ioc: per adapter object
5540  * @reset_phase: phase
5541  *
5542  * The handler for doing any required cleanup or initialization.
5543  *
5544  * The reset phase can be MPT2_IOC_PRE_RESET, MPT2_IOC_AFTER_RESET,
5545  * MPT2_IOC_DONE_RESET
5546  *
5547  * Return nothing.
5548  */
5549 void
5550 mpt2sas_scsih_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
5551 {
5552         switch (reset_phase) {
5553         case MPT2_IOC_PRE_RESET:
5554                 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
5555                     "MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
5556                 _scsih_fw_event_off(ioc);
5557                 break;
5558         case MPT2_IOC_AFTER_RESET:
5559                 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
5560                     "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
5561                 if (ioc->tm_cmds.status & MPT2_CMD_PENDING) {
5562                         ioc->tm_cmds.status |= MPT2_CMD_RESET;
5563                         mpt2sas_base_free_smid(ioc, ioc->tm_cmds.smid);
5564                         complete(&ioc->tm_cmds.done);
5565                 }
5566                 _scsih_fw_event_on(ioc);
5567                 _scsih_flush_running_cmds(ioc);
5568                 break;
5569         case MPT2_IOC_DONE_RESET:
5570                 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
5571                     "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
5572                 _scsih_sas_host_refresh(ioc);
5573                 _scsih_search_responding_sas_devices(ioc);
5574                 _scsih_search_responding_raid_devices(ioc);
5575                 _scsih_search_responding_expanders(ioc);
5576                 break;
5577         case MPT2_IOC_RUNNING:
5578                 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
5579                     "MPT2_IOC_RUNNING\n", ioc->name, __func__));
5580                 _scsih_remove_unresponding_devices(ioc);
5581                 break;
5582         }
5583 }
5584
5585 /**
5586  * _firmware_event_work - delayed task for processing firmware events
5587  * @ioc: per adapter object
5588  * @work: equal to the fw_event_work object
5589  * Context: user.
5590  *
5591  * Return nothing.
5592  */
5593 static void
5594 _firmware_event_work(struct work_struct *work)
5595 {
5596         struct fw_event_work *fw_event = container_of(work,
5597             struct fw_event_work, work);
5598         unsigned long flags;
5599         struct MPT2SAS_ADAPTER *ioc = fw_event->ioc;
5600
5601         /* the queue is being flushed so ignore this event */
5602         spin_lock_irqsave(&ioc->fw_event_lock, flags);
5603         if (ioc->fw_events_off || ioc->remove_host) {
5604                 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5605                 _scsih_fw_event_free(ioc, fw_event);
5606                 return;
5607         }
5608         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5609
5610         if (ioc->shost_recovery) {
5611                 _scsih_fw_event_requeue(ioc, fw_event, 1000);
5612                 return;
5613         }
5614
5615         switch (fw_event->event) {
5616         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
5617                 _scsih_sas_topology_change_event(ioc, fw_event);
5618                 break;
5619         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
5620                 _scsih_sas_device_status_change_event(ioc,
5621                     fw_event);
5622                 break;
5623         case MPI2_EVENT_SAS_DISCOVERY:
5624                 _scsih_sas_discovery_event(ioc,
5625                     fw_event);
5626                 break;
5627         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
5628                 _scsih_sas_broadcast_primative_event(ioc,
5629                     fw_event);
5630                 break;
5631         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
5632                 _scsih_sas_enclosure_dev_status_change_event(ioc,
5633                     fw_event);
5634                 break;
5635         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
5636                 _scsih_sas_ir_config_change_event(ioc, fw_event);
5637                 break;
5638         case MPI2_EVENT_IR_VOLUME:
5639                 _scsih_sas_ir_volume_event(ioc, fw_event);
5640                 break;
5641         case MPI2_EVENT_IR_PHYSICAL_DISK:
5642                 _scsih_sas_ir_physical_disk_event(ioc, fw_event);
5643                 break;
5644         case MPI2_EVENT_IR_OPERATION_STATUS:
5645                 _scsih_sas_ir_operation_status_event(ioc, fw_event);
5646                 break;
5647         case MPI2_EVENT_TASK_SET_FULL:
5648                 _scsih_task_set_full(ioc, fw_event);
5649                 break;
5650         }
5651         _scsih_fw_event_free(ioc, fw_event);
5652 }
5653
5654 /**
5655  * mpt2sas_scsih_event_callback - firmware event handler (called at ISR time)
5656  * @ioc: per adapter object
5657  * @msix_index: MSIX table index supplied by the OS
5658  * @reply: reply message frame(lower 32bit addr)
5659  * Context: interrupt.
5660  *
5661  * This function merely adds a new work task into ioc->firmware_event_thread.
5662  * The tasks are worked from _firmware_event_work in user context.
5663  *
5664  * Return 1 meaning mf should be freed from _base_interrupt
5665  *        0 means the mf is freed from this function.
5666  */
5667 u8
5668 mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
5669         u32 reply)
5670 {
5671         struct fw_event_work *fw_event;
5672         Mpi2EventNotificationReply_t *mpi_reply;
5673         unsigned long flags;
5674         u16 event;
5675
5676         /* events turned off due to host reset or driver unloading */
5677         spin_lock_irqsave(&ioc->fw_event_lock, flags);
5678         if (ioc->fw_events_off || ioc->remove_host) {
5679                 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5680                 return 1;
5681         }
5682         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5683
5684         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
5685         event = le16_to_cpu(mpi_reply->Event);
5686
5687         switch (event) {
5688         /* handle these */
5689         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
5690         {
5691                 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
5692                     (Mpi2EventDataSasBroadcastPrimitive_t *)
5693                     mpi_reply->EventData;
5694
5695                 if (baen_data->Primitive !=
5696                     MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT ||
5697                     ioc->broadcast_aen_busy)
5698                         return 1;
5699                 ioc->broadcast_aen_busy = 1;
5700                 break;
5701         }
5702
5703         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
5704                 _scsih_check_topo_delete_events(ioc,
5705                     (Mpi2EventDataSasTopologyChangeList_t *)
5706                     mpi_reply->EventData);
5707                 break;
5708
5709         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
5710         case MPI2_EVENT_IR_OPERATION_STATUS:
5711         case MPI2_EVENT_SAS_DISCOVERY:
5712         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
5713         case MPI2_EVENT_IR_VOLUME:
5714         case MPI2_EVENT_IR_PHYSICAL_DISK:
5715         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
5716         case MPI2_EVENT_TASK_SET_FULL:
5717                 break;
5718
5719         default: /* ignore the rest */
5720                 return 1;
5721         }
5722
5723         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
5724         if (!fw_event) {
5725                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5726                     ioc->name, __FILE__, __LINE__, __func__);
5727                 return 1;
5728         }
5729         fw_event->event_data =
5730             kzalloc(mpi_reply->EventDataLength*4, GFP_ATOMIC);
5731         if (!fw_event->event_data) {
5732                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5733                     ioc->name, __FILE__, __LINE__, __func__);
5734                 kfree(fw_event);
5735                 return 1;
5736         }
5737
5738         memcpy(fw_event->event_data, mpi_reply->EventData,
5739             mpi_reply->EventDataLength*4);
5740         fw_event->ioc = ioc;
5741         fw_event->VF_ID = mpi_reply->VF_ID;
5742         fw_event->VP_ID = mpi_reply->VP_ID;
5743         fw_event->event = event;
5744         _scsih_fw_event_add(ioc, fw_event);
5745         return 1;
5746 }
5747
5748 /* shost template */
5749 static struct scsi_host_template scsih_driver_template = {
5750         .module                         = THIS_MODULE,
5751         .name                           = "Fusion MPT SAS Host",
5752         .proc_name                      = MPT2SAS_DRIVER_NAME,
5753         .queuecommand                   = _scsih_qcmd,
5754         .target_alloc                   = _scsih_target_alloc,
5755         .slave_alloc                    = _scsih_slave_alloc,
5756         .slave_configure                = _scsih_slave_configure,
5757         .target_destroy                 = _scsih_target_destroy,
5758         .slave_destroy                  = _scsih_slave_destroy,
5759         .change_queue_depth             = _scsih_change_queue_depth,
5760         .change_queue_type              = _scsih_change_queue_type,
5761         .eh_abort_handler               = _scsih_abort,
5762         .eh_device_reset_handler        = _scsih_dev_reset,
5763         .eh_target_reset_handler        = _scsih_target_reset,
5764         .eh_host_reset_handler          = _scsih_host_reset,
5765         .bios_param                     = _scsih_bios_param,
5766         .can_queue                      = 1,
5767         .this_id                        = -1,
5768         .sg_tablesize                   = MPT2SAS_SG_DEPTH,
5769         .max_sectors                    = 8192,
5770         .cmd_per_lun                    = 7,
5771         .use_clustering                 = ENABLE_CLUSTERING,
5772         .shost_attrs                    = mpt2sas_host_attrs,
5773         .sdev_attrs                     = mpt2sas_dev_attrs,
5774 };
5775
5776 /**
5777  * _scsih_expander_node_remove - removing expander device from list.
5778  * @ioc: per adapter object
5779  * @sas_expander: the sas_device object
5780  * Context: Calling function should acquire ioc->sas_node_lock.
5781  *
5782  * Removing object and freeing associated memory from the
5783  * ioc->sas_expander_list.
5784  *
5785  * Return nothing.
5786  */
5787 static void
5788 _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
5789     struct _sas_node *sas_expander)
5790 {
5791         struct _sas_port *mpt2sas_port;
5792         struct _sas_device *sas_device;
5793         struct _sas_node *expander_sibling;
5794         unsigned long flags;
5795
5796         if (!sas_expander)
5797                 return;
5798
5799         /* remove sibling ports attached to this expander */
5800  retry_device_search:
5801         list_for_each_entry(mpt2sas_port,
5802            &sas_expander->sas_port_list, port_list) {
5803                 if (mpt2sas_port->remote_identify.device_type ==
5804                     SAS_END_DEVICE) {
5805                         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5806                         sas_device =
5807                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5808                            mpt2sas_port->remote_identify.sas_address);
5809                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5810                         if (!sas_device)
5811                                 continue;
5812                         _scsih_remove_device(ioc, sas_device);
5813                         if (ioc->shost_recovery)
5814                                 return;
5815                         goto retry_device_search;
5816                 }
5817         }
5818
5819  retry_expander_search:
5820         list_for_each_entry(mpt2sas_port,
5821            &sas_expander->sas_port_list, port_list) {
5822
5823                 if (mpt2sas_port->remote_identify.device_type ==
5824                     MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
5825                     mpt2sas_port->remote_identify.device_type ==
5826                     MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
5827
5828                         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5829                         expander_sibling =
5830                             mpt2sas_scsih_expander_find_by_sas_address(
5831                             ioc, mpt2sas_port->remote_identify.sas_address);
5832                         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5833                         if (!expander_sibling)
5834                                 continue;
5835                         _scsih_expander_remove(ioc,
5836                             expander_sibling->sas_address);
5837                         if (ioc->shost_recovery)
5838                                 return;
5839                         goto retry_expander_search;
5840                 }
5841         }
5842
5843         mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
5844             sas_expander->sas_address_parent);
5845
5846         printk(MPT2SAS_INFO_FMT "expander_remove: handle"
5847            "(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
5848             sas_expander->handle, (unsigned long long)
5849             sas_expander->sas_address);
5850
5851         list_del(&sas_expander->list);
5852         kfree(sas_expander->phy);
5853         kfree(sas_expander);
5854 }
5855
5856 /**
5857  * _scsih_remove - detach and remove add host
5858  * @pdev: PCI device struct
5859  *
5860  * Return nothing.
5861  */
5862 static void __devexit
5863 _scsih_remove(struct pci_dev *pdev)
5864 {
5865         struct Scsi_Host *shost = pci_get_drvdata(pdev);
5866         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
5867         struct _sas_port *mpt2sas_port;
5868         struct _sas_device *sas_device;
5869         struct _sas_node *expander_sibling;
5870         struct workqueue_struct *wq;
5871         unsigned long flags;
5872
5873         ioc->remove_host = 1;
5874         _scsih_fw_event_off(ioc);
5875
5876         spin_lock_irqsave(&ioc->fw_event_lock, flags);
5877         wq = ioc->firmware_event_thread;
5878         ioc->firmware_event_thread = NULL;
5879         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5880         if (wq)
5881                 destroy_workqueue(wq);
5882
5883         /* free ports attached to the sas_host */
5884  retry_again:
5885         list_for_each_entry(mpt2sas_port,
5886            &ioc->sas_hba.sas_port_list, port_list) {
5887                 if (mpt2sas_port->remote_identify.device_type ==
5888                     SAS_END_DEVICE) {
5889                         sas_device =
5890                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5891                            mpt2sas_port->remote_identify.sas_address);
5892                         if (sas_device) {
5893                                 _scsih_remove_device(ioc, sas_device);
5894                                 goto retry_again;
5895                         }
5896                 } else {
5897                         expander_sibling =
5898                             mpt2sas_scsih_expander_find_by_sas_address(ioc,
5899                             mpt2sas_port->remote_identify.sas_address);
5900                         if (expander_sibling) {
5901                                 _scsih_expander_remove(ioc,
5902                                     expander_sibling->sas_address);
5903                                 goto retry_again;
5904                         }
5905                 }
5906         }
5907
5908         /* free phys attached to the sas_host */
5909         if (ioc->sas_hba.num_phys) {
5910                 kfree(ioc->sas_hba.phy);
5911                 ioc->sas_hba.phy = NULL;
5912                 ioc->sas_hba.num_phys = 0;
5913         }
5914
5915         sas_remove_host(shost);
5916         mpt2sas_base_detach(ioc);
5917         list_del(&ioc->list);
5918         scsi_remove_host(shost);
5919         scsi_host_put(shost);
5920 }
5921
5922 /**
5923  * _scsih_probe_boot_devices - reports 1st device
5924  * @ioc: per adapter object
5925  *
5926  * If specified in bios page 2, this routine reports the 1st
5927  * device scsi-ml or sas transport for persistent boot device
5928  * purposes.  Please refer to function _scsih_determine_boot_device()
5929  */
5930 static void
5931 _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
5932 {
5933         u8 is_raid;
5934         void *device;
5935         struct _sas_device *sas_device;
5936         struct _raid_device *raid_device;
5937         u16 handle;
5938         u64 sas_address_parent;
5939         u64 sas_address;
5940         unsigned long flags;
5941         int rc;
5942
5943         device = NULL;
5944         if (ioc->req_boot_device.device) {
5945                 device =  ioc->req_boot_device.device;
5946                 is_raid = ioc->req_boot_device.is_raid;
5947         } else if (ioc->req_alt_boot_device.device) {
5948                 device =  ioc->req_alt_boot_device.device;
5949                 is_raid = ioc->req_alt_boot_device.is_raid;
5950         } else if (ioc->current_boot_device.device) {
5951                 device =  ioc->current_boot_device.device;
5952                 is_raid = ioc->current_boot_device.is_raid;
5953         }
5954
5955         if (!device)
5956                 return;
5957
5958         if (is_raid) {
5959                 raid_device = device;
5960                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
5961                     raid_device->id, 0);
5962                 if (rc)
5963                         _scsih_raid_device_remove(ioc, raid_device);
5964         } else {
5965                 sas_device = device;
5966                 handle = sas_device->handle;
5967                 sas_address_parent = sas_device->sas_address_parent;
5968                 sas_address = sas_device->sas_address;
5969                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5970                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
5971                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5972                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
5973                     sas_device->sas_address_parent)) {
5974                         _scsih_sas_device_remove(ioc, sas_device);
5975                 } else if (!sas_device->starget) {
5976                         mpt2sas_transport_port_remove(ioc, sas_address,
5977                             sas_address_parent);
5978                         _scsih_sas_device_remove(ioc, sas_device);
5979                 }
5980         }
5981 }
5982
5983 /**
5984  * _scsih_probe_raid - reporting raid volumes to scsi-ml
5985  * @ioc: per adapter object
5986  *
5987  * Called during initial loading of the driver.
5988  */
5989 static void
5990 _scsih_probe_raid(struct MPT2SAS_ADAPTER *ioc)
5991 {
5992         struct _raid_device *raid_device, *raid_next;
5993         int rc;
5994
5995         list_for_each_entry_safe(raid_device, raid_next,
5996             &ioc->raid_device_list, list) {
5997                 if (raid_device->starget)
5998                         continue;
5999                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
6000                     raid_device->id, 0);
6001                 if (rc)
6002                         _scsih_raid_device_remove(ioc, raid_device);
6003         }
6004 }
6005
6006 /**
6007  * _scsih_probe_sas - reporting sas devices to sas transport
6008  * @ioc: per adapter object
6009  *
6010  * Called during initial loading of the driver.
6011  */
6012 static void
6013 _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
6014 {
6015         struct _sas_device *sas_device, *next;
6016         unsigned long flags;
6017
6018         /* SAS Device List */
6019         list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
6020             list) {
6021                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
6022                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
6023                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
6024
6025                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
6026                     sas_device->sas_address_parent)) {
6027                         _scsih_sas_device_remove(ioc, sas_device);
6028                 } else if (!sas_device->starget) {
6029                         mpt2sas_transport_port_remove(ioc,
6030                             sas_device->sas_address,
6031                             sas_device->sas_address_parent);
6032                         _scsih_sas_device_remove(ioc, sas_device);
6033                 }
6034         }
6035 }
6036
6037 /**
6038  * _scsih_probe_devices - probing for devices
6039  * @ioc: per adapter object
6040  *
6041  * Called during initial loading of the driver.
6042  */
6043 static void
6044 _scsih_probe_devices(struct MPT2SAS_ADAPTER *ioc)
6045 {
6046         u16 volume_mapping_flags =
6047             le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
6048             MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
6049
6050         if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
6051                 return;  /* return when IOC doesn't support initiator mode */
6052
6053         _scsih_probe_boot_devices(ioc);
6054
6055         if (ioc->ir_firmware) {
6056                 if ((volume_mapping_flags &
6057                      MPI2_IOCPAGE8_IRFLAGS_HIGH_VOLUME_MAPPING)) {
6058                         _scsih_probe_sas(ioc);
6059                         _scsih_probe_raid(ioc);
6060                 } else {
6061                         _scsih_probe_raid(ioc);
6062                         _scsih_probe_sas(ioc);
6063                 }
6064         } else
6065                 _scsih_probe_sas(ioc);
6066 }
6067
6068 /**
6069  * _scsih_probe - attach and add scsi host
6070  * @pdev: PCI device struct
6071  * @id: pci device id
6072  *
6073  * Returns 0 success, anything else error.
6074  */
6075 static int
6076 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
6077 {
6078         struct MPT2SAS_ADAPTER *ioc;
6079         struct Scsi_Host *shost;
6080
6081         shost = scsi_host_alloc(&scsih_driver_template,
6082             sizeof(struct MPT2SAS_ADAPTER));
6083         if (!shost)
6084                 return -ENODEV;
6085
6086         /* init local params */
6087         ioc = shost_priv(shost);
6088         memset(ioc, 0, sizeof(struct MPT2SAS_ADAPTER));
6089         INIT_LIST_HEAD(&ioc->list);
6090         list_add_tail(&ioc->list, &mpt2sas_ioc_list);
6091         ioc->shost = shost;
6092         ioc->id = mpt_ids++;
6093         sprintf(ioc->name, "%s%d", MPT2SAS_DRIVER_NAME, ioc->id);
6094         ioc->pdev = pdev;
6095         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
6096         ioc->tm_cb_idx = tm_cb_idx;
6097         ioc->ctl_cb_idx = ctl_cb_idx;
6098         ioc->base_cb_idx = base_cb_idx;
6099         ioc->transport_cb_idx = transport_cb_idx;
6100         ioc->config_cb_idx = config_cb_idx;
6101         ioc->tm_tr_cb_idx = tm_tr_cb_idx;
6102         ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
6103         ioc->logging_level = logging_level;
6104         /* misc semaphores and spin locks */
6105         spin_lock_init(&ioc->ioc_reset_in_progress_lock);
6106         spin_lock_init(&ioc->scsi_lookup_lock);
6107         spin_lock_init(&ioc->sas_device_lock);
6108         spin_lock_init(&ioc->sas_node_lock);
6109         spin_lock_init(&ioc->fw_event_lock);
6110         spin_lock_init(&ioc->raid_device_lock);
6111
6112         INIT_LIST_HEAD(&ioc->sas_device_list);
6113         INIT_LIST_HEAD(&ioc->sas_device_init_list);
6114         INIT_LIST_HEAD(&ioc->sas_expander_list);
6115         INIT_LIST_HEAD(&ioc->fw_event_list);
6116         INIT_LIST_HEAD(&ioc->raid_device_list);
6117         INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
6118         INIT_LIST_HEAD(&ioc->delayed_tr_list);
6119
6120         /* init shost parameters */
6121         shost->max_cmd_len = 16;
6122         shost->max_lun = max_lun;
6123         shost->transportt = mpt2sas_transport_template;
6124         shost->unique_id = ioc->id;
6125
6126         if ((scsi_add_host(shost, &pdev->dev))) {
6127                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6128                     ioc->name, __FILE__, __LINE__, __func__);
6129                 list_del(&ioc->list);
6130                 goto out_add_shost_fail;
6131         }
6132
6133         scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
6134             | SHOST_DIF_TYPE3_PROTECTION);
6135         scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
6136
6137         /* event thread */
6138         snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
6139             "fw_event%d", ioc->id);
6140         ioc->firmware_event_thread = create_singlethread_workqueue(
6141             ioc->firmware_event_name);
6142         if (!ioc->firmware_event_thread) {
6143                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6144                     ioc->name, __FILE__, __LINE__, __func__);
6145                 goto out_thread_fail;
6146         }
6147
6148         ioc->wait_for_port_enable_to_complete = 1;
6149         if ((mpt2sas_base_attach(ioc))) {
6150                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
6151                     ioc->name, __FILE__, __LINE__, __func__);
6152                 goto out_attach_fail;
6153         }
6154
6155         ioc->wait_for_port_enable_to_complete = 0;
6156         _scsih_probe_devices(ioc);
6157         return 0;
6158
6159  out_attach_fail:
6160         destroy_workqueue(ioc->firmware_event_thread);
6161  out_thread_fail:
6162         list_del(&ioc->list);
6163         scsi_remove_host(shost);
6164  out_add_shost_fail:
6165         return -ENODEV;
6166 }
6167
6168 #ifdef CONFIG_PM
6169 /**
6170  * _scsih_suspend - power management suspend main entry point
6171  * @pdev: PCI device struct
6172  * @state: PM state change to (usually PCI_D3)
6173  *
6174  * Returns 0 success, anything else error.
6175  */
6176 static int
6177 _scsih_suspend(struct pci_dev *pdev, pm_message_t state)
6178 {
6179         struct Scsi_Host *shost = pci_get_drvdata(pdev);
6180         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
6181         u32 device_state;
6182
6183         mpt2sas_base_stop_watchdog(ioc);
6184         flush_scheduled_work();
6185         scsi_block_requests(shost);
6186         device_state = pci_choose_state(pdev, state);
6187         printk(MPT2SAS_INFO_FMT "pdev=0x%p, slot=%s, entering "
6188             "operating state [D%d]\n", ioc->name, pdev,
6189             pci_name(pdev), device_state);
6190
6191         mpt2sas_base_free_resources(ioc);
6192         pci_save_state(pdev);
6193         pci_disable_device(pdev);
6194         pci_set_power_state(pdev, device_state);
6195         return 0;
6196 }
6197
6198 /**
6199  * _scsih_resume - power management resume main entry point
6200  * @pdev: PCI device struct
6201  *
6202  * Returns 0 success, anything else error.
6203  */
6204 static int
6205 _scsih_resume(struct pci_dev *pdev)
6206 {
6207         struct Scsi_Host *shost = pci_get_drvdata(pdev);
6208         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
6209         u32 device_state = pdev->current_state;
6210         int r;
6211
6212         printk(MPT2SAS_INFO_FMT "pdev=0x%p, slot=%s, previous "
6213             "operating state [D%d]\n", ioc->name, pdev,
6214             pci_name(pdev), device_state);
6215
6216         pci_set_power_state(pdev, PCI_D0);
6217         pci_enable_wake(pdev, PCI_D0, 0);
6218         pci_restore_state(pdev);
6219         ioc->pdev = pdev;
6220         r = mpt2sas_base_map_resources(ioc);
6221         if (r)
6222                 return r;
6223
6224         mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
6225         scsi_unblock_requests(shost);
6226         mpt2sas_base_start_watchdog(ioc);
6227         return 0;
6228 }
6229 #endif /* CONFIG_PM */
6230
6231
6232 static struct pci_driver scsih_driver = {
6233         .name           = MPT2SAS_DRIVER_NAME,
6234         .id_table       = scsih_pci_table,
6235         .probe          = _scsih_probe,
6236         .remove         = __devexit_p(_scsih_remove),
6237 #ifdef CONFIG_PM
6238         .suspend        = _scsih_suspend,
6239         .resume         = _scsih_resume,
6240 #endif
6241 };
6242
6243
6244 /**
6245  * _scsih_init - main entry point for this driver.
6246  *
6247  * Returns 0 success, anything else error.
6248  */
6249 static int __init
6250 _scsih_init(void)
6251 {
6252         int error;
6253
6254         mpt_ids = 0;
6255         printk(KERN_INFO "%s version %s loaded\n", MPT2SAS_DRIVER_NAME,
6256             MPT2SAS_DRIVER_VERSION);
6257
6258         mpt2sas_transport_template =
6259             sas_attach_transport(&mpt2sas_transport_functions);
6260         if (!mpt2sas_transport_template)
6261                 return -ENODEV;
6262
6263         mpt2sas_base_initialize_callback_handler();
6264
6265          /* queuecommand callback hander */
6266         scsi_io_cb_idx = mpt2sas_base_register_callback_handler(_scsih_io_done);
6267
6268         /* task managment callback handler */
6269         tm_cb_idx = mpt2sas_base_register_callback_handler(_scsih_tm_done);
6270
6271         /* base internal commands callback handler */
6272         base_cb_idx = mpt2sas_base_register_callback_handler(mpt2sas_base_done);
6273
6274         /* transport internal commands callback handler */
6275         transport_cb_idx = mpt2sas_base_register_callback_handler(
6276             mpt2sas_transport_done);
6277
6278         /* configuration page API internal commands callback handler */
6279         config_cb_idx = mpt2sas_base_register_callback_handler(
6280             mpt2sas_config_done);
6281
6282         /* ctl module callback handler */
6283         ctl_cb_idx = mpt2sas_base_register_callback_handler(mpt2sas_ctl_done);
6284
6285         tm_tr_cb_idx = mpt2sas_base_register_callback_handler(
6286             _scsih_tm_tr_complete);
6287         tm_sas_control_cb_idx = mpt2sas_base_register_callback_handler(
6288             _scsih_sas_control_complete);
6289
6290         mpt2sas_ctl_init();
6291
6292         error = pci_register_driver(&scsih_driver);
6293         if (error)
6294                 sas_release_transport(mpt2sas_transport_template);
6295
6296         return error;
6297 }
6298
6299 /**
6300  * _scsih_exit - exit point for this driver (when it is a module).
6301  *
6302  * Returns 0 success, anything else error.
6303  */
6304 static void __exit
6305 _scsih_exit(void)
6306 {
6307         printk(KERN_INFO "mpt2sas version %s unloading\n",
6308             MPT2SAS_DRIVER_VERSION);
6309
6310         pci_unregister_driver(&scsih_driver);
6311
6312         sas_release_transport(mpt2sas_transport_template);
6313         mpt2sas_base_release_callback_handler(scsi_io_cb_idx);
6314         mpt2sas_base_release_callback_handler(tm_cb_idx);
6315         mpt2sas_base_release_callback_handler(base_cb_idx);
6316         mpt2sas_base_release_callback_handler(transport_cb_idx);
6317         mpt2sas_base_release_callback_handler(config_cb_idx);
6318         mpt2sas_base_release_callback_handler(ctl_cb_idx);
6319
6320         mpt2sas_base_release_callback_handler(tm_tr_cb_idx);
6321         mpt2sas_base_release_callback_handler(tm_sas_control_cb_idx);
6322
6323         mpt2sas_ctl_exit();
6324 }
6325
6326 module_init(_scsih_init);
6327 module_exit(_scsih_exit);