third_party/openthread/repo/examples/platforms/efr32mg12/alarm.c

   1 /*
   2  *  Copyright (c) 2020, The OpenThread Authors.
   3  *  All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions are met:
   7  *  1. Redistributions of source code must retain the above copyright
   8  *     notice, this list of conditions and the following disclaimer.
   9  *  2. Redistributions in binary form must reproduce the above copyright
  10  *     notice, this list of conditions and the following disclaimer in the
  11  *     documentation and/or other materials provided with the distribution.
  12  *  3. Neither the name of the copyright holder nor the
  13  *     names of its contributors may be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  *  POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /**
  30  * @file
  31  *   This file implements the OpenThread platform abstraction for the alarm.
  32  *
  33  */
  34
  35 #include <assert.h>
  36 #include <stdbool.h>
  37 #include <stdint.h>
  38
  39 #include "openthread-system.h"
  40 #include <openthread/config.h>
  41 #include <openthread/platform/alarm-milli.h>
  42 #include <openthread/platform/diag.h>
  43 #include "common/logging.hpp"
  44
  45 #include "platform-efr32.h"
  46 #include "utils/code_utils.h"
  47
  48 #include "em_core.h"
  49 #include "rail.h"
  50 #include "sl_sleeptimer.h"
  51
  52 #define XTAL_ACCURACY 200
  53
  54 static sl_sleeptimer_timer_handle_t sl_handle;
  55 static uint32_t                     sAlarm     = 0;
  56 static bool                         sIsRunning = false;
  57
  58 static void AlarmCallback(sl_sleeptimer_timer_handle_t *aHandle, void *aData)
  59 {
  60     otSysEventSignalPending();
  61 }
  62
  63 void efr32AlarmInit(void)
  64 {
  65     memset(&sl_handle, 0, sizeof sl_handle);
  66 }
  67
  68 uint32_t otPlatAlarmMilliGetNow(void)
  69 {
  70     uint64_t    ticks;
  71     uint64_t    now;
  72     sl_status_t status;
  73
  74     ticks  = sl_sleeptimer_get_tick_count64();
  75     status = sl_sleeptimer_tick64_to_ms(ticks, &now);
  76     assert(status == SL_STATUS_OK);
  77     return (uint32_t)now;
  78 }
  79
  80 uint32_t otPlatTimeGetXtalAccuracy(void)
  81 {
  82     return XTAL_ACCURACY;
  83 }
  84
  85 void otPlatAlarmMilliStartAt(otInstance *aInstance, uint32_t aT0, uint32_t aDt)
  86 {
  87     OT_UNUSED_VARIABLE(aInstance);
  88     sl_status_t status;
  89     int32_t     remaining;
  90     uint32_t    ticks;
  91
  92     sl_sleeptimer_stop_timer(&sl_handle);
  93
  94     sAlarm     = aT0 + aDt;
  95     remaining  = (int32_t)(sAlarm - otPlatAlarmMilliGetNow());
  96     sIsRunning = true;
  97
  98     if (remaining <= 0)
  99     {
 100         otSysEventSignalPending();
 101     }
 102     else
 103     {
 104         status = sl_sleeptimer_ms32_to_tick(remaining, &ticks);
 105         assert(status == SL_STATUS_OK);
 106
 107         status = sl_sleeptimer_start_timer(&sl_handle, ticks, AlarmCallback, NULL, 0,
 108                                            SL_SLEEPTIMER_NO_HIGH_PRECISION_HF_CLOCKS_REQUIRED_FLAG);
 109         assert(status == SL_STATUS_OK);
 110     }
 111 }
 112
 113 void otPlatAlarmMilliStop(otInstance *aInstance)
 114 {
 115     OT_UNUSED_VARIABLE(aInstance);
 116
 117     sl_sleeptimer_stop_timer(&sl_handle);
 118     sIsRunning = false;
 119 }
 120
 121 void efr32AlarmProcess(otInstance *aInstance)
 122 {
 123     int32_t remaining;
 124
 125     if (sIsRunning)
 126     {
 127         remaining = (int32_t)(sAlarm - otPlatAlarmMilliGetNow());
 128
 129         if (remaining <= 0)
 130         {
 131             sIsRunning = false;
 132
 133 #if OPENTHREAD_CONFIG_DIAG_ENABLE
 134             if (otPlatDiagModeGet())
 135             {
 136                 otPlatDiagAlarmFired(aInstance);
 137             }
 138             else
 139 #endif
 140             {
 141                 otPlatAlarmMilliFired(aInstance);
 142             }
 143         }
 144     }
 145 }