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