File Manager

003 File Manager

Current Path: /usr/src/sys/dev/isci/scil

📁 ..
📄 intel_ata.h(25.31 KB)
📄 intel_pci.h(3.08 KB)
📄 intel_sas.h(30.43 KB)
📄 intel_sat.h(3.79 KB)
📄 intel_sata.h(8.02 KB)
📄 intel_scsi.h(20.25 KB)
📄 sati.c(39.3 KB)
📄 sati.h(10.92 KB)
📄 sati_abort_task_set.c(6.05 KB)
📄 sati_abort_task_set.h(3.27 KB)
📄 sati_atapi.c(8.5 KB)
📄 sati_atapi.h(7.71 KB)
📄 sati_callbacks.h(16.32 KB)
📄 sati_design.h(7.36 KB)
📄 sati_device.c(8.93 KB)
📄 sati_device.h(6.68 KB)
📄 sati_inquiry.c(27.11 KB)
📄 sati_inquiry.h(4.15 KB)
📄 sati_log_sense.c(24.41 KB)
📄 sati_log_sense.h(3.44 KB)
📄 sati_lun_reset.c(4.82 KB)
📄 sati_lun_reset.h(3.16 KB)
📄 sati_mode_pages.c(9.41 KB)
📄 sati_mode_pages.h(4.89 KB)
📄 sati_mode_select.c(37.17 KB)
📄 sati_mode_select.h(3.29 KB)
📄 sati_mode_sense.c(29.7 KB)
📄 sati_mode_sense.h(5.1 KB)
📄 sati_mode_sense_10.c(19.27 KB)
📄 sati_mode_sense_10.h(4.23 KB)
📄 sati_mode_sense_6.c(15.91 KB)
📄 sati_mode_sense_6.h(4.22 KB)
📄 sati_move.c(22.63 KB)
📄 sati_move.h(4.43 KB)
📄 sati_passthrough.c(17.55 KB)
📄 sati_passthrough.h(3.36 KB)
📄 sati_read.c(11.59 KB)
📄 sati_read.h(3.45 KB)
📄 sati_read_buffer.c(8.13 KB)
📄 sati_read_buffer.h(3.15 KB)
📄 sati_read_capacity.c(13.36 KB)
📄 sati_read_capacity.h(3.55 KB)
📄 sati_reassign_blocks.c(21.91 KB)
📄 sati_reassign_blocks.h(3.12 KB)
📄 sati_report_luns.c(5.04 KB)
📄 sati_report_luns.h(3.11 KB)
📄 sati_request_sense.c(12.11 KB)
📄 sati_request_sense.h(3.41 KB)
📄 sati_start_stop_unit.c(14.45 KB)
📄 sati_start_stop_unit.h(4.2 KB)
📄 sati_synchronize_cache.c(4.66 KB)
📄 sati_synchronize_cache.h(2.94 KB)
📄 sati_test_unit_ready.c(6.63 KB)
📄 sati_test_unit_ready.h(3.18 KB)
📄 sati_translator_sequence.h(10.92 KB)
📄 sati_types.h(5.14 KB)
📄 sati_unmap.c(22.99 KB)
📄 sati_unmap.h(4.66 KB)
📄 sati_util.c(72.2 KB)
📄 sati_util.h(13.53 KB)
📄 sati_verify.c(10.08 KB)
📄 sati_verify.h(3.23 KB)
📄 sati_write.c(11.64 KB)
📄 sati_write.h(3.45 KB)
📄 sati_write_and_verify.c(8.64 KB)
📄 sati_write_and_verify.h(3.45 KB)
📄 sati_write_buffer.c(8.94 KB)
📄 sati_write_buffer.h(3.06 KB)
📄 sati_write_long.c(8.25 KB)
📄 sati_write_long.h(3.2 KB)
📄 sci_abstract_list.c(15.87 KB)
📄 sci_abstract_list.h(36.67 KB)
📄 sci_base_controller.c(4.18 KB)
📄 sci_base_controller.h(11.67 KB)
📄 sci_base_domain.c(3.36 KB)
📄 sci_base_domain.h(9.88 KB)
📄 sci_base_iterator.c(5.56 KB)
📄 sci_base_iterator.h(4.34 KB)
📄 sci_base_library.c(3.71 KB)
📄 sci_base_library.h(6.19 KB)
📄 sci_base_logger.c(9.68 KB)
📄 sci_base_logger.h(4.12 KB)
📄 sci_base_memory_descriptor_list.c(5.99 KB)
📄 sci_base_memory_descriptor_list.h(5.97 KB)
📄 sci_base_memory_descriptor_list_decorator.c(5.42 KB)
📄 sci_base_object.c(4.06 KB)
📄 sci_base_object.h(4.74 KB)
📄 sci_base_observer.c(3.79 KB)
📄 sci_base_observer.h(5.39 KB)
📄 sci_base_phy.c(3.32 KB)
📄 sci_base_phy.h(6.67 KB)
📄 sci_base_port.c(3.29 KB)
📄 sci_base_port.h(7.1 KB)
📄 sci_base_remote_device.c(3 KB)
📄 sci_base_remote_device.h(9.65 KB)
📄 sci_base_request.c(2.98 KB)
📄 sci_base_request.h(6.48 KB)
📄 sci_base_state.h(3.6 KB)
📄 sci_base_state_machine.c(7.36 KB)
📄 sci_base_state_machine.h(5.04 KB)
📄 sci_base_state_machine_logger.c(8.77 KB)
📄 sci_base_state_machine_logger.h(5.47 KB)
📄 sci_base_state_machine_observer.c(3.81 KB)
📄 sci_base_state_machine_observer.h(4.67 KB)
📄 sci_base_subject.c(4.91 KB)
📄 sci_base_subject.h(4.8 KB)
📄 sci_controller.h(4.38 KB)
📄 sci_controller_constants.h(7.19 KB)
📄 sci_fast_list.h(11.91 KB)
📄 sci_iterator.h(4.23 KB)
📄 sci_library.h(3.71 KB)
📄 sci_logger.h(9.93 KB)
📄 sci_memory_descriptor_list.h(6.25 KB)
📄 sci_memory_descriptor_list_decorator.h(5.28 KB)
📄 sci_object.h(5.19 KB)
📄 sci_overview.h(10.95 KB)
📄 sci_pool.h(6.18 KB)
📄 sci_simple_list.h(11.04 KB)
📄 sci_status.h(14.61 KB)
📄 sci_types.h(8.59 KB)
📄 sci_util.c(2.72 KB)
📄 sci_util.h(5.54 KB)
📄 scic_config_parameters.h(11.02 KB)
📄 scic_controller.h(35.07 KB)
📄 scic_io_request.h(27 KB)
📄 scic_library.h(9.29 KB)
📄 scic_logger.h(5.26 KB)
📄 scic_overview.h(3.58 KB)
📄 scic_phy.h(15.08 KB)
📄 scic_port.h(8.01 KB)
📄 scic_remote_device.h(16.95 KB)
📄 scic_sds_controller.c(219.91 KB)
📄 scic_sds_controller.h(25.17 KB)
📄 scic_sds_controller_registers.h(15.37 KB)
📄 scic_sds_library.c(8.78 KB)
📄 scic_sds_library.h(3.81 KB)
📄 scic_sds_logger.h(3.33 KB)
📄 scic_sds_pci.c(8.47 KB)
📄 scic_sds_pci.h(4.64 KB)
📄 scic_sds_phy.c(120.86 KB)
📄 scic_sds_phy.h(14.08 KB)
📄 scic_sds_phy_registers.h(9.56 KB)
📄 scic_sds_port.c(104.9 KB)
📄 scic_sds_port.h(16.3 KB)
📄 scic_sds_port_configuration_agent.c(38.16 KB)
📄 scic_sds_port_configuration_agent.h(4.26 KB)
📄 scic_sds_port_registers.h(4.69 KB)
📄 scic_sds_remote_device.c(85.08 KB)
📄 scic_sds_remote_device.h(20.58 KB)
📄 scic_sds_remote_node_context.c(45.54 KB)
📄 scic_sds_remote_node_context.h(12.77 KB)
📄 scic_sds_remote_node_table.c(22.19 KB)
📄 scic_sds_remote_node_table.h(6.63 KB)
📄 scic_sds_request.c(88.54 KB)
📄 scic_sds_request.h(16.53 KB)
📄 scic_sds_sgpio.c(8.43 KB)
📄 scic_sds_smp_remote_device.c(12.13 KB)
📄 scic_sds_smp_request.c(29.64 KB)
📄 scic_sds_smp_request.h(3.01 KB)
📄 scic_sds_ssp_request.c(11.96 KB)
📄 scic_sds_stp_packet_request.c(32.87 KB)
📄 scic_sds_stp_packet_request.h(6.06 KB)
📄 scic_sds_stp_pio_request.h(4.49 KB)
📄 scic_sds_stp_remote_device.c(35.79 KB)
📄 scic_sds_stp_request.c(80.59 KB)
📄 scic_sds_stp_request.h(8.91 KB)
📄 scic_sds_unsolicited_frame_control.c(14.8 KB)
📄 scic_sds_unsolicited_frame_control.h(9.62 KB)
📄 scic_sgpio.h(9.79 KB)
📄 scic_task_request.h(7.41 KB)
📄 scic_user_callback.h(41.37 KB)
📄 scif_config_parameters.h(6.19 KB)
📄 scif_controller.h(17.94 KB)
📄 scif_domain.h(7.18 KB)
📄 scif_io_request.h(10.26 KB)
📄 scif_library.h(6.96 KB)
📄 scif_logger.h(4.54 KB)
📄 scif_overview.h(5.27 KB)
📄 scif_remote_device.h(12.12 KB)
📄 scif_sas_constants.h(2.97 KB)
📄 scif_sas_controller.c(39.23 KB)
📄 scif_sas_controller.h(9.32 KB)
📄 scif_sas_controller_state_handlers.c(66.96 KB)
📄 scif_sas_controller_states.c(13.31 KB)
📄 scif_sas_design.h(15.75 KB)
📄 scif_sas_domain.c(49.41 KB)
📄 scif_sas_domain.h(9.6 KB)
📄 scif_sas_domain_state_handlers.c(58.4 KB)
📄 scif_sas_domain_states.c(20.18 KB)
📄 scif_sas_high_priority_request_queue.c(5.86 KB)
📄 scif_sas_high_priority_request_queue.h(4.5 KB)
📄 scif_sas_internal_io_request.c(9.31 KB)
📄 scif_sas_internal_io_request.h(5.11 KB)
📄 scif_sas_io_request.c(27.08 KB)
📄 scif_sas_io_request.h(5.08 KB)
📄 scif_sas_io_request_state_handlers.c(13.93 KB)
📄 scif_sas_io_request_states.c(8.65 KB)
📄 scif_sas_library.c(8.96 KB)
📄 scif_sas_library.h(3.54 KB)
📄 scif_sas_logger.h(3.33 KB)
📄 scif_sas_remote_device.c(26.69 KB)
📄 scif_sas_remote_device.h(16.3 KB)
📄 scif_sas_remote_device_ready_substate_handlers.c(28.59 KB)
📄 scif_sas_remote_device_ready_substates.c(9.95 KB)
📄 scif_sas_remote_device_starting_substate_handlers.c(11.85 KB)
📄 scif_sas_remote_device_starting_substates.c(5.1 KB)
📄 scif_sas_remote_device_state_handlers.c(43.12 KB)
📄 scif_sas_remote_device_states.c(17.46 KB)
📄 scif_sas_request.c(6.87 KB)
📄 scif_sas_request.h(6.91 KB)
📄 scif_sas_sati_binding.h(11.21 KB)
📄 scif_sas_smp_activity_clear_affiliation.c(8.52 KB)
📄 scif_sas_smp_io_request.c(19.84 KB)
📄 scif_sas_smp_io_request.h(4.87 KB)
📄 scif_sas_smp_phy.c(11.61 KB)
📄 scif_sas_smp_phy.h(5.88 KB)
📄 scif_sas_smp_remote_device.c(92.85 KB)
📄 scif_sas_smp_remote_device.h(13.24 KB)
📄 scif_sas_stp_io_request.c(21.64 KB)
📄 scif_sas_stp_io_request.h(3.7 KB)
📄 scif_sas_stp_remote_device.c(7.46 KB)
📄 scif_sas_stp_remote_device.h(3.99 KB)
📄 scif_sas_stp_task_request.c(9.92 KB)
📄 scif_sas_stp_task_request.h(3.73 KB)
📄 scif_sas_task_request.c(16.16 KB)
📄 scif_sas_task_request.h(4.92 KB)
📄 scif_sas_task_request_state_handlers.c(13.5 KB)
📄 scif_sas_task_request_states.c(8.87 KB)
📄 scif_sas_timer.c(4.4 KB)
📄 scif_task_request.h(5.28 KB)
📄 scif_user_callback.h(37.98 KB)
📄 scu_bios_definitions.h(36.53 KB)
📄 scu_completion_codes.h(10.96 KB)
📄 scu_constants.h(6.55 KB)
📄 scu_event_codes.h(11.77 KB)
📄 scu_registers.h(83.65 KB)
📄 scu_remote_node_context.h(7.11 KB)
📄 scu_task_context.h(26.33 KB)
📄 scu_unsolicited_frame.h(4.1 KB)
📄 scu_viit_data.h(6.23 KB)

