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