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