File: /usr/src/linux/drivers/s390/net/fsm.h
1 /* $Id: fsm.h,v 1.3 2001/06/18 16:49:19 felfert Exp $
2 */
3 #ifndef _FSM_H_
4 #define _FSM_H_
5
6 #include <linux/kernel.h>
7 #include <linux/types.h>
8 #include <linux/timer.h>
9 #include <linux/time.h>
10 #include <linux/slab.h>
11 #include <linux/sched.h>
12 #include <linux/string.h>
13 #include <asm/atomic.h>
14
15 /**
16 * Define this to get debugging messages.
17 */
18 #define FSM_DEBUG 0
19
20 /**
21 * Define this to get debugging massages for
22 * timer handling.
23 */
24 #define FSM_TIMER_DEBUG 0
25
26 /**
27 * Define these to record a history of
28 * Events/Statechanges and print it if a
29 * action_function is not found.
30 */
31 #define FSM_DEBUG_HISTORY 0
32 #define FSM_HISTORY_SIZE 40
33
34 struct fsm_instance_t;
35
36 /**
37 * Definition of an action function, called by a FSM
38 */
39 typedef void (*fsm_function_t)(struct fsm_instance_t *, int, void *);
40
41 /**
42 * Internal jump table for a FSM
43 */
44 typedef struct {
45 fsm_function_t *jumpmatrix;
46 int nr_events;
47 int nr_states;
48 const char **event_names;
49 const char **state_names;
50 } fsm;
51
52 #if FSM_DEBUG_HISTORY
53 /**
54 * Element of State/Event history used for debugging.
55 */
56 typedef struct {
57 int state;
58 int event;
59 } fsm_history;
60 #endif
61
62 /**
63 * Representation of a FSM
64 */
65 typedef struct fsm_instance_t {
66 fsm *f;
67 atomic_t state;
68 char name[16];
69 void *userdata;
70 int userint;
71 #if FSM_DEBUG_HISTORY
72 int history_index;
73 int history_size;
74 fsm_history history[FSM_HISTORY_SIZE];
75 #endif
76 } fsm_instance;
77
78 /**
79 * Description of a state-event combination
80 */
81 typedef struct {
82 int cond_state;
83 int cond_event;
84 fsm_function_t function;
85 } fsm_node;
86
87 /**
88 * Description of a FSM Timer.
89 */
90 typedef struct {
91 fsm_instance *fi;
92 struct timer_list tl;
93 int expire_event;
94 void *event_arg;
95 } fsm_timer;
96
97 /**
98 * Creates an FSM
99 *
100 * @param name Name of this instance for logging purposes.
101 * @param state_names An array of names for all states for logging purposes.
102 * @param event_names An array of names for all events for logging purposes.
103 * @param nr_states Number of states for this instance.
104 * @param nr_events Number of events for this instance.
105 * @param tmpl An array of fsm_nodes, describing this FSM.
106 * @param tmpl_len Length of the describing array.
107 * @param order Parameter for allocation of the FSM data structs.
108 */
109 extern fsm_instance *
110 init_fsm(char *name, const char **state_names,
111 const char **event_names,
112 int nr_states, int nr_events, const fsm_node *tmpl,
113 int tmpl_len, int order);
114
115 /**
116 * Releases an FSM
117 *
118 * @param fi Pointer to an FSM, previously created with init_fsm.
119 */
120 extern void kfree_fsm(fsm_instance *fi);
121
122 #if FSM_DEBUG_HISTORY
123 extern void
124 fsm_print_history(fsm_instance *fi);
125
126 extern void
127 fsm_record_history(fsm_instance *fi, int state, int event);
128 #endif
129
130 /**
131 * Emits an event to a FSM.
132 * If an action function is defined for the current state/event combination,
133 * this function is called.
134 *
135 * @param fi Pointer to FSM which should receive the event.
136 * @param event The event do be delivered.
137 * @param arg A generic argument, handed to the action function.
138 *
139 * @return 0 on success,
140 * 1 if current state or event is out of range
141 * !0 if state and event in range, but no action defined.
142 */
143 extern __inline__ int
144 fsm_event(fsm_instance *fi, int event, void *arg)
145 {
146 fsm_function_t r;
147 int state = atomic_read(&fi->state);
148
149 if ((state >= fi->f->nr_states) ||
150 (event >= fi->f->nr_events) ) {
151 printk(KERN_ERR "fsm(%s): Invalid state st(%ld/%ld) ev(%d/%ld)\n",
152 fi->name, (long)state,(long)fi->f->nr_states, event,
153 (long)fi->f->nr_events);
154 #if FSM_DEBUG_HISTORY
155 fsm_print_history(fi);
156 #endif
157 return 1;
158 }
159 r = fi->f->jumpmatrix[fi->f->nr_states * event + state];
160 if (r) {
161 #if FSM_DEBUG
162 printk(KERN_DEBUG "fsm(%s): state %s event %s\n",
163 fi->name, fi->f->state_names[state],
164 fi->f->event_names[event]);
165 #endif
166 #if FSM_DEBUG_HISTORY
167 fsm_record_history(fi, state, event);
168 #endif
169 r(fi, event, arg);
170 return 0;
171 } else {
172 #if FSM_DEBUG || FSM_DEBUG_HISTORY
173 printk(KERN_DEBUG "fsm(%s): no function for event %s in state %s\n",
174 fi->name, fi->f->event_names[event],
175 fi->f->state_names[state]);
176 #endif
177 #if FSM_DEBUG_HISTORY
178 fsm_print_history(fi);
179 #endif
180 return !0;
181 }
182 }
183
184 /**
185 * Modifies the state of an FSM.
186 * This does <em>not</em> trigger an event or calls an action function.
187 *
188 * @param fi Pointer to FSM
189 * @param state The new state for this FSM.
190 */
191 extern __inline__ void
192 fsm_newstate(fsm_instance *fi, int newstate)
193 {
194 atomic_set(&fi->state,newstate);
195 #if FSM_DEBUG_HISTORY
196 fsm_record_history(fi, newstate, -1);
197 #endif
198 #if FSM_DEBUG
199 printk(KERN_DEBUG "fsm(%s): New state %s\n", fi->name,
200 fi->f->state_names[newstate]);
201 #endif
202 }
203
204 /**
205 * Retrieves the state of an FSM
206 *
207 * @param fi Pointer to FSM
208 *
209 * @return The current state of the FSM.
210 */
211 extern __inline__ int
212 fsm_getstate(fsm_instance *fi)
213 {
214 return atomic_read(&fi->state);
215 }
216
217 /**
218 * Retrieves the name of the state of an FSM
219 *
220 * @param fi Pointer to FSM
221 *
222 * @return The current state of the FSM in a human readable form.
223 */
224 extern const char *fsm_getstate_str(fsm_instance *fi);
225
226 /**
227 * Initializes a timer for an FSM.
228 * This prepares an fsm_timer for usage with fsm_addtimer.
229 *
230 * @param fi Pointer to FSM
231 * @param timer The timer to be initialized.
232 */
233 extern void fsm_settimer(fsm_instance *fi, fsm_timer *);
234
235 /**
236 * Clears a pending timer of an FSM instance.
237 *
238 * @param timer The timer to clear.
239 */
240 extern void fsm_deltimer(fsm_timer *timer);
241
242 /**
243 * Adds and starts a timer to an FSM instance.
244 *
245 * @param timer The timer to be added. The field fi of that timer
246 * must have been set to point to the instance.
247 * @param millisec Duration, after which the timer should expire.
248 * @param event Event, to trigger if timer expires.
249 * @param arg Generic argument, provided to expiry function.
250 *
251 * @return 0 on success, -1 if timer is already active.
252 */
253 extern int fsm_addtimer(fsm_timer *timer, int millisec, int event, void *arg);
254
255 /**
256 * Modifies a timer of an FSM.
257 *
258 * @param timer The timer to modify.
259 * @param millisec Duration, after which the timer should expire.
260 * @param event Event, to trigger if timer expires.
261 * @param arg Generic argument, provided to expiry function.
262 */
263 extern void fsm_modtimer(fsm_timer *timer, int millisec, int event, void *arg);
264
265 #endif /* _FSM_H_ */
266