Editing: scif_sas_remote_device.c

/*-
 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * BSD LICENSE
 *
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

/**
 * @file
 *
 * @brief This file contains the implementation of the SCIF_SAS_REMOTE_DEVICE
 *        object.
 */

#include <dev/isci/scil/scic_remote_device.h>
#include <dev/isci/scil/scic_port.h>
#include <dev/isci/scil/scic_user_callback.h>

#include <dev/isci/scil/scif_sas_logger.h>
#include <dev/isci/scil/scif_sas_remote_device.h>
#include <dev/isci/scil/scif_sas_stp_remote_device.h>
#include <dev/isci/scil/scif_sas_domain.h>
#include <dev/isci/scil/scif_sas_controller.h>
#include <dev/isci/scil/sci_controller.h>
#include <dev/isci/scil/sci_util.h>

//******************************************************************************
//* P U B L I C   M E T H O D S
//******************************************************************************

U32 scif_remote_device_get_object_size(
   void
)
{
   return ( sizeof(SCIF_SAS_REMOTE_DEVICE_T)
          + scic_remote_device_get_object_size() );
}

// ---------------------------------------------------------------------------

void scif_remote_device_construct(
   SCI_DOMAIN_HANDLE_T          domain,
   void                       * remote_device_memory,
   SCI_REMOTE_DEVICE_HANDLE_T * new_scif_remote_device_handle
)
{
   SCIF_SAS_DOMAIN_T        * fw_domain = (SCIF_SAS_DOMAIN_T *) domain;
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
                                          remote_device_memory;

SCIF_LOG_TRACE((
      sci_base_object_get_logger(fw_domain),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_remote_device_construct(0x%x, 0x%x, 0x%x) enter\n",
      domain, remote_device_memory, new_scif_remote_device_handle
   ));

memset(remote_device_memory, 0, sizeof(SCIF_SAS_REMOTE_DEVICE_T));

// The user's handle to the remote device evaluates to the memory
   // address where the remote device object is stored.
   *new_scif_remote_device_handle = remote_device_memory;

fw_device->domain                = fw_domain;
   fw_device->destruct_when_stopped = FALSE;
   //fw_device->parent.is_failed      = FALSE;
   fw_device->operation_status      = SCI_SUCCESS;
   fw_device->request_count         = 0;
   fw_device->task_request_count    = 0;
   fw_device->is_currently_discovered = TRUE;
   fw_device->containing_device       = NULL;
   fw_device->device_port_width       = 1;
   fw_device->expander_phy_identifier = 0;
   fw_device->destination_state       =
      SCIF_SAS_REMOTE_DEVICE_DESTINATION_STATE_UNSPECIFIED;
   fw_device->ea_target_reset_request_scheduled = NULL;

// Construct the base object first in order to ensure logging can
   // function.
   sci_base_remote_device_construct(
      &fw_device->parent,
      sci_base_object_get_logger(fw_domain),
      scif_sas_remote_device_state_table
   );

sci_base_state_machine_construct(
      &fw_device->starting_substate_machine,
      &fw_device->parent.parent,
      scif_sas_remote_device_starting_substate_table,
      SCIF_SAS_REMOTE_DEVICE_STARTING_SUBSTATE_AWAIT_COMPLETE
   );

sci_base_state_machine_construct(
      &fw_device->ready_substate_machine,
      &fw_device->parent.parent,
      scif_sas_remote_device_ready_substate_table,
      SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
   );

scif_sas_remote_device_initialize_state_logging(fw_device);

scic_remote_device_construct(
      fw_domain->core_object,
      ((U8*) remote_device_memory) + sizeof(SCIF_SAS_REMOTE_DEVICE_T),
      &fw_device->core_object
   );

// Set the association in the core object, so that we are able to
   // determine our framework remote device object from the core remote
   // device.
   sci_object_set_association(fw_device->core_object, fw_device);
}

