718cf2ccb9
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
405 lines
15 KiB
C
405 lines
15 KiB
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
|
|
* SCIC_SDS_UNSOLICITED_FRAME_CONTROL object and it's public,
|
|
* protected, and private methods.
|
|
*/
|
|
|
|
#include <dev/isci/scil/scic_sds_unsolicited_frame_control.h>
|
|
#include <dev/isci/scil/scu_registers.h>
|
|
#include <dev/isci/scil/scic_sds_controller.h>
|
|
#include <dev/isci/scil/scic_user_callback.h>
|
|
#include <dev/isci/scil/sci_util.h>
|
|
|
|
/**
|
|
* @brief The UF buffer address table size must be programmed to a power
|
|
* of 2. Find the first power of 2 that is equal to or greater then
|
|
* the number of unsolicited frame buffers to be utilized.
|
|
*
|
|
* @param[in,out] uf_control This parameter specifies the UF control
|
|
* object for which to update the address table count.
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_unsolicited_frame_control_set_address_table_count(
|
|
SCIC_SDS_UNSOLICITED_FRAME_CONTROL_T *uf_control
|
|
)
|
|
{
|
|
uf_control->address_table.count = SCU_MIN_UF_TABLE_ENTRIES;
|
|
while (
|
|
(uf_control->address_table.count < uf_control->buffers.count)
|
|
&& (uf_control->address_table.count < SCU_ABSOLUTE_MAX_UNSOLICITED_FRAMES)
|
|
)
|
|
{
|
|
uf_control->address_table.count <<= 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method will program the unsolicited frames (UFs) into
|
|
* the UF address table and construct the UF frame structure
|
|
* being modeled in the core. It will handle the case where
|
|
* some of the UFs are not being used and thus should have
|
|
* entries programmed to zero in the address table.
|
|
*
|
|
* @param[in,out] uf_control This parameter specifies the unsolicted
|
|
* frame control object for which to construct the
|
|
* unsolicited frames objects.
|
|
* @param[in] uf_buffer_phys_address This parameter specifies the
|
|
* physical address for the first unsolicited frame
|
|
* buffer.
|
|
* @param[in] uf_buffer_virt_address This parameter specifies the
|
|
* virtual address for the first unsolicited frame
|
|
* buffer.
|
|
* @param[in] unused_uf_header_entries This parameter specifies
|
|
* the number of unused UF headers. This value can
|
|
* be non-zero when there are a non-power of 2 number
|
|
* of unsolicited frames being supported.
|
|
* @param[in] used_uf_header_entries This parameter specifies
|
|
* the number of actually utilized UF headers.
|
|
*
|
|
* @return none
|
|
*/
|
|
static
|
|
void scic_sds_unsolicited_frame_control_construct_frames(
|
|
SCIC_SDS_UNSOLICITED_FRAME_CONTROL_T *uf_control,
|
|
SCI_PHYSICAL_ADDRESS uf_buffer_phys_address,
|
|
POINTER_UINT uf_buffer_virt_address,
|
|
U32 unused_uf_header_entries,
|
|
U32 used_uf_header_entries
|
|
)
|
|
{
|
|
U32 index;
|
|
SCIC_SDS_UNSOLICITED_FRAME_T *uf;
|
|
|
|
// Program the unused buffers into the UF address table and the
|
|
// controller's array of UFs.
|
|
for (index = 0; index < unused_uf_header_entries; index++)
|
|
{
|
|
uf = &uf_control->buffers.array[index];
|
|
|
|
sci_cb_make_physical_address(
|
|
uf_control->address_table.array[index], 0, 0
|
|
);
|
|
uf->buffer = NULL;
|
|
uf->header = &uf_control->headers.array[index];
|
|
uf->state = UNSOLICITED_FRAME_EMPTY;
|
|
}
|
|
|
|
// Program the actual used UF buffers into the UF address table and
|
|
// the controller's array of UFs.
|
|
for (index = unused_uf_header_entries;
|
|
index < unused_uf_header_entries + used_uf_header_entries;
|
|
index++)
|
|
{
|
|
uf = &uf_control->buffers.array[index];
|
|
|
|
uf_control->address_table.array[index] = uf_buffer_phys_address;
|
|
|
|
uf->buffer = (void*) uf_buffer_virt_address;
|
|
uf->header = &uf_control->headers.array[index];
|
|
uf->state = UNSOLICITED_FRAME_EMPTY;
|
|
|
|
// Increment the address of the physical and virtual memory pointers
|
|
// Everything is aligned on 1k boundary with an increment of 1k
|
|
uf_buffer_virt_address += SCU_UNSOLICITED_FRAME_BUFFER_SIZE;
|
|
sci_physical_address_add(
|
|
uf_buffer_phys_address, SCU_UNSOLICITED_FRAME_BUFFER_SIZE
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief This method constructs the various members of the unsolicted
|
|
* frame control object (buffers, headers, address, table, etc).
|
|
*
|
|
* @param[in,out] uf_control This parameter specifies the unsolicited
|
|
* frame control object to construct.
|
|
* @param[in] mde This parameter specifies the memory descriptor
|
|
* from which to derive all of the address information
|
|
* needed to get the unsolicited frame functionality
|
|
* working.
|
|
* @param[in] controller This parameter specifies the controller
|
|
* object associated with the uf_control being constructed.
|
|
*
|
|
* @return none
|
|
*/
|
|
void scic_sds_unsolicited_frame_control_construct(
|
|
SCIC_SDS_UNSOLICITED_FRAME_CONTROL_T *uf_control,
|
|
SCI_PHYSICAL_MEMORY_DESCRIPTOR_T *mde,
|
|
SCIC_SDS_CONTROLLER_T *controller
|
|
)
|
|
{
|
|
U32 unused_uf_header_entries;
|
|
U32 used_uf_header_entries;
|
|
U32 used_uf_buffer_bytes;
|
|
U32 unused_uf_header_bytes;
|
|
U32 used_uf_header_bytes;
|
|
SCI_PHYSICAL_ADDRESS uf_buffer_phys_address;
|
|
|
|
// Prepare all of the memory sizes for the UF headers, UF address
|
|
// table, and UF buffers themselves.
|
|
used_uf_buffer_bytes = uf_control->buffers.count
|
|
* SCU_UNSOLICITED_FRAME_BUFFER_SIZE;
|
|
unused_uf_header_entries = uf_control->address_table.count
|
|
- uf_control->buffers.count;
|
|
used_uf_header_entries = uf_control->buffers.count;
|
|
unused_uf_header_bytes = unused_uf_header_entries
|
|
* sizeof(SCU_UNSOLICITED_FRAME_HEADER_T);
|
|
used_uf_header_bytes = used_uf_header_entries
|
|
* sizeof(SCU_UNSOLICITED_FRAME_HEADER_T);
|
|
|
|
// The Unsolicited Frame buffers are set at the start of the UF
|
|
// memory descriptor entry. The headers and address table will be
|
|
// placed after the buffers.
|
|
uf_buffer_phys_address = mde->physical_address;
|
|
|
|
// Program the location of the UF header table into the SCU.
|
|
// Notes:
|
|
// - The address must align on a 64-byte boundary. Guaranteed to be
|
|
// on 64-byte boundary already 1KB boundary for unsolicited frames.
|
|
// - Program unused header entries to overlap with the last
|
|
// unsolicited frame. The silicon will never DMA to these unused
|
|
// headers, since we program the UF address table pointers to
|
|
// NULL.
|
|
uf_control->headers.physical_address = uf_buffer_phys_address;
|
|
sci_physical_address_add(
|
|
uf_control->headers.physical_address, used_uf_buffer_bytes);
|
|
sci_physical_address_subtract(
|
|
uf_control->headers.physical_address, unused_uf_header_bytes);
|
|
|
|
uf_control->headers.array = (SCU_UNSOLICITED_FRAME_HEADER_T*)
|
|
((U8 *)mde->virtual_address + used_uf_buffer_bytes - unused_uf_header_bytes);
|
|
|
|
// Program the location of the UF address table into the SCU.
|
|
// Notes:
|
|
// - The address must align on a 64-bit boundary. Guaranteed to be on 64
|
|
// byte boundary already due to above programming headers being on a
|
|
// 64-bit boundary and headers are on a 64-bytes in size.
|
|
uf_control->address_table.physical_address = uf_buffer_phys_address;
|
|
sci_physical_address_add(
|
|
uf_control->address_table.physical_address, used_uf_buffer_bytes);
|
|
sci_physical_address_add(
|
|
uf_control->address_table.physical_address, used_uf_header_bytes);
|
|
|
|
uf_control->address_table.array = (SCI_PHYSICAL_ADDRESS*)
|
|
((U8 *)mde->virtual_address + used_uf_buffer_bytes + used_uf_header_bytes);
|
|
|
|
uf_control->get = 0;
|
|
|
|
// UF buffer requirements are:
|
|
// - The last entry in the UF queue is not NULL.
|
|
// - There is a power of 2 number of entries (NULL or not-NULL)
|
|
// programmed into the queue.
|
|
// - Aligned on a 1KB boundary.
|
|
|
|
// If the user provided less then the maximum amount of memory,
|
|
// then be sure that we programm the first entries in the UF
|
|
// address table to NULL.
|
|
scic_sds_unsolicited_frame_control_construct_frames(
|
|
uf_control,
|
|
uf_buffer_phys_address,
|
|
(POINTER_UINT) mde->virtual_address,
|
|
unused_uf_header_entries,
|
|
used_uf_header_entries
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief This method returns the frame header for the specified frame
|
|
* index.
|
|
*
|
|
* @param[in] uf_control
|
|
* @param[in] frame_index
|
|
* @param[out] frame_header
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_unsolicited_frame_control_get_header(
|
|
SCIC_SDS_UNSOLICITED_FRAME_CONTROL_T *uf_control,
|
|
U32 frame_index,
|
|
void **frame_header
|
|
)
|
|
{
|
|
if (frame_index < uf_control->address_table.count)
|
|
{
|
|
// Skip the first word in the frame since this is a control word used
|
|
// by the hardware.
|
|
*frame_header = &uf_control->buffers.array[frame_index].header->data;
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method returns the frame buffer for the specified frame
|
|
* index.
|
|
*
|
|
* @param[in] uf_control
|
|
* @param[in] frame_index
|
|
* @param[out] frame_buffer
|
|
*
|
|
* @return SCI_STATUS
|
|
*/
|
|
SCI_STATUS scic_sds_unsolicited_frame_control_get_buffer(
|
|
SCIC_SDS_UNSOLICITED_FRAME_CONTROL_T *uf_control,
|
|
U32 frame_index,
|
|
void **frame_buffer
|
|
)
|
|
{
|
|
if (frame_index < uf_control->address_table.count)
|
|
{
|
|
*frame_buffer = uf_control->buffers.array[frame_index].buffer;
|
|
|
|
return SCI_SUCCESS;
|
|
}
|
|
|
|
return SCI_FAILURE_INVALID_PARAMETER_VALUE;
|
|
}
|
|
|
|
/**
|
|
* @brief This method releases the frame once this is done the frame is
|
|
* available for re-use by the hardware. The data contained in the
|
|
* frame header and frame buffer is no longer valid.
|
|
*
|
|
* @param[in] uf_control This parameter specifies the UF control object
|
|
* @param[in] frame_index This parameter specifies the frame index to
|
|
* attempt to release.
|
|
*
|
|
* @return This method returns an indication to the caller as to whether
|
|
* the unsolicited frame get pointer should be updated.
|
|
* @retval TRUE This value indicates the unsolicited frame get pointer
|
|
* should be updated (i.e. write SCU_UFQGP_WRITE).
|
|
* @retval FALSE This value indicates the get pointer should not be
|
|
* updated.
|
|
*/
|
|
BOOL scic_sds_unsolicited_frame_control_release_frame(
|
|
SCIC_SDS_UNSOLICITED_FRAME_CONTROL_T *uf_control,
|
|
U32 frame_index
|
|
)
|
|
{
|
|
U32 frame_get;
|
|
U32 frame_cycle;
|
|
|
|
frame_get = uf_control->get & (uf_control->address_table.count - 1);
|
|
frame_cycle = uf_control->get & uf_control->address_table.count;
|
|
|
|
// In the event there are NULL entries in the UF table, we need to
|
|
// advance the get pointer in order to find out if this frame should
|
|
// be released (i.e. update the get pointer).
|
|
while (
|
|
(
|
|
(sci_cb_physical_address_lower(
|
|
uf_control->address_table.array[frame_get]) == 0)
|
|
&& (sci_cb_physical_address_upper(
|
|
uf_control->address_table.array[frame_get]) == 0)
|
|
)
|
|
&& (frame_get < uf_control->address_table.count)
|
|
)
|
|
{
|
|
frame_get++;
|
|
}
|
|
|
|
// The table has a NULL entry as it's last element. This is
|
|
// illegal.
|
|
ASSERT(frame_get < uf_control->address_table.count);
|
|
|
|
if (frame_index < uf_control->address_table.count)
|
|
{
|
|
uf_control->buffers.array[frame_index].state = UNSOLICITED_FRAME_RELEASED;
|
|
|
|
// The frame index is equal to the current get pointer so we
|
|
// can now free up all of the frame entries that
|
|
if (frame_get == frame_index)
|
|
{
|
|
while (
|
|
uf_control->buffers.array[frame_get].state
|
|
== UNSOLICITED_FRAME_RELEASED
|
|
)
|
|
{
|
|
uf_control->buffers.array[frame_get].state = UNSOLICITED_FRAME_EMPTY;
|
|
|
|
INCREMENT_QUEUE_GET(
|
|
frame_get,
|
|
frame_cycle,
|
|
uf_control->address_table.count - 1,
|
|
uf_control->address_table.count
|
|
);
|
|
}
|
|
|
|
uf_control->get =
|
|
(SCU_UFQGP_GEN_BIT(ENABLE_BIT) | frame_cycle | frame_get);
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Frames remain in use until we advance the get pointer
|
|
// so there is nothing we can do here
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|