uisimulator/sdl/kernel.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Felix Arends
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdlib.h>
  21 #include "memory.h"
  22 #include "uisdl.h"
  23 #include "kernel.h"
  24 #include "thread-sdl.h"
  25 #include "thread.h"
  26 #include "debug.h"
  27
  28 static void (*tick_funcs[MAX_NUM_TICK_TASKS])(void);
  29
  30 int set_irq_level (int level)
  31 {
  32     static int _lv = 0;
  33     return (_lv = level);
  34 }
  35
  36 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
  37 /* Moves waiting thread's descriptor to the current sender when a
  38    message is dequeued */
  39 static void queue_fetch_sender(struct queue_sender_list *send,
  40                                unsigned int i)
  41 {
  42     int old_level = set_irq_level(15<<4);
  43     struct queue_sender **spp = &send->senders[i];
  44
  45     if(*spp)
  46     {
  47         send->curr_sender = *spp;
  48         *spp = NULL;
  49     }
  50
  51     set_irq_level(old_level);
  52 }
  53
  54 /* Puts the specified return value in the waiting thread's return value
  55    and wakes the thread  - a sender should be confirmed to exist first */
  56 static void queue_release_sender(struct queue_sender **sender,
  57                                  intptr_t retval)
  58 {
  59     (*sender)->retval = retval;
  60     *sender = NULL;
  61 }
  62
  63 /* Releases any waiting threads that are queued with queue_send -
  64    reply with NULL */
  65 static void queue_release_all_senders(struct event_queue *q)
  66 {
  67     if(q->send)
  68     {
  69         unsigned int i;
  70         for(i = q->read; i != q->write; i++)
  71         {
  72             struct queue_sender **spp =
  73                 &q->send->senders[i & QUEUE_LENGTH_MASK];
  74             if(*spp)
  75             {
  76                 queue_release_sender(spp, 0);
  77             }
  78         }
  79     }
  80 }
  81
  82 /* Enables queue_send on the specified queue - caller allocates the extra
  83    data structure */
  84 void queue_enable_queue_send(struct event_queue *q,
  85                              struct queue_sender_list *send)
  86 {
  87     q->send = send;
  88     memset(send, 0, sizeof(*send));
  89 }
  90 #endif /* HAVE_EXTENDED_MESSAGING_AND_NAME */
  91
  92 void queue_init(struct event_queue *q, bool register_queue)
  93 {
  94     (void)register_queue;
  95
  96     q->read   = 0;
  97     q->write  = 0;
  98     q->thread = NULL;
  99 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 100     q->send   = NULL; /* No message sending by default */
 101 #endif
 102 }
 103
 104 void queue_delete(struct event_queue *q)
 105 {
 106     (void)q;
 107 }
 108
 109 void queue_wait(struct event_queue *q, struct event *ev)
 110 {
 111     unsigned int rd;
 112
 113     while(q->read == q->write)
 114     {
 115         switch_thread(true, NULL);
 116     }
 117
 118     rd = q->read++ & QUEUE_LENGTH_MASK;
 119     *ev = q->events[rd];
 120
 121 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 122     if(q->send && q->send->senders[rd])
 123     {
 124         /* Get data for a waiting thread if one */
 125         queue_fetch_sender(q->send, rd);
 126     }
 127 #endif
 128 }
 129
 130 void queue_wait_w_tmo(struct event_queue *q, struct event *ev, int ticks)
 131 {
 132     unsigned int timeout = current_tick + ticks;
 133
 134     while(q->read == q->write && TIME_BEFORE( current_tick, timeout ))
 135     {
 136         sim_sleep(1);
 137     }
 138
 139     if(q->read != q->write)
 140     {
 141         unsigned int rd = q->read++ & QUEUE_LENGTH_MASK;
 142         *ev = q->events[rd];
 143
 144 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 145         if(q->send && q->send->senders[rd])
 146         {
 147             /* Get data for a waiting thread if one */
 148             queue_fetch_sender(q->send, rd);
 149         }
 150 #endif
 151     }
 152     else
 153     {
 154         ev->id = SYS_TIMEOUT;
 155     }
 156 }
 157
 158 void queue_post(struct event_queue *q, long id, intptr_t data)
 159 {
 160     int oldlevel = set_irq_level(15<<4);
 161     unsigned int wr = q->write++ & QUEUE_LENGTH_MASK;
 162
 163     q->events[wr].id   = id;
 164     q->events[wr].data = data;
 165
 166 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 167     if(q->send)
 168     {
 169         struct queue_sender **spp = &q->send->senders[wr];
 170
 171         if(*spp)
 172         {
 173             /* overflow protect - unblock any thread waiting at this index */
 174             queue_release_sender(spp, 0);
 175         }
 176     }
 177 #endif
 178
 179     set_irq_level(oldlevel);
 180 }
 181
 182 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 183 intptr_t queue_send(struct event_queue *q, long id, intptr_t data)
 184 {
 185     int oldlevel = set_irq_level(15<<4);
 186     unsigned int wr = q->write++ & QUEUE_LENGTH_MASK;
 187
 188     q->events[wr].id   = id;
 189     q->events[wr].data = data;
 190
 191     if(q->send)
 192     {
 193         struct queue_sender **spp = &q->send->senders[wr];
 194         struct queue_sender sender;
 195
 196         if(*spp)
 197         {
 198             /* overflow protect - unblock any thread waiting at this index */
 199             queue_release_sender(spp, 0);
 200         }
 201
 202         *spp = &sender;
 203
 204         set_irq_level(oldlevel);
 205         while (*spp != NULL)
 206         {
 207             switch_thread(true, NULL);
 208         }
 209
 210         return sender.retval;
 211     }
 212
 213     /* Function as queue_post if sending is not enabled */
 214     set_irq_level(oldlevel);
 215     return 0;
 216 }
 217
 218 #if 0 /* not used now but probably will be later */
 219 /* Query if the last message dequeued was added by queue_send or not */
 220 bool queue_in_queue_send(struct event_queue *q)
 221 {
 222     return q->send && q->send->curr_sender;
 223 }
 224 #endif
 225
 226 /* Replies with retval to any dequeued message sent with queue_send */
 227 void queue_reply(struct event_queue *q, intptr_t retval)
 228 {
 229     if(q->send && q->send->curr_sender)
 230     {
 231         queue_release_sender(&q->send->curr_sender, retval);
 232     }
 233 }
 234 #endif /* HAVE_EXTENDED_MESSAGING_AND_NAME */
 235
 236 bool queue_empty(const struct event_queue* q)
 237 {
 238     return ( q->read == q->write );
 239 }
 240
 241 void queue_clear(struct event_queue* q)
 242 {
 243     /* fixme: This is potentially unsafe in case we do interrupt-like processing */
 244 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 245     /* Release all thread waiting in the queue for a reply -
 246        dequeued sent message will be handled by owning thread */
 247     queue_release_all_senders(q);
 248 #endif
 249     q->read = 0;
 250     q->write = 0;
 251 }
 252
 253 void queue_remove_from_head(struct event_queue *q, long id)
 254 {
 255     int oldlevel = set_irq_level(15<<4);
 256
 257     while(q->read != q->write)
 258     {
 259         unsigned int rd = q->read & QUEUE_LENGTH_MASK;
 260
 261         if(q->events[rd].id != id)
 262         {
 263             break;
 264         }
 265
 266 #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
 267         if(q->send)
 268         {
 269             struct queue_sender **spp = &q->send->senders[rd];
 270
 271             if(*spp)
 272             {
 273                 /* Release any thread waiting on this message */
 274                 queue_release_sender(spp, 0);
 275             }
 276         }
 277 #endif
 278         q->read++;
 279     }
 280
 281     set_irq_level(oldlevel);
 282 }
 283
 284 void switch_thread(bool save_context, struct thread_entry **blocked_list)
 285 {
 286     (void)save_context;
 287     (void)blocked_list;
 288
 289     yield ();
 290 }
 291
 292 void sim_tick_tasks(void)
 293 {
 294     int i;
 295
 296     /* Run through the list of tick tasks */
 297     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 298     {
 299         if(tick_funcs[i])
 300         {
 301             tick_funcs[i]();
 302         }
 303     }
 304 }
 305
 306 int tick_add_task(void (*f)(void))
 307 {
 308     int i;
 309
 310     /* Add a task if there is room */
 311     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 312     {
 313         if(tick_funcs[i] == NULL)
 314         {
 315             tick_funcs[i] = f;
 316             return 0;
 317         }
 318     }
 319     DEBUGF("Error! tick_add_task(): out of tasks");
 320     return -1;
 321 }
 322
 323 int tick_remove_task(void (*f)(void))
 324 {
 325     int i;
 326
 327     /* Remove a task if it is there */
 328     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 329     {
 330         if(tick_funcs[i] == f)
 331         {
 332             tick_funcs[i] = NULL;
 333             return 0;
 334         }
 335     }
 336
 337     return -1;
 338 }
 339
 340 /* Very simple mutex simulation - won't work with pre-emptive
 341    multitasking, but is better than nothing at all */
 342 void mutex_init(struct mutex *m)
 343 {
 344     m->locked = false;
 345 }
 346
 347 void mutex_lock(struct mutex *m)
 348 {
 349     while(m->locked)
 350         switch_thread(true, NULL);
 351     m->locked = true;
 352 }
 353
 354 void mutex_unlock(struct mutex *m)
 355 {
 356     m->locked = false;
 357 }
 358
 359 void spinlock_lock(struct mutex *m)
 360 {
 361     while(m->locked)
 362         switch_thread(true, NULL);
 363     m->locked = true;
 364 }
 365
 366 void spinlock_unlock(struct mutex *m)
 367 {
 368     m->locked = false;
 369 }