/** * @file    IxQMgrDispatcher.c * * @author Intel Corporation * @date    20-Dec-2001 *     * @brief   This file contains the implementation of the Dispatcher sub component * *  * @par * IXP400 SW Release version 2.0 *  * -- Copyright Notice -- *  * @par * Copyright 2001-2005, Intel Corporation. * All rights reserved. *  * @par * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. Neither the name of the Intel Corporation nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. *  * @par * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. *  * @par * -- End of Copyright Notice --*//* * User defined include files. */#include "IxQMgr.h"#include "IxQMgrAqmIf_p.h"#include "IxQMgrQCfg_p.h"#include "IxQMgrDispatcher_p.h"#include "IxQMgrLog_p.h"#include "IxQMgrDefines_p.h"#include "IxFeatureCtrl.h"#include "IxOsal.h"/* * #defines and macros used in this file. *//* * This constant is used to indicate the number of priority levels supported */#define IX_QMGR_NUM_PRIORITY_LEVELS 3/*  * This constant is used to set the size of the array of status words */#define MAX_Q_STATUS_WORDS      4/* * This macro is used to check if a given priority is valid */#define IX_QMGR_DISPATCHER_PRIORITY_CHECK(priority) \(((priority) >= IX_QMGR_Q_PRIORITY_0) && ((priority) <= IX_QMGR_Q_PRIORITY_2))/* * This macto is used to check that a given interrupt source is valid */#define IX_QMGR_DISPATCHER_SOURCE_ID_CHECK(srcSel) \(((srcSel) >= IX_QMGR_Q_SOURCE_ID_E) && ((srcSel) <= IX_QMGR_Q_SOURCE_ID_NOT_F))/* * Number of times a dummy callback is called before logging a trace * message */#define LOG_THROTTLE_COUNT 1000000/* Priority tables limits */#define IX_QMGR_MIN_LOW_QUE_PRIORITY_TABLE_INDEX (0)#define IX_QMGR_MID_LOW_QUE_PRIORITY_TABLE_INDEX (16)#define IX_QMGR_MAX_LOW_QUE_PRIORITY_TABLE_INDEX (31)#define IX_QMGR_MIN_UPP_QUE_PRIORITY_TABLE_INDEX (32)#define IX_QMGR_MID_UPP_QUE_PRIORITY_TABLE_INDEX (48)#define IX_QMGR_MAX_UPP_QUE_PRIORITY_TABLE_INDEX (63) /* * This macro is used to check if a given callback type is valid */#define IX_QMGR_DISPATCHER_CALLBACK_TYPE_CHECK(type) \            (((type) >= IX_QMGR_TYPE_REALTIME_OTHER) && \            ((type) <= IX_QMGR_TYPE_REALTIME_SPORADIC))/*  * define max index in lower queue to use in loops  */#define IX_QMGR_MAX_LOW_QUE_TABLE_INDEX (31)/* * Typedefs whose scope is limited to this file. *//* * Information on a queue needed by the Dispatcher */typedef struct {    IxQMgrCallback callback;       /* Notification callback                  */    IxQMgrCallbackId callbackId;   /* Notification callback identifier       */    unsigned dummyCallbackCount;   /* Number of times runs of dummy callback */    IxQMgrPriority priority;       /* Dispatch priority                      */    unsigned int statusWordOffset; /* Offset to the status word to check     */    UINT32 statusMask;             /* Status mask                            */        UINT32 statusCheckValue;       /* Status check value                     */    UINT32 intRegCheckMask;	   /* Interrupt register check mask          */} IxQMgrQInfo;/* * Variable declarations global to this file. Externs are followed by * statics. *//*  * Flag to keep record of what dispatcher set in featureCtrl when ixQMgrInit() * is called. This is needed because it is possible that a client might * change whether the live lock prevention dispatcher is used between * calls to ixQMgrInit() and ixQMgrDispatcherLoopGet().  */PRIVATE IX_STATUS ixQMgrOrigB0Dispatcher = IX_FEATURE_CTRL_COMPONENT_ENABLED;/*  * keep record of Q types - not in IxQMgrQInfo for performance as * it is only used with ixQMgrDispatcherLoopRunB0LLP() */PRIVATE IxQMgrType ixQMgrQTypes[IX_QMGR_MAX_NUM_QUEUES];/* * This array contains a list of queue identifiers ordered by priority. The table * is split logically between queue identifiers 0-31 and 32-63. */static IxQMgrQId priorityTable[IX_QMGR_MAX_NUM_QUEUES];/* * This flag indicates to the dispatcher that the priority table needs to be rebuilt. */static BOOL rebuildTable = FALSE;/* Dispatcher statistics */static IxQMgrDispatcherStats dispatcherStats;/* Table of queue information */static IxQMgrQInfo dispatchQInfo[IX_QMGR_MAX_NUM_QUEUES];/* Masks use to identify the first queues in the priority tables *  when comparing with the interrupt register*/static unsigned int lowPriorityTableFirstHalfMask;static unsigned int uppPriorityTableFirstHalfMask;/* * Static function prototypes *//* * This function is the default callback for all queues */PRIVATE voiddummyCallback (IxQMgrQId qId,	      	       IxQMgrCallbackId cbId);PRIVATE voidixQMgrDispatcherReBuildPriorityTable (void);/* * Function definitions. */voidixQMgrDispatcherInit (void){    int i;    IxFeatureCtrlProductId productId = 0;    IxFeatureCtrlDeviceId deviceId = 0;    BOOL stickyIntSilicon = TRUE;     /* Set default priorities */    for (i=0; i< IX_QMGR_MAX_NUM_QUEUES; i++)    {	dispatchQInfo[i].callback = dummyCallback;	dispatchQInfo[i].callbackId = 0;	dispatchQInfo[i].dummyCallbackCount = 0;	dispatchQInfo[i].priority = IX_QMGR_Q_PRIORITY_2;	dispatchQInfo[i].statusWordOffset = 0;	dispatchQInfo[i].statusCheckValue = 0;	dispatchQInfo[i].statusMask = 0;          /* 	 * There are two interrupt registers, 32 bits each. One for the lower	 * queues(0-31) and one for the upper queues(32-63). Therefore need to	 * mod by 32 i.e the min upper queue identifier.	 */	dispatchQInfo[i].intRegCheckMask = (1<<(i%(IX_QMGR_MIN_QUEUPP_QID)));        /*          * Set the Q types - will only be used with livelock          */        ixQMgrQTypes[i] = IX_QMGR_TYPE_REALTIME_OTHER;	/* Reset queue statistics */	dispatcherStats.queueStats[i].callbackCnt = 0;	dispatcherStats.queueStats[i].priorityChangeCnt = 0;	dispatcherStats.queueStats[i].intNoCallbackCnt = 0;	dispatcherStats.queueStats[i].intLostCallbackCnt = 0;        dispatcherStats.queueStats[i].notificationEnabled = FALSE;        dispatcherStats.queueStats[i].srcSel = 0;    }    /* Priority table. Order the table from queue 0 to 63 */    ixQMgrDispatcherReBuildPriorityTable();    /* Reset statistics */    dispatcherStats.loopRunCnt = 0;    /* Get the device ID for the underlying silicon */    deviceId = ixFeatureCtrlDeviceRead();        /* Get the product ID for the underlying silicon */    productId = ixFeatureCtrlProductIdRead();    /*      * Check featureCtrl to see if Livelock prevention is required      */    ixQMgrOrigB0Dispatcher = ixFeatureCtrlSwConfigurationCheck(                                  IX_FEATURECTRL_ORIGB0_DISPATCHER);    /*     * Check if the silicon supports the sticky interrupt feature.     * IF (IXP42X AND A0) -> No sticky interrupt feature supported      */    if ((IX_FEATURE_CTRL_DEVICE_TYPE_IXP42X ==         (IX_FEATURE_CTRL_DEVICE_TYPE_MASK & deviceId)) &&        (IX_FEATURE_CTRL_SILICON_TYPE_A0 ==         (IX_FEATURE_CTRL_SILICON_STEPPING_MASK & productId)))     {       stickyIntSilicon = FALSE;    }    /*     * IF user wants livelock prev option AND silicon supports sticky interrupt      * feature -> enable the sticky interrupt bit     */    if ((IX_FEATURE_CTRL_SWCONFIG_DISABLED == ixQMgrOrigB0Dispatcher) &&         stickyIntSilicon)      {        ixQMgrStickyInterruptRegEnable();    }}IX_STATUSixQMgrDispatcherPrioritySet (IxQMgrQId qId,			     IxQMgrPriority priority){       int ixQMgrLockKey;    if (!ixQMgrQIsConfigured(qId))    {	return IX_QMGR_Q_NOT_CONFIGURED;    }        if (!IX_QMGR_DISPATCHER_PRIORITY_CHECK(priority))    {	return IX_QMGR_Q_INVALID_PRIORITY;    }    ixQMgrLockKey = ixOsalIrqLock();        /* Change priority */    dispatchQInfo[qId].priority = priority;    /* Set flag */    rebuildTable = TRUE;    ixOsalIrqUnlock(ixQMgrLockKey);#ifndef NDEBUG    /* Update statistics */    dispatcherStats.queueStats[qId].priorityChangeCnt++;#endif    return IX_SUCCESS;}IX_STATUSixQMgrNotificationCallbackSet (IxQMgrQId qId,			       IxQMgrCallback callback,			       IxQMgrCallbackId callbackId){    if (!ixQMgrQIsConfigured(qId))    {	return IX_QMGR_Q_NOT_CONFIGURED;    }    if (NULL == callback)    {	/* Reset to dummy callback */	dispatchQInfo[qId].callback = dummyCallback;	dispatchQInfo[qId].dummyCallbackCount = 0;	dispatchQInfo[qId].callbackId = 0;    }    else     {	dispatchQInfo[qId].callback = callback;	dispatchQInfo[qId].callbackId = callbackId;    }    return IX_SUCCESS;}IX_STATUSixQMgrNotificationEnable (IxQMgrQId qId, 			  IxQMgrSourceId srcSel){    IxQMgrQStatus qStatusOnEntry;/* The queue status on entry/exit */    IxQMgrQStatus qStatusOnExit; /* to this function               */    int ixQMgrLockKey;#ifndef NDEBUG    if (!ixQMgrQIsConfigured (qId))    {	return IX_QMGR_Q_NOT_CONFIGURED;    }    if ((qId < IX_QMGR_MIN_QUEUPP_QID) &&       !IX_QMGR_DISPATCHER_SOURCE_ID_CHECK(srcSel))    {	/* QId 0-31 source id invalid */	return IX_QMGR_INVALID_INT_SOURCE_ID;    }    if ((IX_QMGR_Q_SOURCE_ID_NE != srcSel) &&	(qId >= IX_QMGR_MIN_QUEUPP_QID))    {	/*	 * For queues 32-63 the interrupt source is fixed to the Nearly	 * Empty status flag and therefore should have a srcSel of NE.	 */	return IX_QMGR_INVALID_INT_SOURCE_ID;    }#endif#ifndef NDEBUG    dispatcherStats.queueStats[qId].notificationEnabled = TRUE;    dispatcherStats.queueStats[qId].srcSel = srcSel;#endif    /* Get the current queue status */    ixQMgrAqmIfQueStatRead (qId, &qStatusOnEntry);      /*      * Enabling interrupts results in Read-Modify-Write     * so need critical section     */    ixQMgrLockKey = ixOsalIrqLock();    /* Calculate the checkMask and checkValue for this q */    ixQMgrAqmIfQStatusCheckValsCalc (qId,				     srcSel,				     &dispatchQInfo[qId].statusWordOffset,				     &dispatchQInfo[qId].statusCheckValue,				     &dispatchQInfo[qId].statusMask);    /* Set the interupt source is this queue is in the range 0-31 */    if (qId < IX_QMGR_MIN_QUEUPP_QID)    {	ixQMgrAqmIfIntSrcSelWrite (qId, srcSel);    }    /* Enable the interrupt */    ixQMgrAqmIfQInterruptEnable (qId);    ixOsalIrqUnlock(ixQMgrLockKey);        /* Get the current queue status */    ixQMgrAqmIfQueStatRead (qId, &qStatusOnExit);      /* If the status has changed return a warning */    if (qStatusOnEntry != qStatusOnExit)    {	return IX_QMGR_WARNING;    }        return IX_SUCCESS;}IX_STATUSixQMgrNotificationDisable (IxQMgrQId qId){    int ixQMgrLockKey;#ifndef NDEBUG    /* Validate parameters */    if (!ixQMgrQIsConfigured (qId))    {	return IX_QMGR_Q_NOT_CONFIGURED;    }#endif      /*      * Enabling interrupts results in Read-Modify-Write     * so need critical section     */#ifndef NDEBUG    dispatcherStats.queueStats[qId].notificationEnabled = FALSE;#endif    ixQMgrLockKey = ixOsalIrqLock();    ixQMgrAqmIfQInterruptDisable (qId);        ixOsalIrqUnlock(ixQMgrLockKey);    return IX_SUCCESS;    }void ixQMgrStickyInterruptRegEnable(void){ /* Use Aqm If function to set Interrupt Register0 Bit-3 */  ixQMgrAqmIfIntSrcSelReg0Bit3Set ();   }#if !defined __XSCALE__ || defined __linux