4ae87c8b8a
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@13806 a1c6a512-1295-4272-9138-f99709370657
802 lines
18 KiB
C
802 lines
18 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2002 by Björn Stenberg
|
|
*
|
|
* 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 <string.h>
|
|
#include "config.h"
|
|
#include "kernel.h"
|
|
#include "thread.h"
|
|
#include "cpu.h"
|
|
#include "system.h"
|
|
#include "panic.h"
|
|
|
|
#if !defined(CPU_PP) || !defined(BOOTLOADER)
|
|
volatile long current_tick NOCACHEDATA_ATTR = 0;
|
|
#endif
|
|
|
|
void (*tick_funcs[MAX_NUM_TICK_TASKS])(void);
|
|
|
|
/* This array holds all queues that are initiated. It is used for broadcast. */
|
|
static struct event_queue *all_queues[32] NOCACHEBSS_ATTR;
|
|
static int num_queues NOCACHEBSS_ATTR;
|
|
|
|
void queue_wait(struct event_queue *q, struct event *ev) ICODE_ATTR;
|
|
|
|
/****************************************************************************
|
|
* Standard kernel stuff
|
|
****************************************************************************/
|
|
void kernel_init(void)
|
|
{
|
|
/* Init the threading API */
|
|
init_threads();
|
|
|
|
if(CURRENT_CORE == CPU)
|
|
{
|
|
memset(tick_funcs, 0, sizeof(tick_funcs));
|
|
|
|
num_queues = 0;
|
|
memset(all_queues, 0, sizeof(all_queues));
|
|
}
|
|
|
|
tick_start(1000/HZ);
|
|
}
|
|
|
|
void sleep(int ticks)
|
|
{
|
|
#if CONFIG_CPU == S3C2440 && defined(BOOTLOADER)
|
|
volatile int counter;
|
|
TCON &= ~(1 << 20); // stop timer 4
|
|
// TODO: this constant depends on dividers settings inherited from
|
|
// firmware. Set them explicitly somwhere.
|
|
TCNTB4 = 12193 * ticks / HZ;
|
|
TCON |= 1 << 21; // set manual bit
|
|
TCON &= ~(1 << 21); // reset manual bit
|
|
TCON &= ~(1 << 22); //autoreload Off
|
|
TCON |= (1 << 20); // start timer 4
|
|
do {
|
|
counter = TCNTO4;
|
|
} while(counter > 0);
|
|
|
|
#elif defined(CPU_PP) && defined(BOOTLOADER)
|
|
unsigned stop = USEC_TIMER + ticks * (1000000/HZ);
|
|
while (TIME_BEFORE(USEC_TIMER, stop))
|
|
switch_thread(true,NULL);
|
|
#else
|
|
sleep_thread(ticks);
|
|
#endif
|
|
}
|
|
|
|
void yield(void)
|
|
{
|
|
#if ((CONFIG_CPU == S3C2440 || defined(ELIO_TPJ1022)) && defined(BOOTLOADER))
|
|
/* Some targets don't like yielding in the bootloader */
|
|
#else
|
|
switch_thread(true, NULL);
|
|
#endif
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Queue handling stuff
|
|
****************************************************************************/
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
/* Moves waiting thread's descriptor to the current sender when a
|
|
message is dequeued */
|
|
static void queue_fetch_sender(struct queue_sender_list *send,
|
|
unsigned int i)
|
|
{
|
|
struct thread_entry **spp = &send->senders[i];
|
|
|
|
if (*spp)
|
|
{
|
|
send->curr_sender = *spp;
|
|
*spp = NULL;
|
|
}
|
|
}
|
|
|
|
/* Puts the specified return value in the waiting thread's return value
|
|
* and wakes the thread.
|
|
* 1) A sender should be confirmed to exist before calling which makes it
|
|
* more efficent to reject the majority of cases that don't need this
|
|
called.
|
|
* 2) Requires interrupts disabled since queue overflows can cause posts
|
|
* from interrupt handlers to wake threads. Not doing so could cause
|
|
* an attempt at multiple wakes or other problems.
|
|
*/
|
|
static void queue_release_sender(struct thread_entry **sender,
|
|
intptr_t retval)
|
|
{
|
|
(*sender)->retval = retval;
|
|
wakeup_thread_irq_safe(sender);
|
|
#if 0
|
|
/* This should _never_ happen - there must never be multiple
|
|
threads in this list and it is a corrupt state */
|
|
if (*sender != NULL)
|
|
panicf("Queue: send slot ovf");
|
|
#endif
|
|
}
|
|
|
|
/* Releases any waiting threads that are queued with queue_send -
|
|
* reply with 0.
|
|
* Disable IRQs before calling since it uses queue_release_sender.
|
|
*/
|
|
static void queue_release_all_senders(struct event_queue *q)
|
|
{
|
|
if(q->send)
|
|
{
|
|
unsigned int i;
|
|
for(i = q->read; i != q->write; i++)
|
|
{
|
|
struct thread_entry **spp =
|
|
&q->send->senders[i & QUEUE_LENGTH_MASK];
|
|
|
|
if(*spp)
|
|
{
|
|
queue_release_sender(spp, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Enables queue_send on the specified queue - caller allocates the extra
|
|
data structure */
|
|
void queue_enable_queue_send(struct event_queue *q,
|
|
struct queue_sender_list *send)
|
|
{
|
|
q->send = send;
|
|
memset(send, 0, sizeof(struct queue_sender_list));
|
|
}
|
|
#endif /* HAVE_EXTENDED_MESSAGING_AND_NAME */
|
|
|
|
|
|
void queue_init(struct event_queue *q, bool register_queue)
|
|
{
|
|
q->read = 0;
|
|
q->write = 0;
|
|
q->thread = NULL;
|
|
#if NUM_CORES > 1
|
|
q->irq_safe = false;
|
|
#endif
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
q->send = NULL; /* No message sending by default */
|
|
#endif
|
|
|
|
if(register_queue)
|
|
{
|
|
/* Add it to the all_queues array */
|
|
all_queues[num_queues++] = q;
|
|
}
|
|
}
|
|
|
|
#if NUM_CORES > 1
|
|
/**
|
|
* If IRQ mode is enabled, some core-wise locking mechanisms are disabled
|
|
* causing accessing queue to be no longer thread safe from the other core.
|
|
* However, that locking mechanism would also kill IRQ handlers.
|
|
*
|
|
* @param q struct of an event_queue
|
|
* @param state enable/disable IRQ mode
|
|
* @default state disabled
|
|
*/
|
|
void queue_set_irq_safe(struct event_queue *q, bool state)
|
|
{
|
|
q->irq_safe = state;
|
|
}
|
|
#endif
|
|
|
|
void queue_delete(struct event_queue *q)
|
|
{
|
|
int i;
|
|
bool found = false;
|
|
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
lock_cores();
|
|
|
|
/* Release theads waiting on queue */
|
|
wakeup_thread(&q->thread);
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
/* Release waiting threads and reply to any dequeued message
|
|
waiting for one. */
|
|
queue_release_all_senders(q);
|
|
queue_reply(q, 0);
|
|
#endif
|
|
|
|
/* Find the queue to be deleted */
|
|
for(i = 0;i < num_queues;i++)
|
|
{
|
|
if(all_queues[i] == q)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(found)
|
|
{
|
|
/* Move the following queues up in the list */
|
|
for(;i < num_queues-1;i++)
|
|
{
|
|
all_queues[i] = all_queues[i+1];
|
|
}
|
|
|
|
num_queues--;
|
|
}
|
|
|
|
unlock_cores();
|
|
set_irq_level(oldlevel);
|
|
}
|
|
|
|
void queue_wait(struct event_queue *q, struct event *ev)
|
|
{
|
|
int oldlevel;
|
|
unsigned int rd;
|
|
|
|
oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
lock_cores();
|
|
|
|
if (q->read == q->write)
|
|
{
|
|
set_irq_level_and_block_thread(&q->thread, oldlevel);
|
|
oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
lock_cores();
|
|
}
|
|
|
|
rd = q->read++ & QUEUE_LENGTH_MASK;
|
|
*ev = q->events[rd];
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
if(q->send && q->send->senders[rd])
|
|
{
|
|
/* Get data for a waiting thread if one */
|
|
queue_fetch_sender(q->send, rd);
|
|
}
|
|
#endif
|
|
|
|
unlock_cores();
|
|
set_irq_level(oldlevel);
|
|
}
|
|
|
|
void queue_wait_w_tmo(struct event_queue *q, struct event *ev, int ticks)
|
|
{
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
lock_cores();
|
|
|
|
if (q->read == q->write && ticks > 0)
|
|
{
|
|
set_irq_level_and_block_thread_w_tmo(&q->thread, ticks, oldlevel);
|
|
oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
lock_cores();
|
|
}
|
|
|
|
if (q->read != q->write)
|
|
{
|
|
unsigned int rd = q->read++ & QUEUE_LENGTH_MASK;
|
|
*ev = q->events[rd];
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
if(q->send && q->send->senders[rd])
|
|
{
|
|
/* Get data for a waiting thread if one */
|
|
queue_fetch_sender(q->send, rd);
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
ev->id = SYS_TIMEOUT;
|
|
}
|
|
|
|
unlock_cores();
|
|
set_irq_level(oldlevel);
|
|
}
|
|
|
|
void queue_post(struct event_queue *q, long id, intptr_t data)
|
|
{
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
unsigned int wr;
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
lock_cores();
|
|
#endif
|
|
|
|
wr = q->write++ & QUEUE_LENGTH_MASK;
|
|
|
|
q->events[wr].id = id;
|
|
q->events[wr].data = data;
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
if(q->send)
|
|
{
|
|
struct thread_entry **spp = &q->send->senders[wr];
|
|
|
|
if (*spp)
|
|
{
|
|
/* overflow protect - unblock any thread waiting at this index */
|
|
queue_release_sender(spp, 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
wakeup_thread_irq_safe(&q->thread);
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
unlock_cores();
|
|
#endif
|
|
set_irq_level(oldlevel);
|
|
|
|
}
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
/* No wakeup_thread_irq_safe here because IRQ handlers are not allowed
|
|
use of this function - we only aim to protect the queue integrity by
|
|
turning them off. */
|
|
intptr_t queue_send(struct event_queue *q, long id, intptr_t data)
|
|
{
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
unsigned int wr;
|
|
|
|
lock_cores();
|
|
|
|
wr = q->write++ & QUEUE_LENGTH_MASK;
|
|
|
|
q->events[wr].id = id;
|
|
q->events[wr].data = data;
|
|
|
|
if(q->send)
|
|
{
|
|
struct thread_entry **spp = &q->send->senders[wr];
|
|
|
|
if (*spp)
|
|
{
|
|
/* overflow protect - unblock any thread waiting at this index */
|
|
queue_release_sender(spp, 0);
|
|
}
|
|
|
|
wakeup_thread(&q->thread);
|
|
set_irq_level_and_block_thread(spp, oldlevel);
|
|
return thread_get_current()->retval;
|
|
}
|
|
|
|
/* Function as queue_post if sending is not enabled */
|
|
wakeup_thread(&q->thread);
|
|
unlock_cores();
|
|
set_irq_level(oldlevel);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0 /* not used now but probably will be later */
|
|
/* Query if the last message dequeued was added by queue_send or not */
|
|
bool queue_in_queue_send(struct event_queue *q)
|
|
{
|
|
return q->send && q->send->curr_sender;
|
|
}
|
|
#endif
|
|
|
|
/* Replies with retval to any dequeued message sent with queue_send */
|
|
void queue_reply(struct event_queue *q, intptr_t retval)
|
|
{
|
|
lock_cores();
|
|
/* No IRQ lock here since IRQs cannot change this */
|
|
if(q->send && q->send->curr_sender)
|
|
{
|
|
queue_release_sender(&q->send->curr_sender, retval);
|
|
}
|
|
unlock_cores();
|
|
}
|
|
#endif /* HAVE_EXTENDED_MESSAGING_AND_NAME */
|
|
|
|
bool queue_empty(const struct event_queue* q)
|
|
{
|
|
bool is_empty;
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
lock_cores();
|
|
#endif
|
|
|
|
is_empty = ( q->read == q->write );
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
unlock_cores();
|
|
#endif
|
|
|
|
return is_empty;
|
|
}
|
|
|
|
void queue_clear(struct event_queue* q)
|
|
{
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
lock_cores();
|
|
#endif
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
/* Release all thread waiting in the queue for a reply -
|
|
dequeued sent message will be handled by owning thread */
|
|
queue_release_all_senders(q);
|
|
#endif
|
|
|
|
q->read = 0;
|
|
q->write = 0;
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
unlock_cores();
|
|
#endif
|
|
|
|
set_irq_level(oldlevel);
|
|
}
|
|
|
|
void queue_remove_from_head(struct event_queue *q, long id)
|
|
{
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
lock_cores();
|
|
#endif
|
|
|
|
while(q->read != q->write)
|
|
{
|
|
unsigned int rd = q->read & QUEUE_LENGTH_MASK;
|
|
|
|
if(q->events[rd].id != id)
|
|
{
|
|
break;
|
|
}
|
|
|
|
#ifdef HAVE_EXTENDED_MESSAGING_AND_NAME
|
|
if(q->send)
|
|
{
|
|
struct thread_entry **spp = &q->send->senders[rd];
|
|
|
|
if (*spp)
|
|
{
|
|
/* Release any thread waiting on this message */
|
|
queue_release_sender(spp, 0);
|
|
}
|
|
}
|
|
#endif
|
|
q->read++;
|
|
}
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
unlock_cores();
|
|
#endif
|
|
|
|
set_irq_level(oldlevel);
|
|
}
|
|
|
|
/**
|
|
* The number of events waiting in the queue.
|
|
*
|
|
* @param struct of event_queue
|
|
* @return number of events in the queue
|
|
*/
|
|
int queue_count(const struct event_queue *q)
|
|
{
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
int result;
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
lock_cores();
|
|
#endif
|
|
|
|
result = q->write - q->read;
|
|
|
|
#if NUM_CORES > 1
|
|
if (!q->irq_safe)
|
|
unlock_cores();
|
|
#endif
|
|
|
|
set_irq_level(oldlevel);
|
|
|
|
return result;
|
|
}
|
|
|
|
int queue_broadcast(long id, intptr_t data)
|
|
{
|
|
int i;
|
|
|
|
for(i = 0;i < num_queues;i++)
|
|
{
|
|
queue_post(all_queues[i], id, data);
|
|
}
|
|
|
|
return num_queues;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Timer tick
|
|
****************************************************************************/
|
|
#if CONFIG_CPU == SH7034
|
|
void tick_start(unsigned int interval_in_ms)
|
|
{
|
|
unsigned long count;
|
|
|
|
count = CPU_FREQ * interval_in_ms / 1000 / 8;
|
|
|
|
if(count > 0x10000)
|
|
{
|
|
panicf("Error! The tick interval is too long (%d ms)\n",
|
|
interval_in_ms);
|
|
return;
|
|
}
|
|
|
|
/* We are using timer 0 */
|
|
|
|
TSTR &= ~0x01; /* Stop the timer */
|
|
TSNC &= ~0x01; /* No synchronization */
|
|
TMDR &= ~0x01; /* Operate normally */
|
|
|
|
TCNT0 = 0; /* Start counting at 0 */
|
|
GRA0 = (unsigned short)(count - 1);
|
|
TCR0 = 0x23; /* Clear at GRA match, sysclock/8 */
|
|
|
|
/* Enable interrupt on level 1 */
|
|
IPRC = (IPRC & ~0x00f0) | 0x0010;
|
|
|
|
TSR0 &= ~0x01;
|
|
TIER0 = 0xf9; /* Enable GRA match interrupt */
|
|
|
|
TSTR |= 0x01; /* Start timer 1 */
|
|
}
|
|
|
|
void IMIA0(void) __attribute__ ((interrupt_handler));
|
|
void IMIA0(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]();
|
|
}
|
|
}
|
|
|
|
current_tick++;
|
|
|
|
TSR0 &= ~0x01;
|
|
}
|
|
#elif defined(CPU_COLDFIRE)
|
|
void tick_start(unsigned int interval_in_ms)
|
|
{
|
|
unsigned long count;
|
|
int prescale;
|
|
|
|
count = CPU_FREQ/2 * interval_in_ms / 1000 / 16;
|
|
|
|
if(count > 0x10000)
|
|
{
|
|
panicf("Error! The tick interval is too long (%d ms)\n",
|
|
interval_in_ms);
|
|
return;
|
|
}
|
|
|
|
prescale = cpu_frequency / CPU_FREQ;
|
|
/* Note: The prescaler is later adjusted on-the-fly on CPU frequency
|
|
changes within timer.c */
|
|
|
|
/* We are using timer 0 */
|
|
|
|
TRR0 = (unsigned short)(count - 1); /* The reference count */
|
|
TCN0 = 0; /* reset the timer */
|
|
TMR0 = 0x001d | ((unsigned short)(prescale - 1) << 8);
|
|
/* restart, CLK/16, enabled, prescaler */
|
|
|
|
TER0 = 0xff; /* Clear all events */
|
|
|
|
ICR1 = 0x8c; /* Interrupt on level 3.0 */
|
|
IMR &= ~0x200;
|
|
}
|
|
|
|
void TIMER0(void) __attribute__ ((interrupt_handler));
|
|
void TIMER0(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]();
|
|
}
|
|
}
|
|
|
|
current_tick++;
|
|
|
|
TER0 = 0xff; /* Clear all events */
|
|
}
|
|
|
|
#elif defined(CPU_PP)
|
|
|
|
#ifndef BOOTLOADER
|
|
void TIMER1(void)
|
|
{
|
|
int i;
|
|
|
|
TIMER1_VAL; /* Read value to ack IRQ */
|
|
/* Run through the list of tick tasks (using main core) */
|
|
if (CURRENT_CORE == CPU)
|
|
{
|
|
for (i = 0;i < MAX_NUM_TICK_TASKS;i++)
|
|
{
|
|
if (tick_funcs[i])
|
|
{
|
|
tick_funcs[i]();
|
|
}
|
|
}
|
|
|
|
current_tick++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void tick_start(unsigned int interval_in_ms)
|
|
{
|
|
#ifndef BOOTLOADER
|
|
if(CURRENT_CORE == CPU)
|
|
{
|
|
TIMER1_CFG = 0x0;
|
|
TIMER1_VAL;
|
|
/* enable timer */
|
|
TIMER1_CFG = 0xc0000000 | (interval_in_ms*1000 - 1);
|
|
/* unmask interrupt source */
|
|
CPU_INT_EN = TIMER1_MASK;
|
|
} else {
|
|
COP_INT_EN = TIMER1_MASK;
|
|
}
|
|
#else
|
|
/* We don't enable interrupts in the bootloader */
|
|
(void)interval_in_ms;
|
|
#endif
|
|
}
|
|
|
|
#elif CONFIG_CPU == PNX0101
|
|
|
|
void timer_handler(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]();
|
|
}
|
|
|
|
current_tick++;
|
|
|
|
TIMER0.clr = 0;
|
|
}
|
|
|
|
void tick_start(unsigned int interval_in_ms)
|
|
{
|
|
TIMER0.ctrl &= ~0x80; /* Disable the counter */
|
|
TIMER0.ctrl |= 0x40; /* Reload after counting down to zero */
|
|
TIMER0.load = 3000000 * interval_in_ms / 1000;
|
|
TIMER0.ctrl &= ~0xc; /* No prescaler */
|
|
TIMER0.clr = 1; /* Clear the interrupt request */
|
|
|
|
irq_set_int_handler(IRQ_TIMER0, timer_handler);
|
|
irq_enable_int(IRQ_TIMER0);
|
|
|
|
TIMER0.ctrl |= 0x80; /* Enable the counter */
|
|
}
|
|
#endif
|
|
|
|
int tick_add_task(void (*f)(void))
|
|
{
|
|
int i;
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
|
|
/* 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;
|
|
set_irq_level(oldlevel);
|
|
return 0;
|
|
}
|
|
}
|
|
set_irq_level(oldlevel);
|
|
panicf("Error! tick_add_task(): out of tasks");
|
|
return -1;
|
|
}
|
|
|
|
int tick_remove_task(void (*f)(void))
|
|
{
|
|
int i;
|
|
int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
|
|
|
|
/* 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;
|
|
set_irq_level(oldlevel);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
set_irq_level(oldlevel);
|
|
return -1;
|
|
}
|
|
|
|
#ifndef SIMULATOR
|
|
/*
|
|
* Simulator versions in uisimulator/SIMVER/
|
|
*/
|
|
|
|
/****************************************************************************
|
|
* Simple mutex functions
|
|
****************************************************************************/
|
|
void mutex_init(struct mutex *m)
|
|
{
|
|
m->locked = false;
|
|
m->thread = NULL;
|
|
}
|
|
|
|
void mutex_lock(struct mutex *m)
|
|
{
|
|
if (test_and_set(&m->locked, 1))
|
|
{
|
|
/* Wait until the lock is open... */
|
|
block_thread(&m->thread);
|
|
}
|
|
}
|
|
|
|
void mutex_unlock(struct mutex *m)
|
|
{
|
|
lock_cores();
|
|
|
|
if (m->thread == NULL)
|
|
m->locked = 0;
|
|
else
|
|
wakeup_thread(&m->thread);
|
|
|
|
unlock_cores();
|
|
}
|
|
|
|
void spinlock_lock(struct mutex *m)
|
|
{
|
|
while (test_and_set(&m->locked, 1))
|
|
{
|
|
/* wait until the lock is open... */
|
|
switch_thread(true, NULL);
|
|
}
|
|
}
|
|
|
|
void spinlock_unlock(struct mutex *m)
|
|
{
|
|
m->locked = 0;
|
|
}
|
|
|
|
#endif /* ndef SIMULATOR */
|