Merge branch 'u-boot-imx/master' into 'u-boot-arm/master'
[platform/kernel/u-boot.git] / drivers / net / npe / IxEthAccDataPlane.c
1 /**
2  * @file IxEthDataPlane.c
3  *
4  * @author Intel Corporation
5  * @date 12-Feb-2002
6  *
7  * @brief This file contains the implementation of the IXPxxx
8  * Ethernet Access Data plane component
9  *
10  * Design Notes:
11  *
12  * @par
13  * IXP400 SW Release version 2.0
14  *
15  * -- Copyright Notice --
16  *
17  * @par
18  * Copyright 2001-2005, Intel Corporation.
19  * All rights reserved.
20  *
21  * @par
22  * SPDX-License-Identifier:     BSD-3-Clause
23  * @par
24  * -- End of Copyright Notice --
25  */
26
27 #include "IxNpeMh.h"
28 #include "IxEthAcc.h"
29 #include "IxEthDB.h"
30 #include "IxOsal.h"
31 #include "IxEthDBPortDefs.h"
32 #include "IxFeatureCtrl.h"
33 #include "IxEthAcc_p.h"
34 #include "IxEthAccQueueAssign_p.h"
35
36 extern PUBLIC IxEthAccMacState ixEthAccMacState[];
37 extern PUBLIC UINT32 ixEthAccNewSrcMask;
38
39 /**
40  * private functions prototype
41  */
42 PRIVATE IX_OSAL_MBUF *
43 ixEthAccEntryFromQConvert(UINT32 qEntry, UINT32 mask);
44
45 PRIVATE UINT32
46 ixEthAccMbufRxQPrepare(IX_OSAL_MBUF *mbuf);
47
48 PRIVATE UINT32
49 ixEthAccMbufTxQPrepare(IX_OSAL_MBUF *mbuf);
50
51 PRIVATE IxEthAccStatus
52 ixEthAccTxSwQHighestPriorityGet(IxEthAccPortId portId,
53                                 IxEthAccTxPriority *priorityPtr);
54
55 PRIVATE IxEthAccStatus
56 ixEthAccTxFromSwQ(IxEthAccPortId portId,
57                   IxEthAccTxPriority priority);
58
59 PRIVATE IxEthAccStatus
60 ixEthAccRxFreeFromSwQ(IxEthAccPortId portId);
61
62 PRIVATE void
63 ixEthAccMbufFromTxQ(IX_OSAL_MBUF *mbuf);
64
65 PRIVATE void
66 ixEthAccMbufFromRxQ(IX_OSAL_MBUF *mbuf);
67
68 PRIVATE IX_STATUS
69 ixEthAccQmgrLockTxWrite(IxEthAccPortId portId,
70                         UINT32 qBuffer);
71
72 PRIVATE IX_STATUS
73 ixEthAccQmgrLockRxWrite(IxEthAccPortId portId,
74                         UINT32 qBuffer);
75
76 PRIVATE IX_STATUS
77 ixEthAccQmgrTxWrite(IxEthAccPortId portId,
78                     UINT32 qBuffer,
79                     UINT32 priority);
80
81 /**
82  * @addtogroup IxEthAccPri
83  *@{
84  */
85
86 /* increment a counter only when stats are enabled */
87 #define TX_STATS_INC(port,field) \
88         IX_ETH_ACC_STATS_INC(ixEthAccPortData[port].ixEthAccTxData.stats.field)
89 #define RX_STATS_INC(port,field) \
90         IX_ETH_ACC_STATS_INC(ixEthAccPortData[port].ixEthAccRxData.stats.field)
91
92 /* always increment the counter (mainly used for unexpected errors) */
93 #define TX_INC(port,field) \
94         ixEthAccPortData[port].ixEthAccTxData.stats.field++
95 #define RX_INC(port,field) \
96         ixEthAccPortData[port].ixEthAccRxData.stats.field++
97
98 PRIVATE IxEthAccDataPlaneStats     ixEthAccDataStats;
99
100 extern IxEthAccPortDataInfo   ixEthAccPortData[];
101 extern IxEthAccInfo   ixEthAccDataInfo;
102
103 PRIVATE IxOsalFastMutex txWriteMutex[IX_ETH_ACC_NUMBER_OF_PORTS];
104 PRIVATE IxOsalFastMutex rxWriteMutex[IX_ETH_ACC_NUMBER_OF_PORTS];
105
106 /**
107  *
108  * @brief Mbuf header conversion macros : they implement the
109  *  different conversions using a temporary value. They also double-check
110  *  that the parameters can be converted to/from NPE format.
111  *
112  */
113 #if defined(__wince) && !defined(IN_KERNEL)
114 #define PTR_VIRT2NPE(ptrSrc,dst) \
115   do { UINT32 temp; \
116       IX_OSAL_ENSURE(sizeof(ptrSrc) == sizeof(UINT32), "Wrong parameter type"); \
117       IX_OSAL_ENSURE(sizeof(dst) == sizeof(UINT32), "Wrong parameter type"); \
118       temp = (UINT32)IX_OSAL_MBUF_MBUF_VIRTUAL_TO_PHYSICAL_TRANSLATION((IX_OSAL_MBUF*)ptrSrc); \
119       (dst) = IX_OSAL_SWAP_BE_SHARED_LONG(temp); } \
120   while(0)
121
122 #define PTR_NPE2VIRT(type,src,ptrDst) \
123   do { void *temp; \
124       IX_OSAL_ENSURE(sizeof(type) == sizeof(UINT32), "Wrong parameter type"); \
125       IX_OSAL_ENSURE(sizeof(src) == sizeof(UINT32), "Wrong parameter type"); \
126       IX_OSAL_ENSURE(sizeof(ptrDst) == sizeof(UINT32), "Wrong parameter type"); \
127       temp = (void *)IX_OSAL_SWAP_BE_SHARED_LONG(src); \
128       (ptrDst) = (type)IX_OSAL_MBUF_MBUF_PHYSICAL_TO_VIRTUAL_TRANSLATION(temp); } \
129   while(0)
130 #else
131 #define PTR_VIRT2NPE(ptrSrc,dst) \
132   do { UINT32 temp; \
133       IX_OSAL_ENSURE(sizeof(ptrSrc) == sizeof(UINT32), "Wrong parameter type"); \
134       IX_OSAL_ENSURE(sizeof(dst) == sizeof(UINT32), "Wrong parameter type"); \
135       temp = (UINT32)IX_OSAL_MMU_VIRT_TO_PHYS(ptrSrc); \
136       (dst) = IX_OSAL_SWAP_BE_SHARED_LONG(temp); } \
137   while(0)
138
139 #define PTR_NPE2VIRT(type,src,ptrDst) \
140   do { void *temp; \
141       IX_OSAL_ENSURE(sizeof(type) == sizeof(UINT32), "Wrong parameter type"); \
142       IX_OSAL_ENSURE(sizeof(src) == sizeof(UINT32), "Wrong parameter type"); \
143       IX_OSAL_ENSURE(sizeof(ptrDst) == sizeof(UINT32), "Wrong parameter type"); \
144       temp = (void *)IX_OSAL_SWAP_BE_SHARED_LONG(src); \
145       (ptrDst) = (type)IX_OSAL_MMU_PHYS_TO_VIRT(temp); } \
146   while(0)
147 #endif
148
149 /**
150  *
151  * @brief Mbuf payload pointer conversion macros : Wince has its own
152  *  method to convert the buffer pointers
153  */
154 #if defined(__wince) && !defined(IN_KERNEL)
155 #define DATAPTR_VIRT2NPE(ptrSrc,dst) \
156   do { UINT32 temp; \
157       temp = (UINT32)IX_OSAL_MBUF_DATA_VIRTUAL_TO_PHYSICAL_TRANSLATION(ptrSrc); \
158       (dst) = IX_OSAL_SWAP_BE_SHARED_LONG(temp); } \
159   while(0)
160
161 #else
162 #define DATAPTR_VIRT2NPE(ptrSrc,dst) PTR_VIRT2NPE(IX_OSAL_MBUF_MDATA(ptrSrc),dst)
163 #endif
164
165
166 /* Flush the shared part of the mbuf header */
167 #define IX_ETHACC_NE_CACHE_FLUSH(mbufPtr) \
168   do { \
169       IX_OSAL_CACHE_FLUSH(IX_ETHACC_NE_SHARED(mbufPtr), \
170                               sizeof(IxEthAccNe)); \
171     } \
172   while(0)
173
174 /* Invalidate the shared part of the mbuf header */
175 #define IX_ETHACC_NE_CACHE_INVALIDATE(mbufPtr) \
176   do { \
177       IX_OSAL_CACHE_INVALIDATE(IX_ETHACC_NE_SHARED(mbufPtr), \
178                                    sizeof(IxEthAccNe)); \
179     } \
180   while(0)
181
182 /* Preload one cache line (shared mbuf headers are aligned
183  * and their size is 1 cache line)
184  *
185  * IX_OSAL_CACHED  is defined when the mbuf headers are
186  * allocated from cached memory.
187  *
188  * Other processor on emulation environment may not implement
189  * preload function
190  */
191 #ifdef IX_OSAL_CACHED
192         #if (CPU!=SIMSPARCSOLARIS) && !defined (__wince)
193                 #define IX_ACC_DATA_CACHE_PRELOAD(ptr) \
194                 do { /* preload a cache line (Xscale Processor) */ \
195                         __asm__ (" pld [%0]\n": : "r" (ptr)); \
196                 } \
197                 while(0)
198         #else
199                 /* preload not implemented on different processor */
200                 #define IX_ACC_DATA_CACHE_PRELOAD(mbufPtr) \
201                 do { /* nothing */ } while (0)
202         #endif
203 #else
204         /* preload not needed if cache is not enabled */
205         #define IX_ACC_DATA_CACHE_PRELOAD(mbufPtr) \
206         do { /* nothing */ } while (0)
207 #endif
208
209 /**
210  *
211  * @brief function to retrieve the correct pointer from
212  * a queue entry posted by the NPE
213  *
214  * @param qEntry : entry from qmgr queue
215  *        mask : applicable mask for this queue
216  *        (4 most significant bits are used for additional informations)
217  *
218  * @return IX_OSAL_MBUF * pointer to mbuf header
219  *
220  * @internal
221  */
222 PRIVATE IX_OSAL_MBUF *
223 ixEthAccEntryFromQConvert(UINT32 qEntry, UINT32 mask)
224 {
225     IX_OSAL_MBUF *mbufPtr;
226
227     if (qEntry != 0)
228     {
229         /* mask NPE bits (e.g. priority, port ...) */
230         qEntry &= mask;
231
232 #if IX_ACC_DRAM_PHYS_OFFSET != 0
233         /* restore the original address pointer (if PHYS_OFFSET is not 0) */
234         qEntry |= (IX_ACC_DRAM_PHYS_OFFSET & ~IX_ETHNPE_QM_Q_RXENET_ADDR_MASK);
235 #endif
236         /* get the mbuf pointer address from the npe-shared address */
237         qEntry -= offsetof(IX_OSAL_MBUF,ix_ne);
238
239         /* phys2virt mbuf */
240         mbufPtr = (IX_OSAL_MBUF *)IX_OSAL_MMU_PHYS_TO_VIRT(qEntry);
241
242         /* preload the cacheline shared with NPE */
243         IX_ACC_DATA_CACHE_PRELOAD(IX_ETHACC_NE_SHARED(mbufPtr));
244
245         /* preload the cacheline used by xscale */
246         IX_ACC_DATA_CACHE_PRELOAD(mbufPtr);
247     }
248     else
249     {
250         mbufPtr = NULL;
251     }
252
253     return mbufPtr;
254 }
255
256 /* Convert the mbuf header for NPE transmission */
257 PRIVATE UINT32
258 ixEthAccMbufTxQPrepare(IX_OSAL_MBUF *mbuf)
259 {
260     UINT32 qbuf;
261     UINT32 len;
262
263     /* endianess swap for tci and flags
264        note: this is done only once, even for chained buffers */
265     IX_ETHACC_NE_FLAGS(mbuf)   = IX_OSAL_SWAP_BE_SHARED_SHORT(IX_ETHACC_NE_FLAGS(mbuf));
266     IX_ETHACC_NE_VLANTCI(mbuf) = IX_OSAL_SWAP_BE_SHARED_SHORT(IX_ETHACC_NE_VLANTCI(mbuf));
267
268     /* test for unchained mbufs */
269     if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbuf) == NULL)
270     {
271         /* "best case" scenario : unchained mbufs */
272         IX_ETH_ACC_STATS_INC(ixEthAccDataStats.unchainedTxMBufs);
273
274         /* payload pointer conversion */
275         DATAPTR_VIRT2NPE(mbuf, IX_ETHACC_NE_DATA(mbuf));
276
277         /* unchained mbufs : the frame length is the mbuf length
278          * and the 2 identical lengths are stored in the same
279          * word.
280          */
281         len = IX_OSAL_MBUF_MLEN(mbuf);
282
283         /* set the length in both length and pktLen 16-bits fields */
284         len |= (len << IX_ETHNPE_ACC_LENGTH_OFFSET);
285         IX_ETHACC_NE_LEN(mbuf) = IX_OSAL_SWAP_BE_SHARED_LONG(len);
286
287         /* unchained mbufs : next contains 0 */
288         IX_ETHACC_NE_NEXT(mbuf) = 0;
289
290         /* flush shared header after all address conversions */
291         IX_ETHACC_NE_CACHE_FLUSH(mbuf);
292     }
293     else
294     {
295         /* chained mbufs */
296         IX_OSAL_MBUF *ptr = mbuf;
297         IX_OSAL_MBUF *nextPtr;
298         UINT32 frmLen;
299
300         /* get the frame length from the header of the first buffer */
301         frmLen = IX_OSAL_MBUF_PKT_LEN(mbuf);
302
303         do
304         {
305             IX_ETH_ACC_STATS_INC(ixEthAccDataStats.chainedTxMBufs);
306
307             /* payload pointer */
308             DATAPTR_VIRT2NPE(ptr,IX_ETHACC_NE_DATA(ptr));
309             /* Buffer length and frame length are stored in the same word */
310             len = IX_OSAL_MBUF_MLEN(ptr);
311             len = frmLen | (len << IX_ETHNPE_ACC_LENGTH_OFFSET);
312             IX_ETHACC_NE_LEN(ptr) = IX_OSAL_SWAP_BE_SHARED_LONG(len);
313
314             /* get the virtual next chain pointer */
315             nextPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(ptr);
316             if (nextPtr != NULL)
317             {
318                 /* shared pointer of the next buffer is chained */
319                 PTR_VIRT2NPE(IX_ETHACC_NE_SHARED(nextPtr),
320                              IX_ETHACC_NE_NEXT(ptr));
321             }
322             else
323             {
324                 IX_ETHACC_NE_NEXT(ptr) = 0;
325             }
326
327             /* flush shared header after all address conversions */
328             IX_ETHACC_NE_CACHE_FLUSH(ptr);
329
330             /* move to next buffer */
331             ptr = nextPtr;
332
333             /* the frame length field is set only in the first buffer
334              * and is zeroed in the next buffers
335              */
336             frmLen = 0;
337         }
338         while(ptr != NULL);
339
340     }
341
342     /* virt2phys mbuf itself */
343     qbuf = (UINT32)IX_OSAL_MMU_VIRT_TO_PHYS(
344                   IX_ETHACC_NE_SHARED(mbuf));
345
346     /* Ensure the bits which are reserved to exchange information with
347      * the NPE are cleared
348      *
349      * If the mbuf address is not correctly aligned, or from an
350      * incompatible memory range, there is no point to continue
351      */
352     IX_OSAL_ENSURE(((qbuf & ~IX_ETHNPE_QM_Q_TXENET_ADDR_MASK) == 0),
353               "Invalid address range");
354
355     return qbuf;
356 }
357
358 /* Convert the mbuf header for NPE reception */
359 PRIVATE UINT32
360 ixEthAccMbufRxQPrepare(IX_OSAL_MBUF *mbuf)
361 {
362     UINT32 len;
363     UINT32 qbuf;
364
365     if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbuf) == NULL)
366     {
367         /* "best case" scenario : unchained mbufs */
368         IX_ETH_ACC_STATS_INC(ixEthAccDataStats.unchainedRxFreeMBufs);
369
370         /* unchained mbufs : payload pointer */
371         DATAPTR_VIRT2NPE(mbuf, IX_ETHACC_NE_DATA(mbuf));
372
373         /* unchained mbufs : set the buffer length
374         * and the frame length field is zeroed
375         */
376         len = (IX_OSAL_MBUF_MLEN(mbuf) << IX_ETHNPE_ACC_LENGTH_OFFSET);
377         IX_ETHACC_NE_LEN(mbuf) = IX_OSAL_SWAP_BE_SHARED_LONG(len);
378
379         /* unchained mbufs : next pointer is null */
380         IX_ETHACC_NE_NEXT(mbuf) = 0;
381
382         /* flush shared header after all address conversions */
383         IX_ETHACC_NE_CACHE_FLUSH(mbuf);
384
385         /* remove shared header cache line */
386         IX_ETHACC_NE_CACHE_INVALIDATE(mbuf);
387     }
388     else
389     {
390         /* chained mbufs */
391         IX_OSAL_MBUF *ptr = mbuf;
392         IX_OSAL_MBUF *nextPtr;
393
394         do
395         {
396             /* chained mbufs */
397             IX_ETH_ACC_STATS_INC(ixEthAccDataStats.chainedRxFreeMBufs);
398
399             /* we must save virtual next chain pointer */
400             nextPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(ptr);
401
402             if (nextPtr != NULL)
403             {
404                 /* chaining pointer for NPE */
405                 PTR_VIRT2NPE(IX_ETHACC_NE_SHARED(nextPtr),
406                              IX_ETHACC_NE_NEXT(ptr));
407             }
408             else
409             {
410                 IX_ETHACC_NE_NEXT(ptr) = 0;
411             }
412
413             /* payload pointer */
414             DATAPTR_VIRT2NPE(ptr,IX_ETHACC_NE_DATA(ptr));
415
416             /* buffer length */
417             len = (IX_OSAL_MBUF_MLEN(ptr) << IX_ETHNPE_ACC_LENGTH_OFFSET);
418             IX_ETHACC_NE_LEN(ptr) = IX_OSAL_SWAP_BE_SHARED_LONG(len);
419
420             /* flush shared header after all address conversions */
421             IX_ETHACC_NE_CACHE_FLUSH(ptr);
422
423             /* remove shared header cache line */
424             IX_ETHACC_NE_CACHE_INVALIDATE(ptr);
425
426             /* next mbuf in the chain */
427             ptr = nextPtr;
428         }
429         while(ptr != NULL);
430     }
431
432     /* virt2phys mbuf itself */
433     qbuf = (UINT32)IX_OSAL_MMU_VIRT_TO_PHYS(
434                   IX_ETHACC_NE_SHARED(mbuf));
435
436     /* Ensure the bits which are reserved to exchange information with
437      * the NPE are cleared
438      *
439      * If the mbuf address is not correctly aligned, or from an
440      * incompatible memory range, there is no point to continue
441      */
442     IX_OSAL_ENSURE(((qbuf & ~IX_ETHNPE_QM_Q_RXENET_ADDR_MASK) == 0),
443               "Invalid address range");
444
445     return qbuf;
446 }
447
448 /* Convert the mbuf header after NPE transmission
449  * Since there is nothing changed by the NPE, there is no need
450  * to process anything but the update of internal stats
451  * when they are enabled
452 */
453 PRIVATE void
454 ixEthAccMbufFromTxQ(IX_OSAL_MBUF *mbuf)
455 {
456 #ifndef NDEBUG
457     /* test for unchained mbufs */
458     if (IX_ETHACC_NE_NEXT(mbuf) == 0)
459     {
460         /* unchained mbufs : update the stats */
461         IX_ETH_ACC_STATS_INC(ixEthAccDataStats.unchainedTxDoneMBufs);
462     }
463     else
464     {
465         /* chained mbufs : walk the chain and update the stats */
466         IX_OSAL_MBUF *ptr = mbuf;
467
468         do
469         {
470             IX_ETH_ACC_STATS_INC(ixEthAccDataStats.chainedTxDoneMBufs);
471             ptr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(ptr);
472         }
473         while (ptr != NULL);
474     }
475 #endif
476 }
477
478 /* Convert the mbuf header after NPE reception */
479 PRIVATE void
480 ixEthAccMbufFromRxQ(IX_OSAL_MBUF *mbuf)
481 {
482     UINT32 len;
483
484     /* endianess swap for tci and flags
485        note: this is done only once, even for chained buffers */
486     IX_ETHACC_NE_FLAGS(mbuf)   = IX_OSAL_SWAP_BE_SHARED_SHORT(IX_ETHACC_NE_FLAGS(mbuf));
487     IX_ETHACC_NE_VLANTCI(mbuf) = IX_OSAL_SWAP_BE_SHARED_SHORT(IX_ETHACC_NE_VLANTCI(mbuf));
488
489     /* test for unchained mbufs */
490     if (IX_ETHACC_NE_NEXT(mbuf) == 0)
491     {
492         /* unchained mbufs */
493         IX_ETH_ACC_STATS_INC(ixEthAccDataStats.unchainedRxMBufs);
494
495         /* get the frame length. it is the same than the buffer length */
496         len = IX_OSAL_SWAP_BE_SHARED_LONG(IX_ETHACC_NE_LEN(mbuf));
497         len &= IX_ETHNPE_ACC_PKTLENGTH_MASK;
498         IX_OSAL_MBUF_PKT_LEN(mbuf) = IX_OSAL_MBUF_MLEN(mbuf) = len;
499
500         /* clears the next packet field */
501         IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbuf) = NULL;
502     }
503     else
504     {
505         IX_OSAL_MBUF *ptr = mbuf;
506         IX_OSAL_MBUF *nextPtr;
507         UINT32 frmLen;
508
509         /* convert the frame length */
510         frmLen = IX_OSAL_SWAP_BE_SHARED_LONG(IX_ETHACC_NE_LEN(mbuf));
511         IX_OSAL_MBUF_PKT_LEN(mbuf) = (frmLen & IX_ETHNPE_ACC_PKTLENGTH_MASK);
512
513         /* chained mbufs */
514         do
515         {
516             IX_ETH_ACC_STATS_INC(ixEthAccDataStats.chainedRxMBufs);
517
518             /* convert the length */
519             len = IX_OSAL_SWAP_BE_SHARED_LONG(IX_ETHACC_NE_LEN(ptr));
520             IX_OSAL_MBUF_MLEN(ptr) = (len >> IX_ETHNPE_ACC_LENGTH_OFFSET);
521
522             /* get the next pointer */
523             PTR_NPE2VIRT(IX_OSAL_MBUF *,IX_ETHACC_NE_NEXT(ptr), nextPtr);
524             if (nextPtr != NULL)
525             {
526                 nextPtr = (IX_OSAL_MBUF *)((UINT8 *)nextPtr - offsetof(IX_OSAL_MBUF,ix_ne));
527             }
528             /* set the next pointer */
529             IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(ptr) = nextPtr;
530
531             /* move to the next buffer */
532             ptr = nextPtr;
533         }
534         while (ptr != NULL);
535     }
536 }
537
538 /* write to qmgr if possible and report an overflow if not possible
539  * Use a fast lock to protect the queue write.
540  * This way, the tx feature is reentrant.
541  */
542 PRIVATE IX_STATUS
543 ixEthAccQmgrLockTxWrite(IxEthAccPortId portId, UINT32 qBuffer)
544 {
545     IX_STATUS qStatus;
546     if (ixOsalFastMutexTryLock(&txWriteMutex[portId]) == IX_SUCCESS)
547     {
548         qStatus = ixQMgrQWrite(
549                IX_ETH_ACC_PORT_TO_TX_Q_ID(portId),
550                &qBuffer);
551 #ifndef NDEBUG
552         if (qStatus != IX_SUCCESS)
553         {
554             TX_STATS_INC(portId, txOverflow);
555         }
556 #endif
557         ixOsalFastMutexUnlock(&txWriteMutex[portId]);
558     }
559     else
560     {
561         TX_STATS_INC(portId, txLock);
562         qStatus = IX_QMGR_Q_OVERFLOW;
563     }
564     return qStatus;
565 }
566
567 /* write to qmgr if possible and report an overflow if not possible
568  * Use a fast lock to protect the queue write.
569  * This way, the Rx feature is reentrant.
570  */
571 PRIVATE IX_STATUS
572 ixEthAccQmgrLockRxWrite(IxEthAccPortId portId, UINT32 qBuffer)
573 {
574     IX_STATUS qStatus;
575     if (ixOsalFastMutexTryLock(&rxWriteMutex[portId]) == IX_SUCCESS)
576     {
577         qStatus = ixQMgrQWrite(
578                IX_ETH_ACC_PORT_TO_RX_FREE_Q_ID(portId),
579                &qBuffer);
580 #ifndef NDEBUG
581         if (qStatus != IX_SUCCESS)
582         {
583             RX_STATS_INC(portId, rxFreeOverflow);
584         }
585 #endif
586         ixOsalFastMutexUnlock(&rxWriteMutex[portId]);
587     }
588     else
589     {
590         RX_STATS_INC(portId, rxFreeLock);
591         qStatus = IX_QMGR_Q_OVERFLOW;
592     }
593     return qStatus;
594 }
595
596 /*
597  * Set the priority and write to a qmgr queue.
598  */
599 PRIVATE IX_STATUS
600 ixEthAccQmgrTxWrite(IxEthAccPortId portId, UINT32 qBuffer, UINT32 priority)
601 {
602     /* fill the priority field */
603     qBuffer |= (priority << IX_ETHNPE_QM_Q_FIELD_PRIOR_R);
604
605     return ixEthAccQmgrLockTxWrite(portId, qBuffer);
606 }
607
608 /**
609  *
610  * @brief This function will discover the highest priority S/W Tx Q that
611  *        has entries in it
612  *
613  * @param portId - (in) the id of the port whose S/W Tx queues are to be searched
614  *        priorityPtr - (out) the priority of the highest priority occupied q will be written
615  *                      here
616  *
617  * @return IX_ETH_ACC_SUCCESS if an occupied Q is found
618  *         IX_ETH_ACC_FAIL if no Q has entries
619  *
620  * @internal
621  */
622 PRIVATE IxEthAccStatus
623 ixEthAccTxSwQHighestPriorityGet(IxEthAccPortId portId,
624                                 IxEthAccTxPriority *priorityPtr)
625 {
626     if (ixEthAccPortData[portId].ixEthAccTxData.schDiscipline
627         == FIFO_NO_PRIORITY)
628     {
629         if(IX_ETH_ACC_DATAPLANE_IS_Q_EMPTY(ixEthAccPortData[portId].
630                ixEthAccTxData.txQ[IX_ETH_ACC_TX_DEFAULT_PRIORITY]))
631         {
632             return IX_ETH_ACC_FAIL;
633         }
634         else
635         {
636             *priorityPtr = IX_ETH_ACC_TX_DEFAULT_PRIORITY;
637             TX_STATS_INC(portId,txPriority[*priorityPtr]);
638             return IX_ETH_ACC_SUCCESS;
639         }
640     }
641     else
642     {
643         IxEthAccTxPriority highestPriority = IX_ETH_ACC_TX_PRIORITY_7;
644         while(1)
645         {
646             if(!IX_ETH_ACC_DATAPLANE_IS_Q_EMPTY(ixEthAccPortData[portId].
647                ixEthAccTxData.txQ[highestPriority]))
648             {
649
650                 *priorityPtr = highestPriority;
651                 TX_STATS_INC(portId,txPriority[highestPriority]);
652                 return IX_ETH_ACC_SUCCESS;
653
654             }
655             if (highestPriority == IX_ETH_ACC_TX_PRIORITY_0)
656             {
657                 return IX_ETH_ACC_FAIL;
658             }
659             highestPriority--;
660         }
661     }
662 }
663
664 /**
665  *
666  * @brief This function will take a buffer from a TX S/W Q and attempt
667  *        to add it to the relevant TX H/W Q
668  *
669  * @param portId - the port whose TX queue is to be written to
670  *        priority - identifies the queue from which the entry is to be read
671  *
672  * @internal
673  */
674 PRIVATE IxEthAccStatus
675 ixEthAccTxFromSwQ(IxEthAccPortId portId,
676                   IxEthAccTxPriority priority)
677 {
678     IX_OSAL_MBUF        *mbuf;
679     IX_STATUS      qStatus;
680
681     IX_OSAL_ENSURE((UINT32)priority <= (UINT32)7, "Invalid priority");
682
683     IX_ETH_ACC_DATAPLANE_REMOVE_MBUF_FROM_Q_HEAD(
684         ixEthAccPortData[portId].ixEthAccTxData.txQ[priority],
685         mbuf);
686
687     if (mbuf != NULL)
688     {
689         /*
690          * Add the Tx buffer to the H/W Tx Q
691          * We do not need to flush here as it is already done
692          * in TxFrameSubmit().
693          */
694         qStatus = ixEthAccQmgrTxWrite(
695               portId,
696               IX_OSAL_MMU_VIRT_TO_PHYS((UINT32)IX_ETHACC_NE_SHARED(mbuf)),
697               priority);
698
699         if (qStatus == IX_SUCCESS)
700         {
701             TX_STATS_INC(portId,txFromSwQOK);
702             return IX_SUCCESS;
703         }
704         else if (qStatus == IX_QMGR_Q_OVERFLOW)
705         {
706             /*
707              * H/W Q overflow, need to save the buffer
708              * back on the s/w Q.
709              * we must put it back on the head of the q to avoid
710              * reordering packet tx
711              */
712             TX_STATS_INC(portId,txFromSwQDelayed);
713             IX_ETH_ACC_DATAPLANE_ADD_MBUF_TO_Q_HEAD(
714                 ixEthAccPortData[portId].ixEthAccTxData.txQ[priority],
715                 mbuf);
716
717             /*enable Q notification*/
718             qStatus = ixQMgrNotificationEnable(
719                 IX_ETH_ACC_PORT_TO_TX_Q_ID(portId),
720                 IX_ETH_ACC_PORT_TO_TX_Q_SOURCE(portId));
721
722             if (qStatus != IX_SUCCESS && qStatus != IX_QMGR_WARNING)
723             {
724                 TX_INC(portId,txUnexpectedError);
725                 IX_ETH_ACC_FATAL_LOG(
726                     "ixEthAccTxFromSwQ:Unexpected Error: %u\n",
727                     qStatus, 0, 0, 0, 0, 0);
728             }
729         }
730         else
731         {
732             TX_INC(portId,txUnexpectedError);
733
734             /* recovery attempt */
735             IX_ETH_ACC_DATAPLANE_ADD_MBUF_TO_Q_HEAD(
736                 ixEthAccPortData[portId].ixEthAccTxData.txQ[priority],
737                 mbuf);
738
739             IX_ETH_ACC_FATAL_LOG(
740                 "ixEthAccTxFromSwQ:Error: unexpected QM status 0x%08X\n",
741                 qStatus, 0, 0, 0, 0, 0);
742         }
743     }
744     else
745     {
746         /* sw queue is empty */
747     }
748     return IX_ETH_ACC_FAIL;
749 }
750
751 /**
752  *
753  * @brief This function will take a buffer from a RXfree S/W Q and attempt
754  *        to add it to the relevant RxFree H/W Q
755  *
756  * @param portId - the port whose RXFree queue is to be written to
757  *
758  * @internal
759  */
760 PRIVATE IxEthAccStatus
761 ixEthAccRxFreeFromSwQ(IxEthAccPortId portId)
762 {
763     IX_OSAL_MBUF        *mbuf;
764     IX_STATUS      qStatus = IX_SUCCESS;
765
766     IX_ETH_ACC_DATAPLANE_REMOVE_MBUF_FROM_Q_HEAD(
767           ixEthAccPortData[portId].ixEthAccRxData.freeBufferList,
768           mbuf);
769     if (mbuf != NULL)
770     {
771         /*
772          * Add The Rx Buffer to the H/W Free buffer Q if possible
773          */
774         qStatus = ixEthAccQmgrLockRxWrite(portId,
775                   IX_OSAL_MMU_VIRT_TO_PHYS(
776                          (UINT32)IX_ETHACC_NE_SHARED(mbuf)));
777
778         if (qStatus == IX_SUCCESS)
779         {
780             RX_STATS_INC(portId,rxFreeRepFromSwQOK);
781             /*
782              * Buffer added to h/w Q.
783              */
784             return IX_SUCCESS;
785         }
786         else if (qStatus == IX_QMGR_Q_OVERFLOW)
787         {
788             /*
789              * H/W Q overflow, need to save the buffer back on the s/w Q.
790              */
791             RX_STATS_INC(portId,rxFreeRepFromSwQDelayed);
792
793             IX_ETH_ACC_DATAPLANE_ADD_MBUF_TO_Q_HEAD(
794                    ixEthAccPortData[portId].ixEthAccRxData.freeBufferList,
795                    mbuf);
796         }
797         else
798         {
799             /* unexpected qmgr error */
800             RX_INC(portId,rxUnexpectedError);
801
802             IX_ETH_ACC_DATAPLANE_ADD_MBUF_TO_Q_HEAD(
803                     ixEthAccPortData[portId].ixEthAccRxData.freeBufferList,
804                     mbuf);
805
806             IX_ETH_ACC_FATAL_LOG("IxEthAccRxFreeFromSwQ:Error: unexpected QM status 0x%08X\n",
807                                  qStatus, 0, 0, 0, 0, 0);
808         }
809     }
810     else
811     {
812         /* sw queue is empty */
813     }
814     return IX_ETH_ACC_FAIL;
815 }
816
817
818 IX_ETH_ACC_PUBLIC
819 IxEthAccStatus ixEthAccInitDataPlane()
820 {
821     UINT32 portId;
822
823     /*
824      * Initialize the service and register callback to other services.
825      */
826
827     IX_ETH_ACC_MEMSET(&ixEthAccDataStats,
828                       0,
829                       sizeof(ixEthAccDataStats));
830
831     for(portId=0; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
832     {
833         ixOsalFastMutexInit(&txWriteMutex[portId]);
834         ixOsalFastMutexInit(&rxWriteMutex[portId]);
835
836         IX_ETH_ACC_MEMSET(&ixEthAccPortData[portId],
837                           0,
838                           sizeof(ixEthAccPortData[portId]));
839
840         ixEthAccPortData[portId].ixEthAccTxData.schDiscipline = FIFO_NO_PRIORITY;
841     }
842
843     return (IX_ETH_ACC_SUCCESS);
844 }
845
846
847 IX_ETH_ACC_PUBLIC
848 IxEthAccStatus ixEthAccPortTxDoneCallbackRegister(IxEthAccPortId portId,
849                                                   IxEthAccPortTxDoneCallback
850                                                   txCallbackFn,
851                                                   UINT32 callbackTag)
852 {
853     if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
854     {
855         return (IX_ETH_ACC_FAIL);
856     }
857     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
858     {
859         return (IX_ETH_ACC_INVALID_PORT);
860     }
861
862 /* HACK: removing this code to enable NPE-A preliminary testing
863  *    if (IX_ETH_ACC_SUCCESS != ixEthAccSingleEthNpeCheck(portId))
864  *    {
865  *        IX_ETH_ACC_WARNING_LOG("ixEthAccPortTxDoneCallbackRegister: Unavailable Eth %d: Cannot register TxDone Callback.\n",(INT32)portId,0,0,0,0,0);
866  *        return IX_ETH_ACC_SUCCESS ;
867  *    }
868  */
869
870     if (!IX_ETH_IS_PORT_INITIALIZED(portId))
871     {
872         return (IX_ETH_ACC_PORT_UNINITIALIZED);
873     }
874     if (txCallbackFn == 0)
875         /* Check for null function pointer here. */
876     {
877         return (IX_ETH_ACC_INVALID_ARG);
878     }
879     ixEthAccPortData[portId].ixEthAccTxData.txBufferDoneCallbackFn = txCallbackFn;
880     ixEthAccPortData[portId].ixEthAccTxData.txCallbackTag = callbackTag;
881     return (IX_ETH_ACC_SUCCESS);
882 }
883
884
885 IX_ETH_ACC_PUBLIC
886 IxEthAccStatus ixEthAccPortRxCallbackRegister(IxEthAccPortId portId,
887                                               IxEthAccPortRxCallback
888                                               rxCallbackFn,
889                                               UINT32 callbackTag)
890 {
891     IxEthAccPortId port;
892
893     if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
894     {
895         return (IX_ETH_ACC_FAIL);
896     }
897     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
898     {
899         return (IX_ETH_ACC_INVALID_PORT);
900     }
901
902     if (IX_ETH_ACC_SUCCESS != ixEthAccSingleEthNpeCheck(portId))
903     {
904         IX_ETH_ACC_WARNING_LOG("ixEthAccPortRxCallbackRegister: Unavailable Eth %d: Cannot register Rx Callback.\n",(INT32)portId,0,0,0,0,0);
905         return IX_ETH_ACC_SUCCESS ;
906     }
907
908     if (!IX_ETH_IS_PORT_INITIALIZED(portId))
909     {
910         return (IX_ETH_ACC_PORT_UNINITIALIZED);
911     }
912
913     /* Check for null function pointer here. */
914     if (rxCallbackFn == NULL)
915     {
916         return (IX_ETH_ACC_INVALID_ARG);
917     }
918
919     /* Check the user is not changing the callback type
920      * when the port is enabled.
921     */
922     if (ixEthAccMacState[portId].portDisableState == ACTIVE)
923     {
924         for (port = 0; port < IX_ETH_ACC_NUMBER_OF_PORTS; port++)
925         {
926             if ((ixEthAccMacState[port].portDisableState == ACTIVE)
927                 && (ixEthAccPortData[port].ixEthAccRxData.rxMultiBufferCallbackInUse == true))
928             {
929                 /* one of the active ports has a different rx callback type.
930                  * Changing the callback type when the port is enabled
931                  * is not safe
932                  */
933                 return (IX_ETH_ACC_INVALID_ARG);
934             }
935         }
936     }
937
938     /* update the callback pointer : this is done before
939      * registering the new qmgr callback
940      */
941     ixEthAccPortData[portId].ixEthAccRxData.rxCallbackFn = rxCallbackFn;
942     ixEthAccPortData[portId].ixEthAccRxData.rxCallbackTag = callbackTag;
943
944     /* update the qmgr callback for rx queues */
945     if (ixEthAccQMgrRxCallbacksRegister(ixEthRxFrameQMCallback)
946         != IX_ETH_ACC_SUCCESS)
947     {
948         /* unexpected qmgr error */
949         IX_ETH_ACC_FATAL_LOG("ixEthAccPortRxCallbackRegister: unexpected QMgr error, " \
950             "could not register Rx single-buffer callback\n", 0, 0, 0, 0, 0, 0);
951
952         RX_INC(portId,rxUnexpectedError);
953         return (IX_ETH_ACC_INVALID_ARG);
954     }
955
956     ixEthAccPortData[portId].ixEthAccRxData.rxMultiBufferCallbackInUse = false;
957
958     return (IX_ETH_ACC_SUCCESS);
959 }
960
961 IX_ETH_ACC_PUBLIC
962 IxEthAccStatus ixEthAccPortMultiBufferRxCallbackRegister(
963                          IxEthAccPortId portId,
964                          IxEthAccPortMultiBufferRxCallback
965                          rxCallbackFn,
966                          UINT32 callbackTag)
967 {
968     IxEthAccPortId port;
969
970     if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
971     {
972         return (IX_ETH_ACC_FAIL);
973     }
974     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
975     {
976         return (IX_ETH_ACC_INVALID_PORT);
977     }
978
979     if (IX_ETH_ACC_SUCCESS != ixEthAccSingleEthNpeCheck(portId))
980     {
981         IX_ETH_ACC_WARNING_LOG("ixEthAccPortMultiBufferRxCallbackRegister: Unavailable Eth %d: Cannot register Rx Callback.\n",(INT32)portId,0,0,0,0,0);
982         return IX_ETH_ACC_SUCCESS ;
983     }
984
985     if (!IX_ETH_IS_PORT_INITIALIZED(portId))
986     {
987         return (IX_ETH_ACC_PORT_UNINITIALIZED);
988     }
989
990     /* Check for null function pointer here. */
991     if (rxCallbackFn == NULL)
992     {
993         return (IX_ETH_ACC_INVALID_ARG);
994     }
995
996     /* Check the user is not changing the callback type
997      * when the port is enabled.
998     */
999     if (ixEthAccMacState[portId].portDisableState == ACTIVE)
1000     {
1001         for (port = 0; port < IX_ETH_ACC_NUMBER_OF_PORTS; port++)
1002         {
1003             if ((ixEthAccMacState[port].portDisableState == ACTIVE)
1004                 && (ixEthAccPortData[port].ixEthAccRxData.rxMultiBufferCallbackInUse == false))
1005             {
1006                 /* one of the active ports has a different rx callback type.
1007                  * Changing the callback type when the port is enabled
1008                  * is not safe
1009                  */
1010                 return (IX_ETH_ACC_INVALID_ARG);
1011             }
1012         }
1013     }
1014
1015     /* update the callback pointer : this is done before
1016      * registering the new qmgr callback
1017      */
1018     ixEthAccPortData[portId].ixEthAccRxData.rxMultiBufferCallbackFn = rxCallbackFn;
1019     ixEthAccPortData[portId].ixEthAccRxData.rxMultiBufferCallbackTag = callbackTag;
1020
1021     /* update the qmgr callback for rx queues */
1022     if (ixEthAccQMgrRxCallbacksRegister(ixEthRxMultiBufferQMCallback)
1023         != IX_ETH_ACC_SUCCESS)
1024     {
1025         /* unexpected qmgr error */
1026         RX_INC(portId,rxUnexpectedError);
1027
1028         IX_ETH_ACC_FATAL_LOG("ixEthAccPortMultiBufferRxCallbackRegister: unexpected QMgr error, " \
1029             "could not register Rx multi-buffer callback\n", 0, 0, 0, 0, 0, 0);
1030
1031         return (IX_ETH_ACC_INVALID_ARG);
1032     }
1033
1034     ixEthAccPortData[portId].ixEthAccRxData.rxMultiBufferCallbackInUse = true;
1035
1036     return (IX_ETH_ACC_SUCCESS);
1037 }
1038
1039 IX_ETH_ACC_PUBLIC
1040 IxEthAccStatus ixEthAccPortTxFrameSubmit(IxEthAccPortId portId,
1041                                          IX_OSAL_MBUF *buffer,
1042                                          IxEthAccTxPriority priority)
1043 {
1044     IX_STATUS   qStatus = IX_SUCCESS;
1045     UINT32      qBuffer;
1046     IxEthAccTxPriority highestPriority;
1047     IxQMgrQStatus txQStatus;
1048
1049 #ifndef NDEBUG
1050     if (buffer == NULL)
1051     {
1052         return (IX_ETH_ACC_FAIL);
1053     }
1054     if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
1055     {
1056         return (IX_ETH_ACC_FAIL);
1057     }
1058     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
1059     {
1060         return (IX_ETH_ACC_INVALID_PORT);
1061     }
1062
1063     if (IX_ETH_ACC_SUCCESS != ixEthAccSingleEthNpeCheck(portId))
1064     {
1065         IX_ETH_ACC_FATAL_LOG("ixEthAccPortTxFrameSubmit: Unavailable Eth %d: Cannot submit Tx Frame.\n",
1066                              (INT32)portId,0,0,0,0,0);
1067         return IX_ETH_ACC_PORT_UNINITIALIZED ;
1068     }
1069
1070     if (!IX_ETH_IS_PORT_INITIALIZED(portId))
1071     {
1072         return (IX_ETH_ACC_PORT_UNINITIALIZED);
1073     }
1074     if ((UINT32)priority > (UINT32)IX_ETH_ACC_TX_PRIORITY_7)
1075     {
1076         return (IX_ETH_ACC_INVALID_ARG);
1077     }
1078 #endif
1079
1080     /*
1081      * Need to Flush the MBUF and its contents (data) as it may be
1082      * read from the NPE. Convert virtual addresses to physical addresses also.
1083      */
1084     qBuffer = ixEthAccMbufTxQPrepare(buffer);
1085
1086     /*
1087      * If no fifo priority set on Xscale ...
1088      */
1089     if (ixEthAccPortData[portId].ixEthAccTxData.schDiscipline ==
1090         FIFO_NO_PRIORITY)
1091     {
1092         /*
1093          * Add The Tx Buffer to the H/W Tx Q if possible
1094          * (the priority is passed to the NPE, because
1095          * the NPE is able to reorder the frames
1096          * before transmission to the underlying hardware)
1097          */
1098         qStatus = ixEthAccQmgrTxWrite(portId,
1099                                       qBuffer,
1100                                       IX_ETH_ACC_TX_DEFAULT_PRIORITY);
1101
1102         if (qStatus == IX_SUCCESS)
1103         {
1104             TX_STATS_INC(portId,txQOK);
1105
1106             /*
1107              * "best case" scenario : Buffer added to h/w Q.
1108              */
1109             return (IX_SUCCESS);
1110         }
1111         else if (qStatus == IX_QMGR_Q_OVERFLOW)
1112         {
1113             /*
1114              * We were unable to write the buffer to the
1115              * appropriate H/W Q,  Save it in the sw Q.
1116              * (use the default priority queue regardless of
1117              * input parameter)
1118              */
1119             priority = IX_ETH_ACC_TX_DEFAULT_PRIORITY;
1120         }
1121         else
1122         {
1123             /* unexpected qmgr error */
1124             TX_INC(portId,txUnexpectedError);
1125             IX_ETH_ACC_FATAL_LOG(
1126                 "ixEthAccPortTxFrameSubmit:Error: qStatus = %u\n",
1127                 (UINT32)qStatus, 0, 0, 0, 0, 0);
1128             return (IX_ETH_ACC_FAIL);
1129         }
1130     }
1131     else if (ixEthAccPortData[portId].ixEthAccTxData.schDiscipline ==
1132              FIFO_PRIORITY)
1133     {
1134
1135         /*
1136          * For priority transmission, put the frame directly on the H/W queue
1137          * if the H/W queue is empty, otherwise, put it in a S/W Q
1138          */
1139         ixQMgrQStatusGet(IX_ETH_ACC_PORT_TO_TX_Q_ID(portId), &txQStatus);
1140         if((txQStatus & IX_QMGR_Q_STATUS_E_BIT_MASK) != 0)
1141         {
1142             /*The tx queue is empty, check whether there are buffers on the s/w queues*/
1143             if(ixEthAccTxSwQHighestPriorityGet(portId,  &highestPriority)
1144                !=IX_ETH_ACC_FAIL)
1145             {
1146                 /*there are buffers on the s/w queues, submit them*/
1147                 ixEthAccTxFromSwQ(portId, highestPriority);
1148
1149                 /* the queue was empty, 1 buffer is already supplied
1150                  * but is likely to be immediately transmitted and the
1151                  * hw queue is likely to be empty again, so submit
1152                  * more from the sw queues
1153                  */
1154                 if(ixEthAccTxSwQHighestPriorityGet(portId,  &highestPriority)
1155                    !=IX_ETH_ACC_FAIL)
1156                 {
1157                     ixEthAccTxFromSwQ(portId, highestPriority);
1158                     /*
1159                      * and force the buffer supplied to be placed
1160                      * on a priority queue
1161                      */
1162                     qStatus = IX_QMGR_Q_OVERFLOW;
1163                 }
1164                 else
1165                 {
1166                     /*there are no buffers in the s/w queues, submit directly*/
1167                     qStatus = ixEthAccQmgrTxWrite(portId, qBuffer, priority);
1168                 }
1169             }
1170             else
1171             {
1172                 /*there are no buffers in the s/w queues, submit directly*/
1173                 qStatus = ixEthAccQmgrTxWrite(portId, qBuffer, priority);
1174             }
1175         }
1176         else
1177         {
1178             qStatus = IX_QMGR_Q_OVERFLOW;
1179         }
1180     }
1181     else
1182     {
1183         TX_INC(portId,txUnexpectedError);
1184         IX_ETH_ACC_FATAL_LOG(
1185             "ixEthAccPortTxFrameSubmit:Error: wrong schedule discipline setup\n",
1186             0, 0, 0, 0, 0, 0);
1187         return (IX_ETH_ACC_FAIL);
1188     }
1189
1190     if(qStatus == IX_SUCCESS )
1191     {
1192         TX_STATS_INC(portId,txQOK);
1193         return IX_ETH_ACC_SUCCESS;
1194     }
1195     else if(qStatus == IX_QMGR_Q_OVERFLOW)
1196     {
1197         TX_STATS_INC(portId,txQDelayed);
1198         /*
1199          * We were unable to write the buffer to the
1200          * appropriate H/W Q,  Save it in a s/w Q.
1201          */
1202         IX_ETH_ACC_DATAPLANE_ADD_MBUF_TO_Q_TAIL(
1203                 ixEthAccPortData[portId].
1204                 ixEthAccTxData.txQ[priority],
1205                 buffer);
1206
1207         qStatus = ixQMgrNotificationEnable(
1208                 IX_ETH_ACC_PORT_TO_TX_Q_ID(portId),
1209                 IX_ETH_ACC_PORT_TO_TX_Q_SOURCE(portId));
1210
1211         if (qStatus != IX_SUCCESS)
1212         {
1213             if (qStatus == IX_QMGR_WARNING)
1214             {
1215                 /* notification is enabled for a queue
1216                  * which is already empty (the condition is already met)
1217                  * and there will be no more queue event to drain the sw queue
1218                  */
1219                 TX_STATS_INC(portId,txLateNotificationEnabled);
1220
1221                 /* pull a buffer from the sw queue */
1222                 if(ixEthAccTxSwQHighestPriorityGet(portId,  &highestPriority)
1223                    !=IX_ETH_ACC_FAIL)
1224                 {
1225                     /*there are buffers on the s/w queues, submit from them*/
1226                     ixEthAccTxFromSwQ(portId, highestPriority);
1227                 }
1228             }
1229             else
1230             {
1231                 TX_INC(portId,txUnexpectedError);
1232                 IX_ETH_ACC_FATAL_LOG(
1233                      "ixEthAccPortTxFrameSubmit: unexpected Error: %u\n",
1234                      qStatus, 0, 0, 0, 0, 0);
1235             }
1236         }
1237     }
1238     else
1239     {
1240         TX_INC(portId,txUnexpectedError);
1241         IX_ETH_ACC_FATAL_LOG(
1242              "ixEthAccPortTxFrameSubmit: unexpected Error: %u\n",
1243              qStatus, 0, 0, 0, 0, 0);
1244         return (IX_ETH_ACC_FAIL);
1245     }
1246
1247     return (IX_ETH_ACC_SUCCESS);
1248 }
1249
1250
1251 /**
1252  *
1253  * @brief replenish: convert a chain of mbufs to the format
1254  *        expected by the NPE
1255  *
1256   */
1257
1258 IX_ETH_ACC_PUBLIC
1259 IxEthAccStatus ixEthAccPortRxFreeReplenish(IxEthAccPortId portId,
1260                                            IX_OSAL_MBUF *buffer)
1261 {
1262     IX_STATUS   qStatus = IX_SUCCESS;
1263     UINT32      qBuffer;
1264
1265     /*
1266      * Check buffer is valid.
1267      */
1268
1269 #ifndef NDEBUG
1270     /* check parameter value */
1271     if (buffer == 0)
1272     {
1273         return (IX_ETH_ACC_FAIL);
1274     }
1275     if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
1276     {
1277         return (IX_ETH_ACC_FAIL);
1278     }
1279     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
1280     {
1281         return (IX_ETH_ACC_INVALID_PORT);
1282     }
1283
1284     /* check initialisation is done */
1285     if (IX_ETH_ACC_SUCCESS != ixEthAccSingleEthNpeCheck(portId))
1286     {
1287         IX_ETH_ACC_FATAL_LOG(" ixEthAccPortRxFreeReplenish: Unavailable Eth %d: Cannot replenish Rx Free Q.\n",(INT32)portId,0,0,0,0,0);
1288         return IX_ETH_ACC_PORT_UNINITIALIZED ;
1289     }
1290
1291     if (!IX_ETH_IS_PORT_INITIALIZED(portId))
1292     {
1293         return (IX_ETH_ACC_PORT_UNINITIALIZED);
1294     }
1295     /* check boundaries and constraints */
1296     if (IX_OSAL_MBUF_MLEN(buffer) < IX_ETHNPE_ACC_RXFREE_BUFFER_LENGTH_MIN)
1297     {
1298         return (IX_ETH_ACC_FAIL);
1299     }
1300 #endif
1301
1302     qBuffer = ixEthAccMbufRxQPrepare(buffer);
1303
1304     /*
1305      * Add The Rx Buffer to the H/W Free buffer Q if possible
1306      */
1307     qStatus = ixEthAccQmgrLockRxWrite(portId, qBuffer);
1308
1309     if (qStatus == IX_SUCCESS)
1310     {
1311         RX_STATS_INC(portId,rxFreeRepOK);
1312         /*
1313          * Buffer added to h/w Q.
1314          */
1315         return (IX_SUCCESS);
1316     }
1317     else if (qStatus == IX_QMGR_Q_OVERFLOW)
1318     {
1319         RX_STATS_INC(portId,rxFreeRepDelayed);
1320         /*
1321          * We were unable to write the buffer to the approprate H/W Q,
1322          * Save it in a s/w Q.
1323          */
1324         IX_ETH_ACC_DATAPLANE_ADD_MBUF_TO_Q_TAIL(
1325             ixEthAccPortData[portId].ixEthAccRxData.freeBufferList,
1326             buffer);
1327
1328         qStatus = ixQMgrNotificationEnable(
1329             IX_ETH_ACC_PORT_TO_RX_FREE_Q_ID(portId),
1330             IX_ETH_ACC_PORT_TO_RX_FREE_Q_SOURCE(portId));
1331
1332         if (qStatus != IX_SUCCESS)
1333         {
1334             if (qStatus == IX_QMGR_WARNING)
1335             {
1336                 /* notification is enabled for a queue
1337                  * which is already empty (the condition is already met)
1338                  * and there will be no more queue event to drain the sw queue
1339                  * move an entry from the sw queue to the hw queue */
1340                 RX_STATS_INC(portId,rxFreeLateNotificationEnabled);
1341                 ixEthAccRxFreeFromSwQ(portId);
1342             }
1343             else
1344             {
1345                 RX_INC(portId,rxUnexpectedError);
1346                 IX_ETH_ACC_FATAL_LOG(
1347                      "ixEthAccRxPortFreeReplenish:Error: %u\n",
1348                      qStatus, 0, 0, 0, 0, 0);
1349             }
1350         }
1351     }
1352     else
1353     {
1354         RX_INC(portId,rxUnexpectedError);
1355         IX_ETH_ACC_FATAL_LOG(
1356             "ixEthAccRxPortFreeReplenish:Error: qStatus = %u\n",
1357             (UINT32)qStatus, 0, 0, 0, 0, 0);
1358         return(IX_ETH_ACC_FAIL);
1359     }
1360     return (IX_ETH_ACC_SUCCESS);
1361 }
1362
1363
1364 IX_ETH_ACC_PUBLIC
1365 IxEthAccStatus ixEthAccTxSchedulingDisciplineSetPriv(IxEthAccPortId portId,
1366                                                  IxEthAccSchedulerDiscipline
1367                                                  sched)
1368 {
1369     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
1370     {
1371         return (IX_ETH_ACC_INVALID_PORT);
1372     }
1373
1374     if (IX_ETH_ACC_SUCCESS != ixEthAccSingleEthNpeCheck(portId))
1375     {
1376         IX_ETH_ACC_WARNING_LOG("ixEthAccTxSchedulingDisciplineSet: Unavailable Eth %d: Cannot set Tx Scheduling Discipline.\n",(INT32)portId,0,0,0,0,0);
1377         return IX_ETH_ACC_SUCCESS ;
1378     }
1379
1380     if (!IX_ETH_IS_PORT_INITIALIZED(portId))
1381     {
1382         return (IX_ETH_ACC_PORT_UNINITIALIZED);
1383     }
1384
1385     if (sched != FIFO_PRIORITY && sched != FIFO_NO_PRIORITY)
1386     {
1387         return (IX_ETH_ACC_INVALID_ARG);
1388     }
1389
1390     ixEthAccPortData[portId].ixEthAccTxData.schDiscipline = sched;
1391     return (IX_ETH_ACC_SUCCESS);
1392 }
1393
1394 IX_ETH_ACC_PUBLIC
1395 IxEthAccStatus ixEthAccRxSchedulingDisciplineSetPriv(IxEthAccSchedulerDiscipline
1396                                                  sched)
1397 {
1398     if (sched != FIFO_PRIORITY && sched != FIFO_NO_PRIORITY)
1399     {
1400         return (IX_ETH_ACC_INVALID_ARG);
1401     }
1402
1403     ixEthAccDataInfo.schDiscipline = sched;
1404
1405     return (IX_ETH_ACC_SUCCESS);
1406 }
1407
1408
1409 /**
1410  * @fn ixEthRxFrameProcess(IxEthAccPortId portId, IX_OSAL_MBUF *mbufPtr)
1411  *
1412  * @brief process incoming frame :
1413  *
1414  * @param @ref IxQMgrCallback IxQMgrMultiBufferCallback
1415  *
1416  * @return none
1417  *
1418  * @internal
1419  *
1420  */
1421 IX_ETH_ACC_PRIVATE BOOL
1422 ixEthRxFrameProcess(IxEthAccPortId portId, IX_OSAL_MBUF *mbufPtr)
1423 {
1424     UINT32 flags;
1425     IxEthDBStatus result;
1426
1427 #ifndef NDEBUG
1428     /* Prudent to at least check the port is within range */
1429     if (portId >= IX_ETH_ACC_NUMBER_OF_PORTS)
1430     {
1431         ixEthAccDataStats.unexpectedError++;
1432         IX_ETH_ACC_FATAL_LOG(
1433              "ixEthRxFrameProcess: Illegal port: %u\n",
1434              (UINT32)portId, 0, 0, 0, 0, 0);
1435         return false;
1436     }
1437 #endif
1438
1439     /* convert fields from mbuf header */
1440     ixEthAccMbufFromRxQ(mbufPtr);
1441
1442     /* check about any special processing for this frame */
1443     flags = IX_ETHACC_NE_FLAGS(mbufPtr);
1444     if ((flags & (IX_ETHACC_NE_FILTERMASK | IX_ETHACC_NE_NEWSRCMASK)) == 0)
1445     {
1446         /* "best case" scenario : nothing special to do for this frame */
1447         return true;
1448     }
1449
1450 #ifdef CONFIG_IXP425_COMPONENT_ETHDB
1451     /* if a new source MAC address is detected by the NPE,
1452      * update IxEthDB with the portId and the MAC address.
1453      */
1454     if ((flags & IX_ETHACC_NE_NEWSRCMASK & ixEthAccNewSrcMask) != 0)
1455     {
1456         result = ixEthDBFilteringDynamicEntryProvision(portId,
1457                           (IxEthDBMacAddr *) IX_ETHACC_NE_SOURCEMAC(mbufPtr));
1458
1459         if (result != IX_ETH_DB_SUCCESS && result != IX_ETH_DB_FEATURE_UNAVAILABLE)
1460         {
1461             if ((ixEthAccMacState[portId].portDisableState == ACTIVE) && (result != IX_ETH_DB_BUSY))
1462             {
1463                 RX_STATS_INC(portId, rxUnexpectedError);
1464                 IX_ETH_ACC_FATAL_LOG("ixEthRxFrameProcess: Failed to add source MAC \
1465                                     to the Learning/Filtering database\n", 0, 0, 0, 0, 0, 0);
1466             }
1467             else
1468             {
1469                 /* we expect this to fail during PortDisable, as EthDB is disabled for
1470                  * that port and will refuse to learn new addresses
1471                  */
1472             }
1473         }
1474         else
1475         {
1476             RX_STATS_INC(portId, rxUnlearnedMacAddress);
1477         }
1478     }
1479 #endif
1480
1481     /* check if this frame should have been filtered
1482      * by the NPE and take the appropriate action
1483      */
1484     if (((flags & IX_ETHACC_NE_FILTERMASK) != 0)
1485         && (ixEthAccMacState[portId].portDisableState == ACTIVE))
1486     {
1487         /* If the mbuf was allocated with a small data size, or the current data pointer is not
1488          * within the allocated data area, then the buffer is non-standard and has to be
1489          * replenished with the minimum size only
1490          */
1491         if( (IX_OSAL_MBUF_ALLOCATED_BUFF_LEN(mbufPtr) < IX_ETHNPE_ACC_RXFREE_BUFFER_LENGTH_MIN)
1492            || ((UINT8 *)IX_OSAL_MBUF_ALLOCATED_BUFF_DATA(mbufPtr) > IX_OSAL_MBUF_MDATA(mbufPtr))
1493            || ((UINT8 *)(IX_OSAL_MBUF_ALLOCATED_BUFF_DATA(mbufPtr) +
1494               IX_OSAL_MBUF_ALLOCATED_BUFF_LEN(mbufPtr))
1495                < IX_OSAL_MBUF_MDATA(mbufPtr)) )
1496         {
1497             /* set to minimum length */
1498             IX_OSAL_MBUF_MLEN(mbufPtr) = IX_OSAL_MBUF_PKT_LEN(mbufPtr) =
1499                 IX_ETHNPE_ACC_RXFREE_BUFFER_LENGTH_MIN;
1500         }
1501         else
1502         {
1503             /* restore original length */
1504             IX_OSAL_MBUF_MLEN(mbufPtr) = IX_OSAL_MBUF_PKT_LEN(mbufPtr) =
1505                 ( IX_OSAL_MBUF_ALLOCATED_BUFF_LEN(mbufPtr) -
1506                  (IX_OSAL_MBUF_MDATA(mbufPtr) - (UINT8 *)IX_OSAL_MBUF_ALLOCATED_BUFF_DATA(mbufPtr)) );
1507         }
1508
1509         /* replenish from here */
1510         if (ixEthAccPortRxFreeReplenish(portId, mbufPtr) != IX_ETH_ACC_SUCCESS)
1511         {
1512                 IX_ETH_ACC_FATAL_LOG("ixEthRxFrameProcess: Failed to replenish with filtered frame\
1513                                       on port %d\n", portId, 0, 0, 0, 0, 0);
1514         }
1515
1516         RX_STATS_INC(portId, rxFiltered);
1517
1518         /* indicate that frame should not be subjected to further processing */
1519         return false;
1520     }
1521
1522     return true;
1523 }
1524
1525
1526 /**
1527  * @fn ixEthRxFrameQMCallback
1528  *
1529  * @brief receive callback for Frame receive Q from NPE
1530  *
1531  * Frames are passed one-at-a-time to the user
1532  *
1533  * @param @ref IxQMgrCallback
1534  *
1535  * @return none
1536  *
1537  * @internal
1538  *
1539  * Design note : while processing the entry X, entry X+1 is preloaded
1540  * into memory to reduce the number of stall cycles
1541  *
1542  */
1543 void ixEthRxFrameQMCallback(IxQMgrQId qId, IxQMgrCallbackId callbackId)
1544 {
1545     IX_OSAL_MBUF    *mbufPtr;
1546     IX_OSAL_MBUF    *nextMbufPtr;
1547     UINT32     qEntry;
1548     UINT32     nextQEntry;
1549     UINT32     *qEntryPtr;
1550     UINT32     portId;
1551     UINT32     destPortId;
1552     UINT32     npeId;
1553     UINT32     rxQReadStatus;
1554
1555     /*
1556      * Design note : entries are read in a buffer, This buffer contains
1557      * an extra zeroed entry so the loop will
1558      * always terminate on a null entry, whatever the result of Burst read is.
1559      */
1560     UINT32 rxQEntry[IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK + 1];
1561
1562     /*
1563      * Indication of the number of times the callback is used.
1564      */
1565     IX_ETH_ACC_STATS_INC(ixEthAccDataStats.rxCallbackCounter);
1566
1567     do
1568     {
1569         /*
1570          * Indication of the number of times the queue is drained
1571          */
1572         IX_ETH_ACC_STATS_INC(ixEthAccDataStats.rxCallbackBurstRead);
1573
1574         /* ensure the last entry of the array contains a zeroed value */
1575         qEntryPtr = rxQEntry;
1576         qEntryPtr[IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK] = 0;
1577
1578         rxQReadStatus = ixQMgrQBurstRead(qId,
1579                  IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK,
1580                  qEntryPtr);
1581
1582 #ifndef NDEBUG
1583         if ((rxQReadStatus != IX_QMGR_Q_UNDERFLOW)
1584             && (rxQReadStatus != IX_SUCCESS))
1585         {
1586             ixEthAccDataStats.unexpectedError++;
1587             /*major error*/
1588             IX_ETH_ACC_FATAL_LOG(
1589                 "ixEthRxFrameQMCallback:Error: %u\n",
1590                 (UINT32)rxQReadStatus, 0, 0, 0, 0, 0);
1591             return;
1592         }
1593 #endif
1594
1595         /* convert and preload the next entry
1596          * (the conversion function takes care about null pointers which
1597          * are used to mark the end of the loop)
1598          */
1599         nextQEntry = *qEntryPtr;
1600         nextMbufPtr = ixEthAccEntryFromQConvert(nextQEntry,
1601                           IX_ETHNPE_QM_Q_RXENET_ADDR_MASK);
1602
1603         while(nextQEntry != 0)
1604         {
1605             /* get the next entry */
1606             qEntry = nextQEntry;
1607             mbufPtr = nextMbufPtr;
1608
1609 #ifndef NDEBUG
1610             if (mbufPtr == NULL)
1611             {
1612                 ixEthAccDataStats.unexpectedError++;
1613                 IX_ETH_ACC_FATAL_LOG(
1614                     "ixEthRxFrameQMCallback: Null Mbuf Ptr\n",
1615                     0, 0, 0, 0, 0, 0);
1616                 return;
1617             }
1618 #endif
1619
1620             /* convert the next entry
1621              * (the conversion function takes care about null pointers which
1622              * are used to mark the end of the loop)
1623              */
1624             nextQEntry = *(++qEntryPtr);
1625             nextMbufPtr = ixEthAccEntryFromQConvert(nextQEntry,
1626                               IX_ETHNPE_QM_Q_RXENET_ADDR_MASK);
1627
1628             /*
1629              * Get Port and Npe ID from message.
1630              */
1631             npeId = ((IX_ETHNPE_QM_Q_RXENET_NPEID_MASK &
1632                       qEntry) >> IX_ETHNPE_QM_Q_FIELD_NPEID_R);
1633             portId = IX_ETH_ACC_NPE_TO_PORT_ID(npeId);
1634
1635             /* process frame, check the return code and skip the remaining of
1636              * the loop if the frame is to be filtered out
1637              */
1638             if (ixEthRxFrameProcess(portId, mbufPtr))
1639             {
1640                 /* destination portId for this packet */
1641                 destPortId = IX_ETHACC_NE_DESTPORTID(mbufPtr);
1642
1643                 if (destPortId != IX_ETH_DB_UNKNOWN_PORT)
1644                 {
1645                     destPortId = IX_ETH_DB_NPE_LOGICAL_ID_TO_PORT_ID(destPortId);
1646                 }
1647
1648                 /* test if QoS is enabled in ethAcc
1649                 */
1650                 if (ixEthAccDataInfo.schDiscipline == FIFO_PRIORITY)
1651                 {
1652                     /* check if there is a higher priority queue
1653                     * which may require processing and then process it.
1654                     */
1655                     if (ixEthAccDataInfo.higherPriorityQueue[qId] < IX_QMGR_MAX_NUM_QUEUES)
1656                     {
1657                         ixEthRxFrameQMCallback(ixEthAccDataInfo.higherPriorityQueue[qId],
1658                                             callbackId);
1659                     }
1660                 }
1661
1662                 /*
1663                 * increment priority stats
1664                 */
1665                 RX_STATS_INC(portId,rxPriority[IX_ETHACC_NE_QOS(mbufPtr)]);
1666
1667                 /*
1668                 * increment callback count stats
1669                 */
1670                 RX_STATS_INC(portId,rxFrameClientCallback);
1671
1672                 /*
1673                 * Call user level callback.
1674                 */
1675                 ixEthAccPortData[portId].ixEthAccRxData.rxCallbackFn(
1676                     ixEthAccPortData[portId].ixEthAccRxData.rxCallbackTag,
1677                     mbufPtr,
1678                     destPortId);
1679             }
1680         }
1681     } while (rxQReadStatus == IX_SUCCESS);
1682 }
1683
1684 /**
1685  * @fn ixEthRxMultiBufferQMCallback
1686  *
1687  * @brief receive callback for Frame receive Q from NPE
1688  *
1689  * Frames are passed as an array to the user
1690  *
1691  * @param @ref IxQMgrCallback
1692  *
1693  * @return none
1694  *
1695  * @internal
1696  *
1697  * Design note : while processing the entry X, entry X+1 is preloaded
1698  * into memory to reduce the number of stall cycles
1699  *
1700  */
1701 void ixEthRxMultiBufferQMCallback(IxQMgrQId qId, IxQMgrCallbackId callbackId)
1702 {
1703     IX_OSAL_MBUF    *mbufPtr;
1704     IX_OSAL_MBUF    *nextMbufPtr;
1705     UINT32     qEntry;
1706     UINT32     nextQEntry;
1707     UINT32     *qEntryPtr;
1708     UINT32     portId;
1709     UINT32     npeId;
1710     UINT32     rxQReadStatus;
1711     /*
1712      * Design note : entries are read in a static buffer, This buffer contains
1713      * an extra zeroed entry so the loop will
1714      * always terminate on a null entry, whatever the result of Burst read is.
1715      */
1716     static UINT32 rxQEntry[IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK + 1];
1717     static IX_OSAL_MBUF *rxMbufPortArray[IX_ETH_ACC_NUMBER_OF_PORTS][IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK + 1];
1718     IX_OSAL_MBUF **rxMbufPtr[IX_ETH_ACC_NUMBER_OF_PORTS];
1719
1720     for (portId = 0; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
1721     {
1722         rxMbufPtr[portId] = rxMbufPortArray[portId];
1723     }
1724
1725     /*
1726      * Indication of the number of times the callback is used.
1727      */
1728     IX_ETH_ACC_STATS_INC(ixEthAccDataStats.rxCallbackCounter);
1729
1730     do
1731     {
1732         /*
1733          * Indication of the number of times the queue is drained
1734          */
1735         IX_ETH_ACC_STATS_INC(ixEthAccDataStats.rxCallbackBurstRead);
1736
1737         /* ensure the last entry of the array contains a zeroed value */
1738         qEntryPtr = rxQEntry;
1739         qEntryPtr[IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK] = 0;
1740
1741         rxQReadStatus = ixQMgrQBurstRead(qId,
1742                  IX_ETH_ACC_MAX_RX_FRAME_CONSUME_PER_CALLBACK,
1743                  qEntryPtr);
1744
1745 #ifndef NDEBUG
1746         if ((rxQReadStatus != IX_QMGR_Q_UNDERFLOW)
1747             && (rxQReadStatus != IX_SUCCESS))
1748         {
1749             ixEthAccDataStats.unexpectedError++;
1750             /*major error*/
1751             IX_ETH_ACC_FATAL_LOG(
1752                 "ixEthRxFrameMultiBufferQMCallback:Error: %u\n",
1753                 (UINT32)rxQReadStatus, 0, 0, 0, 0, 0);
1754             return;
1755         }
1756 #endif
1757
1758         /* convert and preload the next entry
1759          * (the conversion function takes care about null pointers which
1760          * are used to mark the end of the loop)
1761          */
1762         nextQEntry = *qEntryPtr;
1763         nextMbufPtr = ixEthAccEntryFromQConvert(nextQEntry,
1764                           IX_ETHNPE_QM_Q_RXENET_ADDR_MASK);
1765
1766         while(nextQEntry != 0)
1767         {
1768             /* get the next entry */
1769             qEntry = nextQEntry;
1770             mbufPtr = nextMbufPtr;
1771
1772 #ifndef NDEBUG
1773             if (mbufPtr == NULL)
1774             {
1775                 ixEthAccDataStats.unexpectedError++;
1776                 IX_ETH_ACC_FATAL_LOG(
1777                     "ixEthRxFrameMultiBufferQMCallback:Error: Null Mbuf Ptr\n",
1778                     0, 0, 0, 0, 0, 0);
1779                 return;
1780             }
1781 #endif
1782
1783             /* convert the next entry
1784              * (the conversion function takes care about null pointers which
1785              * are used to mark the end of the loop)
1786              */
1787             nextQEntry = *(++qEntryPtr);
1788             nextMbufPtr = ixEthAccEntryFromQConvert(nextQEntry,
1789                               IX_ETHNPE_QM_Q_RXENET_ADDR_MASK);
1790
1791             /*
1792              * Get Port and Npe ID from message.
1793              */
1794             npeId = ((IX_ETHNPE_QM_Q_RXENET_NPEID_MASK &
1795                       qEntry) >>
1796                      IX_ETHNPE_QM_Q_FIELD_NPEID_R);
1797             portId = IX_ETH_ACC_NPE_TO_PORT_ID(npeId);
1798
1799             /* skip the remaining of the loop if the frame is
1800              * to be filtered out
1801              */
1802             if (ixEthRxFrameProcess(portId, mbufPtr))
1803             {
1804                 /* store a mbuf pointer in an array */
1805                 *rxMbufPtr[portId]++ = mbufPtr;
1806
1807                 /*
1808                  * increment priority stats
1809                  */
1810                 RX_STATS_INC(portId,rxPriority[IX_ETHACC_NE_QOS(mbufPtr)]);
1811             }
1812
1813             /* test for QoS enabled in ethAcc */
1814             if (ixEthAccDataInfo.schDiscipline == FIFO_PRIORITY)
1815             {
1816                 /* check if there is a higher priority queue
1817                  * which may require processing and then process it.
1818                  */
1819                 if (ixEthAccDataInfo.higherPriorityQueue[qId] < IX_QMGR_MAX_NUM_QUEUES)
1820                 {
1821                     ixEthRxMultiBufferQMCallback(ixEthAccDataInfo.higherPriorityQueue[qId],
1822                                                  callbackId);
1823                 }
1824             }
1825         }
1826
1827         /* check if any of the the arrays contains any entry */
1828         for (portId = 0; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
1829         {
1830             if (rxMbufPtr[portId] != rxMbufPortArray[portId])
1831             {
1832                 /* add a last NULL pointer at the end of the
1833                  * array of mbuf pointers
1834                  */
1835                 *rxMbufPtr[portId] = NULL;
1836
1837                 /*
1838                  * increment callback count stats
1839                  */
1840                 RX_STATS_INC(portId,rxFrameClientCallback);
1841
1842                 /*
1843                  * Call user level callback with an array of
1844                  * buffers (NULL terminated)
1845                  */
1846                 ixEthAccPortData[portId].ixEthAccRxData.
1847                     rxMultiBufferCallbackFn(
1848                             ixEthAccPortData[portId].ixEthAccRxData.
1849                                    rxMultiBufferCallbackTag,
1850                             rxMbufPortArray[portId]);
1851
1852                 /* reset the buffer pointer to the beginning of
1853                  * the array
1854                  */
1855                 rxMbufPtr[portId] = rxMbufPortArray[portId];
1856             }
1857         }
1858
1859     } while (rxQReadStatus == IX_SUCCESS);
1860 }
1861
1862
1863 /**
1864  * @brief  rxFree low event handler
1865  *
1866  */
1867 void ixEthRxFreeQMCallback(IxQMgrQId qId, IxQMgrCallbackId callbackId)
1868 {
1869     IxEthAccPortId      portId = (IxEthAccPortId) callbackId;
1870     int                 lockVal;
1871     UINT32              maxQWritesToPerform = IX_ETH_ACC_MAX_RX_FREE_BUFFERS_LOAD;
1872     IX_STATUS           qStatus = IX_SUCCESS;
1873
1874     /*
1875      * We have reached a low threshold on one of the Rx Free Qs
1876      */
1877
1878     /*note that due to the fact that we are working off an Empty threshold, this callback
1879       need only write a single entry to the Rx Free queue in order to re-arm the notification
1880     */
1881
1882     RX_STATS_INC(portId,rxFreeLowCallback);
1883
1884     /*
1885      * Get buffers from approprite S/W Rx freeBufferList Q.
1886      */
1887
1888 #ifndef NDEBUG
1889     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
1890     {
1891         ixEthAccDataStats.unexpectedError++;
1892         IX_ETH_ACC_FATAL_LOG(
1893             "ixEthRxFreeQMCallback:Error: Invalid Port 0x%08X\n",
1894             portId, 0, 0, 0, 0, 0);
1895         return;
1896     }
1897 #endif
1898     IX_ETH_ACC_DATA_PLANE_LOCK(lockVal);
1899     if (IX_ETH_ACC_DATAPLANE_IS_Q_EMPTY(ixEthAccPortData[portId].
1900                                         ixEthAccRxData.freeBufferList))
1901     {
1902         /*
1903          * Turn off Q callback notification for Q in Question.
1904          */
1905         qStatus = ixQMgrNotificationDisable(
1906             IX_ETH_ACC_PORT_TO_RX_FREE_Q_ID(portId));
1907
1908
1909         IX_ETH_ACC_DATA_PLANE_UNLOCK(lockVal);
1910
1911         if (qStatus != IX_SUCCESS)
1912         {
1913             RX_INC(portId,rxUnexpectedError);
1914             IX_ETH_ACC_FATAL_LOG(
1915                 "ixEthRxFreeQMCallback:Error: unexpected QM status 0x%08X\n",
1916                 qStatus, 0, 0, 0, 0, 0);
1917             return;
1918         }
1919     }
1920     else
1921     {
1922         IX_ETH_ACC_DATA_PLANE_UNLOCK(lockVal);
1923         /*
1924          * Load the H/W Q with buffers from the s/w Q.
1925          */
1926
1927         do
1928         {
1929             /*
1930              * Consume Q entries. - Note Q contains Physical addresss,
1931              * and have already been flushed to memory,
1932              * And endianess converted if required.
1933              */
1934             if (ixEthAccRxFreeFromSwQ(portId) != IX_SUCCESS)
1935             {
1936                 /*
1937                  * No more entries in s/w Q.
1938                  * Turn off Q callback indication
1939                  */
1940
1941                 IX_ETH_ACC_DATA_PLANE_LOCK(lockVal);
1942                 if (IX_ETH_ACC_DATAPLANE_IS_Q_EMPTY(ixEthAccPortData[portId].
1943                     ixEthAccRxData.freeBufferList))
1944                 {
1945                     qStatus = ixQMgrNotificationDisable(
1946                         IX_ETH_ACC_PORT_TO_RX_FREE_Q_ID(portId));
1947                 }
1948                 IX_ETH_ACC_DATA_PLANE_UNLOCK(lockVal);
1949                 break;
1950             }
1951         }
1952         while (--maxQWritesToPerform);
1953     }
1954 }
1955 /**
1956  * @fn Tx queue low event handler
1957  *
1958  */
1959 void
1960 ixEthTxFrameQMCallback(IxQMgrQId qId, IxQMgrCallbackId callbackId)
1961 {
1962     IxEthAccPortId portId = (IxEthAccPortId) callbackId;
1963     int            lockVal;
1964     UINT32         maxQWritesToPerform = IX_ETH_ACC_MAX_TX_FRAME_TX_CONSUME_PER_CALLBACK;
1965     IX_STATUS      qStatus = IX_SUCCESS;
1966     IxEthAccTxPriority highestPriority;
1967
1968
1969     /*
1970      * We have reached a low threshold on the Tx Q, and are being asked to
1971      * supply a buffer for transmission from our S/W TX queues
1972      */
1973     TX_STATS_INC(portId,txLowThreshCallback);
1974
1975     /*
1976      * Get buffers from approprite Q.
1977      */
1978
1979 #ifndef NDEBUG
1980     if (!IX_ETH_ACC_IS_PORT_VALID(portId))
1981     {
1982         ixEthAccDataStats.unexpectedError++;
1983         IX_ETH_ACC_FATAL_LOG(
1984             "ixEthTxFrameQMCallback:Error: Invalid Port 0x%08X\n",
1985             portId, 0, 0, 0, 0, 0);
1986         return;
1987     }
1988 #endif
1989
1990     do
1991     {
1992         /*
1993          * Consume Q entries. - Note Q contains Physical addresss,
1994          * and have already been flushed to memory,
1995          * and endianess already sone if required.
1996          */
1997
1998         IX_ETH_ACC_DATA_PLANE_LOCK(lockVal);
1999
2000         if(ixEthAccTxSwQHighestPriorityGet(portId, &highestPriority) ==
2001            IX_ETH_ACC_FAIL)
2002         {
2003             /*
2004              * No more entries in s/w Q.
2005              * Turn off Q callback indication
2006              */
2007             qStatus = ixQMgrNotificationDisable(
2008                 IX_ETH_ACC_PORT_TO_TX_Q_ID(portId));
2009
2010             IX_ETH_ACC_DATA_PLANE_UNLOCK(lockVal);
2011
2012             if (qStatus != IX_SUCCESS)
2013             {
2014                 ixEthAccDataStats.unexpectedError++;
2015                 IX_ETH_ACC_FATAL_LOG(
2016                     "ixEthTxFrameQMCallback:Error: unexpected QM status 0x%08X\n",
2017                     qStatus, 0, 0, 0, 0, 0);
2018             }
2019
2020             return;
2021         }
2022         else
2023         {
2024             IX_ETH_ACC_DATA_PLANE_UNLOCK(lockVal);
2025             if (ixEthAccTxFromSwQ(portId,highestPriority)!=IX_SUCCESS)
2026             {
2027                 /* nothing left in the sw queue or the hw queues are
2028                 * full. There is no point to continue to drain the
2029                 * sw queues
2030                 */
2031                 return;
2032             }
2033         }
2034     }
2035     while (--maxQWritesToPerform);
2036 }
2037
2038 /**
2039  * @brief TxDone event handler
2040  *
2041  * Design note : while processing the entry X, entry X+1 is preloaded
2042  * into memory to reduce the number of stall cycles
2043  *
2044  */
2045
2046 void
2047 ixEthTxFrameDoneQMCallback(IxQMgrQId qId, IxQMgrCallbackId callbackId)
2048 {
2049     IX_OSAL_MBUF    *mbufPtr;
2050     UINT32     qEntry;
2051     UINT32     *qEntryPtr;
2052     UINT32     txDoneQReadStatus;
2053     UINT32     portId;
2054     UINT32     npeId;
2055
2056     /*
2057      * Design note : entries are read in a static buffer, This buffer contains
2058      * an extra entyry (which is zeroed by the compiler), so the loop will
2059      * always terminate on a null entry, whatever the result of Burst read is.
2060      */
2061     static UINT32 txDoneQEntry[IX_ETH_ACC_MAX_TX_FRAME_DONE_CONSUME_PER_CALLBACK + 1];
2062
2063     /*
2064      * Indication that Tx frames have been transmitted from the NPE.
2065      */
2066
2067     IX_ETH_ACC_STATS_INC(ixEthAccDataStats.txDoneCallbackCounter);
2068
2069     do{
2070         qEntryPtr = txDoneQEntry;
2071         txDoneQReadStatus = ixQMgrQBurstRead(IX_ETH_ACC_TX_FRAME_DONE_ETH_Q,
2072                      IX_ETH_ACC_MAX_TX_FRAME_DONE_CONSUME_PER_CALLBACK,
2073                      qEntryPtr);
2074
2075 #ifndef NDEBUG
2076         if (txDoneQReadStatus != IX_QMGR_Q_UNDERFLOW
2077             && (txDoneQReadStatus != IX_SUCCESS))
2078         {
2079             /*major error*/
2080             ixEthAccDataStats.unexpectedError++;
2081             IX_ETH_ACC_FATAL_LOG(
2082                 "ixEthTxFrameDoneQMCallback:Error: %u\n",
2083                 (UINT32)txDoneQReadStatus, 0, 0, 0, 0, 0);
2084             return;
2085         }
2086 #endif
2087
2088         qEntry = *qEntryPtr;
2089
2090         while(qEntry != 0)
2091         {
2092             mbufPtr = ixEthAccEntryFromQConvert(qEntry,
2093                       IX_ETHNPE_QM_Q_TXENET_ADDR_MASK);
2094
2095 #ifndef NDEBUG
2096             if (mbufPtr == NULL)
2097             {
2098                 ixEthAccDataStats.unexpectedError++;
2099                 IX_ETH_ACC_FATAL_LOG(
2100                     "ixEthTxFrameDoneQMCallback:Error: Null Mbuf Ptr\n",
2101                     0, 0, 0, 0, 0, 0);
2102                 return;
2103             }
2104 #endif
2105
2106             /* endianness conversions and stats updates */
2107             ixEthAccMbufFromTxQ(mbufPtr);
2108
2109             /*
2110              * Get NPE id from message, then convert to portId.
2111              */
2112             npeId = ((IX_ETHNPE_QM_Q_TXENETDONE_NPEID_MASK &
2113                        qEntry) >>
2114                       IX_ETHNPE_QM_Q_FIELD_NPEID_R);
2115             portId = IX_ETH_ACC_NPE_TO_PORT_ID(npeId);
2116
2117 #ifndef NDEBUG
2118             /* Prudent to at least check the port is within range */
2119             if (portId >= IX_ETH_ACC_NUMBER_OF_PORTS)
2120             {
2121                 ixEthAccDataStats.unexpectedError++;
2122                 IX_ETH_ACC_FATAL_LOG(
2123                     "ixEthTxFrameDoneQMCallback: Illegal port: %u\n",
2124                     (UINT32)portId, 0, 0, 0, 0, 0);
2125                 return;
2126             }
2127 #endif
2128
2129             TX_STATS_INC(portId,txDoneClientCallback);
2130
2131             /*
2132              * Call user level callback.
2133              */
2134             ixEthAccPortData[portId].ixEthAccTxData.txBufferDoneCallbackFn(
2135                 ixEthAccPortData[portId].ixEthAccTxData.txCallbackTag,
2136                 mbufPtr);
2137
2138             /* move to next queue entry */
2139             qEntry = *(++qEntryPtr);
2140
2141         }
2142     } while( txDoneQReadStatus == IX_SUCCESS );
2143 }
2144
2145 IX_ETH_ACC_PUBLIC
2146 void ixEthAccDataPlaneShow(void)
2147 {
2148     UINT32 numTx0Entries;
2149     UINT32 numTx1Entries;
2150     UINT32 numTxDoneEntries;
2151     UINT32 numRxEntries;
2152     UINT32 numRxFree0Entries;
2153     UINT32 numRxFree1Entries;
2154     UINT32 portId;
2155 #ifdef __ixp46X
2156     UINT32 numTx2Entries;
2157     UINT32 numRxFree2Entries;
2158 #endif
2159 #ifndef NDEBUG
2160     UINT32 priority;
2161     UINT32 numBuffersInRx=0;
2162     UINT32 numBuffersInTx=0;
2163     UINT32 numBuffersInSwQ=0;
2164     UINT32 totalBuffers=0;
2165     UINT32 rxFreeCallbackCounter = 0;
2166     UINT32 txCallbackCounter = 0;
2167 #endif
2168     UINT32 key;
2169
2170     /* snapshot of stats */
2171     IxEthAccTxDataStats tx[IX_ETH_ACC_NUMBER_OF_PORTS];
2172     IxEthAccRxDataStats rx[IX_ETH_ACC_NUMBER_OF_PORTS];
2173     IxEthAccDataPlaneStats stats;
2174
2175     if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
2176     {
2177         return;
2178     }
2179
2180     /* get a reliable snapshot */
2181     key = ixOsalIrqLock();
2182
2183     numTx0Entries = 0;
2184     ixQMgrQNumEntriesGet(IX_ETH_ACC_TX_FRAME_ENET0_Q, &numTx0Entries);
2185     numTx1Entries = 0;
2186     ixQMgrQNumEntriesGet(IX_ETH_ACC_TX_FRAME_ENET1_Q, &numTx1Entries);
2187     numTxDoneEntries = 0;
2188     ixQMgrQNumEntriesGet( IX_ETH_ACC_TX_FRAME_DONE_ETH_Q, &numTxDoneEntries);
2189     numRxEntries = 0;
2190     ixEthAccQMgrRxQEntryGet(&numRxEntries);
2191     numRxFree0Entries = 0;
2192     ixQMgrQNumEntriesGet(IX_ETH_ACC_RX_FREE_BUFF_ENET0_Q, &numRxFree0Entries);
2193     numRxFree1Entries = 0;
2194     ixQMgrQNumEntriesGet(IX_ETH_ACC_RX_FREE_BUFF_ENET1_Q, &numRxFree1Entries);
2195
2196 #ifdef __ixp46X
2197     numTx2Entries = 0;
2198     ixQMgrQNumEntriesGet(IX_ETH_ACC_TX_FRAME_ENET2_Q, &numTx2Entries);
2199     numRxFree2Entries = 0;
2200     ixQMgrQNumEntriesGet(IX_ETH_ACC_RX_FREE_BUFF_ENET2_Q, &numRxFree2Entries);
2201 #endif
2202
2203     for(portId=IX_ETH_PORT_1; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
2204     {
2205         memcpy(&tx[portId],
2206                &ixEthAccPortData[portId].ixEthAccTxData.stats,
2207                sizeof(tx[portId]));
2208         memcpy(&rx[portId],
2209                &ixEthAccPortData[portId].ixEthAccRxData.stats,
2210                sizeof(rx[portId]));
2211     }
2212     memcpy(&stats, &ixEthAccDataStats, sizeof(stats));
2213
2214     ixOsalIrqUnlock(key);
2215
2216 #ifdef NDEBUG
2217     printf("Detailed statistics collection not supported in this load\n");
2218 #endif
2219
2220     /* print snapshot */
2221     for(portId=0; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
2222     {
2223         /* If not IXP42X A0 stepping, proceed to check for existence of coprocessors */
2224         if ((IX_FEATURE_CTRL_SILICON_TYPE_A0 !=
2225              (ixFeatureCtrlProductIdRead() & IX_FEATURE_CTRL_SILICON_STEPPING_MASK))
2226             || (IX_FEATURE_CTRL_DEVICE_TYPE_IXP42X != ixFeatureCtrlDeviceRead ()))
2227         {
2228                 if ((IX_ETH_PORT_1 == portId) &&
2229                     (ixFeatureCtrlComponentCheck(IX_FEATURECTRL_ETH0) ==
2230                      IX_FEATURE_CTRL_COMPONENT_DISABLED))
2231                 {
2232                    continue ;
2233                 }
2234                 if ((IX_ETH_PORT_2 == portId) &&
2235                     (ixFeatureCtrlComponentCheck(IX_FEATURECTRL_ETH1) ==
2236                      IX_FEATURE_CTRL_COMPONENT_DISABLED))
2237                 {
2238                     continue ;
2239                 }
2240                 if ((IX_ETH_PORT_3 == portId) &&
2241                     (ixFeatureCtrlComponentCheck(IX_FEATURECTRL_NPEA_ETH) ==
2242                      IX_FEATURE_CTRL_COMPONENT_DISABLED))
2243                 {
2244                     continue ;
2245                 }
2246         }
2247
2248         printf("PORT %u --------------------------------\n",
2249                portId);
2250 #ifndef NDEBUG
2251         printf("Tx Done Frames                : %u\n",
2252                tx[portId].txDoneClientCallback +
2253                tx[portId].txDoneSwQDuringDisable +
2254                tx[portId].txDoneDuringDisable);
2255         printf("Tx Frames                     : %u\n",
2256                tx[portId].txQOK + tx[portId].txQDelayed);
2257         printf("Tx H/W Q Added OK             : %u\n",
2258                tx[portId].txQOK);
2259         printf("Tx H/W Q Delayed              : %u\n",
2260                tx[portId].txQDelayed);
2261         printf("Tx From S/W Q Added OK        : %u\n",
2262                tx[portId].txFromSwQOK);
2263         printf("Tx From S/W Q Delayed         : %u\n",
2264                tx[portId].txFromSwQDelayed);
2265         printf("Tx Overflow                   : %u\n",
2266                tx[portId].txOverflow);
2267         printf("Tx Mutual Lock                : %u\n",
2268                tx[portId].txLock);
2269         printf("Tx Late Ntf Enabled           : %u\n",
2270                tx[portId].txLateNotificationEnabled);
2271         printf("Tx Low Thresh CB              : %u\n",
2272                tx[portId].txLowThreshCallback);
2273         printf("Tx Done from H/W Q (Disable)  : %u\n",
2274                tx[portId].txDoneDuringDisable);
2275         printf("Tx Done from S/W Q (Disable)  : %u\n",
2276                tx[portId].txDoneSwQDuringDisable);
2277         for (priority = IX_ETH_ACC_TX_PRIORITY_0;
2278              priority <= IX_ETH_ACC_TX_PRIORITY_7;
2279              priority++)
2280         {
2281             if (tx[portId].txPriority[priority])
2282             {
2283                 printf("Tx Priority %u                 : %u\n",
2284                        priority,
2285                        tx[portId].txPriority[priority]);
2286             }
2287         }
2288 #endif
2289         printf("Tx unexpected errors          : %u (should be 0)\n",
2290                tx[portId].txUnexpectedError);
2291
2292 #ifndef NDEBUG
2293         printf("Rx Frames                     : %u\n",
2294                rx[portId].rxFrameClientCallback +
2295                rx[portId].rxSwQDuringDisable+
2296                rx[portId].rxDuringDisable);
2297         printf("Rx Free Replenish             : %u\n",
2298                rx[portId].rxFreeRepOK + rx[portId].rxFreeRepDelayed);
2299         printf("Rx Free H/W Q Added OK        : %u\n",
2300                rx[portId].rxFreeRepOK);
2301         printf("Rx Free H/W Q Delayed         : %u\n",
2302                rx[portId].rxFreeRepDelayed);
2303         printf("Rx Free From S/W Q Added OK   : %u\n",
2304                rx[portId].rxFreeRepFromSwQOK);
2305         printf("Rx Free From S/W Q Delayed    : %u\n",
2306                rx[portId].rxFreeRepFromSwQDelayed);
2307         printf("Rx Free Overflow              : %u\n",
2308                rx[portId].rxFreeOverflow);
2309         printf("Rx Free Mutual Lock           : %u\n",
2310                rx[portId].rxFreeLock);
2311         printf("Rx Free Late Ntf Enabled      : %u\n",
2312                rx[portId].rxFreeLateNotificationEnabled);
2313         printf("Rx Free Low CB                : %u\n",
2314                rx[portId].rxFreeLowCallback);
2315         printf("Rx From H/W Q (Disable)       : %u\n",
2316                rx[portId].rxDuringDisable);
2317         printf("Rx From S/W Q (Disable)       : %u\n",
2318                rx[portId].rxSwQDuringDisable);
2319         printf("Rx unlearned Mac Address      : %u\n",
2320                rx[portId].rxUnlearnedMacAddress);
2321         printf("Rx Filtered (Rx => RxFree)    : %u\n",
2322             rx[portId].rxFiltered);
2323
2324         for (priority = IX_ETH_ACC_TX_PRIORITY_0;
2325              priority <= IX_ETH_ACC_TX_PRIORITY_7;
2326              priority++)
2327         {
2328             if (rx[portId].rxPriority[priority])
2329             {
2330                 printf("Rx Priority %u                 : %u\n",
2331                        priority,
2332                        rx[portId].rxPriority[priority]);
2333             }
2334         }
2335 #endif
2336         printf("Rx unexpected errors          : %u (should be 0)\n",
2337                rx[portId].rxUnexpectedError);
2338
2339 #ifndef NDEBUG
2340         numBuffersInTx = tx[portId].txQOK +
2341             tx[portId].txQDelayed -
2342             tx[portId].txDoneClientCallback -
2343             tx[portId].txDoneSwQDuringDisable -
2344             tx[portId].txDoneDuringDisable;
2345
2346         printf("# Tx Buffers currently for transmission : %u\n",
2347                numBuffersInTx);
2348
2349         numBuffersInRx = rx[portId].rxFreeRepOK +
2350             rx[portId].rxFreeRepDelayed -
2351             rx[portId].rxFrameClientCallback -
2352             rx[portId].rxSwQDuringDisable -
2353             rx[portId].rxDuringDisable;
2354
2355         printf("# Rx Buffers currently for reception    : %u\n",
2356                numBuffersInRx);
2357
2358         totalBuffers += numBuffersInRx + numBuffersInTx;
2359 #endif
2360     }
2361
2362     printf("---------------------------------------\n");
2363
2364 #ifndef NDEBUG
2365     printf("\n");
2366     printf("Mbufs :\n");
2367     printf("Tx Unchained mbufs            : %u\n",
2368            stats.unchainedTxMBufs);
2369     printf("Tx Chained bufs               : %u\n",
2370            stats.chainedTxMBufs);
2371     printf("TxDone Unchained mbufs        : %u\n",
2372            stats.unchainedTxDoneMBufs);
2373     printf("TxDone Chained bufs           : %u\n",
2374            stats.chainedTxDoneMBufs);
2375     printf("RxFree Unchained mbufs        : %u\n",
2376            stats.unchainedRxFreeMBufs);
2377     printf("RxFree Chained bufs           : %u\n",
2378            stats.chainedRxFreeMBufs);
2379     printf("Rx Unchained mbufs            : %u\n",
2380            stats.unchainedRxMBufs);
2381     printf("Rx Chained bufs               : %u\n",
2382            stats.chainedRxMBufs);
2383
2384     printf("\n");
2385     printf("Software queue usage :\n");
2386     printf("Buffers added to S/W Q        : %u\n",
2387            stats.addToSwQ);
2388     printf("Buffers removed from S/W Q    : %u\n",
2389            stats.removeFromSwQ);
2390
2391     printf("\n");
2392     printf("Hardware queues callbacks :\n");
2393
2394     for(portId=0; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
2395     {
2396         rxFreeCallbackCounter += rx[portId].rxFreeLowCallback;
2397         txCallbackCounter += tx[portId].txLowThreshCallback;
2398     }
2399     printf("Tx Done QM Callback invoked   : %u\n",
2400            stats.txDoneCallbackCounter);
2401     printf("Tx QM Callback invoked        : %u\n",
2402            txCallbackCounter);
2403     printf("Rx QM Callback invoked        : %u\n",
2404            stats.rxCallbackCounter);
2405     printf("Rx QM Callback burst read     : %u\n",
2406            stats.rxCallbackBurstRead);
2407     printf("Rx Free QM Callback invoked   : %u\n",
2408            rxFreeCallbackCounter);
2409 #endif
2410     printf("Unexpected errors in CB       : %u (should be 0)\n",
2411            stats.unexpectedError);
2412     printf("\n");
2413
2414     printf("Hardware queues levels :\n");
2415     printf("Transmit Port 1 Q             : %u \n",numTx0Entries);
2416     printf("Transmit Port 2 Q             : %u \n",numTx1Entries);
2417 #ifdef __ixp46X
2418     printf("Transmit Port 3 Q             : %u \n",numTx2Entries);
2419 #endif
2420     printf("Transmit Done Q               : %u \n",numTxDoneEntries);
2421     printf("Receive Q                     : %u \n",numRxEntries);
2422     printf("Receive Free Port 1 Q         : %u \n",numRxFree0Entries);
2423     printf("Receive Free Port 2 Q         : %u \n",numRxFree1Entries);
2424 #ifdef __ixp46X
2425     printf("Receive Free Port 3 Q         : %u \n",numRxFree2Entries);
2426 #endif
2427
2428 #ifndef NDEBUG
2429     printf("\n");
2430     printf("# Total Buffers accounted for : %u\n",
2431            totalBuffers);
2432
2433     numBuffersInSwQ = ixEthAccDataStats.addToSwQ -
2434         ixEthAccDataStats.removeFromSwQ;
2435
2436     printf("    Buffers in S/W Qs         : %u\n",
2437            numBuffersInSwQ);
2438     printf("    Buffers in H/W Qs or NPEs : %u\n",
2439            totalBuffers - numBuffersInSwQ);
2440 #endif
2441
2442     printf("Rx QoS Discipline             : %s\n",
2443            (ixEthAccDataInfo.schDiscipline ==
2444             FIFO_PRIORITY ) ? "Enabled" : "Disabled");
2445
2446     for(portId=0; portId < IX_ETH_ACC_NUMBER_OF_PORTS; portId++)
2447     {
2448         printf("Tx QoS Discipline port %u      : %s\n",
2449                portId,
2450                (ixEthAccPortData[portId].ixEthAccTxData.schDiscipline ==
2451                 FIFO_PRIORITY ) ? "Enabled" : "Disabled");
2452     }
2453     printf("\n");
2454 }
2455
2456
2457
2458
2459