Quelle  cvmx-cmd-queue.c   Sprache: C

/***********************license start***************
 * Author: Cavium Networks
 *
 * Contact: support@caviumnetworks.com
 * This file is part of the OCTEON SDK
 *
 * Copyright (c) 2003-2008 Cavium Networks
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, Version 2, as
 * published by the Free Software Foundation.
 *
 * This file is distributed in the hope that it will be useful, but
 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
 * NONINFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this file; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 * or visit http://www.gnu.org/licenses/.
 *
 * This file may also be available under a different license from Cavium.
 * Contact Cavium Networks for more information
 ***********************license end**************************************/

/*
 * Support functions for managing command queues used for
 * various hardware blocks.
 */

#include <linux/kernel.h>

#include <asm/octeon/octeon.h>

#include <asm/octeon/cvmx-config.h>
#include <asm/octeon/cvmx-fpa.h>
#include <asm/octeon/cvmx-cmd-queue.h>

#include <asm/octeon/cvmx-npei-defs.h>
#include <asm/octeon/cvmx-pexp-defs.h>
#include <asm/octeon/cvmx-pko-defs.h>

/*
 * This application uses this pointer to access the global queue
 * state. It points to a bootmem named block.
 */
__cvmx_cmd_queue_all_state_t *__cvmx_cmd_queue_state_ptr;
EXPORT_SYMBOL_GPL(__cvmx_cmd_queue_state_ptr);

/*
 * Initialize the Global queue state pointer.
 *
 * Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
 */
static cvmx_cmd_queue_result_t __cvmx_cmd_queue_init_state_ptr(void)
{
 char *alloc_name = "cvmx_cmd_queues";
 extern uint64_t octeon_reserve32_memory;

 if (likely(__cvmx_cmd_queue_state_ptr))
  return CVMX_CMD_QUEUE_SUCCESS;

 if (octeon_reserve32_memory)
  __cvmx_cmd_queue_state_ptr =
      cvmx_bootmem_alloc_named_range(sizeof(*__cvmx_cmd_queue_state_ptr),
         octeon_reserve32_memory,
         octeon_reserve32_memory +
         (CONFIG_CAVIUM_RESERVE32 <<
          20) - 1, 128, alloc_name);
 else
  __cvmx_cmd_queue_state_ptr =
      cvmx_bootmem_alloc_named(sizeof(*__cvmx_cmd_queue_state_ptr),
         128,
         alloc_name);
 if (__cvmx_cmd_queue_state_ptr)
  memset(__cvmx_cmd_queue_state_ptr, 0,
         sizeof(*__cvmx_cmd_queue_state_ptr));
 else {
  struct cvmx_bootmem_named_block_desc *block_desc =
      cvmx_bootmem_find_named_block(alloc_name);
  if (block_desc)
   __cvmx_cmd_queue_state_ptr =
       cvmx_phys_to_ptr(block_desc->base_addr);
  else {
   cvmx_dprintf
       ("ERROR: cvmx_cmd_queue_initialize: Unable to get named block %s.\n",
        alloc_name);
   return CVMX_CMD_QUEUE_NO_MEMORY;
  }
 }
 return CVMX_CMD_QUEUE_SUCCESS;
}

/*
 * Initialize a command queue for use. The initial FPA buffer is
 * allocated and the hardware unit is configured to point to the
 * new command queue.
 *
 * @queue_id:  Hardware command queue to initialize.
 * @max_depth: Maximum outstanding commands that can be queued.
 * @fpa_pool:  FPA pool the command queues should come from.
 * @pool_size: Size of each buffer in the FPA pool (bytes)
 *
 * Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
 */
cvmx_cmd_queue_result_t cvmx_cmd_queue_initialize(cvmx_cmd_queue_id_t queue_id,
        int max_depth, int fpa_pool,
        int pool_size)
{
 __cvmx_cmd_queue_state_t *qstate;
 cvmx_cmd_queue_result_t result = __cvmx_cmd_queue_init_state_ptr();
 if (result != CVMX_CMD_QUEUE_SUCCESS)
  return result;

 qstate = __cvmx_cmd_queue_get_state(queue_id);
 if (qstate == NULL)
  return CVMX_CMD_QUEUE_INVALID_PARAM;

 /*
  * We artificially limit max_depth to 1<<20 words. It is an
  * arbitrary limit.
 */
 if (CVMX_CMD_QUEUE_ENABLE_MAX_DEPTH) {
  if ((max_depth < 0) || (max_depth > 1 << 20))
   return CVMX_CMD_QUEUE_INVALID_PARAM;
 } else if (max_depth != 0)
  return CVMX_CMD_QUEUE_INVALID_PARAM;

 if ((fpa_pool < 0) || (fpa_pool > 7))
  return CVMX_CMD_QUEUE_INVALID_PARAM;
 if ((pool_size < 128) || (pool_size > 65536))
  return CVMX_CMD_QUEUE_INVALID_PARAM;

 /* See if someone else has already initialized the queue */
 if (qstate->base_ptr_div128) {
  if (max_depth != (int)qstate->max_depth) {
   cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
    "Queue already initialized with different "
    "max_depth (%d).\n",
        (int)qstate->max_depth);
   return CVMX_CMD_QUEUE_INVALID_PARAM;
  }
  if (fpa_pool != qstate->fpa_pool) {
   cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
    "Queue already initialized with different "
    "FPA pool (%u).\n",
        qstate->fpa_pool);
   return CVMX_CMD_QUEUE_INVALID_PARAM;
  }
  if ((pool_size >> 3) - 1 != qstate->pool_size_m1) {
   cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
    "Queue already initialized with different "
    "FPA pool size (%u).\n",
        (qstate->pool_size_m1 + 1) << 3);
   return CVMX_CMD_QUEUE_INVALID_PARAM;
  }
  CVMX_SYNCWS;
  return CVMX_CMD_QUEUE_ALREADY_SETUP;
 } else {
  union cvmx_fpa_ctl_status status;
  void *buffer;

  status.u64 = cvmx_read_csr(CVMX_FPA_CTL_STATUS);
  if (!status.s.enb) {
   cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
         "FPA is not enabled.\n");
   return CVMX_CMD_QUEUE_NO_MEMORY;
  }
  buffer = cvmx_fpa_alloc(fpa_pool);
  if (buffer == NULL) {
   cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
         "Unable to allocate initial buffer.\n");
   return CVMX_CMD_QUEUE_NO_MEMORY;
  }

  memset(qstate, 0, sizeof(*qstate));
  qstate->max_depth = max_depth;
  qstate->fpa_pool = fpa_pool;
  qstate->pool_size_m1 = (pool_size >> 3) - 1;
  qstate->base_ptr_div128 = cvmx_ptr_to_phys(buffer) / 128;
  /*
   * We zeroed the now serving field so we need to also
   * zero the ticket.
 */
  __cvmx_cmd_queue_state_ptr->
      ticket[__cvmx_cmd_queue_get_index(queue_id)] = 0;
  CVMX_SYNCWS;
  return CVMX_CMD_QUEUE_SUCCESS;
 }
}

