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