1 /* 2 * This file is provided under a dual BSD/GPLv2 license. When using or 3 * redistributing this file, you may do so under either license. 4 * 5 * GPL LICENSE SUMMARY 6 * 7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of version 2 of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 21 * The full GNU General Public License is included in this distribution 22 * in the file called LICENSE.GPL. 23 * 24 * BSD LICENSE 25 * 26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 27 * All rights reserved. 28 * 29 * Redistribution and use in source and binary forms, with or without 30 * modification, are permitted provided that the following conditions 31 * are met: 32 * 33 * * Redistributions of source code must retain the above copyright 34 * notice, this list of conditions and the following disclaimer. 35 * * Redistributions in binary form must reproduce the above copyright 36 * notice, this list of conditions and the following disclaimer in 37 * the documentation and/or other materials provided with the 38 * distribution. 39 * * Neither the name of Intel Corporation nor the names of its 40 * contributors may be used to endorse or promote products derived 41 * from this software without specific prior written permission. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 54 */ 55 56 #include "host.h" 57 58 #define SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT (10) 59 #define SCIC_SDS_APC_RECONFIGURATION_TIMEOUT (10) 60 #define SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION (1000) 61 62 enum SCIC_SDS_APC_ACTIVITY { 63 SCIC_SDS_APC_SKIP_PHY, 64 SCIC_SDS_APC_ADD_PHY, 65 SCIC_SDS_APC_START_TIMER, 66 67 SCIC_SDS_APC_ACTIVITY_MAX 68 }; 69 70 /* 71 * ****************************************************************************** 72 * General port configuration agent routines 73 * ****************************************************************************** */ 74 75 /** 76 * sci_sas_address_compare() 77 * @address_one: A SAS Address to be compared. 78 * @address_two: A SAS Address to be compared. 79 * 80 * Compare the two SAS Address and if SAS Address One is greater than SAS 81 * Address Two then return > 0 else if SAS Address One is less than SAS Address 82 * Two return < 0 Otherwise they are the same return 0 A signed value of x > 0 83 * > y where x is returned for Address One > Address Two y is returned for 84 * Address One < Address Two 0 is returned ofr Address One = Address Two 85 */ 86 static s32 sci_sas_address_compare( 87 struct sci_sas_address address_one, 88 struct sci_sas_address address_two) 89 { 90 if (address_one.high > address_two.high) { 91 return 1; 92 } else if (address_one.high < address_two.high) { 93 return -1; 94 } else if (address_one.low > address_two.low) { 95 return 1; 96 } else if (address_one.low < address_two.low) { 97 return -1; 98 } 99 100 /* The two SAS Address must be identical */ 101 return 0; 102 } 103 104 /** 105 * sci_port_configuration_agent_find_port() 106 * @ihost: The controller object used for the port search. 107 * @iphy: The phy object to match. 108 * 109 * This routine will find a matching port for the phy. This means that the 110 * port and phy both have the same broadcast sas address and same received sas 111 * address. The port address or the NULL if there is no matching 112 * port. port address if the port can be found to match the phy. 113 * NULL if there is no matching port for the phy. 114 */ 115 static struct isci_port *sci_port_configuration_agent_find_port( 116 struct isci_host *ihost, 117 struct isci_phy *iphy) 118 { 119 u8 i; 120 struct sci_sas_address port_sas_address; 121 struct sci_sas_address port_attached_device_address; 122 struct sci_sas_address phy_sas_address; 123 struct sci_sas_address phy_attached_device_address; 124 125 /* 126 * Since this phy can be a member of a wide port check to see if one or 127 * more phys match the sent and received SAS address as this phy in which 128 * case it should participate in the same port. 129 */ 130 sci_phy_get_sas_address(iphy, &phy_sas_address); 131 sci_phy_get_attached_sas_address(iphy, &phy_attached_device_address); 132 133 for (i = 0; i < ihost->logical_port_entries; i++) { 134 struct isci_port *iport = &ihost->ports[i]; 135 136 sci_port_get_sas_address(iport, &port_sas_address); 137 sci_port_get_attached_sas_address(iport, &port_attached_device_address); 138 139 if (sci_sas_address_compare(port_sas_address, phy_sas_address) == 0 && 140 sci_sas_address_compare(port_attached_device_address, phy_attached_device_address) == 0) 141 return iport; 142 } 143 144 return NULL; 145 } 146 147 /** 148 * sci_port_configuration_agent_validate_ports() 149 * @ihost: This is the controller object that contains the port agent 150 * @port_agent: This is the port configuration agent for the controller. 151 * 152 * This routine will validate the port configuration is correct for the SCU 153 * hardware. The SCU hardware allows for port configurations as follows. LP0 154 * -> (PE0), (PE0, PE1), (PE0, PE1, PE2, PE3) LP1 -> (PE1) LP2 -> (PE2), (PE2, 155 * PE3) LP3 -> (PE3) enum sci_status SCI_SUCCESS the port configuration is valid for 156 * this port configuration agent. SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION 157 * the port configuration is not valid for this port configuration agent. 158 */ 159 static enum sci_status sci_port_configuration_agent_validate_ports( 160 struct isci_host *ihost, 161 struct sci_port_configuration_agent *port_agent) 162 { 163 struct sci_sas_address first_address; 164 struct sci_sas_address second_address; 165 166 /* 167 * Sanity check the max ranges for all the phys the max index 168 * is always equal to the port range index */ 169 if (port_agent->phy_valid_port_range[0].max_index != 0 || 170 port_agent->phy_valid_port_range[1].max_index != 1 || 171 port_agent->phy_valid_port_range[2].max_index != 2 || 172 port_agent->phy_valid_port_range[3].max_index != 3) 173 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 174 175 /* 176 * This is a request to configure a single x4 port or at least attempt 177 * to make all the phys into a single port */ 178 if (port_agent->phy_valid_port_range[0].min_index == 0 && 179 port_agent->phy_valid_port_range[1].min_index == 0 && 180 port_agent->phy_valid_port_range[2].min_index == 0 && 181 port_agent->phy_valid_port_range[3].min_index == 0) 182 return SCI_SUCCESS; 183 184 /* 185 * This is a degenerate case where phy 1 and phy 2 are assigned 186 * to the same port this is explicitly disallowed by the hardware 187 * unless they are part of the same x4 port and this condition was 188 * already checked above. */ 189 if (port_agent->phy_valid_port_range[2].min_index == 1) { 190 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 191 } 192 193 /* 194 * PE0 and PE3 can never have the same SAS Address unless they 195 * are part of the same x4 wide port and we have already checked 196 * for this condition. */ 197 sci_phy_get_sas_address(&ihost->phys[0], &first_address); 198 sci_phy_get_sas_address(&ihost->phys[3], &second_address); 199 200 if (sci_sas_address_compare(first_address, second_address) == 0) { 201 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 202 } 203 204 /* 205 * PE0 and PE1 are configured into a 2x1 ports make sure that the 206 * SAS Address for PE0 and PE2 are different since they can not be 207 * part of the same port. */ 208 if (port_agent->phy_valid_port_range[0].min_index == 0 && 209 port_agent->phy_valid_port_range[1].min_index == 1) { 210 sci_phy_get_sas_address(&ihost->phys[0], &first_address); 211 sci_phy_get_sas_address(&ihost->phys[2], &second_address); 212 213 if (sci_sas_address_compare(first_address, second_address) == 0) { 214 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 215 } 216 } 217 218 /* 219 * PE2 and PE3 are configured into a 2x1 ports make sure that the 220 * SAS Address for PE1 and PE3 are different since they can not be 221 * part of the same port. */ 222 if (port_agent->phy_valid_port_range[2].min_index == 2 && 223 port_agent->phy_valid_port_range[3].min_index == 3) { 224 sci_phy_get_sas_address(&ihost->phys[1], &first_address); 225 sci_phy_get_sas_address(&ihost->phys[3], &second_address); 226 227 if (sci_sas_address_compare(first_address, second_address) == 0) { 228 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 229 } 230 } 231 232 return SCI_SUCCESS; 233 } 234 235 /* 236 * ****************************************************************************** 237 * Manual port configuration agent routines 238 * ****************************************************************************** */ 239 240 /* verify all of the phys in the same port are using the same SAS address */ 241 static enum sci_status 242 sci_mpc_agent_validate_phy_configuration(struct isci_host *ihost, 243 struct sci_port_configuration_agent *port_agent) 244 { 245 u32 phy_mask; 246 u32 assigned_phy_mask; 247 struct sci_sas_address sas_address; 248 struct sci_sas_address phy_assigned_address; 249 u8 port_index; 250 u8 phy_index; 251 252 assigned_phy_mask = 0; 253 sas_address.high = 0; 254 sas_address.low = 0; 255 256 for (port_index = 0; port_index < SCI_MAX_PORTS; port_index++) { 257 phy_mask = ihost->oem_parameters.ports[port_index].phy_mask; 258 259 if (!phy_mask) 260 continue; 261 /* 262 * Make sure that one or more of the phys were not already assinged to 263 * a different port. */ 264 if ((phy_mask & ~assigned_phy_mask) == 0) { 265 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 266 } 267 268 /* Find the starting phy index for this round through the loop */ 269 for (phy_index = 0; phy_index < SCI_MAX_PHYS; phy_index++) { 270 if ((phy_mask & (1 << phy_index)) == 0) 271 continue; 272 sci_phy_get_sas_address(&ihost->phys[phy_index], 273 &sas_address); 274 275 /* 276 * The phy_index can be used as the starting point for the 277 * port range since the hardware starts all logical ports 278 * the same as the PE index. */ 279 port_agent->phy_valid_port_range[phy_index].min_index = port_index; 280 port_agent->phy_valid_port_range[phy_index].max_index = phy_index; 281 282 if (phy_index != port_index) { 283 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 284 } 285 286 break; 287 } 288 289 /* 290 * See how many additional phys are being added to this logical port. 291 * Note: We have not moved the current phy_index so we will actually 292 * compare the startting phy with itself. 293 * This is expected and required to add the phy to the port. */ 294 for (; phy_index < SCI_MAX_PHYS; phy_index++) { 295 if ((phy_mask & (1 << phy_index)) == 0) 296 continue; 297 sci_phy_get_sas_address(&ihost->phys[phy_index], 298 &phy_assigned_address); 299 300 if (sci_sas_address_compare(sas_address, phy_assigned_address) != 0) { 301 /* 302 * The phy mask specified that this phy is part of the same port 303 * as the starting phy and it is not so fail this configuration */ 304 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION; 305 } 306 307 port_agent->phy_valid_port_range[phy_index].min_index = port_index; 308 port_agent->phy_valid_port_range[phy_index].max_index = phy_index; 309 310 sci_port_add_phy(&ihost->ports[port_index], 311 &ihost->phys[phy_index]); 312 313 assigned_phy_mask |= (1 << phy_index); 314 } 315 316 } 317 318 return sci_port_configuration_agent_validate_ports(ihost, port_agent); 319 } 320 321 static void mpc_agent_timeout(struct timer_list *t) 322 { 323 u8 index; 324 struct sci_timer *tmr = from_timer(tmr, t, timer); 325 struct sci_port_configuration_agent *port_agent; 326 struct isci_host *ihost; 327 unsigned long flags; 328 u16 configure_phy_mask; 329 330 port_agent = container_of(tmr, typeof(*port_agent), timer); 331 ihost = container_of(port_agent, typeof(*ihost), port_agent); 332 333 spin_lock_irqsave(&ihost->scic_lock, flags); 334 335 if (tmr->cancel) 336 goto done; 337 338 port_agent->timer_pending = false; 339 340 /* Find the mask of phys that are reported read but as yet unconfigured into a port */ 341 configure_phy_mask = ~port_agent->phy_configured_mask & port_agent->phy_ready_mask; 342 343 for (index = 0; index < SCI_MAX_PHYS; index++) { 344 struct isci_phy *iphy = &ihost->phys[index]; 345 346 if (configure_phy_mask & (1 << index)) { 347 port_agent->link_up_handler(ihost, port_agent, 348 phy_get_non_dummy_port(iphy), 349 iphy); 350 } 351 } 352 353 done: 354 spin_unlock_irqrestore(&ihost->scic_lock, flags); 355 } 356 357 static void sci_mpc_agent_link_up(struct isci_host *ihost, 358 struct sci_port_configuration_agent *port_agent, 359 struct isci_port *iport, 360 struct isci_phy *iphy) 361 { 362 /* If the port is NULL then the phy was not assigned to a port. 363 * This is because the phy was not given the same SAS Address as 364 * the other PHYs in the port. 365 */ 366 if (!iport) 367 return; 368 369 port_agent->phy_ready_mask |= (1 << iphy->phy_index); 370 sci_port_link_up(iport, iphy); 371 if ((iport->active_phy_mask & (1 << iphy->phy_index))) 372 port_agent->phy_configured_mask |= (1 << iphy->phy_index); 373 } 374 375 /** 376 * sci_mpc_agent_link_down() 377 * @ihost: This is the controller object that receives the link down 378 * notification. 379 * @port_agent: This is the port configuration agent for the controller. 380 * @iport: This is the port object associated with the phy. If the is no 381 * associated port this is an NULL. The port is an invalid 382 * handle only if the phy was never port of this port. This happens when 383 * the phy is not broadcasting the same SAS address as the other phys in the 384 * assigned port. 385 * @iphy: This is the phy object which has gone link down. 386 * 387 * This function handles the manual port configuration link down notifications. 388 * Since all ports and phys are associated at initialization time we just turn 389 * around and notifiy the port object of the link down event. If this PHY is 390 * not associated with a port there is no action taken. Is it possible to get a 391 * link down notification from a phy that has no assocoated port? 392 */ 393 static void sci_mpc_agent_link_down( 394 struct isci_host *ihost, 395 struct sci_port_configuration_agent *port_agent, 396 struct isci_port *iport, 397 struct isci_phy *iphy) 398 { 399 if (iport != NULL) { 400 /* 401 * If we can form a new port from the remainder of the phys 402 * then we want to start the timer to allow the SCI User to 403 * cleanup old devices and rediscover the port before 404 * rebuilding the port with the phys that remain in the ready 405 * state. 406 */ 407 port_agent->phy_ready_mask &= ~(1 << iphy->phy_index); 408 port_agent->phy_configured_mask &= ~(1 << iphy->phy_index); 409 410 /* 411 * Check to see if there are more phys waiting to be 412 * configured into a port. If there are allow the SCI User 413 * to tear down this port, if necessary, and then reconstruct 414 * the port after the timeout. 415 */ 416 if ((port_agent->phy_configured_mask == 0x0000) && 417 (port_agent->phy_ready_mask != 0x0000) && 418 !port_agent->timer_pending) { 419 port_agent->timer_pending = true; 420 421 sci_mod_timer(&port_agent->timer, 422 SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT); 423 } 424 425 sci_port_link_down(iport, iphy); 426 } 427 } 428 429 /* verify phys are assigned a valid SAS address for automatic port 430 * configuration mode. 431 */ 432 static enum sci_status 433 sci_apc_agent_validate_phy_configuration(struct isci_host *ihost, 434 struct sci_port_configuration_agent *port_agent) 435 { 436 u8 phy_index; 437 u8 port_index; 438 struct sci_sas_address sas_address; 439 struct sci_sas_address phy_assigned_address; 440 441 phy_index = 0; 442 443 while (phy_index < SCI_MAX_PHYS) { 444 port_index = phy_index; 445 446 /* Get the assigned SAS Address for the first PHY on the controller. */ 447 sci_phy_get_sas_address(&ihost->phys[phy_index], 448 &sas_address); 449 450 while (++phy_index < SCI_MAX_PHYS) { 451 sci_phy_get_sas_address(&ihost->phys[phy_index], 452 &phy_assigned_address); 453 454 /* Verify each of the SAS address are all the same for every PHY */ 455 if (sci_sas_address_compare(sas_address, phy_assigned_address) == 0) { 456 port_agent->phy_valid_port_range[phy_index].min_index = port_index; 457 port_agent->phy_valid_port_range[phy_index].max_index = phy_index; 458 } else { 459 port_agent->phy_valid_port_range[phy_index].min_index = phy_index; 460 port_agent->phy_valid_port_range[phy_index].max_index = phy_index; 461 break; 462 } 463 } 464 } 465 466 return sci_port_configuration_agent_validate_ports(ihost, port_agent); 467 } 468 469 /* 470 * This routine will restart the automatic port configuration timeout 471 * timer for the next time period. This could be caused by either a link 472 * down event or a link up event where we can not yet tell to which a phy 473 * belongs. 474 */ 475 static void sci_apc_agent_start_timer(struct sci_port_configuration_agent *port_agent, 476 u32 timeout) 477 { 478 port_agent->timer_pending = true; 479 sci_mod_timer(&port_agent->timer, timeout); 480 } 481 482 static void sci_apc_agent_configure_ports(struct isci_host *ihost, 483 struct sci_port_configuration_agent *port_agent, 484 struct isci_phy *iphy, 485 bool start_timer) 486 { 487 u8 port_index; 488 enum sci_status status; 489 struct isci_port *iport; 490 enum SCIC_SDS_APC_ACTIVITY apc_activity = SCIC_SDS_APC_SKIP_PHY; 491 492 iport = sci_port_configuration_agent_find_port(ihost, iphy); 493 494 if (iport) { 495 if (sci_port_is_valid_phy_assignment(iport, iphy->phy_index)) 496 apc_activity = SCIC_SDS_APC_ADD_PHY; 497 else 498 apc_activity = SCIC_SDS_APC_SKIP_PHY; 499 } else { 500 /* 501 * There is no matching Port for this PHY so lets search through the 502 * Ports and see if we can add the PHY to its own port or maybe start 503 * the timer and wait to see if a wider port can be made. 504 * 505 * Note the break when we reach the condition of the port id == phy id */ 506 for (port_index = port_agent->phy_valid_port_range[iphy->phy_index].min_index; 507 port_index <= port_agent->phy_valid_port_range[iphy->phy_index].max_index; 508 port_index++) { 509 510 iport = &ihost->ports[port_index]; 511 512 /* First we must make sure that this PHY can be added to this Port. */ 513 if (sci_port_is_valid_phy_assignment(iport, iphy->phy_index)) { 514 /* 515 * Port contains a PHY with a greater PHY ID than the current 516 * PHY that has gone link up. This phy can not be part of any 517 * port so skip it and move on. */ 518 if (iport->active_phy_mask > (1 << iphy->phy_index)) { 519 apc_activity = SCIC_SDS_APC_SKIP_PHY; 520 break; 521 } 522 523 /* 524 * We have reached the end of our Port list and have not found 525 * any reason why we should not either add the PHY to the port 526 * or wait for more phys to become active. */ 527 if (iport->physical_port_index == iphy->phy_index) { 528 /* 529 * The Port either has no active PHYs. 530 * Consider that if the port had any active PHYs we would have 531 * or active PHYs with 532 * a lower PHY Id than this PHY. */ 533 if (apc_activity != SCIC_SDS_APC_START_TIMER) { 534 apc_activity = SCIC_SDS_APC_ADD_PHY; 535 } 536 537 break; 538 } 539 540 /* 541 * The current Port has no active PHYs and this PHY could be part 542 * of this Port. Since we dont know as yet setup to start the 543 * timer and see if there is a better configuration. */ 544 if (iport->active_phy_mask == 0) { 545 apc_activity = SCIC_SDS_APC_START_TIMER; 546 } 547 } else if (iport->active_phy_mask != 0) { 548 /* 549 * The Port has an active phy and the current Phy can not 550 * participate in this port so skip the PHY and see if 551 * there is a better configuration. */ 552 apc_activity = SCIC_SDS_APC_SKIP_PHY; 553 } 554 } 555 } 556 557 /* 558 * Check to see if the start timer operations should instead map to an 559 * add phy operation. This is caused because we have been waiting to 560 * add a phy to a port but could not becuase the automatic port 561 * configuration engine had a choice of possible ports for the phy. 562 * Since we have gone through a timeout we are going to restrict the 563 * choice to the smallest possible port. */ 564 if ( 565 (start_timer == false) 566 && (apc_activity == SCIC_SDS_APC_START_TIMER) 567 ) { 568 apc_activity = SCIC_SDS_APC_ADD_PHY; 569 } 570 571 switch (apc_activity) { 572 case SCIC_SDS_APC_ADD_PHY: 573 status = sci_port_add_phy(iport, iphy); 574 575 if (status == SCI_SUCCESS) { 576 port_agent->phy_configured_mask |= (1 << iphy->phy_index); 577 } 578 break; 579 580 case SCIC_SDS_APC_START_TIMER: 581 sci_apc_agent_start_timer(port_agent, 582 SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION); 583 break; 584 585 case SCIC_SDS_APC_SKIP_PHY: 586 default: 587 /* do nothing the PHY can not be made part of a port at this time. */ 588 break; 589 } 590 } 591 592 /** 593 * sci_apc_agent_link_up - handle apc link up events 594 * @ihost: This is the controller object that receives the link up 595 * notification. 596 * @port_agent: This is the port configuration agent for the controller. 597 * @iport: This is the port object associated with the phy. If the is no 598 * associated port this is an NULL. 599 * @iphy: This is the phy object which has gone link up. 600 * 601 * This method handles the automatic port configuration for link up 602 * notifications. Is it possible to get a link down notification from a phy 603 * that has no assocoated port? 604 */ 605 static void sci_apc_agent_link_up(struct isci_host *ihost, 606 struct sci_port_configuration_agent *port_agent, 607 struct isci_port *iport, 608 struct isci_phy *iphy) 609 { 610 u8 phy_index = iphy->phy_index; 611 612 if (!iport) { 613 /* the phy is not the part of this port */ 614 port_agent->phy_ready_mask |= 1 << phy_index; 615 sci_apc_agent_start_timer(port_agent, 616 SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION); 617 } else { 618 /* the phy is already the part of the port */ 619 port_agent->phy_ready_mask |= 1 << phy_index; 620 sci_port_link_up(iport, iphy); 621 } 622 } 623 624 /** 625 * sci_apc_agent_link_down() 626 * @ihost: This is the controller object that receives the link down 627 * notification. 628 * @port_agent: This is the port configuration agent for the controller. 629 * @iport: This is the port object associated with the phy. If the is no 630 * associated port this is an NULL. 631 * @iphy: This is the phy object which has gone link down. 632 * 633 * This method handles the automatic port configuration link down 634 * notifications. not associated with a port there is no action taken. Is it 635 * possible to get a link down notification from a phy that has no assocoated 636 * port? 637 */ 638 static void sci_apc_agent_link_down( 639 struct isci_host *ihost, 640 struct sci_port_configuration_agent *port_agent, 641 struct isci_port *iport, 642 struct isci_phy *iphy) 643 { 644 port_agent->phy_ready_mask &= ~(1 << iphy->phy_index); 645 646 if (!iport) 647 return; 648 if (port_agent->phy_configured_mask & (1 << iphy->phy_index)) { 649 enum sci_status status; 650 651 status = sci_port_remove_phy(iport, iphy); 652 653 if (status == SCI_SUCCESS) 654 port_agent->phy_configured_mask &= ~(1 << iphy->phy_index); 655 } 656 } 657 658 /* configure the phys into ports when the timer fires */ 659 static void apc_agent_timeout(struct timer_list *t) 660 { 661 u32 index; 662 struct sci_timer *tmr = from_timer(tmr, t, timer); 663 struct sci_port_configuration_agent *port_agent; 664 struct isci_host *ihost; 665 unsigned long flags; 666 u16 configure_phy_mask; 667 668 port_agent = container_of(tmr, typeof(*port_agent), timer); 669 ihost = container_of(port_agent, typeof(*ihost), port_agent); 670 671 spin_lock_irqsave(&ihost->scic_lock, flags); 672 673 if (tmr->cancel) 674 goto done; 675 676 port_agent->timer_pending = false; 677 678 configure_phy_mask = ~port_agent->phy_configured_mask & port_agent->phy_ready_mask; 679 680 if (!configure_phy_mask) 681 goto done; 682 683 for (index = 0; index < SCI_MAX_PHYS; index++) { 684 if ((configure_phy_mask & (1 << index)) == 0) 685 continue; 686 687 sci_apc_agent_configure_ports(ihost, port_agent, 688 &ihost->phys[index], false); 689 } 690 691 if (is_controller_start_complete(ihost)) 692 sci_controller_transition_to_ready(ihost, SCI_SUCCESS); 693 694 done: 695 spin_unlock_irqrestore(&ihost->scic_lock, flags); 696 } 697 698 /* 699 * ****************************************************************************** 700 * Public port configuration agent routines 701 * ****************************************************************************** */ 702 703 /* 704 * This method will construct the port configuration agent for operation. This 705 * call is universal for both manual port configuration and automatic port 706 * configuration modes. 707 */ 708 void sci_port_configuration_agent_construct( 709 struct sci_port_configuration_agent *port_agent) 710 { 711 u32 index; 712 713 port_agent->phy_configured_mask = 0x00; 714 port_agent->phy_ready_mask = 0x00; 715 716 port_agent->link_up_handler = NULL; 717 port_agent->link_down_handler = NULL; 718 719 port_agent->timer_pending = false; 720 721 for (index = 0; index < SCI_MAX_PORTS; index++) { 722 port_agent->phy_valid_port_range[index].min_index = 0; 723 port_agent->phy_valid_port_range[index].max_index = 0; 724 } 725 } 726 727 bool is_port_config_apc(struct isci_host *ihost) 728 { 729 return ihost->port_agent.link_up_handler == sci_apc_agent_link_up; 730 } 731 732 enum sci_status sci_port_configuration_agent_initialize( 733 struct isci_host *ihost, 734 struct sci_port_configuration_agent *port_agent) 735 { 736 enum sci_status status; 737 enum sci_port_configuration_mode mode; 738 739 mode = ihost->oem_parameters.controller.mode_type; 740 741 if (mode == SCIC_PORT_MANUAL_CONFIGURATION_MODE) { 742 status = sci_mpc_agent_validate_phy_configuration( 743 ihost, port_agent); 744 745 port_agent->link_up_handler = sci_mpc_agent_link_up; 746 port_agent->link_down_handler = sci_mpc_agent_link_down; 747 748 sci_init_timer(&port_agent->timer, mpc_agent_timeout); 749 } else { 750 status = sci_apc_agent_validate_phy_configuration( 751 ihost, port_agent); 752 753 port_agent->link_up_handler = sci_apc_agent_link_up; 754 port_agent->link_down_handler = sci_apc_agent_link_down; 755 756 sci_init_timer(&port_agent->timer, apc_agent_timeout); 757 } 758 759 return status; 760 } 761