drivers/staging/epl/TimerHighReskX86.c

   1 /****************************************************************************
   2
   3   (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
   4       www.systec-electronic.com
   5
   6   Project:      openPOWERLINK
   7
   8   Description:  target specific implementation of
   9                 high resolution timer module for X86 under Linux
  10                 The Linux kernel has to be compiled with high resolution
  11                 timers enabled. This is done by configuring the kernel
  12                 with CONFIG_HIGH_RES_TIMERS enabled.
  13
  14   License:
  15
  16     Redistribution and use in source and binary forms, with or without
  17     modification, are permitted provided that the following conditions
  18     are met:
  19
  20     1. Redistributions of source code must retain the above copyright
  21        notice, this list of conditions and the following disclaimer.
  22
  23     2. Redistributions in binary form must reproduce the above copyright
  24        notice, this list of conditions and the following disclaimer in the
  25        documentation and/or other materials provided with the distribution.
  26
  27     3. Neither the name of SYSTEC electronic GmbH nor the names of its
  28        contributors may be used to endorse or promote products derived
  29        from this software without prior written permission. For written
  30        permission, please contact info@systec-electronic.com.
  31
  32     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  35     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  36     COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  37     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  38     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  39     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  40     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  41     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  42     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  43     POSSIBILITY OF SUCH DAMAGE.
  44
  45     Severability Clause:
  46
  47         If a provision of this License is or becomes illegal, invalid or
  48         unenforceable in any jurisdiction, that shall not affect:
  49         1. the validity or enforceability in that jurisdiction of any other
  50            provision of this License; or
  51         2. the validity or enforceability in other jurisdictions of that or
  52            any other provision of this License.
  53
  54   -------------------------------------------------------------------------
  55
  56                 $RCSfile: TimerHighReskX86.c,v $
  57
  58                 $Author: D.Krueger $
  59
  60                 $Revision: 1.4 $  $Date: 2008/04/17 21:38:01 $
  61
  62                 $State: Exp $
  63
  64                 Build Environment:
  65                     GNU
  66
  67   -------------------------------------------------------------------------
  68
  69   Revision History:
  70
  71 ****************************************************************************/
  72
  73 #include "EplInc.h"
  74 #include "kernel/EplTimerHighResk.h"
  75 #include "Benchmark.h"
  76
  77 //#include <linux/config.h>
  78 #include <linux/module.h>
  79 #include <linux/kernel.h>
  80 #include <linux/hrtimer.h>
  81
  82 /***************************************************************************/
  83 /*                                                                         */
  84 /*                                                                         */
  85 /*          G L O B A L   D E F I N I T I O N S                            */
  86 /*                                                                         */
  87 /*                                                                         */
  88 /***************************************************************************/
  89
  90 //---------------------------------------------------------------------------
  91 // const defines
  92 //---------------------------------------------------------------------------
  93
  94 #define TIMER_COUNT           2 /* max 15 timers selectable */
  95 #define TIMER_MIN_VAL_SINGLE  5000      /* min 5us */
  96 #define TIMER_MIN_VAL_CYCLE   100000    /* min 100us */
  97
  98 #define PROVE_OVERRUN
  99
 100 #ifndef CONFIG_HIGH_RES_TIMERS
 101 #error "Kernel symbol CONFIG_HIGH_RES_TIMERS is required."
 102 #endif
 103
 104 // TracePoint support for realtime-debugging
 105 #ifdef _DBG_TRACE_POINTS_
 106 void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
 107 void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 108 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 109 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 110 #else
 111 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
 112 #define TGT_DBG_POST_TRACE_VALUE(v)
 113 #endif
 114 #define HRT_DBG_POST_TRACE_VALUE(Event_p, uiNodeId_p, wErrorCode_p) \
 115     TGT_DBG_POST_TRACE_VALUE((0xE << 28) | (Event_p << 24) \
 116                              | (uiNodeId_p << 16) | wErrorCode_p)
 117
 118 #define TIMERHDL_MASK         0x0FFFFFFF
 119 #define TIMERHDL_SHIFT        28
 120 #define HDL_TO_IDX(Hdl)       ((Hdl >> TIMERHDL_SHIFT) - 1)
 121 #define HDL_INIT(Idx)         ((Idx + 1) << TIMERHDL_SHIFT)
 122 #define HDL_INC(Hdl)          (((Hdl + 1) & TIMERHDL_MASK) \
 123                                | (Hdl & ~TIMERHDL_MASK))
 124
 125 //---------------------------------------------------------------------------
 126 // modul global types
 127 //---------------------------------------------------------------------------
 128
 129 typedef struct {
 130         tEplTimerEventArg m_EventArg;
 131         tEplTimerkCallback m_pfnCallback;
 132         struct hrtimer m_Timer;
 133         BOOL m_fContinuously;
 134         unsigned long long m_ullPeriod;
 135
 136 } tEplTimerHighReskTimerInfo;
 137
 138 typedef struct {
 139         tEplTimerHighReskTimerInfo m_aTimerInfo[TIMER_COUNT];
 140
 141 } tEplTimerHighReskInstance;
 142
 143 //---------------------------------------------------------------------------
 144 // local vars
 145 //---------------------------------------------------------------------------
 146
 147 static tEplTimerHighReskInstance EplTimerHighReskInstance_l;
 148
 149 //---------------------------------------------------------------------------
 150 // local function prototypes
 151 //---------------------------------------------------------------------------
 152
 153 enum hrtimer_restart EplTimerHighReskCallback(struct hrtimer *pTimer_p);
 154
 155 //=========================================================================//
 156 //                                                                         //
 157 //          P U B L I C   F U N C T I O N S                                //
 158 //                                                                         //
 159 //=========================================================================//
 160
 161 //---------------------------------------------------------------------------
 162 //
 163 // Function:    EplTimerHighReskInit()
 164 //
 165 // Description: initializes the high resolution timer module.
 166 //
 167 // Parameters:  void
 168 //
 169 // Return:      tEplKernel      = error code
 170 //
 171 // State:       not tested
 172 //
 173 //---------------------------------------------------------------------------
 174
 175 tEplKernel PUBLIC EplTimerHighReskInit(void)
 176 {
 177         tEplKernel Ret;
 178
 179         Ret = EplTimerHighReskAddInstance();
 180
 181         return Ret;
 182
 183 }
 184
 185 //---------------------------------------------------------------------------
 186 //
 187 // Function:    EplTimerHighReskAddInstance()
 188 //
 189 // Description: initializes the high resolution timer module.
 190 //
 191 // Parameters:  void
 192 //
 193 // Return:      tEplKernel      = error code
 194 //
 195 // State:       not tested
 196 //
 197 //---------------------------------------------------------------------------
 198
 199 tEplKernel PUBLIC EplTimerHighReskAddInstance(void)
 200 {
 201         tEplKernel Ret;
 202         unsigned int uiIndex;
 203
 204         Ret = kEplSuccessful;
 205
 206         EPL_MEMSET(&EplTimerHighReskInstance_l, 0,
 207                    sizeof(EplTimerHighReskInstance_l));
 208
 209 #ifndef CONFIG_HIGH_RES_TIMERS
 210         printk
 211             ("EplTimerHighResk: Kernel symbol CONFIG_HIGH_RES_TIMERS is required.\n");
 212         Ret = kEplNoResource;
 213         return Ret;
 214 #endif
 215
 216         /*
 217          * Initialize hrtimer structures for all usable timers.
 218          */
 219         for (uiIndex = 0; uiIndex < TIMER_COUNT; uiIndex++) {
 220                 tEplTimerHighReskTimerInfo *pTimerInfo;
 221                 struct hrtimer *pTimer;
 222
 223                 pTimerInfo = &EplTimerHighReskInstance_l.m_aTimerInfo[uiIndex];
 224                 pTimer = &pTimerInfo->m_Timer;
 225                 hrtimer_init(pTimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
 226
 227                 pTimer->function = EplTimerHighReskCallback;
 228         }
 229
 230         return Ret;
 231 }
 232
 233 //---------------------------------------------------------------------------
 234 //
 235 // Function:    EplTimerHighReskDelInstance()
 236 //
 237 // Description: shuts down the high resolution timer module.
 238 //
 239 // Parameters:  void
 240 //
 241 // Return:      tEplKernel      = error code
 242 //
 243 // State:       not tested
 244 //
 245 //---------------------------------------------------------------------------
 246
 247 tEplKernel PUBLIC EplTimerHighReskDelInstance(void)
 248 {
 249         tEplTimerHighReskTimerInfo *pTimerInfo;
 250         tEplKernel Ret;
 251         unsigned int uiIndex;
 252
 253         Ret = kEplSuccessful;
 254
 255         for (uiIndex = 0; uiIndex < TIMER_COUNT; uiIndex++) {
 256                 pTimerInfo = &EplTimerHighReskInstance_l.m_aTimerInfo[0];
 257                 pTimerInfo->m_pfnCallback = NULL;
 258                 pTimerInfo->m_EventArg.m_TimerHdl = 0;
 259                 /*
 260                  * In this case we can not just try to cancel the timer.
 261                  * We actually have to wait until its callback function
 262                  * has returned.
 263                  */
 264                 hrtimer_cancel(&pTimerInfo->m_Timer);
 265         }
 266
 267         return Ret;
 268
 269 }
 270
 271 //---------------------------------------------------------------------------
 272 //
 273 // Function:    EplTimerHighReskModifyTimerNs()
 274 //
 275 // Description: modifies the timeout of the timer with the specified handle.
 276 //              If the handle the pointer points to is zero, the timer must
 277 //              be created first.
 278 //              If it is not possible to stop the old timer,
 279 //              this function always assures that the old timer does not
 280 //              trigger the callback function with the same handle as the new
 281 //              timer. That means the callback function must check the passed
 282 //              handle with the one returned by this function. If these are
 283 //              unequal, the call can be discarded.
 284 //
 285 // Parameters:  pTimerHdl_p     = pointer to timer handle
 286 //              ullTimeNs_p     = relative timeout in [ns]
 287 //              pfnCallback_p   = callback function, which is called mutual
 288 //                                exclusive with the Edrv callback functions
 289 //                                (Rx and Tx).
 290 //              ulArgument_p    = user-specific argument
 291 //              fContinuously_p = if TRUE, callback function will be called
 292 //                                continuously;
 293 //                                otherwise, it is a oneshot timer.
 294 //
 295 // Return:      tEplKernel      = error code
 296 //
 297 // State:       not tested
 298 //
 299 //---------------------------------------------------------------------------
 300
 301 tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p,
 302                                                 unsigned long long ullTimeNs_p,
 303                                                 tEplTimerkCallback
 304                                                 pfnCallback_p,
 305                                                 unsigned long ulArgument_p,
 306                                                 BOOL fContinuously_p)
 307 {
 308         tEplKernel Ret;
 309         unsigned int uiIndex;
 310         tEplTimerHighReskTimerInfo *pTimerInfo;
 311         ktime_t RelTime;
 312
 313         Ret = kEplSuccessful;
 314
 315         // check pointer to handle
 316         if (pTimerHdl_p == NULL) {
 317                 Ret = kEplTimerInvalidHandle;
 318                 goto Exit;
 319         }
 320
 321         if (*pTimerHdl_p == 0) {        // no timer created yet
 322
 323                 // search free timer info structure
 324                 pTimerInfo = &EplTimerHighReskInstance_l.m_aTimerInfo[0];
 325                 for (uiIndex = 0; uiIndex < TIMER_COUNT;
 326                      uiIndex++, pTimerInfo++) {
 327                         if (pTimerInfo->m_EventArg.m_TimerHdl == 0) {   // free structure found
 328                                 break;
 329                         }
 330                 }
 331                 if (uiIndex >= TIMER_COUNT) {   // no free structure found
 332                         Ret = kEplTimerNoTimerCreated;
 333                         goto Exit;
 334                 }
 335
 336                 pTimerInfo->m_EventArg.m_TimerHdl = HDL_INIT(uiIndex);
 337         } else {
 338                 uiIndex = HDL_TO_IDX(*pTimerHdl_p);
 339                 if (uiIndex >= TIMER_COUNT) {   // invalid handle
 340                         Ret = kEplTimerInvalidHandle;
 341                         goto Exit;
 342                 }
 343
 344                 pTimerInfo = &EplTimerHighReskInstance_l.m_aTimerInfo[uiIndex];
 345         }
 346
 347         /*
 348          * increment timer handle
 349          * (if timer expires right after this statement, the user
 350          * would detect an unknown timer handle and discard it)
 351          */
 352         pTimerInfo->m_EventArg.m_TimerHdl =
 353             HDL_INC(pTimerInfo->m_EventArg.m_TimerHdl);
 354         *pTimerHdl_p = pTimerInfo->m_EventArg.m_TimerHdl;
 355
 356         // reject too small time values
 357         if ((fContinuously_p && (ullTimeNs_p < TIMER_MIN_VAL_CYCLE))
 358             || (!fContinuously_p && (ullTimeNs_p < TIMER_MIN_VAL_SINGLE))) {
 359                 Ret = kEplTimerNoTimerCreated;
 360                 goto Exit;
 361         }
 362
 363         pTimerInfo->m_EventArg.m_ulArg = ulArgument_p;
 364         pTimerInfo->m_pfnCallback = pfnCallback_p;
 365         pTimerInfo->m_fContinuously = fContinuously_p;
 366         pTimerInfo->m_ullPeriod = ullTimeNs_p;
 367
 368         /*
 369          * HRTIMER_MODE_REL does not influence general handling of this timer.
 370          * It only sets relative mode for this start operation.
 371          * -> Expire time is calculated by: Now + RelTime
 372          * hrtimer_start also skips pending timer events.
 373          * The state HRTIMER_STATE_CALLBACK is ignored.
 374          * We have to cope with that in our callback function.
 375          */
 376         RelTime = ktime_add_ns(ktime_set(0, 0), ullTimeNs_p);
 377         hrtimer_start(&pTimerInfo->m_Timer, RelTime, HRTIMER_MODE_REL);
 378
 379       Exit:
 380         return Ret;
 381
 382 }
 383
 384 //---------------------------------------------------------------------------
 385 //
 386 // Function:    EplTimerHighReskDeleteTimer()
 387 //
 388 // Description: deletes the timer with the specified handle. Afterward the
 389 //              handle is set to zero.
 390 //
 391 // Parameters:  pTimerHdl_p     = pointer to timer handle
 392 //
 393 // Return:      tEplKernel      = error code
 394 //
 395 // State:       not tested
 396 //
 397 //---------------------------------------------------------------------------
 398
 399 tEplKernel PUBLIC EplTimerHighReskDeleteTimer(tEplTimerHdl * pTimerHdl_p)
 400 {
 401         tEplKernel Ret = kEplSuccessful;
 402         unsigned int uiIndex;
 403         tEplTimerHighReskTimerInfo *pTimerInfo;
 404
 405         // check pointer to handle
 406         if (pTimerHdl_p == NULL) {
 407                 Ret = kEplTimerInvalidHandle;
 408                 goto Exit;
 409         }
 410
 411         if (*pTimerHdl_p == 0) {        // no timer created yet
 412                 goto Exit;
 413         } else {
 414                 uiIndex = HDL_TO_IDX(*pTimerHdl_p);
 415                 if (uiIndex >= TIMER_COUNT) {   // invalid handle
 416                         Ret = kEplTimerInvalidHandle;
 417                         goto Exit;
 418                 }
 419                 pTimerInfo = &EplTimerHighReskInstance_l.m_aTimerInfo[uiIndex];
 420                 if (pTimerInfo->m_EventArg.m_TimerHdl != *pTimerHdl_p) {        // invalid handle
 421                         goto Exit;
 422                 }
 423         }
 424
 425         *pTimerHdl_p = 0;
 426         pTimerInfo->m_EventArg.m_TimerHdl = 0;
 427         pTimerInfo->m_pfnCallback = NULL;
 428
 429         /*
 430          * Three return cases of hrtimer_try_to_cancel have to be tracked:
 431          *  1 - timer has been removed
 432          *  0 - timer was not active
 433          *      We need not do anything. hrtimer timers just consist of
 434          *      a hrtimer struct, which we might enqueue in the hrtimers
 435          *      event list by calling hrtimer_start().
 436          *      If a timer is not enqueued, it is not present in hrtimers.
 437          * -1 - callback function is running
 438          *      In this case we have to ensure that the timer is not
 439          *      continuously restarted. This has been done by clearing
 440          *      its handle.
 441          */
 442         hrtimer_try_to_cancel(&pTimerInfo->m_Timer);
 443
 444       Exit:
 445         return Ret;
 446
 447 }
 448
 449 //---------------------------------------------------------------------------
 450 //
 451 // Function:    EplTimerHighReskCallback()
 452 //
 453 // Description: Callback function commonly used for all timers.
 454 //
 455 // Parameters:  pTimer_p = pointer to hrtimer
 456 //
 457 // Return:
 458 //
 459 // State:       not tested
 460 //
 461 //---------------------------------------------------------------------------
 462
 463 enum hrtimer_restart EplTimerHighReskCallback(struct hrtimer *pTimer_p)
 464 {
 465         unsigned int uiIndex;
 466         tEplTimerHighReskTimerInfo *pTimerInfo;
 467         tEplTimerHdl OrgTimerHdl;
 468         enum hrtimer_restart Ret;
 469
 470         BENCHMARK_MOD_24_SET(4);
 471
 472         Ret = HRTIMER_NORESTART;
 473         pTimerInfo =
 474             container_of(pTimer_p, tEplTimerHighReskTimerInfo, m_Timer);
 475         uiIndex = HDL_TO_IDX(pTimerInfo->m_EventArg.m_TimerHdl);
 476         if (uiIndex >= TIMER_COUNT) {   // invalid handle
 477                 goto Exit;
 478         }
 479
 480         /*
 481          * We store the timer handle before calling the callback function
 482          * as the timer can be modified inside it.
 483          */
 484         OrgTimerHdl = pTimerInfo->m_EventArg.m_TimerHdl;
 485
 486         if (pTimerInfo->m_pfnCallback != NULL) {
 487                 pTimerInfo->m_pfnCallback(&pTimerInfo->m_EventArg);
 488         }
 489
 490         if (pTimerInfo->m_fContinuously) {
 491                 ktime_t Interval;
 492 #ifdef PROVE_OVERRUN
 493                 ktime_t Now;
 494                 unsigned long Overruns;
 495 #endif
 496
 497                 if (OrgTimerHdl != pTimerInfo->m_EventArg.m_TimerHdl) {
 498                         /* modified timer has already been restarted */
 499                         goto Exit;
 500                 }
 501 #ifdef PROVE_OVERRUN
 502                 Now = ktime_get();
 503                 Interval =
 504                     ktime_add_ns(ktime_set(0, 0), pTimerInfo->m_ullPeriod);
 505                 Overruns = hrtimer_forward(pTimer_p, Now, Interval);
 506                 if (Overruns > 1) {
 507                         printk
 508                             ("EplTimerHighResk: Continuous timer (handle 0x%lX) had to skip %lu interval(s)!\n",
 509                              pTimerInfo->m_EventArg.m_TimerHdl, Overruns - 1);
 510                 }
 511 #else
 512                 pTimer_p->expires = ktime_add_ns(pTimer_p->expires,
 513                                                  pTimerInfo->m_ullPeriod);
 514 #endif
 515
 516                 Ret = HRTIMER_RESTART;
 517         }
 518
 519       Exit:
 520         BENCHMARK_MOD_24_RESET(4);
 521         return Ret;
 522 }