5d147e7383
This removes scic_controller_get_handler_methods and its associated unused code. Signed-off-by: Edmund Nadolski <edmund.nadolski@intel.com> [djbw: kill off the legacy handler, now that we have basic error isr support] Signed-off-by: Dan Williams <dan.j.williams@intel.com>
495 lines
23 KiB
C
495 lines
23 KiB
C
/*
|
|
* 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.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#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"
|
|
|
|
struct scic_sds_request;
|
|
struct scic_sds_phy;
|
|
struct scic_sds_port;
|
|
struct scic_sds_remote_device;
|
|
|
|
|
|
enum sci_controller_mode {
|
|
SCI_MODE_SPEED, /* Optimized for performance */
|
|
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_ */
|
|
|