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(fsm_timer *this) 133 { 134 #if FSM_TIMER_DEBUG 135 printk(KERN_DEBUG "fsm(%s): Timer %p expired\n", 136 this->fi->name, this); 137 #endif 138 fsm_event(this->fi, this->expire_event, this->event_arg); 139 } 140 141 void 142 fsm_settimer(fsm_instance *fi, fsm_timer *this) 143 { 144 this->fi = fi; 145 this->tl.function = (void *)fsm_expire_timer; 146 this->tl.data = (long)this; 147 #if FSM_TIMER_DEBUG 148 printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name, 149 this); 150 #endif 151 init_timer(&this->tl); 152 } 153 154 void 155 fsm_deltimer(fsm_timer *this) 156 { 157 #if FSM_TIMER_DEBUG 158 printk(KERN_DEBUG "fsm(%s): Delete timer %p\n", this->fi->name, 159 this); 160 #endif 161 del_timer(&this->tl); 162 } 163 164 int 165 fsm_addtimer(fsm_timer *this, int millisec, int event, void *arg) 166 { 167 168 #if FSM_TIMER_DEBUG 169 printk(KERN_DEBUG "fsm(%s): Add timer %p %dms\n", 170 this->fi->name, this, millisec); 171 #endif 172 173 init_timer(&this->tl); 174 this->tl.function = (void *)fsm_expire_timer; 175 this->tl.data = (long)this; 176 this->expire_event = event; 177 this->event_arg = arg; 178 this->tl.expires = jiffies + (millisec * HZ) / 1000; 179 add_timer(&this->tl); 180 return 0; 181 } 182 183 /* FIXME: this function is never used, why */ 184 void 185 fsm_modtimer(fsm_timer *this, int millisec, int event, void *arg) 186 { 187 188 #if FSM_TIMER_DEBUG 189 printk(KERN_DEBUG "fsm(%s): Restart timer %p %dms\n", 190 this->fi->name, this, millisec); 191 #endif 192 193 del_timer(&this->tl); 194 init_timer(&this->tl); 195 this->tl.function = (void *)fsm_expire_timer; 196 this->tl.data = (long)this; 197 this->expire_event = event; 198 this->event_arg = arg; 199 this->tl.expires = jiffies + (millisec * HZ) / 1000; 200 add_timer(&this->tl); 201 } 202 203 EXPORT_SYMBOL(init_fsm); 204 EXPORT_SYMBOL(kfree_fsm); 205 EXPORT_SYMBOL(fsm_settimer); 206 EXPORT_SYMBOL(fsm_deltimer); 207 EXPORT_SYMBOL(fsm_addtimer); 208 EXPORT_SYMBOL(fsm_modtimer); 209 EXPORT_SYMBOL(fsm_getstate_str); 210 211 #if FSM_DEBUG_HISTORY 212 EXPORT_SYMBOL(fsm_print_history); 213 EXPORT_SYMBOL(fsm_record_history); 214 #endif 215