11 files changed, 158 insertions, 132 deletions

diff --git a/apps/debug_menu.c b/apps/debug_menu.c
index b3b6fe3eca..0dec961f3f 100644
--- a/apps/debug_menu.c
+++ b/apps/debug_menu.c
@@ -125,6 +125,8 @@ static char* dbg_listmessage_getname(int item, void * data, char *buffer)
 #endif
 
 struct action_callback_info;
+#define DBGLIST_SHOW_SELECTION 0x1
+
 struct action_callback_info
 {
     char *title;
@@ -137,6 +139,7 @@ struct action_callback_info
 };
 
 static char* dbg_menu_getname(int item, void * data, char *buffer);
+static char* threads_getname(int selected_item, void * data, char *buffer);
 static bool dbg_list(struct action_callback_info *info)
 {
     struct gui_synclist lists;
@@ -149,8 +152,7 @@ static bool dbg_list(struct action_callback_info *info)
     gui_synclist_set_title(&lists, info->title, NOICON);
     gui_synclist_set_icon_callback(&lists, NULL);
     gui_synclist_set_nb_items(&lists, info->count*info->selection_size);
-    if (info->dbg_getname != dbg_menu_getname)
-        gui_synclist_hide_selection_marker(&lists, true);
+    gui_synclist_hide_selection_marker(&lists, true);
     
     if (info->action_callback)
         info->action_callback(ACTION_REDRAW, info);
@@ -179,17 +181,28 @@ static bool dbg_list(struct action_callback_info *info)
 /*---------------------------------------------------*/
 extern struct thread_entry threads[MAXTHREADS];
 
-static char thread_status_char(int status)
+static char thread_status_char(unsigned status)
 {
-    switch (status)
+    static const char thread_status_chars[THREAD_NUM_STATES+1] =
     {
-        case STATE_RUNNING      : return 'R';
-        case STATE_BLOCKED      : return 'B';
-        case STATE_SLEEPING     : return 'S';
-        case STATE_BLOCKED_W_TMO: return 'T';
-    }
+        [0 ... THREAD_NUM_STATES] = '?',
+        [STATE_RUNNING]           = 'R',
+        [STATE_BLOCKED]           = 'B',
+        [STATE_SLEEPING]          = 'S',
+        [STATE_BLOCKED_W_TMO]     = 'T',
+        [STATE_FROZEN]            = 'F',
+        [STATE_KILLED]            = 'K',
+    };
 
-    return '?';
+#if NUM_CORES > 1
+    if (status == STATE_BUSY) /* Not a state index */
+        return '.';
+#endif
+
+    if (status > THREAD_NUM_STATES)
+        status = THREAD_NUM_STATES;
+
+    return thread_status_chars[status];
 }
 
 static char* threads_getname(int selected_item, void * data, char *buffer)
@@ -214,7 +227,7 @@ static char* threads_getname(int selected_item, void * data, char *buffer)
     thread = &threads[selected_item];
     status = thread_get_status(thread);
     
