← Back to branch summary

~ubuntu-branches/ubuntu/maverick/u-boot-omap3/maverick

« back to all changes in this revision

Viewing changes to cpu/ixp/npe/IxOsalBufferMgt.c

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2010-03-22 15:06:23 UTC
  • Revision ID: james.westby@ubuntu.com-20100322150623-i21g8rgiyl5dohag
Tags: upstream-2010.3git20100315
Import upstream version 2010.3git20100315

Show diffs side-by-side

added added

removed removed

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