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/slab.h> 9 #include <linux/timer.h> 10 11 MODULE_AUTHOR("(C) 2000 IBM Corp. by Fritz Elfert (felfert@millenux.com)"); 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, 17 int nr_events, const fsm_node *tmpl, int tmpl_len, gfp_t order) 18 { 19 int i; 20 fsm_instance *this; 21 fsm_function_t *m; 22 fsm *f; 23 24 this = kzalloc(sizeof(fsm_instance), order); 25 if (this == NULL) { 26 printk(KERN_WARNING 27 "fsm(%s): init_fsm: Couldn't alloc instance\n", name); 28 return NULL; 29 } 30 strlcpy(this->name, name, sizeof(this->name)); 31 init_waitqueue_head(&this->wait_q); 32 33 f = kzalloc(sizeof(fsm), order); 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 } 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 46 m = kcalloc(nr_states*nr_events, sizeof(fsm_function_t), 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 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) { 76 kfree(this->f->jumpmatrix); 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 132 fsm_expire_timer(struct timer_list *t) 133 { 134 fsm_timer *this = from_timer(this, t, tl); 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; 146 #if FSM_TIMER_DEBUG 147 printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name, 148 this); 149 #endif 150 timer_setup(&this->tl, fsm_expire_timer, 0); 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 172 timer_setup(&this->tl, fsm_expire_timer, 0); 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); 191 timer_setup(&this->tl, fsm_expire_timer, 0); 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 210