drivers/scsi/mpt3sas/mpt3sas_scsih.c

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