-    if (thread->name == NULL)
+    if (status == STATE_KILLED)
     {
         snprintf(buffer, MAX_PATH, "%2d: ---", selected_item);
         return buffer;
@@ -222,7 +235,6 @@ static char* threads_getname(int selected_item, void * data, char *buffer)
 
     thread_get_name(name, 32, thread);
     usage = thread_stack_usage(thread);
-    status = thread_get_status(thread);
 
     snprintf(buffer, MAX_PATH,
              "%2d: " IF_COP("(%d) ") "%c%c " IF_PRIO("%d ") "%2d%% %s", 
@@ -2329,6 +2341,7 @@ static const struct the_menu_item menuitems[] = {
     };
 static int menu_action_callback(int btn, struct action_callback_info *info)
 {
+    gui_synclist_hide_selection_marker(info->lists, false);
     if (btn == ACTION_STD_OK)
     {
         menuitems[gui_synclist_get_sel_pos(info->lists)].function();
diff --git a/apps/playback.c b/apps/playback.c
index b80c68384f..0fd1c21daf 100644
--- a/apps/playback.c
+++ b/apps/playback.c
@@ -290,8 +290,8 @@ static void set_current_codec(int codec_idx);
 static void set_filebuf_watermark(int seconds);
 
 /* Audio thread */
-static struct event_queue       audio_queue;
-static struct queue_sender_list audio_queue_sender_list;
+static struct event_queue       audio_queue NOCACHEBSS_ATTR;
+static struct queue_sender_list audio_queue_sender_list NOCACHEBSS_ATTR;
 static long audio_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
 static const char audio_thread_name[] = "audio";
 
@@ -340,9 +340,10 @@ static unsigned char *dram_buf = NULL;
    automatically swaps in the other and the swap when unlocking should not
    happen if the parity is even.
  */
-static bool          swap_codec_parity = false; /* true=odd, false=even */
-/* Mutex to control which codec (normal/voice) is running */
-static struct mutex mutex_codecthread NOCACHEBSS_ATTR; 
+static bool   swap_codec_parity NOCACHEBSS_ATTR = false; /* true=odd, false=even */
+/* Locking to control which codec (normal/voice) is running */
+static struct semaphore sem_codecthread NOCACHEBSS_ATTR;
+static struct event event_codecthread NOCACHEBSS_ATTR;
 
 /* Voice state */
 static volatile bool voice_thread_start = false; /* Triggers voice playback (A/V) */
@@ -424,8 +425,7 @@ static void wait_for_voice_swap_in(void)
     if (NULL == iram_buf)
         return;
 
-    while (current_codec != CODEC_IDX_VOICE)
-        yield();
+    event_wait(&event_codecthread, STATE_NONSIGNALED);
 #endif /* PLAYBACK_VOICE */
 }
 
@@ -924,21 +924,21 @@ static void swap_codec(void)
     }
 
     /* Release my semaphore */
-    mutex_unlock(&mutex_codecthread);
+    semaphore_release(&sem_codecthread);
     logf("unlocked: %d", my_codec);
 
-    /* Loop until the other codec has locked and run */
-    do {
-        /* Release my semaphore and force a task switch. */
-        yield();
-    } while (my_codec == current_codec);
+    /* Wait for other codec */
+    event_wait(&event_codecthread,
+        (my_codec == CODEC_IDX_AUDIO) ? STATE_NONSIGNALED : STATE_SIGNALED);
 
     /* Wait for other codec to unlock */
-    mutex_lock(&mutex_codecthread);
+    logf("waiting for lock: %d", my_codec);
+    semaphore_wait(&sem_codecthread);
 
     /* Take control */
-    logf("waiting for lock: %d", my_codec);
     set_current_codec(my_codec);
+    event_set_state(&event_codecthread,
+        (my_codec == CODEC_IDX_AUDIO) ? STATE_SIGNALED : STATE_NONSIGNALED);
 
     /* Reload our IRAM and DRAM */
     memswap128(iram_buf, CODEC_IRAM_ORIGIN, CODEC_IRAM_SIZE);
@@ -1161,7 +1161,7 @@ static bool voice_on_voice_stop(bool aborting, size_t *realsize)
 
 static void* voice_request_buffer_callback(size_t *realsize, size_t reqsize)
 {
-    struct event ev;
+    struct queue_event ev;
 
     if (ci_voice.new_track)
     {
@@ -1332,7 +1332,8 @@ static void voice_thread(void)
 {
     logf("Loading voice codec");
     voice_codec_loaded = true;
-    mutex_lock(&mutex_codecthread);
+    semaphore_wait(&sem_codecthread);
+    event_set_state(&event_codecthread, false);
     set_current_codec(CODEC_IDX_VOICE);
     dsp_configure(DSP_RESET, 0);
     voice_remaining = 0;
@@ -1344,9 +1345,8 @@ static void voice_thread(void)
 
     logf("Voice codec finished");
     voice_codec_loaded = false;
-    mutex_unlock(&mutex_codecthread);
     voice_thread_p = NULL;
-    remove_thread(NULL);
+    semaphore_release(&sem_codecthread);
 } /* voice_thread */
 
 #endif /* PLAYBACK_VOICE */
@@ -1968,7 +1968,7 @@ static bool codec_request_next_track_callback(void)
 
 static void codec_thread(void)
 {
-    struct event ev;
+    struct queue_event ev;
     int status;
     size_t wrap;
 
@@ -1988,13 +1988,14 @@ static void codec_thread(void)
                     LOGFQUEUE("codec > voice Q_AUDIO_PLAY");
                     queue_post(&voice_queue, Q_AUDIO_PLAY, 0);
                 }
-                mutex_lock(&mutex_codecthread);
+                semaphore_wait(&sem_codecthread);
+                event_set_state(&event_codecthread, true);
 #endif
                 set_current_codec(CODEC_IDX_AUDIO);
                 ci.stop_codec = false;
                 status = codec_load_file((const char *)ev.data, &ci);
 #ifdef PLAYBACK_VOICE
-                mutex_unlock(&mutex_codecthread);
+                semaphore_release(&sem_codecthread);
 #endif
                 break;
 
@@ -2019,7 +2020,8 @@ static void codec_thread(void)
                     LOGFQUEUE("codec > voice Q_AUDIO_PLAY");
                     queue_post(&voice_queue, Q_AUDIO_PLAY, 0);
                 }
-                mutex_lock(&mutex_codecthread);
+                semaphore_wait(&sem_codecthread);
+                event_set_state(&event_codecthread, true);
 #endif
                 set_current_codec(CODEC_IDX_AUDIO);
                 ci.stop_codec = false;
@@ -2027,7 +2029,7 @@ static void codec_thread(void)
                 status = codec_load_ram(CUR_TI->codecbuf, CUR_TI->codecsize,
                         &filebuf[0], wrap, &ci);
 #ifdef PLAYBACK_VOICE
-                mutex_unlock(&mutex_codecthread);
+                semaphore_release(&sem_codecthread);
 #endif
                 break;
 
@@ -2041,14 +2043,15 @@ static void codec_thread(void)
                     LOGFQUEUE("codec > voice Q_ENCODER_RECORD");
                     queue_post(&voice_queue, Q_ENCODER_RECORD, 0);
                 }
-                mutex_lock(&mutex_codecthread);
+                semaphore_wait(&sem_codecthread);
+                event_set_state(&event_codecthread, true);
 #endif
                 logf("loading encoder");
                 set_current_codec(CODEC_IDX_AUDIO);
                 ci.stop_encoder = false;
                 status = codec_load_file((const char *)ev.data, &ci);
 #ifdef PLAYBACK_VOICE
-                mutex_unlock(&mutex_codecthread);
+                semaphore_release(&sem_codecthread);
 #endif
                 logf("encoder stopped");
                 break;
@@ -3594,13 +3597,13 @@ static bool ata_fillbuffer_callback(void)
 
 static void audio_thread(void)
 {
-    struct event ev;
+    struct queue_event ev;
 
     pcm_postinit();
 
 #ifdef PLAYBACK_VOICE
-    /* Unlock mutex that init stage locks before creating this thread */
-    mutex_unlock(&mutex_codecthread);
+    /* Unlock semaphore that init stage locks before creating this thread */
+    semaphore_release(&sem_codecthread);
 
     /* Buffers must be set up by now - should panic - really */
     if (buffer_state != BUFFER_STATE_INITIALIZED)
@@ -3764,7 +3767,9 @@ void audio_init(void)
 #ifdef PLAYBACK_VOICE
     static bool voicetagtrue = true;
     static struct mp3entry id3_voice;
+    struct thread_entry *voice_thread_p = NULL;
 #endif
+    struct thread_entry *audio_thread_p;
 
     /* Can never do this twice */
     if (audio_is_initialized)
@@ -3779,11 +3784,11 @@ void audio_init(void)
        to send messages. Thread creation will be delayed however so nothing
        starts running until ready if something yields such as talk_init. */
 #ifdef PLAYBACK_VOICE
-    mutex_init(&mutex_codecthread);
     /* Take ownership of lock to prevent playback of anything before audio
        hardware is initialized - audio thread unlocks it after final init
        stage */
-    mutex_lock(&mutex_codecthread);
+    semaphore_init(&sem_codecthread, 1, 0);
+    event_init(&event_codecthread, EVENT_MANUAL | STATE_SIGNALED);
 #endif
     queue_init(&audio_queue, true);
     queue_enable_queue_send(&audio_queue, &audio_queue_sender_list);
@@ -3842,16 +3847,16 @@ void audio_init(void)
        talk first */
     talk_init();
 
-    /* Create the threads late now that we shouldn't be yielding again before
-       returning */
     codec_thread_p = create_thread(
             codec_thread, codec_stack, sizeof(codec_stack),
+            CREATE_THREAD_FROZEN,
             codec_thread_name IF_PRIO(, PRIORITY_PLAYBACK)
-        IF_COP(, CPU, true));
+            IF_COP(, CPU));
 
-    create_thread(audio_thread, audio_stack, sizeof(audio_stack),
+    audio_thread_p = create_thread(audio_thread, audio_stack,
+                  sizeof(audio_stack), CREATE_THREAD_FROZEN,
                   audio_thread_name IF_PRIO(, PRIORITY_BUFFERING)
-          IF_COP(, CPU, false));
+                  IF_COP(, CPU));
 
 #ifdef PLAYBACK_VOICE
     /* TODO: Change this around when various speech codecs can be used */
@@ -3859,9 +3864,10 @@ void audio_init(void)
     {
         logf("Starting voice codec");
         queue_init(&voice_queue, true);
-        create_thread(voice_thread, voice_stack,
-                sizeof(voice_stack), voice_thread_name 
-                IF_PRIO(, PRIORITY_PLAYBACK) IF_COP(, CPU, false));
+        voice_thread_p = create_thread(voice_thread, voice_stack,
+                sizeof(voice_stack), CREATE_THREAD_FROZEN,
+                voice_thread_name
+                IF_PRIO(, PRIORITY_PLAYBACK) IF_COP(, CPU));
     }
 #endif
 
@@ -3881,5 +3887,13 @@ void audio_init(void)
 #ifndef HAVE_FLASH_STORAGE 
     audio_set_buffer_margin(global_settings.buffer_margin);
 #endif
+
+    /* it's safe to let the threads run now */
+    thread_thaw(codec_thread_p);
+#ifdef PLAYBACK_VOICE
+    if (voice_thread_p)
+        thread_thaw(voice_thread_p);
+#endif
+    thread_thaw(audio_thread_p);
 } /* audio_init */
 
diff --git a/apps/playlist.c b/apps/playlist.c
index 47a1f3730d..025e07d8a7 100644
--- a/apps/playlist.c
+++ b/apps/playlist.c
@@ -1163,7 +1163,7 @@ static int compare(const void* p1, const void* p2)
  */
 static void playlist_thread(void)
 {
-    struct event ev;
+    struct queue_event ev;
     bool dirty_pointers = false;
     static char tmp[MAX_PATH+1];
 
@@ -1889,8 +1889,8 @@ void playlist_init(void)
     memset(playlist->filenames, 0,
            playlist->max_playlist_size * sizeof(int));
     create_thread(playlist_thread, playlist_stack, sizeof(playlist_stack),
-                  playlist_thread_name IF_PRIO(, PRIORITY_BACKGROUND)
-                  IF_COP(, CPU, false));
+                  0, playlist_thread_name IF_PRIO(, PRIORITY_BACKGROUND)
+                          IF_COP(, CPU));
     queue_init(&playlist_queue, true);
 #endif
 }
