URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [s390/] [net/] [fsm.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/**
 * $Id: fsm.c,v 1.1.1.1 2004-04-15 02:05:52 phoenix Exp $
 *
 * A generic FSM based on fsm used in isdn4linux
 *
 */
 
#include "fsm.h"
#include <linux/version.h>
#include <linux/config.h>
#include <linux/module.h>
 
fsm_instance *
init_fsm(char *name, const char **state_names, const char **event_names, int nr_states,
                int nr_events, const fsm_node *tmpl, int tmpl_len, int order)
{
        int i;
        fsm_instance *this;
        fsm_function_t *m;
        fsm *f;
 
        this = (fsm_instance *)kmalloc(sizeof(fsm_instance), order);
        if (this == NULL) {
                printk(KERN_WARNING
                        "fsm(%s): init_fsm: Couldn't alloc instance\n", name);
                return NULL;
        }
        memset(this, 0, sizeof(fsm_instance));
        strncpy(this->name, name, sizeof(this->name));
 
        f = (fsm *)kmalloc(sizeof(fsm), order);
        if (f == NULL) {
                printk(KERN_WARNING
                        "fsm(%s): init_fsm: Couldn't alloc fsm\n", name);
                kfree_fsm(this);
                return NULL;
        }
        memset(f, 0, sizeof(fsm));
        f->nr_events = nr_events;
        f->nr_states = nr_states;
        f->event_names = event_names;
        f->state_names = state_names;
        this->f = f;
 
        m = (fsm_function_t *)kmalloc(
                        sizeof(fsm_function_t) * nr_states * nr_events, order);
        if (m == NULL) {
                printk(KERN_WARNING
                        "fsm(%s): init_fsm: Couldn't alloc jumptable\n", name);
                kfree_fsm(this);
                return NULL;
        }
        memset(m, 0, sizeof(fsm_function_t) * f->nr_states * f->nr_events);
        f->jumpmatrix = m;
 
        for (i = 0; i < tmpl_len; i++) {
                if ((tmpl[i].cond_state >= nr_states) ||
                    (tmpl[i].cond_event >= nr_events)   ) {
                        printk(KERN_ERR
                                "fsm(%s): init_fsm: Bad template l=%d st(%ld/%ld) ev(%ld/%ld)\n",
                                name, i, (long)tmpl[i].cond_state, (long)f->nr_states,
                                (long)tmpl[i].cond_event, (long)f->nr_events);
                        kfree_fsm(this);
                        return NULL;
                } else
                        m[nr_states * tmpl[i].cond_event + tmpl[i].cond_state] =
                                tmpl[i].function;
        }
        return this;
}
 
void
kfree_fsm(fsm_instance *this)
{
        if (this) {
                if (this->f) {
                        if (this->f->jumpmatrix)
                                kfree(this->f->jumpmatrix);
                        kfree(this->f);
                }
                kfree(this);
        } else
                printk(KERN_WARNING
                        "fsm: kfree_fsm called with NULL argument\n");
}
 
#if FSM_DEBUG_HISTORY
void
fsm_print_history(fsm_instance *fi)
{
        int idx = 0;
        int i;
 
        if (fi->history_size >= FSM_HISTORY_SIZE)
                idx = fi->history_index;
 
        printk(KERN_DEBUG "fsm(%s): History:\n", fi->name);
        for (i = 0; i < fi->history_size; i++) {
                int e = fi->history[idx].event;
                int s = fi->history[idx++].state;
                idx %= FSM_HISTORY_SIZE;
                if (e == -1)
                        printk(KERN_DEBUG "  S=%s\n",
                               fi->f->state_names[s]);
                else
                        printk(KERN_DEBUG "  S=%s E=%s\n",
                               fi->f->state_names[s],
                               fi->f->event_names[e]);
        }
        fi->history_size = fi->history_index = 0;
}
 
void
fsm_record_history(fsm_instance *fi, int state, int event)
{
        fi->history[fi->history_index].state = state;
        fi->history[fi->history_index++].event = event;
        fi->history_index %= FSM_HISTORY_SIZE;
        if (fi->history_size < FSM_HISTORY_SIZE)
                fi->history_size++;
}
#endif
 
const char *
fsm_getstate_str(fsm_instance *fi)
{
        int st = atomic_read(&fi->state);
        if (st >= fi->f->nr_states)
                return "Invalid";
        return fi->f->state_names[st];
}
 
static void
fsm_expire_timer(fsm_timer *this)
{
#if FSM_TIMER_DEBUG
        printk(KERN_DEBUG "fsm(%s): Timer %p expired\n",
               this->fi->name, this);
#endif
        fsm_event(this->fi, this->expire_event, this->event_arg);
}
 
void
fsm_settimer(fsm_instance *fi, fsm_timer *this)
{
        this->fi = fi;
        this->tl.function = (void *)fsm_expire_timer;
        this->tl.data = (long)this;
#if FSM_TIMER_DEBUG
        printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name,
               this);
#endif
        init_timer(&this->tl);
}
 