// ---------------------------------------------------------------------------

SCI_STATUS scif_remote_device_da_construct(
   SCI_REMOTE_DEVICE_HANDLE_T                   remote_device,
   SCI_SAS_ADDRESS_T                          * sas_address,
   SCI_SAS_IDENTIFY_ADDRESS_FRAME_PROTOCOLS_T * protocols
)
{
   SCI_STATUS                 status    = SCI_SUCCESS;
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
                                          remote_device;

SCIF_LOG_TRACE((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_remote_device_da_construct(0x%x, 0x%x, 0x%x) enter\n",
      remote_device, sas_address, protocols
   ));

scic_port_get_properties(fw_device->domain->core_object, &properties);

// Check to see if this is the direct attached device.
      if (  (sas_address->low == properties.remote.sas_address.low)
         && (sas_address->high == properties.remote.sas_address.high) )
      {
         //Get accurate port width from port's phy mask for a DA device.
         SCI_GET_BITS_SET_COUNT(properties.phy_mask, fw_device->device_port_width);

status = scic_remote_device_da_construct(fw_device->core_object);
      }
      else
         // Don't allow the user to construct a direct attached device
         // if it's not a direct attached device.
         status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
   }
   else
      status = SCI_FAILURE_DEVICE_EXISTS;

if (status == SCI_SUCCESS)
   {
      // Add the device to the domain list.
      sci_abstract_list_pushback(
         &fw_device->domain->remote_device_list, fw_device
      );

// If a SATA/STP device is connected, then construct it.
      if (protocols->u.bits.stp_target)
         scif_sas_stp_remote_device_construct(fw_device);
      else if (protocols->u.bits.smp_target)
         scif_sas_smp_remote_device_construct(fw_device);

SCIF_LOG_INFO((
         sci_base_object_get_logger(fw_device),
         SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
         "Domain:0x%x SasAddress:0x%x,0x%x remote device constructed\n",
         fw_device->domain, sas_address->low, sas_address->high
      ));

status = fw_device->state_handlers->parent.start_handler(
                  &fw_device->parent
               );
   }
   else
   {
      SCIF_LOG_WARNING((
         sci_base_object_get_logger(fw_device),
         SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
         "Domain:0x%x SasAddress:0x%x,0x%x Status:0x%x remote device construct failure\n",
         fw_device->domain, sas_address->low, sas_address->high, status
      ));
   }

