25 files changed, 180 insertions, 148 deletions

diff --git a/firmware/target/arm/as3525/ascodec-as3525.c b/firmware/target/arm/as3525/ascodec-as3525.c
index 822d48e241..39658c0637 100644
--- a/firmware/target/arm/as3525/ascodec-as3525.c
+++ b/firmware/target/arm/as3525/ascodec-as3525.c
@@ -107,7 +107,7 @@ struct ascodec_request {
     unsigned char status;
     unsigned char cnt;
     unsigned char data[ASCODEC_REQ_MAXLEN];
-    struct wakeup wkup;
+    struct semaphore complete;
     ascodec_cb_fn *callback;
     struct ascodec_request *next;
 };
@@ -121,7 +121,7 @@ static unsigned char *req_data_ptr = NULL;
 static struct ascodec_request *req_head = NULL;
 static struct ascodec_request *req_tail = NULL;
 
-static struct wakeup adc_wkup;
+static struct semaphore adc_done_sem;
 static struct ascodec_request as_audio_req;
 
 #ifdef DEBUG
@@ -168,7 +168,7 @@ static void ascodec_finish_req(struct ascodec_request *req)
     if (req->callback) {
         req->callback(req->data, req_data_ptr - req->data);
     }
-    wakeup_signal(&req->wkup);
+    semaphore_release(&req->complete);
 
     req_head = req->next;
     req->next = NULL;
@@ -263,7 +263,7 @@ void ascodec_init(void)
     int prescaler;
 
     mutex_init(&as_mtx);
-    wakeup_init(&adc_wkup);
+    semaphore_init(&adc_done_sem, 1, 0);
 
     /* enable clock */
     bitset32(&CGU_PERI, CGU_I2C_AUDIO_MASTER_CLOCK_ENABLE);
@@ -312,7 +312,7 @@ void ascodec_init(void)
 static void ascodec_req_init(struct ascodec_request *req, int type,
                       unsigned int index, unsigned int cnt)
 {
-    wakeup_init(&req->wkup);
+    semaphore_init(&req->complete, 1, 0);
     req->next = NULL;
     req->callback = NULL;
     req->type = type;
@@ -337,19 +337,10 @@ static void ascodec_submit(struct ascodec_request *req)
     restore_irq(oldlevel);
 }
 
-static int irq_disabled(void)
-{
-    unsigned long cpsr;
-
-    asm volatile ("mrs %0, cpsr" : "=r"(cpsr));
-
-    return (cpsr & IRQ_STATUS) == IRQ_DISABLED;
-}
-
 static void ascodec_wait(struct ascodec_request *req)
 {
-    if (!irq_disabled()) {
-        wakeup_wait(&req->wkup, TIMEOUT_BLOCK);
+    if (irq_enabled()) {
+        semaphore_wait(&req->complete, TIMEOUT_BLOCK);
         return;
     }
 
@@ -477,7 +468,7 @@ static void ascodec_read_cb(unsigned const char *data, unsigned int len)
     }
     if (data[2] & IRQ_ADC) { /* adc finished */
         IFDEBUG(int_adc++);
-        wakeup_signal(&adc_wkup);
+        semaphore_release(&adc_done_sem);
     }
     VIC_INT_ENABLE = INTERRUPT_AUDIO;
 }
@@ -492,7 +483,7 @@ void INT_AUDIO(void)
 
 void ascodec_wait_adc_finished(void)
 {
-    wakeup_wait(&adc_wkup, TIMEOUT_BLOCK);
+    semaphore_wait(&adc_done_sem, TIMEOUT_BLOCK);
 }
 
 #ifdef CONFIG_CHARGING
diff --git a/firmware/target/arm/as3525/ascodec-target.h b/firmware/target/arm/as3525/ascodec-target.h
index 7c47bd7e9c..85c3d1c103 100644
--- a/firmware/target/arm/as3525/ascodec-target.h
+++ b/firmware/target/arm/as3525/ascodec-target.h
@@ -28,7 +28,7 @@
 #ifndef SIMULATOR
 
 #include "as3514.h"
-#include "kernel.h"       /* for struct wakeup */
+#include "kernel.h"       /* for struct semaphore */
 #include "clock-target.h" /* for AS3525_I2C_PRESCALER */
 #include "system-arm.h"
 
diff --git a/firmware/target/arm/as3525/sd-as3525.c b/firmware/target/arm/as3525/sd-as3525.c
index 5a6e0df39a..a2d20c36fa 100644
--- a/firmware/target/arm/as3525/sd-as3525.c
+++ b/firmware/target/arm/as3525/sd-as3525.c
@@ -136,7 +136,7 @@ static bool hs_card = false;
 #define EXT_SD_BITS (1<<2)
 #endif
 
-static struct wakeup transfer_completion_signal;
+static struct semaphore transfer_completion_signal;
 static volatile unsigned int transfer_error[NUM_VOLUMES];
 #define PL180_MAX_TRANSFER_ERRORS 10
 
@@ -191,7 +191,7 @@ void INT_NAND(void)
 
     transfer_error[INTERNAL_AS3525] = status & MCI_DATA_ERROR;
 
-    wakeup_signal(&transfer_completion_signal);
+    semaphore_release(&transfer_completion_signal);
     MCI_CLEAR(INTERNAL_AS3525) = status;
 }
 
@@ -202,7 +202,7 @@ void INT_MCI0(void)
 
     transfer_error[SD_SLOT_AS3525] = status & MCI_DATA_ERROR;
 
-    wakeup_signal(&transfer_completion_signal);
+    semaphore_release(&transfer_completion_signal);
     MCI_CLEAR(SD_SLOT_AS3525) = status;
 }
 #endif
@@ -568,7 +568,7 @@ int sd_init(void)
     bitset32(&CCU_IO, 1<<2);
 #endif
 
-    wakeup_init(&transfer_completion_signal);
+    semaphore_init(&transfer_completion_signal, 1, 0);
 
     init_pl180_controller(INTERNAL_AS3525);
     ret = sd_init_card(INTERNAL_AS3525);
@@ -678,7 +678,7 @@ static int sd_select_bank(signed char bank)
                                 (9<<4) /* 2^9 = 512 */ ;
 
         /* Wakeup signal from NAND/MCIO isr on MCI_DATA_ERROR | MCI_DATA_END */
-        wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+        semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 
         /*  Wait for FIFO to empty, card may still be in PRG state  */
         while(MCI_STATUS(INTERNAL_AS3525) & MCI_TX_ACTIVE );
@@ -837,7 +837,7 @@ static int sd_transfer_sectors(IF_MD2(int drive,) unsigned long start,
                                 (9<<4) /* 2^9 = 512 */ ;
 
         /* Wakeup signal from NAND/MCIO isr on MCI_DATA_ERROR | MCI_DATA_END */
-        wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+        semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 
         /*  Wait for FIFO to empty, card may still be in PRG state for writes */
         while(MCI_STATUS(drive) & MCI_TX_ACTIVE);
diff --git a/firmware/target/arm/as3525/sd-as3525v2.c b/firmware/target/arm/as3525/sd-as3525v2.c
index 70d7c8fda1..b863337cbc 100644
--- a/firmware/target/arm/as3525/sd-as3525v2.c
+++ b/firmware/target/arm/as3525/sd-as3525v2.c
@@ -342,8 +342,8 @@ static struct event_queue sd_queue;
 bool sd_enabled = false;
 #endif
 
-static struct wakeup transfer_completion_signal;
-static struct wakeup command_completion_signal;
+static struct semaphore transfer_completion_signal;
+static struct semaphore command_completion_signal;
 static volatile bool retry;
 static volatile int cmd_error;
 
@@ -365,12 +365,12 @@ void INT_NAND(void)
         retry = true;
 
     if( status & (MCI_INT_DTO|MCI_DATA_ERROR))
-        wakeup_signal(&transfer_completion_signal);
+        semaphore_release(&transfer_completion_signal);
 
     cmd_error = status & MCI_CMD_ERROR;
 
     if(status & MCI_INT_CD)
-        wakeup_signal(&command_completion_signal);
+        semaphore_release(&command_completion_signal);
 
     MCI_CTRL |= INT_ENABLE;
 }