diff --git a/apps/plugin.c b/apps/plugin.c
index 685dab960f..c06ae257e4 100644
--- a/apps/plugin.c
+++ b/apps/plugin.c
@@ -141,6 +141,7 @@ static const struct plugin_api rockbox_api = {
     /* remote lcd */
     lcd_remote_set_contrast,
     lcd_remote_clear_display,
+    lcd_remote_setmargins,
     lcd_remote_puts,
     lcd_remote_puts_scroll,
     lcd_remote_stop_scroll,
@@ -183,6 +184,9 @@ static const struct plugin_api rockbox_api = {
 #if defined(HAVE_LCD_COLOR)
     lcd_yuv_blit,
 #endif
+#if defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200)
+    lcd_yuv_set_options,
+#endif
     /* list */
     gui_synclist_init,
     gui_synclist_set_nb_items,
@@ -202,6 +206,7 @@ static const struct plugin_api rockbox_api = {
     button_get_w_tmo,
     button_status,
     button_clear_queue,
+    button_queue_count,
 #ifdef HAS_BUTTON_HOLD
     button_hold,
 #endif
@@ -463,6 +468,13 @@ static const struct plugin_api rockbox_api = {
 #endif
     &global_settings,
     &global_status,
+    talk_disable_menus,
+    talk_enable_menus,
+#if CONFIG_CODEC == SWCODEC
+    codec_load_file,
+    get_codec_filename,
+    get_metadata,
+#endif
     mp3info,
     count_mp3_frames,
     create_xing_header,
@@ -492,6 +504,11 @@ static const struct plugin_api rockbox_api = {
     detect_flashed_ramimage,
     detect_flashed_romimage,
 #endif
+    led,
+#ifdef CACHE_FUNCTIONS_AS_CALL
+    flush_icache,
+    invalidate_icache,
+#endif
     /* new stuff at the end, sort into place next time
        the API gets incompatible */
 
@@ -499,27 +516,6 @@ static const struct plugin_api rockbox_api = {
     spinlock_init,
     spinlock_lock,
     spinlock_unlock,
-
-    codec_load_file,
-    get_codec_filename,
-    get_metadata,
-#endif
-    led,
-
-#if defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200)
-    lcd_yuv_set_options,
-#endif
-
-#ifdef CACHE_FUNCTIONS_AS_CALL
-    flush_icache,
-    invalidate_icache,
-#endif
-    talk_disable_menus,
-    talk_enable_menus,
-
-    button_queue_count,
-#ifdef HAVE_REMOTE_LCD
-    lcd_remote_setmargins,
 #endif
 };
 
@@ -666,7 +662,11 @@ int plugin_load(const char* plugin, void* parameter)
 #endif
     lcd_remote_setmargins(rxm, rym);
     lcd_remote_clear_display();
+
+
     lcd_remote_update();
+
+
 #endif
 
     if (pfn_tsr_exit == NULL)
diff --git a/apps/plugin.h b/apps/plugin.h
index 1a87ab6cb6..e36c99c5fd 100644
--- a/apps/plugin.h
+++ b/apps/plugin.h
@@ -112,12 +112,12 @@
 #define PLUGIN_MAGIC 0x526F634B /* RocK */
 
 /* increase this every time the api struct changes */
-#define PLUGIN_API_VERSION 82
+#define PLUGIN_API_VERSION 83
 
 /* update this to latest version if a change to the api struct breaks
    backwards compatibility (and please take the opportunity to sort in any
    new function which are "waiting" at the end of the function table) */
-#define PLUGIN_MIN_API_VERSION 82
+#define PLUGIN_MIN_API_VERSION 83
 
 /* plugin return codes */
 enum plugin_status {
@@ -219,6 +219,7 @@ struct plugin_api {
     /* remote lcd */
     void (*lcd_remote_set_contrast)(int x);
     void (*lcd_remote_clear_display)(void);
+    void (*lcd_remote_setmargins)(int x, int y);
     void (*lcd_remote_puts)(int x, int y, const unsigned char *string);
     void (*lcd_remote_lcd_puts_scroll)(int x, int y, const unsigned char* string);
     void (*lcd_remote_lcd_stop_scroll)(void);
@@ -265,6 +266,10 @@ struct plugin_api {
                          int x, int y, int width, int height);
 #endif
 
+#if defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200)
+    void (*lcd_yuv_set_options)(unsigned options);
+#endif
+
     /* list */
     void (*gui_synclist_init)(struct gui_synclist * lists,
             list_get_name callback_get_item_name,void * data,
@@ -288,6 +293,7 @@ struct plugin_api {
     long (*button_get_w_tmo)(int ticks);
     int (*button_status)(void);
     void (*button_clear_queue)(void);
+    int (*button_queue_count)(void);   
 #ifdef HAS_BUTTON_HOLD
     bool (*button_hold)(void);
 #endif
@@ -334,9 +340,10 @@ struct plugin_api {
     long (*default_event_handler_ex)(long event, void (*callback)(void *), void *parameter);
     struct thread_entry* threads;
     struct thread_entry* (*create_thread)(void (*function)(void), void* stack,
-                                          int stack_size, const char *name
+                                          int stack_size, unsigned flags,
+                                          const char *name
                                           IF_PRIO(, int priority)
-                                          IF_COP(, unsigned int core, bool fallback));
+                                                              IF_COP(, unsigned int core));
     void (*remove_thread)(struct thread_entry *thread);
     void (*reset_poweroff_timer)(void);
 #ifndef SIMULATOR
@@ -359,7 +366,7 @@ struct plugin_api {
     void (*queue_init)(struct event_queue *q, bool register_queue);
     void (*queue_delete)(struct event_queue *q);
     void (*queue_post)(struct event_queue *q, long id, intptr_t data);
-    void (*queue_wait_w_tmo)(struct event_queue *q, struct event *ev,
+    void (*queue_wait_w_tmo)(struct event_queue *q, struct queue_event *ev,
             int ticks);
     void (*usb_acknowledge)(long id);
 #ifdef RB_PROFILE
@@ -572,6 +579,13 @@ struct plugin_api {
 #endif
     struct user_settings* global_settings;
     struct system_status *global_status;
+    void (*talk_disable_menus)(void);
+    void (*talk_enable_menus)(void);
+#if CONFIG_CODEC == SWCODEC
+    int (*codec_load_file)(const char* codec, struct codec_api *api);
+    const char *(*get_codec_filename)(int cod_spec);
+    bool (*get_metadata)(struct mp3entry* id3, int fd, const char* trackname);
+#endif
     bool (*mp3info)(struct mp3entry *entry, const char *filename);
     int (*count_mp3_frames)(int fd, int startpos, int filesize,
                             void (*progressfunc)(int));
@@ -609,35 +623,21 @@ struct plugin_api {
     bool (*detect_flashed_ramimage)(void);
     bool (*detect_flashed_romimage)(void);
 #endif
-    /* new stuff at the end, sort into place next time
-       the API gets incompatible */
-
-#if (CONFIG_CODEC == SWCODEC)
-    void (*spinlock_init)(struct mutex *m);
-    void (*spinlock_lock)(struct mutex *m);
-    void (*spinlock_unlock)(struct mutex *m);
 
-    int (*codec_load_file)(const char* codec, struct codec_api *api);
-    const char *(*get_codec_filename)(int cod_spec);
-    bool (*get_metadata)(struct mp3entry* id3, int fd, const char* trackname);
-#endif
     void (*led)(bool on);
 
-#if defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200)
-    void (*lcd_yuv_set_options)(unsigned options);
-#endif
-
 #ifdef CACHE_FUNCTIONS_AS_CALL
     void (*flush_icache)(void);
     void (*invalidate_icache)(void);
 #endif
 
-    void (*talk_disable_menus)(void);
-    void (*talk_enable_menus)(void);
+    /* new stuff at the end, sort into place next time
+       the API gets incompatible */
 
-    int (*button_queue_count)(void);   
-#ifdef HAVE_REMOTE_LCD
-    void (*lcd_remote_setmargins)(int x, int y);
+#if (CONFIG_CODEC == SWCODEC)
+    void (*spinlock_init)(struct spinlock *l IF_COP(, unsigned int flags));
+    void (*spinlock_lock)(struct spinlock *l);
+    void (*spinlock_unlock)(struct spinlock *l);
 #endif
 };
 
diff --git a/apps/plugins/alpine_cdc.c b/apps/plugins/alpine_cdc.c
index c4b897fc3a..622338742a 100644
--- a/apps/plugins/alpine_cdc.c
+++ b/apps/plugins/alpine_cdc.c
@@ -1167,9 +1167,9 @@ int main(void* parameter)
 
     rb->memset(&gTread, 0, sizeof(gTread));
     gTread.foreground = true;
-    rb->create_thread(thread, stack, stacksize, "CDC"
+    rb->create_thread(thread, stack, stacksize, 0, "CDC"
                       IF_PRIO(, PRIORITY_BACKGROUND)
-                      IF_COP(, CPU, false));
+                              IF_COP(, CPU));
 
 #ifdef DEBUG
     do
diff --git a/apps/plugins/battery_bench.c b/apps/plugins/battery_bench.c
index 7889f551a4..dfe9632f7b 100644
--- a/apps/plugins/battery_bench.c
+++ b/apps/plugins/battery_bench.c
@@ -215,7 +215,7 @@ void thread(void)
 #endif    
     long sleep_time = 5 * HZ;
     
-    struct event ev;
+    struct queue_event ev;
 
     buffelements = sizeof(bat)/sizeof(struct batt_info);
 
@@ -500,9 +500,9 @@ int main(void)
     
     rb->queue_init(&thread_q, true); /* put the thread's queue in the bcast list */
     if(rb->create_thread(thread, thread_stack,
-        sizeof(thread_stack), "Battery Benchmark" 
+        sizeof(thread_stack), 0, "Battery Benchmark" 
         IF_PRIO(, PRIORITY_BACKGROUND)
-        IF_COP(, CPU, false)) == NULL)
+            IF_COP(, CPU)) == NULL)
     {
         rb->splash(HZ, "Cannot create thread!");
         return PLUGIN_ERROR;
diff --git a/apps/plugins/mpegplayer/mpegplayer.c b/apps/plugins/mpegplayer/mpegplayer.c
index ea10411f3f..12282a3322 100644
--- a/apps/plugins/mpegplayer/mpegplayer.c
+++ b/apps/plugins/mpegplayer/mpegplayer.c
@@ -189,11 +189,11 @@ typedef struct
 {
     struct thread_entry *thread; /* Stream's thread */
     int      status;             /* Current stream status */
-    struct   event ev;           /* Event sent to steam */
+    struct   queue_event ev;     /* Event sent to steam */
     int      have_msg;           /* 1=event pending */
     int      replied;            /* 1=replied to last event */
     int      reply;              /* reply value */
-    struct mutex msg_lock;       /* serialization for event senders */
+    struct spinlock msg_lock;    /* serialization for event senders */
     uint8_t* curr_packet;        /* Current stream packet beginning */
     uint8_t* curr_packet_end;    /* Current stream packet end */
 
@@ -256,7 +256,7 @@ static void str_wait_msg(Stream *str)
 
 /* Returns a message waiting or blocks until one is available - removes the
    event */
-static void str_get_msg(Stream *str, struct event *ev)
+static void str_get_msg(Stream *str, struct queue_event *ev)
 {
     str_wait_msg(str);
     ev->id   = str->ev.id;
@@ -266,7 +266,7 @@ static void str_get_msg(Stream *str, struct event *ev)
 
 /* Peeks at the current message without blocking, returns the data but
    does not remove the event */
-static bool str_look_msg(Stream *str, struct event *ev)
+static bool str_look_msg(Stream *str, struct queue_event *ev)
 {
     if (!str_have_msg(str))
         return false;
@@ -345,9 +345,9 @@ static size_t file_remaining IBSS_ATTR;
 
 #if NUM_CORES > 1
 /* Some stream variables are shared between cores */
-struct mutex stream_lock IBSS_ATTR;
+struct spinlock stream_lock IBSS_ATTR;
 static inline void init_stream_lock(void)
-    { rb->spinlock_init(&stream_lock); }
+    { rb->spinlock_init(&stream_lock, SPINLOCK_TASK_SWITCH); }
 static inline void lock_stream(void)
     { rb->spinlock_lock(&stream_lock); }
 static inline void unlock_stream(void)
@@ -1050,7 +1050,7 @@ static int button_loop(void)
 
     if (str_have_msg(&audio_str))
     {
-        struct event ev;
+        struct queue_event ev;
         str_get_msg(&audio_str, &ev);
 
         if (ev.id == STREAM_QUIT)
@@ -1375,7 +1375,7 @@ static void audio_thread(void)
             {
                 if (str_have_msg(&audio_str))
                 {
-                    struct event ev;
+                    struct queue_event ev;
                     str_look_msg(&audio_str, &ev);
 
                     if (ev.id == STREAM_QUIT)
@@ -1498,7 +1498,7 @@ static uint32_t video_stack[VIDEO_STACKSIZE / sizeof(uint32_t)] IBSS_ATTR;
 
 static void video_thread(void)
 {
-    struct event ev;
+    struct queue_event ev;
     const mpeg2_info_t * info;
     mpeg2_state_t state;
     char str[80];
@@ -1929,9 +1929,8 @@ void display_thumb(int in_file)
     video_str.status = STREAM_PLAYING;
 
     if ((video_str.thread = rb->create_thread(video_thread,
-       (uint8_t*)video_stack,VIDEO_STACKSIZE,"mpgvideo" 
-       IF_PRIO(,PRIORITY_PLAYBACK)
-       IF_COP(, COP, true))) == NULL)
+       (uint8_t*)video_stack,VIDEO_STACKSIZE, 0,"mpgvideo" 
+       IF_PRIO(,PRIORITY_PLAYBACK) IF_COP(, COP))) == NULL)
     {
         rb->splash(HZ, "Cannot create video thread!");
     }
@@ -2354,8 +2353,8 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
     initialize_stream( &video_str, disk_buf_start, disk_buf_len, 0xe0 );
     initialize_stream( &audio_str, disk_buf_start, disk_buf_len, 0xc0 );
 
-    rb->spinlock_init(&audio_str.msg_lock);
-    rb->spinlock_init(&video_str.msg_lock);
+    rb->spinlock_init(&audio_str.msg_lock IF_COP(, SPINLOCK_TASK_SWITCH));
+    rb->spinlock_init(&video_str.msg_lock IF_COP(, SPINLOCK_TASK_SWITCH));
 
     audio_str.status = STREAM_BUFFERING;
     video_str.status = STREAM_PLAYING;
@@ -2372,14 +2371,14 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 
     /* We put the video thread on the second processor for multi-core targets. */
     if ((video_str.thread = rb->create_thread(video_thread,
-        (uint8_t*)video_stack,VIDEO_STACKSIZE,"mpgvideo" IF_PRIO(,PRIORITY_PLAYBACK)
-        IF_COP(, COP, true))) == NULL)
+        (uint8_t*)video_stack, VIDEO_STACKSIZE, 0,
+        "mpgvideo" IF_PRIO(,PRIORITY_PLAYBACK) IF_COP(, COP))) == NULL)
     {
         rb->splash(HZ, "Cannot create video thread!");
     }
     else if ((audio_str.thread = rb->create_thread(audio_thread,
-        (uint8_t*)audio_stack,AUDIO_STACKSIZE,"mpgaudio" IF_PRIO(,PRIORITY_PLAYBACK)
-        IF_COP(, CPU, false))) == NULL)
+        (uint8_t*)audio_stack,AUDIO_STACKSIZE, 0,"mpgaudio"
+        IF_PRIO(,PRIORITY_PLAYBACK) IF_COP(, CPU))) == NULL)
     {
         rb->splash(HZ, "Cannot create audio thread!");
     }
diff --git a/apps/plugins/test_codec.c b/apps/plugins/test_codec.c
index 2918f611a1..e2f599c361 100644
--- a/apps/plugins/test_codec.c
+++ b/apps/plugins/test_codec.c
@@ -584,8 +584,8 @@ static enum plugin_status test_track(char* filename)
     codec_playing = true;
 
     if ((codecthread_id = rb->create_thread(codec_thread,
-        (uint8_t*)codec_stack, codec_stack_size, "testcodec" IF_PRIO(,PRIORITY_PLAYBACK)
-        IF_COP(, CPU, false))) == NULL)
+        (uint8_t*)codec_stack, codec_stack_size, 0, "testcodec"
+        IF_PRIO(,PRIORITY_PLAYBACK) IF_COP(, CPU))) == NULL)
     {
         log_text("Cannot create codec thread!",true);
         goto exit;
diff --git a/apps/screens.c b/apps/screens.c
index b725beaa7a..ce62911624 100644
--- a/apps/screens.c
+++ b/apps/screens.c
@@ -153,7 +153,7 @@ void usb_screen(void)
 #ifdef HAVE_MMC
 int mmc_remove_request(void)
 {
-    struct event ev;
+    struct queue_event ev;
     int i;
     FOR_NB_SCREENS(i)
         screens[i].clear_display();
diff --git a/apps/tagcache.c b/apps/tagcache.c
index 4a2f107d24..2ed7574f3b 100644
--- a/apps/tagcache.c
+++ b/apps/tagcache.c
@@ -88,7 +88,7 @@
 
 #ifndef __PCTOOL__
 /* Tag Cache thread. */
-static struct event_queue tagcache_queue;
+static struct event_queue tagcache_queue NOCACHEBSS_ATTR;
 static long tagcache_stack[(DEFAULT_STACK_SIZE + 0x4000)/sizeof(long)];
 static const char tagcache_thread_name[] = "tagcache";
 #endif
@@ -152,7 +152,7 @@ struct tagcache_command_entry {
 static struct tagcache_command_entry command_queue[TAGCACHE_COMMAND_QUEUE_LENGTH];
 static volatile int command_queue_widx = 0;
 static volatile int command_queue_ridx = 0;
-static struct mutex command_queue_mutex;
+static struct mutex command_queue_mutex NOCACHEBSS_ATTR;
 /* Timestamp of the last added event, so we can wait a bit before committing the
  * whole queue at once. */
 static long command_queue_timestamp = 0;
@@ -3377,7 +3377,7 @@ static bool delete_entry(long idx_id)
  */
 static bool check_event_queue(void)
 {
-    struct event ev;
+    struct queue_event ev;
     
     queue_wait_w_tmo(&tagcache_queue, &ev, 0);
     switch (ev.id)
@@ -3972,7 +3972,7 @@ void tagcache_unload_ramcache(void)
 #ifndef __PCTOOL__
 static void tagcache_thread(void)
 {
-    struct event ev;
+    struct queue_event ev;
     bool check_done = false;
 
     /* If the previous cache build/update was interrupted, commit
@@ -4176,9 +4176,9 @@ void tagcache_init(void)
     mutex_init(&command_queue_mutex);
     queue_init(&tagcache_queue, true);
     create_thread(tagcache_thread, tagcache_stack,
-                  sizeof(tagcache_stack), tagcache_thread_name 
+                  sizeof(tagcache_stack), 0, tagcache_thread_name 
                   IF_PRIO(, PRIORITY_BACKGROUND)
-                  IF_COP(, CPU, false));
+                          IF_COP(, CPU));
 #else
     tc_stat.initialized = true;
     allocate_tempbuf();