return status;
}

// ---------------------------------------------------------------------------

SCI_STATUS scif_remote_device_ea_construct(
   SCI_REMOTE_DEVICE_HANDLE_T   remote_device,
   SCI_REMOTE_DEVICE_HANDLE_T   containing_device,
   SMP_RESPONSE_DISCOVER_T    * smp_response
)
{
   SCI_SAS_ADDRESS_T        * sas_address;
   SCI_STATUS                 status        = SCI_SUCCESS;
   SCIF_SAS_REMOTE_DEVICE_T * fw_device     = (SCIF_SAS_REMOTE_DEVICE_T *)
                                              remote_device;
   SCIF_SAS_REMOTE_DEVICE_T * fw_smp_device = (SCIF_SAS_REMOTE_DEVICE_T *)
                                              containing_device;

fw_device->containing_device = fw_smp_device;
   fw_device->expander_phy_identifier =
      fw_smp_device->protocol_device.smp_device.current_activity_phy_index;

sas_address = &smp_response->attached_sas_address;

SCIF_LOG_TRACE((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_remote_device_ea_construct(0x%x, 0x%x) enter\n",
      remote_device, smp_response
   ));

// Make sure the device hasn't already been constructed and added
   // to the domain.
   if (scif_domain_get_device_by_sas_address(fw_device->domain, sas_address)
       == SCI_INVALID_HANDLE)
   {
      //for sata device, we need another routine. likely
      //scif_remote_device_ea_sata_construct.
      status = scic_remote_device_ea_construct(fw_device->core_object, smp_response);
   }
   else
      status = SCI_FAILURE_DEVICE_EXISTS;

if (status == SCI_SUCCESS)
   {
      // Add the device to the domain list.
      sci_abstract_list_pushback(
         &fw_device->domain->remote_device_list, fw_device
      );

if (smp_response->protocols.u.bits.attached_smp_target)
         scif_sas_smp_remote_device_construct(fw_device);
      else if (smp_response->protocols.u.bits.attached_stp_target)
         scif_sas_stp_remote_device_construct(fw_device);

//only start the device if the device is not a SATA disk on SPINUP_HOLD state.
      if ( scic_remote_device_get_connection_rate(fw_device->core_object) !=
              SCI_SATA_SPINUP_HOLD )
      {
          status = fw_device->state_handlers->parent.start_handler(
                      &fw_device->parent
                   );
      }
   }
   else
   {
      SCIF_LOG_WARNING((
         sci_base_object_get_logger(fw_device),
         SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_DOMAIN_DISCOVERY,
         "Domain:0x%x SasAddress:0x%x,0x%x Status:0x%x remote device construct failure\n",
         fw_device->domain, sas_address->low, sas_address->high, status
      ));
   }

return status;
}