@@ -442,7 +442,7 @@ static bool send_cmd(const int drive, const int cmd, const int arg, const int fl
             _buttonlight_off();
     }
 #endif
-    wakeup_wait(&command_completion_signal, TIMEOUT_BLOCK);
+    semaphore_wait(&command_completion_signal, TIMEOUT_BLOCK);
 
     /*  Handle command responses & errors */
     if(flags & MCI_RESP)
@@ -769,8 +769,8 @@ int sd_init(void)
                | (AS3525_SDSLOT_DIV << 2)
                | 1;             /* clock source = PLLA */
 
-    wakeup_init(&transfer_completion_signal);
-    wakeup_init(&command_completion_signal);
+    semaphore_init(&transfer_completion_signal, 1, 0);
+    semaphore_init(&command_completion_signal, 1, 0);
 
 #if defined(SANSA_FUZEV2) || defined(SANSA_CLIPPLUS)
     if (amsv2_variant == 1)
@@ -932,7 +932,7 @@ sd_transfer_retry_with_reinit:
             goto sd_transfer_error;
         }
 
-        wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+        semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 
         last_disk_activity = current_tick;
 
diff --git a/firmware/target/arm/as3525/usb-drv-as3525.c b/firmware/target/arm/as3525/usb-drv-as3525.c
index 2e5330ec1b..69c50cda93 100644
--- a/firmware/target/arm/as3525/usb-drv-as3525.c
+++ b/firmware/target/arm/as3525/usb-drv-as3525.c
@@ -40,6 +40,7 @@
 static struct usb_endpoint endpoints[USB_NUM_EPS][2];
 static int got_set_configuration = 0;
 static int usb_enum_timeout = -1;
+static bool initialized = false;
 
 /*
  * dma/setup descriptors and buffers should avoid sharing
@@ -180,19 +181,19 @@ static void reset_endpoints(int init)
             if (endpoints[i][0].state & EP_STATE_BUSY) {
                 if (endpoints[i][0].state & EP_STATE_ASYNC) {
                     endpoints[i][0].rc = -1;
-                    wakeup_signal(&endpoints[i][0].complete);
+                    semaphore_release(&endpoints[i][0].complete);
                 } else {
                     usb_core_transfer_complete(i, USB_DIR_IN, -1, 0);
                 }
             }
             endpoints[i][0].state = 0;
-            wakeup_init(&endpoints[i][0].complete);
+            semaphore_wait(&endpoints[i][0].complete, TIMEOUT_NOBLOCK);
 
             if (i != 2) { /* Skip the OUT EP0 alias */
                 if (endpoints[i][1].state & EP_STATE_BUSY)
                     usb_core_transfer_complete(i, USB_DIR_OUT, -1, 0);
                 endpoints[i][1].state = 0;
-                wakeup_init(&endpoints[i][1].complete);
+                semaphore_wait(&endpoints[i][1].complete, TIMEOUT_NOBLOCK);
                 USB_OEP_SUP_PTR(i)    = 0;
             }
         }
@@ -225,6 +226,18 @@ void usb_drv_init(void)
 {
     logf("usb_drv_init() !!!!\n");
 
+    if (!initialized)
+    {
+        int i;
+        for (i = 0; i < USB_NUM_EPS; i++)
+        {
+            semaphore_init(&endpoints[i][0].complete, 1, 0);
+            semaphore_init(&endpoints[i][1].complete, 1, 0);
+        }
+
+        initialized = true;
+    }
+
     usb_enable_pll();
 
     /* we have external power, so boost cpu */
@@ -322,6 +335,7 @@ void usb_drv_exit(void)
     ascodec_write(AS3515_USB_UTIL, ascodec_read(AS3515_USB_UTIL) & ~(1<<4));
     usb_disable_pll();
     cpu_boost(0);
+    initialized = false;
     logf("usb_drv_exit() !!!!\n");
 }
 
@@ -529,7 +543,7 @@ int usb_drv_send(int ep, void *ptr, int len)
     }
 
     ep_send(ep, ptr, len);
-    if (wakeup_wait(&endpoints[ep][0].complete, HZ) == OBJ_WAIT_TIMEDOUT)
+    if (semaphore_wait(&endpoints[ep][0].complete, HZ) == OBJ_WAIT_TIMEDOUT)
         logf("send timed out!\n");
 
     return endpoints[ep][0].rc;
@@ -570,7 +584,7 @@ static void handle_in_ep(int ep)
             endpoints[ep][0].state &= ~EP_STATE_ASYNC;
             usb_core_transfer_complete(ep, USB_DIR_IN, 0, endpoints[ep][0].len);
         } else {
-            wakeup_signal(&endpoints[ep][0].complete);
+            semaphore_release(&endpoints[ep][0].complete);
         }
         ep_sts &= ~USB_EP_STAT_TDC;
     }
diff --git a/firmware/target/arm/as3525/usb-drv-as3525.h b/firmware/target/arm/as3525/usb-drv-as3525.h
index 960b023039..0f8b3c0668 100644
--- a/firmware/target/arm/as3525/usb-drv-as3525.h
+++ b/firmware/target/arm/as3525/usb-drv-as3525.h
@@ -310,7 +310,7 @@ struct usb_endpoint
     unsigned int len;
     volatile unsigned int state;
     int rc;
-    struct wakeup complete;
+    struct semaphore complete;
     struct usb_dev_dma_desc *uc_desc;
 };
 
diff --git a/firmware/target/arm/as3525/usb-drv-as3525v2.c b/firmware/target/arm/as3525/usb-drv-as3525v2.c
index 78dc2a603f..24548f30c5 100644
--- a/firmware/target/arm/as3525/usb-drv-as3525v2.c
+++ b/firmware/target/arm/as3525/usb-drv-as3525v2.c
@@ -61,7 +61,7 @@ static const uint8_t out_ep_list[NUM_OUT_EP + 1] = {0, OUT_EP_LIST};
 struct usb_endpoint
 {
     unsigned int len; /* length of the data buffer */
-    struct wakeup complete; /* wait object */
+    struct semaphore complete; /* wait object */
     int8_t status; /* completion status (0 for success) */
     bool active; /* true is endpoint has been requested (true for EP0) */
     bool wait; /* true if usb thread is blocked on completion */
@@ -281,7 +281,7 @@ static void reset_endpoints(void)
         if(endpoints[ep][DIR_IN].wait)
         {
             endpoints[ep][DIR_IN].wait = false;
-            wakeup_signal(&endpoints[ep][DIR_IN].complete);
+            semaphore_release(&endpoints[ep][DIR_IN].complete);
         }
         if(DIEPCTL(ep) & DEPCTL_epena)
             DIEPCTL(ep) = DEPCTL_snak;
@@ -297,7 +297,7 @@ static void reset_endpoints(void)
         if(endpoints[ep][DIR_OUT].wait)
         {
             endpoints[ep][DIR_OUT].wait = false;
-            wakeup_signal(&endpoints[ep][DIR_OUT].complete);
+            semaphore_release(&endpoints[ep][DIR_OUT].complete);
         }
         if(DOEPCTL(ep) & DEPCTL_epena)
             DOEPCTL(ep) =  DEPCTL_snak;
@@ -329,7 +329,7 @@ static void cancel_all_transfers(bool cancel_ep0)
         if(endpoints[ep][DIR_IN].wait)
         {
             endpoints[ep][DIR_IN].wait = false;
-            wakeup_signal(&endpoints[ep][DIR_IN].complete);
+            semaphore_release(&endpoints[ep][DIR_IN].complete);
         }
         DIEPCTL(ep) = (DIEPCTL(ep) & ~DEPCTL_usbactep) | DEPCTL_snak;
     }
