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