drivers/bus/dpaa/include/fsl_bman.h

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