@@ -340,7 +340,7 @@ static void cancel_all_transfers(bool cancel_ep0)
         if(endpoints[ep][DIR_OUT].wait)
         {
             endpoints[ep][DIR_OUT].wait = false;
-            wakeup_signal(&endpoints[ep][DIR_OUT].complete);
+            semaphore_release(&endpoints[ep][DIR_OUT].complete);
         }
         DOEPCTL(ep) = (DOEPCTL(ep) & ~DEPCTL_usbactep) | DEPCTL_snak;
     }
@@ -457,9 +457,9 @@ void usb_drv_init(void)
     /* Core init */
     core_init();
     FOR_EACH_IN_EP_AND_EP0(i, ep)
-        wakeup_init(&endpoints[ep][DIR_IN].complete);
+        semaphore_init(&endpoints[ep][DIR_IN].complete, 1, 0);
     FOR_EACH_OUT_EP_AND_EP0(i, ep)
-        wakeup_init(&endpoints[ep][DIR_OUT].complete);
+        semaphore_init(&endpoints[ep][DIR_OUT].complete, 1, 0);
     /* Enable global interrupts */
     enable_global_interrupts();
 }
@@ -498,7 +498,7 @@ static void handle_ep_in_int(int ep)
             if(endpoint->wait)
             {
                 endpoint->wait = false;
-                wakeup_signal(&endpoint->complete);
+                semaphore_release(&endpoint->complete);
             }
         }
     }
@@ -515,7 +515,7 @@ static void handle_ep_in_int(int ep)
             if(endpoint->wait)
             {
                 endpoint->wait = false;
-                wakeup_signal(&endpoint->complete);
+                semaphore_release(&endpoint->complete);
             }
         }
     }
@@ -549,7 +549,7 @@ static void handle_ep_out_int(int ep)
             if(endpoint->wait)
             {
                 endpoint->wait = false;
-                wakeup_signal(&endpoint->complete);
+                semaphore_release(&endpoint->complete);
             }
         }
     }
@@ -798,7 +798,7 @@ static int usb_drv_transfer(int ep, void *ptr, int len, bool dir_in, bool blocki
 
     if(blocking)
     {
-        wakeup_wait(&endpoint->complete, TIMEOUT_BLOCK);
+        semaphore_wait(&endpoint->complete, TIMEOUT_BLOCK);
         return endpoint->status;
     }
 
diff --git a/firmware/target/arm/imx31/ata-imx31.c b/firmware/target/arm/imx31/ata-imx31.c
index d539282e70..8a40c924ff 100644
--- a/firmware/target/arm/imx31/ata-imx31.c
+++ b/firmware/target/arm/imx31/ata-imx31.c
@@ -246,7 +246,7 @@ static const struct ata_udma_timings
 
 /** Threading **/
 /* Signal to tell thread when DMA is done */
-static struct wakeup ata_dma_wakeup;
+static struct semaphore ata_dma_complete;
 
 /** SDMA **/
 /* Array of buffer descriptors for large transfers and alignnment */
@@ -445,7 +445,7 @@ static void ata_dma_callback(void)
     ATA_INTERRUPT_CLEAR = ATA_INTERRUPT_PENDING;
 
     ata_set_intrq(false);           /* Return INTRQ to MCU */
-    wakeup_signal(&ata_dma_wakeup); /* Signal waiting thread */
+    semaphore_release(&ata_dma_complete); /* Signal waiting thread */
 }
 
 bool ata_dma_setup(void *addr, unsigned long bytes, bool write)
@@ -580,7 +580,8 @@ bool ata_dma_finish(void)
     {
         int oldirq;
 
-        if (LIKELY(wakeup_wait(&ata_dma_wakeup, HZ/2) == OBJ_WAIT_SUCCEEDED))
+        if (LIKELY(semaphore_wait(&ata_dma_complete, HZ/2)
+               == OBJ_WAIT_SUCCEEDED))
             break;
 
         ata_keep_active();
@@ -594,7 +595,8 @@ bool ata_dma_finish(void)
         sdma_channel_stop(channel); /* Stop DMA */
         restore_irq(oldirq);
 
-        if (wakeup_wait(&ata_dma_wakeup, TIMEOUT_NOBLOCK) == OBJ_WAIT_SUCCEEDED)
+        if (semaphore_wait(&ata_dma_complete, TIMEOUT_NOBLOCK)
+                == OBJ_WAIT_SUCCEEDED)
             break; /* DMA really did finish after timeout */
 
         sdma_channel_reset(channel); /* Reset everything + clear error */
@@ -716,7 +718,7 @@ void ata_device_init(void)
     ata_dma_selected = ATA_DMA_PIO;
 
     /* Called for first time at startup */
-    wakeup_init(&ata_dma_wakeup);
+    semaphore_init(&ata_dma_complete, 1, 0);
 
     if (!sdma_channel_init(ATA_DMA_CH_NUM_RD, &ata_cd_rd, ata_bda) ||
         !sdma_channel_init(ATA_DMA_CH_NUM_WR, &ata_cd_wr, ata_bda))
diff --git a/firmware/target/arm/imx31/gigabeat-s/adc-gigabeat-s.c b/firmware/target/arm/imx31/gigabeat-s/adc-gigabeat-s.c
index f7bc0ed37c..eb30919077 100644
--- a/firmware/target/arm/imx31/gigabeat-s/adc-gigabeat-s.c
+++ b/firmware/target/arm/imx31/gigabeat-s/adc-gigabeat-s.c
@@ -35,7 +35,7 @@ static const unsigned char reg_array[4] =
 };
 
 static uint32_t channels[2][4];
-static struct wakeup adc_wake;
+static struct semaphore adc_done_signal;
 static struct mutex adc_mtx;
 static long last_adc_read[2]; /* One for each input group */
 
@@ -67,7 +67,7 @@ unsigned short adc_read(int channel)
         mc13783_write(MC13783_ADC1, adc1);
 
         /* Wait for done signal */
-        wakeup_wait(&adc_wake, TIMEOUT_BLOCK);
+        semaphore_wait(&adc_done_signal, TIMEOUT_BLOCK);
 
         /* Read all 8 channels that are converted - two channels in each
          * word. */
