[PATCH] sk98lin: add permanent address support
[linux-2.6] / drivers / net / sk98lin / skqueue.c
1 /******************************************************************************
2  *
3  * Name:        skqueue.c
4  * Project:     Gigabit Ethernet Adapters, Event Scheduler Module
5  * Version:     $Revision: 1.20 $
6  * Date:        $Date: 2003/09/16 13:44:00 $
7  * Purpose:     Management of an event queue.
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  *      Event queue and dispatcher
28  */
29 #if (defined(DEBUG) || ((!defined(LINT)) && (!defined(SK_SLIM))))
30 static const char SysKonnectFileId[] =
31         "@(#) $Id: skqueue.c,v 1.20 2003/09/16 13:44:00 rschmidt Exp $ (C) Marvell.";
32 #endif
33
34 #include "h/skdrv1st.h"         /* Driver Specific Definitions */
35 #include "h/skqueue.h"          /* Queue Definitions */
36 #include "h/skdrv2nd.h"         /* Adapter Control- and Driver specific Def. */
37
38 #ifdef __C2MAN__
39 /*
40         Event queue management.
41
42         General Description:
43
44  */
45 intro()
46 {}
47 #endif
48
49 #define PRINTF(a,b,c)
50
51 /*
52  * init event queue management
53  *
54  * Must be called during init level 0.
55  */
56 void    SkEventInit(
57 SK_AC   *pAC,   /* Adapter context */
58 SK_IOC  Ioc,    /* IO context */
59 int             Level)  /* Init level */
60 {
61         switch (Level) {
62         case SK_INIT_DATA:
63                 pAC->Event.EvPut = pAC->Event.EvGet = pAC->Event.EvQueue;
64                 break;
65         default:
66                 break;
67         }
68 }
69
70 /*
71  * add event to queue
72  */
73 void    SkEventQueue(
74 SK_AC           *pAC,   /* Adapters context */
75 SK_U32          Class,  /* Event Class */
76 SK_U32          Event,  /* Event to be queued */
77 SK_EVPARA       Para)   /* Event parameter */
78 {
79         pAC->Event.EvPut->Class = Class;
80         pAC->Event.EvPut->Event = Event;
81         pAC->Event.EvPut->Para = Para;
82         
83         if (++pAC->Event.EvPut == &pAC->Event.EvQueue[SK_MAX_EVENT])
84                 pAC->Event.EvPut = pAC->Event.EvQueue;
85
86         if (pAC->Event.EvPut == pAC->Event.EvGet) {
87                 SK_ERR_LOG(pAC, SK_ERRCL_NORES, SKERR_Q_E001, SKERR_Q_E001MSG);
88         }
89 }
90
91 /*
92  * event dispatcher
93  *      while event queue is not empty
94  *              get event from queue
95  *              send command to state machine
96  *      end
97  *      return error reported by individual Event function
98  *              0 if no error occured.
99  */
100 int     SkEventDispatcher(
101 SK_AC   *pAC,   /* Adapters Context */
102 SK_IOC  Ioc)    /* Io context */
103 {
104         SK_EVENTELEM    *pEv;   /* pointer into queue */
105         SK_U32                  Class;
106         int                     Rtv;
107
108         pEv = pAC->Event.EvGet;
109         
110         PRINTF("dispatch get %x put %x\n", pEv, pAC->Event.ev_put);
111         
112         while (pEv != pAC->Event.EvPut) {
113                 PRINTF("dispatch Class %d Event %d\n", pEv->Class, pEv->Event);
114
115                 switch (Class = pEv->Class) {
116 #ifndef SK_USE_LAC_EV
117 #ifndef SK_SLIM
118                 case SKGE_RLMT:         /* RLMT Event */
119                         Rtv = SkRlmtEvent(pAC, Ioc, pEv->Event, pEv->Para);
120                         break;
121                 case SKGE_I2C:          /* I2C Event */
122                         Rtv = SkI2cEvent(pAC, Ioc, pEv->Event, pEv->Para);
123                         break;
124                 case SKGE_PNMI:         /* PNMI Event */
125                         Rtv = SkPnmiEvent(pAC, Ioc, pEv->Event, pEv->Para);
126                         break;
127 #endif  /* not SK_SLIM */
128 #endif  /* not SK_USE_LAC_EV */
129                 case SKGE_DRV:          /* Driver Event */
130                         Rtv = SkDrvEvent(pAC, Ioc, pEv->Event, pEv->Para);
131                         break;
132 #ifndef SK_USE_SW_TIMER
133                 case SKGE_HWAC:
134                         Rtv = SkGeSirqEvent(pAC, Ioc, pEv->Event, pEv->Para);
135                         break;
136 #else /* !SK_USE_SW_TIMER */
137         case SKGE_SWT :
138                         Rtv = SkSwtEvent(pAC, Ioc, pEv->Event, pEv->Para);
139                         break;
140 #endif /* !SK_USE_SW_TIMER */
141 #ifdef SK_USE_LAC_EV
142                 case SKGE_LACP :
143                         Rtv = SkLacpEvent(pAC, Ioc, pEv->Event, pEv->Para);
144                         break;
145                 case SKGE_RSF :
146                         Rtv = SkRsfEvent(pAC, Ioc, pEv->Event, pEv->Para);
147                         break;
148                 case SKGE_MARKER :
149                         Rtv = SkMarkerEvent(pAC, Ioc, pEv->Event, pEv->Para);
150                         break;
151                 case SKGE_FD :
152                         Rtv = SkFdEvent(pAC, Ioc, pEv->Event, pEv->Para);
153                         break;
154 #endif /* SK_USE_LAC_EV */
155 #ifdef  SK_USE_CSUM
156                 case SKGE_CSUM :
157                         Rtv = SkCsEvent(pAC, Ioc, pEv->Event, pEv->Para);
158                         break;
159 #endif  /* SK_USE_CSUM */
160                 default :
161                         SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_Q_E002, SKERR_Q_E002MSG);
162                         Rtv = 0;
163                 }
164
165                 if (Rtv != 0) {
166                         return(Rtv);
167                 }
168
169                 if (++pEv == &pAC->Event.EvQueue[SK_MAX_EVENT])
170                         pEv = pAC->Event.EvQueue;
171
172                 /* Renew get: it is used in queue_events to detect overruns */
173                 pAC->Event.EvGet = pEv;
174         }
175
176         return(0);
177 }
178
179 /* End of file */