[linux.git] / drivers / s390 / net / fsm.c

/**
 * A generic FSM based on fsm used in isdn4linux
 *
 */

#include "fsm.h"
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/timer.h>

MODULE_AUTHOR("(C) 2000 IBM Corp. by Fritz Elfert ([email protected])");
MODULE_DESCRIPTION("Finite state machine helper functions");
MODULE_LICENSE("GPL");

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, gfp_t order)
{
	int i;
	fsm_instance *this;
	fsm_function_t *m;
	fsm *f;

	this = kzalloc(sizeof(fsm_instance), order);
	if (this == NULL) {
		printk(KERN_WARNING
			"fsm(%s): init_fsm: Couldn't alloc instance\n", name);
		return NULL;
	}
	strlcpy(this->name, name, sizeof(this->name));
	init_waitqueue_head(&this->wait_q);

	f = kzalloc(sizeof(fsm), order);
	if (f == NULL) {
		printk(KERN_WARNING
			"fsm(%s): init_fsm: Couldn't alloc fsm\n", name);
		kfree_fsm(this);
		return NULL;
	}
	f->nr_events = nr_events;
	f->nr_states = nr_states;
	f->event_names = event_names;
	f->state_names = state_names;
	this->f = f;

	m = kcalloc(nr_states*nr_events, sizeof(fsm_function_t), order);
	if (m == NULL) {
		printk(KERN_WARNING
			"fsm(%s): init_fsm: Couldn't alloc jumptable\n", name);
		kfree_fsm(this);
		return NULL;
	}
	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) {
			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(struct timer_list *t)
{
	fsm_timer *this = from_timer(this, t, tl);
#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;
#if FSM_TIMER_DEBUG
	printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name,
	       this);
#endif
	timer_setup(&this->tl, fsm_expire_timer, 0);
}

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

	timer_setup(&this->tl, fsm_expire_timer, 0);
	this->expire_event = event;
	this->event_arg = arg;
	this->tl.expires = jiffies + (millisec * HZ) / 1000;
	add_timer(&this->tl);
	return 0;
}

/* FIXME: this function is never used, why */
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

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