[PATCH] gfp_t: remaining bits of drivers/*
[linux-2.6.git] / drivers / s390 / net / fsm.c
1 /**
2  * $Id: fsm.c,v 1.6 2003/10/15 11:37:29 mschwide Exp $
3  *
4  * A generic FSM based on fsm used in isdn4linux
5  *
6  */
7
8 #include "fsm.h"
9 #include <linux/config.h>
10 #include <linux/module.h>
11 #include <linux/timer.h>
12
13 MODULE_AUTHOR("(C) 2000 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
14 MODULE_DESCRIPTION("Finite state machine helper functions");
15 MODULE_LICENSE("GPL");
16
17 fsm_instance *
18 init_fsm(char *name, const char **state_names, const char **event_names, int nr_states,
19                 int nr_events, const fsm_node *tmpl, int tmpl_len, gfp_t order)
20 {
21         int i;
22         fsm_instance *this;
23         fsm_function_t *m;
24         fsm *f;
25
26         this = (fsm_instance *)kmalloc(sizeof(fsm_instance), order);
27         if (this == NULL) {
28                 printk(KERN_WARNING
29                         "fsm(%s): init_fsm: Couldn't alloc instance\n", name);
30                 return NULL;
31         }
32         memset(this, 0, sizeof(fsm_instance));
33         strlcpy(this->name, name, sizeof(this->name));
34
35         f = (fsm *)kmalloc(sizeof(fsm), order);
36         if (f == NULL) {
37                 printk(KERN_WARNING
38                         "fsm(%s): init_fsm: Couldn't alloc fsm\n", name);
39                 kfree_fsm(this);
40                 return NULL;
41         }
42         memset(f, 0, sizeof(fsm));
43         f->nr_events = nr_events;
44         f->nr_states = nr_states;
45         f->event_names = event_names;
46         f->state_names = state_names;
47         this->f = f;
48
49         m = (fsm_function_t *)kmalloc(
50                         sizeof(fsm_function_t) * nr_states * nr_events, order);
51         if (m == NULL) {
52                 printk(KERN_WARNING
53                         "fsm(%s): init_fsm: Couldn't alloc jumptable\n", name);
54                 kfree_fsm(this);
55                 return NULL;
56         }
57         memset(m, 0, sizeof(fsm_function_t) * f->nr_states * f->nr_events);
58         f->jumpmatrix = m;
59
60         for (i = 0; i < tmpl_len; i++) {
61                 if ((tmpl[i].cond_state >= nr_states) ||
62                     (tmpl[i].cond_event >= nr_events)   ) {
63                         printk(KERN_ERR
64                                 "fsm(%s): init_fsm: Bad template l=%d st(%ld/%ld) ev(%ld/%ld)\n",
65                                 name, i, (long)tmpl[i].cond_state, (long)f->nr_states,
66                                 (long)tmpl[i].cond_event, (long)f->nr_events);
67                         kfree_fsm(this);
68                         return NULL;
69                 } else
70                         m[nr_states * tmpl[i].cond_event + tmpl[i].cond_state] =
71                                 tmpl[i].function;
72         }
73         return this;
74 }
75
76 void
77 kfree_fsm(fsm_instance *this)
78 {
79         if (this) {
80                 if (this->f) {
81                         if (this->f->jumpmatrix)
82                                 kfree(this->f->jumpmatrix);
83                         kfree(this->f);
84                 }
85                 kfree(this);
86         } else
87                 printk(KERN_WARNING
88                         "fsm: kfree_fsm called with NULL argument\n");
89 }
90
91 #if FSM_DEBUG_HISTORY
92 void
93 fsm_print_history(fsm_instance *fi)
94 {
95         int idx = 0;
96         int i;
97
98         if (fi->history_size >= FSM_HISTORY_SIZE)
99                 idx = fi->history_index;
100
101         printk(KERN_DEBUG "fsm(%s): History:\n", fi->name);
102         for (i = 0; i < fi->history_size; i++) {
103                 int e = fi->history[idx].event;
104                 int s = fi->history[idx++].state;
105                 idx %= FSM_HISTORY_SIZE;
106                 if (e == -1)
107                         printk(KERN_DEBUG "  S=%s\n",
108                                fi->f->state_names[s]);
109                 else
110                         printk(KERN_DEBUG "  S=%s E=%s\n",
111                                fi->f->state_names[s],
112                                fi->f->event_names[e]);
113         }
114         fi->history_size = fi->history_index = 0;
115 }
116
117 void
118 fsm_record_history(fsm_instance *fi, int state, int event)
119 {
120         fi->history[fi->history_index].state = state;
121         fi->history[fi->history_index++].event = event;
122         fi->history_index %= FSM_HISTORY_SIZE;
123         if (fi->history_size < FSM_HISTORY_SIZE)
124                 fi->history_size++;
125 }
126 #endif
127
128 const char *
129 fsm_getstate_str(fsm_instance *fi)
130 {
131         int st = atomic_read(&fi->state);
132         if (st >= fi->f->nr_states)
133                 return "Invalid";
134         return fi->f->state_names[st];
135 }
136
137 static void
138 fsm_expire_timer(fsm_timer *this)
139 {
140 #if FSM_TIMER_DEBUG
141         printk(KERN_DEBUG "fsm(%s): Timer %p expired\n",
142                this->fi->name, this);
143 #endif
144         fsm_event(this->fi, this->expire_event, this->event_arg);
145 }
146
147 void
148 fsm_settimer(fsm_instance *fi, fsm_timer *this)
149 {
150         this->fi = fi;
151         this->tl.function = (void *)fsm_expire_timer;
152         this->tl.data = (long)this;
153 #if FSM_TIMER_DEBUG
154         printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name,
155                this);
156 #endif
157         init_timer(&this->tl);
158 }
159
160 void
161 fsm_deltimer(fsm_timer *this)
162 {
163 #if FSM_TIMER_DEBUG
164         printk(KERN_DEBUG "fsm(%s): Delete timer %p\n", this->fi->name,
165                 this);
166 #endif
167         del_timer(&this->tl);
168 }
169
170 int
171 fsm_addtimer(fsm_timer *this, int millisec, int event, void *arg)
172 {
173
174 #if FSM_TIMER_DEBUG
175         printk(KERN_DEBUG "fsm(%s): Add timer %p %dms\n",
176                this->fi->name, this, millisec);
177 #endif
178
179         init_timer(&this->tl);
180         this->tl.function = (void *)fsm_expire_timer;
181         this->tl.data = (long)this;
182         this->expire_event = event;
183         this->event_arg = arg;
184         this->tl.expires = jiffies + (millisec * HZ) / 1000;
185         add_timer(&this->tl);
186         return 0;
187 }
188
189 /* FIXME: this function is never used, why */
190 void
191 fsm_modtimer(fsm_timer *this, int millisec, int event, void *arg)
192 {
193
194 #if FSM_TIMER_DEBUG
195         printk(KERN_DEBUG "fsm(%s): Restart timer %p %dms\n",
196                 this->fi->name, this, millisec);
197 #endif
198
199         del_timer(&this->tl);
200         init_timer(&this->tl);
201         this->tl.function = (void *)fsm_expire_timer;
202         this->tl.data = (long)this;
203         this->expire_event = event;
204         this->event_arg = arg;
205         this->tl.expires = jiffies + (millisec * HZ) / 1000;
206         add_timer(&this->tl);
207 }
208
209 EXPORT_SYMBOL(init_fsm);
210 EXPORT_SYMBOL(kfree_fsm);
211 EXPORT_SYMBOL(fsm_settimer);
212 EXPORT_SYMBOL(fsm_deltimer);
213 EXPORT_SYMBOL(fsm_addtimer);
214 EXPORT_SYMBOL(fsm_modtimer);
215 EXPORT_SYMBOL(fsm_getstate_str);
216
217 #if FSM_DEBUG_HISTORY
218 EXPORT_SYMBOL(fsm_print_history);
219 EXPORT_SYMBOL(fsm_record_history);
220 #endif