drivers/scsi/mpt3sas/mpt3sas_transport.c

   1 /*
   2  * SAS Transport Layer for MPT (Message Passing Technology) based controllers
   3  *
   4  * This code is based on drivers/scsi/mpt3sas/mpt3sas_transport.c
   5  * Copyright (C) 2012-2014  LSI Corporation
   6  * Copyright (C) 2013-2014 Avago Technologies
   7  *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * NO WARRANTY
  20  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  21  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  22  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  23  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  24  * solely responsible for determining the appropriateness of using and
  25  * distributing the Program and assumes all risks associated with its
  26  * exercise of rights under this Agreement, including but not limited to
  27  * the risks and costs of program errors, damage to or loss of data,
  28  * programs or equipment, and unavailability or interruption of operations.
  29
  30  * DISCLAIMER OF LIABILITY
  31  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  32  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  34  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  35  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  36  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  37  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  38
  39  * You should have received a copy of the GNU General Public License
  40  * along with this program; if not, write to the Free Software
  41  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  42  * USA.
  43  */
  44
  45 #include <linux/module.h>
  46 #include <linux/kernel.h>
  47 #include <linux/init.h>
  48 #include <linux/errno.h>
  49 #include <linux/sched.h>
  50 #include <linux/workqueue.h>
  51 #include <linux/delay.h>
  52 #include <linux/pci.h>
  53
  54 #include <scsi/scsi.h>
  55 #include <scsi/scsi_cmnd.h>
  56 #include <scsi/scsi_device.h>
  57 #include <scsi/scsi_host.h>
  58 #include <scsi/scsi_transport_sas.h>
  59 #include <scsi/scsi_dbg.h>
  60
  61 #include "mpt3sas_base.h"
  62
  63 /**
  64  * _transport_sas_node_find_by_sas_address - sas node search
  65  * @ioc: per adapter object
  66  * @sas_address: sas address of expander or sas host
  67  * Context: Calling function should acquire ioc->sas_node_lock.
  68  *
  69  * Search for either hba phys or expander device based on handle, then returns
  70  * the sas_node object.
  71  */
  72 static struct _sas_node *
  73 _transport_sas_node_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
  74         u64 sas_address)
  75 {
  76         if (ioc->sas_hba.sas_address == sas_address)
  77                 return &ioc->sas_hba;
  78         else
  79                 return mpt3sas_scsih_expander_find_by_sas_address(ioc,
  80                     sas_address);
  81 }
  82
  83 /**
  84  * _transport_convert_phy_link_rate -
  85  * @link_rate: link rate returned from mpt firmware
  86  *
  87  * Convert link_rate from mpi fusion into sas_transport form.
  88  */
  89 static enum sas_linkrate
  90 _transport_convert_phy_link_rate(u8 link_rate)
  91 {
  92         enum sas_linkrate rc;
  93
  94         switch (link_rate) {
  95         case MPI2_SAS_NEG_LINK_RATE_1_5:
  96                 rc = SAS_LINK_RATE_1_5_GBPS;
  97                 break;
  98         case MPI2_SAS_NEG_LINK_RATE_3_0:
  99                 rc = SAS_LINK_RATE_3_0_GBPS;
 100                 break;
 101         case MPI2_SAS_NEG_LINK_RATE_6_0:
 102                 rc = SAS_LINK_RATE_6_0_GBPS;
 103                 break;
 104         case MPI25_SAS_NEG_LINK_RATE_12_0:
 105                 rc = SAS_LINK_RATE_12_0_GBPS;
 106                 break;
 107         case MPI2_SAS_NEG_LINK_RATE_PHY_DISABLED:
 108                 rc = SAS_PHY_DISABLED;
 109                 break;
 110         case MPI2_SAS_NEG_LINK_RATE_NEGOTIATION_FAILED:
 111                 rc = SAS_LINK_RATE_FAILED;
 112                 break;
 113         case MPI2_SAS_NEG_LINK_RATE_PORT_SELECTOR:
 114                 rc = SAS_SATA_PORT_SELECTOR;
 115                 break;
 116         case MPI2_SAS_NEG_LINK_RATE_SMP_RESET_IN_PROGRESS:
 117                 rc = SAS_PHY_RESET_IN_PROGRESS;
 118                 break;
 119
 120         default:
 121         case MPI2_SAS_NEG_LINK_RATE_SATA_OOB_COMPLETE:
 122         case MPI2_SAS_NEG_LINK_RATE_UNKNOWN_LINK_RATE:
 123                 rc = SAS_LINK_RATE_UNKNOWN;
 124                 break;
 125         }
 126         return rc;
 127 }
 128
 129 /**
 130  * _transport_set_identify - set identify for phys and end devices
 131  * @ioc: per adapter object
 132  * @handle: device handle
 133  * @identify: sas identify info
 134  *
 135  * Populates sas identify info.
 136  *
 137  * Return: 0 for success, non-zero for failure.
 138  */
 139 static int
 140 _transport_set_identify(struct MPT3SAS_ADAPTER *ioc, u16 handle,
 141         struct sas_identify *identify)
 142 {
 143         Mpi2SasDevicePage0_t sas_device_pg0;
 144         Mpi2ConfigReply_t mpi_reply;
 145         u32 device_info;
 146         u32 ioc_status;
 147
 148         if (ioc->shost_recovery || ioc->pci_error_recovery) {
 149                 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
 150                 return -EFAULT;
 151         }
 152
 153         if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 154             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
 155                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 156                         __FILE__, __LINE__, __func__);
 157                 return -ENXIO;
 158         }
 159
 160         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 161             MPI2_IOCSTATUS_MASK;
 162         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 163                 ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x) failure at %s:%d/%s()!\n",
 164                         handle, ioc_status, __FILE__, __LINE__, __func__);
 165                 return -EIO;
 166         }
 167
 168         memset(identify, 0, sizeof(struct sas_identify));
 169         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
 170
 171         /* sas_address */
 172         identify->sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
 173
 174         /* phy number of the parent device this device is linked to */
 175         identify->phy_identifier = sas_device_pg0.PhyNum;
 176
 177         /* device_type */
 178         switch (device_info & MPI2_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
 179         case MPI2_SAS_DEVICE_INFO_NO_DEVICE:
 180                 identify->device_type = SAS_PHY_UNUSED;
 181                 break;
 182         case MPI2_SAS_DEVICE_INFO_END_DEVICE:
 183                 identify->device_type = SAS_END_DEVICE;
 184                 break;
 185         case MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER:
 186                 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
 187                 break;
 188         case MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER:
 189                 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
 190                 break;
 191         }
 192
 193         /* initiator_port_protocols */
 194         if (device_info & MPI2_SAS_DEVICE_INFO_SSP_INITIATOR)
 195                 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
 196         if (device_info & MPI2_SAS_DEVICE_INFO_STP_INITIATOR)
 197                 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
 198         if (device_info & MPI2_SAS_DEVICE_INFO_SMP_INITIATOR)
 199                 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
 200         if (device_info & MPI2_SAS_DEVICE_INFO_SATA_HOST)
 201                 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
 202
 203         /* target_port_protocols */
 204         if (device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET)
 205                 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
 206         if (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
 207                 identify->target_port_protocols |= SAS_PROTOCOL_STP;
 208         if (device_info & MPI2_SAS_DEVICE_INFO_SMP_TARGET)
 209                 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
 210         if (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
 211                 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
 212
 213         return 0;
 214 }
 215
 216 /**
 217  * mpt3sas_transport_done -  internal transport layer callback handler.
 218  * @ioc: per adapter object
 219  * @smid: system request message index
 220  * @msix_index: MSIX table index supplied by the OS
 221  * @reply: reply message frame(lower 32bit addr)
 222  *
 223  * Callback handler when sending internal generated transport cmds.
 224  * The callback index passed is `ioc->transport_cb_idx`
 225  *
 226  * Return: 1 meaning mf should be freed from _base_interrupt
 227  *         0 means the mf is freed from this function.
 228  */
 229 u8
 230 mpt3sas_transport_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
 231         u32 reply)
 232 {
 233         MPI2DefaultReply_t *mpi_reply;
 234
 235         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
 236         if (ioc->transport_cmds.status == MPT3_CMD_NOT_USED)
 237                 return 1;
 238         if (ioc->transport_cmds.smid != smid)
 239                 return 1;
 240         ioc->transport_cmds.status |= MPT3_CMD_COMPLETE;
 241         if (mpi_reply) {
 242                 memcpy(ioc->transport_cmds.reply, mpi_reply,
 243                     mpi_reply->MsgLength*4);
 244                 ioc->transport_cmds.status |= MPT3_CMD_REPLY_VALID;
 245         }
 246         ioc->transport_cmds.status &= ~MPT3_CMD_PENDING;
 247         complete(&ioc->transport_cmds.done);
 248         return 1;
 249 }
 250
 251 /* report manufacture request structure */
 252 struct rep_manu_request {
 253         u8 smp_frame_type;
 254         u8 function;
 255         u8 reserved;
 256         u8 request_length;
 257 };
 258
 259 /* report manufacture reply structure */
 260 struct rep_manu_reply {
 261         u8 smp_frame_type; /* 0x41 */
 262         u8 function; /* 0x01 */
 263         u8 function_result;
 264         u8 response_length;
 265         u16 expander_change_count;
 266         u8 reserved0[2];
 267         u8 sas_format;
 268         u8 reserved2[3];
 269         u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
 270         u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
 271         u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
 272         u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
 273         u16 component_id;
 274         u8 component_revision_id;
 275         u8 reserved3;
 276         u8 vendor_specific[8];
 277 };
 278
 279 /**
 280  * transport_expander_report_manufacture - obtain SMP report_manufacture
 281  * @ioc: per adapter object
 282  * @sas_address: expander sas address
 283  * @edev: the sas_expander_device object
 284  *
 285  * Fills in the sas_expander_device object when SMP port is created.
 286  *
 287  * Return: 0 for success, non-zero for failure.
 288  */
 289 static int
 290 _transport_expander_report_manufacture(struct MPT3SAS_ADAPTER *ioc,
 291         u64 sas_address, struct sas_expander_device *edev)
 292 {
 293         Mpi2SmpPassthroughRequest_t *mpi_request;
 294         Mpi2SmpPassthroughReply_t *mpi_reply;
 295         struct rep_manu_reply *manufacture_reply;
 296         struct rep_manu_request *manufacture_request;
 297         int rc;
 298         u16 smid;
 299         void *psge;
 300         u8 issue_reset = 0;
 301         void *data_out = NULL;
 302         dma_addr_t data_out_dma;
 303         dma_addr_t data_in_dma;
 304         size_t data_in_sz;
 305         size_t data_out_sz;
 306
 307         if (ioc->shost_recovery || ioc->pci_error_recovery) {
 308                 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
 309                 return -EFAULT;
 310         }
 311
 312         mutex_lock(&ioc->transport_cmds.mutex);
 313
 314         if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
 315                 ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
 316                 rc = -EAGAIN;
 317                 goto out;
 318         }
 319         ioc->transport_cmds.status = MPT3_CMD_PENDING;
 320
 321         rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
 322         if (rc)
 323                 goto out;
 324
 325         smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
 326         if (!smid) {
 327                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
 328                 rc = -EAGAIN;
 329                 goto out;
 330         }
 331
 332         rc = 0;
 333         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 334         ioc->transport_cmds.smid = smid;
 335
 336         data_out_sz = sizeof(struct rep_manu_request);
 337         data_in_sz = sizeof(struct rep_manu_reply);
 338         data_out = dma_alloc_coherent(&ioc->pdev->dev, data_out_sz + data_in_sz,
 339                         &data_out_dma, GFP_KERNEL);
 340         if (!data_out) {
 341                 pr_err("failure at %s:%d/%s()!\n", __FILE__,
 342                     __LINE__, __func__);
 343                 rc = -ENOMEM;
 344                 mpt3sas_base_free_smid(ioc, smid);
 345                 goto out;
 346         }
 347
 348         data_in_dma = data_out_dma + sizeof(struct rep_manu_request);
 349
 350         manufacture_request = data_out;
 351         manufacture_request->smp_frame_type = 0x40;
 352         manufacture_request->function = 1;
 353         manufacture_request->reserved = 0;
 354         manufacture_request->request_length = 0;
 355
 356         memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
 357         mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
 358         mpi_request->PhysicalPort = 0xFF;
 359         mpi_request->SASAddress = cpu_to_le64(sas_address);
 360         mpi_request->RequestDataLength = cpu_to_le16(data_out_sz);
 361         psge = &mpi_request->SGL;
 362
 363         ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
 364             data_in_sz);
 365
 366         dtransportprintk(ioc,
 367                          ioc_info(ioc, "report_manufacture - send to sas_addr(0x%016llx)\n",
 368                                   (u64)sas_address));
 369         init_completion(&ioc->transport_cmds.done);
 370         ioc->put_smid_default(ioc, smid);
 371         wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
 372
 373         if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
 374                 ioc_err(ioc, "%s: timeout\n", __func__);
 375                 _debug_dump_mf(mpi_request,
 376                     sizeof(Mpi2SmpPassthroughRequest_t)/4);
 377                 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
 378                         issue_reset = 1;
 379                 goto issue_host_reset;
 380         }
 381
 382         dtransportprintk(ioc, ioc_info(ioc, "report_manufacture - complete\n"));
 383
 384         if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
 385                 u8 *tmp;
 386
 387                 mpi_reply = ioc->transport_cmds.reply;
 388
 389                 dtransportprintk(ioc,
 390                                  ioc_info(ioc, "report_manufacture - reply data transfer size(%d)\n",
 391                                           le16_to_cpu(mpi_reply->ResponseDataLength)));
 392
 393                 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
 394                     sizeof(struct rep_manu_reply))
 395                         goto out;
 396
 397                 manufacture_reply = data_out + sizeof(struct rep_manu_request);
 398                 strncpy(edev->vendor_id, manufacture_reply->vendor_id,
 399                      SAS_EXPANDER_VENDOR_ID_LEN);
 400                 strncpy(edev->product_id, manufacture_reply->product_id,
 401                      SAS_EXPANDER_PRODUCT_ID_LEN);
 402                 strncpy(edev->product_rev, manufacture_reply->product_rev,
 403                      SAS_EXPANDER_PRODUCT_REV_LEN);
 404                 edev->level = manufacture_reply->sas_format & 1;
 405                 if (edev->level) {
 406                         strncpy(edev->component_vendor_id,
 407                             manufacture_reply->component_vendor_id,
 408                              SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
 409                         tmp = (u8 *)&manufacture_reply->component_id;
 410                         edev->component_id = tmp[0] << 8 | tmp[1];
 411                         edev->component_revision_id =
 412                             manufacture_reply->component_revision_id;
 413                 }
 414         } else
 415                 dtransportprintk(ioc,
 416                                  ioc_info(ioc, "report_manufacture - no reply\n"));
 417
 418  issue_host_reset:
 419         if (issue_reset)
 420                 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
 421  out:
 422         ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
 423         if (data_out)
 424                 dma_free_coherent(&ioc->pdev->dev, data_out_sz + data_in_sz,
 425                     data_out, data_out_dma);
 426
 427         mutex_unlock(&ioc->transport_cmds.mutex);
 428         return rc;
 429 }
 430
 431
 432 /**
 433  * _transport_delete_port - helper function to removing a port
 434  * @ioc: per adapter object
 435  * @mpt3sas_port: mpt3sas per port object
 436  */
 437 static void
 438 _transport_delete_port(struct MPT3SAS_ADAPTER *ioc,
 439         struct _sas_port *mpt3sas_port)
 440 {
 441         u64 sas_address = mpt3sas_port->remote_identify.sas_address;
 442         enum sas_device_type device_type =
 443             mpt3sas_port->remote_identify.device_type;
 444
 445         dev_printk(KERN_INFO, &mpt3sas_port->port->dev,
 446             "remove: sas_addr(0x%016llx)\n",
 447             (unsigned long long) sas_address);
 448
 449         ioc->logging_level |= MPT_DEBUG_TRANSPORT;
 450         if (device_type == SAS_END_DEVICE)
 451                 mpt3sas_device_remove_by_sas_address(ioc, sas_address);
 452         else if (device_type == SAS_EDGE_EXPANDER_DEVICE ||
 453             device_type == SAS_FANOUT_EXPANDER_DEVICE)
 454                 mpt3sas_expander_remove(ioc, sas_address);
 455         ioc->logging_level &= ~MPT_DEBUG_TRANSPORT;
 456 }
 457
 458 /**
 459  * _transport_delete_phy - helper function to removing single phy from port
 460  * @ioc: per adapter object
 461  * @mpt3sas_port: mpt3sas per port object
 462  * @mpt3sas_phy: mpt3sas per phy object
 463  */
 464 static void
 465 _transport_delete_phy(struct MPT3SAS_ADAPTER *ioc,
 466         struct _sas_port *mpt3sas_port, struct _sas_phy *mpt3sas_phy)
 467 {
 468         u64 sas_address = mpt3sas_port->remote_identify.sas_address;
 469
 470         dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
 471             "remove: sas_addr(0x%016llx), phy(%d)\n",
 472             (unsigned long long) sas_address, mpt3sas_phy->phy_id);
 473
 474         list_del(&mpt3sas_phy->port_siblings);
 475         mpt3sas_port->num_phys--;
 476         sas_port_delete_phy(mpt3sas_port->port, mpt3sas_phy->phy);
 477         mpt3sas_phy->phy_belongs_to_port = 0;
 478 }
 479
 480 /**
 481  * _transport_add_phy - helper function to adding single phy to port
 482  * @ioc: per adapter object
 483  * @mpt3sas_port: mpt3sas per port object
 484  * @mpt3sas_phy: mpt3sas per phy object
 485  */
 486 static void
 487 _transport_add_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_port *mpt3sas_port,
 488         struct _sas_phy *mpt3sas_phy)
 489 {
 490         u64 sas_address = mpt3sas_port->remote_identify.sas_address;
 491
 492         dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
 493             "add: sas_addr(0x%016llx), phy(%d)\n", (unsigned long long)
 494             sas_address, mpt3sas_phy->phy_id);
 495
 496         list_add_tail(&mpt3sas_phy->port_siblings, &mpt3sas_port->phy_list);
 497         mpt3sas_port->num_phys++;
 498         sas_port_add_phy(mpt3sas_port->port, mpt3sas_phy->phy);
 499         mpt3sas_phy->phy_belongs_to_port = 1;
 500 }
 501
 502 /**
 503  * _transport_add_phy_to_an_existing_port - adding new phy to existing port
 504  * @ioc: per adapter object
 505  * @sas_node: sas node object (either expander or sas host)
 506  * @mpt3sas_phy: mpt3sas per phy object
 507  * @sas_address: sas address of device/expander were phy needs to be added to
 508  */
 509 static void
 510 _transport_add_phy_to_an_existing_port(struct MPT3SAS_ADAPTER *ioc,
 511         struct _sas_node *sas_node, struct _sas_phy *mpt3sas_phy,
 512         u64 sas_address)
 513 {
 514         struct _sas_port *mpt3sas_port;
 515         struct _sas_phy *phy_srch;
 516
 517         if (mpt3sas_phy->phy_belongs_to_port == 1)
 518                 return;
 519
 520         list_for_each_entry(mpt3sas_port, &sas_node->sas_port_list,
 521             port_list) {
 522                 if (mpt3sas_port->remote_identify.sas_address !=
 523                     sas_address)
 524                         continue;
 525                 list_for_each_entry(phy_srch, &mpt3sas_port->phy_list,
 526                     port_siblings) {
 527                         if (phy_srch == mpt3sas_phy)
 528                                 return;
 529                 }
 530                 _transport_add_phy(ioc, mpt3sas_port, mpt3sas_phy);
 531                 return;
 532         }
 533
 534 }
 535
 536 /**
 537  * _transport_del_phy_from_an_existing_port - delete phy from existing port
 538  * @ioc: per adapter object
 539  * @sas_node: sas node object (either expander or sas host)
 540  * @mpt3sas_phy: mpt3sas per phy object
 541  */
 542 static void
 543 _transport_del_phy_from_an_existing_port(struct MPT3SAS_ADAPTER *ioc,
 544         struct _sas_node *sas_node, struct _sas_phy *mpt3sas_phy)
 545 {
 546         struct _sas_port *mpt3sas_port, *next;
 547         struct _sas_phy *phy_srch;
 548
 549         if (mpt3sas_phy->phy_belongs_to_port == 0)
 550                 return;
 551
 552         list_for_each_entry_safe(mpt3sas_port, next, &sas_node->sas_port_list,
 553             port_list) {
 554                 list_for_each_entry(phy_srch, &mpt3sas_port->phy_list,
 555                     port_siblings) {
 556                         if (phy_srch != mpt3sas_phy)
 557                                 continue;
 558
 559                         if (mpt3sas_port->num_phys == 1)
 560                                 _transport_delete_port(ioc, mpt3sas_port);
 561                         else
 562                                 _transport_delete_phy(ioc, mpt3sas_port,
 563                                     mpt3sas_phy);
 564                         return;
 565                 }
 566         }
 567 }
 568
 569 /**
 570  * _transport_sanity_check - sanity check when adding a new port
 571  * @ioc: per adapter object
 572  * @sas_node: sas node object (either expander or sas host)
 573  * @sas_address: sas address of device being added
 574  *
 575  * See the explanation above from _transport_delete_duplicate_port
 576  */
 577 static void
 578 _transport_sanity_check(struct MPT3SAS_ADAPTER *ioc, struct _sas_node *sas_node,
 579         u64 sas_address)
 580 {
 581         int i;
 582
 583         for (i = 0; i < sas_node->num_phys; i++) {
 584                 if (sas_node->phy[i].remote_identify.sas_address != sas_address)
 585                         continue;
 586                 if (sas_node->phy[i].phy_belongs_to_port == 1)
 587                         _transport_del_phy_from_an_existing_port(ioc, sas_node,
 588                             &sas_node->phy[i]);
 589         }
 590 }
 591
 592 /**
 593  * mpt3sas_transport_port_add - insert port to the list
 594  * @ioc: per adapter object
 595  * @handle: handle of attached device
 596  * @sas_address: sas address of parent expander or sas host
 597  * Context: This function will acquire ioc->sas_node_lock.
 598  *
 599  * Adding new port object to the sas_node->sas_port_list.
 600  *
 601  * Return: mpt3sas_port.
 602  */
 603 struct _sas_port *
 604 mpt3sas_transport_port_add(struct MPT3SAS_ADAPTER *ioc, u16 handle,
 605         u64 sas_address)
 606 {
 607         struct _sas_phy *mpt3sas_phy, *next;
 608         struct _sas_port *mpt3sas_port;
 609         unsigned long flags;
 610         struct _sas_node *sas_node;
 611         struct sas_rphy *rphy;
 612         struct _sas_device *sas_device = NULL;
 613         int i;
 614         struct sas_port *port;
 615
 616         mpt3sas_port = kzalloc(sizeof(struct _sas_port),
 617             GFP_KERNEL);
 618         if (!mpt3sas_port) {
 619                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 620                         __FILE__, __LINE__, __func__);
 621                 return NULL;
 622         }
 623
 624         INIT_LIST_HEAD(&mpt3sas_port->port_list);
 625         INIT_LIST_HEAD(&mpt3sas_port->phy_list);
 626         spin_lock_irqsave(&ioc->sas_node_lock, flags);
 627         sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
 628         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 629
 630         if (!sas_node) {
 631                 ioc_err(ioc, "%s: Could not find parent sas_address(0x%016llx)!\n",
 632                         __func__, (u64)sas_address);
 633                 goto out_fail;
 634         }
 635
 636         if ((_transport_set_identify(ioc, handle,
 637             &mpt3sas_port->remote_identify))) {
 638                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 639                         __FILE__, __LINE__, __func__);
 640                 goto out_fail;
 641         }
 642
 643         if (mpt3sas_port->remote_identify.device_type == SAS_PHY_UNUSED) {
 644                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 645                         __FILE__, __LINE__, __func__);
 646                 goto out_fail;
 647         }
 648
 649         _transport_sanity_check(ioc, sas_node,
 650             mpt3sas_port->remote_identify.sas_address);
 651
 652         for (i = 0; i < sas_node->num_phys; i++) {
 653                 if (sas_node->phy[i].remote_identify.sas_address !=
 654                     mpt3sas_port->remote_identify.sas_address)
 655                         continue;
 656                 list_add_tail(&sas_node->phy[i].port_siblings,
 657                     &mpt3sas_port->phy_list);
 658                 mpt3sas_port->num_phys++;
 659         }
 660
 661         if (!mpt3sas_port->num_phys) {
 662                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 663                         __FILE__, __LINE__, __func__);
 664                 goto out_fail;
 665         }
 666
 667         if (!sas_node->parent_dev) {
 668                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 669                         __FILE__, __LINE__, __func__);
 670                 goto out_fail;
 671         }
 672         port = sas_port_alloc_num(sas_node->parent_dev);
 673         if ((sas_port_add(port))) {
 674                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 675                         __FILE__, __LINE__, __func__);
 676                 goto out_fail;
 677         }
 678
 679         list_for_each_entry(mpt3sas_phy, &mpt3sas_port->phy_list,
 680             port_siblings) {
 681                 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
 682                         dev_printk(KERN_INFO, &port->dev,
 683                                 "add: handle(0x%04x), sas_addr(0x%016llx), phy(%d)\n",
 684                                 handle, (unsigned long long)
 685                             mpt3sas_port->remote_identify.sas_address,
 686                             mpt3sas_phy->phy_id);
 687                 sas_port_add_phy(port, mpt3sas_phy->phy);
 688                 mpt3sas_phy->phy_belongs_to_port = 1;
 689         }
 690
 691         mpt3sas_port->port = port;
 692         if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE)
 693                 rphy = sas_end_device_alloc(port);
 694         else
 695                 rphy = sas_expander_alloc(port,
 696                     mpt3sas_port->remote_identify.device_type);
 697
 698         rphy->identify = mpt3sas_port->remote_identify;
 699
 700         if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE) {
 701                 sas_device = mpt3sas_get_sdev_by_addr(ioc,
 702                                     mpt3sas_port->remote_identify.sas_address);
 703                 if (!sas_device) {
 704                         dfailprintk(ioc,
 705                                     ioc_info(ioc, "failure at %s:%d/%s()!\n",
 706                                              __FILE__, __LINE__, __func__));
 707                         goto out_fail;
 708                 }
 709                 sas_device->pend_sas_rphy_add = 1;
 710         }
 711
 712         if ((sas_rphy_add(rphy))) {
 713                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 714                         __FILE__, __LINE__, __func__);
 715         }
 716
 717         if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE) {
 718                 sas_device->pend_sas_rphy_add = 0;
 719                 sas_device_put(sas_device);
 720         }
 721
 722         if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
 723                 dev_printk(KERN_INFO, &rphy->dev,
 724                         "add: handle(0x%04x), sas_addr(0x%016llx)\n",
 725                         handle, (unsigned long long)
 726                     mpt3sas_port->remote_identify.sas_address);
 727         mpt3sas_port->rphy = rphy;
 728         spin_lock_irqsave(&ioc->sas_node_lock, flags);
 729         list_add_tail(&mpt3sas_port->port_list, &sas_node->sas_port_list);
 730         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 731
 732         /* fill in report manufacture */
 733         if (mpt3sas_port->remote_identify.device_type ==
 734             MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
 735             mpt3sas_port->remote_identify.device_type ==
 736             MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER)
 737                 _transport_expander_report_manufacture(ioc,
 738                     mpt3sas_port->remote_identify.sas_address,
 739                     rphy_to_expander_device(rphy));
 740         return mpt3sas_port;
 741
 742  out_fail:
 743         list_for_each_entry_safe(mpt3sas_phy, next, &mpt3sas_port->phy_list,
 744             port_siblings)
 745                 list_del(&mpt3sas_phy->port_siblings);
 746         kfree(mpt3sas_port);
 747         return NULL;
 748 }
 749
 750 /**
 751  * mpt3sas_transport_port_remove - remove port from the list
 752  * @ioc: per adapter object
 753  * @sas_address: sas address of attached device
 754  * @sas_address_parent: sas address of parent expander or sas host
 755  * Context: This function will acquire ioc->sas_node_lock.
 756  *
 757  * Removing object and freeing associated memory from the
 758  * ioc->sas_port_list.
 759  */
 760 void
 761 mpt3sas_transport_port_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
 762         u64 sas_address_parent)
 763 {
 764         int i;
 765         unsigned long flags;
 766         struct _sas_port *mpt3sas_port, *next;
 767         struct _sas_node *sas_node;
 768         u8 found = 0;
 769         struct _sas_phy *mpt3sas_phy, *next_phy;
 770
 771         spin_lock_irqsave(&ioc->sas_node_lock, flags);
 772         sas_node = _transport_sas_node_find_by_sas_address(ioc,
 773             sas_address_parent);
 774         if (!sas_node) {
 775                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 776                 return;
 777         }
 778         list_for_each_entry_safe(mpt3sas_port, next, &sas_node->sas_port_list,
 779             port_list) {
 780                 if (mpt3sas_port->remote_identify.sas_address != sas_address)
 781                         continue;
 782                 found = 1;
 783                 list_del(&mpt3sas_port->port_list);
 784                 goto out;
 785         }
 786  out:
 787         if (!found) {
 788                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 789                 return;
 790         }
 791
 792         for (i = 0; i < sas_node->num_phys; i++) {
 793                 if (sas_node->phy[i].remote_identify.sas_address == sas_address)
 794                         memset(&sas_node->phy[i].remote_identify, 0 ,
 795                             sizeof(struct sas_identify));
 796         }
 797
 798         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 799
 800         list_for_each_entry_safe(mpt3sas_phy, next_phy,
 801             &mpt3sas_port->phy_list, port_siblings) {
 802                 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
 803                         dev_printk(KERN_INFO, &mpt3sas_port->port->dev,
 804                             "remove: sas_addr(0x%016llx), phy(%d)\n",
 805                             (unsigned long long)
 806                             mpt3sas_port->remote_identify.sas_address,
 807                             mpt3sas_phy->phy_id);
 808                 mpt3sas_phy->phy_belongs_to_port = 0;
 809                 if (!ioc->remove_host)
 810                         sas_port_delete_phy(mpt3sas_port->port,
 811                                                 mpt3sas_phy->phy);
 812                 list_del(&mpt3sas_phy->port_siblings);
 813         }
 814         if (!ioc->remove_host)
 815                 sas_port_delete(mpt3sas_port->port);
 816         kfree(mpt3sas_port);
 817 }
 818
 819 /**
 820  * mpt3sas_transport_add_host_phy - report sas_host phy to transport
 821  * @ioc: per adapter object
 822  * @mpt3sas_phy: mpt3sas per phy object
 823  * @phy_pg0: sas phy page 0
 824  * @parent_dev: parent device class object
 825  *
 826  * Return: 0 for success, non-zero for failure.
 827  */
 828 int
 829 mpt3sas_transport_add_host_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_phy
 830         *mpt3sas_phy, Mpi2SasPhyPage0_t phy_pg0, struct device *parent_dev)
 831 {
 832         struct sas_phy *phy;
 833         int phy_index = mpt3sas_phy->phy_id;
 834
 835
 836         INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
 837         phy = sas_phy_alloc(parent_dev, phy_index);
 838         if (!phy) {
 839                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 840                         __FILE__, __LINE__, __func__);
 841                 return -1;
 842         }
 843         if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
 844             &mpt3sas_phy->identify))) {
 845                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 846                         __FILE__, __LINE__, __func__);
 847                 sas_phy_free(phy);
 848                 return -1;
 849         }
 850         phy->identify = mpt3sas_phy->identify;
 851         mpt3sas_phy->attached_handle = le16_to_cpu(phy_pg0.AttachedDevHandle);
 852         if (mpt3sas_phy->attached_handle)
 853                 _transport_set_identify(ioc, mpt3sas_phy->attached_handle,
 854                     &mpt3sas_phy->remote_identify);
 855         phy->identify.phy_identifier = mpt3sas_phy->phy_id;
 856         phy->negotiated_linkrate = _transport_convert_phy_link_rate(
 857             phy_pg0.NegotiatedLinkRate & MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
 858         phy->minimum_linkrate_hw = _transport_convert_phy_link_rate(
 859             phy_pg0.HwLinkRate & MPI2_SAS_HWRATE_MIN_RATE_MASK);
 860         phy->maximum_linkrate_hw = _transport_convert_phy_link_rate(
 861             phy_pg0.HwLinkRate >> 4);
 862         phy->minimum_linkrate = _transport_convert_phy_link_rate(
 863             phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
 864         phy->maximum_linkrate = _transport_convert_phy_link_rate(
 865             phy_pg0.ProgrammedLinkRate >> 4);
 866
 867         if ((sas_phy_add(phy))) {
 868                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 869                         __FILE__, __LINE__, __func__);
 870                 sas_phy_free(phy);
 871                 return -1;
 872         }
 873         if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
 874                 dev_printk(KERN_INFO, &phy->dev,
 875                     "add: handle(0x%04x), sas_addr(0x%016llx)\n"
 876                     "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
 877                     mpt3sas_phy->handle, (unsigned long long)
 878                     mpt3sas_phy->identify.sas_address,
 879                     mpt3sas_phy->attached_handle,
 880                     (unsigned long long)
 881                     mpt3sas_phy->remote_identify.sas_address);
 882         mpt3sas_phy->phy = phy;
 883         return 0;
 884 }
 885
 886
 887 /**
 888  * mpt3sas_transport_add_expander_phy - report expander phy to transport
 889  * @ioc: per adapter object
 890  * @mpt3sas_phy: mpt3sas per phy object
 891  * @expander_pg1: expander page 1
 892  * @parent_dev: parent device class object
 893  *
 894  * Return: 0 for success, non-zero for failure.
 895  */
 896 int
 897 mpt3sas_transport_add_expander_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_phy
 898         *mpt3sas_phy, Mpi2ExpanderPage1_t expander_pg1,
 899         struct device *parent_dev)
 900 {
 901         struct sas_phy *phy;
 902         int phy_index = mpt3sas_phy->phy_id;
 903
 904         INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
 905         phy = sas_phy_alloc(parent_dev, phy_index);
 906         if (!phy) {
 907                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 908                         __FILE__, __LINE__, __func__);
 909                 return -1;
 910         }
 911         if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
 912             &mpt3sas_phy->identify))) {
 913                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 914                         __FILE__, __LINE__, __func__);
 915                 sas_phy_free(phy);
 916                 return -1;
 917         }
 918         phy->identify = mpt3sas_phy->identify;
 919         mpt3sas_phy->attached_handle =
 920             le16_to_cpu(expander_pg1.AttachedDevHandle);
 921         if (mpt3sas_phy->attached_handle)
 922                 _transport_set_identify(ioc, mpt3sas_phy->attached_handle,
 923                     &mpt3sas_phy->remote_identify);
 924         phy->identify.phy_identifier = mpt3sas_phy->phy_id;
 925         phy->negotiated_linkrate = _transport_convert_phy_link_rate(
 926             expander_pg1.NegotiatedLinkRate &
 927             MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
 928         phy->minimum_linkrate_hw = _transport_convert_phy_link_rate(
 929             expander_pg1.HwLinkRate & MPI2_SAS_HWRATE_MIN_RATE_MASK);
 930         phy->maximum_linkrate_hw = _transport_convert_phy_link_rate(
 931             expander_pg1.HwLinkRate >> 4);
 932         phy->minimum_linkrate = _transport_convert_phy_link_rate(
 933             expander_pg1.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
 934         phy->maximum_linkrate = _transport_convert_phy_link_rate(
 935             expander_pg1.ProgrammedLinkRate >> 4);
 936
 937         if ((sas_phy_add(phy))) {
 938                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
 939                         __FILE__, __LINE__, __func__);
 940                 sas_phy_free(phy);
 941                 return -1;
 942         }
 943         if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
 944                 dev_printk(KERN_INFO, &phy->dev,
 945                     "add: handle(0x%04x), sas_addr(0x%016llx)\n"
 946                     "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
 947                     mpt3sas_phy->handle, (unsigned long long)
 948                     mpt3sas_phy->identify.sas_address,
 949                     mpt3sas_phy->attached_handle,
 950                     (unsigned long long)
 951                     mpt3sas_phy->remote_identify.sas_address);
 952         mpt3sas_phy->phy = phy;
 953         return 0;
 954 }
 955
 956 /**
 957  * mpt3sas_transport_update_links - refreshing phy link changes
 958  * @ioc: per adapter object
 959  * @sas_address: sas address of parent expander or sas host
 960  * @handle: attached device handle
 961  * @phy_number: phy number
 962  * @link_rate: new link rate
 963  */
 964 void
 965 mpt3sas_transport_update_links(struct MPT3SAS_ADAPTER *ioc,
 966         u64 sas_address, u16 handle, u8 phy_number, u8 link_rate)
 967 {
 968         unsigned long flags;
 969         struct _sas_node *sas_node;
 970         struct _sas_phy *mpt3sas_phy;
 971
 972         if (ioc->shost_recovery || ioc->pci_error_recovery)
 973                 return;
 974
 975         spin_lock_irqsave(&ioc->sas_node_lock, flags);
 976         sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
 977         if (!sas_node) {
 978                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 979                 return;
 980         }
 981
 982         mpt3sas_phy = &sas_node->phy[phy_number];
 983         mpt3sas_phy->attached_handle = handle;
 984         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 985         if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) {
 986                 _transport_set_identify(ioc, handle,
 987                     &mpt3sas_phy->remote_identify);
 988                 _transport_add_phy_to_an_existing_port(ioc, sas_node,
 989                     mpt3sas_phy, mpt3sas_phy->remote_identify.sas_address);
 990         } else
 991                 memset(&mpt3sas_phy->remote_identify, 0 , sizeof(struct
 992                     sas_identify));
 993
 994         if (mpt3sas_phy->phy)
 995                 mpt3sas_phy->phy->negotiated_linkrate =
 996                     _transport_convert_phy_link_rate(link_rate);
 997
 998         if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
 999                 dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
