/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2002 by Ulf Ralberg * * 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. * ****************************************************************************/ #ifndef THREAD_H #define THREAD_H #include "config.h" #include #include /* Priority scheduling (when enabled with HAVE_PRIORITY_SCHEDULING) works * by giving high priority threads more CPU time than less priority threads * when they need it. * * If software playback codec pcm buffer is going down to critical, codec * can change it own priority to REALTIME to override user interface and * prevent playback skipping. */ #define PRIORITY_REALTIME 1 #define PRIORITY_USER_INTERFACE 4 /* The main thread */ #define PRIORITY_RECORDING 4 /* Recording thread */ #define PRIORITY_PLAYBACK 4 /* or REALTIME when needed */ #define PRIORITY_BUFFERING 4 /* Codec buffering thread */ #define PRIORITY_SYSTEM 6 /* All other firmware threads */ #define PRIORITY_BACKGROUND 8 /* Normal application threads */ #if CONFIG_CODEC == SWCODEC #define MAXTHREADS 16 #else #define MAXTHREADS 11 #endif #define DEFAULT_STACK_SIZE 0x400 /* Bytes */ #ifndef SIMULATOR /* Need to keep structures inside the header file because debug_menu * needs them. */ #ifdef CPU_COLDFIRE struct regs { unsigned int macsr; /* 0 - EMAC status register */ unsigned int d[6]; /* 4-24 - d2-d7 */ unsigned int a[5]; /* 28-44 - a2-a6 */ void *sp; /* 48 - Stack pointer (a7) */ void *start; /* 52 - Thread start address, or NULL when started */ } __attribute__((packed)); #elif CONFIG_CPU == SH7034 struct regs { unsigned int r[7]; /* 0-24 - Registers r8 thru r14 */ void *sp; /* 28 - Stack pointer (r15) */ void *pr; /* 32 - Procedure register */ void *start; /* 36 - Thread start address, or NULL when started */ } __attribute__((packed)); #elif defined(CPU_ARM) struct regs { unsigned int r[8]; /* 0-28 - Registers r4-r11 */ void *sp; /* 32 - Stack pointer (r13) */ unsigned int lr; /* 36 - r14 (lr) */ void *start; /* 40 - Thread start address, or NULL when started */ } __attribute__((packed)); #endif /* CONFIG_CPU */ #else struct regs { void *t; /* Simulator OS thread */ void *c; /* Condition for blocking and sync */ void (*start)(void); /* Start function */ }; #endif /* !SIMULATOR */ #define STATE_RUNNING 0x00000000 #define STATE_BLOCKED 0x20000000 #define STATE_SLEEPING 0x40000000 #define STATE_BLOCKED_W_TMO 0x60000000 #define THREAD_STATE_MASK 0x60000000 #define STATE_ARG_MASK 0x1FFFFFFF #define GET_STATE_ARG(state) (state & STATE_ARG_MASK) #define GET_STATE(state) (state & THREAD_STATE_MASK) #define SET_STATE(var,state,arg) (var = (state | ((arg) & STATE_ARG_MASK))) #define CLEAR_STATE_ARG(var) (var &= ~STATE_ARG_MASK) #define STATE_BOOSTED 0x80000000 #define STATE_IS_BOOSTED(var) (var & STATE_BOOSTED) #define SET_BOOST_STATE(var) (var |= STATE_BOOSTED) struct thread_entry { struct regs context; const char *name; void *stack; unsigned long statearg; unsigned short stack_size; # if NUM_CORES > 1 unsigned char core; /* To which core threads belongs to. */ # endif #ifdef HAVE_PRIORITY_SCHEDULING unsigned char priority; unsigned char priority_x; long last_run; #endif struct thread_entry *next, *prev; #ifdef HAVE_EXTENDED_MESSAGING_AND_NAME intptr_t retval; #endif }; struct core_entry { struct thread_entry *running; struct thread_entry *sleeping; struct thread_entry *waking; struct thread_entry **wakeup_list; #ifdef HAVE_PRIORITY_SCHEDULING long highest_priority; #endif #if NUM_CORES > 1 volatile bool lock_issued; volatile bool kernel_running; #endif long last_tick; int switch_to_irq_level; #define STAY_IRQ_LEVEL -1 }; #ifdef HAVE_PRIORITY_SCHEDULING #define IF_PRIO(...) __VA_ARGS__ #else #define IF_PRIO(...) #endif /* PortalPlayer chips have 2 cores, therefore need atomic mutexes * Just use it for ARM, Coldfire and whatever else well...why not? */ /* Macros generate better code than an inline function is this case */ #if defined (CPU_PP) || defined (CPU_ARM) #define test_and_set(x_, v_) \ ({ \ uint32_t old; \ asm volatile ( \ "swpb %[old], %[v], [%[x]] \r\n" \ : [old]"=r"(old) \ : [v]"r"((uint32_t)v_), [x]"r"((uint32_t *)x_) \ ); \ old; \ }) #elif defined (CPU_COLDFIRE) #define test_and_set(x_, v_) \ ({ \ uint8_t old; \ asm volatile ( \ "bset.l %[v], (%[x]) \r\n" \ "sne.b %[old] \r\n" \ : [old]"=d,d"(old) \ : [v]"i,d"((uint32_t)v_), [x]"a,a"((uint32_t *)x_) \ ); \ old; \ }) #elif CONFIG_CPU == SH7034 #define test_and_set(x_, v_) \ ({ \ uint32_t old; \ asm volatile ( \ "tas.b @%[x] \r\n" \ "mov #-1, %[old] \r\n" \ "negc %[old], %[old] \r\n" \ : [old]"=r"(old) \ : [v]"M"((uint32_t)v_), /* Value of v_ must be 1 */ \ [x]"r"((uint8_t *)x_) \ ); \ old; \ }) #else /* default for no asm version */ #define test_and_set(x_, v_) \ ({ \ uint32_t old = *(uint32_t *)x_; \ *(uint32_t *)x_ = v_; \ old; \ }) #endif struct thread_entry* create_thread(void (*function)(void), void* stack, int stack_size, const char *name IF_PRIO(, int priority) IF_COP(, unsigned int core, bool fallback)); #ifdef HAVE_SCHEDULER_BOOSTCTRL void trigger_cpu_boost(void); #else #define trigger_cpu_boost() #endif void remove_thread(struct thread_entry *thread); void switch_thread(bool save_context, struct thread_entry **blocked_list); void sleep_thread(int ticks); void block_thread(struct thread_entry **thread); void block_thread_w_tmo(struct thread_entry **thread, int timeout); void set_irq_level_and_block_thread(struct thread_entry **thread, int level); void set_irq_level_and_block_thread_w_tmo(struct thread_entry **list, int timeout, int level); void wakeup_thread(struct thread_entry **thread); void wakeup_thread_irq_safe(struct thread_entry **thread); #ifdef HAVE_PRIORITY_SCHEDULING int thread_set_priority(struct thread_entry *thread, int priority); int thread_get_priority(struct thread_entry *thread); /* Yield that guarantees thread execution once per round regardless of thread's scheduler priority - basically a transient realtime boost without altering the scheduler's thread precedence. */ void priority_yield(void); #else #define priority_yield yield #endif /* HAVE_PRIORITY_SCHEDULING */ struct thread_entry * thread_get_current(void); void init_threads(void); int thread_stack_usage(const struct thread_entry *thread); #if NUM_CORES > 1 int idle_stack_usage(unsigned int core); #endif int thread_get_status(const struct thread_entry *thread); void thread_get_name(char *buffer, int size, struct thread_entry *thread); #ifdef RB_PROFILE void profile_thread(void); #endif #endif