drivers/message/fusion/mptsas.c

   1 /*
   2  *  linux/drivers/message/fusion/mptsas.c
   3  *      For use with LSI PCI chip/adapter(s)
   4  *      running LSI Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2008 LSI Corporation
   7  *  (mailto:DL-MPTFusionLinux@lsi.com)
   8  */
   9 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  10 /*
  11     This program is free software; you can redistribute it and/or modify
  12     it under the terms of the GNU General Public License as published by
  13     the Free Software Foundation; version 2 of the License.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     NO WARRANTY
  21     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  22     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  23     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  24     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  25     solely responsible for determining the appropriateness of using and
  26     distributing the Program and assumes all risks associated with its
  27     exercise of rights under this Agreement, including but not limited to
  28     the risks and costs of program errors, damage to or loss of data,
  29     programs or equipment, and unavailability or interruption of operations.
  30
  31     DISCLAIMER OF LIABILITY
  32     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  33     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  35     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  36     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  37     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  38     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  39
  40     You should have received a copy of the GNU General Public License
  41     along with this program; if not, write to the Free Software
  42     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  43 */
  44 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  45
  46 #include <linux/module.h>
  47 #include <linux/kernel.h>
  48 #include <linux/slab.h>
  49 #include <linux/init.h>
  50 #include <linux/errno.h>
  51 #include <linux/jiffies.h>
  52 #include <linux/workqueue.h>
  53 #include <linux/delay.h>        /* for mdelay */
  54
  55 #include <scsi/scsi.h>
  56 #include <scsi/scsi_cmnd.h>
  57 #include <scsi/scsi_device.h>
  58 #include <scsi/scsi_host.h>
  59 #include <scsi/scsi_transport_sas.h>
  60 #include <scsi/scsi_transport.h>
  61 #include <scsi/scsi_dbg.h>
  62
  63 #include "mptbase.h"
  64 #include "mptscsih.h"
  65 #include "mptsas.h"
  66
  67
  68 #define my_NAME         "Fusion MPT SAS Host driver"
  69 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  70 #define MYNAM           "mptsas"
  71
  72 /*
  73  * Reserved channel for integrated raid
  74  */
  75 #define MPTSAS_RAID_CHANNEL     1
  76
  77 #define SAS_CONFIG_PAGE_TIMEOUT         30
  78 MODULE_AUTHOR(MODULEAUTHOR);
  79 MODULE_DESCRIPTION(my_NAME);
  80 MODULE_LICENSE("GPL");
  81 MODULE_VERSION(my_VERSION);
  82
  83 static int mpt_pt_clear;
  84 module_param(mpt_pt_clear, int, 0);
  85 MODULE_PARM_DESC(mpt_pt_clear,
  86                 " Clear persistency table: enable=1  "
  87                 "(default=MPTSCSIH_PT_CLEAR=0)");
  88
  89 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
  90 #define MPTSAS_MAX_LUN (16895)
  91 static int max_lun = MPTSAS_MAX_LUN;
  92 module_param(max_lun, int, 0);
  93 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
  94
  95 static u8       mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  96 static u8       mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  97 static u8       mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
  98 static u8       mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
  99 static u8       mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS;
 100
 101 static void mptsas_firmware_event_work(struct work_struct *work);
 102 static void mptsas_send_sas_event(struct fw_event_work *fw_event);
 103 static void mptsas_send_raid_event(struct fw_event_work *fw_event);
 104 static void mptsas_send_ir2_event(struct fw_event_work *fw_event);
 105 static void mptsas_parse_device_info(struct sas_identify *identify,
 106                 struct mptsas_devinfo *device_info);
 107 static inline void mptsas_set_rphy(MPT_ADAPTER *ioc,
 108                 struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy);
 109 static struct mptsas_phyinfo    *mptsas_find_phyinfo_by_sas_address
 110                 (MPT_ADAPTER *ioc, u64 sas_address);
 111 static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
 112         struct mptsas_devinfo *device_info, u32 form, u32 form_specific);
 113 static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc,
 114         struct mptsas_enclosure *enclosure, u32 form, u32 form_specific);
 115 static int mptsas_add_end_device(MPT_ADAPTER *ioc,
 116         struct mptsas_phyinfo *phy_info);
 117 static void mptsas_del_end_device(MPT_ADAPTER *ioc,
 118         struct mptsas_phyinfo *phy_info);
 119 static void mptsas_send_link_status_event(struct fw_event_work *fw_event);
 120 static struct mptsas_portinfo   *mptsas_find_portinfo_by_sas_address
 121                 (MPT_ADAPTER *ioc, u64 sas_address);
 122 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
 123                 struct mptsas_portinfo *port_info, u8 force);
 124 static void mptsas_send_expander_event(struct fw_event_work *fw_event);
 125 static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
 126 static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
 127 static void mptsas_broadcast_primative_work(struct fw_event_work *fw_event);
 128 static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event);
 129 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id);
 130 void    mptsas_schedule_target_reset(void *ioc);
 131
 132 static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
 133                                         MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
 134 {
 135         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 136             "---- IO UNIT PAGE 0 ------------\n", ioc->name));
 137         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
 138             ioc->name, le16_to_cpu(phy_data->AttachedDeviceHandle)));
 139         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Controller Handle=0x%X\n",
 140             ioc->name, le16_to_cpu(phy_data->ControllerDevHandle)));
 141         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port=0x%X\n",
 142             ioc->name, phy_data->Port));
 143         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port Flags=0x%X\n",
 144             ioc->name, phy_data->PortFlags));
 145         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Flags=0x%X\n",
 146             ioc->name, phy_data->PhyFlags));
 147         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
 148             ioc->name, phy_data->NegotiatedLinkRate));
 149         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 150             "Controller PHY Device Info=0x%X\n", ioc->name,
 151             le32_to_cpu(phy_data->ControllerPhyDeviceInfo)));
 152         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DiscoveryStatus=0x%X\n\n",
 153             ioc->name, le32_to_cpu(phy_data->DiscoveryStatus)));
 154 }
 155
 156 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0)
 157 {
 158         __le64 sas_address;
 159
 160         memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
 161
 162         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 163             "---- SAS PHY PAGE 0 ------------\n", ioc->name));
 164         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 165             "Attached Device Handle=0x%X\n", ioc->name,
 166             le16_to_cpu(pg0->AttachedDevHandle)));
 167         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
 168             ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
 169         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 170             "Attached PHY Identifier=0x%X\n", ioc->name,
 171             pg0->AttachedPhyIdentifier));
 172         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Attached Device Info=0x%X\n",
 173             ioc->name, le32_to_cpu(pg0->AttachedDeviceInfo)));
 174         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
 175             ioc->name,  pg0->ProgrammedLinkRate));
 176         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Change Count=0x%X\n",
 177             ioc->name, pg0->ChangeCount));
 178         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Info=0x%X\n\n",
 179             ioc->name, le32_to_cpu(pg0->PhyInfo)));
 180 }
 181
 182 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1)
 183 {
 184         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 185             "---- SAS PHY PAGE 1 ------------\n", ioc->name));
 186         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Invalid Dword Count=0x%x\n",
 187             ioc->name,  pg1->InvalidDwordCount));
 188         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 189             "Running Disparity Error Count=0x%x\n", ioc->name,
 190             pg1->RunningDisparityErrorCount));
 191         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 192             "Loss Dword Synch Count=0x%x\n", ioc->name,
 193             pg1->LossDwordSynchCount));
 194         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 195             "PHY Reset Problem Count=0x%x\n\n", ioc->name,
 196             pg1->PhyResetProblemCount));
 197 }
 198
 199 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0)
 200 {
 201         __le64 sas_address;
 202
 203         memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
 204
 205         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 206             "---- SAS DEVICE PAGE 0 ---------\n", ioc->name));
 207         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
 208             ioc->name, le16_to_cpu(pg0->DevHandle)));
 209         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Handle=0x%X\n",
 210             ioc->name, le16_to_cpu(pg0->ParentDevHandle)));
 211         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Enclosure Handle=0x%X\n",
 212             ioc->name, le16_to_cpu(pg0->EnclosureHandle)));
 213         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Slot=0x%X\n",
 214             ioc->name, le16_to_cpu(pg0->Slot)));
 215         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
 216             ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
 217         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Target ID=0x%X\n",
 218             ioc->name, pg0->TargetID));
 219         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Bus=0x%X\n",
 220             ioc->name, pg0->Bus));
 221         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Phy Num=0x%X\n",
 222             ioc->name, pg0->PhyNum));
 223         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Access Status=0x%X\n",
 224             ioc->name, le16_to_cpu(pg0->AccessStatus)));
 225         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Device Info=0x%X\n",
 226             ioc->name, le32_to_cpu(pg0->DeviceInfo)));
 227         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Flags=0x%X\n",
 228             ioc->name, le16_to_cpu(pg0->Flags)));
 229         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n\n",
 230             ioc->name, pg0->PhysicalPort));
 231 }
 232
 233 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1)
 234 {
 235         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 236             "---- SAS EXPANDER PAGE 1 ------------\n", ioc->name));
 237         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n",
 238             ioc->name, pg1->PhysicalPort));
 239         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Identifier=0x%X\n",
 240             ioc->name, pg1->PhyIdentifier));
 241         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
 242             ioc->name, pg1->NegotiatedLinkRate));
 243         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
 244             ioc->name, pg1->ProgrammedLinkRate));
 245         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hardware Link Rate=0x%X\n",
 246             ioc->name, pg1->HwLinkRate));
 247         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Owner Device Handle=0x%X\n",
 248             ioc->name, le16_to_cpu(pg1->OwnerDevHandle)));
 249         dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 250             "Attached Device Handle=0x%X\n\n", ioc->name,
 251             le16_to_cpu(pg1->AttachedDevHandle)));
 252 }
 253
 254 /* inhibit sas firmware event handling */
 255 static void
 256 mptsas_fw_event_off(MPT_ADAPTER *ioc)
 257 {
 258         unsigned long flags;
 259
 260         spin_lock_irqsave(&ioc->fw_event_lock, flags);
 261         ioc->fw_events_off = 1;
 262         ioc->sas_discovery_quiesce_io = 0;
 263         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
 264
 265 }
 266
 267 /* enable sas firmware event handling */
 268 static void
 269 mptsas_fw_event_on(MPT_ADAPTER *ioc)
 270 {
 271         unsigned long flags;
 272
 273         spin_lock_irqsave(&ioc->fw_event_lock, flags);
 274         ioc->fw_events_off = 0;
 275         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
 276 }
 277
 278 /* queue a sas firmware event */
 279 static void
 280 mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
 281     unsigned long delay)
 282 {
 283         unsigned long flags;
 284
 285         spin_lock_irqsave(&ioc->fw_event_lock, flags);
 286         list_add_tail(&fw_event->list, &ioc->fw_event_list);
 287         INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work);
 288         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: add (fw_event=0x%p)\n",
 289             ioc->name, __func__, fw_event));
 290         queue_delayed_work(ioc->fw_event_q, &fw_event->work,
 291             delay);
 292         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
 293 }
 294
 295 /* requeue a sas firmware event */
 296 static void
 297 mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
 298     unsigned long delay)
 299 {
 300         unsigned long flags;
 301         spin_lock_irqsave(&ioc->fw_event_lock, flags);
 302         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: reschedule task "
 303             "(fw_event=0x%p)\n", ioc->name, __func__, fw_event));
 304         fw_event->retries++;
 305         queue_delayed_work(ioc->fw_event_q, &fw_event->work,
 306             msecs_to_jiffies(delay));
 307         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
 308 }
 309
 310 /* free memory assoicated to a sas firmware event */
 311 static void
 312 mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event)
 313 {
 314         unsigned long flags;
 315
 316         spin_lock_irqsave(&ioc->fw_event_lock, flags);
 317         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: kfree (fw_event=0x%p)\n",
 318             ioc->name, __func__, fw_event));
 319         list_del(&fw_event->list);
 320         kfree(fw_event);
 321         spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
 322 }
 323
 324 /* walk the firmware event queue, and either stop or wait for
 325  * outstanding events to complete */
 326 static void
 327 mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc)
 328 {
 329         struct fw_event_work *fw_event, *next;
 330         struct mptsas_target_reset_event *target_reset_list, *n;
 331         MPT_SCSI_HOST   *hd = shost_priv(ioc->sh);
 332
 333         /* flush the target_reset_list */
 334         if (!list_empty(&hd->target_reset_list)) {
 335                 list_for_each_entry_safe(target_reset_list, n,
 336                     &hd->target_reset_list, list) {
 337                         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 338                             "%s: removing target reset for id=%d\n",
 339                             ioc->name, __func__,
 340                            target_reset_list->sas_event_data.TargetID));
 341                         list_del(&target_reset_list->list);
 342                         kfree(target_reset_list);
 343                 }
 344         }
 345
 346         if (list_empty(&ioc->fw_event_list) ||
 347              !ioc->fw_event_q || in_interrupt())
 348                 return;
 349
 350         list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
 351                 if (cancel_delayed_work(&fw_event->work))
 352                         mptsas_free_fw_event(ioc, fw_event);
 353         }
 354 }
 355
 356
 357 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
 358 {
 359         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 360         return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
 361 }
 362
 363 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
 364 {
 365         struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
 366         return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
 367 }
 368
 369 /*
 370  * mptsas_find_portinfo_by_handle
 371  *
 372  * This function should be called with the sas_topology_mutex already held
 373  */
 374 static struct mptsas_portinfo *
 375 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
 376 {
 377         struct mptsas_portinfo *port_info, *rc=NULL;
 378         int i;
 379
 380         list_for_each_entry(port_info, &ioc->sas_topology, list)
 381                 for (i = 0; i < port_info->num_phys; i++)
 382                         if (port_info->phy_info[i].identify.handle == handle) {
 383                                 rc = port_info;
 384                                 goto out;
 385                         }
 386  out:
 387         return rc;
 388 }
 389
 390 /**
 391  *      mptsas_find_portinfo_by_sas_address -
 392  *      @ioc: Pointer to MPT_ADAPTER structure
 393  *      @handle:
 394  *
 395  *      This function should be called with the sas_topology_mutex already held
 396  *
 397  **/
 398 static struct mptsas_portinfo *
 399 mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
 400 {
 401         struct mptsas_portinfo *port_info, *rc = NULL;
 402         int i;
 403
 404         if (sas_address >= ioc->hba_port_sas_addr &&
 405             sas_address < (ioc->hba_port_sas_addr +
 406             ioc->hba_port_num_phy))
 407                 return ioc->hba_port_info;
 408
 409         mutex_lock(&ioc->sas_topology_mutex);
 410         list_for_each_entry(port_info, &ioc->sas_topology, list)
 411                 for (i = 0; i < port_info->num_phys; i++)
 412                         if (port_info->phy_info[i].identify.sas_address ==
 413                             sas_address) {
 414                                 rc = port_info;
 415                                 goto out;
 416                         }
 417  out:
 418         mutex_unlock(&ioc->sas_topology_mutex);
 419         return rc;
 420 }
 421
 422 /*
 423  * Returns true if there is a scsi end device
 424  */
 425 static inline int
 426 mptsas_is_end_device(struct mptsas_devinfo * attached)
 427 {
 428         if ((attached->sas_address) &&
 429             (attached->device_info &
 430             MPI_SAS_DEVICE_INFO_END_DEVICE) &&
 431             ((attached->device_info &
 432             MPI_SAS_DEVICE_INFO_SSP_TARGET) |
 433             (attached->device_info &
 434             MPI_SAS_DEVICE_INFO_STP_TARGET) |
 435             (attached->device_info &
 436             MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
 437                 return 1;
 438         else
 439                 return 0;
 440 }
 441
 442 /* no mutex */
 443 static void
 444 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
 445 {
 446         struct mptsas_portinfo *port_info;
 447         struct mptsas_phyinfo *phy_info;
 448         u8      i;
 449
 450         if (!port_details)
 451                 return;
 452
 453         port_info = port_details->port_info;
 454         phy_info = port_info->phy_info;
 455
 456         dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
 457             "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
 458             port_details->num_phys, (unsigned long long)
 459             port_details->phy_bitmask));
 460
 461         for (i = 0; i < port_info->num_phys; i++, phy_info++) {
 462                 if(phy_info->port_details != port_details)
 463                         continue;
 464                 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
 465                 mptsas_set_rphy(ioc, phy_info, NULL);
 466                 phy_info->port_details = NULL;
 467         }
 468         kfree(port_details);
 469 }
 470
 471 static inline struct sas_rphy *
 472 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
 473 {
 474         if (phy_info->port_details)
 475                 return phy_info->port_details->rphy;
 476         else
 477                 return NULL;
 478 }
 479
 480 static inline void
 481 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
 482 {
 483         if (phy_info->port_details) {
 484                 phy_info->port_details->rphy = rphy;
 485                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
 486                     ioc->name, rphy));
 487         }
 488
 489         if (rphy) {
 490                 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
 491                     &rphy->dev, MYIOC_s_FMT "add:", ioc->name));
 492                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rphy=%p release=%p\n",
 493                     ioc->name, rphy, rphy->dev.release));
 494         }
 495 }
 496
 497 static inline struct sas_port *
 498 mptsas_get_port(struct mptsas_phyinfo *phy_info)
 499 {
 500         if (phy_info->port_details)
 501                 return phy_info->port_details->port;
 502         else
 503                 return NULL;
 504 }
 505
 506 static inline void
 507 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
 508 {
 509         if (phy_info->port_details)
 510                 phy_info->port_details->port = port;
 511
 512         if (port) {
 513                 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
 514                     &port->dev, MYIOC_s_FMT "add:", ioc->name));
 515                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "port=%p release=%p\n",
 516                     ioc->name, port, port->dev.release));
 517         }
 518 }
 519
 520 static inline struct scsi_target *
 521 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
 522 {
 523         if (phy_info->port_details)
 524                 return phy_info->port_details->starget;
 525         else
 526                 return NULL;
 527 }
 528
 529 static inline void
 530 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
 531 starget)
 532 {
 533         if (phy_info->port_details)
 534                 phy_info->port_details->starget = starget;
 535 }
 536
 537 /**
 538  *      mptsas_add_device_component -
 539  *      @ioc: Pointer to MPT_ADAPTER structure
 540  *      @channel: fw mapped id's
 541  *      @id:
 542  *      @sas_address:
 543  *      @device_info:
 544  *
 545  **/
 546 static void
 547 mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id,
 548         u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id)
 549 {
 550         struct mptsas_device_info       *sas_info, *next;
 551         struct scsi_device      *sdev;
 552         struct scsi_target      *starget;
 553         struct sas_rphy *rphy;
 554
 555         /*
 556          * Delete all matching devices out of the list
 557          */
 558         mutex_lock(&ioc->sas_device_info_mutex);
 559         list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
 560             list) {
 561                 if (!sas_info->is_logical_volume &&
 562                     (sas_info->sas_address == sas_address ||
 563                     (sas_info->fw.channel == channel &&
 564                      sas_info->fw.id == id))) {
 565                         list_del(&sas_info->list);
 566                         kfree(sas_info);
 567                 }
 568         }
 569
 570         sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
 571         if (!sas_info)
 572                 goto out;
 573
 574         /*
 575          * Set Firmware mapping
 576          */
 577         sas_info->fw.id = id;
 578         sas_info->fw.channel = channel;
 579
 580         sas_info->sas_address = sas_address;
 581         sas_info->device_info = device_info;
 582         sas_info->slot = slot;
 583         sas_info->enclosure_logical_id = enclosure_logical_id;
 584         INIT_LIST_HEAD(&sas_info->list);
 585         list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
 586
 587         /*
 588          * Set OS mapping
 589          */
 590         shost_for_each_device(sdev, ioc->sh) {
 591                 starget = scsi_target(sdev);
 592                 rphy = dev_to_rphy(starget->dev.parent);
 593                 if (rphy->identify.sas_address == sas_address) {
 594                         sas_info->os.id = starget->id;
 595                         sas_info->os.channel = starget->channel;
 596                 }
 597         }
 598
 599  out:
 600         mutex_unlock(&ioc->sas_device_info_mutex);
 601         return;
 602 }
 603
 604 /**
 605  *      mptsas_add_device_component_by_fw -
 606  *      @ioc: Pointer to MPT_ADAPTER structure
 607  *      @channel:  fw mapped id's
 608  *      @id:
 609  *
 610  **/
 611 static void
 612 mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
 613 {
 614         struct mptsas_devinfo sas_device;
 615         struct mptsas_enclosure enclosure_info;
 616         int rc;
 617
 618         rc = mptsas_sas_device_pg0(ioc, &sas_device,
 619             (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
 620              MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
 621             (channel << 8) + id);
 622         if (rc)
 623                 return;
 624
 625         memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
 626         mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
 627             (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
 628              MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
 629              sas_device.handle_enclosure);
 630
 631         mptsas_add_device_component(ioc, sas_device.channel,
 632             sas_device.id, sas_device.sas_address, sas_device.device_info,
 633             sas_device.slot, enclosure_info.enclosure_logical_id);
 634 }
 635
 636 /**
 637  *      mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding each individual device to list
 638  *      @ioc: Pointer to MPT_ADAPTER structure
 639  *      @channel: fw mapped id's
 640  *      @id:
 641  *
 642  **/
 643 static void
 644 mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc,
 645                 struct scsi_target *starget)
 646 {
 647         CONFIGPARMS                     cfg;
 648         ConfigPageHeader_t              hdr;
 649         dma_addr_t                      dma_handle;
 650         pRaidVolumePage0_t              buffer = NULL;
 651         int                             i;
 652         RaidPhysDiskPage0_t             phys_disk;
 653         struct mptsas_device_info       *sas_info, *next;
 654
 655         memset(&cfg, 0 , sizeof(CONFIGPARMS));
 656         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
 657         hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
 658         /* assumption that all volumes on channel = 0 */
 659         cfg.pageAddr = starget->id;
 660         cfg.cfghdr.hdr = &hdr;
 661         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 662         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
 663
 664         if (mpt_config(ioc, &cfg) != 0)
 665                 goto out;
 666
 667         if (!hdr.PageLength)
 668                 goto out;
 669
 670         buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
 671             &dma_handle);
 672
 673         if (!buffer)
 674                 goto out;
 675
 676         cfg.physAddr = dma_handle;
 677         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 678
 679         if (mpt_config(ioc, &cfg) != 0)
 680                 goto out;
 681
 682         if (!buffer->NumPhysDisks)
 683                 goto out;
 684
 685         /*
 686          * Adding entry for hidden components
 687          */
 688         for (i = 0; i < buffer->NumPhysDisks; i++) {
 689
 690                 if (mpt_raid_phys_disk_pg0(ioc,
 691                     buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
 692                         continue;
 693
 694                 mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus,
 695                     phys_disk.PhysDiskID);
 696
 697                 mutex_lock(&ioc->sas_device_info_mutex);
 698                 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
 699                     list) {
 700                         if (!sas_info->is_logical_volume &&
 701                             (sas_info->fw.channel == phys_disk.PhysDiskBus &&
 702                             sas_info->fw.id == phys_disk.PhysDiskID)) {
 703                                 sas_info->is_hidden_raid_component = 1;
 704                                 sas_info->volume_id = starget->id;
 705                         }
 706                 }
 707                 mutex_unlock(&ioc->sas_device_info_mutex);
 708
 709         }
 710
 711         /*
 712          * Delete all matching devices out of the list
 713          */
 714         mutex_lock(&ioc->sas_device_info_mutex);
 715         list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
 716             list) {
 717                 if (sas_info->is_logical_volume && sas_info->fw.id ==
 718                     starget->id) {
 719                         list_del(&sas_info->list);
 720                         kfree(sas_info);
 721                 }
 722         }
 723
 724         sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
 725         if (sas_info) {
 726                 sas_info->fw.id = starget->id;
 727                 sas_info->os.id = starget->id;
 728                 sas_info->os.channel = starget->channel;
 729                 sas_info->is_logical_volume = 1;
 730                 INIT_LIST_HEAD(&sas_info->list);
 731                 list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
 732         }
 733         mutex_unlock(&ioc->sas_device_info_mutex);
 734
 735  out:
 736         if (buffer)
 737                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
 738                     dma_handle);
 739 }
 740
 741 /**
 742  *      mptsas_add_device_component_starget -
 743  *      @ioc: Pointer to MPT_ADAPTER structure
 744  *      @starget:
 745  *
 746  **/
 747 static void
 748 mptsas_add_device_component_starget(MPT_ADAPTER *ioc,
 749         struct scsi_target *starget)
 750 {
 751         VirtTarget      *vtarget;
 752         struct sas_rphy *rphy;
 753         struct mptsas_phyinfo   *phy_info = NULL;
 754         struct mptsas_enclosure enclosure_info;
 755
 756         rphy = dev_to_rphy(starget->dev.parent);
 757         vtarget = starget->hostdata;
 758         phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
 759                         rphy->identify.sas_address);
 760         if (!phy_info)
 761                 return;
 762
 763         memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
 764         mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
 765                 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
 766                 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
 767                 phy_info->attached.handle_enclosure);
 768
 769         mptsas_add_device_component(ioc, phy_info->attached.channel,
 770                 phy_info->attached.id, phy_info->attached.sas_address,
 771                 phy_info->attached.device_info,
 772                 phy_info->attached.slot, enclosure_info.enclosure_logical_id);
 773 }
 774
 775 /**
 776  *      mptsas_del_device_component_by_os - Once a device has been removed, we mark the entry in the list as being cached
 777  *      @ioc: Pointer to MPT_ADAPTER structure
 778  *      @channel: os mapped id's
 779  *      @id:
 780  *
 781  **/
 782 static void
 783 mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
 784 {
 785         struct mptsas_device_info       *sas_info, *next;
 786
 787         /*
 788          * Set is_cached flag
 789          */
 790         list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
 791                 list) {
 792                 if (sas_info->os.channel == channel && sas_info->os.id == id)
 793                         sas_info->is_cached = 1;
 794         }
 795 }
 796
 797 /**
 798  *      mptsas_del_device_components - Cleaning the list
 799  *      @ioc: Pointer to MPT_ADAPTER structure
 800  *
 801  **/
 802 static void
 803 mptsas_del_device_components(MPT_ADAPTER *ioc)
 804 {
 805         struct mptsas_device_info       *sas_info, *next;
 806
 807         mutex_lock(&ioc->sas_device_info_mutex);
 808         list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
 809                 list) {
 810                 list_del(&sas_info->list);
 811                 kfree(sas_info);
 812         }
 813         mutex_unlock(&ioc->sas_device_info_mutex);
 814 }
 815
 816
 817 /*
 818  * mptsas_setup_wide_ports
 819  *
 820  * Updates for new and existing narrow/wide port configuration
 821  * in the sas_topology
 822  */
 823 static void
 824 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
 825 {
 826         struct mptsas_portinfo_details * port_details;
 827         struct mptsas_phyinfo *phy_info, *phy_info_cmp;
 828         u64     sas_address;
 829         int     i, j;
 830
 831         mutex_lock(&ioc->sas_topology_mutex);
 832
 833         phy_info = port_info->phy_info;
 834         for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
 835                 if (phy_info->attached.handle)
 836                         continue;
 837                 port_details = phy_info->port_details;
 838                 if (!port_details)
 839                         continue;
 840                 if (port_details->num_phys < 2)
 841                         continue;
 842                 /*
 843                  * Removing a phy from a port, letting the last
 844                  * phy be removed by firmware events.
 845                  */
 846                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 847                     "%s: [%p]: deleting phy = %d\n",
 848                     ioc->name, __func__, port_details, i));
 849                 port_details->num_phys--;
 850                 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
 851                 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
 852                 if (phy_info->phy) {
 853                         devtprintk(ioc, dev_printk(KERN_DEBUG,
 854                                 &phy_info->phy->dev, MYIOC_s_FMT
 855                                 "delete phy %d, phy-obj (0x%p)\n", ioc->name,
 856                                 phy_info->phy_id, phy_info->phy));
 857                         sas_port_delete_phy(port_details->port, phy_info->phy);
 858                 }
 859                 phy_info->port_details = NULL;
 860         }
 861
 862         /*
 863          * Populate and refresh the tree
 864          */
 865         phy_info = port_info->phy_info;
 866         for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
 867                 sas_address = phy_info->attached.sas_address;
 868                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
 869                     ioc->name, i, (unsigned long long)sas_address));
 870                 if (!sas_address)
 871                         continue;
 872                 port_details = phy_info->port_details;
 873                 /*
 874                  * Forming a port
 875                  */
 876                 if (!port_details) {
 877                         port_details = kzalloc(sizeof(struct
 878                                 mptsas_portinfo_details), GFP_KERNEL);
 879                         if (!port_details)
 880                                 goto out;
 881                         port_details->num_phys = 1;
 882                         port_details->port_info = port_info;
 883                         if (phy_info->phy_id < 64 )
 884                                 port_details->phy_bitmask |=
 885                                     (1 << phy_info->phy_id);
 886                         phy_info->sas_port_add_phy=1;
 887                         dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
 888                             "phy_id=%d sas_address=0x%018llX\n",
 889                             ioc->name, i, (unsigned long long)sas_address));
 890                         phy_info->port_details = port_details;
 891                 }
 892
 893                 if (i == port_info->num_phys - 1)
 894                         continue;
 895                 phy_info_cmp = &port_info->phy_info[i + 1];
 896                 for (j = i + 1 ; j < port_info->num_phys ; j++,
 897                     phy_info_cmp++) {
 898                         if (!phy_info_cmp->attached.sas_address)
 899                                 continue;
 900                         if (sas_address != phy_info_cmp->attached.sas_address)
 901                                 continue;
 902                         if (phy_info_cmp->port_details == port_details )
 903                                 continue;
 904                         dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 905                             "\t\tphy_id=%d sas_address=0x%018llX\n",
 906                             ioc->name, j, (unsigned long long)
 907                             phy_info_cmp->attached.sas_address));
 908                         if (phy_info_cmp->port_details) {
 909                                 port_details->rphy =
 910                                     mptsas_get_rphy(phy_info_cmp);
 911                                 port_details->port =
 912                                     mptsas_get_port(phy_info_cmp);
 913                                 port_details->starget =
 914                                     mptsas_get_starget(phy_info_cmp);
 915                                 port_details->num_phys =
 916                                         phy_info_cmp->port_details->num_phys;
 917                                 if (!phy_info_cmp->port_details->num_phys)
 918                                         kfree(phy_info_cmp->port_details);
 919                         } else
 920                                 phy_info_cmp->sas_port_add_phy=1;
 921                         /*
 922                          * Adding a phy to a port
 923                          */
 924                         phy_info_cmp->port_details = port_details;
 925                         if (phy_info_cmp->phy_id < 64 )
 926                                 port_details->phy_bitmask |=
 927                                 (1 << phy_info_cmp->phy_id);
 928                         port_details->num_phys++;
 929                 }
 930         }
 931
 932  out:
 933
 934         for (i = 0; i < port_info->num_phys; i++) {
 935                 port_details = port_info->phy_info[i].port_details;
 936                 if (!port_details)
 937                         continue;
 938                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 939                     "%s: [%p]: phy_id=%02d num_phys=%02d "
 940                     "bitmask=0x%016llX\n", ioc->name, __func__,
 941                     port_details, i, port_details->num_phys,
 942                     (unsigned long long)port_details->phy_bitmask));
 943                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
 944                     ioc->name, port_details->port, port_details->rphy));
 945         }
 946         dsaswideprintk(ioc, printk("\n"));
 947         mutex_unlock(&ioc->sas_topology_mutex);
 948 }
 949
 950 /**
 951  * csmisas_find_vtarget
 952  *
 953  * @ioc
 954  * @volume_id
 955  * @volume_bus
 956  *
 957  **/
 958 static VirtTarget *
 959 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
 960 {
 961         struct scsi_device              *sdev;
 962         VirtDevice                      *vdevice;
 963         VirtTarget                      *vtarget = NULL;
 964
 965         shost_for_each_device(sdev, ioc->sh) {
 966                 vdevice = sdev->hostdata;
 967                 if ((vdevice == NULL) ||
 968                         (vdevice->vtarget == NULL))
 969                         continue;
 970                 if ((vdevice->vtarget->tflags &
 971                     MPT_TARGET_FLAGS_RAID_COMPONENT ||
 972                     vdevice->vtarget->raidVolume))
 973                         continue;
 974                 if (vdevice->vtarget->id == id &&
 975                         vdevice->vtarget->channel == channel)
 976                         vtarget = vdevice->vtarget;
 977         }
 978         return vtarget;
 979 }
 980
 981 static void
 982 mptsas_queue_device_delete(MPT_ADAPTER *ioc,
 983         MpiEventDataSasDeviceStatusChange_t *sas_event_data)
 984 {
 985         struct fw_event_work *fw_event;
 986         int sz;
 987
 988         sz = offsetof(struct fw_event_work, event_data) +
 989             sizeof(MpiEventDataSasDeviceStatusChange_t);
 990         fw_event = kzalloc(sz, GFP_ATOMIC);
 991         if (!fw_event) {
 992                 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
 993                     ioc->name, __func__, __LINE__);
 994                 return;
 995         }
 996         memcpy(fw_event->event_data, sas_event_data,
 997             sizeof(MpiEventDataSasDeviceStatusChange_t));
 998         fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
 999         fw_event->ioc = ioc;
