1 files changed, 60 insertions, 50 deletions

diff --git a/firmware/target/hosted/android/kernel-android.c b/firmware/target/hosted/android/kernel-android.c
index c0d927d026..bac6d2a8fd 100644
--- a/firmware/target/hosted/android/kernel-android.c
+++ b/firmware/target/hosted/android/kernel-android.c
@@ -20,73 +20,83 @@
  ****************************************************************************/
 
 
-#include <jni.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <unistd.h>
+#include <semaphore.h>
 #include "config.h"
 #include "system.h"
 #include "button.h"
 #include "audio.h"
+#include "panic.h"
 
-extern JNIEnv *env_ptr;
 
-extern jobject RockboxService_instance;
+static sem_t wfi_sem;
+/*
+ * call tick tasks and wake the scheduler up */
+void timer_signal(int sig)
+{
+    (void)sig;
+    call_tick_tasks();
+    interrupt();
+}
 
-static jclass  RockboxTimer_class;
-static jobject RockboxTimer_instance;
-static jmethodID java_wait_for_interrupt;
-static bool    initialized = false;
 /*
- * This is called from the separate Timer java thread. I have not added any
- * interrupt simulation to it (like the sdl counterpart does),
- * I think this is probably not needed, unless code calls disable_interrupt()
- * in order to be protected from tick tasks, but I can't remember a place right
- * now.
+ * wait on the sem which the signal handler posts to save cpu time (aka sleep)
  *
- * No synchronisation mechanism either. This could possibly be problematic,
- * but we'll see :)
- */
-JNIEXPORT void JNICALL
-Java_org_rockbox_RockboxTimer_timerTask(JNIEnv *env, jobject this)
+ * other mechanisms could use them as well */
+void wait_for_interrupt(void)
 {
-    (void)env;
-    (void)this;
-    call_tick_tasks();
+    sem_wait(&wfi_sem);
 }
 
-void tick_start(unsigned int interval_in_ms)
+void interrupt(void)
 {
-    JNIEnv e = *env_ptr;
-    /* first, create a new Timer instance */
-    RockboxTimer_class  = e->FindClass(env_ptr, "org/rockbox/RockboxTimer");
-    jmethodID constructor = e->GetMethodID(env_ptr,
-                                           RockboxTimer_class,
-                                           "<init>",
-                                           "(Landroid/content/Context;J)V");
-    /* the constructor will do the tick_start */
-    RockboxTimer_instance = e->NewObject(env_ptr,
-                                         RockboxTimer_class,
-                                         constructor,
-                                         RockboxService_instance,
-                                         (jlong)interval_in_ms);
-
-    /* get our wfi func also */
-    java_wait_for_interrupt = e->GetMethodID(env_ptr,
-                                             RockboxTimer_class,
-                                             "java_wait_for_interrupt",
-                                             "()V");
-    /* it's now safe to call java_wait_for_interrupt */
-    initialized = true;
+    int s;
+    /* unless idling, we usually have more interrupt() than wait_for_interrupt()
+     * don't post unecessarily because wait_for_interrupt() would need to
+     * decrement for each wasted sem_post(), instead of sleeping directly */
+    sem_getvalue(&wfi_sem, &s);
+    if (s <= 0)
+        sem_post(&wfi_sem);
 }
 
-void wait_for_interrupt(void)
+/*
+ * setup a hrtimer to send a signal to our process every tick */
+void tick_start(unsigned int interval_in_ms)
 {
-    if (LIKELY(initialized))
-    {
-        (*env_ptr)->CallVoidMethod(env_ptr,
-                                   RockboxTimer_instance,
-                                   java_wait_for_interrupt);
-    }
+    int ret = 0;
+    sigset_t proc_set;
+    timer_t timerid;
+    struct itimerspec ts;
+    sigevent_t sigev = {
+        .sigev_notify = SIGEV_SIGNAL,
+        .sigev_signo  = SIGUSR2,
+    };
+
+    ts.it_value.tv_sec = ts.it_interval.tv_sec = 0;
+    ts.it_value.tv_nsec = ts.it_interval.tv_nsec = interval_in_ms*1000*1000;
+
+    /* add the signal handler */
+    signal(SIGUSR2, timer_signal);
+
+    /* add the timer */
+    ret |= timer_create(CLOCK_REALTIME, &sigev, &timerid);
+    ret |= timer_settime(timerid, 0, &ts, NULL);
+
+    /* unblock SIGUSR2 so the handler can run */
+    ret |= sigprocmask(0, NULL, &proc_set);
+    ret |= sigdelset(&proc_set, SIGUSR2);
+    ret |= sigprocmask(SIG_SETMASK, &proc_set, NULL);
+
+    ret |= sem_init(&wfi_sem, 0, 0);
+
+    if (ret != 0)
+        panicf("%s(): %s\n", __func__, strerror(errno));
 }
- 
+
+
 bool timer_register(int reg_prio, void (*unregister_callback)(void),
                     long cycles, void (*timer_callback)(void))
 {