@@ -113,12 +113,12 @@ bool adc_enable_channel(int channel, bool enable)
 /* Called by mc13783 interrupt thread when conversion is complete */
 void adc_done(void)
 {
-    wakeup_signal(&adc_wake);
+    semaphore_release(&adc_done_signal);
 }
 
 void adc_init(void) 
 {
-    wakeup_init(&adc_wake);
+    semaphore_init(&adc_done_signal, 1, 0);
     mutex_init(&adc_mtx);
 
     /* Init so first reads get data */
diff --git a/firmware/target/arm/imx31/gigabeat-s/headphone-gigabeat-s.c b/firmware/target/arm/imx31/gigabeat-s/headphone-gigabeat-s.c
index 0f8cb67a9d..6e76615308 100644
--- a/firmware/target/arm/imx31/gigabeat-s/headphone-gigabeat-s.c
+++ b/firmware/target/arm/imx31/gigabeat-s/headphone-gigabeat-s.c
@@ -29,7 +29,7 @@
 #include "adc.h"
 #include "button.h"
 
-static struct wakeup headphone_wakeup;
+static struct semaphore headphone_wakeup;
 static unsigned int headphone_thread_id;
 static int headphone_stack[200/sizeof(int)]; /* Not much stack needed */
 static const char * const headphone_thread_name = "headphone";
@@ -115,7 +115,7 @@ static void headphone_thread(void)
 
     while (1)
     {
-        int rc = wakeup_wait(&headphone_wakeup, headphone_wait_timeout);
+        int rc = semaphore_wait(&headphone_wakeup, headphone_wait_timeout);
         unsigned int data = adc_read(ADC_HPREMOTE);
 
         if (rc == OBJ_WAIT_TIMEDOUT)
@@ -175,7 +175,7 @@ static void headphone_thread(void)
 void headphone_detect_event(void)
 {
     /* Trigger the thread immediately. */
-    wakeup_signal(&headphone_wakeup);
+    semaphore_release(&headphone_wakeup);
 }
 
 /* Tell if anything is in the jack. */
@@ -187,7 +187,7 @@ bool headphones_inserted(void)
 void INIT_ATTR headphone_init(void)
 {
     /* A thread is required to monitor the remote ADC and jack state. */
-    wakeup_init(&headphone_wakeup);
+    semaphore_init(&headphone_wakeup, 1, 0);
     headphone_thread_id = create_thread(headphone_thread, 
                                         headphone_stack,
                                         sizeof(headphone_stack),
diff --git a/firmware/target/arm/imx31/i2c-imx31.c b/firmware/target/arm/imx31/i2c-imx31.c
index 4e810c588f..975f951fdc 100644
--- a/firmware/target/arm/imx31/i2c-imx31.c
+++ b/firmware/target/arm/imx31/i2c-imx31.c
@@ -48,7 +48,7 @@ static struct i2c_module_descriptor
     volatile unsigned short * const base; /* Module base address */
     void (* const handler)(void);         /* Module interrupt handler */
     struct mutex m;                       /* Node mutual-exclusion */
-    struct wakeup w;                      /* I2C done signal */
+    struct semaphore complete;            /* I2C completion signal */
     unsigned char *addr_data;             /* Additional addressing data */
     int addr_count;                       /* Addressing byte count */
     unsigned char *data;                  /* TX/RX buffer (actual data) */
@@ -164,7 +164,7 @@ i2c_stop:
     base[I2CR] &= ~(I2C_I2CR_MSTA | I2C_I2CR_IIEN);
 i2c_done:
     /* Signal thread we're done */
-    wakeup_signal(&desc->w);
+    semaphore_release(&desc->complete);
 }
 
 #if (I2C_MODULE_MASK & USE_I2C1_MODULE)
@@ -221,7 +221,7 @@ static int i2c_transfer(struct i2c_node * const node,
     base[I2DR] = desc->addr;
 
     /* Wait for transfer to complete */
-    if (wakeup_wait(&desc->w, HZ) == OBJ_WAIT_SUCCEEDED)
+    if (semaphore_wait(&desc->complete, HZ) == OBJ_WAIT_SUCCEEDED)
     {
         count -= desc->data_count;
     }
@@ -294,7 +294,7 @@ void i2c_init(void)
         struct i2c_module_descriptor *const desc = &i2c_descs[i];
         ccm_module_clock_gating(desc->cg, CGM_ON_RUN_WAIT);
         mutex_init(&desc->m);
-        wakeup_init(&desc->w);
+        semaphore_init(&desc->complete, 1, 0);
         desc->base[I2CR] = 0;
         ccm_module_clock_gating(desc->cg, CGM_OFF);
     }
diff --git a/firmware/target/arm/imx31/mc13783-imx31.c b/firmware/target/arm/imx31/mc13783-imx31.c
index d5d22e2c75..006b065ea5 100644
--- a/firmware/target/arm/imx31/mc13783-imx31.c
+++ b/firmware/target/arm/imx31/mc13783-imx31.c
@@ -32,11 +32,11 @@ extern struct spi_node mc13783_spi;
 /* PMIC event service data */
 static int mc13783_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)];
 static const char *mc13783_thread_name = "pmic";
-static struct wakeup mc13783_svc_wake;
+static struct semaphore mc13783_svc_wake;
 
 /* Synchronous thread communication objects */
 static struct mutex mc13783_spi_mutex;
-static struct wakeup mc13783_spi_wake;
+static struct semaphore mc13783_spi_complete;
 
 /* Tracking for which interrupts are enabled */
 static uint32_t pmic_int_enabled[2] =
@@ -69,13 +69,13 @@ static void mc13783_xfer_complete_cb(struct spi_transfer_desc *xfer)
     if (xfer->count != 0)
         return;
 
-    wakeup_signal(&mc13783_spi_wake);
+    semaphore_release(&mc13783_spi_complete);
 }
 
 static inline bool wait_for_transfer_complete(void)
 {
-    return wakeup_wait(&mc13783_spi_wake, HZ*2) == OBJ_WAIT_SUCCEEDED &&
-           mc13783_transfer.count == 0;
+    return semaphore_wait(&mc13783_spi_complete, HZ*2)
+            == OBJ_WAIT_SUCCEEDED && mc13783_transfer.count == 0;
 }
 
 static void mc13783_interrupt_thread(void)
@@ -89,7 +89,7 @@ static void mc13783_interrupt_thread(void)
     {
         const struct mc13783_event *event, *event_last;
 
-        wakeup_wait(&mc13783_svc_wake, TIMEOUT_BLOCK);
+        semaphore_wait(&mc13783_svc_wake, TIMEOUT_BLOCK);
 
         if (mc13783_thread_id == 0)
             break;
@@ -140,16 +140,16 @@ void mc13783_event(void)
     /* Mask the interrupt (unmasked when PMIC thread services it). */
     bitclr32(&MC13783_GPIO_IMR, 1ul << MC13783_GPIO_LINE);
     MC13783_GPIO_ISR = (1ul << MC13783_GPIO_LINE);
-    wakeup_signal(&mc13783_svc_wake);
+    semaphore_release(&mc13783_svc_wake);
 }
 
 void INIT_ATTR mc13783_init(void)
 {
     /* Serial interface must have been initialized first! */
-    wakeup_init(&mc13783_svc_wake);
+    semaphore_init(&mc13783_svc_wake, 1, 0);
     mutex_init(&mc13783_spi_mutex);
 
-    wakeup_init(&mc13783_spi_wake);
+    semaphore_init(&mc13783_spi_complete, 1, 0);
 
     /* Enable the PMIC SPI module */
     spi_enable_module(&mc13783_spi);
@@ -175,7 +175,7 @@ void mc13783_close(void)
         return;
 
     mc13783_thread_id = 0;
-    wakeup_signal(&mc13783_svc_wake);
+    semaphore_release(&mc13783_svc_wake);
     thread_wait(thread_id);
     spi_disable_module(&mc13783_spi);
 }
diff --git a/firmware/target/arm/ipod/button-clickwheel.c b/firmware/target/arm/ipod/button-clickwheel.c
index dd561b2e50..d5edd2bebc 100644
--- a/firmware/target/arm/ipod/button-clickwheel.c
+++ b/firmware/target/arm/ipod/button-clickwheel.c
@@ -84,7 +84,7 @@ int int_btn = BUTTON_NONE;
 #endif
 
 #if CONFIG_CPU==S5L8701 || CONFIG_CPU==S5L8702
-static struct wakeup button_init_wakeup;
+static struct semaphore button_init_wakeup;
 #endif
 
 #if CONFIG_CPU==S5L8702
@@ -273,7 +273,7 @@ static inline int ipod_4g_button_read(void)
                 btn |= BUTTON_PLAY;
             if (status & 0x00100000)
                 btn |= BUTTON_MENU;
-            wakeup_signal(&button_init_wakeup);
+            semaphore_release(&button_init_wakeup);
         }
 #endif
 
@@ -373,7 +373,7 @@ void s5l_clickwheel_init(void)
 
 void button_init_device(void)
 {
-    wakeup_init(&button_init_wakeup);
+    semaphore_init(&button_init_wakeup, 1, 0);
 #if CONFIG_CPU==S5L8701
     INTMSK |= (1<<26);
 #elif CONFIG_CPU==S5L8702
@@ -381,7 +381,7 @@ void button_init_device(void)
     holdswitch_last_value = (pmu_read(0x87) & 2) == 0;
 #endif
     s5l_clickwheel_init();
-    wakeup_wait(&button_init_wakeup, HZ / 10);
+    semaphore_wait(&button_init_wakeup, HZ / 10);
 }
 
 bool button_hold(void)
