include/fsl-mc/fsl_qbman_portal.h - uboot-imx - Git at Google

 /* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Copyright (C) 2014 Freescale Semiconductor
  */

 #ifndef _FSL_QBMAN_PORTAL_H
 #define _FSL_QBMAN_PORTAL_H

 #include <fsl-mc/fsl_qbman_base.h>

 /* Create and destroy a functional object representing the given QBMan portal
  * descriptor. */
 struct qbman_swp *qbman_swp_init(const struct qbman_swp_desc *);

 	/************/
 	/* Dequeues */
 	/************/

 /* See the QBMan driver API documentation for details on the enqueue
  * mechanisms. NB: the use of a 'ldpaa_' prefix for this type is because it is
  * primarily used by the "DPIO" layer that sits above (and hides) the QBMan
  * driver. The structure is defined in the DPIO interface, but to avoid circular
  * dependencies we just pre/re-declare it here opaquely. */
 struct ldpaa_dq;


 /* ------------------- */
 /* Pull-mode dequeuing */
 /* ------------------- */

 struct qbman_pull_desc {
 	uint32_t dont_manipulate_directly[6];
 };

 /* Clear the contents of a descriptor to default/starting state. */
 void qbman_pull_desc_clear(struct qbman_pull_desc *);
 /* If not called, or if called with 'storage' as NULL, the result pull dequeues
  * will produce results to DQRR. If 'storage' is non-NULL, then results are
  * produced to the given memory location (using the physical/DMA address which
  * the caller provides in 'storage_phys'), and 'stash' controls whether or not
  * those writes to main-memory express a cache-warming attribute. */
 void qbman_pull_desc_set_storage(struct qbman_pull_desc *,
 				 struct ldpaa_dq *storage,
 				 dma_addr_t storage_phys,
 				 int stash);
 /* numframes must be between 1 and 16, inclusive */
 void qbman_pull_desc_set_numframes(struct qbman_pull_desc *, uint8_t numframes);
 /* token is the value that shows up in the dequeue results that can be used to
  * detect when the results have been published, and is not really used when
  * dequeue results go to DQRR. The easiest technique is to zero result "storage"
  * before issuing a pull dequeue, and use any non-zero 'token' value. */
 void qbman_pull_desc_set_token(struct qbman_pull_desc *, uint8_t token);
 /* Exactly one of the following descriptor "actions" should be set. (Calling any
  * one of these will replace the effect of any prior call to one of these.)
  * - pull dequeue from the given frame queue (FQ)
  * - pull dequeue from any FQ in the given work queue (WQ)
  * - pull dequeue from any FQ in any WQ in the given channel
  */
 void qbman_pull_desc_set_fq(struct qbman_pull_desc *, uint32_t fqid);

 /* Issue the pull dequeue command */
 int qbman_swp_pull(struct qbman_swp *, struct qbman_pull_desc *);

 /* -------------------------------- */
 /* Polling DQRR for dequeue results */
 /* -------------------------------- */

 /* NULL return if there are no unconsumed DQRR entries. Returns a DQRR entry
  * only once, so repeated calls can return a sequence of DQRR entries, without
  * requiring they be consumed immediately or in any particular order. */
 const struct ldpaa_dq *qbman_swp_dqrr_next(struct qbman_swp *);
 /* Consume DQRR entries previously returned from qbman_swp_dqrr_next(). */
 void qbman_swp_dqrr_consume(struct qbman_swp *, const struct ldpaa_dq *);

 /* ------------------------------------------------- */
 /* Polling user-provided storage for dequeue results */
 /* ------------------------------------------------- */

 /* Only used for user-provided storage of dequeue results, not DQRR. Prior to
  * being used, the storage must set "oldtoken", so that the driver notices when
  * hardware has filled it in with results using a "newtoken". NB, for efficiency
  * purposes, the driver will perform any required endianness conversion to
  * ensure that the user's dequeue result storage is in host-endian format
  * (whether or not that is the same as the little-endian format that hardware
  * DMA'd to the user's storage). As such, once the user has called
  * qbman_dq_entry_has_newtoken() and been returned a valid dequeue result, they
  * should not call it again on the same memory location (except of course if
  * another dequeue command has been executed to produce a new result to that
  * location).
  */
 void qbman_dq_entry_set_oldtoken(struct ldpaa_dq *,
 				 unsigned int num_entries,
 				 uint8_t oldtoken);
 int qbman_dq_entry_has_newtoken(struct qbman_swp *,
 				const struct ldpaa_dq *,
 				uint8_t newtoken);

 /* -------------------------------------------------------- */
 /* Parsing dequeue entries (DQRR and user-provided storage) */
 /* -------------------------------------------------------- */

 /* DQRR entries may contain non-dequeue results, ie. notifications */
 int qbman_dq_entry_is_DQ(const struct ldpaa_dq *);

 	/************/
 	/* Enqueues */
 	/************/

 struct qbman_eq_desc {
 	uint32_t dont_manipulate_directly[8];
 };


 /* Clear the contents of a descriptor to default/starting state. */
 void qbman_eq_desc_clear(struct qbman_eq_desc *);
 /* Exactly one of the following descriptor "actions" should be set. (Calling
  * any one of these will replace the effect of any prior call to one of these.)
  * - enqueue without order-restoration
  * - enqueue with order-restoration
  * - fill a hole in the order-restoration sequence, without any enqueue
  * - advance NESN (Next Expected Sequence Number), without any enqueue
  * 'respond_success' indicates whether an enqueue response should be DMA'd
  * after success (otherwise a response is DMA'd only after failure).
  * 'incomplete' indicates that other fragments of the same 'seqnum' are yet to
  * be enqueued.
  */
 void qbman_eq_desc_set_no_orp(struct qbman_eq_desc *, int respond_success);
 void qbman_eq_desc_set_response(struct qbman_eq_desc *,
 				dma_addr_t storage_phys,
 				int stash);
 /* token is the value that shows up in an enqueue response that can be used to
  * detect when the results have been published. The easiest technique is to zero
  * result "storage" before issuing an enqueue, and use any non-zero 'token'
  * value. */
 void qbman_eq_desc_set_token(struct qbman_eq_desc *, uint8_t token);
 /* Exactly one of the following descriptor "targets" should be set. (Calling any
  * one of these will replace the effect of any prior call to one of these.)
  * - enqueue to a frame queue
  * - enqueue to a queuing destination
  * Note, that none of these will have any affect if the "action" type has been
  * set to "orp_hole" or "orp_nesn".
  */
 void qbman_eq_desc_set_fq(struct qbman_eq_desc *, uint32_t fqid);
 void qbman_eq_desc_set_qd(struct qbman_eq_desc *, uint32_t qdid,
 			  uint32_t qd_bin, uint32_t qd_prio);

 /* Issue an enqueue command. ('fd' should only be NULL if the "action" of the
  * descriptor is "orp_hole" or "orp_nesn".) */
 int qbman_swp_enqueue(struct qbman_swp *, const struct qbman_eq_desc *,
 		      const struct qbman_fd *fd);

 	/*******************/
 	/* Buffer releases */
 	/*******************/

 struct qbman_release_desc {
 	uint32_t dont_manipulate_directly[1];
 };

 /* Clear the contents of a descriptor to default/starting state. */
 void qbman_release_desc_clear(struct qbman_release_desc *);
 /* Set the ID of the buffer pool to release to */
 void qbman_release_desc_set_bpid(struct qbman_release_desc *, uint32_t bpid);
 /* Issue a release command. 'num_buffers' must be less than 8. */
 int qbman_swp_release(struct qbman_swp *, const struct qbman_release_desc *,
 		      const uint64_t *buffers, unsigned int num_buffers);

 	/*******************/
 	/* Buffer acquires */
 	/*******************/

 int qbman_swp_acquire(struct qbman_swp *, uint32_t bpid, uint64_t *buffers,
 		      unsigned int num_buffers);
 #endif /* !_FSL_QBMAN_PORTAL_H */
	/* SPDX-License-Identifier: GPL-2.0+ */
	/*
	* Copyright (C) 2014 Freescale Semiconductor
	*/

	#ifndef _FSL_QBMAN_PORTAL_H
	#define _FSL_QBMAN_PORTAL_H

	#include <fsl-mc/fsl_qbman_base.h>

	/* Create and destroy a functional object representing the given QBMan portal
	* descriptor. */
	struct qbman_swp qbman_swp_init(const struct qbman_swp_desc );

	/************/
	/* Dequeues */
	/************/

	/* See the QBMan driver API documentation for details on the enqueue
	* mechanisms. NB: the use of a 'ldpaa_' prefix for this type is because it is
	* primarily used by the "DPIO" layer that sits above (and hides) the QBMan
	* driver. The structure is defined in the DPIO interface, but to avoid circular
	* dependencies we just pre/re-declare it here opaquely. */
	struct ldpaa_dq;


	/* ------------------- */
	/* Pull-mode dequeuing */
	/* ------------------- */

	struct qbman_pull_desc {
	uint32_t dont_manipulate_directly[6];
	};

	/* Clear the contents of a descriptor to default/starting state. */
	void qbman_pull_desc_clear(struct qbman_pull_desc *);
	/* If not called, or if called with 'storage' as NULL, the result pull dequeues
	* will produce results to DQRR. If 'storage' is non-NULL, then results are
	* produced to the given memory location (using the physical/DMA address which
	* the caller provides in 'storage_phys'), and 'stash' controls whether or not
	* those writes to main-memory express a cache-warming attribute. */
	void qbman_pull_desc_set_storage(struct qbman_pull_desc *,
	struct ldpaa_dq *storage,
	dma_addr_t storage_phys,
	int stash);
	/* numframes must be between 1 and 16, inclusive */
	void qbman_pull_desc_set_numframes(struct qbman_pull_desc *, uint8_t numframes);
	/* token is the value that shows up in the dequeue results that can be used to
	* detect when the results have been published, and is not really used when
	* dequeue results go to DQRR. The easiest technique is to zero result "storage"
	* before issuing a pull dequeue, and use any non-zero 'token' value. */
	void qbman_pull_desc_set_token(struct qbman_pull_desc *, uint8_t token);
	/* Exactly one of the following descriptor "actions" should be set. (Calling any
	* one of these will replace the effect of any prior call to one of these.)
	* - pull dequeue from the given frame queue (FQ)
	* - pull dequeue from any FQ in the given work queue (WQ)
	* - pull dequeue from any FQ in any WQ in the given channel
	*/
	void qbman_pull_desc_set_fq(struct qbman_pull_desc *, uint32_t fqid);

	/* Issue the pull dequeue command */
	int qbman_swp_pull(struct qbman_swp , struct qbman_pull_desc );

	/* -------------------------------- */
	/* Polling DQRR for dequeue results */
	/* -------------------------------- */

	/* NULL return if there are no unconsumed DQRR entries. Returns a DQRR entry
	* only once, so repeated calls can return a sequence of DQRR entries, without
	* requiring they be consumed immediately or in any particular order. */
	const struct ldpaa_dq qbman_swp_dqrr_next(struct qbman_swp );
	/* Consume DQRR entries previously returned from qbman_swp_dqrr_next(). */
	void qbman_swp_dqrr_consume(struct qbman_swp , const struct ldpaa_dq );

	/* ------------------------------------------------- */
	/* Polling user-provided storage for dequeue results */
	/* ------------------------------------------------- */

	/* Only used for user-provided storage of dequeue results, not DQRR. Prior to
	* being used, the storage must set "oldtoken", so that the driver notices when
	* hardware has filled it in with results using a "newtoken". NB, for efficiency
	* purposes, the driver will perform any required endianness conversion to
	* ensure that the user's dequeue result storage is in host-endian format
	* (whether or not that is the same as the little-endian format that hardware
	* DMA'd to the user's storage). As such, once the user has called
	* qbman_dq_entry_has_newtoken() and been returned a valid dequeue result, they
	* should not call it again on the same memory location (except of course if
	* another dequeue command has been executed to produce a new result to that
	* location).
	*/
	void qbman_dq_entry_set_oldtoken(struct ldpaa_dq *,
	unsigned int num_entries,
	uint8_t oldtoken);
	int qbman_dq_entry_has_newtoken(struct qbman_swp *,
	const struct ldpaa_dq *,
	uint8_t newtoken);

	/* -------------------------------------------------------- */
	/* Parsing dequeue entries (DQRR and user-provided storage) */
	/* -------------------------------------------------------- */

	/* DQRR entries may contain non-dequeue results, ie. notifications */
	int qbman_dq_entry_is_DQ(const struct ldpaa_dq *);

	/************/
	/* Enqueues */
	/************/

	struct qbman_eq_desc {
	uint32_t dont_manipulate_directly[8];
	};


	/* Clear the contents of a descriptor to default/starting state. */
	void qbman_eq_desc_clear(struct qbman_eq_desc *);
	/* Exactly one of the following descriptor "actions" should be set. (Calling
	* any one of these will replace the effect of any prior call to one of these.)
	* - enqueue without order-restoration
	* - enqueue with order-restoration
	* - fill a hole in the order-restoration sequence, without any enqueue
	* - advance NESN (Next Expected Sequence Number), without any enqueue
	* 'respond_success' indicates whether an enqueue response should be DMA'd
	* after success (otherwise a response is DMA'd only after failure).
	* 'incomplete' indicates that other fragments of the same 'seqnum' are yet to
	* be enqueued.
	*/
	void qbman_eq_desc_set_no_orp(struct qbman_eq_desc *, int respond_success);
	void qbman_eq_desc_set_response(struct qbman_eq_desc *,
	dma_addr_t storage_phys,
	int stash);
	/* token is the value that shows up in an enqueue response that can be used to
	* detect when the results have been published. The easiest technique is to zero
	* result "storage" before issuing an enqueue, and use any non-zero 'token'
	* value. */
	void qbman_eq_desc_set_token(struct qbman_eq_desc *, uint8_t token);
	/* Exactly one of the following descriptor "targets" should be set. (Calling any
	* one of these will replace the effect of any prior call to one of these.)
	* - enqueue to a frame queue
	* - enqueue to a queuing destination
	* Note, that none of these will have any affect if the "action" type has been
	* set to "orp_hole" or "orp_nesn".
	*/
	void qbman_eq_desc_set_fq(struct qbman_eq_desc *, uint32_t fqid);
	void qbman_eq_desc_set_qd(struct qbman_eq_desc *, uint32_t qdid,
	uint32_t qd_bin, uint32_t qd_prio);

	/* Issue an enqueue command. ('fd' should only be NULL if the "action" of the
	* descriptor is "orp_hole" or "orp_nesn".) */
	int qbman_swp_enqueue(struct qbman_swp , const struct qbman_eq_desc ,
	const struct qbman_fd *fd);

	/*******************/
	/* Buffer releases */
	/*******************/

	struct qbman_release_desc {
	uint32_t dont_manipulate_directly[1];
	};

	/* Clear the contents of a descriptor to default/starting state. */
	void qbman_release_desc_clear(struct qbman_release_desc *);
	/* Set the ID of the buffer pool to release to */
	void qbman_release_desc_set_bpid(struct qbman_release_desc *, uint32_t bpid);
	/* Issue a release command. 'num_buffers' must be less than 8. */
	int qbman_swp_release(struct qbman_swp , const struct qbman_release_desc ,
	const uint64_t *buffers, unsigned int num_buffers);

	/*******************/
	/* Buffer acquires */
	/*******************/

	int qbman_swp_acquire(struct qbman_swp , uint32_t bpid, uint64_t buffers,
	unsigned int num_buffers);
	#endif /* !_FSL_QBMAN_PORTAL_H */