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