drivers/message/fusion/mptsas.c

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