err.no Git - linux-2.6/blob - drivers/message/fusion/mptsas.c

   1 /*
   2  *  linux/drivers/message/fusion/mptsas.c
   3  *      For use with LSI Logic PCI chip/adapter(s)
   4  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2005 LSI Logic Corporation
   7  *  (mailto:mpt_linux_developer@lsil.com)
   8  *  Copyright (c) 2005 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 /*
  90  * SAS topology structures
  91  *
  92  * The MPT Fusion firmware interface spreads information about the
  93  * SAS topology over many manufacture pages, thus we need some data
  94  * structure to collect it and process it for the SAS transport class.
  95  */
  96
  97 struct mptsas_devinfo {
  98         u16     handle;         /* unique id to address this device */
  99         u8      phy_id;         /* phy number of parent device */
 100         u8      port_id;        /* sas physical port this device
 101                                    is assoc'd with */
 102         u8      target;         /* logical target id of this device */
 103         u8      bus;            /* logical bus number of this device */
 104         u64     sas_address;    /* WWN of this device,
 105                                    SATA is assigned by HBA,expander */
 106         u32     device_info;    /* bitfield detailed info about this device */
 107 };
 108
 109 struct mptsas_phyinfo {
 110         u8      phy_id;                 /* phy index */
 111         u8      port_id;                /* port number this phy is part of */
 112         u8      negotiated_link_rate;   /* nego'd link rate for this phy */
 113         u8      hw_link_rate;           /* hardware max/min phys link rate */
 114         u8      programmed_link_rate;   /* programmed max/min phy link rate */
 115         struct mptsas_devinfo identify; /* point to phy device info */
 116         struct mptsas_devinfo attached; /* point to attached device info */
 117         struct sas_rphy *rphy;
 118 };
 119
 120 struct mptsas_portinfo {
 121         struct list_head list;
 122         u16             handle;         /* unique id to address this */
 123         u8              num_phys;       /* number of phys */
 124         struct mptsas_phyinfo *phy_info;
 125 };
 126
 127
 128 #ifdef SASDEBUG
 129 static void mptsas_print_phy_data(MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
 130 {
 131         printk("---- IO UNIT PAGE 0 ------------\n");
 132         printk("Handle=0x%X\n",
 133                 le16_to_cpu(phy_data->AttachedDeviceHandle));
 134         printk("Controller Handle=0x%X\n",
 135                 le16_to_cpu(phy_data->ControllerDevHandle));
 136         printk("Port=0x%X\n", phy_data->Port);
 137         printk("Port Flags=0x%X\n", phy_data->PortFlags);
 138         printk("PHY Flags=0x%X\n", phy_data->PhyFlags);
 139         printk("Negotiated Link Rate=0x%X\n", phy_data->NegotiatedLinkRate);
 140         printk("Controller PHY Device Info=0x%X\n",
 141                 le32_to_cpu(phy_data->ControllerPhyDeviceInfo));
 142         printk("DiscoveryStatus=0x%X\n",
 143                 le32_to_cpu(phy_data->DiscoveryStatus));
 144         printk("\n");
 145 }
 146
 147 static void mptsas_print_phy_pg0(SasPhyPage0_t *pg0)
 148 {
 149         __le64 sas_address;
 150
 151         memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
 152
 153         printk("---- SAS PHY PAGE 0 ------------\n");
 154         printk("Attached Device Handle=0x%X\n",
 155                         le16_to_cpu(pg0->AttachedDevHandle));
 156         printk("SAS Address=0x%llX\n",
 157                         (unsigned long long)le64_to_cpu(sas_address));
 158         printk("Attached PHY Identifier=0x%X\n", pg0->AttachedPhyIdentifier);
 159         printk("Attached Device Info=0x%X\n",
 160                         le32_to_cpu(pg0->AttachedDeviceInfo));
 161         printk("Programmed Link Rate=0x%X\n", pg0->ProgrammedLinkRate);
 162         printk("Change Count=0x%X\n", pg0->ChangeCount);
 163         printk("PHY Info=0x%X\n", le32_to_cpu(pg0->PhyInfo));
 164         printk("\n");
 165 }
 166
 167 static void mptsas_print_phy_pg1(SasPhyPage1_t *pg1)
 168 {
 169         printk("---- SAS PHY PAGE 1 ------------\n");
 170         printk("Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount);
 171         printk("Running Disparity Error Count=0x%x\n",
 172                         pg1->RunningDisparityErrorCount);
 173         printk("Loss Dword Synch Count=0x%x\n", pg1->LossDwordSynchCount);
 174         printk("PHY Reset Problem Count=0x%x\n", pg1->PhyResetProblemCount);
 175         printk("\n");
 176 }
 177
 178 static void mptsas_print_device_pg0(SasDevicePage0_t *pg0)
 179 {
 180         __le64 sas_address;
 181
 182         memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
 183
 184         printk("---- SAS DEVICE PAGE 0 ---------\n");
 185         printk("Handle=0x%X\n" ,le16_to_cpu(pg0->DevHandle));
 186         printk("Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle));
 187         printk("Slot=0x%X\n", le16_to_cpu(pg0->Slot));
 188         printk("SAS Address=0x%llX\n", le64_to_cpu(sas_address));
 189         printk("Target ID=0x%X\n", pg0->TargetID);
 190         printk("Bus=0x%X\n", pg0->Bus);
 191         /* The PhyNum field specifies the PHY number of the parent
 192          * device this device is linked to
 193          */
 194         printk("Parent Phy Num=0x%X\n", pg0->PhyNum);
 195         printk("Access Status=0x%X\n", le16_to_cpu(pg0->AccessStatus));
 196         printk("Device Info=0x%X\n", le32_to_cpu(pg0->DeviceInfo));
 197         printk("Flags=0x%X\n", le16_to_cpu(pg0->Flags));
 198         printk("Physical Port=0x%X\n", pg0->PhysicalPort);
 199         printk("\n");
 200 }
 201
 202 static void mptsas_print_expander_pg1(SasExpanderPage1_t *pg1)
 203 {
 204         printk("---- SAS EXPANDER PAGE 1 ------------\n");
 205
 206         printk("Physical Port=0x%X\n", pg1->PhysicalPort);
 207         printk("PHY Identifier=0x%X\n", pg1->PhyIdentifier);
 208         printk("Negotiated Link Rate=0x%X\n", pg1->NegotiatedLinkRate);
 209         printk("Programmed Link Rate=0x%X\n", pg1->ProgrammedLinkRate);
 210         printk("Hardware Link Rate=0x%X\n", pg1->HwLinkRate);
 211         printk("Owner Device Handle=0x%X\n",
 212                         le16_to_cpu(pg1->OwnerDevHandle));
 213         printk("Attached Device Handle=0x%X\n",
 214                         le16_to_cpu(pg1->AttachedDevHandle));
 215 }
 216 #else
 217 #define mptsas_print_phy_data(phy_data)         do { } while (0)
 218 #define mptsas_print_phy_pg0(pg0)               do { } while (0)
 219 #define mptsas_print_phy_pg1(pg1)               do { } while (0)
 220 #define mptsas_print_device_pg0(pg0)            do { } while (0)
 221 #define mptsas_print_expander_pg1(pg1)          do { } while (0)
 222 #endif
 223
 224
 225 /*
 226  * This is pretty ugly.  We will be able to seriously clean it up
 227  * once the DV code in mptscsih goes away and we can properly
 228  * implement ->target_alloc.
 229  */
 230 static int
 231 mptsas_slave_alloc(struct scsi_device *sdev)
 232 {
 233         struct Scsi_Host        *host = sdev->host;
 234         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)host->hostdata;
 235         struct sas_rphy         *rphy;
 236         struct mptsas_portinfo  *p;
 237         VirtTarget              *vtarget;
 238         VirtDevice              *vdev;
 239         struct scsi_target      *starget;
 240         int i;
 241
 242         vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL);
 243         if (!vdev) {
 244                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 245                                 hd->ioc->name, sizeof(VirtDevice));
 246                 return -ENOMEM;
 247         }
 248         memset(vdev, 0, sizeof(VirtDevice));
 249         vdev->ioc_id = hd->ioc->id;
 250         sdev->hostdata = vdev;
 251         starget = scsi_target(sdev);
 252         vtarget = starget->hostdata;
 253         vdev->vtarget = vtarget;
 254         if (vtarget->num_luns == 0) {
 255                 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES|MPT_TARGET_FLAGS_VALID_INQUIRY;
 256                 hd->Targets[sdev->id] = vtarget;
 257         }
 258
 259         rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
 260         list_for_each_entry(p, &hd->ioc->sas_topology, list) {
 261                 for (i = 0; i < p->num_phys; i++) {
 262                         if (p->phy_info[i].attached.sas_address ==
 263                                         rphy->identify.sas_address) {
 264                                 vdev->target_id =
 265                                         p->phy_info[i].attached.target;
 266                                 vdev->bus_id = p->phy_info[i].attached.bus;
 267                                 vdev->lun = sdev->lun;
 268                                 goto out;
 269                         }
 270                 }
 271         }
 272
 273         printk("No matching SAS device found!!\n");
 274         kfree(vdev);
 275         return -ENODEV;
 276
 277  out:
 278         vtarget->ioc_id = vdev->ioc_id;
 279         vtarget->target_id = vdev->target_id;
 280         vtarget->bus_id = vdev->bus_id;
 281         vtarget->num_luns++;
 282         return 0;
 283 }
 284
 285 static struct scsi_host_template mptsas_driver_template = {
 286         .module                         = THIS_MODULE,
 287         .proc_name                      = "mptsas",
 288         .proc_info                      = mptscsih_proc_info,
 289         .name                           = "MPT SPI Host",
 290         .info                           = mptscsih_info,
 291         .queuecommand                   = mptscsih_qcmd,
 292         .target_alloc                   = mptscsih_target_alloc,
 293         .slave_alloc                    = mptsas_slave_alloc,
 294         .slave_configure                = mptscsih_slave_configure,
 295         .target_destroy                 = mptscsih_target_destroy,
 296         .slave_destroy                  = mptscsih_slave_destroy,
 297         .change_queue_depth             = mptscsih_change_queue_depth,
 298         .eh_abort_handler               = mptscsih_abort,
 299         .eh_device_reset_handler        = mptscsih_dev_reset,
 300         .eh_bus_reset_handler           = mptscsih_bus_reset,
 301         .eh_host_reset_handler          = mptscsih_host_reset,
 302         .bios_param                     = mptscsih_bios_param,
 303         .can_queue                      = MPT_FC_CAN_QUEUE,
 304         .this_id                        = -1,
 305         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 306         .max_sectors                    = 8192,
 307         .cmd_per_lun                    = 7,
 308         .use_clustering                 = ENABLE_CLUSTERING,
 309 };
 310
 311 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
 312 {
 313         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
 314         return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
 315 }
 316
 317 static int mptsas_get_linkerrors(struct sas_phy *phy)
 318 {
 319         MPT_ADAPTER *ioc = phy_to_ioc(phy);
 320         ConfigExtendedPageHeader_t hdr;
 321         CONFIGPARMS cfg;
 322         SasPhyPage1_t *buffer;
 323         dma_addr_t dma_handle;
 324         int error;
 325
 326         hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
 327         hdr.ExtPageLength = 0;
 328         hdr.PageNumber = 1 /* page number 1*/;
 329         hdr.Reserved1 = 0;
 330         hdr.Reserved2 = 0;
 331         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 332         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
 333
 334         cfg.cfghdr.ehdr = &hdr;
 335         cfg.physAddr = -1;
 336         cfg.pageAddr = phy->identify.phy_identifier;
 337         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 338         cfg.dir = 0;    /* read */
 339         cfg.timeout = 10;
 340
 341         error = mpt_config(ioc, &cfg);
 342         if (error)
 343                 return error;
 344         if (!hdr.ExtPageLength)
 345                 return -ENXIO;
 346
 347         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 348                                       &dma_handle);
 349         if (!buffer)
 350                 return -ENOMEM;
 351
 352         cfg.physAddr = dma_handle;
 353         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 354
 355         error = mpt_config(ioc, &cfg);
 356         if (error)
 357                 goto out_free_consistent;
 358
 359         mptsas_print_phy_pg1(buffer);
 360
 361         phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
 362         phy->running_disparity_error_count =
 363                 le32_to_cpu(buffer->RunningDisparityErrorCount);
 364         phy->loss_of_dword_sync_count =
 365                 le32_to_cpu(buffer->LossDwordSynchCount);
 366         phy->phy_reset_problem_count =
 367                 le32_to_cpu(buffer->PhyResetProblemCount);
 368
 369  out_free_consistent:
 370         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 371                             buffer, dma_handle);
 372         return error;
 373 }
 374
 375 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
 376                 MPT_FRAME_HDR *reply)
 377 {
 378         ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
 379         if (reply != NULL) {
 380                 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
 381                 memcpy(ioc->sas_mgmt.reply, reply,
 382                     min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
 383         }
 384         complete(&ioc->sas_mgmt.done);
 385         return 1;
 386 }
 387
 388 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
 389 {
 390         MPT_ADAPTER *ioc = phy_to_ioc(phy);
 391         SasIoUnitControlRequest_t *req;
 392         SasIoUnitControlReply_t *reply;
 393         MPT_FRAME_HDR *mf;
 394         MPIHeader_t *hdr;
 395         unsigned long timeleft;
 396         int error = -ERESTARTSYS;
 397
 398         /* not implemented for expanders */
 399         if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
 400                 return -ENXIO;
 401
 402         if (down_interruptible(&ioc->sas_mgmt.mutex))
 403                 goto out;
 404
 405         mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
 406         if (!mf) {
 407                 error = -ENOMEM;
 408                 goto out_unlock;
 409         }
 410
 411         hdr = (MPIHeader_t *) mf;
 412         req = (SasIoUnitControlRequest_t *)mf;
 413         memset(req, 0, sizeof(SasIoUnitControlRequest_t));
 414         req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
 415         req->MsgContext = hdr->MsgContext;
 416         req->Operation = hard_reset ?
 417                 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
 418         req->PhyNum = phy->identify.phy_identifier;
 419
 420         mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
 421
 422         timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
 423                         10 * HZ);
 424         if (!timeleft) {
 425                 /* On timeout reset the board */
 426                 mpt_free_msg_frame(ioc, mf);
 427                 mpt_HardResetHandler(ioc, CAN_SLEEP);
 428                 error = -ETIMEDOUT;
 429                 goto out_unlock;
 430         }
 431
 432         /* a reply frame is expected */
 433         if ((ioc->sas_mgmt.status &
 434             MPT_IOCTL_STATUS_RF_VALID) == 0) {
 435                 error = -ENXIO;
 436                 goto out_unlock;
 437         }
 438
 439         /* process the completed Reply Message Frame */
 440         reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
 441         if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
 442                 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
 443                     __FUNCTION__,
 444                     reply->IOCStatus,
 445                     reply->IOCLogInfo);
 446                 error = -ENXIO;
 447                 goto out_unlock;
 448         }
 449
 450         error = 0;
 451
 452  out_unlock:
 453         up(&ioc->sas_mgmt.mutex);
 454  out:
 455         return error;
 456 }
 457
 458 static struct sas_function_template mptsas_transport_functions = {
 459         .get_linkerrors         = mptsas_get_linkerrors,
 460         .phy_reset              = mptsas_phy_reset,
 461 };
 462
 463 static struct scsi_transport_template *mptsas_transport_template;
 464
 465 static int
 466 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
 467 {
 468         ConfigExtendedPageHeader_t hdr;
 469         CONFIGPARMS cfg;
 470         SasIOUnitPage0_t *buffer;
 471         dma_addr_t dma_handle;
 472         int error, i;
 473
 474         hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
 475         hdr.ExtPageLength = 0;
 476         hdr.PageNumber = 0;
 477         hdr.Reserved1 = 0;
 478         hdr.Reserved2 = 0;
 479         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 480         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
 481
 482         cfg.cfghdr.ehdr = &hdr;
 483         cfg.physAddr = -1;
 484         cfg.pageAddr = 0;
 485         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 486         cfg.dir = 0;    /* read */
 487         cfg.timeout = 10;
 488
 489         error = mpt_config(ioc, &cfg);
 490         if (error)
 491                 goto out;
 492         if (!hdr.ExtPageLength) {
 493                 error = -ENXIO;
 494                 goto out;
 495         }
 496
 497         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 498                                             &dma_handle);
 499         if (!buffer) {
 500                 error = -ENOMEM;
 501                 goto out;
 502         }
 503
 504         cfg.physAddr = dma_handle;
 505         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 506
 507         error = mpt_config(ioc, &cfg);
 508         if (error)
 509                 goto out_free_consistent;
 510
 511         port_info->num_phys = buffer->NumPhys;
 512         port_info->phy_info = kcalloc(port_info->num_phys,
 513                 sizeof(struct mptsas_phyinfo),GFP_KERNEL);
 514         if (!port_info->phy_info) {
 515                 error = -ENOMEM;
 516                 goto out_free_consistent;
 517         }
 518
 519         for (i = 0; i < port_info->num_phys; i++) {
 520                 mptsas_print_phy_data(&buffer->PhyData[i]);
 521                 port_info->phy_info[i].phy_id = i;
 522                 port_info->phy_info[i].port_id =
 523                     buffer->PhyData[i].Port;
 524                 port_info->phy_info[i].negotiated_link_rate =
 525                     buffer->PhyData[i].NegotiatedLinkRate;
 526         }
 527
 528  out_free_consistent:
 529         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 530                             buffer, dma_handle);
 531  out:
 532         return error;
 533 }
 534
 535 static int
 536 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
 537                 u32 form, u32 form_specific)
 538 {
 539         ConfigExtendedPageHeader_t hdr;
 540         CONFIGPARMS cfg;
 541         SasPhyPage0_t *buffer;
 542         dma_addr_t dma_handle;
 543         int error;
 544
 545         hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
 546         hdr.ExtPageLength = 0;
 547         hdr.PageNumber = 0;
 548         hdr.Reserved1 = 0;
 549         hdr.Reserved2 = 0;
 550         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 551         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
 552
 553         cfg.cfghdr.ehdr = &hdr;
 554         cfg.dir = 0;    /* read */
 555         cfg.timeout = 10;
 556
 557         /* Get Phy Pg 0 for each Phy. */
 558         cfg.physAddr = -1;
 559         cfg.pageAddr = form + form_specific;
 560         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 561
 562         error = mpt_config(ioc, &cfg);
 563         if (error)
 564                 goto out;
 565
 566         if (!hdr.ExtPageLength) {
 567                 error = -ENXIO;
 568                 goto out;
 569         }
 570
 571         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 572                                       &dma_handle);
 573         if (!buffer) {
 574                 error = -ENOMEM;
 575                 goto out;
 576         }
 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_pg0(buffer);
 586
 587         phy_info->hw_link_rate = buffer->HwLinkRate;
 588         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
 589         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
 590         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
 591
 592  out_free_consistent:
 593         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 594                             buffer, dma_handle);
 595  out:
 596         return error;
 597 }
 598
 599 static int
 600 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
 601                 u32 form, u32 form_specific)
 602 {
 603         ConfigExtendedPageHeader_t hdr;
 604         CONFIGPARMS cfg;
 605         SasDevicePage0_t *buffer;
 606         dma_addr_t dma_handle;
 607         __le64 sas_address;
 608         int error;
 609
 610         hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
 611         hdr.ExtPageLength = 0;
 612         hdr.PageNumber = 0;
 613         hdr.Reserved1 = 0;
 614         hdr.Reserved2 = 0;
 615         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 616         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
 617
 618         cfg.cfghdr.ehdr = &hdr;
 619         cfg.pageAddr = form + form_specific;
 620         cfg.physAddr = -1;
 621         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 622         cfg.dir = 0;    /* read */
 623         cfg.timeout = 10;
 624
 625         error = mpt_config(ioc, &cfg);
 626         if (error)
 627                 goto out;
 628         if (!hdr.ExtPageLength) {
 629                 error = -ENXIO;
 630                 goto out;
 631         }
 632
 633         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 634                                       &dma_handle);
 635         if (!buffer) {
 636                 error = -ENOMEM;
 637                 goto out;
 638         }
 639
 640         cfg.physAddr = dma_handle;
 641         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 642
 643         error = mpt_config(ioc, &cfg);
 644         if (error)
 645                 goto out_free_consistent;
 646
 647         mptsas_print_device_pg0(buffer);
 648
 649         device_info->handle = le16_to_cpu(buffer->DevHandle);
 650         device_info->phy_id = buffer->PhyNum;
 651         device_info->port_id = buffer->PhysicalPort;
 652         device_info->target = buffer->TargetID;
 653         device_info->bus = buffer->Bus;
 654         memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
 655         device_info->sas_address = le64_to_cpu(sas_address);
 656         device_info->device_info =
 657             le32_to_cpu(buffer->DeviceInfo);
 658
 659  out_free_consistent:
 660         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 661                             buffer, dma_handle);
 662  out:
 663         return error;
 664 }
 665
 666 static int
 667 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
 668                 u32 form, u32 form_specific)
 669 {
 670         ConfigExtendedPageHeader_t hdr;
 671         CONFIGPARMS cfg;
 672         SasExpanderPage0_t *buffer;
 673         dma_addr_t dma_handle;
 674         int error;
 675
 676         hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
 677         hdr.ExtPageLength = 0;
 678         hdr.PageNumber = 0;
 679         hdr.Reserved1 = 0;
 680         hdr.Reserved2 = 0;
 681         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 682         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
 683
 684         cfg.cfghdr.ehdr = &hdr;
 685         cfg.physAddr = -1;
 686         cfg.pageAddr = form + form_specific;
 687         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 688         cfg.dir = 0;    /* read */
 689         cfg.timeout = 10;
 690
 691         error = mpt_config(ioc, &cfg);
 692         if (error)
 693                 goto out;
 694
 695         if (!hdr.ExtPageLength) {
 696                 error = -ENXIO;
 697                 goto out;
 698         }
 699
 700         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 701                                       &dma_handle);
 702         if (!buffer) {
 703                 error = -ENOMEM;
 704                 goto out;
 705         }
 706
 707         cfg.physAddr = dma_handle;
 708         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 709
 710         error = mpt_config(ioc, &cfg);
 711         if (error)
 712                 goto out_free_consistent;
 713
 714         /* save config data */
 715         port_info->num_phys = buffer->NumPhys;
 716         port_info->handle = le16_to_cpu(buffer->DevHandle);
 717         port_info->phy_info = kcalloc(port_info->num_phys,
 718                 sizeof(struct mptsas_phyinfo),GFP_KERNEL);
 719         if (!port_info->phy_info) {
 720                 error = -ENOMEM;
 721                 goto out_free_consistent;
 722         }
 723
 724  out_free_consistent:
 725         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 726                             buffer, dma_handle);
 727  out:
 728         return error;
 729 }
 730
 731 static int
 732 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
 733                 u32 form, u32 form_specific)
 734 {
 735         ConfigExtendedPageHeader_t hdr;
 736         CONFIGPARMS cfg;
 737         SasExpanderPage1_t *buffer;
 738         dma_addr_t dma_handle;
 739         int error;
 740
 741         hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
 742         hdr.ExtPageLength = 0;
 743         hdr.PageNumber = 1;
 744         hdr.Reserved1 = 0;
 745         hdr.Reserved2 = 0;
 746         hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
 747         hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
 748
 749         cfg.cfghdr.ehdr = &hdr;
 750         cfg.physAddr = -1;
 751         cfg.pageAddr = form + form_specific;
 752         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 753         cfg.dir = 0;    /* read */
 754         cfg.timeout = 10;
 755
 756         error = mpt_config(ioc, &cfg);
 757         if (error)
 758                 goto out;
 759
 760         if (!hdr.ExtPageLength) {
 761                 error = -ENXIO;
 762                 goto out;
 763         }
 764
 765         buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 766                                       &dma_handle);
 767         if (!buffer) {
 768                 error = -ENOMEM;
 769                 goto out;
 770         }
 771
 772         cfg.physAddr = dma_handle;
 773         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 774
 775         error = mpt_config(ioc, &cfg);
 776         if (error)
 777                 goto out_free_consistent;
 778
 779
 780         mptsas_print_expander_pg1(buffer);
 781
 782         /* save config data */
 783         phy_info->phy_id = buffer->PhyIdentifier;
 784         phy_info->port_id = buffer->PhysicalPort;
 785         phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
 786         phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
 787         phy_info->hw_link_rate = buffer->HwLinkRate;
 788         phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
 789         phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
 790
 791
 792  out_free_consistent:
 793         pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
 794                             buffer, dma_handle);
 795  out:
 796         return error;
 797 }
 798
 799 static void
 800 mptsas_parse_device_info(struct sas_identify *identify,
 801                 struct mptsas_devinfo *device_info)
 802 {
 803         u16 protocols;
 804
 805         identify->sas_address = device_info->sas_address;
 806         identify->phy_identifier = device_info->phy_id;
 807
 808         /*
 809          * Fill in Phy Initiator Port Protocol.
 810          * Bits 6:3, more than one bit can be set, fall through cases.
 811          */
 812         protocols = device_info->device_info & 0x78;
 813         identify->initiator_port_protocols = 0;
 814         if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
 815                 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
 816         if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
 817                 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
 818         if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
 819                 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
 820         if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
 821                 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
 822
 823         /*
 824          * Fill in Phy Target Port Protocol.
 825          * Bits 10:7, more than one bit can be set, fall through cases.
 826          */
 827         protocols = device_info->device_info & 0x780;
 828         identify->target_port_protocols = 0;
 829         if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
 830                 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
 831         if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
 832                 identify->target_port_protocols |= SAS_PROTOCOL_STP;
 833         if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
 834                 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
 835         if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
 836                 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
 837
 838         /*
 839          * Fill in Attached device type.
 840          */
 841         switch (device_info->device_info &
 842                         MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
 843         case MPI_SAS_DEVICE_INFO_NO_DEVICE:
 844                 identify->device_type = SAS_PHY_UNUSED;
 845                 break;
 846         case MPI_SAS_DEVICE_INFO_END_DEVICE:
 847                 identify->device_type = SAS_END_DEVICE;
 848                 break;
 849         case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
 850                 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
 851                 break;
 852         case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
 853                 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
 854                 break;
 855         }
 856 }
 857
 858 static int mptsas_probe_one_phy(struct device *dev,
 859                 struct mptsas_phyinfo *phy_info, int index, int local)
 860 {
 861         struct sas_phy *port;
 862         int error;
 863
 864         port = sas_phy_alloc(dev, index);
 865         if (!port)
 866                 return -ENOMEM;
 867
 868         port->port_identifier = phy_info->port_id;
 869         mptsas_parse_device_info(&port->identify, &phy_info->identify);
 870
 871         /*
 872          * Set Negotiated link rate.
 873          */
 874         switch (phy_info->negotiated_link_rate) {
 875         case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
 876                 port->negotiated_linkrate = SAS_PHY_DISABLED;
 877                 break;
 878         case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
 879                 port->negotiated_linkrate = SAS_LINK_RATE_FAILED;
 880                 break;
 881         case MPI_SAS_IOUNIT0_RATE_1_5:
 882                 port->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
 883                 break;
 884         case MPI_SAS_IOUNIT0_RATE_3_0:
 885                 port->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
 886                 break;
 887         case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
 888         case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
 889         default:
 890                 port->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
 891                 break;
 892         }
 893
 894         /*
 895          * Set Max hardware link rate.
 896          */
 897         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
 898         case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
 899                 port->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
 900                 break;
 901         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
 902                 port->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
 903                 break;
 904         default:
 905                 break;
 906         }
 907
 908         /*
 909          * Set Max programmed link rate.
 910          */
 911         switch (phy_info->programmed_link_rate &
 912                         MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
 913         case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
 914                 port->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
 915                 break;
 916         case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
 917                 port->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
 918                 break;
 919         default:
 920                 break;
 921         }
 922
 923         /*
 924          * Set Min hardware link rate.
 925          */
 926         switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
 927         case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
 928                 port->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
 929                 break;
 930         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
 931                 port->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
 932                 break;
 933         default:
 934                 break;
 935         }
 936
 937         /*
 938          * Set Min programmed link rate.
 939          */
 940         switch (phy_info->programmed_link_rate &
 941                         MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
 942         case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
 943                 port->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
 944                 break;
 945         case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
 946                 port->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
 947                 break;
 948         default:
 949                 break;
 950         }
 951
 952         if (local)
 953                 port->local_attached = 1;
 954
 955         error = sas_phy_add(port);
 956         if (error) {
 957                 sas_phy_free(port);
 958                 return error;
 959         }
 960
 961         if (phy_info->attached.handle) {
 962                 struct sas_rphy *rphy;
 963
 964                 rphy = sas_rphy_alloc(port);
 965                 if (!rphy)
 966                         return 0; /* non-fatal: an rphy can be added later */
 967
 968                 mptsas_parse_device_info(&rphy->identify, &phy_info->attached);
 969                 error = sas_rphy_add(rphy);
 970                 if (error) {
 971                         sas_rphy_free(rphy);
 972                         return error;
 973                 }
 974
 975                 phy_info->rphy = rphy;
 976         }
 977
 978         return 0;
 979 }
 980
 981 static int
 982 mptsas_probe_hba_phys(MPT_ADAPTER *ioc, int *index)
 983 {
 984         struct mptsas_portinfo *port_info;
 985         u32 handle = 0xFFFF;
 986         int error = -ENOMEM, i;
 987
 988         port_info = kmalloc(sizeof(*port_info), GFP_KERNEL);
 989         if (!port_info)
 990                 goto out;
 991         memset(port_info, 0, sizeof(*port_info));
 992
 993         error = mptsas_sas_io_unit_pg0(ioc, port_info);
 994         if (error)
 995                 goto out_free_port_info;
 996
 997         list_add_tail(&port_info->list, &ioc->sas_topology);
 998         for (i = 0; i < port_info->num_phys; i++) {
 999                 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
1000                         (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
1001                          MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
1002
1003                 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
1004                         (MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE <<
1005                          MPI_SAS_DEVICE_PGAD_FORM_SHIFT), handle);
1006                 port_info->phy_info[i].identify.phy_id =
1007                     port_info->phy_info[i].phy_id;
1008                 handle = port_info->phy_info[i].identify.handle;
1009
1010                 if (port_info->phy_info[i].attached.handle) {
1011                         mptsas_sas_device_pg0(ioc,
1012                                 &port_info->phy_info[i].attached,
1013                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1014                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1015                                 port_info->phy_info[i].attached.handle);
1016                 }
1017
1018                 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
1019                                      &port_info->phy_info[i], *index, 1);
1020                 (*index)++;
1021         }
1022
1023         return 0;
1024
1025  out_free_port_info:
1026         kfree(port_info);
1027  out:
1028         return error;
1029 }
1030
1031 static int
1032 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)
1033 {
1034         struct mptsas_portinfo *port_info, *p;
1035         int error = -ENOMEM, i, j;
1036
1037         port_info = kmalloc(sizeof(*port_info), GFP_KERNEL);
1038         if (!port_info)
1039                 goto out;
1040         memset(port_info, 0, sizeof(*port_info));
1041
1042         error = mptsas_sas_expander_pg0(ioc, port_info,
1043                 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
1044                  MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
1045         if (error)
1046                 goto out_free_port_info;
1047
1048         *handle = port_info->handle;
1049
1050         list_add_tail(&port_info->list, &ioc->sas_topology);
1051         for (i = 0; i < port_info->num_phys; i++) {
1052                 struct device *parent;
1053
1054                 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
1055                         (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
1056                          MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
1057
1058                 if (port_info->phy_info[i].identify.handle) {
1059                         mptsas_sas_device_pg0(ioc,
1060                                 &port_info->phy_info[i].identify,
1061                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1062                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1063                                 port_info->phy_info[i].identify.handle);
1064                         port_info->phy_info[i].identify.phy_id =
1065                             port_info->phy_info[i].phy_id;
1066                 }
1067
1068                 if (port_info->phy_info[i].attached.handle) {
1069                         mptsas_sas_device_pg0(ioc,
1070                                 &port_info->phy_info[i].attached,
1071                                 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1072                                  MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1073                                 port_info->phy_info[i].attached.handle);
1074                 }
1075
1076                 /*
1077                  * If we find a parent port handle this expander is
1078                  * attached to another expander, else it hangs of the
1079                  * HBA phys.
1080                  */
1081                 parent = &ioc->sh->shost_gendev;
1082                 list_for_each_entry(p, &ioc->sas_topology, list) {
1083                         for (j = 0; j < p->num_phys; j++) {
1084                                 if (port_info->phy_info[i].identify.handle ==
1085                                                 p->phy_info[j].attached.handle)
1086                                         parent = &p->phy_info[j].rphy->dev;
1087                         }
1088                 }
1089
1090                 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
1091                                      *index, 0);
1092                 (*index)++;
1093         }
1094
1095         return 0;
1096
1097  out_free_port_info:
1098         kfree(port_info);
1099  out:
1100         return error;
1101 }
1102
1103 static void
1104 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
1105 {
1106         u32 handle = 0xFFFF;
1107         int index = 0;
1108
1109         mptsas_probe_hba_phys(ioc, &index);
1110         while (!mptsas_probe_expander_phys(ioc, &handle, &index))
1111                 ;
1112 }
1113
1114 static int
1115 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1116 {
1117         struct Scsi_Host        *sh;
1118         MPT_SCSI_HOST           *hd;
1119         MPT_ADAPTER             *ioc;
1120         unsigned long            flags;
1121         int                      sz, ii;
1122         int                      numSGE = 0;
1123         int                      scale;
1124         int                      ioc_cap;
1125         u8                      *mem;
1126         int                     error=0;
1127         int                     r;
1128
1129         r = mpt_attach(pdev,id);
1130         if (r)
1131                 return r;
1132
1133         ioc = pci_get_drvdata(pdev);
1134         ioc->DoneCtx = mptsasDoneCtx;
1135         ioc->TaskCtx = mptsasTaskCtx;
1136         ioc->InternalCtx = mptsasInternalCtx;
1137
1138         /*  Added sanity check on readiness of the MPT adapter.
1139          */
1140         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1141                 printk(MYIOC_s_WARN_FMT
1142                   "Skipping because it's not operational!\n",
1143                   ioc->name);
1144                 error = -ENODEV;
1145                 goto out_mptsas_probe;
1146         }
1147
1148         if (!ioc->active) {
1149                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1150                   ioc->name);
1151                 error = -ENODEV;
1152                 goto out_mptsas_probe;
1153         }
1154
1155         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1156          */
1157         ioc_cap = 0;
1158         for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
1159                 if (ioc->pfacts[ii].ProtocolFlags &
1160                                 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1161                         ioc_cap++;
1162         }
1163
1164         if (!ioc_cap) {
1165                 printk(MYIOC_s_WARN_FMT
1166                         "Skipping ioc=%p because SCSI Initiator mode "
1167                         "is NOT enabled!\n", ioc->name, ioc);
1168                 return 0;
1169         }
1170
1171         sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
1172         if (!sh) {
1173                 printk(MYIOC_s_WARN_FMT
1174                         "Unable to register controller with SCSI subsystem\n",
1175                         ioc->name);
1176                 error = -1;
1177                 goto out_mptsas_probe;
1178         }
1179
1180         spin_lock_irqsave(&ioc->FreeQlock, flags);
1181
1182         /* Attach the SCSI Host to the IOC structure
1183          */
1184         ioc->sh = sh;
1185
1186         sh->io_port = 0;
1187         sh->n_io_port = 0;
1188         sh->irq = 0;
1189
1190         /* set 16 byte cdb's */
1191         sh->max_cmd_len = 16;
1192
1193         sh->max_id = ioc->pfacts->MaxDevices + 1;
1194
1195         sh->transportt = mptsas_transport_template;
1196
1197         sh->max_lun = MPT_LAST_LUN + 1;
1198         sh->max_channel = 0;
1199         sh->this_id = ioc->pfacts[0].PortSCSIID;
1200
1201         /* Required entry.
1202          */
1203         sh->unique_id = ioc->id;
1204
1205         INIT_LIST_HEAD(&ioc->sas_topology);
1206         init_MUTEX(&ioc->sas_mgmt.mutex);
1207         init_completion(&ioc->sas_mgmt.done);
1208
1209         /* Verify that we won't exceed the maximum
1210          * number of chain buffers
1211          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1212          * For 32bit SGE's:
1213          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1214          *               + (req_sz - 64)/sizeof(SGE)
1215          * A slightly different algorithm is required for
1216          * 64bit SGEs.
1217          */
1218         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1219         if (sizeof(dma_addr_t) == sizeof(u64)) {
1220                 numSGE = (scale - 1) *
1221                   (ioc->facts.MaxChainDepth-1) + scale +
1222                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1223                   sizeof(u32));
1224         } else {
1225                 numSGE = 1 + (scale - 1) *
1226                   (ioc->facts.MaxChainDepth-1) + scale +
1227                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1228                   sizeof(u32));
1229         }
1230
1231         if (numSGE < sh->sg_tablesize) {
1232                 /* Reset this value */
1233                 dprintk((MYIOC_s_INFO_FMT
1234                   "Resetting sg_tablesize to %d from %d\n",
1235                   ioc->name, numSGE, sh->sg_tablesize));
1236                 sh->sg_tablesize = numSGE;
1237         }
1238
1239         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1240
1241         hd = (MPT_SCSI_HOST *) sh->hostdata;
1242         hd->ioc = ioc;
1243
1244         /* SCSI needs scsi_cmnd lookup table!
1245          * (with size equal to req_depth*PtrSz!)
1246          */
1247         sz = ioc->req_depth * sizeof(void *);
1248         mem = kmalloc(sz, GFP_ATOMIC);
1249         if (mem == NULL) {
1250                 error = -ENOMEM;
1251                 goto out_mptsas_probe;
1252         }
1253
1254         memset(mem, 0, sz);
1255         hd->ScsiLookup = (struct scsi_cmnd **) mem;
1256
1257         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p, sz=%d\n",
1258                  ioc->name, hd->ScsiLookup, sz));
1259
1260         /* Allocate memory for the device structures.
1261          * A non-Null pointer at an offset
1262          * indicates a device exists.
1263          * max_id = 1 + maximum id (hosts.h)
1264          */
1265         sz = sh->max_id * sizeof(void *);
1266         mem = kmalloc(sz, GFP_ATOMIC);
1267         if (mem == NULL) {
1268                 error = -ENOMEM;
1269                 goto out_mptsas_probe;
1270         }
1271
1272         memset(mem, 0, sz);
1273         hd->Targets = (VirtTarget **) mem;
1274
1275         dprintk((KERN_INFO
1276           "  vtarget @ %p, sz=%d\n", hd->Targets, sz));
1277
1278         /* Clear the TM flags
1279          */
1280         hd->tmPending = 0;
1281         hd->tmState = TM_STATE_NONE;
1282         hd->resetPending = 0;
1283         hd->abortSCpnt = NULL;
1284
1285         /* Clear the pointer used to store
1286          * single-threaded commands, i.e., those
1287          * issued during a bus scan, dv and
1288          * configuration pages.
1289          */
1290         hd->cmdPtr = NULL;
1291
1292         /* Initialize this SCSI Hosts' timers
1293          * To use, set the timer expires field
1294          * and add_timer
1295          */
1296         init_timer(&hd->timer);
1297         hd->timer.data = (unsigned long) hd;
1298         hd->timer.function = mptscsih_timer_expired;
1299
1300         hd->mpt_pq_filter = mpt_pq_filter;
1301         ioc->sas_data.ptClear = mpt_pt_clear;
1302
1303         if (ioc->sas_data.ptClear==1) {
1304                 mptbase_sas_persist_operation(
1305                     ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
1306         }
1307
1308         ddvprintk((MYIOC_s_INFO_FMT
1309                 "mpt_pq_filter %x mpt_pq_filter %x\n",
1310                 ioc->name,
1311                 mpt_pq_filter,
1312                 mpt_pq_filter));
1313
1314         init_waitqueue_head(&hd->scandv_waitq);
1315         hd->scandv_wait_done = 0;
1316         hd->last_queue_full = 0;
1317
1318         error = scsi_add_host(sh, &ioc->pcidev->dev);
1319         if (error) {
1320                 dprintk((KERN_ERR MYNAM
1321                   "scsi_add_host failed\n"));
1322                 goto out_mptsas_probe;
1323         }
1324
1325         mptsas_scan_sas_topology(ioc);
1326
1327         return 0;
1328
1329 out_mptsas_probe:
1330
1331         mptscsih_remove(pdev);
1332         return error;
1333 }
1334
1335 static void __devexit mptsas_remove(struct pci_dev *pdev)
1336 {
1337         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1338         struct mptsas_portinfo *p, *n;
1339
1340         sas_remove_host(ioc->sh);
1341
1342         list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
1343                 list_del(&p->list);
1344                 kfree(p);
1345         }
1346
1347         mptscsih_remove(pdev);
1348 }
1349
1350 static struct pci_device_id mptsas_pci_table[] = {
1351         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064,
1352                 PCI_ANY_ID, PCI_ANY_ID },
1353         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1066,
1354                 PCI_ANY_ID, PCI_ANY_ID },
1355         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1068,
1356                 PCI_ANY_ID, PCI_ANY_ID },
1357         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064E,
1358                 PCI_ANY_ID, PCI_ANY_ID },
1359         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1066E,
1360                 PCI_ANY_ID, PCI_ANY_ID },
1361         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1068E,
1362                 PCI_ANY_ID, PCI_ANY_ID },
1363         {0}     /* Terminating entry */
1364 };
1365 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
1366
1367
1368 static struct pci_driver mptsas_driver = {
1369         .name           = "mptsas",
1370         .id_table       = mptsas_pci_table,
1371         .probe          = mptsas_probe,
1372         .remove         = __devexit_p(mptsas_remove),
1373         .shutdown       = mptscsih_shutdown,
1374 #ifdef CONFIG_PM
1375         .suspend        = mptscsih_suspend,
1376         .resume         = mptscsih_resume,
1377 #endif
1378 };
1379
1380 static int __init
1381 mptsas_init(void)
1382 {
1383         show_mptmod_ver(my_NAME, my_VERSION);
1384
1385         mptsas_transport_template =
1386             sas_attach_transport(&mptsas_transport_functions);
1387         if (!mptsas_transport_template)
1388                 return -ENODEV;
1389
1390         mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
1391         mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER);
1392         mptsasInternalCtx =
1393                 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
1394         mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
1395
1396         if (mpt_event_register(mptsasDoneCtx, mptscsih_event_process) == 0) {
1397                 devtprintk((KERN_INFO MYNAM
1398                   ": Registered for IOC event notifications\n"));
1399         }
1400
1401         if (mpt_reset_register(mptsasDoneCtx, mptscsih_ioc_reset) == 0) {
1402                 dprintk((KERN_INFO MYNAM
1403                   ": Registered for IOC reset notifications\n"));
1404         }
1405
1406         return pci_register_driver(&mptsas_driver);
1407 }
1408
1409 static void __exit
1410 mptsas_exit(void)
1411 {
1412         pci_unregister_driver(&mptsas_driver);
1413         sas_release_transport(mptsas_transport_template);
1414
1415         mpt_reset_deregister(mptsasDoneCtx);
1416         mpt_event_deregister(mptsasDoneCtx);
1417
1418         mpt_deregister(mptsasMgmtCtx);
1419         mpt_deregister(mptsasInternalCtx);
1420         mpt_deregister(mptsasTaskCtx);
1421         mpt_deregister(mptsasDoneCtx);
1422 }
1423
1424 module_init(mptsas_init);
1425 module_exit(mptsas_exit);