/*
 * Shutdown a queue and free its command buffers to the FPA. The
 * hardware connected to the queue must be stopped before this
 * function is called.
 *
 * @queue_id: Queue to shutdown
 *
 * Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
 */
cvmx_cmd_queue_result_t cvmx_cmd_queue_shutdown(cvmx_cmd_queue_id_t queue_id)
{
 __cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
 if (qptr == NULL) {
  cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Unable to "
        "get queue information.\n");
  return CVMX_CMD_QUEUE_INVALID_PARAM;
 }

 if (cvmx_cmd_queue_length(queue_id) > 0) {
  cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Queue still "
        "has data in it.\n");
  return CVMX_CMD_QUEUE_FULL;
 }

 __cvmx_cmd_queue_lock(queue_id, qptr);
 if (qptr->base_ptr_div128) {
  cvmx_fpa_free(cvmx_phys_to_ptr
         ((uint64_t) qptr->base_ptr_div128 << 7),
         qptr->fpa_pool, 0);
  qptr->base_ptr_div128 = 0;
 }
 __cvmx_cmd_queue_unlock(qptr);

 return CVMX_CMD_QUEUE_SUCCESS;
}

/*
 * Return the number of command words pending in the queue. This
 * function may be relatively slow for some hardware units.
 *
 * @queue_id: Hardware command queue to query
 *
 * Returns Number of outstanding commands
 */
int cvmx_cmd_queue_length(cvmx_cmd_queue_id_t queue_id)
{
 if (CVMX_ENABLE_PARAMETER_CHECKING) {
  if (__cvmx_cmd_queue_get_state(queue_id) == NULL)
   return CVMX_CMD_QUEUE_INVALID_PARAM;
 }

 /*
  * The cast is here so gcc with check that all values in the
  * cvmx_cmd_queue_id_t enumeration are here.
 */
 switch ((cvmx_cmd_queue_id_t) (queue_id & 0xff0000)) {
 case CVMX_CMD_QUEUE_PKO_BASE:
  /*
   * FIXME: Need atomic lock on
   * CVMX_PKO_REG_READ_IDX. Right now we are normally
   * called with the queue lock, so that is a SLIGHT
   * amount of protection.
 */
  cvmx_write_csr(CVMX_PKO_REG_READ_IDX, queue_id & 0xffff);
  if (OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
   union cvmx_pko_mem_debug9 debug9;
   debug9.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG9);
   return debug9.cn38xx.doorbell;
  } else {
   union cvmx_pko_mem_debug8 debug8;
   debug8.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG8);
   return debug8.cn50xx.doorbell;
  }
 case CVMX_CMD_QUEUE_ZIP:
 case CVMX_CMD_QUEUE_DFA:
 case CVMX_CMD_QUEUE_RAID:
  /* FIXME: Implement other lengths */
  return 0;
 case CVMX_CMD_QUEUE_DMA_BASE:
  {
   union cvmx_npei_dmax_counts dmax_counts;
   dmax_counts.u64 =
       cvmx_read_csr(CVMX_PEXP_NPEI_DMAX_COUNTS
       (queue_id & 0x7));
   return dmax_counts.s.dbell;
  }
 case CVMX_CMD_QUEUE_END:
  return CVMX_CMD_QUEUE_INVALID_PARAM;
 }
 return CVMX_CMD_QUEUE_INVALID_PARAM;
}

/*
 * Return the command buffer to be written to. The purpose of this
 * function is to allow CVMX routine access to the low level buffer
 * for initial hardware setup. User applications should not call this
 * function directly.
 *
 * @queue_id: Command queue to query
 *
 * Returns Command buffer or NULL on failure
 */
void *cvmx_cmd_queue_buffer(cvmx_cmd_queue_id_t queue_id)
{
 __cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
 if (qptr && qptr->base_ptr_div128)
  return cvmx_phys_to_ptr((uint64_t) qptr->base_ptr_div128 << 7);
 else
  return NULL;
}