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