void
fsm_deltimer(fsm_timer *this)
{
#if FSM_TIMER_DEBUG
        printk(KERN_DEBUG "fsm(%s): Delete timer %p\n", this->fi->name,
                this);
#endif
        del_timer(&this->tl);
}
 
int
fsm_addtimer(fsm_timer *this, int millisec, int event, void *arg)
{
 
#if FSM_TIMER_DEBUG
        printk(KERN_DEBUG "fsm(%s): Add timer %p %dms\n",
               this->fi->name, this, millisec);
#endif
 
#if LINUX_VERSION_CODE >= 0x020300
        if (this->tl.list.next || this->tl.list.prev) {
                printk(KERN_WARNING "fsm(%s): timer already active!\n",
                        this->fi->name);
                return -1;
        }
#else
        if (this->tl.next || this->tl.prev) {
                printk(KERN_WARNING "fsm(%s): timer already active!\n",
                        this->fi->name);
                return -1;
        }
#endif
        init_timer(&this->tl);
        this->tl.function = (void *)fsm_expire_timer;
        this->tl.data = (long)this;
        this->expire_event = event;
        this->event_arg = arg;
        this->tl.expires = jiffies + (millisec * HZ) / 1000;
        add_timer(&this->tl);
        return 0;
}
 
void
fsm_modtimer(fsm_timer *this, int millisec, int event, void *arg)
{
 
#if FSM_TIMER_DEBUG
        printk(KERN_DEBUG "fsm(%s): Restart timer %p %dms\n",
                this->fi->name, this, millisec);
#endif
 
#if LINUX_VERSION_CODE >= 0x020300
        if (this->tl.list.next || this->tl.list.prev)
                del_timer(&this->tl);
#else
        if (this->tl.next || this->tl.prev)
                del_timer(&this->tl);
#endif
        init_timer(&this->tl);
        this->tl.function = (void *)fsm_expire_timer;
        this->tl.data = (long)this;
        this->expire_event = event;
        this->event_arg = arg;
        this->tl.expires = jiffies + (millisec * HZ) / 1000;
        add_timer(&this->tl);
}
 
EXPORT_SYMBOL(init_fsm);
EXPORT_SYMBOL(kfree_fsm);
EXPORT_SYMBOL(fsm_settimer);
EXPORT_SYMBOL(fsm_deltimer);
EXPORT_SYMBOL(fsm_addtimer);
EXPORT_SYMBOL(fsm_modtimer);
EXPORT_SYMBOL(fsm_getstate_str);
 
#if FSM_DEBUG_HISTORY
EXPORT_SYMBOL(fsm_print_history);
EXPORT_SYMBOL(fsm_record_history);
#endif

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [s390/] [net/] [fsm.c] - Blame information for rev 1765

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