release/src-rt/include/hndrte_lbuf.h

   1 /*
   2  * HND RTE packet buffer definitions.
   3  *
   4  * Copyright (C) 2010, Broadcom Corporation
   5  * All Rights Reserved.
   6  *
   7  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
   8  * the contents of this file may not be disclosed to third parties, copied
   9  * or duplicated in any form, in whole or in part, without the prior
  10  * written permission of Broadcom Corporation.
  11  *
  12  * $Id: hndrte_lbuf.h,v 13.38 2009-11-08 21:00:48 Exp $
  13  */
  14
  15 #ifndef _hndrte_lbuf_h_
  16 #define _hndrte_lbuf_h_
  17
  18 #include <bcmdefs.h>
  19
  20 struct lbuf {
  21         struct lbuf     *next;          /* next lbuf in a chain of lbufs forming one packet */
  22         struct lbuf     *link;          /* first lbuf of next packet in a list of packets */
  23         uchar           *head;          /* fixed start of buffer */
  24         uchar           *end;           /* fixed end of buffer */
  25         uchar           *data;          /* variable start of data */
  26         uint16          len;            /* nbytes of data */
  27         uint16          flags;          /* private flags; don't touch */
  28         uint16          dmapad;         /* padding to be added for tx dma */
  29         uint8           dataOff;        /* offset to beginning of data in 4-byte words */
  30         uint8           refcnt;         /* external references to this lbuf */
  31         void            *pool;          /* BCMPKTPOOL */
  32         uint32          pkttag[(OSL_PKTTAG_SZ + 3) / 4];  /* 4-byte-aligned packet tag area */
  33 };
  34
  35 #define LBUFSZ          sizeof(struct lbuf)
  36
  37 /* Total maximum packet buffer size including lbuf header */
  38 #define MAXPKTBUFSZ     1920            /* enough to fit a 1500 MTU plus overhead */
  39
  40 /* private flags - don't reference directly */
  41 #define LBF_PRI         0x0007          /* priority (low 3 bits of flags) */
  42 #define LBF_SUM_NEEDED  0x0008
  43 #define LBF_SUM_GOOD    0x0010
  44 #define LBF_MSGTRACE    0x0020
  45 #define LBF_CLONE       0x0040
  46 #define LBF_PTBLK       0x0100          /* came from fixed block in a partition, not main malloc */
  47 #define LBF_POOL        0x0200
  48 #define LBF_POOLSTATE_MASK      0xF000
  49 #define LBF_POOLSTATE_SHIFT     12
  50
  51
  52 #define LBP(lb)         ((struct lbuf *)(lb))
  53
  54 /* lbuf clone structure
  55  * if lbuf->flags LBF_CLONE bit is set, the lbuf can be cast to an lbuf_clone
  56  */
  57 struct lbuf_clone {
  58         struct lbuf     lbuf;
  59         struct lbuf     *orig;  /* original non-clone lbuf providing the buffer space */
  60 };
  61
  62 /* prototypes */
  63 extern void lb_init(void);
  64 #if defined(BCMDBG_MEM) || defined(BCMDBG_MEMFAIL)
  65 extern struct lbuf *lb_alloc(uint size, const char *file, int line);
  66 extern struct lbuf *lb_clone(struct lbuf *lb, int offset, int len, const char *file, int line);
  67 #else
  68 extern struct lbuf *lb_alloc(uint size);
  69 extern struct lbuf *lb_clone(struct lbuf *lb, int offset, int len);
  70 #endif /* BCMDBG_MEM || BCMDBG_MEMFAIL */
  71
  72 extern struct lbuf *lb_dup(struct lbuf *lb);
  73 extern void lb_free(struct lbuf *lb);
  74 extern bool lb_sane(struct lbuf *lb);
  75 extern void lb_resetpool(struct lbuf *lb, uint16 len);
  76 #ifdef BCMDBG
  77 extern void lb_dump(void);
  78 #endif
  79
  80 #ifdef __GNUC__
  81
  82 /* GNU macro versions avoid the -fno-inline used in ROM builds. */
  83
  84 #define lb_push(lb, _len) ({ \
  85         uint __len = (_len); \
  86         ASSERT(lb_sane(lb)); \
  87         ASSERT(((lb)->data - __len) >= (lb)->head); \
  88         (lb)->data -= __len; \
  89         (lb)->len += __len; \
  90         lb->data; \
  91 })
  92
  93 #define lb_pull(lb, _len) ({ \
  94         uint __len = (_len); \
  95         ASSERT(lb_sane(lb)); \
  96         ASSERT(__len <= (lb)->len); \
  97         (lb)->data += __len; \
  98         (lb)->len -= __len; \
  99         lb->data; \
 100 })
 101
 102 #define lb_setlen(lb, _len) ({ \
 103         uint __len = (_len); \
 104         ASSERT(lb_sane(lb)); \
 105         ASSERT((lb)->data + __len <= (lb)->end); \
 106         (lb)->len = (__len); \
 107 })
 108
 109 #define lb_pri(lb) ({ \
 110         ASSERT(lb_sane(lb)); \
 111         ((lb)->flags & LBF_PRI); \
 112 })
 113
 114 #define lb_setpri(lb, pri) ({ \
 115         uint _pri = (pri); \
 116         ASSERT(lb_sane(lb)); \
 117         ASSERT((_pri & LBF_PRI) == _pri); \
 118         (lb)->flags = ((lb)->flags & ~LBF_PRI) | (_pri & LBF_PRI); \
 119 })
 120
 121 #define lb_sumneeded(lb) ({ \
 122         ASSERT(lb_sane(lb)); \
 123         (((lb)->flags & LBF_SUM_NEEDED) != 0); \
 124 })
 125
 126 #define lb_setsumneeded(lb, summed) ({ \
 127         ASSERT(lb_sane(lb)); \
 128         if (summed) \
 129                 (lb)->flags |= LBF_SUM_NEEDED; \
 130         else \
 131                 (lb)->flags &= ~LBF_SUM_NEEDED; \
 132 })
 133
 134 #define lb_sumgood(lb) ({ \
 135         ASSERT(lb_sane(lb)); \
 136         (((lb)->flags & LBF_SUM_GOOD) != 0); \
 137 })
 138
 139 #define lb_setsumgood(lb, summed) ({ \
 140         ASSERT(lb_sane(lb)); \
 141         if (summed) \
 142                 (lb)->flags |= LBF_SUM_GOOD; \
 143         else \
 144                 (lb)->flags &= ~LBF_SUM_GOOD; \
 145 })
 146
 147 #define lb_msgtrace(lb) ({ \
 148         ASSERT(lb_sane(lb)); \
 149         (((lb)->flags & LBF_MSGTRACE) != 0); \
 150 })
 151
 152 #define lb_setmsgtrace(lb, set) ({ \
 153         ASSERT(lb_sane(lb)); \
 154         if (set) \
 155                 (lb)->flags |= LBF_MSGTRACE; \
 156         else \
 157                 (lb)->flags &= ~LBF_MSGTRACE; \
 158 })
 159
 160 #define lb_dataoff(lb) ({ \
 161         ASSERT(lb_sane(lb)); \
 162         (lb)->dataOff; \
 163 })
 164
 165 #define lb_setdataoff(lb, _dataOff) ({ \
 166         ASSERT(lb_sane(lb)); \
 167         (lb)->dataOff = _dataOff; \
 168 })
 169
 170 #define lb_isclone(lb) ({ \
 171         ASSERT(lb_sane(lb)); \
 172         (((lb)->flags & LBF_CLONE) != 0); \
 173 })
 174
 175 #define lb_isptblk(lb) ({ \
 176         ASSERT(lb_sane(lb)); \
 177         (((lb)->flags & LBF_PTBLK) != 0); \
 178 })
 179
 180 #define lb_setpool(lb, set, _pool) ({ \
 181         ASSERT(lb_sane(lb)); \
 182         if (set) \
 183                 (lb)->flags |= LBF_POOL; \
 184         else \
 185                 (lb)->flags &= ~LBF_POOL; \
 186         (lb)->pool = (_pool); \
 187 })
 188
 189 #define lb_getpool(lb) ({ \
 190         ASSERT(lb_sane(lb)); \
 191         (lb)->pool; \
 192 })
 193
 194 #define lb_pool(lb) ({ \
 195         ASSERT(lb_sane(lb)); \
 196         (((lb)->flags & LBF_POOL) != 0); \
 197 })
 198
 199 #define lb_poolstate(lb) ({ \
 200         ASSERT(lb_sane(lb)); \
 201         (((lb)->flags & LBF_POOLSTATE_MASK) >> LBF_POOLSTATE_SHIFT); \
 202 })
 203
 204 #define lb_setpoolstate(lb, state) ({ \
 205         ASSERT(lb_sane(lb)); \
 206         (lb)->flags &= ~LBF_POOLSTATE_MASK; \
 207         (lb)->flags |= (state) << LBF_POOLSTATE_SHIFT; \
 208 })
 209
 210 #else /* !__GNUC__ */
 211
 212 static INLINE uchar *
 213 lb_push(struct lbuf *lb, uint len)
 214 {
 215         ASSERT(lb_sane(lb));
 216         ASSERT((lb->data - len) >= lb->head);
 217         lb->data -= len;
 218         lb->len += len;
 219         return (lb->data);
 220 }
 221
 222 static INLINE uchar *
 223 lb_pull(struct lbuf *lb, uint len)
 224 {
 225         ASSERT(lb_sane(lb));
 226         ASSERT(len <= lb->len);
 227         lb->data += len;
 228         lb->len -= len;
 229         return (lb->data);
 230 }
 231
 232 static INLINE void
 233 lb_setlen(struct lbuf *lb, uint len)
 234 {
 235         ASSERT(lb_sane(lb));
 236         ASSERT(lb->data + len <= lb->end);
 237         lb->len = len;
 238 }
 239
 240 static INLINE uint
 241 lb_pri(struct lbuf *lb)
 242 {
 243         ASSERT(lb_sane(lb));
 244         return (lb->flags & LBF_PRI);
 245 }
 246
 247 static INLINE void
 248 lb_setpri(struct lbuf *lb, uint pri)
 249 {
 250         ASSERT(lb_sane(lb));
 251         ASSERT((pri & LBF_PRI) == pri);
 252         lb->flags = (lb->flags & ~LBF_PRI) | (pri & LBF_PRI);
 253 }
 254
 255 static INLINE bool
 256 lb_sumneeded(struct lbuf *lb)
 257 {
 258         ASSERT(lb_sane(lb));
 259         return ((lb->flags & LBF_SUM_NEEDED) != 0);
 260 }
 261
 262 static INLINE void
 263 lb_setsumneeded(struct lbuf *lb, bool summed)
 264 {
 265         ASSERT(lb_sane(lb));
 266         if (summed)
 267                 lb->flags |= LBF_SUM_NEEDED;
 268         else
 269                 lb->flags &= ~LBF_SUM_NEEDED;
 270 }
 271
 272 static INLINE bool
 273 lb_sumgood(struct lbuf *lb)
 274 {
 275         ASSERT(lb_sane(lb));
 276         return ((lb->flags & LBF_SUM_GOOD) != 0);
 277 }
 278
 279 static INLINE void
 280 lb_setsumgood(struct lbuf *lb, bool summed)
 281 {
 282         ASSERT(lb_sane(lb));
 283         if (summed)
 284                 lb->flags |= LBF_SUM_GOOD;
 285         else
 286                 lb->flags &= ~LBF_SUM_GOOD;
 287 }
 288
 289 static INLINE bool
 290 lb_msgtrace(struct lbuf *lb)
 291 {
 292         ASSERT(lb_sane(lb));
 293         return ((lb->flags & LBF_MSGTRACE) != 0);
 294 }
 295
 296 static INLINE void
 297 lb_setmsgtrace(struct lbuf *lb, bool set)
 298 {
 299         ASSERT(lb_sane(lb));
 300         if (set)
 301                 lb->flags |= LBF_MSGTRACE;
 302         else
 303                 lb->flags &= ~LBF_MSGTRACE;
 304 }
 305
 306 /* get Data Offset */
 307 static INLINE uint8
 308 lb_dataoff(struct lbuf *lb)
 309 {
 310         ASSERT(lb_sane(lb));
 311         return (lb->dataOff);
 312 }
 313
 314 /* set Data Offset */
 315 static INLINE void
 316 lb_setdataoff(struct lbuf *lb, uint8 dataOff)
 317 {
 318         ASSERT(lb_sane(lb));
 319         lb->dataOff = dataOff;
 320 }
 321
 322 static INLINE int
 323 lb_isclone(struct lbuf *lb)
 324 {
 325         ASSERT(lb_sane(lb));
 326         return ((lb->flags & LBF_CLONE) != 0);
 327 }
 328
 329 static INLINE int
 330 lb_isptblk(struct lbuf *lb)
 331 {
 332         ASSERT(lb_sane(lb));
 333         return ((lb->flags & LBF_PTBLK) != 0);
 334 }
 335
 336 /* if set, lb_free() skips de-alloc */
 337 static INLINE void
 338 lb_setpool(struct lbuf *lb, int8 set, void *pool)
 339 {
 340         ASSERT(lb_sane(lb));
 341
 342         if (set)
 343                 lb->flags |= LBF_POOL;
 344         else
 345                 lb->flags &= ~LBF_POOL;
 346
 347         lb->pool = pool;
 348 }
 349
 350 static INLINE void *
 351 lb_getpool(struct lbuf *lb)
 352 {
 353         ASSERT(lb_sane(lb));
 354
 355         return lb->pool;
 356 }
 357
 358 static INLINE bool
 359 lb_pool(struct lbuf *lb)
 360 {
 361         ASSERT(lb_sane(lb));
 362         return ((lb->flags & LBF_POOL) != 0);
 363 }
 364
 365 static INLINE int8
 366 lb_poolstate(struct lbuf *lb)
 367 {
 368         ASSERT(lb_sane(lb));
 369         return ((lb->flags & LBF_POOLSTATE_MASK) >> LBF_POOLSTATE_SHIFT);
 370 }
 371
 372 static INLINE void
 373 lb_setpoolstate(struct lbuf *lb, int8 state)
 374 {
 375         ASSERT(lb_sane(lb));
 376         lb->flags &= ~LBF_POOLSTATE_MASK;
 377         lb->flags |= state << LBF_POOLSTATE_SHIFT;
 378 }
 379
 380 #endif  /* !__GNUC__ */
 381 #endif  /* !_hndrte_lbuf_h_ */