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