summaryrefslogtreecommitdiffstats
path: root/firmware/target/hosted/android/system-android.c
blob: 313bfbcd629bbb9bc3e2ffe43b9eaf642411d08e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (c) 2010 Thomas Martitz
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/


#include <setjmp.h>
#include <jni.h>
#include <pthread.h>
#include <unistd.h>
#include "config.h"
#include "system.h"
#include "power.h"
#include "button.h"



/* global fields for use with various JNI calls */
static JavaVM *vm_ptr;
JNIEnv *env_ptr;
jobject RockboxService_instance;
jclass  RockboxService_class;

uintptr_t *stackbegin;
uintptr_t *stackend;

extern int main(void);
extern void telephony_init_device(void);

void system_exception_wait(void)
{
    intptr_t dummy = 0;
    while(button_read_device(&dummy) != BUTTON_BACK);
}

void system_reboot(void)
{
    power_off();
}

/* this is used to return from the entry point of the native library. */
static jmp_buf poweroff_buf;
void power_off(void)
{
    longjmp(poweroff_buf, 1);
}

void system_init(void)
{
    /* no better place yet */
    telephony_init_device();
}

void hostfs_init(void)
{
    /* stub */
}

int hostfs_flush(void)
{
    sync();
    return 0;
}

JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void* reserved)
{
    (void)reserved;
    vm_ptr = vm;

    return JNI_VERSION_1_2;
}

JNIEnv* getJavaEnvironment(void)
{
    JNIEnv* env;
    (*vm_ptr)->GetEnv(vm_ptr, (void**) &env, JNI_VERSION_1_2);
    return env;
}

/* this is the entry point of the android app initially called by jni */
JNIEXPORT void JNICALL
Java_org_rockbox_RockboxService_main(JNIEnv *env, jobject this)
{
    /* hack!!! we can't have a valid stack pointer otherwise.
     * but we don't really need it anyway, thread.c only needs it
     * for overflow detection which doesn't apply for the main thread
     * (it's managed by the OS) */

    volatile uintptr_t stack = 0;
    stackbegin = stackend = (uintptr_t*) &stack;
    /* setup a jmp_buf to come back later in case of exit */
    if (setjmp(poweroff_buf) == 0)
    {
        env_ptr = env;

        RockboxService_instance = this;
        RockboxService_class = (*env)->GetObjectClass(env, this);

        main();
    }
    /* simply return here. this will allow the VM to clean up objects and do
     * garbage collection */
}


/* below is the facility for external (from other java threads) to safely call
 * into our snative code. When extracting rockbox.zip the main function is
 * called only after extraction. This delay can be accounted for by calling
 * wait_rockbox_ready(). This does not return until the critical parts of Rockbox
 * can be considered up and running. */
static pthread_cond_t btn_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t btn_mtx = PTHREAD_MUTEX_INITIALIZER;
static bool initialized;

bool is_rockbox_ready(void)
{
    /* don't bother with mutexes for this */
    return initialized;
}

void wait_rockbox_ready(void)
{
    pthread_mutex_lock(&btn_mtx);

    if (!initialized)
        pthread_cond_wait(&btn_cond, &btn_mtx);

    pthread_mutex_unlock(&btn_mtx);
}

void set_rockbox_ready(void)
{
    pthread_mutex_lock(&btn_mtx);

    initialized = true;
    /* now ready. signal all waiters */
    pthread_cond_broadcast(&btn_cond);

    pthread_mutex_unlock(&btn_mtx);
}