diff --git a/firmware/target/arm/ipod/video/lcd-video.c b/firmware/target/arm/ipod/video/lcd-video.c
index 944f2c4236..c499e9f745 100644
--- a/firmware/target/arm/ipod/video/lcd-video.c
+++ b/firmware/target/arm/ipod/video/lcd-video.c
@@ -107,7 +107,7 @@ struct
 #ifdef HAVE_LCD_SLEEP
     bool display_on;
     bool waking;
-    struct wakeup initwakeup;
+    struct semaphore initwakeup;
 #endif
 } lcd_state IBSS_ATTR;
 
@@ -188,7 +188,7 @@ static inline unsigned bcm_read32(unsigned address)
 static void continue_lcd_awake(void)
 {
     lcd_state.waking = false;
-    wakeup_signal(&(lcd_state.initwakeup));
+    semaphore_release(&(lcd_state.initwakeup));
 }
 #endif
 
@@ -357,7 +357,7 @@ void lcd_init_device(void)
         /* lcd_write_data needs an even number of 16 bit values */
         flash_vmcs_length = ((flash_vmcs_length + 3) >> 1) & ~1;
     }
-    wakeup_init(&(lcd_state.initwakeup));
+    semaphore_init(&(lcd_state.initwakeup), 1, 0);
     lcd_state.waking = false;
 
     if (GPO32_VAL & 0x4000)
@@ -620,7 +620,7 @@ void lcd_awake(void)
          */
         lcd_state.waking = true;
         tick_add_task(&lcd_tick);
-        wakeup_wait(&(lcd_state.initwakeup), TIMEOUT_BLOCK);
+        semaphore_wait(&(lcd_state.initwakeup), TIMEOUT_BLOCK);
 
         send_event(LCD_EVENT_ACTIVATION, NULL);
     }
diff --git a/firmware/target/arm/olympus/mrobe-100/lcd-remote-mr100.c b/firmware/target/arm/olympus/mrobe-100/lcd-remote-mr100.c
index 036b6ae71c..d1e1c82c95 100644
--- a/firmware/target/arm/olympus/mrobe-100/lcd-remote-mr100.c
+++ b/firmware/target/arm/olympus/mrobe-100/lcd-remote-mr100.c
@@ -67,7 +67,7 @@ unsigned char rc_buf[5];
 /* Remote thread functions                            */
 /*   These functions are private to the remote thread */
 /* ================================================== */
-static struct wakeup rc_thread_wakeup;
+static struct semaphore rc_thread_wakeup;
 static unsigned int remote_thread_id;
 static int remote_stack[256/sizeof(int)];
 static const char * const remote_thread_name = "remote";
@@ -368,7 +368,7 @@ static void remote_thread(void)
 
     while (1)
     {
-        wakeup_wait(&rc_thread_wakeup, rc_thread_wait_timeout);
+        semaphore_wait(&rc_thread_wakeup, rc_thread_wait_timeout);
 
         /* Error handling (most likely due to remote not present) */
         if (rc_status & RC_ERROR_MASK)
@@ -500,7 +500,7 @@ void lcd_remote_off(void)
 {
     /* should only be used to power off at shutdown */
     rc_status |= RC_POWER_OFF;
-    wakeup_signal(&rc_thread_wakeup);
+    semaphore_release(&rc_thread_wakeup);
 
     /* wait until the things are powered off */
     while (rc_status & RC_DEV_INIT)
@@ -515,7 +515,7 @@ void lcd_remote_on(void)
     {
         rc_status &= ~RC_FORCE_DETECT;
         rc_status &= ~RC_POWER_OFF;
-        wakeup_signal(&rc_thread_wakeup);
+        semaphore_release(&rc_thread_wakeup);
     }
 }
 
@@ -536,7 +536,7 @@ void lcd_remote_init_device(void)
     GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80);
 
     /* a thread is required to poll & update the remote */
