git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/mpt2sas/mpt2sas_scsih.c

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