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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Felix Arends
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdlib.h>
#include "uisdl.h"
#include "kernel.h"
#include "thread-sdl.h"
#include "thread.h"
#include "debug.h"
static void (*tick_funcs[MAX_NUM_TICK_TASKS])(void);
int set_irq_level (int level)
{
static int _lv = 0;
return (_lv = level);
}
void queue_init(struct event_queue *q, bool register_queue)
{
(void)register_queue;
q->read = 0;
q->write = 0;
q->thread = NULL;
}
void queue_delete(struct event_queue *q)
{
(void)q;
}
void queue_wait(struct event_queue *q, struct event *ev)
{
while(q->read == q->write)
{
switch_thread(true, NULL);
}
*ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
}
void queue_wait_w_tmo(struct event_queue *q, struct event *ev, int ticks)
{
unsigned int timeout = current_tick + ticks;
while(q->read == q->write && TIME_BEFORE( current_tick, timeout ))
{
sim_sleep(1);
}
if(q->read != q->write)
{
*ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
}
else
{
ev->id = SYS_TIMEOUT;
}
}
void queue_post(struct event_queue *q, long id, void *data)
{
int wr;
int oldlevel;
oldlevel = set_irq_level(15<<4);
wr = (q->write++) & QUEUE_LENGTH_MASK;
q->events[wr].id = id;
q->events[wr].data = data;
set_irq_level(oldlevel);
}
bool queue_empty(const struct event_queue* q)
{
return ( q->read == q->write );
}
void queue_clear(struct event_queue* q)
{
/* fixme: This is potentially unsafe in case we do interrupt-like processing */
q->read = 0;
q->write = 0;
}
void queue_remove_from_head(struct event_queue *q, long id)
{
int oldlevel = set_irq_level(15<<4);
while (q->read != q->write &&
q->events[(q->read) & QUEUE_LENGTH_MASK].id == id)
{
q->read++;
}
set_irq_level(oldlevel);
}
void switch_thread(bool save_context, struct thread_entry **blocked_list)
{
(void)save_context;
(void)blocked_list;
yield ();
}
void sim_tick_tasks(void)
{
int i;
/* Run through the list of tick tasks */
for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
{
if(tick_funcs[i])
{
tick_funcs[i]();
}
}
}
int tick_add_task(void (*f)(void))
{
int i;
/* Add a task if there is room */
for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
{
if(tick_funcs[i] == NULL)
{
tick_funcs[i] = f;
return 0;
}
}
DEBUGF("Error! tick_add_task(): out of tasks");
return -1;
}
int tick_remove_task(void (*f)(void))
{
int i;
/* Remove a task if it is there */
for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
{
if(tick_funcs[i] == f)
{
tick_funcs[i] = NULL;
return 0;
}
}
return -1;
}
/* Very simple mutex simulation - won't work with pre-emptive
multitasking, but is better than nothing at all */
void mutex_init(struct mutex *m)
{
m->locked = false;
}
void mutex_lock(struct mutex *m)
{
while(m->locked)
switch_thread(true, NULL);
m->locked = true;
}
void mutex_unlock(struct mutex *m)
{
m->locked = false;
}
|