-    wakeup_init(&rc_thread_wakeup);
+    semaphore_init(&rc_thread_wakeup, 1, 0);
     remote_thread_id = create_thread(remote_thread, remote_stack,
                             sizeof(remote_stack), 0, remote_thread_name
                             IF_PRIO(, PRIORITY_SYSTEM)
diff --git a/firmware/target/arm/s3c2440/i2c-s3c2440.c b/firmware/target/arm/s3c2440/i2c-s3c2440.c
index 155eb2f956..33c4e3180a 100644
--- a/firmware/target/arm/s3c2440/i2c-s3c2440.c
+++ b/firmware/target/arm/s3c2440/i2c-s3c2440.c
@@ -21,7 +21,7 @@
 #include "system.h"
 #include "i2c-s3c2440.h"
 
-static struct wakeup i2c_wake; /* Transfer completion signal */
+static struct semaphore i2c_complete; /* Transfer completion signal */
 static struct mutex i2c_mtx;   /* Mutual exclusion */
 static unsigned char *buf_ptr; /* Next byte to transfer */
 static int buf_count;          /* Number of bytes remaining to transfer */
@@ -64,7 +64,7 @@ void i2c_write(int addr, const unsigned char *buf, int count)
     /* Generate START */
     IICSTAT = I2C_MODE_MASTER | I2C_MODE_TX | I2C_START | I2C_RXTX_ENB;
 
-    if (wakeup_wait(&i2c_wake, HZ) != OBJ_WAIT_SUCCEEDED)
+    if (semaphore_wait(&i2c_complete, HZ) != OBJ_WAIT_SUCCEEDED)
     {
         /* Something went wrong - stop transmission */
         int oldlevel = disable_irq_save();
@@ -84,7 +84,7 @@ void i2c_write(int addr, const unsigned char *buf, int count)
 void i2c_init(void)
 {
     /* Init kernel objects */
-    wakeup_init(&i2c_wake);
+    semaphore_init(&i2c_complete, 1, 0);
     mutex_init(&i2c_mtx);
 
     /* Clear pending source */
@@ -134,7 +134,7 @@ void IIC(void)
         i2c_stop();
 
         /* Signal thread */
-        wakeup_signal(&i2c_wake);
+        semaphore_release(&i2c_complete);
         break;
     }
 
diff --git a/firmware/target/arm/s3c2440/sd-s3c2440.c b/firmware/target/arm/s3c2440/sd-s3c2440.c
index 4a15835b67..0dcd900d11 100644
--- a/firmware/target/arm/s3c2440/sd-s3c2440.c
+++ b/firmware/target/arm/s3c2440/sd-s3c2440.c
@@ -119,7 +119,7 @@ static long             sd_stack [(DEFAULT_STACK_SIZE*2 + 0x1c0)/sizeof(long)];
 static const char               sd_thread_name[] = "sd";
 static struct mutex             sd_mtx SHAREDBSS_ATTR;
 static struct event_queue       sd_queue;
-static struct wakeup            transfer_completion_signal;
+static struct semaphore         transfer_completion_signal;
 static volatile unsigned int    transfer_error[NUM_VOLUMES];
 /* align on cache line size */
 static unsigned char    aligned_buffer[UNALIGNED_NUM_SECTORS * SD_BLOCK_SIZE] 
@@ -223,7 +223,7 @@ void SDI (void)
 
     dbgprintf ("SDI %x\n", transfer_error[curr_card]);
     
-    wakeup_signal(&transfer_completion_signal);
+    semaphore_release(&transfer_completion_signal);
 
     /* Ack the interrupt */
     SRCPND = SDI_MASK;
@@ -242,7 +242,7 @@ void dma_callback (void)
     SDIDSTA |= S3C2410_SDIDSTA_CLEAR_BITS;  /* needed to clear int  */
     
     dbgprintf ("dma_cb\n");
-    wakeup_signal(&transfer_completion_signal);
+    semaphore_release(&transfer_completion_signal);
 }
 #endif
 
@@ -783,7 +783,7 @@ static int sd_transfer_sectors(int card_no, unsigned long start,
                                 (9<<4) /* 2^9 = 512 */ ;
 #endif
 
-        wakeup_wait(&transfer_completion_signal, 100 /*TIMEOUT_BLOCK*/);
+        semaphore_wait(&transfer_completion_signal, 100 /*TIMEOUT_BLOCK*/);
         
         /* wait for DMA to finish */
         while (DSTAT0 & DSTAT_STAT_BUSY)
@@ -928,7 +928,7 @@ int sd_init(void)
     sd_enabled = true;
     sd_enable(false);
 #endif
-    wakeup_init(&transfer_completion_signal);
+    semaphore_init(&transfer_completion_signal, 1, 0);
     /* init mutex */
     mutex_init(&sd_mtx);
     queue_init(&sd_queue, true);
diff --git a/firmware/target/arm/s5l8700/adc-s5l8700.c b/firmware/target/arm/s5l8700/adc-s5l8700.c
index f979a9d54f..270c133e94 100644
--- a/firmware/target/arm/s5l8700/adc-s5l8700.c
+++ b/firmware/target/arm/s5l8700/adc-s5l8700.c
@@ -42,11 +42,11 @@
 
 
 static struct mutex adc_mtx;
-static struct wakeup adc_wakeup;
+static struct semaphore adc_wakeup;
 
 void INT_ADC(void)
 {
-    wakeup_signal(&adc_wakeup);
+    semaphore_release(&adc_wakeup);
 }
 
 unsigned short adc_read(int channel)
@@ -61,7 +61,7 @@ unsigned short adc_read(int channel)
              (1 << 0);          /* enable start */
     
     /* wait for conversion */
-    wakeup_wait(&adc_wakeup, TIMEOUT_BLOCK);
+    semaphore_wait(&adc_wakeup, TIMEOUT_BLOCK);
     
     /* get the converted data */
     data = ADCDAT0 & 0x3FF;
@@ -77,7 +77,7 @@ unsigned short adc_read(int channel)
 void adc_init(void)
 {
     mutex_init(&adc_mtx);
-    wakeup_init(&adc_wakeup);
+    semaphore_init(&adc_wakeup, 1, 0);
 
     /* enable clock to ADC */
     PWRCON &= ~(1 << 10);
diff --git a/firmware/target/arm/s5l8700/ipodnano2g/nand-nano2g.c b/firmware/target/arm/s5l8700/ipodnano2g/nand-nano2g.c
index 8a4541a226..9261e5b3a0 100644
--- a/firmware/target/arm/s5l8700/ipodnano2g/nand-nano2g.c
+++ b/firmware/target/arm/s5l8700/ipodnano2g/nand-nano2g.c
@@ -94,9 +94,9 @@ static long nand_last_activity_value = -1;
 static long nand_stack[DEFAULT_STACK_SIZE];
 
 static struct mutex nand_mtx;
-static struct wakeup nand_wakeup;
+static struct semaphore nand_complete;
 static struct mutex ecc_mtx;
-static struct wakeup ecc_wakeup;
+static struct semaphore ecc_complete;
 
 static uint8_t nand_data[0x800] STORAGE_ALIGN_ATTR;
 static uint8_t nand_ctrl[0x200] STORAGE_ALIGN_ATTR;
@@ -731,9 +731,9 @@ static void nand_thread(void)
 int nand_device_init(void)
 {
     mutex_init(&nand_mtx);
-    wakeup_init(&nand_wakeup);
+    semaphore_init(&nand_complete, 1, 0);
     mutex_init(&ecc_mtx);
-    wakeup_init(&ecc_wakeup);
+    semaphore_init(&ecc_complete, 1, 0);
 
     uint32_t type;
     uint32_t i, j;
diff --git a/firmware/target/arm/s5l8702/ipod6g/lcd-ipod6g.c b/firmware/target/arm/s5l8702/ipod6g/lcd-ipod6g.c
index de731a91b8..0ad9da22bb 100644
--- a/firmware/target/arm/s5l8702/ipod6g/lcd-ipod6g.c
+++ b/firmware/target/arm/s5l8702/ipod6g/lcd-ipod6g.c
@@ -50,7 +50,7 @@
 
 int lcd_type; /* also needed in debug-s5l8702.c */
 static struct dma_lli lcd_lli[(LCD_WIDTH * LCD_HEIGHT - 1) / 0xfff] CACHEALIGN_ATTR;
-static struct wakeup lcd_wakeup;
+static struct semaphore lcd_wakeup;
 static struct mutex lcd_mutex;
 static uint16_t lcd_dblbuf[LCD_HEIGHT][LCD_WIDTH];
 
@@ -149,7 +149,7 @@ void lcd_sleep(void)
 void lcd_init_device(void)
 {
     /* Detect lcd type */
-    wakeup_init(&lcd_wakeup);
+    semaphore_init(&lcd_wakeup, 1, 0);
     mutex_init(&lcd_mutex);
     lcd_type = (PDAT6 & 0x30) >> 4;
 }
@@ -180,7 +180,7 @@ static void displaylcd_setup(int x, int y, int width, int height) ICODE_ATTR;
 static void displaylcd_setup(int x, int y, int width, int height)
 {
     mutex_lock(&lcd_mutex);
-    while (DMAC0C4CONFIG & 1) wakeup_wait(&lcd_wakeup, HZ / 10);
+    while (DMAC0C4CONFIG & 1) semaphore_wait(&lcd_wakeup, HZ / 10);
 
     int xe = (x + width) - 1;           /* max horiz */
     int ye = (y + height) - 1;          /* max vert */
@@ -237,7 +237,7 @@ void INT_DMAC0C4(void) ICODE_ATTR;
 void INT_DMAC0C4(void)
 {
     DMAC0INTTCCLR = 0x10;
-    wakeup_signal(&lcd_wakeup);
+    semaphore_release(&lcd_wakeup);
 }
 
 /* Update a fraction of the display. */
diff --git a/firmware/target/arm/s5l8702/ipod6g/storage_ata-ipod6g.c b/firmware/target/arm/s5l8702/ipod6g/storage_ata-ipod6g.c
index 66e02d65bb..79a8964c3c 100644
--- a/firmware/target/arm/s5l8702/ipod6g/storage_ata-ipod6g.c
+++ b/firmware/target/arm/s5l8702/ipod6g/storage_ata-ipod6g.c
@@ -53,7 +53,7 @@ bool ata_lba48;
 bool ata_dma;
 uint64_t ata_total_sectors;
 struct mutex ata_mutex;
-static struct wakeup ata_wakeup;
+static struct semaphore ata_wakeup;
 static uint32_t ata_dma_flags;
 static long ata_last_activity_value = -1;
 static long ata_sleep_timeout = 20 * HZ;
@@ -61,8 +61,8 @@ static uint32_t ata_stack[(DEFAULT_STACK_SIZE + 0x400) / 4];
 static bool ata_powered;
 static const int ata_retries = ATA_RETRIES;
 static const bool ata_error_srst = true;
-static struct wakeup mmc_wakeup;
-static struct wakeup mmc_comp_wakeup;
+static struct semaphore mmc_wakeup;
+static struct semaphore mmc_comp_wakeup;
 static int spinup_time = 0;
 static int dma_mode = 0;
 
@@ -319,7 +319,7 @@ void mmc_discard_irq(void)
 {
     SDCI_IRQ = SDCI_IRQ_DAT_DONE_INT | SDCI_IRQ_MASK_MASK_IOCARD_IRQ_INT
              | SDCI_IRQ_MASK_MASK_READ_WAIT_INT;
-    wakeup_wait(&mmc_wakeup, 0);
+    semaphore_wait(&mmc_wakeup, 0);
 }
 
 int ceata_read_multiple_register(uint32_t addr, void* dest, uint32_t size)
@@ -338,7 +338,8 @@ int ceata_read_multiple_register(uint32_t addr, void* dest, uint32_t size)
                            | MMC_CMD_CEATA_RW_MULTIPLE_REG_ADDRESS(addr & 0xfc)
                            | MMC_CMD_CEATA_RW_MULTIPLE_REG_COUNT(size & 0xfc),
                              NULL, CEATA_COMMAND_TIMEOUT), 2, 1);
-    if (wakeup_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000) == OBJ_WAIT_TIMEDOUT) RET_ERR(2);
+    if (semaphore_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000)
+        == OBJ_WAIT_TIMEDOUT) RET_ERR(2);
     PASS_RC(mmc_dsta_check_data_success(), 2, 3);
     return 0;
 }
