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