drivers/net/sk98lin/skqueue.c

   1 /******************************************************************************
   2  *
   3  * Name:        skqueue.c
   4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
   5  * Version:     $Revision: 1.18 $
   6  * Date:        $Date: 2002/05/07 14:11:11 $
   7  * Purpose:     Management of an event queue.
   8  *
   9  ******************************************************************************/
  10
  11 /******************************************************************************
  12  *
  13  *      (C)Copyright 1998,1999 SysKonnect,
  14  *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
  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  * History:
  28  *
  29  *      $Log: skqueue.c,v $
  30  *      Revision 1.18  2002/05/07 14:11:11  rwahl
  31  *      Fixed Watcom Precompiler error.
  32  *
  33  *      Revision 1.17  2002/03/25 10:06:41  mkunz
  34  *      SkIgnoreEvent deleted
  35  *
  36  *      Revision 1.16  2002/03/15 10:51:59  mkunz
  37  *      Added event classes for link aggregation
  38  *
  39  *      Revision 1.15  1999/11/22 13:36:29  cgoos
  40  *      Changed license header to GPL.
  41  *
  42  *      Revision 1.14  1998/10/15 15:11:35  gklug
  43  *      fix: ID_sccs to SysKonnectFileId
  44  *
  45  *      Revision 1.13  1998/09/08 08:47:52  gklug
  46  *      add: init level handling
  47  *
  48  *      Revision 1.12  1998/09/08 07:43:20  gklug
  49  *      fix: Sirq Event function name
  50  *
  51  *      Revision 1.11  1998/09/08 05:54:34  gklug
  52  *      chg: define SK_CSUM is replaced by SK_USE_CSUM
  53  *
  54  *      Revision 1.10  1998/09/03 14:14:49  gklug
  55  *      add: CSUM and HWAC Eventclass and function.
  56  *
  57  *      Revision 1.9  1998/08/19 09:50:50  gklug
  58  *      fix: remove struct keyword from c-code (see CCC) add typedefs
  59  *
  60  *      Revision 1.8  1998/08/17 13:43:11  gklug
  61  *      chg: Parameter will be union of 64bit para, 2 times SK_U32 or SK_PTR
  62  *
  63  *      Revision 1.7  1998/08/14 07:09:11  gklug
  64  *      fix: chg pAc -> pAC
  65  *
  66  *      Revision 1.6  1998/08/11 12:13:14  gklug
  67  *      add: return code feature of Event service routines
  68  *      add: correct Error log calls
  69  *
  70  *      Revision 1.5  1998/08/07 12:53:45  gklug
  71  *      fix: first compiled version
  72  *
  73  *      Revision 1.4  1998/08/07 09:20:48  gklug
  74  *      adapt functions to C coding conventions.
  75  *
  76  *      Revision 1.3  1998/08/05 11:29:32  gklug
  77  *      rmv: Timer event entry. Timer will queue event directly
  78  *
  79  *      Revision 1.2  1998/07/31 11:22:40  gklug
  80  *      Initial version
  81  *
  82  *      Revision 1.1  1998/07/30 15:14:01  gklug
  83  *      Initial version. Adapted from SMT
  84  *
  85  *
  86  *
  87  ******************************************************************************/
  88
  89
  90 #include <config.h>
  91
  92 /*
  93         Event queue and dispatcher
  94 */
  95 static const char SysKonnectFileId[] =
  96         "$Header: /usr56/projects/ge/schedule/skqueue.c,v 1.18 2002/05/07 14:11:11 rwahl Exp $" ;
  97
  98 #include "h/skdrv1st.h"         /* Driver Specific Definitions */
  99 #include "h/skqueue.h"          /* Queue Definitions */
 100 #include "h/skdrv2nd.h"         /* Adapter Control- and Driver specific Def. */
 101
 102 #ifdef __C2MAN__
 103 /*
 104         Event queue management.
 105
 106         General Description:
 107
 108  */
 109 intro()
 110 {}
 111 #endif
 112
 113 #define PRINTF(a,b,c)
 114
 115 /*
 116  * init event queue management
 117  *
 118  * Must be called during init level 0.
 119  */
 120 void    SkEventInit(
 121 SK_AC   *pAC,   /* Adapter context */
 122 SK_IOC  Ioc,    /* IO context */
 123 int     Level)  /* Init level */
 124 {
 125         switch (Level) {
 126         case SK_INIT_DATA:
 127                 pAC->Event.EvPut = pAC->Event.EvGet = pAC->Event.EvQueue ;
 128                 break;
 129         default:
 130                 break;
 131         }
 132 }
 133
 134 /*
 135  * add event to queue
 136  */
 137 void    SkEventQueue(
 138 SK_AC           *pAC,   /* Adapters context */
 139 SK_U32          Class,  /* Event Class */
 140 SK_U32          Event,  /* Event to be queued */
 141 SK_EVPARA       Para)   /* Event parameter */
 142 {
 143         pAC->Event.EvPut->Class = Class ;
 144         pAC->Event.EvPut->Event = Event ;
 145         pAC->Event.EvPut->Para = Para ;
 146         if (++pAC->Event.EvPut == &pAC->Event.EvQueue[SK_MAX_EVENT])
 147                 pAC->Event.EvPut = pAC->Event.EvQueue ;
 148
 149         if (pAC->Event.EvPut == pAC->Event.EvGet) {
 150                 SK_ERR_LOG(pAC, SK_ERRCL_NORES, SKERR_Q_E001, SKERR_Q_E001MSG) ;
 151         }
 152 }
 153
 154 /*
 155  * event dispatcher
 156  *      while event queue is not empty
 157  *              get event from queue
 158  *              send command to state machine
 159  *      end
 160  *      return error reported by individual Event function
 161  *              0 if no error occured.
 162  */
 163 int     SkEventDispatcher(
 164 SK_AC   *pAC,   /* Adapters Context */
 165 SK_IOC  Ioc)    /* Io context */
 166 {
 167         SK_EVENTELEM    *pEv ;  /* pointer into queue */
 168         SK_U32                  Class ;
 169         int                     Rtv ;
 170
 171         pEv = pAC->Event.EvGet ;
 172         PRINTF("dispatch get %x put %x\n",pEv,pAC->Event.ev_put) ;
 173         while (pEv != pAC->Event.EvPut) {
 174                 PRINTF("dispatch Class %d Event %d\n",pEv->Class,pEv->Event) ;
 175                 switch(Class = pEv->Class) {
 176 #ifndef SK_USE_LAC_EV
 177                 case SKGE_RLMT :        /* RLMT Event */
 178                         Rtv = SkRlmtEvent(pAC,Ioc,pEv->Event,pEv->Para);
 179                         break ;
 180                 case SKGE_I2C :         /* I2C Event */
 181                         Rtv = SkI2cEvent(pAC,Ioc,pEv->Event,pEv->Para);
 182                         break ;
 183                 case SKGE_PNMI :
 184                         Rtv = SkPnmiEvent(pAC,Ioc,pEv->Event,pEv->Para);
 185                         break ;
 186 #endif /* SK_USE_LAC_EV */
 187                 case SKGE_DRV :         /* Driver Event */
 188                         Rtv = SkDrvEvent(pAC,Ioc,pEv->Event,pEv->Para);
 189                         break ;
 190 #ifndef SK_USE_SW_TIMER
 191                 case SKGE_HWAC :
 192                         Rtv = SkGeSirqEvent(pAC,Ioc,pEv->Event,pEv->Para);
 193                         break ;
 194 #else /* !SK_USE_SW_TIMER */
 195         case SKGE_SWT :
 196                         Rtv = SkSwtEvent(pAC,Ioc,pEv->Event,pEv->Para);
 197                         break ;
 198 #endif /* !SK_USE_SW_TIMER */
 199 #ifdef SK_USE_LAC_EV
 200                 case SKGE_LACP :
 201                         Rtv = SkLacpEvent(pAC,Ioc,pEv->Event,pEv->Para);
 202                         break ;
 203                 case SKGE_RSF :
 204                         Rtv = SkRsfEvent(pAC,Ioc,pEv->Event,pEv->Para);
 205                         break ;
 206                 case SKGE_MARKER :
 207                         Rtv = SkMarkerEvent(pAC,Ioc,pEv->Event,pEv->Para);
 208                         break ;
 209                 case SKGE_FD :
 210                         Rtv = SkFdEvent(pAC,Ioc,pEv->Event,pEv->Para);
 211                         break ;
 212 #endif /* SK_USE_LAC_EV */
 213 #ifdef  SK_USE_CSUM
 214                 case SKGE_CSUM :
 215                         Rtv = SkCsEvent(pAC,Ioc,pEv->Event,pEv->Para);
 216                         break ;
 217 #endif  /* SK_USE_CSUM */
 218                 default :
 219                         SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_Q_E002,
 220                                 SKERR_Q_E002MSG) ;
 221                         Rtv = 0;
 222                 }
 223
 224                 if (Rtv != 0) {
 225                         return(Rtv) ;
 226                 }
 227
 228                 if (++pEv == &pAC->Event.EvQueue[SK_MAX_EVENT])
 229                         pEv = pAC->Event.EvQueue ;
 230
 231                 /* Renew get: it is used in queue_events to detect overruns */
 232                 pAC->Event.EvGet = pEv;
 233         }
 234
 235         return(0) ;
 236 }
 237
 238 /* End of file */