net/ax25/ax25_timer.c

   1 /*
   2  *      AX.25 release 037
   3  *
   4  *      This code REQUIRES 2.1.15 or higher/ NET3.038
   5  *
   6  *      This module:
   7  *              This module is free software; you can redistribute it and/or
   8  *              modify it under the terms of the GNU General Public License
   9  *              as published by the Free Software Foundation; either version
  10  *              2 of the License, or (at your option) any later version.
  11  *
  12  *      History
  13  *      AX.25 028a      Jonathan(G4KLX) New state machine based on SDL diagrams.
  14  *      AX.25 028b      Jonathan(G4KLX) Extracted AX25 control block from the
  15  *                                      sock structure.
  16  *      AX.25 029       Alan(GW4PTS)    Switched to KA9Q constant names.
  17  *      AX.25 031       Joerg(DL1BKE)   Added DAMA support
  18  *      AX.25 032       Joerg(DL1BKE)   Fixed DAMA timeout bug
  19  *      AX.25 033       Jonathan(G4KLX) Modularisation functions.
  20  *      AX.25 035       Frederic(F1OAT) Support for pseudo-digipeating.
  21  *      AX.25 036       Jonathan(G4KLX) Split Standard and DAMA code into separate files.
  22  *                      Joerg(DL1BKE)   Fixed DAMA Slave. We are *required* to start with
  23  *                                      standard AX.25 mode.
  24  *      AX.25 037       Jonathan(G4KLX) New timer architecture.
  25  */
  26
  27 #include <linux/config.h>
  28 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  29 #include <linux/errno.h>
  30 #include <linux/types.h>
  31 #include <linux/socket.h>
  32 #include <linux/in.h>
  33 #include <linux/kernel.h>
  34 #include <linux/sched.h>
  35 #include <linux/timer.h>
  36 #include <linux/string.h>
  37 #include <linux/sockios.h>
  38 #include <linux/net.h>
  39 #include <net/ax25.h>
  40 #include <linux/inet.h>
  41 #include <linux/netdevice.h>
  42 #include <linux/skbuff.h>
  43 #include <net/sock.h>
  44 #include <asm/uaccess.h>
  45 #include <asm/system.h>
  46 #include <linux/fcntl.h>
  47 #include <linux/mm.h>
  48 #include <linux/interrupt.h>
  49
  50 static void ax25_heartbeat_expiry(unsigned long);
  51 static void ax25_t1timer_expiry(unsigned long);
  52 static void ax25_t2timer_expiry(unsigned long);
  53 static void ax25_t3timer_expiry(unsigned long);
  54 static void ax25_idletimer_expiry(unsigned long);
  55
  56 void ax25_start_heartbeat(ax25_cb *ax25)
  57 {
  58         del_timer(&ax25->timer);
  59
  60         ax25->timer.data     = (unsigned long)ax25;
  61         ax25->timer.function = &ax25_heartbeat_expiry;
  62         ax25->timer.expires  = jiffies + 5 * HZ;
  63
  64         add_timer(&ax25->timer);
  65 }
  66
  67 void ax25_start_t1timer(ax25_cb *ax25)
  68 {
  69         del_timer(&ax25->t1timer);
  70
  71         ax25->t1timer.data     = (unsigned long)ax25;
  72         ax25->t1timer.function = &ax25_t1timer_expiry;
  73         ax25->t1timer.expires  = jiffies + ax25->t1;
  74
  75         add_timer(&ax25->t1timer);
  76 }
  77
  78 void ax25_start_t2timer(ax25_cb *ax25)
  79 {
  80         del_timer(&ax25->t2timer);
  81
  82         ax25->t2timer.data     = (unsigned long)ax25;
  83         ax25->t2timer.function = &ax25_t2timer_expiry;
  84         ax25->t2timer.expires  = jiffies + ax25->t2;
  85
  86         add_timer(&ax25->t2timer);
  87 }
  88
  89 void ax25_start_t3timer(ax25_cb *ax25)
  90 {
  91         del_timer(&ax25->t3timer);
  92
  93         if (ax25->t3 > 0) {
  94                 ax25->t3timer.data     = (unsigned long)ax25;
  95                 ax25->t3timer.function = &ax25_t3timer_expiry;
  96                 ax25->t3timer.expires  = jiffies + ax25->t3;
  97
  98                 add_timer(&ax25->t3timer);
  99         }
 100 }
 101
 102 void ax25_start_idletimer(ax25_cb *ax25)
 103 {
 104         del_timer(&ax25->idletimer);
 105
 106         if (ax25->idle > 0) {
 107                 ax25->idletimer.data     = (unsigned long)ax25;
 108                 ax25->idletimer.function = &ax25_idletimer_expiry;
 109                 ax25->idletimer.expires  = jiffies + ax25->idle;
 110
 111                 add_timer(&ax25->idletimer);
 112         }
 113 }
 114
 115 void ax25_stop_heartbeat(ax25_cb *ax25)
 116 {
 117         del_timer(&ax25->timer);
 118 }
 119
 120 void ax25_stop_t1timer(ax25_cb *ax25)
 121 {
 122         del_timer(&ax25->t1timer);
 123 }
 124
 125 void ax25_stop_t2timer(ax25_cb *ax25)
 126 {
 127         del_timer(&ax25->t2timer);
 128 }
 129
 130 void ax25_stop_t3timer(ax25_cb *ax25)
 131 {
 132         del_timer(&ax25->t3timer);
 133 }
 134
 135 void ax25_stop_idletimer(ax25_cb *ax25)
 136 {
 137         del_timer(&ax25->idletimer);
 138 }
 139
 140 int ax25_t1timer_running(ax25_cb *ax25)
 141 {
 142         return (ax25->t1timer.prev != NULL || ax25->t1timer.next != NULL);
 143 }
 144
 145 unsigned long ax25_display_timer(struct timer_list *timer)
 146 {
 147         if (timer->prev == NULL && timer->next == NULL)
 148                 return 0;
 149
 150         return timer->expires - jiffies;
 151 }
 152
 153 static void ax25_heartbeat_expiry(unsigned long param)
 154 {
 155         ax25_cb *ax25 = (ax25_cb *)param;
 156
 157         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 158                 case AX25_PROTO_STD_SIMPLEX:
 159                 case AX25_PROTO_STD_DUPLEX:
 160                         ax25_std_heartbeat_expiry(ax25);
 161                         break;
 162
 163 #ifdef CONFIG_AX25_DAMA_SLAVE
 164                 case AX25_PROTO_DAMA_SLAVE:
 165                         if (ax25->ax25_dev->dama.slave)
 166                                 ax25_ds_heartbeat_expiry(ax25);
 167                         else
 168                                 ax25_std_heartbeat_expiry(ax25);
 169                         break;
 170 #endif
 171         }
 172 }
 173
 174 static void ax25_t1timer_expiry(unsigned long param)
 175 {
 176         ax25_cb *ax25 = (ax25_cb *)param;
 177
 178         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 179                 case AX25_PROTO_STD_SIMPLEX:
 180                 case AX25_PROTO_STD_DUPLEX:
 181                         ax25_std_t1timer_expiry(ax25);
 182                         break;
 183
 184 #ifdef CONFIG_AX25_DAMA_SLAVE
 185                 case AX25_PROTO_DAMA_SLAVE:
 186                         if (!ax25->ax25_dev->dama.slave)
 187                                 ax25_std_t1timer_expiry(ax25);
 188                         break;
 189 #endif
 190         }
 191 }
 192
 193 static void ax25_t2timer_expiry(unsigned long param)
 194 {
 195         ax25_cb *ax25 = (ax25_cb *)param;
 196
 197         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 198                 case AX25_PROTO_STD_SIMPLEX:
 199                 case AX25_PROTO_STD_DUPLEX:
 200                         ax25_std_t2timer_expiry(ax25);
 201                         break;
 202
 203 #ifdef CONFIG_AX25_DAMA_SLAVE
 204                 case AX25_PROTO_DAMA_SLAVE:
 205                         if (!ax25->ax25_dev->dama.slave)
 206                                 ax25_std_t2timer_expiry(ax25);
 207                         break;
 208 #endif
 209         }
 210 }
 211
 212 static void ax25_t3timer_expiry(unsigned long param)
 213 {
 214         ax25_cb *ax25 = (ax25_cb *)param;
 215
 216         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 217                 case AX25_PROTO_STD_SIMPLEX:
 218                 case AX25_PROTO_STD_DUPLEX:
 219                         ax25_std_t3timer_expiry(ax25);
 220                         break;
 221
 222 #ifdef CONFIG_AX25_DAMA_SLAVE
 223                 case AX25_PROTO_DAMA_SLAVE:
 224                         if (ax25->ax25_dev->dama.slave)
 225                                 ax25_ds_t3timer_expiry(ax25);
 226                         else
 227                                 ax25_std_t3timer_expiry(ax25);
 228                         break;
 229 #endif
 230         }
 231 }
 232
 233 static void ax25_idletimer_expiry(unsigned long param)
 234 {
 235         ax25_cb *ax25 = (ax25_cb *)param;
 236
 237         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 238                 case AX25_PROTO_STD_SIMPLEX:
 239                 case AX25_PROTO_STD_DUPLEX:
 240                         ax25_std_idletimer_expiry(ax25);
 241                         break;
 242
 243 #ifdef CONFIG_AX25_DAMA_SLAVE
 244                 case AX25_PROTO_DAMA_SLAVE:
 245                         if (ax25->ax25_dev->dama.slave)
 246                                 ax25_ds_idletimer_expiry(ax25);
 247                         else
 248                                 ax25_std_idletimer_expiry(ax25);
 249                         break;
 250 #endif
 251         }
 252 }
 253
 254 #endif