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