drivers/message/fusion/mptsas.c

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