drivers/message/fusion/mptsas.c

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