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/config.h>
   8 #include <linux/module.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
  32         f = kzalloc(sizeof(fsm), order);
  33         if (f == NULL) {
  34                 printk(KERN_WARNING
  35                         "fsm(%s): init_fsm: Couldn't alloc fsm\n", name);
  36                 kfree_fsm(this);
  37                 return NULL;
  38         }
  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 = kcalloc(nr_states*nr_events, sizeof(fsm_function_t), order);
  46         if (m == NULL) {
  47                 printk(KERN_WARNING
  48                         "fsm(%s): init_fsm: Couldn't alloc jumptable\n", name);
  49                 kfree_fsm(this);
  50                 return NULL;
  51         }
  52         f->jumpmatrix = m;
  53
  54         for (i = 0; i < tmpl_len; i++) {
  55                 if ((tmpl[i].cond_state >= nr_states) ||
  56                     (tmpl[i].cond_event >= nr_events)   ) {
  57                         printk(KERN_ERR
  58                                 "fsm(%s): init_fsm: Bad template l=%d st(%ld/%ld) ev(%ld/%ld)\n",
  59                                 name, i, (long)tmpl[i].cond_state, (long)f->nr_states,
  60                                 (long)tmpl[i].cond_event, (long)f->nr_events);
  61                         kfree_fsm(this);
  62                         return NULL;
  63                 } else
  64                         m[nr_states * tmpl[i].cond_event + tmpl[i].cond_state] =
  65                                 tmpl[i].function;
  66         }
  67         return this;
  68 }
  69
  70 void
  71 kfree_fsm(fsm_instance *this)
  72 {
  73         if (this) {
  74                 if (this->f) {
  75                         kfree(this->f->jumpmatrix);
  76                         kfree(this->f);
  77                 }
  78                 kfree(this);
  79         } else
  80                 printk(KERN_WARNING
  81                         "fsm: kfree_fsm called with NULL argument\n");
  82 }
  83
  84 #if FSM_DEBUG_HISTORY
  85 void
  86 fsm_print_history(fsm_instance *fi)
  87 {
  88         int idx = 0;
  89         int i;
  90
  91         if (fi->history_size >= FSM_HISTORY_SIZE)
  92                 idx = fi->history_index;
  93
  94         printk(KERN_DEBUG "fsm(%s): History:\n", fi->name);
  95         for (i = 0; i < fi->history_size; i++) {
  96                 int e = fi->history[idx].event;
  97                 int s = fi->history[idx++].state;
  98                 idx %= FSM_HISTORY_SIZE;
  99                 if (e == -1)
 100                         printk(KERN_DEBUG "  S=%s\n",
 101                                fi->f->state_names[s]);
 102                 else
 103                         printk(KERN_DEBUG "  S=%s E=%s\n",
 104                                fi->f->state_names[s],
 105                                fi->f->event_names[e]);
 106         }
 107         fi->history_size = fi->history_index = 0;
 108 }
 109
 110 void
 111 fsm_record_history(fsm_instance *fi, int state, int event)
 112 {
 113         fi->history[fi->history_index].state = state;
 114         fi->history[fi->history_index++].event = event;
 115         fi->history_index %= FSM_HISTORY_SIZE;
 116         if (fi->history_size < FSM_HISTORY_SIZE)
 117                 fi->history_size++;
 118 }
 119 #endif
 120
 121 const char *
 122 fsm_getstate_str(fsm_instance *fi)
 123 {
 124         int st = atomic_read(&fi->state);
 125         if (st >= fi->f->nr_states)
 126                 return "Invalid";
 127         return fi->f->state_names[st];
 128 }
 129
 130 static void
 131 fsm_expire_timer(fsm_timer *this)
 132 {
 133 #if FSM_TIMER_DEBUG
 134         printk(KERN_DEBUG "fsm(%s): Timer %p expired\n",
 135                this->fi->name, this);
 136 #endif
 137         fsm_event(this->fi, this->expire_event, this->event_arg);
 138 }
 139
 140 void
 141 fsm_settimer(fsm_instance *fi, fsm_timer *this)
 142 {
 143         this->fi = fi;
 144         this->tl.function = (void *)fsm_expire_timer;
 145         this->tl.data = (long)this;
 146 #if FSM_TIMER_DEBUG
 147         printk(KERN_DEBUG "fsm(%s): Create timer %p\n", fi->name,
 148                this);
 149 #endif
 150         init_timer(&this->tl);
 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         init_timer(&this->tl);
 173         this->tl.function = (void *)fsm_expire_timer;
 174         this->tl.data = (long)this;
 175         this->expire_event = event;
 176         this->event_arg = arg;
 177         this->tl.expires = jiffies + (millisec * HZ) / 1000;
 178         add_timer(&this->tl);
 179         return 0;
 180 }
 181
 182 /* FIXME: this function is never used, why */
 183 void
 184 fsm_modtimer(fsm_timer *this, int millisec, int event, void *arg)
 185 {
 186
 187 #if FSM_TIMER_DEBUG
 188         printk(KERN_DEBUG "fsm(%s): Restart timer %p %dms\n",
 189                 this->fi->name, this, millisec);
 190 #endif
 191
 192         del_timer(&this->tl);
 193         init_timer(&this->tl);
 194         this->tl.function = (void *)fsm_expire_timer;
 195         this->tl.data = (long)this;
 196         this->expire_event = event;
 197         this->event_arg = arg;
 198         this->tl.expires = jiffies + (millisec * HZ) / 1000;
 199         add_timer(&this->tl);
 200 }
 201
 202 EXPORT_SYMBOL(init_fsm);
 203 EXPORT_SYMBOL(kfree_fsm);
 204 EXPORT_SYMBOL(fsm_settimer);
 205 EXPORT_SYMBOL(fsm_deltimer);
 206 EXPORT_SYMBOL(fsm_addtimer);
 207 EXPORT_SYMBOL(fsm_modtimer);
 208 EXPORT_SYMBOL(fsm_getstate_str);
 209
 210 #if FSM_DEBUG_HISTORY
 211 EXPORT_SYMBOL(fsm_print_history);
 212 EXPORT_SYMBOL(fsm_record_history);
 213 #endif