Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 /******************************************************************************
  2  *
  3  *      (C)Copyright 1998,1999 SysKonnect,
  4  *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
  5  *
  6  *      See the file "skfddi.c" for further information.
  7  *
  8  *      This program is free software; you can redistribute it and/or modify
  9  *      it under the terms of the GNU General Public License as published by
 10  *      the Free Software Foundation; either version 2 of the License, or
 11  *      (at your option) any later version.
 12  *
 13  *      The information in this file is provided "AS IS" without warranty.
 14  *
 15  ******************************************************************************/
 16 
 17 /*
 18         SMT Event Queue Management
 19 */
 20 
 21 #include "h/types.h"
 22 #include "h/fddi.h"
 23 #include "h/smc.h"
 24 
 25 #ifndef lint
 26 static const char ID_sccs[] = "@(#)queue.c      2.9 97/08/04 (C) SK " ;
 27 #endif
 28 
 29 #define PRINTF(a,b,c)
 30 
 31 /*
 32  * init event queue management
 33  */
 34 void ev_init(struct s_smc *smc)
 35 {
 36         smc->q.ev_put = smc->q.ev_get = smc->q.ev_queue ;
 37 }
 38 
 39 /*
 40  * add event to queue
 41  */
 42 void queue_event(struct s_smc *smc, int class, int event)
 43 {
 44         PRINTF("queue class %d event %d\n",class,event) ;
 45         smc->q.ev_put->class = class ;
 46         smc->q.ev_put->event = event ;
 47         if (++smc->q.ev_put == &smc->q.ev_queue[MAX_EVENT])
 48                 smc->q.ev_put = smc->q.ev_queue ;
 49 
 50         if (smc->q.ev_put == smc->q.ev_get) {
 51                 SMT_ERR_LOG(smc,SMT_E0137, SMT_E0137_MSG) ;
 52         }
 53 }
 54 
 55 /*
 56  * timer_event is called from HW timer package.
 57  */
 58 void timer_event(struct s_smc *smc, u_long token)
 59 {
 60         PRINTF("timer event class %d token %d\n",
 61                 EV_T_CLASS(token),
 62                 EV_T_EVENT(token)) ;
 63         queue_event(smc,EV_T_CLASS(token),EV_T_EVENT(token));
 64 }
 65 
 66 /*
 67  * event dispatcher
 68  *      while event queue is not empty
 69  *              get event from queue
 70  *              send command to state machine
 71  *      end
 72  */
 73 void ev_dispatcher(struct s_smc *smc)
 74 {
 75         struct event_queue *ev ;        /* pointer into queue */
 76         int             class ;
 77 
 78         ev = smc->q.ev_get ;
 79         PRINTF("dispatch get %x put %x\n",ev,smc->q.ev_put) ;
 80         while (ev != smc->q.ev_put) {
 81                 PRINTF("dispatch class %d event %d\n",ev->class,ev->event) ;
 82                 switch(class = ev->class) {
 83                 case EVENT_ECM :                /* Entity Corordination  Man. */
 84                         ecm(smc,(int)ev->event) ;
 85                         break ;
 86                 case EVENT_CFM :                /* Configuration Man. */
 87                         cfm(smc,(int)ev->event) ;
 88                         break ;
 89                 case EVENT_RMT :                /* Ring Man. */
 90                         rmt(smc,(int)ev->event) ;
 91                         break ;
 92                 case EVENT_SMT :
 93                         smt_event(smc,(int)ev->event) ;
 94                         break ;
 95 #ifdef  CONCENTRATOR
 96                 case 99 :
 97                         timer_test_event(smc,(int)ev->event) ;
 98                         break ;
 99 #endif
100                 case EVENT_PCMA :               /* PHY A */
101                 case EVENT_PCMB :               /* PHY B */
102                 default :
103                         if (class >= EVENT_PCMA &&
104                             class < EVENT_PCMA + NUMPHYS) {
105                                 pcm(smc,class - EVENT_PCMA,(int)ev->event) ;
106                                 break ;
107                         }
108                         SMT_PANIC(smc,SMT_E0121, SMT_E0121_MSG) ;
109                         return ;
110                 }
111 
112                 if (++ev == &smc->q.ev_queue[MAX_EVENT])
113                         ev = smc->q.ev_queue ;
114 
115                 /* Renew get: it is used in queue_events to detect overruns */
116                 smc->q.ev_get = ev;
117         }
118 }
119 
120 /*
121  * smt_online connects to or disconnects from the ring
122  * MUST be called to initiate connection establishment
123  *
124  *      on      0       disconnect
125  *      on      1       connect
126  */
127 u_short smt_online(struct s_smc *smc, int on)
128 {
129         queue_event(smc,EVENT_ECM,on ? EC_CONNECT : EC_DISCONNECT) ;
130         ev_dispatcher(smc) ;
131         return(smc->mib.fddiSMTCF_State) ;
132 }
133 
134 /*
135  * set SMT flag to value
136  *      flag            flag name
137  *      value           flag value
138  * dump current flag setting
139  */
140 #ifdef  CONCENTRATOR
141 void do_smt_flag(struct s_smc *smc, char *flag, int value)
142 {
143 #ifdef  DEBUG
144         struct smt_debug        *deb;
145 
146         SK_UNUSED(smc) ;
147 
148 #ifdef  DEBUG_BRD
149         deb = &smc->debug;
150 #else
151         deb = &debug;
152 #endif
153         if (!strcmp(flag,"smt"))
154                 deb->d_smt = value ;
155         else if (!strcmp(flag,"smtf"))
156                 deb->d_smtf = value ;
157         else if (!strcmp(flag,"pcm"))
158                 deb->d_pcm = value ;
159         else if (!strcmp(flag,"rmt"))
160                 deb->d_rmt = value ;
161         else if (!strcmp(flag,"cfm"))
162                 deb->d_cfm = value ;
163         else if (!strcmp(flag,"ecm"))
164                 deb->d_ecm = value ;
165         printf("smt     %d\n",deb->d_smt) ;
166         printf("smtf    %d\n",deb->d_smtf) ;
167         printf("pcm     %d\n",deb->d_pcm) ;
168         printf("rmt     %d\n",deb->d_rmt) ;
169         printf("cfm     %d\n",deb->d_cfm) ;
170         printf("ecm     %d\n",deb->d_ecm) ;
171 #endif  /* DEBUG */
172 }
173 #endif
174 
  This page was automatically generated by the LXR engine.