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