1000                     "refresh: parent sas_addr(0x%016llx),\n"
1001                     "\tlink_rate(0x%02x), phy(%d)\n"
1002                     "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
1003                     (unsigned long long)sas_address,
1004                     link_rate, phy_number, handle, (unsigned long long)
1005                     mpt3sas_phy->remote_identify.sas_address);
1006 }
1007
1008 static inline void *
1009 phy_to_ioc(struct sas_phy *phy)
1010 {
1011         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
1012         return shost_priv(shost);
1013 }
1014
1015 static inline void *
1016 rphy_to_ioc(struct sas_rphy *rphy)
1017 {
1018         struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
1019         return shost_priv(shost);
1020 }
1021
1022 /* report phy error log structure */
1023 struct phy_error_log_request {
1024         u8 smp_frame_type; /* 0x40 */
1025         u8 function; /* 0x11 */
1026         u8 allocated_response_length;
1027         u8 request_length; /* 02 */
1028         u8 reserved_1[5];
1029         u8 phy_identifier;
1030         u8 reserved_2[2];
1031 };
1032
1033 /* report phy error log reply structure */
1034 struct phy_error_log_reply {
1035         u8 smp_frame_type; /* 0x41 */
1036         u8 function; /* 0x11 */
1037         u8 function_result;
1038         u8 response_length;
1039         __be16 expander_change_count;
1040         u8 reserved_1[3];
1041         u8 phy_identifier;
1042         u8 reserved_2[2];
1043         __be32 invalid_dword;
1044         __be32 running_disparity_error;
1045         __be32 loss_of_dword_sync;
1046         __be32 phy_reset_problem;
1047 };
1048
1049 /**
1050  * _transport_get_expander_phy_error_log - return expander counters
1051  * @ioc: per adapter object
1052  * @phy: The sas phy object
1053  *
1054  * Return: 0 for success, non-zero for failure.
1055  *
1056  */
1057 static int
1058 _transport_get_expander_phy_error_log(struct MPT3SAS_ADAPTER *ioc,
1059         struct sas_phy *phy)
1060 {
1061         Mpi2SmpPassthroughRequest_t *mpi_request;
1062         Mpi2SmpPassthroughReply_t *mpi_reply;
1063         struct phy_error_log_request *phy_error_log_request;
1064         struct phy_error_log_reply *phy_error_log_reply;
1065         int rc;
1066         u16 smid;
1067         void *psge;
1068         u8 issue_reset = 0;
1069         void *data_out = NULL;
1070         dma_addr_t data_out_dma;
1071         u32 sz;
1072
1073         if (ioc->shost_recovery || ioc->pci_error_recovery) {
1074                 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
1075                 return -EFAULT;
1076         }
1077
1078         mutex_lock(&ioc->transport_cmds.mutex);
1079
1080         if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1081                 ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
1082                 rc = -EAGAIN;
1083                 goto out;
1084         }
1085         ioc->transport_cmds.status = MPT3_CMD_PENDING;
1086
1087         rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
1088         if (rc)
1089                 goto out;
1090
1091         smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1092         if (!smid) {
1093                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1094                 rc = -EAGAIN;
1095                 goto out;
1096         }
1097
1098         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1099         ioc->transport_cmds.smid = smid;
1100
1101         sz = sizeof(struct phy_error_log_request) +
1102             sizeof(struct phy_error_log_reply);
1103         data_out = dma_alloc_coherent(&ioc->pdev->dev, sz, &data_out_dma,
1104                         GFP_KERNEL);
1105         if (!data_out) {
1106                 pr_err("failure at %s:%d/%s()!\n", __FILE__,
1107                     __LINE__, __func__);
1108                 rc = -ENOMEM;
1109                 mpt3sas_base_free_smid(ioc, smid);
1110                 goto out;
1111         }
1112
1113         rc = -EINVAL;
1114         memset(data_out, 0, sz);
1115         phy_error_log_request = data_out;
1116         phy_error_log_request->smp_frame_type = 0x40;
1117         phy_error_log_request->function = 0x11;
1118         phy_error_log_request->request_length = 2;
1119         phy_error_log_request->allocated_response_length = 0;
1120         phy_error_log_request->phy_identifier = phy->number;
1121
1122         memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1123         mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1124         mpi_request->PhysicalPort = 0xFF;
1125         mpi_request->VF_ID = 0; /* TODO */
1126         mpi_request->VP_ID = 0;
1127         mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1128         mpi_request->RequestDataLength =
1129             cpu_to_le16(sizeof(struct phy_error_log_request));
1130         psge = &mpi_request->SGL;
1131
1132         ioc->build_sg(ioc, psge, data_out_dma,
1133                 sizeof(struct phy_error_log_request),
1134             data_out_dma + sizeof(struct phy_error_log_request),
1135             sizeof(struct phy_error_log_reply));
1136
1137         dtransportprintk(ioc,
1138                          ioc_info(ioc, "phy_error_log - send to sas_addr(0x%016llx), phy(%d)\n",
1139                                   (u64)phy->identify.sas_address,
1140                                   phy->number));
1141         init_completion(&ioc->transport_cmds.done);
1142         ioc->put_smid_default(ioc, smid);
1143         wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
1144
1145         if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1146                 ioc_err(ioc, "%s: timeout\n", __func__);
1147                 _debug_dump_mf(mpi_request,
1148                     sizeof(Mpi2SmpPassthroughRequest_t)/4);
1149                 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1150                         issue_reset = 1;
1151                 goto issue_host_reset;
1152         }
1153
1154         dtransportprintk(ioc, ioc_info(ioc, "phy_error_log - complete\n"));
1155
1156         if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1157
1158                 mpi_reply = ioc->transport_cmds.reply;
1159
1160                 dtransportprintk(ioc,
1161                                  ioc_info(ioc, "phy_error_log - reply data transfer size(%d)\n",
1162                                           le16_to_cpu(mpi_reply->ResponseDataLength)));
1163
1164                 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1165                     sizeof(struct phy_error_log_reply))
1166                         goto out;
1167
1168                 phy_error_log_reply = data_out +
1169                     sizeof(struct phy_error_log_request);
1170
1171                 dtransportprintk(ioc,
1172                                  ioc_info(ioc, "phy_error_log - function_result(%d)\n",
1173                                           phy_error_log_reply->function_result));
1174
1175                 phy->invalid_dword_count =
1176                     be32_to_cpu(phy_error_log_reply->invalid_dword);
1177                 phy->running_disparity_error_count =
1178                     be32_to_cpu(phy_error_log_reply->running_disparity_error);
1179                 phy->loss_of_dword_sync_count =
1180                     be32_to_cpu(phy_error_log_reply->loss_of_dword_sync);
1181                 phy->phy_reset_problem_count =
1182                     be32_to_cpu(phy_error_log_reply->phy_reset_problem);
1183                 rc = 0;
1184         } else
1185                 dtransportprintk(ioc,
1186                                  ioc_info(ioc, "phy_error_log - no reply\n"));
1187
1188  issue_host_reset:
1189         if (issue_reset)
1190                 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
1191  out:
1192         ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1193         if (data_out)
1194                 dma_free_coherent(&ioc->pdev->dev, sz, data_out, data_out_dma);
1195
1196         mutex_unlock(&ioc->transport_cmds.mutex);
1197         return rc;
1198 }
1199
1200 /**
1201  * _transport_get_linkerrors - return phy counters for both hba and expanders
1202  * @phy: The sas phy object
1203  *
1204  * Return: 0 for success, non-zero for failure.
1205  *
1206  */
1207 static int
1208 _transport_get_linkerrors(struct sas_phy *phy)
1209 {
1210         struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1211         unsigned long flags;
1212         Mpi2ConfigReply_t mpi_reply;
1213         Mpi2SasPhyPage1_t phy_pg1;
1214
1215         spin_lock_irqsave(&ioc->sas_node_lock, flags);
1216         if (_transport_sas_node_find_by_sas_address(ioc,
1217             phy->identify.sas_address) == NULL) {
1218                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1219                 return -EINVAL;
1220         }
1221         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1222
1223         if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1224                 return _transport_get_expander_phy_error_log(ioc, phy);
1225
1226         /* get hba phy error logs */
1227         if ((mpt3sas_config_get_phy_pg1(ioc, &mpi_reply, &phy_pg1,
1228                     phy->number))) {
1229                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1230                         __FILE__, __LINE__, __func__);
1231                 return -ENXIO;
1232         }
1233
1234         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1235                 ioc_info(ioc, "phy(%d), ioc_status (0x%04x), loginfo(0x%08x)\n",
1236                          phy->number,
1237                          le16_to_cpu(mpi_reply.IOCStatus),
1238                          le32_to_cpu(mpi_reply.IOCLogInfo));
1239
1240         phy->invalid_dword_count = le32_to_cpu(phy_pg1.InvalidDwordCount);
1241         phy->running_disparity_error_count =
1242             le32_to_cpu(phy_pg1.RunningDisparityErrorCount);
1243         phy->loss_of_dword_sync_count =
1244             le32_to_cpu(phy_pg1.LossDwordSynchCount);
1245         phy->phy_reset_problem_count =
1246             le32_to_cpu(phy_pg1.PhyResetProblemCount);
1247         return 0;
1248 }
1249
1250 /**
1251  * _transport_get_enclosure_identifier -
1252  * @rphy: The sas phy object
1253  * @identifier: ?
1254  *
1255  * Obtain the enclosure logical id for an expander.
1256  * Return: 0 for success, non-zero for failure.
1257  */
1258 static int
1259 _transport_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1260 {
1261         struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1262         struct _sas_device *sas_device;
1263         unsigned long flags;
1264         int rc;
1265
1266         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1267         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1268             rphy->identify.sas_address);
1269         if (sas_device) {
1270                 *identifier = sas_device->enclosure_logical_id;
1271                 rc = 0;
1272                 sas_device_put(sas_device);
1273         } else {
1274                 *identifier = 0;
1275                 rc = -ENXIO;
1276         }
1277
1278         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1279         return rc;
1280 }
1281
1282 /**
1283  * _transport_get_bay_identifier -
1284  * @rphy: The sas phy object
1285  *
1286  * Return: the slot id for a device that resides inside an enclosure.
1287  */
1288 static int
1289 _transport_get_bay_identifier(struct sas_rphy *rphy)
1290 {
1291         struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1292         struct _sas_device *sas_device;
1293         unsigned long flags;
1294         int rc;
1295
1296         spin_lock_irqsave(&ioc->sas_device_lock, flags);
1297         sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1298             rphy->identify.sas_address);
1299         if (sas_device) {
1300                 rc = sas_device->slot;
1301                 sas_device_put(sas_device);
1302         } else {
1303                 rc = -ENXIO;
1304         }
1305         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1306         return rc;
1307 }
1308
1309 /* phy control request structure */
1310 struct phy_control_request {
1311         u8 smp_frame_type; /* 0x40 */
1312         u8 function; /* 0x91 */
1313         u8 allocated_response_length;
1314         u8 request_length; /* 0x09 */
1315         u16 expander_change_count;
1316         u8 reserved_1[3];
1317         u8 phy_identifier;
1318         u8 phy_operation;
1319         u8 reserved_2[13];
1320         u64 attached_device_name;
1321         u8 programmed_min_physical_link_rate;
1322         u8 programmed_max_physical_link_rate;
1323         u8 reserved_3[6];
1324 };
1325
1326 /* phy control reply structure */
1327 struct phy_control_reply {
1328         u8 smp_frame_type; /* 0x41 */
1329         u8 function; /* 0x11 */
1330         u8 function_result;
1331         u8 response_length;
1332 };
1333
1334 #define SMP_PHY_CONTROL_LINK_RESET      (0x01)
1335 #define SMP_PHY_CONTROL_HARD_RESET      (0x02)
1336 #define SMP_PHY_CONTROL_DISABLE         (0x03)
1337
1338 /**
1339  * _transport_expander_phy_control - expander phy control
1340  * @ioc: per adapter object
1341  * @phy: The sas phy object
1342  * @phy_operation: ?
1343  *
1344  * Return: 0 for success, non-zero for failure.
1345  *
1346  */
1347 static int
1348 _transport_expander_phy_control(struct MPT3SAS_ADAPTER *ioc,
1349         struct sas_phy *phy, u8 phy_operation)
1350 {
1351         Mpi2SmpPassthroughRequest_t *mpi_request;
1352         Mpi2SmpPassthroughReply_t *mpi_reply;
1353         struct phy_control_request *phy_control_request;
1354         struct phy_control_reply *phy_control_reply;
1355         int rc;
1356         u16 smid;
1357         void *psge;
1358         u8 issue_reset = 0;
1359         void *data_out = NULL;
1360         dma_addr_t data_out_dma;
1361         u32 sz;
1362
1363         if (ioc->shost_recovery || ioc->pci_error_recovery) {
1364                 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
1365                 return -EFAULT;
1366         }
1367
1368         mutex_lock(&ioc->transport_cmds.mutex);
1369
1370         if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1371                 ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
1372                 rc = -EAGAIN;
1373                 goto out;
1374         }
1375         ioc->transport_cmds.status = MPT3_CMD_PENDING;
1376
1377         rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
1378         if (rc)
1379                 goto out;
1380
1381         smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1382         if (!smid) {
1383                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1384                 rc = -EAGAIN;
1385                 goto out;
1386         }
1387
1388         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1389         ioc->transport_cmds.smid = smid;
1390
1391         sz = sizeof(struct phy_control_request) +
1392             sizeof(struct phy_control_reply);
1393         data_out = dma_alloc_coherent(&ioc->pdev->dev, sz, &data_out_dma,
1394                         GFP_KERNEL);
1395         if (!data_out) {
1396                 pr_err("failure at %s:%d/%s()!\n", __FILE__,
1397                     __LINE__, __func__);
1398                 rc = -ENOMEM;
1399                 mpt3sas_base_free_smid(ioc, smid);
1400                 goto out;
1401         }
1402
1403         rc = -EINVAL;
1404         memset(data_out, 0, sz);
1405         phy_control_request = data_out;
1406         phy_control_request->smp_frame_type = 0x40;
1407         phy_control_request->function = 0x91;
1408         phy_control_request->request_length = 9;
1409         phy_control_request->allocated_response_length = 0;
1410         phy_control_request->phy_identifier = phy->number;
1411         phy_control_request->phy_operation = phy_operation;
1412         phy_control_request->programmed_min_physical_link_rate =
1413             phy->minimum_linkrate << 4;
1414         phy_control_request->programmed_max_physical_link_rate =
1415             phy->maximum_linkrate << 4;
1416
1417         memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1418         mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1419         mpi_request->PhysicalPort = 0xFF;
1420         mpi_request->VF_ID = 0; /* TODO */
1421         mpi_request->VP_ID = 0;
1422         mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1423         mpi_request->RequestDataLength =
1424             cpu_to_le16(sizeof(struct phy_error_log_request));
1425         psge = &mpi_request->SGL;
1426
1427         ioc->build_sg(ioc, psge, data_out_dma,
1428                             sizeof(struct phy_control_request),
1429             data_out_dma + sizeof(struct phy_control_request),
1430             sizeof(struct phy_control_reply));
1431
1432         dtransportprintk(ioc,
1433                          ioc_info(ioc, "phy_control - send to sas_addr(0x%016llx), phy(%d), opcode(%d)\n",
1434                                   (u64)phy->identify.sas_address,
1435                                   phy->number, phy_operation));
1436         init_completion(&ioc->transport_cmds.done);
1437         ioc->put_smid_default(ioc, smid);
1438         wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
1439
1440         if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1441                 ioc_err(ioc, "%s: timeout\n", __func__);
1442                 _debug_dump_mf(mpi_request,
1443                     sizeof(Mpi2SmpPassthroughRequest_t)/4);
1444                 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1445                         issue_reset = 1;
1446                 goto issue_host_reset;
1447         }
1448
1449         dtransportprintk(ioc, ioc_info(ioc, "phy_control - complete\n"));
1450
1451         if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1452
1453                 mpi_reply = ioc->transport_cmds.reply;
1454
1455                 dtransportprintk(ioc,
1456                                  ioc_info(ioc, "phy_control - reply data transfer size(%d)\n",
1457                                           le16_to_cpu(mpi_reply->ResponseDataLength)));
1458
1459                 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1460                     sizeof(struct phy_control_reply))
1461                         goto out;
1462
1463                 phy_control_reply = data_out +
1464                     sizeof(struct phy_control_request);
1465
1466                 dtransportprintk(ioc,
1467                                  ioc_info(ioc, "phy_control - function_result(%d)\n",
1468                                           phy_control_reply->function_result));
1469
1470                 rc = 0;
1471         } else
1472                 dtransportprintk(ioc,
1473                                  ioc_info(ioc, "phy_control - no reply\n"));
1474
1475  issue_host_reset:
1476         if (issue_reset)
1477                 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
1478  out:
1479         ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1480         if (data_out)
1481                 dma_free_coherent(&ioc->pdev->dev, sz, data_out,
1482                                 data_out_dma);
1483
1484         mutex_unlock(&ioc->transport_cmds.mutex);
1485         return rc;
1486 }
1487
1488 /**
1489  * _transport_phy_reset -
1490  * @phy: The sas phy object
1491  * @hard_reset:
1492  *
1493  * Return: 0 for success, non-zero for failure.
1494  */
1495 static int
1496 _transport_phy_reset(struct sas_phy *phy, int hard_reset)
1497 {
1498         struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1499         Mpi2SasIoUnitControlReply_t mpi_reply;
1500         Mpi2SasIoUnitControlRequest_t mpi_request;
1501         unsigned long flags;
1502
1503         spin_lock_irqsave(&ioc->sas_node_lock, flags);
1504         if (_transport_sas_node_find_by_sas_address(ioc,
1505             phy->identify.sas_address) == NULL) {
1506                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1507                 return -EINVAL;
1508         }
1509         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1510
1511         /* handle expander phys */
1512         if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1513                 return _transport_expander_phy_control(ioc, phy,
1514                     (hard_reset == 1) ? SMP_PHY_CONTROL_HARD_RESET :
1515                     SMP_PHY_CONTROL_LINK_RESET);
1516
1517         /* handle hba phys */
1518         memset(&mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
1519         mpi_request.Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
1520         mpi_request.Operation = hard_reset ?
1521             MPI2_SAS_OP_PHY_HARD_RESET : MPI2_SAS_OP_PHY_LINK_RESET;
1522         mpi_request.PhyNum = phy->number;
1523
1524         if ((mpt3sas_base_sas_iounit_control(ioc, &mpi_reply, &mpi_request))) {
1525                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1526                         __FILE__, __LINE__, __func__);
1527                 return -ENXIO;
1528         }
1529
1530         if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1531                 ioc_info(ioc, "phy(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
1532                          phy->number, le16_to_cpu(mpi_reply.IOCStatus),
1533                          le32_to_cpu(mpi_reply.IOCLogInfo));
1534
1535         return 0;
1536 }
1537
1538 /**
1539  * _transport_phy_enable - enable/disable phys
1540  * @phy: The sas phy object
1541  * @enable: enable phy when true
1542  *
1543  * Only support sas_host direct attached phys.
1544  * Return: 0 for success, non-zero for failure.
1545  */
1546 static int
1547 _transport_phy_enable(struct sas_phy *phy, int enable)
1548 {
1549         struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1550         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1551         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
1552         Mpi2ConfigReply_t mpi_reply;
1553         u16 ioc_status;
1554         u16 sz;
1555         int rc = 0;
1556         unsigned long flags;
1557         int i, discovery_active;
1558
1559         spin_lock_irqsave(&ioc->sas_node_lock, flags);
1560         if (_transport_sas_node_find_by_sas_address(ioc,
1561             phy->identify.sas_address) == NULL) {
1562                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1563                 return -EINVAL;
1564         }
1565         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1566
1567         /* handle expander phys */
1568         if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1569                 return _transport_expander_phy_control(ioc, phy,
1570                     (enable == 1) ? SMP_PHY_CONTROL_LINK_RESET :
1571                     SMP_PHY_CONTROL_DISABLE);
1572
1573         /* handle hba phys */
1574
1575         /* read sas_iounit page 0 */
1576         sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
1577             sizeof(Mpi2SasIOUnit0PhyData_t));
1578         sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
1579         if (!sas_iounit_pg0) {
1580                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1581                         __FILE__, __LINE__, __func__);
1582                 rc = -ENOMEM;
1583                 goto out;
1584         }
1585         if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
1586             sas_iounit_pg0, sz))) {
1587                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1588                         __FILE__, __LINE__, __func__);
1589                 rc = -ENXIO;
1590                 goto out;
1591         }
1592         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1593             MPI2_IOCSTATUS_MASK;
1594         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1595                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1596                         __FILE__, __LINE__, __func__);
1597                 rc = -EIO;
1598                 goto out;
1599         }
1600
1601         /* unable to enable/disable phys when when discovery is active */
1602         for (i = 0, discovery_active = 0; i < ioc->sas_hba.num_phys ; i++) {
1603                 if (sas_iounit_pg0->PhyData[i].PortFlags &
1604                     MPI2_SASIOUNIT0_PORTFLAGS_DISCOVERY_IN_PROGRESS) {
1605                         ioc_err(ioc, "discovery is active on port = %d, phy = %d: unable to enable/disable phys, try again later!\n",
1606                                 sas_iounit_pg0->PhyData[i].Port, i);
1607                         discovery_active = 1;
1608                 }
1609         }
1610
1611         if (discovery_active) {
1612                 rc = -EAGAIN;
1613                 goto out;
1614         }
1615
1616         /* read sas_iounit page 1 */
1617         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1618             sizeof(Mpi2SasIOUnit1PhyData_t));
1619         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1620         if (!sas_iounit_pg1) {
1621                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1622                         __FILE__, __LINE__, __func__);
1623                 rc = -ENOMEM;
1624                 goto out;
1625         }
1626         if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1627             sas_iounit_pg1, sz))) {
1628                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1629                         __FILE__, __LINE__, __func__);
1630                 rc = -ENXIO;
1631                 goto out;
1632         }
1633         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1634             MPI2_IOCSTATUS_MASK;
1635         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1636                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1637                         __FILE__, __LINE__, __func__);
1638                 rc = -EIO;
1639                 goto out;
1640         }
1641
1642         /* copy Port/PortFlags/PhyFlags from page 0 */
1643         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
1644                 sas_iounit_pg1->PhyData[i].Port =
1645                     sas_iounit_pg0->PhyData[i].Port;
1646                 sas_iounit_pg1->PhyData[i].PortFlags =
1647                     (sas_iounit_pg0->PhyData[i].PortFlags &
1648                     MPI2_SASIOUNIT0_PORTFLAGS_AUTO_PORT_CONFIG);
1649                 sas_iounit_pg1->PhyData[i].PhyFlags =
1650                     (sas_iounit_pg0->PhyData[i].PhyFlags &
1651                     (MPI2_SASIOUNIT0_PHYFLAGS_ZONING_ENABLED +
1652                     MPI2_SASIOUNIT0_PHYFLAGS_PHY_DISABLED));
1653         }
1654
1655         if (enable)
1656                 sas_iounit_pg1->PhyData[phy->number].PhyFlags
1657                     &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1658         else
1659                 sas_iounit_pg1->PhyData[phy->number].PhyFlags
1660                     |= MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1661
1662         mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1, sz);
1663
1664         /* link reset */
1665         if (enable)
1666                 _transport_phy_reset(phy, 0);
1667
1668  out:
1669         kfree(sas_iounit_pg1);
1670         kfree(sas_iounit_pg0);
1671         return rc;
1672 }
1673
1674 /**
1675  * _transport_phy_speed - set phy min/max link rates
1676  * @phy: The sas phy object
1677  * @rates: rates defined in sas_phy_linkrates
1678  *
1679  * Only support sas_host direct attached phys.
1680  *
1681  * Return: 0 for success, non-zero for failure.
1682  */
1683 static int
1684 _transport_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates)
1685 {
1686         struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1687         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1688         Mpi2SasPhyPage0_t phy_pg0;
1689         Mpi2ConfigReply_t mpi_reply;
1690         u16 ioc_status;
1691         u16 sz;
1692         int i;
1693         int rc = 0;
1694         unsigned long flags;
1695
1696         spin_lock_irqsave(&ioc->sas_node_lock, flags);
1697         if (_transport_sas_node_find_by_sas_address(ioc,
1698             phy->identify.sas_address) == NULL) {
1699                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1700                 return -EINVAL;
1701         }
1702         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1703
1704         if (!rates->minimum_linkrate)
1705                 rates->minimum_linkrate = phy->minimum_linkrate;
1706         else if (rates->minimum_linkrate < phy->minimum_linkrate_hw)
1707                 rates->minimum_linkrate = phy->minimum_linkrate_hw;
1708
1709         if (!rates->maximum_linkrate)
1710                 rates->maximum_linkrate = phy->maximum_linkrate;
1711         else if (rates->maximum_linkrate > phy->maximum_linkrate_hw)
1712                 rates->maximum_linkrate = phy->maximum_linkrate_hw;
1713
1714         /* handle expander phys */
1715         if (phy->identify.sas_address != ioc->sas_hba.sas_address) {
1716                 phy->minimum_linkrate = rates->minimum_linkrate;
1717                 phy->maximum_linkrate = rates->maximum_linkrate;
1718                 return _transport_expander_phy_control(ioc, phy,
1719                     SMP_PHY_CONTROL_LINK_RESET);
1720         }
1721
1722         /* handle hba phys */
1723
1724         /* sas_iounit page 1 */
1725         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1726             sizeof(Mpi2SasIOUnit1PhyData_t));
1727         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1728         if (!sas_iounit_pg1) {
1729                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1730                         __FILE__, __LINE__, __func__);
1731                 rc = -ENOMEM;
1732                 goto out;
1733         }
1734         if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1735             sas_iounit_pg1, sz))) {
1736                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1737                         __FILE__, __LINE__, __func__);
1738                 rc = -ENXIO;
1739                 goto out;
1740         }
1741         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1742             MPI2_IOCSTATUS_MASK;
1743         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1744                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1745                         __FILE__, __LINE__, __func__);
1746                 rc = -EIO;
1747                 goto out;
1748         }
1749
1750         for (i = 0; i < ioc->sas_hba.num_phys; i++) {
1751                 if (phy->number != i) {
1752                         sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1753                             (ioc->sas_hba.phy[i].phy->minimum_linkrate +
1754                             (ioc->sas_hba.phy[i].phy->maximum_linkrate << 4));
1755                 } else {
1756                         sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1757                             (rates->minimum_linkrate +
1758                             (rates->maximum_linkrate << 4));
1759                 }
1760         }
1761
1762         if (mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
1763             sz)) {
1764                 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1765                         __FILE__, __LINE__, __func__);
1766                 rc = -ENXIO;
1767                 goto out;
1768         }
1769
1770         /* link reset */
1771         _transport_phy_reset(phy, 0);
1772
1773         /* read phy page 0, then update the rates in the sas transport phy */
1774         if (!mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
1775             phy->number)) {
1776                 phy->minimum_linkrate = _transport_convert_phy_link_rate(
1777                     phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
1778                 phy->maximum_linkrate = _transport_convert_phy_link_rate(
1779                     phy_pg0.ProgrammedLinkRate >> 4);
1780                 phy->negotiated_linkrate = _transport_convert_phy_link_rate(
1781                     phy_pg0.NegotiatedLinkRate &
1782                     MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
1783         }
1784
1785  out:
1786         kfree(sas_iounit_pg1);
1787         return rc;
1788 }
1789
1790 static int
1791 _transport_map_smp_buffer(struct device *dev, struct bsg_buffer *buf,
1792                 dma_addr_t *dma_addr, size_t *dma_len, void **p)
1793 {
1794         /* Check if the request is split across multiple segments */
1795         if (buf->sg_cnt > 1) {
1796                 *p = dma_alloc_coherent(dev, buf->payload_len, dma_addr,
1797                                 GFP_KERNEL);
1798                 if (!*p)
1799                         return -ENOMEM;
1800                 *dma_len = buf->payload_len;
1801         } else {
1802                 if (!dma_map_sg(dev, buf->sg_list, 1, DMA_BIDIRECTIONAL))
1803                         return -ENOMEM;
1804                 *dma_addr = sg_dma_address(buf->sg_list);
1805                 *dma_len = sg_dma_len(buf->sg_list);
1806                 *p = NULL;
1807         }
1808
1809         return 0;
1810 }
1811
1812 static void
1813 _transport_unmap_smp_buffer(struct device *dev, struct bsg_buffer *buf,
1814                 dma_addr_t dma_addr, void *p)
1815 {
1816         if (p)
1817                 dma_free_coherent(dev, buf->payload_len, p, dma_addr);
1818         else
1819                 dma_unmap_sg(dev, buf->sg_list, 1, DMA_BIDIRECTIONAL);
1820 }
1821
1822 /**
1823  * _transport_smp_handler - transport portal for smp passthru
1824  * @job: ?
1825  * @shost: shost object
1826  * @rphy: sas transport rphy object
1827  *
1828  * This used primarily for smp_utils.
1829  * Example:
1830  *           smp_rep_general /sys/class/bsg/expander-5:0
1831  */
1832 static void
1833 _transport_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
1834                 struct sas_rphy *rphy)
1835 {
1836         struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1837         Mpi2SmpPassthroughRequest_t *mpi_request;
1838         Mpi2SmpPassthroughReply_t *mpi_reply;
1839         int rc;
1840         u16 smid;
1841         void *psge;
1842         dma_addr_t dma_addr_in;
1843         dma_addr_t dma_addr_out;
1844         void *addr_in = NULL;
1845         void *addr_out = NULL;
1846         size_t dma_len_in;
1847         size_t dma_len_out;
1848         unsigned int reslen = 0;
1849
1850         if (ioc->shost_recovery || ioc->pci_error_recovery) {
1851                 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
1852                 rc = -EFAULT;
1853                 goto job_done;
1854         }
1855
1856         rc = mutex_lock_interruptible(&ioc->transport_cmds.mutex);
1857         if (rc)
1858                 goto job_done;
1859
1860         if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1861                 ioc_err(ioc, "%s: transport_cmds in use\n",
1862                         __func__);
1863                 rc = -EAGAIN;
1864                 goto out;
1865         }
1866         ioc->transport_cmds.status = MPT3_CMD_PENDING;
1867
1868         rc = _transport_map_smp_buffer(&ioc->pdev->dev, &job->request_payload,
1869                         &dma_addr_out, &dma_len_out, &addr_out);
1870         if (rc)
1871                 goto out;
1872         if (addr_out) {
1873                 sg_copy_to_buffer(job->request_payload.sg_list,
1874                                 job->request_payload.sg_cnt, addr_out,
1875                                 job->request_payload.payload_len);
1876         }
1877
1878         rc = _transport_map_smp_buffer(&ioc->pdev->dev, &job->reply_payload,
1879                         &dma_addr_in, &dma_len_in, &addr_in);
1880         if (rc)
1881                 goto unmap_out;
1882
1883         rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
1884         if (rc)
1885                 goto unmap_in;
1886
1887         smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1888         if (!smid) {
1889                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1890                 rc = -EAGAIN;
1891                 goto unmap_in;
1892         }
1893
1894         rc = 0;
1895         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1896         ioc->transport_cmds.smid = smid;
1897
1898         memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1899         mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1900         mpi_request->PhysicalPort = 0xFF;
1901         mpi_request->SASAddress = (rphy) ?
1902             cpu_to_le64(rphy->identify.sas_address) :
1903             cpu_to_le64(ioc->sas_hba.sas_address);
1904         mpi_request->RequestDataLength = cpu_to_le16(dma_len_out - 4);
1905         psge = &mpi_request->SGL;
1906
1907         ioc->build_sg(ioc, psge, dma_addr_out, dma_len_out - 4, dma_addr_in,
1908                         dma_len_in - 4);
1909
1910         dtransportprintk(ioc,
1911                          ioc_info(ioc, "%s: sending smp request\n", __func__));
1912
1913         init_completion(&ioc->transport_cmds.done);
1914         ioc->put_smid_default(ioc, smid);
1915         wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
1916
1917         if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1918                 ioc_err(ioc, "%s: timeout\n", __func__);
1919                 _debug_dump_mf(mpi_request,
1920                     sizeof(Mpi2SmpPassthroughRequest_t)/4);
1921                 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET)) {
1922                         mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
1923                         rc = -ETIMEDOUT;
1924                         goto unmap_in;
1925                 }
1926         }
1927
1928         dtransportprintk(ioc, ioc_info(ioc, "%s - complete\n", __func__));
1929
1930         if (!(ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID)) {
1931                 dtransportprintk(ioc,
1932                                  ioc_info(ioc, "%s: no reply\n", __func__));
1933                 rc = -ENXIO;
1934                 goto unmap_in;
1935         }
1936
1937         mpi_reply = ioc->transport_cmds.reply;
1938
1939         dtransportprintk(ioc,
1940                          ioc_info(ioc, "%s: reply data transfer size(%d)\n",
1941                                   __func__,
1942                                   le16_to_cpu(mpi_reply->ResponseDataLength)));
1943
1944         memcpy(job->reply, mpi_reply, sizeof(*mpi_reply));
1945         job->reply_len = sizeof(*mpi_reply);
1946         reslen = le16_to_cpu(mpi_reply->ResponseDataLength);
1947
1948         if (addr_in) {
1949                 sg_copy_to_buffer(job->reply_payload.sg_list,
1950                                 job->reply_payload.sg_cnt, addr_in,
1951                                 job->reply_payload.payload_len);
1952         }
1953
1954         rc = 0;
1955  unmap_in:
1956         _transport_unmap_smp_buffer(&ioc->pdev->dev, &job->reply_payload,
1957                         dma_addr_in, addr_in);
1958  unmap_out:
1959         _transport_unmap_smp_buffer(&ioc->pdev->dev, &job->request_payload,
1960                         dma_addr_out, addr_out);
1961  out:
1962         ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1963         mutex_unlock(&ioc->transport_cmds.mutex);
1964 job_done:
1965         bsg_job_done(job, rc, reslen);
1966 }
1967
1968 struct sas_function_template mpt3sas_transport_functions = {
1969         .get_linkerrors         = _transport_get_linkerrors,
1970         .get_enclosure_identifier = _transport_get_enclosure_identifier,
1971         .get_bay_identifier     = _transport_get_bay_identifier,
1972         .phy_reset              = _transport_phy_reset,
1973         .phy_enable             = _transport_phy_enable,
1974         .set_phy_speed          = _transport_phy_speed,
1975         .smp_handler            = _transport_smp_handler,
1976 };
1977
1978 struct scsi_transport_template *mpt3sas_transport_template;