SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/mpt2sas/mpt2sas_scsih.c

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