// ---------------------------------------------------------------------------

SCI_STATUS scif_remote_device_destruct(
   SCI_REMOTE_DEVICE_HANDLE_T  remote_device
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                          remote_device;

SCIF_LOG_TRACE((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_remote_device_destruct(0x%x) enter\n",
      remote_device
   ));

//remove the device from domain's remote_device_list
   fw_device->domain->state_handlers->device_destruct_handler(
      &fw_device->domain->parent, &fw_device->parent
   );

// The destruct process may not complete immediately, since the core
   // remote device likely needs to be stopped first.  However, the user
   // is not given a callback notification for destruction.
   return fw_device->state_handlers->parent.destruct_handler(
             &fw_device->parent
          );
}

// ---------------------------------------------------------------------------

SCI_REMOTE_DEVICE_HANDLE_T scif_remote_device_get_scic_handle(
   SCI_REMOTE_DEVICE_HANDLE_T  scif_remote_device
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                          scif_remote_device;

if ( (fw_device == NULL) || (fw_device->core_object == SCI_INVALID_HANDLE) )
      return SCI_INVALID_HANDLE;

SCIF_LOG_WARNING((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "RemoteDevice:0x%x no associated core device found\n",
      fw_device
   ));

return fw_device->core_object;
}

// ---------------------------------------------------------------------------

