[deliverable/linux.git] / drivers / staging / octeon / cvmx-cmd-queue.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 "cvmx-config.h"
#include "cvmx-fpa.h"
#include "cvmx-cmd-queue.h"

#include <asm/octeon/cvmx-npei-defs.h>
#include <asm/octeon/cvmx-pexp-defs.h>
#include "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;

/**
 * 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";
#if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
	extern uint64_t octeon_reserve32_memory;
#endif

	if (likely(__cvmx_cmd_queue_state_ptr))
		return CVMX_CMD_QUEUE_SUCCESS;

#if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
	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
#endif
		__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 a free it's 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.cn58xx.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 t othe 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;
}
Commit	Line	Data
80ff0fd3 DD	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 "cvmx-config.h"
	38	#include "cvmx-fpa.h"
	39	#include "cvmx-cmd-queue.h"
	40
	41	#include <asm/octeon/cvmx-npei-defs.h>
	42	#include <asm/octeon/cvmx-pexp-defs.h>
	43	#include "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
	51	/**
	52	* Initialize the Global queue state pointer.
	53	*
	54	* Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
	55	*/
	56	static cvmx_cmd_queue_result_t __cvmx_cmd_queue_init_state_ptr(void)
	57	{
	58	char *alloc_name = "cvmx_cmd_queues";
	59	#if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
	60	extern uint64_t octeon_reserve32_memory;
	61	#endif
	62
	63	if (likely(__cvmx_cmd_queue_state_ptr))
	64	return CVMX_CMD_QUEUE_SUCCESS;
65
66	#if defined(CONFIG_CAVIUM_RESERVE32) && CONFIG_CAVIUM_RESERVE32
67	if (octeon_reserve32_memory)
68	__cvmx_cmd_queue_state_ptr =
69	cvmx_bootmem_alloc_named_range(sizeof(*__cvmx_cmd_queue_state_ptr),
70	octeon_reserve32_memory,
71	octeon_reserve32_memory +
72	(CONFIG_CAVIUM_RESERVE32 <<
73	20) - 1, 128, alloc_name);
74	else
75	#endif
76	__cvmx_cmd_queue_state_ptr =
77	cvmx_bootmem_alloc_named(sizeof(*__cvmx_cmd_queue_state_ptr),
78	128,
79	alloc_name);
80	if (__cvmx_cmd_queue_state_ptr)
81	memset(__cvmx_cmd_queue_state_ptr, 0,
82	sizeof(*__cvmx_cmd_queue_state_ptr));
83	else {
84	struct cvmx_bootmem_named_block_desc *block_desc =
85	cvmx_bootmem_find_named_block(alloc_name);
86	if (block_desc)
87	__cvmx_cmd_queue_state_ptr =
88	cvmx_phys_to_ptr(block_desc->base_addr);
89	else {
90	cvmx_dprintf
91	("ERROR: cvmx_cmd_queue_initialize: Unable to get named block %s.\n",
92	alloc_name);
93	return CVMX_CMD_QUEUE_NO_MEMORY;
94	}
95	}
96	return CVMX_CMD_QUEUE_SUCCESS;
97	}
98
99	/**
100	* Initialize a command queue for use. The initial FPA buffer is
101	* allocated and the hardware unit is configured to point to the
102	* new command queue.
103	*
104	* @queue_id: Hardware command queue to initialize.
105	* @max_depth: Maximum outstanding commands that can be queued.
106	* @fpa_pool: FPA pool the command queues should come from.
107	* @pool_size: Size of each buffer in the FPA pool (bytes)
108	*
109	* Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
110	*/
111	cvmx_cmd_queue_result_t cvmx_cmd_queue_initialize(cvmx_cmd_queue_id_t queue_id,
112	int max_depth, int fpa_pool,
113	int pool_size)
114	{
115	__cvmx_cmd_queue_state_t *qstate;
116	cvmx_cmd_queue_result_t result = __cvmx_cmd_queue_init_state_ptr();
117	if (result != CVMX_CMD_QUEUE_SUCCESS)
118	return result;
119
120	qstate = __cvmx_cmd_queue_get_state(queue_id);
121	if (qstate == NULL)
122	return CVMX_CMD_QUEUE_INVALID_PARAM;
123
124	/*
125	* We artificially limit max_depth to 1<<20 words. It is an
126	* arbitrary limit.
127	*/
128	if (CVMX_CMD_QUEUE_ENABLE_MAX_DEPTH) {
129	if ((max_depth < 0) \|\| (max_depth > 1 << 20))
130	return CVMX_CMD_QUEUE_INVALID_PARAM;
131	} else if (max_depth != 0)
132	return CVMX_CMD_QUEUE_INVALID_PARAM;
133
134	if ((fpa_pool < 0) \|\| (fpa_pool > 7))
135	return CVMX_CMD_QUEUE_INVALID_PARAM;
136	if ((pool_size < 128) \|\| (pool_size > 65536))
137	return CVMX_CMD_QUEUE_INVALID_PARAM;
138
139	/* See if someone else has already initialized the queue */
140	if (qstate->base_ptr_div128) {
141	if (max_depth != (int)qstate->max_depth) {
142	cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
37523e84	143	"Queue already initialized with different "
80ff0fd3 DD	144	"max_depth (%d).\n",
	145	(int)qstate->max_depth);
	146	return CVMX_CMD_QUEUE_INVALID_PARAM;
	147	}
	148	if (fpa_pool != qstate->fpa_pool) {
	149	cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
37523e84	150	"Queue already initialized with different "
80ff0fd3 DD	151	"FPA pool (%u).\n",
	152	qstate->fpa_pool);
	153	return CVMX_CMD_QUEUE_INVALID_PARAM;
	154	}
	155	if ((pool_size >> 3) - 1 != qstate->pool_size_m1) {
	156	cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
37523e84	157	"Queue already initialized with different "
80ff0fd3 DD	158	"FPA pool size (%u).\n",
	159	(qstate->pool_size_m1 + 1) << 3);
	160	return CVMX_CMD_QUEUE_INVALID_PARAM;
	161	}
	162	CVMX_SYNCWS;
	163	return CVMX_CMD_QUEUE_ALREADY_SETUP;
	164	} else {
	165	union cvmx_fpa_ctl_status status;
	166	void *buffer;
	167
	168	status.u64 = cvmx_read_csr(CVMX_FPA_CTL_STATUS);
	169	if (!status.s.enb) {
	170	cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
	171	"FPA is not enabled.\n");
	172	return CVMX_CMD_QUEUE_NO_MEMORY;
	173	}
	174	buffer = cvmx_fpa_alloc(fpa_pool);
	175	if (buffer == NULL) {
	176	cvmx_dprintf("ERROR: cvmx_cmd_queue_initialize: "
	177	"Unable to allocate initial buffer.\n");
	178	return CVMX_CMD_QUEUE_NO_MEMORY;
	179	}
	180
	181	memset(qstate, 0, sizeof(*qstate));
	182	qstate->max_depth = max_depth;
	183	qstate->fpa_pool = fpa_pool;
	184	qstate->pool_size_m1 = (pool_size >> 3) - 1;
	185	qstate->base_ptr_div128 = cvmx_ptr_to_phys(buffer) / 128;
	186	/*
	187	* We zeroed the now serving field so we need to also
	188	* zero the ticket.
	189	*/
	190	__cvmx_cmd_queue_state_ptr->
	191	ticket[__cvmx_cmd_queue_get_index(queue_id)] = 0;
	192	CVMX_SYNCWS;
	193	return CVMX_CMD_QUEUE_SUCCESS;
	194	}
	195	}
	196
	197	/**
	198	* Shutdown a queue a free it's command buffers to the FPA. The
	199	* hardware connected to the queue must be stopped before this
	200	* function is called.
	201	*
	202	* @queue_id: Queue to shutdown
	203	*
	204	* Returns CVMX_CMD_QUEUE_SUCCESS or a failure code
	205	*/
	206	cvmx_cmd_queue_result_t cvmx_cmd_queue_shutdown(cvmx_cmd_queue_id_t queue_id)
	207	{
	208	__cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
	209	if (qptr == NULL) {
	210	cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Unable to "
	211	"get queue information.\n");
	212	return CVMX_CMD_QUEUE_INVALID_PARAM;
	213	}
	214
	215	if (cvmx_cmd_queue_length(queue_id) > 0) {
	216	cvmx_dprintf("ERROR: cvmx_cmd_queue_shutdown: Queue still "
	217	"has data in it.\n");
	218	return CVMX_CMD_QUEUE_FULL;
	219	}
	220
	221	__cvmx_cmd_queue_lock(queue_id, qptr);