1000         mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1001 }
1002
1003 static void
1004 mptsas_queue_rescan(MPT_ADAPTER *ioc)
1005 {
1006         struct fw_event_work *fw_event;
1007         int sz;
1008
1009         sz = offsetof(struct fw_event_work, event_data);
1010         fw_event = kzalloc(sz, GFP_ATOMIC);
1011         if (!fw_event) {
1012                 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1013                     ioc->name, __func__, __LINE__);
1014                 return;
1015         }
1016         fw_event->event = -1;
1017         fw_event->ioc = ioc;
1018         mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1019 }
1020
1021
1022 /**
1023  * mptsas_target_reset
1024  *
1025  * Issues TARGET_RESET to end device using handshaking method
1026  *
1027  * @ioc
1028  * @channel
1029  * @id
1030  *
1031  * Returns (1) success
1032  *         (0) failure
1033  *
1034  **/
1035 static int
1036 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
1037 {
1038         MPT_FRAME_HDR   *mf;
1039         SCSITaskMgmt_t  *pScsiTm;
1040         if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
1041                 return 0;
1042
1043
1044         mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
1045         if (mf == NULL) {
1046                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1047                         "%s, no msg frames @%d!!\n", ioc->name,
1048                         __func__, __LINE__));
1049                 goto out_fail;
1050         }
1051
1052         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1053                 ioc->name, mf));
1054
1055         /* Format the Request
1056          */
1057         pScsiTm = (SCSITaskMgmt_t *) mf;
1058         memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
1059         pScsiTm->TargetID = id;
1060         pScsiTm->Bus = channel;
1061         pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1062         pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
1063         pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
1064
1065         DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
1066
1067         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1068            "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
1069            ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
1070
1071         mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
1072
1073         return 1;
1074
1075  out_fail:
1076
1077         mpt_clear_taskmgmt_in_progress_flag(ioc);
1078         return 0;
1079 }
1080
1081 static void
1082 mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
1083 {
1084         scsi_device_set_state(sdev, SDEV_BLOCK);
1085 }
1086
1087 static void
1088 mptsas_block_io_starget(struct scsi_target *starget)
1089 {
1090         if (starget)
1091                 starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
1092 }
1093
1094 /**
1095  * mptsas_target_reset_queue
1096  *
1097  * Receive request for TARGET_RESET after recieving an firmware
1098  * event NOT_RESPONDING_EVENT, then put command in link list
1099  * and queue if task_queue already in use.
1100  *
1101  * @ioc
1102  * @sas_event_data
1103  *
1104  **/
1105 static void
1106 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
1107     EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
1108 {
1109         MPT_SCSI_HOST   *hd = shost_priv(ioc->sh);
1110         VirtTarget *vtarget = NULL;
1111         struct mptsas_target_reset_event *target_reset_list;
1112         u8              id, channel;
1113
1114         id = sas_event_data->TargetID;
1115         channel = sas_event_data->Bus;
1116
1117         vtarget = mptsas_find_vtarget(ioc, channel, id);
1118         if (vtarget) {
1119                 mptsas_block_io_starget(vtarget->starget);
1120                 vtarget->deleted = 1; /* block IO */
1121         }
1122
1123         target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
1124             GFP_ATOMIC);
1125         if (!target_reset_list) {
1126                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1127                         "%s, failed to allocate mem @%d..!!\n",
1128                         ioc->name, __func__, __LINE__));
1129                 return;
1130         }
1131
1132         memcpy(&target_reset_list->sas_event_data, sas_event_data,
1133                 sizeof(*sas_event_data));
1134         list_add_tail(&target_reset_list->list, &hd->target_reset_list);
1135
1136         target_reset_list->time_count = jiffies;
1137
1138         if (mptsas_target_reset(ioc, channel, id)) {
1139                 target_reset_list->target_reset_issued = 1;
1140         }
1141 }
1142
1143 /**
1144  * mptsas_schedule_target_reset- send pending target reset
1145  * @iocp: per adapter object
1146  *
1147  * This function will delete scheduled target reset from the list and
1148  * try to send next target reset. This will be called from completion
1149  * context of any Task managment command.
1150  */
1151
1152 void
1153 mptsas_schedule_target_reset(void *iocp)
1154 {
1155         MPT_ADAPTER *ioc = (MPT_ADAPTER *)(iocp);
1156         MPT_SCSI_HOST   *hd = shost_priv(ioc->sh);
1157         struct list_head *head = &hd->target_reset_list;
1158         struct mptsas_target_reset_event        *target_reset_list;
1159         u8              id, channel;
1160         /*
1161          * issue target reset to next device in the queue
1162          */
1163
1164         head = &hd->target_reset_list;
1165         if (list_empty(head))
1166                 return;
1167
1168         target_reset_list = list_entry(head->next,
1169                 struct mptsas_target_reset_event, list);
1170
1171         id = target_reset_list->sas_event_data.TargetID;
1172         channel = target_reset_list->sas_event_data.Bus;
1173         target_reset_list->time_count = jiffies;
1174
1175         if (mptsas_target_reset(ioc, channel, id))
1176                 target_reset_list->target_reset_issued = 1;
1177         return;
1178 }
1179
1180
1181 /**
1182  *      mptsas_taskmgmt_complete - complete SAS task management function
1183  *      @ioc: Pointer to MPT_ADAPTER structure
1184  *
1185  *      Completion for TARGET_RESET after NOT_RESPONDING_EVENT, enable work
1186  *      queue to finish off removing device from upper layers. then send next
1187  *      TARGET_RESET in the queue.
1188  **/
1189 static int
1190 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
1191 {
1192         MPT_SCSI_HOST   *hd = shost_priv(ioc->sh);
1193         struct list_head *head = &hd->target_reset_list;
1194         u8              id, channel;
1195         struct mptsas_target_reset_event        *target_reset_list;
1196         SCSITaskMgmtReply_t *pScsiTmReply;
1197
1198         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
1199             "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
1200
1201         pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
1202         if (pScsiTmReply) {
1203                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1204                     "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
1205                     "\ttask_type = 0x%02X, iocstatus = 0x%04X "
1206                     "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
1207                     "term_cmnds = %d\n", ioc->name,
1208                     pScsiTmReply->Bus, pScsiTmReply->TargetID,
1209                     pScsiTmReply->TaskType,
1210                     le16_to_cpu(pScsiTmReply->IOCStatus),
1211                     le32_to_cpu(pScsiTmReply->IOCLogInfo),
1212                     pScsiTmReply->ResponseCode,
1213                     le32_to_cpu(pScsiTmReply->TerminationCount)));
1214
1215                 if (pScsiTmReply->ResponseCode)
1216                         mptscsih_taskmgmt_response_code(ioc,
1217                         pScsiTmReply->ResponseCode);
1218         }
1219
1220         if (pScsiTmReply && (pScsiTmReply->TaskType ==
1221             MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
1222              MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET)) {
1223                 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
1224                 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
1225                 memcpy(ioc->taskmgmt_cmds.reply, mr,
1226                     min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
1227                 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
1228                         ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
1229                         complete(&ioc->taskmgmt_cmds.done);
1230                         return 1;
1231                 }
1232                 return 0;
1233         }
1234
1235         mpt_clear_taskmgmt_in_progress_flag(ioc);
1236
1237         if (list_empty(head))
1238                 return 1;
1239
1240         target_reset_list = list_entry(head->next,
1241             struct mptsas_target_reset_event, list);
1242
1243         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1244             "TaskMgmt: completed (%d seconds)\n",
1245             ioc->name, jiffies_to_msecs(jiffies -
1246             target_reset_list->time_count)/1000));
1247
1248         id = pScsiTmReply->TargetID;
1249         channel = pScsiTmReply->Bus;
1250         target_reset_list->time_count = jiffies;
1251
1252         /*
1253          * retry target reset
1254          */
1255         if (!target_reset_list->target_reset_issued) {
1256                 if (mptsas_target_reset(ioc, channel, id))
1257                         target_reset_list->target_reset_issued = 1;
1258                 return 1;
1259         }
1260
1261         /*
1262          * enable work queue to remove device from upper layers
1263          */
1264         list_del(&target_reset_list->list);
1265         if (!ioc->fw_events_off)
1266                 mptsas_queue_device_delete(ioc,
1267                         &target_reset_list->sas_event_data);
1268
1269
1270         ioc->schedule_target_reset(ioc);
1271
1272         return 1;
1273 }
1274
1275 /**
1276  * mptscsih_ioc_reset
1277  *
1278  * @ioc
1279  * @reset_phase
1280  *
1281  **/
1282 static int
1283 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1284 {
1285         MPT_SCSI_HOST   *hd;
1286         int rc;
1287
1288         rc = mptscsih_ioc_reset(ioc, reset_phase);
1289         if ((ioc->bus_type != SAS) || (!rc))
1290                 return rc;
1291
1292         hd = shost_priv(ioc->sh);
1293         if (!hd->ioc)
1294                 goto out;
1295
1296         switch (reset_phase) {
1297         case MPT_IOC_SETUP_RESET:
1298                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1299                     "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
1300                 mptsas_fw_event_off(ioc);
1301                 break;
1302         case MPT_IOC_PRE_RESET:
1303                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1304                     "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
1305                 break;
1306         case MPT_IOC_POST_RESET:
1307                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1308                     "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
1309                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
1310                         ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
1311                         complete(&ioc->sas_mgmt.done);
1312                 }
1313                 mptsas_cleanup_fw_event_q(ioc);
1314                 mptsas_queue_rescan(ioc);
1315                 break;
1316         default:
1317                 break;
1318         }
1319
1320  out:
1321         return rc;
1322 }
1323
1324
1325 /**
1326  * enum device_state -
1327  * @DEVICE_RETRY: need to retry the TUR
1328  * @DEVICE_ERROR: TUR return error, don't add device
1329  * @DEVICE_READY: device can be added
1330  *
1331  */
1332 enum device_state{
1333         DEVICE_RETRY,
1334         DEVICE_ERROR,
1335         DEVICE_READY,
1336 };
1337
1338 static int
1339 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
1340                 u32 form, u32 form_specific)
1341 {
1342         ConfigExtendedPageHeader_t hdr;
1343         CONFIGPARMS cfg;
1344         SasEnclosurePage0_t *buffer;
1345         dma_addr_t dma_handle;
1346         int error;
1347         __le64 le_identifier;
1348
1349         memset(&hdr, 0, sizeof(hdr));
1350         hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
1351         hdr.PageNumber = 0;
1352         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1353         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
1354
1355         cfg.cfghdr.ehdr = &hdr;
1356         cfg.physAddr = -1;
1357         cfg.pageAddr = form + form_specific;
1358         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1359         cfg.dir = 0;    /* read */
1360         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
1361
1362         error = mpt_config(ioc, &cfg);
1363         if (error)
1364                 goto out;
1365         if (!hdr.ExtPageLength) {
1366                 error = -ENXIO;
1367                 goto out;
1368         }
1369
1370         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1371                         &dma_handle);
1372         if (!buffer) {
1373                 error = -ENOMEM;
1374                 goto out;
1375         }
1376
1377         cfg.physAddr = dma_handle;
1378         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1379
1380         error = mpt_config(ioc, &cfg);
1381         if (error)
1382                 goto out_free_consistent;
1383
1384         /* save config data */
1385         memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
1386         enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
1387         enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
1388         enclosure->flags = le16_to_cpu(buffer->Flags);
1389         enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
1390         enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
1391         enclosure->start_id = buffer->StartTargetID;
1392         enclosure->start_channel = buffer->StartBus;
1393         enclosure->sep_id = buffer->SEPTargetID;
1394         enclosure->sep_channel = buffer->SEPBus;
1395
1396  out_free_consistent:
1397         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1398                             buffer, dma_handle);
1399  out:
1400         return error;
1401 }
1402
1403 /**
1404  *      mptsas_add_end_device - report a new end device to sas transport layer
1405  *      @ioc: Pointer to MPT_ADAPTER structure
1406  *      @phy_info: decribes attached device
1407  *
1408  *      return (0) success (1) failure
1409  *
1410  **/
1411 static int
1412 mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1413 {
1414         struct sas_rphy *rphy;
1415         struct sas_port *port;
1416         struct sas_identify identify;
1417         char *ds = NULL;
1418         u8 fw_id;
1419
1420         if (!phy_info) {
1421                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1422                         "%s: exit at line=%d\n", ioc->name,
1423                          __func__, __LINE__));
1424                 return 1;
1425         }
1426
1427         fw_id = phy_info->attached.id;
1428
1429         if (mptsas_get_rphy(phy_info)) {
1430                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1431                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1432                          __func__, fw_id, __LINE__));
1433                 return 2;
1434         }
1435
1436         port = mptsas_get_port(phy_info);
1437         if (!port) {
1438                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1439                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1440                          __func__, fw_id, __LINE__));
1441                 return 3;
1442         }
1443
1444         if (phy_info->attached.device_info &
1445             MPI_SAS_DEVICE_INFO_SSP_TARGET)
1446                 ds = "ssp";
1447         if (phy_info->attached.device_info &
1448             MPI_SAS_DEVICE_INFO_STP_TARGET)
1449                 ds = "stp";
1450         if (phy_info->attached.device_info &
1451             MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1452                 ds = "sata";
1453
1454         printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
1455             " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
1456             phy_info->attached.channel, phy_info->attached.id,
1457             phy_info->attached.phy_id, (unsigned long long)
1458             phy_info->attached.sas_address);
1459
1460         mptsas_parse_device_info(&identify, &phy_info->attached);
1461         rphy = sas_end_device_alloc(port);
1462         if (!rphy) {
1463                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1464                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1465                          __func__, fw_id, __LINE__));
1466                 return 5; /* non-fatal: an rphy can be added later */
1467         }
1468
1469         rphy->identify = identify;
1470         if (sas_rphy_add(rphy)) {
1471                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1472                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1473                          __func__, fw_id, __LINE__));
1474                 sas_rphy_free(rphy);
1475                 return 6;
1476         }
1477         mptsas_set_rphy(ioc, phy_info, rphy);
1478         return 0;
1479 }
1480
1481 /**
1482  *      mptsas_del_end_device - report a deleted end device to sas transport layer
1483  *      @ioc: Pointer to MPT_ADAPTER structure
1484  *      @phy_info: decribes attached device
1485  *
1486  **/
1487 static void
1488 mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1489 {
1490         struct sas_rphy *rphy;
1491         struct sas_port *port;
1492         struct mptsas_portinfo *port_info;
1493         struct mptsas_phyinfo *phy_info_parent;
1494         int i;
1495         char *ds = NULL;
1496         u8 fw_id;
1497         u64 sas_address;
1498
1499         if (!phy_info)
1500                 return;
1501
1502         fw_id = phy_info->attached.id;
1503         sas_address = phy_info->attached.sas_address;
1504
1505         if (!phy_info->port_details) {
1506                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1507                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1508                          __func__, fw_id, __LINE__));
1509                 return;
1510         }
1511         rphy = mptsas_get_rphy(phy_info);
1512         if (!rphy) {
1513                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1514                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1515                          __func__, fw_id, __LINE__));
1516                 return;
1517         }
1518
1519         if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_INITIATOR
1520                 || phy_info->attached.device_info
1521                         & MPI_SAS_DEVICE_INFO_SMP_INITIATOR
1522                 || phy_info->attached.device_info
1523                         & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1524                 ds = "initiator";
1525         if (phy_info->attached.device_info &
1526             MPI_SAS_DEVICE_INFO_SSP_TARGET)
1527                 ds = "ssp";
1528         if (phy_info->attached.device_info &
1529             MPI_SAS_DEVICE_INFO_STP_TARGET)
1530                 ds = "stp";
1531         if (phy_info->attached.device_info &
1532             MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1533                 ds = "sata";
1534
1535         dev_printk(KERN_DEBUG, &rphy->dev, MYIOC_s_FMT
1536             "removing %s device: fw_channel %d, fw_id %d, phy %d,"
1537             "sas_addr 0x%llx\n", ioc->name, ds, phy_info->attached.channel,
1538             phy_info->attached.id, phy_info->attached.phy_id,
1539             (unsigned long long) sas_address);
1540
1541         port = mptsas_get_port(phy_info);
1542         if (!port) {
1543                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1544                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
1545                          __func__, fw_id, __LINE__));
1546                 return;
1547         }
1548         port_info = phy_info->portinfo;
1549         phy_info_parent = port_info->phy_info;
1550         for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
1551                 if (!phy_info_parent->phy)
1552                         continue;
1553                 if (phy_info_parent->attached.sas_address !=
1554                     sas_address)
1555                         continue;
1556                 dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
1557                     MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
1558                     ioc->name, phy_info_parent->phy_id,
1559                     phy_info_parent->phy);
1560                 sas_port_delete_phy(port, phy_info_parent->phy);
1561         }
1562
1563         dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
1564             "delete port %d, sas_addr (0x%llx)\n", ioc->name,
1565              port->port_identifier, (unsigned long long)sas_address);
1566         sas_port_delete(port);
1567         mptsas_set_port(ioc, phy_info, NULL);
1568         mptsas_port_delete(ioc, phy_info->port_details);
1569 }
1570
1571 struct mptsas_phyinfo *
1572 mptsas_refreshing_device_handles(MPT_ADAPTER *ioc,
1573         struct mptsas_devinfo *sas_device)
1574 {
1575         struct mptsas_phyinfo *phy_info;
1576         struct mptsas_portinfo *port_info;
1577         int i;
1578
1579         phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
1580             sas_device->sas_address);
1581         if (!phy_info)
1582                 goto out;
1583         port_info = phy_info->portinfo;
1584         if (!port_info)
1585                 goto out;
1586         mutex_lock(&ioc->sas_topology_mutex);
1587         for (i = 0; i < port_info->num_phys; i++) {
1588                 if (port_info->phy_info[i].attached.sas_address !=
1589                         sas_device->sas_address)
1590                         continue;
1591                 port_info->phy_info[i].attached.channel = sas_device->channel;
1592                 port_info->phy_info[i].attached.id = sas_device->id;
1593                 port_info->phy_info[i].attached.sas_address =
1594                     sas_device->sas_address;
1595                 port_info->phy_info[i].attached.handle = sas_device->handle;
1596                 port_info->phy_info[i].attached.handle_parent =
1597                     sas_device->handle_parent;
1598                 port_info->phy_info[i].attached.handle_enclosure =
1599                     sas_device->handle_enclosure;
1600         }
1601         mutex_unlock(&ioc->sas_topology_mutex);
1602  out:
1603         return phy_info;
1604 }
1605
1606 /**
1607  * mptsas_firmware_event_work - work thread for processing fw events
1608  * @work: work queue payload containing info describing the event
1609  * Context: user
1610  *
1611  */
1612 static void
1613 mptsas_firmware_event_work(struct work_struct *work)
1614 {
1615         struct fw_event_work *fw_event =
1616                 container_of(work, struct fw_event_work, work.work);
1617         MPT_ADAPTER *ioc = fw_event->ioc;
1618
1619         /* special rescan topology handling */
1620         if (fw_event->event == -1) {
1621                 if (ioc->in_rescan) {
1622                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1623                                 "%s: rescan ignored as it is in progress\n",
1624                                 ioc->name, __func__));
1625                         return;
1626                 }
1627                 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rescan after "
1628                     "reset\n", ioc->name, __func__));
1629                 ioc->in_rescan = 1;
1630                 mptsas_not_responding_devices(ioc);
1631                 mptsas_scan_sas_topology(ioc);
1632                 ioc->in_rescan = 0;
1633                 mptsas_free_fw_event(ioc, fw_event);
1634                 mptsas_fw_event_on(ioc);
1635                 return;
1636         }
1637
1638         /* events handling turned off during host reset */
1639         if (ioc->fw_events_off) {
1640                 mptsas_free_fw_event(ioc, fw_event);
1641                 return;
1642         }
1643
1644         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_event=(0x%p), "
1645             "event = (0x%02x)\n", ioc->name, __func__, fw_event,
1646             (fw_event->event & 0xFF)));
1647
1648         switch (fw_event->event) {
1649         case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
1650                 mptsas_send_sas_event(fw_event);
1651                 break;
1652         case MPI_EVENT_INTEGRATED_RAID:
1653                 mptsas_send_raid_event(fw_event);
1654                 break;
1655         case MPI_EVENT_IR2:
1656                 mptsas_send_ir2_event(fw_event);
1657                 break;
1658         case MPI_EVENT_PERSISTENT_TABLE_FULL:
1659                 mptbase_sas_persist_operation(ioc,
1660                     MPI_SAS_OP_CLEAR_NOT_PRESENT);
1661                 mptsas_free_fw_event(ioc, fw_event);
1662                 break;
1663         case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
1664                 mptsas_broadcast_primative_work(fw_event);
1665                 break;
1666         case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
1667                 mptsas_send_expander_event(fw_event);
1668                 break;
1669         case MPI_EVENT_SAS_PHY_LINK_STATUS:
1670                 mptsas_send_link_status_event(fw_event);
1671                 break;
1672         case MPI_EVENT_QUEUE_FULL:
1673                 mptsas_handle_queue_full_event(fw_event);
1674                 break;
1675         }
1676 }
1677
1678
1679
1680 static int
1681 mptsas_slave_configure(struct scsi_device *sdev)
1682 {
1683         struct Scsi_Host        *host = sdev->host;
1684         MPT_SCSI_HOST   *hd = shost_priv(host);
1685         MPT_ADAPTER     *ioc = hd->ioc;
1686         VirtDevice      *vdevice = sdev->hostdata;
1687
1688         if (vdevice->vtarget->deleted) {
1689                 sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
1690                 vdevice->vtarget->deleted = 0;
1691         }
1692
1693         /*
1694          * RAID volumes placed beyond the last expected port.
1695          * Ignore sending sas mode pages in that case..
1696          */
1697         if (sdev->channel == MPTSAS_RAID_CHANNEL) {
1698                 mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
1699                 goto out;
1700         }
1701
1702         sas_read_port_mode_page(sdev);
1703
1704         mptsas_add_device_component_starget(ioc, scsi_target(sdev));
1705
1706  out:
1707         return mptscsih_slave_configure(sdev);
1708 }
1709
1710 static int
1711 mptsas_target_alloc(struct scsi_target *starget)
1712 {
1713         struct Scsi_Host *host = dev_to_shost(&starget->dev);
1714         MPT_SCSI_HOST           *hd = shost_priv(host);
1715         VirtTarget              *vtarget;
1716         u8                      id, channel;
1717         struct sas_rphy         *rphy;
1718         struct mptsas_portinfo  *p;
1719         int                      i;
1720         MPT_ADAPTER             *ioc = hd->ioc;
1721
1722         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
1723         if (!vtarget)
1724                 return -ENOMEM;
1725
1726         vtarget->starget = starget;
1727         vtarget->ioc_id = ioc->id;
1728         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
1729         id = starget->id;
1730         channel = 0;
1731
1732         /*
1733          * RAID volumes placed beyond the last expected port.
1734          */
1735         if (starget->channel == MPTSAS_RAID_CHANNEL) {
1736                 if (!ioc->raid_data.pIocPg2) {
1737                         kfree(vtarget);
1738                         return -ENXIO;
1739                 }
1740                 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
1741                         if (id == ioc->raid_data.pIocPg2->
1742                                         RaidVolume[i].VolumeID) {
1743                                 channel = ioc->raid_data.pIocPg2->
1744                                         RaidVolume[i].VolumeBus;
1745                         }
1746                 }
1747                 vtarget->raidVolume = 1;
1748                 goto out;
1749         }
1750
1751         rphy = dev_to_rphy(starget->dev.parent);
1752         mutex_lock(&ioc->sas_topology_mutex);
1753         list_for_each_entry(p, &ioc->sas_topology, list) {
1754                 for (i = 0; i < p->num_phys; i++) {
1755                         if (p->phy_info[i].attached.sas_address !=
1756                                         rphy->identify.sas_address)
1757                                 continue;
1758                         id = p->phy_info[i].attached.id;
1759                         channel = p->phy_info[i].attached.channel;
1760                         mptsas_set_starget(&p->phy_info[i], starget);
1761
1762                         /*
1763                          * Exposing hidden raid components
1764                          */
1765                         if (mptscsih_is_phys_disk(ioc, channel, id)) {
1766                                 id = mptscsih_raid_id_to_num(ioc,
1767                                                 channel, id);
1768                                 vtarget->tflags |=
1769                                     MPT_TARGET_FLAGS_RAID_COMPONENT;
1770                                 p->phy_info[i].attached.phys_disk_num = id;
1771                         }
1772                         mutex_unlock(&ioc->sas_topology_mutex);
1773                         goto out;
1774                 }
1775         }
1776         mutex_unlock(&ioc->sas_topology_mutex);
1777
1778         kfree(vtarget);
1779         return -ENXIO;
1780
1781  out:
1782         vtarget->id = id;
1783         vtarget->channel = channel;
1784         starget->hostdata = vtarget;
1785         return 0;
1786 }
1787
1788 static void
1789 mptsas_target_destroy(struct scsi_target *starget)
1790 {
1791         struct Scsi_Host *host = dev_to_shost(&starget->dev);
1792         MPT_SCSI_HOST           *hd = shost_priv(host);
1793         struct sas_rphy         *rphy;
1794         struct mptsas_portinfo  *p;
1795         int                      i;
1796         MPT_ADAPTER     *ioc = hd->ioc;
1797         VirtTarget      *vtarget;
1798
1799         if (!starget->hostdata)
1800                 return;
1801
1802         vtarget = starget->hostdata;
1803
1804         mptsas_del_device_component_by_os(ioc, starget->channel,
1805             starget->id);
1806
1807
1808         if (starget->channel == MPTSAS_RAID_CHANNEL)
1809                 goto out;
1810
1811         rphy = dev_to_rphy(starget->dev.parent);
1812         list_for_each_entry(p, &ioc->sas_topology, list) {
1813                 for (i = 0; i < p->num_phys; i++) {
1814                         if (p->phy_info[i].attached.sas_address !=
1815                                         rphy->identify.sas_address)
1816                                 continue;
1817
1818                         starget_printk(KERN_INFO, starget, MYIOC_s_FMT
1819                         "delete device: fw_channel %d, fw_id %d, phy %d, "
1820                         "sas_addr 0x%llx\n", ioc->name,
1821                         p->phy_info[i].attached.channel,
1822                         p->phy_info[i].attached.id,
1823                         p->phy_info[i].attached.phy_id, (unsigned long long)
1824                         p->phy_info[i].attached.sas_address);
1825
1826                         mptsas_set_starget(&p->phy_info[i], NULL);
1827                 }
1828         }
1829
1830  out:
1831         vtarget->starget = NULL;
1832         kfree(starget->hostdata);
1833         starget->hostdata = NULL;
1834 }
1835
1836
1837 static int
1838 mptsas_slave_alloc(struct scsi_device *sdev)
1839 {
1840         struct Scsi_Host        *host = sdev->host;
1841         MPT_SCSI_HOST           *hd = shost_priv(host);
1842         struct sas_rphy         *rphy;
1843         struct mptsas_portinfo  *p;
1844         VirtDevice              *vdevice;
1845         struct scsi_target      *starget;
1846         int                     i;
1847         MPT_ADAPTER *ioc = hd->ioc;
1848
1849         vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
1850         if (!vdevice) {
1851                 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
1852                                 ioc->name, sizeof(VirtDevice));
1853                 return -ENOMEM;
1854         }
1855         starget = scsi_target(sdev);
1856         vdevice->vtarget = starget->hostdata;
1857
1858         if (sdev->channel == MPTSAS_RAID_CHANNEL)
1859                 goto out;
1860
1861         rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1862         mutex_lock(&ioc->sas_topology_mutex);
1863         list_for_each_entry(p, &ioc->sas_topology, list) {
1864                 for (i = 0; i < p->num_phys; i++) {
1865                         if (p->phy_info[i].attached.sas_address !=
1866                                         rphy->identify.sas_address)
1867                                 continue;
1868                         vdevice->lun = sdev->lun;
1869                         /*
1870                          * Exposing hidden raid components
1871                          */
1872                         if (mptscsih_is_phys_disk(ioc,
1873                             p->phy_info[i].attached.channel,
1874                             p->phy_info[i].attached.id))
1875                                 sdev->no_uld_attach = 1;
1876                         mutex_unlock(&ioc->sas_topology_mutex);
1877                         goto out;
1878                 }
1879         }
1880         mutex_unlock(&ioc->sas_topology_mutex);
1881
1882         kfree(vdevice);
1883         return -ENXIO;
1884
1885  out:
1886         vdevice->vtarget->num_luns++;
1887         sdev->hostdata = vdevice;
1888         return 0;
1889 }
1890
1891 static int
1892 mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1893 {
1894         MPT_SCSI_HOST   *hd;
1895         MPT_ADAPTER     *ioc;
1896         VirtDevice      *vdevice = SCpnt->device->hostdata;
1897
1898         if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
1899                 SCpnt->result = DID_NO_CONNECT << 16;
1900                 done(SCpnt);
1901                 return 0;
1902         }
1903
1904         hd = shost_priv(SCpnt->device->host);
1905         ioc = hd->ioc;
1906
1907         if (ioc->sas_discovery_quiesce_io)
1908                 return SCSI_MLQUEUE_HOST_BUSY;
1909
1910         if (ioc->debug_level & MPT_DEBUG_SCSI)
1911                 scsi_print_command(SCpnt);
1912
1913         return mptscsih_qcmd(SCpnt,done);
1914 }
1915
1916 /**
1917  *      mptsas_mptsas_eh_timed_out - resets the scsi_cmnd timeout
1918  *              if the device under question is currently in the
1919  *              device removal delay.
1920  *      @sc: scsi command that the midlayer is about to time out
1921  *
1922  **/
1923 static enum blk_eh_timer_return mptsas_eh_timed_out(struct scsi_cmnd *sc)
1924 {
1925         MPT_SCSI_HOST *hd;
1926         MPT_ADAPTER   *ioc;
1927         VirtDevice    *vdevice;
1928         enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1929
1930         hd = shost_priv(sc->device->host);
1931         if (hd == NULL) {
1932                 printk(KERN_ERR MYNAM ": %s: Can't locate host! (sc=%p)\n",
1933                     __func__, sc);
1934                 goto done;
1935         }
1936
1937         ioc = hd->ioc;
1938         if (ioc->bus_type != SAS) {
1939                 printk(KERN_ERR MYNAM ": %s: Wrong bus type (sc=%p)\n",
1940                     __func__, sc);
1941                 goto done;
1942         }
1943
1944         vdevice = sc->device->hostdata;
1945         if (vdevice && vdevice->vtarget && (vdevice->vtarget->inDMD
1946                 || vdevice->vtarget->deleted)) {
1947                 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: target removed "
1948                     "or in device removal delay (sc=%p)\n",
1949                     ioc->name, __func__, sc));
1950                 rc = BLK_EH_RESET_TIMER;
1951                 goto done;
1952         }
1953
1954 done:
1955         return rc;
1956 }
1957
1958
1959 static struct scsi_host_template mptsas_driver_template = {
1960         .module                         = THIS_MODULE,
1961         .proc_name                      = "mptsas",
1962         .proc_info                      = mptscsih_proc_info,
1963         .name                           = "MPT SAS Host",
1964         .info                           = mptscsih_info,
1965         .queuecommand                   = mptsas_qcmd,
1966         .target_alloc                   = mptsas_target_alloc,
1967         .slave_alloc                    = mptsas_slave_alloc,
1968         .slave_configure                = mptsas_slave_configure,
1969         .target_destroy                 = mptsas_target_destroy,
1970         .slave_destroy                  = mptscsih_slave_destroy,
1971         .change_queue_depth             = mptscsih_change_queue_depth,
1972         .eh_abort_handler               = mptscsih_abort,
1973         .eh_device_reset_handler        = mptscsih_dev_reset,
1974         .eh_bus_reset_handler           = mptscsih_bus_reset,
1975         .eh_host_reset_handler          = mptscsih_host_reset,
1976         .bios_param                     = mptscsih_bios_param,
1977         .can_queue                      = MPT_SAS_CAN_QUEUE,
1978         .this_id                        = -1,
1979         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
1980         .max_sectors                    = 8192,
1981         .cmd_per_lun                    = 7,
1982         .use_clustering                 = ENABLE_CLUSTERING,
1983         .shost_attrs                    = mptscsih_host_attrs,
1984 };
1985
1986 static int mptsas_get_linkerrors(struct sas_phy *phy)
1987 {
1988         MPT_ADAPTER *ioc = phy_to_ioc(phy);
1989         ConfigExtendedPageHeader_t hdr;
1990         CONFIGPARMS cfg;
1991         SasPhyPage1_t *buffer;
1992         dma_addr_t dma_handle;
1993         int error;
1994
1995         /* FIXME: only have link errors on local phys */
1996         if (!scsi_is_sas_phy_local(phy))
1997                 return -EINVAL;
1998
1999         hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
2000         hdr.ExtPageLength = 0;
2001         hdr.PageNumber = 1 /* page number 1*/;
2002         hdr.Reserved1 = 0;
2003         hdr.Reserved2 = 0;
2004         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2005         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2006
2007         cfg.cfghdr.ehdr = &hdr;
2008         cfg.physAddr = -1;
2009         cfg.pageAddr = phy->identify.phy_identifier;
2010         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2011         cfg.dir = 0;    /* read */
2012         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2013
2014         error = mpt_config(ioc, &cfg);
2015         if (error)
2016                 return error;
2017         if (!hdr.ExtPageLength)
2018                 return -ENXIO;
2019
2020         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2021                                       &dma_handle);
2022         if (!buffer)
2023                 return -ENOMEM;
2024
2025         cfg.physAddr = dma_handle;
2026         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2027
2028         error = mpt_config(ioc, &cfg);
2029         if (error)
2030                 goto out_free_consistent;
2031
2032         mptsas_print_phy_pg1(ioc, buffer);
2033
2034         phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
2035         phy->running_disparity_error_count =
2036                 le32_to_cpu(buffer->RunningDisparityErrorCount);
2037         phy->loss_of_dword_sync_count =
2038                 le32_to_cpu(buffer->LossDwordSynchCount);
2039         phy->phy_reset_problem_count =
2040                 le32_to_cpu(buffer->PhyResetProblemCount);
2041
2042  out_free_consistent:
2043         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2044                             buffer, dma_handle);
2045         return error;
2046 }
2047
2048 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2049                 MPT_FRAME_HDR *reply)
2050 {
2051         ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2052         if (reply != NULL) {
2053                 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID;
2054                 memcpy(ioc->sas_mgmt.reply, reply,
2055                     min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
2056         }
2057
2058         if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
2059                 ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING;
2060                 complete(&ioc->sas_mgmt.done);
2061                 return 1;
2062         }
2063         return 0;
2064 }
2065
2066 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
2067 {
2068         MPT_ADAPTER *ioc = phy_to_ioc(phy);
2069         SasIoUnitControlRequest_t *req;
2070         SasIoUnitControlReply_t *reply;
2071         MPT_FRAME_HDR *mf;
2072         MPIHeader_t *hdr;
2073         unsigned long timeleft;
2074         int error = -ERESTARTSYS;
2075
2076         /* FIXME: fusion doesn't allow non-local phy reset */
2077         if (!scsi_is_sas_phy_local(phy))
2078                 return -EINVAL;
2079
2080         /* not implemented for expanders */
2081         if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
2082                 return -ENXIO;
2083
2084         if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
2085                 goto out;
2086
2087         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2088         if (!mf) {
2089                 error = -ENOMEM;
2090                 goto out_unlock;
2091         }
2092
2093         hdr = (MPIHeader_t *) mf;
2094         req = (SasIoUnitControlRequest_t *)mf;
2095         memset(req, 0, sizeof(SasIoUnitControlRequest_t));
2096         req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
2097         req->MsgContext = hdr->MsgContext;
2098         req->Operation = hard_reset ?
2099                 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
2100         req->PhyNum = phy->identify.phy_identifier;
2101
2102         INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2103         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2104
2105         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
2106                         10 * HZ);
2107         if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2108                 error = -ETIME;
2109                 mpt_free_msg_frame(ioc, mf);
2110                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2111                         goto out_unlock;
2112                 if (!timeleft)
2113                         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2114                 goto out_unlock;
2115         }
2116
2117         /* a reply frame is expected */
2118         if ((ioc->sas_mgmt.status &
2119             MPT_MGMT_STATUS_RF_VALID) == 0) {
2120                 error = -ENXIO;
2121                 goto out_unlock;
2122         }
2123
2124         /* process the completed Reply Message Frame */
2125         reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
2126         if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
2127                 printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
2128                     ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
2129                 error = -ENXIO;
2130                 goto out_unlock;
2131         }
2132
2133         error = 0;
2134
2135  out_unlock:
2136         CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2137         mutex_unlock(&ioc->sas_mgmt.mutex);
2138  out:
2139         return error;
2140 }
2141
2142 static int
2143 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
2144 {
2145         MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2146         int i, error;
2147         struct mptsas_portinfo *p;
2148         struct mptsas_enclosure enclosure_info;
2149         u64 enclosure_handle;
2150
2151         mutex_lock(&ioc->sas_topology_mutex);
2152         list_for_each_entry(p, &ioc->sas_topology, list) {
2153                 for (i = 0; i < p->num_phys; i++) {
2154                         if (p->phy_info[i].attached.sas_address ==
2155                             rphy->identify.sas_address) {
2156                                 enclosure_handle = p->phy_info[i].
2157                                         attached.handle_enclosure;
2158                                 goto found_info;
2159                         }
2160                 }
2161         }
2162         mutex_unlock(&ioc->sas_topology_mutex);
2163         return -ENXIO;
2164
2165  found_info:
2166         mutex_unlock(&ioc->sas_topology_mutex);
2167         memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
2168         error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
2169                         (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
2170                          MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
2171         if (!error)
2172                 *identifier = enclosure_info.enclosure_logical_id;
2173         return error;
2174 }
2175
2176 static int
2177 mptsas_get_bay_identifier(struct sas_rphy *rphy)
2178 {
2179         MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2180         struct mptsas_portinfo *p;
2181         int i, rc;
2182
2183         mutex_lock(&ioc->sas_topology_mutex);
2184         list_for_each_entry(p, &ioc->sas_topology, list) {
2185                 for (i = 0; i < p->num_phys; i++) {
2186                         if (p->phy_info[i].attached.sas_address ==
2187                             rphy->identify.sas_address) {
2188                                 rc = p->phy_info[i].attached.slot;
2189                                 goto out;
2190                         }
2191                 }
2192         }
2193         rc = -ENXIO;
2194  out:
2195         mutex_unlock(&ioc->sas_topology_mutex);
2196         return rc;
2197 }
2198
2199 static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
2200                               struct request *req)
2201 {
2202         MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
2203         MPT_FRAME_HDR *mf;
2204         SmpPassthroughRequest_t *smpreq;
2205         struct request *rsp = req->next_rq;
2206         int ret;
2207         int flagsLength;
2208         unsigned long timeleft;
2209         char *psge;
2210         dma_addr_t dma_addr_in = 0;
2211         dma_addr_t dma_addr_out = 0;
2212         u64 sas_address = 0;
2213
2214         if (!rsp) {
2215                 printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n",
2216                     ioc->name, __func__);
2217                 return -EINVAL;
2218         }
2219
2220         /* do we need to support multiple segments? */
2221         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
2222                 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
2223                     ioc->name, __func__, req->bio->bi_vcnt, blk_rq_bytes(req),
2224                     rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
2225                 return -EINVAL;
2226         }
2227
2228         ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2229         if (ret)
2230                 goto out;
2231
2232         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2233         if (!mf) {
2234                 ret = -ENOMEM;
2235                 goto out_unlock;
2236         }
2237
2238         smpreq = (SmpPassthroughRequest_t *)mf;
2239         memset(smpreq, 0, sizeof(*smpreq));
2240
2241         smpreq->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
2242         smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2243
2244         if (rphy)
2245                 sas_address = rphy->identify.sas_address;
2246         else {
2247                 struct mptsas_portinfo *port_info;
2248
2249                 mutex_lock(&ioc->sas_topology_mutex);
2250                 port_info = ioc->hba_port_info;
2251                 if (port_info && port_info->phy_info)
2252                         sas_address =
2253                                 port_info->phy_info[0].phy->identify.sas_address;
2254                 mutex_unlock(&ioc->sas_topology_mutex);
2255         }
2256
2257         *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2258
2259         psge = (char *)
2260                 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2261
2262         /* request */
2263         flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2264                        MPI_SGE_FLAGS_END_OF_BUFFER |
2265                        MPI_SGE_FLAGS_DIRECTION)
2266                        << MPI_SGE_FLAGS_SHIFT;
2267         flagsLength |= (blk_rq_bytes(req) - 4);
2268
2269         dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
2270                                       blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
2271         if (!dma_addr_out)
2272                 goto put_mf;
2273         ioc->add_sge(psge, flagsLength, dma_addr_out);
2274         psge += ioc->SGE_size;
2275
2276         /* response */
2277         flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2278                 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2279                 MPI_SGE_FLAGS_IOC_TO_HOST |
2280                 MPI_SGE_FLAGS_END_OF_BUFFER;
2281
2282         flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2283         flagsLength |= blk_rq_bytes(rsp) + 4;
2284         dma_addr_in =  pci_map_single(ioc->pcidev, bio_data(rsp->bio),
2285                                       blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
2286         if (!dma_addr_in)
2287                 goto unmap;
2288         ioc->add_sge(psge, flagsLength, dma_addr_in);
2289
2290         INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2291         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2292
2293         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2294         if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2295                 ret = -ETIME;
2296                 mpt_free_msg_frame(ioc, mf);
2297                 mf = NULL;
2298                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2299                         goto unmap;
2300                 if (!timeleft)
2301                         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2302                 goto unmap;
2303         }
2304         mf = NULL;
2305
2306         if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2307                 SmpPassthroughReply_t *smprep;
2308
2309                 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2310                 memcpy(req->sense, smprep, sizeof(*smprep));
2311                 req->sense_len = sizeof(*smprep);
2312                 req->resid_len = 0;
2313                 rsp->resid_len -= smprep->ResponseDataLength;
2314         } else {
2315                 printk(MYIOC_s_ERR_FMT
2316                     "%s: smp passthru reply failed to be returned\n",
2317                     ioc->name, __func__);
2318                 ret = -ENXIO;
2319         }
2320 unmap:
2321         if (dma_addr_out)
2322                 pci_unmap_single(ioc->pcidev, dma_addr_out, blk_rq_bytes(req),
2323                                  PCI_DMA_BIDIRECTIONAL);
2324         if (dma_addr_in)
2325                 pci_unmap_single(ioc->pcidev, dma_addr_in, blk_rq_bytes(rsp),
2326                                  PCI_DMA_BIDIRECTIONAL);
2327 put_mf:
2328         if (mf)
2329                 mpt_free_msg_frame(ioc, mf);
2330 out_unlock:
2331         CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2332         mutex_unlock(&ioc->sas_mgmt.mutex);
2333 out:
2334         return ret;
2335 }
2336
2337 static struct sas_function_template mptsas_transport_functions = {
2338         .get_linkerrors         = mptsas_get_linkerrors,
2339         .get_enclosure_identifier = mptsas_get_enclosure_identifier,
2340         .get_bay_identifier     = mptsas_get_bay_identifier,
2341         .phy_reset              = mptsas_phy_reset,
2342         .smp_handler            = mptsas_smp_handler,
2343 };
2344
2345 static struct scsi_transport_template *mptsas_transport_template;
2346
2347 static int
2348 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
2349 {
2350         ConfigExtendedPageHeader_t hdr;
2351         CONFIGPARMS cfg;
2352         SasIOUnitPage0_t *buffer;
2353         dma_addr_t dma_handle;
2354         int error, i;
2355
2356         hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
2357         hdr.ExtPageLength = 0;
2358         hdr.PageNumber = 0;
2359         hdr.Reserved1 = 0;
2360         hdr.Reserved2 = 0;
2361         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2362         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2363
2364         cfg.cfghdr.ehdr = &hdr;
2365         cfg.physAddr = -1;
2366         cfg.pageAddr = 0;
2367         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2368         cfg.dir = 0;    /* read */
2369         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2370
2371         error = mpt_config(ioc, &cfg);
2372         if (error)
2373                 goto out;
2374         if (!hdr.ExtPageLength) {
2375                 error = -ENXIO;
2376                 goto out;
2377         }
2378
2379         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2380                                             &dma_handle);
2381         if (!buffer) {
2382                 error = -ENOMEM;
2383                 goto out;
2384         }
2385
2386         cfg.physAddr = dma_handle;
2387         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2388
2389         error = mpt_config(ioc, &cfg);
2390         if (error)
2391                 goto out_free_consistent;
2392
2393         port_info->num_phys = buffer->NumPhys;
2394         port_info->phy_info = kcalloc(port_info->num_phys,
2395                 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2396         if (!port_info->phy_info) {
2397                 error = -ENOMEM;
2398                 goto out_free_consistent;
2399         }
2400
2401         ioc->nvdata_version_persistent =
2402             le16_to_cpu(buffer->NvdataVersionPersistent);
2403         ioc->nvdata_version_default =
2404             le16_to_cpu(buffer->NvdataVersionDefault);
2405
2406         for (i = 0; i < port_info->num_phys; i++) {
2407                 mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
2408                 port_info->phy_info[i].phy_id = i;
2409                 port_info->phy_info[i].port_id =
2410                     buffer->PhyData[i].Port;
2411                 port_info->phy_info[i].negotiated_link_rate =
2412                     buffer->PhyData[i].NegotiatedLinkRate;
2413                 port_info->phy_info[i].portinfo = port_info;
2414                 port_info->phy_info[i].handle =
2415                     le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
2416         }
2417
2418  out_free_consistent:
2419         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2420                             buffer, dma_handle);
2421  out:
2422         return error;
2423 }
2424
2425 static int
2426 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
2427 {
2428         ConfigExtendedPageHeader_t hdr;
2429         CONFIGPARMS cfg;
2430         SasIOUnitPage1_t *buffer;
2431         dma_addr_t dma_handle;
2432         int error;
2433         u8 device_missing_delay;
2434
2435         memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
2436         memset(&cfg, 0, sizeof(CONFIGPARMS));
2437
2438         cfg.cfghdr.ehdr = &hdr;
2439         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2440         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2441         cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2442         cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2443         cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
2444         cfg.cfghdr.ehdr->PageNumber = 1;
2445
2446         error = mpt_config(ioc, &cfg);
2447         if (error)
2448                 goto out;
2449         if (!hdr.ExtPageLength) {
2450                 error = -ENXIO;
2451                 goto out;
2452         }
2453
2454         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2455                                             &dma_handle);
2456         if (!buffer) {
2457                 error = -ENOMEM;
2458                 goto out;
2459         }
2460
2461         cfg.physAddr = dma_handle;
2462         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2463
2464         error = mpt_config(ioc, &cfg);
2465         if (error)
2466                 goto out_free_consistent;
2467
2468         ioc->io_missing_delay  =
2469             le16_to_cpu(buffer->IODeviceMissingDelay);
2470         device_missing_delay = buffer->ReportDeviceMissingDelay;
2471         ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
2472             (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
2473             device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
2474
2475  out_free_consistent:
2476         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2477                             buffer, dma_handle);
2478  out:
2479         return error;
2480 }
2481
2482 static int
2483 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2484                 u32 form, u32 form_specific)
2485 {
2486         ConfigExtendedPageHeader_t hdr;
2487         CONFIGPARMS cfg;
2488         SasPhyPage0_t *buffer;
2489         dma_addr_t dma_handle;
2490         int error;
2491
2492         hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
2493         hdr.ExtPageLength = 0;
2494         hdr.PageNumber = 0;
2495         hdr.Reserved1 = 0;
2496         hdr.Reserved2 = 0;
2497         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2498         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2499
2500         cfg.cfghdr.ehdr = &hdr;
2501         cfg.dir = 0;    /* read */
2502         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2503
2504         /* Get Phy Pg 0 for each Phy. */
2505         cfg.physAddr = -1;
2506         cfg.pageAddr = form + form_specific;
2507         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2508
2509         error = mpt_config(ioc, &cfg);
2510         if (error)
2511                 goto out;
2512
2513         if (!hdr.ExtPageLength) {
2514                 error = -ENXIO;
2515                 goto out;
2516         }
2517
2518         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2519                                       &dma_handle);
2520         if (!buffer) {
2521                 error = -ENOMEM;
2522                 goto out;
2523         }
2524
2525         cfg.physAddr = dma_handle;
2526         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2527
2528         error = mpt_config(ioc, &cfg);
2529         if (error)
2530                 goto out_free_consistent;
2531
2532         mptsas_print_phy_pg0(ioc, buffer);
2533
2534         phy_info->hw_link_rate = buffer->HwLinkRate;
2535         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2536         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2537         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2538
2539  out_free_consistent:
2540         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2541                             buffer, dma_handle);
2542  out:
2543         return error;
2544 }
2545
2546 static int
2547 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
2548                 u32 form, u32 form_specific)
2549 {
2550         ConfigExtendedPageHeader_t hdr;
2551         CONFIGPARMS cfg;
2552         SasDevicePage0_t *buffer;
2553         dma_addr_t dma_handle;
2554         __le64 sas_address;
2555         int error=0;
2556
2557         hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
2558         hdr.ExtPageLength = 0;
2559         hdr.PageNumber = 0;
2560         hdr.Reserved1 = 0;
2561         hdr.Reserved2 = 0;
2562         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2563         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
2564
2565         cfg.cfghdr.ehdr = &hdr;
2566         cfg.pageAddr = form + form_specific;
2567         cfg.physAddr = -1;
2568         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2569         cfg.dir = 0;    /* read */
2570         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2571
2572         memset(device_info, 0, sizeof(struct mptsas_devinfo));
2573         error = mpt_config(ioc, &cfg);
2574         if (error)
2575                 goto out;
2576         if (!hdr.ExtPageLength) {
2577                 error = -ENXIO;
2578                 goto out;
2579         }
2580
2581         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2582                                       &dma_handle);
2583         if (!buffer) {
2584                 error = -ENOMEM;
2585                 goto out;
2586         }
2587
2588         cfg.physAddr = dma_handle;
2589         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2590
2591         error = mpt_config(ioc, &cfg);
2592
2593         if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2594                 error = -ENODEV;
2595                 goto out_free_consistent;
2596         }
2597
2598         if (error)
2599                 goto out_free_consistent;
2600
2601         mptsas_print_device_pg0(ioc, buffer);
2602
2603         memset(device_info, 0, sizeof(struct mptsas_devinfo));
2604         device_info->handle = le16_to_cpu(buffer->DevHandle);
2605         device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
2606         device_info->handle_enclosure =
2607             le16_to_cpu(buffer->EnclosureHandle);
2608         device_info->slot = le16_to_cpu(buffer->Slot);
2609         device_info->phy_id = buffer->PhyNum;
2610         device_info->port_id = buffer->PhysicalPort;
2611         device_info->id = buffer->TargetID;
2612         device_info->phys_disk_num = ~0;
2613         device_info->channel = buffer->Bus;
2614         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2615         device_info->sas_address = le64_to_cpu(sas_address);
2616         device_info->device_info =
2617             le32_to_cpu(buffer->DeviceInfo);
2618         device_info->flags = le16_to_cpu(buffer->Flags);
2619
2620  out_free_consistent:
2621         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2622                             buffer, dma_handle);
2623  out:
2624         return error;
2625 }
2626
2627 static int
2628 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
2629                 u32 form, u32 form_specific)
2630 {
2631         ConfigExtendedPageHeader_t hdr;
2632         CONFIGPARMS cfg;
2633         SasExpanderPage0_t *buffer;
2634         dma_addr_t dma_handle;
2635         int i, error;
2636         __le64 sas_address;
2637
2638         memset(port_info, 0, sizeof(struct mptsas_portinfo));
2639         hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
2640         hdr.ExtPageLength = 0;
2641         hdr.PageNumber = 0;
2642         hdr.Reserved1 = 0;
2643         hdr.Reserved2 = 0;
2644         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2645         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2646
2647         cfg.cfghdr.ehdr = &hdr;
2648         cfg.physAddr = -1;
2649         cfg.pageAddr = form + form_specific;
2650         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2651         cfg.dir = 0;    /* read */
2652         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2653
2654         memset(port_info, 0, sizeof(struct mptsas_portinfo));
2655         error = mpt_config(ioc, &cfg);
2656         if (error)
2657                 goto out;
2658
2659         if (!hdr.ExtPageLength) {
2660                 error = -ENXIO;
2661                 goto out;
2662         }
2663
2664         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2665                                       &dma_handle);
2666         if (!buffer) {
2667                 error = -ENOMEM;
2668                 goto out;
2669         }
2670
2671         cfg.physAddr = dma_handle;
2672         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2673
2674         error = mpt_config(ioc, &cfg);
2675         if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2676                 error = -ENODEV;
2677                 goto out_free_consistent;
2678         }
2679
2680         if (error)
2681                 goto out_free_consistent;
2682
2683         /* save config data */
2684         port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
2685         port_info->phy_info = kcalloc(port_info->num_phys,
2686                 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2687         if (!port_info->phy_info) {
2688                 error = -ENOMEM;
2689                 goto out_free_consistent;
2690         }
2691
2692         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2693         for (i = 0; i < port_info->num_phys; i++) {
2694                 port_info->phy_info[i].portinfo = port_info;
2695                 port_info->phy_info[i].handle =
2696                     le16_to_cpu(buffer->DevHandle);
2697                 port_info->phy_info[i].identify.sas_address =
2698                     le64_to_cpu(sas_address);
2699                 port_info->phy_info[i].identify.handle_parent =
2700                     le16_to_cpu(buffer->ParentDevHandle);
2701         }
2702
2703  out_free_consistent:
2704         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2705                             buffer, dma_handle);
2706  out:
2707         return error;
2708 }
2709
2710 static int
2711 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2712                 u32 form, u32 form_specific)
2713 {
2714         ConfigExtendedPageHeader_t hdr;
2715         CONFIGPARMS cfg;
2716         SasExpanderPage1_t *buffer;
2717         dma_addr_t dma_handle;
2718         int error=0;
2719
2720         hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
2721         hdr.ExtPageLength = 0;
2722         hdr.PageNumber = 1;
2723         hdr.Reserved1 = 0;
2724         hdr.Reserved2 = 0;
2725         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2726         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2727
2728         cfg.cfghdr.ehdr = &hdr;
2729         cfg.physAddr = -1;
2730         cfg.pageAddr = form + form_specific;
2731         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2732         cfg.dir = 0;    /* read */
2733         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2734
2735         error = mpt_config(ioc, &cfg);
2736         if (error)
2737                 goto out;
2738
2739         if (!hdr.ExtPageLength) {
2740                 error = -ENXIO;
2741                 goto out;
2742         }
2743
2744         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2745                                       &dma_handle);
2746         if (!buffer) {
2747                 error = -ENOMEM;
2748                 goto out;
2749         }
2750
2751         cfg.physAddr = dma_handle;
2752         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2753
2754         error = mpt_config(ioc, &cfg);
2755
2756         if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2757                 error = -ENODEV;
2758                 goto out_free_consistent;
2759         }
2760
2761         if (error)
2762                 goto out_free_consistent;
2763
2764
2765         mptsas_print_expander_pg1(ioc, buffer);
2766
2767         /* save config data */
2768         phy_info->phy_id = buffer->PhyIdentifier;
2769         phy_info->port_id = buffer->PhysicalPort;
2770         phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
2771         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2772         phy_info->hw_link_rate = buffer->HwLinkRate;
2773         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2774         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2775
2776  out_free_consistent:
2777         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2778                             buffer, dma_handle);
2779  out:
2780         return error;
2781 }
2782
2783 struct rep_manu_request{
2784         u8 smp_frame_type;
2785         u8 function;
2786         u8 reserved;
2787         u8 request_length;
2788 };
2789
2790 struct rep_manu_reply{
2791         u8 smp_frame_type; /* 0x41 */
2792         u8 function; /* 0x01 */
2793         u8 function_result;
2794         u8 response_length;
2795         u16 expander_change_count;
2796         u8 reserved0[2];
2797         u8 sas_format:1;
2798         u8 reserved1:7;
2799         u8 reserved2[3];
2800         u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
2801         u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
2802         u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
2803         u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
2804         u16 component_id;
2805         u8 component_revision_id;
2806         u8 reserved3;
2807         u8 vendor_specific[8];
2808 };
2809
2810 /**
2811   * mptsas_exp_repmanufacture_info -
2812   * @ioc: per adapter object
2813   * @sas_address: expander sas address
2814   * @edev: the sas_expander_device object
2815   *
2816   * Fills in the sas_expander_device object when SMP port is created.
2817   *
2818   * Returns 0 for success, non-zero for failure.
2819   */
2820 static int
2821 mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
2822         u64 sas_address, struct sas_expander_device *edev)
2823 {
2824         MPT_FRAME_HDR *mf;
2825         SmpPassthroughRequest_t *smpreq;
2826         SmpPassthroughReply_t *smprep;
2827         struct rep_manu_reply *manufacture_reply;
2828         struct rep_manu_request *manufacture_request;
2829         int ret;
2830         int flagsLength;
2831         unsigned long timeleft;
2832         char *psge;
2833         unsigned long flags;
2834         void *data_out = NULL;
2835         dma_addr_t data_out_dma = 0;
2836         u32 sz;
2837
2838         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2839         if (ioc->ioc_reset_in_progress) {
2840                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2841                 printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
2842                         __func__, ioc->name);
2843                 return -EFAULT;
2844         }
2845         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2846
2847         ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2848         if (ret)
2849                 goto out;
2850
2851         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2852         if (!mf) {
2853                 ret = -ENOMEM;
2854                 goto out_unlock;
2855         }
2856
2857         smpreq = (SmpPassthroughRequest_t *)mf;
2858         memset(smpreq, 0, sizeof(*smpreq));
2859
2860         sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
2861
2862         data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma);
2863         if (!data_out) {
2864                 printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
2865                         __FILE__, __LINE__, __func__);
2866                 ret = -ENOMEM;
2867                 goto put_mf;
2868         }
2869
2870         manufacture_request = data_out;
2871         manufacture_request->smp_frame_type = 0x40;
2872         manufacture_request->function = 1;
2873         manufacture_request->reserved = 0;
2874         manufacture_request->request_length = 0;
2875
2876         smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2877         smpreq->PhysicalPort = 0xFF;
2878         *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2879         smpreq->RequestDataLength = sizeof(struct rep_manu_request);
2880
2881         psge = (char *)
2882                 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2883
2884         flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2885                 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2886                 MPI_SGE_FLAGS_HOST_TO_IOC |
2887                 MPI_SGE_FLAGS_END_OF_BUFFER;
2888         flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2889         flagsLength |= sizeof(struct rep_manu_request);
2890
2891         ioc->add_sge(psge, flagsLength, data_out_dma);
2892         psge += ioc->SGE_size;
2893
2894         flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2895                 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2896                 MPI_SGE_FLAGS_IOC_TO_HOST |
2897                 MPI_SGE_FLAGS_END_OF_BUFFER;
2898         flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2899         flagsLength |= sizeof(struct rep_manu_reply);
2900         ioc->add_sge(psge, flagsLength, data_out_dma +
2901         sizeof(struct rep_manu_request));
2902
2903         INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2904         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2905
2906         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2907         if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2908                 ret = -ETIME;
2909                 mpt_free_msg_frame(ioc, mf);
2910                 mf = NULL;
2911                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2912                         goto out_free;
2913                 if (!timeleft)
2914                         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2915                 goto out_free;
2916         }
2917
2918         mf = NULL;
2919
2920         if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2921                 u8 *tmp;
2922
2923         smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2924         if (le16_to_cpu(smprep->ResponseDataLength) !=
2925                 sizeof(struct rep_manu_reply))
2926                         goto out_free;
2927
2928         manufacture_reply = data_out + sizeof(struct rep_manu_request);
2929         strncpy(edev->vendor_id, manufacture_reply->vendor_id,
2930                 SAS_EXPANDER_VENDOR_ID_LEN);
2931         strncpy(edev->product_id, manufacture_reply->product_id,
2932                 SAS_EXPANDER_PRODUCT_ID_LEN);
2933         strncpy(edev->product_rev, manufacture_reply->product_rev,
2934                 SAS_EXPANDER_PRODUCT_REV_LEN);
2935         edev->level = manufacture_reply->sas_format;
2936         if (manufacture_reply->sas_format) {
2937                 strncpy(edev->component_vendor_id,
2938                         manufacture_reply->component_vendor_id,
2939                                 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
2940                 tmp = (u8 *)&manufacture_reply->component_id;
2941                 edev->component_id = tmp[0] << 8 | tmp[1];
2942                 edev->component_revision_id =
2943                         manufacture_reply->component_revision_id;
2944                 }
2945         } else {
2946                 printk(MYIOC_s_ERR_FMT
2947                         "%s: smp passthru reply failed to be returned\n",
2948                         ioc->name, __func__);
2949                 ret = -ENXIO;
2950         }
2951 out_free:
2952         if (data_out_dma)
2953                 pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma);
2954 put_mf:
2955         if (mf)
2956                 mpt_free_msg_frame(ioc, mf);
2957 out_unlock:
2958         CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2959         mutex_unlock(&ioc->sas_mgmt.mutex);
2960 out:
2961         return ret;
2962  }
2963
2964 static void
2965 mptsas_parse_device_info(struct sas_identify *identify,
2966                 struct mptsas_devinfo *device_info)
2967 {
2968         u16 protocols;
2969
2970         identify->sas_address = device_info->sas_address;
2971         identify->phy_identifier = device_info->phy_id;
2972
2973         /*
2974          * Fill in Phy Initiator Port Protocol.
2975          * Bits 6:3, more than one bit can be set, fall through cases.
2976          */
2977         protocols = device_info->device_info & 0x78;
2978         identify->initiator_port_protocols = 0;
2979         if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
2980                 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
2981         if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
2982                 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
2983         if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
2984                 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
2985         if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
2986                 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
2987
2988         /*
2989          * Fill in Phy Target Port Protocol.
2990          * Bits 10:7, more than one bit can be set, fall through cases.
2991          */
2992         protocols = device_info->device_info & 0x780;
2993         identify->target_port_protocols = 0;
2994         if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
2995                 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
2996         if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
2997                 identify->target_port_protocols |= SAS_PROTOCOL_STP;
2998         if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
2999                 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
3000         if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
3001                 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
3002
3003         /*
3004          * Fill in Attached device type.
3005          */
3006         switch (device_info->device_info &
3007                         MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
3008         case MPI_SAS_DEVICE_INFO_NO_DEVICE:
3009                 identify->device_type = SAS_PHY_UNUSED;
3010                 break;
3011         case MPI_SAS_DEVICE_INFO_END_DEVICE:
3012                 identify->device_type = SAS_END_DEVICE;
3013                 break;
3014         case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
3015                 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
3016                 break;
3017         case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
3018                 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
3019                 break;
3020         }
3021 }
3022
3023 static int mptsas_probe_one_phy(struct device *dev,
3024                 struct mptsas_phyinfo *phy_info, int index, int local)
3025 {
3026         MPT_ADAPTER *ioc;
3027         struct sas_phy *phy;
3028         struct sas_port *port;
3029         int error = 0;
3030         VirtTarget *vtarget;
3031
3032         if (!dev) {
3033                 error = -ENODEV;
3034                 goto out;
3035         }
3036
3037         if (!phy_info->phy) {
3038                 phy = sas_phy_alloc(dev, index);
3039                 if (!phy) {
3040                         error = -ENOMEM;
3041                         goto out;
3042                 }
3043         } else
3044                 phy = phy_info->phy;
3045
3046         mptsas_parse_device_info(&phy->identify, &phy_info->identify);
3047
3048         /*
3049          * Set Negotiated link rate.
3050          */
3051         switch (phy_info->negotiated_link_rate) {
3052         case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
3053                 phy->negotiated_linkrate = SAS_PHY_DISABLED;
3054                 break;
3055         case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
3056                 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
3057                 break;
3058         case MPI_SAS_IOUNIT0_RATE_1_5:
3059                 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
3060                 break;
3061         case MPI_SAS_IOUNIT0_RATE_3_0:
3062                 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
3063                 break;
3064         case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
3065         case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
3066         default:
3067                 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
3068                 break;
3069         }
3070
3071         /*
3072          * Set Max hardware link rate.
3073          */
3074         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3075         case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
3076                 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3077                 break;
3078         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3079                 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3080                 break;
3081         default:
3082                 break;
3083         }
3084
3085         /*
3086          * Set Max programmed link rate.
3087          */
3088         switch (phy_info->programmed_link_rate &
3089                         MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3090         case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
3091                 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3092                 break;
3093         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3094                 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3095                 break;
3096         default:
3097                 break;
3098         }
3099
3100         /*
3101          * Set Min hardware link rate.
3102          */
3103         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
3104         case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
3105                 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3106                 break;
3107         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3108                 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3109                 break;
3110         default:
3111                 break;
3112         }
3113
3114         /*
3115          * Set Min programmed link rate.
3116          */
3117         switch (phy_info->programmed_link_rate &
3118                         MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
3119         case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
3120                 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3121                 break;
3122         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3123                 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3124                 break;
3125         default:
3126                 break;
3127         }
3128
3129         if (!phy_info->phy) {
3130
3131                 error = sas_phy_add(phy);
3132                 if (error) {
3133                         sas_phy_free(phy);
3134                         goto out;
3135                 }
3136                 phy_info->phy = phy;
3137         }
3138
3139         if (!phy_info->attached.handle ||
3140                         !phy_info->port_details)
3141                 goto out;
3142
3143         port = mptsas_get_port(phy_info);
3144         ioc = phy_to_ioc(phy_info->phy);
3145
3146         if (phy_info->sas_port_add_phy) {
3147
3148                 if (!port) {
3149                         port = sas_port_alloc_num(dev);
3150                         if (!port) {
3151                                 error = -ENOMEM;
3152                                 goto out;
3153                         }
3154                         error = sas_port_add(port);
3155                         if (error) {
3156                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3157                                         "%s: exit at line=%d\n", ioc->name,
3158                                         __func__, __LINE__));
3159                                 goto out;
3160                         }
3161                         mptsas_set_port(ioc, phy_info, port);
3162                         devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
3163                             MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
3164                             ioc->name, port->port_identifier,
3165                             (unsigned long long)phy_info->
3166                             attached.sas_address));
3167                 }
3168                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3169                         "sas_port_add_phy: phy_id=%d\n",
3170                         ioc->name, phy_info->phy_id));
3171                 sas_port_add_phy(port, phy_info->phy);
3172                 phy_info->sas_port_add_phy = 0;
3173                 devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3174                     MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
3175                      phy_info->phy_id, phy_info->phy));
3176         }
3177         if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
3178
3179                 struct sas_rphy *rphy;
3180                 struct device *parent;
3181                 struct sas_identify identify;
3182
3183                 parent = dev->parent->parent;
3184                 /*
3185                  * Let the hotplug_work thread handle processing
3186                  * the adding/removing of devices that occur
3187                  * after start of day.
3188                  */
3189                 if (mptsas_is_end_device(&phy_info->attached) &&
3190                     phy_info->attached.handle_parent) {
3191                         goto out;
3192                 }
3193
3194                 mptsas_parse_device_info(&identify, &phy_info->attached);
3195                 if (scsi_is_host_device(parent)) {
3196                         struct mptsas_portinfo *port_info;
3197                         int i;
3198
3199                         port_info = ioc->hba_port_info;
3200
3201                         for (i = 0; i < port_info->num_phys; i++)
3202                                 if (port_info->phy_info[i].identify.sas_address ==
3203                                     identify.sas_address) {
3204                                         sas_port_mark_backlink(port);
3205                                         goto out;
3206                                 }
3207
3208                 } else if (scsi_is_sas_rphy(parent)) {
3209                         struct sas_rphy *parent_rphy = dev_to_rphy(parent);
3210                         if (identify.sas_address ==
3211                             parent_rphy->identify.sas_address) {
3212                                 sas_port_mark_backlink(port);
3213                                 goto out;
3214                         }
3215                 }
3216
3217                 switch (identify.device_type) {
3218                 case SAS_END_DEVICE:
3219                         rphy = sas_end_device_alloc(port);
3220                         break;
3221                 case SAS_EDGE_EXPANDER_DEVICE:
3222                 case SAS_FANOUT_EXPANDER_DEVICE:
3223                         rphy = sas_expander_alloc(port, identify.device_type);
3224                         break;
3225                 default:
3226                         rphy = NULL;
3227                         break;
3228                 }
3229                 if (!rphy) {
3230                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3231                                 "%s: exit at line=%d\n", ioc->name,
3232                                 __func__, __LINE__));
3233                         goto out;
3234                 }
3235
3236                 rphy->identify = identify;
3237                 error = sas_rphy_add(rphy);
3238                 if (error) {
3239                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3240                                 "%s: exit at line=%d\n", ioc->name,
3241                                 __func__, __LINE__));
3242                         sas_rphy_free(rphy);
3243                         goto out;
3244                 }
3245                 mptsas_set_rphy(ioc, phy_info, rphy);
3246                 if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
3247                         identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
3248                                 mptsas_exp_repmanufacture_info(ioc,
3249                                         identify.sas_address,
3250                                         rphy_to_expander_device(rphy));
3251         }
3252
3253         /* If the device exists,verify it wasn't previously flagged
3254         as a missing device.  If so, clear it */
3255         vtarget = mptsas_find_vtarget(ioc,
3256             phy_info->attached.channel,
3257             phy_info->attached.id);
3258         if (vtarget && vtarget->inDMD) {
3259                 printk(KERN_INFO "Device returned, unsetting inDMD\n");
3260                 vtarget->inDMD = 0;
3261         }
3262
3263  out:
3264         return error;
3265 }
3266
3267 static int
3268 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
3269 {
3270         struct mptsas_portinfo *port_info, *hba;
3271         int error = -ENOMEM, i;
3272
3273         hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3274         if (! hba)
3275                 goto out;
3276
3277         error = mptsas_sas_io_unit_pg0(ioc, hba);
3278         if (error)
3279                 goto out_free_port_info;
3280
3281         mptsas_sas_io_unit_pg1(ioc);
3282         mutex_lock(&ioc->sas_topology_mutex);
3283         port_info = ioc->hba_port_info;
3284         if (!port_info) {
3285                 ioc->hba_port_info = port_info = hba;
3286                 ioc->hba_port_num_phy = port_info->num_phys;
3287                 list_add_tail(&port_info->list, &ioc->sas_topology);
3288         } else {
3289                 for (i = 0; i < hba->num_phys; i++) {
3290                         port_info->phy_info[i].negotiated_link_rate =
3291                                 hba->phy_info[i].negotiated_link_rate;
3292                         port_info->phy_info[i].handle =
3293                                 hba->phy_info[i].handle;
3294                         port_info->phy_info[i].port_id =
3295                                 hba->phy_info[i].port_id;
3296                 }
3297                 kfree(hba->phy_info);
3298                 kfree(hba);
3299                 hba = NULL;
3300         }
3301         mutex_unlock(&ioc->sas_topology_mutex);
3302 #if defined(CPQ_CIM)
3303         ioc->num_ports = port_info->num_phys;
3304 #endif
3305         for (i = 0; i < port_info->num_phys; i++) {
3306                 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
3307                         (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
3308                          MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
3309                 port_info->phy_info[i].identify.handle =
3310                     port_info->phy_info[i].handle;
3311                 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
3312                         (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3313                          MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3314                          port_info->phy_info[i].identify.handle);
3315                 if (!ioc->hba_port_sas_addr)
3316                         ioc->hba_port_sas_addr =
3317                             port_info->phy_info[i].identify.sas_address;
3318                 port_info->phy_info[i].identify.phy_id =
3319                     port_info->phy_info[i].phy_id = i;
3320                 if (port_info->phy_info[i].attached.handle)
3321                         mptsas_sas_device_pg0(ioc,
3322                                 &port_info->phy_info[i].attached,
3323                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3324                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3325                                 port_info->phy_info[i].attached.handle);
3326         }
3327
3328         mptsas_setup_wide_ports(ioc, port_info);
3329
3330         for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3331                 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
3332                     &port_info->phy_info[i], ioc->sas_index, 1);
3333
3334         return 0;
3335
3336  out_free_port_info:
3337         kfree(hba);
3338  out:
3339         return error;
3340 }
3341
3342 static void
3343 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
3344 {
3345         struct mptsas_portinfo *parent;
3346         struct device *parent_dev;
3347         struct sas_rphy *rphy;
3348         int             i;
3349         u64             sas_address; /* expander sas address */
3350         u32             handle;
3351
3352         handle = port_info->phy_info[0].handle;
3353         sas_address = port_info->phy_info[0].identify.sas_address;
3354         for (i = 0; i < port_info->num_phys; i++) {
3355                 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
3356                     (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
3357                     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
3358
3359                 mptsas_sas_device_pg0(ioc,
3360                     &port_info->phy_info[i].identify,
3361                     (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3362                     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3363                     port_info->phy_info[i].identify.handle);
3364                 port_info->phy_info[i].identify.phy_id =
3365                     port_info->phy_info[i].phy_id;
3366
3367                 if (port_info->phy_info[i].attached.handle) {
3368                         mptsas_sas_device_pg0(ioc,
3369                             &port_info->phy_info[i].attached,
3370                             (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3371                              MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3372                             port_info->phy_info[i].attached.handle);
3373                         port_info->phy_info[i].attached.phy_id =
3374                             port_info->phy_info[i].phy_id;
3375                 }
3376         }
3377
3378         mutex_lock(&ioc->sas_topology_mutex);
3379         parent = mptsas_find_portinfo_by_handle(ioc,
3380             port_info->phy_info[0].identify.handle_parent);
3381         if (!parent) {
3382                 mutex_unlock(&ioc->sas_topology_mutex);
3383                 return;
3384         }
3385         for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
3386             i++) {
3387                 if (parent->phy_info[i].attached.sas_address == sas_address) {
3388                         rphy = mptsas_get_rphy(&parent->phy_info[i]);
3389                         parent_dev = &rphy->dev;
3390                 }
3391         }
3392         mutex_unlock(&ioc->sas_topology_mutex);
3393
3394         mptsas_setup_wide_ports(ioc, port_info);
3395         for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3396                 mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
3397                     ioc->sas_index, 0);
3398 }
3399
3400 static void
3401 mptsas_expander_event_add(MPT_ADAPTER *ioc,
3402     MpiEventDataSasExpanderStatusChange_t *expander_data)
3403 {
3404         struct mptsas_portinfo *port_info;
3405         int i;
3406         __le64 sas_address;
3407
3408         port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3409         if (!port_info)
3410                 BUG();
3411         port_info->num_phys = (expander_data->NumPhys) ?
3412             expander_data->NumPhys : 1;
3413         port_info->phy_info = kcalloc(port_info->num_phys,
3414             sizeof(struct mptsas_phyinfo), GFP_KERNEL);
3415         if (!port_info->phy_info)
3416                 BUG();
3417         memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3418         for (i = 0; i < port_info->num_phys; i++) {
3419                 port_info->phy_info[i].portinfo = port_info;
3420                 port_info->phy_info[i].handle =
3421                     le16_to_cpu(expander_data->DevHandle);
3422                 port_info->phy_info[i].identify.sas_address =
3423                     le64_to_cpu(sas_address);
3424                 port_info->phy_info[i].identify.handle_parent =
3425                     le16_to_cpu(expander_data->ParentDevHandle);
3426         }
3427
3428         mutex_lock(&ioc->sas_topology_mutex);
3429         list_add_tail(&port_info->list, &ioc->sas_topology);
3430         mutex_unlock(&ioc->sas_topology_mutex);
3431
3432         printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3433             "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3434             (unsigned long long)sas_address);
3435
3436         mptsas_expander_refresh(ioc, port_info);
3437 }
3438
3439 /**
3440  * mptsas_delete_expander_siblings - remove siblings attached to expander
3441  * @ioc: Pointer to MPT_ADAPTER structure
3442  * @parent: the parent port_info object
3443  * @expander: the expander port_info object
3444  **/
3445 static void
3446 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
3447     *parent, struct mptsas_portinfo *expander)
3448 {
3449         struct mptsas_phyinfo *phy_info;
3450         struct mptsas_portinfo *port_info;
3451         struct sas_rphy *rphy;
3452         int i;
3453
3454         phy_info = expander->phy_info;
3455         for (i = 0; i < expander->num_phys; i++, phy_info++) {
3456                 rphy = mptsas_get_rphy(phy_info);
3457                 if (!rphy)
3458                         continue;
3459                 if (rphy->identify.device_type == SAS_END_DEVICE)
3460                         mptsas_del_end_device(ioc, phy_info);
3461         }
3462
3463         phy_info = expander->phy_info;
3464         for (i = 0; i < expander->num_phys; i++, phy_info++) {
3465                 rphy = mptsas_get_rphy(phy_info);
3466                 if (!rphy)
3467                         continue;
3468                 if (rphy->identify.device_type ==
3469                     MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
3470                     rphy->identify.device_type ==
3471                     MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
3472                         port_info = mptsas_find_portinfo_by_sas_address(ioc,
3473                             rphy->identify.sas_address);
3474                         if (!port_info)
3475                                 continue;
3476                         if (port_info == parent) /* backlink rphy */
3477                                 continue;
3478                         /*
3479                         Delete this expander even if the expdevpage is exists
3480                         because the parent expander is already deleted
3481                         */
3482                         mptsas_expander_delete(ioc, port_info, 1);
3483                 }
3484         }
3485 }
3486
3487
3488 /**
3489  *      mptsas_expander_delete - remove this expander
3490  *      @ioc: Pointer to MPT_ADAPTER structure
3491  *      @port_info: expander port_info struct
3492  *      @force: Flag to forcefully delete the expander
3493  *
3494  **/
3495
3496 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
3497                 struct mptsas_portinfo *port_info, u8 force)
3498 {
3499
3500         struct mptsas_portinfo *parent;
3501         int             i;
3502         u64             expander_sas_address;
3503         struct mptsas_phyinfo *phy_info;
3504         struct mptsas_portinfo buffer;
3505         struct mptsas_portinfo_details *port_details;
3506         struct sas_port *port;
3507
3508         if (!port_info)
3509                 return;
3510
3511         /* see if expander is still there before deleting */
3512         mptsas_sas_expander_pg0(ioc, &buffer,
3513             (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3514             MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
3515             port_info->phy_info[0].identify.handle);
3516
3517         if (buffer.num_phys) {
3518                 kfree(buffer.phy_info);
3519                 if (!force)
3520                         return;
3521         }
3522
3523
3524         /*
3525          * Obtain the port_info instance to the parent port
3526          */
3527         port_details = NULL;
3528         expander_sas_address =
3529             port_info->phy_info[0].identify.sas_address;
3530         parent = mptsas_find_portinfo_by_handle(ioc,
3531             port_info->phy_info[0].identify.handle_parent);
3532         mptsas_delete_expander_siblings(ioc, parent, port_info);
3533         if (!parent)
3534                 goto out;
3535
3536         /*
3537          * Delete rphys in the parent that point
3538          * to this expander.
3539          */
3540         phy_info = parent->phy_info;
3541         port = NULL;
3542         for (i = 0; i < parent->num_phys; i++, phy_info++) {
3543                 if (!phy_info->phy)
3544                         continue;
3545                 if (phy_info->attached.sas_address !=
3546                     expander_sas_address)
3547                         continue;
3548                 if (!port) {
3549                         port = mptsas_get_port(phy_info);
3550                         port_details = phy_info->port_details;
3551                 }
3552                 dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3553                     MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
3554                     phy_info->phy_id, phy_info->phy);
3555                 sas_port_delete_phy(port, phy_info->phy);
3556         }
3557         if (port) {
3558                 dev_printk(KERN_DEBUG, &port->dev,
3559                     MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
3560                     ioc->name, port->port_identifier,
3561                     (unsigned long long)expander_sas_address);
3562                 sas_port_delete(port);
3563                 mptsas_port_delete(ioc, port_details);
3564         }
3565  out:
3566
3567         printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
3568             "sas_addr (0x%llx)\n",  ioc->name, port_info->num_phys,
3569             (unsigned long long)expander_sas_address);
3570
3571         /*
3572          * free link
3573          */
3574         list_del(&port_info->list);
3575         kfree(port_info->phy_info);
3576         kfree(port_info);
3577 }
3578
3579
3580 /**
3581  * mptsas_send_expander_event - expanders events
3582  * @ioc: Pointer to MPT_ADAPTER structure
3583  * @expander_data: event data
3584  *
3585  *
3586  * This function handles adding, removing, and refreshing
3587  * device handles within the expander objects.
3588  */
3589 static void
3590 mptsas_send_expander_event(struct fw_event_work *fw_event)
3591 {
3592         MPT_ADAPTER *ioc;
3593         MpiEventDataSasExpanderStatusChange_t *expander_data;
3594         struct mptsas_portinfo *port_info;
3595         __le64 sas_address;
3596         int i;
3597
3598         ioc = fw_event->ioc;
3599         expander_data = (MpiEventDataSasExpanderStatusChange_t *)
3600             fw_event->event_data;
3601         memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3602         sas_address = le64_to_cpu(sas_address);
3603         port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3604
3605         if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
3606                 if (port_info) {
3607                         for (i = 0; i < port_info->num_phys; i++) {
3608                                 port_info->phy_info[i].portinfo = port_info;
3609                                 port_info->phy_info[i].handle =
3610                                     le16_to_cpu(expander_data->DevHandle);
3611                                 port_info->phy_info[i].identify.sas_address =
3612                                     le64_to_cpu(sas_address);
3613                                 port_info->phy_info[i].identify.handle_parent =
3614                                     le16_to_cpu(expander_data->ParentDevHandle);
3615                         }
3616                         mptsas_expander_refresh(ioc, port_info);
3617                 } else if (!port_info && expander_data->NumPhys)
3618                         mptsas_expander_event_add(ioc, expander_data);
3619         } else if (expander_data->ReasonCode ==
3620             MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
3621                 mptsas_expander_delete(ioc, port_info, 0);
3622
3623         mptsas_free_fw_event(ioc, fw_event);
3624 }
3625
3626
3627 /**
3628  * mptsas_expander_add -
3629  * @ioc: Pointer to MPT_ADAPTER structure
3630  * @handle:
3631  *
3632  */
3633 struct mptsas_portinfo *
3634 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
3635 {
3636         struct mptsas_portinfo buffer, *port_info;
3637         int i;
3638
3639         if ((mptsas_sas_expander_pg0(ioc, &buffer,
3640             (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3641             MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
3642                 return NULL;
3643
3644         port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC);
3645         if (!port_info) {
3646                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3647                 "%s: exit at line=%d\n", ioc->name,
3648                 __func__, __LINE__));
3649                 return NULL;
3650         }
3651         port_info->num_phys = buffer.num_phys;
3652         port_info->phy_info = buffer.phy_info;
3653         for (i = 0; i < port_info->num_phys; i++)
3654                 port_info->phy_info[i].portinfo = port_info;
3655         mutex_lock(&ioc->sas_topology_mutex);
3656         list_add_tail(&port_info->list, &ioc->sas_topology);
3657         mutex_unlock(&ioc->sas_topology_mutex);
3658         printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3659             "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3660             (unsigned long long)buffer.phy_info[0].identify.sas_address);
3661         mptsas_expander_refresh(ioc, port_info);
3662         return port_info;
3663 }
3664
3665 static void
3666 mptsas_send_link_status_event(struct fw_event_work *fw_event)
3667 {
3668         MPT_ADAPTER *ioc;
3669         MpiEventDataSasPhyLinkStatus_t *link_data;
3670         struct mptsas_portinfo *port_info;
3671         struct mptsas_phyinfo *phy_info = NULL;
3672         __le64 sas_address;
3673         u8 phy_num;
3674         u8 link_rate;
3675
3676         ioc = fw_event->ioc;
3677         link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
3678
3679         memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
3680         sas_address = le64_to_cpu(sas_address);
3681         link_rate = link_data->LinkRates >> 4;
3682         phy_num = link_data->PhyNum;
3683
3684         port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3685         if (port_info) {
3686                 phy_info = &port_info->phy_info[phy_num];
3687                 if (phy_info)
3688                         phy_info->negotiated_link_rate = link_rate;
3689         }
3690
3691         if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
3692             link_rate == MPI_SAS_IOUNIT0_RATE_3_0) {
3693
3694                 if (!port_info) {
3695                         if (ioc->old_sas_discovery_protocal) {
3696                                 port_info = mptsas_expander_add(ioc,
3697                                         le16_to_cpu(link_data->DevHandle));
3698                                 if (port_info)
3699                                         goto out;
3700                         }
3701                         goto out;
3702                 }
3703
3704                 if (port_info == ioc->hba_port_info)
3705                         mptsas_probe_hba_phys(ioc);
3706                 else
3707                         mptsas_expander_refresh(ioc, port_info);
3708         } else if (phy_info && phy_info->phy) {
3709                 if (link_rate ==  MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
3710                         phy_info->phy->negotiated_linkrate =
3711                             SAS_PHY_DISABLED;
3712                 else if (link_rate ==
3713                     MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
3714                         phy_info->phy->negotiated_linkrate =
3715                             SAS_LINK_RATE_FAILED;
3716                 else {
3717                         phy_info->phy->negotiated_linkrate =
3718                             SAS_LINK_RATE_UNKNOWN;
3719                         if (ioc->device_missing_delay &&
3720                             mptsas_is_end_device(&phy_info->attached)) {
3721                                 struct scsi_device              *sdev;
3722                                 VirtDevice                      *vdevice;
3723                                 u8      channel, id;
3724                                 id = phy_info->attached.id;
3725                                 channel = phy_info->attached.channel;
3726                                 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3727                                 "Link down for fw_id %d:fw_channel %d\n",
3728                                     ioc->name, phy_info->attached.id,
3729                                     phy_info->attached.channel));
3730
3731                                 shost_for_each_device(sdev, ioc->sh) {
3732                                         vdevice = sdev->hostdata;
3733                                         if ((vdevice == NULL) ||
3734                                                 (vdevice->vtarget == NULL))
3735                                                 continue;
3736                                         if ((vdevice->vtarget->tflags &
3737                                             MPT_TARGET_FLAGS_RAID_COMPONENT ||
3738                                             vdevice->vtarget->raidVolume))
3739                                                 continue;
3740                                         if (vdevice->vtarget->id == id &&
3741                                                 vdevice->vtarget->channel ==
3742                                                 channel)
3743                                                 devtprintk(ioc,
3744                                                 printk(MYIOC_s_DEBUG_FMT
3745                                                 "SDEV OUTSTANDING CMDS"
3746                                                 "%d\n", ioc->name,
3747                                                 sdev->device_busy));
3748                                 }
3749
3750                         }
3751                 }
3752         }
3753  out:
3754         mptsas_free_fw_event(ioc, fw_event);
3755 }
3756
3757 static void
3758 mptsas_not_responding_devices(MPT_ADAPTER *ioc)
3759 {
3760         struct mptsas_portinfo buffer, *port_info;
3761         struct mptsas_device_info       *sas_info;
3762         struct mptsas_devinfo sas_device;
3763         u32     handle;
3764         VirtTarget *vtarget = NULL;
3765         struct mptsas_phyinfo *phy_info;
3766         u8 found_expander;
3767         int retval, retry_count;
3768         unsigned long flags;
3769
3770         mpt_findImVolumes(ioc);
3771
3772         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3773         if (ioc->ioc_reset_in_progress) {
3774                 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3775                    "%s: exiting due to a parallel reset \n", ioc->name,
3776                     __func__));
3777                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3778                 return;
3779         }
3780         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3781
3782         /* devices, logical volumes */
3783         mutex_lock(&ioc->sas_device_info_mutex);
3784  redo_device_scan:
3785         list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
3786                 if (sas_info->is_cached)
3787                         continue;
3788                 if (!sas_info->is_logical_volume) {
3789                         sas_device.handle = 0;
3790                         retry_count = 0;
3791 retry_page:
3792                         retval = mptsas_sas_device_pg0(ioc, &sas_device,
3793                                 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID
3794                                 << MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3795                                 (sas_info->fw.channel << 8) +
3796                                 sas_info->fw.id);
3797
3798                         if (sas_device.handle)
3799                                 continue;
3800                         if (retval == -EBUSY) {
3801                                 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3802                                 if (ioc->ioc_reset_in_progress) {
3803                                         dfailprintk(ioc,
3804                                         printk(MYIOC_s_DEBUG_FMT
3805                                         "%s: exiting due to reset\n",
3806                                         ioc->name, __func__));
3807                                         spin_unlock_irqrestore
3808                                         (&ioc->taskmgmt_lock, flags);
3809                                         mutex_unlock(&ioc->
3810                                         sas_device_info_mutex);
3811                                         return;
3812                                 }
3813                                 spin_unlock_irqrestore(&ioc->taskmgmt_lock,
3814                                 flags);
3815                         }
3816
3817                         if (retval && (retval != -ENODEV)) {
3818                                 if (retry_count < 10) {
3819                                         retry_count++;
3820                                         goto retry_page;
3821                                 } else {
3822                                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3823                                         "%s: Config page retry exceeded retry "
3824                                         "count deleting device 0x%llx\n",
3825                                         ioc->name, __func__,
3826                                         sas_info->sas_address));
3827                                 }
3828                         }
3829
3830                         /* delete device */
3831                         vtarget = mptsas_find_vtarget(ioc,
3832                                 sas_info->fw.channel, sas_info->fw.id);
3833
3834                         if (vtarget)
3835                                 vtarget->deleted = 1;
3836
3837                         phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
3838                                         sas_info->sas_address);
3839
3840                         if (phy_info) {
3841                                 mptsas_del_end_device(ioc, phy_info);
3842                                 goto redo_device_scan;
3843                         }
3844                 } else
3845                         mptsas_volume_delete(ioc, sas_info->fw.id);
3846         }
3847         mutex_unlock(&ioc->sas_device_info_mutex);
3848
3849         /* expanders */
3850         mutex_lock(&ioc->sas_topology_mutex);
3851  redo_expander_scan:
3852         list_for_each_entry(port_info, &ioc->sas_topology, list) {
3853
3854                 if (port_info->phy_info &&
3855                     (!(port_info->phy_info[0].identify.device_info &
3856                     MPI_SAS_DEVICE_INFO_SMP_TARGET)))
3857                         continue;
3858                 found_expander = 0;
3859                 handle = 0xFFFF;
3860                 while (!mptsas_sas_expander_pg0(ioc, &buffer,
3861                     (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3862                      MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
3863                     !found_expander) {
3864
3865                         handle = buffer.phy_info[0].handle;
3866                         if (buffer.phy_info[0].identify.sas_address ==
3867                             port_info->phy_info[0].identify.sas_address) {
3868                                 found_expander = 1;
3869                         }
3870                         kfree(buffer.phy_info);
3871                 }
3872
3873                 if (!found_expander) {
3874                         mptsas_expander_delete(ioc, port_info, 0);
3875                         goto redo_expander_scan;
3876                 }
3877         }
3878         mutex_unlock(&ioc->sas_topology_mutex);
3879 }
3880
3881 /**
3882  *      mptsas_probe_expanders - adding expanders
3883  *      @ioc: Pointer to MPT_ADAPTER structure
3884  *
3885  **/
3886 static void
3887 mptsas_probe_expanders(MPT_ADAPTER *ioc)
3888 {
3889         struct mptsas_portinfo buffer, *port_info;
3890         u32                     handle;
3891         int i;
3892
3893         handle = 0xFFFF;
3894         while (!mptsas_sas_expander_pg0(ioc, &buffer,
3895             (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3896              MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
3897
3898                 handle = buffer.phy_info[0].handle;
3899                 port_info = mptsas_find_portinfo_by_sas_address(ioc,
3900                     buffer.phy_info[0].identify.sas_address);
3901
3902                 if (port_info) {
3903                         /* refreshing handles */
3904                         for (i = 0; i < buffer.num_phys; i++) {
3905                                 port_info->phy_info[i].handle = handle;
3906                                 port_info->phy_info[i].identify.handle_parent =
3907                                     buffer.phy_info[0].identify.handle_parent;
3908                         }
3909                         mptsas_expander_refresh(ioc, port_info);
3910                         kfree(buffer.phy_info);
3911                         continue;
3912                 }
3913
3914                 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3915                 if (!port_info) {
3916                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3917                         "%s: exit at line=%d\n", ioc->name,
3918                         __func__, __LINE__));
3919                         return;
3920                 }
3921                 port_info->num_phys = buffer.num_phys;
3922                 port_info->phy_info = buffer.phy_info;
3923                 for (i = 0; i < port_info->num_phys; i++)
3924                         port_info->phy_info[i].portinfo = port_info;
3925                 mutex_lock(&ioc->sas_topology_mutex);
3926                 list_add_tail(&port_info->list, &ioc->sas_topology);
3927                 mutex_unlock(&ioc->sas_topology_mutex);
3928                 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3929                     "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3930             (unsigned long long)buffer.phy_info[0].identify.sas_address);
3931                 mptsas_expander_refresh(ioc, port_info);
3932         }
3933 }
3934
3935 static void
3936 mptsas_probe_devices(MPT_ADAPTER *ioc)
3937 {
3938         u16 handle;
3939         struct mptsas_devinfo sas_device;
3940         struct mptsas_phyinfo *phy_info;
3941
3942         handle = 0xFFFF;
3943         while (!(mptsas_sas_device_pg0(ioc, &sas_device,
3944             MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
3945
3946                 handle = sas_device.handle;
3947
3948                 if ((sas_device.device_info &
3949                      (MPI_SAS_DEVICE_INFO_SSP_TARGET |
3950                       MPI_SAS_DEVICE_INFO_STP_TARGET |
3951                       MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
3952                         continue;
3953
3954                 /* If there is no FW B_T mapping for this device then continue
3955                  * */
3956                 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
3957                         || !(sas_device.flags &
3958                         MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
3959                         continue;
3960
3961                 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
3962                 if (!phy_info)
3963                         continue;
3964
3965                 if (mptsas_get_rphy(phy_info))
3966                         continue;
3967
3968                 mptsas_add_end_device(ioc, phy_info);
3969         }
3970 }
3971
3972 /**
3973  *      mptsas_scan_sas_topology -
3974  *      @ioc: Pointer to MPT_ADAPTER structure
3975  *      @sas_address:
3976  *
3977  **/
3978 static void
3979 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
3980 {
3981         struct scsi_device *sdev;
3982         int i;
3983
3984         mptsas_probe_hba_phys(ioc);
3985         mptsas_probe_expanders(ioc);
3986         mptsas_probe_devices(ioc);
3987
3988         /*
3989           Reporting RAID volumes.
3990         */
3991         if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
3992             !ioc->raid_data.pIocPg2->NumActiveVolumes)
3993                 return;
3994         for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
3995                 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
3996                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
3997                 if (sdev) {
3998                         scsi_device_put(sdev);
3999                         continue;
4000                 }
4001                 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4002                     "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4003                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
4004                 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4005                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4006         }
4007 }
4008
4009
4010 static void
4011 mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
4012 {
4013         MPT_ADAPTER *ioc;
4014         EventDataQueueFull_t *qfull_data;
4015         struct mptsas_device_info *sas_info;
4016         struct scsi_device      *sdev;
4017         int depth;
4018         int id = -1;
4019         int channel = -1;
4020         int fw_id, fw_channel;
4021         u16 current_depth;
4022
4023
4024         ioc = fw_event->ioc;
4025         qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
4026         fw_id = qfull_data->TargetID;
4027         fw_channel = qfull_data->Bus;
4028         current_depth = le16_to_cpu(qfull_data->CurrentDepth);
4029
4030         /* if hidden raid component, look for the volume id */
4031         mutex_lock(&ioc->sas_device_info_mutex);
4032         if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
4033                 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4034                     list) {
4035                         if (sas_info->is_cached ||
4036                             sas_info->is_logical_volume)
4037                                 continue;
4038                         if (sas_info->is_hidden_raid_component &&
4039                             (sas_info->fw.channel == fw_channel &&
4040                             sas_info->fw.id == fw_id)) {
4041                                 id = sas_info->volume_id;
4042                                 channel = MPTSAS_RAID_CHANNEL;
4043                                 goto out;
4044                         }
4045                 }
4046         } else {
4047                 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4048                     list) {
4049                         if (sas_info->is_cached ||
4050                             sas_info->is_hidden_raid_component ||
4051                             sas_info->is_logical_volume)
4052                                 continue;
4053                         if (sas_info->fw.channel == fw_channel &&
4054                             sas_info->fw.id == fw_id) {
4055                                 id = sas_info->os.id;
4056                                 channel = sas_info->os.channel;
4057                                 goto out;
4058                         }
4059                 }
4060
4061         }
4062
4063  out:
4064         mutex_unlock(&ioc->sas_device_info_mutex);
4065
4066         if (id != -1) {
4067                 shost_for_each_device(sdev, ioc->sh) {
4068                         if (sdev->id == id && sdev->channel == channel) {
4069                                 if (current_depth > sdev->queue_depth) {
4070                                         sdev_printk(KERN_INFO, sdev,
4071                                             "strange observation, the queue "
4072                                             "depth is (%d) meanwhile fw queue "
4073                                             "depth (%d)\n", sdev->queue_depth,
4074                                             current_depth);
4075                                         continue;
4076                                 }
4077                                 depth = scsi_track_queue_full(sdev,
4078                                     current_depth - 1);
4079                                 if (depth > 0)
4080                                         sdev_printk(KERN_INFO, sdev,
4081                                         "Queue depth reduced to (%d)\n",
4082                                            depth);
4083                                 else if (depth < 0)
4084                                         sdev_printk(KERN_INFO, sdev,
4085                                         "Tagged Command Queueing is being "
4086                                         "disabled\n");
4087                                 else if (depth == 0)
4088                                         sdev_printk(KERN_INFO, sdev,
4089                                         "Queue depth not changed yet\n");
4090                         }
4091                 }
4092         }
4093
4094         mptsas_free_fw_event(ioc, fw_event);
4095 }
4096
4097
4098 static struct mptsas_phyinfo *
4099 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
4100 {
4101         struct mptsas_portinfo *port_info;
4102         struct mptsas_phyinfo *phy_info = NULL;
4103         int i;
4104
4105         mutex_lock(&ioc->sas_topology_mutex);
4106         list_for_each_entry(port_info, &ioc->sas_topology, list) {
4107                 for (i = 0; i < port_info->num_phys; i++) {
4108                         if (!mptsas_is_end_device(
4109                                 &port_info->phy_info[i].attached))
4110                                 continue;
4111                         if (port_info->phy_info[i].attached.sas_address
4112                             != sas_address)
4113                                 continue;
4114                         phy_info = &port_info->phy_info[i];
4115                         break;
4116                 }
4117         }
4118         mutex_unlock(&ioc->sas_topology_mutex);
4119         return phy_info;
4120 }
4121
4122 /**
4123  *      mptsas_find_phyinfo_by_phys_disk_num -
4124  *      @ioc: Pointer to MPT_ADAPTER structure
4125  *      @phys_disk_num:
4126  *      @channel:
4127  *      @id:
4128  *
4129  **/
4130 static struct mptsas_phyinfo *
4131 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
4132         u8 channel, u8 id)
4133 {
4134         struct mptsas_phyinfo *phy_info = NULL;
4135         struct mptsas_portinfo *port_info;
4136         RaidPhysDiskPage1_t *phys_disk = NULL;
4137         int num_paths;
4138         u64 sas_address = 0;
4139         int i;
4140
4141         phy_info = NULL;
4142         if (!ioc->raid_data.pIocPg3)
4143                 return NULL;
4144         /* dual port support */
4145         num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
4146         if (!num_paths)
4147                 goto out;
4148         phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
4149            (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
4150         if (!phys_disk)
4151                 goto out;
4152         mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
4153         for (i = 0; i < num_paths; i++) {
4154                 if ((phys_disk->Path[i].Flags & 1) != 0)
4155                         /* entry no longer valid */
4156                         continue;
4157                 if ((id == phys_disk->Path[i].PhysDiskID) &&
4158                     (channel == phys_disk->Path[i].PhysDiskBus)) {
4159                         memcpy(&sas_address, &phys_disk->Path[i].WWID,
4160                                 sizeof(u64));
4161                         phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4162                                         sas_address);
4163                         goto out;
4164                 }
4165         }
4166
4167  out:
4168         kfree(phys_disk);
4169         if (phy_info)
4170                 return phy_info;
4171
4172         /*
4173          * Extra code to handle RAID0 case, where the sas_address is not updated
4174          * in phys_disk_page_1 when hotswapped
4175          */
4176         mutex_lock(&ioc->sas_topology_mutex);
4177         list_for_each_entry(port_info, &ioc->sas_topology, list) {
4178                 for (i = 0; i < port_info->num_phys && !phy_info; i++) {
4179                         if (!mptsas_is_end_device(
4180                                 &port_info->phy_info[i].attached))
4181                                 continue;
4182                         if (port_info->phy_info[i].attached.phys_disk_num == ~0)
4183                                 continue;
4184                         if ((port_info->phy_info[i].attached.phys_disk_num ==
4185                             phys_disk_num) &&
4186                             (port_info->phy_info[i].attached.id == id) &&
4187                             (port_info->phy_info[i].attached.channel ==
4188                              channel))
4189                                 phy_info = &port_info->phy_info[i];
4190                 }
4191         }
4192         mutex_unlock(&ioc->sas_topology_mutex);
4193         return phy_info;
4194 }
4195
4196 static void
4197 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
4198 {
4199         int rc;
4200
4201         sdev->no_uld_attach = data ? 1 : 0;
4202         rc = scsi_device_reprobe(sdev);
4203 }
4204
4205 static void
4206 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
4207 {
4208         starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
4209                         mptsas_reprobe_lun);
4210 }
4211
4212 static void
4213 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
4214 {
4215         CONFIGPARMS                     cfg;
4216         ConfigPageHeader_t              hdr;
4217         dma_addr_t                      dma_handle;
4218         pRaidVolumePage0_t              buffer = NULL;
4219         RaidPhysDiskPage0_t             phys_disk;
4220         int                             i;
4221         struct mptsas_phyinfo   *phy_info;
4222         struct mptsas_devinfo           sas_device;
4223
4224         memset(&cfg, 0 , sizeof(CONFIGPARMS));
4225         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
4226         hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
4227         cfg.pageAddr = (channel << 8) + id;
4228         cfg.cfghdr.hdr = &hdr;
4229         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4230         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
4231
4232         if (mpt_config(ioc, &cfg) != 0)
4233                 goto out;
4234
4235         if (!hdr.PageLength)
4236                 goto out;
4237
4238         buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
4239             &dma_handle);
4240
4241         if (!buffer)
4242                 goto out;
4243
4244         cfg.physAddr = dma_handle;
4245         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4246
4247         if (mpt_config(ioc, &cfg) != 0)
4248                 goto out;
4249
4250         if (!(buffer->VolumeStatus.Flags &
4251             MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
4252                 goto out;
4253
4254         if (!buffer->NumPhysDisks)
4255                 goto out;
4256
4257         for (i = 0; i < buffer->NumPhysDisks; i++) {
4258
4259                 if (mpt_raid_phys_disk_pg0(ioc,
4260                     buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
4261                         continue;
4262
4263                 if (mptsas_sas_device_pg0(ioc, &sas_device,
4264                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4265                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4266                         (phys_disk.PhysDiskBus << 8) +
4267                         phys_disk.PhysDiskID))
4268                         continue;
4269
4270                 /* If there is no FW B_T mapping for this device then continue
4271                  * */
4272                 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4273                         || !(sas_device.flags &
4274                         MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4275                         continue;
4276
4277
4278                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4279                     sas_device.sas_address);
4280                 mptsas_add_end_device(ioc, phy_info);
4281         }
4282
4283  out:
4284         if (buffer)
4285                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
4286                     dma_handle);
4287 }
4288 /*
4289  * Work queue thread to handle SAS hotplug events
4290  */
4291 static void
4292 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
4293     struct mptsas_hotplug_event *hot_plug_info)
4294 {
4295         struct mptsas_phyinfo *phy_info;
4296         struct scsi_target * starget;
4297         struct mptsas_devinfo sas_device;
4298         VirtTarget *vtarget;
4299         int i;
4300         struct mptsas_portinfo *port_info;
4301
4302         switch (hot_plug_info->event_type) {
4303
4304         case MPTSAS_ADD_PHYSDISK:
4305
4306                 if (!ioc->raid_data.pIocPg2)
4307                         break;
4308
4309                 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4310                         if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
4311                             hot_plug_info->id) {
4312                                 printk(MYIOC_s_WARN_FMT "firmware bug: unable "
4313                                     "to add hidden disk - target_id matchs "
4314                                     "volume_id\n", ioc->name);
4315                                 mptsas_free_fw_event(ioc, fw_event);
4316                                 return;
4317                         }
4318                 }
4319                 mpt_findImVolumes(ioc);
4320
4321         case MPTSAS_ADD_DEVICE:
4322                 memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
4323                 mptsas_sas_device_pg0(ioc, &sas_device,
4324                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4325                     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4326                     (hot_plug_info->channel << 8) +
4327                     hot_plug_info->id);
4328
4329                 /* If there is no FW B_T mapping for this device then break
4330                  * */
4331                 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4332                         || !(sas_device.flags &
4333                         MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4334                         break;
4335
4336                 if (!sas_device.handle)
4337                         return;
4338
4339                 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
4340                 /* Only For SATA Device ADD */
4341                 if (!phy_info && (sas_device.device_info &
4342                                 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) {
4343                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4344                                 "%s %d SATA HOT PLUG: "
4345                                 "parent handle of device %x\n", ioc->name,
4346                                 __func__, __LINE__, sas_device.handle_parent));
4347                         port_info = mptsas_find_portinfo_by_handle(ioc,
4348                                 sas_device.handle_parent);
4349
4350                         if (port_info == ioc->hba_port_info)
4351                                 mptsas_probe_hba_phys(ioc);
4352                         else if (port_info)
4353                                 mptsas_expander_refresh(ioc, port_info);
4354                         else {
4355                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4356                                         "%s %d port info is NULL\n",
4357                                         ioc->name, __func__, __LINE__));
4358                                 break;
4359                         }
4360                         phy_info = mptsas_refreshing_device_handles
4361                                 (ioc, &sas_device);
4362                 }
4363
4364                 if (!phy_info) {
4365                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4366                                 "%s %d phy info is NULL\n",
4367                                 ioc->name, __func__, __LINE__));
4368                         break;
4369                 }
4370
4371                 if (mptsas_get_rphy(phy_info))
4372                         break;
4373
4374                 mptsas_add_end_device(ioc, phy_info);
4375                 break;
4376
4377         case MPTSAS_DEL_DEVICE:
4378                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4379                     hot_plug_info->sas_address);
4380                 mptsas_del_end_device(ioc, phy_info);
4381                 break;
4382
4383         case MPTSAS_DEL_PHYSDISK:
4384
4385                 mpt_findImVolumes(ioc);
4386
4387                 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
4388                                 ioc, hot_plug_info->phys_disk_num,
4389                                 hot_plug_info->channel,
4390                                 hot_plug_info->id);
4391                 mptsas_del_end_device(ioc, phy_info);
4392                 break;
4393
4394         case MPTSAS_ADD_PHYSDISK_REPROBE:
4395
4396                 if (mptsas_sas_device_pg0(ioc, &sas_device,
4397                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4398                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4399                     (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4400                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4401                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
4402                                  __func__, hot_plug_info->id, __LINE__));
4403                         break;
4404                 }
4405
4406                 /* If there is no FW B_T mapping for this device then break
4407                  * */
4408                 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4409                         || !(sas_device.flags &
4410                         MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4411                         break;
4412
4413                 phy_info = mptsas_find_phyinfo_by_sas_address(
4414                     ioc, sas_device.sas_address);
4415
4416                 if (!phy_info) {
4417                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4418                                 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4419                                  __func__, hot_plug_info->id, __LINE__));
4420                         break;
4421                 }
4422
4423                 starget = mptsas_get_starget(phy_info);
4424                 if (!starget) {
4425                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4426                                 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4427                                  __func__, hot_plug_info->id, __LINE__));
4428                         break;
4429                 }
4430
4431                 vtarget = starget->hostdata;
4432                 if (!vtarget) {
4433                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4434                                 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4435                                  __func__, hot_plug_info->id, __LINE__));
4436                         break;
4437                 }
4438
4439                 mpt_findImVolumes(ioc);
4440
4441                 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
4442                     "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4443                     ioc->name, hot_plug_info->channel, hot_plug_info->id,
4444                     hot_plug_info->phys_disk_num, (unsigned long long)
4445                     sas_device.sas_address);
4446
4447                 vtarget->id = hot_plug_info->phys_disk_num;
4448                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4449                 phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
4450                 mptsas_reprobe_target(starget, 1);
4451                 break;
4452
4453         case MPTSAS_DEL_PHYSDISK_REPROBE:
4454
4455                 if (mptsas_sas_device_pg0(ioc, &sas_device,
4456                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4457                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4458                         (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4459                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4460                                     "%s: fw_id=%d exit at line=%d\n",
4461                                     ioc->name, __func__,
4462                                     hot_plug_info->id, __LINE__));
4463                         break;
4464                 }
4465
4466                 /* If there is no FW B_T mapping for this device then break
4467                  * */
4468                 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4469                         || !(sas_device.flags &
4470                         MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4471                         break;
4472
4473                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4474                                 sas_device.sas_address);
4475                 if (!phy_info) {
4476                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4477                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4478                          __func__, hot_plug_info->id, __LINE__));
4479                         break;
4480                 }
4481
4482                 starget = mptsas_get_starget(phy_info);
4483                 if (!starget) {
4484                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4485                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4486                          __func__, hot_plug_info->id, __LINE__));
4487                         break;
4488                 }
4489
4490                 vtarget = starget->hostdata;
4491                 if (!vtarget) {
4492                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4493                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4494                          __func__, hot_plug_info->id, __LINE__));
4495                         break;
4496                 }
4497
4498                 if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
4499                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4500                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4501                          __func__, hot_plug_info->id, __LINE__));
4502                         break;
4503                 }
4504
4505                 mpt_findImVolumes(ioc);
4506
4507                 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
4508                     " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4509                     ioc->name, hot_plug_info->channel, hot_plug_info->id,
4510                     hot_plug_info->phys_disk_num, (unsigned long long)
4511                     sas_device.sas_address);
4512
4513                 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4514                 vtarget->id = hot_plug_info->id;
4515                 phy_info->attached.phys_disk_num = ~0;
4516                 mptsas_reprobe_target(starget, 0);
4517                 mptsas_add_device_component_by_fw(ioc,
4518                     hot_plug_info->channel, hot_plug_info->id);
4519                 break;
4520
4521         case MPTSAS_ADD_RAID:
4522
4523                 mpt_findImVolumes(ioc);
4524                 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4525                     "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4526                     hot_plug_info->id);
4527                 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4528                     hot_plug_info->id, 0);
4529                 break;
4530
4531         case MPTSAS_DEL_RAID:
4532
4533                 mpt_findImVolumes(ioc);
4534                 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4535                     "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4536                     hot_plug_info->id);
4537                 scsi_remove_device(hot_plug_info->sdev);
4538                 scsi_device_put(hot_plug_info->sdev);
4539                 break;
4540
4541         case MPTSAS_ADD_INACTIVE_VOLUME:
4542
4543                 mpt_findImVolumes(ioc);
4544                 mptsas_adding_inactive_raid_components(ioc,
4545                     hot_plug_info->channel, hot_plug_info->id);
4546                 break;
4547
4548         default:
4549                 break;
4550         }
4551
4552         mptsas_free_fw_event(ioc, fw_event);
4553 }
4554
4555 static void
4556 mptsas_send_sas_event(struct fw_event_work *fw_event)
4557 {
4558         MPT_ADAPTER *ioc;
4559         struct mptsas_hotplug_event hot_plug_info;
4560         EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
4561         u32 device_info;
4562         u64 sas_address;
4563
4564         ioc = fw_event->ioc;
4565         sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
4566             fw_event->event_data;
4567         device_info = le32_to_cpu(sas_event_data->DeviceInfo);
4568
4569         if ((device_info &
4570                 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
4571                 MPI_SAS_DEVICE_INFO_STP_TARGET |
4572                 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) {
4573                 mptsas_free_fw_event(ioc, fw_event);
4574                 return;
4575         }
4576
4577         if (sas_event_data->ReasonCode ==
4578                 MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
4579                 mptbase_sas_persist_operation(ioc,
4580                 MPI_SAS_OP_CLEAR_NOT_PRESENT);
4581                 mptsas_free_fw_event(ioc, fw_event);
4582                 return;
4583         }
4584
4585         switch (sas_event_data->ReasonCode) {
4586         case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
4587         case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
4588                 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4589                 hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
4590                 hot_plug_info.channel = sas_event_data->Bus;
4591                 hot_plug_info.id = sas_event_data->TargetID;
4592                 hot_plug_info.phy_id = sas_event_data->PhyNum;
4593                 memcpy(&sas_address, &sas_event_data->SASAddress,
4594                     sizeof(u64));
4595                 hot_plug_info.sas_address = le64_to_cpu(sas_address);
4596                 hot_plug_info.device_info = device_info;
4597                 if (sas_event_data->ReasonCode &
4598                     MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
4599                         hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
4600                 else
4601                         hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
4602                 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4603                 break;
4604
4605         case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
4606                 mptbase_sas_persist_operation(ioc,
4607                     MPI_SAS_OP_CLEAR_NOT_PRESENT);
4608                 mptsas_free_fw_event(ioc, fw_event);
4609                 break;
4610
4611         case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
4612         /* TODO */
4613         case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
4614         /* TODO */
4615         default:
4616                 mptsas_free_fw_event(ioc, fw_event);
4617                 break;
4618         }
4619 }
4620
4621 static void
4622 mptsas_send_raid_event(struct fw_event_work *fw_event)
4623 {
4624         MPT_ADAPTER *ioc;
4625         EVENT_DATA_RAID *raid_event_data;
4626         struct mptsas_hotplug_event hot_plug_info;
4627         int status;
4628         int state;
4629         struct scsi_device *sdev = NULL;
4630         VirtDevice *vdevice = NULL;
4631         RaidPhysDiskPage0_t phys_disk;
4632
4633         ioc = fw_event->ioc;
4634         raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
4635         status = le32_to_cpu(raid_event_data->SettingsStatus);
4636         state = (status >> 8) & 0xff;
4637
4638         memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4639         hot_plug_info.id = raid_event_data->VolumeID;
4640         hot_plug_info.channel = raid_event_data->VolumeBus;
4641         hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
4642
4643         if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
4644             raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
4645             raid_event_data->ReasonCode ==
4646             MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
4647                 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4648                     hot_plug_info.id, 0);
4649                 hot_plug_info.sdev = sdev;
4650                 if (sdev)
4651                         vdevice = sdev->hostdata;
4652         }
4653
4654         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4655             "ReasonCode=%02x\n", ioc->name, __func__,
4656             raid_event_data->ReasonCode));
4657
4658         switch (raid_event_data->ReasonCode) {
4659         case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4660                 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
4661                 break;
4662         case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4663                 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
4664                 break;
4665         case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4666                 switch (state) {
4667                 case MPI_PD_STATE_ONLINE:
4668                 case MPI_PD_STATE_NOT_COMPATIBLE:
4669                         mpt_raid_phys_disk_pg0(ioc,
4670                             raid_event_data->PhysDiskNum, &phys_disk);
4671                         hot_plug_info.id = phys_disk.PhysDiskID;
4672                         hot_plug_info.channel = phys_disk.PhysDiskBus;
4673                         hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4674                         break;
4675                 case MPI_PD_STATE_FAILED:
4676                 case MPI_PD_STATE_MISSING:
4677                 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
4678                 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
4679                 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
4680                         hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4681                         break;
4682                 default:
4683                         break;
4684                 }
4685                 break;
4686         case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4687                 if (!sdev)
4688                         break;
4689                 vdevice->vtarget->deleted = 1; /* block IO */
4690                 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4691                 break;
4692         case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4693                 if (sdev) {
4694                         scsi_device_put(sdev);
4695                         break;
4696                 }
4697                 hot_plug_info.event_type = MPTSAS_ADD_RAID;
4698                 break;
4699         case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4700                 if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
4701                         if (!sdev)
4702                                 break;
4703                         vdevice->vtarget->deleted = 1; /* block IO */
4704                         hot_plug_info.event_type = MPTSAS_DEL_RAID;
4705                         break;
4706                 }
4707                 switch (state) {
4708                 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
4709                 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
4710                         if (!sdev)
4711                                 break;
4712                         vdevice->vtarget->deleted = 1; /* block IO */
4713                         hot_plug_info.event_type = MPTSAS_DEL_RAID;
4714                         break;
4715                 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
4716                 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
4717                         if (sdev) {
4718                                 scsi_device_put(sdev);
4719                                 break;
4720                         }
4721                         hot_plug_info.event_type = MPTSAS_ADD_RAID;
4722                         break;
4723                 default:
4724                         break;
4725                 }
4726                 break;
4727         default:
4728                 break;
4729         }
4730
4731         if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
4732                 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4733         else
4734                 mptsas_free_fw_event(ioc, fw_event);
4735 }
4736
4737 /**
4738  *      mptsas_issue_tm - send mptsas internal tm request
4739  *      @ioc: Pointer to MPT_ADAPTER structure
4740  *      @type: Task Management type
4741  *      @channel: channel number for task management
4742  *      @id: Logical Target ID for reset (if appropriate)
4743  *      @lun: Logical unit for reset (if appropriate)
4744  *      @task_context: Context for the task to be aborted
4745  *      @timeout: timeout for task management control
4746  *
4747  *      return 0 on success and -1 on failure:
4748  *
4749  */
4750 static int
4751 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun,
4752         int task_context, ulong timeout, u8 *issue_reset)
4753 {
4754         MPT_FRAME_HDR   *mf;
4755         SCSITaskMgmt_t  *pScsiTm;
4756         int              retval;
4757         unsigned long    timeleft;
4758
4759         *issue_reset = 0;
4760         mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
4761         if (mf == NULL) {
4762                 retval = -1; /* return failure */
4763                 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
4764                     "msg frames!!\n", ioc->name));
4765                 goto out;
4766         }
4767
4768         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
4769             "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
4770             "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
4771              type, timeout, channel, id, (unsigned long long)lun,
4772              task_context));
4773
4774         pScsiTm = (SCSITaskMgmt_t *) mf;
4775         memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
4776         pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4777         pScsiTm->TaskType = type;
4778         pScsiTm->MsgFlags = 0;
4779         pScsiTm->TargetID = id;
4780         pScsiTm->Bus = channel;
4781         pScsiTm->ChainOffset = 0;
4782         pScsiTm->Reserved = 0;
4783         pScsiTm->Reserved1 = 0;
4784         pScsiTm->TaskMsgContext = task_context;
4785         int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
4786
4787         INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4788         CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
4789         retval = 0;
4790         mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
4791
4792         /* Now wait for the command to complete */
4793         timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
4794             timeout*HZ);
4795         if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
4796                 retval = -1; /* return failure */
4797                 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
4798                     "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
4799                 mpt_free_msg_frame(ioc, mf);
4800                 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
4801                         goto out;
4802                 *issue_reset = 1;
4803                 goto out;
4804         }
4805
4806         if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
4807                 retval = -1; /* return failure */
4808                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4809                     "TaskMgmt request: failed with no reply\n", ioc->name));
4810                 goto out;
4811         }
4812
4813  out:
4814         CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4815         return retval;
4816 }
4817
4818 /**
4819  *      mptsas_broadcast_primative_work - Handle broadcast primitives
4820  *      @work: work queue payload containing info describing the event
4821  *
4822  *      this will be handled in workqueue context.
4823  */
4824 static void
4825 mptsas_broadcast_primative_work(struct fw_event_work *fw_event)
4826 {
4827         MPT_ADAPTER *ioc = fw_event->ioc;
4828         MPT_FRAME_HDR   *mf;
4829         VirtDevice      *vdevice;
4830         int                     ii;
4831         struct scsi_cmnd        *sc;
4832         SCSITaskMgmtReply_t     *pScsiTmReply;
4833         u8                      issue_reset;
4834         int                     task_context;
4835         u8                      channel, id;
4836         int                      lun;
4837         u32                      termination_count;
4838         u32                      query_count;
4839
4840         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4841             "%s - enter\n", ioc->name, __func__));
4842
4843         mutex_lock(&ioc->taskmgmt_cmds.mutex);
4844         if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4845                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4846                 mptsas_requeue_fw_event(ioc, fw_event, 1000);
4847                 return;
4848         }
4849
4850         issue_reset = 0;
4851         termination_count = 0;
4852         query_count = 0;
4853         mpt_findImVolumes(ioc);
4854         pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
4855
4856         for (ii = 0; ii < ioc->req_depth; ii++) {
4857                 if (ioc->fw_events_off)
4858                         goto out;
4859                 sc = mptscsih_get_scsi_lookup(ioc, ii);
4860                 if (!sc)
4861                         continue;
4862                 mf = MPT_INDEX_2_MFPTR(ioc, ii);
4863                 if (!mf)
4864                         continue;
4865                 task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
4866                 vdevice = sc->device->hostdata;
4867                 if (!vdevice || !vdevice->vtarget)
4868                         continue;
4869                 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
4870                         continue; /* skip hidden raid components */
4871                 if (vdevice->vtarget->raidVolume)
4872                         continue; /* skip hidden raid components */
4873                 channel = vdevice->vtarget->channel;
4874                 id = vdevice->vtarget->id;
4875                 lun = vdevice->lun;
4876                 if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
4877                     channel, id, (u64)lun, task_context, 30, &issue_reset))
4878                         goto out;
4879                 query_count++;
4880                 termination_count +=
4881                     le32_to_cpu(pScsiTmReply->TerminationCount);
4882                 if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
4883                     (pScsiTmReply->ResponseCode ==
4884                     MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4885                     pScsiTmReply->ResponseCode ==
4886                     MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4887                         continue;
4888                 if (mptsas_issue_tm(ioc,
4889                     MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
4890                     channel, id, (u64)lun, 0, 30, &issue_reset))
4891                         goto out;
4892                 termination_count +=
4893                     le32_to_cpu(pScsiTmReply->TerminationCount);
4894         }
4895
4896  out:
4897         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4898             "%s - exit, query_count = %d termination_count = %d\n",
4899             ioc->name, __func__, query_count, termination_count));
4900
4901         ioc->broadcast_aen_busy = 0;
4902         mpt_clear_taskmgmt_in_progress_flag(ioc);
4903         mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4904
4905         if (issue_reset) {
4906                 printk(MYIOC_s_WARN_FMT
4907                        "Issuing Reset from %s!! doorbell=0x%08x\n",
4908                        ioc->name, __func__, mpt_GetIocState(ioc, 0));
4909                 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
4910         }
4911         mptsas_free_fw_event(ioc, fw_event);
4912 }
4913
4914 /*
4915  * mptsas_send_ir2_event - handle exposing hidden disk when
4916  * an inactive raid volume is added
4917  *
4918  * @ioc: Pointer to MPT_ADAPTER structure
4919  * @ir2_data
4920  *
4921  */
4922 static void
4923 mptsas_send_ir2_event(struct fw_event_work *fw_event)
4924 {
4925         MPT_ADAPTER     *ioc;
4926         struct mptsas_hotplug_event hot_plug_info;
4927         MPI_EVENT_DATA_IR2      *ir2_data;
4928         u8 reasonCode;
4929         RaidPhysDiskPage0_t phys_disk;
4930
4931         ioc = fw_event->ioc;
4932         ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
4933         reasonCode = ir2_data->ReasonCode;
4934
4935         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4936             "ReasonCode=%02x\n", ioc->name, __func__, reasonCode));
4937
4938         memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4939         hot_plug_info.id = ir2_data->TargetID;
4940         hot_plug_info.channel = ir2_data->Bus;
4941         switch (reasonCode) {
4942         case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
4943                 hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
4944                 break;
4945         case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
4946                 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4947                 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4948                 break;
4949         case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
4950                 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4951                 mpt_raid_phys_disk_pg0(ioc,
4952                     ir2_data->PhysDiskNum, &phys_disk);
4953                 hot_plug_info.id = phys_disk.PhysDiskID;
4954                 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4955                 break;
4956         default:
4957                 mptsas_free_fw_event(ioc, fw_event);
4958                 return;
4959         }
4960         mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4961 }
4962
4963 static int
4964 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
4965 {
4966         u32 event = le32_to_cpu(reply->Event);
4967         int sz, event_data_sz;
4968         struct fw_event_work *fw_event;
4969         unsigned long delay;
4970
4971         if (ioc->bus_type != SAS)
4972                 return 0;
4973
4974         /* events turned off due to host reset or driver unloading */
4975         if (ioc->fw_events_off)
4976                 return 0;
4977
4978         delay = msecs_to_jiffies(1);
4979         switch (event) {
4980         case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
4981         {
4982                 EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
4983                     (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
4984                 if (broadcast_event_data->Primitive !=
4985                     MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
4986                         return 0;
4987                 if (ioc->broadcast_aen_busy)
4988                         return 0;
4989                 ioc->broadcast_aen_busy = 1;
4990                 break;
4991         }
4992         case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
4993         {
4994                 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
4995                     (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
4996                 u16     ioc_stat;
4997                 ioc_stat = le16_to_cpu(reply->IOCStatus);
4998
4999                 if (sas_event_data->ReasonCode ==
5000                     MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
5001                         mptsas_target_reset_queue(ioc, sas_event_data);
5002                         return 0;
5003                 }
5004                 if (sas_event_data->ReasonCode ==
5005                         MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5006                         ioc->device_missing_delay &&
5007                         (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
5008                         VirtTarget *vtarget = NULL;
5009                         u8              id, channel;
5010                         u32      log_info = le32_to_cpu(reply->IOCLogInfo);
5011
5012                         id = sas_event_data->TargetID;
5013                         channel = sas_event_data->Bus;
5014
5015                         vtarget = mptsas_find_vtarget(ioc, channel, id);
5016                         if (vtarget) {
5017                                 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5018                                     "LogInfo (0x%x) available for "
5019                                    "INTERNAL_DEVICE_RESET"
5020                                    "fw_id %d fw_channel %d\n", ioc->name,
5021                                    log_info, id, channel));
5022                                 if (vtarget->raidVolume) {
5023                                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5024                                         "Skipping Raid Volume for inDMD\n",
5025                                         ioc->name));
5026                                 } else {
5027                                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5028                                         "Setting device flag inDMD\n",
5029                                         ioc->name));
5030                                         vtarget->inDMD = 1;
5031                                 }
5032
5033                         }
5034
5035                 }
5036
5037                 break;
5038         }
5039         case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
5040         {
5041                 MpiEventDataSasExpanderStatusChange_t *expander_data =
5042                     (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
5043
5044                 if (ioc->old_sas_discovery_protocal)
5045                         return 0;
5046
5047                 if (expander_data->ReasonCode ==
5048                     MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
5049                     ioc->device_missing_delay)
5050                         delay = HZ * ioc->device_missing_delay;
5051                 break;
5052         }
5053         case MPI_EVENT_SAS_DISCOVERY:
5054         {
5055                 u32 discovery_status;
5056                 EventDataSasDiscovery_t *discovery_data =
5057                     (EventDataSasDiscovery_t *)reply->Data;
5058
5059                 discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
5060                 ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
5061                 if (ioc->old_sas_discovery_protocal && !discovery_status)
5062                         mptsas_queue_rescan(ioc);
5063                 return 0;
5064         }
5065         case MPI_EVENT_INTEGRATED_RAID:
5066         case MPI_EVENT_PERSISTENT_TABLE_FULL:
5067         case MPI_EVENT_IR2:
5068         case MPI_EVENT_SAS_PHY_LINK_STATUS:
5069         case MPI_EVENT_QUEUE_FULL:
5070                 break;
5071         default:
5072                 return 0;
5073         }
5074
5075         event_data_sz = ((reply->MsgLength * 4) -
5076             offsetof(EventNotificationReply_t, Data));
5077         sz = offsetof(struct fw_event_work, event_data) + event_data_sz;
5078         fw_event = kzalloc(sz, GFP_ATOMIC);
5079         if (!fw_event) {
5080                 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
5081                  __func__, __LINE__);
5082                 return 0;
5083         }
5084         memcpy(fw_event->event_data, reply->Data, event_data_sz);
5085         fw_event->event = event;
5086         fw_event->ioc = ioc;
5087         mptsas_add_fw_event(ioc, fw_event, delay);
5088         return 0;
5089 }
5090
5091 /* Delete a volume when no longer listed in ioc pg2
5092  */
5093 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
5094 {
5095         struct scsi_device *sdev;
5096         int i;
5097
5098         sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
5099         if (!sdev)
5100                 return;
5101         if (!ioc->raid_data.pIocPg2)
5102                 goto out;
5103         if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
5104                 goto out;
5105         for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
5106                 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
5107                         goto release_sdev;
5108  out:
5109         printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
5110             "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id);
5111         scsi_remove_device(sdev);
5112  release_sdev:
5113         scsi_device_put(sdev);
5114 }
5115
5116 static int
5117 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5118 {
5119         struct Scsi_Host        *sh;
5120         MPT_SCSI_HOST           *hd;
5121         MPT_ADAPTER             *ioc;
5122         unsigned long            flags;
5123         int                      ii;
5124         int                      numSGE = 0;
5125         int                      scale;
5126         int                      ioc_cap;
5127         int                     error=0;
5128         int                     r;
5129
5130         r = mpt_attach(pdev,id);
5131         if (r)
5132                 return r;
5133
5134         ioc = pci_get_drvdata(pdev);
5135         mptsas_fw_event_off(ioc);
5136         ioc->DoneCtx = mptsasDoneCtx;
5137         ioc->TaskCtx = mptsasTaskCtx;
5138         ioc->InternalCtx = mptsasInternalCtx;
5139         ioc->schedule_target_reset = &mptsas_schedule_target_reset;
5140         /*  Added sanity check on readiness of the MPT adapter.
5141          */
5142         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
5143                 printk(MYIOC_s_WARN_FMT
5144                   "Skipping because it's not operational!\n",
5145                   ioc->name);
5146                 error = -ENODEV;
5147                 goto out_mptsas_probe;
5148         }
5149
5150         if (!ioc->active) {
5151                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
5152                   ioc->name);
5153                 error = -ENODEV;
5154                 goto out_mptsas_probe;
5155         }
5156
5157         /*  Sanity check - ensure at least 1 port is INITIATOR capable
5158          */
5159         ioc_cap = 0;
5160         for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
5161                 if (ioc->pfacts[ii].ProtocolFlags &
5162                                 MPI_PORTFACTS_PROTOCOL_INITIATOR)
5163                         ioc_cap++;
5164         }
5165
5166         if (!ioc_cap) {
5167                 printk(MYIOC_s_WARN_FMT
5168                         "Skipping ioc=%p because SCSI Initiator mode "
5169                         "is NOT enabled!\n", ioc->name, ioc);
5170                 return 0;
5171         }
5172
5173         sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
5174         if (!sh) {
5175                 printk(MYIOC_s_WARN_FMT
5176                         "Unable to register controller with SCSI subsystem\n",
5177                         ioc->name);
5178                 error = -1;
5179                 goto out_mptsas_probe;
5180         }
5181
5182         spin_lock_irqsave(&ioc->FreeQlock, flags);
5183
5184         /* Attach the SCSI Host to the IOC structure
5185          */
5186         ioc->sh = sh;
5187
5188         sh->io_port = 0;
5189         sh->n_io_port = 0;
5190         sh->irq = 0;
5191
5192         /* set 16 byte cdb's */
5193         sh->max_cmd_len = 16;
5194         sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
5195         sh->max_id = -1;
5196         sh->max_lun = max_lun;
5197         sh->transportt = mptsas_transport_template;
5198
5199         /* Required entry.
5200          */
5201         sh->unique_id = ioc->id;
5202
5203         INIT_LIST_HEAD(&ioc->sas_topology);
5204         mutex_init(&ioc->sas_topology_mutex);
5205         mutex_init(&ioc->sas_discovery_mutex);
5206         mutex_init(&ioc->sas_mgmt.mutex);
5207         init_completion(&ioc->sas_mgmt.done);
5208
5209         /* Verify that we won't exceed the maximum
5210          * number of chain buffers
5211          * We can optimize:  ZZ = req_sz/sizeof(SGE)
5212          * For 32bit SGE's:
5213          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
5214          *               + (req_sz - 64)/sizeof(SGE)
5215          * A slightly different algorithm is required for
5216          * 64bit SGEs.
5217          */
5218         scale = ioc->req_sz/ioc->SGE_size;
5219         if (ioc->sg_addr_size == sizeof(u64)) {
5220                 numSGE = (scale - 1) *
5221                   (ioc->facts.MaxChainDepth-1) + scale +
5222                   (ioc->req_sz - 60) / ioc->SGE_size;
5223         } else {
5224                 numSGE = 1 + (scale - 1) *
5225                   (ioc->facts.MaxChainDepth-1) + scale +
5226                   (ioc->req_sz - 64) / ioc->SGE_size;
5227         }
5228
5229         if (numSGE < sh->sg_tablesize) {
5230                 /* Reset this value */
5231                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5232                   "Resetting sg_tablesize to %d from %d\n",
5233                   ioc->name, numSGE, sh->sg_tablesize));
5234                 sh->sg_tablesize = numSGE;
5235         }
5236
5237         hd = shost_priv(sh);
5238         hd->ioc = ioc;
5239
5240         /* SCSI needs scsi_cmnd lookup table!
5241          * (with size equal to req_depth*PtrSz!)
5242          */
5243         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
5244         if (!ioc->ScsiLookup) {
5245                 error = -ENOMEM;
5246                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5247                 goto out_mptsas_probe;
5248         }
5249         spin_lock_init(&ioc->scsi_lookup_lock);
5250
5251         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
5252                  ioc->name, ioc->ScsiLookup));
5253
5254         ioc->sas_data.ptClear = mpt_pt_clear;
5255
5256         hd->last_queue_full = 0;
5257         INIT_LIST_HEAD(&hd->target_reset_list);
5258         INIT_LIST_HEAD(&ioc->sas_device_info_list);
5259         mutex_init(&ioc->sas_device_info_mutex);
5260
5261         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5262
5263         if (ioc->sas_data.ptClear==1) {
5264                 mptbase_sas_persist_operation(
5265                     ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
5266         }
5267
5268         error = scsi_add_host(sh, &ioc->pcidev->dev);
5269         if (error) {
5270                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
5271                   "scsi_add_host failed\n", ioc->name));
5272                 goto out_mptsas_probe;
5273         }
5274
5275         /* older firmware doesn't support expander events */
5276         if ((ioc->facts.HeaderVersion >> 8) < 0xE)
5277                 ioc->old_sas_discovery_protocal = 1;
5278         mptsas_scan_sas_topology(ioc);
5279         mptsas_fw_event_on(ioc);
5280         return 0;
5281
5282  out_mptsas_probe:
5283
5284         mptscsih_remove(pdev);
5285         return error;
5286 }
5287
5288 void
5289 mptsas_shutdown(struct pci_dev *pdev)
5290 {
5291         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5292
5293         mptsas_fw_event_off(ioc);
5294         mptsas_cleanup_fw_event_q(ioc);
5295 }
5296
5297 static void __devexit mptsas_remove(struct pci_dev *pdev)
5298 {
5299         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5300         struct mptsas_portinfo *p, *n;
5301         int i;
5302
5303         if (!ioc->sh) {
5304                 printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name);
5305                 mpt_detach(pdev);
5306                 return;
5307         }
5308
5309         mptsas_shutdown(pdev);
5310
5311         mptsas_del_device_components(ioc);
5312
5313         ioc->sas_discovery_ignore_events = 1;
5314         sas_remove_host(ioc->sh);
5315
5316         mutex_lock(&ioc->sas_topology_mutex);
5317         list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
5318                 list_del(&p->list);
5319                 for (i = 0 ; i < p->num_phys ; i++)
5320                         mptsas_port_delete(ioc, p->phy_info[i].port_details);
5321
5322                 kfree(p->phy_info);
5323                 kfree(p);
5324         }
5325         mutex_unlock(&ioc->sas_topology_mutex);
5326         ioc->hba_port_info = NULL;
5327         mptscsih_remove(pdev);
5328 }
5329
5330 static struct pci_device_id mptsas_pci_table[] = {
5331         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
5332                 PCI_ANY_ID, PCI_ANY_ID },
5333         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
5334                 PCI_ANY_ID, PCI_ANY_ID },
5335         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
5336                 PCI_ANY_ID, PCI_ANY_ID },
5337         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
5338                 PCI_ANY_ID, PCI_ANY_ID },
5339         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
5340                 PCI_ANY_ID, PCI_ANY_ID },
5341         {0}     /* Terminating entry */
5342 };
5343 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
5344
5345
5346 static struct pci_driver mptsas_driver = {
5347         .name           = "mptsas",
5348         .id_table       = mptsas_pci_table,
5349         .probe          = mptsas_probe,
5350         .remove         = __devexit_p(mptsas_remove),
5351         .shutdown       = mptsas_shutdown,
5352 #ifdef CONFIG_PM
5353         .suspend        = mptscsih_suspend,
5354         .resume         = mptscsih_resume,
5355 #endif
5356 };
5357
5358 static int __init
5359 mptsas_init(void)
5360 {
5361         int error;
5362
5363         show_mptmod_ver(my_NAME, my_VERSION);
5364
5365         mptsas_transport_template =
5366             sas_attach_transport(&mptsas_transport_functions);
5367         if (!mptsas_transport_template)
5368                 return -ENODEV;
5369         mptsas_transport_template->eh_timed_out = mptsas_eh_timed_out;
5370
5371         mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER,
5372             "mptscsih_io_done");
5373         mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER,
5374             "mptscsih_taskmgmt_complete");
5375         mptsasInternalCtx =
5376                 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER,
5377                     "mptscsih_scandv_complete");
5378         mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER,
5379             "mptsas_mgmt_done");
5380         mptsasDeviceResetCtx =
5381                 mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER,
5382                     "mptsas_taskmgmt_complete");
5383
5384         mpt_event_register(mptsasDoneCtx, mptsas_event_process);
5385         mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
5386
5387         error = pci_register_driver(&mptsas_driver);
5388         if (error)
5389                 sas_release_transport(mptsas_transport_template);
5390
5391         return error;
5392 }
5393
5394 static void __exit
5395 mptsas_exit(void)
5396 {
5397         pci_unregister_driver(&mptsas_driver);
5398         sas_release_transport(mptsas_transport_template);
5399
5400         mpt_reset_deregister(mptsasDoneCtx);
5401         mpt_event_deregister(mptsasDoneCtx);
5402
5403         mpt_deregister(mptsasMgmtCtx);
5404         mpt_deregister(mptsasInternalCtx);
5405         mpt_deregister(mptsasTaskCtx);
5406         mpt_deregister(mptsasDoneCtx);
5407         mpt_deregister(mptsasDeviceResetCtx);
5408 }
5409
5410 module_init(mptsas_init);
5411 module_exit(mptsas_exit);