FS#8961 - Anti-Aliased Fonts.
[kugel-rb.git] / firmware / export / kernel.h
bloba21b0b3cee36407b75029454be695002c0a14e3a
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2002 by Björn Stenberg
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
21 #ifndef _KERNEL_H_
22 #define _KERNEL_H_
24 #include <stdbool.h>
25 #include <inttypes.h>
26 #include "config.h"
28 #include "thread.h"
30 /* wrap-safe macros for tick comparison */
31 #define TIME_AFTER(a,b) ((long)(b) - (long)(a) < 0)
32 #define TIME_BEFORE(a,b) TIME_AFTER(b,a)
34 #define HZ 100 /* number of ticks per second */
36 #define MAX_NUM_TICK_TASKS 8
38 #define MAX_NUM_QUEUES 32
39 #define QUEUE_LENGTH 16 /* MUST be a power of 2 */
40 #define QUEUE_LENGTH_MASK (QUEUE_LENGTH - 1)
42 /* System defined message ID's - |sign bit = 1|class|id| */
43 /* Event class list */
44 #define SYS_EVENT_CLS_QUEUE 0
45 #define SYS_EVENT_CLS_USB 1
46 #define SYS_EVENT_CLS_POWER 2
47 #define SYS_EVENT_CLS_FILESYS 3
48 #define SYS_EVENT_CLS_PLUG 4
49 #define SYS_EVENT_CLS_MISC 5
50 #define SYS_EVENT_CLS_PRIVATE 7 /* For use inside plugins */
51 /* make sure SYS_EVENT_CLS_BITS has enough range */
53 /* Bit 31->|S|c...c|i...i| */
54 #define SYS_EVENT ((long)(int)(1 << 31))
55 #define SYS_EVENT_CLS_BITS (3)
56 #define SYS_EVENT_CLS_SHIFT (31-SYS_EVENT_CLS_BITS)
57 #define SYS_EVENT_CLS_MASK (((1l << SYS_EVENT_CLS_BITS)-1) << SYS_EVENT_SHIFT)
58 #define MAKE_SYS_EVENT(cls, id) (SYS_EVENT | ((long)(cls) << SYS_EVENT_CLS_SHIFT) | (long)(id))
59 /* Macros for extracting codes */
60 #define SYS_EVENT_CLS(e) (((e) & SYS_EVENT_CLS_MASK) >> SYS_EVENT_SHIFT)
61 #define SYS_EVENT_ID(e) ((e) & ~(SYS_EVENT|SYS_EVENT_CLS_MASK))
63 #define SYS_TIMEOUT MAKE_SYS_EVENT(SYS_EVENT_CLS_QUEUE, 0)
64 #define SYS_USB_CONNECTED MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 0)
65 #define SYS_USB_CONNECTED_ACK MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 1)
66 #define SYS_USB_DISCONNECTED MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 2)
67 #define SYS_USB_DISCONNECTED_ACK MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 3)
68 #define SYS_USB_LUN_LOCKED MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 4)
69 #define SYS_USB_READ_DATA MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 5)
70 #define SYS_USB_WRITE_DATA MAKE_SYS_EVENT(SYS_EVENT_CLS_USB, 6)
71 #define SYS_POWEROFF MAKE_SYS_EVENT(SYS_EVENT_CLS_POWER, 0)
72 #define SYS_CHARGER_CONNECTED MAKE_SYS_EVENT(SYS_EVENT_CLS_POWER, 1)
73 #define SYS_CHARGER_DISCONNECTED MAKE_SYS_EVENT(SYS_EVENT_CLS_POWER, 2)
74 #define SYS_BATTERY_UPDATE MAKE_SYS_EVENT(SYS_EVENT_CLS_POWER, 3)
75 #define SYS_FS_CHANGED MAKE_SYS_EVENT(SYS_EVENT_CLS_FILESYS, 0)
76 #define SYS_HOTSWAP_INSERTED MAKE_SYS_EVENT(SYS_EVENT_CLS_PLUG, 0)
77 #define SYS_HOTSWAP_EXTRACTED MAKE_SYS_EVENT(SYS_EVENT_CLS_PLUG, 1)
78 #define SYS_PHONE_PLUGGED MAKE_SYS_EVENT(SYS_EVENT_CLS_PLUG, 2)
79 #define SYS_PHONE_UNPLUGGED MAKE_SYS_EVENT(SYS_EVENT_CLS_PLUG, 3)
80 #define SYS_REMOTE_PLUGGED MAKE_SYS_EVENT(SYS_EVENT_CLS_PLUG, 4)
81 #define SYS_REMOTE_UNPLUGGED MAKE_SYS_EVENT(SYS_EVENT_CLS_PLUG, 5)
82 #define SYS_CAR_ADAPTER_RESUME MAKE_SYS_EVENT(SYS_EVENT_CLS_MISC, 0)
83 #define SYS_IAP_PERIODIC MAKE_SYS_EVENT(SYS_EVENT_CLS_MISC, 1)
84 #define SYS_IAP_HANDLEPKT MAKE_SYS_EVENT(SYS_EVENT_CLS_MISC, 2)
86 #define IS_SYSEVENT(ev) ((ev & SYS_EVENT) == SYS_EVENT)
88 #ifndef TIMEOUT_BLOCK
89 #define TIMEOUT_BLOCK -1
90 #define TIMEOUT_NOBLOCK 0
91 #endif
93 struct queue_event
95 long id;
96 intptr_t data;
99 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
100 struct queue_sender_list
102 /* If non-NULL, there is a thread waiting for the corresponding event */
103 /* Must be statically allocated to put in non-cached ram. */
104 struct thread_entry *senders[QUEUE_LENGTH]; /* message->thread map */
105 struct thread_entry *list; /* list of senders in map */
106 /* Send info for last message dequeued or NULL if replied or not sent */
107 struct thread_entry *curr_sender;
108 #ifdef HAVE_PRIORITY_SCHEDULING
109 struct blocker blocker;
110 #endif
112 #endif /* HAVE_EXTENDED_MESSAGING_AND_NAME */
114 #ifdef HAVE_PRIORITY_SCHEDULING
115 #define QUEUE_GET_THREAD(q) \
116 (((q)->send == NULL) ? NULL : (q)->send->blocker.thread)
117 #else
118 /* Queue without priority enabled have no owner provision _at this time_ */
119 #define QUEUE_GET_THREAD(q) \
120 (NULL)
121 #endif
123 struct event_queue
125 struct thread_entry *queue; /* waiter list */
126 struct queue_event events[QUEUE_LENGTH]; /* list of events */
127 unsigned int read; /* head of queue */
128 unsigned int write; /* tail of queue */
129 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
130 struct queue_sender_list *send; /* list of threads waiting for
131 reply to an event */
132 #ifdef HAVE_PRIORITY_SCHEDULING
133 struct blocker *blocker_p; /* priority inheritance info
134 for sync message senders */
135 #endif
136 #endif
137 IF_COP( struct corelock cl; ) /* multiprocessor sync */
140 #ifdef HAVE_PRIORITY_SCHEDULING
141 #define MUTEX_SET_THREAD(m, t) ((m)->blocker.thread = (t))
142 #define MUTEX_GET_THREAD(m) ((m)->blocker.thread)
143 #else
144 #define MUTEX_SET_THREAD(m, t) ((m)->thread = (t))
145 #define MUTEX_GET_THREAD(m) ((m)->thread)
146 #endif
148 struct mutex
150 struct thread_entry *queue; /* waiter list */
151 int count; /* lock owner recursion count */
152 #ifdef HAVE_PRIORITY_SCHEDULING
153 struct blocker blocker; /* priority inheritance info
154 for waiters */
155 bool no_preempt; /* don't allow higher-priority thread
156 to be scheduled even if woken */
157 #else
158 struct thread_entry *thread;
159 #endif
160 IF_COP( struct corelock cl; ) /* multiprocessor sync */
161 unsigned char locked; /* locked semaphore */
164 #ifdef HAVE_SEMAPHORE_OBJECTS
165 struct semaphore
167 struct thread_entry *queue; /* Waiter list */
168 int count; /* # of waits remaining before unsignaled */
169 int max; /* maximum # of waits to remain signaled */
170 IF_COP( struct corelock cl; ) /* multiprocessor sync */
172 #endif
174 #ifdef HAVE_WAKEUP_OBJECTS
175 struct wakeup
177 struct thread_entry *queue; /* waiter list */
178 unsigned char signalled; /* signalled status */
179 IF_COP( struct corelock cl; ) /* multiprocessor sync */
181 #endif
184 /* global tick variable */
185 #if defined(CPU_PP) && defined(BOOTLOADER)
186 /* We don't enable interrupts in the iPod bootloader, so we need to fake
187 the current_tick variable */
188 #define current_tick (signed)(USEC_TIMER/10000)
190 static inline void call_tick_tasks(void)
193 #else
194 extern volatile long current_tick;
196 /* inline helper for implementing target interrupt handler */
197 static inline void call_tick_tasks(void)
199 extern void (*tick_funcs[MAX_NUM_TICK_TASKS+1])(void);
200 void (**p)(void) = tick_funcs;
201 void (*fn)(void);
203 current_tick++;
205 for(fn = *p; fn != NULL; fn = *(++p))
207 fn();
210 #endif
212 #if defined(SIMULATOR) && !defined(PLUGIN) && !defined(CODEC)
213 #define sleep(x) sim_sleep(x)
214 #endif
216 /* kernel functions */
217 extern void kernel_init(void);
218 extern void yield(void);
219 extern void sleep(int ticks);
220 int tick_add_task(void (*f)(void));
221 int tick_remove_task(void (*f)(void));
222 extern void tick_start(unsigned int interval_in_ms);
224 #ifdef INCLUDE_TIMEOUT_API
225 struct timeout;
227 /* timeout callback type
228 * tmo - pointer to struct timeout associated with event
229 * return next interval or <= 0 to stop event
231 #define MAX_NUM_TIMEOUTS 8
232 typedef int (* timeout_cb_type)(struct timeout *tmo);
234 struct timeout
236 timeout_cb_type callback;/* callback - returning false cancels */
237 intptr_t data; /* data passed to callback */
238 long expires; /* expiration tick */
241 void timeout_register(struct timeout *tmo, timeout_cb_type callback,
242 int ticks, intptr_t data);
243 void timeout_cancel(struct timeout *tmo);
244 #endif /* INCLUDE_TIMEOUT_API */
246 #define STATE_NONSIGNALED 0
247 #define STATE_SIGNALED 1
249 #define OBJ_WAIT_TIMEDOUT (-1)
250 #define OBJ_WAIT_FAILED 0
251 #define OBJ_WAIT_SUCCEEDED 1
253 extern void queue_init(struct event_queue *q, bool register_queue);
254 extern void queue_delete(struct event_queue *q);
255 extern void queue_wait(struct event_queue *q, struct queue_event *ev);
256 extern void queue_wait_w_tmo(struct event_queue *q, struct queue_event *ev,
257 int ticks);
258 extern void queue_post(struct event_queue *q, long id, intptr_t data);
259 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
260 extern void queue_enable_queue_send(struct event_queue *q,
261 struct queue_sender_list *send,
262 unsigned int owner_id);
263 extern intptr_t queue_send(struct event_queue *q, long id, intptr_t data);
264 extern void queue_reply(struct event_queue *q, intptr_t retval);
265 extern bool queue_in_queue_send(struct event_queue *q);
266 #endif /* HAVE_EXTENDED_MESSAGING_AND_NAME */
267 extern bool queue_empty(const struct event_queue* q);
268 extern bool queue_peek(struct event_queue *q, struct queue_event *ev);
269 extern void queue_clear(struct event_queue* q);
270 extern void queue_remove_from_head(struct event_queue *q, long id);
271 extern int queue_count(const struct event_queue *q);
272 extern int queue_broadcast(long id, intptr_t data);
274 extern void mutex_init(struct mutex *m);
275 extern void mutex_lock(struct mutex *m);
276 extern void mutex_unlock(struct mutex *m);
277 #ifdef HAVE_PRIORITY_SCHEDULING
278 /* Temporary function to disable mutex preempting a thread on unlock */
279 static inline void mutex_set_preempt(struct mutex *m, bool preempt)
280 { m->no_preempt = !preempt; }
281 #endif
282 #ifdef HAVE_SEMAPHORE_OBJECTS
283 extern void semaphore_init(struct semaphore *s, int max, int start);
284 extern void semaphore_wait(struct semaphore *s);
285 extern void semaphore_release(struct semaphore *s);
286 #endif /* HAVE_SEMAPHORE_OBJECTS */
288 #ifdef HAVE_WAKEUP_OBJECTS
289 extern void wakeup_init(struct wakeup *w);
290 extern int wakeup_wait(struct wakeup *w, int timeout);
291 extern int wakeup_signal(struct wakeup *w);
292 #endif /* HAVE_WAKEUP_OBJECTS */
294 #endif /* _KERNEL_H_ */