Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
       2                 :            :  *
       3                 :            :  * Copyright 2008-2012 Freescale Semiconductor, Inc.
       4                 :            :  *
       5                 :            :  */
       6                 :            : 
       7                 :            : #ifndef __FSL_BMAN_H
       8                 :            : #define __FSL_BMAN_H
       9                 :            : 
      10                 :            : #include <rte_compat.h>
      11                 :            : 
      12                 :            : #ifdef __cplusplus
      13                 :            : extern "C" {
      14                 :            : #endif
      15                 :            : 
      16                 :            : /* This wrapper represents a bit-array for the depletion state of the 64 Bman
      17                 :            :  * buffer pools.
      18                 :            :  */
      19                 :            : struct bman_depletion {
      20                 :            :         u32 state[2];
      21                 :            : };
      22                 :            : 
      23                 :            : static inline void bman_depletion_init(struct bman_depletion *c)
      24                 :            : {
      25                 :          0 :         c->state[0] = c->state[1] = 0;
      26                 :          0 : }
      27                 :            : 
      28                 :            : static inline void bman_depletion_fill(struct bman_depletion *c)
      29                 :            : {
      30                 :          0 :         c->state[0] = c->state[1] = ~0;
      31                 :            : }
      32                 :            : 
      33                 :            : /* --- Bman data structures (and associated constants) --- */
      34                 :            : 
      35                 :            : /* Represents s/w corenet portal mapped data structures */
      36                 :            : struct bm_rcr_entry;    /* RCR (Release Command Ring) entries */
      37                 :            : struct bm_mc_command;   /* MC (Management Command) command */
      38                 :            : struct bm_mc_result;    /* MC result */
      39                 :            : 
      40                 :            : /* Code-reduction, define a wrapper for 48-bit buffers. In cases where a buffer
      41                 :            :  * pool id specific to this buffer is needed (BM_RCR_VERB_CMD_BPID_MULTI,
      42                 :            :  * BM_MCC_VERB_ACQUIRE), the 'bpid' field is used.
      43                 :            :  */
      44                 :            : struct __rte_aligned(8) bm_buffer {
      45                 :            :         union {
      46                 :            :                 struct {
      47                 :            : #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
      48                 :            :                         u8 __reserved1;
      49                 :            :                         u8 bpid;
      50                 :            :                         u16 hi; /* High 16-bits of 48-bit address */
      51                 :            :                         u32 lo; /* Low 32-bits of 48-bit address */
      52                 :            : #else
      53                 :            :                         u32 lo;
      54                 :            :                         u16 hi;
      55                 :            :                         u8 bpid;
      56                 :            :                         u8 __reserved;
      57                 :            : #endif
      58                 :            :                 };
      59                 :            :                 struct {
      60                 :            : #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
      61                 :            :                         u64 __notaddress:16;
      62                 :            :                         u64 addr:48;
      63                 :            : #else
      64                 :            :                         u64 addr:48;
      65                 :            :                         u64 __notaddress:16;
      66                 :            : #endif
      67                 :            :                 };
      68                 :            :                 u64 opaque;
      69                 :            :         };
      70                 :            : };
      71                 :            : static inline u64 bm_buffer_get64(const struct bm_buffer *buf)
      72                 :            : {
      73                 :            :         return buf->addr;
      74                 :            : }
      75                 :            : 
      76                 :            : static inline dma_addr_t bm_buf_addr(const struct bm_buffer *buf)
      77                 :            : {
      78                 :            :         return (dma_addr_t)buf->addr;
      79                 :            : }
      80                 :            : 
      81                 :            : #define bm_buffer_set64(buf, v) \
      82                 :            :         do { \
      83                 :            :                 struct bm_buffer *__buf931 = (buf); \
      84                 :            :                 __buf931->hi = upper_32_bits(v); \
      85                 :            :                 __buf931->lo = lower_32_bits(v); \
      86                 :            :         } while (0)
      87                 :            : 
      88                 :            : /* See 1.5.3.5.4: "Release Command" */
      89                 :            : struct __rte_packed_begin bm_rcr_entry {
      90                 :            :         union {
      91                 :            :                 struct {
      92                 :            :                         u8 __dont_write_directly__verb;
      93                 :            :                         u8 bpid; /* used with BM_RCR_VERB_CMD_BPID_SINGLE */
      94                 :            :                         u8 __reserved1[62];
      95                 :            :                 };
      96                 :            :                 struct bm_buffer bufs[8];
      97                 :            :         };
      98                 :            : } __rte_packed_end;
      99                 :            : #define BM_RCR_VERB_VBIT                0x80
     100                 :            : #define BM_RCR_VERB_CMD_MASK            0x70    /* one of two values; */
     101                 :            : #define BM_RCR_VERB_CMD_BPID_SINGLE     0x20
     102                 :            : #define BM_RCR_VERB_CMD_BPID_MULTI      0x30
     103                 :            : #define BM_RCR_VERB_BUFCOUNT_MASK       0x0f    /* values 1..8 */
     104                 :            : 
     105                 :            : /* See 1.5.3.1: "Acquire Command" */
     106                 :            : /* See 1.5.3.2: "Query Command" */
     107                 :            : struct __rte_packed_begin bm_mcc_acquire {
     108                 :            :         u8 bpid;
     109                 :            :         u8 __reserved1[62];
     110                 :            : } __rte_packed_end;
     111                 :            : struct __rte_packed_begin bm_mcc_query {
     112                 :            :         u8 __reserved2[63];
     113                 :            : } __rte_packed_end;
     114                 :            : struct __rte_packed_begin bm_mc_command {
     115                 :            :         u8 __dont_write_directly__verb;
     116                 :            :         union {
     117                 :            :                 struct bm_mcc_acquire acquire;
     118                 :            :                 struct bm_mcc_query query;
     119                 :            :         };
     120                 :            : } __rte_packed_end;
     121                 :            : #define BM_MCC_VERB_VBIT                0x80
     122                 :            : #define BM_MCC_VERB_CMD_MASK            0x70    /* where the verb contains; */
     123                 :            : #define BM_MCC_VERB_CMD_ACQUIRE         0x10
     124                 :            : #define BM_MCC_VERB_CMD_QUERY           0x40
     125                 :            : #define BM_MCC_VERB_ACQUIRE_BUFCOUNT    0x0f    /* values 1..8 go here */
     126                 :            : 
     127                 :            : /* See 1.5.3.3: "Acquire Response" */
     128                 :            : /* See 1.5.3.4: "Query Response" */
     129                 :            : struct bm_pool_state {
     130                 :            :         u8 __reserved1[32];
     131                 :            :         /* "availability state" and "depletion state" */
     132                 :            :         struct {
     133                 :            :                 u8 __reserved1[8];
     134                 :            :                 /* Access using bman_depletion_***() */
     135                 :            :                 struct bman_depletion state;
     136                 :            :         } as, ds;
     137                 :            : };
     138                 :            : 
     139                 :            : struct __rte_packed_begin bm_mc_result {
     140                 :            :         union {
     141                 :            :                 struct {
     142                 :            :                         u8 verb;
     143                 :            :                         u8 __reserved1[63];
     144                 :            :                 };
     145                 :            :                 union {
     146                 :            :                         struct {
     147                 :            :                                 u8 __reserved1;
     148                 :            :                                 u8 bpid;
     149                 :            :                                 u8 __reserved2[62];
     150                 :            :                         };
     151                 :            :                         struct bm_buffer bufs[8];
     152                 :            :                 } acquire;
     153                 :            :                 struct bm_pool_state query;
     154                 :            :         };
     155                 :            : } __rte_packed_end;
     156                 :            : #define BM_MCR_VERB_VBIT                0x80
     157                 :            : #define BM_MCR_VERB_CMD_MASK            BM_MCC_VERB_CMD_MASK
     158                 :            : #define BM_MCR_VERB_CMD_ACQUIRE         BM_MCC_VERB_CMD_ACQUIRE
     159                 :            : #define BM_MCR_VERB_CMD_QUERY           BM_MCC_VERB_CMD_QUERY
     160                 :            : #define BM_MCR_VERB_CMD_ERR_INVALID     0x60
     161                 :            : #define BM_MCR_VERB_CMD_ERR_ECC         0x70
     162                 :            : #define BM_MCR_VERB_ACQUIRE_BUFCOUNT    BM_MCC_VERB_ACQUIRE_BUFCOUNT /* 0..8 */
     163                 :            : 
     164                 :            : /* Portal and Buffer Pools */
     165                 :            : /* Represents a managed portal */
     166                 :            : struct bman_portal;
     167                 :            : 
     168                 :            : /* This object type represents Bman buffer pools. */
     169                 :            : struct bman_pool;
     170                 :            : 
     171                 :            : /* This struct specifies parameters for a bman_pool object. */
     172                 :            : struct bman_pool_params {
     173                 :            :         /* index of the buffer pool to encapsulate (0-63), ignored if
     174                 :            :          * BMAN_POOL_FLAG_DYNAMIC_BPID is set.
     175                 :            :          */
     176                 :            :         u32 bpid;
     177                 :            :         /* bit-mask of BMAN_POOL_FLAG_*** options */
     178                 :            :         u32 flags;
     179                 :            :         /* depletion-entry/exit thresholds, if BMAN_POOL_FLAG_THRESH is set. NB:
     180                 :            :          * this is only allowed if BMAN_POOL_FLAG_DYNAMIC_BPID is used *and*
     181                 :            :          * when run in the control plane (which controls Bman CCSR). This array
     182                 :            :          * matches the definition of bm_pool_set().
     183                 :            :          */
     184                 :            :         u32 thresholds[4];
     185                 :            : };
     186                 :            : 
     187                 :            : /* Flags to bman_new_pool() */
     188                 :            : #define BMAN_POOL_FLAG_NO_RELEASE    0x00000001 /* can't release to pool */
     189                 :            : #define BMAN_POOL_FLAG_ONLY_RELEASE  0x00000002 /* can only release to pool */
     190                 :            : #define BMAN_POOL_FLAG_DYNAMIC_BPID  0x00000008 /* (de)allocate bpid */
     191                 :            : #define BMAN_POOL_FLAG_THRESH        0x00000010 /* set depletion thresholds */
     192                 :            : 
     193                 :            : /* Flags to bman_release() */
     194                 :            : #define BMAN_RELEASE_FLAG_NOW        0x00000008 /* issue immediate release */
     195                 :            : 
     196                 :            : 
     197                 :            : /**
     198                 :            :  * bman_get_portal_index - get portal configuration index
     199                 :            :  */
     200                 :            : int bman_get_portal_index(void);
     201                 :            : 
     202                 :            : /**
     203                 :            :  * bman_rcr_is_empty - Determine if portal's RCR is empty
     204                 :            :  *
     205                 :            :  * For use in situations where a cpu-affine caller needs to determine when all
     206                 :            :  * releases for the local portal have been processed by Bman but can't use the
     207                 :            :  * BMAN_RELEASE_FLAG_WAIT_SYNC flag to do this from the final bman_release().
     208                 :            :  * The function forces tracking of RCR consumption (which normally doesn't
     209                 :            :  * happen until release processing needs to find space to put new release
     210                 :            :  * commands), and returns zero if the ring still has unprocessed entries,
     211                 :            :  * non-zero if it is empty.
     212                 :            :  */
     213                 :            : int bman_rcr_is_empty(void);
     214                 :            : 
     215                 :            : /**
     216                 :            :  * bman_alloc_bpid_range - Allocate a contiguous range of BPIDs
     217                 :            :  * @result: is set by the API to the base BPID of the allocated range
     218                 :            :  * @count: the number of BPIDs required
     219                 :            :  * @align: required alignment of the allocated range
     220                 :            :  * @partial: non-zero if the API can return fewer than @count BPIDs
     221                 :            :  *
     222                 :            :  * Returns the number of buffer pools allocated, or a negative error code. If
     223                 :            :  * @partial is non zero, the allocation request may return a smaller range of
     224                 :            :  * BPs than requested (though alignment will be as requested). If @partial is
     225                 :            :  * zero, the return value will either be 'count' or negative.
     226                 :            :  */
     227                 :            : int bman_alloc_bpid_range(u32 *result, u32 count, u32 align, int partial);
     228                 :            : static inline int bman_alloc_bpid(u32 *result)
     229                 :            : {
     230                 :          0 :         int ret = bman_alloc_bpid_range(result, 1, 0, 0);
     231                 :            : 
     232                 :            :         return (ret > 0) ? 0 : ret;
     233                 :            : }
     234                 :            : 
     235                 :            : /**
     236                 :            :  * bman_release_bpid_range - Release the specified range of buffer pool IDs
     237                 :            :  * @bpid: the base BPID of the range to deallocate
     238                 :            :  * @count: the number of BPIDs in the range
     239                 :            :  *
     240                 :            :  * This function can also be used to seed the allocator with ranges of BPIDs
     241                 :            :  * that it can subsequently allocate from.
     242                 :            :  */
     243                 :            : void bman_release_bpid_range(u32 bpid, unsigned int count);
     244                 :            : static inline void bman_release_bpid(u32 bpid)
     245                 :            : {
     246                 :          0 :         bman_release_bpid_range(bpid, 1);
     247                 :          0 : }
     248                 :            : 
     249                 :            : int bman_reserve_bpid_range(u32 bpid, unsigned int count);
     250                 :            : static inline int bman_reserve_bpid(u32 bpid)
     251                 :            : {
     252                 :            :         return bman_reserve_bpid_range(bpid, 1);
     253                 :            : }
     254                 :            : 
     255                 :            : void bman_seed_bpid_range(u32 bpid, unsigned int count);
     256                 :            : 
     257                 :            : int bman_shutdown_pool(u32 bpid);
     258                 :            : 
     259                 :            : /**
     260                 :            :  * bman_new_pool - Allocates a Buffer Pool object
     261                 :            :  * @params: parameters specifying the buffer pool ID and behaviour
     262                 :            :  *
     263                 :            :  * Creates a pool object for the given @params. A portal and the depletion
     264                 :            :  * callback field of @params are only used if the BMAN_POOL_FLAG_DEPLETION flag
     265                 :            :  * is set. NB, the fields from @params are copied into the new pool object, so
     266                 :            :  * the structure provided by the caller can be released or reused after the
     267                 :            :  * function returns.
     268                 :            :  */
     269                 :            : __rte_internal
     270                 :            : struct bman_pool *bman_new_pool(const struct bman_pool_params *params);
     271                 :            : 
     272                 :            : /**
     273                 :            :  * bman_free_pool - Deallocates a Buffer Pool object
     274                 :            :  * @pool: the pool object to release
     275                 :            :  */
     276                 :            : __rte_internal
     277                 :            : void bman_free_pool(struct bman_pool *pool);
     278                 :            : 
     279                 :            : /**
     280                 :            :  * bman_get_params - Returns a pool object's parameters.
     281                 :            :  * @pool: the pool object
     282                 :            :  *
     283                 :            :  * The returned pointer refers to state within the pool object so must not be
     284                 :            :  * modified and can no longer be read once the pool object is destroyed.
     285                 :            :  */
     286                 :            : __rte_internal
     287                 :            : const struct bman_pool_params *bman_get_params(const struct bman_pool *pool);
     288                 :            : 
     289                 :            : /**
     290                 :            :  * bman_release - Release buffer(s) to the buffer pool
     291                 :            :  * @pool: the buffer pool object to release to
     292                 :            :  * @bufs: an array of buffers to release
     293                 :            :  * @num: the number of buffers in @bufs (1-8)
     294                 :            :  * @flags: bit-mask of BMAN_RELEASE_FLAG_*** options
     295                 :            :  *
     296                 :            :  */
     297                 :            : __rte_internal
     298                 :            : int bman_release(struct bman_pool *pool, const struct bm_buffer *bufs, u8 num,
     299                 :            :                  u32 flags);
     300                 :            : 
     301                 :            : /**
     302                 :            :  * bman_acquire - Acquire buffer(s) from a buffer pool
     303                 :            :  * @pool: the buffer pool object to acquire from
     304                 :            :  * @bufs: array for storing the acquired buffers
     305                 :            :  * @num: the number of buffers desired (@bufs is at least this big)
     306                 :            :  *
     307                 :            :  * Issues an "Acquire" command via the portal's management command interface.
     308                 :            :  * The return value will be the number of buffers obtained from the pool, or a
     309                 :            :  * negative error code if a h/w error or pool starvation was encountered.
     310                 :            :  */
     311                 :            : __rte_internal
     312                 :            : int bman_acquire(struct bman_pool *pool, struct bm_buffer *bufs, u8 num,
     313                 :            :                  u32 flags);
     314                 :            : 
     315                 :            : /**
     316                 :            :  * bman_query_pools - Query all buffer pool states
     317                 :            :  * @state: storage for the queried availability and depletion states
     318                 :            :  */
     319                 :            : int bman_query_pools(struct bm_pool_state *state);
     320                 :            : 
     321                 :            : /**
     322                 :            :  * bman_query_free_buffers - Query how many free buffers are in buffer pool
     323                 :            :  * @pool: the buffer pool object to query
     324                 :            :  *
     325                 :            :  * Return the number of the free buffers
     326                 :            :  */
     327                 :            : __rte_internal
     328                 :            : u32 bman_query_free_buffers(struct bman_pool *pool);
     329                 :            : 
     330                 :            : /**
     331                 :            :  * bman_update_pool_thresholds - Change the buffer pool's depletion thresholds
     332                 :            :  * @pool: the buffer pool object to which the thresholds will be set
     333                 :            :  * @thresholds: the new thresholds
     334                 :            :  */
     335                 :            : int bman_update_pool_thresholds(struct bman_pool *pool, const u32 *thresholds);
     336                 :            : 
     337                 :            : /**
     338                 :            :  * bm_pool_set_hw_threshold - Change the buffer pool's thresholds
     339                 :            :  * @pool: Pool id
     340                 :            :  * @low_thresh: low threshold
     341                 :            :  * @high_thresh: high threshold
     342                 :            :  */
     343                 :            : int bm_pool_set_hw_threshold(u32 bpid, const u32 low_thresh,
     344                 :            :                              const u32 high_thresh);
     345                 :            : 
     346                 :            : #ifdef __cplusplus
     347                 :            : }
     348                 :            : #endif
     349                 :            : 
     350                 :            : #endif /* __FSL_BMAN_H */