forked from Minki/linux
743 lines
27 KiB
C
743 lines
27 KiB
C
/******************************************************************************
|
|
*
|
|
* Name: skdim.c
|
|
* Project: GEnesis, PCI Gigabit Ethernet Adapter
|
|
* Version: $Revision: 1.5 $
|
|
* Date: $Date: 2003/11/28 12:55:40 $
|
|
* Purpose: All functions to maintain interrupt moderation
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* (C)Copyright 1998-2002 SysKonnect GmbH.
|
|
* (C)Copyright 2002-2003 Marvell.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* The information in this file is provided "AS IS" without warranty.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Description:
|
|
*
|
|
* This module is intended to manage the dynamic interrupt moderation on both
|
|
* GEnesis and Yukon adapters.
|
|
*
|
|
* Include File Hierarchy:
|
|
*
|
|
* "skdrv1st.h"
|
|
* "skdrv2nd.h"
|
|
*
|
|
******************************************************************************/
|
|
|
|
#ifndef lint
|
|
static const char SysKonnectFileId[] =
|
|
"@(#) $Id: skdim.c,v 1.5 2003/11/28 12:55:40 rroesler Exp $ (C) SysKonnect.";
|
|
#endif
|
|
|
|
#define __SKADDR_C
|
|
|
|
#ifdef __cplusplus
|
|
#error C++ is not yet supported.
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Includes
|
|
**
|
|
*******************************************************************************/
|
|
|
|
#ifndef __INC_SKDRV1ST_H
|
|
#include "h/skdrv1st.h"
|
|
#endif
|
|
|
|
#ifndef __INC_SKDRV2ND_H
|
|
#include "h/skdrv2nd.h"
|
|
#endif
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Defines
|
|
**
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Typedefs
|
|
**
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Local function prototypes
|
|
**
|
|
*******************************************************************************/
|
|
|
|
static unsigned int GetCurrentSystemLoad(SK_AC *pAC);
|
|
static SK_U64 GetIsrCalls(SK_AC *pAC);
|
|
static SK_BOOL IsIntModEnabled(SK_AC *pAC);
|
|
static void SetCurrIntCtr(SK_AC *pAC);
|
|
static void EnableIntMod(SK_AC *pAC);
|
|
static void DisableIntMod(SK_AC *pAC);
|
|
static void ResizeDimTimerDuration(SK_AC *pAC);
|
|
static void DisplaySelectedModerationType(SK_AC *pAC);
|
|
static void DisplaySelectedModerationMask(SK_AC *pAC);
|
|
static void DisplayDescrRatio(SK_AC *pAC);
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Global variables
|
|
**
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Local variables
|
|
**
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Global functions
|
|
**
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
** Function : SkDimModerate
|
|
** Description : Called in every ISR to check if moderation is to be applied
|
|
** or not for the current number of interrupts
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 22-mar-03
|
|
** Returns : void (!)
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
void
|
|
SkDimModerate(SK_AC *pAC) {
|
|
unsigned int CurrSysLoad = 0; /* expressed in percent */
|
|
unsigned int LoadIncrease = 0; /* expressed in percent */
|
|
SK_U64 ThresholdInts = 0;
|
|
SK_U64 IsrCallsPerSec = 0;
|
|
|
|
#define M_DIMINFO pAC->DynIrqModInfo
|
|
|
|
if (!IsIntModEnabled(pAC)) {
|
|
if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
|
|
CurrSysLoad = GetCurrentSystemLoad(pAC);
|
|
if (CurrSysLoad > 75) {
|
|
/*
|
|
** More than 75% total system load! Enable the moderation
|
|
** to shield the system against too many interrupts.
|
|
*/
|
|
EnableIntMod(pAC);
|
|
} else if (CurrSysLoad > M_DIMINFO.PrevSysLoad) {
|
|
LoadIncrease = (CurrSysLoad - M_DIMINFO.PrevSysLoad);
|
|
if (LoadIncrease > ((M_DIMINFO.PrevSysLoad *
|
|
C_INT_MOD_ENABLE_PERCENTAGE) / 100)) {
|
|
if (CurrSysLoad > 10) {
|
|
/*
|
|
** More than 50% increase with respect to the
|
|
** previous load of the system. Most likely this
|
|
** is due to our ISR-proc...
|
|
*/
|
|
EnableIntMod(pAC);
|
|
}
|
|
}
|
|
} else {
|
|
/*
|
|
** Neither too much system load at all nor too much increase
|
|
** with respect to the previous system load. Hence, we can leave
|
|
** the ISR-handling like it is without enabling moderation.
|
|
*/
|
|
}
|
|
M_DIMINFO.PrevSysLoad = CurrSysLoad;
|
|
}
|
|
} else {
|
|
if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
|
|
ThresholdInts = ((M_DIMINFO.MaxModIntsPerSec *
|
|
C_INT_MOD_DISABLE_PERCENTAGE) / 100);
|
|
IsrCallsPerSec = GetIsrCalls(pAC);
|
|
if (IsrCallsPerSec <= ThresholdInts) {
|
|
/*
|
|
** The number of interrupts within the last second is
|
|
** lower than the disable_percentage of the desried
|
|
** maxrate. Therefore we can disable the moderation.
|
|
*/
|
|
DisableIntMod(pAC);
|
|
M_DIMINFO.MaxModIntsPerSec =
|
|
(M_DIMINFO.MaxModIntsPerSecUpperLimit +
|
|
M_DIMINFO.MaxModIntsPerSecLowerLimit) / 2;
|
|
} else {
|
|
/*
|
|
** The number of interrupts per sec is the same as expected.
|
|
** Evalulate the descriptor-ratio. If it has changed, a resize
|
|
** in the moderation timer might be useful
|
|
*/
|
|
if (M_DIMINFO.AutoSizing) {
|
|
ResizeDimTimerDuration(pAC);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Some information to the log...
|
|
*/
|
|
if (M_DIMINFO.DisplayStats) {
|
|
DisplaySelectedModerationType(pAC);
|
|
DisplaySelectedModerationMask(pAC);
|
|
DisplayDescrRatio(pAC);
|
|
}
|
|
|
|
M_DIMINFO.NbrProcessedDescr = 0;
|
|
SetCurrIntCtr(pAC);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : SkDimStartModerationTimer
|
|
** Description : Starts the audit-timer for the dynamic interrupt moderation
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 22-mar-03
|
|
** Returns : void (!)
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
void
|
|
SkDimStartModerationTimer(SK_AC *pAC) {
|
|
SK_EVPARA EventParam; /* Event struct for timer event */
|
|
|
|
SK_MEMSET((char *) &EventParam, 0, sizeof(EventParam));
|
|
EventParam.Para32[0] = SK_DRV_MODERATION_TIMER;
|
|
SkTimerStart(pAC, pAC->IoBase, &pAC->DynIrqModInfo.ModTimer,
|
|
SK_DRV_MODERATION_TIMER_LENGTH,
|
|
SKGE_DRV, SK_DRV_TIMER, EventParam);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : SkDimEnableModerationIfNeeded
|
|
** Description : Either enables or disables moderation
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 22-mar-03
|
|
** Returns : void (!)
|
|
** Notes : This function is called when a particular adapter is opened
|
|
** There is no Disable function, because when all interrupts
|
|
** might be disable, the moderation timer has no meaning at all
|
|
******************************************************************************/
|
|
|
|
void
|
|
SkDimEnableModerationIfNeeded(SK_AC *pAC) {
|
|
|
|
if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_STATIC) {
|
|
EnableIntMod(pAC); /* notification print in this function */
|
|
} else if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
|
|
SkDimStartModerationTimer(pAC);
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("Dynamic moderation has been enabled\n");
|
|
}
|
|
} else {
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("No moderation has been enabled\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : SkDimDisplayModerationSettings
|
|
** Description : Displays the current settings regaring interrupt moderation
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 22-mar-03
|
|
** Returns : void (!)
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
void
|
|
SkDimDisplayModerationSettings(SK_AC *pAC) {
|
|
DisplaySelectedModerationType(pAC);
|
|
DisplaySelectedModerationMask(pAC);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Local functions
|
|
**
|
|
*******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
** Function : GetCurrentSystemLoad
|
|
** Description : Retrieves the current system load of the system. This load
|
|
** is evaluated for all processors within the system.
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 22-mar-03
|
|
** Returns : unsigned int: load expressed in percentage
|
|
** Notes : The possible range being returned is from 0 up to 100.
|
|
** Whereas 0 means 'no load at all' and 100 'system fully loaded'
|
|
** It is impossible to determine what actually causes the system
|
|
** to be in 100%, but maybe that is due to too much interrupts.
|
|
*******************************************************************************/
|
|
|
|
static unsigned int
|
|
GetCurrentSystemLoad(SK_AC *pAC) {
|
|
unsigned long jif = jiffies;
|
|
unsigned int UserTime = 0;
|
|
unsigned int SystemTime = 0;
|
|
unsigned int NiceTime = 0;
|
|
unsigned int IdleTime = 0;
|
|
unsigned int TotalTime = 0;
|
|
unsigned int UsedTime = 0;
|
|
unsigned int SystemLoad = 0;
|
|
|
|
/* unsigned int NbrCpu = 0; */
|
|
|
|
/*
|
|
** The following lines have been commented out, because
|
|
** from kernel 2.5.44 onwards, the kernel-owned structure
|
|
**
|
|
** struct kernel_stat kstat
|
|
**
|
|
** is not marked as an exported symbol in the file
|
|
**
|
|
** kernel/ksyms.c
|
|
**
|
|
** As a consequence, using this driver as KLM is not possible
|
|
** and any access of the structure kernel_stat via the
|
|
** dedicated macros kstat_cpu(i).cpustat.xxx is to be avoided.
|
|
**
|
|
** The kstat-information might be added again in future
|
|
** versions of the 2.5.xx kernel, but for the time being,
|
|
** number of interrupts will serve as indication how much
|
|
** load we currently have...
|
|
**
|
|
** for (NbrCpu = 0; NbrCpu < num_online_cpus(); NbrCpu++) {
|
|
** UserTime = UserTime + kstat_cpu(NbrCpu).cpustat.user;
|
|
** NiceTime = NiceTime + kstat_cpu(NbrCpu).cpustat.nice;
|
|
** SystemTime = SystemTime + kstat_cpu(NbrCpu).cpustat.system;
|
|
** }
|
|
*/
|
|
SK_U64 ThresholdInts = 0;
|
|
SK_U64 IsrCallsPerSec = 0;
|
|
|
|
ThresholdInts = ((M_DIMINFO.MaxModIntsPerSec *
|
|
C_INT_MOD_ENABLE_PERCENTAGE) + 100);
|
|
IsrCallsPerSec = GetIsrCalls(pAC);
|
|
if (IsrCallsPerSec >= ThresholdInts) {
|
|
/*
|
|
** We do not know how much the real CPU-load is!
|
|
** Return 80% as a default in order to activate DIM
|
|
*/
|
|
SystemLoad = 80;
|
|
return (SystemLoad);
|
|
}
|
|
|
|
UsedTime = UserTime + NiceTime + SystemTime;
|
|
|
|
IdleTime = jif * num_online_cpus() - UsedTime;
|
|
TotalTime = UsedTime + IdleTime;
|
|
|
|
SystemLoad = ( 100 * (UsedTime - M_DIMINFO.PrevUsedTime) ) /
|
|
(TotalTime - M_DIMINFO.PrevTotalTime);
|
|
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("Current system load is: %u\n", SystemLoad);
|
|
}
|
|
|
|
M_DIMINFO.PrevTotalTime = TotalTime;
|
|
M_DIMINFO.PrevUsedTime = UsedTime;
|
|
|
|
return (SystemLoad);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : GetIsrCalls
|
|
** Description : Depending on the selected moderation mask, this function will
|
|
** return the number of interrupts handled in the previous time-
|
|
** frame. This evaluated number is based on the current number
|
|
** of interrupts stored in PNMI-context and the previous stored
|
|
** interrupts.
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : int: the number of interrupts being executed in the last
|
|
** timeframe
|
|
** Notes : It makes only sense to call this function, when dynamic
|
|
** interrupt moderation is applied
|
|
*******************************************************************************/
|
|
|
|
static SK_U64
|
|
GetIsrCalls(SK_AC *pAC) {
|
|
SK_U64 RxPort0IntDiff = 0;
|
|
SK_U64 RxPort1IntDiff = 0;
|
|
SK_U64 TxPort0IntDiff = 0;
|
|
SK_U64 TxPort1IntDiff = 0;
|
|
|
|
if (pAC->DynIrqModInfo.MaskIrqModeration == IRQ_MASK_TX_ONLY) {
|
|
if (pAC->GIni.GIMacsFound == 2) {
|
|
TxPort1IntDiff = pAC->Pnmi.Port[1].TxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort1TxIntrCts;
|
|
}
|
|
TxPort0IntDiff = pAC->Pnmi.Port[0].TxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort0TxIntrCts;
|
|
} else if (pAC->DynIrqModInfo.MaskIrqModeration == IRQ_MASK_RX_ONLY) {
|
|
if (pAC->GIni.GIMacsFound == 2) {
|
|
RxPort1IntDiff = pAC->Pnmi.Port[1].RxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort1RxIntrCts;
|
|
}
|
|
RxPort0IntDiff = pAC->Pnmi.Port[0].RxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort0RxIntrCts;
|
|
} else {
|
|
if (pAC->GIni.GIMacsFound == 2) {
|
|
RxPort1IntDiff = pAC->Pnmi.Port[1].RxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort1RxIntrCts;
|
|
TxPort1IntDiff = pAC->Pnmi.Port[1].TxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort1TxIntrCts;
|
|
}
|
|
RxPort0IntDiff = pAC->Pnmi.Port[0].RxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort0RxIntrCts;
|
|
TxPort0IntDiff = pAC->Pnmi.Port[0].TxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort0TxIntrCts;
|
|
}
|
|
|
|
return (RxPort0IntDiff + RxPort1IntDiff + TxPort0IntDiff + TxPort1IntDiff);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : GetRxCalls
|
|
** Description : This function will return the number of times a receive inter-
|
|
** rupt was processed. This is needed to evaluate any resizing
|
|
** factor.
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : SK_U64: the number of RX-ints being processed
|
|
** Notes : It makes only sense to call this function, when dynamic
|
|
** interrupt moderation is applied
|
|
*******************************************************************************/
|
|
|
|
static SK_U64
|
|
GetRxCalls(SK_AC *pAC) {
|
|
SK_U64 RxPort0IntDiff = 0;
|
|
SK_U64 RxPort1IntDiff = 0;
|
|
|
|
if (pAC->GIni.GIMacsFound == 2) {
|
|
RxPort1IntDiff = pAC->Pnmi.Port[1].RxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort1RxIntrCts;
|
|
}
|
|
RxPort0IntDiff = pAC->Pnmi.Port[0].RxIntrCts -
|
|
pAC->DynIrqModInfo.PrevPort0RxIntrCts;
|
|
|
|
return (RxPort0IntDiff + RxPort1IntDiff);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : SetCurrIntCtr
|
|
** Description : Will store the current number orf occured interrupts in the
|
|
** adapter context. This is needed to evaluated the number of
|
|
** interrupts within a current timeframe.
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : void (!)
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
SetCurrIntCtr(SK_AC *pAC) {
|
|
if (pAC->GIni.GIMacsFound == 2) {
|
|
pAC->DynIrqModInfo.PrevPort1RxIntrCts = pAC->Pnmi.Port[1].RxIntrCts;
|
|
pAC->DynIrqModInfo.PrevPort1TxIntrCts = pAC->Pnmi.Port[1].TxIntrCts;
|
|
}
|
|
pAC->DynIrqModInfo.PrevPort0RxIntrCts = pAC->Pnmi.Port[0].RxIntrCts;
|
|
pAC->DynIrqModInfo.PrevPort0TxIntrCts = pAC->Pnmi.Port[0].TxIntrCts;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : IsIntModEnabled()
|
|
** Description : Retrieves the current value of the interrupts moderation
|
|
** command register. Its content determines whether any
|
|
** moderation is running or not.
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : SK_TRUE : if mod timer running
|
|
** SK_FALSE : if no moderation is being performed
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static SK_BOOL
|
|
IsIntModEnabled(SK_AC *pAC) {
|
|
unsigned long CtrCmd;
|
|
|
|
SK_IN32(pAC->IoBase, B2_IRQM_CTRL, &CtrCmd);
|
|
if ((CtrCmd & TIM_START) == TIM_START) {
|
|
return SK_TRUE;
|
|
} else {
|
|
return SK_FALSE;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : EnableIntMod()
|
|
** Description : Enables the interrupt moderation using the values stored in
|
|
** in the pAC->DynIntMod data structure
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 22-mar-03
|
|
** Returns : -
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
EnableIntMod(SK_AC *pAC) {
|
|
unsigned long ModBase;
|
|
|
|
if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
|
|
ModBase = C_CLK_FREQ_GENESIS / pAC->DynIrqModInfo.MaxModIntsPerSec;
|
|
} else {
|
|
ModBase = C_CLK_FREQ_YUKON / pAC->DynIrqModInfo.MaxModIntsPerSec;
|
|
}
|
|
|
|
SK_OUT32(pAC->IoBase, B2_IRQM_INI, ModBase);
|
|
SK_OUT32(pAC->IoBase, B2_IRQM_MSK, pAC->DynIrqModInfo.MaskIrqModeration);
|
|
SK_OUT32(pAC->IoBase, B2_IRQM_CTRL, TIM_START);
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("Enabled interrupt moderation (%i ints/sec)\n",
|
|
M_DIMINFO.MaxModIntsPerSec);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : DisableIntMod()
|
|
** Description : Disbles the interrupt moderation independent of what inter-
|
|
** rupts are running or not
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : -
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
DisableIntMod(SK_AC *pAC) {
|
|
|
|
SK_OUT32(pAC->IoBase, B2_IRQM_CTRL, TIM_STOP);
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("Disabled interrupt moderation\n");
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : ResizeDimTimerDuration();
|
|
** Description : Checks the current used descriptor ratio and resizes the
|
|
** duration timer (longer/smaller) if possible.
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : -
|
|
** Notes : There are both maximum and minimum timer duration value.
|
|
** This function assumes that interrupt moderation is already
|
|
** enabled!
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
ResizeDimTimerDuration(SK_AC *pAC) {
|
|
SK_BOOL IncreaseTimerDuration;
|
|
int TotalMaxNbrDescr;
|
|
int UsedDescrRatio;
|
|
int RatioDiffAbs;
|
|
int RatioDiffRel;
|
|
int NewMaxModIntsPerSec;
|
|
int ModAdjValue;
|
|
long ModBase;
|
|
|
|
/*
|
|
** Check first if we are allowed to perform any modification
|
|
*/
|
|
if (IsIntModEnabled(pAC)) {
|
|
if (M_DIMINFO.IntModTypeSelect != C_INT_MOD_DYNAMIC) {
|
|
return;
|
|
} else {
|
|
if (M_DIMINFO.ModJustEnabled) {
|
|
M_DIMINFO.ModJustEnabled = SK_FALSE;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If we got until here, we have to evaluate the amount of the
|
|
** descriptor ratio change...
|
|
*/
|
|
TotalMaxNbrDescr = pAC->RxDescrPerRing * GetRxCalls(pAC);
|
|
UsedDescrRatio = (M_DIMINFO.NbrProcessedDescr * 100) / TotalMaxNbrDescr;
|
|
|
|
if (UsedDescrRatio > M_DIMINFO.PrevUsedDescrRatio) {
|
|
RatioDiffAbs = (UsedDescrRatio - M_DIMINFO.PrevUsedDescrRatio);
|
|
RatioDiffRel = (RatioDiffAbs * 100) / UsedDescrRatio;
|
|
M_DIMINFO.PrevUsedDescrRatio = UsedDescrRatio;
|
|
IncreaseTimerDuration = SK_FALSE; /* in other words: DECREASE */
|
|
} else if (UsedDescrRatio < M_DIMINFO.PrevUsedDescrRatio) {
|
|
RatioDiffAbs = (M_DIMINFO.PrevUsedDescrRatio - UsedDescrRatio);
|
|
RatioDiffRel = (RatioDiffAbs * 100) / M_DIMINFO.PrevUsedDescrRatio;
|
|
M_DIMINFO.PrevUsedDescrRatio = UsedDescrRatio;
|
|
IncreaseTimerDuration = SK_TRUE; /* in other words: INCREASE */
|
|
} else {
|
|
RatioDiffAbs = (M_DIMINFO.PrevUsedDescrRatio - UsedDescrRatio);
|
|
RatioDiffRel = (RatioDiffAbs * 100) / M_DIMINFO.PrevUsedDescrRatio;
|
|
M_DIMINFO.PrevUsedDescrRatio = UsedDescrRatio;
|
|
IncreaseTimerDuration = SK_TRUE; /* in other words: INCREASE */
|
|
}
|
|
|
|
/*
|
|
** Now we can determine the change in percent
|
|
*/
|
|
if ((RatioDiffRel >= 0) && (RatioDiffRel <= 5) ) {
|
|
ModAdjValue = 1; /* 1% change - maybe some other value in future */
|
|
} else if ((RatioDiffRel > 5) && (RatioDiffRel <= 10) ) {
|
|
ModAdjValue = 1; /* 1% change - maybe some other value in future */
|
|
} else if ((RatioDiffRel > 10) && (RatioDiffRel <= 15) ) {
|
|
ModAdjValue = 1; /* 1% change - maybe some other value in future */
|
|
} else {
|
|
ModAdjValue = 1; /* 1% change - maybe some other value in future */
|
|
}
|
|
|
|
if (IncreaseTimerDuration) {
|
|
NewMaxModIntsPerSec = M_DIMINFO.MaxModIntsPerSec +
|
|
(M_DIMINFO.MaxModIntsPerSec * ModAdjValue) / 100;
|
|
} else {
|
|
NewMaxModIntsPerSec = M_DIMINFO.MaxModIntsPerSec -
|
|
(M_DIMINFO.MaxModIntsPerSec * ModAdjValue) / 100;
|
|
}
|
|
|
|
/*
|
|
** Check if we exceed boundaries...
|
|
*/
|
|
if ( (NewMaxModIntsPerSec > M_DIMINFO.MaxModIntsPerSecUpperLimit) ||
|
|
(NewMaxModIntsPerSec < M_DIMINFO.MaxModIntsPerSecLowerLimit)) {
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("Cannot change ModTim from %i to %i ints/sec\n",
|
|
M_DIMINFO.MaxModIntsPerSec, NewMaxModIntsPerSec);
|
|
}
|
|
return;
|
|
} else {
|
|
if (M_DIMINFO.DisplayStats) {
|
|
printk("Resized ModTim from %i to %i ints/sec\n",
|
|
M_DIMINFO.MaxModIntsPerSec, NewMaxModIntsPerSec);
|
|
}
|
|
}
|
|
|
|
M_DIMINFO.MaxModIntsPerSec = NewMaxModIntsPerSec;
|
|
|
|
if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
|
|
ModBase = C_CLK_FREQ_GENESIS / pAC->DynIrqModInfo.MaxModIntsPerSec;
|
|
} else {
|
|
ModBase = C_CLK_FREQ_YUKON / pAC->DynIrqModInfo.MaxModIntsPerSec;
|
|
}
|
|
|
|
/*
|
|
** We do not need to touch any other registers
|
|
*/
|
|
SK_OUT32(pAC->IoBase, B2_IRQM_INI, ModBase);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : DisplaySelectedModerationType()
|
|
** Description : Displays what type of moderation we have
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : void!
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
DisplaySelectedModerationType(SK_AC *pAC) {
|
|
|
|
if (pAC->DynIrqModInfo.DisplayStats) {
|
|
if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_STATIC) {
|
|
printk("Static int moderation runs with %i INTS/sec\n",
|
|
pAC->DynIrqModInfo.MaxModIntsPerSec);
|
|
} else if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
|
|
if (IsIntModEnabled(pAC)) {
|
|
printk("Dynamic int moderation runs with %i INTS/sec\n",
|
|
pAC->DynIrqModInfo.MaxModIntsPerSec);
|
|
} else {
|
|
printk("Dynamic int moderation currently not applied\n");
|
|
}
|
|
} else {
|
|
printk("No interrupt moderation selected!\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : DisplaySelectedModerationMask()
|
|
** Description : Displays what interrupts are moderated
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : void!
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
DisplaySelectedModerationMask(SK_AC *pAC) {
|
|
|
|
if (pAC->DynIrqModInfo.DisplayStats) {
|
|
if (pAC->DynIrqModInfo.IntModTypeSelect != C_INT_MOD_NONE) {
|
|
switch (pAC->DynIrqModInfo.MaskIrqModeration) {
|
|
case IRQ_MASK_TX_ONLY:
|
|
printk("Only Tx-interrupts are moderated\n");
|
|
break;
|
|
case IRQ_MASK_RX_ONLY:
|
|
printk("Only Rx-interrupts are moderated\n");
|
|
break;
|
|
case IRQ_MASK_SP_ONLY:
|
|
printk("Only special-interrupts are moderated\n");
|
|
break;
|
|
case IRQ_MASK_TX_RX:
|
|
printk("Tx- and Rx-interrupts are moderated\n");
|
|
break;
|
|
case IRQ_MASK_SP_RX:
|
|
printk("Special- and Rx-interrupts are moderated\n");
|
|
break;
|
|
case IRQ_MASK_SP_TX:
|
|
printk("Special- and Tx-interrupts are moderated\n");
|
|
break;
|
|
case IRQ_MASK_RX_TX_SP:
|
|
printk("All Rx-, Tx and special-interrupts are moderated\n");
|
|
break;
|
|
default:
|
|
printk("Don't know what is moderated\n");
|
|
break;
|
|
}
|
|
} else {
|
|
printk("No specific interrupts masked for moderation\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
** Function : DisplayDescrRatio
|
|
** Description : Like the name states...
|
|
** Programmer : Ralph Roesler
|
|
** Last Modified: 23-mar-03
|
|
** Returns : void!
|
|
** Notes : -
|
|
*******************************************************************************/
|
|
|
|
static void
|
|
DisplayDescrRatio(SK_AC *pAC) {
|
|
int TotalMaxNbrDescr = 0;
|
|
|
|
if (pAC->DynIrqModInfo.DisplayStats) {
|
|
TotalMaxNbrDescr = pAC->RxDescrPerRing * GetRxCalls(pAC);
|
|
printk("Ratio descriptors: %i/%i\n",
|
|
M_DIMINFO.NbrProcessedDescr, TotalMaxNbrDescr);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** End of file
|
|
**
|
|
*******************************************************************************/
|