drivers/net/sk98lin/skdim.c

   1 /******************************************************************************
   2  *
   3  * Name:        skdim.c
   4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
   5  * Version:     $Revision: 1.5 $
   6  * Date:        $Date: 2003/11/28 12:55:40 $
   7  * Purpose:     All functions to maintain interrupt moderation
   8  *
   9  ******************************************************************************/
  10
  11 /******************************************************************************
  12  *
  13  *      (C)Copyright 1998-2002 SysKonnect GmbH.
  14  *      (C)Copyright 2002-2003 Marvell.
  15  *
  16  *      This program is free software; you can redistribute it and/or modify
  17  *      it under the terms of the GNU General Public License as published by
  18  *      the Free Software Foundation; either version 2 of the License, or
  19  *      (at your option) any later version.
  20  *
  21  *      The information in this file is provided "AS IS" without warranty.
  22  *
  23  ******************************************************************************/
  24
  25 /******************************************************************************
  26  *
  27  * Description:
  28  *
  29  * This module is intended to manage the dynamic interrupt moderation on both
  30  * GEnesis and Yukon adapters.
  31  *
  32  * Include File Hierarchy:
  33  *
  34  *      "skdrv1st.h"
  35  *      "skdrv2nd.h"
  36  *
  37  ******************************************************************************/
  38
  39 #ifndef lint
  40 static const char SysKonnectFileId[] =
  41         "@(#) $Id: skdim.c,v 1.5 2003/11/28 12:55:40 rroesler Exp $ (C) SysKonnect.";
  42 #endif
  43
  44 #define __SKADDR_C
  45
  46 #ifdef __cplusplus
  47 #error C++ is not yet supported.
  48 extern "C" {
  49 #endif
  50
  51 /*******************************************************************************
  52 **
  53 ** Includes
  54 **
  55 *******************************************************************************/
  56
  57 #ifndef __INC_SKDRV1ST_H
  58 #include "h/skdrv1st.h"
  59 #endif
  60
  61 #ifndef __INC_SKDRV2ND_H
  62 #include "h/skdrv2nd.h"
  63 #endif
  64
  65 #include        <linux/kernel_stat.h>
  66
  67 /*******************************************************************************
  68 **
  69 ** Defines
  70 **
  71 *******************************************************************************/
  72
  73 /*******************************************************************************
  74 **
  75 ** Typedefs
  76 **
  77 *******************************************************************************/
  78
  79 /*******************************************************************************
  80 **
  81 ** Local function prototypes
  82 **
  83 *******************************************************************************/
  84
  85 static unsigned int GetCurrentSystemLoad(SK_AC *pAC);
  86 static SK_U64       GetIsrCalls(SK_AC *pAC);
  87 static SK_BOOL      IsIntModEnabled(SK_AC *pAC);
  88 static void         SetCurrIntCtr(SK_AC *pAC);
  89 static void         EnableIntMod(SK_AC *pAC);
  90 static void         DisableIntMod(SK_AC *pAC);
  91 static void         ResizeDimTimerDuration(SK_AC *pAC);
  92 static void         DisplaySelectedModerationType(SK_AC *pAC);
  93 static void         DisplaySelectedModerationMask(SK_AC *pAC);
  94 static void         DisplayDescrRatio(SK_AC *pAC);
  95
  96 /*******************************************************************************
  97 **
  98 ** Global variables
  99 **
 100 *******************************************************************************/
 101
 102 /*******************************************************************************
 103 **
 104 ** Local variables
 105 **
 106 *******************************************************************************/
 107
 108 /*******************************************************************************
 109 **
 110 ** Global functions
 111 **
 112 *******************************************************************************/
 113
 114 /*******************************************************************************
 115 ** Function     : SkDimModerate
 116 ** Description  : Called in every ISR to check if moderation is to be applied
 117 **                or not for the current number of interrupts
 118 ** Programmer   : Ralph Roesler
 119 ** Last Modified: 22-mar-03
 120 ** Returns      : void (!)
 121 ** Notes        : -
 122 *******************************************************************************/
 123
 124 void
 125 SkDimModerate(SK_AC *pAC) {
 126     unsigned int CurrSysLoad    = 0;  /* expressed in percent */
 127     unsigned int LoadIncrease   = 0;  /* expressed in percent */
 128     SK_U64       ThresholdInts  = 0;
 129     SK_U64       IsrCallsPerSec = 0;
 130
 131 #define M_DIMINFO pAC->DynIrqModInfo
 132
 133     if (!IsIntModEnabled(pAC)) {
 134         if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
 135             CurrSysLoad = GetCurrentSystemLoad(pAC);
 136             if (CurrSysLoad > 75) {
 137                     /*
 138                     ** More than 75% total system load! Enable the moderation
 139                     ** to shield the system against too many interrupts.
 140                     */
 141                     EnableIntMod(pAC);
 142             } else if (CurrSysLoad > M_DIMINFO.PrevSysLoad) {
 143                 LoadIncrease = (CurrSysLoad - M_DIMINFO.PrevSysLoad);
 144                 if (LoadIncrease > ((M_DIMINFO.PrevSysLoad *
 145                                          C_INT_MOD_ENABLE_PERCENTAGE) / 100)) {
 146                     if (CurrSysLoad > 10) {
 147                         /*
 148                         ** More than 50% increase with respect to the
 149                         ** previous load of the system. Most likely this
 150                         ** is due to our ISR-proc...
 151                         */
 152                         EnableIntMod(pAC);
 153                     }
 154                 }
 155             } else {
 156                 /*
 157                 ** Neither too much system load at all nor too much increase
 158                 ** with respect to the previous system load. Hence, we can leave
 159                 ** the ISR-handling like it is without enabling moderation.
 160                 */
 161             }
 162             M_DIMINFO.PrevSysLoad = CurrSysLoad;
 163         }
 164     } else {
 165         if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
 166             ThresholdInts  = ((M_DIMINFO.MaxModIntsPerSec *
 167                                    C_INT_MOD_DISABLE_PERCENTAGE) / 100);
 168             IsrCallsPerSec = GetIsrCalls(pAC);
 169             if (IsrCallsPerSec <= ThresholdInts) {
 170                 /*
 171                 ** The number of interrupts within the last second is
 172                 ** lower than the disable_percentage of the desried
 173                 ** maxrate. Therefore we can disable the moderation.
 174                 */
 175                 DisableIntMod(pAC);
 176                 M_DIMINFO.MaxModIntsPerSec =
 177                    (M_DIMINFO.MaxModIntsPerSecUpperLimit +
 178                     M_DIMINFO.MaxModIntsPerSecLowerLimit) / 2;
 179             } else {
 180                 /*
 181                 ** The number of interrupts per sec is the same as expected.
 182                 ** Evalulate the descriptor-ratio. If it has changed, a resize
 183                 ** in the moderation timer might be usefull
 184                 */
 185                 if (M_DIMINFO.AutoSizing) {
 186                     ResizeDimTimerDuration(pAC);
 187                 }
 188             }
 189         }
 190     }
 191
 192     /*
 193     ** Some information to the log...
 194     */
 195     if (M_DIMINFO.DisplayStats) {
 196         DisplaySelectedModerationType(pAC);
 197         DisplaySelectedModerationMask(pAC);
 198         DisplayDescrRatio(pAC);
 199     }
 200
 201     M_DIMINFO.NbrProcessedDescr = 0;
 202     SetCurrIntCtr(pAC);
 203 }
 204
 205 /*******************************************************************************
 206 ** Function     : SkDimStartModerationTimer
 207 ** Description  : Starts the audit-timer for the dynamic interrupt moderation
 208 ** Programmer   : Ralph Roesler
 209 ** Last Modified: 22-mar-03
 210 ** Returns      : void (!)
 211 ** Notes        : -
 212 *******************************************************************************/
 213
 214 void
 215 SkDimStartModerationTimer(SK_AC *pAC) {
 216     SK_EVPARA    EventParam;   /* Event struct for timer event */
 217
 218     SK_MEMSET((char *) &EventParam, 0, sizeof(EventParam));
 219     EventParam.Para32[0] = SK_DRV_MODERATION_TIMER;
 220     SkTimerStart(pAC, pAC->IoBase, &pAC->DynIrqModInfo.ModTimer,
 221                  SK_DRV_MODERATION_TIMER_LENGTH,
 222                  SKGE_DRV, SK_DRV_TIMER, EventParam);
 223 }
 224
 225 /*******************************************************************************
 226 ** Function     : SkDimEnableModerationIfNeeded
 227 ** Description  : Either enables or disables moderation
 228 ** Programmer   : Ralph Roesler
 229 ** Last Modified: 22-mar-03
 230 ** Returns      : void (!)
 231 ** Notes        : This function is called when a particular adapter is opened
 232 **                There is no Disable function, because when all interrupts
 233 **                might be disable, the moderation timer has no meaning at all
 234 ******************************************************************************/
 235
 236 void
 237 SkDimEnableModerationIfNeeded(SK_AC *pAC) {
 238
 239     if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_STATIC) {
 240         EnableIntMod(pAC);   /* notification print in this function */
 241     } else if (M_DIMINFO.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
 242         SkDimStartModerationTimer(pAC);
 243         if (M_DIMINFO.DisplayStats) {
 244             printk("Dynamic moderation has been enabled\n");
 245         }
 246     } else {
 247         if (M_DIMINFO.DisplayStats) {
 248             printk("No moderation has been enabled\n");
 249         }
 250     }
 251 }
 252
 253 /*******************************************************************************
 254 ** Function     : SkDimDisplayModerationSettings
 255 ** Description  : Displays the current settings regaring interrupt moderation
 256 ** Programmer   : Ralph Roesler
 257 ** Last Modified: 22-mar-03
 258 ** Returns      : void (!)
 259 ** Notes        : -
 260 *******************************************************************************/
 261
 262 void
 263 SkDimDisplayModerationSettings(SK_AC *pAC) {
 264     DisplaySelectedModerationType(pAC);
 265     DisplaySelectedModerationMask(pAC);
 266 }
 267
 268 /*******************************************************************************
 269 **
 270 ** Local functions
 271 **
 272 *******************************************************************************/
 273
 274 /*******************************************************************************
 275 ** Function     : GetCurrentSystemLoad
 276 ** Description  : Retrieves the current system load of the system. This load
 277 **                is evaluated for all processors within the system.
 278 ** Programmer   : Ralph Roesler
 279 ** Last Modified: 22-mar-03
 280 ** Returns      : unsigned int: load expressed in percentage
 281 ** Notes        : The possible range being returned is from 0 up to 100.
 282 **                Whereas 0 means 'no load at all' and 100 'system fully loaded'
 283 **                It is impossible to determine what actually causes the system
 284 **                to be in 100%, but maybe that is due to too much interrupts.
 285 *******************************************************************************/
 286
 287 static unsigned int
 288 GetCurrentSystemLoad(SK_AC *pAC) {
 289         unsigned long jif         = jiffies;
 290         unsigned int  UserTime    = 0;
 291         unsigned int  SystemTime  = 0;
 292         unsigned int  NiceTime    = 0;
 293         unsigned int  IdleTime    = 0;
 294         unsigned int  TotalTime   = 0;
 295         unsigned int  UsedTime    = 0;
 296         unsigned int  SystemLoad  = 0;
 297
 298         /* unsigned int  NbrCpu      = 0; */
 299
 300         /*
 301         ** The following lines have been commented out, because
 302         ** from kernel 2.5.44 onwards, the kernel-owned structure
 303         **
 304         **      struct kernel_stat kstat
 305         **
 306         ** is not marked as an exported symbol in the file
 307         **
 308         **      kernel/ksyms.c
 309         **
 310         ** As a consequence, using this driver as KLM is not possible
 311         ** and any access of the structure kernel_stat via the
 312         ** dedicated macros kstat_cpu(i).cpustat.xxx is to be avoided.
 313         **
 314         ** The kstat-information might be added again in future
 315         ** versions of the 2.5.xx kernel, but for the time being,
 316         ** number of interrupts will serve as indication how much
 317         ** load we currently have...
 318         **
 319         ** for (NbrCpu = 0; NbrCpu < num_online_cpus(); NbrCpu++) {
 320         **      UserTime   = UserTime   + kstat_cpu(NbrCpu).cpustat.user;
 321         **      NiceTime   = NiceTime   + kstat_cpu(NbrCpu).cpustat.nice;
 322         **      SystemTime = SystemTime + kstat_cpu(NbrCpu).cpustat.system;
 323         ** }
 324         */
 325         SK_U64 ThresholdInts  = 0;
 326         SK_U64 IsrCallsPerSec = 0;
 327
 328         ThresholdInts  = ((M_DIMINFO.MaxModIntsPerSec *
 329                            C_INT_MOD_ENABLE_PERCENTAGE) + 100);
 330         IsrCallsPerSec = GetIsrCalls(pAC);
 331         if (IsrCallsPerSec >= ThresholdInts) {
 332             /*
 333             ** We do not know how much the real CPU-load is!
 334             ** Return 80% as a default in order to activate DIM
 335             */
 336             SystemLoad = 80;
 337             return (SystemLoad);
 338         }
 339
 340         UsedTime  = UserTime + NiceTime + SystemTime;
 341
 342         IdleTime  = jif * num_online_cpus() - UsedTime;
 343         TotalTime = UsedTime + IdleTime;
 344
 345         SystemLoad = ( 100 * (UsedTime  - M_DIMINFO.PrevUsedTime) ) /
 346                                                 (TotalTime - M_DIMINFO.PrevTotalTime);
 347
 348         if (M_DIMINFO.DisplayStats) {
 349                 printk("Current system load is: %u\n", SystemLoad);
 350         }
 351
 352         M_DIMINFO.PrevTotalTime = TotalTime;
 353         M_DIMINFO.PrevUsedTime  = UsedTime;
 354
 355         return (SystemLoad);
 356 }
 357
 358 /*******************************************************************************
 359 ** Function     : GetIsrCalls
 360 ** Description  : Depending on the selected moderation mask, this function will
 361 **                return the number of interrupts handled in the previous time-
 362 **                frame. This evaluated number is based on the current number
 363 **                of interrupts stored in PNMI-context and the previous stored
 364 **                interrupts.
 365 ** Programmer   : Ralph Roesler
 366 ** Last Modified: 23-mar-03
 367 ** Returns      : int:   the number of interrupts being executed in the last
 368 **                       timeframe
 369 ** Notes        : It makes only sense to call this function, when dynamic
 370 **                interrupt moderation is applied
 371 *******************************************************************************/
 372
 373 static SK_U64
 374 GetIsrCalls(SK_AC *pAC) {
 375     SK_U64   RxPort0IntDiff = 0;
 376     SK_U64   RxPort1IntDiff = 0;
 377     SK_U64   TxPort0IntDiff = 0;
 378     SK_U64   TxPort1IntDiff = 0;
 379
 380     if (pAC->DynIrqModInfo.MaskIrqModeration == IRQ_MASK_TX_ONLY) {
 381         if (pAC->GIni.GIMacsFound == 2) {
 382             TxPort1IntDiff = pAC->Pnmi.Port[1].TxIntrCts -
 383                              pAC->DynIrqModInfo.PrevPort1TxIntrCts;
 384         }
 385         TxPort0IntDiff = pAC->Pnmi.Port[0].TxIntrCts -
 386                          pAC->DynIrqModInfo.PrevPort0TxIntrCts;
 387     } else if (pAC->DynIrqModInfo.MaskIrqModeration == IRQ_MASK_RX_ONLY) {
 388         if (pAC->GIni.GIMacsFound == 2) {
 389             RxPort1IntDiff = pAC->Pnmi.Port[1].RxIntrCts -
 390                              pAC->DynIrqModInfo.PrevPort1RxIntrCts;
 391         }
 392         RxPort0IntDiff = pAC->Pnmi.Port[0].RxIntrCts -
 393                          pAC->DynIrqModInfo.PrevPort0RxIntrCts;
 394     } else {
 395         if (pAC->GIni.GIMacsFound == 2) {
 396             RxPort1IntDiff = pAC->Pnmi.Port[1].RxIntrCts -
 397                              pAC->DynIrqModInfo.PrevPort1RxIntrCts;
 398             TxPort1IntDiff = pAC->Pnmi.Port[1].TxIntrCts -
 399                              pAC->DynIrqModInfo.PrevPort1TxIntrCts;
 400         }
 401         RxPort0IntDiff = pAC->Pnmi.Port[0].RxIntrCts -
 402                          pAC->DynIrqModInfo.PrevPort0RxIntrCts;
 403         TxPort0IntDiff = pAC->Pnmi.Port[0].TxIntrCts -
 404                          pAC->DynIrqModInfo.PrevPort0TxIntrCts;
 405     }
 406
 407     return (RxPort0IntDiff + RxPort1IntDiff + TxPort0IntDiff + TxPort1IntDiff);
 408 }
 409
 410 /*******************************************************************************
 411 ** Function     : GetRxCalls
 412 ** Description  : This function will return the number of times a receive inter-
 413 **                rupt was processed. This is needed to evaluate any resizing
 414 **                factor.
 415 ** Programmer   : Ralph Roesler
 416 ** Last Modified: 23-mar-03
 417 ** Returns      : SK_U64: the number of RX-ints being processed
 418 ** Notes        : It makes only sense to call this function, when dynamic
 419 **                interrupt moderation is applied
 420 *******************************************************************************/
 421
 422 static SK_U64
 423 GetRxCalls(SK_AC *pAC) {
 424     SK_U64   RxPort0IntDiff = 0;
 425     SK_U64   RxPort1IntDiff = 0;
 426
 427     if (pAC->GIni.GIMacsFound == 2) {
 428         RxPort1IntDiff = pAC->Pnmi.Port[1].RxIntrCts -
 429                          pAC->DynIrqModInfo.PrevPort1RxIntrCts;
 430     }
 431     RxPort0IntDiff = pAC->Pnmi.Port[0].RxIntrCts -
 432                      pAC->DynIrqModInfo.PrevPort0RxIntrCts;
 433
 434     return (RxPort0IntDiff + RxPort1IntDiff);
 435 }
 436
 437 /*******************************************************************************
 438 ** Function     : SetCurrIntCtr
 439 ** Description  : Will store the current number orf occured interrupts in the
 440 **                adapter context. This is needed to evaluated the number of
 441 **                interrupts within a current timeframe.
 442 ** Programmer   : Ralph Roesler
 443 ** Last Modified: 23-mar-03
 444 ** Returns      : void (!)
 445 ** Notes        : -
 446 *******************************************************************************/
 447
 448 static void
 449 SetCurrIntCtr(SK_AC *pAC) {
 450     if (pAC->GIni.GIMacsFound == 2) {
 451         pAC->DynIrqModInfo.PrevPort1RxIntrCts = pAC->Pnmi.Port[1].RxIntrCts;
 452         pAC->DynIrqModInfo.PrevPort1TxIntrCts = pAC->Pnmi.Port[1].TxIntrCts;
 453     }
 454     pAC->DynIrqModInfo.PrevPort0RxIntrCts = pAC->Pnmi.Port[0].RxIntrCts;
 455     pAC->DynIrqModInfo.PrevPort0TxIntrCts = pAC->Pnmi.Port[0].TxIntrCts;
 456 }
 457
 458 /*******************************************************************************
 459 ** Function     : IsIntModEnabled()
 460 ** Description  : Retrieves the current value of the interrupts moderation
 461 **                command register. Its content determines whether any
 462 **                moderation is running or not.
 463 ** Programmer   : Ralph Roesler
 464 ** Last Modified: 23-mar-03
 465 ** Returns      : SK_TRUE  : if mod timer running
 466 **                SK_FALSE : if no moderation is being performed
 467 ** Notes        : -
 468 *******************************************************************************/
 469
 470 static SK_BOOL
 471 IsIntModEnabled(SK_AC *pAC) {
 472     unsigned long CtrCmd;
 473
 474     SK_IN32(pAC->IoBase, B2_IRQM_CTRL, &CtrCmd);
 475     if ((CtrCmd & TIM_START) == TIM_START) {
 476        return SK_TRUE;
 477     } else {
 478        return SK_FALSE;
 479     }
 480 }
 481
 482 /*******************************************************************************
 483 ** Function     : EnableIntMod()
 484 ** Description  : Enables the interrupt moderation using the values stored in
 485 **                in the pAC->DynIntMod data structure
 486 ** Programmer   : Ralph Roesler
 487 ** Last Modified: 22-mar-03
 488 ** Returns      : -
 489 ** Notes        : -
 490 *******************************************************************************/
 491
 492 static void
 493 EnableIntMod(SK_AC *pAC) {
 494     unsigned long ModBase;
 495
 496     if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
 497        ModBase = C_CLK_FREQ_GENESIS / pAC->DynIrqModInfo.MaxModIntsPerSec;
 498     } else {
 499        ModBase = C_CLK_FREQ_YUKON / pAC->DynIrqModInfo.MaxModIntsPerSec;
 500     }
 501
 502     SK_OUT32(pAC->IoBase, B2_IRQM_INI,  ModBase);
 503     SK_OUT32(pAC->IoBase, B2_IRQM_MSK,  pAC->DynIrqModInfo.MaskIrqModeration);
 504     SK_OUT32(pAC->IoBase, B2_IRQM_CTRL, TIM_START);
 505     if (M_DIMINFO.DisplayStats) {
 506         printk("Enabled interrupt moderation (%i ints/sec)\n",
 507                M_DIMINFO.MaxModIntsPerSec);
 508     }
 509 }
 510
 511 /*******************************************************************************
 512 ** Function     : DisableIntMod()
 513 ** Description  : Disbles the interrupt moderation independent of what inter-
 514 **                rupts are running or not
 515 ** Programmer   : Ralph Roesler
 516 ** Last Modified: 23-mar-03
 517 ** Returns      : -
 518 ** Notes        : -
 519 *******************************************************************************/
 520
 521 static void
 522 DisableIntMod(SK_AC *pAC) {
 523
 524     SK_OUT32(pAC->IoBase, B2_IRQM_CTRL, TIM_STOP);
 525     if (M_DIMINFO.DisplayStats) {
 526         printk("Disabled interrupt moderation\n");
 527     }
 528 }
 529
 530 /*******************************************************************************
 531 ** Function     : ResizeDimTimerDuration();
 532 ** Description  : Checks the current used descriptor ratio and resizes the
 533 **                duration timer (longer/smaller) if possible.
 534 ** Programmer   : Ralph Roesler
 535 ** Last Modified: 23-mar-03
 536 ** Returns      : -
 537 ** Notes        : There are both maximum and minimum timer duration value.
 538 **                This function assumes that interrupt moderation is already
 539 **                enabled!
 540 *******************************************************************************/
 541
 542 static void
 543 ResizeDimTimerDuration(SK_AC *pAC) {
 544     SK_BOOL IncreaseTimerDuration;
 545     int     TotalMaxNbrDescr;
 546     int     UsedDescrRatio;
 547     int     RatioDiffAbs;
 548     int     RatioDiffRel;
 549     int     NewMaxModIntsPerSec;
 550     int     ModAdjValue;
 551     long    ModBase;
 552
 553     /*
 554     ** Check first if we are allowed to perform any modification
 555     */
 556     if (IsIntModEnabled(pAC)) {
 557         if (M_DIMINFO.IntModTypeSelect != C_INT_MOD_DYNAMIC) {
 558             return;
 559         } else {
 560             if (M_DIMINFO.ModJustEnabled) {
 561                 M_DIMINFO.ModJustEnabled = SK_FALSE;
 562                 return;
 563             }
 564         }
 565     }
 566
 567     /*
 568     ** If we got until here, we have to evaluate the amount of the
 569     ** descriptor ratio change...
 570     */
 571     TotalMaxNbrDescr = pAC->RxDescrPerRing * GetRxCalls(pAC);
 572     UsedDescrRatio   = (M_DIMINFO.NbrProcessedDescr * 100) / TotalMaxNbrDescr;
 573
 574     if (UsedDescrRatio > M_DIMINFO.PrevUsedDescrRatio) {
 575         RatioDiffAbs = (UsedDescrRatio - M_DIMINFO.PrevUsedDescrRatio);
 576         RatioDiffRel = (RatioDiffAbs * 100) / UsedDescrRatio;
 577         M_DIMINFO.PrevUsedDescrRatio = UsedDescrRatio;
 578         IncreaseTimerDuration = SK_FALSE;  /* in other words: DECREASE */
 579     } else if (UsedDescrRatio < M_DIMINFO.PrevUsedDescrRatio) {
 580         RatioDiffAbs = (M_DIMINFO.PrevUsedDescrRatio - UsedDescrRatio);
 581         RatioDiffRel = (RatioDiffAbs * 100) / M_DIMINFO.PrevUsedDescrRatio;
 582         M_DIMINFO.PrevUsedDescrRatio = UsedDescrRatio;
 583         IncreaseTimerDuration = SK_TRUE;   /* in other words: INCREASE */
 584     } else {
 585         RatioDiffAbs = (M_DIMINFO.PrevUsedDescrRatio - UsedDescrRatio);
 586         RatioDiffRel = (RatioDiffAbs * 100) / M_DIMINFO.PrevUsedDescrRatio;
 587         M_DIMINFO.PrevUsedDescrRatio = UsedDescrRatio;
 588         IncreaseTimerDuration = SK_TRUE;   /* in other words: INCREASE */
 589     }
 590
 591     /*
 592     ** Now we can determine the change in percent
 593     */
 594     if ((RatioDiffRel >= 0) && (RatioDiffRel <= 5) ) {
 595        ModAdjValue = 1;  /*  1% change - maybe some other value in future */
 596     } else if ((RatioDiffRel > 5) && (RatioDiffRel <= 10) ) {
 597        ModAdjValue = 1;  /*  1% change - maybe some other value in future */
 598     } else if ((RatioDiffRel > 10) && (RatioDiffRel <= 15) ) {
 599        ModAdjValue = 1;  /*  1% change - maybe some other value in future */
 600     } else {
 601        ModAdjValue = 1;  /*  1% change - maybe some other value in future */
 602     }
 603
 604     if (IncreaseTimerDuration) {
 605        NewMaxModIntsPerSec =  M_DIMINFO.MaxModIntsPerSec +
 606                              (M_DIMINFO.MaxModIntsPerSec * ModAdjValue) / 100;
 607     } else {
 608        NewMaxModIntsPerSec =  M_DIMINFO.MaxModIntsPerSec -
 609                              (M_DIMINFO.MaxModIntsPerSec * ModAdjValue) / 100;
 610     }
 611
 612     /*
 613     ** Check if we exceed boundaries...
 614     */
 615     if ( (NewMaxModIntsPerSec > M_DIMINFO.MaxModIntsPerSecUpperLimit) ||
 616          (NewMaxModIntsPerSec < M_DIMINFO.MaxModIntsPerSecLowerLimit)) {
 617         if (M_DIMINFO.DisplayStats) {
 618             printk("Cannot change ModTim from %i to %i ints/sec\n",
 619                    M_DIMINFO.MaxModIntsPerSec, NewMaxModIntsPerSec);
 620         }
 621         return;
 622     } else {
 623         if (M_DIMINFO.DisplayStats) {
 624             printk("Resized ModTim from %i to %i ints/sec\n",
 625                    M_DIMINFO.MaxModIntsPerSec, NewMaxModIntsPerSec);
 626         }
 627     }
 628
 629     M_DIMINFO.MaxModIntsPerSec = NewMaxModIntsPerSec;
 630
 631     if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
 632         ModBase = C_CLK_FREQ_GENESIS / pAC->DynIrqModInfo.MaxModIntsPerSec;
 633     } else {
 634         ModBase = C_CLK_FREQ_YUKON / pAC->DynIrqModInfo.MaxModIntsPerSec;
 635     }
 636
 637     /*
 638     ** We do not need to touch any other registers
 639     */
 640     SK_OUT32(pAC->IoBase, B2_IRQM_INI, ModBase);
 641 }
 642
 643 /*******************************************************************************
 644 ** Function     : DisplaySelectedModerationType()
 645 ** Description  : Displays what type of moderation we have
 646 ** Programmer   : Ralph Roesler
 647 ** Last Modified: 23-mar-03
 648 ** Returns      : void!
 649 ** Notes        : -
 650 *******************************************************************************/
 651
 652 static void
 653 DisplaySelectedModerationType(SK_AC *pAC) {
 654
 655     if (pAC->DynIrqModInfo.DisplayStats) {
 656         if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_STATIC) {
 657              printk("Static int moderation runs with %i INTS/sec\n",
 658                     pAC->DynIrqModInfo.MaxModIntsPerSec);
 659         } else if (pAC->DynIrqModInfo.IntModTypeSelect == C_INT_MOD_DYNAMIC) {
 660              if (IsIntModEnabled(pAC)) {
 661                 printk("Dynamic int moderation runs with %i INTS/sec\n",
 662                        pAC->DynIrqModInfo.MaxModIntsPerSec);
 663              } else {
 664                 printk("Dynamic int moderation currently not applied\n");
 665              }
 666         } else {
 667              printk("No interrupt moderation selected!\n");
 668         }
 669     }
 670 }
 671
 672 /*******************************************************************************
 673 ** Function     : DisplaySelectedModerationMask()
 674 ** Description  : Displays what interrupts are moderated
 675 ** Programmer   : Ralph Roesler
 676 ** Last Modified: 23-mar-03
 677 ** Returns      : void!
 678 ** Notes        : -
 679 *******************************************************************************/
 680
 681 static void
 682 DisplaySelectedModerationMask(SK_AC *pAC) {
 683
 684     if (pAC->DynIrqModInfo.DisplayStats) {
 685         if (pAC->DynIrqModInfo.IntModTypeSelect != C_INT_MOD_NONE) {
 686             switch (pAC->DynIrqModInfo.MaskIrqModeration) {
 687                 case IRQ_MASK_TX_ONLY:
 688                    printk("Only Tx-interrupts are moderated\n");
 689                    break;
 690                 case IRQ_MASK_RX_ONLY:
 691                    printk("Only Rx-interrupts are moderated\n");
 692                    break;
 693                 case IRQ_MASK_SP_ONLY:
 694                    printk("Only special-interrupts are moderated\n");
 695                    break;
 696                 case IRQ_MASK_TX_RX:
 697                    printk("Tx- and Rx-interrupts are moderated\n");
 698                    break;
 699                 case IRQ_MASK_SP_RX:
 700                    printk("Special- and Rx-interrupts are moderated\n");
 701                    break;
 702                 case IRQ_MASK_SP_TX:
 703                    printk("Special- and Tx-interrupts are moderated\n");
 704                    break;
 705                 case IRQ_MASK_RX_TX_SP:
 706                    printk("All Rx-, Tx and special-interrupts are moderated\n");
 707                    break;
 708                 default:
 709                    printk("Don't know what is moderated\n");
 710                    break;
 711             }
 712         } else {
 713             printk("No specific interrupts masked for moderation\n");
 714         }
 715     }
 716 }
 717
 718 /*******************************************************************************
 719 ** Function     : DisplayDescrRatio
 720 ** Description  : Like the name states...
 721 ** Programmer   : Ralph Roesler
 722 ** Last Modified: 23-mar-03
 723 ** Returns      : void!
 724 ** Notes        : -
 725 *******************************************************************************/
 726
 727 static void
 728 DisplayDescrRatio(SK_AC *pAC) {
 729     int TotalMaxNbrDescr = 0;
 730
 731     if (pAC->DynIrqModInfo.DisplayStats) {
 732         TotalMaxNbrDescr = pAC->RxDescrPerRing * GetRxCalls(pAC);
 733         printk("Ratio descriptors: %i/%i\n",
 734                M_DIMINFO.NbrProcessedDescr, TotalMaxNbrDescr);
 735     }
 736 }
 737
 738 /*******************************************************************************
 739 **
 740 ** End of file
 741 **
 742 *******************************************************************************/