workbench/network/stacks/AROSTCP/bsdsocket/kern/amiga_time.c

   1 /*
   2  * Copyright (C) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
   3  *                    Helsinki University of Technology, Finland.
   4  *                    All rights reserved.
   5  * Copyright (C) 2005 - 2007 The AROS Dev Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19  * MA 02111-1307, USA.
  20  *
  21  */
  22
  23 #include <conf.h>
  24
  25 #include <sys/param.h>
  26 #include <sys/systm.h>
  27 #include <sys/synch.h>
  28 #include <sys/syslog.h>
  29 #include <sys/socket.h>
  30 #include <sys/socketvar.h>
  31 #include <sys/protosw.h>        /* for protocol timeouts */
  32 #include <net/if.h>             /* for if timeout */
  33 #include <netinet/in.h>
  34 #include <net/sana2arp.h>       /* for arp timeout */
  35
  36 #include <kern/amiga_includes.h>
  37 #include <kern/amiga_time.h>
  38
  39 /*
  40  * include prototypes for timeout functions
  41  */
  42 #include <net/if_protos.h>              /* if_slowtimo() */
  43 #include <kern/uipc_domain_protos.h>    /* pfslowtimo(), pffasttimo() */
  44
  45 /*
  46  * Global timer base pointer used throughout the code.
  47  * Commodore says that same base should not be used by different task,
  48  * so API users should have their own base pointer.
  49  */
  50 #ifdef __MORPHOS__
  51 struct Library    *TimerBase = NULL;
  52 #else
  53 struct Device     *TimerBase = NULL;
  54 #endif
  55
  56 static struct MsgPort     *timerport = NULL;     /* Timer message reply port */
  57 static struct timerequest *timerIORequest = NULL; /* template IORequest */
  58
  59 /*
  60  * timeoutrequest pointers for all the timeouts
  61  */
  62 static struct timeoutRequest *ifTimer = NULL,
  63   *arpTimer = NULL,
  64   *protoSlowTimer = NULL,
  65   *protoFastTimer = NULL;
  66
  67 static BOOL can_send_timeouts = FALSE;
  68
  69 /*
  70  * Initialize the timer. This MUST be called before any Timer functions are
  71  * used (including get_time() and microtime() which use GetSysTime())
  72  * (see sys/time.h).
  73  *
  74  * timerIORequest is used as a template from which all needed timer
  75  * IO messages are copied. The command field of the request is initialized to
  76  * TR_ADDREQUEST. Requests node type is initialized to NT_UNKNOWN for us
  77  * to be able to recognize if it has been used.
  78  *
  79  * Note that we need to check manually the version of the opened device. The
  80  * version number must be at least 36 since we use the GetSysTime() function
  81  * which is not defined in earlier versions.
  82  *
  83  * This initializes all the needed timeoutrequests too.
  84  */
  85 ULONG
  86 timer_init(void)
  87 {
  88   LONG error;
  89 #if defined(__AROS__)
  90 D(bug("[AROSTCP](amiga_timer.c) timer_init()\n"));
  91 #endif
  92
  93   /*
  94    * Return success if already initialized
  95    */
  96   if (timerport != NULL)
  97     return TRUE;
  98
  99   /*
 100    * allocate and initialize the timer message reply port
 101    */
 102   timerport = CreateMsgPort();
 103   if (timerport != NULL) {
 104     /*
 105      * allocate and initialize the template message structure
 106      */
 107     timerIORequest = (struct timerequest *)
 108       CreateIORequest(timerport, sizeof(struct timerequest));
 109     if (timerIORequest != NULL) {
 110       error = OpenDevice(TIMERNAME, UNIT_VBLANK,
 111                          (struct IORequest *)timerIORequest, 0);
 112       if (error == 0) {
 113         /*
 114          * Make sure that we got at least V36 timer, since we use some
 115          * functions defined only in V36 and later.
 116          */
 117         if ((timerIORequest->tr_node.io_Device)->dd_Library.lib_Version >= 36) {
 118           /*
 119            * initialize TimerBase from timerIORequest
 120            */
 121           TimerBase = timerIORequest->tr_node.io_Device;
 122           /*
 123            * Initialize some fields of the IO request to common values
 124            */
 125           timerIORequest->tr_node.io_Command = TR_ADDREQUEST;
 126           /*
 127            * NT_UNKNOWN means unused, too (see note on exec/nodes.h)
 128            */
 129           timerIORequest->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN;
 130
 131           /*
 132            * create timeout requests for all timeouts;
 133            */
 134           ifTimer = createTimeoutRequest(if_slowtimo, 1 / IFNET_SLOWHZ, 0);
 135           arpTimer = createTimeoutRequest(arptimer, ARPT_AGE, 0);
 136           protoSlowTimer = createTimeoutRequest(pfslowtimo, 0, 1000000 / PR_SLOWHZ);
 137           protoFastTimer = createTimeoutRequest(pffasttimo, 0, 1000000 / PR_FASTHZ);
 138           if (protoFastTimer && protoSlowTimer && arpTimer && ifTimer) {
 139             can_send_timeouts = TRUE;
 140             return (ULONG)(1 << timerport->mp_SigBit);
 141           }
 142         }
 143       }
 144     }
 145   }
 146   /*
 147    * clean all in case of any error
 148    */
 149   timer_deinit();
 150
 151   return (0);
 152 }
 153
 154 /*
 155  * Deinitialize the timer.
 156  * The requests are cancelled first.
 157  */
 158 void
 159 timer_deinit(void)
 160 {
 161 #if defined(__AROS__)
 162 D(bug("[AROSTCP](amiga_timer.c) timer_deinit()\n"));
 163 #endif
 164   can_send_timeouts = FALSE;
 165
 166   if (protoFastTimer)
 167     deleteTimeoutRequest(protoFastTimer);
 168   if (protoSlowTimer)
 169     deleteTimeoutRequest(protoSlowTimer);
 170   if (arpTimer)
 171     deleteTimeoutRequest(arpTimer);
 172   if (ifTimer)
 173     deleteTimeoutRequest(ifTimer);
 174
 175   if (timerIORequest) {
 176     TimerBase = NULL;
 177     if (timerIORequest->tr_node.io_Device != NULL)
 178       CloseDevice((struct IORequest *)timerIORequest);
 179     DeleteIORequest((struct IORequest *)timerIORequest);
 180     timerIORequest = NULL;
 181   }
 182   if (timerport) {
 183     DeleteMsgPort(timerport);
 184     timerport = NULL;
 185   }
 186 }
 187
 188 /*
 189  * Function to send all the timeout requests when everything is initialized
 190  * DON'T even try to call this function otherwise!
 191  */
 192 void
 193 timer_send(void)
 194 {
 195 #if defined(__AROS__)
 196 D(bug("[AROSTCP](amiga_timer.c) timer_send()\n"));
 197 #endif
 198   if (can_send_timeouts != FALSE) {
 199     /*
 200      * Start timeout requests
 201      */
 202     sendTimeoutRequest(ifTimer);
 203     sendTimeoutRequest(arpTimer);
 204     sendTimeoutRequest(protoSlowTimer);
 205     sendTimeoutRequest(protoFastTimer);
 206
 207     can_send_timeouts = FALSE;
 208   }
 209 }
 210
 211 /*
 212  * functions to create new timeoutRequest (after timer is initialized!)
 213  */
 214 struct timeoutRequest *
 215 createTimeoutRequest(TimerCallback_t fun,
 216                      ULONG seconds, ULONG micros)
 217 {
 218   struct timeoutRequest *tr;
 219 #if defined(__AROS__)
 220 D(bug("[AROSTCP](amiga_timer.c) createTimeoutRequest()\n"));
 221 #endif
 222
 223 #if DIAGNOSTIC
 224   /*
 225    * sanity check the micros value
 226    */
 227   if (micros >= 1000000) {
 228     log(LOG_ERR, "More than 1000000 microseconds in initTimeoutRequest()\n");
 229     return NULL;
 230   }
 231 #endif
 232
 233   /*
 234    * allocate IO request
 235    */
 236   tr = (struct timeoutRequest *)CreateIORequest(timerport, sizeof(*tr));
 237   if (tr == NULL)
 238     return NULL;
 239
 240   /*
 241    * copy initial values from the initialized timerrequest
 242    */
 243
 244   /* Node */
 245   tr->timeout_request.tr_node.io_Message.mn_Node.ln_Type =
 246     timerIORequest->tr_node.io_Message.mn_Node.ln_Type;
 247   tr->timeout_request.tr_node.io_Message.mn_Node.ln_Pri =
 248     timerIORequest->tr_node.io_Message.mn_Node.ln_Pri;
 249   tr->timeout_request.tr_node.io_Message.mn_Node.ln_Name =
 250     timerIORequest->tr_node.io_Message.mn_Node.ln_Name;
 251
 252   /* Message */
 253   tr->timeout_request.tr_node.io_Message.mn_ReplyPort =
 254     timerIORequest->tr_node.io_Message.mn_ReplyPort;
 255
 256   /* IORequest */
 257   tr->timeout_request.tr_node.io_Device = timerIORequest->tr_node.io_Device;
 258   tr->timeout_request.tr_node.io_Unit = timerIORequest->tr_node.io_Unit;
 259   tr->timeout_request.tr_node.io_Command = timerIORequest->tr_node.io_Command;
 260   tr->timeout_request.tr_node.io_Flags = timerIORequest->tr_node.io_Flags;
 261
 262   /*
 263    * set our own fields
 264    */
 265   tr->timeout_timeval.tv_secs = seconds;
 266   tr->timeout_timeval.tv_micro = micros;
 267   tr->timeout_function = fun;
 268
 269   return tr;
 270 }
 271
 272 void
 273 deleteTimeoutRequest(struct timeoutRequest *tr)
 274 {
 275 #if defined(__AROS__)
 276 D(bug("[AROSTCP](amiga_timer.c) deleteTimeoutRequest()\n"));
 277 #endif
 278   /*
 279    * Abort the request if ever used
 280    */
 281   if (((struct Node *)tr)->ln_Type != NT_UNKNOWN) {
 282     AbortIO((struct IORequest *)tr);
 283     WaitIO((struct IORequest *)tr);
 284     /*
 285      * Make sure the signal gets cleared
 286      */
 287     SetSignal(0, 1 << timerport->mp_SigBit);
 288   }
 289   /*
 290    * free the request
 291    */
 292   DeleteIORequest((struct IORequest *)tr);
 293 }
 294
 295 BOOL timer_poll(VOID)
 296 {
 297   struct timeoutRequest *timerReply;
 298 /* Uncomment the following lines to get debug - however please note: this func runs often */
 299 //#if defined(__AROS__)
 300 //D(bug("[AROSTCP](amiga_timer.c) timer_poll()\n"));
 301 //#endif
 302   /*
 303    * Get all messages from the timer reply port.
 304    */
 305   if (timerReply = (struct timeoutRequest *)GetMsg(timerport)) {
 306     /*
 307      * enter softclock interrupt level
 308      */
 309     spl_t s = splsoftclock();
 310     /*
 311      * handle the timeout
 312      */
 313     handleTimeoutRequest(timerReply);
 314     /*
 315      * restart timeout request
 316      */
 317     sendTimeoutRequest(timerReply);
 318     /*
 319      * restore previous interrupt level
 320      */
 321     splx(s);
 322
 323     return TRUE;
 324   }
 325
 326   return FALSE;
 327 }