FreeBSD/Linux Kernel Cross Reference
sys/dev/isci/scil/scic_sds_unsolicited_frame_control.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;
   }
   

Cache object: 06fdb916e4ce48e6c61e0fa3a24a7824