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 SAS 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 (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2042                 error = -ETIME;
2043                 mpt_free_msg_frame(ioc, mf);
2044                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2045                         goto out_unlock;
2046                 if (!timeleft)
2047                         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2048                 goto out_unlock;
2049         }
2050
2051         /* a reply frame is expected */
2052         if ((ioc->sas_mgmt.status &
2053             MPT_MGMT_STATUS_RF_VALID) == 0) {
2054                 error = -ENXIO;
2055                 goto out_unlock;
2056         }
2057
2058         /* process the completed Reply Message Frame */
2059         reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
2060         if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
2061                 printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
2062                     ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
2063                 error = -ENXIO;
2064                 goto out_unlock;
2065         }
2066
2067         error = 0;
2068
2069  out_unlock:
2070         CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2071         mutex_unlock(&ioc->sas_mgmt.mutex);
2072  out:
2073         return error;
2074 }
2075
2076 static int
2077 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
2078 {
2079         MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2080         int i, error;
2081         struct mptsas_portinfo *p;
2082         struct mptsas_enclosure enclosure_info;
2083         u64 enclosure_handle;
2084
2085         mutex_lock(&ioc->sas_topology_mutex);
2086         list_for_each_entry(p, &ioc->sas_topology, list) {
2087                 for (i = 0; i < p->num_phys; i++) {
2088                         if (p->phy_info[i].attached.sas_address ==
2089                             rphy->identify.sas_address) {
2090                                 enclosure_handle = p->phy_info[i].
2091                                         attached.handle_enclosure;
2092                                 goto found_info;
2093                         }
2094                 }
2095         }
2096         mutex_unlock(&ioc->sas_topology_mutex);
2097         return -ENXIO;
2098
2099  found_info:
2100         mutex_unlock(&ioc->sas_topology_mutex);
2101         memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
2102         error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
2103                         (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
2104                          MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
2105         if (!error)
2106                 *identifier = enclosure_info.enclosure_logical_id;
2107         return error;
2108 }
2109
2110 static int
2111 mptsas_get_bay_identifier(struct sas_rphy *rphy)
2112 {
2113         MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2114         struct mptsas_portinfo *p;
2115         int i, rc;
2116
2117         mutex_lock(&ioc->sas_topology_mutex);
2118         list_for_each_entry(p, &ioc->sas_topology, list) {
2119                 for (i = 0; i < p->num_phys; i++) {
2120                         if (p->phy_info[i].attached.sas_address ==
2121                             rphy->identify.sas_address) {
2122                                 rc = p->phy_info[i].attached.slot;
2123                                 goto out;
2124                         }
2125                 }
2126         }
2127         rc = -ENXIO;
2128  out:
2129         mutex_unlock(&ioc->sas_topology_mutex);
2130         return rc;
2131 }
2132
2133 static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
2134                               struct request *req)
2135 {
2136         MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
2137         MPT_FRAME_HDR *mf;
2138         SmpPassthroughRequest_t *smpreq;
2139         struct request *rsp = req->next_rq;
2140         int ret;
2141         int flagsLength;
2142         unsigned long timeleft;
2143         char *psge;
2144         dma_addr_t dma_addr_in = 0;
2145         dma_addr_t dma_addr_out = 0;
2146         u64 sas_address = 0;
2147
2148         if (!rsp) {
2149                 printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n",
2150                     ioc->name, __func__);
2151                 return -EINVAL;
2152         }
2153
2154         /* do we need to support multiple segments? */
2155         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
2156                 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
2157                     ioc->name, __func__, req->bio->bi_vcnt, blk_rq_bytes(req),
2158                     rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
2159                 return -EINVAL;
2160         }
2161
2162         ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2163         if (ret)
2164                 goto out;
2165
2166         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2167         if (!mf) {
2168                 ret = -ENOMEM;
2169                 goto out_unlock;
2170         }
2171
2172         smpreq = (SmpPassthroughRequest_t *)mf;
2173         memset(smpreq, 0, sizeof(*smpreq));
2174
2175         smpreq->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
2176         smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2177
2178         if (rphy)
2179                 sas_address = rphy->identify.sas_address;
2180         else {
2181                 struct mptsas_portinfo *port_info;
2182
2183                 mutex_lock(&ioc->sas_topology_mutex);
2184                 port_info = ioc->hba_port_info;
2185                 if (port_info && port_info->phy_info)
2186                         sas_address =
2187                                 port_info->phy_info[0].phy->identify.sas_address;
2188                 mutex_unlock(&ioc->sas_topology_mutex);
2189         }
2190
2191         *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2192
2193         psge = (char *)
2194                 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2195
2196         /* request */
2197         flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2198                        MPI_SGE_FLAGS_END_OF_BUFFER |
2199                        MPI_SGE_FLAGS_DIRECTION)
2200                        << MPI_SGE_FLAGS_SHIFT;
2201         flagsLength |= (blk_rq_bytes(req) - 4);
2202
2203         dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
2204                                       blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
2205         if (!dma_addr_out)
2206                 goto put_mf;
2207         ioc->add_sge(psge, flagsLength, dma_addr_out);
2208         psge += ioc->SGE_size;
2209
2210         /* response */
2211         flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2212                 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2213                 MPI_SGE_FLAGS_IOC_TO_HOST |
2214                 MPI_SGE_FLAGS_END_OF_BUFFER;
2215
2216         flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2217         flagsLength |= blk_rq_bytes(rsp) + 4;
2218         dma_addr_in =  pci_map_single(ioc->pcidev, bio_data(rsp->bio),
2219                                       blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
2220         if (!dma_addr_in)
2221                 goto unmap;
2222         ioc->add_sge(psge, flagsLength, dma_addr_in);
2223
2224         INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2225         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2226
2227         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2228         if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2229                 ret = -ETIME;
2230                 mpt_free_msg_frame(ioc, mf);
2231                 mf = NULL;
2232                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2233                         goto unmap;
2234                 if (!timeleft)
2235                         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2236                 goto unmap;
2237         }
2238         mf = NULL;
2239
2240         if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2241                 SmpPassthroughReply_t *smprep;
2242
2243                 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2244                 memcpy(req->sense, smprep, sizeof(*smprep));
2245                 req->sense_len = sizeof(*smprep);
2246                 req->resid_len = 0;
2247                 rsp->resid_len -= smprep->ResponseDataLength;
2248         } else {
2249                 printk(MYIOC_s_ERR_FMT
2250                     "%s: smp passthru reply failed to be returned\n",
2251                     ioc->name, __func__);
2252                 ret = -ENXIO;
2253         }
2254 unmap:
2255         if (dma_addr_out)
2256                 pci_unmap_single(ioc->pcidev, dma_addr_out, blk_rq_bytes(req),
2257                                  PCI_DMA_BIDIRECTIONAL);
2258         if (dma_addr_in)
2259                 pci_unmap_single(ioc->pcidev, dma_addr_in, blk_rq_bytes(rsp),
2260                                  PCI_DMA_BIDIRECTIONAL);
2261 put_mf:
2262         if (mf)
2263                 mpt_free_msg_frame(ioc, mf);
2264 out_unlock:
2265         CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2266         mutex_unlock(&ioc->sas_mgmt.mutex);
2267 out:
2268         return ret;
2269 }
2270
2271 static struct sas_function_template mptsas_transport_functions = {
2272         .get_linkerrors         = mptsas_get_linkerrors,
2273         .get_enclosure_identifier = mptsas_get_enclosure_identifier,
2274         .get_bay_identifier     = mptsas_get_bay_identifier,
2275         .phy_reset              = mptsas_phy_reset,
2276         .smp_handler            = mptsas_smp_handler,
2277 };
2278
2279 static struct scsi_transport_template *mptsas_transport_template;
2280
2281 static int
2282 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
2283 {
2284         ConfigExtendedPageHeader_t hdr;
2285         CONFIGPARMS cfg;
2286         SasIOUnitPage0_t *buffer;
2287         dma_addr_t dma_handle;
2288         int error, i;
2289
2290         hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
2291         hdr.ExtPageLength = 0;
2292         hdr.PageNumber = 0;
2293         hdr.Reserved1 = 0;
2294         hdr.Reserved2 = 0;
2295         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2296         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2297
2298         cfg.cfghdr.ehdr = &hdr;
2299         cfg.physAddr = -1;
2300         cfg.pageAddr = 0;
2301         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2302         cfg.dir = 0;    /* read */
2303         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2304
2305         error = mpt_config(ioc, &cfg);
2306         if (error)
2307                 goto out;
2308         if (!hdr.ExtPageLength) {
2309                 error = -ENXIO;
2310                 goto out;
2311         }
2312
2313         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2314                                             &dma_handle);
2315         if (!buffer) {
2316                 error = -ENOMEM;
2317                 goto out;
2318         }
2319
2320         cfg.physAddr = dma_handle;
2321         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2322
2323         error = mpt_config(ioc, &cfg);
2324         if (error)
2325                 goto out_free_consistent;
2326
2327         port_info->num_phys = buffer->NumPhys;
2328         port_info->phy_info = kcalloc(port_info->num_phys,
2329                 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2330         if (!port_info->phy_info) {
2331                 error = -ENOMEM;
2332                 goto out_free_consistent;
2333         }
2334
2335         ioc->nvdata_version_persistent =
2336             le16_to_cpu(buffer->NvdataVersionPersistent);
2337         ioc->nvdata_version_default =
2338             le16_to_cpu(buffer->NvdataVersionDefault);
2339
2340         for (i = 0; i < port_info->num_phys; i++) {
2341                 mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
2342                 port_info->phy_info[i].phy_id = i;
2343                 port_info->phy_info[i].port_id =
2344                     buffer->PhyData[i].Port;
2345                 port_info->phy_info[i].negotiated_link_rate =
2346                     buffer->PhyData[i].NegotiatedLinkRate;
2347                 port_info->phy_info[i].portinfo = port_info;
2348                 port_info->phy_info[i].handle =
2349                     le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
2350         }
2351
2352  out_free_consistent:
2353         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2354                             buffer, dma_handle);
2355  out:
2356         return error;
2357 }
2358
2359 static int
2360 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
2361 {
2362         ConfigExtendedPageHeader_t hdr;
2363         CONFIGPARMS cfg;
2364         SasIOUnitPage1_t *buffer;
2365         dma_addr_t dma_handle;
2366         int error;
2367         u16 device_missing_delay;
2368
2369         memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
2370         memset(&cfg, 0, sizeof(CONFIGPARMS));
2371
2372         cfg.cfghdr.ehdr = &hdr;
2373         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2374         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2375         cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2376         cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2377         cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
2378         cfg.cfghdr.ehdr->PageNumber = 1;
2379
2380         error = mpt_config(ioc, &cfg);
2381         if (error)
2382                 goto out;
2383         if (!hdr.ExtPageLength) {
2384                 error = -ENXIO;
2385                 goto out;
2386         }
2387
2388         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2389                                             &dma_handle);
2390         if (!buffer) {
2391                 error = -ENOMEM;
2392                 goto out;
2393         }
2394
2395         cfg.physAddr = dma_handle;
2396         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2397
2398         error = mpt_config(ioc, &cfg);
2399         if (error)
2400                 goto out_free_consistent;
2401
2402         ioc->io_missing_delay  =
2403             le16_to_cpu(buffer->IODeviceMissingDelay);
2404         device_missing_delay = le16_to_cpu(buffer->ReportDeviceMissingDelay);
2405         ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
2406             (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
2407             device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
2408
2409  out_free_consistent:
2410         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2411                             buffer, dma_handle);
2412  out:
2413         return error;
2414 }
2415
2416 static int
2417 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2418                 u32 form, u32 form_specific)
2419 {
2420         ConfigExtendedPageHeader_t hdr;
2421         CONFIGPARMS cfg;
2422         SasPhyPage0_t *buffer;
2423         dma_addr_t dma_handle;
2424         int error;
2425
2426         hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
2427         hdr.ExtPageLength = 0;
2428         hdr.PageNumber = 0;
2429         hdr.Reserved1 = 0;
2430         hdr.Reserved2 = 0;
2431         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2432         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2433
2434         cfg.cfghdr.ehdr = &hdr;
2435         cfg.dir = 0;    /* read */
2436         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2437
2438         /* Get Phy Pg 0 for each Phy. */
2439         cfg.physAddr = -1;
2440         cfg.pageAddr = form + form_specific;
2441         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2442
2443         error = mpt_config(ioc, &cfg);
2444         if (error)
2445                 goto out;
2446
2447         if (!hdr.ExtPageLength) {
2448                 error = -ENXIO;
2449                 goto out;
2450         }
2451
2452         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2453                                       &dma_handle);
2454         if (!buffer) {
2455                 error = -ENOMEM;
2456                 goto out;
2457         }
2458
2459         cfg.physAddr = dma_handle;
2460         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2461
2462         error = mpt_config(ioc, &cfg);
2463         if (error)
2464                 goto out_free_consistent;
2465
2466         mptsas_print_phy_pg0(ioc, buffer);
2467
2468         phy_info->hw_link_rate = buffer->HwLinkRate;
2469         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2470         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2471         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2472
2473  out_free_consistent:
2474         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2475                             buffer, dma_handle);
2476  out:
2477         return error;
2478 }
2479
2480 static int
2481 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
2482                 u32 form, u32 form_specific)
2483 {
2484         ConfigExtendedPageHeader_t hdr;
2485         CONFIGPARMS cfg;
2486         SasDevicePage0_t *buffer;
2487         dma_addr_t dma_handle;
2488         __le64 sas_address;
2489         int error=0;
2490
2491         hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
2492         hdr.ExtPageLength = 0;
2493         hdr.PageNumber = 0;
2494         hdr.Reserved1 = 0;
2495         hdr.Reserved2 = 0;
2496         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2497         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
2498
2499         cfg.cfghdr.ehdr = &hdr;
2500         cfg.pageAddr = form + form_specific;
2501         cfg.physAddr = -1;
2502         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2503         cfg.dir = 0;    /* read */
2504         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2505
2506         memset(device_info, 0, sizeof(struct mptsas_devinfo));
2507         error = mpt_config(ioc, &cfg);
2508         if (error)
2509                 goto out;
2510         if (!hdr.ExtPageLength) {
2511                 error = -ENXIO;
2512                 goto out;
2513         }
2514
2515         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2516                                       &dma_handle);
2517         if (!buffer) {
2518                 error = -ENOMEM;
2519                 goto out;
2520         }
2521
2522         cfg.physAddr = dma_handle;
2523         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2524
2525         error = mpt_config(ioc, &cfg);
2526
2527         if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2528                 error = -ENODEV;
2529                 goto out_free_consistent;
2530         }
2531
2532         if (error)
2533                 goto out_free_consistent;
2534
2535         mptsas_print_device_pg0(ioc, buffer);
2536
2537         memset(device_info, 0, sizeof(struct mptsas_devinfo));
2538         device_info->handle = le16_to_cpu(buffer->DevHandle);
2539         device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
2540         device_info->handle_enclosure =
2541             le16_to_cpu(buffer->EnclosureHandle);
2542         device_info->slot = le16_to_cpu(buffer->Slot);
2543         device_info->phy_id = buffer->PhyNum;
2544         device_info->port_id = buffer->PhysicalPort;
2545         device_info->id = buffer->TargetID;
2546         device_info->phys_disk_num = ~0;
2547         device_info->channel = buffer->Bus;
2548         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2549         device_info->sas_address = le64_to_cpu(sas_address);
2550         device_info->device_info =
2551             le32_to_cpu(buffer->DeviceInfo);
2552
2553  out_free_consistent:
2554         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2555                             buffer, dma_handle);
2556  out:
2557         return error;
2558 }
2559
2560 static int
2561 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
2562                 u32 form, u32 form_specific)
2563 {
2564         ConfigExtendedPageHeader_t hdr;
2565         CONFIGPARMS cfg;
2566         SasExpanderPage0_t *buffer;
2567         dma_addr_t dma_handle;
2568         int i, error;
2569         __le64 sas_address;
2570
2571         memset(port_info, 0, sizeof(struct mptsas_portinfo));
2572         hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
2573         hdr.ExtPageLength = 0;
2574         hdr.PageNumber = 0;
2575         hdr.Reserved1 = 0;
2576         hdr.Reserved2 = 0;
2577         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2578         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2579
2580         cfg.cfghdr.ehdr = &hdr;
2581         cfg.physAddr = -1;
2582         cfg.pageAddr = form + form_specific;
2583         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2584         cfg.dir = 0;    /* read */
2585         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2586
2587         memset(port_info, 0, sizeof(struct mptsas_portinfo));
2588         error = mpt_config(ioc, &cfg);
2589         if (error)
2590                 goto out;
2591
2592         if (!hdr.ExtPageLength) {
2593                 error = -ENXIO;
2594                 goto out;
2595         }
2596
2597         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2598                                       &dma_handle);
2599         if (!buffer) {
2600                 error = -ENOMEM;
2601                 goto out;
2602         }
2603
2604         cfg.physAddr = dma_handle;
2605         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2606
2607         error = mpt_config(ioc, &cfg);
2608         if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2609                 error = -ENODEV;
2610                 goto out_free_consistent;
2611         }
2612
2613         if (error)
2614                 goto out_free_consistent;
2615
2616         /* save config data */
2617         port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
2618         port_info->phy_info = kcalloc(port_info->num_phys,
2619                 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2620         if (!port_info->phy_info) {
2621                 error = -ENOMEM;
2622                 goto out_free_consistent;
2623         }
2624
2625         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2626         for (i = 0; i < port_info->num_phys; i++) {
2627                 port_info->phy_info[i].portinfo = port_info;
2628                 port_info->phy_info[i].handle =
2629                     le16_to_cpu(buffer->DevHandle);
2630                 port_info->phy_info[i].identify.sas_address =
2631                     le64_to_cpu(sas_address);
2632                 port_info->phy_info[i].identify.handle_parent =
2633                     le16_to_cpu(buffer->ParentDevHandle);
2634         }
2635
2636  out_free_consistent:
2637         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2638                             buffer, dma_handle);
2639  out:
2640         return error;
2641 }
2642
2643 static int
2644 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2645                 u32 form, u32 form_specific)
2646 {
2647         ConfigExtendedPageHeader_t hdr;
2648         CONFIGPARMS cfg;
2649         SasExpanderPage1_t *buffer;
2650         dma_addr_t dma_handle;
2651         int error=0;
2652
2653         hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
2654         hdr.ExtPageLength = 0;
2655         hdr.PageNumber = 1;
2656         hdr.Reserved1 = 0;
2657         hdr.Reserved2 = 0;
2658         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2659         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2660
2661         cfg.cfghdr.ehdr = &hdr;
2662         cfg.physAddr = -1;
2663         cfg.pageAddr = form + form_specific;
2664         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2665         cfg.dir = 0;    /* read */
2666         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2667
2668         error = mpt_config(ioc, &cfg);
2669         if (error)
2670                 goto out;
2671
2672         if (!hdr.ExtPageLength) {
2673                 error = -ENXIO;
2674                 goto out;
2675         }
2676
2677         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2678                                       &dma_handle);
2679         if (!buffer) {
2680                 error = -ENOMEM;
2681                 goto out;
2682         }
2683
2684         cfg.physAddr = dma_handle;
2685         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2686
2687         error = mpt_config(ioc, &cfg);
2688
2689         if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2690                 error = -ENODEV;
2691                 goto out_free_consistent;
2692         }
2693
2694         if (error)
2695                 goto out_free_consistent;
2696
2697
2698         mptsas_print_expander_pg1(ioc, buffer);
2699
2700         /* save config data */
2701         phy_info->phy_id = buffer->PhyIdentifier;
2702         phy_info->port_id = buffer->PhysicalPort;
2703         phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
2704         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2705         phy_info->hw_link_rate = buffer->HwLinkRate;
2706         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2707         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2708
2709  out_free_consistent:
2710         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2711                             buffer, dma_handle);
2712  out:
2713         return error;
2714 }
2715
2716 struct rep_manu_request{
2717         u8 smp_frame_type;
2718         u8 function;
2719         u8 reserved;
2720         u8 request_length;
2721 };
2722
2723 struct rep_manu_reply{
2724         u8 smp_frame_type; /* 0x41 */
2725         u8 function; /* 0x01 */
2726         u8 function_result;
2727         u8 response_length;
2728         u16 expander_change_count;
2729         u8 reserved0[2];
2730         u8 sas_format:1;
2731         u8 reserved1:7;
2732         u8 reserved2[3];
2733         u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
2734         u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
2735         u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
2736         u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
2737         u16 component_id;
2738         u8 component_revision_id;
2739         u8 reserved3;
2740         u8 vendor_specific[8];
2741 };
2742
2743 /**
2744   * mptsas_exp_repmanufacture_info -
2745   * @ioc: per adapter object
2746   * @sas_address: expander sas address
2747   * @edev: the sas_expander_device object
2748   *
2749   * Fills in the sas_expander_device object when SMP port is created.
2750   *
2751   * Returns 0 for success, non-zero for failure.
2752   */
2753 static int
2754 mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
2755         u64 sas_address, struct sas_expander_device *edev)
2756 {
2757         MPT_FRAME_HDR *mf;
2758         SmpPassthroughRequest_t *smpreq;
2759         SmpPassthroughReply_t *smprep;
2760         struct rep_manu_reply *manufacture_reply;
2761         struct rep_manu_request *manufacture_request;
2762         int ret;
2763         int flagsLength;
2764         unsigned long timeleft;
2765         char *psge;
2766         unsigned long flags;
2767         void *data_out = NULL;
2768         dma_addr_t data_out_dma = 0;
2769         u32 sz;
2770
2771         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2772         if (ioc->ioc_reset_in_progress) {
2773                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2774                 printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
2775                         __func__, ioc->name);
2776                 return -EFAULT;
2777         }
2778         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2779
2780         ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2781         if (ret)
2782                 goto out;
2783
2784         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2785         if (!mf) {
2786                 ret = -ENOMEM;
2787                 goto out_unlock;
2788         }
2789
2790         smpreq = (SmpPassthroughRequest_t *)mf;
2791         memset(smpreq, 0, sizeof(*smpreq));
2792
2793         sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
2794
2795         data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma);
2796         if (!data_out) {
2797                 printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
2798                         __FILE__, __LINE__, __func__);
2799                 ret = -ENOMEM;
2800                 goto put_mf;
2801         }
2802
2803         manufacture_request = data_out;
2804         manufacture_request->smp_frame_type = 0x40;
2805         manufacture_request->function = 1;
2806         manufacture_request->reserved = 0;
2807         manufacture_request->request_length = 0;
2808
2809         smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2810         smpreq->PhysicalPort = 0xFF;
2811         *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2812         smpreq->RequestDataLength = sizeof(struct rep_manu_request);
2813
2814         psge = (char *)
2815                 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2816
2817         flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2818                 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2819                 MPI_SGE_FLAGS_HOST_TO_IOC |
2820                 MPI_SGE_FLAGS_END_OF_BUFFER;
2821         flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2822         flagsLength |= sizeof(struct rep_manu_request);
2823
2824         ioc->add_sge(psge, flagsLength, data_out_dma);
2825         psge += ioc->SGE_size;
2826
2827         flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2828                 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2829                 MPI_SGE_FLAGS_IOC_TO_HOST |
2830                 MPI_SGE_FLAGS_END_OF_BUFFER;
2831         flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2832         flagsLength |= sizeof(struct rep_manu_reply);
2833         ioc->add_sge(psge, flagsLength, data_out_dma +
2834         sizeof(struct rep_manu_request));
2835
2836         INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2837         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2838
2839         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2840         if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2841                 ret = -ETIME;
2842                 mpt_free_msg_frame(ioc, mf);
2843                 mf = NULL;
2844                 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2845                         goto out_free;
2846                 if (!timeleft)
2847                         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2848                 goto out_free;
2849         }
2850
2851         mf = NULL;
2852
2853         if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2854                 u8 *tmp;
2855
2856         smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2857         if (le16_to_cpu(smprep->ResponseDataLength) !=
2858                 sizeof(struct rep_manu_reply))
2859                         goto out_free;
2860
2861         manufacture_reply = data_out + sizeof(struct rep_manu_request);
2862         strncpy(edev->vendor_id, manufacture_reply->vendor_id,
2863                 SAS_EXPANDER_VENDOR_ID_LEN);
2864         strncpy(edev->product_id, manufacture_reply->product_id,
2865                 SAS_EXPANDER_PRODUCT_ID_LEN);
2866         strncpy(edev->product_rev, manufacture_reply->product_rev,
2867                 SAS_EXPANDER_PRODUCT_REV_LEN);
2868         edev->level = manufacture_reply->sas_format;
2869         if (manufacture_reply->sas_format) {
2870                 strncpy(edev->component_vendor_id,
2871                         manufacture_reply->component_vendor_id,
2872                                 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
2873                 tmp = (u8 *)&manufacture_reply->component_id;
2874                 edev->component_id = tmp[0] << 8 | tmp[1];
2875                 edev->component_revision_id =
2876                         manufacture_reply->component_revision_id;
2877                 }
2878         } else {
2879                 printk(MYIOC_s_ERR_FMT
2880                         "%s: smp passthru reply failed to be returned\n",
2881                         ioc->name, __func__);
2882                 ret = -ENXIO;
2883         }
2884 out_free:
2885         if (data_out_dma)
2886                 pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma);
2887 put_mf:
2888         if (mf)
2889                 mpt_free_msg_frame(ioc, mf);
2890 out_unlock:
2891         CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2892         mutex_unlock(&ioc->sas_mgmt.mutex);
2893 out:
2894         return ret;
2895  }
2896
2897 static void
2898 mptsas_parse_device_info(struct sas_identify *identify,
2899                 struct mptsas_devinfo *device_info)
2900 {
2901         u16 protocols;
2902
2903         identify->sas_address = device_info->sas_address;
2904         identify->phy_identifier = device_info->phy_id;
2905
2906         /*
2907          * Fill in Phy Initiator Port Protocol.
2908          * Bits 6:3, more than one bit can be set, fall through cases.
2909          */
2910         protocols = device_info->device_info & 0x78;
2911         identify->initiator_port_protocols = 0;
2912         if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
2913                 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
2914         if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
2915                 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
2916         if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
2917                 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
2918         if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
2919                 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
2920
2921         /*
2922          * Fill in Phy Target Port Protocol.
2923          * Bits 10:7, more than one bit can be set, fall through cases.
2924          */
2925         protocols = device_info->device_info & 0x780;
2926         identify->target_port_protocols = 0;
2927         if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
2928                 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
2929         if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
2930                 identify->target_port_protocols |= SAS_PROTOCOL_STP;
2931         if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
2932                 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
2933         if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2934                 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
2935
2936         /*
2937          * Fill in Attached device type.
2938          */
2939         switch (device_info->device_info &
2940                         MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
2941         case MPI_SAS_DEVICE_INFO_NO_DEVICE:
2942                 identify->device_type = SAS_PHY_UNUSED;
2943                 break;
2944         case MPI_SAS_DEVICE_INFO_END_DEVICE:
2945                 identify->device_type = SAS_END_DEVICE;
2946                 break;
2947         case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
2948                 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
2949                 break;
2950         case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
2951                 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
2952                 break;
2953         }
2954 }
2955
2956 static int mptsas_probe_one_phy(struct device *dev,
2957                 struct mptsas_phyinfo *phy_info, int index, int local)
2958 {
2959         MPT_ADAPTER *ioc;
2960         struct sas_phy *phy;
2961         struct sas_port *port;
2962         int error = 0;
2963
2964         if (!dev) {
2965                 error = -ENODEV;
2966                 goto out;
2967         }
2968
2969         if (!phy_info->phy) {
2970                 phy = sas_phy_alloc(dev, index);
2971                 if (!phy) {
2972                         error = -ENOMEM;
2973                         goto out;
2974                 }
2975         } else
2976                 phy = phy_info->phy;
2977
2978         mptsas_parse_device_info(&phy->identify, &phy_info->identify);
2979
2980         /*
2981          * Set Negotiated link rate.
2982          */
2983         switch (phy_info->negotiated_link_rate) {
2984         case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
2985                 phy->negotiated_linkrate = SAS_PHY_DISABLED;
2986                 break;
2987         case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
2988                 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
2989                 break;
2990         case MPI_SAS_IOUNIT0_RATE_1_5:
2991                 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
2992                 break;
2993         case MPI_SAS_IOUNIT0_RATE_3_0:
2994                 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
2995                 break;
2996         case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
2997         case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
2998         default:
2999                 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
3000                 break;
3001         }
3002
3003         /*
3004          * Set Max hardware link rate.
3005          */
3006         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3007         case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
3008                 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3009                 break;
3010         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3011                 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3012                 break;
3013         default:
3014                 break;
3015         }
3016
3017         /*
3018          * Set Max programmed link rate.
3019          */
3020         switch (phy_info->programmed_link_rate &
3021                         MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3022         case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
3023                 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3024                 break;
3025         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3026                 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3027                 break;
3028         default:
3029                 break;
3030         }
3031
3032         /*
3033          * Set Min hardware link rate.
3034          */
3035         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
3036         case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
3037                 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3038                 break;
3039         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3040                 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3041                 break;
3042         default:
3043                 break;
3044         }
3045
3046         /*
3047          * Set Min programmed link rate.
3048          */
3049         switch (phy_info->programmed_link_rate &
3050                         MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
3051         case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
3052                 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3053                 break;
3054         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3055                 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3056                 break;
3057         default:
3058                 break;
3059         }
3060
3061         if (!phy_info->phy) {
3062
3063                 error = sas_phy_add(phy);
3064                 if (error) {
3065                         sas_phy_free(phy);
3066                         goto out;
3067                 }
3068                 phy_info->phy = phy;
3069         }
3070
3071         if (!phy_info->attached.handle ||
3072                         !phy_info->port_details)
3073                 goto out;
3074
3075         port = mptsas_get_port(phy_info);
3076         ioc = phy_to_ioc(phy_info->phy);
3077
3078         if (phy_info->sas_port_add_phy) {
3079
3080                 if (!port) {
3081                         port = sas_port_alloc_num(dev);
3082                         if (!port) {
3083                                 error = -ENOMEM;
3084                                 goto out;
3085                         }
3086                         error = sas_port_add(port);
3087                         if (error) {
3088                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3089                                         "%s: exit at line=%d\n", ioc->name,
3090                                         __func__, __LINE__));
3091                                 goto out;
3092                         }
3093                         mptsas_set_port(ioc, phy_info, port);
3094                         devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
3095                             MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
3096                             ioc->name, port->port_identifier,
3097                             (unsigned long long)phy_info->
3098                             attached.sas_address));
3099                 }
3100                 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3101                         "sas_port_add_phy: phy_id=%d\n",
3102                         ioc->name, phy_info->phy_id));
3103                 sas_port_add_phy(port, phy_info->phy);
3104                 phy_info->sas_port_add_phy = 0;
3105                 devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3106                     MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
3107                      phy_info->phy_id, phy_info->phy));
3108         }
3109         if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
3110
3111                 struct sas_rphy *rphy;
3112                 struct device *parent;
3113                 struct sas_identify identify;
3114
3115                 parent = dev->parent->parent;
3116                 /*
3117                  * Let the hotplug_work thread handle processing
3118                  * the adding/removing of devices that occur
3119                  * after start of day.
3120                  */
3121                 if (mptsas_is_end_device(&phy_info->attached) &&
3122                     phy_info->attached.handle_parent) {
3123                         goto out;
3124                 }
3125
3126                 mptsas_parse_device_info(&identify, &phy_info->attached);
3127                 if (scsi_is_host_device(parent)) {
3128                         struct mptsas_portinfo *port_info;
3129                         int i;
3130
3131                         port_info = ioc->hba_port_info;
3132
3133                         for (i = 0; i < port_info->num_phys; i++)
3134                                 if (port_info->phy_info[i].identify.sas_address ==
3135                                     identify.sas_address) {
3136                                         sas_port_mark_backlink(port);
3137                                         goto out;
3138                                 }
3139
3140                 } else if (scsi_is_sas_rphy(parent)) {
3141                         struct sas_rphy *parent_rphy = dev_to_rphy(parent);
3142                         if (identify.sas_address ==
3143                             parent_rphy->identify.sas_address) {
3144                                 sas_port_mark_backlink(port);
3145                                 goto out;
3146                         }
3147                 }
3148
3149                 switch (identify.device_type) {
3150                 case SAS_END_DEVICE:
3151                         rphy = sas_end_device_alloc(port);
3152                         break;
3153                 case SAS_EDGE_EXPANDER_DEVICE:
3154                 case SAS_FANOUT_EXPANDER_DEVICE:
3155                         rphy = sas_expander_alloc(port, identify.device_type);
3156                         break;
3157                 default:
3158                         rphy = NULL;
3159                         break;
3160                 }
3161                 if (!rphy) {
3162                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3163                                 "%s: exit at line=%d\n", ioc->name,
3164                                 __func__, __LINE__));
3165                         goto out;
3166                 }
3167
3168                 rphy->identify = identify;
3169                 error = sas_rphy_add(rphy);
3170                 if (error) {
3171                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3172                                 "%s: exit at line=%d\n", ioc->name,
3173                                 __func__, __LINE__));
3174                         sas_rphy_free(rphy);
3175                         goto out;
3176                 }
3177                 mptsas_set_rphy(ioc, phy_info, rphy);
3178                 if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
3179                         identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
3180                                 mptsas_exp_repmanufacture_info(ioc,
3181                                         identify.sas_address,
3182                                         rphy_to_expander_device(rphy));
3183         }
3184
3185  out:
3186         return error;
3187 }
3188
3189 static int
3190 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
3191 {
3192         struct mptsas_portinfo *port_info, *hba;
3193         int error = -ENOMEM, i;
3194
3195         hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3196         if (! hba)
3197                 goto out;
3198
3199         error = mptsas_sas_io_unit_pg0(ioc, hba);
3200         if (error)
3201                 goto out_free_port_info;
3202
3203         mptsas_sas_io_unit_pg1(ioc);
3204         mutex_lock(&ioc->sas_topology_mutex);
3205         port_info = ioc->hba_port_info;
3206         if (!port_info) {
3207                 ioc->hba_port_info = port_info = hba;
3208                 ioc->hba_port_num_phy = port_info->num_phys;
3209                 list_add_tail(&port_info->list, &ioc->sas_topology);
3210         } else {
3211                 for (i = 0; i < hba->num_phys; i++) {
3212                         port_info->phy_info[i].negotiated_link_rate =
3213                                 hba->phy_info[i].negotiated_link_rate;
3214                         port_info->phy_info[i].handle =
3215                                 hba->phy_info[i].handle;
3216                         port_info->phy_info[i].port_id =
3217                                 hba->phy_info[i].port_id;
3218                 }
3219                 kfree(hba->phy_info);
3220                 kfree(hba);
3221                 hba = NULL;
3222         }
3223         mutex_unlock(&ioc->sas_topology_mutex);
3224 #if defined(CPQ_CIM)
3225         ioc->num_ports = port_info->num_phys;
3226 #endif
3227         for (i = 0; i < port_info->num_phys; i++) {
3228                 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
3229                         (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
3230                          MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
3231                 port_info->phy_info[i].identify.handle =
3232                     port_info->phy_info[i].handle;
3233                 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
3234                         (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3235                          MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3236                          port_info->phy_info[i].identify.handle);
3237                 if (!ioc->hba_port_sas_addr)
3238                         ioc->hba_port_sas_addr =
3239                             port_info->phy_info[i].identify.sas_address;
3240                 port_info->phy_info[i].identify.phy_id =
3241                     port_info->phy_info[i].phy_id = i;
3242                 if (port_info->phy_info[i].attached.handle)
3243                         mptsas_sas_device_pg0(ioc,
3244                                 &port_info->phy_info[i].attached,
3245                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3246                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3247                                 port_info->phy_info[i].attached.handle);
3248         }
3249
3250         mptsas_setup_wide_ports(ioc, port_info);
3251
3252         for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3253                 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
3254                     &port_info->phy_info[i], ioc->sas_index, 1);
3255
3256         return 0;
3257
3258  out_free_port_info:
3259         kfree(hba);
3260  out:
3261         return error;
3262 }
3263
3264 static void
3265 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
3266 {
3267         struct mptsas_portinfo *parent;
3268         struct device *parent_dev;
3269         struct sas_rphy *rphy;
3270         int             i;
3271         u64             sas_address; /* expander sas address */
3272         u32             handle;
3273
3274         handle = port_info->phy_info[0].handle;
3275         sas_address = port_info->phy_info[0].identify.sas_address;
3276         for (i = 0; i < port_info->num_phys; i++) {
3277                 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
3278                     (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
3279                     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
3280
3281                 mptsas_sas_device_pg0(ioc,
3282                     &port_info->phy_info[i].identify,
3283                     (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3284                     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3285                     port_info->phy_info[i].identify.handle);
3286                 port_info->phy_info[i].identify.phy_id =
3287                     port_info->phy_info[i].phy_id;
3288
3289                 if (port_info->phy_info[i].attached.handle) {
3290                         mptsas_sas_device_pg0(ioc,
3291                             &port_info->phy_info[i].attached,
3292                             (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3293                              MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3294                             port_info->phy_info[i].attached.handle);
3295                         port_info->phy_info[i].attached.phy_id =
3296                             port_info->phy_info[i].phy_id;
3297                 }
3298         }
3299
3300         mutex_lock(&ioc->sas_topology_mutex);
3301         parent = mptsas_find_portinfo_by_handle(ioc,
3302             port_info->phy_info[0].identify.handle_parent);
3303         if (!parent) {
3304                 mutex_unlock(&ioc->sas_topology_mutex);
3305                 return;
3306         }
3307         for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
3308             i++) {
3309                 if (parent->phy_info[i].attached.sas_address == sas_address) {
3310                         rphy = mptsas_get_rphy(&parent->phy_info[i]);
3311                         parent_dev = &rphy->dev;
3312                 }
3313         }
3314         mutex_unlock(&ioc->sas_topology_mutex);
3315
3316         mptsas_setup_wide_ports(ioc, port_info);
3317         for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3318                 mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
3319                     ioc->sas_index, 0);
3320 }
3321
3322 static void
3323 mptsas_expander_event_add(MPT_ADAPTER *ioc,
3324     MpiEventDataSasExpanderStatusChange_t *expander_data)
3325 {
3326         struct mptsas_portinfo *port_info;
3327         int i;
3328         __le64 sas_address;
3329
3330         port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3331         if (!port_info)
3332                 BUG();
3333         port_info->num_phys = (expander_data->NumPhys) ?
3334             expander_data->NumPhys : 1;
3335         port_info->phy_info = kcalloc(port_info->num_phys,
3336             sizeof(struct mptsas_phyinfo), GFP_KERNEL);
3337         if (!port_info->phy_info)
3338                 BUG();
3339         memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3340         for (i = 0; i < port_info->num_phys; i++) {
3341                 port_info->phy_info[i].portinfo = port_info;
3342                 port_info->phy_info[i].handle =
3343                     le16_to_cpu(expander_data->DevHandle);
3344                 port_info->phy_info[i].identify.sas_address =
3345                     le64_to_cpu(sas_address);
3346                 port_info->phy_info[i].identify.handle_parent =
3347                     le16_to_cpu(expander_data->ParentDevHandle);
3348         }
3349
3350         mutex_lock(&ioc->sas_topology_mutex);
3351         list_add_tail(&port_info->list, &ioc->sas_topology);
3352         mutex_unlock(&ioc->sas_topology_mutex);
3353
3354         printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3355             "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3356             (unsigned long long)sas_address);
3357
3358         mptsas_expander_refresh(ioc, port_info);
3359 }
3360
3361 /**
3362  * mptsas_delete_expander_siblings - remove siblings attached to expander
3363  * @ioc: Pointer to MPT_ADAPTER structure
3364  * @parent: the parent port_info object
3365  * @expander: the expander port_info object
3366  **/
3367 static void
3368 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
3369     *parent, struct mptsas_portinfo *expander)
3370 {
3371         struct mptsas_phyinfo *phy_info;
3372         struct mptsas_portinfo *port_info;
3373         struct sas_rphy *rphy;
3374         int i;
3375
3376         phy_info = expander->phy_info;
3377         for (i = 0; i < expander->num_phys; i++, phy_info++) {
3378                 rphy = mptsas_get_rphy(phy_info);
3379                 if (!rphy)
3380                         continue;
3381                 if (rphy->identify.device_type == SAS_END_DEVICE)
3382                         mptsas_del_end_device(ioc, phy_info);
3383         }
3384
3385         phy_info = expander->phy_info;
3386         for (i = 0; i < expander->num_phys; i++, phy_info++) {
3387                 rphy = mptsas_get_rphy(phy_info);
3388                 if (!rphy)
3389                         continue;
3390                 if (rphy->identify.device_type ==
3391                     MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
3392                     rphy->identify.device_type ==
3393                     MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
3394                         port_info = mptsas_find_portinfo_by_sas_address(ioc,
3395                             rphy->identify.sas_address);
3396                         if (!port_info)
3397                                 continue;
3398                         if (port_info == parent) /* backlink rphy */
3399                                 continue;
3400                         /*
3401                         Delete this expander even if the expdevpage is exists
3402                         because the parent expander is already deleted
3403                         */
3404                         mptsas_expander_delete(ioc, port_info, 1);
3405                 }
3406         }
3407 }
3408
3409
3410 /**
3411  *      mptsas_expander_delete - remove this expander
3412  *      @ioc: Pointer to MPT_ADAPTER structure
3413  *      @port_info: expander port_info struct
3414  *      @force: Flag to forcefully delete the expander
3415  *
3416  **/
3417
3418 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
3419                 struct mptsas_portinfo *port_info, u8 force)
3420 {
3421
3422         struct mptsas_portinfo *parent;
3423         int             i;
3424         u64             expander_sas_address;
3425         struct mptsas_phyinfo *phy_info;
3426         struct mptsas_portinfo buffer;
3427         struct mptsas_portinfo_details *port_details;
3428         struct sas_port *port;
3429
3430         if (!port_info)
3431                 return;
3432
3433         /* see if expander is still there before deleting */
3434         mptsas_sas_expander_pg0(ioc, &buffer,
3435             (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3436             MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
3437             port_info->phy_info[0].identify.handle);
3438
3439         if (buffer.num_phys) {
3440                 kfree(buffer.phy_info);
3441                 if (!force)
3442                         return;
3443         }
3444
3445
3446         /*
3447          * Obtain the port_info instance to the parent port
3448          */
3449         port_details = NULL;
3450         expander_sas_address =
3451             port_info->phy_info[0].identify.sas_address;
3452         parent = mptsas_find_portinfo_by_handle(ioc,
3453             port_info->phy_info[0].identify.handle_parent);
3454         mptsas_delete_expander_siblings(ioc, parent, port_info);
3455         if (!parent)
3456                 goto out;
3457
3458         /*
3459          * Delete rphys in the parent that point
3460          * to this expander.
3461          */
3462         phy_info = parent->phy_info;
3463         port = NULL;
3464         for (i = 0; i < parent->num_phys; i++, phy_info++) {
3465                 if (!phy_info->phy)
3466                         continue;
3467                 if (phy_info->attached.sas_address !=
3468                     expander_sas_address)
3469                         continue;
3470                 if (!port) {
3471                         port = mptsas_get_port(phy_info);
3472                         port_details = phy_info->port_details;
3473                 }
3474                 dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3475                     MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
3476                     phy_info->phy_id, phy_info->phy);
3477                 sas_port_delete_phy(port, phy_info->phy);
3478         }
3479         if (port) {
3480                 dev_printk(KERN_DEBUG, &port->dev,
3481                     MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
3482                     ioc->name, port->port_identifier,
3483                     (unsigned long long)expander_sas_address);
3484                 sas_port_delete(port);
3485                 mptsas_port_delete(ioc, port_details);
3486         }
3487  out:
3488
3489         printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
3490             "sas_addr (0x%llx)\n",  ioc->name, port_info->num_phys,
3491             (unsigned long long)expander_sas_address);
3492
3493         /*
3494          * free link
3495          */
3496         list_del(&port_info->list);
3497         kfree(port_info->phy_info);
3498         kfree(port_info);
3499 }
3500
3501
3502 /**
3503  * mptsas_send_expander_event - expanders events
3504  * @ioc: Pointer to MPT_ADAPTER structure
3505  * @expander_data: event data
3506  *
3507  *
3508  * This function handles adding, removing, and refreshing
3509  * device handles within the expander objects.
3510  */
3511 static void
3512 mptsas_send_expander_event(struct fw_event_work *fw_event)
3513 {
3514         MPT_ADAPTER *ioc;
3515         MpiEventDataSasExpanderStatusChange_t *expander_data;
3516         struct mptsas_portinfo *port_info;
3517         __le64 sas_address;
3518         int i;
3519
3520         ioc = fw_event->ioc;
3521         expander_data = (MpiEventDataSasExpanderStatusChange_t *)
3522             fw_event->event_data;
3523         memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3524         sas_address = le64_to_cpu(sas_address);
3525         port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3526
3527         if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
3528                 if (port_info) {
3529                         for (i = 0; i < port_info->num_phys; i++) {
3530                                 port_info->phy_info[i].portinfo = port_info;
3531                                 port_info->phy_info[i].handle =
3532                                     le16_to_cpu(expander_data->DevHandle);
3533                                 port_info->phy_info[i].identify.sas_address =
3534                                     le64_to_cpu(sas_address);
3535                                 port_info->phy_info[i].identify.handle_parent =
3536                                     le16_to_cpu(expander_data->ParentDevHandle);
3537                         }
3538                         mptsas_expander_refresh(ioc, port_info);
3539                 } else if (!port_info && expander_data->NumPhys)
3540                         mptsas_expander_event_add(ioc, expander_data);
3541         } else if (expander_data->ReasonCode ==
3542             MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
3543                 mptsas_expander_delete(ioc, port_info, 0);
3544
3545         mptsas_free_fw_event(ioc, fw_event);
3546 }
3547
3548
3549 /**
3550  * mptsas_expander_add -
3551  * @ioc: Pointer to MPT_ADAPTER structure
3552  * @handle:
3553  *
3554  */
3555 struct mptsas_portinfo *
3556 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
3557 {
3558         struct mptsas_portinfo buffer, *port_info;
3559         int i;
3560
3561         if ((mptsas_sas_expander_pg0(ioc, &buffer,
3562             (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3563             MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
3564                 return NULL;
3565
3566         port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC);
3567         if (!port_info) {
3568                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3569                 "%s: exit at line=%d\n", ioc->name,
3570                 __func__, __LINE__));
3571                 return NULL;
3572         }
3573         port_info->num_phys = buffer.num_phys;
3574         port_info->phy_info = buffer.phy_info;
3575         for (i = 0; i < port_info->num_phys; i++)
3576                 port_info->phy_info[i].portinfo = port_info;
3577         mutex_lock(&ioc->sas_topology_mutex);
3578         list_add_tail(&port_info->list, &ioc->sas_topology);
3579         mutex_unlock(&ioc->sas_topology_mutex);
3580         printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3581             "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3582             (unsigned long long)buffer.phy_info[0].identify.sas_address);
3583         mptsas_expander_refresh(ioc, port_info);
3584         return port_info;
3585 }
3586
3587 static void
3588 mptsas_send_link_status_event(struct fw_event_work *fw_event)
3589 {
3590         MPT_ADAPTER *ioc;
3591         MpiEventDataSasPhyLinkStatus_t *link_data;
3592         struct mptsas_portinfo *port_info;
3593         struct mptsas_phyinfo *phy_info = NULL;
3594         __le64 sas_address;
3595         u8 phy_num;
3596         u8 link_rate;
3597
3598         ioc = fw_event->ioc;
3599         link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
3600
3601         memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
3602         sas_address = le64_to_cpu(sas_address);
3603         link_rate = link_data->LinkRates >> 4;
3604         phy_num = link_data->PhyNum;
3605
3606         port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3607         if (port_info) {
3608                 phy_info = &port_info->phy_info[phy_num];
3609                 if (phy_info)
3610                         phy_info->negotiated_link_rate = link_rate;
3611         }
3612
3613         if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
3614             link_rate == MPI_SAS_IOUNIT0_RATE_3_0) {
3615
3616                 if (!port_info) {
3617                         if (ioc->old_sas_discovery_protocal) {
3618                                 port_info = mptsas_expander_add(ioc,
3619                                         le16_to_cpu(link_data->DevHandle));
3620                                 if (port_info)
3621                                         goto out;
3622                         }
3623                         goto out;
3624                 }
3625
3626                 if (port_info == ioc->hba_port_info)
3627                         mptsas_probe_hba_phys(ioc);
3628                 else
3629                         mptsas_expander_refresh(ioc, port_info);
3630         } else if (phy_info && phy_info->phy) {
3631                 if (link_rate ==  MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
3632                         phy_info->phy->negotiated_linkrate =
3633                             SAS_PHY_DISABLED;
3634                 else if (link_rate ==
3635                     MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
3636                         phy_info->phy->negotiated_linkrate =
3637                             SAS_LINK_RATE_FAILED;
3638                 else
3639                         phy_info->phy->negotiated_linkrate =
3640                             SAS_LINK_RATE_UNKNOWN;
3641         }
3642  out:
3643         mptsas_free_fw_event(ioc, fw_event);
3644 }
3645
3646 static void
3647 mptsas_not_responding_devices(MPT_ADAPTER *ioc)
3648 {
3649         struct mptsas_portinfo buffer, *port_info;
3650         struct mptsas_device_info       *sas_info;
3651         struct mptsas_devinfo sas_device;
3652         u32     handle;
3653         VirtTarget *vtarget = NULL;
3654         struct mptsas_phyinfo *phy_info;
3655         u8 found_expander;
3656         int retval, retry_count;
3657         unsigned long flags;
3658
3659         mpt_findImVolumes(ioc);
3660
3661         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3662         if (ioc->ioc_reset_in_progress) {
3663                 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3664                    "%s: exiting due to a parallel reset \n", ioc->name,
3665                     __func__));
3666                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3667                 return;
3668         }
3669         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3670
3671         /* devices, logical volumes */
3672         mutex_lock(&ioc->sas_device_info_mutex);
3673  redo_device_scan:
3674         list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
3675                 if (sas_info->is_cached)
3676                         continue;
3677                 if (!sas_info->is_logical_volume) {
3678                         sas_device.handle = 0;
3679                         retry_count = 0;
3680 retry_page:
3681                         retval = mptsas_sas_device_pg0(ioc, &sas_device,
3682                                 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID
3683                                 << MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3684                                 (sas_info->fw.channel << 8) +
3685                                 sas_info->fw.id);
3686
3687                         if (sas_device.handle)
3688                                 continue;
3689                         if (retval == -EBUSY) {
3690                                 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3691                                 if (ioc->ioc_reset_in_progress) {
3692                                         dfailprintk(ioc,
3693                                         printk(MYIOC_s_DEBUG_FMT
3694                                         "%s: exiting due to reset\n",
3695                                         ioc->name, __func__));
3696                                         spin_unlock_irqrestore
3697                                         (&ioc->taskmgmt_lock, flags);
3698                                         mutex_unlock(&ioc->
3699                                         sas_device_info_mutex);
3700                                         return;
3701                                 }
3702                                 spin_unlock_irqrestore(&ioc->taskmgmt_lock,
3703                                 flags);
3704                         }
3705
3706                         if (retval && (retval != -ENODEV)) {
3707                                 if (retry_count < 10) {
3708                                         retry_count++;
3709                                         goto retry_page;
3710                                 } else {
3711                                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3712                                         "%s: Config page retry exceeded retry "
3713                                         "count deleting device 0x%llx\n",
3714                                         ioc->name, __func__,
3715                                         sas_info->sas_address));
3716                                 }
3717                         }
3718
3719                         /* delete device */
3720                         vtarget = mptsas_find_vtarget(ioc,
3721                                 sas_info->fw.channel, sas_info->fw.id);
3722
3723                         if (vtarget)
3724                                 vtarget->deleted = 1;
3725
3726                         phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
3727                                         sas_info->sas_address);
3728
3729                         if (phy_info) {
3730                                 mptsas_del_end_device(ioc, phy_info);
3731                                 goto redo_device_scan;
3732                         }
3733                 } else
3734                         mptsas_volume_delete(ioc, sas_info->fw.id);
3735         }
3736         mutex_unlock(&ioc->sas_device_info_mutex);
3737
3738         /* expanders */
3739         mutex_lock(&ioc->sas_topology_mutex);
3740  redo_expander_scan:
3741         list_for_each_entry(port_info, &ioc->sas_topology, list) {
3742
3743                 if (port_info->phy_info &&
3744                     (!(port_info->phy_info[0].identify.device_info &
3745                     MPI_SAS_DEVICE_INFO_SMP_TARGET)))
3746                         continue;
3747                 found_expander = 0;
3748                 handle = 0xFFFF;
3749                 while (!mptsas_sas_expander_pg0(ioc, &buffer,
3750                     (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3751                      MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
3752                     !found_expander) {
3753
3754                         handle = buffer.phy_info[0].handle;
3755                         if (buffer.phy_info[0].identify.sas_address ==
3756                             port_info->phy_info[0].identify.sas_address) {
3757                                 found_expander = 1;
3758                         }
3759                         kfree(buffer.phy_info);
3760                 }
3761
3762                 if (!found_expander) {
3763                         mptsas_expander_delete(ioc, port_info, 0);
3764                         goto redo_expander_scan;
3765                 }
3766         }
3767         mutex_unlock(&ioc->sas_topology_mutex);
3768 }
3769
3770 /**
3771  *      mptsas_probe_expanders - adding expanders
3772  *      @ioc: Pointer to MPT_ADAPTER structure
3773  *
3774  **/
3775 static void
3776 mptsas_probe_expanders(MPT_ADAPTER *ioc)
3777 {
3778         struct mptsas_portinfo buffer, *port_info;
3779         u32                     handle;
3780         int i;
3781
3782         handle = 0xFFFF;
3783         while (!mptsas_sas_expander_pg0(ioc, &buffer,
3784             (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3785              MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
3786
3787                 handle = buffer.phy_info[0].handle;
3788                 port_info = mptsas_find_portinfo_by_sas_address(ioc,
3789                     buffer.phy_info[0].identify.sas_address);
3790
3791                 if (port_info) {
3792                         /* refreshing handles */
3793                         for (i = 0; i < buffer.num_phys; i++) {
3794                                 port_info->phy_info[i].handle = handle;
3795                                 port_info->phy_info[i].identify.handle_parent =
3796                                     buffer.phy_info[0].identify.handle_parent;
3797                         }
3798                         mptsas_expander_refresh(ioc, port_info);
3799                         kfree(buffer.phy_info);
3800                         continue;
3801                 }
3802
3803                 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3804                 if (!port_info) {
3805                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3806                         "%s: exit at line=%d\n", ioc->name,
3807                         __func__, __LINE__));
3808                         return;
3809                 }
3810                 port_info->num_phys = buffer.num_phys;
3811                 port_info->phy_info = buffer.phy_info;
3812                 for (i = 0; i < port_info->num_phys; i++)
3813                         port_info->phy_info[i].portinfo = port_info;
3814                 mutex_lock(&ioc->sas_topology_mutex);
3815                 list_add_tail(&port_info->list, &ioc->sas_topology);
3816                 mutex_unlock(&ioc->sas_topology_mutex);
3817                 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3818                     "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3819             (unsigned long long)buffer.phy_info[0].identify.sas_address);
3820                 mptsas_expander_refresh(ioc, port_info);
3821         }
3822 }
3823
3824 static void
3825 mptsas_probe_devices(MPT_ADAPTER *ioc)
3826 {
3827         u16 handle;
3828         struct mptsas_devinfo sas_device;
3829         struct mptsas_phyinfo *phy_info;
3830
3831         handle = 0xFFFF;
3832         while (!(mptsas_sas_device_pg0(ioc, &sas_device,
3833             MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
3834
3835                 handle = sas_device.handle;
3836
3837                 if ((sas_device.device_info &
3838                      (MPI_SAS_DEVICE_INFO_SSP_TARGET |
3839                       MPI_SAS_DEVICE_INFO_STP_TARGET |
3840                       MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
3841                         continue;
3842
3843                 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
3844                 if (!phy_info)
3845                         continue;
3846
3847                 if (mptsas_get_rphy(phy_info))
3848                         continue;
3849
3850                 mptsas_add_end_device(ioc, phy_info);
3851         }
3852 }
3853
3854 /**
3855  *      mptsas_scan_sas_topology -
3856  *      @ioc: Pointer to MPT_ADAPTER structure
3857  *      @sas_address:
3858  *
3859  **/
3860 static void
3861 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
3862 {
3863         struct scsi_device *sdev;
3864         int i;
3865
3866         mptsas_probe_hba_phys(ioc);
3867         mptsas_probe_expanders(ioc);
3868         mptsas_probe_devices(ioc);
3869
3870         /*
3871           Reporting RAID volumes.
3872         */
3873         if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
3874             !ioc->raid_data.pIocPg2->NumActiveVolumes)
3875                 return;
3876         for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
3877                 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
3878                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
3879                 if (sdev) {
3880                         scsi_device_put(sdev);
3881                         continue;
3882                 }
3883                 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
3884                     "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
3885                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
3886                 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
3887                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
3888         }
3889 }
3890
3891
3892 static void
3893 mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
3894 {
3895         MPT_ADAPTER *ioc;
3896         EventDataQueueFull_t *qfull_data;
3897         struct mptsas_device_info *sas_info;
3898         struct scsi_device      *sdev;
3899         int depth;
3900         int id = -1;
3901         int channel = -1;
3902         int fw_id, fw_channel;
3903         u16 current_depth;
3904
3905
3906         ioc = fw_event->ioc;
3907         qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
3908         fw_id = qfull_data->TargetID;
3909         fw_channel = qfull_data->Bus;
3910         current_depth = le16_to_cpu(qfull_data->CurrentDepth);
3911
3912         /* if hidden raid component, look for the volume id */
3913         mutex_lock(&ioc->sas_device_info_mutex);
3914         if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
3915                 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
3916                     list) {
3917                         if (sas_info->is_cached ||
3918                             sas_info->is_logical_volume)
3919                                 continue;
3920                         if (sas_info->is_hidden_raid_component &&
3921                             (sas_info->fw.channel == fw_channel &&
3922                             sas_info->fw.id == fw_id)) {
3923                                 id = sas_info->volume_id;
3924                                 channel = MPTSAS_RAID_CHANNEL;
3925                                 goto out;
3926                         }
3927                 }
3928         } else {
3929                 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
3930                     list) {
3931                         if (sas_info->is_cached ||
3932                             sas_info->is_hidden_raid_component ||
3933                             sas_info->is_logical_volume)
3934                                 continue;
3935                         if (sas_info->fw.channel == fw_channel &&
3936                             sas_info->fw.id == fw_id) {
3937                                 id = sas_info->os.id;
3938                                 channel = sas_info->os.channel;
3939                                 goto out;
3940                         }
3941                 }
3942
3943         }
3944
3945  out:
3946         mutex_unlock(&ioc->sas_device_info_mutex);
3947
3948         if (id != -1) {
3949                 shost_for_each_device(sdev, ioc->sh) {
3950                         if (sdev->id == id && sdev->channel == channel) {
3951                                 if (current_depth > sdev->queue_depth) {
3952                                         sdev_printk(KERN_INFO, sdev,
3953                                             "strange observation, the queue "
3954                                             "depth is (%d) meanwhile fw queue "
3955                                             "depth (%d)\n", sdev->queue_depth,
3956                                             current_depth);
3957                                         continue;
3958                                 }
3959                                 depth = scsi_track_queue_full(sdev,
3960                                     current_depth - 1);
3961                                 if (depth > 0)
3962                                         sdev_printk(KERN_INFO, sdev,
3963                                         "Queue depth reduced to (%d)\n",
3964                                            depth);
3965                                 else if (depth < 0)
3966                                         sdev_printk(KERN_INFO, sdev,
3967                                         "Tagged Command Queueing is being "
3968                                         "disabled\n");
3969                                 else if (depth == 0)
3970                                         sdev_printk(KERN_INFO, sdev,
3971                                         "Queue depth not changed yet\n");
3972                         }
3973                 }
3974         }
3975
3976         mptsas_free_fw_event(ioc, fw_event);
3977 }
3978
3979
3980 static struct mptsas_phyinfo *
3981 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
3982 {
3983         struct mptsas_portinfo *port_info;
3984         struct mptsas_phyinfo *phy_info = NULL;
3985         int i;
3986
3987         mutex_lock(&ioc->sas_topology_mutex);
3988         list_for_each_entry(port_info, &ioc->sas_topology, list) {
3989                 for (i = 0; i < port_info->num_phys; i++) {
3990                         if (!mptsas_is_end_device(
3991                                 &port_info->phy_info[i].attached))
3992                                 continue;
3993                         if (port_info->phy_info[i].attached.sas_address
3994                             != sas_address)
3995                                 continue;
3996                         phy_info = &port_info->phy_info[i];
3997                         break;
3998                 }
3999         }
4000         mutex_unlock(&ioc->sas_topology_mutex);
4001         return phy_info;
4002 }
4003
4004 /**
4005  *      mptsas_find_phyinfo_by_phys_disk_num -
4006  *      @ioc: Pointer to MPT_ADAPTER structure
4007  *      @phys_disk_num:
4008  *      @channel:
4009  *      @id:
4010  *
4011  **/
4012 static struct mptsas_phyinfo *
4013 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
4014         u8 channel, u8 id)
4015 {
4016         struct mptsas_phyinfo *phy_info = NULL;
4017         struct mptsas_portinfo *port_info;
4018         RaidPhysDiskPage1_t *phys_disk = NULL;
4019         int num_paths;
4020         u64 sas_address = 0;
4021         int i;
4022
4023         phy_info = NULL;
4024         if (!ioc->raid_data.pIocPg3)
4025                 return NULL;
4026         /* dual port support */
4027         num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
4028         if (!num_paths)
4029                 goto out;
4030         phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
4031            (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
4032         if (!phys_disk)
4033                 goto out;
4034         mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
4035         for (i = 0; i < num_paths; i++) {
4036                 if ((phys_disk->Path[i].Flags & 1) != 0)
4037                         /* entry no longer valid */
4038                         continue;
4039                 if ((id == phys_disk->Path[i].PhysDiskID) &&
4040                     (channel == phys_disk->Path[i].PhysDiskBus)) {
4041                         memcpy(&sas_address, &phys_disk->Path[i].WWID,
4042                                 sizeof(u64));
4043                         phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4044                                         sas_address);
4045                         goto out;
4046                 }
4047         }
4048
4049  out:
4050         kfree(phys_disk);
4051         if (phy_info)
4052                 return phy_info;
4053
4054         /*
4055          * Extra code to handle RAID0 case, where the sas_address is not updated
4056          * in phys_disk_page_1 when hotswapped
4057          */
4058         mutex_lock(&ioc->sas_topology_mutex);
4059         list_for_each_entry(port_info, &ioc->sas_topology, list) {
4060                 for (i = 0; i < port_info->num_phys && !phy_info; i++) {
4061                         if (!mptsas_is_end_device(
4062                                 &port_info->phy_info[i].attached))
4063                                 continue;
4064                         if (port_info->phy_info[i].attached.phys_disk_num == ~0)
4065                                 continue;
4066                         if ((port_info->phy_info[i].attached.phys_disk_num ==
4067                             phys_disk_num) &&
4068                             (port_info->phy_info[i].attached.id == id) &&
4069                             (port_info->phy_info[i].attached.channel ==
4070                              channel))
4071                                 phy_info = &port_info->phy_info[i];
4072                 }
4073         }
4074         mutex_unlock(&ioc->sas_topology_mutex);
4075         return phy_info;
4076 }
4077
4078 static void
4079 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
4080 {
4081         int rc;
4082
4083         sdev->no_uld_attach = data ? 1 : 0;
4084         rc = scsi_device_reprobe(sdev);
4085 }
4086
4087 static void
4088 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
4089 {
4090         starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
4091                         mptsas_reprobe_lun);
4092 }
4093
4094 static void
4095 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
4096 {
4097         CONFIGPARMS                     cfg;
4098         ConfigPageHeader_t              hdr;
4099         dma_addr_t                      dma_handle;
4100         pRaidVolumePage0_t              buffer = NULL;
4101         RaidPhysDiskPage0_t             phys_disk;
4102         int                             i;
4103         struct mptsas_phyinfo   *phy_info;
4104         struct mptsas_devinfo           sas_device;
4105
4106         memset(&cfg, 0 , sizeof(CONFIGPARMS));
4107         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
4108         hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
4109         cfg.pageAddr = (channel << 8) + id;
4110         cfg.cfghdr.hdr = &hdr;
4111         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4112         cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
4113
4114         if (mpt_config(ioc, &cfg) != 0)
4115                 goto out;
4116
4117         if (!hdr.PageLength)
4118                 goto out;
4119
4120         buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
4121             &dma_handle);
4122
4123         if (!buffer)
4124                 goto out;
4125
4126         cfg.physAddr = dma_handle;
4127         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4128
4129         if (mpt_config(ioc, &cfg) != 0)
4130                 goto out;
4131
4132         if (!(buffer->VolumeStatus.Flags &
4133             MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
4134                 goto out;
4135
4136         if (!buffer->NumPhysDisks)
4137                 goto out;
4138
4139         for (i = 0; i < buffer->NumPhysDisks; i++) {
4140
4141                 if (mpt_raid_phys_disk_pg0(ioc,
4142                     buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
4143                         continue;
4144
4145                 if (mptsas_sas_device_pg0(ioc, &sas_device,
4146                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4147                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4148                         (phys_disk.PhysDiskBus << 8) +
4149                         phys_disk.PhysDiskID))
4150                         continue;
4151
4152                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4153                     sas_device.sas_address);
4154                 mptsas_add_end_device(ioc, phy_info);
4155         }
4156
4157  out:
4158         if (buffer)
4159                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
4160                     dma_handle);
4161 }
4162 /*
4163  * Work queue thread to handle SAS hotplug events
4164  */
4165 static void
4166 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
4167     struct mptsas_hotplug_event *hot_plug_info)
4168 {
4169         struct mptsas_phyinfo *phy_info;
4170         struct scsi_target * starget;
4171         struct mptsas_devinfo sas_device;
4172         VirtTarget *vtarget;
4173         int i;
4174
4175         switch (hot_plug_info->event_type) {
4176
4177         case MPTSAS_ADD_PHYSDISK:
4178
4179                 if (!ioc->raid_data.pIocPg2)
4180                         break;
4181
4182                 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4183                         if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
4184                             hot_plug_info->id) {
4185                                 printk(MYIOC_s_WARN_FMT "firmware bug: unable "
4186                                     "to add hidden disk - target_id matchs "
4187                                     "volume_id\n", ioc->name);
4188                                 mptsas_free_fw_event(ioc, fw_event);
4189                                 return;
4190                         }
4191                 }
4192                 mpt_findImVolumes(ioc);
4193
4194         case MPTSAS_ADD_DEVICE:
4195                 memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
4196                 mptsas_sas_device_pg0(ioc, &sas_device,
4197                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4198                     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4199                     (hot_plug_info->channel << 8) +
4200                     hot_plug_info->id);
4201
4202                 if (!sas_device.handle)
4203                         return;
4204
4205                 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
4206                 if (!phy_info)
4207                         break;
4208
4209                 if (mptsas_get_rphy(phy_info))
4210                         break;
4211
4212                 mptsas_add_end_device(ioc, phy_info);
4213                 break;
4214
4215         case MPTSAS_DEL_DEVICE:
4216                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4217                     hot_plug_info->sas_address);
4218                 mptsas_del_end_device(ioc, phy_info);
4219                 break;
4220
4221         case MPTSAS_DEL_PHYSDISK:
4222
4223                 mpt_findImVolumes(ioc);
4224
4225                 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
4226                                 ioc, hot_plug_info->phys_disk_num,
4227                                 hot_plug_info->channel,
4228                                 hot_plug_info->id);
4229                 mptsas_del_end_device(ioc, phy_info);
4230                 break;
4231
4232         case MPTSAS_ADD_PHYSDISK_REPROBE:
4233
4234                 if (mptsas_sas_device_pg0(ioc, &sas_device,
4235                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4236                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4237                     (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4238                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4239                         "%s: fw_id=%d exit at line=%d\n", ioc->name,
4240                                  __func__, hot_plug_info->id, __LINE__));
4241                         break;
4242                 }
4243
4244                 phy_info = mptsas_find_phyinfo_by_sas_address(
4245                     ioc, sas_device.sas_address);
4246
4247                 if (!phy_info) {
4248                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4249                                 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4250                                  __func__, hot_plug_info->id, __LINE__));
4251                         break;
4252                 }
4253
4254                 starget = mptsas_get_starget(phy_info);
4255                 if (!starget) {
4256                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4257                                 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4258                                  __func__, hot_plug_info->id, __LINE__));
4259                         break;
4260                 }
4261
4262                 vtarget = starget->hostdata;
4263                 if (!vtarget) {
4264                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4265                                 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4266                                  __func__, hot_plug_info->id, __LINE__));
4267                         break;
4268                 }
4269
4270                 mpt_findImVolumes(ioc);
4271
4272                 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
4273                     "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4274                     ioc->name, hot_plug_info->channel, hot_plug_info->id,
4275                     hot_plug_info->phys_disk_num, (unsigned long long)
4276                     sas_device.sas_address);
4277
4278                 vtarget->id = hot_plug_info->phys_disk_num;
4279                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4280                 phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
4281                 mptsas_reprobe_target(starget, 1);
4282                 break;
4283
4284         case MPTSAS_DEL_PHYSDISK_REPROBE:
4285
4286                 if (mptsas_sas_device_pg0(ioc, &sas_device,
4287                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4288                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4289                         (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4290                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4291                                     "%s: fw_id=%d exit at line=%d\n",
4292                                     ioc->name, __func__,
4293                                     hot_plug_info->id, __LINE__));
4294                         break;
4295                 }
4296
4297                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4298                                 sas_device.sas_address);
4299                 if (!phy_info) {
4300                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4301                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4302                          __func__, hot_plug_info->id, __LINE__));
4303                         break;
4304                 }
4305
4306                 starget = mptsas_get_starget(phy_info);
4307                 if (!starget) {
4308                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4309                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4310                          __func__, hot_plug_info->id, __LINE__));
4311                         break;
4312                 }
4313
4314                 vtarget = starget->hostdata;
4315                 if (!vtarget) {
4316                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4317                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4318                          __func__, hot_plug_info->id, __LINE__));
4319                         break;
4320                 }
4321
4322                 if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
4323                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4324                             "%s: fw_id=%d exit at line=%d\n", ioc->name,
4325                          __func__, hot_plug_info->id, __LINE__));
4326                         break;
4327                 }
4328
4329                 mpt_findImVolumes(ioc);
4330
4331                 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
4332                     " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4333                     ioc->name, hot_plug_info->channel, hot_plug_info->id,
4334                     hot_plug_info->phys_disk_num, (unsigned long long)
4335                     sas_device.sas_address);
4336
4337                 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4338                 vtarget->id = hot_plug_info->id;
4339                 phy_info->attached.phys_disk_num = ~0;
4340                 mptsas_reprobe_target(starget, 0);
4341                 mptsas_add_device_component_by_fw(ioc,
4342                     hot_plug_info->channel, hot_plug_info->id);
4343                 break;
4344
4345         case MPTSAS_ADD_RAID:
4346
4347                 mpt_findImVolumes(ioc);
4348                 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4349                     "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4350                     hot_plug_info->id);
4351                 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4352                     hot_plug_info->id, 0);
4353                 break;
4354
4355         case MPTSAS_DEL_RAID:
4356
4357                 mpt_findImVolumes(ioc);
4358                 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4359                     "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4360                     hot_plug_info->id);
4361                 scsi_remove_device(hot_plug_info->sdev);
4362                 scsi_device_put(hot_plug_info->sdev);
4363                 break;
4364
4365         case MPTSAS_ADD_INACTIVE_VOLUME:
4366
4367                 mpt_findImVolumes(ioc);
4368                 mptsas_adding_inactive_raid_components(ioc,
4369                     hot_plug_info->channel, hot_plug_info->id);
4370                 break;
4371
4372         default:
4373                 break;
4374         }
4375
4376         mptsas_free_fw_event(ioc, fw_event);
4377 }
4378
4379 static void
4380 mptsas_send_sas_event(struct fw_event_work *fw_event)
4381 {
4382         MPT_ADAPTER *ioc;
4383         struct mptsas_hotplug_event hot_plug_info;
4384         EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
4385         u32 device_info;
4386         u64 sas_address;
4387
4388         ioc = fw_event->ioc;
4389         sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
4390             fw_event->event_data;
4391         device_info = le32_to_cpu(sas_event_data->DeviceInfo);
4392
4393         if ((device_info &
4394                 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
4395                 MPI_SAS_DEVICE_INFO_STP_TARGET |
4396                 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) {
4397                 mptsas_free_fw_event(ioc, fw_event);
4398                 return;
4399         }
4400
4401         if (sas_event_data->ReasonCode ==
4402                 MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
4403                 mptbase_sas_persist_operation(ioc,
4404                 MPI_SAS_OP_CLEAR_NOT_PRESENT);
4405                 mptsas_free_fw_event(ioc, fw_event);
4406                 return;
4407         }
4408
4409         switch (sas_event_data->ReasonCode) {
4410         case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
4411         case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
4412                 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4413                 hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
4414                 hot_plug_info.channel = sas_event_data->Bus;
4415                 hot_plug_info.id = sas_event_data->TargetID;
4416                 hot_plug_info.phy_id = sas_event_data->PhyNum;
4417                 memcpy(&sas_address, &sas_event_data->SASAddress,
4418                     sizeof(u64));
4419                 hot_plug_info.sas_address = le64_to_cpu(sas_address);
4420                 hot_plug_info.device_info = device_info;
4421                 if (sas_event_data->ReasonCode &
4422                     MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
4423                         hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
4424                 else
4425                         hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
4426                 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4427                 break;
4428
4429         case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
4430                 mptbase_sas_persist_operation(ioc,
4431                     MPI_SAS_OP_CLEAR_NOT_PRESENT);
4432                 mptsas_free_fw_event(ioc, fw_event);
4433                 break;
4434
4435         case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
4436         /* TODO */
4437         case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
4438         /* TODO */
4439         default:
4440                 mptsas_free_fw_event(ioc, fw_event);
4441                 break;
4442         }
4443 }
4444
4445 static void
4446 mptsas_send_raid_event(struct fw_event_work *fw_event)
4447 {
4448         MPT_ADAPTER *ioc;
4449         EVENT_DATA_RAID *raid_event_data;
4450         struct mptsas_hotplug_event hot_plug_info;
4451         int status;
4452         int state;
4453         struct scsi_device *sdev = NULL;
4454         VirtDevice *vdevice = NULL;
4455         RaidPhysDiskPage0_t phys_disk;
4456
4457         ioc = fw_event->ioc;
4458         raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
4459         status = le32_to_cpu(raid_event_data->SettingsStatus);
4460         state = (status >> 8) & 0xff;
4461
4462         memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4463         hot_plug_info.id = raid_event_data->VolumeID;
4464         hot_plug_info.channel = raid_event_data->VolumeBus;
4465         hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
4466
4467         if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
4468             raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
4469             raid_event_data->ReasonCode ==
4470             MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
4471                 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4472                     hot_plug_info.id, 0);
4473                 hot_plug_info.sdev = sdev;
4474                 if (sdev)
4475                         vdevice = sdev->hostdata;
4476         }
4477
4478         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4479             "ReasonCode=%02x\n", ioc->name, __func__,
4480             raid_event_data->ReasonCode));
4481
4482         switch (raid_event_data->ReasonCode) {
4483         case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4484                 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
4485                 break;
4486         case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4487                 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
4488                 break;
4489         case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4490                 switch (state) {
4491                 case MPI_PD_STATE_ONLINE:
4492                 case MPI_PD_STATE_NOT_COMPATIBLE:
4493                         mpt_raid_phys_disk_pg0(ioc,
4494                             raid_event_data->PhysDiskNum, &phys_disk);
4495                         hot_plug_info.id = phys_disk.PhysDiskID;
4496                         hot_plug_info.channel = phys_disk.PhysDiskBus;
4497                         hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4498                         break;
4499                 case MPI_PD_STATE_FAILED:
4500                 case MPI_PD_STATE_MISSING:
4501                 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
4502                 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
4503                 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
4504                         hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4505                         break;
4506                 default:
4507                         break;
4508                 }
4509                 break;
4510         case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4511                 if (!sdev)
4512                         break;
4513                 vdevice->vtarget->deleted = 1; /* block IO */
4514                 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4515                 break;
4516         case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4517                 if (sdev) {
4518                         scsi_device_put(sdev);
4519                         break;
4520                 }
4521                 hot_plug_info.event_type = MPTSAS_ADD_RAID;
4522                 break;
4523         case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4524                 if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
4525                         if (!sdev)
4526                                 break;
4527                         vdevice->vtarget->deleted = 1; /* block IO */
4528                         hot_plug_info.event_type = MPTSAS_DEL_RAID;
4529                         break;
4530                 }
4531                 switch (state) {
4532                 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
4533                 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
4534                         if (!sdev)
4535                                 break;
4536                         vdevice->vtarget->deleted = 1; /* block IO */
4537                         hot_plug_info.event_type = MPTSAS_DEL_RAID;
4538                         break;
4539                 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
4540                 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
4541                         if (sdev) {
4542                                 scsi_device_put(sdev);
4543                                 break;
4544                         }
4545                         hot_plug_info.event_type = MPTSAS_ADD_RAID;
4546                         break;
4547                 default:
4548                         break;
4549                 }
4550                 break;
4551         default:
4552                 break;
4553         }
4554
4555         if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
4556                 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4557         else
4558                 mptsas_free_fw_event(ioc, fw_event);
4559 }
4560
4561 /**
4562  *      mptsas_issue_tm - send mptsas internal tm request
4563  *      @ioc: Pointer to MPT_ADAPTER structure
4564  *      @type: Task Management type
4565  *      @channel: channel number for task management
4566  *      @id: Logical Target ID for reset (if appropriate)
4567  *      @lun: Logical unit for reset (if appropriate)
4568  *      @task_context: Context for the task to be aborted
4569  *      @timeout: timeout for task management control
4570  *
4571  *      return 0 on success and -1 on failure:
4572  *
4573  */
4574 static int
4575 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun,
4576         int task_context, ulong timeout, u8 *issue_reset)
4577 {
4578         MPT_FRAME_HDR   *mf;
4579         SCSITaskMgmt_t  *pScsiTm;
4580         int              retval;
4581         unsigned long    timeleft;
4582
4583         *issue_reset = 0;
4584         mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
4585         if (mf == NULL) {
4586                 retval = -1; /* return failure */
4587                 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
4588                     "msg frames!!\n", ioc->name));
4589                 goto out;
4590         }
4591
4592         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
4593             "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
4594             "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
4595              type, timeout, channel, id, (unsigned long long)lun,
4596              task_context));
4597
4598         pScsiTm = (SCSITaskMgmt_t *) mf;
4599         memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
4600         pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4601         pScsiTm->TaskType = type;
4602         pScsiTm->MsgFlags = 0;
4603         pScsiTm->TargetID = id;
4604         pScsiTm->Bus = channel;
4605         pScsiTm->ChainOffset = 0;
4606         pScsiTm->Reserved = 0;
4607         pScsiTm->Reserved1 = 0;
4608         pScsiTm->TaskMsgContext = task_context;
4609         int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
4610
4611         INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4612         CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
4613         retval = 0;
4614         mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
4615
4616         /* Now wait for the command to complete */
4617         timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
4618             timeout*HZ);
4619         if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
4620                 retval = -1; /* return failure */
4621                 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
4622                     "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
4623                 mpt_free_msg_frame(ioc, mf);
4624                 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
4625                         goto out;
4626                 *issue_reset = 1;
4627                 goto out;
4628         }
4629
4630         if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
4631                 retval = -1; /* return failure */
4632                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4633                     "TaskMgmt request: failed with no reply\n", ioc->name));
4634                 goto out;
4635         }
4636
4637  out:
4638         CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4639         return retval;
4640 }
4641
4642 /**
4643  *      mptsas_broadcast_primative_work - Handle broadcast primitives
4644  *      @work: work queue payload containing info describing the event
4645  *
4646  *      this will be handled in workqueue context.
4647  */
4648 static void
4649 mptsas_broadcast_primative_work(struct fw_event_work *fw_event)
4650 {
4651         MPT_ADAPTER *ioc = fw_event->ioc;
4652         MPT_FRAME_HDR   *mf;
4653         VirtDevice      *vdevice;
4654         int                     ii;
4655         struct scsi_cmnd        *sc;
4656         SCSITaskMgmtReply_t     *pScsiTmReply;
4657         u8                      issue_reset;
4658         int                     task_context;
4659         u8                      channel, id;
4660         int                      lun;
4661         u32                      termination_count;
4662         u32                      query_count;
4663
4664         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4665             "%s - enter\n", ioc->name, __func__));
4666
4667         mutex_lock(&ioc->taskmgmt_cmds.mutex);
4668         if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4669                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4670                 mptsas_requeue_fw_event(ioc, fw_event, 1000);
4671                 return;
4672         }
4673
4674         issue_reset = 0;
4675         termination_count = 0;
4676         query_count = 0;
4677         mpt_findImVolumes(ioc);
4678         pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
4679
4680         for (ii = 0; ii < ioc->req_depth; ii++) {
4681                 if (ioc->fw_events_off)
4682                         goto out;
4683                 sc = mptscsih_get_scsi_lookup(ioc, ii);
4684                 if (!sc)
4685                         continue;
4686                 mf = MPT_INDEX_2_MFPTR(ioc, ii);
4687                 if (!mf)
4688                         continue;
4689                 task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
4690                 vdevice = sc->device->hostdata;
4691                 if (!vdevice || !vdevice->vtarget)
4692                         continue;
4693                 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
4694                         continue; /* skip hidden raid components */
4695                 if (vdevice->vtarget->raidVolume)
4696                         continue; /* skip hidden raid components */
4697                 channel = vdevice->vtarget->channel;
4698                 id = vdevice->vtarget->id;
4699                 lun = vdevice->lun;
4700                 if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
4701                     channel, id, (u64)lun, task_context, 30, &issue_reset))
4702                         goto out;
4703                 query_count++;
4704                 termination_count +=
4705                     le32_to_cpu(pScsiTmReply->TerminationCount);
4706                 if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
4707                     (pScsiTmReply->ResponseCode ==
4708                     MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4709                     pScsiTmReply->ResponseCode ==
4710                     MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4711                         continue;
4712                 if (mptsas_issue_tm(ioc,
4713                     MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
4714                     channel, id, (u64)lun, 0, 30, &issue_reset))
4715                         goto out;
4716                 termination_count +=
4717                     le32_to_cpu(pScsiTmReply->TerminationCount);
4718         }
4719
4720  out:
4721         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4722             "%s - exit, query_count = %d termination_count = %d\n",
4723             ioc->name, __func__, query_count, termination_count));
4724
4725         ioc->broadcast_aen_busy = 0;
4726         mpt_clear_taskmgmt_in_progress_flag(ioc);
4727         mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4728
4729         if (issue_reset) {
4730                 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
4731                     ioc->name, __func__);
4732                 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
4733         }
4734         mptsas_free_fw_event(ioc, fw_event);
4735 }
4736
4737 /*
4738  * mptsas_send_ir2_event - handle exposing hidden disk when
4739  * an inactive raid volume is added
4740  *
4741  * @ioc: Pointer to MPT_ADAPTER structure
4742  * @ir2_data
4743  *
4744  */
4745 static void
4746 mptsas_send_ir2_event(struct fw_event_work *fw_event)
4747 {
4748         MPT_ADAPTER     *ioc;
4749         struct mptsas_hotplug_event hot_plug_info;
4750         MPI_EVENT_DATA_IR2      *ir2_data;
4751         u8 reasonCode;
4752         RaidPhysDiskPage0_t phys_disk;
4753
4754         ioc = fw_event->ioc;
4755         ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
4756         reasonCode = ir2_data->ReasonCode;
4757
4758         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4759             "ReasonCode=%02x\n", ioc->name, __func__, reasonCode));
4760
4761         memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4762         hot_plug_info.id = ir2_data->TargetID;
4763         hot_plug_info.channel = ir2_data->Bus;
4764         switch (reasonCode) {
4765         case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
4766                 hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
4767                 break;
4768         case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
4769                 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4770                 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4771                 break;
4772         case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
4773                 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4774                 mpt_raid_phys_disk_pg0(ioc,
4775                     ir2_data->PhysDiskNum, &phys_disk);
4776                 hot_plug_info.id = phys_disk.PhysDiskID;
4777                 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4778                 break;
4779         default:
4780                 mptsas_free_fw_event(ioc, fw_event);
4781                 return;
4782         }
4783         mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4784 }
4785
4786 static int
4787 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
4788 {
4789         u32 event = le32_to_cpu(reply->Event);
4790         int sz, event_data_sz;
4791         struct fw_event_work *fw_event;
4792         unsigned long delay;
4793
4794         if (ioc->bus_type != SAS)
4795                 return 0;
4796
4797         /* events turned off due to host reset or driver unloading */
4798         if (ioc->fw_events_off)
4799                 return 0;
4800
4801         delay = msecs_to_jiffies(1);
4802         switch (event) {
4803         case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
4804         {
4805                 EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
4806                     (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
4807                 if (broadcast_event_data->Primitive !=
4808                     MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
4809                         return 0;
4810                 if (ioc->broadcast_aen_busy)
4811                         return 0;
4812                 ioc->broadcast_aen_busy = 1;
4813                 break;
4814         }
4815         case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
4816         {
4817                 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
4818                     (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
4819
4820                 if (sas_event_data->ReasonCode ==
4821                     MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
4822                         mptsas_target_reset_queue(ioc, sas_event_data);
4823                         return 0;
4824                 }
4825                 break;
4826         }
4827         case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
4828         {
4829                 MpiEventDataSasExpanderStatusChange_t *expander_data =
4830                     (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
4831
4832                 if (ioc->old_sas_discovery_protocal)
4833                         return 0;
4834
4835                 if (expander_data->ReasonCode ==
4836                     MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
4837                     ioc->device_missing_delay)
4838                         delay = HZ * ioc->device_missing_delay;
4839                 break;
4840         }
4841         case MPI_EVENT_SAS_DISCOVERY:
4842         {
4843                 u32 discovery_status;
4844                 EventDataSasDiscovery_t *discovery_data =
4845                     (EventDataSasDiscovery_t *)reply->Data;
4846
4847                 discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
4848                 ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
4849                 if (ioc->old_sas_discovery_protocal && !discovery_status)
4850                         mptsas_queue_rescan(ioc);
4851                 return 0;
4852         }
4853         case MPI_EVENT_INTEGRATED_RAID:
4854         case MPI_EVENT_PERSISTENT_TABLE_FULL:
4855         case MPI_EVENT_IR2:
4856         case MPI_EVENT_SAS_PHY_LINK_STATUS:
4857         case MPI_EVENT_QUEUE_FULL:
4858                 break;
4859         default:
4860                 return 0;
4861         }
4862
4863         event_data_sz = ((reply->MsgLength * 4) -
4864             offsetof(EventNotificationReply_t, Data));
4865         sz = offsetof(struct fw_event_work, event_data) + event_data_sz;
4866         fw_event = kzalloc(sz, GFP_ATOMIC);
4867         if (!fw_event) {
4868                 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
4869                  __func__, __LINE__);
4870                 return 0;
4871         }
4872         memcpy(fw_event->event_data, reply->Data, event_data_sz);
4873         fw_event->event = event;
4874         fw_event->ioc = ioc;
4875         mptsas_add_fw_event(ioc, fw_event, delay);
4876         return 0;
4877 }
4878
4879 /* Delete a volume when no longer listed in ioc pg2
4880  */
4881 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
4882 {
4883         struct scsi_device *sdev;
4884         int i;
4885
4886         sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
4887         if (!sdev)
4888                 return;
4889         if (!ioc->raid_data.pIocPg2)
4890                 goto out;
4891         if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
4892                 goto out;
4893         for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
4894                 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
4895                         goto release_sdev;
4896  out:
4897         printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4898             "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id);
4899         scsi_remove_device(sdev);
4900  release_sdev:
4901         scsi_device_put(sdev);
4902 }
4903
4904 static int
4905 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
4906 {
4907         struct Scsi_Host        *sh;
4908         MPT_SCSI_HOST           *hd;
4909         MPT_ADAPTER             *ioc;
4910         unsigned long            flags;
4911         int                      ii;
4912         int                      numSGE = 0;
4913         int                      scale;
4914         int                      ioc_cap;
4915         int                     error=0;
4916         int                     r;
4917
4918         r = mpt_attach(pdev,id);
4919         if (r)
4920                 return r;
4921
4922         ioc = pci_get_drvdata(pdev);
4923         mptsas_fw_event_off(ioc);
4924         ioc->DoneCtx = mptsasDoneCtx;
4925         ioc->TaskCtx = mptsasTaskCtx;
4926         ioc->InternalCtx = mptsasInternalCtx;
4927
4928         /*  Added sanity check on readiness of the MPT adapter.
4929          */
4930         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
4931                 printk(MYIOC_s_WARN_FMT
4932                   "Skipping because it's not operational!\n",
4933                   ioc->name);
4934                 error = -ENODEV;
4935                 goto out_mptsas_probe;
4936         }
4937
4938         if (!ioc->active) {
4939                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
4940                   ioc->name);
4941                 error = -ENODEV;
4942                 goto out_mptsas_probe;
4943         }
4944
4945         /*  Sanity check - ensure at least 1 port is INITIATOR capable
4946          */
4947         ioc_cap = 0;
4948         for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
4949                 if (ioc->pfacts[ii].ProtocolFlags &
4950                                 MPI_PORTFACTS_PROTOCOL_INITIATOR)
4951                         ioc_cap++;
4952         }
4953
4954         if (!ioc_cap) {
4955                 printk(MYIOC_s_WARN_FMT
4956                         "Skipping ioc=%p because SCSI Initiator mode "
4957                         "is NOT enabled!\n", ioc->name, ioc);
4958                 return 0;
4959         }
4960
4961         sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
4962         if (!sh) {
4963                 printk(MYIOC_s_WARN_FMT
4964                         "Unable to register controller with SCSI subsystem\n",
4965                         ioc->name);
4966                 error = -1;
4967                 goto out_mptsas_probe;
4968         }
4969
4970         spin_lock_irqsave(&ioc->FreeQlock, flags);
4971
4972         /* Attach the SCSI Host to the IOC structure
4973          */
4974         ioc->sh = sh;
4975
4976         sh->io_port = 0;
4977         sh->n_io_port = 0;
4978         sh->irq = 0;
4979
4980         /* set 16 byte cdb's */
4981         sh->max_cmd_len = 16;
4982         sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
4983         sh->max_id = -1;
4984         sh->max_lun = max_lun;
4985         sh->transportt = mptsas_transport_template;
4986
4987         /* Required entry.
4988          */
4989         sh->unique_id = ioc->id;
4990
4991         INIT_LIST_HEAD(&ioc->sas_topology);
4992         mutex_init(&ioc->sas_topology_mutex);
4993         mutex_init(&ioc->sas_discovery_mutex);
4994         mutex_init(&ioc->sas_mgmt.mutex);
4995         init_completion(&ioc->sas_mgmt.done);
4996
4997         /* Verify that we won't exceed the maximum
4998          * number of chain buffers
4999          * We can optimize:  ZZ = req_sz/sizeof(SGE)
5000          * For 32bit SGE's:
5001          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
5002          *               + (req_sz - 64)/sizeof(SGE)
5003          * A slightly different algorithm is required for
5004          * 64bit SGEs.
5005          */
5006         scale = ioc->req_sz/ioc->SGE_size;
5007         if (ioc->sg_addr_size == sizeof(u64)) {
5008                 numSGE = (scale - 1) *
5009                   (ioc->facts.MaxChainDepth-1) + scale +
5010                   (ioc->req_sz - 60) / ioc->SGE_size;
5011         } else {
5012                 numSGE = 1 + (scale - 1) *
5013                   (ioc->facts.MaxChainDepth-1) + scale +
5014                   (ioc->req_sz - 64) / ioc->SGE_size;
5015         }
5016
5017         if (numSGE < sh->sg_tablesize) {
5018                 /* Reset this value */
5019                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5020                   "Resetting sg_tablesize to %d from %d\n",
5021                   ioc->name, numSGE, sh->sg_tablesize));
5022                 sh->sg_tablesize = numSGE;
5023         }
5024
5025         hd = shost_priv(sh);
5026         hd->ioc = ioc;
5027
5028         /* SCSI needs scsi_cmnd lookup table!
5029          * (with size equal to req_depth*PtrSz!)
5030          */
5031         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
5032         if (!ioc->ScsiLookup) {
5033                 error = -ENOMEM;
5034                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5035                 goto out_mptsas_probe;
5036         }
5037         spin_lock_init(&ioc->scsi_lookup_lock);
5038
5039         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
5040                  ioc->name, ioc->ScsiLookup));
5041
5042         ioc->sas_data.ptClear = mpt_pt_clear;
5043
5044         hd->last_queue_full = 0;
5045         INIT_LIST_HEAD(&hd->target_reset_list);
5046         INIT_LIST_HEAD(&ioc->sas_device_info_list);
5047         mutex_init(&ioc->sas_device_info_mutex);
5048
5049         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5050
5051         if (ioc->sas_data.ptClear==1) {
5052                 mptbase_sas_persist_operation(
5053                     ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
5054         }
5055
5056         error = scsi_add_host(sh, &ioc->pcidev->dev);
5057         if (error) {
5058                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
5059                   "scsi_add_host failed\n", ioc->name));
5060                 goto out_mptsas_probe;
5061         }
5062
5063         /* older firmware doesn't support expander events */
5064         if ((ioc->facts.HeaderVersion >> 8) < 0xE)
5065                 ioc->old_sas_discovery_protocal = 1;
5066         mptsas_scan_sas_topology(ioc);
5067         mptsas_fw_event_on(ioc);
5068         return 0;
5069
5070  out_mptsas_probe:
5071
5072         mptscsih_remove(pdev);
5073         return error;
5074 }
5075
5076 void
5077 mptsas_shutdown(struct pci_dev *pdev)
5078 {
5079         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5080
5081         mptsas_fw_event_off(ioc);
5082         mptsas_cleanup_fw_event_q(ioc);
5083 }
5084
5085 static void __devexit mptsas_remove(struct pci_dev *pdev)
5086 {
5087         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5088         struct mptsas_portinfo *p, *n;
5089         int i;
5090
5091         if (!ioc->sh) {
5092                 printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name);
5093                 mpt_detach(pdev);
5094                 return;
5095         }
5096
5097         mptsas_shutdown(pdev);
5098
5099         mptsas_del_device_components(ioc);
5100
5101         ioc->sas_discovery_ignore_events = 1;
5102         sas_remove_host(ioc->sh);
5103
5104         mutex_lock(&ioc->sas_topology_mutex);
5105         list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
5106                 list_del(&p->list);
5107                 for (i = 0 ; i < p->num_phys ; i++)
5108                         mptsas_port_delete(ioc, p->phy_info[i].port_details);
5109
5110                 kfree(p->phy_info);
5111                 kfree(p);
5112         }
5113         mutex_unlock(&ioc->sas_topology_mutex);
5114         ioc->hba_port_info = NULL;
5115         mptscsih_remove(pdev);
5116 }
5117
5118 static struct pci_device_id mptsas_pci_table[] = {
5119         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
5120                 PCI_ANY_ID, PCI_ANY_ID },
5121         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
5122                 PCI_ANY_ID, PCI_ANY_ID },
5123         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
5124                 PCI_ANY_ID, PCI_ANY_ID },
5125         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
5126                 PCI_ANY_ID, PCI_ANY_ID },
5127         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
5128                 PCI_ANY_ID, PCI_ANY_ID },
5129         {0}     /* Terminating entry */
5130 };
5131 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
5132
5133
5134 static struct pci_driver mptsas_driver = {
5135         .name           = "mptsas",
5136         .id_table       = mptsas_pci_table,
5137         .probe          = mptsas_probe,
5138         .remove         = __devexit_p(mptsas_remove),
5139         .shutdown       = mptsas_shutdown,
5140 #ifdef CONFIG_PM
5141         .suspend        = mptscsih_suspend,
5142         .resume         = mptscsih_resume,
5143 #endif
5144 };
5145
5146 static int __init
5147 mptsas_init(void)
5148 {
5149         int error;
5150
5151         show_mptmod_ver(my_NAME, my_VERSION);
5152
5153         mptsas_transport_template =
5154             sas_attach_transport(&mptsas_transport_functions);
5155         if (!mptsas_transport_template)
5156                 return -ENODEV;
5157
5158         mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
5159         mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER);
5160         mptsasInternalCtx =
5161                 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
5162         mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
5163         mptsasDeviceResetCtx =
5164                 mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
5165
5166         mpt_event_register(mptsasDoneCtx, mptsas_event_process);
5167         mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
5168
5169         error = pci_register_driver(&mptsas_driver);
5170         if (error)
5171                 sas_release_transport(mptsas_transport_template);
5172
5173         return error;
5174 }
5175
5176 static void __exit
5177 mptsas_exit(void)
5178 {
5179         pci_unregister_driver(&mptsas_driver);
5180         sas_release_transport(mptsas_transport_template);
5181
5182         mpt_reset_deregister(mptsasDoneCtx);
5183         mpt_event_deregister(mptsasDoneCtx);
5184
5185         mpt_deregister(mptsasMgmtCtx);
5186         mpt_deregister(mptsasInternalCtx);
5187         mpt_deregister(mptsasTaskCtx);
5188         mpt_deregister(mptsasDoneCtx);
5189         mpt_deregister(mptsasDeviceResetCtx);
5190 }
5191
5192 module_init(mptsas_init);
5193 module_exit(mptsas_exit);