~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/cavium-octeon/executive/cvmx-cmd-queue.c

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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.cn58xx.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 }
308 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp