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