source: SVN/cambria/redboot/packages/devs/eth/intel/npe/common/current/src/IxOsalBufferMgt.c @ 1

Last change on this file since 1 was 1, checked in by Tim Harvey, 2 years ago

restored latest version of files from server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 23.1 KB
Line 
1/**
2 * @file IxOsalBufferMgt.c
3 *
4 * @brief Default buffer pool management and buffer management
5 *        Implementation.
6 *
7 * Design Notes:
8 *
9 * @par
10 * IXP400 SW Release version  2.0
11 *
12 * -- Intel Copyright Notice --
13 *
14 * @par
15 * Copyright 2002-2004 Intel Corporation All Rights Reserved.
16 *
17 * @par
18 * The source code contained or described herein and all documents
19 * related to the source code ("Material") are owned by Intel Corporation
20 * or its suppliers or licensors.  Title to the Material remains with
21 * Intel Corporation or its suppliers and licensors.
22 *
23 * @par
24 * The Material is protected by worldwide copyright and trade secret laws
25 * and treaty provisions. No part of the Material may be used, copied,
26 * reproduced, modified, published, uploaded, posted, transmitted,
27 * distributed, or disclosed in any way except in accordance with the
28 * applicable license agreement .
29 *
30 * @par
31 * No license under any patent, copyright, trade secret or other
32 * intellectual property right is granted to or conferred upon you by
33 * disclosure or delivery of the Materials, either expressly, by
34 * implication, inducement, estoppel, except in accordance with the
35 * applicable license agreement.
36 *
37 * @par
38 * Unless otherwise agreed by Intel in writing, you may not remove or
39 * alter this notice or any other notice embedded in Materials by Intel
40 * or Intel's suppliers or licensors in any way.
41 *
42 * @par
43 * For further details, please see the file README.TXT distributed with
44 * this software.
45 *
46 * @par
47 * -- End Intel Copyright Notice --
48 */
49
50/*
51 * OS may choose to use default bufferMgt by defining
52 * IX_OSAL_USE_DEFAULT_BUFFER_MGT in IxOsalOsBufferMgt.h 
53 */
54
55#include "IxOsal.h"
56
57#define IX_OSAL_BUFFER_FREE_PROTECTION  /* Define this to enable Illegal MBuf Freed Protection*/
58
59/*
60 * The implementation is only used when the following
61 * is defined.
62 */
63#ifdef IX_OSAL_USE_DEFAULT_BUFFER_MGT
64
65
66#define IX_OSAL_MBUF_SYS_SIGNATURE                              (0x8BADF00D)
67#define IX_OSAL_MBUF_SYS_SIGNATURE_MASK                         (0xEFFFFFFF)
68#define IX_OSAL_MBUF_USED_FLAG                                  (0x10000000)
69#define IX_OSAL_MBUF_SYS_SIGNATURE_INIT(bufPtr)                 IX_OSAL_MBUF_SIGNATURE (bufPtr) = (UINT32)IX_OSAL_MBUF_SYS_SIGNATURE
70
71/*
72*  This implementation is protect, the buffer pool management's  ixOsalMBufFree
73*  against an invalid MBUF pointer argument that already has been freed earlier
74*  or in other words resides in the free pool of MBUFs. This added feature,
75*  checks the MBUF "USED" FLAG. The Flag tells if the MBUF is still not freed
76*  back to the Buffer Pool.
77*  Disable this feature for performance reasons by undef
78*  IX_OSAL_BUFFER_FREE_PROTECTION macro.
79*/
80#ifdef IX_OSAL_BUFFER_FREE_PROTECTION  /*IX_OSAL_BUFFER_FREE_PROTECTION With Buffer Free protection*/
81
82#define IX_OSAL_MBUF_GET_SYS_SIGNATURE(bufPtr)          (IX_OSAL_MBUF_SIGNATURE (bufPtr)&(IX_OSAL_MBUF_SYS_SIGNATURE_MASK) )
83#define IX_OSAL_MBUF_SET_SYS_SIGNATURE(bufPtr)    do {                                                                                                                                                                                                                  \
84                                                                                                                                                                                                        IX_OSAL_MBUF_SIGNATURE (bufPtr)&(~IX_OSAL_MBUF_SYS_SIGNATURE_MASK);\
85                                                                                                                                                                                        IX_OSAL_MBUF_SIGNATURE (bufPtr)|=IX_OSAL_MBUF_SYS_SIGNATURE;                    \
86                                                                                                                                                                                                        }while(0)
87
88#define IX_OSAL_MBUF_SET_USED_FLAG(bufPtr)   IX_OSAL_MBUF_SIGNATURE (bufPtr)|=IX_OSAL_MBUF_USED_FLAG
89#define IX_OSAL_MBUF_CLEAR_USED_FLAG(bufPtr) IX_OSAL_MBUF_SIGNATURE (bufPtr)&=~IX_OSAL_MBUF_USED_FLAG
90#define IX_OSAL_MBUF_ISSET_USED_FLAG(bufPtr) (IX_OSAL_MBUF_SIGNATURE (bufPtr)&IX_OSAL_MBUF_USED_FLAG)
91
92#else
93
94#define IX_OSAL_MBUF_GET_SYS_SIGNATURE(bufPtr)   IX_OSAL_MBUF_SIGNATURE (bufPtr)
95#define IX_OSAL_MBUF_SET_SYS_SIGNATURE(bufPtr)   IX_OSAL_MBUF_SIGNATURE (bufPtr) = IX_OSAL_MBUF_SYS_SIGNATURE
96
97#endif /*IX_OSAL_BUFFER_FREE_PROTECTION With Buffer Free protection*/
98/*
99 * Variable declarations global to this file only.  Externs are followed by
100 * static variables.
101 */
102
103/*
104 * A unit of 32, used to provide bit-shift for pool
105 * management. Needs some work if users want more than 32 pools.
106 */
107#define IX_OSAL_BUFF_FREE_BITS 32
108
109PRIVATE UINT32 ixOsalBuffFreePools[IX_OSAL_MBUF_MAX_POOLS /
110    IX_OSAL_BUFF_FREE_BITS];
111
112PUBLIC IX_OSAL_MBUF_POOL ixOsalBuffPools[IX_OSAL_MBUF_MAX_POOLS];
113
114static int ixOsalBuffPoolsInUse = 0;
115
116#ifdef IX_OSAL_BUFFER_ALLOC_SEPARATELY
117PRIVATE IX_OSAL_MBUF *
118ixOsalBuffPoolMbufInit (UINT32 mbufSizeAligned,
119                      UINT32 dataSizeAligned,
120                      IX_OSAL_MBUF_POOL *poolPtr);
121#endif
122
123PRIVATE IX_OSAL_MBUF_POOL * ixOsalPoolAlloc (void);                     
124
125/*
126 * Function definition: ixOsalPoolAlloc
127 */
128
129/****************************/
130
131PRIVATE IX_OSAL_MBUF_POOL *
132ixOsalPoolAlloc (void)
133{
134    register unsigned int i = 0;
135
136    /*
137     * Scan for the first free buffer. Free buffers are indicated by 0
138     * on the corrsponding bit in ixOsalBuffFreePools.
139     */
140    if (ixOsalBuffPoolsInUse >= IX_OSAL_MBUF_MAX_POOLS)
141    {
142        /*
143         * Fail to grab a ptr this time
144         */
145        return NULL;
146    }
147
148    while (ixOsalBuffFreePools[i / IX_OSAL_BUFF_FREE_BITS] &
149        (1 << (i % IX_OSAL_BUFF_FREE_BITS)))
150        i++;
151    /*
152     * Free buffer found. Mark it as busy and initialize.
153     */
154    ixOsalBuffFreePools[i / IX_OSAL_BUFF_FREE_BITS] |=
155        (1 << (i % IX_OSAL_BUFF_FREE_BITS));
156
157    memset (&ixOsalBuffPools[i], 0, sizeof (IX_OSAL_MBUF_POOL));
158
159    ixOsalBuffPools[i].poolIdx = i;
160    ixOsalBuffPoolsInUse++;
161
162    return &ixOsalBuffPools[i];
163}
164
165
166#ifdef IX_OSAL_BUFFER_ALLOC_SEPARATELY
167PRIVATE IX_OSAL_MBUF *
168ixOsalBuffPoolMbufInit (UINT32 mbufSizeAligned,
169                      UINT32 dataSizeAligned,
170                      IX_OSAL_MBUF_POOL *poolPtr)
171{
172    UINT8 *dataPtr;
173    IX_OSAL_MBUF *realMbufPtr;
174    /* Allocate cache-aligned memory for mbuf header */
175    realMbufPtr = (IX_OSAL_MBUF *) IX_OSAL_CACHE_DMA_MALLOC (mbufSizeAligned);
176    IX_OSAL_ASSERT (realMbufPtr != NULL);
177    memset (realMbufPtr, 0, mbufSizeAligned);
178
179    /* Allocate cache-aligned memory for mbuf data */
180    dataPtr = (UINT8 *) IX_OSAL_CACHE_DMA_MALLOC (dataSizeAligned);
181    IX_OSAL_ASSERT (dataPtr != NULL);
182    memset (dataPtr, 0, dataSizeAligned);
183
184    /* Fill in mbuf header fields */
185    IX_OSAL_MBUF_MDATA (realMbufPtr) = dataPtr;
186    IX_OSAL_MBUF_ALLOCATED_BUFF_DATA (realMbufPtr) = (UINT32)dataPtr;
187
188    IX_OSAL_MBUF_MLEN (realMbufPtr) = dataSizeAligned;
189    IX_OSAL_MBUF_ALLOCATED_BUFF_LEN (realMbufPtr) = dataSizeAligned;
190
191    IX_OSAL_MBUF_NET_POOL (realMbufPtr) = (IX_OSAL_MBUF_POOL *) poolPtr;
192
193    IX_OSAL_MBUF_SYS_SIGNATURE_INIT(realMbufPtr);
194
195    /* update some statistical information */
196    poolPtr->mbufMemSize += mbufSizeAligned;
197    poolPtr->dataMemSize += dataSizeAligned;
198
199    return realMbufPtr;
200}
201#endif /* #ifdef IX_OSAL_BUFFER_ALLOC_SEPARATELY */
202
203/*
204 * Function definition: ixOsalBuffPoolInit
205 */
206
207PUBLIC IX_OSAL_MBUF_POOL *
208ixOsalPoolInit (UINT32 count, UINT32 size, const char *name)
209{
210
211    /* These variables are only used if UX_OSAL_BUFFER_ALLOC_SEPERATELY
212     * is defined .
213     */
214#ifdef IX_OSAL_BUFFER_ALLOC_SEPARATELY
215    UINT32 i, mbufSizeAligned, dataSizeAligned;
216    IX_OSAL_MBUF *currentMbufPtr = NULL;
217#else
218    void *poolBufPtr;
219    void *poolDataPtr;
220    int mbufMemSize;
221    int dataMemSize;
222#endif
223
224    IX_OSAL_MBUF_POOL *poolPtr = NULL;
225   
226    if (count <= 0)
227    {
228        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
229            IX_OSAL_LOG_DEV_STDOUT,
230            "ixOsalPoolInit(): " "count = 0 \n", 0, 0, 0, 0, 0, 0);
231        return NULL;       
232    }
233
234    if (name == NULL)
235    {
236        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
237            IX_OSAL_LOG_DEV_STDOUT,
238            "ixOsalPoolInit(): " "NULL name \n", 0, 0, 0, 0, 0, 0);
239        return NULL;       
240    }
241   
242    if (strlen (name) > IX_OSAL_MBUF_POOL_NAME_LEN)
243    {
244        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
245            IX_OSAL_LOG_DEV_STDOUT,
246            "ixOsalPoolInit(): "
247            "ERROR - name length should be no greater than %d  \n",
248            IX_OSAL_MBUF_POOL_NAME_LEN, 0, 0, 0, 0, 0);
249        return NULL;
250    }
251
252/* OS can choose whether to allocate all buffers all together (if it
253 * can handle a huge single alloc request), or to allocate buffers
254 * separately by the defining IX_OSAL_BUFFER_ALLOC_SEPARATELY.
255 */
256#ifdef IX_OSAL_BUFFER_ALLOC_SEPARATELY
257    /* Get a pool Ptr */
258    poolPtr = ixOsalPoolAlloc ();
259
260    if (poolPtr == NULL)
261    {
262        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
263            IX_OSAL_LOG_DEV_STDOUT,
264            "ixOsalPoolInit(): " "Fail to Get PoolPtr \n", 0, 0, 0, 0, 0, 0);   
265        return NULL;
266    }
267
268    mbufSizeAligned = IX_OSAL_MBUF_POOL_SIZE_ALIGN (sizeof (IX_OSAL_MBUF));
269    dataSizeAligned = IX_OSAL_MBUF_POOL_SIZE_ALIGN(size);
270
271    poolPtr->nextFreeBuf = NULL;   
272    poolPtr->mbufMemPtr = NULL;   
273    poolPtr->dataMemPtr = NULL;
274    poolPtr->bufDataSize = dataSizeAligned;
275    poolPtr->totalBufsInPool = count;
276    poolPtr->poolAllocType = IX_OSAL_MBUF_POOL_TYPE_SYS_ALLOC;
277    strcpy (poolPtr->name, name);
278
279
280    for (i = 0; i < count; i++)
281    {
282            /* create an mbuf */
283            currentMbufPtr = ixOsalBuffPoolMbufInit (mbufSizeAligned,
284                                                 dataSizeAligned,
285                                                 poolPtr);
286
287#ifdef IX_OSAL_BUFFER_FREE_PROTECTION           
288/* Set the Buffer USED Flag. If not, ixOsalMBufFree will fail.
289   ixOsalMbufFree used here is in a special case whereby, it's
290   used to add MBUF to the Pool. By specification, ixOsalMbufFree
291   deallocates an allocated MBUF from Pool.
292*/                               
293      IX_OSAL_MBUF_SET_USED_FLAG(currentMbufPtr);
294#endif                             
295            /* Add it to the pool */
296            ixOsalMbufFree (currentMbufPtr);
297
298            /* flush the pool information to RAM */
299            IX_OSAL_CACHE_FLUSH (currentMbufPtr, mbufSizeAligned);
300    }
301   
302    /*
303     * update the number of free buffers in the pool
304     */
305    poolPtr->freeBufsInPool = count;
306
307#else
308/* Otherwise allocate buffers in a continuous block fashion */   
309    poolBufPtr = IX_OSAL_MBUF_POOL_MBUF_AREA_ALLOC (count, mbufMemSize);
310    IX_OSAL_ASSERT (poolBufPtr != NULL);
311    poolDataPtr =
312        IX_OSAL_MBUF_POOL_DATA_AREA_ALLOC (count, size, dataMemSize);
313    IX_OSAL_ASSERT (poolDataPtr != NULL);
314
315    poolPtr = ixOsalNoAllocPoolInit (poolBufPtr, poolDataPtr,
316        count, size, name);
317    if (poolPtr == NULL)
318    {
319        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
320            IX_OSAL_LOG_DEV_STDOUT,
321            "ixOsalPoolInit(): " "Fail to get pool ptr \n", 0, 0, 0, 0, 0, 0);
322        return NULL;
323    }
324
325    poolPtr->poolAllocType = IX_OSAL_MBUF_POOL_TYPE_SYS_ALLOC;
326
327#endif /* IX_OSAL_BUFFER_ALLOC_SEPARATELY */
328    return poolPtr;
329}
330
331PUBLIC IX_OSAL_MBUF_POOL *
332ixOsalNoAllocPoolInit (void *poolBufPtr,
333    void *poolDataPtr, UINT32 count, UINT32 size, const char *name)
334{
335    UINT32 i,  mbufSizeAligned, sizeAligned;
336    IX_OSAL_MBUF *currentMbufPtr = NULL;
337    IX_OSAL_MBUF *nextMbufPtr = NULL;
338    IX_OSAL_MBUF_POOL *poolPtr = NULL;
339
340    /*
341     * check parameters
342     */
343    if (poolBufPtr == NULL)
344    {
345        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
346            IX_OSAL_LOG_DEV_STDOUT,
347            "ixOsalNoAllocPoolInit(): "
348            "ERROR - NULL poolBufPtr \n", 0, 0, 0, 0, 0, 0);
349        return NULL;
350    }
351
352    if (count <= 0)
353    {
354        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
355            IX_OSAL_LOG_DEV_STDOUT,
356            "ixOsalNoAllocPoolInit(): "
357            "ERROR - count must > 0   \n", 0, 0, 0, 0, 0, 0);
358        return NULL;
359    }
360
361    if (name == NULL)
362    {
363        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
364            IX_OSAL_LOG_DEV_STDOUT,
365            "ixOsalNoAllocPoolInit(): "
366            "ERROR - NULL name ptr  \n", 0, 0, 0, 0, 0, 0);
367        return NULL;
368    }
369
370    if (strlen (name) > IX_OSAL_MBUF_POOL_NAME_LEN)
371    {
372        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
373            IX_OSAL_LOG_DEV_STDOUT,
374            "ixOsalNoAllocPoolInit(): "
375            "ERROR - name length should be no greater than %d  \n",
376            IX_OSAL_MBUF_POOL_NAME_LEN, 0, 0, 0, 0, 0);
377        return NULL;
378    }
379
380    poolPtr = ixOsalPoolAlloc ();
381
382    if (poolPtr == NULL)
383    {
384        return NULL;
385    }
386
387    /*
388     * Adjust sizes to ensure alignment on cache line boundaries
389     */
390    mbufSizeAligned =
391        IX_OSAL_MBUF_POOL_SIZE_ALIGN (sizeof (IX_OSAL_MBUF));
392    /*
393     * clear the mbuf memory area
394     */
395    memset (poolBufPtr, 0, mbufSizeAligned * count);
396
397    if (poolDataPtr != NULL)
398    {
399        /*
400         * Adjust sizes to ensure alignment on cache line boundaries
401         */
402        sizeAligned = IX_OSAL_MBUF_POOL_SIZE_ALIGN (size);
403        /*
404         * clear the data memory area
405         */
406        memset (poolDataPtr, 0, sizeAligned * count);
407    }
408    else
409    {
410        sizeAligned = 0;
411    }
412
413    /*
414     * initialise pool fields
415     */
416    strcpy ((poolPtr)->name, name);
417
418    poolPtr->dataMemPtr = poolDataPtr;
419    poolPtr->mbufMemPtr = poolBufPtr;
420    poolPtr->bufDataSize = sizeAligned;
421    poolPtr->totalBufsInPool = count;
422    poolPtr->mbufMemSize = mbufSizeAligned * count;
423    poolPtr->dataMemSize = sizeAligned * count;
424
425    currentMbufPtr = (IX_OSAL_MBUF *) poolBufPtr;
426
427    poolPtr->nextFreeBuf = currentMbufPtr;
428
429    for (i = 0; i < count; i++)
430    {
431        if (i < (count - 1))
432        {
433            nextMbufPtr =
434                (IX_OSAL_MBUF *) ((unsigned) currentMbufPtr +
435                mbufSizeAligned);
436        }
437        else
438        {                       /* last mbuf in chain */
439            nextMbufPtr = NULL;
440        }
441        IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR (currentMbufPtr) = nextMbufPtr;
442        IX_OSAL_MBUF_NET_POOL (currentMbufPtr) = poolPtr;
443
444        IX_OSAL_MBUF_SYS_SIGNATURE_INIT(currentMbufPtr);
445
446        if (poolDataPtr != NULL)
447        {
448            IX_OSAL_MBUF_MDATA (currentMbufPtr) = poolDataPtr;
449            IX_OSAL_MBUF_ALLOCATED_BUFF_DATA(currentMbufPtr) = (UINT32) poolDataPtr;
450
451            IX_OSAL_MBUF_MLEN (currentMbufPtr) = sizeAligned;
452            IX_OSAL_MBUF_ALLOCATED_BUFF_LEN(currentMbufPtr) = sizeAligned;
453
454            poolDataPtr = (void *) ((unsigned) poolDataPtr + sizeAligned);
455        }
456
457        currentMbufPtr = nextMbufPtr;
458    }
459
460    /*
461     * update the number of free buffers in the pool
462     */
463    poolPtr->freeBufsInPool = count;
464
465    poolPtr->poolAllocType = IX_OSAL_MBUF_POOL_TYPE_USER_ALLOC;
466
467    return poolPtr;
468}
469
470/*
471 * Get a mbuf ptr from the pool
472 */
473PUBLIC IX_OSAL_MBUF *
474ixOsalMbufAlloc (IX_OSAL_MBUF_POOL * poolPtr)
475{
476    int lock;
477    IX_OSAL_MBUF *newBufPtr = NULL;
478
479    /*
480     * check parameters
481     */
482    if (poolPtr == NULL)
483    {
484        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
485            IX_OSAL_LOG_DEV_STDOUT,
486            "ixOsalMbufAlloc(): "
487            "ERROR - Invalid Parameter\n", 0, 0, 0, 0, 0, 0);
488        return NULL;
489    }
490
491    lock = ixOsalIrqLock ();
492
493    newBufPtr = poolPtr->nextFreeBuf;
494    if (newBufPtr)
495    {
496        poolPtr->nextFreeBuf =
497            IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR (newBufPtr);
498        IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR (newBufPtr) = NULL;
499
500        /*
501         * update the number of free buffers in the pool
502         */
503        poolPtr->freeBufsInPool--;
504    }
505    else
506    {
507        /* Return NULL to indicate to caller that request is denied. */
508        ixOsalIrqUnlock (lock);
509
510        return NULL;
511    }
512
513#ifdef IX_OSAL_BUFFER_FREE_PROTECTION
514        /* Set Buffer Used Flag to indicate state.*/
515    IX_OSAL_MBUF_SET_USED_FLAG(newBufPtr);
516#endif
517
518    ixOsalIrqUnlock (lock);
519
520    return newBufPtr;
521}
522
523PUBLIC IX_OSAL_MBUF *
524ixOsalMbufFree (IX_OSAL_MBUF * bufPtr)
525{
526    int lock;
527    IX_OSAL_MBUF_POOL *poolPtr;
528
529    IX_OSAL_MBUF *nextBufPtr = NULL;
530
531    /*
532     * check parameters
533     */
534    if (bufPtr == NULL)
535    {
536        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
537            IX_OSAL_LOG_DEV_STDOUT,
538            "ixOsalMbufFree(): "
539            "ERROR - Invalid Parameter\n", 0, 0, 0, 0, 0, 0);
540        return NULL;
541    }
542
543
544
545    lock = ixOsalIrqLock ();
546
547#ifdef IX_OSAL_BUFFER_FREE_PROTECTION
548       
549        /* Prevention for Buffer freed more than once*/
550    if(!IX_OSAL_MBUF_ISSET_USED_FLAG(bufPtr))
551    {
552        return NULL;
553    }
554    IX_OSAL_MBUF_CLEAR_USED_FLAG(bufPtr);
555#endif
556       
557    poolPtr = IX_OSAL_MBUF_NET_POOL (bufPtr);
558
559    /*
560     * check the mbuf wrapper signature (if mbuf wrapper was used)
561     */
562    if (poolPtr->poolAllocType == IX_OSAL_MBUF_POOL_TYPE_SYS_ALLOC)
563    {
564        IX_OSAL_ENSURE ( (IX_OSAL_MBUF_GET_SYS_SIGNATURE(bufPtr) == IX_OSAL_MBUF_SYS_SIGNATURE),
565            "ixOsalBuffPoolBufFree: ERROR - Invalid mbuf signature.");
566    }
567
568    nextBufPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR (bufPtr);
569
570    IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR (bufPtr) = poolPtr->nextFreeBuf;
571    poolPtr->nextFreeBuf = bufPtr;
572
573    /*
574     * update the number of free buffers in the pool
575     */
576    poolPtr->freeBufsInPool++;
577
578    ixOsalIrqUnlock (lock);
579
580    return nextBufPtr;
581}
582
583PUBLIC void
584ixOsalMbufChainFree (IX_OSAL_MBUF * bufPtr)
585{
586    while ((bufPtr = ixOsalMbufFree (bufPtr)));
587}
588
589/*
590 * Function definition: ixOsalBuffPoolShow
591 */
592PUBLIC void
593ixOsalMbufPoolShow (IX_OSAL_MBUF_POOL * poolPtr)
594{
595    IX_OSAL_MBUF *nextBufPtr;
596    int count = 0;
597    int lock;
598
599    /*
600     * check parameters
601     */
602    if (poolPtr == NULL)
603    {
604        ixOsalLog (IX_OSAL_LOG_LVL_ERROR,
605            IX_OSAL_LOG_DEV_STDOUT,
606            "ixOsalBuffPoolShow(): "
607            "ERROR - Invalid Parameter", 0, 0, 0, 0, 0, 0);
608        /*
609         * return IX_FAIL;
610         */
611        return;
612    }
613
614    lock = ixOsalIrqLock ();
615    count = poolPtr->freeBufsInPool;
616    nextBufPtr = poolPtr->nextFreeBuf;
617    ixOsalIrqUnlock (lock);
618
619    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE,
620        IX_OSAL_LOG_DEV_STDOUT, "=== POOL INFORMATION ===\n", 0, 0, 0,
621        0, 0, 0);
622    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
623        "Pool Name:                   %s\n",
624        (unsigned int) poolPtr->name, 0, 0, 0, 0, 0);
625    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
626        "Pool Allocation Type:        %d\n",
627        (unsigned int) poolPtr->poolAllocType, 0, 0, 0, 0, 0);
628    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
629        "Pool Mbuf Mem Usage (bytes): %d\n",
630        (unsigned int) poolPtr->mbufMemSize, 0, 0, 0, 0, 0);
631    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
632        "Pool Data Mem Usage (bytes): %d\n",
633        (unsigned int) poolPtr->dataMemSize, 0, 0, 0, 0, 0);
634    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
635        "Mbuf Data Capacity  (bytes): %d\n",
636        (unsigned int) poolPtr->bufDataSize, 0, 0, 0, 0, 0);
637    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
638        "Total Mbufs in Pool:         %d\n",
639        (unsigned int) poolPtr->totalBufsInPool, 0, 0, 0, 0, 0);
640    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
641        "Available Mbufs:             %d\n", (unsigned int) count, 0,
642        0, 0, 0, 0);
643    ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
644        "Next Available Mbuf:         %p\n", (unsigned int) nextBufPtr,
645        0, 0, 0, 0, 0);
646
647    if (poolPtr->poolAllocType == IX_OSAL_MBUF_POOL_TYPE_USER_ALLOC)
648    {
649        ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE,
650            IX_OSAL_LOG_DEV_STDOUT,
651            "Mbuf Mem Area Start address: %p\n",
652            (unsigned int) poolPtr->mbufMemPtr, 0, 0, 0, 0, 0);
653        ixOsalLog (IX_OSAL_LOG_LVL_MESSAGE, IX_OSAL_LOG_DEV_STDOUT,
654            "Data Mem Area Start address: %p\n",
655            (unsigned int) poolPtr->dataMemPtr, 0, 0, 0, 0, 0);
656    }
657}
658
659PUBLIC void
660ixOsalMbufDataPtrReset (IX_OSAL_MBUF * bufPtr)
661{
662    IX_OSAL_MBUF_POOL *poolPtr;
663    UINT8 *poolDataPtr;
664
665    if (bufPtr == NULL)
666    {
667        ixOsalLog (IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDOUT,
668            "ixOsalBuffPoolBufDataPtrReset"
669            ": ERROR - Invalid Parameter\n", 0, 0, 0, 0, 0, 0);
670        return;
671    }
672
673    poolPtr = (IX_OSAL_MBUF_POOL *) IX_OSAL_MBUF_NET_POOL (bufPtr);
674    poolDataPtr = poolPtr->dataMemPtr;
675
676    if (poolPtr->poolAllocType == IX_OSAL_MBUF_POOL_TYPE_SYS_ALLOC)
677    {
678        if (IX_OSAL_MBUF_GET_SYS_SIGNATURE(bufPtr) != IX_OSAL_MBUF_SYS_SIGNATURE)
679        {
680            ixOsalLog (IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDOUT,
681                "ixOsalBuffPoolBufDataPtrReset"
682                ": invalid mbuf, cannot reset mData pointer\n", 0, 0,
683                0, 0, 0, 0);
684            return;
685        }
686        IX_OSAL_MBUF_MDATA (bufPtr) = (UINT8*)IX_OSAL_MBUF_ALLOCATED_BUFF_DATA (bufPtr);
687    }
688    else
689    {
690        if (poolDataPtr)
691        {
692            unsigned int bufSize = poolPtr->bufDataSize;
693            unsigned int bufDataAddr =
694                (unsigned int) IX_OSAL_MBUF_MDATA (bufPtr);
695            unsigned int poolDataAddr = (unsigned int) poolDataPtr;
696
697            /*
698             * the pointer is still pointing somewhere in the mbuf payload.
699             * This operation moves the pointer to the beginning of the
700             * mbuf payload
701             */
702            bufDataAddr = ((bufDataAddr - poolDataAddr) / bufSize) * bufSize;
703            IX_OSAL_MBUF_MDATA (bufPtr) = &poolDataPtr[bufDataAddr];
704        }
705        else
706        {
707            ixOsalLog (IX_OSAL_LOG_LVL_WARNING, IX_OSAL_LOG_DEV_STDOUT,
708                "ixOsalBuffPoolBufDataPtrReset"
709                ": cannot be used if user supplied NULL pointer for pool data area "
710                "when pool was created\n", 0, 0, 0, 0, 0, 0);
711            return;
712        }
713    }
714
715}
716
717/*
718 * Function definition: ixOsalBuffPoolUninit
719 */
720PUBLIC IX_STATUS
721ixOsalBuffPoolUninit (IX_OSAL_MBUF_POOL * pool)
722{
723    if (!pool)
724    {
725        ixOsalLog (IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDOUT,
726            "ixOsalBuffPoolUninit: NULL ptr \n", 0, 0, 0, 0, 0, 0);
727        return IX_FAIL;
728    }
729
730    if (pool->freeBufsInPool != pool->totalBufsInPool)
731    {
732        ixOsalLog (IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDOUT,
733            "ixOsalBuffPoolUninit: need to return all ptrs to the pool first! \n",
734            0, 0, 0, 0, 0, 0);
735        return IX_FAIL;
736    }
737
738    if (pool->poolAllocType == IX_OSAL_MBUF_POOL_TYPE_SYS_ALLOC)
739    {
740#ifdef IX_OSAL_BUFFER_ALLOC_SEPARATELY
741                                UINT32 i;
742                                IX_OSAL_MBUF* pBuf;
743                               
744                                pBuf = pool->nextFreeBuf;
745                                /* Freed the Buffer one by one till all the Memory is freed*/
746                                for (i= pool->freeBufsInPool; i >0 && pBuf!=NULL ;i--){
747                                                IX_OSAL_MBUF* pBufTemp;
748                                                pBufTemp = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(pBuf);
749                                                /* Freed MBUF Data Memory area*/
750                                                IX_OSAL_CACHE_DMA_FREE( (void *) (IX_OSAL_MBUF_ALLOCATED_BUFF_DATA(pBuf)) );
751                                                /* Freed MBUF Struct Memory area*/
752                                                IX_OSAL_CACHE_DMA_FREE(pBuf);
753                                                pBuf = pBufTemp;
754                                }
755                               
756#else           
757        IX_OSAL_CACHE_DMA_FREE (pool->mbufMemPtr);
758        IX_OSAL_CACHE_DMA_FREE (pool->dataMemPtr);
759#endif       
760    }
761
762    ixOsalBuffFreePools[pool->poolIdx / IX_OSAL_BUFF_FREE_BITS] &=
763        ~(1 << (pool->poolIdx % IX_OSAL_BUFF_FREE_BITS));
764    ixOsalBuffPoolsInUse--;
765    return IX_SUCCESS;
766}
767
768/*
769 * Function definition: ixOsalBuffPoolDataAreaSizeGet
770 */
771PUBLIC UINT32
772ixOsalBuffPoolDataAreaSizeGet (int count, int size)
773{
774    UINT32 memorySize;
775    memorySize = count * IX_OSAL_MBUF_POOL_SIZE_ALIGN (size);
776    return memorySize;
777}
778
779/*
780 * Function definition: ixOsalBuffPoolMbufAreaSizeGet
781 */
782PUBLIC UINT32
783ixOsalBuffPoolMbufAreaSizeGet (int count)
784{
785    UINT32 memorySize;
786    memorySize =
787        count * IX_OSAL_MBUF_POOL_SIZE_ALIGN (sizeof (IX_OSAL_MBUF));
788    return memorySize;
789}
790
791/*
792 * Function definition: ixOsalBuffPoolFreeCountGet
793 */
794PUBLIC UINT32 ixOsalBuffPoolFreeCountGet(IX_OSAL_MBUF_POOL * poolPtr)
795
796{
797
798   return poolPtr->freeBufsInPool;
799
800}
801
802#endif /* IX_OSAL_USE_DEFAULT_BUFFER_MGT */
Note: See TracBrowser for help on using the repository browser.