rom/devs/ahci/timer.c

   1 /*
   2     Copyright © 2009-2018, The AROS Development Team. All rights reserved
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8 /*
   9  * PARTIAL CHANGELOG:
  10  * DATE        NAME                ENTRY
  11  * ----------  ------------------  -------------------------------------------------------------------
  12  * 2005-03-06  T. Wiszkowski       few corrections (thanks, Georg)
  13  * 2005-03-05  T. Wiszkowski       created file; initial benchmarked nanowait and timer-based micro/sec wait
  14  */
  15
  16 #include <aros/debug.h>
  17
  18 #include <proto/exec.h>
  19
  20 /* We want all other bases obtained from our base */
  21 #define __NOLIBBASE__
  22
  23 #include <exec/types.h>
  24 #include <devices/timer.h>
  25 #include <exec/io.h>
  26 #include <proto/timer.h>
  27
  28 #include "timer.h"
  29
  30 ULONG iters_per_100ns = ~0;
  31
  32 static BOOL ahci_Calibrate(struct IORequest* tmr)
  33 {
  34     struct Device *TimerBase = tmr->io_Device;
  35     register ULONG x;
  36     register ULONG scale = 0x8000;      // min iterations...
  37     volatile register ULONG t = 1;
  38     struct timeval t1, t2;
  39
  40     D(bug("[AHCI  ] Calibration started\n"));
  41
  42     while (scale <= 0x80000000)
  43     {
  44         Forbid();
  45         GetUpTime(&t1);
  46         for (x = 1; x < scale; x++)
  47             t = (((t + x) * t) - x) / x;    // add, mul, sub, div, trivial benchmark.
  48
  49         GetUpTime(&t2);
  50         Permit();
  51         SubTime(&t2, &t1);
  52
  53         // ok, it's going to be totally insane, if secs > 1.
  54         if (t2.tv_secs != 0)
  55         {
  56             bug("[AHCI  ] micro wait useless.\n");
  57             return FALSE;
  58         }
  59
  60         /*
  61          * we expect at least 10000 times longer period, which should be 'achievable'
  62          * unlikely we will cross the magic boundary here of 4 billion instructions in 10 millisecond (yielding 400'000MIPS?)
  63          * on the other side, if we go as low as 1, then 4 iterations of add/sub/mul/div is perfectly fine yielding a bit more than 400ns...
  64          */
  65
  66         if (t2.tv_micro >= 10000)
  67             break;
  68         scale <<= 1;
  69     }
  70
  71     D(bug("[AHCI  ] Executed %ld ops in %ldus\n", scale, t2.tv_micro));
  72
  73     // always round up to the next value.. so 30.9 -> 31, 5.1 -> 6, etc
  74     x = (x + t2.tv_micro - 1) / t2.tv_micro;
  75     x = (x+9) / 10;
  76
  77     bug("[AHCI  ] Approximate number of iterations per 100 nanoseconds: %ld\n", x);
  78     iters_per_100ns = x;
  79     return TRUE;
  80 }
  81
  82 struct IORequest *ahci_OpenTimer()
  83 {
  84     struct MsgPort *p = CreateMsgPort();
  85     if (NULL != p)
  86     {
  87         struct IORequest *io = CreateIORequest(p, sizeof(struct timerequest));
  88
  89         if (NULL != io)
  90         {
  91             /*
  92              * We only need this timer for relatively long delays
  93              */
  94             if (0 == OpenDevice(TIMERNAME, UNIT_MICROHZ, io, 0))
  95             {
  96                 if (iters_per_100ns == ~0)
  97                 {
  98                     ahci_Calibrate(io);
  99                 }
 100                 return io;
 101             }
 102             else
 103             {
 104                 bug("[AHCI  ] Failed to open timer.device, unit MICROHZ\n");
 105             }
 106             DeleteIORequest(io);
 107         }
 108         else
 109         {
 110             bug("[AHCI  ] Failed to create timerequest\n");
 111         }
 112         DeleteMsgPort(p);
 113     }
 114     else
 115     {
 116         bug("[AHCI  ] Failed to create timer port\n");
 117     }
 118
 119     return NULL;
 120 }
 121
 122 void ahci_CloseTimer(struct IORequest *tmr)
 123 {
 124     if (NULL != tmr)
 125     {
 126         struct MsgPort *p = tmr->io_Message.mn_ReplyPort;
 127         CloseDevice(tmr);
 128         DeleteIORequest(tmr);
 129         DeleteMsgPort(p);
 130     }
 131 }
 132
 133 void ahci_WaitNano(register ULONG ns)
 134 {
 135     volatile register ULONG t = 1;
 136     ns = (ns + 99) / 100;
 137     ns *= iters_per_100ns;
 138     while (ns > 0)
 139     {
 140         t = (((t + ns) * t) - ns) / ns;    // add, mul, sub, div, trivial benchmark.
 141         --ns;
 142     }
 143 }
 144
 145 ULONG ahci_WaitTO(struct IORequest* tmr, ULONG secs, ULONG micro, ULONG sigs)
 146 {
 147     ULONG iosig = 1 << tmr->io_Message.mn_ReplyPort->mp_SigBit;
 148
 149     //D(bug("[AHCI--] Timed wait %lds %ldu\n", secs, micro));
 150
 151     tmr->io_Command = TR_ADDREQUEST;
 152     tmr->io_Flags   = 0;
 153     ((struct timerequest*)tmr)->tr_time.tv_secs = secs;
 154     ((struct timerequest*)tmr)->tr_time.tv_micro = micro;
 155
 156     SendIO(tmr);
 157     sigs = Wait(sigs | iosig);
 158     if (0 == (sigs & iosig)) {
 159         if (!CheckIO(tmr))
 160             AbortIO(tmr);
 161     }
 162     WaitIO(tmr);
 163
 164     SetSignal(0, iosig);
 165
 166     return sigs &~ iosig;
 167 }
 168