sys/dev/isci/scil/scif_sas_smp_remote_device.c

   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  *
  40  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  41  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  42  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  43  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  44  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  46  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  47  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  48  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  49  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  50  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  51  */
  52
  53 #include <sys/cdefs.h>
  54 __FBSDID("$FreeBSD$");
  55
  56 /**
  57  * @file
  58  *
  59  * @brief This file contains the methods for the SCIF_SAS_SMP_REMOTE_DEVICE object.
  60  */
  61 #include <dev/isci/scil/sci_controller.h>
  62 #include <dev/isci/scil/scif_sas_controller.h>
  63 #include <dev/isci/scil/scif_sas_remote_device.h>
  64 #include <dev/isci/scil/scif_sas_logger.h>
  65
  66 #include <dev/isci/scil/scif_sas_smp_remote_device.h>
  67 #include <dev/isci/scil/scif_sas_smp_io_request.h>
  68 #include <dev/isci/scil/intel_sas.h>
  69 #include <dev/isci/scil/scic_io_request.h>
  70 #include <dev/isci/scil/scic_remote_device.h>
  71 #include <dev/isci/scil/scif_sas_smp_phy.h>
  72
  73
  74 /**
  75  * @brief This method resets all fields for a smp remote device. This is a
  76  *        private method.
  77  *
  78  * @param[in] fw_device the framework SMP device that is being
  79  *            constructed.
  80  *
  81  * @return none
  82  */
  83 void scif_sas_smp_remote_device_clear(
  84    SCIF_SAS_REMOTE_DEVICE_T * fw_device
  85 )
  86 {
  87    //reset all fields in smp_device, indicate that the smp device is not
  88    //in discovery process.
  89    fw_device->protocol_device.smp_device.current_activity =
  90       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
  91
  92    fw_device->protocol_device.smp_device.current_smp_request =
  93       NOT_IN_SMP_ACTIVITY;
  94
  95    fw_device->protocol_device.smp_device.current_activity_phy_index = 0;
  96
  97    fw_device->protocol_device.smp_device.curr_config_route_index = 0;
  98
  99    fw_device->protocol_device.smp_device.config_route_smp_phy_anchor = NULL;
 100
 101    fw_device->protocol_device.smp_device.is_route_table_cleaned = FALSE;
 102
 103    fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy = NULL;
 104
 105    fw_device->protocol_device.smp_device.scheduled_activity =
 106       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
 107
 108    fw_device->protocol_device.smp_device.io_retry_count = 0;
 109
 110    fw_device->protocol_device.smp_device.curr_clear_affiliation_phy = NULL;
 111
 112    if (fw_device->protocol_device.smp_device.smp_activity_timer != NULL)
 113    {
 114       //stop the timer
 115       scif_cb_timer_stop(
 116          fw_device->domain->controller,
 117          fw_device->protocol_device.smp_device.smp_activity_timer
 118       );
 119
 120       //destroy the timer
 121       scif_cb_timer_destroy(
 122          fw_device->domain->controller,
 123          fw_device->protocol_device.smp_device.smp_activity_timer
 124       );
 125
 126       fw_device->protocol_device.smp_device.smp_activity_timer = NULL;
 127    }
 128 }
 129
 130
 131 /**
 132  * @brief This method intializes a smp remote device.
 133  *
 134  * @param[in] fw_device the framework SMP device that is being
 135  *            constructed.
 136  *
 137  * @return none
 138  */
 139 void scif_sas_smp_remote_device_construct(
 140    SCIF_SAS_REMOTE_DEVICE_T * fw_device
 141 )
 142 {
 143    SCIF_LOG_TRACE((
 144       sci_base_object_get_logger(fw_device),
 145       SCIF_LOG_OBJECT_REMOTE_DEVICE,
 146       "scif_sas_smp_remote_device_construct(0x%x) enter\n",
 147       fw_device
 148    ));
 149
 150    fw_device->protocol_device.smp_device.number_of_phys = 0;
 151    fw_device->protocol_device.smp_device.expander_route_indexes = 0;
 152    fw_device->protocol_device.smp_device.is_table_to_table_supported = FALSE;
 153    fw_device->protocol_device.smp_device.is_externally_configurable  = FALSE;
 154    fw_device->protocol_device.smp_device.is_able_to_config_others    = FALSE;
 155
 156    sci_fast_list_init(&fw_device->protocol_device.smp_device.smp_phy_list);
 157
 158    scif_sas_smp_remote_device_clear(fw_device);
 159 }
 160
 161
 162 /**
 163  * @brief This method decodes a smp response to this smp device and then
 164  *        continue the smp discover process.
 165  *
 166  * @param[in] fw_device The framework device that a SMP response targets to.
 167  * @param[in] fw_request The pointer to an smp request whose response
 168  *       is to be decoded.
 169  * @param[in] response_data The response data passed in.
 170  *
 171  * @return none
 172  */
 173 SCI_STATUS scif_sas_smp_remote_device_decode_smp_response(
 174    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 175    SCIF_SAS_REQUEST_T       * fw_request,
 176    void                     * response_data,
 177    SCI_IO_STATUS              completion_status
 178 )
 179 {
 180    SMP_RESPONSE_T * smp_response = (SMP_RESPONSE_T *)response_data;
 181    SCI_STATUS       status       = SCI_FAILURE_UNSUPPORTED_INFORMATION_TYPE;
 182
 183    if (fw_device->protocol_device.smp_device.smp_activity_timer != NULL)
 184    {
 185       //if there is a timer being used, recycle it now. Since we may
 186       //use the timer for other purpose next.
 187       scif_cb_timer_destroy(
 188          fw_device->domain->controller,
 189          fw_device->protocol_device.smp_device.smp_activity_timer
 190       );
 191
 192       fw_device->protocol_device.smp_device.smp_activity_timer = NULL;
 193    }
 194
 195    //if Core set the status of this io to be RETRY_REQUIRED, we should
 196    //retry the IO without even decode the response.
 197    if (completion_status == SCI_FAILURE_RETRY_REQUIRED)
 198    {
 199       scif_sas_smp_remote_device_continue_current_activity(
 200          fw_device, fw_request, SCI_FAILURE_RETRY_REQUIRED
 201       );
 202
 203       return SCI_FAILURE_RETRY_REQUIRED;
 204    }
 205
 206    //check the current smp request, decide what's next smp request to issue.
 207    switch (fw_device->protocol_device.smp_device.current_smp_request)
 208    {
 209       case SMP_FUNCTION_REPORT_GENERAL:
 210       {
 211          //interpret REPORT GENERAL response.
 212          status = scif_sas_smp_remote_device_decode_report_general_response(
 213             fw_device, smp_response
 214          );
 215
 216          break;
 217       }
 218
 219       case SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION:
 220       {
 221          // No need to perform any parsing.  Just want to see
 222          // the information in a trace if necessary.
 223          status = SCI_SUCCESS;
 224          break;
 225       }
 226
 227       case SMP_FUNCTION_DISCOVER:
 228       {
 229          if (fw_device->protocol_device.smp_device.current_activity ==
 230                 SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER)
 231          {
 232             //decode discover response
 233             status = scif_sas_smp_remote_device_decode_initial_discover_response(
 234                         fw_device, smp_response
 235                      );
 236          }
 237          else if (fw_device->protocol_device.smp_device.current_activity ==
 238                   SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
 239          {
 240             //decode discover response as a polling result for a remote device
 241             //target reset.
 242             status =
 243                scif_sas_smp_remote_device_decode_target_reset_discover_response(
 244                   fw_device, smp_response
 245                );
 246          }
 247          else if (fw_device->protocol_device.smp_device.current_activity ==
 248                 SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_SATA_SPINUP_HOLD_RELEASE)
 249          {
 250             //decode discover response
 251             status =
 252                scif_sas_smp_remote_device_decode_spinup_hold_release_discover_response(
 253                   fw_device, smp_response
 254                );
 255          }
 256          else
 257             ASSERT(0);
 258          break;
 259       }
 260
 261       case SMP_FUNCTION_REPORT_PHY_SATA:
 262       {
 263          //decode the report phy sata response.
 264          status = scif_sas_smp_remote_device_decode_report_phy_sata_response(
 265             fw_device, smp_response
 266          );
 267
 268          break;
 269       }
 270
 271       case SMP_FUNCTION_PHY_CONTROL:
 272       {
 273          if (fw_device->protocol_device.smp_device.current_activity ==
 274                 SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER)
 275          {
 276             //decode the phy control response.
 277             status = scif_sas_smp_remote_device_decode_discover_phy_control_response(
 278                         fw_device, smp_response
 279                      );
 280          }
 281          else if (fw_device->protocol_device.smp_device.current_activity ==
 282                      SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
 283          {
 284             //decode discover response as a polling result for a remote device
 285             //target reset.
 286             status = scif_sas_smp_remote_device_decode_target_reset_phy_control_response(
 287                         fw_device, smp_response
 288                      );
 289          }
 290          else if (fw_device->protocol_device.smp_device.current_activity ==
 291                      SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAR_AFFILIATION)
 292          {
 293             //currently don't care about the status.
 294             status = SCI_SUCCESS;
 295          }
 296          else
 297             ASSERT(0);
 298          break;
 299       }
 300
 301       case SMP_FUNCTION_CONFIGURE_ROUTE_INFORMATION:
 302       {
 303          //Note, currently we don't expect any abnormal status from config route info response,
 304          //but there is a possibility that we exceed the maximum route index. We will take care
 305          //of errors later.
 306          status = scif_sas_smp_remote_device_decode_config_route_info_response(
 307                      fw_device, smp_response
 308                   );
 309          break;
 310       }
 311
 312       default:
 313          //unsupported case, TBD
 314          status = SCI_FAILURE_UNSUPPORTED_INFORMATION_TYPE;
 315          break;
 316    } //end of switch
 317
 318    //Continue current activity based on response's decoding status.
 319    scif_sas_smp_remote_device_continue_current_activity(
 320       fw_device, fw_request, status
 321    );
 322
 323    return status;
 324 }
 325
 326
 327 /**
 328  * @brief This method decodes a smp Report Genernal response to this smp device
 329  *        and then continue the smp discover process.
 330  *
 331  * @param[in] fw_device The framework device that the REPORT GENERAL command
 332  *       targets to.
 333  * @param[in] report_general_response The pointer to a report general response
 334  *
 335  * @return none
 336  */
 337 SCI_STATUS scif_sas_smp_remote_device_decode_report_general_response(
 338    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 339    SMP_RESPONSE_T           * smp_response
 340 )
 341 {
 342    SMP_RESPONSE_REPORT_GENERAL_T * report_general_response =
 343       &smp_response->response.report_general;
 344
 345    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 346
 347    SCIF_LOG_TRACE((
 348       sci_base_object_get_logger(fw_device),
 349       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 350       "scif_sas_smp_remote_device_decode_report_general_response(0x%x, 0x%x) enter\n",
 351       fw_device, smp_response
 352    ));
 353
 354    if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 355    {
 356       /// @todo: more decoding work needed when the function_result is not
 357       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 358       /// function result.
 359       SCIF_LOG_ERROR((
 360          sci_base_object_get_logger(fw_device),
 361          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 362          "Report General function result(0x%x)\n",
 363          response_header->function_result
 364       ));
 365
 366       return SCI_FAILURE;
 367    }
 368
 369    //get info from report general response.
 370    fw_device->protocol_device.smp_device.number_of_phys =
 371       (U8)report_general_response->number_of_phys;
 372
 373    //currently there is byte swap issue in U16 data.
 374    fw_device->protocol_device.smp_device.expander_route_indexes =
 375       ((report_general_response->expander_route_indexes & 0xff) << 8) |
 376       ((report_general_response->expander_route_indexes & 0xff00) >> 8);
 377
 378    fw_device->protocol_device.smp_device.is_table_to_table_supported =
 379       (BOOL)report_general_response->table_to_table_supported;
 380
 381    fw_device->protocol_device.smp_device.is_externally_configurable =
 382       (BOOL)report_general_response->configurable_route_table;
 383
 384    fw_device->protocol_device.smp_device.is_able_to_config_others =
 385       (BOOL)report_general_response->configures_others;
 386
 387    //If the top level expander of a domain is able to configure others,
 388    //no config route table is needed in the domain. Or else,
 389    //we'll let all the externally configurable expanders in the damain
 390    //configure route table.
 391    if (fw_device->containing_device == NULL
 392        && ! fw_device->protocol_device.smp_device.is_able_to_config_others)
 393       fw_device->domain->is_config_route_table_needed = TRUE;
 394
 395    //knowing number of phys this expander has, we can allocate all the smp phys for
 396    //this expander now if it is not done already.
 397    if (fw_device->protocol_device.smp_device.smp_phy_list.element_count == 0)
 398       scif_sas_smp_remote_device_populate_smp_phy_list(fw_device);
 399
 400    if (report_general_response->configuring)
 401       return SCI_FAILURE_RETRY_REQUIRED;
 402
 403    return SCI_SUCCESS;
 404 }
 405
 406
 407 /**
 408  * @brief This method decodes a smp Discover response to this smp device
 409  *        and then continue the smp discover process. This is only ever
 410  *        called for the very first discover stage during a given domain
 411  *        discovery process.
 412  *
 413  * @param[in] fw_device The framework device that the DISCOVER command
 414  *       targets to.
 415  * @param[in] discover_response The pointer to a DISCOVER response
 416  *
 417  * @return none
 418  */
 419 SCI_STATUS scif_sas_smp_remote_device_decode_initial_discover_response(
 420    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 421    SMP_RESPONSE_T           * smp_response
 422 )
 423 {
 424    SCIF_SAS_DOMAIN_T        * fw_domain = fw_device->domain;
 425    SCI_SAS_ADDRESS_T          attached_device_address;
 426    SCIF_SAS_REMOTE_DEVICE_T * attached_remote_device;
 427    SMP_RESPONSE_DISCOVER_T  * discover_response =
 428       &smp_response->response.discover;
 429    SMP_RESPONSE_HEADER_T    * response_header = &smp_response->header;
 430
 431    SCIF_LOG_TRACE((
 432       sci_base_object_get_logger(fw_device),
 433       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 434       "scif_sas_smp_remote_device_decode_initial_discover_response(0x%x, 0x%x) enter\n",
 435       fw_device, smp_response
 436    ));
 437
 438    if (response_header->function_result == SMP_RESULT_PHY_VACANT)
 439    {
 440       return SCI_SUCCESS;
 441    }
 442    else if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 443    {
 444       /// @todo: more decoding work needed when the function_result is not
 445       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 446       /// function result.
 447       SCIF_LOG_ERROR((
 448          sci_base_object_get_logger(fw_device),
 449          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 450          "Discover function result(0x%x)\n",
 451          response_header->function_result
 452       ));
 453
 454       return SCI_FAILURE;
 455    }
 456
 457    //only if there is target device attached. We don't add device that is
 458    //initiator only.
 459    if ( ( discover_response->u2.sas1_1.attached_device_type
 460              != SMP_NO_DEVICE_ATTACHED )
 461        && ( discover_response->protocols.u.bits.attached_ssp_target
 462            || discover_response->protocols.u.bits.attached_stp_target
 463            || discover_response->protocols.u.bits.attached_smp_target
 464            || discover_response->protocols.u.bits.attached_sata_device ) )
 465    {
 466       attached_device_address = discover_response->attached_sas_address;
 467
 468       attached_remote_device = (SCIF_SAS_REMOTE_DEVICE_T *)
 469          scif_domain_get_device_by_sas_address(
 470             fw_domain, &attached_device_address
 471          );
 472
 473       //need to check if the device already existed in the domian.
 474       if (attached_remote_device != SCI_INVALID_HANDLE)
 475       {
 476 #if !defined(DISABLE_WIDE_PORTED_TARGETS)
 477          if ( attached_remote_device->is_currently_discovered == TRUE
 478              && attached_remote_device != fw_device->containing_device )
 479          {
 480             //a downstream wide port target is found.
 481             attached_remote_device->device_port_width++;
 482          }
 483          else
 484 #endif //#if !defined(DISABLE_WIDE_PORTED_TARGETS)
 485          {
 486             //The device already existed. Mark the device as discovered.
 487             attached_remote_device->is_currently_discovered = TRUE;
 488          }
 489
 490 #if !defined(DISABLE_WIDE_PORTED_TARGETS)
 491          if (attached_remote_device->device_port_width !=
 492                 scic_remote_device_get_port_width(attached_remote_device->core_object)
 493              && discover_response->protocols.u.bits.attached_ssp_target
 494             )
 495          {
 496             scif_sas_remote_device_update_port_width(
 497                attached_remote_device, attached_remote_device->device_port_width);
 498          }
 499 #endif //#if !defined(DISABLE_WIDE_PORTED_TARGETS)
 500
 501          if ( discover_response->protocols.u.bits.attached_smp_target
 502              && attached_remote_device != fw_device->containing_device)
 503          {
 504             //another expander device is discovered. Its own smp discover will starts after
 505             //this discover finishes.
 506             attached_remote_device->protocol_device.smp_device.scheduled_activity =
 507                SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER;
 508          }
 509       }
 510       else
 511       {
 512          //report the discovery of a disk for all types of end device.
 513          scif_cb_domain_ea_device_added(
 514             fw_domain->controller, fw_domain, fw_device, discover_response
 515          );
 516
 517          //get info from discover response to see what we found. And do
 518          //extra work according to end device's protocol type.
 519          if ( discover_response->protocols.u.bits.attached_ssp_target
 520              || discover_response->protocols.u.bits.attached_smp_target)
 521          {
 522             //for SSP or SMP target, no extra work.
 523             ;
 524          }
 525          else if (  (discover_response->protocols.u.bits.attached_stp_target)
 526                  || (discover_response->protocols.u.bits.attached_sata_device) )
 527          {
 528             // We treat a SATA Device bit the same as an attached STP
 529             // target.
 530             discover_response->protocols.u.bits.attached_stp_target = 1;
 531
 532             //kick off REPORT PHY SATA to the same phy.
 533             fw_device->protocol_device.smp_device.current_smp_request =
 534                SMP_FUNCTION_REPORT_PHY_SATA;
 535          }
 536       }
 537    }
 538    else if( (discover_response->u2.sas1_1.negotiated_physical_link_rate == SCI_SATA_SPINUP_HOLD
 539              || discover_response->u4.sas2.negotiated_physical_link_rate == SCI_SATA_SPINUP_HOLD)
 540           &&(discover_response->protocols.u.bits.attached_stp_target
 541              || discover_response->protocols.u.bits.attached_sata_device)
 542           )
 543    {
 544       attached_remote_device = scif_sas_domain_get_device_by_containing_device(
 545                                   fw_domain,
 546                                   fw_device,
 547                                   discover_response->phy_identifier
 548                                );
 549
 550       if (attached_remote_device != SCI_INVALID_HANDLE)
 551       {
 552          //Here, the only reason a device already existed in domain but
 553          //the initial discover rersponse shows it in SPINUP_HOLD, is that
 554          //a device has been removed and coming back in SPINUP_HOLD before
 555          //we detected. The possibility of this situation is very very rare.
 556          //we need to remove the device then add it back using the new
 557          //discover response.
 558          scif_cb_domain_device_removed(
 559             fw_domain->controller, fw_domain, attached_remote_device
 560          );
 561       }
 562
 563       discover_response->protocols.u.bits.attached_stp_target = 1;
 564
 565       //still report ea_device_added(). But this device will not be
 566       //started during scif_remote_device_ea_construct().
 567       scif_cb_domain_ea_device_added(
 568          fw_domain->controller, fw_domain, fw_device, discover_response
 569       );
 570
 571       //need to send Phy Control (RESET) to release the phy from spinup hold
 572       //condition.
 573       fw_device->protocol_device.smp_device.current_smp_request =
 574          SMP_FUNCTION_PHY_CONTROL;
 575    }
 576
 577    //update the smp phy info based on this DISCOVER response.
 578    return scif_sas_smp_remote_device_save_smp_phy_info(
 579              fw_device, discover_response);
 580 }
 581
 582
 583 /**
 584  * @brief This method decodes a smp Report Phy Sata response to this
 585  *        smp device and then continue the smp discover process.
 586  *
 587  * @param[in] fw_device The framework device that the REPORT PHY SATA
 588  *       command targets to.
 589  * @param[in] report_phy_sata_response The pointer to a REPORT PHY
 590  *       SATA response
 591  *
 592  * @return none
 593  */
 594 SCI_STATUS scif_sas_smp_remote_device_decode_report_phy_sata_response(
 595    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 596    SMP_RESPONSE_T           * smp_response
 597 )
 598 {
 599    SMP_RESPONSE_REPORT_PHY_SATA_T * report_phy_sata_response =
 600       &smp_response->response.report_phy_sata;
 601
 602    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 603
 604    SCIF_LOG_TRACE((
 605       sci_base_object_get_logger(fw_device),
 606       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 607       "scif_sas_smp_remote_device_decode_report_phy_sata_response(0x%x, 0x%x) enter\n",
 608       fw_device, smp_response
 609    ));
 610
 611    if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 612    {
 613       /// @todo: more decoding work needed when the function_result is not
 614       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 615       /// function result.
 616       SCIF_LOG_ERROR((
 617          sci_base_object_get_logger(fw_device),
 618          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 619          "Report Phy Sata function result(0x%x)\n",
 620          response_header->function_result
 621       ));
 622
 623       return SCI_FAILURE;
 624    }
 625
 626    scif_sas_remote_device_save_report_phy_sata_information(
 627       report_phy_sata_response
 628    );
 629
 630    // continue the discover process.
 631    fw_device->protocol_device.smp_device.current_smp_request =
 632       SMP_FUNCTION_DISCOVER;
 633
 634    return SCI_SUCCESS;
 635 }
 636
 637
 638 /**
 639  * @brief This method decodes a smp Phy Control response to this smp device and
 640  *        then continue the smp TARGET RESET process.
 641  *
 642  * @param[in] fw_device The framework device that the Phy Control command
 643  *       targets to.
 644  * @param[in] smp_response The pointer to a Phy Control response
 645  * @param[in] fw_io The scif IO request that associates to this smp response.
 646  *
 647  * @return none
 648  */
 649 SCI_STATUS scif_sas_smp_remote_device_decode_target_reset_phy_control_response(
 650    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 651    SMP_RESPONSE_T           * smp_response
 652 )
 653 {
 654    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 655
 656    SCI_STATUS status = SCI_SUCCESS;
 657
 658    SCIF_LOG_TRACE((
 659       sci_base_object_get_logger(fw_device),
 660       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 661       "scif_sas_smp_remote_device_decode_target_reset_phy_control_response(0x%x, 0x%x) enter\n",
 662       fw_device, smp_response
 663    ));
 664
 665    if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 666    {
 667       /// @todo: more decoding work needed when the function_result is not
 668       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 669       /// function result.
 670       SCIF_LOG_ERROR((
 671          sci_base_object_get_logger(fw_device),
 672          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 673          "Phy Control function unaccepted result(0x%x)\n",
 674          response_header->function_result
 675       ));
 676
 677       status = SCI_FAILURE_RETRY_REQUIRED;
 678    }
 679
 680    // phy Control succeeded.
 681    return status;
 682 }
 683
 684 /**
 685  * @brief This method decodes a smp Phy Control response to this smp device and
 686  *        then continue the smp DISCOVER process.
 687  *
 688  * @param[in] fw_device The framework device that the Phy Control command
 689  *       targets to.
 690  * @param[in] smp_response The pointer to a Phy Control response
 691  *
 692  * @return Almost always SCI_SUCCESS
 693  */
 694 SCI_STATUS scif_sas_smp_remote_device_decode_discover_phy_control_response(
 695    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 696    SMP_RESPONSE_T           * smp_response
 697 )
 698 {
 699    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 700
 701    SCI_STATUS status = SCI_SUCCESS;
 702
 703    SCIF_LOG_TRACE((
 704       sci_base_object_get_logger(fw_device),
 705       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 706       "scif_sas_smp_remote_device_decode_discover_phy_control_response(0x%x, 0x%x) enter\n",
 707       fw_device, smp_response
 708    ));
 709
 710    if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 711    {
 712       /// @todo: more decoding work needed when the function_result is not
 713       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 714       /// function result.
 715       SCIF_LOG_ERROR((
 716          sci_base_object_get_logger(fw_device),
 717          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 718          "Phy Control function unaccepted result(0x%x)\n",
 719          response_header->function_result
 720       ));
 721
 722       return SCI_FAILURE_RETRY_REQUIRED;
 723    }
 724
 725    // continue the discover process.
 726    fw_device->protocol_device.smp_device.current_smp_request =
 727       SMP_FUNCTION_DISCOVER;
 728
 729    // phy Control succeeded.
 730    return status;
 731 }
 732
 733
 734 /**
 735  * @brief This method decodes a smp Discover response to this smp device
 736  *        and then continue the smp discover process.
 737  *
 738  * @param[in] fw_device The framework device that the DISCOVER command
 739  *       targets to.
 740  * @param[in] discover_response The pointer to a DISCOVER response
 741  *
 742  * @return none
 743  */
 744 SCI_STATUS scif_sas_smp_remote_device_decode_target_reset_discover_response(
 745    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 746    SMP_RESPONSE_T           * smp_response
 747 )
 748 {
 749    SCIF_SAS_DOMAIN_T  * fw_domain;
 750    SCI_SAS_ADDRESS_T attached_device_address;
 751    SMP_RESPONSE_DISCOVER_T * discover_response =
 752       &smp_response->response.discover;
 753
 754    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 755
 756    SCIF_LOG_TRACE((
 757       sci_base_object_get_logger(fw_device),
 758       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 759       "scif_sas_smp_remote_device_decode_target_reset_discover_response(0x%x, 0x%x) enter\n",
 760       fw_device, smp_response
 761    ));
 762
 763    if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 764    {
 765       /// @todo: more decoding work needed when the function_result is not
 766       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 767       /// function result.
 768       SCIF_LOG_ERROR((
 769          sci_base_object_get_logger(fw_device),
 770          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 771          "Discover function result(0x%x)\n",
 772          response_header->function_result
 773       ));
 774
 775       return SCI_FAILURE_RETRY_REQUIRED;
 776    }
 777
 778    //only if there is device attached.
 779    if ( discover_response->u2.sas1_1.attached_device_type != SMP_NO_DEVICE_ATTACHED )
 780    {
 781       fw_domain = fw_device->domain;
 782       attached_device_address = discover_response->attached_sas_address;
 783
 784       // the device should have already existed in the domian.
 785       ASSERT(scif_domain_get_device_by_sas_address(
 786                 fw_domain,
 787                 &attached_device_address
 788              ) != SCI_INVALID_HANDLE);
 789       return SCI_SUCCESS;
 790    }
 791    else
 792       return SCI_FAILURE_RETRY_REQUIRED;
 793 }
 794
 795 /**
 796  * @brief This method decodes a smp Discover response to this smp device
 797  *        for SPINUP_HOLD_RELEASE activity. If a DISCOVER response says
 798  *        SATA DEVICE ATTACHED and has a valid NPL value, we call fw_device's
 799  *        start_handler(). But if a DISCOVER response still shows SPINUP
 800  *        in NPL state, we need to return retry_required status
 801  *
 802  * @param[in] fw_device The framework device that the DISCOVER command
 803  *       targets to.
 804  * @param[in] discover_response The pointer to a DISCOVER response
 805  *
 806  * @return SCI_SUCCESS
 807  *         SCI_FAILURE_RETRY_REQUIRED
 808  */
 809 SCI_STATUS scif_sas_smp_remote_device_decode_spinup_hold_release_discover_response(
 810    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 811    SMP_RESPONSE_T           * smp_response
 812 )
 813 {
 814    SMP_RESPONSE_DISCOVER_T * discover_response = &smp_response->response.discover;
 815
 816    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 817
 818    SCIF_LOG_TRACE((
 819       sci_base_object_get_logger(fw_device),
 820       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 821       "scif_sas_smp_remote_device_decode_spinup_hold_release_discover_response(0x%x, 0x%x) enter\n",
 822       fw_device, smp_response
 823    ));
 824
 825    if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 826    {
 827       /// @todo: more decoding work needed when the function_result is not
 828       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 829       /// function result.
 830       SCIF_LOG_ERROR((
 831          sci_base_object_get_logger(fw_device),
 832          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 833          "Discover function result(0x%x)\n",
 834          response_header->function_result
 835       ));
 836
 837       return SCI_FAILURE;
 838    }
 839
 840    if ( discover_response->u2.sas1_1.attached_device_type != SMP_NO_DEVICE_ATTACHED )
 841    {
 842       if (discover_response->u2.sas1_1.negotiated_physical_link_rate != SCI_SATA_SPINUP_HOLD
 843           && discover_response->u4.sas2.negotiated_physical_link_rate != SCI_SATA_SPINUP_HOLD
 844           && ( discover_response->protocols.u.bits.attached_stp_target
 845              ||discover_response->protocols.u.bits.attached_sata_device )
 846          )
 847       {
 848          SCIF_SAS_REMOTE_DEVICE_T * target_device =
 849             scif_sas_domain_get_device_by_containing_device(
 850                fw_device->domain,
 851                fw_device,
 852                fw_device->protocol_device.smp_device.current_activity_phy_index
 853             );
 854
 855          //Need to update the device's connection rate. Its connection rate was SPINIP_HOLD.
 856          scic_remote_device_set_max_connection_rate(
 857             target_device->core_object,
 858             discover_response->u2.sas1_1.negotiated_physical_link_rate
 859          );
 860
 861          //Need to update the smp phy info too.
 862          scif_sas_smp_remote_device_save_smp_phy_info(
 863              fw_device, discover_response);
 864
 865          //This device has already constructed, only need to call start_handler
 866          //of this device here.
 867          return target_device->state_handlers->parent.start_handler(
 868                    &target_device->parent );
 869       }
 870       else
 871          return SCI_FAILURE_RETRY_REQUIRED;
 872    }
 873    else
 874       return SCI_FAILURE_RETRY_REQUIRED;
 875 }
 876
 877
 878 /**
 879  * @brief This method decodes a smp CONFIG ROUTE INFO response to this smp
 880  *        device and then continue to config route table.
 881  *
 882  * @param[in] fw_device The framework device that the CONFIG ROUTE INFO command
 883  *       targets to.
 884  * @param[in] smp_response The pointer to a CONFIG ROUTE INFO response
 885  *
 886  * @return none
 887  */
 888 SCI_STATUS scif_sas_smp_remote_device_decode_config_route_info_response(
 889    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 890    SMP_RESPONSE_T           * smp_response
 891 )
 892 {
 893    SMP_RESPONSE_HEADER_T * response_header = &smp_response->header;
 894
 895    SCIF_LOG_TRACE((
 896       sci_base_object_get_logger(fw_device),
 897       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 898       "scif_sas_smp_remote_device_decode_config_route_info_response(0x%x, 0x%x) enter\n",
 899       fw_device, smp_response
 900    ));
 901
 902    if (response_header->function_result == SMP_RESULT_INDEX_DOES_NOT_EXIST)
 903    {
 904       //case of exceeding max route index. We need to remove the devices that are not
 905       //able to be edit to route table. The destination config route smp phy
 906       //is used to remove devices.
 907       scif_sas_smp_remote_device_cancel_config_route_table_activity(fw_device);
 908
 909       return SCI_FAILURE_EXCEED_MAX_ROUTE_INDEX;
 910    }
 911    else if (response_header->function_result != SMP_RESULT_FUNCTION_ACCEPTED)
 912    {
 913       /// @todo: more decoding work needed when the function_result is not
 914       /// SMP_RESULT_FUNCTION_ACCEPTED. Retry might be the option for some
 915       /// function result.
 916       SCIF_LOG_ERROR((
 917          sci_base_object_get_logger(fw_device),
 918          SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 919          "Discover function result(0x%x)\n",
 920          response_header->function_result
 921       ));
 922
 923       return SCI_FAILURE;
 924    }
 925
 926    return SCI_SUCCESS;
 927 }
 928
 929
 930 /**
 931  * @brief This method starts the smp Discover process for an expander by
 932  *        sending Report General request.
 933  *
 934  * @param[in] fw_device The framework smp device that a  command
 935  *       targets to.
 936  *
 937  * @return none
 938  */
 939 void scif_sas_smp_remote_device_start_discover(
 940    SCIF_SAS_REMOTE_DEVICE_T * fw_device
 941 )
 942 {
 943    SCIF_SAS_CONTROLLER_T * fw_controller = fw_device->domain->controller;
 944
 945    SCIF_LOG_TRACE((
 946       sci_base_object_get_logger(fw_device),
 947       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
 948       "scif_sas_smp_remote_device_start_discover(0x%x) enter\n",
 949       fw_device
 950    ));
 951
 952    //For safety, clear the device again, there may be some config route table
 953    //related info are not cleared yet.
 954    scif_sas_smp_remote_device_clear(fw_device);
 955
 956    //set current activity
 957    fw_device->protocol_device.smp_device.current_activity =
 958       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER;
 959
 960    //Set current_smp_request to REPORT GENERAL.
 961    fw_device->protocol_device.smp_device.current_smp_request =
 962       SMP_FUNCTION_REPORT_GENERAL;
 963
 964    //reset discover_to_start flag.
 965    fw_device->protocol_device.smp_device.scheduled_activity =
 966       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
 967
 968    //build the first smp request Report Genernal.
 969    scif_sas_smp_request_construct_report_general(fw_controller, fw_device);
 970
 971    //issue DPC to start this request.
 972    scif_cb_start_internal_io_task_schedule(
 973       fw_controller,
 974       scif_sas_controller_start_high_priority_io,
 975       fw_controller
 976    );
 977 }
 978
 979
 980 /**
 981  * @brief This method continues the smp Discover process.
 982  *
 983  * @param[in] fw_device The framework smp device that a DISCOVER command
 984  *       targets to.
 985  * @param[in] fw_request The pointer to an smp request whose response
 986  *       has been decoded.
 987  * @param[in] status The decoding status of the smp request's response
 988  *
 989  * @return none
 990  */
 991 void scif_sas_smp_remote_device_continue_current_activity(
 992    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
 993    SCIF_SAS_REQUEST_T       * fw_request,
 994    SCI_STATUS                 status
 995 )
 996 {
 997    SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T *)fw_request;
 998    // save the retry count.
 999    U8 io_retry_count = fw_io->retry_count;
1000
1001    if (fw_request->is_internal)
1002    {
1003       // Complete this internal io request now. We want to free this io before
1004       // we create another SMP request, which is going to happen soon.
1005       scif_sas_internal_io_request_complete(
1006          fw_device->domain->controller,
1007          (SCIF_SAS_INTERNAL_IO_REQUEST_T *)fw_request,
1008          SCI_SUCCESS
1009       );
1010    }
1011
1012    if (fw_device->protocol_device.smp_device.current_activity ==
1013       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_DISCOVER)
1014    {
1015       if (status == SCI_SUCCESS)
1016       {   //continue the discover process.
1017          scif_sas_smp_remote_device_continue_discover(fw_device);
1018       }
1019       else if (status == SCI_FAILURE_RETRY_REQUIRED)
1020       {
1021          //Retry the smp request. Since we are in the middle of Discover
1022          //process, all the smp requests are internal. A new smp request
1023          //will be created for retry.
1024          U32 retry_wait_duration = (SCIF_DOMAIN_DISCOVER_TIMEOUT / 2) / SCIF_SAS_IO_RETRY_LIMIT;
1025
1026          if (io_retry_count < SCIF_SAS_IO_RETRY_LIMIT)
1027             scif_sas_smp_remote_device_retry_internal_io (
1028                fw_device, io_retry_count, retry_wait_duration);
1029          else
1030             scif_sas_smp_remote_device_fail_discover(fw_device);
1031       }
1032       else if (status == SCI_FAILURE_ILLEGAL_ROUTING_ATTRIBUTE_CONFIGURATION)
1033       {
1034          //remove this expander device and its child devices. No need to
1035          //continue the discover on this device.
1036          scif_sas_domain_remove_expander_device(fw_device->domain, fw_device);
1037
1038          //continue the domain's smp discover.
1039          scif_sas_domain_continue_discover(fw_device->domain);
1040       }
1041       else
1042       {  //terminate the discover process.
1043          scif_sas_smp_remote_device_fail_discover(fw_device);
1044       }
1045    }
1046    else if (fw_device->protocol_device.smp_device.current_activity ==
1047       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET)
1048    {
1049       if (status == SCI_SUCCESS)
1050       {   //continue the target reset process.
1051          scif_sas_smp_remote_device_continue_target_reset(
1052             fw_device, fw_request);
1053       }
1054       else if (status == SCI_FAILURE_RETRY_REQUIRED)
1055       {
1056          //Retry the same smp request. Since we are in the middle of Target
1057          //reset process, all the smp requests are using external resource.
1058          //We will use the exactly same memory to retry.
1059          if (io_retry_count < SCIF_SAS_IO_RETRY_LIMIT)
1060          {
1061             if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
1062             {
1063                //create the timer to wait before retry.
1064                fw_device->protocol_device.smp_device.smp_activity_timer =
1065                   scif_cb_timer_create(
1066                   (SCI_CONTROLLER_HANDLE_T *)fw_device->domain->controller,
1067                   (SCI_TIMER_CALLBACK_T)scif_sas_smp_external_request_retry,
1068                   (void*)fw_request
1069                );
1070             }
1071             else
1072             {
1073                ASSERT(0);
1074             }
1075
1076             //start the timer to wait
1077             scif_cb_timer_start(
1078                (SCI_CONTROLLER_HANDLE_T)fw_device->domain->controller,
1079                fw_device->protocol_device.smp_device.smp_activity_timer,
1080                SMP_REQUEST_RETRY_WAIT_DURATION  //20 miliseconds
1081             );
1082          }
1083          else
1084             scif_sas_smp_remote_device_fail_target_reset(fw_device, fw_request);
1085       }
1086       else
1087          //terminate the discover process.
1088          scif_sas_smp_remote_device_fail_target_reset(fw_device, fw_request);
1089    }
1090    else if (fw_device->protocol_device.smp_device.current_activity ==
1091       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_SATA_SPINUP_HOLD_RELEASE)
1092    {
1093       SCIF_SAS_REMOTE_DEVICE_T * target_device =
1094          scif_sas_domain_get_device_by_containing_device(
1095             fw_device->domain,
1096             fw_device,
1097             fw_device->protocol_device.smp_device.current_activity_phy_index
1098          );
1099
1100       if (status == SCI_SUCCESS)
1101       {
1102          //move on to next round of SPINUP_HOLD_REALSE activity.
1103          scif_sas_smp_remote_device_sata_spinup_hold_release(fw_device);
1104       }
1105       else if (status == SCI_FAILURE_RETRY_REQUIRED)
1106       {
1107          U32 delay =
1108             (scic_remote_device_get_suggested_reset_timeout(target_device->core_object) /
1109                 SCIF_SAS_IO_RETRY_LIMIT);
1110
1111          //Retry the smp request. Since we are in the middle of Discover
1112          //process, all the smp requests are internal. A new smp request
1113          //will be created for retry.
1114          if (io_retry_count < SCIF_SAS_IO_RETRY_LIMIT)
1115          {
1116             scif_sas_smp_remote_device_retry_internal_io(
1117                fw_device, io_retry_count, delay);
1118          }
1119          else //give up on this target device.
1120          {
1121             scif_sas_smp_remote_device_fail_target_spinup_hold_release(
1122                fw_device , target_device);
1123          }
1124       }
1125       else //give up on this target device.
1126         scif_sas_smp_remote_device_fail_target_spinup_hold_release(
1127            fw_device, target_device);
1128    }
1129    else if (fw_device->protocol_device.smp_device.current_activity ==
1130       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE)
1131    {
1132       SCI_FAST_LIST_ELEMENT_T * next_phy_element = sci_fast_list_get_next(
1133          &(fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element) );
1134
1135       SCI_FAST_LIST_T * destination_smp_phy_list =
1136           fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element.owning_list;
1137
1138       SCIF_SAS_SMP_PHY_T * next_phy_in_wide_port = NULL;
1139
1140       if (next_phy_element != NULL
1141           && status != SCI_FAILURE_EXCEED_MAX_ROUTE_INDEX)
1142       {
1143          fw_device->protocol_device.smp_device.curr_config_route_index++;
1144
1145          fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy =
1146             (SCIF_SAS_SMP_PHY_T *)sci_fast_list_get_object(next_phy_element);
1147
1148          // Update the anchor for config route index.
1149          fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->config_route_table_index_anchor =
1150             fw_device->protocol_device.smp_device.curr_config_route_index;
1151
1152          scif_sas_smp_remote_device_configure_route_table(fw_device);
1153       }
1154       else if ( scif_sas_smp_remote_device_get_config_route_table_method(fw_device)
1155                    == SCIF_SAS_CONFIG_ROUTE_TABLE_ALL_PHYS
1156                 && (next_phy_in_wide_port = scif_sas_smp_phy_find_next_phy_in_wide_port(
1157                        fw_device->protocol_device.smp_device.config_route_smp_phy_anchor)
1158                    )!= NULL
1159               )
1160       {
1161          //config the other phy in the same wide port
1162          fw_device->protocol_device.smp_device.config_route_smp_phy_anchor =
1163             next_phy_in_wide_port;
1164
1165          fw_device->protocol_device.smp_device.current_activity_phy_index =
1166             fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier;
1167
1168          fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy =
1169             sci_fast_list_get_head(destination_smp_phy_list);
1170
1171          if (fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->config_route_table_index_anchor != 0)
1172             fw_device->protocol_device.smp_device.curr_config_route_index =
1173                fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->config_route_table_index_anchor + 1;
1174          else
1175             fw_device->protocol_device.smp_device.curr_config_route_index = 0;
1176
1177          scif_sas_smp_remote_device_configure_route_table(fw_device);
1178       }
1179       else if ( fw_device->protocol_device.smp_device.is_route_table_cleaned == FALSE)
1180       {
1181          fw_device->protocol_device.smp_device.current_activity =
1182             SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAN_ROUTE_TABLE;
1183
1184          scif_sas_smp_remote_device_clean_route_table(fw_device);
1185       }
1186       else
1187       {
1188          //set this device's activity to NON.
1189          fw_device->protocol_device.smp_device.current_activity =
1190             SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
1191
1192          //we need to notify domain that this device finished config route table, domain
1193          //may pick up other activities (i.e. Discover) for other expanders.
1194          scif_sas_domain_continue_discover(fw_device->domain);
1195       }
1196    }
1197    else if (fw_device->protocol_device.smp_device.current_activity ==
1198                SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAN_ROUTE_TABLE)
1199    {
1200       scif_sas_smp_remote_device_clean_route_table(fw_device);
1201    }
1202    else if (fw_device->protocol_device.smp_device.current_activity ==
1203                SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CLEAR_AFFILIATION)
1204    {
1205       scif_sas_smp_remote_device_continue_clear_affiliation(fw_device);
1206    }
1207 }
1208
1209
1210 /**
1211  * @brief This method continues the smp Discover process.
1212  *
1213  * @param[in] fw_device The framework smp device that a DISCOVER command
1214  *       targets to.
1215  *
1216  * @return none
1217  */
1218 void scif_sas_smp_remote_device_continue_discover(
1219    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1220 )
1221 {
1222    SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
1223
1224    SCIF_LOG_TRACE((
1225       sci_base_object_get_logger(fw_device),
1226       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1227       "scif_sas_smp_remote_device_continue_discover(0x%x) enter\n",
1228       fw_device
1229    ));
1230
1231    switch (fw_device->protocol_device.smp_device.current_smp_request)
1232    {
1233       case SMP_FUNCTION_REPORT_GENERAL:
1234          // send the REPORT MANUFACTURER_INFO request
1235          fw_device->protocol_device.smp_device.current_smp_request =
1236             SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION;
1237
1238          scif_sas_smp_request_construct_report_manufacturer_info(
1239             fw_domain->controller, fw_device
1240          );
1241
1242          break;
1243
1244       case SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION:
1245          //send the first SMP DISCOVER request.
1246          fw_device->protocol_device.smp_device.current_activity_phy_index = 0;
1247          fw_device->protocol_device.smp_device.current_smp_request =
1248             SMP_FUNCTION_DISCOVER;
1249
1250          scif_sas_smp_request_construct_discover(
1251             fw_domain->controller,
1252             fw_device,
1253             fw_device->protocol_device.smp_device.current_activity_phy_index,
1254             NULL, NULL
1255          );
1256          break;
1257
1258
1259       case SMP_FUNCTION_DISCOVER:
1260          fw_device->protocol_device.smp_device.current_activity_phy_index++;
1261
1262          if ( (fw_device->protocol_device.smp_device.current_activity_phy_index <
1263                   fw_device->protocol_device.smp_device.number_of_phys) )
1264          {
1265             scif_sas_smp_request_construct_discover(
1266                fw_domain->controller,
1267                fw_device,
1268                fw_device->protocol_device.smp_device.current_activity_phy_index,
1269                NULL, NULL
1270             );
1271          }
1272          else
1273             scif_sas_smp_remote_device_finish_initial_discover(fw_device);
1274          break;
1275
1276
1277       case SMP_FUNCTION_REPORT_PHY_SATA:
1278          scif_sas_smp_request_construct_report_phy_sata(
1279             fw_device->domain->controller,
1280             fw_device,
1281             fw_device->protocol_device.smp_device.current_activity_phy_index
1282          );
1283
1284          break;
1285
1286
1287       case SMP_FUNCTION_PHY_CONTROL:
1288          scif_sas_smp_request_construct_phy_control(
1289             fw_device->domain->controller,
1290             fw_device,
1291             PHY_OPERATION_HARD_RESET,
1292             fw_device->protocol_device.smp_device.current_activity_phy_index,
1293             NULL,
1294             NULL
1295          );
1296
1297          break;
1298
1299       default:
1300          break;
1301    }
1302 }
1303
1304 /**
1305  * @brief This method finishes the initial smp DISCOVER process. There
1306  *        may be a spinup_hold release phase following of initial discover,
1307  *        depending on whether there are SATA device in the domain
1308  *        in SATA_SPINUP_HOLD condition.
1309  *
1310  * @param[in] fw_device The framework smp device that finishes all the
1311  *       DISCOVER requests.
1312  *
1313  * @return none
1314  */
1315 void scif_sas_smp_remote_device_finish_initial_discover(
1316    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1317 )
1318 {
1319    SCIF_SAS_REMOTE_DEVICE_T * device_in_sata_spinup_hold =
1320       scif_sas_domain_find_device_in_spinup_hold(fw_device->domain);
1321
1322    SCIF_LOG_TRACE((
1323       sci_base_object_get_logger(fw_device),
1324       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1325       "scif_sas_smp_remote_device_finish_initial_discover(0x%x) enter\n",
1326       fw_device
1327    ));
1328
1329    if ( device_in_sata_spinup_hold != NULL )
1330    {
1331      //call the common private routine to reset all fields of this smp device.
1332      scif_sas_smp_remote_device_clear(fw_device);
1333
1334      //Move on to next activity SPINUP_HOLD_RELEASE
1335      fw_device->protocol_device.smp_device.current_activity =
1336         SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_SATA_SPINUP_HOLD_RELEASE;
1337
1338       //create the timer to delay a little bit before going to
1339       //sata spinup hold release activity.
1340       if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
1341       {
1342       fw_device->protocol_device.smp_device.smp_activity_timer =
1343          scif_cb_timer_create(
1344             (SCI_CONTROLLER_HANDLE_T *)fw_device->domain->controller,
1345             (SCI_TIMER_CALLBACK_T)scif_sas_smp_remote_device_sata_spinup_hold_release,
1346             (void*)fw_device
1347          );
1348       }
1349       else
1350       {
1351          ASSERT (0);
1352       }
1353
1354       scif_cb_timer_start(
1355          (SCI_CONTROLLER_HANDLE_T)fw_device->domain->controller,
1356          fw_device->protocol_device.smp_device.smp_activity_timer,
1357          SMP_SPINUP_HOLD_RELEASE_WAIT_DURATION
1358       );
1359    }
1360    else
1361       scif_sas_smp_remote_device_finish_discover(fw_device);
1362 }
1363
1364
1365 /**
1366  * @brief This method finishes the smp DISCOVER process.
1367  *
1368  * @param[in] fw_device The framework smp device that finishes all the
1369  *       DISCOVER requests.
1370  *
1371  * @return none
1372  */
1373 void scif_sas_smp_remote_device_finish_discover(
1374    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1375 )
1376 {
1377    SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
1378
1379    SCIF_LOG_TRACE((
1380       sci_base_object_get_logger(fw_device),
1381       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1382       "scif_sas_smp_remote_device_finish_discover(0x%x) enter\n",
1383       fw_device
1384    ));
1385
1386    if ( fw_domain->is_config_route_table_needed
1387        && fw_device->protocol_device.smp_device.smp_phy_list.list_head != NULL)
1388       scif_sas_smp_remote_device_configure_upstream_expander_route_info(fw_device);
1389
1390    //call the common private routine to reset all fields of this smp device.
1391    scif_sas_smp_remote_device_clear(fw_device);
1392
1393 #ifdef SCI_SMP_PHY_LIST_DEBUG_PRINT
1394    scif_sas_smp_remote_device_print_smp_phy_list(fw_device);
1395 #endif
1396
1397    //notify domain this smp device's discover finishes, it's up to domain
1398    //to continue the discover process in a bigger scope.
1399    scif_sas_domain_continue_discover(fw_domain);
1400 }
1401
1402
1403 /**
1404  * @brief This method continues the smp Target Reset (Phy Control) process.
1405  *
1406  * @param[in] fw_device The framework smp device that a smp reset targets to.
1407  *
1408  * @return none
1409  */
1410 void scif_sas_smp_remote_device_continue_target_reset(
1411    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
1412    SCIF_SAS_REQUEST_T       * fw_request
1413 )
1414 {
1415    SCIF_SAS_CONTROLLER_T * fw_controller = fw_device->domain->controller;
1416    SCIF_SAS_REMOTE_DEVICE_T * target_device =
1417       scif_sas_domain_get_device_by_containing_device(
1418          fw_device->domain,
1419          fw_device,
1420          fw_device->protocol_device.smp_device.current_activity_phy_index
1421       );
1422
1423    SCIF_LOG_TRACE((
1424       sci_base_object_get_logger(fw_device),
1425       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1426       "scif_sas_smp_remote_device_continue_target_reset(0x%x, 0x%x) enter\n",
1427       fw_device, fw_request
1428    ));
1429
1430    if (fw_device->protocol_device.smp_device.current_smp_request ==
1431           SMP_FUNCTION_PHY_CONTROL)
1432    {
1433       //query the core remote device to get suggested reset timeout value
1434       //then scale down by factor of 8 to get the duration of the pause
1435       //before sending out Discover command to poll.
1436       U32 delay =
1437          (scic_remote_device_get_suggested_reset_timeout(target_device->core_object)/8);
1438
1439       //create the timer to send Discover command polling target device's
1440       //coming back.
1441       if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
1442       {
1443          fw_device->protocol_device.smp_device.smp_activity_timer =
1444             scif_cb_timer_create(
1445                (SCI_CONTROLLER_HANDLE_T *)fw_controller,
1446                (SCI_TIMER_CALLBACK_T)scif_sas_smp_remote_device_target_reset_poll,
1447                (void*)fw_request
1448             );
1449       }
1450       else
1451       {
1452          ASSERT(0);
1453       }
1454
1455       //start the timer
1456       scif_cb_timer_start(
1457          (SCI_CONTROLLER_HANDLE_T)fw_controller,
1458          fw_device->protocol_device.smp_device.smp_activity_timer,
1459          delay
1460       );
1461    }
1462    else if (fw_device->protocol_device.smp_device.current_smp_request ==
1463           SMP_FUNCTION_DISCOVER)
1464    {
1465       //tell target reset successful
1466       scif_sas_remote_device_target_reset_complete(
1467          target_device, fw_request, SCI_SUCCESS);
1468    }
1469 }
1470
1471 /**
1472  * @brief This routine is invoked by timer or when 2 BCN are received
1473  *        after Phy Control command. This routine will construct a
1474  *        Discover command to the same expander phy to poll the target
1475  *        device's coming back. This new request is then put into
1476  *        high priority queue and will be started by a DPC soon.
1477  *
1478  * @param[in] fw_request The scif request for smp activities.
1479  */
1480 void scif_sas_smp_remote_device_target_reset_poll(
1481    SCIF_SAS_REQUEST_T       * fw_request
1482 )
1483 {
1484    SCIF_SAS_REMOTE_DEVICE_T * fw_device = fw_request->device;
1485    SCIF_SAS_CONTROLLER_T * fw_controller = fw_device->domain->controller;
1486    void * new_command_handle;
1487
1488    SCIF_LOG_TRACE((
1489       sci_base_object_get_logger(fw_device),
1490       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1491       "scif_sas_smp_remote_device_target_reset_poll(0x%x) enter\n",
1492       fw_request
1493    ));
1494
1495    // Before we construct new io using the same memory, we need to
1496    // remove the IO from the list of outstanding requests on the domain
1497    // so that we don't damage the domain's fast list of request.
1498    sci_fast_list_remove_element(&fw_request->list_element);
1499
1500    fw_device->protocol_device.smp_device.current_smp_request =
1501       SMP_FUNCTION_DISCOVER;
1502
1503    //sent smp discover request to poll on remote device's coming back.
1504    //construct Discover command using the same memory as fw_request.
1505    new_command_handle = scif_sas_smp_request_construct_discover(
1506       fw_device->domain->controller,
1507       fw_device,
1508       fw_device->protocol_device.smp_device.current_activity_phy_index,
1509       (void *)sci_object_get_association(fw_request),
1510       (void *)fw_request
1511    );
1512
1513    //put into the high priority queue.
1514    sci_pool_put(fw_controller->hprq.pool, (POINTER_UINT) new_command_handle);
1515
1516    //schedule the DPC to start new Discover command.
1517    scif_cb_start_internal_io_task_schedule(
1518       fw_controller, scif_sas_controller_start_high_priority_io, fw_controller
1519    );
1520 }
1521
1522
1523 /**
1524  * @brief This method fails discover process.
1525  *
1526  * @param[in] fw_device The framework smp device that failed at current
1527  *       activity.
1528  *
1529  * @return none
1530  */
1531 void scif_sas_smp_remote_device_fail_discover(
1532    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1533 )
1534 {
1535    SCIF_LOG_TRACE((
1536       sci_base_object_get_logger(fw_device),
1537       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1538       "scif_sas_smp_remote_device_fail_discover(0x%x) enter\n",
1539       fw_device
1540    ));
1541
1542    switch (fw_device->protocol_device.smp_device.current_smp_request)
1543    {
1544       case SMP_FUNCTION_REPORT_GENERAL:
1545       case SMP_FUNCTION_REPORT_MANUFACTURER_INFORMATION:
1546          scif_sas_smp_remote_device_finish_discover(fw_device);
1547          break;
1548
1549       case SMP_FUNCTION_DISCOVER:
1550       case SMP_FUNCTION_REPORT_PHY_SATA:
1551          //Retry limit reached, we will continue to send DISCOVER to next phy.
1552          fw_device->protocol_device.smp_device.current_smp_request =
1553             SMP_FUNCTION_DISCOVER;
1554
1555          scif_sas_smp_remote_device_continue_discover(fw_device);
1556          break;
1557
1558       default:
1559          break;
1560    }
1561 }
1562
1563
1564 /**
1565  * @brief This method fails Target Reset.
1566  *
1567  * @param[in] fw_device The framework smp device that failed at current
1568  *       activity.
1569  * @param[in] fw_request The smp request created for target reset
1570  *       using external resource.
1571  *
1572  * @return none
1573  */
1574 void scif_sas_smp_remote_device_fail_target_reset(
1575    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
1576    SCIF_SAS_REQUEST_T       * fw_request
1577 )
1578 {
1579    SCIF_SAS_REMOTE_DEVICE_T * target_device =
1580       scif_sas_domain_get_device_by_containing_device(
1581          fw_device->domain,
1582          fw_device,
1583          fw_device->protocol_device.smp_device.current_activity_phy_index
1584       );
1585
1586    SCIF_LOG_TRACE((
1587       sci_base_object_get_logger(fw_device),
1588       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1589       "scif_sas_smp_remote_device_fail_target_reset(0x%x, 0x%x, 0x%x) enter\n",
1590       fw_device, target_device, fw_request
1591    ));
1592
1593    //tell target reset failed
1594    scif_sas_remote_device_target_reset_complete(
1595       target_device, fw_request, SCI_FAILURE);
1596 }
1597
1598 /**
1599  * @brief This method init or continue the SATA SPINUP_HOLD RELEASE activity.
1600  * This function searches domain's device list, find a device in STOPPED STATE
1601  * and its connection_rate is SPINIP, then send DISCOVER command to its expander
1602  * phy id to poll. But if searching the domain's device list for SATA devices on
1603  * SPINUP_HOLD finds no device, the activity SPINUP_HOLD_RELEASE is finished.
1604  * We then call fw_domain->device_start_complete_handler() for this smp-device.
1605  *
1606  * @param[in] fw_device The framework smp device that is on SATA SPINUP_HOLD_RELEASE
1607  *       activity.
1608  *
1609  * @return none
1610  */
1611 void scif_sas_smp_remote_device_sata_spinup_hold_release(
1612    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1613 )
1614 {
1615    SCIF_SAS_DOMAIN_T        * fw_domain = fw_device->domain;
1616    SCIF_SAS_CONTROLLER_T    * fw_controller = fw_domain->controller;
1617    SCIF_SAS_REMOTE_DEVICE_T * device_to_poll = NULL;
1618
1619    SCIF_LOG_TRACE((
1620       sci_base_object_get_logger(fw_device),
1621       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1622       "scif_sas_smp_remote_device_sata_spinup_hold_release(0x%x) enter\n",
1623       fw_device
1624    ));
1625
1626    //search throught domain's device list to find a sata device on spinup_hold
1627    //state to poll.
1628    device_to_poll = scif_sas_domain_find_device_in_spinup_hold(fw_domain);
1629
1630    if (device_to_poll != NULL)
1631    {
1632       //send DISCOVER command to this device's expaner phy.
1633       fw_device->protocol_device.smp_device.current_smp_request =
1634          SMP_FUNCTION_DISCOVER;
1635
1636       fw_device->protocol_device.smp_device.current_activity_phy_index =
1637         device_to_poll->expander_phy_identifier;
1638
1639       scif_sas_smp_request_construct_discover(
1640          fw_domain->controller,
1641          fw_device,
1642          fw_device->protocol_device.smp_device.current_activity_phy_index,
1643          NULL, NULL
1644       );
1645
1646       //schedule the DPC to start new Discover command.
1647       scif_cb_start_internal_io_task_schedule(
1648          fw_controller, scif_sas_controller_start_high_priority_io, fw_controller
1649       );
1650    }
1651    else //SATA SPINUP HOLD RELEASE activity is done.
1652       scif_sas_smp_remote_device_finish_discover (fw_device);
1653 }
1654
1655
1656 /**
1657  * @brief This method fail an action of SATA SPINUP_HOLD RELEASE on a single EA
1658  *        SATA device. It will remove a remote_device object for a sata device
1659  *        that fails to come out of spinup_hold.
1660  *
1661  * @param[in] fw_device The framework smp device that is on SATA SPINUP_HOLD_RELEASE
1662  *       activity.
1663  * @param[in] target_device The expander attached device failed being brought out
1664  *       of SPINUP_HOLD state.
1665  *
1666  * @return none
1667  */
1668 void scif_sas_smp_remote_device_fail_target_spinup_hold_release(
1669    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
1670    SCIF_SAS_REMOTE_DEVICE_T * target_device
1671 )
1672 {
1673    SCIF_SAS_DOMAIN_T * fw_domain = fw_device->domain;
1674
1675    SCIF_LOG_TRACE((
1676       sci_base_object_get_logger(fw_device),
1677       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1678       "scif_sas_smp_remote_device_fail_target_spinup_hold_release(0x%x, 0x%x) enter\n",
1679       fw_device, target_device
1680    ));
1681
1682    //need to remove the device, since we have to give up on spinup_hold_release
1683    //activity on this device.
1684    scif_cb_domain_device_removed(
1685       fw_domain->controller, fw_domain, target_device
1686    );
1687
1688    //move on to next round of SPINUP_HOLD_REALSE activity.
1689    scif_sas_smp_remote_device_sata_spinup_hold_release(fw_device);
1690 }
1691
1692
1693 /**
1694  * @brief This method retry only internal IO for the smp device.
1695  *
1696  * @param[in] fw_device The framework smp device that has an smp request to retry.
1697  * @param[in] io_retry_count current count for times the IO being retried.
1698  * @param[in] delay The time delay before the io gets retried.
1699  *
1700  * @return none
1701  */
1702 void scif_sas_smp_remote_device_retry_internal_io(
1703    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
1704    U8                         io_retry_count,
1705    U32                        delay
1706 )
1707 {
1708    SCIF_LOG_TRACE((
1709       sci_base_object_get_logger(fw_device),
1710       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1711       "scif_sas_smp_remote_device_retry_internal_io(0x%x, 0x%x, 0x%x) enter\n",
1712       fw_device, io_retry_count, delay
1713    ));
1714
1715    fw_device->protocol_device.smp_device.io_retry_count =
1716       io_retry_count;
1717
1718    //create the timer for poll target device's coming back.
1719    if (fw_device->protocol_device.smp_device.smp_activity_timer == NULL)
1720    {
1721       fw_device->protocol_device.smp_device.smp_activity_timer =
1722          scif_cb_timer_create(
1723             (SCI_CONTROLLER_HANDLE_T *)fw_device->domain->controller,
1724             (SCI_TIMER_CALLBACK_T)scif_sas_smp_internal_request_retry,
1725             (void*)fw_device
1726          );
1727    }
1728    else
1729    {
1730       ASSERT(0);
1731    }
1732    //start the timer for a purpose of waiting.
1733    scif_cb_timer_start(
1734       (SCI_CONTROLLER_HANDLE_T)fw_device->domain->controller,
1735       fw_device->protocol_device.smp_device.smp_activity_timer,
1736       delay
1737    );
1738 }
1739
1740
1741 /**
1742  * @brief This method indicates whether an expander device is in Discover
1743  *        process.
1744  *
1745  * @param[in] fw_device The framework smp device.
1746  *
1747  * @return Whether an expander device is in the middle of discovery process.
1748  */
1749 BOOL scif_sas_smp_remote_device_is_in_activity(
1750    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1751 )
1752 {
1753    return(fw_device->protocol_device.smp_device.current_activity
1754           != SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE);
1755 }
1756
1757 /**
1758  * @brief This method search through the smp phy list of an expander to
1759  *        find a smp phy by its phy id of the expander.
1760  *
1761  * @param[in] phy_identifier The search criteria.
1762  * @param[in] smp_remote_device The expander that owns the smp phy list.
1763  *
1764  * @return The found smp phy or a NULL pointer to indicate no smp phy is found.
1765  */
1766 SCIF_SAS_SMP_PHY_T * scif_sas_smp_remote_device_find_smp_phy_by_id(
1767    U8                             phy_identifier,
1768    SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device
1769 )
1770 {
1771    SCI_FAST_LIST_ELEMENT_T  * element = smp_remote_device->smp_phy_list.list_head;
1772    SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
1773
1774    ASSERT(phy_identifier < smp_remote_device->smp_phy_list.number_of_phys);
1775
1776    while (element != NULL)
1777    {
1778       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
1779       element = sci_fast_list_get_next(element);
1780
1781       if (curr_smp_phy->phy_identifier == phy_identifier)
1782          return curr_smp_phy;
1783    }
1784
1785    return NULL;
1786 }
1787
1788 /**
1789  * @brief This method takes care of removing smp phy list of a smp devcie, which is
1790  *           about to be removed.
1791  *
1792  * @param[in] fw_device The expander device that is about to be removed.
1793  *
1794  * @return none.
1795  */
1796 void scif_sas_smp_remote_device_removed(
1797    SCIF_SAS_REMOTE_DEVICE_T * this_device
1798 )
1799 {
1800    SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
1801       &this_device->protocol_device.smp_device;
1802
1803    SCI_FAST_LIST_ELEMENT_T  * element = smp_remote_device->smp_phy_list.list_head;
1804    SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
1805
1806    SCIF_LOG_TRACE((
1807       sci_base_object_get_logger(this_device),
1808       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1809       "scif_sas_smp_remote_device_removed(0x%x) enter\n",
1810       this_device
1811    ));
1812
1813    //remove all the smp phys in this device's smp_phy_list, and the conterpart smp phys
1814    //in phy connections.
1815    while (element != NULL)
1816    {
1817       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
1818       element = sci_fast_list_get_next(element);
1819
1820       scif_sas_smp_phy_destruct(curr_smp_phy);
1821    }
1822
1823    this_device->protocol_device.smp_device.number_of_phys = 0;
1824    this_device->protocol_device.smp_device.expander_route_indexes = 0;
1825    this_device->protocol_device.smp_device.is_table_to_table_supported = FALSE;
1826    this_device->protocol_device.smp_device.is_externally_configurable  = FALSE;
1827    this_device->protocol_device.smp_device.is_able_to_config_others    = FALSE;
1828
1829    scif_sas_smp_remote_device_clear(this_device);
1830 }
1831
1832
1833 /**
1834  * @brief This method takes care of terminated smp request to a smp device. The
1835  *        terminated smp request is most likely timeout and being aborted. A timeout
1836  *        maybe due to OPEN REJECT (NO DESTINATION).
1837  *
1838  * @param[in] fw_device The expander device that a timed out smp request towards to.
1839  * @param[in] fw_request A failed smp request that is terminated by scic.
1840  *
1841  * @return none.
1842  */
1843 void scif_sas_smp_remote_device_terminated_request_handler(
1844    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
1845    SCIF_SAS_REQUEST_T       * fw_request
1846 )
1847 {
1848    SCIF_LOG_TRACE((
1849       sci_base_object_get_logger(fw_device),
1850       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1851       "scif_sas_smp_remote_device_terminated_request_handler(0x%x, 0x%x) enter\n",
1852       fw_device, fw_request
1853    ));
1854
1855    scif_sas_smp_remote_device_decode_smp_response(
1856       fw_device, fw_request, NULL, SCI_IO_FAILURE_RETRY_REQUIRED
1857    );
1858 }
1859
1860
1861 /**
1862  * @brief This method allocates and populates the smp phy list of a expander device.
1863  *
1864  * @param[in] fw_device The expander device, whose smp phy list is to be populated after
1865  *                      getting REPORT GENERAL response.
1866  *
1867  * @return none.
1868  */
1869 void scif_sas_smp_remote_device_populate_smp_phy_list(
1870    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1871 )
1872 {
1873    SCIF_SAS_SMP_PHY_T * this_smp_phy = NULL;
1874    U8                   expander_phy_id = 0;
1875
1876    SCIF_LOG_TRACE((
1877       sci_base_object_get_logger(fw_device),
1878       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1879       "scif_sas_smp_remote_device_populate_smp_phy_list(0x%x) enter\n",
1880       fw_device
1881    ));
1882
1883    for ( expander_phy_id = 0;
1884          expander_phy_id < fw_device->protocol_device.smp_device.number_of_phys;
1885          expander_phy_id++ )
1886    {
1887       this_smp_phy =
1888          scif_sas_controller_allocate_smp_phy(fw_device->domain->controller);
1889
1890       ASSERT( this_smp_phy != NULL );
1891
1892       if ( this_smp_phy != NULL )
1893          scif_sas_smp_phy_construct(this_smp_phy, fw_device, expander_phy_id);
1894    }
1895 }
1896
1897
1898 /**
1899  * @brief This method updates a smp phy of a expander device based on DISCOVER response.
1900  *
1901  * @param[in] fw_device The expander device, one of whose smp phys is to be updated.
1902  * @param[in] discover_response The smp DISCOVER response.
1903  *
1904  * @return SCI_STATUS If a smp phy pair between expanders has invalid routing attribute,
1905  *                    return SCI_FAILURE_ILLEGAL_ROUTING_ATTRIBUTE_CONFIGURATION, otherwise,
1906  *                    return SCI_SUCCESS
1907  */
1908 SCI_STATUS scif_sas_smp_remote_device_save_smp_phy_info(
1909    SCIF_SAS_REMOTE_DEVICE_T * fw_device,
1910    SMP_RESPONSE_DISCOVER_T  * discover_response
1911 )
1912 {
1913    SCI_STATUS status = SCI_SUCCESS;
1914    SCIF_SAS_SMP_PHY_T * smp_phy = NULL;
1915    SCIF_SAS_REMOTE_DEVICE_T * attached_device = NULL;
1916
1917     SCIF_LOG_TRACE((
1918       sci_base_object_get_logger(fw_device),
1919       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
1920       "scif_sas_smp_remote_device_save_smp_phy_info(0x%x, 0x%x) enter\n",
1921       fw_device, discover_response
1922    ));
1923
1924    smp_phy = scif_sas_smp_remote_device_find_smp_phy_by_id(
1925                 discover_response->phy_identifier,
1926                 &fw_device->protocol_device.smp_device
1927              );
1928
1929    ASSERT( smp_phy != NULL );
1930
1931    //Note, attached_device could be NULL, not all the smp phy have to connected to a device.
1932    attached_device = (SCIF_SAS_REMOTE_DEVICE_T *)
1933       scif_domain_get_device_by_sas_address(
1934          fw_device->domain, &discover_response->attached_sas_address);
1935
1936    scif_sas_smp_phy_save_information(
1937       smp_phy, attached_device, discover_response);
1938
1939    //handle the special case of smp phys between expanders.
1940    if ( discover_response->protocols.u.bits.attached_smp_target )
1941    {
1942        //this fw_device is a child expander, just found its parent expander.
1943        //And there is no smp_phy constructed yet, record this phy connection.
1944        if ( attached_device != NULL
1945            && attached_device == fw_device->containing_device )
1946        {
1947           //record the smp phy info, for this phy connects to a upstream smp device.
1948           //the connection of a pair of smp phys are completed.
1949           status = scif_sas_smp_phy_set_attached_phy(
1950                       smp_phy,
1951                       discover_response->attached_phy_identifier,
1952                       attached_device
1953                    );
1954
1955           if (status == SCI_SUCCESS)
1956           {
1957              //check the routing attribute for this phy and its containing device's
1958              //expander_phy_routing_attribute.
1959              if ( scif_sas_smp_phy_verify_routing_attribute(
1960                      smp_phy, smp_phy->u.attached_phy) != SCI_SUCCESS )
1961                 return SCI_FAILURE_ILLEGAL_ROUTING_ATTRIBUTE_CONFIGURATION;
1962           }
1963        }
1964     }
1965
1966     return status;
1967 }
1968
1969 #ifdef SCI_SMP_PHY_LIST_DEBUG_PRINT
1970 void scif_sas_smp_remote_device_print_smp_phy_list(
1971    SCIF_SAS_REMOTE_DEVICE_T * fw_device
1972 )
1973 {
1974    SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device = &fw_device->protocol_device.smp_device;
1975    SCI_FAST_LIST_ELEMENT_T  * element = smp_remote_device->smp_phy_list.list_head;
1976    SCIF_SAS_SMP_PHY_T * curr_smp_phy = NULL;
1977
1978    SCIF_LOG_ERROR((
1979       sci_base_object_get_logger(fw_device),
1980       SCIF_LOG_OBJECT_REMOTE_DEVICE,
1981       "==========EXPANDER DEVICE (0x%x) smp phy list========== \n",
1982       fw_device
1983    ));
1984
1985    while (element != NULL)
1986    {
1987       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
1988       element = sci_fast_list_get_next(element);
1989
1990       //print every thing about a smp phy
1991       SCIF_LOG_ERROR((
1992          sci_base_object_get_logger(fw_device),
1993          SCIF_LOG_OBJECT_REMOTE_DEVICE,
1994          "SMP_PHY_%d (0x%x), attached device(0x%x), attached_sas_address(%x%x) attached_device_type(%d), routing_attribute(%d)\n",
1995          curr_smp_phy->phy_identifier, curr_smp_phy,
1996          curr_smp_phy->u.end_device,
1997          curr_smp_phy->attached_sas_address.high, curr_smp_phy->attached_sas_address.low,
1998          curr_smp_phy->attached_device_type,
1999          curr_smp_phy->routing_attribute
2000       ));
2001    }
2002 }
2003 #endif
2004
2005
2006 /**
2007  * @brief This method configure upstream expander(s)' (if there is any) route info.
2008  *
2009  * @param[in] this_device The expander device that is currently in discover process.
2010  *
2011  * @return none.
2012  */
2013 void scif_sas_smp_remote_device_configure_upstream_expander_route_info(
2014    SCIF_SAS_REMOTE_DEVICE_T * this_device
2015 )
2016 {
2017    SCIF_SAS_REMOTE_DEVICE_T * curr_child_expander = this_device;
2018    SCIF_SAS_REMOTE_DEVICE_T * curr_parent_expander =
2019       scif_sas_remote_device_find_upstream_expander(this_device);
2020
2021    SCIF_SAS_REMOTE_DEVICE_T * curr_config_route_info_expander = NULL;
2022
2023    SCIF_LOG_TRACE((
2024       sci_base_object_get_logger(this_device),
2025       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2026       "scif_sas_smp_remote_device_configure_upstream_expander_route_info(0x%x) enter\n",
2027       this_device
2028    ));
2029
2030    //traverse back to find root device.
2031    while(curr_parent_expander != NULL )
2032    {
2033       //must set destination_smp_phy outside of find_upstream_expander() using the device
2034       //that is just about to finish the discovery.
2035       curr_parent_expander->protocol_device.smp_device.curr_config_route_destination_smp_phy =
2036          (SCIF_SAS_SMP_PHY_T*)sci_fast_list_get_object(
2037              this_device->protocol_device.smp_device.smp_phy_list.list_head);
2038
2039       curr_child_expander = curr_parent_expander;
2040       curr_parent_expander = scif_sas_remote_device_find_upstream_expander(curr_child_expander);
2041    }
2042
2043    //found the root device: curr_child_expander. configure it and its downstream expander(s) till
2044    //this_device or a self-configuring expander that configures others;
2045    curr_config_route_info_expander = curr_child_expander;
2046
2047    while ( curr_config_route_info_expander != NULL
2048           && curr_config_route_info_expander != this_device
2049           && curr_config_route_info_expander->protocol_device.smp_device.scheduled_activity
2050                 == SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE
2051          )
2052    {
2053       if (curr_config_route_info_expander->protocol_device.smp_device.is_externally_configurable)
2054       {
2055          SCIF_SAS_SMP_PHY_T * phy_being_config =
2056             curr_config_route_info_expander->protocol_device.smp_device.config_route_smp_phy_anchor;
2057
2058          curr_config_route_info_expander->protocol_device.smp_device.curr_config_route_index =
2059             phy_being_config->config_route_table_index_anchor;
2060
2061          if (curr_config_route_info_expander->protocol_device.smp_device.curr_config_route_index != 0)
2062             curr_config_route_info_expander->protocol_device.smp_device.curr_config_route_index++;
2063
2064          curr_config_route_info_expander->protocol_device.smp_device.scheduled_activity =
2065             SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE;
2066
2067          //Find a downstream expander that has curr_config_route_destination_smp_phy.owning device
2068          //same as curr_config_route_info_expander.
2069          curr_config_route_info_expander = scif_sas_remote_device_find_downstream_expander(
2070             curr_config_route_info_expander);
2071       }
2072       else if (curr_config_route_info_expander->protocol_device.smp_device.is_able_to_config_others)
2073       {
2074          //no need to config route table to this expander and its children.
2075          //find its downstream expander and clear the planned config route table activity.
2076          SCIF_SAS_REMOTE_DEVICE_T * curr_downstream_expander =
2077             scif_sas_remote_device_find_downstream_expander(
2078                curr_config_route_info_expander);
2079
2080          scif_sas_smp_remote_device_clear(curr_config_route_info_expander);
2081
2082          while ( curr_downstream_expander != NULL
2083                 && curr_downstream_expander != this_device )
2084          {
2085             scif_sas_smp_remote_device_clear(curr_downstream_expander);
2086             curr_downstream_expander =
2087                scif_sas_remote_device_find_downstream_expander(
2088                   curr_config_route_info_expander);
2089          }
2090
2091          break;
2092       }
2093       else
2094       {
2095          // current expander is a self-configuring expander, which is not externally
2096          // configurable, and doesn't config others. we need to simply skip this expander.
2097          curr_config_route_info_expander = scif_sas_remote_device_find_downstream_expander(
2098             curr_config_route_info_expander);
2099       }
2100    }
2101 }
2102
2103 /**
2104  * @brief This method finds the immediate upstream expander of a given expander device.
2105  *
2106  * @param[in] this_device The given expander device, whose upstream expander is to be found.
2107  *
2108  * @return The immediate upstream expander. Or a NULL pointer if this_device is root already.
2109  */
2110 SCIF_SAS_REMOTE_DEVICE_T * scif_sas_remote_device_find_upstream_expander(
2111    SCIF_SAS_REMOTE_DEVICE_T * this_device
2112 )
2113 {
2114    SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
2115       &this_device->protocol_device.smp_device;
2116
2117    SCIF_SAS_REMOTE_DEVICE_T    * upstream_expander = NULL;
2118
2119    SCI_FAST_LIST_ELEMENT_T     * element = smp_remote_device->smp_phy_list.list_head;
2120    SCIF_SAS_SMP_PHY_T          * curr_smp_phy = NULL;
2121
2122    SCIF_LOG_TRACE((
2123       sci_base_object_get_logger(this_device),
2124       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2125       "scif_sas_smp_remote_device_configure_upstream_expander_route_info(0x%x) enter\n",
2126       this_device
2127    ));
2128
2129    while (element != NULL)
2130    {
2131       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
2132       element = sci_fast_list_get_next(element);
2133
2134       if ( curr_smp_phy->routing_attribute == SUBTRACTIVE_ROUTING_ATTRIBUTE
2135           && ( curr_smp_phy->attached_device_type == SMP_EDGE_EXPANDER_DEVICE
2136               || curr_smp_phy->attached_device_type == SMP_FANOUT_EXPANDER_DEVICE)
2137           && curr_smp_phy->u.attached_phy != NULL
2138           && curr_smp_phy->u.attached_phy->routing_attribute == TABLE_ROUTING_ATTRIBUTE )
2139       {
2140          //set the current_activity and current_config_route_index for that
2141          //upstream expander.
2142          upstream_expander = curr_smp_phy->u.attached_phy->owning_device;
2143
2144          upstream_expander->protocol_device.smp_device.current_smp_request =
2145             SMP_FUNCTION_CONFIGURE_ROUTE_INFORMATION;
2146
2147          //if the upstream_expander's config route table method is config phy0 only or
2148          //config all phys, the current activity phy is found.
2149          upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor =
2150             scif_sas_smp_remote_device_find_smp_phy_by_id(
2151                curr_smp_phy->u.attached_phy->phy_identifier,
2152                &(curr_smp_phy->u.attached_phy->owning_device->protocol_device.smp_device)
2153             );
2154
2155          //if the upstream_expander's config route table method is config middle phy only
2156          //config highest phy only, the current activity phy needs a update.
2157          if ( scif_sas_smp_remote_device_get_config_route_table_method(upstream_expander)
2158                  == SCIF_SAS_CONFIG_ROUTE_TABLE_MIDDLE_PHY_ONLY )
2159          {
2160             upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor =
2161                scif_sas_smp_phy_find_middle_phy_in_wide_port (
2162                   upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor
2163                );
2164          }
2165          else if ( scif_sas_smp_remote_device_get_config_route_table_method(upstream_expander)
2166                       == SCIF_SAS_CONFIG_ROUTE_TABLE_HIGHEST_PHY_ONLY )
2167          {
2168             upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor =
2169                scif_sas_smp_phy_find_highest_phy_in_wide_port (
2170                   upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor
2171                );
2172          }
2173
2174          upstream_expander->protocol_device.smp_device.current_activity_phy_index =
2175             upstream_expander->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier;
2176
2177          return upstream_expander;
2178       }
2179    }
2180
2181    return NULL;
2182 }
2183
2184
2185 /**
2186  * @brief This method finds the immediate downstream expander of a given expander device.
2187  *
2188  * @param[in] this_device The given expander device, whose downstream expander is to be found.
2189  *
2190  * @return The immediate downstream expander. Or a NULL pointer if there is none.
2191  */
2192 SCIF_SAS_REMOTE_DEVICE_T * scif_sas_remote_device_find_downstream_expander(
2193    SCIF_SAS_REMOTE_DEVICE_T * this_device
2194 )
2195 {
2196    SCIF_SAS_SMP_REMOTE_DEVICE_T * this_smp_remote_device =
2197       &this_device->protocol_device.smp_device;
2198
2199    SCIF_SAS_REMOTE_DEVICE_T    * downstream_expander = NULL;
2200
2201    SCI_FAST_LIST_ELEMENT_T     * element = this_smp_remote_device->smp_phy_list.list_head;
2202    SCIF_SAS_SMP_PHY_T          * curr_smp_phy = NULL;
2203
2204    SCIF_LOG_TRACE((
2205       sci_base_object_get_logger(this_device),
2206       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2207       "scif_sas_remote_device_find_downstream_expander(0x%x) enter\n",
2208       this_device
2209    ));
2210
2211    while (element != NULL)
2212    {
2213       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
2214       element = sci_fast_list_get_next(element);
2215
2216       if ( curr_smp_phy->routing_attribute == TABLE_ROUTING_ATTRIBUTE
2217           && curr_smp_phy->attached_device_type == SMP_EDGE_EXPANDER_DEVICE
2218           && curr_smp_phy->u.attached_phy != NULL)
2219       {
2220          //set the current_activity and current_config_route_index for that
2221          //upstream expander.
2222          downstream_expander = curr_smp_phy->u.attached_phy->owning_device;
2223
2224          if ( downstream_expander->protocol_device.smp_device.curr_config_route_destination_smp_phy != NULL
2225              && downstream_expander->protocol_device.smp_device.curr_config_route_destination_smp_phy->owning_device ==
2226                 this_smp_remote_device->curr_config_route_destination_smp_phy->owning_device )
2227             return downstream_expander;
2228       }
2229    }
2230
2231    return NULL;
2232 }
2233
2234
2235 /**
2236  * @brief This method follows route table optimization rule to check if a destination_device
2237  *        should be recorded in the device_being_config's route table
2238  *
2239  * @param[in] device_being_config The upstream expander device, whose route table is being configured.
2240  * @param[in] destination_smp_phy A smp phy whose attached device is potentially to be
2241  *               recorded in route table.
2242  *
2243  * @return BOOL This method returns TRUE if a destination_device should be recorded in route table.
2244  *              This method returns FALSE if a destination_device need not to be recorded
2245  *              in route table.
2246  */
2247 BOOL scif_sas_smp_remote_device_do_config_route_info(
2248    SCIF_SAS_REMOTE_DEVICE_T * device_being_config,
2249    SCIF_SAS_SMP_PHY_T       * destination_smp_phy
2250 )
2251 {
2252    SCI_SAS_ADDRESS_T device_being_config_sas_address;
2253
2254    SCIF_LOG_TRACE((
2255       sci_base_object_get_logger(device_being_config),
2256       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2257       "scif_sas_smp_remote_device_do_config_route_info(0x%x, 0x%x) enter\n",
2258       device_being_config, destination_smp_phy
2259    ));
2260
2261    scic_remote_device_get_sas_address(
2262       device_being_config->core_object, &device_being_config_sas_address
2263    );
2264
2265    //refer to SAS-2 spec 4.8.3, rule (b)
2266    if ((destination_smp_phy->attached_sas_address.low == 0
2267         && destination_smp_phy->attached_sas_address.high == 0)
2268        && (destination_smp_phy->attached_device_type == SMP_NO_DEVICE_ATTACHED))
2269    {
2270       return FALSE;
2271    }
2272
2273    //refer to SAS-2 spec 4.8.3, rule (c), self-referencing.
2274    if (destination_smp_phy->attached_sas_address.high ==
2275           device_being_config_sas_address.high
2276        && destination_smp_phy->attached_sas_address.low ==
2277              device_being_config_sas_address.low)
2278    {
2279       return FALSE;
2280    }
2281
2282    //There will be no cases that falling into rule (a), (d), (e) to be excluded,
2283    //based on our current mechanism of cofig route table.
2284
2285    return TRUE;
2286 }
2287
2288
2289 /**
2290  * @brief This method configures device_being_config's route table for all the enclosed devices in
2291  *           a downstream smp device, destination_device.
2292  *
2293  * @param[in] device_being_config The upstream expander device, whose route table is being configured.
2294  *
2295  * @return None
2296  */
2297 void scif_sas_smp_remote_device_configure_route_table(
2298    SCIF_SAS_REMOTE_DEVICE_T * device_being_config
2299 )
2300 {
2301    //go through the smp phy list of this_device.
2302    SCI_FAST_LIST_ELEMENT_T     * element =
2303       &(device_being_config->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element);
2304    SCIF_SAS_SMP_PHY_T          * curr_smp_phy = NULL;
2305
2306    SCIF_LOG_TRACE((
2307       sci_base_object_get_logger(device_being_config),
2308       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2309       "scif_sas_smp_remote_device_configure_route_table(0x%x) enter\n",
2310       device_being_config
2311    ));
2312
2313    device_being_config->protocol_device.smp_device.current_activity =
2314       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE;
2315
2316    while (element != NULL)
2317    {
2318       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
2319       element = sci_fast_list_get_next(element);
2320
2321       //check if this phy needs to be added to the expander's route table.
2322       if (scif_sas_smp_remote_device_do_config_route_info(
2323              device_being_config, curr_smp_phy) == TRUE )
2324       {
2325          SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
2326             &device_being_config->protocol_device.smp_device;
2327
2328          smp_remote_device->curr_config_route_destination_smp_phy =
2329             curr_smp_phy;
2330
2331          //Then config this_device's route table entry at the phy and next route_index.
2332          //send config_route_info using curr_smp_phy.phy_identifier and sas_address.
2333          scif_sas_smp_request_construct_config_route_info(
2334             device_being_config->domain->controller,
2335             device_being_config,
2336             smp_remote_device->current_activity_phy_index,
2337             smp_remote_device->curr_config_route_index,
2338             curr_smp_phy->attached_sas_address,
2339             FALSE
2340          );
2341
2342          //schedule the DPC.
2343          scif_cb_start_internal_io_task_schedule(
2344             device_being_config->domain->controller,
2345             scif_sas_controller_start_high_priority_io,
2346             device_being_config->domain->controller
2347          );
2348
2349          //stop here, we need to wait for config route info's response then send
2350          //the next one.
2351          break;
2352       }
2353    }
2354 }
2355
2356
2357 /**
2358  * @brief This method walks through an expander's route table to clean table
2359  *           attribute phys' route entries. This routine finds one table entry
2360  *           to clean and will be called repeatly till it finishes cleanning the
2361  *           whole table.
2362  *
2363  * @param[in] fw_device The expander device, whose route table entry is to be cleaned.
2364  *
2365  * @return None.
2366  */
2367 void scif_sas_smp_remote_device_clean_route_table(
2368    SCIF_SAS_REMOTE_DEVICE_T * fw_device
2369 )
2370 {
2371    SCIF_SAS_SMP_PHY_T * smp_phy_being_config;
2372
2373    SCIF_LOG_TRACE((
2374       sci_base_object_get_logger(fw_device),
2375       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2376       "scif_sas_smp_remote_device_clean_route_table(0x%x) enter\n",
2377       fw_device
2378    ));
2379
2380    //from anchors, start to clean all the other route table entries.
2381    fw_device->protocol_device.smp_device.curr_config_route_index++;
2382
2383    if ( fw_device->protocol_device.smp_device.curr_config_route_index >=
2384            fw_device->protocol_device.smp_device.expander_route_indexes )
2385    {
2386       fw_device->protocol_device.smp_device.curr_config_route_index = 0;
2387
2388       do //find next table attribute PHY.
2389       {
2390          fw_device->protocol_device.smp_device.current_activity_phy_index++;
2391          if (fw_device->protocol_device.smp_device.current_activity_phy_index ==
2392                 fw_device->protocol_device.smp_device.number_of_phys)
2393             fw_device->protocol_device.smp_device.current_activity_phy_index=0;
2394
2395          //phy_index changed, so update the smp_phy_being_config.
2396          smp_phy_being_config =
2397             scif_sas_smp_remote_device_find_smp_phy_by_id(
2398                fw_device->protocol_device.smp_device.current_activity_phy_index,
2399                &(fw_device->protocol_device.smp_device)
2400             );
2401       } while( smp_phy_being_config->routing_attribute != TABLE_ROUTING_ATTRIBUTE );
2402
2403       if ( smp_phy_being_config->phy_identifier !=
2404               fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier)
2405       {
2406          if (smp_phy_being_config->config_route_table_index_anchor != 0)
2407             fw_device->protocol_device.smp_device.curr_config_route_index =
2408                smp_phy_being_config->config_route_table_index_anchor + 1;
2409          else
2410             fw_device->protocol_device.smp_device.curr_config_route_index = 0;
2411       }
2412    }
2413
2414    if ( !(fw_device->protocol_device.smp_device.current_activity_phy_index ==
2415              fw_device->protocol_device.smp_device.config_route_smp_phy_anchor->phy_identifier
2416           && fw_device->protocol_device.smp_device.curr_config_route_index == 0)
2417       )
2418    {
2419       //clean this route entry.
2420       scif_sas_smp_remote_device_clean_route_table_entry(fw_device);
2421    }
2422    else
2423    {
2424       fw_device->protocol_device.smp_device.is_route_table_cleaned = TRUE;
2425
2426       //set this device's activity to NON.
2427       fw_device->protocol_device.smp_device.current_activity =
2428          SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_NONE;
2429
2430       //we need to notify domain that this device finished config route table, domain
2431       //may pick up other activities (i.e. Discover) for other expanders.
2432       scif_sas_domain_continue_discover(fw_device->domain);
2433    }
2434 }
2435
2436 /**
2437  * @brief This method cleans a device's route table antry.
2438  *
2439  * @param[in] fw_device The expander device, whose route table entry is to be cleaned.
2440  *
2441  * @return None.
2442  */
2443 void scif_sas_smp_remote_device_clean_route_table_entry(
2444    SCIF_SAS_REMOTE_DEVICE_T * fw_device
2445 )
2446 {
2447    SCI_SAS_ADDRESS_T empty_sas_address;
2448    SCIF_SAS_SMP_REMOTE_DEVICE_T * smp_remote_device =
2449       &(fw_device->protocol_device.smp_device);
2450
2451    SCIF_LOG_TRACE((
2452       sci_base_object_get_logger(fw_device),
2453       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2454       "scif_sas_smp_remote_device_clean_route_table(0x%x) enter\n",
2455       fw_device
2456    ));
2457
2458    empty_sas_address.high = 0;
2459    empty_sas_address.low = 0;
2460
2461    scif_sas_smp_request_construct_config_route_info(
2462       fw_device->domain->controller,
2463       fw_device,
2464       smp_remote_device->current_activity_phy_index,
2465       smp_remote_device->curr_config_route_index,
2466       empty_sas_address,
2467       TRUE
2468    );
2469
2470    //schedule the DPC.
2471    scif_cb_start_internal_io_task_schedule(
2472       fw_device->domain->controller,
2473       scif_sas_controller_start_high_priority_io,
2474       fw_device->domain->controller
2475    );
2476 }
2477
2478
2479 /**
2480  * @brief This method handles the case of exceeding route index when config route table
2481  *           for a device, by removing the attached device of current config route
2482  *           destination smp phy and the rest of smp phys in the same smp phy list.
2483  *
2484  * @param[in] fw_device The expander device, whose route table to be edited but failed
2485  *               with a SMP function result of INDEX DOES NOT EXIST.
2486  *
2487  * @return None.
2488  */
2489 void scif_sas_smp_remote_device_cancel_config_route_table_activity(
2490    SCIF_SAS_REMOTE_DEVICE_T * fw_device
2491 )
2492 {
2493    //go through the rest of the smp phy list of destination device.
2494    SCI_FAST_LIST_ELEMENT_T     * element =
2495       &(fw_device->protocol_device.smp_device.curr_config_route_destination_smp_phy->list_element);
2496    SCIF_SAS_SMP_PHY_T          * curr_smp_phy = NULL;
2497    SCIF_SAS_REMOTE_DEVICE_T    * curr_attached_device = NULL;
2498
2499    SCIF_LOG_TRACE((
2500       sci_base_object_get_logger(fw_device),
2501       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2502       "scif_sas_smp_remote_device_cancel_config_route_table_activity(0x%x) enter\n",
2503       fw_device
2504    ));
2505
2506    while (element != NULL)
2507    {
2508       curr_smp_phy = (SCIF_SAS_SMP_PHY_T*) sci_fast_list_get_object(element);
2509       element = sci_fast_list_get_next(element);
2510
2511       //check if this phy needs to be added to the expander's route table but can't due to
2512       //exceeding max route index.
2513       if (scif_sas_smp_remote_device_do_config_route_info(
2514              fw_device, curr_smp_phy) == TRUE )
2515       {
2516          //set the is_currently_discovered to FALSE for attached device. Then when
2517          //domain finish discover, domain will remove this device.
2518          curr_attached_device = (SCIF_SAS_REMOTE_DEVICE_T *)
2519             scif_domain_get_device_by_sas_address(
2520                fw_device->domain, &(curr_smp_phy->attached_sas_address));
2521
2522          if (curr_attached_device != NULL)
2523             curr_attached_device->is_currently_discovered = FALSE;
2524       }
2525    }
2526 }
2527
2528
2529 /**
2530  * @brief This method cancel current activity and terminate the outstanding internal IO
2531  *           if there is one.
2532  *
2533  * @param[in] fw_device The expander device, whose smp activity is to be canceled.
2534  *
2535  * @return None.
2536  */
2537 void scif_sas_smp_remote_device_cancel_smp_activity(
2538    SCIF_SAS_REMOTE_DEVICE_T * fw_device
2539 )
2540 {
2541    SCIF_LOG_TRACE((
2542       sci_base_object_get_logger(fw_device),
2543       SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
2544       "scif_sas_smp_remote_device_cancel_smp_activity(0x%x) enter\n",
2545       fw_device
2546    ));
2547
2548    //Terminate all of the requests in the silicon for this device.
2549    scif_sas_domain_terminate_requests(
2550       fw_device->domain, fw_device, NULL, NULL
2551    );
2552
2553    if (fw_device->protocol_device.smp_device.current_activity ==
2554           SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_CONFIG_ROUTE_TABLE)
2555       scif_sas_smp_remote_device_cancel_config_route_table_activity(fw_device);
2556
2557    //Clear the device to stop the smp sctivity.
2558    scif_sas_smp_remote_device_clear(fw_device);
2559 }
2560
2561
2562 /**
2563  * @brief This method tells the way to configure route table for a expander. The
2564  *          possible ways are: configure phy 0's route table, configure middle
2565  *          phy's route table, configure highest order phy's route table,
2566  *          configure all phys.
2567  *
2568  * @param[in] fw_device The expander device, whose config route table method is
2569  *               to be chosen.
2570  *
2571  * @return one in 4 possible options.
2572  */
2573 U8 scif_sas_smp_remote_device_get_config_route_table_method(
2574    SCIF_SAS_REMOTE_DEVICE_T * fw_device
2575 )
2576 {
2577    U8 config_route_table_method;
2578
2579    //config_route_table_method = SCIF_SAS_CONFIG_ROUTE_TABLE_MIDDLE_PHY_ONLY;
2580    config_route_table_method = SCIF_SAS_CONFIG_ROUTE_TABLE_ALL_PHYS;
2581
2582    return config_route_table_method;
2583 }
2584
2585
2586 /**
2587  * @brief This method starts the EA target reset process by constructing
2588  *           and starting a PHY CONTROL (hard reset) smp request.
2589  *
2590  * @param[in] expander_device The expander device, to which a PHY Control smp command is
2591  *               sent.
2592  * @param[in] target_device The expander attahced target device, to which the target reset
2593  *               request is sent.
2594  * @param[in] fw_request The target reset task request.
2595  *
2596  * @return none
2597  */
2598 void scif_sas_smp_remote_device_start_target_reset(
2599    SCIF_SAS_REMOTE_DEVICE_T * expander_device,
2600    SCIF_SAS_REMOTE_DEVICE_T * target_device,
2601    SCIF_SAS_REQUEST_T       * fw_request
2602 )
2603 {
2604    SCIF_SAS_CONTROLLER_T * fw_controller = expander_device->domain->controller;
2605
2606    //set current_activity and current_smp_request to expander device.
2607    expander_device->protocol_device.smp_device.current_activity =
2608       SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET;
2609    expander_device->protocol_device.smp_device.current_smp_request =
2610       SMP_FUNCTION_PHY_CONTROL;
2611    expander_device->protocol_device.smp_device.current_activity_phy_index =
2612       target_device->expander_phy_identifier;
2613
2614    //A Phy Control smp request has been constructed towards parent device.
2615    //Walk the high priority io path.
2616    fw_controller->state_handlers->start_high_priority_io_handler(
2617       (SCI_BASE_CONTROLLER_T*) fw_controller,
2618       (SCI_BASE_REMOTE_DEVICE_T*) expander_device,
2619       (SCI_BASE_REQUEST_T*) fw_request,
2620       SCI_CONTROLLER_INVALID_IO_TAG
2621    );
2622 }
2623
2624