drivers/message/fusion/mptsas.c

   1 /*
   2  *  linux/drivers/message/fusion/mptsas.c
   3  *      For use with LSI Logic PCI chip/adapter(s)
   4  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2007 LSI Logic Corporation
   7  *  (mailto:DL-MPTFusionLinux@lsi.com)
   8  *  Copyright (c) 2005-2007 Dell
   9  */
  10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  11 /*
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; version 2 of the License.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19     GNU General Public License for more details.
  20
  21     NO WARRANTY
  22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  26     solely responsible for determining the appropriateness of using and
  27     distributing the Program and assumes all risks associated with its
  28     exercise of rights under this Agreement, including but not limited to
  29     the risks and costs of program errors, damage to or loss of data,
  30     programs or equipment, and unavailability or interruption of operations.
  31
  32     DISCLAIMER OF LIABILITY
  33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  40
  41     You should have received a copy of the GNU General Public License
  42     along with this program; if not, write to the Free Software
  43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  44 */
  45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  46
  47 #include <linux/module.h>
  48 #include <linux/kernel.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
  65
  66 #define my_NAME         "Fusion MPT SAS Host driver"
  67 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  68 #define MYNAM           "mptsas"
  69
  70 /*
  71  * Reserved channel for integrated raid
  72  */
  73 #define MPTSAS_RAID_CHANNEL     1
  74
  75 MODULE_AUTHOR(MODULEAUTHOR);
  76 MODULE_DESCRIPTION(my_NAME);
  77 MODULE_LICENSE("GPL");
  78 MODULE_VERSION(my_VERSION);
  79
  80 static int mpt_pt_clear;
  81 module_param(mpt_pt_clear, int, 0);
  82 MODULE_PARM_DESC(mpt_pt_clear,
  83                 " Clear persistency table: enable=1  "
  84                 "(default=MPTSCSIH_PT_CLEAR=0)");
  85
  86 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
  87 #define MPTSAS_MAX_LUN (16895)
  88 static int max_lun = MPTSAS_MAX_LUN;
  89 module_param(max_lun, int, 0);
  90 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
  91
  92 static int      mptsasDoneCtx = -1;
  93 static int      mptsasTaskCtx = -1;
  94 static int      mptsasInternalCtx = -1; /* Used only for internal commands */
  95 static int      mptsasMgmtCtx = -1;
  96
  97 static void mptsas_hotplug_work(struct work_struct *work);
  98
  99 struct mptsas_target_reset_event {
 100         struct list_head        list;
 101         EVENT_DATA_SAS_DEVICE_STATUS_CHANGE sas_event_data;
 102         u8      target_reset_issued;
 103 };
 104
 105 enum mptsas_hotplug_action {
 106         MPTSAS_ADD_DEVICE,
 107         MPTSAS_DEL_DEVICE,
 108         MPTSAS_ADD_RAID,
 109         MPTSAS_DEL_RAID,
 110         MPTSAS_ADD_INACTIVE_VOLUME,
 111         MPTSAS_IGNORE_EVENT,
 112 };
 113
 114 struct mptsas_hotplug_event {
 115         struct work_struct      work;
 116         MPT_ADAPTER             *ioc;
 117         enum mptsas_hotplug_action event_type;
 118         u64                     sas_address;
 119         u8                      channel;
 120         u8                      id;
 121         u32                     device_info;
 122         u16                     handle;
 123         u16                     parent_handle;
 124         u8                      phy_id;
 125         u8                      phys_disk_num_valid;    /* hrc (hidden raid component) */
 126         u8                      phys_disk_num;          /* hrc - unique index*/
 127         u8                      hidden_raid_component;  /* hrc - don't expose*/
 128 };
 129
 130 struct mptsas_discovery_event {
 131         struct work_struct      work;
 132         MPT_ADAPTER             *ioc;
 133 };
 134
 135 /*
 136  * SAS topology structures
 137  *
 138  * The MPT Fusion firmware interface spreads information about the
 139  * SAS topology over many manufacture pages, thus we need some data
 140  * structure to collect it and process it for the SAS transport class.
 141  */
 142
 143 struct mptsas_devinfo {
 144         u16     handle;         /* unique id to address this device */
 145         u16     handle_parent;  /* unique id to address parent device */
 146         u16     handle_enclosure; /* enclosure identifier of the enclosure */
 147         u16     slot;           /* physical slot in enclosure */
 148         u8      phy_id;         /* phy number of parent device */
 149         u8      port_id;        /* sas physical port this device
 150                                    is assoc'd with */
 151         u8      id;             /* logical target id of this device */
 152         u32     phys_disk_num;  /* phys disk id, for csmi-ioctls */
 153         u8      channel;        /* logical bus number of this device */
 154         u64     sas_address;    /* WWN of this device,
 155                                    SATA is assigned by HBA,expander */
 156         u32     device_info;    /* bitfield detailed info about this device */
 157 };
 158
 159 /*
 160  * Specific details on ports, wide/narrow
 161  */
 162 struct mptsas_portinfo_details{
 163         u16     num_phys;       /* number of phys belong to this port */
 164         u64     phy_bitmask;    /* TODO, extend support for 255 phys */
 165         struct sas_rphy *rphy;  /* transport layer rphy object */
 166         struct sas_port *port;  /* transport layer port object */
 167         struct scsi_target *starget;
 168         struct mptsas_portinfo *port_info;
 169 };
 170
 171 struct mptsas_phyinfo {
 172         u16     handle;                 /* unique id to address this */
 173         u8      phy_id;                 /* phy index */
 174         u8      port_id;                /* firmware port identifier */
 175         u8      negotiated_link_rate;   /* nego'd link rate for this phy */
 176         u8      hw_link_rate;           /* hardware max/min phys link rate */
 177         u8      programmed_link_rate;   /* programmed max/min phy link rate */
 178         u8      sas_port_add_phy;       /* flag to request sas_port_add_phy*/
 179         struct mptsas_devinfo identify; /* point to phy device info */
 180         struct mptsas_devinfo attached; /* point to attached device info */
 181         struct sas_phy *phy;            /* transport layer phy object */
 182         struct mptsas_portinfo *portinfo;
 183         struct mptsas_portinfo_details * port_details;
 184 };
 185
 186 struct mptsas_portinfo {
 187         struct list_head list;
 188         u16             num_phys;       /* number of phys */
 189         struct mptsas_phyinfo *phy_info;
 190 };
 191
 192 struct mptsas_enclosure {
 193         u64     enclosure_logical_id;   /* The WWN for the enclosure */
 194         u16     enclosure_handle;       /* unique id to address this */
 195         u16     flags;                  /* details enclosure management */
 196         u16     num_slot;               /* num slots */
 197         u16     start_slot;             /* first slot */
 198         u8      start_id;               /* starting logical target id */
 199         u8      start_channel;          /* starting logical channel id */
 200         u8      sep_id;                 /* SEP device logical target id */
 201         u8      sep_channel;            /* SEP channel logical channel id */
 202 };
 203
 204 static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
 205                                         MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
 206 {
 207         dsasprintk(ioc, printk(KERN_DEBUG "---- IO UNIT PAGE 0 ------------\n"));
 208         dsasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n",
 209                 le16_to_cpu(phy_data->AttachedDeviceHandle)));
 210         dsasprintk(ioc, printk(KERN_DEBUG "Controller Handle=0x%X\n",
 211                 le16_to_cpu(phy_data->ControllerDevHandle)));
 212         dsasprintk(ioc, printk(KERN_DEBUG "Port=0x%X\n", phy_data->Port));
 213         dsasprintk(ioc, printk(KERN_DEBUG "Port Flags=0x%X\n", phy_data->PortFlags));
 214         dsasprintk(ioc, printk(KERN_DEBUG "PHY Flags=0x%X\n", phy_data->PhyFlags));
 215         dsasprintk(ioc, printk(KERN_DEBUG "Negotiated Link Rate=0x%X\n", phy_data->NegotiatedLinkRate));
 216         dsasprintk(ioc, printk(KERN_DEBUG "Controller PHY Device Info=0x%X\n",
 217                 le32_to_cpu(phy_data->ControllerPhyDeviceInfo)));
 218         dsasprintk(ioc, printk(KERN_DEBUG "DiscoveryStatus=0x%X\n\n",
 219                 le32_to_cpu(phy_data->DiscoveryStatus)));
 220 }
 221
 222 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0)
 223 {
 224         __le64 sas_address;
 225
 226         memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
 227
 228         dsasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 0 ------------\n"));
 229         dsasprintk(ioc, printk(KERN_DEBUG "Attached Device Handle=0x%X\n",
 230                         le16_to_cpu(pg0->AttachedDevHandle)));
 231         dsasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n",
 232                         (unsigned long long)le64_to_cpu(sas_address)));
 233         dsasprintk(ioc, printk(KERN_DEBUG "Attached PHY Identifier=0x%X\n", pg0->AttachedPhyIdentifier));
 234         dsasprintk(ioc, printk(KERN_DEBUG "Attached Device Info=0x%X\n",
 235                         le32_to_cpu(pg0->AttachedDeviceInfo)));
 236         dsasprintk(ioc, printk(KERN_DEBUG "Programmed Link Rate=0x%X\n", pg0->ProgrammedLinkRate));
 237         dsasprintk(ioc, printk(KERN_DEBUG "Change Count=0x%X\n", pg0->ChangeCount));
 238         dsasprintk(ioc, printk(KERN_DEBUG "PHY Info=0x%X\n\n", le32_to_cpu(pg0->PhyInfo)));
 239 }
 240
 241 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1)
 242 {
 243         dsasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 1 ------------\n"));
 244         dsasprintk(ioc, printk(KERN_DEBUG "Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount));
 245         dsasprintk(ioc, printk(KERN_DEBUG "Running Disparity Error Count=0x%x\n",
 246                         pg1->RunningDisparityErrorCount));
 247         dsasprintk(ioc, printk(KERN_DEBUG "Loss Dword Synch Count=0x%x\n", pg1->LossDwordSynchCount));
 248         dsasprintk(ioc, printk(KERN_DEBUG "PHY Reset Problem Count=0x%x\n\n", pg1->PhyResetProblemCount));
 249 }
 250
 251 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0)
 252 {
 253         __le64 sas_address;
 254
 255         memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
 256
 257         dsasprintk(ioc, printk(KERN_DEBUG "---- SAS DEVICE PAGE 0 ---------\n"));
 258         dsasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n" ,le16_to_cpu(pg0->DevHandle)));
 259         dsasprintk(ioc, printk(KERN_DEBUG "Parent Handle=0x%X\n" ,le16_to_cpu(pg0->ParentDevHandle)));
 260         dsasprintk(ioc, printk(KERN_DEBUG "Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle)));
 261         dsasprintk(ioc, printk(KERN_DEBUG "Slot=0x%X\n", le16_to_cpu(pg0->Slot)));
 262         dsasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n", (unsigned long long)
 263             le64_to_cpu(sas_address)));
 264         dsasprintk(ioc, printk(KERN_DEBUG "Target ID=0x%X\n", pg0->TargetID));
 265         dsasprintk(ioc, printk(KERN_DEBUG "Bus=0x%X\n", pg0->Bus));
 266         /* The PhyNum field specifies the PHY number of the parent
 267          * device this device is linked to
 268          */
 269         dsasprintk(ioc, printk(KERN_DEBUG "Parent Phy Num=0x%X\n", pg0->PhyNum));
 270         dsasprintk(ioc, printk(KERN_DEBUG "Access Status=0x%X\n", le16_to_cpu(pg0->AccessStatus)));
 271         dsasprintk(ioc, printk(KERN_DEBUG "Device Info=0x%X\n", le32_to_cpu(pg0->DeviceInfo)));
 272         dsasprintk(ioc, printk(KERN_DEBUG "Flags=0x%X\n", le16_to_cpu(pg0->Flags)));
 273         dsasprintk(ioc, printk(KERN_DEBUG "Physical Port=0x%X\n\n", pg0->PhysicalPort));
 274 }
 275
 276 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1)
 277 {
 278         dsasprintk(ioc, printk(KERN_DEBUG "---- SAS EXPANDER PAGE 1 ------------\n"));
 279         dsasprintk(ioc, printk(KERN_DEBUG "Physical Port=0x%X\n", pg1->PhysicalPort));
 280         dsasprintk(ioc, printk(KERN_DEBUG "PHY Identifier=0x%X\n", pg1->PhyIdentifier));
 281         dsasprintk(ioc, printk(KERN_DEBUG "Negotiated Link Rate=0x%X\n", pg1->NegotiatedLinkRate));
 282         dsasprintk(ioc, printk(KERN_DEBUG "Programmed Link Rate=0x%X\n", pg1->ProgrammedLinkRate));
 283         dsasprintk(ioc, printk(KERN_DEBUG "Hardware Link Rate=0x%X\n", pg1->HwLinkRate));
 284         dsasprintk(ioc, printk(KERN_DEBUG "Owner Device Handle=0x%X\n",
 285                         le16_to_cpu(pg1->OwnerDevHandle)));
 286         dsasprintk(ioc, printk(KERN_DEBUG "Attached Device Handle=0x%X\n\n",
 287                         le16_to_cpu(pg1->AttachedDevHandle)));
 288 }
 289
 290 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
 291 {
 292         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 293         return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
 294 }
 295
 296 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
 297 {
 298         struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
 299         return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
 300 }
 301
 302 /*
 303  * mptsas_find_portinfo_by_handle
 304  *
 305  * This function should be called with the sas_topology_mutex already held
 306  */
 307 static struct mptsas_portinfo *
 308 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
 309 {
 310         struct mptsas_portinfo *port_info, *rc=NULL;
 311         int i;
 312
 313         list_for_each_entry(port_info, &ioc->sas_topology, list)
 314                 for (i = 0; i < port_info->num_phys; i++)
 315                         if (port_info->phy_info[i].identify.handle == handle) {
 316                                 rc = port_info;
 317                                 goto out;
 318                         }
 319  out:
 320         return rc;
 321 }
 322
 323 /*
 324  * Returns true if there is a scsi end device
 325  */
 326 static inline int
 327 mptsas_is_end_device(struct mptsas_devinfo * attached)
 328 {
 329         if ((attached->sas_address) &&
 330             (attached->device_info &
 331             MPI_SAS_DEVICE_INFO_END_DEVICE) &&
 332             ((attached->device_info &
 333             MPI_SAS_DEVICE_INFO_SSP_TARGET) |
 334             (attached->device_info &
 335             MPI_SAS_DEVICE_INFO_STP_TARGET) |
 336             (attached->device_info &
 337             MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
 338                 return 1;
 339         else
 340                 return 0;
 341 }
 342
 343 /* no mutex */
 344 static void
 345 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
 346 {
 347         struct mptsas_portinfo *port_info;
 348         struct mptsas_phyinfo *phy_info;
 349         u8      i;
 350
 351         if (!port_details)
 352                 return;
 353
 354         port_info = port_details->port_info;
 355         phy_info = port_info->phy_info;
 356
 357         dsaswideprintk(ioc, printk(KERN_DEBUG "%s: [%p]: num_phys=%02d "
 358             "bitmask=0x%016llX\n", __FUNCTION__, port_details,
 359             port_details->num_phys, (unsigned long long)
 360             port_details->phy_bitmask));
 361
 362         for (i = 0; i < port_info->num_phys; i++, phy_info++) {
 363                 if(phy_info->port_details != port_details)
 364                         continue;
 365                 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
 366                 phy_info->port_details = NULL;
 367         }
 368         kfree(port_details);
 369 }
 370
 371 static inline struct sas_rphy *
 372 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
 373 {
 374         if (phy_info->port_details)
 375                 return phy_info->port_details->rphy;
 376         else
 377                 return NULL;
 378 }
 379
 380 static inline void
 381 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
 382 {
 383         if (phy_info->port_details) {
 384                 phy_info->port_details->rphy = rphy;
 385                 dsaswideprintk(ioc, printk(KERN_DEBUG "sas_rphy_add: rphy=%p\n", rphy));
 386         }
 387
 388         if (rphy) {
 389                 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
 390                     &rphy->dev, "add:"));
 391                 dsaswideprintk(ioc, printk(KERN_DEBUG "rphy=%p release=%p\n",
 392                         rphy, rphy->dev.release));
 393         }
 394 }
 395
 396 static inline struct sas_port *
 397 mptsas_get_port(struct mptsas_phyinfo *phy_info)
 398 {
 399         if (phy_info->port_details)
 400                 return phy_info->port_details->port;
 401         else
 402                 return NULL;
 403 }
 404
 405 static inline void
 406 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
 407 {
 408         if (phy_info->port_details)
 409                 phy_info->port_details->port = port;
 410
 411         if (port) {
 412                 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
 413                     &port->dev, "add:"));
 414                 dsaswideprintk(ioc, printk(KERN_DEBUG "port=%p release=%p\n",
 415                         port, port->dev.release));
 416         }
 417 }
 418
 419 static inline struct scsi_target *
 420 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
 421 {
 422         if (phy_info->port_details)
 423                 return phy_info->port_details->starget;
 424         else
 425                 return NULL;
 426 }
 427
 428 static inline void
 429 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
 430 starget)
 431 {
 432         if (phy_info->port_details)
 433                 phy_info->port_details->starget = starget;
 434 }
 435
 436
 437 /*
 438  * mptsas_setup_wide_ports
 439  *
 440  * Updates for new and existing narrow/wide port configuration
 441  * in the sas_topology
 442  */
 443 static void
 444 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
 445 {
 446         struct mptsas_portinfo_details * port_details;
 447         struct mptsas_phyinfo *phy_info, *phy_info_cmp;
 448         u64     sas_address;
 449         int     i, j;
 450
 451         mutex_lock(&ioc->sas_topology_mutex);
 452
 453         phy_info = port_info->phy_info;
 454         for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
 455                 if (phy_info->attached.handle)
 456                         continue;
 457                 port_details = phy_info->port_details;
 458                 if (!port_details)
 459                         continue;
 460                 if (port_details->num_phys < 2)
 461                         continue;
 462                 /*
 463                  * Removing a phy from a port, letting the last
 464                  * phy be removed by firmware events.
 465                  */
 466                 dsaswideprintk(ioc, printk(KERN_DEBUG
 467                         "%s: [%p]: deleting phy = %d\n",
 468                         __FUNCTION__, port_details, i));
 469                 port_details->num_phys--;
 470                 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
 471                 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
 472                 sas_port_delete_phy(port_details->port, phy_info->phy);
 473                 phy_info->port_details = NULL;
 474         }
 475
 476         /*
 477          * Populate and refresh the tree
 478          */
 479         phy_info = port_info->phy_info;
 480         for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
 481                 sas_address = phy_info->attached.sas_address;
 482                 dsaswideprintk(ioc, printk(KERN_DEBUG "phy_id=%d sas_address=0x%018llX\n",
 483                     i, (unsigned long long)sas_address));
 484                 if (!sas_address)
 485                         continue;
 486                 port_details = phy_info->port_details;
 487                 /*
 488                  * Forming a port
 489                  */
 490                 if (!port_details) {
 491                         port_details = kzalloc(sizeof(*port_details),
 492                                 GFP_KERNEL);
 493                         if (!port_details)
 494                                 goto out;
 495                         port_details->num_phys = 1;
 496                         port_details->port_info = port_info;
 497                         if (phy_info->phy_id < 64 )
 498                                 port_details->phy_bitmask |=
 499                                     (1 << phy_info->phy_id);
 500                         phy_info->sas_port_add_phy=1;
 501                         dsaswideprintk(ioc, printk(KERN_DEBUG "\t\tForming port\n\t\t"
 502                             "phy_id=%d sas_address=0x%018llX\n",
 503                             i, (unsigned long long)sas_address));
 504                         phy_info->port_details = port_details;
 505                 }
 506
 507                 if (i == port_info->num_phys - 1)
 508                         continue;
 509                 phy_info_cmp = &port_info->phy_info[i + 1];
 510                 for (j = i + 1 ; j < port_info->num_phys ; j++,
 511                     phy_info_cmp++) {
 512                         if (!phy_info_cmp->attached.sas_address)
 513                                 continue;
 514                         if (sas_address != phy_info_cmp->attached.sas_address)
 515                                 continue;
 516                         if (phy_info_cmp->port_details == port_details )
 517                                 continue;
 518                         dsaswideprintk(ioc, printk(KERN_DEBUG
 519                             "\t\tphy_id=%d sas_address=0x%018llX\n",
 520                             j, (unsigned long long)
 521                             phy_info_cmp->attached.sas_address));
 522                         if (phy_info_cmp->port_details) {
 523                                 port_details->rphy =
 524                                     mptsas_get_rphy(phy_info_cmp);
 525                                 port_details->port =
 526                                     mptsas_get_port(phy_info_cmp);
 527                                 port_details->starget =
 528                                     mptsas_get_starget(phy_info_cmp);
 529                                 port_details->num_phys =
 530                                         phy_info_cmp->port_details->num_phys;
 531                                 if (!phy_info_cmp->port_details->num_phys)
 532                                         kfree(phy_info_cmp->port_details);
 533                         } else
 534                                 phy_info_cmp->sas_port_add_phy=1;
 535                         /*
 536                          * Adding a phy to a port
 537                          */
 538                         phy_info_cmp->port_details = port_details;
 539                         if (phy_info_cmp->phy_id < 64 )
 540                                 port_details->phy_bitmask |=
 541                                 (1 << phy_info_cmp->phy_id);
 542                         port_details->num_phys++;
 543                 }
 544         }
 545
 546  out:
 547
 548         for (i = 0; i < port_info->num_phys; i++) {
 549                 port_details = port_info->phy_info[i].port_details;
 550                 if (!port_details)
 551                         continue;
 552                 dsaswideprintk(ioc, printk(KERN_DEBUG
 553                     "%s: [%p]: phy_id=%02d num_phys=%02d "
 554                     "bitmask=0x%016llX\n", __FUNCTION__,
 555                     port_details, i, port_details->num_phys,
 556                     (unsigned long long)port_details->phy_bitmask));
 557                 dsaswideprintk(ioc, printk(KERN_DEBUG"\t\tport = %p rphy=%p\n",
 558                         port_details->port, port_details->rphy));
 559         }
 560         dsaswideprintk(ioc, printk(KERN_DEBUG"\n"));
 561         mutex_unlock(&ioc->sas_topology_mutex);
 562 }
 563
 564 /**
 565  * csmisas_find_vtarget
 566  *
 567  * @ioc
 568  * @volume_id
 569  * @volume_bus
 570  *
 571  **/
 572 static VirtTarget *
 573 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
 574 {
 575         struct scsi_device              *sdev;
 576         VirtDevice                      *vdev;
 577         VirtTarget                      *vtarget = NULL;
 578
 579         shost_for_each_device(sdev, ioc->sh) {
 580                 if ((vdev = sdev->hostdata) == NULL)
 581                         continue;
 582                 if (vdev->vtarget->id == id &&
 583                     vdev->vtarget->channel == channel)
 584                         vtarget = vdev->vtarget;
 585         }
 586         return vtarget;
 587 }
 588
 589 /**
 590  * mptsas_target_reset
 591  *
 592  * Issues TARGET_RESET to end device using handshaking method
 593  *
 594  * @ioc
 595  * @channel
 596  * @id
 597  *
 598  * Returns (1) success
 599  *         (0) failure
 600  *
 601  **/
 602 static int
 603 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
 604 {
 605         MPT_FRAME_HDR   *mf;
 606         SCSITaskMgmt_t  *pScsiTm;
 607
 608         if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
 609                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
 610                     ioc->name,__FUNCTION__, __LINE__));
 611                 return 0;
 612         }
 613
 614         /* Format the Request
 615          */
 616         pScsiTm = (SCSITaskMgmt_t *) mf;
 617         memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
 618         pScsiTm->TargetID = id;
 619         pScsiTm->Bus = channel;
 620         pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
 621         pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
 622         pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
 623
 624         DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
 625
 626         if (mpt_send_handshake_request(ioc->TaskCtx, ioc,
 627             sizeof(SCSITaskMgmt_t), (u32 *)mf, NO_SLEEP)) {
 628                 mpt_free_msg_frame(ioc, mf);
 629                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, tm handshake failed @%d!!\n",
 630                     ioc->name,__FUNCTION__, __LINE__));
 631                 return 0;
 632         }
 633
 634         return 1;
 635 }
 636
 637 /**
 638  * mptsas_target_reset_queue
 639  *
 640  * Receive request for TARGET_RESET after recieving an firmware
 641  * event NOT_RESPONDING_EVENT, then put command in link list
 642  * and queue if task_queue already in use.
 643  *
 644  * @ioc
 645  * @sas_event_data
 646  *
 647  **/
 648 static void
 649 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
 650     EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
 651 {
 652         MPT_SCSI_HOST   *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
 653         VirtTarget *vtarget = NULL;
 654         struct mptsas_target_reset_event *target_reset_list;
 655         u8              id, channel;
 656
 657         id = sas_event_data->TargetID;
 658         channel = sas_event_data->Bus;
 659
 660         if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
 661                 return;
 662
 663         vtarget->deleted = 1; /* block IO */
 664
 665         target_reset_list = kzalloc(sizeof(*target_reset_list),
 666             GFP_ATOMIC);
 667         if (!target_reset_list) {
 668                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
 669                     ioc->name,__FUNCTION__, __LINE__));
 670                 return;
 671         }
 672
 673         memcpy(&target_reset_list->sas_event_data, sas_event_data,
 674                 sizeof(*sas_event_data));
 675         list_add_tail(&target_reset_list->list, &hd->target_reset_list);
 676
 677         if (hd->resetPending)
 678                 return;
 679
 680         if (mptsas_target_reset(ioc, channel, id)) {
 681                 target_reset_list->target_reset_issued = 1;
 682                 hd->resetPending = 1;
 683         }
 684 }
 685
 686 /**
 687  * mptsas_dev_reset_complete
 688  *
 689  * Completion for TARGET_RESET after NOT_RESPONDING_EVENT,
 690  * enable work queue to finish off removing device from upper layers.
 691  * then send next TARGET_RESET in the queue.
 692  *
 693  * @ioc
 694  *
 695  **/
 696 static void
 697 mptsas_dev_reset_complete(MPT_ADAPTER *ioc)
 698 {
 699         MPT_SCSI_HOST   *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
 700         struct list_head *head = &hd->target_reset_list;
 701         struct mptsas_target_reset_event *target_reset_list;
 702         struct mptsas_hotplug_event *ev;
 703         EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
 704         u8              id, channel;
 705         __le64          sas_address;
 706
 707         if (list_empty(head))
 708                 return;
 709
 710         target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, list);
 711
 712         sas_event_data = &target_reset_list->sas_event_data;
 713         id = sas_event_data->TargetID;
 714         channel = sas_event_data->Bus;
 715         hd->resetPending = 0;
 716
 717         /*
 718          * retry target reset
 719          */
 720         if (!target_reset_list->target_reset_issued) {
 721                 if (mptsas_target_reset(ioc, channel, id)) {
 722                         target_reset_list->target_reset_issued = 1;
 723                         hd->resetPending = 1;
 724                 }
 725                 return;
 726         }
 727
 728         /*
 729          * enable work queue to remove device from upper layers
 730          */
 731         list_del(&target_reset_list->list);
 732
 733         ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
 734         if (!ev) {
 735                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
 736                     ioc->name,__FUNCTION__, __LINE__));
 737                 return;
 738         }
 739
 740         INIT_WORK(&ev->work, mptsas_hotplug_work);
 741         ev->ioc = ioc;
 742         ev->handle = le16_to_cpu(sas_event_data->DevHandle);
 743         ev->parent_handle =
 744             le16_to_cpu(sas_event_data->ParentDevHandle);
 745         ev->channel = channel;
 746         ev->id =id;
 747         ev->phy_id = sas_event_data->PhyNum;
 748         memcpy(&sas_address, &sas_event_data->SASAddress,
 749             sizeof(__le64));
 750         ev->sas_address = le64_to_cpu(sas_address);
 751         ev->device_info = le32_to_cpu(sas_event_data->DeviceInfo);
 752         ev->event_type = MPTSAS_DEL_DEVICE;
 753         schedule_work(&ev->work);
 754         kfree(target_reset_list);
 755
 756         /*
 757          * issue target reset to next device in the queue
 758          */
 759
 760         head = &hd->target_reset_list;
 761         if (list_empty(head))
 762                 return;
 763
 764         target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
 765             list);
 766
 767         sas_event_data = &target_reset_list->sas_event_data;
 768         id = sas_event_data->TargetID;
 769         channel = sas_event_data->Bus;
 770
 771         if (mptsas_target_reset(ioc, channel, id)) {
 772                 target_reset_list->target_reset_issued = 1;
 773                 hd->resetPending = 1;
 774         }
 775 }
 776
 777 /**
 778  * mptsas_taskmgmt_complete
 779  *
 780  * @ioc
 781  * @mf
 782  * @mr
 783  *
 784  **/
 785 static int
 786 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
 787 {
 788         mptsas_dev_reset_complete(ioc);
 789         return mptscsih_taskmgmt_complete(ioc, mf, mr);
 790 }
 791
 792 /**
 793  * mptscsih_ioc_reset
 794  *
 795  * @ioc
 796  * @reset_phase
 797  *
 798  **/
 799 static int
 800 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
 801 {
 802         MPT_SCSI_HOST   *hd;
 803         struct mptsas_target_reset_event *target_reset_list, *n;
 804         int rc;
 805
 806         rc = mptscsih_ioc_reset(ioc, reset_phase);
 807
 808         if (ioc->bus_type != SAS)
 809                 goto out;
 810
 811         if (reset_phase != MPT_IOC_POST_RESET)
 812                 goto out;
 813
 814         if (!ioc->sh || !ioc->sh->hostdata)
 815                 goto out;
 816         hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
 817         if (!hd->ioc)
 818                 goto out;
 819
 820         if (list_empty(&hd->target_reset_list))
 821                 goto out;
 822
 823         /* flush the target_reset_list */
 824         list_for_each_entry_safe(target_reset_list, n,
 825             &hd->target_reset_list, list) {
 826                 list_del(&target_reset_list->list);
 827                 kfree(target_reset_list);
 828         }
 829
 830  out:
 831         return rc;
 832 }
 833
 834 static int
 835 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
 836                 u32 form, u32 form_specific)
 837 {
 838         ConfigExtendedPageHeader_t hdr;
 839         CONFIGPARMS cfg;
 840         SasEnclosurePage0_t *buffer;
 841         dma_addr_t dma_handle;
 842         int error;
 843         __le64 le_identifier;
 844
 845         memset(&hdr, 0, sizeof(hdr));
 846         hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
 847         hdr.PageNumber = 0;
 848         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 849         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
 850
 851         cfg.cfghdr.ehdr = &hdr;
 852         cfg.physAddr = -1;
 853         cfg.pageAddr = form + form_specific;
 854         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 855         cfg.dir = 0;    /* read */
 856         cfg.timeout = 10;
 857
 858         error = mpt_config(ioc, &cfg);
 859         if (error)
 860                 goto out;
 861         if (!hdr.ExtPageLength) {
 862                 error = -ENXIO;
 863                 goto out;
 864         }
 865
 866         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 867                         &dma_handle);
 868         if (!buffer) {
 869                 error = -ENOMEM;
 870                 goto out;
 871         }
 872
 873         cfg.physAddr = dma_handle;
 874         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 875
 876         error = mpt_config(ioc, &cfg);
 877         if (error)
 878                 goto out_free_consistent;
 879
 880         /* save config data */
 881         memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
 882         enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
 883         enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
 884         enclosure->flags = le16_to_cpu(buffer->Flags);
 885         enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
 886         enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
 887         enclosure->start_id = buffer->StartTargetID;
 888         enclosure->start_channel = buffer->StartBus;
 889         enclosure->sep_id = buffer->SEPTargetID;
 890         enclosure->sep_channel = buffer->SEPBus;
 891
 892  out_free_consistent:
 893         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 894                             buffer, dma_handle);
 895  out:
 896         return error;
 897 }
 898
 899 static int
 900 mptsas_slave_configure(struct scsi_device *sdev)
 901 {
 902
 903         if (sdev->channel == MPTSAS_RAID_CHANNEL)
 904                 goto out;
 905
 906         sas_read_port_mode_page(sdev);
 907
 908  out:
 909         return mptscsih_slave_configure(sdev);
 910 }
 911
 912 static int
 913 mptsas_target_alloc(struct scsi_target *starget)
 914 {
 915         struct Scsi_Host *host = dev_to_shost(&starget->dev);
 916         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)host->hostdata;
 917         VirtTarget              *vtarget;
 918         u8                      id, channel;
 919         struct sas_rphy         *rphy;
 920         struct mptsas_portinfo  *p;
 921         int                      i;
 922
 923         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 924         if (!vtarget)
 925                 return -ENOMEM;
 926
 927         vtarget->starget = starget;
 928         vtarget->ioc_id = hd->ioc->id;
 929         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 930         id = starget->id;
 931         channel = 0;
 932
 933         /*
 934          * RAID volumes placed beyond the last expected port.
 935          */
 936         if (starget->channel == MPTSAS_RAID_CHANNEL) {
 937                 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
 938                         if (id == hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
 939                                 channel = hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
 940                 goto out;
 941         }
 942
 943         rphy = dev_to_rphy(starget->dev.parent);
 944         mutex_lock(&hd->ioc->sas_topology_mutex);
 945         list_for_each_entry(p, &hd->ioc->sas_topology, list) {
 946                 for (i = 0; i < p->num_phys; i++) {
 947                         if (p->phy_info[i].attached.sas_address !=
 948                                         rphy->identify.sas_address)
 949                                 continue;
 950                         id = p->phy_info[i].attached.id;
 951                         channel = p->phy_info[i].attached.channel;
 952                         mptsas_set_starget(&p->phy_info[i], starget);
 953
 954                         /*
 955                          * Exposing hidden raid components
 956                          */
 957                         if (mptscsih_is_phys_disk(hd->ioc, channel, id)) {
 958                                 id = mptscsih_raid_id_to_num(hd->ioc,
 959                                                 channel, id);
 960                                 vtarget->tflags |=
 961                                     MPT_TARGET_FLAGS_RAID_COMPONENT;
 962                                 p->phy_info[i].attached.phys_disk_num = id;
 963                         }
 964                         mutex_unlock(&hd->ioc->sas_topology_mutex);
 965                         goto out;
 966                 }
 967         }
 968         mutex_unlock(&hd->ioc->sas_topology_mutex);
 969
 970         kfree(vtarget);
 971         return -ENXIO;
 972
 973  out:
 974         vtarget->id = id;
 975         vtarget->channel = channel;
 976         starget->hostdata = vtarget;
 977         return 0;
 978 }
 979
 980 static void
 981 mptsas_target_destroy(struct scsi_target *starget)
 982 {
 983         struct Scsi_Host *host = dev_to_shost(&starget->dev);
 984         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)host->hostdata;
 985         struct sas_rphy         *rphy;
 986         struct mptsas_portinfo  *p;
 987         int                      i;
 988
 989         if (!starget->hostdata)
 990                 return;
 991
 992         if (starget->channel == MPTSAS_RAID_CHANNEL)
 993                 goto out;
 994
 995         rphy = dev_to_rphy(starget->dev.parent);
 996         list_for_each_entry(p, &hd->ioc->sas_topology, list) {
 997                 for (i = 0; i < p->num_phys; i++) {
 998                         if (p->phy_info[i].attached.sas_address !=
 999                                         rphy->identify.sas_address)
1000                                 continue;
1001                         mptsas_set_starget(&p->phy_info[i], NULL);
1002                         goto out;
1003                 }
1004         }
1005
1006  out:
1007         kfree(starget->hostdata);
1008         starget->hostdata = NULL;
1009 }
1010
1011
1012 static int
1013 mptsas_slave_alloc(struct scsi_device *sdev)
1014 {
1015         struct Scsi_Host        *host = sdev->host;
1016         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)host->hostdata;
1017         struct sas_rphy         *rphy;
1018         struct mptsas_portinfo  *p;
1019         VirtDevice              *vdev;
1020         struct scsi_target      *starget;
1021         int                     i;
1022
1023         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
1024         if (!vdev) {
1025                 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
1026                                 hd->ioc->name, sizeof(VirtDevice));
1027                 return -ENOMEM;
1028         }
1029         starget = scsi_target(sdev);
1030         vdev->vtarget = starget->hostdata;
1031
1032         if (sdev->channel == MPTSAS_RAID_CHANNEL)
1033                 goto out;
1034
1035         rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1036         mutex_lock(&hd->ioc->sas_topology_mutex);
1037         list_for_each_entry(p, &hd->ioc->sas_topology, list) {
1038                 for (i = 0; i < p->num_phys; i++) {
1039                         if (p->phy_info[i].attached.sas_address !=
1040                                         rphy->identify.sas_address)
1041                                 continue;
1042                         vdev->lun = sdev->lun;
1043                         /*
1044                          * Exposing hidden raid components
1045                          */
1046                         if (mptscsih_is_phys_disk(hd->ioc,
1047                             p->phy_info[i].attached.channel,
1048                             p->phy_info[i].attached.id))
1049                                 sdev->no_uld_attach = 1;
1050                         mutex_unlock(&hd->ioc->sas_topology_mutex);
1051                         goto out;
1052                 }
1053         }
1054         mutex_unlock(&hd->ioc->sas_topology_mutex);
1055
1056         kfree(vdev);
1057         return -ENXIO;
1058
1059  out:
1060         vdev->vtarget->num_luns++;
1061         sdev->hostdata = vdev;
1062         return 0;
1063 }
1064
1065 static int
1066 mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1067 {
1068         VirtDevice      *vdev = SCpnt->device->hostdata;
1069
1070         if (!vdev || !vdev->vtarget || vdev->vtarget->deleted) {
1071                 SCpnt->result = DID_NO_CONNECT << 16;
1072                 done(SCpnt);
1073                 return 0;
1074         }
1075
1076 //      scsi_print_command(SCpnt);
1077
1078         return mptscsih_qcmd(SCpnt,done);
1079 }
1080
1081
1082 static struct scsi_host_template mptsas_driver_template = {
1083         .module                         = THIS_MODULE,
1084         .proc_name                      = "mptsas",
1085         .proc_info                      = mptscsih_proc_info,
1086         .name                           = "MPT SPI Host",
1087         .info                           = mptscsih_info,
1088         .queuecommand                   = mptsas_qcmd,
1089         .target_alloc                   = mptsas_target_alloc,
1090         .slave_alloc                    = mptsas_slave_alloc,
1091         .slave_configure                = mptsas_slave_configure,
1092         .target_destroy                 = mptsas_target_destroy,
1093         .slave_destroy                  = mptscsih_slave_destroy,
1094         .change_queue_depth             = mptscsih_change_queue_depth,
1095         .eh_abort_handler               = mptscsih_abort,
1096         .eh_device_reset_handler        = mptscsih_dev_reset,
1097         .eh_bus_reset_handler           = mptscsih_bus_reset,
1098         .eh_host_reset_handler          = mptscsih_host_reset,
1099         .bios_param                     = mptscsih_bios_param,
1100         .can_queue                      = MPT_FC_CAN_QUEUE,
1101         .this_id                        = -1,
1102         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
1103         .max_sectors                    = 8192,
1104         .cmd_per_lun                    = 7,
1105         .use_clustering                 = ENABLE_CLUSTERING,
1106         .shost_attrs                    = mptscsih_host_attrs,
1107 };
1108
1109 static int mptsas_get_linkerrors(struct sas_phy *phy)
1110 {
1111         MPT_ADAPTER *ioc = phy_to_ioc(phy);
1112         ConfigExtendedPageHeader_t hdr;
1113         CONFIGPARMS cfg;
1114         SasPhyPage1_t *buffer;
1115         dma_addr_t dma_handle;
1116         int error;
1117
1118         /* FIXME: only have link errors on local phys */
1119         if (!scsi_is_sas_phy_local(phy))
1120                 return -EINVAL;
1121
1122         hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
1123         hdr.ExtPageLength = 0;
1124         hdr.PageNumber = 1 /* page number 1*/;
1125         hdr.Reserved1 = 0;
1126         hdr.Reserved2 = 0;
1127         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1128         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1129
1130         cfg.cfghdr.ehdr = &hdr;
1131         cfg.physAddr = -1;
1132         cfg.pageAddr = phy->identify.phy_identifier;
1133         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1134         cfg.dir = 0;    /* read */
1135         cfg.timeout = 10;
1136
1137         error = mpt_config(ioc, &cfg);
1138         if (error)
1139                 return error;
1140         if (!hdr.ExtPageLength)
1141                 return -ENXIO;
1142
1143         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1144                                       &dma_handle);
1145         if (!buffer)
1146                 return -ENOMEM;
1147
1148         cfg.physAddr = dma_handle;
1149         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1150
1151         error = mpt_config(ioc, &cfg);
1152         if (error)
1153                 goto out_free_consistent;
1154
1155         mptsas_print_phy_pg1(ioc, buffer);
1156
1157         phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
1158         phy->running_disparity_error_count =
1159                 le32_to_cpu(buffer->RunningDisparityErrorCount);
1160         phy->loss_of_dword_sync_count =
1161                 le32_to_cpu(buffer->LossDwordSynchCount);
1162         phy->phy_reset_problem_count =
1163                 le32_to_cpu(buffer->PhyResetProblemCount);
1164
1165  out_free_consistent:
1166         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1167                             buffer, dma_handle);
1168         return error;
1169 }
1170
1171 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
1172                 MPT_FRAME_HDR *reply)
1173 {
1174         ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
1175         if (reply != NULL) {
1176                 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
1177                 memcpy(ioc->sas_mgmt.reply, reply,
1178                     min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
1179         }
1180         complete(&ioc->sas_mgmt.done);
1181         return 1;
1182 }
1183
1184 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
1185 {
1186         MPT_ADAPTER *ioc = phy_to_ioc(phy);
1187         SasIoUnitControlRequest_t *req;
1188         SasIoUnitControlReply_t *reply;
1189         MPT_FRAME_HDR *mf;
1190         MPIHeader_t *hdr;
1191         unsigned long timeleft;
1192         int error = -ERESTARTSYS;
1193
1194         /* FIXME: fusion doesn't allow non-local phy reset */
1195         if (!scsi_is_sas_phy_local(phy))
1196                 return -EINVAL;
1197
1198         /* not implemented for expanders */
1199         if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
1200                 return -ENXIO;
1201
1202         if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
1203                 goto out;
1204
1205         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
1206         if (!mf) {
1207                 error = -ENOMEM;
1208                 goto out_unlock;
1209         }
1210
1211         hdr = (MPIHeader_t *) mf;
1212         req = (SasIoUnitControlRequest_t *)mf;
1213         memset(req, 0, sizeof(SasIoUnitControlRequest_t));
1214         req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
1215         req->MsgContext = hdr->MsgContext;
1216         req->Operation = hard_reset ?
1217                 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
1218         req->PhyNum = phy->identify.phy_identifier;
1219
1220         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
1221
1222         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
1223                         10 * HZ);
1224         if (!timeleft) {
1225                 /* On timeout reset the board */
1226                 mpt_free_msg_frame(ioc, mf);
1227                 mpt_HardResetHandler(ioc, CAN_SLEEP);
1228                 error = -ETIMEDOUT;
1229                 goto out_unlock;
1230         }
1231
1232         /* a reply frame is expected */
1233         if ((ioc->sas_mgmt.status &
1234             MPT_IOCTL_STATUS_RF_VALID) == 0) {
1235                 error = -ENXIO;
1236                 goto out_unlock;
1237         }
1238
1239         /* process the completed Reply Message Frame */
1240         reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
1241         if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
1242                 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
1243                     __FUNCTION__,
1244                     reply->IOCStatus,
1245                     reply->IOCLogInfo);
1246                 error = -ENXIO;
1247                 goto out_unlock;
1248         }
1249
1250         error = 0;
1251
1252  out_unlock:
1253         mutex_unlock(&ioc->sas_mgmt.mutex);
1254  out:
1255         return error;
1256 }
1257
1258 static int
1259 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1260 {
1261         MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1262         int i, error;
1263         struct mptsas_portinfo *p;
1264         struct mptsas_enclosure enclosure_info;
1265         u64 enclosure_handle;
1266
1267         mutex_lock(&ioc->sas_topology_mutex);
1268         list_for_each_entry(p, &ioc->sas_topology, list) {
1269                 for (i = 0; i < p->num_phys; i++) {
1270                         if (p->phy_info[i].attached.sas_address ==
1271                             rphy->identify.sas_address) {
1272                                 enclosure_handle = p->phy_info[i].
1273                                         attached.handle_enclosure;
1274                                 goto found_info;
1275                         }
1276                 }
1277         }
1278         mutex_unlock(&ioc->sas_topology_mutex);
1279         return -ENXIO;
1280
1281  found_info:
1282         mutex_unlock(&ioc->sas_topology_mutex);
1283         memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
1284         error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
1285                         (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
1286                          MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
1287         if (!error)
1288                 *identifier = enclosure_info.enclosure_logical_id;
1289         return error;
1290 }
1291
1292 static int
1293 mptsas_get_bay_identifier(struct sas_rphy *rphy)
1294 {
1295         MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1296         struct mptsas_portinfo *p;
1297         int i, rc;
1298
1299         mutex_lock(&ioc->sas_topology_mutex);
1300         list_for_each_entry(p, &ioc->sas_topology, list) {
1301                 for (i = 0; i < p->num_phys; i++) {
1302                         if (p->phy_info[i].attached.sas_address ==
1303                             rphy->identify.sas_address) {
1304                                 rc = p->phy_info[i].attached.slot;
1305                                 goto out;
1306                         }
1307                 }
1308         }
1309         rc = -ENXIO;
1310  out:
1311         mutex_unlock(&ioc->sas_topology_mutex);
1312         return rc;
1313 }
1314
1315 static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
1316                               struct request *req)
1317 {
1318         MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
1319         MPT_FRAME_HDR *mf;
1320         SmpPassthroughRequest_t *smpreq;
1321         struct request *rsp = req->next_rq;
1322         int ret;
1323         int flagsLength;
1324         unsigned long timeleft;
1325         char *psge;
1326         dma_addr_t dma_addr_in = 0;
1327         dma_addr_t dma_addr_out = 0;
1328         u64 sas_address = 0;
1329
1330         if (!rsp) {
1331                 printk(KERN_ERR "%s: the smp response space is missing\n",
1332                        __FUNCTION__);
1333                 return -EINVAL;
1334         }
1335
1336         /* do we need to support multiple segments? */
1337         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
1338                 printk(KERN_ERR "%s: multiple segments req %u %u, rsp %u %u\n",
1339                        __FUNCTION__, req->bio->bi_vcnt, req->data_len,
1340                        rsp->bio->bi_vcnt, rsp->data_len);
1341                 return -EINVAL;
1342         }
1343
1344         ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
1345         if (ret)
1346                 goto out;
1347
1348         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
1349         if (!mf) {
1350                 ret = -ENOMEM;
1351                 goto out_unlock;
1352         }
1353
1354         smpreq = (SmpPassthroughRequest_t *)mf;
1355         memset(smpreq, 0, sizeof(*smpreq));
1356
1357         smpreq->RequestDataLength = cpu_to_le16(req->data_len - 4);
1358         smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
1359
1360         if (rphy)
1361                 sas_address = rphy->identify.sas_address;
1362         else {
1363                 struct mptsas_portinfo *port_info;
1364
1365                 mutex_lock(&ioc->sas_topology_mutex);
1366                 port_info = mptsas_find_portinfo_by_handle(ioc, ioc->handle);
1367                 if (port_info && port_info->phy_info)
1368                         sas_address =
1369                                 port_info->phy_info[0].phy->identify.sas_address;
1370                 mutex_unlock(&ioc->sas_topology_mutex);
1371         }
1372
1373         *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
1374
1375         psge = (char *)
1376                 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
1377
1378         /* request */
1379         flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1380                        MPI_SGE_FLAGS_END_OF_BUFFER |
1381                        MPI_SGE_FLAGS_DIRECTION |
1382                        mpt_addr_size()) << MPI_SGE_FLAGS_SHIFT;
1383         flagsLength |= (req->data_len - 4);
1384
1385         dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
1386                                       req->data_len, PCI_DMA_BIDIRECTIONAL);
1387         if (!dma_addr_out)
1388                 goto put_mf;
1389         mpt_add_sge(psge, flagsLength, dma_addr_out);
1390         psge += (sizeof(u32) + sizeof(dma_addr_t));
1391
1392         /* response */
1393         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
1394         flagsLength |= rsp->data_len + 4;
1395         dma_addr_in =  pci_map_single(ioc->pcidev, bio_data(rsp->bio),
1396                                       rsp->data_len, PCI_DMA_BIDIRECTIONAL);
1397         if (!dma_addr_in)
1398                 goto unmap;
1399         mpt_add_sge(psge, flagsLength, dma_addr_in);
1400
1401         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
1402
1403         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
1404         if (!timeleft) {
1405                 printk(KERN_ERR "%s: smp timeout!\n", __FUNCTION__);
1406                 /* On timeout reset the board */
1407                 mpt_HardResetHandler(ioc, CAN_SLEEP);
1408                 ret = -ETIMEDOUT;
1409                 goto unmap;
1410         }
1411         mf = NULL;
1412
1413         if (ioc->sas_mgmt.status & MPT_IOCTL_STATUS_RF_VALID) {
1414                 SmpPassthroughReply_t *smprep;
1415
1416                 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
1417                 memcpy(req->sense, smprep, sizeof(*smprep));
1418                 req->sense_len = sizeof(*smprep);
1419         } else {
1420                 printk(KERN_ERR "%s: smp passthru reply failed to be returned\n",
1421                        __FUNCTION__);
1422                 ret = -ENXIO;
1423         }
1424 unmap:
1425         if (dma_addr_out)
1426                 pci_unmap_single(ioc->pcidev, dma_addr_out, req->data_len,
1427                                  PCI_DMA_BIDIRECTIONAL);
1428         if (dma_addr_in)
1429                 pci_unmap_single(ioc->pcidev, dma_addr_in, rsp->data_len,
1430                                  PCI_DMA_BIDIRECTIONAL);
1431 put_mf:
1432         if (mf)
1433                 mpt_free_msg_frame(ioc, mf);
1434 out_unlock:
1435         mutex_unlock(&ioc->sas_mgmt.mutex);
1436 out:
1437         return ret;
1438 }
1439
1440 static struct sas_function_template mptsas_transport_functions = {
1441         .get_linkerrors         = mptsas_get_linkerrors,
1442         .get_enclosure_identifier = mptsas_get_enclosure_identifier,
1443         .get_bay_identifier     = mptsas_get_bay_identifier,
1444         .phy_reset              = mptsas_phy_reset,
1445         .smp_handler            = mptsas_smp_handler,
1446 };
1447
1448 static struct scsi_transport_template *mptsas_transport_template;
1449
1450 static int
1451 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
1452 {
1453         ConfigExtendedPageHeader_t hdr;
1454         CONFIGPARMS cfg;
1455         SasIOUnitPage0_t *buffer;
1456         dma_addr_t dma_handle;
1457         int error, i;
1458
1459         hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
1460         hdr.ExtPageLength = 0;
1461         hdr.PageNumber = 0;
1462         hdr.Reserved1 = 0;
1463         hdr.Reserved2 = 0;
1464         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1465         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1466
1467         cfg.cfghdr.ehdr = &hdr;
1468         cfg.physAddr = -1;
1469         cfg.pageAddr = 0;
1470         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1471         cfg.dir = 0;    /* read */
1472         cfg.timeout = 10;
1473
1474         error = mpt_config(ioc, &cfg);
1475         if (error)
1476                 goto out;
1477         if (!hdr.ExtPageLength) {
1478                 error = -ENXIO;
1479                 goto out;
1480         }
1481
1482         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1483                                             &dma_handle);
1484         if (!buffer) {
1485                 error = -ENOMEM;
1486                 goto out;
1487         }
1488
1489         cfg.physAddr = dma_handle;
1490         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1491
1492         error = mpt_config(ioc, &cfg);
1493         if (error)
1494                 goto out_free_consistent;
1495
1496         port_info->num_phys = buffer->NumPhys;
1497         port_info->phy_info = kcalloc(port_info->num_phys,
1498                 sizeof(*port_info->phy_info),GFP_KERNEL);
1499         if (!port_info->phy_info) {
1500                 error = -ENOMEM;
1501                 goto out_free_consistent;
1502         }
1503
1504         ioc->nvdata_version_persistent =
1505             le16_to_cpu(buffer->NvdataVersionPersistent);
1506         ioc->nvdata_version_default =
1507             le16_to_cpu(buffer->NvdataVersionDefault);
1508
1509         for (i = 0; i < port_info->num_phys; i++) {
1510                 mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
1511                 port_info->phy_info[i].phy_id = i;
1512                 port_info->phy_info[i].port_id =
1513                     buffer->PhyData[i].Port;
1514                 port_info->phy_info[i].negotiated_link_rate =
1515                     buffer->PhyData[i].NegotiatedLinkRate;
1516                 port_info->phy_info[i].portinfo = port_info;
1517                 port_info->phy_info[i].handle =
1518                     le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
1519         }
1520
1521  out_free_consistent:
1522         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1523                             buffer, dma_handle);
1524  out:
1525         return error;
1526 }
1527
1528 static int
1529 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
1530 {
1531         ConfigExtendedPageHeader_t hdr;
1532         CONFIGPARMS cfg;
1533         SasIOUnitPage1_t *buffer;
1534         dma_addr_t dma_handle;
1535         int error;
1536         u16 device_missing_delay;
1537
1538         memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
1539         memset(&cfg, 0, sizeof(CONFIGPARMS));
1540
1541         cfg.cfghdr.ehdr = &hdr;
1542         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1543         cfg.timeout = 10;
1544         cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1545         cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1546         cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
1547         cfg.cfghdr.ehdr->PageNumber = 1;
1548
1549         error = mpt_config(ioc, &cfg);
1550         if (error)
1551                 goto out;
1552         if (!hdr.ExtPageLength) {
1553                 error = -ENXIO;
1554                 goto out;
1555         }
1556
1557         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1558                                             &dma_handle);
1559         if (!buffer) {
1560                 error = -ENOMEM;
1561                 goto out;
1562         }
1563
1564         cfg.physAddr = dma_handle;
1565         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1566
1567         error = mpt_config(ioc, &cfg);
1568         if (error)
1569                 goto out_free_consistent;
1570
1571         ioc->io_missing_delay  =
1572             le16_to_cpu(buffer->IODeviceMissingDelay);
1573         device_missing_delay = le16_to_cpu(buffer->ReportDeviceMissingDelay);
1574         ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
1575             (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
1576             device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
1577
1578  out_free_consistent:
1579         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1580                             buffer, dma_handle);
1581  out:
1582         return error;
1583 }
1584
1585 static int
1586 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1587                 u32 form, u32 form_specific)
1588 {
1589         ConfigExtendedPageHeader_t hdr;
1590         CONFIGPARMS cfg;
1591         SasPhyPage0_t *buffer;
1592         dma_addr_t dma_handle;
1593         int error;
1594
1595         hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
1596         hdr.ExtPageLength = 0;
1597         hdr.PageNumber = 0;
1598         hdr.Reserved1 = 0;
1599         hdr.Reserved2 = 0;
1600         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1601         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1602
1603         cfg.cfghdr.ehdr = &hdr;
1604         cfg.dir = 0;    /* read */
1605         cfg.timeout = 10;
1606
1607         /* Get Phy Pg 0 for each Phy. */
1608         cfg.physAddr = -1;
1609         cfg.pageAddr = form + form_specific;
1610         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1611
1612         error = mpt_config(ioc, &cfg);
1613         if (error)
1614                 goto out;
1615
1616         if (!hdr.ExtPageLength) {
1617                 error = -ENXIO;
1618                 goto out;
1619         }
1620
1621         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1622                                       &dma_handle);
1623         if (!buffer) {
1624                 error = -ENOMEM;
1625                 goto out;
1626         }
1627
1628         cfg.physAddr = dma_handle;
1629         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1630
1631         error = mpt_config(ioc, &cfg);
1632         if (error)
1633                 goto out_free_consistent;
1634
1635         mptsas_print_phy_pg0(ioc, buffer);
1636
1637         phy_info->hw_link_rate = buffer->HwLinkRate;
1638         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1639         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1640         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1641
1642  out_free_consistent:
1643         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1644                             buffer, dma_handle);
1645  out:
1646         return error;
1647 }
1648
1649 static int
1650 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
1651                 u32 form, u32 form_specific)
1652 {
1653         ConfigExtendedPageHeader_t hdr;
1654         CONFIGPARMS cfg;
1655         SasDevicePage0_t *buffer;
1656         dma_addr_t dma_handle;
1657         __le64 sas_address;
1658         int error=0;
1659
1660         if (ioc->sas_discovery_runtime &&
1661                 mptsas_is_end_device(device_info))
1662                         goto out;
1663
1664         hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
1665         hdr.ExtPageLength = 0;
1666         hdr.PageNumber = 0;
1667         hdr.Reserved1 = 0;
1668         hdr.Reserved2 = 0;
1669         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1670         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1671
1672         cfg.cfghdr.ehdr = &hdr;
1673         cfg.pageAddr = form + form_specific;
1674         cfg.physAddr = -1;
1675         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1676         cfg.dir = 0;    /* read */
1677         cfg.timeout = 10;
1678
1679         memset(device_info, 0, sizeof(struct mptsas_devinfo));
1680         error = mpt_config(ioc, &cfg);
1681         if (error)
1682                 goto out;
1683         if (!hdr.ExtPageLength) {
1684                 error = -ENXIO;
1685                 goto out;
1686         }
1687
1688         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1689                                       &dma_handle);
1690         if (!buffer) {
1691                 error = -ENOMEM;
1692                 goto out;
1693         }
1694
1695         cfg.physAddr = dma_handle;
1696         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1697
1698         error = mpt_config(ioc, &cfg);
1699         if (error)
1700                 goto out_free_consistent;
1701
1702         mptsas_print_device_pg0(ioc, buffer);
1703
1704         device_info->handle = le16_to_cpu(buffer->DevHandle);
1705         device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
1706         device_info->handle_enclosure =
1707             le16_to_cpu(buffer->EnclosureHandle);
1708         device_info->slot = le16_to_cpu(buffer->Slot);
1709         device_info->phy_id = buffer->PhyNum;
1710         device_info->port_id = buffer->PhysicalPort;
1711         device_info->id = buffer->TargetID;
1712         device_info->phys_disk_num = ~0;
1713         device_info->channel = buffer->Bus;
1714         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
1715         device_info->sas_address = le64_to_cpu(sas_address);
1716         device_info->device_info =
1717             le32_to_cpu(buffer->DeviceInfo);
1718
1719  out_free_consistent:
1720         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1721                             buffer, dma_handle);
1722  out:
1723         return error;
1724 }
1725
1726 static int
1727 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
1728                 u32 form, u32 form_specific)
1729 {
1730         ConfigExtendedPageHeader_t hdr;
1731         CONFIGPARMS cfg;
1732         SasExpanderPage0_t *buffer;
1733         dma_addr_t dma_handle;
1734         int i, error;
1735
1736         hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1737         hdr.ExtPageLength = 0;
1738         hdr.PageNumber = 0;
1739         hdr.Reserved1 = 0;
1740         hdr.Reserved2 = 0;
1741         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1742         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1743
1744         cfg.cfghdr.ehdr = &hdr;
1745         cfg.physAddr = -1;
1746         cfg.pageAddr = form + form_specific;
1747         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1748         cfg.dir = 0;    /* read */
1749         cfg.timeout = 10;
1750
1751         memset(port_info, 0, sizeof(struct mptsas_portinfo));
1752         error = mpt_config(ioc, &cfg);
1753         if (error)
1754                 goto out;
1755
1756         if (!hdr.ExtPageLength) {
1757                 error = -ENXIO;
1758                 goto out;
1759         }
1760
1761         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1762                                       &dma_handle);
1763         if (!buffer) {
1764                 error = -ENOMEM;
1765                 goto out;
1766         }
1767
1768         cfg.physAddr = dma_handle;
1769         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1770
1771         error = mpt_config(ioc, &cfg);
1772         if (error)
1773                 goto out_free_consistent;
1774
1775         /* save config data */
1776         port_info->num_phys = buffer->NumPhys;
1777         port_info->phy_info = kcalloc(port_info->num_phys,
1778                 sizeof(*port_info->phy_info),GFP_KERNEL);
1779         if (!port_info->phy_info) {
1780                 error = -ENOMEM;
1781                 goto out_free_consistent;
1782         }
1783
1784         for (i = 0; i < port_info->num_phys; i++) {
1785                 port_info->phy_info[i].portinfo = port_info;
1786                 port_info->phy_info[i].handle =
1787                     le16_to_cpu(buffer->DevHandle);
1788         }
1789
1790  out_free_consistent:
1791         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1792                             buffer, dma_handle);
1793  out:
1794         return error;
1795 }
1796
1797 static int
1798 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1799                 u32 form, u32 form_specific)
1800 {
1801         ConfigExtendedPageHeader_t hdr;
1802         CONFIGPARMS cfg;
1803         SasExpanderPage1_t *buffer;
1804         dma_addr_t dma_handle;
1805         int error=0;
1806
1807         if (ioc->sas_discovery_runtime &&
1808                 mptsas_is_end_device(&phy_info->attached))
1809                         goto out;
1810
1811         hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1812         hdr.ExtPageLength = 0;
1813         hdr.PageNumber = 1;
1814         hdr.Reserved1 = 0;
1815         hdr.Reserved2 = 0;
1816         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1817         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1818
1819         cfg.cfghdr.ehdr = &hdr;
1820         cfg.physAddr = -1;
1821         cfg.pageAddr = form + form_specific;
1822         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1823         cfg.dir = 0;    /* read */
1824         cfg.timeout = 10;
1825
1826         error = mpt_config(ioc, &cfg);
1827         if (error)
1828                 goto out;
1829
1830         if (!hdr.ExtPageLength) {
1831                 error = -ENXIO;
1832                 goto out;
1833         }
1834
1835         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1836                                       &dma_handle);
1837         if (!buffer) {
1838                 error = -ENOMEM;
1839                 goto out;
1840         }
1841
1842         cfg.physAddr = dma_handle;
1843         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1844
1845         error = mpt_config(ioc, &cfg);
1846         if (error)
1847                 goto out_free_consistent;
1848
1849
1850         mptsas_print_expander_pg1(ioc, buffer);
1851
1852         /* save config data */
1853         phy_info->phy_id = buffer->PhyIdentifier;
1854         phy_info->port_id = buffer->PhysicalPort;
1855         phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
1856         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1857         phy_info->hw_link_rate = buffer->HwLinkRate;
1858         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1859         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1860
1861  out_free_consistent:
1862         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1863                             buffer, dma_handle);
1864  out:
1865         return error;
1866 }
1867
1868 static void
1869 mptsas_parse_device_info(struct sas_identify *identify,
1870                 struct mptsas_devinfo *device_info)
1871 {
1872         u16 protocols;
1873
1874         identify->sas_address = device_info->sas_address;
1875         identify->phy_identifier = device_info->phy_id;
1876
1877         /*
1878          * Fill in Phy Initiator Port Protocol.
1879          * Bits 6:3, more than one bit can be set, fall through cases.
1880          */
1881         protocols = device_info->device_info & 0x78;
1882         identify->initiator_port_protocols = 0;
1883         if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
1884                 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
1885         if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1886                 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
1887         if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
1888                 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
1889         if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
1890                 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
1891
1892         /*
1893          * Fill in Phy Target Port Protocol.
1894          * Bits 10:7, more than one bit can be set, fall through cases.
1895          */
1896         protocols = device_info->device_info & 0x780;
1897         identify->target_port_protocols = 0;
1898         if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1899                 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
1900         if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
1901                 identify->target_port_protocols |= SAS_PROTOCOL_STP;
1902         if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
1903                 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
1904         if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1905                 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
1906
1907         /*
1908          * Fill in Attached device type.
1909          */
1910         switch (device_info->device_info &
1911                         MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
1912         case MPI_SAS_DEVICE_INFO_NO_DEVICE:
1913                 identify->device_type = SAS_PHY_UNUSED;
1914                 break;
1915         case MPI_SAS_DEVICE_INFO_END_DEVICE:
1916                 identify->device_type = SAS_END_DEVICE;
1917                 break;
1918         case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
1919                 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
1920                 break;
1921         case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
1922                 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
1923                 break;
1924         }
1925 }
1926
1927 static int mptsas_probe_one_phy(struct device *dev,
1928                 struct mptsas_phyinfo *phy_info, int index, int local)
1929 {
1930         MPT_ADAPTER *ioc;
1931         struct sas_phy *phy;
1932         struct sas_port *port;
1933         int error = 0;
1934
1935         if (!dev) {
1936                 error = -ENODEV;
1937                 goto out;
1938         }
1939
1940         if (!phy_info->phy) {
1941                 phy = sas_phy_alloc(dev, index);
1942                 if (!phy) {
1943                         error = -ENOMEM;
1944                         goto out;
1945                 }
1946         } else
1947                 phy = phy_info->phy;
1948
1949         mptsas_parse_device_info(&phy->identify, &phy_info->identify);
1950
1951         /*
1952          * Set Negotiated link rate.
1953          */
1954         switch (phy_info->negotiated_link_rate) {
1955         case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
1956                 phy->negotiated_linkrate = SAS_PHY_DISABLED;
1957                 break;
1958         case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
1959                 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
1960                 break;
1961         case MPI_SAS_IOUNIT0_RATE_1_5:
1962                 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
1963                 break;
1964         case MPI_SAS_IOUNIT0_RATE_3_0:
1965                 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
1966                 break;
1967         case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
1968         case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
1969         default:
1970                 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
1971                 break;
1972         }
1973
1974         /*
1975          * Set Max hardware link rate.
1976          */
1977         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1978         case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
1979                 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1980                 break;
1981         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1982                 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1983                 break;
1984         default:
1985                 break;
1986         }
1987
1988         /*
1989          * Set Max programmed link rate.
1990          */
1991         switch (phy_info->programmed_link_rate &
1992                         MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1993         case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
1994                 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1995                 break;
1996         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1997                 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1998                 break;
1999         default:
2000                 break;
2001         }
2002
2003         /*
2004          * Set Min hardware link rate.
2005          */
2006         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
2007         case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
2008                 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
2009                 break;
2010         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
2011                 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
2012                 break;
2013         default:
2014                 break;
2015         }
2016
2017         /*
2018          * Set Min programmed link rate.
2019          */
2020         switch (phy_info->programmed_link_rate &
2021                         MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
2022         case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
2023                 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
2024                 break;
2025         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
2026                 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
2027                 break;
2028         default:
2029                 break;
2030         }
2031
2032         if (!phy_info->phy) {
2033
2034                 error = sas_phy_add(phy);
2035                 if (error) {
2036                         sas_phy_free(phy);
2037                         goto out;
2038                 }
2039                 phy_info->phy = phy;
2040         }
2041
2042         if (!phy_info->attached.handle ||
2043                         !phy_info->port_details)
2044                 goto out;
2045
2046         port = mptsas_get_port(phy_info);
2047         ioc = phy_to_ioc(phy_info->phy);
2048
2049         if (phy_info->sas_port_add_phy) {
2050
2051                 if (!port) {
2052                         port = sas_port_alloc_num(dev);
2053                         if (!port) {
2054                                 error = -ENOMEM;
2055                                 goto out;
2056                         }
2057                         error = sas_port_add(port);
2058                         if (error) {
2059                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2060                                         "%s: exit at line=%d\n", ioc->name,
2061                                         __FUNCTION__, __LINE__));
2062                                 goto out;
2063                         }
2064                         mptsas_set_port(ioc, phy_info, port);
2065                         dsaswideprintk(ioc, printk(KERN_DEBUG
2066                             "sas_port_alloc: port=%p dev=%p port_id=%d\n",
2067                             port, dev, port->port_identifier));
2068                 }
2069                 dsaswideprintk(ioc, printk(KERN_DEBUG "sas_port_add_phy: phy_id=%d\n",
2070                     phy_info->phy_id));
2071                 sas_port_add_phy(port, phy_info->phy);
2072                 phy_info->sas_port_add_phy = 0;
2073         }
2074
2075         if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
2076
2077                 struct sas_rphy *rphy;
2078                 struct device *parent;
2079                 struct sas_identify identify;
2080
2081                 parent = dev->parent->parent;
2082                 /*
2083                  * Let the hotplug_work thread handle processing
2084                  * the adding/removing of devices that occur
2085                  * after start of day.
2086                  */
2087                 if (ioc->sas_discovery_runtime &&
2088                         mptsas_is_end_device(&phy_info->attached))
2089                                 goto out;
2090
2091                 mptsas_parse_device_info(&identify, &phy_info->attached);
2092                 if (scsi_is_host_device(parent)) {
2093                         struct mptsas_portinfo *port_info;
2094                         int i;
2095
2096                         mutex_lock(&ioc->sas_topology_mutex);
2097                         port_info = mptsas_find_portinfo_by_handle(ioc,
2098                                                                    ioc->handle);
2099                         mutex_unlock(&ioc->sas_topology_mutex);
2100
2101                         for (i = 0; i < port_info->num_phys; i++)
2102                                 if (port_info->phy_info[i].identify.sas_address ==
2103                                     identify.sas_address) {
2104                                         sas_port_mark_backlink(port);
2105                                         goto out;
2106                                 }
2107
2108                 } else if (scsi_is_sas_rphy(parent)) {
2109                         struct sas_rphy *parent_rphy = dev_to_rphy(parent);
2110                         if (identify.sas_address ==
2111                             parent_rphy->identify.sas_address) {
2112                                 sas_port_mark_backlink(port);
2113                                 goto out;
2114                         }
2115                 }
2116
2117                 switch (identify.device_type) {
2118                 case SAS_END_DEVICE:
2119                         rphy = sas_end_device_alloc(port);
2120                         break;
2121                 case SAS_EDGE_EXPANDER_DEVICE:
2122                 case SAS_FANOUT_EXPANDER_DEVICE:
2123                         rphy = sas_expander_alloc(port, identify.device_type);
2124                         break;
2125                 default:
2126                         rphy = NULL;
2127                         break;
2128                 }
2129                 if (!rphy) {
2130                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2131                                 "%s: exit at line=%d\n", ioc->name,
2132                                 __FUNCTION__, __LINE__));
2133                         goto out;
2134                 }
2135
2136                 rphy->identify = identify;
2137                 error = sas_rphy_add(rphy);
2138                 if (error) {
2139                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2140                                 "%s: exit at line=%d\n", ioc->name,
2141                                 __FUNCTION__, __LINE__));
2142                         sas_rphy_free(rphy);
2143                         goto out;
2144                 }
2145                 mptsas_set_rphy(ioc, phy_info, rphy);
2146         }
2147
2148  out:
2149         return error;
2150 }
2151
2152 static int
2153 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
2154 {
2155         struct mptsas_portinfo *port_info, *hba;
2156         int error = -ENOMEM, i;
2157
2158         hba = kzalloc(sizeof(*port_info), GFP_KERNEL);
2159         if (! hba)
2160                 goto out;
2161
2162         error = mptsas_sas_io_unit_pg0(ioc, hba);
2163         if (error)
2164                 goto out_free_port_info;
2165
2166         mptsas_sas_io_unit_pg1(ioc);
2167         mutex_lock(&ioc->sas_topology_mutex);
2168         ioc->handle = hba->phy_info[0].handle;
2169         port_info = mptsas_find_portinfo_by_handle(ioc, ioc->handle);
2170         if (!port_info) {
2171                 port_info = hba;
2172                 list_add_tail(&port_info->list, &ioc->sas_topology);
2173         } else {
2174                 for (i = 0; i < hba->num_phys; i++) {
2175                         port_info->phy_info[i].negotiated_link_rate =
2176                                 hba->phy_info[i].negotiated_link_rate;
2177                         port_info->phy_info[i].handle =
2178                                 hba->phy_info[i].handle;
2179                         port_info->phy_info[i].port_id =
2180                                 hba->phy_info[i].port_id;
2181                 }
2182                 kfree(hba->phy_info);
2183                 kfree(hba);
2184                 hba = NULL;
2185         }
2186         mutex_unlock(&ioc->sas_topology_mutex);
2187         for (i = 0; i < port_info->num_phys; i++) {
2188                 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
2189                         (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
2190                          MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
2191
2192                 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
2193                         (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2194                          MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2195                          port_info->phy_info[i].handle);
2196                 port_info->phy_info[i].identify.phy_id =
2197                     port_info->phy_info[i].phy_id = i;
2198                 if (port_info->phy_info[i].attached.handle)
2199                         mptsas_sas_device_pg0(ioc,
2200                                 &port_info->phy_info[i].attached,
2201                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2202                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2203                                 port_info->phy_info[i].attached.handle);
2204         }
2205
2206         mptsas_setup_wide_ports(ioc, port_info);
2207
2208         for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
2209                 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
2210                     &port_info->phy_info[i], ioc->sas_index, 1);
2211
2212         return 0;
2213
2214  out_free_port_info:
2215         kfree(hba);
2216  out:
2217         return error;
2218 }
2219
2220 static int
2221 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)
2222 {
2223         struct mptsas_portinfo *port_info, *p, *ex;
2224         struct device *parent;
2225         struct sas_rphy *rphy;
2226         int error = -ENOMEM, i, j;
2227
2228         ex = kzalloc(sizeof(*port_info), GFP_KERNEL);
2229         if (!ex)
2230                 goto out;
2231
2232         error = mptsas_sas_expander_pg0(ioc, ex,
2233             (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
2234              MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
2235         if (error)
2236                 goto out_free_port_info;
2237
2238         *handle = ex->phy_info[0].handle;
2239
2240         mutex_lock(&ioc->sas_topology_mutex);
2241         port_info = mptsas_find_portinfo_by_handle(ioc, *handle);
2242         if (!port_info) {
2243                 port_info = ex;
2244                 list_add_tail(&port_info->list, &ioc->sas_topology);
2245         } else {
2246                 for (i = 0; i < ex->num_phys; i++) {
2247                         port_info->phy_info[i].handle =
2248                                 ex->phy_info[i].handle;
2249                         port_info->phy_info[i].port_id =
2250                                 ex->phy_info[i].port_id;
2251                 }
2252                 kfree(ex->phy_info);
2253                 kfree(ex);
2254                 ex = NULL;
2255         }
2256         mutex_unlock(&ioc->sas_topology_mutex);
2257
2258         for (i = 0; i < port_info->num_phys; i++) {
2259                 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
2260                         (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
2261                          MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
2262
2263                 if (port_info->phy_info[i].identify.handle) {
2264                         mptsas_sas_device_pg0(ioc,
2265                                 &port_info->phy_info[i].identify,
2266                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2267                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2268                                 port_info->phy_info[i].identify.handle);
2269                         port_info->phy_info[i].identify.phy_id =
2270                             port_info->phy_info[i].phy_id;
2271                 }
2272
2273                 if (port_info->phy_info[i].attached.handle) {
2274                         mptsas_sas_device_pg0(ioc,
2275                                 &port_info->phy_info[i].attached,
2276                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2277                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2278                                 port_info->phy_info[i].attached.handle);
2279                         port_info->phy_info[i].attached.phy_id =
2280                             port_info->phy_info[i].phy_id;
2281                 }
2282         }
2283
2284         parent = &ioc->sh->shost_gendev;
2285         for (i = 0; i < port_info->num_phys; i++) {
2286                 mutex_lock(&ioc->sas_topology_mutex);
2287                 list_for_each_entry(p, &ioc->sas_topology, list) {
2288                         for (j = 0; j < p->num_phys; j++) {
2289                                 if (port_info->phy_info[i].identify.handle !=
2290                                                 p->phy_info[j].attached.handle)
2291                                         continue;
2292                                 rphy = mptsas_get_rphy(&p->phy_info[j]);
2293                                 parent = &rphy->dev;
2294                         }
2295                 }
2296                 mutex_unlock(&ioc->sas_topology_mutex);
2297         }
2298
2299         mptsas_setup_wide_ports(ioc, port_info);
2300
2301         for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
2302                 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
2303                     ioc->sas_index, 0);
2304
2305         return 0;
2306
2307  out_free_port_info:
2308         if (ex) {
2309                 kfree(ex->phy_info);
2310                 kfree(ex);
2311         }
2312  out:
2313         return error;
2314 }
2315
2316 /*
2317  * mptsas_delete_expander_phys
2318  *
2319  *
2320  * This will traverse topology, and remove expanders
2321  * that are no longer present
2322  */
2323 static void
2324 mptsas_delete_expander_phys(MPT_ADAPTER *ioc)
2325 {
2326         struct mptsas_portinfo buffer;
2327         struct mptsas_portinfo *port_info, *n, *parent;
2328         struct mptsas_phyinfo *phy_info;
2329         struct sas_port * port;
2330         int i;
2331         u64     expander_sas_address;
2332
2333         mutex_lock(&ioc->sas_topology_mutex);
2334         list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {
2335
2336                 if (port_info->phy_info &&
2337                     (!(port_info->phy_info[0].identify.device_info &
2338                     MPI_SAS_DEVICE_INFO_SMP_TARGET)))
2339                         continue;
2340
2341                 if (mptsas_sas_expander_pg0(ioc, &buffer,
2342                      (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
2343                      MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
2344                      port_info->phy_info[0].handle)) {
2345
2346                         /*
2347                          * Obtain the port_info instance to the parent port
2348                          */
2349                         parent = mptsas_find_portinfo_by_handle(ioc,
2350                             port_info->phy_info[0].identify.handle_parent);
2351
2352                         if (!parent)
2353                                 goto next_port;
2354
2355                         expander_sas_address =
2356                                 port_info->phy_info[0].identify.sas_address;
2357
2358                         /*
2359                          * Delete rphys in the parent that point
2360                          * to this expander.  The transport layer will
2361                          * cleanup all the children.
2362                          */
2363                         phy_info = parent->phy_info;
2364                         for (i = 0; i < parent->num_phys; i++, phy_info++) {
2365                                 port = mptsas_get_port(phy_info);
2366                                 if (!port)
2367                                         continue;
2368                                 if (phy_info->attached.sas_address !=
2369                                         expander_sas_address)
2370                                         continue;
2371                                 dsaswideprintk(ioc,
2372                                         dev_printk(KERN_DEBUG, &port->dev,
2373                                         "delete port (%d)\n", port->port_identifier));
2374                                 sas_port_delete(port);
2375                                 mptsas_port_delete(ioc, phy_info->port_details);
2376                         }
2377  next_port:
2378
2379                         phy_info = port_info->phy_info;
2380                         for (i = 0; i < port_info->num_phys; i++, phy_info++)
2381                                 mptsas_port_delete(ioc, phy_info->port_details);
2382
2383                         list_del(&port_info->list);
2384                         kfree(port_info->phy_info);
2385                         kfree(port_info);
2386                 }
2387                 /*
2388                 * Free this memory allocated from inside
2389                 * mptsas_sas_expander_pg0
2390                 */
2391                 kfree(buffer.phy_info);
2392         }
2393         mutex_unlock(&ioc->sas_topology_mutex);
2394 }
2395
2396 /*
2397  * Start of day discovery
2398  */
2399 static void
2400 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
2401 {
2402         u32 handle = 0xFFFF;
2403         int i;
2404
2405         mutex_lock(&ioc->sas_discovery_mutex);
2406         mptsas_probe_hba_phys(ioc);
2407         while (!mptsas_probe_expander_phys(ioc, &handle))
2408                 ;
2409         /*
2410           Reporting RAID volumes.
2411         */
2412         if (!ioc->ir_firmware)
2413                 goto out;
2414         if (!ioc->raid_data.pIocPg2)
2415                 goto out;
2416         if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
2417                 goto out;
2418         for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
2419                 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
2420                     ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
2421         }
2422  out:
2423         mutex_unlock(&ioc->sas_discovery_mutex);
2424 }
2425
2426 /*
2427  * Work queue thread to handle Runtime discovery
2428  * Mere purpose is the hot add/delete of expanders
2429  *(Mutex UNLOCKED)
2430  */
2431 static void
2432 __mptsas_discovery_work(MPT_ADAPTER *ioc)
2433 {
2434         u32 handle = 0xFFFF;
2435
2436         ioc->sas_discovery_runtime=1;
2437         mptsas_delete_expander_phys(ioc);
2438         mptsas_probe_hba_phys(ioc);
2439         while (!mptsas_probe_expander_phys(ioc, &handle))
2440                 ;
2441         ioc->sas_discovery_runtime=0;
2442 }
2443
2444 /*
2445  * Work queue thread to handle Runtime discovery
2446  * Mere purpose is the hot add/delete of expanders
2447  *(Mutex LOCKED)
2448  */
2449 static void
2450 mptsas_discovery_work(struct work_struct *work)
2451 {
2452         struct mptsas_discovery_event *ev =
2453                 container_of(work, struct mptsas_discovery_event, work);
2454         MPT_ADAPTER *ioc = ev->ioc;
2455
2456         mutex_lock(&ioc->sas_discovery_mutex);
2457         __mptsas_discovery_work(ioc);
2458         mutex_unlock(&ioc->sas_discovery_mutex);
2459         kfree(ev);
2460 }
2461
2462 static struct mptsas_phyinfo *
2463 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
2464 {
2465         struct mptsas_portinfo *port_info;
2466         struct mptsas_phyinfo *phy_info = NULL;
2467         int i;
2468
2469         mutex_lock(&ioc->sas_topology_mutex);
2470         list_for_each_entry(port_info, &ioc->sas_topology, list) {
2471                 for (i = 0; i < port_info->num_phys; i++) {
2472                         if (!mptsas_is_end_device(
2473                                 &port_info->phy_info[i].attached))
2474                                 continue;
2475                         if (port_info->phy_info[i].attached.sas_address
2476                             != sas_address)
2477                                 continue;
2478                         phy_info = &port_info->phy_info[i];
2479                         break;
2480                 }
2481         }
2482         mutex_unlock(&ioc->sas_topology_mutex);
2483         return phy_info;
2484 }
2485
2486 static struct mptsas_phyinfo *
2487 mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id)
2488 {
2489         struct mptsas_portinfo *port_info;
2490         struct mptsas_phyinfo *phy_info = NULL;
2491         int i;
2492
2493         mutex_lock(&ioc->sas_topology_mutex);
2494         list_for_each_entry(port_info, &ioc->sas_topology, list) {
2495                 for (i = 0; i < port_info->num_phys; i++) {
2496                         if (!mptsas_is_end_device(
2497                                 &port_info->phy_info[i].attached))
2498                                 continue;
2499                         if (port_info->phy_info[i].attached.id != id)
2500                                 continue;
2501                         if (port_info->phy_info[i].attached.channel != channel)
2502                                 continue;
2503                         phy_info = &port_info->phy_info[i];
2504                         break;
2505                 }
2506         }
2507         mutex_unlock(&ioc->sas_topology_mutex);
2508         return phy_info;
2509 }
2510
2511 static struct mptsas_phyinfo *
2512 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2513 {
2514         struct mptsas_portinfo *port_info;
2515         struct mptsas_phyinfo *phy_info = NULL;
2516         int i;
2517
2518         mutex_lock(&ioc->sas_topology_mutex);
2519         list_for_each_entry(port_info, &ioc->sas_topology, list) {
2520                 for (i = 0; i < port_info->num_phys; i++) {
2521                         if (!mptsas_is_end_device(
2522                                 &port_info->phy_info[i].attached))
2523                                 continue;
2524                         if (port_info->phy_info[i].attached.phys_disk_num == ~0)
2525                                 continue;
2526                         if (port_info->phy_info[i].attached.phys_disk_num != id)
2527                                 continue;
2528                         if (port_info->phy_info[i].attached.channel != channel)
2529                                 continue;
2530                         phy_info = &port_info->phy_info[i];
2531                         break;
2532                 }
2533         }
2534         mutex_unlock(&ioc->sas_topology_mutex);
2535         return phy_info;
2536 }
2537
2538 /*
2539  * Work queue thread to clear the persitency table
2540  */
2541 static void
2542 mptsas_persist_clear_table(struct work_struct *work)
2543 {
2544         MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task);
2545
2546         mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
2547 }
2548
2549 static void
2550 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
2551 {
2552         int rc;
2553
2554         sdev->no_uld_attach = data ? 1 : 0;
2555         rc = scsi_device_reprobe(sdev);
2556 }
2557
2558 static void
2559 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
2560 {
2561         starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
2562                         mptsas_reprobe_lun);
2563 }
2564
2565 static void
2566 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
2567 {
2568         CONFIGPARMS                     cfg;
2569         ConfigPageHeader_t              hdr;
2570         dma_addr_t                      dma_handle;
2571         pRaidVolumePage0_t              buffer = NULL;
2572         RaidPhysDiskPage0_t             phys_disk;
2573         int                             i;
2574         struct mptsas_hotplug_event     *ev;
2575
2576         memset(&cfg, 0 , sizeof(CONFIGPARMS));
2577         memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
2578         hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
2579         cfg.pageAddr = (channel << 8) + id;
2580         cfg.cfghdr.hdr = &hdr;
2581         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2582
2583         if (mpt_config(ioc, &cfg) != 0)
2584                 goto out;
2585
2586         if (!hdr.PageLength)
2587                 goto out;
2588
2589         buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
2590             &dma_handle);
2591
2592         if (!buffer)
2593                 goto out;
2594
2595         cfg.physAddr = dma_handle;
2596         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2597
2598         if (mpt_config(ioc, &cfg) != 0)
2599                 goto out;
2600
2601         if (!(buffer->VolumeStatus.Flags &
2602             MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
2603                 goto out;
2604
2605         if (!buffer->NumPhysDisks)
2606                 goto out;
2607
2608         for (i = 0; i < buffer->NumPhysDisks; i++) {
2609
2610                 if (mpt_raid_phys_disk_pg0(ioc,
2611                     buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
2612                         continue;
2613
2614                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2615                 if (!ev) {
2616                         printk(KERN_WARNING "mptsas: lost hotplug event\n");
2617                         goto out;
2618                 }
2619
2620                 INIT_WORK(&ev->work, mptsas_hotplug_work);
2621                 ev->ioc = ioc;
2622                 ev->id = phys_disk.PhysDiskID;
2623                 ev->channel = phys_disk.PhysDiskBus;
2624                 ev->phys_disk_num_valid = 1;
2625                 ev->phys_disk_num = phys_disk.PhysDiskNum;
2626                 ev->event_type = MPTSAS_ADD_DEVICE;
2627                 schedule_work(&ev->work);
2628         }
2629
2630  out:
2631         if (buffer)
2632                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
2633                     dma_handle);
2634 }
2635 /*
2636  * Work queue thread to handle SAS hotplug events
2637  */
2638 static void
2639 mptsas_hotplug_work(struct work_struct *work)
2640 {
2641         struct mptsas_hotplug_event *ev =
2642                 container_of(work, struct mptsas_hotplug_event, work);
2643
2644         MPT_ADAPTER *ioc = ev->ioc;
2645         struct mptsas_phyinfo *phy_info;
2646         struct sas_rphy *rphy;
2647         struct sas_port *port;
2648         struct scsi_device *sdev;
2649         struct scsi_target * starget;
2650         struct sas_identify identify;
2651         char *ds = NULL;
2652         struct mptsas_devinfo sas_device;
2653         VirtTarget *vtarget;
2654         VirtDevice *vdevice;
2655
2656         mutex_lock(&ioc->sas_discovery_mutex);
2657         switch (ev->event_type) {
2658         case MPTSAS_DEL_DEVICE:
2659
2660                 phy_info = NULL;
2661                 if (ev->phys_disk_num_valid) {
2662                         if (ev->hidden_raid_component){
2663                                 if (mptsas_sas_device_pg0(ioc, &sas_device,
2664                                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2665                                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2666                                     (ev->channel << 8) + ev->id)) {
2667                                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2668                                         "%s: exit at line=%d\n", ioc->name,
2669                                                 __FUNCTION__, __LINE__));
2670                                         break;
2671                                 }
2672                                 phy_info = mptsas_find_phyinfo_by_sas_address(
2673                                     ioc, sas_device.sas_address);
2674                         }else
2675                                 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
2676                                     ioc, ev->channel, ev->phys_disk_num);
2677                 }
2678
2679                 if (!phy_info)
2680                         phy_info = mptsas_find_phyinfo_by_target(ioc,
2681                             ev->channel, ev->id);
2682
2683                 /*
2684                  * Sanity checks, for non-existing phys and remote rphys.
2685                  */
2686                 if (!phy_info){
2687                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2688                                 "%s: exit at line=%d\n", ioc->name,
2689                                 __FUNCTION__, __LINE__));
2690                         break;
2691                 }
2692                 if (!phy_info->port_details) {
2693                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2694                                 "%s: exit at line=%d\n", ioc->name,
2695                                 __FUNCTION__, __LINE__));
2696                         break;
2697                 }
2698                 rphy = mptsas_get_rphy(phy_info);
2699                 if (!rphy) {
2700                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2701                                 "%s: exit at line=%d\n", ioc->name,
2702                                 __FUNCTION__, __LINE__));
2703                         break;
2704                 }
2705
2706                 port = mptsas_get_port(phy_info);
2707                 if (!port) {
2708                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2709                                 "%s: exit at line=%d\n", ioc->name,
2710                                 __FUNCTION__, __LINE__));
2711                         break;
2712                 }
2713
2714                 starget = mptsas_get_starget(phy_info);
2715                 if (starget) {
2716                         vtarget = starget->hostdata;
2717
2718                         if (!vtarget) {
2719                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2720                                         "%s: exit at line=%d\n", ioc->name,
2721                                         __FUNCTION__, __LINE__));
2722                                 break;
2723                         }
2724
2725                         /*
2726                          * Handling  RAID components
2727                          */
2728                         if (ev->phys_disk_num_valid &&
2729                             ev->hidden_raid_component) {
2730                                 printk(MYIOC_s_INFO_FMT
2731                                     "RAID Hidding: channel=%d, id=%d, "
2732                                     "physdsk %d \n", ioc->name, ev->channel,
2733                                     ev->id, ev->phys_disk_num);
2734                                 vtarget->id = ev->phys_disk_num;
2735                                 vtarget->tflags |=
2736                                     MPT_TARGET_FLAGS_RAID_COMPONENT;
2737                                 mptsas_reprobe_target(starget, 1);
2738                                 phy_info->attached.phys_disk_num =
2739                                     ev->phys_disk_num;
2740                         break;
2741                         }
2742                 }
2743
2744                 if (phy_info->attached.device_info &
2745                     MPI_SAS_DEVICE_INFO_SSP_TARGET)
2746                         ds = "ssp";
2747                 if (phy_info->attached.device_info &
2748                     MPI_SAS_DEVICE_INFO_STP_TARGET)
2749                         ds = "stp";
2750                 if (phy_info->attached.device_info &
2751                     MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2752                         ds = "sata";
2753
2754                 printk(MYIOC_s_INFO_FMT
2755                        "removing %s device, channel %d, id %d, phy %d\n",
2756                        ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
2757                 dev_printk(KERN_DEBUG, &port->dev,
2758                     "delete port (%d)\n", port->port_identifier);
2759                 sas_port_delete(port);
2760                 mptsas_port_delete(ioc, phy_info->port_details);
2761                 break;
2762         case MPTSAS_ADD_DEVICE:
2763
2764                 if (ev->phys_disk_num_valid)
2765                         mpt_findImVolumes(ioc);
2766
2767                 /*
2768                  * Refresh sas device pg0 data
2769                  */
2770                 if (mptsas_sas_device_pg0(ioc, &sas_device,
2771                     (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2772                      MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2773                         (ev->channel << 8) + ev->id)) {
2774                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2775                                         "%s: exit at line=%d\n", ioc->name,
2776                                         __FUNCTION__, __LINE__));
2777                         break;
2778                 }
2779
2780                 __mptsas_discovery_work(ioc);
2781
2782                 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
2783                                 sas_device.sas_address);
2784
2785                 if (!phy_info || !phy_info->port_details) {
2786                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2787                                 "%s: exit at line=%d\n", ioc->name,
2788                                 __FUNCTION__, __LINE__));
2789                         break;
2790                 }
2791
2792                 starget = mptsas_get_starget(phy_info);
2793                 if (starget && (!ev->hidden_raid_component)){
2794
2795                         vtarget = starget->hostdata;
2796
2797                         if (!vtarget) {
2798                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2799                                         "%s: exit at line=%d\n", ioc->name,
2800                                         __FUNCTION__, __LINE__));
2801                                 break;
2802                         }
2803                         /*
2804                          * Handling  RAID components
2805                          */
2806                         if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
2807                                 printk(MYIOC_s_INFO_FMT
2808                                     "RAID Exposing: channel=%d, id=%d, "
2809                                     "physdsk %d \n", ioc->name, ev->channel,
2810                                     ev->id, ev->phys_disk_num);
2811                                 vtarget->tflags &=
2812                                     ~MPT_TARGET_FLAGS_RAID_COMPONENT;
2813                                 vtarget->id = ev->id;
2814                                 mptsas_reprobe_target(starget, 0);
2815                                 phy_info->attached.phys_disk_num = ~0;
2816                         }
2817                         break;
2818                 }
2819
2820                 if (mptsas_get_rphy(phy_info)) {
2821                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2822                                 "%s: exit at line=%d\n", ioc->name,
2823                                 __FUNCTION__, __LINE__));
2824                         if (ev->channel) printk("%d\n", __LINE__);
2825                         break;
2826                 }
2827
2828                 port = mptsas_get_port(phy_info);
2829                 if (!port) {
2830                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2831                                 "%s: exit at line=%d\n", ioc->name,
2832                                 __FUNCTION__, __LINE__));
2833                         break;
2834                 }
2835                 memcpy(&phy_info->attached, &sas_device,
2836                     sizeof(struct mptsas_devinfo));
2837
2838                 if (phy_info->attached.device_info &
2839                     MPI_SAS_DEVICE_INFO_SSP_TARGET)
2840                         ds = "ssp";
2841                 if (phy_info->attached.device_info &
2842                     MPI_SAS_DEVICE_INFO_STP_TARGET)
2843                         ds = "stp";
2844                 if (phy_info->attached.device_info &
2845                     MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2846                         ds = "sata";
2847
2848                 printk(MYIOC_s_INFO_FMT
2849                        "attaching %s device, channel %d, id %d, phy %d\n",
2850                        ioc->name, ds, ev->channel, ev->id, ev->phy_id);
2851
2852                 mptsas_parse_device_info(&identify, &phy_info->attached);
2853                 rphy = sas_end_device_alloc(port);
2854                 if (!rphy) {
2855                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2856                                 "%s: exit at line=%d\n", ioc->name,
2857                                 __FUNCTION__, __LINE__));
2858                         break; /* non-fatal: an rphy can be added later */
2859                 }
2860
2861                 rphy->identify = identify;
2862                 if (sas_rphy_add(rphy)) {
2863                         dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2864                                 "%s: exit at line=%d\n", ioc->name,
2865                                 __FUNCTION__, __LINE__));
2866                         sas_rphy_free(rphy);
2867                         break;
2868                 }
2869                 mptsas_set_rphy(ioc, phy_info, rphy);
2870                 break;
2871         case MPTSAS_ADD_RAID:
2872                 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2873                     ev->id, 0);
2874                 if (sdev) {
2875                         scsi_device_put(sdev);
2876                         break;
2877                 }
2878                 printk(MYIOC_s_INFO_FMT
2879                        "attaching raid volume, channel %d, id %d\n",
2880                        ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2881                 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0);
2882                 mpt_findImVolumes(ioc);
2883                 break;
2884         case MPTSAS_DEL_RAID:
2885                 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2886                     ev->id, 0);
2887                 if (!sdev)
2888                         break;
2889                 printk(MYIOC_s_INFO_FMT
2890                        "removing raid volume, channel %d, id %d\n",
2891                        ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2892                 vdevice = sdev->hostdata;
2893                 scsi_remove_device(sdev);
2894                 scsi_device_put(sdev);
2895                 mpt_findImVolumes(ioc);
2896                 break;
2897         case MPTSAS_ADD_INACTIVE_VOLUME:
2898                 mptsas_adding_inactive_raid_components(ioc,
2899                     ev->channel, ev->id);
2900                 break;
2901         case MPTSAS_IGNORE_EVENT:
2902         default:
2903                 break;
2904         }
2905
2906         mutex_unlock(&ioc->sas_discovery_mutex);
2907         kfree(ev);
2908 }
2909
2910 static void
2911 mptsas_send_sas_event(MPT_ADAPTER *ioc,
2912                 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
2913 {
2914         struct mptsas_hotplug_event *ev;
2915         u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
2916         __le64 sas_address;
2917
2918         if ((device_info &
2919              (MPI_SAS_DEVICE_INFO_SSP_TARGET |
2920               MPI_SAS_DEVICE_INFO_STP_TARGET |
2921               MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
2922                 return;
2923
2924         switch (sas_event_data->ReasonCode) {
2925         case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
2926
2927                 mptsas_target_reset_queue(ioc, sas_event_data);
2928                 break;
2929
2930         case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
2931                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2932                 if (!ev) {
2933                         printk(KERN_WARNING "mptsas: lost hotplug event\n");
2934                         break;
2935                 }
2936
2937                 INIT_WORK(&ev->work, mptsas_hotplug_work);
2938                 ev->ioc = ioc;
2939                 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
2940                 ev->parent_handle =
2941                     le16_to_cpu(sas_event_data->ParentDevHandle);
2942                 ev->channel = sas_event_data->Bus;
2943                 ev->id = sas_event_data->TargetID;
2944                 ev->phy_id = sas_event_data->PhyNum;
2945                 memcpy(&sas_address, &sas_event_data->SASAddress,
2946                     sizeof(__le64));
2947                 ev->sas_address = le64_to_cpu(sas_address);
2948                 ev->device_info = device_info;
2949
2950                 if (sas_event_data->ReasonCode &
2951                     MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
2952                         ev->event_type = MPTSAS_ADD_DEVICE;
2953                 else
2954                         ev->event_type = MPTSAS_DEL_DEVICE;
2955                 schedule_work(&ev->work);
2956                 break;
2957         case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
2958         /*
2959          * Persistent table is full.
2960          */
2961                 INIT_WORK(&ioc->sas_persist_task,
2962                     mptsas_persist_clear_table);
2963                 schedule_work(&ioc->sas_persist_task);
2964                 break;
2965         /*
2966          * TODO, handle other events
2967          */
2968         case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
2969         case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
2970         case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
2971         case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
2972         case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
2973         case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
2974         case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
2975         default:
2976                 break;
2977         }
2978 }
2979 static void
2980 mptsas_send_raid_event(MPT_ADAPTER *ioc,
2981                 EVENT_DATA_RAID *raid_event_data)
2982 {
2983         struct mptsas_hotplug_event *ev;
2984         int status = le32_to_cpu(raid_event_data->SettingsStatus);
2985         int state = (status >> 8) & 0xff;
2986
2987         if (ioc->bus_type != SAS)
2988                 return;
2989
2990         ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2991         if (!ev) {
2992                 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2993                 return;
2994         }
2995
2996         INIT_WORK(&ev->work, mptsas_hotplug_work);
2997         ev->ioc = ioc;
2998         ev->id = raid_event_data->VolumeID;
2999         ev->channel = raid_event_data->VolumeBus;
3000         ev->event_type = MPTSAS_IGNORE_EVENT;
3001
3002         switch (raid_event_data->ReasonCode) {
3003         case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
3004                 ev->phys_disk_num_valid = 1;
3005                 ev->phys_disk_num = raid_event_data->PhysDiskNum;
3006                 ev->event_type = MPTSAS_ADD_DEVICE;
3007                 break;
3008         case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
3009                 ev->phys_disk_num_valid = 1;
3010                 ev->phys_disk_num = raid_event_data->PhysDiskNum;
3011                 ev->hidden_raid_component = 1;
3012                 ev->event_type = MPTSAS_DEL_DEVICE;
3013                 break;
3014         case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
3015                 switch (state) {
3016                 case MPI_PD_STATE_ONLINE:
3017                 case MPI_PD_STATE_NOT_COMPATIBLE:
3018                         ev->phys_disk_num_valid = 1;
3019                         ev->phys_disk_num = raid_event_data->PhysDiskNum;
3020                         ev->hidden_raid_component = 1;
3021                         ev->event_type = MPTSAS_ADD_DEVICE;
3022                         break;
3023                 case MPI_PD_STATE_MISSING:
3024                 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
3025                 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
3026                 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
3027                         ev->phys_disk_num_valid = 1;
3028                         ev->phys_disk_num = raid_event_data->PhysDiskNum;
3029                         ev->event_type = MPTSAS_DEL_DEVICE;
3030                         break;
3031                 default:
3032                         break;
3033                 }
3034                 break;
3035         case MPI_EVENT_RAID_RC_VOLUME_DELETED:
3036                 ev->event_type = MPTSAS_DEL_RAID;
3037                 break;
3038         case MPI_EVENT_RAID_RC_VOLUME_CREATED:
3039                 ev->event_type = MPTSAS_ADD_RAID;
3040                 break;
3041         case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
3042                 switch (state) {
3043                 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
3044                 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
3045                         ev->event_type = MPTSAS_DEL_RAID;
3046                         break;
3047                 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
3048                 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
3049                         ev->event_type = MPTSAS_ADD_RAID;
3050                         break;
3051                 default:
3052                         break;
3053                 }
3054                 break;
3055         default:
3056                 break;
3057         }
3058         schedule_work(&ev->work);
3059 }
3060
3061 static void
3062 mptsas_send_discovery_event(MPT_ADAPTER *ioc,
3063         EVENT_DATA_SAS_DISCOVERY *discovery_data)
3064 {
3065         struct mptsas_discovery_event *ev;
3066
3067         /*
3068          * DiscoveryStatus
3069          *
3070          * This flag will be non-zero when firmware
3071          * kicks off discovery, and return to zero
3072          * once its completed.
3073          */
3074         if (discovery_data->DiscoveryStatus)
3075                 return;
3076
3077         ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
3078         if (!ev)
3079                 return;
3080         INIT_WORK(&ev->work, mptsas_discovery_work);
3081         ev->ioc = ioc;
3082         schedule_work(&ev->work);
3083 };
3084
3085 /*
3086  * mptsas_send_ir2_event - handle exposing hidden disk when
3087  * an inactive raid volume is added
3088  *
3089  * @ioc: Pointer to MPT_ADAPTER structure
3090  * @ir2_data
3091  *
3092  */
3093 static void
3094 mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data)
3095 {
3096         struct mptsas_hotplug_event *ev;
3097
3098         if (ir2_data->ReasonCode !=
3099             MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED)
3100                 return;
3101
3102         ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
3103         if (!ev)
3104                 return;
3105
3106         INIT_WORK(&ev->work, mptsas_hotplug_work);
3107         ev->ioc = ioc;
3108         ev->id = ir2_data->TargetID;
3109         ev->channel = ir2_data->Bus;
3110         ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME;
3111
3112         schedule_work(&ev->work);
3113 };
3114
3115 static int
3116 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
3117 {
3118         int rc=1;
3119         u8 event = le32_to_cpu(reply->Event) & 0xFF;
3120
3121         if (!ioc->sh)
3122                 goto out;
3123
3124         /*
3125          * sas_discovery_ignore_events
3126          *
3127          * This flag is to prevent anymore processing of
3128          * sas events once mptsas_remove function is called.
3129          */
3130         if (ioc->sas_discovery_ignore_events) {
3131                 rc = mptscsih_event_process(ioc, reply);
3132                 goto out;
3133         }
3134
3135         switch (event) {
3136         case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
3137                 mptsas_send_sas_event(ioc,
3138                         (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
3139                 break;
3140         case MPI_EVENT_INTEGRATED_RAID:
3141                 mptsas_send_raid_event(ioc,
3142                         (EVENT_DATA_RAID *)reply->Data);
3143                 break;
3144         case MPI_EVENT_PERSISTENT_TABLE_FULL:
3145                 INIT_WORK(&ioc->sas_persist_task,
3146                     mptsas_persist_clear_table);
3147                 schedule_work(&ioc->sas_persist_task);
3148                 break;
3149          case MPI_EVENT_SAS_DISCOVERY:
3150                 mptsas_send_discovery_event(ioc,
3151                         (EVENT_DATA_SAS_DISCOVERY *)reply->Data);
3152                 break;
3153         case MPI_EVENT_IR2:
3154                 mptsas_send_ir2_event(ioc,
3155                     (PTR_MPI_EVENT_DATA_IR2)reply->Data);
3156                 break;
3157         default:
3158                 rc = mptscsih_event_process(ioc, reply);
3159                 break;
3160         }
3161  out:
3162
3163         return rc;
3164 }
3165
3166 static int
3167 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
3168 {
3169         struct Scsi_Host        *sh;
3170         MPT_SCSI_HOST           *hd;
3171         MPT_ADAPTER             *ioc;
3172         unsigned long            flags;
3173         int                      ii;
3174         int                      numSGE = 0;
3175         int                      scale;
3176         int                      ioc_cap;
3177         int                     error=0;
3178         int                     r;
3179
3180         r = mpt_attach(pdev,id);
3181         if (r)
3182                 return r;
3183
3184         ioc = pci_get_drvdata(pdev);
3185         ioc->DoneCtx = mptsasDoneCtx;
3186         ioc->TaskCtx = mptsasTaskCtx;
3187         ioc->InternalCtx = mptsasInternalCtx;
3188
3189         /*  Added sanity check on readiness of the MPT adapter.
3190          */
3191         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
3192                 printk(MYIOC_s_WARN_FMT
3193                   "Skipping because it's not operational!\n",
3194                   ioc->name);
3195                 error = -ENODEV;
3196                 goto out_mptsas_probe;
3197         }
3198
3199         if (!ioc->active) {
3200                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
3201                   ioc->name);
3202                 error = -ENODEV;
3203                 goto out_mptsas_probe;
3204         }
3205
3206         /*  Sanity check - ensure at least 1 port is INITIATOR capable
3207          */
3208         ioc_cap = 0;
3209         for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
3210                 if (ioc->pfacts[ii].ProtocolFlags &
3211                                 MPI_PORTFACTS_PROTOCOL_INITIATOR)
3212                         ioc_cap++;
3213         }
3214
3215         if (!ioc_cap) {
3216                 printk(MYIOC_s_WARN_FMT
3217                         "Skipping ioc=%p because SCSI Initiator mode "
3218                         "is NOT enabled!\n", ioc->name, ioc);
3219                 return 0;
3220         }
3221
3222         sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
3223         if (!sh) {
3224                 printk(MYIOC_s_WARN_FMT
3225                         "Unable to register controller with SCSI subsystem\n",
3226                         ioc->name);
3227                 error = -1;
3228                 goto out_mptsas_probe;
3229         }
3230
3231         spin_lock_irqsave(&ioc->FreeQlock, flags);
3232
3233         /* Attach the SCSI Host to the IOC structure
3234          */
3235         ioc->sh = sh;
3236
3237         sh->io_port = 0;
3238         sh->n_io_port = 0;
3239         sh->irq = 0;
3240
3241         /* set 16 byte cdb's */
3242         sh->max_cmd_len = 16;
3243
3244         sh->max_id = ioc->pfacts[0].PortSCSIID;
3245         sh->max_lun = max_lun;
3246
3247         sh->transportt = mptsas_transport_template;
3248
3249         sh->this_id = ioc->pfacts[0].PortSCSIID;
3250
3251         /* Required entry.
3252          */
3253         sh->unique_id = ioc->id;
3254
3255         INIT_LIST_HEAD(&ioc->sas_topology);
3256         mutex_init(&ioc->sas_topology_mutex);
3257         mutex_init(&ioc->sas_discovery_mutex);
3258         mutex_init(&ioc->sas_mgmt.mutex);
3259         init_completion(&ioc->sas_mgmt.done);
3260
3261         /* Verify that we won't exceed the maximum
3262          * number of chain buffers
3263          * We can optimize:  ZZ = req_sz/sizeof(SGE)
3264          * For 32bit SGE's:
3265          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
3266          *               + (req_sz - 64)/sizeof(SGE)
3267          * A slightly different algorithm is required for
3268          * 64bit SGEs.
3269          */
3270         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
3271         if (sizeof(dma_addr_t) == sizeof(u64)) {
3272                 numSGE = (scale - 1) *
3273                   (ioc->facts.MaxChainDepth-1) + scale +
3274                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
3275                   sizeof(u32));
3276         } else {
3277                 numSGE = 1 + (scale - 1) *
3278                   (ioc->facts.MaxChainDepth-1) + scale +
3279                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
3280                   sizeof(u32));
3281         }
3282
3283         if (numSGE < sh->sg_tablesize) {
3284                 /* Reset this value */
3285                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3286                   "Resetting sg_tablesize to %d from %d\n",
3287                   ioc->name, numSGE, sh->sg_tablesize));
3288                 sh->sg_tablesize = numSGE;
3289         }
3290
3291         hd = (MPT_SCSI_HOST *) sh->hostdata;
3292         hd->ioc = ioc;
3293
3294         /* SCSI needs scsi_cmnd lookup table!
3295          * (with size equal to req_depth*PtrSz!)
3296          */
3297         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
3298         if (!hd->ScsiLookup) {
3299                 error = -ENOMEM;
3300                 goto out_mptsas_probe;
3301         }
3302
3303         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
3304                  ioc->name, hd->ScsiLookup));
3305
3306         /* Clear the TM flags
3307          */
3308         hd->tmPending = 0;
3309         hd->tmState = TM_STATE_NONE;
3310         hd->resetPending = 0;
3311         hd->abortSCpnt = NULL;
3312
3313         /* Clear the pointer used to store
3314          * single-threaded commands, i.e., those
3315          * issued during a bus scan, dv and
3316          * configuration pages.
3317          */
3318         hd->cmdPtr = NULL;
3319
3320         /* Initialize this SCSI Hosts' timers
3321          * To use, set the timer expires field
3322          * and add_timer
3323          */
3324         init_timer(&hd->timer);
3325         hd->timer.data = (unsigned long) hd;
3326         hd->timer.function = mptscsih_timer_expired;
3327
3328         ioc->sas_data.ptClear = mpt_pt_clear;
3329
3330         init_waitqueue_head(&hd->scandv_waitq);
3331         hd->scandv_wait_done = 0;
3332         hd->last_queue_full = 0;
3333         INIT_LIST_HEAD(&hd->target_reset_list);
3334         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
3335
3336         if (ioc->sas_data.ptClear==1) {
3337                 mptbase_sas_persist_operation(
3338                     ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
3339         }
3340
3341         error = scsi_add_host(sh, &ioc->pcidev->dev);
3342         if (error) {
3343                 dprintk(ioc, printk(KERN_ERR MYNAM
3344                   "scsi_add_host failed\n"));
3345                 goto out_mptsas_probe;
3346         }
3347
3348         mptsas_scan_sas_topology(ioc);
3349
3350         return 0;
3351
3352  out_mptsas_probe:
3353
3354         mptscsih_remove(pdev);
3355         return error;
3356 }
3357
3358 static void __devexit mptsas_remove(struct pci_dev *pdev)
3359 {
3360         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
3361         struct mptsas_portinfo *p, *n;
3362         int i;
3363
3364         ioc->sas_discovery_ignore_events = 1;
3365         sas_remove_host(ioc->sh);
3366
3367         mutex_lock(&ioc->sas_topology_mutex);
3368         list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
3369                 list_del(&p->list);
3370                 for (i = 0 ; i < p->num_phys ; i++)
3371                         mptsas_port_delete(ioc, p->phy_info[i].port_details);
3372                 kfree(p->phy_info);
3373                 kfree(p);
3374         }
3375         mutex_unlock(&ioc->sas_topology_mutex);
3376
3377         mptscsih_remove(pdev);
3378 }
3379
3380 static struct pci_device_id mptsas_pci_table[] = {
3381         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
3382                 PCI_ANY_ID, PCI_ANY_ID },
3383         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
3384                 PCI_ANY_ID, PCI_ANY_ID },
3385         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
3386                 PCI_ANY_ID, PCI_ANY_ID },
3387         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
3388                 PCI_ANY_ID, PCI_ANY_ID },
3389         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
3390                 PCI_ANY_ID, PCI_ANY_ID },
3391         {0}     /* Terminating entry */
3392 };
3393 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
3394
3395
3396 static struct pci_driver mptsas_driver = {
3397         .name           = "mptsas",
3398         .id_table       = mptsas_pci_table,
3399         .probe          = mptsas_probe,
3400         .remove         = __devexit_p(mptsas_remove),
3401         .shutdown       = mptscsih_shutdown,
3402 #ifdef CONFIG_PM
3403         .suspend        = mptscsih_suspend,
3404         .resume         = mptscsih_resume,
3405 #endif
3406 };
3407
3408 static int __init
3409 mptsas_init(void)
3410 {
3411         int error;
3412
3413         show_mptmod_ver(my_NAME, my_VERSION);
3414
3415         mptsas_transport_template =
3416             sas_attach_transport(&mptsas_transport_functions);
3417         if (!mptsas_transport_template)
3418                 return -ENODEV;
3419
3420         mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
3421         mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
3422         mptsasInternalCtx =
3423                 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
3424         mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
3425
3426         mpt_event_register(mptsasDoneCtx, mptsas_event_process);
3427         mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
3428
3429         error = pci_register_driver(&mptsas_driver);
3430         if (error)
3431                 sas_release_transport(mptsas_transport_template);
3432
3433         return error;
3434 }
3435
3436 static void __exit
3437 mptsas_exit(void)
3438 {
3439         pci_unregister_driver(&mptsas_driver);
3440         sas_release_transport(mptsas_transport_template);
3441
3442         mpt_reset_deregister(mptsasDoneCtx);
3443         mpt_event_deregister(mptsasDoneCtx);
3444
3445         mpt_deregister(mptsasMgmtCtx);
3446         mpt_deregister(mptsasInternalCtx);
3447         mpt_deregister(mptsasTaskCtx);
3448         mpt_deregister(mptsasDoneCtx);
3449 }
3450
3451 module_init(mptsas_init);
3452 module_exit(mptsas_exit);