DO NOT MERGE ANYWHERE: apps: export rtcGetTime and add hostGetTime

Here are the different "time" functions:
timGetTime: time based on clock ticks while awake + rtc time when stopped
rtcGetTime: time based on rtc time
hostGetTime: estimated host time (or 0 if we don't have one)
sensorGetTime: time to put into referenceTime in a sensor packet

Bug: 28290568

Change-Id: Ib2f0e708375c36c1479c672020472ba7a4b8fc8c
Signed-off-by: Ben Fennema <fennema@google.com>
(cherry picked from commit ff2d397716fa332b2771e9719101e52970c7c657)

10 files changed, 103 insertions, 18 deletions

diff --git a/firmware/app/test0.app/test_app0.c b/firmware/app/test0.app/test_app0.c
index cd600331..8f45bcc4 100644
--- a/firmware/app/test0.app/test_app0.c
+++ b/firmware/app/test0.app/test_app0.c
@@ -56,7 +56,7 @@ static void handle_event(uint32_t evtType, const void* evtData)
         eOsLog(LOG_INFO, "App 0 started with tid %u timerid %u\n", mMyTid, timerId);
     } else if (evtType == EVT_APP_TIMER) {
         te = evtData;
-        eOsLog(LOG_INFO, "App 0 received timer %u callback: %d\n", te->timerId, *(int *)te->data);
+        eOsLog(LOG_INFO, "App 0 received timer %u callback: %d (TIM: %lld, RTC: %lld, SENSOR: %lld, HOST: %lld)\n", te->timerId, *(int *)te->data, eOsTimGetTime(), eOsRtcGetTime(), eOsSensorGetTime(), eOsHostGetTime());
         extMsg = eOsHeapAlloc(sizeof(*extMsg));
         extMsg->hdr.appId = APP_ID_MAKE(APP_ID_VENDOR_GOOGLE, 0x548000);
         extMsg->hdr.dataLen = 5;
diff --git a/firmware/inc/nanohubCommand.h b/firmware/inc/nanohubCommand.h
index be87b742..992575ec 100644
--- a/firmware/inc/nanohubCommand.h
+++ b/firmware/inc/nanohubCommand.h
@@ -38,5 +38,6 @@ struct NanohubHalCommand {
 };
 
 const struct NanohubHalCommand *nanohubHalFindCommand(uint8_t msg);
+uint64_t hostGetTime(void);
 
 #endif /* __NANOHUBCOMMAND_H */
diff --git a/firmware/inc/osApi.h b/firmware/inc/osApi.h
index 2a7a7866..20b2158b 100644
--- a/firmware/inc/osApi.h
+++ b/firmware/inc/osApi.h
@@ -81,7 +81,9 @@ union OsApiSlabItem { //main OS "things" slab must fit this
 #define SYSCALL_OS_MAIN_TIME              3
 #define SYSCALL_OS_MAIN_HEAP              4
 #define SYSCALL_OS_MAIN_SLAB              5
-#define SYSCALL_OS_MAIN_LAST              6 // always last. holes are allowed, but not immediately before this
+#define SYSCALL_OS_MAIN_HOST              6
+#define SYSCALL_OS_MAIN_RTC               7
+#define SYSCALL_OS_MAIN_LAST              8 // always last. holes are allowed, but not immediately before this
 
 //level 3 indices in the OS.main.event_queue table
 #define SYSCALL_OS_MAIN_EVTQ_SUBCRIBE        0 // (uint32_t tid, uint32_t evtType) -> bool success
@@ -107,7 +109,8 @@ union OsApiSlabItem { //main OS "things" slab must fit this
 #define SYSCALL_OS_MAIN_SENSOR_RELEASE       7 // (uint32_t clientId, uint32_t sensorHandle) -> bool success
 #define SYSCALL_OS_MAIN_SENSOR_TRIGGER       8 // (uint32_t clientId, uint32_t sensorHandle) -> bool success
 #define SYSCALL_OS_MAIN_SENSOR_GET_RATE      9 // (uint32_t sensorHandle) -> uint32_t rate
-#define SYSCALL_OS_MAIN_SENSOR_LAST         10 // always last. holes are allowed, but not immediately before this
+#define SYSCALL_OS_MAIN_SENSOR_GET_TIME     10 // (uint64_t *timeNanos) -> void
+#define SYSCALL_OS_MAIN_SENSOR_LAST         11 // always last. holes are allowed, but not immediately before this
 
 //level 3 indices in the OS.main.timer table
 #define SYSCALL_OS_MAIN_TIME_GET_TIME     0 // (uint64_t *timeNanos) -> void
@@ -127,6 +130,13 @@ union OsApiSlabItem { //main OS "things" slab must fit this
 #define SYSCALL_OS_MAIN_SLAB_FREE         3 // (struct SlabAllocator *slab, void *mem) -> void
 #define SYSCALL_OS_MAIN_SLAB_LAST         4 // always last. holes are allowed, but not immediately before this
 
+//level 3 indices in the OS.main.host table
+#define SYSCALL_OS_MAIN_HOST_GET_TIME     0 // (uint64_t *timeNanos) -> void
+#define SYSCALL_OS_MAIN_HOST_LAST         1
+
+//level 3 indices in the OS.main.rtc table
+#define SYSCALL_OS_MAIN_RTC_GET_TIME      0 // (uint64_t *timeNanos) -> void
+#define SYSCALL_OS_MAIN_RTC_LAST          1
 
 //called by os entry point to export the api
 void osApiExport(struct SlabAllocator *mainSlubAllocator);
diff --git a/firmware/inc/sensors.h b/firmware/inc/sensors.h
index 7679b686..c96ef8df 100644
--- a/firmware/inc/sensors.h
+++ b/firmware/inc/sensors.h
@@ -264,6 +264,7 @@ bool sensorCalibrate(uint32_t sensorHandle);
 bool sensorCfgData(uint32_t sensorHandle, void* cfgData);
 uint32_t sensorGetCurRate(uint32_t sensorHandle);
 uint64_t sensorGetCurLatency(uint32_t sensorHandle);
+uint64_t sensorGetTime(void);
 bool sensorGetInitComplete(uint32_t sensorHandle); // DO NOT poll on this value
 bool sensorMarshallEvent(uint32_t sensorHandle, uint32_t evtType, void *evtData, TaggedPtr *evtFreeingInfoP);
 
diff --git a/firmware/inc/syscallDo.h b/firmware/inc/syscallDo.h
index 97c2fcf3..7dba269e 100644
--- a/firmware/inc/syscallDo.h
+++ b/firmware/inc/syscallDo.h
@@ -208,6 +208,13 @@ static inline uint32_t eOsSensorGetCurRate(uint32_t sensorHandle)
     return syscallDo1P(SYSCALL_NO(SYSCALL_DOMAIN_OS, SYSCALL_OS_MAIN, SYSCALL_OS_MAIN_SENSOR, SYSCALL_OS_MAIN_SENSOR_GET_RATE), sensorHandle);
 }
 
+static inline uint64_t eOsSensorGetTime(void)
+{
+    uint64_t timeNanos;
+    syscallDo1P(SYSCALL_NO(SYSCALL_DOMAIN_OS, SYSCALL_OS_MAIN, SYSCALL_OS_MAIN_SENSOR, SYSCALL_OS_MAIN_SENSOR_GET_TIME), &timeNanos);
+    return timeNanos;
+}
+
 static inline uint64_t eOsTimGetTime(void)
 {
     uint64_t timeNanos;
@@ -258,6 +265,20 @@ static inline void eOsSlabAllocatorFree(struct SlabAllocator* allocator, void* p
     (void)syscallDo2P(SYSCALL_NO(SYSCALL_DOMAIN_OS, SYSCALL_OS_MAIN, SYSCALL_OS_MAIN_SLAB, SYSCALL_OS_MAIN_SLAB_FREE), allocator, ptrP);
 }
 
+static inline uint64_t eOsHostGetTime(void)
+{
+    uint64_t timeNanos;
+    syscallDo1P(SYSCALL_NO(SYSCALL_DOMAIN_OS, SYSCALL_OS_MAIN, SYSCALL_OS_MAIN_HOST, SYSCALL_OS_MAIN_HOST_GET_TIME), &timeNanos);
+    return timeNanos;
+}
+
+static inline uint64_t eOsRtcGetTime(void)
+{
+    uint64_t timeNanos;
+    syscallDo1P(SYSCALL_NO(SYSCALL_DOMAIN_OS, SYSCALL_OS_MAIN, SYSCALL_OS_MAIN_RTC, SYSCALL_OS_MAIN_RTC_GET_TIME), &timeNanos);
+    return timeNanos;
+}
+
 static inline struct Gpio* eOsGpioRequest(uint32_t gpioNum)
 {
     return (struct Gpio*)syscallDo1P(SYSCALL_NO(SYSCALL_DOMAIN_OS, SYSCALL_OS_DRIVERS, SYSCALL_OS_DRV_GPIO, SYSCALL_OS_DRV_GPIO_REQ), gpioNum);
diff --git a/firmware/src/drivers/bosch_bmi160/bosch_bmi160.c b/firmware/src/drivers/bosch_bmi160/bosch_bmi160.c
index 352b0d6c..09af7459 100644
--- a/firmware/src/drivers/bosch_bmi160/bosch_bmi160.c
+++ b/firmware/src/drivers/bosch_bmi160/bosch_bmi160.c
@@ -2777,14 +2777,14 @@ static void handleSpiDoneEvt(const void* evtData)
         break;
     case SENSOR_TIME_SYNC:
         SensorTime = parseSensortime(mTask.sensorTimeBuffer[1] | (mTask.sensorTimeBuffer[2] << 8) | (mTask.sensorTimeBuffer[3] << 16));
-        map_sensortime_to_rtc_time(SensorTime, rtcGetTime());
+        map_sensortime_to_rtc_time(SensorTime, sensorGetTime());
 
         temperature16 = (mTask.temperatureBuffer[1] | (mTask.temperatureBuffer[2] << 8));
         if (temperature16 == 0x8000) {
             mTask.tempCelsius = kTempInvalid;
         } else {
             mTask.tempCelsius = 23.0f + temperature16 * kScale_temp;
-            mTask.tempTime = rtcGetTime();
+            mTask.tempTime = sensorGetTime();
         }
 
         if (mTask.active_poll_generation == mTask.poll_generation) {
diff --git a/firmware/src/hostIntf.c b/firmware/src/hostIntf.c
index 43144b93..35067671 100644
--- a/firmware/src/hostIntf.c
+++ b/firmware/src/hostIntf.c
@@ -353,7 +353,7 @@ void hostIntfRxPacket(bool wakeupActive)
 
 static void hostIntfRxDone(size_t rx, int err)
 {
-    mRxTimestamp = rtcGetTime();
+    mRxTimestamp = sensorGetTime();
     mRxSize = rx;
 
     if (err != 0) {
@@ -1034,7 +1034,7 @@ static void hostIntfHandleEvent(uint32_t evtType, const void* evtData)
 {
     struct ConfigCmd *cmd;
     uint32_t i, cnt;
-    uint64_t rtcTime;
+    uint64_t sensorTime;
     struct ActiveSensor *sensor;
     uint32_t tempSensorHandle;
     const struct HostHubRawPacket *hostMsg;
@@ -1091,12 +1091,12 @@ static void hostIntfHandleEvent(uint32_t evtType, const void* evtData)
     }
 #endif
     else if (evtType == EVT_LATENCY_TIMER) {
-        rtcTime = rtcGetTime();
+        sensorTime = sensorGetTime();
 
         for (i = 0, cnt = 0; i < mNumSensors && cnt < mLatencyCnt; i++) {
             if (mActiveSensorTable[i].latency > 0) {
                 cnt++;
-                if (mActiveSensorTable[i].firstTime && rtcTime >= mActiveSensorTable[i].firstTime + mActiveSensorTable[i].latency) {
+                if (mActiveSensorTable[i].firstTime && sensorTime >= mActiveSensorTable[i].firstTime + mActiveSensorTable[i].latency) {
                     hostIntfSetInterrupt(mActiveSensorTable[i].interrupt);
                 }
             }
@@ -1201,14 +1201,14 @@ static void hostIntfHandleEvent(uint32_t evtType, const void* evtData)
 
                 switch (sensor->numAxis) {
                 case NUM_AXIS_EMBEDDED:
-                    rtcTime = rtcGetTime();
-                    if (sensor->buffer.length > 0 && rtcTime - sensor->lastTime >= delta_time_max) {
+                    sensorTime = sensorGetTime();
+                    if (sensor->buffer.length > 0 && sensorTime - sensor->lastTime >= delta_time_max) {
                         simpleQueueEnqueue(mOutputQ, &sensor->buffer, sizeof(uint32_t) + sensor->buffer.length, sensor->discard);
                         resetBuffer(sensor);
                     }
                     if (sensor->buffer.length == 0) {
                         sensor->buffer.length = sizeof(struct SingleAxisDataEvent) + sizeof(struct SingleAxisDataPoint);
-                        sensor->lastTime = sensor->buffer.referenceTime = rtcTime;
+                        sensor->lastTime = sensor->buffer.referenceTime = sensorTime;
                         if (sensor->interrupt == NANOHUB_INT_WAKEUP)
                             mWakeupBlocks++;
                         else if (sensor->interrupt == NANOHUB_INT_NONWAKEUP)
@@ -1218,8 +1218,8 @@ static void hostIntfHandleEvent(uint32_t evtType, const void* evtData)
                         sensor->buffer.single[0].idata = (uint32_t)evtData;
                     } else {
                         sensor->buffer.length += sizeof(struct SingleAxisDataPoint);
-                        sensor->buffer.single[sensor->buffer.firstSample.numSamples].deltaTime = encodeDeltaTime(rtcTime - sensor->lastTime);
-                        sensor->lastTime = rtcTime;
+                        sensor->buffer.single[sensor->buffer.firstSample.numSamples].deltaTime = encodeDeltaTime(sensorTime - sensor->lastTime);
+                        sensor->lastTime = sensorTime;
                         sensor->buffer.single[sensor->buffer.firstSample.numSamples].idata = (uint32_t)evtData;
                         sensor->buffer.firstSample.numSamples++;
                     }
@@ -1240,12 +1240,12 @@ static void hostIntfHandleEvent(uint32_t evtType, const void* evtData)
                 }
             }
 
-            rtcTime = rtcGetTime();
+            sensorTime = sensorGetTime();
 
             if (sensor->firstTime &&
-                ((rtcTime >= sensor->firstTime + sensor->latency) ||
+                ((sensorTime >= sensor->firstTime + sensor->latency) ||
                  ((sensor->latency > sensorGetCurLatency(sensor->sensorHandle)) &&
-                  (rtcTime + sensorGetCurLatency(sensor->sensorHandle) > sensor->firstTime + sensor->latency)))) {
+                  (sensorTime + sensorGetCurLatency(sensor->sensorHandle) > sensor->firstTime + sensor->latency)))) {
                 interrupt = sensor->interrupt;
             } else if (mWakeupBlocks + mNonWakeupBlocks >= mTotalBlocks) {
                 interrupt = sensor->interrupt;
diff --git a/firmware/src/nanohubCommand.c b/firmware/src/nanohubCommand.c
index d037d2d5..9e5efe6c 100644
--- a/firmware/src/nanohubCommand.c
+++ b/firmware/src/nanohubCommand.c
@@ -15,7 +15,6 @@
  */
 
 #include <plat/inc/taggedPtr.h>
-#include <plat/inc/rtc.h>
 #include <inttypes.h>
 #include <string.h>
 #include <stdint.h>
@@ -1135,3 +1134,13 @@ const struct NanohubHalCommand *nanohubHalFindCommand(uint8_t msg)
     }
     return NULL;
 }
+
+uint64_t hostGetTime(void)
+{
+    uint64_t delta = getAvgDelta(&mTimeSync);
+
+    if (!delta)
+        return 0ULL;
+    else
+        return sensorGetTime() + delta;
+}
diff --git a/firmware/src/osApi.c b/firmware/src/osApi.c
index 47155761..a1c1624c 100644
--- a/firmware/src/osApi.c
+++ b/firmware/src/osApi.c
@@ -15,6 +15,7 @@
  */
 
 #include <plat/inc/taggedPtr.h>
+#include <plat/inc/rtc.h>
 #include <syscall.h>
 #include <sensors.h>
 #include <errno.h>
@@ -26,6 +27,7 @@
 #include <slab.h>
 #include <heap.h>
 #include <i2c.h>
+#include <nanohubCommand.h>
 
 static struct SlabAllocator *mSlabAllocator;
 
@@ -183,6 +185,12 @@ static void osExpApiSensorGetRate(uintptr_t *retValP, va_list args)
     *retValP = sensorGetCurRate(sensorHandle);
 }
 
+static void osExpApiSensorGetTime(uintptr_t *retValP, va_list args)
+{
+    uint64_t *timeNanos = va_arg(args, uint64_t *);
+    *timeNanos = sensorGetTime();
+}
+
 static void osExpApiTimGetTime(uintptr_t *retValP, va_list args)
 {
     uint64_t *timeNanos = va_arg(args, uint64_t *);
@@ -255,6 +263,18 @@ static void osExpApiSlabFree(uintptr_t *retValP, va_list args)
     slabAllocatorFree(allocator, mem);
 }
 
+static void osExpApiHostGetTime(uintptr_t *retValP, va_list args)
+{
+    uint64_t *timeNanos = va_arg(args, uint64_t *);
+    *timeNanos = hostGetTime();
+}
+
+static void osExpApiRtcGetTime(uintptr_t *retValP, va_list args)
+{
+    uint64_t *timeNanos = va_arg(args, uint64_t *);
+    *timeNanos = rtcGetTime();
+}
+
 static union OsApiSlabItem* osExpApiI2cCbkInfoAlloc(uint32_t tid, void *cookie)
 {
     union OsApiSlabItem *thing = slabAllocatorAlloc(mSlabAllocator);
@@ -490,6 +510,7 @@ void osApiExport(struct SlabAllocator *mainSlubAllocator)
             [SYSCALL_OS_MAIN_SENSOR_RELEASE]       = { .func = osExpApiSensorRel,     },
             [SYSCALL_OS_MAIN_SENSOR_TRIGGER]       = { .func = osExpApiSensorTrigger, },
             [SYSCALL_OS_MAIN_SENSOR_GET_RATE]      = { .func = osExpApiSensorGetRate, },
+            [SYSCALL_OS_MAIN_SENSOR_GET_TIME]      = { .func = osExpApiSensorGetTime, },
 
         },
     };
@@ -521,6 +542,20 @@ void osApiExport(struct SlabAllocator *mainSlubAllocator)
         },
     };
 
+    static const struct SyscallTable osMainHostTable = {
+        .numEntries = SYSCALL_OS_MAIN_HOST_LAST,
+        .entry = {
+            [SYSCALL_OS_MAIN_HOST_GET_TIME] = { .func = osExpApiHostGetTime },
+        },
+    };
+
+    static const struct SyscallTable osMainRtcTable = {
+        .numEntries = SYSCALL_OS_MAIN_RTC_LAST,
+        .entry = {
+            [SYSCALL_OS_MAIN_RTC_GET_TIME] = { .func = osExpApiRtcGetTime },
+        },
+    };
+
     static const struct SyscallTable osMainTable = {
         .numEntries = SYSCALL_OS_MAIN_LAST,
         .entry = {
@@ -530,6 +565,8 @@ void osApiExport(struct SlabAllocator *mainSlubAllocator)
             [SYSCALL_OS_MAIN_TIME]    = { .subtable = (struct SyscallTable*)&osMainTimerTable,   },
             [SYSCALL_OS_MAIN_HEAP]    = { .subtable = (struct SyscallTable*)&osMainHeapTable,    },
             [SYSCALL_OS_MAIN_SLAB]    = { .subtable = (struct SyscallTable*)&osMainSlabTable,    },
+            [SYSCALL_OS_MAIN_HOST]    = { .subtable = (struct SyscallTable*)&osMainHostTable,    },
+            [SYSCALL_OS_MAIN_RTC]     = { .subtable = (struct SyscallTable*)&osMainRtcTable,     },
         },
     };
 
diff --git a/firmware/src/sensors.c b/firmware/src/sensors.c
index 4468e54d..81d8033f 100644
--- a/firmware/src/sensors.c
+++ b/firmware/src/sensors.c
@@ -15,6 +15,7 @@
  */
 
 #include <plat/inc/taggedPtr.h>
+#include <plat/inc/rtc.h>
 #include <cpu/inc/barrier.h>
 #include <atomicBitset.h>
 #include <inttypes.h>
@@ -761,6 +762,11 @@ uint64_t sensorGetCurLatency(uint32_t sensorHandle)
     return s ? s->currentLatency : SENSOR_LATENCY_INVALID;
 }
 
+uint64_t sensorGetTime(void)
+{
+    return rtcGetTime();
+}
+
 bool sensorGetInitComplete(uint32_t sensorHandle)
 {
     struct Sensor* s = sensorFindByHandle(sensorHandle);