void scic_cb_remote_device_start_complete(
   SCI_CONTROLLER_HANDLE_T    controller,
   SCI_REMOTE_DEVICE_HANDLE_T remote_device,
   SCI_STATUS                 completion_status
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                      sci_object_get_association(remote_device);

SCIF_LOG_TRACE((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_REMOTE_DEVICE_CONFIG,
      "scic_cb_remote_device_start_complete(0x%x, 0x%x, 0x%x) enter\n",
      controller, remote_device, completion_status
   ));

fw_device->state_handlers->start_complete_handler(
      fw_device, completion_status
   );
}

// ---------------------------------------------------------------------------

void scic_cb_remote_device_stop_complete(
   SCI_CONTROLLER_HANDLE_T    controller,
   SCI_REMOTE_DEVICE_HANDLE_T remote_device,
   SCI_STATUS                 completion_status
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                      sci_object_get_association(remote_device);

SCIF_LOG_TRACE((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_REMOTE_DEVICE_CONFIG,
      "scic_cb_remote_device_stop_complete(0x%x, 0x%x, 0x%x) enter\n",
      controller, remote_device, completion_status
   ));

fw_device->state_handlers->stop_complete_handler(
      fw_device, completion_status
   );
}

// ---------------------------------------------------------------------------

void scic_cb_remote_device_ready(
   SCI_CONTROLLER_HANDLE_T     controller,
   SCI_REMOTE_DEVICE_HANDLE_T  remote_device
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                      sci_object_get_association(remote_device);

fw_device->state_handlers->ready_handler(fw_device);
}

// ---------------------------------------------------------------------------

void scic_cb_remote_device_not_ready(
   SCI_CONTROLLER_HANDLE_T     controller,
   SCI_REMOTE_DEVICE_HANDLE_T  remote_device,
   U32                         reason_code
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                      sci_object_get_association(remote_device);

fw_device->state_handlers->not_ready_handler(fw_device,reason_code);
}

// ---------------------------------------------------------------------------

U16 scif_remote_device_get_max_queue_depth(
   SCI_REMOTE_DEVICE_HANDLE_T  remote_device
)
{
   SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
                                          remote_device;
   SMP_DISCOVER_RESPONSE_PROTOCOLS_T  protocols;

scic_remote_device_get_protocols(fw_device->core_object, &protocols);

// If the target is a SATA/STP target, then determine the queue depth
   // for either NCQ or for UDMA.
   if (protocols.u.bits.attached_stp_target)
   {
      if (fw_device->protocol_device.stp_device.sati_device.capabilities
          & SATI_DEVICE_CAP_NCQ_SUPPORTED_ENABLE)
      {
         return fw_device->protocol_device.stp_device.sati_device.ncq_depth;
      }
      else
      {
         // At the moment, we only allow a single UDMA request to be queued.
         return 1;
      }
   }

// For SSP devices return a no maximum queue depth supported.
   return SCIF_REMOTE_DEVICE_NO_MAX_QUEUE_DEPTH;
}

// ---------------------------------------------------------------------------

SCI_STATUS scif_remote_device_get_containing_device(
   SCI_REMOTE_DEVICE_HANDLE_T          remote_device,
   SCI_REMOTE_DEVICE_HANDLE_T        * containing_device
)
{
   SCI_STATUS                 status      = SCI_FAILURE;
   SCIF_SAS_REMOTE_DEVICE_T * this_device = (SCIF_SAS_REMOTE_DEVICE_T *)
                                            remote_device;

if ( (this_device != NULL) && (containing_device != NULL) )
   {
      *containing_device = (SCI_REMOTE_DEVICE_HANDLE_T)(this_device->containing_device);
      if (*containing_device != NULL)
      {
         status = SCI_SUCCESS;
      }
   }

return status;
}

// ---------------------------------------------------------------------------

U32 scif_remote_device_get_started_io_count(
   SCI_REMOTE_DEVICE_HANDLE_T  remote_device
)
{
   SCIF_SAS_REMOTE_DEVICE_T * this_device = (SCIF_SAS_REMOTE_DEVICE_T *)
                                            remote_device;

return this_device->request_count - this_device->task_request_count;
}
//******************************************************************************
//* P R O T E C T E D   M E T H O D S
//******************************************************************************

