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