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