/*
void scif_sas_remote_device_failure(
   SCIF_SAS_REMOTE_DEVICE_T * fw_device
)
{
   fw_device->parent.is_failed = TRUE;
   sci_base_state_machine_change_state(
      &fw_device->parent.state_machine, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
   );
}
*/

/**
 * @brief This method retrieves info from Report Phy Sata response and
 *        save the additional data for a SATA remote device, if necessary.
 *
 * @param[in] report_phy_sata_response SMP Report Phy Sata response
 *
 * @return none
 */
void scif_sas_remote_device_save_report_phy_sata_information(
   SMP_RESPONSE_REPORT_PHY_SATA_T * report_phy_sata_response
)
{
   //do nothing currently. Later, if needed, we will search the existed
   //remote device by stp_sas_address, then save more information for
   //that device off the report_phy_sata_response. This assumes the
   //stp_sas_address from report_phy_sata response is the same sas address
   //from discover response.

return;
}

/**
 * @brief This method does target reset for DA or EA remote device.
 *
 * @param[in] fw_controller, the controller object the target device belongs
 *            to.
 * @param[in] fw_device, the target device to be hard reset.
 * @param[in] fw_request, the scif task request object that asked for this
 *            target reset.
 */
void scif_sas_remote_device_target_reset(
   SCIF_SAS_REMOTE_DEVICE_T * fw_device,
   SCIF_SAS_REQUEST_T       * fw_request
)
{
   SCIF_LOG_INFO((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_sas_remote_device_target_reset! fw_device:0x%x fw_request:0x%x\n",
      fw_device, fw_request
   ));

if (fw_device->containing_device == NULL)
   {
      SCI_PORT_HANDLE_T port;

port = scif_domain_get_scic_port_handle(fw_device->domain);

//Direct attached device target reset.
      //calling core to do port reset. The fw_request will not be used here.
      scic_port_hard_reset(
         port,
         scic_remote_device_get_suggested_reset_timeout(fw_device->core_object)
      );
   }
   else
   {  //Expander attached device target reset.

if ( fw_device->containing_device->protocol_device.smp_device.current_activity
              == SCIF_SAS_SMP_REMOTE_DEVICE_ACTIVITY_TARGET_RESET )
      {
         //The containing expander is in the middle of target resetting other of its
         //remote disks. Flag this remote device to be target reset later.
         SCIF_LOG_INFO((
            sci_base_object_get_logger(fw_device),
            SCIF_LOG_OBJECT_REMOTE_DEVICE,
            "scif_sas_remote_device_target_reset DELAYED! fw_device:0x%x fw_request:0x%x\n",
            fw_device, fw_request
         ));

fw_device->ea_target_reset_request_scheduled = fw_request;
         return;
      }

//set current_activity and current_smp_request to expander device.
      scif_sas_smp_remote_device_start_target_reset(
         fw_device->containing_device, fw_device, fw_request);
   }

scic_remote_device_reset(fw_device->core_object);
}

/**
 * @brief This method completes target reset for DA or EA remote device.
 *
 * @param[in] fw_device, the target device to be hard reset.
 * @param[in] fw_request, the scif task request object that asked for this
 *            target reset.
 * @param[in] completion_status
 */
void scif_sas_remote_device_target_reset_complete(
   SCIF_SAS_REMOTE_DEVICE_T * fw_device,
   SCIF_SAS_REQUEST_T       * fw_request,
   SCI_STATUS                 completion_status
)
{
   SCIF_LOG_INFO((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_sas_remote_device_target_reset_complete! "
      "fw_device:0x%x fw_request:0x%x completion_status 0x%x\n",
      fw_device, fw_request, completion_status
   ));

scif_cb_task_request_complete(
      fw_device->domain->controller,
      fw_device,
      fw_request,
      (SCI_TASK_STATUS) completion_status
   );

scic_remote_device_reset_complete(fw_device->core_object);

//For expander attached device done target reset.
   if (fw_device->containing_device != NULL)
   {
      //search for all the devices in the domain to find other remote devices
      //needs to be target reset.
      SCIF_SAS_REMOTE_DEVICE_T * next_device;

scif_sas_smp_remote_device_clear(fw_device->containing_device);

if( (next_device = scif_sas_domain_find_next_ea_target_reset(fw_device->domain))
              != NULL )
      {
         scif_sas_smp_remote_device_start_target_reset(
            next_device->containing_device,
            next_device,
            next_device->ea_target_reset_request_scheduled
         );

next_device->ea_target_reset_request_scheduled = NULL;
      }
      else
      {
         //if the domain is in the DISCOVER state, we should resume the DISCOVER.
         if (fw_device->domain->parent.state_machine.current_state_id ==
                SCI_BASE_DOMAIN_STATE_DISCOVERING)
         {
            SCIF_SAS_REMOTE_DEVICE_T * top_expander = fw_device->containing_device;

while(top_expander->containing_device != NULL)
               top_expander = top_expander->containing_device;

scif_sas_domain_start_smp_discover(fw_device->domain, top_expander);
         }
         else
         {
            //Tell driver to kick off Discover process. If the domain is already
            //in Discovery state, this discovery requst will not be carried on.
            scif_cb_domain_change_notification(
            fw_device->domain->controller, fw_device->domain );
         }
      }
   }
   else
   {
      //Tell driver to kick off Discover process. If the domain is already
      //in Discovery state, this discovery requst will not be carried on.
      scif_cb_domain_change_notification(
         fw_device->domain->controller, fw_device->domain );
   }
}