@@ -362,7 +363,8 @@ int ceata_write_multiple_register(uint32_t addr, void* dest, uint32_t size)
     SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX;
     for (i = 0; i < size / 4; i++) SDCI_DATA = ((uint32_t*)dest)[i];
     long startusec = USEC_TIMER;
-    if (wakeup_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000) == OBJ_WAIT_TIMEDOUT) RET_ERR(2);
+    if (semaphore_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000)
+        == OBJ_WAIT_TIMEDOUT) RET_ERR(2);
     while ((SDCI_STATE & SDCI_STATE_DAT_STATE_MASK) != SDCI_STATE_DAT_STATE_IDLE)
     {
         if (TIMEOUT_EXPIRED(startusec, CEATA_COMMAND_TIMEOUT)) RET_ERR(3);
@@ -479,13 +481,13 @@ int ceata_rw_multiple_block(bool write, void* buf, uint32_t count, long timeout)
                              direction | MMC_CMD_CEATA_RW_MULTIPLE_BLOCK_COUNT(count),
                              NULL, CEATA_COMMAND_TIMEOUT), 4, 0);
     if (write) SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX;
-    if (wakeup_wait(&mmc_wakeup, timeout) == OBJ_WAIT_TIMEDOUT)
+    if (semaphore_wait(&mmc_wakeup, timeout) == OBJ_WAIT_TIMEDOUT)
     {
         PASS_RC(ceata_cancel_command(), 4, 1);
         RET_ERR(2);
     }
     PASS_RC(mmc_dsta_check_data_success(), 4, 3);