222	if (qptr->base_ptr_div128) {
223	cvmx_fpa_free(cvmx_phys_to_ptr
224	((uint64_t) qptr->base_ptr_div128 << 7),
225	qptr->fpa_pool, 0);
226	qptr->base_ptr_div128 = 0;
227	}
228	__cvmx_cmd_queue_unlock(qptr);
229
230	return CVMX_CMD_QUEUE_SUCCESS;
231	}
232
233	/**
234	* Return the number of command words pending in the queue. This
235	* function may be relatively slow for some hardware units.
236	*
237	* @queue_id: Hardware command queue to query
238	*
239	* Returns Number of outstanding commands
240	*/
241	int cvmx_cmd_queue_length(cvmx_cmd_queue_id_t queue_id)
242	{
243	if (CVMX_ENABLE_PARAMETER_CHECKING) {
244	if (__cvmx_cmd_queue_get_state(queue_id) == NULL)
245	return CVMX_CMD_QUEUE_INVALID_PARAM;
246	}
247
248	/*
249	* The cast is here so gcc with check that all values in the
250	* cvmx_cmd_queue_id_t enumeration are here.
251	*/
252	switch ((cvmx_cmd_queue_id_t) (queue_id & 0xff0000)) {
253	case CVMX_CMD_QUEUE_PKO_BASE:
254	/*
255	* FIXME: Need atomic lock on
256	* CVMX_PKO_REG_READ_IDX. Right now we are normally
257	* called with the queue lock, so that is a SLIGHT
258	* amount of protection.
259	*/
260	cvmx_write_csr(CVMX_PKO_REG_READ_IDX, queue_id & 0xffff);
261	if (OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
262	union cvmx_pko_mem_debug9 debug9;
263	debug9.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG9);
264	return debug9.cn38xx.doorbell;
265	} else {
266	union cvmx_pko_mem_debug8 debug8;
267	debug8.u64 = cvmx_read_csr(CVMX_PKO_MEM_DEBUG8);
268	return debug8.cn58xx.doorbell;
269	}
270	case CVMX_CMD_QUEUE_ZIP:
271	case CVMX_CMD_QUEUE_DFA:
272	case CVMX_CMD_QUEUE_RAID:
273	/* FIXME: Implement other lengths */
274	return 0;
275	case CVMX_CMD_QUEUE_DMA_BASE:
276	{
277	union cvmx_npei_dmax_counts dmax_counts;
278	dmax_counts.u64 =
279	cvmx_read_csr(CVMX_PEXP_NPEI_DMAX_COUNTS
280	(queue_id & 0x7));
281	return dmax_counts.s.dbell;
282	}
283	case CVMX_CMD_QUEUE_END:
284	return CVMX_CMD_QUEUE_INVALID_PARAM;
285	}
286	return CVMX_CMD_QUEUE_INVALID_PARAM;
287	}
288
289	/**
290	* Return the command buffer to be written to. The purpose of this
291	* function is to allow CVMX routine access t othe low level buffer
292	* for initial hardware setup. User applications should not call this
293	* function directly.
294	*
295	* @queue_id: Command queue to query
296	*
297	* Returns Command buffer or NULL on failure
298	*/
299	void *cvmx_cmd_queue_buffer(cvmx_cmd_queue_id_t queue_id)
300	{
301	__cvmx_cmd_queue_state_t *qptr = __cvmx_cmd_queue_get_state(queue_id);
302	if (qptr && qptr->base_ptr_div128)
303	return cvmx_phys_to_ptr((uint64_t) qptr->base_ptr_div128 << 7);
304	else
305	return NULL;
306	}