root/arch/mips/cavium-octeon/executive/cvmx-cmd-queue.c

DEFINITIONS

1. __cvmx_cmd_queue_init_state_ptr
2. cvmx_cmd_queue_initialize
3. cvmx_cmd_queue_shutdown
4. cvmx_cmd_queue_length
5. cvmx_cmd_queue_buffer

   1 /***********************license start***************
   2  * Author: Cavium Networks
   3  *
   4  * Contact: support@caviumnetworks.com
   5  * This file is part of the OCTEON SDK
   6  *
   7  * Copyright (c) 2003-2008 Cavium Networks
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License, Version 2, as
  11  * published by the Free Software Foundation.
  12  *
  13  * This file is distributed in the hope that it will be useful, but
  14  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  16  * NONINFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this file; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  * or visit http://www.gnu.org/licenses/.
  23  *
  24  * This file may also be available under a different license from Cavium.
  25  * Contact Cavium Networks for more information
  26  ***********************license end**************************************/
  27 
  28 /*
  29  * Support functions for managing command queues used for
  30  * various hardware blocks.
  31  */
  32 
  33 #include <linux/kernel.h>
  34 
  35 #include <asm/octeon/octeon.h>
  36 
  37 #include <asm/octeon/cvmx-config.h>
  38 #include <asm/octeon/cvmx-fpa.h>
  39 #include <asm/octeon/cvmx-cmd-queue.h>
  40 
  41 #include <asm/octeon/cvmx-npei-defs.h>
  42 #include <asm/octeon/cvmx-pexp-defs.h>
  43 #include <asm/octeon/cvmx-pko-defs.h>
  44 
  45 /**
  46  * This application uses this pointer to access the global queue
  47  * state. It points to a bootmem named block.
  48  */
  49 __cvmx_cmd_queue_all_state_t *__cvmx_cmd_queue_state_ptr;
  50 EXPORT_SYMBOL_GPL(__cvmx_cmd_queue_state_ptr);
  51 
  52 /**
  53  * Initialize the Global queue state pointer.
  54  *
  55  * Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
  56  */
  57 static cvmx_cmd_queue_result_t __cvmx_cmd_queue_init_state_ptr(void)
  58 {
  59         char *alloc_name = "cvmx_cmd_queues";
  60 #if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
  61         extern uint64_t octeon_reserve32_memory;
  62 #endif
  63 
  64         if (likely(__cvmx_cmd_queue_state_ptr))
  65                 return CVMX_CMD_QUEUE_SUCCESS;
  66 
  67 #if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
  68         if (octeon_reserve32_memory)
  69                 __cvmx_cmd_queue_state_ptr =
  70                     cvmx_bootmem_alloc_named_range(sizeof(*__cvmx_cmd_queue_state_ptr),
  71                                                    octeon_reserve32_memory,
  72                                                    octeon_reserve32_memory +
  73                                                    (CONFIG_CAVIUM_RESERVE32 <<
  74                                                     20) - 1, 128, alloc_name);
  75         else
  76 #endif
  77                 __cvmx_cmd_queue_state_ptr =
  78                     cvmx_bootmem_alloc_named(sizeof(*__cvmx_cmd_queue_state_ptr),
  79                                             128,
  80                                             alloc_name);
  81         if (__cvmx_cmd_queue_state_ptr)
  82                 memset(__cvmx_cmd_queue_state_ptr, 0,
  83                        sizeof(*__cvmx_cmd_queue_state_ptr));
  84         else {
  85                 struct cvmx_bootmem_named_block_desc *block_desc =
  86                     cvmx_bootmem_find_named_block(alloc_name);
  87                 if (block_desc)
  88                         __cvmx_cmd_queue_state_ptr =
  89                             cvmx_phys_to_ptr(block_desc->base_addr);
  90                 else {
  91                         cvmx_dprintf
  92                             ("ERROR: cvmx_cmd_queue_initialize: Unable to get named block %s.\n",
  93                              alloc_name);
  94                         return CVMX_CMD_QUEUE_NO_MEMORY;
  95                 }
  96         }
  97         return CVMX_CMD_QUEUE_SUCCESS;
  98 }
  99 
 100 /**
 101  * Initialize a command queue for use. The initial FPA buffer is
 102  * allocated and the hardware unit is configured to point to the
 103  * new command queue.
 104  *
 105  * @queue_id:  Hardware command queue to initialize.
 106  * @max_depth: Maximum outstanding commands that can be queued.
 107  * @fpa_pool:  FPA pool the command queues should come from.
 108  * @pool_size: Size of each buffer in the FPA pool (bytes)
 109  *
 110  * Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
 111  */
 112 cvmx_cmd_queue_result_t cvmx_cmd_queue_initialize(cvmx_cmd_queue_id_t queue_id,
 113                                                   int max_depth, int fpa_pool,
 114                                                   int pool_size)
 115 {
 116         __cvmx_cmd_queue_state_t *qstate;
 117         cvmx_cmd_queue_result_t result = __cvmx_cmd_queue_init_state_ptr();
 118         if (result != CVMX_CMD_QUEUE_SUCCESS)
 119                 return result;
 120 
 121         qstate = __cvmx_cmd_queue_get_state(queue_id);
 122         if (qstate == NULL)
 123                 return CVMX_CMD_QUEUE_INVALID_PARAM;
 124 
 125         /*
 126          * We artificially limit max_depth to 1<<20 words. It is an
 127          * arbitrary limit.
 128          */
 129         if (CVMX_CMD_QUEUE_ENABLE_MAX_DEPTH) {
 130                 if ((max_depth < 0) || (max_depth > 1 << 20))
 131                         return CVMX_CMD_QUEUE_INVALID_PARAM;
 132         } else if (max_depth != 0)
 133                 return CVMX_CMD_QUEUE_INVALID_PARAM;
 134 
 135         if ((fpa_pool < 0) || (fpa_pool > 7))
 136                 return CVMX_CMD_QUEUE_INVALID_PARAM;
 137         if ((pool_size < 128) || (pool_size > 65536))
 138                 return CVMX_CMD_QUEUE_INVALID_PARAM;
 139 
 140         /* See if someone else has already initialized the queue */
 141         if (qstate->base_ptr_div128) {
 142                 if (max_depth != (int)qstate->max_depth) {
 143                         cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
 144                                 "Queue already initialized with different "
 145                                 "max_depth (%d).\n",
 146                              (int)qstate->max_depth);
 147                         return CVMX_CMD_QUEUE_INVALID_PARAM;
 148                 }
 149                 if (fpa_pool != qstate->fpa_pool) {
 150                         cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
 151                                 "Queue already initialized with different "
 152                                 "FPA pool (%u).\n",
 153                              qstate->fpa_pool);
 154                         return CVMX_CMD_QUEUE_INVALID_PARAM;
 155                 }
 156                 if ((pool_size >> 3) - 1 != qstate->pool_size_m1) {
 157                         cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
 158                                 "Queue already initialized with different "
 159                                 "FPA pool size (%u).\n",
 160                              (qstate->pool_size_m1 + 1) << 3);
 161                         return CVMX_CMD_QUEUE_INVALID_PARAM;
 162                 }
 163                 CVMX_SYNCWS;
 164                 return CVMX_CMD_QUEUE_ALREADY_SETUP;
 165         } else {
 166                 union cvmx_fpa_ctl_status status;
 167                 void *buffer;
 168 
 169                 status.u64 = cvmx_read_csr(CVMX_FPA_CTL_STATUS);
 170                 if (!status.s.enb) {
 171                         cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
 172                                      "FPA is not enabled.\n");
 173                         return CVMX_CMD_QUEUE_NO_MEMORY;
 174                 }
 175                 buffer = cvmx_fpa_alloc(fpa_pool);
 176                 if (buffer == NULL) {
 177                         cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
 178                                      "Unable to allocate initial buffer.\n");
 179                         return CVMX_CMD_QUEUE_NO_MEMORY;
 180                 }
 181 
 182                 memset(qstate, 0, sizeof(*qstate));
 183                 qstate->max_depth = max_depth;
 184                 qstate->fpa_pool = fpa_pool;
 185                 qstate->pool_size_m1 = (pool_size >> 3) - 1;
 186                 qstate->base_ptr_div128 = cvmx_ptr_to_phys(buffer) / 128;
 187                 /*
 188                  * We zeroed the now serving field so we need to also
 189                  * zero the ticket.
 190                  */
 191                 __cvmx_cmd_queue_state_ptr->
 192                     ticket[__cvmx_cmd_queue_get_index(queue_id)] = 0;
 193                 CVMX_SYNCWS;
 194                 return CVMX_CMD_QUEUE_SUCCESS;
 195         }
 196 }
 197 
 198 /**
 199  * Shutdown a queue a free it's command buffers to the FPA. The
 200  * hardware connected to the queue must be stopped before this
 201  * function is called.
 202  *
 203  * @queue_id: Queue to shutdown
 204  *
 205  * Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
 206  */
 207 cvmx_cmd_queue_result_t cvmx_cmd_queue_shutdown(cvmx_cmd_queue_id_t queue_id)
 208 {
 209         __cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
 210         if (qptr == NULL) {
 211                 cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Unable to "
 212                              "get queue information.\n");
 213                 return CVMX_CMD_QUEUE_INVALID_PARAM;
 214         }
 215 
 216         if (cvmx_cmd_queue_length(queue_id) > 0) {
 217                 cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Queue still "
 218                              "has data in it.\n");
 219                 return CVMX_CMD_QUEUE_FULL;
 220         }
 221 
 222         __cvmx_cmd_queue_lock(queue_id, qptr);
 223         if (qptr->base_ptr_div128) {
 224                 cvmx_fpa_free(cvmx_phys_to_ptr
 225                               ((uint64_t) qptr->base_ptr_div128 << 7),
 226                               qptr->fpa_pool, 0);
 227                 qptr->base_ptr_div128 = 0;
 228         }
 229         __cvmx_cmd_queue_unlock(qptr);
 230 
 231         return CVMX_CMD_QUEUE_SUCCESS;
 232 }
 233 
 234 /**
 235  * Return the number of command words pending in the queue. This
 236  * function may be relatively slow for some hardware units.
 237  *
 238  * @queue_id: Hardware command queue to query
 239  *
 240  * Returns Number of outstanding commands
 241  */
 242 int cvmx_cmd_queue_length(cvmx_cmd_queue_id_t queue_id)
 243 {
 244         if (CVMX_ENABLE_PARAMETER_CHECKING) {
 245                 if (__cvmx_cmd_queue_get_state(queue_id) == NULL)
 246                         return CVMX_CMD_QUEUE_INVALID_PARAM;
 247         }
 248 
 249         /*
 250          * The cast is here so gcc with check that all values in the
 251          * cvmx_cmd_queue_id_t enumeration are here.
 252          */
 253         switch ((cvmx_cmd_queue_id_t) (queue_id & 0xff0000)) {
 254         case CVMX_CMD_QUEUE_PKO_BASE:
 255                 /*
 256                  * FIXME: Need atomic lock on
 257                  * CVMX_PKO_REG_READ_IDX. Right now we are normally
 258                  * called with the queue lock, so that is a SLIGHT
 259                  * amount of protection.
 260                  */
 261                 cvmx_write_csr(CVMX_PKO_REG_READ_IDX, queue_id & 0xffff);
 262                 if (OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
 263                         union cvmx_pko_mem_debug9 debug9;
 264                         debug9.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG9);
 265                         return debug9.cn38xx.doorbell;
 266                 } else {
 267                         union cvmx_pko_mem_debug8 debug8;
 268                         debug8.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG8);
 269                         return debug8.cn50xx.doorbell;
 270                 }
 271         case CVMX_CMD_QUEUE_ZIP:
 272         case CVMX_CMD_QUEUE_DFA:
 273         case CVMX_CMD_QUEUE_RAID:
 274                 /* FIXME: Implement other lengths */
 275                 return 0;
 276         case CVMX_CMD_QUEUE_DMA_BASE:
 277                 {
 278                         union cvmx_npei_dmax_counts dmax_counts;
 279                         dmax_counts.u64 =
 280                             cvmx_read_csr(CVMX_PEXP_NPEI_DMAX_COUNTS
 281                                           (queue_id & 0x7));
 282                         return dmax_counts.s.dbell;
 283                 }
 284         case CVMX_CMD_QUEUE_END:
 285                 return CVMX_CMD_QUEUE_INVALID_PARAM;
 286         }
 287         return CVMX_CMD_QUEUE_INVALID_PARAM;
 288 }
 289 
 290 /**
 291  * Return the command buffer to be written to. The purpose of this
 292  * function is to allow CVMX routine access t othe low level buffer
 293  * for initial hardware setup. User applications should not call this
 294  * function directly.
 295  *
 296  * @queue_id: Command queue to query
 297  *
 298  * Returns Command buffer or NULL on failure
 299  */
 300 void *cvmx_cmd_queue_buffer(cvmx_cmd_queue_id_t queue_id)
 301 {
 302         __cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
 303         if (qptr && qptr->base_ptr_div128)
 304                 return cvmx_phys_to_ptr((uint64_t) qptr->base_ptr_div128 << 7);
 305         else
 306                 return NULL;
 307 }