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 (sas_device->enclosure_handle && !(mpt2sas_config_get_enclosure_pg0(
3667            ioc, &mpi_reply, &enclosure_pg0, 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         /* get device name */
3673         sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName);
3674
3675         if (ioc->wait_for_port_enable_to_complete)
3676                 _scsih_sas_device_init_add(ioc, sas_device);
3677         else
3678                 _scsih_sas_device_add(ioc, sas_device);
3679
3680         return 0;
3681 }
3682
3683 /**
3684  * _scsih_remove_device -  removing sas device object
3685  * @ioc: per adapter object
3686  * @handle: sas device handle
3687  *
3688  * Return nothing.
3689  */
3690 static void
3691 _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
3692 {
3693         struct MPT2SAS_TARGET *sas_target_priv_data;
3694         struct _sas_device *sas_device;
3695         unsigned long flags;
3696         Mpi2SasIoUnitControlReply_t mpi_reply;
3697         Mpi2SasIoUnitControlRequest_t mpi_request;
3698         u16 device_handle;
3699
3700         /* lookup sas_device */
3701         spin_lock_irqsave(&ioc->sas_device_lock, flags);
3702         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
3703         if (!sas_device) {
3704                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3705                 return;
3706         }
3707
3708         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: handle"
3709             "(0x%04x)\n", ioc->name, __func__, handle));
3710
3711         if (sas_device->starget && sas_device->starget->hostdata) {
3712                 sas_target_priv_data = sas_device->starget->hostdata;
3713                 sas_target_priv_data->deleted = 1;
3714         }
3715         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
3716
3717         if (ioc->remove_host)
3718                 goto out;
3719
3720         /* Target Reset to flush out all the outstanding IO */
3721         device_handle = (sas_device->hidden_raid_component) ?
3722             sas_device->volume_handle : handle;
3723         if (device_handle) {
3724                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "issue target reset: "
3725                     "handle(0x%04x)\n", ioc->name, device_handle));
3726                 mutex_lock(&ioc->tm_cmds.mutex);
3727                 mpt2sas_scsih_issue_tm(ioc, device_handle, 0,
3728                     MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 10);
3729                 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
3730                 mutex_unlock(&ioc->tm_cmds.mutex);
3731                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "issue target reset "
3732                     "done: handle(0x%04x)\n", ioc->name, device_handle));
3733         }
3734
3735         /* SAS_IO_UNIT_CNTR - send REMOVE_DEVICE */
3736         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "sas_iounit: handle"
3737             "(0x%04x)\n", ioc->name, handle));
3738         memset(&mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
3739         mpi_request.Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
3740         mpi_request.Operation = MPI2_SAS_OP_REMOVE_DEVICE;
3741         mpi_request.DevHandle = handle;
3742         mpi_request.VF_ID = 0;
3743         if ((mpt2sas_base_sas_iounit_control(ioc, &mpi_reply,
3744             &mpi_request)) != 0) {
3745                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
3746                     ioc->name, __FILE__, __LINE__, __func__);
3747         }
3748
3749         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "sas_iounit: ioc_status"
3750             "(0x%04x), loginfo(0x%08x)\n", ioc->name,
3751             le16_to_cpu(mpi_reply.IOCStatus),
3752             le32_to_cpu(mpi_reply.IOCLogInfo)));
3753
3754  out:
3755         mpt2sas_transport_port_remove(ioc, sas_device->sas_address,
3756             sas_device->parent_handle);
3757
3758         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
3759             "(0x%016llx)\n", ioc->name, sas_device->handle,
3760             (unsigned long long) sas_device->sas_address);
3761         _scsih_sas_device_remove(ioc, sas_device);
3762
3763         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: exit: handle"
3764             "(0x%04x)\n", ioc->name, __func__, handle));
3765 }
3766
3767 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
3768 /**
3769  * _scsih_sas_topology_change_event_debug - debug for topology event
3770  * @ioc: per adapter object
3771  * @event_data: event data payload
3772  * Context: user.
3773  */
3774 static void
3775 _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
3776     Mpi2EventDataSasTopologyChangeList_t *event_data)
3777 {
3778         int i;
3779         u16 handle;
3780         u16 reason_code;
3781         u8 phy_number;
3782         char *status_str = NULL;
3783         char link_rate[25];
3784
3785         switch (event_data->ExpStatus) {
3786         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
3787                 status_str = "add";
3788                 break;
3789         case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING:
3790                 status_str = "remove";
3791                 break;
3792         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
3793                 status_str =  "responding";
3794                 break;
3795         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
3796                 status_str = "remove delay";
3797                 break;
3798         default:
3799                 status_str = "unknown status";
3800                 break;
3801         }
3802         printk(MPT2SAS_DEBUG_FMT "sas topology change: (%s)\n",
3803             ioc->name, status_str);
3804         printk(KERN_DEBUG "\thandle(0x%04x), enclosure_handle(0x%04x) "
3805             "start_phy(%02d), count(%d)\n",
3806             le16_to_cpu(event_data->ExpanderDevHandle),
3807             le16_to_cpu(event_data->EnclosureHandle),
3808             event_data->StartPhyNum, event_data->NumEntries);
3809         for (i = 0; i < event_data->NumEntries; i++) {
3810                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3811                 if (!handle)
3812                         continue;
3813                 phy_number = event_data->StartPhyNum + i;
3814                 reason_code = event_data->PHY[i].PhyStatus &
3815                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3816                 switch (reason_code) {
3817                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
3818                         snprintf(link_rate, 25, ": add, link(0x%02x)",
3819                             (event_data->PHY[i].LinkRate >> 4));
3820                         status_str = link_rate;
3821                         break;
3822                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
3823                         status_str = ": remove";
3824                         break;
3825                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
3826                         status_str = ": remove_delay";
3827                         break;
3828                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
3829                         snprintf(link_rate, 25, ": link(0x%02x)",
3830                             (event_data->PHY[i].LinkRate >> 4));
3831                         status_str = link_rate;
3832                         break;
3833                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
3834                         status_str = ": responding";
3835                         break;
3836                 default:
3837                         status_str = ": unknown";
3838                         break;
3839                 }
3840                 printk(KERN_DEBUG "\tphy(%02d), attached_handle(0x%04x)%s\n",
3841                     phy_number, handle, status_str);
3842         }
3843 }
3844 #endif
3845
3846 /**
3847  * _scsih_sas_topology_change_event - handle topology changes
3848  * @ioc: per adapter object
3849  * @VF_ID:
3850  * @event_data: event data payload
3851  * fw_event:
3852  * Context: user.
3853  *
3854  */
3855 static void
3856 _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
3857     Mpi2EventDataSasTopologyChangeList_t *event_data,
3858     struct fw_event_work *fw_event)
3859 {
3860         int i;
3861         u16 parent_handle, handle;
3862         u16 reason_code;
3863         u8 phy_number;
3864         struct _sas_node *sas_expander;
3865         unsigned long flags;
3866         u8 link_rate_;
3867
3868 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
3869         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
3870                 _scsih_sas_topology_change_event_debug(ioc, event_data);
3871 #endif
3872
3873         if (!ioc->sas_hba.num_phys)
3874                 _scsih_sas_host_add(ioc);
3875         else
3876                 _scsih_sas_host_refresh(ioc, 0);
3877
3878         if (fw_event->ignore) {
3879                 dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "ignoring expander "
3880                     "event\n", ioc->name));
3881                 return;
3882         }
3883
3884         parent_handle = le16_to_cpu(event_data->ExpanderDevHandle);
3885
3886         /* handle expander add */
3887         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED)
3888                 if (_scsih_expander_add(ioc, parent_handle) != 0)
3889                         return;
3890
3891         /* handle siblings events */
3892         for (i = 0; i < event_data->NumEntries; i++) {
3893                 if (fw_event->ignore) {
3894                         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "ignoring "
3895                             "expander event\n", ioc->name));
3896                         return;
3897                 }
3898                 if (event_data->PHY[i].PhyStatus &
3899                     MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT)
3900                         continue;
3901                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
3902                 if (!handle)
3903                         continue;
3904                 phy_number = event_data->StartPhyNum + i;
3905                 reason_code = event_data->PHY[i].PhyStatus &
3906                     MPI2_EVENT_SAS_TOPO_RC_MASK;
3907                 link_rate_ = event_data->PHY[i].LinkRate >> 4;
3908                 switch (reason_code) {
3909                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
3910                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
3911                         if (!parent_handle) {
3912                                 if (phy_number < ioc->sas_hba.num_phys)
3913                                         _scsih_link_change(ioc,
3914                                            ioc->sas_hba.phy[phy_number].handle,
3915                                            handle, phy_number, link_rate_);
3916                         } else {
3917                                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
3918                                 sas_expander =
3919                                     mpt2sas_scsih_expander_find_by_handle(ioc,
3920                                         parent_handle);
3921                                 spin_unlock_irqrestore(&ioc->sas_node_lock,
3922                                     flags);
3923                                 if (sas_expander) {
3924                                         if (phy_number < sas_expander->num_phys)
3925                                                 _scsih_link_change(ioc,
3926                                                    sas_expander->
3927                                                    phy[phy_number].handle,
3928                                                    handle, phy_number,
3929                                                    link_rate_);
3930                                 }
3931                         }
3932                         if (reason_code == MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED) {
3933                                 if (link_rate_ >= MPI2_SAS_NEG_LINK_RATE_1_5)
3934                                         _scsih_ublock_io_device(ioc, handle);
3935                         }
3936                         if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED) {
3937                                 if (link_rate_ < MPI2_SAS_NEG_LINK_RATE_1_5)
3938                                         break;
3939                                 _scsih_add_device(ioc, handle, phy_number, 0);
3940                         }
3941                         break;
3942                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
3943                         _scsih_remove_device(ioc, handle);
3944                         break;
3945                 }
3946         }
3947
3948         /* handle expander removal */
3949         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
3950                 _scsih_expander_remove(ioc, parent_handle);
3951
3952 }
3953
3954 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
3955 /**
3956  * _scsih_sas_device_status_change_event_debug - debug for device event
3957  * @event_data: event data payload
3958  * Context: user.
3959  *
3960  * Return nothing.
3961  */
3962 static void
3963 _scsih_sas_device_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
3964     Mpi2EventDataSasDeviceStatusChange_t *event_data)
3965 {
3966         char *reason_str = NULL;
3967
3968         switch (event_data->ReasonCode) {
3969         case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
3970                 reason_str = "smart data";
3971                 break;
3972         case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
3973                 reason_str = "unsupported device discovered";
3974                 break;
3975         case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
3976                 reason_str = "internal device reset";
3977                 break;
3978         case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
3979                 reason_str = "internal task abort";
3980                 break;
3981         case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
3982                 reason_str = "internal task abort set";
3983                 break;
3984         case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
3985                 reason_str = "internal clear task set";
3986                 break;
3987         case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
3988                 reason_str = "internal query task";
3989                 break;
3990         case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE:
3991                 reason_str = "sata init failure";
3992                 break;
3993         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET:
3994                 reason_str = "internal device reset complete";
3995                 break;
3996         case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL:
3997                 reason_str = "internal task abort complete";
3998                 break;
3999         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
4000                 reason_str = "internal async notification";
4001                 break;
4002         default:
4003                 reason_str = "unknown reason";
4004                 break;
4005         }
4006         printk(MPT2SAS_DEBUG_FMT "device status change: (%s)\n"
4007             "\thandle(0x%04x), sas address(0x%016llx)", ioc->name,
4008             reason_str, le16_to_cpu(event_data->DevHandle),
4009             (unsigned long long)le64_to_cpu(event_data->SASAddress));
4010         if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
4011                 printk(MPT2SAS_DEBUG_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
4012                     event_data->ASC, event_data->ASCQ);
4013         printk(KERN_INFO "\n");
4014 }
4015 #endif
4016
4017 /**
4018  * _scsih_sas_device_status_change_event - handle device status change
4019  * @ioc: per adapter object
4020  * @VF_ID:
4021  * @event_data: event data payload
4022  * Context: user.
4023  *
4024  * Return nothing.
4025  */
4026 static void
4027 _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4028     Mpi2EventDataSasDeviceStatusChange_t *event_data)
4029 {
4030 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4031         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4032                 _scsih_sas_device_status_change_event_debug(ioc, event_data);
4033 #endif
4034 }
4035
4036 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4037 /**
4038  * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure event
4039  * @ioc: per adapter object
4040  * @event_data: event data payload
4041  * Context: user.
4042  *
4043  * Return nothing.
4044  */
4045 static void
4046 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
4047     Mpi2EventDataSasEnclDevStatusChange_t *event_data)
4048 {
4049         char *reason_str = NULL;
4050
4051         switch (event_data->ReasonCode) {
4052         case MPI2_EVENT_SAS_ENCL_RC_ADDED:
4053                 reason_str = "enclosure add";
4054                 break;
4055         case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING:
4056                 reason_str = "enclosure remove";
4057                 break;
4058         default:
4059                 reason_str = "unknown reason";
4060                 break;
4061         }
4062
4063         printk(MPT2SAS_DEBUG_FMT "enclosure status change: (%s)\n"
4064             "\thandle(0x%04x), enclosure logical id(0x%016llx)"
4065             " number slots(%d)\n", ioc->name, reason_str,
4066             le16_to_cpu(event_data->EnclosureHandle),
4067             (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
4068             le16_to_cpu(event_data->StartSlot));
4069 }
4070 #endif
4071
4072 /**
4073  * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events
4074  * @ioc: per adapter object
4075  * @VF_ID:
4076  * @event_data: event data payload
4077  * Context: user.
4078  *
4079  * Return nothing.
4080  */
4081 static void
4082 _scsih_sas_enclosure_dev_status_change_event(struct MPT2SAS_ADAPTER *ioc,
4083     u8 VF_ID, Mpi2EventDataSasEnclDevStatusChange_t *event_data)
4084 {
4085 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4086         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4087                 _scsih_sas_enclosure_dev_status_change_event_debug(ioc,
4088                      event_data);
4089 #endif
4090 }
4091
4092 /**
4093  * _scsih_sas_broadcast_primative_event - handle broadcast events
4094  * @ioc: per adapter object
4095  * @event_data: event data payload
4096  * Context: user.
4097  *
4098  * Return nothing.
4099  */
4100 static void
4101 _scsih_sas_broadcast_primative_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4102     Mpi2EventDataSasBroadcastPrimitive_t *event_data)
4103 {
4104         struct scsi_cmnd *scmd;
4105         u16 smid, handle;
4106         u32 lun;
4107         struct MPT2SAS_DEVICE *sas_device_priv_data;
4108         u32 termination_count;
4109         u32 query_count;
4110         Mpi2SCSITaskManagementReply_t *mpi_reply;
4111
4112         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "broadcast primative: "
4113             "phy number(%d), width(%d)\n", ioc->name, event_data->PhyNum,
4114             event_data->PortWidth));
4115
4116         dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
4117             __func__));
4118
4119         mutex_lock(&ioc->tm_cmds.mutex);
4120         termination_count = 0;
4121         query_count = 0;
4122         mpi_reply = ioc->tm_cmds.reply;
4123         for (smid = 1; smid <= ioc->request_depth; smid++) {
4124                 scmd = _scsih_scsi_lookup_get(ioc, smid);
4125                 if (!scmd)
4126                         continue;
4127                 sas_device_priv_data = scmd->device->hostdata;
4128                 if (!sas_device_priv_data || !sas_device_priv_data->sas_target)
4129                         continue;
4130                  /* skip hidden raid components */
4131                 if (sas_device_priv_data->sas_target->flags &
4132                     MPT_TARGET_FLAGS_RAID_COMPONENT)
4133                         continue;
4134                  /* skip volumes */
4135                 if (sas_device_priv_data->sas_target->flags &
4136                     MPT_TARGET_FLAGS_VOLUME)
4137                         continue;
4138
4139                 handle = sas_device_priv_data->sas_target->handle;
4140                 lun = sas_device_priv_data->lun;
4141                 query_count++;
4142
4143                 mpt2sas_scsih_issue_tm(ioc, handle, lun,
4144                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30);
4145                 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
4146
4147                 if ((mpi_reply->IOCStatus == MPI2_IOCSTATUS_SUCCESS) &&
4148                     (mpi_reply->ResponseCode ==
4149                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4150                      mpi_reply->ResponseCode ==
4151                      MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4152                         continue;
4153
4154                 mpt2sas_scsih_issue_tm(ioc, handle, lun,
4155                     MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET, 0, 30);
4156                 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
4157                 termination_count += le32_to_cpu(mpi_reply->TerminationCount);
4158         }
4159         ioc->broadcast_aen_busy = 0;
4160         mutex_unlock(&ioc->tm_cmds.mutex);
4161
4162         dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT
4163             "%s - exit, query_count = %d termination_count = %d\n",
4164             ioc->name, __func__, query_count, termination_count));
4165 }
4166
4167 /**
4168  * _scsih_sas_discovery_event - handle discovery events
4169  * @ioc: per adapter object
4170  * @event_data: event data payload
4171  * Context: user.
4172  *
4173  * Return nothing.
4174  */
4175 static void
4176 _scsih_sas_discovery_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4177     Mpi2EventDataSasDiscovery_t *event_data)
4178 {
4179 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4180         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
4181                 printk(MPT2SAS_DEBUG_FMT "discovery event: (%s)", ioc->name,
4182                     (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
4183                     "start" : "stop");
4184         if (event_data->DiscoveryStatus)
4185                 printk(MPT2SAS_DEBUG_FMT ", discovery_status(0x%08x)",
4186                     ioc->name, le32_to_cpu(event_data->DiscoveryStatus));
4187         printk("\n");
4188         }
4189 #endif
4190
4191         if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
4192             !ioc->sas_hba.num_phys)
4193                 _scsih_sas_host_add(ioc);
4194 }
4195
4196 /**
4197  * _scsih_reprobe_lun - reprobing lun
4198  * @sdev: scsi device struct
4199  * @no_uld_attach: sdev->no_uld_attach flag setting
4200  *
4201  **/
4202 static void
4203 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
4204 {
4205         int rc;
4206
4207         sdev->no_uld_attach = no_uld_attach ? 1 : 0;
4208         sdev_printk(KERN_INFO, sdev, "%s raid component\n",
4209             sdev->no_uld_attach ? "hidding" : "exposing");
4210         rc = scsi_device_reprobe(sdev);
4211 }
4212
4213 /**
4214  * _scsih_reprobe_target - reprobing target
4215  * @starget: scsi target struct
4216  * @no_uld_attach: sdev->no_uld_attach flag setting
4217  *
4218  * Note: no_uld_attach flag determines whether the disk device is attached
4219  * to block layer. A value of `1` means to not attach.
4220  **/
4221 static void
4222 _scsih_reprobe_target(struct scsi_target *starget, int no_uld_attach)
4223 {
4224         struct MPT2SAS_TARGET *sas_target_priv_data = starget->hostdata;
4225
4226         if (no_uld_attach)
4227                 sas_target_priv_data->flags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4228         else
4229                 sas_target_priv_data->flags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4230
4231         starget_for_each_device(starget, no_uld_attach ? (void *)1 : NULL,
4232             _scsih_reprobe_lun);
4233 }
4234 /**
4235  * _scsih_sas_volume_add - add new volume
4236  * @ioc: per adapter object
4237  * @element: IR config element data
4238  * Context: user.
4239  *
4240  * Return nothing.
4241  */
4242 static void
4243 _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
4244     Mpi2EventIrConfigElement_t *element)
4245 {
4246         struct _raid_device *raid_device;
4247         unsigned long flags;
4248         u64 wwid;
4249         u16 handle = le16_to_cpu(element->VolDevHandle);
4250         int rc;
4251
4252 #if 0 /* RAID_HACKS */
4253         if (le32_to_cpu(event_data->Flags) &
4254             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
4255                 return;
4256 #endif
4257
4258         mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
4259         if (!wwid) {
4260                 printk(MPT2SAS_ERR_FMT
4261                     "failure at %s:%d/%s()!\n", ioc->name,
4262                     __FILE__, __LINE__, __func__);
4263                 return;
4264         }
4265
4266         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4267         raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid);
4268         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4269
4270         if (raid_device)
4271                 return;
4272
4273         raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
4274         if (!raid_device) {
4275                 printk(MPT2SAS_ERR_FMT
4276                     "failure at %s:%d/%s()!\n", ioc->name,
4277                     __FILE__, __LINE__, __func__);
4278                 return;
4279         }
4280
4281         raid_device->id = ioc->sas_id++;
4282         raid_device->channel = RAID_CHANNEL;
4283         raid_device->handle = handle;
4284         raid_device->wwid = wwid;
4285         _scsih_raid_device_add(ioc, raid_device);
4286         if (!ioc->wait_for_port_enable_to_complete) {
4287                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
4288                     raid_device->id, 0);
4289                 if (rc)
4290                         _scsih_raid_device_remove(ioc, raid_device);
4291         } else
4292                 _scsih_determine_boot_device(ioc, raid_device, 1);
4293 }
4294
4295 /**
4296  * _scsih_sas_volume_delete - delete volume
4297  * @ioc: per adapter object
4298  * @element: IR config element data
4299  * Context: user.
4300  *
4301  * Return nothing.
4302  */
4303 static void
4304 _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc,
4305     Mpi2EventIrConfigElement_t *element)
4306 {
4307         struct _raid_device *raid_device;
4308         u16 handle = le16_to_cpu(element->VolDevHandle);
4309         unsigned long flags;
4310         struct MPT2SAS_TARGET *sas_target_priv_data;
4311
4312 #if 0 /* RAID_HACKS */
4313         if (le32_to_cpu(event_data->Flags) &
4314             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG)
4315                 return;
4316 #endif
4317
4318         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4319         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
4320         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4321         if (!raid_device)
4322                 return;
4323         if (raid_device->starget) {
4324                 sas_target_priv_data = raid_device->starget->hostdata;
4325                 sas_target_priv_data->deleted = 1;
4326                 scsi_remove_target(&raid_device->starget->dev);
4327         }
4328         _scsih_raid_device_remove(ioc, raid_device);
4329 }
4330
4331 /**
4332  * _scsih_sas_pd_expose - expose pd component to /dev/sdX
4333  * @ioc: per adapter object
4334  * @element: IR config element data
4335  * Context: user.
4336  *
4337  * Return nothing.
4338  */
4339 static void
4340 _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
4341     Mpi2EventIrConfigElement_t *element)
4342 {
4343         struct _sas_device *sas_device;
4344         unsigned long flags;
4345         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4346
4347         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4348         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4349         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4350         if (!sas_device)
4351                 return;
4352
4353         /* exposing raid component */
4354         sas_device->volume_handle = 0;
4355         sas_device->volume_wwid = 0;
4356         sas_device->hidden_raid_component = 0;
4357         _scsih_reprobe_target(sas_device->starget, 0);
4358 }
4359
4360 /**
4361  * _scsih_sas_pd_hide - hide pd component from /dev/sdX
4362  * @ioc: per adapter object
4363  * @element: IR config element data
4364  * Context: user.
4365  *
4366  * Return nothing.
4367  */
4368 static void
4369 _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
4370     Mpi2EventIrConfigElement_t *element)
4371 {
4372         struct _sas_device *sas_device;
4373         unsigned long flags;
4374         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4375
4376         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4377         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4378         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4379         if (!sas_device)
4380                 return;
4381
4382         /* hiding raid component */
4383         mpt2sas_config_get_volume_handle(ioc, handle,
4384             &sas_device->volume_handle);
4385         mpt2sas_config_get_volume_wwid(ioc, sas_device->volume_handle,
4386             &sas_device->volume_wwid);
4387         sas_device->hidden_raid_component = 1;
4388         _scsih_reprobe_target(sas_device->starget, 1);
4389 }
4390
4391 /**
4392  * _scsih_sas_pd_delete - delete pd component
4393  * @ioc: per adapter object
4394  * @element: IR config element data
4395  * Context: user.
4396  *
4397  * Return nothing.
4398  */
4399 static void
4400 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
4401     Mpi2EventIrConfigElement_t *element)
4402 {
4403         struct _sas_device *sas_device;
4404         unsigned long flags;
4405         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4406
4407         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4408         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4409         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4410         if (!sas_device)
4411                 return;
4412         _scsih_remove_device(ioc, handle);
4413 }
4414
4415 /**
4416  * _scsih_sas_pd_add - remove pd component
4417  * @ioc: per adapter object
4418  * @element: IR config element data
4419  * Context: user.
4420  *
4421  * Return nothing.
4422  */
4423 static void
4424 _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
4425     Mpi2EventIrConfigElement_t *element)
4426 {
4427         struct _sas_device *sas_device;
4428         unsigned long flags;
4429         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
4430
4431         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4432         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4433         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4434         if (sas_device)
4435                 sas_device->hidden_raid_component = 1;
4436         else
4437                 _scsih_add_device(ioc, handle, 0, 1);
4438 }
4439
4440 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4441 /**
4442  * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events
4443  * @ioc: per adapter object
4444  * @event_data: event data payload
4445  * Context: user.
4446  *
4447  * Return nothing.
4448  */
4449 static void
4450 _scsih_sas_ir_config_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
4451     Mpi2EventDataIrConfigChangeList_t *event_data)
4452 {
4453         Mpi2EventIrConfigElement_t *element;
4454         u8 element_type;
4455         int i;
4456         char *reason_str = NULL, *element_str = NULL;
4457
4458         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4459
4460         printk(MPT2SAS_DEBUG_FMT "raid config change: (%s), elements(%d)\n",
4461             ioc->name, (le32_to_cpu(event_data->Flags) &
4462             MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
4463             "foreign" : "native", event_data->NumElements);
4464         for (i = 0; i < event_data->NumElements; i++, element++) {
4465                 switch (element->ReasonCode) {
4466                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
4467                         reason_str = "add";
4468                         break;
4469                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
4470                         reason_str = "remove";
4471                         break;
4472                 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:
4473                         reason_str = "no change";
4474                         break;
4475                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
4476                         reason_str = "hide";
4477                         break;
4478                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
4479                         reason_str = "unhide";
4480                         break;
4481                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
4482                         reason_str = "volume_created";
4483                         break;
4484                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
4485                         reason_str = "volume_deleted";
4486                         break;
4487                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
4488                         reason_str = "pd_created";
4489                         break;
4490                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
4491                         reason_str = "pd_deleted";
4492                         break;
4493                 default:
4494                         reason_str = "unknown reason";
4495                         break;
4496                 }
4497                 element_type = le16_to_cpu(element->ElementFlags) &
4498                     MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK;
4499                 switch (element_type) {
4500                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:
4501                         element_str = "volume";
4502                         break;
4503                 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:
4504                         element_str = "phys disk";
4505                         break;
4506                 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:
4507                         element_str = "hot spare";
4508                         break;
4509                 default:
4510                         element_str = "unknown element";
4511                         break;
4512                 }
4513                 printk(KERN_DEBUG "\t(%s:%s), vol handle(0x%04x), "
4514                     "pd handle(0x%04x), pd num(0x%02x)\n", element_str,
4515                     reason_str, le16_to_cpu(element->VolDevHandle),
4516                     le16_to_cpu(element->PhysDiskDevHandle),
4517                     element->PhysDiskNum);
4518         }
4519 }
4520 #endif
4521
4522 /**
4523  * _scsih_sas_ir_config_change_event - handle ir configuration change events
4524  * @ioc: per adapter object
4525  * @VF_ID:
4526  * @event_data: event data payload
4527  * Context: user.
4528  *
4529  * Return nothing.
4530  */
4531 static void
4532 _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4533     Mpi2EventDataIrConfigChangeList_t *event_data)
4534 {
4535         Mpi2EventIrConfigElement_t *element;
4536         int i;
4537
4538 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4539         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4540                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
4541
4542 #endif
4543
4544         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
4545         for (i = 0; i < event_data->NumElements; i++, element++) {
4546
4547                 switch (element->ReasonCode) {
4548                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:
4549                 case MPI2_EVENT_IR_CHANGE_RC_ADDED:
4550                         _scsih_sas_volume_add(ioc, element);
4551                         break;
4552                 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:
4553                 case MPI2_EVENT_IR_CHANGE_RC_REMOVED:
4554                         _scsih_sas_volume_delete(ioc, element);
4555                         break;
4556                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
4557                         _scsih_sas_pd_hide(ioc, element);
4558                         break;
4559                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
4560                         _scsih_sas_pd_expose(ioc, element);
4561                         break;
4562                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
4563                         _scsih_sas_pd_add(ioc, element);
4564                         break;
4565                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
4566                         _scsih_sas_pd_delete(ioc, element);
4567                         break;
4568                 }
4569         }
4570 }
4571
4572 /**
4573  * _scsih_sas_ir_volume_event - IR volume event
4574  * @ioc: per adapter object
4575  * @event_data: event data payload
4576  * Context: user.
4577  *
4578  * Return nothing.
4579  */
4580 static void
4581 _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4582     Mpi2EventDataIrVolume_t *event_data)
4583 {
4584         u64 wwid;
4585         unsigned long flags;
4586         struct _raid_device *raid_device;
4587         u16 handle;
4588         u32 state;
4589         int rc;
4590         struct MPT2SAS_TARGET *sas_target_priv_data;
4591
4592         if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)
4593                 return;
4594
4595         handle = le16_to_cpu(event_data->VolDevHandle);
4596         state = le32_to_cpu(event_data->NewValue);
4597         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: handle(0x%04x), "
4598             "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
4599             le32_to_cpu(event_data->PreviousValue), state));
4600
4601         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4602         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
4603         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4604
4605         switch (state) {
4606         case MPI2_RAID_VOL_STATE_MISSING:
4607         case MPI2_RAID_VOL_STATE_FAILED:
4608                 if (!raid_device)
4609                         break;
4610                 if (raid_device->starget) {
4611                         sas_target_priv_data = raid_device->starget->hostdata;
4612                         sas_target_priv_data->deleted = 1;
4613                         scsi_remove_target(&raid_device->starget->dev);
4614                 }
4615                 _scsih_raid_device_remove(ioc, raid_device);
4616                 break;
4617
4618         case MPI2_RAID_VOL_STATE_ONLINE:
4619         case MPI2_RAID_VOL_STATE_DEGRADED:
4620         case MPI2_RAID_VOL_STATE_OPTIMAL:
4621                 if (raid_device)
4622                         break;
4623
4624                 mpt2sas_config_get_volume_wwid(ioc, handle, &wwid);
4625                 if (!wwid) {
4626                         printk(MPT2SAS_ERR_FMT
4627                             "failure at %s:%d/%s()!\n", ioc->name,
4628                             __FILE__, __LINE__, __func__);
4629                         break;
4630                 }
4631
4632                 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
4633                 if (!raid_device) {
4634                         printk(MPT2SAS_ERR_FMT
4635                             "failure at %s:%d/%s()!\n", ioc->name,
4636                             __FILE__, __LINE__, __func__);
4637                         break;
4638                 }
4639
4640                 raid_device->id = ioc->sas_id++;
4641                 raid_device->channel = RAID_CHANNEL;
4642                 raid_device->handle = handle;
4643                 raid_device->wwid = wwid;
4644                 _scsih_raid_device_add(ioc, raid_device);
4645                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
4646                     raid_device->id, 0);
4647                 if (rc)
4648                         _scsih_raid_device_remove(ioc, raid_device);
4649                 break;
4650
4651         case MPI2_RAID_VOL_STATE_INITIALIZING:
4652         default:
4653                 break;
4654         }
4655 }
4656
4657 /**
4658  * _scsih_sas_ir_physical_disk_event - PD event
4659  * @ioc: per adapter object
4660  * @event_data: event data payload
4661  * Context: user.
4662  *
4663  * Return nothing.
4664  */
4665 static void
4666 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4667    Mpi2EventDataIrPhysicalDisk_t *event_data)
4668 {
4669         u16 handle;
4670         u32 state;
4671         struct _sas_device *sas_device;
4672         unsigned long flags;
4673
4674         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
4675                 return;
4676
4677         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
4678         state = le32_to_cpu(event_data->NewValue);
4679
4680         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: handle(0x%04x), "
4681             "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
4682             le32_to_cpu(event_data->PreviousValue), state));
4683
4684         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4685         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4686         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4687
4688         switch (state) {
4689 #if 0
4690         case MPI2_RAID_PD_STATE_OFFLINE:
4691                 if (sas_device)
4692                         _scsih_remove_device(ioc, handle);
4693                 break;
4694 #endif
4695         case MPI2_RAID_PD_STATE_ONLINE:
4696         case MPI2_RAID_PD_STATE_DEGRADED:
4697         case MPI2_RAID_PD_STATE_REBUILDING:
4698         case MPI2_RAID_PD_STATE_OPTIMAL:
4699                 if (sas_device)
4700                         sas_device->hidden_raid_component = 1;
4701                 else
4702                         _scsih_add_device(ioc, handle, 0, 1);
4703                 break;
4704
4705         case MPI2_RAID_PD_STATE_NOT_CONFIGURED:
4706         case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:
4707         case MPI2_RAID_PD_STATE_HOT_SPARE:
4708         default:
4709                 break;
4710         }
4711 }
4712
4713 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4714 /**
4715  * _scsih_sas_ir_operation_status_event_debug - debug for IR op event
4716  * @ioc: per adapter object
4717  * @event_data: event data payload
4718  * Context: user.
4719  *
4720  * Return nothing.
4721  */
4722 static void
4723 _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
4724     Mpi2EventDataIrOperationStatus_t *event_data)
4725 {
4726         char *reason_str = NULL;
4727
4728         switch (event_data->RAIDOperation) {
4729         case MPI2_EVENT_IR_RAIDOP_RESYNC:
4730                 reason_str = "resync";
4731                 break;
4732         case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:
4733                 reason_str = "online capacity expansion";
4734                 break;
4735         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
4736                 reason_str = "consistency check";
4737                 break;
4738         default:
4739                 reason_str = "unknown reason";
4740                 break;
4741         }
4742
4743         printk(MPT2SAS_INFO_FMT "raid operational status: (%s)"
4744             "\thandle(0x%04x), percent complete(%d)\n",
4745             ioc->name, reason_str,
4746             le16_to_cpu(event_data->VolDevHandle),
4747             event_data->PercentComplete);
4748 }
4749 #endif
4750
4751 /**
4752  * _scsih_sas_ir_operation_status_event - handle RAID operation events
4753  * @ioc: per adapter object
4754  * @VF_ID:
4755  * @event_data: event data payload
4756  * Context: user.
4757  *
4758  * Return nothing.
4759  */
4760 static void
4761 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4762     Mpi2EventDataIrOperationStatus_t *event_data)
4763 {
4764 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
4765         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
4766                 _scsih_sas_ir_operation_status_event_debug(ioc, event_data);
4767 #endif
4768 }
4769
4770 /**
4771  * _scsih_task_set_full - handle task set full
4772  * @ioc: per adapter object
4773  * @event_data: event data payload
4774  * Context: user.
4775  *
4776  * Throttle back qdepth.
4777  */
4778 static void
4779 _scsih_task_set_full(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
4780     Mpi2EventDataTaskSetFull_t *event_data)
4781 {
4782         unsigned long flags;
4783         struct _sas_device *sas_device;
4784         static struct _raid_device *raid_device;
4785         struct scsi_device *sdev;
4786         int depth;
4787         u16 current_depth;
4788         u16 handle;
4789         int id, channel;
4790         u64 sas_address;
4791
4792         current_depth = le16_to_cpu(event_data->CurrentDepth);
4793         handle = le16_to_cpu(event_data->DevHandle);
4794         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4795         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
4796         if (!sas_device) {
4797                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4798                 return;
4799         }
4800         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4801         id = sas_device->id;
4802         channel = sas_device->channel;
4803         sas_address = sas_device->sas_address;
4804
4805         /* if hidden raid component, then change to volume characteristics */
4806         if (sas_device->hidden_raid_component && sas_device->volume_handle) {
4807                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
4808                 raid_device = _scsih_raid_device_find_by_handle(
4809                     ioc, sas_device->volume_handle);
4810                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4811                 if (raid_device) {
4812                         id = raid_device->id;
4813                         channel = raid_device->channel;
4814                         handle = raid_device->handle;
4815                         sas_address = raid_device->wwid;
4816                 }
4817         }
4818
4819         if (ioc->logging_level & MPT_DEBUG_TASK_SET_FULL)
4820                 starget_printk(KERN_DEBUG, sas_device->starget, "task set "
4821                     "full: handle(0x%04x), sas_addr(0x%016llx), depth(%d)\n",
4822                     handle, (unsigned long long)sas_address, current_depth);
4823
4824         shost_for_each_device(sdev, ioc->shost) {
4825                 if (sdev->id == id && sdev->channel == channel) {
4826                         if (current_depth > sdev->queue_depth) {
4827                                 if (ioc->logging_level &
4828                                     MPT_DEBUG_TASK_SET_FULL)
4829                                         sdev_printk(KERN_INFO, sdev, "strange "
4830                                             "observation, the queue depth is"
4831                                             " (%d) meanwhile fw queue depth "
4832                                             "is (%d)\n", sdev->queue_depth,
4833                                             current_depth);
4834                                 continue;
4835                         }
4836                         depth = scsi_track_queue_full(sdev,
4837                             current_depth - 1);
4838                         if (depth > 0)
4839                                 sdev_printk(KERN_INFO, sdev, "Queue depth "
4840                                     "reduced to (%d)\n", depth);
4841                         else if (depth < 0)
4842                                 sdev_printk(KERN_INFO, sdev, "Tagged Command "
4843                                     "Queueing is being disabled\n");
4844                         else if (depth == 0)
4845                                 if (ioc->logging_level &
4846                                      MPT_DEBUG_TASK_SET_FULL)
4847                                         sdev_printk(KERN_INFO, sdev,
4848                                              "Queue depth not changed yet\n");
4849                 }
4850         }
4851 }
4852
4853 /**
4854  * _scsih_mark_responding_sas_device - mark a sas_devices as responding
4855  * @ioc: per adapter object
4856  * @sas_address: sas address
4857  * @slot: enclosure slot id
4858  * @handle: device handle
4859  *
4860  * After host reset, find out whether devices are still responding.
4861  * Used in _scsi_remove_unresponsive_sas_devices.
4862  *
4863  * Return nothing.
4864  */
4865 static void
4866 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
4867     u16 slot, u16 handle)
4868 {
4869         struct MPT2SAS_TARGET *sas_target_priv_data;
4870         struct scsi_target *starget;
4871         struct _sas_device *sas_device;
4872         unsigned long flags;
4873
4874         spin_lock_irqsave(&ioc->sas_device_lock, flags);
4875         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
4876                 if (sas_device->sas_address == sas_address &&
4877                     sas_device->slot == slot && sas_device->starget) {
4878                         sas_device->responding = 1;
4879                         starget_printk(KERN_INFO, sas_device->starget,
4880                             "handle(0x%04x), sas_addr(0x%016llx), enclosure "
4881                             "logical id(0x%016llx), slot(%d)\n", handle,
4882                             (unsigned long long)sas_device->sas_address,
4883                             (unsigned long long)
4884                             sas_device->enclosure_logical_id,
4885                             sas_device->slot);
4886                         if (sas_device->handle == handle)
4887                                 goto out;
4888                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
4889                             sas_device->handle);
4890                         sas_device->handle = handle;
4891                         starget = sas_device->starget;
4892                         sas_target_priv_data = starget->hostdata;
4893                         sas_target_priv_data->handle = handle;
4894                         goto out;
4895                 }
4896         }
4897  out:
4898         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
4899 }
4900
4901 /**
4902  * _scsih_search_responding_sas_devices -
4903  * @ioc: per adapter object
4904  *
4905  * After host reset, find out whether devices are still responding.
4906  * If not remove.
4907  *
4908  * Return nothing.
4909  */
4910 static void
4911 _scsih_search_responding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
4912 {
4913         Mpi2SasDevicePage0_t sas_device_pg0;
4914         Mpi2ConfigReply_t mpi_reply;
4915         u16 ioc_status;
4916         __le64 sas_address;
4917         u16 handle;
4918         u32 device_info;
4919         u16 slot;
4920
4921         printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
4922
4923         if (list_empty(&ioc->sas_device_list))
4924                 return;
4925
4926         handle = 0xFFFF;
4927         while (!(mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
4928             &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE,
4929             handle))) {
4930                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4931                     MPI2_IOCSTATUS_MASK;
4932                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
4933                         break;
4934                 handle = le16_to_cpu(sas_device_pg0.DevHandle);
4935                 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
4936                 if (!(_scsih_is_end_device(device_info)))
4937                         continue;
4938                 sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
4939                 slot = le16_to_cpu(sas_device_pg0.Slot);
4940                 _scsih_mark_responding_sas_device(ioc, sas_address, slot,
4941                     handle);
4942         }
4943 }
4944
4945 /**
4946  * _scsih_mark_responding_raid_device - mark a raid_device as responding
4947  * @ioc: per adapter object
4948  * @wwid: world wide identifier for raid volume
4949  * @handle: device handle
4950  *
4951  * After host reset, find out whether devices are still responding.
4952  * Used in _scsi_remove_unresponsive_raid_devices.
4953  *
4954  * Return nothing.
4955  */
4956 static void
4957 _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
4958     u16 handle)
4959 {
4960         struct MPT2SAS_TARGET *sas_target_priv_data;
4961         struct scsi_target *starget;
4962         struct _raid_device *raid_device;
4963         unsigned long flags;
4964
4965         spin_lock_irqsave(&ioc->raid_device_lock, flags);
4966         list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
4967                 if (raid_device->wwid == wwid && raid_device->starget) {
4968                         raid_device->responding = 1;
4969                         starget_printk(KERN_INFO, raid_device->starget,
4970                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
4971                             (unsigned long long)raid_device->wwid);
4972                         if (raid_device->handle == handle)
4973                                 goto out;
4974                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
4975                             raid_device->handle);
4976                         raid_device->handle = handle;
4977                         starget = raid_device->starget;
4978                         sas_target_priv_data = starget->hostdata;
4979                         sas_target_priv_data->handle = handle;
4980                         goto out;
4981                 }
4982         }
4983  out:
4984         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
4985 }
4986
4987 /**
4988  * _scsih_search_responding_raid_devices -
4989  * @ioc: per adapter object
4990  *
4991  * After host reset, find out whether devices are still responding.
4992  * If not remove.
4993  *
4994  * Return nothing.
4995  */
4996 static void
4997 _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
4998 {
4999         Mpi2RaidVolPage1_t volume_pg1;
5000         Mpi2ConfigReply_t mpi_reply;
5001         u16 ioc_status;
5002         u16 handle;
5003
5004         printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
5005
5006         if (list_empty(&ioc->raid_device_list))
5007                 return;
5008
5009         handle = 0xFFFF;
5010         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
5011             &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
5012                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5013                     MPI2_IOCSTATUS_MASK;
5014                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
5015                         break;
5016                 handle = le16_to_cpu(volume_pg1.DevHandle);
5017                 _scsih_mark_responding_raid_device(ioc,
5018                     le64_to_cpu(volume_pg1.WWID), handle);
5019         }
5020 }
5021
5022 /**
5023  * _scsih_mark_responding_expander - mark a expander as responding
5024  * @ioc: per adapter object
5025  * @sas_address: sas address
5026  * @handle:
5027  *
5028  * After host reset, find out whether devices are still responding.
5029  * Used in _scsi_remove_unresponsive_expanders.
5030  *
5031  * Return nothing.
5032  */
5033 static void
5034 _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
5035      u16 handle)
5036 {
5037         struct _sas_node *sas_expander;
5038         unsigned long flags;
5039
5040         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5041         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
5042                 if (sas_expander->sas_address == sas_address) {
5043                         sas_expander->responding = 1;
5044                         if (sas_expander->handle != handle) {
5045                                 printk(KERN_INFO "old handle(0x%04x)\n",
5046                                     sas_expander->handle);
5047                                 sas_expander->handle = handle;
5048                         }
5049                         goto out;
5050                 }
5051         }
5052  out:
5053         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5054 }
5055
5056 /**
5057  * _scsih_search_responding_expanders -
5058  * @ioc: per adapter object
5059  *
5060  * After host reset, find out whether devices are still responding.
5061  * If not remove.
5062  *
5063  * Return nothing.
5064  */
5065 static void
5066 _scsih_search_responding_expanders(struct MPT2SAS_ADAPTER *ioc)
5067 {
5068         Mpi2ExpanderPage0_t expander_pg0;
5069         Mpi2ConfigReply_t mpi_reply;
5070         u16 ioc_status;
5071         __le64 sas_address;
5072         u16 handle;
5073
5074         printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, __func__);
5075
5076         if (list_empty(&ioc->sas_expander_list))
5077                 return;
5078
5079         handle = 0xFFFF;
5080         while (!(mpt2sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
5081             MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) {
5082
5083                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
5084                     MPI2_IOCSTATUS_MASK;
5085                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
5086                         break;
5087
5088                 handle = le16_to_cpu(expander_pg0.DevHandle);
5089                 sas_address = le64_to_cpu(expander_pg0.SASAddress);
5090                 printk(KERN_INFO "\texpander present: handle(0x%04x), "
5091                     "sas_addr(0x%016llx)\n", handle,
5092                     (unsigned long long)sas_address);
5093                 _scsih_mark_responding_expander(ioc, sas_address, handle);
5094         }
5095
5096 }
5097
5098 /**
5099  * _scsih_remove_unresponding_devices - removing unresponding devices
5100  * @ioc: per adapter object
5101  *
5102  * Return nothing.
5103  */
5104 static void
5105 _scsih_remove_unresponding_devices(struct MPT2SAS_ADAPTER *ioc)
5106 {
5107         struct _sas_device *sas_device, *sas_device_next;
5108         struct _sas_node *sas_expander, *sas_expander_next;
5109         struct _raid_device *raid_device, *raid_device_next;
5110         unsigned long flags;
5111
5112         _scsih_search_responding_sas_devices(ioc);
5113         _scsih_search_responding_raid_devices(ioc);
5114         _scsih_search_responding_expanders(ioc);
5115
5116         spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
5117         ioc->shost_recovery = 0;
5118         if (ioc->shost->shost_state == SHOST_RECOVERY) {
5119                 printk(MPT2SAS_INFO_FMT "putting controller into "
5120                     "SHOST_RUNNING\n", ioc->name);
5121                 scsi_host_set_state(ioc->shost, SHOST_RUNNING);
5122         }
5123         spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
5124
5125         list_for_each_entry_safe(sas_device, sas_device_next,
5126             &ioc->sas_device_list, list) {
5127                 if (sas_device->responding) {
5128                         sas_device->responding = 0;
5129                         continue;
5130                 }
5131                 if (sas_device->starget)
5132                         starget_printk(KERN_INFO, sas_device->starget,
5133                             "removing: handle(0x%04x), sas_addr(0x%016llx), "
5134                             "enclosure logical id(0x%016llx), slot(%d)\n",
5135                             sas_device->handle,
5136                             (unsigned long long)sas_device->sas_address,
5137                             (unsigned long long)
5138                             sas_device->enclosure_logical_id,
5139                             sas_device->slot);
5140                 _scsih_remove_device(ioc, sas_device->handle);
5141         }
5142
5143         list_for_each_entry_safe(raid_device, raid_device_next,
5144             &ioc->raid_device_list, list) {
5145                 if (raid_device->responding) {
5146                         raid_device->responding = 0;
5147                         continue;
5148                 }
5149                 if (raid_device->starget) {
5150                         starget_printk(KERN_INFO, raid_device->starget,
5151                             "removing: handle(0x%04x), wwid(0x%016llx)\n",
5152                               raid_device->handle,
5153                             (unsigned long long)raid_device->wwid);
5154                         scsi_remove_target(&raid_device->starget->dev);
5155                 }
5156                 _scsih_raid_device_remove(ioc, raid_device);
5157         }
5158
5159         list_for_each_entry_safe(sas_expander, sas_expander_next,
5160             &ioc->sas_expander_list, list) {
5161                 if (sas_expander->responding) {
5162                         sas_expander->responding = 0;
5163                         continue;
5164                 }
5165                 printk("\tremoving expander: handle(0x%04x), "
5166                     " sas_addr(0x%016llx)\n", sas_expander->handle,
5167                     (unsigned long long)sas_expander->sas_address);
5168                 _scsih_expander_remove(ioc, sas_expander->handle);
5169         }
5170 }
5171
5172 /**
5173  * _firmware_event_work - delayed task for processing firmware events
5174  * @ioc: per adapter object
5175  * @work: equal to the fw_event_work object
5176  * Context: user.
5177  *
5178  * Return nothing.
5179  */
5180 static void
5181 _firmware_event_work(struct work_struct *work)
5182 {
5183         struct fw_event_work *fw_event = container_of(work,
5184             struct fw_event_work, work);
5185         unsigned long flags;
5186         struct MPT2SAS_ADAPTER *ioc = fw_event->ioc;
5187
5188         /* This is invoked by calling _scsih_queue_rescan(). */
5189         if (fw_event->event == MPT2SAS_RESCAN_AFTER_HOST_RESET) {
5190                 _scsih_fw_event_free(ioc, fw_event);
5191                 _scsih_sas_host_refresh(ioc, 1);
5192                 _scsih_remove_unresponding_devices(ioc);
5193                 return;
5194         }
5195
5196         /* the queue is being flushed so ignore this event */
5197         spin_lock_irqsave(&ioc->fw_event_lock, flags);
5198         if (ioc->fw_events_off || ioc->remove_host) {
5199                 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5200                 _scsih_fw_event_free(ioc, fw_event);
5201                 return;
5202         }
5203         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5204
5205         spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
5206         if (ioc->shost_recovery) {
5207                 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
5208                 _scsih_fw_event_requeue(ioc, fw_event, 1000);
5209                 return;
5210         }
5211         spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
5212
5213         switch (fw_event->event) {
5214         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
5215                 _scsih_sas_topology_change_event(ioc, fw_event->VF_ID,
5216                     fw_event->event_data, fw_event);
5217                 break;
5218         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
5219                 _scsih_sas_device_status_change_event(ioc, fw_event->VF_ID,
5220                     fw_event->event_data);
5221                 break;
5222         case MPI2_EVENT_SAS_DISCOVERY:
5223                 _scsih_sas_discovery_event(ioc, fw_event->VF_ID,
5224                     fw_event->event_data);
5225                 break;
5226         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
5227                 _scsih_sas_broadcast_primative_event(ioc, fw_event->VF_ID,
5228                     fw_event->event_data);
5229                 break;
5230         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
5231                 _scsih_sas_enclosure_dev_status_change_event(ioc,
5232                     fw_event->VF_ID, fw_event->event_data);
5233                 break;
5234         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
5235                 _scsih_sas_ir_config_change_event(ioc, fw_event->VF_ID,
5236                     fw_event->event_data);
5237                 break;
5238         case MPI2_EVENT_IR_VOLUME:
5239                 _scsih_sas_ir_volume_event(ioc, fw_event->VF_ID,
5240                     fw_event->event_data);
5241                 break;
5242         case MPI2_EVENT_IR_PHYSICAL_DISK:
5243                 _scsih_sas_ir_physical_disk_event(ioc, fw_event->VF_ID,
5244                     fw_event->event_data);
5245                 break;
5246         case MPI2_EVENT_IR_OPERATION_STATUS:
5247                 _scsih_sas_ir_operation_status_event(ioc, fw_event->VF_ID,
5248                     fw_event->event_data);
5249                 break;
5250         case MPI2_EVENT_TASK_SET_FULL:
5251                 _scsih_task_set_full(ioc, fw_event->VF_ID,
5252                     fw_event->event_data);
5253                 break;
5254         }
5255         _scsih_fw_event_free(ioc, fw_event);
5256 }
5257
5258 /**
5259  * mpt2sas_scsih_event_callback - firmware event handler (called at ISR time)
5260  * @ioc: per adapter object
5261  * @VF_ID: virtual function id
5262  * @reply: reply message frame(lower 32bit addr)
5263  * Context: interrupt.
5264  *
5265  * This function merely adds a new work task into ioc->firmware_event_thread.
5266  * The tasks are worked from _firmware_event_work in user context.
5267  *
5268  * Return nothing.
5269  */
5270 void
5271 mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, u32 reply)
5272 {
5273         struct fw_event_work *fw_event;
5274         Mpi2EventNotificationReply_t *mpi_reply;
5275         unsigned long flags;
5276         u16 event;
5277
5278         /* events turned off due to host reset or driver unloading */
5279         spin_lock_irqsave(&ioc->fw_event_lock, flags);
5280         if (ioc->fw_events_off || ioc->remove_host) {
5281                 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5282                 return;
5283         }
5284         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5285
5286         mpi_reply =  mpt2sas_base_get_reply_virt_addr(ioc, reply);
5287         event = le16_to_cpu(mpi_reply->Event);
5288
5289         switch (event) {
5290         /* handle these */
5291         case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:
5292         {
5293                 Mpi2EventDataSasBroadcastPrimitive_t *baen_data =
5294                     (Mpi2EventDataSasBroadcastPrimitive_t *)
5295                     mpi_reply->EventData;
5296
5297                 if (baen_data->Primitive !=
5298                     MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT ||
5299                     ioc->broadcast_aen_busy)
5300                         return;
5301                 ioc->broadcast_aen_busy = 1;
5302                 break;
5303         }
5304
5305         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
5306                 _scsih_check_topo_delete_events(ioc,
5307                     (Mpi2EventDataSasTopologyChangeList_t *)
5308                     mpi_reply->EventData);
5309                 break;
5310
5311         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
5312         case MPI2_EVENT_IR_OPERATION_STATUS:
5313         case MPI2_EVENT_SAS_DISCOVERY:
5314         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
5315         case MPI2_EVENT_IR_VOLUME:
5316         case MPI2_EVENT_IR_PHYSICAL_DISK:
5317         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
5318         case MPI2_EVENT_TASK_SET_FULL:
5319                 break;
5320
5321         default: /* ignore the rest */
5322                 return;
5323         }
5324
5325         fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
5326         if (!fw_event) {
5327                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5328                     ioc->name, __FILE__, __LINE__, __func__);
5329                 return;
5330         }
5331         fw_event->event_data =
5332             kzalloc(mpi_reply->EventDataLength*4, GFP_ATOMIC);
5333         if (!fw_event->event_data) {
5334                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5335                     ioc->name, __FILE__, __LINE__, __func__);
5336                 kfree(fw_event);
5337                 return;
5338         }
5339
5340         memcpy(fw_event->event_data, mpi_reply->EventData,
5341             mpi_reply->EventDataLength*4);
5342         fw_event->ioc = ioc;
5343         fw_event->VF_ID = VF_ID;
5344         fw_event->event = event;
5345         _scsih_fw_event_add(ioc, fw_event);
5346 }
5347
5348 /* shost template */
5349 static struct scsi_host_template scsih_driver_template = {
5350         .module                         = THIS_MODULE,
5351         .name                           = "Fusion MPT SAS Host",
5352         .proc_name                      = MPT2SAS_DRIVER_NAME,
5353         .queuecommand                   = _scsih_qcmd,
5354         .target_alloc                   = _scsih_target_alloc,
5355         .slave_alloc                    = _scsih_slave_alloc,
5356         .slave_configure                = _scsih_slave_configure,
5357         .target_destroy                 = _scsih_target_destroy,
5358         .slave_destroy                  = _scsih_slave_destroy,
5359         .change_queue_depth             = _scsih_change_queue_depth,
5360         .change_queue_type              = _scsih_change_queue_type,
5361         .eh_abort_handler               = _scsih_abort,
5362         .eh_device_reset_handler        = _scsih_dev_reset,
5363         .eh_target_reset_handler        = _scsih_target_reset,
5364         .eh_host_reset_handler          = _scsih_host_reset,
5365         .bios_param                     = _scsih_bios_param,
5366         .can_queue                      = 1,
5367         .this_id                        = -1,
5368         .sg_tablesize                   = MPT2SAS_SG_DEPTH,
5369         .max_sectors                    = 8192,
5370         .cmd_per_lun                    = 7,
5371         .use_clustering                 = ENABLE_CLUSTERING,
5372         .shost_attrs                    = mpt2sas_host_attrs,
5373         .sdev_attrs                     = mpt2sas_dev_attrs,
5374 };
5375
5376 /**
5377  * _scsih_expander_node_remove - removing expander device from list.
5378  * @ioc: per adapter object
5379  * @sas_expander: the sas_device object
5380  * Context: Calling function should acquire ioc->sas_node_lock.
5381  *
5382  * Removing object and freeing associated memory from the
5383  * ioc->sas_expander_list.
5384  *
5385  * Return nothing.
5386  */
5387 static void
5388 _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
5389     struct _sas_node *sas_expander)
5390 {
5391         struct _sas_port *mpt2sas_port;
5392         struct _sas_device *sas_device;
5393         struct _sas_node *expander_sibling;
5394         unsigned long flags;
5395
5396         if (!sas_expander)
5397                 return;
5398
5399         /* remove sibling ports attached to this expander */
5400  retry_device_search:
5401         list_for_each_entry(mpt2sas_port,
5402            &sas_expander->sas_port_list, port_list) {
5403                 if (mpt2sas_port->remote_identify.device_type ==
5404                     SAS_END_DEVICE) {
5405                         spin_lock_irqsave(&ioc->sas_device_lock, flags);
5406                         sas_device =
5407                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5408                            mpt2sas_port->remote_identify.sas_address);
5409                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5410                         if (!sas_device)
5411                                 continue;
5412                         _scsih_remove_device(ioc, sas_device->handle);
5413                         goto retry_device_search;
5414                 }
5415         }
5416
5417  retry_expander_search:
5418         list_for_each_entry(mpt2sas_port,
5419            &sas_expander->sas_port_list, port_list) {
5420
5421                 if (mpt2sas_port->remote_identify.device_type ==
5422                     MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
5423                     mpt2sas_port->remote_identify.device_type ==
5424                     MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
5425
5426                         spin_lock_irqsave(&ioc->sas_node_lock, flags);
5427                         expander_sibling =
5428                             mpt2sas_scsih_expander_find_by_sas_address(
5429                             ioc, mpt2sas_port->remote_identify.sas_address);
5430                         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
5431                         if (!expander_sibling)
5432                                 continue;
5433                         _scsih_expander_remove(ioc, expander_sibling->handle);
5434                         goto retry_expander_search;
5435                 }
5436         }
5437
5438         mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
5439             sas_expander->parent_handle);
5440
5441         printk(MPT2SAS_INFO_FMT "expander_remove: handle"
5442            "(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
5443             sas_expander->handle, (unsigned long long)
5444             sas_expander->sas_address);
5445
5446         list_del(&sas_expander->list);
5447         kfree(sas_expander->phy);
5448         kfree(sas_expander);
5449 }
5450
5451 /**
5452  * _scsih_remove - detach and remove add host
5453  * @pdev: PCI device struct
5454  *
5455  * Return nothing.
5456  */
5457 static void __devexit
5458 _scsih_remove(struct pci_dev *pdev)
5459 {
5460         struct Scsi_Host *shost = pci_get_drvdata(pdev);
5461         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
5462         struct _sas_port *mpt2sas_port;
5463         struct _sas_device *sas_device;
5464         struct _sas_node *expander_sibling;
5465         struct workqueue_struct *wq;
5466         unsigned long flags;
5467
5468         ioc->remove_host = 1;
5469         _scsih_fw_event_off(ioc);
5470
5471         spin_lock_irqsave(&ioc->fw_event_lock, flags);
5472         wq = ioc->firmware_event_thread;
5473         ioc->firmware_event_thread = NULL;
5474         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
5475         if (wq)
5476                 destroy_workqueue(wq);
5477
5478         /* free ports attached to the sas_host */
5479  retry_again:
5480         list_for_each_entry(mpt2sas_port,
5481            &ioc->sas_hba.sas_port_list, port_list) {
5482                 if (mpt2sas_port->remote_identify.device_type ==
5483                     SAS_END_DEVICE) {
5484                         sas_device =
5485                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
5486                            mpt2sas_port->remote_identify.sas_address);
5487                         if (sas_device) {
5488                                 _scsih_remove_device(ioc, sas_device->handle);
5489                                 goto retry_again;
5490                         }
5491                 } else {
5492                         expander_sibling =
5493                             mpt2sas_scsih_expander_find_by_sas_address(ioc,
5494                             mpt2sas_port->remote_identify.sas_address);
5495                         if (expander_sibling) {
5496                                 _scsih_expander_remove(ioc,
5497                                     expander_sibling->handle);
5498                                 goto retry_again;
5499                         }
5500                 }
5501         }
5502
5503         /* free phys attached to the sas_host */
5504         if (ioc->sas_hba.num_phys) {
5505                 kfree(ioc->sas_hba.phy);
5506                 ioc->sas_hba.phy = NULL;
5507                 ioc->sas_hba.num_phys = 0;
5508         }
5509
5510         sas_remove_host(shost);
5511         mpt2sas_base_detach(ioc);
5512         list_del(&ioc->list);
5513         scsi_remove_host(shost);
5514         scsi_host_put(shost);
5515 }
5516
5517 /**
5518  * _scsih_probe_boot_devices - reports 1st device
5519  * @ioc: per adapter object
5520  *
5521  * If specified in bios page 2, this routine reports the 1st
5522  * device scsi-ml or sas transport for persistent boot device
5523  * purposes.  Please refer to function _scsih_determine_boot_device()
5524  */
5525 static void
5526 _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
5527 {
5528         u8 is_raid;
5529         void *device;
5530         struct _sas_device *sas_device;
5531         struct _raid_device *raid_device;
5532         u16 handle, parent_handle;
5533         u64 sas_address;
5534         unsigned long flags;
5535         int rc;
5536
5537         device = NULL;
5538         if (ioc->req_boot_device.device) {
5539                 device =  ioc->req_boot_device.device;
5540                 is_raid = ioc->req_boot_device.is_raid;
5541         } else if (ioc->req_alt_boot_device.device) {
5542                 device =  ioc->req_alt_boot_device.device;
5543                 is_raid = ioc->req_alt_boot_device.is_raid;
5544         } else if (ioc->current_boot_device.device) {
5545                 device =  ioc->current_boot_device.device;
5546                 is_raid = ioc->current_boot_device.is_raid;
5547         }
5548
5549         if (!device)
5550                 return;
5551
5552         if (is_raid) {
5553                 raid_device = device;
5554                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
5555                     raid_device->id, 0);
5556                 if (rc)
5557                         _scsih_raid_device_remove(ioc, raid_device);
5558         } else {
5559                 sas_device = device;
5560                 handle = sas_device->handle;
5561                 parent_handle = sas_device->parent_handle;
5562                 sas_address = sas_device->sas_address;
5563                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5564                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
5565                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5566                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
5567                     sas_device->parent_handle)) {
5568                         _scsih_sas_device_remove(ioc, sas_device);
5569                 } else if (!sas_device->starget) {
5570                         mpt2sas_transport_port_remove(ioc, sas_address,
5571                             parent_handle);
5572                         _scsih_sas_device_remove(ioc, sas_device);
5573                 }
5574         }
5575 }
5576
5577 /**
5578  * _scsih_probe_raid - reporting raid volumes to scsi-ml
5579  * @ioc: per adapter object
5580  *
5581  * Called during initial loading of the driver.
5582  */
5583 static void
5584 _scsih_probe_raid(struct MPT2SAS_ADAPTER *ioc)
5585 {
5586         struct _raid_device *raid_device, *raid_next;
5587         int rc;
5588
5589         list_for_each_entry_safe(raid_device, raid_next,
5590             &ioc->raid_device_list, list) {
5591                 if (raid_device->starget)
5592                         continue;
5593                 rc = scsi_add_device(ioc->shost, RAID_CHANNEL,
5594                     raid_device->id, 0);
5595                 if (rc)
5596                         _scsih_raid_device_remove(ioc, raid_device);
5597         }
5598 }
5599
5600 /**
5601  * _scsih_probe_sas - reporting raid volumes to sas transport
5602  * @ioc: per adapter object
5603  *
5604  * Called during initial loading of the driver.
5605  */
5606 static void
5607 _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
5608 {
5609         struct _sas_device *sas_device, *next;
5610         unsigned long flags;
5611         u16 handle, parent_handle;
5612         u64 sas_address;
5613
5614         /* SAS Device List */
5615         list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
5616             list) {
5617                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
5618                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
5619                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
5620
5621                 handle = sas_device->handle;
5622                 parent_handle = sas_device->parent_handle;
5623                 sas_address = sas_device->sas_address;
5624                 if (!mpt2sas_transport_port_add(ioc, handle, parent_handle)) {
5625                         _scsih_sas_device_remove(ioc, sas_device);
5626                 } else if (!sas_device->starget) {
5627                         mpt2sas_transport_port_remove(ioc, sas_address,
5628                             parent_handle);
5629                         _scsih_sas_device_remove(ioc, sas_device);
5630                 }
5631         }
5632 }
5633
5634 /**
5635  * _scsih_probe_devices - probing for devices
5636  * @ioc: per adapter object
5637  *
5638  * Called during initial loading of the driver.
5639  */
5640 static void
5641 _scsih_probe_devices(struct MPT2SAS_ADAPTER *ioc)
5642 {
5643         u16 volume_mapping_flags =
5644             le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) &
5645             MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE;
5646
5647         if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR))
5648                 return;  /* return when IOC doesn't support initiator mode */
5649
5650         _scsih_probe_boot_devices(ioc);
5651
5652         if (ioc->ir_firmware) {
5653                 if ((volume_mapping_flags &
5654                      MPI2_IOCPAGE8_IRFLAGS_HIGH_VOLUME_MAPPING)) {
5655                         _scsih_probe_sas(ioc);
5656                         _scsih_probe_raid(ioc);
5657                 } else {
5658                         _scsih_probe_raid(ioc);
5659                         _scsih_probe_sas(ioc);
5660                 }
5661         } else
5662                 _scsih_probe_sas(ioc);
5663 }
5664
5665 /**
5666  * _scsih_probe - attach and add scsi host
5667  * @pdev: PCI device struct
5668  * @id: pci device id
5669  *
5670  * Returns 0 success, anything else error.
5671  */
5672 static int
5673 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5674 {
5675         struct MPT2SAS_ADAPTER *ioc;
5676         struct Scsi_Host *shost;
5677
5678         shost = scsi_host_alloc(&scsih_driver_template,
5679             sizeof(struct MPT2SAS_ADAPTER));
5680         if (!shost)
5681                 return -ENODEV;
5682
5683         /* init local params */
5684         ioc = shost_priv(shost);
5685         memset(ioc, 0, sizeof(struct MPT2SAS_ADAPTER));
5686         INIT_LIST_HEAD(&ioc->list);
5687         list_add_tail(&ioc->list, &mpt2sas_ioc_list);
5688         ioc->shost = shost;
5689         ioc->id = mpt_ids++;
5690         sprintf(ioc->name, "%s%d", MPT2SAS_DRIVER_NAME, ioc->id);
5691         ioc->pdev = pdev;
5692         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
5693         ioc->tm_cb_idx = tm_cb_idx;
5694         ioc->ctl_cb_idx = ctl_cb_idx;
5695         ioc->base_cb_idx = base_cb_idx;
5696         ioc->transport_cb_idx = transport_cb_idx;
5697         ioc->config_cb_idx = config_cb_idx;
5698         ioc->logging_level = logging_level;
5699         /* misc semaphores and spin locks */
5700         spin_lock_init(&ioc->ioc_reset_in_progress_lock);
5701         spin_lock_init(&ioc->scsi_lookup_lock);
5702         spin_lock_init(&ioc->sas_device_lock);
5703         spin_lock_init(&ioc->sas_node_lock);
5704         spin_lock_init(&ioc->fw_event_lock);
5705         spin_lock_init(&ioc->raid_device_lock);
5706
5707         INIT_LIST_HEAD(&ioc->sas_device_list);
5708         INIT_LIST_HEAD(&ioc->sas_device_init_list);
5709         INIT_LIST_HEAD(&ioc->sas_expander_list);
5710         INIT_LIST_HEAD(&ioc->fw_event_list);
5711         INIT_LIST_HEAD(&ioc->raid_device_list);
5712         INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list);
5713
5714         /* init shost parameters */
5715         shost->max_cmd_len = 16;
5716         shost->max_lun = max_lun;
5717         shost->transportt = mpt2sas_transport_template;
5718         shost->unique_id = ioc->id;
5719
5720         if ((scsi_add_host(shost, &pdev->dev))) {
5721                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5722                     ioc->name, __FILE__, __LINE__, __func__);
5723                 list_del(&ioc->list);
5724                 goto out_add_shost_fail;
5725         }
5726
5727         scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION
5728             | SHOST_DIF_TYPE3_PROTECTION);
5729
5730         /* event thread */
5731         snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name),
5732             "fw_event%d", ioc->id);
5733         ioc->firmware_event_thread = create_singlethread_workqueue(
5734             ioc->firmware_event_name);
5735         if (!ioc->firmware_event_thread) {
5736                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5737                     ioc->name, __FILE__, __LINE__, __func__);
5738                 goto out_thread_fail;
5739         }
5740
5741         ioc->wait_for_port_enable_to_complete = 1;
5742         if ((mpt2sas_base_attach(ioc))) {
5743                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
5744                     ioc->name, __FILE__, __LINE__, __func__);
5745                 goto out_attach_fail;
5746         }
5747
5748         ioc->wait_for_port_enable_to_complete = 0;
5749         _scsih_probe_devices(ioc);
5750         return 0;
5751
5752  out_attach_fail:
5753         destroy_workqueue(ioc->firmware_event_thread);
5754  out_thread_fail:
5755         list_del(&ioc->list);
5756         scsi_remove_host(shost);
5757  out_add_shost_fail:
5758         return -ENODEV;
5759 }
5760
5761 #ifdef CONFIG_PM
5762 /**
5763  * _scsih_suspend - power management suspend main entry point
5764  * @pdev: PCI device struct
5765  * @state: PM state change to (usually PCI_D3)
5766  *
5767  * Returns 0 success, anything else error.
5768  */
5769 static int
5770 _scsih_suspend(struct pci_dev *pdev, pm_message_t state)
5771 {
5772         struct Scsi_Host *shost = pci_get_drvdata(pdev);
5773         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
5774         u32 device_state;
5775
5776         flush_scheduled_work();
5777         scsi_block_requests(shost);
5778         device_state = pci_choose_state(pdev, state);
5779         printk(MPT2SAS_INFO_FMT "pdev=0x%p, slot=%s, entering "
5780             "operating state [D%d]\n", ioc->name, pdev,
5781             pci_name(pdev), device_state);
5782
5783         mpt2sas_base_free_resources(ioc);
5784         pci_save_state(pdev);
5785         pci_disable_device(pdev);
5786         pci_set_power_state(pdev, device_state);
5787         return 0;
5788 }
5789
5790 /**
5791  * _scsih_resume - power management resume main entry point
5792  * @pdev: PCI device struct
5793  *
5794  * Returns 0 success, anything else error.
5795  */
5796 static int
5797 _scsih_resume(struct pci_dev *pdev)
5798 {
5799         struct Scsi_Host *shost = pci_get_drvdata(pdev);
5800         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
5801         u32 device_state = pdev->current_state;
5802         int r;
5803
5804         printk(MPT2SAS_INFO_FMT "pdev=0x%p, slot=%s, previous "
5805             "operating state [D%d]\n", ioc->name, pdev,
5806             pci_name(pdev), device_state);
5807
5808         pci_set_power_state(pdev, PCI_D0);
5809         pci_enable_wake(pdev, PCI_D0, 0);
5810         pci_restore_state(pdev);
5811         ioc->pdev = pdev;
5812         r = mpt2sas_base_map_resources(ioc);
5813         if (r)
5814                 return r;
5815
5816         mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET);
5817         scsi_unblock_requests(shost);
5818         return 0;
5819 }
5820 #endif /* CONFIG_PM */
5821
5822
5823 static struct pci_driver scsih_driver = {
5824         .name           = MPT2SAS_DRIVER_NAME,
5825         .id_table       = scsih_pci_table,
5826         .probe          = _scsih_probe,
5827         .remove         = __devexit_p(_scsih_remove),
5828 #ifdef CONFIG_PM
5829         .suspend        = _scsih_suspend,
5830         .resume         = _scsih_resume,
5831 #endif
5832 };
5833
5834
5835 /**
5836  * _scsih_init - main entry point for this driver.
5837  *
5838  * Returns 0 success, anything else error.
5839  */
5840 static int __init
5841 _scsih_init(void)
5842 {
5843         int error;
5844
5845         mpt_ids = 0;
5846         printk(KERN_INFO "%s version %s loaded\n", MPT2SAS_DRIVER_NAME,
5847             MPT2SAS_DRIVER_VERSION);
5848
5849         mpt2sas_transport_template =
5850             sas_attach_transport(&mpt2sas_transport_functions);
5851         if (!mpt2sas_transport_template)
5852                 return -ENODEV;
5853
5854         mpt2sas_base_initialize_callback_handler();
5855
5856          /* queuecommand callback hander */
5857         scsi_io_cb_idx = mpt2sas_base_register_callback_handler(_scsih_io_done);
5858
5859         /* task managment callback handler */
5860         tm_cb_idx = mpt2sas_base_register_callback_handler(_scsih_tm_done);
5861
5862         /* base internal commands callback handler */
5863         base_cb_idx = mpt2sas_base_register_callback_handler(mpt2sas_base_done);
5864
5865         /* transport internal commands callback handler */
5866         transport_cb_idx = mpt2sas_base_register_callback_handler(
5867             mpt2sas_transport_done);
5868
5869         /* configuration page API internal commands callback handler */
5870         config_cb_idx = mpt2sas_base_register_callback_handler(
5871             mpt2sas_config_done);
5872
5873         /* ctl module callback handler */
5874         ctl_cb_idx = mpt2sas_base_register_callback_handler(mpt2sas_ctl_done);
5875
5876         mpt2sas_ctl_init();
5877
5878         error = pci_register_driver(&scsih_driver);
5879         if (error)
5880                 sas_release_transport(mpt2sas_transport_template);
5881
5882         return error;
5883 }
5884
5885 /**
5886  * _scsih_exit - exit point for this driver (when it is a module).
5887  *
5888  * Returns 0 success, anything else error.
5889  */
5890 static void __exit
5891 _scsih_exit(void)
5892 {
5893         printk(KERN_INFO "mpt2sas version %s unloading\n",
5894             MPT2SAS_DRIVER_VERSION);
5895
5896         pci_unregister_driver(&scsih_driver);
5897
5898         sas_release_transport(mpt2sas_transport_template);
5899         mpt2sas_base_release_callback_handler(scsi_io_cb_idx);
5900         mpt2sas_base_release_callback_handler(tm_cb_idx);
5901         mpt2sas_base_release_callback_handler(base_cb_idx);
5902         mpt2sas_base_release_callback_handler(transport_cb_idx);
5903         mpt2sas_base_release_callback_handler(config_cb_idx);
5904         mpt2sas_base_release_callback_handler(ctl_cb_idx);
5905
5906         mpt2sas_ctl_exit();
5907 }
5908
5909 module_init(_scsih_init);
5910 module_exit(_scsih_exit);