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