-    if (wakeup_wait(&mmc_comp_wakeup, timeout) == OBJ_WAIT_TIMEDOUT)
+    if (semaphore_wait(&mmc_comp_wakeup, timeout) == OBJ_WAIT_TIMEDOUT)
     {
         PASS_RC(ceata_cancel_command(), 4, 4);
         RET_ERR(4);
@@ -750,11 +752,12 @@ int ata_rw_chunk_internal(uint64_t sector, uint32_t cnt, void* buffer, bool writ
             ATA_XFR_NUM = SECTOR_SIZE * cnt - 1;
             ATA_CFG |= ata_dma_flags;
             ATA_CFG &= ~(BIT(7) | BIT(8));
-            wakeup_wait(&ata_wakeup, 0);
+            semaphore_wait(&ata_wakeup, 0);
             ATA_IRQ = BITRANGE(0, 4);
             ATA_IRQ_MASK = BIT(0);
             ATA_COMMAND = BIT(0);
-            if (wakeup_wait(&ata_wakeup, 500000 * HZ / 1000000) == OBJ_WAIT_TIMEDOUT)
+            if (semaphore_wait(&ata_wakeup, 500000 * HZ / 1000000)
+                == OBJ_WAIT_TIMEDOUT)
             {
                 ATA_COMMAND = BIT(1);
                 ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12));
@@ -1068,9 +1071,9 @@ void ata_bbt_reload(void)
 int ata_init(void)
 {
     mutex_init(&ata_mutex);
-    wakeup_init(&ata_wakeup);
-    wakeup_init(&mmc_wakeup);
-    wakeup_init(&mmc_comp_wakeup);
+    semaphore_init(&ata_wakeup, 1, 0);
+    semaphore_init(&mmc_wakeup, 1, 0);
+    semaphore_init(&mmc_comp_wakeup, 1, 0);
     ceata = PDAT(11) & BIT(1);
     if (ceata)
     {
@@ -1129,14 +1132,14 @@ void INT_ATA(void)
 {
     uint32_t ata_irq = ATA_IRQ;
     ATA_IRQ = ata_irq;
-    if (ata_irq & ATA_IRQ_MASK) wakeup_signal(&ata_wakeup);
+    if (ata_irq & ATA_IRQ_MASK) semaphore_release(&ata_wakeup);
     ATA_IRQ_MASK = 0;
 }
 
 void INT_MMC(void)
 {
     uint32_t irq = SDCI_IRQ;
-    if (irq & SDCI_IRQ_DAT_DONE_INT) wakeup_signal(&mmc_wakeup);
-    if (irq & SDCI_IRQ_IOCARD_IRQ_INT) wakeup_signal(&mmc_comp_wakeup);
+    if (irq & SDCI_IRQ_DAT_DONE_INT) semaphore_release(&mmc_wakeup);
+    if (irq & SDCI_IRQ_IOCARD_IRQ_INT) semaphore_release(&mmc_comp_wakeup);
     SDCI_IRQ = irq;
 }
diff --git a/firmware/target/arm/system-arm.h b/firmware/target/arm/system-arm.h
index 7f10a30bdb..b3630a8473 100644
--- a/firmware/target/arm/system-arm.h
+++ b/firmware/target/arm/system-arm.h
@@ -62,6 +62,21 @@ void __div0(void);
 #define enable_fiq() \
     enable_interrupt(FIQ_STATUS)
 
+#define irq_enabled() \
+    interrupt_enabled(IRQ_STATUS)
+#define fiq_enabled() \
+    interrupt_enabled(FIQ_STATUS)
+#define ints_enabled() \
+    interrupt_enabled(IRQ_FIQ_STATUS)
+
+#define irq_enabled_checkval(val) \
+    (((val) & IRQ_STATUS) == 0)
+#define fiq_enabled_checkval(val) \
+    (((val) & FIQ_STATUS) == 0)
+#define ints_enabled_checkval(val) \
+    (((val) & IRQ_FIQ_STATUS) == 0)
+
+
 /* Core-level interrupt masking */
 
 static inline int set_interrupt_status(int status, int mask)
@@ -87,6 +102,13 @@ static inline void restore_interrupt(int cpsr)
     asm volatile ("msr cpsr_c, %0" : : "r"(cpsr));
 }
 
+static inline bool interrupt_enabled(int status)
+{
+    unsigned long cpsr;
+    asm ("mrs %0, cpsr" : "=r"(cpsr));
+    return (cpsr & status) == 0;
+}
+
 /* ARM_ARCH version section for architecture*/
 
 #if ARM_ARCH >= 6
diff --git a/firmware/target/arm/tms320dm320/creative-zvm/dma-creativezvm.c b/firmware/target/arm/tms320dm320/creative-zvm/dma-creativezvm.c
index d1408fee70..6a74ff5e57 100644
--- a/firmware/target/arm/tms320dm320/creative-zvm/dma-creativezvm.c
+++ b/firmware/target/arm/tms320dm320/creative-zvm/dma-creativezvm.c
@@ -37,14 +37,14 @@
 #define CF_START        0x40000000
 #define SSFDC_START     0x48000000
 
-static struct wakeup transfer_completion_signal;
+static struct semaphore transfer_completion_signal;
 
 static bool dma_in_progress = false;
 
 void MTC0(void)
 {
     IO_INTC_IRQ1 = INTR_IRQ1_MTC0;
-    wakeup_signal(&transfer_completion_signal);
+    semaphore_release(&transfer_completion_signal);
     dma_in_progress = false;
 }
 
@@ -59,7 +59,7 @@ void dma_start(const void* addr, size_t size)
 void dma_ata_read(unsigned char* buf, int shortcount)
 {
     if(dma_in_progress)
-        wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+        semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 
     while((unsigned long)buf & 0x1F)
     {
@@ -83,7 +83,7 @@ void dma_ata_read(unsigned char* buf, int shortcount)
     IO_EMIF_DMACTL = 3; /* Select MTC->AHB and start transfer */
 
     dma_in_progress = true;
-    wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+    semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 
     if(shortcount % 2)
     {
@@ -97,7 +97,7 @@ void dma_ata_read(unsigned char* buf, int shortcount)
 void dma_ata_write(unsigned char* buf, int wordcount)
 {
     if(dma_in_progress)
-        wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+        semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 
     while((unsigned long)buf & 0x1F)
     {
@@ -121,12 +121,12 @@ void dma_ata_write(unsigned char* buf, int wordcount)
     IO_EMIF_DMACTL = 1; /* Select AHB->MTC and start transfer */
 
     dma_in_progress = true;
-    wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
+    semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
 }
 
 void dma_init(void)
 {
     IO_INTC_EINT1 |= INTR_EINT1_MTC0;     /* enable MTC interrupt */
-    wakeup_init(&transfer_completion_signal);
+    semaphore_init(&transfer_completion_signal, 1, 0);
     dma_in_progress = false;
 }
diff --git a/firmware/target/arm/usb-drv-arc.c b/firmware/target/arm/usb-drv-arc.c
index fc74ce5bf0..f252f11f3e 100644
--- a/firmware/target/arm/usb-drv-arc.c
+++ b/firmware/target/arm/usb-drv-arc.c
@@ -349,7 +349,7 @@ struct queue_head {
 static struct queue_head qh_array[USB_NUM_ENDPOINTS*2]
     USB_QHARRAY_ATTR;
 
-static struct wakeup transfer_completion_signal[USB_NUM_ENDPOINTS*2]
+static struct semaphore transfer_completion_signal[USB_NUM_ENDPOINTS*2]
     SHAREDBSS_ATTR;
 
 static const unsigned int pipe2mask[] = {
@@ -424,7 +424,7 @@ void usb_drv_startup(void)
     /* Initialize all the signal objects once */
     int i;
     for(i=0;i<USB_NUM_ENDPOINTS*2;i++) {
-        wakeup_init(&transfer_completion_signal[i]);
+        semaphore_init(&transfer_completion_signal[i], 1, 0);
     }
 }
 
@@ -778,7 +778,7 @@ static int prime_transfer(int ep_num, void* ptr, int len, bool send, bool wait)
 
     if (wait) {
         /* wait for transfer to finish */
-        wakeup_wait(&transfer_completion_signal[pipe], TIMEOUT_BLOCK);
+        semaphore_wait(&transfer_completion_signal[pipe], TIMEOUT_BLOCK);
         if(qh->status!=0) {
             /* No need to cancel wait here since it was done and the signal
              * came. */
@@ -797,7 +797,7 @@ pt_error:
         qh->wait = 0;
         /* Make sure to remove any signal if interrupt fired before we zeroed
          * qh->wait. Could happen during a bus reset for example. */
-        wakeup_wait(&transfer_completion_signal[pipe], TIMEOUT_NOBLOCK);
+        semaphore_wait(&transfer_completion_signal[pipe], TIMEOUT_NOBLOCK);
     }
 
     return rc;
@@ -814,7 +814,7 @@ void usb_drv_cancel_all_transfers(void)
         if(qh_array[i].wait) {
             qh_array[i].wait=0;
             qh_array[i].status=DTD_STATUS_HALTED;
-            wakeup_signal(&transfer_completion_signal[i]);
+            semaphore_release(&transfer_completion_signal[i]);
         }
     }
 }
@@ -906,7 +906,7 @@ static void control_received(void)
         if(qh_array[i].wait) {
             qh_array[i].wait=0;
             qh_array[i].status=DTD_STATUS_HALTED;
-            wakeup_signal(&transfer_completion_signal[i]);
+            semaphore_release(&transfer_completion_signal[i]);
         }
     }
 
@@ -945,7 +945,7 @@ static void transfer_completed(void)
                 }
                 if(qh->wait) {
                     qh->wait=0;
-                    wakeup_signal(&transfer_completion_signal[pipe]);
+                    semaphore_release(&transfer_completion_signal[pipe]);
                 }
                 
                 usb_core_transfer_complete(ep, dir?USB_DIR_IN:USB_DIR_OUT,
diff --git a/firmware/target/arm/usb-s3c6400x.c b/firmware/target/arm/usb-s3c6400x.c
index eb7a0170bf..24e0fdc08a 100644
--- a/firmware/target/arm/usb-s3c6400x.c
+++ b/firmware/target/arm/usb-s3c6400x.c
@@ -44,7 +44,7 @@ struct ep_type
     bool done;
     int rc;
     int size;
-    struct wakeup complete;
+    struct semaphore complete;
 } ;
 
 static struct ep_type endpoints[USB_NUM_ENDPOINTS];
@@ -64,7 +64,7 @@ static void reset_endpoints(int reinit)
         endpoints[i].busy = false;
         endpoints[i].rc = -1;
         endpoints[i].done = true;
-        wakeup_signal(&endpoints[i].complete);
+        semaphore_release(&endpoints[i].complete);
     }
     DIEPCTL0 = 0x8800;  /* EP0 IN ACTIVE NEXT=1 */
     DOEPCTL0 = 0x8000;  /* EP0 OUT ACTIVE */
@@ -201,7 +201,7 @@ void INT_USB_FUNC(void)
                         endpoints[i].rc = 0;
                         endpoints[i].done = true;
                         usb_core_transfer_complete(i, USB_DIR_IN, 0, bytes);
-                        wakeup_signal(&endpoints[i].complete);
+                        semaphore_release(&endpoints[i].complete);
                     }
                 }
                 if (epints & 4)  /* AHB error */
@@ -213,7 +213,7 @@ void INT_USB_FUNC(void)
                         endpoints[i].busy = false;
                         endpoints[i].rc = 1;
                         endpoints[i].done = true;
-                        wakeup_signal(&endpoints[i].complete);
+                        semaphore_release(&endpoints[i].complete);
                     }
                 }
                 DIEPINT(i) = epints;
@@ -233,7 +233,7 @@ void INT_USB_FUNC(void)
                         endpoints[i].rc = 0;
                         endpoints[i].done = true;
                         usb_core_transfer_complete(i, USB_DIR_OUT, 0, bytes);
-                        wakeup_signal(&endpoints[i].complete);
+                        semaphore_release(&endpoints[i].complete);
                     }
                 }
                 if (epints & 4)  /* AHB error */
@@ -325,7 +325,7 @@ int usb_drv_send(int endpoint, void *ptr, int length)
     endpoints[endpoint].done = false;
     ep_send(endpoint, ptr, length);
     while (!endpoints[endpoint].done && endpoints[endpoint].busy)
-        wakeup_wait(&endpoints[endpoint].complete, TIMEOUT_BLOCK);
+        semaphore_wait(&endpoints[endpoint].complete, TIMEOUT_BLOCK);
     return endpoints[endpoint].rc;
 }
 
@@ -412,7 +412,7 @@ void usb_init_device(void)
 {
     unsigned int i;
     for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++)
-        wakeup_init(&endpoints[i].complete);
+        semaphore_init(&endpoints[i].complete, 1, 0);
 
     /* Power up the core clocks to allow writing
        to some registers needed to power it down */