isci: namespacecheck cleanups (35173d57) · Commits · jan.koester / Linux

drivers/scsi/isci/core/sci_base_port.h

+0 −12

Original line number	Diff line number	Diff line
		@@ -188,16 +188,4 @@ struct sci_base_port_state_handler {
		SCI_BASE_PORT_PHY_HANDLER_T remove_phy_handler;

		};

		/**
		* sci_base_port_construct() - Construct the base port object
		* @this_port: This parameter specifies the base port to be constructed.
		* @state_table: This parameter specifies the table of state definitions to be
		* utilized for the domain state machine.
		*
		*/
		void sci_base_port_construct(
		struct sci_base_port *this_port,
		const struct sci_base_state *state_table);

		#endif /* _SCI_BASE_PORT_H_ */

drivers/scsi/isci/core/scic_config_parameters.h

+0 −13

Original line number	Diff line number	Diff line
		@@ -260,19 +260,6 @@ enum sci_status scic_user_parameters_set(
		struct scic_sds_controller *controller,
		union scic_user_parameters *user_parameters);

		/**
		* scic_user_parameters_get() - This method allows the user to retrieve the
		* user parameters utilized by the controller.
		* @controller: This parameter specifies the controller on which to set the
		* user parameters.
		* @user_parameters: This parameter specifies the USER_PARAMETERS object into
		* which the framework shall save it's parameters.
		*
		*/
		void scic_user_parameters_get(
		struct scic_sds_controller *controller,
		union scic_user_parameters *user_parameters);

		/**
		* scic_oem_parameters_set() - This method allows the user to attempt to change
		* the OEM parameters utilized by the controller.

drivers/scsi/isci/core/scic_controller.h

+0 −348

Original line number	Diff line number	Diff line
		@@ -56,14 +56,6 @@
		#ifndef _SCIC_CONTROLLER_H_
		#define _SCIC_CONTROLLER_H_

		/**
		* This file contains all of the interface methods that can be called by an
		* SCIC user on a controller object.
		*
		*
		*/


		#include "sci_status.h"
		#include "sci_controller.h"
		#include "scic_config_parameters.h"
		@@ -79,417 +71,77 @@ enum sci_controller_mode {
		SCI_MODE_SIZE /* Optimized for memory use */
		};


		/**
		* scic_controller_construct() - This method will attempt to construct a
		* controller object utilizing the supplied parameter information.
		* @c: This parameter specifies the controller to be constructed.
		* @scu_base: mapped base address of the scu registers
		* @smu_base: mapped base address of the smu registers
		*
		* Indicate if the controller was successfully constructed or if it failed in
		* some way. SCI_SUCCESS This value is returned if the controller was
		* successfully constructed. SCI_WARNING_TIMER_CONFLICT This value is returned
		* if the interrupt coalescence timer may cause SAS compliance issues for SMP
		* Target mode response processing. SCI_FAILURE_UNSUPPORTED_CONTROLLER_TYPE
		* This value is returned if the controller does not support the supplied type.
		* SCI_FAILURE_UNSUPPORTED_INIT_DATA_VERSION This value is returned if the
		* controller does not support the supplied initialization data version.
		*/
		enum sci_status scic_controller_construct(struct scic_sds_controller *c,
		void __iomem *scu_base,
		void __iomem *smu_base);

		/**
		* scic_controller_enable_interrupts() - This method will enable all controller
		* interrupts.
		* @controller: This parameter specifies the controller for which to enable
		* interrupts.
		*
		*/
		void scic_controller_enable_interrupts(
		struct scic_sds_controller *controller);

		/**
		* scic_controller_disable_interrupts() - This method will disable all
		* controller interrupts.
		* @controller: This parameter specifies the controller for which to disable
		* interrupts.
		*
		*/
		void scic_controller_disable_interrupts(
		struct scic_sds_controller *controller);


		/**
		* scic_controller_initialize() - This method will initialize the controller
		* hardware managed by the supplied core controller object. This method
		* will bring the physical controller hardware out of reset and enable the
		* core to determine the capabilities of the hardware being managed. Thus,
		* the core controller can determine it's exact physical (DMA capable)
		* memory requirements.
		* @controller: This parameter specifies the controller to be initialized.
		*
		* The SCI Core user must have called scic_controller_construct() on the
		* supplied controller object previously. Indicate if the controller was
		* successfully initialized or if it failed in some way. SCI_SUCCESS This value
		* is returned if the controller hardware was successfully initialized.
		*/
		enum sci_status scic_controller_initialize(
		struct scic_sds_controller *controller);

		/**
		* scic_controller_get_suggested_start_timeout() - This method returns the
		* suggested scic_controller_start() timeout amount. The user is free to
		* use any timeout value, but this method provides the suggested minimum
		* start timeout value. The returned value is based upon empirical
		* information determined as a result of interoperability testing.
		* @controller: the handle to the controller object for which to return the
		* suggested start timeout.
		*
		* This method returns the number of milliseconds for the suggested start
		* operation timeout.
		*/
		u32 scic_controller_get_suggested_start_timeout(
		struct scic_sds_controller *controller);

		/**
		* scic_controller_start() - This method will start the supplied core
		* controller. This method will start the staggered spin up operation. The
		* SCI User completion callback is called when the following conditions are
		* met: -# the return status of this method is SCI_SUCCESS. -# after all of
		* the phys have successfully started or been given the opportunity to start.
		* @controller: the handle to the controller object to start.
		* @timeout: This parameter specifies the number of milliseconds in which the
		* start operation should complete.
		*
		* The SCI Core user must have filled in the physical memory descriptor
		* structure via the sci_controller_get_memory_descriptor_list() method. The
		* SCI Core user must have invoked the scic_controller_initialize() method
		* prior to invoking this method. The controller must be in the INITIALIZED or
		* STARTED state. Indicate if the controller start method succeeded or failed
		* in some way. SCI_SUCCESS if the start operation succeeded.
		* SCI_WARNING_ALREADY_IN_STATE if the controller is already in the STARTED
		* state. SCI_FAILURE_INVALID_STATE if the controller is not either in the
		* INITIALIZED or STARTED states. SCI_FAILURE_INVALID_MEMORY_DESCRIPTOR if
		* there are inconsistent or invalid values in the supplied
		* struct sci_physical_memory_descriptor array.
		*/
		enum sci_status scic_controller_start(
		struct scic_sds_controller *controller,
		u32 timeout);

		/**
		* scic_controller_stop() - This method will stop an individual controller
		* object.This method will invoke the associated user callback upon
		* completion. The completion callback is called when the following
		* conditions are met: -# the method return status is SCI_SUCCESS. -# the
		* controller has been quiesced. This method will ensure that all IO
		* requests are quiesced, phys are stopped, and all additional operation by
		* the hardware is halted.
		* @controller: the handle to the controller object to stop.
		* @timeout: This parameter specifies the number of milliseconds in which the
		* stop operation should complete.
		*
		* The controller must be in the STARTED or STOPPED state. Indicate if the
		* controller stop method succeeded or failed in some way. SCI_SUCCESS if the
		* stop operation successfully began. SCI_WARNING_ALREADY_IN_STATE if the
		* controller is already in the STOPPED state. SCI_FAILURE_INVALID_STATE if the
		* controller is not either in the STARTED or STOPPED states.
		*/
		enum sci_status scic_controller_stop(
		struct scic_sds_controller *controller,
		u32 timeout);

		/**
		* scic_controller_reset() - This method will reset the supplied core
		* controller regardless of the state of said controller. This operation is
		* considered destructive. In other words, all current operations are wiped
		* out. No IO completions for outstanding devices occur. Outstanding IO
		* requests are not aborted or completed at the actual remote device.
		* @controller: the handle to the controller object to reset.
		*
		* Indicate if the controller reset method succeeded or failed in some way.
		* SCI_SUCCESS if the reset operation successfully started. SCI_FATAL_ERROR if
		* the controller reset operation is unable to complete.
		*/
		enum sci_status scic_controller_reset(
		struct scic_sds_controller *controller);

		/**
		* scic_controller_start_io() - This method is called by the SCI user to
		* send/start an IO request. If the method invocation is successful, then
		* the IO request has been queued to the hardware for processing.
		* @controller: the handle to the controller object for which to start an IO
		* request.
		* @remote_device: the handle to the remote device object for which to start an
		* IO request.
		* @io_request: the handle to the io request object to start.
		* @io_tag: This parameter specifies a previously allocated IO tag that the
		* user desires to be utilized for this request. This parameter is optional.
		* The user is allowed to supply SCI_CONTROLLER_INVALID_IO_TAG as the value
		* for this parameter.
		*
		* - IO tags are a protected resource. It is incumbent upon the SCI Core user
		* to ensure that each of the methods that may allocate or free available IO
		* tags are handled in a mutually exclusive manner. This method is one of said
		* methods requiring proper critical code section protection (e.g. semaphore,
		* spin-lock, etc.). - For SATA, the user is required to manage NCQ tags. As a
		* result, it is expected the user will have set the NCQ tag field in the host
		* to device register FIS prior to calling this method. There is also a
		* requirement for the user to call scic_stp_io_set_ncq_tag() prior to invoking
		* the scic_controller_start_io() method. scic_controller_allocate_tag() for
		* more information on allocating a tag. Indicate if the controller
		* successfully started the IO request. SCI_IO_SUCCESS if the IO request was
		* successfully started. Determine the failure situations and return values.
		*/
		enum sci_io_status scic_controller_start_io(
		struct scic_sds_controller *controller,
		struct scic_sds_remote_device *remote_device,
		struct scic_sds_request *io_request,
		u16 io_tag);


		/**
		* scic_controller_start_task() - This method is called by the SCIC user to
		* send/start a framework task management request.
		* @controller: the handle to the controller object for which to start the task
		* management request.
		* @remote_device: the handle to the remote device object for which to start
		* the task management request.
		* @task_request: the handle to the task request object to start.
		* @io_tag: This parameter specifies a previously allocated IO tag that the
		* user desires to be utilized for this request. Note this not the io_tag
		* of the request being managed. It is to be utilized for the task request
		* itself. This parameter is optional. The user is allowed to supply
		* SCI_CONTROLLER_INVALID_IO_TAG as the value for this parameter.
		*
		* - IO tags are a protected resource. It is incumbent upon the SCI Core user
		* to ensure that each of the methods that may allocate or free available IO
		* tags are handled in a mutually exclusive manner. This method is one of said
		* methods requiring proper critical code section protection (e.g. semaphore,
		* spin-lock, etc.). - The user must synchronize this task with completion
		* queue processing. If they are not synchronized then it is possible for the
		* io requests that are being managed by the task request can complete before
		* starting the task request. scic_controller_allocate_tag() for more
		* information on allocating a tag. Indicate if the controller successfully
		* started the IO request. SCI_TASK_SUCCESS if the task request was
		* successfully started. SCI_TASK_FAILURE_REQUIRES_SCSI_ABORT This value is
		* returned if there is/are task(s) outstanding that require termination or
		* completion before this request can succeed.
		*/
		enum sci_task_status scic_controller_start_task(
		struct scic_sds_controller *controller,
		struct scic_sds_remote_device *remote_device,
		struct scic_sds_request *task_request,
		u16 io_tag);

		/**
		* scic_controller_complete_task() - This method will perform core specific
		* completion operations for task management request. After this method is
		* invoked, the user should consider the task request as invalid until it is
		* properly reused (i.e. re-constructed).
		* @controller: The handle to the controller object for which to complete the
		* task management request.
		* @remote_device: The handle to the remote device object for which to complete
		* the task management request.
		* @task_request: the handle to the task management request object to complete.
		*
		* Indicate if the controller successfully completed the task management
		* request. SCI_SUCCESS if the completion process was successful.
		*/
		enum sci_status scic_controller_complete_task(
		struct scic_sds_controller *controller,
		struct scic_sds_remote_device *remote_device,
		struct scic_sds_request *task_request);


		/**
		* scic_controller_terminate_request() - This method is called by the SCI Core
		* user to terminate an ongoing (i.e. started) core IO request. This does
		* not abort the IO request at the target, but rather removes the IO request
		* from the host controller.
		* @controller: the handle to the controller object for which to terminate a
		* request.
		* @remote_device: the handle to the remote device object for which to
		* terminate a request.
		* @request: the handle to the io or task management request object to
		* terminate.
		*
		* Indicate if the controller successfully began the terminate process for the
		* IO request. SCI_SUCCESS if the terminate process was successfully started
		* for the request. Determine the failure situations and return values.
		*/
		enum sci_status scic_controller_terminate_request(
		struct scic_sds_controller *controller,
		struct scic_sds_remote_device *remote_device,
		struct scic_sds_request *request);

		/**
		* scic_controller_complete_io() - This method will perform core specific
		* completion operations for an IO request. After this method is invoked,
		* the user should consider the IO request as invalid until it is properly
		* reused (i.e. re-constructed).
		* @controller: The handle to the controller object for which to complete the
		* IO request.
		* @remote_device: The handle to the remote device object for which to complete
		* the IO request.
		* @io_request: the handle to the io request object to complete.
		*
		* - IO tags are a protected resource. It is incumbent upon the SCI Core user
		* to ensure that each of the methods that may allocate or free available IO
		* tags are handled in a mutually exclusive manner. This method is one of said
		* methods requiring proper critical code section protection (e.g. semaphore,
		* spin-lock, etc.). - If the IO tag for a request was allocated, by the SCI
		* Core user, using the scic_controller_allocate_io_tag() method, then it is
		* the responsibility of the caller to invoke the scic_controller_free_io_tag()
		* method to free the tag (i.e. this method will not free the IO tag). Indicate
		* if the controller successfully completed the IO request. SCI_SUCCESS if the
		* completion process was successful.
		*/
		enum sci_status scic_controller_complete_io(
		struct scic_sds_controller *controller,
		struct scic_sds_remote_device *remote_device,
		struct scic_sds_request *io_request);


		/**
		* scic_controller_get_port_handle() - This method simply provides the user
		* with a unique handle for a given SAS/SATA core port index.
		* @controller: This parameter represents the handle to the controller object
		* from which to retrieve a port (SAS or SATA) handle.
		* @port_index: This parameter specifies the port index in the controller for
		* which to retrieve the port handle. 0 <= port_index < maximum number of
		* phys.
		* @port_handle: This parameter specifies the retrieved port handle to be
		* provided to the caller.
		*
		* Indicate if the retrieval of the port handle was successful. SCI_SUCCESS
		* This value is returned if the retrieval was successful.
		* SCI_FAILURE_INVALID_PORT This value is returned if the supplied port id is
		* not in the supported range.
		*/
		enum sci_status scic_controller_get_port_handle(
		struct scic_sds_controller *controller,
		u8 port_index,
		struct scic_sds_port **port_handle);

		/**
		* scic_controller_get_phy_handle() - This method simply provides the user with
		* a unique handle for a given SAS/SATA phy index/identifier.
		* @controller: This parameter represents the handle to the controller object
		* from which to retrieve a phy (SAS or SATA) handle.
		* @phy_index: This parameter specifies the phy index in the controller for
		* which to retrieve the phy handle. 0 <= phy_index < maximum number of phys.
		* @phy_handle: This parameter specifies the retrieved phy handle to be
		* provided to the caller.
		*
		* Indicate if the retrieval of the phy handle was successful. SCI_SUCCESS This
		* value is returned if the retrieval was successful. SCI_FAILURE_INVALID_PHY
		* This value is returned if the supplied phy id is not in the supported range.
		*/
		enum sci_status scic_controller_get_phy_handle(
		struct scic_sds_controller *controller,
		u8 phy_index,
		struct scic_sds_phy **phy_handle);

		/**
		* scic_controller_allocate_io_tag() - This method will allocate a tag from the
		* pool of free IO tags. Direct allocation of IO tags by the SCI Core user
		* is optional. The scic_controller_start_io() method will allocate an IO
		* tag if this method is not utilized and the tag is not supplied to the IO
		* construct routine. Direct allocation of IO tags may provide additional
		* performance improvements in environments capable of supporting this usage
		* model. Additionally, direct allocation of IO tags also provides
		* additional flexibility to the SCI Core user. Specifically, the user may
		* retain IO tags across the lives of multiple IO requests.
		* @controller: the handle to the controller object for which to allocate the
		* tag.
		*
		* IO tags are a protected resource. It is incumbent upon the SCI Core user to
		* ensure that each of the methods that may allocate or free available IO tags
		* are handled in a mutually exclusive manner. This method is one of said
		* methods requiring proper critical code section protection (e.g. semaphore,
		* spin-lock, etc.). An unsigned integer representing an available IO tag.
		* SCI_CONTROLLER_INVALID_IO_TAG This value is returned if there are no
		* currently available tags to be allocated. All return other values indicate a
		* legitimate tag.
		*/
		u16 scic_controller_allocate_io_tag(
		struct scic_sds_controller *controller);

		/**
		* scic_controller_free_io_tag() - This method will free an IO tag to the pool
		* of free IO tags. This method provides the SCI Core user more flexibility
		* with regards to IO tags. The user may desire to keep an IO tag after an
		* IO request has completed, because they plan on re-using the tag for a
		* subsequent IO request. This method is only legal if the tag was
		* allocated via scic_controller_allocate_io_tag().
		* @controller: This parameter specifies the handle to the controller object
		* for which to free/return the tag.
		* @io_tag: This parameter represents the tag to be freed to the pool of
		* available tags.
		*
		* - IO tags are a protected resource. It is incumbent upon the SCI Core user
		* to ensure that each of the methods that may allocate or free available IO
		* tags are handled in a mutually exclusive manner. This method is one of said
		* methods requiring proper critical code section protection (e.g. semaphore,
		* spin-lock, etc.). - If the IO tag for a request was allocated, by the SCI
		* Core user, using the scic_controller_allocate_io_tag() method, then it is
		* the responsibility of the caller to invoke this method to free the tag. This
		* method returns an indication of whether the tag was successfully put back
		* (freed) to the pool of available tags. SCI_SUCCESS This return value
		* indicates the tag was successfully placed into the pool of available IO
		* tags. SCI_FAILURE_INVALID_IO_TAG This value is returned if the supplied tag
		* is not a valid IO tag value.
		*/
		enum sci_status scic_controller_free_io_tag(
		struct scic_sds_controller *controller,
		u16 io_tag);




		/**
		* scic_controller_set_mode() - This method allows the user to configure the
		* SCI core into either a performance mode or a memory savings mode.
		* @controller: This parameter represents the handle to the controller object
		* for which to update the operating mode.
		* @mode: This parameter specifies the new mode for the controller.
		*
		* Indicate if the user successfully change the operating mode of the
		* controller. SCI_SUCCESS The user successfully updated the mode.
		*/
		enum sci_status scic_controller_set_mode(
		struct scic_sds_controller *controller,
		enum sci_controller_mode mode);


		/**
		* scic_controller_set_interrupt_coalescence() - This method allows the user to
		* configure the interrupt coalescence.
		* @controller: This parameter represents the handle to the controller object
		* for which its interrupt coalesce register is overridden.
		* @coalesce_number: Used to control the number of entries in the Completion
		* Queue before an interrupt is generated. If the number of entries exceed
		* this number, an interrupt will be generated. The valid range of the input
		* is [0, 256]. A setting of 0 results in coalescing being disabled.
		* @coalesce_timeout: Timeout value in microseconds. The valid range of the
		* input is [0, 2700000] . A setting of 0 is allowed and results in no
		* interrupt coalescing timeout.
		*
		* Indicate if the user successfully set the interrupt coalesce parameters.
		* SCI_SUCCESS The user successfully updated the interrutp coalescence.
		* SCI_FAILURE_INVALID_PARAMETER_VALUE The user input value is out of range.
		*/
		enum sci_status scic_controller_set_interrupt_coalescence(
		struct scic_sds_controller *controller,
		u32 coalesce_number,
		u32 coalesce_timeout);

		struct device;
		struct scic_sds_controller scic_controller_alloc(struct device dev);


		#endif /* _SCIC_CONTROLLER_H_ */

drivers/scsi/isci/core/scic_io_request.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -325,7 +325,7 @@ enum sci_status scic_io_request_construct(
		struct scic_sds_remote_device *scic_remote_device,
		u16 io_tag,
		void *user_io_request_object,
		void *scic_io_request_memory,
		struct scic_sds_request *scic_io_request_memory,
		struct scic_sds_request **new_scic_io_request_handle);

		/**