#if !defined(DISABLE_WIDE_PORTED_TARGETS)
SCI_STATUS scif_sas_remote_device_update_port_width(
   SCIF_SAS_REMOTE_DEVICE_T * fw_device,
   U8                         new_port_width
)
{
   SCIF_LOG_INFO((
      sci_base_object_get_logger(fw_device),
      SCIF_LOG_OBJECT_REMOTE_DEVICE,
      "scif_sas_remote_device_update_port_width (0x%x, 0x%x) enter\n",
      fw_device, new_port_width
   ));

fw_device->device_port_width = new_port_width;

//Don't Start a new update of port width if a device is already in
   //UPDATING PORT WIDTH state.
   if (fw_device->parent.state_machine.current_state_id == SCI_BASE_REMOTE_DEVICE_STATE_READY)
   {
      if (fw_device->device_port_width != 0)
      {
         //Change state to UPDATING_PORT_WIDTH
         sci_base_state_machine_change_state(
            &fw_device->parent.state_machine,
            SCI_BASE_REMOTE_DEVICE_STATE_UPDATING_PORT_WIDTH
         );
      }

return SCI_SUCCESS;
   }
   else if (fw_device->parent.state_machine.current_state_id ==
               SCI_BASE_REMOTE_DEVICE_STATE_STARTING)
   {
      fw_device->destination_state =
         SCIF_SAS_REMOTE_DEVICE_DESTINATION_STATE_UPDATING_PORT_WIDTH;
   }

return SCI_FAILURE_INVALID_STATE;
}
#endif //#if !defined(DISABLE_WIDE_PORTED_TARGETS)

#ifdef SCI_LOGGING
void scif_sas_remote_device_initialize_state_logging(
   SCIF_SAS_REMOTE_DEVICE_T * remote_device
)
{
   sci_base_state_machine_logger_initialize(
      &remote_device->parent.state_machine_logger,
      &remote_device->parent.state_machine,
      &remote_device->parent.parent,
      scif_cb_logger_log_states,
      "SCIF_SAS_REMOTE_DEVICE_T", "base_state_machine",
      SCIF_LOG_OBJECT_REMOTE_DEVICE
   );

sci_base_state_machine_logger_initialize(
      &remote_device->starting_substate_machine_logger,
      &remote_device->starting_substate_machine,
      &remote_device->parent.parent,
      scif_cb_logger_log_states,
      "SCIF_SAS_REMOTE_DEVICE_T", "starting substate machine",
      SCIF_LOG_OBJECT_REMOTE_DEVICE
   );

sci_base_state_machine_logger_initialize(
      &remote_device->ready_substate_machine_logger,
      &remote_device->ready_substate_machine,
      &remote_device->parent.parent,
      scif_cb_logger_log_states,
      "SCIF_SAS_REMOTE_DEVICE_T", "ready substate machine",
      SCIF_LOG_OBJECT_REMOTE_DEVICE
   );
}

void scif_sas_remote_device_deinitialize_state_logging(
   SCIF_SAS_REMOTE_DEVICE_T * remote_device
)
{
   sci_base_state_machine_logger_deinitialize(
      &remote_device->parent.state_machine_logger,
      &remote_device->parent.state_machine
   );

sci_base_state_machine_logger_deinitialize(
      &remote_device->starting_substate_machine_logger,
      &remote_device->starting_substate_machine
   );

sci_base_state_machine_logger_deinitialize(
      &remote_device->ready_substate_machine_logger,
      &remote_device->ready_substate_machine
   );
}
#endif // SCI_LOGGING

003 File Manager

Editing: scif_sas_remote_device.c

Upload File

Create Folder